【redis6.0.6】redis源码慢慢学，慢慢看 -- 第二天：空间配置（zmalloc）

#if defined(USE_TCMALLOC)
	#define ZMALLOC_LIB ("tcmalloc-" __xstr(TC_VERSION_MAJOR) "." __xstr(TC_VERSION_MINOR))
	#include <google/tcmalloc.h>
	#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 <jemalloc/jemalloc.h>
	#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 <malloc/malloc.h>
		#define HAVE_MALLOC_SIZE 1
		#define zmalloc_size(p) malloc_size(p)
#endif

#ifndef ZMALLOC_LIB
	#define ZMALLOC_LIB "libc"
	#ifdef __GLIBC__
		#include <malloc.h>
		#define HAVE_MALLOC_SIZE 1
		#define zmalloc_size(p) malloc_usable_size(p)
	#endif
#endif

void *zmalloc(size_t size); /* 调用zmalloc申请size个大小的空间 */
void *zcalloc(size_t size); /* 调用系统函数calloc函数申请空间 */
void *zrealloc(void *ptr, size_t size); /* 原内存重新调整空间为size的大小 */
void zfree(void *ptr); /* 释放空间方法，并更新used_memory的值 */
char *zstrdup(const char *s); /* 字符串复制方法 */
size_t zmalloc_used_memory(void); /* 获取当前已经占用的内存大小 */
void zmalloc_enable_thread_safeness(void); /* 是否设置线程安全模式 */
void zmalloc_set_oom_handler(void (*oom_handler)(size_t)); /* 可自定义设置内存溢出的处理方法 */
float zmalloc_get_fragmentation_ratio(size_t rss); /* 所给大小与已使用内存大小之比 */
size_t zmalloc_get_private_dirty(void); /* 获取私有的脏数据大小 */
void zlibc_free(void *ptr);  /* 原始系统free释放方法 */

static size_t used_memory = 0;	//系统已经使用了多少的内存
static int zmalloc_thread_safe = 0;	//这指的是线程安全模式状态
pthread_mutex_t used_memory_mutex = PTHREAD_MUTEX_INITIALIZER;	//锁

/* 调用zmalloc申请size个大小的空间 */
void *zmalloc(size_t size) {
    void *ptr = malloc(size+PREFIX_SIZE);	//实际调用的还是malloc函数
    //注1：PREFIX_SIZE

    if (!ptr) 
    	zmalloc_oom_handler(size);	//如果申请的结果为null，说明发生了oom,调用oom的处理方法
		//注2：oom处理方法

#ifdef HAVE_MALLOC_SIZE		//HAVE_MALLOC_SIZE，往前翻翻
	update_zmalloc_stat_alloc(zmalloc_size(ptr));	//更新used_memory的大小	zmalloc_size这个函数后面会讲
    return ptr;
    //注3：update_zmalloc_stat_alloc
#else
	*((size_t*)ptr) = size;
	update_zmalloc_stat_alloc(size+PREFIX_SIZE);
	return (char*)ptr+PREFIX_SIZE;
#endif
}

#ifdef HAVE_MALLOC_SIZE
	#define PREFIX_SIZE (0)
#else
	#if defined(__sun) || defined(__sparc) || defined(__sparc__)
		#define PREFIX_SIZE (sizeof(long long))
	#else
		#define PREFIX_SIZE (sizeof(size_t))
	#endif
#endif

static void (*zmalloc_oom_handler)(size_t) = zmalloc_default_oom;	

static void zmalloc_default_oom(size_t size) {
    fprintf(stderr, "zmalloc: Out of memory trying to allocate %zu bytesn",
        size);
    fflush(stderr);
    abort();
}
//其实我并不知道为什么要分成两个函数来写

#define update_zmalloc_stat_alloc(__n) do { 
    size_t _n = (__n); 
    if (_n&(sizeof(long)-1)) _n += sizeof(long)-(_n&(sizeof(long)-1)); 
    atomicIncr(used_memory,__n); 		//注4：atomicIncr
} while(0)

/* atomicIncr(var,count) -- Increment the atomic counter  增加原子计数器*/

