操作系统原理动态分区式存贮区管理


一、题目要求

设计一个动态分区式存贮区管理程序,要求支持不同的放置策略。如首次、最佳、最坏。
说明:
(1) 分区描述器 rd 如下:
flag size next
要求空闲区队列按链表组织。
主存大小假设为 maxsize(单位为节=rd 的大小)。
(2) 主程序结构如下: 输入放置策略–申请一块内存作为主存–循环处理用户的请求(包括申请、释放)
需设计两个函数处理用户请求: 申请函数 Addr=Request(size)
释放函数 Release(addr)
(3)数据实例:maxsize=512 J1 申请162,J2 申请64,J3 申请120,J4 申请86,J1完成,J3完成,J5申请 72,J6申请100,J2完成,J7申请36,J8申请60,J4完成,J9申请110, J10申请42。备注:
(a)所有大小其单位为节(1 节=rd 的大小)
(b)作业申请 n 节,实际分配的分区大小应为 n+1 节。 其中一节作为分区描述器,其他 n 节提供给作业。
(c)已分配区放在高地址处。
(d)合并时应考虑四种情况: 假设回收区为 r,上邻 为 f1(f1 需搜索自由主存队列),下邻为 f2(f2 可直 接计算)
A)f1空闲,f2已分配;
B)f1已分配,f2空闲;
C)f1空闲,f2空闲;
D)f1已分配,f2已分配;

二、程序功能及设计思路

需求分析:空闲区队列按链表组织,且需要设计申请函数和释放函数,分区描述器占一节,已分配区在高地址处,合并时需要考虑多种情况。而申请函数又包含三种方式,所以每种方式遍历链表的操作必然不同。
所以程序应该有创建分区链表,申请内存和释放内存的功能。
设计思路:创建分区描述器类,进程类和一个管理类。管理类中包含各种适应算法和释放算法,同时创建一个进程类类型的vecotr数组,用来存储所有已经申请成功的进程,为释放算法作基础。
首次适应算法比较简单,直接根据申请顺序往主存中塞入即可。
最佳适应算法,则设计一个变量通过比较来记录当前遍历过的链表中内存最小的块,从而实现算法。
最坏适应算法,同理,设计一个变量通过比较来记录当前遍历过的链表中内存最大的块,从而实现算法。

三、数据结构及算法设计

(1)设计:数据结构
分区描述器应该具有分配标志,对空闲分区而言为0,对已分配区而言为1。同时也应该具有空闲区大小和勾链字,勾链字指向队列中下一个空闲分区,对已分配区而言,此项为0.

分区描述器类

class Rd { 
public:
    bool m_flag;//分配标志
    int m_size;//空闲区大小
    Rd *m_next;//勾链字 
    Rd(bool flag, int size, Rd* next) {
        m_flag = flag;
        m_size = size;
        m_next = next;
    }
    ~Rd(){}
};

进程具有进程名,首地址和程序大小三个特征。
进程类

class Proceedings
{
public:
    string m_name;//进程名
    int m_begin;//首地址
    int m_size;//程序大小
public:
    Proceedings(string name, int begin, int size) {
        m_name = name;
        m_begin = begin;
        m_size = size;
    }
    ~Proceedings() {}
};

管理类除包含各种算法外,应该有一指针指向分区链表的第一个节点,也需要一个容器来存储所有已经申请成功的进程。
管理类

class Manage {
    Rd* m_first; //指向分区链表的第一个节点
    vector<Proceedings>all; //存储所有已经申请成功的进程
public:
    Manage(Rd* first) :m_first(first) {}
    void first_adapt();//首次适应算法
    void BestWay();//最佳适应算法
    void WorstWay();//最坏适应算法
    void Read();
    void Release();//释放合并函数
};

(2)算法设计
首次适应算法

void Manage::first_adapt()
{
    int address=0;//address记录当前块的地址
    cout << "输入程序名和进程区的大小:";
    string name;
    int  size;
    cin >> name >> size;
    Rd* p(m_first);
    while (p) 
    {
        address =address+(p->m_size + 1);//注意分区描述器占1节
        if (p->m_flag==0)
        {
            if (p->m_size == size)
            {
                p->m_flag =1;
                address =address- size - 1;//正好占完空闲区
                break;
            }
            else if(p->m_size > size) //当前块大于进程申请的大小 
            {
                p->m_size = p->m_size-size- 1;
                address = address - size - 1;
                Rd *newRd = new Rd(1, size, p->m_next);
                p->m_next = newRd;//塞入后更新p的信息
                break;
            }
            else { p = p->m_next; }
        }
        else { p = p->m_next; }
    }
    if (p!=nullptr)//循环结束后,若p不为空,说明进程成功申请,将其加入vector
    {
      Proceedings newProceedings(name, size, address);
        all.push_back(newProceedings);
    }
    else {
        cout << "分配失败" << endl;
    }
}

最佳适应算法

