系统相关
首页 > 系统相关> > 不考虑性能的内存管理模拟系统(假内存)的C语言实现

不考虑性能的内存管理模拟系统(假内存)的C语言实现

作者:互联网

#include<stdio.h>           /*头文件*/

 

#define PROCESS_NAME_LEN 32   /*进程名长度*/

#define MIN_SLICE    10             /*最小碎片的大小*/

#define DEFAULT_MEM_SIZE 1024     /*内存大小*/

#define DEFAULT_MEM_START 0       /*起始位置*/

 

#define FF 1             /*首次适应*/

#define BF 2             /*最佳适应*/

#define WF 3             /*最坏适应*/

 

int mem_size = DEFAULT_MEM_SIZE;        /*内存大小*/

int manage_algorithm = FF;           /*当前分配算法*/

static int pid = 0;              /*初始pid*/

int flag = 0;              /*内存是否已设置标志*/

 

/*********************************************************/

typedef struct free_block{     /*描述每一个空闲块的数据结构*/

    int size;               /*空闲块大小*/

    int start_addr;             /*起始地址*/

    struct free_block* next;    /*下一个空闲块的指针*/

}free_block; 

 

free_block* head_of_free_block = NULL; //指向内存中空闲块链表的首指针

 

/*********************************************************/

typedef struct allocated_block{     /*进程已分配的内存块的描述*/

    int pid;                    /*所占进程的标识符*/

    int size;                       /*块大小*/

    int start_addr;           /*起始地址*/

    char process_name[PROCESS_NAME_LEN];    /*进程名*/

    struct allocated_block *next;       /*下一个分配快*/

}allocated_block;

 

allocated_block* head_of_allocated_block = NULL;    /*进程分配内存块链表的首指针*/

 

/*********************************************************/

free_block* init_free_block(int);       //初始化空闲区

void display_menu(void);        //显示菜单

int set_mem_size(void);          //设置内存大小

void set_algorithm(void);       //设置算法

void rearrange(int);        //重排链表

void rearrange_FF(void);        //首次重排

void rearrange_BF(void);        //最佳重排

void rearrange_WF(void);        //最坏重排

int new_process(void);          //创建新进程

int allocate_mem(allocated_block*); //分配内存

void rearrange_Allocated(void);     //进程链排序

void kill_process(void);        //删除进程

allocated_block* find_process(int pid); //查找块位置

int dispose(allocated_block*);  //块归还

int free_mem(allocated_block*); //释放内存

int display_mem_usage(void);        //显示内存使用

void do_exit(void);         //释放链表并退出

 

/*********************************************************/

int main(void){

    char choice;      /*选择的功能*/

    pid = 0;            /*初始化pid*/

    head_of_free_block = init_free_block(mem_size); //初始化空闲区

    while(1){

        display_menu(); //显示菜单

        fflush(stdin);

        choice = getchar(); //获取用户输入

        switch(choice){

            case '1':set_mem_size();break;  //设置内存大小

            case '2':set_algorithm();break;//设置算法

            case '3':new_process();break;//创建新进程

            case '4':kill_process();break;//删除进程

            case '5':display_mem_usage();break; //显示内存使用

            case '0':do_exit();exit(0); //释放链表并退出

            default:printf("ErrorInput_Exception\n");break;     

        }

    }

}

 

/*********************************************************/

/*初始化空闲块,默认为一块,可以指定大小及起始地址*/

free_block* init_free_block(int mem_size){

    free_block* fb = NULL;

 

    fb = (free_block*)malloc(sizeof(free_block));

    if(fb==NULL){

        printf("MemoryOverFlow_Exception\n");

        return NULL;

    }

    fb->size = mem_size;

    fb->start_addr = DEFAULT_MEM_START;

    fb->next = NULL;

    return fb;

}

 

/*********************************************************/

/*显示菜单*/

void display_menu(void){

    printf("\n");

    printf("1 - Set memory size (default=%d,current=%d)\n",DEFAULT_MEM_SIZE,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");

}

 

/*********************************************************/

/*设置内存的大小*/

int set_mem_size(void){

    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;

        head_of_free_block->size = mem_size;

        flag = 1;

    }

    else printf("SizeSetNoLegal_Exception\n");

    return 1;

}

 

