zmalloc

原文鏈接：https://www.cnblogs.com/bush2582/p/8969000.html

redis的內存分配主要就是對malloc和free進行了一層簡單的封裝。具體的實現在zmalloc.h和zmalloc.c中。本文將對redis的內存管理相關幾個比較重要的函數做逐一的介紹
參考：

1. http://blog.csdn.net/guodongxiaren/article/details/44783767
2. http://www.voidcn.com/article/p-kxxvjygo-bpm.html
3. http://blog.ddup.us/2011/05/11/redis-internal-memory-allocation/
4. http://blog.csdn.net/taozhi20084525/article/details/23621345

void *zmalloc(size_t size);
void *zcalloc(size_t size);
void *zrealloc(void *ptr, size_t size);
void zfree(void *ptr);
size_t zmalloc_used_memory(void);
void zmalloc_enable_thread_safeness(void);
float zmalloc_get_fragmentation_ratio(size_t rss);
size_t zmalloc_get_rss(void);

zmalloc

在zmalloc函數中，實際可能會每次多申請一個 PREFIX_SIZE的空間。從如下的代碼中看出，如果定義了宏HAVE_MALLOC_SIZE，那麼 PREFIX_SIZE的長度爲0。其他的情況下，都會多分配至少8字節的長度的內存空間。

• zmalloc.c

#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

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;
    update_zmalloc_stat_alloc(size+PREFIX_SIZE);
    return (char*)ptr+PREFIX_SIZE;
#endif
}

這麼做的原因是因爲： tcmalloc 和 Mac平臺下的 malloc 函數族提供了計算已分配空間大小的函數（分別是tcmallocsize和mallocsize），所以就不需要單獨分配一段空間記錄大小了。而針對linux和sun平臺則要記錄分配空間大小。對於linux，使用sizeof(sizet)定長字段記錄；對於sun os，使用sizeof(long long)定長字段記錄。因此當宏HAVE_MALLOC_SIZE沒有被定義的時候，就需要在多分配出的空間內記錄下當前申請的內存空間的大小。

update_zmalloc_stat_alloc

update_zmalloc_stat_alloc 是一個宏，因爲sizeof(long) == 8 [64位系統中]，所以其實第一個if的代碼等價於if(_n&7) _n += 8 - (_n&7); 這段代碼就是判斷分配的內存空間的大小是不是8的倍數。如果內存大小不是8的倍數，就加上相應的偏移量使之變成8的倍數。_n&7 在功能上等價於 _n%8，不過位操作的效率顯然更高。

    #define update_zmalloc_stat_alloc(__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_add(_n); \  
        } else { \  
            used_memory += _n; \  
        } \  
    } while(0)  

malloc函數本身能夠保證分配的內存是8字節對齊的，如果要分配的內存不是8的倍數，那麼malloc就會多分配一點，來湊成8的倍數。所以這段代碼真正的作用是獲得使用內存的精確大小。
第二個if主要判斷當前是否處於線程安全的情況下。如果處於線程安全的情況下，就使用update_zmalloc_stat_add宏來更改全局變量used_memory。否則的話就直接加上n。

    #define update_zmalloc_stat_add(__n) do { \  
        pthread_mutex_lock(&used_memory_mutex); \  
        used_memory += (__n); \  
        pthread_mutex_unlock(&used_memory_mutex); \  
    } while(0)  

zmalloc_size

在zmalloc.h的代碼中，有一段如下定義的代碼：

    #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"
    #endif

可以看如果使用了jemalloc tcmalloc 或者apple系統下，都提供了檢測內存塊大小的函數，因此 zmalloc_size就使用相應的庫函數。如果默認使用libc的話則 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

zfree

有分配就有內存回收，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
   }

上面的代碼可以看出，根據用的庫不相同，回收的時候也採用了不同的方法。

   #else
       realptr = (char*)ptr-PREFIX_SIZE;
       oldsize = *((size_t*)realptr);
       update_zmalloc_stat_free(oldsize+PREFIX_SIZE);
       free(realptr);
   #endif

