操作系统实验指导书文档格式.docx

操作系统实验指导书文档格式.docx

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

intnumlabel;

charproduct;

charstate;

structpcb*processlink;

}*exe=NULL,*over=NULL;

typedefstructpcbPCB;

PCB*readyhead=NULL,*readytail=NULL;

PCB*consumerhead=NULL,*consumertail=NULL;

PCB*producerhead=NULL,*producertail=NULL;

//产品数量

intproductnum=0;

intfull=0,empty=buffersize;

//semaphore

charbuffer[buffersize];

//缓冲区

intbufferpoint=0;

//缓冲区指针

voidlinkqueue（PCB*process,PCB**tail）;

PCB*getq（PCB*head,PCB**tail）;

boolhasElement（PCB*pro）;

voiddisplay（PCB*p）;

voidlinklist（PCB*p,PCB*listhead）;

voidfreelink（PCB*linkhead）;

boolprocessproc（）;

boolwaitempty（）;

boolwaitfull（）;

voidsignalempty（）;

voidsignalfull（）;

voidproducerrun（）;

voidcomsuerrun（）;

voidlinklist（PCB*p,PCB*listhead）

{

PCB*cursor=listhead;

while（cursor->

processlink!

=NULL）{

cursor=cursor->

processlink;

}

cursor->

processlink=p;

}

voidfreelink（PCB*linkhead）

PCB*p;

while（linkhead!

p=linkhead;

linkhead=linkhead->

free（p）;

voidlinkqueue（PCB*process,PCB**tail）

if（（*tail）!

（*tail）->

processlink=process;

（*tail）=process;

else{

printf（"

队列未初始化！

"

）;

}

PCB*getq（PCB*head,PCB**tail）

p=head->

if（p!

head->

processlink=p->

p->

processlink=NULL;

if（head->

processlink==NULL）

（*tail）=head;

else

returnNULL;

returnp;

boolprocessproc（）

inti,f,num;

charch;

PCB*p=NULL;

PCB**p1=NULL;

\n请输入希望产生的进程个数?

scanf（"

%d"

&

num）;

getchar（）;

for（i=0;

i<

num;

i++）

