From d493480140eb933857552b0e908171f84cc36ff9 Mon Sep 17 00:00:00 2001 From: Benny Prijono Date: Mon, 21 Nov 2005 16:58:03 +0000 Subject: [PATCH] Small optimization in pool (removed used_size) git-svn-id: https://svn.pjsip.org/repos/pjproject/trunk@69 74dad513-b988-da41-8d7b-12977e46ad98 --- pjlib/include/pj/pool.h | 3 --- pjlib/include/pj/pool_i.h | 18 ++++++++++-------- pjlib/src/pj/pool.c | 26 +++++++++----------------- pjlib/src/pj/pool_caching.c | 9 +++++---- 4 files changed, 24 insertions(+), 32 deletions(-) diff --git a/pjlib/include/pj/pool.h b/pjlib/include/pj/pool.h index c47195c8c..93d67a906 100644 --- a/pjlib/include/pj/pool.h +++ b/pjlib/include/pj/pool.h @@ -151,9 +151,6 @@ struct pj_pool_t /** Current capacity allocated by the pool. */ pj_size_t capacity; - /** Number of memory used/allocated. */ - pj_size_t used_size; - /** Size of memory block to be allocated when the pool runs out of memory */ pj_size_t increment_size; diff --git a/pjlib/include/pj/pool_i.h b/pjlib/include/pj/pool_i.h index 39c04877e..05db29b74 100644 --- a/pjlib/include/pj/pool_i.h +++ b/pjlib/include/pj/pool_i.h @@ -29,24 +29,27 @@ PJ_IDEF(pj_size_t) pj_pool_get_capacity( pj_pool_t *pool ) PJ_IDEF(pj_size_t) pj_pool_get_used_size( pj_pool_t *pool ) { - return pool->used_size; + pj_pool_block *b = pool->block_list.next; + pj_size_t used_size = sizeof(pj_pool_t); + while (b != &pool->block_list) { + used_size += (b->cur - b->buf) + sizeof(pj_pool_block); + b = b->next; + } + return used_size; } -PJ_IDEF(void*) pj_pool_alloc_from_block( pj_pool_t *pool, - pj_pool_block *block, pj_size_t size ) +PJ_IDEF(void*) pj_pool_alloc_from_block( pj_pool_block *block, pj_size_t size ) { /* The operation below is valid for size==0. * When size==0, the function will return the pointer to the pool * memory address, but no memory will be allocated. */ if (size & (PJ_POOL_ALIGNMENT-1)) { - size &= ~(PJ_POOL_ALIGNMENT-1); - size += PJ_POOL_ALIGNMENT; + size = (size + PJ_POOL_ALIGNMENT) & ~(PJ_POOL_ALIGNMENT-1); } if ((unsigned)(block->end - block->cur) >= size) { void *ptr = block->cur; block->cur += size; - pool->used_size += size; return ptr; } return NULL; @@ -54,8 +57,7 @@ PJ_IDEF(void*) pj_pool_alloc_from_block( pj_pool_t *pool, PJ_IDEF(void*) pj_pool_alloc( pj_pool_t *pool, pj_size_t size) { - pj_pool_block *block = pool->block_list.next; - void *ptr = pj_pool_alloc_from_block(pool, block, size); + void *ptr = pj_pool_alloc_from_block(pool->block_list.next, size); if (!ptr) ptr = pj_pool_allocate_find(pool, size); return ptr; diff --git a/pjlib/src/pj/pool.c b/pjlib/src/pj/pool.c index 299668096..06cc009d2 100644 --- a/pjlib/src/pj/pool.c +++ b/pjlib/src/pj/pool.c @@ -45,7 +45,7 @@ static pj_pool_block *pj_pool_create_block( pj_pool_t *pool, pj_size_t size) pj_assert(size >= sizeof(pj_pool_block)); LOG((pool->obj_name, "create_block(sz=%u), cur.cap=%u, cur.used=%u", - size, pool->capacity, pool->used_size)); + size, pool->capacity, pj_pool_get_used_size(pool))); /* Request memory from allocator. */ block = (pj_pool_block*) @@ -57,7 +57,6 @@ static pj_pool_block *pj_pool_create_block( pj_pool_t *pool, pj_size_t size) /* Add capacity. */ pool->capacity += size; - pool->used_size += sizeof(pj_pool_block); /* Set block attribytes. */ block->cur = block->buf = ((unsigned char*)block) + sizeof(pj_pool_block); @@ -86,7 +85,7 @@ PJ_DEF(void*) pj_pool_allocate_find(pj_pool_t *pool, unsigned size) PJ_CHECK_STACK(); while (block != &pool->block_list) { - p = pj_pool_alloc_from_block(pool, block, size); + p = pj_pool_alloc_from_block(block, size); if (p != NULL) return p; block = block->next; @@ -97,7 +96,7 @@ PJ_DEF(void*) pj_pool_allocate_find(pj_pool_t *pool, unsigned size) if (pool->increment_size == 0) { LOG((pool->obj_name, "Can't expand pool to allocate %u bytes " "(used=%u, cap=%u)", - size, pool->used_size, pool->capacity)); + size, pj_pool_get_used_size(pool), pool->capacity)); (*pool->callback)(pool, size); return NULL; } @@ -118,13 +117,13 @@ PJ_DEF(void*) pj_pool_allocate_find(pj_pool_t *pool, unsigned size) LOG((pool->obj_name, "%u bytes requested, resizing pool by %u bytes (used=%u, cap=%u)", - size, block_size, pool->used_size, pool->capacity)); + size, block_size, pj_pool_get_used_size(pool), pool->capacity)); block = pj_pool_create_block(pool, block_size); if (!block) return NULL; - p = pj_pool_alloc_from_block(pool, block, size); + p = pj_pool_alloc_from_block(block, size); pj_assert(p != NULL); #if PJ_DEBUG if (p == NULL) { @@ -142,18 +141,10 @@ PJ_DEF(void) pj_pool_init_int( pj_pool_t *pool, pj_size_t increment_size, pj_pool_callback *callback) { - pj_pool_block *block; - PJ_CHECK_STACK(); pool->increment_size = increment_size; pool->callback = callback; - pool->used_size = sizeof(*pool); - block = pool->block_list.next; - while (block != &pool->block_list) { - pool->used_size += sizeof(pj_pool_block); - block = block->next; - } if (name) { if (strchr(name, '%') != NULL) { @@ -237,7 +228,6 @@ static void reset_pool(pj_pool_t *pool) block = pool->block_list.next; block->cur = block->buf; pool->capacity = block->end - (unsigned char*)pool; - pool->used_size = 0; } /* @@ -246,7 +236,8 @@ static void reset_pool(pj_pool_t *pool) PJ_DEF(void) pj_pool_reset(pj_pool_t *pool) { LOG((pool->obj_name, "reset(): cap=%d, used=%d(%d%%)", - pool->capacity, pool->used_size, pool->used_size*100/pool->capacity)); + pool->capacity, pj_pool_get_used_size(pool), + pj_pool_get_used_size(pool)*100/pool->capacity)); reset_pool(pool); } @@ -259,7 +250,8 @@ PJ_DEF(void) pj_pool_destroy_int(pj_pool_t *pool) pj_size_t initial_size; LOG((pool->obj_name, "destroy(): cap=%d, used=%d(%d%%), block0=%p-%p", - pool->capacity, pool->used_size, pool->used_size*100/pool->capacity, + pool->capacity, pj_pool_get_used_size(pool), + pj_pool_get_used_size(pool)*100/pool->capacity, ((pj_pool_block*)pool->block_list.next)->buf, ((pj_pool_block*)pool->block_list.next)->end)); diff --git a/pjlib/src/pj/pool_caching.c b/pjlib/src/pj/pool_caching.c index 5fa5ff741..2ae39ef99 100644 --- a/pjlib/src/pj/pool_caching.c +++ b/pjlib/src/pj/pool_caching.c @@ -174,7 +174,8 @@ static void cpool_release_pool( pj_pool_factory *pf, pj_pool_t *pool) /* Reset pool. */ PJ_LOG(4, (pool->obj_name, "recycle(): cap=%d, used=%d(%d%%)", - pool->capacity, pool->used_size, pool->used_size*100/pool->capacity)); + pool->capacity, pj_pool_get_used_size(pool), + pj_pool_get_used_size(pool)*100/pool->capacity)); pj_pool_reset(pool); /* @@ -207,9 +208,9 @@ static void cpool_dump_status(pj_pool_factory *factory, pj_bool_t detail ) PJ_LOG(3,("cachpool", " Dumping all active pools:")); while (pool != (void*)&cp->used_list) { PJ_LOG(3,("cachpool", " %12s: %8d of %8d (%d%%) used", pool->obj_name, - pool->used_size, pool->capacity, - pool->used_size*100/pool->capacity)); - total_used += pool->used_size; + pj_pool_get_used_size(pool), pool->capacity, + pj_pool_get_used_size(pool)*100/pool->capacity)); + total_used += pj_pool_get_used_size(pool); total_capacity += pool->capacity; pool = pool->next; }