操作系统课程实验3-可变分区存储管理

最新推荐文章于 2024-09-21 14:48:47 发布
最新推荐文章于 2024-09-21 14:48:47 发布
阅读量465 收藏 11
点赞数 7
分类专栏： 计算机操作系统 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46396470/article/details/139133376
版权

操作系统课程实验3-可变分区存储管理

一、实验介绍

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

参照教材P137-P140的内容，编写一个C程序，用循环首次适应算法、最佳适应算法和最坏适应算法，模拟可变分区存储管理，实现对内存区的分配和回收管理。

1.3 实验要求
  1. 每次分配和释放后显示空闲分区表。
  2. 空闲分区表可采用结构数组的形式（最低要求）或双向链表的形式。
1.4 参考测试数据

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

二、实现代码

#include<stdio.h>  
#include<stdlib.h> 
#include<iostream> 

using namespace std; 

#define ALLOCATED 1 						// 定义已分配状态为1
#define FREE 0 								// 定义空闲状态为0
#define SEQUENCELENGTH 6 					// 定义操作序列长度为6

typedef struct CHAIN { 						// 定义链表结构体 Table
    int status; 							// 记录块的状态：ALLOCATED 或 FREE
    int pid; 								// 记录分配给的进程ID
    int size; 								// 记录块的大小
    int addr; 								// 记录块的起始地址
    struct CHAIN *Next_Block; 				// 指向下一块的指针
    struct CHAIN *Pre_Block; 				// 指向前一块的指针
} Table; 

Table *Head; 								// 头指针，指向链表的头部
int OCPSequence[SEQUENCELENGTH][3] = { 		// 操作序列数组，包含分配和回收操作
    {1, 1, 300}, {1, 2, 100}, {2, 1, 300}, {1, 3, 150}, {1, 4, 90}, {2, 2, 100}
};

void start(); 								// 声明启动函数

void FirstFit(); 							// 声明首次适应算法函数
void BestFit(); 							// 声明最佳适应算法函数
void WorstFit(); 							// 声明最坏适应算法函数
void CirFirstFit(); 						// 声明循环首次适应算法函数

bool recycle(int pid); 						// 声明回收函数
void linkprint(void); 						// 声明链表打印函数
void CommomDeal(int alg); 					// 声明通用处理函数

Table* FindFF(int size); 					// 声明首次适应算法查找函数
Table* FindBF(int size); 					// 声明最佳适应算法查找函数
Table* FindWF(int size); 					// 声明最坏适应算法查找函数
Table* FindCFF(int size); 					// 声明循环首次适应算法查找函数

void HeadReset(void); 						// 声明头节点重置函数

int main(void) {
    Head = (Table*)malloc(sizeof(Table)); 	// 分配内存给头节点
    Head->Next_Block = Head->Pre_Block = NULL; // 初始化头节点的前后指针
    HeadReset(); 							// 重置头节点
    start(); 								// 启动模拟
    return 0; 
}

void start() {
    cout << "we are gonna do a simulation about memory allocation" << endl; 
    cout << "next,there are some algorithm is waiting for you,you need to choose one of them in every circle" << endl; 
    cout << "1.首次适应算法\t2.最佳适应算法\t3.最坏适应算法\t4.循环首次适应算法" << endl << endl << endl << endl; 
    int IDofAlgorithm; 						// 声明算法ID变量
    for (int i = 0; i < 4; i++) { 			// 循环4次，模拟4个算法
        cout << "输入算法ID："; 			
        cin >> IDofAlgorithm; 				// 输入算法ID
        while (IDofAlgorithm < 1 || IDofAlgorithm > 4) { // 检查输入是否合法
            cout << "无效的算法ID，请重新输入："; 
            cin >> IDofAlgorithm; 
        }
        switch (IDofAlgorithm) { 			// 根据算法ID选择对应算法
            case 1:
                printf("--------------------------------------------------------------------------------------\n                                     首次适应算法                                     \n--------------------------------------------------------------------------------------\n"); // 打印首次适应算法标题
                FirstFit(); 				// 调用首次适应算法函数
                break;
            case 2:
                printf("--------------------------------------------------------------------------------------\n                                     最佳适应算法                                     \n--------------------------------------------------------------------------------------\n"); // 打印最佳适应算法标题
                BestFit(); 					// 调用最佳适应算法函数
                break;
            case 3:
                printf("--------------------------------------------------------------------------------------\n                                     最坏适应算法                                     \n--------------------------------------------------------------------------------------\n"); // 打印最坏适应算法标题
                WorstFit(); 				// 调用最坏适应算法函数
                break;
            case 4:
                printf("--------------------------------------------------------------------------------------\n                                   循环首次适应算法                                   \n--------------------------------------------------------------------------------------\n"); // 打印循环首次适应算法标题
                CirFirstFit(); 				// 调用循环首次适应算法函数
                break;
        }
        HeadReset(); 						// 重置头节点，准备下一个算法测试
    }
}

