操作系统实验1.docx

操作系统实验1.docx

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

操作系统实验1

《操作系统》实验指导书

一、多道程序的转换调度（学时2）

实现多道程序的转换调度

题目要求：

（作业调度和进程调度结合在一起）

1、作业流信息是从指定文本文件（TXT文件）中读取

作业信息：

作业号进入系统时间估计运行时间优先级内存需求量磁带机需求量都为整型

2、作业调度算法：

1、先来先服务；2、最短作业优先（二者选一）

进程调度算法：

1、先来先服务；2、基于优先级的算法（静态优先级）（二者选一）

3、输出：

作业序列

格式：

作业号时间间隔

1800-810（/*8：

00-8：

10*/）

2810-900

1900-930

平均周转时间：

总的周转时间/作业总数

周转时间就是作业结束时间减去作业进入系统时间

示例：

#include

#include

#include

#include

#include

#definenull0

#definelensizeof（structjnote）

structjcb

{

intstate;

intnum;

intin;

intrun;

intpri;

intmem;

inttape;

}job[50];

structjnote

{

intid;

intin;

intstart;

intrun;

intend;

intpri;

intsize;

inttape;

int*maddr;

structjnote*next;

};

intrest=4,memory[101],*mh=memory,logo=0,fid=0;

structjcb*p=job;

structjnote*jh=null,*rp=null,*jp=null;

txt（）/*从txt文件中作业流*/

{

FILE*fp;

charpt;

inti,space=0,j=0,data[100],h,k,count;

charstr[10];

for（i=0;i<100;i++）data[i]=-1;

for（i=0;i<20;i++）

{

job[i].num=-1;

job[i].tape=-1;

job[i].state=-1;

}

i=0;

fp=fopen（"job.txt","r+"）;

if（fp==NULL）

{

printf（"Cann'tthefile\n"）;

exit（0）;

}

while（（pt=getc（fp））!

=EOF）

{

if（pt>='0'&&pt<='9'）

{

str[i]=pt;

i++;

space=0;

}

else

{

if（pt==''||pt=='\n'）

{

if（space==1）continue;

else

{

str[i]='\0';

data[j]=atoi（str）;

j++;

i=0;

space=1;

}

}

}

}

for（h=0,k=0;data[k]!

=-1;k++,h++）

{

job[h].num=data[k];k++;

job[h].in=data[k];k++;

job[h].run=data[k];k++;

job[h].pri=data[k];k++;

job[h].mem=data[k];k++;

job[h].tape=data[k];

}

if（job[h-1].tape==-1）

{

str[i]='\0';

job[h-1].tape=atoi（str）;

}

clrscr（）;

for（i=0;job[i].num!

=-1;i++）;

return（i）;

}

rpend（start,run）/*计算进程的结束时间*/

intstart,run;

{

intend=0;

inti=start%100+run;

end=（start/100+i/60）*100+i%60;

return（end）;

}

time_time（end,in）/*计算周转时间或计算剩余的运行时间*/

intin,end;

{

inttime;

time=end/100*60+end%100-（in/100*60+in%100）;

return（time）;

}

int*m_pd（intsize）/*内存判断*/

{

int*mp,*cp;

inti=0;

mp=cp=mh;

while（*mp!

=-1）

{

while（*cp==0）

{

cp++;i++;

}

if（i>=size）return（mp）;

while（*cp==1）cp++;

mp=cp;

}

return（null）;

}

zy_div_free（mp,msize,tape,h）/*资源分配与释放*/

int*mp,msize,tape,h;

{

int*cp,i=msize;

cp=mp;

if（h==1）

{

for（;i>0;i--）

{

*cp=1;cp++;

}

rest=rest-tape;

return

（1）;

}

if（h==2）

{

for（;i>0;i--）

{

*cp=0;cp++;

}

rest=rest+tape;

return

（2）;

}

}

selectrp（plogo,time）/*选择当前运行进程*/

intplogo,time;

