计算机操作系统内存分配实验源代码

合集下载

计算机操作系统内存分配源码

计算机操作系统内存分配源码

#include<stdio.h>#include<iostream>usingnamespace std;#define MEM_SIZE 200staticchar mem[MEM_SIZE];#define MINBLK 16struct block {struct block * next;size_t length;char data[0];};staticstruct block * free_list = NULL;//free_list为空void malloc_init(void){free_list = (struct block *)mem;free_list->next = NULL;//next指向空free_list->length = MEM_SIZE - sizeof(struct block);//data段的长度}//字节对齐void * malloc(size_t size){size = (size + 7) & ~7;struct block * prev = (struct block *) &free_list;//block首段struct block * cur = free_list;//cur 指向空闲的块while (cur != NULL) {if (cur->length >= size) //判断cur指向的块是否满足所要求的大小break;prev = cur;cur = cur->next;}if (cur == NULL)return NULL;//cur->length(data段的长度)-size后的大小可不可以放下blockif ((cur->length - size) >= MINBLK) {struct block * temp = (struct block *)(cur->data + size);//temp指向新block的头temp->next = cur->next;//新block指向下一个空白temp->length = cur->length - size - sizeof(struct block);prev->next = temp;cur->length = size;}else {prev->next = cur->next;}return cur->data;}void free(void * ptr){if (ptr == NULL)return;struct block * temp = (struct block *)((char *)ptr - sizeof(struct block));char * tempn = (char *)ptr + temp->length; // 和temp物理上相邻的下一个block的地址struct block * prev = (struct block *) &free_list;struct block * cur = free_list;char * curn; // 和cur物理上相邻的下一个block的地址// 考虑多种情况,完成free函数// ... ...if (free_list > temp)//空块地址大于要释放的块的地址,直接将释放的块放入空白块头部(第一种情况){if (((char*)temp + sizeof(block)+temp->length) == (char*)free_list) {temp->length += sizeof(block)+free_list->length;free_list = temp;}else {temp->next = free_list;free_list = temp;}ptr = NULL;return;}//若不一定插入头部,寻找插入块while (cur != NULL && (char*)cur < (char*)temp){prev = cur;cur = cur->next;}//temp与前段free_list相邻if (((char *)prev + sizeof(struct block) + prev->length) == (char*)temp){prev->length =prev->length + sizeof(struct block) + temp->length;temp = prev;ptr = NULL;}else{prev->next = temp;ptr = NULL;}//free_list在比temp地址大的地方且两者相邻if ((char *)tempn == (char *)cur || cur == NULL){temp->next = cur->next;temp->length = sizeof(struct block) + cur->length + temp->length;ptr = NULL;}else{temp->next = cur;ptr = NULL;}}void malloc_state(void){printf("free blocks:\n");struct block * ptr;for (ptr = free_list; ptr != NULL; ptr = ptr->next) {int i;printf("%p:", ptr);//printf("%d", ptr->length);for (int i = 0; i < ptr->length; i++) {printf("=");}printf(" ");}printf("\n");}void malloc_test(void){//定义abcdef为分配状态char* a = (char*)malloc(sizeof(char));malloc_state();char* b = (char*)malloc(sizeof(char));malloc_state();char* c = (char*)malloc(sizeof(char));malloc_state();char* d = (char*)malloc(sizeof(char));malloc_state();char* e = (char*)malloc(sizeof(char));malloc_state();char* f = (char*)malloc(sizeof(char));//按照adbfec的顺序进行释放会将所有的情况包含进去malloc_state();free(a);malloc_state();free(d);malloc_state();free(b);malloc_state();free(f);malloc_state();free(e);malloc_state();free(c);malloc_state();}int main(int argc, constchar *argv[]) {malloc_init();malloc_test();system("pause");return 0;}。

实现内存分配实验报告(3篇)

实现内存分配实验报告(3篇)

第1篇一、实验目的1. 理解操作系统内存分配的基本原理和常用算法。

2. 掌握动态分区分配方式中的数据结构和分配算法。

3. 通过编写程序,实现内存分配和回收功能。

二、实验环境1. 操作系统:Linux2. 编程语言:C语言3. 开发工具:GCC编译器三、实验原理1. 内存分配的基本原理操作系统内存分配是指操作系统根据程序运行需要,将物理内存分配给程序使用的过程。

内存分配算法主要包括以下几种:(1)首次适应算法(First Fit):从内存空间首部开始查找,找到第一个满足条件的空闲区域进行分配。

(2)最佳适应算法(Best Fit):在所有满足条件的空闲区域中,选择最小的空闲区域进行分配。

(3)最坏适应算法(Worst Fit):在所有满足条件的空闲区域中,选择最大的空闲区域进行分配。

2. 动态分区分配方式动态分区分配方式是指操作系统在程序运行过程中,根据需要动态地分配和回收内存空间。

动态分区分配方式包括以下几种:(1)固定分区分配:将内存划分为若干个固定大小的分区,程序运行时按需分配分区。

(2)可变分区分配:根据程序大小动态分配分区,分区大小可变。

(3)分页分配:将内存划分为若干个固定大小的页,程序运行时按需分配页。

四、实验内容1. 实现首次适应算法(1)创建空闲分区链表,记录空闲分区信息,包括分区起始地址、分区大小等。

(2)编写分配函数,实现首次适应算法,根据程序大小查找空闲分区,分配内存。

(3)编写回收函数,回收程序所占用的内存空间,更新空闲分区链表。

2. 实现最佳适应算法(1)创建空闲分区链表,记录空闲分区信息。

(2)编写分配函数,实现最佳适应算法,根据程序大小查找最佳空闲分区,分配内存。

(3)编写回收函数,回收程序所占用的内存空间,更新空闲分区链表。

3. 实验结果分析(1)通过实验,验证首次适应算法和最佳适应算法的正确性。

(2)对比两种算法在内存分配效率、外部碎片等方面的差异。

五、实验步骤1. 创建一个动态内存分配模拟程序,包括空闲分区链表、分配函数和回收函数。

WinCE5.0中VirtualAlloc内存分配的试验代码

WinCE5.0中VirtualAlloc内存分配的试验代码

WinCE5.0中VirtualAlloc内存分配的试验代码⼀、引WINCE HELP中对VirtualAlloc的说明⾥,对第⼀个参数pAddress描述⾥写到“If the memory is being reserved, the specified address is rounded down to the next 64-KB boundary. If the memory is reserved and is being committed, the address is rounded down to the next page boundary. ” 如果不是上⾯提到这篇⽂章,我根本就不会注意到这句,因为TCPMP⾥的⽤法是:p = VirtualAlloc(NULL,n,MEM_COMMIT,PAGE_READWRITE);这第⼀个参数根本就忽略过去了。

下⾯的代码试验是基于这篇⽂章的。

其中我最担⼼的⼀点,就是⽂章是针对的,⽽⽬前我⽤的版本是5.0,⽂中所提到的⼀些限制,是否已经有所改进了呢。

⼆、测试64KB对齐的直接分配⽅式写个测试代码验证⼀下#include "stdafx.h"#include "Winbase.h"#include "stdlib.h"int WINAPI WinMain( HINSTANCE hInstance,HINSTANCE hPrevInstance,LPTSTR lpCmdLine,int nCmdShow){// TODO: Place code here.int i = 0;void* pMem = NULL;SYSTEM_INFO SystemInfo;GetSystemInfo(&SystemInfo);printf("SystemInfo.dwPageSize = %d \n", SystemInfo.dwPageSize);printf("SystemInfo.lpMinimumApplicationAddress = 0x%x \n", (int)SystemInfo.lpMinimumApplicationAddress);printf("SystemInfo.lpMaximumApplicationAddress = 0x%x \n", (int)SystemInfo.lpMaximumApplicationAddress);GlobalMemoryStatus(&MemStatus);printf("MemStatus.dwTotalPhys = %d \n", MemStatus.dwTotalPhys);printf("MemStatus. dwAvailPhys = %d \n", MemStatus.dwAvailPhys);printf("MemStatus.dwTotalVirtual = %d \n", MemStatus.dwTotalVirtual);printf("MemStatus.dwAvailVirtual = %d \n", MemStatus.dwAvailVirtual);while(1){pMem = VirtualAlloc (0, 512, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);if(!pMem){printf("alloc %d times, failed, end",i+1);break;}else{printf("0x%X ",(int)pMem);}i++;}GlobalMemoryStatus(&MemStatus);printf("MemStatus.dwTotalPhys = %d \n", MemStatus.dwTotalPhys);printf("MemStatus. dwAvailPhys = %d \n", MemStatus.dwAvailPhys);printf("MemStatus.dwTotalVirtual = %d \n", MemStatus.dwTotalVirtual);printf("MemStatus.dwAvailVirtual = %d \n", MemStatus.dwAvailVirtual);return 1;}运⾏结果:SystemInfo.dwPageSize = 4096SystemInfo.lpMinimumApplicationAddress = 0x10000SystemInfo.lpMaximumApplicationAddress = 0x7fffffffMemStatus.dwTotalPhys = 55,656,448MemStatus.dwAvailPhys = 40,923,136MemStatus.dwTotalVirtual = 33,554,4320x60000 0x70000 0x80000 0x900000xA0000 0xB0000 0xC0000 0xD0000......0x1E40000 0x1E50000 0x1E60000 0x1E700000x1E80000 0x1E90000 0x1EA0000 0x1EB0000alloc 487 times to failed, ENDMemStatus.dwTotalPhys = 55,656,448MemStatus.dwAvailPhys = 38,903,808MemStatus.dwTotalVirtual = 33,554,432MemStatus.dwAvailVirtual = 0很好,和⾼级内存管理⼀⽂描述的情况⼀样, 不过还是有些意外的发现. 我们再来仔细看⼀下(1) 所谓的next 64-KB boundary,换算成16进制也就是0x10000, 上⾯测试代码所得到的结果,的确是每次分配按0x10000递增的(2) 的确在分配不⾜512次后,内存就⽤光了,分配失败停⽌了。

内存分配实验代码 -回复

内存分配实验代码 -回复

内存分配实验代码-回复内存分配实验代码:探索动态内存分配的原理与过程引言在计算机程序设计中,内存分配是至关重要的一环。

