要求
8 、固定式分区分配及可变式分区分配的存储管理方案设计与实现
【问题描述1】
设计一个固定式分区分配的存储管理方案，并模拟实现分区的分配和回收过程。
【设计要求1】
可以假定每个作业都是批处理作业，并且不允许动态申请内存。为实现分区的分配和回收，可以设定一个分区说明表，按照表中的有关信息进行分配，并根据分区的分配和回收情况修改该表。
【问题描述2】
设计一个可变式分区分配的存储管理方案，并模拟实现分区的分配和回收过程。
【设计要求2】
对分区的管理法至少是下面三种算法之一：
① 首次适应算法
② 循环首次适应算法
③ 最佳适应算法
- 首次使用算法，地址由高到低
- 最佳适应算法，内存空间由最小到大
- 最坏使用算法，内存空间由大到小
一、数据结构
- 建立内存分区链表
- 建立PCB进程需求链表
class MemUsedTable { // 内存
public:
int ID; // 空闲分区的ID
int size; // 空闲分区的大小
int address; // 空闲分区的开始地址
int state; // 0 表示未使用， 1表示使用
int workID;
MemUsedTable* next; // 下一个的指针
MemUsedTable() {
this->ID = 0;
this->size = 0;
this->address = 0;
this->state = 0;
this->workID = 0;
this->next = NULL;
}
};
class PCB {
// 进程的数据结构
public:
int ID; // PCB的ID
int size; // PCB需要的内存大小
int address; // PCB的开始地址
int runState; // 运行状态 0 表示未获得内存 1 表示获得内存
PCB* next;
PCB() {
this->ID = 0;
this->size = 0;
this->address = 0;
this->runState = 0; //
this->next = NULL; // 指向下一个
}
};
一、固定分区分配
一.1 最佳适应算法
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cmath>
using namespace std;
class MemUsedTable { // 内存
public:
int ID; // 空闲分区的ID
int size; // 空闲分区的大小
int address; // 空闲分区的开始地址
int state; // 0 表示未使用， 1表示使用
int workID;
MemUsedTable* next; // 下一个的指针
MemUsedTable() {
this->ID = 0;
this->size = 0;
this->address = 0;
this->state = 0;
this->workID = 0;
this->next = NULL;
}
};
class PCB {
// 进程的数据结构
public:
int ID; // PCB的ID
int size; // PCB需要的内存大小
int address; // PCB的开始地址
int runState; // 运行状态 0 表示未获得内存 1 表示获得内存
PCB* next;
PCB() {
this->ID = 0;
this->size = 0;
this->address = 0;
this->runState = 0; //
this->next = NULL; // 指向下一个
}
};
void dispMemInfo(MemUsedTable* memReady); // 展示内存的信息
void dispPCBInfo(PCB*& pcbQ); // 展示PCB链表的信息
int getMemLength(MemUsedTable* memReady); // 获取内存块的长度
MemUsedTable* inputMem(MemUsedTable* memReady); // 输入固定分区的内存块
MemUsedTable* sortMem(MemUsedTable* memReady, int flag); // 对内存进行排序
PCB* inputPCB(PCB* pcbQ); // 输入PCB块的信息
MemUsedTable* allocateMem(MemUsedTable*& memReady,
int label, int size); // 单个内存的分配
MemUsedTable* allocateMems(MemUsedTable*& memReady, PCB*& pcbQ); // 对PCB进行分区
bool checkMemEmpty(MemUsedTable* memReady); // 检测内存是否全部释放
bool checkPCBEmpty(PCB* pcbQ); // 检测PCB链表是否都在内存中执行
MemUsedTable* recoverMem(MemUsedTable* memReady, PCB* pcbQ); // 回收内存
// ============================= //
void dispMemInfo(MemUsedTable* memReady) {
MemUsedTable* p = memReady;
cout << endl;
while (p != NULL) {
cout << "MEM->ID: " << p->ID << ", 大小: " << p->size << "B, 分配状态： " << p->state << ", 开始地址："
<< p->address << "B";
if (p->workID != 0) {
cout << ", 已分配的作业ID: " << p->workID << endl;
}
else {
cout << ", 未分配任何作业" << endl;
}
p = p->next;
}
cout << endl;
}
int getMemLength(MemUsedTable* memReady) {
int cnt = 0;
MemUsedTable* p = memReady; // NULL 指针
while (p != NULL) {
cnt++;
p = p->next;
}
return cnt;
}
// 输入内存大小的个数
MemUsedTable* inputMem(MemUsedTable* memReady) {
// Notes：参数传入 指针时 不是全局的指针
/**
* 内存的大小以字节为单位
*
*/
int address = 0; // 内存从0开始
int id = 0; // ID号从0开始
MemUsedTable* last = NULL;
// 输入内存
cout << "请输入现有内存的大小:(起始地址从0开始)" << endl;
int size;
cin >> size;
int MemSize = pow(2, size);
cout << "输入的内存的大小为: " << MemSize << "B" << endl;
// 进行分区，输入分区的块数，以及内存的大小， 2指数倍数
int num;
cout << "输入内存的块数: " << endl;
cin >> num;
for (int i = 0; i < num; ++i) {
cout << "第" << i << "号" << "内存, 输入内存的大小, 2的指数" << endl;
int n; // 输入占用内存的大小， 2的指数
cin >> n;
// n 的判断 n 的范围在 0 - MemSize之间
int size = pow(2, n);
while (size >= MemSize) {
cout << "输入的n太大, 重新输入!" << endl;
cin >> n;
size = pow(2, n);
}
cout << "第" << i << "号,内存块的大小为: " << size << "B" << endl << endl;
MemUsedTable* mp = new MemUsedTable();
mp->ID = i;
mp->size = size;
mp->state = 0; // 0表示未占用
mp->address = address;
// 调整全局的信息
address += size;
MemSize -= size;
// 链接到链表后
if (memReady == NULL) {
// 没有表格的时候
memReady = mp;
last = memReady;
}
else {
// 加入链表中
last->next = mp;
last = mp;
}
}
dispMemInfo(memReady);
return memReady;
}
MemUsedTable* sortMem(MemUsedTable* memReady, int flag) {
MemUsedTable* p1 = memReady;
if (p1 == NULL) {
cout << "链表为空" << endl;
return NULL;
}
if (p1->next == NULL) {
cout << "只有一个节点不用排序" << endl;
return NULL;
}
if (flag == 1) {
// 最佳适应算法
while (p1->next != NULL) {
// 指向下一个
MemUsedTable* p2 = p1->next;
while (p2 != NULL) {
if (p1->size > p2->size) {
// 交换指针
// MemUsedTable tmp = *p1;
// *p1 = *p2;
// *p2 = temp;
//
// tmp.next = p1;
// p1->next = p2->next;
// p2->next = tmp.next;
int ID = p1->ID;
int size = p1->size;
int address = p1->address;
int workID = p1->workID;
int state = p1->state;
p1->ID = p2->ID;
p1->size = p2->size;
p1->address = p2->address;
p1->workID = p2->workID;
p1->state = p2->state;
p2->ID = ID;
p2->size = size;
p2->address = address;
p2->workID = workID;
p2->state = state;
}
p2 = p2->next;
}
p1 = p1->next;
}
return memReady;
}
else if (flag == 2) {
// 最坏适应算法
while (p1->next != NULL) {
// 指向下一个
MemUsedTable* p2 = p1->next;
while (p2 != NULL) {
if (p1->size < p2->size) {
// 交换指针
// MemUsedTable tmp = *p1;
// *p1 = *p2;
// *p2 = temp;
//
// tmp.next = p1;
// p1->next = p2->next;
// p2->next = tmp.next;
int ID = p1->ID;
int size = p1->size;
int address = p1->address;
int workID = p1->workID;
int state = p1->state;
p1->ID = p2->ID;
p1->size = p2->size;
p1->address = p2->address;
p1->workID = p2->workID;
p1->state = p2->state;
p2->ID = ID;
p2->size = size;
p2->address = address;
p2->workID = workID;
p2->state = state;
}
p2 = p2->next;
}
p1 = p1->next;
}
return memReady;
}
else if (flag == 3) {
// 首次使用算法， 不排序
return memReady;
}
}
void dispPCBInfo(PCB*& pcbQ) {
PCB* p = pcbQ;
cout << endl;
while (p != NULL) {
cout << "PCB->ID: " << p->ID << ", PCB运行状态: " << p->runState << ", PCB大小： " <<
p->size << "B, " << ", PCB运行地址: " << p->address << endl;
p = p->next;
}
cout << endl;
}
PCB* inputPCB(PCB* pcbQ) {
/**
* 作业不排序
*/
cout << "输入作业的个数" << endl;
int num;
PCB* last = NULL;
cin >> num;
for (int i = 1; i <= num; ++i) {
PCB* np = new PCB();
np->ID = i;
cout << "输入PCB的大小" << endl;
int pcbSize;
cin >> pcbSize;
np->size = pcbSize;
if (pcbQ == NULL) {
pcbQ = np;
last = pcbQ;
}
else {
last->next = np;
last = np;
}
}
return pcbQ;
}
MemUsedTable* allocateMem(MemUsedTable*& memReady, int label, int size) {
/**
* 分配内存给作业 label 为作业号， size为分配内存的大小
*/
MemUsedTable* p = memReady;
while (p != NULL) {
if (p->size >= size) {
if (p->state != 1) {
p->state = 1;
p->workID = label;
return p;
}
}
p = p->next;
}
return NULL;
}
MemUsedTable* allocateMems(MemUsedTable*& memReady, PCB*& pcbQ) {
/**
* 1. 循环作业进行分配
* 2. 修改信息
*/
PCB* p = pcbQ;
while (p != NULL) {
if (p->runState != 1) {
MemUsedTable* allocated_mem = allocateMem(memReady, p->ID, p->size);
if (allocated_mem != NULL) {
cout << "分配成功: PCB_ID: " << p->ID << " 分配的内存块ID: " << allocated_mem->ID << endl;
p->runState = 1;
p->address = allocated_mem->address;
}
}
p = p->next;
}
return memReady;
}
bool checkMemEmpty(MemUsedTable* memReady) {
MemUsedTable* p = memReady;
bool flag = true; // 假设内存已经全部释放
while (p != NULL) {
if (p->state == 1) {
return false;
}
p = p->next;
}
return flag;
}
bool checkPCBEmpty(PCB* pcbQ) {
PCB* p = pcbQ;
while (p != NULL) {
if (p->runState == 0) {
return false;
}
p = p->next;
}
return true;
}
MemUsedTable* recoverMem(MemUsedTable* memReady, PCB* pcbQ) {
/**
* 收回固定分配的内存
* 输入要收回分区的个数，输入要收回分区的ID号，
* 根据ID号释放内存， 更改内存块的状态
*
*/
int num;
int memLength = getMemLength(memReady);
while (1) {
cout << endl << endl;
dispMemInfo(memReady);
cout << "输入要释放的内存块号" << endl;
int memBlock;
cin >> memBlock;
if (checkPCBEmpty(pcbQ) && checkMemEmpty(memReady)) {
cout << "作业已经调度完, 并且内存以释放完" << endl;
dispPCBInfo(pcbQ);
break;
}
MemUsedTable* p = memReady;
while (p != NULL) {
if (p->ID == memBlock) {
if (p->state == 1) {
p->state = 0; // 释放内存
p->workID = 0; // 修改被占用的工作块
cout << "内存释放成功" << endl;
allocateMems(memReady, pcbQ);
dispMemInfo(memReady);
dispPCBInfo(pcbQ);
}
else if (p->state == 0) {
cout << "此内存块为空闲块" << endl;
}
}
p = p->next;
}
if (checkPCBEmpty(pcbQ) && checkMemEmpty(memReady)) {
cout << "作业已经调度完, 并且内存以释放完" << endl;
dispPCBInfo(pcbQ);
break;
}
char flag;
cout << "是否继续释放内存 y/Y ->Yes, n/N ->No" << endl;
cin >> flag;
while (!(flag == 'Y' || flag == 'y' || flag == 'N' || flag == 'n')) {
cout << "输入 y/Y ->Yes, n/N ->No" << endl;
cin >> flag;
}
if (flag == 'y' || flag == 'Y') {
continue;
}
else if (flag == 'N' || flag == 'n') {
break;
}
}
cout << endl << "内存状态： " << endl;
dispMemInfo(memReady);
return memReady;
}
int main() {
cout << "<<<<<<<<<<<<<<<<<<<<<< 固定分区， 最佳适应算法算法 >>>>>>>>>>>>>>>>>>>>>>>>>>>>" << endl;
MemUsedTable* memReady = NULL; // 内存链表
MemUsedTable* mem = inputMem(memReady);
MemUsedTable* sortmem = sortMem(mem, 1);
PCB* pcbQ = NULL;
PCB* input_pcb = inputPCB(pcbQ);
dispPCBInfo(input_pcb);
allocateMems(sortmem, input_pcb);
dispPCBInfo(input_pcb);
recoverMem(sortmem, input_pcb);
system("pause");
return 0;
}
/**
测试 Case : 1
10
4
5
6
5
4
6
20
10
20
20
30
20
*/
二、可变分区分配方式
二、1 可变分区-最佳适应算法
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cmath>
using namespace std;
class MemUsedTable { // 内存
public:
int ID; // 空闲分区的ID
int size; // 空闲分区的大小
int address; // 空闲分区的开始地址
int state; // 分区的状态 0 未分配 1 分配
int workID;
MemUsedTable* pre; // 前一个指针
MemUsedTable* next; // 下一个指针
MemUsedTable() {
this->ID = 0;
this->size = 0;
this->address = 0;
this->state = 0; // 未使用
this->workID = 0;
this->next = NULL;
this->pre = NULL;
}
};
class PCB {
// 进程的数据结构
public:
int ID; // PCB的ID
int size; // PCB需要的内存大小
int address; // PCB的开始地址
int runState; // 运行状态
PCB* next;
PCB() {
this->ID = 0;
this->size = 0;
this->address = -1;
this->runState = 0; // 0 未运行 1 运行
this->next = NULL; // 指向下一个
}
};
void dispMemInfo(MemUsedTable* memReady); // 展示内存块的信息
void dispPCBInfo(PCB*& pcbQ); // 展示PCB进程的信息
int getMemLength(MemUsedTable* memReady); // 获取内存块的长度，可用于内存划分
MemUsedTable* inputMem(MemUsedTable* memReady); // 输入内存的大小
PCB* inputPCB(PCB* pcbQ); // 输入进程PCB的信息，PCB的大小
MemUsedTable* sortMem(MemUsedTable* memReady, int flag); // 对内存按照要求排序
// 1 最佳适应 2 最坏适应， 3 首次适应
bool checkMemEmpty(MemUsedTable* memReady); // 检测内存块是否都未被使用
bool checkPCBEmpty(PCB* pcbQ); // 检测内存都已经得到分配，并且运行
MemUsedTable* allocateMem(MemUsedTable*& memReady, int label, int size);
// 分配单个进程PCB
MemUsedTable* allocateMems(MemUsedTable*& memReady, PCB*& pcbQ); // 对PCB链表进行内存分配
MemUsedTable* recoverMem(MemUsedTable* memReady, PCB* pcbQ); // 回收内存
///====================================
void dispMemInfo(MemUsedTable* memReady) {
MemUsedTable* p = memReady;
cout << endl;
while (p != NULL) {
cout << "Mem->ID: " << p->ID << ", 大小: " << p->size << "B, 分配状态： " << p->state << ", 开始地址："
<< p->address << "B";
if (p->workID != 0) {
cout << ", 已分配的作业ID: " << p->workID << endl;
}
else {
cout << ", 未分配任何作业" << endl;
}
p = p->next;
}
cout << endl;
}
int getMemLength(MemUsedTable* memReady) {
int cnt = 0;
MemUsedTable* p1 = memReady; // NULL 指针
// 链表为空的时候
if (p1 == NULL) {
cout << "链表为空" << endl;
return 0;
}
while (p1 != NULL) {
cnt++;
p1 = p1->next;
}
return cnt;
}
// 输入内存大小的个数
MemUsedTable* inputMem(MemUsedTable* memReady) {
// 输入内存
cout << "请输入现有内存的大小:(起始地址从0开始)" << endl;
int size;
cin >> size;
int MemSize = pow(2, size);
// 建立主内存块
MemUsedTable* mp = new MemUsedTable();
mp->ID = 0;
mp->size = MemSize;
mp->state = 0; // 0表示未占用
mp->address = 0;
memReady = mp;
cout << "输入的内存的大小为: " << MemSize << "B" << endl;
// dispMemInfo(memReady);
return memReady;
}
void dispPCBInfo(PCB*& pcbQ) {
PCB* p = pcbQ;
cout << endl;
while (p != NULL) {
cout << "PCB->ID: " << p->ID << ", PCB运行状态: " << p->runState << ", PCB大小： " <<
p->size << "B, " << ", PCB运行地址: " << p->address << endl;
p = p->next;
}
cout << endl;
}
PCB* inputPCB(PCB* pcbQ) {
/**
* 作业不排序
*/
cout << "输入作业的个数" << endl;
int num;
PCB* last = NULL;
cin >> num;
for (int i = 1; i <= num; ++i) {
PCB* np = new PCB();
np->ID = i;
cout << "输入PCB的大小" << endl;
int pcbSize;
cin >> pcbSize;
np->size = pcbSize;
if (pcbQ == NULL) {
pcbQ = np;
last = pcbQ;
}
else {
last->next = np;
last = np;
}
}
return pcbQ;
}
MemUsedTable* sortMem(MemUsedTable* memReady, int flag) {
MemUsedTable* p1 = memReady;
if (p1 == NULL) {
cout << "链表为空" << endl;
return NULL;
}
if (p1->next == NULL) {
cout << "只有一个节点不用排序" << endl;
return memReady;
}
if (flag == 1) {
// 最佳适应算法
while (p1->next != NULL) {
// 指向下一个
MemUsedTable* p2 = p1->next;
while (p2 != NULL) {
if (p1->size > p2->size) {
// 交换指针
// MemUsedTable tmp = *p1;
// *p1 = *p2;
// *p2 = temp;
//
// tmp.next = p1;
// p1->next = p2->next;
// p2->next = tmp.next;
int ID = p1->ID;
int size = p1->size;
int address = p1->address;
int workID = p1->workID;
int state = p1->state;
p1->ID = p2->ID;
p1->size = p2->size;
p1->address = p2->address;
p1->workID = p2->workID;
p1->state = p2->state;
p2->ID = ID;
p2->size = size;
p2->address = address;
p2->workID = workID;
p2->state = state;
}
p2 = p2->next;
}
p1 = p1->next;
}
return memReady;
}
else if (flag == 2) {
// 最坏适应算法
while (p1->next != NULL) {
// 指向下一个
MemUsedTable* p2 = p1->next;
while (p2 != NULL) {
if (p1->size < p2->size) {
// 交换指针
// MemUsedTable tmp = *p1;
// *p1 = *p2;
// *p2 = temp;
//
// tmp.next = p1;
// p1->next = p2->next;
// p2->next = tmp.next;
int ID = p1->ID;
int size = p1->size;
int address = p1->address;
int workID = p1->workID;
int state = p1->state;
p1->ID = p2->ID;
p1->size = p2->size;
p1->address = p2->address;
p1->workID = p2->workID;
p1->state = p2->state;
p2->ID = ID;
p2->size = size;
p2->address = address;
p2->workID = workID;
p2->state = state;
}
p2 = p2->next;
}
p1 = p1->next;
}
return memReady;
}
else if (flag == 3) {
// 首次使用算法， 不排序
return memReady;
}
}
bool checkMemEmpty(MemUsedTable* memReady) {
MemUsedTable* p = memReady;
bool flag = true; // 假设内存已经全部释放
while (p != NULL) {
if (p->state == 1) {
return false;
}
p = p->next;
}
return flag;
}
bool checkPCBEmpty(PCB* pcbQ) {
PCB* p = pcbQ;
while (p != NULL) {
if (p->runState == 0) {
return false;
}
p = p->next;
}
return true;
}
MemUsedTable* allocateMem(MemUsedTable*& memReady, int label, int size) {
/**
* 分配内存给作业 label 为作业号， size为分配内存的大小
*/
MemUsedTable* p = memReady;
while (p != NULL) {
if (p->size >= size) {
// 未被占用
if (p->state != 1) {
p->state = 1;
p->workID = label;
// 割掉一个分区
if (p->size > size) {
MemUsedTable* mp = new MemUsedTable();
int ID = getMemLength(memReady);
int splitSize = p->size - size;
int address = p->address + size;
// 修改分区信息
mp->ID = ID;
mp->size = splitSize;
mp->address = address;
mp->state = 0;
mp->workID = 0;
// 添加到链表中
if (p->next != NULL) {
MemUsedTable* nextP = p->next;
mp->pre = p;
p->next = mp;
nextP->pre = mp;
mp->next = nextP;
}
else {
// 只有一个分区的时候与
p->next = mp;
mp->pre = p;
}
}
// 修改p的状态
p->size = size;
return p;
}
}
p = p->next;
}
return NULL;
}
MemUsedTable* allocateMems(MemUsedTable*& memReady, PCB*& pcbQ) {
PCB* p = pcbQ;
while (p != NULL) {
if (p->runState != 1) {
MemUsedTable* allocated_mem = allocateMem(memReady, p->ID, p->size);
if (allocated_mem != NULL) {
cout << "分配成功: PCB_ID: " << p->ID << " 分配的内存块ID: " << allocated_mem->ID << endl;
p->runState = 1;
p->address = allocated_mem->address;
}
}
p = p->next;
}
return memReady;
}
MemUsedTable* recoverMem(MemUsedTable* memReady, PCB* pcbQ) {
/**
* 动态回收内存
* 输入要释放内存的个数
* 动态回收的情形
* 1. 上一个是空闲分区， 与上一个合并，开始的地址为上一个空闲分区
* 2. 下一个是空闲分区， 与下一个合并，开始的地址为这个内存区的地址
* 3. 上一个与下一个都是空闲分区， 与上下合并，内存分区减少一个， 开始第一位号小的那个
* 4. 没有相邻的时候， 放到队列中
*/
while (1) {
int memLength = getMemLength(memReady);
cout << endl << endl;
dispMemInfo(memReady);
// 检查内存为空
if (checkPCBEmpty(pcbQ) && checkMemEmpty(memReady)) {
cout << "作业已经调度完, 并且内存以释放完" << endl;
dispPCBInfo(pcbQ);
break;
}
cout << "输入要释放的内存块号" << endl;
int memBlock;
cin >> memBlock;
while (memBlock >= memLength) {
cout << "内存块号越界!, 请重新输入" << endl;
cin >> memBlock;
}
MemUsedTable* p = memReady;
while (p != NULL) {
if (p->ID == memBlock) {
if (p->state == 1) {
// 判断前后分区
if (p->pre != NULL && p->next != NULL) {
if (p->pre->state == 0 && p->next->state == 0) {
// 前后分区空闲
cout << endl << "前为空，后为空" << endl << endl;
// 修改信息
p->pre->size += p->size + p->next->size;
// 确定地址
int addressPre = p->pre->address;
int addressCurrent = p->address;
int addressNext = p->next->address;
int min = addressPre > addressCurrent ? addressCurrent : addressPre;
min = min < addressNext ? min : addressNext;
p->pre->address = min;
// 指针移动 三个分区合并
p->pre->next = p->next->next;
if (p->next->next != NULL) {
p->next->next->pre = p->pre;
}
// delete p->next;
// delete p;
}
else if (p->pre->state == 0 && p->next->state == 1) {
// 前一个空闲
cout << endl << "前为空，后不为空" << endl << endl;
p->pre->size += p->size;
p->pre->address = p->size > p->pre->address ? p->pre->size : p->address;
// 修改指针
p->pre->next = p->next;
p->next->pre = p->pre;
// delete p;
}
else if (p->pre->state == 1 && p->next->state == 0) {
cout << endl << "前不为空，后为空" << endl << endl;
// 修改状态
p->size += p->next->size;
p->address = p->address < p->next->address ? p->address : p->next->address;
p->state = 0;
p->workID = 0;
// 从后指向前， 在从前指向后
// 修改指针
if (p->next->next != NULL) {
p->next->next->pre = p;
// p->next->pre = NULL;
p->next = p->next->next;
// p->next->next = NULL;
}
// 后面的内存只有一个的时候
if (p->next->next == NULL) {
p->next = NULL;
}
// delete p->next;
}
else if (p->pre->state == 1 && p->next->state == 1) {
cout << endl << "前不为空，后不为空" << endl << endl;
p->state = 0;
p->workID = 0;
}
}
else if (p->pre == NULL && p->next != NULL) {
if (p->next->state == 0) {
cout << endl << "前为NULL, 后为空" << endl << endl;
// 修改状态
p->size += p->next->size;
p->address = p->address < p->next->address ? p->address : p->next->address;
p->state = 0;
p->workID = 0;
// 修改指针
if (p->next->next != NULL) {
p->next->next->pre = p;
// p->next->pre = NULL;
p->next = p->next->next;
// p->next->next = NULL;
}
// MemUsedTable* tmp = p->next;
// 后面的内存只有一个的时候
if (p->next->next == NULL) {
p->next = NULL;
}
// delete tmp;
}
else {
cout << endl << "前为NULL, 后不为空" << endl << endl;
p->state = 0;
p->workID = 0;
}
}
else if (p->next == NULL && p->pre != NULL) {
if (p->pre->state == 0) {
cout << endl << "前为空，后为NULL" << endl << endl;
p->pre->size += p->size;
p->pre->address = p->size > p->pre->address ? p->pre->size : p->address;
// 移动指针
p->pre->next = p->next; // 为NULL
// delete p;
}
else {
cout << endl << "前不为空，后为NULL" << endl << endl;
p->state = 0;
p->workID = 0;
}
}
cout << "内存释放成功" << endl;
// 释放完之后 再次分配
MemUsedTable* sortedMem = sortMem(memReady, 1);
dispMemInfo(sortedMem);
dispPCBInfo(pcbQ);
allocateMems(sortedMem, pcbQ);
dispMemInfo(sortedMem);
dispPCBInfo(pcbQ);
}
else if (p->state == 0) {
cout << "此内存块为空闲块" << endl;
}
break;
}
p = p->next;
}
// 检查内存为空
if (checkPCBEmpty(pcbQ) && checkMemEmpty(memReady)) {
cout << "作业已经调度完, 并且内存以释放完" << endl;
dispPCBInfo(pcbQ);
break;
}
// 合法的输入
char flag;
cout << "是否继续释放内存 y/Y ->Yes, n/N ->No" << endl;
cin >> flag;
while (!(flag == 'Y' || flag == 'y' || flag == 'N' || flag == 'n')) {
cout << "输入 y/Y ->Yes, n/N ->No" << endl;
cin >> flag;
}
if (flag == 'y' || flag == 'Y') {
continue;
}
else if (flag == 'N' || flag == 'n') {
break;
}
}
// 最后展示内存的状态
cout << endl << "内存状态： " << endl;
dispMemInfo(memReady);
return memReady;
}
int main() {
MemUsedTable* memReady = NULL;
MemUsedTable* mem = inputMem(memReady);
dispMemInfo(mem);
PCB* pcbQ = NULL;
pcbQ = inputPCB(pcbQ);
dispPCBInfo(pcbQ);
MemUsedTable* allocate_mem = allocateMems(mem, pcbQ);
dispMemInfo(allocate_mem);
dispPCBInfo(pcbQ);
recoverMem(allocate_mem, pcbQ);
return 0;
}
/**
测试 Case1 :
7
3
50
60
30
*/
932
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
