Started with a rough structure

src/GC/include/allocator.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <assert.h>
+#include <memory>
+#include <stdlib.h>
+
+namespace GC {
+
+class Allocator {
+public:
+    Allocator(size_t size) {
+        alloc_size = size;
+    }
+
+    size_t getSize() {
+        return alloc_size;
+    }
+
+    void *alloc();
+
+private:
+    size_t alloc_size;
+
+
+};
+
+}

src/GC/include/heap.hpp

@@ -0,0 +1,62 @@
+#pragma once
+
+#include <assert.h>
+#include <iostream>
+#include <setjmp.h>
+#include <stdlib.h>
+#include <vector>
+
+#include "allocator.hpp"
+
+#define HEAP_SIZE   65536
+
+namespace GC {
+
+class Heap {
+public:
+
+    static Heap &the() {
+        if (s_instance)
+            return *s_instance;
+        s_instance = new Heap();
+        return *s_instance;
+    }
+
+    ~Heap() {
+
+    }
+
+    size_t getHeapSize() {
+        return heap_size;
+    }
+
+    Allocator *getAllocator(size_t size) {
+        for (auto *alloc : h_allocs) {
+            if (alloc->getSize() >= size)
+                return alloc;
+        }
+        std::cout << "Object too big" << std::endl;
+        assert(false);
+    }
+
+    void collect();
+
+private:
+    inline static Heap *s_instance = nullptr;
+
+    Heap() {
+        h_allocs.push_back(new Allocator(16));
+        h_allocs.push_back(new Allocator(32));
+        h_allocs.push_back(new Allocator(64));
+        h_allocs.push_back(new Allocator(128));
+        h_allocs.push_back(new Allocator(256));
+        h_allocs.push_back(new Allocator(512));
+        h_allocs.push_back(new Allocator(1024));
+    }
+
+    char _heap[HEAP_SIZE] = {0};
+    size_t heap_size = 0;
+    std::vector<Allocator *> h_allocs;
+};
+
+}

src/GC/include/heap_obj.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <cstdlib>
+
+class HeapObj {
+public:
+    HeapObj(size_t size_) {
+        size = size_;
+    }
+
+    ~HeapObj() { }
+
+private:
+    size_t size { 0 };
+    bool marked { false };
+};

src/GC/todo.md

@@ -0,0 +1,34 @@
+# Garbage collection
+
+## Algorithm
+
+Potential algorithms:
+- mark & sweep
+    - easy to implement
+    - slow
+- mark & compact
+    - no memory fragmentation
+    - slow
+- stop-copy algorithms (?)
+    - no memory fragmentation
+    - slow
+    - maybe good for FP langs?
+
+## Type hierarchy
+
+- Heap class
+    - Holds all memory
+        - Resizeable array?
+    - Singleton instance
+
+- Allocator class
+    - Allocates chunks of memory
+    - keeps track of chunks that are available and their sizes
+    - Several instances of allocator class with different sizes?
+
+- HeapObj class
+    - parent of all heap objects
+    - contains metadata
+        - size
+        - location
+        - marked bit