操作系统实验(一)——可变分区存储管理

这篇具有很好参考价值的文章主要介绍了操作系统实验(一)——可变分区存储管理。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

湖南师范大学信息科学与工程学院计算机科学与技术非师范班操作系统实验报告

一、实验目的:

  1. 加深对可变分区存储管理的理解;
  2. 提高用C语言编制大型系统程序的能力,特别是掌握C语言编程的难点:指针和指针作为函数参数;
  3. 掌握用指针实现链表和在链表上的基本操作。

二、实验内容:

参照教材P137-P140的内容,编写一个C程序,用char *malloc(unsigned size)函数向系统申请一次内存空间(如size=1000,单位为字节),用循环首次适应算法、最佳适应算法和最坏适应算法,模拟可变分区存储管理,实现对内存区的分配和回收管理。

三、实验要求:

  1. 分配函数addr=(char *)lmalloc(unsigned size)和释放函数lfree(unsigned size,char *addr)的参数size和addr,要以键盘命令的形式输入,每次分配和释放后显示空闲分区表。
  2. 空闲分区表可采用结构数组的形式(最低要求)或双向链表的形式。

四、参考测试数据:

操作系统在低地址占用100KB的空间,用户区主存从100KB处开始占用512KB。初始时,用户区全部为空闲,分配时截取空闲分区的低地址部分作为已分配区。执行以下申请、释放操作序列后:请求300KB,请求100KB,释放300KB,请求150KB,请求90KB,释放100KB。

开始写代码!

空闲分区表采用双向链表的形式

struct SubAreaNode{
    int id;
    int addr;
    int size;
    char state;
    SubAreaList pre;
    SubAreaList next;
};

完整代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MEMORY_SIZE 512
#define ALLOCATED 1
#define FREE 0
typedef struct SubAreaNode *SubAreaList;
struct SubAreaNode{
    int addr;
    int size;
    int pid;
    int state;
    SubAreaList pre;
    SubAreaList next;
};
SubAreaList head;
SubAreaList nowList;

SubAreaList getSubArea(){
    return (SubAreaList) malloc(sizeof(struct SubAreaNode));
}
//初始化分区链表
SubAreaList initSubArea(){
    SubAreaList p = getSubArea();//?
    p->addr = 100;//初始地址
    p->size = MEMORY_SIZE;
    p->pid = -1;
    p->state = FREE;
    p->pre = NULL;
    p->next = NULL;
    return p;
}
//分配
int alloc(int pid, int psize, SubAreaList p) {
    if (p == NULL)   //无合适空间可分配
        return 0;
    if (p->size == psize) {   //分区整块分配
        p->state = ALLOCATED;
        p->pid = pid;
    } else {                  //分割分区
        SubAreaList newSubArea = getSubArea();
        newSubArea->addr = p->addr + psize;
        newSubArea->size = p->size - psize;
        newSubArea->state = FREE;
        newSubArea->pid = -1;

        p->size = psize;
        p->state = ALLOCATED;
        p->pid = pid;

        newSubArea->next = p->next;
        p->next = newSubArea;
        newSubArea->pre = p;
    }
    return 1;
} 
//回收
int freeAlloc(int pid){
    SubAreaList p = head;
    while(p){
        if(p->pid == pid) break;
        p = p->next;
    }
    if(p==NULL)
        return 0;
    //不是首块分区且与前一空闲分区相连
    if(p!=head && p->pre->state==FREE && p->pre->addr+p->pre->size==p->addr){
        SubAreaList preNode = p->pre;
        SubAreaList nextNode = p->next;
        preNode->size += p->size;
        preNode->next = p->next;
        nextNode->pre = preNode;
    //与后一空闲分区相邻
        if(p->next->state==FREE && p->pre->addr+p->pre->size==p->next->addr){
            preNode->size += nextNode->size;
            preNode->next = nextNode->next;
            nextNode->next->pre = preNode;//?
            free(nextNode);
        }
        free(p);
    }else{
        //不是最后一个分区且与后一分区相邻
        if(p->next!=NULL && p->next->state==FREE && p->addr+p->size==p->next->addr){
            SubAreaList nextNode = p->next;
            p->size += nextNode->size;
            p->next = nextNode->next;
            nextNode->next->pre = p;
            p->pid = -1;
            p->state = FREE;
            free(nextNode);
        } else {
            p->pid = -1;
            p->state = FREE;
        }
    }
    return 1;
}
void displayAllocTable(){
    SubAreaList p = head;
    printf("\n%5s %5s %5s %5s\n","起始地址","终止地址","长度","分配状态","ID");

    while (p){
        printf("\n%5d %5d %5d %5d\n",p->addr,p->addr+p->size,p->size,p->state,p->pid);
        p = p->next;
    }
    printf("\n");
}
 
