才半页

  博客园  :: 首页  :: 新随笔  :: 联系 :: 订阅 订阅  :: 管理
  • 李微微
  • 201821121001
  • 计算1811

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

     ①根据实验课上的PPT,记录进程使用了哪些内存空间,用链表实现。在结构体里声明进程ID、占用大小、起始地址、进程名和指向自己类型的指针,用于存放进程信息。

/*记录内存空间使用情况*/
typedef struct allocated_block{
    int pid;
    int size;
    int start_addr;
    char process_name[PNAME_LEN];
    struct allocated_block *next;
}AB;

     ②定义一个全局指针变量,作为进程分配内存块的首指针,指向链表头结点。在分配内存时,用指针将该结点加入链表;在释放内存时,用指针将该结点从链表中删除。

AB *allocated_block_head = NULL; 

2. 记录空闲分区

     ①同样用链表记录空闲分区,同样定义一个结构体,声明占用大小、起始地址和指向自己类型的指针。

typedef struct free_block_type{
     int size;
     int start_addr;
     struct free_block_type *next;
}FBT;

     ②同样定义一个全局指针变量,作为内存中空闲块链表首指针,指向链表头结点。在刚初始化内存空间时,内存空间都是空闲分区;当分配内存空间后,内存管理算法会从空闲分区分出一块,这样就会导致空闲分区不连续。所以将空闲分区结点插入,并重新排序。释放内存时,分区结点从链表中删除。

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

3. 内存分配算法

  • 使用的内存分配:首次适配
  • 代码包括分配内存算法、应用分配内存算法的模块(包括内存紧缩后分配函数、重排空闲分区函数)、为进程分配内存模块。
  • 算法的本质是,把最合适的空闲区分配给进程。空闲区足够大则分割,分割后会打乱空闲区,就需要把空闲区加入链表,重新排序;空闲区不够则用内存紧缩,合并空闲分区,再分配。
 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 residue = tmp->size - request;
             tmp->size = residue;
             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("Not enough free memory!\n");
         return -1;
     }else{
         if(f == 0){                //内存紧缩后分配
             Memory_Compact();
         }
         Do_Allocate_Mem(ab);       //分配
     }
     Rearrange(ma_algorithm);       //重排空闲分区
     return 1;
 }
 int Alloc_Process(PRO prc){        //为进程分配内存
     AB *ab;
     int ret;
     ab = (AB*)malloc(sizeof(AB));
     if(!ab) exit(-5);
     ab->next=NULL;
     pid++;
     strcpy(ab->process_name,prc.process_name);
     ab->pid = pid;
     ab->size=prc.size+rand()%ALLOC_SIZE; //随机分配内存
     ret = Allocate_Mem(ab);              //分配内存,ret==1表示分配成功
     if((ret == 1) && (allocated_block_head == NULL)){ //若allocated_block_head尚未赋值
         allocated_block_head = ab;
         return 1;
     }else if(ret == 1){                  //分配成功
         ab->next = allocated_block_head;
         allocated_block_head = ab;
         return 2;
     }else if(ret == -1){                 //分配不成功
         printf("Fail!\n");
         free(ab);
         return -1;
     }
     return 3;
 }
void  Memory_Compact(){             //进行内存紧缩
     FBT *fbttmp = free_block;
     AB *abtmp = allocated_block_head;
     int sum = 0;
     while(fbttmp!=NULL){            //检测剩余内存
         sum += fbttmp->size;
         fbttmp = fbttmp->next;
     }
     fbttmp = free_block;            //合并区块
     fbttmp->size = sum;
     fbttmp->start_addr = 0;
     fbttmp->next=NULL;
     FBT *pr = free_block->next;      //释放分区
     while(pr != NULL){
         fbttmp = pr->next;
         free(pr);
         pr = fbttmp;
     }
     Sort_AB();                      //已分配空间重新排序
     Reset_AB(sum);
 }

4. 内存释放算法

  • 内存释放包括链表结点释放、更新分区表、释放进程内存(寻找链表结点函数)。
  • 算法过程是释放结点,再将释放的结点插入空闲分区末尾,再排序,合并必要的空闲分区,最后按首次适配算法排序。
  • 代码
 int Dispose(AB *free_ab){            //释放链表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){                //更新分区表归还已分配区,以及可能的合并
     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_FIR();                   //首次适配算法
     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){
         Free_Mem(ab);                //释放分配表
         Dispose(ab);                 //释放节点
         return 0;
     }else{
         return -1;
     }
 }

5. 运行结果

(1)产生测试数据

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

