操作系统第5次实验报告：内存管理

• 姓名：徐思婕
• 学号：201821121004
• 班级：计算1811

1. 记录内存空间使用情况

        定义已分配分区的结构体allocated_block，定义一个指针allocated_block_head指向链表表头，为进程分配内存空间时，就将分配到内存空间的进程块节点添加到链表中。

typedef struct allocated_block{
    int pid;
    int size;
    int start_addr;
    char process_name[PROCESS_NAME_LEN];
    struct allocated_block *next;
}allocated_block;
//进程分配内存块链表的首指针
struct allocated_block *allocated_block_head = NULL;

 

2. 记录空闲分区

      定义空闲分区的结构体free_block_type，定义一个指针free block指向链表表头，对内存初始化后，空闲分区按从小到大进行排序，自表头开始查找到第一个满足要求的自由分区分配。

typedef struct free_block_type{
    int size;
    int start_addr;
    struct free_block_type *next;
}free_block_type;
//指向内存中空闲块链表的首指针
free_block_type *free_block;

 

3. 内存分配算法

       使用了最佳适应算法，从全部空闲区中找出能满足作业要求且大小最小的空闲分区，从而使链表中的结点大小趋于均匀，空闲分区按大小从小到大排序，该算法保留小的空闲区，尽量减少小的碎片产生。

void rearrange_BF(){
    free_block_type *temp,*p=NULL;
    free_block_type *head=NULL;
    int current_min_size=free_block->size;
    temp=free_block;
    while(temp->next!=NULL){
       if(temp->next->size<current_min_size){
            current_min_size=temp->next->size;
            p=temp;
        }
        temp=temp->next;
    }
    if(p!=NULL){
        temp=p->next;
        p->next=p->next->next;
        temp->next=free_block;
        free_block=temp;
    }
    head=free_block;
    p=head;
    temp=head->next;
    while(head->next!=NULL){
        current_min_size=head->next->size;
        while(temp->next!=NULL){
            if(temp->next->size<current_min_size){
                current_min_size=temp->next->size;
                p=temp;
            }
            temp=temp->next;
        }
        if(p->next!=head->next){
            temp=p;
            p->next=p->next->next;
            temp->next=head->next;
            head->next=temp;
        }
        head=head->next;
        temp=head->next;
        p=head;
    }
}

 

4. 内存释放算法

        找到对应的链表节点，释放释放杀死进程的内存块，归还进程的已分配的存储空间，按大小从小到大排序，销毁杀死进程的结点。

//杀死进程
int kill_process(int pid){
    allocated_block *ab;
    ab = find_process(pid);
    if(ab!=NULL){
        free_mem(ab);
        dispose(ab);
        return 0;
    }else{
        return -1;
    }
}

//释放杀死进程的内存块
int free_mem(allocated_block *ab){
    int algorithm = ma_algorithm;
    struct free_block_type *fbt,*pre,*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;
    work = free_block;
    if(work == NULL){
        free_block = fbt;
        fbt->next == NULL;
    }else{
        while(work ->next != NULL){
            work = work->next;
        }
        fbt->next = work->next;
        work->next = fbt;
    }
    rearrange_BF();
    pre = free_block;
    while(pre->next){
        work = pre->next;
        if(pre->start_addr + pre->size == work->start_addr ){
            pre->size = pre->size + work->size;
            pre->next = work->next;
            free(work);
            continue;
        }else{
            pre = pre->next;
        }
    }
    rearrange(ma_algorithm);
    return 1;
}

//销毁杀死进程的结点
int dispose(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;
}

 

5. 运行结果

（1）运行结果：

        

        

 

（2）产生测试数据

int main(int argc, char const *argv[]){
    int p1,p2;
    int total=0; //统计分配内存的次数
    free_block = init_free_block(mem_size); //初始化空闲区域
    Prc prc[PROCESS_NUM];
    init_program(prc,PROCESS_NUM);//初始化进程
    srand( (unsigned)time( NULL ) );
    for(int i=0;i<DATA_NUM;++i){
        p1=rand()%2;
        int count=0;
        for(int j=0;j<PROCESS_NUM;++j){
            if(prc[j].pid!=-1)
                count++;
        }
        if((count==PROCESS_NUM && p1==0)||total==10){
            p1=1;
        }
        if(count==0 && p1==1){
            p1=0;
        }
        if(p1==0){
            do{
                p2=rand()%PROCESS_NUM;
            }while(prc[p2].pid!=-1);
            alloc_process(prc[p2]);
            prc[p2].pid=pid;
            total++;
            display_mem_usage();//输出内存使用情况
        }
        else
        {
            do{
                p2=rand()%PROCESS_NUM;
            }while(prc[p2].pid==-1);
            kill_process(prc[p2].pid);
            prc[p2].pid=-1;
            display_mem_usage();
        }
    }
}

 

（3）解释结果

第一组：为process-02分配了从0开始，大小为28的内存单元，分配后空闲分区内存剩余地址为从28开始，大小为996的空间。

第二组：释放了process-02从0开始，大小为28的内存单元，释放后空闲分区内存剩余地址为从0开始，大小为1024的空间。

第三组：为process-03分配了从0开始，大小为102的内存单元，分配后空闲分区内存剩余地址为从102开始，大小为922的空间。

第四组：为process-02分配了从102开始，大小为108的内存单元，分配后空闲分区内存剩余地址为从210开始，大小为814的空间。