固定分区、可变式分区分配及段页式分区分配c代码实现

最新推荐文章于 2024-05-02 15:41:36 发布
最新推荐文章于 2024-05-02 15:41:36 发布
阅读量5k 收藏 91
点赞数 18
分类专栏： 操作系统 文章标签： 存储管理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42241438/article/details/80504784
版权

       本实验通过三种分区分配的方法，分别是固定分区分配、可变分区分配及段页式分区分配，从连续内存分区分配方式到离散分区分配方式。段页式的采用减少了碎片的产生，极大地提高了内存空间的利用率，但是却增加了访存的次数，因此，可以采用快表机制，减少访存的次数，对段页式存储管理进行优化。

      1、固定分区分配回收内存空间代码

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define getpch(type) (type*)malloc(sizeof(type))
int SIZE;
struct sif //内存分区使用说明表
{
    int id;
    int size;
    int begin_adress;
    char status;//F-已分配，T-未分配
    struct sif *next;
}*p,*ready=NULL;

typedef struct sif SIF;

int allocate(int size)//分配内存，返回0代表分配成功
{
    p=ready;
    while(p!=NULL)
    {
        if((p->status=='T')&&(p->size>=size))
        {
            p->status='F';
            return 1;
        }
        p=p->next;
    }
    return 0;
}
void disp()//打印内存分配情况
{
    printf("\n 当前内存分配情况如下：\n");
    printf("\n |id |size |begin_adress |status \n");
    p=ready;
    while(p!=NULL)
    {
        printf("\n %d| %d| %d| %c\n",p->id,p->size,p->begin_adress,p->status);
        p=p->next;
    }
}
void Input()
{
    int num,i,j,d=0,id=0;
    SIF *last=ready;
    printf("\n 请输入现有内存的大小:  (起始地址从0开始) \n");
    scanf("%d",&SIZE);
    //初始化内存信息
    printf("\n 请输入固定分区不同内存块的个数: ");
    scanf("%d",&num);
    for(i=0; i<num; i++)
    {
        int n;
        printf("\n 请输入%f KB内存的个数: ",pow(2,4+i));
        scanf("%d",&n);
        for(j=0; j<n; j++)
        {
            p=getpch(SIF);
            p->id=id++;
            p->size=(int)(pow(2,4+i));//size是按照2的指数递增的
            p->begin_adress=d;
            if((rand()%2)==0)//是否被分配初始化
                p->status='T';
            else
                p->status='F';
            p->next=NULL;
            d+=p->size;
            if(d>=SIZE)
            {
              printf("\n 已超出系统总内存量,%d号分配失败 \n",p->id);
              break;
            }
            if(ready==NULL)
            {
                ready=p;
                last=ready;
            }
            else
            {
                last->next=p;
                last=last->next;
            }
        }
    }
    disp();//打印内存说明表
}
void allocation()
{
    int num1;
    int i,s;
    //给作业分配内存空间
    printf("\n 请输入待分配内存的作业个数：");


    scanf("%d",&num1);
    for(i=0; i<num1; i++)
    {
        printf("\n 请输入第%d个作业的大小: ",i);
        scanf("%d",&s);
        if(allocate(s)==1)
        {
            printf("\n 已为该作业分配内存空间\n");
            printf("\n 存储该作业内存空间的详细信息如下：\n");
            printf("\n 内存块号：%d, 内存大小：%d \n",p->id,p->size);
        }
        else
            printf("\n 未能该该作业分配内存 \n");
    }
    disp();
}
void recover()//作业完成后回收资源
{
    int i,k,num;
    printf("\n 请输入需要释放的作业个数: ");
    scanf("%d",&num);
    for(i=0; i<num; i++)
    {
        printf("\n 请输入存储该作业的内存分区说明表的ID \n");
        scanf("%d",&k);
        p=ready;
        while(p!=NULL)
        {
            if(p->id==k)
            {
                p->status='T';
                printf("\n 已释放该作业所占用的资源 \n");
                break;
            }
            p=p->next;
        }
    }
    disp();
}
int main()
{
    int command;
    Input();//初始化内存说明表
    printf("\n 请输入命令，给作业分配资源输入1，释放资源输入2，退出请输入任意键：\n");
    scanf("%d",&command);
    while(1)
    {
        if(command==1)
            allocation();
        else if(command==2)
            recover();
        else
            break;
        printf("\n 请继续输入命令 \n");
        scanf("%d",&command);
    }
    return 0;
}

      2、可变分区分配并回收内存空间（首次适应法）

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define getpch(type) (type*)malloc(sizeof(type))
int SIZE;
int id=0;
struct sif //内存分区使用说明表
{
    int id;
    int size;
    int begin_adress;
    char status;//F-已分配，T-未分配
    struct sif *next;
}*p,*ready=NULL;

