在一页式存储管理系统中，某作业页表如下。
 
已知页面大小为 1024 字节，问逻辑地址1068，2566，5699 所对应的物理地址各是多少？如果需要置换一页，应该选择哪一页？置换后所对应的物理地址是多少？
 
 
物理地址=帧号×页面大小+页内偏移
 
帧号=逻辑地址/页面大小的商作为页号对应的帧号
 
业内偏移=逻辑地址/页面大小的余
 
1) 1068 位于 1#页，页内偏移 44，物理地址 3×1024＋44＝3116  
 
2) 2566 位于 2#页，页内偏移 518，但此页不在内存，所以产生缺页中断。置换时应该选择 3#页。置换后 2566 对应的物理地址是 1×1024＋518＝1542 
 
3) 5699 位于 5#页，页内偏移 579，物理地址 2×1024＋579＝2627

转载地址：http://blog.csdn.net/seawaywjd/article/details/7435190
 
 
 
 
1、段式和页式存储管理的地址结构很类似，但是它们有实质上的不同，以下错误的是（D） 
 
 
     A．页式的逻辑地址是连续的，段式的逻辑地址可以不连续 
 
 
     B．页式的地址是一维的，段式的地址是二维的 
 
 
     C．分页是操作系统进行的，分段是用户确定的 
 
 
     D．页式采用静态重定位方式，段式采用动态重定位方式 
 
 
2、在以下的存储管理方案中，能扩充主存容量的是（D） 
 　 A． 固定式分区分配              　　 B． 可变式分区分配 
 　 C． 页式存储管理                　　 D． 分页虚拟存储管理
 
 
3、段页式管理中，地址映像表是（C）
 
 
      A．每个进程一张段表，一张页表         B．进程的每个段一张段表，一张页表 
 
 
      C．每个进程一张段表，每个段一张页表   D．每个进程一张页表，每个段一张段表  
 
 
4、一段页式存储器，地址结构如下所示
 
 
     23                            10 9           0
 
  
 
 
段号
 
页号
页内偏移
 
 
 该存储器最多容许
 16
 个段，请填写每个部分的含义，计算每一段所容纳的页数和最大长度。
 
  
 
每一段可以包含210=1024页，最大长度为210*1K=1M
 
 
5、采用 ( B ) 不会产生内部碎片。
 
 
A．分页式存储管理          B．分段式存储管理
 
 
C．固定分区式存储管理      D．段页式存储管理
 
 
6．离散存储管理的主要特点是 ( A) 。
 
 
A．不要求将作业装入到内存的连续区域    
 
 
B．不要求将作业同时全部装入到内存的连续区域
 
 
C．不要求进行缺页中断处理         D．不要求进行页面置换  
 
 
7、可变式分区又称为动态分区，它是在系统运行过程中（B）时动态建立的。
 
 
      A．在作业装入  B．在作业创建   C．在作业完成   D．在作业未装入
 
 
8、计算机系统的二级存储包括（D）
 
 
      A．CPU寄存器和主存缓冲区   B．超高速缓存和内存储器
 
 
      C．ROM和RAM             D．主存储器和辅助存储器
 
 
9、某页式存储管理系统中，地址寄存器长度为24位，其中页号占14位，则主存的分块大小是（A）字节 
 
 
       A．210   B．10    C．214    D．224
 
 
10、作业在执行中发生了缺页中断，经OS处理后，应让其执行（B）指令。
 
 
A．被中断的前一条    B．被中断的那一条  
 
 
 C．被中断的后一条   D．启动时的第一条
 
 
11、分页式虚拟存储管理系统中，页面的大小与可能产生的缺页中断次数（B）。
 
 
       A．成正比   B．成反比    C．无关    D．成固定值
 
 
12、某虚拟存储器中的用户空间共有32个页面，每页1KB，主存16KB。假定某时候系统为用户的第0、1、2、3页分别分配的物理块号为5、10、4、7，虚拟地址0A6F对应的物理地址是（126F）。 
 
 
13、覆盖和对换都需要从外存读入信息，所以覆盖是对换的别名。（错误）
 
 
14、在某页式虚拟系统中，假定访问内存的时间是10ms，平均缺页中断处理为 25 ms，平均缺页中断率为5%，试计算在该虚拟系统中，平均有效访问时间是多少？ 
 
 
在内存：10 ms+10 ms=20 ms
 
 
不在内存：10 ms+25 ms+10 ms+10 ms =55 ms
 
 
20 msX（1-5%）+55 msX5%=21.75 ms 
 
 
15、在请求分页系统中，假设某进程页表如下：
 
 
 
