jemalloc源码解析-核心架构

struct arena_s {
    ...
    /* 当前arena管理的dirty chunks */
    arena_chunk_tree_t  chunks_dirty;
    /* arena缓存的最近释放的chunk, 每个arena一个spare chunk */
    arena_chunk_t       *spare;
    /* 当前arena中正在使用的page数. */
    size_t          nactive;
    /*当前arana中未使用的dirty page数*/
    size_t          ndirty;
    /* 需要清理的page的大概数目 */
    size_t          npurgatory;
 
 
    /* 当前arena可获得的runs构成的红黑树， */
    /* 红黑树按大小/地址顺序进行排列。 分配run时采用first-best-fit策略*/
    arena_avail_tree_t  runs_avail;
    /* bins储存不同大小size的内存区域 */
    arena_bin_t     bins[NBINS];
};

struct arena_bin_s {
    /* 作用域当前数据结构的锁*/
    malloc_mutex_t  lock;
    /* 当前正在使用的run */
    arena_run_t *runcur;
    /* 可用的run构成的红黑树， 主要用于runcur用完的时候。在查找可用run时， 
     * 为保证对象紧凑分布，尽量从低地址开始查找，减少快要空闲的chunk的数量。
     */
    arena_run_tree_t runs;
    /* 用于bin统计 */
    malloc_bin_stats_t stats;
};

struct arena_run_s {
    /* 所属的bin */
    arena_bin_t *bin;
    /*下一块可分配区域的索引 */
    uint32_t    nextind;
    /* 当前run中空闲块数目. */
    unsigned    nfree;
};

* Each run has the following layout:
*
*               /--------------------\
*               | arena_run_t header |
*               | ...                |
* bitmap_offset | bitmap             |
*               | ...                |
*   ctx0_offset | ctx map            |
*               | ...                |
*               |--------------------|
*               | redzone            |
*   reg0_offset | region 0           |
*               | redzone            |
*               |--------------------| \
*               | redzone            | |
*               | region 1           |  > reg_interval
*               | redzone            | /
*               |--------------------|
*               | ...                |
*               | ...                |
*               | ...                |
*               |--------------------|
*               | redzone            |
*               | region nregs-1     |
*               | redzone            |
*               |--------------------|
*               | alignment pad?     |
*               \--------------------/

/* Arena chunk header. */
struct arena_chunk_s {
    /* 管理当前chunk的Arena */
    arena_t         *arena;
    /* 链接到所属arena的dirty chunks树的节点*/
    rb_node(arena_chunk_t)  dirty_link;
    /* 脏页数 */
    size_t          ndirty;
    /* 空闲run数 Number of available runs. */
    size_t          nruns_avail;
    /* 相邻的run数，清理的时候可以合并的run */
    size_t          nruns_adjac;
    /* 用来跟踪chunk使用状况的关于page的map, 它的下标对应于run在chunk中的位置，通过加map_bias不跟踪chunk 头部的信息
     * 通过加map_bias不跟踪chunk 头部的信息
     */
    arena_chunk_map_t   map[1]; /* Dynamically sized. */
};

static arena_run_t *
arena_bin_runs_first(arena_bin_t *bin)
{
    /*通过bin的runs得到关于该run的描述信息mapelm*/
    arena_chunk_map_t *mapelm = arena_run_tree_first(&bin->runs);
    if (mapelm != NULL) {
        arena_chunk_t *chunk;
        size_t pageind;
        arena_run_t *run;
        /*通过红操作定位到对应的chunk*/
        chunk = (arena_chunk_t *)CHUNK_ADDR2BASE(mapelm);
        /*通过地址计算得到run对应的pageid*/
        pageind = ((((uintptr_t)mapelm - (uintptr_t)chunk->map) /
            sizeof(arena_chunk_map_t))) + map_bias;
        /*通过地址运算得到对应的run*/
        run = (arena_run_t *)((uintptr_t)chunk + (uintptr_t)((pageind -
            arena_mapbits_small_runind_get(chunk, pageind)) <<
            LG_PAGE));
        return (run);
    }
    return (NULL);
}

JEMALLOC_ALWAYS_INLINE void *
arena_malloc(arena_t *arena, size_t size, bool zero, bool try_tcache)
{
    tcache_t *tcache;
    assert(size != 0);
    assert(size <= arena_maxclass);
    /*分配small object*/
    if (size <= SMALL_MAXCLASS) {
        if (try_tcache && (tcache = tcache_get(true)) != NULL)
            return (tcache_alloc_small(tcache, size, zero));
        else {
            return (arena_malloc_small(choose_arena(arena), size,
                zero));
        }
    } else {
        /*
         * Initialize tcache after checking size in order to avoid
         * infinite recursion during tcache initialization.
         */
        /*分配large object*/
        if (try_tcache && size <= tcache_maxclass && (tcache =
            tcache_get(true)) != NULL)
            return (tcache_alloc_large(tcache, size, zero));
        else {
            return (arena_malloc_large(choose_arena(arena), size,
                zero));
        }
    }
}

struct tcache_bin_s {
    ...
    unsigned    ncached;    /* 缓存对象数目. */
    void        **avail;    /*缓存对象栈. */
};
struct tcache_s {
    ...
    arena_t     *arena;     /* 线程对应arena. */
    unsigned    ev_cnt;     /* GC事件数 */
    unsigned    next_gc_bin;    /* 下一个需要GC的bin. */
    tcache_bin_t    tbins[1];   /* 表示不同size的缓存 */
};