实验五 分页式存储管理
一、实验目的
通过编写分页式存储管理的模拟程序，加深对页式存储管理方式的理解，熟悉逻辑地址到物理地址的转换过程，掌握虚拟存储管理中的页面调度算法，认识分页式虚拟存储系统中缺页中断的处理过程。
二、实验内容
1、设计一个分页式虚拟存储系统，用程序模拟实现，假设页面大小为1K，每个作业分配三个页面。
2、页面调度分别采用FIFO调度算法和最佳置换算法。（淘汰页面时直接将该页面从内存中直接淘汰，不考虑该页面是否被修改，是否需要保存到外存。）
3
4操作符 页号1 页内地址1 页号2 页内地址2 表示将页面1内地址为011单元的
内容和页面2中地址为051的单元的内容相加。例如：
5面调度算法，淘汰之前内存中相应页,然后该页放进内存。
6、要求每执行上述指令流中的一条逻辑指令，输出相应的物理指令，若页表有修改，则显示修改后的页表。
这次试验是用Java 写的。
首先，在页表类中，该类定义为：
Page.java:
package 操作系统;
public class Page {
private int pageNo; //表示页号码
private int mark; //表示标志
private int blockNo; //表示主存块号
public Page(int pageNo, int mark, int blockNo) {
super();
this.pageNo = pageNo;
this.mark
this.blockNo = blockNo;
}
public int getPageNo() {
return pageNo;
}
public void setPageNo(int pageNo) {
this.pageNo = pageNo;
}
public int getMark() {
return mark;
}
public void setMark(int mark) {
this.mark = mark;
}
public int getBlockNo() {
return blockNo;
}
public void setBlockNo(int blockNo) {
this.blockNo = blockNo;
}
}
其次，我将操作指令封装成一个类，该类为：
Command.java:
package 操作系统;
public class Command {
private static int fifoindex=0; //下面有解释
private static int optimalIndex = 0; //跟上面 一个一样 private int pageNo; //表示页号
private String pageAdd; //表示业内地址
public Command() {
}
public Command(int pageNo, String pageAdd) {
super();
this.pageNo = pageNo;
this.pageAdd = pageAdd;
}
public int getPageNo() {
return pageNo;
}
public void setPageNo(int pageNo) {
this.pageNo = pageNo;
}
public String getPageAdd() {
return pageAdd;
}
public void setPageAdd(String pageAdd) {
this.pageAdd = pageAdd;
}
前面部分就是设置与获取操作指令中的私有属性。
下半部分分别是Fifo算法和最优置换算法。
//该函数用来判断指令中的页号是否在主存当中
boolean isInMain(Page page[] ,Command first) {
if(page[first.getPageNo()].getMark() == 1) {
return true;
}
return false;
}
//用来输出当前主存中的页表
void printPage(Page page[] ,Command first,Command
second,String oper) {
System.out.println("当前主存的页表为：");
System.out.println("页号 " + " 标志 " + " 主存块号" );
for(int i=0;i
System.out.print(" " + page[i].getPageNo()); System.out.print(" " + page[i].getMark());
System.out.println(" " + page[i].getBlockNo()); }
System.out.println();
System.out.println("当前的物理指令为："
+ oper + " " + first.getPageNo() + " " + first.getPageAdd() + " " + second.getPageNo() + " " +
second.getPageAdd());
}
//用来表示输出结果
void print(Command first, String oper,Command second ,Page page[]) {
int index1 = 0,index2 = 0;
for(int i=0;i
if(first.getPageNo() == page[i].getPageNo()) { index1 = i;
}
if(second.getPageNo() == page[i].getPageNo()) { index2 = i;
}
}
if(oper.equals("读")) {
System.out.println("(" + page[index1].getBlockNo() + first.getPageAdd() + ")" + "(" +
page[index2].getBlockNo() +second.getPageAdd() + ")" );
}else {
System.out.println("(" + page[index1].getBlockNo() + first.getPageAdd() + ")" + (String)oper + "(" + page[index2].getBlockNo() +second.getPageAdd() + ")" );
}
}
//该函数是将在外存的页号调入主存中
void fifoChangeLocation(Page page[] ,Command first) {
/*如果不在主存当中，那么最最最最最最最最最最最最起初当然是删除第一个，
* 然后把该页号送进这块主存的地方，然后fifoindex递增一次，当到达最后一个时候要返回第一个，
* 所以要设置循环，所以fifoindex= fifoindex%3
*/
page[fifoindex].setMark(0);
page[fifoindex].setPageNo(first.getPageNo());
fifoindex++;
fifoindex = fifoindex % 3;
}
//FIFO算法
void fifoOperate(String oper, Command first, Command second, Page page[] )
{
//首先进来对两个页号进行判断，看其是否在主存之中.如果不在主存块中，那么根据先进先出原则，把
if(!isInMain(page,first)) {
//如果不在内存中，实行调换
fifoChangeLocation(page,first);
}
if(!isInMain(page,second)) {
fifoChangeLocation(page,second);
}
printPage(page,first,second,oper);
print(first,oper,second,page);
System.out.println();
}
//y用来判断主存中三个页号最晚出现的页号
int min(int a,int b,int c) {
int min = a;
if(min
min = b;
if(min
min = c;
}
}
return min;
}
//最优置换算法将外存的页号调入内存
//用来进行调换外存页号与要被替换的主存页号
void optimalChangeLocation(Page page[],Command
character[],Command first ) {
int firstNum = -1; //用来记录外存中
int secondNum = -1;
int thirtNum = -1;
for(int i=0;i
if(page[0].getPageNo() == character[i].getPageNo()) { firstNum = i;
}
if(page[1].getPageNo() == character[i].getPageNo()) { secondNum = i;
}
if(page[2].getPageNo() == character[i].getPageNo()) { thirtNum = i;
}
//这边我只在乎谁最后一个出现
if(firstNum != -1 && secondNum != -1 && thirtNum != -1) {
break;
}
}
int = min(firstNum,secondNum,thirtNum);
page[optimalIndex].setMark(0);
page[optimalIndex].setPageNo(first.getPageNo());
optimalIndex++;
optimalIndex = optimalIndex % 3;
}
//最优置换算法操作
void optimalOperate(Command character[],Page page[],String oper, Command first,Command second) {
if(!isInMain(page,first)) {
optimalChangeLocation(page,character,first);
}
if(!isInMain(page,second)) {
optimalChangeLocation(page,character,second);
}
printPage(page,first,second,oper);
print(first,oper,second,page);
System.out.println();
}
}
在主函数中：
即在TestMain.java:
package 操作系统;
public class TestMain {
public static void main(String[] args) {
//首先对页表进行初始化
Page A = new Page(0,1,3);
Page B = new Page(1,1,4);
Page C = new Page(2,1,5);
Page D = new Page(3,0,0);
Page E = new Page(4,0,0);
Page F = new Page(5,0,0);
Page page[] = {A,B,C,D,E,F};
//然后再植入指令序列
Command a = new Command(0, "030");
Command b = new Command(2, "003");
Command c = new Command(1, "050");
Command d = new Command(2, "005");
Command e = new Command(2, "001");
Command f = new Command(5, "004");
Command g = new Command(3, "007");
Command h = new Command(1, "031");
Command i = new Command(4, "034");
Command j = new Command(3, "025");
Command character[] = {a,b,c,d,e,f,g,h,i,j};
Command operate = new Command();
operate.fifoOperate("+", a, b, page);
operate.fifoOperate("-", c, d, page);
operate.fifoOperate("*", e, f, page);
operate.fifoOperate("/", g, h, page);
operate.fifoOperate("读", i, j, page);
//（3030 + 5003 4050-5005 5001*3004 4007/5031 3034 读 4025）
System.out.println("最优置换算法输出结果：");
operate.optimalOperate(character,page,"+", a, b); operate.optimalOperate(character,page,"-", c, d); operate.optimalOperate(character,page,"*", e, f); operate.optimalOperate(character,page,"/", g, h); operate.optimalOperate(character,page,"读", i, j); }
}
最后的实验结果：
实验五 分页式存储管理
一、实验目的
通过编写分页式存储管理的模拟程序，加深对页式存储管理方式的理解，熟悉逻辑地址到物理地址的转换过程，掌握虚拟存储管理中的页面调度算法，认识分页式虚拟存储系统中缺页中断的处理过程。
二、实验内容
1、设计一个分页式虚拟存储系统，用程序模拟实现，假设页面大小为1K，每个作业分配三个页面。
2、页面调度分别采用FIFO调度算法和最佳置换算法。（淘汰页面时直接将该页面从内存中直接淘汰，不考虑该页面是否被修改，是否需要保存到外存。）
3
4操作符 页号1 页内地址1 页号2 页内地址2 表示将页面1内地址为011单元的
内容和页面2中地址为051的单元的内容相加。例如：
5面调度算法，淘汰之前内存中相应页,然后该页放进内存。
6、要求每执行上述指令流中的一条逻辑指令，输出相应的物理指令，若页表有修改，则显示修改后的页表。
这次试验是用Java 写的。
首先，在页表类中，该类定义为：
Page.java:
package 操作系统;
public class Page {
private int pageNo; //表示页号码
private int mark; //表示标志
private int blockNo; //表示主存块号
public Page(int pageNo, int mark, int blockNo) {
super();
this.pageNo = pageNo;
this.mark
this.blockNo = blockNo;
}
public int getPageNo() {
return pageNo;
}
public void setPageNo(int pageNo) {
this.pageNo = pageNo;
}
public int getMark() {
return mark;
}
public void setMark(int mark) {
this.mark = mark;
}
public int getBlockNo() {
return blockNo;
}
public void setBlockNo(int blockNo) {
this.blockNo = blockNo;
}
}
其次，我将操作指令封装成一个类，该类为：
Command.java:
package 操作系统;
public class Command {
private static int fifoindex=0; //下面有解释
private static int optimalIndex = 0; //跟上面 一个一样 private int pageNo; //表示页号
private String pageAdd; //表示业内地址
public Command() {
}
public Command(int pageNo, String pageAdd) {
super();
this.pageNo = pageNo;
this.pageAdd = pageAdd;
}
public int getPageNo() {
return pageNo;
}
public void setPageNo(int pageNo) {
this.pageNo = pageNo;
}
public String getPageAdd() {
return pageAdd;
}
public void setPageAdd(String pageAdd) {
this.pageAdd = pageAdd;
}
前面部分就是设置与获取操作指令中的私有属性。
下半部分分别是Fifo算法和最优置换算法。
//该函数用来判断指令中的页号是否在主存当中
boolean isInMain(Page page[] ,Command first) {
if(page[first.getPageNo()].getMark() == 1) {
return true;
}
return false;
}
//用来输出当前主存中的页表
void printPage(Page page[] ,Command first,Command
second,String oper) {
System.out.println("当前主存的页表为：");
System.out.println("页号 " + " 标志 " + " 主存块号" );
for(int i=0;i
System.out.print(" " + page[i].getPageNo()); System.out.print(" " + page[i].getMark());
System.out.println(" " + page[i].getBlockNo()); }
System.out.println();
System.out.println("当前的物理指令为："
+ oper + " " + first.getPageNo() + " " + first.getPageAdd() + " " + second.getPageNo() + " " +
second.getPageAdd());
}
//用来表示输出结果
void print(Command first, String oper,Command second ,Page page[]) {
int index1 = 0,index2 = 0;
for(int i=0;i
if(first.getPageNo() == page[i].getPageNo()) { index1 = i;
}
if(second.getPageNo() == page[i].getPageNo()) { index2 = i;
}
}
if(oper.equals("读")) {
System.out.println("(" + page[index1].getBlockNo() + first.getPageAdd() + ")" + "(" +
page[index2].getBlockNo() +second.getPageAdd() + ")" );
}else {
System.out.println("(" + page[index1].getBlockNo() + first.getPageAdd() + ")" + (String)oper + "(" + page[index2].getBlockNo() +second.getPageAdd() + ")" );
}
}
//该函数是将在外存的页号调入主存中
void fifoChangeLocation(Page page[] ,Command first) {
/*如果不在主存当中，那么最最最最最最最最最最最最起初当然是删除第一个，
* 然后把该页号送进这块主存的地方，然后fifoindex递增一次，当到达最后一个时候要返回第一个，
* 所以要设置循环，所以fifoindex= fifoindex%3
*/
page[fifoindex].setMark(0);
page[fifoindex].setPageNo(first.getPageNo());
fifoindex++;
fifoindex = fifoindex % 3;
}
//FIFO算法
void fifoOperate(String oper, Command first, Command second, Page page[] )
{
//首先进来对两个页号进行判断，看其是否在主存之中.如果不在主存块中，那么根据先进先出原则，把
if(!isInMain(page,first)) {
//如果不在内存中，实行调换
fifoChangeLocation(page,first);
}
if(!isInMain(page,second)) {
fifoChangeLocation(page,second);
}
printPage(page,first,second,oper);
print(first,oper,second,page);
System.out.println();
}
//y用来判断主存中三个页号最晚出现的页号
int min(int a,int b,int c) {
int min = a;
if(min
min = b;
if(min
min = c;
}
}
return min;
}
//最优置换算法将外存的页号调入内存
//用来进行调换外存页号与要被替换的主存页号
void optimalChangeLocation(Page page[],Command
character[],Command first ) {
int firstNum = -1; //用来记录外存中
int secondNum = -1;
int thirtNum = -1;
for(int i=0;i
if(page[0].getPageNo() == character[i].getPageNo()) { firstNum = i;
}
if(page[1].getPageNo() == character[i].getPageNo()) { secondNum = i;
}
if(page[2].getPageNo() == character[i].getPageNo()) { thirtNum = i;
}
//这边我只在乎谁最后一个出现
if(firstNum != -1 && secondNum != -1 && thirtNum != -1) {
break;
}
}
int = min(firstNum,secondNum,thirtNum);
page[optimalIndex].setMark(0);
page[optimalIndex].setPageNo(first.getPageNo());
optimalIndex++;
optimalIndex = optimalIndex % 3;
}
//最优置换算法操作
void optimalOperate(Command character[],Page page[],String oper, Command first,Command second) {
if(!isInMain(page,first)) {
optimalChangeLocation(page,character,first);
}
if(!isInMain(page,second)) {
optimalChangeLocation(page,character,second);
}
printPage(page,first,second,oper);
print(first,oper,second,page);
System.out.println();
}
}
在主函数中：
即在TestMain.java:
package 操作系统;
public class TestMain {
public static void main(String[] args) {
//首先对页表进行初始化
Page A = new Page(0,1,3);
Page B = new Page(1,1,4);
Page C = new Page(2,1,5);
Page D = new Page(3,0,0);
Page E = new Page(4,0,0);
Page F = new Page(5,0,0);
Page page[] = {A,B,C,D,E,F};
//然后再植入指令序列
Command a = new Command(0, "030");
Command b = new Command(2, "003");
Command c = new Command(1, "050");
Command d = new Command(2, "005");
Command e = new Command(2, "001");
Command f = new Command(5, "004");
Command g = new Command(3, "007");
Command h = new Command(1, "031");
Command i = new Command(4, "034");
Command j = new Command(3, "025");
Command character[] = {a,b,c,d,e,f,g,h,i,j};
Command operate = new Command();
operate.fifoOperate("+", a, b, page);
operate.fifoOperate("-", c, d, page);
operate.fifoOperate("*", e, f, page);
operate.fifoOperate("/", g, h, page);
operate.fifoOperate("读", i, j, page);
//（3030 + 5003 4050-5005 5001*3004 4007/5031 3034 读 4025）
System.out.println("最优置换算法输出结果：");
operate.optimalOperate(character,page,"+", a, b); operate.optimalOperate(character,page,"-", c, d); operate.optimalOperate(character,page,"*", e, f); operate.optimalOperate(character,page,"/", g, h); operate.optimalOperate(character,page,"读", i, j); }
}
最后的实验结果：