//首次适应算法
SubAreaList ff(int psize){
    SubAreaList p = head;
    while(p){
        if(p->size>=psize && p->state==FREE) return p;
        p = p->next;
    }
    return NULL;
}
int ffAlloc(int pid,int psize){
    return alloc(pid,psize, ff(psize));
}
//循环首次适应
SubAreaList nfFindFreeSubArea(int psize) {
    SubAreaList tmp = nowList;
    while (nowList) {
        if (nowList->state == FREE && nowList->size >= psize)  return nowList;
        nowList = nowList->next == NULL ? head : nowList->next;//如果到了队尾 返回队首
        if (nowList == tmp) return NULL;//判断是否循环了一圈
    }
}
int nfAlloc(int pid, int psize) {
    int ret = alloc(pid, psize, nfFindFreeSubArea(psize));
    nowList = nowList->next == NULL ? head : nowList->next;
    return ret;
}
//最佳适应算法
SubAreaList bfFindFreeSubArea(int psize) {
    SubAreaList p = head, minP = NULL;
    int minSize = MEMORY_SIZE + 1;
    while (p) {
        if (p->state == FREE && p->size >= psize) {
            if (p->size < minSize) {
                minSize = p->size;
                minP = p;
            }
        }
        p = p->next;
    }
    return minP;
}
int bfAlloc(int pid, int psize) {
    return alloc(pid, psize, bfFindFreeSubArea(psize));
}
//最坏适应算法
SubAreaList wfFindFreeSubArea(int psize) {
    SubAreaList p = head, maxP = NULL;
    int maxSize = -1;

    while (p) {
        if (p->state == FREE && p->size >= psize) {
            if (p->size > maxSize) {
                maxSize = p->size;
                maxP = p;
            }
        }
        p = p->next;
    }

    return maxP;
}
int wfAlloc(int pid, int psize) {
    return alloc(pid, psize, wfFindFreeSubArea(psize));
}

 
void FF(){
    printf("分配输入: A 作业号 大小\n");
    printf("回收输入: F 作业号\n");
    printf("退出输入: Q\n\n");

    char T[5];
    scanf("%s",T);
    while (T[0]!='Q'){
        if(T[0]=='A'){
            int id,size;
            printf("> ");
            scanf("%d%d",&id,&size);
            printf("%d %d",id,size);
            int ret = ffAlloc(id,size);
            if(ret){
                printf("作业号%d 分配%d KB\n",id,size);
                displayAllocTable();
            } else{
                printf("\n 内存不足,分配失败\n\n");
            }
        } else if(T[0]=='F'){
            int id;
            scanf("%d",&id);
            int ret = freeAlloc(id);
            if(ret){
                printf("作业号 %d  已回收\n", id);
                displayAllocTable();
            }else {
                printf("未找到相关作业,回收失败\n\n");
            }
        }else
            exit(0);
        scanf("%s",T);
    }
}
 