动态内存分配是指在程序运行时根据需要分配和释放内存空间。

它可以帮助开发人员灵活地管理资源,提高程序的效率和性能。

本文将以实验代码为主题,一步一步解释内存分配的原理与过程,并介绍常用的动态内存分配函数。

读者可以通过这篇文章理解内存分配的机制,并在实际开发过程中更好地进行内存管理。

1. 实验代码介绍实验代码是一个简单的C语言程序,用于模拟内存分配的过程。

以下是代码的核心部分:#include <stdio.h>#include <stdlib.h>int main() {int *ptr;int size;printf("请输入需要分配的内存大小:");scanf("d", &size);ptr = (int*)malloc(size * sizeof(int)); 动态内存分配if (ptr == NULL) {printf("内存分配失败!\n");return 1;}printf("成功分配了d个int型变量的内存\n", size);printf("内存地址:0xp\n", ptr);free(ptr); 释放内存printf("释放了d个int型变量的内存\n", size);return 0;}以上代码通过调用`malloc`函数动态分配了一个指定大小的内存空间,并通过`free`函数释放了分配的内存。

通过运行这段代码,我们可以观察内存分配的过程和结果,了解内存分配的实现细节。

2. 动态内存分配原理动态内存分配是通过在程序运行时从操作系统获取一块连续的内存空间。

C语言中,我们可以通过调用`malloc`函数来进行动态内存分配。

计算机操作系统-固定分区分配-c++源代码

计算机操作系统-固定分区分配-c++源代码
2013年11月4日报告退发订正重做一实验目的通过编写固定分区存储管理的模拟程序加深对操作系统存储管理功能中的固定分区管理方式主存分配表等相应知识的理解
实验报告 3
课程 计算机操作系统 实验名称 班级 11 计本 学号 实验日期:2013 年 11 月 4 日 固定分区存储管理 105032011130 第 姓名 1 页 风律澈
长 度 10K 18K 16K 6K 21K 30 K
占用标志 0 J1 J2 0 0 0
3、有若个作业申请或释放内存空间,请求如下: (1)作业 J3 请求资源,申请 5K 大小的内存空间; (2)作业 J4 申请 33K 大小的内存空间 ; (3)作业 J1 执行完毕,释放空间 4、编写程序实现相应存储空间的分配和去配,若请求成功,修改主 存分配表,并输出该表,若请求不能满足,输出“分配失败” 。 (其中 不考虑空闲分区的移动) 。
报告退发 (订正 、 重做)
一、实验目的 通过编写固定分区存储管理的模拟程序, 加深对操作系统存储管 理功能中的固定分区管理方式、主存分配表等相应知识的理解。 二、实验内容 1、实现固定分区存储管理方式下存储空间的分配和去配。 2、已知当前内存分配表如下:
分 区 号 1 2 3 44 K 50 K 71 K
} else cout<<"wrong:unfind enough space to put in!"<<endl; } // // //使用说明:释放函数,用于释放空间 // // // void free(int job,int space[][4]){ for(int i=0;i<6;i++){ if(space[i][3]==job){ space[i][3]=0; cout<<"clear job"<<job<<" room"<<endl; return; } } cout<<"No find job"<<job<<" saveroom"<<endl; return; } //main.cpp #include"way.h" void main(){ int space[6][4]={ {1,0,10,0}, {2,10,18,1}, {3,28,16,2}, {4,44,6,0}, {5,50,21,0}, {6,71,30,0} }; request(3,5,space); request(4,33,space); free(1,space); return; }

内存分配算法实验代码

内存分配算法实验代码

内存分配算法实验代码好的,下面是一个简单的内存分配算法的示例代码,使用了最先适配(First Fit)算法来分配内存:```pythonclass MemoryAllocator:def __init__(self, memory_size):self.memory_size = memory_sizeself.memory_map = [0] * memory_sizedef allocate_memory(self, size):if size > self.memory_size:return -1for i in range(0, self.memory_size - size + 1):if self.memory_map[i] == 0:self.memory_map[i:i + size] = [1] * sizereturn ireturn -1def free_memory(self, address, size):if address < 0 or address + size > self.memory_size:return -1self.memory_map[address:address + size] = [0] * size# 示例用法memory_allocator = MemoryAllocator(1024)address = memory_allocator.allocate_memory(128)print("分配的内存地址:", address)memory_allocator.free_memory(address, 128)```在上述示例中,我们定义了一个 `MemoryAllocator` 类,它使用最先适配算法来管理内存分配。

类中的 `allocate_memory` 方法用于分配指定大小的内存,它会遍历内存映射数组,找到第一个连续的空闲区域,并将其分配给请求的内存。

操作系统实验——磁盘存储空间的分配和回收C++源程序

操作系统实验——磁盘存储空间的分配和回收C++源程序

#include<stdio.h>#include<stdlib.h>#define NUM 128typedef struct{ int zm_no;int cd_no;int jl_no;}disk;void disp(int m[]){int i;printf("位?示º?图ª?:êo\n");for(i=0;i<NUM;i++){if(i%8==0)printf("\n");printf("%d\t",m[i]);}printf("\n");}void creat(int m[]){ int j=0,zh,wh;int keyong=0;while(j<NUM){ if(m[j]==0){ keyong=1;m[j]=1;disk a;a.zm_no=j/8;a.cd_no=(j%8)/4;a.jl_no=(j%8)%4;zh=a.zm_no;wh=a.cd_no*4+a.jl_no;printf("柱¨´面?号?\t磁ä?道̨¤号?\t物?理¤¨ª记?录?号?\n");printf("%d\t%d\t%d\n",a.zm_no,a.cd_no,a.jl_no);printf("字Á?号?\t位?号?\n");printf("%d\t%d\n",zh,wh);break;}else j++;}if(keyong==0){ printf("无T可¨¦用®?磁ä?盘¨¬块¨¦!ê?\n");printf("\n");}}void del(int m[]){ disk b;int zm_no,cd_no,jl_no,j;printf("输º?入¨?待äy回?收º?磁ä?盘¨¬块¨¦的Ì?柱¨´面?号?,ê?磁ä?道̨¤号?,ê?物?理¤¨ª记?录?号?:êo");scanf("%d%d%d",&b.zm_no,&b.cd_no,&b.jl_no);j=8*b.zm_no+4*b.cd_no+b.jl_no;if(m[j]==0)printf("已°?是º?空?闲D状Á¡ä态¬?,ê?不?必À?回?收º?!ê?\n");else{ m[j]=0;disp(m);}}int main(){int i;int input=1;int m[NUM]={ 0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1};while(input!=0){ printf("1.当Ì¡À前¡ã磁ä?盘¨¬状Á¡ä态¬? 2.申¦¨º请?磁ä?盘¨¬块¨¦ 3.回?收º?磁ä?盘¨¬块¨¦ 0.退ª?出?\n");scanf("%d",&input);switch(input){ case 1: disp(m);break;case 2: creat(m);break;case 3: del(m);break;default:break;}}system("pause");return 0;}。

操作系统内存分配代码(第二次实验)

操作系统内存分配代码(第二次实验)

