存储管理原理最先适应--操作系统专题作业

已于 2022-11-26 19:05:45 修改
阅读量2.7k 收藏 44
点赞数 9
分类专栏： 操作系统 存储管理 最先适应算法 文章标签： 算法 操作系统
于 2022-01-14 13:34:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hzy626372333/article/details/122492255
版权

一、问题描述

设物理内存320KB，共有10个进程先后申请进入内存，进程详细情况见表1-1。

其中实现动态分区管理的具体要求如下：

1. 设计动态分区存储管理必须的表格，例如分区说明表、可用表或自由链；

2. 内存分配策略包括最先适应、最佳适应、最坏适应三种，程序可实现不同内存策略的切换；

3. 程序能够实现“当一个进程申请使用内存时，能够显示该进程在内存的占用情况及其可用表和分区说明表的变化情况；当一个进程执行完毕释放内存时，能够显示可用表和分区说明表的变化情况”;

                                              表1-1 进程相关信息

进程

进程长度（KB）

到达时间

执行时间

A

30

0

10

B

28

5

15

C

15

6

16

D

6

10

5

E

78

10

10

F

108

16

3

G

320

18

20

H

60

22

17

I

18

22

30

  • 二、问题分析

  • 涉及的知识点

  1. 动态分区分配（又称为可变分区分配）：这种分配方式不会预先划分内存分区，而是在进程装入内存时，根据进程的大小动态地建立分区，并使分区的大小正好适合进程的需要。因此系统分区的大小和数目是可变的。
  2. 分区说明表：每个分区对应一个表项。表项中包含分区号、分区大小、分区起始地址、状态信息。
  3. 空闲分区表：每个空闲分区对应一个表项。表项中包含分区号、分区大小、分区起始地址。【注：因为分区说明表涵盖了空闲分区表，且各时段的分区数目不超过两个，为了更好的屏幕展示效果，本实验只打印出分区说明表】
  4. 分区双向链表：每个分区起始部分和末尾部分分别设置前向指针和后向指针，各分区节点记录分区大小、起始地址、状态以及进程信息，同时给链表安排一个头结点。
  5. 动态分区分配算法：
  • 最先适应算法：算法思想：每次都从低地址开始查找，找到第一个能满足大小的空闲分区。算法实现：空闲分区以地址递增的次序排列。每次分配内存时顺序查找空闲分区链，找到大小能满足要求的第一个空闲分区。
  • 最佳适应算法：算法思想：由于动态分区分配是一种连续分配方式，为各进程分配的空间必须是连续的一整片区域。因此为了保证当“大进程”到来时能有连续的大片空间，可以尽可能多地留下大片的空闲区，即优先使用更小的空闲区。算法实现：空闲分区按容量递增次序链接。每次分配内存时顺序查找空闲分区链，找到大小能满足要求的第一个空闲分区。
  • 最坏适应算法：算法思想：为了解决最佳适应算法的问题——即留下太多难以利用的小碎片，故在每次分配时优先使用最大的连续空闲区，这样分配后剩余的空闲区就不会太小，更方便使用。算法实现：空闲分区按容量递减次序链接。每次分配内存时顺序查找空闲分区链，找到大小能满足要求的第一个空闲分区。

6．内存分区的回收（分4种情况）：

  • 当“回收区的后面有一个相邻的空闲分区”，则两个相邻的空闲分区合并为一个，并修改后面这个分区的分区大小和起始地址。
  • 当“回收区的前面有一个相邻的空闲分区”，则两个相邻的空闲分区合并为一个，并修改前面这个分区的分区大小。
  • 当“回收区的前、后各有一个相邻的空闲分区”，则三个相邻的空闲分区合并为一个，并修改前面这个分区的分区大小。
  • 当“回收区的前、后都没有相邻的空闲分区”，则将该分区的状态改为“空闲”，并在空闲分区表中增加一个表项。

    •                                         问题的解决思路

因为问题给出了各个进程的达到时间，则按时间点的顺序，依次安排各进程进入内存（若到达时间相同，则规定进程编号小的进程优先占用内存）。设置三种不同的动态分区分配算法，，根据各算法实现方式进行对分区链表进行处理。当选择一种算法之后，在各个进程进入/离开内存的时间点上，打印出当前内存的使用情况，即分区说明表。

                                                        三、实验结果分析

    1. 结果展示：

                                                                           图3-1

