C++博客-Brian Warehouse-随笔分类-OS

实验三代码文件管理

Brian — Tue, 17 Aug 2010 05:04:00 GMT

摘要: /*Title: 文件管理Author: BrianDate: 2010/06/17*/#include #include #include #include using namespace&nbs... 阅读全文

Brian 2010-08-17 13:04 发表评论

实验三文件管理(指导书)

Brian — Tue, 17 Aug 2010 05:03:00 GMT

一、实验内容

利用高级语言，设计一个采用二级或二级以上的多级文件目录管理系统，实现对文件的基本操作，如：文件的建立、打开、关闭、复制、撤销、检索等。

二、实验目的

用高级语言编写和调试一个简单的文件系统，模拟文件管理的工作过程。从而对各种文件操作命令的实质内容和执行过程有比较深入的了解。

要求设计一个 n个用户的文件系统，每次用户可保存m个文件，用户在一次运行中只能打开一个文件，对

文件必须设置保护措施，且至少有Create、delete、open、close、read、write等命令。

三、实验环境

1．PC微机。

2．Windows 操作系统。

3．C/C++/VB开发集成环境。

四、实验题目

设计一个10个用户的文件系统，每次用户可保存10个文件，一次运行用户可以打开5个文件。程序采用二级文件目录（即设置主目录[MFD]）和用户文件目录（UED）。另外，为打开文件设置了运行文件目录（AFD）。为了便于实现，对文件的读写作了简化，在执行读写命令时，只需改读写指针，并不进行实际的读写操作。

算法设计思想：

（1）因系统小，文件目录的检索使用了简单的线性搜索。

（2）文件保护简单使用了三位保护码：允许读写执行、对应位为 1，对应位为0，则表示不允许读写、执行。

（3）程序中使用的主要设计结构如下：

主文件目录和用户文件目录（ MFD、UFD），打开文件目录（ AFD）（即运行文件目录）

M D F	U F D	A F D
用户名	文件名	打开文件名
文件目录指针	保护码	打开保护码
用户名	文件长度	读写指针
文件目录指针	文件名
	· · ·

Brian 2010-08-17 13:03 发表评论

实验二代码首次适应法位示图法

Brian — Tue, 17 Aug 2010 05:02:00 GMT

摘要: /*Title: 首次适应算法Author: BrianDate: 2010/05/31*/#include #include // system()using namespace std;typedef struct SNo... 阅读全文

Brian 2010-08-17 13:02 发表评论

实验二内存储器空间的管理(指导书)

Brian — Tue, 17 Aug 2010 05:00:00 GMT

摘要: 一、实验内容利用高级语言，实现存储分配算法，开发一个存储管理的模拟程序,对内存空间的管理和分配。内存空间的管理可采用固定分区管理方式，可变分区管理方式,页式存储管理，段式存储管理等方案。二、实验目的一个好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器，而且要能合理地分配和使用这些存储空间。当用户提出申请存储器空间时，存储管理必须根据申请者的要求，按一定的策略分析主... 阅读全文

Brian 2010-08-17 13:00 发表评论

实验一代码时间片轮转法高响应比优先

Brian — Tue, 17 Aug 2010 04:59:00 GMT

/*
Title: 时间片轮转法
Author: Brian
Date: 2010/04/09
*/
#include <iostream>
#include <cstdlib>
using namespace std;

typedef struct PNode { // PCB
   struct PNode *next; //指向下一个节点的指针
   char name[12];    // 进程名
   int All_Time;    // 总运行时间
   int Runed_Time;    // 已运行时间
   char state;        // 进程状态 Ready / End
}* Proc; // 指向该PCB的指针

int ProcNum; // 全局变量，用于用户自己确定进程个数

void InitPCB(Proc &H) { //初始化就绪队列
    cout<<"输入总进程个数: ";
    cin>>ProcNum; //进程总个数
    int Num=ProcNum;
    H=(Proc)malloc(sizeof(PNode));
    H->next=NULL;
    Proc p=H;
    cout<<"总进程个数默认为 "<<ProcNum<<" 个,请输入相应信息\n\n";

    while (Num--) {
        p=p->next=(Proc)malloc(sizeof(PNode));
        cout<<"进程名总运行时间已运行时间 :";
        cin>>p->name>>p->All_Time>>p->Runed_Time;
        p->state='R';
        p->next=NULL;
    }
    p->next=H->next; // 构造循环队列
}