#include<stdio.h>#include<stdlib.h>#define FF 0#define BF 1typedef struct JCB//作业结构体{int ads;int size;int id;struct JCB *next;}JCB,*JCBStr;typedef struct{JCBStr front;JCBStr end;}Link;Link Ready,Free;//已分配和未分配队列int Type;//内存分配操作int Size;//内存总大小int Fit;//内存分配方法int adress;//临时地址void build(JCBStr &q)//创建空链节{q = (JCBStr) malloc(sizeof(JCB));q->next = NULL;}void create(JCBStr &q,int id)//创建一个JCB {build(q);q->id = id;q->size = Size;q->ads = adress;}void Init()//队列初始化{build(Ready.front);Ready.end = Ready.front;build(Free.front);Free.end = Free.front;JCBStr q;create(q,0);Free.front->next = q;Free.end = q;q->ads = 0;}void lookFree(JCBStr &q)//查看空闲队列{JCBStr s,t;s = Free.front;t = Free.front->next;while(t){if(t->size>=Size){adress = t->ads;break;}s = t;t = t->next;}q = t;if(t && Fit == BF){s->next = t->next;if(t == Free.end)Free.end = s;}}void lookReady(JCBStr &q,int id)//查看并取出链节{JCBStr s;s = Ready.front;q = Ready.front->next;while(q){if(q->id == id)break;s = q;q = q->next;}if(!q) return;q->id = 0;s->next = q->next;if(q == Ready.end)Ready.end = s;}void insertReadyLink(JCBStr &q)//插入分配队列{Ready.end->next = q;Ready.end = q;}void InsertFreeBF(JCBStr &q)//根据内存空间排序插入{JCBStr s,t;t = Free.front;s = Free.front->next;while(s){if(s->size <= q->size){t = s;s = s->next;}else{break;}}t->next = q;q->next = s;if(t == Free.end)Free.end = q;}void InsertFreeFF(JCBStr &q)//根据内存地址排序插入{JCBStr s,t;t = Free.front;s = Free.front->next;while(s){if(s->ads < q->ads){t = s;s = s->next;}else{break;}}t->next = q;q->next = s;if(t == Free.end)Free.end = q;}void hebinFF(JCBStr &q,JCBStr &node,int type)//快速回收查找方法{JCBStr s,t;s = Free.front;t = s->next;switch(type){case 0:while(t){if(t->ads + t->size < q->ads){s = t;t = t->next;}else if(t->ads+t->size == q->ads){node = t;s->next = t->next;if(t == Free.end)Free.end = s;break;}else{node = NULL;break;}}break;case 1:while(t){if(q->ads+q->size < t->ads){s = t;t = t->next;}else if(q->ads+q->size == t->ads){node = t;s->next = t->next;if(t == Free.end)Free.end = s;break;}else{node = NULL;break;}}break;}}void hebinBF(JCBStr &q,JCBStr &node,int type)//最优回收{JCBStr s,t;node = NULL;s = Free.front;t = s->next;switch(type){case 0:while(t){if(t->ads+t->size != q->ads){s = t;t = t->next;}else{node = t;s->next = t->next;if(t == Free.end)Free.end = s;break;}}break;case 1:while(t){if(q->ads+q->size != t->ads){s = t;t = t->next;}else{node = t;s->next = t->next;if(t == Free.end)Free.end = s;break;}}break;}}void hebin(JCBStr &node,JCBStr &node1,int type)//回收合并方法{if(node1!=NULL){switch(type){case 0:node->ads -= node1->size;node->size +=node1->size;free(node1);break;case 1:node->size += node1->size;free(node1);break;}}}int buildLink(int id,int type,int fit) //内存分配回收{JCBStr node,node1;switch(type){case 1://内存分配lookFree(node);//查看满足空间的内存,不取出if(!node) return 0;switch(fit){case FF:create(node1,id);//创建Ready节点insertReadyLink(node1);//放入队列node->ads += Size;//空闲节点地址增加node->size -=Size;//节点空间减少break;case BF:create(node1,id);//创建Ready节点insertReadyLink(node1);//放入队列node->ads += Size;//空闲节点地址增加node->size -=Size;//节点空间减少InsertFreeBF(node);//按空间大小排序插入队列break;}break;case 2://内存回收lookReady(node,id);if(!node) return 0;switch(fit){case FF://合并hebinFF(node,node1,0);hebin(node,node1,0);hebinFF(node,node1,1);hebin(node,node1,1);//直接插入InsertFreeFF(node);break;case BF://合并hebinBF(node,node1,0);hebin(node,node1,0);hebinBF(node,node1,1);hebin(node,node1,1);//排序插入空闲队列InsertFreeBF(node);break;}break;}return 1;}//输出void print(Link Q){JCBStr p;p=Q.front->next;if(p==NULL)printf("# 队列为空!#\n");//队列为空else{printf("# 分区号起始大小#\n");while(p!=NULL) //否则显示队列中所有元素{printf(" %d %d %d \n",p->id,p->ads,p->size);p=p->next;}}}int main(){int id,flag;printf("##########################################\n");printf("# 请输入总内存大小#\n");printf("##########################################\n");scanf("%d",&Size);Init();//printf("########################################\n");printf("#选择内存分配策略,0 :首次适应算法(first fit);1 :最佳适应算法(best fit)#\n");//printf("########################################\n");scanf("%d",&Fit);//printf("########################################\n");printf("#选择内存操作,1 :分配内存,2 :内存回收,0 退出程序!#\n");//printf("# #\n");while(scanf("%d",&Type),Type!=0){switch(Type){case 1:printf("请输入内存分配编号和所需内存大小!\n");scanf("%d%d",&id,&Size);flag = buildLink(id,Type,Fit);if(flag == 0)printf("内存空间不足!\n");else{printf("回收成功!已分配内存为:\n");print(Ready);printf("剩余内存为:\n");print(Free);}break;case 2:printf("请输入内存回收编号!\n");scanf("%d",&id);flag = buildLink(id,Type,Fit);if(flag == 0)printf("此编号不存在!\n");else{printf("回收成功!已分配内存为:\n");print(Ready);printf("剩余内存为:\n");print(Free);}break;}//printf("########################################\n");printf("#选择内存操作,1 :分配内存,2 :内存回收,0 退出程序!#\n");// printf("#0 退出程序!#\n");//printf("########################################\n");}return 0;}。

操作系统实验内存分配

操作系统实验内存分配

西安邮电大学(计算机学院)课内实验报告实验名称:内存管理专业名称:软件工程班级:学生姓名:学号(8位):指导教师:实验日期:实验五:进程1.实验目的通过深入理解区管理的三种算法,定义相应的数据结构,编写具体代码。

充分模拟三种算法的实现过程,并通过对比,分析三种算法的优劣。

(1)掌握内存分配FF,BF,WF策略及实现的思路;(2)掌握内存回收过程及实现思路;(3)参考给出的代码思路,实现内存的申请、释放的管理程序,调试运行,总结程序设计中出现的问题并找出原因,写出实验报告。

2.实验要求:1)掌握内存分配FF,BF,WF策略及实现的思路;2)掌握内存回收过程及实现思路;3)参考本程序思路,实现内存的申请、释放的管理程序,调试运行,总结程序设计中出现的问题并找出原因,写出实验报告。

3.实验过程:创建进程:删除其中几个进程:(默认以ff首次适应算法方式排列)Bf最佳适应算法排列方式:wf最差匹配算法排列方式:4.实验心得:这次实验实验时间比较长,而且实验指导书中对内存的管理讲的很详细,老师上课的时候也有讲的很详细,但是代码比较长,刚开始的时候也是不太懂,但是后面经过和同学一起商讨,明白几种算法的含义:①首次适应算法。

在采用空闲分区链作为数据结构时,该算法要求空闲分区链表以地址递增的次序链接。

在进行内存分配时,从链首开始顺序查找,直至找到一个能满足进程大小要求的空闲分区为止。

然后,再按照进程请求内存的大小,从该分区中划出一块内存空间分配给请求进程,余下的空闲分区仍留在空闲链中。

②循环首次适应算法。

该算法是由首次适应算法演变而形成的,在为进程分配内存空间时,从上次找到的空闲分区的下一个空闲分区开始查找,直至找到第一个能满足要求的空闲分区,并从中划出一块与请求的大小相等的内存空间分配给进程。

③最佳适应算法将空闲分区链表按分区大小由小到大排序,在链表中查找第一个满足要求的分区。

④最差匹配算法将空闲分区链表按分区大小由大到小排序,在链表中找到第一个满足要求的空闲分区。

操作系统实验六:主存空间的分配与回收(题目及实例代码(基于java))

操作系统实验六:主存空间的分配与回收(题目及实例代码(基于java))

实验六:主存空间的分配与回收(题目及实例代码(基于java))实验目的:编程模拟主存空间的分配与回收,采用最先适应算法分配分区实验要求:基于现有程序,补全分配与回收部分程序实例代码:import java.util.LinkedList;import java.util.Scanner;public class DArea {public static LinkedList<Area> array1 = new LinkedList();public static void main(String args[]){array1.add(new Area(40,16));array1.add(new Area(78,24));array1.add(new Area(150,50));outArea();int addr=0;int arealong=0;System.out.println("请选择\n1:申请分区\n2:释放分区\n0:退出");Scanner in=new Scanner(System.in);int t=in.nextInt();while(t!=0){if(t==1){System.out.println("请输入申请分区长度");arealong=in.nextInt();int size=array1.size();int i=0;if(size==0)System.out.println("没有空间");else{for(i=0;i<size;i++){if(array1.get(i).areaLong>arealong){array1.get(i).addr=array1.get(i).addr+arealong;array1.get(i).areaLong=array1.get(i).areaLong-areal ong;System.out.println("申请空间分配成功");break;}elseif(array1.get(i).areaLong==arealong){array1.remove(i);System.out.println("申请空间分配成功");break;}}if(i==size)System.out.println("没有满足要求的分区");}}else if(t==2){System.out.println("请输入释放分区起始地址及长度");addr=in.nextInt();arealong=in.nextInt();int size=array1.size();int i=0;if(size==0)array1.add(new Area(addr, arealong));else{for(i=0;i<size;i++){if(array1.get(i).addr>addr)break;}if(i==0){if((addr+arealong)<array1.get(i).addr)array1.addFirst(newArea(addr,arealong));elseif((addr+arealong)==array1.get(i).addr){array1.get(i).addr=addr;array1.get(i).areaLong=arealong+array1.get(i).areaL ong;}else{System.out.println("释放空间数据有误");}}else if(i>=size){if((array1.get(i-1).addr+array1.get(i-1).areaLong)< addr)array1.add(newArea(addr,arealong));elseif((array1.get(i-1).addr+array1.get(i-1).areaLong)==a ddr){array1.get(i-1).areaLong=arealong+array1.get(i-1).a reaLong;}else{System.out.println("释放空间数据有误");}}else{if((array1.get(i-1).addr+array1.get(i-1).areaLong)= =addr&&(addr+arealong)==array1.get(i).addr){array1.get(i-1).areaLong=arealong+array1.get(i-1).a reaLong+array1.get(i).areaLong;array1.remove(i);}elseif((array1.get(i-1).addr+array1.get(i-1).areaLong)==a ddr){array1.get(i-1).areaLong=arealong+array1.get(i-1).a reaLong;}elseif((addr+arealong)==array1.get(i).addr){array1.get(i).addr=addr;array1.get(i).areaLong=arealong+array1.get(i).areaL ong;}elseif((array1.get(i-1).addr+array1.get(i-1).areaLong)>ad dr&&(addr+arealong)<array1.get(i).addr){array1.add(i,newArea(addr,arealong));}else{System.out.println("释放空间数据有误");}}}}outArea();System.out.println("请选择\n1:申请分区\n2:释放分区\n0:退出");t=in.nextInt();}}public static void outArea(){if(array1.size()==0)System.out.println("内存空间已全部分配");else{System.out.println("内存空间可用情况:");System.out.println("起始地址\t分区长度");for(int i=0;i<array1.size();i++){System.out.println(array1.get(i).addr+"\t"+array1.g et(i).areaLong);}}}}class Area {int addr;int areaLong;public Area(int addr, int areaLong) {this.addr = addr;this.areaLong = areaLong;}public int getAddr() {return addr;}public void setAddr(int addr) {this.addr = addr;}public int getAreaLong() {return areaLong;}public void setAreaLong(int areaLong) { this.areaLong = areaLong;}}实例运行:内存空间可用情况:起始地址分区长度40 1678 24150 50请选择1:申请分区2:释放分区0:退出1请输入申请分区长度30申请空间分配成功内存空间可用情况:起始地址分区长度40 1678 24180 20请选择1:申请分区2:释放分区0:退出2请输入释放分区起始地址及长度2020内存空间可用情况:起始地址分区长度20 3678 24180 20请选择1:申请分区2:释放分区0:退出。

操作系统-实验四动态分区分配算法源代码最全(可编辑)

操作系统-实验四动态分区分配算法源代码最全(可编辑)

操作系统-实验四动态分区分配算法源代码最全(可编辑)实验四操作系统-动态分区分配算法萨斯的发生的v设计程序模拟四种动态分区分配算法:首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法的工作过程。