图3-1为初始菜单选择算法执行页面，用户可通过键入1、2、3、0选择不同的功能。

                            图3-2最先、最佳适应算法（截取第10s的内存分配与回收） 

                                图3-3 最坏适应算法（截取第10s的内存分配与回收） 

在本次内存管理作业中，最佳适应度算法与最先适应度算法的表现结果完全一样，故不再重复截取图片。最后，附上各算法的初始执行状态和最终执行状态，很巧合的是，采用各个算法的内存最终进程执行完毕的时间均相同且初始状态也都相同，故都只截取一张图片表示。

                                图3-4内存初始状态（三种算法执行结果均为此图）

                                图3-5内存最终状态（三种算法执行结果均为此图） 

如图3-5所示，展示完第一种算法之后，用户仍可以键入对应数字来选择下一种算法执行，直至用户按0选择退出，如图3-6所示。

                                                                图3-6退出程序 

    1. 结果原因刨析

在此实验中，最佳适应度算法与最坏适应度算法有很大的不同。最佳适应算法：为了保证当“大进程”到来时能有连续的大片空间，可以尽可能多地留下大片的空闲区，即优先使用更小的空闲区。所以如图3-2、图3-3所示：当进程A释放完内存空间后，此时内存中有两块空闲的内存空间（分区1，大小30KB；分区3，大小247KB）。此时刚好D进程（6KB）来占用内存，最佳适应度算法会分配该进程D进1号分区，因为1号分区在当前所有空闲分区中分区长度最短，此时的空闲分区链如图3-7所示：它会最先找到分区空间大的空闲分区。而最坏适应度算法则会分配该进程D进入4号分区，因为4号分区在当前所有空闲分区中分区长度最长，此时的空闲分区链如图3-8所示：它会最先找到分区空间大的空闲分区。

                     图3-7 最佳适应算法的空闲分区链（截取第10sA进程释放内存）    

                            

                        图3-8 最佳适应算法的空闲分区链（截取第10sA进程释放内存） 

总结如下：最佳适应度算法：空闲分区按容量递增次序链接。每次分配内存时顺序查找空闲分区链，找到大小能满足要求的第一个空闲分区。

最差适应度算法：空闲分区按容量递减次序链接。每次分配内存时顺序查找空闲分区链，找到大小能满足要求的第一个空闲分区。

对最先适应度算法进行如下总结：该算法会将空闲分区以地址递增的次序排列。每次分配内存时顺序查找空闲分区链，找到大小能满足要求的第一个空闲分区来进行进程分配。

    1. 性能分析

首先，从搜索速度上看，最先适应算法具有最佳性能。尽管最佳适应算法或最坏适应算法看上去能很快地找到一个最适合的或最大的空闲区，但后两种算法都要求首先把大小不同的空闲区按其大小进行排队，这实际上是对所有空闲区进行一次搜索。再者，从回收过程来看，最先适应算法也是最佳的。因为使用最先适应算法回收某一空闲区时，无论被释放区是否与空闲区相邻，都不用改变该区在可用表或自由链中的位置，只需修改其大小或起始地址。而最佳适应算法和最坏适应算法都必须重新调整该区的位置。
最先适应算法的另一个优点就是尽可能地利用了低地址空间，从而保证高地址有较大的空闲区来放置要求内存较多的进程或作业。

反过来，最佳适应法找到的空闲区是最佳的，也就是说，用最佳适应法找到的空闲区或者是正好等于用户请求的大小或者是能满足用户要求的最小空闲区。不过，尽管最佳适应法能选出最适合用户要求的可用空闲区，但这样做在某些情况下并不一定能提高内存的利用率。例如，当用户请求小于最小空闲区不太多时，分配程序会将其分配后的剩余部分作为一个新的小空闲区留在可用表或自由链中。这种小空闲区有可能永远得不到再利用(除非与别的空闲区合并)，而且也会增加内存分配和回收时的查找负担。
最坏适应算法正是基于不留下碎片空闲区这一出发点的，它选择最大的空闲区来满足用户要求，以期分配后的剩余部分仍能进行再分配。

综上所述：这三种算法各有所长，针对不同的请求队列，效果和功能是不一样的。

