动态分区式内存管理（完整代码）

已于 2022-03-15 00:17:31 修改
阅读量1.1w 收藏 180
点赞数 14
分类专栏： 一些小程序 文章标签： 操作系统 c++ 算法 内存管理 数据结构
于 2021-04-16 22:00:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46291251/article/details/115772341
版权

操作系统实验导航
实验一：银行家算法 https://blog.csdn.net/weixin_46291251/article/details/115384510
实验二：多级队列调度和多级反馈队列调度算法 https://blog.csdn.net/weixin_46291251/article/details/115530582
实验三：动态分区式内存管理 https://blog.csdn.net/weixin_46291251/article/details/115772341
实验四：Linux下多进程通信 https://blog.csdn.net/weixin_46291251/article/details/116274665
实验五：进程通信的三种方式 https://blog.csdn.net/weixin_46291251/article/details/116301250
实验六：Linux文件系统实验 https://blog.csdn.net/weixin_46291251/article/details/116423798
实验七：自制简单U盘引导程序 https://blog.csdn.net/weixin_46291251/article/details/116427629
实验八：磁盘调度算法 https://blog.csdn.net/weixin_46291251/article/details/116431907
实验九：请求分页系统中的置换算法 https://blog.csdn.net/weixin_46291251/article/details/116443021
学习笔记：操作系统复习笔记 https://blog.csdn.net/weixin_46291251/article/details/117086851

背景知识：

关于内存管理的几种方式：
固定分区：

原理：又称定长分区或静态分区模式，是满足多道程序设计需要的最简单的存储管理技术。基本思想：给进入主存的用户作业划分一块连续存储区域，把作业装入该连续存储区域，若有多个作业装入主存，则它们可并发执行。

使用大小相等的固定分区有两个难点：程序可能太大而不能放到一个分区中，内存的，利用率很低。由于被装入的数据块小于分区大小，从而导致分区内部有浪费现象，成为“内部碎片”。对与大小不等的分区策略，最简单的方法就是把每个进程分配到能够容纳它的最小分区中。

目前已经基本上没有什么场合使用固定分区。

优势：实现简单，只需要极少的操作系统开销

缺点：有内部碎片，对内存的使用不充分，活动进程的最大数目是固定的。

可变分区：

可变分区存储管理不是预先把内存中的用户区域划分成若干固定分区，而是在作业要求装入内存时，根据用户作业的大小和当时内存空间使用情况决定是否为该作业分配一个分区。因此分区大小不是预先固定的，而是按作业需求量来划分的；分区的个数和位置也不是预先确定的。它有效地克服了固定分区方式中，由于分区内部剩余内存空置造成浪费的问题。
可变分区方式常用的内存分配算法有以下几种：

  • 1、 最先适应分配算法
    　　每次分配总是顺序查找空闲区表，找到能满足长度要求的空闲区就分配。优点是实现简单，缺点是可能将大的空闲区分割成许多小的空闲区，形成许多不连续的“碎片”。碎片长度可能不能满足作业要求，降低了内存利用率。
    　　改进方法，可把空闲区按地址顺序从小到大登记在空闲区表中，有利于大作业。问题是归还空区时须按地址插入表中适当位置。

  • 2、最优适应分配算法
    　　按作业要求从所有空闲区中挑选一个能满足要求的最小空闲区，这样保证不去分割一个更大的区域，使装入大作业时比较容易得到满足。实现办法：将空闲区按长度以递增次序登记在表中，分配时按空闲区表顺序查找即可。缺点是可能碎片更小而无法使用。回收时也要按长度扦入。

  • 3、最坏适应分配算法
    　　这种算法总是挑选一个最大的空闲区分割一部分给作业使用，使剩下部分不致太小，仍可供分配使用。实现办法：空闲区表中的登记项按空闲区长度递减顺序排列，按序查找分配。

题目描述：动态分区式存贮区管理

设计一个动态分区式存贮区管理程序，要求支持不同的放置策略。如首次、最佳、最坏。
说明：
（1）分区描述器rd如下:
flagsizenext
  要求空闲区队列按链表组织。
  主存大小假设为maxsize（单位为节=rd的大小）。
（2）主程序结构如下：
  输入放置策略     
  申请一块内存作为主存
  循环处理用户的请求（包括申请、释放）