假设内存中空闲分区个数为n,空闲分区大小分别为P1, … ,Pn,在动态分区分配过程中需要分配的进程个数为m(m?n),它们需要的分区大小分别为S1, … ,Sm,分别利用四种动态分区分配算法将m个进程放入n个空闲分区,给出进程在空闲分区中的分配情况。

程序要求如下:1)利用首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法四种动态分区分配算法模拟分区分配过程。

2)模拟四种算法的分区分配过程,给出每种算法进程在空闲分区中的分配情况。

3)输入:空闲分区个数n,空闲分区大小P1, … ,Pn,进程个数m,进程需要的分区大小S1, … ,Sm,算法选择1-首次适应算法,2-循环首次适应算法,3-最佳适应算法,4-最坏适应算法。

4)输出:最终内存空闲分区的分配情况。

代码实现:#include#include#includeusing namespace std;const int Number100; int FreePartition[Number];//空闲分区大小 int FirstPartition[Number];//1-首次适应算法 intCycleFirstPartition[Number];//2-循环首次适应算法 intBestPartition[Number];//3-最佳适应算法 int WorstPartition[Number];//4-最坏适应算法 int ProcessNeed[Number];//进程需要的分区大小 int PartitionNum,ProcessNum; char ProcessName[Number];//进程名char ProcessPartition[Number];//进程分配的序列 int Partition[Number]; char str[Number][Number]; void FirstFitint n,int m; void NextFitintn,int m; void BestFitint n,int m; void WorstFitint n,int m; voidPrintint n, int m; void Print2int n, int m; //void FirstFitint n, int m cout"选择了首次适应算法!"endl;coutendl;int i,j,k0;fori0; in; i++FirstPartition[i] FreePartition[i]; forj0; jm; j++fori0; in; i++ifProcessNeed[j]FirstPartition[i] ProcessPartition[j]i;//str[i][k] ProcessName[j];FirstPartition[i] FirstPartition[i]-ProcessNeed[j];break;Printn,m;cout"空间序号:"" ";fori0; in; i++cout"|"setwm-1"空间"i+1;coutendl;cout"分区大小:"" ";fori0; in; i++cout"|"setwmsetiosflagsios::leftFreePartition[i];coutendl;cout"剩余分区大小:";fori0; in; i++cout"|"setwmsetiosflagsios::leftFirstPartition[i];coutendl;Print2n,m;void NextFitint n, int m cout"选择了循环首次适应算法!"endl; coutendl;int i,j,flag0;fori0; in; i++CycleFirstPartition[i] FreePartition[i];forj0; jm; j++foriflag; in; i++ifProcessNeed[j]CycleFirstPartition[i]ProcessPartition[j]i; CycleFirstPartition[i] CycleFirstPartition[i]-ProcessNeed[j];flag i+1;ifin-1flag0;break;Printn,m;cout"空间序号:"" ";fori0; in; i++cout"|"setwm-1"空间"i+1;coutendl;cout"分区大小:"" ";fori0; in; i++cout"|"setwmsetiosflagsios::leftFreePartition[i]; coutendl;cout"剩余分区大小:";fori0; in; i++cout"|"setwmsetiosflagsios::leftCycleFirstPartition[i]; coutendl;Print2n,m;void BestFitint n, int mcout"选择了最佳适应算法!"endl;coutendl;int i,j,flag0,temp,id0,flag10; fori0; in; i++ BestPartition[i] FreePartition[i]; whileflag1mflag 0;fori0; in; i++Partition[i]0;fori0; in; i++ifProcessNeed[flag1]BestPartition[i] Partition[flag]i; flag + 1;temp BestPartition[Partition[0]]; id Partition[0]; fori1;iflag; i++ iftemp BestPartition[Partition[i]] temp BestPartition[Partition[i]];id Partition[i];BestPartition[id]BestPartition[id]-ProcessNeed[flag1];ProcessPartition[flag1]id; flag1 + 1;Printn,m;cout"空间序号:"" ";fori0; in; i++cout"|"setwm-1"空间"i+1;coutendl;cout"分区大小:"" ";fori0; in; i++cout"|"setwmsetiosflagsios::leftFreePartition[i]; coutendl;cout"剩余分区大小:";fori0; in; i++cout"|"setwmsetiosflagsios::leftBestPartition[i]; coutendl;Print2n,m;void WorstFitint n, int mcout"选择了最坏适应算法!"endl;coutendl;int i,j,flag0,temp,id0,flag10;fori0; in; i++WorstPartition[i] FreePartition[i];whileflag1mflag 0;fori0; in; i++Partition[i]0;fori0; in; i++ifProcessNeed[flag1]WorstPartition[i]Partition[flag]i;flag + 1;temp WorstPartition[Partition[0]]; id Partition[0]; fori1;iflag; i++ ifWorstPartition[Partition[i]] temp temp WorstPartition[Partition[i]];id Partition[i];WorstPartition[id]WorstPartition[id]-ProcessNeed[flag1];ProcessPartition[flag1]id; flag1 + 1;Printn,m;cout"空间序号:"" ";fori0; in; i++cout"|"setwm-1"空间"i+1;coutendl;cout"分区大小:"" ";fori0; in; i++cout"|"setwmsetiosflagsios::leftFreePartition[i];coutendl;cout"剩余分区大小:";fori0; in; i++cout"|"setwmsetiosflagsios::leftWorstPartition[i];coutendl;Print2n,m;void choiceint n, int m int intput;cout"\n请选择:1.首次适应算法 2.循环首次适应算法 3.最佳适应算法 4. 最坏适应算法:"endl;cinintput;coutendl;switchintputcase 1:FirstFitn,m;choicen,m;break;case 2:NextFitn,m;choicen,m;break;case 3:BestFitn,m;choicen,m;break;case 4:WorstFitn,m; choicen,m;break;coutendl;void Printint n, int mint j;cout"进程名:";forj0; jm; j++ cout"|"setwmsetiosflagsios::leftProcessName[j]; coutendl;cout"进程分区大小:";forj0; jm; j++ cout"|"setwmsetiosflagsios::leftProcessNeed[j]; coutendl;cout"分配结果:"endl;void Print2int n, int m int i,j;fori0; in; i++forj0; jm; j++str[i][j] 0;cout"进程分配分区:";fori0; in; i++int k0;forj0; jm; j++ifProcessPartition[j]i str[i][k] ProcessName[j];k + 1;fori0; in; i++cout"|";forj0; jm; j++coutsetw1str[i][j]; coutendl;//void mainifstream in"yin.txt"; int n,m;int i,j;inn;fori0; in; i++ inFreePartition[i]; inm;forj0; jm; j++ inProcessName[j]; forj0; jm; j++ inProcessNeed[j]; choicen,m;运行结果:。

计算机操作系统内存分配实验

计算机操作系统内存分配实验

