#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#define PROCESS_NAME_LEN 32 /*进程名称的最大长度*/
#define MIN_SLICE 10 /*最小碎片的大小*/
#define DEFAULT_MEM_SIZE 1024 /*默认内存的大小*/
#define DEFAULT_MEM_START 0 /*默认内存的起始位置*/
/* 内存分配算法 */
#define MA_FF 1
#define MA_BF 2
#define MA_WF 3
#define MA_NF 4
int mem_size = DEFAULT_MEM_SIZE; /*内存大小*/
int ma_algorithm = MA_FF; /*当前分配算法*/
int flag = 0; /*设置内存大小标志*/
static int pid = 0; /*初始pid*/
int algorithm;
/*描述每一个空闲块的数据结构*/
struct free_block_type {
int size;
int start_addr;
struct free_block_type *next;
};
/*指向内存中空闲块链表的首指针*/
struct free_block_type *free_block;
struct free_block_type *NF_tmp = NULL;
/*每个进程分配到的内存块的描述*/
struct allocated_block {
int pid;
int size;
int start_addr;
char process_name[PROCESS_NAME_LEN];
struct allocated_block *next;
};
/*进程分配内存块链表的首指针*/
struct allocated_block *allocated_block_head = NULL;
struct allocated_block *find_process(int id) {
struct allocated_block *p;
p = allocated_block_head;
while (p != NULL) {
if (p->pid == id)
return p;
p = p->next;
}
return NULL;
}
void swap(int *p, int *q) {
int temp;
temp = *p;
*p = *q;
*q = temp;
return;
}
void do_exit() { exit(0); }
/*初始化空闲块,默认为一块,可以指定大小及起始地址*/
struct free_block_type *init_free_block(int mem_size) {
struct free_block_type *fb;
fb = (struct free_block_type *)malloc(sizeof(struct free_block_type));
if (fb == NULL) {
printf("No mem\n");
return NULL;
}
fb->size = mem_size;
fb->start_addr = DEFAULT_MEM_START;
fb->next = NULL;
// NF_tmp = fb;
return fb;
}
/*显示菜单*/
void display_menu() {
printf("\n");
printf("1 - Set memory size (default=%d)\n", DEFAULT_MEM_SIZE);
printf("2 - Select memory allocation algorithm\n");
printf("3 - New process \n");
printf("4 - Terminate a process \n");
printf("5 - Display memory usage \n");
printf("0 - Exit\n");
}
/*设置内存的大小*/
set_mem_size() {
int size;
if (flag != 0) { //防止重复设置
printf("Cannot set memory size again\n");
return 0;
}
printf("Total memory size =");
scanf("%d", &size);
if (size > 0) {
mem_size = size;
free_block->size = mem_size;
}
flag = 1;
return 1;
}
/*按FF算法重新整理内存空闲块链表*/
rearrange_FF() {
struct free_block_type *tmp, *work;
printf("Rearrange free blocks for FF \n");
tmp = free_block;
if (ma_algorithm == MA_FF || NF_tmp == NULL)
NF_tmp = free_block;
while (tmp != NULL) {
work = tmp->next;
while (work != NULL) {
if (work->start_addr < tmp->start_addr) { /*地址递增*/
swap(&work->start_addr, &tmp->start_addr);
swap(&work->size, &tmp->size);
}
work = work->next;
}
tmp = tmp->next;
}
}
/*按BF最佳适应算法重新整理内存空闲块链表*/
rearrange_BF() {
struct free_block_type *tmp, *work;
printf("Rearrange free blocks for BF \n");
tmp = free_block;
NF_tmp = free_block;
while (tmp != NULL) {
work = tmp->next;
while (work != NULL) {
if (work->size > tmp->size) { /*地址递增*/
swap(&work->start_addr, &tmp->start_addr);
swap(&work->size, &tmp->size);
}
work = work->next;
}
tmp = tmp->next;
}
}
/*按WF算法重新整理内存空闲块链表*/
rearrange_WF() {
struct free_block_type *tmp, *work;
printf("Rearrange free blocks for WF \n");
tmp = free_block;
NF_tmp = free_block;
while (tmp != NULL) {
work = tmp->next;
while (work != NULL) {
if (work->size > tmp->size) { /*地址递增*/
swap(&work->start_addr, &tmp->start_addr);
swap(&work->size, &tmp->size);
} else
work = work->next;
}
tmp = tmp->next;
}
}
/*按指定的算法整理内存空闲块链表*/
rearrange(int algorithm) {
switch (algorithm) {
case MA_FF:
rearrange_FF();
break;
case MA_BF:
rearrange_BF();
break;
case MA_WF:
rearrange_WF();
break;
case MA_NF:
rearrange_FF();
break;
}
}
/* 设置当前的分配算法 */
void set_algorithm() {
printf("\t1 - First Fit\n");
printf("\t2 - Best Fit \n");
printf("\t3 - Worst Fit \n");
printf("\t4 - Next Fit \n");
scanf("%d", &algorithm);
if (algorithm >= 1 && algorithm <= 4)
ma_algorithm = algorithm;
else
printf("选择不正确!\n");
//按指定算法重新排列空闲区链表
rearrange(ma_algorithm);
}
/*分配内存模块*/
int allocate_mem(struct allocated_block *ab, int ab_size) {
struct free_block_type *fbt, *pre, *temp, *work, *F = NULL;
int request_size = ab_size;
if (NF_tmp == free_block || NF_tmp == NULL) {
F = NULL;
NF_tmp = free_block;
} else
F = NF_tmp;
fbt = NF_tmp;
pre = fbt;
do {
if (F != NULL && fbt == NULL)
fbt = free_block;
if (fbt->size >= request_size) {
NF_tmp = fbt;
if (fbt->size - request_size >=
MIN_SLICE) /*分配后空闲空间足够大,则分割*/
{
mem_size -= request_size;
fbt->size -= request_size;
ab->start_addr = fbt->start_addr;
fbt->start_addr += request_size;
NF_tmp = fbt;
} else if ((fbt->size - request_size) < MIN_SLICE)
/*分割后空闲区成为小碎片,一起分配*/
{
mem_size -= fbt->size;
if (pre == free_block)
free_block = fbt->next;
else if (pre == fbt)
for (pre = free_block; pre->next != NULL; pre = pre->next)
if (pre->next == fbt)
break;
pre->next = fbt->next;
NF_tmp = fbt->next;
ab->start_addr = fbt->start_addr;
ab->size = fbt->size;
free(fbt);
} else {
temp = free_block;
while (temp != NULL) {
work = temp->next;
if (work !=
NULL) /*如果当前空闲区与后面的空闲区相连,则合并*/
{
if (temp->start_addr + temp->size == work->start_addr) {
temp->size += work->size;
temp->next = work->next;
if (NF_tmp == work)
NF_tmp = temp;
free(work);
continue;
}
}
temp = temp->next;
}
rearrange(algorithm); /*重新按当前的算法排列空闲区*/
}
return 1;
}
pre = fbt;
fbt = fbt->next;
} while (fbt != F);
return -1;
}
/*创建新的进程,主要是获取内存的申请数量*/
new_process() {
struct allocated_block *ab;
int size;
int ret;
ab = (struct allocated_block *)malloc(sizeof(struct allocated_block));
if (!ab)
exit(-5);
ab->next = NULL;
pid++;
sprintf(ab->process_name, "PROCESS-%02d", pid);
ab->pid = pid;
printf("Memory for %s:", ab->process_name);
scanf("%d", &size);
if (size > 0)
ab->size = size;
else
printf("输入大小不合法!\n");
ret = allocate_mem(ab, ab->size); /* 从空闲区分配内存,ret==1表示分配ok*/
/*如果此时allocated_block_head尚未赋值,则赋值*/
if ((ret == 1) && (allocated_block_head == NULL)) {
allocated_block_head = ab;
return 1;
}
/*分配成功,将该已分配块的描述插入已分配链表*/
else if (ret == 1) {
ab->next = allocated_block_head;
allocated_block_head = ab;
return 2;
} else if (ret == -1) { /*分配不成功*/
printf("Allocation fail\n");
free(ab);
return -1;
}
return 3;
}
/*将ab所表示的已分配区归还,并进行可能的合并*/
int free_mem(struct allocated_block *ab) {
int algorithm = ma_algorithm;
struct free_block_type *fbt, *work;
fbt = (struct free_block_type *)malloc(sizeof(struct free_block_type));
if (!fbt)
return -1;
fbt->size = ab->size;
fbt->start_addr = ab->start_addr;
/*插入到空闲区链表的头部并将空闲区按地址递增的次序排列*/
fbt->next = free_block;
free_block = fbt;
rearrange(MA_FF);
fbt = free_block;
while (fbt != NULL) {
work = fbt->next;
if (work != NULL) {
/*如果当前空闲区与后面的空闲区相连,则合并*/
if (fbt->start_addr + fbt->size == work->start_addr) {
fbt->size += work->size;
fbt->next = work->next;
if (NF_tmp == work)
NF_tmp = fbt;
free(work);
continue;
}
}
fbt = fbt->next;
}
rearrange(algorithm); /*重新按当前的算法排列空闲区*/
return 1;
}
/*释放ab数据结构节点*/
int dispose(struct allocated_block *free_ab) {
struct allocated_block *pre, *ab;
if (free_ab == allocated_block_head) { /*如果要释放第一个节点*/
allocated_block_head = allocated_block_head->next;
free(free_ab);
return 1;
}
pre = allocated_block_head;
ab = allocated_block_head->next;
while (ab != free_ab) {
pre = ab;
ab = ab->next;
}
pre->next = ab->next;
free(ab);
return 2;
}
/* 显示当前内存的使用情况,包括空闲区的情况和已经分配的情况 */
display_mem_usage() {
struct free_block_type *fbt = free_block;
struct allocated_block *ab = allocated_block_head;
printf("------------------------------------------------------\n");
printf("\tFree Memory:\n");
if (fbt == NULL) {
printf("内存已满,无空闲!!!\n");
}
/* 显示空闲区 */
else
printf("%20s %20s\n", " start_addr", " size");
while (fbt != NULL) {
printf("%20d %20d\n", fbt->start_addr, fbt->size);
fbt = fbt->next;
}
/* 显示已分配区 */
printf("------------------------------------------------------\n");
printf("\nUsed Memory:\n");
printf("%10s %20s %20s %10s\n", "PID", "ProcessName", "start_addr",
" size");
while (ab != NULL) {
printf("%10d %20s %20d %10d\n", ab->pid, ab->process_name,
ab->start_addr, ab->size);
ab = ab->next;
}
printf("------------------------------------------------------\n");
return 0;
}
/*删除进程,归还分配的存储空间,并删除描述该进程内存分配的节点*/
kill_process() {
struct allocated_block *ab;
int pid;
printf("Kill Process, pid=");
scanf("%d", &pid);
ab = find_process(pid);
if (ab != NULL) {
free_mem(ab); /*释放ab所表示的分配区*/
dispose(ab); /*释放ab数据结构节点*/
}
}
int main() {
char choice;
pid = 0;
free_block = init_free_block(mem_size); //初始化空闲区
for (;;) {
display_menu(); //显示菜单
fflush(stdin); //清空输入缓冲区
choice = getchar(); //获取用户输入
switch (choice) {
case '1':
set_mem_size();
break; //设置内存大小
case '2':
set_algorithm();
flag = 1;
break; //设置分配算法
case '3':
new_process();
flag = 1;
break; //创建新进程
case '4':
kill_process();
flag = 1;
break; //删除进程
case '5':
display_mem_usage();
flag = 1;
break; //显示内存使用
case '0':
do_exit();
exit(0);
break; //释放链表并退出
default:
break;
}
}
return 0;
}