需设计两个函数处理用户请求：

  • 申请函数 Addr=Request(size)
  • 释放函数 Release(addr）
（3）数据实例：maxsize=512
    J1申请162，J2申请64，J3申请120，J4申请86，J1完成，
    J3完成，J5申请72，J6申请100，J2完成，J7申请36，
    J8申请60，J4完成， J9申请110，J10申请42。

备注：

  • （a）所有大小其单位为节（1节=rd的大小）
  • （b）作业申请n节,实际分配的分区大小应为n+1节。 其中一节作为分区描述器，其他n节提供给作业。
  • （c）已分配区放在高地址处。
  • （d）合并时应考虑四种情况： 假设回收区为r,上邻为f1（f1需搜索自由主存队列）,下邻为f2（f2可直接计算）
    A)f1空闲，f2已分配；
    B)f1已分配，f2空闲；
    C)f1空闲，f2空闲；
    D)f1已分配，f2已分配；

设计思路：

  • 向系统申请内存：
    需要申请的内存单元的个数：totalNum
    每个内存单元的大小：sizeof(rd)
    程序实际向系统申请到达大小：maxsize
    即：
    const int totalNum = 512;//需要申请的块数
    const int maxsize = totalNum * sizeof(rd);//实际需要申请的大小
    rd* MainHead = (rd*)malloc(maxsize);//申请到的资源

  • 进程向程序申请内存Request：
    原型：rd* Request(int need,int choice);
    参数：need表示需要申请的大小，choice表示分配时采取的方法。
    返回值：返回一个指针，指向申请到的空间的首地址，若为空则表示申请失败。

  • 进程释放内存Release：
    原型：bool Release(rd* r);
    参数：r表示待释放内存的首地址
    返回值：返回1表示释放成功，0表示失败

  • 可视化展示内存使用情况：
    每一次读取用户的请求后，程序均输出当前的内存使用情况，方便用户查看，包括空闲队列的情况、已用队列的情况、内存总体分配情况。

数据结构：

  • 分区描述器：
    设计一个结构体rd用来表示分区描述器，其包含：
    Flag：分配标志，空闲为0，不为0则表示进程编号
    Size：分区大小，分区可用字数+分区描述器大小
    *next：指向下一个同类型的区域
struct rd {//分区描述器
    int flag = -1;  //分配标志，空闲为0，不为0则表示进程编号
    int size = -1;   //分区大小，分区可用字数+分区描述器大小
    rd* next = NULL;   //指向下一个同类型的区域
};
  • 空闲内存队列和已用内存队列：
    两个队列都通过链表的形式组织
    分别为其设置头节点Free和Used：
rd* Free = new rd, * Used = new rd;//分别用来存空闲队列和已占用队列

算法设计

三种算法：
  首次：按物理地址的顺序排列，优先地址最小的
  最佳：按照空闲容量递增排列，优先最小的
  最坏：按照空闲容量递减排列，优先最大的

三种算法在分配和释放的操作上没有区别。
区别在于：空闲队列变化以后需要排序，该排序对应的排序算法不同（依据是以上原理）。但在本程序中不使用排序算法，而是每次都遍历搜索满足条件的最值。

进程向程序申请内存Request：

无论是利用上述的哪种方法，都需要从已经给定的头节点开始遍历，找到>=需求的一块空间。
找到满足上述三种算法中最优的内存块：找到内存大小比need大的内存块中地址最小的、内存最小的、内存最大的。
上述最优的内存块分两种情况：

  • 内存=need:这种情况只需要在free队列删除该节点，并将其加入used队列即可。
  • 内存>need:这种情况需要将原节点信息中的size减小need大小然后在used队列中插入一个新节点。
进程释放内存Release：

释放进程时需要分以下四种情况：假设三块连续内存分别为f1、r、f2
上邻为f1（f1需搜索自由主存队列）,下邻为f2（f2可直接计算）

  • A)f1空闲，f2已分配； //f和f1合并，修改表项f1，数量不变
  • B)f1已分配，f2空闲； //f和f2合并，修改表项f2，数量不变
  • C)f1空闲，f2空闲； //f1 f f2合并，修改表项f1，删除f2
  • D)f1已分配，f2已分配； //增加空闲表项f

这里设计两个信号量bool f1_is_free = 1, f2_is_free = 1;分别用来判断f1、f2是否已分配，然后程序遍历两个队列正确修改信号量的值后，程序根据这两个值分四种情况对两个队列做出相应的修改即可。

可视化展示内存使用情况：

首先遍历输出两个队列的以下信息：

  • 1.头节点相对于总内存起点的偏移量
  • 2.该段内存实际大小

