动态多分区存储管理模拟系统

操作系统课程设计实验报告

设计题目三：动态多分区存储管理模拟系统

——

一、设计题目要求

   1、对理论课中学习的内存管理当中的概念做进一步的理解；

   2、了解内存管理任务的主要实现方法；

   3、掌握内存的分配，回收等主要算法的原理；

   4、通过编程，熟悉分区式存储管理方法中内存分配回收算法的实现方法。

二、程序设计思路及流程图

   程序功能简介：

    主存分配函数：寻找空闲分区，空闲分区表的修改，已分配分区表的修改。其中，若寻找到的最小适合空间相对作业请求的空间来说仍过大，则要分割该分区。

主存回收函数：回收作业释放的分区、修改已分配分区表、修改空闲分区表。其中，若回收的分区有上邻空闲分区或（和）下邻空闲分区的，要合并成为一个空闲分区，登记在空闲分区表的一个表项里。

程序设计思路：

（1）设计一个用来记录主存使用情况的数据结构，登记空闲区和作业区占用的情况；

（2）在设计好的该数据结构上面，再设计一个主存分配算法；

（3）在设计好的该数据结构上面，再设计一个主存回收算法。

开始时，纠结于使用什么数据结构来构建空闲分区表和一个分配表，很明显的是，链表比静态的数组更好一点。但是在思考链表的使用时，竟然错误地定义了两种类型的链表，其实没有必要的，因为这两个表的内容是相同的，一个类型就可以了。这我也是第一次在一个程序里面声明两个链表，对两个链表进行操作。

程序流程图：

见附录A

三、涉及的背景知识及所用函数简介

1、malloc函数

函数原型 ：void *malloc(unsigned int num_bytes);

头文件 ：stdlib.h

作用 ：分配长度为num_bytes字节的内存块

返回值 ：分配成功则返回指向被分配内存的指针，否则返回空指针NULL。

2、freopen函数

函数原型 ：FILE *freopen(char *filename ,char *type,FILE *stream);

头文件 ：stdio.h

作用 ：替换一个流，或者说重新分配文件指针，实现重定向。

参数 ：filename:要打开的文件名

stream:文件指针，通常使用标准流文件

返回值 ：成功返回参数文件指针。

3、strcmp函数

函数原型 ：extern int strcmp(const char *s1,const char *s2); 

头文件 ：string.h

作用 ：比较字符串s1和s2

参数 ：s1:第一个字符串

s2:第二个字符串

返回值 ：如果s1小于s2,返回负数；如果s1大于s2，返回正数；二者相等 返回0.

4、strcpy 函数

函数原型 ：extern char strcpy(char dest,const char src); 

头文件 ：string,h

作用 ：把从src地址开始且含有NULL结束符的字符串复制到已dest开始 的地址空间

参数 ：scr:原串

Dest：目标串

返回值 ：目标串的地址

四、程序所用数据结构简介

int choose :选择要进行的操作；

#define total_size 128：磁盘的总大小；

 

typedef struct node

{

    char name[5];

    float address;

    float length;

    int flag;

    struct node *next;

}node, *pnode;

定义结点类型；

 

typedef struct 

{

    node *head;

}linklist, *plinklist;

定义链表类型；

linklist used_table, free_table;声明两条链表；

plinklist pused_table, pfree_table; 声明两个指向链表的指针；

 

void system_init(); 初始化系统，创建两条链表；

plinklist create_list_in_head();  创建链表；

void insert_node_address_asc(plinklist pl, pnode item);按地址升序在链表中插入结点；

void insert_node_length_asc(plinklist pl, pnode item);按空间大小升序在链表中插入结点；

void insert_node_length_desc(plinklist pl, pnode item);按空间大小降序在链表中插入结点；

void delete_node_in_list(plinklist pl, pnode item);从链表中删除结点；

void display_node_in_list(plinklist pl);显示链表中的所有结点；

void ff();调用首次适应算法ff；

void bf();调用最佳适应算法bf；

void wf();调用最坏适应算法为wf；

五、程序源代码

见附录B

