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

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

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

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

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

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

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

连续式分配代码贴上：

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

#define ret printf("
")
#define spa printf(" ")
#define hli printf("-")
#define vli printf("    |")
#define tab printf("	")
#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....
");
    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("	1024k");
    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
", 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
", memsum);
    while(t){
        curp %= memsum;
        i = curp;
        //printf("t : %d curp : %d length: %d state: %d
", 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
", 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("
------------The current memory state----------!
");
    mem_state();
    _keygo();
    printf("
------------The work allocate start-----------!
");
    start = 5;
    for(i=start;i<jobsum;++i){
        printf("The work %s wait to allocate, The size is %iK
", jobdata[i].name, jobdata[i].vol);
        _sleep(1);
        j = mem_allocate_ff(i);
        printf("The allocate : %d
", j);
        if(j == -1) printf("The work %s is too big, the allocation is failed
", jobdata[i].name);
        else{
            printf("allocation space to The work %s
", jobdata[i].name);
            mem_allocate(i, j);
            mem_state();
        }
        _keygo();
    }
    printf("----------------The allocation over!---------
");
    printf("restore the memory!
");
    printf("
----------------The current memory state------------
");
    mem_state();
    j = 88;
    while(j != 0){
        printf("
 Please choose the job No: ");
        scanf("%d", &j);
        mem_redraw(j);
        printf("
The restore success !
");
        printf("
-------------The current memory state---------
");
        mem_state();
    }
    _keygo();
    return 0;
}