void DispInfo(Proc H) { //输出运行中信息
    Proc p=H->next;
    do {
        if (p->state != 'E')
        {
            cout<<"进程名:"<<p->name<<"\t总运行时间:"<<p->All_Time
                <<"\t已运行时间:"<<p->Runed_Time
                <<"\t状态:"<<p->state<<endl;
            p=p->next;
        }
        else p=p->next;
    } while (p != H->next); // 整个进程链条始终完整，只是状态位有差异
}

void SJP_Simulator(Proc &H) { // 时间片轮转法模拟器
    cout<<endl<<"-------------------START--------------------\n";
    int flag=ProcNum; // 记录剩余进程数
    int round=0; // 记录轮转数
    Proc p=H->next;
    while (p->All_Time > p->Runed_Time) {
            round++;
            cout<<endl<<"Round "<<round<<"--正在运行 "<<p->name<<" 进程"<<endl;
            p->Runed_Time++;
            DispInfo(H);
            if (p->All_Time == p->Runed_Time) {
                p->state='E';
                flag--;
                cout<<p->name<<" 进程已运行结束,进程被删除!\n";
            }
            p=p->next;
            while (flag && p->All_Time == p->Runed_Time)
                p=p->next; // 这一步非常重要，跳过先前已结束的进程

    }
    cout<<endl<<"--------------------END---------------------\n";
}

void main() {
    Proc H;
    InitPCB(H); // 数据初始化
    DispInfo(H); // 初始化成功后的进程状态
    SJP_Simulator(H); // 模拟时间片轮转法
    system("pause");
}

/*
Title: 高响应比优先算法
Author: Brian
Date: 2010/04/11
*/
#include <iostream>
#include <cstdlib>
#include <cstring>
using namespace std;

typedef struct PNode {  //PCB
    struct PNode *next; //指向下一个节点的指针
    char name[12];        //进程名
    int All_Time;        //要求运行时间
    int Wait_Time;        //等待时间
    float Res_Ratio;    //响应比
    char state;            //状态 Ready/End
}* Proc; //指向该PCB的指针

int ProcNum; // 全局变量，用于用户自己确定进程个数

void ComputeRes(Proc &H) //计算响应比
{
    Proc p=H->next;
    while (p) {
        if (p->state == 'R') {
            p->Wait_Time++;
            p->Res_Ratio=1+(float)(p->Wait_Time)/p->All_Time;
        }
        else p->Res_Ratio=0.0;
        p=p->next;
    }
}

void InitProc(Proc &H)
{
    cout<<"输入总进程个数: ";
    cin>>ProcNum; //进程总个数
    int Num=ProcNum;
    H=(Proc)malloc(sizeof(PNode));
    H->next=NULL;
    Proc p=H;
    cout<<"总进程个数默认为 "<<ProcNum<<" 个,请输入相应信息\n\n";

    while (Num--) {
        p=p->next=(Proc)malloc(sizeof(PNode));
        cout<<"进程名总运行时间等待时间 :";
        cin>>p->name>>p->All_Time>>p->Wait_Time;
        p->state='R';
        p->Res_Ratio=1+(float)(p->Wait_Time)/p->All_Time;
        p->next=NULL;
    }
}

void DispInfo(Proc H) { //输出运行中信息
    Proc p=H->next;
    while (p) {
        cout<<endl<<"进程名:"<<p->name<<"\t总运行时间:"<<p->All_Time
            <<"\t等待时间:"<<p->Wait_Time
            <<"\t响应比:"<<p->Res_Ratio<<"\t状态:"<<p->state<<endl;
        p=p->next;
    }
}

void RelocateMax(Proc &H)  // 进程排序 (逆序算法) , 首节点是响应比最高节点
{
    if(H->next==NULL || H->next->next==NULL)
        return; // 只剩一个节点或没有节点时无需排序
    Proc p=H->next,q,r;
    if (p) {
        r=p->next;
        p->next=NULL;
        p=r;
        while (p) {
            r=p->next;
            q=H;
            while (q->next && q->next->Res_Ratio < p->Res_Ratio)
                q=q->next;
            p->next=q->next;
            q->next=p;
            p=r;
        }
    }
    p=H->next;
    H->next=NULL;
    while (p) {
        q=p->next;
        p->next=H->next;
        H->next=p;
        p=q;
    }
}

