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沒有被定義的時候，就需要在多分配出的空間內記錄下當前申請的內存空間的大小。
![image](https://pic4.zhimg.com/50/v2-439f7c9d9a4b3d9a9f4e0a2737ab9fd1_hd.jpg)

### 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/<pid>/stat 【<pid>表示當前進程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

include <sys/types.h>

include <sys/stat.h>

include

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

include

include

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();
}

```

redis源碼筆記-內存管理zmalloc.c