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; }