APR分析-内存篇

内存管理一直是让C程序员头痛的问题，作为一个通用接口集，APR当然也提供其自己的内存管理接口--APR

Pool。APR Pool作为整个APR的一个基础功能接口，直接影响着APR的设计风格。在这篇Blog中，我们就要和APR

Pool来一次“亲密接触”。(还是以Unix平台实现为例)

APR Pool源代码的位置在$(APR_HOME)/memory目录下，本篇blog着重分析unix子目录下的apr_pools.c文件内容，其相应头文件为$(APR_HOME)/include/apr_pools.h；在apr_pools.c中还实现了负责APR内部内存分配的APRallocator的相关操作接口(APR

allocator相关头文件为$(APR_HOME)/include/apr_allocator.h)。

一、APR Pool概述

我们平时常用的内存管理方式都是基于“request-style”的，即分配所请求大小的内存，使用之，销毁之。而APR

Pool的设计初衷是为Complex Application提供良好的内存管理接口，其使用方式与“request-style”有所不同。在$(APR_HOME)/docs/pool-design.htm文档中，设计者道出了“使用好”APR

Pool的几个Rules，同时也从侧面反映出APRPool的设计。

1、任何Object都不应该有自己的Pool，它应该在其构造函数的调用者的Pool中分配。因为一般调用者知道该Object的生命周期，并通过Pool管理之。也就是说Object无须自己调用"Close"

or "Free"，这些操作在Object所在Pool被摧毁时会被隐式调用的。

2、函数无须为了他们的行为而去Create/Destroy Pool，它们应该使用它们调用者传给它们的Pool。

3、为了防止内存无限制的增长，APR Pool建议当遇到unbounded

iteration时使用sub_pool，标准格式如下：

subpool = apr_poll_create(pool, NULL);

for (i = 0; i < n; ++i) {

apr_pool_clear(subpool);

... ...

do_operation(..., subpool);

}

apr_pool_destroy(subpool);

二、深入APR Pool

到目前为止我们已经知道了该如何“很好的”使用APR

Pool，接下来我们来深入APRPool的内部，看究竟有什么“奥秘”。

1、分析apr_pool_initialize

任何使用APR的应用程序一般都会调用apr_app_initalize来初始化APR的内部使用的数据结构，察看一下app_app_initialize的代码，你会发现apr_pool_initialize在被apr_app_initialize调用的apr_initialize中被调用，该函数用来初始化使用Pool所需的内部结构(用户无须直接调用apr_pool_initialize，在apr_app_initialize时它被自动调用，而apr_app_initialize又是APR

program调用的第一个function，其在apr_general.h中声明，在misc/unix/start.c中实现)。

apr_pool_initialize的伪码如下(这里先不考虑多线程的情况)：

static apr_byte_t apr_pools_initialized = 0;

static apr_pool_t *global_pool = NULL;

static apr_allocator_t *global_allocator = NULL;

apr_pool_initialize

{

如果(!apr_pools_initialized)

{

创建global_allocator; ------(1)

}

创建global_pool; -------(2)

给global_pool起名为"apr_global_pool";

}

(1) Pool和Allocator

每个Pool都有一个allocator相伴，这个allocator可能是Pool自己的，也可能是其ParentPool的。allocator的结构如下：

/* in apr_pools.c */

struct apr_allocator_t {

apr_uint32_t        max_index;

apr_uint32_t        max_free_index;

apr_uint32_t        current_free_index;

... ...[注1]

apr_pool_t         *owner;

apr_memnode_t     *free[MAX_INDEX];

};

在(1)调用后，global_allocator的所有xx_index字段都为0，owner-->NULL，free指针数组中的指针也都-->NULL。这里的index是大小的级别，这里最大级别为20(即MAX_INDEX

= 20)，free指针数组中free[0]所指的node大小为MIN_ALLOC大小，即8192，即2的13次幂。按此类推free[19]所指的node大小应为2的32次幂，即4G

byte。allocator_alloc中是通过index =(size >> BOUNDARY_INDEX) - 1来得到这一index的。allocator维护了一个index不同的memnode池，每一index级别上又有一个memnode

list，以后用户调用apr_palloc分配size大小内存时，allocaotr_alloc函数就会在free

memnode池中选和要寻找的size的index级别相同的memnode，而不是重新malloc一个size大小的memnode。另外要说明一点的是APR

Pool中所有ADT中的xx_index字段都是大小级别的概念。

(2)创建global_pool

在APR Pool初始化的时候，唯一创建一个Pool-- global_pool。apr_pool_t的非Debug版本如下：

/* in apr_pools.c */

struct apr_pool_t {

apr_pool_t           *parent;

apr_pool_t           *child;

apr_pool_t          *sibling;

apr_pool_t           **ref;

cleanup_t           *cleanups;

cleanup_t           *free_cleanups;

apr_allocator_t     *allocator;

struct process_chain *subprocesses;

apr_abortfunc_t       abort_fn;

apr_hash_t          *user_data;

constchar           *tag;

apr_memnode_t        *active;

apr_memnode_t        *self; /* The nodecontaining the pool itself */

char                *self_first_avail;

... ...

}

