广工操作系统实验2014 2015

操作系统实验报告

学生学院计算机学院

专业班级X级网络工程2班

学号 311X

学生姓名 X

指导教师 X 2013年12月26 日

计算机学院网络工程专业 2 班学号：X 姓名：X 协作者：________ 教师评定：

实验__一__题目_实验一进程调度

实验__二__题目_实验二作业调度

实验__三__题目_实验三储存管理空间的分配与回收模拟

计算机学院网络工程专业 2 班学号：31X6

姓名：X 协作者：________ 教师评定：

实验题目___实验一进程调度

一、实验目的

用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解。

二、实验原理

设计一个有N个进程并发的进程调度程序。要求采用最高级优先数优先算法。

每个进程有一个进程控制块PCB表示。进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。进程的优先数以及需要的运行时间可以事先人为地指定。进程的到达时间为进程输入的时间。进程的运行时间以及时间片为单位进行计算。

每个进程的状态可以是未准备N(no ready)、就绪W(wait)、运行R(run)、完成F(finish)四种状态之一。

就绪进程获得CPU后就只能进行一个时间片。用已占用CPU时间加1来表示。

如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤销该进程，如果运行一个时间片后进程的已占用CPU时间还未到达所需要的运行时间，也就是进程还需要继续运行，此时，应将进程的优先数减1，然后把它插入就绪队列等待CPU。每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进程检查。

重复以上过程，知道所有进程完成为止。

三、实验方法、步骤、方案

1、动态优先数时间片轮转法：采用时间片轮转法和动态优先数算法的混合思想：一开始给予任务赋予优先数，如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤销该进程，如果运行一个时间片后进程的已占用CPU时间还未到达所需要的运行时间，也就是进程还需要继续运行，此时，应将进程的优先数减1(即满足动态优先数)，然后比较队列的优先数，并把该任务插入比该任务现在的优先数还大的进程的最前面。然后继续进行下一个时间片，直到所有进程完成为止。

2、开放式多级反馈队列调度算法：采用多级反馈队列调度算法。其基本思想是：当一个新进程进入内在后，首先将它放入第一个队列的末尾，按FCFS原则排队等待高度。当轮到该进程执行时，如能在该时间片内完成，便可准备撤离系统；如果它在一个时间片结束时尚为完成，调度程序便将该进程转入第二队列的末尾，再同样地按FCFS原则等待调度执行，以此类推。开放式实现：允许完成一个时间片后插入进程，对该进程的插入方式是：插入第一队队列的末端。

四、重要函数、数据结构说明

动态优先数时间片轮转法：

struct pcb{//进程控制块

char name[10];//进程名

char state;//进程状态

int super;//优先数

int ntime;//需要运行时间

int rtime;//已占用CPU时间

int pieces;//时间片

struct pcb* link;

}

sort()//对进程进行优先级排列函数

{

PCB *first,*second;

int insert=0;

if((ready==NULL)||((p->super)>(ready->super))){

p->link=ready;

ready=p;

}//优先数最大进入队列头

else{

first=ready;

second=first->link;

while(second!=NULL){

if((p->super)>(second->super))//插入进程优先数大于当前进程优先数

{//插入到当前进程前面

p->link=second;

first->link=p;

second=NULL;

insert=1;

}

else{//否则进入对尾

first=first->link;

second=second->link;

}

}

if(insert==0){//不插入则继续

first->link=p;

}

}

7

running()//建立进程就绪函数

{

if(p->pieces==1){

p->rtime+=3;//时间片运行

}

else{

(p->rtime)++;

}

if(p->rtime==p->ntime||p->rtime>p->ntime){

destroy();

}

else{

(p->super)--;

p->state='W';

sort();

}

}

开放式多级反馈队列调度算法：

typedef struct pcb{//进程控制块

char name[10];//进程名

char state;//进程状态

int queue;//进程所在队列

int ntime;//需要运行时间

int rtime;//已占用CPU时间

int qtime;//进程在当前队列可运行的时间块

struct pcb* link;

}

findpos()//找到队列函数

{

PCB *ps=pfend;

if(!ps||!ps->link||(ps->link->queue-ps->queue)>1){

pinsert=ps;

}

else{

while(ps->link&&ps->link->queue!=(pfend->queue+2)){ ps=ps->link;

}

pinsert=ps;

}

}

insert()插入函数

{

if(!ready){

8

ready=p;

pfend=p;

pinsert=p;

}

else if(ready->queue==1){

p->link=pfend->link;

pfend->link=p;

pfend=p;

findpos();

}

else{

p->link=ready;

ready=p;

findpos();

}

}

sort()//插入队列过程函数

{

if(!ready->link||ready->queuelink->queue){

return;

}

p=ready->link;

ready->link=pinsert->link;

pinsert->link=ready;

pinsert=ready;

ready=p;

if(ready&&ready->queue==pinsert->queue){

findpos();

}

}

五、实验效果

动态优先数时间片轮转法：

输入：

9

10

第一个时间片：

第二个时间片：

第三个时间片：

第八个时间片：

11

开放式多级反馈队列调度算法：

输入：

第一个时间片：

第三个时间片：

12

插入进程third ：

第六个时间片：

第十个时间片：

六、失败案例

一、优先数溢出：

出现原因：needtime>优先数，而动态优先数规则是逐步-1.

参考解决方案：添加个判断语句规定优先数最少为0，即当所有进程优先数为0该算法转变为FCFS 算法。

二、老进程饿死：

出现原因：即在开放性的条件下出现不停插入新进程，导致永远无法执行老进程。

解决方案：1)添加一个强制执行机构，给予他一个值t，用户可以自行输入t的大小，当队列的进程大于t时，则插入下一个队列里。2)引用HRN高响应比算法。