{printf（"

\n请输入您要产生的进程：

输入1为生产者进程；

输入2为消费者进程\n"

f）;

p=（PCB*）malloc（sizeof（PCB））;

if（!

p）{

内存分配失败"

returnfalse;

flag=f;

processnum++;

numlabel=processnum;

state='

w'

;

if（p->

flag==1）{

您要产生的进程是生产者，它是第%d个进程。

请您输入您要该进程产生的字符！

\n"

processnum）;

%c"

ch）;

product=ch;

productnum++;

您要该进程产生的字符是%c\n"

p->

product）;

else{

您要产生的进程是消费者，它是第%d个进程。

numlabel）;

linkqueue（p,&

readytail）;

returntrue;

boolwaitempty（）

if（empty<

=0）

{

进程%d:

缓冲区存数，缓冲区满，该进程进入生产者等待队列\n"

exe->

linkqueue（exe,&

producertail）;

else{

empty--;

voidsignalempty（）

if（hasElement（producerhead））{

p=getq（producerhead,&

等待中的生产者进程进入就绪队列，它的进程号是%d\n"

empty++;

boolwaitfull（）

if（full<

缓冲区取数，缓冲区空，该进程进入消费者等待队列\n"

consumertail）;

full--;

voidsignalfull（）

if（hasElement（consumerhead））{

p=getq（consumerhead,&

等待中的消费者进程进入就绪队列，它的进程号是%d\n"

full++;

voidproducerrun（）

if（!

waitempty（））

return;

进程%d开始向缓冲区存数%c\n"

numlabel,exe->

buffer[bufferpoint]=exe->

product;

bufferpoint++;

进程%d向缓冲区存数操作结束\n"

signalfull（）;

linklist（exe,over）;

voidcomsuerrun（）

waitfull（））

进程%d开始向缓冲区取数\n"

exe->

product=buffer[bufferpoint-1];

bufferpoint--;

进程%d向缓冲区取数操作结束，取数是%c\n"

signalempty（）;

voiddisplay（PCB*p）

p=p->

while（p!

进程%d，它是一个"

flag==1?

生产者\n"

）:

printf（"

消费者\n"

boolhasElement（PCB*pro）

if（pro->

processlink==NULL）

elsereturntrue;

voidmain（）

{

charterminate;

boolelement;

你想开始程序吗?

（y/n）"

terminate）;

//Queueinitialize;

readyhead=（PCB*）malloc（sizeof（PCB））;

if（readyhead==NULL）return;

readytail=readyhead;

readyhead->

flag=3;

consumerhead=（PCB*）malloc（sizeof（PCB））;

if（consumerhead==NULL）return;

consumertail=consumerhead;

consumerhead->

flag=4;

producerhead=（PCB*）malloc（sizeof（PCB））;

if（producerhead==NULL）return;

producertail=producerhead;

producerhead->

flag=5;

over=（PCB*）malloc（sizeof（PCB））;

if（over==NULL）return;

over->

while（terminate=='

y'

）

{

processproc（））break;

element=hasElement（readyhead）;

while（element）{

exe=getq（readyhead,&

进程%d申请运行，它是一个"

if（exe->

flag==1）

producerrun（）;

else

comsuerrun（）;

就绪队列没有进程\n"

if（hasElement（consumerhead））

{printf（"

消费者等待队列中有进程:

display（consumerhead）;

消费者等待队列中没有进程\n"

if（hasElement（producerhead））

生产者等待队列中有进程:

display（producerhead）;

生产者等待队列中没有进程\n"

你想继续吗?

（press'

foron）"

\n\n进程模拟完成.\n"

//Freetheroom;

freelink（over）;

over=NULL;

freelink（readyhead）;

readyhead=NULL;

readytail=NULL;

freelink（consumerhead）;

consumerhead=NULL;

consumertail=NULL;

freelink（producerhead）;

producerhead=NULL;

producertail=NULL;

三、实验结果与讨论

输入测试数据，分析产生不同结果的原因。

实验二：

处理机调度

验证

掌握常用作业调度算法的实现过程。

调度算法有FIFO，优先数调度算法，时间片轮转调度算法，分级调度算法。

进程调度算法的数据结构主要有：

进程函数定义，建立进程函数，进程调度函数。

已给出FIFO调度算法的实现代码，根据此代码完成优先权调度算法（静态或动态）的实现过程。

源代码：

#definemax100

#definepfree0/*processend*/

#definerunning1/*processrunningstatus*/

#defineaready2/*processareadystatus*/

#defineblocking3/*processareadyblockingstatus*/

typedefstructnode

charname;

intstatus;

intprecendence;

intax,bx,cx,dx;

intpc;

intpsw;

structnode*next;

/*pcbdefine*/

}pcb;

pcb*createprocess（pcb*head）

pcb*p,*q;

inta,b,c,d,m,n;

charID;

ints;

q=NULL;

\ninputthefirstsevenstatuspcb:

scanf（"

\n%c"

ID）;

%d%d%d%d%d%d"

a,&

b,&

c,&

d,&

m,&

n）;

while（ID!

='

*'

p=（pcb*）malloc（sizeof（pcb））;

name=ID;

ax=a;

bx=b;

cx=c;

dx=d;

pc=m;

psw=n;

precendence=pfree;

status=aready;

if（head==NULL）

head=p;

else

q->

next=p;

q=p;

\ninputthenextpcb:

"

}

if（q!

=NULL）

next=NULL;

q=head;

while（q）

\npeocessname.status.ax.bx.cx.dx.pc.psw.\n"

%10c%5d%8d%5d%5d%5d%5d%5d%5d"

q->

name,q->

status,q->

precendence,q->

ax,q->

bx,q->

cx,q->

dx,q->

pc,q->

psw）;

q=q->

next;

returnhead;

/*createprocessend*/

voidprocessfifo（pcb*head）/*usefifo*/

pcb*p;

p=head;

\ntheprocessusefifomethod.\n"

runningthefirstprocess:

while（p!

p->

status=running;

\nprocessnamestatus.ax.bx.cx.dx.pc.psw."

\n%10c%5d%8d%5d%5d%5d%5d%5d"

name,p->

status,p->

ax,p->

bx,p->

cx,p->

dx,p->

pc,p->

/*checkprocessrunningstatus*/

status=0;

p=p->

\ncheckweatherfertheprocesscomplete:

while（p）

\n%3c%3d"

status）;

\ngameisover!

intmain（void）

pcb*head;

head=NULL;

head=createprocess（head）;

processfifo（head）;

return0;

实验三：

存储器管理

掌握动态可变分区的算法与实现过程。

模拟存储管理中内存空间的管理和分配内存空间的管理分为固定分区管理方式，可变分区管理方式，页式存储管理，段式存储管理。

#include<

stdio.h>

conio.h>

stdlib.h>

#definen10/*假定系统允许的最大作业为，假定模拟实验中n值为10*/

#definem10/*假定系统允许的空闲区表最大为m，假定模拟实验中m值为10*/

#defineminisize100

struct

floataddress;

/*已分分区起始地址*/

floatlength;

/*已分分区长度，单位为字节*/

intflag;

/*已分配区表登记栏标志，用"

0"

表示空栏目*/

}used_table[n];

/*已分配区表*/

/*空闲区起始地址*/

/*空闲区长度，单位为字节*/

/*空闲区表登记栏标志，用"

表示空栏目，用"

1"

表示未分配*/

}free_table[m];

/*空闲区表*/

allocate（charJ,floatxk）

/*采用最优分配算法分配xk大小的空间*/

inti,k;

floatad;

k=-1;

m;

i++）/*寻找空间大于xk的最小空闲区登记项k*/

if（free_table[i].length>

=xk&

&

free_table[i].flag==1）

if（k==-1||free_table[i].length<

free_table[k].length）

k=i;

if（k==-1）/*未找到可用空闲区，返回*/

无可用空闲区\n"

/*找到可用空闲区，开始分配：

若空闲区大小与要求分配的空间差小于msize大小，则空闲区全部分配；

若空闲区大小与要求分配的空间差大于minisize大小，则从空闲区划出一部分分配*/

if（free_table[k].length-xk<

=minisize）

free_table[k].flag=0;

ad=free_table[k].address;

xk=free_table[k].length;

free_table[k].length=free_table[k].length-xk;

ad=free_table[k].address+free_table[k].length;

/*修改已分配区表*/

i=0;

while（used_table[i].flag!

=0&

n）/*寻找空表目*/

i++;

if（i>

=n）/*无表目填写已分分区*/

print