页号
 
 
页框号
 
 
存在位
 
0
 
101H
 
1
1
——
0
2
 
254H
 
1
 
 
 页面大小
 4K
 ，一次访问内存时间
 100ns
 ，一次访问快表（
 TLB
 ）的时间为
 10 ns
 ，处理一次缺页平均花费
 108 ns
 （含更新
 TLB
 和页表时间），进程的驻留集大小固定为
 2
 ，采用
 LRU
 和局部置换。假设（
 1
 ）
 TLB
 初始为空 （
 2
 ）地址转换时先访问
 TLB
 ，若不中，再访问页表（忽略之后
 TLB
 更新时间）（
 3
 ）存在位为
 0
 表示不在内存，产生缺页中断，中断后回到产生中断的指令执行。设有地址访问序列
 2362H
 ，
 1565H
 ，
 25A5H
 。问
 
 
 
（1） 访问上述3个地址，分别需要多长时间。
 
 
（2） 基于上述访问序列，1565H的物理地址是多少？
 
 
解答：（1）页面大小4K，在逻辑地址中是后12位。2362H和25A5H页号为2，1565H页号为1，
 
 
访问2362H的时间=10 ns（访问TLB）+100 ns（访问页表）+ 100 ns（访问内存单元）
 
 
=210 ns
 
 
访问1565H，发生缺页中断，返回后需要再次访问TLB
 
 
访问1565H的时间=10 ns（访问TLB）+100 ns（访问页表）+ 100000000 ns （缺页中断）+10 ns （访问TLB）+100 ns（访问内存单元）=1100000220 ns
 
 
访问 25A5H的时间=10 ns（访问TLB）+100 ns（访问内存）=110 ns 因为此次TLB命中
 
 
（2） 根据LRU算法，访问1565H的时候，1号页要替换掉0号页，所以对应101H页框
 
 
所以1565H的物理地址是101565H
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

 

首先我们来看下题目
 
假定某采用页式存储管理系统中，主存容量为lMB,被分成256块,块号为0, 1, 2, …
 255。现有一个共4页(页号为0，1, 2，3)的作业被依次装入到主存的第2，4，1，5
 块中。请回答:
 (1)主存地址应该用多少位来表示?
 (2)作业每一页的长度为多少字节?逻辑地址中的页内地址部分应占用多少位?
 (3)画出页表并给出作业中每–页占用的主存块起始地址。
 (4)若作业执行中要从第0页的第75单元和第3页的第548单元读信息，那么，实际
 应从主存的哪两个单元读信息?请把应访问的主存绝对地址用十六进制数表示。
 
解答过程（只针对第四小问的详细解答）：
 
此问题就是求解用十六进制表示出主存的绝对地址，即表示物理地址，附上手写过程：
 
 希望对你有所帮助！

使用FIFO算法和LRU算法模拟虚拟页式存储管理
 
#include<stdio.h> 
#include<string.h> 
#include<iostream>
using namespace std; 
const int MAXSIZE=1000;//定义最大页面数 
const int NUM=3;//定义页框数（物理块数）

typedef struct node{ 
	int loaded;   //记录该物理块存储的页面
	int time;     //记录该物理块没有被使用的时间
}page;

page pages[NUM]; //定义页框表 （物理块表）
int queue[MAXSIZE]; 
int quantity;

//初始化结构函数 
void initial(){ 
	int i; 
	for(i=0;i<NUM;i++){ 
		pages[i].loaded=-1; 
	} 
	for(i=0;i<MAXSIZE;i++){ 
		queue[i]=-1;
	} 
	quantity=0;
}

//读入页面流
void readData(){ 
	FILE *fp; 
	char fname[20];
	int i;
	cout<<"请输入页面流文件名:"; 
	cin>>fname;
	if((fp=fopen(fname,"r"))==NULL){ 
		cout<<"错误,文件打不开,请检查文件名"; 
	}else{ 
		while(!feof(fp)){ 
			fscanf(fp,"%d ",&queue[quantity]);
			quantity++; 
		} 
	} 
	cout<<"读入的页面流:"; 
	for(i=0;i<quantity;i++){
		cout<<queue[i]<<" ";
	} 
}

