伙伴系统内存管理-优快云博客

假设系统的可利用内存空间容量为2^m个字(地址从0到2^m-1)，则在开始运行时，整个内存区是一个大小为2^m的空闲块，在运行了一段时间之后，被分隔成若干占用块和空闲块。为了在分配时查找方便起见，我们将所有大小相同的空闲块建于一张子表中。每个子表是一个双重链表，这样的链表可能有m+1个，将这m+1个表头指针用向量结构组织成一个表，这就是伙伴系统中的可利用空间表，如图所示：

分配算法：

当用户提出大小为n的内存请求时，首先在可利用表上寻找结点大小与n相匹配的子表，若此子表非空，则将子表中任意一个结点分配之即可；若此子表为空，则需从结点更大的非空子表中去查找，直至找到一个空闲块，则将其中一部分分配给用户，而将剩余部分插入相应的子表中。
若2^k-1 < n ≤ 2^k-1，又第k+1个子表不空，则只要删除此链表中第一个结点并分配给用户即可；若 2^k-2 < n ≤ 2^k-1-1，此时由于结点大小为2^k-1 的子表为空，则需从结点大小为2^k 的子表中取出一块，将其中一半分配给用户，剩余的一半作为一个新结点插入在结点大小为2^k-1的子表中，若2^k-i-1 < n ≤ 2^k-i-1(i为小于是的整数)，并且所有结点小于2^k的子表均为空，则同样需从结点大小为2^k的子表中取出一块，将其中2^k-i的一小部分分配给用户，剩余部分分割成若干个结点分别插入在结点大小为2^k-1 、 2^k-2 、…、 2^k-i的子表中。

回收算法：

在用户释放不再使用的占用块时，系统需将这新的空闲块插入到可利用空间表中去。这里，同样有一个地址相邻的空闲块归并成大块的问题。但是在伙伴系统中仅考虑互为“伙伴”的两个空闲块的归并。
何谓“伙伴”?如前所述，在分配时经常需要将一个大的空闲块分裂成两个大小相等的存储区，这两个由同一大块分裂出来的小块就称之“互为伙伴”。例如：假设p为大小为pow(2,k)的空闲块的初始地址，且p MOD pow(2,k+1)=0，则初始地址为p和p+pow(2,k)的两个空闲块互为伙伴。在伙伴系统中回收空闲块时，只当其伙伴为空闲块时才归并成大块。也就是说，若有两个空闲块，即使大小相同且地址相邻，但不是由同一大块分裂出来的，也不归并在一起。
由此，在回收空闲块时，应首先判别其伙伴是否为空闲块，若否，则只要将释放的空闲块简单插入在相应子表中即可；若是，则需在相应子表中找到其伙伴并删除之，然后再判别合并后的空闲块的伙伴是否是空闲块。依此重复，直到归并所得空闲块的伙伴不是空闲块时，再插入到相应的子表中去。

代码如下（只用了单链表）：

