【操作系统】内存分配与回收

已于 2023-08-18 17:45:00 修改
阅读量2.8k 收藏 32
点赞数 3
文章标签： c++ 算法 数据结构
于 2020-12-14 16:26:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SGchi/article/details/111169521
版权
该博客介绍了两种内存分配方法——Firstfit和Nextfit，以及相应的内存回收机制。Firstfit策略从空闲分区表的开始寻找合适的空间分配，而Nextfit则从上次分配后的位置开始查找。程序实现了这两种分配法，允许用户分配和回收内存，并显示内存占用情况和空闲分区列表。此外，还提供了计算平均搜索空闲区次数的功能。
摘要由CSDN通过智能技术生成

实现了两种内存分配方法，和内存回收机制

First fit 分配法

在这里插入图片描述

// #include <iomanip>
#include <iostream>
#include<algorithm>
#define M 20
#define N 20
using namespace std;

//假定最大空闲分区20个，内存中同时最多可容纳的作业数20个
struct my_empty//空闲分区表
{
    int address_of_start; //起始地址
    int size_of_empty; //空闲大小,依据分配单元考虑，即大小为分配单元数而非实际字节数
    int yesorno; //是否空闲,1 空闲，有效
} Empty[M];

struct not_empty//已分配分区表
{
    int process_id;//作业标志符，此处采用0-255的整数
    int address_of_start;//起始地址
    int size_of_notempty;//作业请求的内存单元数
    int yesorno; //是否已分配，1 已分配 有效
} Not_Empty[N];

int CountOfEmpty = 1, CountOfNotEmpty = 0; //假定从0时刻开始，最初内存中没有作业
int Max_Size = 256;   //最大空间256 X 1kb = 256kb
int Num_Of_Row = 20; //显示时，横排个数
int Num_of_Holes = 0; //碎片空闲区个数
int Time[N];     //进程分配搜索空闲区次数
int num = 0;

bool cmp(const my_empty& a, const my_empty& b) {
    return a.address_of_start < b.address_of_start;
}

bool cmp2(const my_empty& a, const my_empty& b) {
    return a.address_of_start > b.address_of_start;
}

bool cmp_NotEmpty(const not_empty& a, const not_empty& b) {
    return a.address_of_start < b.address_of_start;
}
bool cmp_NotEmpty2(const not_empty& a, const not_empty& b) {
    return a.address_of_start > b.address_of_start;
}
int enough(int Size_Of_NotEmpty) //判断是否存在可分配给新作业的空闲区
{
    int i;
    for (i = 0; i < CountOfEmpty; i++) //首次适配 first fit
    {
        if (Empty[i].size_of_empty >= Size_Of_NotEmpty) {
            Time[num] += 1;
            num++;
            return i;
        }
        else {
            Time[num] += 1;
        }
    }
    return -1;
}

int fenpei()
{
    int temp, i;
    CountOfNotEmpty += 1;
    Not_Empty[CountOfNotEmpty].yesorno = 0;
    for (i = 0; i < CountOfNotEmpty; i++) {
        if (Not_Empty[i].yesorno == 0) {
            cout << "输入进程ID (0 ~ 255),占用空间大小(0 ~ " << 10 << ")\n";
            cin >> Not_Empty[i].process_id >> Not_Empty[i].size_of_notempty;
            if (Not_Empty[i].process_id < 0 || Not_Empty[i].process_id >255)
            {
                CountOfNotEmpty -= 1;
                cout << "进程号 0 ~ 255\n";
                return -1;
            }
            for (int ii = 0; ii < CountOfNotEmpty; ii++)
            {
                if (Not_Empty[i].process_id == Not_Empty[ii].process_id && i != ii)
                {
                    CountOfNotEmpty -= 1;
                    cout << "进程号必须唯一\n";
                    return -1;
                }
            }
            temp = enough(Not_Empty[i].size_of_notempty);
            if (temp >= 0) //找到了能满足请求的空闲分区
            {
                Not_Empty[i].address_of_start = Empty[temp].address_of_start;
                Not_Empty[i].yesorno = 1;// 占用队列有效
                Empty[temp].address_of_start += Not_Empty[i].size_of_notempty;//修改空闲队列
                Empty[temp].size_of_empty -= Not_Empty[i].size_of_notempty;
                if (Empty[temp].size_of_empty == 0) {
                    Empty[temp].yesorno = 0;
                }
                if (Empty[temp].size_of_empty <= 2 && Empty[temp].size_of_empty >= 1)
                    Num_of_Holes++;
                return 0;
            }
            else
            {
                CountOfNotEmpty -= 1;
                cout << "未找到足够大的空闲分区\n";
                return -1;
            }
        }
    }
}

