• ptmalloc源码分析 - free()函数的实现（10）

    目录

    一、步骤1-标记MMAP分配的使用munmap_chunk释放

    二、步骤2-释放的是小块内存，则chunk放入fastbin

    三、步骤3-如果不是MMAP分配，则释放到unsorted bins

    四、步骤4-如果nextchunk 就是Top chunk，则直接扩容Top chunk

    五、步骤5-如果释放的内存比较大，则需要对chunk进行一些缩容处理

    1. malloc_consolidate整理fastbin

    2. 主分配区systrim缩容Top chunk

    3. 非主分配区heap_trim缩容heap区域

    六、步骤6-MMAP方式分配的，则直接执行munmap_chunk

    本章节主要讲解free函数的实现。free函数的入口函数：__libc_free，该入口函数也在malloc.c的文件中。

    前几章节我们讲了malloc的具体实现，基本了解了ptmalloc是通过fast bins、unsorted bin、small bin、large bin 和 Top chunk等来管理释放后的内存的。free函数的基本步骤有6步：

    1. 步骤1：如果是MMAP分配的，则调用munmap_chunk进行chunk的释放操作

    2. 步骤2：如果释放的内存小于get_max_fast（），则释放的chunk放入fastbin

    3. 步骤3：如果不是MMAP分配，则释放的时候释放到unsorted bin

    4. 步骤四：如果释放的chunk的nextchunk 就是Top chunk，则直接扩容Top chunk

    5. 步骤五：如果释放的内存比较大，则需要对chunk进行一些缩容处理

    6. 步骤6：MMAP方式分配的，则直接执行munmap_chunk

    一、步骤1-标记MMAP分配的使用munmap_chunk释放

    如果是MMAP分配的，则调用munmap_chunk进行chunk的释放操作。

    mchunk_size字段中的标记位IS_MMAPPED，如果是这个标记的说明是MMAP方式分配。

    1. /**
    2.  * free()函数的入口
    3.  */
    4. void
    5. __libc_free (void *mem)
    6. {
    7.   mstate ar_ptr; //指针地址
    8.   mchunkptr p;   //chunk地址                       /* chunk corresponding to mem */
    9.  
    10.   void (*hook) (void *, const void *)
    11.     = atomic_forced_read (__free_hook);
    12.   if (__builtin_expect (hook != NULL, 0))
    13.     {
    14.       (*hook)(mem, RETURN_ADDRESS (0));
    15.       return;
    16.     }
    17.  
    18.   /* 内存指针地址为0，则直接返回 */
    19.   if (mem == 0)                              /* free(0) has no effect */
    20.     return;
    21.  
    22.   p = mem2chunk (mem); //通过内存地址获取chunk地址
    23.  
    24.   /* 步骤1：如果是MMAP分配的，则调用munmap_chunk进行chunk的释放操作
    25.    * 获取状态值，是否是MMAP分配的 mchunk_size字段中的标记位 IS_MMAPPED */
    26.   if (chunk_is_mmapped (p))                       /* release mmapped memory. */
    27.     {
    28.       /* See if the dynamic brk/mmap threshold needs adjusting.
    29. 	 Dumped fake mmapped chunks do not affect the threshold.  */
    30.       if (!mp_.no_dyn_threshold
    31.           && chunksize_nomask (p) > mp_.mmap_threshold
    32.           && chunksize_nomask (p) <= DEFAULT_MMAP_THRESHOLD_MAX
    33. 	  && !DUMPED_MAIN_ARENA_CHUNK (p))
    34.         {
    35.           mp_.mmap_threshold = chunksize (p);
    36.           mp_.trim_threshold = 2 * mp_.mmap_threshold;
    37.           LIBC_PROBE (memory_mallopt_free_dyn_thresholds, 2,
    38.                       mp_.mmap_threshold, mp_.trim_threshold);
    39.         }
    40.       munmap_chunk (p); //清空MMAP的chunk结构
    41.       return;
    42.     }
    43.  
    44.   MAYBE_INIT_TCACHE ();
    45.  
    46.   ar_ptr = arena_for_chunk (p); //获取分区地址
    47.   _int_free (ar_ptr, p, 0); //调用free核心函数
    48. }

    在malloc的时候，如果遇到try map方式实现MMAP方式的分配，都会有此标记。在通过Try mmap的方法中，会在分配chunk的时候进行对齐操作，并且对齐后因为前置会有空余字节，则会生成一个chunk，所以在释放free的时候也需要计算前一个chunk。

    通过调用__munmap函数，最终来释放MMAP分配的内存。

    1. /**
    2.  * MMAP 清除chunk数据
    3.  */
    4. static void
    5. munmap_chunk (mchunkptr p)
    6. {
    7.   size_t pagesize = GLRO (dl_pagesize);
    8.   INTERNAL_SIZE_T size = chunksize (p); //获取chunk的size
    9.  
    10.   assert (chunk_is_mmapped (p));
    11.  
    12.   /* Do nothing if the chunk is a faked mmapped chunk in the dumped
    13.      main arena.  We never free this memory.  */
    14.   /* 如果是伪造的主分区的一个MMAP的chunk，则不做任何操作 */
    15.   if (DUMPED_MAIN_ARENA_CHUNK (p))
    16.     return;
    17.  
    18.   /* 在通过Try mmap的方法中，会在分配chunk的时候进行对齐操作，并且对齐后因为前置会有空余字节，则会生成一个chunk，free的时候要计算此chunk*/
    19.   uintptr_t mem = (uintptr_t) chunk2mem (p); //获取内存地址
    20.   uintptr_t block = (uintptr_t) p - prev_size (p); //指向前一个chunk的地址
    21.   size_t total_size = prev_size (p) + size; //前一个空闲的大小
    22.   /* Unfortunately we have to do the compilers job by hand here.  Normally
    23.      we would test BLOCK and TOTAL-SIZE separately for compliance with the
    24.      page size.  But gcc does not recognize the optimization possibility
    25.      (in the moment at least) so we combine the two values into one before
    26.      the bit test.  */
    27.   if (__glibc_unlikely ((block | total_size) & (pagesize - 1)) != 0
    28.       || __glibc_unlikely (!powerof2 (mem & (pagesize - 1))))
    29.     malloc_printerr ("munmap_chunk(): invalid pointer");
    30.  
    31.   atomic_decrement (&mp_.n_mmaps);
    32.   atomic_add (&mp_.mmapped_mem, -total_size);
    33.  
    34.   /* If munmap failed the process virtual memory address space is in a
    35.      bad shape.  Just leave the block hanging around, the process will
    36.      terminate shortly anyway since not much can be done.  */
    37.   __munmap ((char *) block, total_size); //释放MUNMAP，包含当前MMAP的chunk，以及对齐前置的chunk
    38. }

    二、步骤2-释放的是小块内存，则chunk放入fastbin

    这里面有几个关键步骤：

    • 首选，需要判断释放的内存小于get_max_fast（）
    • 通过free_perturb对当前内存块进行清空操作，并通过函数atomic_store_relaxed原子操作设置fastbin的空闲/繁忙状态标记
    • 通过fastbin_index找到数组下标，fastbin函数找到对应的切入点可操作的chunk
    • 如果是单线程则直接调整单向链表
    • 如果是多线程，则通过catomic_compare_and_exchange_val_rel函数，原子操作fastbin链表
    1. /**
    2.  * free核心函数
    3.  */
    4. static void
    5. _int_free (mstate av, mchunkptr p, int have_lock)
    6. {
    7.   INTERNAL_SIZE_T size;        /* its size */
    8.   mfastbinptr *fb;             /* associated fastbin */
    9.   mchunkptr nextchunk;         /* next contiguous chunk */
    10.   INTERNAL_SIZE_T nextsize;    /* its size */
    11.   int nextinuse;               /* true if nextchunk is used */
    12.   INTERNAL_SIZE_T prevsize;    /* size of previous contiguous chunk */
    13.   mchunkptr bck;               /* misc temp for linking */
    14.   mchunkptr fwd;               /* misc temp for linking */
    15.  
    16.   size = chunksize (p); //获取chunk的size
    17.  
    18. .........
    19.  
    20.  /**
    21.    * 步骤2：如果释放的内存小于get_max_fast（），则释放的chunk放入fastbin
    22.    */
    23.   if ((unsigned long)(size) <= (unsigned long)(get_max_fast ())
    24.  
    25. #if TRIM_FASTBINS
    26.       /*
    27. 	If TRIM_FASTBINS set, don't place chunks
    28. 	bordering top into fastbins
    29.       */
    30.       && (chunk_at_offset(p, size) != av->top)
    31. #endif
    32.       ) {
    33.  
    34.     if (__builtin_expect (chunksize_nomask (chunk_at_offset (p, size))
    35. 			  <= 2 * SIZE_SZ, 0)
    36. 	|| __builtin_expect (chunksize (chunk_at_offset (p, size))
    37. 			     >= av->system_mem, 0))
    38.       {
    39. 	bool fail = true;
    40. 	/* We might not have a lock at this point and concurrent modifications
    41. 	   of system_mem might result in a false positive.  Redo the test after
    42. 	   getting the lock.  */
    43. 	if (!have_lock)
    44. 	  {
    45. 	    __libc_lock_lock (av->mutex);
    46. 	    fail = (chunksize_nomask (chunk_at_offset (p, size)) <= 2 * SIZE_SZ
    47. 		    || chunksize (chunk_at_offset (p, size)) >= av->system_mem);
    48. 	    __libc_lock_unlock (av->mutex);
    49. 	  }
    50.  
    51. 	if (fail)
    52. 	  malloc_printerr ("free(): invalid next size (fast)");
    53.       }
    54.  
    55.     /* 对当前内存块进行清空操作，设置的大小等于chunk的size 减去2个SIZE_SZ的空间 */
    56.     free_perturb (chunk2mem(p), size - 2 * SIZE_SZ);
    57.  
    58.     atomic_store_relaxed (&av->have_fastchunks, true); //设置分配区的标志位表示fastbin有空闲chunk，原子操作
    59.     unsigned int idx = fastbin_index(size); //获取fastbin 数组下标
    60.     fb = &fastbin (av, idx); //找到对应的fb
    61.  
    62.     /* Atomically link P to its fastbin: P->FD = *FB; *FB = P;  */
    63.     mchunkptr old = *fb, old2;
    64.  
    65.     /* 如果是单线程处理，则直接操作 */
    66.     if (SINGLE_THREAD_P)
    67.       {
    68. 	/* Check that the top of the bin is not the record we are going to
    69. 	   add (i.e., double free).  */
    70. 	if (__builtin_expect (old == p, 0))
    71. 	  malloc_printerr ("double free or corruption (fasttop)");
    72. 	p->fd = old;
    73. 	*fb = p;
    74.       }
    75.     else
    76.       do
    77. 	{
    78. 	  /* Check that the top of the bin is not the record we are going to
    79. 	     add (i.e., double free).  */
    80.       /* 如果是多线程的，则需要进行原子操作 */
    81. 	  if (__builtin_expect (old == p, 0))
    82. 	    malloc_printerr ("double free or corruption (fasttop)");
    83. 	  p->fd = old2 = old;
    84. 	}
    85.       //catomic_compare_and_exchange_val_rel 原子操作 如果*MEM等于OLDVAL，则将*MEM存储为NEWVAL，返回OLDVAL
    86.       while ((old = catomic_compare_and_exchange_val_rel (fb, p, old2))
    87. 	     != old2);
    88.  
    89.     /* Check that size of fastbin chunk at the top is the same as
    90.        size of the chunk that we are adding.  We can dereference OLD
    91.        only if we have the lock, otherwise it might have already been
    92.        allocated again.  */
    93.     if (have_lock && old != NULL
    94. 	&& __builtin_expect (fastbin_index (chunksize (old)) != idx, 0))
    95.       malloc_printerr ("invalid fastbin entry (free)");
    96.   }

    三、步骤3-如果不是MMAP分配，则释放到unsorted bins

     如果不是MMAP分配，则直接放入unsorted bins，未整理的bins上。那什么时候放入small bin或者large bin上呢，是在malloc分配的时候，会去循环遍历unsorted bin的双向链表上每一个未存储的chunk，并对未整理的chunk进行合并、整理操作。

    • 如果不是MMAP分配，则释放的时候释放到unsorted bins。当malloc分配的时候，会去遍历unsorted bins，寻找合适的chunk。并对未整理的chunk进行合并、整理操作。

    • 如果物理相邻的前一个chunk也是空闲状态，则合并前一个chunk。并通过unlink_chunk函数，解除前一个chunk在bins上的链表关系

    • 如果物理相邻的后一个chunk不为Top chunk，则需要判断使用状态，如果也是空闲状态，则合并；如果是使用状态，则清除后一个chunk的PREV_INUSE状态

    • 最后，通过unsorted_chunks函数，获取unsorted的bins对象，并将整理后的chunk放入到未整理的bins上

    1.  /**
    2.    * 步骤3：如果不是MMAP分配，则释放的时候释放到unsorted bins
    3.    */
    4.   else if (!chunk_is_mmapped(p)) {
    5.  
    6.     /* If we're single-threaded, don't lock the arena.  */
    7.     if (SINGLE_THREAD_P)
    8.       have_lock = true;
    9.  
    10.     if (!have_lock)
    11.       __libc_lock_lock (av->mutex);
    12.  
    13.     nextchunk = chunk_at_offset(p, size); //获取下一个chunk
    14.  
    15.    ............
    16.     nextsize = chunksize(nextchunk); //下一个chunk的size
    17.     if (__builtin_expect (chunksize_nomask (nextchunk) <= 2 * SIZE_SZ, 0)
    18. 	|| __builtin_expect (nextsize >= av->system_mem, 0))
    19.       malloc_printerr ("free(): invalid next size (normal)");
    20.  
    21.     /* 对当前内存块进行清空操作，设置的大小等于chunk的size 减去2个SIZE_SZ的空间 */
    22.     free_perturb (chunk2mem(p), size - 2 * SIZE_SZ);
    23.  
    24.     /* consolidate backward */
    25.     /* 如果前一个chunk也是空闲的，则要合并这个chunk */
    26.     if (!prev_inuse(p)) {
    27.       prevsize = prev_size (p); //获取前一个chunk的 size
    28.       size += prevsize; //
    29.       p = chunk_at_offset(p, -((long) prevsize)); //p值指向前一个chunk地址
    30.       if (__glibc_unlikely (chunksize(p) != prevsize))
    31.         malloc_printerr ("corrupted size vs. prev_size while consolidating");
    32.       /* 解除这个chunk在bins上的关系,为何要解除呢？因为前面这个chunk是空闲的基本就挂载在bins上 */
    33.       /* 这里的两个chunk是需要进行合并的 */
    34.       unlink_chunk (av, p);
    35.     }
    36.  
    37.     /* 如果nextchunk 不是 Topchunk */
    38.     if (nextchunk != av->top) {
    39. 		  /* get and clear inuse bit */
    40. 		  nextinuse = inuse_bit_at_offset(nextchunk, nextsize); //获取下一个chunk的使用状态
    41.  
    42. 		  /* consolidate forward */
    43. 		  if (!nextinuse) { //如果空闲的，则进行内存合并
    44. 			unlink_chunk (av, nextchunk); //解除下一个chunk
    45. 			size += nextsize; //内存合并，扩大内存size
    46. 		  } else
    47. 		 clear_inuse_bit_at_offset(nextchunk, 0); //如果非空闲，则清除nextchunk的PREV_INUSE状态
    48.  
    49.       /*
    50. 	Place the chunk in unsorted chunk list. Chunks are
    51. 	not placed into regular bins until after they have
    52. 	been given one chance to be used in malloc.
    53.       */
    54.  
    55. 		  bck = unsorted_chunks(av); //获取unsorted bins的对象
    56. 		  fwd = bck->fd;
    57. 		  if (__glibc_unlikely (fwd->bk != bck))
    58. 	      malloc_printerr ("free(): corrupted unsorted chunks");
    59. 		  /* 放入链表中 */
    60. 		  p->fd = fwd;
    61. 		  p->bk = bck;
    62. 		  /* 如果不为small bin，则设置fd_nextsize/bk_nextsize值*/
    63. 		  if (!in_smallbin_range(size)) {
    64. 			  p->fd_nextsize = NULL;
    65. 			  p->bk_nextsize = NULL;
    66. 		  }
    67. 		  /* 调整前后bck和fwd的指向 */
    68. 		  bck->fd = p;
    69. 		  fwd->bk = p;
    70.  
    71. 		  set_head(p, size | PREV_INUSE); //设置头部
    72. 		  set_foot(p, size); //设置脚部
    73.  
    74. 		  check_free_chunk(av, p);

    四、步骤4-如果nextchunk 就是Top chunk，则直接扩容Top chunk

    接着上一个步骤，如果nextchunk就是Topchunk，意味着当前要释放的chunk跟Top chunk物理地址相邻，则释放的时候直接释放到Top chunk上即可（调整Top chunk的指针即可）

    1.    /* 步骤4：如果nextchunk 就是Top chunk，则直接扩容Top chunk */
    2.   } else {
    3.       size += nextsize;
    4.       set_head(p, size | PREV_INUSE);
    5.       av->top = p;
    6.       check_chunk(av, p);
    7.     }

    五、步骤5-如果释放的内存比较大，则需要对chunk进行一些缩容处理

    如果释放的内存比较大，则需要对chunk进行一些缩容处理：

    • 释放的内存size需要大于FASTBIN_CONSOLIDATION_THRESHOLD（64k），则尝试一次缩容的操作，缩容大小mp_.top_pad（128k）
    • 如果fastbin中有数据，则调用malloc_consolidate进行整理，将fastbin上的数据进行合并整理到unsorted bin上。

    • 如果是主分配区，如果是主分配区，并且主分配区的top chunk大于一定的值，就通过systrim缩小top chunk

    • 如果是非主分配区，就获得top chunk对应的非主分配区的heap_info指针，调用heap_trim尝试缩小该heap

    1.  /**
    2.      * 步骤5：如果释放的内存比较大，则需要对chunk进行一些缩容处理
    3.      * FASTBIN_CONSOLIDATION_THRESHOLD = 65536UL
    4.      * mp_.top_pad = 128k = 131072
    5.      * 1. size需要大于FASTBIN_CONSOLIDATION_THRESHOLD
    6.      * 2. 如果fastbin中有数据，则调用malloc_consolidate进行整理
    7.      * 3. 如果是主分配区，如果是主分配区，并且主分配区的top chunk大于一定的值，就通过systrim缩小top chunk
    8.      * 4. 如果是非主分配区，就获得top chunk对应的非主分配区的heap_info指针，调用heap_trim尝试缩小该heap
    9.      */
    10.     if ((unsigned long)(size) >= FASTBIN_CONSOLIDATION_THRESHOLD) {
    11.  
    12.       /* 原子操作，获取是否fastbin中，有fastbin的chunk*/
    13.       if (atomic_load_relaxed (&av->have_fastchunks))
    14.     	  malloc_consolidate(av); //对fastbin进行整理合并操作，整理后的放入unsorted bin
    15.  
    16.       /* 主分配区操作：systrim缩小top chunk*/
    17.       if (av == &main_arena) {
    18. 		#ifndef MORECORE_CANNOT_TRIM
    19. 			if ((unsigned long)(chunksize(av->top)) >=
    20. 				(unsigned long)(mp_.trim_threshold))
    21. 			  systrim(mp_.top_pad, av);
    22. 		#endif
    23. 	  /* 非主分配区操作：调用heap_trim尝试缩小该heap*/
    24.       } else {
    25. 		/* Always try heap_trim(), even if the top chunk is not
    26. 		   large, because the corresponding heap might go away.  */
    27. 		heap_info *heap = heap_for_ptr(top(av));
    28.  
    29. 		assert(heap->ar_ptr == av);
    30. 		heap_trim(heap, mp_.top_pad); //缩小
    31.       }
    32.     }
    33.  
    34.     if (!have_lock)
    35.       __libc_lock_unlock (av->mutex);
    36.   }

    1. malloc_consolidate整理fastbin

    对fastbin进行整理合并操作，整理后的放入unsorted bin。 

    循环遍历fastbin，并检查物理相邻前一个chunk的使用状态，如果前一个chunk空闲中，则合并。

    然后检查物理相邻的后一个chunk的使用状态，如果后一个chunk空闲中，则合并。如果后一个chunk就是Top chunk，则回收到Top chunk上去。如果后一个chunk不是Top chunk，则回收到unsorted bin上去。

    1. static void malloc_consolidate(mstate av)
    2. {
    3.   mfastbinptr*    fb;                 /* current fastbin being consolidated */
    4.   mfastbinptr*    maxfb;              /* last fastbin (for loop control) */
    5.   mchunkptr       p;                  /* current chunk being consolidated */
    6.   mchunkptr       nextp;              /* next chunk to consolidate */
    7.   mchunkptr       unsorted_bin;       /* bin header */
    8.   mchunkptr       first_unsorted;     /* chunk to link to */
    9.  
    10.   /* These have same use as in free() */
    11.   mchunkptr       nextchunk;
    12.   INTERNAL_SIZE_T size;
    13.   INTERNAL_SIZE_T nextsize;
    14.   INTERNAL_SIZE_T prevsize;
    15.   int             nextinuse;
    16.  
    17.   atomic_store_relaxed (&av->have_fastchunks, false); //直接设置标记，没有fast chunk
    18.  
    19.   /* 获取unsorted bin */
    20.   unsorted_bin = unsorted_chunks(av);
    21.  
    22.   /*
    23.     Remove each chunk from fast bin and consolidate it, placing it
    24.     then in unsorted bin. Among other reasons for doing this,
    25.     placing in unsorted bin avoids needing to calculate actual bins
    26.     until malloc is sure that chunks aren't immediately going to be
    27.     reused anyway.
    28.   */
    29.  
    30.   maxfb = &fastbin (av, NFASTBINS - 1); //获取最后一个fastbin
    31.   fb = &fastbin (av, 0); //获取当前的fastbin
    32.   do {
    33.     p = atomic_exchange_acq (fb, NULL);
    34.     if (p != 0) {
    35.       do {
    36. 	{
    37. 	  unsigned int idx = fastbin_index (chunksize (p));
    38. 	  if ((&fastbin (av, idx)) != fb)
    39. 	    malloc_printerr ("malloc_consolidate(): invalid chunk size");
    40. 	}
    41.  
    42. 	check_inuse_chunk(av, p); //检查chunk的使用状态
    43. 	nextp = p->fd; //用于遍历整个fastbin的单向链表
    44.  
    45. 	/* Slightly streamlined version of consolidation code in free() */
    46. 	size = chunksize (p); //chunk的size
    47. 	nextchunk = chunk_at_offset(p, size); //下一个chunk
    48. 	nextsize = chunksize(nextchunk); //下一个chunk的size
    49.  
    50. 	/* 如果前一个chunk空闲，则将前一个物理相邻的chunk进行合并 */
    51. 	if (!prev_inuse(p)) {
    52. 	  prevsize = prev_size (p);
    53. 	  size += prevsize;
    54. 	  p = chunk_at_offset(p, -((long) prevsize));
    55. 	  if (__glibc_unlikely (chunksize(p) != prevsize))
    56. 	    malloc_printerr ("corrupted size vs. prev_size in fastbins");
    57. 	  unlink_chunk (av, p);
    58. 	}
    59.  
    60. 	/* 如果nextchunk不是Top chunk*/
    61. 	if (nextchunk != av->top) {
    62. 	  nextinuse = inuse_bit_at_offset(nextchunk, nextsize); //获取nextchunk的使用状态
    63.  
    64. 	  /* 如果空闲中 */
    65. 	  if (!nextinuse) {
    66. 	    size += nextsize; //调整size大小，合并nextchunk
    67. 	    unlink_chunk (av, nextchunk);
    68. 	  } else
    69. 	    clear_inuse_bit_at_offset(nextchunk, 0); //如果非空闲，则清除nextchunk的PREV_INUSE状态
    70.  
    71. 	  /* 然后将chunk 放置到unsorted_bin 上去 */
    72. 	  first_unsorted = unsorted_bin->fd;
    73. 	  unsorted_bin->fd = p;
    74. 	  first_unsorted->bk = p;
    75.  
    76. 	  if (!in_smallbin_range (size)) {
    77. 	    p->fd_nextsize = NULL;
    78. 	    p->bk_nextsize = NULL;
    79. 	  }
    80.  
    81. 	  set_head(p, size | PREV_INUSE);
    82. 	  p->bk = unsorted_bin;
    83. 	  p->fd = first_unsorted;
    84. 	  set_foot(p, size);
    85. 	}
    86. 	/* 如果是Top chunk，则将当前chunk或者合并过的chunk，都设置到Top chunk，调整Top chunk指针地址*/
    87. 	else {
    88. 	  size += nextsize;
    89. 	  set_head(p, size | PREV_INUSE);
    90. 	  av->top = p;
    91. 	}
    92.  
    93.       } while ( (p = nextp) != 0);
    94.  
    95.     }
    96.   } while (fb++ != maxfb);
    97. }

    2. 主分配区systrim缩容Top chunk

    systrim函数主要用来缩容Top chunk。首先需要判断缩容的空间大小，如果缩容空间大小有限，则不进行缩容操作。缩容过程中，需要检查当前的指针地址是否跟 Topchunk的尾部地址是相等的，避免外部调用过sbrk 。MORECORE函数为brk函数的实现， MORECORE (-extra)即是缩容，指针往后推extra空间。通过老的Topchunk的尾部指针地址 减去 新的Topchunk的尾部指针地址，则是最终缩容的空间。

    1. static int
    2. systrim (size_t pad, mstate av)
    3. {
    4.   long top_size;         /* Amount of top-most memory */
    5.   long extra;            /* Amount to release */
    6.   long released;         /* Amount actually released */
    7.   char *current_brk;     /* address returned by pre-check sbrk call */
    8.   char *new_brk;         /* address returned by post-check sbrk call */
    9.   size_t pagesize;
    10.   long top_area;
    11.  
    12.   pagesize = GLRO (dl_pagesize);
    13.   top_size = chunksize (av->top); //获取Topchunk size
    14.  
    15.   /* 如果没什么空间了，则返回不缩小 */
    16.   top_area = top_size - MINSIZE - 1;
    17.   if (top_area <= pad)
    18.     return 0;
    19.  
    20.   /* Release in pagesize units and round down to the nearest page.  */
    21.   extra = ALIGN_DOWN(top_area - pad, pagesize); //经过对齐后的需要裁剪的量
    22.  
    23.   if (extra == 0)
    24.     return 0;
    25.  
    26.   /*
    27.      Only proceed if end of memory is where we last set it.
    28.      This avoids problems if there were foreign sbrk calls.
    29.    */
    30.    /* 检查当前的指针地址是否跟 Topchunk的尾部地址是相等的，避免外部调用过sbrk*/
    31.   current_brk = (char *) (MORECORE (0));
    32.   if (current_brk == (char *) (av->top) + top_size)
    33.     {
    34.       /*
    35.          Attempt to release memory. We ignore MORECORE return value,
    36.          and instead call again to find out where new end of memory is.
    37.          This avoids problems if first call releases less than we asked,
    38.          of if failure somehow altered brk value. (We could still
    39.          encounter problems if it altered brk in some very bad way,
    40.          but the only thing we can do is adjust anyway, which will cause
    41.          some downstream failure.)
    42.        */
    43.  
    44.       MORECORE (-extra); //extra为要缩容的空间
    45.       /* Call the `morecore' hook if necessary.  */
    46.       void (*hook) (void) = atomic_forced_read (__after_morecore_hook);
    47.       if (__builtin_expect (hook != NULL, 0))
    48.         (*hook)();
    49.       new_brk = (char *) (MORECORE (0)); //为新的Topchunk的尾部地址
    50.  
    51.       LIBC_PROBE (memory_sbrk_less, 2, new_brk, extra);
    52.  
    53.       if (new_brk != (char *) MORECORE_FAILURE)
    54.         {
    55.           released = (long) (current_brk - new_brk); //计算释放的虚拟内存的大小
    56.  
    57.           if (released != 0)
    58.             {
    59.               /* Success. Adjust top. */
    60.               av->system_mem -= released; //减去系统内存空间
    61.               set_head (av->top, (top_size - released) | PREV_INUSE); //设置状态
    62.               check_malloc_state (av);
    63.               return 1;
    64.             }
    65.         }
    66.     }
    67.   return 0;
    68. }

    3. 非主分配区heap_trim缩容heap区域

    我们知道，非主分配区主要通过MMAP的方式每次分配一块大对象用来当Top chunk。多次分配的时候通过heap结构的链表来进行链接管理。《ptmalloc源码分析 - 分配区heap_info结构实现（05）》 在第五章节中我们详细讲解过heap_info结构，这里不展开。

    heap_trim函数主要是通过计算得到需要缩容的空间，最终调用shrink_heap函数来实现缩容。

    1. /* 用来缩小非主分配区的heap大小 */
    2. static int heap_trim(heap_info *heap, size_t pad) {
    3. 	mstate ar_ptr = heap->ar_ptr;
    4. 	unsigned long pagesz = GLRO(dl_pagesize);
    5. 	mchunkptr top_chunk = top(ar_ptr), p;
    6. 	heap_info *prev_heap;
    7. 	long new_size, top_size, top_area, extra, prev_size, misalign;
    8.  
    9. 	/* Can this heap go away completely? */
    10. 	while (top_chunk == chunk_at_offset(heap, sizeof(*heap))) {
    11. 		prev_heap = heap->prev;
    12. 		prev_size = prev_heap->size - (MINSIZE - 2 * SIZE_SZ);
    13. 		p = chunk_at_offset(prev_heap, prev_size);
    14. 		/* fencepost must be properly aligned.  */
    15. 		misalign = ((long) p) & MALLOC_ALIGN_MASK;
    16. 		p = chunk_at_offset(prev_heap, prev_size - misalign);
    17. 		assert(chunksize_nomask(p) == (0 | PREV_INUSE)); /* must be fencepost */
    18. 		p = prev_chunk(p);
    19. 		new_size = chunksize(p) + (MINSIZE - 2 * SIZE_SZ) + misalign;
    20. 		assert(new_size > 0 && new_size < (long) (2 * MINSIZE));
    21. 		if (!prev_inuse(p))
    22. 			new_size += prev_size(p);
    23. 		assert(new_size > 0 && new_size < HEAP_MAX_SIZE);
    24. 		if (new_size + (HEAP_MAX_SIZE - prev_heap->size)
    25. 				< pad + MINSIZE + pagesz)
    26. 			break;
    27. 		ar_ptr->system_mem -= heap->size;
    28. 		LIBC_PROBE(memory_heap_free, 2, heap, heap->size);
    29. 		delete_heap(heap);
    30. 		heap = prev_heap;
    31. 		if (!prev_inuse(p)) /* consolidate backward */
    32. 		{
    33. 			p = prev_chunk(p);
    34. 			unlink_chunk(ar_ptr, p);
    35. 		}
    36. 		assert(((unsigned long) ((char *) p + new_size) & (pagesz - 1)) == 0);
    37. 		assert(((char *) p + new_size) == ((char *) heap + heap->size));
    38. 		top (ar_ptr) = top_chunk = p;
    39. 		set_head(top_chunk, new_size | PREV_INUSE);
    40. 		/*check_chunk(ar_ptr, top_chunk);*/
    41. 	}
    42.  
    43. 	/* Uses similar logic for per-thread arenas as the main arena with systrim
    44. 	 and _int_free by preserving the top pad and rounding down to the nearest
    45. 	 page.  */
    46. 	top_size = chunksize(top_chunk); //Top chunk的大小
    47. 	if ((unsigned long) (top_size) < (unsigned long) (mp_.trim_threshold))
    48. 		return 0;
    49.  
    50. 	top_area = top_size - MINSIZE - 1; //Top chunk的区域
    51. 	if (top_area < 0 || (size_t) top_area <= pad)
    52. 		return 0;
    53.  
    54. 	/* Release in pagesize units and round down to the nearest page.  */
    55. 	extra = ALIGN_DOWN(top_area - pad, pagesz); //缩容的大小
    56. 	if (extra == 0)
    57. 		return 0;
    58.  
    59. 	/* Try to shrink. 尝试调用缩小函数 */
    60. 	if (shrink_heap(heap, extra) != 0)
    61. 		return 0;
    62.  
    63. 	ar_ptr->system_mem -= extra;
    64.  
    65. 	/* Success. Adjust top accordingly. */
    66. 	set_head(top_chunk, (top_size - extra) | PREV_INUSE);
    67. 	/*check_chunk(ar_ptr, top_chunk);*/
    68. 	return 1;
    69. }

    六、步骤6-MMAP方式分配的，则直接执行munmap_chunk

    1.   /*
    2.     If the chunk was allocated via mmap, release via munmap().
    3.   */
    4.   /* 步骤6：MMAP方式分配的，则直接执行munmap_chunk */
    5.   else {
    6.     munmap_chunk (p);
    7.   }
    8. }

  • 相关阅读:
    C++继承机制学习笔记
    Mysql8.1.0 windows 绿色版安装
    【蓝桥杯选拔赛真题48】python最小矩阵 青少年组蓝桥杯python 选拔赛STEMA比赛真题解析
    【Matlab笔记_18】函数处理不同输出变量
    存内计算技术在边缘计算、物联网设备中的应用及前景
    java计算机毕业设计校园表白墙服务平台源程序+mysql+系统+lw文档+远程调试
    腾讯云5年服务器2核4G和4核8G配置租用价格表
    软件测试——Docker基本命令汇总
    C++ std::pair and std::list \ std::array
    数据结构之插入排序
  • 原文地址：https://blog.csdn.net/initphp/article/details/133309636