13

14

计算机学院网络工程专业 2 班学号：X 姓名：X 协作者：________ 教师评定：

实验题目___实验二作业调度

一、实验目的

本实验要求学生模拟作业调度的实现，用高级语言编写和调试一个或多个作业调度的模拟程序，了解作业调度在操作系统中的作用，以加深对作业调度算法的理解。

二、实验原理

模拟批处理多道操作系统的作业调度

(1)、编写并调试一个作业调度模拟程序。

(2)、作业调度算法：分别采用先来先服务（FCFS），最短作业优先（SJF）、响应比高者优先（HRN）的调度算法。

(3)、在批处理系统中，要假定系统中具有各种资源及数量、调度作业时必须考虑到每个作业的资源要求，所需要的资源是否得到满足。

作业调度程序负责从输入井选择若干个作业进入主存，为他们分配必要的资源，当他们能够被进程调度选中时，就可占用处理器运行。作业调度选择一个作业的必要条件是系统中现有的尚未分配的资源可满足该作业的资源要求。但有时系统中现有的尚未分配的资源既可满足某个作业的要求也可满足其他一些作业的要求，那么，作业调度必须按一定的算法在这些作业中做出选择。当作业正常运行完毕或发生错误非正常终止时，作业进入完成状态，此时，系统将收回该作业所占用的全部资源，并清除有关的JCB。

并输出显示作业运行情况及作业输出结果。

(4)、每个作业由一个作业控制块JCB表示，JCB可以包含如下信息：作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。每个作业的最初状态总是等待W。

(5)、对每种调度算法都要求打印每个作业开始运行时刻、完成时刻，并比较各种算法的优缺点。

三、实验方法、步骤、方案

编写并调度一个多道程序系统的作业调度模拟程序。

作业调度算法：采用基于先来先服务（FCFS）的调度算法或短作业优先（SJF）调度算法。可参考课本中的方法自行设计。

对于多道程序系统，要假设系统中具有的各种资源及数量、调度作业时必须考虑到每个作业的资源要求。

要求打印每选择一个作业后的作业表变化情况以及作业被选中执行的次序。

[提示]：

假定某系统可供用户使用的主存空间共100KB，并有5台磁带机。由于本实验是模拟作业调度，假定程序已经把一批作业的信息存放在输入井，并为他们建立如下的作业表：

用户名作业名状态到达时间运行时间资源要求

主存磁带机

A JOBA 后备9：00 0.25小时20K 2

B JOBB 后备9：20 0.3小时60K 1

C JOBC 后备9：30 0.15小时45K 3

D JOBD 后备9：35 0.2小时10K 2

E JOBE 后备9：45 0.1小时25K 3

其中状态分三种：

后备状态——作业已在输入井，但尚未被选中执行；

执行状态——作业被选中，正在执行；

完成状态——作业执行结束。

1)先来先服务算法：是按照作业进入输入井的先后次序来挑选作业，先进入输入井的

作业优先被挑选，当系统中现有的尚未分配的资源不能满足先进入输入井的作业

时，那么顺序挑选后面的作业。

2)短作业优先算法：总是按作业要求运行的时间来挑选作业，每次挑选要求运算时间

短且资源要求能满足的作业先进入主存执行。

