A. 操作系统上机实验—存储管理
#include<stdio.h>#include <dos.h>#include<stdlib.h>#include<conio.h>#include<iostream.h>
#define n 10 /*假定系统允许的最大作业数为n，假定模拟实验中n值为10*/ #define m 10 /*假定系统允许的空闲区表最大为m，假定模拟实验中m值为10*/ #define minisize 100 /*空闲分区被分配时，如果分配后剩余的空间小于minisize，则将该空闲分区全部分配，若大于minisize，则切割分配*/
struct { float address; /*已分配分区起始地址*/ float length; /*已分配分区长度，单位为字节*/ int flag; /*已分配区表登记栏标志，用"0"表示空栏目*/ }used_table[n]; /*已分配区表*/
struct { float address; /*空闲区起始地址*/ float length; /*空闲区长度，单位为字节*/ int flag; /*空闲区表登记栏标志，用"0"表示空栏目，用"1"表示未分配*/ }free_table[m]; /*空闲区表*/
void allocate(char J,float xk) /*给J作业，采用最佳分配算法分配xk大小的空间*/ { int i,k; float ad; k=-1;
for(i=0;i<m;i++) /*寻找空间大于xk的最小空闲区登记项k*/ if(free_table[i].length>=xk&&free_table[i].flag==1) if(k==-1||free_table[i].length<free_table[k].length) k=i; if(k==-1)/*未找到可用空闲区，返回*/ { printf("无可用空闲区\n"); return; }
/*找到可用空闲区，开始分配：若空闲区大小与要求分配的空间差小于minisize大小，则空闲区全部分配；若空闲区大小与要求分配的空间差大于minisize大小，则从空闲区划出一部分分配*/ if(free_table[k].length-xk<=minisize) { free_table[k].flag=0; ad=free_table[k].address; xk=free_table[k].length; } else { free_table[k].length=free_table[k].length-xk; ad=free_table[k].address+free_table[k].length; } /*修改已分配区表*/ i=0; while(used_table[i].flag!=0&&i<n) /*寻找空表目*/ i++;
if(i>=n) /*无表目可填写已分配分区*/ { printf("无表目填写已分分区，错误\n");
/*修正空闲区表*/ if(free_table[k].flag==0) /*前面找到的是整个空闲分区*/ free_table[k].flag=1; else {/*前面找到的是某个空闲分区的一部分*/ free_table[k].length=free_table[k].length+xk; return; } } else {/*修改已分配表*/ used_table[i].address=ad; used_table[i].length=xk; used_table[i].flag=J; }
return; }/*主存分配函数结束*/
void reclaim(char J) /*回收作业名为J的作业所占主存空间*/ { int i,k,j,s,t; float S,L;
/*寻找已分配表中对应登记项*/ s=0; while((used_table[s].flag!=J||used_table[s].flag==0)&&s<n) s++;
if(s>=n)/*在已分配表中找不到名字为J的作业*/ { printf("找不到该作业\n"); return; }
/*修改已分配表*/ used_table[s].flag=0;
/*取得归还分区的起始地址S和长度L*/ S=used_table[s].address; L=used_table[s].length; j=-1;k=-1;i=0;
/*寻找回收分区的空闲上下邻，上邻表目k，下邻表目j*/ while(i<m&&(j==-1||k==-1)) { if(free_table[i].flag==1) { if(free_table[i].address+free_table[i].length==S)k=i;/*找到上邻*/ if(free_table[i].address==S+L)j=i;/*找到下邻*/ } i++; }
if(k!=-1) if(j!=-1) /* 上邻空闲区，下邻空闲区，三项合并*/ { free_table[k].length=free_table[j].length+free_table[k].length+L; free_table[j].flag=0; } else /*上邻空闲区，下邻非空闲区，与上邻合并*/ free_table[k].length=free_table[k].length+L; else if(j!=-1) /*上邻非空闲区，下邻为空闲区，与下邻合并*/ { free_table[j].address=S; free_table[j].length=free_table[j].length+L; } else /*上下邻均为非空闲区，回收区域直接填入*/ { /*在空闲区表中寻找空栏目*/ t=0; while(free_table[t].flag==1&&t<m) t++; if(t>=m)/*空闲区表满,回收空间失败,将已分配表复原*/ { printf("主存空闲表没有空间,回收空间失败\n"); used_table[s].flag=J; return; } free_table[t].address=S; free_table[t].length=L; free_table[t].flag=1; } return; }/*主存回收函数结束*/
int main( ) { int i,a; float xk; char J;
/*空闲分区表初始化：*/ free_table[0].address=10240; /*起始地址假定为10240*/ free_table[0].length=10240; /*长度假定为10240，即10k*/ free_table[0].flag=1; /*初始空闲区为一个整体空闲区*/ for(i=1;i<m;i++) free_table[i].flag=0; /*其余空闲分区表项未被使用*/
/*已分配表初始化：*/ for(i=0;i<n;i++) used_table[i].flag=0; /*初始时均未分配*/
while(1) { printf("选择功能项（0-退出,1-分配主存,2-回收主存,3-显示主存）\n"); printf("选择功项(0~3) :");
scanf("%d",&a); switch(a) { case 0: exit(0); /*a=0程序结束*/
case 1: /*a=1分配主存空间*/ printf("输入作业名J和作业所需长度xk: "); scanf("%*c%c%f",&J,&xk); allocate(J,xk); /*分配主存空间*/ break;
case 2: /*a=2回收主存空间*/ printf("输入要回收分区的作业名"); scanf("%*c%c",&J); reclaim(J); /*回收主存空间*/ break;
case 3: /*a=3显示主存情况*/ /*输出空闲区表和已分配表的内容*/ printf("输出空闲区表：\n起始地址 分区长度 标志\n"); for(i=0;i<m;i++) printf("%6.0f%9.0f%6d\n",free_table[i].address,free_table[i].length, free_table[i].flag); printf(" 按任意键,输出已分配区表\n"); getch(); printf(" 输出已分配区表：\n起始地址 分区长度 标志\n"); for(i=0;i<n;i++) if(used_table[i].flag!=0) printf("%6.0f%9.0f%6c\n",used_table[i].address,used_table[i].length, used_table[i].flag); else printf("%6.0f%9.0f%6d\n",used_table[i].address,used_table[i].length, used_table[i].flag); break;
default:printf("没有该选项\n"); }/*case*/ }/*while*/
return 1;}
B. 模拟实现一个简单的固定(或可变)分区存储管理系统 课程设计 帮帮忙啊
会使一个程序变得过于的庞大而对编写过程中的调试模拟实现可变分区存储管理(代码 文档) 一、设计目的在熟练掌握计算机分区存储管理方式的原理的基础
C. “银行家算法程序，先来先服务调度算法，存储管理的模拟实现”
-
#include<stdio.h>
#include<string.h>
#include<iostream>
#include<stdlib.h>
#include<iomanip>
#include<conio.h>
using namespace std;
const int MAX_P=20;
const int MAXA=10; //定义A类资源的数量
const int MAXB=5;
const int MAXC=7;
typedef struct node{
int a;
int b;
int c;
int remain_a;
int remain_b;
int remain_c;
}bank;
typedef struct node1{
char name[20];
int a;
int b;
int c;
int need_a;
int need_b;
int need_c;
}process;
bank banker;
process processes[MAX_P];
int quantity;
//初始化函数
void initial()
{
int i;
banker.a=MAXA;
banker.b=MAXB;
banker.c=MAXC;
banker.remain_a=MAXA;
banker.remain_b=MAXB;
banker.remain_c=MAXC;
for(i=0;i<MAX_P;i++){
strcpy(processes[i].name,"");
processes[i].a=0;
processes[i].b=0;
processes[i].c=0;
processes[i].need_a=0;
processes[i].need_b=0;
processes[i].need_c=0;
}
}
//新加作业
void add()
{
char name[20];
int flag=0;
int t;
int need_a,need_b,need_c;
int i;
cout<<endl;
cout<<"新加作业"<<endl;
cout<<"━━━━━━━━━━━━━━━━━━━━━━━━━━━━"<<endl;
cout<<"请输入新加作业名:";
cin>>name;
for(i=0;i<quantity;i++){
if(!strcmp(processes[i].name,name)){
flag=1;
break;
}
}
if(flag){
cout<<"错误,作业已存在"<<endl;
}
else{
cout<<"本作业所需A类资源:";
cin>>need_a;
cout<<"本作业所需B类资源:";
cin>>need_b;
cout<<"本作业所需C类资源:";
cin>>need_c;
t=1;
cout<<need_a<<banker.remain_a;
if(need_a>banker.remain_a){
cout<<"错误,所需A类资源大于银行家所剩A类资源"<<endl;
t=0;
}
if(need_b>banker.remain_b){
cout<<"错误,所需B类资源大于银行家所剩B类资源"<<endl;
t=0;
}
if(need_c>banker.remain_c){
cout<<"错误,所需C类资源大于银行家所剩C类资源"<<endl;
t=0;
}
if(t){
strcpy(processes[quantity].name,name);
processes[quantity].need_a=need_a;
processes[quantity].need_b=need_b;
processes[quantity].need_c=need_c;
quantity++;
cout<<"新加作业成功"<<endl;
}
else{
cout<<"新加作业失败"<<endl;
}
}
}
//为作业申请资源
void bid()
{
char name[20];
int i,p;
int a,b,c;
int flag;
cout<<endl<<"为作业申请资源"<<endl;
cout<<"━━━━━━━━━━━━━━━━━━━━━━━━━━━━"<<endl;
cout<<"要申请资源的作业名:";
cin>>name;
p=-1;
for(i=0;i<quantity;i++){
if(!strcmp(processes[i].name,name)){
p=i;
break;
}
}
if(p!=-1){
cout<<"该作业要申请A类资源数量:";
cin>>a;
cout<<"该作业要申请B类资源数量:";
cin>>b;
cout<<"该作业要申请C类资源数量:";
cin>>c;
flag=1;
if((a>banker.remain_a)||(a>processes[p].need_a-processes[p].a)){
cout<<"错误,所申请A类资源大于银行家所剩A类资源或该进程还需数量"<<endl;
flag=0;
}
if((b>banker.remain_b)||(b>processes[p].need_b-processes[p].b)){
cout<<"错误,所申请B类资源大于银行家所剩B类资源或该进程还需数量"<<endl;
flag=0;
}
if((c>banker.remain_c)||(c>processes[p].need_c-processes[p].c)){
cout<<"错误,所申请C类资源大于银行家所剩C类资源或该进程还需数量"<<endl;
flag=0;
}
if(flag){
banker.remain_a-=a;
banker.remain_b-=b;
banker.remain_c-=c;
processes[p].a+=a;
processes[p].b+=b;
processes[p].c+=c;
cout<<"为作业申请资源成功"<<endl;
}
else{
cout<<"为作业申请资源失败"<<endl;
}
}
else{
cout<<"该作业不存在"<<endl;
}
}
//撤消作业
void finished()
{
char name[20];
int i,p;
cout<<endl<<"撤消作业"<<endl;
cout<<"━━━━━━━━━━━━━━━━━━━━━━━━━━━━"<<endl;
cout<<"要撤消作业名:";
cin>>name;
p=-1;
for(i=0;i<quantity;i++){
if(!strcmp(processes[i].name,name)){
p=i;
break;
}
}
if(p!=-1){
banker.remain_a+=processes[p].a;
banker.remain_b+=processes[p].b;
banker.remain_c+=processes[p].c;
for(i=p;i<quantity-1;i++){
processes[i]=processes[i+1];
}
strcpy(processes[quantity-1].name,"");
processes[quantity-1].a=0;
processes[quantity-1].b=0;
processes[quantity-1].c=0;
processes[quantity-1].need_a=0;
processes[quantity-1].need_b=0;
processes[quantity-1].need_c=0;
quantity--;
cout<<"撤消作业成功"<<endl;
}
else{
cout<<"撤消作业失败"<<endl;
}
}
//查看资源情况
void view()
{
int i;
cout<<endl<<"查看资源情况"<<endl;
cout<<"━━━━━━━━━━━━━━━━━━━━━━━━━━━━"<<endl;
cout<<"银行家所剩资源(剩余资源/总共资源)"<<endl;
cout<<"A类:"<<banker.remain_a<<"/"<<banker.a;
cout<<" B类:"<<banker.remain_b<<"/"<<banker.b;
cout<<" C类:"<<banker.remain_c<<"/"<<banker.c;
cout<<endl<<endl<<"作业占用情况(已占用资源/所需资源)"<<endl<<endl;
if(quantity>0){
for(i=0;i<quantity;i++){
cout<<"作业名:"<<processes[i].name<<endl;
cout<<"A类:"<<processes[i].a<<"/"<<processes[i].need_a;
cout<<" B类:"<<processes[i].b<<"/"<<processes[i].need_b;
cout<<" C类:"<<processes[i].c<<"/"<<processes[i].need_c;
cout<<endl;
}
}
else{
cout<<"当前没有作业"<<endl;
}
}
//显示版权信息函数
void version()
{
cout<<endl<<endl;
cout<<" ┏━━━━━━━━━━━━━━━━━━━━━━━┓"<<endl;
cout<<" ┃ 银 行 家 算 法 ┃"<<endl;
cout<<" ┠———————————————————————┨"<<endl;
cout<<" ┃ (c)All Right Reserved Neo ┃"<<endl;
cout<<" ┃ [email protected] ┃"<<endl;
cout<<" ┃ version 2004 build 1122 ┃"<<endl;
cout<<" ┗━━━━━━━━━━━━━━━━━━━━━━━┛"<<endl;
cout<<endl<<endl;
}
int main(void)
{
int chioce;
int flag=1;
initial();
version();
while(flag){
cout<<"━━━━━━━━━━━━━━━━━━━━━━━━━━━━"<<endl;
cout<<"1.新加作业 2.为作业申请资源 3.撤消作业"<<endl;
cout<<"4.查看资源情况 0.退出系统"<<endl;
cout<<"请选择:";
cin>>chioce;
switch(chioce){
case 1:
add();
break;
case 2:
bid();
break;
case 3:
finished();
break;
case 4:
view();
break;
case 0:
flag=0;
break;
default:
cout<<"选择错误"<<endl<<endl;
}
}
return 0;
}
D. （操作系统） 编写代码对存储管理部件的工作过程进行模拟
采用分页存储器允许把一个作业存放到若干不相邻的分区中，既可免去移动信息的工作，又可尽量减少主存的碎片。分页式存储管理的基本原理如下：
1、 页框：物理地址分成大小相等的许多区，每个区称为一块；
2、址分成大小相等的区，区的大小与块的大小相等，每个称一个页面。
3、 逻辑地址形式：与此对应，分页存储器的逻辑地址由两部分组成，页号和单元号。逻辑地址格式为 页号 单元号（页内地址） 采用分页式存储管理时，逻辑地址是连续的。所以，用户在编制程序时仍只须使用顺序的地址，而不必考虑如何去分页。
4、页表和地址转换：如何保证程序正确执行呢？
采用的办法是动态重定位技术，让程序的指令执行时作地址变换，由于程序段以页为单位，所以，我们给每个页设立一个重定位寄存器，这些重定位寄存器的集合便称页表。页表是操作系统为每个用户作业建立的，用来记录程序页面和主存对应页框的对照表，页表中的每一栏指明了程序中的一个页面和分得的页框的对应关系。绝对地址=块号*块长+单元号 以上从拓扑结构角度分析了对称式与非对称式虚拟存储方案的异同,实际从虚拟化存储的实现原理来讲也有两种方式;即数据块虚拟与虚拟文件系统. 数据块虚拟存储方案着重解决数据传输过程中的冲突和延时问题.在多交换机组成的大型Fabric结构的SAN中,由于多台主机通过多个交换机端口访问存储设备,延时和数据块冲突问题非常严重.数据块虚拟存储方案利用虚拟的多端口并行技术,为多台客户机提供了极高的带宽,最大限度上减少了延时与冲突的发生,在实际应用中,数据块虚拟存储方案以对称式拓扑结构为表现形式. 虚拟文件系统存储方案着重解决大规模网络中文件共享的安全机制问题.通过对不同的站点指定不同的访问权限,保证网络文件的安全.在实际应用中,虚拟文件系统存储方案以非对称式拓扑结构为表现形式. 虚拟存储技术,实际上是虚拟存储技术的一个方面,特指以CPU时间和外存空间换取昂贵内存空间的操作系统中的资源转换技术 基本思想:程序,数据,堆栈的大小可以超过内存的大小,操作系统把程序当前使用的部分保留在内存,而把其他部分保存在磁盘上,并在需要时在内存和磁盘之间动态交换,虚拟存储器支持多道程序设计技术 目的:提高内存利用率 管理方式
A 请求式分页存储管理 在进程开始运行之前,不是装入全部页面,而是装入一个或零个页面,之后根据进程运行的需要,动态装入其他页面;当内存空间已满,而又需要装入新的页面时,则根据某种算法淘汰某个页面,以便装入新的页面
B 请求式分段存储管理 为了能实现虚拟存储,段式逻辑地址空间中的程序段在运行时并不全部装入内存,而是如同请求式分页存储管理,首先调入一个或若干个程序段运行,在运行过程中调用到哪段时,就根据该段长度在内存分配一个连续的分区给它使用.若内存中没有足够大的空闲分区,则考虑进行段的紧凑或将某段或某些段淘汰出去,这种存储管理技术称为请求式分段存储管理
你好，希望采纳！
E. C++模拟动态存储管理的程序。
include<iomanip.h>
#include<iostream.h>
//节点元素类型
typedef unsigned long ELEMENT;
struct NODE
{ ELEMENT element1; //存放第一个元素
ELEMENT element2; //存放第二个元素
NODE* next; //指向下一个节点的链
};
class LINKLIST{
public:
LINKLIST(); //构造函数，设置链头、链尾为空指针，节点个数为0
~LINKLIST(); //析构函数，释放链表占用的内存空间
int is_empty(); //判断当前链表是否为空，是则返回1，否则返回2
NODE* get_top(); //取链头的节点
NODE* get_bottom(); //取链尾的节点
unsigned long get_num(); //取链表的节点个数
void print(); //自头向尾输出链表
NODE* del(ELEMENT ad); //在链表中删除第一元素ad所对应的节点,并返回指向该节点的指针
NODE* insert(NODE* insertor); //在链表中按节点第一元素大小从小到大插入节点insertor ,并返回指向该节点的前一个节点的指针
NODE* combine(NODE* left, NODE* right); //将右节点与左节点结合,能结合则返回指向左节点的指针left,否则返回指向右节点的指针right
private:
NODE* top; //指向链头的指针
NODE* bottom; //指向链尾的指针
unsigned long num; //链中节点的个数
};
F. 请求调页存储管理方式的模拟,谢谢，急 啊 ！
这可是hen宝贵的啊
#include <iostream.h>
#include<stdlib.h>
#include<conio.h>
#include<stdio.h>
#define Bsize 4
typedef struct BLOCK//声明一种新类型——物理块类型
{
int pagenum;//页号
int accessed;//访问字段，其值表示多久未被访问
}BLOCK;
int pc;//程序计数器，用来记录指令的序号
int n;//缺页计数器，用来记录缺页的次数
static int temp[320];//用来存储320条随机数
BLOCK block[Bsize]; //定义一大小为4的物理块数组
//*************************************************************
void init( ); //程序初始化函数
int findExist(int curpage);//查找物理块中是否有该页面
int findSpace( );//查找是否有空闲物理块
int findReplace( );//查找应予置换的页面
void display ( );//显示
void suijishu( );//产生320条随机数,显示并存储到temp[320]
void pagestring( );//显示调用的页面队列
void OPT( );//OPT算法
void LRU( );// LRU算法
void FIFO( );//FIFO算法
//*************************************************************
void init( )
{
for(int i=0;i<Bsize;i++)
{
block[i].pagenum=-1;
block[i].accessed=0;
pc=n=0;
}
}
//-------------------------------------------------------------
int findExist(int curpage)
{
for(int i=0; i<Bsize; i++)
{
if(block[i].pagenum == curpage )
return i;//检测到内存中有该页面，返回block中的位置
}
return -1;
}
//-------------------------------------------------------------
int findSpace( )
{
for(int i=0; i<Bsize; i++)
{
if(block[i].pagenum == -1)
return i;//找到空闲的block，返回block中的位置
}
return -1;
}
//-------------------------------------------------------------
int findReplace( )
{
int pos = 0;
for(int i=0; i<Bsize; i++)
{
if(block[i].accessed >block[pos].accessed)
pos = i;//找到应予置换页面，返回BLOCK中位置
}
return pos;
}
//-------------------------------------------------------------
void display( )
{
for(int i=0; i<Bsize; i++)
{
if(block[i].pagenum != -1)
{ printf(" %02d",block[i].pagenum);}
}
cout<<endl;
}
//-------------------------------------------------------------
void suijishu( )
{ int flag=0;
cin>>pc;
cout<<"******按照要求产生的320个随机数：*******"<<endl;
for(int i=0;i<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<<endl;
}
}
//-------------------------------------------------------------
void pagestring( )
{
for(int i=0;i<320;i++)
{
printf(" %02d",temp[i]/10);
if((i+1)%10==0) cout<<endl;
}
}
//-------------------------------------------------------------
void OPT( )
{
int exist,space,position ;
int curpage;
for(int i=0;i<320;i++)
{
if(i%100==0) getch( );
pc=temp[i];
curpage=pc/10;
exist = findExist(curpage);
if(exist==-1)
{
space = findSpace ( );
if(space != -1)
{
block[space].pagenum = curpage;
display( );
n=n+1;
}
else
{
for(int k=0;k<Bsize;k++)
{
for(int j=i;j<320;j++)
{
if(block[k].pagenum!= temp[j]/10)
{
block[k].accessed = 1000;
}//将来不会用，设置为一个很大数
else
{
block[k].accessed = j;
break;
}
}
}
position = findReplace( );
block[position].pagenum = curpage;
display( );
n++;
}
}
}
cout<<"缺页次数:"<<n<<endl;
cout<<"缺页率:"<<(n/320.0)*100<<"%"<<endl;
}
//-------------------------------------------------------------
void LRU( )
{
int exist,space,position ;
int curpage;
for(int i=0;i<320;i++)
{
if(i%100==0) getch( );
pc=temp[i];
curpage=pc/10;
exist = findExist(curpage);
if(exist==-1)
{
space = findSpace( );
if(space != -1)
{
block[space].pagenum = curpage;
display( );
n=n+1;
}
else
{
position = findReplace( );
block[position].pagenum = curpage;
display( );
n++;
}
}
else block[exist].accessed = -1;//恢复存在的并刚访问过的BLOCK中页面accessed为-1
for(int j=0; j<4; j++)
{block[j].accessed++;}
}
cout<<"缺页次数:"<<n<<endl;
cout<<"缺页率:"<<(n/320.0)*100<<"%"<<endl;
}
//-------------------------------------------------------------
void FIFO( )
{
int exist,space,position ;
int curpage;
for(int i=0;i<320;i++)
{
if(i%100==0) getch( );
pc=temp[i];
curpage=pc/10;
exist = findExist(curpage);
if(exist==-1)
{
space = findSpace( );
if(space != -1)
{
block[space].pagenum = curpage;
display( );
n=n+1;
}
else
{
position = findReplace( );
block[position].pagenum = curpage;
display( );
n++;
block[position].accessed--;
}
}
for(int j=0; j<Bsize; j++)
block[j].accessed++;
}
cout<<"缺页次数:"<<n<<endl;
cout<<"缺页率:"<<(n/320.0)*100<<"%"<<endl;
}
//*************************************************************
void main( )
{
int select;
cout<<"请输入第一条指令号(0~320)：";
suijishu( );
cout<<"*****对应的调用页面队列*******"<<endl;
pagestring( );
do
{
cout<<"****************************************"<<endl;
cout<<"------1:OPT 2:LRU 3:FIFO 4:退出-----"<<endl;
cout<<"****************************************"<<endl;
cout<<" 请选择一种页面置换算法:";
cin>>select;
cout<<"****************************************"<<endl;
init( );
switch(select)
{
case 1:cout<<"最佳置换算法OPT:"<<endl;
cout<<"*****************"<<endl;
OPT( );
break;
case 2:cout<<"最近最久未使用置换算法LRU:"<<endl;
cout<<"**************************"<<endl;
LRU( );
break;
case 3:cout<<"先进先出置换算法FIFO:"<<endl;
cout<<"*********************"<<endl;
FIFO( );
break;
default: ;
}
}while(select!=4);
}
你试试可以不，应该没问题的
要注意这是用C++编写的，你改一下就可以用了
G. 题目名称：请求分页存储器的管理 目的和要求：学生编写几个常用存储分配算法，并能设计一个存储器的模拟程
就按算法思路来做，选一个将来不用的，则任选一个就是了。
做这种题并不一定就只有一种解，操作系统运行用户不是无法预知嘛，可以说在当前条件下，这三个都有可能。
H. 模拟实现一个简单的固定（或可变）分区存储管理系统
int i,j,flag,t;
printf("请输入新申请内存空间的作业名和空间大小:"); scanf("%s",job_name); scanf("%d",&job_length); flag=0;
for(i=0;i<free_quantity;i++) { if(frees[i].length>=job_length) //如果空闲空间I的长度>=作业长度 {
flag=1; //空闲标志位就置1 }
} if(flag==0) { printf("对不起,当前没有能满足你申请长度的空闲内存,请稍候再试！\n"); } else { t=0; i=0;
while(t==0) //为空闲区间的时候 {
if(frees[i].length>=job_length) {
t=1;
}
i++;//如果空闲空间I的长度不大于作业长度，I加1，判断下一个空间 } i--;
occupys[occupy_quantity].front=frees[i].front;//把未用的空闲空间的首地址付给已用空间的首地址
strcpy(occupys[occupy_quantity].data,job_name);//已用空间的内容为作业名 occupys[occupy_quantity].length=job_length;//已用空间的长度为作业的长度 occupy_quantity++; //已用空间数量加1
if(frees[i].length>job_length) //如果空间的长度大于作业的长度， {
frees[i].front+=job_length; //空闲空间的起始首地址=原空闲区间的起始长度加
作业长度 frees[i].length-=job_length;//空闲区间的长度=原空闲区间的长度-作业的长度 }
else //如果空间的长度=作业的长度 {
for(j=i;j<free_quantity-1;j++) {
frees[j]=frees[j+1];//空闲区间前移一位
}
free_quantity--;//空闲区间的数量减一 }
printf("内存空间分配成功!\n");
}
}
//撤消作业 void cancel() { char job_name[20]; int i,j,flag,p=0; int start; int len;
printf("请输入要撤消的作业名:"); scanf("%s",job_name); flag=0;
for(i=0;i<occupy_quantity;i++) {
if(!strcmp(occupys[i].data,job_name))//当输入作业名匹配时 {
flag=i;//把i的值赋给flag;
start=occupys[i].front;//把已用空间的首地址赋给start len=occupys[i].length;//把已用空间的长度赋给len } } if(flag==0)
{
printf("没有这个作业名，请重新输入作业名！\n"); } else
{ //加入空闲表 for(i=0;i<free_quantity;i++) {
if((frees[i].front+frees[i].length)==start)//上空 { if(((i+1)<free_quantity)&&(frees[i+1].front==start+len))//下空
{
//第i个空闲区间的长度=第i个空闲区间的长度+第i+1个空闲区间的长度（下空闲区）+length
frees[i].length=frees[i].length+frees[i+1].length+len; for(j=i+1;j<free_quantity;j++)
{ frees[j]=frees[j+1];//空闲区间前移一位 }
free_quantity--;//空闲区的数量渐少了一个 p=1;
} else {
frees[i].length+=len;//（上空下不空）第i个空闲区间的长度=第i个空闲区间的长度+length，空闲区个数不变
p=1;
}
}
if(frees[i].front==(start+len))//下空上不空 { frees[i].front=start;//起始地址等于待回收地址
frees[i].length+=len;//第i个空闲区间的长度=第i个空闲区间的长度+length p=1;
}
}
if(p==0) //上下空闲区都不空（直接在空闲区表中找一个空表目，将其内容插入） {
frees[free_quantity].front=start;
frees[free_quantity].length=len; free_quantity++; //空闲区的数量加1 }
//删除分配表中的该作业 for(i=flag;i<occupy_quantity;i++) {
occupys[i]=occupys[i+1]; }
occupy_quantity--;//已用的区的数量 printf("内存空间回收完毕!\n"); }
}
//主函数 void main() { int flag=0; int t=1; int chioce=0;
printf(" |--------------------------------------------------|\n");
printf(" | 可变分区存储管理模拟系统 |\n"); printf(" |--------------------------------------------------|\n"); printf(" |菜单： (0)退出 |\n");
printf(" | |\n"); printf(" | (1)申请空间 (2)撤消作业 |\n"); printf(" | |\n"); printf(" | (3)显示空闲表和分配表 |\n");
printf(" |--------------------------------------------------|\n"); initial(); flag=initial(); while(flag==1) { printf("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n"); printf("请选择:"); scanf("%d",&chioce); switch(chioce)
{
case 1: assign(); break; case 2: cancel(); break; case 3: show(); break; case 0: flag=0; break; default:
printf("选择错误!"); }
}
}
I. 设计一个请求页式存储管理方案，并编写模拟程序实现之。
#include "utility.h"
#include "lk_queue.h"
//定义页表结构
struct table
{
int no; //页号
int state; //状态位（1 表示在内存,0 表示不在内存）
int block_no; //块号
};
void main()
{
int loc[10]; //直接用的是十进制的逻辑地址
int i,j,e;
table page_table[64];
LinkQueue <int> bno;
//随机逻辑地址并显示出来
cout<<"十进制的逻辑地址：";
for( i=0;i<10;i++)
{
loc[i]=rand()%640000;
cout<<loc[i]<<" ";
}
cout<<endl<<endl;
//初始化页表
for( i=0;i<64;i++)
{
page_table[i].no=i;
page_table[i].state=0;
page_table[i].block_no=-1;
}
int a[2];
for( i=0;i<10;i++)
{
a[0]=loc[i]/1024; //计算出的页号
a[1]=loc[i]%1024; //计算出的页内偏移量
//找到页表中的该页
for( j=0;j<64;j++)
{
if(page_table[j].no==a[0]) break;
}
//该页在内存
if(page_table[j].state==1)
{
bno.Traverse(Write); // 输出队列里的页面
cout<<endl;
cout<<page_table[j].no<<' '<<page_table[j].state<<' '<<page_table[j].block_no<<endl<<endl; // 输出页表信息
}
//该页不在内存，FIFO算法
if(page_table[j].state==0)
{
//内存有空闲
if(bno.Length()<5)
{
page_table[j].state=1;
page_table[j].block_no=i+10;
bno.InQueue(page_table[j].no);
bno.Traverse(Write);
cout<<endl;
cout<<page_table[j].no<<' '<<page_table[j].state<<' '<<page_table[j].block_no<<endl<<endl;
}
//内存没有空闲
else if(bno.Length()==5)
{
bno.OutQueue(e);
page_table[e].state=0;
page_table[j].state=1;
page_table[j].block_no=page_table[e].block_no;
bno.InQueue(page_table[j].no);
bno.Traverse(Write);
cout<<endl;
cout<<page_table[j].no<<’'<<page_table[j].state<<' '<<page_table[j].block_no<<endl<<endl;
}
}
}
}