void HRN_Simulator(Proc &H) //高响应比算法模拟器
{
    cout<<endl<<"-------------------START--------------------\n";
    int flag=ProcNum; // 记录剩余进程数
     while (flag)
    {
        Proc p=H->next;
        p->All_Time--;
        p->Wait_Time=0;
        p->Res_Ratio=1.0;
        if (p->All_Time == 0)
        {
            p->state = 'E';
            ComputeRes(H);
            DispInfo(H);
            if (p->next == NULL)
                H->next = NULL;
            else H->next = p->next; //将首节点删除
            cout<<endl<<p->name<<" 进程已运行结束\n";
            flag--;
        }
        else
        {

            DispInfo(H);ComputeRes(H);
        }
        RelocateMax(H);
    }
    cout<<endl<<"--------------------END---------------------\n\n";
}

void main()
{
    Proc H;
    InitProc(H); // 数据初始化
    DispInfo(H); // 初始化成功后的进程状态
    HRN_Simulator(H); // 模拟高响应比优先算法
    system("pause");
}

Brian 2010-08-17 12:59 发表评论

实验一进程调度(指导书)

Brian — Tue, 17 Aug 2010 04:57:00 GMT

一、实验内容

利用高级语言模拟进程的时间片轮转调度算法，响应比高者优先调度算法。

二、实验目的

在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。本实验模拟在单处理器情况下的处理器调度，帮助学生加深了解处理器调度的工作。

三、实验环境

1．PC微机。

2．Windows 操作系统。

3．C/C++/VB开发集成环境。

四、实验题目

本实验有两个小题。

第一题：设计一个按时间片轮转法实现处理器调度的程序。

算法设计思想：

(1) 假定系统有五个进程，每一个进程用一个进程控制块PCB来代表。进程控制块的格式为：

进程名

指针

要求运行时间

已运行时间

状态

其中，进程名——作为进程的标识，假设五个进程的进程名分别为Q₁，Q₂，Q₃，Q₄，Q₅。

指针——进程按顺序排成循环队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程的指针指出第一个进程的进程控制块首地址。

要求运行时间——假设进程需要运行的单位时间数。

已运行时间——假设进程已经运行的单位时间数，初始值为“0”。

状态——有两种状态，“就绪”和“结束”，初始状态都为“就绪”，用“R”表示。当一个进程运行结束后，它的状态为“结束”，用“E”表示。

(2) 每次运行所设计的进程调度程序前，为每个进程任意确定它的“要求运行时间”。

(3) 把五个进程按顺序排成循环队列，用指针指出队列连接情况。另用一标志单元记录轮到运行的进程。例如，当前轮到P₂执行，则有：

标志单元

K₂

K₁	Q₁	K₂	Q₂	K₃	Q₃	K₄	Q₄	K₅	Q₅
	K₂		K₃		K₄		K₅		K₁
	2		3		1		2		4
	1		0		0		0		0
	R		R		R		R		R
	PCB1		PCB2		PCB3		PCB4		PCB5

(4) 处理器调度总是选择标志单元指示的进程运行。由于本实验是模拟处理器调度的功能，所以，对被选中的进程并不实际的启动运行，而是执行：

已运行时间+1

来模拟进程的一次运行，表示进程已经运行过一个单位的时间。

请注意：在实际的系统中，当一个进程被选中运行时，必须置上该进程可以运行的时间片值，以及恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行满一个时间片。在这时省去了这些工作，仅用“已运行时间+1”来表示进程已经运行满一个时间片。

(5) 进程运行一次后，应把该进程的进程控制块中的指针值送到标志单元，以指示下一个轮到运行的进程。同时，应判断该进程的要求运行时间与已运行时间，若该进程的要求运行时间?已运行时间，则表示它尚未执行结束，应待到下一轮时再运行。若该进程的要求运行时间=已运行时间，则表示它已经执行结束，应指导它的状态修改成“结束”（E）且退出队列。此时，应把该进程的进程控制块中的指针值送到前面一个进程的指针位置。

(6) 若“就绪”状态的进程队列不为空，则重复上面的（4）和（5）的步骤，直到所有的进程都成为“结束”状态。