#include<stdio.h>#include<stdlib.h>#define OK 1 //完成#define ERROR 0 //出错typedef int Status;typedef struct free_table//定义一个空闲区说明表结构{int num; //分区序号long address; //起始地址long length; //分区大小int state; //分区状态}ElemType;typedef struct Node// 线性表的双向链表存储结构{ElemType data;struct Node *prior; //前趋指针struct Node *next; //后继指针}Node,*LinkList;LinkList first; //头结点LinkList end; //尾结点int flag;//记录要删除的分区序号Status Initblock()//开创带头结点的内存空间链表{first=(LinkList)malloc(sizeof(Node));end=(LinkList)malloc(sizeof(Node));first->prior=NULL;first->next=end;end->prior=first;end->next=NULL;end->data.num=1;end->data.address=40;end->data.length=600;end->data.state=0;return OK;}void sort()//分区序号重新排序{Node *p=first->next,*q;q=p->next;for(;p!=NULL;p=p->next){for(q=p->next;q;q=q->next){if(p->data.num>=q->data.num){q->data.num+=1;}}}}//显示主存分配情况void show(){ int flag=0;//用来记录分区序号Node *p=first;p->data.num=0;p->data.address=0;p->data.length=40;p->data.state=1;sort();printf("\n\t\t》主存空间分配情况《\n");printf("**********************************************************\n\n");printf("分区序号\t起始地址\t分区大小\t分区状态\n\n");while(p){printf("%d\t\t%d\t\t%d",p->data.num,p->data.address,p->data.length);if(p->data.state==0) printf("\t\t空闲\n\n");else printf("\t\t已分配\n\n");p=p->next;}printf("**********************************************************\n\n");}//首次适应算法Status First_fit(int request){//为申请作业开辟新空间且初始化Node *p=first->next;LinkList temp=(LinkList)malloc(sizeof(Node));temp->data.length=request;temp->data.state=1;p->data.num=1;while(p){if((p->data.state==0)&&(p->data.length==request)){//有大小恰好合适的空闲块p->data.state=1;return OK;break;}else if((p->data.state==0) && (p->data.length>request)){//有空闲块能满足需求且有剩余temp->prior=p->prior;temp->next=p;temp->data.address=p->data.address;temp->data.num=p->data.num;p->prior->next=temp;p->prior=temp;p->data.address=temp->data.address+temp->data.length;p->data.length-=request;p->data.num+=1;return OK;break;}p=p->next;}return ERROR;}//最佳适应算法Status Best_fit(int request){int ch; //记录最小剩余空间Node *p=first;Node *q=NULL; //记录最佳插入位置LinkList temp=(LinkList)malloc(sizeof(Node));temp->data.length=request;temp->data.state=1;p->data.num=1;while(p) //初始化最小空间和最佳位置{if((p->data.state==0) && (p->data.length>=request) ) {if(q==NULL){q=p;ch=p->data.length-request;}else if(q->data.length > p->data.length){q=p;ch=p->data.length-request;}}p=p->next;}if(q==NULL) return ERROR;//没有找到空闲块else if(q->data.length==request){q->data.state=1;return OK;}else{temp->prior=q->prior;temp->next=q;temp->data.address=q->data.address;temp->data.num=q->data.num;q->prior->next=temp;q->prior=temp;q->data.address+=request;q->data.length=ch;q->data.num+=1;return OK;}return OK;}//最差适应算法Status Worst_fit(int request){int ch; //记录最大剩余空间Node *p=first->next;Node *q=NULL; //记录最佳插入位置LinkList temp=(LinkList)malloc(sizeof(Node));temp->data.length=request;temp->data.state=1;p->data.num=1;while(p) //初始化最大空间和最佳位置{if(p->data.state==0 && (p->data.length>=request) ){if(q==NULL){q=p;ch=p->data.length-request;}else if(q->data.length < p->data.length){q=p;ch=p->data.length-request;}}p=p->next;}if(q==NULL) return ERROR;//没有找到空闲块else if(q->data.length==request){q->data.length=1;return OK;}else{temp->prior=q->prior;temp->next=q;temp->data.address=q->data.address;temp->data.num=q->data.num;q->prior->next=temp;q->prior=temp;q->data.address+=request;q->data.length=ch;q->data.num+=1;return OK;}return OK;}//分配主存Status allocation(int a){int request;//申请内存大小printf("请输入申请分配的主存大小(单位:KB):"); scanf("%d",&request);if(request<0 ||request==0){printf("分配大小不合适,请重试!");return ERROR;}switch(a){case 1: //默认首次适应算法if(First_fit(request)==OK) printf("\t****分配成功!****");else printf("\t****内存不足,分配失败!****");return OK;break;case 2: //选择最佳适应算法if(Best_fit(request)==OK) printf("\t****分配成功!****");else printf("\t****内存不足,分配失败!****");return OK;break;case 3: //选择最差适应算法if(Worst_fit(request)==OK) printf("\t****分配成功!****");else printf("\t****内存不足,分配失败!****");return OK;break;}}Status deal1(Node *p)//处理回收空间{Node *q=first;for(;q!=NULL;q=q->next){if(q==p){if(q->prior->data.state==0&&q->next->data.state!=0){q->prior->data.length+=q->data.length;q->prior->next=q->next;q->next->prior=q->prior;q=q->prior;q->data.state=0;q->data.num=flag-1;}if(q->prior->data.state!=0&&q->next->data.state==0){q->data.length+=q->next->data.length;q->next=q->next->next;q->next->next->prior=q;q->data.state=0;q->data.num=flag;}if(q->prior->data.state==0&&q->next->data.state==0){q->prior->data.length+=q->data.length;q->prior->next=q->next;q->next->prior=q->prior;q=q->prior;q->data.state=0;q->data.num=flag-1;}if(q->prior->data.state!=0&&q->next->data.state!=0){q->data.state=0;}}}return OK;}Status deal2(Node *p)//处理回收空间{Node *q=first;for(;q!=NULL;q=q->next){if(q==p){if(q->prior->data.state==0&&q->next->data.state!=0){q->prior->data.length+=q->data.length;q->prior->next=q->next;q->next->prior=q->prior;q=p->prior;q->data.state=0;q->data.num=flag-1;}if(q->prior->data.state!=0&&q->next->data.state==0){q->data.state=0;}if(q->prior->data.state==0&&q->next->data.state==0){q->prior->data.length+=q->data.length;q->prior->next=q->next;q->next->prior=q->prior;q=q->prior;q->data.state=0;q->data.num=flag-1;}if(q->prior->data.state!=0&&q->next->data.state!=0){q->data.state=0;}}}return OK;}//主存回收Status recovery(int flag){Node *p=first;for(;p!=NULL;p=p->next){if(p->data.num==flag){if(p->prior==first){if(p->next!=end)//当前P指向的下一个不是最后一个时{if(p->next->data.state==0) //与后面的空闲块相连{p->data.length+=p->next->data.length;p->next->next->prior=p;p->next=p->next->next;p->data.state=0;p->data.num=flag;}else p->data.state=0;}if(p->next==end)//当前P指向的下一个是最后一个时{p->data.state=0;}}//结束if(p->prior==block_first)的情况else if(p->prior!=first){if(p->next!=end){deal1(p);}else{deal2(p);}}//结束if(p->prior!=block_first)的情况}//结束if(p->data.num==flag)的情况}printf("\t****回收成功****");return OK;}//主函数void main(){int i; //操作选择标记int a;//算法选择标记printf("**********************************************************\n"); printf("\t\t用以下三种方法实现主存空间的分配\n");printf("\t(1)首次适应算法\t(2)最佳适应算法\t(3)最差适应算法\n"); printf("**********************************************************\n"); printf("\n");printf("请输入所使用的内存分配算法:");scanf("%d",&a);while(a<1||a>3){printf("输入错误,请重新输入所使用的内存分配算法:\n"); scanf("%d",&a);}switch(a){case 1:printf("\n\t****使用首次适应算法:****\n");break;case 2:printf("\n\t****使用最佳适应算法:****\n");break;case 3:printf("\n\t****使用最坏适应算法:****\n");break;}Initblock(); //开创空间表while(1){show();printf("\t1: 分配内存\t2: 回收内存\t0: 退出\n");printf("请输入您的操作:");scanf("%d",&i);if(i==1)allocation(a); // 分配内存else if(i==2) // 内存回收{printf("请输入您要释放的分区号:");scanf("%d",&flag);recovery(flag);}else if(i==0){printf("\n退出程序\n");break; //退出}else //输入操作有误{printf("输入有误,请重试!");continue;}}}八、执行结果和结果分析初始化首次适应算法:当作业1、2、3顺利分配内存空间后:回收序号2里面的内存:分配作业4:回收序号3里面的内存(与上邻序号2相连了)回收序号1里的内存(与下邻序号2相连了)继续分配(会发现总是按顺序查找满足要求的第一个空闲块,一旦发现就会分配):。

操作系统内存分配实验报告

操作系统内存分配实验报告

操作系统实验报告内存分配学生学号:学生姓名:专业年级:(一)实验目的设计编写首次适应算法实现内存分配,每次从低位开始对内存进行检验分配。

(二)设计思想程序分配内存时每次从最低位开始检验是否有满足分配条件的空闲空间,有则把该进程分配到链表的最后(若在中间有足够空闲空间且与两者差大于最小分配的空间大小则分配到该空闲空间的后面,然后把原空闲空间减去已分配的大小);每次释放空间先检查所释放空间前后是否有空闲空间,有则将空间合并。

(三)主要数据结构及变量说明空间链表数据类型space:struct space{struct space *former; int address;int num; int size; int state; struct space *next;},记录内存空间相关属性;最小分配空间int size_min=10;定义空间链表为S:typedef struct space S;S的指针mem:S *mem;;数据类型struct space *former:链表头结点;数据类型struct space *next:链表尾节点;m存放系统内存空间总大小的值。

(四)流程图(五)运行结果(六)附录(代码):#include<stdio.h>#include<stdlib.h>#include <iostream.h>struct space{struct space *former;int address;int num;int size;int state;struct space *next;};typedef struct space S;S *mem;int size_min=10;int m;void init(){mem=new S;mem->size=m;mem->former=0;mem->next=0;}void alloc(S *ptr,S *assign){if(ptr->next==NULL){if(ptr->size>=assign->size){ptr->size=ptr->size-assign->size;assign->state=1;ptr->next=assign;assign->former=ptr;}else{printf("没有足够的内存空间为进程%d分配\n",assign->num);delete assign;}}else{S *previous,*current;previous=ptr;current=previous->next;while(current!=NULL){if(current->size>=assign->size&&current->state==0){break;}previous=current;current=current->next;}if(current==NULL){if(ptr->size>=assign->size){assign->address =m-(ptr->size);ptr->size=ptr->size-assign->size;assign->state=1;assign->former=previous;previous->next=assign;}else{printf("没有足够的内存空间为进程%d分配\n",assign->num);}}else{if((current->size-assign->size)<=size_min){current->num=assign->num;current->state=1;delete assign;}else{current->size=current->size-assign->size;assign->state=1;assign->address=current->address;current->address=assign->address+assign->size;current->former=assign;assign->next=current;assign->former=previous;previous->next=assign;}}}}void printgroup(S *ptr){S *temp;temp=ptr->next;printf("内存链的状态为:\n");while(temp!=NULL){if(temp->state==0){printf(" 起始地址为:%d",temp->address);printf(" 空闲空间大小为:%d",temp->size);printf(" 内存空闲\n");}else{printf("运行的进程:%d",temp->num);printf(" 起始地址为:%d",temp->address);printf(" 分配空间大小为:%d",temp->size);printf(" 内存已分配\n");}temp=temp->next;}}void free(S *ptr,int i){S *previous,*current;previous=ptr; current=previous->next;while(current!=NULL){if(current->state==1&&current->num==i){break;}previous=current;current=current->next;}if(current==NULL){printf("内存中没有任何进程!!!\n");}else if(current->next==NULL){if(previous->state==0){previous->size=previous->size+current->size;previous->next=NULL;}else{current->state=0;}printf("进程%d释放%d的空间\n",current->num,current->size);printgroup(mem);}else{if(previous->state==0&&(current->next)->state==0){previous->size=previous->size+current->size+(current->next)->s ize;if((current->next)->next==NULL){previous->next=NULL;}else{((current->next)->next)->former=previous;previous->next=(current->next)->next;}}else if(previous->state==0){previous->size=previous->size+current->size;(current->next)->former=previous;previous->next=current->next;}else if((current->next)->state==0){current->size=current->size+(current->next)->size;current->state=0;if((current->next)->next==NULL){previous->next=NULL;}else{((current->next)->next)->former=current;current->next=(current->next)->next;}}else{current->state=0;}printf("进程%d释放%d的空间\n",current->num,current->size);printgroup(mem);}}void Creat(int i,int temp){printf("输入进程名和大小:\n");scanf("%d",&i);scanf("%d",&temp);space *fenpei;fenpei=(S *)malloc(sizeof(space));fenpei->former=NULL;fenpei->address=0;fenpei->size=temp;fenpei->num=i;fenpei->state=0;fenpei->next=NULL;alloc(mem,fenpei);printgroup(mem);}void main(void){int i;int j,k;printf("请输入内存大小:");scanf("%d",&m);init();while(1){printf("**************************\n");printf("申请内存输入数字1\n");printf("释放内存输入数字2\n");printf("中止进程输入数字0\n");printf("**************************\n");scanf("%d",&i);if(i==1){Creat(j,k);}if(i==2){printf("输入进程名:\n");scanf("%d",&j);free(mem,j);}if(i==0){break;}}}。

