自考操作系统上机操作答案(全)

1.进程调度

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

3.页式存储管理方案中的内存分配

4.虚拟存储管理器的页面调度

5.磁盘存储空间的管理

7.磁盘调度

8.作业调度

9.银行家算法

10.死锁检测算法

返回首页

/*

进程调度算法有FIFO，优先数调度算法，时间片轮转调度算法，分级调度算法，目前主要是考FIFO和优先数调度算法（静态优先级）。

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

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

输出:

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

本程序包括:FIFO，优先数调度算法，时间片轮转调度算法

VC++调试通过

(C)copyright by Neo

欢迎大家测试请问题请Email:sony006@https://www.360docs.net/doc/a89277016.html,

*/

#include

#include

#include

const int block_time=10; //定义时间片的长度为10秒

const int MAXPCB=100; //定义最大进程数

//定义进程结构体

typedef struct node{

char name[20];

int status;

int time;

int privilege;

int finished;

int wait_time;

}pcb;

pcb pcbs[MAXPCB];

int quantity;

//初始化函数

void initial(){

int i;

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;

}

//读数据函数

int readData(){

FILE *fp;

char fname[20];

int i;

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);

}

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

void init()

{

int i;

for(i=0;i

pcbs[i].finished=0;

pcbs[i].wait_time=0;

}

}

//先进先出算法

void FIFO()

{

int i,j;

int total;

//输出FIFO算法执行流

cout<

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<<"总等待时间:"<

}

//优先数调度算法

void privilege()

{

int i,j,p;

int passed_time=0;

int total;

int queue[MAXPCB];

int current_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<<"进程名等待时间"<

for(i=0;i

cout<<" "<

}

total=0;

for(i=0;i

total+=pcbs[i].wait_time;

}

cout<<"总等待时间:"<

}

//时间片轮转调度算法

void timer()

{

int i,j,number,flag=1;

int passed_time=0;

int max_time=0;

int round=0;

int queue[1000];

int total=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<

for(i=0;i

cout<

}

}

//显示版权信息函数

void version()

{

cout<

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

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

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

cout<<" ┃(c)All Right Reserved Neo ┃"<

cout<<" ┃sony006@https://www.360docs.net/doc/a89277016.html, ┃"<

cout<<" ┃version 2004 build 1122 ┃"<

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

cout<

}

//主函数

void main()

{

int flag;

version();

initial();

flag=readData();

if(flag==1){

FIFO();

init();

privilege();

init();

timer();

}

}

返回首页

/* 可变分区调度算法有:最先适应分配算法,最优适应分配算法,最坏适应算法

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

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

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

1．程序运行时首先接收输入：空闲区数据文件，包括若干行，每行有两个数据项：起始地址、长度（均为整数），各数据项以逗号隔开。

2．建立空闲区表并在屏幕上显示输出空闲区表内容，空闲区表中记录了内存中可供分配的空闲区的始址和长度，用标志位指出该分区是否是未分配的空闲区。

3．从用户界面根据用户提示接收一个内存申请，格式为：作业名、申请空间的大小。

4．按照最差（最坏）适配算法选择一个空闲区，分割并分配，修改相应的数据结构（空闲区表），填写内存已分配区表（起始地址、长度、标志位），其中标志位的一个作用是指出该区域分配给哪个作业。5．重复3、4，直到输入为特殊字符（0）。

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

本程序包括:FIFO,最优适应分配算法,最坏适应算法

VC++调试通过

(C)copyright by Neo

欢迎大家测试请问题请Email:sony006@https://www.360docs.net/doc/a89277016.html,

*/

#include

#include

#include

#include

const int MAXJOB=100;//定义表最大记录数

typedef struct node{

int start;

int length;

char tag[20];

}job;

job frees[MAXJOB];//定义空闲区表

int free_quantity;

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

int occupy_quantity;

//初始化函数

void initial()

{

int i;

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;

}

//读数据函数

int readData()

{

FILE *fp;

char fname[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++;

}

return 1;

}

return 0;

}

//sort

void sort()

int i,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];

}

}

}

//显示函数

void view()

{

int i;

cout<

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

for(i=0;i

cout.setf(2);

cout.width(12);

cout<

cout.width(10);

cout<

cout.width(8);

cout<

}

cout<

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

for(i=0;i

cout.setf(2);

cout.width(12);

cout<

cout.width(10);

cout<

cout.width(8);

cout<

}

//最先适应分配算法

void earliest()

{

char job_name[20];

int job_length;

int i,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<<"内存空间成功:)"<

}

}

