模拟操作系统的请求分页存储管理java代码
请求分页管理源程序
#include<iostream>#include<time.h>using namespace std;const int MaxNum=320;//指令数const int M=5;//内存容量int PageOrder[MaxNum];//页面请求int Simulate[MaxNum][M];//页面访问过程int PageCount[M],LackNum;//PageCount用来记录LRU算法中最久未使用时间,LackNum记录缺页数float PageRate;//命中率int PageCount1[32];bool IsExit(int i)//FIFO算法中判断新的页面请求是否在内存中{bool f=false;for(int j=0;j<M;j++){if(Simulate[i-1][j]==PageOrder[i])//在前一次页面请求过程中寻找是否存在新的页面请求{f=true;}}return f;}int IsExitLRU(int i)//LRU算法中判断新的页面请求是否在内存中{int f=-1;for(int j=0;j<M;j++){if(Simulate[i-1][j]==PageOrder[i]){f=j;}}return f;}int Compare()//LRU算法找出内存中需要置换出来的页面{int p,q;p=PageCount[0];q=0;for(int i=1;i<M;i++){if(p<PageCount[i]){p=PageCount[i];q=i;}}return q;}void Init() //初始化页框{for(int k=0;k<MaxNum;k++){int n=rand()%320;//随机数产生320次指令PageOrder[k]=n/10;//根据指令产生320次页面请求}for(int i=0;i<MaxNum;i++)//初始化页面访问过程{for(int j=0;j<M;j++){Simulate[i][j]=-1;}}for(int q=0;q<M;q++)//初始化最久未使用数组{PageCount[q]=0;}}void OutPut()//输出{int i,j;cout<<"页面访问序列:"<<endl;for(j=0;j<MaxNum;j++){cout<<PageOrder[j]<<" ";}cout<<endl;cout<<"页面访问过程(只显示前10个):"<<endl;for(i=0;i<10;i++){for(j=0;j<M;j++){if(Simulate[i][j]==-1)cout<<" ";elsecout<<Simulate[i][j]<<" ";}cout<<endl;}cout<<"缺页数= "<<LackNum<<endl;cout<<"命中率= "<<PageRate<<endl;cout<<"--------------------------------------------------------------"<<endl;}void FIFO()//FIFO算法{int j,x=0,y=0;LackNum=0,Init();for(j=0;j<M;j++)//将前五个页面请求直接放入内存中{for(int k=0;k<=j;k++){if(j==k)Simulate[j][k]=PageOrder[j];elseSimulate[j][k]=Simulate[j-1][k];}//LackNum++;}for(x=M;x<MaxNum;x++){for(int t=0;t<M;t++)//先将前一次页面访问过程赋值给新的页面访问过程{Simulate[x][t]=Simulate[x-1][t];}if(!IsExit(x))//根据新访问页面是否存在内存中来更新页面访问过程{LackNum++;Simulate[x][y%M]=PageOrder[x];y++;}}PageRate=1-((float)LackNum/(float)MaxNum);//算出命中率OutPut();}void LRU()//LRU算法{int j,x=0,y=0;LackNum=0,Init();for(j=0;j<M;j++)//将前五个页面请求直接放入内存中{for(int k=0;k<=j;k++){PageCount[k]++;if(j==k)Simulate[j][k]=PageOrder[j];elseSimulate[j][k]=Simulate[j-1][k];}LackNum++;}for(x=M;x<MaxNum;x++){for(int t=0;t<M;t++)//先将前一次页面访问过程赋值给新的页面访问过程{Simulate[x][t]=Simulate[x-1][t];}int p=IsExitLRU(x);if(p==-1)//根据反回的p值来更新页面访问过程{int k;k=Compare();for(int w=0;w<M;w++){if(w!=k)PageCount[w]++;elsePageCount[k]=1;}Simulate[x][k]=PageOrder[x];LackNum++;}else{for(int w=0;w<M;w++){if(w!=p)PageCount[w]++;elsePageCount[p]=1;}}}PageRate=1-((float)LackNum/(float)MaxNum);//算出命中率OutPut();}//最近最不常用调度算法(LFU)void LFU(){}void NUR(){}void YourChoice(int choice){switch(choice){case 1:cout<<"----------------------------------------------------------"<<endl;cout<<"FIFO算法结果如下:"<<endl;FIFO();break;case 2:cout<<"----------------------------------------------------------"<<endl;cout<<"LRU算法结果如下:"<<endl;LRU();break;case 3:cout<<"----------------------------------------------------------"<<endl;cout<<"LFU算法结果如下:"<<endl;//LFU();break;case 4:cout<<"----------------------------------------------------------"<<endl;cout<<"NUR算法结果如下:"<<endl;//NUR();break;case 5:break;default:cout<<"重新选择算法:1--FIFO 2--LRU 3--LFU 4--NUR 5--退出 "<<endl;cin>>choice;YourChoice(choice);}}void main(){int choice,i=1;while(i){cout<<"请选择算法:1--FIFO 2--LRU 3--LFU 4--NUR 5--退出 "<<endl;cin>>choice;if(choice==5){i=0;}else{YourChoice(choice);}}}9. 实验体会通过上面的截图可以发现,实验中指令是由随机函数产生的,然后根据产生的指令算出需要访问的页面.在本次实验中我写了四个页面置换算法—(先进先出)FIFO算法和(最久未使用)LRU算法, 最少访问页面算法 (LFR);最近最不经常使用算法 (NUR)。
Java逻辑分页代码
Java逻辑分页代码前台jsp代码如下:<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" %><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/><title>office模版管理</title><%@include file="/commons/include/manageCommon.jsp"%><link rel="stylesheet" href="${ctx}/assets/stylesheets/thestyle.css"/><script type="text/javascript">function showOffice(officeName,officeExt,hideOfficePath){window.location.href="${ctx}/platform/system/sysOffice/download.ht?officeName="+officeName+"&officeExt="+officeExt+"&hideOfficePath="+hideOfficePath;}function editOffice(officePath,officeExt){if(officeExt != "doc" && officeExt != "DOC" && officeExt != "docx" && officeExt != "DOCX"){layer.msg("请选择doc或docx格式的⽂书进⾏编辑!", {time: 2000,type: 1,skin: "layer-tips-box",anim: 1,offset: "30%",content: content1.replace("#tips#", "请选择doc或docx格式的⽂书进⾏编辑!")});return false;}window.location.href = "edit.ht?officePath="+officePath;}function changePageSize(){var pageSize = $("#pageSizeSelect option:selected").val();$("#pageSizeSpan").html(pageSize);$("#pageSize").val(pageSize);var currentPage = $("#currentPageInput").val();$("#currentPage").val(currentPage);$("#searchForm").submit();}function first(){$("#currentPage").val(parseInt(1));$("#currentPageInput").val(parseInt(1));$("#searchForm").submit();}function previous(){var currentPage = $("#currentPageInput").val();if(parseInt(currentPage)-1 >= parseInt(1)){$("#currentPage").val(parseInt(currentPage)-1);$("#currentPageInput").val(parseInt(currentPage)-1);}$("#searchForm").submit();}function next(){var currentPage = $("#currentPageInput").val();if(parseInt(currentPage)+1 <= parseInt("${totalPage}")){$("#currentPage").val(parseInt(currentPage)+1);$("#currentPageInput").val(parseInt(currentPage)+1);}$("#searchForm").submit();}function last(){$("#currentPage").val(parseInt("${totalPage}"));$("#currentPageInput").val(parseInt("${totalPage}"));$("#searchForm").submit();}function jumpTo(){var currentPage = $("#currentPageInput").val();$("#currentPage").val(parseInt(currentPage));$("#searchForm").submit();}</script></head><body><div class="panel"><div class="panel-heading"><form id="searchForm" method="post" action="list.ht" class="form-inline inputFrom"><div class="form-group"><span>⽂书名称:</span><input type="text" name="officeName"class="form-control input-sm" value="${officeName}"/></div><input id="pageSize" name="pageSize" value="${pageSize }" style="display:none"/><input id="currentPage" name="currentPage" value="${currentPage }" style="display:none"/></form></div><div class="panel-body"><c:set var="checkAll"><input type="checkbox" id="chkall"/></c:set><display:table name="sysOfficeList" id="sysOfficeItem" requestURI="list.ht" sort="external" cellpadding="1" cellspacing="1"class="table-grid table table-bordered table-striped table-hover text-center"><display:caption><div class="btn-group-p"><a class="btn btn-primary link search" id="btnSearch"><span class="fa fa-search">查询</span></a><a class="btn btn-primary" href="add.ht"><span class="fa fa-plus">添加</span></a><a class="btn btn-primary link del" action="del.ht"><span class="fa fa-times">批量删除</span></a></div></display:caption><display:column title="${checkAll}" media="html" style="width:30px;"><input type="checkbox" class="pk" name="officePath" value="${sysOfficeItem.officePath}"></display:column><display:column title="⽂书名称" class="text-left"><%-- <a class="titleTip" title="${sysOfficeItem.officeName}" href="javascript:void(0)" onclick="showOffice('${sysOfficeItem.officeName}','${sysOfficeItem.officeExt}','${sysOfficeItem.hideOfficePath}')"> --%><a class="titleTip" title="${sysOfficeItem.officeName}" href="get.ht?officePath=${sysOfficeItem.officePath}">${fn:substring(sysOfficeItem.officeName,0,10)}${fn:length(sysOfficeItem.officeName)>10?'...':''}</a></display:column><display:column title="⽂书后缀">${sysOfficeItem.officeExt}</display:column><display:column title="⽂书路径"><span class="titleTip" title="${sysOfficeItem.officePath}">${fn:substring(sysOfficeItem.officePath,0,80)}${fn:length(sysOfficeItem.officePath)>80?'...':''}</span></display:column><display:column title="管理" media="html" class="row-nowrap text-center"><a href="get.ht?officePath=${sysOfficeItem.officePath}" class="link detail gray leave-blank">明细</a><a onclick="editOffice('${sysOfficeItem.officePath}','${sysOfficeItem.officeExt}')" href="javascript:void(0)" class="link edit gray leave-blank">编辑</a><a href="del.ht?officePath=${sysOfficeItem.officePath}" class="link del gray leave-blank">删除</a></display:column></display:table><div class="btn-group" style="background-color: white;width: 100%"><div style="float: left;"><span>每页记录</span><select id="pageSizeSelect" name="pageSizeSelect" onchange="changePageSize()" class="input-sm" style="margin: 0 5px;"><option value="5" <c:out value="${pageSize eq '5'? 'selected' : '' }"/>>5</option><option value="10" <c:out value="${pageSize eq '10'? 'selected' : '' }"/>>10</option><option value="15" <c:out value="${pageSize eq '15'? 'selected' : '' }"/>>15</option><option value="20" <c:out value="${pageSize eq '20'? 'selected' : '' }"/>>20</option><option value="50" <c:out value="${pageSize eq '50'? 'selected' : '' }"/>>50</option><option value="100" <c:out value="${pageSize eq '100'? 'selected' : '' }"/>>100</option></select><a href="javascript:window.location.reload()"><span class="fa fa-refresh" style="display: inline-block;margin:0 5px;"></span></a><span style="display: inline-block;margin:0 5px;">显⽰记录从1到<span id="pageSizeSpan" name="pageSizeSpan">10</span>,总数 ${totalNum }条</span><a href="javascript:;" onclick="first()" title="⾸页"><span class="fa fa-step-backward" style="display: inline-block;margin:0 5px;"></span></a><a href="javascript:;" onclick="previous();" title="上⼀页"><span class="fa fa-chevron-left"></span></a><span style="display: inline-block;margin:0 5px;"><input class="pageInputText" size="4" value="${currentPage}" maxlength="4" type="text" id="currentPageInput" name="currentPageInput" style="width: 35px;border: 1px solid #ddd;height: 24px;line-height: 24px;">/ </span><a href="javascript:;" onclick="next()" title="下⼀页"><span class="fa fa-chevron-right" style="display: inline-block;margin:0 5px;"></span></a><a href="javascript:;" onclick="last()" title="尾页"><span class="fa fa-step-forward" style="display: inline-block;margin:0 5px;"></span></a><input type="button" id="btnGo" value="GO" onclick="jumpTo();" class="btn btn-primary"><div class="l-clear"></div></div></div></div><!-- end of panel-body --><!-- end of panel --></body><!-- 提⽰ --><link rel="stylesheet" type="text/css" href="${ctx}/js/poshytip-1.2/tip-yellowsimple/tip-yellowsimple.css"/><script type="text/javascript" src="${ctx}/js/poshytip-1.2/jquery.poshytip.js"></script><script type="text/javascript" src="${ctx}/js/util/toolTipCommon.js"></script></html>后台Java代码如下:package com.ksource.platform.controller.system;import java.io.BufferedInputStream;import java.io.BufferedOutputStream;import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import java.io.PrintWriter;import .HttpURLConnection;import .URL;import .URLEncoder;import java.util.ArrayList;import java.util.HashMap;import java.util.Iterator;import java.util.List;import java.util.Map;import javax.annotation.Resource;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import com.ksource.platform.model.system.SysAuditModelType;import com.ksource.platform.model.system.SysFile;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.ResponseBody;import org.springframework.web.multipart.MultipartFile;import org.springframework.web.multipart.MultipartHttpServletRequest;import org.springframework.web.servlet.ModelAndView;import com.ksource.core.annotion.Action;import com.ksource.core.annotion.ActionExecOrder;import com.ksource.core.util.AppConfigUtil;import com.ksource.core.util.FileUtil;import com.ksource.core.web.ResultMessage;import com.ksource.core.web.controller.BaseController;import com.ksource.core.web.query.QueryFilter;import com.ksource.core.web.util.RequestUtil;import com.ksource.platform.service.system.SysFileService;import com.ksource.pwlp.controller.system.SysOffice;@Controller@RequestMapping({ "/platform/system/sysOffice/" })@Action(ownermodel = SysAuditModelType.BASICDATA_MANAGEMENT)public class SysOfficeController extends BaseController {@Resourceprivate SysFileService sysFileService;/*** 查看系统⽂书模版分页列表* @param request* @return* @throws Exception*/@RequestMapping({ "list" })@Action(description = "查看系统⽂书模版分页列表", detail = "查看系统⽂书模版分页列表")public ModelAndView list(HttpServletRequest request) throws Exception {QueryFilter filter = new QueryFilter(request, "sysOfficeItem");String officePath = request.getSession().getServletContext().getRealPath("/")+"WEB-INF/fileTemplate/office";List<SysOffice> sysOfficeList = new ArrayList<SysOffice>();findFileList(new File(officePath),sysOfficeList,filter);//pageSize 每页展⽰个数int pageSize = RequestUtil.getInt(request, "pageSize",10);//currentPage 当前页int currentPage = RequestUtil.getInt(request, "currentPage",1);//totalNum 总数int totalNum = sysOfficeList.size();//totalPage 总页数int totalPage = 0;if(sysOfficeList.size() % pageSize==0){//说明整除,正好每页显⽰pageSize条数据,没有多余⼀页要显⽰少于pageSize条数据的totalPage = sysOfficeList.size() / pageSize;}else{//不整除,就要在加⼀页,来显⽰多余的数据。
请求分页存储管理(虚拟存储)
任务四、请求分页存储管理(虚拟存储)一、实验目的通过请求分页存储管理的设计,让学生了解虚拟存储器的概念和实现方法。
进行运行时不需要将所有的页面都调入内存,只需将部分调入内存,即可运行,在运行的过程中若要访问的页面不在内存时,则需求有请求调入的功能将其调入。
假如此时若内存没有空白物理块,则通过页面置换的功能将一个老的不用的页面淘汰出来,其中淘汰的算法有多种。
二、实验内容模拟仿真请求分页调度算法,其中淘汰的算法可选下列其一1、先进先出算法2、最近最久算法3、CLOCK算法三、实验代码#include<iostream>#include<vector>using namespace std;int n;typedef struct Queue{int time;int data;struct Queue *next;}Queue,*QueuePtr;typedef struct {QueuePtr front;QueuePtr rear;}LinkQueue;//fifo=======================================void InitQueue(LinkQueue &Q);void FiFoEnQueueRear(LinkQueue &Q,int e,vector<int> &v);void FiFoDeQueueFront(LinkQueue &Q);inline void PrintQueue(LinkQueue &Q);void FiFoFiFoDoQueueEarly(LinkQueue &Q,int a,vector<int> &v);void FiFoDoQueue(LinkQueue &Q,int a,vector<int> &v);inline int PanDuan(LinkQueue &Q,int a);inline int YeMianCount(LinkQueue &Q);void fifo();//lru=============================================void InitQueue(LinkQueue &Q);void EnQueueMid(LinkQueue &Q,int e,QueuePtr p,vector<int> &v);void EnQueueTheFist(LinkQueue &Q,int e);void PrintQueue(LinkQueue &Q);//void ZhiZhenInit(int n);void DoQueueEarly(LinkQueue &Q,int e,vector<int> &v);void EnQueueRear(LinkQueue &Q,int e,QueuePtr p,vector<int> &v);//void DeQueueFront(LinkQueue &Q);QueuePtr ZhiZhen(LinkQueue &Q,int e);void EnQueue(LinkQueue &Q,int e,vector<int> &v);//void DeQueue(LinkQueue &Q,QueuePtr p);int PanDuan(LinkQueue &Q,int a);int YeMianCount(LinkQueue &Q);void lru();QueuePtr OptimalZhiZhen(LinkQueue &Q,int e);//求出需要置换的页面的上一个页面的位置void EnQueue(LinkQueue &Q,int e,vector<int> &v,int i,vector<int> &vc);inline int YeMianCount(LinkQueue &Q);//使用内敛函数,提高性能inline int Destance(vector<int> &v,int i);inline void SubbDestance(LinkQueue &Q);//=================================================int main(){int k;for(;;){cout<<"请选择!"<<endl;cout<<"1——FiFo算法"<<endl;cout<<"2——LRU算法"<<endl;cout<<"0——退出"<<endl;cin>>k;if(k==0)break;else{switch(k){case 1:fifo();break;case 2:lru();break;default:cout<<" 请从以上的选择中选择一个选项!!"<<endl;}}}}//fifo========================================void InitQueue(LinkQueue &Q){Q.front=Q.rear=(QueuePtr)malloc(sizeof(Queue));if(!Q.front)cout<<"initqueue worng!"<<endl;Q.front->next=NULL;//return OK;}void FiFoEnQueueRear(LinkQueue &Q,int e,vector<int> &v){ QueuePtr p;p=(QueuePtr)malloc(sizeof(Queue));if(!p)cout<<"cannot malloc EnQueue of the p"<<endl;p->data=e;p->next=NULL;Q.rear->next=p;Q.rear=p;v.push_back(e);//cout<<p->data;//return OK;}void FiFoDeQueueFront(LinkQueue &Q){QueuePtr p;if(Q.front==Q.rear)cout<<"the Queue is empty,cannot delete !!"<<endl;p=Q.front->next;Q.front->next=p->next;free(p);if(Q.rear==p)Q.rear=Q.front;//return OK}void PrintQueue(LinkQueue &Q){QueuePtr p;if(Q.front==Q.rear)cout<<"the Queue is empty,cannot print!"<<endl;p=Q.front;for(p=Q.front;p->next!=NULL;p=p->next){cout<<p->next->data<<" ";}cout<<endl;//retrun OK;}void FiFoFiFoDoQueueEarly(LinkQueue &Q,int a,vector<int> &v){ QueuePtr p;int count=0;//设置标志位,记录重复的个数。
实验二--请求分页存储管理模拟实验
实验二请求分页存储管理模拟实验一、实验目的:通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解。
熟悉虚存管理的各种页面淘汰算法。
通过编写和调试地址转换过程的模拟程序以加强对地址转换过程的了解。
二、实验要求:设计一个请求页式存储管理方案。
并编写模拟程序实现。
(1)产生一个需要访问的指令地址流。
它是一系列需要访问的指令的地址。
为不失一般性,你可以适当地(用人工指定地方法或用随机数产生器)生成这个序列。
(2)简单起见,页面淘汰算法采用LRU页面淘汰算法,并且在淘汰一页时,只将该页在页表中抹去。
而不再判断它是否被改写过,也不将它写回到辅存。
#include<iostream>#include<stdio.h>#include<stdlib.h>#include<string.h>using namespace std;struct pagetable{int pagenumber;//页号int phnumber;//物理块号int state;//状态位int visit;//访问字段int modify;//修改位int address;//外存地址};struct logicA{int pagenumber;int pagedaddress;};pagetable p[10];int ph[4]={1,2,3,4};//4个物理块int j=0;bool boolph[4]={true,true,false,true};void show(){for(int i=0;i<5;i++){cout<<"页号\t"<<"物理块号\t"<<"状态位\t"<<"访问字段"<<endl;cout<<p[i].pagenumber<<"\t"<<p[i].phnumber<<"\t\t"<<p[i].state<<"\t"<<p[i].visit<<endl;}}int phaddress;void disp(int i,logicA log[]){int page;page=log[i].pagenumber;if(page>5)cout<<"越界"<<endl;else{if(p[page].state==1){p[page].visit++;phaddress=log[i].pagedaddress+4096*p[page].phnumber;cout<<"在内存中---------------------------------"<<endl;show();cout<<"物理地址为:"<<phaddress<<endl;}else{int sum=0;for(int i=0;i<5;i++)sum+=p[i].state;if(sum==4)//内存满{int temp=1000,j,x;for( j=0;j<5;j++){if(p[j].state==1&&p[j].visit<temp){temp=p[j].visit;x=j;}}p[page].phnumber=p[x].phnumber;p[page].state=1;p[x].state=0;p[x].phnumber=0;cout<<"内存已经满,替换第"<<x+1<<"块"<<endl;show();}else //内存未满{cout<<"内存未满,调入页面进内存----------------------"<<endl;if(p[page].modify==0){for(int j=0;j<4;j++){if(!boolph[j]){p[page].phnumber=ph[j];boolph[j]=true;}}p[page].state=1;show();}else{cout<<"先写回外存"<<endl;cout<<"外存换回内存"<<endl;for(int j=0;j<4;j++){if(!boolph[j]){p[page].phnumber=ph[j];boolph[j]=true;}}p[page].state=1;show();}}}}}void init(){p[0].pagenumber=0;p[0].phnumber=1;p[0].state=0;p[0].visit=1;p[0].modify=0;//1 p[1].pagenumber=1;p[1].phnumber=0;p[1].state=0;p[1].visit=0;p[1].modify=0;//2 p[2].pagenumber=2;p[2].phnumber=2;p[2].state=0;p[2].visit=2;p[2].modify=1;//3 p[3].pagenumber=3;p[3].phnumber=0;p[3].state=0;p[3].visit=0;p[3].modify=0;//4 p[4].pagenumber=4;p[4].phnumber=4;p[4].state=0;p[4].visit=1;p[4].modify=0;//5 }void logic(){int logicAddress;//31——12 为页号(0-4),11-0为页内地址(5-7)212=4KB int sum;init();while(1){printf("输入逻辑地址快数:");scanf("%d",&sum);logicA log[sum];for(int i=0;i<sum;i++){printf("输入第%d个逻辑地址:",i+1);scanf("%d",&logicAddress);//show();log[i].pagenumber=logicAddress/4096; //4kBlog[i].pagedaddress=logicAddress%4096;disp(i,log);}}}int main(){logic();//show();return 0;}。
请求分页式存储管理课程设计java
请求分页式存储管理课程设计java在Java中实现分页式存储管理,可以设计一个简单的模拟系统,如下面的概念框架。
假设我们有一组固定大小的页和一组固定大小的内存帧。
分页算法的任务是当请求来时,找到一个空闲的内存帧并分配给请求的页。
下面是一个简单的课程设计方案:定义页面和帧的概念:使用类来表示页和帧。
class Page {// ...}class Frame {// ...}创建页表和帧池:使用集合来表示页表和帧池Map<Page, Frame> pageTable = new HashMap<>();List<Frame> framePool = new ArrayList<>();实现分页算法:当请求到来时,找到一个空闲的帧并分配给请求的页。
如果没有空闲的帧,那么就需要使用某种页面替换算法(如最少使用算法或最近最久未使用算法)来选择一个帧进行替换。
public Frame allocateFrame(Page page) {// ...}处理页错误:如果请求的页不在内存中,那么就会产生页错误。
在这种情况下,需要将页面从磁盘加载到内存中。
public void handlePageFault(Page page) {// ...}这只是一个非常基础的框架,你可能需要添加更多的功能,比如模拟从磁盘读取页面的延迟,或者记录并显示内存的使用情况等。
记住,这个项目是一个模拟的分页存储管理系统,所以实际的实现细节可能会有所不同。
在实际的操作系统中,分页存储管理涉及到很多复杂的问题,比如虚拟内存管理、页面替换算法、页表管理等。
操作系统-基本分页存储管理(内有代码)
基本分页存储管理实验目的连续内存分配方式会形成许多“碎片”,虽然可以通过“紧凑”方法将许多碎片拼接成可用的大块空间,但须为之付出很大开销。
如果允许将一个进程直接分散地装入到许多不相邻接的分区中,则无需再进行“紧凑”。
基于这一思想而产生了离散分配方式。
如果离散分配的基本单位是页,则称为分页存储管理方式;如果离散分配的基本单位是段,则称为分段存储管理方式。
在分页存储管理方式中,如果不具备页面兑换功能,则称为基本的分页存储管理方式,或称为纯分页存储管理方式,它不具备支持虚拟存储器的功能,它要求把每个作业全部装入内存后方能运行。
本实验通过程序模拟操作系统的基本分页存储管理方式,进一步理解这一内存分配方式的原理和特点,加深对理论知识的掌握。
实验要求1、用C语言或Java语言编写程序模拟操作系统对内存的基本分页存储管理方式2、程序要能正确对“内存”进行“分配”和“回收”,能接受用户的输入,显示内存的分配情况,并有一定的容错能力。
3、每个人独立按时完成实验内容。
实验内容本实验假定内存空间已经按块划分,目标程序无需关心内存块大小等底层细节,只需按算法对内存块进行分配即可。
程序应该实现以下功能:1、内存初始化。
假定内存块共有N个,初始化后的内存空间应该有一部分已经被使用,这可以用随机数或程序内部的其他算法完成。
2、程序应该能接受用户输入的进程信息,并为之分配内存,返回分配结果(成功或失败),注意,此处应该考虑到不合法的输入并进行相应处理。
3、程序能回收用户指定的进程所占用的内存空间,因此,程序可能需要为每个进程分配一个唯一的进程号并给出详细的提示信息。
4、能直观合理地显示内存分配情况。
5、程序界面友好,便于操作和查看运行结果。
#include <stdio.h>#include <windows.h>#define N 100 // 共有100个内存块int process[N][N+1]; // 存放每个进程的页表int block[N]; // 内存块状态标志数组,0:空闲,1:使用int blockCount; // 记录当前内存剩余空间int processCount; // 记录当前进程数bool flag = true;void init();void output();bool createProcess();bool endProcess();void init(){int i, j;// 初始化内存状态标志数组for (i=0; i<N; i++)block[i] = 0;for (i=0; i<20; i++)block[rand()%(N-1)] = 1;blockCount = 0;for (i=0; i<N; i++)if (block[i] == 0)blockCount++;// 初始化存放进程的数组for (i=0; i<N; i++){process[i][0] = 0;for (j=1; j<N; j++)process[i][j] = -1;}processCount = 0;printf("初始化结果如下:");output();flag = false;}void output(){printf("\n内存总量:%d 块, 已用空间:%d 块, 剩余空间:%d 块, 进程总数:%d 个\n", N, N-blockCount, blockCount, processCount);if (flag && blockCount < N){printf("已使用的内存块(%d):\n", N-blockCount);for (int k=0,count=0; k<N; k++){if (block[k] == 1)printf("%2d ", k, ++count);if (count == 15){putchar('\n');count = 0;}}putchar('\n');}// 输出各进程占用内存详细情况if (processCount > 0){printf("内存详细使用情况如下:\n");for (int i=0; i<N; i++){if (process[i][0] > 0){printf("进程号:%d \n占用内存块(%2d):", i, process[i][0]);for (int j=1,count=0; j<=process[i][0]; j++){printf("%2d ", process[i][j], count++);if (count == 15){putchar('\n');printf(" ");count = 0;}}putchar('\n');}}}elseprintf("当前内存无进程!\n");/*// 输出空闲内存块if (blockCount > 0){printf("空闲内存块(%d):\n", blockCount);for (int k=0,count=0; k<N; k++){if (block[k] == 0)printf("%2d ", k, ++count);if (count == 15){putchar('\n');count = 0;}}putchar('\n');}*/putchar('\n');}bool createProcess(){int pid, pages, k = 0;loop:printf("请输入进程号(小于%d)和所需页面数:", N);scanf("%d%d", &pid, &pages);if (pid > 99){printf("错误!进程号过大!\n");goto loop;}if (pages > blockCount)return false;blockCount -= pages;process[pid][0] = pages;for (int i=1; i<=pages; i++){while (block[k]==1 && k<100)k++;process[pid][i] = k;block[k] = 1;k++;}processCount++;return true;}bool endProcess(){int pid, pages;if (processCount < 1){printf("当前内存没有进程!\n\n");return false;}printf("当前内存中的进程有%d 个,进程号为:", processCount);for (int i=0; i<N; i++)if (process[i][0] > 0)printf("%2d ", i);putchar('\n');printf("请输入您要结束的进程号(小于%d):", N);scanf("%d", &pid);pages = process[pid][0];if (pages == 0){printf("对不起!该进程不存在!\n");return false;}for (int j=1; j<pages; j++){block[process[pid][j]] = 0;process[pid][j] = -1;}process[pid][0] = 0;processCount--;blockCount += pages;return true;}void menu(){int choice;while (true){printf("操作菜单:\n");printf(" 1 --> 创建进程\n 2 --> 结束进程\n 3 --> 查看内存\n 0 --> 退出程序\n");printf("请输入您要进行的操作:");scanf("%d", &choice);switch (choice){case 1:if (createProcess())printf("创建新进程成功!\n\n");elseprintf("抱歉!内存空间不足,创建新进程失败!\n\n");break;case 2:if (endProcess())printf("进程已结束!\n\n");elseprintf("进程结束失败!\n\n");break;case 3:output();break;case 0:return ;default:printf("对不起!您的选择有误!请重新选择!\n\n");}}}void main(){init();menu();}实验总结基本分页的思想是比较简单的,而且实验前老师已经给出了一种可行的数据结构来存储程序中需要用到的数据,因此这个实验在构思上是没有多少难度的。
Java模拟操作系统实现存储管理
存储器管理1.实验内容:模拟请求页式存储管理中硬件的地址转换和缺页中断,并用先进先出调度算法(FIFO)处理缺页中断;2.要求:①指令序列的设定可以执行拟定,格式如表3;②在完成了FIFO换页策略后,可以选做LRU的换页策略,并进行比较;③作业允许的页架数m在不同情况下的缺页中断率;④程序运行时显示地址转变和页面调入调出过程。
3.实验控制流图:4.数据结构核心代码:package xiao.zhang.bean;public class Instruction {/*** 指令操作符号*/private String op;/*** 页号*/private int pageId;/*** 页内地址*/private int pageInAddress;public Instruction() {}public Instruction(String op, int pageId, int pageInAddress) { this.op = op;this.pageId = pageId;this.pageInAddress = pageInAddress;}public String getOp() {return op;}public void setOp(String op) {this.op = op;}public int getPageId() {return pageId;}public void setPageId(int pageId) {this.pageId = pageId;}public int getPageInAddress() {return pageInAddress;}public void setPageInAddress(int pageInAddress) { this.pageInAddress = pageInAddress;}/** (non-Javadoc)** @see ng.Object#toString()*/@Overridepublic String toString() {return"Instruction [op=" + this.op + ", pageId=" + this.pageId+ ", pageInAddress=" + this.pageInAddress + ", getOp()="+ this.getOp() + ", getPageId()=" + this.getPageId()+ ", getPageInAddress()=" + this.getPageInAddress()+ ", getClass()=" + this.getClass() + ", hashCode()="+ this.hashCode() + ", toString()=" + super.toString() + "]";}}package xiao.zhang.bean;import java.util.LinkedList;public class ExecuteFiFo {/*** 指令队列*/public LinkedList<Instruction> is;/*** 页面存储*/public LinkedList<Page> pages;/*** 是否还有存储页架*/private final int isUseablePageFrame;public static int point = 0;/*** 默认设置页架为4个*/public ExecuteFiFo() {this.isUseablePageFrame = 4;}public ExecuteFiFo(int isUseablePageFrame) {is = new LinkedList<Instruction>();pages = new LinkedList<Page>();this.isUseablePageFrame = isUseablePageFrame;}public ExecuteFiFo(LinkedList<Instruction> is, LinkedList<Page> pages,int isUseablePageFrame) {this.is = is;this.pages = pages;this.isUseablePageFrame = isUseablePageFrame;}/*** 一次性调度完成,装载所有的可用的页*/public void initalExecute() {for (int i = 0; i < isUseablePageFrame; i++) {/*** 从指令队列出一条指令*/Instruction ins = is.poll();/*** 访问指定页号的主存*/Page p = pages.get(i);p.setPageId(ins.getPageId());p.setInMen(true);p.setModifyFlag(isModify(ins.getOp()));printINInformation(ins);}}/*** 执行指令*/public void executeInstruction() {/*** 先判断执行的页是否住存指令序列中将其删除*/while (!is.isEmpty()) {Instruction ins = is.poll();if (isExistMemeroy(ins)) {System.out.println("[页号为:\t" + ins.getPageId() + "\t存在]");Page p = pages.get(ins.getPageId());printOUTInformation(p);printINInformation(ins);} else {System.out.println("[页号为:\t" + ins.getPageId() + "\t不存在]");Page p = pages.get(ins.getPageId());p.setInMen(true);Page outP = pages.get(point % isUseablePageFrame);p.setPageFrameId(outP.getPageFrameId());p.setModifyFlag(isModify(ins.getOp()));printOUTInformation(outP);printINInformation(ins);}point++;}}/*** 判断指定序列是否住存** @return*/public boolean isExistMemeroy(Instruction ins) {for (int i = 0; i < this.pages.size(); i++) {if (this.pages.get(i).getPageId() == ins.getPageId()&& this.pages.get(i).isInMen()) {return true;}}return false;}/*** 打印装载信息** @param ins*/public void printINInformation(Instruction ins) {System.out.println("[页号:" + ins.getPageId() + "\tIN\t" + "执行:"+ ins.getOp() + "操作\t" + "物理地址:"+ (1024 * ins.getPageId() + ins.getPageInAddress()) + "]");}/*** 打印调出信息** @param p*/public void printOUTInformation(Page p) {if (p.isModifyFlag()) {System.out.println("[页号:" + p.getPageId() + "\tOUT\t" + "页架号:"+ p.getPageFrameId() + "\t修改\t" + "写回磁盘:"+ p.getLocationInDisk() + "]");} else {System.out.println("[页号:" + p.getPageId() + "\tOUT\t" + "页架号:"+ p.getPageFrameId() + "\t未修改\t" + "不用写回磁盘]");}}* 判断指令是否修改主存内容** @param op* @return*/public boolean isModify(String op) { if (op.equals("R") || op.equals("W")) { return true;}return false;}/*** @return the isUseablePageFrame*/public int getIsUseablePageFrame() { return isUseablePageFrame;}/*** @return the ispublic LinkedList<Instruction> getIs() { return this.is;}/*** @return the pages*/public LinkedList<Page> getPages() {return this.pages;}/*** @param is* the is to set*/public void setIs(LinkedList<Instruction> is) { this.is = is;}/*** @param pages* the pages to set*/public void setPages(LinkedList<Page> pages) { this.pages = pages;}}package xiao.zhang;import xiao.zhang.bean.ExecuteFiFo;import xiao.zhang.bean.Instruction;import xiao.zhang.bean.Page;public class MainExecute {public static void main(String[] args) {Instruction[] i = new Instruction[12];i[0] = new Instruction("+", 0, 70);i[1] = new Instruction("-", 1, 50);i[2] = new Instruction("*", 2, 15);i[3] = new Instruction("R", 3, 21);i[4] = new Instruction("W", 0, 56);i[5] = new Instruction("-", 6, 40);i[6] = new Instruction("RM", 4, 53);i[7] = new Instruction("+", 5, 23);i[8] = new Instruction("W", 1, 37);i[9] = new Instruction("R", 2, 78);i[10] = new Instruction("+", 4, 1);i[11] = new Instruction("W", 6, 84);Page[] p = new Page[7];p[0] = new Page(0, true, 5, false, 11); p[1] = new Page(2, true, 8, false, 12); p[2] = new Page(3, true, 9, false, 13); p[3] = new Page(4, true, 1, false, 21); p[4] = new Page(5, false, 0, false, 22); p[5] = new Page(6, false, 0, false, 23); p[6] = new Page(7, false, 0, false, 121);ExecuteFiFo xf = new ExecuteFiFo(4); for (int j = 0; j < p.length; j++) {xf.getPages().add(p[j]);}for (int j = 0; j < i.length; j++) {xf.getIs().add(i[j]);}xf.initalExecute();xf.executeInstruction();}}精品6.程序运行结构截图:精品。
操作系统实验4-请求分页存储管理模拟实验
实验四请求分页存储管理模拟实验一:实验目得通过对页面、页表、地址转换与页面置换过程得模拟,加深对请求分页存储管理系统得原理与实现技术得理解.二:实验内容假设每个页面可以存放10条指令,分配给进程得存储块数为4。
用C语言或Pascal语言模拟一进程得执行过程。
设该进程共有320条指令,地址空间为32个页面,运行前所有页面均没有调入内存。
模拟运行时,如果所访问得指令已经在内存,则显示其物理地址,并转下一条指令;如果所访问得指令还未装入内存,则发生缺页,此时需要记录缺页产生次数,并将相应页面调入内存,如果4个内存块已满,则需要进行页面置换。
最后显示其物理地址,并转下一条指令。
在所有指令执行完毕后,显示进程运行过程中得缺页次数与缺页率.页面置换算法:分别采用OPT、FIFO、LRU三种算法。
进程中得指令访问次序按如下原则生成:50%得指令就是顺序执行得。
25%得指令就是均匀分布在低地址部分.25%得指令就是均匀分布在高地址部分.三:实验类别分页存储管理四:实验类型模拟实验五:主要仪器计算机六:结果OPT:LRU:FIFO:七:程序# i nclude 〈stdio 、h 〉# incl ude 〈stdlib 、h 〉# include 〈conio 、h># def ine blockn um 4//页面尺寸大小int m; //程序计数器,用来记录按次序执行得指令对应得页号s ta ti c in t num [320]; //用来存储320条指令typedef s truct BLOCK //声明一种新类型—-物理块类型{ﻩint pagenum; //页号ﻩint acces sed; //访问量,其值表示多久未被访问}BLOCK ;BLOCK bl ock [bl ocknum ]; //定义一大小为8得物理块数组void init () //程序初始化函数,对bl ock 初始化{for (int i=0;i <blo cknum;i++)block[i]、pagenum=—1;block[i]、accessed=0;ﻩm=0;}}int pageExist(int curpage)//查找物理块中页面就是否存在,寻找该页面curpage就是否在内存块block中,若在,返回块号{ﻩfor(int i=0;i<blocknum; i++)ﻩ{ﻩﻩif(block[i]、pagenum == curpage )ﻩﻩreturn i; //在内存块block中,返回块号ﻩ}return -1;}int findSpace()//查找就是否有空闲物理块,寻找空闲块block,返回其块号{for(int i=0;i<blocknum;i++)ﻩ{if(block[i]、pagenum==-1)ﻩreturn i;//找到了空闲得block,返回块号}ﻩreturn -1;}int findReplace()//查找应予置换得页面{ﻩint pos = 0;ﻩfor(int i=0;i〈blocknum;i++){if(block[i]、accessed 〉block[pos]、accessed)ﻩpos = i; //找到应该置换页面,返回BLOCK中位置ﻩ}return pos;}void display()//显示物理块中得页面号{ﻩﻩfor(int i=0; i〈blocknum; i++)ﻩ{ﻩif(block[i]、pagenum != -1)ﻩ{ﻩﻩprintf(” %02d ",block[i]、pagenum);ﻩﻩﻩprintf("%p |”,&block[i]、pagenum);ﻩﻩ}printf("\n");}void randam()//产生320条随机数,显示并存储到num[320]{int flag=0;printf(”请为一进程输入起始执行指令得序号(0~320):\n”);ﻩscanf("%d",&m);//用户决定得起始执行指令printf("******进程中指令访问次序如下:(由随机数产生)*******\n");for(int i=0;i〈320;i++){//进程中得320条指令访问次序得生成ﻩﻩnum[i]=m;//当前执行得指令数,ﻩﻩif(flag%2==0)ﻩm=++m%320;//顺序执行下一条指令ﻩﻩif(flag==1)ﻩﻩm=rand()%(m-1);//通过随机数,跳转到低地址部分[0,m—1]得一条指令处,设其序号为m1if(flag==3)ﻩﻩm=m+1+(rand()%(320-(m+1)));//通过随机数,跳转到高地址部分[m1+2,319]得一条指令处,设其序号为m2ﻩﻩflag=++flag%4;ﻩprintf(” %03d”,num[i]);//输出格式:3位数ﻩﻩif((i+1)%10==0)//控制换行,每个页面可以存放10条指令,共32个页面ﻩprintf(”\n”);}}void pagestring() //显示调用得页面序列,求出此进程按次序执行得各指令所在得页面号并显示输出{for(int i=0;i〈320;i++)ﻩ{printf(”%02d",num[i]/10);//输出格式:2位数if((i+1)%10==0)//控制换行,每个页面可以存放10条指令,共32个页面ﻩﻩprintf("\n”);}}void OPT() //最佳替换算法{ﻩint n=0;//记录缺页次数int exist,space,position;ﻩintcurpage;//当前指令得页面号ﻩfor(int i=0;i<320;i++)ﻩ{ﻩm=num[i];ﻩcurpage=m/10;ﻩﻩexist=pageExist(curpage);ﻩif(exist==-1)ﻩﻩ{ //当前指令得页面号不在物理块中space=findSpace();ﻩﻩif(space != -1)ﻩﻩ{//当前存在空闲得物理块ﻩﻩblock[space]、pagenum= curpage;//将此页面调入内存ﻩﻩﻩdisplay();//显示物理块中得页面号ﻩﻩn++;//缺页次数+1ﻩ}ﻩﻩelseﻩﻩ{ //当前不存在空闲得物理块,需要进行页面置换for(intk=0;k<blocknum;k++)ﻩﻩﻩﻩ{for(int j=i;j〈320;j++)ﻩ{//找到在最长(未来)时间内不再被访问得页面ﻩﻩﻩﻩif(block[k]、pagenum!= num[j]/10)ﻩﻩﻩ{ﻩﻩblock[k]、accessed = 1000;ﻩﻩﻩ} //将来不会被访问,设置为一个很大数ﻩﻩﻩelseﻩﻩﻩ{ //将来会被访问,访问量设为jﻩﻩﻩblock[k]、accessed = j;ﻩﻩﻩﻩﻩbreak;ﻩﻩﻩﻩ}ﻩﻩﻩ}ﻩ}ﻩposition = findReplace();//找到被置换得页面,淘汰ﻩblock[position]、pagenum = curpage;// 将新页面调入display();ﻩﻩn++; //缺页次数+1ﻩ}}ﻩ}ﻩprintf(”缺页次数:%d\n",n);printf("缺页率:%f%%\n",(n/320、0)*100);}void LRU() //最近最久未使用算法{int n=0;//记录缺页次数ﻩint exist,space,position ;ﻩint curpage;//当前指令得页面号ﻩfor(int i=0;i<320;i++)ﻩ{ﻩm=num[i];ﻩﻩcurpage=m/10;ﻩexist = pageExist(curpage);ﻩif(exist==-1)ﻩﻩ{ //当前指令得页面号不在物理块中space = findSpace();ﻩﻩif(space!= —1)ﻩ{ //当前存在空闲得物理块ﻩﻩblock[space]、pagenum = curpage;//将此页面调入内存ﻩﻩdisplay();//显示物理块中得页面号ﻩn++;//缺页次数+1ﻩﻩ}else{ //当前不存在空闲得物理块,需要进行页面置换ﻩﻩposition= findReplace();ﻩblock[position]、pagenum = curpage;ﻩﻩdisplay();ﻩn++;//缺页次数+1ﻩ}ﻩﻩ}elseﻩﻩblock[exist]、accessed = -1;//恢复存在得并刚访问过得BLOCK中页面accessed为-1for(int j=0; j<blocknum; j++)ﻩﻩ{//其余得accessed++ﻩﻩblock[j]、accessed++;}ﻩ}printf("缺页次数:%d\n”,n);ﻩprintf("缺页率:%f%%\n",(n/320、0)*100);}void FIFO(){int n=0;//记录缺页次数int exist,space,position ;ﻩ int curpage;//当前指令得页面号int blockpointer=-1;for(int i=0;i<320;i++)ﻩ{ﻩ m=num[i];curpage=m/10;ﻩexist = pageExist(curpage);ﻩ if(exist==-1){//当前指令得页面号不在物理块中ﻩ space = findSpace();ﻩﻩif(space !=-1)ﻩ { //当前存在空闲得物理块ﻩﻩ blockpointer++;ﻩﻩﻩblock[space]、pagenum=curpage; //将此页面调入内存ﻩ n++;//缺页次数+1ﻩﻩﻩ display();//显示物理块中得页面号ﻩ}ﻩ elseﻩ { //没有空闲物理块,进行置换ﻩﻩﻩﻩposition = (++blockpointer)%4;ﻩ block[position]、pagenum = curpage;//将此页面调入内存ﻩﻩn++;ﻩﻩ display();ﻩ}ﻩ }}printf("缺页次数:%d\n",n);printf("缺页率:%f%%\n",(n/320、0)*100);}void main(){ﻩint choice;ﻩprintf("************请求分页存储管理模拟系统*************\n");ﻩrandam();printf("************此进程得页面调用序列如下**************\n”);pagestring();ﻩwhile(choice!= 4){ﻩﻩprintf("********1:OPT 2:LRU 3:FIFO 4:退出*********\n”);ﻩprintf("请选择一种页面置换算法:”);ﻩscanf("%d",&choice);ﻩinit();ﻩswitch(choice)ﻩ{ﻩcase 1:ﻩﻩﻩprintf(”最佳置换算法OPT:\n");ﻩprintf("页面号物理地址页面号物理地址页面号物理地址页面号物理地址\n");ﻩﻩﻩOPT();ﻩbreak;ﻩcase 2:ﻩﻩprintf("最近最久未使用置换算法LRU:\n");ﻩprintf("页面号物理地址页面号物理地址页面号物理地址页面号物理地址\n");ﻩLRU();ﻩﻩﻩbreak;ﻩﻩcase 3:ﻩprintf("先进先出置换算法FIFO:\n");ﻩprintf("页面号物理地址页面号物理地址页面号物理地址页面号物理地址\n");FIFO();ﻩﻩbreak;ﻩ}}}。
实验--编程实现请求分页存储管理页面Optimal、FIFO、LRU置换算法
for(int i=0;i<fS;i++){
if(((Couple)(i)).time<temp){
temp=((Couple)(i)).time;
index=i;
}
}
for(int i=0;i<fS;i++){
if(i!=index){
((Couple)(i)).time--;
for(int i=0;i<;i++){
"Frame size: "+frameSize[i]+"\n");
(frameSize[i]);
(frameSize[i]);
"Total errors found: "+errorCount);
"\n************************************\n");
(frameSize[i]);
(frameSize[i]);
"Total errors found: "+errorCount);
"\n************************************\n");
errorCount=0;
}
"----------------Using LRU----------------");
(new Couple(0));
}
}
public void LRUReplace(int fS){
boolean findThesame=false;
int pre=-1;alue==digitalArray[j]){
Java分页代码的实现
Java分页代码的实现1、定义分页模型:PageModelpackage mon.page;import java.util.List;/*** 封装分页信息* @author Administrator**/public class PageModel<E> {//结果集private List<E> list;//查询记录数private int totalRecords;//每页多少条数据private int pageSize;//第⼏页private int pageNo;/*** 总页数* @return*/public int getTotalPages() {return(totalRecords + pageSize - 1) / pageSize;}/*** 取得⾸页* @return*/public int getTopPageNo() {return1;}/*** 上⼀页* @return*/public int getPreviousPageNo() {if(pageNo <= 1) {return1;}return pageNo - 1;}/*** 下⼀页* @return*/public int getNextPageNo() {if(pageNo >= getBottomPageNo()) {return getBottomPageNo();}return pageNo + 1;}/*** 取得尾页* @return*/public int getBottomPageNo() {return getTotalPages();}public List<E> getList() {return list;}public void setList(List<E> list) {this.list = list;}public int getTotalRecords() {return totalRecords;}public void setTotalRecords(int totalRecords) {this.totalRecords = totalRecords;}public int getPageSize() {return pageSize;}public void setPageSize(int pageSize) {this.pageSize = pageSize;}public int getPageNo() {return pageNo;}public void setPageNo(int pageNo) {this.pageNo = pageNo;}}2、分页测试:在MySQL中建⽴admin表,⾥⾯有字段id、name、password3、简历Admin的实体bean类:package mon.page;public class Admin {private int id;private String name;private String password;public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}}package mon.page;import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;import java.util.ArrayList;import java.util.List;import mon.db.DbUtil;public class Client {public static PageModel findAdmins(int pageNo,int pageSize){Connection conn=DbUtil.getConnection();String sql="select * from admin limit ?,?";PageModel pageModel=null;PreparedStatement pstm=null;ResultSet rs=null;Admin admin=null;List<Admin> list=new ArrayList<Admin>();try{pstm=conn.prepareStatement(sql);pstm.setInt(1, (pageNo-1)*pageSize);pstm.setInt(2, pageNo*pageSize);rs=pstm.executeQuery();;while(rs.next()){admin=new Admin();admin.setId(rs.getInt("a_id"));admin.setName(rs.getString("a_name"));admin.setPassword(rs.getString("a_pwd"));list.add(admin);}ResultSet rs2=pstm.executeQuery("select count(*) from admin");int total=0;if(rs2.next()){total=rs2.getInt(1);}pageModel=new PageModel();pageModel.setPageNo(pageNo);pageModel.setPageSize(pageSize);pageModel.setTotalRecords(total);pageModel.setList(list);} catch(SQLException e) {e.printStackTrace();}finally{DbUtil.close(conn);DbUtil.close(pstm);DbUtil.close(rs);}return pageModel;}public static void main(String[] args) {PageModel pageModel=Client.findAdmins(2,4);List<Admin> list=pageModel.getList();for(Admin a:list){System.out.print("ID:"+a.getId()+",⽤户名:"+a.getName()+",密码:"+a.getPassword());System.out.println();}System.out.print("当前页:"+pageModel.getPageNo()+" ");System.out.print("共"+pageModel.getTotalPages()+"页 ");System.out.print("⾸页:"+pageModel.getTopPageNo()+" ");System.out.print("上⼀页:"+pageModel.getPreviousPageNo()+" ");System.out.print("下⼀页:"+pageModel.getNextPageNo()+" ");System.out.print("尾页:"+pageModel.getBottomPageNo()+" ");System.out.print("共"+pageModel.getTotalRecords()+"条记录");System.out.println();}}这样分页效果就实现了,我们要实现分页效果,只要传⼊相应的参数和相应的数据库执⾏语句即可实现。
操作系统课程设计模拟请求页式存储管理
操作系统课程设计报告项目:模拟请求页式存储管理一、目的和要求1、实训目的(1)通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解。
熟悉虚存管理的各种页面淘汰算法(2)通过编写和调试地址转换过程的模拟程序以加强对地址转换过程的了解。
2、实训要求编写并调试完成请求页式存储管理程序。
页面置换算法:最佳置换算法(OPT)、先进先出算法(FIFO)和最近最少用算法(LRU)。
要求打印每个页面置换算法的页面置换变化示意图、缺页中断次数和缺页中断率,以比较各种算法的优缺点。
二、设计思路及过程1、概要设计1.1 问题概述根据三种不同的置换算法(FIFO、LRU、OPT),依据其不同的算法方式,分别计算该页面引用串在不同算法下的缺页次数与缺页率,并显示各页面的变化情况。
1.2 内容分析对于该课程设计中模拟的请求页式存储管理的页面置换过程,只要掌握其中最基本的三种算法,包括FIFO、LRU及OPT。
另外,对于同一个页面引用串,要求能够调用不同的算法对它进行操作。
2、过程设计2.1模块设计在下图的主模块设计图中,只注重描绘了请求页式存储管理的三种主要算法,未描绘出细节部分。
图2.1 请求页式存储管理的主模块设计图2.2 算法原理分析要成功实现算法,首先要知道各个方法是怎么做的,即原理是怎样的,下面是三种算法的原理。
(1)FIFO算法:该算法认为刚被调入的页面在最近的将来被访问的可能性很大,而在主存中滞留时间最长的页面在最近的将来被访问的可能性很小。
因此。
FIFO算法总是淘汰最先进入主存的页面,即淘汰在主存中滞留时间最长的页面。
(2)LRU算法是最近最久未使用,当当前内存中没有正要访问的页面时,置换出在当前页面中最近最久没有使用的页面。
该算法总是选择最近一段时间内最长时间没有被访问过的页面调出。
它认为那些刚被访问过的页面可能在最近的将来还会经常访问他们,而那些在较长时间里未被访问的页面,一般在最近的将来再被访问的可能性较小。
请求页式存储管理的模拟实现_参考代码_
case REQUEST_EXECUTE:
ptr_pageTabIt->count++;
if(!(ptr_pageTabIt->proType&EXECUTABLE)){
do_error(ERROR_EXECUTE_DENY);
return ;
}
info.Format(_T("执行成功\n"));
out->SetSel(-1, -1);
out->ReplaceSel(info);
if(pageTable[page].modified){
info.Format(_T("有修改,写回至外存\n"));
out->SetSel(-1, -1);
out->ReplaceSel(info);
do_page_out(&pageTable[page]);
do_init(){
int i,j;
srand(time(NULL));
for(i=0;i<PAGE_SUM;i++){
pageTable[i].pageNum=i;
pageTable[i].effective=mFALSE;
pageTable[i].modified=mFALSE;
pageTable[i].count=0;
ptr_pageTabIt->blockNum=j;//修改调入页的页表项
ptr_pageTabIt->effective=TRUE;
ptr_pageTabIt->count=0;
info.Format(_T("页面替换成功\n"));
模拟操作系统的请求分页存储管理java代码
请求分页存储管理的实现写出方案实现代码(1)page类package homework;public class Page {private int pagenumb;//页号private int physicsnumb;//物理块号private boolean state;//状态位private int visitcount;//访问字段private boolean change;//修改位private int CRTaddress;//外存地址public Page(){this.pagenumb=-1;this.physicsnumb=-1;this.state=false;this.visitcount=0;this.change=false;this.CRTaddress=-1;}public Page(int pagenumb,int physicsnumb,boolean state,int visitcount,boolean change,int CRTaddress){this.pagenumb=pagenumb;this.physicsnumb=physicsnumb;this.state=state;this.visitcount=visitcount;this.change=change;this.CRTaddress=CRTaddress;}public void setPagenumb(int pagenumb){this.pagenumb=pagenumb;}public void setPhysicsnumb(int physicsnumb){this.physicsnumb=physicsnumb;}public void setState(boolean state){this.state=state;}public void setVisitcount(int visitcount){this.visitcount=visitcount;}public void setChange(boolean change){this.change=change;}public void setCRTaddress(int CRTaddress){this.CRTaddress=CRTaddress;}public int getPagenumb(){return this.pagenumb;}public int getPhysicsnumb(){return this.physicsnumb;}public boolean getState(){return this.state;}public int getVisitcount(){return this.visitcount;}public boolean getChange(){return this.change;}public int getCRTaddress(){return this.CRTaddress;}}(2)Shell类:页表package homework;import java.util.Scanner;public class Shell {Page shell[];private int current;private int length;public Shell(){ };public Shell(int length){this.length=length;this.current=0;shell=new Page[length];for(int i=0;i<length;i++){this.shell[i]=new Page();}}public void setCurrent(int current){this.current=current;} public int getCurrent(){return this.current;}public int searchpage(int pagenumb){int i=0;if(this.current==0){return -2;}else{while(i<this.current){if(this.shell[i].getPagenumb()==pagenumb){return i;}i++;}return -1;}}public void Inchange(int b[],String ch,int number){Scanner a=new Scanner(System.in);switch(ch){case"yes":{System.out.println("请输入一个新的数据");b[this.shell[number].getPhysicsnumb()]=a.nextInt();this.shell[number].setChange(true);System.out.println("修改成功!");break;}case"no":{break;}default:{System.out.println("输入字符有误,将退出程序!!");System.exit(0);}}}public int Isover(){if(this.current>=this.length){return 1;}else return 0;}public int MinVisitcount(){int i,t=0;for(i=1;i<this.current;i++){if(this.shell[i].getVisitcount()<this.shell[t].getVisitcount()){ t=i;}}return t;}public int Ischange(int number){if(this.shell[number].getChange()==true){return 1;}else return 0;}public void printPageShell(){System.out.println("页表:");System.out.println("索引\t"+"页号\t"+"物理块号\t"+"状态\t"+"访问次数\t"+"修改\t"+"外存地址\t");for(int i=0;i<this.length;i++){System.out.println(i+"\t"+this.shell[i].getPagenumb()+"\t"+this.shell[i ].getPhysicsnumb()+"\t"+this.shell[i].getState()+"\t"+this.shell[i].getVisi tcount()+"\t"+this.shell[i].getChange()+"\t"+this.shell[i].getCRTaddress()) ;}}public void programFunction(){System.out.println("****************************请求分页存储系统****************************");System.out.println("功能:");System.out.println("\t 1.查看页表");System.out.println("\t 2.查看快表");System.out.println("\t 3.查看外存");System.out.println("\t 4.在内存修改数据");System.out.println("\t 5.继续访问页面");System.out.println("\t 6.退出程序");}public void Dealfunction(int i,KShell TLB,Source s[],int b[]){ if(i==1){this.printPageShell();}else if(i==2){TLB.printKShell();}else if(i==3){System.out.println("外存:");System.out.println("外存地址\t"+"页号\t"+"数据\n");for(int k=0;k<20;k++){s[k].printSource(k);}}else if(i==4){String ch="yes";int pageNumb;Scanner a=new Scanner(System.in);System.out.print("请输入一个页号:");pageNumb=a.nextInt();int numb=this.searchpage(pageNumb);if(numb<0){System.out.println("内存中没有此页号");}else{this.Inchange(b, ch,numb);}}else if(i==6){System.out.println("结束程序");System.exit(0);}}public static void main(String[] args){Scanner a=new Scanner(System.in);int i,number=-10,k1,k2,result;int k3=0;//当前存储的内存地址int t;//页表中访问次数最小的索引int b[]=new int[10];//内存中存储的数据String ch;int slength,plength,Tlength,data;System.out.print("请输入外存大小:");slength=a.nextInt();System.out.print("请输入页表大小:");plength=a.nextInt();System.out.print("请输入快表大小:");Tlength=a.nextInt();//定义页表,快表,外存Shell pageshell=new Shell(plength);//页表Source s[]=new Source[slength];//外存KShell TLB=new KShell(Tlength);//快表System.out.println("产生一个随机序列作为外存数据!");//录入外存地址和数据for(i=0;i<slength;i++){data=(int)(100*Math.random());System.out.print(data+"\t");s[i]=new Source(i,data);System.out.println("\n外存设置成功");//请求页面do{//TLB.printKShell();//打印当前快表的情况//pageshell.printPageShell();//打印当前页表的情况System.out.println("请输入一个页面的页号(0-19):");k1=a.nextInt();if(k1>=20||k1<0){System.out.println("输入数据有错,将退出程序!!");System.exit(0);}//检测快表,快表存储当前的页表项,即当快表满时采用最近最久未被使用算法置换快表System.out.println("进入快表检测");if(TLB.getCurrent()>0){number=TLB.searchpage(k1);if(number!=-1&&number!=-2){result=b[TLB.shell[number].getPhysicsnumb()];System.out.println("在快表中找到,结果为:"+result);//找出该页号在页表中的位置并修改访问字段number=TLB.shell[number].getIndex();pageshell.shell[number].setVisitcount(pageshell.shell[number].getVisitc ount()+1);}}if(TLB.getCurrent()<=0||number==-1){System.out.println("在快表中找不到!"+"进入内存检测:");//在快表中找不到,去内存区的页表找if(pageshell.current>0){number=pageshell.searchpage(k1);//页号k1所在的下标if(number!=-1&&number!=-2){result=b[pageshell.shell[number].getPhysicsnumb()];System.out.println("在页表中找到,结果为:"+result);//修改访问字段和状态位pageshell.shell[number].setVisitcount(pageshell.shell[number].getVisitc ount()+1);//修改快表TLB.changeKShell(pageshell, number);}if(pageshell.current<=0||number==-1){System.out.println("在内存中找不到!!");System.out.println("从外存中调入内存:");//在页表找不到,去外存区找for(i=0;i<slength;i++){if(k1==s[i].getPagenumb()){//在外存找到了缺页k2=pageshell.Isover();if(k2==1){//内存已满t=pageshell.MinVisitcount();System.out.println("内存已满!即将调出页号"+pageshell.shell[t].getPagenumb());}else{t=pageshell.current;pageshell.setCurrent(pageshell.getCurrent()+1);}//判断是否修改了内存的数据if(pageshell.Ischange(t)==1){s[pageshell.shell[t].getCRTaddress()].setSts(b[pageshell.shell[t].getPh ysicsnumb()]);}//调入内存pageshell.shell[t].setPagenumb(k1);if(k2==1){b[pageshell.shell[t].getPhysicsnumb()]=s[i].getSts();}else{pageshell.shell[t].setPhysicsnumb(k3);//未满则设置物理块号,满了只改变其他5个字段b[k3]=s[i].getSts();k3++;//物理块号}pageshell.shell[t].setState(true);pageshell.shell[t].setVisitcount(1);pageshell.shell[t].setChange(false);pageshell.shell[t].setCRTaddress(i);System.out.println("调入内存成功!");//修改快表TLB.changeKShell(pageshell,t);System.out.println("修改快表成功!");System.out.println("结果为:"+b[k3-1]);break;}}}}do{pageshell.programFunction();System.out.print("请输入一个整数(1-6):");i=a.nextInt();while(i<1||i>6){System.out.println("输入有误,请重新输入(1-6):");i=a.nextInt();}pageshell.Dealfunction(i,TLB,s,b);}while(i!=5);/*System.out.println("是否继续请求访问页面(1 or 0):");i=a.nextInt();while(i!=1&&i!=0){System.out.println("输入有误,请重新输入(1 or 0):");i=a.nextInt();}*/}while(i==5);System.out.println("退出程序!");}}(4)KShell类:快表package homework;public class KShell {KPage shell[];private int current;private int length;private int changenumb;//修改快表的次数public KShell(){ };public KShell(int length){this.length=length;this.current=0;this.changenumb=0;shell=new KPage[length];for(int i=0;i<length;i++){this.shell[i]=new KPage();}public void setCurrent(int current){this.current=current;}public void setChangenumb(int changenumb){this.changenumb=changenumb;} public int getCurrent(){ return current;}public int getChangenumb(){return changenumb;}public int getLength(){ return length;}public int searchpage(int pagenumb){int i=0;if(this.changenumb==0&&this.current==0){return -2;}else if(this.changenumb<this.length){while(i<this.current){if(this.shell[i].getPagenumb()==pagenumb){return i;}i++;}return -1;}else{while(i<this.length){if(this.shell[i].getPagenumb()==pagenumb){return i;}i++;}return -1;}}public void changeKShell(Shell pageshell,int number){if(this.getChangenumb()>=this.getLength()){if(this.getCurrent()==this.getLength()){this.setCurrent(0);}System.out.println("快表已满,快表中即将调出页号"+this.shell[this.current].getPagenumb());}if(this.getCurrent()<this.getLength()){this.shell[this.getCurrent()].setIndex(number);this.shell[this.getCurrent()].setPagenumb(pageshell.shell[number].getPa genumb());this.shell[this.getCurrent()].setPhysicsnumb(pageshell.shell[number].ge tPhysicsnumb());this.setCurrent(this.getCurrent()+1);this.setChangenumb(this.getChangenumb()+1);}}public void printKShell(){System.out.println("快表:");System.out.println("索引\t"+"页号\t"+"物理块号\t"+"在页表下的索引");for(int i=0;i<this.length;i++){System.out.println(i+"\t"+this.shell[i].getPagenumb()+"\t"+this.shell[i ].getPhysicsnumb()+"\t"+this.shell[i].getIndex());}}}(5)Source类:外存package homework;public class Source {private int pagenumb;//页号private int sts; //数据int length;public Source(){}public Source(int pagenumb,int sts){this.pagenumb=pagenumb;this.sts=sts;}public void setPagenumb(int pagenumb){this.pagenumb=pagenumb;}public void setSts(int sts){this.sts=sts;}public int getPagenumb(){return this.pagenumb;}public int getSts(){return this.sts;}public void printSource(int i){System.out.println(i+"\t"+this.pagenumb+"\t"+this.sts+"\n");}}4.用户使用说明答:本程序是使用java语言编写的实现请求分页存储管理的程序,是在eclipise下运行的结果,只需运行Shell类就行了首先先设置外存,页表和快表的大小,然后输入一个请求访问的页面。
操作系统实验3--请求分页式存储管理
请求分页式存储管理一、问题描述设计一个请求页式存储管理方案,为简单起见。
页面淘汰算法采用FIFO页面淘汰算法,并且在淘汰一页时,只将该页在页表中修改状态位。
而不再判断它是否被改写过,也不将它写回到辅存。
二、基本要求页面尺寸1K,输入进程大小(例如5300bytes),对页表进行初始化页表结构如下:系统为进程分配:任意输入一个需要访问的指令地址流(例如:3635、3642、1140、0087、1700、5200、4355,输入负数结束),打印页表情况。
每访问一个地址时,首先要计算该地址所在的页的页号,然后查页表,判断该页是否在主存——如果该页已在主存,则打印页表情况;如果该页不在主存且页框未满(查空闲块表,找到空闲块),则调入该页并修改页表,打印页表情况;如果该页不在主存且页框已满,则按FIFO页面淘汰算法淘汰一页后调入所需的页,修改页表,打印页表情况。
存储管理算法的流程图见下页。
三、实验要求完成实验内容并写出实验报告,报告应具有以下内容:1、实验目的。
2、实验内容。
3、程序及运行情况。
4、实验过程中出现的问题及解决方法。
#include<stdio.h>#include<stdlib.h>int PUB[20][3];int ABC[3][2]={{0,1},{1,1},{2,1}};//物理块int key=0;void output(int size){//打印int i,j;printf("页号\t\t物理块号\t\t状态位\n\n");for(i=0;i<size;i++){printf(" %d\t\t%d\t\t\t%d\n\n",PUB[i][0],PUB[i][1],PUB[i][2]);}printf("物理块号\t\t是否空闲\n\n");for(i=0;i<3;i++){printf(" %d\t\t\t%d\n\n",ABC[i][0],ABC[i][1]);}}void main(){int size;int i,j;int address=0;int select=0;printf("请输入进程大小\n");scanf("%d",&size);if(size<=0 || size>20000){printf("进程大小超出范围\n");exit(0);}size%1000==0 ? size=size/1000 : size=size/1000+1;for(i=0;i<size;i++){PUB[i][0]=i; //页号PUB[i][1]=0; //物理块号PUB[i][2]=0; //状态位}output(size);while(1){printf("输入指令地址\n");scanf("%d",&address);if(address<0 || address>20000){printf("地址超出范围\n");exit(0);}address%1000==0 ? address=address/1000 : address=address/1000;if(PUB[address][2]==0) //不在主存{if(ABC[2][1]==0) //满了{printf("满了\n");if(select!=address) key++;for(i=0;i<size;i++){if(PUB[i][1]==key){PUB[i][1]=0;PUB[i][2]=0;}}PUB[address][1]=key;PUB[address][2]=1;key++;if(key>3) key=1;}if(ABC[2][1]==1) //没满{printf("没满\n");for(i=0;i<3;i++){if(ABC[i][1]==1){ABC[i][1]=0;PUB[address][1]=i+1;PUB[address][2]=1;break;}}}output(size);}else{printf("该页已在内存\n");output(size);}select=address;}}。
计算机操作系统实验_源码_模拟请求分页虚拟存储管理中的硬件地址变换过程[技巧]
地址变换算法框图如图10—1所示。
运行设计的地址变换程序 ,显示或打印运行结果。。因为只是模拟地址变换,并不
cin>>menu;
while(menu)
{
switch(menu)
{
case 1:
cout<<"请输入指令的逻辑地址:";
cin>>ins;
changeaddr(p,ins);
break;
case 2:
cout<<"谢谢使用,下次再见~"<<endl;
exit(0);
break;
default:
cout<<"输入有误,请重新输入~"<<endl;
cout<<"----------\t\t1.输入指令\t\t---------"<<endl;
cout<<"----------\t\t2.退出程序\t\t---------"<<endl;
cout<<"----------欢迎使用分页虚拟存储器硬件地址变换算法---------"<<endl;
cout<<endl<<"请输入您的选择:";
p[2].pno=2;p[2].flag=1;p[2].cno=9;p[2].modf=0;p[2].addr=013;
操作系统_请求分页存储管理模拟实现
操作系统请求分页存储管理模拟实现#include<stdlib.h>#include<iomanip.h>#include"windows.h"#include"os.h"#define n 64//实验中假定主存的长度#define m 4//实验中假定每个作业分得主存块块数int p[m];//定义页struct{short int lnumber;//页号short int flag;//表示该页是否在主存,“1”表示在主存,“0”表示不在主存short int pnumber;//该页所在主存块的块号short int write;//该页是否被修改过,“1”表示修改过,“0”表示没有修改过short int dnumber;//该页存放在磁盘上的位置,即磁盘块号short int times;//被访问的次数,用于LRU算法}page[n];//定义页表//各个函数的实现如下:computer::computer(){int i;for(i=0;i<n;i++){page[i].lnumber = i;page[i].flag = 0;page[i].pnumber = 10000;//用10000表示为空page[i].write = 0;page[i].dnumber = i;page[i].times = 0;}//初始化页表for(i=0;i<m;i++){page[i].pnumber = i;}for(i=0;i<m;i++){p[i] = i;page[i].flag = 1;}//初始化页}void computer::showpagelist(){int i;cout<<"页号"<<"\t"<<"是否在主存中"<<"\t"<<"块号"<<"\t"<<"是否被修改过"<<"\t"<<"磁盘块号"<<"\t"<<"访问次数"<<endl;for(i=0;i<n;i++){cout<<page[i].lnumber<<"\t"<<page[i].flag<<""<<page[i].pnumber<<"\t"<<page[i].write<<" "<<page[i].dnumber<<" \t"<<page[i].times<<endl;}}void computer::showpage(){int i;for(i=0;i<m;i++){cout<<"\t"<<p[i];}cout<<endl;}void computer::transformation(){unsignedlogicAddress,logicNumber,innerAddress,physicsAddress,physicsNumber;int i,head=0,fail = 0;int method,temppage=0;short int times = 10000;cout<<"请输入一个逻辑地址(四位十六进制数):";cin>>hex>>logicAddress;//读入逻辑地址logicNumber = logicAddress >> 10;//得到页号cout<<"页号为:"<<logicNumber<<endl;innerAddress = logicAddress & 0x03ff;//得到页内地址cout<<"页内地址为:"<<innerAddress<<endl;for(i=0;i<n;i++){if(logicNumber==(unsigned)page[i].lnumber){if(page[i].flag == 1){cout<<"请求的页面在主存中!"<<endl;page[i].times++;physicsNumber = page[i].pnumber;//由页号得到块号cout<<"请求的主存块号为:"<<physicsNumber<<endl;physicsAddress = physicsNumber << 10 |innerAddress;//得到物理地址cout<<"请求的物理地址为:"<<physicsAddress<<endl;//输出物理地址break;}else{cout<<"请求的页面不在主存中! 将进行缺页中断处理!"<<endl<<"请选择算法!"<<endl; cout<<"1.先进先出"<<endl<<"2.最近最少用"<<endl<<"请选择置换算法:";cin>>method;if(method == 1) //采用先进先出算法{cout<<"采用先进先出算法!"<<endl;fail = p[head];cout<<"第"<<fail<<"页将被替换!"<<endl;p[head] = logicNumber;head = (head+1) % m;if(page[fail].write == 1)cout<<"第"<<fail<<"页曾被修改过!"<<endl;page[fail].flag = 0;page[logicNumber].flag = 1;page[logicNumber].write = 0;page[logicNumber].pnumber = page[fail].pnumber; page[fail].pnumber = 10000;page[logicNumber].times++;break;}else if(method == 2) //采用最近最少用算法{cout<<"采用最近最少用算法!"<<endl;for(i=0;i<n;i++){if(page[i].flag == 1){if(page[i].times<times){times = page[i].times;temppage = page[i].lnumber;}}}cout<<"第"<<temppage<<"页将被替换!"<<endl; for(i=0;i<m;i++){if(p[i] == temppage){p[i] = logicNumber;}}if(page[temppage].write == 1)cout<<"第"<<temppage<<"页曾被修改过!"<<endl; page[temppage].flag = 0;page[logicNumber].flag = 1;page[logicNumber].write = 0;page[logicNumber].pnumber = page[temppage].pnumber; page[temppage].pnumber = 10000;page[logicNumber].times++;break;}else{ cout<<"你输入有误,即将退出!";exit(1);}}}}}void main(){char c,d;computer os;cout<<"页表正在初始化中...,3秒钟后为你显示页和页表!"<<endl; Sleep(3000);os.showpage();os.showpagelist();T:os.transformation();cout<<"是否显示页和页表?(Y/N)";cin>>c;switch(c){case 'y':os.showpage();os.showpagelist();case 'n':cout<<"是否继续进行请求分页?(Y/N)";cin>>d;if (d=='Y'||d=='y')goto T;else if (d=='N'||d=='n')exit(1);elsecout<<"输入错误!"<<endl; default:cout<<"输入错误!"<<endl; } }。
请求分页存储管理模拟实验
操作系统模拟实验实验名称:请求分页存储管理模拟实验实验目的:通过实验了解windows系统中的线程同步如何使用,进一步了解操作系统的同步机制。
实验内容:调用Windows API,模拟解决生产者-消费者问题;思考在两个线程函数中哪些是临界资源?哪些代码是临界区?哪些代码是进入临界区?哪些代码是退出临界区?进入临界区和退出临界区的代码是否成对出现?学习Windows API中的如何创建线程,互斥,临界区等。
程序运行结果:源程序:#include "stdAfx.h"//包含头文件以支持多线程#include "windows.h"#include "stdio.h"//用于标志所有的子线程是否结束//每次子线程结束后,此值便加1。
static long ThreadCompleted = 0;//互斥量HANDLE mutex;//信号量,用于生产者通知消费者HANDLE full;//信号量,用于消费者通知生产者HANDLE empty;//信号量,当所有的子线程结束后,通知主线程,可以结束。
HANDLE evtTerminate;//生产标志#define p_item 1//消费标志#define c_item 0//哨兵#define END 10//缓冲区最大长度const int max_buf_size=11;const int cur_size=10;//缓冲区定义int BUFFER[max_buf_size];//放消息指针int in=0;//取消息指针int out=0;int front=0;int tail=0;int sleep_time=1000;bool flag=true;//线程函数的标准格式unsigned long __stdcall p_Thread(void *theBuf);unsigned long __stdcall c_Thread(void *theBuf);//打印缓冲区内容void PrintBuf(int buf[],int buf_size);int main(int argc, char* argv[]){//初始化缓冲区unsigned long TID1, TID2;for(int i=0;i<cur_size;i++)BUFFER[i]=0;//互斥量和信号量的创建,函数用法可查看MSDNmutex=CreateMutex(NULL,false,"mutex");full=CreateSemaphore(NULL,0,1,"full");empty=CreateSemaphore(NULL,max_buf_size,max_buf_size,"empty");evtTerminate = CreateEvent(NULL, FALSE, FALSE, "Terminate");//创建一个生产者线程和消费者线程。
操作系统实验请求分页存储管理模拟实验
实验四请求分页存储管理模拟实验一:实验目的通过对页面、页表、地址转换和页面置换过程的模拟,加深对请求分页存储管理系统的原理和实现技术的理解;二:实验内容假设每个页面可以存放10条指令,分配给进程的存储块数为4;用C语言或Pascal语言模拟一进程的执行过程;设该进程共有320条指令,地址空间为32个页面,运行前所有页面均没有调入内存;模拟运行时,如果所访问的指令已经在内存,则显示其物理地址,并转下一条指令;如果所访问的指令还未装入内存,则发生缺页,此时需要记录缺页产生次数,并将相应页面调入内存,如果4个内存块已满,则需要进行页面置换;最后显示其物理地址,并转下一条指令;在所有指令执行完毕后,显示进程运行过程中的缺页次数和缺页率;页面置换算法:分别采用OPT、FIFO、LRU三种算法;进程中的指令访问次序按如下原则生成:50%的指令是顺序执行的;25%的指令是均匀分布在低地址部分;25%的指令是均匀分布在高地址部分;三:实验类别分页存储管理四:实验类型模拟实验五:主要仪器计算机六:结果OPT:LRU: FIFO:七:程序include<>include<>include<>define blocknum 4agenum=-1;blocki.accessed=0;m=0;}}int pageExistint curpageagenum == curpagereturn i; agenum==-1return i; ccessed > blockpos.accessedpos = i; agenum = -1{printf" %02d ",blocki.pagenum;printf"%p |",&blocki.pagenum;}}printf"\n";}void randamagenum = curpage; agenum= numj/10{blockk.accessed = 1000;} ccessed = j;break;}}}position = findReplace;agenum = curpage;agenum = curpage; agenum = curpage;display;n++; ccessed = -1;ccessed++;}}printf"缺页次数:%d\n",n;printf"缺页率:%f%%\n",n/100;}void FIFO{int n=0;agenum=curpage; agenum = curpage; //将此页面调入内存n++;display;}}}printf"缺页次数:%d\n",n;printf"缺页率:%f%%\n",n/100;}void main{int choice;printf"请求分页存储管理模拟系统\n";randam;printf"此进程的页面调用序列如下\n";pagestring;whilechoice = 4{printf"1:OPT 2:LRU 3:FIFO 4:退出\n";printf"请选择一种页面置换算法:";scanf"%d",&choice;init;switchchoice{case 1:printf"最佳置换算法OPT:\n";printf"页面号物理地址页面号物理地址页面号物理地址页面号物理地址\n";OPT;break;case 2:printf"最近最久未使用置换算法LRU:\n";printf"页面号物理地址页面号物理地址页面号物理地址页面号物理地址\n";LRU;break;case 3:printf"先进先出置换算法FIFO:\n";printf"页面号物理地址页面号物理地址页面号物理地址页面号物理地址\n";FIFO;break;}}}。
请求调页存储管理方式的模拟
实验3请求调页存储管理方式的模拟1实验目的通过对页面、页表、地址转换和页面置换过程的模拟,加深对请求调页系统的原理和实现过程的理解。
2实验内容(1)假设每个页面中可存放10条指令,分配给一作业的内存块数为4。
(2)模拟一作业的执行过程。
该作业共有320条指令,即它的地址空间为32页,目前它的所有页都还未调入内存。
在模拟过程中,如果所访问的指令已经在内存中,则显示其物理地址,并转下一条指令。
如果所访问的指令还未装入内存,则发生缺页,此时需记录缺页的次数,并将相应页调入内存。
如果4个内存块中均已装入该作业,则需进行页面置换。
最后显示其物理地址,并转下一条指令。
在所有320条指令执行完毕后,请计算并显示作业运行过程中发生的缺页率。
(3)置换算法:请分别考虑OPT、FIFO和LRU算法。
(4)作业中指令的访问次序按下述原则生成:•50%的指令是顺序执行的。
•25%的指令是均匀分布在前地址部分。
•25%的指令时均匀分布在后地址部分。
代码:package mainDart;import java.util.ArrayList;import java.util.List;import java.util.Random;public class FIFO {private static int times=0;//记录置换内存页面的次数/*** 随机产生0~319之间的数* 产生320条指令** @return 包含320条指令的数组*/public static int[] productNumber(){int order[] = new int[320];//数组存储的数字表示指令Random rand = new Random();for(int i=0;i<320;i++){if(i%4==0){order[i]=rand.nextInt(319); //0<=order<319}else if(i%4==1){order[i]=order[i-1]+1;//1<=order<320}else if(i%4==2){order[i]= rand.nextInt(order[i-1]);}else if(i%4==3){order[i]=order[i-1]+rand.nextInt(320-order[i-1]);}}return order;}/*** 打印链表* @param list*/public static void printList(List<Integer> list){for(int temt:list){System.out.print(temt+"\t");}System.out.println();}/*** 先进先出算法* 总是淘汰最先进入内存的页面* 在实现的时候,记录上一次所替换的页面在内存的下标,则本次要替换的位置就是上次下标+1的位置,并且下标是0~3循环的* @param memoryNum* @param page*/public static void FIFOChangePage(List<Integer> memoryNum,int page){int index = FIFOChangePage(memoryNum,page,++times);memoryNum.remove(index);memoryNum.add(index, page);}/*** 返回本次替换的页面在内存中的位置* @param memoryNum* @param page* @param times记录替换页面的次数,第一次替换的是内存第0个单元* @return*/public static int FIFOChangePage(List<Integer> memoryNum,int page,int times) {if(times==1){return 0;}int index = (FIFOChangePage(memoryNum,page,times-1)+1)%4;return index;}public static void main(String[] args) {int[] order = productNumber();System.out.println("320条随机指令数:");for(int i =0;i<order.length;i++){System.out.print(order[i]+"\t");if((i+1)%10==0){System.out.println();}}List<Integer> memoryNum= new ArrayList<Integer>(4);//内存块存储的页面int count=0;//记录缺页次数for(int i=0;i<320;i++){int page = order[i]/10;if(memoryNum.contains(page)) //若该指令所在页面已经在内存,输出该页面所在内存块的号{}else//没在内存,发生缺页,需要判断内存块是否存满,{if(memoryNum.size()<4) //内存没满,直接将所需页面调入内存{memoryNum.add(page);}else//内存存满,需要调用页面置换算法,进行页面置换{FIFOChangePage(memoryNum,page);//先进先出算法}count++;//记录缺页次数}printList(memoryNum);//打印内存所调入页面的情况}System.out.println("缺页率:"+(double)count/320);}}package mainDart;import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;import java.util.Random;public class LRU {/*** 随机产生0~319之间的数* 产生320条指令** @return 包含320条指令的数组*/public static int[] productNumber(){int order[] = new int[320];//数组存储的数字表示指令Random rand = new Random();for(int i=0;i<320;i++){if(i%4==0){order[i]=rand.nextInt(319); //0<=order<319}else if(i%4==1){order[i]=order[i-1]+1;//1<=order<320}else if(i%4==2){order[i]= rand.nextInt(order[i-1]);}else if(i%4==3){order[i]=order[i-1]+rand.nextInt(320-order[i-1]);}}return order;}/*** 打印链表* @param list*/public static void printList(List<Integer> list){for(int temt:list){System.out.print(temt+"\t");}System.out.println();}/*** 最近最久未使用算法* @param order*/public static void LRUChangePage(int [] order){List<Integer> memoryNum = new ArrayList<Integer>(4);//内存块int[] timeFlag =new int[]{-1,-1,-1,-1}; //用来记录内存当中各单元未被访问的时间值int count=0;//记录缺页次数for(int i=0;i<320;i++){int page = order[i]/10;if(memoryNum.contains(page)) //若该指令所在页面已经在内存{int index = memoryNum.indexOf(page);timeFlag[index]=0;//将时间变为0 }else//没在内存,发生缺页,需要判断内存块是否存满,{if(memoryNum.size()<4) //内存没满,直接将所需页面调入内存{//将没有命中的所有页面的时间加一for(int in=0;in<4;in++){if(timeFlag[in]!=-1){timeFlag[in]+=1;}}//将page加入内存并将时间置为0memoryNum.add(page);timeFlag[memoryNum.indexOf(page)]=0;}else//内存存满,需要调用页面置换算法,进行页面置换{int maxIn=-1;//记录拥有最大时间值的标记的下标int maxT=-1;//记录最大的时间值for(int in=0;in<4;in++)//找出内存中时间值最大的进行替换{if(timeFlag[in]>maxT){maxT=timeFlag[in];maxIn=in;}}memoryNum.remove(maxIn);memoryNum.add(maxIn,page);timeFlag[maxIn]=0;//将没有命中的所有页面的时间加一for(int in=0;in<4;in++){if(in!=maxIn){timeFlag[in]+=1;}}}count++;//记录缺页次数}printList(memoryNum);//打印内存所调入页面的情况}System.out.println("缺页率:"+(double)count/320);}public static void main(String[] args) {int[] order = productNumber();System.out.println("320条随机指令数:");for(int i =0;i<order.length;i++){System.out.print(order[i]+"\t");if((i+1)%10==0){System.out.println();}}LRUChangePage(order);}}package mainDart;import java.util.ArrayList;import java.util.List;import java.util.Random;public class Optimal {/*** 随机产生0~319之间的数* 产生320条指令** @return 包含320条指令的数组*/public static int[] productNumber(){int order[] = new int[320];//数组存储的数字表示指令Random rand = new Random();for(int i=0;i<320;i++){if(i%4==0){order[i]=rand.nextInt(319); //0<=order<319}else if(i%4==1){order[i]=order[i-1]+1;//1<=order<320}else if(i%4==2){order[i]= rand.nextInt(order[i-1]);}else if(i%4==3){order[i]=order[i-1]+rand.nextInt(320-order[i-1]);}}return order;}/**** @param order320条指令数组* @return 返回一个链表,依次保存着320条指令每条指令所在的页面*/public static List<Integer> pageSeq(int[] order){List<Integer> pageSeq = new ArrayList<Integer>();for(int temp:order){pageSeq.add(temp/10);}return pageSeq;}/*** 打印链表* @param list*/public static void printList(List<Integer> list){for(int temt:list){System.out.print(temt+"\t");}System.out.println();}/*** 最佳置换算法* 根据当前已经在内存中的页面在之后被需要的先后进行置换** @param pageSeq 整个320条指令,从头到尾所需要的页面* @param memoryNum 已满的内存空间* @param page等待被调入内存的页面*/public static void OptimalChangePage(List<Integer> pageSeq,int start,List<Integer> memoryNum,int page){int maxSeq=-1,index=0;for(int pageNum:memoryNum) //遍历内存{for(int i=start;i<pageSeq.size();i++){if(pageNum==pageSeq.get(i)){if(i>maxSeq){maxSeq=i;}break;}}}if(maxSeq>-1)//maxSeq==-1说明内存当中的四个页面在将来都不会再被使用,这时默认将内存块中的第一个页面置换出{index = memoryNum.indexOf(pageSeq.get(maxSeq));//记录将要被置换的那个页面所在内存位置}memoryNum.remove(index);//将内存中将来最久被使用的页面删除memoryNum.add(index, page);//将需要调入的页面加入内存}public static void main(String[] args) {int[] order = productNumber();System.out.println("320条随机指令数:");for(int i =0;i<order.length;i++){System.out.print(order[i]+"\t");if((i+1)%10==0){System.out.println();}}List<Integer> pageSeq = pageSeq(order); //依次存放着指令所在的页面号List<Integer> memoryNum= new ArrayList<Integer>(4);//内存块存储的页面int count=0;//记录缺页次数for(int i=0;i<320;i++){int page = order[i]/10;if(memoryNum.contains(page)) //若该指令所在页面已经在内存,输出该页面所在内存块的号{}else//没在内存,发生缺页,需要判断内存块是否存满,{if(memoryNum.size()<4) //内存没满,直接将所需页面调入内存{memoryNum.add(page);}else//内存存满,需要调用页面置换算法,进行页面置换{OptimalChangePage(pageSeq,i+1,memoryNum,page);//最佳置换算法}count++;//记录缺页次数}printList(memoryNum);//打印内存所调入页面的情况}System.out.println("缺页率:"+(double)count/320);}}package mainDart;import java.util.ArrayList;import java.util.List;public class TestAPP {public static void main(String[] args) {List<Integer> list = new ArrayList<Integer>();list.add(1);list.add(3);list.add(45);System.out.println(list);list.remove(1);list.add(1, -1);System.out.println(list);}}。
实验三--请求分页存储器的管理调度算法
#include <stdio.h>#include <stdlib.h>#include <math.h>#include <time.h>#define addressnum 32FILE *fp;int exchange(int &a,int &b){int t;t=a;a=b;b=t;return 0;}int Product_Address(int (&address)[100]) {//产生含50%的随机数值在之间的地址流;//int address[addressnum]={0};int i;srand(time(NULL));for(i=0;i<addressnum;i++){if( (i%4==1) || (i%4==2) ){address[i] = rand()+1;}/*else if(i%4==2){address[i]=random(32768)+1;} */}for(i=0;i<addressnum;i++){if(i%4==0){address[i]=address[i+1]+1001;}else if(i%4==3){address[i]=address[i-1]+1001;}}return 0;printf("产生的地址流如下\n");fprintf(fp,"产生的地址流如下\n");for(i=0;i<addressnum;i++){printf("%d ",address[i]);fprintf(fp,"%d ",address[i]);}}int Translate_to_Pages(int address[100],int (&page)[100],int PageSize,int &PageNum){//把地址流根据页面大小和页面数转化为页面流int i;//int page[addressnum]={0};PageNum=32/PageSize;for(i=0;i<addressnum;i++){page[i]=(address[i])/(1024*PageSize);}printf("产生的页面流如下\n");fprintf(fp,"产生的页面流如下\n");for(i=0;i<addressnum;i++){printf("%d ",page[i]);fprintf(fp,"%d ",page[i]);}return 0;}int FIFO(int page[],int memory[],int PageNum){//先进先出页面调度算法// int memory[32]={0};int i,j,k,breaknum=0;double rate;printf("\n");for(i=0;i<addressnum;i++){for(j=0;j<PageNum;j++){if(page[i]==memory[j]){printf("o");fprintf(fp,"o");break;}}if(j==PageNum){ breaknum++;for(k=PageNum-1;k>=0;k--){memory[k]=memory[k-1];}memory[0]=page[i];printf("x");fprintf(fp,"x");}}rate=(double)breaknum/(double)addressnum;rate=1.0-rate;printf("\n");printf("本次FIFO算法命中率为%lf\n",rate);fprintf(fp,"本次FIFO算法命中率为%lf\n",rate);return 0;}int LRU (int page[],int memory[],int PageNum)//不是设的全局变量啊,为什么会改变数组值啊?{//最近最少使用淘汰算法int i,j,breaknum=0;double rate;printf("\n");/* for(i=0;i<PageNum;i++){breaknum++;printf("x");fprintf(fp,"x");}*/for(i=0;i<PageNum;i++)memory[i]=-1;for(i=0;i<addressnum;i++){for(j=0;j<PageNum;j++){if(memory[j]==page[i]){//找到内存中有所需页面exchange(memory[0],memory[j]);//始终使memory[]按使用次数排序printf("o");fprintf(fp,"o");break;}}if(j==PageNum){//内存中无现成页面,需要从虚存中调度,此时淘汰memory[]数组中最后一个元素即可memory[PageNum-1]=page[i];breaknum++;printf("x");fprintf(fp,"x");}}rate=(double)breaknum/(double)addressnum;rate=1.000-rate;printf("\n");printf("本次LRU算法命中率为%lf\n",rate);fprintf(fp,"本次LRU算法命中率为%lf\n",rate);return 0;}int Caculate_distance(int memory[],int page[],int PageNum,int breakpoint){//计算每个页面距离下次内存中再次出现的距离,并淘汰最远的一个int dismemory[32]={0};int i,j,k,distance=0,Max=0;for(i=0;i<PageNum;i++){for(j=breakpoint;j<addressnum;j++){distance++;if(page[j]==memory[i]){break;}}dismemory[i]=distance;}for(k=0;k<PageNum;k++){if(dismemory[k]>Max)Max=dismemory[k];}for(k=0;k<PageNum;k++){if(dismemory[k]==Max)break;}return k;}int OPT(int page[],int memory[],int PageNum){//最佳适配算法int i,j,breaknum=0,dis=0,breakpoint=0;double rate;for(i=0;i<PageNum;i++)memory[i]=-1;for(i=0;i<addressnum;i++){for(j=0;j<PageNum;j++){if(memory[j]==page[i])//如果该页面在内存中,则不作任何改变{printf("o");fprintf(fp,"o");break;}}if(j==PageNum){/*若该页面不在内存中,扫描内存中每个页面,计算每个页面距离下次内存中再次出现的距离,并淘汰最远的一个*/breakpoint=i;dis=Caculate_distance(memory,page,PageNum,breakpoint);memory[dis]=page[i];breaknum++;printf("x");fprintf(fp,"x");}}rate=(double)breaknum/(double)addressnum;rate=1.0-rate;printf("\n");printf("本次OPT算法命中率为%lf\n",rate);fprintf(fp,"本次OPT算法命中率为%lf\n",rate);return 0;}int main (){int i;int PageNum=0,PageSize=0;int address[100]={0},page[100]={0},memory[32]={0};for(i=0;i<32;i++) memory[i]=-1;if( ( fp=fopen("data.txt","w") )==NULL ){printf("can not open file!");}// printf("请输入地址流的数目addressnum=");// scanf("%d",&addressnum);Product_Address(address);while(1){printf("请输入页面大小PageSize=");scanf("%d",&PageSize);Translate_to_Pages(address,page,PageSize,PageNum);printf("\n本组数据的命中率比较");FIFO(page,memory,PageNum);LRU(page,memory,PageNum);OPT(page,memory,PageNum);}fclose(fp);return 0;}。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
请求分页存储管理的实现写出方案实现代码(1)page类package homework;public class Page {private int pagenumb;//页号private int physicsnumb;//物理块号private boolean state;//状态位private int visitcount;//访问字段private boolean change;//修改位private int CRTaddress;//外存地址public Page(){this.pagenumb=-1;this.physicsnumb=-1;this.state=false;this.visitcount=0;this.change=false;this.CRTaddress=-1;}public Page(int pagenumb,int physicsnumb,boolean state,int visitcount,boolean change,int CRTaddress){this.pagenumb=pagenumb;this.physicsnumb=physicsnumb;this.state=state;this.visitcount=visitcount;this.change=change;this.CRTaddress=CRTaddress;}public void setPagenumb(int pagenumb){this.pagenumb=pagenumb;}public void setPhysicsnumb(int physicsnumb){this.physicsnumb=physicsnumb;}public void setState(boolean state){this.state=state;}public void setVisitcount(int visitcount){this.visitcount=visitcount;}public void setChange(boolean change){this.change=change;}public void setCRTaddress(int CRTaddress){this.CRTaddress=CRTaddress;}public int getPagenumb(){return this.pagenumb;}public int getPhysicsnumb(){return this.physicsnumb;}public boolean getState(){return this.state;}public int getVisitcount(){return this.visitcount;}public boolean getChange(){return this.change;}public int getCRTaddress(){return this.CRTaddress;}}(2)Shell类:页表package homework;import java.util.Scanner;public class Shell {Page shell[];private int current;private int length;public Shell(){ };public Shell(int length){this.length=length;this.current=0;shell=new Page[length];for(int i=0;i<length;i++){this.shell[i]=new Page();}}public void setCurrent(int current){this.current=current;} public int getCurrent(){return this.current;}public int searchpage(int pagenumb){int i=0;if(this.current==0){return -2;}else{while(i<this.current){if(this.shell[i].getPagenumb()==pagenumb){return i;}i++;}return -1;}}public void Inchange(int b[],String ch,int number){Scanner a=new Scanner(System.in);switch(ch){case"yes":{System.out.println("请输入一个新的数据");b[this.shell[number].getPhysicsnumb()]=a.nextInt();this.shell[number].setChange(true);System.out.println("修改成功!");break;}case"no":{break;}default:{System.out.println("输入字符有误,将退出程序!!");System.exit(0);}}}public int Isover(){if(this.current>=this.length){return 1;}else return 0;}public int MinVisitcount(){int i,t=0;for(i=1;i<this.current;i++){if(this.shell[i].getVisitcount()<this.shell[t].getVisitcount()){ t=i;}}return t;}public int Ischange(int number){if(this.shell[number].getChange()==true){return 1;}else return 0;}public void printPageShell(){System.out.println("页表:");System.out.println("索引\t"+"页号\t"+"物理块号\t"+"状态\t"+"访问次数\t"+"修改\t"+"外存地址\t");for(int i=0;i<this.length;i++){System.out.println(i+"\t"+this.shell[i].getPagenumb()+"\t"+this.shell[i ].getPhysicsnumb()+"\t"+this.shell[i].getState()+"\t"+this.shell[i].getVisi tcount()+"\t"+this.shell[i].getChange()+"\t"+this.shell[i].getCRTaddress()) ;}}public void programFunction(){System.out.println("****************************请求分页存储系统****************************");System.out.println("功能:");System.out.println("\t 1.查看页表");System.out.println("\t 2.查看快表");System.out.println("\t 3.查看外存");System.out.println("\t 4.在内存修改数据");System.out.println("\t 5.继续访问页面");System.out.println("\t 6.退出程序");}public void Dealfunction(int i,KShell TLB,Source s[],int b[]){ if(i==1){this.printPageShell();}else if(i==2){TLB.printKShell();}else if(i==3){System.out.println("外存:");System.out.println("外存地址\t"+"页号\t"+"数据\n");for(int k=0;k<20;k++){s[k].printSource(k);}}else if(i==4){String ch="yes";int pageNumb;Scanner a=new Scanner(System.in);System.out.print("请输入一个页号:");pageNumb=a.nextInt();int numb=this.searchpage(pageNumb);if(numb<0){System.out.println("内存中没有此页号");}else{this.Inchange(b, ch,numb);}}else if(i==6){System.out.println("结束程序");System.exit(0);}}public static void main(String[] args){Scanner a=new Scanner(System.in);int i,number=-10,k1,k2,result;int k3=0;//当前存储的内存地址int t;//页表中访问次数最小的索引int b[]=new int[10];//内存中存储的数据String ch;int slength,plength,Tlength,data;System.out.print("请输入外存大小:");slength=a.nextInt();System.out.print("请输入页表大小:");plength=a.nextInt();System.out.print("请输入快表大小:");Tlength=a.nextInt();//定义页表,快表,外存Shell pageshell=new Shell(plength);//页表Source s[]=new Source[slength];//外存KShell TLB=new KShell(Tlength);//快表System.out.println("产生一个随机序列作为外存数据!");//录入外存地址和数据for(i=0;i<slength;i++){data=(int)(100*Math.random());System.out.print(data+"\t");s[i]=new Source(i,data);System.out.println("\n外存设置成功");//请求页面do{//TLB.printKShell();//打印当前快表的情况//pageshell.printPageShell();//打印当前页表的情况System.out.println("请输入一个页面的页号(0-19):");k1=a.nextInt();if(k1>=20||k1<0){System.out.println("输入数据有错,将退出程序!!");System.exit(0);}//检测快表,快表存储当前的页表项,即当快表满时采用最近最久未被使用算法置换快表System.out.println("进入快表检测");if(TLB.getCurrent()>0){number=TLB.searchpage(k1);if(number!=-1&&number!=-2){result=b[TLB.shell[number].getPhysicsnumb()];System.out.println("在快表中找到,结果为:"+result);//找出该页号在页表中的位置并修改访问字段number=TLB.shell[number].getIndex();pageshell.shell[number].setVisitcount(pageshell.shell[number].getVisitc ount()+1);}}if(TLB.getCurrent()<=0||number==-1){System.out.println("在快表中找不到!"+"进入内存检测:");//在快表中找不到,去内存区的页表找if(pageshell.current>0){number=pageshell.searchpage(k1);//页号k1所在的下标if(number!=-1&&number!=-2){result=b[pageshell.shell[number].getPhysicsnumb()];System.out.println("在页表中找到,结果为:"+result);//修改访问字段和状态位pageshell.shell[number].setVisitcount(pageshell.shell[number].getVisitc ount()+1);//修改快表TLB.changeKShell(pageshell, number);}if(pageshell.current<=0||number==-1){System.out.println("在内存中找不到!!");System.out.println("从外存中调入内存:");//在页表找不到,去外存区找for(i=0;i<slength;i++){if(k1==s[i].getPagenumb()){//在外存找到了缺页k2=pageshell.Isover();if(k2==1){//内存已满t=pageshell.MinVisitcount();System.out.println("内存已满!即将调出页号"+pageshell.shell[t].getPagenumb());}else{t=pageshell.current;pageshell.setCurrent(pageshell.getCurrent()+1);}//判断是否修改了内存的数据if(pageshell.Ischange(t)==1){s[pageshell.shell[t].getCRTaddress()].setSts(b[pageshell.shell[t].getPh ysicsnumb()]);}//调入内存pageshell.shell[t].setPagenumb(k1);if(k2==1){b[pageshell.shell[t].getPhysicsnumb()]=s[i].getSts();}else{pageshell.shell[t].setPhysicsnumb(k3);//未满则设置物理块号,满了只改变其他5个字段b[k3]=s[i].getSts();k3++;//物理块号}pageshell.shell[t].setState(true);pageshell.shell[t].setVisitcount(1);pageshell.shell[t].setChange(false);pageshell.shell[t].setCRTaddress(i);System.out.println("调入内存成功!");//修改快表TLB.changeKShell(pageshell,t);System.out.println("修改快表成功!");System.out.println("结果为:"+b[k3-1]);break;}}}}do{pageshell.programFunction();System.out.print("请输入一个整数(1-6):");i=a.nextInt();while(i<1||i>6){System.out.println("输入有误,请重新输入(1-6):");i=a.nextInt();}pageshell.Dealfunction(i,TLB,s,b);}while(i!=5);/*System.out.println("是否继续请求访问页面(1 or 0):");i=a.nextInt();while(i!=1&&i!=0){System.out.println("输入有误,请重新输入(1 or 0):");i=a.nextInt();}*/}while(i==5);System.out.println("退出程序!");}}(4)KShell类:快表package homework;public class KShell {KPage shell[];private int current;private int length;private int changenumb;//修改快表的次数public KShell(){ };public KShell(int length){this.length=length;this.current=0;this.changenumb=0;shell=new KPage[length];for(int i=0;i<length;i++){this.shell[i]=new KPage();}public void setCurrent(int current){this.current=current;}public void setChangenumb(int changenumb){this.changenumb=changenumb;} public int getCurrent(){ return current;}public int getChangenumb(){return changenumb;}public int getLength(){ return length;}public int searchpage(int pagenumb){int i=0;if(this.changenumb==0&&this.current==0){return -2;}else if(this.changenumb<this.length){while(i<this.current){if(this.shell[i].getPagenumb()==pagenumb){return i;}i++;}return -1;}else{while(i<this.length){if(this.shell[i].getPagenumb()==pagenumb){return i;}i++;}return -1;}}public void changeKShell(Shell pageshell,int number){if(this.getChangenumb()>=this.getLength()){if(this.getCurrent()==this.getLength()){this.setCurrent(0);}System.out.println("快表已满,快表中即将调出页号"+this.shell[this.current].getPagenumb());}if(this.getCurrent()<this.getLength()){this.shell[this.getCurrent()].setIndex(number);this.shell[this.getCurrent()].setPagenumb(pageshell.shell[number].getPa genumb());this.shell[this.getCurrent()].setPhysicsnumb(pageshell.shell[number].ge tPhysicsnumb());this.setCurrent(this.getCurrent()+1);this.setChangenumb(this.getChangenumb()+1);}}public void printKShell(){System.out.println("快表:");System.out.println("索引\t"+"页号\t"+"物理块号\t"+"在页表下的索引");for(int i=0;i<this.length;i++){System.out.println(i+"\t"+this.shell[i].getPagenumb()+"\t"+this.shell[i ].getPhysicsnumb()+"\t"+this.shell[i].getIndex());}}}(5)Source类:外存package homework;public class Source {private int pagenumb;//页号private int sts; //数据int length;public Source(){}public Source(int pagenumb,int sts){this.pagenumb=pagenumb;this.sts=sts;}public void setPagenumb(int pagenumb){this.pagenumb=pagenumb;}public void setSts(int sts){this.sts=sts;}public int getPagenumb(){return this.pagenumb;}public int getSts(){return this.sts;}public void printSource(int i){System.out.println(i+"\t"+this.pagenumb+"\t"+this.sts+"\n");}}4.用户使用说明答:本程序是使用java语言编写的实现请求分页存储管理的程序,是在eclipise下运行的结果,只需运行Shell类就行了首先先设置外存,页表和快表的大小,然后输入一个请求访问的页面。