计算机操作系统内存分配实验源代码

计算机操作系统内存分配实验源代码

#include<stdio.h>#include<stdlib.h>#define OK 1 //完成#define ERROR 0 //出错typedef int Status;typedef struct free_table//定义一个空闲区说明表结构{int num; //分区序号long address; //起始地址long length; //分区大小int state; //分区状态}ElemType;typedef struct Node// 线性表的双向链表存储结构{ElemType data;struct Node *prior; //前趋指针struct Node *next; //后继指针}Node,*LinkList;LinkList first; //头结点LinkList end; //尾结点int flag;//记录要删除的分区序号Status Initblock<>//开创带头结点的内存空间链表{first=<LinkList>malloc<sizeof<Node>>;end=<LinkList>malloc<sizeof<Node>>;first->prior=NULL;first->next=end;end->prior=first;end->next=NULL;end->data.num=1;end->data.address=40;end->data.length=600;end->data.state=0;return OK;}void sort<>//分区序号重新排序{Node *p=first->next,*q;q=p->next;for<;p!=NULL;p=p->next>{for<q=p->next;q;q=q->next>{if<p->data.num>=q->data.num>{q->data.num+=1;}}}}//显示主存分配情况void show<>{ int flag=0;//用来记录分区序号Node *p=first;p->data.num=0;p->data.address=0;p->data.length=40;p->data.state=1;sort<>;printf<"\n\t\t》主存空间分配情况《\n">;printf<"**********************************************************\n\n">; printf<"分区序号\t起始地址\t分区大小\t分区状态\n\n">;while<p>{printf<"%d\t\t%d\t\t%d",p->data.num,p->data.address,p->data.length>;if<p->data.state==0> printf<"\t\t空闲\n\n">;else printf<"\t\t已分配\n\n">;p=p->next;}printf<"**********************************************************\n\n">; }//首次适应算法Status First_fit<int request>{//为申请作业开辟新空间且初始化Node *p=first->next;LinkList temp=<LinkList>malloc<sizeof<Node>>;temp->data.length=request;temp->data.state=1;p->data.num=1;while<p>{if<<p->data.state==0>&&<p->data.length==request>>{//有大小恰好合适的空闲块p->data.state=1;return OK;break;}else if<<p->data.state==0> && <p->data.length>request>> {//有空闲块能满足需求且有剩余temp->prior=p->prior;temp->next=p;temp->data.address=p->data.address;temp->data.num=p->data.num;p->prior->next=temp;p->prior=temp;p->data.address=temp->data.address+temp->data.length; p->data.length-=request;p->data.num+=1;return OK;break;}p=p->next;}return ERROR;}//最佳适应算法Status Best_fit<int request>{int ch; //记录最小剩余空间Node *p=first;Node *q=NULL; //记录最佳插入位置LinkList temp=<LinkList>malloc<sizeof<Node>>;temp->data.length=request;temp->data.state=1;p->data.num=1;while<p> //初始化最小空间和最佳位置{if<<p->data.state==0> && <p->data.length>=request> >{if<q==NULL>{q=p;ch=p->data.length-request;}else if<q->data.length > p->data.length>{q=p;ch=p->data.length-request;}}p=p->next;}if<q==NULL> return ERROR;//没有找到空闲块else if<q->data.length==request>{q->data.state=1;return OK;}else{temp->prior=q->prior;temp->next=q;temp->data.address=q->data.address;temp->data.num=q->data.num;q->prior->next=temp;q->prior=temp;q->data.address+=request;q->data.length=ch;q->data.num+=1;return OK;}return OK;}//最差适应算法Status Worst_fit<int request>{int ch; //记录最大剩余空间Node *p=first->next;Node *q=NULL; //记录最佳插入位置LinkList temp=<LinkList>malloc<sizeof<Node>>;temp->data.length=request;temp->data.state=1;p->data.num=1;while<p> //初始化最大空间和最佳位置{if<p->data.state==0 && <p->data.length>=request> > {if<q==NULL>{q=p;ch=p->data.length-request;}else if<q->data.length < p->data.length>{q=p;ch=p->data.length-request;}}p=p->next;}if<q==NULL> return ERROR;//没有找到空闲块else if<q->data.length==request>{q->data.length=1;return OK;}else{temp->prior=q->prior;temp->next=q;temp->data.address=q->data.address;temp->data.num=q->data.num;q->prior->next=temp;q->prior=temp;q->data.address+=request;q->data.length=ch;q->data.num+=1;return OK;}return OK;}//分配主存Status allocation<int a>{int request;//申请内存大小printf<"请输入申请分配的主存大小<单位:KB>:">;scanf<"%d",&request>;if<request<0 ||request==0>{printf<"分配大小不合适,请重试!">;return ERROR;}switch<a>{case 1: //默认首次适应算法if<First_fit<request>==OK> printf<"\t****分配成功!****">; else printf<"\t****内存不足,分配失败!****">;return OK;break;case 2: //选择最佳适应算法if<Best_fit<request>==OK> printf<"\t****分配成功!****">; else printf<"\t****内存不足,分配失败!****">;return OK;break;case 3: //选择最差适应算法if<Worst_fit<request>==OK> printf<"\t****分配成功!****">; else printf<"\t****内存不足,分配失败!****">;return OK;break;}}Status deal1<Node *p>//处理回收空间{Node *q=first;for<;q!=NULL;q=q->next>{if<q==p>{if<q->prior->data.state==0&&q->next->data.state!=0> {q->prior->data.length+=q->data.length;q->prior->next=q->next;q->next->prior=q->prior;q=q->prior;q->data.state=0;q->data.num=flag-1;}if<q->prior->data.state!=0&&q->next->data.state==0>{q->data.length+=q->next->data.length;q->next=q->next->next;q->next->next->prior=q;q->data.state=0;q->data.num=flag;}if<q->prior->data.state==0&&q->next->data.state==0> {q->prior->data.length+=q->data.length;q->prior->next=q->next;q->next->prior=q->prior;q=q->prior;q->data.state=0;q->data.num=flag-1;}if<q->prior->data.state!=0&&q->next->data.state!=0> {q->data.state=0;}}}return OK;}Status deal2<Node *p>//处理回收空间{Node *q=first;for<;q!=NULL;q=q->next>{if<q==p>{if<q->prior->data.state==0&&q->next->data.state!=0> {q->prior->data.length+=q->data.length;q->prior->next=q->next;q->next->prior=q->prior;q=p->prior;q->data.state=0;q->data.num=flag-1;}if<q->prior->data.state!=0&&q->next->data.state==0>{q->data.state=0;}if<q->prior->data.state==0&&q->next->data.state==0> {q->prior->data.length+=q->data.length;q->prior->next=q->next;q->next->prior=q->prior;q=q->prior;q->data.state=0;q->data.num=flag-1;}if<q->prior->data.state!=0&&q->next->data.state!=0> {q->data.state=0;}}}return OK;}//主存回收Status recovery<int flag>{Node *p=first;for<;p!=NULL;p=p->next>{if<p->data.num==flag>{if<p->prior==first>{if<p->next!=end>//当前P指向的下一个不是最后一个时{if<p->next->data.state==0> //与后面的空闲块相连 {p->data.length+=p->next->data.length;p->next->next->prior=p;p->next=p->next->next;p->data.state=0;p->data.num=flag;}else p->data.state=0;}if<p->next==end>//当前P指向的下一个是最后一个时{p->data.state=0;}}//结束if<p->prior==block_first>的情况else if<p->prior!=first>{if<p->next!=end>{deal1<p>;}else{deal2<p>;}}//结束if<p->prior!=block_first>的情况}//结束if<p->data.num==flag>的情况}printf<"\t****回收成功****">;return OK;}//主函数void main<>{int i; //操作选择标记int a;//算法选择标记printf<"**********************************************************\n">; printf<"\t\t用以下三种方法实现主存空间的分配\n">;printf<"\t<1>首次适应算法\t<2>最佳适应算法\t<3>最差适应算法\n">;printf<"**********************************************************\n">; printf<"\n">;printf<"请输入所使用的内存分配算法:">;scanf<"%d",&a>;while<a<1||a>3>{printf<"输入错误,请重新输入所使用的内存分配算法:\n">;scanf<"%d",&a>;}switch<a>{case 1:printf<"\n\t****使用首次适应算法:****\n">;break;case 2:printf<"\n\t****使用最佳适应算法:****\n">;break;case 3:printf<"\n\t****使用最坏适应算法:****\n">;break;}Initblock<>; //开创空间表while<1>{show<>;printf<"\t1: 分配内存\t2: 回收内存\t0: 退出\n">;printf<"请输入您的操作:">;scanf<"%d",&i>;if<i==1>allocation<a>; // 分配内存else if<i==2> // 内存回收{printf<"请输入您要释放的分区号:">;scanf<"%d",&flag>;recovery<flag>;}else if<i==0>{printf<"\n退出程序\n">;break; //退出}else //输入操作有误{printf<"输入有误,请重试!">;continue;}}}八、执行结果和结果分析初始化首次适应算法:当作业1、2、3顺利分配内存空间后:回收序号2里面的内存:分配作业4:回收序号3里面的内存〔与上邻序号2相连了回收序号1里的内存〔与下邻序号2相连了继续分配〔会发现总是按顺序查找满足要求的第一个空闲块,一旦发现就会分配:。

操作系统实验—内存管理源代码

操作系统实验—内存管理源代码

