Merge pull request #402 from yamacir-kit/garbage-collector

Author: yamacir-kit

README.md

@@ -103,9 +103,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.64.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.81.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.64_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.81_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -120,7 +120,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.64
+Meevax Lisp System, version 0.4.81
 
 Usage: meevax [OPTION...] [FILE...]
 

VERSION

@@ -1 +1 @@
-0.4.64
+0.4.81

include/meevax/kernel/environment.hpp

@@ -72,10 +72,9 @@ inline namespace kernel
 
     auto declare_import(const_reference) -> void;
 
-    template <typename... Ts, REQUIRES(std::is_convertible<Ts, std::string>...)>
-    auto declare_import(Ts&&... xs) -> void
+    auto declare_import(std::string const& import_set) -> void
     {
-      (declare_import(read(xs)), ...);
+      declare_import(read(import_set));
     }
 
     auto define(const_reference, const_reference = undefined) -> void;

include/meevax/kernel/heterogeneous.hpp

@@ -89,11 +89,11 @@ inline namespace kernel
 
       if constexpr (std::is_same_v<Bound, Top>)
       {
-        return heterogeneous(new (gc) Top(std::forward<decltype(xs)>(xs)...));
+        return heterogeneous(gc.make<Top>(std::forward<decltype(xs)>(xs)...));
       }
       else if constexpr (std::is_class_v<Bound>)
       {
-        return heterogeneous(new (gc) binder<Bound>(std::forward<decltype(xs)>(xs)...));
+        return heterogeneous(gc.make<binder<Bound>>(std::forward<decltype(xs)>(xs)...));
       }
       else
       {

include/meevax/kernel/library.hpp

@@ -17,6 +17,7 @@
 #ifndef INCLUDED_MEEVAX_KERNEL_LIBRARY_HPP
 #define INCLUDED_MEEVAX_KERNEL_LIBRARY_HPP
 
+#include <functional>
 #include <meevax/kernel/environment.hpp>
 #include <unordered_map>
 
@@ -73,10 +74,9 @@ inline namespace kernel
       export_specs.push_back(export_spec);
     }
 
-    template <typename... Ts, REQUIRES(std::is_convertible<Ts, std::string>...)>
-    auto declare_export(Ts&&... xs) -> void
+    auto declare_export(std::string const& export_spec) -> void
     {
-      (declare_export(read(xs)), ...);
+      declare_export(read(export_spec));
     }
 
     auto resolve_export_specs()

include/meevax/kernel/reader.hpp

@@ -443,7 +443,7 @@ inline namespace kernel
     {
       let const result = read(standard_input);
 
-      write(debug_port(), header(__func__), result, "\n");
+      write(debug_port(), pretty::header(__func__), result, "\n");
 
       return result;
     }

include/meevax/memory/collector.hpp

@@ -25,7 +25,7 @@
 #include <new>
 #include <set>
 
-#include <meevax/memory/region.hpp>
+#include <meevax/memory/tracer.hpp>
 #include <meevax/memory/simple_allocator.hpp>
 #include <meevax/string/header.hpp>
 
@@ -44,68 +44,108 @@ inline namespace memory
   * ------------------------------------------------------------------------- */
   {
   public:
-    struct collectable
+    class traceable
     {
+      friend class collector;
+
+      memory::tracer * tracer = nullptr;
+
+      explicit traceable(memory::tracer * tracer)
+        : tracer { tracer }
+      {
+        if (tracer)
+        {
+          auto const lock = std::unique_lock(resource);
+          traceables.insert(std::end(traceables), this);
+        }
+      }
+
+      auto reset(memory::tracer * after) -> void
+      {
+        if (auto before = std::exchange(tracer, after); not before and after)
+        {
+          auto const lock = std::unique_lock(resource);
+          traceables.insert(this);
+        }
+        else if (before and not after)
+        {
+          traceables.erase(this);
+        }
+      }
+
+      auto locate(void * const data)
+      {
+        assert(data);
+
+        if (newest_tracer->contains(data)) // Heuristic-based optimization.
+        {
+          return newest_tracer;
+        }
+        else
+        {
+          auto dummy = memory::tracer(data, 0);
+          auto iter = tracers.lower_bound(&dummy);
+          assert(iter != std::end(tracers));
+          return *iter;
+        }
+      }
+
     protected:
-      region * context = nullptr;
+      explicit traceable() = default;
 
-      explicit constexpr collectable() = default;
+      explicit traceable(traceable const& other)
+        : traceable { other.tracer }
+      {}
 
       template <typename Pointer>
-      explicit collectable(Pointer const p)
-        : collectable { collector::reset(p, deallocator<Pointer>::deallocate) }
+      explicit traceable(Pointer const p)
+        : traceable { p ? locate(p) : nullptr }
       {}
 
-      explicit collectable(region * region)
-        : context { region }
+      ~traceable()
       {
-        if (context)
+        if (tracer)
         {
           auto const lock = std::unique_lock(resource);
-          objects.try_emplace(this, context);
+          traceables.erase(this);
         }
       }
 
-      ~collectable()
+      auto reset()
       {
-        auto const lock = std::unique_lock(resource);
-        objects.erase(this);
+        reset(nullptr);
       }
 
       template <typename Pointer>
       auto reset(Pointer const p) -> void
       {
-        reset(collector::reset(p, deallocator<Pointer>::deallocate));
+        reset(p ? locate(p) : nullptr);
       }
 
-      auto reset(region * region) -> void
+      auto reset(traceable const& other) -> void
       {
-        if (context = region)
-        {
-          auto const lock = std::unique_lock(resource);
-          objects.insert_or_assign(this, context);
-        }
+        reset(other.tracer);
       }
     };
 
   private:
-    static inline std::mutex resource;
-
-    static inline simple_allocator<region> region_allocator {};
-
     template <typename T>
     using set = std::set<T, std::less<T>, simple_allocator<T>>;
 
-    static inline set<region *> regions;
+  protected:
+    static inline std::mutex resource;
+
+    static inline simple_allocator<tracer> tracer_source {};
+
+    static inline tracer * newest_tracer = nullptr;
 
-    template <typename T, typename U>
-    using map = std::map<T, U, std::less<T>, simple_allocator<std::pair<T, U>>>;
+    static inline set<tracer *> tracers {};
 
-    static inline map<collectable * const, region *> objects;
+    static inline set<traceable *> traceables {};
 
-    static inline std::size_t allocation;
+    static inline std::size_t allocation = 0;
 
-    static inline std::size_t threshold;
+    static inline std::size_t threshold = 8_MiB;
 
   public:
     explicit collector();
@@ -120,33 +160,48 @@ inline namespace memory
 
     auto operator =(collector const&) -> collector & = delete;
 
-    static auto allocate(std::size_t const) -> void *;
+    template <typename T, typename... Ts>
+    static auto make(Ts&&... xs)
+    {
+      if (auto data = new T(std::forward<decltype(xs)>(xs)...); data)
+      {
+        if (allocation += sizeof(T); threshold < allocation)
+        {
+          collect();
+        }
+
+        newest_tracer = tracer_source.new_(data, sizeof(T), deallocator<T>::deallocate);
+
+        assert(tracers.find(newest_tracer) == std::end(tracers));
+
+        tracers.insert(std::end(tracers), newest_tracer);
+
+        return data;
+      }
+      else
+      {
+        throw std::bad_alloc();
+      }
+    }
 
     static auto clear() -> void;
 
     static auto collect() -> std::size_t;
 
     static auto count() noexcept -> std::size_t;
 
-    static auto deallocate(void * const, std::size_t const = 0) -> void;
-
     static auto mark() -> void;
 
-    static auto region_of(void const* const) -> decltype(regions)::iterator;
-
-    static auto reset(void * const, deallocator<void>::signature const) -> region *;
+    static auto tracer_of(void * const) -> decltype(tracers)::iterator;
 
     static auto reset_threshold(std::size_t const = std::numeric_limits<std::size_t>::max()) -> void;
 
     static auto sweep() -> void;
 
-    static auto traverse(region * const) -> void;
-  } static gc;
+    static auto trace(tracer * const) -> void;
+  }
+  static gc;
 } // namespace memory
 } // namespace meevax
 
