操作系统课内实践：内存管理

Posted 2022-01-27 拾年之璐

注：本文记录　WHUT-计算机学院-操作系统 课程　课内实践：内存管理

纸上得来终觉浅，觉知此事需躬行！

1、实验内容：

•实验预备：掌握内存管理的相关内容，对内存的分配与回收有深入的理解。

•实验内容：模拟实现内存管理机制

•具体要求：

• • 
    
• –任选一种计算机高级语言编程实现
• –选择一种内存管理方案：动态分区式、请求页式、段式、段页式等
• –能够输入给定的内存大小，进程的个数，每个进程所需内存空间的大小等
• –能够选择分配 / 回收操作
• –能够显示进程在内存的存储地址、大小等
• –显示每次完成内存分配或回收后内存空间的使用情况
  • 
    

2、运行结果：

首先输入基本信息：

然后对其中某个分区进行释放操作，假设选择3号区，结果如下：

继续对上面分区表的2号区释放内存操作，按照程序要求，释放的2号要与空闲分区3号合并，合并后空闲长度应为二者之和，即22，结果如下图：

下面进行添加进程操作，假设添加如下的进程号、进程长度：

A  15  ，  B  1  ，C  10

然后采用最先适应算法分配分区，运行结果如下图：

然后将上图中的1号区、2号区的内存释放，分区表信息如下：

这时，添加4个进程：

D 6；E 18；F 25；G 4

本次采用最佳适应算法，运行结果如下图：

这时，将：0、3、6、7四个分区的进程释放，分区边信息如下：

此时，请求表中还有进程G需要请求4个长度的内存信息；

再次基础上，增加进程：  H 25  ;  I 3  ;  K 18

增加之后，请求表中的信息应该是下图这样的：

本次采用最坏适应算法，运行结果如下：

3、实验源码：

本次实践难度不大，建议自行完成！

下面代码是使用C++、链表实现！

#include <iostream>
#include <string>
using namespace std;

int processNum = 0;//进程个数
int totalRAM = 0; //给定的内存

//分区表
int partitionNum=0; //分区个数
struct RAM
  int processNo;      //进程编号
  int start=0;      //首址
  int length=0;     //长度大小
  int end=0;        //结束
  int status=0; //分区状态
;
RAM ram[100];//下标i表示区号

//可用表
int freeNum=0;//空闲分区个数
struct FREERAM
  int freePartNo=-1;  //空闲区号
  int freeLength=-1;  //空闲区长度
  int freeStart=-1; //空闲区起址
;
FREERAM freePart[100];//空闲分区表，可用表

//请求表
int reqNum=0;//请求进程个数
struct REQUEST
  string reqProcessNo;  //请求进程名
  int reqLength;      //请求进程长度
  int reqed=0;      //请求进程状态（即是否分配处理）
;
REQUEST request[100];

//分区表
struct RamNode 
  int partNo;       //每个节点都是一个分区，有一个区号，默认从0开始
  string processNo;   //如果被占用，则显示被占用的进程编号
  int start = 0;      //分区首址
  int length = 0;     //分区长度大小
  int end = 0;      //分区尾址
  int status = 0;     //分区状态
  RamNode *next;      //下一个分区
;
typedef RamNode *ramNode;
ramNode head = NULL, tail = NULL, p, q;

//输出分区表
void printDongtai();

