《计算机操作系统》实验要求

《计算机操作系统》实验要求
为了顺利完成操作系统课程实验，应做到：
（1）实验前，认真学习教材以及实验要求的相关内容，提前做好实验准备。

（2）实验结束后三天内提交实验报告的电子版和打印版。

实验报告内容应包括：实验目的、实验内容、设计思路和流程框图，主要程序代码、测试结果以及实验总结。

（实验报告模板见“OS实验模板”）
（3）遵守机房纪律，服从指挥，爱护实验设备。

实验的验收将分为两个部分。

第一部分是上机操作，随机抽查程序运行和即时提问；第二部分是提交书面的实验报告。

要杜绝抄袭现象，一经发现雷同，双方成绩均以0分计算。

实验内容安排：
实验一进程调度实验 (3)
实验二页面置换算法模拟 (10)
实验三银行家算法模拟 (15)
实验一进程调度实验
【开发语言及实现平台或实验环境】
C++/C#
Turbo C / Microsoft V isual Studio 6.0 / Microsoft Visual Studio .NET 2010
【实验目的】
（1）加深对进程的概念及进程调度算法的理解；
（2）在了解和掌握进程调度算法的基础上，编制进程调度算法通用程序，将调试结果显示在计算机屏幕上，并检测机算和笔算的一致性。

【实验要求】
（1）了解进程调度；
（2）理解利用进程调度算法进行调度的原理；
（3）使用某种编程语言进行算法模拟。

【实验原理】
（注意：这个仅是个例子，可以参考本例，选择其他算法进行实验）
一、例题：设计一个有N个进程的进程调度算法。

进程调度算法：采用最高优先数的调度算法（即把处理机分配给优先数最高的进程）。

每个进程有一个进程控制块（PCB）表示。

进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。

进程的优先数及需要的运行时间可以事先人为的指定（也可以由随机数产生）。

进程的到达时间为进程的输入的时间。

进程的运行时间以时间片为单位进行计算。

每个进程的状态可以是就绪W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。

就绪进程获得CPU后都只能运行一个时间片。

用已占用CPU时间加1表示。

如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤销该进程，如果运行一个时间片后，进程的已占用CPU时间还未达到所需要的运行时间，也就是进程还需要继续运行，此时应该将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。

每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。

重复以上过程，直到所要的进程都完成为止。

分析:
使用固定队列与静动态优先级结合每个优先级为0~0xFF,并且以小的数字为高优先级，大的数字为低优先级，每次皆使用循环得到最高优先级的进程并执行，然后将其动态优先级设置为最低，并将其他进程动态优先级提高，以使得每个进程都有机会运行。

进程的优先级与运行时间由随机数产生。

