投稿
  1. 首页
  2. 随笔

*** 作系统C语言模拟内存分配算法的模拟实现

奥地利签证 • 2022-12-13 • 随笔 • 阅读 126

*** 作系统C语言模拟内存分配算法的模拟实现,第1张

*** 作系统C语言模拟内存分配算法的模拟实现

使用一个一维数组来模拟内存储空间，建立内存块来记录内存分配使用情况，通过随机产生进程及其所需要的内存来模拟真实的进程。通过给进程分配内存及回收来实现对动态不等长存储管理方法。
代码

#include "math.h"
//#include "stdafx.h"
#include "stdio.h"
#include "stdlib.h"
typedef struct MEMORY_BLOCK
{
	 int name;//进程名称 
	 int address;//地址空间 
     int length;
	 int flag;//判断是否被占用 1为被占用   ，0为空闲 
	 MEMORY_BLOCK *next;
}MEMORY_BLOCK;
int allocation(MEMORY_BLOCK *Header,int name,int time);//使用 
int reclaim(int processname, MEMORY_BLOCK *Header);//回收 
int main()
{
 #define NUM 10    //定义了10个进程 
 int time,i;
 MEMORY_BLOCK *Header,*t;
 Header=new MEMORY_BLOCK;  //初始化存储空间
 Header->name=-1;
 Header->address=0;
 Header->length=100;
 Header->flag=0;
 Header->next=NULL;
 srand(100);
// printf("hahahhaha%dn",i);
 for(i=0;iname,t->address,t->length,t->flag);
  t=t->next;
 }
 ///
 int a=0;
 printf("请输入您要回收的进程：n");
 scanf("%d",&a);

 	if(a>0&&a<10){
 	 int processname=a;//回收
    printf("回收 process name %dn",processname);
    reclaim(processname,Header);
    t=Header;
 while(t!=0)
 {
  printf("process name %d, address=%d, length=%d,flag=%dn"
		,t->name,t->address,t->length,t->flag);
  t=t->next;
 }
 }else{
 	printf("您输入的进程不存在！n");
 }
 
 /// 
  return 1;

}

int reclaim(int processname, MEMORY_BLOCK *Header)
{
	 MEMORY_BLOCK *temp,*t,*tt;
	t=Header;
 temp=t;
 while(t->name!=processname)
 {
  temp=t;
  t=t->next;
 } 
 if(t==0) {printf("no process");return 0;}
  else
  { if(t->next!=NULL)
   if(temp->flag==0&&t->next->flag==0)//左右为空
   {  temp->name=-1;
      temp->length=temp->length+t->length+t->next->length;
	  tt=t->next;
	  temp->next=tt->next;
	  delete tt;
	  delete t;
   }
     else if(temp->flag==0) //左为空
	 {
      temp->name=-1;
      temp->length=temp->length+t->length;
	  temp->next=t->next;
	  delete t;
	 }
	 else if(t->next->flag==0) //右为空
	 {
	  t->name=-1;
      t->length=t->length+t->next->length;
	  t->flag=0;
	  tt=t->next;
	  t->next=tt->next;
	  delete tt;
	 }
	 else {
	  t->name=-1;
	  t->flag=0;
	 }
	else
		{
		if(temp->flag==0) //左为空
	 {
      temp->name=-1;
      temp->length=temp->length+t->length;
	  temp=t->next;
	  delete t;
	 }
	 else {
	  t->name=-1;
	  t->flag=0;
	 }
		}
  }
	return 1;
}

int allocation(MEMORY_BLOCK *Header,int name,int time)
{
	MEMORY_BLOCK *temp,*t,*tt;
	int thresh=2;
	t=Header;
  while(t!=0)
  {
	if(t->length>time&&t->flag==0) break;
    t=t->next;
  }
  if(t==0) { printf("no memory :%dn",name); return 0;}
  else{
          
		  if(t->length-time>thresh) //分割
		  {
           	  temp=new MEMORY_BLOCK;
              temp->name=-1;
              temp->flag=0;
			  temp->length=t->length-time;
	          temp->address=t->address+time;
              t->name=name;
              t->flag=1;
	          t->length=time;
              temp->next=t->next;
			  t->next=temp;
		  }
		  else  //直接分配
		  {
              t->name=name;
              t->flag=1;         
		  }
  }
	return 1;
}

实验五 存储管理实验

一、 实验类型
本实验为综合性实验。

二、 实验目的与任务
1） 理解动态异长存储分区资源管理
2） 掌握所需数据结构和管理程序
3） 了解各种存储分配算法的优点和缺点。
4） 编程实现动态不等长存储管理的模拟程序。

三、 预习要求
1） 进程控制的概念及内容
2） 熟悉存储管理的概念
3） 了解动态分区管理的思想，熟悉分配算法和回收算法
4） 熟悉c语言编程，指针及结构体等知识
5） 数据结构中的链表的建立及基本 *** 作

四、 实验基本原理
使用一个一维数组来模拟内存储空间，建立内存块来记录内存分配使用情况，通过随机产生进程及其所需要的内存来模拟真实的进程。通过给进程分配内存及回收来实现对动态不等长存储管理方法。

五、 实验仪器与设备（或工具软件）
实验设备：计算机一台，软件环境要求：安装Red Hat Linux *** 作系统和gcc编译器。

