吉林大学操作系统上机实验三（存储管理算法NF实现）

原创 已于 2025-05-22 23:19:14 修改 · 2.7k 阅读 · 22 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
收录于
操作系统上机实验

当前文章被收录于：

操作系统上机实验
5 篇文章 6 人学习
订阅专栏 查看详情
于 2025-05-22 17:30:24 首次发布

操作系统上机随笔《实验三》

老规矩，上文是本次实验的基础内容，本文实现加分项：除First Fit存储分配算法外，其他算法

NF算法的实现 

NF算法（下次适应算法，Next Fit）介绍：


思想：

自上次分配空闲区域的下一个位置开始，选取第一个可满足的空闲区域

实现：

设置一个循环查找指针，开始时指向表头，每次分配从该指针处开始查找（若查到表尾则将指针置到表头）第一个遇到的可满足的区域，分配后将指针调整为所分配区域的下一个区域处。

优点：

可以减少查找空闲区域所花费的时间开销，并使空闲区域分布更均匀。

缺点：

可能分割大空闲区

代码：

#ifdef  HAVE_CONFIG_H
#include  <config.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#define MAPSIZE 100
struct map  //存储资源表结构
{
    int m_addr;
    int m_size;
};
struct map map[MAPSIZE];  //存储资源表
struct map* np = NULL;
//BF存储分配函数
int BF_malloc(struct map* mp, int size)
{
    register int a, s;
    register struct map* bp, * bpp;
    for (bp = mp; bp->m_size; bp++)
    {
        if (bp->m_size >= size)
        {
            a = bp->m_addr;
            s = bp->m_size;
            for (bpp = bp; bpp->m_size; bpp++)
            {   //最佳适应
                if (bpp->m_size >= size && bpp->m_size < s)
                {
                    a = bpp->m_addr;
                    s = bpp->m_size;
                    bp = bpp;
                }
            }

            bp->m_addr += size;
            if ((bp->m_size -= size) == 0)
                do
                {
                    bp++;
                    (bp - 1)->m_addr = bp->m_addr;
                } while ((bp - 1)->m_size = bp->m_size);
            return(a);
        }
    }
    return(-1);
}

//WF存储分配函数
int WF_malloc(struct map* mp, int size)
{
    register int a, s;
    register struct map* bp, * bpp;
    
    for (bp = mp; bp->m_size; bp++)
    {
        if (bp->m_size >= size)
        {
            a = bp->m_addr;
            s = bp->m_size;
            for (bpp = bp; bpp->m_size; bpp++)
            {   //最坏适应
                if (bpp->m_size > s)
                {
                    a = bpp->m_addr;
                    s = bpp->m_size;
                    bp = bpp;
                }
            }
            bp->m_addr += size;
            if ((bp->m_size -= size) == 0)
                do
                {
                    bp++;
                    (bp - 1)->m_addr = bp->m_addr;
                } while ((bp - 1)->m_size = bp->m_size);
            return(a);
        }
    }
    return(-1);
}

//NF存储分配函数
int NF_malloc(struct map* mp, int size)
{
    register int a;
    register struct map* bp;
    if (!np || np->m_size == 0) {
        np = mp;
    }
    bp = np;
    do {
        if (bp->m_size >= size)
        {
            a = bp->m_addr;
            np = bp + 1;
            bp->m_addr += size;
            if ((bp->m_size -= size) == 0) {
                np--;
                do
                {
                    bp++;
                    (bp - 1)->m_addr = bp->m_addr;
                } while ((bp - 1)->m_size = bp->m_size);
            }

            return(a);
        }
        bp++;
        if (bp->m_size == 0) bp = mp;
    } while (bp != np);
    return(-1);
}