由于本程序中插入队列元素时没有对其排序，上述输出不直观，所以继续采用以下方法输出：
由内存的起点开始向后同时遍历两个队列，每次找到与之最相邻的那个内存块。
找到内存块后由flag判断其是否已占用，由size判断这块内存的大小。
输出头节点相对于总内存起点的偏移量然后输出不同数量的符号表示这块空间
原则：未占用用‘-’表示，已占用用‘+’表示
输出的数量（长度）与内存大小成正比。
输出示例：

在这里插入图片描述

整体实现的代码：

#include <iostream>
#include <fstream>
using namespace std;

struct rd {//分区描述器
    int flag = -1;  //分配标志，空闲为0，//不为0则表示进程编号
    int size = -1;   //分区大小，分区可用字数+分区描述器大小
    rd* next = NULL;   //对空闲区：指向下一个空闲分区，对已分配区：此项为零。
};
rd* Free = new rd, * Used = new rd;//分别用来存空闲队列和已占用队列

const int totalNum = 512;//需要申请的块数
const int maxsize = 512 * sizeof(rd);//实际需要申请的大小
rd* MainHead = (rd*)malloc(maxsize);//申请到的资源


rd* Request(int need,int choice) {//申请地址的函数，返回申请到的地址，为NULL则无法申请。
    //size为要申请的danwei大小的个数，实际大小为size* sizeof(rd);   
    int tem;
    rd* Ans = NULL;
    rd* p = NULL, * prep = new rd, * preAns = new rd;

    if (choice == 1) {//首次算法:按物理地址的顺序排列，优先地址最小的
        tem = INT_MAX;
        for (p = Free->next, prep->next = p; p != NULL; p = p->next, prep = prep->next)
            if ((int)p < tem && p->size > need)
                tem = (int)p, Ans = p, preAns = prep;
        if (Ans == NULL)
            return NULL;
    }
    else if (choice == 2) {//最佳算法按:照空闲容量递增排列，优先最小的
        tem = totalNum;
        for (p = Free->next, prep->next = p; p != NULL; p=p->next, prep= prep->next)
            if (p->size < tem && p->size > need)
                tem = p->size, Ans = p, preAns = prep;
        if (Ans == NULL)
            return NULL;
    }
    else  if (choice == 3) {//最坏算法：按照空闲容量递减排列，优先最大的
        tem = 0;
        for (p = Free->next, prep->next = p; p != NULL; p = p->next, prep = prep->next)
            if (p->size > tem) 
                tem = p->size, Ans = p, preAns = prep;
        if (tem < need)
            return NULL;
    }

    //修改free队列
    if (Ans->size == need)
        preAns->next = Ans->next;//删除表项
    else {
        Ans->size -= need;
        //Ans =(Ans+Ans->size * sizeof(rd));//后一半划分出去

 //       cout<<"当前分配地址距离开始" << Ans - MainHead << endl;
        Ans += Ans->size;
    }

    Ans->flag = 1;
    Ans->size = need;

    //修改used队列
    if (Used->next == NULL) {
        Used->next = Ans;
        Ans->next = NULL;
    }   else {
        Ans->next = Used->next;
        Used->next = Ans;
    }

    return Ans;
}
bool Release(rd* r) {//释放所给出的分区的地址，返回1表示正常释放
    if (r->flag == 0) {
        cout << "该空间未使用，无法释放" << endl;
        return 0;
    }

    rd* p = NULL;
    rd* f1 = NULL, * f2 = NULL;
   
    //先判断used
    for (p = Used->next; p != NULL; p = p->next) {
        if (p->next == r)
            f1 = p;
        if (r->next == p)
            f2 = p;
    }
    //再判断free
    for (p = Free->next; p != NULL; p = p->next) {
        if (p+p->size == r)
            f1 = p;
        if (r+r->size == p)
            f2 = p;
    }


    //修改used队列
    for (p = Used->next; p != NULL; p = p->next)
        if (p->next == r) {
            p->next = r->next;
            break;
        }




    bool f1_is_free = 1, f2_is_free = 1;
    if (f1->flag)
        f1_is_free = 0;
    if (f2 == NULL || f2->flag)
        f2_is_free = 0;
    //修改free队列
    if (f1_is_free && !f2_is_free) {     // A)f1空闲，f2已分配；     //f和f1合并，修改表项f1，数量不变
        f1->next = r->next;
        f1->size += r->size;
    }
    else if (!f1_is_free && f2_is_free) { // B)f1已分配，f2空闲；     //f和f2合并，修改表项f2，数量不变
        r->next = f2->next;
        r->flag = 0;
        r->size += f2->size;
        for (p = Free; p != NULL; p = p->next)//找到f2的前驱
            if (p->next == f2) {
                p->next = r;//后继修改为r
                break;
            }
    }
    else if (f1_is_free && f2_is_free) {  // C)f1空闲，f2空闲；       //f1 f f2合并，修改表项f1，删除f2
        for (p = Free; p != NULL; p = p->next)//找到f1的前驱
            if (p->next == f1) 
                break;
            
        if (p != f2->next)//防止构成环路
            f1->next = f2->next;
        f1->size += (f2->size+r->size);
        for (p = Free; p != NULL; p = p->next)//找到f2的前驱
            if (p->next == f2) {
                p->next = f2->next;//后继修改为r
                break;
            }
    }
    else if (!f1_is_free && !f2_is_free) {// D)f1已分配，f2已分配；   //增加空闲表项f
        r->flag = 0;
        if (Free->next == NULL) {
            Free->next = r;
            r->next = NULL;
        }
        else {
            r->next = Free->next;
            Free->next = r;
        }
    }
    return 1;
}
void show_detail() {//展示内存的使用情况
    rd* p = NULL;
    rd* Cur = MainHead;

    //先判断used
    cout <<"Used:--";
    for (p = Used->next; p != NULL; p = p->next) {
        cout << p - MainHead <<"_"<<p->size<< "--->";
    }
    cout << endl;
    //再判断free
    cout << "Free:--";
    for (p = Free->next; p != NULL; p = p->next) {
        cout << p - MainHead << "_" << p->size << "--->";
    }
    cout << endl;

    do{//直到当前是最后一块为止

        for (p = Free->next; p != NULL; p = p->next)
            if (Cur == p) {
                break;
            }
        for (p = Used->next; p != NULL; p = p->next)
            if (Cur == p) {
                break;
            }

        //到此就找到了上一次的Cur后跟的块（free或者used）
        //输出可视化
        //512个字节，共分为26段，已用用+++++表示，未用用======表示，每段用三个符号表示
        string u = "+++";
        string f = "---";

        if (Cur->flag == 0) {//为free
          //  cout << Cur->size;
            cout << Cur - MainHead;
            for (int i = 0; i < (Cur->size / 20); i++)
                    cout << f;

        }
        if (Cur->flag != 0) {//为free
            cout << Cur - MainHead;
            for (int i = 0; i < (Cur->size / 20); i++)
                cout << u;
        }
        Cur += Cur->size;
    } while ((Cur - MainHead )  < totalNum-1);

    cout << "|||";
    cout << endl << endl << endl << endl;



 }

