heap

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

struct malloc_chunk {
  // 前一个chunk的大小，当前一个chunk释放时堆管理器可以通过这个字段访问并合并前一个空闲块，是内存相邻的
  INTERNAL_SIZE_T      mchunk_prev_size;  /* Size of previous chunk (if free).  */
  // 当前chunk总大小
  INTERNAL_SIZE_T      mchunk_size;       /* Size in bytes, including overhead. */

  // 下一个空闲chunk，是链表相邻的
  struct malloc_chunk* fd;         /* double links -- used only if free. */
  // 上一个空闲chunk
  struct malloc_chunk* bk;

  /* Only used for large blocks: pointer to next larger size.  */
  // 指向大小略大于当前chunk的下一个空闲chunk
  struct malloc_chunk* fd_nextsize; /* double links -- used only if free. */
  // 指向大小略小于当前chunk的上一个空闲chunk
  struct malloc_chunk* bk_nextsize;
};

1
2
3
4
5
6
7

#define PREV_INUSE 0x1     // P
#define IS_MMAPPED 0x2     // M
#define NON_MAIN_ARENA 0x4 // A
#define SIZE_BITS (PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)

// 获取实际大小
size_t actual_size = mchunk_size & ~SIZE_BITS;

 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

struct malloc_state
{
  /* Serialize access.  */
  __libc_lock_define (, mutex);

  /* Flags (formerly in max_fast).  */
  int flags;

  /* Set if the fastbin chunks contain recently inserted free blocks.  */
  /* Note this is a bool but not all targets support atomics on booleans.  */
  int have_fastchunks;

  /* Fastbins */    // typedef struct malloc_chunk* mchunkptr;
  mfastbinptr fastbinsY[NFASTBINS];  // 指针数组，指向不同大小的fastbins链表

  /* Base of the topmost chunk -- not otherwise kept in a bin */
  mchunkptr top;  // 指向堆的最顶端

  /* The remainder from the most recent split of a small request */
  mchunkptr last_remainder;  // 指向最近一次小内存请求剩余的空间，用于减少碎片化

  /* Normal bins packed as described above */
  mchunkptr bins[NBINS * 2 - 2];  // 指向普通bins

  /* Bitmap of bins */
  unsigned int binmap[BINMAPSIZE];

  /* Linked list */
  struct malloc_state *next;  // 指向下一个malloc_state

  /* Linked list for free arenas.  Access to this field is serialized
     by free_list_lock in arena.c.  */
  struct malloc_state *next_free;

  /* Number of threads attached to this arena.  0 if the arena is on
     the free list.  Access to this field is serialized by
     free_list_lock in arena.c.  */
  INTERNAL_SIZE_T attached_threads;

  /* Memory allocated from the system in this arena.  */
  INTERNAL_SIZE_T system_mem;
  INTERNAL_SIZE_T max_system_mem;
};