malloc

文章:malloc 函数详解

 

使用 malloc 要加头文件,malloc 是分配一块连续的内存,和 free 函数是一起用的。但是一部分人还是将 malloc 当作系统所提供的或者是 C 的关键字,事实上 malloc 只是 C 标准库中提供的一个普通函数

而且很多人都对 malloc 的具体实现机制不是很了解。

 

一、关于 malloc 以及相关的几个函数
// Linux
#include <stdlib.h>       

void *malloc(size_t size);
void free(void *ptr);
void *calloc(size_t nmemb, size_t size);
void *realloc(void *ptr, size_t size);

也可以这样认为(window 下)原型:extern void *malloc(unsigned int num_bytes);

导入头文件 #include <malloc.h> 或者 #include <alloc.h> 两者的内容是完全一样的。

如果分配成功,则返回指向被分配内存空间的指针;不然,返回空指针 NULL同时,当内存不再使用的时候,应使用 free() 函数将内存块释放掉。

关于:void * 表示未确定类型的指针。CC++ 规定,void * 类型可以强转为任何其他类型的的指针。

malloc returns a void pointer to the allocated space, or NULL if there is insufficient memory available. To return a pointer to a type other than void, use a type cast on the return value. The storage space pointed to by the return value is guaranteed to be suitably aligned for storage of any type of object. If size is 0, malloc allocates a zero-length item in the heap and returns a valid pointer to that item. Always check the return from malloc, even if the amount of memory requested is small.

关于 void * 的其他说法:

void * p1;
int *p2;

p1 = p2;  // 其他任意类型都可以直接赋值给它,无需进行强转,但是反过来不可以。

malloc

①、malloc 分配的内存大小至少为 size 参数所指定的字节数;

②、malloc 的返回值是一个指针,指向一段可用内存的起始地址;

③、多次调用 malloc 所分配的地址不能有重叠部分,除非某次 malloc 所分配的地址被释放掉

④、malloc 应该尽快完成内存分配并返回(不能使用 NP-hard 的内存分配算法)

⑤、实现 malloc 时应同时实现内存大小调整和内存释放函数(reallocfree

mallocfree 函数是配对的,如果申请后不释放就是内存泄露;如果无故释放那就是什么都没有做,释放只能释放一次,如果释放两次及两次以上会出现错误(但是释放空指针例外,释放空指针其实也等于什么都没有做,所以释放多少次都是可以的。

 

二、malloc 和 new

new 返回指定类型的指针,并且可以自动计算所需要的大小。

int *p;
p = new int;      // 返回类型为 int * 类型,分配的大小为 sizeof(int)
p = new int[100]; // 返回类型为 int * 类型,分配的大小为 sizeof(int) * 100

malloc必须由我们计算字节数,并且在返回的时候强转成实际指定类型的指针。

int *p = (int *)malloc(sizeof(int));

①、malloc 的返回是 void *,如果写成了 p = malloc(sizeof(int)); 间接的说明了将 void * 转成 int *,这不合理

②、malloc 的实参是 sizeof(int),用于指明一个整形数据需要的大小,如果我们写成:

int * p = (int *)malloc(1);

可以看出,只是申请了一个字节的空间,如果向里面存放了一个整数的话,将会占用额外的 3 个字节,可能会改变原有内存空间中的数据。

③、malloc 只管分配内存,并不能对其进行初始化,所以得到的一片新内存中,其值将是随机的。一般习惯性的将其初始化为NULL。当然,也可以用 memset 函数的。

简单的说:

malloc 函数其实就是在内存中找一片指定大小的空间,然后将这个空间的首地址给一个指针变量,这里的指针变量可以是一个单独的指针,也可以是一个数组的首地址, 这要看 malloc 函数中参数 size 的具体内容。我们这里 malloc 分配的内存空间在逻辑上是连续的,而在物理上可以不连续。程序员关注的是逻辑上的连续,其它的,操作系统会帮着我们处理的。

下面看看 malloc 的具体实现机制。

 

三、Linux 内存管理

1、虚拟内存地址与物理内存地址

为了简单,现代操作系统在处理内存地址时,普遍采用虚拟内存地址技术。即在汇编程序(或机器语言)层面,当涉及内存地址时, 都是使用虚拟内存地址。采用这种技术时,每个进程仿佛自己独享一片 2N 字节的内存,其中 N 是机器位数。例如在 64CPU64 位操作系统下,每个进程的虚拟地址空间为 264Byte

这种虚拟地址空间的作用主要是简化程序的编写及方便操作系统对进程间内存的隔离管理,真实中的进程不太可能(也用不到)如此大的内存空间,实际能用到的内存取决于物理内存大小。

由于在机器语言层面都是采用虚拟地址,当实际的机器码程序涉及到内存操作时,需要根据当前进程运行的实际上下文将虚拟地址转换为物理内存地址,才能实现对真实内存数据的操作。这个转换一般由一个叫 MMUMemory Management Unit)的硬件完成。

 

2、页与地址构成

在现代操作系统中,不论是虚拟内存还是物理内存,都不是以字节为单位进行管理的,而是以页(Page)为单位。一个内存页是一段固定大小的连续内存地址的总称,具体到 Linux 中,典型的内存页大小为 4096Byte4K)。

