内存分配算法（操作系统课程实验）

最新推荐文章于 2024-07-14 19:56:17 发布
最新推荐文章于 2024-07-14 19:56:17 发布
阅读量80 收藏 1
点赞数
文章标签： 算法 windows
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/timeflyfast/article/details/133859803
版权 
_memory.h

#include<string>
#include<stdio.h>
#include<iostream>
using namespace std;
typedef struct Lnode
{
    string name;
    int startaddress;
    int size;
    int state;
    string sign;
    
}Lnode;

typedef struct process
{
    string name;
    int size;
}Process;



 void _print();
 static void _First_Distribution();
void _First_Distribution_Print();
static void _Cycle_First_Distribution();
void _Cycle_First_Distribution_Print();

static void _Worst_Distribution();
void _Worst_Distribution_Print();

static void _Best_Distribution();
void _Best_Distribution_Print();

static void _Recycle();
void _Recycle_Print();

static void _Merge_Blank_Partitions();
void _Merge_Blank_Partitions_Print();

_memory.cpp

#include<stdio.h>
#include<string>
#include"_memory.h"
#include<iostream>
using namespace std;

#define L 40
Lnode P[L] = { {"a",0,128,0},{"b",200,256,0},{"c",500,512,0},{"d",1500,1024},{"e",5000,2048}};
int Num = 5;//目前的分区块数
int f = 0;//循环首次
int G = 30;
 void _print()
{
    int i = 0;
    cout << "分区名字  起始地址   分区    状态" << endl;
    for (i = 0; i < Num; i++)
    {
        for (int j = 0; j < Num - i - 1; j++)
        {
            if (P[j].startaddress > P[j + 1].startaddress)
            {
                swap(P[j], P[j + 1]);
            }
        }
    }
    for (i=0; i < Num; i++)
    {
        cout<<P[i].name << "        " << P[i].startaddress << "        " << P[i].size << "    " << P[i].state << "    " << endl;
    }
}

static void _First_Distribution()
{
    int i = 0;
    Process A;
    int log = 0;
    cout << "输入请求分区的进程名字和大小" << endl;
    cin >> A.name>>A.size;
    for (; i < Num; i++)
    {
        if (P[i].size < A.size)
            continue;
        else 
            if (P[i].size ==A.size|| P[i].size - A.size < G)
            {
                P[i].state = 1;
                P[i].sign = P[i].name;
                P[i].name = A.name;
                
                log = 1;
                break;
            }
            else 
            {  
                P[Num].startaddress = P[i].startaddress +A.size;
                P[Num].size = P[i].size - A.size;
                P[Num].name = P[i].name;
                P[i].size =A.size;
                P[i].sign = P[i].name;
                P[i].name = A.name;
                P[i].state = 1;
                log = 1;
                Num++;
                break;
            }
             
        
    }
    if (log == 1 || i < Num)
    {
        cout << "地址分配成功" << endl;
        cout << "地址分配成功后的状态" << endl;
        _print();
    }
    else
    {
        cout << "没有足够的分配空间" << endl;
    }
}

static void _Cycle_First_Distribution()
{
     Process A;
    int t = 0;
    int log = 0;
    cout << ("请输入需要分配分区的大小") << endl;
    cin >> A.name >> A.size;

    while (f < Num)
    {
        if (P[f].size <A.size)
        {
            f = f + 1;
            if (f % Num == 0)
            {
                f = 0;
                t = 1;

            }
            continue;
        }
        if (P[f].size == A.size && P[f].state != 1)
        {
            P[f].state = 1;
            P[f].name = A.name;
            log = 1;
            f = f + 1;
            break;
        }
        if (P[f].size > A.size && P[f].state != 1)
        {
            P[Num].startaddress = P[f].startaddress + A.size;
            P[Num].size = P[f].size - A.size;
            P[Num].name = P[f].name;
            P[f].size = A.size;
            P[f].sign = P[f].name;
            P[f].name = A.name;
            P[f].state = 1;
            log = 1;
            Num = Num + 1;
            f = f + 1;
            break;
        }
        
    }
    if (log == 1)
    {
        cout << ("内存已经分配成功") << endl;
        cout << ("内存分配后的状态：") << endl;
        _print();
    }
    else
    {
        cout << ("没有足够的内存空间") << endl;
    }
}

