H5W3
当前位置:H5W3 > 其他技术问题 > 正文

操作系统- 虚拟内存页面置换算法-详细设计附源码

一、需求分析

1、程序设计的任务和目的

通过这次实验,加深对虚拟内存页面置换概念的理解,进一步掌握先进先出FIFO、最佳置换OPI和最近最久未使用LRU页面置换算法的实现方法。

2、输入的形式和输入值的范围

最小物理块数m,页面个数n,页面访问序列P1, … ,Pn,算法选择1-FIFO,2-OPI,3-LRU。

3、输出的形式

每种算法的缺页次数和缺页率。

4、程序所能达到的功能

设计程序模拟先进先出FIFO、最佳置换OPI和最近最久未使用LRU页面置换算法的工作过程。假设内存中分配给每个进程的最小物理块数为m,在进程运行过程中要访问的页面个数为n,页面访问序列为P1, … ,Pn,分别利用不同的页面置换算法调度进程的页面访问序列,给出页面访问序列的置换过程,计算每种算法缺页次数和缺页率。

5、测试数据,包括正确的输入及其输出结果和含有错误的输入及其输出结果

正确用例

输入

请输入最小物理块数MinBlockNum:4
请输入页面个数PageNum:12
请输入页面1编号PageOrder[1]:4
请输入页面2编号PageOrder[2]:3
请输入页面3编号PageOrder[3]:2
请输入页面4编号PageOrder[4]:1
请输入页面5编号PageOrder[5]:4
请输入页面6编号PageOrder[6]:3
请输入页面7编号PageOrder[7]:5
请输入页面8编号PageOrder[8]:4
请输入页面9编号PageOrder[9]:3
请输入页面10编号PageOrder[10]:2
请输入页面11编号PageOrder[11]:1
请输入页面12编号PageOrder[12]:5
请选择想要先使用的算法( 1-先进先出(FIFO)页面置换算法,2-最佳(OPI)页面置换算法,3-最近最久未使用(LRU)页面置换算法 ):1
 

输出

请选择想要先使用的算法( 1-先进先出(FIFO)页面置换算法,2-最佳(OPI)页面置换算法,3-最近最久未使用(LRU)页面置换算法 ):1
您选择的是1-先进先出(FIFO)页面置换算法
页面7换掉第1物理块中的页面
页面8换掉第2物理块中的页面
页面9换掉第3物理块中的页面
页面10换掉第4物理块中的页面
页面11换掉第1物理块中的页面
页面12换掉第2物理块中的页面
页面置换算法模拟过程如下:
Page 1    Page 2    Page 3    Page 4    Page 5    Page 6    Page 7    Page 8    Page 9    Page10    Page11    Page12
BlockNum 1         4         4         4         4         4         4         5         5         5         5         1         1
BlockNum 2                   3         3         3         3         3         3         4         4         4         4         5
BlockNum 3                             2         2         2         2         2         2         3         3         3         3
BlockNum 4                                       1         1         1         1         1         1         2         2         2
页面置换算法缺页次数为:10
页面置换算法缺页率为:83%
 

错误用例(输入中带有0页面,该页面号设置为状态量)

输入

请输入最小物理块数MinBlockNum:4
请输入页面个数PageNum:12
请输入页面1编号PageOrder[1]:4
请输入页面2编号PageOrder[2]:3
请输入页面3编号PageOrder[3]:2
请输入页面4编号PageOrder[4]:1
请输入页面5编号PageOrder[5]:4
请输入页面6编号PageOrder[6]:0
请输入页面7编号PageOrder[7]:5
请输入页面8编号PageOrder[8]:4
请输入页面9编号PageOrder[9]:0
请输入页面10编号PageOrder[10]:
2
请输入页面11编号PageOrder[11]:1
请输入页面12编号PageOrder[12]:0
请选择想要先使用的算法( 1-先进先出(FIFO)页面置换算法,2-最佳(OPI)页面置换算法,3-最近最久未使用(LRU)页面置换算法 ):2
 

输出