void NF(){
    printf("分配输入: A 作业号 大小\n");
    printf("回收输入: F 作业号\n");
    printf("退出输入: Q\n\n");

    char T[5];
    scanf("%s",T);
    while (T[0]!='Q'){
        if(T[0]=='A'){
            int id,size;
            printf("> ");
            scanf("%d%d",&id,&size);
            printf("\n%d %d",id,size);
            //关键步骤
            int ret = nfAlloc(id,size);
            if(ret){
                printf("作业号%d 分配%d KB\n",id,size);
                displayAllocTable();
            } else{
                printf("\n 内存不足,分配失败\n\n");
            }
        } else if(T[0]=='F'){
            int id;
            scanf("%d",&id);
            int ret = freeAlloc(id);
            if(ret){
                printf("作业号 %d  已回收\n", id);
                displayAllocTable();
            }else {
                printf("未找到相关作业,回收失败\n\n");
            }
        }else
            exit(0);
        scanf("%s",T);
    }
}
void BF(){
    printf("分配输入: A 作业号 大小\n");
    printf("回收输入: F 作业号\n");
    printf("退出输入: Q\n\n");

    char T[5];
    scanf("%s",T);
    while (T[0]!='Q'){
        if(T[0]=='A'){
            int id,size;
            printf("> ");
            scanf("%d%d",&id,&size);
            printf("%d %d",id,size);
            //关键步骤
            int ret = bfAlloc(id,size);
            if(ret){
                printf("作业号%d 分配%d KB\n",id,size);
                displayAllocTable();
            } else{
                printf("\n 内存不足,分配失败\n\n");
            }
        } else if(T[0]=='F'){
            int id;
            scanf("%d",&id);
            int ret = freeAlloc(id);
            if(ret){
                printf("作业号 %d  已回收\n", id);
                displayAllocTable();
            }else {
                printf("未找到相关作业,回收失败\n\n");
            }
        }else
            exit(0);
        scanf("%s",T);
    }
}
void WF(){
    printf("分配输入: A 作业号 大小\n");
    printf("回收输入: F 作业号\n");
    printf("退出输入: Q\n\n");

    char T[5];
    scanf("%s",T);
    while (T[0]!='Q'){
        if(T[0]=='A'){
            int id,size;
            printf("> ");
            scanf("%d%d",&id,&size);
            printf("%d %d",id,size);
            //关键步骤
            int ret = wfAlloc(id,size);
            if(ret){
                printf("作业号%d 分配%d KB\n",id,size);
                displayAllocTable();
            } else{
                printf("\n 内存不足,分配失败\n\n");
            }
        } else if(T[0]=='F'){
            int id;
            scanf("%d",&id);
            int ret = freeAlloc(id);
            if(ret){
                printf("作业号 %d  已回收\n", id);
                displayAllocTable();
            }else {
                printf("未找到相关作业,回收失败\n\n");
            }
        }else
            exit(0);
        scanf("%s",T);
    }
}
 
 
int main(){
    head = initSubArea();
    nowList = head;

    printf("\n-----------------------------------\n\n");
    printf("            内存动态分区分配方式的模拟           \n\n");
    printf(" 1) 首次适应算法\n");
    printf(" 2) 循环首次适应算法\n");
    printf(" 3) 最佳适应算法\n");
    printf(" 4) 最坏适应算法\n");
    printf(" q) 退出\n");
    printf("\n-------------------------------\n\n");
    char op[20];
    printf("> ");
    scanf("%s",op);

    if (!strcmp(op, "1"))
        FF();
    else if (!strcmp(op, "2"))
        NF();
    else if (!strcmp(op, "3"))
        BF();
    else if (!strcmp(op, "4"))
        WF();

    return 0;
}

参考链接:基于c语言的分区算法https://www.write-bug.com/article/1383.html文章来源地址https://www.toymoban.com/news/detail-460948.html