static void _Worst_Distribution()
{
    int log = 0;
    int t = 0;
     Process A;
    int i = 0;
    int temp[L];
    cout << ("请输入要分配分区的大小") << endl;
    cin >> A.name >> A.size;
    for (; i < Num; i++)
    {
        temp[i] = 0;
        if (P[i].size < A.size)
        {
            continue;
        }
        else
            if (P[i].size == A.size)
            {
                P[i].state = 1;
                P[i].sign = P[i].name;
                P[i].name = A.name;
                log = 1;
                break;
            }
            else
            {
                temp[i] = P[i].size - A.size;
            }
    }

        if (log == 0)
        {
            for (i = 0; i < Num; i++)
            {
                if (temp[i] != 0)
                {
                    t = i;
                }
            }
            for (i = 0; i < Num; i++)
            {
                if (temp[i] != 0 && temp[i] > temp[t])
                {
                    t = i;
                }
            }
            P[Num].startaddress = P[t].startaddress + A.size;
            P[Num].size = P[t].size - A.size;
            P[Num].name = P[t].name;
            P[t].size = A.size;
            P[t].sign = P[t].name;
            P[t].name = A.name;
            P[t].state = 1;
            log = 1;
            Num = Num + 1;
        }
        if (log == 1||i<Num)
        {
            cout << ("内存已经分配成功") << endl;
            cout << ("内存分配后的状态：") << endl;
            _print();
        }
        else
        {
            cout << ("没有足够的内存空间") << endl;
        }
    
}

static void _Best_Distribution()
{
    int log = 0;
    int t = 0;
    Process A;
    int i = 0;
    int temp[L];
    cout << ("请输入要分配分区的大小") << endl;
    cin >> A.name >> A.size;
    for (; i < Num; i++)
    {
        temp[i] = 0;
        if (P[i].size < A.size)
        {
            continue;
        }
        else
            if (P[i].size == A.size)
            {
                P[i].state = 1;
                P[i].sign = P[i].name;
                P[i].name = A.name;
                log = 1;
                break;
            }
            else
            {
                temp[i] = P[i].size - A.size;
            }
    }

    if (log == 0)
    {
        for (i = 0; i < Num; i++)
        {
            if (temp[i] != 0)
            {
                t = i;
            }
        }
        for (i = 0; i < Num; i++)
        {
            if (temp[i] != 0 && temp[i] < temp[t])
            {
                t = i;
            }
        }
        P[Num].startaddress = P[t].startaddress + A.size;
        P[Num].size = P[t].size - A.size;
        P[Num].name = P[t].name;
        P[t].size = A.size;
        P[t].sign = P[t].name;
        P[t].name = A.name;
        P[t].state = 1;
        log = 1;
        Num = Num + 1;
    }
    if (log == 1 || i < Num)
    {
        cout << ("内存已经分配成功") << endl;
        cout << ("内存分配后的状态：") << endl;
        _print();
    }
    else
    {
        cout << ("没有足够的内存空间") << endl;
    }


}


void _First_Distribution_Print()
{
    cout << ("分配前状态为") << endl;
    _print();
    _First_Distribution();
}
void _Cycle_First_Distribution_Print()
{

    cout << ("分配前状态为") << endl;
    _print();
    _Cycle_First_Distribution();
}

void _Worst_Distribution_Print()
{
    cout << ("分配前状态为") << endl;
    _print();
    _Worst_Distribution();
}

void _Best_Distribution_Print()
{
    cout << ("分配前状态为") << endl;
    _print();
    _Best_Distribution();

}

static void _Recycle()
{  
    Process A;
    cout << ("请输入要回收的进程名字");
    cin >>A.name;
    int i = 0;
    for (i = 0; i < Num; i++)
    {
        if (P[i].name == A.name)
        {
            P[i].state = 0;
            P[i].name = P[i].sign;
        }
    }
}
void _Recycle_Print()
{
    _Recycle();
    _print();
}

static void _Merge_Blank_Partitions()
{
    int i = 0;    
    for (i = 0; i < Num; i++)
    {
        for (int j = 0; j < Num - i - 1; j++)
        {
            if (P[j].startaddress > P[j + 1].startaddress)
            {
                swap(P[j], P[j + 1]);
            }
        }
    }
    for (i = 0; i < Num-1; i++)
    {
        if (P[i].state == 0 && P[i].startaddress + P[i].size == P[i + 1].startaddress)
        {
            P[i].name = P[i + 1].name;
        }
    }
    for (i = 0; i < Num-1; i++)
    {
        if (P[i].name == P[i + 1].name)
        {
        
            P[i].size = P[i].size + P[i + 1].size;
        
            P[i + 1] = P[Num-1];
            Num = Num - 1;
            for (i = 0; i < Num; i++)
            {
                for (int j = 0; j < Num - i - 1; j++)
                {
                    if (P[j].startaddress > P[j + 1].startaddress)
                    {
                        swap(P[j], P[j + 1]);
                    }
                }
            }
        }
    }


}
void _Merge_Blank_Partitions_Print()
{
    _Merge_Blank_Partitions();
    _print();
}

