十四. malloc&free的实现

发表于 | 更新于 | 分类于

之前的内容中已经实现过内存分配的功能，但之前的内存管理模块中只是实现了内核空间的内存分配，而且每次分配的空间都是已页为单位，也就是只能分配页的整数倍的空间。已页为单位的内存确实是最利于操作系统管理的，但是当只需要小块内存区域的时候，之前的内存管理模块就无法完成了。所以在这里要完善之前的内存管理模块，使其能够支持小块内存的分配。有了底层的内存管理模块的支撑之后，malloc和free的实现就非常容易了。

malloc底层原理

之前的内存管理模块中是通过bitmap对内存进行管理的，bitmap中的每一个bit位就代表一页大小的内存，该位为1时表示这页已经分配出去了。那么对小块内存进行分配的时候，同样需要一个结构来记录这块内存的情况，也就是说，要通过一种结构来对内存的分配与释放进行管理。

arena是一大块的内存被划分的多个小的内存块的内存仓库。按照内存块的大小，可以划分成不同规格的arena。比如一种arena中全是32byte的内存块，它就只相应32byte以下内存空间的分配。这一整块arena的大小同样是页的整数倍，按照申请内存空间的大小，这个arena可能是1页或者多页。

按照这种原理，arena就由两部分组成，一是这块内存的元信息，用来描述这个arena中剩余的内存块，二是内存池区域，里面就是多个大小相同的内存块。其结构如下图所示

arena结构

一块arena大小的内存总有分配完的时候，也就是该arena中的所有mem_block都分配出去了，那么肯定需要新增一个与之前arena规格相同的arena来满足内存的需求，那么这些相同规格arena之前同样需要一个结构来进行管理，这个结构用来记录arena的规格以及同规格arena中所有空闲内存块链表

内存块描述符

内存块描述符中会将所有同规格arena的空间内存块进行汇总，它相当于所有内存块的大仓库，分配内存的时候经过这个大仓库，找到里面的某个arena，也就是小仓库，最后从这个arena中找到某个空闲的内存块，将其分配出去。这个过程是不是和现实生活中从仓库取物品很类似。

arena中主要是针对小内存分配的管理，里面的内存块规格最大不会超过1024byte，那么对于超过1024byte的空间如何分配呢？一种可能的情况是将多个内存块合并起来，这些合并的内存块组成这个大空间，但是用这种方式对内存块信息的维护就变的极其麻烦。所以对于大的内存就不进行内存块的划分，它的arena就变成了这个样子

mark

这里我划分了7种规格的arena，分别为16byte, 32byte, 64byte, …. 1024byte。一个arena一般占用1页也就是4096byte，arena中的元信息在设计中它会占用12byte大小，对于规格为16byte的arena来说，它有(4096 - 12) / 16 = 255个内存块，有4byte的空间被浪费。

在内存分配的过程中，小于16byte的空间就会采用16byte的arena进行分配，后面同理。

实现malloc

说了那么多原理，还是来看看代码实现，从源码中能够更清晰的看出其原理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 内存块描述符
struct mem_block_desc
{
    uint32_t block_size;    // 内存块规格
    uint32_t blocks_per_arena;  //本arena中可容纳mem_block的数量
    struct list free_list;  // 目前可用的mem_block链表
};

struct arena
{
    struct mem_block_desc *desc; // arena中的元信息
    uint32_t cnt; // 空闲内存块的数量
    bool large; // 是否为大内存，当申请大内存时因为不会对内存块进行划分，他的desc会被置为NULL
};

// 内存块描述符个数
#define DESC_CNT 7

struct mem_block_desc k_block_descs[DESC_CNT];

内存管理的结构如上面所示，每个成员的作用都已经用注释说明了。需要注意的是当large为false时，该arena的内存块描述符会为NULL，因为该arena不会划分小的内存块，而是作为一个整体使用，且cnt不再表示空闲内存块的数量，而是表示所占用的页框数。

1
2
3
4
5
6
7
8
9
10
11
12
13
void block_desc_init(struct mem_block_desc *desc_array)
{
    uint16_t desc_idx, block_size = 16;

    for (desc_idx = 0; desc_idx < DESC_CNT; ++desc_idx)
    {
        desc_array[desc_idx].block_size = block_size;

        desc_array[desc_idx].blocks_per_arena = (PG_SIZE - sizeof(struct arena)) / block_size;
        list_init(&desc_array[desc_idx].free_list);
        block_size *= 2;
    }
}

对7种规格的内存块描述符进行初始化。

