【OS实验四】存储管理(仿真实验)

最新推荐文章于 2023-06-17 18:33:06 发布

array020

最新推荐文章于 2023-06-17 18:33:06 发布

阅读量1.6k

点赞数

CC 4.0 BY-SA版权

文章标签：存储 os manager vpn 算法 table

本文链接：https://blog.youkuaiyun.com/damacheng/article/details/6481741

本文通过实现FIFO和LFU两种页面置换算法，模拟了虚拟存储技术中的请求页式存储管理过程，比较了它们在不同内存分配情况下的缺页率，展示了算法在内存管理中的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

实验目的：

通过模拟实现请求页式存储管理的几种基本页面置换算法，了解虚拟存储技术的特点，掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程，并比较它们的效率。

实验仪器及材料：

微型计算机、红帽子Linux系统

任务：虚拟存储技术中，FIFO和LFU两种换页算法的模拟实现和效率比较

程序说明

本程序由以下三大部分组成：

(1) 一共320条指令顺序存储，即数字0~319是这320条指令的顺序的逻辑地址。通过随机数产生一个指令访问序列(实际上是指令的逻辑地址序列)。指令的访问序列按下述原则生成：

A：50%的指令是顺序执行的

B：25%的指令要实现向前跳转，均匀分布在前地址部分

C：25%的指令要实现向后跳转，均匀分布在后地址部分

具体的实施方法是：

A：在[0，319]的指令地址之间随机选取一起点m，执行指令m

B：顺序执行下一条指令，即执行地址为m+1的指令

C：在前地址[0，m+1]中随机选取一条指令并执行，该指令的地址为m’

D：顺序执行下一条指令，其地址为m’+1

E：在后地址[m’+2，319]中随机选取一条指令m并执行

F：重复步骤B-E，直到执行完320条指令

(2) 将每条指令的逻辑地址变换为页号和页内偏移地址

在用户的逻辑地址空间中，按每页存放10条指令排列逻辑地址，即320条指令在逻辑地址空间中的存放方式为：

第 0 条-第 9 条指令为第0页（对应逻辑地址为[0，9]）

第10条-第19条指令为第1页（对应逻辑地址为[10，19]）

………………………………

第310条-第319条指令为第31页（对应逻辑地址为[310，319]）

即：每条指令的逻辑地址中，最低位是页内偏移量，高位是页号。

按以上方式，用户指令可组成32页；

用户虚存容量为32块，即可以运行32页长度的作业；

用户实际分到的内存容量4块~32块。

(3) 分别使用FIFO算法和LFU算法，计算机给用户进程的这32页分配4，5，…，32个页面(内存块)时其缺页率。

Vir_Page.h

Code:

#ifndef _VIR_PAGE_H_
#define _VIR_PAGE_H_
class Vir_Page
{
public:
Vir_Page(unsigned int vpn,int rpn,unsigned int c)
:vir_page_no(vpn),real_page_no(rpn),count(c){}
Vir_Page(){}
bool operator <(const Vir_Page &rvp) const
{
return count < rvp.count;
}
void set_Vir_Page_No(unsigned int vpn)
{
vir_page_no = vpn;
}
unsigned int get_Vir_Page_No() const
{
return vir_page_no;
}
void set_Real_Page_No(int rpn)
{
real_page_no = rpn;
}
int get_Real_Page_No() const
{
return real_page_no;
}
void set_Count(unsigned int c)
{
count = c;
}
unsigned int get_Count() const
{
return count;
}
private:
unsigned int vir_page_no;
int real_page_no;
unsigned int count;
};
#endif

Real_Page.h

Code:

#ifndef _REAL_PAGE_H_
#define _REAL_PAGE_H_
class Real_Page
{
public:
Real_Page(unsigned int vpn,unsigned int rpn)
:vir_page_no(vpn),real_page_no(rpn){}
Real_Page(){}
Real_Page& operator=(const Real_Page &rp)
{
this->vir_page_no = rp.vir_page_no;
this->real_page_no = rp.real_page_no;
return *this;
}
void set_Vir_Page_No(unsigned int vpn)
{
vir_page_no = vpn;
}
unsigned int get_Vir_Page_No() const
{
return vir_page_no;
}
void set_Real_Page_No(unsigned int rpn)
{
real_page_no = rpn;
}
unsigned int get_Real_Page_No() const
{
return real_page_no;
}
private:
unsigned int vir_page_no;
unsigned int real_page_no;
};
#endif

Memory_Manager.h

Code:

#ifndef _MEMORY_MANAGER_H_
#define _MEMORY_MANAGER_H_
#include <vector>
#include <deque>
#include <queue>
#include "Vir_Page.h"
#include "Real_Page.h"
using std::vector;
using std::queue;
using std::deque;
class Memory_Manager
{
public:
Memory_Manager();
void FIFO(unsigned int real_page_num);
void LSU(unsigned int real_page_num);
private:
void init(unsigned int real_page_num);
static const unsigned int instruc_num;
vector<unsigned int> instruc;
vector<unsigned int> page;
vector<unsigned int> offset;
vector<Vir_Page> page_table;
queue<Real_Page> free_real_page_table;
deque<Real_Page> busy_real_page_table;
};
#endif

