refactor: rename intrusive_string_set to OAHSet

Author: BorysTheDev

src/core/CMakeLists.txt

@@ -40,7 +40,7 @@ cxx_test(interpreter_test dfly_core LABELS DFLY)
 
 cxx_test(string_set_test dfly_core LABELS DFLY)
 cxx_test(string_map_test dfly_core LABELS DFLY)
-cxx_test(intrusive_string_set_test dfly_core LABELS DFLY)
+cxx_test(oah_set_test dfly_core LABELS DFLY)
 cxx_test(sorted_map_test dfly_core redis_test_lib LABELS DFLY)
 cxx_test(bptree_set_test dfly_core LABELS DFLY)
 cxx_test(score_map_test dfly_core LABELS DFLY)

src/core/intrusive_string_list.h src/core/oah_entry.hsrc/core/intrusive_string_list.h renamed to src/core/oah_entry.h

@@ -27,7 +27,7 @@ static uint32_t BucketId(uint64_t hash, uint32_t capacity_log) {
   return hash >> (64 - capacity_log);
 }
 // doesn't possess memory, it should be created and release manually
-class ISLEntry {
+class OAHEntry {
   // we can assume that high 12 bits of user address space
   // can be used for tagging. At most 52 bits of address are reserved for
   // some configurations, and usually it's 48 bits.
@@ -47,9 +47,9 @@ class ISLEntry {
   static constexpr size_t kTagMask = 4095ULL << 52;  // we reserve 12 high bits.
 
  public:
-  ISLEntry() = default;
+  OAHEntry() = default;
 
-  ISLEntry(std::string_view key, uint32_t expiry = UINT32_MAX) {
+  OAHEntry(std::string_view key, uint32_t expiry = UINT32_MAX) {
     uint32_t key_size = key.size();
 
     uint32_t expiry_size = (expiry != UINT32_MAX) * sizeof(expiry);
@@ -80,25 +80,25 @@ class ISLEntry {
   }
 
   // TODO add initializer list constructor
-  ISLEntry(size_t vector_size) {
+  OAHEntry(size_t vector_size) {
     // TODO rewrite to simple array
-    data_ = reinterpret_cast<char*>(new std::vector<ISLEntry>(vector_size));
+    data_ = reinterpret_cast<char*>(new std::vector<OAHEntry>(vector_size));
     SetVectorBit();
   }
 
-  ISLEntry(const ISLEntry& e) = delete;
-  ISLEntry(ISLEntry&& e) {
+  OAHEntry(const OAHEntry& e) = delete;
+  OAHEntry(OAHEntry&& e) {
     data_ = e.data_;
     e.data_ = nullptr;
   }
 
   // consider manual removing, we waste a lot of time to check nullptr
-  inline ~ISLEntry() {
+  inline ~OAHEntry() {
     Clear();
   }
 
-  ISLEntry& operator=(const ISLEntry& e) = delete;
-  ISLEntry& operator=(ISLEntry&& e) {
+  OAHEntry& operator=(const OAHEntry& e) = delete;
+  OAHEntry& operator=(OAHEntry&& e) {
     std::swap(data_, e.data_);
     return *this;
   }
@@ -115,8 +115,8 @@ class ISLEntry {
     return (uptr() & kVectorBit) != 0;
   }
 
-  inline std::vector<ISLEntry>& AsVector() {
-    return *reinterpret_cast<std::vector<ISLEntry>*>(Raw());
+  inline std::vector<OAHEntry>& AsVector() {
+    return *reinterpret_cast<std::vector<OAHEntry>*>(Raw());
   }
 
   inline std::string_view Key() const {
@@ -139,11 +139,11 @@ class ISLEntry {
   }
 
   // TODO consider another option to implement iterator
-  ISLEntry* operator->() {
+  OAHEntry* operator->() {
     return this;
   }
 
-  inline uint64_t GetExtendedHash() const {
+  inline uint64_t GetHash() const {
     return (uptr() & kExtHashShiftedMask) >> kExtHashShift;
   }
 
@@ -154,9 +154,9 @@ class ISLEntry {
     uint32_t bucket_id_hash_part = capacity_log > shift_log ? shift_log : capacity_log;
     uint32_t bucket_mask = (1 << bucket_id_hash_part) - 1;
     bucket_id &= bucket_mask;
-    auto stored_hash = GetExtendedHash();
+    auto stored_hash = GetHash();
     if (!stored_hash) {
-      stored_hash = SetExtendedHash(Hash(Key()), capacity_log, shift_log);
+      stored_hash = SetHash(Hash(Key()), capacity_log, shift_log);
     }
     uint32_t stored_bucket_id = stored_hash >> (kExtHashSize - bucket_id_hash_part);
     return bucket_id == stored_bucket_id;
@@ -168,16 +168,16 @@ class ISLEntry {
     const uint32_t start_hash_bit = capacity_log > shift_log ? capacity_log - shift_log : 0;
     const uint32_t ext_hash_shift = 64 - start_hash_bit - kExtHashSize;
     const uint64_t ext_hash = (hash >> ext_hash_shift) & kExtHashMask;
-    auto stored_hash = GetExtendedHash();
+    auto stored_hash = GetHash();
     if (!stored_hash && !IsVector()) {
-      stored_hash = SetExtendedHash(Hash(Key()), capacity_log, shift_log);
+      stored_hash = SetHash(Hash(Key()), capacity_log, shift_log);
     }
     return stored_hash == ext_hash;
   }
 
   // TODO rename to SetHash
   // shift_log identify which bucket the element belongs to
-  uint64_t SetExtendedHash(uint64_t hash, uint32_t capacity_log, uint32_t shift_log) {
+  uint64_t SetHash(uint64_t hash, uint32_t capacity_log, uint32_t shift_log) {
     DCHECK(!IsVector());
     const uint32_t start_hash_bit = capacity_log > shift_log ? capacity_log - shift_log : 0;
     const uint32_t ext_hash_shift = 64 - start_hash_bit - kExtHashSize;
@@ -195,7 +195,7 @@ class ISLEntry {
   uint32_t Rehash(uint32_t current_bucket_id, uint32_t prev_capacity_log, uint32_t new_capacity_log,
                   uint32_t shift_log) {
     DCHECK(!IsVector());
-    auto stored_hash = GetExtendedHash();
+    auto stored_hash = GetHash();
 
     const uint32_t logs_diff = new_capacity_log - prev_capacity_log;
     const uint32_t prev_significant_bits =
@@ -204,7 +204,7 @@ class ISLEntry {
 
     if (!stored_hash || needed_hash_bits > kExtHashSize) {
       auto hash = Hash(Key());
-      SetExtendedHash(hash, new_capacity_log, shift_log);
+      SetHash(hash, new_capacity_log, shift_log);
       return BucketId(hash, new_capacity_log);
     }
 
@@ -232,7 +232,7 @@ class ISLEntry {
       auto* expiry_pos = Raw();
       std::memcpy(expiry_pos, &at_sec, sizeof(at_sec));
     } else {
-      *this = ISLEntry(Key(), at_sec);
+      *this = OAHEntry(Key(), at_sec);
     }
   }
 
@@ -266,12 +266,12 @@ class ISLEntry {
   }
 
   // TODO refactor, because it's inefficient
-  inline uint32_t Insert(ISLEntry&& e) {
+  inline uint32_t Insert(OAHEntry&& e) {
     if (Empty()) {
       *this = std::move(e);
       return 0;
     } else if (!IsVector()) {
-      ISLEntry tmp(2);
+      OAHEntry tmp(2);
       auto& arr = tmp.AsVector();
       arr[0] = std::move(*this);
       arr[1] = std::move(e);
@@ -300,7 +300,7 @@ class ISLEntry {
   }
 
   // TODO remove, it is inefficient
-  inline ISLEntry& operator[](uint32_t pos) {
+  inline OAHEntry& operator[](uint32_t pos) {
     DCHECK(!Empty());
     if (!IsVector()) {
       DCHECK(pos == 0);
@@ -312,11 +312,11 @@ class ISLEntry {
     }
   }
 
-  ISLEntry Remove(uint32_t pos) {
+  OAHEntry Remove(uint32_t pos) {
     if (Empty()) {
       // I'm not sure that this scenario should be check at all
       DCHECK(pos == 0);
-      return ISLEntry();
+      return OAHEntry();
     } else if (!IsVector()) {
       DCHECK(pos == 0);
       return std::move(*this);
@@ -327,7 +327,7 @@ class ISLEntry {
     }
   }
 
-  ISLEntry Pop() {
+  OAHEntry Pop() {
     if (IsVector()) {
       auto& arr = AsVector();
       for (auto& e : arr) {

src/core/intrusive_string_set.h src/core/oah_set.hsrc/core/intrusive_string_set.h renamed to src/core/oah_set.h

@@ -10,26 +10,23 @@
 #include <vector>
 
 #include "base/pmr/memory_resource.h"
-#include "intrusive_string_list.h"
+#include "oah_entry.h"
 
 namespace dfly {
 
-// NOTE: do not change the ABI of ISLEntry struct as long as we support
-// --stringset_experimental=false
-
-class IntrusiveStringSet {
-  using Buckets = std::vector<ISLEntry, PMR_NS::polymorphic_allocator<ISLEntry>>;
+class OAHSet {  // Open Addressing Hash Set
+  using Buckets = std::vector<OAHEntry, PMR_NS::polymorphic_allocator<OAHEntry>>;
 
  public:
   class iterator {
    public:
     using iterator_category = std::forward_iterator_tag;
     using difference_type = std::ptrdiff_t;
-    using value_type = ISLEntry;
-    using pointer = ISLEntry*;
-    using reference = ISLEntry&;
+    using value_type = OAHEntry;
+    using pointer = OAHEntry*;
+    using reference = OAHEntry&;
 
-    iterator(IntrusiveStringSet* owner, uint32_t bucket_id, uint32_t pos_in_bucket)
+    iterator(OAHSet* owner, uint32_t bucket_id, uint32_t pos_in_bucket)
         : owner_(owner), bucket_(bucket_id), pos_(pos_in_bucket) {
       // TODO rewrite, it's inefficient
       SetEntryIt();
@@ -94,7 +91,7 @@ class IntrusiveStringSet {
     }
 
    private:
-    IntrusiveStringSet* owner_;
+    OAHSet* owner_;
     uint32_t bucket_;
     uint32_t pos_;
   };
@@ -107,8 +104,7 @@ class IntrusiveStringSet {
     return iterator(nullptr, 0, 0);
   }
 
-  explicit IntrusiveStringSet(PMR_NS::memory_resource* mr = PMR_NS::get_default_resource())
-      : entries_(mr) {
+  explicit OAHSet(PMR_NS::memory_resource* mr = PMR_NS::get_default_resource()) : entries_(mr) {
   }
 
   static constexpr uint32_t kMaxBatchLen = 32;
@@ -122,10 +118,6 @@ class IntrusiveStringSet {
 
     // TODO FindInternal and FindEmptyAround can be one function to get better performance
     if (auto item = FindInternal(bucket_id, str, hash); item != end()) {
-      // Update ttl if found
-      // if (!keepttl) {
-      //   item->SetExpiryTime(EntryTTL(ttl_sec) /*, &entries_[item.second].obj_malloc_used_*/);
-      // }
       return false;
     }
 
@@ -157,8 +149,8 @@ class IntrusiveStringSet {
                      uint32_t ttl_sec = UINT32_MAX) {
     ++size_;
     uint32_t at = EntryTTL(ttl_sec);
-    uint32_t pos = entries_[bucket].Insert(ISLEntry(str, at));
-    entries_[bucket][pos].SetExtendedHash(hash, capacity_log_, kShiftLog);
+    uint32_t pos = entries_[bucket].Insert(OAHEntry(str, at));
+    entries_[bucket][pos].SetHash(hash, capacity_log_, kShiftLog);
     return iterator(this, bucket, pos);
   }
 
@@ -173,8 +165,8 @@ class IntrusiveStringSet {
     return res;
   }
 
-  // TODO: Consider using chunks for this as string set
-  void Fill(IntrusiveStringSet* other) {
+  // TODO: Consider using chunks for this as in StringSet
+  void Fill(OAHSet* other) {
     DCHECK(other->entries_.empty());
     other->Reserve(UpperBoundSize());
     other->set_time(time_now());
@@ -200,7 +192,6 @@ class IntrusiveStringSet {
 
   using ItemCb = std::function<void(std::string_view)>;
 
-  // TODO fix with CheckExtendedHash
   uint32_t Scan(uint32_t cursor, const ItemCb& cb) {
     const uint32_t capacity_mask = Capacity() - 1;
     uint32_t bucket_id = cursor >> (32 - capacity_log_);
@@ -224,7 +215,7 @@ class IntrusiveStringSet {
     return bucket_id << (32 - capacity_log_);
   }
 
-  ISLEntry Pop() {
+  OAHEntry Pop() {
     for (auto& bucket : entries_) {
       if (auto res = bucket.Pop(); !res.Empty()) {
         --size_;
@@ -242,7 +233,7 @@ class IntrusiveStringSet {
     auto bucket_id = BucketId(hash, capacity_log_);
     auto item = FindInternal(bucket_id, str, hash);
     if (item != end()) {
-      *item = ISLEntry();
+      *item = OAHEntry();
       return true;
     }
     return false;
@@ -290,15 +281,14 @@ class IntrusiveStringSet {
   }
 
   size_t ObjMallocUsed() const {
-    size_t bucket_obj_memory = 0;
-    // for (const auto& bucket : entries_) {
-    //   bucket_obj_memory += bucket.ObjMallocUsed();
-    // }
-    return bucket_obj_memory;
+    // TODO implement
+    LOG(FATAL) << "ExpirationUsed() isn't implemented";
+    return 0;
   }
 
   size_t SetMallocUsed() const {
-    // return entries_.capacity() * sizeof(ISLEntry);
+    // TODO implement
+    LOG(FATAL) << "ExpirationUsed() isn't implemented";
     return 0;
   }
 
@@ -349,10 +339,7 @@ class IntrusiveStringSet {
       const uint32_t bucket_id = (bid + i) & capacity_mask;
       if (entries_[bucket_id].Empty())
         return bucket_id;
-      // it->ExpireIfNeeded(time_now_, &size_);
-      // if (it->Empty()) {
-      //   return it;
-      // }
+      // TODO add expiration logic
     }
 
     DCHECK(Capacity() > kDisplacementSize);