3)当作业执行结束进入完成状态时，做好释放资源等善后工作。

4)本实验主要模拟作业调度，所对处理器调度，作业控制过程简化。用输入随机数模

拟处理器调度，用输入“用户名，作业名”模拟一个作业已经执行结束。

5)为作业分配资源可用修改资源分配表来代替。

四、重要函数、数据结构说明

先来先服务（FCFS）：

typedef struct JCB{//作业控制块

char uname[10];//用户名

char jname[10];//作业名

char state;//作业状态

int atime;//到达时间)

int rtime;//运行时间

RESOURCE resource;//资源量

struct JCB *link;

}JCB;

sendsource()//送入内存（运行）

{

JCB *p;

p=pjcb->link;

while(p){

if(p->state=='W'&&source.memory-p->resource.memory>=0&&source.tape-p->resource.tape>=0 ){

p->state='R';

source.memory-=p->resource.memory;

source.tape-=p->resource.tape;

printf("Now,the %s %s is into the RAM\n",p->uname,p->jname);

}

15

p=p->link;

}

}

running()

{

if(check()){

printf("All assignments were done\n");

getchar();

exit(0);

}

JCB *p=pjcb->link;

int time;

while(p){

time=nowtime-(p->atime);

if(p->state=='R'&&time>=p->rtime){

p->state='F';

source.memory+=p->resource.memory;

source.tape+=p->resource.tape;

printf("\nThe %s %s was done\n",p->uname,p->jname);

break;

}

p=p->link;

}

p=pjcb->link;

while(p){

if(nowtime==p->atime&&p->state=='N'){

p->state='W';

printf("\nNow,the %s %s assignment was arrived\n",p->uname,p->jname);

}

p=p->link;

}

sendsource();

disp();

}

短作业优先（SJF）：

typedef struct JCB{//作业控制块

char uname[10];//用户名

char jname[10];//作业名

char state;//作业状态

int atime;//到达时间)

int rtime;//运行时间

16

RESOURCE resource;//资源量

struct JCB *link;

int stime;

}JCB;

JCB *pjcb;

sendsource()//排队函数

{

JCB *p;

p=pjcb->link;

int min=99;

while(p){//做一个min运算求出最短运行时间

if(p->state=='W'){

min=min<(p->rtime)?min:(p->rtime);

}

p=p->link;

}

p=pjcb->link;

while(p){

if(p->state=='W'&&p->rtime<=min&&source.memory-p->resource.memory>=0&&source.tape-p ->resource.tape>=0){

p->stime=nowtime;

p->state='R';

source.memory-=p->resource.memory;

source.tape-=p->resource.tape;

printf("Now,the %s %s is into the RAM\n",p->uname,p->jname);

}

p=p->link;

}

p=pjcb->link;

while(p){

if(p->state=='W'&&source.memory-p->resource.memory>=0&&source.tape-p->resource.tape>=0 ){

p->stime=nowtime;

p->state='R';

source.memory-=p->resource.memory;

source.tape-=p->resource.tape;

printf("Now,the %s %s is into the RAM\n",p->uname,p->jname);

}

p=p->link;

}

}

17

高响应比优先算法（HRN）：

struct jcb //作业控制块

{

char name[10]; //作业名

int reachtime; //作业到达时间

int starttime; //作业开始时间

int needtime; //作业需要运行的时间

float super; //作业的响应比

int finishtime; //作业完成时间

int cycletime; //作业周转时间

float cltime; //作业带权周转时间

char state; //作业状态

struct jcb *next; //结构体指针

}*ready=NULL,*p,*q;

typedef struct jcb JCB;

void running(JCB *p,int m) //运行作业

{

if(p==ready) //先将要运行的作业从队列中分离出来

{

ready=p->next;

p->next=NULL;

}

else

{

q=ready;

while(q->next!=p) q=q->next;

q->next=p->next;

}

p->starttime=times; //计算作业运行后的完成时间,周转时间等等

p->state='R';

p->finishtime=p->starttime+p->needtime;

p->cycletime=(int)(p->finishtime-p->reachtime);

p->cltime=(int)(p->cycletime/p->needtime);

T1+=p->cycletime;

T2+=p->cltime;

disp(p,m); //调用disp()函数,显示作业运行情况

times+=p->needtime;

p->state='F';

printf("\n\n%s was finished!\n",p->name);

free(p); //释放运行后的作业

getch();

}

void super() //计算队列中作业的高响应比

18

19

