redis内存管理代码注释

zmalloc.h

[cpp] view
plaincopy

/* zmalloc - total amount of allocated memory aware version of malloc()

*

* Copyright (c) 2009-2010, Salvatore Sanfilippo <antirez at gmail dot com>

* All rights reserved.

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions are met:

*

* * Redistributions of source code must retain the above copyright notice,

* this list of conditions and the following disclaimer.

* * Redistributions in binary form must reproduce the above copyright

* notice, this list of conditions and the following disclaimer in the

* documentation and/or other materials provided with the distribution.

* * Neither the name of Redis nor the names of its contributors may be used

* to endorse or promote products derived from this software without

* specific prior written permission.

*

* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE

* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

* POSSIBILITY OF SUCH DAMAGE.

*/

#ifndef __ZMALLOC_H

#define __ZMALLOC_H

/* Double expansion needed for stringification of macro values. */

#define __xstr(s) __str(s)

#define __str(s) #s

//TCMALLOC内存分配器

#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 //TCMALLOC内置获取分配内存空间大小的函数

#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

//使用默认libc分配器

#ifndef ZMALLOC_LIB

#define ZMALLOC_LIB "libc"

#endif

void *zmalloc(size_t size);

void *zcalloc(size_t size);

void *zrealloc(void *ptr, size_t size);

void zfree(void *ptr);

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_rss(void);

size_t zmalloc_get_private_dirty(void);

size_t zmalloc_get_smap_bytes_by_field(char *field);

void zlibc_free(void *ptr);

#ifndef HAVE_MALLOC_SIZE

size_t zmalloc_size(void *ptr);

#endif

#endif /* __ZMALLOC_H */

zmalloc.c

[cpp] view
plaincopy

/* zmalloc - total amount of allocated memory aware version of malloc()

*

* Copyright (c) 2009-2010, Salvatore Sanfilippo <antirez at gmail dot com>

* All rights reserved.

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions are met:

*

* * Redistributions of source code must retain the above copyright notice,

* this list of conditions and the following disclaimer.

* * Redistributions in binary form must reproduce the above copyright

* notice, this list of conditions and the following disclaimer in the

* documentation and/or other materials provided with the distribution.

* * Neither the name of Redis nor the names of its contributors may be used

* to endorse or promote products derived from this software without

* specific prior written permission.

*

* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE

* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

* POSSIBILITY OF SUCH DAMAGE.

*/

#include <stdio.h>

#include <stdlib.h>

/* This function provide us access to the original libc free(). This is useful

* for instance to free results obtained by backtrace_symbols(). We need

* to define this function before including zmalloc.h that may shadow the

* free implementation if we use jemalloc or another non standard allocator. */

//保留了libc的free()接口，用于释放backtrace_symbols()获取的结果

void zlibc_free(void *ptr) {

free(ptr);

}

#include <string.h>

#include <pthread.h>

#include "config.h"

#include "zmalloc.h"

#ifdef HAVE_MALLOC_SIZE //tc_malloc,je_malloc,Mac平台

#define PREFIX_SIZE (0)

#else

/*其他平台内存分配

**内存模型：data_size(PREFIX_SIZE)+data

**前面PREFIX_SIZE字节存储申请空间大小，后面空间为申请的内存

*/

#if defined(__sun) || defined(__sparc) || defined(__sparc__)

#define PREFIX_SIZE (sizeof(long long))

#else //linux

#define PREFIX_SIZE (sizeof(size_t))

#endif

#endif

/* Explicitly override malloc/free etc when using tcmalloc. */

#if defined(USE_TCMALLOC)

#define malloc(size) tc_malloc(size)

#define calloc(count,size) tc_calloc(count,size)

#define realloc(ptr,size) tc_realloc(ptr,size)

#define free(ptr) tc_free(ptr)

#elif defined(USE_JEMALLOC)

#define malloc(size) je_malloc(size)

#define calloc(count,size) je_calloc(count,size)

#define realloc(ptr,size) je_realloc(ptr,size)

#define free(ptr) je_free(ptr)

#endif

//原子操作修改总共使用内存

#if defined(__ATOMIC_RELAXED)

#define update_zmalloc_stat_add(__n) __atomic_add_fetch(&used_memory, (__n), __ATOMIC_RELAXED)

#define update_zmalloc_stat_sub(__n) __atomic_sub_fetch(&used_memory, (__n), __ATOMIC_RELAXED)

#elif defined(HAVE_ATOMIC)