六、调试方案及调试过程记录与分析

输入文件选取：

本程序共3个输入文件，每种算法分别对应一个txt测试数据，见附录B。

输入数据的处理：

采用重定向输入法freopen(“in.txt”, “r”, stdin);

即改变输入路径，不从键盘上输入，而是从文件中读取；

因此，在主函数中只能有一次选择使用哪种算法，若要再次选择其他算法，则需再次输入命令./main。

 

测试结果、调试过程：

第一次测试结果：文件数据读取错误，数据读取错位。

第一次调试：去掉while(1),重新执行，文件可以正常读取。

第二次测试结果：输出结果陷入死循环。

第二次调试：接受数据的elem变量在接收完一次数据之后没有做初始化处理。

第三次测试结果：结果可以正常输出，但wf算法，并未按空间大小降序排列。

第三次调试：在合并分区时，借用临时变量存储curr。

第四次测试结果：合并可以正常运行，经测试，三种算法均正常执行，结果也是正确的。

七、思考与体会

这次写代码时，没有备份，一不小心把代码全部用rm命令删除了，当时真是欲哭无泪，白辛苦了这么长时间，就这样被自己毁了，还好，用了一个上午重新写了一下，血的教训呀！ 

要熟练掌握链表的操作，插入，删除。注意特殊情况的处理，比如prev为空时；遍历结束，curr为空时；链表中没有结点时，只有一个结点时，都要认真考虑。

合并的原则：即在物理空间上，地址连续的可以进行合并。

在bf,wf实现时，分区的合并处理，对elem的影响时时变化，所以elem得值也要时时改变，否则，会出现相邻分区未合并的情况。

 程序源代码：

源文件名：main.c
内容：/
*************************************************************************
> File Name: main.c
> Author:
> Mail:
>CreatedTime:2014年10月24日 星期五 10时35分43秒************************************************************************/

#include"linklist.h"
int main(void)
{
int choose;
// while(1)//
// {
printf("Welcome!But you should konw that you can run one time. If you want to run again, please input ./main again.\n");
printf("******1.First Fit 2.Best fit *******\n");
printf("******3.Worst Fit 4.exit *******\n");
printf("Please choose the case(1-4):\n");
scanf("%d", &choose);
system_init();
switch(choose)
{
case 1:
ff();
break;

case 2:
bf();
break;

case 3:
wf();
break;

case 4:
exit(0);

default:
printf("Your input is wrong, please input again!\n");
}
// }
return 0;
}

/*************************************************************************
> File Name: linklist.c
> Author:
> Mail:
> Created Time: 2014年10月24日 星期五 10时 30分53秒
************************************************************************/