typedef struct sif SIF;

int allocate(int size)//分配内存
{
    p=ready;
    while(p!=NULL)
    {
        if((p->status=='T')&&(p->size>=size))
        {
            p->status='F';
            if(((p->size)-size)>0)//若分配后存在碎片
            {
                if((p->next->status)=='T')//若下一相邻存储块未被分配，将此碎片与相邻存储片合并
                {
                    p->next->begin_adress=p->next->begin_adress-(p->size-size);
                    p->next->size=p->next->size+(p->size-size);
                    p->next=p->next->next;
                }
                else//若下一相邻存储块已被分配，为此碎片新建一存储块
                {
                    SIF *q=getpch(SIF);
                    q->id=id++;
                    q->size=(p->size)-size;
                    q->status='T';
                    q->begin_adress=p->begin_adress+size;
                    q->next=p->next;
                    p->next=q;
                    p->size=size;
                }
            }
            return 1;
        }
        p=p->next;
    }
    return 0;
}
void disp()//显示当前内存分配情况
{
    printf("\n 当前内存分配情况如下：\n");
    printf("\n |id |size |begin_adress |status \n");
    p=ready;
    while(p!=NULL)
    {
        printf("\n %d| %d| %d| %c\n",p->id,p->size,p->begin_adress,p->status);
        p=p->next;
    }
}
void Input()
{
    int d=0;
    SIF *last=ready;
    printf("\n 请输入现有内存的大小:  (起始地址从0开始) \n");
    scanf("%d",&SIZE);
    //初始化内存信息
    while(d!=SIZE)
    {
        p=getpch(SIF);
        p->id=id++;
        p->size=rand()%(63-1+1)+1;//使用随机函数分配存储块size
        p->begin_adress=d;
        if((id%2)==1)
            p->status='F';
        else
            p->status='T';

        p->next=NULL;
        if(d>(SIZE-(p->size)))
        {
            p->size=SIZE-d;
        }
        d+=p->size;
        if(ready==NULL)
        {
            ready=p;
            last=ready;
        }
        else
        {
            last->next=p;
            last=last->next;
        }
    }
    disp();//打印内存说明表
}
void allocation()//采用首次适应算法分配内存
{
    int num1;
    int i,s;
    //给作业分配内存空间
    printf("\n 请输入待分配内存的作业个数：");

    scanf("%d",&num1);
    for(i=0; i<num1; i++)
    {
        printf("\n 请输入第%d个作业的大小: ",i);
        scanf("%d",&s);
        if(allocate(s)==1)
        {
            printf("\n 已为该作业分配内存空间\n");
            printf("\n 存储该作业内存空间的详细信息如下：\n");
            printf("\n 内存块号：%d, 内存大小：%d \n",p->id,p->size);
        }
        else
            printf("\n 未能该该作业分配内存 \n");
    }
    disp();
}
void recover()//作业完成后回收资源
{
    int i,k,num;
    printf("\n 请输入需要释放的作业个数: ");
    scanf("%d",&num);
    for(i=0; i<num; i++)
    {
        printf("\n 请输入存储该作业的内存分区说明表的ID \n");
        scanf("%d",&k);
        p=ready;
        SIF *q=getpch(SIF);

        while(p!=NULL)
        {
            if(p->id==k)
            {
                p->status='T';

                if((q->status=='T')&&(p->next->status=='T'))//释放资源上下相邻块均未存储信息,合并三块为一块
                {
                    (q->size)+=p->size+p->next->size;
                    (q->next)=p->next->next;
                }
                if((q->status=='T')&&(p->next->status=='F'))//相邻上块未分配，下层已分配，合并上层及当前块
                {
                    (q->size)+=p->size;
                    (q->next)=p->next;
                }
                if((q->status=='F')&&(p->next->status=='T'))//相邻下块未分配，上层已分配，合并下层及当前块
                {
                    p->size=(p->size)+(p->next->size);
                    p->next=p->next->next;
                }

                printf("\n 已释放该作业所占用的资源 \n");
                break;
            }
            q=p;
            p=p->next;
        }
    }
    disp();
}
int main()
{
    int command;
    Input();//初始化内存说明表
    printf("\n 请输入命令，给作业分配资源输入1，释放资源输入2，退出请输入任意键：\n");
    scanf("%d ",&command);
    while(1)
    {
        if(command==1)
            allocation();
        else if(command==2)
            recover();
        else
            break;
        printf("\n 请继续输入命令 \n");
        scanf("%d",&command);
    }
    return 0;
}

     3、段页式存储管理分配内存空间并实现逻辑地址转换功能

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define getpch(type) (type*)malloc(sizeof(type))

