Implement typed-gc

ksh8281 · ksh8281 · commit 014d14a7191d · 2025-05-20T16:34:39.000+09:00
Signed-off-by: Seonghyun Kim &lt;sh8281.kim@samsung.com&gt;
diff --git a/escargotshim.gyp b/escargotshim.gyp
@@ -89,6 +89,7 @@
         '-Wno-unused-result',
         '-fexceptions',
         '-fvisibility=hidden',
+        '-Wno-invalid-offsetof',
       ],
       'direct_dependent_settings': {
         'defines': [
diff --git a/src/api/engine.cc b/src/api/engine.cc
@@ -115,18 +115,18 @@ void GCHeap::acquire(void* address, Kind kind, void* data) {
 
   auto iter = persistents_.find(GC_WRAP_PERSISTENT_POINTER(address));
   if (iter != persistents_.end()) {
-    if (kind == STRONG) iter->second.strong++;
-    if (kind == WEAK) iter->second.weak++;
+    if (kind == STRONG) iter.value().strong++;
+    if (kind == WEAK) iter.value().weak++;
   } else {
     auto iter = weakPhantoms_.find(GC_WRAP_WEAK_POINTER(address));
     if (iter != weakPhantoms_.end()) {
-      AddressInfo info = iter->second;
+      AddressInfo info = iter.value();
 
       LWNODE_CHECK(info.strong == 0);
       LWNODE_CHECK(info.weak != 0);
 
-      if (kind == STRONG) iter->second.strong++;
-      if (kind == WEAK) iter->second.weak++;
+      if (kind == STRONG) iter.value().strong++;
+      if (kind == WEAK) iter.value().weak++;
 
       persistents_.emplace(GC_WRAP_PERSISTENT_POINTER(address), info);
       weakPhantoms_.erase(iter);
@@ -147,16 +147,16 @@ void GCHeap::release(void* address, Kind kind) {
 
   auto iter = persistents_.find(GC_WRAP_PERSISTENT_POINTER(address));
   if (iter != persistents_.end()) {
-    if (kind == STRONG) iter->second.strong--;
-    if (kind == WEAK) iter->second.weak--;
+    if (kind == STRONG) iter.value().strong--;
+    if (kind == WEAK) iter.value().weak--;
 
-    iter->second.strong = std::max(iter->second.strong, 0);
-    iter->second.weak = std::max(iter->second.weak, 0);
+    iter.value().strong = std::max(iter.value().strong, 0);
+    iter.value().weak = std::max(iter.value().weak, 0);
 
     // progress handling weak phantoms
     if (iter->second.strong == 0) {
       if (iter->second.weak > 0) {
-        weakPhantoms_.emplace(GC_WRAP_WEAK_POINTER(address), iter->second);
+        weakPhantoms_.emplace(GC_WRAP_WEAK_POINTER(address), iter.value());
       }
       persistents_.erase(iter);
     }
diff --git a/src/api/global-handles.cc b/src/api/global-handles.cc
@@ -69,7 +69,7 @@ void GlobalHandles::create(ValueWrap* lwValue) {
   if (iter == persistentValues_.end()) {
     persistentValues_.emplace(lwValue, 1);
   } else {
-    ++iter->second;
+    ++iter.value();
     // TODO:
     LWNODE_CALL_TRACE_ID(GLOBALHANDLES,
                          "Persistent value was created multiple times: %p",
@@ -83,7 +83,7 @@ bool GlobalHandles::destroy(ValueWrap* lwValue) {
     if (iter->second == 1) {
       persistentValues_.erase(iter);
     } else {
-      --iter->second;
+      --iter.value();
     }
     return true;
   }
diff --git a/src/api/isolate.cc b/src/api/isolate.cc
@@ -29,6 +29,15 @@ namespace internal {
 
 using namespace EscargotShim;
 
+void Isolate::fillGCDescriptor(GC_word* desc) {
+  GC_set_bit(desc, GC_WORD_OFFSET(Isolate, scheduled_exception_));
+  GC_set_bit(desc, GC_WORD_OFFSET(Isolate, global_handles_));
+  GC_set_bit(desc, GC_WORD_OFFSET(Isolate, try_catch_handler_));
+  GC_set_bit(desc, GC_WORD_OFFSET(Isolate, pending_exception_));
+  GC_set_bit(desc, GC_WORD_OFFSET(Isolate, pending_message_obj_));
+  GC_set_bit(desc, GC_WORD_OFFSET(Isolate, prepareStackTraceRecursion_));
+}
+
 // 'exception_' is of type ValueWrap*. Ref: api-exception.cc
 void Isolate::SetTerminationOnExternalTryCatch() {
   LWNODE_CALL_TRACE_ID(TRYCATCH, "try_catch_handler_: %p", try_catch_handler_);
@@ -269,6 +278,39 @@ namespace EscargotShim {
 LWNODE_EXPORT THREAD_LOCAL IsolateWrap* IsolateWrap::s_currentIsolate;
 LWNODE_EXPORT THREAD_LOCAL IsolateWrap* IsolateWrap::s_previousIsolate;
 
+void IsolateWrap::fillGCDescriptor(GC_word* desc) {
+  Isolate::fillGCDescriptor(desc);
+  GC_set_bit(desc, GC_WORD_OFFSET(IsolateWrap, eternals_));
+  markHashSet(desc, GC_WORD_OFFSET(IsolateWrap, backingStoreCounter_));
+  GC_set_bit(desc, GC_WORD_OFFSET(IsolateWrap, handleScopes_));
+  GC_set_bit(desc, GC_WORD_OFFSET(IsolateWrap, contextScopes_));
+
+  GC_set_bit(desc, GC_WORD_OFFSET(IsolateWrap, privateValuesSymbol_));
+  GC_set_bit(desc, GC_WORD_OFFSET(IsolateWrap, apiSymbols_));
+  GC_set_bit(desc, GC_WORD_OFFSET(IsolateWrap, apiPrivateSymbols_));
+
+  GC_set_bit(desc, GC_WORD_OFFSET(IsolateWrap, vmInstance_));
+
+  GC_set_bit(desc, GC_WORD_OFFSET(IsolateWrap, release_lock_));
+  for (size_t i = 0; i < internal::Internals::kRootIndexSize; i++) {
+    GC_set_bit(desc, GC_WORD_OFFSET(IsolateWrap, globalSlot_) + i);
+  }
+
+  GC_set_bit(desc, GC_WORD_OFFSET(IsolateWrap, threadManager_));
+}
+
+void* IsolateWrap::operator new(size_t size) {
+  static bool typeInited = false;
+  static GC_descr descr;
+  if (!typeInited) {
+    GC_word desc[GC_BITMAP_SIZE(IsolateWrap)] = {0};
+    fillGCDescriptor(desc);
+    descr = GC_make_descriptor(desc, GC_WORD_LEN(IsolateWrap));
+    typeInited = true;
+  }
+  return GC_MALLOC_EXPLICITLY_TYPED(size, descr);
+}
+
 IsolateWrap::IsolateWrap() {
   LWNODE_CALL_TRACE_ID(ISOWRAP, "malc: %p", this);
 
@@ -552,7 +594,7 @@ void IsolateWrap::addEternal(GCManagedObject* value) {
 void IsolateWrap::addBackingStore(BackingStoreRef* value) {
   auto itr = backingStoreCounter_.find(value);
   if (itr != backingStoreCounter_.end()) {
-    ++itr->second;
+    itr.value() = itr.value() + 1;
   } else {
     backingStoreCounter_.insert(std::make_pair(value, 1));
   }
@@ -564,7 +606,7 @@ void IsolateWrap::removeBackingStore(BackingStoreRef* value) {
     if (itr->second == 1) {
       backingStoreCounter_.erase(itr);
     } else {
-      --itr->second;
+      itr.value() = itr.value() - 1;
     }
   } else {
     LWNODE_CHECK_MSG(false, "increment/decrement count do not match");
diff --git a/src/api/isolate.h b/src/api/isolate.h
@@ -110,6 +110,7 @@ class Isolate : public gc {
   EscargotShim::GlobalHandles* global_handles() { return global_handles_; }
 
  protected:
+  static void fillGCDescriptor(GC_word* desc);
   void set_pending_exception(Escargot::ValueRef* exception_obj);
   void set_pending_message_obj(Escargot::ValueRef* message_obj);
   void clear_pending_exception();
@@ -149,12 +150,6 @@ class ContextWrap;
 
 typedef gc GCManagedObject;
 
-struct BackingStoreComparator {
-  bool operator()(const BackingStoreRef* a, const BackingStoreRef* b) const {
-    return a < b;
-  }
-};
-
 class IsolateWrap final : public v8::internal::Isolate {
  public:
   enum class State { None, Active, Disposed };
@@ -279,13 +274,17 @@ class IsolateWrap final : public v8::internal::Isolate {
 
   State getState() { return state_; }
 
+  void* operator new(size_t size);
+
  private:
+  static void fillGCDescriptor(GC_word* desc);
   IsolateWrap();
 
   void InitializeGlobalSlots();
 
   GCVector<GCManagedObject*> eternals_;
-  GCMap<BackingStoreRef*, int, BackingStoreComparator> backingStoreCounter_;
+  GCUnorderedMap<BackingStoreRef*, StorePositiveNumberAsOddNumber>
+      backingStoreCounter_;
 
   GCVector<HandleScopeWrap*> handleScopes_;
   GCVector<ContextWrap*> contextScopes_;
diff --git a/src/api/utils/gc-util.h b/src/api/utils/gc-util.h
@@ -25,6 +25,23 @@
 #include "gc-container.h"
 #include "sf-vector.h"
 
+// from deps/escargot/src/api
+#include "../../third_party/robin_map/include/tsl/robin_map.h"
+#include "../../third_party/robin_map/include/tsl/robin_set.h"
+
+class StorePositiveNumberAsOddNumber {
+ public:
+  StorePositiveNumberAsOddNumber(const size_t& src = 0) {
+    // ASSERT(src < std::numeric_limits<size_t>::max() / 2);
+    m_data = (src << 1) | 0x1;
+  }
+
+  operator size_t() const { return m_data >> 1; }
+
+ private:
+  size_t m_data;
+};
+
 #include <string>
 
 // typedef of GC-aware vector
@@ -47,19 +64,15 @@ class GCVector : public GCVectorT<T, isEraseStrategyStrict, Allocator>,
                  public gc {};
 #endif
 
-// typedef of GC-aware list
-template <typename T, typename Allocator = GCUtil::gc_malloc_allocator<T>>
-using GCListT = std::list<T, Allocator>;
-
-template <typename T, typename Allocator = GCUtil::gc_malloc_allocator<T>>
-class GCList : public GCListT<T, Allocator>, public gc {};
-
-// typedef of GC-aware deque
-template <typename T, typename Allocator = GCUtil::gc_malloc_allocator<T>>
-using GCDequeT = std::deque<T, Allocator>;
-
-template <typename T, typename Allocator = GCUtil::gc_malloc_allocator<T>>
-class GCDeque : public GCDequeT<T, Allocator>, public gc {};
+template <class Key,
+          class T,
+          class Hash = std::hash<Key>,
+          class KeyEqual = std::equal_to<Key>,
+          class Allocator = std::allocator<std::pair<Key, T>>,
+          bool StoreHash = false,
+          class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
+using HashMap =
+    tsl::robin_map<Key, T, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy>;
 
 // typedef of GC-aware unordered_map
 template <typename Key,
@@ -68,8 +81,7 @@ template <typename Key,
           typename Predicate = std::equal_to<Key>,
           typename Allocator =
               GCUtil::gc_malloc_allocator<std::pair<Key const, Value>>>
-using GCUnorderedMapT =
-    std::unordered_map<Key, Value, Hasher, Predicate, Allocator>;
+using GCUnorderedMapT = HashMap<Key, Value, Hasher, Predicate, Allocator>;
 
 template <typename Key,
           typename Value,
@@ -86,49 +98,41 @@ template <typename Key,
           typename Hasher = std::hash<Key>,
           typename Predicate = std::equal_to<Key>,
           typename Allocator =
-              GCUtil::gc_malloc_allocator<std::pair<Key const, Value>>>
-using GCUnorderedMultiMapT =
-    std::unordered_multimap<Key, Value, Hasher, Predicate, Allocator>;
+              GCUtil::gc_malloc_atomic_allocator<std::pair<Key const, Value>>>
+using GCAtomicUnorderedMapT = HashMap<Key, Value, Hasher, Predicate, Allocator>;
 
 template <typename Key,
           typename Value,
           typename Hasher = std::hash<Key>,
           typename Predicate = std::equal_to<Key>,
           typename Allocator =
-              GCUtil::gc_malloc_allocator<std::pair<Key const, Value>>>
-class GCUnorderedMultiMap
-    : public GCUnorderedMultiMapT<Key, Value, Hasher, Predicate, Allocator>,
+              GCUtil::gc_malloc_atomic_allocator<std::pair<Key const, Value>>>
+class GCAtomicUnorderedMap
+    : public GCAtomicUnorderedMapT<Key, Value, Hasher, Predicate, Allocator>,
       public gc {};
 
-// typedef of GC-aware map
-template <typename Key,
-          typename Value,
-          typename Comparator,
-          typename Allocator =
-              GCUtil::gc_malloc_allocator<std::pair<Key const, Value>>>
-using GCMapT = std::map<Key, Value, Comparator, Allocator>;
-
-template <typename Key,
-          typename Value,
-          typename Comparator,
-          typename Allocator =
-              GCUtil::gc_malloc_allocator<std::pair<Key const, Value>>>
-class GCMap : public GCMapT<Key, Value, Comparator, Allocator>, public gc {};
+template <class Key,
+          class Hash = std::hash<Key>,
+          class KeyEqual = std::equal_to<Key>,
+          class Allocator = std::allocator<Key>,
+          bool StoreHash = false,
+          class GrowthPolicy = tsl::rh::power_of_two_growth_policy<2>>
+using HashSet =
+    tsl::robin_set<Key, Hash, KeyEqual, Allocator, StoreHash, GrowthPolicy>;
 
 // typedef of GC-aware unordered_set
 template <typename T,
           typename Hasher = std::hash<T>,
           typename Predicate = std::equal_to<T>,
           typename Allocator = GCUtil::gc_malloc_allocator<T>>
-using GCUnorderedSetT = std::unordered_set<T, Hasher, Predicate, Allocator>;
-
-template <typename T,
-          typename Hasher = std::hash<T>,
-          typename Predicate = std::equal_to<T>,
-          typename Allocator = GCUtil::gc_malloc_allocator<T>>
-class GCUnorderedSet : public GCUnorderedSetT<T, Hasher, Predicate, Allocator>,
+class GCUnorderedSet : public HashSet<T, Hasher, Predicate, Allocator>,
                        public gc {};
 
+inline void markHashSet(GC_word* desc, size_t base) {
+  GC_set_bit(desc, base + 1);  // m_ht.m_buckets_data
+  GC_set_bit(desc, base + 4);  // m_ht.m_buckets
+}
+
 namespace Escargot {
 class ValueRef;
 class ObjectRef;
diff --git a/src/execution/v8threads.h b/src/execution/v8threads.h
@@ -36,6 +36,8 @@ class ThreadManager : public gc {
 
   bool IsLockedByCurrentThread() const;
 
+  void* operator new(size_t size) { return GC_MALLOC_ATOMIC(size); }
+
   std::mutex mutex_;
   std::atomic<std::thread::id> mutex_owner_;
 };