//存储释放函数
void mfree(struct map* mp, int aa, int size)
{
    register struct map* bp;
    register int t;
    register int a;
    a = aa;
    for (bp = mp; bp->m_addr <= a && bp->m_size != 0; bp++)
        ;//找到释放空间后面的空闲空间
    if (bp > mp && (bp - 1)->m_addr + (bp - 1)->m_size == a)
    {  //与前合并
        (bp - 1)->m_size += size;
        if (a + size == bp->m_addr)
        {   //前后合并，后为空不影响
            (bp - 1)->m_size += bp->m_size;
            while (bp->m_size)
            {//后面所有向前移动
                
                bp++;
                (bp - 1)->m_addr = bp->m_addr;
                (bp - 1)->m_size = bp->m_size;
                if (np && bp == np) np--;
            }
        }
    }

    else
    {
        if (a + size == bp->m_addr && bp->m_size)
        {   //与后合并
            bp->m_addr -= size;
            bp->m_size += size;
        }
        else if (size) {
            int  flag = 0;

            do
            {   //无合并,插入新空闲区域，后面所有向后移动
                t = bp->m_addr;
                bp->m_addr = a;
                a = t;
                t = bp->m_size;
                bp->m_size = size;
                if (bp == np) flag = 1;
                bp++;
            } while (size = t);
            if (np && flag) np++;
        }
            
    }
}
void init()
{
    struct map* bp;
    int addr, size;
    int i = 0;
    bp = map;
    printf("Please input starting addr and total size:");
    scanf("%d,%d", &addr, &size);
    getchar();
    bp->m_addr = addr;
    bp->m_size = size;
    (++bp)->m_size = 0;  //表尾
}

void show_map()
{
    int i = 0;
    //system("clear");  //清屏
    struct map* bp;
    bp = map;
    printf("\nCurrent memory map...\n");
    printf("Address\t\tSize\n");
    while (bp->m_size != 0)
    {
        printf("<%d\t\t%d>\n", bp->m_addr, bp->m_size);
        bp++;
    }
    printf("\n");
}

int main()
{
    int a, s;
    char c;
    int i;
    init();
    printf("please input, b for BF, w for WF，n for NF:");
    scanf("%c", &c);
    getchar();
    do
    {
        show_map(); //显示存储资源表
        if (np) printf("np: %d\n", np->m_addr);
        printf("Please input,1 for request,2 for release,0 for exit:");
        scanf("%d", &i);
        getchar();
        switch (i)
        {
        case 1:
            printf("Please input size:");
            scanf("%d", &s);
            getchar();
            if (c == 'b')  //BF
                a = BF_malloc(map, s);
            else if (c == 'w')  //WF
                a = WF_malloc(map, s);
            else
                a = NF_malloc(map, s);
            if (a == -1)
                printf("request can't be satisfied\n");
            else
                printf("alloc memory at address:%d,size:%d\n", a, s);
            break;
        case 2:
            printf("Please input addr and size:");
            scanf("%d,%d", &a, &s);
            getchar();
            mfree(map, a, s);
            break;
        case 0:
            exit(0);
        }
    } while (1);
}

具体实现： 

struct map* np = NULL;

保存一个全局变量指针 np ，即循环查找指针，未使用时指空。

//NF存储分配函数
int NF_malloc(struct map* mp, int size)
{
    register int a;
    register struct map* bp;
    if (!np || np->m_size == 0) {
        np = mp;
    }
    bp = np;
    do {
        if (bp->m_size >= size)
        {
            a = bp->m_addr;
            np = bp + 1;
            bp->m_addr += size;
            if ((bp->m_size -= size) == 0) {
                np--;
                do
                {
                    bp++;
                    (bp - 1)->m_addr = bp->m_addr;
                } while ((bp - 1)->m_size = bp->m_size);
            }

            return(a);
        }
        bp++;
        if (bp->m_size == 0) bp = mp;
    } while (bp != np);
    return(-1);
}

1.进入 NF 后，先判断 np 是否指空或指向表位，如果是，将其重新指向表头。

