用循环首次适应算法、最佳适应算法和最坏适应算法，模拟可变分区存储管理，实现对内存区的分配和回收管理

最新推荐文章于 2023-05-13 19:31:02 发布
最新推荐文章于 2023-05-13 19:31:02 发布
阅读量7.1k 收藏 90
点赞数 10
分类专栏： 操作系统 文章标签： c++ 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45688165/article/details/117171675
版权

湖南师范大学 信息科学与工程学院 操作系统课程实验报告

实验项目名称： 可变分区存储管理

题目

实验一、可变分区存储管理
一、实验目的：

  1. 加深对可变分区存储管理的理解；
  2. 提高用C语言编制大型系统程序的能力，特别是掌握C语言编程的难点：指针和指针作为函数参数；
  3. 掌握用指针实现链表和在链表上的基本操作。
    二、实验内容：
    参照教材P137-P140的内容，编写一个C程序，用char *malloc（unsigned size）函数向系统申请一次内存空间（如size=1000，单位为字节），用循环首次适应算法、最佳适应算法和最坏适应算法，模拟可变分区存储管理，实现对内存区的分配和回收管理。
    三、实验要求：
  4. 分配函数addr=（char *）lmalloc（unsigned size）和释放函数lfree（unsigned size，char *addr）的参数size和addr，要以键盘命令的形式输入，每次分配和释放后显示空闲分区表。
  5. 空闲分区表可采用结构数组的形式（最低要求）或双向链表的形式。
    四、参考测试数据：
    操作系统在低地址占用100KB的空间，用户区主存从100KB处开始占用512KB。初始时，用户区全部为空闲，分配时截取空闲分区的低地址部分作为已分配区。执行以下申请、释放操作序列后：请求300KB，请求100KB，释放300KB，请求150KB，请求90KB，释放100KB。

代码实现

#include "stdio.h"
#include "iostream"
using namespace std;

void firstmethod();
void bestmethod();
void badmethod();

int main()
{
    int menu;
    do
    {
        cout << "------------------------------------------" << endl;
        cout << "\n菜单：\n1.循环首次适应算法\n2.最佳适应算法\n3.最坏适应算法\n-------\n输入0结束程序\n请输入你要执行的操作：\n";
        cout << "------------------------------------------" << endl;
        cin >> menu;
        switch (menu)
        {
        case 1:
            cout << "*******************循环首次适应算法**********************" << endl;
            firstmethod();
            cout << "********************************************************" << endl;
            break;
        case 2:
            cout << "*********************最佳适应算法************************" << endl;
            bestmethod();
            cout << "********************************************************" << endl;
            break;
        case 3:
            cout << "*********************最坏适应算法************************" << endl;
            badmethod();
            cout << "********************************************************" << endl;
            break;
        case 0:
            break;
        default:
            cout << "输入错误，请重新选择操作" << endl;
            break;
        }

    } while (menu != 0);
}

typedef struct Double_linked_list
{
    //char name[10];//进程名
    int flag;                                //1为已分配，0为空闲
    unsigned int size;                       //所指分区的大小
    char *addr;                              //分区起始地址
    struct Double_linked_list *prior, *next; //本表项的前后表项
} DllNode, *Dll;

Dll first, current; //首表项与起始查询指针

unsigned start; //主存起始地址
char *p;        //地址的开始

//初始化空闲分区表
void initDll()
{
    first = (Dll)malloc(sizeof(DllNode));
    if (!first)
    {
        //分配失败
        exit(0);
    }
    printf("请输入你要设置的主存起始地址：\n");
    cin >> start;
    printf("请输入你要设置的主存大小：\n");
    cin >> first->size;
    p = (char *)malloc(first->size + start);
    first->addr = p + start;
    first->flag = 0;
    first->next = first->prior = NULL;
}

void printDll()
{
    Dll tmp = first;
    cout << "\n\n-----------------free table---------------" << endl;
    while (tmp != NULL)
    {
        if (!tmp->flag)
            printf("起始地址：%4u,大小：%4d,结束地址：%4u\n", tmp->addr - p, tmp->size, tmp->addr - p + tmp->size - 1);
        tmp = tmp->next;
    }
    cout << "------------------------------------------" << endl;
    tmp = first;
    cout << "----------------allowcation table---------" << endl;
    while (tmp != NULL)
    {
        if (tmp->flag)
            printf("起始地址：%4u,大小：%4d,结束地址：%4u\n", tmp->addr - p, tmp->size, tmp->addr - p + tmp->size - 1);
        tmp = tmp->next;
    }
    cout << "------------------------------------------\n\n"
         << endl;
}