所以内存地址可以分为页号和页内偏移量。下面以 64 位机器,4G 物理内存,4K 页大小为例,虚拟内存地址和物理内存地址的组成如下:

内存地址构成

上面是虚拟内存地址,下面是物理内存地址。由于页大小都是 4K,所以页内偏移都是用低 12 位表示,而剩下的高地址表示页号。

MMU 映射单位并不是字节,而是页,这个映射通过查一个常驻内存的数据结构页表来实现。现在计算机具体的内存地址映射比较复杂,为了加快速度会引入一系列缓存和优化,例如 TLB 等机制。下面给出一个经过简化的内存地址翻译示意图,虽然经过了简化,但是基本原理与现代计算机真实的情况的一致的。

内存地址翻译

 

3、内存页与磁盘页

一般将内存看做磁盘的的缓存,有时 MMU 在工作时,会发现页表表明某个内存页不在物理内存中,此时会触发一个缺页异常(Page Fault),此时系统会到磁盘中相应的地方将磁盘页载入到内存中,然后重新执行由于缺页而失败的机器指令。关于这部分,因为可以看做对 malloc 实现是透明的,所以不再详细讲述,有兴趣的可以参考《深入理解计算机系统》相关章节。

最后附上一张在维基百科找到的更加符合真实地址翻译的流程供大家参考,这张图加入了TLB和缺页异常的流程(图片来源页)。

较为完整的地址翻译流程

 

四、Linux 进程级内存管理

1、内存排布

明白了虚拟内存和物理内存的关系及相关的映射机制,下面看一下具体在一个进程内是如何排布内存的。

Linux 64 位系统为例。理论上,64bit 内存地址可用空间为 0x0000000000000000 ~ 0xFFFFFFFFFFFFFFFF,这是个相当庞大的空间,Linux 实际上只用了其中一小部分(256T)。

根据 Linux 内核相关文档描述,Linux 64 位操作系统仅使用低 47 位,高 17 位做扩展(只能是全 0 或全 1)。所以,实际用到的地址为空间为 0x0000000000000000 ~ 0x00007FFFFFFFFFFF0xFFFF800000000000 ~ 0xFFFFFFFFFFFFFFFF,其中前面为用户空间(User Space),后者为内核空间(Kernel Space)。图示如下:

Linux进程地址排布

