SIPCall::~SIPCall()
{
_debug ("SIPCall: Delete call");
_debug ("SDP: pool capacity %d", pj_pool_get_capacity (pool_));
_debug ("SDP: pool size %d", pj_pool_get_used_size (pool_));
delete local_sdp_;
pj_pool_release (pool_);
delete _audiortp;
}
static void cpool_dump_status(pj_pool_factory *factory, pj_bool_t detail )
{
#if PJ_LOG_MAX_LEVEL >= 3
pj_caching_pool *cp = (pj_caching_pool*)factory;
pj_lock_acquire(cp->lock);
PJ_LOG(3,("cachpool", " Dumping caching pool:"));
PJ_LOG(3,("cachpool", " Capacity=%u, max_capacity=%u, used_cnt=%u", \
cp->capacity, cp->max_capacity, cp->used_count));
if (detail) {
pj_pool_t *pool = (pj_pool_t*) cp->used_list.next;
pj_uint32_t total_used = 0, total_capacity = 0;
PJ_LOG(3,("cachpool", " Dumping all active pools:"));
while (pool != (void*)&cp->used_list) {
unsigned pool_capacity = pj_pool_get_capacity(pool);
PJ_LOG(3,("cachpool", " %12s: %8d of %8d (%d%%) used",
pj_pool_getobjname(pool),
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;
}
if (total_capacity) {
PJ_LOG(3,("cachpool", " Total %9d of %9d (%d %%) used!",
total_used, total_capacity,
total_used * 100 / total_capacity));
}
}
pj_lock_release(cp->lock);
#else
PJ_UNUSED_ARG(factory);
PJ_UNUSED_ARG(detail);
#endif
}
//
// Get current capacity.
//
pj_size_t get_capacity()
{
pj_pool_get_capacity(p_);
}
static void cpool_release_pool( pj_pool_factory *pf, pj_pool_t *pool)
{
pj_caching_pool *cp = (pj_caching_pool*)pf;
unsigned pool_capacity;
unsigned i;
PJ_CHECK_STACK();
PJ_ASSERT_ON_FAIL(pf && pool, return);
pj_lock_acquire(cp->lock);
#if PJ_SAFE_POOL
/* Make sure pool is still in our used list */
if (pj_list_find_node(&cp->used_list, pool) != pool) {
pj_assert(!"Attempt to destroy pool that has been destroyed before");
return;
}
#endif
/* Erase from the used list. */
pj_list_erase(pool);
/* Decrement used count. */
--cp->used_count;
pool_capacity = pj_pool_get_capacity(pool);
/* Destroy the pool if the size is greater than our size or if the total
* capacity in our recycle list (plus the size of the pool) exceeds
* maximum capacity.
. */
if (pool_capacity > pool_sizes[PJ_CACHING_POOL_ARRAY_SIZE-1] ||
cp->capacity + pool_capacity > cp->max_capacity)
{
pj_pool_destroy_int(pool);
pj_lock_release(cp->lock);
return;
}
/* Reset pool. */
PJ_LOG(6, (pool->obj_name, "recycle(): cap=%d, used=%d(%d%%)",
pool_capacity, pj_pool_get_used_size(pool),
pj_pool_get_used_size(pool)*100/pool_capacity));
pj_pool_reset(pool);
pool_capacity = pj_pool_get_capacity(pool);
/*
* Otherwise put the pool in our recycle list.
*/
i = (unsigned) (unsigned long) pool->factory_data;
pj_assert(i<PJ_CACHING_POOL_ARRAY_SIZE);
if (i >= PJ_CACHING_POOL_ARRAY_SIZE ) {
/* Something has gone wrong with the pool. */
pj_pool_destroy_int(pool);
pj_lock_release(cp->lock);
return;
}
pj_list_insert_after(&cp->free_list[i], pool);
cp->capacity += pool_capacity;
pj_lock_release(cp->lock);
}
static pj_pool_t* cpool_create_pool(pj_pool_factory *pf,
const char *name,
pj_size_t initial_size,
pj_size_t increment_sz,
pj_pool_callback *callback)
{
pj_caching_pool *cp = (pj_caching_pool*)pf;
pj_pool_t *pool;
int idx;
PJ_CHECK_STACK();
pj_lock_acquire(cp->lock);
/* Use pool factory's policy when callback is NULL */
if (callback == NULL) {
callback = pf->policy.callback;
}
/* Search the suitable size for the pool.
* We'll just do linear search to the size array, as the array size itself
* is only a few elements. Binary search I suspect will be less efficient
* for this purpose.
*/
if (initial_size <= pool_sizes[START_SIZE]) {
for (idx=START_SIZE-1;
idx >= 0 && pool_sizes[idx] >= initial_size;
--idx)
;
++idx;
} else {
for (idx=START_SIZE+1;
idx < PJ_CACHING_POOL_ARRAY_SIZE &&
pool_sizes[idx] < initial_size;
++idx)
;
}
/* Check whether there's a pool in the list. */
if (idx==PJ_CACHING_POOL_ARRAY_SIZE || pj_list_empty(&cp->free_list[idx])) {
/* No pool is available. */
/* Set minimum size. */
if (idx < PJ_CACHING_POOL_ARRAY_SIZE)
initial_size = pool_sizes[idx];
/* Create new pool */
pool = pj_pool_create_int(&cp->factory, name, initial_size,
increment_sz, callback);
if (!pool) {
pj_lock_release(cp->lock);
return NULL;
}
} else {
/* Get one pool from the list. */
pool = (pj_pool_t*) cp->free_list[idx].next;
pj_list_erase(pool);
/* Initialize the pool. */
pj_pool_init_int(pool, name, increment_sz, callback);
/* Update pool manager's free capacity. */
cp->capacity -= pj_pool_get_capacity(pool);
PJ_LOG(6, (pool->obj_name, "pool reused, size=%u", pool->capacity));
}
/* Put in used list. */
pj_list_insert_before( &cp->used_list, pool );
/* Mark factory data */
pool->factory_data = (void*) (long) idx;
/* Increment used count. */
++cp->used_count;
pj_lock_release(cp->lock);
return pool;
}