int main()
{
    while (1) {
        cout << "——————————请输入放置策略————————" << endl;
        cout << "—— 首次：1     最佳：2    最坏：3    退出：0——" << endl;
        cout << "—————————————————————————" << endl;
        int method ;
        cin >> method;
        if(method==0) {
            system("cls");
            cout << "——————————Thanks!————————" << endl;
            return 0;
        }
        if (method != 1 && method != 2 && method != 3) {
            cout << "您的输入有误，请重新输入:" << endl;
            continue;
        }
            

        MainHead = (rd*)malloc(maxsize);//申请到的资源
        Free = new rd, Used = new rd;//分别用来存空闲队列和已占用队列
       
        MainHead->next = NULL;
        rd* fir = MainHead;fir->next = NULL; fir->flag = 0;  fir->size = totalNum - 1;
        Free->next = fir;

        char operat;
        int id, need;
        fstream In;
        In.open("请求.txt");
        if (!In.is_open())
            cout << "文件打开失败" << endl;
        cout << "初始状态：" << endl; show_detail();//展示初始状态
        while (!In.eof()) {
            In >> operat;
            
            if (operat == '+') {
                In >> id >> need;
                rd* req = Request(need+1, method);//req为申请到的地址
                if (req == NULL) {
                    cout << "     失败___" << id << " +++ " << need << " " << endl;
                    break;
                }
                cout << "     成功___" <<id<< " +++ " << need << " " << endl;
                req->flag = id;
                req->size = need+1;
            }
            else 
            if (operat == '-') {
                In >> id ;
                rd* rel = Used->next;
                for (; rel != NULL; rel=rel->next)
                    if (rel->flag == id)
                        break;
                int rel_ans = 1;
                int rel_size = rel->size;
                if (rel == Used->next) {
                    cout << "进程" << id << "没有正在使用的空间" << endl;
                    break;
                }
                else 
                    rel_ans = Release(rel);

                if (rel_ans == 0) {
                    cout << "进程___" << id << "无法释放" << endl;
                }
                else 
                    cout << "     成功___" << id << " --- " << rel_size << "  " << endl;
                

            }
            else {
                cout << operat << "读取失败" << endl;
                break;
            }
            show_detail();//展示每次修改后的结果
        }
        free(MainHead);
}
    return 0;
}