接下来就看sys_malloc的具体实现，该函数就是在堆上分配指定大小的空间。这也是malloc的底层实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
void *sys_malloc(uint32_t size)
{
    enum pool_flags pf;
    struct pool *mem_pool;
    uint32_t pool_size;
    struct mem_block_desc *descs;
    task_struct *cur_thread = running_thread();
    // 判断是内核还是用户进程需要分配空间
    if(cur_thread->pgdir == NULL)
    {
        pf = PF_KERNEL;
        pool_size = kernel_pool.pool_size;
        mem_pool = &kernel_pool;
        descs = k_block_descs;
    }
    else
    {
        pf = PF_USER;
        pool_size = user_pool.pool_size;
        mem_pool = &user_pool;
        descs = cur_thread->u_block_desc;
    }

    if(!(size > 0 && size < pool_size))
        return NULL;

    struct arena *a;
    struct mem_block *b;
    lock_acquire(&mem_pool->lock);

    // 处理大内存分配的情况，直接分配。
    // 分配的大小对4096向上取整
    if(size > 1024)
    {
        uint32_t page_cnt = DIV_ROUND_UP(size + sizeof(struct arena), PG_SIZE);

        a = malloc_page(pf, page_cnt);
        if (a != NULL)
        {
            memset(a, 0, page_cnt * PG_SIZE);

            a->desc = NULL;
            a->cnt = page_cnt;
            a->large = true;
            lock_release(&mem_pool->lock);
            return (void *)(a + 1);
        }
        else
        {
            lock_release(&mem_pool->lock);
            return NULL;
        }
    }

    // 小内存的分配情况
    else
    {
        int desc_idx = 0;

        // 找到使用哪种规格的内存描述符
        for (; desc_idx < DESC_CNT; ++desc_idx)
        {
            if(size <= descs[desc_idx].block_size)
                break;
        }

        // 该内存块描述符中的arena为空时，首先为其分配arena
        // 然后会将该arena根据其描述符中的规格大小进行内存块的划分
        // 划分的过程主要是通过arena2block这个函数对arena中的地址进行转换，使其指向下一个内存块所在的首地址，最后添加到链表中
        if (list_empty(&descs[desc_idx].free_list))
        {
            a = malloc_page(pf, 1);
            if(a == NULL)
            {
                lock_release(&mem_pool->lock);
                return NULL;
            }

            memset(a, 0, PG_SIZE);

            a->desc = &descs[desc_idx];
            a->cnt = descs[desc_idx].blocks_per_arena;
            a->large = false;

            enum intr_status old_status = intr_disable();

            uint32_t block_idx = 0;

            for (; block_idx < descs[desc_idx].blocks_per_arena; ++block_idx)
            {
                b = arena2block(a, block_idx);
                ASSERT(!elem_find(&a->desc->free_list, &b->free_elem));
                list_append(&a->desc->free_list, &b->free_elem);

            }
            intr_set_status(old_status);
        }

        // 有空闲的内存块之后找到该内存块相对于arena的偏移地址，该地址便为分配到的空间的首地址
        b = elem2entry(struct mem_block, free_elem, list_pop(&descs[desc_idx].free_list));
        memset(b, 0, descs[desc_idx].block_size);
        a = block2arena(b);
        a->cnt--;
        lock_release(&mem_pool->lock);
        return (void *)b;    
    } 
}

该函数整体的执行流程如下

首先判断是内核还是用户进程需要分配空间，确定在相应的内存池中进行分配

申请的空间大于1024byte的情况，会分配申请内存大小+元信息大小对4096向上取整的页框数，比如说申请的内存大小为4092byte，元信息的大小为12byte，所以总共需要5004byte，也就是说需要2个页框，最后返回的地址要跳过元信息。

对于小于1024byte的情况，从7种规格的arena中找个分配颗粒与所需大小最接近的arena，比如33byte，就会使用64byte的arena。申请63byte空间，同样会使用64byte的arena。也就是说，即使只需要33byte的空间，实际分配的过程中，还是会占用64byte的内存空间。这种空间的浪费是无法避免的。下面看一下执行的结果

mark

在调用的过程中申请了两块内存空间，第一块空间的大小为33byte，第二块空间的大小为63byte，这两块空间都是使用64byte的arena，因为是第一次申请空间，所以首先会建立64byte的arena，也就是说这两块空间都会使用同一个页框，该页框的首地址为0xc0102000，首先需要跳过元信息的大小为0xc，所以第一块内存的地址就是0xc0102000+0xc， 第二块内存的地址是0xc0102000 + 0xc + 0x40。

底层的封装已经封装好了，接下来就要通过系统调用，提供对外的接口啦

1
2
3
4
void *malloc(uint32_t size)
{
    return (void*)_syscall1(SYS_MALLOC, size);
}

系统调用的原理就是根据传递的子功能号去调用相应的中断处理例程，这里的中断处理例程就是上面的sys_malloc这个函数啦。

实现free

