實驗四主存空間的分配和回收模擬

時間 2019-12-20

標籤實驗空間分配回收模擬简体版

原文原文鏈接

1. 實驗目的

爲了合理地分配和使用這些存儲空間，當用戶提出申請主存儲器空間時，存儲管理必須根據申請者的要求，按必定的策略分析主存空間和使用狀況，找出足夠的空閒區域給申請者。看成業撤離歸還主存資源時，則存儲管理要收回佔用的主存空間。主存的分配和回收的實現是與主存儲器的管理方式有關的，經過本實驗幫助咱們理解在不一樣的存儲管理方式下應怎樣實現主存空間的分配和回收。算法

用高級語言完成一個主存空間的分配和回收模擬程序，以加深對內存分配方式及其算法的理解。函數

2. 實驗內容

2.1 模擬包括3部分：學習

1）實現特定的內存分配算法編碼

2）實現內存回收模擬設計

3）每種內存分配策略對應的碎片數統計指針

2.2 固定分區存儲管理調試

假設內存容量爲120KB，而且分別劃分紅8,16,32,64KB大小的塊各一塊。blog

一個進程所須要的內存爲0到100個KB。同時假設一個進程在運行過程當中所需內存的大小不變。進程

模擬五個進程到達請求分配與運行完回收狀況,輸出主存分配表.內存

2.3 動態分區分配存儲管理

採用連續分配方式之動態分區分配存儲管理，使用首次適應算法、下次適應算法、最佳適應算法和最壞適應算法4種算法完成設計(任選兩種算法)。

（1）在程序運行過程，由用戶指定申請與釋放。

（2）設計一個已佔用分區表，以保存某時刻主存空間佔用狀況。

（3）設計一個空閒分區表，以保存某時刻主存空間剩餘狀況。

（4）用兩個表的變化狀況,反應各進程所需內存的申請與釋放狀況。

3. 實驗環境

根據指定的實驗課題，完成設計、編碼和調試工做，完成實驗報告。

能夠選用Turbo C做爲開發環境。也能夠選用Windows下的VB，CB或其餘可視化環境，利用各類控件較爲方便。自主選擇實驗環境。

四、實驗代碼和截圖

#include <stdio.h>
#include <stdlib.h>
#include <string.h> 
const int CANUSE = 1;
const int CANTUSE = 0;
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("內存的使用狀況\n");
     printf("beginaddr\tlength\tstate\ttask\n");     
     while( NULL!=Mpoint)
     {
         printf("%dk\t\t",Mpoint->begin_addr);
         printf("%dk\t",Mpoint->length);
         Mpoint->state?printf("CANUSE\t"):printf("CANTUSE\t");
         printf("%s\n",Mpoint->task_name);
         Mpoint = Mpoint->next;
     } 
     system("pause");      
}
 
//memoallocate函數，用於分配內純 
void memoallocate(void)
{
     struct MZone *Mnew = (struct MZone*)malloc(sizeof(struct MZone));
     printf("輸入要分配內存大小(kb):\n");
     scanf("%d",&Mnew->length);
     printf("輸入任務名:\n");
     scanf("%s",&Mnew->task_name);
     Minsert(Mnew)?printf("分配內存成功\n"):printf("沒有符合大小的空閒分區，內存分配失敗。\n"); 
     system("pause");
     free(Mnew);
}
 
//Minsert函數，功能插入任務到空閒分區 
int Minsert(struct MZone* Mnew)
{
 
     struct MZone *Zinsert = Mhead;   
     int flag = 1;      //flag用於指示是Zinsert到了NULL，既沒有內存能夠分配
     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("輸入要收回的任務名\n");
     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("內存回收成功！\n");
   }
}
  
int main(void)
{
     int func_ = 0;         
     Mhead = (struct MZone*)malloc(sizeof(struct MZone));//初始化Mhead 
     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:查看內存分配狀況\n");
           printf("|2:申請分配內存\n");
           printf("|3:申請回收內存\n");
           printf("|4:退出程序\n");
           printf("********************************************************************************");
           scanf("%d",&func_);
           switch( func_ )
           {
                   case 1 :showmemory();break;
                   case 2 :memoallocate();break;
                   case 3 :memoreturn();break; 
                   case 4 :return 1;
           }
           system("cls");
     }       
}