void FirstFit() {
    CommomDeal(1); // 调用通用处理函数，参数为1（首次适应算法）
}
void BestFit() {
    CommomDeal(2); // 调用通用处理函数，参数为2（最佳适应算法）
}
void WorstFit() {
    CommomDeal(3); // 调用通用处理函数，参数为3（最坏适应算法）
}

Table* FindFF(int size) {
    Table * p = Head; 					// 初始化指针p为头节点
    while (p != NULL ) { 				// 遍历链表
        if (p->size >= size && p->status == FREE) // 找到第一个合适的空闲块
            return p; 					// 返回该块指针
        p = p->Next_Block; 				// 移动到下一个块
    }
    return NULL; 						// 如果没有合适的块，返回NULL
}

Table* FindBF(int size) {
    Table * p = Head; 					// 初始化指针p为头节点
    Table * best = NULL; 				// 初始化最优块指针为NULL
    while (p != NULL ) { 				// 遍历链表
        if (p->status == FREE && p->size >= size && (best == NULL || p->size < best->size)) // 找到更小的合适空闲块
            best = p; 					// 更新最优块指针
        p = p->Next_Block; 				// 移动到下一个块
    }
    return best; 						// 返回最优块指针
}

Table* FindWF(int size) {
    Table * p = Head; 					// 初始化指针p为头节点
    Table * Worst = NULL; 				// 初始化最差块指针为NULL
    while (p != NULL ) { 				// 遍历链表
        if (p->status == FREE && p->size >= size && (Worst == NULL || p->size > Worst->size)) // 找到更大的合适空闲块
            Worst = p; 					// 更新最差块指针
        p = p->Next_Block; 				// 移动到下一个块
    }
    return Worst; 						// 返回最差块指针
}

Table* FindCFF(Table * p, int size) {
    Table * Flag = p; 					// 保存初始块指针
    if (p == NULL) 						// 如果初始块为空
        p = Head; 						// 从头开始
    while (p != NULL) { 				// 遍历链表
        if (p->status == FREE && p->size >= size) // 找到合适的空闲块
            return p; 					// 返回该块指针
        if (!p->Next_Block) 			// 如果到达链表末尾
            p = Head; 					// 回到头节点
        else
            p = p->Next_Block; 			// 移动到下一个块
        if (p == Flag) 					// 如果回到初始块
            return NULL; 				// 返回NULL表示没有找到合适块
    }
}

