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版本，或者安装两个成熟的内存管理库来提高性能。
