feat: mark all root objects and values (users'program and compiler ones)

Author: aymaneelmaini

src/common.h

@@ -14,4 +14,7 @@ typedef uint32_t u32;
 #define DEBUG_PRINT_CODE
 #define DEBUG_TRACE_EXECUTION
 
+#define DEBUG_STRESS_GC
+#define DEBUG_LOG_GC
+
 #endif

src/compiler.c

@@ -6,6 +6,7 @@
 #include "chunk.h"
 #include "common.h"
 #include "compiler.h"
+#include "memory.h"
 #include "object.h"
 #include "scanner.h"
 #include "value.h"
@@ -986,3 +987,13 @@ ObjFunction* compile(const char* source)
     ObjFunction* function = end_compiler();
     return parser.had_error ? NULL : function;
 }
+
+void mark_compiler_roots()
+{
+    Compiler* compiler = current;
+    while (compiler != NULL)
+    {
+        mark_object((Obj*)compiler->function);
+        compiler = compiler->enclosing;
+    }
+}

src/compiler.h

@@ -5,5 +5,6 @@
 #include "object.h"
 
 ObjFunction* compile(const char* source);
+void         mark_compiler_roots();
 
 #endif

src/memory.c

@@ -1,13 +1,26 @@
 #include <stdlib.h>
 
 #include "chunk.h"
+#include "compiler.h"
 #include "memory.h"
 #include "object.h"
+#include "table.h"
 #include "value.h"
 #include "vm.h"
 
+#ifdef DEBUG_LOG_GC
+#include "debug.h"
+#include <stdio.h>
+#endif
+
 void* reallocate(void* pointer, size_t old_size, size_t new_size)
 {
+    if (new_size > old_size)
+    {
+#ifdef DEBUG_PRINT_CODE
+        collect_garbage();
+#endif
+    }
     if (new_size == 0)
     {
         free(pointer);
@@ -20,8 +33,35 @@ void* reallocate(void* pointer, size_t old_size, size_t new_size)
     return result;
 }
 
+void mark_object(Obj* object)
+{
+    if (object == NULL)
+        return;
+
+#ifdef DEBUG_LOG_GC
+    printf("%p mark ", (void*)object);
+    print_value(OBJ_VAL(object));
+    printf("\n");
+#endif
+
+    object->is_marked = true;
+}
+
+void mark_value(Value value)
+{
+    if (!IS_OBJ(value))
+        return;
+
+    mark_object(AS_OBJ(value));
+}
+
 static void free_object(Obj* object)
 {
+
+#ifdef DEBUG_LOG_GC
+    printf("%p free type %d\n", (void*)object, object->type);
+#endif
+
     switch (object->type)
     {
     case OBJ_CLOSURE:
@@ -57,6 +97,7 @@ static void free_object(Obj* object)
     }
     }
 }
+
 void free_objects()
 {
     Obj* object = vm.objects;
@@ -67,3 +108,38 @@ void free_objects()
         object = next;
     }
 }
+
+static void mark_roots()
+{
+    for (Value* slot = vm.stack; slot < vm.stack_top; slot++)
+    {
+        mark_value(*slot);
+    }
+
+    for (int i = 0; i < vm.frame_count; i++)
+    {
+        mark_object((Obj*)&vm.frames[i].closure);
+    }
+
+    // WALKING A LINKED LIST
+    for (ObjUpvalue* upvalue = vm.open_upvalues; upvalue != NULL; upvalue = upvalue->next)
+    {
+        mark_object((Obj*)upvalue);
+    }
+
+    mark_table(&vm.globals);
+    mark_compiler_roots();
+}
+
+void collect_garbage()
+{
+#ifdef DEBUG_LOG_GC
+    printf("-- GC Begins \n");
+#endif
+
+    mark_roots();
+
+#ifdef DEBUG_LOG_GC
+    printf("-- GC Ends \n");
+#endif
+}

src/memory.h

@@ -2,6 +2,7 @@
 #define clox_memory_h
 
 #include "common.h"
+#include "value.h"
 
 #define ALLOCATE(type, count) (type*)reallocate(NULL, 0, sizeof(type) * (count))
 
@@ -17,6 +18,9 @@
     reallocate(pointer, sizeof(type) * (oldCount), 0)
 
 void* reallocate(void* pointer, size_t old_size, size_t new_size);
+void  mark_object(Obj* object);
+void  mark_value(Value value);
+void  collect_garbage();
 void  free_objects();
 
 #endif

src/object.c

@@ -18,8 +18,13 @@ static Obj* allocate_object(size_t size, ObjType type)
     Obj* object = (Obj*)reallocate(NULL, 0, size);
     object->type = type;
     object->next = vm.objects;
+    object->is_marked = false;
     vm.objects = object;
 
+#ifdef DEBUG_LOG_GC
+    printf("%p allocate %ld for %d\n", (void*)object, size, type);
+#endif
+
     return object;
 }
 

src/object.h

@@ -32,6 +32,7 @@ typedef enum
 struct Obj
 {
     ObjType     type;
+    bool        is_marked;
     struct Obj* next;
 };
 

src/table.c

@@ -161,3 +161,13 @@ ObjString* table_find_string(Table* table, const char* chars, int length,
         index = (index + 1) % table->capacity;
     }
 }
+
+void mark_table(Table* table)
+{
+    for (int i = 0; i < table->capacity; i++)
+    {
+        Entry* entry = &table->entries[i];
+        mark_object((Obj*)entry->key);
+        mark_value(entry->value);
+    }
+}

src/table.h

@@ -23,7 +23,7 @@ bool       table_get(Table* table, ObjString* key, Value* value);
 bool       table_set(Table* table, ObjString* key, Value value);
 bool       table_delete(Table* table, ObjString* key);
 void       table_add_all(Table* from, Table* to);
-ObjString* table_find_string(Table* table, const char* chars, int length,
-                             u32 hash);
+ObjString* table_find_string(Table* table, const char* chars, int length, u32 hash);
+void       mark_table(Table* table);
 
 #endif