void CommomDeal(int alg) {
    Table* (*Tar)(int); 				// 定义函数指针
    switch (alg) { 						// 根据算法选择对应查找函数
        case 1:
            Tar = FindFF; // 指向首次适应算法查找函数
            break;
        case 2:
            Tar = FindBF; // 指向最佳适应算法查找函数
            break;
        case 3:
            Tar = FindWF; // 指向最坏适应算法查找函数
            break;
    }
    for (int i = 0; i < SEQUENCELENGTH; i++) { 			// 遍历操作序列
        if (OCPSequence[i][0] == 1) { 					// 分配操作
            int ID, size;
            ID = OCPSequence[i][1]; 					// 获取进程ID
            size = OCPSequence[i][2]; 					// 获取请求大小
            Table  *pReturn;
            printf("进程%d请求%dKB\n", ID, size); 		// 打印请求信息
            printf("--------------------------------------------------------------------------------------\n");

            if ((pReturn = Tar(size)) != NULL) { 		// 调用查找函数，找到合适块
                if (pReturn->size == size) { 			// 如果块大小正好
                    pReturn->pid = ID; 					// 设置块的进程ID
                    pReturn->status = ALLOCATED; 		// 设置块的状态为已分配
                } else { 								// 如果块大小大于请求大小
                    Table * NewFreeNode = (Table*)malloc(sizeof(Table)); // 创建新空闲块
                    NewFreeNode->pid = -1; 				// 初始化新块
                    NewFreeNode->addr = pReturn->addr + size; // 设置新块地址
                    NewFreeNode->size = pReturn->size - size; // 设置新块大小
                    NewFreeNode->status = FREE; 		// 设置新块状态为空闲

                    pReturn->pid = ID; 					// 设置当前块的进程ID
                    pReturn->size = size; 				// 设置当前块的大小
                    pReturn->status = ALLOCATED; 		// 设置当前块的状态为已分配

                    NewFreeNode->Pre_Block = pReturn; 	// 设置新块的前指针
                    NewFreeNode->Next_Block = pReturn->Next_Block; // 设置新块的后指针
                    pReturn->Next_Block = NewFreeNode; 	// 设置当前块的后指针为新块
                }
            } else { 									// 如果没有合适的块
                cout << "内存不足，分配失败" << endl; 	// 打印失败信息
            }

        } else { 										// 回收操作
            int pid;
            pid = OCPSequence[i][1]; 					// 获取要回收的进程ID
            printf("请求回收进程%d，即将释放内存空间%dKB\n", pid, OCPSequence[i][2]); // 打印回收请求信息
            if (!recycle(pid)) 							// 调用回收函数
                cout << "进程不存在，回收失败" << endl; // 打印回收失败信息
            else
                cout << "回收成功" << endl; 			// 打印回收成功信息
        }
        linkprint(); 									// 打印当前链表状态
        printf("--------------------------------------------------------------------------------------\n");
    }
    cout << endl << endl << endl;
}

void CirFirstFit() {
    Table *Current = NULL; 								// 初始化当前指针为空
    for (int i = 0; i < SEQUENCELENGTH; i++) { 			// 遍历操作序列
        if (OCPSequence[i][0] == 1) { 					// 分配操作
            int ID, size;
            ID = OCPSequence[i][1]; 					// 获取进程ID
            size = OCPSequence[i][2]; 					// 获取请求大小
            printf("进程%d请求%dKB\n", ID, size); 		// 打印请求信息
            printf("--------------------------------------------------------------------------------------\n");
            if ((Current = FindCFF(Current ? Current->Next_Block : Head, size)) != NULL) { // 调用循环首次适应查找函数
                if (Current->size == size) { 			// 如果块大小正好
                    Current->pid = ID; 					// 设置块的进程ID
                    Current->status = ALLOCATED; 		// 设置块的状态为已分配
                } else { 								// 如果块大小大于请求大小
                    Table * NewFreeNode = (Table*)malloc(sizeof(Table)); // 创建新空闲块
                    NewFreeNode->pid = -1; 				// 初始化新块
                    NewFreeNode->addr = Current->addr + size; // 设置新块地址
                    NewFreeNode->size = Current->size - size; // 设置新块大小
                    NewFreeNode->status = FREE; 		// 设置新块状态为空闲

                    Current->pid = ID;					// 设置当前块的进程ID
                    Current->size = size; 				// 设置当前块的大小
                    Current->status = ALLOCATED; 		// 设置当前块的状态为已分配

                    NewFreeNode->Pre_Block = Current; 	// 设置新块的前指针
                    NewFreeNode->Next_Block = Current->Next_Block; // 设置新块的后指针
                    Current->Next_Block = NewFreeNode; 	// 设置当前块的后指针为新块
                }
            } else { 									// 如果没有合适的块
                cout << "内存不足，分配失败" << endl; 	// 打印失败信息
            }

        } else { 										// 回收操作
            int pid;
            pid = OCPSequence[i][1]; 					// 获取要回收的进程ID
            printf("请求回收进程%d，即将释放内存空间%dKB\n", pid, OCPSequence[i][2]); // 打印回收请求信息
            if (!recycle(pid)) 							// 调用回收函数
                cout << "进程不存在，回收失败" << endl; // 打印回收失败信息
            else
                cout << "回收成功" << endl; 			// 打印回收成功信息
        }
        linkprint(); 									// 打印当前链表状态
        printf("--------------------------------------------------------------------------------------\n");
    }
    cout << endl << endl << endl;
}