-auto operator new(std::size_t const, meevax::collector &) -> void *;
-
-void operator delete(void * const, meevax::collector &) noexcept;
-
 #endif // INCLUDED_MEEVAX_MEMORY_COLLECTOR_HPP

include/meevax/memory/deallocator.hpp

@@ -26,19 +26,11 @@ inline namespace memory
   template <typename T>
   struct deallocator
   {
-    using signature = void (*)(void const* const);
+    using signature = void (*)(void *);
 
-    static void deallocate(void const* const p)
+    static void deallocate(void * p)
     {
-      if constexpr (std::is_pointer<T>::value)
-      {
-        using element_type = typename std::pointer_traits<T>::element_type;
-        delete static_cast<element_type const* const>(p);
-      }
-      else
-      {
-        delete static_cast<T const* const>(p);
-      }
+      delete static_cast<T *>(p);
     }
   };
 } // namespace memory

include/meevax/memory/gc_pointer.hpp

@@ -17,6 +17,7 @@
 #ifndef INCLUDED_MEEVAX_MEMORY_GC_POINTER_HPP
 #define INCLUDED_MEEVAX_MEMORY_GC_POINTER_HPP
 
+#include <cstddef>
 #include <meevax/memory/collector.hpp>
 #include <meevax/memory/nan_boxing_pointer.hpp>
 
@@ -27,19 +28,25 @@ inline namespace memory
   template <typename... Ts>
   struct gc_pointer
     : public nan_boxing_pointer<Ts...>
-    , private collector::collectable
+    , private collector::traceable
   {
-    gc_pointer(std::nullptr_t = nullptr)
+    explicit gc_pointer(std::nullptr_t = nullptr)
+    {}
+
+    template <typename T, REQUIRES(std::is_scalar<T>)>
+    explicit gc_pointer(T const& datum)
+      : nan_boxing_pointer<Ts...> { datum }
+      , collector::traceable { nan_boxing_pointer<Ts...>::get() }
     {}
 
     explicit gc_pointer(nan_boxing_pointer<Ts...> const& datum)
       : nan_boxing_pointer<Ts...> { datum }
-      , collector::collectable { datum.get() }
+      , collector::traceable { nan_boxing_pointer<Ts...>::get() }
     {}
 
     explicit gc_pointer(gc_pointer const& gcp)
       : nan_boxing_pointer<Ts...> { gcp }
-      , collector::collectable { gcp.context }
+      , collector::traceable { static_cast<collector::traceable const&>(gcp) }
     {}
 
     auto operator =(gc_pointer const& gcp) -> auto &
@@ -48,10 +55,16 @@ inline namespace memory
       return *this;
     }
 
-    auto reset(gc_pointer const& gcp = nullptr) -> void
+    auto reset(gc_pointer const& gcp) -> void
+    {
+      nan_boxing_pointer<Ts...>::reset(gcp);
+      collector::traceable::reset(static_cast<collector::traceable const&>(gcp));
+    }
+
+    auto reset(std::nullptr_t = nullptr) -> void
     {
-      nan_boxing_pointer<Ts...>::operator =(gcp);
-      collector::collectable::reset(gcp.context);
+      nan_boxing_pointer<Ts...>::reset();
+      collector::traceable::reset();
     }
   };
 } // namespace memory