5种页面置换算法的实现

前几天做了一个有关页面替换算法的题，要求如下：

1 简介
要求实现多种页面替换算法，然后利用随机产生的引用串测试其性能。
2 页面替换算法
   我们做如下假设：
• 虚拟内存页面总数为P，标号从0到P−1；
• 引用串RS(reference string)是一个整数序列，整数的取值范围为0到P−1。RS中的每个元素p表示对页面p的一次引用；
• 物理内存由F帧组成，标号从0到F−1。我们引入一个数组M[F]， 数组元素M[f]中包含数字p，它表示帧f中包含页面p。页面替换算法顺次读取RS中的每个元素。对于RS中的元素值p，算法搜索数组M[F]，判断是否存在某个f，使得M[f] == p。如果未发现，则表示页面缺失。这时，算法必须根据其特定的替换规则，选择一帧M[i]，用页面p替换其中的内容，即令M[i] = p。
   下面讨论各种替换算法所需要的不同数据结构：
• 最佳替换算法和随机替换算法不需要其它的数据结构。 对于最佳替换 算法，通过搜索RS即足以确定应被替换的页面；对于随机替换算法，产生一个取值范围在0和F−1之间的随机数，该随机数即可表示应被替换的页面。
• FIFO需要一个指向最老页面的指针（数组索引）。每当该页面被替换的时候，把该指针加1(模F)即可。
• LRU算法则需要一个尺寸为F的数组，该数组用来实现排队功能：每次处理一个新的页面引用时，则把该页放置在队列的末尾。这样， 每当需要淘汰一个页面时，从队首取到的即最长时间未被用到的页面。
• Clock算法（也叫second−chance算法）和FIFO算法一样，需要一个指针。此外，它还需要一个数组，用来记录每一帧的使用情况。

   本实验要求实现多种页面替换算法，然后利用随机产生的引用串测试其性能。

3 引用串的生成
   实现了页面替换算法以后，我们还需要生成引用串，用以测试页面替换算法的性能。生成引用串的关键在于如何模拟程序的局部性。
生成不带局部性的引用串最为容易， 遗憾的是， 这和绝大多数的程序特性不符。多数程序都显示出高度的局部性，也就是说，在一个时间内，一组页面被反复引用。

   这组被反复引用的页面随着时间的推移，其成员也会发生变化。有时这种变化是剧烈的，有时这种变化则是渐进的。我们把这组页面的集合称 为当前工作集。

   我们可以为程序的这种行为方式建立如下模型。首先，我们定当前工作集由虚拟内存中连续的页面组成。这当然与实际情况不符，因为程序的代码、数据和堆栈通常分处在不同的虚拟内存区域。但是，对于研究页面替换算法来说，我们关心的只是当前工作集的大小，以及其成员更替的频繁程度。因此，从这个意义上说，我们的假设是合理的。
   我们进一步假设引用在当前工作集内的分布是均匀的。工作集可用其起始页面，以及其中包含的页面数表示。 随着时间的推移，工作集在虚拟内存中不断移动。有时，这种移动是渐进的，而有时则是剧烈的。为了给渐进移动建立模型，我们做如下假设：

工作集在固定的方向向匀速前进（例如，在处理了m个引用后，把工作集的起始页面加1）。对于剧烈移动，我们则重新随机选择工作集的起始页面 即可。剧烈移动在整个移动中的比率，我们用t表示。根据以上假设，引用串可用如下算法产生：
1. 确定虚拟内存的尺寸P，工作集的起始位置p，工作集中包含的页数e，工作集移动率m，以及一个范围在0和1之间的值t；
2. 生成m个取值范围在p和p+e间的随机数，并记录到引用串中；
3. 生成一个随机数r，0 ≤r ≤1；
4. 如果r<t，则为p生成一个新值，否则p = (p+1) mod P；
5. 如果想继续加大引用串的长度，请返回第而2步，否则结束。
4 性能评测
测试不同的引用串以及不同的虚拟内存尺寸

我把页面置换算法封装起来了，引用串的生成函数放在了main函数的上面，先贴封装的算法类：

头文件如下：

#ifndef __ALG__
#define __ALG__

#include <vector>
#include <iostream>
#include <time.h>

using namespace std;

enum Strategy
{
	OPT = 0,	//最佳置换算法
	RPA,		//随机置换算法
	FIFO,		//先进先出算法
	LUR,		//最近最久未使用算法
	CLOCK		//时钟算法
};

class NodeForLUR
{
public:
	NodeForLUR() {}
	~NodeForLUR() {}

	int index;
	NodeForLUR* next;
};

class LinkForLUR
{
public:
	LinkForLUR() {}
	~LinkForLUR() {}

	NodeForLUR* head;
	NodeForLUR* tail;
};