//最优适应分配算法

void excellent()

{

char job_name[20];

int job_length;

int i,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

}

}

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<<"内存空间成功:)"<

}

}

}

//最坏适应算法

void worst()

{

char job_name[20];

int job_length;

int i,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<<"内存空间成功:)"<

}

}

}

//撤消作业

void finished()

{

char job_name[20];

int i,j,flag,p=0;

int start;

int length;

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)

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

}

free_quantity--;

p=1;

}

else{

frees[i].length+=length;

p=1;

}

}

if(frees[i].start==(start+length)){

frees[i].start=start;

frees[i].length+=length;

p=1;

}

}

if(p==0){

frees[free_quantity].start=start;

frees[free_quantity].length=length;

free_quantity++;

}

//删除分配表中的该作业

for(i=flag;i

occupys[i]=occupys[i+1];

}

occupy_quantity--;

}

}

//显示版权信息函数

void version()

{

cout<

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

}

void main()

{

int flag=0;

int t=1;

int chioce=0;

version();

initial();

flag=readData();

while(flag==1){

sort();

cout<

cout<<" 可变分区存储管理模拟系统"<

cout<<"========================================================="<

cout<<" 1.申请空间 2.撤消作业 3.显示空闲表和分配表 0.退出"<

cout<<"请选择:";

cin>>chioce;

switch(chioce){

case 1:

//换算法请换下一句调用

earliest();

break;

case 2:

finished();

break;

case 3:

view();

break;

case 0:

flag=0;

break;

default:

cout<<"选择错误!"<

}

}

}

返回首页

/*页式存储管理方案中的内存分配

用户提出内存空间的申请；系统根据申请者的要求，按照一定的分配策略分析内存空间的使用情况，找出能满足请求的空闲区，分给申请者；当程序执行完毕或主动归还内存资源时，系统要收回它所占用的内存空间或它归还的部分内存空间。

1．程序运行时首先接收输入：位示图数据文件，包括若干个0和1，0表示该物理页面为空闲，1表示已分配出去。

2．建立位示图并在屏幕上显示输出位示图内容。假设内存有512个物理页面，字长为32位。（显示时，要求每行显示一个字长）

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

4．按照位示图分配算法进行内存分配，修改相应的数据结构（位示图）。同时，计算每一位所对应的物理页面号，并在屏幕上显示输出物理页面号。（假设所有物理页面从0开始编号）

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

6．在屏幕上显示输出新的位示图内容。

7．测试说明：测试教师将事先准备好一个文件，启动程序运行后，程序首先提示输入文件名，测试教师输入文件名，屏幕上首先显示位示图的内容，然后，测试教师输入其他数据，并查看程序输出结果。*/

#include "stdio.h"

#include

#include

/*

内存类

*/

class MemoryBitMap

{

private:

int m_iSize; //内存大小

char* m_pMem; //内存数组

public:

MemoryBitMap(int iSize); //构造函数，iSize为内存空间大小

~MemoryBitMap(); //释构函数，空间释放

void init(); //依照初始化文件，对内存做初始化

void ShowMe(); //显示内存情况

void MallocMem(int size); //分配内存

void MemSet(int iStart,int iSize,char ch); //设置一段内存的标记

};

//构造函数

MemoryBitMap::MemoryBitMap(int iSize)

{

m_iSize = iSize;

m_pMem = new char[iSize];

}

//释构函数

MemoryBitMap::~MemoryBitMap()

{

delete m_pMem;

}

//初始化

void MemoryBitMap::init()

