精华内容
下载资源
问答
  • 2018-07-21 16:00:53

    模拟内存管理设计与实现:
    模拟实现动态分区内存管理机制。设计和实现关于内存管理的内存布局初始化及内存申请分配、内存回收等基本功能操作函数,尝试对 256MB 的用户内存空间进行动态分区方式模拟管理。内存分配的基本单位为 1KB,同时要求支持至少两种分配策略,并进行测试和对不同分配策略的性能展开比较评估。要求随机发生进程创建事件(包括进程运行时间及申请内存空间大小)。

        首次适应(First Fit)算法:空闲分区以地址递增的次序链接。分配内存时顺序查找,找到大小能满足要求的第一个空闲分区。 

        最佳适应(Best Fit)算法:空闲分区按容量递增形成分区链,找到第一个能满足要求的空闲分区。 

        最坏适应(Worst Fit)算法:又称最大适应(Largest Fit)算法,空闲分区以容量递减的次序链接。找到第一个能满足要求的空闲分区,也就是挑选出最大的分区。

    // 模拟内存管理.cpp : 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    #include <stdio.h>
    #include <stdlib.h>
    #include <windows.h>
    
    
    typedef unsigned long DIZHI;  //地址类型的设置
    
    int num = 0;  //进程数量
    int c;  //选择算法
    int times = 0;  //查找次数
    
    typedef struct freenode {  //空闲内存链表
    	int size;  //空闲地址块的大小
    	int address;  //起始地址
    	struct freenode* next;  //指向下一个空闲地址块
    };
    freenode *free_L = NULL;  //空闲链表
    
    struct busynode {  //内存占用链表
    	int pid;  //进程号
    	int size;  //地址块的大小
    	int address;  //起始地址
    	struct busynode* next;  //指向下一个被占用的地址块
    };
    busynode* busy_L = NULL;  //进程内存链表
    
    
    /*设计一定的数据结构以描述256MB内存空间的使用状况,并设计和构建函数void ChuShuHuaNC
    实现内存布局的初始化。假定内存空间的低址部分56MB(即0~56M-1)作为系统区和不参与分配过程。*/
    void ChuShiHuaNC(DIZHI zKS_KYNC, DIZHI zJS_KYNC)
    {
    	struct freenode *p;
    	busy_L = (busynode*)malloc(sizeof(busynode));
    	free_L = (freenode*)malloc(sizeof(freenode));
    	p = (freenode*)malloc(sizeof(freenode));
    
    	busy_L->next = NULL;  //初始化占用地址块链表
    	free_L->next = p;  //初始化空闲地址链表
    	p->size = zJS_KYNC - zKS_KYNC;  //空闲区的大小
    	p->address = zKS_KYNC;  //0~55不参与内存分配过程
    	printf("内存空间(%d~%dM)参与实际分配过程\n",zKS_KYNC,zJS_KYNC);
    	p->next = NULL;
    }
    
    void FF() {
    	freenode* fbh = free_L->next;
    	freenode* fbp = free_L->next;
    	int sizep;
    	int addrp;
    	while (fbh != NULL) {
    		while (fbp->next != NULL) {
    			if (fbp->address>fbp->next->address) {
    				addrp = fbp->address;
    				fbp->address = fbp->next->address;
    				fbp->next->address = addrp;
    				sizep = fbp->size;
    				fbp->size = fbp->next->size;
    				fbp->next->size = sizep;
    			}
    			fbp = fbp->next;
    		}
    		fbp = free_L->next;
    		fbh = fbh->next;
    	}
    	while (fbh != NULL) {
    		printf("%d,%d", fbh->size, fbh->address);
    		fbh = fbh->next;
    	}
    }
    
    void BF() {
    	freenode* fbh = free_L->next;
    	freenode* fbp = free_L->next;
    	int sizep;
    	int addrp;
    	while (fbh != NULL) {
    		while (fbp->next != NULL) {
    			if (fbp->size > fbp->next->size) {
    				addrp = fbp->address;
    				fbp->address = fbp->next->address;
    				fbp->next->address = addrp;
    				sizep = fbp->size;
    				fbp->size = fbp->next->size;
    				fbp->next->size = sizep;
    			}
    			fbp = fbp->next;
    		}
    		fbp = free_L->next;
    		fbh = fbh->next;
    	}
    	while (fbh != NULL) {
    		printf("%d,%d", fbh->size, fbh->address);
    		fbh = fbh->next;
    	}
    }
    
    void WF() {
    	freenode* fbh = free_L->next;
    	freenode* fbp = free_L->next;
    	int sizep;
    	int addrp;
    	while (fbh != NULL) {
    		while (fbp->next != NULL) {
    			if (fbp->size<fbp->next->size) {
    				addrp = fbp->address;
    				fbp->address = fbp->next->address;
    				fbp->next->address = addrp;
    				sizep = fbp->size;
    				fbp->size = fbp->next->size;
    				fbp->next->size = sizep;
    			}
    			fbp = fbp->next;
    		}
    		fbp = free_L->next;
    		fbh = fbh->next;
    	}
    	while (fbh != NULL) {
    		printf("%d,%d", fbh->size, fbh->address);
    		fbh = fbh->next;
    	}
    }
    
    /*设计和实现内存申请分配函数DIZHI ShenQingNC(unsigned long zDX),内存分配的基本单位为1KB,
    同时要求支持至少两种分配策略(如首次适应、循环首次适应、最佳适应、最坏适应等),若分配失败则返回NULL。*/
    DIZHI ShenQingNC(unsigned long zDX)
    {
    	printf("\n创建新的进程:所需空间为%d\n",zDX);
    
    	busynode *b = (busynode*)malloc(sizeof(busynode));
    	busynode *a = (busynode*)malloc(sizeof(busynode));
    
    	switch (c){
    	case 1: FF(); 
    		break;
    	case 2: BF(); 
    		break;
    	case 3: WF(); 
    		break;
    	default: printf("输入错误!\n"); 
    		return NULL;
    	}
    	freenode *p = free_L->next;
    	while (p != NULL)
    	{
    		if (p->size >= zDX)
    		{
    			a->next = busy_L->next;
    			busy_L->next = a;
    			
    			num++;  //进程数量增加
    			p->size -= zDX;
    			a->size = zDX;
    			a->address = p->address;
    			p->address = p->address + a->size;
    			printf("将首地址为%d,大小为%d的内存空间分配给进程!\n\n", a->address, a->size);
    			return 1;
    		}
    		p = p->next;
    		times++;
    	}
    	printf("内存空间不足!\n");
    	free(a);
    	return 0;
    }
    
    /*设计和实现内存回收函数void HuiShouNC(DIZHI zKSDZ) ,若回收分区与其它空闲分区相邻接,则采取合并措施。*/
    void HuiShouNC(DIZHI zKSDZ)
    {
    	int i = 0;
    	int m = rand()%num;  //随机指定进程号
    	busynode *b = (busynode*)malloc(sizeof(busynode)),
    		*c = (busynode*)malloc(sizeof(busynode));
    	printf("回收进程%d所分配的内存\n",m);
    	c = busy_L;
    	b = c->next;
    	while (b != NULL)
    	{
    		if (i == m)
    			break;
    		i++;
    		c = b;
    		b = b->next;
    	}
    	if (b->size == NULL)
    	{
    		printf("指定进程时出错!\n");
    		return;
    	}
    	else
    	{
    		c->next = b->next;  //回收算法 完成地址块的合并
    		
    		num--;
    		freenode *t = (freenode*)malloc(sizeof(freenode));
    		t->next = free_L->next;
    		free_L->next = t;
    		t->size = b->size;
    		t->address = b->address;
    		free(b);
    		printf("回收完成!\n");
    		FF();  //地址递增排序
    		freenode *p,*q;
    		q = free_L->next;
    		p = q->next;
    		while (p != NULL)   //合并内存
    		{
    			if (q->address + q->size == p->address)
    			{
    				printf("合并地址为%d和%d的空间!\n",q->address,p->address);
    				q->size += p->size;
    				q->next = p->next;
    				free(p);
    				p = q->next;
    				continue;
    			}
    			q = p;
    			p = p->next;
    		}
    	}
    }
    void display_memory()
    {
    	int s = 0;
    	busynode *a;
    	a = busy_L->next;
    	printf("\n----------------------------\n");
    	while (a != NULL)
    	{
    		printf("进程%d:起始地址为%d,大小为%d\n",s++,a->address,a->size);
    		a = a->next;
    	}
    	printf("----------------------------\n\n");
    }
    int main()
    {
    	printf("地址分配实验:\n");
    	printf("初始化内存空间:(%d~%dM)\n",0,256);
    	ChuShiHuaNC(56,256);  //初始化内存空间,0~56M-1不参与分配过程
    
    	printf("选择分配策略: 1.FF 2.BF 3.WF\n");
    	scanf("%d", &c);
    /*基于不同的内存分配策略形成不同版本的内存管理器,并根据内存平均利用率和
    分配查找分区比较次数等指标展开测试和对不同分配策略的内存管理器性能进行评估。*/
    	double aver = 0;  //平均内存利用率
    	int x = 0;
    	double size = 0;
    	int tag = 0;
    	while(1)
    	{
    		display_memory();
    //		Sleep(3000);
    		if (num>0)  //产生随机数,并根据该值确定是申请内存还是回收内存
    		{
    			int ss = rand() % 7;
    			if (ss%2 == 0)
    			{
    				int m = rand()%80;
    				if (m != 0)
    				{
    					ShenQingNC(m);
    					size += m;
    					tag++;
    				}
    			}
    			else
    			{
    				int n = rand() % num;
    				HuiShouNC(n);
    			}
    		}
    		else
    		{
    			int m = rand() % 80;
    			if (m != 0)
    			{
    				ShenQingNC(m);
    				size += m;
    				tag++;
    			}
    		}
    		//性能指标计算:内存平均利用率&&查找次数
    		//计算内存平均利用率
    		busynode *it = busy_L->next;
    		double P = 0;
    		while (it != NULL)
    		{
    			P += it->size;
    			it = it->next;
    		}
    		printf("内存利用率:%.3f\n",P/200);
    		x++;
    		aver += P/200;
    		if (x == 10000)
    			break;
    	}
    	printf("\n该方法平均内存申请大小:%.3f,平均内存利用率:%.3f,查找次数:%d\n",size/tag, aver/x ,times);
    	return 0;
    }
    
    更多相关内容
  • 内存动态分区管理模拟实现

    千次阅读 2019-12-11 11:31:36
    //Link.h 数据结构及函数定义 #ifndef LINK_H #define LINK_H ...//定义分区链表结构体 typedef struct DNode { int Daddress;//首地址 int Dsize; //当前长度 DNode* next; //下一结点指针 }...

    //Link.h 数据结构及函数定义

    #ifndef LINK_H
    #define LINK_H
    
    typedef int BOOL;
    #define TRUE  1
    #define FALSE 0
    
    //定义分区链表结构体
    typedef struct DNode
    {
    	int Daddress;//首地址
    	int Dsize;  //当前长度
    	DNode* next; //下一结点指针
    }DNode,*DLink;
    
    #define MAXPROCESS 10 //最大进程数
    typedef struct Process
    {
    	BOOL state;   //进程状态:为TRUE则在内存中、为FALSE则不再内存中
    	char  name[20];  //进程名
    	int Paddress; //进程存储地址
    	int Psize;    //进程大小
    }Process;
    
    /*使用到的函数如下*/
    DLink Init(int ma,int ms);//内存初始化
    DLink InitMore();         //初始化多个空闲区
    BOOL ProcessBuild();//建立进程
    //核心工作
    BOOL MemoryAlloc(DLink head);    //内存分配
    BOOL MemoryRecovery(DLink head,char *ProcessName); //内存回收
    //这里规定   1.低地址为上空闲区  2.高地址为下空闲区
    DLink UpFree(DLink head,int PN);                  //回收区存在上空闲区
    DLink DownFree(DLink head,int PN);                //回收区存在下空闲区
    //打印表
    void ShowMemory(DLink head);                      //打印空闲区块
    void ShowProcess();                               //打印进程表
    //排序算法
    void SortBigToSmall(DLink head);//从大到小排序
    void SortSmallToBig(DLink head);//从小到大排序
    void SortByAddress(DLink head); //按地址从小到大排序
    #endif

    //Link.cpp 相关函数实现

    #include"link.h"
    #include<stdlib.h>
    #include<stdio.h>
    #include<string.h>
    #pragma warning(disable : 4996)
    extern Process ProcessTable[MAXPROCESS];
    extern int ProcessNum;
    DLink Init(int ma,int ms)
    {//内存初始化
    	DLink Head;//头结点
    	DLink first;//第一个结点
    	Head = (DLink)malloc(sizeof(DNode));//分配头节点内存
    	if (Head == NULL)
    	{
    		printf("分配失败\n");
    	}
    	first = (DLink)malloc(sizeof(DNode));//分配第一个结点内存
    	if (first == NULL)
    	{
    		printf("分配失败\n");
    	}
    	Head->next = first;//头节点指向第一个结点
    	first->next = NULL;//第一个结点没有后继节点
    	first->Daddress = ma;//初始空闲区起始地址
    	first->Dsize = ms;  //初始空闲区大小
    	return Head;
    }
    
    DLink InitMore()
    {//初始化多个空闲区
    	DLink Head;//头结点
    	DLink p;//链表结点
    	int num=-1;
    	int ma,ms;
    	printf("输入空闲区个数(>=1):");
    	scanf("%d", &num);
    	if (num <= 0)
    	{
    		printf("空闲区小于1个,无法分配!\n");
    		return NULL;
    	}
    	Head = (DLink)malloc(sizeof(DNode));
    	if (Head == NULL)
    		printf("头结点分配失败\n");
    	p = Head;
    	for (int i = 0; i < num; i++)
    	{
    		DLink D;
    		D = (DLink)malloc(sizeof(DNode));
    		if (D == NULL)
    		{
    			printf("结点分配失败\n");
    		}
    		printf("输入第%d个空闲区的始址:",i+1);
    		scanf("%d", &ma);
    		printf("输入第%d个空闲区的大小:", i + 1);
    		scanf("%d", &ms);
    		D->Daddress = ma;
    		D->Dsize = ms;
    		p->next = D;
    		p = D;
    	}
    	p->next = NULL;
    	return Head;
    }
    
    BOOL ProcessBuild()
    {//建立进程
    	if (ProcessNum >= MAXPROCESS)
    	{
    		printf("进程已满!");
    		return FALSE;
    	}
    	printf("输入进程名:");
    	scanf("%s", ProcessTable[ProcessNum].name);
    	printf("输入进程大小:");
    	scanf("%d", &ProcessTable[ProcessNum].Psize);
    	ProcessTable[ProcessNum].state = FALSE;
    	ProcessTable[ProcessNum].Paddress = -1;
    	return TRUE;
    }
    
    BOOL MemoryAlloc(DLink head)
    {//内存分配
    	DLink p = head;
    	DLink pre;                     //用于指向p的前一个结点
    	while (p->next != NULL)
    	{
    		pre = p;
    		p = p->next;    //取下一结点
    		if (p->Dsize >= ProcessTable[ProcessNum].Psize)
    		{//当前分区结点足够分配
    			//分配操作
    			if (p->Dsize == ProcessTable[ProcessNum].Psize)
    			{//若当前结点与进程空间相等,则在链表中删除该结点
    				ProcessTable[ProcessNum].Paddress = p->Daddress;           //为进程存储位置赋值
    				pre->next = p->next;//将该结点移除链表
    				free(p);            //释放内存
    			}
    			else if (p->Dsize > ProcessTable[ProcessNum].Psize)
    			{//若当前结点大于进程空间,则减少该结点的大小
    				p->Dsize -= ProcessTable[ProcessNum].Psize;
    				ProcessTable[ProcessNum].Paddress = p->Daddress + p->Dsize;//为进程存储位置赋值
    			}
    			ProcessTable[ProcessNum].state = TRUE;//状态置为已分配
    			ProcessNum++;
    			//分配成功
    			return TRUE;
    		}
    	}
    	//链表遍历完还未完成分配,则分配失败
    	printf("无大小足够的分区!");
    	return FALSE;
    }
    
    BOOL MemoryRecovery(DLink head,char *ProcessName)
    {//内存回收
    	int pnum = -1;//进程序号
    	for (int i = 0; i < ProcessNum; i++)
    	{
    		if (strcmp(ProcessTable[i].name, ProcessName) == 0 && ProcessTable[i].state == TRUE)
    		{
    			pnum = i;
    		}
    	}
    	if (pnum == -1)
    	{//未找到同名进程
    		printf("不存在进程%s\n", ProcessName);
    		return FALSE;
    	}
    	if (UpFree(head, pnum) != NULL && DownFree(head, pnum) != NULL)
    	{//上下均有空闲区,合并两个空闲区
    		DLink pUp = UpFree(head, pnum);
    		DLink pDownPre = DownFree(head, pnum);
    		DLink pDown = pDownPre->next;
    		pUp->Dsize += ProcessTable[pnum].Psize + pDown->Dsize;
    		pDownPre->next = pDown->next;//将结点移出链表
    		free(pDown);//释放内存
    	}
    	else if (UpFree(head, pnum) != NULL && DownFree(head, pnum) == NULL)
    	{//仅存在上空闲区,并入上空闲区,且上空闲区大小增加
    		DLink pUp = UpFree(head, pnum);
    		pUp->Dsize += ProcessTable[pnum].Psize;
    	}
    	else if (UpFree(head, pnum) == NULL && DownFree(head, pnum) != NULL)
    	{//仅存在下空闲区,并入下空闲区,且下空闲区地址减小,大小增加
    		DLink pDownPre = DownFree(head, pnum);
    		DLink pDown = pDownPre->next;
    		pDown->Dsize += ProcessTable[pnum].Psize;
    		pDown->Daddress -= ProcessTable[pnum].Psize;
    	}
    	else
    	{//上下均存在空闲区,增加一个结点
    		DLink newNode = (DLink)malloc(sizeof(DNode));
    		newNode->Daddress = ProcessTable[pnum].Paddress;  //结点初始地址
    		newNode->Dsize = ProcessTable[pnum].Psize;        //结点长度
    		
    		DLink p = head;
    		//遍历链表直至找到初始地址小于该节点,下一结点的初始地址大于该结点的结点
    		while (p->next != NULL)
    		{
    			p = p->next;
    			if (p->Daddress < newNode->Daddress &&(p->next == NULL|| p->next->Daddress > newNode->Daddress))
    			{
    				newNode->next = p->next;
    				p->next = newNode;
    			}
    		}
    	}
    	ProcessTable[pnum].state = FALSE;
    	return TRUE;
    }
    
    DLink UpFree(DLink head, int PN)
    {//回收区存在上空闲区,低地址为上空闲区
    	DLink p = head;
    	while (p->next != NULL)
    	{
    		p = p->next;
    		if ((p->Daddress + p->Dsize) == ProcessTable[PN].Paddress)
    		{//存在上空闲区
    			return p;
    		}
    	}
    	//不存在上空闲区
    	return NULL;
    }
    
    DLink DownFree(DLink head, int PN)
    {//回收区存在下空闲区,高地址为下空闲区
    	DLink p = head;
    	DLink pre;//前一个结点
    	while (p->next != NULL)
    	{
    		pre = p;
    		p = p->next;
    		if ((ProcessTable[PN].Paddress + ProcessTable[PN].Psize) == p->Daddress)
    		{//存在下空闲区
    			return pre;//返回下空闲区的前一个结点
    		}
    	}
    	//不存在下空闲区
    	return NULL;
    }
    
    
    void ShowMemory(DLink head)
    {//打印空闲区块
    	DLink p = head;
    	printf("\n——空闲区块信息如下:\n");
    	printf("始址\t长度\t末址\n");
    	while (p->next != NULL)
    	{
    		p = p->next;
    		printf("%d\t%d\t%d\n", p->Daddress, p->Dsize, p->Daddress + p->Dsize);
    	}
    	printf("\n");
    }
    
    void ShowProcess()
    {//打印进程表
    	printf("\n——进程信息如下:\n");
    	printf("序号\t名字\t始址\t大小\t状态\n");
    	for (int i = 0; i < ProcessNum; i++)
    	{
    		if (ProcessTable[i].state == TRUE)
    		{
    			printf("%d\t%s\t%d\t%d\t分配\n", i, ProcessTable[i].name, ProcessTable[i].Paddress, ProcessTable[i].Psize);
    		}
    		else
    		{
    			printf("%d\t%s\t%d\t%d\t回收\n", i, ProcessTable[i].name, ProcessTable[i].Paddress, ProcessTable[i].Psize);
    		}
    	}
    }
    
    void SortBigToSmall(DLink head)
    {//从大到小排序
    	DLink T = head;//p用于控制冒泡排序循环次数
    	DLink p = head;//当前结点
    	DLink pre;//前一个结点
    	int TempA;
    	int TempS;
    	if (p->next == NULL)
    	{
    		printf("空闲区无结点!无法排序\n");
    		return;
    	}
    	p = p->next;
    	if (p->next == NULL)
    	{
    		printf("空闲区只有一个结点!不需要排序\n");
    		return;
    	}
    	while (T->next != NULL)
    	{//外循环,冒泡轮数
    		p = head->next;//初始化p为第一个结点
    		while (p->next != NULL)
    		{//内循环,冒泡实现
    			pre = p;         //pre为前一个结点
    			p = p->next;     //p为后一个结点
    			if (pre->Dsize < p->Dsize)
    			{//前一个结点小于后一个结点
    				TempA = pre->Daddress;
    				TempS = pre->Dsize;
    				pre->Daddress = p->Daddress;
    				pre->Dsize = p->Dsize;
    				p->Daddress = TempA;
    				p->Dsize = TempS;
    			}
    		}
    		T = T->next;
    	}
    	return;
    }
    void SortSmallToBig(DLink head)
    {//从小到大排序
    	DLink T = head;//p用于控制冒泡排序循环次数
    	DLink p = head;//当前结点
    	DLink pre;//前一个结点
    	int TempA;
    	int TempS;
    	if (p->next == NULL)
    	{
    		printf("空闲区无结点!无法排序\n");
    		return;
    	}
    	p = p->next;
    	if (p->next == NULL)
    	{
    		printf("空闲区只有一个结点!不需要排序\n");
    		return;
    	}
    	while (T->next != NULL)
    	{//外循环,冒泡轮数
    		p = head->next;//初始化p为第一个结点
    		while (p->next != NULL)
    		{//内循环,冒泡实现
    			pre = p;         //pre为前一个结点
    			p = p->next;     //p为后一个结点
    			if (pre->Dsize > p->Dsize)
    			{//前一个结点大于后一个结点
    				TempA = pre->Daddress;
    				TempS = pre->Dsize;
    				pre->Daddress = p->Daddress;
    				pre->Dsize = p->Dsize;
    				p->Daddress = TempA;
    				p->Dsize = TempS;
    			}
    		}
    		T = T->next;
    	}
    	return;
    }
    void SortByAddress(DLink head)
    {//按地址从小到大排序
    	DLink T = head;//p用于控制冒泡排序循环次数
    	DLink p = head;//当前结点
    	DLink pre;//前一个结点
    	int TempA;
    	int TempS;
    	if (p->next == NULL)
    	{
    		printf("空闲区无结点!无法排序\n");
    		return;
    	}
    	p = p->next;
    	if (p->next == NULL)
    	{
    		printf("空闲区只有一个结点!不需要排序\n");
    		return;
    	}
    	while (T->next != NULL)
    	{//外循环,冒泡轮数
    		p = head->next;//初始化p为第一个结点
    		while (p->next != NULL)
    		{//内循环,冒泡实现
    			pre = p;         //pre为前一个结点
    			p = p->next;     //p为后一个结点
    			if (pre->Daddress > p->Daddress)
    			{//前一个结点地址大于后一个结点
    				TempA = pre->Daddress;
    				TempS = pre->Dsize;
    				pre->Daddress = p->Daddress;
    				pre->Dsize = p->Dsize;
    				p->Daddress = TempA;
    				p->Dsize = TempS;
    			}
    		}
    		T = T->next;
    	}
    	return;
    }

    //Main.cpp 主函数

    #include<stdio.h>
    #include<stdlib.h>
    #include"link.h"
    #pragma warning(disable : 4996)
    Process ProcessTable[MAXPROCESS];   //进程表
    int ProcessNum = 0;                 //当前进程数
    
    int main()
    {
    	DLink Head;
    	printf("初始内存分配方式\n");
    	printf("1.整块内存\n");
    	printf("2.多块空闲区\n");
    	printf("选择你需要的方式:");
    	int cho = 0;
    	scanf("%d", &cho);
    	if (cho == 1)
    	{
    		printf("输入内存初始地址:");
    		int memoryaddress;
    		scanf("%d", &memoryaddress);
    		printf("输入内存大小:");
    		int memorysize;
    		scanf("%d", &memorysize);
    		Head = Init(memoryaddress,memorysize);
    	}
    	else if (cho == 2)
    	{
    		Head = InitMore();
    	}
    	else
    	{
    		printf("选择了不存在的选项!\n");
    		exit(0);
    	}
    
    	int choose = 1;
    	while (choose != 0)
    	{
    		printf("\n功能如下:\n");
    		printf("1.分配(最先适应法)\t");
    		printf("2.分配(最佳适应法)\t");
    		printf("3.分配(最坏适应法)\n");
    		printf("4.释放\n");
    //		printf("5.打印当前空闲表\t");
    //		printf("6.打印当前进程表\n");
    		printf("0.退出\n");
    		printf("选择你需要的功能:");
    		scanf("%d", &choose);
    		switch (choose)
    		{
    		case 1:
    			if (ProcessBuild() == TRUE)
    			{
    				SortByAddress(Head);//按地址升序排序
    				MemoryAlloc(Head);
    			}
    			else
    				printf("分配失败!!!\n");
    			break;
    		case 2:
    			if (ProcessBuild() == TRUE)
    			{
    				SortSmallToBig(Head);//按大小升序排列
    				MemoryAlloc(Head);
    			}
    			else
    				printf("分配失败!!!\n");
    			break;
    		case 3:
    			if (ProcessBuild() == TRUE)
    			{
    				SortBigToSmall(Head);//按大小降序排列
    				MemoryAlloc(Head);
    			}
    			else
    				printf("分配失败!!!\n");
    			break;
    		case 4:
    			char Pname[20];
    			printf("输入你要回收的进程名:");
    			scanf("%s", Pname);
    			MemoryRecovery(Head, Pname);
    			break;
    		case 5:
    			ShowMemory(Head);
    			break;
    		case 6:
    			ShowProcess();
    			break;
    		default:
    			break;
    		}
    		ShowMemory(Head);
    		ShowProcess();
    	}
    	DLink p = Head;
    	while (Head->next != NULL)
    	{
    		p = Head;
    		Head = Head->next;
    		free(p);
    	}
    	free(Head);
    	return 0;
    }
    展开全文
  • 模拟动态分区存储管理算法,实现用户区的分配回收 ◆菜单包括 ➢初始化(设置内存大小、可用分区表、内存分配表) ➢分配(输入一个进程名和所需内存大小,按某种分配算法进行分配,输出分配情况;如不能分配,说明...
  • 编写一个动态分区分配算法模拟程序,加深对动态分区存储管理方式及其实现过程的理解。 要求: 1.空闲分区通过空闲区链进行管理,在内存分配时,优先考虑低地址部分的空闲区。 2.分别采用首次适应算法、最佳适应算法...
  • 开发一个C语言程序实现内存空间管理动态分区分配方案。 二、实验原理 动态分区分配:根据进程的实际需要,动态地创建分区为之分配内存空间,在实现动态分区分配时,将涉及分区分配中所使用的数据结构,分区分配...

    动态分区分配
    一、实验目标
    开发一个C语言程序实现内存空间管理的动态分区分配方案。
    二、实验原理
    动态分区分配:根据进程的实际需要,动态地创建分区为之分配内存空间,在实现动态分区分配时,将涉及分区分配中所使用的数据结构,分区分配算法和分区的分配与回收操作等问题。
    1) 分区分配中的数据结构
     空闲分区表:一个数据表,用于记录每个空闲块的情况,如起始地址、大小、使用情况等;
     空闲分区链表:把所有的空闲分区链接成一个链表,便于内存空间查看与分配回收。
    2) 内存分配过程
    利用分配算法找到满足要求的内存块,设请求的内存大小为size:
     若找到的空闲分区的大小等于size,完全分配;
     若找到的空闲分区大小大于size,且一分为二后,剩余大小小于1K,则不再分割,作为整体进行分配;否则一分为二,剩余部分仍然作为空闲分区存在;
     若无满足要求空闲分区,则分配失败
    3) 分配算法
     首次适应法:空闲分区按首地址递增次序组织,每次查找时从链首出发,寻找满足要求的内存块。
     最佳适应法:空闲分区按空闲分区大小址递增次序组织,每次查找时从链首出发,寻找满足要求的最小内存块进行分配。
     最坏适应法:空闲分区按空闲分区大小递减次序组织,每次查找时直接判断最大空闲分区是否满足要求。
    4) 内存回收
    根据释放区首址和大小,查找空闲分区表/链表,判断是否有相邻的空闲分区存在:
     释放区与前空闲区相邻:将释放区与前空闲区合并为一个空闲区。其首址仍为前空闲区首址,大小为释放区大小与空闲区大小之和。
     释放区与前后两个空闲区相邻:将这三个区合为一个空闲区,其首址为前空闲区首址,大小为这三个区大小之和,并取消原后空闲区表目。
     释放区与后空闲区相邻:则把释放区合并到后空闲,首地址为释放区首地址,大小为二者大小之和。
     释放区不与任何空闲区相邻:将释放区作为一个空闲区,将其大小和首址插入到空闲区表的适当位置。

    实验目的或要求:通过本实验使我们深入理解计算机存储器管理的连续分配方式或离散分配方式的分页技术的思想与实现方法,使我们更好分析和掌握连续或分页实现内存管理的特点,达到对计算机学科基础实践能力、问题分析、设计、算法实现的专业核心能力的培养。
    开发一个C语言程序实现内存空间管理的动态分区分配方案。根据进程的实际需要,动态地创建分区为之分配内存空间,在实现动态分区分配时,将涉及分区分配中所使用的数据结构,分区分配算法和分区的分配与回收操作等问题。设计分区分配中的数据结构,实现内存分配过程,使用首次适应法实现分配内存空间作用,并处理好各种内存回收中的各种情况,比如释放区与前空闲区相邻,释放区与前后两个空闲区相邻等等。

    在这里插入图片描述

    #include <stdio.h>
    #include <stdlib.h>
    
    int memory = 0; //存储空间的大小
    int count = 0;	//记录总的作业数
    typedef struct Storage{
    	int number;		//作业号
    	int start;
    	int last;
    	int size;
    	int state;	//区分内存空间是已分配还是未分配  空闲为0 
    	struct  Storage *next;
    }Storage;
    int add(Storage *head,int number,int size){
    	Storage *add1 = head->next;
    	//遍历
    	while(add1 != NULL){
    		//找到大于或等于插入作业的空闲区 
    		if(add1->number==-1 && add1->size>=size){
    			break; 
    		}
    		add1 = add1->next;
    	}
    	if(add1 == NULL){
    		//未找到合适的空闲区
    		return 0;	
    	}
    	//将空闲区划分为两个部分
    	int sizeOld = add1->size;
    	
    	//存储作业 
    	add1->number=number;
    	add1->size = size;
    	add1->state = 1;
    	add1->last = add1->start + size - 1;
    
    	//新空闲区部分
    	Storage *add2 = (Storage *)malloc(sizeof(Storage));
    	add2->number = -1;
    	add2->size = sizeOld - size;
    	add2->start = add1->last + 1;
    	if(add2->start >= memory - 1){
    		add1->next = NULL;
    		return 1; 
    	} 
    	add2->state = 0;
    	add2->last = add2->start + add2->size - 1;
    	add2->next = add1->next;
    	add1->next = add2;	
    	return 1; 
    }
    
    int deleted(Storage *head,int id){
    	Storage *del1 = head->next;
    	Storage *del2 = del1->next;
    	int temp1 = -1,temp2 = -1;
    	
    	while(del1 != NULL){
    		if(id == del2->number){
    			temp1 = 0;
    			temp2 = 0; 
    			//与前一个空闲区相邻 
    			if(del1->state == 0){
    				temp1 = 1;
    			}
    			//与后一个空闲区相邻 
    			if(del2->next->state == 0){
    				temp2 = 1;
    			}
    			break;
    		}
    		del1 = del1->next;
    		del2 = del2->next;
    	}
    	//讨论空闲区前后空闲区情况 
    	//前后都是空闲区
    	if(temp1 == 1 && temp2 == 1){ 
    		del1->last = del2->next->last;
    		del1->size = del1->size + del2->size + del2->next->size;
    		del1->state = 0;	
    		del1->number = -1; 
    		del1->next = del2->next->next;
    	}
    	//前面是空闲区 
    	else if(temp1 == 1){
    		del1->number = -1;
    		del1->size = del1->size + del2->size;
    		del1->state = 0;
    		del1->last = del2->last;
    		del1->next = del2->next;
    	}
    	//后面是空闲区 
    	else if(temp2 == 1){ 
    		del2->number = -1;
    		del2->size = del2->size + del2->next->size;
    		del2->state = 0;
    		del2->last = del2->next->last;
    		del2->next = del2->next->next; 
    	}
    	//前后都不是空闲区
    	else{
    		del2->number = -1;
    		del2->state = 0;
    	} 
    	return 1;
    }
    //查看内存分配情况 
    void viewinformation(Storage *head){
    	Storage *p = head->next;
    	while(p != NULL){
    		if(0 == p->state){
    			printf("空闲区  \tstart = %d\tlast = %d\tsize = %d\n",p->start,p->last,p->size);
    		} 
    		else{
    			printf("作业id = %d\tstart = %d\tlast = %d\tsize = %d\n",p->number,p->start,p->last,p->size);
    		}
    		p = p->next;
    	}
    }
    
    void firstview(){
    	    printf("1: 为新作业分配内存\n");
            printf("2: 回收作业释放内存\n");
     	    printf("3: 查看内存分配情况\n");        
    		printf("4:退出\n");
    		printf( "请输入操作: " );
    } 
    int main(){
    	printf("请输入存储空间大小(单位K):");
    	scanf("%d",&memory);
    	//初始化 
    	Storage *head = (Storage *)malloc(sizeof(Storage));
    	Storage *storage = (Storage *)malloc(sizeof(Storage));
    	head->next = NULL;
    	storage->number = -1;
    	storage->size = memory;
    	storage->start = 0;
    	storage->last = memory-1;
    	storage->state = 0;
    	storage->next = NULL;
    	head->next = storage;
    	while(1){
    		int chioce, id, size;
    		firstview();
            scanf("%d", &chioce);
            switch(chioce){
            	//四个选项,分别做不同的事情 
    			case 1 : {
    				//分配新作业 
            		printf("请输入作业id 和 作业大小size:\n");
            		printf("id = ");
            		scanf("%d",&id);
            		printf("size = ");
            		scanf("%d",&size);
            		if(add(head,id,size)){ 
    					printf("空间分配成功!\n");
    					//每分配一次空间,作业数加一 
    					count++; 
    				} 
    				else{
    					printf("空间分配失败!\n");
    				}
    				break;
    			} 
    			case 2 : {
    				//回收作业 
    				printf("请输入回收作业的 id:");
    				scanf("%d",&id);
    				if(deleted(head,id)){
    					//回收成功 
    					count--;
    					printf("作业回收成功!\n");	
    				}
    				else{
    					//回收失败 
    					printf("作业回收失败!\n");
    				}
    				break;
    			}
    			case 3 : { 
    				//查看分配情况 
    				viewinformation(head);
    				break;
    			} 
    			case 4 : {
    				//退出程序 
    				return 0;
    			} 
    		}
    	}
    	return 0;
    }
    
    
    展开全文
  • c++模拟实现动态分区存储管理

    千次阅读 2021-06-05 17:08:58
    请重新选择"二、介绍 编程实现动态分区存储管理方式的主存分配回收。具体内容包括:首先确定主存空间分配表;然后采用最优适应算法及首次适应算法完成主存空间的分配和回收。 具体讲: 初始状态:动态分区管理方式...

    一、代码

    #include<iostream>
    #include<vector>
    #include<string>
    using namespace std;
    typedef struct memoryBlock{
        string jobName;
        int startadress;
        int length;
        bool state;
    }memoryBlock;
    vector<memoryBlock> mb;
    void init(){
        memoryBlock m1,m2,m3,m4,m5;
        m1.jobName="作业1";m2.jobName="作业3";m3.jobName="未分配";m4.jobName="作业2";m5.jobName="未分配";
        m1.state=1;m2.state=1;m3.state=0;m4.state=1;m5.state=0;
        m1.startadress=5;m2.startadress=10;m3.startadress=14;m4.startadress=26;m5.startadress=32;
        m1.length=5;m2.length=4;m3.length=12;m4.length=6;m5.length=96;
        mb.push_back(m1);mb.push_back(m2);mb.push_back(m3);mb.push_back(m4);mb.push_back(m5);
    }
    void firstfit(){
        string name;
        cout<<"请输入要分配的作业名称:";
        cin>>name;
        int size;
        cout<<"请输入作业主存量:";
        cin>>size;
        for(vector<memoryBlock>::iterator it = mb.begin();it!=mb.end();++it){
            int s_pos = it->startadress+size;
            int last_size = it->length-size;
            int f = 0;
            if(it->length>size){
                f=1;
            }
            if(it->state==0&&it->length>=size){
                it->state=1;
                it->length=size;
                it->jobName = name;
                if(f){
                    memoryBlock m;
                    m.jobName="未分配";
                    m.length=last_size;
                    m.state=0;
                    m.startadress = s_pos;
                    it++;
                    mb.insert(it,m);
                }
                break;
            }
        }
    }
    void bestfit(){
        string name;
        cout<<"请输入要分配的作业名称:";
        cin>>name;
        int size;
        cout<<"请输入作业主存量:";
        cin>>size;
        int min_last=128;
        for(vector<memoryBlock>::iterator it = mb.begin();it!=mb.end();++it){
            if(it->state==0&&it->length>=size){
                int last_size = it->length-size;
                if(last_size<min_last){
                    min_last=last_size;
                }
            }
        }
        for(vector<memoryBlock>::iterator it = mb.begin();it!=mb.end();++it){
            int s_pos = it->startadress+size;
            int last_size = it->length-size;
            if(last_size==min_last){
                it->state=1;
                it->length=size;
                it->jobName = name;
                if(last_size>0){
                    memoryBlock m;
                    m.jobName="未分配";
                    m.length=last_size;
                    m.state=0;
                    m.startadress = s_pos;
                    it++;
                    mb.insert(it,m);
                }
                break;
            }
        }
    }
    void memoryrecycle(){
        cout<<"请输入要回收的作业名称:";
        string name;
        cin>>name;
        vector<memoryBlock>::iterator it_new;
        for(vector<memoryBlock>::iterator it = mb.begin();it!=mb.end();++it){
            if(it->jobName.compare(name)==0){
                it->state=0;
                it->jobName="未分配";
                it_new = it;
                break;
            }
        }
        vector<memoryBlock>::iterator it_pre=--it_new;
        it_new++;
        vector<memoryBlock>::iterator it_next=++it_new;
        it_new--;
        if(it_pre->state==1&&it_next->state==0){
            it_new->length+=it_next->length;
            mb.erase(it_next);
        }
        else if(it_pre->state==0&&it_next->state==1){
            it_pre->length+=it_new->length;
            mb.erase(it_new);
        }
        else if(it_pre->state==0&&it_next->state==0){
            it_pre->length+=it_new->length;
            it_pre->length+=it_next->length;
            mb.erase(it_new);
            mb.erase(it_next);
        }
    }
    void showMT(){
        cout<<"*********************空闲区表*********************"<<endl;
        cout<<"\t起止\t|\t长度\t|\t状态"<<endl;
        for(vector<memoryBlock>::iterator it = mb.begin();it!=mb.end();++it){
            if(it->state==0){
                cout<<"\t"<<it->startadress<<"k\t|\t"<<it->length<<"k\t|\t"<<it->jobName<<endl;
            }
        }
        cout<<"**************************************************"<<endl;
        cout<<"*********************已分配表*********************"<<endl;
        cout<<"\t起止\t|\t长度\t|\t名称"<<endl;
        for(vector<memoryBlock>::iterator it = mb.begin();it!=mb.end();++it){
            if(it->state==1){
                cout<<"\t"<<it->startadress<<"k\t|\t"<<it->length<<"k\t|\t"<<it->jobName<<endl;
            }
        }
        cout<<"**************************************************"<<endl;
    }
    int main(){
        init();
        cout<<"选择分配主存算法(a-首次适应算法,b-最优适应算法)"<<endl<<"请输入选择的算法:";
        char option1;
        cin>>option1;
        int option2;
        int running = 1;
        while(running){
            cout<<"选择功能项(0-退出,1-分配主存,2-回收主存,3-显示主存)"<<endl<<"请输入选择的功能:";
            cin>>option2;
            switch (option2){
                case 0: running = 0;break;
                case 1: {
                    if(option1=='a'){
                        firstfit();
                    }
                    else if(option1=='b'){
                        bestfit();
                    }
                    break;
                }
                case 2: {memoryrecycle();break;}
                case 3: {showMT();break;}
                default:{
                    cout<<"输入有误!请重新选择"<<endl;
                    break;
                } 
                
            }
        }
        return 0;
    }

    二、介绍

    编程实现动态分区存储管理方式的主存分配与回收。具体内容包括:首先确定主存空间分配表;然后采用最优适应算法及首次适应算法完成主存空间的分配和回收。

    具体讲:

    初始状态:动态分区管理方式预先不将主存划分区域。而是把主存除操作系统占用区域外的空间看作一个大的空闲区。当作业要求装入主存时,根据作业的大小查询主存内各空闲区。并按照特定的算法选择一合适的空闲区,按作业大小的要求画出一个分区并装入该作业。剩下的区域作为新的空闲区。

    当作业执行完毕后,所占用的主存空间将被回收,成为一个空闲区。注意如果该空闲区的相邻分区也是空闲区,则需要将相邻空闲区合并成一个空闲区。

    提示:

    动态分区大小由作业需求量决定,分区的长度预先不能固定。

    可建立两张分区表记录主存使用情况:

    “已分配表”记录作业占用分区;“空闲区表”记录空闲区。

    主程序菜单可参考:

        选择功能项(0-退出、1-分配主存、2-回收主存、3-显示主存)

        分配时,要求输入作业名和长度

        回收时,要求输入要回收的作业名

        显示主存,则显示空闲分区情况以及已分配分区情况等。

    本实验模拟在两种存储管理方式下的主存分配和回收。

    图例:

    可变分区方式是按作业需要的主存空间大小来分割分区的。当要装入一个作业时,根据作业需要的主存量查看是否有足够的空闲空间,若有,则按需要量分割一个分区分配给该作业;若无,则作业不能装入。随着作业的装入、撤离,主存空间被分成许多个分区,有的分区被作业占用,而有的分区是空闲的。

    为了说明哪些区是空闲的,可以用来装入新作业,必须要有一张空闲区说明表,格式如下:

     

    起    址

    长    度

    状      态

    第一栏

    14 K

    12 K

    未 分 配

    第二栏

    32 K

    96 K

    未 分 配

    其中,起址——指出一个空闲区的主存起始地址。

          长度——指出从起始地址开始的一个连续空闲的长度。

          状态——有两种状态,一种是“未分配”状态,指出对应的由起址指出的某个长度的区域是空闲区;另一种是“空表目”状态,表示表中对应的登记项目是空白(无效),可用来登记新的空闲区(例如,作业撤离后,它所占的区域就成了空闲区,应找一个“空表目”栏登记归还区的起址和长度且修改状态)。由于分区的个数不定,所以空闲区说明表中应有适量的状态为“空表目”的登记栏目,否则造成表格“溢出”无法登记。

    上述的这张说明表的登记情况是按例所装入的三个作业占用的主存区域后填写的。

    (1) 当有一个新作业要求装入主存时,必须查空闲区说明表,从中找出一个足够大的空闲区。有时找到的空闲区可能大于作业需要量,这时应把原来的空闲区变成两部分:一部分分给作业占用;另一部分又成为一个较小的空闲区。为了尽量减少由于分割造成的空闲区,而尽量保存高地址部分有较大的连续空闲区域,以利于大型作业的装入。为此,在空闲区说明表中,把每个空闲区按其地址顺序登记,即每个后继的空闲区其起始地址总是比前者大。为了方便查找还可使表格“紧缩”,总是让“空表目”栏集中在表格的后部。

    (2) 采用最先适应算法(顺序分配算法)分配主存空间。

    按照作业的需要量,查空闲区说明表,顺序查看登记栏,找到第一个能满足要求的空闲区。当空闲区大于需要量时,一部分用来装入作业,另一部分仍为空闲区登记在空闲区说明表中。

    由于本实验是模拟主存的分配,所以把主存区分配给作业后并不实际启动装入程序装入作业,而用输出“分配情况”来代替。最先适应分配算法如图4-1。

    (3) 当一个作业执行结束撤离时,作业所占的区域应该归还,归还的区域如果与其它空闲区相邻,则应合成一个较大的空闲区,登记在空闲区说明表中。例如,在提示(1)中列举的情况下,如果作业2撤离,归还所占主存区域时,应与上、下相邻的空闲区一起合成一个大的空闲区登记在空闲区说明表中。归还主存时的回收算法如图4-2。

    (4) 请按最先适应算法设计主存分配和回收的程序。然后按主存中已装入三个作业,且形成两个空闲区,确定空闲区说明表的初值。现有一个需要主存量为6K的作业4申请装入主存;然后作业3撤离;再作业2撤离。请你为它们进行主存分配和回收,把空闲区说明表的初值以及每次分配或回收后的变化显示出来或打印出来。

    图1:最先适应分配模拟算法

     
     

    图2: 主存回收算法

     
     


     

     

     

     

    展开全文
  • 动态分区内存管理(完整代码)

    千次阅读 2021-04-16 21:34:06
    设计一个动态分区式存贮区管理程序,要求支持不同的放置策略。如首次、最佳、最坏。 说明: (1)分区描述器rd如下: flag size next 要求空闲区队列按链表组织。 主存大小假设为maxsize(单位为节=rd的大小...
  • 课题八:存储管理---动态分区分配算法的模拟: 要求设计主界面以灵活选择某算法,且以下算法都要实现:首次适应算法、循环首次适应算法、最佳适应算法;
  • 这一篇博客前一篇博客内容连续,这一篇博客主要讨论可重定位分区分配进程对换的相关知识,也是以理解概念为主要任务。多看几遍,就能搞懂。 动态重定位的引入 在连续分配方式中,必须把一个系统或用户程序...
  • C++动态内存管理

    2018-07-14 16:29:46
    1 内存分配方式 (1) 从静态存储区域分配。内存在程序编译的时候就已经分配好,这块内存在程序的 整个运行期间都存在。例如全局变量,static 变量。...(3) 从堆上分配,亦称动态内存分配。程序在...
  • 含C++源码和设计文档 内存动态分区管理 适合初学者
  • 并加以实现,加深对操作系统原理和实现过程的理解。 二、实验内容: 多级反馈队列调度的模拟。 本算法设置了三个优先级从高到低的队列,时间片长度分别为: 队列一:2 队列二:4 队列三:8 三、实现思路: 采用...
  • 操作系统可以使用一种称为重定位的技术来管理每个进程在内存中的存储位置。 操作系统核心模块通常存储在最高的内存地址中。 当程序编译并执行时,它从零地址位开始处理,最大地址等于总内存大小减去操作系统大小。 ...
  • 当进程在CPU上运行时,如指令中涉及逻辑地址时,操作系统自动根据页长得到页号和页内偏移,把页内偏移拷贝到物理地址寄存器,再根据页号,查页表,得到该页在内存中的块号,把块号左移页长的位数,写到物理地址...
  • 操作系统实验2—实现动态分区分配模拟程序 文章目录操作系统实验2—实现...本实验要求学生独立设计实现可分区管理方式下的内存分配回收模拟程序,以加深对各种分配回收算法和分区存储管理方式及其实现过程的
  • 掌握内存管理的相关内容,对内存分配回收有深入的理解。 2.具体要求 (1)选择1~3种内存分配算法(最先适应、最佳适应、最坏适应)实现内存分配 (2)能够输入给定的内存大小、进程个数、每个进程申请的内存空间 ...
  • 初始状态:动态分区管理方式预先不将主存划分区域。而是把主存除操作系统占用区域外的空间看作一个大的空闲区。当作业要求装入主存时,根据作业的大小查询主存内各空闲区。并按照特定的算法选择一合适的空闲区,按...
  • C++实现动态分区方式的模拟

    千次阅读 2020-06-12 21:01:23
    C++实现动态分区分配方式的模拟动态分区分配方式的模拟一、实验目的二、实验环境三、实验内容四、C++实现代码 动态分区分配方式的模拟 一、实验目的 了解动态分区分配方式中使用的数据结构和分配算法,并进一步加深...
  • 这是一个纯虚的函数, MemMgr的两个子类FirstAdapter(首次适应算法),OptiAdapter(最佳适应算法)分别实现了那个纯虚函数, 表示了当有size大小的内存分配需求时, 所采取的不同分配算法, 如果还有其他的分配算法,...
  • 设计一个模拟内存管理中采用“动态分区”方式的存储器管理程序,实现以下操作: (1)以链接存储结构建立内存分配表、内存空闲表并进行初始化; (2)动态申请一段内存,对该段内存进行“动态分区”方式的管理,选择...
  • 目前的配置方案有两种:寄存器、内存、外存相配合寄存器、高速缓存、内存、外存相配合存储管理的基本任务储存空间的分配和回收地址变换存储共享和保护存储器扩充提高主存储器的利用率地址重定位逻辑地址空间程序经过...
  • 操作系统 实验3【动态分区存储管理
  • 使用动态分区分配方式的模拟1、实验目的了解动态分区分配方式中使用的数据结构和分配算法,并进一步加深对动态分区存储管理方式及其实现过程的理解。2、实验内容(1) 用C语言分别实现采用首次适应算法和最佳适应算法...
  • C++模拟动态内存管理

    万次阅读 2018-05-17 22:20:24
    使用链表对进程进行存储,每个节点记录、 下一个进程的占用内存的大小 起始地址 执行时间 下一个进程的地址 随机生成进程(空间大小、执行时间) ...* title :C++模拟动态内存管理 * author ...
  • [Java教程]使用动态分区分配方式的模拟0 2015-12-06 17:00:341实验目的(1)了解动态分区分配方式中使用的数据结构和分配算法(2)加深对动态分区存储管理方式及其实现过程的理解。2实验内容(1)分别实现采用首次适应算法...
  • C++动态内存管理总结

    2021-05-08 18:55:43
    内存分区、其作用及原因2.C动态内存管理方式3.C++动态内存管理方式4.定位new表达式5.内存泄露相关6.常见的内存池思想7.面试题:new和malloc的区别 1.内存分区、其作用及原因 2.C动态内存管理方式 C的动态内存管理...
  • packagememory;importjava.util.ArrayList;importjava.util.Collection;importjava.util.Scanner;public classMain {static ArrayList list =... //建立一个链表,来表示内存的使用情况static Scanner sc = newScann...
  • 设物理内存320KB,输入进程名,进程长度,到达时间以及执行时间来自动模拟动态分区管理,并显示可用表与分区说明表的变化情况 例如: 进程 进程长度(KB) 到达时间 执行...
  • 第八章 内存管理

    2019-03-03 18:33:00
    思维导图: 内存管理流程 地址空间的不对应 ...地址重定位 逻辑地址向物理地址转换 存储管理方式 单处理分配 固定分配 ...
  • 湖 南 文 理 学 院 实 验 报 告课程名称 操作系统课程设计实验名称 存储管理——动态分区分配算法的模拟成绩学生姓名 曹乐 专业 计算机班级、学号 13101 18同组者姓名实验日期 12.21实验目的通过这次实验,加深对...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,665
精华内容 2,666
关键字:

动态可重定位分区内存管理模拟设计与实现