操作系统上机答案全.docx

操作系统上机答案全.docx

《操作系统上机答案全.docx》由会员分享，可在线阅读，更多相关《操作系统上机答案全.docx（69页珍藏版）》请在冰豆网上搜索。

操作系统上机答案全

1.进程调度

/*

进程调度算法有FIFO，优先数调度算法，时间片轮转调度算法，

目前主要是考FIFO和优先数调度算法（静态优先级）。

输入：

进程流文件，其中存储的是一系列要执行的进程，每个作业包括四个数据项：

进程名进程状态（1就绪2等待3运行）  所需时间  优先数（0级最高）

输出:

进程执行流和等待时间平均等待时间

  本程序包括:

FIFO，优先数调度算法，时间片轮转调度算法

  VC++调试通过

  （C）copyrightbyNeo

  欢迎大家测试请问题请Email:

sony006@

  */

#include

#include

#include

constintblock_time=10;//定义时间片的长度为10秒

constintMAXPCB=100;//定义最大进程数

//定义进程结构体

typedefstructnode{

charname[20];

intstatus;

inttime;

intprivilege;

intfinished;

intwait_time;

}pcb;

pcbpcbs[MAXPCB];

intquantity;

//初始化函数

voidinitial（）{

inti;

for（i=0;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];

inti;

cout<<"请输入进程流文件名:

";

cin>>fname;

if（（fp=fopen（fname,"r"））==NULL）{

  cout<<"错误,文件打不开,请检查文件名"<

}

else{

  while（!

feof（fp））{

  fscanf（fp,"%s%d%d%d",pcbs[quantity].name,&pcbs[quantity].status,&pcbs[quantity].time,&pcbs[quantity].privilege）;

  quantity++;

  }

  //输出所读入的数据

  cout<<"输出所读入的数据"<

  cout<<"进程名进程状态  所需时间  优先数"<

  for（i=0;i

  cout<<"  "<

  }

  return

（1）;

}

return（0）;

}

//重置数据,以供另一个算法使用

voidinit（）

{

inti;

for（i=0;i

  pcbs[i].finished=0;

  pcbs[i].wait_time=0;

}

}

//先进先出算法

voidFIFO（）

{

inti,j;

inttotal;

//输出FIFO算法执行流

cout<

cout<<"FIFO算法执行流:

"<

cout<<"进程名    等待时间"<

for（i=0;i

  cout<<"  "<

  for（j=i+1;j

  pcbs[j].wait_time+=pcbs[i].time;

  }

}

total=0;

for（i=0;i

  total+=pcbs[i].wait_time;

}

cout<<"总等待时间:

"<

"<

}

//优先数调度算法

voidprivilege（）

{

inti,j,p;

intpassed_time=0;

inttotal;

intqueue[MAXPCB];

intcurrent_privilege=1000;

for（i=0;i

  current_privilege=1000;

  for（j=0;j

  if（（pcbs[j].finished==0）&&（pcbs[j].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;

}

//输出优先数调度执行流

cout<

cout<<"优先数调度执行流:

"<

cout<<"进程名    等待时间"<

for（i=0;i

  cout<<"  "<

}

total=0;

for（i=0;i

  total+=pcbs[i].wait_time;

}

cout<<"总等待时间:

"<

"<

}

//时间片轮转调度算法

voidtimer（）

{

inti,j,number,flag=1;

intpassed_time=0;

intmax_time=0;

intround=0;

intqueue[1000];

inttotal=0;

while（flag==1）{

  flag=0;

  number=0;

  for（i=0;i

  if（pcbs[i].finished==0）{

    number++;

    j=i;

  }

  }

  if（number==1）{

    queue[total]=j;

    total++;

    pcbs[j].finished=1;

  }

  if（number>1）{

  for（i=0;i

  if（pcbs[i].finished==0）{

    flag=1;

    queue[total]=i;

    total++;

    if（pcbs[i].time<=block_time*（round+1））{

    pcbs[i].finished=1;

    }

  }

  }

  }

  round++;

}

