操作系统实验五Word文档格式.docx

操作系统实验五Word文档格式.docx

《操作系统实验五Word文档格式.docx》由会员分享，可在线阅读，更多相关《操作系统实验五Word文档格式.docx（22页珍藏版）》请在冰豆网上搜索。

⑦重复跳转到前地址部分、顺序执行、跳转到后地址部分、顺序执行的过程，直至执行320条指令。

代码1：

#include<

iostream.h>

stdlib.h>

#defineFree0//空闲状态

#defineBusy1//已用状态

#defineOK1//完成

#defineERROR0//出错

#defineMAX_length640//最大内存空间为640KB

typedefintStatus;

typedefstructfreearea//定义一个空闲区说明表结构

{intID;

//分区号

longsize;

//分区大小

longaddress;

//分区地址

intstate;

//状态

}ElemType;

//----------线性表的双向链表存储结构------------

typedefstructDuLNode//doublelinkedlist

{ElemTypedata;

structDuLNode*prior;

//前趋指针

structDuLNode*next;

//后继指针

}DuLNode,*DuLinkList;

DuLinkListblock_first;

//头结点

DuLinkListblock_last;

//尾结点

Statusalloc（int）;

//内存分配

Statusfree（int）;

//内存回收

StatusFirst_fit（int,int）;

//首次适应算法

StatusBest_fit（int,int）;

//最佳适应算法

voidshow（）;

//查看分配

StatusInitblock（）;

//开创空间表

StatusInitblock（）//开创带头结点的内存空间链表

{

block_first=（DuLinkList）malloc（sizeof（DuLNode））;

block_last=（DuLinkList）malloc（sizeof（DuLNode））;

block_first->

prior=NULL;

next=block_last;

block_last->

prior=block_first;

next=NULL;

data.address=0;

data.size=MAX_length;

data.ID=0;

data.state=Free;

returnOK;

}

//-----------------------分配主存-------------------------

Statusalloc（intch）

intID,request;

cout<

<

"

请输入作业（分区号）：

;

cin>

>

ID;

请输入需要分配的主存大小（单位:

KB）：

request;

if（request<

0||request==0）

{

cout<

分配大小不合适，请重试！

endl;

returnERROR;

}

if（ch==2）//选择最佳适应算法

