实验五内存管理实验

一、实验目的

1、了解操作系统动态分区存储管理过程和方法。

2、掌握动态分区存储管理的主要数据结构--空闲表区。

3、加深理解动态分区存储管理中内存的分配和回收。

4、掌握空闲区表中空闲区3种不同放置策略的基本思想和实现过程。

5、通过模拟程序实现动态分区存储管理。

6、了解请求分页虚拟存储管理技术的方法和特点。

7、通过模拟实现请求页式存储管理的几种基本页面置换算法。

8、掌握页面置换算法种缺页率、置换率和命中率的计算方法。

二、实验内容

1、编程模拟实现动态分区管理中内存的分配和回收及空闲区表的管理。（2分）

首次适应算法（First Fit）参考程序：

#include<unistd.h>

#include<stdio.h>

#include<stdlib.h>

#define N 5

struct freearea

{

int startaddr; //空闲区起始地址

int size; //空闲区大小

int state; //1表示空闲，0表示占用

}freeblock[N]={{20,20,1},{80,50,1},{150,100,1},{300,30,1},{600,100,1}};

int alloc(int size)

{

int i,tag=0,allocaddr;

for(i=0;i<N;i++)

{

if(freeblock[i].state==1 && freeblock[i].size>size) //申请空间小于空闲空间

{

allocaddr=freeblock[i].startaddr; //作业地址

freeblock[i].startaddr+=size; //新空闲区起始地址

freeblock[i].size-=size; //新空闲区大小

tag=1; //分配标记

break;

}

else if(freeblock[i].state==1 && freeblock[i].size==size)//申请空间正好等于空闲空间

{

allocaddr=freeblock[i].startaddr;

freeblock[i].state=0;tag=1;

break;

}

if(tag==0) //表示没找到合适的空闲区，未分配内存

allocaddr=-1;

return allocaddr; //返回作业地址

}

void setfree(int addr,int size) //传过来的参数是要释放内存的起始地址和大小

{

int i,tag1=0,tag2=0,n1=0,n2=0;

for(i=0;i<N;i++)

{

if(freeblock[i].startaddr+freeblock[i].size==addr && freeblock[i].state==1)

{

tag1=1; //有上邻标记

n1=i; //记录上邻数组位置（分区号）

break;

}

for(i=0;i<N;i++)

{

if(freeblock[i].startaddr==addr+size && freeblock[i].state==1)

{

tag2=1; //有下邻标记

n2=i; //记录下邻数组位置（分区号）

break;

}

if(tag1==1 && tag2==0) //有上邻无下邻

{

freeblock[n1].size+=size;

}

else if(tag1==1 && tag2==1) //有上邻有下邻

{

freeblock[n1].size+=freeblock[n2].size+size;

freeblock[n2].state=0;//？？？

}

else if(tag1==0 && tag2==1) //无上邻有下邻

{

freeblock[n2].startaddr=addr;

freeblock[n2].size+=size;

}

else //无上邻无下邻（表明空间正好全部分配出去，空间的状态为0）

{

for(i=0;i<N;i++)

{

if(freeblock[i].state==0) //通过空间状态值找到这块空间

{

freeblock[i].startaddr=addr;

freeblock[i].size=size;

freeblock[i].state=1;

break;

}

void adjust()

{

int i,j;

struct freearea temp;

for(i=1;i<N;i++) //依据首次适应算法将空闲区按起始地址由低到高冒泡排序

{

for(j=0;j<N-i;j++)

{

if(freeblock[j].startaddr>freeblock[j+1].startaddr)

{

temp=freeblock[j];

freeblock[j]=freeblock[j+1];

freeblock[j+1]=temp;

}

for(i=1;i<N;i++) //把状态为0的排到后面

{

for(j=0;j<N-i;j++)

{

if(freeblock[j].state==0 && freeblock[j+1].state==1)

{

temp=freeblock[j];

freeblock[j]=freeblock[j+1];

freeblock[j+1]=temp;

}

void print()

{

int i;

printf("\t|-------------------------------|\n");

printf("\t|startaddr size state |\n");

for(i=0;i<N;i++)

printf("\t|%4d %4d %4d |\n",freeblock[i].startaddr,freeblock[i].size,freeblock[i].state);

}

int main()

{

int size,addr;

char c1,c2,c;

printf("At first the free memory is this:\n");//首先，空闲区是这样的

adjust();

print();

printf("Is there any job request memory?(y or n):");//有作业需要申请内存么？

while((c1=getchar())=='y')

{

printf("Input request memory size:"); //输入所需内存大小

scanf("%d",&size);

addr=alloc(size); //调用内存分配函数，返回的是作业的起始地址

if(addr==-1)

printf("There is no fit memory.Please wait!!!\n");

else

{

printf("Job's memory start address is:%d\n",addr); //输出作业的起始地址

printf("Job's size is:%d\n",size); //输出作业大小

printf("After allocation the free memory is this:\n"); //分配后可用内存如下： adjust();

print();

printf("Job is running.\n");

}

getchar();

printf("Is there any memory for free?(y or n):");//有需要释放的内存么？

while((c2=getchar())=='y')

{

printf("Input free area startaddress:");

scanf("%d",&addr); //输入要释放内存的起始地址

printf("Input free area size:");

scanf("%d",&size); //输入要释放内存的大小

setfree(addr,size); //调用释放内存函数

adjust();

print();

getchar();

printf("Is there any memory for free?(y or n):");

}

getchar();

printf("Is there any job request memory?(y or n):");

}

return 0;

}

运行结果截屏（包含分配和回收两部分）:

分析该程序，列出各模块实现的功能：

alloc()

根据作业的大小申请空闲内存区域，并返回作业的起始地址。

2）setfree()

释放指定起始地址和大小的内存区域，将其设置为空闲状态。

3) adjust()

根据首次适应算法对空闲区进行排序和整理。

修改上题，用最佳适应算法和最坏适应算法模拟内存空间的分配和回收。（4分）

注：只需列出程序不同部分，无需将整个程序列出。

最佳适应算法

int best_fit_alloc(int size) {

int i, allocaddr = -1, min_size = INT_MAX;

for (i = 0; i < N; i++) {

if (freeblock[i].state == 1 && freeblock[i].size >= size && freeblock[i].size < min_size) {

allocaddr = freeblock[i].startaddr;

min_size = freeblock[i].size;

}

if (allocaddr != -1) {

for (i = 0; i < N; i++) {

if (freeblock[i].startaddr == allocaddr) {

if (freeblock[i].size > size) {

freeblock[i].startaddr += size;

freeblock[i].size -= size;

} else {

freeblock[i].state = 0;

}

break;

}

return allocaddr;

}

最坏适应算法

int worst_fit_alloc(int size) {

int i, allocaddr = -1, max_size = -1;

for (i = 0; i < N; i++) {

if (freeblock[i].state == 1 && freeblock[i].size >= size && freeblock[i].size > max_size) {

allocaddr = freeblock[i].startaddr;

max_size = freeblock[i].size;

}

if (allocaddr != -1) {

for (i = 0; i < N; i++) {

if (freeblock[i].startaddr == allocaddr) {

if (freeblock[i].size > size) {

freeblock[i].startaddr += size;

freeblock[i].size -= size;

} else {

freeblock[i].state = 0;

}

break;

}

return allocaddr;

}

编写程序实现先进先出页面置换算法，并计算缺页次数，缺页率，置换次数和命中率。（2分）

参考程序：

#include <stdio.h>

//初始化内存队列

void initializeList(int list[],int number){

int i;

for (i = 0; i < number; i ++) {

list[i] = -1;

}

//展示要访问页面号数组

void showList(int list[], int number){

int i;

for (i = 0; i < number; i ++) {

printf("%2d",list[i]);

}

printf("\n");

}

//展示当前内存状态

void showMemoryList(int list[],int phyBlockNum){

int i;

for (i = 0; i < phyBlockNum; i ++) {

if (list[i] == -1) {

break;

}

printf(" |%d|",list[i]);

}

printf("\n");

}

//计算各项指标

void informationCount(int missingCount,int replaceCount,int pageNum){

printf("缺页次数:%d 缺页率:%d/%d\n",missingCount,missingCount,pageNum);

double result = (double)(pageNum - missingCount)/(double)pageNum;

printf("置换次数:%d 命中率:%.2f\n",replaceCount,result);

}

//先进先出置换算法

void replacePageByFIFO(int memoryList[],int phyNum,int strList[],int pageNum){

//置换次数

int replaceCount = 0;

//缺页次数

int missingCount = 0;

//记录当前最早进入内存的下标

int pointer = 0;

//记录当前页面的访问情况: 0 未访问

int i,j,isVisited = 0;

for (i = 0; i < pageNum; i ++) {

isVisited = 0;

//判断是否需要置换->内存已满且需要访问的页面不在内存中

for (j = 0; j < phyNum; j ++) {

if (memoryList[j] == strList[i]) {

//该页面已经存在内存中

//修改访问情况

isVisited = 1;

//展示

printf("%d\n",strList[i]);

break;

}

if (memoryList[j] == -1) {

//页面不在内存中且内存未满->直接存入

memoryList[j] = strList[i];

//修改访问情况

isVisited = 1;

missingCount ++;

//展示

printf("%d\n",strList[i]);

showMemoryList(memoryList, phyNum);

break;

}

if (!isVisited) {

//当前页面还未被访问过->需要进行页面置换

//直接把这个页面存到所记录的下标中

memoryList[pointer] = strList[i];

//下标指向下一个

pointer ++;

//如果到了最后一个，将下标归零

if (pointer > phyNum-1) {

pointer = 0;

}

missingCount ++;

replaceCount ++;

//展示

printf("%d\n",strList[i]);

showMemoryList(memoryList, phyNum);

}

informationCount(missingCount, replaceCount, pageNum);//计算各项指标

}

int main(int argc, const char * argv[]) {

//物理块的数量

int phyBlockNum;

printf("请输入物理块数量:\n");

scanf("%d",&phyBlockNum);

//生成内存队列数组

int memoryList[phyBlockNum];

//初始化内存状态

initializeList(memoryList, phyBlockNum);

//showMemoryList(memoryList,phyBlockNum);

//页面数量

int pageNum;

printf("请输入要访问的页面总数:\n");

scanf("%d",&pageNum);

//保存页面号数组

int pageNumStrList[pageNum];

int i;

//将要访问的页面号存入数组中

printf("请输入要访问的页面号:\n");

for (i = 0; i < pageNum; i ++) {

scanf("%d",&pageNumStrList[i]);

}

//显示要访问页面号数组中内容

showList(pageNumStrList, pageNum);

int chose;

while (1) {

printf("请选择所需的置换算法:\n");

printf("1.FIFO 2.退出\n");

scanf("%d",&chose);

switch (chose) {

case 1:

//显示要访问页面号数组中内容

showList(pageNumStrList, pageNum);

//调用先进先出置换算法

replacePageByFIFO(memoryList, phyBlockNum, pageNumStrList, pageNum);

//重新初始化内存

initializeList(memoryList , phyBlockNum);

break;

default:

return 0;

break;

}

return 0;

}

编译及执行过程以及结果截屏：

分析程序功能：

1.用户输入物理块数量和要访问的页面总数。

2.用户输入要访问的页面号，将其存入一个数组中。

3.用户选择要使用的置换算法，目前只支持FIFO算法。

4.程序调用replacePageByFIFO函数来执行FIFO算法： a. 该函数通过遍历页面号数组，判断页面是否在内存中，如果在则不进行操作，如果不在则进行页面置换。 b. 如果内存未满，直接将页面存入内存；如果内存已满，将最早进入内存的页面置换出去，并将新页面存入内存。 c. 统计缺页次数和置换次数，并展示当前内存状态。

5.调用informationCount函数计算并展示各项指标，包括缺页次数、缺页率、置换次数和命中率。

6.重新初始化内存，回到步骤3，直到用户选择退出程序为止。

编程实现其它页面置换算法（如最近最久未使用算法或最佳置换算法等），计算缺页次数，缺页率，置换次数和命中率。（1分）

#include <stdio.h>

#define MAX_PAGES 100

#define MAX_FRAMES 10

// 初始化页面访问序列

void initializePages(int pages[], int numPages) {

printf("请输入页面访问序列（以-1结束）：\n");

int i = 0;

do {

scanf("%d", &pages[i]);

i++;

} while (pages[i-1] != -1 && i < numPages);

}

// LRU算法

int lru(int pages[], int numPages, int numFrames) {

int frames[MAX_FRAMES] = {-1}; // 帧表

int lruCount[MAX_FRAMES] = {0}; // 记录每个帧最后一次使用的时间

int numFaults = 0; // 缺页次数

int numReplacements = 0; // 置换次数

int numHits = 0; // 命中次数

int time = 0; // 记录时间

for (int i = 0; i < numPages; i++) {

int page = pages[i];

int j;

for (j = 0; j < numFrames; j++) {

if (frames[j] == page) {

numHits++;

lruCount[j] = time;

break;

}

if (j == numFrames) {

int lruIndex = 0;

for (int k = 1; k < numFrames; k++) {

if (lruCount[k] < lruCount[lruIndex]) {

lruIndex = k;

}

frames[lruIndex] = page;

lruCount[lruIndex] = time;

numFaults++;

numReplacements++;

}

time++;

}

printf("\nLRU算法结果：\n");

printf("缺页次数：%d\n", numFaults);

printf("缺页率：%f\n", (float)numFaults/numPages);

printf("置换次数：%d\n", numReplacements);

printf("命中率：%f\n\n", (float)numHits/numPages);

return numFaults;

}

// 最佳置换算法

int optimal(int pages[], int numPages, int numFrames) {

int frames[MAX_FRAMES] = {-1}; // 帧表

int numFaults = 0; // 缺页次数

int numReplacements = 0; // 置换次数

int numHits = 0; // 命中次数

for (int i = 0; i < numPages; i++) {

int page = pages[i];

int j;

for (j = 0; j < numFrames; j++) {

if (frames[j] == page) {

numHits++;

break;

}

if (j == numFrames) {

int replaceIndex = -1;

int found = 0;

for (int k = 0; k < numFrames; k++) {

int m;

for (m = i+1; m < numPages; m++) {

if (frames[k] == pages[m]) {

found = 1;

if (m > replaceIndex) {

replaceIndex = m;

}

break;

}

if (!found) {

replaceIndex = k;

break;

}

frames[replaceIndex] = page;

numFaults++;

numReplacements++;

}

printf("最佳置换算法结果：\n");

printf("缺页次数：%d\n", numFaults);

printf("缺页率：%f\n", (float)numFaults/numPages);

printf("置换次数：%d\n", numReplacements);

printf("命中率：%f\n\n", (float)numHits/numPages);

return numFaults;

}

int main() {

int pages[MAX_PAGES];

int numPages;

int numFrames;

printf("请输入页面数：");

scanf("%d", &numPages);

printf("请输入帧数：");

scanf("%d", &numFrames);

initializePages(pages, numPages);

lru(pages, numPages, numFrames);

optimal(pages, numPages, numFrames);

return 0;

}

编程用动态分区链形式模拟动态分区管理中内存的分配和回收，采用3种算法（首次适应算法，最佳适应算法，最坏适应算法）实现。（附加题）

#include <stdio.h>

#include <stdlib.h>

#define MAX_SIZE 100

typedef struct Node {

int start;

int end;

int size;

int status; // 0表示未分配，1表示已分配

struct Node* next;

} Node;

Node* head = NULL;

// 初始化内存

void initMemory() {

head = (Node*)malloc(sizeof(Node));

head->start = 0;

head->end = MAX_SIZE;

head->size = MAX_SIZE;

head->status = 0;

head->next = NULL;

}

// 打印内存分配情况

void printMemory() {

Node* current = head;

while (current != NULL) {

printf("[%d-%d] Size: %d ", current->start, current->end, current->size);

if (current->status == 0) {

printf("Status: Free\n");

} else {

printf("Status: Allocated\n");

}

current = current->next;

}

printf("\n");

}

// 首次适应算法分配内存

void* allocateFirstFit(int size) {

Node* current = head;

while (current != NULL) {

if (current->status == 0 && current->size >= size) {

int remainingSize = current->size - size;

if (remainingSize > 0) {

Node* newNode = (Node*)malloc(sizeof(Node));

newNode->start = current->start;

newNode->end = current->start + size;

newNode->size = size;

newNode->status = 1;

newNode->next = current->next;

current->start = newNode->end;

current->size = remainingSize;

current->next = newNode;

} else {

current->status = 1;

}

return (void*)current->start;

}

current = current->next;

}

return NULL;

}

// 最佳适应算法分配内存

void* allocateBestFit(int size) {

Node* current = head;

Node* bestFitBlock = NULL;

int bestFitSize = MAX_SIZE + 1;

while (current != NULL) {

if (current->status == 0 && current->size >= size && current->size < bestFitSize) {

bestFitBlock = current;

bestFitSize = current->size;

}

current = current->next;

}

if (bestFitBlock != NULL) {

int remainingSize = bestFitBlock->size - size;

if (remainingSize > 0) {

Node* newNode = (Node*)malloc(sizeof(Node));

newNode->start = bestFitBlock->start;

newNode->end = bestFitBlock->start + size;

newNode->size = size;

newNode->status = 1;

newNode->next = bestFitBlock->next;

bestFitBlock->start = newNode->end;

bestFitBlock->size = remainingSize;

bestFitBlock->next = newNode;

} else {

bestFitBlock->status = 1;

}

return (void*)bestFitBlock->start;

}

return NULL;

}

// 最坏适应算法分配内存

void* allocateWorstFit(int size) {

Node* current = head;

Node* worstFitBlock = NULL;

int worstFitSize = -1;

while (current != NULL) {

if (current->status == 0 && current->size >= size && current->size > worstFitSize) {

worstFitBlock = current;

worstFitSize = current->size;

}

current = current->next;

}

if (worstFitBlock != NULL) {

int remainingSize = worstFitBlock->size - size;

if (remainingSize > 0) {

Node* newNode = (Node*)malloc(sizeof(Node));

newNode->start = worstFitBlock->start;

newNode->end = worstFitBlock->start + size;

newNode->size = size;

newNode->status = 1;

newNode->next = worstFitBlock->next;

worstFitBlock->start = newNode->end;

worstFitBlock->size = remainingSize;

worstFitBlock->next = newNode;

} else {

worstFitBlock->status = 1;

}

return (void*)worstFitBlock->start;

}

return NULL;

}

// 回收内存

void deallocate(void* addr) {

Node* current = head;

Node* prev = NULL;

while (current != NULL) {

if (current->start == (int)addr) {

current->status = 0;

// 合并相邻的空闲块

if (prev != NULL && prev->status == 0) {

prev->end = current->end;

prev->size += current->size;

prev->next = current->next;

free(current);

current = prev;

}

if (current->next != NULL && current->next->status == 0) {

current->end = current->next->end;

current->size += current->next->size;

Node* temp = current->next->next;

free(current->next);

current->next = temp;

}

return;

}

prev = current;

current = current->next;

}

int main() {

initMemory();

printMemory();

void* addr1 = allocateFirstFit(20);

printf("Allocated block: [0-20]\n");

printMemory();

void* addr2 = allocateBestFit(30);

printf("Allocated block: [20-50]\n");

printMemory();

void* addr3 = allocateWorstFit(40);

printf("Allocated block: [50-90]\n");

printMemory();

deallocate(addr2);

printf("Deallocated block: [20-50]\n");

printMemory();

deallocate(addr1);

printf("Deallocated block: [0-20]\n");

printMemory();

void* addr4 = allocateBestFit(70);

printf("Allocated block: [0-70]\n");

printMemory();

return 0;

}

三、实验总结和体会（1分）

通过实际编写程序实现内存分配与回收的算法，我更加理解了这些算法的原理和实现方式。其次，通过对比不同算法的性能，我能够更加准确地选择适合当前需求的算法。最后，我还学到了一些实际应用中的内存管理技巧和策略，为日后的工作打下了基础。

在实验过程中，我发现自己对于某些算法和概念的理解还不够深入，需要进一步学习和加强。此外，我在实验中遇到了一些问题，如编写不完善的算法导致程序出错等，这些问题提醒我需要加强对代码质量和细节的把控。