您选择的是2-最佳(OPI)页面置换算法
页面6于最远距离100换掉第2物理块中的页面
页面9于最远距离100换掉第1物理块中的页面
页面12于最远距离0换掉第0物理块中的页面
页面置换算法模拟过程如下:
Page 1    Page 2    Page 3    Page 4    Page 5    Page 6    Page 7    Page 8    Page 9    Page10    Page11    Page12
BlockNum 1         4         4         4         4         4         4         4         4                   2         2         2
BlockNum 2                   3         3         3         3                   5         5         5         5         5         5
BlockNum 3                             2         2         2         2         2         2         2         2         2         2
BlockNum 4                                       1         1         1         1         1         1         1         1         1
页面置换算法缺页次数为:9
页面置换算法缺页率为:75%
 

二、概要设计

1、抽象数据类型的定义

int PageOrder[MaxNumber];//页面序列
int Simulate[MaxNumber][MaxNumber];//模拟过程
int PageNum;//页面数
int MinBlockNum;//最小物理块数
int LackNum;//缺页数
double LackPageRate;//缺页率
bool found;
int isAlgorithm;//算法选择
 

2、主程序的流程

int main() {
virtualMemoryPageReplacementAlgorithm virtualMemoryPageReplacementAlgorithm{};
virtualMemoryPageReplacementAlgorithm.Input();
return 0;
}
 

3、各程序模块之间的层次(调用)关系

int main() {
virtualMemoryPageReplacementAlgorithm virtualMemoryPageReplacementAlgorithm{};
virtualMemoryPageReplacementAlgorithm.Input();
return 0;
}
//输入函数调用InputAlgorithm函数选择输入函数
void Input() {
···
InputAlgorithm();
}
//调用IsAlgorithm函数进行算法存储确认
void InputAlgorithm() {
···
IsAlgorithm();
}
//算法确认后按照确认结果调用不同算法函数,若确认失败,要求重新输入
void IsAlgorithm() {
···
switch (isAlgorithm) {
case 1:
AlgorithmFIFO();
case 2:
AlgorithmOPI();
case 3:
AlgorithmLRU();
default:
InputAlgorithm();
}
}
//算法函数仅以FIFO为例,在完成算法处理后调用Print函数输出本算法运算结果,并调用NextAlgorithm函数询问下一算法使用
void AlgorithmFIFO() {
···
Print();
NextAlgorithm();
}
//询问后续,若有则重新调用算法确认函数循环流程,若触发终止条件结束进程
void NextAlgorithm() {
···
IsAlgorithm();
}
 

三、详细设计

实现程序模块的具体算法

1、先进先出(FIFO)页面置换算法

//调用先进先出(FIFO)页面置换算法进行调度计算
void AlgorithmFIFO() {
//初始化缺页次数
LackNum = 0;
//定义队列指针,指向下一个换出的页面
int pointer = 0;
for (int i = 1; i <= PageNum; i++) {
//初始化found
found = false;
//如果是第一个页面,直接添加页面进Simulate[1][i],缺页数+1
if (i == 1) {
···
continue;
}
for (int j = 1; j <= MinBlockNum; j++) {
//判断是否在物理块中,若存在,则此页面未缺页
if (Simulate[j][i - 1] == PageOrder[i]) {
···
break;
}
//若缺页且有空物理块,则不置换,直接填入
if (Simulate[j][i - 1] == 0) {
···
break;
}
}
//若正常缺页,进行置换且输出置换步骤
if (!found) {
···
}
}
LackPageRate = (double) LackNum / (double) PageNum;
Print();
NextAlgorithm();
}
 

2、最佳(OPI)页面置换算法

//调用最佳(OPI)页面置换算法进行调度计算
void AlgorithmOPI() {
//初始化缺页次数
LackNum = 0;
for (int i = 1; i <= PageNum; i++) {
//初始化found
found = false;
//初始化队列指针,指向下一个换出的页面
int pointer = 0;
//初始化最远距离
int distance = 0;
//如果是第一个页面,直接添加页面,缺页数+1
if (i == 1) {
···
continue;
}
for (int j = 1; j <= MinBlockNum; j++) {
//判断是否在物理块中,若存在,则此页面未缺页
···
break;
}
//若缺页且有空物理块,则不置换,直接填入
if (Simulate[j][i - 1] == 0) {
···
break;
}
}
if (!found) {
for (int j = 1; j <= MinBlockNum; j++) {
Simulate[j][i] = Simulate[j][i - 1];
//寻找最优置换位
for (int k = i + 1; k <= PageNum; k++) {
if (Simulate[j][i] == PageOrder[k]) {
if (k - i > distance) {
distance = k - i;
pointer = j;
}
break;
}
//判断页列表中无此需求,直接将此页面作为替换页面
if (k == PageNum && distance < MaxNumber) {
distance = MaxNumber;
pointer = j;
}
}
}
···
}
}
LackPageRate = (double) LackNum / (double) PageNum;
Print();
NextAlgorithm();
}
 