bool recycle(int pid) {
    Table *p = Head; 									// 初始化指针p为头节点
    while (p) { 										// 遍历链表
        if (p->pid == pid) { 							// 找到匹配的进程ID
            p->status = FREE; 							// 设置块状态为空闲
            // 合并相邻的空闲块
            if (p->Next_Block && p->Next_Block->status == FREE) { // 如果下一块也是空闲
                Table *next = p->Next_Block; 			// 保存下一块指针
                p->size += next->size; 					// 合并大小
                p->Next_Block = next->Next_Block; 		// 更新当前块的后指针
                if (next->Next_Block) {
                    next->Next_Block->Pre_Block = p; 	// 更新下一块的前指针
                }
                free(next); 							// 释放合并的块
            }
            if (p->Pre_Block && p->Pre_Block->status == FREE) { // 如果前一块也是空闲
                Table *prev = p->Pre_Block; 			// 保存前一块指针
                prev->size += p->size; 					// 合并大小
                prev->Next_Block = p->Next_Block; 		// 更新前一块的后指针
                if (p->Next_Block) {
                    p->Next_Block->Pre_Block = prev; 	// 更新当前块的前指针
                }
                free(p); 								// 释放合并的块
                p = prev; 								// 更新指针p为前一块
            }
            return true; 								// 返回回收成功
        }
        p = p->Next_Block; 								// 移动到下一个块
    }
    return false; 										// 如果没有找到匹配的进程ID，返回回收失败
}

void linkprint(void) {
    Table *p = Head; 									
    while (p) { 									
        if (p->status == 0) 							
            cout << "" << p->addr << "~" << p->addr + p->size << ":" << p->status <<  ""; // 打印空闲块信息
        else 											
            cout << "" << p->addr << "~" << p->addr + p->size << ":" << p->status << " by " << p->pid << ""; // 打印已分配块信息
        if (p->Next_Block) 								
            cout << "-->"; 								
        p = p->Next_Block; 								
    }
    cout << endl; 									
}

void HeadReset(void) {
    Table* p = Head->Next_Block; 			// 初始化指针p为头节点的下一块
    Table *temp; 							// 声明临时指针
    while (p) { 							// 遍历链表
        temp = p->Next_Block; 				// 保存下一块指针
        free(p); 							// 释放当前块
        p = temp; 							// 更新指针p为下一块
    }
    Head->addr = 100; 						// 重置头节点地址
    Head->Next_Block = NULL; 				// 重置头节点后指针
    Head->Pre_Block = NULL; 				// 重置头节点前指针
    Head->pid = -1; 						// 重置头节点进程ID
    Head->size = 500; 						// 重置头节点大小
    Head->status = FREE; 					// 重置头节点状态为空闲
}

三、心灵的救赎

  1. 人间没有永恒的夜晚，世界没有永恒的冬天。
  2. 当生活把无边的严寒铺盖在你身上时，一定会给你一根火柴。
    在这里插入图片描述