/*********************************************************/

/* 设置当前的分配算法 */

void set_algorithm(void){

    int algorithm;

    printf("\t1 - First Fit\n");

    printf("\t2 - Best Fit \n");

    printf("\t3 - Worst Fit \n");

    scanf("%d",&algorithm);

    if(algorithm >= 1 && algorithm <= 3)

        manage_algorithm = algorithm;

    else{

        printf("NoSuchAlgorithm_Exception\n");

        return -1;

    }

    flag = 1;

    rearrange(manage_algorithm);    //按指定算法重新排列空闲区链表

}

 

/*********************************************************/

/*按指定的算法整理内存空闲块链表*/

void rearrange(int algorithm){

    switch(algorithm){

        case FF:rearrange_FF();break;

        case BF:rearrange_BF();break;

        case WF:rearrange_WF();break;

    }

}

 

/*********************************************************/

/*按FF算法重新整理内存空闲块链表*/

void rearrange_FF(void){  

    free_block* fb;                 //内循环

    free_block* temp;                       //外循环

    int size;

    int start_addr;                              

    for(temp = head_of_free_block;temp != NULL;temp = temp->next){

        for(fb = temp->next;fb != NULL;fb = fb->next){

            if(temp->start_addr > fb->start_addr){

                size = temp->size;

                start_addr = temp->start_addr;

                temp->size = fb->size;

                temp->start_addr = fb->start_addr;

                fb->size = size;

                fb->start_addr = start_addr;

            }

        }

    }

}

 

/*********************************************************/

/*按BF算法重新整理内存空闲块链表*/

void rearrange_BF(void){

    free_block* fb;                 //内循环

    free_block* temp;                       //外循环

    int size;

    int start_addr;                         

    for(temp = head_of_free_block;temp != NULL;temp = temp->next){

        for(fb = temp->next;fb != NULL;fb = fb->next){

            if(temp->size > fb->size){

                size = temp->size;

                start_addr = temp->start_addr;

                temp->size = fb->size;

                temp->start_addr = fb->start_addr;

                fb->size = size;

                fb->start_addr = start_addr;

            }

        }

    }

}

 

/*********************************************************/

/*按WF算法重新整理内存空闲块链表*/

void rearrange_WF(void){

    free_block* fb;                 //内循环

    free_block* temp;                       //外循环

    int size;

    int start_addr;                             

    for(temp = head_of_free_block;temp != NULL;temp = temp->next){

        for(fb = temp->next;fb != NULL;fb = fb->next){

            if(temp->size < fb->size){

                size = temp->size;

                start_addr = temp->start_addr;

                temp->size = fb->size;

                temp->start_addr = fb->start_addr;

                fb->size = size;

                fb->start_addr = start_addr;

            }

        }

    }

}

 

/*********************************************************/

/*创建新的进程,主要是获取内存的申请数量*/

int new_process(void){

    allocated_block* ab;

    int size;   

    ab=(allocated_block*)malloc(sizeof(allocated_block));

    if(!ab) exit(-5);

    ab->next = NULL;

    pid++;

    sprintf(ab->process_name, "PROCESS-%02d\0", pid);

    ab->pid = pid;   

    printf("Memory for %s:", ab->process_name);

    scanf("%d", &size);

    if(size>0) ab->size = size;

    else{

        printf("SizeNotLegal_Exception\n");

        pid--;

        return -1;

    }

 

    ab->start_addr = allocate_mem(ab);          /* 从空闲区分配内存,ab->start_addr表示分配地址,-1表示未成功*/

 

    if((ab->start_addr != -1) && (head_of_allocated_block == NULL)){    /*如果此时head_of_allocated_block尚未赋值,则赋值*/

        head_of_allocated_block = ab;

        flag = 1;

        return 1;       

    }

    else if (ab->start_addr != -1){     /*分配成功,将该已分配块的描述插入已分配链表,头插法*/

        ab->next = head_of_allocated_block;

        head_of_allocated_block = ab;

        flag = 1;

        return 2;       

    }

    else if(ab->start_addr == -1){          /*分配不成功*/

        printf("AllocationFail_Exception\n");

        free(ab);

        return -2;      

    }

    return 3;

}

 