//该程序从文件读入每次的操作,并将结果输出到out.txt文件中#include <stdio.h>#include <stdlib.h>#include <windows.h>#include <iostream.h>#include <fstream.h>struct operation{int time; // 起始时间开始执行的时间int block; //内存页数块数int oper; //操作int protection; //权限};struct trace //跟踪每一次分配活动的数据结构{LPVOID start; //起始地址long size; //分配的大小};HANDLE allo,trac;//信号量句柄DWORD Tracker(LPDWORD lpdwparm) //跟踪allocator线程的内存行为,并输出必要信息{ofstream outfile; //输出文件outfile.open("out.txt");for(int i=0;i<=30;i++){WaitForSingleObject(trac,INFINITE);//等待allocator一次内存分配活动结束//打印内存状况和系统状况outfile<<i<<endl;//以下一段显示系统信息,每次执行操作后系统消息不变//每次的系统信息相同,察看时可以取消注释//系统信息SYSTEM_INFO info;GetSystemInfo(&info);outfile<<"dwActiveProcessorMask"<<'\t'<<info.dwActiveProcessorMask<<endl;outfile<<"dwAllocationGranularity"<<'\t'<<info.dwAllocationGranularity<<endl;outfile<<"dwNumberOfPrecessors"<<'\t'<<info.dwNumberOfProcessors<<endl;outfile<<"dwOemID"<<'\t'<<info.dwOemId<<endl;outfile<<"dwPageSize"<<'\t'<<info.dwPageSize<<endl;outfile<<"dwProcessorType"<<'\t'<<info.dwProcessorType<<endl;outfile<<"lpMaximumApplicationAddress"<<'\t'<<info.lpMaximumApplicationAddress<<endl; outfile<<"lpMinimumApplicationAddress"<<'\t'<<info.lpMinimumApplicationAddress<<endl; outfile<<"wProcessorArchitecture"<<'\t'<<info.wProcessorArchitecture<<endl;outfile<<"wProcessorLevel"<<'\t'<<info.wProcessorLevel<<endl;outfile<<"wProcessorRevision"<<'\t'<<info.wProcessorRevision<<endl;outfile<<"wReserved"<<'\t'<<info.wReserved<<endl;outfile<<"*************************************************"<<endl;//内存状况MEMORYSTATUS status;GlobalMemoryStatus(&status);outfile<<"dwAvailPageFile"<<'\t'<<status.dwAvailPageFile<<endl;outfile<<"dwAvailPhys"<<'\t'<<status.dwAvailPhys<<endl;outfile<<"dwAvailVirtual"<<'\t'<<status.dwAvailVirtual<<endl;outfile<<"dwLength"<<'\t'<<status.dwLength<<endl;outfile<<"dwMemoryLoad"<<'\t'<<status.dwMemoryLoad<<endl;outfile<<"dwTotalPageFile"<<'\t'<<status.dwTotalPageFile<<endl;outfile<<"dwTotalPhy"<<'\t'<<status.dwTotalPhys<<endl;outfile<<"dwTotalVirtual"<<'\t'<<status.dwTotalVirtual<<endl;outfile<<"&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& &&&&&&&&&&"<<endl;//内存基本信息,每次执行的结果相同,察看时可以取消注释MEMORY_BASIC_INFORMATION mem;VitualQuery(info.lpMinimumApplicationAddress,&mem,sizeof(MEMORY_BASIC_INFORMA TION));outfile<<"AllocationBase"<<'\t'<<mem.AllocationBase<<endl;outfile<<"AllocationProtect"<<'\t'<<mem.AllocationProtect<<endl;outfile<<"BaseAddress"<<'\t'<<mem.BaseAddress<<endl;outfile<<"Protect"<<'\t'<<mem.Protect<<endl;outfile<<"RegionSize"<<'\t'<<mem.RegionSize<<endl;outfile<<"State"<<'\t'<<mem.State<<endl;outfile<<"Type"<<'\t'<<mem.Type<<endl;outfile<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ "<<endl;//释放信号量通知allocator可以执行下一次内存分配活动ReleaseSemaphore(allo,1,NULL);}return 0;}void Allocator()//模拟内存分配活动的线程{trace traceArray[5];int index=0;FILE* file;file=fopen("opfile","rb");//读入文件operation op;SYSTEM_INFO info;DWORD temp;GetSystemInfo(&info);for(int i=0;i<30;i++){WaitForSingleObject(allo,INFINITE);//等待tracker打印结束的信号量cout<<i<<':';fread(&op,sizeof(operation),1,file);Sleep(op.time);//执行时间,如果想在指定时间执行可以取消注释GetSystemInfo(&info);switch(op.protection)//根据文件内容确定权限{case 0:{index=0;temp=PAGE_READONLY;break;}case 1:temp=PAGE_READWRITE;break;case 2:temp=PAGE_EXECUTE;break;case 3:temp=PAGE_EXECUTE_READ;break;case 4:temp=PAGE_EXECUTE_READWRITE;break;default:temp=PAGE_READONLY;}switch(op.oper){case 0://保留一个区域{cout<<"reserve now "<<endl;traceArray[index].start=VirtualAlloc(NULL,op.block*info.dwPageSize,MEM_RESERVE,PAGE_NOACCESS);traceArray[index++].size=op.block*info.dwPageSize;cout<<"starting address:"<<traceArray[index-1].start<<'\t'<<"size:"<<traceArray[index-1].size<<endl;break;}case 1://提交一个区域{cout<<"commit now "<<endl;traceArray[index].start=VirtualAlloc(traceArray[index].start,traceArray[index].size,MEM_COMMIT,temp);index++;cout<<"starting address:"<<traceArray[index-1].start<<'\t'<<"size:"<<traceArray[index-1].size<<endl;break;}case 2://锁一个区域{cout<<"lock now"<<endl;cout<<"starting address:"<<traceArray[index].start<<'\t'<<"size:"<<traceArray[index].size<<endl;if(!VirtualLock(traceArray[index].start,traceArray[index++].size))cout<<GetLastError()<<endl;//GetLastError()函数返回错误号break;}case 3://解锁一个区域{cout<<"unlock now"<<endl;cout<<"starting address:"<<traceArray[index].start<<'\t'<<"size:"<<traceArray[index].size<<endl;if(!VirtualUnlock(traceArray[index].start,traceArray[index++].size))cout<<GetLastError()<<endl;break;}case 4://回收一个区域{cout<<"decommit now"<<endl;cout<<"starting address:"<<traceArray[index].start<<'\t'<<"size:"<<traceArray[index].size<<endl;if(!VirtualFree(traceArray[index].start,traceArray[index++].size,MEM_DECOMMIT)) cout<<GetLastError()<<endl;break;}case 5://释放一个区域{cout<<"release now"<<endl;cout<<"starting address:"<<traceArray[index].start<<'\t'<<"size:"<<traceArray[index].size<<endl;if(!VirtualFree(traceArray[index++].start,0,MEM_RELEASE))cout<<GetLastError()<<endl;break;}default:cout<<"error"<<endl;}ReleaseSemaphore(trac,1,NULL);//释放信号量通知tracker可以打印信息}}int main(){DWORD dwThread;HANDLE handle[2];//生成两个线程handle[0]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)Tracker,NULL,0, &dwThread);handle[1]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)Allocator,NULL,0, &dwThread);//生成两个信号量allo=CreateSemaphore(NULL,0,1,"allo");trac=CreateSemaphore(NULL,1,1,"trac");//等待线程执行的执行结束后,再退出WaitForMultipleObjects(2,handle,TRUE,INFINITE);return 0;}。

操作系统实验内存分配(链表实现)