int huishou() {
    int id, flag = 0;
    cout << "输入进程ID (0 ~ 255)：\n";
    cin >> id;
    if (id > 255 || id < 0) {
        cout << "进程号 0 ~ 255\n";
        return -1;
    }

    for (int i = 0; i < CountOfNotEmpty; i++) { //检测回收进程是否在占用队列中
        if (Not_Empty[i].process_id == id) {
           
            int tmp_start = Not_Empty[i].address_of_start;
            int tmp_size = Not_Empty[i].size_of_notempty;
            int tmp_end = tmp_start + tmp_size;

            Not_Empty[i].process_id = 0;//回收占用进程
            Not_Empty[i].address_of_start = 0;           
            Not_Empty[i].size_of_notempty = 0;
            Not_Empty[i].yesorno = 0;
           

            //修改空闲队列
            for (int j = 0; j < CountOfEmpty; j++) {
                if (Empty[j].yesorno == 1) {
                    if (tmp_end == Empty[j].address_of_start) {//回收进程在空闲区前面，向前合并
                        Empty[j].address_of_start -= tmp_size;
                        Empty[j].size_of_empty += tmp_size;
                        flag = 1;
                        break;
                    }
                    else if (Empty[j].address_of_start + Empty[j].size_of_empty == tmp_start) {//回收进行在空闲向后合并
                        Empty[j].size_of_empty += tmp_size;
                        if (j + 1 < CountOfEmpty && Empty[j + 1].address_of_start == tmp_end) {//左右合并，空闲区个数减一                      
                            Empty[j].size_of_empty += Empty[j + 1].size_of_empty;
                            Empty[j + 1].address_of_start = 0;//清空合并空闲队列
                            Empty[j + 1].size_of_empty = 0;
                            Empty[j + 1].yesorno = 0;
                            sort(Empty, Empty + CountOfEmpty, cmp2);
                            CountOfEmpty--;
                            sort(Empty, Empty + CountOfEmpty, cmp);
                            flag = 1;
                            break;
                        }                       
                    }
                }               
            }

            if (flag == 0) {//未与已存在空闲区合并，生成独立空闲区
                Empty[CountOfEmpty].address_of_start = tmp_start;//创建空进程
                Empty[CountOfEmpty].size_of_empty = tmp_size;
                Empty[CountOfEmpty].yesorno = 1;      
                CountOfEmpty += 1;
                sort(Empty, Empty + CountOfEmpty, cmp);              
                flag = 1;
                break;
            } 
        }
    }

    if (flag == 0) {
        cout << "进程不存在" << endl;
    }

    return 1;
}

int fragment_count() {//碎片空闲分区数
    return Num_of_Holes;
}

double NumofReaserch(){
    int sum = 0;
    for (int i = 0; i < num; i++) {
        sum += Time[i];
    }
    return sum * 1.0 / num;
}

void show_empty()//显示空闲区队列【包括起始地址和空闲区大小】
{
    int i;
    cout << "\n空闲分区列表\n";
    for (i = 0; i < CountOfEmpty; i++)
    {
        if (Empty[i].yesorno == 1)
        {
            cout << Empty[i].address_of_start << ' ' << Empty[i].size_of_empty << endl;
        }
    }
    cout << "\n碎片空闲分区数： " << fragment_count() << endl;
}