#include"linklist.h"
plinklist create_list_in_head()
{
plinklist pl = (linklist *)malloc(sizeof(linklist));
pl->head = NULL;//init the head node;
return pl;
}
void system_init()
{
pused_table = create_list_in_head();
pfree_table = create_list_in_head();

pnode item = (node *)malloc(sizeof(node));
item->next = NULL;
item->length = total_size;
item->address = 0;
item->flag = 0;
strcpy(item->name, "pf");
pfree_table->head =item;
printf("List:pfree_table:\n");
display_node_in_list(pfree_table);
return ;
}
void insert_node_address_asc(plinklist pl, pnode item)
{
pnode curr, prev;
if(pl->head == NULL)
{
item->next = pl->head;
pl->head = item;
return;
}
for(curr = pl->head, prev = NULL; curr != NULL; prev = curr, curr = curr->next)
{
if(item->address <= curr->address)
{
if(prev == NULL)
{
item->next = curr;
pl->head = item;
return;
}
else
{
break ;
}
}
}
item->next = curr;
prev->next = item;
return ;
}
void insert_node_length_asc(plinklist pl, pnode item)
{
pnode curr, prev;
if(pl->head == NULL)
{
item->next = pl->head;
pl->head = item;
return;
}
for(curr = pl->head, prev = NULL; curr != NULL; prev = curr, curr = curr->next)
{
if(item->length < curr->length)
{
if(prev == NULL)
{
item->next = curr;
pl->head = item;
return;
}
else
break;
}
}
item->next = curr;
prev->next = item;
return ;
}
void insert_node_length_desc(plinklist pl, pnode item)
{
pnode curr, prev;
if(pl->head == NULL)
{
item->next = pl->head;
pl->head = item;
return ;
}
for(curr = pl->head, prev = NULL; curr != NULL; prev = curr, curr = curr->next)
{
if(item->length > curr->length)
{
if(prev == NULL)
{
item->next = curr;
pl->head = item;
return;
}
else
break;
}
}
item->next = curr;
prev->next = item;
return;
}
void delete_node_in_list(plinklist pl, pnode item)
{
pnode curr, prev;
if(pl->head == NULL)
{
printf("the list is null!\n");
return;
}
for(curr = pl->head, prev = NULL; curr != NULL; prev = curr, curr = curr->next)
{
if(strcmp(curr->name, item->name) == 0)
{
if(prev == NULL)
{
pl->head = curr->next;
}
else
prev->next = curr->next;
return;
}
}
printf("Cannot find the nodeitem!\n");
return ;
}
void display_node_in_list(plinklist pl)
{
pnode p = pl->head;
int i = 0;
while(p)
{
printf("display_node[%d]:%s\t%f\t%f\n", i, p->name, p->address, p->length);
p = p->next;
i++;
}
return ;
}
/*************************************************************************
> File Name: ff.c
> Author:
> Mail:
> Created Time: 2014年10月24日 星期五 10时44分30秒
************************************************************************/

#include"linklist.h"
void ff()
{
pnode elem = (pnode)malloc(sizeof(node));
freopen("ff.txt", "r", stdin);
// freopen("ffout.txt", "w", stdout);
while(scanf("%s%f%d", elem->name, &elem->length, &elem->flag) != EOF)
{
printf("\nRead from the ff.txt:\t%s\t%f\t%d\n", elem->name, elem->length, elem->flag);
if(elem->flag == 0)//distribute ;
{
pnode curr, prev;
for(curr = pfree_table->head, prev = NULL; curr != NULL; prev = curr, curr = curr->next)//scan the free_table;
{
if(curr->length >= elem->length)//find a free_table node;
{
elem->address = curr->address;
elem->flag = 1;
elem->next = NULL;
if(curr->length > elem->length)//divide;
{
insert_node_address_asc(pused_table, elem);
curr->length -= elem->length;
curr->address += elem->length;
break;
}
else
{
insert_node_address_asc(pused_table, elem);
delete_node_in_list(pfree_table, curr);
break;
}
}//if
}//for
}
else//free the used_table;
{
pnode curr, prev;
for(curr = pused_table->head, prev = NULL; curr != NULL; prev = curr, curr = curr->next)//scan the used_table node;
{
if(strcmp(elem->name, curr->name) == 0)
{
elem->address = curr->address;//**
elem->flag = 0;
elem->next = NULL;
insert_node_address_asc(pfree_table, elem);
delete_node_in_list(pused_table, elem);
break;
}
}//for
//merge;
pnode c, p;
for(c = pfree_table->head, p = NULL; c!= NULL; p = c, c = c->next)
{
if(strcmp(elem->name, c->name) == 0)
{
if(p == NULL)
{
if(c->address + c->length == (c->next)->address)
{
c->next->length += c->length;
c->next->address = c->address;
delete_node_in_list(pfree_table, c);
break;
}
}
else if(c->next == NULL)
{
if(p->address + p->length == c->address)
{
c->address = p->address;
c->length += p->length;
delete_node_in_list(pfree_table, p);
break;
}
}
else
{
if(p->address + p->length + c->length == c->next->address)
{
c->next->address = p->address;
c->next->length += p->length + c->length;
delete_node_in_list(pfree_table, p);
delete_node_in_list(pfree_table, c);
break;
}
}
}//if
}//for
}//else
printf("The two list:\n");
printf("List1:pfree_table:\n");
display_node_in_list(pfree_table);
printf("List2:pused_table:\n");
display_node_in_list(pused_table);

elem = (pnode)malloc(sizeof(node));//***
}//while
return ;
}
/*************************************************************************
> File Name: bf.c
> Author:
> Mail:
> Created Time: 2014年10月24日 星期五 10时45分59秒
************************************************************************/

