从malloc到内存管理

Posted 2021-08-26 Fireplusplus

故事从malloc开始

malloc是谁？malloc是怎么分配内存的？malloc分配的是什么内存？

malloc是谁

最常用且最便捷的内存分配方式当然是栈内存了，随着栈指针的上下移动，完成了压栈出栈操作，编译器替我们规划好了栈上内存的申请、释放。

但是呢，栈内存是有限且可怜的。一方面，是因为没有程序需要那么多的栈内存，另一方面，栈内存的软限制防止了无尽的递归操作耗尽系统内存的可能。如下，可查看一般栈内存的大小也只有8MB.

[root@localhost ~]# ulimit -s
8192

glibc是GNU发布的libc库，即GNU标准的C函数库。malloc是其中提供的一个函数接口，为应用程序提供通用的内存分配接口。

malloc是怎么分配内存的

我们都听过，局部变量在栈上分配内存，并由高地址向低地址增长，动态内存在堆上分配，并由低地址向高地址增长。具体细节是怎么样的，还是要看下源码如何做的。

在malloc.c中可以看到malloc是__libc_malloc的别名：

strong_alias (__libc_malloc, __malloc) strong_alias (__libc_malloc, malloc)

 __libc_malloc定义如下：

void * __libc_malloc (size_t bytes)
{
  mstate ar_ptr;
  void *victim;
  void *(*hook) (size_t, const void *)
    = atomic_forced_read (__malloc_hook);
  if (__builtin_expect (hook != NULL, 0))
    return (*hook)(bytes, RETURN_ADDRESS (0));
  ...
  arena_get (ar_ptr, bytes);
  victim = _int_malloc (ar_ptr, bytes);
  ...
  return victim;
}

 初次进来会先调用__malloc_hook，初始化分配区main_arena，这里维护了申请内存的各种信息：

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 */
  mfastbinptr fastbinsY[NFASTBINS];
  /* 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];
  /* Bitmap of bins */
  unsigned int binmap[BINMAPSIZE];
  /* Linked list */
  struct malloc_state *next;
  /* 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;
};

内存块由chunk维护，并被组织成链表：

struct malloc_chunk {
  INTERNAL_SIZE_T      mchunk_prev_size;  /* Size of previous chunk (if free).  */
  INTERNAL_SIZE_T      mchunk_size;       /* Size in bytes, including overhead. */
  struct malloc_chunk* fd;         /* double links -- used only if free. */
  struct malloc_chunk* bk;
  /* Only used for large blocks: pointer to next larger size.  */
  struct malloc_chunk* fd_nextsize; /* double links -- used only if free. */
  struct malloc_chunk* bk_nextsize;
};

然后再调用__libc_malloc的一个封装：

static void * malloc_hook_ini (size_t sz, const void *caller)
{
  __malloc_hook = NULL;
  ptmalloc_init ();
  return __libc_malloc (sz);
}

初始化完成后，将进入核心分配函数_int_malloc：进来先调用checked_request2size将申请的size转换为size + sizeof(chunk)的大小，并对齐到16字节的整数倍：

static inline bool checked_request2size (size_t req, size_t *sz) __nonnull (1)
{
  if (__glibc_unlikely (req > PTRDIFF_MAX))
    return false;
  *sz = request2size (req);
  return true;
}

首先，尝试在fast_bin中查找对应的空闲块，如果申请的块size小于64B，则有可能直接找到返回：

  if ((unsigned long) (nb) <= (unsigned long) (get_max_fast ())) {
      idx = fastbin_index (nb);
      mfastbinptr *fb = &fastbin (av, idx);
      mchunkptr pp;
      victim = *fb;

      if (victim != NULL) {
        ...
	    void *p = chunk2mem (victim);
	    alloc_perturb (p, bytes);
	    return p;
	  }
    }

如果没找到，再判断申请的size小于512B，尝试从smallbin中查找对应的空闲块，否则会尝试合并fastbin中的碎片：

if (in_smallbin_range (nb)) {
      idx = smallbin_index (nb);
      bin = bin_at (av, idx);
      if ((victim = last (bin)) != bin) {
          ...
          void *p = chunk2mem (victim);
          alloc_perturb (p, bytes);
          return p;
      }
} else {
      idx = largebin_index (nb);
      if (atomic_load_relaxed (&av->have_fastchunks))
        malloc_consolidate (av);
}

如果还是没有，会做一些垃圾回收的操作：处理最近释放的块，仅在size完全匹配的时候才返回这个块，否则就把块按大小放入对应的bin中。

对于仍未找到空闲块的情形，将会调用sysmalloc向内核分配一块新的空间：

void *p = sysmalloc (nb, av);
if (p != NULL)
  alloc_perturb (p, bytes);

 sysmalloc先判断size是否大于128KB，若是，则通过mmap申请一块内存，将其映射到堆栈段中间的内存映射段，否则通过向上调整brk指针的方式增大虚拟内存边界，然后返回。

malloc分配的是什么内存

malloc无论是通过mmap系统调用，或是调整brk指针申请内存，申请的都还只是虚拟内存，并没有分配实际的物理页。应用程序看到malloc返回的地址，就已经认为内存申请成功了。

至于物理内存页，要等到应用程序初次使用这部分内存块时，才会真正的通过内核来分配。