自定义内存管理-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_32938605/article/details/107324937

1 源码：

源码已经提交github，内存管理github链接，欢迎一起讨论。

2 实现过程

该代码实现了在固定地址空间上进行内存的分配与释放。在操作系统启动时刻指定固定的地址作为mymlloc（）操作的Heap空间，也可以直接定义数组。在嵌入式系统中，最好指定固定的地址，方便进行管理以及问题的排查。

2.1 内存控制块定义

struct free_block_t{
    unsigned long size;
    unsigned char *start;
    unsigned char *end;
    struct list_head node_list;
    unsigned char is_empty;	
}__attribute__((aligned(4)));

以上代码定义了内存控制块，整个内存的分配与释放，就是对内存控制块所组成的链表进行添加与释放的操作。这里采用双向链表来实现。（参考Linux内核实现的）

/*form linux kernel*/

#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER) 

#define container_of(ptr, type, member) ({			        \
	const typeof( ((type *)0)->member ) *__mptr = (ptr);	\
	(type *)( (char *)__mptr - offsetof(type,member) );})

/*  list_entry 根据成员指针找到结构体指针
 *  @ptr    成员指针
 *  @head   结构体类型
 *  @member 在结构体中链表对应的成员名称
 */
#define list_entry(ptr, type, member) \
    container_of(ptr, type, member)
	
/*  list_for_each_entry 遍历整个链表
 *  @pos    循环变量
 *  @head   链表头节点
 *  @member 在结构体中链表对应的成员名称
 */
#define list_for_each_entry(pos, head, member)				    \
	for (pos = list_entry((head)->next, typeof(*pos), member);	\
	     &pos->member != (head); 	\
	     pos = list_entry(pos->member.next, typeof(*pos), member))
		 
#define LIST_HEAD_INIT(name) { &(name), &(name) }

#define LIST_HEAD(name) \
	struct list_head name = LIST_HEAD_INIT(name)
	
struct list_head {
	struct list_head *next, *prev;
};

/* INIT_LIST_HEAD 初始化链表头
 * @list 链表头名称
 */
static inline void INIT_LIST_HEAD(struct list_head *list)
{
	list->next = list;
	list->prev = list;
}

/* __list_add 添加节点到指定位置
 * @ new  新添加的节点
 * @ prev 插入点的前一个结点
 * @ next 插入点的下一个节点
 */
static inline void __list_add(struct list_head *new,
			      struct list_head *prev,
			      struct list_head *next)
{
	next->prev = new;
	new->next  = next;
	new->prev  = prev;
	prev->next = new;
}

/* list_add_tail 添加节点到链表尾部
 * @ new  新添加的节点
 * @ head 链表头节点
 */
static inline void list_add_tail(struct list_head *new, struct list_head *head)
{
	__list_add(new, head->prev, head);
}

/* __list_del 删除指定位置节点
 1. @ prev 要删除节点的前一个节点
 2. @ next 要删除节点的后一个节点
 */
static inline void __list_del(struct list_head * prev, struct list_head * next)
{
	next->prev = prev;
	prev->next = next;
}

内核在实现链表时只用了 *next, *prev 两个指针成员，每次想要获取链表上的实际数据时，可以通过list_entry（）函数来获取，list_entry（）又被定义成container_of（）。这个宏是内存中最常用的宏之一，使用结构体成员指针来获取结构体指针。

2.2 分配过程

判断输入参数，并且对齐
寻找空闲块
拆分空闲块

 list_for_each_entry(k,p_head,node_list)                 /*找到合适的空闲块*/
    {
        if(k->is_empty && k->size >= size)
        {
            LOG("k->start = %p\n", k->start);
            addr = k->start + sizeof(struct free_block_t); 
            
            LOG("start addr = %p\n",addr);
            
            bk_remain_size = k->end - k->start - sizeof(struct free_block_t) - size;
            
            LOG("bk_remain_size = %ld",bk_remain_size);
            
            k->end = addr + size;      /*截取空闲块*/
            
            LOG(" end addr = %p\n",k->end );
            k->is_empty = 0;   
            
            if(bk_remain_size > sizeof(struct free_block_t))
            {
                free_block_p                 = (void *)k->end;       /*建立新的内存控制块*/
                free_block_p->start          = free_block_p;
                free_block_p->end            = (void *)free_block_p + bk_remain_size;
                free_block_p->size           = bk_remain_size - sizeof(struct free_block_t);
                free_block_p->is_empty       = 1;
                free_block_p->node_list.next = &(free_block_p->node_list);
                free_block_p->node_list.prev = &(free_block_p->node_list);
                
                LOG("node_list = %p\n", &free_block_p->node_list);
                
                LOG("next = %p prev = %p\n",free_block_p->node_list.next,free_block_p->node_list.prev);
                
                LOG("head = %p\n",p_head);
                
                LOG("p_head->prev->next = %p\n",p_head->prev);
                
                LOG("pos = 0x%p\n",&k);
                
                list_add_tail(&(free_block_p->node_list),p_head);
            }
            LOG("found block node \n");
            break;
        }

通过代码可以看出来，在第一次内存分配的时候，把一个整的空闲块拆成了两个。第二次分配把剩下的空闲块又拆成了两个。。。最坏情况是内存中有SIZE_OF_MALLOC/sizeof(struct free_block_t)个内存控制块，但是在嵌入式系统中不会频繁且动态的分配释放内存，因此这样的设计是可以被接受的。

2.3 释放过程

在实现myfree（）时，对相邻的空闲块进行了合并，提高了在多次分配释放的使用场合下的内存使用效率，减少内存碎片。

 if(k->node_list.prev != p_head)                                               /*空闲块的前一个不是head*/
    {
        if(list_entry(k->node_list.prev,struct free_block_t,node_list)->is_empty == 1)
        {   
            LOG("delete a free block \n");
            LOG("k->node_list.prev->next = %p \n",k->node_list.prev->next);
            LOG("k->node_list.next->prev = %p \n",k->node_list.next->prev);
            
            
            LOG("k->node_list.prev = %p \n",k->node_list.prev);
            LOG("k->node_list.next = %p \n",k->node_list.next);
            
            __list_del((k->node_list.prev),(k->node_list.next));
           // k->node_list.prev->next = k->node_list.next;
           // k->node_list.next->prev = k->node_list.prev;
            LOG("k->node_list.prev->next = %p \n",k->node_list.prev->next);
            LOG("k->node_list.next->prev = %p \n",k->node_list.next->prev);
        }
    }
    if(k->node_list.next != p_head)                                               /*空闲块的后一个不是head*/
    {
        if(list_entry(k->node_list.next,struct free_block_t,node_list)->is_empty == 1)
        {
            LOG("delete b free block \n");
            __list_del(&(k->node_list),(k->node_list.next->next));  
        }
    }