#include"linklist.h"
void bf()
{
pnode elem = (pnode)malloc(sizeof(node));
freopen("bf.txt", "r", stdin);
// freopen("bfout.txt", "w", stdout);
while(scanf("%s%f%d", elem->name, &elem->length, &elem->flag) != EOF)
{
printf("\nRead from the bf.txt:\t%s\t%f\t%d\n", elem->name, elem->length, elem->flag);
if(elem->flag == 0)//distribute ;
{
pnode curr, prev;
for(curr = pfree_table->head, prev = NULL; curr != NULL; prev = curr, curr = curr->next)//scan the free_table;
{
if((*curr).length >= elem->length)//find the first free_table node;
{
elem->address = curr->address;
elem->flag = 1;
elem->next = NULL;
if(curr->length > elem->length)//divide;
{
insert_node_length_asc(pused_table, elem);
curr->length -= elem->length;
curr->address += elem->length;

pnode item = (pnode)malloc(sizeof(node));
*(item) = *(curr);
item->next = NULL;
delete_node_in_list(pfree_table, curr);
insert_node_length_asc(pfree_table, item);
break;
}
else
{
insert_node_length_asc(pused_table, elem);
delete_node_in_list(pfree_table, curr);
break;
}
}
}
}
else//free the used_table;
{
pnode curr, prev;
for(curr = pused_table->head, prev = NULL; curr != NULL; prev = curr, curr = curr->next)//scan the used_table node;
{
if(strcmp(elem->name, curr->name) == 0)
{
elem->flag = 0;
elem->address = curr->address;
elem->next = NULL;
insert_node_length_asc(pfree_table, elem);
delete_node_in_list(pused_table, curr);
break;
}
}
//merge;
pnode c, p;
for(c = pfree_table->head, p = NULL; c!= NULL; p = c, c = c->next)
{
if(c->address + c->length == elem->address)
{
c->length += elem->length;
delete_node_in_list(pfree_table, elem);

pnode item = (pnode)malloc(sizeof(node));
*(item) = *(c);
item->next = NULL;
delete_node_in_list(pfree_table, c);
insert_node_length_asc(pfree_table, item);

*(elem) = *(item);
elem->next = NULL;
}
if(elem->address + elem->length == c->address)
{
c->address = elem->address;
c->length += elem->length;
delete_node_in_list(pfree_table, elem);

pnode item = (pnode)malloc(sizeof(node));
*(item) = *(c);
item->next = NULL;
delete_node_in_list(pfree_table, c);
insert_node_length_asc(pfree_table, item);

*(elem) = *(item);
elem->next = NULL;
}
}//for
}//else
printf("The two list:\n");
printf("List1:pfree_table:\n");
display_node_in_list(pfree_table);
printf("List2:pused_table:\n");
display_node_in_list(pused_table);

elem = (pnode)malloc(sizeof(node));
}
return ;
}
/*************************************************************************
> File Name: wf.c
> Author:
> Mail:
>CreatedTime:2014年10月24日 星期五 10时46分27秒
************************************************************************/