main.cpp

#include<stdio.h>
#include<string>
#include"_memory.h"
#include<iostream>
using namespace std;

int main()
{
    int run = 1;

    while (run == 1)
    {
        int selct = 1;

        while (selct == 1)
        {
            cout << "******************************************\n";
            cout << "*****1.********    首次适应算法     ************\n";
            cout << "*****2.********  循环首次适应算法   ************\n";
            cout << "*****3.********    最坏适应算法     ************\n";
            cout << "*****4.********    最佳适应算法     ************\n";
            cout << "*****5.********   回收已分配内存    ************\n";
            cout << "*****6.********    合并空白分区     ************\n";
            int a;
            cin >> a;
            switch (a)
            {
            case 1:

                _First_Distribution_Print();
                break;
            case 2:
                _Cycle_First_Distribution_Print();
                break;
            case 3:
                _Worst_Distribution_Print();
                break;
            case 4:
                _Best_Distribution_Print();
                break;
            case 5:
                _Recycle_Print();
                break;
            case 6:
                _Merge_Blank_Partitions_Print();
                break;
            default:
                break;
            }
            cout << "是否继续进行实验" << endl;
            cout << "1继续   0退出" << endl;
            cin >> selct;

        }

        cout << "是否更新数据再次进行实验" << endl;
        cout << "1继续   0退出" << endl;
        cin >> run;
    }
    return 0;
}
秋到亦天凉
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
《修改动态内存分配算法》操作系统 课程设计
WindsZL的博客
10-18 414
在动态存储管理系统中，开始时，整个内存区是一个“空闲块”。随着作业进入系统， 先后提出申请存储空间的请求，系统则依次进行分配。因此，在系统运行的初期，整个内存 区基本上分隔成两大部分：低地址区包含若干占用块；高地址区是一个“空闲块”。经过一 段时间以后，有的作业运行结束，它所占用的内存区在释放后变成空闲块，这就使整个内存 区呈现出占用块和空闲块犬牙交错的状态。
计算机操作系统，课程主要算法实验
12-27
操作系统是计算机科学中的核心课程，它管理着计算机的硬件资源，包括处理器、内存、磁盘等，以确保多个进程能够高效、公平地共享这些资源。本课程的重点在于讲解和实践操作系统中的关键算法，如银行家算法、高响应比...
《操作系统》——内存管理和分配算法实现
yubo_830的博客
12-01 1218
《操作系统》课程实验（四） ——内存管理和分配算法实现 实验目的 页面置换算法的好坏直接关系到系统运行的效率。本设计要求用高级语言编写和调试一个简单的内存页面调度程序。通过本实验可以加深理解有关最佳置换算法、先进先出置换算法和最近最久未使用置换算法的概念，并体会和了解这三种页面置换算法的具体实施办法。 实验内容 页面流如下： ...
操作系统内存分配算法C++代码的实现
Carmelo_7的博客
11-17 4295
一、实验目的 通过本实验帮助学生理解在动态分区管理方式下应怎样实现主存空间的分配和回收。 二、实验内容 在动态分区管理方式下采用不同的分配算法实现主存分配和实现主存回收。 三、实验要求 （1）可变分区方式是按作业需要的主存空间大小来分割分区的。当要装入一个作业时，根据作业需要的主存量查看是否有足够的空闲空间，若有，则按需要量分割一个分区分配给该作业；若无，则作业不能装入。随着作业的装入、撤离、主存空间被分成许多个分区，有的分区被作业占用，而有的分区是空闲的。例如： 为了说明哪些区是空闲的，可以用来装入新作
操作系统-内存分配算法
cangzhexingxing的博客
05-22 4807
操作系统原理实验报告 实验题目 实验四内存分配算法 实验四、内存分配算法 1.1 实验目的 一个好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器，而且要能合理地分配和使用这些存储空间。当用户提出申请主存储器空间时，存储管理必须根据申请者的要求，按一定的策略分析主存空间的使用情况，找出足够的空闲区域分配给申请者。当作业撤离或主动归还主存资源时，则存储管理要收回作业占用的主存空间或归还部分主存空间。主存的分配和回收的实现是与主存储器的管理方式有关的，软件模拟内存的...
操作系统课程设计——处理机和进程调度算法及内存分配回收机制
qq_43750573的博客
12-02 3438
多道程序系统中，进程与进程之间存在同步与互斥关系。当就绪进程数大于处理机数时，需按照某种策略决定哪些进程先占用处理机。在可变分区管理方式下，采用首次适应算法实现主存空间的分配和回收。本程序模拟实现处理机调度和内存分配及回收机制，并通过可视化界面观察进程的运行流程与情况。
内存分配算法
weixin_34334744的博客
12-11 105
http://blog.csdn.net/xygl2009/article/details/47006225 转载于:https://www.cnblogs.com/blog-yejy/p/8021847.html
操作系统内存分配算法_操作系统基础31-连续内存分配
weixin_42497593的博客
01-27 460
内存应容纳操作系统和各种用户进程，因此应该尽可能有效地分配内存。下面介绍一种早期方法：连续内存分配。内存通常分为两个区域：一个用于驻留操作系统，另一个用于用户进程。操作系统可以放在低内存，也可放在高内存，这取决于中断向量的位置。由于中断向量通常位于低内存，因此程序员通常将操作系统也放在低内存。因此，这里只讨论操作系统位于低内存的情况，其他情况的讨论也类似。通常，我们需要将多个进程同时放在内存中。...
操作系统（三）内存管理和分配
就随便写写....
07-19 1404
操作系统原理的内存单元
操作系统实验三（动态分区分配算法）
蒟蒻达的博客
12-07 9286
动态分区分配算法 一、实验目的 用高级语言编写和调试一个内存连续分配中动态分区分配模拟程序，以加深对进程的概念及进程调度算法的理解． 二、实验指导 设计程序模拟内存动态分区分配流程，要求实现三项功能：分配内存、回收内存、显示内存使用情况 内存连续分配动态分区分配流程图如下 回收分区时应考虑分区合并的情况，三种情况，如下图 #include<bits/stdc++.h> using ...
操作系统课程设计动态分区分配存储管理.doc
12-29
"操作系统课程设计动态分区分配存储管理" 在操作系统中，存储管理是非常重要的一部分，它负责管理计算机的存储资源，包括内存分配、进程管理、存储分区管理等。动态分区分配存储管理是存储管理的一种重要技术，本节...
Memory2(new).rar_内存_操作系统 课程设计_操作系统实验
09-21
在本次的“Memory2(new).rar”压缩包中，我们主要关注的是与内存管理和操作系统相关的课程设计内容。这个实验项目旨在模拟一个64MB的内存动态管理，涵盖了内存的分配和回收这两个关键操作，这对于理解操作系统如何...
操作系统课程设计——页面置换算法模拟实现
02-24
设计内容：设计一个虚拟存储及内存工作区，使用先进先出算法（FIFO），理想型淘汰算法（OPT），最近最久未使用算法（LRU）计算不同内存容量下的缺页率，模拟表示出不同算法内存中页面的变化情况，并对不同内存容量下...
操作系统课程实验
12-06
操作系统课程实验是计算机科学教育中的重要组成部分，它涵盖了操作系统的基本概念、原理以及实际操作。这个实验旨在帮助学生深入理解操作系统的内部运作，并通过编写代码来增强动手能力。在这个压缩包中，很可能包含...
算法014：找到字符串中所有字母异位词
m0_62319039的博客
07-14 443
算法014：找到字符串中所有字母异位词
LC53最大子数组和、lc5最长回文子串、lc283移动零
m0_47536537的博客
07-14 212
请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。连续子数组 [4,-1,2,1] 的和最大，为 6。移动到数组的末尾，同时保持非零元素的相对顺序。，必须在不复制数组的情况下原地对数组进行操作。"aba" 同样是符合题意的答案。是数组中的一个连续部分。，编写一个函数将所有。LC53最大子数组和。
代码随想录算法训练营第三十二天
最新发布
weixin_44791877的博客
07-14 226
这道题自己思考ac出来了，主要是这道题需要使用二维的dp数组进行规划，由于动归是递推的，所以从结果向前思考，因此到右下角的方法只能由右下角这个格子或者左边这个格子走过来，因此右下角这个格子的方法数应该等于上一个格子的方法数加上左边这个格子的方法数。值得注意的是只有一行的或者一列的每个格子都只有1种方法，还有就是多行多列的边界格子也是只有一种方法，这个也是要初始化的。然后初始化边界的时候在障碍物之前的都初始化为1，障碍物以及障碍物之后的都初始化为0；首先几个特殊情况 当障碍物在起点或者终点的话直接返回0；
摩尔投票算法
qq_55846232的博客
07-14 470
摩尔投票算法的介绍以及相关例题的讲解
手撕七大排序(三)
Zbldx的博客
07-14 309
手撕七大排序 （三）
操作系统内存分配与回收算法模拟实现
本资源是一份关于操作系统...总结来说，这份文档提供了一个操作系统内存分配算法的具体实现案例，涵盖了理论概念、数据结构设计、核心代码示例，以及实际操作步骤，适合用于教学或自我学习操作系统内存管理方面的课程。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

秋到亦天凉

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

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

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

打赏作者

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

抵扣说明：

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

余额充值