操作系统课程设计.docx

操作系统课程设计.docx

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

操作系统课程设计

任务一、进程创建、控制与撤消

一、目的：

通过进程的创建和控制的设计来达到如下目的：

1、加深对进程概念的理解，明确进程和程序的区别；

2、进一步认识并发执行的概念，区别顺序执行和并发执行；

3、分析进程争用临界资源的现象，学习解决进程互斥的方法；

二、内容：

在WINDOWS环境下模拟实验：

1、编写一程序，来模拟进程的创建和撤消，要求通过终端键盘输入三、四作业的名称、大小、优先级等。

系统为它创建进程，并把进程控制块PCB的内容送到终端显示器上输出。

2、同时模拟内存空间为作业分配内存空间，并把结果用图形形象地表示出来，同样通过终端输出。

3、按进程的优先级的顺序撤消进程，同时通过终端显示PCB的撤消过程和内存的释放过程

程序流程图：

源代码如下：

#include;

usingnamespacestd;

structPCB

{

intpid;

intpriority;

intsize;

intdetail;

intisrun;

};

PCBrunning[20],ready[20];

intsum=0,pid_1;

voidchoose（）;

voidmenu（）;

intcreate（）

{

if（sum>=20）

{

cout<<"内存已满，请先结束或换出进程"<

}

else

{

cout<<"请输入第"<

cout<<"请输入进程的pid"<

cin>>running[sum+1].pid;

cout<<"请输入新的进程的优先级"<

cin>>running[sum+1].priority;

cout<<"请输入新的进程的大小"<

cin>>running[sum+1].size;

cout<<"请输入新的进程的详情"<

cin>>running[sum+1].detail;

running[sum+1].isrun=1;

sum++;

}

returnrunning[sum-1].isrun;

choose（）;

}

voiddisplay（）

{

intpid;

cout<<"请输入进程的pid"<

cin>>pid;

if（pid>0&&pid<=20&&running[pid].isrun==1）

{

cout<<"进程的pid是:

"<

cout<<"进程的优先级是:

"<

cout<<"进程的大小是:

"<

cout<<"进程的相关信息:

"<

}

else

{

cout<<"所查看运行进程不存在"<

}

choose（）;

}

voidreplace（）

