操作系统原理与实验——实验十分段存储管理

2024-05-09 14:52
文章标签 原理 实验 存储管理 操作系统 十分

本文主要是介绍操作系统原理与实验——实验十分段存储管理，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

实验指南

运行环境：

Dev c++

算法思想：

本实验是模拟分段存储管理，系统需要建立两张分区表，分别是已分配和未分配分区表，首先根据装入作业的大小判断是否小于空闲分区的总容量，若满足，则对该作业继续进行分段，每输入一个分段大小就在空闲分区中找到第一个没有使用且足够大的分区，若找到将该分区标记为该作业名和对应的分段号，修改已分配和未分配分区表，并打印内存分配信息。对已分配分区的回收，首先输入要回收的作业名，找到该作业的每一段所在的分区，修改已分配分区表，未分配分区表（根据是否存在上下邻），打印回收成功后内存分配信息。

关键数据结构定义：

//内存结构体

typedef struct memory_node

{

    int size; //内存大小

    int address; //内存始址

} memoryNode;

memoryNode memory;

//分区结构体

typedef struct link_node

{

    int id;//分区号

    int size; //分区长度

    int address; //分区始址

    char flag[20]; //分区状态，空闲或者占用作业名

    struct link_node* next;

} node;

//段表

typedef struct segment_node

{

    int a[10][10];

    struct segment_node *next;

} segmentNode;

程序框架：

//函数名 :initMemory  参数:无

node* initMemory()

{

  //函数功能：初始化内存空间

}

//函数名:operation 参数:node* head

int operation(node *head)

{

//函数功能：打印操作菜单，选择需要进行的操作,输入1进行内存 分配,输入2进  行内存去配,输入0退出

}

//函数名:allocate 参数:node* head

void allocate(node *head)

{

//函数名：输入作业名和大小，默认采用最先分配

}

//函数名:firstAllocation 参数:node* head,int size,charc[10]

void firstAllocation(node* head,int size,char c[10])

{

 //函数功能：对作业进行分段，并采用最先分配，分段结束后打印 段表

}

        //函数名:reorder 参数:node* head

void reorder(node* head)

{

   //函数功能：对分区和未分区的存储区域进行编号 

}

//函数名:recycle 参数:node* head

void recyle(node* head) //回收算法

{

   //函数功能：对归还分区按情况进行处理，，有上邻有下邻，有上邻     无下邻，无上邻有下邻，无上邻无下邻

            

}

//函数名:print参数:node* head

void print(node* head)

{

   //函数功能：打印主存分配表

}

int main()

{

    node* head;

    head=initMemory();

    while(1)

    {

        int c;

        c=operation(head);

        if(c==1)

        {

            break;

        }

    }

    return 0;

}

测试用例：

/*

256

40

1

jobA

50

2

20

30

1

jobB

100

3

30

35

35

2

jobB

2

jobA

0

*/

关键代码