{

structjnote*newj;

structjnote*temp;

if（jh==null&&rp==null）

{

p=job;

for（;p->state==0;）p++;

zy_div_free（mh,p->mem,p->tape,1）;

p->state=0;

newj=（structjnote*）malloc（len）;

rp=newj;

rp->id=p->num;rp->in=p->in;rp->start=p->in;rp->run=p->run;rp->end=0;rp->pri=p->pri;rp->size=p->mem;rp->tape=p->tape;

rp->maddr=mh;rp->next=null;

return（0）;

}

else

{

if（jh!

=null&&rp==null）

{

rp=jh;

jh=jh->next;

rp->next=null;

rp->start=time;

if（plogo==2）selectrp（plogo,time）;

elsereturn（-1）;

}

else

{

if（jh!

=null&&rp!

=null）

{

if（plogo==2）

{

if（logo==0）

{

if（jh->pri>rp->pri）

{

temp=jh;

jh=jh->next;

temp->next=rp;

printf（"%d:

%d---%d\n",rp->id,rp->start,temp->in）;

rp->run-=time_time（temp->in,rp->start）;

rp->start=0;

rp=temp;

rp->start=rp->in;

return（0）;

}

}

if（fid==1）

{

if（jh->pri>rp->pri）

{

temp=jh;

jh=jh->next;

temp->next=rp;

rp=temp;

rp->start=time;

selectrp（plogo,time）;

}

else

{

rp->start=time;

return（0）;

}

}

}

return（0）;

}

else

{

rp->start=time;

return（0）;

}

}

}

return（0）;

}

WORK（jlogo,plogo,count）

intjlogo,plogo,count;

{

intk=count,sum=0,time,t;/*sum是周转时间之和*/

structjnote*cp,*p1,*newj;

int*mp;

selectrp（plogo,0）;

while（k>0）

{

p=job;

do

{

if（p->state==0）p++;

while（p->state==-1&&p->num!

=-1&&（（logo==0&&p->instart,rp->run））||（logo==1&&p->in<=rpend（rp->start,rp->run））））

{

mp=m_pd（p->mem）;

if（rest>=p->tape）t=1;

elset=0;

if（mp!

=null&&t==1）

{

zy_div_free（mp,p->mem,p->tape,1）;

p->state=0;

newj=（structjnote*）malloc（len）;

newj->id=p->num;newj->in=p->in;newj->start=0;newj->run=p->run;newj->end=0;

newj->pri=p->pri;newj->size=p->mem;newj->tape=p->tape;newj->maddr=mp;newj->next=null;

if（jh==null）

{

jh=newj;jp=jh;

}

else

{

if（jlogo==1）{jp->next=newj;jp=newj;}/*作业为FCFS*/

else/*作业为最短运行时间优先*/

{

jp=cp=jh;

if（newj->run>=jp->run&&jp->next!

=null）

{

cp=jp;jp=jp->next;

}

else

{

if（newj->runrun）

{

if（cp==jp）

{

newj->next=jp;jh=newj;

}

else

{

cp->next=newj;newj->next=jp;

}

}

elsejp->next=newj;

}

}

}

if（plogo==2）selectrp（plogo,0）;

}

p++;

}

}while（p->state==0）;

if（logo==0）

{

zy_div_free（rp->maddr,rp->size,rp->tape,2）;

logo=1;

}

else

{

rp->end=rpend（rp->start,rp->run）;/*此时计算结束时间*/

printf（"%d:

%d---%d\n",rp->id,rp->start,rp->end）;

sum+=time_time（rp->end,rp->in）;/*计算周转时间总和*/

if（k-1==0）

{

p1=rp;rp=rp->next;free（p1）;break;

}

time=rp->end;

p1=rp;

rp=rp->next;

free（p1）;

k--;

fid=1;

selectrp（plogo,time）;

fid=0;

logo=0;

}

}

printf（"Theaveragetime:

%d\n",sum/count）;

}

init（）

{

inti;

for（i=0;job[i].num!

=-1;i++）job[i].state=-1;

logo=0;fid=0;

}

main（）

{

inti,count;

count=txt（）;/*返回作业总数*/

for（i=0;i<100;i++）memory[i]=0;memory[i]=-1;mh=memory;/*内存清0，处于未分配状态，最后一个用于标识*/

printf（"Job_Process\n\n"）;

printf（"FCFS_FCFS:

\n"）;

WORK（1,1,count）;/*作业FCFS,进程FCFS*/

init（）;

printf（"\nSHORT_FCFS:

\n"）;

WORK（2,1,count）;/*作业最短运行时间优先,进程FCFS*/

printf（"\n\nPleasepresskeybordtoseetheresultofprocessisPRI"）;

getchar（）;

clrscr（）;

init（）;

printf（"Job_Process\n"）;

printf（"\nFCFS_PRI:

\n"）;

WORK（1,2,count）;

init（）;

printf（"\nSHORT_PRI:

\n"）;

WORK（2,2,count）;

getchar（）;

}