2.从 np 开始，向后查找第一个足够大的空闲块，如果遍历到表尾，重新指向表头，直到再次遍历到 np 的话，返回-1。如果找到，更新该块首地址和大小，以反映内存分配，并将 np 指向下一个块。如果分配后块的大小为0，移除此块，后面的块依次向前移动，np 也向前移动。返回分配首地址a。

mfree函数的适应性调整：

//存储释放函数
void mfree(struct map* mp, int aa, int size)
{
    register struct map* bp;
    register int t;
    register int a;
    a = aa;
    for (bp = mp; bp->m_addr <= a && bp->m_size != 0; bp++)
        ;//找到释放空间后面的空闲空间
    if (bp > mp && (bp - 1)->m_addr + (bp - 1)->m_size == a)
    {  //与前合并
        (bp - 1)->m_size += size;
        if (a + size == bp->m_addr)
        {   //前后合并，后为空不影响
            (bp - 1)->m_size += bp->m_size;
            while (bp->m_size)
            {//后面所有向前移动
                
                bp++;
                (bp - 1)->m_addr = bp->m_addr;
                (bp - 1)->m_size = bp->m_size;
                if (np && bp == np) np--;
            }
        }
    }

    else
    {
        if (a + size == bp->m_addr && bp->m_size)
        {   //与后合并
            bp->m_addr -= size;
            bp->m_size += size;
        }
        else if (size) {
            int  flag = 0;

            do
            {   //无合并,插入新空闲区域，后面所有向后移动
                t = bp->m_addr;
                bp->m_addr = a;
                a = t;
                t = bp->m_size;
                bp->m_size = size;
                if (bp == np) flag = 1;
                bp++;
            } while (size = t);
            if (np && flag) np++;
        }
            
    }
}

问题：

存储释放时，若前后都合并或都不合并时，后续块需要移动。此时，若 np 所指向的块被移动，需更新 np 。

具体修改：

1.若前后都合并，后续块向前移动过程中遍历到 np 所指的块，更新 np--；

2.若前后都不合并，后续块向后移动过程中，若遍历到 np 所指的块，记录，都遍历完成后，更新 np++。

运行结果：

（为了直观展示 np 指针的效果，在主函数中，show_map后，输出np->m_addr。）

分析： 

由图一可以看出，申请70大小的块后，np 指向表位。且释放存储后，仍能正确指向表位；

由图二可以看出，再次申请10大小的块时，由于 np 指向表位，再次从头开始遍历。（不是BF算法）；

申请5大小的块后，再次申请10大小的块，都能从正确的块中分配空间。（不是WF算法）。

由图三可以看出，当遍历到表尾时，回回到表头继续遍历。 

结尾 

别忘了在主函数中正确适配NF算法。

