精华内容
下载资源
问答
  • 2019-11-24 17:06:09

    设物理内存320KB,输入进程名,进程长度,到达时间以及执行时间来自动模拟动态分区管理,并显示可用表与分区说明表的变化情况

    例如:
     

    进程

    进程长度(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

    三个分配策略:最先,最佳,最坏

    #include <iostream>
    #include <cstring>
    #include <fstream>
    using namespace std;
    int num=0;
    int ns[999999]={0}; 	//标识此进程是否已经结束 
    /* run this program using the console pauser or add your own getch, system("pause") or input loop */
    //可用表 
    struct U{
    	int U_num;	
    	int U_lengh;	
    	int U_Start;	
    	U *U_p; 
    }*usin;
    //分区说明表 
    struct instructions{
    	int In_num;		 
    	int In_lengh;	
    	int In_Start;	
    	string In_How;	
    	instructions *In_p;
    }*ins;
    
    //进程表 
    struct JinCheng{
    	char name;		
    	int lon;		 
    	int time;		
    	int need_time;			
    	int adress;		//进程占用内存后的首地址,便于内存回收 
    	int num;		//记录分区号 
    }; 
    
    void menu(){
    	cout<<"1.最先适应";
    	cout<<"2.最佳适应";
    	cout<<"3.最坏适应";
    }
    
    //初始化 
    void init(){
    	usin=new U;
    	ins=new instructions;
    	ins->In_num=1;
    	ins->In_lengh=320;
    	ins->In_Start=0;
    	ins->In_How="未分配";
    	ins->In_p=NULL;
    	
    	usin->U_num=1;
    	usin->U_lengh=320;
    	usin->U_Start=0;
    	usin->U_p=NULL;
    } 
    
    void show(){
    
    	//显示分区说明表
    	struct instructions *Fi=new instructions;
    	Fi=ins;
    	cout<<"分区说明表更新为:"<<endl;
    	cout<<"分区号 起始地址 分区长度 状态"<<endl; 
    	while(Fi!=NULL){
    	    if(Fi->In_Start==0){
                    cout<<Fi->In_num<<"      "<<Fi->In_Start<<"                     "<<Fi->In_lengh<<"      "<<Fi->In_How<<endl;
    	
    	    }
    	    else{
    		cout<<Fi->In_num<<"      "<<Fi->In_Start+1<<"      "<<Fi->In_lengh<<              "      "<<Fi->In_How<<endl;
    	
    	    }
    	    cout<<endl;
    	    Fi=Fi->In_p;
    }
    	
    	//显示可用表 
    	struct U *Uii=new U;
    	Uii=usin;
    	cout<<"可用表更新为:"<<endl;
    	cout<<"分区号 起始地址 分区长度"<<endl; 
    	while(Uii!=NULL){
    	    cout<<Uii->U_num<<"      "<<Uii->U_Start+1<<"         "<<Uii->U_lengh<<endl;
    	    cout<<endl;
    	    if(Uii->U_lengh==320)
    		break;
    	    else
    		Uii=Uii->U_p;
    	}
    	
    }
    
    int Pan(){
    	struct instructions *ii=new instructions;
    	ii=ins;
    	while(ii!=NULL){
    		if(ii->In_How=="已分配")
    			return 0;
    		ii=ii->In_p; 
    	}
    	return 1;
    }
    void sort1()
    {
        struct U *p = NULL;
        struct U *q = NULL;
        struct U *t = NULL;
         
        if(usin->U_p == NULL)
        {
            return;
        }
    	for(p = usin; p != NULL; p = p->U_p)
    	{
    	    for(q = usin; q->U_p!= NULL; q = q->U_p)
    	    {
    	        if(q->U_Start> q->U_p->U_Start)
    	        {
    	            swap(q->U_lengh, q->U_p->U_lengh);
    	            swap(q->U_num, q->U_p->U_num);
    	            swap(q->U_Start, q->U_p->U_Start);
    	        }
    	    }
    	         
    	}
    		
    }
    
    
    
    void sort(int a)
    {
        struct U *p = NULL;
        struct U *q = NULL;
        struct U *t = NULL;
         
        if(usin->U_p == NULL)
        {
            return;
        }
    	if(a==1){	//最佳排序 
    	    for(p = usin; p != NULL; p = p->U_p)
    	     {
    	        for(q = usin; q->U_p!= NULL; q = q->U_p)
    	         {
    	            if(q->U_lengh> q->U_p->U_lengh)
    	            {
    	               swap(q->U_lengh, q->U_p->U_lengh);
    	               swap(q->U_num, q->U_p->U_num);
    	               swap(q->U_Start, q->U_p->U_Start);
    	            }
    	        }
    	         
    	    }
    		
    	}
    	else{		//最坏排序 
    	    for(p = usin; p != NULL; p = p->U_p)
    	     {
    	        for(q = usin; q->U_p!= NULL; q = q->U_p)
    	         {
    	            if(q->U_lengh< q->U_p->U_lengh)
    	            {
    	               swap(q->U_lengh, q->U_p->U_lengh);
    	               swap(q->U_num, q->U_p->U_num);
    	               swap(q->U_Start, q->U_p->U_Start);
    	            }
    	        }
    	         
    	    }
    	}
        
    }
    int how=0;			//记录已经执行完的进程的个数,用于控制程序停止 
    void First(int n){
    	
    	cout<<"请输入进程个数";
    	int m;
    	cin>>m;
    	JinCheng Jc[m];
    	cout<<"请输入进程的进程名,进程长度,到达时间,执行时间:"<<endl;
    	for(int i=0;i<m;i++){
    	    cin>>Jc[i].name>>Jc[i].lon>>Jc[i].time>>Jc[i].need_time;
    	}
    	int j=0,a=1;			//进程数组下标j,增加的分区号 a
    	int l;				//保存需要修改的进程号 
    	int Biao=0;			//保存内存分配是否成功	 
    	
    	
    	//用循环模拟时间流逝,i的值代表了当前的时间 
    	for(int i=0;i<100;i++){
    	    cout<<"时间:"<<i<<endl;
    	    if(Jc[j].time<=i){
    			
    		struct U *q=new U;
    		q=usin;
    		while(q!=NULL){
    		    if(q->U_lengh>=Jc[j].lon&&q!=NULL){	 
    			cout<<"进程"<<Jc[j].name<<"内存分配成功,进入内存"<<endl;
    			cout<<"该进程使用内存大小为:"<<Jc[j].lon; 
    			l=q->U_num;
    			num++;
    					
    					
    			Jc[j].adress=q->U_Start;
    			Jc[j].num=q->U_num; 
    					
    			//修改可用表
    			q->U_lengh=q->U_lengh-Jc[j].lon;
    			q->U_num=a+1;
    			a=a+1;
    			q->U_Start=q->U_Start+Jc[j].lon;
    					
    			Biao=1; //表示内存分配成功,用于后面更改进程的到达时间
    					
    			//修改分区说明表 
    			struct instructions *T=new instructions;
    			T=ins;
    			while(T->In_num!=l){
    				T=T->In_p;
    			} 
    			struct instructions *tt=new instructions;
    			tt->In_num=a;
    			tt->In_Start=T->In_Start+Jc[j].lon;
    			tt->In_lengh=T->In_lengh-Jc[j].lon;
    			tt->In_How="未分配";
    			tt->In_p=T->In_p;
    			T->In_lengh=Jc[j].lon;
    			T->In_How="已分配";
    			T->In_p=tt;
    					
    					
    			Jc[j].time=i;			
    			j++; 
    					
    					
    			if(T->In_Start==0)
    				cout<<"   内存起始地址为:"<<T->In_Start<<endl<<endl;
    			else
    				cout<<"   内存起始地址为:"<<T->In_Start+1<<endl<<endl;
    						
    			//判断是否为最佳或最坏算法,进行相应排序 
    			if(n==2){
    				sort(1);
    			} 
    			else if(n==3){
    				sort(2);
    			}
    			show();			 
    			Biao=1;			
    			break;	
    		    }
    		    else{
    		        q=q->U_p;
    		    }
    				
    				
    		    if(Biao==0){
    		        for(int u=j;u<m;u++){
    			    if(Jc[u].time<=i)
    			        Jc[u].time=i;
    		        }
    					
    		    }
    		    Biao=0;		//重置标识 
    				
    	        }
    
            }
    
    		
    		
    	//判断是否有进程执行结束
    	for(int k=0;k<=j;k++){
                if(Jc[k].need_time+Jc[k].time==i&&ns[k]==0){
                    how++;
                    ns[k]=1;	
                    cout<<"进程"<<Jc[k].name<<"执行完毕"<<endl;
                    struct instructions *T=new instructions;
    		T=ins;
    				
    		int fi=0;		
    		int up=0; 		
    		while(T!=NULL){
    		    if(T->In_num==Jc[k].num){		
    			T->In_How="未分配";
    			if(T->In_p->In_How=="未分配"){
                                T->In_lengh+=T->In_p->In_lengh;
    
    			    T->In_p=T->In_p->In_p; 
    			    fi=1;
    		        }
    			struct instructions *L=new instructions;
    			L=ins;
    			while(L->In_p!=T&&L!=T){	
    			    L=L->In_p;
    			}
    			if(L->In_How=="未分配"&&L!=T){
    			    L->In_lengh+=T->In_lengh;
    			    L->In_p=T->In_p;
    			    up=1;
    			}
    			break;
    		    }
    		    else{
    		        T=T->In_p;
    		    }
    	        }
    				
    	        //更新可用表
    		//合并前对可用表按照首地址从小到大进行排列,这样合并算法可以多用 
    		if(n==2||n==3)
    			sort1();
    		struct U *q=new U;
    		q->U_num=T->In_num;
    		q->U_Start=T->In_Start;
    		q->U_lengh=T->In_lengh;
    		struct U *pp=new U;
    		pp=usin;
    		//若此结束的进程占用第一块内存,则特殊处理 
    		if(q->U_num==1){
    			q->U_p=pp;
    			usin=q;
    			show();
    			break;
    		}
    		while(pp->U_p->U_Start<q->U_Start){
    			pp=pp->U_p;
    		}
    				
    		//判断说明表更新的时候是否发生合并 
    		if(fi==1&&up==1){			//向上向下合并都发生 
    			q->U_lengh=T->In_lengh;
    			q->U_p=pp->U_p->U_p;
    			pp->U_p=q;
    			pp->U_lengh+=q->U_lengh;
    			pp->U_p=q->U_p;
    		}	
    		else if(fi==1){				//仅发生向下合并 
    			q->U_lengh=T->In_lengh;
    			q->U_p=pp->U_p->U_p;
    			pp->U_p=q;
    		}
    		else if(up==1){				//仅发生向上合并
    			pp->U_lengh+=T->In_lengh;
    		}
    			
    		else{						//没有合并发生 
    			q->U_p=pp->U_p;
    			pp->U_p=q;
    		}
    		if(n==2){		//重新对可用表按照分配策略进行排序 
    			sort(1);
    		} 
    		else if(n==3){
    			sort(2);
    		}
    		show();
    				
    				
    				 
    	    }
    	}
    
    	if(how==m){
    		cout<<"所有进程已经运行完毕"<<endl;
    		break;
    	}
    
    	
          }
    }
    
    
    
    int main(){
    	
    	init();		
    	menu();
    	cout<<"请选择分配策略:";
    	cout<<"1.最优    2.最佳   3.最坏";
    	int n;
    	cin>>n;	//借用n判断是否使用排序 
    	First(n);
    	return 0;
    }
    
    
    
    

     

    缺点:

    关于多线程:

    C类语言没有多线程这一概念因此多线程处理有些瑕疵,其实可以将输入进程打包为函数,然后内存处理作为一个函数,去查看下一个进程是否也同时进入以此决定是否调用内存处理函数。

    关于尾节点的处理:
    可用表的尾节点在G进程前后会多出一个长度为0首地址为321的尾结点,可能对于当只有一个进程进入的时候需要对可用表进行特殊处理。

    更多相关内容
  • 可变式分区存储管理: 通过文件操作读取空闲区表(包含空闲区的起始地址和长度),通过用户选择分配/回收内存,回收的内存如果和空闲区表的内存块相邻,则进行合并 注:解决方案中带有data.txt文件,并在代码中指定...
  • 模拟动态分区管理.cpp

    2021-05-23 15:42:46
    设计一个模拟内存管理中采用“动态分区”方式的存储器管理程序,实现以下操作: (1)以链接存储结构建立内存分配表、内存空闲表并进行初始化; (2)动态申请一段内存,对该段内存进行“动态分区”方式的管理,...
  • ● 建立描述内存分配状况的数据结构; ● 建立描述进程的数据结构; ● 使用两种方式产生进程:(a)自动产生, (b)手工输入;...压缩包里有内核工程和演示工程,内核C语言,演示c++(内核已生成lib),有成品报告
  • NULL 博文链接:https://touch-2011.iteye.com/blog/1068974
  • mem.c //源代码文件 mem.exe //演示程序文件
  • 动态分区存储管理

    2019-05-12 18:46:26
    3. 分区动态分配过程:由用户输入作业号和作业的大小,实现分区过程。 4. 分区的回收:用户输入作业号,实现分区回收,同时,分区的合并要体现出来。(注意:不存在的作业号要给出错误提示!) 5. 分区的显示:...
  • 操作系统实验,分区存储管理,使用VS2010编译,C++语言
  • c++模拟实现动态分区存储管理

    千次阅读 2021-06-05 17:08:58
    请重新选择"二、介绍 编程实现动态分区存储管理方式的主存分配与回收。具体内容包括:首先确定主存空间分配表;然后采用最优适应算法及首次适应算法完成主存空间的分配和回收。 具体讲: 初始状态:动态分区管理方式...

    一、代码

    #include<iostream>
    #include<vector>
    #include<string>
    using namespace std;
    typedef struct memoryBlock{
        string jobName;
        int startadress;
        int length;
        bool state;
    }memoryBlock;
    vector<memoryBlock> mb;
    void init(){
        memoryBlock m1,m2,m3,m4,m5;
        m1.jobName="作业1";m2.jobName="作业3";m3.jobName="未分配";m4.jobName="作业2";m5.jobName="未分配";
        m1.state=1;m2.state=1;m3.state=0;m4.state=1;m5.state=0;
        m1.startadress=5;m2.startadress=10;m3.startadress=14;m4.startadress=26;m5.startadress=32;
        m1.length=5;m2.length=4;m3.length=12;m4.length=6;m5.length=96;
        mb.push_back(m1);mb.push_back(m2);mb.push_back(m3);mb.push_back(m4);mb.push_back(m5);
    }
    void firstfit(){
        string name;
        cout<<"请输入要分配的作业名称:";
        cin>>name;
        int size;
        cout<<"请输入作业主存量:";
        cin>>size;
        for(vector<memoryBlock>::iterator it = mb.begin();it!=mb.end();++it){
            int s_pos = it->startadress+size;
            int last_size = it->length-size;
            int f = 0;
            if(it->length>size){
                f=1;
            }
            if(it->state==0&&it->length>=size){
                it->state=1;
                it->length=size;
                it->jobName = name;
                if(f){
                    memoryBlock m;
                    m.jobName="未分配";
                    m.length=last_size;
                    m.state=0;
                    m.startadress = s_pos;
                    it++;
                    mb.insert(it,m);
                }
                break;
            }
        }
    }
    void bestfit(){
        string name;
        cout<<"请输入要分配的作业名称:";
        cin>>name;
        int size;
        cout<<"请输入作业主存量:";
        cin>>size;
        int min_last=128;
        for(vector<memoryBlock>::iterator it = mb.begin();it!=mb.end();++it){
            if(it->state==0&&it->length>=size){
                int last_size = it->length-size;
                if(last_size<min_last){
                    min_last=last_size;
                }
            }
        }
        for(vector<memoryBlock>::iterator it = mb.begin();it!=mb.end();++it){
            int s_pos = it->startadress+size;
            int last_size = it->length-size;
            if(last_size==min_last){
                it->state=1;
                it->length=size;
                it->jobName = name;
                if(last_size>0){
                    memoryBlock m;
                    m.jobName="未分配";
                    m.length=last_size;
                    m.state=0;
                    m.startadress = s_pos;
                    it++;
                    mb.insert(it,m);
                }
                break;
            }
        }
    }
    void memoryrecycle(){
        cout<<"请输入要回收的作业名称:";
        string name;
        cin>>name;
        vector<memoryBlock>::iterator it_new;
        for(vector<memoryBlock>::iterator it = mb.begin();it!=mb.end();++it){
            if(it->jobName.compare(name)==0){
                it->state=0;
                it->jobName="未分配";
                it_new = it;
                break;
            }
        }
        vector<memoryBlock>::iterator it_pre=--it_new;
        it_new++;
        vector<memoryBlock>::iterator it_next=++it_new;
        it_new--;
        if(it_pre->state==1&&it_next->state==0){
            it_new->length+=it_next->length;
            mb.erase(it_next);
        }
        else if(it_pre->state==0&&it_next->state==1){
            it_pre->length+=it_new->length;
            mb.erase(it_new);
        }
        else if(it_pre->state==0&&it_next->state==0){
            it_pre->length+=it_new->length;
            it_pre->length+=it_next->length;
            mb.erase(it_new);
            mb.erase(it_next);
        }
    }
    void showMT(){
        cout<<"*********************空闲区表*********************"<<endl;
        cout<<"\t起止\t|\t长度\t|\t状态"<<endl;
        for(vector<memoryBlock>::iterator it = mb.begin();it!=mb.end();++it){
            if(it->state==0){
                cout<<"\t"<<it->startadress<<"k\t|\t"<<it->length<<"k\t|\t"<<it->jobName<<endl;
            }
        }
        cout<<"**************************************************"<<endl;
        cout<<"*********************已分配表*********************"<<endl;
        cout<<"\t起止\t|\t长度\t|\t名称"<<endl;
        for(vector<memoryBlock>::iterator it = mb.begin();it!=mb.end();++it){
            if(it->state==1){
                cout<<"\t"<<it->startadress<<"k\t|\t"<<it->length<<"k\t|\t"<<it->jobName<<endl;
            }
        }
        cout<<"**************************************************"<<endl;
    }
    int main(){
        init();
        cout<<"选择分配主存算法(a-首次适应算法,b-最优适应算法)"<<endl<<"请输入选择的算法:";
        char option1;
        cin>>option1;
        int option2;
        int running = 1;
        while(running){
            cout<<"选择功能项(0-退出,1-分配主存,2-回收主存,3-显示主存)"<<endl<<"请输入选择的功能:";
            cin>>option2;
            switch (option2){
                case 0: running = 0;break;
                case 1: {
                    if(option1=='a'){
                        firstfit();
                    }
                    else if(option1=='b'){
                        bestfit();
                    }
                    break;
                }
                case 2: {memoryrecycle();break;}
                case 3: {showMT();break;}
                default:{
                    cout<<"输入有误!请重新选择"<<endl;
                    break;
                } 
                
            }
        }
        return 0;
    }

    二、介绍

    编程实现动态分区存储管理方式的主存分配与回收。具体内容包括:首先确定主存空间分配表;然后采用最优适应算法及首次适应算法完成主存空间的分配和回收。

    具体讲:

    初始状态:动态分区管理方式预先不将主存划分区域。而是把主存除操作系统占用区域外的空间看作一个大的空闲区。当作业要求装入主存时,根据作业的大小查询主存内各空闲区。并按照特定的算法选择一合适的空闲区,按作业大小的要求画出一个分区并装入该作业。剩下的区域作为新的空闲区。

    当作业执行完毕后,所占用的主存空间将被回收,成为一个空闲区。注意如果该空闲区的相邻分区也是空闲区,则需要将相邻空闲区合并成一个空闲区。

    提示:

    动态分区大小由作业需求量决定,分区的长度预先不能固定。

    可建立两张分区表记录主存使用情况:

    “已分配表”记录作业占用分区;“空闲区表”记录空闲区。

    主程序菜单可参考:

        选择功能项(0-退出、1-分配主存、2-回收主存、3-显示主存)

        分配时,要求输入作业名和长度

        回收时,要求输入要回收的作业名

        显示主存,则显示空闲分区情况以及已分配分区情况等。

    本实验模拟在两种存储管理方式下的主存分配和回收。

    图例:

    可变分区方式是按作业需要的主存空间大小来分割分区的。当要装入一个作业时,根据作业需要的主存量查看是否有足够的空闲空间,若有,则按需要量分割一个分区分配给该作业;若无,则作业不能装入。随着作业的装入、撤离,主存空间被分成许多个分区,有的分区被作业占用,而有的分区是空闲的。

    为了说明哪些区是空闲的,可以用来装入新作业,必须要有一张空闲区说明表,格式如下:

     

    起    址

    长    度

    状      态

    第一栏

    14 K

    12 K

    未 分 配

    第二栏

    32 K

    96 K

    未 分 配

    其中,起址——指出一个空闲区的主存起始地址。

          长度——指出从起始地址开始的一个连续空闲的长度。

          状态——有两种状态,一种是“未分配”状态,指出对应的由起址指出的某个长度的区域是空闲区;另一种是“空表目”状态,表示表中对应的登记项目是空白(无效),可用来登记新的空闲区(例如,作业撤离后,它所占的区域就成了空闲区,应找一个“空表目”栏登记归还区的起址和长度且修改状态)。由于分区的个数不定,所以空闲区说明表中应有适量的状态为“空表目”的登记栏目,否则造成表格“溢出”无法登记。

    上述的这张说明表的登记情况是按例所装入的三个作业占用的主存区域后填写的。

    (1) 当有一个新作业要求装入主存时,必须查空闲区说明表,从中找出一个足够大的空闲区。有时找到的空闲区可能大于作业需要量,这时应把原来的空闲区变成两部分:一部分分给作业占用;另一部分又成为一个较小的空闲区。为了尽量减少由于分割造成的空闲区,而尽量保存高地址部分有较大的连续空闲区域,以利于大型作业的装入。为此,在空闲区说明表中,把每个空闲区按其地址顺序登记,即每个后继的空闲区其起始地址总是比前者大。为了方便查找还可使表格“紧缩”,总是让“空表目”栏集中在表格的后部。

    (2) 采用最先适应算法(顺序分配算法)分配主存空间。

    按照作业的需要量,查空闲区说明表,顺序查看登记栏,找到第一个能满足要求的空闲区。当空闲区大于需要量时,一部分用来装入作业,另一部分仍为空闲区登记在空闲区说明表中。

    由于本实验是模拟主存的分配,所以把主存区分配给作业后并不实际启动装入程序装入作业,而用输出“分配情况”来代替。最先适应分配算法如图4-1。

    (3) 当一个作业执行结束撤离时,作业所占的区域应该归还,归还的区域如果与其它空闲区相邻,则应合成一个较大的空闲区,登记在空闲区说明表中。例如,在提示(1)中列举的情况下,如果作业2撤离,归还所占主存区域时,应与上、下相邻的空闲区一起合成一个大的空闲区登记在空闲区说明表中。归还主存时的回收算法如图4-2。

    (4) 请按最先适应算法设计主存分配和回收的程序。然后按主存中已装入三个作业,且形成两个空闲区,确定空闲区说明表的初值。现有一个需要主存量为6K的作业4申请装入主存;然后作业3撤离;再作业2撤离。请你为它们进行主存分配和回收,把空闲区说明表的初值以及每次分配或回收后的变化显示出来或打印出来。

    图1:最先适应分配模拟算法

     
     

    图2: 主存回收算法

     
     


     

     

     

     

    展开全文
  • 操作系统实验三 动态分区存储管理

    千次阅读 2020-05-08 20:32:23
    任务:用高级语言模拟实现动态分区存储管理。 二、内容、要求与安排 1、实验内容 分区分配算法至少实现首次适应算法、最佳适应算法和最坏适应算法中的至少一种。熟悉并掌握各种算法的空闲区组织方式。 分区的初始化...

    不要抄!好好写!
    在这里插入图片描述

    一、目的与任务
    目的:熟悉并掌握动态分区分配的各种算法,熟悉并掌握动态分区中分区回收的各种情况,并能够实现分区合并。
    任务:用高级语言模拟实现动态分区存储管理。
    二、内容、要求与安排
    1、实验内容
    分区分配算法至少实现首次适应算法、最佳适应算法和最坏适应算法中的至少一种。熟悉并掌握各种算法的空闲区组织方式。
    分区的初始化——可以由用户输入初始分区的大小。(初始化后只有一个空闲分区,起始地址为0,大小是用户输入的大小)
    分区的动态分配过程:由用户输入作业号和作业的大小,实现分区过程。
    分区的回收:用户输入作业号,实现分区回收,同时,分区的合并要体现出来。(注意:不存在的作业号要给出错误提示!)
    分区的显示:任何时刻,可以查看当前内存的情况(起始地址是什么,大小多大的分区时空闲的,或者占用的,能够显示出来)。
    2、实验要求
    (1)内存空间不足的情况,要有相应的显示;
    (2)作业不能同名,但是删除后可以再用这个名字;
    (3)作业空间回收是输入作业名,回收相应的空间,如果这个作业名不存在,也要有相应的提示。
    (4)要求实现FF、BF、WF算法中至少两种算法。
    (5)实验完成后要参加实验答辩。

    #include <iostream>
    #include <stdio.h>
    #include <stdlib.h>
    using namespace std;
    
    typedef struct job *List;
    struct job
    {
        int num;
        int m_begin;
        int m_size;
        int m_end;
        bool status;
        List Next;
        void set_date(int num, int m_begin, int m_size, bool status)
        {
            this->num = num;
            this->m_begin = m_begin;
            this->m_size = m_size;
            this->m_end = m_begin + m_size - 1;
            this->status = status;
        }
    };
    
    List Using, Free;
    int algType;
    job *Map[10000];
    
    void in_it();
    void solve();
    void FF();
    void m_malloc();
    void m_free();
    void merge_check(List L, job* t);
    void show();
    List MakeEmpty();
    void Insert(List L, job *t);
    void Delete(List L, job *t);
    int menu();
    
    int main()
    {
        in_it();
        solve();
    
    }
    
    void in_it()
    {
        Using = MakeEmpty();
        Free = MakeEmpty();
        for(int i=0; i<10000; i++)
            Map[i] = NULL;
        printf("Input memory size:");
        int m;
        while(scanf("%d", &m), m<=0)
            printf("!!! Illegal, input again:");
        job *t = (job*)malloc(sizeof(struct job));
        t->set_date(-1, 0, m, false);
        t->Next = NULL;
        Insert(Free, t);
    }
    void solve()
    {
        printf("FF,1\n");
        printf("WF,2\n");
        while(scanf("%d", &algType), algType!=1&&algType!=2)
            printf("!!! Illegal, input again:");
        int flag;
        while( (flag = menu()) )
        {
            switch(flag)
            {
            case 1:
                m_malloc();
                break;
            case 2:
                m_free();
                break;
            case 3:
                show();
                break;
            case -1:
                printf("!!! Illegal, input again:\n");
                break;
            }
        }
    }
    void m_malloc()
    {
        int num, m_size;
        printf("Input job num and size:");
        scanf("%d%d", &num, &m_size);
        if(Map[num] != NULL)
        {
            printf("!!! Num repeat, input again:\n");
            return;
        }
        List Temp = Free;
        if(algType == 1)
        {
            while(Temp->Next != NULL)
            {
                Temp = Temp->Next;
                if(Temp->m_size >= m_size)
                {
                    job *t = (job*)malloc(sizeof(struct job));
                    t->set_date(num, Temp->m_begin, m_size, true);
                    t->Next = NULL;
                    Map[num] = t;
                    Insert(Using, t);
                    Temp->m_begin += m_size;
                    Temp->m_size -= m_size;
                    if(Temp->m_size == 0)
                        Delete(Free, Temp);
                    printf("Create succeed\n");
                    return;
                }
            }
        }
        else
        {
            job* Max = Temp;
            while(Temp->Next != NULL)//与FF唯一的区别就是在空闲内存块中取内存最大的
            {
                Temp = Temp->Next;
                if(Temp->m_size >= Max->m_size)
                    Max = Temp;
            }
            Temp = Max;
            if(Temp->m_size >= m_size)
            {
                job *t = (job*)malloc(sizeof(struct job));
                t->set_date(num, Temp->m_begin, m_size, true);
                t->Next = NULL;
                Map[num] = t;
                Insert(Using, t);
                Temp->m_begin += m_size;
                Temp->m_size -= m_size;
                if(Temp->m_size == 0)
                    Delete(Free, Temp);
                printf("Create succeed\n");
                return;
            }
        }
        printf("!!! Memory full\n");
    }
    void m_free()
    {
        int num;
        printf("Input job num:");
        scanf("%d", &num);
        if(Map[num] == NULL)
        {
            printf("!!! Num miss, input again:\n");
            return;
        }
        job* Temp = Map[num];
    
        job *t = (job*)malloc(sizeof(struct job));
        t->set_date(-1, Temp->m_begin, Temp->m_size, false);
        t->Next = NULL;
        Insert(Free, t);
        Delete(Using, Temp);
        Map[num] = NULL;
        printf("Free succeed\n");
        merge_check(Free, t);
    }
    void merge_check(List L, job* t)
    {
        List Temp = L;
        while(Temp->Next != t)
            Temp = Temp->Next;
        if(t->Next != NULL && t->m_end+1 == t->Next->m_begin)//向下合并
        {
            t->m_end = t->Next->m_end;
            t->m_size += t->Next->m_size;
            t->Next = t->Next->Next;
            printf("Down Merge succeed\n");
        }
        if(Temp->m_end+1 == Temp->Next->m_begin)//向上合并
        {
            Temp->m_end = t->m_end;
            Temp->m_size += t->m_size;
            Temp->Next = t->Next;
            free(t);
            printf("Up Merge succeed\n");
        }
    }
    void show()
    {
        printf("%s\t%s\t%s\t%s\t%s\n", "num", "begin", "end", "size", "use");
        List t1 = Using->Next, t2 = Free->Next;
        while(t1 != NULL && t2 != NULL)
        {
            if(t1->m_begin < t2->m_begin)
            {
                printf("%d\t%d\t%d\t%d\t%d\n", t1->num, t1->m_begin, t1->m_end, t1->m_size, t1->status);
                t1 = t1->Next;
            }
            else
            {
                printf("%d\t%d\t%d\t%d\t%d\n", t2->num, t2->m_begin, t2->m_end, t2->m_size, t2->status);
                t2 = t2->Next;
            }
        }
        while(t1 != NULL)
        {
            printf("%d\t%d\t%d\t%d\t%d\n", t1->num, t1->m_begin, t1->m_end, t1->m_size, t1->status);
            t1 = t1->Next;
        }
        while(t2 != NULL)
        {
            printf("%d\t%d\t%d\t%d\t%d\n", t2->num, t2->m_begin, t2->m_end, t2->m_size, t2->status);
            t2 = t2->Next;
        }
    }
    
    List MakeEmpty()
    {
        List L;
        L = (List)malloc(sizeof(struct job));
        L->Next = NULL;
        return L;
    }
    void Insert(List L, job *t)
    {
        if(L->Next == NULL)
        {
            L->Next = t;
            return;
        }
        List Temp = L;
        while(t->m_begin > Temp->Next->m_begin)
        {
            Temp = Temp->Next;
            if(Temp->Next == NULL)
            {
                Temp->Next = t;
                return;
            }
        }
        t->Next = Temp->Next;
        Temp->Next = t;
        return;
    }
    void Delete(List L, job *t)
    {
        List Temp = L;
        while(Temp->Next != t)
            Temp = Temp->Next;
        Temp->Next = t->Next;
        free(t);
    }
    
    int menu()
    {
        printf("--------------------\n");
        printf("Create:1\n");
        printf("Free:2\n");
        printf("View Info:3\n");
        printf("Over Input:0\n");
        printf("Plase Input A Num:");
        int m;
        scanf("%d",&m);
        switch(m)
        {
        case 0:
        case 1:
        case 2:
        case 3:
            return m;
            break;
        default:
            return -1;
        }
    
        return m;
    }
    /*
    50
    1
    1 1 5
    3
    1 2 5
    3
    1 3 5
    3
    2 2
    3
    1 4 3
    3
    */
    
    
    展开全文
  • 操作系统 【动态分区分配存储管理】 一、设计任务: 动态分区分配存储管理 二、设计要求: ● 建立描述内存分配状况的数据结构; ● 建立描述进程的数据结构; ● 使用两种方式产生进程:(a)自动产生, (b)...
  • 操作系统实验_动态分区存储管理方式的主存分配回收 功能: 《计算机操作系统》实验 首次适应性算法 摸拟 动态分区 存储管理方式的主存 分配 和 回收
  • 操作系统老师留的作业,动态分区存储管理方式的主存分配回收
  • 操作系统 实验3【动态分区存储管理
    1. 操作系统 实验1【短作业优先调度算法(C++实现——FCFS\SJF\HRRN)】
    2. 操作系统 实验2【动态高优先权优先调度算法 C++实现】
    3. 操作系统 实验3【动态分区存储管理 Python实现】
    4. 操作系统 实验4【基本分页存储管理 C++实现】

    目录

    一、实验目的(目的与任务)

    二、实验内容(内容、要求与安排方式)

    三、实验代码

    ①创建表示分区的类,类包含:分区ID、起始地址、结束地址、分区长度、分区状态

    ②导入python模块,方便拷贝分区对象

    ③编写表示分区状态的函数

    ④编写冒泡排序函数

    ⑤编写首次适应算法(First Fit)函数

    ⑥编写最佳适应算法(Best Fit)函数

    ⑦回收内存(作业)函数

    ⑧编写主函数

    完整实验代码

    四、实验结果

    五、实验总结


    一、实验目的(目的与任务)

    熟悉并掌握动态分区分配的各种算法。

    熟悉并掌握动态分区中分区回收的各种情况,并能够实现分区合并。

    二、实验内容(内容、要求与安排方式)

    用高级语言模拟实现动态分区存储管理,要求:

    1. 分区分配算法至少实现首次适应算法、最佳适应算法和最坏适应算法中的至少一种。熟悉并掌握各种算法的空闲区组织方式。
    2. 分区的初始化——可以由用户输入初始分区的大小。(初始化后只有一个空闲分区,起始地址为0,大小是用户输入的大小)
    3. 分区的动态分配过程:由用户输入作业号和作业的大小,实现分区过程。
    4. 分区的回收:用户输入作业号,实现分区回收,同时,分区的合并要体现出来。(注意:不存在的作业号要给出错误提示!)
    5. 分区的显示:任何时刻,可以查看当前内存的情况(起始地址是什么,大小多大的分区时空闲的,或者占用的,能够显示出来)
    6. 要求考虑:(1)内存空间不足的情况,要有相应的显示;

          (2)作业不能同名,但是删除后可以再用这个名字;

          (3)作业空间回收是输入作业名,回收相应的空间,如果这个作业名不存在,也要有相应的提示。

    三、实验代码

    ①创建表示分区的类,类包含:分区ID、起始地址、结束地址、分区长度、分区状态

    class Memory(object):

        def __init__(selfstartendlengthstate=1ID=0):

            self.Id = ID  ##ID0是未分配,其余为任务编号

            self.start = start

            self.end = end

            self.length = length

            self.state = state  # state1:内存未分配

    ②导入python模块,方便拷贝分区对象

    import copy 导入python模块,copy仅拷贝对象本身

    ③编写表示分区状态的函数

    def show_memory(list):

        print("分配状态    分区号    起始地址   终止地址  分区大小")

        for i in range(0len(list)):

            p = list[i]

            if p.state == 1:

                print("%s%s%s%11.d%11.d%10.d" % ('空闲'"          ", p.Id, p.start, p.end, p.length))

            else:

                print("%s%s%s%11.d%11.d%10.d" % ('已分配'"        ", p.Id, p.start, p.end, p.length))

    ④编写冒泡排序函数

    ##冒泡排序

    def bubble_sort(list):

        count = len(list)

        for i in range(0, count):

            for j in range(i + 1, count):

                if list[i].length < list[j].length:

                    list[i], list[j] = list[j], list[i]

        return list

    ⑤编写首次适应算法(First Fit)函数

    首次适应算法(First Fit

    def FF(work_idwork_lengthlist):

        for i in list:

            if i.Id == work_id:

                print('作业已存在!')

                return

        for i in range(0len(list)):

            p = list[i]

            if p.state == 1 and p.length > work_length:  # p是当前未分配内存的大小

                node2 = Memory(p.start + work_length, p.end, p.length - work_length, 10)  剩下的未分配的

                a = Memory(p.start, p.start + work_length - 1, work_length, state=0ID=work_id)  # a是已分配的

                del list[i]

                list.insert(i, node2)

                list.insert(i, a)

                show_memory(list)

                return

            if p.state == 1 and p.length == work_length:

                p.state = 0

                show_memory(list)

                return

        print("内存空间不足!")

    ⑥编写最佳适应算法(Best Fit)函数

    ##最佳适应算法(Best Fit

    def BF(work_idwork_lengthli):

        for i in li:

            if i.Id == work_id:

                print('作业已存在!')

                return

        q = copy.copy(li)

        q = bubble_sort(q)  从小到大排序,给所有已分配和未分配的排序

        s = -1

        ss12 = -1

        for i in range(0len(q)):

            p = q[i]

            if p.state == 1 and p.length > work_length:  # p.state == 1 已分配的不参与分配

                s = p.start  # s得到起始位置

            elif p.state == 1 and p.length == work_length:

                ss12 = p.start

        if s == -1 and ss12 == -1:

            print("内存空间不足!")

            return

        for i in range(0len(li)):

            p = li[i]

            if p.start == s:

                node2 = Memory(p.start + work_length, p.end, p.length - work_length, 10)  未分配

                a = Memory(p.start, p.start + work_length - 1, work_length, state=0ID=work_id)

                del li[i]

                li.insert(i, node2)

                li.insert(i, a)

                show_memory(li)

                return

            elif p.start == ss12:

                p.state = 0

                show_memory(li)

                return

     

    ⑦回收内存(作业)函数

    ##回收内存(作业)函数

    def free1(work_idli):

        for i in range(0len(li)):

            p = li[i]

            if p.Id == work_id:

                p.state = 1

                target = i

                p.Id = 0

                break

        向前合并空闲块

        if target - 1 > 0:

            if li[target - 1].state == 1:

                a = Memory(li[target - 1].start, li[target].end, li[target - 1].length + li[target].length, 10)

                del li[target - 1]

                del li[target - 1]

                li.insert(target - 1, a)

                target = target - 1

        向后合并空闲块

        if target + 1 < len(li):

            if li[target + 1].state == 1:

                a = Memory(li[target].start, li[target + 1].end, li[target].length + li[target + 1].length, 10)

                del li[target]

                del li[target]

                li.insert(target, a)

        show_memory(li)

    ⑧编写主函数

    if __name__ == '__main__':

        print("输入内存大小:")

        size = int(input())

        a = Memory(0, size - 1, size, state=1ID=0)

        b = []

        b.append(a)

        print('*******1:初始化******')

        print('*******2:分配空间****')

        print('*******3:回收********')

        print('*******4:查看********')

        print('*******5:退出********')

        while (True):

            select = input('请输入想要执行的功能:')

            if select == '5':

                break

            elif select == '1':

                print("输入内存大小:")

                size = int(input())

                a = Memory(0, size - 1, size, state=1ID=0)

                b = []

                b.append(a)

            elif select == '2':

                print("1.首次适应算法:FF")

                print("2.最佳适应算法:BF")

                x = input("请输入分配执行的算法:")

                x = float(x)

                repit = 'Y'

                while (repit == 'Y'):

                    if x == 1:

                        work_size = input('请输入作业id和大小:').split()

                        FF(work_size[0], int(work_size[1]), b)

                        repit = input('是否继续(Y/N):')

                    elif x == 2:

                        work_size = input('请输入作业id和大小:').split()

                        BF(work_size[0], int(work_size[1]), b)

                        repit = input('是否继续(Y/N):')

            elif select == '3':

                id_delete = input('请输入删除作业id')

                free1(id_delete, b)

            else:

                show_memory(b)

    完整实验代码

    import copy  # 导入python模块,copy仅拷贝对象本身
    
    
    # 创建表示分区的类,类包含:分区ID、起始地址、结束地址、分区长度、分区状态
    class Memory(object):
        def __init__(self, start, end, length, state=1, ID=0):  # __init__()方法是一种特殊的方法,被称为类的初始化方法,当创建这个类的实例时就会调用该方法
            # self代表类的实例,self在定义类的方法时是必须有的,虽然在调用时不必传入相应的参数
            self.Id = ID  ##ID为0是未分配,其余为任务编号
            self.start = start
            self.end = end
            self.length = length
            self.state = state  # state为1:内存未分配
    
    
    # 编写表示分区状态的函数
    def show_memory(list):
        print("分配状态    分区号    起始地址   终止地址  分区大小")
        for i in range(0, len(list)):
            p = list[i]
            if p.state == 1:
                print("%s%s%s%11.d%11.d%10.d" % ('空闲', "          ", p.Id, p.start, p.end, p.length))
            else:
                print("%s%s%s%11.d%11.d%10.d" % ('已分配', "        ", p.Id, p.start, p.end, p.length))
    
    
    # 首次适应算法(First Fit)
    def FF(work_id, work_length, list):
        for i in list:
            if i.Id == work_id:
                print('作业已存在!')
                return
        for i in range(0, len(list)):
            p = list[i]
            if p.state == 1 and p.length > work_length:  # p是当前未分配内存的大小
                node2 = Memory(p.start + work_length, p.end, p.length - work_length, 1, 0)  # 剩下的未分配的
                a = Memory(p.start, p.start + work_length - 1, work_length, state=0, ID=work_id)  # a是已分配的
                del list[i]
                list.insert(i, node2)
                list.insert(i, a)
                show_memory(list)
                return
            if p.state == 1 and p.length == work_length:
                p.state = 0
                show_memory(list)
                return
        print("内存空间不足!")
    
    
    # 回收内存(作业)函数
    def free1(work_id, li):
        for i in range(0, len(li)):
            p = li[i]
            if p.Id == work_id:
                p.state = 1
                target = i
                p.Id = 0
                break
        # 向前合并空闲块
        if target - 1 > 0:
            if li[target - 1].state == 1:
                a = Memory(li[target - 1].start, li[target].end, li[target - 1].length + li[target].length, 1, 0)
                del li[target - 1]
                del li[target - 1]
                li.insert(target - 1, a)
                target = target - 1
        # 向后合并空闲块
        if target + 1 < len(li):
            if li[target + 1].state == 1:
                a = Memory(li[target].start, li[target + 1].end, li[target].length + li[target + 1].length, 1, 0)
                del li[target]
                del li[target]
                li.insert(target, a)
        show_memory(li)
    
    
    # 冒泡排序
    def bubble_sort(list):
        count = len(list)
        for i in range(0, count):
            for j in range(i + 1, count):
                if list[i].length < list[j].length:
                    list[i], list[j] = list[j], list[i]
        return list
    
    
    # 最佳适应算法(Best Fit)
    def BF(work_id, work_length, li):
        for i in li:
            if i.Id == work_id:
                print('作业已存在!')
                return
        q = copy.copy(li)
        q = bubble_sort(q)  # 从小到大排序,给所有已分配和未分配的排序
        s = -1
        ss12 = -1
        for i in range(0, len(q)):
            p = q[i]
            if p.state == 1 and p.length > work_length:  # p.state == 1,已分配的不参与分配
                s = p.start  # s得到起始位置
            elif p.state == 1 and p.length == work_length:
                ss12 = p.start
        if s == -1 and ss12 == -1:
            print("内存空间不足!")
            return
        for i in range(0, len(li)):
            p = li[i]
            if p.start == s:
                node2 = Memory(p.start + work_length, p.end, p.length - work_length, 1, 0)  # 未分配
                a = Memory(p.start, p.start + work_length - 1, work_length, state=0, ID=work_id)
                del li[i]
                li.insert(i, node2)
                li.insert(i, a)
                show_memory(li)
                return
            elif p.start == ss12:
                p.state = 0
                show_memory(li)
                return
    
    
    # 主函数
    if __name__ == '__main__':
        print("输入内存大小:")
        size = int(input())
        a = Memory(0, size - 1, size, state=1, ID=0)
        b = []
        b.append(a)
        print('*******1:初始化******')
        print('*******2:分配空间(FF\BF)****')
        print('*******3:回收********')
        print('*******4:查看********')
        print('*******5:退出********')
        while (True):
            select = input('请输入想要执行的功能:')
            if select == '5':
                break
            elif select == '1':
                print("输入内存大小:")
                size = int(input())
                a = Memory(0, size - 1, size, state=1, ID=0)
                b = []
                b.append(a)
            elif select == '2':
                print("1.首次适应算法:FF")
                print("2.最佳适应算法:BF")
                x = input("请输入分配执行的算法:")
                x = float(x)
                repit = 'Y'
                while (repit == 'Y'):
                    if x == 1:
                        work_size = input('请输入作业id和大小:').split()
                        FF(work_size[0], int(work_size[1]), b)
                        repit = input('是否继续(Y/N):')
                    elif x == 2:
                        work_size = input('请输入作业id和大小:').split()
                        BF(work_size[0], int(work_size[1]), b)
                        repit = input('是否继续(Y/N):')
            elif select == '3':
                id_delete = input('请输入删除作业id:')
                free1(id_delete, b)
            else:
                show_memory(b)

    四、实验结果

    BF算法有一点小毛病儿:两个相同的分区,比如2个20,这个BF是从末尾地址开始分配的;不能这样写,应该从低地址开始分配。

       

    五、实验总结

    动态分区分配算法包括如下4种算法:首次适应算法(First Fit)、最佳适应算法(Best Fit)、最坏适应算法(Worst Fit)、临近适应算法(Next Fit)。

    动态分区管理方式,在初始时不将主存划分区域,而是把占用区域外的空间看作一个大的空闲区。当作业要求装入主存时,根据作业的大小查询主存内各空闲区的状态,按照特定的算法选择一个合适的空闲区,按作业大小划分出一个分区并装入该作业,剩下的区域作为新的空闲区。

    当作业执行完毕后,所占用的主存空间将被回收,成为一个空闲区;如果该空闲区的相邻分区也是空闲区,则需要将相邻空闲区合并成一个空闲区。

       通过本次实验,我对动态分区分配算法有了更深的理解,将4种算法的特点整理如下:

    算法

    算法思想

    分区排列顺序

    优点

    缺点

    首次适应算法

    从头到尾寻找合适的分区

    空闲分区以地址递增次序排列

    综合看,首次适应算法性能最好。算法开销小,回收分区后,一般不需要对空闲分区队列重新排序

    略!

    最佳适应算法

    优先使用更小的分区,以保留更多的大分区

    空闲分区以容量递增次序排列

    会有更多的大分区被保留下来,更能满足大进程需求

    会产生很多太小的、难以利用的碎片:算法开销大,回收分区后可能需要对空闲分区队列重新排序

    最坏适应算法

    优先使用更大的分区,以防止产生太小的不可用碎片

    空闲分区以容量递减次序排列

    可以减少难以利用的小碎片

    大分区容易被用完,不利于大进程:算法开销大(原因同上)

    临近适应算法

    由首次适应算法演变而来,每次从上次查找结束的位置开始查找

    空闲分区以地址递增次序排列(可排列成循环链表)

    不用每次都从低地址的小分区开始检索。算法开销小(原因同首次适应算法)

    会使高地址的大分区也被用完

    展开全文
  • 本设计的目的是使学生熟悉存储器管理系统的设计方法;加深对所学各种存储器管理方案的了解;要求采用一些常用的存储器分配算法,设计一个存储器管理模拟系统并调试运行
  • 基于C/C++模拟处理机调度、存储管理动态分区分配、分页存储地址转换)和文件系统 基于C/C++模拟处理机调度、存储管理动态分区分配、分页存储地址转换)和文件系统 基于C/C++模拟处理机调度、存储管理...
  • C++源码和设计文档 内存动态分区管理 适合初学者
  • 一实验目的 通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解熟悉可变分区存 储管理的内存分配和回收 二实验内容 确定内存空间分配表 采用最优适应算法完成内存空间的分配和回收 编写主函数对所做工作...
  • 操作系统存储管理算法 首次适应、最佳适应、最差适应算法 输入: 1)当前内存空闲分区的序列,包括起始地址、空闲分区大小。 2)进程的分区请求序列。 输出要求: 1)三种算法的空闲分区队列。 2)三种算法的分配...
  • 可变分区方式是按作业需要的主存空间大小来分区。当装入一个作业时,首先要查看是否有足够的空闲空间来分配,若有则按指定的分配方式进行分配;否则作业不能装入。 首次适应算法:在空闲区间中查询满足作业需要的...
  • c++模拟实现动态分区存储管理,用c++模拟实现动态分区存储管理,用c++模拟实现动态分区存储管理,用c++模拟实现动态分区存储管理,用c++模拟实现动态分区存储管理
  • C++模拟操作系统动态分区存储管理中最佳适应算法的实现
  • 可变分区存储管理

    2013-12-23 21:12:44
    可变分区存储管理 源代码,C,推荐给初学者参考使用
  • 操作系统的动态分区分配代码
  • 操作系统 动态分区存储管理 实验要求 通过编写动态分区存储管理的模拟程序,加深对操作系统存储管理功能中的动态分区管理方式、空闲分区表等相应知识的理解。 实验内容 实现动态分区存储管理方式下存储空间的分配和...
  • 实验三 使用动态分区分配方式的模拟 1实验目的 了解动态分区分配方式中使用的数据结构和分配算法并进一步加深对动态分区存储管理方式及其实现过程的理解 2实验内容 (1) 用C语言分别实现采用首次适应算法和最佳适应...
  • 时间片轮转调度算法

    2018-11-20 09:07:16
    分区的回收:用户输入作业号,实现分区回收,同时,分区的合并要体现出来。(注意:不存在的作业号要给出错误提示!)这里的允许碎片大小为5k
  • 操作系统实习:动态分区分配(C++实现)包含源程序和运行结果

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 30,400
精华内容 12,160
关键字:

动态分区存储管理c++

c++ 订阅