{

JCB *padv; padv=ready;

do{ if(padv->state=='W'&&(padv->reachtime)<=times) { padv->super=(float)(times-padv->reachtime+padv->needtime)/padv->needtime;

}

padv=padv->next; }while(padv!=NULL); }

五、实验效果

先来先服务（FCFS ）：

时间片Nowtime=0时，运行A （先来先服务原则）。

时间片Nowtime=35时，C 被阻塞（内存不足），先运行D 。

20

短作业优先（SJF）：

时间片Nowtime=0时，运行A（只有A到达）。

时间片Nowtime=30时。

21

高响应比算法（HRN ）：

输入相应的作业名字，及其需要的时间。默认有4个作业。

第一个任务进入CPU 运行：

根据HRN计算运行程序：

六、失败案例

一、running()函数算法问题：

显然，ftime=nowtime-p->rtime是错误的，因为：若出现W,W（即排队现象）那么后者他的ftime明显不是nowtime-p->rtime，因为他等待了若干时间，于是使用lftime（last finish time）这个全局int变量由上一个指针来定制他的内涵：即当成功调用上一次running函数里的finish块（即把'W'变成'F'的if语句块）的时候，记录此时的nowtime，并且得到更加准确的公式：ftime=nowtime-lftime.这样就避免了W,W现象而影响队列的不正确'F'时间。

running() 即问题1还有后续问题：若出现R,R情况（即多重运行），那么明显的，这个lftime又会被打乱：即后者的R会受到影响，导致‘F'时间变化。所以在此在PCB结构体中加入了stime（start time）此时：当nowtime-p->stime>=p->rtime，即是完成态。

二、sendsource()函数算法问题：

短作业优先算法核心语句:min=min<(p->rtime)?min:(p->rtime); 而后续使用while与if 来确定某一处于'W'的任务是否满足：1、min==p->rtime 2、内存够用3、磁盘够用。于是出现很明显的弊端，即是问题2 中的后者情况：A->C->B，在此我选择了使用额外一个循环，此循环判断条件抛弃了1、，只有2、3、属于牵强做法。

22

计算机学院网络工程专业 2 班学号：X

姓名：X 协作者：________ 教师评定：

实验题目___实验三、储存管理空间的分配与回收模拟

一、实验目的

1、通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解。熟悉虚存管理的各种液面淘汰算法。

2、通过编写和调试地址转换过程的模拟程序以加强对地址转换过程的了解。

3、熟悉主存的分配与回收。理解在不同的储存管理方式下，如何实现主存空间的分配与回收。掌握动态分区分配方式中的数据结构和分配算法及动态分区储存管理方式及其实现过程。

二、实验原理

设计一个请求页式存储管理方案。并编写模拟程序实现之。产生一个需要访问的指令地址流。它是一系列需要访问的指令的地址。为不失一般性，你可以适当地（用人工指定地方法或用随机数产生器）生成这个序列，似的50%的指令时顺序执行的。25%的指令均匀地散布在前地址部分，25%的地址是均匀地散布在后面地址部分。

具体的做法可以是：

产生一个需要访问的指令地址流；指令合适的页面尺寸（例如以1K或2K为1页）；指定内存页表的最大长度，并对页表进行初始化；每访问一个地址时，首先要计算该地址所在的页的页号，然后查页表，判断该页是否打印页表情况；如果该页不足主存且页表已满，则按FIFO页面淘汰算法淘汰一页后调入所需的页，打印页表情况；逐个地址访问，知道所有地址访问完毕。

主存的分配和回收的实现是与主存储器的管理方式有关的，所谓分配，就是解决多道作业或多道进程如何共享主存空间的问题。所谓回收，就是当作业运行完成时将作业或进程所占的主存空间归还给系统。

实验要求使用可变分区储存管理方式，分区分配中所用的数据结构采用空闲分区表和控线分区链来进行，分区分配中所用的算法采用首次适应算法、最佳适应算法两种算法来实现主存的分配与回收。同时，要求设计一个试用友好的用户界面，并显示分配与回收的过程。

三、实验方法、步骤、方案

1、设计一个可变式分区分配的存储管理方案。并模拟实现分区的分配和回收过程。

对分区的管理法可以是下面三种算法之一：

首次适应算法

最佳适应算法

2、编写并调试一个段页式存储管理的地址转换的模拟程序。首先设计好段表、页表，然后给出若干个有一定代表性的地址，通过查找段表页表后得到转换的地址。要求打印转换前的地址，相应的段表，页表条款及转换后的地址，以便检查。

[示例]：存储管理算法的流程图如下：

23