内存管理器（内存池）

讨论QQ群：135202158

在一些应用场合，比如一个繁忙的服务器程序中，服务器频繁地接受并处理用户请求，如果每次处理都需要从系统动态地申请和释放内存，由于此操作开销较大，会加大处理时延；另一方面，此开销造成的累积效应也是很大的。

对此我们可以举一个生活中的例子：假设一个烟鬼一天抽10包烟（这有点太多了，假设啊），如果他每次去商店只买一包烟，他一天就要往商店跑10次，很麻烦；如果他一次买一条（10 包）放着，那么他一天之内就可以不用再跑商店了，想抽烟的时候，直接拿抽剩下的就行了。

这种预先分配所有所需资源、在运行时直接调配的思想，都可以称为池化策略，比如内存池和线程池。其实上面烟鬼买烟的例子，举的并不是特别恰当。因为池中的资源（内存或线程），在使用完之后，是可以回收的，而烟抽完就没有了。

这篇随笔主要讲内存池，线程池见http://www.cnblogs.com/zzqcn/p/3625452.html。

要实现内存池，除了预先分配一块大内存块之外，我们还需要设计一个用来记录当前内存使用情况的数据结构，它至少需要记录以下信息：

1. 某个内存块是否可用
2. 内存块的起始地址
3. 内存块的大小

我们可以设计一个双向循环链表来保存内存使用信息，而表中每一个结点如下图所示：

如果用C++语言表示，则如下（mbl：memory block list）：

struct mblnode
{
    mblnode*    left;
    mblnode*    right;
    bool        tag;
    size_t      offset;
    size_t      size;
};

另外，还需要制订内存分配和回收的策略。这些策略包括：

1. 从哪个地方开始分配
2. 用户申请多少，就分配多少，还是有一个分配最小值
3. 回收某个内存块之后，如何和其他空闲块合并成大的空闲块
4. 回收内存块之后，下次分配的位置是否变化

讨论分配和策略之前，我们先设定一个当前指针p，它指向一个可用块，每次内存分配都从这个可用块进行。

对于1：每次分配后，都将p指向已分配块的下一个可用内存块；
对于2：设定一个最小值MINSIZE，当用户申请的内存块大小小于MINSIZE时，就分配MINSIZE大小的内存块给用户；
对于3：回收某块内存后，需要根据多种不同情况，与周围的可用块进行合并，形成更大的可用块；
对于4：回收内存后，应比较新合并的可用块的大小和p指向的内存块的大小，并将p指向更大的内存块。

上述分配回收策略，都减小了内存池中的碎片，提升分配效率。

下面用图演示一下分配过程。假设内存池大小为12，绿色代表空闲块，红色代表已用块，p为当前分配指针，下面的数据结构是我们的双向循环链表，链表结点中第1项是是否可用的标志，打勾表示可用，打x表示已用，第2项表示内存块起始地址，第3项表示此块的大小。下图表示从完全空闲的内存池连续分配大小为2、5的两块内存的情况：

 下图表示回收一块内存时与周围空闲块合并的多种情况，每一种情况都需要小心地编码：

完整C++代码：

/*
 * 内存池实现 - 使用双循环链表.
 * Author: 赵子清
 * Blog: http://www.cnblogs.com/zzqcn
 **/


#include <cstdlib>
#include <cstdio>


struct mblnode
{
    mblnode*    left;
    mblnode*    right;
    bool        tag;
    size_t      offset;
    size_t      size;
};


#define     MAXBUFF     12
#define     MINSIZE     2

char        BUFF[MAXBUFF];
mblnode*    mbl = NULL;

int     my_init();
int     my_deinit();
char*   my_new(size_t _n);
int     my_del(char* _p);
void    my_merge_nil  (mblnode* _p);
void    my_merge_left (mblnode* _p);
void    my_merge_right(mblnode* _p);
void    my_merge_both (mblnode* _p);
int     my_print_mbl();


int  main(int argc, char** argv)
{
    my_init();

    // new
    char* p = my_new(2);
    if (p != NULL)
    {
        p[0] = 'a';
        p[1] = 'b';
    }
    my_print_mbl();

    // new
    char* p2 = my_new(5);
    if (p2 != NULL)
    {
        p2[0] = 'c';
        p2[1] = 'd';
        p2[2] = 'e';
        p2[3] = 'f';
        p2[4] = 'g';
    }
    my_print_mbl();

    // new
    char* p3 = my_new(2);
    if (p3 != NULL)
    {
        p3[0] = 'h';
        p3[1] = 'i';
    }
    my_print_mbl();

    my_del(p2);     my_print_mbl();
    my_del(p);      my_print_mbl();
    my_del(p3);     my_print_mbl();

    my_deinit();
    
    system("PAUSE");
    return 0;
}


int  my_init()
{
    if (mbl != NULL)
        my_deinit();

    mblnode* p = new mblnode;
    p->left = p->right = p;
    p->offset = 0;
    p->size = MAXBUFF;
    p->tag = false;

    mbl = p;

    return 0;
}


