gc.hpp: Count threads to allow immediate free

rt/include/typon/fundamental/gc.hpp

@@ -48,13 +48,15 @@ namespace typon::fdt::lock_free
     };
 
     const uint _concurrency;
+    const uint _bits;
     std::atomic<u64> * const _stamps;
-    std::atomic<u64> _stamp {0};
+    std::atomic<u64> _state {0};
     std::atomic<node *> _head;
     std::atomic<node *> _tail;
 
     gc(uint concurrency) noexcept
       : _concurrency(concurrency)
+      , _bits(std::bit_width(concurrency))
       , _stamps(new std::atomic<u64>[concurrency])
     {
       auto first = new node(0);
@@ -68,20 +70,29 @@ namespace typon::fdt::lock_free
 
     void enter(uint id) noexcept
     {
-      _stamps[id].store(_stamp.fetch_add(1));
+      auto state = _state.fetch_add((1 << _bits) + 1);
+      _stamps[id].store(state >> _bits);
     }
 
     template <typename T>
     void retire(T * ptr) noexcept
     {
-      auto stamp = _stamp.load();
-      auto node = new garbage<T> { ptr, stamp };
-      auto head = _head.exchange(node);
-      head->_next.store(node);
+      auto state = _state.load();
+      if ((state & ((1 << _bits) - 1)) == 0)
+      {
+        delete ptr;
+      }
+      else
+      {
+        auto node = new garbage<T> { ptr, state >> _bits };
+        auto head = _head.exchange(node);
+        head->_next.store(node);
+      }
     }
 
     void leave(uint id) noexcept
     {
+      _state.fetch_sub(1);
       _stamps[id].store(u64(-1));
       if (_tail.load())
       {