3、最近最久未使用(LRU)页面置换算法

//调用最近最久未使用(LRU)页面置换算法进行调度计算
void AlgorithmLRU() {
//初始化缺页次数
LackNum = 0;
for (int i = 1; i <= PageNum; i++) {
//初始化found
found = false;
//初始化队列指针,指向下一个换出的页面
int pointer = 0;
//初始化最远距离
int distance = 0;
//如果是第一个页面,直接添加页面,缺页数+1
if (i == 1) {
···
continue;
}
for (int j = 1; j <= MinBlockNum; j++) {
//判断是否在物理块中,若存在,则此页面未缺页
···
break;
}
//若缺页且有空物理块,则不置换,直接填入
if (Simulate[j][i - 1] == 0) {
···
break;
}
}
if (!found) {
for (int j = 1; j <= MinBlockNum; j++) {
Simulate[j][i] = Simulate[j][i - 1];
//寻找最优置换位
for (int k = i - 1; k > 0; k--) {
if (Simulate[j][i] == PageOrder[k]) {
if (i - k > distance) {
distance = i - k;
pointer = j;
}
break;
}
//判断页列表中无此需求,直接将此页面作为替换页面
if (k == 1 && distance < MaxNumber) {
distance = MaxNumber;
pointer = j;
}
}
}
···
}
}
LackPageRate = (double) LackNum / (double) PageNum;
Print();
NextAlgorithm();
}
 

四、调试分析

调试过程中遇到的问题以及解决方法,设计与实现的回顾讨论和分析

问题 描述 解决方法
OPI、LRU算法同优先级处理问题 OPI、LRU算法中多个页面本页面序列中都不再使用时,因判定原因,会造成无限循环 使用if (k == 1 && distance < MaxNumber)条件语句解决本问题

算法的性能分析(包括基本操作和其它算法的时间复杂度和空间复杂度的分析)及其改进设想

性能分析

算法 时间复杂度 空间复杂度
先进先出(FIFO)页面置换算法 T(n) = O(n2) S(n) = O(n2)
最佳(OPI)页面置换算法 T(n) = O(n2) S(n) = O(n2)
最近最久未使用(LRU)页面置换算法 T(n) = O(n2) S(n) = O(n2)
Print数据输出 T(n) = O(n) S(n) = O(n2)
NextAlgorithm算法 T(n) = O(1) S(n) = O(1)

改进设想

设置页面0为状态符导致无法使用页面号为0的情况,可以考虑设计为数据结构

五、用户使用说明

使用说明

  • 控制台会提示要求用户进行输入,按提示输入内容即可
  • 不可输入页面0(该页面号设置为状态量)
  • 选择算法输入完成后将会输出虚拟内存页面置换过程及模拟列表
  • 可根据需要选择是否使用其他算法进行虚拟内存页面置换或退出

六、测试结果

测试结果,包括输入和输出

