redis内存管理代码注释

来源：互联网发布：知鱼之乐编辑：程序博客网时间：2024/06/04 20:01

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:");  
}  

0 0