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