//初始化
void InitDongtai() 
  cout<< "*******初始化******" <<endl;
  cout << "　请输入内存总大小：";
  cin >> totalRAM;
  cout << "　请输入进程个数：";
  cin >> processNum;
  cout << "　请输入进程 1到" << processNum << " 所需要的内存空间：";
  for (int i = 0; i < processNum; i++) 
    int tempRam = 0;
    cin >> tempRam;

    //看一下能不能放下第 i 个进程
    if (i==0 && tempRam < totalRAM) 
      p = new RamNode;
      p->partNo = i;            //节点区号
      p->processNo = to_string(i + 1);  //占用进行号
      p->start = 0;           //起址
      p->length = tempRam;        //长度
      p->end = p->start + p->length - 1;  //终址
      p->status = 1;            //状态
      p->next = NULL;

      partitionNum++; 

      if (head == NULL) 
        head = p; q = p;
      
      else 
        q->next = p;
        q = p;
      
    
    else if(tempRam+q->end<totalRAM)
      p = new RamNode;
      p->partNo = i;
      p->processNo =to_string(i + 1);
      p->start = q->end + 1;
      p->length = tempRam;
      p->end = p->start + p->length - 1;
      p->status = 1;
      p->next = NULL;

      partitionNum++;

      if (head == NULL) 
        head = p;
        q = p;
      
      else 
        q->next = p;
        q = p;
      
    
    //放不下了o(╥﹏╥)o进入请求队列吧，等会儿写
    else 
      request[reqNum].reqProcessNo = to_string(i + 1);
      request[reqNum].reqLength = tempRam;
      reqNum++;
    
  
  //如果分配总内存有剩余，最后剩余空间也是一个分区
  if (q->end < totalRAM - 1) 
    p = new RamNode;
    p->partNo = q->partNo + 1;
    p->start = q->end + 1;
    p->end = totalRAM - 1;
    p->status = 0;
    p->next = NULL;
    p->length = totalRAM - p->start ;
    if (head == NULL) 
      head = p;
      q = p;
    
    else 
      q->next = p;
      q = p;
    

  
  //尾指针，先放着，应该有用，(⊙o⊙)…最终没用到
  tail = p;


//初始化分区的区号，每次当改变链表结构的时候，都要运行一次。
void InitpartNo() 
  int i = 0;
  for (p = head; p != NULL; p=p->next) 
    p->partNo = i;
    i++;
  


//给出第i个请求任务的插入点p，实现链表插入
void insert(ramNode &p,int i) 
  p->processNo = request[i].reqProcessNo;
  p->status = 1;
  //如果请求长度等于空闲长度，最好不过了
  if (request[i].reqLength == p->length) 
  //请求＜空闲，需要分割了o(╥﹏╥)o
  else 
    q = new RamNode;
    q->end = p->end;
    p->end = p->start + request[i].reqLength - 1;
    p->length = request[i].reqLength;

    q->partNo = p->partNo + 1;
    q->start = p->end + 1;
    q->length = q->end - q->start + 1;
    q->status = 0;

    q->next = p->next;
    p->next = q;
  
  //修改请求表请求进程状态为 已分配
  request[i].reqed = 1;


/*最先适应算法*/
void zuixianSuanfa(int &i) 
  for (i; i < reqNum; i++) 
    //按空闲分区首地址递增
    for (p = head; p != NULL; p = p->next) 
      //如果当前请求进程请求长度小于最先找到的空闲分区长度，则进行分配
      if (request[i].reqLength <= p->length && p->status == 0) 
        insert(p, i);
        break;
      
    
    //第1个请求进程，遍历完链表，仍然找不到内存去，直接返回。
    if (i == 0 && p == NULL) 
      return;
    
    else if (p == NULL) 
      return;
    
  


/*更新请求表信息，已经分配的进程取出*/
void refeshReq(int i) 
  int temp = reqNum;
  reqNum = reqNum - i;
  for (int j = 0; j < temp; i++, j++) 
    request[j].reqProcessNo = request[i].reqProcessNo;
    request[j].reqLength = request[i].reqLength;
    request[j].reqed = request[i].reqed;
  



/*最先适应算法*/
void zuixian() 
  cout<<"当前请求表信息如下："<<endl;
  cout<<"顺序\\t进程名\\t请求长度"<<endl;
  for (int i = 0; i < reqNum; i++) 
    cout << i+1 <<"\\t" << request[i].reqProcessNo << "\\t" << request[i].reqLength << endl;
  
  int i=0;
  zuixianSuanfa(i);
  //未做任何分配，直接返回
  if (i == 0) 
    cout << "该策略下空间不足，未做任何分配！" << endl;
    return;
  
  //全部分配完毕
  else if (i == reqNum) 
    cout << "请求表中的进程全部分配完毕！" << endl;
  
  //只完成部分分配
  else 
    cout << "请求表中的进程部分分配完毕！剩余未分配进程如下：" << endl;
    cout << "\\t进程名\\t请求长度" << endl;
    for (int i = 0; i < reqNum; i++) 
      if (request[i].reqed == 0) 
        cout << "\\t" << request[i].reqProcessNo << "\\t" << request[i].reqLength << endl;
      
    
  
  cout << "分配后内存使用情况如下：" << endl;
  printDongtai();
  InitpartNo(); 
  //对请求表数据更新（删除）
  refeshReq(i);
  return;


