Jameson Miller | 065feab | 2018-04-11 18:37:55 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Memory Pool implementation logic. |
| 3 | */ |
| 4 | |
| 5 | #include "cache.h" |
| 6 | #include "mem-pool.h" |
| 7 | |
René Scharfe | 116affa | 2021-03-13 17:17:37 +0100 | [diff] [blame] | 8 | #define BLOCK_GROWTH_SIZE (1024 * 1024 - sizeof(struct mp_block)) |
Jameson Miller | 158dfef | 2018-07-02 19:49:34 +0000 | [diff] [blame] | 9 | |
| 10 | /* |
| 11 | * Allocate a new mp_block and insert it after the block specified in |
| 12 | * `insert_after`. If `insert_after` is NULL, then insert block at the |
| 13 | * head of the linked list. |
| 14 | */ |
Elijah Newren | f87bf28 | 2020-08-15 17:37:57 +0000 | [diff] [blame] | 15 | static struct mp_block *mem_pool_alloc_block(struct mem_pool *pool, |
| 16 | size_t block_alloc, |
| 17 | struct mp_block *insert_after) |
Jameson Miller | 065feab | 2018-04-11 18:37:55 +0000 | [diff] [blame] | 18 | { |
| 19 | struct mp_block *p; |
| 20 | |
Elijah Newren | f87bf28 | 2020-08-15 17:37:57 +0000 | [diff] [blame] | 21 | pool->pool_alloc += sizeof(struct mp_block) + block_alloc; |
Jameson Miller | 065feab | 2018-04-11 18:37:55 +0000 | [diff] [blame] | 22 | p = xmalloc(st_add(sizeof(struct mp_block), block_alloc)); |
Jameson Miller | 158dfef | 2018-07-02 19:49:34 +0000 | [diff] [blame] | 23 | |
Jameson Miller | 065feab | 2018-04-11 18:37:55 +0000 | [diff] [blame] | 24 | p->next_free = (char *)p->space; |
| 25 | p->end = p->next_free + block_alloc; |
Jameson Miller | 158dfef | 2018-07-02 19:49:34 +0000 | [diff] [blame] | 26 | |
| 27 | if (insert_after) { |
| 28 | p->next_block = insert_after->next_block; |
| 29 | insert_after->next_block = p; |
| 30 | } else { |
Elijah Newren | f87bf28 | 2020-08-15 17:37:57 +0000 | [diff] [blame] | 31 | p->next_block = pool->mp_block; |
| 32 | pool->mp_block = p; |
Jameson Miller | 158dfef | 2018-07-02 19:49:34 +0000 | [diff] [blame] | 33 | } |
Jameson Miller | 065feab | 2018-04-11 18:37:55 +0000 | [diff] [blame] | 34 | |
| 35 | return p; |
| 36 | } |
| 37 | |
Elijah Newren | 44c7e1a | 2020-08-15 17:37:56 +0000 | [diff] [blame] | 38 | void mem_pool_init(struct mem_pool *pool, size_t initial_size) |
Jameson Miller | 158dfef | 2018-07-02 19:49:34 +0000 | [diff] [blame] | 39 | { |
Elijah Newren | 44c7e1a | 2020-08-15 17:37:56 +0000 | [diff] [blame] | 40 | memset(pool, 0, sizeof(*pool)); |
Jameson Miller | 158dfef | 2018-07-02 19:49:34 +0000 | [diff] [blame] | 41 | pool->block_alloc = BLOCK_GROWTH_SIZE; |
| 42 | |
| 43 | if (initial_size > 0) |
| 44 | mem_pool_alloc_block(pool, initial_size, NULL); |
Jameson Miller | 158dfef | 2018-07-02 19:49:34 +0000 | [diff] [blame] | 45 | } |
| 46 | |
Elijah Newren | f87bf28 | 2020-08-15 17:37:57 +0000 | [diff] [blame] | 47 | void mem_pool_discard(struct mem_pool *pool, int invalidate_memory) |
Jameson Miller | 158dfef | 2018-07-02 19:49:34 +0000 | [diff] [blame] | 48 | { |
| 49 | struct mp_block *block, *block_to_free; |
| 50 | |
Elijah Newren | f87bf28 | 2020-08-15 17:37:57 +0000 | [diff] [blame] | 51 | block = pool->mp_block; |
Jameson Miller | 8e72d67 | 2018-07-02 19:49:37 +0000 | [diff] [blame] | 52 | while (block) |
Jameson Miller | 158dfef | 2018-07-02 19:49:34 +0000 | [diff] [blame] | 53 | { |
| 54 | block_to_free = block; |
| 55 | block = block->next_block; |
Jameson Miller | 8616a2d | 2018-07-02 19:49:39 +0000 | [diff] [blame] | 56 | |
| 57 | if (invalidate_memory) |
| 58 | memset(block_to_free->space, 0xDD, ((char *)block_to_free->end) - ((char *)block_to_free->space)); |
| 59 | |
Jameson Miller | 158dfef | 2018-07-02 19:49:34 +0000 | [diff] [blame] | 60 | free(block_to_free); |
| 61 | } |
| 62 | |
Elijah Newren | f87bf28 | 2020-08-15 17:37:57 +0000 | [diff] [blame] | 63 | pool->mp_block = NULL; |
| 64 | pool->pool_alloc = 0; |
Jameson Miller | 158dfef | 2018-07-02 19:49:34 +0000 | [diff] [blame] | 65 | } |
| 66 | |
Elijah Newren | f87bf28 | 2020-08-15 17:37:57 +0000 | [diff] [blame] | 67 | void *mem_pool_alloc(struct mem_pool *pool, size_t len) |
Jameson Miller | 065feab | 2018-04-11 18:37:55 +0000 | [diff] [blame] | 68 | { |
Jameson Miller | 8fb8e3f | 2018-07-02 19:49:33 +0000 | [diff] [blame] | 69 | struct mp_block *p = NULL; |
Jameson Miller | 065feab | 2018-04-11 18:37:55 +0000 | [diff] [blame] | 70 | void *r; |
| 71 | |
| 72 | /* round up to a 'uintmax_t' alignment */ |
| 73 | if (len & (sizeof(uintmax_t) - 1)) |
| 74 | len += sizeof(uintmax_t) - (len & (sizeof(uintmax_t) - 1)); |
| 75 | |
Elijah Newren | f87bf28 | 2020-08-15 17:37:57 +0000 | [diff] [blame] | 76 | if (pool->mp_block && |
| 77 | pool->mp_block->end - pool->mp_block->next_free >= len) |
| 78 | p = pool->mp_block; |
Jameson Miller | 065feab | 2018-04-11 18:37:55 +0000 | [diff] [blame] | 79 | |
| 80 | if (!p) { |
Elijah Newren | f87bf28 | 2020-08-15 17:37:57 +0000 | [diff] [blame] | 81 | if (len >= (pool->block_alloc / 2)) |
| 82 | return mem_pool_alloc_block(pool, len, pool->mp_block); |
Jameson Miller | 065feab | 2018-04-11 18:37:55 +0000 | [diff] [blame] | 83 | |
Elijah Newren | f87bf28 | 2020-08-15 17:37:57 +0000 | [diff] [blame] | 84 | p = mem_pool_alloc_block(pool, pool->block_alloc, NULL); |
Jameson Miller | 065feab | 2018-04-11 18:37:55 +0000 | [diff] [blame] | 85 | } |
| 86 | |
| 87 | r = p->next_free; |
| 88 | p->next_free += len; |
| 89 | return r; |
| 90 | } |
| 91 | |
Elijah Newren | f87bf28 | 2020-08-15 17:37:57 +0000 | [diff] [blame] | 92 | void *mem_pool_calloc(struct mem_pool *pool, size_t count, size_t size) |
Jameson Miller | 065feab | 2018-04-11 18:37:55 +0000 | [diff] [blame] | 93 | { |
| 94 | size_t len = st_mult(count, size); |
Elijah Newren | f87bf28 | 2020-08-15 17:37:57 +0000 | [diff] [blame] | 95 | void *r = mem_pool_alloc(pool, len); |
Jameson Miller | 065feab | 2018-04-11 18:37:55 +0000 | [diff] [blame] | 96 | memset(r, 0, len); |
| 97 | return r; |
| 98 | } |
Jameson Miller | 0e58301 | 2018-07-02 19:49:35 +0000 | [diff] [blame] | 99 | |
Elijah Newren | a762c8c | 2020-08-15 17:37:55 +0000 | [diff] [blame] | 100 | char *mem_pool_strdup(struct mem_pool *pool, const char *str) |
| 101 | { |
| 102 | size_t len = strlen(str) + 1; |
| 103 | char *ret = mem_pool_alloc(pool, len); |
| 104 | |
| 105 | return memcpy(ret, str, len); |
| 106 | } |
| 107 | |
| 108 | char *mem_pool_strndup(struct mem_pool *pool, const char *str, size_t len) |
| 109 | { |
| 110 | char *p = memchr(str, '\0', len); |
| 111 | size_t actual_len = (p ? p - str : len); |
| 112 | char *ret = mem_pool_alloc(pool, actual_len+1); |
| 113 | |
| 114 | ret[actual_len] = '\0'; |
| 115 | return memcpy(ret, str, actual_len); |
| 116 | } |
| 117 | |
Elijah Newren | f87bf28 | 2020-08-15 17:37:57 +0000 | [diff] [blame] | 118 | int mem_pool_contains(struct mem_pool *pool, void *mem) |
Jameson Miller | 0e58301 | 2018-07-02 19:49:35 +0000 | [diff] [blame] | 119 | { |
| 120 | struct mp_block *p; |
| 121 | |
| 122 | /* Check if memory is allocated in a block */ |
Elijah Newren | f87bf28 | 2020-08-15 17:37:57 +0000 | [diff] [blame] | 123 | for (p = pool->mp_block; p; p = p->next_block) |
Jameson Miller | 0e58301 | 2018-07-02 19:49:35 +0000 | [diff] [blame] | 124 | if ((mem >= ((void *)p->space)) && |
| 125 | (mem < ((void *)p->end))) |
| 126 | return 1; |
| 127 | |
| 128 | return 0; |
| 129 | } |
| 130 | |
| 131 | void mem_pool_combine(struct mem_pool *dst, struct mem_pool *src) |
| 132 | { |
| 133 | struct mp_block *p; |
| 134 | |
| 135 | /* Append the blocks from src to dst */ |
| 136 | if (dst->mp_block && src->mp_block) { |
| 137 | /* |
| 138 | * src and dst have blocks, append |
| 139 | * blocks from src to dst. |
| 140 | */ |
| 141 | p = dst->mp_block; |
| 142 | while (p->next_block) |
| 143 | p = p->next_block; |
| 144 | |
| 145 | p->next_block = src->mp_block; |
| 146 | } else if (src->mp_block) { |
| 147 | /* |
| 148 | * src has blocks, dst is empty. |
| 149 | */ |
| 150 | dst->mp_block = src->mp_block; |
| 151 | } else { |
| 152 | /* src is empty, nothing to do. */ |
| 153 | } |
| 154 | |
| 155 | dst->pool_alloc += src->pool_alloc; |
| 156 | src->pool_alloc = 0; |
| 157 | src->mp_block = NULL; |
| 158 | } |