Midsummer-逐梦
关注
专栏目录
可变分区存储管理实验报告总结_可变分区存储管理方式的内存分配和回收实验报告(最优算法)...
weixin_39854867的博客
12-19 1611
第1页一．实验目的通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解，熟悉可变分区存储管理的内存分配和回收。二．实验内容1．确定内存空间分配表；2．采用最优适应算法完成内存空间的分配和回收；3．编写主函数对所做工作进行测试。三．实验背景材料由于可变分区的大小是由作业需求量决定的，故分区的长度是预先不固定的，且分区的个数也随内存分配和回收变动。总之，所有分区情况随时可能发生变化，数据表格的设...
可变分区存储管理实验报告总结_操作系统课程设计实验报告-可变分区存储管理和多级队列调度算法模拟实现...
weixin_39779530的博客
12-19 886
操作系统课程设计实验报告-可变分区存储管理和多级队列调度算法模拟实现 (34页) 本资源提供全文预览，点击全文预览即可全文预览,如果喜欢文档就下载吧，查找使用更方便哦！19.90 积分操作系统课程设计报告姓名学号班级院系日期指导教师实验一可变分区存储管理一、实验要求设计合理的数据结构来描述存储空间对于未分配出去的部分，可以用空闲分区队列来描述，对于已经分配出去的部分，由装入内存的作业占据，可以将...
操作系统实验四——可变分区内存管理器设计与实现
qq_63052532的博客
01-17 1418
可变分区内存管理器设计与实现。
可变分区存储管理实验报告总结_操作系统实验报告-可变分区存储管理方式的内存分配回收...
weixin_33305287的博客
12-29 2176
实验三可变分区存储管理方式的内存分配回收一．实验目的(1)深入了解可变分区存储管理方式的内存分配回收的实现。二．实验内容编写程序完成可变分区存储管理方式的内存分配回收，要求有内存空间分配表，并采用最优适应算法完成内存的分配与回收。三．实验原理在可变分区模式下，在系统初启且用户作业尚未装入主存储器之前，整个用户区是一个大空闲分区，随着作业的装入和撤离，主存空间被分成许多分区，有的分区被占用，而有的分...
可变分区存储管理实验报告总结_分区存储管理实验报告.docx
weixin_34382015的博客
01-12 1802
分区存储管理的实验报告实验题目：可变分区存储管理　　一、实验目的　　可变分区存储管理方式是操作系统中存储管理的重要方式，其主要思想是用户作业进行连续存储，每次按照用户的请求，如果内存中有能满足用户作业大小的空闲区，就采用不同的算法分配给用户，否则，不分配，可变分区容易产生外零头。分区分配算法包括最佳适应算法、最坏适应算法、首次适应算法等。　　通过本实验可加深学生对存储器管理方式的把握以及分配算法的...
分区存储管理 C语言,操作系统实验一可变分区存储管理(含代码).doc
weixin_36366239的博客
05-18 1405
操作系统实验一可变分区存储管理(含代码)《计算机操作系统》实 验 任 务 书实验报告内容规范实验报告内容要求如下：课程名称实验日期实验名称姓名学号指导教师一、实验目的及要求本次所涉及并要求掌握的知识点。二、实验环境本次所使用的软件。三、实验内容四、实验步骤五、调试过程详细记录过程中出现的问题及解决方法。记录结果、总结心得体会及改进意见。70以如下格式命名：实验序号学号姓名.doc；如：实验三.do...
可变分区存储管理实验报告总结_操作系统内存储器空间的管理的实验报告.doc...
weixin_39966020的博客
12-19 442
操作系统内存储器空间的管理的实验报告安徽师范大学学院实验报告专业名称 软件工程实 验 室 2#201实验课程 操作系统实验实验名称 内存储器空间的管理姓 名学 号同组人员实验日期 2013/6/7注：实验报告应包含(实验目的，实验原理，主要仪器设备和材料，实验过程和步骤，实验原始数据记录和处理，实验结果和分析，成绩评定)等七项内容。具体内容可根据专业特点和实验性质略作调整，...
操作系统课程设计--连续动态分区内存管理模拟实现.doc
05-06
### 操作系统课程设计——连续动态分区内存管理模拟实现 #### 一、引言 在计算机科学领域，操作系统作为连接硬件与应用软件的重要桥梁，其核心任务之一就是有效地管理和调度计算机系统的资源，特别是内存资源。...
计算机操作系统内存管理系统可变分区存储管理方式的内存分配回收.doc
11-15
【计算机操作系统内存管理系统可变分区存储管理方式的内存分配回收】 在计算机操作系统中，内存管理是确保高效利用有限内存资源的关键部分。可变分区存储管理方式是一种动态分配内存的方法，它根据进程的需求来划分...
计算机操作系统内存标准管理系统可变分区存储管理方式的内存分配回收.doc
12-18
计算机操作系统内存标准管理系统可变分区存储管理方式的内存分配回收 计算机操作系统内存标准管理系统可变分区存储管理方式的内存分配回收是计算机操作系统中的一种重要的内存管理机制。本文将详细介绍可变分区存储...
操作系统实验一可变分区存储管理含代码.doc
07-08
总之，可变分区存储管理实验是操作系统课程中的关键部分，它帮助学生实际操作内存分配和回收，增强对操作系统内存管理策略的直观理解。实验代码的设计和实现有助于巩固数据结构、内存管理和指针操作等重要概念。
OS课程设计实验报告_可变分区存储管理.pdf
11-09
操作系统课程设计实验报告的核心主题是可变分区存储管理的模拟实现。可变分区存储管理是一种内存分配策略，它允许内存分区的大小根据作业的需求动态变化。以下是对这一主题的详细说明： 1. 数据结构设计： - 空闲...
Python爬取某猫投诉数据（含signature参数分析与算法还原）
吴秋霖的博客
09-15 1174
使用Python爬取某猫投诉的数据（包含加密参数分析与算法的还原）
力扣 16.最接近的三数之和
qq_51352130的博客
09-16 387
设 s=nums[i]+nums[j]+nums[k]，为了判断 s 是不是与 target 最近的数，我们还需要用一个变量 minDiff 维护 ∣s−target∣ 的最小值。分类讨论：如果 s=target，那么答案就是 s，直接返回 s。如果 s>target，那么如果 s−target<minDiff，说明找到了一个与 target 更近的数，更新 minDiff 为 s−target，更新答案为 s。然后和三数之和一样，把 k 减一。
拥塞控制算法为何失效，网络为何难以测量？
Netfilter
09-14 7772
所以你知道实验室仿真的宇宙第一算法为啥拉了吧，也就不用再问为什么部署了 bbr 却还不如 cubic 了吧，如果你还希望研发一个精准的，普适的端到端算法，我劝你改行去卖皮鞋，至少还有很多经理市场。这和上一篇说的测量系统容量的方法并不矛盾，因为对于网络传输系统而言，系统是动态变化的，在流量部署到系统上并开始传输时，没有全局视图，就不能指望全局公平，留下的 gap 是固有的，没法靠算法弥补。，超级经典的一篇论文，我推荐过不止一次，因此我本文不谈异构问题，说点别的，比如拓扑。对，就是要砸，因为我不干了。
尊享面试100题
最新发布
qq_71286244的博客
09-21 229
尊享面试100题
双指针算法专题（2）
我要学编程的博客
09-16 992
LeetCode刷题：有效三角形的个数、查找总价格为目标值的两个商品（两数之和）、三数之和、四数之和
二分系列(二分答案最大值)9/15.16
2301_78191305的博客
09-16 1009
给你一批机器，及其它制作一块合金所需要的不同种类金属的个数。第一台机器制作一块合金，需要一块A金属、一块B金属、一块C金属。我们对每一类机器所需要的各种种类的金属进行判断，如果仓库里面有，就不需要花钱；如果mid-index<1的，要计算有多少个1。前n项和:(mid-1+1)*(mid-1)/2+leftCount-(mid-1);根据贪心:以index为中心，向两边依次-1，直到减到1为止。如果mid-rightCount<1,先计算多少个1，xxx。
操作系统的可变分区存储管理：首次、最佳与最坏适应算法
在操作系统中，可变分区存储管理是一种内存分配策略，它根据进程的需求动态地分配内存空间。这种管理方式适用于内存需求不固定的场景，允许系统在运行时调整分区大小。本课程设计关注的是如何实现动态分区分配，主要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值