实验四--动态分区分配方式的模拟-答案
动态分区分配方式的模拟
动态分区分配方式的模拟动态分区分配方式是计算机中内存管理的一种重要方式。
在动态分区分配方式中,内存空间被分割为多个不同大小的分区,每个分区可以被进程占用。
当一个进程需要内存时,系统会为其分配一个适当大小的分区,进程结束后,该分区将会被释放出来供其他进程使用。
为了更好地理解动态分区分配方式的原理和实际运作,可以通过模拟的方法来观察和分析。
下面是一个简单的动态分区分配方式的模拟过程:假设我们有一块容量为6400KB的内存,要模拟分配4个进程的情况。
这4个进程的内存需求分别是1000KB,2000KB,500KB和300KB。
首先,我们可以将内存划分为几个分区,每个分区的大小根据需要进行调整。
可以设置整块内存为一块分区(大小为6400KB),或者划分成多个较小的分区。
由于这里有4个进程需要分配内存,我们可以为它们设置4个分区,分别为P1,P2,P3和P41.初始状态:内存:[6400KB](未分配)进程:P1,P2,P3,P4(空)2.分配P1:内存:[1000KB](P1)、[5400KB](未分配)进程:P1,P2,P3,P4P1占用了1000KB的内存,剩余空间为5400KB。
3.分配P2:内存:[1000KB](P1)、[2000KB](P2)、[3400KB](未分配)进程:P1,P2,P3,P4P2占用了2000KB的内存,剩余空间为3400KB。
4.分配P3:内存:[1000KB](P1)、[2000KB](P2)、[500KB](P3)、[2900KB](未分配)进程:P1,P2,P3,P4P3占用了500KB的内存,剩余空间为2900KB。
5.分配P4:内存:[1000KB](P1)、[2000KB](P2)、[500KB](P3)、[300KB](P4)、[2600KB](未分配)进程:P1,P2,P3,P4P4占用了300KB的内存,剩余空间为2600KB。
在模拟的过程中,我们可以看到进程在内存中的分配情况和未分配内存的变化。
循环首次适应的动态分区分配算法模拟
循环首次适应的动态分区分配算法模拟1.初始化内存空间为一个整体的空闲块。
2.当进程请求内存空间时,多次内存空闲块的循环链表,直到找到一个合适大小的空闲块为止。
3.如果找到了合适的空闲块,则将其划分为两个部分,一个部分给予进程使用,另一个部分保留为新的空闲块。
4.如果未找到合适的空闲块,则表示内存空间不足,需要进行深度缺页异常处理。
以下是一个循环首次适应算法的模拟过程:1.假设一个内存空间大小为1000KB,初始时为一个整体的空闲块。
2.进程A请求100KB的内存空间,开始内存空闲块链表。
3.如果找到合适的空闲块(大小≥100KB),则将其划分为两个部分,一个部分分配给进程A,另一个部分保留为新的空闲块。
4.进程B请求200KB的内存空间,继续内存空闲块链表。
5.如果找到合适的空闲块(大小≥200KB),则将其划分为两个部分,一个部分分配给进程B,另一个部分保留为新的空闲块。
6.进程C请求150KB的内存空间,继续内存空闲块链表。
7.找到合适的空闲块(大小≥150KB),将其划分为两个部分,一个部分分配给进程C,另一个部分保留为新的空闲块。
8.进程D请求300KB的内存空间,继续内存空闲块链表。
但此时已经循环了一次,仍未找到合适的空闲块。
9.进行深度缺页异常处理,即向操作系统申请更多的内存空间。
10.操作系统分配一块500KB的空闲块给进程D。
11.继续内存空闲块链表,找到合适的空闲块(大小≥300KB)。
12.将其划分为两个部分,一个部分分配给进程D,另一个部分保留为新的空闲块。
13.进程E请求250KB的内存空间,继续内存空闲块链表。
14.找到合适的空闲块(大小≥250KB),将其划分为两个部分,一个部分分配给进程E,另一个部分保留为新的空闲块。
15.当所有进程运行完毕后,剩余的空闲块可以继续加入链表,供下一次的分配请求使用。
总结起来,循环首次适应算法通过循环链表合适大小的空闲块来满足进程的内存需求,能够最大限度地利用内存空间,避免了内存碎片的产生。
动态内存分区分配方式模拟
“计算机操作系统”课程设计实验报告动态内存分区分配方式模拟学生姓名专业名称学号目录1 题目要求 (1)2 设计思想 (1)3 数据定义 (2)4 处理流程 (3)5 源程序 (6)6 运行结果 (15)7 设计体会 (22)动态内存分区分配方式模拟1题目要求假设初始态下,可用内存空间为640K,并有下列请求序列,请分别用首次适应算法和最佳适应算法为作业分配和回收内存块,并显示出每次分配和回收后的空闲分区链的情况来以及内存占用情况图。
作业1申请130K作业2申请60K作业3申请100k作业2释放60K作业4申请200K作业3释放100K作业1释放130K作业5申请140K作业6申请60K作业7申请50K作业6释放60K2设计思想根据题目要求,要用首次适应算法和最佳适应算法分别实现内存的动态分区,因此先介绍一下这两种算法的基本思想:首次适应算法中,空闲分区链是按地址递增的次序链接的,当要分配内存空间时,就查表,在各空闲分区中查找满足大小要求的可用块,只要找到第一个足以满足要求的空间就停止查找,并把它分配出去,如果该空闲空间与所需空间大小一样,则将该分区的状态改为1,即已被分配,若还有剩余,则将剩余空间重新划为一个空闲分区,有新的起始地址,状态为0。
最佳适应算法的空闲链是按照空闲块的大小为序、按增量方式排列的,即小块在前,大块在后,它在满足需要的前提下,尽量分配最小的空闲块,这样每次查找分配时第一次找到的能满足要求的必然的最佳的,若空闲空间大小与要分配的大小相差不多时,可直接将其状态改为1即可,若有剩余,则将剩余空闲空间重新划分为一个空闲区,并根据空闲区的大小对链表进行重新排序。
首次适应算法的回收过程相对简单,因为分区链是按照地址顺序链接的,因此释放内存时只需要判断要释放的分区前后是否也为空闲区,然后根据情况看是要跟前边或后边或前后都合并为一个大的空闲区,如果前后分区都已分配,则直接将该分区状态改为0即可。
存储管理——动态分区分配回收算法的模拟
齐齐哈尔大学操作系统课程综合实践题目:存储管理——动态分区分配/回收算法的模拟班级:0姓名:0学号:0指导教师:02011年 12 月综合实践评分表班级0 姓名0 指导教师0 题目:存储管理---动态分区分配/回收算法的模拟评分标准评分标准分数权重评分的依据得分A C选题10 选题符合大纲要求,题目较新颖,工作量大选题基本符合大纲要求,工作量适中工作态度10 态度端正,能主动认真完成各个环节的工作,不迟到早退,出勤好。
能够完成各环节基本工作,出勤较好。
存储结构、算法描述20能正确选择存储结构,定义准确,算法流程图或类C语言描述的算法准确无误能正确选择存储结构,算法流程图或类C语言描述的算法基本准确独立解决问题的能力10具有独立分析、解决问题能力,有一定的创造性,能够独立完成软件的设计与调试工作,程序结构清晰,逻辑严谨,功能完善。
有一定的分析、解决问题能力。
能够在老师指导下完成软件的设计与调试工作,程序功能较完善。
答辨问题回答20 能准确回答老师提出的问题能基本准确回答老师提出的问题程序运行情况10 程序运行正确、界面清晰,测试数据设计合理。
程序运行正确、界面较清晰,能给出合适的测试数据。
综合实践报告20 格式规范,层次清晰,设计思想明确,解决问题方法合理,体会深刻。
格式较规范,设计思想基本明确,解决问题方法较合理。
总分指导教师(签字):注:介于A和C之间为B级,低于C为D级和E级。
按各项指标打分后,总分在90~100为优,80~89为良,70~79为中,60~69为及格,60分以下为不及格。
存储管理---动态分区分配/回收算法的模拟摘要:主存的分配和回收的实现是与住存储器的管理方式有关的。
解决多进程如何共享主存空间的问题。
当进程运行完时将进程所占的主存空间归还给系统。
可变分区存储管理方式,分区分配中所用的数据就够采用空闲分区说明表和空闲分区链表来进行。
关键字:内存分配,空闲分区表,进程申请队列一、【实践目的】:1、熟悉主存分配与回收2、理解在不同的存储管理方式,如何实现主存空间的分配与回收3、掌握动态分区分配方式中的数据结构和分配算法及动态分区存储管理方式及其实现过程。
动态分区分配方式的模拟实验原理说明
动态分区分配方式的模拟实验原理说明一、引言动态分区分配方式是操作系统中的一种内存管理方式,它将内存分为若干个不同大小的分区,根据进程的需求动态地分配内存。
在实际应用中,动态分区分配方式广泛应用于多任务操作系统中,如Windows、Linux等。
本文将介绍动态分区分配方式的模拟实验原理。
二、动态分区分配方式的基本原理动态分区分配方式是指在内存空间中按照进程需要划分出若干个不同大小的空间块,每个空间块可以被一个进程占用。
当有新进程需要内存时,操作系统会在空闲的空间块中选择一个大小合适的空间块给该进程使用。
当进程结束时,该进程所占用的空间块就会被释放出来,成为空闲块。
三、模拟实验环境搭建为了模拟动态分区分配方式,我们需要搭建一个虚拟机环境。
首先需要安装一款虚拟机软件(如VMware Workstation),然后安装一个操作系统(如Windows)。
接下来,在虚拟机中安装Visual Studio等开发工具。
四、模拟实验步骤1.设计数据结构为了方便管理内存空间,我们需要设计一种数据结构来存储内存块的信息。
我们可以使用链表来实现这一功能,每个节点表示一个内存块,包括该内存块的起始地址、大小以及状态(已分配或未分配)等信息。
2.初始化内存空间在模拟实验中,我们需要初始化一段虚拟内存空间。
我们可以使用一个数组来表示整个内存空间,并将其划分为若干个大小不同的空间块。
同时,我们需要将这些空间块的信息存储到链表中。
3.模拟进程请求内存在模拟实验中,我们需要模拟多个进程同时请求内存的情况。
当一个进程请求内存时,操作系统会根据其所需的内存大小,在空闲的空间块中选择一个合适的块分配给该进程,并将该块标记为已分配状态。
4.模拟进程释放内存当一个进程结束时,它所占用的内存块就会被释放出来,成为空闲块。
此时操作系统会更新链表信息,并将该块标记为未分配状态。
5.显示当前内存使用情况在模拟实验过程中,我们需要不断地显示当前的内存使用情况。
实验四动态分区分配算法
实验容:存储器管理实验一、实验目的采用首次适应算法〔FF〕,最正确适应算法〔BF〕,最坏适应算法〔WF〕三种不同的算法,实现对系统空闲区的动态分区分配。
二、实验题目给予顺序搜索的动态分区算法的程序。
三、实验要求读懂给出的核心代码,进展适当的修改,编译通过后,完成实验报告。
四、核心代码#include <stdio.h>#include <stdlib.h>#include <malloc.h>//常量定义#define PROCESS_NAME_LEN 32#define MIN_SLICE 10#define DEFAULT_MEM_SIZE 1024#define DEFAULT_MEM_START 0#define MA_FF 1#define MA_BF 2#define MA_WF 3int mem_size=DEFAULT_MEM_SIZE;int ma_algorithm = MA_FF;static int pid = 0;int flag = 0;struct free_block_type{int size;int start_addr;struct free_block_type *next;};struct free_block_type *free_block;//描述已分配的存块struct allocated_block{int pid; int size;int start_addr;char process_name[PROCESS_NAME_LEN];struct allocated_block *next;};struct allocated_block *allocated_block_head = NULL;//函数声明struct free_block_type* init_free_block(int mem_size);void display_menu();int set_mem_size();void set_algorithm();void rearrange(int algorithm);int rearrange_FF();int rearrange_BF();int rearrange_WF();int new_process();int allocate_mem(struct allocated_block *ab);void kill_process();int free_mem(struct allocated_block *ab);int dispose(struct allocated_block *free_ab);int display_mem_usage();void do_exit();struct allocated_block *find_process(int pid);int main(){char choice; pid=0;free_block= init_free_block(mem_size); //初始化空闲区while(1) {display_menu(); //显示菜单fflush(stdin);choice=getchar(); //获取用户输入switch(choice){case '1': set_mem_size(); break; //设置存大小case '2': set_algorithm();flag=1; break;//设置算法case '3': new_process(); flag=1; break;//创立新进程case '4': kill_process(); flag=1; break;//删除进程case '5': display_mem_usage(); flag=1; break; //显示存使用case '0': do_exit(); exit(0); //释放链表并退出default: break;}}return 1;}struct free_block_type* init_free_block(int mem_size){struct free_block_type *fb;fb=(struct free_block_type *)malloc(sizeof(struct free_block_type));if(fb==NULL){printf("No mem\n");return NULL;}fb->size = mem_size;fb->start_addr = DEFAULT_MEM_START;fb->next = NULL;return fb;}void display_menu(){printf("\n");printf("1 - Set memory size (default=%d)\n", DEFAULT_MEM_SIZE);printf("2 - Select memory allocation algorithm\n");printf("3 - New process \n");printf("4 - T erminate a process \n");printf("5 - Display memory usage \n");printf("0 - Exit\n");}int set_mem_size(){int size;if(flag!=0){ //防止重复设置printf("Cannot set memory size again\n");return 0;}printf("T otal memory size =");scanf("%d", &size);if(size>0) {mem_size = size;free_block->size = mem_size;}flag=1;return 1;}void set_algorithm(){int algorithm;while(1) {printf("\t1 - First Fit\n");printf("\t2 - Best Fit \n");printf("\t3 - Worst Fit \n");scanf("%d", &algorithm);if(algorithm>=1 && algorithm <=3) {ma_algorithm = algorithm;break;}elseprintf("输入有误,请重新输入!\n");}//按指定算法重新排列空闲区链表rearrange(ma_algorithm);}void rearrange(int algorithm){switch(algorithm){case MA_FF: rearrange_FF(); break;case MA_BF: rearrange_BF(); break;case MA_WF: rearrange_WF(); break;}}//首次适应算法int rearrange_FF(){struct free_block_type *temp;//使用头插法,thead为临时头,p为最小地址的数据块的前一个结点struct free_block_type *thead=NULL,*p=NULL;//当前的最小地址int min_addr = free_block->start_addr;temp = free_block;while(temp->next!=NULL) {if(temp->next->start_addr<min_addr) {min_addr = temp->next->start_addr;p = temp;}temp = temp->next;}if(NULL!=p) {temp = p->next;p->next = p->next->next;temp->next = free_block;free_block = temp;}thead = free_block;p = free_block;temp = free_block->next;while(thead->next!=NULL) {min_addr = thead->next->start_addr;while(temp->next!=NULL) {if(temp->next->start_addr<min_addr) {min_addr = temp->next->start_addr;p = temp;}temp = temp->next;}if(p->next!=thead->next) {temp = p->next;p->next = p->next->next;temp->next = thead->next;thead->next = temp;}thead = thead->next;p = thead;temp = thead->next;}return 1;}//最正确适应算法int rearrange_BF(){struct free_block_type *temp;//使用头插法,thead为临时头,p为最小存的数据块的前一个结点struct free_block_type *thead=NULL,*p=NULL;//当前的最小存int min_size = free_block->size;temp = free_block;while(temp->next!=NULL) {if(temp->next->size<min_size) {min_size = temp->next->size;p = temp;}temp = temp->next;}if(NULL!=p) {temp = p->next;p->next = p->next->next;temp->next = free_block;free_block = temp;}thead = free_block;p = free_block;temp = free_block->next;while(thead->next!=NULL) {min_size = thead->next->size;while(temp->next!=NULL) {if(temp->next->size<min_size) {min_size = temp->next->size;p = temp;}temp = temp->next;}if(p->next!=thead->next) {temp = p->next;p->next = p->next->next;temp->next = thead->next;thead->next = temp;}thead = thead->next;p = thead;temp = thead->next;}return 1;}//最坏适应算法int rearrange_WF(){struct free_block_type *temp;//使用头插法,thead为临时头,p为最大存的数据块的前一个结点struct free_block_type *thead=NULL,*p=NULL;//当前的最大存int max_size = free_block->size;temp = free_block;while(temp->next!=NULL) {if(temp->next->size>max_size) {max_size = temp->next->size;p = temp;}temp = temp->next;}if(NULL!=p) {temp = p->next;p->next = p->next->next;temp->next = free_block;free_block = temp;}thead = free_block;p = free_block;temp = free_block->next;while(thead->next!=NULL) {max_size = thead->next->size;while(temp->next!=NULL) {if(temp->next->size>max_size) {max_size = temp->next->size;p = temp;}temp = temp->next;}if(p->next!=thead->next) {temp = p->next;p->next = p->next->next;temp->next = thead->next;thead->next = temp;}thead = thead->next;p = thead;temp = thead->next;}return 1;}int new_process(){struct allocated_block *ab;int size;int ret;ab = (struct allocated_block *)malloc(sizeof(struct allocated_block));if(!ab) exit(-5);ab->next = NULL;pid++;sprintf(ab->process_name, "PROCESS-d", pid);ab->pid = pid;while(1) {printf("Memory for %s:", ab->process_name);scanf("%d", &size);if(size>0) {ab->size=size;break;}else printf("输入大小有误,请重新输入\n");}ret = allocate_mem(ab);if((ret==1) &&(allocated_block_head == NULL)){allocated_block_head=ab;return 1;}else if (ret==1) {ab->next = allocated_block_head;allocated_block_head = ab;return 2; }else if(ret==-1){printf("Allocation fail\n");pid--;free(ab);return -1;}return 3;}int allocate_mem(struct allocated_block *ab){struct free_block_type *fbt, *pre,*head,*temp,*tt;struct allocated_block *tp;int request_size=ab->size;int sum=0;int max;head = (struct free_block_type *)malloc(sizeof(struct free_block_type));pre = head;fbt = free_block;pre->next = fbt;if(ma_algorithm==MA_WF) {if(NULL==fbt||fbt->size<request_size)return -1;}else {while(NULL!=fbt&&fbt->size<request_size) {pre = fbt;fbt = fbt->next;}}if(NULL==fbt||fbt->size<request_size) {if(NULL!=free_block->next) {sum = free_block->size;temp = free_block->next;while(NULL!=temp) {sum += temp->size;if(sum>=request_size)break;temp = temp->next;}if(NULL==temp)return -1;else {pre = free_block;max = free_block->start_addr;fbt = free_block;while(temp->next!=pre) {if(max<pre->start_addr) {max = pre->start_addr;fbt = pre;}pre = pre->next;}pre = free_block;while(temp->next!=pre) {tp = allocated_block_head;tt = free_block;if(pre!=fbt) {while(NULL!=tp) {if(tp->start_addr>pre->start_addr)tp->start_addr = tp->start_addr - pre->size;tp = tp->next;}while(NULL!=tt) {if(tt->start_addr>pre->start_addr)tt->start_addr = tt->start_addr - pre->size;tt = tt->next;}}pre = pre->next;}pre = free_block;while(pre!=temp->next) {if(pre!=fbt)free(pre);pre = pre->next;}free_block = fbt;free_block->size = sum;free_block->next = temp->next;if(free_block->size - request_size < MIN_SLICE) {ab->size = free_block->size;ab->start_addr = free_block->start_addr;pre = free_block;free_block = free_block->next;free(pre);}else {ab->start_addr = fbt->start_addr;free_block->start_addr = free_block->start_addr + request_size;free_block->size = free_block->size - request_size;}}}elsereturn -1;}else {//将存块全局部配if(fbt->size - request_size < MIN_SLICE) {ab->size = fbt->size;ab->start_addr = fbt->start_addr;if(pre->next==free_block) {free_block = fbt->next;}elsepre->next = fbt->next;free(fbt);}else {ab->start_addr = fbt->start_addr;fbt->start_addr = fbt->start_addr + request_size;fbt->size = fbt->size - request_size;}}free(head);rearrange(ma_algorithm);return 1;}void kill_process(){struct allocated_block *ab;int pid;printf("Kill Process, pid=");scanf("%d", &pid);ab = find_process(pid);if(ab!=NULL){free_mem(ab);dispose(ab);}else {printf("没有pid为%d的进程!\n",pid);}}struct allocated_block *find_process(int pid) {struct allocated_block *ab=NULL;ab = allocated_block_head;while(NULL!=ab&&ab->pid!=pid)ab = ab->next;return ab;}int free_mem(struct allocated_block *ab){int algorithm = ma_algorithm;struct free_block_type *fbt, *pre=NULL,*head;fbt=(struct free_block_type*) malloc(sizeof(struct free_block_type));pre=(struct free_block_type*) malloc(sizeof(struct free_block_type));if(!fbt) return -1;// 进展可能的合并,根本策略如下// 1. 将新释放的结点插入到空闲分区队列末尾// 2. 对空闲链表按照地址有序排列// 3. 检查并合并相邻的空闲分区// 4. 将空闲链表重新按照当前算法排序head = pre;fbt->start_addr = ab->start_addr;fbt->size = ab->size;fbt->next = free_block; //新释放的结点插入到空闲分区链表的表头free_block = fbt;rearrange_FF(); //对空闲链表按照地址有序排列pre->next = free_block; //求的pre为fbt的前一个结点pre->size = 0;while(pre->next->start_addr!=fbt->start_addr)pre = pre->next;//左右分区都存在if(0!=pre->size&&NULL!=fbt->next) {//左右分区都可合并if((pre->start_addr+pre->size)==fbt->start_addr && (fbt->start_addr+fbt->size)==fbt->next->start_addr) {pre->size = pre->size + fbt->size + fbt->next->size;pre->next = fbt->next->next;free(fbt->next);free(fbt);}//左分区可合并else if((pre->start_addr+pre->size)==fbt->start_addr) {pre->size = pre->size + fbt->size;pre->next = fbt->next;free(fbt);}//右分区可合并else if((fbt->start_addr+fbt->size)==fbt->next->start_addr) {fbt->size = fbt->size + fbt->next->size;fbt->next = fbt->next->next;free(fbt->next);}}//左分区不存在else if(0==pre->size) {if((fbt->start_addr+fbt->size)==fbt->next->start_addr) {fbt->size = fbt->size + fbt->next->size;fbt->next = fbt->next->next;free(fbt->next);}}//右分区不存在else if(NULL==fbt->next) {if((pre->start_addr+pre->size)==fbt->start_addr) {pre->size = pre->size + fbt->size;pre->next = fbt->next;free(fbt);}}rearrange(algorithm);free(head);return 1;}int dispose(struct allocated_block *free_ab){struct allocated_block *pre, *ab;if(free_ab == allocated_block_head) {allocated_block_head = allocated_block_head->next;free(free_ab);return 1;}pre = allocated_block_head;ab = allocated_block_head->next;while(ab!=free_ab){ pre = ab; ab = ab->next; }pre->next = ab->next;free(ab);return 2;}int display_mem_usage(){struct free_block_type *fbt=free_block;struct allocated_block *ab=allocated_block_head;if(fbt==NULL) return(-1);printf("----------------------------------------------------------\n");printf("Free Memory:\n");printf(" s s\n", " start_addr", " size");while(fbt!=NULL){printf(" d d\n", fbt->start_addr, fbt->size);fbt=fbt->next;}printf("\nUsed Memory:\n");printf("s s s s\n", "PID", "ProcessName", "start_addr", " size");while(ab!=NULL){printf("d s d d\n", ab->pid, ab->process_name, ab->start_addr, ab->size);ab=ab->next;}printf("----------------------------------------------------------\n");return 0;}void do_exit() {}。
动态分区分配方式的模拟
this.work=work;
}
publicString getNumber() {
returnnumber;
}
publicvoidsetNumber(Stringnumber) {
this.number=number;
}
publicString getSize() {
pstmt = conn.prepareStatement(sql);
pstmt.setString(1, number);
int num = pstmt.executeUpdate();
System.out.println("删除"+num+"条数据");
}finally {
/*ConnectionFactory.close(null, pstmt, conn);*/
Connection conn = null;
PreparedStatement pstmt = null;
try {
conn = ConnectionFactory.getConnection();
String sql = " delete from zone where number = ?";
太原工业学院计算机工程系
操作系统实验报告()
实验名称
动态分区分配方式的模拟
实验日期
2016/12/3
成绩
姓名
班级学号
实
验
目
的
了解动态分区分配方式中使用的数据结构和分配算法,进一步加深对动态分区存储管理方式及其实现过程的理解
实
验
环
动态分区分配方式的模拟实验报告
if(L[i].rom-T[k].rom>Size)
{
L[i].sad=L[i].sad+T[k].rom;
L[i].rom=L[i].rom-T[k].rom;
L[i].state=1;
T[k].sad=L[i].sad-T[k].rom;
printf("内存分配成功!\n作业申请空间为%d\n起始地址为%d\n",T[k].rom,T[k].sad);
2. 给出初始状态、可用内存空间、请求序列,分别采用首次适应算法和最佳适应算法进行内存块的分配和回收,要求每次分配和回后显示出空闲内存分区链的情况(共有多个空闲分区,每个空闲分区的大小分别为多大)。
4.实验原理或流程图
首次适应算法(First-fit):当要分配内存空间时,就查表,在各空闲区中查找满足大小要求的可用块。只要找到第一个足以满足要球的空闲块就停止查找,并把它分配出去;如果该空闲空间与所需空间大小一样,则从空闲表中取消该项;如果还有剩余,则余下的部分仍留在空闲表中,但应修改分区大小和分区始址。
{
printf("请输入第%d个分区的信息:\n",i);
cin>>L[i].rom>>L[i].sad;
L[i].id=i;
L[i].state=0;
}
printf("输入完毕,当前空闲分区表状态为:\n");
print();
printf("请输入不再切割的剩余空间的大小:\n");
cin>>Size;
{
int id;///空闲分区编号
int sad;///空闲分区首地址
int rom;///空间
动态分区分配算法
计算机操作系统动态分区磁盘调度算法一个好的计算机系统不仅要有足够的存储容量,较高的存取速度和稳定可靠的存储器,而且能够合理的分配和使用这些主存空间。
当用户提出申请主存空间的要求时,存储管理能够按照一定的策略分析主存的使用情况,找出足够的空间分配给申请者;当作业运行完毕,存储管理要回收作业占用的主存空间。
本实验采取可变分区存储管理方法,用常用分区管理算法模拟磁盘管理过程,以加深了解操作系统的存储管理功能。
1. 本实验是模拟操作系统的主存分配,运用可变分区的存储管理算法设计主存分配和回收程序,并不实际启动装入作业。
2. 采用最先适应法、最佳适应法、最坏适应法分配主存空间。
3. 当一个新作业要求装入主存时,必须查空闲区表,从中找出一个足够大的空闲区。
若找到的空闲区大于作业需要量,这是应把它分成二部分,一部分为占用区,加一部分又成为一个空闲区。
4. 当一个作业撤离时,归还的区域如果与其他空闲区相邻,则应合并成一个较大的空闲区,登在空闲区表中。
5. 设计的模拟系统中,进程数不小于5,进程调度方式可以采用实验一中的任何一种。
6. 运行所设计的程序,输出有关数据结构表项的变化和内存的当前状态。
首次适应算法将内存中的空闲区按照地址由低到高的顺序形成空闲区表当一个新作业要求装入主存时,查空闲区表,从中找到第一个满足要求的空闲区,为作业分配主存空间,并将剩余空闲区按照地址由小到大的顺序插入空闲区表的合适位置,修改已分配表当作业运行结束后,回收作业的主存空间,并与相邻空闲区合并,修改空闲区表和已分配表每次主存分配和回收后,打印空闲区表和已分配表详细描述实验设计思想、程序结构及各模块设计思路;详细描述程序所用数据结构及算法;明确给出测试用例和实验结果;为增加程序可读性,在程序中进行适当注释说明;认真进行实验总结,包括:设计中遇到的问题、解决方法与收获等;#include<iostream>#include<cstdlib>using namespace std;const int procsize=5;typedef struct Node{int PId; //进程Idint Prio; //进程优先数int NeedRunTime; //进程需要运行时间int Room; //进程所需空间大小Node * next; //就绪队列中的下个就绪进程的地址}PCB;typedef struct{ //就绪链式队列结构体PCB *front;PCB *rear;}AleadyQueue;typedef struct Tab{ //分区表结构体int CalledId; //调用该分区的进程Idint TabId; //分区号int Size; //大小int StartAdd; //始址char * Status; //使用状态Tab *next; //指向下个分区}Table;void CinInfo(PCB P[procsize]){ //输入进程信息cout<<"\t\t请输入5个进程,格式如下:\n\n ";cout<<"PId 优先数运行时间所需内存大小(最好是小于20)\n";int i=0,j=0;for(i,j; i<procsize ; i++,j++){cin>>P[j].PId>>P[j].Prio>>P[j].NeedRunTime>>P[j].Room;}}void Sort(PCB P[procsize]){ //根据优先数由冒泡法对进程进行排序int i,j,exchange=1; //exchange表示相邻PCB是否调换PCB Temp;for(i=procsize;i>1&&exchange;i--){exchange=0;for(j=0;j<i-1;j++)if(P[j].Prio<P[j+1].Prio){Temp=P[j];P[j]=P[j+1];P[j+1]=Temp;exchange=1;}}}AleadyQueue InitQueue(){ //就绪队列初始化函数AleadyQueue Q;Node *p;p=(Node *)malloc(sizeof(PCB));if(!p){cout<<"就绪队列初始化失败!\n";exit(0);}else{Q.front=Q.rear=p;Q.front->next=NULL;return Q;}}void EnQueue(AleadyQueue &Queue,PCB &P){ //进程入队操作函数Node *p;p=(Node *)malloc(sizeof(PCB));if(!p)cout<<"分配节点失败!\n";else {*p=P;p->next=NULL;Queue.rear->next=p;Queue.rear=p;}}void EnQueue1(AleadyQueue &Queue,PCB &P){ //进程入队操作函数Node *p;p=(Node *)malloc(sizeof(PCB));if(!p)cout<<"分配节点失败!\n";else {*p=P;p->next=NULL;Queue.rear->next=p;Queue.rear=p;}}PCB OutQueue(AleadyQueue &Q){ //进程出队操作函数Node *P;P=(Node *)malloc(sizeof(PCB));if(Q.front->next!=NULL){P=Q.front->next;Q.front->next=P->next;}return *P;}PCB OutQueue1(AleadyQueue &Q){ //进程出队操作函数Node *P;P=(Node *)malloc(sizeof(PCB));if(Q.front->next!=NULL){P=Q.front->next;Q.front->next=P->next;}return *P;}void printinfo(AleadyQueue Q){ //打印就绪队列的情况cout<<"目前就绪队列进程情况如下:\n";cout<<"PId\t\tPriority\t\tNeedTime\t\tRoom\n";Q.front=Q.front->next;while(1){if(Q.front!=NULL){cout<<Q.front->PId<<"\t\t"<<Q.front->Prio<<"\t\t\t";cout<<Q.front->NeedRunTime<<"\t\t\t"<<Q.front->Room<<endl;Q.front=Q.front->next;}elsebreak;}}int chose(){ //选择所选算法int i;cout<<"请选择:\n";cout<<" 1、采用<首次适应>算法为进程分配内存!\n";cout<<" 2、采用<最佳适应>算法为进程分配内存!\n";cout<<" 3、采用<最坏适应>算法为进程分配内存!\n";cout<<" 4、结束!\n";cin>>i;return i;}Table * CreateMMTable(){ //定义主存分区表Table * FT; //用尾插入法Table * R;Table * P;FT=(Table *)malloc(sizeof(Tab));R=FT;FT->next=NULL;int num=0;int LastAdd=0;int LastSize=1;while(1){P=(Table *)malloc(sizeof(Tab));P->CalledId=0; //被调用的进程调Id初始化为0P->TabId=num; //主存分区号P->Size=3*num+1; //分区大小P->StartAdd=LastAdd+LastSize; //分区始址P->Status="Free"; //分区状态num++; //分区号加1LastAdd=P->StartAdd; //重新定义LastAdd为上次的StartAddLastSize=P->Size; //同上P->next=NULL;R->next=P;R=P;if(P->StartAdd==93) //内存初始化完毕break;}return FT;}Table * CreateUsedTable(){ //创建已分配表Table * T;T=(Table *)malloc(sizeof(Tab));T->next=NULL;return T;}void CoutMMTable(Table * FTL){ //打印主存表情况cout<<"主存表情况:\n";cout<<"分区号\t\t"<<"分区始址\t"<<"分区大小\t"<<"状态\n";FTL=FTL->next;while(1){cout<<FTL->TabId<<"\t\t"<<FTL->StartAdd<<"\t\t";cout<<FTL->Size<<"\t\t";cout<<FTL->Status<<endl;FTL=FTL->next;if(FTL->next==NULL)break;}}void CoutFreeTable(Table * FTL){ //打印空闲区表cout<<"空闲区表情况:\n";cout<<"分区号\t\t"<<"分区始址\t"<<"分区大小\t"<<"状态\n";FTL=FTL->next;while(1){cout<<FTL->TabId<<"\t\t"<<FTL->StartAdd<<"\t\t";cout<<FTL->Size<<"\t\t";printf("%s\n",FTL->Status);FTL=FTL->next;if(FTL->next==NULL)break;}}void CoutUsedTable(Table * UTL){ //打印已分配表cout<<"已分配表情况:\n";cout<<"分区号\t\t"<<"分区始址\t"<<"分区大小\t"<<"状态\n";UTL=UTL->next;while(1){if(UTL->Status=="Used"){cout<<UTL->TabId<<"\t\t"<<UTL->StartAdd<<"\t\t";cout<<UTL->Size<<"\t\t";printf("%s\n",UTL->Status);}UTL=UTL->next;if(UTL->next==NULL)break;}}int DistribMM(Table * MMTableList,PCB Temp,Table * FTL,Table * UTL){//分配一块一定大小的内存Table *P;Table * TempMM; //需要改为已分配节点的上一个节点TempMM=MMTableList;Table * TTT;TTT=MMTableList->next;while(1){ //查找满足大小的分区节点if(TTT->Size>=Temp.Room && TTT->Status=="Free")break;TTT=TTT->next;if(TTT==NULL){cout<<"\n\n\n\t\t\t\t警告!内存不足....\n\n\n";return 0;}}//while//以下是内存改为已分配P=(Table *)malloc(sizeof(Tab));while(1){if(TempMM->next==TTT)break;TempMM=TempMM->next;}P->next=TempMM->next;TempMM->next=P;P->StartAdd=TTT->StartAdd;P->Size=Temp.Room;P->CalledId=Temp.PId;P->TabId=TTT->TabId;P->Status="Used";P=P->next;while(P!=NULL){(P->TabId)++;P=P->next;}FTL=FTL->next;while(1){ //将空闲分区对应的首地址更改if(FTL->StartAdd==TTT->StartAdd)break;FTL=FTL->next;}TTT->StartAdd=FTL->StartAdd=TTT->StartAdd+Temp.Room;//空闲表的首地址=原来+Room TTT->Size=FTL->Size=TTT->Size-Temp.Room;while(FTL!=NULL){(FTL->TabId)++;FTL=FTL->next;}return 2;}void ReturnMM(Table * MMTableList,Table * FTL,Table * UTL,PCB &Temp){ //回收一块内存MMTableList=MMTableList->next;FTL=FTL->next;Table *TT;while(1){if(MMTableList->CalledId==Temp.PId){if(MMTableList->next->Status=="Free"){MMTableList->Status="Free"; //修改内存,相邻的为FreeMMTableList->CalledId=0;MMTableList->Size=MMTableList->Size+MMTableList->next->Size;MMTableList->next=MMTableList->next->next;TT=MMTableList;while(FTL!=NULL){if(FTL->StartAdd==TT->next->StartAdd)break;FTL=FTL->next;}FTL->Size=TT->Size;}if(MMTableList->next->Status!="Free"){MMTableList->Status="Free"; //修改内存,相邻的为USedMMTableList->CalledId=0;while(FTL!=NULL){if(FTL->StartAdd==TT->next->StartAdd)break;FTL=FTL->next;}FTL->Size=TT->Size;}}if(MMTableList->next==NULL)break;MMTableList=MMTableList->next;}//总whilecout<<"\n";}int FF(Table * MMTableList,Table * FTL,Table * UTL,AleadyQueue &Q){ //首次适应算法PCB Temp;int i; //记录分配函数的返回值0int num=0; //记录进程首次分配内存while(1){Temp=OutQueue(Q);if(num<procsize){if(num==0){cout<<"正在为"<<Temp.PId<<" 号进程分配内存......\n";i=DistribMM(MMTableList,Temp,FTL,UTL); //分配内存函数if(i==0) return 0; //内存不足CoutMMTable(MMTableList); //打印主存情况CoutFreeTable(FTL); //打印空闲分区表CoutUsedTable(MMTableList); //打印已分配表}if(num==1){cout<<"正在为"<<Temp.PId<<" 号进程分配内存......\n";i=DistribMM(MMTableList,Temp,FTL,UTL); //分配内存函数if(i==0) return 0;CoutMMTable(MMTableList); //打印主存情况CoutFreeTable(FTL); //打印空闲分区表CoutUsedTable(MMTableList); //打印已分配表}if(num==2){cout<<"正在为"<<Temp.PId<<" 号进程分配内存......\n";i=DistribMM(MMTableList,Temp,FTL,UTL); //分配内存函数if(i==0) return 0; // printf("y余朝水\n");CoutMMTable(MMTableList); //打印主存情况CoutFreeTable(FTL); //打印空闲分区表CoutUsedTable(MMTableList); //打印已分配表}if(num==3){cout<<"正在为"<<Temp.PId<<" 号进程分配内存......\n";i=DistribMM(MMTableList,Temp,FTL,UTL); //分配内存函数if(i==0) return 0;CoutMMTable(MMTableList); //打印主存情况CoutFreeTable(FTL); //打印空闲分区表CoutUsedTable(MMTableList); //打印已分配表}if(num==4){cout<<"正在为"<<Temp.PId<<" 号进程分配内存......\n";i=DistribMM(MMTableList,Temp,FTL,UTL); //分配内存函数if(i==0) return 0;CoutMMTable(MMTableList); //打印主存情况CoutFreeTable(FTL); //打印空闲分区表CoutUsedTable(MMTableList); //打印已分配表}}cout<<"正在执行"<<Temp.PId<<" 号进程.....\n"; //队首调度完毕并出队Temp.Prio--; //进程优先数减1Temp.NeedRunTime--; //进程还需运行时间减1cout<<"\t\t\t目前进程"<<Temp.PId<<"的优先数: "<<Temp.Prio;cout<<" 还需运行时间: "<<Temp.NeedRunTime<<endl;num++;if(Temp.NeedRunTime==0) { //判断是否进程运行完毕,如果运行时间为0,则不再入队cout<<"\n进程"<<Temp.PId<<" 运行完成!\n";cout<<"正在回收内存......\n";if(Temp.PId==5)return 1;ReturnMM(MMTableList,FTL,UTL,Temp); //回收内存CoutMMTable(MMTableList); //打印主存情况CoutFreeTable(FTL); //打印空闲分区表CoutUsedTable(MMTableList); //打印已分配表printinfo(Q);if(Q.front->next==NULL) //判断就绪队列是否为空break;}elseEnQueue(Q,Temp); //运行时间不为0,还需入队等待下一个时间片再次执行}return 2;}int BF(Table * MMTableList,Table * FTL,Table * UTL,AleadyQueue &Q2){ //最佳适应算法PCB P[procsize]; //定义五个进程CinInfo(P); //输入进程信息Sort(P); //根据优先数的大小进行排序,形成进程数组PQ2=InitQueue(); //就绪队列初始化for(int k=0; k<procsize; k++)EnQueue(Q2,P[k]);int i; //记录分配函数的返回值0int num=0;PCB Temp;while(1){Temp=OutQueue1(Q2);if(num<procsize){if(num==0){cout<<"正在为"<<Temp.PId<<"进程分配内存......\n";cout<<"...........................\n\n";}if(num==1){cout<<"正在为"<<Temp.PId<<"进程分配内存......\n";cout<<"...........................\n\n";}if(num==2){cout<<"正在为"<<Temp.PId<<"进程分配内存......\n";cout<<"...........................\n\n";}if(num==3){cout<<"正在为"<<Temp.PId<<"进程分配内存......\n";cout<<"...........................\n\n";}if(num==4){cout<<"正在为"<<Temp.PId<<"进程分配内存......\n";cout<<"...........................\n\n";}}cout<<"正在执行"<<Temp.PId<<" 号进程.....\n"; //队首调度完毕并出队Temp.Prio--; //进程优先数减1Temp.NeedRunTime--; //进程还需运行时间减1cout<<"\t\t\t目前进程"<<Temp.PId<<"的优先数: "<<Temp.Prio;cout<<" 还需运行时间: "<<Temp.NeedRunTime<<endl;num++;if(Temp.NeedRunTime==0) { //判断是否进程运行完毕,如果运行时间为0,则不再入队cout<<"\n进程"<<Temp.PId<<" 运行完成!\n";cout<<"正在回收内存......\n";cout<<"...........................\n\n";if(Q2.front->next==NULL) //判断就绪队列是否为空break;}elseEnQueue1(Q2,Temp); //运行时间不为0,还需入队等待下一个时间片再次执行}return 1;}int WF(Table * MMTableList,Table * FTL,Table * UTL,AleadyQueue &Q2){ //最坏适应算法PCB P[procsize]; //定义五个进程CinInfo(P); //输入进程信息Sort(P); //根据优先数的大小进行排序,形成进程数组P Q2=InitQueue(); //就绪队列初始化for(int k=0; k<procsize; k++)EnQueue(Q2,P[k]);int i; //记录分配函数的返回值0int num=0;PCB Temp;while(1){Temp=OutQueue1(Q2);if(num<procsize){if(num==0){cout<<"正在为"<<Temp.PId<<"进程分配内存......\n";cout<<"...........................\n\n";}if(num==1){cout<<"正在为"<<Temp.PId<<"进程分配内存......\n";cout<<"...........................\n\n";}if(num==2){cout<<"正在为"<<Temp.PId<<"进程分配内存......\n";cout<<"...........................\n\n";}if(num==3){cout<<"正在为"<<Temp.PId<<"进程分配内存......\n";cout<<"...........................\n\n";}if(num==4){cout<<"正在为"<<Temp.PId<<"进程分配内存......\n";cout<<"...........................\n\n";}}cout<<"正在执行"<<Temp.PId<<" 号进程.....\n"; //队首调度完毕并出队Temp.Prio--; //进程优先数减1Temp.NeedRunTime--; //进程还需运行时间减1cout<<"\t\t\t目前进程"<<Temp.PId<<"的优先数: "<<Temp.Prio;cout<<" 还需运行时间: "<<Temp.NeedRunTime<<endl;num++;if(Temp.NeedRunTime==0) { //判断是否进程运行完毕,如果运行时间为0,则不再入队cout<<"\n进程"<<Temp.PId<<" 运行完成!\n";cout<<"正在回收内存......\n";cout<<"...........................\n\n";if(Q2.front->next==NULL) //判断就绪队列是否为空break;}elseEnQueue1(Q2,Temp); //运行时间不为0,还需入队等待下一个时间片再次执行}return 2;}void main(){AleadyQueue Q1; //定义一个就绪队列AleadyQueue Q2;AleadyQueue Q3;PCB P[procsize]; //定义五个进程CinInfo(P); //输入进程信息Sort(P); //根据优先数的大小进行排序,形成进程数组P Q1=InitQueue(); //就绪队列初始化Q2=InitQueue();Q3=InitQueue();for(int k=0; k<procsize; k++)EnQueue(Q1,P[k]); //首次排好序的就绪进程入队,//进程依次等待处理机调度for(k=0; k<procsize; k++)EnQueue(Q2,P[k]);for(k=0; k<procsize; k++)EnQueue(Q3,P[k]);printinfo(Q1); //打印当前就绪队列的情况Q3=Q2=Q1;Table * MMTableList; //主存分区表Table * MM;Table * FreeTableList; //空闲分区表Table * UsedTableList; //已分配分区表MMTableList=CreateMMTable(); //创建主存分区表MM=CreateMMTable();FreeTableList=CreateMMTable(); //创建空闲分区表(初始化时和内存分区表相同)UsedTableList=CreateUsedTable(); //创建已分配表CoutMMTable(MMTableList); //打印主存分区表int i; //记录0,内存不足int j; //记录所选算法while(1){j=chose(); //判断所选算法,所需操作(FF、BF、WF)if(j==1)i=FF(MM,FreeTableList,UsedTableList,Q1);//首次适应算法if(i==0)exit(0); //内存不足if(j==2)i=BF(MM,FreeTableList,UsedTableList,Q2);//最佳适应算法if(i==0)exit(0); //内存不足if(j==3)i=WF(MM,FreeTableList,UsedTableList,Q3);//最坏适应算法if(i==0)exit(0); //内存不足if(j==4)break; //结束内存分配}cout<<"\n\n\n-----------------------------------欢迎使用!------------------------------------\n\n\n\n\n"; }。
计算机操作系统实验报告动态分区分配方式的模拟
计算机操作系统实验报告姓名:班级:学号:题目:动态分区分配方式的模拟实习内容简要描述本次实验要完成两部分内容:一是用C语言实现对采用首次适应算法和最佳适应算法的动态分区分配过程ALLOCo和回收过程FREE(),其中空闲分区由空闲分区链来管理,进行分配时,系统优先使用空闲区底端空间。
二是假设初始状态下,可用内存空间为640KBO按照题目要求的作业顺序,以及各个作业分配和回收的内存空间。
分别采用首次适应法和最佳适应法,对内存进行分配和回收,要求每次分配和回收后显示空闲内存分区链的情况。
实验分析算法介绍本次实验通过用C语言进行编程并调试、运行,形象地表现出动态分区的分配方式,直观地展现了首次适应算法和最佳适应算法对内存的释放和回收方式之间的区别。
加深了我们对两种算法优缺点的理解,帮助我们了解一些数据结构和分配算法,进一步加深我们对动态分区存储器管理方式及其实现过程的理解。
主要的问题在于,如何解决两种算法对内存的释放和回收空间的表示。
动态分区分配:又称为可变分区分配,这种分配方式并不事先先将主存划分成一块块的分区,而是在作业进入主存时,根据作业的大小动态地建立分区。
并使分区的大小正好适应作业的需要。
因此系统中分区的大小是可变的,分区的数目也是可变的。
分区分配算法:(两者的空闲块链接方式不冋)①首次适应法:为作业选择分区时总是按地址从高到低搜索,只要找到可以容纳该作业的空白块,就把该空白块分配给该作业。
特点:优先利用内存中底地址部分的空闲分区(将所有空闲区,按其地址递增的顺序链接)②最佳适应算法:接到内存申请时,在空闲块表中找到一个不小于请求的最小空块进行分配;为作业选择分区时总是寻找其大小最接近于作业所要求的存储区域。
特点:用最小空间满足要求(将所有空闲区,按其大小递增的顺序联接成空闲区链)结果分析(思考题解答;错误原因分析)间的分配和回收。
思考题解答:1、首次适应算法分配时从表头指针开始查找可利用空间表,将找到的第一个大小不小于“请求”的空闲块的一部分分配给用户。
动态分区分配方式模拟
动态分区分配方式模拟动态分区分配方式的核心思想是将内存划分为若干个不同大小的分区,每个分区可以用来存放一个进程或作为一部分进程的存储区域。
当一个进程需要分配内存时,系统会根据进程的需要选择一个合适大小的空闲分区分配给该进程。
当进程执行完毕后,系统会回收其占用的内存分区,再次将其标记为空闲分区。
首次适应算法(First Fit)是最简单的动态分区分配算法之一、它从内存的起始位置开始,寻找第一个满足进程需要的空闲分区,然后将该分区分配给进程。
首次适应算法的优点是实现简单,且内存利用率较高。
然而,它也有一些缺点,比如容易产生碎片,导致内存的利用率下降。
最佳适应算法(Best Fit)是根据进程需要的内存大小,选择最小的满足条件的空闲分区进行分配。
最佳适应算法可以最大限度地减少碎片的产生,提高内存的利用率。
但是,最佳适应算法的缺点是实现较为复杂,同时由于选择最小的分区进行分配,会导致大量的碎片出现。
最坏适应算法(Worst Fit)与最佳适应算法相反,它选择最大的满足进程需要的空闲分区进行分配。
最坏适应算法的优点是可以减少大型进程的外部碎片,但由于选择最大的分区进行分配,会导致更多的碎片产生。
为了更好地理解动态分区分配方式,我们可以通过一个简单的模拟实例来进行说明。
假设有一块内存大小为1MB,现有以下三个请求需要进行内存分配:1.进程A需要200KB的内存;2.进程B需要400KB的内存;3.进程C需要600KB的内存。
首次适应算法:首先,进程A需要200KB的内存,首次适应算法从内存起始位置开始寻找空闲分区,找到一个大小符合要求的空闲分区,将其分配给进程A。
然后,进程B需要400KB的内存,首次适应算法会从上次分配的位置开始,找到一个大小满足要求的空闲分区,并将其分配给进程B。
最后,进程C需要600KB的内存,首次适应算法会继续从上次分配的位置开始,但发现没有足够的空闲分区,分配失败。
最佳适应算法:最佳适应算法需要对所有空闲分区进行排序,按照分区大小的升序排列。
操作系统实验四实验报告动态分区分配算法
操作系统实验四【实验题目】:动态分区分配算法【实验学时】:4学时【实验目的】通过这次实验,加深对动态分区分配算法的理解,进一步掌握首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法的实现方法。
【实验内容及要求】问题描述:设计程序模拟四种动态分区分配算法:首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法的工作过程。
假设内存中空闲分区个数为n,空闲分区大小分别为P1, … ,P n,在动态分区分配过程中需要分配的进程个数为m(m≤n),它们需要的分区大小分别为S1, … ,S m,分别利用四种动态分区分配算法将m个进程放入n个空闲分区,给出进程在空闲分区中的分配情况。
程序要求:1)利用首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法四种动态分区分配算法模拟分区分配过程。
2)模拟四种算法的分区分配过程,给出每种算法进程在空闲分区中的分配情况。
3)输入:空闲分区个数n,空闲分区大小P1, … ,P n,进程个数m,进程需要的分区大小S1, … ,S m。
4)输出:首次适应算法,循环首次适应算法,最佳适应算法,最坏适应算法,最终内存空闲分区的分配情况。
实现源代码:#include<iostream>#include<fstream>#include<iomanip>#include<string>#define max 100using namespace std;int work_num;int zone_num;struct Data{int data;char name;};Data *d=new Data[max];struct Table{int data;char array[max];int length;};Table *T=new Table[max];Table *temp=new Table[max];void Init(){ifstream inf("DTFQ.txt");int i,j;char ch;inf>>work_num;cout<<"作业数:"<<work_num<<endl;inf>>zone_num;cout<<"空闲分区数:"<<zone_num<<endl;cout<<" 作业为:";for(j=0;j<work_num;j++){inf.get(ch);d[j].name=ch;cout<<setw(4)<<d[j].name;}cout<<endl;cout<<"作业大小:";for(i=0;i<work_num;i++){.inf>>d[i].data;cout<<setw(4)<<d[i].data;}cout<<endl;cout<<"空闲分区:";for(j=0;j<zone_num;j++){inf>>T[j].data;temp[j].data=T[j].data;T[j].length=0;temp[j].length=0;cout<<setw(4)<<T[j].data;}cout<<endl;}void renew(){int j;for(j=0;j<zone_num;j++){T[j].data=temp[j].data;T[j].length=temp[j].length;}}void re(){int i;for(i=0;i<zone_num;i++){T[i].array[T[i].length]='#';}}void show(){int i,j;re();for(i=0;i<zone_num;i++){if(T[i].data==temp[i].data)cout<<setw(4)<<T[i].data;else{cout<<setiosflags(ios::right)<<setw(4)<<T[i].data<<setw(1);for(j=0;j<T[i].length;j++){if(T[i].array[j]=='#')break;elsecout<<setiosflags(ios::right)<<T[i].array[j];}}}cout<<endl;}void first_fit(){renew();cout<<"fist fit:";int i,j;int tag=0;for(i=0;i<work_num;i++){for(j=0;j<zone_num;j++){if(d[i].data<=T[j].data){T[j].data=T[j].data - d[i].data;T[j].array[T[j].length]=d[i].name;T[j].length++;tag=0;break;}elsetag=1;}if(tag==1){cout<<"作业太大,无满足条件分区!"<<endl;break;}}//re();}void next_fit(){renew();cout<<"next fit:";int i,j;int m=0,tag=0,count=0;for(i=0;i<work_num;i++){for(j=m;j<zone_num;j++){if(d[i].data<=T[j].data){T[j].data=T[j].data - d[i].data;T[j].array[T[j].length]=d[i].name;T[j].length++;tag=0;m=j;break;}else{tag=1;count++;}}while(tag==1 && count<zone_num){for(j=0;j<m;j++){if(d[i].data<=T[j].data){T[j].data=T[j].data - d[i].data;T[j].array[T[j].length]=d[i].name;T[j].length++;tag=0;break;}else{tag=1;count++;}}}if(tag==1 && count==zone_num){cout<<"作业太大,无满足条件分区!"<<endl;break;}}//re();}void best_fit(){renew();cout<<"best fit:";int i,j,k,temp,m;int tag=0,n=0;for(i=0;i<work_num;i++){for(j=0;j<zone_num;j++){if(d[i].data<=T[j].data){temp=T[j].data;m=j;int tag1=0;for(k=m+1;k<=zone_num;k++){if(T[k].data<temp){if(T[k].data>=d[i].data){temp=T[k].data;n=k;tag1=1;}}else if(tag1==0)n=j;}T[n].data=temp - d[i].data;T[n].array[T[n].length]=d[i].name;T[n].length++;tag=0;break;}elsetag=1;}if(tag==1){cout<<"作业太大,无满足条件分区!"<<endl;break;}}//re();}void worst_fit(){renew();cout<<"worst fit:";int i,j,k,temp,m;int tag=0,n=0;for(i=0;i<work_num;i++){for(j=0;j<zone_num;j++){if(d[i].data<=T[j].data){int tag1=0;temp=T[j].data;m=j;for(k=m+1;k<=zone_num;k++){if(T[k].data>temp){if(T[k].data>=d[i].data){temp=T[k].data;n=k;tag1=1;}}else if(tag1==0)n=j;}T[n].data=temp - d[i].data;T[n].array[T[n].length]=d[i].name;T[n].length++;tag=0;break;}elsetag=1;}if(tag==1){cout<<"作业太大,无满足条件分区!"<<endl;break;}}//re();}void main(){Init();first_fit();show();next_fit();show();best_fit();show();worst_fit();show();system("pause");}实验截图:如有侵权请联系告知删除,感谢你们的配合!。
(完整word版)动态分区分配方式模拟
使用动态分区分配方式的模拟1内容(1)用C语言分别实现采用首次适应算法和最佳适应算法的动态分区分配过程alloc( )和回收过程free( )。
其中,空闲分区通过空闲分区链来管理:在进行内存分配时,系统优先使用空闲区低端的空间。
(2)假设初始状态下,可用的内存空间为640KB,并有下列的请求序列:•作业1申请130KB。
•作业2申请60KB。
•作业3申请100KB。
•作业2释放60KB。
•作业4申请200KB。
•作业3释放100KB。
•作业1释放130KB。
•作业5申请140KB。
•作业6申请60KB。
•作业7申请50KB。
•作业6释放60KB。
请分别采用首次适应算法和最佳适应算法,对内存块进行分配和回收,要求每次分配和回收后显示出空闲分区链的情况。
2、示例程序://Tittle: 使用动态分区算法的模拟//author: XuYongzhen#include <stdio.h>#include <stdlib.h>#include <malloc.h>#include <iostream>using namespace std;typedef struct DuLNode{struct DuLNode *prior;struct DuLNode *next;int address;int jsize;int jnumber;//显示分区被那个作业占用,显示零则为空闲分区;}DuLNode,*DuLinkList ;void CreatList(DuLinkList &L){DuLinkList p=(DuLinkList)malloc(sizeof(DuLNode));L->next=p;L->jnumber=100;//为释放头结点后面的结点空间做统一化处理p->prior=L;p->next=NULL;p->jsize=600;p->address=0;p->jnumber=0;}void RequestList(DuLinkList &L,int job,int size){cout<<"作业"<<job<<"申请"<<size<<"KB的空间"<<endl;DuLinkList p=L->next;while((p->jnumber>0||p->jsize<size)&&p)p=p->next;if(p==NULL)cout<<"没有适合的空间分配"<<endl;else{DuLinkList s=(DuLinkList)malloc(sizeof(DuLNode));s->prior=p->prior;p->prior->next=s;s->next=p;p->prior=s;s->jnumber=job;s->jsize=size;s->address=p->address;p->address=p->address+s->jsize;p->jsize=p->jsize-s->jsize;DuLinkList t=L->next;while(t){if(t->jnumber==0)cout<<"空闲分区:始址="<<t->address<<"大小="<<t->jsize<<endl;elsecout<<"已分配的分区:作业号="<<t->jnumber<<"始址="<<t->address<<"大小="<<t->jsize<<endl;t=t->next;}//whilecout<<endl;}//else}//RequestListvoid FreeList(DuLinkList &L,int job){cout<<"作业"<<job<<"释放"<<endl;DuLinkList p=L->next;while(p->next&&p->jnumber!=job)p=p->next;if(p->prior->jnumber==0 && p->next->jnumber==0){//p的前后都是空闲分区,则合并三者DuLinkList s=p->next;DuLinkList q=p->prior;p->prior->next=p->next;p->next->prior=p->prior;s->prior->next=s->next;s->next->prior=p->prior;q->jsize=p->jsize+s->jsize+q->jsize;}if(p->prior->jnumber==0 && p->next->jnumber!=0){//回收区与插入点的前一个分区相临接DuLinkList q=p->prior;p->prior->next=p->next;p->next->prior=p->prior;q->jsize=p->jsize+q->jsize;}if(p->prior->jnumber!=0 && p->next->jnumber==0){//回收区与插入点的后一个分区相临接DuLinkList q=p->next;p->prior->next=p->next;p->next->prior=p->prior;q->address=p->address;q->jsize=p->jsize+q->jsize;}if(p->prior->jnumber!=0 && p->next->jnumber!=0)//回收区去插入点前后的两个空闲分区都不相临接p->jnumber=0;DuLinkList t=L->next;while(t){if(t->jnumber==0)cout<<"空闲分区:始址="<<t->address<<"大小="<<t->jsize<<endl;elsecout<<"已分配的分区:作业号="<<t->jnumber<<"始址="<<t->address<<"大小="<<t->jsize<<endl;t=t->next;}cout<<endl;}void main(){DuLinkList L=(DuLinkList)malloc(sizeof(DuLNode));CreatList(L);RequestList(L,1,130);RequestList(L,2,60);RequestList(L,3,100);FreeList(L,2);RequestList(L,4,200);FreeList(L,3);FreeList(L,1);RequestList(L,5,140);RequestList(L,6,60);RequestList(L,7,50);FreeList(L,6);}。
操作系统试验动态分区分配 某系统采用动态分区分配方式
操作系统试验动态分区分配某系统采用动态分区分配方式实验报告课程名称________操作系统试验____________实验名称________动态分区分配___________实验类型_________验证型_________________实验地点___机房___实验日期__2011_指导教师__________________________专业_计算机科学与技术_班级__________学号______________姓名____________成绩________________XX大学计算机与通信工程学院实验3动态分区分配一.实验目的用高级语言编写和调试一个内存分配模拟程序,以加深对动态分区的概念及内存分配原理的理解。
二.实验原理可变分区调度算法有:最先适应分配算法,最优适应分配算法,最坏适应算法。
用户提出内存空间的申请;系统根据申请者的要求,按照一定的分配策略分析内存空间的使用情况,找出能满足请求的空闲区,分给申请者;当程序执行完毕或主动归还内存资源时,系统要收回它所占用的内存空间或它归还的部分内存空间。
每当一个进程被创建时,内存分配程序首先要查找空闲内存分区表(链),从中寻找一个合适的空闲块进行划分,并修改空闲内存分区表(链)。
当进程运行完毕释放内存时,系统根据回收区的首址,从空闲区表(链)中找到相应的插入点,此时出现如下四种情况:1)回收区与插入点的前一个空闲分区F1相邻接,此时可将回收区直接与F1合并,并修改F1的大小;2)回收区与插入点的后一个空闲分区F2相邻接,此时可将回收区直接与F2合并,并用回收区的首址最为新空闲区的首址,大小为二者之和;3)回收区同时与插入点的前、后两个空闲分区邻接,此时需将三者合并;4)回收区不与任何一个空闲区邻接,此时应建一新的表项。
三.实验内容编写并调试一个模拟的内存分配程序。
具体做法为:使用一个循环,根据提示,由用户选择随时创建一个新的进程,并为其分配存储空间,也随时可以撤销一个进程,可以根据需要随时打印空闲分区表(链)以及打印系统中内存使用情况。
动态分区分配方式的模拟实验原理说明
动态分区分配方式的模拟实验原理说明一、引言动态分区分配方式是计算机内存管理中一种常见的分配方式,它将内存按需划分为多个独立的区域,用于分配进程所需的内存空间。
本文将详细探讨动态分区分配方式的原理及其在模拟实验中的应用。
二、动态分区分配方式的原理动态分区分配方式基于内存动态分配,将可用内存划分为多个不连续的分区,每个分区可用于存放一个进程或程序。
此分配方式具有灵活性,能够更好地满足不同程序对内存空间的需求。
2.1 空闲内存分区列表在动态分区分配方式中,操作系统维护一个空闲内存分区列表,记录可供分配的内存空间情况。
列表中的每个分区都有其起始地址和长度。
2.2 分区分配算法动态分区分配方式有多种分区分配算法可供选择,主要包括首次适应算法、最佳适应算法和最差适应算法。
•首次适应算法:从空闲分区列表中找到第一个满足分配要求的分区进行分配。
•最佳适应算法:从空闲分区列表中找到最小的满足分配要求的分区进行分配。
•最差适应算法:从空闲分区列表中找到最大的满足分配要求的分区进行分配。
2.3 分区回收算法当进程结束或释放内存时,操作系统需要将其占用的内存空间回收,归还给空闲内存区。
分区回收算法的目标是尽可能地合并相邻的空闲区域,以最大程度地提供可用内存。
三、动态分区分配方式的模拟实验为了更好地理解和研究动态分区分配方式,可以进行一系列模拟实验。
下面将介绍动态分区分配方式的模拟实验原理及步骤。
3.1 实验原理动态分区分配方式的模拟实验基于以下原理: - 创建一个内存模拟环境,模拟操作系统管理的内存空间。
- 设计一系列测试用例,模拟进程的创建、分配和回收过程。
- 根据所选的分区分配算法和分区回收算法,计算分区分配和回收的效果。
- 比较不同算法在性能方面的差异,并分析其优缺点。
3.2 实验步骤动态分区分配方式的模拟实验包括以下步骤: 1. 初始化内存模拟环境,创建一个空闲分区列表。
2. 设计多个测试用例,包括不同大小和数量的进程。
存储管理动态分区分配算法的模拟
存储管理动态分区分配算法的模拟一(题目: 存储管理--- 动态分区分配算法的模拟二(任务: 设计主界面以灵活选择某算法,且以下算法都要实现:首次适应算法、循环首次适应算法、最佳适应算法;。
三(思想: 对任务进行构思和设想。
(1) 首次适应算法:FF算法要求空闲分区链以地址递增的次序链接。
在分配内存时,从链首开始顺巡查找,直到找到一个大小能够满足要求的空闲分区为止; 然后再按照作业的大小,从该分区中划出一块内存空间分配给请求者,余下的空闲区间仍留在空闲链中。
若从链首直至链尾都不能找到一个能满足要求的分区,则此次内存分配失败,返回。
该算法倾向于优先利用内存中低址部分的空闲分区,从而保留了高址部分的大空闲区。
这给为以后到达的大作业分配大的内存空间创造了条件。
(2) 循环首次适应算法该算法是由首次适应算法演变而成的。
在为进程分配内存空间时,不再是每次都从链首开始查找,而是从上次找到的空闲分区的下一个空闲分区开始查找,直至找到一个能满足要求的空闲分区,从中划出一块的请求大小相等的内存空间分配给作业。
为实现该算法,应设置一起始查找指针,用于指示下一次起始查询的空闲分区,并采用循环查找方式,即如果最后一个( 链尾)空闲分区的大小仍不能满足要求,则返回到第一个空闲分区,比较大小是否满足,找到后,应调整起始查询指针。
(3) 最佳适应算法是将最小的空闲分区分配给作业,避免"大材小用"。
为了加速寻找,该算法要求将所有的空闲分区按照某容量以从小到大的顺序形成一空闲分区链。
这样,第一次找到的能满足要求的空闲区,必然是最佳的。
(4) 内存回收:将释放作业所在内存块的状态改为空闲状态,删除其作业名,设置为空。
并判断该空闲块是否与其他空闲块相连,若释放的内存空间与空闲块相连时,则合并为同一个空闲块,同时修改分区大小及起始地址。
四(目的: 在构思中提出要达到的目的。
(1) 按照首次适应算法对内存进行分配,得到(2) 按照循环首次适应算法对内存(3) 按照最佳适应算法对内存进行分配(4) 在作业完成时,释放作业所在内存块,使其能够再次被利用五(方案: 对构思的细化,提出粗略的方案。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
动态分区分配方式的模拟第一部分设计思想的说明1 设计目标用C语言或C++语言分别实现采用首次适应算法和最佳适应算法的动态分区分配过程alloc()和回收过程free()。
其中,空闲分区通过空闲分区链表来管理,在进行内存分配时,系统优先使用空闲区低端空间。
预期结果:假设初始状态如下,可用的内存空间为640KB,并有下列请求序列:作业1 申请 130KB作业2 申请 60KB作业3 申请 100KB作业2 释放 60KB作业4 申请 200KB作业3 释放 100KB作业1 释放 130KB作业5 申请 140KB作业6 申请 60KB作业7 申请 50KB作业6 释放 60KB分别用首次适应算法和最佳适应算法进行内存块的分配和回收,同时显示内存块分配和回收后空闲内存分区链的情况。
2、设计理论首次适应算法(First-fit):当要分配内存空间时,就查表,在各空闲区中查找满足大小要求的可用块。
只要找到第一个足以满足要球的空闲块就停止查找,并把它分配出去;如果该空闲空间与所需空间大小一样,则从空闲表中取消该项;如果还有剩余,则余下的部分仍留在空闲表中,但应修改分区大小和分区始址。
最佳适应算法(Best-fit):当要分配内存空间时,就查找空闲表中满足要求的空闲块,并使得剩余块是最小的。
然后把它分配出去,若大小恰好合适,则直按分配;若有剩余块,则仍保留该余下的空闲分区,并修改分区大小的起始地址。
内存回收:将释放作业所在内存块的状态改为空闲状态,删除其作业名,设置为空。
并判断该空闲块是否与其他空闲块相连,若释放的内存空间与空闲块相连时,则合并为同一个空闲块,同时修改分区大小及起始地址。
第二部分程序清单//*************************************************************** //******** 动态分区分配方式的模拟 *********//***************************************************************#include<iostream.h>#include<stdlib.h>#define Free 0 //空闲状态#define Busy 1 //已用状态#define OK 1 //完成#define ERROR 0 //出错#define MAX_length 640 //最大内存空间为640KBtypedef int Status;typedef struct freearea//定义一个空闲区说明表结构{int ID; //分区号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_last->data.address=0;block_last->data.size=MAX_length;block_last->data.ID=0;block_last->data.state=Free;return OK;}//----------------------- 分配主存 -------------------------Status alloc(int ch){int ID,request;cout<<"请输入作业(分区号):";cin>>ID;cout<<"请输入需要分配的主存大小(单位:KB):";cin>>request;if(request<0 ||request==0){cout<<"分配大小不合适,请重试!"<<endl;return ERROR;}if(ch==2) //选择最佳适应算法{if(Best_fit(ID,request)==OK) cout<<"分配成功!"<<endl;else cout<<"内存不足,分配失败!"<<endl;return OK;}else //默认首次适应算法{if(First_fit(ID,request)==OK) cout<<"分配成功!"<<endl;else cout<<"内存不足,分配失败!"<<endl;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){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 free(int ID){DuLNode *p=block_first;while(p){if(p->data.ID==ID){p->data.state=Free;p->data.ID=Free;if(p->prior->data.state==Free)//与前面的空闲块相连{p->prior->data.size+=p->data.size;p->prior->next=p->next;p->next->prior=p->prior;}if(p->next->data.state==Free)//与后面的空闲块相连{p->data.size+=p->next->data.size;p->next->next->prior=p;p->next=p->next->next;}break;}p=p->next;}return OK;}//--------------- 显示主存分配情况 ------------------void show(){cout<<"+++++++++++++++++++++++++++++++++++++++\n";cout<<"+++ 主存分配情况 +++\n";cout<<"+++++++++++++++++++++++++++++++++++++++\n"; DuLNode *p=block_first->next;while(p){cout<<"分区号:";if(p->data.ID==Free) cout<<"Free"<<endl;else cout<<p->data.ID<<endl;cout<<"起始地址:"<<p->data.address<<endl;cout<<"分区大小:"<<p->data.size<<" KB"<<endl;cout<<"状态:";if(p->data.state==Free) cout<<"空闲"<<endl;else cout<<"已分配"<<endl;cout<<"——————————————"<<endl;p=p->next;}}//----------------------- 主函数---------------------------void main(){int ch;//算法选择标记cout<<" 动态分区分配方式的模拟 \n";cout<<"************************************\n";cout<<"** 1)首次适应算法 2)最佳适应算法 **\n";cout<<"************************************\n";cout<<"请选择分配算法:";cin>>ch;Initblock(); //开创空间表int choice; //操作选择标记while(1){cout<<"********************************************\n";cout<<"** 1: 分配内存 2: 回收内存 **\n";cout<<"** 3: 查看分配 0: 退出 **\n";cout<<"********************************************\n";cout<<"请输入您的操作:";cin>>choice;if(choice==1) alloc(ch); // 分配内存else if(choice==2) // 内存回收{int ID;cout<<"请输入您要释放的分区号:";cin>>ID;free(ID);}else if(choice==3) show();//显示主存else if(choice==0) break; //退出else //输入操作有误{cout<<"输入有误,请重试!"<<endl;continue;}}}。