对用户来说,主要关注的空间是 User Space。将 User Space 放大后,可以看到里面主要分为如下几段:

  • Code:这是整个用户空间的最低地址部分,存放的是指令(也就是程序所编译成的可执行机器码);
  • Data:这里存放的是初始化过的全局变量;
  •  BSS:这里存放的是未初始化的全局变量;
  • Heap:堆。堆自低地址向高地址增长,后面要讲到的 brk 相关的系统调用就是从这里分配内存
  • Mapping Area:这里是与 mmap 系统调用相关的区域。大多数实际的 malloc 实现会考虑通过 mmap 分配较大块的内存区域,本文不讨论这种情况。这个区域自高地址向低地址增长
  • Stack:栈。自高地址向低地址增长。

下面我们主要关注 Heap 区域的操作。

 

2、Heap 内存模型

一般来说,malloc 所申请的内存主要从 Heap 区域分配(本文不考虑通过 mmap 申请大块内存的情况)。

由上文知道,进程所面对的虚拟内存地址空间,只有按页映射到物理内存地址后,才能真正使用。受物理存储容量限制,整个堆虚拟内存空间不可能全部映射到实际的物理内存。Linux 对堆的管理示意如下:

Linux进程堆管理

Linux 维护一个 break 指针,这个指针指向堆空间的某个地址。从堆起始地址到 break 之间的地址空间为映射好的,可以供进程访问;而从 break 往上,是未映射的地址空间,如果访问这段空间则程序会报错。

 

3brksbrk

由上文知道,要增加一个进程实际的可用堆大小,就需要将 break 指针向高地址移动。Linux 通过 brksbrk 系统调用操作 break 指针。两个系统调用的原型如下:

int brk(void *addr);
void *sbrk(intptr_t increment);

brkbreak 指针直接设置为某个地址,而 sbrkbreak 从当前位置移动 increment 所指定的增量。brk 在执行成功时返回0,否则返回 -1 并设置 errnoENOMEMsbrk 成功时返回 break 移动之前所指向的地址,否则返回 (void *)-1

小技巧:如果将 increment 设置为 0,则可以获得当前 break 的地址。

另外需要注意的是,由于 Linux 是按页进行内存映射的,所以如果 break 被设置为没有按页大小对齐,则系统实际上会在最后映射一个完整的页,从而实际已映射的内存空间比 break 指向的地方要大一些。但是使用 break 之后的地址是很危险的(尽管也许 break 之后确实有 一小块可用内存地址)。

 

4、资源限制与 rlimit

系统对每一个进程所分配的资源不是无限的,包括可映射的内存空间,因此每个进程有一个 rlimit 表示当前进程可用的资源上限。这个限制可以通过 getrlimit 系统调用得到,下面代码获取当前进程虚拟内存空间的 rlimit

int main() {
      struct rlimit * limit = (struct rlimit *)malloc(sizeof(struct rlimit));
      getrlimit(RLIMIT_AS, limit);
      
      printf("soft limit: %ld, hard limit: %ld\n", limit->rlim_cur, limit->rlim_max);
}

其中 rlimit 是一个结构体:

struct rlimit {
     rlim_t rlim_cur; /* Soft limit */
     rlim_t rlim_max; /* Hard limit (ceiling for rlim_cur) */
};

每种资源有软限制和硬限制,并且可以通过 setrlimitrlimit 进行有条件设置。其中硬限制作为软限制的上限,非特权进程只能设置软限制,且不能超过硬限制

 

五、实现 malloc

1、玩具实现

在正式开始讨论 malloc 的实现前,我们可以利用上述知识实现一个简单但几乎没法用于真实的玩具 malloc,权当对上面知识的复习:

#include <sys/types.h>
#include <unistd.h>

void *malloc(size_t size)
{
     void *p = sbrk(0);

     if (sbrk(size) == (void *)-1)
          return NULL;
     return p;
}

这个 malloc 每次都在当前 break 的基础上增加 size 所指定的字节数,并将之前 break 的地址返回。这个 malloc 由于对所分配的内存缺乏记录,不便于内存释放,所以无法用于真实场景。

 

2、正式实现

下面讨论 malloc 的实现方案。

2.1 数据结构

