操作系统实验.docx

操作系统实验.docx

《操作系统实验.docx》由会员分享，可在线阅读，更多相关《操作系统实验.docx（71页珍藏版）》请在冰豆网上搜索。

操作系统实验

计算机操作系统实验指导

实验一进程管理

1．目的和要求

加强对进程概念的理解。

2．实验内容

至少要有：

创建新的进程；查看运行进程；换出某个进程；杀死运行进程以及进程之间通信等功能。

3．实验环境

Windows、DOS系统

TC语言

4．实验提示

PCB结构通常包括以下信息：

进程名，进程优先数，轮转时间片，进程所占用的CPU时间，进程的状态，当前队列指针等。

可根据实验的不同，PCB结构的内容可以作适当的增删。

主体程序

#include"conio.h"

#include"stdio.h"

#include"stdlib.h"

structjincheng_type

{intpid;

intyouxian;

intdaxiao;………};

structjincheng_typeneicun[20];

intshumu=0,pid_l;

main（）

{

intn,m,i;

chara;

n=1;

while（n==1）

{

clrscr（）;

printf（"\n********************************************"）;

printf（"\n*进程演示系统*"）;

printf（"\n********************************************"）;

printf（"\n1.创建新的进程2.查看运行进程"）;

printf（"\n3.换出某个进程4.杀死运行进程"）;

printf（"\n5.进程之间通信6.退出系统"）;

printf（"\n********************************************"）;

printf（"\n请选择（1～6）"）;

a=getche（）;

switch（a）

{case'1':

create（）;

break;

case'2':

run（）;

break;

case'3':

huanchu（）;

break;

case'4':

kill（）;

break;

case'5':

tongxun（）;

break;

case'6':

exit（0）;

default:

n=0;

}

}

}

create（）/*创建一个进程的示例（不完整的程序）*/

{

if（shumu>=20）

{

printf（"\n内存已满，请先结束或换出进程\n"）;

}

else

{

printf（"\n请输入新进程的pid\n"）;

scanf（"%d",&neicun[shumu-1].pid）;

printf（"\n请输入新进程的优先级\n"）;

scanf（"%d",&neicun[shumu-1].youxian）;

printf（"\n请输入新进程的大小\n"）;

scanf（"%d",&neicun[shumu-1].daxiao）;

shumu++;

}

}

5．实验运行结果

********************************************

*进程演示系统*

********************************************

1.创建新的进程2.查看运行进程

3.换出某个进程4.杀死运行进程

5.进程之间通信6.退出系统

********************************************

请选择（1～6）

然后根据你选择的不同，出现不同的结果。

实验二进程调度

1．目的和要求

进程调度是处理机管理的核心内容。

本实验要求用C语言编写和调试一个简单的进程调度程序。

通过本实验可以加深理解有关进程控制块、进程队列的概念，并体会和了解优先数和时间片轮转调度算法的具体实施办法。

2．实验内容

①设计进程控制块PCB表结构（与实验一的结构相同），分别适用于优先数调度算法和循环轮转调度算法。

②建立进程就绪队列。

对两种不同算法编制入链子程序。

③编制两种进程调度算法：

1）优先数调度；2）循环轮转调度

3．实验环境

同实验一

4．实验提示

①本程序用两种算法对五个进程进行调度，每个进程可有三个状态，并假设初始状态为就绪状态。

②为了便于处理，程序中的某进程运行时间以时间片为单位计算。

各进程的优先数或轮转时间数以及进程需运行的时间片数的初始值均由用户给定。

③在优先数算法中，优先数可以先取值为98，进程每执行一次，优先数减3，CPU时间片数加1，进程还需要的时间片数减1。

在轮转算法中，采用固定时间片（即：

每执行一次进程，该进程的执行时间片数为已执行了2个单位），这时，CPU时间片数加2，进程还需要的时间片数减2，并排列到就绪队列的尾上。

④对于遇到优先数一致的情况，采用FIFO策略解决。

5．实验运行结果

TYPETHEALGORITHM（PRIORITY/ROUNDROBIN）:

若选择了PRIORITY（优先数算法），则进一步显示：

INPUTNAMEANDNEEDTIME

A12

A23

A34

A42

A54

OUTPUTOFPRIORITY：

CPUTIME:

1

NAMECPUTIMENEEDTIMEPRIORITYSTATE

A11145working

A20347ready

A30446ready

A40248ready

A50446ready

CPUTIME:

2

NAMECPUTIMENEEDTIMEPRIORITYSTATE

A12145ready

A20347ready

A30446ready

A41145working

A50446ready

CPUTIME:

3

NAMECPUTIMENEEDTIMEPRIORITYSTATE

A13145ready

A21244working

A30446ready

A42245ready

A50446ready

CPUTIME:

4

NAMECPUTIMENEEDTIMEPRIORITYSTATE

A14145working

A22244ready