if（queue[total-1]==queue[total-2]）{

  total--;

}

cout<

cout<<"时间片轮转调度执行流:

";

for（i=0;i

  cout<

}

}

//显示版权信息函数

voidversion（）

{

cout<

cout<<"┏━━━━━━━━━━━━━━━━━━━━━━━┓"<

cout<<"┃　　　　　　进程调度模拟系统　　　　　　　　┃"<

cout<<"┠───────────────────────┨"<

cout<<"┃　  　（c）AllRightReserved  Neo　　　　　　┃"<

cout<<"┃　　　　　　sony006@　　　　　　　　　┃"<

cout<<"┃　　　　　version2004  build1122　　　　　　┃"<

cout<<"┗━━━━━━━━━━━━━━━━━━━━━━━┛"<

cout<

}

//主函数

voidmain（）

{

intflag;

version（）;

initial（）;

flag=readData（）;

if（flag==1）{

FIFO（）;

init（）;

privilege（）;

init（）;

timer（）;

}

}

2.可变分区存储管理方案中的内存分配

/*  可变分区调度算法有:

最先适应分配算法,最优适应分配算法,最坏适应算法

用户提出内存空间的申请；系统根据申请者的要求，按照一定的分配策略分析内存空间的使用情况，找出能

满足请求的空闲区，分给申请者；当程序执行完毕或主动归还内存资源时，系统要收回它所占用的内存空间

或它归还的部分内存空间。

1．程序运行时首先接收输入：

空闲区数据文件，包括若干行，每行有两个数据项：

起始地址、长度（均为

整数），各数据项以逗号隔开。

2．建立空闲区表并在屏幕上显示输出空闲区表内容，空闲区表中记录了内存中可供分配的空闲区的始址和

长度，用标志位指出该分区是否是未分配的空闲区。

3．从用户界面根据用户提示接收一个内存申请，格式为：

作业名、申请空间的大小。

4．按照最差（最坏）适配算法选择一个空闲区，分割并分配，修改相应的数据结构（空闲区表），填写内

存已分配区表（起始地址、长度、标志位），其中标志位的一个作用是指出该区域分配给哪个作业。

5．重复3、4，直到输入为特殊字符（0）。

6．在屏幕上显示输出新的空闲区表和已分配区表的内容。

本程序包括:

FIFO,最优适应分配算法,最坏适应算法

  VC++调试通过

  （C）copyrightbyNeo

  欢迎大家测试请问题请Email:

sony006@

*/

#include

#include

#include

#include

constintMAXJOB=100;//定义表最大记录数

typedefstructnode{

intstart;

intlength;

chartag[20];

}job;

jobfrees[MAXJOB];//定义空闲区表

intfree_quantity;

joboccupys[MAXJOB];//定义已分配区表

intoccupy_quantity;

//初始化函数

voidinitial（）

{

inti;

for（i=0;i

  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（）

{

FILE*fp;

charfname[20];

cout<<"请输入初始空闲表文件名:

";

cin>>fname;

if（（fp=fopen（fname,"r"））==NULL）{

  cout<<"错误,文件打不开,请检查文件名"<

}

else{

  while（!

feof（fp））{

  fscanf（fp,"%d,%d",&frees[free_quantity].start,&frees[free_quantity].length）;

  free_quantity++;

  }

  return1;

}

return0;

}

//sort

voidsort（）

{

inti,j,p;

for（i=0;i

  p=i;

  for（j=i+1;j

  if（frees[j].start

    p=j;

  }

  }

  if（p!

=i）{

  frees[free_quantity]=frees[i];

  frees[i]=frees[p];

  frees[p]=frees[free_quantity];

  }

}

}

//显示函数

voidview（）

{

inti;

cout<

cout<<"当前空闲表:

"<

cout<<"起始地址    长度      状态"<

for（i=0;i

  cout.setf

（2）;

  cout.width（12）;

  cout<

  cout.width（10）;

  cout<

  cout.width（8）;

  cout<

}