二、代码试例
#include <stdlib.h>
#include <stdio.h>
#include <t ime.h>
/*常量和状态定义*/
#define PRO_NUM 0x05 #define MAX_TIME 0xFF /*状态宏*/
#define WAIT 0x01
#define RUN 0x02
#define FINISH 0x03
#define ID_ERROR 0x10
#define MIN_PRIOR 0xFF
#define MAX_PRIOR 0x00
typedef unsigned int Uint32;
/*进程PCB*/
struct PCB_Info
{
Uint32 s_id;
Uint32 s_static_prior;
Uint32 s_dynamic_prior;
Uint32 s_start_tim e;
Uint32 s_need_time;
Uint32 s_used_time;
Uint32 s_state;
};
/*进程队列*/
PCB_Info g_queue[5];
Uint32 g_tim e;
/*模拟进程执行函数*/
void Simulator();
/*初始化5个进程函数*/
void Init_Process();
/*初始化进程队列函数*/
void Init_Queue();
/*创建进程函数*/
Uint32 Create_Process(Uint32 pri,Uint32 needtime); /*系统运行函数*/
void Run_Process();
/*得到最高优先级进程ID函数*/
Uint32 Get_PriProcess();
/*进程时间片执行函数*/
void Work_Process(Uint32 id);
/*改变进程状态和优先级函数*/
void Change_Process(Uint32 id);
/*打印进程状态函数*/
void Print_State();
/*结束系统函数*/
void End_Process();
/*入口函数*/
int m ain( int argc, char *argv[ ])
{
Sim ulator();
return 0;
}
void Simulator()
{
Init_Process();
Run_Process();
End_Process();
}
void Init_Process()
{
int i;
Uint32 id;
srand( (unsigned)tim e( NULL ) );
Init_Queue();
for(i=0;i<PRO_NUM;++i)
{
/*在这里修改随机数的范围，建议优先级取值为0到4之间，进程工作总时间为1到10之间*/
id=Create_Process(rand()%4,1+rand()%10);
if(id!=ID_ERROR)
{
printf("**********************************\n");
printf("创建进程成功\n");
printf("进程ID号为:%d\n",id);
printf("进程的静态优先权为:%d\n",g_queue[id].s_static_prior);
printf("进程的动态优先权为:%d\n",g_queue[id].s_dynamic_prior);
printf("进程的到达时间为:%d\n",g_queue[id].s_start_tim e);
printf("进程需要时间为:%d\n",g_queue[id].s_need_tim e);
printf("进程已用CPU时间为:%d\n",g_queue[id].s_used_time);
printf("进程的状态为:%d\n",g_queue[id].s_state);
printf("\n");
}
else
{
printf("创建进程失败\n");
}
}
}
void Init_Queue()
{
int i;
for(i=0;i<PRO_NUM;++i)
{
g_queue[i].s_id=i;
g_queue[i].s_dynamic_prior=MIN_PRIOR;
g_queue[i].s_need_time=0;
g_queue[i].s_start_tim e=0;
g_queue[i].s_static_prior=MIN_PRIOR;
g_queue[i].s_used_time=0;
g_queue[i].s_state=FINISH;
}
}
Uint32 Create_Process(Uint32 pri,Uint32 needtime) {
int i=0;
Uint32 id=ID_ERROR;
for(i=0;i<PRO_NUM;++i)
{
if(g_queue[i].s_state==FINISH)
{
id=g_queue[i].s_id;
g_queue[i].s_dynamic_prior=MIN_PRIOR;
g_queue[i].s_need_time=needtime;
g_queue[i].s_start_time=g_tim e;
g_queue[i].s_state=WAIT;
g_queue[i].s_static_prior=pri;
g_queue[i].s_used_time=0x0;
break;
}
}
return id;
}
void Run_Process()
{
Uint32 id;
while((id=Get_PriProcess())!=ID_ERROR)
{
Work_Process(id);
Change_Process(id);
}
}
void Print_State()
{
int i;
printf("时间进程ID\t状态已用时间需要时间开始时间静优先级动优先级\n");
for(i=0;i<PRO_NUM;++i)
{
printf("%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n",g_time,g_queue[i].s_id,g_queu e[i].s_state,g_queue[i].s_used_time,g_queue[i].s_need_time,
g_queue[i].s_start_tim e,g_queue[i].s_static_prior,g_queue[i].s_dynamic_prior);
}
}
Uint32 Get_PriProcess()
{
Uint32 id=ID_ERROR;
int i,prev_id=ID_ERROR;
Uint32 prior=MIN_PRIOR*2,tem p_prior;
for(i=0;i<PRO_NUM;++i)
{
if(g_queue[i].s_state!=FINISH)
{
tem p_prior=g_queue[i].s_dynamic_prior+g_queue[i].s_static_prior;
if(tem p_prior<=prior)
{
id=i;
prior=temp_prior;
}
}
}
return id;
}
void Work_Process(Uint32 id)
{
++g_tim e;
g_queue[id].s_state=RUN;
++g_queue[id].s_used_time;
Print_State();
}
void Change_Process(Uint32 id)
{
int i;
if(g_queue[id].s_need_time==g_queue[id].s_used_time)
{
g_queue[id].s_state=FINISH;
}
else
{
g_queue[id].s_dynamic_prior=MIN_PRIOR;
g_queue[id].s_state=WAIT;
}
for(i=0;i<PRO_NUM;++i)
{
if((i!=id)&&(g_queue[i].s_state!=FINISH))
{
g_queue[i].s_dynamic_prior>0?--g_queue[i].s_dynamic_prior:g_queue[i].s_dyna mic_prior=0;
}
}
}
void End_Process()
{
printf("所有进程结束状态:\n");
Print_State();
printf("所有进程已经结束!\n");
}
实验二请求页式存储管理中常用页面置换算法模拟
【开发语言及实现平台或实验环境】
C++/C#
Turbo C / Microsoft V isual Studio 6.0 / Microsoft V isual Studio .NET 2010
【实验目的】
（1）了解内存分页管理策略
（2）掌握调页策略
（3）掌握一般常用的调度算法
（4）学会各种存储分配算法的实现方法。

（5）了解页面大小和内存实际容量对命中率的影响。