#include<stdio.h>
#include<malloc.h>
#include<string.h>
int g_size; 
//内存结构体
typedef struct memory_node
{int size; //内存大小int address; //内存始址
} memoryNode;memoryNode memory;//分区结构体
typedef struct link_node
{int id;//分区号int size; //分区长度int address; //分区始址char flag[20]; //分区状态，空闲或者占用作业名struct link_node* next;
} node;//段表
typedef struct segment_node
{int sum;char jobname[20];int a[10][10];struct segment_node *next;
} segmentNode;node* initMemory();
node* operation(node *head);
node* allocate(node *head);
node* firstAllocation(node* head,int size,char c[10]);
node* reorder(node* head);
node* recyle(node* head);
void print(node* head);node *distribute = NULL;segmentNode *duanbiao =NULL;//函数名 :initMemory  参数:无
node* initMemory()
{//函数功能：初始化内存空间printf("请输入内存大小：");scanf("%d",&memory.size);g_size = memory.size;printf("请输入起始地址：");scanf("%d",&memory.address);node* p = (node *) malloc ( sizeof(node) * memory.size ); //分配可以放得下265个node的内存空间p->next = NULL;p->id = 1;p->size = memory.size;p->address = memory.address;p->flag[0] = '\0';return p;
}//函数名:operation 参数:node* head
node* operation(node *head)
{
//函数功能：打印操作菜单，选择需要进行的操作,输入1进行内存分配,输入2进行内存去配,输入0退出int choice; printf("*********可变分区管理**********\n");printf("   *     1.内存分配      *\n");printf("   *     2.内存去配      *\n");printf("   *     0.退出          *\n");printf("         请输入选项[ ]\b\b");scanf("%d",&choice);if(choice == 1){printf("1.内存分配\n");reorder(head); print(head);head=allocate(head);}else if(choice == 2){printf("2.内存去配\n");reorder(head);print(head);head=recyle(head); }else{return NULL;}return head;
}
//函数名:allocate 参数:node* head
node* allocate(node *head)
{
//函数名：输入作业名和大小，默认采用最先分配char name[20];int jobsize;printf("请输入作业名：");scanf("%s",&name);printf("请输入%s需要分配的主存大小：",name);scanf("%d",&jobsize);if(jobsize <= g_size)head = firstAllocation(head,jobsize,name);elseprintf("分配失败！");return head;}//函数名:firstAllocation 参数:node* head,int size,charc[10]
node* firstAllocation(node* head,int size,char c[10])
{//函数功能：对作业进行分段，并采用最先分配，分段结束后打印 段表int count = 0,blockNum,jobblocksize,state;node *q,*pre;segmentNode* D = (segmentNode *) malloc ( sizeof(segmentNode) * 1 ); D->next = NULL;strcpy(D->jobname,c);if(duanbiao == NULL) duanbiao = D;else{D->next = duanbiao;duanbiao = D;}q = head;printf("请输入要分成几段：");scanf("%d",&blockNum);D->sum = blockNum;while(count != blockNum){   printf("剩余%dKB的内存，请输入第%d段的大小：",size,count+1);scanf("%d",&jobblocksize);node* p = (node *) malloc ( sizeof(node) * 1 ); p->next = NULL;p->size = jobblocksize;strcpy(p->flag,c);
//      p->flag[strlen(p->flag)+1] = p->flag[strlen(p->flag)];
//      p->flag[strlen(p->flag)]= '0' + count;state = count;while(1){if(state/10 == 0){p->flag[strlen(p->flag)+1] = p->flag[strlen(p->flag)];p->flag[strlen(p->flag)]= '0' + state%10;break;}else{p->flag[strlen(p->flag)+1] = p->flag[strlen(p->flag)];p->flag[strlen(p->flag)]= '0' + state/10;state=state%10;}}while(q!=NULL){if(q->size >= p->size)break;pre = q;q = q->next;}if(q!=NULL){p->address = q->address;if(q->size == p->size){if(q==head)head=NULL;elsepre->next = q->next;}else{q->size = q->size -p->size;q->address = q->address + p->size;}if(distribute == NULL){distribute = p;}else{p->next = distribute;distribute = p;}}else{printf("分配失败！");return head;}D->a[count][0] = jobblocksize;D->a[count][1] = p->address + p->size;count++;size = size - jobblocksize;reorder(head);print(head);}printf("分配成功！\n");printf("************打印%s段表************\n",c);printf("段号\t段长\t基址\n");for(int i=0;i<blockNum;i++)printf("%d\t%d\t%d\n",i,D->a[i][0],D->a[i][1]);return head;
}//函数名:reorder 参数:node* head
node* reorder(node* head) 
{//函数功能：对分区和未分区的存储区域进行编号  int count;node *p;count = 1;p = distribute;while(p!=NULL){p->id = count;count++;p = p->next; }p = head;while(p!=NULL){p->id = count;count++;p = p->next; }return head;
}//函数名:recycle 参数:node* head
node* recyle(node *head) //回收算法
{//函数功能：对归还分区按情况进行处理，有上邻有下邻，有上邻无下邻，无上邻有下邻，无上邻无下邻char name[20];int state;segmentNode *q,*preq;node *qq,*preqq,*qqq,*preqqq;//distribute q = duanbiao;printf("请输入您想回收的作业名：");scanf("%s",&name);while(q!=NULL&&strcmp(q->jobname,name)!=0){preq = q;q = q->next;}if(q==duanbiao){duanbiao=q->next;}else{preq->next=q->next;}if(q==NULL)printf("没有该作业！");else{for(int i=0;i<q->sum;i++){ qq = distribute;//已分配链表 while(qq!=NULL)//在已分配表中找要回收的作业{if(qq->address == q->a[i][1]-q->a[i][0]){if(qq==distribute){distribute = qq->next;}else{preqq->next = qq->next;}break;}preqq = qq;qq = qq->next;}preqqq = NULL;qqq = head;//未分配链表 while(qqq!=NULL)//将要回收的作业的空闲分区合并{if(qq->address+qq->size<head->address)//头没有临界区{qq->next = head;head = qq;printf("回收%s的段%s成功！\n",name,qq->flag);qq->flag[0] = '\0'; break;}else if(qq->address+qq->size == head->address)//头有下{head->address = qq->address;head->size = head->size + qq->size;printf("回收%s的段%s成功！\n",name,qq->flag);break;}else if(preqqq!=NULL&&qq->address == preqqq->address+preqqq->size&&qq->address+qq->size==qqq->address)//有上有下{preqqq->size = preqqq->size+qqq->size+qq->size;preqqq->next = qqq->next;printf("回收%s的段%s成功！\n",name,qq->flag);free(qq);break;}else if(preqqq!=NULL&&qq->address == preqqq->address+preqqq->size&&qq->address+qq->size<qqq->address)//有上没有下{preqqq->size =preqqq->size + qq->size;printf("回收%s的段%s成功！\n",name,qq->flag);free(qq);break;}else if(preqqq!=NULL&&qq->address > preqqq->address+preqqq->size&&qq->address+qq->size==qqq->address)//没有上有下{qqq->address = qq->address;qqq->size = qqq->size+qq->size;printf("回收%s的段%s成功！\n",name,qq->flag);free(qq);break;}else if(preqqq!=NULL&&qq->address > preqqq->address+preqqq->size&&qq->address+qq->size<qqq->address)//没有上没有下{qq->next = qqq;preqqq->next = qq;printf("回收%s的段%s成功！\n",name,qq->flag);qq->flag[0] = '\0';break;}else if(preqqq!=NULL&&qqq->next == NULL&&qqq->address+qqq->size==qq->address)//尾部（有上）{qqq->size = qqq->size+qq->size;printf("回收%s的段%s成功！\n",name,qq->flag);break;}else if(preqqq!=NULL&&qqq->next == NULL&&qqq->address+qqq->size<qq->address)// 尾部（没有上）{qqq->next = qq;qq->next =NULL;printf("回收%s的段%s成功！\n",name,qq->flag);qq->flag[0]='\0';break;}preqqq = qqq;qqq = qqq->next; }}reorder(head);print(head);free(q);}return head;
}
//函数名:print参数:node* head
void print(node* head)
{//函数功能：打印主存分配表node *p;printf("******************主存分配情况******************\n");p = distribute;printf("已分配：\n");printf("分配号  大小（KB）      起始（KB）      状态\n");while(p!=NULL&&p->flag[0]!='\0'){printf("%d\t%d\t\t%d\t\t%s\n",p->id,p->size,p->address,p->flag);p = p->next;}printf("\n\n\n");p = head;printf("未分配：\n");printf("分配号  大小（KB）      起始（KB）      状态\n");while(p!=NULL&&p->flag[0] == '\0'){printf("%d\t%d\t\t%d\t\t空闲\n",p->id,p->size,p->address,p->flag);p = p->next;}
}int main()
{node* head;head=initMemory();while(1){head=operation(head);if(head==NULL){break;}}return 0;
}

运行结果

实验总结

①对单链表还是不熟,没有头结点的单链表head没有next；

②对链表的遍历条件没有设计好，在该题中preqqq！=NULL才能进行遍历；

③对于指针，如果修改了指针则要返回该指针并赋值给它本身，或者在传递指针时，传的是指针的指针，否则对指针的处理是无效的。

这篇关于操作系统原理与实验——实验十分段存储管理的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/973694。

相关文章

ShardingProxy读写分离之原理、配置与实践过程

ShardingProxy读写分离之原理、配置与实践过程

《ShardingProxy读写分离之原理、配置与实践过程》ShardingProxy是ApacheShardingSphere的数据库中间件,通过三层架构实现读写分离,解决高并发场景下数据库性能瓶... 目录一、ShardingProxy技术定位与读写分离核心价值1.1 技术定位1.2 读写分离核心价值二
阅读更多...
深度解析Python中递归下降解析器的原理与实现

深度解析Python中递归下降解析器的原理与实现

《深度解析Python中递归下降解析器的原理与实现》在编译器设计、配置文件处理和数据转换领域,递归下降解析器是最常用且最直观的解析技术,本文将详细介绍递归下降解析器的原理与实现,感兴趣的小伙伴可以跟随... 目录引言：解析器的核心价值一、递归下降解析器基础1.1 核心概念解析1.2 基本架构二、简单算术表达
阅读更多...
深入浅出Spring中的@Autowired自动注入的工作原理及实践应用

深入浅出Spring中的@Autowired自动注入的工作原理及实践应用

《深入浅出Spring中的@Autowired自动注入的工作原理及实践应用》在Spring框架的学习旅程中,@Autowired无疑是一个高频出现却又让初学者头疼的注解,它看似简单,却蕴含着Sprin... 目录深入浅出Spring中的@Autowired：自动注入的奥秘什么是依赖注入？@Autowired
阅读更多...
从原理到实战解析Java Stream 的并行流性能优化

从原理到实战解析Java Stream 的并行流性能优化

《从原理到实战解析JavaStream的并行流性能优化》本文给大家介绍JavaStream的并行流性能优化：从原理到实战的全攻略,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的... 目录一、并行流的核心原理与适用场景二、性能优化的核心策略1. 合理设置并行度：打破默认阈值2. 避免装箱
阅读更多...
Python中的filter() 函数的工作原理及应用技巧

Python中的filter() 函数的工作原理及应用技巧

《Python中的filter()函数的工作原理及应用技巧》Python的filter()函数用于筛选序列元素,返回迭代器,适合函数式编程,相比列表推导式,内存更优,尤其适用于大数据集,结合lamb... 目录前言一、基本概念基本语法二、使用方式1. 使用 lambda 函数2. 使用普通函数3. 使用 N
阅读更多...
MyBatis-Plus 与 Spring Boot 集成原理实战示例

MyBatis-Plus 与 Spring Boot 集成原理实战示例

《MyBatis-Plus与SpringBoot集成原理实战示例》MyBatis-Plus通过自动配置与核心组件集成SpringBoot实现零配置,提供分页、逻辑删除等插件化功能,增强MyBa... 目录 一、MyBATis-Plus 简介 二、集成方式（Spring Boot）1. 引入依赖 三、核心机制
阅读更多...
redis和redission分布式锁原理及区别说明

redis和redission分布式锁原理及区别说明

《redis和redission分布式锁原理及区别说明》文章对比了synchronized、乐观锁、Redis分布式锁及Redission锁的原理与区别,指出在集群环境下synchronized失效,... 目录Redis和redission分布式锁原理及区别1、有的同伴想到了synchronized关键字
阅读更多...
Linux中的HTTPS协议原理分析

Linux中的HTTPS协议原理分析

《Linux中的HTTPS协议原理分析》文章解释了HTTPS的必要性：HTTP明文传输易被篡改和劫持,HTTPS通过非对称加密协商对称密钥、CA证书认证和混合加密机制,有效防范中间人攻击,保障通信安全... 目录一、什么是加密和解密？二、为什么需要加密？三、常见的加密方式3.1 对称加密3.2非对称加密四、
阅读更多...
setsid 命令工作原理和使用案例介绍

setsid 命令工作原理和使用案例介绍

《setsid命令工作原理和使用案例介绍》setsid命令在Linux中创建独立会话,使进程脱离终端运行,适用于守护进程和后台任务,通过重定向输出和确保权限,可有效管理长时间运行的进程,本文给大家介... 目录setsid 命令介绍和使用案例基本介绍基本语法主要特点命令参数使用案例1. 在后台运行命令2.
阅读更多...
Spring Security 单点登录与自动登录机制的实现原理

Spring Security 单点登录与自动登录机制的实现原理

《SpringSecurity单点登录与自动登录机制的实现原理》本文探讨SpringSecurity实现单点登录（SSO）与自动登录机制,涵盖JWT跨系统认证、RememberMe持久化Token... 目录一、核心概念解析1.1 单点登录（SSO）1.2 自动登录（Remember Me）二、代码分析三、
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2