mark and sweep

Author: paulfauthmayer

CMakeLists.txt

@@ -24,6 +24,7 @@ add_executable(scheme
   src/test.cpp
   src/repl.cpp
   src/setup.cpp
+  src/garbage_collection.cpp
   include/loguru.cpp
   )
 

src/environment.hpp

@@ -1,5 +1,6 @@
 #pragma once
 #include <map>
+// #include "garbage_collection.hpp"
 #include "scheme.hpp"
 
 namespace scm {
@@ -27,6 +28,8 @@ class Environment {
   friend void printEnv(Environment& env);
   friend Object* getVariable(Environment& env, Object* key);
   friend Object* getVariable(Environment& env, std::string& key);
+  // garbage collection
+  friend void mark(Environment& env);
 };
 
 void define(Environment& env, Object* key, Object* value);

src/garbage_collection.cpp

@@ -0,0 +1,133 @@
+#include "garbage_collection.hpp"
+#include <iostream>
+#include <list>
+#include <loguru.hpp>
+#include "environment.hpp"
+#include "scheme.hpp"
+
+namespace scm {
+
+// keep track of how many objects we've created in the lifetime of the program
+static int totalObjectCount{0};
+
+// keep track of all existing objects
+// std::vector<Collectable*> ObjectHeap;
+
+// constructor and destructor for Collectable class
+Collectable::Collectable() : marked(false)
+{
+  id = totalObjectCount++;
+  // keep track of the newly created object
+  ObjectHeap.push_back(this);
+  DLOG_IF_F(
+      INFO, LOG_GARBAGE_COLLECTION, "create Obj:%d (marked: %d)", static_cast<int>(id), marked);
+}
+
+Collectable::~Collectable()
+{
+  DLOG_IF_F(ERROR, LOG_GARBAGE_COLLECTION, "delete Obj:%d", static_cast<int>(id));
+}
+
+/**
+ * Marks a scheme object as not to be deleted during garbage collection.
+ * Will recursively call itself in case of cons objects.
+ * @param obj the pointer to an object that's to be marked.
+ */
+void markSchemeObject(Object* obj)
+{
+  switch (getTag(obj)) {
+    // in most cases, simply mark the object
+    case TAG_INT:
+    case TAG_FLOAT:
+    case TAG_STRING:
+    case TAG_SYMBOL:
+    case TAG_NIL:
+    case TAG_TRUE:
+    case TAG_FALSE:
+    case TAG_VOID:
+    case TAG_EOF:
+    case TAG_FUNC_BUILTIN:
+    case TAG_SYNTAX:
+      obj->marked = true;
+      break;
+    // user functions consist of two cons objects, the argument and bodylist
+    case TAG_FUNC_USER:
+      markSchemeObject(getUserFunctionArgList(obj));
+      markSchemeObject(getUserFunctionBodyList(obj));
+      break;
+    // recur until we've reached the end of the list
+    case TAG_CONS:
+      markSchemeObject(getCar(obj));
+      markSchemeObject(getCdr(obj));
+      break;
+
+    default:
+      schemeThrow("tag " + std::to_string(obj->tag) + " isn't handled yet");
+      break;
+  }
+};
+
+/**
+ * Mark all objects reachable from a given environment as not to be collected.
+ * @param env the environment from which an object needs to be reachable in order to be accepted
+ */
+void mark(Environment& env)
+{
+  for (auto& binding : env.bindings) {
+    DLOG_IF_F(INFO,
+              LOG_GARBAGE_COLLECTION,
+              "marking binding %s | %s",
+              binding.first.c_str(),
+              toString(binding.second).c_str());
+    markSchemeObject(binding.second);
+  }
+}
+
+/**
+ * Delete all objects that weren't marked or aren't essential.
+ */
+void sweep()
+{
+  int nObjectsBefore{static_cast<int>(ObjectHeap.size())};
+  for (auto i = ObjectHeap.begin(); i != ObjectHeap.end();) {
+    if (!(*i)->marked && !(*i)->essential) {
+      DLOG_IF_F(INFO,
+                LOG_GARBAGE_COLLECTION,
+                "delete %s %s",
+                tagToString(getTag((Object*)(*i))).c_str(),
+                toString((Object*)(*i)).c_str());
+      // TODO: this doesn't seem to work yet -> no deleting as of yet :)
+      // delete *i;
+      i = ObjectHeap.erase(i);
+    }
+    else {
+      DLOG_IF_F(INFO,
+                LOG_GARBAGE_COLLECTION,
+                "keep %s %s",
+                tagToString(((Object*)(*i))->tag).c_str(),
+                toString((Object*)(*i)).c_str());
+      (*i)->marked = false;
+      ++i;
+    }
+  }
+  int nObjectsAfter{static_cast<int>(ObjectHeap.size())};
+  DLOG_IF_F(WARNING,
+            LOG_GARBAGE_COLLECTION,
+            "cleaned up %d/%d objects",
+            nObjectsBefore - nObjectsAfter,
+            nObjectsBefore);
+}
+
+/**
+ * Check which objects are still reachable from a given environment and delete the rest.
+ * Implementation of a simple mark and sweep algorithm.
+ * @param env the environment from which the objects need to be reachable in order not to be
+ * deleted.
+ */
+void markAndSweep(Environment& env)
+{
+  mark(env);
+  sweep();
+}
+
+}  // namespace scm

src/garbage_collection.hpp

@@ -0,0 +1,30 @@
+#pragma once
+#include <iostream>
+#include <stack>
+#include <vector>
+// #include "environment.hpp"
+
+namespace scm {
+class Environment;
+
+/**
+ * The base class of every object that's supposed to be visible to the garbage collector.
+ */
+class Collectable {
+ public:
+  // a unique identifier of the object
+  long id;
+  // essential objects are never collected
+  bool essential;
+  // determines whether the object should be spared during the next sweeping cycle
+  bool marked;
+
+  Collectable();
+  virtual ~Collectable();
+};
+
+static std::vector<Collectable*> ObjectHeap;
+void markAndSweep(Environment& env);
+void mark(Environment& env);
+
+}  // namespace scm

src/memory.cpp

@@ -1,5 +1,6 @@
 #include "memory.hpp"
 #include <loguru.hpp>
+#include "garbage_collection.hpp"
 #include "scheme.hpp"
 
 namespace scm {
@@ -32,6 +33,8 @@ void initializeSingletons()
 Object* newSingleton(ObjectTypeTag type)
 {
   Object* obj{new Object(type)};
+  // singletons should never be deleted!
+  obj->essential = true;
   return obj;
 }
 
@@ -110,6 +113,8 @@ Object* newBuiltinFunction(std::string name, int numArgs, FunctionTag funcTag, s
 {
   Object* obj{new Object(TAG_FUNC_BUILTIN)};
   obj->value = FuncValue{"primitive:" + name, numArgs, funcTag, helpText};
+  // builtin functions should never be deleted!
+  obj->essential = true;
   return obj;
 };
 
@@ -127,6 +132,8 @@ Object* newSyntax(std::string name, int numArgs, FunctionTag funcTag, std::strin
 {
   Object* obj{new Object(TAG_SYNTAX)};
   obj->value = FuncValue{"syntax:" + name, numArgs, funcTag, helpText};
+  // builtin syntax should never be deleted!
+  obj->essential = true;
   return obj;
 }
 

src/operations.cpp

@@ -306,7 +306,8 @@ static Continuation* ifSyntax_Part1()
       break;
     }
     default: {
-      schemeThrow("evaluation not yet implemented for " + toString(evaluatedCondition));
+      schemeThrow("evaluation not yet implemented for " + toString(evaluatedCondition) +
+                  " with tag " + tagToString(evaluatedCondition->tag));
       break;
     }
   }

src/parse.cpp

@@ -217,6 +217,7 @@ Object* readInput(std::istream* streamPtr, bool isFile)
 
     // remove comments, as they shouldn't be interpreted
     line = line.substr(0, line.find(';'));
+    DLOG_IF_F(INFO, LOG_PARSER, "read line: %s", line.c_str());
 
     // split the read line into lexical elements and store them
     std::vector<std::string> split = splitLine(line);

src/repl.cpp

@@ -3,6 +3,7 @@
 #include <loguru.hpp>
 #include "environment.hpp"
 #include "evaluate.hpp"
+#include "garbage_collection.hpp"
 #include "memory.hpp"
 #include "parse.hpp"
 #include "scheme.hpp"
@@ -55,6 +56,9 @@ void repl(scm::Environment& env, std::istream* streamPtr, bool isFile)
       if (!isFile) {
         std::cout << '\n';
       }
+
+      // collect garbage if necessary
+      markAndSweep(env);
     }
     catch (scm::schemeException& e) {
       std::cerr << e.what() << '\n';
@@ -120,9 +124,11 @@ void printWelcome()
   std::stringstream ss(lambdaGraphics);
   std::string token;
   std::cout << "\n\n";
+  std::cout << loguru::terminal_bold() << loguru::terminal_green();
   while (std::getline(ss, token, '\n')) {
     printCentered(token);
   }
+  std::cout << loguru::terminal_reset();
   std::cout << "\n\n";
   printCentered("Welcome to Scheme++");
   printCentered("Version 1.0.0");

src/scheme.cpp

@@ -36,7 +36,7 @@ double getFloatValue(Object* obj)
 ConsValue getCons(Object* obj)
 {
   if (!hasTag(obj, TAG_CONS)) {
-    schemeThrow("tried to get consvalue from non-cons object");
+    schemeThrow("tried to get consvalue from non-cons object: " + toString(obj));
   }
   return std::get<ConsValue>(obj->value);
 }
@@ -144,9 +144,54 @@ bool LOG_PARSER = 0;
 bool LOG_STACK_TRACE = 0;
 bool LOG_TESTS = 1;
 bool LOG_TRAMPOLINE_TRACE = 0;
+bool LOG_GARBAGE_COLLECTION = 0;
 
 // other helper functions
 
+std::string tagToString(ObjectTypeTag tag)
+{
+  switch (tag) {
+    case TAG_INT:
+      return "integer";
+      break;
+    case TAG_FLOAT:
+      return "float";
+      break;
+    case TAG_STRING:
+      return "string";
+      break;
+    case TAG_SYMBOL:
+      return "symbol";
+      break;
+    case TAG_CONS:
+      return "cons";
+      break;
+    case TAG_NIL:
+      return "cons";
+      break;
+    case TAG_TRUE:
+      return "true";
+      break;
+    case TAG_FALSE:
+      return "false";
+      break;
+    case TAG_FUNC_BUILTIN:
+      return "builtin function";
+      break;
+    case TAG_FUNC_USER:
+      return "user function";
+      break;
+    case TAG_SYNTAX:
+      return "syntax";
+      break;
+    case TAG_VOID:
+      return "void";
+      break;
+    default:
+      return "unrecognized name";
+  };
+}
+
 static std::string consToString(scm::Object* cons, std::string& str)
 {
   scm::Object *car, *cdr;

src/scheme.hpp

@@ -6,6 +6,7 @@
 #include <stack>
 #include <string>
 #include <variant>
+#include "garbage_collection.hpp"
 
 namespace scm {
 
@@ -18,7 +19,6 @@ enum ObjectTypeTag {
   TAG_NIL,
   TAG_TRUE,
   TAG_FALSE,
-  TAG_ENV,
   TAG_FUNC_BUILTIN,
   TAG_FUNC_USER,
   TAG_SYNTAX,
@@ -78,10 +78,11 @@ struct UserFuncValue {
   Environment* env;
 };
 
-struct Object {
+struct Object : public Collectable {
   ObjectTypeTag tag;
   std::variant<int, double, std::string, ConsValue, FuncValue, UserFuncValue> value;
   Object(ObjectTypeTag tag) : tag(tag){};
+  ~Object(){};
 };
 
 class schemeException : public std::runtime_error {
@@ -131,6 +132,7 @@ bool isString(Object* obj);
 bool isNumeric(Object* obj);
 bool isFloatingPoint(Object* obj);
 bool isOneOf(Object* obj, std::vector<ObjectTypeTag> validTypes);
+std::string tagToString(ObjectTypeTag tag);
 std::string toString(scm::Object* obj);
 static std::string consToString(scm::Object* cons, std::string& str);
 std::string prettifyUserFunction(Object* func);
@@ -153,6 +155,7 @@ using ObjectStack = std::stack<Object*>;
 using FunctionStack = std::stack<Continuation*>;
 
 // logging activation
+extern bool LOG_GARBAGE_COLLECTION;
 extern bool LOG_TRAMPOLINE_TRACE;
 extern bool LOG_STACK_TRACE;
 extern bool LOG_PARSER;