操作系统实验3：内存分配与回收

今天早上做了操作系统实验：

1、阅读理解两个例程，掌握例程的运作流程。

2、连续式分配例程中提供了三种分配算法：首次适应、循环首次适应、最佳适应。例程还缺少分配作业和回收作业的功能。请至少实现一种分配算法并完成分配作业的功能，保证该例程能够正确实现分配作业的功能

3、回收作业的功能属于选做部分。

4、分页管理例程缺少分配作业和回收的功能，请实现这两个功能，保证该例程能够正确实现分页管理的分配与回收功能

5、上述要求2和4，必须完成其中一个。

连续式分配代码贴上：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#define ret printf("\n")
#define spa printf(" ")
#define hli printf("-")
#define vli printf("    |")
#define tab printf("\t")
#define capacity 1024          //内存总大小
#define max 100              //数组最大长度
#define jobsum 8             //作业总数量

void _sleep(int n){
clock_t goal;
goal = (clock_t)n * CLOCKS_PER_SEC + clock();
while(goal > clock());
}

char _keygo(){                //按任意键继续
char c;
printf("Please touch any key to continue....\n");
c = getchar();
return c;
}

typedef struct job JOB;
struct job {                //作业结构体
int jobid;                //作业ID，系统做东分配，无需输入
char name[20];            //作业名称
int vol;                //作业大小，即要申请的内存空间大小
};

JOB jobdata[jobsum] = {        //作业队列
{8100, "System", 50},
{8101, "QianQian", 32},
{8102, "XunLei", 128},
{8103, "Dictionary", 76},
{8104, "NorDun", 86},
{10001, "QQ", 168},
{10002, "eMule", 98},
{10003, "Word", 43},
};

typedef struct memblock MEM;//内存分区结构
struct memblock{
int head;                //地址
int length;                //长度
int state;                //状态，0表示空闲，1表示占用
int jobid;                //已分配，记录作业ID，否则为0
};

MEM memdata[max] = {        //内存状态表
{0, 50, 1, 8100},
{50, 50, 0, 0},
{100, 32, 1, 8101},
{132, 128, 1, 8102},
{260, 100, 0, 0},
{360, 76, 1, 8103},
{436, 200, 0, 0},
{636, 88, 1, 8104},
{724, 300, 0, 0},
};

int memsum = 9;                //当前分区总数量，包括已分配分区和空闲分区
int curp = 0;                //curp 是位置指针

MEM membackup[9] = {        //内存状态源数据备份，用于还原
{0, 50, 1, 8100},
{50, 50, 0, 0},
{100, 32, 1, 8101},
{132, 128, 1, 8102},
{260, 100, 0, 0},
{360, 76, 1, 8103},
{436, 200, 0, 0},
{636, 88, 1, 8104},
{724, 300, 0, 0},
};

int job_locate(int id){        //根据作业ID，查找作业在数组jobdata的位置
int i;
for(i=0;i<jobsum;++i)
if(id == jobdata[i].jobid)
return i;
return -1;
}

void mem_state(){            //根据memdata数组显示当前内存状态
int i, j, k;
for(i=0;i<memsum;++i){
tab;
printf("%4ik", memdata[i].head);
for(j=0;j<20;++j) hli;
ret;tab; vli;
for(j=0;j<5;++j) spa;
if(memdata[i].jobid == 0)
printf("%10s", "$block$");
else{
k = job_locate(memdata[i].jobid);
printf("%10s", jobdata[k].name);
}
vli;ret;
}
printf("\t1024k");
for(j=0;j<20;++j) hli;
ret;
}

int mem_allocate_ff(int k){            //首次适应算法
int i;
int job_size = jobdata[k].vol;

// for(i=0;i<memsum;++i){
//     printf("%d %d %d %d\n", memdata[i].head, memdata[i].length, memdata[i].state, memdata[i].jobid);
// }
for(i=0;i<memsum;++i){
if(!memdata[i].state && job_size <= memdata[i].length)
return i;
}
return -1;
}