请输入最小物理块数MinBlockNum:4
请输入页面个数PageNum:12
请输入页面1编号PageOrder[1]:4
请输入页面2编号PageOrder[2]:3
请输入页面3编号PageOrder[3]:2
请输入页面4编号PageOrder[4]:1
请输入页面5编号PageOrder[5]:4
请输入页面6编号PageOrder[6]:3
请输入页面7编号PageOrder[7]:5
请输入页面8编号PageOrder[8]:4
请输入页面9编号PageOrder[9]:3
请输入页面10编号PageOrder[10]:2
请输入页面11编号PageOrder[11]:1
请输入页面12编号PageOrder[12]:5
请选择想要先使用的算法( 1-先进先出(FIFO)页面置换算法,2-最佳(OPI)页面置换算法,3-最近最久未使用(LRU)页面置换算法 ):1
您选择的是1-先进先出(FIFO)页面置换算法
页面7换掉第1物理块中的页面
页面8换掉第2物理块中的页面
页面9换掉第3物理块中的页面
页面10换掉第4物理块中的页面
页面11换掉第1物理块中的页面
页面12换掉第2物理块中的页面
页面置换算法模拟过程如下:
Page 1    Page 2    Page 3    Page 4    Page 5    Page 6    Page 7    Page 8    Page 9    Page10    Page11    Page12
BlockNum 1         4         4         4         4         4         4         5         5         5         5         1         1
BlockNum 2                   3         3         3         3         3         3         4         4         4         4         5
BlockNum 3                             2         2         2         2         2         2         3         3         3         3
BlockNum 4                                       1         1         1         1         1         1         2         2         2
页面置换算法缺页次数为:10
页面置换算法缺页率为:83%
请问是否还要进行其余算法,若是,请输入(1-3值);若否,请输入任意字符( 1-先进先出(FIFO)页面置换算法,2-最佳(OPI)页面置换算法,3-最近最久未使用(LRU)页面置换算法 ):2
您选择的是2-最佳(OPI)页面置换算法
页面7于最远距离4换掉第4物理块中的页面
页面11于最远距离100换掉第1物理块中的页面
页面置换算法模拟过程如下:
Page 1    Page 2    Page 3    Page 4    Page 5    Page 6    Page 7    Page 8    Page 9    Page10    Page11    Page12
BlockNum 1         4         4         4         4         4         4         4         4         4         4         1         1
BlockNum 2                   3         3         3         3         3         3         3         3         3         3         3
BlockNum 3                             2         2         2         2         2         2         2         2         2         2
BlockNum 4                                       1         1         1         5         5         5         5         5         5
页面置换算法缺页次数为:6
页面置换算法缺页率为:50%
请问是否还要进行其余算法,若是,请输入(1-3值);若否,请输入任意字符( 1-先进先出(FIFO)页面置换算法,2-最佳(OPI)页面置换算法,3-最近最久未使用(LRU)页面置换算法 ):3
您选择的是3-最近最久未使用(LRU)页面置换算法
页面7于最远距离4换掉第3物理块中的页面
页面10于最远距离6换掉第4物理块中的页面
页面11于最远距离4换掉第3物理块中的页面
页面12于最远距离4换掉第1物理块中的页面
页面置换算法模拟过程如下:
Page 1    Page 2    Page 3    Page 4    Page 5    Page 6    Page 7    Page 8    Page 9    Page10    Page11    Page12
BlockNum 1         4         4         4         4         4         4         4         4         4         4         4         5
BlockNum 2                   3         3         3         3         3         3         3         3         3         3         3
BlockNum 3                             2         2         2         2         5         5         5         5         1         1
BlockNum 4                                       1         1         1         1         1         1         2         2         2
页面置换算法缺页次数为:8
页面置换算法缺页率为:67%
请问是否还要进行其余算法,若是,请输入(1-3值);若否,请输入任意字符( 1-先进先出(FIFO)页面置换算法,2-最佳(OPI)页面置换算法,3-最近最久未使用(LRU)页面置换算法 ):0
Process finished with exit code 0
 

七、附录

带注释的源程序