有了申请内存之后就得有内存的释放，毕竟有借得有换。内存释放的过程其实并不神秘，想想之前申请内存的步骤

  1. 在虚拟内存池中分配内存地址，它的实质也就是在bitmap中将相应的位置1。
  2. 在物理内存池中分配内存地址，这两步说的内存都是以页为单位的，他们是通过bitmap进行管理的。这里同样只需要在物理内存池的bitmap中将相应的位置1
  3. 建立虚拟页与物理页之间的映射关系。

所以咯，内存的释放只需要将相应的bitmap中的相应位置0即可，然后在页表中去掉对虚拟地址的映射

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
// 将物理地址pg_phy_addr对应的页回收
void pfree(uint32_t pg_phy_addr)
{
    struct pool *mem_pool;
    uint32_t bit_idx = 0;

    if(pg_phy_addr >= user_pool.phy_addr_start)
    {
        mem_pool = &user_pool;
        bit_idx = (pg_phy_addr - user_pool.phy_addr_start) / PG_SIZE;
    }
    else
    {
        mem_pool = &kernel_pool;
        bit_idx = (pg_phy_addr - kernel_pool.phy_addr_start) / PG_SIZE;
    }

    bitmap_set(&mem_pool->pool_bitmap, bit_idx , 0);
}

// 去掉页表中虚拟地址的映射，只需要将pte中的P位置0
static void page_table_pte_remove(uint32_t vaddr)
{
    uint32_t *pte = pte_ptr(vaddr);
    *pte &= ~PG_P_1;
    asm volatile("invlpg %0" :: "m" (vaddr):"memory");
}

// 回收虚拟内存
static void vaddr_remove(enum pool_flags pf, void *_vaddr, uint32_t pg_cnt)
{
    uint32_t bit_idx_start = 0;
    uint32_t vaddr = (uint32_t)_vaddr;
    uint32_t cnt = 0;

    if (pf == PF_KERNEL)
    {
        bit_idx_start = (vaddr - kernel_vaddr.vaddr_start) / PG_SIZE;
        while (cnt < pg_cnt)
        {
            bitmap_set(&kernel_vaddr.vaddr_bitmap, bit_idx_start + cnt++, 0);
        }
    }
    else
    {
        task_struct *cur_thread = running_thread();
        bit_idx_start = (vaddr - cur_thread->userprog_vaddr.vaddr_start) / PG_SIZE;
        while (cnt < pg_cnt)
        {
            bitmap_set(&cur_thread->userprog_vaddr.vaddr_bitmap, bit_idx_start + cnt++, 0);
        }
    }
}

上面这些过程是对整页的内存进行释放操作，对于小块内存的回收则更加简单了，只需要将这个内存块加入到该内存块对应的arena的空闲链表中即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
/* 回收内存ptr */
void sys_free(void* ptr) 
{
    ASSERT(ptr != NULL);
    if (ptr != NULL) 
    {
        enum pool_flags PF;
        struct pool* mem_pool;

        /* 判断是线程还是进程 */
        if (running_thread()->pgdir == NULL) 
        {
            ASSERT((uint32_t)ptr >= K_HEAP_START);
            PF = PF_KERNEL;
            mem_pool = &kernel_pool;
        }
        else 
        { 
            PF = PF_USER;
             mem_pool = &user_pool;
        }

        lock_acquire(&mem_pool->lock);
        struct mem_block* b = ptr;
        struct arena* a = block2arena(b);      // 把mem_block转换成arena,获取元信息  
        ASSERT(a->large == 0 || a->large == 1);
        if (a->desc == NULL && a->large == true) 
        { // 大于1024的内存
            mfree_page(PF, a, a->cnt); 
        } 
        else 
        {               
            // 小于等于1024的内存块
            /* 先将内存块回收到free_list */
            list_append(&a->desc->free_list, &b->free_elem);
     
            /* 再判断此arena中的内存块是否都是空闲,如果是就释放arena */
            if (++a->cnt == a->desc->blocks_per_arena) 
            {
                uint32_t block_idx;
                for (block_idx = 0; block_idx < a->desc->blocks_per_arena; block_idx++  ) 
                {
                    struct mem_block*  b = arena2block(a, block_idx);
                    ASSERT(elem_find(&a->desc->free_list, &b->free_elem));
                    list_remove(&b->free_elem);
                }
                mfree_page(PF, a, 1);
            }
        }
        lock_release(&mem_pool->lock);
   }  
}

对于大块的内存，就如之前所说，释放其对应的页。对于小块内存，直接加入其对应的空闲链表中，如果这一整页的内存块都是空闲的，释放该页。

提供系统调用free

1
2
3
4
void free(void *ptr)
{
    _syscall1(SYS_FREE, ptr);
}