void show() {
    int k = 0;
    sort(Not_Empty, Not_Empty + CountOfNotEmpty, cmp_NotEmpty);
    for (int i = 0; i < Max_Size; i++) {
        if (i % Num_Of_Row == 0) {
            cout << endl;
        }
        while (Not_Empty[k].yesorno == 0) { k++; }

        if (Not_Empty[k].address_of_start == i) {                
                for (int j = 0; j < Not_Empty[k].size_of_notempty; j++) {
                    if (j == 0) {
                        cout << Not_Empty[k].process_id;
                    }
                    else {
                        cout << "+";
                        if ((i+j+1) % Num_Of_Row == 0 && j != Not_Empty[k].size_of_notempty-1) {
                            cout << endl;
                        }
                    }
                }
                i += Not_Empty[k].size_of_notempty - 1;       
                k++;
        }
      
        else {
            cout << "-";
        }      
    }
}

int main()
{
    Empty[0].address_of_start = 0;
    Empty[0].size_of_empty = Max_Size;
    Empty[0].yesorno = 1;
    int i;
    cout << "******************Memory Size: " << Max_Size << "KB*******************\n" << endl;
    cout << "1 分配;                      2 回收;\n3 内存占用情况图;            4 退出\n";
    cout << "\n请输入你的选择(1~4):\n";
    while (cin >> i)
    {
        switch (i)
        {
        case 1:
            if (fenpei() == 0)
                show();//内存占用情况图：注意用不同符号表示某个单元是空闲还是已经分配给作业
            show_empty();//显示空闲区链
            cout<<"\n平均搜索空闲区次数： "<< NumofReaserch() <<endl;
            break;
        case 2:huishou();//回收内存【注意图1的组合情况】
            show();//内存占用情况图
            show_empty();//空闲区链
            break;
        case 3:
            show();
            break;
        case 4:return 0;
        default: break;
        }
        cout << "******************Memory Size: " << Max_Size << "KB*******************\n" << endl;
        cout << "1 分配;                      2 回收;\n3 内存占用情况图;          4 退出\n";
        cout << "\n请输入你的选择(1~4):\n";
    }
    return 0;
}

Next Fit分配法

在这里插入图片描述

// #include <iomanip>
#include <iostream>
#include<algorithm>
#define M 20
#define N 20
using namespace std;

//假定最大空闲分区20个，内存中同时最多可容纳的作业数20个
struct my_empty//空闲分区表
{
    int address_of_start; //起始地址
    int size_of_empty; //空闲大小,依据分配单元考虑，即大小为分配单元数而非实际字节数
    int yesorno; //是否空闲,1 空闲，有效
} Empty[M];

struct not_empty//已分配分区表
{
    int process_id;//作业标志符，此处采用0-255的整数
    int address_of_start;//起始地址
    int size_of_notempty;//作业请求的内存单元数
    int yesorno; //是否已分配，1 已分配 有效
} Not_Empty[N];

int CountOfEmpty = 1, CountOfNotEmpty = 0; //假定从0时刻开始，最初内存中没有作业
int Max_Size = 256;   //最大空间256 X 1kb = 256kb
int Num_Of_Row = 20; //显示时，横排个数
int Num_of_Holes = 0; //碎片空闲区个数
int Time[N];     //进程分配搜索空闲区次数
int num = 0;
int Next_fit_count = 0;
bool cmp(const my_empty& a, const my_empty& b) {
    return a.address_of_start < b.address_of_start;
}

bool cmp2(const my_empty& a, const my_empty& b) {
    return a.address_of_start > b.address_of_start;
}

