Heap linked list implementation

Makefile

@@ -1,4 +1,18 @@
 CFLAGS=-Wall -Wextra -Werror -std=c11 -pedantic -ggdb
 
-heap: main.c heap.c heap.h
-	$(CC) $(CFLAGS) -o heap main.c heap.c
+# Default target
+all: clean heap
+
+# Target for building heap with heap1.c
+chunk: main.c heap_using_chunk_lists.c heap.h chunk_lists.h
+	$(CC) $(CFLAGS) -o heap main.c heap_using_chunk_lists.c logger.c
+
+# Target for building heap with heap2.c
+linkedlist: main.c heap_using_linked_lists.c heap.h logger.c logger.h linked_list.h
+	$(CC) $(CFLAGS) -o heap main.c heap_using_linked_lists.c logger.c
+
+# Target for cleaning up
+clean:
+	rm -f heap
+
+.PHONY: all heap1 heap2 clean

README.md

@@ -4,8 +4,15 @@
 
 ## Quick Start
 
+### To run original implementation
 ```console
-$ make
+$ make chunk
+$ ./heap
+```
+
+### Alternative Implementation
+```console
+$ make linkedlist
 $ ./heap
 ```
 

chunk_lists.h

@@ -0,0 +1,37 @@
+#ifndef CHUNK_LISTS_H_
+#define CHUNK_LISTS_H_
+
+#include <assert.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#define UNIMPLEMENTED \
+    do { \
+        fprintf(stderr, "%s:%d: %s is not implemented yet\n", \
+                __FILE__, __LINE__, __func__); \
+        abort(); \
+    } while(0)
+
+#define CHUNK_LIST_CAP 1024
+
+typedef struct {
+    uintptr_t *start;
+    size_t size;
+} Chunk;
+
+typedef struct {
+    size_t count;
+    Chunk chunks[CHUNK_LIST_CAP];
+} Chunk_List;
+
+extern Chunk_List alloced_chunks;
+extern Chunk_List freed_chunks;
+extern Chunk_List tmp_chunks;
+
+void chunk_list_insert(Chunk_List *list, void *start, size_t size);
+void chunk_list_merge(Chunk_List *dst, const Chunk_List *src);
+void chunk_list_dump(const Chunk_List *list, const char *name);
+int chunk_list_find(const Chunk_List *list, uintptr_t *ptr);
+void chunk_list_remove(Chunk_List *list, size_t index);
+
+#endif //CHUNK_LISTS_H_

heap.h

@@ -5,13 +5,6 @@
 #include <stdint.h>
 #include <stdlib.h>
 
-#define UNIMPLEMENTED \
-    do { \
-        fprintf(stderr, "%s:%d: %s is not implemented yet\n", \
-                __FILE__, __LINE__, __func__); \
-        abort(); \
-    } while(0)
-
 #define HEAP_CAP_BYTES 640000
 static_assert(HEAP_CAP_BYTES % sizeof(uintptr_t) == 0,
               "The heap capacity is not divisible by "
@@ -24,27 +17,6 @@ extern const uintptr_t *stack_base;
 void *heap_alloc(size_t size_bytes);
 void heap_free(void *ptr);
 void heap_collect();
+void run_tests(void); 
 
-#define CHUNK_LIST_CAP 1024
-
-typedef struct {
-    uintptr_t *start;
-    size_t size;
-} Chunk;
-
-typedef struct {
-    size_t count;
-    Chunk chunks[CHUNK_LIST_CAP];
-} Chunk_List;
-
-extern Chunk_List alloced_chunks;
-extern Chunk_List freed_chunks;
-extern Chunk_List tmp_chunks;
-
-void chunk_list_insert(Chunk_List *list, void *start, size_t size);
-void chunk_list_merge(Chunk_List *dst, const Chunk_List *src);
-void chunk_list_dump(const Chunk_List *list, const char *name);
-int chunk_list_find(const Chunk_List *list, uintptr_t *ptr);
-void chunk_list_remove(Chunk_List *list, size_t index);
-
-#endif // HEAP_H_
+#endif // HEAP_H_

heap.c → heap_using_chunk_lists.c

@@ -1,7 +1,9 @@
+
 #include <stdio.h>
 #include <stdbool.h>
 #include <string.h>
-#include "./heap.h"
+#include "heap.h"
+#include "chunk_lists.h"
 
 uintptr_t heap[HEAP_CAP_WORDS] = {0};
 const uintptr_t *stack_base = 0;
@@ -162,3 +164,84 @@ void heap_collect()
         heap_free(to_free[i]);
     }
 }
+
+/*-------------------------MAIN FUNCTION IMPLEMENTATION-------------------------------*/
+
+#define JIM_IMPLEMENTATION
+#include "jim.h"
+
+typedef struct Node Node;
+
+struct Node {
+    char x;
+    Node *left;
+    Node *right;
+};
+
+Node *generate_tree(size_t level_cur, size_t level_max)
+{
+    if (level_cur < level_max) {
+        Node *root = heap_alloc(sizeof(*root));
+        assert((char) level_cur - 'a' <= 'z');
+        root->x = level_cur + 'a';
+        root->left = generate_tree(level_cur + 1, level_max);
+        root->right = generate_tree(level_cur + 1, level_max);
+        return root;
+    } else {
+        return NULL;
+    }
+}
+
+void print_tree(Node *root, Jim *jim)
+{
+    if (root != NULL) {
+        jim_object_begin(jim);
+
+        jim_member_key(jim, "value");
+        jim_string_sized(jim, &root->x, 1);
+
+        jim_member_key(jim, "left");
+        print_tree(root->left, jim);
+
+        jim_member_key(jim, "right");
+        print_tree(root->right, jim);
+
+        jim_object_end(jim);
+    } else {
+        jim_null(jim);
+    }
+}
+
+#define N 10
+
+void *ptrs[N] = {0};
+
+void run_tests(void)
+{
+    stack_base = (const uintptr_t*)__builtin_frame_address(0);
+
+    for (size_t i = 0; i < 10; ++i) {
+        heap_alloc(i);
+    }
+
+    Node *root = generate_tree(0, 3);
+
+    printf("root: %p\n", (void*)root);
+
+    Jim jim = {
+        .sink = stdout,
+        .write = (Jim_Write) fwrite,
+    };
+
+    print_tree(root, &jim);
+
+    printf("\n------------------------------\n");
+    heap_collect();
+    chunk_list_dump(&alloced_chunks, "Alloced");
+    chunk_list_dump(&freed_chunks, "Freed");
+    printf("------------------------------\n");
+    root = NULL;
+    heap_collect();
+    chunk_list_dump(&alloced_chunks, "Alloced");
+    chunk_list_dump(&freed_chunks, "Freed");
+}