操作系统上机答案全Word文档下载推荐.docx
《操作系统上机答案全Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《操作系统上机答案全Word文档下载推荐.docx（69页珍藏版）》请在冰豆网上搜索。
intprivilege;
intfinished;
intwait_time;
}pcb;
pcbpcbs[MAXPCB];
intquantity;
//初始化函数
voidinitial（）{
inti;
for（i=0;
i<
MAXPCB;
i++）{
strcpy（pcbs[i].name,"
"
）;
pcbs[i].status=0;
pcbs[i].time=0;
pcbs[i].privilege=0;
pcbs[i].finished=0;
pcbs[i].wait_time=0;
}
quantity=0;
//读数据函数
intreadData（）{
FILE*fp;
charfname[20];
cout<
<
请输入进程流文件名:
;
cin>
>
fname;
if（（fp=fopen（fname,"
r"
））==NULL）{
错误,文件打不开,请检查文件名"
endl;
}
else{
while（!
feof（fp））{
fscanf（fp,"
%s%d%d%d"
pcbs[quantity].name,&
pcbs[quantity].status,&
pcbs[quantity].time,&
pcbs[quantity].privilege）;
quantity++;
//输出所读入的数据
输出所读入的数据"
进程名进程状态
优先数"
quantity;
cout<
pcbs[i].name<
"
pcbs[i].status<
pcbs[i].time<
pcbs[i].privilege<
return
（1）;
return（0）;
//重置数据,以供另一个算法使用
voidinit（）
{
i++）{
//先进先出算法
voidFIFO（）
{
inti,j;
inttotal;
//输出FIFO算法执行流
endl<
---------------------------------------------------------------"
FIFO算法执行流:
进程名
等待时间"
pcbs[i].wait_time<
for（j=i+1;
j<
j++）{
pcbs[j].wait_time+=pcbs[i].time;
total=0;
total+=pcbs[i].wait_time;
总等待时间:
total<
平均等待时间:
total/quantity<
//优先数调度算法
voidprivilege（）
inti,j,p;
intpassed_time=0;
intqueue[MAXPCB];
intcurrent_privilege=1000;
current_privilege=1000;
for（j=0;
if（（pcbs[j].finished==0）&
&
（pcbs[j].privilege<
current_privilege））{
p=j;
current_privilege=pcbs[j].privilege;
}
queue[i]=p;
pcbs[p].finished=1;
pcbs[p].wait_time+=passed_time;
passed_time+=pcbs[p].time;
//输出优先数调度执行流
优先数调度执行流:
pcbs[queue[i]].name<
pcbs[queue[i]].wait_time<
//时间片轮转调度算法
voidtimer（）
inti,j,number,flag=1;
intmax_time=0;
intround=0;
intqueue[1000];
inttotal=0;
while（flag==1）{
flag=0;
number=0;
if（pcbs[i].finished==0）{
number++;
j=i;
if（number==1）{
queue[total]=j;
total++;
pcbs[j].finished=1;
if（number>
1）{
flag=1;
queue[total]=i;
if（pcbs[i].time<
=block_time*（round+1））{
pcbs[i].finished=1;
round++;
if（queue[total-1]==queue[total-2]）{
total--;
时间片轮转调度执行流:
total;
//显示版权信息函数
voidversion（）
┏━━━━━━━━━━━━━━━━━━━━━━━┓"
┃ 进程调度模拟系统 ┃"
┠───────────────────────┨"
┃
（c）AllRightReserved
Neo ┃"
┃ sony006@ ┃"
┃ version2004
build1122 ┃"
┗━━━━━━━━━━━━━━━━━━━━━━━┛"
//主函数
voidmain（）
intflag;
version（）;
initial（）;
flag=readData（）;
if（flag==1）{
FIFO（）;
init（）;
privilege（）;
timer（）;
2.可变分区存储管理方案中的内存分配
/*
可变分区调度算法有:
最先适应分配算法,最优适应分配算法,最坏适应算法
用户提出内存空间的申请；
系统根据申请者的要求，按照一定的分配策略分析内存空间的使用情况，找出能
满足请求的空闲区，分给申请者；
当程序执行完毕或主动归还内存资源时，系统要收回它所占用的内存空间
或它归还的部分内存空间。
1．程序运行时首先接收输入：
空闲区数据文件，包括若干行，每行有两个数据项：
起始地址、长度（均为
整数），各数据项以逗号隔开。
2．建立空闲区表并在屏幕上显示输出空闲区表内容，空闲区表中记录了内存中可供分配的空闲区的始址和
长度，用标志位指出该分区是否是未分配的空闲区。
3．从用户界面根据用户提示接收一个内存申请，格式为：
作业名、申请空间的大小。
4．按照最差（最坏）适配算法选择一个空闲区，分割并分配，修改相应的数据结构（空闲区表），填写内
存已分配区表（起始地址、长度、标志位），其中标志位的一个作用是指出该区域分配给哪个作业。
5．重复3、4，直到输入为特殊字符（0）。
6．在屏幕上显示输出新的空闲区表和已分配区表的内容。
FIFO,最优适应分配算法,最坏适应算法
VC++调试通过
（C）copyrightbyNeo
*/
iomanip.h>
constintMAXJOB=100;
//定义表最大记录数
intstart;
intlength;
chartag[20];
}job;
jobfrees[MAXJOB];
//定义空闲区表
intfree_quantity;
joboccupys[MAXJOB];
//定义已分配区表
intoccupy_quantity;
voidinitial（）
MAXJOB;
frees[i].start=-1;
frees[i].length=0;
strcpy（frees[i].tag,"
free"
occupys[i].start=-1;
occupys[i].length=0;
strcpy（occupys[i].tag,"
free_quantity=0;
occupy_quantity=0;
intreadData（）
请输入初始空闲表文件名:
%d,%d"
&
frees[free_quantity].start,&
frees[free_quantity].length）;
free_quantity++;
return1;
return0;
//sort
voidsort（）
free_quantity-1;
p=i;
free_quantity;
if（frees[j].start<
frees[p].start）{
if（p!
=i）{
frees[free_quantity]=frees[i];
frees[i]=frees[p];
frees[p]=frees[free_quantity];
//显示函数
voidview（）
----------------------------------------------------------"
当前空闲表:
起始地址
长度
状态"
cout.setf
（2）;
cout.width（12）;
frees[i].start;
cout.width（10）;
frees[i].length;
cout.width（8）;
frees[i].tag<
当前已分配表:
占用作业名"
occupy_quantity;
occupys[i].start;
occupys[i].length;
occupys[i].tag<
//最先适应分配算法
voidearliest（）
charjob_name[20];
intjob_length;
inti,j,flag,t;
请输入新申请内存空间的作业名和空间大小:
job_name;
job_length;
if（frees[i].length>
=job_length）{
flag=1;
if（flag==0）{
Sorry,当前没有能满足你申请长度的空闲内存,请稍候再试"
t=0;
i=0;
while（t==0）{
if（frees[i].length>
t=1;
i++;
i--;
occupys[occupy_quantity].start=frees[i].start;
strcpy（occupys[occupy_quantity].tag,job_name）;
occupys[occupy_quantity].length=job_length;
occupy_quantity++;
job_length）{
frees[i].start+=job_length;
frees[i].length-=job_length;
for（j=i;
frees[j]=frees[j+1];
free_quantity--;
内存空间成功:
）"
//最优适应分配算法
voidexcellent（）
if（（frees[j].length>
=job_length）&
（frees[j].length<
frees[i].length））{
i=j;
//最坏适应算法
voidworst（）
（frees[j].length>
//撤消作业
voidfinished（）
inti,j,flag,p=0;
请输入要撤消的作业名:
flag=-1;
if（!
strcmp（occupys[i].tag,job_name））{
flag=i;
start=occupys[i].start;
length=occupys[i].length;
if（flag==-1）{
没有这个作业名"
//加入空闲表
if（（frees[i].start+frees[i].length）==start）{
if（（（i+1）<
free_qu
升级会员 