Redis源码研究之内存管理

本文主要说明Redis中的内存管理，Redis中使用自己实现了一个内存管理库来进行内存管理。

I、上帝视角看几个主要函数

1、Redis中的内存管理操作主要集中在zmalloc.c文件中，其主要函数包括：

zmalloc()        //内存分配
zfree()          //内存释放
zcalloc()          //calloc，与malloc的区别在于在分配完内存后初始化为0，而malloc为随机的垃圾数据
zrealloc()          //重新分配内存
zstrdup()        //strdup，复制字符串函数  

2、Redis为了屏蔽不同库的差异进行了预处理，自己封装了系统的内存分配函数：

/*src/zmalloc.h*/
#if defined(USE_TCMALLOC)  
#define ZMALLOC_LIB ("tcmalloc-" __xstr(TC_VERSION_MAJOR) "." __xstr(TC_VERSION_MINOR))  
#include   
#if (TC_VERSION_MAJOR == 1 && TC_VERSION_MINOR >= 6) || (TC_VERSION_MAJOR > 1)  
#define HAVE_MALLOC_SIZE 1  
#define zmalloc_size(p) tc_malloc_size(p)  
#else  
#error "Newer version of tcmalloc required"  
#endif  
  
#elif defined(USE_JEMALLOC)  
#define ZMALLOC_LIB ("jemalloc-" __xstr(JEMALLOC_VERSION_MAJOR) "." __xstr(JEMALLOC_VERSION_MINOR) "." __xstr(JEMALLOC_VERSION_BUGFIX))  
#include   
#if (JEMALLOC_VERSION_MAJOR == 2 && JEMALLOC_VERSION_MINOR >= 1) || (JEMALLOC_VERSION_MAJOR > 2)  
#define HAVE_MALLOC_SIZE 1  
#define zmalloc_size(p) je_malloc_usable_size(p)  
#else  
#error "Newer version of jemalloc required"  
#endif  
  
#elif defined(__APPLE__)  
#include   
#define HAVE_MALLOC_SIZE 1  
#define zmalloc_size(p) malloc_size(p)  
#endif  
  
#ifndef ZMALLOC_LIB  
#define ZMALLOC_LIB "libc"  
#endif  
  
...  
#ifndef HAVE_MALLOC_SIZE  
size_t zmalloc_size(void *ptr);  
#endif  

可以看出：
· 若系统中存在Google的TC_MALLOC库，则使用tc_malloc一族函数代替原本的malloc一族函数。
· 如果存在FaceBook的JEMALLOC库，则使用je_malloc一族函数代替原本的malloc一族函数。
· 若使用MAC系统，则使用中的内存分配函数。

II、zmalloc

1、zmalloc()主要提供了对malloc函数的封装，如果是glibc的malloc函数，则分配的内存是长度+要分配的内存，然后将头部放入大小：

/*src/zmalloc.c/zmalloc*/  
/* 内存分配函数zmalloc，size为实际需要分配的内存大小。
 * 而实际调用了  malloc(size+PREFIX_SIZE) ，PREFIX_SIZE是一个条件编译宏  
 * 对不同的编译平台有不同的结果，Linux中是sizeof(size_t)，  
 * 多分配的这个空间用于存储size的值。
*/
void *zmalloc(size_t size) {  
    void *ptr = malloc(size+PREFIX_SIZE);  
  
    if (!ptr) zmalloc_oom_handler(size);  //如果分配失败，则打印错误信息并终止程序
#ifdef HAVE_MALLOC_SIZE  
    update_zmalloc_stat_alloc(zmalloc_size(ptr));  
    return ptr;  
#else  
    *((size_t*)ptr) = size;    //将上面多分配的PREFIX_SIZE大小填充为size值
    update_zmalloc_stat_alloc(size+PREFIX_SIZE);    //更新全局变量used_memory(已分配内存大小)的值
    return (char*)ptr+PREFIX_SIZE;      //返回真正的分配存储空间的位置
#endif  
}  

2、下面我们看上面的update_zmalloc_stat_alloc()函数

