Redis内存管理（二）
上一遍详细的写明了Redis为内存管理所做的初始化工作，这篇文章写具体的函数实现。
1、zmalloc_size，返回内存池大小函数，因为库不同，所以这个函数在内部有很多的宏定义，通过具体使用的库来确定到底用哪个。
#define zmalloc_size(p) tc_malloc_size(p)//TCMalloc #define zmalloc_size(p) je_malloc_usable_size(p)//Jemalloc #define zmalloc_size(p) malloc_size(p)//Mac
//使用系统库的情况下，要单独写返回函数 #ifndef HAVE_MALLOC_SIZE size_t zmalloc_size(void *ptr)
{ void *realptr = (char*)ptr-PREFIX_SIZE; size_t size = *((size_t*)realptr); //具体的计算还没看懂。 if (size&(sizeof(long)-1))
size += sizeof(long)-(size&(sizeof(long)-1)); return size+PREFIX_SIZE; } #endif
2、zmalloc，内存分配函数
void *zmalloc(size_t size) {/*普通的申请内存大小函数，申请的时候，内存的头部加上一个longlong长度的头部*/ 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 }
3.zcalloc
/*重定义calloc函数，单每次只能申请一块内存，放弃了申请多块内存的功能，实际功能和zmalloc类似*/ 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 }
4、zrealloc，该函数放弃了按内存块大小成倍申请的功能，最后功能类似zmalloc
1 void *zrealloc(void *ptr, size_t size) 2 { 3 #ifndef HAVE_MALLOC_SIZE 4 //使用成熟库函数的情况下直接修改大小就好。最后更新使用内存量的大小。 5 void *realptr; 6 #endif 7 8 size_t oldsize; 9 void *newptr; 10 11 if (ptr == NULL) return zmalloc(size); 12 #ifdef HAVE_MALLOC_SIZE 13 oldsize = zmalloc_size(ptr); 14 newptr = realloc(ptr,size); 15 if (!newptr) zmalloc_oom_handler(size); 16 17 update_zmalloc_stat_free(oldsize); 18 update_zmalloc_stat_alloc(zmalloc_size(newptr)); 19 return newptr; 20 #else 21 /*没有使用现成库的情况下，扩展内存 22 将指针前移，找到真正开始的头部并记录下真正的开始， 23 按照新的大小重新申请内存，然后释放旧的，最后更新使用内存量的大小。 24 */ 25 realptr = (char*)ptr-PREFIX_SIZE; 26 oldsize = *((size_t*)realptr); 27 newptr = realloc(realptr,size+PREFIX_SIZE); 28 if (!newptr) zmalloc_oom_handler(size); 29 30 *((size_t*)newptr) = size; 31 update_zmalloc_stat_free(oldsize); 32 update_zmalloc_stat_alloc(size); 33 return (char*)newptr+PREFIX_SIZE; 34 #endif 35 }
5、zfree，内存释放函数
1 void zfree(void *ptr) {
//这个也是分两部分，如果使用了成熟库，直接调用释放就好，如果使用系统的，还要找到真的地址开始的头部然后再释放，最后更新内存使用量的大小。 2 #ifndef HAVE_MALLOC_SIZE 3 void *realptr; 4 size_t oldsize; 5 #endif 6 7 if (ptr == NULL) return; 8 #ifdef HAVE_MALLOC_SIZE 9 update_zmalloc_stat_free(zmalloc_size(ptr)); 10 free(ptr); 11 #else 12 realptr = (char*)ptr-PREFIX_SIZE; 13 oldsize = *((size_t*)realptr); 14 update_zmalloc_stat_free(oldsize+PREFIX_SIZE); 15 free(realptr); 16 #endif 17 }
6、zstrdup
1 /*字符串复制函数，给一个指定的字符串在堆上分配内存，注意，这个地方只是给一个字符串分配了内存，并没有转换成系统内统一的sds字符串，强行按sds使用会出错。*/ 2 char *zstrdup(const char *s) { 3 size_t l = strlen(s)+1; 4 char *p = zmalloc(l); 5 6 memcpy(p,s,l); 7 return p; 8 }
7、zmalloc_used_memory，获取已经使用的内存的大小
1 size_t zmalloc_used_memory(void) 2 { 3 size_t um; 4 //如果是线程安全情况下，读取当前使用内存量时要加互斥锁，不然可能会出现并发问题 5 if (zmalloc_thread_safe) 6 { 7 #if defined(__ATOMIC_RELAXED) || defined(HAVE_ATOMIC) 8 um = update_zmalloc_stat_add(0); 9 #else 10 pthread_mutex_lock(&used_memory_mutex); 11 um = used_memory; 12 pthread_mutex_unlock(&used_memory_mutex); 13 #endif 14 } 15 else 16 {//如果没设定线程安全，直接读取 17 um = used_memory; 18 } 19 20 return um; 21 }
8、zmalloc_enable_thread_safeness,设置线程安全，多线程模式下，最好是设置了，系统好像没提供解除的函数，也就是说系统一但确定了模式将不能改变。
void zmalloc_enable_thread_safeness(void) { zmalloc_thread_safe = 1; }
9、zmalloc_set_oom_handler，设置内存异常处理函数，如果不设置，系统有一个默认的。
void zmalloc_set_oom_handler(void (*oom_handler)(size_t)) { zmalloc_oom_handler = oom_handler; }
10、zmalloc_get_rss，获取进程总的虚拟内存的大小
#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; /*从/proc/PID/stat文件中读取Virtual memory size的大小，指的是虚拟内存的页数*/ 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; /* stat中第24个值记录的是虚拟内存的页数*/ 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
11、zmalloc_get_fragmentation_ratio，计算某块内存占已经使用的内存的百分比。
float zmalloc_get_fragmentation_ratio(size_t rss) { return (float)rss/zmalloc_used_memory(); }
12、最后两个函数不知道干嘛用的，所以没分析
#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 size_t zmalloc_get_private_dirty(void) { return zmalloc_get_smap_bytes_by_field("Private_Dirty:"); }
内存管理模块基本上分析完了，最后两个函数不知道是干嘛的等回头用的时候再说，总的来看，内存管理不是很麻烦，只给内存块加了一个头部来记录快大小，模块也充分考虑了性能，优先使用成熟的内存管理池，如果没有的话就优先使用编译器支持的原子操作，最后再都不支持的情况下才会使用互斥锁，如果在Redis使用的过程中互斥锁降低了性能，可以考虑升级gcc版本，或者安装两个成熟的内存管理库来提高性能。