int n;//全局变量，段表长度

typedef struct page//页表
{
    int id;
    int b_num;
    struct black *b;
}pg;

typedef struct paragraph//段表
{
    int id;//段号
    int size;
    struct page *adress;//页内地址
}ph;

ph PH[10];
pg PG[10][10];

void disp()
{
    printf("\n 当前段表分配情况如下：\n");
    printf("\n |id |pagesize |page_b_adress \n");
    int i;
    for(i=0; i<(int)(sqrt(n)); i++)
    {
        printf("\n %d\t%d\t%d \n",PH[i].id,PH[i].size,PH[i].adress);
    }

    printf("\n 当前页表分配情况如下：\n");
    int j;
    for(i=0; i<(int)(sqrt(n)); i++)
    {
        printf("\n  第%d段页内分配情况如下：\n",i);
        printf("\n |id  | b_num \n");
        for(j=0;j<(int)(sqrt(PH[i].size));j++)
        printf("\n %d\t%d \n",PG[i][j].id,PG[i][j].b_num);
    }
}
void Input()//输入函数
{
    int i,d,m;
    printf("\n 初始化段表 \n");
    printf("\n 请输入段表的起始地址、段表的长度：");
    scanf("%d%d",&d,&n);

    m=d;
    for(i=0; i<(int)(sqrt(n)); i++)
    {
        PH[i].id=i;
        int j=rand()%4;
        PH[i].size=(int)(pow(2,j));//页表长度
        PH[i].adress=m;
        m+=PH[i].size;
        int k;
        for(k=0; k<j; k++)
        {
            PG[i][k].id=k;//每个页面2KB
            PG[i][k].b_num= rand()%(127-0+1)+1;
        }
    }
    disp();
}
int adress_mapping()//地址映射函数
{
    int a,b,c,n1=0,d=0;
    printf("\n请依次输入作业的段号、段内页号及业内地址： ");
    scanf("%d%d%d",&a,&b,&c);
    if(a>n)//判断是否越界
    {
        printf("\n 您输入的段号已越界 \n");
        return -1;
    }

    //若未越界,则进入页表
    int j=sqrt(PH[a].size);
    if(b>j)
    {
        printf("\n 您输入的页号已越界 \n");
        return -1;
    }

    //若未越界，则返回物理地址
    return PG[a][b].b_num*256+c;

}

int main()
{
    Input();
    int command;
    printf("\n 计算物理地址请按1，退出请按0 \n");
    scanf("%d",&command);
    while(command==1)
    {
        printf("\n %d \n",adress_mapping());
        printf("\n 计算物理地址请按1，退出请按0 \n");
        scanf("%d",&command);
    }
}