二、进程调度（学时2）

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

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

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

示例：

#include"stdio.h"

#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;

printf（"\ninputthefirstsevenstatuspcb:

"）;

scanf（"\n%c",&ID）;

scanf（"%d%d%d%d%d%d",&a,&b,&c,&d,&m,&n）;

while（ID!

='*'）

{

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

p->name=ID;

p->ax=a;

p->bx=b;

p->cx=c;

p->dx=d;

p->pc=m;

p->psw=n;

p->precendence=pre;

p->status=aready;

if（head==NULL）

head=p;

else

q->next=p;

q=p;

printf（"\ninputthenextpcb:

"）;

scanf（"\n%c",&ID）;

scanf（"%d%d%d%d%d%d",&a,&b,&c,&d,&m,&n）;

}

if（q!

=NULL）

q->next=NULL;

q=head;

while（q）

{

printf（"\npeocessname.status.ax.bx.cx.dx.pc.psw.\n"）;

printf（"%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;

printf（"\ntheprocessusefifomethod.\n"）;

printf（"runningthefristprocess:

\n"）;

while（p!

=NULL）

{

p->status=running;

printf（"\nprocessnamestatus.ax.bx.cx.dx.pc.psw."）;

printf（"\n%10c%5d%8d%5d%5d%5d%5d%5d",p->name,p->status,p->ax,p->bx,p->cx,p->dx,p->pc,p->psw）;/*checkprocessrunningstatus*/

p->status=0;

p=p->next;

}

printf（"\ncheckweatherfertheprocesscomplete:

"）;

p=head;

while（p）

{

printf（"\n%3c%3d",p->name,p->status）;

p=p->next;

}

printf（"\ngameisover!

\n"）;

}

main（）

{

pcb*head;

head=NULL;

head=createprocess（head）;

processfifo（head）;

}

三、存储器管理（学时2）

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

题目：

模拟内存分配与回收

示例：

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

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

#defineminisize100

struct

{

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

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

intflag;/*已分配区表登记栏标志，用"0"表示空栏目*/

}used_table[n];/*已分配区表*/

struct

{

floataddress;/*空闲区起始地址*/

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

intflag;/*空闲区表登记栏标志，用"0"表示空栏目，用"1"表示未分配*/

}free_table[m];/*空闲区表*/

allocate（J,xk）

charJ;

floatxk;

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

{

inti,k;

floatad;

k=-1;

for（i=0;i

if（free_table[i].length>=xk&&free_table[i].flag==1）

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

k=i;

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

{

printf（"无可用空闲区\n"）;

return;

}

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

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

if（free_table[k].length-xk<=minisize）

{

free_table[k].flag=0;

ad=free_table[k].address;

xk=free_table[k].length;

}

else

{

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&&i

i++;

if（i>=n）/*无表目填写已分分区*/

{

printf（"无表目填写已分分区，错误\n"）;

/*修正空闲区表*/

if（free_table[k].flag==0）

/*前面找到的是整个空闲分区*/

free_table[k].flag=1;

else

{/*前面找到的是某个空闲分区的一部分*/

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

return;

}

}

else

{/*修改已分配表*/

used_table[i].address=ad;

used_table[i].length=xk;

used_table[i].flag=J;

}

return;

}/*主存分配函数结束*/

reclaim（J）

charJ;

/*回收作业名为J的作业所占主存空间*/

{

inti,k,j,s,t;

floatS,L;

/*寻找已分配表中对应登记项*/

s=0;

while（（used_table[s].flag!

=J||used_table[s].flag==0）&&s

s++;

if（s>=n）/*在已分配表中找不到名字为J的作业*/

{

printf（"找不到该作业\n"）;

return;

}

/*修改已分配表*/

used_table[s].flag=0;

/*取得归还分区的起始地址S和长度L*/

S=used_table[s].address;

L=used_table[s].length;

j=-1;k=-1;i=0;

/*寻找回收分区的空闲上下邻，上邻表目k，下邻表目j*/

while（i