| /* |
| * Memory Pool implementation logic. |
| */ |
| |
| #include "git-compat-util.h" |
| #include "mem-pool.h" |
| #include "gettext.h" |
| |
| #define BLOCK_GROWTH_SIZE (1024 * 1024 - sizeof(struct mp_block)) |
| |
| /* |
| * The inner union is an approximation for C11's max_align_t, and the |
| * struct + offsetof computes _Alignof. This can all just be replaced |
| * with _Alignof(max_align_t) if/when C11 is part of the baseline. |
| * Note that _Alignof(X) need not be the same as sizeof(X); it's only |
| * required to be a (possibly trivial) factor. They are the same for |
| * most architectures, but m68k for example has only 2-byte alignment |
| * for its 4-byte and 8-byte types, so using sizeof would waste space. |
| * |
| * Add more types to the union if the current set is insufficient. |
| */ |
| struct git_max_alignment { |
| char unalign; |
| union { |
| uintmax_t max_align_uintmax; |
| void *max_align_pointer; |
| } aligned; |
| }; |
| #define GIT_MAX_ALIGNMENT offsetof(struct git_max_alignment, aligned) |
| |
| /* |
| * 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; |
| |
| len = DIV_ROUND_UP(len, GIT_MAX_ALIGNMENT) * GIT_MAX_ALIGNMENT; |
| |
| 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)) |
| p = mem_pool_alloc_block(pool, len, pool->mp_block); |
| else |
| p = mem_pool_alloc_block(pool, pool->block_alloc, NULL); |
| } |
| |
| r = p->next_free; |
| p->next_free += len; |
| return r; |
| } |
| |
| static char *mem_pool_strvfmt(struct mem_pool *pool, const char *fmt, |
| va_list ap) |
| { |
| struct mp_block *block = pool->mp_block; |
| char *next_free = block ? block->next_free : NULL; |
| size_t available = block ? block->end - block->next_free : 0; |
| va_list cp; |
| int len, len2; |
| size_t size; |
| char *ret; |
| |
| va_copy(cp, ap); |
| len = vsnprintf(next_free, available, fmt, cp); |
| va_end(cp); |
| if (len < 0) |
| die(_("unable to format message: %s"), fmt); |
| |
| size = st_add(len, 1); /* 1 for NUL */ |
| ret = mem_pool_alloc(pool, size); |
| |
| /* Shortcut; relies on mem_pool_alloc() not touching buffer contents. */ |
| if (ret == next_free) |
| return ret; |
| |
| len2 = vsnprintf(ret, size, fmt, ap); |
| if (len2 != len) |
| BUG("your vsnprintf is broken (returns inconsistent lengths)"); |
| return ret; |
| } |
| |
| char *mem_pool_strfmt(struct mem_pool *pool, const char *fmt, ...) |
| { |
| va_list ap; |
| char *ret; |
| |
| va_start(ap, fmt); |
| ret = mem_pool_strvfmt(pool, fmt, ap); |
| va_end(ap); |
| return ret; |
| } |
| |
| 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; |
| } |