Add GC to VM

Author: heinthanth

includes/common.h

@@ -7,6 +7,8 @@
 
 //#define DEBUG_PRINT_CODE
 //#define DEBUG_TRACE_EXECUTION
+//#define DEBUG_STRESS_GC
+//#define DEBUG_LOG_GC
 
 #define UINT8_COUNT (UINT8_MAX + 1)
 

includes/compiler.h

@@ -5,5 +5,6 @@
 #include "object.h"
 
 ObjectFunction* compile(const char *source, const char *filename, int debugLeevl);
+void markCompilerRoots();
 
 #endif

includes/mem.h

@@ -3,6 +3,7 @@
 
 #include "common.h"
 #include "object.h"
+#include "compiler.h"
 
 #define GROW_ARRAY_SIZE(maxSize) ((maxSize) < 8 ? 8 : (maxSize)*2)
 #define GROW_ARRAY(t, pointer, oldSize, newSize) \
@@ -14,6 +15,9 @@
 #define FREE(t, pointer) reallocate(pointer, sizeof(t), 0)
 
 void *reallocate(void *pointer, size_t oldSize, size_t newSize);
+void markValue(Value value);
+void markObject(Object* object);
+void collectGarbage();
 void freeObjects();
 
 #endif

includes/object.h

@@ -31,6 +31,7 @@ struct Object
 {
     object_t t;
     struct Object *next;
+    bool isMarked;
 };
 
 typedef struct

includes/table.h

@@ -22,6 +22,8 @@ void freeTable(Table *table);
 bool tableGet(Table* table, ObjectString* k, Value* v);
 bool tableSet(Table *table, ObjectString *k, Value v);
 void tableAddAll(Table* from, Table* to);
+void tableRemoveWhite(Table* table);
+void markTable(Table* table);
 TableItem *findTableItem(TableItem *entries, int maxSize, ObjectString *k);
 ObjectString* tableFindString(Table* table, const char* chars, int length, uint32_t hash);
 bool tableDelete(Table* table, ObjectString* k);

includes/vm.h

@@ -10,7 +10,7 @@
 
 typedef struct
 {
-    ObjectClosure* closure;
+    ObjectClosure *closure;
     uint8_t *ip;
     Value *slots;
 } CallFrame;
@@ -23,8 +23,15 @@ typedef struct
     Value *stackTop;
     Table globals;
     Table strings;
-    ObjectUpvalue* openUpvalues;
+    ObjectUpvalue *openUpvalues;
+
+    size_t bytesAllocated;
+    size_t nextGC;
+
     Object *objects;
+    int grayCount;
+    int grayCapacity;
+    Object **grayStack;
 } VM;
 
 typedef enum

src/chunk.c

@@ -1,5 +1,6 @@
 #include "chunk.h"
 #include "mem.h"
