内存分配算法 伙伴系统

   伙伴系统是常用的内存分配算法，linux内核的底层页分配算法就是伙伴系统，伙伴系统的优点就是分配和回收速度快，减少外部碎片。算法描述: 

 https://en.wikipedia.org/wiki/Buddy_memory_allocation                                      http://dysphoria.net/OperatingSystems1/4_allocation_buddy_system.html

网上也搜了大牛的实现。 云风:https://github.com/cloudwu/buddy  

对云风的精简版 https://github.com/wuwenbin/buddy2

            这两个版本思想一样都是维护一棵满二叉树，进行分配和回收，云风版的通过标记内存节点状态进行分配，第二个版本是保存当前内存最大的连续可用数，在某些情况下避免了无效的遍历，第二个版本也可以修改为保存最大连续内存数目的阶，内存消耗就会变小。这两个算法分配和回收复杂度都是logn，并且空闲内存必须是2^n个基本分配单位。

      然后又看了一下linux4.8的buddy system实现，linux的buddy system主要进行page分配也是linux最底层的分配，其他的分配算法都是以这个分配为基础，在x86架构下一个page是4KB。linux对内存进行了分区包括低端内存区，高端内存区，dma区，而且还对numa架构做了很多处理，对页面也进行了分类，这些不是讨论的重点，现在主要是提取linux的buddy算法，只提取核心部分，可以在控制台下运行。buddy system的数据结构就是下图所示，看着像哈希表中的拉链法，每个链表保存相同大小的内存块。最大的是10，也就是1024个基本单位，所以linux在x86下一次最多可分配4MB内存。

           顺便学习下linux内核对链表的各种操作，代码实现

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
//双向链表
struct list_head {
    struct list_head *prev, *next;
};

//拉链法存储空闲内存
typedef struct free_area {
    struct list_head free_list;  //把空闲内存块链接到空闲链表
    unsigned long nr_free;       //每个链表空闲块的个数
} free_area_t;

struct page {
    struct list_head page_link;
    int order;                  //当前页面所处的阶
    unsigned int size;          //如过当前页面是起始页面则size表示连续的页面数，如过不是起始页面则是0
};

typedef unsigned char uint8_t ;

#define   MAX_ORDER    11         //最大阶是10,也就是最大的分配单位是2^10，在此程序中一次最多分配4MB内存
#define   PAGE_SIZE    4096       //基本分配单位
#define   PAGE_NUMS    4096       //页面个数

uint8_t mem_size[PAGE_SIZE * PAGE_NUMS];   //需要管理的内存

struct page mem_map[PAGE_NUMS];

free_area_t free_area[MAX_ORDER];

#define PAGE_TO_PFN(page)    ((unsigned int)(page - mem_map))

#define ADDR_TO_PAGE(addr)   (((unsigned int)((uint8_t*)addr - mem_size)) / PAGE_SIZE)
#define PAGE_TO_ADDR(page)    (unsigned int)(PAGE_TO_PFN(page) * PAGE_SIZE + mem_size)
/**
 *获取成员在结构体中的相对偏移大小
 */
#define offsetof(TYPE, MEMBER)	((unsigned int)&((TYPE *)0)->MEMBER)

/**
 *获取结构体地址
 */
#define container_of(ptr, type, member) ({			\
	const typeof( ((type *)0)->member ) *__mptr = (ptr);	\
	(type *)( (char *)__mptr - offsetof(type,member) );})

/**
 *初始化双向链表
 */
#define LIST_HEAD_INIT(name) { &(name), &(name) }

/**
 *用宏快速定义双向链表
 */
#define LIST_HEAD(name) \
    struct list_head name = LIST_HEAD_INIT(name)

static inline void INIT_LIST_HEAD(struct list_head *list)
{
    list->next = list;
    list->prev = list;
}


/**
 *在任意两个元素之间插入一个entry
 */
static inline void __list_add(struct list_head *new,
                              struct list_head *prev,
                              struct list_head *next)
{
    new->next = next;
    prev->next = new;
    next->prev = new;
    new->prev = prev;
}


/**
 *在链表头插入一个新元素，相当于头插法
 */
static inline void list_add(struct list_head *new, struct list_head *head)
{
    __list_add(new, head, head->next);
}


/**
 *在链表尾部插入一个新元素，相当于尾插法
 */
static inline void list_add_tail(struct list_head *new, struct list_head *head)
{
    __list_add(new, head->prev, head);
}

/**
 *删除节点操作,删除两个节点之间的操作
 */
static inline void __list_del(struct list_head *prev, struct list_head *next)
{
    prev->next = next;
    next->prev = prev;
}

/**
 *删除节点
 */
static inline void __list_del_entry(struct list_head *entry)
{
    __list_del(entry->prev, entry->next);
}