{if（Best_fit（ID,request）==OK）cout<

分配成功！

elsecout<

内存不足，分配失败！

returnOK;

else//默认首次适应算法

{if（First_fit（ID,request）==OK）cout<

}

//------------------首次适应算法-----------------------

StatusFirst_fit（intID,intrequest）//传入作业名及申请量

//为申请作业开辟新空间且初始化

DuLinkListtemp=（DuLinkList）malloc（sizeof（DuLNode））;

temp->

data.ID=ID;

data.size=request;

data.state=Busy;

DuLNode*p=block_first->

next;

while（p）

if（p->

data.state==Free&

&

p->

data.size==request）

{//有大小恰好合适的空闲块

p->

returnOK;

break;

}

data.size>

request）

{//有空闲块能满足需求且有剩余"

temp->

prior=p->

prior;

next=p;

data.address=p->

data.address;

prior->

next=temp;

prior=temp;

data.address=temp->

data.address+temp->

data.size;

data.size-=request;

p=p->

returnERROR;

//--------------------最佳适应算法------------------------

StatusBest_fit（intID,intrequest）

intch;

//记录最小剩余空间

DuLNode*q=NULL;

//记录最佳插入位置

while（p）//初始化最小空间和最佳位置

（p->

request||p->

data.size==request））

{q=p;

ch=p->

data.size-request;

{//空闲块大小恰好合适

{//空闲块大于分配需求

if（p->

data.size-request<

ch）//剩余空间比初值还小

{

ch=p->

//更新剩余最小值

q=p;

//更新最佳位置指向

}

if（q==NULL）returnERROR;

//没有找到空闲块

else

{//找到了最佳位置并实现分配

temp->

prior=q->

next=q;

data.address=q->

q->

data.address+=request;

data.size=ch;

//-----------------------主存回收--------------------

Statusfree（intID）

DuLNode*p=block_first;

{if（p->

data.ID==ID）

{

data.ID=Free;

data.state==Free）//与前面的空闲块相连

{p->

data.size+=p->

p->

next=p->

next->

data.state==Free）//与后面的空闲块相连

prior=p;

break;

//---------------显示主存分配情况------------------

voidshow（）

{cout<

+++++++++++++++++++++++++++++++++++++++/n"

+++主存分配情况+++/n"

{cout<

分区号：

data.ID==Free）cout<

Free"

p->

data.ID<

起始地址：

data.address<

分区大小：

data.size<

KB"

状态：

data.state==Free）cout<

空闲"

已分配"

——————————————"

//-----------------------主函数---------------------------

voidmain（）

//算法选择标记

动态分区分配方式的模拟/n"

************************************/n"

**1）首次适应算法2）最佳适应算法**/n"

请选择分配算法：

ch;

Initblock（）;

//开创空间表

intchoice;

//操作选择标记

while

（1）

********************************************/n"

**1:

分配内存2:

回收内存**/n"

**3:

查看分配0:

退出**/n"

请输入您的操作：

choice;

if（choice==1）alloc（ch）;

//分配内存

elseif（choice==2）//内存回收

intID;

cout<

请输入您要释放的分区号：

cin>

free（ID）;

elseif（choice==3）show（）;

//显示主存

elseif（choice==0）break;

//退出

else//输入操作有误

{cout<

输入有误，请重试！

continue;

代码2：

#include<

conio.h>

stdio.h>

#defineBsize4

typedefstructBLOCK//声明一种新类型——物理块类型

{

intpagenum;

//页号

intaccessed;

//访问字段，其值表示多久未被访问

}BLOCK;

intpc;

//程序计数器，用来记录指令的序号

intn;

//缺页计数器，用来记录缺页的次数

staticinttemp[320];

//用来存储320条随机数

BLOCKblock[Bsize];

//定义一大小为4的物理块数组

voidinit（）;

//程序初始化函数

intfindExist（intcurpage）;

//查找物理块中是否有该页面

intfindSpace（）;

//查找是否有空闲物理块

intfindReplace（）;

//查找应予置换的页面

voiddisplay（）;

//显示

voidsuijishu（）;

//产生320条随机数,显示并存储到temp[320]

voidpagestring（）;

//显示调用的页面队列

voidOPT（）;

//OPT算法

voidLRU（）;

//LRU算法

voidFIFO（）;

//FIFO算法

voidinit（）

for（inti=0;

i<

Bsize;

i++）

block[i].pagenum=-1;

block[i].accessed=0;

pc=n=0;

intfindExist（intcurpage）

i<

i++）

if（block[i].pagenum==curpage）

returni;

//检测到内存中有该页面，返回block中的位置

return-1;

intfindSpace（）

for（inti=0;

if（block[i].pagenum==-1）

//找到空闲的block，返回block中的位置

}

intfindReplace（）

intpos=0;

if（block[i].accessed>

block[pos].accessed）

pos=i;

//找到应予置换页面，返回BLOCK中位置

returnpos;

voiddisplay（）

if（block[i].pagenum!

=-1）

{printf（"

%02d"

block[i].pagenum）;

cout<

voidsuijishu（）

{intflag=0;

cin>

pc;

******按照要求产生的320个随机数：

*******"

320;

i++）

{

temp[i]=pc;

if（flag%2==0）pc=++pc%320;

if（flag==1）pc=rand（）%（pc-1）;

if（flag==3）pc=pc+1+（rand（）%（320-（pc+1）））;

flag=++flag%4;

printf（"

%03d"

temp[i]）;

if（（i+1）%10==0）cout<

voidpagestring（）

printf（"

temp[i]/10）;

voidOPT（）

intexist,space,position;

intcurpage;

if（i%100==0）getch（）;

pc=temp[i];

curpage=pc/10;

exist=findExist（curpage）;

if（exist==-1）

space=findSpace（）;

if（space!

block[space].pagenum=curpage;

display（）;

n=n+1;

else

for（intk=0;

k<

k++）

{

for（intj=i;

j<

j++）

{

if（block[k].pagenum!

=temp[j]/10）

{

block[k].accessed=1000;

}//将来不会用，设置为一个很大数

{

block[k].accessed=j;

break;

}

}

}

position=findReplace（）;

block[position].pagenum=curpage;

n++;

缺页次数:

n<

缺页率:

（n/320.0）*100<

%"

//-------------------------------------------------------------

voidLRU（）

space=findSpace（）;

elseblock[exist].accessed=-1;

//恢复存在的并刚访问过的BLOCK中页面accessed为-1

for（intj=0;

j<

4;

j++）

{block[j].accessed++;

//-------------------------------------------------------------

voidFIFO（）