ptmalloc代码浅析3

最新推荐文章于 2022-04-02 22:54:53 发布

原创最新推荐文章于 2022-04-02 22:54:53 发布 · 1.7k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#exchange #null #each

内存管理同时被 2 个专栏收录

6 篇文章

订阅专栏

glibc源码阅读

4 篇文章

订阅专栏

本文详细解析了malloc_consolidate函数的工作原理：该函数通过合并fastbins中的相邻空闲chunk，并将其统一放置到unsorted bin中，以提高内存分配效率。文章深入探讨了其内部实现细节，包括如何遍历fastbins、合并chunk以及更新unsorted bin的过程。

malloc_consolidate函数是将fast bins中所有链表中相邻空闲chunk合并之后放入到unsorted chunk链表中。
注意fd/bk是用来获取前后空闲chunk的指针域，而要获取前后相邻chunk，需要借助宏next_chunk/prev_chunk。

 /*
    If max_fast is 0, we know that av hasn't
    yet been initialized, in which case do so below
  */


    if (get_max_fast () != 0) 
    {
        clear_fastchunks(av);


        unsorted_bin = unsorted_chunks(av);


        /*
        Remove each chunk from fast bin and consolidate it, placing it
        then in unsorted bin. Among other reasons for doing this,
        placing in unsorted bin avoids needing to calculate actual bins
        until malloc is sure that chunks aren't immediately going to be
        reused anyway.
        */


        maxfb = &fastbin (av, NFASTBINS - 1);
        fb = &fastbin (av, 0);
        do {
            p = atomic_exchange_acq (fb, 0);
            if (p != 0) {
                do {
                    check_inuse_chunk(av, p);
                    nextp = p->fd;


                    /* Slightly streamlined version of consolidation code in free() */
                    size = p->size & ~(PREV_INUSE|NON_MAIN_ARENA);
                    nextchunk = chunk_at_offset(p, size);
                    nextsize = chunksize(nextchunk);
                    // 前一个相邻chunk空闲，unlink，然后合并
                    if (!prev_inuse(p)) {
                        prevsize = p->prev_size;
                        size += prevsize;
                        p = chunk_at_offset(p, -((long) prevsize));
                        unlink(p, bck, fwd);
                    }


                    if (nextchunk != av->top) {
                        nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
                         
                        if (!nextinuse) {  // 后一个相邻chunk空闲，unlink，然后合并
                            size += nextsize;
                            unlink(nextchunk, bck, fwd);
                        } else
                        clear_inuse_bit_at_offset(nextchunk, 0);


                        first_unsorted = unsorted_bin->fd;
                        unsorted_bin->fd = p;
                        first_unsorted->bk = p;


                        if (!in_smallbin_range (size)) {
                            p->fd_nextsize = NULL;
                            p->bk_nextsize = NULL;
                        }
                        // 设置相关的头和尾标志位，然后link到unsorted bin
                        set_head(p, size | PREV_INUSE);
                        p->bk = unsorted_bin;
                        p->fd = first_unsorted;
                        set_foot(p, size);
                    }


                    else {
                        size += nextsize;
                        set_head(p, size | PREV_INUSE);
                        av->top = p;
                    }


                } while ( (p = nextp) != 0);


            }
        } while (fb++ != maxfb);
    }
    else {
        malloc_init_state(av);
        check_malloc_state(av);
    }