isc_result_t
isc_taskpool_create(isc_taskmgr_t *tmgr, isc_mem_t *mctx,
unsigned int ntasks, unsigned int quantum,
isc_taskpool_t **poolp)
{
unsigned int i;
isc_taskpool_t *pool = NULL;
isc_result_t result;
INSIST(ntasks > 0);
/* Allocate the pool structure */
result = alloc_pool(tmgr, mctx, ntasks, quantum, &pool);
if (result != ISC_R_SUCCESS)
return (result);
/* Create the tasks */
for (i = 0; i < ntasks; i++) {
result = isc_task_create(tmgr, quantum, &pool->tasks[i]);
if (result != ISC_R_SUCCESS) {
isc_taskpool_destroy(&pool);
return (result);
}
isc_task_setname(pool->tasks[i], "taskpool", NULL);
}
*poolp = pool;
return (ISC_R_SUCCESS);
}
isc_result_t
isc_pool_create(isc_mem_t *mctx, unsigned int count,
isc_pooldeallocator_t free,
isc_poolinitializer_t init, void *initarg,
isc_pool_t **poolp)
{
isc_pool_t *pool = NULL;
isc_result_t result;
unsigned int i;
INSIST(count > 0);
/* Allocate the pool structure */
result = alloc_pool(mctx, count, &pool);
if (result != ISC_R_SUCCESS)
return (result);
pool->free = free;
pool->init = init;
pool->initarg = initarg;
/* Populate the pool */
for (i = 0; i < count; i++) {
result = init(&pool->pool[i], initarg);
if (result != ISC_R_SUCCESS) {
isc_pool_destroy(&pool);
return (result);
}
}
*poolp = pool;
return (ISC_R_SUCCESS);
}
cell* alloc_mem(){
//cell * c=(cell *)malloc(sizeof(cell));
cell *c;
trace(3,"mem \n");
if(mem_pool.top==0)
alloc_pool();
c=&(mem_pool.mem[mem_pool.free[mem_pool.top-1]]);
c->mem_addr=mem_pool.free[mem_pool.top-1];
mem_pool.top--;
mem_pool.cnt++;
return c;
}
isc_result_t
isc_pool_expand(isc_pool_t **sourcep, unsigned int count,
isc_pool_t **targetp)
{
isc_result_t result;
isc_pool_t *pool;
REQUIRE(sourcep != NULL && *sourcep != NULL);
REQUIRE(targetp != NULL && *targetp == NULL);
pool = *sourcep;
if (count > pool->count) {
isc_pool_t *newpool = NULL;
unsigned int i;
/* Allocate a new pool structure */
result = alloc_pool(pool->mctx, count, &newpool);
if (result != ISC_R_SUCCESS)
return (result);
newpool->free = pool->free;
newpool->init = pool->init;
newpool->initarg = pool->initarg;
/* Copy over the objects from the old pool */
for (i = 0; i < pool->count; i++) {
newpool->pool[i] = pool->pool[i];
pool->pool[i] = NULL;
}
/* Populate the new entries */
for (i = pool->count; i < count; i++) {
result = pool->init(&newpool->pool[i], pool->initarg);
if (result != ISC_R_SUCCESS) {
isc_pool_destroy(&pool);
return (result);
}
}
isc_pool_destroy(&pool);
pool = newpool;
}
*sourcep = NULL;
*targetp = pool;
return (ISC_R_SUCCESS);
}
isc_result_t
isc_taskpool_expand(isc_taskpool_t **sourcep, unsigned int size,
isc_taskpool_t **targetp)
{
isc_result_t result;
isc_taskpool_t *pool;
REQUIRE(sourcep != NULL && *sourcep != NULL);
REQUIRE(targetp != NULL && *targetp == NULL);
pool = *sourcep;
if (size > pool->ntasks) {
isc_taskpool_t *newpool = NULL;
unsigned int i;
/* Allocate a new pool structure */
result = alloc_pool(pool->tmgr, pool->mctx, size,
pool->quantum, &newpool);
if (result != ISC_R_SUCCESS)
return (result);
/* Copy over the tasks from the old pool */
for (i = 0; i < pool->ntasks; i++) {
newpool->tasks[i] = pool->tasks[i];
pool->tasks[i] = NULL;
}
/* Create new tasks */
for (i = pool->ntasks; i < size; i++) {
result = isc_task_create(pool->tmgr, pool->quantum,
&newpool->tasks[i]);
if (result != ISC_R_SUCCESS) {
isc_taskpool_destroy(&newpool);
return (result);
}
isc_task_setname(newpool->tasks[i], "taskpool", NULL);
}
isc_taskpool_destroy(&pool);
pool = newpool;
}
*sourcep = NULL;
*targetp = pool;
return (ISC_R_SUCCESS);
}
void *pallocsz(struct pool_rec *p, size_t sz) {
return alloc_pool(p, sz, TRUE);
}
void *palloc(struct pool_rec *p, size_t sz) {
return alloc_pool(p, sz, FALSE);
}
void *pallocsz(struct pool *p, int sz) {
return alloc_pool(p, sz, TRUE);
}
void *palloc(struct pool *p, int sz) {
return alloc_pool(p, sz, FALSE);
}