【实验要求】
（1）采用页式分配存储方案，通过分别计算不同算法的命中率来比较算法的优劣，同时也考虑页面大小及内存实际容量对命中率的影响；
（2）实现OPT 算法(最优置换算法) 、LRU 算法(Least Recently) 、FIFO 算法(First IN First Out)的模拟；
（3）使用某种编程语言模拟页面置换算法。

【实验原理】
分页存储管理将一个进程的逻辑地址空间分成若干大小相等的片，称为页面或页。

在进程运行过程中，若其所要访问的页面不在内存而需把它们调入内存，但内存已无空闲空间时，为了保证该进程能正常运行，系统必须从内存中调出一页程序或数据，送磁盘的对换区中。

但应将哪个页面调出，须根据算法来确定。

通常，把选择换出页面的算法称为页面置换算法。

一个好的页面置换算法，应具有较低的页面更换频率。

从理论上讲，应将那些以后不再会访问的页面换出，或将那些在较长时间内不会再访问的页面调出。

一、最佳置换算法OPT(Optimal)
它是由Belady于1966年提出的一种理论上的算法。

其所选择的被淘汰页面，将是以后永不使用的或许是在最长(未来)时间内不再被访问的页面。

采用最佳置换算法，通常可保证获得最低的缺页率。

但由于人目前还无法预知一个进程在内存的若干个页面中，哪一个页面是未来最长时间内不再被访问的，因而该算法是无法实现的，但是可以利用此算法来评价其它算法。

如果编写程序模拟该算法，可以提前设定页面访问次序，获知某个页面是否在未来不再被访问。

二、先进先出(FIFO)页面置换算法
这是最早出现的置换算法。

该算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。

该算法实现简单只需把一个进程已调入内存的页面，按先后次序链接成一个队列，并设置一个指针，称为替换指针，使它总是指向最老的页面。

三、最近最久未使用置换算法
1、LRU(Least Recently Used)置换算法的描述
FIFO置换算法性能之所以较差，是因为它所依据的条件是各个页面调入内存的时间，而页面调入的先后并不能反映页面的使用情况。

最近最久未使用（LRU）置换算法，是根据
页面调入内存后的使用情况进行决策的。

由于无法预测各页面将来的使用情况，只能利用“最近的过去”作为“最近的将来”的近似，因此，LRU置换算法是选择最近最久未使用的页面予以淘汰。

该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间t,，当须淘汰一个页面时，选择现有页面中其t值最大的，即最近最久未使用的页面予以淘汰。

2、LRU置换算法的硬件支持
LRU置换算法虽然是一种比较好的算法，但要求系统有较多的支持硬件。

为了了解一个进程在内存中的各个页面各有多少时间未被进程访问，以及如何快速地知道哪一页是最近最久未使用的页面，须有以下两类硬件之一的支持：
1）寄存器
为了记录某个进程在内存中各页的使用情况，须为每个在内存中的页面配置一个移位寄存器，可表示为
R=R n-1R n-2R n-3……R2R1R0 当进程访问某物理块时，要将相应寄存器的Rn-1位置成1。

此时，定时信号将每隔一定时间(例如100ms)将寄存器右移一位。

如果我们把n位寄存器的数看作是一个整数，那么具有最小数值的寄存器所对应的页面，就是最近最久未使用的页面。

下图显示了某进程在内存中具有8个页面，为每个内存页面配置一个8位寄存器时的LRU 访问情况。

这里，把8个内存页面的序号分别定为1--8。

由图可以看出，第7个内存页面的
2)栈
可利用一个特殊的栈来保存当前使用的各个页面的页面号。

每当进程访问某页面时，便将页面的页面号从栈中移出，将它压入栈顶。

因此，栈顶始终是最新被访问页面的编号，而栈底则是最近最久未使用的页面的页面号。

【实验步骤】
参考实验步骤如下：（注意：这个仅是个例子，可以参考本例，选择其他算法进行实验）
（1）现定义数据结构和全局变量。