莫言莫语123
关注
  • 18
    点赞
  • 踩
  • 91
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
内存管理之固定分区和动态分区详解
肖氏专栏
05-21 2万+
下面先介绍一个概念： 页：一个固定长度的数据块，存储在二级存储器中（如磁盘）。数据页可以临时复制入内存的页框中。 段：一个变长的数据块，存储在二级存储中，整个段可以临时复制到内存的可用区域（分段），或者将段分成许多页，将页单独复制到内存中（分段分页相结合）。 重定位：就是把程序的逻辑地址空间变换成内存中的实际物理地址空间的过程        操作系统存储至少要分成两级：内存和外存。内存提供
固定分区存储管理(C语言)
qq_48499842的博客
04-27 4581
固定分区存储管理(C语言) 课程 操作系统 实验名称 固定分区存储管理 实验要求 1、 实现固定分区存储管理方式下存储空间的分配和回收。 2、 已知当前内存分配表如下 分区号 起始地址 长度 状态 1 10KB 30KB Job5 2 40KB 7KB 0 3 47KB 50KB Job2 3、 有若干个作业申请或释放内存空间，请求如下： （1） 作业Job6请求资源，申请20KB大小的内存空间； （2） 作业Job7请求资源，申请5KB大小的内存空间； （3） 作业Job2执行
【备战软考（嵌入式系统设计师）】05 - 分区存储管理
最新发布
m0_63235356的博客
05-02 574
就是将主存事先分成几个固定大小的分区，并且不管将作业分配完分区之后，该分区剩多少，都不能再给其他作业使用了。这样的优点就是简单，缺点也很明显，就是不灵活，且容易产生内部碎片。，顾名思义，就是大小可变，每次划分当前作业所需要的大小。相比固定分区，资源利用率提升了不少。不过这样是不产生了内部碎片了。但是会导致产生外部碎片，也就是把主存的空间切割成了很多块。以防有小伙伴不理解外部碎片是怎么产生的，我结合着下面的图片简单说一下。一开始是不会有内部碎片和外部碎片的，比如是像左边那样依次分配好的。
c语言指定分区大小 格式化分区,文件系统——格式化分区
weixin_39944515的博客
05-17 535
本章节用到的命令主要有：mkfs，mke2fs，tune2fs，blkid，e2label，bc一、mkfs命令前文中介绍了如何给磁盘分区，那么分好了区的磁盘，如何使用呢？首先需要对分区进行格式化。格式化分区非常重要，它是用来创建文件系统的，其命令为mkfs，意为makefilesystem。创建文件系统时需要指定具体的类型，故mkfs命令可以与-t选项结合使用，其格式为：mkfs-tFi...
模拟固定分区分配
hebtu666
11-04 4571
介绍 data.h #ifndef _Data_h_ #define _Data_h_ #include <stdio.h> #include <stdlib.h> #include <string.h> #define LIST_INIT_SIZE 10 #define LISTINCREMENT 2 #define true 1 #defin...
模拟设计段式存储管理的分配与回收（三种算法）
m0_64591427的博客
01-16 564
WHUT操作系统课程设计
操作系统—可变式分区分配算法
12-20
与固定分区分配不同，可变式分区分配可以更好地适应不同大小的进程需求，提高了内存利用率。 C++ 和 MFC（Microsoft Foundation Classes）是一种常用的组合，用于开发 Windows 平台上的桌面应用程序。在这个实验中...
操作系统—可变式分区存储管理（C++实现）
05-13
可变式分区存储管理： 通过文件操作读取空闲区表（包含空闲区的起始地址和长度），通过用户选择分配/回收内存，回收的内存如果和空闲区表的内存块相邻，则进行合并 注：解决方案中带有data.txt文件，并在代码中指定...
ff.rar_可变式分区
09-21
在实际操作系统的实现中，可变式分区分配往往结合了其他内存管理机制，如页式或段式存储管理，以提供更高级的功能，如虚拟内存和动态地址映射。通过理解这些基本概念，开发者可以更好地设计和优化内存分配策略，以...
在可变式分区管理中使用空闲区链实现主存的分配与回收源代码
06-25
在可变式分区管理中使用空闲区链实现主存的分配与回收,操作系统实验程序源代码
可变式分区分配
01-08
操作系统可变式分区分配
首次适应算法 C语言实现
热门推荐
weixin_45761769的博客
12-02 1万+
广东工业大学 操作系统实验 用C语言实现采用首次适应算法的动态分区分配过程和回收过程。 其中，空闲分区通过空闲分区链（表）来管理；在进行内存分配时，系统优先使用空闲区低端的空间，要求每次分配和回收后显示出空闲内存分区链的情况。 #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #define FREE 0 #define BUSY 1 #define Max_length 640 typedef s
固定分区分配算法的模拟（c++实现）
falldeep的算法世界
10-11 1558
预先将内存空间（1024KB）划分成4个等值大小的空闲分区（每个分区占256KB），分配过程根据用户需求将某一满足条件的分区直接分配（不进行分割），作业完成后回收相应内存。插入作业若过大，超过分区大小，内存将无法装入，如插入作业D，大小500KB，程序返回异常提醒。1）实现一个完整的固定分区管理器，包括分配，回收等。根据固定分区分配算法，将该作业分配到第0分区。2）初始化功能：内存状态设置为初始状态。输入0，进行回收作业测试，回收作业A成功。3）分配功能：采用固定分区分配算法。图3-3 显示当前内存信息。
可变分区算法c语言,OS_可变分区的存储管理：C++实现
weixin_35173650的博客
05-24 796
一、实验目的：加深对可变分区存储管理的理解；提高用C语言编制大型系统程序的能力，特别是掌握C语言编程的难点：指针和指针作为函数参数；掌握用指针实现链表和在链表上的基本操作。二、实验内容：参照教材P123-P125的内容，编写一个C程序，用char *malloc(unsigned size)函数向系统申请一次内存空间(如size=1000，单位为字节)，用循环首次适应算法、最佳适应算法和最坏适应算...
【自顶向下模块化编程】C语言实现首次/循环首次适应分配算法
究极小白-行者千面的博客
11-20 1266
操作系统，动态分区分配算法，首次/循环首次适应分配算法，模块化编程
内存分配管理机制的实现，可变分区机制下最先适应分配机制C语言（首次适应算法）
糊涂汪的博客
12-10 1633
** 内存分配管理机制的实现（C语言） ** 算法： 首先为内存划分块大小，我们以划分五块为例，然后为作业定义一个大小S，让作业大小与内存中的每个块大小ai进行比较，第一个满足的S<=ai的内存块即为装入的内存块，装入后的内存块ai=ai-S。 设定一个flag，初值为0，当有内存块满足作业装入的时候flag<=1，若flag=0则输出无匹配的内存块，若flag=1则输出分配作业后内存各块的大小。 代码实现： #include <stdio.h> #include <stdli
采用可变式分区管理，使用首次适应算法实现主存的分配与回收（C++实现）
qq_40159978的博客
06-05 9671
算法思想： 采用可变式分区管理，使用首次适应算法实现主存的分配与回收 要求采用分区表进行。 可变式分区管理是指在处理作业过程中建立分区，使分区大小正好适合作业的需要，并且分区个数是可以调整的。当要装入一个作业时。根据作业需要的主存量。查看是否有足够的空闲空间。若有，则按需求量分割一部分给作业。若无，则作业等待。随着作业的装入、完成。主存空间被分隔成许多大大小小的分区，有的分区被作业占用。有的分...
操作系统实验五——可变式分区分配算法（C++实现）
qq_34245098的博客
06-17 3012
要求 编写程序模拟以下状态作业序列的内存运行环境，程序运行后可判断使用三种算法（首次适应算法、最佳适应算法、最差适应算法）在处理该作业序列中哪一种合适， 给予结果反馈。 现在有一作业序列： 作业A（15K）、作业B（16K）、作业C（15K） 依次要求进入系统运行，假设此时系统的空闲区按地址顺序排列，分别是： 起始地址为 40K 的空闲区1（16K）、起始地址为 70K 的空闲区2（14K）、起始地址 为 100K 的空闲区3（5K）、起始地址为 150K 的空闲区4（30K） 用看哪种算法是合适的。 代码
操作系统可变式分区的分配和去配（最先适应分配算法c语言）
是我的博客啊
11-17 2803
代码存在一个问题，就是在allocate和deallocate的函数体内，无法对原来就是空的链表进行插入，原来是因为只有一级指针，所以只能改变结点的值（包括一些值和指针指向）。 例如假如我想要ftable=ftable->next；没有返回值ftable的话，修改是无效的； 我想到解决方法可以是，采用二级指针（啊魔鬼），或者采用存在头结点的单链表，这样就不存在空链表了，或者把两张表合并成一张...
采用可变式分区管理，使用首次适应算法实现主存的分配与回收python代码
06-02
以下是采用可变式分区管理，使用首次适应算法实现主存的分配与回收的 Python 代码： ```python # 定义空闲分区表 free_list = [(0, 100), (200, 300), (400, 500)] # 定义已分配分区表 alloc_list = [] # 首次...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值