int lmalloc(unsigned size)
{
    if (size <= 0)
    {
        cout << "分配大小错误" << endl;
        return 1;
    }
    Dll tmp = current;
    Dll newNode = (Dll)malloc(sizeof(DllNode));
    if (!newNode)
        exit(0);
    newNode->flag = 1;

    newNode->size = size;
    do
    {
        if (current->flag == 1)
        { //已分配的区域跳过
            current = current->next;
            if (!current)
            {
                current = first;
            }
            continue;
        }
        if (current->size > size)
        { //大于所需空间
            if (current == first)
            {
                first = newNode;
                if (current->next == current)
                {
                    current->next = first;
                }
                current->prior = newNode;
            }
            else
            {
                current->prior->next = newNode;
            }
            newNode->prior = current->prior;
            newNode->next = current;
            current->prior = newNode;
            newNode->addr = current->addr;
            current->addr += size;
            current->size -= size;
            return 1;
        }
        else if (current->size == size)
        { //等于所需空间
            current->flag = 1;
            current = current->next;
            if (current == NULL)
            {
                current = first;
            }
            return 1;
        }
        else
        { //小于所需空间
            current = current->next;
        }
        if (current == NULL)
        {
            current = first;
        }

    } while (tmp != current);
    return 0;
}

int lfree(unsigned size, unsigned addr)
{
    Dll tmp = first;
    do
    {
        //为空闲分区则跳过
        if (tmp->flag == 0)
        {
            tmp = tmp->next;
            continue;
        }
        //起始地址或大小不符
        if (tmp->addr - p != addr || tmp->size != size)
        {
            tmp = tmp->next;
            continue;
        }
        //回收链表第一个节点
        if (tmp->prior == NULL)
        {
            //链表只有一个节点
            if (tmp->next == NULL)
            {
                tmp->flag = 0;
                return 1;
            }
            //链表的第一个节点且后面有节点
            else
            {
                //回收链表的第一个节点且后面一个节点为空闲分区
                if (!tmp->next->flag)
                {
                    tmp->size += tmp->next->size;
                    Dll p = tmp->next;
                    tmp->next = tmp->next->next;
                    tmp->flag = 0;
                    free(p);
                    return 1;
                }
                //回收链表的第一个节点且后面一个节点不是空闲分区
                else
                {
                    tmp->flag = 0;
                    return 1;
                }
            }
        }
        if (tmp->next == NULL)
        { //回收链表最后一个节点
            if (!tmp->prior->flag)
            { //前面的节点是空闲分区
                tmp->prior->size += tmp->size;
                tmp->prior->next = tmp->next;
                free(tmp);
                return 1;
            }
            else
            { //前面分区已分配
                tmp->flag = 0;
                return 1;
            }
        }

        //此时的节点不是首尾分区
        //回收分区前有空闲分区
        if (!tmp->prior->flag)
        {
            //回收分区前后都有空闲分区
            if (!tmp->next->flag)
            {
                tmp->prior->size += tmp->size + tmp->next->size;
                tmp->prior->next = tmp->next->next;
                free(tmp->next);
                free(tmp);
                return 1;
            }
            //回收分区后没有空闲分区
            else
            {
                tmp->prior->size += tmp->size;
                tmp->prior->next = tmp->next;
                free(tmp);
                return 1;
            }
        }
        //回收分区前没有空闲分区
        else
        {
            //回收分区后有空闲分区
            if (!tmp->next->flag)
            {
                tmp->size += tmp->next->size;
                Dll p = tmp->next;
                tmp->next = tmp->next->next;
                tmp->flag = 0;
                free(p);
                return 1;
            }
            //回收分区前后都没有
            else
            {
                tmp->flag = 0;
                return 1;
            }
        }
    } while (tmp != NULL);
    //没有要释放的分区
    return 0;
}

void firstmethod()
{
    int menu;
    initDll();
    current = first;
    unsigned size, addr;
    do
    {
        printDll();
        cout << "------------------------------------------\n菜单：\n1.申请内存\n2.释放内存\n------------------------------------------\n输入0结束本次算法\n";
        cin >> menu;
        switch (menu)
        {
        case 1:
            cout << "请输入申请内存大小：" << endl;
            cin >> size;
            if (!(lmalloc(size)))
            {
                cout << "内存不足，分配失败" << endl;
            }
            break;
        case 2:
            cout << "请输入要释放的起始地址" << endl;
            cin >> addr;
            cout << "请输入要释放的地址大小：" << endl;
            cin >> size;
            if (!lfree(size, addr))
            {
                cout << "命令错误，请检查分配表" << endl;
            }
            break;
        case 0:
            free(first);
            break;
        default:
            cout << "输入错误，请重新选择操作" << endl;
            break;
        }
    } while (menu != 0);
}