#define atomicIncr(var,count) do { 
    pthread_mutex_lock(&var ## _mutex); 	//线程安全，两个 ## 配套资料中有说
    var += (count); 
    pthread_mutex_unlock(&var ## _mutex); 
} while(0)

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
}

/*调用zrealloc重新分配空间*/
void *zrealloc(void *ptr, size_t size) {
#ifndef HAVE_MALLOC_SIZE
    void *realptr;
#endif
    size_t oldsize;
    void *newptr;

    if (size == 0 && ptr != NULL) {	//如果是要清空
        zfree(ptr);		//注5：zfree
        return NULL;
    }
    if (ptr == NULL) return zmalloc(size);	//如果是要给一个空指针分配空间

//接下来才是正事
#ifdef HAVE_MALLOC_SIZE
    oldsize = zmalloc_size(ptr);	//注6：zmalloc_size，前面注释太多了，负载均衡一下哈哈哈
    newptr = realloc(ptr,size);		//最终还是调用了realloc函数
    if (!newptr) zmalloc_oom_handler(size);

    update_zmalloc_stat_free(oldsize);	//注7：update_zmalloc_stat_free
    update_zmalloc_stat_alloc(zmalloc_size(newptr));	//注8：update_zmalloc_stat_alloc
    return newptr;
#else
    realptr = (char*)ptr-PREFIX_SIZE;	//将当前指针 ptr 向前偏移 PREFIX_SIZE 个字节，得到真正内存分配的起始地址 realptr；
    oldsize = *((size_t*)realptr);		//取 realptr 位置上的值作为该连续内存块的大小，并且记录在 oldsize 中
    newptr = realloc(realptr,size+PREFIX_SIZE);	
    //realloc 在 realptr 的位置分配 size+PREFIX_SIZE 的空间，返回 newptr。size 的值有可能比 oldsize 大或小，newptr 和 ptr 的值可能相同也可能不同，这个完全取决于 realloc 的实现。
    if (!newptr) zmalloc_oom_handler(size);

    *((size_t*)newptr) = size;	//将 size 记录在 newptr 指向的位置上。
    update_zmalloc_stat_free(oldsize+PREFIX_SIZE);
    update_zmalloc_stat_alloc(size+PREFIX_SIZE);
    
    return (char*)newptr+PREFIX_SIZE;
#endif
}

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
}

/* Provide zmalloc_size() for systems where this function is not provided by
 * malloc itself, given that in that case we store a header with this
 * information as the first bytes of every allocation. */

#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;
}
size_t zmalloc_usable(void *ptr) {
    return zmalloc_size(ptr)-PREFIX_SIZE;
}
#endif

#define update_zmalloc_stat_free(__n) do { 
    size_t _n = (__n); 
    if (_n&(sizeof(long)-1)) _n += sizeof(long)-(_n&(sizeof(long)-1)); 
    atomicDecr(used_memory,__n); 			//注9：atomicDecr，还负载均衡呢。。。
} while(0)

#define update_zmalloc_stat_alloc(__n) do { 
    size_t _n = (__n); 
    if (_n&(sizeof(long)-1)) _n += sizeof(long)-(_n&(sizeof(long)-1)); 
    atomicIncr(used_memory,__n); 	//atomicIncr前面讲过了
} while(0)

#define atomicDecr(var,count) do { 
    pthread_mutex_lock(&var ## _mutex); 
    var -= (count); 
    pthread_mutex_unlock(&var ## _mutex); 
} while(0)

char *zstrdup(const char *s) {
    size_t l = strlen(s)+1;
    char *p = zmalloc(l);

    memcpy(p,s,l);
    return p;
}

size_t zmalloc_used_memory(void) {
    size_t um;
    atomicGet(used_memory,um);
    return um;
}

#define atomicGet(var,dstvar) do { 
    pthread_mutex_lock(&var ## _mutex); 
    dstvar = var; 
    pthread_mutex_unlock(&var ## _mutex); 
} while(0)

/* WARNING: the function zmalloc_get_rss() is not designed to be fast
 * and may not be called in the busy loops where Redis tries to release
 * memory expiring or swapping out objects.
 *
 * For this kind of "fast RSS reporting" usages use instead the
 * function RedisEstimateRSS() that is a much faster (and less precise)
 * version of the function. */