{

FILE* fp;

int i=0;

char ch;

char file_name[128];

do{

cout<<"请输入内存初始化文件:"; cin>>file_name;

fp = fopen(file_name,"r");

if(fp == NULL){

cout<<"文件名无效，请重试!\n"; }

}while(fp == NULL);

while(i

{

ch = fgetc(fp);

if(ch == EOF)

ch = '0';

if(ch == '0' || ch == '1')

{

m_pMem[i] = ch;

i++;

}

}

return;

}

//显示位图

void MemoryBitMap::ShowMe() {

int i=0;

while(i < m_iSize)

{

for(int j=0;j<32;j++)

{

cout<

i++;

}

cout<

}

return;

}

//分配内存

void MemoryBitMap::MallocMem(int iSize)

{

int iStart = 0;

int iLength;

int iCurrent;

bool bFound = false;

do{

//找到第一个空闲位

while(m_pMem[iStart]=='1' && iStart

iStart++;

}

iLength = 0;

//找从iStart开始的连续的空位

iCurrent = iStart;

while(m_pMem[iCurrent]=='0' && iCurrent

iLength++;

iCurrent++;

if(iLength==iSize){

//找到足够的空间

MemSet(iStart,iSize,'1');

cout<<"分配成功,页面号:"<

}

}

iStart+=iLength;

}while(iStart+iSize<=m_iSize);

cout<<"没有足够的空间可以分配!\n";

return;

}

//设置一段内存的标记

void MemoryBitMap::MemSet(int iStart,int iSize,char ch)

{

for(int i=0; i

{

m_pMem[iStart+i] = ch;

}

return;

}

int main(int argc, char* argv[])

{

int iCommand,iSize;

MemoryBitMap myMemory(512);

myMemory.init();

do{

cout<<"请选择要进行的操作(1 for help)：";

cin>>iCommand;

switch(iCommand){

case 1:

cout<<"1: 帮助。"<

cout<<"2: 显示位示图内容。"<

cout<<"3: 分配空间。"<

cout<<"4：退出。"<

break;

case 2:

cout<<"您选择的操作是显示位示图内容:"<

break;

case 3:

cout<<"您选择的操作是分配内存:"<

cout<<"请输入要分配大额内存大小：";

cin>>iSize;

myMemory.MallocMem(iSize);

break;

case 4:

return 0;

default:

cout<<"错误的命令!"<

}

}while(true);

//*/

return 0;

}

返回首页

/*

页面调度算法主要有：FIFO，最近最少使用调度算法（LRU），最近最不常用调度算法（LFU），最佳算法（OPT）

1．输入：

页面流文件，其中存储的是一系列页面号（页面号用整数表示，用空格作为分隔符），用来模拟待换入的页面。

下面是一个示意：

1 2 3 4 1 2 5 1 2 3 4 5

2．处理要求：

程序运行时，首先提示“请输入页面流文件的文件名：”，输入一个文件名后，程序将读入该文件中的有关数据。

初始条件：采用三个页框，初始时均为空。

根据第二次机会算法对数据进行处理。

3．输出要求：

每换入一个页面（即：每读入一个页面号），判断是否有页面需要被换出。若有，把被换出的页面号输出到屏幕上；

若没有，则输出一个“*”号。

4．文件名约定

提交的源程序名字：sourceXXX.c或者sourceXXX.cpp（依据所用语言确定）

输入文件名字：可由用户指定

其中：XXX为账号。

5．测试说明：测试教师将事先准备好一组文件（格式为*.txt），从中为每个程序随机指定一至三个作为输入文件

（被测试者需从键盘输入指定文件的文件名），并查看程序输出结果。

6．第二次机会算法：对FIFO算法做如下简单的修改：发生替换时，先检查最老页面的R（访问）位。如果为0，

那么此页面是最早被换入的，而且近期没有被访问，可以立刻被替换掉；如果R位为1，就清除R位，并修改它的装入时间，

使它就像刚被装入的新页面一样，然后继续搜索可替换的最老页面。

我没做出来~~~~

页面调度算法主要有：FIFO，最近最少使用调度算法（LRU），最近最不常用调度算法（LFU），最佳算法（OPT）

这几种算法的调度都有可能在考试中碰到。

关于这一类型，大家还可以参看书本251页的实验指导。

如2001年考题：

要求：

1。实现三种算法： FIFO，最近最少使用调度算法（LRU），最近最不常用调度算法（LFU）

2。页面序列从指定的文本文件（TXT文件）中取出

3。输出：

第一行：每次淘汰的页面号

第二行：显示缺页的总次数

本程序包括:FIFO，最近最少使用调度算法（LRU），最近最不常用调度算法（LFU）第二次机会算法 VC++调试通过

(C)copyright by Neo

欢迎大家测试请问题请Email:sony006@https://www.360docs.net/doc/a89277016.html, */

#include

#include

#include

const int MAXSIZE=1000;//定义最大页面数

const int MAXQUEUE=3;//定义页框数

typedef struct node{

int loaded;

int hit;

}page;

page pages[MAXQUEUE]; //定义页框表

int queue[MAXSIZE];

int quantity;

//初始化结构函数

void initial()

{

int i;

for(i=0;i

pages[i].loaded=-1;

pages[i].hit=0;

}

for(i=0;i

queue[i]=-1;

}

quantity=0;

}

//初始化页框函数

void init()

{

int i;

for(i=0;i

pages[i].loaded=-1;

pages[i].hit=0;

}

}

//读入页面流

void readData()

{

FILE *fp;

char fname[20];