操作系统实验内存分配(链表实现)
if(manage==0)cout<<"\t\t\t静态分配"<<endl;
else cout<<"\t\t\t动态分配"<<endl;
show();
cout<<"请选择操作:\n1、建立进程并分配\n2、撤销进程\n3、返回上一目录(内存将被初始化)"<<endl;
cin>>choice;
if(choice=='1')
else//找到了,返回1
{
if(manage==0)p->pro=pro;//静态,直接让进程进驻内存
else assign(q,pro,size);//动态,调用assign来给进程pro分配
}
return 1;
}
int bf(int manage,char pro,int size)//最佳适应法
}
int wf(int manage,char pro,int size)//最坏适应法
{
memory *p=base,*temp=NULL,*q,*front;
int max=0;
while(p)//遍历内存,找到最大的一块内存
{
if(p->pro==0&&p->size>=size&&max<p->size)
case 0 :printf("空闲区\t%3dk\t%3dk~%3dk\n",size,begin,begin+size-1);break;
default :printf("进程%c \t%3dk\t%3dk~%3dk\n",ch,size,begin,begin+size-1);break;

操作系统存储器管理源代码

操作系统存储器管理源代码

操作系统存储器管理源代码下面是一个简单的操作系统存储器管理的源代码示例:```c#include <stdio.h>#include <stdlib.h>#define MEMORY_SIZE 1024 //存储器大小为1024字节//内存块的结构体typedef struct MemoryBlockint start_address; // 起始地址int end_address; // 结束地址int size; // 大小int is_allocated; // 是否已分配struct MemoryBlock* next_block; // 下一个内存块的指针} MemoryBlock;MemoryBlock* memory; // 内存块的链表的头指针//初始化内存块void init_memormemory = (MemoryBlock*) malloc(sizeof(MemoryBlock)); memory->start_address = 0;memory->end_address = MEMORY_SIZE - 1;memory->size = MEMORY_SIZE;memory->is_allocated = 0;memory->next_block = NULL;//分配内存void allocate_memory(int request_size)MemoryBlock* curr_block = memory;while (curr_block)if ((!curr_block->is_allocated) && (curr_block->size >= request_size))//如果当前内存块未分配且大小足够,则进行分配MemoryBlock* new_block = (MemoryBlock*)malloc(sizeof(MemoryBlock));new_block->start_address = curr_block->start_address;new_block->end_address = curr_block->start_address + request_size - 1;new_block->size = request_size;new_block->is_allocated = 1;new_block->next_block = curr_block->next_block;curr_block->start_address += request_size;curr_block->size -= request_size;curr_block->next_block = new_block;printf("Allocated memory block starting at address %d\n", new_block->start_address);return;}curr_block = curr_block->next_block;}printf("Unable to allocate memory block of size %d\n", request_size);//释放内存void deallocate_memory(int start_address)MemoryBlock* curr_block = memory;MemoryBlock* prev_block = NULL;while (curr_block)if (curr_block->start_address == start_address)curr_block->is_allocated = 0;//合并内存块if (prev_block && !prev_block->is_allocated)prev_block->next_block = curr_block->next_block;prev_block->end_address = curr_block->end_address;prev_block->size += curr_block->size;free(curr_block);curr_block = prev_block;}if (curr_block->next_block && !curr_block->next_block->is_allocated)MemoryBlock* next_block = curr_block->next_block;curr_block->next_block = next_block->next_block;curr_block->end_address = next_block->end_address;curr_block->size += next_block->size;free(next_block);}printf("Deallocated memory block starting at address %d\n", start_address);return;}prev_block = curr_block;curr_block = curr_block->next_block;}printf("No allocated memory block starting at address %d\n", start_address);//打印内存状态void print_memorMemoryBlock* curr_block = memory;while (curr_block)printf("Memory Block: start_address=%d end_address=%dsize=%d is_allocated=%d\n",curr_block->start_address, curr_block->end_address,curr_block->size, curr_block->is_allocated);curr_block = curr_block->next_block;}int maiinit_memory(;//分配内存块的示例allocate_memory(256);allocate_memory(512);allocate_memory(128);//打印内存状态print_memory(;//释放内存块的示例deallocate_memory(0);deallocate_memory(512);//打印内存状态print_memory(;return 0;```上述代码中,使用链表来管理内存块。

计算机操作系统内存分配实验源代码

计算机操作系统内存分配实验源代码
{
int ch; //记录最小剩余空间
Node *p=first;
Node *q=NULL; //记录最佳插入位置
LinkList temp=(LinkList)malloc(sizeof(Node));
temp->=request;
temp->=1;
p->=1;
while(p) //初始化最小空间和最佳位置
if(request<0 ||request==0)
{
printf("分配大小不合适,请重试!");
return ERROR;
}
switch(a)
{
case 1: //默认首次适应算法
if(First_fit(request)==OK) printf("\t****分配成功!****");
else printf("\t****内存不足,分配失败!****");
{
if((p->==0) && (p->>=request) )
{
if(q==NULL)
{
q=p;
ch=p->;
}
else if(q-> > p->
{
q=p;
ch=p->;
}
}
p=p->next;
}
if(q==NULL) return ERROR;//没有找到空闲块
else if(q->==request)
while(p)
{
if((p->==0)&&(p->==request))
{//有大小恰好合适的空闲块
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

#define OK 1 // 完成#define ERROR 0 // 出错 typedef int Status; typedef struct free_table// 定义一个空闲区说明表结构{int num; // 分区序号 long address; // long length; //int state; // }ElemType; typedef struct Node// { ElemType data; struct Node *prior; // struct Node *next; // 起始地址分区大小 分区状态 线性表的双向链表存储结构 前趋指针 后继指针}Node,*LinkList;LinkList first; // 头结点LinkList end; // 尾结点int flag;// 记录要删除的分区序号Status Initblock()// 开创带头结点的内存空间链表{first=(LinkList)malloc(sizeof(Node));end=(LinkList)malloc(sizeof(Node));first->prior=NULL;first->next=end;end->prior=first;end->next=NULL;end->=1;end->=40;end->=600;end->=0;return OK;void sort()// 分区序号重新排序{Node *p=first->next,*q;q=p->next;for(;p!=NULL;p=p->next) {for(q=p->next;q;q=q->next){if(p->>=q->{q->+=1;}}}}// 显示主存分配情况void show(){ int flag=0;// 用来记录分区序号Node *p=first;p->=0;p->=0;p->=40;p->=1;sort();printf("\n\t\t 》主存空间分配情况《\n");printf("**********************************************************\n\n");printf(" 分区序号\t 起始地址\t 分区大小\t 分区状态\n\n");while(p){printf("%d\t\t%d\t\t%d",p->,p->,p->;if(p->==0) printf("\t\t 空闲\n\n");else printf("\t\t 已分配\n\n");{p=p->next; printf("**********************************************************\n\n"); }// 首次适应算法Status First_fit(int request){// 为申请作业开辟新空间且初始化Node *p=first->next;LinkList temp=(LinkList)malloc(sizeof(Node));temp->=request;temp->=1;p->=1;while(p)if((p->==0)&&(p->==request)){// 有大小恰好合适的空闲块p->=1;return OK;break;}else if((p->==0) && (p->>request)){// 有空闲块能满足需求且有剩余temp->prior=p->prior; temp->next=p;temp->=p->;temp->=p->;p->prior->next=temp; p->prior=temp;p->=temp->+temp->;p->=request;p->+=1;return OK;break;}p=p->next;}return ERROR;}// 最佳适应算法Status Best_fit(int request){int ch; // 记录最小剩余空间Node *p=first;Node *q=NULL; // 记录最佳插入位置LinkList temp=(LinkList)malloc(sizeof(Node)); temp->=request;temp->=1;p->=1;while(p) // 初始化最小空间和最佳位置{if((p->==0) && (p->>=request) ){if(q==NULL){q=p;ch=p->;}else if(q-> > p->{q=p;ch=p->;}p=p->next;}if(q==NULL) return ERROR;//没有找到空闲块else if(q->==request){q->=1;return OK;}else{temp->prior=q->prior;temp->next=q;temp->=q->;temp->=q->;q->prior->next=temp;q->prior=temp;q->+=request;q->=ch;q->+=1;return OK;}return OK;}// 最差适应算法Status Worst_fit(int request){int ch; // 记录最大剩余空间Node *p=first->next;Node *q=NULL; // 记录最佳插入位置LinkList temp=(LinkList)malloc(sizeof(Node));temp->=request;temp->=1;p->=1;while(p) // 初始化最大空间和最佳位置{if(p->==0 && (p->>=request) ){if(q==NULL){q=p;ch=p->;}else if(q-> < p->{q=p;ch=p->;}p=p->next;}if(q==NULL) return ERROR;//没有找到空闲块else if(q->==request){q->=1;return OK;}else{temp->prior=q->prior;temp->next=q;temp->=q->;temp->=q->;q->prior->next=temp;q->prior=temp;q->+=request;q->=ch;q->+=1;return OK;}return OK;}// 分配主存Status allocation(int a){int request;// 申请内存大小printf(" 请输入申请分配的主存大小(单位:KB):"); scanf("%d",&request);if(request<0 ||request==0){printf(" 分配大小不合适,请重试!");return ERROR;}switch(a){case 1: // 默认首次适应算法if(First_fit(request)==OK) printf("\t**** 分配成功!****");else printf("\t**** 内存不足,分配失败!****");return OK;break;case 2: // 选择最佳适应算法if(Best_fit(request)==OK) printf("\t**** 分配成功!****");else printf("\t**** 内存不足,分配失败!****");return OK;break;case 3: // 选择最差适应算法if(Worst_fit(request)==OK) printf("\t**** else printf("\t****分配成功!****");内存不足,分配失败!****"); return OK;break;}}Status deal1(Node *p)// 处理回收空间{Node *q=first;for(;q!=NULL;q=q->next){if(q==p){if(q->prior->==0&&q->next->!=0){q->prior->+=q->;q->prior->next=q->next;q->next->prior=q->prior;q=q->prior;q->=0;q->=flag-1;}if(q->prior->!=0&&q->next->==0) {q->+=q->next->;q->next=q->next->next;q->next->next->prior=q;q->=0;q->=flag;}if(q->prior->==0&&q->next->==0) {q->prior->+=q->;q->prior->next=q->next; q->next->prior=q->prior; q=q->prior;q->=0;q->=flag-1;}if(q->prior->!=0&&q->next->!=0){q->=0;}}}return OK;}Status deal2(Node *p)// 处理回收空间Node *q=first;for(;q!=NULL;q=q->next){if(q==p){if(q->prior->==0&&q->next->!=0){q->prior->+=q->;q->prior->next=q->next;q->next->prior=q->prior;q=p->prior;q->=0;q->=flag-1;}if(q->prior->!=0&&q->next->==0)q->=0;} if(q->prior->==0&&q->next->==0){q->prior->+=q->;q->prior->next=q->next;q->next->prior=q->prior;q=q->prior;q->=0;q->=flag-1;}if(q->prior->!=0&&q->next->!=0){q->=0;}}return OK;}// 主存回收Status recovery(int flag){Node *p=first;for(;p!=NULL;p=p->next){if(p->==flag){if(p->prior==first){if(p->next!=end)// 当前P 指向的下一个不是最后一个时{if(p->next->==0) // 与后面的空闲块相连{p->+=p->next->;p->next->next->prior=p;p->next=p->next->next;p->=0;p->=flag;}else p->=0;}if(p->next==end)// 当前P 指向的下一个是最后一个时{p->=0;}}// 结束if(p->prior==block_first) 的情况else if(p->prior!=first)if(p->next!=end){deal1(p);}else{deal2(p);}}// 结束if(p->prior!=block_first)的情况}// 结束if(p->==flag) 的情况}printf("\t**** 回收成功****");return OK;}// 主函数void main(){int i; // 操作选择标记int a;// 算法选择标记printf(" f******************************************************** **\n");printf("\t\t 用以下三种方法实现主存空间的分配\n");printf("\t(1) 首次适应算法\t(2) 最佳适应算法\t(3) 最差适应算法\n");printf(" f********************************************************* *\n");printf("\n");printf(" 请输入所使用的内存分配算法:");scanf("%d",&a);while(a<1||a>3){printf(" 输入错误,请重新输入所使用的内存分配算法:\n");scanf("%d",&a);}switch(a)case1:printf("\n\t**** case 2:printf("\n\t**** case 3:printf("\n\t**** 使用首次适应算法:使用最佳适应算法:使用最坏适应算法:}Initblock(); // 开创空间表while(1){show();printf("\t1: 分配内存\t2: 回收内存\t0: printf(" 请输入您的操作:");scanf("%d",&i);if(i==1)allocation(a); // 分配内存****\n");break; ****\n");break; ****\n");break;退出\n");else if(i==2) // 内存回收printf(" 请输入您要释放的分区号:"); scanf("%d",&flag);recovery(flag);}else if(i==0){printf("\n 退出程序\n");break; // 退出}else // 输入操作有误{printf(" 输入有误,请重试!"); continue;八、执行结果和结果分析初始化首次适应算法:当作业1、2、3 顺利分配内存空间后:}回收序号 2 里面的内存:分配作业4:回收序号 3 里面的内存(与上邻序号2相连了)回收序号 1 里的内存(与下邻序号 2 相连了)继续分配(会发现总是按顺序查找满足要求的第一个空闲块,一旦发现就会分配)。

相关文档
最新文档