pool_pt mem_pool_open(size_t size, alloc_policy policy) {
// verify that the pool store is allocated
if(pool_store == NULL){
return NULL;
};
// resize the pool store if nessisary
_mem_resize_pool_store();
// allocate a new mem pool mgr
pool_mgr_t *pool_manager;
pool_manager = calloc(1,sizeof(pool_mgr_t));
// ccheck if pool mgr was allocated properly
if(pool_manager == NULL){
return NULL;
};
// allocate a new memory pool
pool_manager->pool.mem = malloc(size);
// check if pool was allocated properly, if not, deallocate pool mgr
if(pool_manager->pool.mem == NULL){
free(pool_manager);
return NULL;
};
// allocate a new node heap
pool_manager->node_heap = calloc(MEM_NODE_HEAP_INIT_CAPACITY, sizeof(node_t));
pool_manager->total_nodes = MEM_NODE_HEAP_INIT_CAPACITY;
// check if node heap was allocated properly, if not, deallocate pool mgr and pool
if(pool_manager->node_heap == NULL){
free(pool_manager->pool.mem);
free(pool_manager);
return NULL;
};
// allocate a new gap index
pool_manager->gap_ix = calloc(MEM_GAP_IX_INIT_CAPACITY,sizeof(gap_t));
pool_manager->gap_ix_capacity = MEM_GAP_IX_INIT_CAPACITY;
// check if gap index was allocated properly, if not, deallocate pool mgr, node heap, and pool
if(pool_manager->gap_ix == NULL){
free(pool_manager->pool.mem);
free(pool_manager->node_heap);
free(pool_manager);
return NULL;
};
//initialize the pool
pool_manager->pool.total_size = size;
pool_manager->pool.alloc_size = 0;
pool_manager->pool.policy = policy;
pool_manager->pool.num_gaps = 1;
pool_manager->pool.num_allocs = 0;
// initialize top node of node heap
pool_manager->node_heap[0].next = NULL;
pool_manager->node_heap[0].prev = NULL;
pool_manager->node_heap[0].allocated = 0;
pool_manager->node_heap[0].used = 1;
pool_manager->node_heap[0].alloc_record.size = pool_manager->pool.total_size;
pool_manager->node_heap[0].alloc_record.mem = pool_manager->pool.mem;
pool_manager->used_nodes = 1;
// initialize top node of gap index
pool_manager->gap_ix[0].node = &pool_manager->node_heap[0];
// assign pool manager to the pool store array index
pool_store[pool_store_size] = pool_manager;
pool_store_size++;
// return the address of the mgr, cast to (pool_pt)
return (pool_pt) pool_manager;
}
pool_pt mem_pool_open(size_t size, alloc_policy policy)
{
// make sure there the pool store is allocated
if(pool_store_size == 0);
else{
return NULL;
}
if(pool_store != NULL);
else{
return NULL;
}
// expand the pool store, if necessary
if (((float) pool_store_size / pool_store_capacity) > MEM_POOL_STORE_FILL_FACTOR && _mem_resize_pool_store() == ALLOC_FAIL) {
return NULL;
}
// allocate a new mem pool mgr
pool_mgr_pt pool_mgr = (pool_mgr_pt) malloc(sizeof(pool_mgr_t));
// check success, on error return null
if (pool_mgr == NULL) {
printf("pool mgr not allocated");
return NULL;
}
// allocate a new memory pool
pool_mgr->pool.mem = (char*) malloc(size);
// check success, on error deallocate mgr and return null
if (pool_mgr->pool.mem == NULL)
{
free(pool_mgr);
printf("mem pool not allocated");
return NULL;
}
// allocate a new node heap
pool_mgr->node_heap = (node_pt) calloc (MEM_NODE_HEAP_INIT_CAPACITY ,sizeof(node_t));
// check success, on error deallocate mgr/pool and return null
if (pool_mgr->node_heap == NULL)
{
free(pool_mgr);
printf("node heap not allocated");
return NULL;
}
// allocate a new gap index
pool_mgr->gap_ix = (gap_pt) calloc (MEM_GAP_IX_INIT_CAPACITY, sizeof(gap_t));
// check success, on error deallocate mgr/pool/heap and return null
if (pool_mgr->gap_ix == NULL)
{
free(pool_mgr->node_heap);
free(&pool_mgr[0].pool);
free(pool_mgr);
printf("gap index not allocated");
return NULL;
}
// assign all the pointers and update meta data:
// initialize top node of node heap
pool_mgr->node_heap[0].alloc_record.mem = pool_mgr->pool.mem;
pool_mgr->node_heap[0].alloc_record.size = size;
pool_mgr->node_heap[0].next = NULL;
pool_mgr->node_heap[0].prev = NULL;
pool_mgr->node_heap[0].used = 0;
pool_mgr->node_heap[0].allocated = 0;
// initialize top node of gap index
pool_mgr->gap_ix[0].node = pool_mgr->node_heap;
pool_mgr->gap_ix[0].size = size;
// initialize pool mgr
pool_mgr->pool.total_size = size;
pool_mgr->pool.policy = policy;
pool_mgr->used_nodes = 1;
pool_mgr->pool.num_gaps = 1;
pool_mgr->pool.alloc_size = 0;
pool_mgr->pool.num_allocs = 0;
// link pool mgr to pool store
int i = 0;
while (pool_store[i] != NULL) {
++i;
}
pool_store[i] = pool_mgr;
pool_store_size = 1;
pool_mgr->total_nodes = MEM_NODE_HEAP_INIT_CAPACITY;
pool_mgr->gap_ix_capacity = MEM_GAP_IX_INIT_CAPACITY;
// return the address of the mgr, cast to (pool_pt)
return (pool_pt) pool_mgr;
}
pool_pt mem_pool_open(size_t size, alloc_policy policy) {
// make sure there the pool store is allocated
if (pool_store == NULL)
return NULL;
// expand the pool store, if necessary
_mem_resize_pool_store();
// allocate a new mem pool mgr
pool_mgr_pt pool_mgr = malloc(sizeof(pool_mgr_t));
// check success, on error return null
if (pool_mgr == NULL)
return NULL;
// allocate a new memory pool
pool_mgr->pool.mem = malloc(size);
pool_mgr->pool.policy = policy;
pool_mgr->pool.total_size = size;
// check success, on error deallocate mgr and return null
if (pool_mgr->pool.mem == NULL) {
free(pool_mgr->pool.mem);
free(pool_mgr);
return NULL;
}
// allocate a new node heap
pool_mgr->node_heap = calloc(MEM_NODE_HEAP_INIT_CAPACITY, sizeof(node_t));
pool_mgr->total_nodes = MEM_NODE_HEAP_INIT_CAPACITY;
// check success, on error deallocate mgr/pool and return null
if (pool_mgr->node_heap == NULL) {
free(pool_mgr->pool.mem);
free(pool_mgr->node_heap);
free(pool_mgr);
return NULL;
}
// allocate a new gap index
pool_mgr->gap_ix = calloc(MEM_GAP_IX_INIT_CAPACITY, sizeof(gap_t));
pool_mgr->gap_ix_capacity = MEM_GAP_IX_INIT_CAPACITY;
// check success, on error deallocate mgr/pool/heap and return null
if (pool_mgr->gap_ix == NULL) {
free(pool_mgr->pool.mem);
free(pool_mgr->node_heap);
free(pool_mgr->gap_ix);
free(pool_mgr);
return NULL;
}
// assign all the pointers and update meta data:
// initialize top node of node heap
pool_mgr->node_heap[0].alloc_record.mem = pool_mgr->pool.mem;
pool_mgr->node_heap[0].alloc_record.size = size;
pool_mgr->node_heap[0].used = 1;
pool_mgr->used_nodes = 1;
pool_mgr->pool.num_gaps = 0;
// initialize top node of gap index
_mem_add_to_gap_ix(pool_mgr, size, &pool_mgr->node_heap[0]);
//pool_mgr->gap_ix[0].node = &pool_mgr->node_heap[0];
//pool_mgr->gap_ix[0].node->alloc_record.size = size;
// link pool mgr to pool store
pool_store[pool_store_size] = pool_mgr;
pool_store_size++;
// return the address of the mgr, cast to (pool_pt)
return (pool_pt) pool_mgr;
}
