feat: implement garbage collection (mark/sweep)

Author: aymaneelmaini

src/memory.c

@@ -13,13 +13,21 @@
 #include <stdio.h>
 #endif
 
+#define GC_HEAP_GROW_FACTOR 2
+
 void* reallocate(void* pointer, size_t old_size, size_t new_size)
 {
+    vm.bytes_allocated += new_size - old_size;
+
     if (new_size > old_size)
     {
-#ifdef DEBUG_PRINT_CODE
+#ifdef DEBUG_STRESS_GC
         collect_garbage();
 #endif
+        if (vm.bytes_allocated > vm.next_GC)
+        {
+            collect_garbage();
+        }
     }
     if (new_size == 0)
     {
@@ -37,6 +45,8 @@ void mark_object(Obj* object)
 {
     if (object == NULL)
         return;
+    if (object->is_marked)
+        return;
 
 #ifdef DEBUG_LOG_GC
     printf("%p mark ", (void*)object);
@@ -45,6 +55,16 @@ void mark_object(Obj* object)
 #endif
 
     object->is_marked = true;
+
+    if (vm.gray_capacity < vm.gray_count + 1)
+    {
+        vm.gray_capacity = GROW_CAPACITY(vm.gray_capacity);
+        vm.gray_stack = realloc(vm.gray_stack, sizeof(Obj*) * vm.gray_capacity);
+
+        if (vm.gray_stack == NULL)
+            exit(1);
+    }
+    vm.gray_stack[vm.gray_count++] = object;
 }
 
 void mark_value(Value value)
@@ -55,6 +75,45 @@ void mark_value(Value value)
     mark_object(AS_OBJ(value));
 }
 
+static void mark_array(ValueArray* array)
+{
+    for (int i = 0; i < array->count; i++)
+    {
+        mark_value(array->values[i]);
+    }
+}
+
+static void blacken_object(Obj* object)
+{
+#ifdef DEBUG_LOG_GC
+    printf("%p blacken", (void*)object);
+    print_value(OBJ_VAL(object));
+    printf("\n");
+#endif  // DEbUG_LOG_GC
+    switch (object->type)
+    {
+    case OBJ_CLOSURE:
+        ObjClosure* closure = (ObjClosure*)object;
+        mark_object((Obj*)closure->function);
+        for (int i = 0; i < closure->upvalue_count; i++)
+        {
+            mark_object((Obj*)closure->upvalues[i]);
+        }
+        break;
+    case OBJ_FUNCTION:
+        ObjFunction* function = (ObjFunction*)object;
+        mark_object((Obj*)function->name);
+        mark_array(&function->chunk.constants);
+        break;
+    case OBJ_UPVALUE:
+        mark_value(((ObjUpvalue*)object)->closed);
+        break;
+    case OBJ_NATIVE:
+    case OBJ_STRING:
+        break;
+    }
+}
+
 static void free_object(Obj* object)
 {
 
@@ -107,6 +166,8 @@ void free_objects()
         free_object(object);
         object = next;
     }
+
+    free(vm.gray_stack);
 }
 
 static void mark_roots()
@@ -131,15 +192,58 @@ static void mark_roots()
     mark_compiler_roots();
 }
 
+static void trace_references()
+{
+    while (vm.gray_count > 0)
+    {
+        Obj* object = vm.gray_stack[--vm.gray_count];
+        blacken_object(object);
+    }
+}
+
+static void sweep()
+{
+    Obj* previous = NULL;
+    Obj* object = vm.objects;
+
+    while (object != NULL)
+    {
+        if (object->is_marked)
+        {
+            object->is_marked = false;
+            previous = object;
+            object = object->next;
+        }
+        else
+        {
+            Obj* unreached = object;
+            object = object->next;
+            if (previous != NULL)
+                previous->next = object;
+            else
+                vm.objects = object;
+            free_object(unreached);
+        }
+    }
+}
+
 void collect_garbage()
 {
 #ifdef DEBUG_LOG_GC
     printf("-- GC Begins \n");
+    size_t before = vm.bytes_allocated;
 #endif
 
     mark_roots();
+    trace_references();
+    table_remove_white(&vm.strings);
+    sweep();
+
+    vm.next_GC = vm.bytes_allocated * GC_HEAP_GROW_FACTOR;
 
 #ifdef DEBUG_LOG_GC
     printf("-- GC Ends \n");
+    printf("    collected %ld bytes (from %ld to %ld) next at %ld\n",
+           before - vm.bytes_allocated, before, vm.bytes_allocated, vm.next_GC);
 #endif
 }

