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

合集下载

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

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

#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;}。

  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 相连了)继续分配(会发现总是按顺序查找满足要求的第一个空闲块,一旦发现就会分配)。

相关文档
最新文档