A30446ready

A43245ready

A50446ready

CPUTIME:

5

NAMECPUTIMENEEDTIMEPRIORITYSTATE

A15145ready

A23244ready

A31343working

A44245ready

A50446ready

CPUTIME:

6

NAMECPUTIMENEEDTIMEPRIORITYSTATE

A16145ready

A24244ready

A32343ready

A45245ready

A51343working

CPUTIME:

7

NAMECPUTIMENEEDTIMEPRIORITYSTATE

A17042finish

A25244ready

A33343ready

A46245ready

A52343ready

CPUTIME:

8

NAMECPUTIMENEEDTIMEPRIORITYSTATE

A17042finish

A26244ready

A34343ready

A47142working

A53343ready

CPUTIME:

9

NAMECPUTIMENEEDTIMEPRIORITYSTATE

A17042finish

A27141working

A35343ready

A48142ready

A54343ready

CPUTIME:

10

NAMECPUTIMENEEDTIMEPRIORITYSTATE

A17042finish

A29141ready

A37240working

A49142ready

A55343ready

CPUTIME:

11

NAMECPUTIMENEEDTIMEPRIORITYSTATE

A17042finish

A210141ready

A38240ready

A410142ready

A56240working

CPUTIME:

12

NAMECPUTIMENEEDTIMEPRIORITYSTATE

A17042finish

A211141ready

A39240ready

A411039finish

A57240ready

CPUTIME:

13

NAMECPUTIMENEEDTIMEPRIORITYSTATE

A17042finish

A212038finish

A39240ready

A411042finish

A57240ready

CPUTIME:

13

NAMECPUTIMENEEDTIMEPRIORITYSTATE

A17042finish

A212038finish

A310137working

A411042finish

A58240ready

CPUTIME:

14

NAMECPUTIMENEEDTIMEPRIORITYSTATE

A17042finish

A212038finish

A311137ready

A411042finish

A59137working

CPUTIME:

15

NAMECPUTIMENEEDTIMEPRIORITYSTATE

A17042finish

A212038finish

A312034finish

A411042finish

A510137ready

CPUTIME:

16

NAMECPUTIMENEEDTIMEPRIORITYSTATE

A17042finish

A212038finish

A312034finish

A411042finish

A511034finish

若选择了ROUNDROBIN（时间片轮转算法），则进一步显示：

INPUTNAMEANDNEEDTIME

A12

A23

A34

A42

A54

OUTPUTOFROUNDROBIN：

NAMECPUTIMENEEDTIMECOUNTSTATE

……………

NAMECPUTIMENEEDTIMECOUNTSTATE

……………

时间片轮转调度算法输出与上大致相同，但要将PRIORITY项换为COUNT项。

有关实验的改进意见:

在实验操作过程中，发现用户输入的数据量太大且每次用户输入的大多数数据为重复数据，因此考虑采用文件输入方式，用户只需指定特定的输入文件的文件名来输入数据。

另一方面，程序的输出量较大，可以考虑采用文件输出的方式来储存程序的运行结果。

也可以用实时的输出界面来输出程序结果。

实验二的示例程序如下：

#include

#include

#include

#include

#include

#defineP_NUM5

#defineP_TIME50

enumstate{

ready,

execute,

block,

finish

};

structpcb{

charname[4];

intpriority;

intcputime;

intneedtime;

intcount;

intround;

stateprocess;

pcb*next;

};

pcb*get_process（）;

pcb*get_process（）{

pcb*q;

pcb*t;

pcb*p;

inti=0;

cout<<"inputnameandtime"<

while（i

q=（structpcb*）malloc（sizeof（pcb））;

cin>>q->name;

cin>>q->needtime;

q->cputime=0;

q->priority=P_TIME-q->needtime;

q->process=ready;

q->next=NULL;

if（i==0）{

p=q;

t=q;

}

else{

t->next=q;

t=q;

}

i++;

}//while

returnp;

}

voiddisplay（pcb*p）{

cout<<"name"<<""<<"cputime"<<""<<"needtime"<<""<<"priority"<<""<<"state"<

while（p）{

cout<name;

cout<<"";

cout<cputime;

cout<<"";

cout<needtime;

cout<<"";

cout<priority;

cout<<"";

switch（p->process）{

caseready:

cout<<"ready"<

caseexecute:

cout<<"execute"<

caseblock:

cout<<"block"<

casefinish:

cout<<"finish"<

}

p=p->next;

}

}

intprocess_finish（pcb*q）{

intbl=1;

while（bl&&q）{

bl=bl&&q->needtime==0;

q=q->next;

}

returnbl;

}

voidcpuexe（pcb*q）{

pcb*t=q;

inttp=0;

while（q）{

if（q->process!

=finish）{

q->process=ready;

if（q->needtime==0）{

q->process=finish;

}

}

if（tppriority&&q->process!

=finish）{

tp=q->priority;

t=q;

}

q=q->next;

}

if（t->needtime!

=0）{

t->priority-=3;

t->needtime--;

t->process=execute;

t->cputime++;

}

}