源代码详见主页

#include<stdio.h>
#include<stdlib.h>
#include<stdlib.h>
#include <iostream>
#define Free 0 //空闲状态
#define Busy 1 //已用状态
#define OK 1    //完成
#define ERROR 0 //出错
#define MAX_length 320 //最大内存空间为320KB
#include<iostream>
using namespace std;

//各列解释：进程号，所占内存，到达时间，执行时间 
int time[10][4]={{0,0,0,0}, 
				{1,30,0,10},
				{2,28,5,15},
				{3,15,6,16},
				{4,6,10,5},
				{5,78,10,10},
				{6,108,16,3},
				{7,320,18,20},
				{8,60,22,17},
				{9,18,22,30}};

typedef int Status;
int n = 0;
char process[11]={ ' ','A','B','C','D','E','F','G','H','I'};
typedef struct freearea//定义一个空闲区说明表结构
{
    int ID;   //分区号 ----hzy修改为进程号 
    long size;   //分区大小
    long address; //分区地址
    int state;   //状态
}ElemType;

//---------- 线性表的双向链表存储结构 ------------
typedef struct DuLNode //double linked list
{
    ElemType data;
    struct DuLNode* prior; //前趋指针
    struct DuLNode* next; //后继指针
}DuLNode, * DuLinkList;

DuLinkList block_first; //头结点
DuLinkList block_last; //尾结点

Status alloc(int);//内存分配
Status free(int); //内存回收
Status First_fit(int, int);//首次适应算法
Status Best_fit(int, int); //最佳适应算法
void show();//查看分配
Status Initblock();//开创空间表

Status Initblock()//开创带头结点的内存空间链表
{
    block_first = (DuLinkList)malloc(sizeof(DuLNode));
    block_last = (DuLinkList)malloc(sizeof(DuLNode));
    block_first->prior = NULL;
    block_first->next = block_last;
    block_last->prior = block_first;
    block_last->next = NULL;
    block_first->data.ID=999;
    block_first->data.state=999;
    block_last->data.address = 0;
    block_last->data.size = MAX_length;
    block_last->data.ID = 0;
    block_last->data.state = Free;

    return OK;
}



//------------------ 首次适应算法 -----------------------
Status First_fit(int ID, int request)//传入作业名及申请量， 
{
    //为申请作业开辟新空间且初始化
    DuLinkList temp = (DuLinkList)malloc(sizeof(DuLNode));
    temp->data.ID = ID;
    temp->data.size = request;
    temp->data.state = Busy;

    DuLNode* p = block_first->next;
    while (p)
    {
        if (p->data.state == Free && p->data.size == request)
        {//有大小恰好合适的空闲块
            p->data.state = Busy;
            p->data.ID = ID;
            return OK;
            break;
        }
        if (p->data.state == Free && p->data.size > request)
        {//有空闲块能满足需求且有剩余"
            temp->prior = p->prior;
            temp->next = p;
            temp->data.address = p->data.address;
            p->prior->next = temp;
            p->prior = temp;
            p->data.address = temp->data.address + temp->data.size;
            p->data.size -= request;
            return OK;
            break;
        }
        p = p->next;
    }
    return ERROR;
}


//-------------------- 最佳适应算法 ------------------------

Status Best_fit(int ID, int request) //ID表示输入的进程，可理解为进程号 
{
    int ch; //记录最小剩余空间
    DuLinkList temp = (DuLinkList)malloc(sizeof(DuLNode));
    temp->data.ID = ID;
    temp->data.size = request;
    temp->data.state = Busy;
    DuLNode* p = block_first->next;
    DuLNode* q = NULL; //记录最佳插入位置
    while (p) //初始化最小空间和最佳位置
    {
        if (p->data.state == Free &&(p->data.size > request || p->data.size == request))
        {
            q = p;
            ch = p->data.size - request;
            break;
        }
        p = p->next;
    }
    while (p)
    {
        if (p->data.state == Free && p->data.size == request)
        {//空闲块大小恰好合适
            p->data.ID = ID;
            p->data.state = Busy;
            return OK;
            break;
        }
        if (p->data.state == Free && p->data.size > request)
        {//空闲块大于分配需求
            if (p->data.size - request < ch)//剩余空间比初值还小
            {
                ch = p->data.size - request;//更新剩余最小值
                q = p;//更新最佳位置指向
            }
        }
        p = p->next;
    }
    if (q == NULL) 
		return ERROR;//没有找到空闲块
    else
    {//找到了最佳位置并实现分配
        temp->prior = q->prior;
        temp->next = q;
        temp->data.address = q->data.address;
        q->prior->next = temp;
        q->prior = temp;
        q->data.address += request;
        q->data.size = ch;
        return OK;
    }
}

