44 #ifndef included_pool_h 45 #define included_pool_h 72 #define pool_aligned_header_bytes \ 73 vec_aligned_header_bytes (sizeof (pool_header_t), sizeof (void *)) 82 extern void _pool_init_fixed (
void **,
u32,
u32);
86 #define pool_init_fixed(pool,max_elts) \ 88 _pool_init_fixed((void **)&(pool),sizeof(pool[0]),max_elts); \ 116 #define pool_validate_index(v,i) \ 118 uword __pool_validate_index = (i); \ 119 vec_validate_ha ((v), __pool_validate_index, \ 120 pool_aligned_header_bytes, 0); \ 121 pool_header_validate_index ((v), __pool_validate_index); \ 140 #define pool_len(p) vec_len(p) 146 #define _pool_len(p) _vec_len(p) 161 #define pool_bytes(P) (vec_bytes (P) + pool_header_bytes (P)) 164 #define _pool_var(v) _pool_##v 188 #define _pool_get_aligned_internal(P,E,A,Z) \ 190 pool_header_t * _pool_var (p) = pool_header (P); \ 191 uword _pool_var (l); \ 193 STATIC_ASSERT(A==0 || ((A % sizeof(P[0]))==0) || ((sizeof(P[0]) % A) == 0), \ 194 "Pool aligned alloc of incorrectly sized object"); \ 197 _pool_var (l) = vec_len (_pool_var (p)->free_indices); \ 199 if (_pool_var (l) > 0) \ 202 uword _pool_var (i) = _pool_var (p)->free_indices[_pool_var (l) - 1]; \ 203 (E) = (P) + _pool_var (i); \ 204 _pool_var (p)->free_bitmap = \ 205 clib_bitmap_andnoti_notrim (_pool_var (p)->free_bitmap, \ 207 _vec_len (_pool_var (p)->free_indices) = _pool_var (l) - 1; \ 208 CLIB_MEM_UNPOISON((E), sizeof((E)[0])); \ 213 if ((P) && _pool_var(p)->max_elts) \ 215 clib_warning ("can't expand fixed-size pool"); \ 216 os_out_of_memory(); \ 219 P = _vec_resize (P, \ 221 (vec_len (P) + 1) * sizeof (P[0]), \ 222 pool_aligned_header_bytes, \ 224 E = vec_end (P) - 1; \ 227 memset(E, 0, sizeof(*E)); \ 231 #define pool_get_aligned(P,E,A) _pool_get_aligned_internal(P,E,A,0) 234 #define pool_get_aligned_zero(P,E,A) _pool_get_aligned_internal(P,E,A,1) 237 #define pool_get(P,E) pool_get_aligned(P,E,0) 240 #define pool_get_zero(P,E) pool_get_aligned_zero(P,E,0) 243 #define pool_get_aligned_will_expand(P,YESNO,A) \ 245 pool_header_t * _pool_var (p) = pool_header (P); \ 246 uword _pool_var (l); \ 251 if (_pool_var (p)->max_elts) \ 252 _pool_var (l) = _pool_var (p)->max_elts; \ 254 _pool_var (l) = vec_len (_pool_var (p)->free_indices); \ 258 if (_pool_var (l) > 0) \ 263 YESNO = _vec_resize_will_expand \ 266 (vec_len (P) + 1) * sizeof (P[0]), \ 267 pool_aligned_header_bytes, \ 273 #define pool_get_will_expand(P,YESNO) pool_get_aligned_will_expand(P,YESNO,0) 276 #define pool_is_free(P,E) \ 278 pool_header_t * _pool_var (p) = pool_header (P); \ 279 uword _pool_var (i) = (E) - (P); \ 280 (_pool_var (i) < vec_len (P)) ? clib_bitmap_get (_pool_var (p)->free_bitmap, _pool_i) : 1; \ 284 #define pool_is_free_index(P,I) pool_is_free((P),(P)+(I)) 287 #define pool_put(P,E) \ 289 typeof (P) _pool_var(p__) = (P); \ 290 typeof (E) _pool_var(e__) = (E); \ 291 pool_header_t * _pool_var (p) = pool_header (_pool_var(p__)); \ 292 uword _pool_var (l) = _pool_var(e__) - _pool_var(p__); \ 293 ASSERT (vec_is_member (_pool_var(p__), _pool_var(e__))); \ 294 ASSERT (! pool_is_free (_pool_var(p__), _pool_var(e__))); \ 297 _pool_var (p)->free_bitmap = \ 298 clib_bitmap_ori_notrim (_pool_var (p)->free_bitmap, \ 302 if (_pool_var (p)->max_elts) \ 304 ASSERT(_pool_var(l) < _pool_var (p)->max_elts); \ 305 _pool_var(p)->free_indices[_vec_len(_pool_var(p)->free_indices)] = \ 307 _vec_len(_pool_var(p)->free_indices) += 1; \ 310 vec_add1 (_pool_var (p)->free_indices, _pool_var (l)); \ 312 CLIB_MEM_POISON(_pool_var(e__), sizeof(_pool_var(e__)[0])); \ 316 #define pool_put_index(p,i) \ 318 typeof (p) _e = (p) + (i); \ 323 #define pool_alloc_aligned(P,N,A) \ 325 pool_header_t * _p; \ 329 _p = pool_header (P); \ 332 clib_warning ("Can't expand fixed-size pool"); \ 333 os_out_of_memory(); \ 337 (P) = _vec_resize ((P), 0, (vec_len (P) + (N)) * sizeof (P[0]), \ 338 pool_aligned_header_bytes, \ 340 _p = pool_header (P); \ 341 vec_resize (_p->free_indices, (N)); \ 342 _vec_len (_p->free_indices) -= (N); \ 346 #define pool_alloc(P,N) pool_alloc_aligned(P,N,0) 355 #define pool_dup_aligned(P,A) \ 357 typeof (P) _pool_var (new) = 0; \ 358 pool_header_t * _pool_var (ph), * _pool_var (new_ph); \ 359 u32 _pool_var (n) = pool_len (P); \ 362 _pool_var (new) = _vec_resize (_pool_var (new), _pool_var (n), \ 363 _pool_var (n) * sizeof ((P)[0]), \ 364 pool_aligned_header_bytes, (A)); \ 365 clib_memcpy_fast (_pool_var (new), (P), \ 366 _pool_var (n) * sizeof ((P)[0])); \ 367 _pool_var (ph) = pool_header (P); \ 368 _pool_var (new_ph) = pool_header (_pool_var (new)); \ 369 _pool_var (new_ph)->free_bitmap = \ 370 clib_bitmap_dup (_pool_var (ph)->free_bitmap); \ 371 _pool_var (new_ph)->free_indices = \ 372 vec_dup (_pool_var (ph)->free_indices); \ 373 _pool_var (new_ph)->max_elts = _pool_var (ph)->max_elts; \ 384 #define pool_dup(P) pool_dup_aligned(P,0) 412 #define pool_free(p) (p) = _pool_free(p) 424 #define pool_foreach_region(LO,HI,POOL,BODY) \ 426 uword _pool_var (i), _pool_var (lo), _pool_var (hi), _pool_var (len); \ 427 uword _pool_var (bl), * _pool_var (b); \ 428 pool_header_t * _pool_var (p); \ 430 _pool_var (p) = pool_header (POOL); \ 431 _pool_var (b) = (POOL) ? _pool_var (p)->free_bitmap : 0; \ 432 _pool_var (bl) = vec_len (_pool_var (b)); \ 433 _pool_var (len) = vec_len (POOL); \ 434 _pool_var (lo) = 0; \ 436 for (_pool_var (i) = 0; \ 437 _pool_var (i) <= _pool_var (bl); \ 440 uword _pool_var (m), _pool_var (f); \ 441 _pool_var (m) = (_pool_var (i) < _pool_var (bl) \ 442 ? _pool_var (b) [_pool_var (i)] \ 444 while (_pool_var (m) != 0) \ 446 _pool_var (f) = first_set (_pool_var (m)); \ 447 _pool_var (hi) = (_pool_var (i) * BITS (_pool_var (b)[0]) \ 448 + min_log2 (_pool_var (f))); \ 449 _pool_var (hi) = (_pool_var (i) < _pool_var (bl) \ 450 ? _pool_var (hi) : _pool_var (len)); \ 451 _pool_var (m) ^= _pool_var (f); \ 452 if (_pool_var (hi) > _pool_var (lo)) \ 454 (LO) = _pool_var (lo); \ 455 (HI) = _pool_var (hi); \ 456 do { BODY; } while (0); \ 458 _pool_var (lo) = _pool_var (hi) + 1; \ 498 #define pool_foreach(VAR,POOL,BODY) \ 500 uword _pool_foreach_lo, _pool_foreach_hi; \ 501 pool_foreach_region (_pool_foreach_lo, _pool_foreach_hi, (POOL), \ 503 for ((VAR) = (POOL) + _pool_foreach_lo; \ 504 (VAR) < (POOL) + _pool_foreach_hi; \ 506 do { BODY; } while (0); \ 519 #define pool_elt_at_index(p,i) \ 521 typeof (p) _e = (p) + (i); \ 522 ASSERT (! pool_is_free (p, _e)); \ 527 #define pool_next_index(P,I) \ 529 pool_header_t * _pool_var (p) = pool_header (P); \ 530 uword _pool_var (rv) = (I) + 1; \ 533 (_pool_var (rv) < vec_len (P) ? \ 534 clib_bitmap_next_clear (_pool_var (p)->free_bitmap, _pool_var(rv)) \ 537 (_pool_var (rv) < vec_len (P) ? \ 538 _pool_var (rv) : ~0); \ 543 #define pool_foreach_index(i,v,body) \ 544 for ((i) = 0; (i) < vec_len (v); (i)++) \ 546 if (! pool_is_free_index ((v), (i))) \ 547 do { body; } while (0); \ 558 #define pool_flush(VAR, POOL, BODY) \ 560 uword *_pool_var(ii), *_pool_var(dv) = NULL; \ 562 pool_foreach((VAR), (POOL), \ 564 vec_add1(_pool_var(dv), (VAR) - (POOL)); \ 566 vec_foreach(_pool_var(ii), _pool_var(dv)) \ 568 (VAR) = pool_elt_at_index((POOL), *_pool_var(ii)); \ 569 do { BODY; } while (0); \ 570 pool_put((POOL), (VAR)); \ 572 vec_free(_pool_var(dv)); \ #define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
static void pool_header_validate_index(void *v, uword index)
#define vec_bytes(v)
Number of data bytes in vector.
static pool_header_t * pool_header(void *v)
Get pool header from user pool pointer.
#define pool_aligned_header_bytes
Align pool header so that pointers are naturally aligned.
static uword pool_header_bytes(void *v)
Memory usage of pool header.
static void pool_validate(void *v)
Validate a pool.
#define vec_free(V)
Free vector's memory (no header).
static void * vec_aligned_header(void *v, uword header_bytes, uword align)
#define vec_capacity(v, b)
Total number of bytes that can fit in vector with current allocation.
static uword clib_bitmap_get(uword *ai, uword i)
Gets the ith bit value from a bitmap.
Bitmaps built as vectors of machine words.
#define clib_bitmap_free(v)
Free a bitmap.
static uword clib_bitmap_count_set_bits(uword *ai)
Return the number of set bits in a bitmap.
#define vec_free_h(V, H)
Free vector's memory (general version)
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
#define clib_unix_warning(format, args...)
static uword pool_free_elts(void *v)
Queries whether pool has at least N_FREE free elements.
static uword pool_elts(void *v)
Number of active elements in a pool.