精华内容
下载资源
问答
  • 论文研究-基于指标体系的区域资源合理配置初探.pdf, 根据评价指标筛选原则,设计了一个反映区域资源-社会经济系统状况多层次评价指标体系,建立了水资源合理配置 ...
  • 此外,由于网络中不同区域的边缘服务器负载不同,需要合理安排任务卸载以及分配边缘服务器计算资源,从而降低任务完成时延,实现负载均衡。因此,研究了工业物联网中基于边缘计算任务卸载和资源分配,提出了一种...
  • 应急设施是应急救援依托载体,其科学合理的选址事关应急救援紧迫性和应急资源分配的及时性,障碍约束下应急设施选址与应急资源分配决策研究具有重要战略意义....
  • 在传统碳排放权分配模式基础上,结合我国电力行业发展实际情况以及发电资源分布特点,提出基于区域比较两级分配机制,并建立相应分配模型。...仿真结果表明该分配机制能合理分配碳排放权。
  • 内存的分配与回收

    2012-03-10 17:36:35
    一个好计算机系统不仅要有一个足够容量、存取速度高、稳定可靠主存储器,而且要能合理分配和使用这些存储空间。当用户提出申请存储器空间时,存储管理必须根据申请者要求,按一定策略分析主存空间...
  • 主存储器空间的分配和回收

    千次阅读 2019-01-22 22:26:54
    当用户提出申请存储器空间时,存储管理必须根据申请者要求,按一定策略分析主存空间使用情况,找出足够空闲区域分配给申请者。当作业撤离或主动归还主存资源时,则存储管理要收回作业占用主存空间或归还...

    一、实验内容

        主存储器空间的分配和回收。

    二、实验目的

    一个好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器,而且要能合理地分配和使用这些存储空间。当用户提出申请存储器空间时,存储管理必须根据申请者的要求,按一定的策略分析主存空间的使用情况,找出足够的空闲区域分配给申请者。当作业撤离或主动归还主存资源时,则存储管理要收回作业占用的主存空间或归还部分主存空间。主存的分配和回收的实现与主存储器的管理方式有关的,通过本实验帮助学生理解在可变分区管理方式下应怎样实现主存空间的分配和回收。

    三、实验原理

    模拟在可变分区管理方式下采用最先适应算法实现主存分配和回收。

    (1)可变分区方式是按作业需要的主存空间大小来分割分区的。当要装入一个作业时,根据作业需要的主存量查看是否有足够的空闲空间,若有,则按需要量分割一个分区分配给该作业;若无,则作业不能装入。随着作业的装入、撤离,主存空间被分成许多个分区,有的分区被作业占用,而有的分区是空闲的。例如:

     

    操作系统

    作业1

    作业3

    空闲区

    作业2

     

    空闲区

     

     

    为了说明哪些区是空闲的,可以用来装入新作业,必须要有一张空闲区说明表,格式如下:

     

     

    起    址

    长    度

    状      态

    第一栏

    14 K

    12 K

    未 分 配

    第二栏

    32 K

    96 K

    未 分 配

    M

    M

    M

    M

     

     

     

    其中,起址——指出一个空闲区的主存起始地址。

          长度——指出从起始地址开始的一个连续空闲的长度。

          状态——有两种状态,一种是“未分配”状态,指出对应的由起址指出的某个长度的区域是空闲区。

     (2) 当有一个新作业要求装入主存时,必须查空闲区说明表,从中找出一个足够大的空闲区。有时找到的空闲区可能大于作业需要量,这时应把原来的空闲区变成两部分:一部分分给作业占用;另一部分又成为一个较小的空闲区。为了尽量减少由于分割造成的空闲区,而尽量保存高地址部分有较大的连续空闲区域,以利于大型作业的装入。为此,在空闲区说明表中,把每个空闲区按其地址顺序登记,即每个后继的空闲区其起始地址总是比前者大。

    (3) 采用最先适应算法(顺序分配算法)分配主存空间。

    按照作业的需要量,查空闲区说明表,顺序查看登记栏,找到第一个能满足要求的空闲区。当空闲区大于需要量时,一部分用来装入作业,另一部分仍为空闲区登记在空闲区说明表中。

    由于本实验是模拟主存的分配,所以把主存区分配给作业后并不实际启动装入程序装入作业,而用输出“分配情况”来代替。

    (4) 当一个作业执行结束撤离时,作业所占的区域应该归还,归还的区域如果与其它空闲区相邻,则应合成一个较大的空闲区,登记在空闲区说明表中。

    (5) 请按最先适应算法设计主存分配和回收的程序。假设初始时主存中没有作业,现按下面序列进行内存的申请与释放:

    作业1申请300K,作业2申请100K,作业1释放300K,作业3申请150K,

    作业4申请30K, 作业5申请40K, 作业6申请60K, 作业4释放30K。     

    四、算法流程图

    五、源程序及注释

    #include <cstdio>
    #include <cmath>
    #define COUNT 512
    #include <iostream>
    using namespace std;
    typedef struct NODE
    {
        char name;//名称
        float start;//起始位置
        float end;//大小
        int flag;//是否分配的标志
    }NODE;
    NODE OS[COUNT];//数组
    int count;//被分成的块数统计
    int applyfree;
    float numb;
    char c;

    //先对数组进行初始化,使没有分配的名称为 P
    void init()
    {
        count=1;
        OS[0].name ='P';
        OS[0].start =0;
        OS[0].end =COUNT;
        OS[0].flag =1;
    }

    //对数组的插入操作
    void insert(int m,float st,float en)
    {
        int i;
        count++;
        for(i=count;i>m+1;i--)
        {
            OS[i]=OS[i-1];
        }
        OS[m].start =st;
        OS[m].end  =en;
    }

    //移动操作,即对数组的删除操作
    void move(int m)
    {
        int i;
        for(i=m;i<count-1;i++)
        {
            OS[i]=OS[i+1];
        }
        count--;
    }

    //如果相邻块都没有分配,则要合并到一起
    void rremove(int m,float st,float en)
    {
        if(!OS[m-1].flag &&!OS[m+1].flag )
        {
            OS[m].name ='P';
            OS[m].flag =1;
        }
        if(OS[m-1].flag )
        {
            OS[m-1].end =OS[m-1].end +en;
            move(m);
        }
        if(OS[m+1].flag )
        {
            OS[m].end =OS[m].end +OS[m+1].end ;
            OS[m].name ='P';
            OS[m].flag =1;
            move(m+1);
        }
    }


    //打印输出
    void show()
    {
        int i;
        printf("名称    标识    起址    长度    状态\n");
        for(i=0;i<count;i++)
        {
            if(OS[i].flag )
                printf("P    ");
            else
                printf("%c    ",OS[i].name );

            printf("%d    %1.0f    %1.0f    ",i,OS[i].start ,OS[i].end );
            if(OS[i].flag )
                printf("未分配\n");
            else
                printf("已分配\n");
        }
    }

    //从键盘输入数据
    void putin()
    {
        printf("请输入申请或者释放的进程名称及资源数量:\n");
        rewind(stdin);
        scanf("%c",&c);
        scanf("%d",&applyfree);
        scanf("%f",&numb);
    }


    int apply()
    {
        int i=0;
        int applyflag=0;
        int freeflag=0;
        if(applyfree)//提出申请资源
        {
            while(!applyflag&&i<count)
            {
                if(OS[i].end >=numb&&OS[i].flag )
                {
                    if(OS[i].end ==numb)
                    {
                        OS[i].name =c;
                        OS[i].flag =0;
                    }
                    else
                    {

                        insert(i+1,OS[i].start +numb,OS[i].end -numb);
                        OS[i+1].flag =1;
                        OS[i+1].name ='P';
                        OS[i].start =OS[i].start ;
                        OS[i].name =c;
                        OS[i].end =numb;
                        OS[i].flag =0;
                    }
                    applyflag=1;
                }
                i++;
            }
            if(applyflag)
            {
                printf("申请成功!\n");
                return 1;
            }
            else
            {
                printf("申请失败!没有足够大的空闲空间。\n");
                return 0;
            }
        }

        else//提出释放资源
        {
            while(!freeflag&&i<count)
            {
                if(OS[i].name ==c)
                {
                    if(OS[i].end ==numb)
                    {
                    rremove(i,OS[i].start ,OS[i].end );
                    }
                    else
                    {
                        if(OS[i].end >numb)
                        {

                                insert(i+1,OS[i].start +numb,OS[i].end -numb);
                                OS[i+1].name ='P';
                                OS[i+1].flag =0;
                                OS[i].end =numb;
                                OS[i].flag =1;
                                if(OS[i-1].flag )
                                {
                                    rremove(i,OS[i].start ,OS[i].end );
                                }
                        }
                        else
                        {
                            printf("释放失败,因为正使用的数量小于要求释放的数量。\n");
                            return 0;
                        }
                    }
                    freeflag=1;
                }
                i++;
            }
            if(freeflag)
            {
                printf("释放成功!\n");
                return 1;
            }
            else
            {
                printf("释放失败!未找到匹配的进程名称。\n");
                return 0;
            }
        }
    }

    int main()
    {
        init();
        show();
        while(1)
        {
            putin();
            apply();
            show();
        }
        return 0;
    }
     

    六、打印的程序运行时初值和运行结果

    1、开始有512K的空间,未分配。用名称P来表示。

    进程A申请200K的空间,(申请用1表示,释放用0表示),其结果显示如下。

    2、进程B申请150K的空间,

    3进程A释放200K的空间,

    4、进程C申请100K的空间,

    进程D申请50K的空间

     

    5、进程E申请30K的空间,

    进程F申请70K的空间

     

    七、实验小结

    本实验用到的一些数据结构有:

    typedef struct NODE

    {

    char name;//名称

    float start;//起始位置

    float end;//大小

    int flag;//是否分配的标志

    }NODE;

    NODE OS[COUNT];//数组

    在清楚主存储器分配和回收的情况下,做些实验还是比较简单的。关键是注意当找到一个大的块时,如何将这个大块分成两小块,一块用于分配,另一块依旧是未分配。

    展开全文
  • 为了合理分配和使用这些存储空间,当用户提出申请主存储器空间时,存储管理必须根据申请者要求,按一定策略分析主存空间和使用情况,找出足够空闲区域给申请者。当作业撤离归还主存资源时,则存储管理要收回...

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

                    13物联网工程    刘烨   201306104146

    一、 实验目的

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

    二、 实验内容和要求

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

    2)实现内存回收模拟

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

    2.2  固定分区存储管理

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

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

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

    2.3  动态分区分配存储管理

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

    1)在程序运行过程,由用户指定申请与释放。

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

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

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

     

    1. 源程序名:实验二 1.c

    可执行程序名:1.exe

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

     

    #include"stdio.h"

    #include"stdlib.h"

    #define n 10 

    #define m 10

    #define minisize 100

    struct{

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

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

        int flag; 

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

     

    struct{

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

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

     int flag; 

    }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("\n选择功能项(0-退出,1-分配主存,2-回收主存,3-显示主存)\n");

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

      scanf("%d",&a);

      switch(a)

      {

      case 0: exit(0); 

      case 1: 

       printf("输入作业名和作业所需长度: ");

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

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

       break;

      case 2: 

    printf("输入要回收分区的作业名");

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

       break;

      case 3:

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

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

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

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

       getchar();

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

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

     

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

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

        else

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

        break;

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

      }

     }

    }/*主函数结束*/ 

    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("没有满足条件的空闲区\n");

     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("\n找不到该作业!\n");

     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("\n已回收!\n");

        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("\n已回收!\n");

         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("\n已回收!\n");

      }

     }

    }

     

    四、实验总结:

    主存空间的分配与回收,可变分区方式是按作业需要的主存空间大小来分割分区的。当要装入一个作业时,根据作业需要的主存容量查看是否有足够的空闲空间,若有,则按需分配,否则,作业无法装入。在进行编程时遇到了算法上的问题,后来经过请教同学以及搜索网上资源而得出结果。

    转载于:https://www.cnblogs.com/46ly/p/5089887.html

    展开全文
  • 为了合理分配和使用这些存储空间,当用户提出申请主存储器空间时,存储管理必须根据申请者要求,按一定策略分析主存空间和使用情况,找出足够空闲区域给申请者。当作业撤离归还主存资源时,则存储管理要收回...

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

    . 实验目的

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

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

    二. 实验内容

    2.1 模拟包括3部分:

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

    2) 实现内存回收模拟

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

    2.2 固定分区存储管理

    假设内存容量为120KB,并且分别划分成23,24,25,26KB大小的块各一块。

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

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

    2.3 动态分区分配存储管理

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

    (1)在程序运行过程,由用户指定申请与释放。

    (2)设计一个已占用分区表,以保存某时刻主存空间占用情况。

    (3)设计一个空闲分区表,以保存某时刻主存空间剩余情况。

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

    3. 实验环境

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

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

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

    #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("\n选择功能项(0-退出,1-分配主存,2-回收主存,3-显示主存)\n");
      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("输出空闲区表:\n起始地址 分区长度 标志\n");
       for(i=0;i<m;i++)
        printf("%6.0f%9.0f%6d\n",free_table[i].address,free_table[i].length, free_table[i].flag);
       printf(" 按任意键,输出已分配区表\n");
       getchar();
           printf(" 输出已分配区表:\n起始地址 分区长度 标志\n");
       for(i=0;i<n;i++)
    
        if(used_table[i].flag!=0)
         printf("%6.0f%9.0f%6c\n",used_table[i].address,used_table[i].length, used_table[i].flag);
        else
         printf("%6.0f%9.0f%6d\n",used_table[i].address,used_table[i].length, used_table[i].flag);
        break;
       default:printf("没有该选项\n");
      }/*case*/
     }/*while*/
    }/*主函数结束*/ 
    int uflag;//分配表标志
    int fflag;//空闲表标志
    float uend_address;
    float fend_address;
    void allocate(char str,float leg)
    {
     uflag=0;fflag=0;
     int k,i;float ressize;
    
     for(i=0;i<m;i++)
     {
      if(free_table[i].flag==1 && free_table[i].length>=leg)
      {
       fflag=1;break;
      }
        
     }
     if(fflag==0)
      printf("没有满足条件的空闲区\n");
     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)
    {
     uflag=0;fflag=0;
     int k,i;
     for(k=0;k<n;k++)
     {
      if(used_table[k].flag==str)
      {
       uflag=1;break;
      }
     }
     if(uflag==0)
      printf("\n找不到该作业!\n");
     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("\n已回收!\n");
        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("\n已回收!\n");
         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("\n已回收!\n");
      }
     }
    }

      

    四.实验总结

        感觉这次实验从原理上理解没有很费劲;但是在打编程的时候就是不知怎么下手,不知怎么打,最后是上网参考的.原理是能理解,但是在编程上,和还是不能很好的打出程序.

     

     

    转载于:https://www.cnblogs.com/z1230/p/5070098.html

    展开全文
  • 为了合理分配和使用这些存储空间,当用户提出申请主存储器空间时,存储管理必须根据申请者要求,按一定策略分析主存空间和使用情况,找出足够 空闲区域给申请者。当作业撤离归还主存资源时,则存储管理要...

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

                                      物联网工程     201306104105   游诗卫

    一、 实验目的

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

    二、实验内容和要求

    2.1  模拟包括3部分:

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

    2)实现内存回收模拟

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

     

    2.2  固定分区存储管理

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

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

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

     

    2.3  动态分区分配存储管理

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

    (1)在程序运行过程,由用户指定申请与释放。

    (2)设计一个已占用分区表,以保存某时刻主存空间占用情况。

    (3)设计一个空闲分区表,以保存某时刻主存空间剩余情况。

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

     

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

    主要程序段及其解释:

    复制代码
    #include<stdio.h>
    #include<malloc.h>
    struct FBT
    {
     int startdress;//分区首地址
     int size;//分区所占内存大小
     int processid;//申请内存分区的进程号
     int state;//分区状态
     struct FBT *next;
    };
    
    struct FBT *create()     //自由块表
    {
    struct FBT *head,*p,*q;
    head=NULL;
    p=(struct FBT *)malloc (sizeof(struct FBT));
    q=(struct FBT *)malloc (sizeof(struct FBT));
    head=p;
    p->size=5;//系统分区,大小为5
    p->processid=-1;//-1表示操作系统的固定分区
    p->startdress=0;//开始地址为0
    p->state=1;//状态为已分配,置1
    p->next=q;
    
    q->size=115;//余下分区大小
    q->processid=0;//进程号为0,表示未分配
    q->startdress=5;//起始地址为5
    q->state=0;
    q->next=NULL;
    return head;
    }
    
    struct  FBT *distribute(struct FBT*head)//分配内存子函数
    {
    int id,needsize;
    struct FBT *pretail,*tail,*p;
    printf("输入要申请内存的进程号:");//输入申请内存的进程号
    scanf("%d",&id);
    printf("请输入申请的内存大小:");//输入申请的内存大小
    scanf("%d",&needsize);
    pretail=tail=head;
    while(tail!=NULL)
    {
    if(tail->state==0&&tail->size>=needsize)//如果此分区没有分配,而且大小大于等于申请的内存大小
    {
    if(tail->size>needsize)//如果此分区大小大于要申请的大小,分配,并把余下的再分割成一个分区
    {
    p=(struct FBT *)malloc (sizeof(struct FBT));
    p->size=needsize;
    p->processid=id;
    p->startdress=tail->startdress;
    p->state=1;
      if(head!=tail)
      {
      pretail->next=p;
      p->next=tail;
      pretail=p;
      }
      else
      {
      p->next=tail;
      head=p;
      tail->next=NULL;
      }
      tail->startdress=p->startdress+p->size;
      tail->size=tail->size-needsize;
      break;
    }
         if(tail->size==needsize)//如果此分区等于要申请的大小,直接分配即可
         {
         tail->processid=id;
         tail->state=1;
         break;
         }
    }
    else //否则,指向下一个结点继续判断
    {
       pretail=tail;
       tail=tail->next;
    }
    }
    if(tail==NULL)//如果遍历完链表都没有找到合适的分区分配,则显示以下信息
        printf("\n没有足够的空间!\n");
    return head;
    } 
    
     struct  FBT *callback(struct FBT *head)//回收内存子函数
     {
       int id;
       struct FBT *pretail,*tail;
       printf("请输入进程号:");
       scanf("%d",&id);
       pretail=tail=head;
    while(tail!=NULL)//遍历链表
    {
    if(tail->processid==id)//如果改分区所对应的进程号要收回分区的进程号,则做以下动作
    {
        if(tail->next!=NULL)//如果改分区不是最后一个分区,则作以下动作
        {
          if(pretail->state==1&&tail->next->state==1)//前一个分区是已分配的且后一个分区也是已分配的
          {
          tail->state=0;
          break;
          }
          if(pretail->state==0&&tail->next->state==1)//前一个分区是未分配的且后一个分区也是已分配的
          {
          pretail->next=tail->next;
          pretail->size=tail->size+pretail->size;
          free(tail);
          break;
          }
         if(pretail->state==1&&tail->next->state==0)//前一个分区是已分配的且后一个分区是未分配的
         {
            if(pretail!=tail)
            {
              pretail->next=tail->next;
              tail->next->size=tail->next->size+tail->size;
              tail->next->startdress=tail->startdress;
              free(tail);
              break;
            }
            else
            {
            head=tail->next;
            tail->next->startdress=0;
            tail->next->size+=tail->size;
            break;
            }
         }
         if(pretail->state==0&&tail->next->state==0)//前一个分区和后一个分区都未分配的
         {
         pretail->next=tail->next->next;
         pretail->size=pretail->size+tail->size+tail->next->size;
         free(tail->next);
         free(tail);
         break;
         }
        }
        else//如果该分区是最后一个分区则作以下动作
        {
        if(pretail->state==1)//如果前一个分区是已分配的
        {
        tail->state=0;
        break;
        }
        else//如果前一个分区是未分配的
        {
        pretail->next=NULL;
        pretail->size=pretail->size+tail->size;
        free(tail);
        break;
        }
        }
     }
    pretail=tail;
    tail=tail->next;//遍历下一个分区结点
    }
    return head;//返回头指针
    }
    
    
     void print(struct FBT *head)//显示FBT的内容给客户
     {
     struct FBT *tail=head;
     printf("startdress\tsize\tstate\t\tprocessid\t\n");
     tail=head;
     while(tail!=NULL)
     {
       if(tail->state==1)
           printf("%5d\t\t%5d\t%5d\t\t%5d\n",tail->startdress,tail->size,tail->state,tail->processid);
        else 
            printf("%5d\t\t%5d\t%5d\n",tail->startdress,tail->size,tail->state);
        tail=tail->next;
     }
     }
    
    void main()//主函数
    {
    int choice=1;
    struct FBT *head;
    head=create();
    while(choice!=0)
    {
        printf("\t1.申请内存\n");
        printf("\t2.回收内存\n");
        printf("\t3.退出\n");
        printf("请选择:");
        scanf("%d",&choice);
        switch(choice)
        {
        case 1:
            head=distribute(head);
            print(head);
            break;
        case 2:
            head=callback(head);
            print(head);
            break;
        case 0:break;
        default:
            printf("输入错误!\n");
        }
    }
    }
    复制代码

    运行结果:

    四、总结

         每一次实验都有其实存在的意义,通过操作不同的实验来掌握不同的知识点,对于本次实验的要求说实在我觉得我自己还没有达到要求,但在日后我会继续加倍努力,在有限的时间充分发挥争取学到跟多的知识,不断充实自我,完善自我。

    转载于:https://www.cnblogs.com/YSW520668/p/5105129.html

    展开全文
  • 当用户提出申请存储器空间时,存储管理必须根据申请者要求,按一定策略分析主存空间使用情况,找出足够空闲区域分配给申请者。当作业撤离或主动归还主存资源时,则存储管理要收回作业占用主存空间或归还...
  • 为了合理分配和使用这些存储空间,当用户提出申请主存储器空间时,存储管理必须根据申请者要求,按一定策略分析主存空间和使用情况,找出足够空闲区域给申请者。当作业撤离归还主存资源时,则存储管理要收回...
  • 一个好计算机系统不仅要有一个足够容量、存取速度高、稳定可靠主存储器,而且要能合理分配和使用这些存储空间。当用户提出申请存储器空间时,存储管理必须根据申请者要求,按一定策略分析主存空间...
  • 机场机位分配

    2015-08-11 09:11:45
    高效合理的机位分配方案不仅会给民 航运输带来巨大经济效益,而且能在一定程度上提高民航运输安全性。安全和效益永远是 民航运输追求不可或缺两个目标。因此,本文从安全性和效益性角度出发,来研究多航 ...
  • 当用户提出申请存储器空间时,存储管理必须根据申请者要求,按一定策略分析主存空间使用情况,找出足够空闲区域分配给申请者。当作业撤离或主动归还主存资源时,则存储管理要收回作业占用主存空间或归还...
  • 为了合理分配和使用这些存储空间,当用户提出申请主存储器空间时,存储管理必须根据申请者要求,按一定策略分析主存空间和使用情况,找出足够空闲区域给申请者。当作业撤离归还主存资源时,则存储管理要收回...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 131
精华内容 52
关键字:

区域资源的合理分配