/*src/zmalloc.c/update_zmalloc_stat_alloc*/
/*更新全局变量used_memory的值*/  
#define update_zmalloc_stat_alloc(__n) do { \  
    size_t _n = (__n); \  
    //if的作用是判断分配的内存空间大小是否为sizeof(long)的倍数，如果不是，则加上响应的偏移量使其成为sizeof(long)的倍数
    if (_n&(sizeof(long)-1)) _n += sizeof(long)-(_n&(sizeof(long)-1)); \  

    //判断是否为线程安全的
    if (zmalloc_thread_safe) { \  
        update_zmalloc_stat_add(_n); \  
    } else { \  
        used_memory += _n; \    //used_memory是一个全局静态变量，表示已分配内存的大小
    } \  
} while(0)  

这里所使用的do{...}while(0)结构可以参见 do{...}while(0)的意义和用法。

而update_zmalloc_stat_add()函数就是在线程安全的情况下通过加锁对used_memory进行+n操作：

/*src/zmalloc.c/update_zmalloc_stat_add()*/
#define update_zmalloc_stat_add(__n) do { \  
    pthread_mutex_lock(&used_memory_mutex); \  
    used_memory += (__n); \  
    pthread_mutex_unlock(&used_memory_mutex); \  
} while(0)  

III、 zfree

1、 zfree()函数主要是对free()函数进行了封装，实现了内存的释放。

/*src/zmalloc.c/zfree*/
void zfree(void *ptr) {  
#ifndef HAVE_MALLOC_SIZE  
    void *realptr;  
    size_t oldsize;  
#endif  
  
    if (ptr == NULL) return;  
#ifdef HAVE_MALLOC_SIZE  
    update_zmalloc_stat_free(zmalloc_size(ptr));  
    free(ptr);  
#else  
    realptr = (char*)ptr-PREFIX_SIZE;  
    oldsize = *((size_t*)realptr);  
    update_zmalloc_stat_free(oldsize+PREFIX_SIZE);  
    free(realptr);  
#endif  
} 

2、 update_zmalloc_stat_free()函数为对used_memory进行-n操作。我们重点关注else之后的部分：

realptr = (char *)ptr - PREFIX_SIZE为得到真正的内存分配位置（即除去头部存储的size值），然后在进行update used_memory 操作。

IV、 zcalloc

1、zcalloc函数主要封装的是calloc函数，其也是内存分配函数，但是与malloc函数不同的是，会对内存进行初始化操作。

/*src/zmalloc.c/zcalloc*/
void *zcalloc(size_t size) {  
    void *ptr = calloc(1, size+PREFIX_SIZE);  
  
    if (!ptr) zmalloc_oom_handler(size);  
#ifdef HAVE_MALLOC_SIZE  
    update_zmalloc_stat_alloc(zmalloc_size(ptr));  
    return ptr;  
#else  
    *((size_t*)ptr) = size;  
    update_zmalloc_stat_alloc(size+PREFIX_SIZE);  
    return (char*)ptr+PREFIX_SIZE;  
#endif  
}  

上述代码与zmalloc函数基本一致。

V、zrealloc

1、zrealloc函数完成的功能是为ptr位置重新分配大小。主要完成的是对realloc的封装。

/*src/zmalloc.c/zrealloc*/
void *zrealloc(void *ptr, size_t size) {  
#ifndef HAVE_MALLOC_SIZE  
    void *realptr;  
#endif  
    size_t oldsize;  
    void *newptr;  
  
    if (ptr == NULL) return zmalloc(size);  
#ifdef HAVE_MALLOC_SIZE  
    oldsize = zmalloc_size(ptr);  
    newptr = realloc(ptr,size);  
    if (!newptr) zmalloc_oom_handler(size);  
  
    update_zmalloc_stat_free(oldsize);  
    update_zmalloc_stat_alloc(zmalloc_size(newptr));  
    return newptr;  
#else  
    realptr = (char*)ptr-PREFIX_SIZE;  
    oldsize = *((size_t*)realptr);  
    newptr = realloc(realptr,size+PREFIX_SIZE);  
    if (!newptr) zmalloc_oom_handler(size);  
  
    *((size_t*)newptr) = size;  
    update_zmalloc_stat_free(oldsize);  
    update_zmalloc_stat_alloc(size);  
    return (char*)newptr+PREFIX_SIZE;  
#endif  
}  

VI、zstrdup

1、zstrdup函数为string分配内存，并完成string的复制：