/*********************************************************/

/*分配内存模块*/

int allocate_mem(allocated_block* ab){

    free_block *now, *pre;

    int request_size = ab->size;

    now = pre = head_of_free_block;

    double temp;

    int sum_size = 0;

    // 1. 找到可满足空闲分区且分配后剩余空间足够大,则分割

    // 2. 找到可满足空闲分区且但分配后剩余空间比较小,则一起分配

    // 3. 找不可满足需要的空闲分区但空闲分区之和能满足需要,则采用内存紧缩技术,进行空闲分区的合并,然后再分配

    // 4. 在成功分配内存后,应保持空闲分区按照相应算法有序

    // 5. 分配成功则返回分配首地址,否则返回-1

    while(now != NULL){

        sum_size = sum_size + now->size;

        if(request_size <= now->size){

            temp = (double)(now->size-request_size)/(double)now->size;

            if(temp <= 0.1){        //剩余空间小于百分之十

                int addr = now->start_addr;

                if(head_of_free_block->next == NULL){

                    ab->size = head_of_free_block->size;

                    head_of_free_block = NULL;

                }

                else{

                    if(now == head_of_free_block){

                        ab->size = head_of_free_block->size;

                        head_of_free_block = head_of_free_block->next;

                    }

 

                    else{

                        ab->size = now->size;

                        pre->next = now->next;

                    }

                }

                return addr;

            }

            else{                   //剩余空间大于百分之十

                int addr = now->start_addr;         //分配

                now->start_addr = now->start_addr + request_size;

                now->size = now->size - request_size;   //减少内存

                switch(manage_algorithm){       //管理重排

                    case FF:rearrange_FF();break;

                    case BF:rearrange_BF();break;

                    case WF:rearrange_WF();break;

                }

                return addr;

            }

        }

        pre = now;

        now = now->next;

    }

    if(sum_size < request_size) return -1;

    else{           //内存紧缩技术

        rearrange_Allocated();      //进程链排序

        allocated_block* abt = head_of_allocated_block;

        int size_T = 0;

        while(abt != NULL){

            abt->start_addr = size_T;

            size_T = size_T + abt->size;

            abt = abt->next;

        }

        free_block* fbt;

        while(head_of_free_block->next != NULL){    //空闲链合并

            fbt = head_of_free_block;

            head_of_free_block = head_of_free_block->next;

            free(fbt);

        }

        head_of_free_block->start_addr = size_T;

        head_of_free_block->size = sum_size;

 

        //分配

        int addr = head_of_free_block->start_addr;      //分配

        head_of_free_block->start_addr = head_of_free_block->start_addr + request_size;

        head_of_free_block->size = head_of_free_block->size - request_size; //减少内存

        return addr;

    }

    return 0;  

}

 

/*********************************************************/

/*对进程链地址排序*/

void rearrange_Allocated(void){  

    allocated_block* ab;                    //内循环

    allocated_block* temp;                      //外循环

 

    int pid;

    int size;

    int start_addr;

    char process_name[PROCESS_NAME_LEN];

 

    for(temp = head_of_allocated_block;temp != NULL;temp = temp->next){

        for(ab = temp->next;ab != NULL;ab = ab->next){

            if(temp->start_addr > ab->start_addr){

                pid = temp->pid;

                size = temp->size;

                start_addr = temp->start_addr;

                strcpy(process_name,temp->process_name);

 

                temp->pid = ab->pid;

                temp->size = ab->size;

                temp->start_addr = ab->start_addr;

                strcpy(temp->process_name,ab->process_name);

 

                ab->pid = pid;

                ab->size = size;

                ab->start_addr = start_addr;

                strcpy(ab->process_name,process_name);

            }

        }

    }

}

 

/*********************************************************/

/*删除进程,归还分配的存储空间,并删除描述该进程内存分配的节点*/