bool cmp_NotEmpty(const not_empty& a, const not_empty& b) {
    return a.address_of_start < b.address_of_start;
}
bool cmp_NotEmpty2(const not_empty& a, const not_empty& b) {
    return a.address_of_start > b.address_of_start;
}
int enough(int Size_Of_NotEmpty) //判断是否存在可分配给新作业的空闲区
{
    for (int i = Next_fit_count; i < CountOfEmpty; i++) //nest fit
    {
        if (Empty[i].size_of_empty >= Size_Of_NotEmpty) {
            Time[num] += 1;
            num++;
            Next_fit_count = i;
            return i;
        }
        else {
            Time[num] += 1;
        }
    }

    for (int i = 0; i < Next_fit_count; i++) //nest fit
    {
        if (Empty[i].size_of_empty >= Size_Of_NotEmpty) {
            Time[num] += 1;
            num++;
            return i;
        }
        else {
            Time[num] += 1;
        }
    }

    return -1;
}

int fenpei()
{
    int temp, i;
    CountOfNotEmpty += 1;
    Not_Empty[CountOfNotEmpty].yesorno = 0;
    for (i = 0; i < CountOfNotEmpty; i++) {
        if (Not_Empty[i].yesorno == 0) {
            cout << "输入进程ID (0 ~ 255),占用空间大小(0 ~ " << 10 << ")\n";
            cin >> Not_Empty[i].process_id >> Not_Empty[i].size_of_notempty;
            if (Not_Empty[i].process_id < 0 || Not_Empty[i].process_id >255)
            {
                CountOfNotEmpty -= 1;
                cout << "进程号 0 ~ 255\n";
                return -1;
            }
            for (int ii = 0; ii < CountOfNotEmpty; ii++)
            {
                if (Not_Empty[i].process_id == Not_Empty[ii].process_id && i != ii)
                {
                    CountOfNotEmpty -= 1;
                    cout << "进程号必须唯一\n";
                    return -1;
                }
            }
            temp = enough(Not_Empty[i].size_of_notempty);
            if (temp >= 0) //找到了能满足请求的空闲分区
            {
                Not_Empty[i].address_of_start = Empty[temp].address_of_start;
                Not_Empty[i].yesorno = 1;// 占用队列有效
                Empty[temp].address_of_start += Not_Empty[i].size_of_notempty;//修改空闲队列
                Empty[temp].size_of_empty -= Not_Empty[i].size_of_notempty;
                if (Empty[temp].size_of_empty == 0) {
                    Empty[temp].yesorno = 0;
                }
                if (Empty[temp].size_of_empty <= 2 && Empty[temp].size_of_empty >= 1)
                    Num_of_Holes++;
                return 0;
            }
            else
            {
                CountOfNotEmpty -= 1;
                cout << "未找到足够大的空闲分区\n";
                return -1;
            }
        }
    }
}

int huishou() {
    int id, flag = 0;
    cout << "输入进程ID (0 ~ 255)：\n";
    cin >> id;
    if (id > 255 || id < 0) {
        cout << "进程号 0 ~ 255\n";
        return -1;
    }

    for (int i = 0; i < CountOfNotEmpty; i++) { //检测回收进程是否在占用队列中
        if (Not_Empty[i].process_id == id) {
           
            int tmp_start = Not_Empty[i].address_of_start;
            int tmp_size = Not_Empty[i].size_of_notempty;
            int tmp_end = tmp_start + tmp_size;

            Not_Empty[i].process_id = 0;//回收占用进程
            Not_Empty[i].address_of_start = 0;           
            Not_Empty[i].size_of_notempty = 0;
            Not_Empty[i].yesorno = 0;
           

            //修改空闲队列
            for (int j = 0; j < CountOfEmpty; j++) {
                if (Empty[j].yesorno == 1) {
                    if (tmp_end == Empty[j].address_of_start) {//回收进程在空闲区前面，向前合并
                        Empty[j].address_of_start -= tmp_size;
                        Empty[j].size_of_empty += tmp_size;
                        flag = 1;
                        break;
                    }
                    else if (Empty[j].address_of_start + Empty[j].size_of_empty == tmp_start) {//回收进行在空闲向后合并
                        Empty[j].size_of_empty += tmp_size;
                        if (j + 1 < CountOfEmpty && Empty[j + 1].address_of_start == tmp_end) {//左右合并，空闲区个数减一                      
                            Empty[j].size_of_empty += Empty[j + 1].size_of_empty;
                            Empty[j + 1].address_of_start = 0;//清空合并空闲队列
                            Empty[j + 1].size_of_empty = 0;
                            Empty[j + 1].yesorno = 0;
                            sort(Empty, Empty + CountOfEmpty, cmp2);
                            CountOfEmpty--;
                            sort(Empty, Empty + CountOfEmpty, cmp);
                            flag = 1;
                            break;
                        }                       
                    }
                }               
            }

            if (flag == 0) {//未与已存在空闲区合并，生成独立空闲区
                Empty[CountOfEmpty].address_of_start = tmp_start;//创建空进程
                Empty[CountOfEmpty].size_of_empty = tmp_size;
                Empty[CountOfEmpty].yesorno = 1;      
                CountOfEmpty += 1;
                sort(Empty, Empty + CountOfEmpty, cmp);              
                flag = 1;
                break;
            } 
        }
    }

    if (flag == 0) {
        cout << "进程不存在" << endl;
    }

    return 1;
}