/*交换a和b的值*/
void change(int &a,int &b)
  int temp;
  temp = a;
  a = b;
  b = temp;


/*找出所有的空闲分区，并放在空闲分区表中*/
void findFreePart() 
  InitpartNo();//初始化一下
  //初始化空闲表
  for (int i = 0; i <= freeNum; i++) 
    freePart[i].freePartNo = -1;
    freePart[i].freeStart = -1;
    freePart[i].freeLength = -1;
  
  freeNum = 0;
  //先揪出那些空闲分区
  for (p = head; p != NULL; p = p->next) 
    //空闲状态分区，进入可用表
    if (p->status == 0) 
      freePart[freeNum].freePartNo = p->partNo;
      freePart[freeNum].freeStart = p->start;
      freePart[freeNum].freeLength = p->length;
      freeNum++;
    
  


/*对找出所有空闲区进行排序：递增*/
void InitZuijia() 
  findFreePart();
  //按空闲分区大小递增排序
  for (int i = 0; i < freeNum - 1; i++) 
    for (int j = 0; j < freeNum - i - 1; j++) 
      if (freePart[j].freeLength > freePart[j + 1].freeLength) 
        change(freePart[j].freePartNo, freePart[j + 1].freePartNo);
        change(freePart[j].freeStart, freePart[j + 1].freeStart);
        change(freePart[j].freeLength, freePart[j + 1].freeLength);
      
    
  


/*找出当前i号请求进行能放得下的区号，并返回区号*/
int findInsertPartNo(int i) 
  //找到当前i能放得下的区号
  int partNo = -1;
  for (int j = 0; j < freeNum; j++) 
    if (request[i].reqLength <= freePart[j].freeLength) 
      partNo = freePart[j].freePartNo;
      //cout << "找到区号：" << partNo << endl;
      return partNo;
    
  
  return -1;


/*最佳使用算法*/
void zuijia() 
  cout << "当前请求表信息如下：" << endl;
  cout << "顺序\\t进程名\\t请求长度" << endl;
  for (int i = 0; i < reqNum; i++) 
    cout << i + 1 << "\\t" << request[i].reqProcessNo << "\\t" << request[i].reqLength << endl;
  

  InitZuijia();
  int i=0;
  for (i; i < reqNum; i++) 

    //找到当前i能放得下的区号
    int partNo = -1;
    partNo = findInsertPartNo(i);

    if (i==0 && partNo == -1) 
      cout << "该策略下空间不足，未做任何分配！" << endl;
      return;
    
    else if (partNo == -1) 
      cout << "仅分配部分进程！剩余未分配进程如下：" << endl;
      cout << "\\t进程名\\t请求长度" << endl;
      for (int j = 0; j < reqNum; j++) 
        if (request[j].reqed == 0) 
          cout << "\\t" << request[j].reqProcessNo << "\\t" << request[j].reqLength << endl;
        
      
      break;
    

    //寻找插入点并放入
    for (p = head; p != NULL; p = p->next) 
      if (p->partNo == partNo) 
        //cout << "找到对应的插入点" << endl;
        insert(p,i);
      
    
    //初始化链表、空闲表
    InitZuijia();
  
  if (i == reqNum)
    cout << "请求表中的进程全部分配完毕！" << endl;
  printDongtai();

  //对请求表数据更新（删除）
  refeshReq(i);


//最坏适应算法

/*对找出所有空闲区安装递减排序*/
void InitZuihuai() 
  findFreePart();
  //按空闲分区大小递减排序
  for (int i = 0; i < freeNum - 1; i++) 
    for (int j = 0; j < freeNum - i - 1; j++) 
      if (freePart[j].freeLength < freePart[j + 1].freeLength) 
        change(freePart[j].freePartNo, freePart[j + 1].freePartNo);
        change(freePart[j].freeStart, freePart[j + 1].freeStart);
        change(freePart[j].freeLength, freePart[j + 1].freeLength);
      
    
  


