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