操作系统伙伴(Buddy) --算法C语言实现

内存分区——伙伴(Buddy)算法

1.1概念

内存管理的分区技术主要为固定分区和动态分区，都存在一定的缺陷。固定分区方案限制了活动进程的数量，内存空间利用率取决于可用分区的大小与进程大小的匹配程度；动态分区的维护比较复杂，并且会引入进行压缩的额外开销。一种折中方案就是伙伴系统。

伙伴系统中可用内存块的大小为2^k个字，L≤K≤U，其中2^L表示分配的最小快的尺寸，2^U表示分配的最大快的尺寸，通常2^U是可供分配的整个内存的大小。
最初，可用于分配的整个空间被视为一个大小块为2^U的块。若请求的大小s满足2^U-1 ≤ s ≤ 2^U，则分配整个空间。否则，该块分成两个大小相等的伙伴，大小均为2^U-1。若有2^U-2 < s ≤ 2^U-1，则给该请求分配两个伙伴中的任何一个；否则，其中的一个伙伴又被分成两半，持续这一过程，直到产生大于等于s的最小快，并且分配给该请求。在任何时候，伙伴系统中为所有大小为2ⁱ的“空洞”维护一个列表。空洞可通过对半分裂从i+1列表中移出，并且在i列表中产生两个大小为2ⁱ的伙伴。当i列表中的一对伙伴都变成未分配的块时，将他们从i列表中移出，合并为i+1列表中的一个块。

1.2基于C语言数组的参考代码：

#include 
#include 

struct Info
{
    int value;
    int count;  
    int begin;
    int end;     
};

void init(struct Info info[])
{
    int i;
    for(i=0; i<11; i++)
    {
        if(i == 0)  info[i].value = 1;
        else info[i].value = info[i-1].value*2;
        info[i].count = 0;   
        info[i].begin = 0;
        info[i].end = 0;    
    }
    info[10].count = 1; 
    info[10].end = 1023;    
}

void print(struct Info info[])
{
    int i,j;
    printf("|");
    for (i=0; i<11; i++){
    	if (info[10].count > 0){
    		printf("%d|",info[10].value);
    		break;
		}
    	if (info[i].count > 0){
    		printf("%d|",info[i].value);
		}else if(info[i+1].count > 0 && i!=9){
			printf("*|");
		}else if(i==9 && info[i].count == 0){
			printf("*|");
		}
	}	
}

void buddy(struct Info info[], int num)
{
    int i, j, k; 
    for(i=0; i<11; i++)
    {
        if(info[i].value >= num)
        {
            if(info[i].count == 1)
            {
                info[i].count = 0;
                printf("Allocate pages succefully!\n"); 
                return ;                
            }
            else{
                for(j=i; j<11; j++)
                {
                    if(info[j].count == 1)
                    {
                        info[j].count = 0;             //把该页拆分开 
                        for(k=i; k<j; k++)
                        {
                            info[k].count = 1;
                            info[k].begin = info[k].value;
                            info[k].end = info[k].begin*2 - 1;         
                        }   
                        printf("Allocate pages succefully!\n");
                        return ;             
                    }   
                    if(j == 10)  
                    {
                        printf("Allocate pages failed!\n");
                        return ; 
                    }
                }    
            }
        }         
    }    
}

int main()
{
    int i, num;
    struct Info info[11];
    printf("Init:\n");
    init(info);
    
    print(info);
    while(1)
    {
        printf("\nPlease input a  num:");
        scanf("%d", &num);
        fflush(stdin);
        if(num > 1023)  printf("The num is too big , try littler\n");
        else
        {
            buddy(info, num);
            print(info);
        }
    }
    system("pause");
    return 0;    
}

也可以参考这篇博文：Buddy算法实现

1.3运行结果

1.4 分析

其实感觉也可以用链表的方式来描述buddy算法，通过将一个链表分裂成两个或多个链表，最后将其顺序输出。如果运算数据较大，链表的运行速度更为理想。