可以發現如果使用的libc庫，則需要將ptr指針向前偏移8個字節的長度，回退到最初malloc返回的地址，然後通過類型轉換再取指針所指向的值。通過zmalloc()函數的分析，可知這裏存儲着我們最初需要分配的內存大小（zmalloc中的size），這裏賦值給oldsize。update_zmalloc_stat_free()也是一個宏函數，和zmalloc中update_zmalloc_stat_alloc()大致相同，唯一不同之處是前者在給變量used_memory減去分配的空間，而後者是加上該空間大小。
最後free(realptr)，清除空間。

zcalloc

zcalloc 函數與zmalloc函數的功能基本相同，但有2點不同的是:

1. 分配的空間大小是 size * nmemb。;
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
}

zrealloc

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  
    }  

zmalloc_used_memory

zmalloc_used_memory 函數用來獲取當前使用的內存總量，其中__sync_add_and_fetch就是宏update_zmalloc_stat_add。關於do while(0)的用法可以參見http://blog.csdn.net/luoweifu/article/details/38563161

size_t zmalloc_used_memory(void) {
    size_t um;

    if (zmalloc_thread_safe) {
#ifdef HAVE_ATOMIC
        um = __sync_add_and_fetch(&used_memory, 0);
#else
        pthread_mutex_lock(&used_memory_mutex);
        um = used_memory;
        pthread_mutex_unlock(&used_memory_mutex);
#endif
    }
    else {
        um = used_memory;
    }

    return um;
}

zmalloc_get_rss

這個函數可以獲取當前進程實際所駐留在內存中的空間大小，即不包括被交換（swap）出去的空間。該函數大致的操作就是在當前進程的 /proc//stat 【表示當前進程id】文件中進行檢索。該文件的第24個字段是RSS的信息，它的單位是pages（內存頁的數目)。如果沒從操作系統的層面獲取駐留內存大小，那就只能絀劣的返回已經分配出去的內存大小。

/* Get the RSS information in an OS-specific way.
 *
 * 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. */

#if defined(HAVE_PROC_STAT)
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

size_t zmalloc_get_rss(void) {
    int page = sysconf(_SC_PAGESIZE);
    size_t rss;
    char buf[4096];
    char filename[256];
    int fd, count;
    char *p, *x;

    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;
    count = 23; /* RSS is the 24th field in /proc/<pid>/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);
    rss *= page;
    return rss;
}
#elif defined(HAVE_TASKINFO)
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/sysctl.h>
#include <mach/task.h>
#include <mach/mach_init.h>

size_t zmalloc_get_rss(void) {
    task_t task = MACH_PORT_NULL;
    struct task_basic_info t_info;
    mach_msg_type_number_t t_info_count = TASK_BASIC_INFO_COUNT;

    if (task_for_pid(current_task(), getpid(), &task) != KERN_SUCCESS)
        return 0;
    task_info(task, TASK_BASIC_INFO, (task_info_t)&t_info, &t_info_count);

    return t_info.resident_size;
}
#else
size_t zmalloc_get_rss(void) {
    /* If we can't get the RSS in an OS-specific way for this system just
     * return the memory usage we estimated in zmalloc()..
     *
     * Fragmentation will appear to be always 1 (no fragmentation)
     * of course... */
    return zmalloc_used_memory();
}
#endif

zmalloc_get_fragmentation_ratio

這個函數可以來提供內存碎片率的指標，直接用駐留在物理內存中的內存/除以分配的總物理內存，得到一個所謂的碎片率， 實際留在物理內存中的除以總分配的。

/* Fragmentation = RSS / allocated-bytes */
float zmalloc_get_fragmentation_ratio(size_t rss) {
    return (float)rss/zmalloc_used_memory();
}