操作系统中的内存管理算法

操作系统的内存管理算法主要分为最近最久未使用算法(LRU),最近最少使用算法(LFU),先进先出算法,最优置换算法。这些算法都比较容易实现,在上课时做了一个课程实验,写了相关的程序:

#include  <iostream>
#include  <queue>
#include  <stack>
#include  <cstdio>
#include  <cstring>
#include  <cstdlib>
#include  <ctime>
#include  <set>
using namespace std;
const int maxn=320;
const int address_stream_length=320;
//int op[maxn]={70,0,10,20,0,30,0,40,20,30,0,30,20,10,20,0,10,70,0,10},lost,num,upper;
int op[maxn],lost,num,upper;
double target;
bool inmemory[35];

void optimization()
{
	set<int> task;
	for(int i=0;i<maxn;i++)
	{
		//cout<<"i="<<i<<endl;
		int page=op[i]/10+1;
		if(inmemory[page])
		{
			continue;
		}
		else
		{
			//cout<<"i="<<i<<" "<<"op[i]="<<op[i]<<" page="<<page<<endl;
			lost++;
			if(num<upper)
			{
				num++;
				inmemory[page]=true;
				task.insert(page);
			}
			else
			{
				int sum=0,out;
				bool count[maxn]={false};
				for(int j=i+1;j<maxn;j++)
				{
					if(inmemory[op[j]/10+1]&&!count[op[j]/10+1])
					{
						sum++;
						//cout<<"sum="<<sum<<endl;
						count[op[j]/10+1]=true;
						if(sum==upper)
						{
							out=op[j]/10+1;
							break;
						}
					}
				}
				if(sum<upper)
				{
					for(int j=1;j<=30;j++)
					{
						if(inmemory[j]&&!count[j])
						{
							out=j;
							break;
						}
					}
				}
				/*
				cout<<"out="<<out<<" before=";
				for(set<int>::iterator i=task.begin();i!=task.end();i++)
				  cout<<(*i)<<‘ ‘;
				cout<<"  after=";
				*/
				inmemory[out]=false;
				task.erase(task.find(out));
				task.insert(page);
				inmemory[page]=true;
				/*
				for(set<int>::iterator i=task.begin();i!=task.end();i++)
				  cout<<(*i)<<‘ ‘;
				cout<<endl;
				*/
			}
		}
	}
	task.clear();
}
void LRU()
{
	set<int> task;
	for(int i=0;i<maxn;i++)
	{
		int page=op[i]/10+1;
		if(inmemory[page])
		{
			continue;
		}
		else
		{
			lost++;
			//cout<<"i="<<i<<" page="<<page-1<<endl;
			if(num<upper)
			{
				task.insert(page);
				inmemory[page]=true;
				num++;
			}
			else
			{
				int sum=0;
				bool vis[maxn]={false};
				for(int j=i-1;j>=0;j--)
				{
					if(!vis[op[j]/10+1]&&inmemory[op[j]/10+1])
					{
						sum++;
						vis[op[j]/10+1]=true;
						if(sum==upper)
						{
							int out=op[j]/10+1;
							//cout<<"out="<<out-1<<endl;
							inmemory[out]=false;
							task.erase(task.find(out));
							inmemory[page]=true;
							task.insert(page);
							break;
						}
					}
				}
			}
		}
	}
	task.clear();
}
void FIFO()
{
	queue<int> task;
	for(int i=0;i<maxn;i++)
	{
		int page=op[i]/10+1;
		if(inmemory[page])
		{
			continue;
		}
		else
		{
			lost++;
			//cout<<"lost page="<<page<<endl;
			if(num<upper)
			{
				task.push(page);
				inmemory[page]=true;
				num++;
			}
			else
			{
				int tag=task.front();
				inmemory[tag]=false;
				task.pop();
				task.push(page);
				inmemory[page]=true;
			}
		}
	}
	while(!task.empty())
	{
		task.pop();
	}
}
void LFU()
{
	int cnt[35]={0};
	memset(cnt,0,sizeof(cnt));
	set<int> task;
	for(int i=0;i<maxn;i++)
	{
		int page=op[i]/10+1;
		if(inmemory[page])
		{
			cnt[page]++;
			continue;
		}
		else
		{
			lost++;
			//cout<<"i="<<i<<"  page="<<page<<endl;
			if(num<upper)
			{
				num++;
				cnt[page]++;
				inmemory[page]=true;
				task.insert(page);
			}
			else
			{
				int tag=0,minm=10000;
				for(int j=0;j<i;j++)
				{
					int page2=op[j]/10+1;
					if(inmemory[page2]&&cnt[page2]<minm)
					{
						tag=page2;
						minm=cnt[page2];
					}
				}
				//cout<<"out="<<tag<<endl;
				task.erase(task.find(tag));
				inmemory[tag]=false;
				task.insert(page);
				inmemory[page]=true;
				cnt[page]++;
			}
		}
	}
	task.clear();
}
int main()
{
	srand(time(NULL));
	upper=rand()%32+1;
	cout<<"Start memory management."<<endl;
	cout<<"Processing address flow,wait for while,please."<<endl;

	for(int i=0;i<160;i++)
		op[i]=rand()%320+1;
	for(int i=160;i<240;i++)
		op[i]=rand()%160+1;
	for(int i=240;i<320;i++)
		op[i]=rand()%160+160;

	cout<<"There are algorithms in the program"<<endl;
	cout<<"  1.Optimization algorithm"<<endl;
	cout<<"  2.Least recently used algorithm"<<endl;
	cout<<"  3.First in first out algorithm"<<endl;
	cout<<"  4.Least frequently used algorithm"<<endl;
	cout<<"Select an algorithm number,please:"<<endl;
	int tag;
	while(scanf("%d",&tag)!=EOF)
	{
		if(tag>=1&&tag<=4)
		{
			num=0;
			lost=0;
			memset(inmemory,false,sizeof(inmemory));
			if(tag==1)
				optimization();
			if(tag==2)
				LRU();
			if(tag==3)
				FIFO();
			if(tag==4)
				LFU();
			cout<<"lost="<<lost<<endl;
			target=1-double(lost)/address_stream_length;
			cout<<"The target="<<target<<endl;
			cout<<"Do you want to try again with another algorithm?(y/n)"<<endl;
			char ch;
			cin>>ch;
			if(ch==‘y‘)
				continue;
			else
				if(ch==‘n‘)
					break;
		}
		else
			cout<<"There is not the algorithm in the program"<<endl;
	}
	return 0;
}

  