而apr_memnode_t的结构如下：

/* in apr_allocator.h */

struct apr_memnode_t {

apr_memnode_t*next;           /**< next memnode */

apr_memnode_t**ref;           /**< reference to self */

apr_uint32_t  index;           /**< size*/

apr_uint32_t  free_index;      /**< how much free */

char         *first_avail;     /**< pointer to first free memory */

char         *endp;           /**< pointer to end of free memory */

};

apr_pool_create_ex首先通过allocator寻找合适的node用于创建Pool，但由于global_allocator尚未分配过任何node，所以global_allocator创建一个新的node，该node大小为MIN_ALLOC(即8192)，该node的当前状态如下：

node -->|---------------|0

|                     |

|                     |

|                     |

|---------------|APR_MEMNODE_T_SIZE first_avail

|                     |

|                     |

|                     |

----------------- size(一般为8192) endp

其他属性值如下：

node->next = NULL;

node->index = (APR_UINT32_TRUNC_CAST)index; /*这里为1 */

创建完node后，我们将在该node上的avail

space划分出我们的global_pool来。划分后状态如下(pool与node关系)：

node -->|---------------|0 self = pool_active

|                      |

|                      |

|---------------|APR_MEMNODE_T_SIZE

|                       |

|                      |

|---------------|APR_MEMNODE_T_SIZE+SIZEOF_POOL_Tfirst_avail = pool->self_first_avail

|                        |

|                       |

----------------- size(一般为8192) endp

pool其他一些属性值(pool与pool之间关系)如下：

pool->allocator = global_allocator;

pool->child = NULL;

pool->sibling = NULL;

pool->ref = NULL;

也许现在你仍然不能看清楚APRPool的结构，无需着急，我们继续往下分析。

2、APR Sub_Pool创建(pool与pool之间关系)

上面我们已经初始化了global_pool，但是global_pool是不能直接拿来就用的，我们需要创建其sub_pool，也就是用户自己的pool。一般创建user的sub_pool我们都使用apr_pool_create宏，它只需要2个参数，并默认sub_pool继承parent_pool的allocator和abort_fn。在apr_pool_create内部调用的还是apr_pool_create_ex函数。我们来看一下创建sub_pool后pool之间的关系：

例:

static apr_pool_t *sub_pool = NULL;

apr_pool_create(&sub_pool, NULL);

这里sub_pool的创建过程与global_pool相似，也是先创建其承载体node，然后设置相关属性，使其成为global_pool的child_pool。创建完后global_pool和该sub_pool的关系如下图：

global_pool   sub_pool

-----------             / /          ------------

sibling --->NULL    /-------   parent

-----------            /            ------------

child ------------ /                sibling ----->NULL

-----------                           ------------

child  ------>NULL

------------

APR Pool是按照二叉树结构组织的，并采用“child-sibling”的链式存储方式，global_pool作为整个树的Root

Node。如果APR Pool中存在多个Pool，其节点结构关系如下：

/-child-->

/ --------Pool_level1-a

/ / parent   /|/    |

/|/_             |     | sibling

global_pool             |    |

/                 |    /|/

/-child-> Pool_level1-b

/|/                 |

-parent------

3、从pool中分配内存

上面我们已经拥有了一个sub_pool，我们现在就可以从sub_pool中分配内存了。APR提供了函数apr_palloc来做这件事情。

例如：apr_alloc(sub_pool,wanted_mem_size);

apr_palloc在真正分配内存前会把wanted_mem_size做一下处理。它使用APR_ALIGN_DEFAULT宏处理wanted_mem_size得到一个圆整到8的new_size，然后再在pool中分配new_size大小的内存，也就是说pool中存在的用户内存块的大小都是8的倍数。举个例子来说，如果wanted_mem_size=

30，apr_alloc实际会在pool中划分出32个字节的空间。

apr_palloc的工作流程简单描述是这样的：

a)如果在pool->active node的avail space足够满足要申请的内存大小size时，则直接返回active->first_avail，并调整active->first_avail=

active->first_avail + size；

b)如果a)不满足，则察看active->next这个node满足与否；如果满足则将返回所要内存，并将该node设为active

node，将以前的active node放在新active node的next位置上;

c)如果b)也不满足，则新创建一个memnode，这个node可能为新创建的，也可能是从allocator的free

memnode池中取出的，取决于当时整个Pool的状态。

从上面我们也可以看出node分为2类，一种是作为pool的承载体，但pool结构的空间不足以完全占满一个node，所以也可以用来分配用户内存；另一种就是完全用于分配用户内存的了。每个pool有一个node

list，当然这个list中包括它自己所在的node了。

4、apr_pool_clear和apr_pool_destroy

创建和分配结束后，我们需要clear或者destroy掉Pool。

clear和destroy的区别在于clear并不真正free内存，只是清理便于以后alloc时重用，而destroy则是真正的free掉内存了。

三、总结

本文并未说明APR Pool有哪些优点或缺点(除了概述中的一些Rules)，仅是把其来龙去脉弄清。

[注1]

在本文中出现的"......"的符号表示与多线程相关的字段和代码的省略。