(7) 在所设计的程序中应有显示或打印语句，能显示或打印每次选中进程的进程名以及运行一次后进程队列的变化。

(8) 为五个进程任意确定一组“要求运行时间”，启动所设计的处理器调度程序，显示或打印逐次被选中的进程名以及进程控制块的动态变化过程。

第二题：设计一个按响应比高者优先调度算法实现进程调度的程序。

算法设计思想：

(1) 假定系统有五个进程，每一个进程用一个进程控制块PCB来代表，进程控制块的格式为：

进程名

指针

要求运行时间

等待时间

响应比

状态

其中，进程名——作为进程的标识，假设五个进程的进程名分别为P₁，P₂，P₃，P₄，P₅。

指针——按优先数的大小把五个进程连成队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程中的指针为“0”。

要求运行时间——假设进程需要运行的单位时间数。

等待时间——自最近一次调度运行至今等待的时间数，当进程被调度时等待时间清零。

响应比——进程调度程序运行前计算每个进程的响应比，调度时总是选取响应比大的进程先执行，每次执行一个固定的时间片。

状态——可假设有两种状态，“就绪”状态和“结束”状态。五个进程的初始状态都为“就绪”，用“R”表示，当一个进程运行结束后，它的状态为“结束”，用“E”表示。

(2) 在每次运行你所设计的处理器调度程序之前，为每个进程任意确定它的“等待时间”和“要求运行时间”。

(3) 为了调度方便，把五个进程按给定的响应比从大到小连成队列。用一单元指出队首进程，用指针指出队列的连接情况。例：

队首标志

K₂

K₁	P₁	K₂	P₂	K₃	P₃	K₄	P₄	K₅	P₅
	0		K₄		K₅		K₃		K₁
	2		3		1		2		4
	1		5		3		4		2
	R		R		R		R		R
	PCB1		PCB2		PCB3		PCB4		PCB5

(4) 处理器调度总是选队首进程运行。采用动态改变响应比的办法，进程每运行一次重新计算各进程的响应比。由于本实验是模拟处理器调度，所以，对被选中的进程并不实际的启动运行，而是执行：要求运行时间-1、等待时间为0。其它进程等待时间+1，重新计算各进程的响应比，并从大到小排序。

提醒注意的是：在实际的系统中，当一个进程被选中运行时，必须恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行结束。在这里省去了这些工作。

(5) 进程运行一次后，若要求运行时间?0，则再将它加入队尾（因其响应比最小。）；若要求运行时间=0，则把它的状态修改成“结束”（E），且退出队列。

(6) 若“就绪”状态的进程队列不为空，则重复上面（4）和（5）的步骤，直到所有进程都成为“结束”状态。

(7) 在所设计的程序中应有显示或打印语句，能显示或打印每次被选中进程的进程名以及运行一次后进程队列的变化及各进程的参数。

(8) 为五个进程任意确定一组“等待时间”和“要求运行时间”，启动所设计的进程调度程序，显示或打印逐次被选中进程的进程名以及进程控制块的动态变化过程。

Brian 2010-08-17 12:57 发表评论

OS 实验分类开篇语

Brian — Tue, 17 Aug 2010 04:56:00 GMT

本学期学习了操作系统，实验课共有三个大实验，共有五个题目：时间片轮转法、高响应比优先、首次适应算法、位示图法、文件管理。每部分都会附上实验指导书和代码。每个实验都有点问题，请大家指教。

还有就是要提醒一下找到这里的学弟学妹，火哥可是知道我写代码的风格的，这些代码他也都看过，如果要用在实验作业上，请你们三思。

如果你们原封不动的复制粘贴，那就太令我失望了，师大的学风要上来啊。

Brian 2010-08-17 12:56 发表评论

C++博客-Brian Warehouse-随笔分类-OS

实验三代码 文件管理

实验三 文件管理(指导书)

实验二代码 首次适应法 位示图法

实验二 内存储器空间的管理(指导书)

实验一代码 时间片轮转法 高响应比优先

实验一 进程调度(指导书)

OS 实验分类开篇语

实验三代码文件管理

实验三文件管理(指导书)

实验二代码首次适应法位示图法

实验二内存储器空间的管理(指导书)

实验一代码时间片轮转法高响应比优先

实验一进程调度(指导书)