时间: 2024-10-10 17:38:39

操作系统中的内存管理算法的相关文章

Android中的内存管理机制以及正确的使用方式

概述 从操作系统的角度来说,内存就是一块数据存储区域,属于可被操作系统调度的资源.现代多任务(进程)的操作系统中,内存管理尤为重要,操作系统需要为每一个进程合理的分配内存资源,所以可以从两方面来理解操作系统的内存管理机制. 第一:分配机制.为每一个进程分配一个合理的内存大小,保证每一个进程能够正常的运行,不至于内存不够使用或者每个进程占用太多的内存. 第二:回收机制.在系统内存不足打的时候,需要有一个合理的回收再分配的机制,以保证新的进程可以正常运行.回收的时候就要杀死那些正在占有内存的进程,操

轻量级操作系统FreeRTOS的内存管理机制(三)

本文由嵌入式企鹅圈原创团队成员朱衡德(Hunter_Zhu)供稿. 轻量级操作系统FreeRTOS的内存管理机制(二)中讲到,heap2.c的内存管理机制会导致内存碎片的问题,系统运行久后会出现无法分配大块内存的情况,heap4.c中的管理机制提供了解决方法,它是在heap2.c的基础上添加了地址相邻空闲块间合并的功能,而heap5.c是对heap4.c的进一步扩展,它能够支持多块不连续分布的RAM空间作为堆使用,本篇将对heap4.c.heap5.c中的管理机制进行分析. 一.heap4.c

Cocos2d-x开发中C++内存管理

