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

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

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

typedef struct allocated_block{
int pid;
int size;
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;
struct free_block_type *next;
}free_block_type;
//指向内存中空闲块链表的首指针
free_block_type *free_block;

# 3. 内存分配算法

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

void rearrange_BF(){
free_block_type *temp,*p=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;
}
while(temp->next!=NULL){
if(temp->next->size<current_min_size){
current_min_size=temp->next->size;
p=temp;
}
temp=temp->next;
}
temp=p;
p->next=p->next->next;
}
}
}

# 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;
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;
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;
free(free_ab);
return 1;
}
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）解释结果

posted @ 2020-05-16 01:56  一昼  阅读(274)  评论(0编辑  收藏  举报