计算机操作系统课程设计Word格式文档下载.docx
《计算机操作系统课程设计Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《计算机操作系统课程设计Word格式文档下载.docx（60页珍藏版）》请在冰豆网上搜索。
else
\n请创建第%d个进程"
shumu）;
\n请输入新进程的pid\n"
scanf（"
%d"
&
neicun[shumu].pid）;
\n请输入新的进程的优先级\n"
neicun[shumu].youxian）;
\n请输入新的进程的大小\n"
neicun[shumu].daxiao）;
\n请输入新的进程的消息\n"
neicun[shumu].msg）;
neicun[shumu].live=1;
shumu++;
returnneicun[shumu-1].live;
}
voidviewrun（）
intvpid;
\n请输入想显示第几个创建的进程\n"
vpid）;
if（vpid>
0&
&
vpid<
=20&
neicun[vpid].live==1）
\n进程的pid是:
%d\n"
neicun[vpid].pid）;
\n进程的优先级是:
neicun[vpid].youxian）;
\n进程的大小是:
neicun[vpid].daxiao）;
\n进程的消息是:
neicun[vpid].msg）;
else
\n所查看运行进程不存在\n"
请按回车退出查看\n"
vpid=getch（）;
}
voidhuanchu（）
{
intpid1,pid2;
charc;
\n请输入第一个替换进程是第几个创建的\n"
pid1）;
\n请输入第二个替换进程是第几个创建的\n"
pid2）;
if（pid1>
pid1<
neicun[pid1].live==1）
{
if（neicun[pid1].youxian>
neicun[pid2].youxian）
{
waicun.pid=neicun[pid1].pid;
waicun.youxian=neicun[pid1].youxian;
waicun.daxiao=neicun[pid1].daxiao;
waicun.msg=neicun[pid1].msg;
neicun[pid1].pid=neicun[pid2].pid;
neicun[pid1].youxian=neicun[pid2].youxian;
neicun[pid1].daxiao=neicun[pid2].daxiao;
neicun[pid1].msg=neicun[pid2].msg;
neicun[pid2].pid=waicun.pid;
neicun[pid2].youxian=waicun.youxian;
neicun[pid2].daxiao=waicun.daxiao;
neicun[pid2].msg=waicun.msg;
\n替换完成\n"
\n被替换进程的pid是:
waicun.pid）;
\n被替换进程的youxian是:
waicun.youxian）;
\n被替换进程的daxiao是:
waicun.daxiao）;
\n被替换进程的msg是:
waicun.msg）;
\n进程优先级不够大"
}
所查看运行进程不存在"
请按回车退出换出进程\n"
c=getche（）;
voidkill（）
intkpid;
\n请输入要撤销第几个创建的进程\n"
kpid）;
if（kpid>
kpid<
20&
neicun[kpid].live==1）
neicun[kpid].live=0;
\n已撤销第%d个创建的进程"
kpid）;
kpid=getch（）;
voidmain（）
intn,m,i;
chara;
n=1;
while（n==1）
system（"
cls"
\n***********************************"
\n*进程演示系统*"
\n1.创建新的进程2.查看运行进程"
\n3.换出某个进程4.杀死运行进程"
\n5.退出"
\n请选择（1~5）"
a=getch（）;
switch（a）
case'
1'
:
create（）;
break;
2'
viewrun（）;
3'
huanchu（）;
4'
kill（）;
5'
exit（0）;
default:
n=0;
五：
实验结果：
任务二、单处理机系统的进程调度
2、深入了解系统如何组织进程，创建进程
3、进一步认识如何实现处理机调度
从下面四个调度算法中，选择一个调度算法来实现进程调度：
1、先来先服务调度算法
2、优先数调度算法
3、时间片轮法调度算法
4、多级反馈队列轮转调度算法
三、结构框图：
#include"
stdio.h"
#definegetpch（type）（type*）malloc（sizeof（type））
#defineNULL0
structpcb
{/*定义进程控制块PCB*/
charname[10];
charstate;
intsuper;
intntime;
intrtime;
structpcb*link;
}*ready=NULL,*p;
typedefstructpcbPCB;
voidsort（）/*建立对进程进行优先级排列函数*/
PCB*first,*second;
intinsert=0;
if（（ready==NULL）||（（p->
super）>
（ready->
super）））/*优先级最大者,插入队首*/
p->
link=ready;
ready=p;
}
else/*进程比较优先级,插入适当的位置中*/
first=ready;
second=first->
link;
while（second!
=NULL）
if（（p->
（second->
super））/*若插入进程比当前进程优先数大,*/
{/*插入到当前进程前面*/
p->
link=second;
first->
link=p;
second=NULL;
insert=1;
else/*插入进程优先数最低,则插入到队尾*/
{
first=first->
second=second->
}
}
if（insert==0）
first->
}
voidinput（）/*建立进程控制块函数*/
inti,num;
\n请输入进程数量:
"
num）;
for（i=1;
i<
=num;
i++）
printf（"
\n进程号No.%d:
\n"
i）;
p=getpch（PCB）;
\n输入进程名:
scanf（"
%s"
p->
name）;
\n输入进程优先数:
p->
super）;
\n输入进程运行时间:
ntime）;
rtime=0;
state='
w'
;
link=NULL;
sort（）;
/*调用sort函数*/
intspace（）
intl=0;
PCB*pr=ready;
while（pr!
l++;
pr=pr->
return（l）;
voidshow（）
\nqname\tstate\tsuper\tndtime\truntime\n"
voiddisp（PCB*pr）/*建立进程显示函数,用于显示当前进程*/
{
%s\t"
pr->
%c\t"
state）;
%d\t"
rtime）;
voidcheck（）/*建立进程查看函数*/
PCB*pr;
\n****当前正在运行的进程是:
/*显示当前运行进程*/
show（）;
disp（p）;
pr=ready;
if（pr==NULL）
\n****当前就绪队列为空!
else
{
printf（"
\n****当前就绪队列状态为:
/*显示就绪队列状态*/
show（）;
while（pr!
{
disp（pr）;
pr=pr->
}
voiddestroy（）/*建立进程撤消函数（进程运行结束,撤消进程）*/
\n进程[%s]已完成.\n"
free（p）;
voidrunning（）/*建立进程就绪函数（进程运行时间到,置就绪状态*/
（p->
rtime）++;
if（p->
rtime==p->
ntime）
destroy（）;
/*调用destroy函数*/
（p->
super）--;
/*调用sort函数*/
voidmain（）/*主函数*/
intlen,h=0;
charch;
input（）;
len=space（）;
while（（len!
=0）&
（ready!
=NULL））
ch=getchar（）;
h++;
\n当前运行次数为:
%d\n"
h）;
p=ready;
ready=p->
R'
check（）;
running（）;
\n按任一键继续......"
\n\n进程已经完成.\n"
ch=getchar（）;
任务三、基本存储器管理
一个好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器，而且要能合理地分配和使用这些存储空间。
当用户提出申请存储器空间时，存储管理必须根据申请者的要求，按一定的策略分析主存空间的使用情况，找出足够的空闲区域分配给申请者。
当作业撤离或主动归还主存资源时，则存储管理要收回作业占用的主存空间或归还部分主存空间。
主存的分配和回收的实现与主存储器的管理方式有关的，通过本实验帮助学生理解在不同的存储管理方式下怎样实现主存的分配和回收
从下两种存储管理方式的主存分配和回收中，选择一种管理方式来实现本次实验任务：
1、在可变（动态）分区管理方式下，采用最先适应算法
2、在分页式管理方式下，采用位示图来表示主存的分配情况和回收情况
#include<
structlinkk
intsize;
intaddr;
structlinkk*next;
structjobtab
intjno;
intflag;
structlinkk*PL,*p,*q,*p1;
structjobtabtab[20];
intl,m,n,t,addr,length;
voidprintlink（）
if（PL!
=NULL）
\n进程内存大小剩余内存\n"
----------------------------\n"
q=PL;
while（q!
%d%d\n"
q->
addr,q->
size）;
q=q->
next;
---------------------\n"
return;
voidprinttab（）
inti;
intflag=0;
for（i=0;
flag==0;
i++）
if（tab[i].flag==1）flag=1;
if（flag==0）
\n无进程!
return;
\n进程编号进程起始地址进程内存大小\n"
----------------------\n"
20;
if（tab[i].flag==1）
%d%d%d\n"
i,tab[i].addr,tab[i].size）;
---------------\n"
voidallocm（）
\n输入进程编号:
n）;
\n输入进程内存大小:
l）;
if（tab[n].flag==1）
\n该进程被创建!
tab[n].flag=1;
tab[n].size=l;
q=PL;
p=PL;
while（q!
if（q->
size==l）
tab[n].addr=q->
addr;
p1=q;
if（p1==PL）PL=q->
elsep->
next=q->
free（p1）;
return;
size>
l）
q->
size=q->
size-l;
q->
addr=q->
addr+l;
p=q;
q=q->
tab[n].flag=0;
\n没有内存剩余!
voidfreem（）
if（tab[n].flag==0）
\n不是该进程!
addr=tab[n].addr;
length=tab[n].size;
if（（q==NULL）||（addr+length<
q->
addr））
p1=（structlinkk*）malloc（sizeof（structlinkk））;
p1->
size=length;
addr=addr;
next=q;
PL=p1;
return;
if（addr+length==q->
addr）
size+length;
p=q;
while（q!
{if（p->
addr+p->
size==addr）
{p->
size=p->
if（addr+length==q->
size+q->
size;
p1=q;
p->
free（p1）;
if（addr+length<
next=p1;
next=NULL;
main（）
PL=（structlinkk*）malloc（sizeof（structlinkk））;
PL->
addr=0;
\n输入内存大小:
size=n;
for（inti=0;
tab[i].jno=i;
tab[i].flag=0;
t=0;
do
\n--------------------------------\n"
1--分配内存2--释放内存\n"
3--链接进程号4--输出_TAB\n"
5--Quit\n"
Select[]\b\b"
m）;
switch（m）
case1:
allocm（）;
case2:
freem（）;
case3:
printlink（）;
case4:
printtab（）;
case5:
t=1;
while（!
t）;
任务四、请求分页存储管理（虚拟存储）
升级会员 