实验四主存空间的分配和回收模拟

实验四 主存空间的分配和回收模拟

1. 实验目的

为了合理地分配和使用这些存储空间，当用户提出申请主存储器空间时，存储管理必须根据申请者的要求，按一定的策略分析主存空间和使用情况，找出足够的空闲区域给申请者。当作业撤离归还主存资源时，则存储管理要收回占用的主存空间。主存的分配和回收的实现是与主存储器的管理方式有关的，通过本实验帮助我们理解在不同的存储管理方式下应怎样实现主存空间的分配和回收。

用高级语言完成一个主存空间的分配和回收模拟程序，以加深对内存分配方式及其算法的理解。

2. 实验内容

2.1 模拟包括3部分：

1）实现特定的内存分配算法

2）实现内存回收模拟

3）每种内存分配策略对应的碎片数统计

2.2 固定分区存储管理

假设内存容量为120KB，并且分别划分成8,16,32,64KB大小的块各一块。

一个进程所需要的内存为0到100个KB。同时假设一个进程在运行过程中所需内存的大小不变。

模拟五个进程到达请求分配与运行完回收情况,输出主存分配表.

2.3 动态分区分配存储管理

采用连续分配方式之动态分区分配存储管理，使用首次适应算法、下次适应算法、最佳适应算法和最坏适应算法4种算法完成设计(任选两种算法)。

（1）在程序运行过程，由用户指定申请与释放。

（2）设计一个已占用分区表，以保存某时刻主存空间占用情况。

（3）设计一个空闲分区表，以保存某时刻主存空间剩余情况。

（4）用两个表的变化情况,反应各进程所需内存的申请与释放情况。

3. 实验环境

根据指定的实验课题，完成设计、编码和调试工作，完成实验报告。

可以选用Turbo C作为开发环境。也可以选用Windows下的VB，CB或其他可视化环境，利用各种控件较为方便。自主选择实验环境。

4. 实验代码

我自己编写，但是没有完成的代码，都不知道该怎么去实现

#include<stdio.h>
typedef struct AAA{ 
char name[10];  //名字
int  need;    //所需空间
}ABC;

typedef struct BBB{
char name[10];
int  ka;       //开始地址
int  ja;       //结束地址
}XZM           //未分配
typedef struct CCC{
char name[10];
int  ka;       //开始地址
int  ja;       //结束地址
}WZJ           //已分配


int n,which,aaa=0,bbb;
int address=512;  //内存大小
int system=100;   //系统所需内存
ABC www[5];
XZM yyy[5];       // 未分配
WZJ zzz[5];       //已分配