void swap_Dll(Dll &L1, Dll &L2)
{
    char *p = L1->addr;
    L1->addr = L2->addr;
    L2->addr = p;
    int flag = L1->flag;
    L1->flag = L2->flag;
    L2->flag = flag;
    int size = L1->size;
    L1->size = L2->size;
    L2->size = size;
}

void sortDll_ASC_size(Dll &L)
{
    Dll p, q;
    for (p = L; p->next != NULL; p = p->next)
    {
        for (q = p->next; q != NULL; q = q->next)
        {
            if (p->size > q->size)
            {
                swap_Dll(p, q);
            }
        }
    }
}
void sortDll_DSC_size(Dll &L)
{
    Dll p, q;
    for (p = L; p->next != NULL; p = p->next)
    {
        for (q = p->next; q != NULL; q = q->next)
        {
            if (p->size < q->size)
            {
                swap_Dll(p, q);
            }
        }
    }
}
void sortDll_ASC_addr(Dll &L)
{
    Dll p, q;
    for (p = L; p->next != NULL; p = p->next)
    {
        for (q = p->next; q != NULL; q = q->next)
        {
            if (p->addr > q->addr)
            {
                swap_Dll(p, q);
            }
        }
    }
}

int lmalloc_other(unsigned size)
{
    if (size <= 0)
    {
        cout << "分配大小错误" << endl;
        return 1;
    }
    Dll tmp = first;
    Dll newNode = (Dll)malloc(sizeof(DllNode));
    if (!newNode)
        exit(0);
    newNode->flag = 1;
    newNode->size = size;
    do
    {
        if (tmp->flag == 1)
        { //已分配的区域跳过
            tmp = tmp->next;
            continue;
        }
        if (tmp->size > size)
        { //大于所需空间
            //第一个节点
            if (tmp == first)
            {
                first = newNode;
                newNode->prior = NULL;
            }
            else
            {
                tmp->prior->next = newNode;
                newNode->prior = tmp->prior;
            }

            newNode->next = tmp;
            tmp->prior = newNode;
            newNode->addr = tmp->addr;
            tmp->addr += size;
            tmp->size -= size;
            return 1;
        }
        else if (tmp->size == size)
        { //等于所需空间
            tmp->flag = 1;
            tmp = tmp->next;
            return 1;
        }
        else
        { //小于所需空间
            tmp = tmp->next;
        }

    } while (tmp != NULL);
    return 0;
}

void bestmethod()
{
    int menu;
    initDll();
    unsigned size, addr;
    do
    {
        printDll();
        cout << "------------------------------------------\n菜单：\n1.申请内存\n2.释放内存\n------------------------------------------\n输入0结束本次算法\n";
        cin >> menu;
        switch (menu)
        {
        case 1:
            sortDll_ASC_size(first);
            cout << "请输入申请内存大小：" << endl;
            cin >> size;
            if (!(lmalloc_other(size)))
            {
                cout << "内存不足，分配失败" << endl;
            }
            sortDll_ASC_addr(first);
            break;
        case 2:
            sortDll_ASC_addr(first);
            cout << "请输入要释放的起始地址" << endl;
            cin >> addr;
            cout << "请输入要释放的地址大小：" << endl;
            cin >> size;
            if (!lfree(size, addr))
            {
                cout << "命令错误，请检查分配表" << endl;
            }
            break;
        case 0:
            free(first);
            break;
        default:
            cout << "输入错误，请重新选择操作" << endl;
            break;
        }
    } while (menu != 0);
}