#define PROCESS_NUM 3          //进程数
int main(int argc, char const *argv[]){ int sel1,sel2; int total=0; //记录分配内存的次数 free_block=Init_Free_Block(mem_size); //初始化空闲区 PRO 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++; } //如果全部分配进程或者进程分配到达10次,那么就不能继续分配内存 if((count==PROCESS_NUM && sel1==0)||total==10) sel1=1; //如果全部未分配进程,那么就不能继续释放内存 324 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(); //显示 } } }

(2)解释结果

运行结果:

 

 

 解释:

①第一次内存分配:进程名为process-03,起始地址为0,进程占用内存大小为98;剩余空闲分区首地址为98,大小为926。

分配结果:

释放进程process-03:

②第二次内存分配:进程名为process-02,起始地址为0,进程占用内存大小为107;剩余空闲分区首地址为107,大小为917。

分配结果:

释放进程process-02:

③第三次内存分配:进程名为process-03,起始地址为0,进程占用内存大小为107;剩余空闲分区首地址为107,大小为917。未释放进程。

分配结果:

 

 ④第四次内存分配:进程名为process-01,起始地址为96,进程占用内存大小为67;剩余空闲分区首地址为163,大小为861。未释放进程。

6. 源码

  1 #include<stdio.h>
  2 #include<stdlib.h>
  3 #include<string.h>
  4 #include<time.h>
  5
  6 #define PNAME_LEN 32           //进程名
  7 #define MEM_SIZE 1024          //内存大小
  8 #define MEM_START 0            //起始位置
  9 #define MATE_FIR 1             //定义首次适配算法
 10 #define DATA_NUM 20            //定义产生数据的组数
 11 #define PROCESS_NUM 3          //进程数
 12 #define PROCESS_SIZE 10        //进程大小
 13 #define ALLOC_SIZE 100         //随机分配最大值
 14
 15 /*记录内存空间使用情况,每个进程分配到的内存块描述*/
 16 typedef struct allocated_block{
 17     int pid;
 18     int size;
 19     int start_addr;
 20     char process_name[PNAME_LEN];
 21     struct allocated_block *next;
 22 }AB;
 23 /*记录空闲分区,描述每一个空闲块的数据结构*/
 24 typedef struct free_block_type{
 25     int size;
 26     int start_addr;
 27     struct free_block_type *next;
 28 }FBT;
 29 /*描述每个进程结构*/
 30 typedef struct Process{
 31     int size;
 32     int pid;
 33     char process_name[PNAME_LEN];
 34 }PRO;
 35
 36 FBT *free_block;//指向内存中空闲块链表的首指针
 37 /*进程分配内存块链表的首指针*/
 38 AB *allocated_block_head = NULL;
 39
 40 static int pid = 0;          /*初始pid*/
 41
 42 int mem_size = MEM_SIZE;     //内存大小
 43 int ma_algorithm = MATE_FIR; //当前分配算法为首次适配算法
 44 int min_mem_size = 0;        //设置剩余分区过小的标志
 45
 46 //初始化空闲分区链表
 47 FBT *Init_Free_Block(int mem_size){
 48     FBT *fb;
 49     fb = (FBT*)malloc(sizeof(FBT));
 50     if(fb==NULL){
 51         printf("No mem\n");
 52         return NULL;
 53     }
 54     fb->size = mem_size;
 55     fb->start_addr = MEM_START;
 56     fb->next = NULL;
 57     return fb;
 58 }
 59
 60 void Rearrange_FIR(){              //首次适配算法,冒泡起始地址升序
 61     if(free_block == NULL || free_block->next == NULL)
 62         return;
 63     FBT *t1,*t2,*head;
 64     head = free_block;
 65     for(t1 = head->next;t1;t1 = t1->next){
 66         for(t2 = head;t2 != t1;t2=t2->next){
 67             if(t2->start_addr > t2->next->start_addr){
 68                 int tmp = t2->start_addr;
 69                 t2->start_addr = t2->next->start_addr;
 70                 t2->next->start_addr = tmp;
 71                 tmp = t2->size;
 72                 t2->size = t2->next->size;
 73                 t2->next->size = tmp;
 74             }
 75         }
 76     }
 77 }
 78 void Rearrange(int algorithm){  //按指定的算法整理内存空闲块链
 79     Rearrange_FIR();
 80 }
 81
 82 int Display_Mem_Usage(){            //显示当前内存的使用情况
 83     FBT *fbt = free_block;
 84     AB *ab = allocated_block_head;
 85     printf("------------------------------------------------------------------\n");
 86     printf("Free Memory:\n");       //空闲内存
 87     printf("%20s %20s\n","     start_addr","       size");
 88     while(fbt!=NULL){
 89         if(fbt->size!=0)
 90             printf("%20d %20d\n",fbt->start_addr,fbt->size);
 91         fbt = fbt->next;
 92     }
 93     printf("\n");
 94     printf("Used Memory:\n");       //已分配内存
 95     printf("%10s %20s %20s %10s\n","PID","ProcessName","start_addr","size");
 96     while(ab != NULL){
 97         printf("%10d %20s %20d %10d\n",ab->pid,ab->process_name,ab->start_addr,ab->size);
 98         ab = ab->next;
 99     }
100     printf("------------------------------------------------------------------\n");
101     return 0;
102 }
103 int Dispose(AB *free_ab){                  //释放链表ab节点
104     AB *pre,*ab;
105     if(free_ab == allocated_block_head){    //若释放首节点
106         allocated_block_head = allocated_block_head->next;
107         free(free_ab);
108         return 1;
109     }
110     pre = allocated_block_head;             //否则
111     ab = allocated_block_head->next;
112     while(ab!=free_ab){
113         pre = ab;
114         ab = ab->next;
115     }
116     pre->next = ab->next;
117     free(ab);
118     return 2;
119 }
120 int Free_Mem(AB *ab){                //更新分区表归还已分配区,以及可能的合并
121     int algorithm = ma_algorithm;
122     FBT *fbt,*pre,*work;
123     fbt = (FBT*)malloc(sizeof(FBT));
124     if(!fbt) return -1;
125
126     fbt->size = ab->size;
127     fbt->start_addr = ab->start_addr; //插入链尾
128     work = free_block;
129     if(work == NULL){
130         free_block = fbt;
131         fbt->next == NULL;
132     }else{
133         while(work ->next != NULL){
134             work = work->next;
135         }
136         fbt->next = work->next;
137         work->next = fbt;
138     }
139     Rearrange_FIR();                   //首次适配算法
140     pre = free_block;
141     while(pre->next){
142         work = pre->next;
143         if(pre->start_addr + pre->size == work->start_addr ){
144             pre->size = pre->size + work->size;
145             pre->next = work->next;
146             free(work);
147             continue;
148         }else{
149             pre = pre->next;
150         }
151     }
152     Rearrange(ma_algorithm);          //按照当前算法排序
153     return 1;
154 }
155 AB *Find_Process(int pid){            //找到pid对应的链表节点
156     AB *tmp = allocated_block_head;
157     while(tmp != NULL){               //如果找不到
158         if(tmp->pid == pid){
159             return tmp;
160         }
161         tmp = tmp->next;
162     }
163     printf("Process with PID %d not found!\n",pid);
164     return NULL;
165 }
166 int Kill_Process(int pid){           //释放进程内存
167     AB *ab;
168     ab = Find_Process(pid);
169     if(ab!=NULL){
170         Free_Mem(ab);                //释放分配表
171         Dispose(ab);                 //释放节点
172         return 0;
173     }else{
174         return -1;
175     }
176 }
177 int Find_Free_Mem(int request){      //寻找非进程分配分区
178     FBT *tmp = free_block;
179     int mem_sum = 0;
180     while(tmp){
181         if(tmp->size >= request){    //若可以直接分配
182             return 1;
183         }
184         mem_sum += tmp->size;
185         tmp = tmp->next;
186     }
187     if(mem_sum >= request){          //若可以合并后分配
188         return 0;
189     }else{                           //若空间不足
190         return -1;
191     }
192 }
193 void Sort_AB(){                      //将已分配表按起始地址从大到小排序
194     if(allocated_block_head == NULL || allocated_block_head->next == NULL)
195         return;
196     AB *t1,*t2,*head;
197     head = allocated_block_head;
198     for(t1 = head->next;t1;t1 = t1->next){
199         for(t2 = head;t2 != t1;t2=t2->next){
200             if(t2->start_addr > t2->next->start_addr){
201                 int tmp = t2->start_addr;
202                 t2->start_addr = t2->next->start_addr;
203                 t2->next->start_addr = tmp;
204                 tmp = t2->size;
205                 t2->size = t2->next->size;
206                 t2->next->size = tmp;
207             }
208         }
209     }
210 }
211 void Reset_AB(int start){            //重新分配内存地址
212     AB *tmp = allocated_block_head;
213     while(tmp != NULL){
214         tmp->start_addr = start;
215         start += tmp->size;
216         tmp = tmp->next;
217     }
218 }
219 void  Memory_Compact(){             //进行内存紧缩
220     FBT *fbttmp = free_block;
221     AB *abtmp = allocated_block_head;
222     int sum = 0;
223     while(fbttmp!=NULL){            //检测剩余内存
224         sum += fbttmp->size;
225         fbttmp = fbttmp->next;
226     }
227     fbttmp = free_block;            //合并区块
228     fbttmp->size = sum;
229     fbttmp->start_addr = 0;
230     fbttmp->next=NULL;
231     FBT *pr = free_block->next;      //释放分区
232     while(pr != NULL){
233         fbttmp = pr->next;
234         free(pr);
235         pr = fbttmp;
236     }
237     Sort_AB();                      //已分配空间重新排序
238     Reset_AB(sum);
239 }
240 void Do_Allocate_Mem(AB *ab){       //分配内存
241     int request = ab->size;
242     FBT *tmp = free_block;
243     while(tmp != NULL){
244         if(tmp->size >= request){
245             ab->start_addr = tmp->start_addr;
246             int residue = tmp->size - request;
247             tmp->size = residue;
248             tmp->start_addr = tmp->start_addr + request;
249             return ;
250         }
251         tmp = tmp->next;
252     }
253 }
254 int Allocate_Mem(AB *ab){          //分配内存应用
255     FBT *fbt,*pre;
256     int request_size=ab->size;
257     fbt = pre = free_block;
258     int f = Find_Free_Mem(request_size); //寻找可分配
259     if(f == -1){                         //空闲内存不足
260         printf("Not enough free memory!\n");
261         return -1;
262     }else{
263         if(f == 0){                //内存紧缩后分配
264             Memory_Compact();
265         }
266         Do_Allocate_Mem(ab);       //分配
267     }
268     Rearrange(ma_algorithm);       //重排空闲分区
269     return 1;
270 }
271 int Alloc_Process(PRO prc){        //为进程分配内存
272     AB *ab;
273     int ret;
274     ab = (AB*)malloc(sizeof(AB));
275     if(!ab) exit(-5);
276     ab->next=NULL;
277     pid++;
278     strcpy(ab->process_name,prc.process_name);
279     ab->pid = pid;
280     ab->size=prc.size+rand()%ALLOC_SIZE; //随机分配内存
281     ret = Allocate_Mem(ab);              //分配内存,ret==1表示分配成功
282     if((ret == 1) && (allocated_block_head == NULL)){ //若allocated_block_head尚未赋值
283         allocated_block_head = ab;
284         return 1;
285     }else if(ret == 1){                  //分配成功
286         ab->next = allocated_block_head;
287         allocated_block_head = ab;
288         return 2;
289     }else if(ret == -1){                 //分配不成功
290         printf("Fail!\n");
291         free(ab);
292         return -1;
293     }
294     return 3;
295 }
296
297 //初始化进程
298 void Init_Program(PRO prc[],int n)
299 {
300     for(int i=0;i<n;++i){
301         prc[i].size=PROCESS_SIZE;
302         prc[i].pid=-1;
303         sprintf(prc[i].process_name,"process-%02d",i+1);
304     }
305 }
306
307 int main(int argc, char const *argv[]){
308     int sel1,sel2;
309     int total=0;                     //记录分配内存的次数
310     free_block=Init_Free_Block(mem_size); //初始化空闲区
311     PRO prc[PROCESS_NUM];            //存放要加载的进程
312     Init_Program(prc,PROCESS_NUM);   //对这几个程进程进行初始化
313     srand((unsigned)time(NULL));
314     for(int i=0;i<DATA_NUM;++i)
315     {
316         sel1=rand()%2;
317         int count=0;                  //统计三个进程中有多少个进程已经分配内存
318         for(int j=0;j<PROCESS_NUM;++j){
319             if(prc[j].pid!=-1)
320                 count++;
321         }        //如果全部分配进程或者进程分配到达10次,那么就不能继续分配内存
322         if((count==PROCESS_NUM && sel1==0)||total==10)
323             sel1=1;                   //如果全部未分配进程,那么就不能继续释放内存
324         if(count==0 && sel1==1)
325             sel1=0;
326         if(sel1==0)                    //为进程分配内存
327         {                              //随机找到一个未分配内存的进程
328             do{
329                 sel2=rand()%PROCESS_NUM;
330             }while(prc[sel2].pid!=-1);
331             Alloc_Process(prc[sel2]);  //分配内存空间
332             prc[sel2].pid=pid;         //改变标记
333             total++;
334             Display_Mem_Usage();       //显示结果
335         }
336         else                           //释放进程占用的内存空间
337         {
338             do{                         //随机找到一个可释放进程
339                 sel2=rand()%PROCESS_NUM;
340             }while(prc[sel2].pid==-1);
341             Kill_Process(prc[sel2].pid);//释放内存空间
342             prc[sel2].pid=-1;           //改变标记
343             Display_Mem_Usage();        //显示
344         }
345     }
346  }
posted on 2020-05-17 00:21  才半页  阅读(328)  评论(0编辑  收藏  举报