class Algorithms
{
public:
	explicit Algorithms(int memory_size);
	~Algorithms();

	void setReferenceString(std::vector<int> rs);
	int exePageReplace(Strategy strategy);
	
private:
	void resetMemory();
	int OPT(int current_serial);
	int RPA();
	int FIFO();
	int LUR();
	void updateLinkForLUR(int index);
	void deleteLinkForLUR(NodeForLUR* node);
	int CLOCK();

	//int page_size;
	int memory_size;
	int memory_used;
	int oldest_index;
	LinkForLUR link_for_LUR;
	int *memory;		//模拟物理内存
	bool *clock;
	int placement_count;//置换次数
	std::vector<int> reference_string;
};

#endif // !__ALG__

CPP文件如下：

#include "stdafx.h"

Algorithms::Algorithms(int memory_size)
{
	this->memory_size = memory_size;
	this->memory_used = 0;
	this->memory = new int[memory_size];
	this->clock = new bool[memory_size];
	this->link_for_LUR.head = nullptr;
	this->link_for_LUR.tail = nullptr;
	this->oldest_index = 0;
	this->placement_count = 0;
}

void Algorithms::setReferenceString(std::vector<int> rs)
{
	this->reference_string.clear();
	this->reference_string = rs;
}

int Algorithms::exePageReplace(Strategy strategy)
{
	//检测引用串的设置情况
	if (reference_string.empty()) {
		std::cout << "ERROR：引用串未设置！" << endl;
		return -1;
	}

	//检测是否初始化内存使用
	if (0 != memory_used) {
		resetMemory();
	}

	vector<int>::iterator ir = reference_string.begin();
	for (; ir < reference_string.end(); ++ir) {
		
		//是否物理内存中已存在该页面
		int index;
		for (index = 0; index < memory_used; index++) {
			if (memory[index] == *ir) {
				break;
			}
		}
		if (index != memory_used) {
			//内存存在
			//std::cout << "引用串第" << ir - reference_string.begin() << "位已存在物理内存中！" << endl;
			if (strategy == Strategy::LUR) {//策略为LUR时，更新最近最久未使用队列
				updateLinkForLUR(index);
			}
			else if (strategy == Strategy::CLOCK) {
				clock[index] = true;
				oldest_index = (index + 1) % memory_size;
			}
			continue;
		}

		//是否有空闲内存
		if (memory_used < memory_size) {
			memory[memory_used++] = *ir;
			//std::cout << "引用串第" << ir - reference_string.begin() << "位已加入空闲物理内存中！" << endl;
			if (strategy == Strategy::LUR) {//策略为LUR时，增加最近最久未使用队列节点
				if (memory_used == 1) {
					link_for_LUR.head = new NodeForLUR();
					link_for_LUR.head->index = 0;
					link_for_LUR.tail = link_for_LUR.head;
				}
				else {
					auto temp_node = new NodeForLUR();
					temp_node->index = memory_used - 1;
					temp_node->next = link_for_LUR.head;
					link_for_LUR.head = temp_node;
				}
			}
			else if (strategy == Strategy::CLOCK) {
				clock[memory_used - 1] = true;
			}
			continue;
		}

		//无空闲内存，页面替换
		int page;
		placement_count++;
		switch (strategy)
		{
		case Strategy::OPT:
		{
			int current_serial = ir - reference_string.begin();
			page = OPT(current_serial);
			break;
		}
		case Strategy::RPA:
			page = RPA();
			break;
		case Strategy::FIFO:
			page = FIFO();
			oldest_index = (oldest_index+1)%memory_size;
			break;
		case Strategy::LUR:
			page = LUR();
			updateLinkForLUR(page);
			break;
		case Strategy::CLOCK:
			page = CLOCK();
			clock[page] = true;
			break;
		default:
			_ASSERTE(0);
		}
		//cout << strategy <<"  page ：" << page << endl;
		memory[page] = *ir;
	}
	return placement_count;
}

/*
	重置内存使用
*/
void Algorithms::resetMemory()
{
	std::cout << "内存使用未重置，正在重置！" << endl;
	while (--memory_used >= 0)
	{
		memory[memory_used] = 0;
	}
	if (link_for_LUR.head != nullptr) {
		deleteLinkForLUR(link_for_LUR.head);
		link_for_LUR.head = nullptr;
		link_for_LUR.tail = nullptr;
	}
	memory_used++;
	oldest_index = 0;
	placement_count = 0;
}