#include<stdio.h>
#include<conio.h>
#define M 4
#define N 17
#define Myprintf printf("|---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---|\n")
/*表格控制*/
typedef struct page
{ int num; /*记录页面号*/
int time; /*记录调入内存时间*/
}Page; /* 页面逻辑结构，结构为方便算法实现设计*/
Page b[M]; /*内存单元数*/
int c[M][N]; /*暂保存内存当前的状态：缓冲区*/
int queue[100]; /*记录调入队列*/
int K; /*调入队列计数变量*/
（2）初始化内存单元、缓冲区
void Init(Page *b,int c[M][N])
{ int i,j;
for(i=0;i<N;i++)
{ b[i].num=-1;
b[i].time=N-i-1; }
for(i=0;i<M;i++)
for(j=0;j<N;j++)
c[i][j]=-1;
}
（3）取得在内存中停留最久的页面,默认状态下为最早调入的页面*/ int GetMax(Page *b)
{ int i;
int max=-1;
int tag=0;
for(i=0;i<M;i++)
{ if(b[i].time>max)
{ max=b[i].time;
tag=i; } }
return tag;
}
（4）判断页面是否已在内存中*/
int Equation(int fold,Page *b)
{ int i;
for(i=0;i<M;i++)
if (fold= =b[i].num) return i;
return -1;
}
（5）LRU算法
void Lru(int fold,Page *b)
{ int i;
val=Equation(fold,b);
if (val>=0)
{ b[val].time=0;
for(i=0;i<M;i++)
if (i!=val) b[i].time++;
}
else
{ queue[++K]=fold;/*记录调入页面*/ val=GetMax(b);
b[val].num=fold;
b[val].time=0;
for(i=0;i<M;i++)
if (i!=val) b[i].time++;
} }
（6）主程序
void main()
{
int a[N]={1,0,1,0,2,4,1,0,0,8,7,5,4,3,2,3,4};
int i,j;
start:
K=-1;
Init(b, c);
for(i=0;i<N;i++)
{ Lru(a[i],b);
c[0][i]=a[i];
/*记录当前的内存单元中的页面*/
for(j=0;j<M;j++)
c[j][i]=b[j].num;
}
/*结果输出*/
printf("内存状态为：\n");
Myprintf;
for(j=0;j<N;j++)
printf("|%2d ",a[j]);
printf("|\n");
Myprintf;
for(i=0;i<M;i++)
{ for(j=0;j<N;j++)
if(c[i][j]==-1) printf("|%2c ",32);
else
printf("|%2d ",c[i][j]);
printf("|\n");
}
printf("\n调入队列为:");
for(i=0;i<K+1;i++)
printf("%3d",queue[i]);
printf("\n缺页次数为：%6d\n缺页率：%16.6f",K+1,(float)(K+1)/N);
printf("\nAre you continuing!\ty?");
if(getche()=='y') goto start;
}
可以参照以上代码写出FIFO的算法。

实验三银行家算法模拟
【开发语言及实现平台或实验环境】
C++/C#
Turbo C / Microsoft V isual Studio 6.0 / Microsoft V isual Studio .NET 2010
【实验目的】
（1）理解利用银行家算法避免死锁的问题；
（2）在了解和掌握银行家算法的基础上，编制银行家算法通用程序，将调试结果显示在计算机屏幕上，并检测机算和笔算的一致性。

（3）理解和掌握安全序列、安全性算法
【实验要求】
（1）了解和理解死锁；
（2）理解利用银行家算法避免死锁的原理；
（3）使用某种编程语言模拟该算法。

【实验原理】
一、安全状态
指系统能按照某种顺序如<P1,P2,…,Pn>(称为<P1,P2,…,Pn>序列为安全序列)，为每个进程分配所需的资源，直至最大需求，使得每个进程都能顺利完成。

二、银行家算法
假设在进程并发执行时，进程i提出请求j类资源k个后，表示为Requesti[j]=k。

系统按下述步骤进行安全检查：
（1）如果Requesti≤Needi则继续以下检查，否则显示需求申请超出最大需求值的错误。

（2）如果Requesti≤Available则继续以下检查，否则显示系统无足够资源，Pi阻塞等待。

（3）系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值： Available［j］∶=Available［j］-Requesti［j］;
Allocation［i,j］∶=Allocation［i,j］+Requesti［j］;
Need［i,j］∶=Need［i,j］-Requesti［j］;
（4）系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。

若安全，才正式将资源分配给进程Pi，以完成本次分配；否则，将本次的试探分配作废，恢复原来的资源分配状态，让进程Pi等待。

三、安全性算法
（1）设置两个向量：
①工作向量Work: 它表示系统可提供给进程继续运行所需的各类资源数目，它含有m 个元素，在执行安全算法开始时，Work∶=Available;
② Finish: 它表示系统是否有足够的资源分配给进程，使之运行完成。

开始时先做Finish［i］∶=false; 当有足够资源分配给进程时，再令Finish［i］∶=true。

