Beginning of GC architecture

Author: penelopeysm

src/compiler.cpp

@@ -1,7 +1,7 @@
 #include "compiler.hpp"
 #include "chunk.hpp"
-#include "scanner.hpp"
 #include "gc.hpp"
+#include "scanner.hpp"
 
 #include <cstdint>
 #include <functional>
@@ -118,10 +118,9 @@ size_t Compiler::declare_upvalue(Upvalue upvalue) {
 using lox::scanner::Scanner;
 using lox::scanner::TokenType;
 
-Parser::Parser(std::unique_ptr<Scanner> scanner, ObjFunction* fnptr,
-               StringMap& string_map)
+Parser::Parser(std::unique_ptr<Scanner> scanner, ObjFunction* fnptr, GC& gc)
     : scanner(std::move(scanner)), current(SENTINEL_EOF),
-      previous(SENTINEL_EOF), errmsg(std::nullopt), string_map(string_map),
+      previous(SENTINEL_EOF), errmsg(std::nullopt), gc(gc),
       compiler(std::make_unique<Compiler>(fnptr)) {}
 
 void Parser::advance() {
@@ -142,7 +141,7 @@ void Parser::function() {
   // updated on the fly later when we parse the function parameters.
   int arity = 0;
   // TODO: This copies the string. Do we need to?
-  auto new_fnptr = gc_new<ObjFunction>(fn_name, arity);
+  auto new_fnptr = gc.alloc<ObjFunction>(fn_name, arity);
   auto new_compiler =
       std::make_unique<Compiler>(new_fnptr, std::move(compiler));
   compiler = std::move(new_compiler);
@@ -407,7 +406,7 @@ void Parser::define_variable(std::string_view var_name) {
 }
 
 void Parser::define_global_variable(std::string_view name) {
-  ObjString* var_name_str = string_map.get_ptr(name);
+  ObjString* var_name_str = gc.get_string_ptr(name);
   // NOTE: we use make_constant here (not emit_constant) because we don't want
   // to emit a CONSTANT instruction right now. If we did so then the VM would
   // interpret it as a string literal.
@@ -466,7 +465,7 @@ void Parser::named_variable(std::string_view lexeme, bool can_assign) {
       // that's a runtime error). We can't error in the compiler because it
       // might be defined later after we're done compiling the current
       // function.
-      ObjString* var_name_str = string_map.get_ptr(lexeme);
+      ObjString* var_name_str = gc.get_string_ptr(lexeme);
       size_t constant_index = make_constant(var_name_str);
       emit_variable_access(lox::OpCode::SET_GLOBAL, lox::OpCode::GET_GLOBAL,
                            can_assign, constant_index);
@@ -659,7 +658,7 @@ void Parser::literal(bool _) {
 }
 
 void Parser::string(bool _) {
-  ObjString* obj_str = string_map.get_ptr(previous.lexeme);
+  ObjString* obj_str = gc.get_string_ptr(previous.lexeme);
   emit_constant(obj_str);
 }
 

src/compiler.hpp

@@ -1,6 +1,6 @@
 #include "chunk.hpp"
+#include "gc.hpp"
 #include "scanner.hpp"
-#include "stringmap.hpp"
 #include <memory>
 #include <optional>
 #include <stdexcept>
@@ -95,8 +95,7 @@ class Compiler {
 
 class Parser {
 public:
-  Parser(std::unique_ptr<scanner::Scanner> scanner, ObjFunction* fnptr,
-         StringMap& string_map);
+  Parser(std::unique_ptr<scanner::Scanner> scanner, ObjFunction* fnptr, GC& gc);
   void parse();
   ObjFunction* finalise_function();
 
@@ -105,7 +104,7 @@ class Parser {
   scanner::Token current;
   scanner::Token previous;
   std::optional<std::pair<std::string, size_t>> errmsg;
-  StringMap& string_map;
+  GC& gc;
   std::unique_ptr<Compiler> compiler;
 
   // Interact with scanner

src/gc.cpp

@@ -0,0 +1,19 @@
+#include "gc.hpp"
+#include "value.hpp"
+#include <string_view>
+#include <unordered_map>
+
+namespace lox {
+
+ObjString* GC::get_string_ptr(std::string_view key) {
+  auto it = interned_strings.map.find(key);
+  if (it == interned_strings.map.end()) {
+    // Not found; create a new one.
+    ObjString* s = alloc<ObjString>(key);
+    auto new_pair = interned_strings.map.emplace(std::string(key), s);
+    it = new_pair.first;
+  }
+  return it->second;
+}
+
+} // namespace lox

src/gc.hpp

@@ -1,8 +1,53 @@
 #pragma once
+#include "value.hpp"
+#include <functional>
+#include <string>
+#include <string_view>
+#include <unordered_map>
 #include <utility>
 
-template <typename T, typename... Args> T* gc_new(Args&&... args) {
-  T* obj = new T(std::forward<Args>(args)...);
-  // TODO: add obj to GC tracking system(?)
-  return obj;
-}
+namespace lox {
+
+// https://www.cppstories.com/2021/heterogeneous-access-cpp20/
+struct string_hash {
+  using is_transparent = void;
+  [[nodiscard]] size_t operator()(std::string_view txt) const {
+    return std::hash<std::string_view>{}(txt);
+  }
+  [[nodiscard]] size_t operator()(const std::string& txt) const {
+    return std::hash<std::string>{}(txt);
+  }
+};
+
+class StringMap {
+public:
+  StringMap() = default;
+  std::unordered_map<std::string, ObjString*, string_hash, std::equal_to<>> map;
+  ObjString* get_ptr(std::string_view key);
+};
+
+class GC {
+public:
+  // Central allocation function
+  template <typename T, typename... Args> T* alloc(Args&&... args) {
+    static_assert(std::is_base_of_v<Obj, T>,
+                  "GC::alloc can only be used to allocate subclasses of Obj");
+    // Create new object
+    T* obj = new T(std::forward<Args>(args)...);
+    // and make it point to the old head
+    obj->next = head;
+    // and make it be the new head
+    head = obj;
+    return obj;
+  }
+
+  // Get a pointer to an interned ObjString object, creating it if necessary.
+  ObjString* get_string_ptr(std::string_view);
+
+private:
+  // First object in the linked list of all objects tracked by the GC.
+  Obj* head = nullptr;
+  StringMap interned_strings;
+};
+
+} // namespace lox

src/stringmap.cpp

@@ -1,5 +1,5 @@
 #include "value.hpp"
-#include "stringmap.hpp"
+#include "gc.hpp"
 #include <iostream>
 
 namespace {
@@ -23,15 +23,15 @@ std::ostream& operator<<(std::ostream& os, const Value& value) {
   return os;
 }
 
-Value ObjString::add(const Obj* other, StringMap& string_map) {
+Value ObjString::add(const Obj* other, GC& gc) {
   if (other->type != ObjType::STRING) {
     throw std::runtime_error(
         "loxc: add: cannot concatenate non-string to string");
   }
   // no choice here, we have to concatenate the strings which means allocating
   auto other_str = static_cast<const ObjString*>(other);
   std::string new_str = value + other_str->value;
-  return string_map.get_ptr(new_str);
+  return gc.get_string_ptr(new_str);
 }
 
 Value ObjNativeFunction::call(uint8_t arg_count, const Value* args) {
@@ -79,14 +79,14 @@ bool is_equal(const Value& a, const Value& b) {
   }
 }
 
-Value add(const Value& a, const Value& b, StringMap& string_map) {
+Value add(const Value& a, const Value& b, GC& gc) {
   if (std::holds_alternative<double>(a) && std::holds_alternative<double>(b)) {
     return std::get<double>(a) + std::get<double>(b);
   } else if (std::holds_alternative<Obj*>(a) &&
              std::holds_alternative<Obj*>(b)) {
     auto aptr = std::get<Obj*>(a);
     auto bptr = std::get<Obj*>(b);
-    return aptr->add(bptr, string_map);
+    return aptr->add(bptr, gc);
   } else {
     throw std::runtime_error(
         "operands to `+` must be two numbers or two strings");

src/stringmap.hpp

@@ -14,7 +14,7 @@ enum class InterpretResult { OK, COMPILE_ERROR, RUNTIME_ERROR };
 enum class ObjType { STRING, FUNCTION, UPVALUE, CLOSURE, NATIVE_FUNCTION };
 
 // Forward declarations
-class StringMap; // Actually in stringmap.hpp
+class GC;
 
 class Upvalue {
 public:
@@ -28,7 +28,11 @@ bool operator==(const Upvalue& a, const Upvalue& b);
 
 class Obj {
 public:
+  // For runtime type information.
   ObjType type;
+  // For our GC's intrusive linked list. This field is managed by the GC, not
+  // by the Obj itself.
+  Obj* next = nullptr;
 
   // NOTE: Marking a member function as `virtual` means that C++ will force
   // it to use dynamic dispatc (i.e., even if there's an Obj* pointer, it will
@@ -47,7 +51,7 @@ class Obj {
   // NOTE: the (= 0) makes this a 'pure virtual' function, meaning that derived
   // classes must implement this function.
   virtual std::string to_repr() const = 0;
-  virtual Value add(const Obj* other, StringMap& string_map) = 0;
+  virtual Value add(const Obj* other, GC& gc) = 0;
 
   // NOTE: `protected` means this constructor can only be called by derived
   // classes
@@ -66,7 +70,7 @@ class ObjString : public Obj {
   }
 #endif
   std::string to_repr() const override { return "\"" + value + "\""; }
-  Value add(const Obj* other, StringMap& string_map) override;
+  Value add(const Obj* other, GC& gc) override;
 };
 
 class ObjFunction : public Obj {
@@ -81,7 +85,7 @@ class ObjFunction : public Obj {
 
   std::string to_repr() const override { return "<fn " + name + ">"; }
   // NOTE: If you aren't using the parameters, you can just omit their names!
-  Value add(const Obj*, StringMap&) override {
+  Value add(const Obj*, GC&) override {
     throw std::runtime_error("loxc: add: cannot add function objects");
   }
 };
@@ -94,7 +98,7 @@ class ObjUpvalue : public Obj {
       : Obj(ObjType::UPVALUE), location(location), closed(std::monostate()) {}
 
   std::string to_repr() const override { return "<upvalue>"; }
-  Value add(const Obj*, StringMap&) override {
+  Value add(const Obj*, GC&) override {
     throw std::runtime_error("loxc: add: cannot add upvalue objects");
   }
 };
@@ -109,7 +113,7 @@ class ObjClosure : public Obj {
   std::string to_repr() const override {
     return "<clos " + function->name + ">";
   }
-  Value add(const Obj*, StringMap&) override {
+  Value add(const Obj*, GC&) override {
     throw std::runtime_error("loxc: add: cannot add function objects");
   }
 };
@@ -124,7 +128,7 @@ class ObjNativeFunction : public Obj {
 
   Value call(uint8_t arg_count, const Value* args);
   std::string to_repr() const override { return "<native fn " + name + ">"; }
-  Value add(const Obj*, StringMap&) override {
+  Value add(const Obj*, GC&) override {
     throw std::runtime_error("loxc: add: cannot add function objects");
   }
 
@@ -138,7 +142,7 @@ class ObjNativeFunction : public Obj {
 
 bool is_truthy(const Value& value);
 bool is_equal(const Value& a, const Value& b);
-Value add(const Value& a, const Value& b, StringMap& string_map);
+Value add(const Value& a, const Value& b, GC& gc);
 
 // NOTE: Operators like these should (best) be declared in the same namespace
 // as the type they operate on. The compiler will be able to find them via