10计科《1》班鞠智明操作系统课程设计Word文件下载.docx
《10计科《1》班鞠智明操作系统课程设计Word文件下载.docx》由会员分享，可在线阅读，更多相关《10计科《1》班鞠智明操作系统课程设计Word文件下载.docx（87页珍藏版）》请在冰豆网上搜索。
******************************\n"
）;
printf（"
\t1.创建一个PCB进程\n\t2.销毁运行PCB进程\n\t3.就绪队列打印输出\n\t4.退出系统n"
scanf（"
%d"
&
on）;
//设置快关按钮
switch（on）
{
case1:
p=Create（nullPcb）;
InsertReadyPcb（readyPcb,p）;
break;
//执行创建PCB进程
case2:
请输入销毁进程的id值\n"
scanf（"
deleteId）;
Delete（deleteId,readyPcb,nullPcb）;
case3:
PrintPCB（readyPcb）;
case4:
exit（0）;
default:
printf（"
请输入1-4之间的序号\n"
}
}while（on!
=4）;
}
voidInitPcb（PCBList&
nullPcb）//初始化空闲队列
{
nullPcb=&
pcb[0];
for（inti=0;
i<
PCBSIZE-1;
i++）{
pcb[i].id=i;
pcb[i].next=&
pcb[i+1];
pcb[PCBSIZE-1].next=NULL;
进程快初始化成功\n"
PCBListCreate（PCBList&
nullPcb）///创建PCB进程
if（nullPcb）{//将空闲队列的第一个赋值给就绪队列，并将它放置在在就绪队列的队尾
pcbP=nullPcb;
nullPcb=nullPcb->
next;
请输入创建PCB的序号id\n"
pcbP->
id）;
请输入它创建的名字\n"
%s"
name）;
请输入它的优先级\n"
priority）;
请输入它运行所需的时间\n"
time）;
returnpcbP;
intDelete（intid,PCBList&
readyPcb,PCBList&
nullPcb）//销毁PCB进程
if（pcbT）{
while（pcbT）{
if（pcbT->
id==id）{
pcbF->
next=pcbT->
pcbT->
next=nullPcb;
nullPcb=pcbT;
printf（"
销毁成功\n"
returnOK;
}
pcbT=pcbT->
pcbF=pcbF->
if（!
pcbT）{
没有要删除的PCB进程\n"
}}
else{
returnOK;
voidPrintPCB（PCBList&
readyPcb）//打印PCB就绪队列
就绪队列中的进程，按照优先级排列的序号:
\n"
\t\t序号\t名字\t优先级\t运行时间\n"
PCBListpcbP=readyPcb->
while（pcbP）
\t\t%d\t%s\t%d\t%d\n"
pcbP->
id,pcbP->
name,pcbP->
priority,pcbP->
pcbP=pcbP->
voidInsertReadyPcb（PCBList&
pcb）
PCBListpcbF=readyPcb;
PCBListpcbT=readyPcb->
if（pcbT）
while（pcbT）
priority<
pcb->
priority）
{
pcb->
next=pcbT;
next=pcb;
创建成功并将进程插入到就绪队列中了\n"
return;
pcbT）
pcbF->
实验结果
实验报告二、单处理机系统的进程调度
鞠智明学号：
一、实验目的：
通过进程的创建和控制的设计来达到如下目的：
1、加深对进程概念的理解，明确进程和程序的区别
2、深入了解系统如何组织进程，创建进程
3、进一步认识如何实现处理机调度。
1、先来先服务调度算法
2、优先数调度算法；
3、时间片轮法调度算法
4、多级反馈队列轮转调度算法
#include"
stdio.h"
conio.h>
#definegetpch（type）（type*）malloc（sizeof（type））
structpcb{/*定义进程控制块PCB*/
charname[10];
charstate;
intsuper;
intntime;
intrtime;
structpcb*link;
}*ready=NULL,*p;
typedefstructpcbPCB;
sort（）/*建立对进程进行优先级排列函数*/
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））/*若插入进程比当前进程优先数大,*/
{/*插入到当前进程前面*/
link=second;
first->
link=p;
second=NULL;
insert=1;
else/*插入进程优先数最低,则插入到队尾*/
first=first->
second=second->
if（insert==0）first->
input（）/*建立进程控制块函数*/
inti,num;
clrscr（）;
/*清屏*/
\n请输入进程号?
"
num）;
for（i=0;
num;
i++）
\n进程号No.%d:
i）;
p=getpch（PCB）;
\n输入进程名:
p->
\n输入进程优先数:
super）;
\n输入进程运行时间:
ntime）;
rtime=0;
state='
w'
;
link=NULL;
sort（）;
/*调用sort函数*/
intspace（）
intl=0;
PCB*pr=ready;
while（pr!
l++;
pr=pr->
return（l）;
disp（PCB*pr）/*建立进程显示函数,用于显示当前进程*/
\nqname\tstate\tsuper\tndtime\truntime\n"
|%s\t"
pr->
|%c\t"
state）;
|%d\t"
rtime）;
check（）/*建立进程查看函数*/
PCB*pr;
\n****当前正在运行的进程是:
/*显示当前运行进程*/
disp（p）;
pr=ready;
\n****当前就绪队列状态为:
/*显示就绪队列状态*/
disp（pr）;
destroy（）/*建立进程撤消函数（进程运行结束,撤消进程）*/
\n进程[%s]已完成.\n"
free（p）;
running（）/*建立进程就绪函数（进程运行时间到,置就绪状态*/
（p->
rtime）++;
if（p->
rtime==p->
ntime）
destroy（）;
/*调用destroy函数*/
else
super）--;
voidmain（）/*主函数*/
intlen,h=0;
charch;
input（）;
len=space（）;
while（（len!
=0）&
&
（ready!
=NULL））
ch=getchar（）;
h++;
\nTheexecutenumber:
%d\n"
h）;
p=ready;
ready=p->
R'
check（）;
running（）;
\n按任一键继续......"
\n\n进程已经完成.\n"
实验报告三、基本存储器管理
一个好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器，而且要能合理地分配和使用这些存储空间。
当用户提出申请存储器空间时，存储管理必须根据申请者的要求，按一定的策略分析主存空间的使用情况，找出足够的空闲区域分配给申请者。
当作业撤离或主动归还主存资源时，则存储管理要收回作业占用的主存空间或归还部分主存空间。
主存的分配和回收的实现与主存储器的管理方式有关的，通过本实验帮助学生理解在不同的存储管理方式下怎样实现主存的分配和回收。
从下两种存储管理方式的主存分配和回收中，选择一种管理方式来实现本次实验任务：
1、在可变（动态）分区管理方式下，采用最先适应算法。
2、在分页式管理方式下，采用位示图来表示主存的分配情况和回收情况。
structlinkk
intsize;
intaddr;
structlinkk*next;
};
structjobtab
intjno;
intflag;
structlinkk*PL,*p,*q,*p1;
structjobtabtab[20];
intl,m,n,t,addr,length;
voidprintlink（）
if（PL!
\n进程内存大小剩余内存\n"
----------------------------\n"
q=PL;
while（q!
%d%d\n"
q->
addr,q->
size）;
q=q->
---------------------\n"
return;
voidprinttab（）
inti;
intflag=0;
for（i=0;
20&
flag==0;
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该进程被创建!
else
tab[n].flag=1;
tab[n].size=l;
q=PL;
p=PL;
if（q->
size==l）
tab[n].addr=q->
addr;
p1=q;
if（p1==PL）PL=q->
elsep->
next=q->
free（p1）;
size>
l）
q->
size=q->
size-l;
q->
addr=q->
addr+l;
p=q;
q=q->
tab[n].flag=0;
\n没有内存剩余!
voidfreem（）
{printf（"
if（tab[n].flag==0）
\n不是该进程!
return;
addr=tab[n].addr;
length=tab[n].size;
tab[n].flag=0;
q=PL;
if（（q==NULL）||（addr+length<
addr））
{p1=（structlinkk*）malloc（sizeof（structlinkk））;
p1->
size=length;
addr=addr;
next=q;
PL=p1;
if（addr+length==q->
addr）
{q->
size+length;
p=q;
while（q!
{if（p->
addr+p->
size==addr）
{p->
size=p->
size+q->
size;
p1=q;
free（p1）;
if（addr+length<
next=p1;
p1=（structlinkk*）malloc（sizeof（structlinkk））;
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）
allocm（）;
case2:
freem（）;
printlink（）;
printtab（）;
case5:
t=1;
while（!
t）;
实验报告四、请求分页存储管理（虚拟存储）
通过请求分页存储管理的设计，让学生了解虚拟存储器的概念和实现方法。
进行运行时不需要将所有的页面都调入内存，只需将部分调入内存，即可运行，在运行的过程中若要访问的页面不在内存时，则需求有请求调入的功能将其调入。
假如此时若内存没有空白物理块，则通过页面置换的功能将一个老的不用的页面淘汰出来，其中淘汰的算法有多种。
模拟仿真请求分页调度算法，其中淘汰的算法可选下列其一
1、先进先出算法
2、最近最久算法
3、CLOCK算法
iostream>
time.h>
usingnamespacestd;
constintMaxNum=320;
//指令数
constintM=5;
//内存容量
intPageOrder[MaxNum];
//页面请求
intSimulate[MaxNum][M];
//页面访问过程
intPageCount[M],LackNum;
//PageCount用来记录LRU算法中最久未使用时间,
LackNum记录缺页数
floatPageRate;
//命中率
intPageCount1[32];
boolIsExit（inti）//FIFO算法中判断新的页面请求是否在内存中
boolf=false;
for（intj=0;
j<
M;
j++）
if（Simulate[i-1][j]==PageOrder[i]）//在前一次页面请求过程中寻找是否存在新的页面请求{
f=true;
returnf;
intIsExitLRU（inti）//LRU算法中判断新的页面请求是否在内存中
intf=-1;
if（Simulate[i-1][j]==PageOrder[i]）
f=j;
intCompare（）//LRU算法找出内存中需要置换出来的页面
intp,q;
p=PageCount[0];
q=0;
for（inti=1;
if（p<
PageCount[i]）
p=Page
升级会员 