实验四 动态分区分配算法

于 2015-12-30 16:43:53 发布
阅读量9.3k 收藏 28
点赞数
分类专栏： C# 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xyj2014/article/details/50435679
版权


一、  需求分析

说明程序设计的任务和目的，明确规定下述内容：

加深对动态分区分配算法的理解，进一步掌握首次适应算法、循环首次适应 算法、最佳适应算法和最坏适应算法的实现方法。

(1)    输入的形式和输入值的范围；

 已在程序中预置好内存和进程等信息

(2)    输出的形式；

 按内存地址从低到高的顺序输出内存状态和进程的分配结果

(3)    程序所能达到的功能；

 模拟首次适应算法、循环首次适应  算法、最佳适应算法和最坏适应算法对内存进行分配

(4)    测试数据，包括正确的输入及其输出结果和含有错误的输入及其输出结果。

进程信息


内存信息（一个 . 代表一个内存单元，| 代表 内存块之间的划分）


二、  概要设计

说明本程序中用到的所有抽象数据类型的定义、主程序的流程以及各程序模块之间的层次(调用)关系。

进程对象

classProcess

    {

        publicstring name;

        publicint needSpace;

    }

内存块对象

classSpace

    {

        privatestaticstring usedFlag = "1";

        privatestaticstring freeFlag = ".";

        publicint id;//空间编号（从小到大排序）

        publicint startIndex;//空间开始索引

        publicint freeStartIndex;//空闲指针[空间内的相对位置0-空间大小]

        publicint freeSize;//空间块空闲大小

        publicList<string> SpaceDetail;//空间详情

        privateList<string>SpaceDetailNote;//【辅助变量】空间详情描述，便于观察分配结果

        privateint NoteStartIndex;//【辅助变量】空间块空闲大小

}

内存对象

classRAM

    {

        publicint size;//内存大小      

        publicList<Space> spaceDetail;//内存块详情

    }

三、  详细设计

实现程序模块的具体算法。

publicbool FirstPartition(List<Process> processList)

publicbool CycleFirstPartition(List<Process> processList)

publicbool BestPartition(List<Process> processList)

publicbool WorstPartition(List<Process> processList)

四、  调试分析

(1)    调试过程中遇到的问题以及解决方法，设计与实现的回顾讨论和分析；

完全采用C#用面向对象的方式编写，编程过程十分顺利

五、  用户使用说明

程序的使用说明，列出每一步的操作步骤。

运行程序---查看结果

六、  测试结果

列出测试结果，包括输入和输出。


七、  附录

带注释的源程序，注释应清楚具体；