show()
{
    printf("已分配表
");
    printf("名字      开始地址         结束地址");
    for(bbb=0;bbb<aaa;bbb++)
    {
        printf("%s      %d      %d",zzz[bbb].name,zzz[bbb].ka,zzz[bbb].ja);     
    }
    printf("未分配表
");
    printf("名字      开始地址         结束地址");
    for(bbb=0;bbb<aaa;bbb++)
    {
        printf("%s      %d      %d",yyy[bbb].name,yyy[bbb].ka,yyy[bbb].ja);     
    }
}


getit()
{

printf("
请选择：1.录入进程   2.回收进程");
scanf("%d",&n);
if(n==1)
{
printf("
现在请输入各进程的详细信息：
");
printf("进程名字 所需空间
");
scanf("%s",&www[aaa].name);
scanf("%d",&www[aaa].nt);
aaa++;
}
else
{
printf("
请输入要撤回的进程的");
scanf("%d",&n);
}

}


first()
{
    

}


next()
{

}







select()
{
int i;
zzz[0].name="system";
zzz[0].ka=0;
zzz[0].ja=system;
printf("
-------------------------美好生活从这里开始!------------------------
");
printf("主存空间的分配和回收模拟：

	1,首次适应 

	2,下次适应
");
printf("请选择：
");
scanf("%d",&i);
if(i==1)
{
printf("
您选择的是首次适应
");
getit();

}
if(i==2)
{
printf("
您选择的是下次适应
");
getit();

}
if(i>3)
{
printf("
输入错误,请输入1-2之间的数!
重新开始:
");
}
}
void main()
{
select(); 
}

我在网上查找的，然后查考的代码

#include"stdio.h"

#include"stdlib.h"

#define n 10 /*假定系统允许的最大作业为n，假定模拟实验中n值为10*/

#define m 10 /*假定系统允许的空闲区表最大为m，假定模拟实验中m值为10*/

#define minisize 100

struct{

float address; /*已分分区起始地址*/

float length; /*已分分区长度，单位为字节*/

int flag; /*已分配区表登记栏标志，用"0"表示空栏目*/

}used_table[n]; /*已分配区表*/

struct{

float address; /*空闲区起始地址*/

float length; /*空闲区长度，单位为字节*/

int flag; /*空闲区表登记栏标志，用"0"表示空栏目，用"1"表示未分配*/

}free_table[m]; /*空闲区表*/

void main( )

{

int i,a;

void allocate(char str,float leg);//分配主存空间函数

void reclaim(char str);//回收主存函数

float xk;

char J;/*空闲分区表初始化：*/

free_table[0].address=10240;

free_table[0].length=102400;

free_table[0].flag=1;

for(i=1;i<m;i++)

free_table[i].flag=0;/*已分配表初始化：*/

for(i=0;i<n;i++)

used_table[i].flag=0;

while(1)

{

printf(" 选择功能项（0-退出,1-分配主存,2-回收主存,3-显示主存） ");

printf("选择功项(0~3) :");

scanf("%d",&a);

switch(a)

{

case 0: exit(0); /*a=0程序结束*/

case 1: /*a=1分配主存空间*/printf("输入作业名J和作业所需长度xk: ");

scanf("%*c%c%f",&J,&xk);

allocate(J,xk);/*分配主存空间*/

break;

case 2: /*a=2回收主存空间*/printf("输入要回收分区的作业名");

scanf("%*c%c",&J);reclaim(J);/*回收主存空间*/

break;

case 3: /*a=3显示主存情况*//*输出空闲区表和已分配表的内容*/

printf("输出空闲区表：起始地址分区长度标志 ");

for(i=0;i<m;i++)

printf("%6.0f%9.0f%6d ",free_table[i].address,free_table[i].length, free_table[i].flag);

printf(" 按任意键,输出已分配区表 ");

getchar();

printf(" 输出已分配区表：起始地址分区长度标志 ");

for(i=0;i<n;i++)

if(used_table[i].flag!=0)

printf("%6.0f%9.0f%6c ",used_table[i].address,used_table[i].length, used_table[i].flag);

else

printf("%6.0f%9.0f%6d ",used_table[i].address,used_table[i].length, used_table[i].flag);

break;

default:printf("没有该选项 ");

}/*case*/

}/*while*/

}/*主函数结束*/

int uflag;//分配表标志

int fflag;//空闲表标志

float uend_address;

float fend_address;

void allocate(char str,float leg)

{

int k,i;

float ressize;

uflag=0;

fflag=0;

for(i=0;i<m;i++)

{

if(free_table[i].flag==1 && free_table[i].length>=leg)

{

fflag=1;break;

}

if(fflag==0)

printf("没有满足条件的空闲区 ");

else

{

ressize=free_table[i].length-leg;

for(k=0;k<n;k++)

{

if(used_table[k].flag==0)

{

if(ressize<minisize)//剩余块过小

{

used_table[k].length=free_table[i].length;

used_table[k].address=free_table[i].address;

used_table[k].flag=str;

free_table[i].length=0;

free_table[i].flag=0;

break;

}

else

{

used_table[k].address=free_table[i].address+ressize;

used_table[k].flag=str;

used_table[k].length=leg;

free_table[i].length=ressize;

break;

}

}//for结束

}

void reclaim(char str)

{

int k,i;

uflag=0;fflag=0;

for(k=0;k<n;k++)

{

if(used_table[k].flag==str)

{

uflag=1;break;

}

if(uflag==0)

printf(" 找不到该作业! ");

else

{

for(i=0;i<m;i++)

{

uend_address=used_table[k].address+used_table[k].length;

fend_address=free_table[i].address+free_table[i].length;

if(used_table[k].address==fend_address)//上邻

{

fflag=1;

free_table[i].length=free_table[i].length+used_table[k].length;

free_table[i].flag=1;

used_table[k].flag=0;

used_table[k].length=0;

used_table[k].address=0;

printf(" 已回收! ");

break;

}

else

{

if(free_table[i].address==uend_address)//下邻

{

fflag=1;

free_table[i].address=used_table[k].address;

free_table[i].length=free_table[i].length+used_table[k].length;

free_table[i].flag=1;

used_table[k].flag=0;

used_table[k].length=0;

used_table[k].address=0;

printf(" 已回收! ");

break;

}

}//for结束

if(fflag==0)

{

i=0;

for(i=0;i<m;i++)

{

if(free_table[i].flag==0)

{

free_table[i].address=used_table[k].address;

free_table[i].length=used_table[k].length;

free_table[i].flag=1;

used_table[k].length=0;

used_table[k].flag=0;

used_table[k].address=0;

break;

}

printf(" 已回收! ");

}

这是首次适应的

#include <stdio.h>
#include <stdlib.h>
#include <string.h> 
const int CANUSE = 1;
const int CANTUSE = 0;
//#define  MSIZE  128;
const int MSIZE = 128;
 
 
//内存分区 
struct MZone
{
       //空闲区起始地址 
    int begin_addr; 
       //一个连续空闲区的长度
    int length;       
       //状态 
    int state;
       //内存中任务名
    char task_name[32];    
       //指向下一个空闲分区
    struct MZone *next;    
};
 
//内存头指针 
struct MZone *Mhead = NULL;
 
//showmemory函数，显示当前内存分配情况 
void showmemory()
{
     struct MZone *Mpoint = Mhead;
      
     printf("内存的使用情况
");
     printf("beginaddr	length	state	task
"); 
      
     while( NULL!=Mpoint)
     {
         printf("%dk		",Mpoint->begin_addr);
         printf("%dk	",Mpoint->length);
         Mpoint->state?printf("CANUSE	"):printf("CANTUSE	");
         printf("%s
",Mpoint->task_name);
         Mpoint = Mpoint->next;
     } 
     
     system("pause");
      
}
 
//memoallocate函数，用于分配内纯 
void memoallocate(void)
{
     struct MZone *Mnew = (struct MZone*)malloc(sizeof(struct MZone));
     printf("输入要分配内存大小(kb):
");
     scanf("%d",&Mnew->length);
     printf("输入任务名:
");
     scanf("%s",&Mnew->task_name);
     Minsert(Mnew)?printf("分配内存成功
"):printf("没有符合大小的空闲分区，内存分配失败。
"); 
     system("pause");
     free(Mnew);
}
 
//Minsert函数，功能插入任务到空闲分区 
int Minsert(struct MZone* Mnew)
{
 
     struct MZone *Zinsert = Mhead;
     //flag用于指示是Zinsert到了NULL，既没有内存可以分配 
     int flag = 1;   
      
     while( Zinsert->length<Mnew->length || !Zinsert->state)
     {
             if( NULL!=Zinsert->next )
             {
                Zinsert = Zinsert->next;
             }
             else
             {   
                 Zinsert = Zinsert->next;
                 break;
             }
             
     }
      
     if( NULL==Zinsert ) 
     {
         return 0;
     }
     
     if( MSIZE == Zinsert->begin_addr+Mnew->length )
     {
          Zinsert->state = CANTUSE;
          strcpy(Zinsert->task_name , Mnew->task_name);
          Zinsert->next = NULL;
          return 1;
     }
     else
     {
         struct MZone *Ztail = (struct MZone *)malloc(sizeof(struct MZone));
         Zinsert->state = CANTUSE;
         strcpy(Zinsert->task_name , Mnew->task_name);
         Zinsert->length = Mnew->length;
         Zinsert->next = Ztail;
          
         memset( Ztail, 0, sizeof(char)*32 );
         Ztail->begin_addr = Zinsert->begin_addr + Mnew->length;
         Ztail->state = CANUSE;
         Ztail->length = MSIZE - Ztail->begin_addr;
         Ztail->next = NULL;
          
         return 1;
     }
}
 
//memoreturn函数，用于回收内存
void memoreturn(void)
{
     char tname[32];
     printf("输入要收回的任务名
");
     scanf("%s",tname);
     Mreturn(tname); 
     system("pause"); 
} 
 
//Mreturn函数，功能回收内存
int Mreturn(char taskname[])
{
    struct MZone *front = NULL;
    struct MZone *position = Mhead;
    struct MZone *tail = Mhead->next;
     
    while( 0!=strcmp(position->task_name,taskname) ) 
    {
           front = position;
           if( NULL!=position->next )
           {
               position = position->next;
           }
           else
           {
               position = NULL;
               break;
           }
           tail = position->next;
    }
     
    if( NULL==position )
    {
        printf("内存中没有此任务！");   
    }
    else
    {
      //不能用CANTUSE 
      if( NULL!=tail&&NULL!=front )
       {
     
            if( front->state&&tail->state )
            {
                front->length = front->length + position->length + tail->length;
                front->next = tail->next;
                free(position);
                free(tail);
            }
            else if( front->state&&!tail->state )
            {
                front->length = front->length + position->length;
                front->next = position->next;
                free(position);
            }
            else if( !front->state&&tail->state )
            {
                position->length = position->length + tail->length;
                memset( position->task_name, 0, sizeof(char)*32 );
                position->next = tail->next;
                position->state = CANUSE;
                free(tail);
            }
            else if( !front->state&&!tail->state )
            {
                memset( position->task_name, 0, sizeof(char)*32 );
                position->state = CANUSE;   
            }
       }
       else if( NULL!=tail&&NULL==front )
       {
         if( !tail->state )
          {
             memset( position->task_name, 0, sizeof(char)*32 );
             position->state = CANUSE;
          }
          else
          {
             position->length = position->length + tail->length;
             position->next = NULL;
             free(tail);
          }
       } 
       else if( NULL==tail&&NULL!=front )
       {
         if(front->state)
          { 
              front->length = front->length + position->length;
              front->next = NULL;
              free(position);
          }
          else
          {
              memset( position->task_name, 0, sizeof(char)*32 );
              position->state = CANUSE;
          }
       }
       else if( NULL==tail&&NULL==front )
       {
            memset( position->task_name, 0, sizeof(char)*32 );
            position->state = CANUSE; 
       }
    printf("内存回收成功！
");
   }
}
  
int main(void)
{
     int func_ = 0;
      
     //初始化Mhead 
     Mhead = (struct MZone*)malloc(sizeof(struct MZone));
     Mhead->begin_addr = 0;
     Mhead->length = MSIZE;
     Mhead->state = CANUSE;
     memset(Mhead->task_name, 0, sizeof(char)*32 );
     Mhead->next = NULL;
      
     while( 1 )
     {
           printf("******************首次适应算法实现主存分配和回收系统（内存MSIZE）***************");
           printf("|1:查看内存分配情况
");
           printf("|2:申请分配内存
");
           printf("|3:申请回收内存
");
           printf("|4:退出程序
");
           printf("********************************************************************************");
           scanf("%d",&func_);
           switch( func_ )
           {
                   case 1 :showmemory();break;
                   case 2 :memoallocate();break;
                   case 3 :memoreturn();break; 
                   case 4 :return 1;
           }
           system("cls");
     }       
}

5. 实验截图

6、实验心得

因为这个实验我一直做不出来，所以一直没有提及作业，后来在网上查找了一些代码，然后看了一下。学习了其他人的编程思路。虽然这些算法的基本思想什么的都懂，但是要我编写出来的时候，我发现没那么简单，所以就看了其他人的，然后学习一下。也很抱歉自己没有写出来，因为一到学期末就各种大作业，所以也一直在忙其他的。对这门课，还有老师的辛勤教学都深深地抱歉。实验也一直没有截图什么的，我会回去补回去的。真的觉得每一个实验都对我们的学习很有帮助。

相关阅读:
android data binding jetpack I 环境配置 model-view 简单绑定
 java 直接内存
 Android内存管理机制
 使用老版本的java api提交hadoop作业
 通过java api提交自定义hadoop 作业
 hadoop错误总结
 linux下eclipse闪退和重装jdk的方法
 完全分布式安装hadoop
hadoop伪分布式安装
 2014年度总结
原文地址：https://www.cnblogs.com/MyDring/p/5101737.html

实验四 主存空间的分配和回收模拟

1. 实验目的

2. 实验内容

3. 实验环境

4. 实验代码

5. 实验截图

6、实验心得

实验四主存空间的分配和回收模拟