首先我们要确定所采用的数据结构。一个简单可行方案是将堆内存空间以块(Block)的形式组织起来,每个块由 meta 区和数据区组成,meta 区记录数据块的元信息(数据区大小、空闲标志位、指针等等),数据区是真实分配的内存区域,并且数据区的第一个字节地址即为 malloc 返回的地址。

可以用如下结构体定义一个 block

typedef struct s_block *t_block;

struct s_block {
     size_t size;    /* 数据区大小 */
     t_block next;   /* 指向下个块的指针 */
     int free;       /* 是否是空闲块 */
     int padding;    /* 填充4字节,保证meta块长度为8的倍数 */
     char data[1];   /* 这是一个虚拟字段,表示数据块的第一个字节,长度不应计入 meta */
};

由于只考虑 64 位机器,为了方便,在结构体最后填充一个 int,使得结构体本身的长度为 8 的倍数,以便内存对齐。示意图如下:

Block结构

关于长度为 1 的数组注意:http://bbs.csdn.net/topics/300077699

 

2.2 寻找合适的 block

现在考虑如何在 block 链中查找合适的 block。一般来说有两种查找算法:

 
  • First fit:从头开始,使用第一个数据区大小大于要求 size 的块所谓此次分配的块;
  •  Best fit:从头开始,遍历所有块,使用数据区大小大于 size差值最小的块作为此次分配的块。

两种方法各有千秋,best fit 具有较高的内存使用率(payload 较高),而 first fit 具有更好的运行效率。这里我们采用 first fit 算法。

/* First fit */
t_block find_block(t_block *last, size_t size) {
 
     t_block b = first_block;

     while(b && !(b->free && b->size >= size)) {
           *last = b;
           b = b->next;
     }
     return b;
}

find_blockfrist_block 开始,查找第一个符合要求的 block 并返回 block 起始地址,如果找不到这返回 NULL。这里在遍历时会更新一个叫 last 的指针,这个指针始终指向当前遍历的 block。这是为了如果找不到合适的 block 而开辟新  block 使用的,具体会在接下来的一节用到。

 

2.3 开辟新的 block

如果现有 block 都不能满足 size 的要求,则需要在链表最后开辟一个新的 block。这里关键是如何只使用 sbrk 创建一个 struct

#define BLOCK_SIZE 24 /* 由于存在虚拟的data字段,sizeof不能正确计算meta长度,这里手工设置 */
 
t_block extend_heap(t_block last, size_t s) {

     t_block b;
     b = sbrk(0);

     if(sbrk(BLOCK_SIZE + s) == (void *)-1)
           return NULL;

     b->size = s;
     b->next = NULL;

     if(last)
           last->next = b;

     b->free = 0;

     return b;
}

 

2.4 分裂 block

First fit 有一个比较致命的缺点,就是可能会让很小的 size 占据很大的一块 block,此时,为了提高 payload,应该在剩余数据区足够大的情况下,将其分裂为一个新的 block,示意如下:

分裂block

实现代码:

void split_block(t_block b, size_t s) {

      t_block new;
      new = b->data + s;
      new->size = b->size - s - BLOCK_SIZE ;
      new->next = b->next;
      new->free = 1;

      b->size = s;
      b->next = new;
}

 

2.5 malloc 的实现

有了上面的代码,我们可以利用它们整合成一个简单但初步可用的 malloc。注意首先要定义个 block 链表的头 first_block,初始化为 NULL;另外,我们需要剩余空间至少有 BLOCK_SIZE + 8 才执行分裂操作。

由于我们希望 malloc 分配的数据区是按 8 字节对齐,所以在 size 不为 8 的倍数时,需要将 size 调整为大于 size 的最小的 8 的倍数:

size_t align8(size_t s) {

     if(s & 0x7 == 0)
           return s;

     return ((s >> 3) + 1) << 3;
}
#define BLOCK_SIZE 24

void *first_block = NULL;
 
/* other functions... */
 