Memory_Manager.cpp

Code:

#include <iostream>
#include "Memory_Manager.h"
#include <algorithm>
using std::cout;
using std::endl;
const unsigned int Memory_Manager::instruc_num = 320;
Memory_Manager::Memory_Manager()
:instruc(instruc_num),page(instruc_num),offset(instruc_num)
{
unsigned int r;
srand(2000);
vector<unsigned int>::iterator i_it = instruc.begin();
vector<unsigned int>::iterator p_it = page.begin();
vector<unsigned int>::iterator o_it = offset.begin();
r = rand() % instruc_num;
for(;i_it != instruc.end();)
{
*i_it++ = r;
*p_it++ = r / 10;
*o_it++ = r % 10;
r = *(i_it - 1);
*i_it++ = r;
*p_it++ = r / 10;
*o_it++ = r % 10;
r = rand() % *(i_it - 1);
*i_it++ = r;
*p_it++ = r / 10;
*o_it++ = r % 10;
r = *(i_it - 1);
*i_it++ = r;
*p_it++ = r / 10;
*o_it++ = r % 10;
r = *(i_it - 1) + (rand() % (instruc_num - *(i_it - 1)));
}
}
void Memory_Manager::init(unsigned int real_page_num)
{
unsigned int i;
unsigned int vir_page_num = (instruc_num % 10) ? instruc_num / 10 + 1 : instruc_num / 10;
if(!page_table.empty())
{
page_table.clear();
}
for(i = 0;i < vir_page_num;i++)
{
page_table.push_back(Vir_Page(i,-1,0));
}
while(!free_real_page_table.empty())
{
free_real_page_table.pop();
}
for(i = 0;i < real_page_num;i++)
{
free_real_page_table.push(Real_Page(0,i));
}
if(!busy_real_page_table.empty())
{
busy_real_page_table.clear();
}
}
void Memory_Manager::FIFO(unsigned int real_page_num)
{
unsigned int i,page_fault_counter = 0;
Vir_Page vp;
Real_Page rp;
init(real_page_num);
for(i = 0;i < instruc_num;i++)
{
vp = page_table.at(page.at(i));
if(vp.get_Real_Page_No() == -1)
{
page_fault_counter++;
if(free_real_page_table.empty())
{
rp = busy_real_page_table.at(0);
busy_real_page_table.pop_front();
page_table.at(rp.get_Vir_Page_No()).set_Real_Page_No(-1);
free_real_page_table.push(rp);
}
rp = free_real_page_table.front();
free_real_page_table.pop();
rp.set_Vir_Page_No(vp.get_Vir_Page_No());
busy_real_page_table.push_back(rp);
page_table.at(page.at(i)).set_Real_Page_No(rp.get_Real_Page_No());
}
}
cout<<"FIFO:%"<<static_cast<double>(page_fault_counter) / instruc_num<<endl;
}
void Memory_Manager::LSU(unsigned int real_page_num)
{
unsigned int i,page_fault_counter = 0;
Vir_Page vp;
Real_Page rp;
vector<Vir_Page>::iterator vp_it,tmp_it;
deque<Real_Page>::iterator rp_it;
init(real_page_num);
for(i = 0;i < instruc_num;i++)
{
vp = page_table.at(page.at(i));
if(vp.get_Real_Page_No() == -1)
{
page_fault_counter++;
if(free_real_page_table.empty())
{
vector<Vir_Page> tmp(page_table);
sort(tmp.begin(),tmp.end());
tmp_it = tmp.begin();
while((tmp_it->get_Real_Page_No() == -1) && (tmp_it != tmp.end()))
{
tmp_it++;
}
rp_it = busy_real_page_table.begin();
while((rp_it->get_Real_Page_No() != tmp_it->get_Real_Page_No()) && (rp_it != busy_real_page_table.end()))
{
rp_it++;
}
page_table.at(rp_it->get_Vir_Page_No()).set_Real_Page_No(-1);
free_real_page_table.push(Real_Page(0,rp_it->get_Real_Page_No()));
busy_real_page_table.erase(rp_it);
}
rp = free_real_page_table.front();
free_real_page_table.pop();
rp.set_Vir_Page_No(vp.get_Vir_Page_No());
busy_real_page_table.push_back(rp);
page_table.at(page.at(i)).set_Real_Page_No(rp.get_Real_Page_No());
page_table.at(page.at(i)).set_Count(1);
}
else
{
page_table.at(page.at(i)).set_Count(page_table.at(page.at(i)).get_Count() + 1);
}
}
cout<<"LSU:%"<<static_cast<double>(page_fault_counter) / instruc_num<<endl;
}