/**
 *删除节点,并且将next和prev置空，linux内核中是指向一个指定的地址
 */
static inline void list_del_entry(struct list_head *entry)
{
    __list_del_entry(entry);
    entry->next = NULL;
    entry->prev = NULL;
}

/**
 *替换某个节点
 */
static inline void list_replace(struct list_head *old, struct list_head *new)
{
    new->next = old->next;
    new->prev = old->prev;
    new->prev->next = new;
    old->next->prev = new;
}

/**
 *把其中一个链表的节点移动到另一个链表头
 */
static inline void list_move(struct list_head *list, struct list_head *head)
{
    __list_del_entry(list);
    list_add(list, head);
}

/**
 *把其中一个链表的节点移动到另一个链表末端
 */
static inline void list_move_tail(struct list_head *list, struct list_head *head)
{
    __list_del_entry(list);
    list_add_tail(list, head);
}

/**
 *判断链表是否是最后一个节点
 */
static inline int list_is_last(const struct list_head *list, const struct list_head *head)
{
    return list->next == head;
}

/**
 *判断链表是否为空
 */
static inline int list_empty(const struct list_head *head)
{
    struct list_head *next = head->next;
    return (next == head) && (head->prev == next);
}

/**
 * 获取包含链表节点的结构体
 * ptr   链表节点地址
 * type  结构体类型
 * member 结构体成员
 */
#define list_entry(ptr, type, member) \
    container_of(ptr, type, member)

/**
 * 获取链表第一个元素的结构体
 * ptr = head
 */
#define list_first_entry(ptr, type, member) \
    list_entry((ptr)->next, type, member)

#define list_first_entry_or_null(ptr, type, member) \
    (ptr)->next == ptr ? NULL : list_first_entry(ptr, type, member)
/**
 * 获取链表最后一个元素的结构体
 */
#define list_last_entry(ptr, type, member) \
    list_entry((ptr)->prev, type, member)

/**
 * 获取下一个元素结构体
 */
#define list_next_entry(pos, member) \
    list_entry((pos)->member.next, typeof(*(pos)), member)

/**
 * 获取上一个元素结构体
 */
#define list_prev_entry(pos, member) \
    list_entry((pos)->member.prev, typeof(*(pos)), member)

/**
 * 遍历链表
 */
#define list_for_each(pos, head) \
    for(pos = (head)->next; pos != (head); pos = pos->next)

/**
 * 遍历链表结构体
 */
#define list_for_each_entry(pos, head, member) \
    for(pos = list_first_entry(head, typeof(*(pos)), member); \
        &(pos->member) != (head);                               \
        pos = list_next_entry(pos, member))

static inline int page_to_pfn(struct page *page)
{
    return PAGE_TO_PFN(page);
}
static inline int fix_size(unsigned int size)
{
    size -= 1;
    size |= size >> 1;
    size |= size >> 2;
    size |= size >> 4;
    size |= size >> 8;
    size |= size >> 16;
    return size + 1;
}
static inline int get_order(unsigned int size)
{
    int i = 0;
    while(i < 32) {
        if(size & (1 << i))
            return i;
        i++;
    }
    return -1;
}

static inline unsigned int
__find_buddy_index(unsigned int page_idx, unsigned int order)
{
	return page_idx ^ (1 << order);
}

static inline int page_is_buddy(struct page *buddy, int order)
{
    return buddy->order == order;
}
static inline void expand(unsigned int low, unsigned int high,
                          struct page *page, struct free_area *area)
{
    unsigned int size;
    while(low < high) {
        high--;
        area--;
        size = 1 << high;
        list_add(&page[size].page_link, &area->free_list);
        area->nr_free++;
        page[size].order = high;
        page[size].size = size;
    }

}
static inline struct page *__alloc_pages(unsigned int order)
{
    unsigned int current_order;
	struct free_area *area;
	struct page *page;
	for(current_order = order; current_order < MAX_ORDER; current_order++) {
        area = &(free_area[current_order]);
        page = list_first_entry_or_null(&area->free_list, struct page, page_link);
        if(!page)
            continue;
        list_del_entry(&(page->page_link));
        page->order = -1;
        page->size = 1 << order;
        area->nr_free--;
        expand(order, current_order, page, area);
        return page;
	}
	return NULL;

}
static struct page *alloc_pages(unsigned int size)
{
    struct page *page;
    unsigned int alloc_size = fix_size(size);
    unsigned int order = get_order(alloc_size);
    if(order < 0)
        assert(0);
    if(order >= MAX_ORDER)
        assert(0);
    page = __alloc_pages(order);
    if(page)
        return page;
    return NULL;
}
static void __free_pages(struct page *page, int order)
{
    unsigned int page_idx;
    unsigned int combined_idx;
	unsigned int buddy_idx;
	unsigned int pfn;
	struct page *buddy;

	pfn = page_to_pfn(page);
	page->size = 0;
	page_idx = pfn & ((1 << MAX_ORDER) - 1);
	while(order < MAX_ORDER - 1) {
        buddy_idx = __find_buddy_index(page_idx, order);
        buddy = page + (buddy_idx - page_idx);
        //buddy可能会越界如果有4097个页面，则idx为4096的页面的buddy越界
        if(buddy > (mem_map + PAGE_NUMS - 1))
            break;
        if(!page_is_buddy(buddy, order))
            break;
        list_del_entry(&buddy->page_link);         //buddy从当前链表删除
        free_area[order].nr_free--; //当前链表空闲数减一
        buddy->order = -1;
        buddy->size = 0;
        combined_idx = buddy_idx & page_idx;
        page = page + (combined_idx - page_idx);
        page_idx = combined_idx;
        order++;
	}
	page->order = order;
	page->size = 1 << order;
	list_add(&(page->page_link), &(free_area[order].free_list));
	free_area[order].nr_free++;
}
static void free_pages(struct page *page)
{
    int order = get_order(page->size);
    __free_pages(page, order);
}