voidpriority_cal（）{

pcb*p;

clrscr（）;

p=get_process（）;

intcpu=0;

clrscr（）;

while（!

process_finish（p））{

cpu++;

cout<<"cputime:

"<

cpuexe（p）;

display（p）;

sleep

（2）;

clrscr（）;

}

printf（"Allprocesseshavefinished,pressanykeytoexit"）;

getch（）;

}

voiddisplay_menu（）{

cout<<"CHOOSETHEALGORITHM:

"<

cout<<"1PRIORITY"<

cout<<"2ROUNDROBIN"<

cout<<"3EXIT"<

}

pcb*get_process_round（）{

pcb*q;

pcb*t;

pcb*p;

inti=0;

cout<<"inputnameandtime"<

while（i

q=（structpcb*）malloc（sizeof（pcb））;

cin>>q->name;

cin>>q->needtime;

q->cputime=0;

q->round=0;

q->count=0;

q->process=ready;

q->next=NULL;

if（i==0）{

p=q;

t=q;

}

else{

t->next=q;

t=q;

}

i++;

}//while

returnp;

}

voidcpu_round（pcb*q）{

q->cputime+=2;

q->needtime-=2;

if（q->needtime<0）{

q->needtime=0;

}

q->count++;

q->round++;

q->process=execute;

}

pcb*get_next（pcb*k,pcb*head）{

pcb*t;

t=k;

do{

t=t->next;

}

while（t&&t->process==finish）;

if（t==NULL）{

t=head;

while（t->next!

=k&&t->process==finish）{

t=t->next;

}

}

returnt;

}

voidset_state（pcb*p）{

while（p）{

if（p->needtime==0）{

p->process=finish;

}

if（p->process==execute）{

p->process=ready;

}

p=p->next;

}

}

voiddisplay_round（pcb*p）{

cout<<"NAME"<<""<<"CPUTIME"<<""<<"NEEDTIME"<<""<<"COUNT"<<""<<"ROUND"<<""<<"STATE"<

while（p）{

cout<name;

cout<<"";

cout<cputime;

cout<<"";

cout<needtime;

cout<<"";

cout<count;

cout<<"";

cout<round;

cout<<"";

switch（p->process）{

caseready:

cout<<"ready"<

caseexecute:

cout<<"execute"<

casefinish:

cout<<"finish"<

}

p=p->next;

}

}

voidround_cal（）{

pcb*p;

pcb*r;

clrscr（）;

p=get_process_round（）;

intcpu=0;

clrscr（）;

r=p;

while（!

process_finish（p））{

cpu+=2;

cpu_round（r）;

r=get_next（r,p）;

cout<<"cpu"<

display_round（p）;

set_state（p）;

sleep（5）;

clrscr（）;

}

}

voidmain（）{

display_menu（）;

intk;

scanf（"%d",&k）;

switch（k）{

case1:

priority_cal（）;break;

case2:

round_cal（）;break;

case3:

break;

display_menu（）;

scanf（"%d",&k）;

}

}

1．目的和要求

存储管理的主要功能之一是合理地分配空间。

请求页式管理是一种常用的虚拟存储管理技术。

本实验的目的是通过请求页式存储管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式管理的页面置换算法。

2．实验内容

1．过随机数产生一个指令序列，共320条指令。

其地址按下述原则生成：

①50%的指令是顺序执行的；

②25%的指令是均匀分布在前地址部分；

③25%的指令是均匀分布在后地址部分；

#具体的实施方法是：

A.在[0，319]的指令地址之间随机选区一起点M;

B.顺序执行一条指令，即执行地址为M+1的指令；

C.在前地址[0，M+1]中随机选取一条指令并执行，该指令的地址为M’;

D.顺序执行一条指令，其地址为M’+1；

E.在后地址[M’+2，319]中随机选取一条指令并执行；

F.重复A—E，直到执行320次指令。

2．指令序列变换成页地址流

设：

（1）页面大小为1K；

（2）用户内存容量为4页到32页；

（3）用户虚存容量为32K。

在用户虚存中，按每K存放10条指令排列虚存地址，即320条指令在虚存中的存放方式为：

第0条—第9条指令为第0页（对应虚存地址为[0，9]）；

第10条—第19条指令为第1页（对应虚存地址为[10，19]）；

。

。

。

。

。

。

。

。

。

。

。

。

。

。

。

。

。

。

。

。

。

第310条—第319条指令为第31页（对应虚存地址为[310，319]）；

按以上方式，用户指令可组成32页。

3.计算并输出下述各种算法在不同内存容量下的命中率。

A.FIFO先进先出的算法

B.LRR最近最少使用算法

C.LFR最少访问页面算法

3．实