Libevent内存分配功能

Libevent内存管理相当简单。可以支持用于自定义的内存分配策略，这个时候就是用户自己写对应的内存分配策略例如可以写个简单的内存池，然后注册回调函数，供内存分配调用；也可以通过系统自带的malloc、realloc、free分配内存。可以通过是否定义_EVENT_DISABLE_MM_REPLACEMENT宏选择内存分配的策略。如果要定制自己的内存分配函数，就得在一开始配置编译Libevent库时候，加入–disable-malloc-replacement选项。默认情况下，加入了这个选项，那么将会在生成的event-config.h中，定义_EVENT_DISABLE_MM_REPLACEMENT这个宏。

//为了支持这两种策略，c语言肯定会进行对应的条件编译。
//event.c定义如下，用户可以通过event_set_mem_functions确定自己的分配策略
#ifndef _EVENT_DISABLE_MM_REPLACEMENT
static void *(*_mm_malloc_fn)(size_t sz) = NULL;
static void *(*_mm_realloc_fn)(void *p, size_t sz) = NULL;
static void (*_mm_free_fn)(void *p) = NULL;
void *
event_mm_malloc_(size_t sz)
{
    if (_mm_malloc_fn)
        return _mm_malloc_fn(sz);
    else
        return malloc(sz);
}
void *
event_mm_calloc_(size_t count, size_t size)
{
    if (_mm_malloc_fn) {
        size_t sz = count * size;
        void *p = _mm_malloc_fn(sz);
        if (p)
            memset(p, 0, sz);
        return p;
    } else
        return calloc(count, size);
}
char *
event_mm_strdup_(const char *str)
{
    if (_mm_malloc_fn) {
        size_t ln = strlen(str);
        void *p = _mm_malloc_fn(ln+1);
        if (p)
            memcpy(p, str, ln+1);
        return p;
    } else
#ifdef WIN32
        return _strdup(str);
#else
        return strdup(str);
#endif
}
void *
event_mm_realloc_(void *ptr, size_t sz)
{
    if (_mm_realloc_fn)
        return _mm_realloc_fn(ptr, sz);
    else
        return realloc(ptr, sz);
}
void
event_mm_free_(void *ptr)
{
    if (_mm_free_fn)
        _mm_free_fn(ptr);
    else
        free(ptr);
}
void
event_set_mem_functions(void *(*malloc_fn)(size_t sz),
            void *(*realloc_fn)(void *ptr, size_t sz),
            void (*free_fn)(void *ptr))
{
    _mm_malloc_fn = malloc_fn;
    _mm_realloc_fn = realloc_fn;
    _mm_free_fn = free_fn;
}
#endif

//mm-internal.h 声明对应的头文件，根据是否定义_EVENT_DISABLE_MM_REPLACEMENT合理选择
#ifndef _EVENT_DISABLE_MM_REPLACEMENT
void *event_mm_malloc_(size_t sz);
void *event_mm_calloc_(size_t count, size_t size);
char *event_mm_strdup_(const char *s);
void *event_mm_realloc_(void *p, size_t sz);
void event_mm_free_(void *p);
#define mm_malloc(sz) event_mm_malloc_(sz)
#define mm_calloc(count, size) event_mm_calloc_((count), (size))
#define mm_strdup(s) event_mm_strdup_(s)
#define mm_realloc(p, sz) event_mm_realloc_((p), (sz))
#define mm_free(p) event_mm_free_(p)
#else
#define mm_malloc(sz) malloc(sz)
#define mm_calloc(n, sz) calloc((n), (sz))
#define mm_strdup(s) strdup(s)
#define mm_realloc(p, sz) realloc((p), (sz))
#define mm_free(p) free(p)
#endif

定制内存分配函数

定制一个内存分配函数，可以统计libevent总共使用了多少内存空间，原理很简单，加入一个静态变量total_allocated，并在相应的内存分配函数里面统计total_allocated。实际使用需要加入对应的锁以支持多线程/进程。

#include <event2/event.h>
#include <sys/types.h>
#include <stdlib.h>
/*
这里为什么可以保证字节对齐，真的看不懂？
*/
/* This union's purpose is to be as big as the largest of all the
 * types it contains. */
union alignment {
    size_t sz;
    void *ptr;
    double dbl;
};
/* 保证字节对齐 */
#define ALIGNMENT sizeof(union alignment)

/* We need to do this cast-to-char* trick on our pointers to adjust
   them; doing arithmetic on a void* is not standard. */
#define OUTPTR(ptr) (((char*)ptr)+ALIGNMENT)
#define INPTR(ptr) (((char*)ptr)-ALIGNMENT)

static size_t total_allocated = 0;
static void *replacement_malloc(size_t sz)
{
    void *chunk = malloc(sz + ALIGNMENT);
    if (!chunk) return chunk;//malloc失败，返回
    total_allocated += sz;//加分配的字节
    *(size_t*)chunk = sz;
    return OUTPTR(chunk);
}
static void *replacement_realloc(void *ptr, size_t sz)
{
    size_t old_size = 0;
    if (ptr) {
        ptr = INPTR(ptr);
        old_size = *(size_t*)ptr;
    }
    ptr = realloc(ptr, sz + ALIGNMENT);
    if (!ptr)
        return NULL;
    *(size_t*)ptr = sz;
    total_allocated = total_allocated - old_size + sz;
    return OUTPTR(ptr);
}
static void replacement_free(void *ptr)
{
    ptr = INPTR(ptr);
    total_allocated -= *(size_t*)ptr;
    free(ptr);
}
void start_counting_bytes(void)
{
    event_set_mem_functions(replacement_malloc,
                            replacement_realloc,
                            replacement_free);
}//注册内存分配函数

//后续就可以通过读取total_allocated数值得到libevent占用的内存空间。

定制自己的内存分配函数需要注意的一些地方：

• 替换内存管理函数影响libevent随后的所有分配、调整大小和释放内存操作。所以必须保证在调用任何其他libevent函数之前进行定制。否则，Libevent可能用定制的free函数释放C语言库的malloc函数分配的内存。
• 定制的malloc和realloc函数返回的内存块应该具有和C库返回的内存块一样的地址对齐
• realloc函数应该正确处理realloc(NULL, sz)（也就是当作malloc(sz)处理）
• realloc函数应该正确处理realloc(ptr, 0)（也就是当作free(ptr)处理）
• 如果在多个线程中使用libevent，替代的内存管理函数需要是线程安全的
  如果要释放由Libevent函数分配的内存，并且已经定制了malloc和realloc函数，那么就应该使用定制的free函数释放。否则将会C语言标准库的free函数释放定制内存分配函数分配的内存，这将发生错误。所以三者要么全部不定制，要么全部定制。