/*最坏适应算法*/
void zuihuai() 
  cout << "当前请求表信息如下：" << endl;
  cout << "顺序\\t进程名\\t请求长度" << endl;
  for (int i = 0; i < reqNum; i++) 
    cout << i + 1 << "\\t" << request[i].reqProcessNo << "\\t" << request[i].reqLength << endl;
  

  InitZuihuai();
  int i = 0;
  for (i; i < reqNum; i++) 

    //找到当前i能放得下的区号
    int partNo = -1;
    partNo = findInsertPartNo(i);

    if (i == 0 && partNo == -1) 
      cout << "该策略下空间不足，未做任何分配！" << endl;
      return;
    
    else if (partNo == -1) 
      cout << "仅分配部分进程！剩余未分配进程如下：" << endl;
      cout << "\\t进程名\\t请求长度" << endl;
      for (int j = 0; j < reqNum; j++) 
        if (request[j].reqed == 0) 
          cout << "\\t" << request[j].reqProcessNo << "\\t" << request[j].reqLength << endl;
        
      
      break;
    

    //寻找插入点并放入
    for (p = head; p != NULL; p = p->next) 
      if (p->partNo == partNo) 
        insert(p, i);
      
    
    //初始化链表、空闲表
    InitZuihuai();
  
  if (i == reqNum)
    cout << "请求表中的进程全部分配完毕！" << endl;
  printDongtai();

  //对请求表数据更新（删除）
  refeshReq(i);


//分配一个分区
void feipeiFenqu() 
  if (reqNum == 0) 
    cout << "当前没有未分配空间的进程！" << endl << endl;
    return;
  
  cout << "　　1、最先适应算法" << endl;
  cout << "　　2、最佳适应算法" << endl;
  cout << "　　3、最坏适应算法" << endl;
  cout << "　　请选择分配策略：";
  int choose;
  cin >> choose;


  switch (choose) 
  case 1:
    zuixian();
    break;

  case 2:
    zuijia();
    break;

  case 3:
    zuihuai();
    break;

  default:
    break;
  


void printDongtai() 
  cout << "区号\\t首址\\t长度\\t尾址\\t状态\\t占用进程编号" << endl;
  int i = 0;
  for (p = head; p != NULL; p = p->next) 
    cout << " " << p->partNo << "\\t" << p->start << "\\t" << p->length << "\\t" << p->end << "\\t";
    if (p->status == 1)
      cout << "占用\\t" << p->processNo << endl;
    else
      cout << "空闲" << endl;
    i++;
  
  cout << endl;


//释放一个分区
void shifangFenqu() 
  cout << "请输入欲释放内存的区号：";
  int freePart;
  cin >> freePart;
  p = head;
  for (int i = 0; i <= freePart; i++) 
    if(i!=freePart)
      p = p->next;
  
  if (p->status == 1) 
    p->status = 0;
    p->processNo = "";
    cout << freePart<<"号分区释放成功！" << endl;

    //分区合并·碎片整理
    for (p = head; p != NULL; ) 
      if (p->status == 0  && p->next!=NULL) 
        if (p->next->status == 0) 
          p->end = p->next->end;
          p->length = p->length + p->next->length;

          q = p->next;
          p->next = q->next;
          delete q;
        
        else 
          p = p->next;
        
      
      else 
        p = p->next;
      
    //碎片整理结束

    InitpartNo();
  
  else 
    cout << "当前分区空闲，无需释放！" << endl;
  
  printDongtai();
  cout << endl;


//添加进程到请求队列中
void addProcess() 
  cout << "请输入进程编号和请求长度：";
  //如果进程编号不存在，则继续执行
  if (1) 
    cin >> request[reqNum].reqProcessNo >> request[reqNum].reqLength;
    reqNum++;
    cout<<"添加成功！"<<endl;
  
  cout << endl;


int main()
  InitDongtai();
  while (1) 
    cout << "********菜  单********" << endl;
    cout << "　1、显示分区状态" << endl;
    cout << "　2、释放分区" << endl;
    cout << "　3、分配分区" << endl;
    cout << "　4、添加进程（作业）" << endl;

    cout << "　请输入选项：";
    int choice;
    cin >> choice;

    switch (choice)
    case 1: 
      printDongtai();
      break;

    case 2:
      shifangFenqu();
      break;

    case 3:
      feipeiFenqu();
      break;

    case 4:
      addProcess();
      break;

    default:
      break;
    
  
  return 0;