int mem_allocate_cf(int k){            //循环首次适应算法
int i;
int job_size = jobdata[k].vol;
int t = memsum;
printf("memsum = %d\n", memsum);
while(t){
curp %= memsum;
i = curp;
//printf("t : %d curp : %d length: %d state: %d\n", t, curp, memdata[i].length, memdata[i].state);
if(!memdata[i].state && job_size <= memdata[i].length){
curp++;
return i;
}
curp++;
t--;
}
return -1;
}

int mem_allocate_bf(int k){            //最佳适应算法
int i;
int job_size = jobdata[k].vol;
int min = -1;
for(i=0;i<memsum;++i){
if(!memdata[i].state && job_size <= memdata[i].length){
if(min == -1) min = i;
else if(memdata[i].length<memdata[min].length) min = i;
}
}
if(min!= -1) return min;
return -1;
}

void mem_allocate(int i, int j){    //将分区j分配给作业i
int k;

if(jobdata[i].vol == memdata[j].length){
memdata[j].state = 1;
memdata[j].jobid = jobdata[i].jobid;
}
else{
for(k=memsum-1;k>=j;--k){
memdata[k+1] = memdata[k];
}
int temp = memdata[j].length;
memdata[j].length = jobdata[i].vol;

memdata[j].state = 1;
memdata[j].jobid = jobdata[i].jobid;
memdata[j+1].length = temp - memdata[j].length;
memdata[j+1].state = 0;
memdata[j+1].jobid = 0;
memdata[j+1].head = memdata[j].length + memdata[j].head;
++memsum;
}
}

int mem_locate(int id){        //根据作业ID，查找jobdata的id在数组memdata的位置
int i;
for(i=0;i<memsum;++i)
if(id == memdata[i].jobid)
return i;
return -1;
}

void mem_redraw(int k){                //作业回收
int i;
int t = mem_locate(k);
printf("t : %d\n", t);
if(t == -1) return ;

memdata[t].state = 0;
memdata[t].jobid = 0;

if( t > 0 && memdata[t-1].state == 0 ){
memdata[t-1].state = 0;
memdata[t-1].jobid = 0;
memdata[t-1].length += memdata[t].length;
for(i=t+1;i<memsum;++i)
memdata[i-1] = memdata[i];
--memsum;
--t;
}
if(t+1 <= memsum && memdata[t+1].state == 0){
memdata[t].state = 0;
memdata[t].jobid = 0;
memdata[t].length += memdata[t+1].length;
for(i=t+2;i<memsum;++i)
memdata[i-1] = memdata[i];
--memsum;
}
}

void mem_restore(){                    //内存状态还原
int k;
memsum = 9;
for(k=0;k<memsum;++k){
memdata[k].head = membackup[k-1].head;
memdata[k].jobid = membackup[k-1].jobid;
memdata[k].state = membackup[k-1].state;
memdata[k].length = membackup[k-1].length;
}
for(k=memsum;k<max;++k){
memdata[k].head = 0;
memdata[k].jobid = 0;
memdata[k].state = 0;
memdata[k].length = 0;
}
}

int main(int argc, char const *argv[])
{
int i, j, start;
printf("\n------------The current memory state----------!\n");
mem_state();
_keygo();
printf("\n------------The work allocate start-----------!\n");
start = 5;
for(i=start;i<jobsum;++i){
printf("The work %s wait to allocate, The size is %iK\n", jobdata[i].name, jobdata[i].vol);
_sleep(1);
j = mem_allocate_ff(i);
printf("The allocate : %d\n", j);
if(j == -1) printf("The work %s is too big, the allocation is failed\n", jobdata[i].name);
else{
printf("allocation space to The work %s\n", jobdata[i].name);
mem_allocate(i, j);
mem_state();
}
_keygo();
}
printf("----------------The allocation over!---------\n");
printf("restore the memory!\n");
printf("\n----------------The current memory state------------\n");
mem_state();
j = 88;
while(j != 0){
printf("\n Please choose the job No: ");
scanf("%d", &j);
mem_redraw(j);
printf("\nThe restore success !\n");
printf("\n-------------The current memory state---------\n");
mem_state();
}
_keygo();
return 0;
}