void badmethod()
{
    int menu;
    initDll();
    unsigned size, addr;
    do
    {
        printDll();
        cout << "------------------------------------------\n菜单：\n1.申请内存\n2.释放内存\n------------------------------------------\n输入0结束本次算法\n";
        cin >> menu;
        switch (menu)
        {
        case 1:
            sortDll_DSC_size(first);
            cout << "请输入申请内存大小：" << endl;
            cin >> size;
            if (!(lmalloc_other(size)))
            {
                cout << "内存不足，分配失败" << endl;
            }
            sortDll_ASC_addr(first);
            break;
        case 2:
            sortDll_ASC_addr(first);
            cout << "请输入要释放的起始地址" << endl;
            cin >> addr;
            cout << "请输入要释放的地址大小：" << endl;
            cin >> size;
            if (!lfree(size, addr))
            {
                cout << "命令错误，请检查分配表" << endl;
            }
            break;
        case 0:
            free(first);
            break;
        default:
            cout << "输入错误，请重新选择操作" << endl;
            break;
        }
    } while (menu != 0);
}

实验结果分析

操作系统在低地址占用100KB的空间，用户区主存从100KB处开始占用512KB。初始时，用户区全部为空闲，分配时截取空闲分区的低地址部分作为已分配区。执行以下申请、释放操作序列后：请求300KB，请求100KB，释放300KB，请求150KB，请求90KB，释放100KB。
首次循环适应算法
最佳适应算法
最坏适应算法

心得体会

这次实验是实现动态分区分配中循环首次适应算法，最佳适应算法和最坏适应算法，三种算法大同小异，在循环首次适应算法中，需要注意的是用current指针指向上一次分配后的空闲分区，在分配时从current指向的分区开始查询。而最佳适应算法和最坏适应算法只需将空闲分区在分配前分别按升序和降序进行排列，在分配后对地址进行升序排列，剩下的分配和回收细节基本相同。