+#include "vm.h"
 
 void initChunk(Chunk *chunk)
 {
@@ -51,7 +52,9 @@ void freeChunk(Chunk *chunk)
 
 int addConstant(Chunk *chunk, Value value)
 {
+    push(value);
     writeValueArr(&chunk->constants, value);
+    pop();
     return chunk->constants.size - 1;
 }
 

src/compiler.c

@@ -1187,4 +1187,14 @@ ObjectFunction *compile(const char *source, const char *filename, int debugLevel
 
     ObjectFunction *function = endCompiler(debugLevel);
     return parser.hadError ? NULL : function;
+}
+
+void markCompilerRoots()
+{
+    Compiler *compiler = current;
+    while (compiler != NULL)
+    {
+        markObject((Object *)compiler->function);
+        compiler = compiler->enclosing;
+    }
 }

src/mem.c

@@ -2,8 +2,27 @@
 #include "mem.h"
 #include "vm.h"
 
+#ifdef DEBUG_LOG_GC
+#include <stdio.h>
+#include "debug.h"
+#endif
+
+#define GC_HEAP_GROW_FACTOR 2
+
 void *reallocate(void *pointer, size_t oldSize, size_t newSize)
 {
+    vm.bytesAllocated += newSize - oldSize;
+    if (newSize > oldSize)
+    {
+#ifdef DEBUG_STRESS_GC
+        collectGarbage();
+#endif
+    }
+    if (vm.bytesAllocated > vm.nextGC)
+    {
+        collectGarbage();
+    }
+
     if (newSize == 0)
     {
         free(pointer);
@@ -15,8 +34,86 @@ void *reallocate(void *pointer, size_t oldSize, size_t newSize)
     return result;
 }
 
+void markObject(Object *object)
+{
+    if (object == NULL)
+        return;
+    if (object->isMarked)
+        return;
+#ifdef DEBUG_LOG_GC
+    printf("%p mark ", (void *)object);
+    printValue(OBJ_VAL(object));
+    printf("\n");
+#endif
+    object->isMarked = true;
+    if (vm.grayCapacity < vm.grayCount + 1)
+    {
+        vm.grayCapacity = GROW_ARRAY_SIZE(vm.grayCapacity);
+        vm.grayStack = realloc(vm.grayStack,
+                               sizeof(Object *) * vm.grayCapacity);
+
+        if (vm.grayStack == NULL)
+            exit(1);
+    }
+
+    vm.grayStack[vm.grayCount++] = object;
+}
+
+void markValue(Value value)
+{
+    if (!IS_OBJ(value))
+        return;
+    markObject(AS_OBJ(value));
+}
+
+static void markArray(ValueArr *array)
+{
+    for (int i = 0; i < array->maxSize; i++)
+    {
+        markValue(array->values[i]);
+    }
+}
+
+static void blackenObject(Object *object)
+{
+#ifdef DEBUG_LOG_GC
+    printf("%p blacken ", (void *)object);
+    printValue(OBJ_VAL(object));
+    printf("\n");
+#endif
+    switch (object->t)
+    {
+    case OBJECT_CLOSURE:
+    {
+        ObjectClosure *closure = (ObjectClosure *)object;
+        markObject((Object *)closure->function);
+        for (int i = 0; i < closure->upvalueCount; i++)
+        {
+            markObject((Object *)closure->upvalues[i]);
+        }
+        break;
+    }
+    case OBJECT_FUNCTION:
+    {
+        ObjectFunction *function = (ObjectFunction *)object;
+        markObject((Object *)function->name);
+        markArray(&function->chunk.constants);
+        break;
+    }
+    case OBJECT_UPVALUE:
+        markValue(((ObjectUpvalue *)object)->closed);
+        break;
+    case OBJECT_NATIVE:
+    case OBJECT_STRING:
+        break;
+    }
+}
+
 static void freeObject(Object *object)
 {
+#ifdef DEBUG_LOG_GC
+    printf("%p free type %d\n", (void *)object, object->t);
+#endif
     switch (object->t)
     {
     case OBJECT_STRING:
@@ -49,6 +146,88 @@ static void freeObject(Object *object)
     }
 }
 
+static void markRoots()
+{
+    for (Value *slot = vm.stack; slot < vm.stackTop; slot++)
+    {
+        markValue(*slot);
+    }
+    for (int i = 0; i < vm.frameCount; i++)
+    {
+        markObject((Object *)vm.frames[i].closure);
+    }
+    for (ObjectUpvalue *upvalue = vm.openUpvalues;
+         upvalue != NULL;
+         upvalue = upvalue->next)
+    {
+        markObject((Object *)upvalue);
+    }
+
+    markTable(&vm.globals);
+    markCompilerRoots();
+}
+
+static void traceReferences()
+{
+    while (vm.grayCount > 0)
+    {
+        Object *object = vm.grayStack[--vm.grayCount];
+        blackenObject(object);
+    }
+}
+
+static void sweep()
+{
+    Object *previous = NULL;
+    Object *object = vm.objects;
+    while (object != NULL)
+    {
+        if (object->isMarked)
+        {
+            object->isMarked = false;
+            previous = object;
+            object = object->next;
+        }
+        else
+        {
+            Object *unreached = object;
+            object = object->next;
+            if (previous != NULL)
+            {
+                previous->next = object;
+            }
+            else
+            {
+                vm.objects = object;
+            }
+
+            freeObject(unreached);
+        }
+    }
+}
+
+void collectGarbage()
+{
+#ifdef DEBUG_LOG_GC
+    printf("-- gc begin\n");
+    size_t before = vm.bytesAllocated;
+#endif
+
+    markRoots();
+    traceReferences();
+    tableRemoveWhite(&vm.strings);
+    sweep();
+
+    vm.nextGC = vm.bytesAllocated * GC_HEAP_GROW_FACTOR;
+
+#ifdef DEBUG_LOG_GC
+    printf("-- gc end\n");
+    printf("   collected %ld bytes (from %ld to %ld) next at %ld\n",
+           before - vm.bytesAllocated, before, vm.bytesAllocated,
+           vm.nextGC);
+#endif
+}
+
 void freeObjects()
 {
     Object *object = vm.objects;
@@ -58,4 +237,5 @@ void freeObjects()
         freeObject(object);
         object = next;
     }
+    free(vm.grayStack);
 }

src/object.c

@@ -14,9 +14,14 @@ static Object *allocateObject(size_t size, object_t t)
 {
     Object *object = (Object *)reallocate(NULL, 0, size);
     object->t = t;
+    object->isMarked = false;
 
     object->next = vm.objects;
     vm.objects = object;
+#ifdef DEBUG_LOG_GC
+    printf("%p allocate %ld for %d\n", (void *)object, size, t);
+#endif
+
     return object;
 }
 
@@ -37,7 +42,9 @@ static ObjectString *allocateString(char *chars, int length, uint32_t hash)
     string->length = length;
     string->chars = chars;
     string->hash = hash;
+    push(OBJ_VAL(string));
     tableSet(&vm.strings, string, NULL_VAL);
+    pop();
     return string;
 }
 

src/table.c

@@ -111,6 +111,28 @@ bool tableSet(Table *table, ObjectString *k, Value v)
     return isNew;
 }
 
+void markTable(Table *table)
+{
+    for (int i = 0; i < table->maxSize; i++)
+    {
+        TableItem *entry = &table->items[i];
+        markObject((Object *)entry->k);
+        markValue(entry->v);
+    }
+}
+
+void tableRemoveWhite(Table *table)
+{
+    for (int i = 0; i < table->maxSize; i++)
+    {
+        TableItem *entry = &table->items[i];
+        if (entry->k != NULL && !entry->k->object.isMarked)
+        {
+            tableDelete(table, entry->k);
+        }
+    }
+}
+
 bool tableDelete(Table *table, ObjectString *k)
 {
     if (table->size == 0)