//-------------------- 最坏适应算法 ------------------------
Status worst_fit(int ID, int request){ //ID表示输入的进程，可理解为进程号 
	int ch; //记录最大剩余空间
    DuLinkList temp = (DuLinkList)malloc(sizeof(DuLNode));
    temp->data.ID = ID;
    temp->data.size = request;
    temp->data.state = Busy;
    DuLNode* p = block_first->next;
    DuLNode* q = NULL; //记录最佳插入位置
    while (p) //初始化最大空间和最佳位置
    {
        if (p->data.state == Free &&(p->data.size > request || p->data.size == request))
        {
            q = p;
            ch = p->data.size - request;
            break;
        }
        p = p->next;
    }
    while (p)  //遍历找到最大空间和最佳位置
    {
        if (p->data.state == Free && p->data.size >= request)
        {//空闲块大于分配需求
            if (p->data.size - request > ch)//剩余空间比初值还小
            {
                ch = p->data.size - request;//更新剩余最大值
                q = p;//更新最佳位置指向
            }
        }
        p = p->next;
    }
    if (q == NULL) 
		return ERROR;//没有找到空闲块
    else
    {//找到了最佳位置并实现分配
        temp->prior = q->prior;
        temp->next = q;
        temp->data.address = q->data.address;
        q->prior->next = temp;
        q->prior = temp;
        q->data.address += request;
        q->data.size = ch;
        return OK;
    }
}
 




//-----------------------   主 存 回 收   --------------------
Status free(int ID)
{
    DuLNode* p = block_first->next;
    while (p)
    {
        if (p->data.ID == ID)
        {
            p->data.state = Free;
            //cout << p->next->data.state << endl;
            //p->data.ID = Free;
            if((p->next!=NULL)&&(p->prior->data.state == Free)&&(p->next->data.state == Free))//前面、后面均为空闲块
            {
            	p->prior->data.size=p->prior->data.size+p->data.size+p->next->data.size;
            	if(p->next->next !=NULL){
            		p->prior->next=p->next->next;
            		p->next->next->prior=p->prior;
				}else
					p->prior->next= NULL;
				free(p);
				free(p->next);
			}
            else if (p->prior->data.state == Free)//与前面的空闲块相连
            {
                p->prior->data.size += p->data.size;
                p->prior->next = p->next;
                p->next->prior = p->prior;
                free(p);
            }
            else if ((p->next!=NULL)&&(p->next->data.state == Free))//与后面的空闲块相连
            {
                    //空闲块的后继指针并不为0
                    p->next->data.size += p->data.size;
                    p->next->prior = p->prior;
                    p->prior->next = p->next;
                    p->next->data.address = p->data.address;
                    free(p);
                    //p->next->next->prior = p;
                    //p->next = p->next->next;
            }
           	break;

        }
        p = p->next;
    }
    return OK;
}


//----------------------- 分 配 内 存 -------------------------  需要改 
Status alloc(int ch,int ID) //ch表示选择的算法 
{
    int request;
	request=time[ID][1];
    if (request < 0 || request == 0)
    {
        return ERROR;
    }

    if (ch == 2) //选择最佳适应算法
    {
        if (Best_fit(ID, request) == OK)
			return OK; 
		else
			return ERROR;
		 
			
    }
    else if (ch==3) //选择最坏适应算法
	{
    	if (worst_fit(ID, request) == OK)
    		return OK; 
		else
			return ERROR;
	}
    else //默认首次适应算法
    {
        if (First_fit(ID, request) == OK)
       		return OK; 
		else
			return ERROR;
    }
}