/*
	最佳页面替换算法，返回替换页面在物理内存中的序号，下同
*/
int Algorithms::OPT(int current_serial)
{
	//分析是否有某个页面后续永不使用
	int memory_index = 0, MAX_PAGE = -1, MAX_COUNT = -1;
	for (; memory_index < memory_size; memory_index++)
	{
		int rs_index;
		for (rs_index = current_serial; rs_index < reference_string.size(); ++rs_index) {
			if (memory[memory_index] == reference_string[rs_index]) {
				if (MAX_COUNT < rs_index) {//当前页面在未来将会被再次引用，记录引用位置和页面号
					MAX_PAGE = memory_index;
					MAX_COUNT = rs_index;
				}
				break;
			}
		}
		if (rs_index == reference_string.size()) {//找到可替换页面（存在某页面永不使用）
			return memory_index;
		}
	}

	//无页面永不使用，则返回最长时间不使用页面在物理内存中的序号
	return MAX_PAGE;
}

/*
	随机置换页面算法
*/
int Algorithms::RPA()
{
	return rand()%memory_size;
}

/*
	先进先出算法
*/
int Algorithms::FIFO()
{
	return oldest_index;
}

int Algorithms::LUR()
{
	return link_for_LUR.tail->index;
}

void Algorithms::updateLinkForLUR(int index)
{
	//移动节点
	auto temp_node = link_for_LUR.head;
	NodeForLUR* last_node = nullptr;
	while (temp_node->index != index)
	{//查找节点
		_ASSERT(temp_node != nullptr);
		last_node = temp_node;
		temp_node = temp_node->next;
	}
	if (temp_node == link_for_LUR.head) {//如果查找到的节点是头结点，则无改动退出。
		return;
	}
	if (temp_node == link_for_LUR.tail && last_node != nullptr) {//是否是尾节点且链长大于1
		link_for_LUR.tail = last_node;
	}
	last_node->next = temp_node->next;
	temp_node->next = link_for_LUR.head;
	link_for_LUR.head = temp_node;
}

/*
	用于删除LUR的链表
*/
void Algorithms::deleteLinkForLUR(NodeForLUR* node)
{
	if (node->next != nullptr) {
		deleteLinkForLUR(node->next);
		delete node;
		node = nullptr;
	}
	else {
		delete node;
		node = nullptr;
	}
}

/*
	 这里借用了FIFO算法的oldest_index游标。反正一个策略执行完也会重置。
*/
int Algorithms::CLOCK()
{
	//查看是否有访问位为0的
	for (int index = oldest_index; index < memory_size; index++)
	{
		if (!clock[index]) {
			oldest_index = (index + 1) % memory_size;
			return index;
		}
		else{
			clock[index] = false;
		}
	}
	oldest_index = 0;
	return CLOCK();
}

Algorithms::~Algorithms()
{
	delete[] memory;
	delete[] clock;
	memory = nullptr;
	if (link_for_LUR.head != nullptr) {
		deleteLinkForLUR(link_for_LUR.head);
	}
}

main函数所在文件如下：

#include "stdafx.h"

#define _SCALE_ 100
/*
	函数功能：用于生成引用串
	参数从左至右依次为：
		v：用于填充的引用串
		page_size：页面总数P
		set_num：工作集中包含的页数e
		move：工作集移动率m
		jitter_rate：抖动率
		rs_size：预期生成的引用串长度
*/
void genReferenceString(vector<int>& v, int page_size, int set_num, 
	int start_position, int move, float jitter_rate, int rs_size) {
	
	int length = 0;
	srand((int)time(0));
	while (length < rs_size)
	{
		for (int count = 0; count < move; count++) {
			v.push_back((start_position + rand() % set_num)% page_size);
			length++;
		}
		int r = rand() % _SCALE_;
		if (r < jitter_rate*_SCALE_) {
			cout << "发生抖动，抖动位置为  " << length << endl;
			start_position = rand() % page_size;
		}
		else
		{
			start_position = (start_position + 1) % page_size;
		}
	}
}

int main()
{
	Algorithms test(10);
	vector<int> rs;
	genReferenceString(rs, 100, 10, 0, 10, 0.3, 40);
	cout << "此次随机生成的引用串如下所示！" << endl;
	for (int index = 0; index < 40; index++) {
		cout << "\t" << rs[index] ;
		if (index % 5 == 4) {
			cout << endl;
		}
	}
	Strategy strategy[] = { Strategy::OPT, Strategy ::RPA, Strategy::FIFO, Strategy::LUR, Strategy::CLOCK};
	test.setReferenceString(rs);
	for (int index = 0; index < 5; ++index) {
		cout << "第" << index << "号策略：" << endl;
		cout << "共计交换页面" << test.exePageReplace(strategy[index]) << "次！" << endl;
	}
    return 0;
}

stdafx.h文件里我放了这么一句，所以要包含一下：

#include "Algorithms.h"

程序的注释也很详细，我就不做过多解释了。有问题可以私信问我。