Browse Source

Handled merge conflicts

watermark_alloc
Cameron Weinfurt 2 years ago
parent
commit
c3c6ead55d
  1. 2
      .gitignore
  2. 3
      Makefile
  3. 108
      main.c
  4. 785
      tree_alloc.c

2
.gitignore

@ -1,2 +1,4 @@
*.o
the_alloc
vgcore*
debug_log.txt

3
Makefile

@ -6,7 +6,8 @@ OUT_NAME = the_alloc
dev: CFLAGS= $(COMMON_FLAGS) -g -D UNIT_TESTS -D DEBUG=1
dev: $(OUT_NAME)
valgrind ./$(OUT_NAME)
rm -f vgcore.*
valgrind ./$(OUT_NAME) 2&> debug_log.txt
release: CFLAGS= $(COMMON_FLAGS) -O2
release: clean $(OUT_NAME)

108
main.c

@ -1,15 +1,17 @@
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <stddef.h>
#include <unistd.h>
#include <sys/mman.h>
#include <string.h>
#include "alloc_api.h"
void *get_new_region(uintptr_t size) {
void *m = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if (m == MAP_FAILED) {
return 0;
return NULL;
}
return m;
}
@ -18,8 +20,99 @@ void error(char *msg) {
printf("=== ALLOCATOR ERROR ===\n%s\n====== END ERROR ======\n", msg);
}
struct AllocationRecord {
uintptr_t size;
void *allocation;
void *reference;
int id;
struct AllocationRecord *next;
struct AllocationRecord *prev;
};
void insert_record(struct AllocationRecord *dummy, void *allocation, uintptr_t size) {
struct AllocationRecord *record = malloc(sizeof(struct AllocationRecord));
record->size = size;
record->allocation = allocation;
record->reference = malloc(size);
record->next = dummy;
record->prev = dummy->prev;
record->id = dummy->id;
dummy->prev->next = record;
dummy->prev = record;
dummy->size += 1;
dummy->id += 1;
memcpy(record->reference, allocation, size);
}
void delete_record(struct AllocationRecord *dummy, struct AllocationRecord *delete) {
free(delete->reference);
delete->prev->next = delete->next;
delete->next->prev = delete->prev;
free(delete);
dummy->size -= 1;
}
struct AllocationRecord *get_record(struct AllocationRecord *dummy, int which) {
struct AllocationRecord *head = dummy->next;
while (which--) {
head = head->next;
}
return head;
}
int validate_record(struct AllocationRecord *record) {
if (memcmp(record->allocation, record->reference, record->size) != 0) {
return 0;
}
return 1;
}
void new_region(struct AllocationRecord *dummy, struct Arena *arena) {
uintptr_t size = 1 + (rand() % 8192);
uintptr_t align = 1 << (rand() % 4);
printf("alloc'ing a region of size %lu with alignment %lu, id %i\n", size, align, dummy->id);
void *region = alloc(arena, size, align);
if (region == NULL) {
printf("memory allocator broke, we have 1L though\n");
return;
}
for (int ii = 0; ii < size; ii++) {
((char*) region)[ii] = (char) rand();
}
insert_record(dummy, region, size);
}
void delete_region(struct AllocationRecord *dummy, struct Arena *arena) {
if (dummy->size == 0) {
return;
}
uintptr_t which = rand() % dummy->size;
struct AllocationRecord *zap = get_record(dummy, which);
printf("dealloc'ing a region of size %lu, id %i\n", zap->size, zap->id);
unalloc(arena, zap->allocation);
delete_record(dummy, zap);
}
int act(struct AllocationRecord *dummy, struct Arena *arena) {
if (rand() & 1) {
new_region(dummy, arena);
} else {
delete_region(dummy, arena);
}
int die = 0;
struct AllocationRecord *head = dummy->next;
while (head != dummy) {
if (!validate_record(head)) {
printf("validation failed at id %i\n", head->id);
die = 1;
}
head = head->next;
}
return die;
}
int main() {
printf("Hello, World!\n");
srand(1);
struct Arena arena = {
NULL,
NULL,
@ -29,5 +122,16 @@ int main() {
};
void *reg = alloc(&arena, 20, 4);
unalloc(&arena, reg);
struct AllocationRecord dummy = {
.size = 0,
.allocation = NULL,
.reference = NULL,
.id = 0,
};
dummy.next = &dummy;
dummy.prev = &dummy;
for (int ii = 0; ii < 100; ii++) {
act(&dummy, &arena);
}
return 0;
}

785
tree_alloc.c

@ -7,16 +7,29 @@
#ifdef DEBUG
#include <stdio.h>
int debug_tree_black_height(TreeAlloc *node) {
if (node == NULL) {
return 1;
}
return ((node->color == COLOR_BLACK) ? 1 : 0) + debug_tree_black_height(node->left);
}
void debug_print_tree(int indent, void *p) {
TreeAlloc *node = (TreeAlloc*) p;
if (node != NULL) {
debug_print_tree(indent + 1, node->left);
for (int ii = 0; ii < indent; ii++) { printf(" "); }
if (node->color == COLOR_RED) { printf("\e[31"); }
printf("%p %lu\n", node, node->size);
if (node->color == COLOR_RED) { printf("\e[37"); }
debug_print_tree(indent + 1, node->right);
}
TreeAlloc *node = (TreeAlloc*) p;
if (node != NULL) {
int bad = debug_tree_black_height(node->left) != debug_tree_black_height(node->right);
bad |= node->color == COLOR_RED && ((node->left != NULL && node->left->color == COLOR_RED) ||
(node->right != NULL && node->right->color == COLOR_RED) || (node->parent != NULL &&
node->parent->color == COLOR_RED));
debug_print_tree(indent + 1, node->left);
for (int ii = 0; ii < indent; ii++) { printf(" "); }
if (node->color == COLOR_RED) { printf(bad ? "\e[30m]" : "\e[31m"); }
if (bad) { printf("\e[43m"); }
printf("%p %lu\n", node, node->size);
if (node->color == COLOR_RED) { printf("\e[37m"); }
if (bad) { printf("\e[40m"); }
debug_print_tree(indent + 1, node->right);
}
}
#endif
@ -29,26 +42,26 @@ TreeAlloc *insert_node_at(void *address, uintptr_t padding, uintptr_t align, uin
* Search for the node whose allocated region contains an address.
*/
TreeAlloc *search_by_address(TreeAlloc *root, void *address) {
TreeAlloc *head = root;
while (1) {
if (head > (TreeAlloc*) address) {
if (head->left == NULL) {
return NULL;
} else {
head = head->left;
}
} else {
if (head->right == NULL || head->right > (TreeAlloc*) address) {
return head;
} else {
head = head->right;
}
}
}
TreeAlloc *head = root;
while (1) {
if (head > (TreeAlloc*) address) {
if (head->left == NULL) {
return NULL;
} else {
head = head->left;
}
} else {
if (head->right == NULL || head->right > (TreeAlloc*) address) {
return head;
} else {
head = head->right;
}
}
}
}
static uintptr_t effective_size(TreeAlloc *head, uintptr_t padding, uintptr_t align) {
return head->size - (align_after(head + padding, align) - (void*) head);
return head->size - (align_after(head + padding, align) - (void*) head);
}
/*
@ -57,27 +70,55 @@ static uintptr_t effective_size(TreeAlloc *head, uintptr_t padding, uintptr_t al
* ordering.
*/
static uintptr_t pessimistic_size(TreeAlloc *head, uintptr_t padding, uintptr_t align) {
return head->size - padding - align + 1;
return head->size - padding - align + 1;
}
TreeAlloc *search_by_size(TreeAlloc *root, uintptr_t padding, uintptr_t align, uintptr_t size) {
TreeAlloc *head = root;
while (1) {
uintptr_t esize = pessimistic_size(head, padding, align);
if (esize < size) {
if (head->right == NULL) {
return NULL;
} else {
head = head->right;
}
} else {
if (head->left == NULL || pessimistic_size(head->left, padding, align) < size) {
return head;
} else {
head = head->left;
}
}
}
TreeAlloc *head = root;
while (1) {
uintptr_t esize = pessimistic_size(head, padding, align);
if (esize < size) {
if (head->right == NULL) {
return NULL;
} else {
head = head->right;
}
} else {
if (head->left == NULL || pessimistic_size(head->left, padding, align) < size) {
return head;
} else {
head = head->left;
}
}
}
}
TreeAlloc *succ(TreeAlloc *el) {
if (el->right != NULL) {
el = el->right;
while (el->left != NULL) {
el = el->left;
}
return el;
}
while (el->parent != NULL && el == el->parent->right) {
el = el->parent;
}
return el->parent;
}
TreeAlloc *pred(TreeAlloc *el) {
if (el->left != NULL) {
el = el->left;
while (el->right != NULL) {
el = el->right;
}
return el;
}
while (el->parent != NULL && el == el->parent->left) {
el = el->parent;
}
return el->parent;
}
TreeAlloc *get_sibling(TreeAlloc *ta) {
@ -91,90 +132,169 @@ TreeAlloc *get_sibling(TreeAlloc *ta) {
}
void rotate_left(TreeAlloc **root_ptr, TreeAlloc *ta) {
TreeAlloc *parent, *tmp;
parent = ta->parent;
tmp = ta->right;
if (!tmp) return;
ta->right = tmp->left;
tmp->left = ta;
ta->parent = tmp;
if (ta->right) ta->right->parent = ta;
if (parent == NULL) {
*root_ptr = tmp;
} else {
if (ta == parent->left)
parent->left = tmp;
else
parent->right = tmp;
}
tmp->parent = parent;
TreeAlloc *parent, *tmp;
tmp = ta->right;
parent = ta->parent;
ta->right = tmp->left;
if (ta->right) ta->right->parent = ta;
tmp->left = ta;
ta->parent = tmp;
tmp->parent = parent;
if (!parent) {
*root_ptr = tmp;
} else if (ta == parent->left) {
parent->left = tmp;
} else {
parent->right = tmp;
}
}
void rotate_right(TreeAlloc **root_ptr, TreeAlloc *ta) {
TreeAlloc *parent, *tmp;
parent = ta->parent;
tmp = ta->left;
if (!tmp) return;
ta->left = tmp->right;
tmp->right = ta;
ta->parent = tmp;
if (ta->left) ta->left->parent = ta;
if (parent == NULL) {
*root_ptr = tmp;
} else {
if (ta == parent->left)
parent->left = tmp;
else
parent->right = tmp;
}
tmp->parent = parent;
TreeAlloc *parent, *tmp;
tmp = ta->left;
parent = ta->parent;
ta->left = tmp->right;
if (ta->left) ta->left->parent = ta;
tmp->right = ta;
ta->parent = tmp;
tmp->parent = parent;
if (!parent) {
*root_ptr = tmp;
} else if (ta == parent->left) {
parent->left = tmp;
} else {
parent->right = tmp;
}
}
#define IS_BLACK_NODE(n) (n == NULL || n->color == COLOR_BLACK)
#define IS_RED_NODE(n) (n != NULL && n->color == COLOR_RED)
void repair_tree_after_insert(TreeAlloc **root_ptr, TreeAlloc *ta) {
TreeAlloc *parent = ta->parent;
if (parent == NULL) {
#ifdef DEBUG
printf("=== PRE-INSERT-FIXUP ===\n");
printf("===== CURRENT TREE =====\n");
debug_print_tree(0, *root_ptr);
printf("===== END OF TREES =====\n");
#endif
if (ta == *root_ptr) {
ta->color = COLOR_BLACK;
} else if (IS_BLACK_NODE(parent)) {
return;
}
TreeAlloc *grandparent = parent->parent;
TreeAlloc *uncle = get_sibling(parent);
} else {
TreeAlloc *uncle = get_sibling(parent);
TreeAlloc *grandparent = parent->parent;
if (parent->color == COLOR_RED) {
if (uncle != NULL && uncle->color == COLOR_RED) {
if (IS_RED_NODE(uncle)) {
parent->color = COLOR_BLACK;
uncle->color = COLOR_BLACK;
grandparent->color = COLOR_RED;
grandparent->color = COLOR_RED;
repair_tree_after_insert(root_ptr, grandparent);
} else {
if (ta == parent->left && parent == grandparent->left) {
rotate_left(root_ptr, parent);
ta = ta->left;
if (parent->left == ta) {
if (grandparent->left == parent) {
rotate_right(root_ptr, grandparent);
grandparent->color = COLOR_RED;
parent->color = COLOR_BLACK;
} else {
rotate_right(root_ptr, parent);
ta = ta->right;
rotate_right(root_ptr, parent);
rotate_left(root_ptr, grandparent);
grandparent->color = COLOR_RED;
ta->color = COLOR_BLACK;
}
parent = ta->parent;
grandparent = parent->parent;
if (ta == parent->left) {
rotate_right(root_ptr, grandparent);
} else {
if (grandparent->left == parent) {
rotate_left(root_ptr, parent);
rotate_right(root_ptr, grandparent);
grandparent->color = COLOR_RED;
ta->color = COLOR_BLACK;
} else {
rotate_left(root_ptr, grandparent);
rotate_left(root_ptr, grandparent);
grandparent->color = COLOR_RED;
parent->color = COLOR_BLACK;
}
parent->color = COLOR_BLACK;
grandparent->color = COLOR_RED;
}
}
}
}
// Inserts a node into an empty tree.
void insert_singleton(TreeAlloc **root_ptr, TreeAlloc *to_insert) {
#ifdef DEBUG
printf("= PRE-INSERT-SINGLETON =\n");
printf("===== CURRENT TREE =====\n");
debug_print_tree(0, *root_ptr);
printf("===== END OF TREES =====\n");
#endif
*root_ptr = to_insert;
to_insert->parent = NULL;
to_insert->color = COLOR_BLACK;
#ifdef DEBUG
printf("= POST-INSERT-SINGLETON =\n");
printf("===== CURRENT TREE =====\n");
debug_print_tree(0, *root_ptr);
printf("===== END OF TREES =====\n");
#endif
}
void insert_right(TreeAlloc** root_ptr, TreeAlloc* to_insert, TreeAlloc* after) {
#ifdef DEBUG
printf("=== PRE-INSERT-RIGHT ===\n");
printf("===== INSERTING =====\n");
debug_print_tree(0, to_insert);
printf("===== CURRENT TREE =====\n");
debug_print_tree(0, *root_ptr);
printf("===== END OF TREES =====\n");
#endif
if (after->right != NULL) {
after->right->parent = to_insert;
to_insert->right = after->right;
}
after->right = to_insert;
to_insert->parent = after;
to_insert->color = COLOR_RED;
repair_tree_after_insert(root_ptr, to_insert);
#ifdef DEBUG
printf("== POST-INSERT-FIXUP ===\n");
printf("===== CURRENT TREE =====\n");
debug_print_tree(0, *root_ptr);
printf("===== END OF TREES =====\n");
#endif
}
void insert_left(TreeAlloc** root_ptr, TreeAlloc* to_insert, TreeAlloc* before) {
#ifdef DEBUG
printf("=== PRE-INSERT-LEFT ====\n");
printf("===== INSERTING =====\n");
debug_print_tree(0, to_insert);
printf("===== CURRENT TREE =====\n");
debug_print_tree(0, *root_ptr);
printf("===== END OF TREES =====\n");
#endif
if (before->left != NULL) {
before->left->parent = to_insert;
to_insert->left = before->left;
}
before->left = to_insert;
to_insert->parent = before;
to_insert->color = COLOR_RED;
repair_tree_after_insert(root_ptr, to_insert);
#ifdef DEBUG
printf("== POST-INSERT-FIXUP ===\n");
printf("===== CURRENT TREE =====\n");
debug_print_tree(0, *root_ptr);
printf("===== END OF TREES =====\n");
#endif
}
void replace_node(TreeAlloc **root_ptr, TreeAlloc *node, TreeAlloc *replace) {
@ -190,24 +310,25 @@ void replace_node(TreeAlloc **root_ptr, TreeAlloc *node, TreeAlloc *replace) {
}
void repair_after_remove(TreeAlloc **root_ptr, TreeAlloc *node) {
if (node->color == COLOR_RED) {
if (IS_RED_NODE(node)) {
node->color = COLOR_BLACK;
} else {
TreeAlloc *sibling = get_sibling(node);
if (sibling->color == COLOR_RED) {
if (node->parent->left == node)
if (IS_RED_NODE(sibling)) {
if (node->parent->left == node) {
rotate_left(root_ptr, node->parent);
else
} else {
rotate_right(root_ptr, node->parent);
}
node->parent->parent->color = node->parent->color = COLOR_BLACK;
}
if (sibling->left->color == COLOR_BLACK && sibling->right->color == COLOR_BLACK) {
if (IS_BLACK_NODE(sibling->left) && IS_BLACK_NODE(sibling->right)) {
node->color = COLOR_BLACK;
sibling->color = COLOR_RED;
repair_after_remove(root_ptr, node->parent);
} else {
if (node->parent->left == node && sibling->right->color == COLOR_BLACK) {
if (node->parent->left == node && IS_BLACK_NODE(sibling)) {
rotate_right(root_ptr, sibling);
sibling = get_sibling(node);
sibling->color = COLOR_RED;
@ -215,7 +336,7 @@ void repair_after_remove(TreeAlloc **root_ptr, TreeAlloc *node) {
rotate_left(root_ptr, node->parent);
node->color = get_sibling(node->parent)->color = COLOR_BLACK;
} else if (node->parent->right == node && sibling->left->color == COLOR_BLACK) {
} else if (node->parent->right == node && IS_BLACK_NODE(sibling)) {
rotate_left(root_ptr, sibling);
sibling = get_sibling(node);
sibling->color = COLOR_RED;
@ -231,229 +352,277 @@ void repair_after_remove(TreeAlloc **root_ptr, TreeAlloc *node) {
}
}
void remove_node(TreeAlloc **root_ptr, TreeAlloc *node) {
void remove_node(TreeAlloc **root_ptr, TreeAlloc *to_remove) {
char do_repair = 0;
#ifdef DEBUG
printf("====== PRE-REMOVE ======\n");
printf("===== REMOVING =====\n");
debug_print_tree(0, to_remove);
printf("===== CURRENT TREE =====\n");
debug_print_tree(0, *root_ptr);
printf("===== END OF TREES =====\n");
#endif
TreeAlloc *replace;
TreeAlloc *parent = node->parent;
if (!node->left) {
replace = node->right;
do_repair = node->color == COLOR_BLACK;
replace_node(root_ptr, node, replace);
} else if (!node->right) {
replace = node->left;
do_repair = node->color == COLOR_BLACK;
replace_node(root_ptr, node, replace);
TreeAlloc *parent = to_remove->parent;
if (!to_remove->left) {
replace = to_remove->right;
do_repair = to_remove->color == COLOR_BLACK;
replace_node(root_ptr, to_remove, replace);
} else if (!to_remove->right) {
replace = to_remove->left;
do_repair = to_remove->color == COLOR_BLACK;
replace_node(root_ptr, to_remove, replace);
} else {
TreeAlloc *tmp = node->right;
TreeAlloc *tmp = to_remove->right;
while (tmp->left) tmp = tmp->left;
replace = tmp->right;
do_repair = tmp->color == COLOR_BLACK;
if (tmp != node->right) {
if (tmp != to_remove->right) {
replace_node(root_ptr, tmp, replace);
tmp->right = node->right;
node->right->parent = tmp;
tmp->right = to_remove->right;
to_remove->right->parent = tmp;
}
replace_node(root_ptr, node, tmp);
tmp->color = node->color;
tmp->left = node->left;
node->left->parent = tmp;
replace_node(root_ptr, to_remove, tmp);
tmp->color = to_remove->color;
tmp->left = to_remove->left;
to_remove->left->parent = tmp;
}
if (do_repair && replace) {
// Make sure that it doesn't have any tree pointers it shouldn't have.
to_remove->parent = to_remove->left = to_remove->right = NULL;
if (replace && replace->parent == NULL) {
#ifdef DEBUG
printf("=== PRE-REMOVE-FIXUP ===\n");
printf("===== CURRENT TREE =====\n");
debug_print_tree(0, *root_ptr);
printf("===== END OF TREES =====\n");
#endif
replace->color = COLOR_BLACK;
} else if (do_repair && replace) {
#ifdef DEBUG
printf("=== PRE-REMOVE-FIXUP ===\n");
printf("===== CURRENT TREE =====\n");
debug_print_tree(0, *root_ptr);
printf("===== END OF TREES =====\n");
#endif
repair_after_remove(root_ptr, replace);
}
}
// Inserts a node into an empty tree.
void insert_singleton(TreeAlloc **root_ptr, TreeAlloc *to_insert) {
*root_ptr = to_insert;
to_insert->parent = NULL;
repair_tree_after_insert(root_ptr, to_insert);
}
void insert_right(TreeAlloc** root_ptr, TreeAlloc* to_insert, TreeAlloc* after) {
if (after->right != NULL) {
after->right->parent = to_insert;
to_insert->right = after->right;
}
after->right = to_insert;
to_insert->parent = after;
repair_tree_after_insert(root_ptr, to_insert);
}
void insert_left(TreeAlloc** root_ptr, TreeAlloc* to_insert, TreeAlloc* before) {
if (before->left != NULL) {
before->left->parent = to_insert;
to_insert->left = before->left;
}
before->left = to_insert;
to_insert->parent = before;
repair_tree_after_insert(root_ptr, to_insert);
#ifdef DEBUG
printf("=== POST-REMOVE ===\n");
printf("===== CURRENT TREE =====\n");
debug_print_tree(0, *root_ptr);
printf("===== END OF TREES =====\n");
#endif
}
int add_new_region(Arena *arena, uintptr_t size, uintptr_t padding, uintptr_t align) {
uintptr_t realsize = size + align + alignof(WatermarkAlloc) + padding - 1;
if (realsize < MIN_NEW_MEM_SIZE) {
realsize = MIN_NEW_MEM_SIZE;
}
FreeSpace *reg = (FreeSpace*) arena->get_new_region(realsize);
if (reg == NULL) {
arena->error("can't allocate a new memory region!");
return 0;
}
FreeSpace *newreg = align_after(reg, alignof(WatermarkAlloc));
newreg->left = NULL;
newreg->right = NULL;
realsize -= (void*) newreg - (void*) reg;
realsize -= realsize % alignof(WatermarkAlloc);
newreg->size = realsize;
if (arena->root_freespace == NULL) {
insert_singleton((TreeAlloc**) &arena->root_freespace, (TreeAlloc*) newreg);
} else {
FreeSpace *head = arena->root_freespace;
while (head->right != NULL) {
head = head->right;
}
insert_right((TreeAlloc**) arena->root_freespace, (TreeAlloc*) newreg, (TreeAlloc*) newreg);
}
return 1;
uintptr_t realsize = size + align + alignof(WatermarkAlloc) + padding - 1;
if (realsize < MIN_NEW_MEM_SIZE) {
realsize = MIN_NEW_MEM_SIZE;
}
FreeSpace *reg = (FreeSpace*) arena->get_new_region(realsize);
if (reg == NULL) {
arena->error("can't allocate a new memory region!");
return 0;
}
FreeSpace *newreg = align_after(reg, alignof(WatermarkAlloc));
newreg->left = NULL;
newreg->right = NULL;
realsize -= (void*) newreg - (void*) reg;
realsize -= realsize % alignof(WatermarkAlloc);
newreg->size = realsize;
if (arena->root_freespace == NULL) {
insert_singleton((TreeAlloc**) &arena->root_freespace, (TreeAlloc*) newreg);
} else {
FreeSpace *head = arena->root_freespace;
while (head->right != NULL) {
head = head->right;
}
insert_right((TreeAlloc**) &arena->root_freespace, (TreeAlloc*) newreg, (TreeAlloc*) head);
}
#ifdef DEBUG
printf("= POST-REGION-CREATION =\n");
printf("==== FREESPACE TREE ====\n");
debug_print_tree(0, arena->root_freespace);
printf("==== TREEALLOC TREE ====\n");
debug_print_tree(0, arena->root_treealloc);
printf("===== END OF TREES =====\n");
#endif
return 1;
}
void unalloc(Arena *arena, void *addr) {
#ifdef DEBUG
printf("==== UNALLOCATING ====\n");
printf("=== FREESPACE TREE ===\n");
debug_print_tree(0, arena->root_freespace);
printf("=== TREEALLOC TREE ===\n");
debug_print_tree(0, arena->root_treealloc);
printf("=== END OF TREES ====\n");
printf("==== UNALLOCATING ====\n");
printf("=== FREESPACE TREE ===\n");
debug_print_tree(0, arena->root_freespace);
printf("=== TREEALLOC TREE ===\n");
debug_print_tree(0, arena->root_treealloc);
printf("==== END OF TREES ====\n");
#endif
if (arena->root_treealloc == NULL) {
arena->error("attempt to unallocate when there are no allocations!");
return;
}
// Find the node this address belongs to
TreeAlloc *node = search_by_address(arena->root_treealloc, addr);
if (node == NULL) {
arena->error("attempt to free memory outside any allocations!");
return;
}
// Handle the watermark allocator in this region. If there are no more
// allocations stored inside of it, then the node can be freed by
// continuing into the code below after the watermark list has been
// cleaned up. Otherwise, the deallocation is already done.
if (node->type == RT_WATERMARK) {
WatermarkAlloc *wma = (WatermarkAlloc *) node;
wma->num_allocs -= 1;
if (wma->num_allocs > 0)
if (arena->root_treealloc == NULL) {
arena->error("attempt to unallocate when there are no allocations!");
return;
}
// Find the node this address belongs to
TreeAlloc *node = search_by_address(arena->root_treealloc, addr);
if (node == NULL) {
arena->error("attempt to free memory outside any allocations!");
return;
if (wma->before)
wma->before->after = wma->after;
if (wma->after)
wma->after->before = wma->before;
}
// Get rid of it
remove_node(&arena->root_treealloc, node);
// If there's free space on either side of it, merge it with the free space into a bigger chunk of
// free space.
uintptr_t size = node->size;
FreeSpace *start = (FreeSpace*) node;
if (node->before != NULL && node->before->type == RT_FREESPACE) {
start = (FreeSpace*) node->before;
size += node->before->size;
remove_node((TreeAlloc**) &arena->root_freespace, node->before);
}
if (node->after != NULL && node->after->type == RT_FREESPACE) {
size += node->after->size;
remove_node((TreeAlloc**) &arena->root_freespace, node->after);
}
start->type = RT_FREESPACE;
start->size = size;
// And finally, insert the resulting free space.
if (arena->root_freespace == NULL) {
insert_singleton((TreeAlloc**) &arena->root_freespace, (TreeAlloc*) start);
} else {
TreeAlloc *insert_point = search_by_size((TreeAlloc*) arena->root_freespace, 0, 1, size);
if (insert_point == NULL) {
TreeAlloc *head = (TreeAlloc*) arena->root_freespace;
while (head->right != NULL) {
head = head->right;
}
insert_right((TreeAlloc**) &arena->root_freespace, (TreeAlloc*) start, head);
} else {
insert_left((TreeAlloc**) &arena->root_freespace, (TreeAlloc*) start, insert_point);
}
}
}
// Handle the watermark allocator in this region
if (node->type == RT_WATERMARK) {
// TODO: handle watermark deallocation
return;
}
// Get rid of it
remove_node(&arena->root_treealloc, node);
// If there's free space on either side of it, merge it with the free space into a bigger chunk of
// free space.
uintptr_t size = node->size;
FreeSpace *start = (FreeSpace*) node;
if (node->before != NULL && node->before->type == RT_FREESPACE) {
start = (FreeSpace*) node->before;
size += node->before->size;
remove_node((TreeAlloc**) &arena->root_freespace, node->before);
}
if (node->after != NULL && node->after->type == RT_FREESPACE) {
size += node->after->size;
remove_node((TreeAlloc**) &arena->root_freespace, node->after);
}
start->type = RT_FREESPACE;
start->size = size;
// And finally, insert the resulting free space.
if (arena->root_freespace == NULL) {
insert_singleton((TreeAlloc**) &arena->root_freespace, (TreeAlloc*) start);
} else {
TreeAlloc *insert_point = search_by_size((TreeAlloc*) arena->root_freespace, 0, 1, size);
if (insert_point == NULL) {
TreeAlloc *head = (TreeAlloc*) arena->root_freespace;
while (head->right != NULL) {
head = head->right;
}
insert_right((TreeAlloc**) &arena->root_freespace, (TreeAlloc*) start, head);
} else {
insert_left((TreeAlloc**) &arena->root_freespace, (TreeAlloc*) start, insert_point);
}
}
}
void *alloc(Arena *arena, uintptr_t size, uintptr_t align) {
uintptr_t actual_align = lcm(alignof(struct WatermarkAlloc), align);
uintptr_t actual_align = lcm(alignof(struct WatermarkAlloc), align);
#ifdef DEBUG
printf("==== ALLOCATING =====\n");
printf("=== FREESPACE TREE ===\n");
debug_print_tree(0, arena->root_freespace);
printf("=== TREEALLOC TREE ===\n");
debug_print_tree(0, arena->root_treealloc);
printf("==== END OF TREES ====\n");
#endif
if (arena->root_freespace == NULL) {
// Handle being out of freespace.
#ifdef DEBUG
printf("Out of freespace nodes; getting more\n");
#endif
if (!add_new_region(arena, size, sizeof(TreeAlloc), actual_align)) {
return NULL;
}
return alloc(arena, size, align);
} else {
TreeAlloc *region = search_by_size((TreeAlloc*) arena->root_freespace, sizeof(TreeAlloc), actual_align, size);
if (region == NULL) {
// Handle insufficient freespace or fragmentation.
#ifdef DEBUG
printf("==== ALLOCATING =====\n");
printf("=== FREESPACE TREE ===\n");
debug_print_tree(0, arena->root_freespace);
printf("=== TREEALLOC TREE ===\n");
debug_print_tree(0, arena->root_treealloc);
printf("=== END OF TREES ====\n");
printf("Out of sufficiently large freespace nodes; getting more\n");
#endif
if (arena->root_freespace == NULL) {
// Handle being out of freespace.
if (!add_new_region(arena, size, sizeof(TreeAlloc), actual_align)) {
return NULL;
}
return alloc(arena, size, align);
} else {
TreeAlloc *region = search_by_size((TreeAlloc*) arena->root_freespace, sizeof(WatermarkAlloc), actual_align, size);
if (region == NULL) {
// Handle insufficient freespace or fragmentation.
if (!add_new_region(arena, size, sizeof(WatermarkAlloc), actual_align)) {
return NULL;
}
return alloc(arena, size, align);
}
remove_node((TreeAlloc**) &arena->root_freespace, region);
void *true_end = align_after(align_after(((void*) region) + sizeof(WatermarkAlloc), actual_align) + size, alignof(WatermarkAlloc));
// The size of the new allocation (adjusted for region header and alignment
uintptr_t new_size = true_end - (void*) region;
// The size of the free space region following the new allocation
uintptr_t new_free_size = region->size - new_size;
region->right = NULL;
region->left = NULL;
region->type = RT_TREE_NODE;
if (!add_new_region(arena, size, sizeof(TreeAlloc), actual_align)) {
return NULL;
}
return alloc(arena, size, align);
}
remove_node((TreeAlloc**) &arena->root_freespace, region);
void *true_end = align_after(align_after(((void*) region) + sizeof(TreeAlloc), actual_align) + size, alignof(WatermarkAlloc));
// The size of the new allocation (adjusted for region header and alignment
uintptr_t new_size = true_end - (void*) region;
// The size of the free space region following the new allocation
uintptr_t new_free_size = region->size - new_size;
region->right = NULL;
region->left = NULL;
region->type = RT_TREE_NODE;
#ifdef DEBUG
printf("sizeof(TreeAlloc): %lu\n", (uintptr_t) sizeof(WatermarkAlloc));
printf("start: %p, end: %p, adjusted end: %p\n", region, ((void*) region) + size, true_end);
printf("size: %lu -> %lu\n", size, new_size);
printf("start: %p, end: %p, adjusted end: %p\n", region, ((void*) region) + size, true_end);
printf("size: %lu -> %lu\n", size, new_size);
#endif
if (arena->root_treealloc == NULL) {
insert_singleton((TreeAlloc**) &arena->root_treealloc, region);
} else {
TreeAlloc *insert_point = search_by_address((TreeAlloc*) arena->root_treealloc, region);
insert_right(&arena->root_treealloc, region, insert_point);
}
if (new_free_size >= sizeof(FreeSpace)) {
// If there's enough free space after the allocation, use it!
region->size = new_size; // Safe because the allocated region tree is not sorted by size.
FreeSpace *new_free = (FreeSpace*) ((void*) region + new_size);
new_free->left = NULL;
new_free->right = NULL;
new_free->type = RT_FREESPACE;
new_free->size = new_free_size;
if (arena->root_freespace == NULL) {
insert_singleton((TreeAlloc**) &arena->root_freespace, (TreeAlloc*) new_free);
} else {
FreeSpace *insert_point = (FreeSpace*) search_by_size((TreeAlloc*) arena->root_freespace, 0, 1, new_free_size);
insert_left((TreeAlloc**) &arena->root_freespace, (TreeAlloc*) new_free, (TreeAlloc*) insert_point);
}
}
return align_after(region + sizeof(TreeAlloc), actual_align);
}
if (arena->root_treealloc == NULL) {
insert_singleton((TreeAlloc**) &arena->root_treealloc, region);
} else {
#ifdef DEBUG
printf("searching for an insert point\n");
#endif
TreeAlloc *insert_point = search_by_address((TreeAlloc*) arena->root_treealloc, region);
if (insert_point == NULL) {
TreeAlloc *head = arena->root_treealloc;
while (head->left != NULL) {
head = head->left;
}
#ifdef DEBUG
printf("none found; inserting before %p\n", head);
#endif
insert_left(&arena->root_treealloc, region, head);
} else {
#ifdef DEBUG
printf("found one: %p\n", insert_point);
#endif
insert_right(&arena->root_treealloc, region, insert_point);
}
}
if (new_free_size >= sizeof(FreeSpace)) {
// If there's enough free space after the allocation, use it!
region->size = new_size; // Safe because the allocated region tree is not sorted by size.
FreeSpace *new_free = (FreeSpace*) ((void*) region + new_size);
new_free->left = NULL;
new_free->right = NULL;
new_free->type = RT_FREESPACE;
new_free->size = new_free_size;
if (arena->root_freespace == NULL) {
insert_singleton((TreeAlloc**) &arena->root_freespace, (TreeAlloc*) new_free);
} else {
FreeSpace *insert_point = (FreeSpace*) search_by_size((TreeAlloc*) arena->root_freespace, 0, 1, new_free_size);
insert_left((TreeAlloc**) &arena->root_freespace, (TreeAlloc*) new_free, (TreeAlloc*) insert_point);
}
// Set the region following this one to be the new free space
region->after = (TreeAlloc*) new_free;
} else {
// There isn't a free space after this one, so put the `next` pointer at the next allocated
// region.
region->after = succ(region);
}
// I seem to have forgotten about the fact that memory may not be contiguous
if (region->after != NULL && region->after != (void*) region + region->size) {
region->after = NULL;
}
// Also make sure the `before` pointer is correct.
TreeAlloc *before_alloc = pred(region);
if (before_alloc == NULL || ((void*) before_alloc) + before_alloc->size < (void*) region) {
region->before = search_by_address((TreeAlloc*) arena->root_freespace, region);
} else {
region->before = before_alloc;
}
// I seem to have forgotten about the fact that memory may not be contiguous
if (region->before != NULL && region->before != (void*) region->before + region->before->size) {
region->before = NULL;
}
#ifdef DEBUG
printf("region is still at %p\n", region);
#endif
return align_after((void*) region + sizeof(TreeAlloc), actual_align);
}
}
void *alloc_growable(Arena *arena, uintptr_t size, uintptr_t align) {
// TODO: Basically the same as above, but put the allocated region in the center of the largest free
// space. Due to alignment and whatnot, the code will be gory.
return NULL;
// TODO: Basically the same as above, but put the allocated region in the center of the largest free
// space. Due to alignment and whatnot, the code will be gory.
return NULL;
}
Loading…
Cancel
Save