Apache中内存分配子的分配和释放函数分析

void allocator_free(apr_allocator_t *allocator, apr_memnode_t *node)

{

    apr_memnode_t *next, *freelist = NULL;

    apr_uint32_t index, max_index;

    apr_uint32_t max_free_index, current_free_index;

#if APR_HAS_THREADS

    if (allocator->mutex)

        apr_thread_mutex_lock(allocator->mutex);

#endif /* APR_HAS_THREADS */

    max_index = allocator->max_index;

    max_free_index = allocator->max_free_index;

    current_free_index = allocator->current_free_index;

    /* Walk the list of submitted nodes and free them one by one,

     * shoving them in the right 'size' buckets as we go.

     */

    do {

        next = node->next;

        index = node->index;

        if (max_free_index != APR_ALLOCATOR_MAX_FREE_UNLIMITED

            && index + 1 > current_free_index) {

            node->next = freelist;

            freelist = node;

        }

        else if (index < MAX_INDEX) {

            /* Add the node to the appropiate 'size' bucket.  Adjust

             * the max_index when appropiate.

             */

            if ((node->next = allocator->free[index]) == NULL

                && index > max_index) {

                max_index = index;

            }

            allocator->free[index] = node;

            if (current_free_index >= index + 1)

                current_free_index -= index + 1;

            else

                current_free_index = 0;

        }

        else {

            /* This node is too large to keep in a specific size bucket,

             * just add it to the sink (at index 0).

             */

            node->next = allocator->free[0];

            allocator->free[0] = node;

            if (current_free_index >= index + 1)

                current_free_index -= index + 1;

            else

                current_free_index = 0;

        }

    } while ((node = next) != NULL);

    allocator->max_index = max_index;

    allocator->current_free_index = current_free_index;

#if APR_HAS_THREADS

    if (allocator->mutex)

        apr_thread_mutex_unlock(allocator->mutex);

#endif /* APR_HAS_THREADS */

    while (freelist != NULL) {

        node = freelist;

        freelist = node->next;

#if APR_ALLOCATOR_USES_MMAP

        munmap(node, (node->index+1) << BOUNDARY_INDEX);

#else

        free(node);

#endif

    }

}

分配子的创建                        apr_allocator_create

分配子的销毁                        apr_allocator_destroy

分配子的空间分配                 apr_allocator_alloc            调用分配子分配一定的空间

分配子的空间释放                 apr_allocator_free              释放分配子已经分配的空间，将它返回给分配子

分配子的其余设置

    apr_allocator_owner_set   设置分配子所属的内存池

    apr_allocator_owner_ger   获取分配子所属的内存池

    apr_allocator_max_free_set  设置分配子可以容纳的最大内存，即max_free_index字段，当然current_free_index会跟                                 着变化

    

分配子的创建和销毁相对较容易理解，这里主要分析分配子的空间分配和释放两个函数。

(1)apr_allocator_alloc

该函数内部，实际上调用的是allocator_alloc函数。下面具体分析：

static APR_INLINE apr_memnode_t *allocator_alloc(apr_allocator_t *allocator, apr_size_t  in_size)

{

    apr_memnode_t  *node, **ref;

    apr_uint32_t  max_index;

    apr_size_t  size, i, index;

   /*该函数所做的第一件事就是分配原则重新调整实际需要分配的空间大小。这里面的调整包括两个部分：首先是对内存结     点本身的大小进行调整，即APR_MEMNODE_T_SIZE；其次，需要分配的空间大小in_size和调整后的内存结点之和也得进行调整，调整后的大小用size表示。另外，这里是调整的原则是以4K对齐，因为BOUNDARY_SIZE为2^12，即4K  。*/ 

    size=APR_ALIGN(in_size + APR_MEMNODE_T_SIZE, BOUNDARY_SIZE);

    /*如果调整失败，则返回NULL。*/

    if (size < in_size)  {

        return NULL;

    }

    /* 如果调整后的大小小于规定的最小分配空间8K，则需要重新设置。*/

    if (size < MIN_ALLOC)

        size=MIN_ALLOC;

    /* 计算该空间大小size所对应的索引值. */

    index= (size >> BOUNDARY) -1;

    if (index > APR_UINT32_MAX)  {

        return NULL;

    }

    /* 首先判断需要分配的结点大小若属于规则结点，并且在分配子中存在，即index<=allocator->max_index   */

    if (index <= allocator->max_index)  {

#if APR_HAS_THREADS

        if (allocator->mutex)

            apr_thread_mutex_lock(allocator->mutex);

#endif

        max_index = allocator->max_index;

        /* ref 是一个二级指针，这里将它指向索引 index 所在数组的地址。  */

        ref=&allocator->free[index];

        i = index;

        /* 正常情况下，能够满足分配的最小结点就是index索引对应的链表结点，但该索引对应的链表可能为空，因此需要                               继续向后查找，直到第一个可用的不为空结点或者到索引为max_index链表。当循环退出的时候，有两种结果：第一，找到了一个索引值小于max_index的非空链表，这时便可以进入链表里进行实际的内存分配。第二，从index开始知道max_index索引之前的所有链表都是空的，这种情况下循环会退出，并且 i=max_index 。总的来说，循环退出后，ref指向对应的索引链表地址，i 为对应的索引值。*/

        while (*ref == NULL  &&  i<max_index)  {

            ref++;

            i++;

        }

        /* 无论是上述哪种情况，都是在规则结点里，下面就该对找到的结点进行处理，这里可能会出现两种情况：一、找到的链表有两个或以上的内存结点，这种情况下把第一个结点分配出去，并且把第二个内存结点链接到索引对应的数组上，这是通过 node = *ref 和 *ref = node->next  这两步实现的。二、找到的链表只有一个内存结点，这种情况下，当把该结点分配出去后，该索引对应的链表设置为空，这里同样是通过 *ref = node->next  实现的，另外，此时分配子的字段max_index必须相应的变化，一步一步往索引值减一方向判断，直到 *ref对应的链表不为空，ref--主要实现的是ref指针往数组小的方向移动，最后循环退出后ref指向最大内存块的数组元素上，max_index即为最大内存块的数组索引值。*/

        if ((node = *ref) != NULL)  {

            if ((*ref = node->next) == NULL &&  i>=max_index)  {

                do {

                    ref--;

                    max_index--;

                }

                while (*ref == NULL   &&  max_index>0);

                allocator->max_index=max_index;

            }

            /* 动态调整分配子字段current_free_index的大小，由于内存结点字段index计算时减掉一个1，这时必须加上。这里还有一个问题，当allocator->current_free_index  >  allocator->max_free_index这种情况出现时，多余的内存空间是如何释放掉给系统的。*/

            allocator->current_free_index+=node->index+1;

            if (allocator->current_free_index  >  allocator->max_free_index)

                allocator->current_free_index = allocator->max_free_index;

#if  APR_HAS_THREADS

            if (allocator->mutex)

                apr_thread_mutex_unlock(allocator->mutex);

#endif

            /*上述工作完成后，剩下就是返回结点了，返回前需要将结点取下来，因为此时node还是一个结点链表，因此需要设置结点node的next字段为NULL，至于为什么要设置first_avail字段，目前还没想清楚。 */

            node->next=NULL;

            node->first_avail = (char *)node + APR_MEMNODE_T_SIZE;

            return node;

        }