int  my_deinit()
{
    if (NULL == mbl)
        return 0;

    mblnode*  p = NULL;
    mblnode*  q = NULL;

    p = mbl;
    do
    {
        q = p;
        p = p->right;
        delete q;   q = NULL;
    } while (p != mbl);

    return 0;
}


char*  my_new(size_t _n)
{
    mblnode*  p = NULL;
    char*     ret = NULL;

    if (NULL == mbl)
        return NULL;

    if (_n < MINSIZE)
        _n = MINSIZE;

    for (p = mbl; p->right != mbl; p = p->right)
    {
        if (p->tag || p->size < _n)
            continue;
        else
            break;
    }

    if (NULL == p || p->size < _n)
        return NULL;

    if (p->size > _n)
    {
        mblnode*  pnew = new mblnode;
        p->left->right = pnew;
        pnew->left  = p->left;
        pnew->right = p;
        pnew->offset = p->offset;
        pnew->size = _n;
        pnew->tag = true;

        p->size -= _n;
        p->offset += _n;
        p->left = pnew;

        mbl = p;
        ret = BUFF + pnew->offset;
    }
    else if (p->size == _n)
    {
        p->tag = true;
        
        mbl = p;
        ret = BUFF + p->offset;
    }

    return ret;
}


int  my_del(char* _p)
{
    if (NULL == _p || _p < BUFF || _p >= BUFF + MAXBUFF)
        return -1;

    int  ret = -1;
    mblnode*  p = NULL;
    mblnode*  pcur = NULL;

    p = mbl;
    do
    {
        if ((p->offset + BUFF) == _p)
        {
            pcur = p;
            break;
        }
        p = p->right;
    } while (p != mbl);
   

    if (NULL == pcur)
        return -1;

    /* left & right are all NOT free */
    if (pcur->left->tag && pcur->right->tag)
    {
        my_merge_nil(pcur);
        ret = 0;
    }
    /* left is free */
    else if (!pcur->left->tag && pcur->right->tag)
    {
        if (pcur->offset != 0)
            my_merge_left(pcur);
        /* upper boundary */
        else
            my_merge_nil(pcur);

        ret = 0;
    }
    /* right is free */
    else if (pcur->left->tag && !pcur->right->tag)
    {
        if (pcur->right->offset != 0)
            my_merge_right(pcur);
        /* lower boundary */
        else
            my_merge_nil(pcur);

        ret = 0;
    }
    /* left and right are all free */
    else if (!pcur->left->tag && !pcur->right->tag)
    {
        //if (0 == pcur->left->offset)
        if (0 == pcur->offset)
            my_merge_right(pcur);
        else if (0 == pcur->right->offset)
            my_merge_left(pcur);
        else
            my_merge_both(pcur);
        
        ret = 0;
    }

    return ret;
}


void  my_merge_nil(mblnode* _p)
{
    _p->tag = false;
    if (mbl->size < _p->size)
        mbl = _p;
}

void  my_merge_left(mblnode* _p)
{
    _p->left->right = _p->right;
    _p->right->left = _p->left;
    _p->left->size += _p->size;

    if (mbl->size < _p->left->size)
        mbl = _p->left;

    delete _p;    _p = NULL;
}

void  my_merge_right(mblnode* _p)
{
    _p->left->right = _p->right;
    _p->right->left = _p->left;
    _p->right->offset = _p->offset;
    _p->right->size += _p->size;

    if (mbl->size < _p->right->size)
        mbl = _p->right;

    delete _p;    _p = NULL;
}

void  my_merge_both(mblnode* _p)
{
    _p->left->right = _p->right->right;
    _p->right->right->left = _p->left;

    _p->left->size += _p->size + _p->right->size;

    if (mbl->size < _p->left->size)
        mbl = _p->left;

    delete _p->right;    _p->right = NULL;
    delete _p;    _p = NULL;
}


int  my_print_mbl()
{
    if (NULL == mbl)
        return -1;

    mblnode* p = mbl;

    do
    {
        printf("[%c, %d, %d]
",
                p->tag ? 'x' : 'v',
                p->offset,
                p->size);
        p = p->right;
    } while (p != mbl);

    printf("------------------
");

    return 0;
}

输出结果：

[v, 2, 10]
[x, 0, 2]
------------------
[v, 7, 5]
[x, 0, 2]
[x, 2, 5]
------------------
[v, 9, 3]
[x, 0, 2]
[x, 2, 5]
[x, 7, 2]
------------------
[v, 2, 5]
[x, 7, 2]
[v, 9, 3]
[x, 0, 2]
------------------
[v, 0, 7]
[x, 7, 2]
[v, 9, 3]
------------------
[v, 0, 12]
------------------
请按任意键继续. . .

【参考资料】

《数据结构（C语言版）》，严蔚敏 吴伟民 编著，清华大学出版社。