由于开始并没有介绍C++语言,C++的内存管理当然也没进行任何的说明,为了掌握Cocos2d-x中的内存管理机制,是有必要先了解一些C++内存管理的知识.C++内存管理非常复杂,如果完全地系统地介绍可能需要一本书的篇幅才能解释清楚.这里只给大家介绍C++内存管理最为基本的用法. 内存分配区域创建对象需要两个步骤:第一步,为对象分配内存,第二步,调用构造函数初始化内存.在第一步中对象分配内存时候,我们可以选择几个不同的分配区域,这几个区域如下:栈区域分配.栈内存分配运算内置于处理器的指令集中,效率

Unity游戏开发中的内存管理_资料

内存是手游的硬伤——Unity游戏Mono内存管理及泄漏http://wetest.qq.com/lab/view/135.html 深入浅出再谈Unity内存泄漏http://wetest.qq.com/lab/view/150.html 这一次,我优化了37%的内存http://wetest.qq.com/lab/view/147.html Unity项目资源加载与管理http://wetest.qq.com/lab/view/124.html Android应用内存泄露分析.改善经验总结h

RT-thread内核之小内存管理算法

 一.动态内存管理 动态内存管理是一个真实的堆(Heap)内存管理模块,可以在当前资源满足的情况下,根据用户的需求分配任意大小的内存块.而当用户不需要再使用这些内存块时,又可以释放回堆中供其他应用分配使用.RT-Thread系统为了满足不同的需求,提供了两套不同的动态内存管理算法,分别是小内存管理算法和SLAB内存管理算法.小堆内存管理模块主要针对系统资源比较少,一般用于小于2M内存空间的系统:而SLAB内存管理模块则主要是在系统资源比较丰富时,提供了一种近似多内存池管理算法的快速算法. 两种内

YJX_Driver_033_驱动中的内存管理

1. 驱动中的内存管理 A. 物理内存 B. 虚拟内存 C. Ring0地址和Ring3地址 D. 驱动程序和进程的关系 E. 分页和非分页内存 F. 分配内核内存 [120]了解两个概念:物理内存  虚拟内存 [140]以下概念针对 32位Windows操作系统(32位及以上的CPU)(32位 / 64位 CPU) [210]64位下的这些概念 略有区别 [240] “ A.物理内存:(Physical Memory Address) 目前主流的操作系统还是32位的XP,而32位的系统提供的寻

【转】Android中的内存管理--不错不错,避免使用枚举类型

原文网址:http://android-performance.com/android/2014/02/17/android-manage-memory.html 本文内容翻译自:http://developer.android.com/training/articles/memory.html 随机存取存储器(RAM)再任何软件开发环境中都是宝贵的资源,但是在移动操作系统中,内存资源更为宝贵,使用时也会收到限制.虽然Android的Dalvik虚拟机有运行时的垃圾回收机制,但是这不意味着你的A

自动内存管理算法 &mdash;&mdash; 标记法

最近阅读了<垃圾回收算法手册>这本经典的书籍,借此机会打算写几篇内存管理算法方面的文章,也算是自己的总结吧. -- 题记 自动内存管理系统 自动内存管理主要面临以下三个方面的任务: 1.为新对象分配内存空间 2.确定"存活"对象 3.回收"死亡"对象所占用的内存空间 其中任务1一般称作"自动内存分配"(Memory Allocation ,下文简称 MA),任务2.3便是常说的"垃圾回收器"(Garbage Col

cocos2dx中的内存管理机制及引用计数

1.内存管理的两大策略: 谁申请,谁释放原则(类似于,谁污染了内存,最后由谁来清理内存)--------->适用于过程性函数 引用计数原则(创建时,引用数为1,每引用一次,计数加1,调用结束时,引用计数减1,当引用计数为0时,才会真正释放内存) --------->适用于注册性函数(消息处理,中断等场合) 2.cocos2dx中的内存管理采用引用计数和内存托管的原则 spr->retainCount();//获取对象的引用计数值 spr->retain();//引用计数加1 spr