实验五

一、        实验目的

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

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

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

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

二、        实验内容和要求

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

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

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

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

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

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

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

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

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

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

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

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

     1 #include"stdio.h"
     2 #include"stdlib.h"
     3 #include"time.h"
     4 struct wuli{
     5     int wuli_number;
     6     char pname; /*已分配区表登记栏标志，用"0"表示空栏目*/
     7 }; /*内存表*/
     8 struct wuli wuli_table[20]={0};
     9 struct page{ 
    10     
    11     char pname;//进程名称
    12     int psize;//进程大小  
    13     int pagetable[10];//进程页表
    14 };//页表
    15 struct page page_table[10]={0};
    16 
    17 int allocate(int wulisize,int i,int pagesize);//为进程分配内存空间
    18 int reclaim(int wulisize,char pname);//释放进程占用的空间
    19 
    20 void output();
    21 int main()
    22 {
    23     int pagesize;//分页大小
    24     int wulisize=80;//内存大小
    25     char pname;
    26     int xuanze;//操作选择
    27     int i;
    28     
    29     printf("输入页面大小：\n");
    30     scanf("%d",&pagesize);
    31     //初始化
    32     for(i=0;i<20;i++)
    33     {
    34         wuli_table[i].wuli_number=i;
    35         wuli_table[i].pname='0';
    36     }
    37     for(i=0;i<10;i++)
    38     {
    39         page_table[i].pname='0';
    40         
    41     }
    42     //初始化后的内存空间有一部分已经被使用
    43     srand((unsigned)time(NULL));
    44     for(i=0;i<7;i++)
    45     {
    46         
    47         int number=rand()%19+1;
    48         wuli_table[number].pname='a';
    49         wulisize--;
    50     }
    51     output();
    52     //进入存储分配
    53     while(wulisize!=0)
    54     {
    55         printf("选择操作\n1.分配  2.回收\n");
    56         scanf("%d",&xuanze);
    57         if(xuanze==1)
    58         {
    59             for( i=0;i<10;i++)
    60             {
    61                 if(page_table[i].pname=='0')
    62                 {
    63                     getchar();
    64                     printf("输入进程名称：");
    65                     scanf("%c",&page_table[i].pname);
    66                     getchar();
    67                     printf("输入进程大小：");
    68                     scanf("%d",&page_table[i].psize);
    69                     break;
    70                 }
    71             }
    72             wulisize=allocate(wulisize,i,pagesize);
    73         }else
    74         {
    75             printf("输入进程名称：");
    76             getchar();
    77             scanf("%c",&pname);
    78             wulisize=reclaim(wulisize,pname);
    79         }
    80         
    81         output();
    82     }
    83     
    84     
    85     return 0;
    86 }
    87 
    88 
    89 
    90 int  allocate(int wulisize,int i,int pagesize)
    91 {
    92     int k;
    93     int j;
    94     for(k=0;k<(page_table[i].psize/pagesize);k++)
    95     {
    96         for( j=0;j<20;j++)
    97         {
    98             if(wuli_table[j].pname=='0')
    99             {
   100                 wuli_table[j].pname=page_table[i].pname;
   101                 page_table[i].pagetable[k]=j;
   102                 wulisize--;
   103                 break;
   104                 
   105             }
   106         }
   107         
   108     }
   109     return wulisize;
   110 }
   111 
   112 int reclaim(int wulisize,char pname)
   113 {
   114     int j;
   115     int k;
   116     for( j=0;j<20;j++)
   117     {
   118         if(wuli_table[j].pname==pname)
   119         {
   120             wuli_table[j].pname='0';
   121             
   122             wulisize++;
   123             
   124             
   125         }
   126     }
   127     for (j=0;j<10;j++)
   128     {
   129         if(page_table[j].pname==pname)
   130         {
   131             page_table[j].pname='0';
   132             page_table[j].psize=0;
   133             for(k=0;k<10;k++)
   134             {
   135                 page_table[j].pagetable[k]=0;
   136             }
   137             
   138             break;
   139             
   140         }
   141     }
   142     return wulisize;
   143 }
   144 
   145 
   146 
   147 void output(){
   148     int i;
   149     printf("————————内存分配情况——————————\n");
   150     printf("物理块号   进程名\n");
   151     for(i=0;i<20;i++)
   152     {
   153         
   154         printf("%d         %c\n",wuli_table[i].wuli_number , wuli_table[i].pname);
   155     }
   156 }

   1. 1.      运行结果及分析
   2. 
   3. 
   4. 

      结果符合预期

       

      一、        实验总结

      刚开始做实验的时候根本没搞懂存储的方式是怎么样的，再加上心很急，就马上想写出代码出来，结果写了两节课都没写出来。后来静下心来，仔细翻阅了课本，就很快地写出来了。