int fragment_count() {//碎片空闲分区数
    return Num_of_Holes;
}

double NumofReaserch(){
    int sum = 0;
    for (int i = 0; i < num; i++) {
        sum += Time[i];
    }
    return sum * 1.0 / num;
}

void show_empty()//显示空闲区队列【包括起始地址和空闲区大小】
{
    int i;
    cout << "\n空闲分区列表\n";
    for (i = 0; i < CountOfEmpty; i++)
    {
        if (Empty[i].yesorno == 1)
        {
            cout << Empty[i].address_of_start << ' ' << Empty[i].size_of_empty << endl;
        }
    }
    cout << "\n碎片空闲分区数： " << fragment_count() << endl;
}


void show() {
    int k = 0;
    sort(Not_Empty, Not_Empty + CountOfNotEmpty, cmp_NotEmpty);
    for (int i = 0; i < Max_Size; i++) {
        if (i % Num_Of_Row == 0) {
            cout << endl;
        }
        while (Not_Empty[k].yesorno == 0) { k++; }

        if (Not_Empty[k].address_of_start == i) {                
                for (int j = 0; j < Not_Empty[k].size_of_notempty; j++) {
                    if (j == 0) {
                        cout << Not_Empty[k].process_id;
                    }
                    else {
                        cout << "+";
                        if ((i+j+1) % Num_Of_Row == 0 && j != Not_Empty[k].size_of_notempty-1) {
                            cout << endl;
                        }
                    }
                }
                i += Not_Empty[k].size_of_notempty - 1;       
                k++;
        }
      
        else {
            cout << "-";
        }      
    }
}

