操作系统实验源码参考终版含文件系统实验Word格式.docx
《操作系统实验源码参考终版含文件系统实验Word格式.docx》由会员分享，可在线阅读，更多相关《操作系统实验源码参考终版含文件系统实验Word格式.docx（51页珍藏版）》请在冰豆网上搜索。
（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->
}
input（）/*建立进程控制块函数*/
{inti,num;
clrscr（）;
/*清屏*/
printf（"
\n请输入进程号?
"
）;
scanf（"
%d"
&
num）;
for（i=0;
i<
num;
i++）
{printf（"
\n进程号No.%d:
\n"
i）;
p=getpch（PCB）;
\n输入进程名:
%s"
p->
name）;
printf（"
\n输入进程优先数:
scanf（"
p->
super）;
\n输入进程运行时间:
ntime）;
p->
rtime=0;
state='
w'
;
link=NULL;
sort（）;
/*调用sort函数*/
intspace（）
{intl=0;
PCB*pr=ready;
while（pr!
{l++;
pr=pr->
return（l）;
disp（PCB*pr）/*建立进程显示函数,用于显示当前进程*/
{printf（"
\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
{（p->
super）--;
/*调用sort函数*/
main（）/*主函数*/
{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（）;
printf（"
\n按任一键继续......"
ch=getchar（）;
\n\n进程已经完成.\n"
ch=getchar（）;
}
3、运行结果：
请输入进程号？
5
进程号No.0：
输入进程名：
A
输入进程优先数：
2
输入进程运行时间：
1
进程号No.1：
B
3
进程号No.2：
C
进程号No.3：
D
4
进程号No.4：
E
Theexecutenumber:
****当前正在运行的进程是：
Qnamestatesuperndtimeruntime
ER510
****当前就绪队列状态为：
Dw410
Bw310
Aw210
Cw110
进程[E]已完成
按任一键继续……
DR410
进程[D]已完成
BR310
进程[B]已完成
AR210
进程[A]已完成
c
cR110
进程[C]已完成
进程已经完成
（二）、简单轮转法
在分时系统中，都毫无例外采用时间片轮转法。
在一种简单的轮转法中，系统将所有就绪进程按FIFO规则排成一个队列，把CPU分配给队首进程，并规定它执行一给定的时间如100ms，称此时间间隔为时间片。
当时间片完成时，系统产生一个时钟中断，剥夺该进程的执行，将它送至就绪队列的末尾，并把处理机分配给就绪队列的新队首进程，同样也让它执行一个时间片。
这样，就绪队列中的所有进程均可获得一个时间片的处理机而运行。
就绪队列中的进程在依次执行时，可能发生以下三种情况：
（1）进程未用完一个时间片就结束，这时系统应提前调度；
（2）进程在执行过程中提出I/O请求而阻塞，系统应将它放入相应的阻塞队列并引起调度；
（3）进程完成一个时间片后尚未完成，系统应将它重新放到就绪队列的末尾，等待下次执行。
由于在分时系统中，键盘命令的执行时间较短，大多能在一个时间片内执行完毕，因此分时系统的实际响应时间将比Nq（N是同时性用户数，q是时间片大小）小。
#include<
stdio.h>
/*定义一个pcb的结构体*/
structpcb
{charname;
/*进程名*/
inttime;
/*进程执行时间*/
};
voidmain（）
{intn,i,j,flag=1;
structpcba[100];
/*最多可以有100个进程*/
printf（"
输入进程个数：
scanf（"
n）;
getchar（）;
/*接收回车*/
for（i=0;
n;
{printf（"
输入进程的名字：
%c"
a[i].name）;
/*以字符接收进程名*/
输入占用的时间片：
/*输入进程占用的时间片*/
a[i].time）;
}
i=0;
while（flag&
n>
0）/*若进程数为空，结束程序*/
{if（a[i].time!
=0）/*就绪队列是否为空*/
a[i].name）;
/*进程执行一次，打印出该进程*/
a[i].time--;
/*使该进程占用的时间片减1*/
for（j=0;
j<
j++）
if（a[j].time）/*若进程所占用的时间片不为0，仍执行下一进程*/
{flag=1;
break;
else/*若进程所占用的时间片为0，说明已经完成，跳过执行下一进程*/
flag=0;
i=（++i）%n;
/*继续执行下一个进程，i＋1*/
}
输入进程个数：
ABCDEABDEBDEDEE
Pressanykeytocontinue
实验二存储管理
一.实验目的：
存储管理的主要功能之一是合理分配空间,请求页式管理是一种常用的虚拟存储管理技术。
本实验的目的是通过请求页式管理中的页面置换算法设计，了解虚拟存储技术的特点，掌握请求页式管理的页面置换算法。
二.实验内容：
1、分区管理的原理：
将存储器划分成若干段大小固定的区域，一个区域里只能运行一个程序，程序只能在其自身所在的分区中活动。
2、固定式分区管理的原理：
区域大小及起始地址是固定的。
一个分区只能存放一个程序。
需要设置一个分区说明表来标明内存的使用状态。
根据分区说明表来给程序分配相应的区域。
由于程序不可能刚刚占有一个分区的大小，这样就会在一个分区之中留下零头，造成了极大的浪费。
3、可变式分区管理的原理：
区域的大小及起始地址是可变的，根据程序装入时的大小动态地分配一个区域。
保证每个区域之中刚好放一个程序。
这样可以充分地利用存储空间，提高内存的使用效率。
如果一个程序运行完毕，就要释放出它所占有的分区，使之变成空闲区。
这样就会出现空闲区与占用区相互交错的情况。
这样就需要P表，F表来分别表示内存的占用区状态与空闲区的状态。
（一）、设计一个固定式分区分配的存储管理方案，并模拟实现分区的分配和回收过程。
1.通过随机数产生一个程序指令序列，使得50%的指令是顺序执行的。
25%的指令是均匀分布在前地址部分，25%的指令是均匀分布在后地址部分。
2.FIFO算法总是选择在内存驻留时间最长的一页将其淘汰。
FIFO算法认为先调入内存的页不再被访问的可能性要比其他页大，因而选择最先调入内存的页换出。
实现FIFO算法需要把各个已分配页面按分配时间顺序记录在一个数组中，每次淘汰最早进入数组的页。
3、程序代码如下：
#include<
math.h>
#definemaxsize32
#definevpf200
voidFIFO（inta[]）;
intcount[maxsize];
inta[vpf];
voidmain（）//定义主函数
{for（inti=0;
200;
i++）//用随机数产生页地址流
a[i]=rand（）%32;
FIFO（a）;
voidFIFO（inta[]）//FIFO算法
{for（intn=4;
n<
33;
n++）//不同的页面数计算命中率
{intnum;
intmax;
intmaxpage=0;
intdis=0;
inti=0;
intk=0;
intsum=n;
intb[maxsize];
for（k=0;
k<
k++）//页面数组，计数数组初始化
{b[k]=-1;
count[k]=0;
for（i=0;
vpf;
i++）
{num=0;
k++）//测试是否命中
{if（a[i]==b[k]）
num++;
if（num==0）//未命中
{dis++;
for（k=0;
k++）//所有页面计数器加一
count[k]++;
if（sum==0）//没空白页面时
{max=0;
k++）
{if（max<
count[k]）//找出计数器值最大的替换
{max=count[k];
maxpage=k;
b[maxpage]=a[i];
count[maxpage]=0;
//被替换页面计数器清零
else{b[n-sum]=a[i];
count[n-sum]=0;
//有空白页面时，将所缺页放入空白页面，
sum--;
//并将该页面计数器清零
}}}
printf（"
n）;
pageframesFIFO:
%3d"
dis）;
FIFO:
%6.4f\n"
1-（float）dis/32）;
}}
运行结果
（二）、编写并调试一个断式存储管理的地址转换的模拟程序。
―――最佳适应算法
iostream.h>
structfreeM{intSadd;
intlength;
structbusyMEM{intSadd;
intEadd;
charfill;
busyMEM*next;
classAssign{
public:
voidinitMEM（）;
voidpai（）;
voidprintList（）;
voidresetfree（）;
voidinsert（）;
voidDelete（）;
private:
freeMfreeMEM[20];
busyMEM*p;
voidAssign:
:
initMEM（）
{p=（busyMEM*）malloc（sizeof（busyMEM））;
busyMEM*L;
L=p;
L->
fill='
O'
Eadd=19;
Sadd=0;
next=（busyMEM*）malloc（sizeof（busyMEM））;
L=L->
next;
A'
Eadd=51;
Sadd=20;
B'
Eadd=71;
Sadd=52;
C'
Eadd=137;
Sadd=98;
D'
Eadd=169;
Sadd=148;
next=p;
resetfree（）;
resetfree（）
{for（inti=0;
20;
{freeMEM[i].length=-1;
freeMEM[i].Sadd=-1;
i=0;
busyMEM*L=p;
while（L->
next!
=p）
{if（L->
next->
Sadd-L->
Eadd-1!
=0）
{freeMEM[i].length=L->
Eadd-1;
freeMEM[i].Sadd=L->
Eadd+1;
i++;
}
L=L->
freeMEM[i].length=256-L->
freeMEM[i].Sadd=L->
printList（）
{cout<
<
┌──────┬──┬──┐"
endl;
cout<
│分区起始地址│长度│状态│"
while（freeMEM[i].length!
=-1）
{if（freeMEM[i].Sadd<
100）
{cout<
├──────┼──┼──┤"
│"
freeMEM[i].Sadd<
k│"
freeMEM[i].length<
k│空闲│"
else
{cout<
i++;
└──────┴──┴──┘"
insert（）
{busyMEM*L;
L=（busyMEM*）malloc（sizeof（busyMEM））;
请输入作业标识:
cin>
>
L->
fill;
请输入作业长度:
inta;
a;
for（inti=0;
{if（freeMEM[i].length>
=a）
break;
if（i==19）{cout<
分配失败！
return;
busyMEM*R=p;
while（R->
Eadd<
freeMEM[i].Sadd&
R->
{R=R->
next=R->
R->
next=L;
Sadd=freeMEM[i].Sadd;
Eadd=freeMEM[i].Sadd+a-1;
resetfree（）
升级会员 