void Manage::BestWay()
{
    int address(0);//address记录当前块的地址
    cout << "输入程序名和进程区的大小:";
    string name;
    int  size;
    cin >> name >> size;
    Rd* p(m_first);
    int max = 10000;
    Rd  *q(NULL);          //记录指针
    while (p)
    {
        if (p->m_flag==0)
        {
            if (p->m_size > size) //当前块大于进程申请的大小 
            {
                if (p->m_size < max) //当前块更适合
                {
                    max = p->m_size;
                    q = p;
                }
            }
            else if(p->m_size == size)//当前块正好等于进程申请的大小
            {
                p->m_flag = 1;
                q = p;
                break;
            }
        }
        p = p->m_next;
    }
    if (q) //循环结束后,若q不为空,则说明进程成功申请,将其加入vector
    {
        q->m_size -= (size + 1);
        Rd *newRd = new Rd(1, size, q->m_next);
        q->m_next = newRd;
        p = m_first;
        while (p) {
            if (p == q->m_next) { break; }
            address += (p->m_size + 1);
            p = p->m_next;
        }
        Proceedings newProceedings(name, size, address);
        all.push_back(newProceedings);
    }
    else { cout << "分配失败" << endl; }

最坏适应算法

void Manage::WorstWay()
{
    int address = 0;//address记录当前块的地址
    cout << "输入程序名和进程区的大小:";
    string name;
    int  size;
    cin >> name >> size;
    Rd* p(m_first);
    int min = 0;
    Rd* q(NULL);          //记录指针
    while (p)
    {
        if (p->m_flag==0)
        {
            if (p->m_size > size) //当前块大于进程申请的大小 
            {
                if (p->m_size > min) //当前块更小
                {
                    min = p->m_size;
                    q = p;
                }
            }
            else if(p->m_size == size)
            {
                p->m_flag = false;
                q = p;
                break;
            }
        }
        p = p->m_next;
    }
    if (q)//循环结束后,若q不为空,则说明进程成功申请,将其加入vector
    {
        q->m_size -= (size + 1);
        Rd* newRd = new Rd(1, size, q->m_next);
        q->m_next = newRd;
        p = m_first;
        while (p)
        {
            if (p == q->m_next)break;
            address += (p->m_size + 1);
            p = p->m_next;
        }
        Proceedings newProceedings(name, size, address);
        all.push_back(newProceedings);
    }
    else {  cout<< "分配失败" << endl; }
}

释放算法

void Manage::Release() {
    cout << "输入释放进程的id:";
    string name;
    cin >> name;
    //在vector中查找是否存在该进程 
    vector<Proceedings>::iterator it;
    for (it = all.begin(); it != all.end(); it++)
    {
        if (it->m_name == name) {
            break;
        }
    }
    if (it == all.end())
    {
        cout << "该进程不存在,请检查输入" << endl;
        return;
    }
    int address=0;
    Rd* p(m_first);
    while (p) {                      //查找该进程所用的分区 
        if (it->m_size == address)break;
        address += (p->m_size + 1);
        p = p->m_next;
    }
    p->m_flag = 0;                                //该块的状态更改为可用
    if (p->m_next)
    {
        if (p->m_next->m_flag == 0)   //若所释放的分区后面存在可用的分区,合并
        {
            p->m_size += (p->m_next->m_size + 1);
            Rd* t(p->m_next);
            p->m_next = p->m_next->m_next;
            delete t;
        }
    }
    Rd* q(m_first);
    while (q) {
        if (q->m_next == p && q->m_flag == 0){//所释放的分区前面存在可用的分区,合并       
            q->m_size += (p->m_size + 1);
        q->m_next = p->m_next;
        delete p;
        break;
    }
    q = q->m_next;
}
all.erase(it);
}

阅读算法

void Manage::Read()
{
    int i = 1;
    int remainsize=512;
    Rd* temp = m_first;
    while (temp)
    {
        if (temp->m_flag == 0) { 
            cout << "第" << i << "块分区可用, "; 
        }
        else {
            cout << "第" << i << "块分区不可用, ";
        }
            cout << "大小为" << temp->m_size << endl;
        
        i++;
        temp = temp->m_next;
    }
    cout << endl;
    vector<Proceedings>::iterator it = all.begin();
    while (it != all.end()) {
        cout << "名为" << it->m_name << "的进程返回的地址为:";
        cout << it->m_size+1 << endl;
        it++;
    }
}

四、程序运行情况

在这里插入图片描述
在这里插入图片描述

五、遇到的困难及解决办法、实习心得或良好建议

遇到的困难:进程返回的地址总是会和应该返回的正确地址不符。
解决办法:通过多次调试,注意分区描述器占1节,在代码计算地址时添加这个关键的1。
实习心得:书中所用例子为已分配进程在低地址区,而本题已分配进程在高地址区,让我对动态分区式存贮区管理有了更深层次的理解,

  • 1
    点赞
  • 23
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ohmysoni_s_zhuo远

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值