//FIFO调度算法
void FIFO() { 
	int i,j,p,flag;
	int absence=0;  //记录缺页次数
	p=0;
	cout<<endl<<"----------------------------------------------------"<<endl; 
	cout<<"先进先出调度算法(FIFO)页面调出流:"; 
	
	for(i=0;i<NUM;i++){  //前3个进入内存的页面
		int flag_f = 0;					//记录内存中是否存在页面 
		for(int j = 0; j < NUM; j++){			//执行检查操作 
			if(queue[i] == pages[j].loaded){			//如果内存中存在该页面 
				flag_f = 1;				//记录 
				break;							//跳出检查操作 
			}else{
				continue;						//否则继续检查 
			}
		}
		if(flag_f){				//如果内存中存在该页面，进入下一个页面 
			continue;
		}
		pages[p].loaded=queue[i];
		cout<<pages[p].loaded<<" ";			//前三个"缺页"输出 
		p=(p+1)%NUM;					//循环增1 	
	}
	if(p == 0){
		absence = 3;
	}else if(p == 2){
		absence = 2;
	}else if(p == 1){
		absence = 1; 
	}
	
	for(i=NUM;i<quantity;i++){ 
		flag=0; 
		for(j=0;j<NUM;j++){  //判断当前需求的页面是否在内存 
			if(pages[j].loaded==queue[i])	
				flag=1;  
		} 
		if(flag==0){ 
			if(pages[p].loaded == -1){				//如果内存中存在空位 
				cout << queue[i] << " ";
				pages[p].loaded = queue[i];
				p=(p + 1) % NUM;
				absence++;
			}else{ 								//内存中不存在空位，需要进行替换 
				cout<<pages[p].loaded<<" ";
				pages[p].loaded=queue[i]; 
				p=(p+1)%NUM; 
				absence++; 
			}
			
		}
	} 
	cout<<endl<<"总缺页数:"<<absence<<endl; 
}

//最近最少使用调度算法（LRU）
void LRU(){ 
	
	//请补充LRU算法的代码
	int i,j,k,p,flag;
	int absence=0;  //记录缺页次数
	p=0;
	cout<<endl<<"----------------------------------------------------"<<endl; 
	cout<<"最近最少使用调度算法（LRU）页面调出流:"; 
	for(i=0;i<NUM;i++){  //前3个进入内存的页面
		int flag_l = 0;						//记录内存中是否存在页面 
		for(j = 0; j < NUM; j++){			//检查 
			if(queue[i] == pages[j].loaded){
				flag_l = 1;
				pages[j].time = 0;
				break;
			}else{
				continue;
			}
		}
		if(flag_l){
			continue;
		}
		pages[p].loaded=queue[i];			//进入页面 
		cout<<pages[p].loaded<<" ";			//输出缺页 
		for(j=0;j<=p;j++){
			pages[j].time++;				//闲置时间增加 
		}
		p=(p+1)%NUM;		//循环增1 
	}
	if(p == 0){
		absence = 3;
	}else if(p == 2){
		absence = 2;
		pages[2].time = 4;				//上调空页面的替换优先级 
	}else if(p == 1){
		absence = 1;
		pages[1].time = 4;				//上调优先级 
		pages[2].time = 3;				//上调优先级 
	}
 
	for(i=NUM;i<quantity;i++){
		flag=0;
		for(j=0;j<NUM;j++){  //判断当前需求的页面是否在内存
			pages[j].time++;
			if(pages[j].loaded==queue[i]){		//如果存在内存中 
				flag=1; 
				pages[j].time=0;				//闲置时间置零 
			}
		}
		if(flag==0){ 					//如果不在内存中 
			int max=0;
			for(k=1;k<NUM;k++){			//比较闲置时间大小 
				if(pages[max].time<pages[k].time){ 
					max=k;
				} 
			}
			if(pages[max].loaded == -1){				//如果内存中存在空位 
				cout << queue[i] << " ";
				pages[max].loaded = queue[i];
				pages[max].time = 0;
				absence++;
			}else{
				cout<<pages[max].loaded<<" ";			//输出被替换掉的页面 
				pages[max].loaded=queue[i]; 			//替换页面 
				pages[max].time=0;						//最近被使用 
				absence++; 								//缺页数增加 
			}
		}
	}
	cout<<endl<<"总缺页数:"<<absence<<endl;
}


int main(){ 
	cout<<"     /**********虚拟存储管理器的页面调度**************/"<<endl;
	initial();
	readData();
	//FIFO();   
	LRU();
	return 0;
}