//--------------- 显示主存分配情况 ------------------  
void show(int time)
{
	cout << "NOW TIME：";
	cout << time << endl;
    cout << "*******************-----------------*********************"<<endl;
    cout << "************       分 区 说 明 表        *************"<<endl;
    cout << "*******************-----------------*********************"<<endl;
    DuLNode* p = block_first->next;
    int i=1;
    
    cout << "分 区 号" << "\t" <<  "起始地址" << "\t"  << "分区大小（KB）" << "\t" << "状    态" << endl;
    cout << "---------------------------------------------------------" << endl;
    
    while (p)
    {
        cout << i++ << "\t\t" << p->data.address << "\t\t" << p->data.size << "\t\t";
        if (p->data.state == Free) cout << "空 闲" << endl;
        else cout << "已分配" << endl;
        p = p->next;
    }
    cout << "---------------------------------------------------------" << endl;
}
//-----------------------菜单--------------------- 
void menu(){
	cout << "1.最先适应算法 2.最佳适应算法 3.最坏适应算法 0.退出"<<endl;
} 
//----------------------- 主 函 数---------------------------  需要改 
void choice()
{
    int ch, d = 0;//算法选择标记
    
    cout << "请选择分配算法："<<endl;
    cin >> ch;
    if (ch == 0 || ch == 1 || ch == 2|| ch == 3) d++;
    while (d == 0)
    {
        cout << "请选择正确的数字0 ,1 ,2或3" << endl;
        cin >> ch;
        if (ch == 0 || ch == 1 || ch == 2|| ch == 3) d++;
    }
    if (ch == 0) exit(0);
    if (n == 0) Initblock(); //开创空间表
    int now_time =0;
    int now_ID=1;
    while(now_time<80){
    	for(int i=1;i<=9;i++){

			if(time[i][2]+time[i][3]==now_time){ //进程离开内存，进行更新 
				free(time[i][0]);     //time【i】【0】为进程号
				cout << "进程" << process[i] << "释放内存" << "  " ; 
				show(now_time);
				for(int k=now_ID;k<=9;k++){
					if(time[k][2]<now_time){
						time[k][2]=now_time;
					}
				}
			}
		} 
		while((time[now_ID][2]==now_time)&&alloc(ch,now_ID)){
			cout << "进程" << process[now_ID] << "("<< time[now_ID][1]<< "KB)" <<  "占用内存" << "  " ; 
			now_ID++;
			show(now_time);
		}
		now_time++;	
		if(time[now_ID][2]<now_time){
    		time[now_ID][2]=now_time;
		}
	}
	

	
    
}
int main(){
	while(1){
		menu();
		choice();
	}
	
	return 0;
}