到了这里,关于操作系统实验(一)——可变分区存储管理的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 操作系统的存储管理

      文件系统是操作系统用于明确存储设备或分区上的文件的方法和数据结构;即在存储设备上组织文件的方法。操作系统中负责管理和存储文件信息的软件机构称为文件管理系统,简称文件系统。 注意:拷的文件比较大时,需要格式化为NTFS 注意:一个硬盘只有一个扩展分区

    2024年01月24日
    浏览(36)
  • 【操作系统】存储器管理练习

    12.(考研真题) 假设一个分页存储系统具有 快表 ,多数活动页表项都可以存在于其中。 若页表放在内存中,内存访问时间是1ns,快表的命中率是85%,快表的访问时间为0.1ns, 则 有效存取时间 为多少? 15.  已知某分页系统,内存容量为64KB,页面大小为1KB,对一个4页大的作业

    2024年02月05日
    浏览(95)
  • 操作系统 | 实验八 文件管理

    掌握文件的存取方法;掌握文件的逻辑结构和物理结构;掌握存储空间的分配和回收;掌握磁盘管理与调度。 用程序模拟磁盘的调度过程,并计算各磁盘调度算法包括先来先服务算法、最短寻道时间优先算法、扫描算法和循环扫描算法的平均寻道长度。 本实验是模拟操作系

    2024年02月06日
    浏览(46)
  • 操作系统实验之文件管理

    目录 一、实验目的 二、实验内容 三、实验思路 四、主要数据结构 五、实验流程图 六、实现代码 七、运行结果 通过这次实验,掌握文件系统的用户管理,掌握普通文件、目录文件管理的基本原理。 1、通过初始化操作建立一个模拟外存空间的虚拟磁盘文件,在该文件中保存

    2024年02月05日
    浏览(47)
  • 【操作系统】——基本分页存储管理

    将内存分为一个个大小相等的分区, 这些分区称作为(页框、页帧、内存块、物理块、物理页面)若对分区进从编号,则又有了对应的(页框号、页帧号、内存块号、物理块号、物理页号),从0开始 进程的信息都是要存在内存中的,既然内存有了分区,那么进程逻辑地址空间

    2024年02月06日
    浏览(43)
  • 操作系统实验——进程管理的算法实现

    笔者在大学下属的事业单位上班,最近去帮着带下操作系统的实验课,这里随手水点参考代码,欢迎各位领导老师莅临指正 编写一个简单的进程调度器 进程控制块(PCB)的定义与管理 进程调度算法的实现 进程创建、销毁和切换 给定一批进程对比3-4种调度算法的时间(自选

    2024年02月06日
    浏览(44)
  • Linux操作系统实验三 文件管理(一)

      1.实验目的与要求 了解Linux文件系统目录结构 掌握目录管理的相关操作 掌握文件管理的相关操作 2.实验平台 实验室安装的实验环境(Linux操作系统)和头歌(www.educoder.net)实验平台(课程实验) 3.实验内容 文件系统目录结构理论知识练习 linux 下目录的创建、应用、查看、

    2024年02月03日
    浏览(52)
  • 计算机系统结构与操作系统实验三(6)-内存管理

    实现内存管理 这里修改makefile文件和run.sh文件 在《操作系统真相还原源码》的基础上稍加修改makefile 注意:这里要用 make all 命令来执行makefile文件了 本实验所有源码👉👉👉 计算机系统结构与操作系统实验三bochs源代码

    2024年02月15日
    浏览(43)
  • 【操作系统笔记04】操作系统之内存管理方式(分页、分段、段页式)、虚拟存储技术、页面置换算法

    这篇文章,主要介绍操作系统之内存管理方式(分页、分段、段页式)、虚拟存储技术、页面置换算法。 目录 一、操作系统 1.1、基地址变换机构 1.2、具有快表的地址变换机构

    2023年04月21日
    浏览(42)
  • 【Linux操作系统】【综合实验三 用户帐号、文件系统与系统安全管理】

    要求掌握Linux系统用户的创建、删除与管理操作;熟悉Linux文件系统的管理模式,学会创建用户文件系统并装载和卸载文件系统;掌握超级用户的管理方式与权限,并实施对普通用户的管理;熟悉Linux系统安全机制与相关管理方法。 通过这个第三阶段实验,要求掌握以下操作与

    2023年04月14日
    浏览(35)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包