/*src/zmalloc.c/zstrdup*/  
char *zstrdup(const char *s) {  
    size_t l = strlen(s)+1;    //+1是加上\0
    char *p = zmalloc(l);    //分配内存
  
    memcpy(p,s,l);        //完成copy
    return p;  
}  

VII、其他辅助函数

在zmalloc.h的辅助函数中，有些会比之前出现的函数更值得学习，因为它们更贴近OS。

7.1 zmalloc_enable_thread_safeness

/*src/zmalloc.c/zmalloc_enable_thread_safeness*/  
void zmalloc_enable_thread_safeness(void) {  
    zmalloc_thread_safe = 1;  
}

1、zmalloc_thread_safe是一个全局静态变量，标记线程安全。

7.2 zmalloc_used_memory

1、zmalloc_used_memory函数返回used_memory的值，其功能为查询当前Redis分配的内存大小。其中包含了线程安全的判断。

/*src/zmalloc.c/zmalloc_used_memory*/
size_t zmalloc_used_memory(void) {  
    size_t um;  
  
    if (zmalloc_thread_safe) {  
#if defined(__ATOMIC_RELAXED) || defined(HAVE_ATOMIC)  
        um = update_zmalloc_stat_add(0);  
#else  
        pthread_mutex_lock(&used_memory_mutex);  
        um = used_memory;  
        pthread_mutex_unlock(&used_memory_mutex);  
#endif  
    }  
    else {  
        um = used_memory;  
    }  
  
    return um;  
} 

7.3 zmalloc_size

1、函数的作用是返回实际分配内存的总大小，这包括size，以及存储size值的头PREFIX_SIZE，还有内存对齐操作所形成的偏移量：

/*src/zmalloc.c/zmalloc_size*/
#ifndef HAVE_MALLOC_SIZE  
size_t zmalloc_size(void *ptr) {  
    void *realptr = (char*)ptr-PREFIX_SIZE;  
    size_t size = *((size_t*)realptr);  
    /* Assume at least that all the allocations are padded at sizeof(long) by 
     * the underlying allocator. */  
    if (size&(sizeof(long)-1)) size += sizeof(long)-(size&(sizeof(long)-1));  
    return size+PREFIX_SIZE;  
}  
#endif  

7.4 zmalloc_get_rss

1、zmalloc_get_rss的作用是获取rss(Resident Set Size)的大小，表示当前进程实际驻留在内存中的空间大小，即不包括swap出去的空间。

2、该函数大致的操作是在当前进程的文件中进行检索。该文件的第24个字段是rss的信息，其单位是pages(内存页的数目)。

/*src/zmalloc.c/zmalloc_get_rss*/
size_t zmalloc_get_rss(void) {  
    int page = sysconf(_SC_PAGESIZE);    //通过调用sysconf库函数，查询内存页大小
    size_t rss;  
    char buf[4096];  
    char filename[256];  
    int fd, count;  
    char *p, *x;  
  
    //将当前进程所对应的stat文件的绝对路径名保存到filename中，万物皆文件的效果。
    snprintf(filename,256,"/proc/%d/stat",getpid());  
    if ((fd = open(filename,O_RDONLY)) == -1) return 0;  
    if (read(fd,buf,4096) <= 0) {  
        close(fd);  
        return 0;  
    }  
    close(fd);  
  
    p = buf;  
    //跳过前23个字段
    count = 23; /* RSS is the 24th field in /proc//stat */  
    while(p && count--) {  
        p = strchr(p,' ');  
        if (p) p++;  
    }  
    if (!p) return 0;  
    x = strchr(p,' ');  
    if (!x) return 0;  
    *x = '\0';  
  
    rss = strtoll(p,NULL,10);    //string to long long
    rss *= page;  
    return rss;  
}    

7.5 zmalloc_get_fragementation_ratio

1、zmalloc_get_fragementation_ratio函数用来查询内存碎片率，即rss和所分配内存空间的比值，这里查询的实际上是内部碎片率。

/*src/malloc.c/zmalloc_get_fragementation_ratio*/
/* Fragmentation = RSS / allocated-bytes */  
float zmalloc_get_fragmentation_ratio(size_t rss) {  
    return (float)rss/zmalloc_used_memory();  
}    

【参考】
[1] Redis内存管理的基石zmalloc.c源码解读