love Taylor forever
关注
专栏目录
实例分析首次适应算法、最佳适应算法、最差适应算法
焕听的专栏
11-15 6万+
关于首次适应算法、最佳适应算法和最差适应算法，先看一下百度百科的解释，已经说出了三者的最大区别。 首次适应算法（first-fit）：从空闲分区表的第一个表目起查找该表，把最先能够满足要求的空闲区分配给作业，这种方法的目的在于减少查找时间。 最佳适应算法（best-fit）：从全部空闲区中找出能满足作业要求的，且大小最小的空闲分区，这种方法能使碎片尽量小。 最差适应算法（worst-fit）
存储管理实验（首次适应算法,循环首次适应算法,最佳适应算法）
11-18
存储管理实验（3个） 首次适应算法,循环首次适应算法,最佳适应算法
首次适应算法 最佳适应算法 循环首次适应算法　
07-17
分配算法　首次适应算法 最佳适应算法 循环首次适应算法 有流程图 源代码
主存分配 最佳适应算法 最坏适应算法 循环首次适应算法 首次适应算法
12-22
操作系统中利用最佳适应算法 最坏适应算法 循环首次适应算法 首次适应算法实现动态内存的分配和回收内存
循环首次适应算法_数据结构与算法之2——排序问题
weixin_39606137的博客
12-03 1089
排序真的是数据结构与算法中的重中之重啊，无论是对编程能力的提升，以后工作后的应用，或者是应对面试的时候都是经常需要用到的。基本的几个经典排序一定要做到滚瓜烂熟，能够做到给你一个具体的排序算法题，一定能短时间内选出最适合的排序算法(时间和空间复杂度以及根据具体所给的条件)，并且不假思索的写出代码。只有这样才能算是技能过关。(本文所有代码实现都是基于python语言，很多代码是自己设计和手打，如有错误...
ncfp.rar_作业分配_内存分配_可变分区_模拟 内存 分配 回收_首次适应算法
09-20
用C实现简单的可变分区的首次适应算法、内存回收算法的模拟，并将模拟运行的结果显示出来。假设内存空间实际大小是100M，共有3个作业请求使用内存空间，作业请求、释放内存空间的顺序如下： 作业A 申请30M内存空间 ...
首次适应算法主存空间的分配和回收C语言源代码
04-01
首次适应算法（First Fit，FF）是操作系统中用于管理可变分区存储的一种策略，它在内存分配时具有较高的效率。这种算法的主要思想是在查找空闲分区时，从内存的起始位置开始，寻找第一个足够大的空闲分区来满足请求...
操作系统可变分区分配算法——首次适应、循坏首次适应、最佳适应、最坏适应
04-25
使用C语言实现了操作系统可变分区分配算法，实现了首次。循环首次、最佳、最坏等算法，可以运行在Linux系统上，只是算法的模拟，没有调用Linux系统内核数据
基于Java Swing的操作系统可变分区内存管理程序，实现了最先适应、下次适应、最优适应和最坏适应分配算法
最新发布
08-17
基于Java Swing的操作系统可变分区内存管理程序，实现了最先适应、下次适应、最优适应和最坏适应分配算法 【项目介绍】 1、该项目是个人高分项目源码，已获导师指导认可通过，答辩评审分达到96分 2、该资源内项目...
在可变分区管理方式下采用最先适应算法实现主存储器的分配和回收。.doc
05-07
"可变分区管理方式下采用最先适应算法实现主存储器的分配和回收" 在计算机系统中，存储管理是非常重要的一部分，好的存储管理可以提高系统的性能和可靠性。实验三和四主要是为了帮助学生理解在不同的存储管理方式下...
操作系统循环首次适应算法
12-15
本算法为循环首次适应算法。 算法：由用户进行初始化，即输入分区的总数及各分区的大小，然后在这个基础上再进行后面的操作。在分配函数中，在本实验中设置一个定位指针，当为作业分配内存空间时，不是从空间分区表的起点开始查找，而是从上次找到的空间分区的位置开始查找，直至找到第一个能满足要求的空闲分区，并进行相应处理，在回收函数中，由于是要求选择需要回收的分区号，要考虑该分区号前后的分区的状态，再进行相应处理，
内存管理实验c语言，完成内存可变分区分配的模拟
05-15
内存管理，c语言，编程实现； 一个模拟程序，完成内存可变分区分配的模拟,要求采用最佳适应法、最坏适应法、首次适应法或下次适应法之一。 具体包括:首先确定分配内存块管理的数据结构、空闲块的数据结构,然后完成内存分配、内存回收、空闲块管理等程序代码;最后编写模拟分配和回收过程的主函数，上机实验并取得结果数据。
C语言模拟实现操作系统内存的分配与回收
07-08
本次实验采用C编写，将内存空间定义为结构体链表，成员有作业名name[20]、作业首址s_add、作业长度length及下一节点的指针next；空闲分区表定义为结构体数组，成员有空闲区首址s_add、空闲区长度length、表项状态state。
内存分配算法--最先适应、最佳适应、最坏适应
07-17
要求模拟分区存储器中动态分区法，实现分区分配的三种算法：最先适应法，最佳适应法和最坏适应法。运行时可任选一种算法。系统应能显示内存分配的状态和参数变化情况。
可变分区管理方式下最先适应分配算法
06-30
模拟计算机主存储器空间的分配和回收，设计一个在可变分区管理方式下的最先适应分配算法的的分配与回收程序。
编写C语言程序，模拟实现首次/最佳/最坏适应算法的内存块分配和回收，要求每次分配和回收后显示出空闲分区和已分配分区的情况。假设初始状态下，可用的内存空间为640KB。（江西师范大学软件学院 操作系统）
qq_63165951的博客
05-13 4749
编写C语言程序，模拟实现首次/最佳/最坏适应算法的内存块分配和回收，要求每次分配和回收后显示出空闲分区和已分配分区的情况。 假设初始状态下，可用的内存空间为640KB。
图解算法：确定单链表有环，如何找到环的入口和长度？
承香墨影的博客
12-23 3743
一、序 本文继续給大家带来一道和单链表相关的算法题。 之前聊到，如何对单链表是否存在环进行检测（戳我了解），今天再来聊聊这个问题的进阶题： 一个单链表，如果有环，求环的入口。 一个单链表，如果有环，求环的长度。 链表这种结构，可以通过「指针」，将一组零散的内存块串联起来。那单链表，如果有环是一个什么情况？ 如上图所示，单链表中如果存在环，一定有且只有一个入口点，进...
c模拟内存分配算法（首次适应算法，最佳适应算法，最坏适应算法）
热门推荐
Y先森0.0
05-10 1万+
#include&lt;bits/stdc++.h&gt; using namespace std; /*定义内存的大小为100*/ #define MEMSIZE 100 /*如果小于此值，将不再分割内存*/ #define MINSIZE 2 /*内存分区空间表结构*/ typedef struct _MemoryInfomation { /*起始地址*/ int...
OS实验-模拟实现首次/最佳/最坏适应算法的内存块分配和回收
Volta小白
04-27 7448
编写C语言程序，模拟实现首次/最佳/最坏适应算法的内存块分配和回收，要求每次分配和回收后显示出空闲分区和已分配分区的情况。 假设初始状态下，可用的内存空间为640KB。 #include<bits/stdc++.h> #define ll long long using namespace std; const ll maxn=1e18; const ll minn=-1e18; const ll mod=1000000007; const ll MAX=100005; bool cmp(l
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值