• 1230《操作系统教程》实验四 主存空间的分配和回收模拟


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

    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.    主要程序段及其解释

      1 #include<stdio.h>
      2 #include<stdlib.h>
      3 #include <conio.h>
      4 #define nil -1
      5 #define NULL 0
      6 #define maxisize 600    //用户的空闲区空间最大值
      7 #define minisize 4     
      8 #define getspace(type) (type*)malloc(sizeof(type)) //分配空间
      9 struct table{
     10     char job;                 //作业标号
     11     float address;            //分区起始地址
     12     float length;             //分区长度,单位为字节
     13     int flag;                 //分区表的状态位
     14     struct table *FRlink;     //前向指针
     15     struct table *RElink;    //后向指针
     16 }*free_table=NULL,*place;   //已分配分区表,空闲分区表
     17 typedef struct table FRtable;
     18 //空间分区链表初始化
     19 FRtable *init(FRtable *tb)
     20 {
     21     tb->FRlink=NULL;
     22     tb->job=nil;
     23     tb->address=1064;
     24     tb->length=1664;
     25     tb->flag=0;
     26     tb->RElink=NULL;
     27     return tb;
     28 }
     29 //主存分配函数,为作业job分配大小为xk的分区空间
     30 void allocate(char job,float xk,int choice)
     31 {
     32     FRtable *tb,*link;
     33     int k=0;
     34     float temp=600;
     35     if (free_table->FRlink==NULL&&free_table->RElink==NULL)
     36     {//给首个作业分配空间,改写分区链表
     37         free_table->job=job;
     38         free_table->length=xk;
     39         free_table->flag=1;
     40         if (xk<maxisize)
     41         {
     42             tb=getspace(FRtable);
     43             free_table->RElink=tb;
     44             tb->FRlink=free_table;
     45             tb->job=nil;
     46             tb->address=1064+xk;
     47             tb->length=maxisize-xk;
     48             tb->flag=0;
     49         }
     50         if (choice==2)
     51         {//链接成循环链表
     52             free_table->FRlink=tb;
     53             tb->RElink=free_table;
     54             place=tb;
     55         }
     56         else
     57         {
     58             free_table->FRlink=NULL;
     59             if (xk<maxisize) tb->RElink=NULL;
     60         }
     61         k=1;
     62     }
     63     else
     64     {
     65         if (2==choice) tb=place;//采用CFF时将ta定位到上次找到的合适空间分区的下个空间分区
     66         else tb=free_table;
     67         while(tb!=NULL)
     68         {
     69             if (3==choice)
     70             {
     71                 while(tb!=NULL)
     72                 {
     73                     if (tb->length>=xk&&tb->flag==0)
     74                         if (tb->length<temp)
     75                             {place=tb;temp=tb->length;}   //选择最适合空间
     76                     tb=tb->RElink;
     77                 }
     78                 tb=place;
     79             }
     80             if (tb->length>=xk&&tb->flag==0)
     81                 if (tb->length-xk<=minisize)
     82                 {//当搜索到的空间大小<=xk+minisize时,将空间全部分配给作业
     83                     tb->job=job;
     84                     tb->flag=1;
     85                     place=tb->RElink;
     86                     k=1;
     87                     break;
     88                 }
     89                 else
     90                 {//当搜索到的空间大小>xk+minisize时,将空间划分,再分配给作业
     91                     link=getspace(FRtable);
     92                     link->length=tb->length-xk;
     93                     tb->job=job;
     94                     tb->length=xk;
     95                     tb->flag=1;
     96                     link->RElink=tb->RElink;
     97                     if (NULL!=tb->RElink) tb->RElink->FRlink=link;
     98                     tb->RElink=link;
     99                     link->FRlink=tb;
    100                     link->job=nil;
    101                     link->address=tb->address+xk;
    102                     link->flag=0;
    103                     place=link;
    104                     k=1;
    105                     break;
    106                 }
    107             tb=tb->RElink;
    108         }
    109     }
    110     if (0==k)
    111     {//未寻找到合适的空间分区,返回
    112         printf(">>空间申请失败! 
    ");
    113         return;
    114     }
    115 }
    116 
    117 //主存回收函数,回收作业job所占用的分区空间
    118 void reclaim(char job,int choice)
    119 {
    120     int bool1=0,bool2=0;
    121     FRtable *tb,*link;
    122     tb=free_table;
    123     if (2==choice) link=tb;
    124     else link=NULL;
    125     do
    126     {
    127         if (job==tb->job&&1==tb->flag) break;
    128         tb=tb->RElink;
    129         if (tb==link)
    130         {
    131             printf("
    >>抱歉,不存在作业%c! 
    ",job);
    132             return;
    133         }
    134     }while(tb!=link);
    135     bool1=(NULL==tb->FRlink||tb->FRlink==tb->RElink)? 1:tb->FRlink->flag;
    136     bool2=(NULL==tb->RElink||tb->FRlink==tb->RElink)? 1:tb->RElink->flag;
    137     if (bool1&&bool2)
    138     {
    139         tb->job=nil;
    140         tb->flag=0;
    141     }
    142     else if ((NULL==tb->FRlink||1==tb->FRlink->flag)&&0==tb->RElink->flag)
    143     {
    144         link=tb->RElink;
    145         tb->job=nil;
    146         tb->length+=link->length;
    147         tb->flag=0;
    148         tb->RElink=link->RElink;
    149         if (NULL!=link->RElink) link->RElink->FRlink=tb;
    150         free(link);
    151     }
    152     else if (0==tb->FRlink->flag&&1==tb->RElink->flag)
    153     {
    154         link=tb->FRlink;
    155         link->length+=tb->length;
    156         link->RElink=tb->RElink;
    157         tb->RElink->FRlink=link;
    158         if (free_table==tb) free_table=link;
    159         free(tb);
    160     }
    161     else if (0==tb->FRlink->flag&&0==tb->RElink->flag)
    162     {
    163         link=tb->FRlink;
    164         link->length=link->length+tb->length+tb->RElink->length;
    165         link->RElink=tb->RElink->RElink;
    166         if (NULL!=tb->RElink->RElink) tb->RElink->RElink->FRlink=link;
    167         if (free_table==tb) free_table=link;
    168         free(tb);
    169         free(tb->RElink);
    170     }
    171 }
    172 //显示空间分区链表
    173 void display(FRtable *tb,int choice)
    174 {
    175 //    clrscr();
    176     FRtable *temp;
    177     if (2==choice) temp=tb;
    178     else temp=NULL;
    179     printf("
    	标号	分区首地址	分区大小(KB)	    状态位
    ");
    180     printf("
    	 sys	 1024.00	 40.00		     1
    ");
    181     do
    182     {
    183         printf("
    	 %c	 %.2f	 %.2f		     %d
    ",tb->job,tb->address,tb->length,tb->flag);
    184         tb=tb->RElink;
    185     }while(temp!=tb);
    186 }
    187 //主函数
    188 int main()
    189 {
    190     int i,a,choice;
    191     float xk;
    192     char job;
    193     FRtable *ta=getspace(FRtable);
    194     free_table=init(ta);
    195     do{
    196         printf("
     分区分配算法:
    	0 - 退出(Exit)
    	1 - 首次适应算法(FF)
    	2 - 循环首次适应算法(CFF)
     
    ");
    197         printf(">>请选择相应的算法(0-2):");
    198         scanf("%d",&choice);
    199         if (0==choice) exit(0);
    200     }while(0>choice&&2<choice);
    201     while(1)
    202     {
    203         printf("
        菜单:
    	0 - 退出(Exit)
    	1 - 申请空间(Allocation)
    	2 - 回收空间(Reclaim) 
    ");
    204         printf(">>请选择你的操作(0-2):");
    205         scanf("%d",&a);
    206         switch(a)
    207         {
    208             //a=0,程序结束
    209             case 0:exit(0);
    210             //a=1,分配主存空间
    211             case 1:printf(">>请输入作业标号和所需要申请的空间:");
    212                     scanf("%*c%c%f",&job,&xk);
    213                     allocate(job,xk,choice);
    214                     display(free_table,choice);
    215                     break;
    216             //a=2,回收主存空间
    217             case 2:printf(">>请输入你想回收的作业的相应标号:");
    218                     scanf("%*c%c",&job);
    219                     reclaim(job,choice);
    220                     display(free_table,choice);
    221                     break;
    222             default:printf(">>ERROR:No thie choose! 
    ");
    223         }
    224     }
    225 }
    View Code

    5.    总结

        本次实验是有关内存空间分配的算法的实现,实验内容相对之前的进程调度稍微简洁些,但是基本实现的数据结构的链表算法是一样的,还是需要通过申请空间,定义分区大小,然后通过链表对各空闲分区进行相应的内存分配。

  • 相关阅读:
    Java言语与C言语有哪些不同
    只会增删改查的Java程序员该如何发展
    java“单根继承结构”
    Java编程领域你需要懂得技术名词解释
    HTTP相关工具类/协助类分享
    说说Java到底是值传递仍是引用传递
    Java自定义ClassLoader实现
    深化详细分析java的发展前景!
    2020Java面试题及答案,命中率高达90%
    Python爬虫详解,每个步骤都给你细致的讲解(附源码)
  • 原文地址:https://www.cnblogs.com/hacop/p/5089077.html
Copyright © 2020-2023  润新知