标签
#算法 #经验分享 #操作系统
操作系统实验报告 实验3存储管理实验(答案全）
m0_51456787的博客
01-22 3820
实验3存储管理实验1 实验目的2 实验要求3 实验原理4 实验步骤2.观测程序源代码3.实验结果及分析 1 实验目的 通过本实验，熟悉程序文件的内容和结构与程序内存映象的内容和结构 2 实验要求 1编写代码并通过GDB调试命令观察程序文件的内容结构 2.GDB观察程序内存映象的内容和结构 在Linux下，用free 和vmstat命令观察内存使用情况 在Linux下，查看/proc与内存管理相关的文件，并解释显示结果 3 实验原理 （1）gcc的使用：gcc是linux系统的C编译器，将C/C++源程序和目
吉林大学软件工程操作系统课程设计上机代码（反置页表）
11-14
基于杂凑技术的反置页表方法的页式内存管理的模拟实现 功能要求 (1)设计非虚拟的反置页表页式存储管理模块； (2)内存空间及其划分（界面） 内存物理空间大小可选择：256M bytes，512M bytes； 每个页框的大小可选择：1K bytes，2K bytes，4K bytes； (3)根据所选择的内存空间及其划分，显示对应的反置页表表项的项数及其所占空间的大小； (4)随机产生多个进程的（进程号，进程逻辑空间大小）二元组并显示； 注：产生的所有进程逻辑页面数之和≤内存物理空间的总页框数； 每个进程逻辑空间大小≥4页； 产生的进程（二元组）个数≥4； 进程逻辑页面数= 进程逻辑空间大小÷页框大小 (5)实现针对上述情况，显示相应反置页表的相关表项内容： 反置页表表项序号、进程号、逻辑页号、冲突标志、空闲/占用标志 (6)随机选定上述产生的一个进程，并随机产生该进程的一个逻辑地址L： L的正确性检查：L对应的逻辑页号应与该进程的逻辑空间大小相符合； 显示L的逻辑页号、页内偏移； 显示L对应的页框号； 显示L访问的实际物理地址
吉林大学2022年操作系统实验报告（仅供参考）
06-05
实验一： 用pipe()创建一个管道文件，然后用fork()创建两个生产进程和两个消费进程，它们之间通过pipe()传递信息。 用clone()创建四个轻进程（线程），用参数指明共享内存等资源，通过共享内存模拟生产消费问题，利用pthread_mutex_lock(), pthread_mutex_unlock()等函数实现对共享存储区访问的互斥。 实验二： 实时任务用task数据结构描述，设计四个函数：select_proc()用于实现调度算法，被选中任务执行proc()，在没有可执行任务时执行idle()，主函数mian()初始化相关数据，创建实时任务并对任务进行调度。 为模拟调度算法，给每个线程设置一个等待锁，暂不运行的任务等待在相应的锁变量上。主线程按调度算法唤醒一个子线程，被选中线程执行一个时间单位，然后将控制权交给主线程判断是否需要重新调度。
吉林大学计算机专业操作系统实验报告
04-01
本文档为吉林大学计算机科学与技术专业大三上学期的操作系统实验课的实验报告，有需要的可以借鉴。
吉林大学操作系统上机（实验一：Linux进程与线程通讯）
热门推荐
KQ的博客
07-07 2万+
菜鸡博客，只是作为学习记录。。。操作系统要好好学！ 1. 上机准备 建议提前弄，这个起码2个小时，因为我们老师建议我们在VMware Workstation上运行Red Hat Linux，并学会gcc编程，所以以下教程都是为了实现这个。 一些概念： 虚拟机：是通过软件模拟出虚拟系统，该系统可以模拟真实计算机所拥有的全部配置和相关功能。 VMware Workstation是一款桌面虚拟计算软件，提供虚拟机的功能，可以同时运行多个不同的操作系统。 Linux 是一款免费的开源操作系统，设计与 UNIX 类
操作系统上机随笔《实验一》
linwuwu985的博客
06-12 5141
吉林大学操作系统上机随笔《实验一》
吉林大学操作系统上机（实验二：处理机调度——实时调度算法EDF和RMS）
KQ的博客
07-07 1万+
每做一个实验都不禁感叹奇妙非常，以下仅为学习记录，不足出错欢迎指出 实验二 处理机调度——实时调度算法EDF和RMS 实验目的 深入理解处理机调度算法，了解硬实时概念，掌握周期性实时任务调度算法EDF(Earliest Deadline First)和RMS(Rate Monotonic Scheduling)的可调度条件，并能在可调度情况下给出具体调度结果。 实验内容 在Linux环境中采用用户级线程模拟实现EDF和RMS两种实时调度算法。给定一组实时任务，按照EDF算法和RMS算法分别判断是否可调度，在
操作系统上机随笔《实验二》
linwuwu985的博客
06-12 3218
吉林大学操作系统上机随笔《实验二》
吉林大学操作系统上机（实验四：文件系统——Hash结构文件）
KQ的博客
07-07 9629
实验四：文件系统——Hash结构文件 实验目的 1、理解Linux文件系统的内部技术，掌握Linux与文件有关的系统调用命令，并在此基础上建立面向随机检索的hash结构文件。 2、Linux系统保持UNIX文件系统的风格，提供流式文件界面，这种结构具有简洁灵活的特点，但并不直接支持记录式文件和关键字检索。本实验是在Linux文件系统基础上，设计一组库函数，以提供对随机检索的支持。 实验内容 1、参考教材中hash文件构造算法，设计一组hash文件函数，包括hash文件创建、打开、关闭、读、写等。 2、编写一
吉林大学操作系统上机实验二（HRN算法和SRTF算法实现）
m0_73654355的博客
05-16 2918
1.在原实时调度框架下实现HRN（最高相应比）算法上文已能解决本次实验基础部分，本文主要关注加分项，即完成其它任意调度算法。1.在原实时调度框架下实现HRN（最高相应比）算法。
吉林大学操作系统上机实验一（pthread_mutex_unlock无法唤醒clone生成的线程问题解决）
m0_73654355的博客
05-15 3155
本文解决了吉林大学操作系统实验一中clone实验线程莫名消失的问题。代码中使用了clone函数创建线程，并通过信号量（sem_t）实现线程间的同步与互斥，避免了使用pthread_mutex时因线程未注册到TCB而导致的唤醒失败问题。具体解决方案包括：使用sem_wait和sem_post替代pthread_mutex_lock和pthread_mutex_unlock，确保线程间的正确同步。实验结果表明，该方案有效解决了线程消失问题，并正确输出了生产者与消费者的操作结果。
吉林大学 操作系统上机 第五次实验 设备管理 修改部分
weixin_61197809的博客
05-30 1427
1.将centos 改成小红帽 ，不然出现的问题.2 file_operation 结构体把deviec改成mydev。3.main函数前面加个void。
吉林大学操作系统实验源代码
04-28
吉林大学软件学院操作系统实验源代码，成绩为优，需要的同学可以参考一下。 （4）死锁环路判定的系统资源分配图约简算法的设计与实现 功能要求 ①系统资源分配图输入（界面） 按资源分配图的形式定义，输入进程名字、资源类名字及其个数、申请/占有边。 ②运行结果（界面） ●以图形的形式输出原资源分配图； ●以图形的形式动态输出原资源分配图约简过程。 实现方式： ①图的描述：定义资源类结点和进程结点的数据结构，以指针方式表示结点之间边的关系（可限定最多指针个数）； ②按算法对描述的资源分配图进行约简，同时动态图形显示约简过程；约简结束后，给出资源分配图是否可完全约简的提示信息。
操作系统上机实验五
m0_62712298的博客
06-06 836
大连理工大学操作系统上机实验五
操作系统第三次实验
anjinggufa的博客
04-08 1450
操作系统实验三 同步问题 ​ 16281049 王晗炜 计科1601 实验目的 系统调用的进一步理解 进程上下文切换 同步的方法 实验题目 通过fork的方式，产生4个进程...
吉林大学操作系统上机实验四（hash存储讲解及顺序存储文件管理实现）
最新发布
m0_73654355的博客
05-29 3630
本文介绍了Linux系统文件操作和两种文件存储实现。主要内容包括：1）文件操作系统调用的详细解析，涵盖creat、open、close、read、write、lseek等函数；2）哈希文件存储的实现，通过hashfile.h和hashfile.c展示了哈希表的创建、读写、查找和删除操作；3）顺序文件存储的实现，对比哈希存储，采用线性方式管理记录。两种存储方式均基于jtRecord结构体实现，但数据组织策略不同。
操作系统——存储管理实验
HELLO_CPY的博客
05-15 3327
计算机小白自制，关于操作系统的存储管理实验，实验涉及到五种算法实现，感兴趣可以进来看看，欢迎批评指正，谢谢大家
吉林大学操作系统复习
m0_74740382的博客
06-10 2584
3.2.1处理器调度算法1.先到先服务算法2.短作业优先3 .最短剩余时间优先4.最高相应比优先（HRN）5.最高优先数（HPF）6.循环轮转（RR）7.多级队列（MLQ）8.排队反馈（FB）3.4实时调度。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值