{

intpid1,pid2;

cout<<"请输入第一个替换进程的pid"<

cin>>pid1;

cout<<"请输入第二个替换进程的pid"<

cin>>pid2;

if（pid1>0&&pid1<=20&&running[pid1].isrun==1）

{

if（running[pid1].priority>running[pid2].priority）{

ready[20].pid=running[pid1].pid;

ready[20].priority=running[pid1].priority;

ready[20].size=running[pid1].size;

ready[20].detail=running[pid1].detail;

running[pid1].pid=running[pid2].pid;

running[pid1].priority=running[pid2].priority;

running[pid1].size=running[pid2].size;

running[pid1].detail=running[pid2].detail;running[pid2].pid=ready[20].pid;running[pid2].priority=ready[20].priority;running[pid2].size=ready[20].size;running[pid2].detail=ready[20].detail;

cout<<"替换完成"<

cout<<"被替换进程的pid是:

"<

cout<<"被替换进程的优先级是:

",ready[20].priority;

cout<<"被替换进程的大小是:

"<

cout<<"被替换进程的详情是:

"<

}

else

{

cout<<"进程优先级不够大"<

}

else

{cout<<"所查看运行进程不存在"<

}

choose（）;

}

voidkill（）

{

intkpid;

cout<<"请输入进程的pid:

";

cin>>kpid;

if（kpid>0&&kpid<20&&running[kpid].isrun==1）

{

running[kpid].isrun=0;

}

choose（）;

}

voidchoose（）{

intchoose;

cout<<"是否继续操作？

继续，请输入1，退出：

按任意键"<

cout<<"请输入你的选择：

";

cin>>choose;

if（choose=1）{

menu（）;

}

else{

exit（0）;

}

}

voidmenu（）{

intn,i;

n=1;

while（n==1）

{

system（"cls"）;

cout<<"进程模拟"<

cout<<"1.创建进程2.查看进程信息"<

cout<<"3.撤销进程4.终止进程"<

cout<<"5.退出"<

cout<<"请输入你的选择：

";

cin>>i;

switch（i）

{

case1:

create（）;break;

case2:

display（）;break;

case3:

replace（）;break;

case4:

kill（）;break;

case5:

exit（0）;

default:

n=0;

}

}

}

intmain（）

{

menu（）;

return0;

}

运行结果如下：

任务三、基本存储器管理

一、目的：

一个好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器，而且要能合理地分配和使用这些存储空间。

当用户提出申请存储器空间时，存储管理必须根据申请者的要求，按一定的策略分析主存空间的使用情况，找出足够的空闲区域分配给申请者。

当作业撤离或主动归还主存资源时，则存储管理要收回作业占用的主存空间或归还部分主存空间。

主存的分配和回收的实现与主存储器的管理方式有关的，通过本实验帮助学生理解在不同的存储管理方式下怎样实现主存的分配和回收。

二、内容：

从下两种存储管理方式的主存分配和回收中，选择一种管理方式来实现本次实验任务：

1、在可变（动态）分区管理方式下，采用最先适应算法。

2、在分页式管理方式下，采用位示图来表示主存的分配情况和回收情况。

程序流程图：

源代码如下：

#include

#include

#definen10//系统最大作业数

#definemaxsize20//空闲区最大内存

#defineminisize100

usingnamespacestd;

struct

{

floataddr;//已分配分区起始地址

floatsize;//已分配分区长度，单位为字节

intflag;

}useed[n];//已分配区表

struct

{

floataddr;//空闲区起始地址

floatsize;//空闲区大小

intflag;//0为空，1未分配

}frees[maxsize];

voidallo（chara,floatxk）

{

inti,k;

floatad;

k=-1;

for（i=0;i

if（frees[i].size>=xk&&frees[i].flag==1）

if（k==-1||frees[i].size

k=i;

if（k==-1）

{

cout<<"无可用空闲区"<

return;

}

if（frees[k].size-xk<=minisize）

{

frees[k].flag=0;

ad=frees[k].addr;

xk=frees[k].size;

}

else

{

frees[k].size=frees[k].size-xk;

ad=frees[k].addr+frees[k].size;

}

i=0;

while（useed[i].flag!

=0&&i

i++;

if（i>=n）

{

cout<<"error,未初始化"<

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

frees[k].flag=1;

else

{

frees[k].size=frees[k].size+xk;

return;

}

}

else

{

useed[i].addr=ad;

useed[i].size=xk;

useed[i].flag=a;

}

return;

}

voidfindc（charx）

{

inti,k,a,s,t;

floatS,L;

s=0;

while（（useed[s].flag!

=x||useed[s].flag==0）&&s

s++;

if（s>=n）

{

cout<<"没有找到该作业"<

return;

}

useed[s].flag=0;

S=useed[s].addr;

L=useed[s].size;

a=-1;k=-1;i=0;

while（i

{

if（frees[i].flag==1）

{

if（frees[i].addr+frees[i].size==S）k=i;

if（frees[i].addr==S+L）a=i;

}

i++;

}

if（k!

=-1）

if（a!

=-1）

{

frees[k].size=frees[a].size+frees[k].size+L;

frees[a].flag=0;

}

else

frees[k].size=frees[k].size+L;

else

if（a!

=-1）

{

frees[a].addr=S;

frees[a].size=frees[a].size+L;

}

else

{

t=0;

while（frees[t].flag==1&&t

t++;

if（t>=maxsize）

{

cout<<"内存空闲表没有空间,回收空间失败"<

useed[s].flag=a;

return;

}

frees[t].addr=S;

frees[t].size=L;

frees[t].flag=1;

}

return;

}

intmain（）

{

inti,a;

floatxk;

frees[0].addr=10240;

frees[0].size=10240;

frees[0].flag=1;

for（i=1;i

frees[i].flag=0;

for（i=0;i

useed[i].flag=0;

while

（1）

{

cout<<"选择操作:

"<

cout<<"请输入你的选择：

";

cin>>a;

switch（a）

{

case0:

exit（0）;

case1:

cout<<"输入作业名:

";

cin>>a;

cout<<"请输入作业大小：

";

cin>>xk;

allo（a,xk）;

break;

case2:

cout<<"输入要回收分区的作业名";

cin>>a;

findc（a）;

break;

case3:

cout<<"输出空闲分区：

"<

for（i=0;i

cout<

cout<<"按任意键,输出已分配信息"<

getch（）;

cout<<"查看已分配分区：

"<

for（i=0;i

if（useed[i].flag!

=0）

cout<

else

cout<

break;

default:

cout<<"输入有误"<

}

}

return1;

}

任务五、死锁的避免

一、目的

在多道程序系统中，多个进程的并发执行来改善系统的资源利用率，提高系统的吞吐量，但可能发生一种危险——死锁。

所谓死锁（Deadlock），是指多个进程在运行过程中因争夺资源而造成的一种僵局（DeadlyEmbrace），当进程处于这种状态时，若无外力作用，他们都无法在向前推进。

我们可以在分配资源时加上限制条件就可以预防死锁，但是，在每一种预防死锁的方法之中，都施加了较强的限制条件；而在避免死锁的方法中，所施加的限制条件较弱，有可能获得令人满意的系统性能。

二、内容

利用银行家算法来避免死锁的发生

#include

#include

#definemax_s20

#definemax_p100

intavailable[max_s];

intmax[max_p][max_s];

intallocation[max_p][max_s];

intneed[max_p][max_s];

intrequest[max_s];

intrequestPID;

intsource;

intprocess;

usingnamespacestd;

//1:

表示请求的资源>还分配的资源

//2:

表示请求的资源>系统剩余的资源

//3:

表示不存在安全序列

//0:

成功

intbanker（intstSq[]）

{

inti,j,k;

for（i=0;i

{

if（request[i]>need[requestPID][i]）

return1;

}

for（i=0;i

{

if（request[i]>available[i]）

return2;

}

for（i=0;i

{

available[i]-=request[i];

allocation[requestPID][i]+=request[i];

need[requestPID][i]-=request[i];

}

intfinish[max_p]={0};

intwork[max_s];

intcurS;

for（i=0;i

work[i]=available[i];

for（k=0;k

{

boolflag=false;

for（i=0;i

flag;i++）

{

if（finish[i]==0）

{

flag=true;

for（j=0;j

{

if（need[i][j]>work[j]）

flag=false;

}

}

curS=i;

}

if（!

flag）

{

for（j=0;j

{

available[j]+=request[j];

allocation[requestPID][j]-=request[j];

need[requestPID][j]+=request[j];

}

return3;

}

finish[curS]=k+1;

for（j=0;j

{

work[j]+=allocation[curS][j];

}

}

for（i=0;i

{

j=0;

while（finish[j]!

=i+1）

j++;

stSq[i]=j;

}

return0;

}

voidsetCS（）

{

source=3;

process=5;

inta[]={4,5,8};

intmax[20][100];

intm[][max_s]={

{8,5,4},

{5,3,3},

{10,1,3},

{3,3,3},

{5,4,4},

};

intal[][max_s]={

{1,2,1},

{3,1,1},

{4,1,3},

{3,2,2},

{1,1,3}

};

intre[]={0,2,2};

inti,j;

cout<<"当前可用资源数:

"<

for（i=0;i

{

available[i]=a[i];

cout<

}

cout<

cout<<"进程所需资源的最大数量:

"<

for（i=0;i

{

for（j=0;j

{

max[i][j]=m[i][j];

cout<

}

cout<

}

cout<

cout<<"进程已分配到资源量:

"<

for（i=0;i

{

for（j=0;j

{

allocation[i][j]=al[i][j];

cout<

}

cout<

}

cout<

cout<<"进程还需的资源量:

"<

for（i=0;i

{

for（j=0;j

{

need[i][j]=max[i][j]-allocation[i][j];

cout<

}

cout<

}

cout<

requestPID=1;

cout<<"进程"<

"<

for（i=0;i

{

request[i]=re[i];

cout<

}

cout<

}

voidmain（）

{

setCS（）;

intstSq[max_p]={0};

cout<<"银行家算法的演示"<

interror=banker（stSq）;

if（!

error）

{

cou