diff --git a/arena_8h.html b/arena_8h.html index 3a9e435..13efb7a 100644 --- a/arena_8h.html +++ b/arena_8h.html @@ -365,7 +365,7 @@

Returns
A pointer to reallocated the memory chunk.
Return values
- +
NULLIf arena doesn't have enough memory for the reallocation.
NULLIf arena doesn't have enough memory for the reallocation or invalid parameters are given.
@@ -428,7 +428,7 @@

Returns
A pointer to reallocated the memory chunk.
Return values
- +
NULLIf arena doesn't have enough memory for the reallocation.
NULLIf arena doesn't have enough memory for the reallocation or invalid parameters are given.
diff --git a/examples_2fstack_2valid_parentheses_8c-example.html b/examples_2fstack_2valid_parentheses_8c-example.html index 0fe41a1..c93be23 100644 --- a/examples_2fstack_2valid_parentheses_8c-example.html +++ b/examples_2fstack_2valid_parentheses_8c-example.html @@ -88,7 +88,106 @@

Examples of how fstack.h header file is used in practice.

-
+
#include <stdint.h>
+
#include <stdio.h>
+
#include <string.h>
+
+
#define NAME paren_stk
+
#define VALUE_TYPE char
+
#include "fstack.h"
+
+
void print_paren_stk(struct paren_stk *stk)
+
{
+
if (stk->count > 0) {
+
printf("%c", paren_stk_at(stk, 0));
+
}
+
else {
+
printf("(empty)");
+
}
+
for (size_t i = 1; i < stk->count; i++) {
+
printf(" <- %c", paren_stk_at(stk, (uint32_t)i));
+
}
+
printf("\n");
+
}
+
+
char matching_paren(char c)
+
{
+
switch (c) {
+
case '(':
+
return ')';
+
case '{':
+
return '}';
+
case '[':
+
return ']';
+
case ')':
+
return '(';
+
case '}':
+
return '{';
+
case ']':
+
return '[';
+
}
+
return '\0';
+
}
+
+
bool isValid(char *s)
+
{
+
const size_t n = strlen(s);
+
struct paren_stk *stk = paren_stk_create((uint32_t)n);
+
+
bool retVal = true;
+
+
for (size_t i = 0; i < n; i++) {
+
switch (s[i]) {
+
case '(':
+
case '{':
+
case '[':
+
if (!paren_stk_is_full(stk)) {
+
paren_stk_push(stk, matching_paren(s[i]));
+
}
+
else {
+
assert(false);
+
}
+
break;
+
case ')':
+
case '}':
+
case ']':
+
retVal &= !paren_stk_is_empty(stk) && paren_stk_pop(stk) == s[i];
+
break;
+
default:
+
assert(false);
+
break;
+
}
+
}
+
retVal &= stk->count == 0;
+
+
paren_stk_destroy(stk);
+
+
return retVal;
+
}
+
+
#define print_and_assert(expr, expected) \
+
__extension__({ \
+
bool res = (expr); \
+
assert(res == (expected)); \
+
printf("%-17s = %s\n", #expr, res ? "true" : "false"); \
+
})
+
+
int main(void)
+
{
+
(void)(print_paren_stk);
+
+
print_and_assert(isValid("()"), true);
+
print_and_assert(isValid("("), false);
+
print_and_assert(isValid(")"), false);
+
print_and_assert(isValid("(]"), false);
+
print_and_assert(isValid("([]){}"), true);
+
print_and_assert(isValid("([){}"), false);
+
print_and_assert(isValid("{[][]}"), true);
+
print_and_assert(isValid("{[[]}"), false);
+
print_and_assert(isValid("{[(])}"), false);
+
}
+
fstack.h
Fixed-size array-based stack.
+
Generated by doxygen 1.12.0 diff --git a/freelist_8h.html b/freelist_8h.html index 303666d..a4a1bb0 100644 --- a/freelist_8h.html +++ b/freelist_8h.html @@ -156,7 +156,9 @@

Best-fit free list allocator.

Sources used:

+

Inspiration:

diff --git a/freelist_8h_source.html b/freelist_8h_source.html index dfd0a49..370f806 100644 --- a/freelist_8h_source.html +++ b/freelist_8h_source.html @@ -102,304 +102,304 @@
9 * See the file LICENSE included with this distribution for more
10 * information. */
11
-
27#pragma once
-
28
-
29#include <stdalign.h>
-
30#include <stdbool.h>
-
31#include <stddef.h>
-
32#include <stdint.h>
-
33#include <string.h>
-
34
-
35#include "align.h" // align, calc_alignment_padding, CALC_ALIGNMENT_PADDING
+
29#pragma once
+
30
+
31#include <stdalign.h>
+
32#include <stdbool.h>
+
33#include <stddef.h>
+
34#include <stdint.h>
+
35#include <string.h>
36
-
-
40struct freelist_header {
-
41 size_t __prev_block_size_w_freed_bit;
-
43 size_t curr_block_size;
-
44 char : CALC_ALIGNMENT_PADDING(alignof(max_align_t), 2 * sizeof(size_t));
-
45};
+
37#include "align.h" // align, calc_alignment_padding, CALC_ALIGNMENT_PADDING
+
38
+
+
42struct freelist_header {
+
43 size_t __prev_block_size_w_freed_bit;
+
45 size_t curr_block_size;
+
46 char : CALC_ALIGNMENT_PADDING(alignof(max_align_t), 2 * sizeof(size_t));
+
47};
-
46
-
48#define NAME freetree
-
49#define KEY_TYPE struct freelist_header
-
50#define KEY_IS_STRICTLY_LESS(a, b) ((a).curr_block_size < (b).curr_block_size)
-
51#define KEY_MEMBER_IS_FIRST
-
52#define ALLOW_DUPLICATES
-
54#include "rbtree.h"
-
55
-
-
59struct freelist {
-
60 size_t buf_len;
-
61 size_t buf_used;
-
62 struct freelist_header *head;
-
63 struct freetree_node *rb_rootptr;
-
64 unsigned char *buf_ptr;
-
65};
+
48
+
50#define NAME freetree
+
51#define KEY_TYPE struct freelist_header
+
52#define KEY_IS_STRICTLY_LESS(a, b) ((a).curr_block_size < (b).curr_block_size)
+
53#define KEY_MEMBER_IS_FIRST
+
54#define ALLOW_DUPLICATES
+
56#include "rbtree.h"
+
57
+
+
61struct freelist {
+
62 size_t buf_len;
+
63 size_t buf_used;
+
64 struct freelist_header *head;
+
65 struct freetree_node *rb_rootptr;
+
66 unsigned char *buf_ptr;
+
67};
-
66
-
68static inline struct freetree_node *internal_freetree_search_best_block(struct freetree_node **rootptr_ptr,
-
69 const size_t block_size);
-
70
-
71static inline void internal_freelist_coalescence(struct freelist *self, struct freelist_header *header);
-
73
-
74/* Create a freelist header from given params */
-
75static inline struct freelist_header freelist_header_from(const bool is_freed, const size_t prev_size,
-
76 const size_t curr_size)
-
77{
-
78 return (struct freelist_header){.__prev_block_size_w_freed_bit = prev_size + (is_freed ? 1 : 0),
-
79 .curr_block_size = curr_size};
-
80}
-
81
-
82/* Get the prev size from header */
-
83static inline size_t freelist_header_prev_size(const struct freelist_header *header)
-
84{
-
85 return (header->__prev_block_size_w_freed_bit & ~(size_t)1);
-
86}
-
87
-
88/* Check if the memory block under header is freed */
-
89static inline bool freelist_header_is_freed(const struct freelist_header *header)
-
90{
-
91 return header->__prev_block_size_w_freed_bit & 1;
-
92}
-
93
-
94/* Get the pointer to previous header */
-
95static inline struct freelist_header *freelist_header_prev(struct freelist_header *header)
-
96{
-
97 const size_t prev_size = freelist_header_prev_size(header);
-
98
-
99 return prev_size == 0 ? NULL : (struct freelist_header *)((char *)header - prev_size);
-
100}
-
101
-
102/* Get the pointer to next header */
-
103static inline struct freelist_header *freelist_header_next(struct freelist_header *header,
-
104 const struct freelist *freelist_ptr)
-
105{
-
106 const char *next = (char *)header + header->curr_block_size;
-
107 const bool is_end = next >= (char *)freelist_ptr->buf_ptr + freelist_ptr->buf_len;
-
108
-
109 return is_end ? NULL : (struct freelist_header *)next;
-
110}
-
111
-
112/* Check if the freelist header *should* be in the freetree */
-
113static inline bool freelist_header_should_be_in_freetree(const struct freelist_header *header)
-
114{
-
115 return freelist_header_is_freed(header) && header->curr_block_size >= sizeof(struct freetree_node);
-
116}
-
117
-
118/* Deallocate everything contained in the freelist */
-
119static inline void freelist_deallocate_all(struct freelist *self)
-
120{
-
121 assert(self);
-
122
-
123 struct freetree_node *node = (struct freetree_node *)self->buf_ptr;
+
68
+
70static inline struct freetree_node *internal_freetree_search_best_block(struct freetree_node **rootptr_ptr,
+
71 const size_t block_size);
+
72
+
73static inline void internal_freelist_coalescence(struct freelist *self, struct freelist_header *header);
+
75
+
76/* Create a freelist header from given params */
+
77static inline struct freelist_header freelist_header_from(const bool is_freed, const size_t prev_size,
+
78 const size_t curr_size)
+
79{
+
80 return (struct freelist_header){.__prev_block_size_w_freed_bit = prev_size + (is_freed ? 1 : 0),
+
81 .curr_block_size = curr_size};
+
82}
+
83
+
84/* Get the prev size from header */
+
85static inline size_t freelist_header_prev_size(const struct freelist_header *header)
+
86{
+
87 return (header->__prev_block_size_w_freed_bit & ~(size_t)1);
+
88}
+
89
+
90/* Check if the memory block under header is freed */
+
91static inline bool freelist_header_is_freed(const struct freelist_header *header)
+
92{
+
93 return header->__prev_block_size_w_freed_bit & 1;
+
94}
+
95
+
96/* Get the pointer to previous header */
+
97static inline struct freelist_header *freelist_header_prev(struct freelist_header *header)
+
98{
+
99 const size_t prev_size = freelist_header_prev_size(header);
+
100
+
101 return prev_size == 0 ? NULL : (struct freelist_header *)((char *)header - prev_size);
+
102}
+
103
+
104/* Get the pointer to next header */
+
105static inline struct freelist_header *freelist_header_next(struct freelist_header *header,
+
106 const struct freelist *freelist_ptr)
+
107{
+
108 const char *next = (char *)header + header->curr_block_size;
+
109 const bool is_end = next >= (char *)freelist_ptr->buf_ptr + freelist_ptr->buf_len;
+
110
+
111 return is_end ? NULL : (struct freelist_header *)next;
+
112}
+
113
+
114/* Check if the freelist header *should* be in the freetree */
+
115static inline bool freelist_header_should_be_in_freetree(const struct freelist_header *header)
+
116{
+
117 return freelist_header_is_freed(header) && header->curr_block_size >= sizeof(struct freetree_node);
+
118}
+
119
+
120/* Deallocate everything contained in the freelist */
+
121static inline void freelist_deallocate_all(struct freelist *self)
+
122{
+
123 assert(self);
124
-
125 freetree_node_init(node, freelist_header_from(true, 0, self->buf_len));
+
125 struct freetree_node *node = (struct freetree_node *)self->buf_ptr;
126
-
127 self->buf_used = self->buf_len - node->key.curr_block_size;
-
128 self->rb_rootptr = node;
-
129 self->head = &node->key;
-
130}
-
131
-
132/* Initialize the freelist */
-
133static inline void freelist_init(struct freelist *self, const size_t len, unsigned char backing_buf[len])
-
134{
-
135 assert(self);
-
136 assert(backing_buf);
-
137
-
138 const uintptr_t padding = calc_alignment_padding(alignof(struct freelist_header), (uintptr_t)&backing_buf[0]);
+
127 freetree_node_init(node, freelist_header_from(true, 0, self->buf_len));
+
128
+
129 self->buf_used = self->buf_len - node->key.curr_block_size;
+
130 self->rb_rootptr = node;
+
131 self->head = &node->key;
+
132}
+
133
+
134/* Initialize the freelist */
+
135static inline void freelist_init(struct freelist *self, const size_t len, unsigned char backing_buf[len])
+
136{
+
137 assert(self);
+
138 assert(backing_buf);
139
-
140 assert(len >= sizeof(struct freetree_node) + padding);
+
140 const uintptr_t padding = calc_alignment_padding(alignof(struct freelist_header), (uintptr_t)&backing_buf[0]);
141
-
142 self->buf_ptr = &backing_buf[padding];
-
143 self->buf_len = len - padding;
-
144
-
145 freelist_deallocate_all(self);
-
146}
-
147
-
148static inline void *internal_freelist_init_block(struct freelist *self, char *block_ptr, struct freelist_header *next,
-
149 const size_t prev_size, const size_t block_size,
-
150 const size_t remaining_size)
-
151{
-
152 if (remaining_size > 0) {
-
153 struct freelist_header *remaining_header = (struct freelist_header *)(block_ptr + block_size);
-
154 *remaining_header = freelist_header_from(true, block_size, remaining_size);
-
155
-
156 if (next) {
-
157 *next = freelist_header_from(freelist_header_is_freed(next), remaining_size, next->curr_block_size);
-
158 }
-
159
-
160 if (freelist_header_should_be_in_freetree(remaining_header)) {
-
161 struct freetree_node *new_node = (struct freetree_node *)remaining_header;
-
162 freetree_node_init(new_node, *remaining_header);
-
163 freetree_insert_node(&self->rb_rootptr, new_node);
-
164 }
-
165 }
-
166 struct freelist_header *curr_header = (struct freelist_header *)block_ptr;
-
167 *curr_header = freelist_header_from(false, prev_size, block_size);
-
168
-
169 return (void *)((char *)curr_header + sizeof(struct freelist_header));
-
170}
-
171
-
172/* Get the pointer to a block of the freelist.*/
-
173static inline void *freelist_allocate(struct freelist *self, const size_t requested_size)
-
174{
-
175 assert(self);
-
176 assert(requested_size != 0);
-
177
-
178 size_t block_size = sizeof(struct freelist_header) + requested_size;
-
179 block_size = block_size >= sizeof(struct freetree_node) ? block_size : sizeof(struct freetree_node);
-
180 block_size = block_size + calc_alignment_padding(alignof(struct freetree_node), block_size);
-
181
-
182 struct freetree_node *node = internal_freetree_search_best_block(&self->rb_rootptr, block_size);
+
142 assert(len >= sizeof(struct freetree_node) + padding);
+
143
+
144 self->buf_ptr = &backing_buf[padding];
+
145 self->buf_len = len - padding;
+
146
+
147 freelist_deallocate_all(self);
+
148}
+
149
+
150static inline void *internal_freelist_init_block(struct freelist *self, char *block_ptr, struct freelist_header *next,
+
151 const size_t prev_size, const size_t block_size,
+
152 const size_t remaining_size)
+
153{
+
154 if (remaining_size > 0) {
+
155 struct freelist_header *remaining_header = (struct freelist_header *)(block_ptr + block_size);
+
156 *remaining_header = freelist_header_from(true, block_size, remaining_size);
+
157
+
158 if (next) {
+
159 *next = freelist_header_from(freelist_header_is_freed(next), remaining_size, next->curr_block_size);
+
160 }
+
161
+
162 if (freelist_header_should_be_in_freetree(remaining_header)) {
+
163 struct freetree_node *new_node = (struct freetree_node *)remaining_header;
+
164 freetree_node_init(new_node, *remaining_header);
+
165 freetree_insert_node(&self->rb_rootptr, new_node);
+
166 }
+
167 }
+
168 struct freelist_header *curr_header = (struct freelist_header *)block_ptr;
+
169 *curr_header = freelist_header_from(false, prev_size, block_size);
+
170
+
171 return (void *)((char *)curr_header + sizeof(struct freelist_header));
+
172}
+
173
+
174/* Get the pointer to a block of the freelist.*/
+
175static inline void *freelist_allocate(struct freelist *self, const size_t requested_size)
+
176{
+
177 assert(self);
+
178 assert(requested_size != 0);
+
179
+
180 size_t block_size = sizeof(struct freelist_header) + requested_size;
+
181 block_size = block_size >= sizeof(struct freetree_node) ? block_size : sizeof(struct freetree_node);
+
182 block_size = block_size + calc_alignment_padding(alignof(struct freetree_node), block_size);
183
-
184 if (node == NULL) {
-
185 return NULL;
-
186 }
-
187
-
188 freetree_delete_node(&self->rb_rootptr, node);
+
184 struct freetree_node *node = internal_freetree_search_best_block(&self->rb_rootptr, block_size);
+
185
+
186 if (node == NULL) {
+
187 return NULL;
+
188 }
189
-
190 self->buf_used += block_size;
+
190 freetree_delete_node(&self->rb_rootptr, node);
191
-
192 return internal_freelist_init_block(self, (char *)node, freelist_header_next(&node->key, self),
-
193 freelist_header_prev_size(&node->key), block_size,
-
194 node->key.curr_block_size - block_size);
-
195}
-
196
-
197/* Deallocate a block from the freelist for further use. */
-
198static inline void freelist_deallocate(struct freelist *self, void *ptr)
-
199{
-
200 struct freelist_header *header = (struct freelist_header *)((char *)ptr - sizeof(struct freelist_header));
-
201
-
202 assert(!freelist_header_is_freed(header) && "double free detected!");
+
192 self->buf_used += block_size;
+
193
+
194 return internal_freelist_init_block(self, (char *)node, freelist_header_next(&node->key, self),
+
195 freelist_header_prev_size(&node->key), block_size,
+
196 node->key.curr_block_size - block_size);
+
197}
+
198
+
199/* Deallocate a block from the freelist for further use. */
+
200static inline void freelist_deallocate(struct freelist *self, void *ptr)
+
201{
+
202 struct freelist_header *header = (struct freelist_header *)((char *)ptr - sizeof(struct freelist_header));
203
-
204 self->buf_used -= header->curr_block_size;
+
204 assert(!freelist_header_is_freed(header) && "double free detected!");
205
-
206 internal_freelist_coalescence(self, header);
-
207}
-
208
-
209/* Reallocate a block and grow / shrink the block. */
-
210/*
-
211static inline void *freelist_reallocate(struct freelist *self, void *ptr, const size_t new_size)
-
212{
-
213 assert(self);
-
214 assert(new_size != 0);
-
215
-
216 struct freelist_header *header = (struct freelist_header *)((char *)ptr - sizeof(struct freelist_header));
-
217 const size_t old_size = header->curr_block_size - sizeof(struct freelist_header);
-
218
-
219 assert(freelist_header_is_freed(header) && "reallocating freed block!");
+
206 self->buf_used -= header->curr_block_size;
+
207
+
208 internal_freelist_coalescence(self, header);
+
209}
+
210
+
211/* Reallocate a block and grow / shrink the block. */
+
212/*
+
213static inline void *freelist_reallocate(struct freelist *self, void *ptr, const size_t new_size)
+
214{
+
215 assert(self);
+
216 assert(new_size != 0);
+
217
+
218 struct freelist_header *header = (struct freelist_header *)((char *)ptr - sizeof(struct freelist_header));
+
219 const size_t old_size = header->curr_block_size - sizeof(struct freelist_header);
220
-
221 if (new_size <= old_size) {
-
222 size_t block_size = sizeof(struct freelist_header) + new_size;
-
223 block_size = block_size >= sizeof(struct freetree_node) ? block_size : sizeof(struct freetree_node);
-
224 block_size = block_size + calc_alignment_padding(alignof(max_align_t), block_size);
-
225
-
226 if (block_size == header->curr_block_size) {
-
227 return ptr;
-
228 }
-
229 else {
-
230 return internal_freelist_init_block(self, (char *)header, freelist_header_next(header, self),
-
231 freelist_header_prev_size(header), block_size,
-
232 header->curr_block_size - block_size);
-
233 }
-
234 }
-
235
-
236 size_t bytes_acc = header->curr_block_size;
-
237 struct freelist_header *next = freelist_header_next(header, self);
-
238 while (bytes_acc < new_size && next != NULL && !freelist_header_is_freed(next)) {
-
239 bytes_acc += next->curr_block_size;
-
240 next = freelist_header_next(next, self);
-
241 }
-
242
-
243 if (bytes_acc >= new_size) {
-
244 return internal_freelist_init_block(self, (char *)header, freelist_header_next(header, self),
-
245 freelist_header_prev_size(header),
-
246 new_size + sizeof(struct freelist_header), header->curr_block_size -);
-
247 }
-
248
-
249 void *ptr_new = freelist_allocate(self, new_size);
-
250 if (!ptr_new) {
-
251 return NULL;
-
252 }
-
253 memcpy(ptr_new, ptr, header->curr_block_size - sizeof(struct freelist_header));
-
254 freelist_deallocate(self, ptr);
-
255 return ptr_new;
-
256}
-
257*/
-
258
-
260static inline struct freetree_node *internal_freetree_search_best_block(struct freetree_node **rootptr_ptr,
-
261 const size_t block_size)
-
262{
-
263 assert(rootptr_ptr != NULL);
-
264
-
265 struct freetree_node *prev_ptr = NULL;
-
266 struct freetree_node *curr_ptr = *rootptr_ptr;
-
267
-
268 while (curr_ptr != NULL) {
-
269 if (block_size > curr_ptr->key.curr_block_size) {
-
270 curr_ptr = curr_ptr->right_ptr;
-
271 }
-
272 else {
-
273 prev_ptr = curr_ptr;
-
274 curr_ptr = curr_ptr->left_ptr;
-
275 }
-
276 }
-
277 return prev_ptr;
-
278}
-
279
-
280static inline void internal_freelist_coalescence(struct freelist *self, struct freelist_header *header)
-
281{
-
282 assert(self);
-
283 assert(header);
-
284
-
285 struct freelist_header *prev = freelist_header_prev(header);
-
286 struct freelist_header *next = freelist_header_next(header, self);
-
287
-
288 struct freelist_header header_new = *header;
-
289 struct freelist_header *header_addr = header;
-
290 struct freelist_header *header_next = next;
-
291
-
292 if (prev && freelist_header_is_freed(prev)) {
-
293 header_new.curr_block_size += prev->curr_block_size;
-
294 header_new.__prev_block_size_w_freed_bit = prev->__prev_block_size_w_freed_bit & ~(uintptr_t)1;
-
295 header_addr = prev;
-
296
-
297 if (freelist_header_should_be_in_freetree(prev)) {
-
298 freetree_delete_node(&self->rb_rootptr, (struct freetree_node *)prev);
-
299 }
-
300 }
-
301 if (next && freelist_header_is_freed(next)) {
-
302 header_new.curr_block_size += next->curr_block_size;
-
303 header_next = freelist_header_next(next, self);
-
304
-
305 if (freelist_header_should_be_in_freetree(next)) {
-
306 freetree_delete_node(&self->rb_rootptr, (struct freetree_node *)next);
-
307 }
-
308 }
-
309 if (header_next) {
-
310 *header_next = freelist_header_from(freelist_header_is_freed(header_next), header_new.curr_block_size,
-
311 header_next->curr_block_size);
-
312 }
-
313 header_new.__prev_block_size_w_freed_bit |= 1;
-
314 assert(freelist_header_should_be_in_freetree(&header_new));
-
315
-
316 struct freetree_node *node_addr = (struct freetree_node *)header_addr;
-
317 freetree_node_init(node_addr, header_new);
-
318 freetree_insert_node(&self->rb_rootptr, node_addr);
-
319}
+
221 assert(freelist_header_is_freed(header) && "reallocating freed block!");
+
222
+
223 if (new_size <= old_size) {
+
224 size_t block_size = sizeof(struct freelist_header) + new_size;
+
225 block_size = block_size >= sizeof(struct freetree_node) ? block_size : sizeof(struct freetree_node);
+
226 block_size = block_size + calc_alignment_padding(alignof(max_align_t), block_size);
+
227
+
228 if (block_size == header->curr_block_size) {
+
229 return ptr;
+
230 }
+
231 else {
+
232 return internal_freelist_init_block(self, (char *)header, freelist_header_next(header, self),
+
233 freelist_header_prev_size(header), block_size,
+
234 header->curr_block_size - block_size);
+
235 }
+
236 }
+
237
+
238 size_t bytes_acc = header->curr_block_size;
+
239 struct freelist_header *next = freelist_header_next(header, self);
+
240 while (bytes_acc < new_size && next != NULL && !freelist_header_is_freed(next)) {
+
241 bytes_acc += next->curr_block_size;
+
242 next = freelist_header_next(next, self);
+
243 }
+
244
+
245 if (bytes_acc >= new_size) {
+
246 return internal_freelist_init_block(self, (char *)header, freelist_header_next(header, self),
+
247 freelist_header_prev_size(header),
+
248 new_size + sizeof(struct freelist_header), header->curr_block_size -);
+
249 }
+
250
+
251 void *ptr_new = freelist_allocate(self, new_size);
+
252 if (!ptr_new) {
+
253 return NULL;
+
254 }
+
255 memcpy(ptr_new, ptr, header->curr_block_size - sizeof(struct freelist_header));
+
256 freelist_deallocate(self, ptr);
+
257 return ptr_new;
+
258}
+
259*/
+
260
+
262static inline struct freetree_node *internal_freetree_search_best_block(struct freetree_node **rootptr_ptr,
+
263 const size_t block_size)
+
264{
+
265 assert(rootptr_ptr != NULL);
+
266
+
267 struct freetree_node *prev_ptr = NULL;
+
268 struct freetree_node *curr_ptr = *rootptr_ptr;
+
269
+
270 while (curr_ptr != NULL) {
+
271 if (block_size > curr_ptr->key.curr_block_size) {
+
272 curr_ptr = curr_ptr->right_ptr;
+
273 }
+
274 else {
+
275 prev_ptr = curr_ptr;
+
276 curr_ptr = curr_ptr->left_ptr;
+
277 }
+
278 }
+
279 return prev_ptr;
+
280}
+
281
+
282static inline void internal_freelist_coalescence(struct freelist *self, struct freelist_header *header)
+
283{
+
284 assert(self);
+
285 assert(header);
+
286
+
287 struct freelist_header *prev = freelist_header_prev(header);
+
288 struct freelist_header *next = freelist_header_next(header, self);
+
289
+
290 struct freelist_header header_new = *header;
+
291 struct freelist_header *header_addr = header;
+
292 struct freelist_header *header_next = next;
+
293
+
294 if (prev && freelist_header_is_freed(prev)) {
+
295 header_new.curr_block_size += prev->curr_block_size;
+
296 header_new.__prev_block_size_w_freed_bit = prev->__prev_block_size_w_freed_bit & ~(uintptr_t)1;
+
297 header_addr = prev;
+
298
+
299 if (freelist_header_should_be_in_freetree(prev)) {
+
300 freetree_delete_node(&self->rb_rootptr, (struct freetree_node *)prev);
+
301 }
+
302 }
+
303 if (next && freelist_header_is_freed(next)) {
+
304 header_new.curr_block_size += next->curr_block_size;
+
305 header_next = freelist_header_next(next, self);
+
306
+
307 if (freelist_header_should_be_in_freetree(next)) {
+
308 freetree_delete_node(&self->rb_rootptr, (struct freetree_node *)next);
+
309 }
+
310 }
+
311 if (header_next) {
+
312 *header_next = freelist_header_from(freelist_header_is_freed(header_next), header_new.curr_block_size,
+
313 header_next->curr_block_size);
+
314 }
+
315 header_new.__prev_block_size_w_freed_bit |= 1;
+
316 assert(freelist_header_should_be_in_freetree(&header_new));
+
317
+
318 struct freetree_node *node_addr = (struct freetree_node *)header_addr;
+
319 freetree_node_init(node_addr, header_new);
+
320 freetree_insert_node(&self->rb_rootptr, node_addr);
+
321}
align.h
Align memory.
calc_alignment_padding
static uintptr_t calc_alignment_padding(const size_t alignment, const uintptr_t ptr)
Calculate the alignment padding required to align a pointer.
Definition align.h:91
CALC_ALIGNMENT_PADDING
#define CALC_ALIGNMENT_PADDING(alignment, ptr)
compile time calc_alignment_padding.
Definition align.h:105
rbtree.h
Intrusive red-black tree.
-
freelist_header
Freelist header definition. This lies at the front of every block.
Definition freelist.h:40
-
freelist_header::__prev_block_size_w_freed_bit
size_t __prev_block_size_w_freed_bit
Definition freelist.h:41
-
freelist_header::curr_block_size
size_t curr_block_size
Current block size.
Definition freelist.h:43
-
freelist
Freelist struct definition.
Definition freelist.h:59
-
freelist::rb_rootptr
struct freetree_node * rb_rootptr
Header of freetree (freed memory blocks)
Definition freelist.h:63
-
freelist::buf_ptr
unsigned char * buf_ptr
Underlying buffer.
Definition freelist.h:64
-
freelist::buf_used
size_t buf_used
Number of bytes used of buffer.
Definition freelist.h:61
-
freelist::head
struct freelist_header * head
Header of freelist headers (all memory blocks)
Definition freelist.h:62
-
freelist::buf_len
size_t buf_len
Buffer length.
Definition freelist.h:60
+
freelist_header
Freelist header definition. This lies at the front of every block.
Definition freelist.h:42
+
freelist_header::__prev_block_size_w_freed_bit
size_t __prev_block_size_w_freed_bit
Definition freelist.h:43
+
freelist_header::curr_block_size
size_t curr_block_size
Current block size.
Definition freelist.h:45
+
freelist
Freelist struct definition.
Definition freelist.h:61
+
freelist::rb_rootptr
struct freetree_node * rb_rootptr
Header of freetree (freed memory blocks)
Definition freelist.h:65
+
freelist::buf_ptr
unsigned char * buf_ptr
Underlying buffer.
Definition freelist.h:66
+
freelist::buf_used
size_t buf_used
Number of bytes used of buffer.
Definition freelist.h:63
+
freelist::head
struct freelist_header * head
Header of freelist headers (all memory blocks)
Definition freelist.h:64
+
freelist::buf_len
size_t buf_len
Buffer length.
Definition freelist.h:62