Rename a field with FixedSizeIndex

Summary:
Renaming a filed 'sizeForMutex_' which actually means the number of stored buckets within mutex boundary.
Original name comes from similar naming with SparseMapIndex, but I feel, with FixedSizeIndex, 'size' doesn't represent what it's supposed to mean.

Reviewed By: AlnisM

Differential Revision: D81283852

fbshipit-source-id: df8211ba66c4e9e719a06f12f1e832b09a156eee

Author: byahn0996

cachelib/navy/block_cache/FixedSizeIndex.cpp

@@ -37,7 +37,7 @@ void FixedSizeIndex::initialize() {
 
   ht_ = std::make_unique<PackedItemRecord[]>(totalBuckets_);
   mutex_ = std::make_unique<SharedMutex[]>(totalMutexes_);
-  sizeForMutex_ = std::make_unique<size_t[]>(totalMutexes_);
+  validBucketsPerMutex_ = std::make_unique<size_t[]>(totalMutexes_);
 
   bucketDistInfo_.initialize(totalBuckets_);
 }
@@ -91,7 +91,7 @@ Index::LookupResult FixedSizeIndex::insert(uint64_t key,
                                  0, /* totalHits */
                                  elb.recordRef().info.curHits));
   } else {
-    ++elb.sizeRef();
+    ++elb.validBucketCntRef();
   }
   // TODO: need to combine this two ops into one to make sure updateDistInfo()
   // part is not missed
@@ -123,8 +123,8 @@ Index::LookupResult FixedSizeIndex::remove(uint64_t key) {
                                      0, /* totalHits */
                                      elb.recordRef().info.curHits)};
 
-    XDCHECK(elb.sizeRef() > 0);
-    --elb.sizeRef();
+    XDCHECK(elb.validBucketCntRef() > 0);
+    --elb.validBucketCntRef();
     elb.recordRef() = PackedItemRecord{};
     return lr;
   }
@@ -139,8 +139,8 @@ bool FixedSizeIndex::removeIfMatch(uint64_t key, uint32_t address) {
   if (elb.recordRef().address == address) {
     elb.recordRef() = PackedItemRecord{};
 
-    XDCHECK(elb.sizeRef() > 0);
-    --elb.sizeRef();
+    XDCHECK(elb.validBucketCntRef() > 0);
+    --elb.validBucketCntRef();
 
     return true;
   }
@@ -154,15 +154,15 @@ void FixedSizeIndex::reset() {
     for (uint64_t j = 0; j < numBucketsPerMutex_; ++j) {
       ht_[bucketId++] = PackedItemRecord{};
     }
-    sizeForMutex_[i] = 0;
+    validBucketsPerMutex_[i] = 0;
   }
 }
 
 size_t FixedSizeIndex::computeSize() const {
   size_t size = 0;
   for (uint32_t i = 0; i < totalMutexes_; i++) {
     auto lock = std::shared_lock{mutex_[i]};
-    size += sizeForMutex_[i];
+    size += validBucketsPerMutex_[i];
   }
 
   return size;
@@ -246,7 +246,7 @@ void FixedSizeIndex::recover(RecordReader& rr) {
           PackedItemRecord{static_cast<uint32_t>(*entry.address()),
                            static_cast<uint16_t>(*entry.sizeHint()),
                            static_cast<uint8_t>(*entry.currentHits())};
-      ++sizeForMutex_[*entry.key() / numBucketsPerMutex_];
+      ++validBucketsPerMutex_[*entry.key() / numBucketsPerMutex_];
     } else {
       ht_[*entry.key()] = PackedItemRecord{};
     }

cachelib/navy/block_cache/FixedSizeIndex.h

@@ -382,15 +382,15 @@ class FixedSizeIndex : public Index {
   std::unique_ptr<PackedItemRecord[]> ht_;
   std::unique_ptr<SharedMutex[]> mutex_;
   // The size for ht (stored bucket count) will be managed per Mutex basis
-  std::unique_ptr<size_t[]> sizeForMutex_;
+  std::unique_ptr<size_t[]> validBucketsPerMutex_;
 
   BucketDistInfo bucketDistInfo_;
 
   // A helper class for exclusive locked access to a bucket.
   // It will lock the proper mutex with the given key when it's created.
-  // recordRef() and sizeRef() will return the record and size with exclusively
-  // locked bucket reference.
-  // Locked mutex will be released when it's destroyed.
+  // recordRef() and validBucketCntRef() will return the record and
+  // valid bucket count with exclusively locked bucket reference. Locked
+  // mutex will be released when it's destroyed.
   class ExclusiveLockedBucket {
    public:
     explicit ExclusiveLockedBucket(uint64_t key,
@@ -400,7 +400,7 @@ class FixedSizeIndex : public Index {
           mid_{index.mutexId(bid_)},
           lg_{index.mutex_[mid_]},
           record_{&index.ht_[bid_]},
-          size_{index.sizeForMutex_[mid_]} {
+          validBuckets_{index.validBucketsPerMutex_[mid_]} {
       auto offset = alloc ? index.decideBucketOffset(bid_, key)
                           : index.checkBucketOffset(bid_, key);
       if (offset != 0) {
@@ -411,7 +411,7 @@ class FixedSizeIndex : public Index {
     }
 
     PackedItemRecord& recordRef() { return *record_; }
-    size_t& sizeRef() { return size_; }
+    size_t& validBucketCntRef() { return validBuckets_; }
     void updateDistInfo(uint64_t key, FixedSizeIndex& index) {
       index.bucketDistInfo_.updateBucketFillInfo(
           bid_, bucketOffset_, index.partialKeyBits(key));
@@ -422,7 +422,7 @@ class FixedSizeIndex : public Index {
     uint64_t mid_;
     std::lock_guard<SharedMutex> lg_;
     PackedItemRecord* record_;
-    size_t& size_;
+    size_t& validBuckets_;
     uint8_t bucketOffset_{0};
   };