using Lab4;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Lab4
{

    class Process
    {
        public string name;
        public int needSpace;
        public Process(string name, int needSpace)
        {
            this.name = name;
            this.needSpace = needSpace;
        }
    }
    class Space
    {
        private static string usedFlag = "1";
        private static string freeFlag = ".";
        public int id;//空间编号（从小到大排序）
        public int startIndex;//空间开始索引
        public int freeStartIndex;//空闲指针[空间内的相对位置0-空间大小]
        public int freeSize;//空间块空闲大小
        public List<string> SpaceDetail;//空间详情
        private List<string> SpaceDetailNote;//【辅助变量】空间详情描述，便于观察分配结果
        private int NoteStartIndex;//【辅助变量】空间块空闲大小
        public Space(int id, int startIndex, int size)
        {
            this.id = id;
            this.startIndex = startIndex;
            freeStartIndex = 0;
            freeSize = size;
            SpaceDetail = new List<string>(); SpaceDetailNote = new List<string>(); NoteStartIndex = 0;
            for (int i = 0; i < size; i++)
            {
                SpaceDetail.Add(freeFlag); SpaceDetailNote.Add(freeFlag);
            }
        }

        public void useSpace(Process process)
        {
            for (int i = freeStartIndex; i < freeStartIndex + process.needSpace; i++)
            {
                SpaceDetail[i] = usedFlag;
            }
            freeSize -= process.needSpace;
            freeStartIndex = SpaceDetail.Count - freeSize - 1;

            SpaceDetailNote.RemoveRange(NoteStartIndex, process.needSpace); SpaceDetailNote.Insert(NoteStartIndex, process.name + "[" + process.needSpace + "]"); NoteStartIndex++;

        }
        public void printSpace()
        {
            for (int i = 0; i < SpaceDetail.Count; i++)
            {
                Console.Write(SpaceDetail[i]);
            }
        }
        public void printSpaceNote()
        {
            for (int i = 0; i < SpaceDetailNote.Count; i++)
            {
                Console.Write(SpaceDetailNote[i]);
            }
        }
    }
    class RAM
    {
        public int size;//内存大小       
        public List<Space> spaceDetail;//内存块详情
        public RAM(int[] spaceSizeArray)
        {
            size = 0;
            spaceDetail = new List<Space>();
            for (int i = 0; i < spaceSizeArray.Length; i++)
            {
                spaceDetail.Add(new Space(i, size, spaceSizeArray[i]));
                size += spaceSizeArray[i];
            }
        }
        public void printRAM(bool printNote = false)
        {
            //打印前将存储块从小到大排序
            spaceDetail = spaceDetail.OrderBy(m => m.id).ToList();
            Console.WriteLine("当前RAM状态如下： \n");
            foreach (var space in spaceDetail)
            {
                space.printSpace();
                Console.Write("|");
                //Console.WriteLine(space.id + "[" + space.startIndex + "," + (space.startIndex + space.SpaceDetail.Count-1) + "]");
            }
            Console.WriteLine("\n");
            if (printNote)
            {

                foreach (var space in spaceDetail)
                {
                    space.printSpaceNote();
                    Console.Write("|");
                    //Console.WriteLine(space.id + "[" + space.startIndex + "," + (space.startIndex + space.SpaceDetail.Count-1) + "]");
                }
                Console.WriteLine("\n");
            }

        }
        //首次适应算法
        public bool FirstPartition(List<Process> processList)
        {
            Console.WriteLine("首次适应算法进行中...");
            //默认分配成功次数
            int succcefulCount = 0;
            //遍历所有进程
            for (int i = 0; i < processList.Count; i++)
            {
                //遍历所有空间块
                for (int j = 0; j < spaceDetail.Count; j++)
                {
                    //如果空间充足
                    if (spaceDetail[j].freeSize >= processList[i].needSpace)
                    {
                        //分配空间并转至处理下一进程
                        spaceDetail[j].useSpace(processList[i]);
                        succcefulCount += 1;
                        break;
                    }
                }
            }
            return succcefulCount == processList.Count ? true : false;
        }
        //循环首次适应算法
        public bool CycleFirstPartition(List<Process> processList)
        {
            Console.WriteLine("循环首次适应算法进行中...");
            //记录上次空间块的位置和1个进程比较空间块的次数
            int spaceIndex = 0, compareCount = 0;
            //默认分配成功次数
            int succcefulCount = 0;
            //遍历所有进程
            for (int i = 0; i < processList.Count; i++)
            {
                //切换到新进程时重置比较次数
                compareCount = 0;
                //循环遍历所有空间块
                while (compareCount < spaceDetail.Count)
                {
                    //如果比较了所有空间块则终止，防止死循环！
                    if (compareCount == spaceDetail.Count)
                    {
                        compareCount = spaceDetail.Count;//同时跳出第二层循环
                        break;
                    }
                    //取模运算,防止循环越界!
                    if (spaceIndex >= spaceDetail.Count)
                    {
                        spaceIndex = spaceIndex % spaceDetail.Count;
                    }
                    //如果空间充足
                    if (spaceDetail[spaceIndex].freeSize >= processList[i].needSpace)
                    {
                        //分配空间并转至处理下一进程
                        spaceDetail[spaceIndex].useSpace(processList[i]);
                        succcefulCount++;
                        spaceIndex++;//移动指针到下一空间
                        break;
                    }
                    spaceIndex++;//移动指针
                }

            }
            return succcefulCount == processList.Count ? true : false;
        }
        //最佳适应算法
        public bool BestPartition(List<Process> processList)
        {
            Console.WriteLine("最佳适应算法进行中...");
            //默认分配成功次数
            int succcefulCount = 0;

            //遍历所有进程
            for (int i = 0; i < processList.Count; i++)
            {
                //空间块排序(按剩余空间从小到大)
                spaceDetail = spaceDetail.OrderBy(m => m.freeSize).ToList();
                //取出空间访问顺序
                List<int> orders = (from t in spaceDetail select t.id).ToList();

                //按访问顺序遍历所有空间块
                for (int j = 0; j < orders.Count; j++)
                {
                    int order = orders[j];
                    Space space = (from t in spaceDetail where t.id == order select t).FirstOrDefault();
                    //如果空间充足
                    if (space.freeSize >= processList[i].needSpace)
                    {
                        //分配空间并转至处理下一进程
                        spaceDetail[j].useSpace(processList[i]);
                        succcefulCount += 1;
                        break;
                    }
                }

            }

            return succcefulCount == processList.Count ? true : false;
        }
        //最坏适应算法
        public bool WorstPartition(List<Process> processList)
        {
            Console.WriteLine("最坏适应算法进行中...");
            //默认分配成功次数
            int succcefulCount = 0;

            //遍历所有进程
            for (int i = 0; i < processList.Count; i++)
            {
                //空间块排序(按剩余空间从大到小)
                spaceDetail = spaceDetail.OrderByDescending(m => m.freeSize).ToList();
                //取出空间访问顺序
                List<int> orders = (from t in spaceDetail select t.id).ToList();

                //按访问顺序遍历所有空间块
                for (int j = 0; j < orders.Count; j++)
                {
                    int order = orders[j];
                    Space space = (from t in spaceDetail where t.id == order select t).FirstOrDefault();
                    //如果空间充足
                    if (space.freeSize >= processList[i].needSpace)
                    {
                        //分配空间并转至处理下一进程
                        spaceDetail[j].useSpace(processList[i]);
                        succcefulCount += 1;
                        break;
                    }
                }

            }

            return succcefulCount == processList.Count ? true : false;
        }
    }
    class Tool
    {
     
        public static void PrintProcessList(List<Process> processList)
        {
            Console.WriteLine("----------进程列表如下: \n");
            for (int i = 0; i < processList.Count; i++)
            {
                Console.Write("进程名 " + processList[i].name + " 进程所需空间大小" + processList[i].needSpace+"\n");
              
            }
            Console.WriteLine("\n提示： . 表示未使用, 1 表示已被进程占用 \n");
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("----------动态分区分配算法----------- \n");
        //初始化进程
        List<Process> processList = new List<Process>();
        processList.Add(new Process("A", 7));
        processList.Add(new Process("B", 18));
        processList.Add(new Process("C", 9));
        processList.Add(new Process("D", 20));

        //初始化内存
        int[] spaceSizeArray = new int[] { 16, 16, 8, 32, 64, 32 };

        //打印信息
        Tool.PrintProcessList(processList);
      

        var r1 = new RAM(spaceSizeArray); r1.printRAM();
        if (r1.FirstPartition(processList))
        {
            r1.printRAM(true);
        }
        else
        {
            Console.Write("警告:RAM不足,部分进程未处理!!! \n");
            r1.printRAM(true);
        }
        var r2 = new RAM(spaceSizeArray); r2.CycleFirstPartition(processList); r2.printRAM(true);
        var r3 = new RAM(spaceSizeArray); r3.BestPartition(processList); r3.printRAM(true);
        var r4 = new RAM(spaceSizeArray); r4.WorstPartition(processList); r4.printRAM(true);

        Console.ReadLine();
    }
}



侨小米
关注
专栏目录
博客
SpringBoot整合lombok日志
06-21 975
SpringBoot整合lombok日志
博客
SpringBoot同时整合JdbcTemplate,Mybatis,Jpa多数据源（MySQL和SQL sever）
06-20 1839
SpringBoot同时整合JdbcTemplate,Mybatis,Jpa多数据源（MySQL和SQL sever）
博客
SpringBoot整合JdbcTemplate多数据源（MySQL和SQL sever）
06-20 751
SpringBoot整合JdbcTemplate多数据源（MySQL和SQL sever）
博客
SpringBoot整合Mybatis多数据源（MySQL和SQL sever）
06-20 1216
SpringBoot整合Mybatis多数据源（MySQL和SQL sever）
博客
SpringBoot整合单元测试
06-19 260
SpringBoot整合单元测试
博客
SpringBoot整合Swagger
06-19 231
SpringBoot整合Swagger
博客
springboot 整合jpa多数据源（sqlsever和mysql）
06-19 1076
springboot jpa实现增删改查
博客
项目集成lombok插件（Idea）
05-26 415
Lombok能通过引入@Data注解来简化Web开发中实体类的get/set方法的编码
博客
JdbcTemplate实现登录注册（前后端分离）
05-26 544
本文将运用近期学习的知识做一个小小的综合案例
博客
SpringBoot 文件上传和参数获取
05-26 2920
配置文件上传大小限制（application.yml）编写服务端接收逻辑(HttpParamContorller)编写客户端发送逻辑(http_param.html)
博客
JdbcTemplate增删改查Mysql数据库（图文教程）
05-26 1266
第一部分：配置数据库相关的依赖（pom.xml） 第二部分：配置数据库连接信息（application.yml） 第三部分：编写数据库实体类（User） 第四部分：编写增删改查的Service接口（HomeService） 第五部分：实现Service接口 （HomeServiceImpl） 第六部分：在控制器中调用Service（HomeController） 附录：（各部分完整代码）
博客
SpringBoot入门，Hello World(图文教程)
05-25 1355
从0开始学SpringBoot-创建第1个Hello World WebApi
博客
动态规划-用金矿模型用通俗的语言讲解
12-19 487
对于动态规划，每个刚接触的人都需要一段时间来理解，特别是第一次接触的时候总是想不通为什么这种方法可行，这篇文章就是为了帮助大家理解动态规划，并通过讲解基本的01背包问题来引导读者如何去思考动态规划。本文力求通俗易懂，无异性，不让读者感到迷惑，引导读者去思考，所以如果你在阅读中发现有不通顺的地方，让你产生错误理解的地方，让你难得读懂的地方，请跟贴指出，谢谢！    ----第一节
博客
分治法-快速排序
12-18 5844
快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列package sortdemo;import java.util.Arrays;/** *
博客
分治法-归并排序
12-18 484
归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。可以看到这种结构很像一棵完全二叉树，本文的归并排序我们采用递归去实现（也可采用迭代的方式去实现）。分阶段可以理
博客
在MVC 中使用 autofac 实现自动注册
07-31 4622
思路很简单：首先我们去找到所有Dll，再去找到实现了IDependency接口的类，然后使用RegisterAssemblyTypes进行注入。IAutoInject是一个空接口，用来辅助我们寻找需要注册的接口
博客
关于sqlsever 通用分页脚本的探索
04-05 653
在上一篇文章-SQLSERVER分页查询中，介绍了如何使用sql脚本进行分页，但是那种方法有个局限性，必须在设计表时把主键名称设置为id，为了解决这个问题，有了这篇文章，接下来进入正题。先上代码declare @begin_date datetimedeclare @end_date datetimeselect @begin_date = getdate()--code st
博客
SQLSERVER分页查询
04-05 639
1.准备工作create table pagetest(id int identity(1,1) not null,col01 int null,col02 nvarchar(50) null,col03 datetime null)--1万记录集declare @i intset @i=0while(@i<10000)begin insert into pag
博客
Winform PropertyGrid使用方法
03-28 1万+
原文连接先来转一个基础的，源自msdnhttp://www.microsoft.com/taiwan/msdn/library/2002/Jul-2002/article/usingpropgrid.htm摘要： 本文旨在帮助您了解 Microsoft .NET 框架中的 PropertyGrid 控件，以及如何针对您的应用程序自定义该控件。适用于：     M
博客
解决ASP.NET Core网站 发布按钮不能用的问题
03-25 1309
1.安装从IIS到Kestrel server的反向代理，下载地址：.NET Core Windows Server Hosting2.安装完后重启服务，用管理员权限打开命令行：输入 net stop was /y运行完后再运行net start w3svc3.重启vs2015就可以发布看到发布按钮从灰色变成可以点击的了
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值