[cpp]view plaincopy 
   
 #include <stdio.h>  
 #include <stdlib.h>  
 #include <time.h>  
   
 #define MIN_MOMORY_SIZE 536870912   //随机产生的最小内存空间：512M （最大为1G）   
 #define INDEX_SIZE 30               //哈希索引表大小   
 #define WORKTIME 1500               //系统工作时间   
 #define MAX_REQ_SIZE 268435456      //申请空闲内存分配的最大容量：256M   
 #define MIN_DUE 30                  //使用内存块的最短时间  
 #define MAX_DUE 90                  //使用内存块的最长时间  
 #define OCCUPY_INTERVAL 60          //每次分配的最大间隔   
 #define USED 1                      //内存块被使用   
 #define UNUSED 0                    //内存块未被使用  
   
 //内存块链表结点结构   
 typedef struct buddy_node {  
     int flag;                       //标记空间是否被使用  
     int base;                       //本块儿内存的基地址   
     int occupy;                     //实际使用空间大小   
     int fragment;                   //碎片大小   
     int duetime;                    //使用时间  
     struct buddy_node *nextPtr;     //指向下一个结点   
 } Buddy, *BuddyPtr;  
   
 //哈希索引表结构   
 typedef struct hash_table {  
     int nodesize;  
     BuddyPtr headPtr;  
 } IndexTable;  
   
 IndexTable table[INDEX_SIZE];//使用哈希表管理伙伴系统   
 int ready = 0;               //需要分配内存的时刻   
 int availSpace;              //可分配空间大小   
 int totalFragment = 0;       //总碎片大小   
   
 //函数：根据k的值计算哈希表项链接的内存块的大小  
 int get_size (int k)  
 {  
     int i, nodesize = 1;  
       
     for (i = 0; i < k; i ++)  
         nodesize *= 2;  
   
     return nodesize;  
 }  
   
 //函数：初始化哈希索引表   
 void ini_index (void)  
 {  
     int i;  
       
     for (i = 0; i < INDEX_SIZE; i ++) {  
         table[i].nodesize = get_size(i);  
         table[i].headPtr = NULL;  
     }   
 }  
   
 //函数：初始化伙伴系统  
 void int_system (int memory_size)  
 {  
     int i, addr = 0;  
     int left = memory_size;  
     BuddyPtr newnodePtr = NULL;  
        
     //初始化可分配空间大小和碎片大小   
     availSpace = memory_size;   
     totalFragment = 0;  
       
     //将内存分割成尽量大的2倍数的空闲块并插入到相应的索引表项中  
     for (i = INDEX_SIZE-1; left > 0; i --) {  
         if (left / table[i].nodesize == 1) {  
             newnodePtr = (BuddyPtr) malloc (sizeof (Buddy));//分配结点   
             newnodePtr->flag = UNUSED;  
             newnodePtr->base = addr;  
             newnodePtr->occupy = 0;   
             newnodePtr->fragment = 0;  
             newnodePtr->duetime = 0;  
             newnodePtr->nextPtr = NULL;  
             table[i].headPtr = newnodePtr;  
             addr += table[i].nodesize;  
             left -= table[i].nodesize;  
         }  
     }   
 }  
   
 //函数：程序运行结束后释放所有结点  
 void free_system (void)  
 {  
     int i;  
     BuddyPtr tempPtr = NULL, tofreePtr = NULL;  
        
     for (i = 0; i < INDEX_SIZE; i ++) {  
         if (table[i].headPtr) {  
             tempPtr = table[i].headPtr;  
             table[i].headPtr = NULL;  
             //依次释放所有结点  
             while (tempPtr) {  
                 tofreePtr = tempPtr;  
                 tempPtr = tempPtr->nextPtr;  
                 free (tofreePtr);  
             }  
         }  
     }  
 }  
   
 //函数：添加结点（形参为内存块结点的信息）   
 void insert_node (int i, int inbase, int f, int occ, int frag, int d)  
 {  
     BuddyPtr newnodePtr = NULL, prePtr = NULL, curPtr = NULL;  
       
     newnodePtr = (BuddyPtr) malloc (sizeof (Buddy));//分配结点  
     newnodePtr->base = inbase;  
     newnodePtr->flag = f;  
     newnodePtr->occupy = occ;   
     newnodePtr->fragment = frag;  
     newnodePtr->duetime = d;  
     newnodePtr->nextPtr = NULL;   
     if (table[i].headPtr == NULL)  
         table[i].headPtr = newnodePtr;  
     else {  
         curPtr = table[i].headPtr;  
         prePtr = NULL;  
         //按地址顺序插入内存块   
         while (curPtr && curPtr->base < inbase) {  
             prePtr = curPtr;  
             curPtr = curPtr->nextPtr;    
         }  
         if (prePtr == NULL) {          //插在最前   
             newnodePtr->nextPtr = curPtr;  
             table[i].headPtr = newnodePtr;  
         }  
         else if (curPtr == NULL) {     //插在最后   
             prePtr->nextPtr = newnodePtr;  
         }  
         else {                         //插在中间   
             prePtr->nextPtr = newnodePtr;  
             newnodePtr->nextPtr = curPtr;  
         }   
     }  
 }  
   
 //函数：删除结点  
 int delete_node (int i, BuddyPtr delPtr)  
 {  
     BuddyPtr prePtr = NULL, curPtr = NULL;  
     int basehold = delPtr->base;  
       
     curPtr = table[i].headPtr;  
     while (curPtr != delPtr) {  //寻找要删除的结点的位置   
         prePtr = curPtr;  
         curPtr = curPtr->nextPtr;    
     }  
     if (prePtr == NULL)         //要删除的结点在最前   
         table[i].headPtr = curPtr->nextPtr;  
     else                        //要删除的结点不在链表的最前   
         prePtr->nextPtr = curPtr->nextPtr;  
   
     free (curPtr);              //释放结点   
       
     return basehold;            //返回删除的内存块结点的基地址   
 }   
   
 //函数：伙伴系统的分配算法   
 void buddy_allocate (int time_slice)  
 {  
     int i, j, size, due;  
     int state = 0;              //分配状态：0为未分配，1为已分配   
     int inbase, basehold;  
     BuddyPtr curPtr = NULL;  
       
     if (ready == time_slice) {  //到达分配内存的时刻   
         printf ("Time %d:", time_slice);  
         size = 1 + rand () % MAX_REQ_SIZE;            //申请使用内存的大小   
         due = MIN_DUE + rand ()%(MAX_DUE - MIN_DUE);  //申请使用内存的时间  
           
         if (availSpace > size) {//在可分配空间大于申请空间时分配  
             //依次寻找可分配的内存块   
             for (i = 0; (i < INDEX_SIZE) && (state == 0); i ++) {  
                 //找到一个不小于申请大小的块索引  
                 if (table[i].nodesize >= size && table[i].headPtr) {  
                     curPtr = table[i].headPtr;  
                     //遍历相应的循环链表中   
                     while (curPtr && (state == 0)) {  
                         //找到空闲块  
                         if (curPtr->flag == UNUSED) {  
                             //空闲块的大小小于申请大小的2倍，分配   
                             if (table[i].nodesize / size == 1) {  
                                 //在分配的内存块上设置信息   
                                 curPtr->flag = USED;  
                                 curPtr->occupy = size;  
                                 curPtr->fragment = table[i].nodesize - size;  
                                 curPtr->duetime = due + ready;  
                                 //修改可系统分配空间和碎片大小   
                                 availSpace -= table[i].nodesize;  
                                 totalFragment += curPtr->fragment;  
                                 state = 1;//标记已分配   
                                 break;  
                             }  
                             //空闲块的大小刚大于申请大小的2倍  
                             else {  
                                 basehold = delete_node (i, curPtr);//删除较大的空闲块并保留其基地址   
                                 inbase = basehold + table[i].nodesize;  
                                 j = i;  
                                 //分割空闲块   
                                 do {  
                                     j --;  
                                     inbase -= table[j].nodesize;   //设置要添加内存块结点的基地址   
                                     insert_node (j, inbase, UNUSED, 0, 0, 0);//添加较小的空闲块   
                                     printf ("A block cut takes place\n");  
                                 } while (table[j].nodesize / size > 1);  
                                 //分配   
                                 insert_node (j, basehold, USED, size, table[j].nodesize - size, due + ready);  
                                 //修改可系统分配空间和碎片大小   
                                 availSpace -= table[j].nodesize;  
                                 totalFragment += table[j].nodesize - size;  
                                 state = 1;//标记已分配   
                             }  
                         }  
                         //块被占用，查看下一结点   
                         else  
                             curPtr = curPtr->nextPtr;  
                     }  
                 }              
             }  
             printf ("Allocated %d,Fragment %d,Due %d\n", size, totalFragment, ready+due);  
         }  
               
         else if ((availSpace < size) && ((availSpace + totalFragment) >= size))  
             printf ("Allocation failed because of fragment!\n");  
         else  
             printf ("Allocation failed because of no enough unused space!\n");  
               
         ready += (1 + rand() % OCCUPY_INTERVAL);  //下次需要分配内存的时刻  
     }  
 }  
   
 //函数：伙伴系统的回收算法  
 void buddy_retrieve (int time_slice)  
 {  
     int i, basehold, dif;  
     int f = 0;  
     int Modnext=0;  
     BuddyPtr curPtr = NULL, todelPtr = NULL;   
       
     //依次查找，并回收需要回收的块   
     for (i = 0; i < INDEX_SIZE; i ++) {  
         if (table[i].headPtr) {  
             curPtr = table[i].headPtr;  
             while (curPtr) {  
                 if ((curPtr->flag == USED) && (curPtr->duetime == time_slice)) {//需要回收   
                     //修改可系统分配空间和碎片大小   
                     availSpace += table[i].nodesize;  
                     totalFragment -= curPtr->fragment;  
                     //回收为空闲块   
                     curPtr->flag = UNUSED;  
                     curPtr->occupy = 0;   
                     curPtr->fragment = 0;  
                     curPtr->duetime = 0;  
                     printf ("Time %d:Retrieve %d,Fragment %d\n", time_slice, table[i].nodesize, totalFragment);  
                 }  
                 curPtr = curPtr->nextPtr;  
             }  
         }  
     }  
       
     //合并空闲块  
     for (i = 0; i < INDEX_SIZE; i ++) {  
         if (table[i].headPtr) {              
             curPtr = table[i].headPtr;  
             while (curPtr && curPtr->nextPtr) {  
                 //将地址连续且都为空闲的块合并后加入下一级的链表中   
                 if (curPtr->flag == UNUSED && (curPtr->nextPtr)->flag == UNUSED) {  
                     dif = (curPtr->nextPtr)->base - curPtr->base;  
                     Modnext = ((int)(curPtr->nextPtr->base))%(2*table[i].nodesize);  
                     if ((dif == table[i].nodesize)&&(Modnext==0)) {  
                         //删除两个结点   
                         todelPtr = curPtr;  
                         curPtr = curPtr->nextPtr;  
                         basehold = delete_node (i, todelPtr);  
                         todelPtr = curPtr;  
                         curPtr = curPtr->nextPtr;  
                         delete_node (i, todelPtr);  
                         insert_node (i+1, basehold, UNUSED, 0, 0, 0);//添加合并后的结点   
                         printf ("Two blocks merge\n");  
                     }  
                     else  
                         curPtr = curPtr->nextPtr;  
                 }  
                 else  
                     curPtr = curPtr->nextPtr;  
             }  
         }  
     }  
 }  
   
 //函数：伙伴系统的处理过程   
 void buddy_system (void)  
 {  
     int time_slice = 0;  
       
     //在每个时间片内使用分配算法和回收算法   
     for (; time_slice < WORKTIME; time_slice ++) {  
         buddy_allocate (time_slice);         //分配算法   
         buddy_retrieve (time_slice);         //回收算法   
     }  
 }  
   
   
 int main(int argc, char *argv[])  
 {  
     int memory_size;  
       
     ini_index ();               //初始化哈希索引表   
     srand (time (NULL));        //设置随机数种子  
     //随机产生需要管理的内存大小：512M ~ 1G   
     memory_size = MIN_MOMORY_SIZE + rand() % MIN_MOMORY_SIZE;   
     printf ("The size of memory is:%d\n", memory_size);  
       
     int_system (memory_size);   //初始化伙伴系统   
       
     buddy_system ();            //伙伴系统的处理过程  
     printf ("Time %d:System execution stops and the spaces are all freed.\n", WORKTIME);  
       
     free_system ();             //释放所有结点   
       
     return 0;  
 }  

内存管理 三

回收算法：

内存管理三