void *malloc(size_t size) {

      t_block b, last;
      size_t s;

      /* 对齐地址 */
      s = align8(size);

      if(first_block) {
           /* 查找合适的block */
           last = first_block;
           b = find_block(&last, s);

           if(b) {
                 /* 如果可以,则分裂 */
                 if ((b->size - s) >= ( BLOCK_SIZE + 8))
                       split_block(b, s);

                 b->free = 0;
           }
           else {
                 /* 没有合适的block,开辟一个新的 */
                 b = extend_heap(last, s);
          
                 if(!b)
                       return NULL;
           }
     }
     else {
           b = extend_heap(NULL, s);

           if(!b)
                 return NULL;

           first_block = b;
     }

     return b->data;
}
 

 

2.6 calloc 的实现

有了 malloc,实现 calloc 只要两步:

①、malloc 一段内存

②、将数据区内容置为 0

由于我们的数据区是按 8 字节对齐的,所以为了提高效率,我们可以每 8 字节一组置 0,而不是一个一个字节设置。我们可以通过新建一个 size_t 指针,将内存区域强制看做 size_t 类型来实现。

void *calloc(size_t number, size_t size) {

      size_t *new;
      size_t s8, i;

      new = malloc(number * size);

      if(new) {
             s8 = align8(number * size) >> 3;

             for(i = 0; i < s8; i++)
                   new[i] = 0;
      }

      return new;
}

 

2.7 free 的实现

free 的实现并不像看上去那么简单,这里我们要解决两个关键问题:

 ①、如何验证所传入的地址是有效地址,即确实是通过 malloc 方式分配的数据区首地址

 ②、如何解决碎片问题

首先我们要保证传入 free 的地址是有效的,这个有效包括两方面:

①、地址应该在之前 malloc 所分配的区域内,即在 first_block 和当前 break 指针范围内

②、这个地址确实是之前通过我们自己的 malloc 分配的

第一个问题比较好解决,只要进行地址比较就可以了,关键是第二个问题。这里有两种解决方案:一是在结构体内埋一个 magic number 字段,free 之前通过相对偏移检查特定位置的值是否为我们设置的 magic number,另一种方法是在结构体内增加一个magic pointer,这个指针指向数据区的第一个字节(也就是在合法时 free 时传入的地址),我们在 free 前检查 magic pointer是否指向参数所指地址。这里我们采用第二种方案:

首先我们在结构体中增加 magic pointer(同时要修改 BLOCK_SIZE):

typedef struct s_block *t_block;

struct s_block {
      size_t size;     /* 数据区大小 */
      t_block next;    /* 指向下个块的指针 */
      int free;        /* 是否是空闲块 */
      int padding;     /* 填充 4 字节,保证 meta 块长度为 8 的倍数 */
      void *ptr;       /* Magic pointer,指向 data */
      char data[1]     /* 这是一个虚拟字段,表示数据块的第一个字节,长度不应计入meta */
};

然后我们定义检查地址合法性的函数:

t_block get_block(void *p) {

     char *tmp;
     tmp = p;

     return (p = tmp -= BLOCK_SIZE);
}
 
int valid_addr(void *p) {

     if(first_block) {
           if(p > first_block && p < sbrk(0)) {
                 return p == (get_block(p))->ptr;
           }
     }

     return 0;
}

当多次 mallocfree 后,整个内存池可能会产生很多碎片 block,这些 block 很小,经常无法使用,甚至出现许多碎片连在一起,虽然总体能满足某此 malloc 要求,但是由于分割成了多个小 block 而无法 fit,这就是碎片问题。

一个简单的解决方式时当 free 某个 block 时,如果发现它相邻的 block 也是 free 的,则将 block 和相邻 block 合并。为了满足这个实现,需要将 s_block 改为双向链表。修改后的 block 结构如下:

typedef struct s_block *t_block;