cout<

cout<<"当前已分配表:

"<

cout<<"起始地址    长度  占用作业名"<

for（i=0;i

  cout.setf

（2）;

  cout.width（12）;

  cout<

  cout.width（10）;

  cout<

  cout.width（8）;

  cout<

}

}

//最先适应分配算法

voidearliest（）

{

charjob_name[20];

intjob_length;

inti,j,flag,t;

cout<<"请输入新申请内存空间的作业名和空间大小:

";

cin>>job_name;

cin>>job_length;

flag=0;

for（i=0;i

  if（frees[i].length>=job_length）{

  flag=1;

  }

}

if（flag==0）{

  cout<

}

else{

  t=0;

  i=0;

  while（t==0）{

  if（frees[i].length>=job_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++;

  if（frees[i].length>job_length）{

  frees[i].start+=job_length;

  frees[i].length-=job_length;

  }

  else{

  for（j=i;j

    frees[j]=frees[j+1];

  }

  free_quantity--;

  cout<<"内存空间成功:

）"<

  }

}

}

//最优适应分配算法

voidexcellent（）

{

charjob_name[20];

intjob_length;

inti,j,flag,t;

cout<<"请输入新申请内存空间的作业名和空间大小:

";

cin>>job_name;

cin>>job_length;

flag=0;

for（i=0;i

  if（frees[i].length>=job_length）{

  flag=1;

  }

}

if（flag==0）{

  cout<

}

else{

  t=0;

  i=0;

  while（t==0）{

  if（frees[i].length>=job_length）{

    t=1;

  }

  i++;

  }

  i--;

  for（j=0;j

    if（（frees[j].length>=job_length）&&（frees[j].length

    i=j;

    }

  }

  occupys[occupy_quantity].start=frees[i].start;

  strcpy（occupys[occupy_quantity].tag,job_name）;

  occupys[occupy_quantity].length=job_length;

  occupy_quantity++;

  if（frees[i].length>job_length）{

  frees[i].start+=job_length;

  frees[i].length-=job_length;

  }

  else{

  for（j=i;j

    frees[j]=frees[j+1];

  }

  free_quantity--;

  cout<<"内存空间成功:

）"<

  }

}

}

//最坏适应算法

voidworst（）

{

charjob_name[20];

intjob_length;

inti,j,flag,t;

cout<<"请输入新申请内存空间的作业名和空间大小:

";

cin>>job_name;

cin>>job_length;

flag=0;

for（i=0;i

  if（frees[i].length>=job_length）{

  flag=1;

  }

}

if（flag==0）{

  cout<

}

else{

  t=0;

  i=0;

  while（t==0）{

  if（frees[i].length>=job_length）{

    t=1;

  }

  i++;

  }

  i--;

  for（j=0;j

    if（（frees[j].length>=job_length）&&（frees[j].length>frees[i].length））{

    i=j;

    }

  }

  occupys[occupy_quantity].start=frees[i].start;

  strcpy（occupys[occupy_quantity].tag,job_name）;

  occupys[occupy_quantity].length=job_length;

  occupy_quantity++;

  if（frees[i].length>job_length）{

  frees[i].start+=job_length;

  frees[i].length-=job_length;

  }

  else{

  for（j=i;j

    frees[j]=frees[j+1];

  }

  free_quantity--;

  cout<<"内存空间成功:

）"<

  }

}

}

//撤消作业  

voidfinished（）

{

charjob_name[20];

inti,j,flag,p=0;

intstart;

intlength;

cout<<"请输入要撤消的作业名:

";

cin>>job_name;

flag=-1;

for（i=0;i

  if（!

strcmp（occupys[i].tag,job_name））{

  flag=i;

  start=occupys[i].start;

  length=occupys[i].length;

  }

}

if（flag==-1）{

  cout<<"没有这个作业名"<

}

else{

  //加入空闲表

  for（i=0;i

  if（（frees[i].start+frees[i].length）==start）{

    if（（（i+1）