#include"linklist.h"
void wf()
{
pnode elem = (pnode)malloc(sizeof(node));
freopen("wf.txt", "r", stdin);
// freopen("wfout.txt", "w", stdout);
while(scanf("%s%f%d", elem->name, &elem->length, &elem->flag) != EOF)
{
printf("\nRead from the wf.txt:\t%s\t%f\t%d\n", elem->name, elem->length, elem->flag);
if(elem->flag == 0)//distribute ;
{
pnode curr, prev;
for(curr = pfree_table->head, prev = NULL; curr != NULL; prev = curr, curr = curr->next)//scan the free_table;
{
if((*curr).length >= elem->length)//find the first free_table node;
{
elem->address = curr->address;
elem->flag = 1;
insert_node_length_desc(pused_table, elem);
curr->length -= elem->length;
curr->address += elem->length;

pnode item = (pnode)malloc(sizeof(node));
*(item) = *(curr);
item->next = NULL;
delete_node_in_list(pfree_table, curr);
insert_node_length_desc(pfree_table, item);
break;
}
else
{
insert_node_length_desc(pused_table, elem);
delete_node_in_list(pfree_table, curr);
break;
}
}
}
else//free the used_table;
{
pnode curr, prev;
for(curr = pused_table->head, prev = NULL; curr != NULL; prev = curr, curr = curr->next)//scan the used_table node;
{
if(strcmp(elem->name, curr->name) == 0)
{
elem->flag = 0;
elem->address = curr->address;
elem->next = NULL;
printf("elem->address = %f\n", elem->address);
insert_node_length_desc(pfree_table, elem);
delete_node_in_list(pused_table, curr);
break;
}
}
//merge;
pnode c, p;
for(c = pfree_table->head, p = NULL; c!= NULL; p = c, c = c->next)
{
if(c->address + c->length == elem->address)
{
c->length += elem->length;
delete_node_in_list(pfree_table, elem);

pnode item = (pnode)malloc(sizeof(node));
*(item) = *(c);
item->next = NULL;
delete_node_in_list(pfree_table, c);
insert_node_length_desc(pfree_table, item);

*(elem) = *(item);
elem->next = NULL;
}
if(elem->address + elem->length == c->address)
{
c->address = elem->address;
c->length += elem->length;
delete_node_in_list(pfree_table, elem);

pnode item = (pnode)malloc(sizeof(node));
*(item) = *(c);
item->next = NULL;
delete_node_in_list(pfree_table, c);
insert_node_length_desc(pfree_table, item);

*(elem) = *(item);
elem->next = NULL;
}
}//for
}//else
printf("The two list:\n");
printf("List1:pfree_table:\n");
display_node_in_list(pfree_table);
printf("List2:pused_table:\n");
display_node_in_list(pused_table);

elem = (pnode)malloc(sizeof(node));
}
return ;
}
/*************************************************************************
> File Name: linklist.h
> Author:
> Mail:
> Created Time: 2014年10月24日 星期五 10时45分53秒
************************************************************************/

#ifndef _LINKLIST_H
#define _LINKLIST_H
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#define total_size 128

typedef struct node
{
char name[5];
float address;
float length;
int flag;
struct node *next;
}node, *pnode;

typedef struct
{
node *head;
}linklist, *plinklist;

linklist used_table, free_table;
plinklist pused_table, pfree_table;

void system_init();
plinklist create_list_in_head();
void insert_node_address_asc(plinklist pl, pnode item);
void insert_node_length_asc(plinklist pl, pnode item);
void insert_node_length_desc(plinklist pl, pnode item);
void delete_node_in_list(plinklist pl, pnode item);
void display_node_in_list(plinklist pl);

void ff();
void bf();
void wf();

#endif

Makefile:
vpath %.h ./
main: main.o linklist.o ff.o bf.o wf.o linklist.h
gcc -o main main.o linklist.o ff.o bf.o wf.o
main.o:main.c linklist.c ff.c bf.c wf.c linklist.h
gcc -c main.c linklist.c ff.c bf.c wf.c
linklist.o: linklist.c linklist.h
gcc -c linklist.c
ff.o:ff.c linklist.c linklist.h
gcc -c ff.c linklist.c
bf.o:bf.c linklist.c linklist.h
gcc -c bf.c linklist.c
wf.o:wf.c linklist.c linklist.h
gcc -c wf.c linklist.c
测试数据：

ff.txt:
P1 28 0
P2 50 0
P3 24 0
P2 50 1
P4 42 0
P1 28 1
P5 25 0
P6 26 0
P4 42 1
b.txt:
P1 28 0
P2 50 0
P3 24 0
P1 28 1
P4 8 0
P3 24 1
P5 18 0
P4 8 1
wf.txt:
P1 28 0
P2 50 0
P3 24 0
P1 28 1
P4 25 0
P2 50 1
P3 24 1