操作系统第五次实验报告——内存管理

0 个人信息

• 张樱姿
• 201821121038
• 计算1812

1 实验目的

• 通过编程进一步了解内存管理。

2 实验内容

• 在服务器上用Vim编写一个程序：仿真实现某个内存管理算法，测试给出结果，并对运行结果进行解释。

3 实验报告

　　3.1 记录内存空间使用情况

　　　使用链表记录内存空间使用情况。

//每个进程分配到的内存块
typedef struct allocated_block{
    int pid;           //进程号
    int size;          //进程分配到的内存块大小
    int start_addr; //内存块起始地址
    char process_name[NAME_LEN]; //进程名
    struct allocated_block *next;       //指向下一个内存块的指针
}AB;    

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

　　3.2 记录空闲分区

　　　同样也使用链表来记录空闲分区。

//每个空闲块
typedef struct free_block_type{
    int size;            //空闲块大小
    int start_addr;   //空闲块起始地址
    struct free_block_type *next;   //指向下一个空闲块
}FBT;

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

　　3.3 内存分配算法

　　　最佳分配算法（Best Fit Allocation）的原理是空闲分区列表按照大小排序，在分配时，查找一个合适的分区（分配n字节分区时，查找并使用不小于n的最小空间分区）；在释放时，查找并且合并临近的空闲分区（如果找到的话）。

//执行分配内存
void do_allocate_mem(AB *ab){
    int request = ab->size;
    FBT *tmp = free_block;
    while(tmp != NULL){
        if(tmp->size >= request){
            //分配
            ab->start_addr = tmp->start_addr;
            int shengyu = tmp->size - request;
            tmp->size = shengyu;
            tmp->start_addr = tmp->start_addr + request;
        
            return ;
        }
        tmp = tmp->next;
    }
}

//分配内存模块
int allocate_mem(AB *ab){
    FBT *fbt,*pre;
    int request_size=ab->size;
    fbt = pre = free_block;
    //尝试寻找可分配空闲
    int f = find_free_mem(request_size);
    if(f == -1){
        //不够分配
        printf("空闲内存不足,内存分配失败!\n");
        return -1;
    }else{
        if(f == 0){
            //需要内存紧缩才能分配
            memory_compact();
        }
        //执行分配
        do_allocate_mem(ab);
    }
    //重新排布空闲分区
    rearrange(ma_algorithm);
    return 1;
} 

//最佳适应算法，空闲分区按大小从小到大排序
void rearrange_BF(){
    if(free_block == NULL || free_block->next == NULL)
        return;
    FBT *t1,*t2,*head;
    head = free_block;
    //遍历整个空闲块列表，比较找到最小的一块空闲块
    for(t1 = head->next;t1;t1 = t1->next){
        for(t2 = head;t2 != t1;t2=t2->next){
            if(t2->size > t2->next->size){
                int tmp = t2->start_addr;
                t2->start_addr = t2->next->start_addr;
                t2->next->start_addr = tmp;

                tmp = t2->size;
                t2->size = t2->next->size;
                t2->next->size = tmp;
            }
        }
    }
}

　　3.4 内存释放算法

//释放链表节点
int dispose(AB *free_ab){
    AB *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;
}

//更新分区表
int free_mem(AB *ab){
    //将ab所表示的已分配区归还，并进行可能的合并
    int algorithm = ma_algorithm;
    FBT *fbt,*pre,*work;
    fbt = (FBT*)malloc(sizeof(FBT));
    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 kill_process(int pid){
    AB *ab;
    ab = find_process(pid);
    if(ab!=NULL){
        //释放ab所表示的分配表
        free_mem(ab);    
        //释放ab数据结构节点
        dispose(ab);    
        return 0;
    }else{
        return -1;
    }
}

　　3.5 运行结果

　　　　3.5.1 产生测试数据

　　　　  随机为3个进程分配、释放内存10次以上，即随机产生10组以上数据。

int main(int argc, char const *argv[]){
    /*
        sel1=0表示为某进程分配内存空间 
        sel1=1表示为释放某进程占用的内存空间 
    */ 
    int sel1,sel2; 
    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)
    {
        sel1=rand()%2;
        int count=0;
        //统计三个进程中有多少个进程已经分配内存 
        for(int j=0;j<PROCESS_NUM;++j){
            if(prc[j].pid!=-1)
                count++;
        }
        //如果全部分配进程或者进程分配到达5次，那么就不能继续分配内存改为释放内存 
        if((count==PROCESS_NUM && sel1==0)||total==5)
            sel1=1;
        //如果全部未分配进程，那么就不能继续释放内存 
        if(count==0 && sel1==1)
            sel1=0;
        if(sel1==0)//为进程分配内存 
        {
            //随机找到一个未分配内存的进程 
            do{
                sel2=rand()%PROCESS_NUM;
            }while(prc[sel2].pid!=-1);
            alloc_process(prc[sel2]);//分配内存空间 
            prc[sel2].pid=pid;//改变标记 
            total++;
            display_mem_usage();//显示 
        }
        else//释放进程占用的内存空间 
        {
            //随机找到一个可释放进程 
            do{
                sel2=rand()%PROCESS_NUM;
            }while(prc[sel2].pid==-1);
            kill_process(prc[sel2].pid);//释放内存空间 
            prc[sel2].pid=-1;//改变标记 
            display_mem_usage();//显示 
        }
    }
}

　　　　3.5.2 解释结果

　　　　　初始的空闲块大小1024KB，

　　　　　①第一次分配结果：

 　　　　为PID为1的进程分配大小为24KB的内存空间，起始地址为0，分配完成后的空闲空间为1000KB，起始地址为24。

　　　　②第二次分配结果：

 　　　　为PID为2的进程分配大小为74KB的内存空间，起始地址为24，分配完成后的空闲空间为926KB，起始地址为98。

　　　　③第三次分配结果：

　　　　为PID为3的进程分配大小为36KB的内存空间，起始地址为98，分配完成后的空闲空间为890KB，起始地址为134。 　　　　

　　　　④第四次分配结果：

　　　　将PID为3的进程释放，空闲空间变为926KB，起始地址为98。

　　　　⑤第五次分配结果：

 　　　　将PID为1的进程释放，空闲空间变为两块，一块大小926KB，起始地址为98。另一块大小24KB，起始地址为0。

4 References

•  https://github.com/City-Zero/LinuxTest/tree/96c823cf1ed5aaaa401d3a3c9e3e4f7948def52b/OSex/mem_manager