#define update_zmalloc_stat_add(__n) __sync_add_and_fetch(&used_memory, (__n))

#define update_zmalloc_stat_sub(__n) __sync_sub_and_fetch(&used_memory, (__n))

#else

#define update_zmalloc_stat_add(__n) do { \

pthread_mutex_lock(&used_memory_mutex); \

used_memory += (__n); \

pthread_mutex_unlock(&used_memory_mutex); \

} while(0)

#define update_zmalloc_stat_sub(__n) do { \

pthread_mutex_lock(&used_memory_mutex); \

used_memory -= (__n); \

pthread_mutex_unlock(&used_memory_mutex); \

} while(0)

#endif

//__n是分配的内存字节，更新used_memory的值，注意long型对齐

#define update_zmalloc_stat_alloc(__n) do { \

size_t _n = (__n); \

if (_n&(sizeof(long)-1)) _n += sizeof(long)-(_n&(sizeof(long)-1)); \ //分配字节不到long型的整数倍增加至整数倍

if (zmalloc_thread_safe) { \ //线程安全模式

update_zmalloc_stat_add(_n); \

} else { \ //非线程安全模式

used_memory += _n; \

} \

} while(0)

//__n是释放的内存字节，更新used_memory的值，注意long型对齐

#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)

static size_t used_memory = 0; //初始时总共使用内存空间为0

static int zmalloc_thread_safe = 0; //默认不启动线程安全模式

pthread_mutex_t used_memory_mutex = PTHREAD_MUTEX_INITIALIZER; //定义并初始化一个互斥量

//内存不足默认处理函数

static void zmalloc_default_oom(size_t size) {

fprintf(stderr, "zmalloc: Out of memory trying to allocate %zu bytes\n",

size);

fflush(stderr);

abort();

}

//内存不足处理函数指针，初始为默认函数

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

//malloc实现内存申请函数

void *zmalloc(size_t size) {

void *ptr = malloc(size+PREFIX_SIZE);

if (!ptr) zmalloc_oom_handler(size); //申请失败调用内存不足处理函数，终止程序

#ifdef HAVE_MALLOC_SIZE //tc_malloc,je_malloc,Mac平台

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

}

//calloc实现内存释放函数

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

}

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

}

/* 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. */

//假设所有分配器分配时均使用long型对齐

if (size&(sizeof(long)-1)) size += sizeof(long)-(size&(sizeof(long)-1));

return size+PREFIX_SIZE;

}

#endif

//释放ptr指向的内存空间

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

}

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;

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;

}

//设置安全线程模式

void zmalloc_enable_thread_safeness(void) {

zmalloc_thread_safe = 1;

}

//设置内存不足处理函数

void zmalloc_set_oom_handler(void (*oom_handler)(size_t)) {

zmalloc_oom_handler = oom_handler;

}

/* 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); //获取page大小

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

/* Fragmentation = RSS / allocated-bytes */

//计算碎片率

float zmalloc_get_fragmentation_ratio(size_t rss) {

return (float)rss/zmalloc_used_memory();

}

/* Get the sum of the specified field (converted form kb to bytes) in

* /proc/self/smaps. The field must be specified with trailing ":" as it

* apperas in the smaps output.

*

* Example: zmalloc_get_smap_bytes_by_field("Rss:");

*/

#if defined(HAVE_PROC_SMAPS)

size_t zmalloc_get_smap_bytes_by_field(char *field) {

char line[1024];

size_t bytes = 0;

FILE *fp = fopen("/proc/self/smaps","r");

int flen = strlen(field);

if (!fp) return 0;

while(fgets(line,sizeof(line),fp) != NULL) {

if (strncmp(line,field,flen) == 0) {

char *p = strchr(line,'k');

if (p) {

*p = '\0';

bytes += strtol(line+flen,NULL,10) * 1024;

}

}

}

fclose(fp);

return bytes;

}

#else

size_t zmalloc_get_smap_bytes_by_field(char *field) {

((void) field);

return 0;

}

#endif

//获取Private_Dirty大小，RSS=Shared_Clean+Shared_Dirty+Private_Clean+Private_Dirty

//Shared_Clean：引用大于1，未被修改

//Shared_Dirty：引用大于1，被修改

//Private_Clean：引用等于1，未被修改

//Private_Dirty：引用等于1，被修改

size_t zmalloc_get_private_dirty(void) {

return zmalloc_get_smap_bytes_by_field("Private_Dirty:");

}