程序运行情况：

测试数据：
  • 在这里插入图片描述
运行截图：
  • 方法二：最佳优先算法
    在这里插入图片描述
    在这里插入图片描述
Cheney822
关注
  • 14
    点赞
  • 踩
  • 180
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
操作系统—可变式分区存储管理（C++实现）
05-13
可变式分区存储管理： 通过文件操作读取空闲区表（包含空闲区的起始地址和长度），通过用户选择分配/回收内存，回收的内存如果和空闲区表的内存块相邻，则进行合并 注：解决方案中带有data.txt文件，并在代码中指定解决方案的data.txt文件，如需用户输入指定路径下的文件，只需要把代码中相关代码取消注释即可 语言：C++ 运行环境：Visual Studio 2013/更高版本
操作系统-分区式存储管理算法.zip
12-25
操作系统存储管理算法 首次适应、最佳适应、最差适应算法 输入： 1）当前内存空闲分区的序列，包括起始地址、空闲分区大小。 2）进程的分区请求序列。 输出要求： 1）三种算法的空闲分区队列。 2）三种算法的分配结果。
动态分区存储管理实验要点和难点以及常见报错解决
最新发布
2401_84235249的博客
06-20 587
同时，需要熟悉并掌握多重动态分区的实现原理、分配与释放过程，以及相关的分配算法（如最先适应算法、最佳适应算法、最坏适应算法等）。实验总结：通过实验，可以加深对动态分区存储管理的理解，掌握动态分区分配和回收的各种算法和策略，提高解决实际问题的能力。动态分区存储管理实验的主要目的是熟悉并掌握动态分区分配的各种算法，以及动态分区中分区回收的各种情况，并能够实现分区合并。需要熟悉这些算法的工作原理，并能够用代码实现。实现分区回收和合并：当用户释放某个分区时，系统需要回收该分区，并根据需要与相邻的空闲分区进行合并。
操作系统（五）存储管理方案
旺旺的碎冰冰~的博客
09-05 1754
存储管理方案
存储管理——动态分区分配算法
06-23
操作系统课设做的动态分区分配算法。第一次上传资源，做的有些乱，献丑了，其中循环首次循环和最佳、最坏分配算法其实只是从首次适应算法改了一点东西。 补充几句，是JAVA做的，分配和回收算法都有，使用数组实现
操作系统——存储管理方式
m0_64567550的博客
05-07 2292
另一个是用户区，它是除系统区以外的全部内存区域，这部分区域是提供给用户使用的区域，任何时刻主存储器中最多只有一个作业，作业放在从用户区起始地址开始的连续地址区域。OS核心处于0环内；内存空间的分配与回收是基于可变分区管理，以作业的段为单位，按照某种分配算法，从空闲分区表/链中找到符合段所需大小的分区，一个段一个段，最终完成整个作业的内存空间分配。进程结束后，按照段表查找每段在内存的起始地址和大小，然后按段一个一个回收其占用的内存，同时修改空闲分区表，把进程所有段回收，则完成整个进程所占内存空间的回收。
动态分区存储管理
qq_52711820的博客
06-06 280
操作系统第三次实验
操作系统--动态分区存储管理
weixin_44620183的博客
07-09 4562
操作系统–动态分区存储管理 实验内容： 分区分配算法至少实现首次适应算法、最佳适应算法和最坏适应算法中的至少一种。熟悉并掌握各种算法的空闲区组织方式。 分区的初始化——可以由用户输入初始分区的大小。（初始化后只有一个空闲分区，起始地址为0，大小是用户输入的大小） 分区的动态分配过程：由用户输入作业号和作业的大小，实现分区过程。 分区的回收：用户输入作业号，实现分区回收，同时，分区的合并要体现出来。（注意：不存在的作业号要给出错误提示！） 分区的显示：任何时刻，可以查看当前内存的情况（起始地址是什么，大小多大
动态分区分配存储管理方式的内存分配回收
振华OPPO的博客世界
03-26 8600
在动态分区分配存储管理方式的内存分配中，当有作业请求装入时，根据作业的需要内存空间的大小查询内存各个空闲区，从中找到一个大于或等于该作业大小的内存空闲区，然后按作业需求量划出一个分区装入该作业。作业执行完后，它占用的内存区被收回，称为空闲区，如果该空闲区的相邻分区也是空闲区，就要合并成为一个空闲区。
动态分区式存储管理-操作系统模拟
07-10
动态分区式存储管理是操作系统内存管理的一种方法，它将内存划分为多个可变大小的分区，以满足不同大小进程的存储需求。在这个场景下，我们关注的是C++模拟实现的操作系统动态分区分配中的最佳适应算法（Best Fit）...
分区式存储管理算法.rar
01-01
分区式存储管理是操作系统中内存管理的一种方法，它将主存划分为若干固定大小的区域，每个区域称为一个分区。这种管理方式主要用于早期的计算机系统，以及一些嵌入式系统和实时系统中，因为它简单且易于实现。在...
操作系统课程设计-分页式内存管理：源代码+实验报告
01-06
操作系统课程设计中，分页式内存管理是一种关键的内存组织策略，它将主存划分为固定大小的块，称为页，而进程的虚拟地址空间也被分割成同样大小的页。这个设计旨在解决内存碎片问题，提高内存利用率。下面将详细讨论...
操作系统第三次实验-动态分区存储管理(python代码实现)
qq_49383677的博客
01-04 3272
在具体的代码实现中，我采用的是Python语言，因为Python中列表这一数据结构可以较为简便地实现分区的增删改，在处理BF和WF内存分配算法时需要注意在分区空间相同时优先向低地址的分区分配作业，这个要求的实现如果不细想的话可能觉得比较复杂，实际在仔细考虑之后只需将排序算法中小于或大于的比较中加上等号就可实现了，因为本身分区是按地址从小到大依次排序的，那么在加上等号之后就可实现在新的排序中即使分区的大小相同，也是地址较小的靠前。分区的回收：用户输入作业号，实现分区回收，同时，分区的合并要体现出来。
十三.动态内存管理
weixin_67401157的博客
01-16 2740
动态内存管理，主要动态内存函数，柔性数组的介绍
动态分区分配策略（四种）
爱学习的JackYang的博客
10-19 6424
第一种：首次适应算法（Firstfit） 按空闲分区依地址递增次序链接，分配内存时按顺序查找,放入第一个匹配到的空闲分区，会造成内部碎片，有着较大的浪费 第二种：最佳适应算法（Bestfit） 将空闲分区按内存大小递增的顺序链接起来，分配内存时按照顺序放入第一个匹配的空闲分区。 第三种：最坏适应算法（Worstfit） 将空闲分区按容量递减的顺序链接起来，分配内存时放入第一个匹配的...
操作系统 连续分配存储管理方式（含动态分区分配算法）
qq_45186202的博客
01-14 9895
看教材枯燥，码字记录提神，根据计算机操作系统（第四版，汤小凤）个人整理，仅作学习记录 :) 为了能将用户程序装入内存，必须为它分配一定大小的内存空间。连续分配存储管理方式是最早出现的一种存储器分配方式。 该分配方式为一个用户程序分配一个连续的内存空间，即程序中代码或数据的逻辑地址相邻，体现在内存分配时物理地址的相邻。 连续分配方式可分为四类： 单一连续分配 固定分区分配 动态分区分配 动态可重定位分区分配 1. 单一连续分配 单道程序环境下，当时的存储器管理方式是把内存分为系统区和用户区两部分。 系统
操作系统实验实验二分区式存储管理
笑着敲代码
11-23 496
操作系统实验实验二——分布式存储管理
操作系统-模拟动态分区管理
LJW_IIE的博客
05-31 1245
目录1、实验目的2、实验内容3、算法设计4、运行与测试5、总结心得 1、实验目的 （1）加深理解内存的分配与回收，分配与回收的策略、地址映射、内存保护等概念。 2、实验内容 设计一个模拟内存管理中采用“动态分区”方式的存储器管理程序，实现以下操作： （1）以链接存储结构建立内存分配表、内存空闲表并进行初始化； （2）动态申请一段内存，对该段内存进行“动态分区”方式的管理，选择最先适配算法进行分配； （3）创建3个进程并装入内存，撤销第2个进程（释放内存）； （4）输出当前“内存”的使用情况。 3、算法设计
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Cheney822

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值