164 lines
4 KiB
C
164 lines
4 KiB
C
#ifndef LINKED_LIST_C
|
|
#define LINKED_LIST_C
|
|
|
|
#include <stdbool.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
typedef struct ll_node {
|
|
void *data;
|
|
int size;
|
|
bool used;
|
|
|
|
struct ll_node *previous;
|
|
struct ll_node *next;
|
|
} ll_node;
|
|
|
|
ll_node *__new_node() {
|
|
ll_node *new_node = malloc(sizeof(ll_node));
|
|
new_node->data = NULL;
|
|
new_node->size = 0;
|
|
new_node->used = false;
|
|
|
|
new_node->previous = NULL;
|
|
new_node->next = NULL;
|
|
return new_node;
|
|
}
|
|
|
|
ll_node *__search_ll_node(ll_node *heap_head, void *data) {
|
|
ll_node *curr_node = heap_head;
|
|
while (!curr_node->used || curr_node->data != data) {
|
|
curr_node = curr_node->next;
|
|
}
|
|
return curr_node;
|
|
}
|
|
|
|
void *__alloc(ll_node *ll_head, int size) {
|
|
ll_node *curr_node = ll_head;
|
|
ll_node *new_node = __new_node();
|
|
new_node->used = true;
|
|
new_node->size = size;
|
|
|
|
while (curr_node->next != NULL) {
|
|
curr_node = curr_node->next;
|
|
|
|
if (!curr_node->used && curr_node->size >= size) {
|
|
curr_node->size -= size;
|
|
|
|
// xxx -> <new_node> -> empty block -> yyy
|
|
|
|
// link new_node to xxx
|
|
curr_node->previous->next = new_node;
|
|
new_node->previous = curr_node->previous;
|
|
|
|
// link new_node to empty_block or yyy
|
|
if (curr_node->size == 0) {
|
|
new_node->next = curr_node->next;
|
|
curr_node->next->previous = new_node;
|
|
free(curr_node);
|
|
} else {
|
|
new_node->next = curr_node;
|
|
curr_node->previous = new_node;
|
|
}
|
|
|
|
void *data = new_node->previous->data + new_node->previous->size;
|
|
new_node->data = data;
|
|
return new_node->data;
|
|
}
|
|
}
|
|
new_node->previous = curr_node;
|
|
curr_node->next = new_node;
|
|
|
|
void *data = new_node->previous->data + new_node->previous->size;
|
|
new_node->data = data;
|
|
return new_node->data;
|
|
}
|
|
|
|
void __free(ll_node *ll_head, void *data) {
|
|
// Search the corresponding block of memory
|
|
// TODO This can be held in a table for quicker lookup
|
|
ll_node *empty_node = __search_ll_node(ll_head, data);
|
|
empty_node->used = false;
|
|
|
|
// Free the node
|
|
if (!empty_node->previous->used) {
|
|
empty_node->size += empty_node->previous->size;
|
|
|
|
empty_node->previous->previous->next = empty_node;
|
|
|
|
ll_node* previous = empty_node->previous;
|
|
empty_node->previous = empty_node->previous->previous;
|
|
|
|
free(previous);
|
|
}
|
|
|
|
if (!empty_node->next->used) {
|
|
empty_node->size += empty_node->next->size;
|
|
|
|
empty_node->next->next->previous = empty_node;
|
|
|
|
ll_node* next = empty_node->next;
|
|
empty_node->next = empty_node->next->next;
|
|
|
|
free(next);
|
|
}
|
|
}
|
|
|
|
void print(ll_node *ll_head) {
|
|
printf("==== MEM DUMP ====\n");
|
|
ll_node *curr_node = ll_head;
|
|
while (curr_node != NULL) {
|
|
if (!curr_node->used) {
|
|
printf("empty");
|
|
} else {
|
|
printf("%p", curr_node->data);
|
|
}
|
|
printf(" (%d)\n", curr_node->size);
|
|
|
|
curr_node = curr_node->next;
|
|
}
|
|
printf("-------------------\n\n");
|
|
}
|
|
|
|
void test_allocs(){
|
|
ll_node *ll_head = __new_node();
|
|
ll_head->data = malloc(sizeof(size_t) * 1000);
|
|
ll_head->used = true;
|
|
ll_head->size = 1;
|
|
void* ptr0 = __alloc(ll_head, 5);
|
|
void* ptr1 = __alloc(ll_head, 5);
|
|
void* ptr4 = __alloc(ll_head, 5);
|
|
print(ll_head);
|
|
|
|
printf("Free nr 3\n");
|
|
__free(ll_head, ptr1);
|
|
print(ll_head);
|
|
|
|
printf("Alloc 3 bytes\n");
|
|
void* ptr2 = __alloc(ll_head, 3);
|
|
print(ll_head);
|
|
|
|
printf("Alloc 3 bytes\n");
|
|
__alloc(ll_head, 3);
|
|
print(ll_head);
|
|
|
|
printf("Alloc 2 bytes\n");
|
|
void* ptr3 = __alloc(ll_head, 2);
|
|
print(ll_head);
|
|
|
|
__free(ll_head, ptr2);
|
|
print(ll_head);
|
|
__free(ll_head, ptr4);
|
|
print(ll_head);
|
|
__free(ll_head, ptr3);
|
|
print(ll_head);
|
|
|
|
__free(ll_head, ptr0);
|
|
print(ll_head);
|
|
}
|
|
|
|
int main() {
|
|
test_allocs();
|
|
}
|
|
|
|
#endif // LINKED_LIST_C
|