#include <iostream>
#include <iomanip>
using namespace std;
#define MaxNumber 100
class virtualMemoryPageReplacementAlgorithm {
public:
int PageOrder[MaxNumber];//页面序列
int Simulate[MaxNumber][MaxNumber];//模拟过程
//    int PageCount[MaxNumber];//当前内存距离下一次出现的距离
int PageNum;//页面数
int MinBlockNum;//最小物理块数
int LackNum;//缺页数
double LackPageRate;//缺页率
bool found;
int isAlgorithm;//算法选择
//输入空闲分区数、空闲的分区大小、进程数、进程需要的分区大小
void Input() {
cout << "请输入最小物理块数MinBlockNum:";
cin >> MinBlockNum;
cout << "请输入页面个数PageNum:";
cin >> PageNum;
for (int i = 1; i <= PageNum; i++) {
cout << "请输入页面" << i << "编号" << "PageOrder[" << i << "]:";
cin >> PageOrder[i];
}
InputAlgorithm();
}
//获取算法选择输入
void InputAlgorithm() {
cout << endl
<< "请选择想要先使用的算法( 1-先进先出(FIFO)页面置换算法,2-最佳(OPI)页面置换算法,3-最近最久未使用(LRU)页面置换算法 ):";
cin >> isAlgorithm;
IsAlgorithm();
}
//算法存储确认
void IsAlgorithm() {
switch (isAlgorithm) {
case 1:
cout << endl << "您选择的是1-先进先出(FIFO)页面置换算法" << endl;
AlgorithmFIFO();
break;
case 2:
cout << endl << "您选择的是2-最佳(OPI)页面置换算法" << endl;
AlgorithmOPI();
break;
case 3:
cout << endl << "您选择的是3-最近最久未使用(LRU)页面置换算法" << endl;
AlgorithmLRU();
break;
default:
cout << "算法值:" << isAlgorithm
<< "有误,请重新输入正确的算法类型( 1-先进先出(FIFO)页面置换算法,2-最佳(OPI)页面置换算法,3-最近最久未使用(LRU)页面置换算法 )"
<< endl;
InputAlgorithm();
}
}
//询问是否还要进行其余算法
void NextAlgorithm() {
cout << endl
<< "请问是否还要进行其余算法,若是,请输入(1-3值);若否,请输入任意字符( 1-先进先出(FIFO)页面置换算法,2-最佳(OPI)页面置换算法,3-最近最久未使用(LRU)页面置换算法 ):";
cin >> isAlgorithm;
if (isAlgorithm != 1 && isAlgorithm != 2 && isAlgorithm != 3) {
return;
}
IsAlgorithm();
}
//输出页面置换算法模拟过程及缺页次数与缺页率
void Print() {
cout << endl << "页面置换算法模拟过程如下:" << endl;
//模拟过程
cout << left << setw(10) << "";
for (int i = 1; i <= PageNum; i++) {
cout << right << setw(8) << "Page" << setw(2) << i;
}
for (int i = 1; i <= MinBlockNum; i++) {
cout << endl << left << setw(8) << "BlockNum" << right << setw(2) << i;
for (int j = 1; j <= PageNum; j++) {
if (Simulate[i][j] != 0) {
cout << right << setw(10) << Simulate[i][j];
} else {
cout << setw(10) << "";
}
}
}
cout << endl << "页面置换算法缺页次数为:" << LackNum << endl;
cout << "页面置换算法缺页率为:" << setprecision(2) << LackPageRate * 100 << "%" << endl;
}
//调用先进先出(FIFO)页面置换算法进行调度计算
void AlgorithmFIFO() {
//初始化缺页次数
LackNum = 0;
//定义队列指针,指向下一个换出的页面
int pointer = 0;
for (int i = 1; i <= PageNum; i++) {
//初始化found
found = false;
//如果是第一个页面,直接添加页面,缺页数+1
if (i == 1) {
Simulate[1][i] = PageOrder[i];
LackNum++;
pointer = 1;
continue;
}
for (int j = 1; j <= MinBlockNum; j++) {
//判断是否在物理块中,若存在,则此页面未缺页
if (Simulate[j][i - 1] == PageOrder[i]) {
for (int k = 1; k <= MinBlockNum; k++) {
Simulate[k][i] = Simulate[k][i - 1];
}
found = true;
break;
}
//若缺页且有空物理块,则不置换,直接填入
if (Simulate[j][i - 1] == 0) {
for (int k = 1; k <= MinBlockNum; k++) {
Simulate[k][i] = Simulate[k][i - 1];
}
Simulate[j][i] = PageOrder[i];
LackNum++;
found = true;
break;
}
}
if (!found) {
for (int j = 1; j <= MinBlockNum; j++) {
Simulate[j][i] = Simulate[j][i - 1];
}
cout << "页面" << i << "换掉第" << pointer << "物理块中的页面" << endl;
Simulate[pointer][i] = PageOrder[i];
LackNum++;
if (pointer == MinBlockNum) {
pointer = 1;
} else {
pointer++;
}
}
}
LackPageRate = (double) LackNum / (double) PageNum;
Print();
NextAlgorithm();
}
//调用最佳(OPI)页面置换算法进行调度计算
void AlgorithmOPI() {
//初始化缺页次数
LackNum = 0;
for (int i = 1; i <= PageNum; i++) {
//初始化found
found = false;
//初始化队列指针,指向下一个换出的页面
int pointer = 0;
//初始化最远距离
int distance = 0;
//如果是第一个页面,直接添加页面,缺页数+1
if (i == 1) {
Simulate[1][i] = PageOrder[i];
LackNum++;
continue;
}
for (int j = 1; j <= MinBlockNum; j++) {
//判断是否在物理块中,若存在,则此页面未缺页
if (Simulate[j][i - 1] == PageOrder[i]) {
for (int k = 1; k <= MinBlockNum; k++) {
Simulate[k][i] = Simulate[k][i - 1];
}
found = true;
break;
}
//若缺页且有空物理块,则不置换,直接填入
if (Simulate[j][i - 1] == 0) {
for (int k = 1; k <= MinBlockNum; k++) {
Simulate[k][i] = Simulate[k][i - 1];
}
Simulate[j][i] = PageOrder[i];
LackNum++;
found = true;
break;
}
}
if (!found) {
for (int j = 1; j <= MinBlockNum; j++) {
Simulate[j][i] = Simulate[j][i - 1];
//寻找最优置换位
for (int k = i + 1; k <= PageNum; k++) {
if (Simulate[j][i] == PageOrder[k]) {
if (k - i > distance) {
distance = k - i;
pointer = j;
}
break;
}
//判断页列表中无此需求,直接将此页面作为替换页面
if (k == PageNum && distance < MaxNumber) {
distance = MaxNumber;
pointer = j;
}
}
}
cout << "页面" << i << "于最远距离" << distance << "换掉第" << pointer << "物理块中的页面" << endl;
Simulate[pointer][i] = PageOrder[i];
LackNum++;
}
}
LackPageRate = (double) LackNum / (double) PageNum;
Print();
NextAlgorithm();
}
//调用最近最久未使用(LRU)页面置换算法进行调度计算
void AlgorithmLRU() {
//初始化缺页次数
LackNum = 0;
for (int i = 1; i <= PageNum; i++) {
//初始化found
found = false;
//初始化队列指针,指向下一个换出的页面
int pointer = 0;
//初始化最远距离
int distance = 0;
//如果是第一个页面,直接添加页面,缺页数+1
if (i == 1) {
Simulate[1][i] = PageOrder[i];
LackNum++;
continue;
}
for (int j = 1; j <= MinBlockNum; j++) {
//判断是否在物理块中,若存在,则此页面未缺页
if (Simulate[j][i - 1] == PageOrder[i]) {
for (int k = 1; k <= MinBlockNum; k++) {
Simulate[k][i] = Simulate[k][i - 1];
}
found = true;
break;
}
//若缺页且有空物理块,则不置换,直接填入
if (Simulate[j][i - 1] == 0) {
for (int k = 1; k <= MinBlockNum; k++) {
Simulate[k][i] = Simulate[k][i - 1];
}
Simulate[j][i] = PageOrder[i];
LackNum++;
found = true;
break;
}
}
if (!found) {
for (int j = 1; j <= MinBlockNum; j++) {
Simulate[j][i] = Simulate[j][i - 1];
//寻找最优置换位
for (int k = i - 1; k > 0; k--) {
if (Simulate[j][i] == PageOrder[k]) {
if (i - k > distance) {
distance = i - k;
pointer = j;
}
break;
}
//判断页列表中无此需求,直接将此页面作为替换页面
if (k == 1 && distance < MaxNumber) {
distance = MaxNumber;
pointer = j;
}
}
}
cout << "页面" << i << "于最远距离" << distance << "换掉第" << pointer << "物理块中的页面" << endl;
Simulate[pointer][i] = PageOrder[i];
LackNum++;
}
}
LackPageRate = (double) LackNum / (double) PageNum;
Print();
NextAlgorithm();
}
};
int main() {
virtualMemoryPageReplacementAlgorithm virtualMemoryPageReplacementAlgorithm{};
virtualMemoryPageReplacementAlgorithm.Input();
return 0;
}
 

本文地址:H5W3 » 操作系统- 虚拟内存页面置换算法-详细设计附源码

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址