int main()
{
    Empty[0].address_of_start = 0;
    Empty[0].size_of_empty = Max_Size;
    Empty[0].yesorno = 1;
    int i;
    cout << "******************Memory Size: " << Max_Size << "KB*******************\n" << endl;
    cout << "1 分配;                      2 回收;\n3 内存占用情况图;            4 退出\n";
    cout << "\n请输入你的选择(1~4):\n";
    while (cin >> i)
    {
        switch (i)
        {
        case 1:
            if (fenpei() == 0)
                show();//内存占用情况图：注意用不同符号表示某个单元是空闲还是已经分配给作业
            show_empty();//显示空闲区链
            cout<<"\n平均搜索空闲区次数： "<< NumofReaserch() <<endl;
            break;
        case 2:huishou();//回收内存【注意图1的组合情况】
            show();//内存占用情况图
            show_empty();//空闲区链
            break;
        case 3:
            show();
            break;
        case 4:return 0;
        default: break;
        }
        cout << "******************Memory Size: " << Max_Size << "KB*******************\n" << endl;
        cout << "1 分配;                      2 回收;\n3 内存占用情况图;          4 退出\n";
        cout << "\n请输入你的选择(1~4):\n";
    }
    return 0;
}
SGchi
关注
  • 3
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
操作系统 内存分配与回收 C语言模拟（含源代码和.exe文件）
06-22
操作系统内存分配与回收C语言模拟。包含源代码和.exe可执行文件
内存分配与回收 操作系统实验
04-11
本人以前的操作系统实验，当时是用eclipse写的，生成的.class文件在dos下可能无法直接运行。读者可以在src目录下面找到源代码，打开所有.java文件，把第一句package CPUScheduling去掉，然后保存自己重新编译，然后...
操作系统—实现可变式分区分配算法
Voltline的博客
04-17 1309
实现可变式分区分配算法
操作系统-内存概念部分01-内存管理-内存分配-内存回收-Buffer和Cache
最新发布
pass
05-20 951
linux性能优化专栏学习的复习，关于内存部分的理论知识，几个核心概念的整理
c语言实现操作系统可变分区管理---内存的最先分配算法首先实现，再逐步完成最优和最坏的分配算法，编写全部程序。
weixin_63161204的博客
12-04 654
【代码】c语言实现操作系统可变分区管理---内存的最先分配算法首先实现，再逐步完成最优和最坏的分配算法，编写全部程序。
可变分区方式下的最优适应调度算法(C++环境下实现)
JAVA,C#,ASP.NET学习驿站
12-09 2030
#include #include #include #define n 10    //假定系统允许的最大作业量n#define m 10    //假定系统允许的空闲区表最大为m#define minsize 100using namespace std;struct use{   float address;    float length; string flag; char uname;
C语言实现简易内存回收
qq_18572807的博客
11-28 2246
对于初级程序员来说内存回收似乎是个遥不可及的东西，本文介绍了如何使用C语言实现简易的内存回收代码，一步步带你揭开内存回收的神秘面纱。
计算机操作系统内存分配实验报告.doc
05-13
计算机操作系统内存分配是操作系统核心功能之一，实验报告中主要探讨了在可变分区存储管理方式下，如何实现主存的分配与回收。可变分区管理允许分区大小根据作业需求动态调整，以确保有效利用内存资源。 实验的目标...
操作系统 内存的分配与回收 实验报告
04-17
操作系统中的内存管理是确保系统高效运行的关键组成部分...总的来说，操作系统内存的分配与回收是一个复杂且重要的问题。实验报告提供了直观的案例，展示了不同分配策略的优缺点，有助于深入理解和掌握内存管理的精髓。
操作系统实验二内存分配及回收
08-02
在本实验“操作系统实验二：内存分配及回收”中，我们将深入探讨在可变分区管理方式下如何有效地进行内存的分配与回收，主要关注最先适应算法的实现。 内存管理是操作系统的重要职责之一，它的目标是确保程序高效、...
操作系统实验三：主存空间的分配与回收
weixin_59532801的博客
07-23 1302
采用可变式分区管理，使用最佳适应算法实现主存的分配与回收主存是中央处理机能直接存取指令和数据的存储器。能否合理而有效地使用主存，在很大程度上将影响到整个计算机系统的性能。本实验采用可变式分区管理，使用首次或最佳适应算法实现主存空间的分配与回收。要求采用分区说明表进行。通过本次实验，帮助学生理解在可变式分区管理方式下，如何实现主存空间的分配与回收。提示：1.可变式分区管理是指在处理作业过程中建立分区，使分区大小正好适合作业的需要，并且分区个数是可以调整的。
操作系统实验·动态分区分配算法
居贝比的博客
12-10 1万+
【实验目的】 1、 熟悉内存自由空闲队列的分配策略 2、 熟悉内存分区的回收原则及实现过程 3、 通过实验深刻理解主存管理的内容 【实验内容】 模拟内存的动态分配和回收，并编程实现。 【实验报告】 1、 列出调试通过程序的清单，并附上文档说明。 2、 总结上机调试过程中所遇到的问题和解决方法及感想。 【实验说明】 实验原理 内存的分配可采用操作系统中的首次适应算法、最佳适...
操作系统实验之内存管理
qq_64377514的博客
05-27 2406
内存回收原理：找到当前回收的内存区间，首先判断是否和前一个区间相邻且空闲，如果相邻的话则该分区和前一分区合并，形成更大的空闲分区；若和前一空闲分区不相邻，则判断该分区是否和后一分区相邻且空闲，则该分区和后一分区合并，形成更大的空闲分区；如果该分区和前后空闲分区都不相邻，则将该分区以后的所有表目向后移动一个，形成一个新的表目并插入新释放的分区。内存分区使用分区（说明）表进行管理，采用最先适应算法从分区表中寻找空闲区进行分配，考虑内存回收时相邻空闲区的合并。•作业1申请130KB •作业2申请60KB。
操作系统实验代码-动态分区分配算法-C++实现
sf_nine的博客
10-29 1979
通过这次实验，加深对动态分区分配算法的理解，进一步掌握首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法的实现方法。
操作系统——存储管理实验
HELLO_CPY的博客
05-15 1176
计算机小白自制，关于操作系统的存储管理实验，实验涉及到五种算法实现，感兴趣可以进来看看，欢迎批评指正，谢谢大家
Unix/Linux操作系统分析实验二 内存分配与回收：Linux系统下利用链表实现动态内存分配
weixin_45720714的博客
01-27 2164
本文章用于记录自己所学的内容，方便自己回顾复习。 实验内容 利用malloc和 calloc函数实现动态内存的分配；利用free函数实现动态内存的释放； 利用realloc函数实现调整内存空间的大小； 利用链表实现动态内存分配。 Linux操作系统原理与应用教材(第2版陈莉君)上的第四章 例 4-1(P95)、4-2(P96)、4-3(P98)、4-4(P98)、5-1(P143)、P158 Linux操作系统原理与应用教材(第2版陈莉君)上的第八章 例8-1 实验步骤 利用malloc函
操作系统第四次实验-基本分页存储管理（python代码实现）
qq_49383677的博客
01-04 2122
其次因为作业分配和回收之间需要靠物理块号来确定每个作业所有物理块在内存中的位置，这其中需要进行行号、列号与物理块号的转换，稍微有一些麻烦，我采用的是通过在作业数据结构定义一个存储每一个物理块行号和列号的列表，每分配一个页面到物理块就记录该物理块的行号与列号，两者作为一个元素，保存至该列表中，在进行作业回收时直接根据该列表中的记录在内存中回收物理块即可，相对来说实现容易一些。（3）作业空间回收是输入作业名，回收相应的空间，如果这个作业名不存在，也要有相应的提示。（1）内存空间不足的情况，要有相应的显示；
【OS系列-4】- 内存详解(分配和回收)
春秋繁露
01-16 1776
内存详解(分配和回收内存申请malloc()/free()和new/delete异同为什么C++不淘汰malloc？malloc 的系统过程？怎么避免内存碎片化？动态内存管理内存分配三种形式内存分配的方式空间分配与回收所产生的问题分配算法边界标识法回收算法伙伴系统动态管理分配算法垃圾回收机制无用单元回收内存紧缩（避免内存碎片化） 《深入理解计算机系统》（P580） 从Code Segment到Stack的内存地址均位于用户空间中，其地址空间由低到高。其中： Code Segment(代码段或Tex
Mybatis-Plus字段策略FieldStrategy详解
热门推荐
弹指天下
07-06 2万+
Mybatis-Plus字段策略FieldStrategy使用详解
操作系统内存分配与回收算法模拟实现
本资源是一份关于操作系统内存分配算法模拟实现的详细文档，主要关注于操作系统如何通过内存管理来支持多道程序并发执行。实验目标包括理解操作系统如何通过作业调度选择作业进入内存，如何为这些作业分配内存空间，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值