chore: minor changes in dash code

Does not change functionality.
bucket_count is currently constant for a segment so
the additional arithmetics do not affect bucket_count_.

Signed-off-by: Roman Gershman <roman@dragonflydb.io>

Author: romange

src/core/dash.h

@@ -785,6 +785,7 @@ auto DashTable<_Key, _Value, Policy>::InsertInternal(U&& key, V&& value, Evictio
 
     typename SegmentType::Iterator it;
     bool res = true;
+    unsigned num_buckets = target->num_buckets();
     if (mode == InsertMode::kForceInsert) {
       it = target->InsertUniq(std::forward<U>(key), std::forward<V>(value), key_hash, true);
       res = it.found();
@@ -794,6 +795,8 @@ auto DashTable<_Key, _Value, Policy>::InsertInternal(U&& key, V&& value, Evictio
     }
 
     if (res) {  // success
+      // in case segment bucket count changed, we need to update total bucket count.
+      bucket_count_ + (target->num_buckets() - num_buckets);
       ++size_;
       return std::make_pair(iterator{this, target_seg_id, it.index, it.slot}, true);
     }
@@ -905,7 +908,12 @@ void DashTable<_Key, _Value, Policy>::Split(uint32_t seg_id) {
 
   auto hash_fn = [this](const auto& k) { return policy_.HashFn(k); };
 
+  // remove current segment bucket count.
+  bucket_count_ -= (source->num_buckets() + target->num_buckets());
   source->Split(std::move(hash_fn), target);  // increases the depth.
+
+  // add back the updated bucket count.
+  bucket_count_ += (target->num_buckets() + source->num_buckets());
   ++unique_segments_;
 
   for (size_t i = start_idx + chunk_size / 2; i < start_idx + chunk_size; ++i) {

src/core/dash_internal.h

@@ -434,11 +434,11 @@ class Segment {
 
   template <bool UV = kUseVersion>
   std::enable_if_t<UV, uint64_t> GetVersion(PhysicalBid bid) const {
-    return bucket_[bid].GetVersion();
+    return GetBucket(bid).GetVersion();
   }
 
   template <bool UV = kUseVersion> std::enable_if_t<UV> SetVersion(PhysicalBid bid, uint64_t v) {
-    return bucket_[bid].SetVersion(v);
+    return GetBucket(bid).SetVersion(v);
   }
 
   // Traverses over Segment's bucket bid and calls cb(const Iterator& it) 0 or more times
@@ -1304,6 +1304,7 @@ void Segment<Key, Value, Policy>::Split(HFunc&& hfn, Segment* dest_right) {
 
 template <typename Key, typename Value, typename Policy>
 int Segment<Key, Value, Policy>::MoveToOther(bool own_items, unsigned from_bid, unsigned to_bid) {
+  assert(from_bid < kBucketNum && to_bid < kBucketNum);
   auto& src = bucket_[from_bid];
   uint32_t mask = src.GetProbe(!own_items);
   if (mask == 0) {
@@ -1519,7 +1520,8 @@ void Segment<Key, Value, Policy>::TraverseBucket(PhysicalBid bid, Cb&& cb) {
 
 template <typename Key, typename Value, typename Policy>
 template <typename Cb, typename HashFn>
-bool Segment<Key, Value, Policy>::TraverseLogicalBucket(uint8_t bid, HashFn&& hfun, Cb&& cb) const {
+bool Segment<Key, Value, Policy>::TraverseLogicalBucket(LogicalBid bid, HashFn&& hfun,
+                                                        Cb&& cb) const {
   assert(bid < kBucketNum);
 
   const Bucket& b = bucket_[bid];
@@ -1673,12 +1675,12 @@ auto Segment<Key, Value, Policy>::BumpUp(uint8_t bid, SlotId slot, Hash_t key_ha
 
   // update ptr for swapped items
   if (is_probing) {
-    unsigned prev_bid = PrevBid(swap_bid);
+    LogicalBid prev_bid = PrevBid(swap_bid);
     auto& prevb = bucket_[prev_bid];
     prevb.SetStashPtr(stash_pos, swap_fp, &swapb);
   } else {
     // stash_ptr resides in the current or the next bucket.
-    unsigned next_bid = NextBid(swap_bid);
+    LogicalBid next_bid = NextBid(swap_bid);
     swapb.SetStashPtr(stash_pos, swap_fp, bucket_ + next_bid);
   }
 

src/core/dash_test.cc

@@ -700,6 +700,7 @@ TEST_F(DashTest, Eviction) {
 
   ASSERT_THROW(loop(), bad_alloc);
   ASSERT_LT(num, 5000);
+  ASSERT_EQ(2, dt_.unique_segments());
   EXPECT_LT(dt_.size(), ev.max_capacity);
   LOG(INFO) << "size is " << dt_.size();