六、 实验内容
1） 实验中使用的数据结构
(1) 内存块表，包括参数①进程名name；②起始地址 address；③长度 length；④标志 flag，表示该块是否被分配。
(2) 为简单起见，只设内存分配记录链表数据结构，用来记录内存分配与空闲情况。
2） 实验中假设有若干个进程，如5个，每个需要空间随机产生，为0~20之间的整数，进程名字实验者自己定义，可以是一个整数。
3） 其他一些参数，如内存空间的大小实验者自己定义，建议为100；
4） 为了得到清晰的实验结果，建议先给每个进程分配存储空间，后进行回收。
5） 程序的流程图如图5.1, 图5.2, 图5.3

图5.3回收流程图
6） 参考程序
#include “math.h”
#include “stdafx.h”
#include “stdio.h”
#include “stdlib.h”
typedef struct MEMORY_BLOCK
{
int name;
int address;
int length;
int flag;
MEMORY_BLOCK *next;
}MEMORY_BLOCK;
int allocation(MEMORY_BLOCK *Header,int name,int time);
int reclaim(int processname, MEMORY_BLOCK *Header);
int main()
{
#define NUM 10
int time,i;
MEMORY_BLOCK *Header,*t;
Header=new MEMORY_BLOCK; //初始化存储空间
Header->name=-1;
Header->address=0;
Header->length=100;
Header->flag=0;
Header->next=NULL;
srand(100);
for(i=0;i {
time=rand()%20; // time=time%20;
allocation(Header,i,time);
}
t=Header;
while(t!=NULL)
{
printf(“process name %d, address=%d, length=%d,flag=%dn”
,t->name,t->address,t->length,t->flag);
t=t->next;
}
int processname=3;//回收
printf(“回收 process name %dn”,processname);
reclaim(processname,Header);
t=Header;
while(t!=0)
{
printf(“process name %d, address=%d, length=%d,flag=%dn”
,t->name,t->address,t->length,t->flag);
t=t->next;
}
processname=4;
printf(“回收 process name %dn”,processname);
reclaim(processname,Header);
t=Header;
while(t!=0)
{
printf(“process name %d, address=%d, length=%d,flag=%dn”
,t->name,t->address,t->length,t->flag);
t=t->next;
}
return 1;
}
int reclaim(int processname, MEMORY_BLOCK *Header)
{
MEMORY_BLOCK *temp,*t,*tt;
t=Header;
temp=t;
while(t->name!=processname)
{
temp=t;
t=t->next;
}
if(t0) {printf(“no process”);return 0;}
else
{ if(t->next!=NULL)
if(temp->flag0&&t->next->flag0)//左右为空
{ temp->name=-1;
temp->length=temp->length+t->length+t->next->length;
tt=t->next;
temp->next=tt->next;
delete tt;
delete t;
}
else if(temp->flag0) //左为空
{
temp->name=-1;
temp->length=temp->length+t->length;
temp->next=t->next;
delete t;
}
else if(t->next->flag0) //右为空
{
t->name=-1;
t->length=t->length+t->next->length;
t->flag=0;
tt=t->next;
t->next=tt->next;
delete tt;
}
else {
t->name=-1;
t->flag=0;
}
else
{
if(temp->flag0) //左为空
{
temp->name=-1;
temp->length=temp->length+t->length;
temp=t->next;
delete t;
}
else {
t->name=-1;
t->flag=0;
}
}
}
return 1;
}

int allocation(MEMORY_BLOCK *Header,int name,int time)
{
MEMORY_BLOCK *temp,*t,*tt;
int thresh=2;
t=Header;
while(t!=0)
{
if(t->length>time&&t->flag0) break;
t=t->next;
}
if(t0) { printf(“no memory :%dn”,name); return 0;}
else{

	  if(t->length-time>thresh) //分割
	  {
       	  temp=new MEMORY_BLOCK;
          temp->name=-1;
          temp->flag=0;
		  temp->length=t->length-time;
          temp->address=t->address+time;
          t->name=name;
          t->flag=1;
          t->length=time;
          temp->next=t->next;
		  t->next=temp;
	  }
	  else  //直接分配
	  {
          t->name=name;
          t->flag=1;         
	  }

}
return 1;
}
7） 编写测试程序，对存储分配表进行初始化，存储分配情况和回收一个进程的存储空间后的结果在屏幕上显示出来，显示的结果如图5.4所示。

图5.4模拟输出的示意图
七、 实验步骤
1） 进入vi编辑器
2） 在编译器中输入所要运行的程序代码
3） 退出编辑器，返回命令行输入方式，使用gcc编译器编译程序，获得能运行的目标程序。
4） 运行目标程序，查看运行结果。

八、 注意事项
1） 随机数的产生由rand()函数实现，rand()的输出随机数范围在0215之间，需要转换到020范围。
2） 节点的删除和插入方式。
3） 回收内存空间时，分四种情况讨论是否需要合并。

九、 实验报告要求
需要列出运行了的程序清单及相应结果，并对结果进行分析和讨论。对结果的分析主要讨论首次适应存储分配算法的优缺点,实验结果是如何体现的？

欢迎分享，转载请注明来源：内存溢出

原文地址: https://outofmemory.cn/zaji/5521105.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
奥地利签证 奥地利签证 一级用户组
0 0
上一篇 2022-12-13
下一篇 2022-12-13

发表评论

登录后才能评论

评论列表（0条）

保存