实验四

标签：

一、        实验目的

连续内存分配方式会形成许多“碎片”，虽然可以通过“紧凑”方法将许多碎片拼接成可用的大块空间，但须为之付出很大开销。如果允许将一个进程直接分散地装入到许多不相邻接的分区中，则无需再进行“紧凑”。基于这一思想而产生了离散分配方式。

如果离散分配的基本单位是页，则称为分页存储管理方式；如果离散分配的基本单位是段，则称为分段存储管理方式。  

在分页存储管理方式中，如果不具备页面兑换功能，则称为基本的分页存储管理方式，或称为纯分页存储管理方式，它不具备支持虚拟存储器的功能，它要求把每个作业全部装入内存后方能运行。

本实验通过程序模拟操作系统的基本分页存储管理方式，进一步理解这一内存分配方式的原理和特点，加深对理论知识的掌握。 

二、        实验内容和要求

实验要求：1、用C语言或Java语言编写程序模拟操作系统对内存的基本分页存储管理方式  

2、程序要能正确对“内存”进行“分配”和“回收”，能接受用户的输入，显示内存的分配情况，并有一定的容错能力。  

3、每个人独立按时完成实验内容。

实验内容：本实验假定内存空间已经按块划分，目标程序无需关心内存块大小等底层细节，只需按算法对内存块进行分配即可。程序应该实现以下功能：

  1、内存初始化。假定内存块共有N个，初始化后的内存空间应该有一部分已经被使用，这可以用随机数或程序内部的其他算法完成。

  2、程序应该能接受用户输入的进程信息，并为之分配内存，返回分配结果（成功或失败），注意，此处应该考虑到不合法的输入并进行相应处理。

  3、程序能回收用户指定的进程所占用的内存空间，因此，程序可能需要为每个进程分配一个唯一的进程号并给出详细的提示信息。

  4、能直观合理地显示内存分配情况。

  5、程序界面友好，便于操作和查看运行结果。 

三、        实验方法、步骤及结果测试

源程序名：分页存储管理.cpp

1. 1.      主要程序段及其解释：

   #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; 
   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");
         
   }
   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);
   }
   int Minsert(struct MZone* Mnew)
   {
    
        struct MZone *Zinsert = Mhead;
        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;
        }
   }
   void memoreturn(void)
   {
        char tname[32];
        printf("输入要收回的任务名\n");
        scanf("%s",tname);
        Mreturn(tname); 
        system("pause"); 
   } 
   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
       { 
         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->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");
        }       
   }

   

实验四

标签：

原文地址：http://www.cnblogs.com/0lwbin/p/4601328.html