void kill_process(void){

    allocated_block* ab;

    int pid;

    printf("Kill Process, pid=");

    scanf("%d", &pid);

    ab = find_process(pid);

    if(ab != NULL){

        flag = 1;

        free_mem(ab); /*释放ab所表示的分配区*/

        dispose(ab);  /*释放ab数据结构节点*/

    }

    else printf("NoSuchProcess_Exception\n");

}

 

/*********************************************************/

/*查找pid进程所在块*/

allocated_block* find_process(int pid){

    allocated_block* ab = head_of_allocated_block;

    while(ab != NULL){

        if(ab->pid == pid) break;

        ab = ab->next;

    }

    return ab;

}

 

/*********************************************************/

/*将ab所表示的已分配区归还,并进行可能的合并*/

int free_mem(allocated_block* ab){

    int algorithm = manage_algorithm;

    free_block *fb, *pre, *now;

    fb = (free_block*)malloc(sizeof(free_block));

    if(!fb) return -1;

    fb->size = ab->size;

    fb->start_addr = ab->start_addr;

    fb->next = NULL;

    // 1. 将新释放的结点插入到空闲分区队列末尾

    // 2. 对空闲链表按照地址有序排列

    // 3. 检查并合并相邻的空闲分区

    // 4. 将空闲链表重新按照当前算法排序

    if(head_of_free_block == NULL) head_of_free_block = fb;

    else{

        now = head_of_free_block;

        while(now->next != NULL) now = now->next;

        now->next = fb;

        rearrange_FF();

        pre = head_of_free_block;

        now = head_of_free_block->next;

        while(now != NULL){

            if((pre->start_addr + pre->size) == now->start_addr){

                fb = now;

                pre->size = pre->size + now->size;

                pre->next = now->next;

                free(fb);

                now = pre->next;

            }

            else{

                pre = now;

                now = now->next;

            }

        }

        switch(algorithm){      //管理重排

            case FF:rearrange_FF();break;

            case BF:rearrange_BF();break;

            case WF:rearrange_WF();break;

        }

    }

    return 1;

}

 

/*********************************************************/

/*释放ab数据结构节点*/

int dispose(allocated_block* free_ab){

    allocated_block *pre, *ab;

    if(free_ab == head_of_allocated_block){ /*如果要释放第一个节点*/

        head_of_allocated_block = head_of_allocated_block->next;

        free(free_ab);

        return 1;

    }

    pre = head_of_allocated_block; 

    ab = head_of_allocated_block->next;

    while(ab != free_ab){

        pre = ab; 

        ab = ab->next;

    }

    pre->next = ab->next;

    free(ab);

    return 2;

}

 

/*********************************************************/

/* 显示当前内存的使用情况,包括空闲区的情况和已经分配的情况 */

int display_mem_usage(void){

    free_block* fbt = head_of_free_block;

    allocated_block* ab = head_of_allocated_block;

 

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

 

    /* 显示空闲区 */

    printf("Free Memory:\n");

    printf("%20s %20s\n", "      start_addr", "       size");

    if(fbt == NULL)

        printf("%20d %20d\n", -1, 0);

    else{

        while(fbt != NULL){

            printf("%20d %20d\n", fbt->start_addr, fbt->size);

            fbt = fbt->next;

        }

    }

    /* 显示已分配区 */

    printf("\nUsed Memory:\n");

    printf("%10s %20s %10s %10s\n", "PID", "ProcessName", "start_addr", " size");

    while(ab != NULL){

        printf("%10d %20s %10d %10d\n", ab->pid, ab->process_name, ab->start_addr, ab->size);

        ab = ab->next;

    }

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

    flag = 1;

    return 0;

}

 

/*********************************************************/

/* 结束前的内存回收 */

void do_exit(void){

    free_block* fb = NULL;

    allocated_block* ab = NULL;

    while(head_of_free_block != NULL){

        fb = head_of_free_block;

        head_of_free_block = head_of_free_block->next;

        free(fb);

    }

    while(head_of_allocated_block != NULL){

        ab = head_of_allocated_block;

        head_of_allocated_block = head_of_allocated_block->next;

        free(ab);

    }

}

 

标签:ab,addr,free,C语言,start,内存,模拟系统,block,size
来源: https://www.cnblogs.com/fusiji/p/11409833.html