src/table.c

@@ -162,6 +162,18 @@ ObjString* table_find_string(Table* table, const char* chars, int length,
     }
 }
 
+void table_remove_white(Table* table)
+{
+    for (int i = 0; i < table->count; i++)
+    {
+        Entry* entry = &table->entries[i];
+        if (entry->key != NULL && !entry->key->obj.is_marked)
+        {
+            table_delete(table, entry->key);
+        }
+    }
+}
+
 void mark_table(Table* table)
 {
     for (int i = 0; i < table->capacity; i++)

src/table.h

@@ -24,6 +24,7 @@ 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);
+void       table_remove_white(Table* table);
 void       mark_table(Table* table);
 
 #endif

src/vm.c

@@ -63,6 +63,13 @@ void init_VM()
     init_table(&vm.globals);
     init_table(&vm.strings);
 
+    vm.bytes_allocated = 0;
+    vm.next_GC = 1024 * 1024;
+
+    vm.gray_capacity = 0;
+    vm.gray_count = 0;
+    vm.gray_stack = NULL;
+
     define_native("clock", clock_native);
 }
 
@@ -199,20 +206,20 @@ static InterpretResult run()
 
 #define READ_BYTE() (*frame->ip++)
 #define READ_SHORT() (frame->ip += 2, (u16)(frame->ip[-2] << 8) | frame->ip[-1])
-#define READ_CONSTANT()                                                        \
+#define READ_CONSTANT() \
     (frame->closure->function->chunk.constants.values[READ_BYTE()])
 #define READ_STRING() AS_STRING(READ_CONSTANT())
-#define BINARY_OP(value_type, op)                                              \
-    do                                                                         \
-    {                                                                          \
-        if (!IS_NUMBER(peek(0)) || !IS_NUMBER(peek(1)))                        \
-        {                                                                      \
-            runtime_error("Operands must be numbers ");                        \
-            return INTERPRET_RUNTIME_ERROR;                                    \
-        }                                                                      \
-        double b = AS_NUMBER(pop());                                           \
-        double a = AS_NUMBER(pop());                                           \
-        push(value_type(a op b));                                              \
+#define BINARY_OP(value_type, op)                       \
+    do                                                  \
+    {                                                   \
+        if (!IS_NUMBER(peek(0)) || !IS_NUMBER(peek(1))) \
+        {                                               \
+            runtime_error("Operands must be numbers "); \
+            return INTERPRET_RUNTIME_ERROR;             \
+        }                                               \
+        double b = AS_NUMBER(pop());                    \
+        double a = AS_NUMBER(pop());                    \
+        push(value_type(a op b));                       \
     } while (false)
 
     for (;;)

src/vm.h

@@ -19,14 +19,19 @@ typedef struct
 
 typedef struct
 {
-    CallFrame frames[FRAMES_MAX];
-    int       frame_count;
-    Value     stack[STACK_MAX];
-    Value*    stack_top;
-    Table     globals;
-    Table     strings;  // for string interning just like (string pool in java)
+    CallFrame   frames[FRAMES_MAX];
+    int         frame_count;
+    Value       stack[STACK_MAX];
+    Value*      stack_top;
+    Table       globals;
+    Table       strings;  // for string interning just like (string pool in java)
     ObjUpvalue* open_upvalues;
+    size_t      bytes_allocated;
+    size_t      next_GC;
     Obj*        objects;
+    int         gray_capacity;
+    int         gray_count;
+    Obj**       gray_stack;
 } VM;
 
 typedef enum