Redis源码剖析——内存分配

发表于 | 分类于 | 阅读次数:
字数统计: 1,393 字

内存分配是程序需要解决的一个大问题，也应该是剖析一个程序的源码最基础最关键的部分之一。

Redis的内存分配主要是在C语言中对内存处理的函数：malloc、realloc、free的基础加了一些封装和异常的处理。

其特点主要有以下三点：

  1. 添加对使用内存的统计，在分配和释放内存的时候都会更新记录使用内存的量
  2. 支持线程安全模式，通过锁的机制对use_memory进行控制，避免其出现脏数据的可能
  3. 增添对内存溢出的处理

首先Redis源码中与内存分配相关的以下全局变量：

1
2
3
static size_t used_memory = 0;    // 使用的内存大小
static int zmalloc_thread_safe = 0;   // 线程安全模式状态
pthread_mutex_t used_memory_mutex = PTHREAD_MUTEX_INITIALIZER;   // 为此服务器

内存分配相关功能函数

Redis中和内存分配相关的功能函数主要有以下这些：

1
2
3
4
5
6
7
8
9
10
11
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);  // 获取rss信息
size_t zmalloc_get_private_dirty(void);   // 获取实际物理分配的内存

内存申请与调整

Redis中和内存申请相关的函数主要是zmalloc、zcalloc和zrealloc，分别是对C语言中的malloc、calloc和realloc的封装。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
// 对malloc进行封装，加上异常处理和内存统计
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
}

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
}

首先要注意的是对内存溢出的处理，可以自定义处理函数，其默认的处理方式如下：

1
2
3
4
5
6
7
8
9
10
// 默认溢出处理方法
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;

然后我们可以看到每次在调整内存的时候，都会对全局变量use_memory进行改变，调整是以sizeof(long)的整数倍进行调整的。在改变use_memory的时候会判断是否在线程安全模式下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 更新使用的内存数量值
#define update_zmalloc_stat_alloc(__n) do { \
    size_t _n = (__n); \
    // _n调整为size(long)的整数倍
    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)

#define update_zmalloc_stat_add(__n) do { \
    pthread_mutex_lock(&used_memory_mutex); \
    used_memory += (__n); \
    pthread_mutex_unlock(&used_memory_mutex); \
} while(0)

内存释放

内存释放部分和申请部分类似，主要是对free函数的封装。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// 获取内存占用空间大小
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. */
    // 调整为sizeof(long)的整数倍，方便对齐
    if (size&(sizeof(long)-1)) size += sizeof(long)-(size&(sizeof(long)-1));
    return size+PREFIX_SIZE;
}
#endif

// 封装对系统的free调用
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
}

对use_memory的操作：

1
2
3
4
5
6
7
8
9
10
11
12
// 释放内存以后对内存空间统计变量的改变
#define update_zmalloc_stat_free(__n) do { \
    size_t _n = (__n); \
    // 以sizeof(long)的整数倍进行调整
    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)

辅助函数

除了最基本的一些内存分配的函数以外，还实现了一些辅助函数(如复制字符串、获取已经使用内存的大小）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// 复制字符串操作
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;
}