]>
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 | ||
158dfeff JM |
36 | void mem_pool_init(struct mem_pool **mem_pool, size_t initial_size) |
37 | { | |
38 | struct mem_pool *pool; | |
39 | ||
40 | if (*mem_pool) | |
41 | return; | |
42 | ||
43 | pool = xcalloc(1, sizeof(*pool)); | |
44 | ||
45 | pool->block_alloc = BLOCK_GROWTH_SIZE; | |
46 | ||
47 | if (initial_size > 0) | |
48 | mem_pool_alloc_block(pool, initial_size, NULL); | |
49 | ||
50 | *mem_pool = pool; | |
51 | } | |
52 | ||
53 | void mem_pool_discard(struct mem_pool *mem_pool) | |
54 | { | |
55 | struct mp_block *block, *block_to_free; | |
56 | ||
8e72d675 JM |
57 | block = mem_pool->mp_block; |
58 | while (block) | |
158dfeff JM |
59 | { |
60 | block_to_free = block; | |
61 | block = block->next_block; | |
62 | free(block_to_free); | |
63 | } | |
64 | ||
65 | free(mem_pool); | |
66 | } | |
67 | ||
065feab4 JM |
68 | void *mem_pool_alloc(struct mem_pool *mem_pool, size_t len) |
69 | { | |
8fb8e3f6 | 70 | struct mp_block *p = NULL; |
065feab4 JM |
71 | void *r; |
72 | ||
73 | /* round up to a 'uintmax_t' alignment */ | |
74 | if (len & (sizeof(uintmax_t) - 1)) | |
75 | len += sizeof(uintmax_t) - (len & (sizeof(uintmax_t) - 1)); | |
76 | ||
8fb8e3f6 JM |
77 | if (mem_pool->mp_block && |
78 | mem_pool->mp_block->end - mem_pool->mp_block->next_free >= len) | |
79 | p = mem_pool->mp_block; | |
065feab4 JM |
80 | |
81 | if (!p) { | |
158dfeff JM |
82 | if (len >= (mem_pool->block_alloc / 2)) |
83 | return mem_pool_alloc_block(mem_pool, len, mem_pool->mp_block); | |
065feab4 | 84 | |
158dfeff | 85 | p = mem_pool_alloc_block(mem_pool, mem_pool->block_alloc, NULL); |
065feab4 JM |
86 | } |
87 | ||
88 | r = p->next_free; | |
89 | p->next_free += len; | |
90 | return r; | |
91 | } | |
92 | ||
93 | void *mem_pool_calloc(struct mem_pool *mem_pool, size_t count, size_t size) | |
94 | { | |
95 | size_t len = st_mult(count, size); | |
96 | void *r = mem_pool_alloc(mem_pool, len); | |
97 | memset(r, 0, len); | |
98 | return r; | |
99 | } | |
0e58301d JM |
100 | |
101 | int mem_pool_contains(struct mem_pool *mem_pool, void *mem) | |
102 | { | |
103 | struct mp_block *p; | |
104 | ||
105 | /* Check if memory is allocated in a block */ | |
106 | for (p = mem_pool->mp_block; p; p = p->next_block) | |
107 | if ((mem >= ((void *)p->space)) && | |
108 | (mem < ((void *)p->end))) | |
109 | return 1; | |
110 | ||
111 | return 0; | |
112 | } | |
113 | ||
114 | void mem_pool_combine(struct mem_pool *dst, struct mem_pool *src) | |
115 | { | |
116 | struct mp_block *p; | |
117 | ||
118 | /* Append the blocks from src to dst */ | |
119 | if (dst->mp_block && src->mp_block) { | |
120 | /* | |
121 | * src and dst have blocks, append | |
122 | * blocks from src to dst. | |
123 | */ | |
124 | p = dst->mp_block; | |
125 | while (p->next_block) | |
126 | p = p->next_block; | |
127 | ||
128 | p->next_block = src->mp_block; | |
129 | } else if (src->mp_block) { | |
130 | /* | |
131 | * src has blocks, dst is empty. | |
132 | */ | |
133 | dst->mp_block = src->mp_block; | |
134 | } else { | |
135 | /* src is empty, nothing to do. */ | |
136 | } | |
137 | ||
138 | dst->pool_alloc += src->pool_alloc; | |
139 | src->pool_alloc = 0; | |
140 | src->mp_block = NULL; | |
141 | } |