Permalink
Cannot retrieve contributors at this time
158 lines (126 sloc)
3.47 KB
| /* | |
| * Memory Pool implementation logic. | |
| */ | |
| #include "cache.h" | |
| #include "mem-pool.h" | |
| #define BLOCK_GROWTH_SIZE (1024 * 1024 - sizeof(struct mp_block)) | |
| /* | |
| * Allocate a new mp_block and insert it after the block specified in | |
| * `insert_after`. If `insert_after` is NULL, then insert block at the | |
| * head of the linked list. | |
| */ | |
| static struct mp_block *mem_pool_alloc_block(struct mem_pool *pool, | |
| size_t block_alloc, | |
| struct mp_block *insert_after) | |
| { | |
| struct mp_block *p; | |
| pool->pool_alloc += sizeof(struct mp_block) + block_alloc; | |
| p = xmalloc(st_add(sizeof(struct mp_block), block_alloc)); | |
| p->next_free = (char *)p->space; | |
| p->end = p->next_free + block_alloc; | |
| if (insert_after) { | |
| p->next_block = insert_after->next_block; | |
| insert_after->next_block = p; | |
| } else { | |
| p->next_block = pool->mp_block; | |
| pool->mp_block = p; | |
| } | |
| return p; | |
| } | |
| void mem_pool_init(struct mem_pool *pool, size_t initial_size) | |
| { | |
| memset(pool, 0, sizeof(*pool)); | |
| pool->block_alloc = BLOCK_GROWTH_SIZE; | |
| if (initial_size > 0) | |
| mem_pool_alloc_block(pool, initial_size, NULL); | |
| } | |
| void mem_pool_discard(struct mem_pool *pool, int invalidate_memory) | |
| { | |
| struct mp_block *block, *block_to_free; | |
| block = pool->mp_block; | |
| while (block) | |
| { | |
| block_to_free = block; | |
| block = block->next_block; | |
| if (invalidate_memory) | |
| memset(block_to_free->space, 0xDD, ((char *)block_to_free->end) - ((char *)block_to_free->space)); | |
| free(block_to_free); | |
| } | |
| pool->mp_block = NULL; | |
| pool->pool_alloc = 0; | |
| } | |
| void *mem_pool_alloc(struct mem_pool *pool, size_t len) | |
| { | |
| struct mp_block *p = NULL; | |
| void *r; | |
| /* round up to a 'uintmax_t' alignment */ | |
| if (len & (sizeof(uintmax_t) - 1)) | |
| len += sizeof(uintmax_t) - (len & (sizeof(uintmax_t) - 1)); | |
| if (pool->mp_block && | |
| pool->mp_block->end - pool->mp_block->next_free >= len) | |
| p = pool->mp_block; | |
| if (!p) { | |
| if (len >= (pool->block_alloc / 2)) | |
| return mem_pool_alloc_block(pool, len, pool->mp_block); | |
| p = mem_pool_alloc_block(pool, pool->block_alloc, NULL); | |
| } | |
| r = p->next_free; | |
| p->next_free += len; | |
| return r; | |
| } | |
| void *mem_pool_calloc(struct mem_pool *pool, size_t count, size_t size) | |
| { | |
| size_t len = st_mult(count, size); | |
| void *r = mem_pool_alloc(pool, len); | |
| memset(r, 0, len); | |
| return r; | |
| } | |
| char *mem_pool_strdup(struct mem_pool *pool, const char *str) | |
| { | |
| size_t len = strlen(str) + 1; | |
| char *ret = mem_pool_alloc(pool, len); | |
| return memcpy(ret, str, len); | |
| } | |
| char *mem_pool_strndup(struct mem_pool *pool, const char *str, size_t len) | |
| { | |
| char *p = memchr(str, '\0', len); | |
| size_t actual_len = (p ? p - str : len); | |
| char *ret = mem_pool_alloc(pool, actual_len+1); | |
| ret[actual_len] = '\0'; | |
| return memcpy(ret, str, actual_len); | |
| } | |
| int mem_pool_contains(struct mem_pool *pool, void *mem) | |
| { | |
| struct mp_block *p; | |
| /* Check if memory is allocated in a block */ | |
| for (p = pool->mp_block; p; p = p->next_block) | |
| if ((mem >= ((void *)p->space)) && | |
| (mem < ((void *)p->end))) | |
| return 1; | |
| return 0; | |
| } | |
| void mem_pool_combine(struct mem_pool *dst, struct mem_pool *src) | |
| { | |
| struct mp_block *p; | |
| /* Append the blocks from src to dst */ | |
| if (dst->mp_block && src->mp_block) { | |
| /* | |
| * src and dst have blocks, append | |
| * blocks from src to dst. | |
| */ | |
| p = dst->mp_block; | |
| while (p->next_block) | |
| p = p->next_block; | |
| p->next_block = src->mp_block; | |
| } else if (src->mp_block) { | |
| /* | |
| * src has blocks, dst is empty. | |
| */ | |
| dst->mp_block = src->mp_block; | |
| } else { | |
| /* src is empty, nothing to do. */ | |
| } | |
| dst->pool_alloc += src->pool_alloc; | |
| src->pool_alloc = 0; | |
| src->mp_block = NULL; | |
| } |