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