（2）从进程集合中找到一个能满足下述条件的进程：
① Finish［i］=false;
② Need［i,j］≤Work［j］；若找到，执行步骤(3)，否则，执行步骤(4)。

（3）当进程Pi获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行： Work［j］∶= Work［i］+Allocation［i,j］;
Finish［i］∶= true;
go to step 2;
（4）如果所有进程的Finish［i］=true都满足，则表示系统处于安全状态；否则，系统处于不安全状态。

【实验步骤】
参考实验步骤如下：
（1）参考下图流程编写安全性算法。

（2）编写统一的输出格式。

每次提出申请之后输出申请成功与否的结果。

如果成功还需要输出变化前后的各种数据，并且输出安全序列。

（3）参考下图所示流程图编写银行家算法。

（4）编写主函数来循环调用银行家算法。

示例：（注意：这个仅是个例子，可以参考本例，选择其他算法进行实验）#include <stdio.h>
int main()
{
int claim[5][3]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};//各线程最大需求量
int allocation[5][3]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};//各线程已分配资源int i,j,k,l=0,count=0,m=0;
int C_A[5][3]={{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0}};//各进程仍需要的各类资源int result[5]={-1,-1,-1,-1,-1};//存放预分配成功的线程
int currentavail[3]={3,3,2};//当前可分配资源
printf("银行家总共拥有的各类资源的总数：\n A B C\n 10 5 7\n");
printf("银行目前仍剩下的各类资源的数量：\n A B C\n 3 3 2\n");
printf("各进程对各类资源的最大需求量：\n A B C\n");
for(i=0;i<5;i++)
{
printf("P%d: ",i);
for(j=0;j<3;j++)
{
printf(" %d ",claim[i][j]);
C_A[i][j]=claim[i][j]-allocation[i][j];
}
printf("\n");
}
printf("各进程已分配到的各类资源：\n A B C\n");
for(i=0;i<5;i++)
{
printf("P%d: ",i);
for(j=0;j<3;j++)
printf(" %d ",allocation[i][j]);
printf("\n");
}
printf("各进程仍需的各类资源数量：\n A B C\n");
for(i=0;i<5;i++)
{
printf("P%d: ",i);
for(j=0;j<3;j++)
printf(" %d ",C_A[i][j]);
printf("\n");
}
while(result[l]==-1)//
{
for(k=0;k<5;k++)
if(result[k]==-1)
{
for(j=0;j<3;j++)
//判断各线程对各资源仍需量是否小于当前可分配资源总量,此量为正数才正常
if(C_A[k][j]<=currentavail[j]&&C_A[k][j]>=0)
{
//把满足条件的进程的已分配资源加到当前可分配资源中
currentavail[j]=currentavail[j]+allocation[k][j];
m++;
if(m==3)
{
result[l]=k;//只有ABC三类资源都满足才把相应的线程记入数组result中
m=0;
}
}
else break;//否则退出循环,打印"系统不安全"
l++;
}
for(i=0;i<l;i++)
if(result[i]!=-1)
{
printf("P%d->",result[i]);//把预分配成功的先打印出来
count++;
}
l=0;//清零,为下一轮的预分配做准备
}
if(count==5)
printf("\n系统安全!上行所示为其中一个进程安全序列\n");
else
printf("\n系统不安全!\n");
}
结果如下：
银行家总共拥有的各类资源的总数：
A B C
10 5 7
银行目前仍剩下的各类资源的数量：
A B C
3 3 2
各进程对各类资源的最大需求量：
A B C
P0: 7 5 3
P1: 3 2 2
P2: 9 0 2
P3: 2 2 2
P4: 4 3 3
各进程已分配到的各类资源：
A B C
P0: 0 1 0
P1: 2 0 0
P2: 3 0 2
P3: 2 1 1
P4: 0 0 2
各进程仍需的各类资源数量：
A B C
P0: 7 4 3
P1: 1 2 2
P2: 6 0 0
P3: 0 1 1
P4: 4 3 1
P1->P3->P4->P0->P2->
系统安全!上行所示为其中一个进程安全序列
【建议】以上资料来源于网络，仅供参考。

大家本学期学习了C#编程和web程序设计，所以建议大家使用C#进行window编程实现相关算法，如果能使用学习的web程序设计，将算法以网络应用的形式实现，则效果更好。

即使自己编程能力欠缺，也希望能理解相关算法，跑通程序，并认真撰写实验报告。