PJ_DEF(pj_pool_t*) pj_pool_create_on_buf(const char *name,
void *buf,
pj_size_t size)
{
#if PJ_HAS_POOL_ALT_API == 0
struct creation_param param;
long align_diff;
PJ_ASSERT_RETURN(buf && size, NULL);
if (!is_initialized) {
if (pool_buf_initialize() != PJ_SUCCESS)
return NULL;
is_initialized = 1;
}
/* Check and align buffer */
align_diff = (long)buf;
if (align_diff & (PJ_POOL_ALIGNMENT-1)) {
align_diff &= (PJ_POOL_ALIGNMENT-1);
buf = (void*) (((char*)buf) + align_diff);
size -= align_diff;
}
param.stack_buf = buf;
param.size = size;
pj_thread_local_set(tls, ¶m);
return pj_pool_create_int(&stack_based_factory, name, size, 0,
pj_pool_factory_default_policy.callback);
#else
PJ_UNUSED_ARG(buf);
return pj_pool_create(NULL, name, size, size, NULL);
#endif
}
PJ_DEF(pj_pool_t*) pj_pool_create_on_buf(const char *name,
void *buf,
pj_size_t size)
{
struct creation_param param;
PJ_ASSERT_RETURN(buf && size, NULL);
if (!is_initialized) {
if (pool_buf_initialize() != PJ_SUCCESS)
return NULL;
is_initialized = 1;
}
param.stack_buf = buf;
param.size = size;
pj_thread_local_set(tls, ¶m);
return pj_pool_create_int(&stack_based_factory, name, size, 0,
pj_pool_factory_default_policy.callback);
}
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;
}