static void buddy_free(void *addr)
{
    struct page *page = &mem_map[ADDR_TO_PAGE(addr)];
    free_pages(page);
}

static void *buddy_malloc(unsigned int size)
{
    struct page *page = alloc_pages(size);
    if(page)
        return mem_size + (PAGE_TO_PFN(page) * PAGE_SIZE);
    return NULL;
}

static void init_free_area()
{
    int cur_order = 0;
    for(; cur_order < MAX_ORDER; cur_order++)
        INIT_LIST_HEAD(&(free_area[cur_order].free_list));
}
static void init_pages()
{
    int i;
    for(i = 0; i < PAGE_NUMS; i++) {
        mem_map[i].order = -1;
        mem_map[i].size = 0;
    }
}
static void free_mem_to_buddy()
{
    int i;
    for(i = 0; i < PAGE_NUMS; i++)
        __free_pages(&mem_map[i], 0);
}

static void init_mm()
{
    init_free_area();
    init_pages();
    free_mem_to_buddy();
}
/*
 * 打印空闲链表的状态
 */
static void __dump()
{
    int order;
    for(order = 0; order < MAX_ORDER; order++) {
        struct page *page;
        if(list_empty(&free_area[order].free_list)) {
            printf("order: %d is NULL\n\n", order);
        } else {
            printf("order: %d, nr_free: %d :\n", order, free_area[order].nr_free);
            list_for_each_entry(page, &free_area[order].free_list, page_link)
                printf("pfn: %d, page_addr: 0x%p, mem_addr: 0x%p, size: %d\n\n",PAGE_TO_PFN(page), page, PAGE_TO_ADDR(page), page->size);
        }
    }
}
static void buddy_test()
{
    uint8_t *p1 = buddy_malloc(1);
    assert(free_area[MAX_ORDER - 1].nr_free == 3 && free_area[0].nr_free == 1);
    __dump();
    buddy_free(p1);
    __dump();
    assert(free_area[MAX_ORDER - 1].nr_free == 4 && free_area[0].nr_free == 0);
    uint8_t *p2 = buddy_malloc(1024);
    uint8_t *p3 = buddy_malloc(1024);
    uint8_t *p4 = buddy_malloc(2);
    assert(p2 == p1);
    assert(free_area[MAX_ORDER - 1].nr_free == 1);
    assert(free_area[0].nr_free == 0);
    buddy_free(p2);
    buddy_free(p4);
    uint8_t *p5 = buddy_malloc(1024);
    uint8_t *p6 = buddy_malloc(1);
    assert(p5 == p4);
    assert(p6 == p2);
    buddy_free(p5);
    buddy_free(p6);
    assert(free_area[MAX_ORDER - 1].nr_free == 3);
    buddy_free(p3);
    assert(free_area[MAX_ORDER - 1].nr_free == 4 && free_area[0].nr_free == 0);
    p1 = buddy_malloc(3);
    p2 = buddy_malloc(4);
    assert(p1 + PAGE_SIZE * 4 == p2);
    p3 = buddy_malloc(16);
    assert(p2 + PAGE_SIZE * 12 == p3);
    p4 = buddy_malloc(16);
    buddy_free(p3);
    buddy_free(p4);
    assert(free_area[4].nr_free == 1);
    p3 = buddy_malloc(512);
    p4 = buddy_malloc(1);
    buddy_free(p1);
    p1 = buddy_malloc(1);
    assert(p1 == p4 + PAGE_SIZE);
    buddy_free(p1);
    buddy_free(p3);
    buddy_free(p4);
    buddy_free(p2);
    assert(free_area[MAX_ORDER - 1].nr_free == 4);

}
int main()
{
    init_mm();
    buddy_test();
    return 0;
}