hzy626372333
关注
  • 9
    点赞
  • 踩
  • 44
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
操作系统作业-文件管理-文件系统.zip
09-23
项目需求 在内存中开辟一个空间作为文件存储器，在其上实现一个简单的文件系统。退出这个文件系统时，需要该文件系统的内容保存到磁盘上，以便下次可以将其恢复到内存中来。 功能描述 - 文件存储空间管理可采取显式链接（如FAT）或者其他方法。（即自选一种方法） - 空闲空间管理可采用位图或者其他方法。如果采用了位图，可将位图和FAT表合二为一。 - 文件目录采用多级目录结构。至于是否采用索引节点结构，自选。目录项目中应包含：文件名、物理地址、长度等信息。同学可在这里增加一些其他信息。 - 文件系统提供的操作： - 格式化 - 创建子目录 - 删除子目录 - 显示目录 - 更改当前目录 - 创建文件..
操作系统 第4章 习题整理
m0_52246399的博客
04-03 9882
文章目录动态分区分配算法虚拟存储器中的页面置换算法 动态分区分配算法 例题 在可变分区存储管理下，按地址排列的内存空闲区为：10KB、4KB、20KB、18KB、7KB、9KB、12KB 和 15KB。 对于下列连续存储区的请求：12KB、10KB、15KB、18KB. 试问：使用首次适应算法、最佳适应算法、最差适应算法和下次适应算法，哪个空闲区将被使用？ 解题过程： 首次适应算法： 解析：首先，按照分区号开始，从上至下开始查找，遇到第一个满足连续存储区要求的分区，就去占用。对于往后的每一个连续存储区都
动态分区算法
最新发布
weixin_62075168的博客
04-09 599
当进程运行完毕释放内存时，系统根据回收区的首址，从空闲区链(表)中找到相应的插入点，此时可能出现以下四种情况之一： (1) 回收区与插入点的前一个空闲分区F1相邻接，此时应将回收区与插入点的前一分区合并，不必为回收分区分配新表项，而只需修改其前一分区F1的大小。(2) 回收分区与插入点的后一空闲分区F2相邻接，此时也可将两分区合并，形成新的空闲分区，但用回收区的首址作为新空闲区的首址，大小为两者之和。然后再按照作业的大小，从该分区中划出一块内存空间，分配给请求者，余下的空闲分区仍留在空闲链中。
操作系统——动态分区存储管理（c++）
qq_42698696的博客
11-24 4521
设物理内存320KB，输入进程名，进程长度，到达时间以及执行时间来自动模拟动态分区管理，并显示可用表与分区说明表的变化情况 例如： 进程 进程长度（KB） 到达时间 执行时间 A 30 0 10 B ...
uTorrent 2.2.1 高级参数设置详解及优化（转载）
热门推荐
u010794523的专栏
11-29 4万+
转自：http://leo.eool.net/blog/archives/802 uT设置网上已有不少教程，这里主要针对缓存、连接、高级参数、新功能和优化进行探讨 本文为软件应用的点滴积累和翻译人工，资料来自uT官网和帮助文件、并结合实践和反馈 uT官方默认参数大多合乎需求，请根据自身网络环境尝试 优化是配合硬件发挥最大功效，不会从物理上改变网络环境 图片中设置内
前端面试题（HTML、JS、Vue、React、小程序）
weixin_43750611的博客
11-05 7324
前端面试题HTML && CSSHTML1、Div 里面有个一个div *****2、doctype的作用 *3、link标签和import标签的区别 **HTML51、h5的新特性 ***CSS & CSS31、盒子模型 ****2、弹性布局、浮动布局、table布局 *****3、flex的属性 ****4、CSS3的新特性 *** （动画效果）5、CSS3选择器优先级及计算 ***6、清除浮动 ***7、position的相关属性 **JS原生*****
OS 最先适应算法、最优适应算法、最坏适应算法的解释
MoMing丶的博客
05-05 3万+
主要介绍最先适应算法、下次适应算法、最优适应算法、最坏适应算法的定义和特点，无代码实现。
存储管理算法设计之【内存空间的分配和回收】
鸽子的博客
08-07 1万+
设计一 内存空间的分配和回收 【实验目的】 通过本实验，帮助学生理解存储管理的功能，掌握动态异长分区的存储分配与回收算法。 【实验内容】 模拟动态异长分区的分配算法、回收算法。 【实验要求】 常用的动态异长分区的分配算法有：最先适应算法、最佳适应算法和最坏适应算法。要求选择任意一种算法，设计相应的数据结构，模拟内存空间的分配和回收。实验报告中给出程序中使用的数据结构及流程图。 【实...
最先适应法、最佳适应法、下次适配法、最差适配法
qq_18671205的博客
07-10 1万+
1.最先适应法：最先适应法又称顺序分配法或首次适配法，在这种分配法中，当接到内存申请时，顺序查找分区说明表，找到第一个满足申请长度的空闲区，将其分割分配。 举例： 2.最佳适应法：当接到内存申请时，查找分区说明表，找到第一个能满足长度的最小空闲区，将其分割并分配。 3. 下次适配法：当接到内存申请时，查找分区说明表，从上一次分配的位置开始扫描内存，选择下一个大小足够的可用块。 4. 最差适配法：在全部空闲区中找出能满足作业要求的，且大小最大的空闲分区，从而使链表中的结点大小趋于均匀，适.
7-1 内存分区分配--首次适应算法 (100 分)
qq_48508278的博客
11-10 6098
一7-1 内存分区分配–首次适应算法 (100 分) 宝 今天你看我博客了吗 输入内存的大小和阈值minsize，按照首次适应算法进行连续的分区分配。在划分时，若剩余的内存小于等于minsize，则将整块内存分配给该进程不再进行划分。 根据菜单选择相应的操作： 1.初始化：输入内存的大小和阈值minsize，初始状态下空闲分区名字为“void”。 2.分配：输入申请进程的名字、大小。 若可以分配，显示“分配成功！”； 若剩余空间不足，显示不分配原因“剩余空间不足，不予分配。”； 若剩余的空间通过紧凑技术，可
操作系统原理实验-动态分区分配方式的模拟
Kni9hT's Blog
07-14 2813
文章目录1.实验目的2.实验内容和要求3.主要仪器设备4.实验原理5.预备知识5.源程序7.实验步骤与调试8.实验结果与分析 1.实验目的 了解动态分区分配方式中使用的数据结构和分配算法，进一步加深对动态分区存储管理方式及其实现过程的理解。 2.实验内容和要求 1．用C或其他语言分别实现采用首次适应算法和最佳适应算法的动态分区分配过程和回收过程。 2．设置初始状态，每次分配和回收后显示出空闲内存分区链的情况。 3.主要仪器设备 仪器： PC机 实验环境： Ubuntu16.04 编程语言：C++
操作系统课程设计--存储管理 源代码及完整报告
05-30
存储管理的主要功能之一是合理地分配空间。请求页式管理是一种常用的虚拟存储管理技术。本设计的目的是通过请求页式存储管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。...
操作系统-存储管理动态分区分配及回收算法附源码.doc
12-01
操作系统-存储管理动态分区分配及回收算法附源码.doc
大作业二-Linux操作系统储存器管理1
08-08
2、若请求的页面不是2的整数次幂，则按照稍大于请求数的2的整数次幂的值搜索对应的页面块组 3、当搜索对应的页块组，而没有可利用的空闲页块时，再搜索更大一些的页块
操作系统原理第八章虚拟存储管理技术.ppt
11-30
操作系统原理第八章虚拟存储管理技术.ppt
c++后端相关(加深记忆，抄的github和小林coding)
weixin_44350672的博客
09-17 315
宏定义相当于字符替换，而const是常量声明；宏定义是预处理器处理，而const是编译器处理；宏定义五类型安全检查，而const有类型安全检查；宏定义不分配内存，const要分配内存；宏定义存在代码段，const存在数据段；析构函数设为私有，类生成对象就只能定义在堆上，因为c++是静态绑定语言，为类对象分配栈空间时，会先检查类析构函数的访问性，若析构函数不能访问就不能在栈上创建对象；第一阶段，使用 new 在堆上寻找可用内存，分配给对象；第二阶段，调用构造函数生成对象。
2022-03-15面试题更新
张凯杰的博客
04-29 242
北游国际面试题总结 人事部分 html、css javascript 网络请求 一、人事部分 参考网址 https://juejin.cn/post/7010948744560508941 自我介绍 模板一: 你好，我叫XXX,有XX年工作经验，来应聘前端开发工程师这一岗位。我之前在XXX工作过，期间主要负责前端项目、app和微信小程序的开发和维护工作。参与开发的项目有XX个，独自开发的项目的有XX个。在此期间，商城/交友/工具/直播/类项目做的比较多。其中印象最深的是XX项目，因为是第一个独立
操作系统最先适应算法（c++双向链表实现）
elexiangchirou的博客
11-22 1840
我参考的这篇文章，点这里 最先适应算法（First Fit）简介 首次适应算法（First Fit）：该算法从空闲分区链首开始查找，直至找到一个能满足其大小要求的空闲分区为止。然后再按照作业的大小，从该分区中划出一块内存分配给请求者，余下的空闲分区仍留在空闲分区链中。 特点： 该算法倾向于使用内存中低地址部分的空闲区，在高地址部分的空闲区很少被利用，从而保留了高地址部分的大空闲区。显然为以后到达的大作业分配大的内存空间创造了条件。 缺点：低地址部分不断被划分，留下许多难以利用、很小的空闲区，而每次查找又都.
【操作系统原理与实践】常见计算题整理：原理+例题
spicy_chicken123的博客
06-28 3006
针对操作系统原理与实践考试中常见的计算题做整理，既有相关知识点又有例题
信息管理作业--企业人力资源管理信息系统
04-05
企业人力资源管理信息系统（HRIS）是一种软件系统，旨在支持企业的人力资源管理功能。它可以处理员工信息、薪资管理、培训、绩效评估、招聘和离职等关键人力资源管理职能。 HRIS系统的主要优势在于它可以自动化许多...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

hzy626372333

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

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

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

打赏作者

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

抵扣说明：

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

余额充值