redis源码1---内存管理(zmalloc)
打算学习一下redis源码，结果刚开始看sds就发现一个陌生的词汇，zmalloc，查看zmalloc的实现，发现是对malloc的封装，并且还引出了ptMalloc和tcMalloc等知识，关于malloc库和redis的其他内存管理的知识，后续查看了后再谈
字长与字节对齐
首先要了解一个操作系统的基础，字长和字节对齐，字长是指 CPU一次性能读取数据的二进制位数，也就是我们通常所说的32位系统（字长4个字节）、64位系统（字长8个字节）的由来。所谓的字节对齐，简单的介绍可以查看 https://blog.csdn.net/ldw662523/article/details/79623404，总之，当我们向系统申请内存的时候，系统会返回给我们 n倍个字长的字节数，比如我们申请10字节，64位系统下会返回给我们2*8个字节
long类型变量和指针类型变量占用一字长的字节数，在32为系统下，sizeof(char *) 和 sizeof(long) 是4，在64位下是8，本文接下来内容都用64位，也就是8字节对齐为主
主要变量和函数
全局变量
//定义当前进程已使用的内存总量
static size_t used_memory = 0;
//标识是否线程安全，值为1时线程安全
static int zmalloc_thread_safe = 0;
//如果是线程安全的，修改used_memory 时的互斥锁
pthread_mutex_t used_memory_mutex = PTHREAD_MUTEX_INITIALIZER;
//zmalloc_oom_handler 为函数指针，当内存出错时调用，默认的调用函数是 zmalloc_default_oom
//oom 是out of memory
static void (*zmalloc_oom_handler)(size_t) = zmalloc_default_oom;
主要函数
void *zmalloc(size_t size); //分配内存空间
void zcalloc(size_t size); //分配内存并初始化为0
void zrealloc(void *ptr,size_t size); //重新分配内存空间的大小
void zfree(void *ptr); //释放zmalloc所分配的内存空间
char *zstrdup(const char *s); //字符串复制
void zlibc_free(void *ptr); //同free()
宏
//linux的glibc下是sizeof(size_t)，64位系统为8字节
//当zmalloc申请内存时，多分配PREFIX_SIZE 个字节
PREFIX_SIZE
//若使用tcmalloc、jemalloc或Mac系统则定义此宏，linux的glibc不定义
HAVE_MALLOC_SIZE
宏函数
//分配内存空间后更新used_memory的值
update_zamlloc_stat_alloc
//释放内存空间后更新used_memory的值
update_zamlloc_stat_free
//线程安全地used_memory增加操作
update_zamlloc_stat_add
//线程安全地used_memory减少操作
update_zamlloc_stat_sub
zmalloc
void *zmalloc(size_t size) {
//size是要分配的内存大小，多分配了PREFIX_SIZE个字节，用于存放size的大小
void *ptr = malloc(size + PREFIX_SIZE);
//如果内存分配失败，调用函数指针zmalloc_oom_handler所指向的函数
if (!ptr) zmalloc_oom_handler(size);
#ifdef HAVE_MALLOC_SIZE
update_zmalloc_stat_alloc(zmalloc_size(ptr));
return ptr;
#else
//前sizeof(size_t) 个字节，存储要分配的内存大小
*((size_t*)ptr) = size;
update_zmalloc_stat_alloc(size+PREFIX_SIZE);
//只返回给用户可用的内存空间
return (char*)ptr+PREFIX_SIZE;
#endif
}
PREFIX_SIZE是一个条件编译的宏，不同的平台有不同的结果，在Linux中其值是sizeof(size_t)，所以我们多分配了一个字长(8个字节)的空间，用于存放size的值
zmalloc_oom_handler指向内存错误处理函数，默认是指向函数zmalloc_default_oom，其主要功能就是打印错误信息并终止程序。
static void zmalloc_default_oom(size_t size) {
//将错误输出到标准错误
fprintf(stderr, "zmalloc: Out of memory trying to allocate %zu bytes\n",
size);
//立即刷新标准错误缓冲区
fflush(stderr);
abort();
}
linux下不定义宏 HAVE_MALLOC_SIZE，所以走 #else的代码
//前sizeof(size_t) 个字节，存储要分配的内存大小
*((size_t*)ptr) = size;
update_zmalloc_stat_alloc(size+PREFIX_SIZE);
//只返回给用户可用的内存空间
return (char*)ptr+PREFIX_SIZE;
前sizeof(size_t)，也就是PREFIX_SIZE个字节，存放所申请的内存大小size。我们先看一下
return (char*)ptr+PREFIX_SIZE;
将指针后移 PREFIX_SIZE 位，只给用户返回可用的内存空间，所以malloc出来的内存被分为了两部分，一部分用来存放size的值，一部分返回给用户。
然后调用了宏函数update_zmalloc_stat_alloc
update_zmalloc_stat_alloc
#define update_zmalloc_stat_alloc(__n) do { \
size_t _n = (__n); \
//判断 _n是否是8的倍数
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; \
} \
} while(0)
其中
if (_n&(sizeof(long)-1)) _n += sizeof(long)-(_n&(sizeof(long)-1)); \
用位运算判断 _n 是否是8的倍数，如果不是，加上所需的数值，使之能被8整除，比如，申请20bytes， 20 & (sizeof (long) - 1) = 20 & 7 = 4，非零，不能整除，即缺 8 - 4 = 4 bytes，于是申请的20 bytes多申请4bytes，24 mod 8 = 0正好
其实malloc出来的内存，已经是8的倍数，系统自动帮我们完成字节对齐，我们之所以还要判断一次，是为了保证used_memory的值是实际分配的内存大小。比如用户申请20字节，malloc以后，系统分配了24字节，但是我们并不知道分配了24字节，所以我们要像系统一样，去做一次字节对齐，这样能够知道系统具体分配了多少
接下来判断是否是线程安全的，zmalloc_thread_safe默认为0，也就是走else下面，直接给used_memory 加上值。如果是线程安全的，调用宏函数 update_zmalloc_stat_add
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)
其实就是调用了互斥锁来保证增加used_memory 值的时候是线程安全的，注意到一点是宏函数外层都用 do while(0) 包裹着，其实并不是额外加了什么功能,只是为了保持宏函数实现的时候语意和我们所写的代码一致,防止大括号以及分号的干扰，详见 https://blog.csdn.net/Move_now/article/details/73480195
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
//将指针前移 PREFIX_SIZE 位
realptr = (char*)ptr-PREFIX_SIZE;
//取出当zmalloc时返回给用户的可用的内存空间大小
oldsize = *((size_t*)realptr);
update_zmalloc_stat_free(oldsize+PREFIX_SIZE);
free(realptr);
#endif
}
我们还是关注没有定义 HAVE_MALLOC_SIZE 的部分，定义指针realptr，让其指向最初malloc返回的地址，用oldsize 保存用户所申请的内存大小
update_zmalloc_stat_free 和 update_zmalloc_stat_alloc 一样是宏函数，不同之处是前者在给变量used_memory减去分配的空间，而后者是加上该空间大小
update_zmalloc_stat_free
#define update_zmalloc_stat_free(__n) do { \
size_t _n = (__n); \
if (_n&(sizeof(long)-1)) _n += sizeof(long)-(_n&(sizeof(long)-1)); \
if (zmalloc_thread_safe) { \
update_zmalloc_stat_sub(_n); \
} else { \
used_memory -= _n; \
} \
} while(0)
update_zmalloc_sub与zmalloc()中的update_zmalloc_add相对应，但功能相反，提供线程安全地used_memory减法操作
update_zmalloc_stat_sub
#define update_zmalloc_stat_sub(__n) do { \
pthread_mutex_lock(&used_memory_mutex); \
used_memory -= (__n); \
pthread_mutex_unlock(&used_memory_mutex); \
} while(0)
zcalloc
zcalloc()的实现基于calloc()，但是两者编程接口不同
void *calloc(size_t nmemb, size_t size);
void *zcalloc(size_t size);
calloc()的功能是也是分配内存空间，与malloc()的不同之处有两点：
1.它分配的空间大小是 size * nmemb。比如calloc(10,sizoef(char)); // 分配10个字节
2.calloc()会对分配的空间做初始化工作（初始化为0），而malloc()不会
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
}
zaclloc和zmalloc原理是一样的，只不过申请内存时malloc换成了calloc，和zmalloc相比就是申请的内存被初始化了
zrealloc
zrealloc()和realloc()具有相同的编程接口：
void *realloc (void *ptr, size_t size);
void *zrealloc(void *ptr, size_t size);
realloc()要完成的功能是给首地址ptr的内存空间，重新分配大小。如果失败了，则在其它位置新建一块大小为size字节的空间，将原先的数据复制到新的内存空间，并返回这段内存首地址【原内存会被系统自然释放】。 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
}
zstrdup
复制字符串s的内容，申请新的内存空间存储字符串。并将这段新的字符串地址返回
char *zstrdup(const char *s) {
//strlen()函数是不统计'\0'的，所以最后要加1
size_t l = strlen(s)+1;
char *p = zmalloc(l);
//调用memcpy来完成复制
memcpy(p,s,l);
return p;
}
zmalloc_size
这个函数是为glibc定制的，只有用这个库时，才能使用这个函数
#ifndef HAVE_MALLOC_SIZE
size_t zmalloc_size(void *ptr) {
void *realptr = (char*)ptr-PREFIX_SIZE;
size_t size = *((size_t*)realptr);
if (size&(sizeof(long)-1)) size += sizeof(long)-(size&(sizeof(long)-1));
return size+PREFIX_SIZE;
}
#endif
得到zmalloc像系统申请的真实的内存大小
参考资料：https://blog.csdn.net/guodongxiaren/article/details/44747719
https://blog.csdn.net/u012842205/article/details/50392119