struct s_block {
      size_t size;    /* 数据区大小 */
      t_block prev;   /* 指向上个块的指针 */
      t_block next;   /* 指向下个块的指针 */
      int free;       /* 是否是空闲块 */
      int padding;    /* 填充4字节,保证meta块长度为8的倍数 */
      void *ptr;      /* Magic pointer,指向data */
      char data[1]    /* 这是一个虚拟字段,表示数据块的第一个字节,长度不应计入meta */
};

合并方法如下:

t_block fusion(t_block b) {

      if (b->next && b->next->free) {
            b->size += BLOCK_SIZE + b->next->size;
            b->next = b->next->next;

            if(b->next)
                  b->next->prev = b;
      }

      return b;
}

有了上述方法,free 的实现思路就比较清晰了:首先检查参数地址的合法性,如果不合法则不做任何事;否则,将此 blockfree 标为 1,并且在可以的情况下与后面的 block 进行合并。如果当前是最后一个 block,则回退 break 指针释放进程内存,如果当前 block 是最后一个 block,则回退 break 指针并设置 first_blockNULL。实现如下:

void free(void *p) {

     t_block b;

     if(valid_addr(p)) {
          b = get_block(p);
          b->free = 1;

          if(b->prev && b->prev->free)
               b = fusion(b->prev);

          if(b->next) {
               fusion(b);
          } 
          else {
               if(b->prev)
                     b->prev->prev = NULL;
               else
                     first_block = NULL;

               brk(b);
          }
     }
}

 

2.8 realloc 的实现

为了实现 realloc,首先要实现一个内存复制方法。如同 calloc 一样,为了效率,我们以 8 字节为单位进行复制:

void copy_block(t_block src, t_block dst) {

     size_t *sdata, *ddata;
     size_t i;
     sdata = src->ptr;
     ddata = dst->ptr;

     for(i = 0; (i * 8) < src->size && (i * 8) < dst->size; i++)
          ddata[i] = sdata[i];
}

然后我们开始实现 realloc。一个简单(但是低效)的方法是 malloc 一段内存,然后将数据复制过去。但是我们可以做的更高效,具体可以考虑以下几个方面:

  • 如果当前 block 的数据区大于等于 realloc 所要求的 size,则不做任何操作
  • 如果新的 size 变小了,考虑 split
  • 如果当前 block 的数据区不能满足 size,但是其后继 blockfree 的,并且合并后可以满足,则考虑做合并。

下面是 realloc 的实现:

void *realloc(void *p, size_t size) {

     size_t s;
     t_block b, new;
     void *newp;

     if (!p)
          /* 根据标准库文档,当p传入NULL时,相当于调用malloc */
          return malloc(size);

     if(valid_addr(p)) {
          s = align8(size);
          b = get_block(p);

          if(b->size >= s) {
               if(b->size - s >= (BLOCK_SIZE + 8))
                    split_block(b,s);
          }
          else {
               /* 看是否可进行合并 */
               if(b->next && b->next->free && (b->size + BLOCK_SIZE + b->next->size) >= s) {
                    fusion(b);

                    if(b->size - s >= (BLOCK_SIZE + 8))
                         split_block(b, s);
               }
               else {
                    /* 新malloc */
                    newp = malloc (s);

                    if (!newp)
                         return NULL;

                    new = get_block(newp);
                    copy_block(b, new);
                    free(p);
                    return(newp);
               }
          }
          return (p);
     }
     return NULL;
}

 

六、遗留问题和优化

以上是一个较为简陋,但是初步可用的 malloc 实现。还有很多遗留的可能优化点,例如:

  • 同时兼容 32 位和 64 位系统
  • 在分配较大快内存时,考虑使用 mmap 而非 sbrk,这通常更高效
  • 可以考虑维护多个链表而非单个,每个链表中的 block 大小均为一个范围内,例如 8 字节链表、16 字节链表、24-32 字节链表等等。此时可以根据 size 到对应链表中做分配,可以有效减少碎片,并提高查询 block 的速度。
  • 可以考虑链表中只存放 freeblock,而不存放已分配的 block,可以减少查找 block 的次数,提高效率。

 

七、其它参考

You may also like...