VPP代码阅读中文注解--pool.h
/** @file
* @brief Fixed length block allocator.
Pools are built from clib vectors and bitmaps. Use pools when
repeatedly allocating and freeing fixed-size data. Pools are
fast, and avoid memory fragmentation.
*/
#ifndef included_pool_h
#define included_pool_h
#include
#include
#include 池基于动态数组和位图构建。主要用于需要频繁申请和释放固定大小内存的场合。先释放到池里面，再次申请的时候，从池里面获取，提升效率。这样做，也能有效的避免内存碎片的产生。
typedef struct
{
/** Bitmap of indices of free objects. */
uword *free_bitmap;
/** Vector of free indices. One element for each set bit in bitmap. */
u32 *free_indices;
/* The following fields are set for fixed-size, preallocated pools */
/** Maximum size of the pool, in elements */
u32 max_elts;
/** mmap segment info: base + length */
u8 *mmap_base;
u64 mmap_size;
} pool_header_t;
池的头部结构。
free_bitmap 当前池里面，哪些内存块是空闲的（未被使用的，置1），哪些是正在被使用的（置0）。
free_indices 一个动态数组，每一个元素是一个空闲块的编号，数组长度与上述位图中置1的bit数目相同。
池可以使用预分配的内存构建，也可以使用动态数组构建。下面3个元素仅用于预分配内存构建的池。
max_elts 当前池最多支持的元素的个数
mmap_base 当前池的内存首地址
mmap_size 当前池的内存大小，字节数目。
/** Align pool header so that pointers are naturally aligned. */
#define pool_aligned_header_bytes \
vec_aligned_header_bytes (sizeof (pool_header_t), sizeof (void *))
/** Get pool header from user pool pointer */
always_inline pool_header_t *
pool_header (void *v)
{
return vec_aligned_header (v, sizeof (pool_header_t), sizeof (void *));
}内存池头部大小（含动态数组头部）
以及根据0号内存块地址算出的内存池头部首地址
extern void _pool_init_fixed (void **, u32, u32);
extern void fpool_free (void *);
/** initialize a fixed-size, preallocated pool */
#define pool_init_fixed(pool,max_elts) \
{ \
_pool_init_fixed((void **)&(pool),sizeof(pool[0]),max_elts); \
}
pool.c中说明
/** Validate a pool */
always_inline void
pool_validate (void *v)
{
pool_header_t *p = pool_header (v);
uword i, n_free_bitmap;
if (!v)
return;
n_free_bitmap = clib_bitmap_count_set_bits (p->free_bitmap);
ASSERT (n_free_bitmap == vec_len (p->free_indices));
for (i = 0; i < vec_len (p->free_indices); i++)
ASSERT (clib_bitmap_get (p->free_bitmap, p->free_indices[i]) == 1);
}对内存池的数据结构进行校验，主要判断是否遭到了破坏。在开发和运行阶段能更快定位问题。
1. 位图中置1的数目与空闲内存块向量长度必须相等。
2. 位图中置1的bit的编号与空闲内存块中的编号必须一 一对应。
always_inline void
pool_header_validate_index (void *v, uword index)
{
pool_header_t *p = pool_header (v);
if (v)
vec_validate (p->free_bitmap, index / BITS (uword));
}
#define pool_validate_index(v,i) \
do { \
uword __pool_validate_index = (i); \
vec_validate_ha ((v), __pool_validate_index, \
pool_aligned_header_bytes, /* align */ 0); \
pool_header_validate_index ((v), __pool_validate_index); \
} while (0)给出需要使用的内存块编号，如果此内存块不存在，则需要动态扩展内存块向量，以及位图向量
/** Number of active elements in a pool.
* @return Number of active elements in a pool
*/
always_inline uword
pool_elts (void *v)
{
uword ret = vec_len (v);
if (v)
ret -= vec_len (pool_header (v)->free_indices);
return ret;
}当前正在使用的内存块数量等于池中总的内存块数量减去空闲状态的内存块数量
/** Number of elements in pool vector.
@note You probably want to call pool_elts() instead.
*/
#define pool_len(p) vec_len(p)
/** Number of elements in pool vector (usable as an lvalue)
@note You probably don't want to use this macro.
*/
#define _pool_len(p) _vec_len(p)当前内存池中总的内存块数量
/** Memory usage of pool header. */
always_inline uword
pool_header_bytes (void *v)
{
pool_header_t *p = pool_header (v);
if (!v)
return 0;
return vec_bytes (p->free_bitmap) + vec_bytes (p->free_indices);
}
/** Memory usage of pool. */
#define pool_bytes(P) (vec_bytes (P) + pool_header_bytes (P))
计算内存池的内存占用。实际上有3大块。
内存池所有内存块的占用
空闲内存块编号向量的占用
空闲内存块位图向量的占用
/** Local variable naming macro. */
#define _pool_var(v) _pool_##v
用于函数宏中的局部变量的命名，防止多个宏同时使用时，命名冲突。
/** Queries whether pool has at least N_FREE free elements. */
always_inline uword
pool_free_elts (void *v)
{
pool_header_t *p = pool_header (v);
uword n_free = 0;
if (v)
{
n_free += vec_len (p->free_indices);
/* Space left at end of vector? */
n_free += vec_capacity (v, sizeof (p[0])) - vec_len (v);
}
return n_free;
}计算当前内存池空间中，除了已经被使用的内存块，还可以分配的内存块数目。这里分为了2部分。一部分是当前处于空闲状态的内存块；另外一部分是在当前总内存空间中(之前已经向系统申请)，还没有被纳入内存池中的内存空间。
/** Allocate an object E from a pool P (general version).
First search free list. If nothing is free extend vector of objects.
*/
#define pool_get_aligned(P,E,A) \
do { \
pool_header_t * _pool_var (p) = pool_header (P); \
uword _pool_var (l); \
\
STATIC_ASSERT(A==0 || ((A % sizeof(P[0]))==0) || ((sizeof(P[0]) % A) == 0), \
"Pool aligned alloc of incorrectly sized object"); \
_pool_var (l) = 0; \
if (P) \
_pool_var (l) = vec_len (_pool_var (p)->free_indices); \
\
if (_pool_var (l) > 0) \
{ \
/* Return free element from free list. */ \
uword _pool_var (i) = _pool_var (p)->free_indices[_pool_var (l) - 1]; \
(E) = (P) + _pool_var (i); \
_pool_var (p)->free_bitmap = \
clib_bitmap_andnoti_notrim (_pool_var (p)->free_bitmap, \
_pool_var (i)); \
_vec_len (_pool_var (p)->free_indices) = _pool_var (l) - 1; \
} \
else \
{ \
/* fixed-size, preallocated pools cannot expand */ \
if ((P) && _pool_var(p)->max_elts) \
{ \
clib_warning ("can't expand fixed-size pool"); \
os_out_of_memory(); \
} \
/* Nothing on free list, make a new element and return it. */ \
P = _vec_resize (P, \
/* length_increment */ 1, \
/* new size */ (vec_len (P) + 1) * sizeof (P[0]), \
pool_aligned_header_bytes, \
/* align */ (A)); \
E = vec_end (P) - 1; \
} \
} while (0)
/** Allocate an object E from a pool P (unspecified alignment). */
#define pool_get(P,E) pool_get_aligned(P,E,0)从内存池中获取内存块。如果有空闲内存块，则先从空闲内存块获取，否则先扩展内存池，再获取内存块。
/** See if pool_get will expand the pool or not */
#define pool_get_aligned_will_expand(P,YESNO,A) \
do { \
pool_header_t * _pool_var (p) = pool_header (P); \
uword _pool_var (l); \
\
_pool_var (l) = 0; \
if (P) \
{ \
if (_pool_var (p)->max_elts) \
_pool_var (l) = _pool_var (p)->max_elts; \
else \
_pool_var (l) = vec_len (_pool_var (p)->free_indices); \
} \
\
/* Free elements, certainly won't expand */ \
if (_pool_var (l) > 0) \
YESNO=0; \
else \
{ \
/* Nothing on free list, make a new element and return it. */ \
YESNO = _vec_resize_will_expand \
(P, \
/* length_increment */ 1, \
/* new size */ (vec_len (P) + 1) * sizeof (P[0]), \
pool_aligned_header_bytes, \
/* align */ (A)); \
} \
} while (0)判断如果从内存池中获取一个内存块，是否需要进行内存扩展。这里的扩展的意思是：是否需要申请新的内存。与上一个场景中扩展的概念不同，上一个指的是数组大小是否变大。
#define pool_get_will_expand(P,YESNO) pool_get_aligned_will_expand(P,YESNO,0)简单封装
/** Use free bitmap to query whether given element is free. */
#define pool_is_free(P,E) \
({ \
pool_header_t * _pool_var (p) = pool_header (P); \
uword _pool_var (i) = (E) - (P); \
(_pool_var (i) < vec_len (P)) ? clib_bitmap_get (_pool_var (p)->free_bitmap, _pool_i) : 1; \
})根据位图来判断，某内存块是否空闲的
/** Use free bitmap to query whether given index is free */
#define pool_is_free_index(P,I) pool_is_free((P),(P)+(I))
简单封装，I 为内存块的编号
/** Free an object E in pool P. */
#define pool_put(P,E) \
do { \
pool_header_t * _pool_var (p) = pool_header (P); \
uword _pool_var (l) = (E) - (P); \
ASSERT (vec_is_member (P, E)); \
ASSERT (! pool_is_free (P, E)); \
\
/* Add element to free bitmap and to free list. */ \
_pool_var (p)->free_bitmap = \
clib_bitmap_ori_notrim (_pool_var (p)->free_bitmap, \
_pool_var (l)); \
\
/* Preallocated pool? */ \
if (_pool_var (p)->max_elts) \
{ \
ASSERT(_pool_var(l) < _pool_var (p)->max_elts); \
_pool_var(p)->free_indices[_vec_len(_pool_var(p)->free_indices)] = \
_pool_var(l); \
_vec_len(_pool_var(p)->free_indices) += 1; \
} \
else \
vec_add1 (_pool_var (p)->free_indices, _pool_var (l)); \
} while (0)
/** Free pool element with given index. */
#define pool_put_index(p,i) \
do { \
typeof (p) _e = (p) + (i); \
pool_put (p, _e); \
} while (0)释放内存块到内存池中，其实就是干2件事情。1，修改空闲位图；2，向空闲块向量增加元素。需要注意的是，如果是预分配的内存池，则不能再重新动态分配内存，所以向空闲块增加元素时，有一个上限(不能超过max_elts)。
/** Allocate N more free elements to pool (general version). */
#define pool_alloc_aligned(P,N,A) \
do { \
pool_header_t * _p; \
\
if ((P)) \
{ \
_p = pool_header (P); \
if (_p->max_elts) \
{ \
clib_warning ("Can't expand fixed-size pool"); \
os_out_of_memory(); \
} \
} \
\
(P) = _vec_resize ((P), 0, (vec_len (P) + (N)) * sizeof (P[0]), \
pool_aligned_header_bytes, \
(A)); \
_p = pool_header (P); \
vec_resize (_p->free_indices, (N)); \
_vec_len (_p->free_indices) -= (N); \
} while (0)
/** Allocate N more free elements to pool (unspecified alignment). */
#define pool_alloc(P,N) pool_alloc_aligned(P,N,0)内存池扩容N个内存块。这个时候，空闲内存块向量也一并扩容，但len不变，只是把内存空间先申请到，免得后面申请不到空间。其实位图内存块也可以先把内存占到，但是这里并没有这样做，毕竟位图占用的内存还是比较少，后面使用到时再申请。
/** Low-level free pool operator (do not call directly). */
always_inline void *
_pool_free (void *v)
{
pool_header_t *p = pool_header (v);
if (!v)
return v;
clib_bitmap_free (p->free_bitmap);
if (p->max_elts)
{
int rv;
rv = munmap (p->mmap_base, p->mmap_size);
if (rv)
clib_unix_warning ("munmap");
}
else
{
vec_free (p->free_indices);
vec_free_h (v, pool_aligned_header_bytes);
}
return 0;
}
/** Free a pool. */
#define pool_free(p) (p) = _pool_free(p)销毁内存池
/** Optimized iteration through pool.
@param LO pointer to first element in chunk
@param HI pointer to last element in chunk
@param POOL pool to iterate across
@param BODY operation to perform
Optimized version which assumes that BODY is smart enough to
process multiple (LOW,HI) chunks. See also pool_foreach().
*/
#define pool_foreach_region(LO,HI,POOL,BODY) \
do { \
uword _pool_var (i), _pool_var (lo), _pool_var (hi), _pool_var (len); \
uword _pool_var (bl), * _pool_var (b); \
pool_header_t * _pool_var (p); \
\
_pool_var (p) = pool_header (POOL); \
_pool_var (b) = (POOL) ? _pool_var (p)->free_bitmap : 0; \
_pool_var (bl) = vec_len (_pool_var (b)); \
_pool_var (len) = vec_len (POOL); \
_pool_var (lo) = 0; \
\
for (_pool_var (i) = 0; \
_pool_var (i) <= _pool_var (bl); \
_pool_var (i)++) \
{ \
uword _pool_var (m), _pool_var (f); \
_pool_var (m) = (_pool_var (i) < _pool_var (bl) \
? _pool_var (b) [_pool_var (i)] \
: 1); \
while (_pool_var (m) != 0) \
{ \
_pool_var (f) = first_set (_pool_var (m)); \
_pool_var (hi) = (_pool_var (i) * BITS (_pool_var (b)[0]) \
+ min_log2 (_pool_var (f))); \
_pool_var (hi) = (_pool_var (i) < _pool_var (bl) \
? _pool_var (hi) : _pool_var (len)); \
_pool_var (m) ^= _pool_var (f); \
if (_pool_var (hi) > _pool_var (lo)) \
{ \
(LO) = _pool_var (lo); \
(HI) = _pool_var (hi); \
do { BODY; } while (0); \
} \
_pool_var (lo) = _pool_var (hi) + 1; \
} \
} \
} while (0)
/** Iterate through pool.
@param VAR A variable of same type as pool vector to be used as an
iterator.
@param POOL The pool to iterate across.
@param BODY The operation to perform, typically a code block. See
the example below.
This macro will call @c BODY with each active pool element.
It is a bad idea to allocate or free pool element from within
@c pool_foreach. Build a vector of indices and dispose of them later.
Or call pool_flush.
@par Example
@code{.c}
proc_t *procs; // a pool of processes.
proc_t *proc; // pointer to one process; used as the iterator.
pool_foreach (proc, procs, ({
if (proc->state != PROC_STATE_RUNNING)
continue;
// check a running proc in some way
...
}));
@endcode
@warning Because @c pool_foreach is a macro, syntax errors can be
difficult to find inside @c BODY, let alone actual code bugs. One
can temporarily split a complex @c pool_foreach into a trivial
@c pool_foreach which builds a vector of active indices, and a
vec_foreach() (or plain for-loop) to walk the active index vector.
*/
#define pool_foreach(VAR,POOL,BODY) \
do { \
uword _pool_foreach_lo, _pool_foreach_hi; \
pool_foreach_region (_pool_foreach_lo, _pool_foreach_hi, (POOL), \
({ \
for ((VAR) = (POOL) + _pool_foreach_lo; \
(VAR) < (POOL) + _pool_foreach_hi; \
(VAR)++) \
do { BODY; } while (0); \
})); \
} while (0)遍历内存池中内存块的快速版本和普通版本。执行用户指定的操作BODY。
主要利用了位图的特性，一个uword为0，则uword内所有bit都为0。
找出连续的0 bit， 分别对他们进行遍历。
其实遍历过程是这样分成trunk进行遍历的。 10000 1 1 1000 10 1 100 1 , 每一个trunk中最多只设置了1个bit。
然后实际执行用户的BODY函数时，只针对0bit进行处理。
/** Returns pointer to element at given index.
ASSERTs that the supplied index is valid.
Even though one can write correct code of the form
@code
p = pool_base + index;
@endcode
use of @c pool_elt_at_index is strongly suggested.
*/
#define pool_elt_at_index(p,i) \
({ \
typeof (p) _e = (p) + (i); \
ASSERT (! pool_is_free (p, _e)); \
_e; \
})返回第 i 号内存块的地址。
/** Return next occupied pool index after @c i, useful for safe iteration. */
#define pool_next_index(P,I) \
({ \
pool_header_t * _pool_var (p) = pool_header (P); \
uword _pool_var (rv) = (I) + 1; \
\
_pool_var(rv) = \
(_pool_var (rv) < vec_len (P) ? \
clib_bitmap_next_clear (_pool_var (p)->free_bitmap, _pool_var(rv)) \
: ~0); \
_pool_var(rv) = \
(_pool_var (rv) < vec_len (P) ? \
_pool_var (rv) : ~0); \
_pool_var(rv); \
})从第i个内存块开始，获取下一个使用中的内存块。注意，使用中的内存块，位图中的值为0
/** Iterate pool by index. */
#define pool_foreach_index(i,v,body) \
for ((i) = 0; (i) < vec_len (v); (i)++) \
{ \
if (! pool_is_free_index ((v), (i))) \
do { body; } while (0); \
}遍历每一个使用中的内存块，执行指定的操作
/**
* @brief Remove all elements from a pool in a safe way
*
* @param VAR each element in the pool
* @param POOL The pool to flush
* @param BODY The actions to perform on each element before it is returned to
* the pool. i.e. before it is 'freed'
*/
#define pool_flush(VAR, POOL, BODY) \
{ \
uword *_pool_var(ii), *_pool_var(dv) = NULL; \
\
pool_foreach((VAR), (POOL), \
({ \
vec_add1(_pool_var(dv), (VAR) - (POOL)); \
})); \
vec_foreach(_pool_var(ii), _pool_var(dv)) \
{ \
(VAR) = pool_elt_at_index((POOL), *_pool_var(ii)); \
do { BODY; } while (0); \
pool_put((POOL), (VAR)); \
} \
vec_free(_pool_var(dv)); \
}以一种比较安全的方式释放所有的内存块到内存池中。其实就是针对没有释放的内存块编号，申请了一个新的向量空间来存储。
最后遍历这个新的向量空间，再处理。这个新的向量空间起一个辅助的作用。新的向量空间不需要进行任何的保护。