MB-16181: Rename 'diskCount' to 'itemCount'

jimwwalker · jimwwalker · commit e02bd2cc4e8b · 2020-10-02T12:51:09.000Z
Both ephemeral and persistent buckets use this field for collection counting - it's not really just the disk count but our canonical place for a collection's item count. Change-Id: Ib3107fd6331357ddbae943a00b04d2da0c3647f7 Reviewed-on: http://review.couchbase.org/c/kv_engine/+/137394 Reviewed-by: Dave Rigby <daver@couchbase.com> Tested-by: Jim Walker <jim@couchbase.com>
diff --git a/engines/ep/src/collections/flush.cc b/engines/ep/src/collections/flush.cc
@@ -62,14 +62,14 @@ class StatsUpdate {
     bool isLogicallyDeleted(uint64_t seqno) const;
 
     /**
-     * Increment the 'disk' count for the collection associated with the key
+     * Increment the item count for the collection associated with the key
      */
-    void incrementDiskCount();
+    void incrementItemCount();
 
     /**
-     * Decrement the 'disk' count for the collection associated with the key
+     * Decrement the item count for the collection associated with the key
      */
-    void decrementDiskCount();
+    void decrementItemCount();
 
     /**
      * Update the on disk size (bytes) for the collection associated with
@@ -86,15 +86,15 @@ bool StatsUpdate::isLogicallyDeleted(uint64_t seqno) const {
     return handle.isLogicallyDeleted(seqno);
 }
 
-void StatsUpdate::incrementDiskCount() {
+void StatsUpdate::incrementItemCount() {
     if (!handle.getKey().isInSystemCollection()) {
-        handle.incrementDiskCount();
+        handle.incrementItemCount();
     }
 }
 
-void StatsUpdate::decrementDiskCount() {
+void StatsUpdate::decrementItemCount() {
     if (!handle.getKey().isInSystemCollection()) {
-        handle.decrementDiskCount();
+        handle.decrementItemCount();
     }
 }
 
@@ -146,7 +146,7 @@ void StatsUpdate::insert(bool isCommitted,
                          bool isDelete,
                          ssize_t diskSizeDelta) {
     if (!isDelete && isCommitted) {
-        incrementDiskCount();
+        incrementItemCount();
     } // else inserting a tombstone or it's a prepare
 
     if (isCommitted) {
@@ -162,7 +162,7 @@ void StatsUpdate::update(bool isCommitted, ssize_t diskSizeDelta) {
 
 void StatsUpdate::remove(bool isCommitted, ssize_t diskSizeDelta) {
     if (isCommitted) {
-        decrementDiskCount();
+        decrementItemCount();
     } // else inserting a tombstone or it's a prepare
 
     if (isCommitted) {
diff --git a/engines/ep/src/collections/vbucket_manifest.cc b/engines/ep/src/collections/vbucket_manifest.cc
@@ -739,9 +739,7 @@ uint64_t Manifest::getItemCount(CollectionID collection) const {
                 __FUNCTION__,
                 "failed find of collection:" + collection.to_string());
     }
-    // For now link through to disk count
-    // @todo: ephemeral support
-    return itr->second.getDiskCount();
+    return itr->second.getItemCount();
 }
 
 uint64_t Manifest::getHighSeqno(CollectionID collection) const {
@@ -789,24 +787,24 @@ void Manifest::setPersistedHighSeqno(CollectionID collection,
     itr->second.setPersistedHighSeqno(value);
 }
 
-void Manifest::incrementDiskCount(CollectionID collection) const {
+void Manifest::incrementItemCount(CollectionID collection) const {
     auto itr = map.find(collection);
     if (itr == map.end()) {
         throwException<std::invalid_argument>(
                 __FUNCTION__,
                 "failed find of collection:" + collection.to_string());
     }
-    return itr->second.incrementDiskCount();
+    return itr->second.incrementItemCount();
 }
 
-void Manifest::decrementDiskCount(CollectionID collection) const {
+void Manifest::decrementItemCount(CollectionID collection) const {
     auto itr = map.find(collection);
     if (itr == map.end()) {
         throwException<std::invalid_argument>(
                 __FUNCTION__,
                 "failed find of collection:" + collection.to_string());
     }
-    return itr->second.decrementDiskCount();
+    return itr->second.decrementItemCount();
 }
 
 bool Manifest::addCollectionStats(Vbid vbid,
@@ -874,7 +872,7 @@ bool Manifest::addScopeStats(Vbid vbid,
                          vbid.get(),
                          entry.getScopeID().to_string().c_str(),
                          cid.to_string().c_str());
-        add_casted_stat(buffer, entry.getDiskCount(), add_stat, cookie);
+        add_casted_stat(buffer, entry.getItemCount(), add_stat, cookie);
     }
 
     return true;
diff --git a/engines/ep/src/collections/vbucket_manifest.h b/engines/ep/src/collections/vbucket_manifest.h
@@ -436,22 +436,22 @@ class Manifest {
     bool isLogicallyDeleted(const container::const_iterator entry,
                             int64_t seqno) const;
 
-    void incrementDiskCount(const container::const_iterator entry) const {
+    void incrementItemCount(const container::const_iterator entry) const {
         if (entry == map.end()) {
             throwException<std::invalid_argument>(__FUNCTION__,
                                                   "iterator is invalid");
         }
 
-        entry->second.incrementDiskCount();
+        entry->second.incrementItemCount();
     }
 
-    void decrementDiskCount(const container::const_iterator entry) const {
+    void decrementItemCount(const container::const_iterator entry) const {
         if (entry == map.end()) {
             throwException<std::invalid_argument>(__FUNCTION__,
                                                   "iterator is invalid");
         }
 
-        entry->second.decrementDiskCount();
+        entry->second.decrementItemCount();
     }
 
     void updateDiskSize(const container::const_iterator entry,
@@ -570,14 +570,14 @@ class Manifest {
      * called via a ReadHandle because the read lock only ensures the map
      * does not change.
      */
-    void incrementDiskCount(CollectionID collection) const;
+    void incrementItemCount(CollectionID collection) const;
 
     /**
      * Decrement the item count for the given collection. Const and can be
      * called via a ReadHandle because the read lock only ensures the map
      * does not change.
      */
-    void decrementDiskCount(CollectionID collection) const;
+    void decrementItemCount(CollectionID collection) const;
 
     container::const_iterator end() const {
         return map.end();
diff --git a/engines/ep/src/collections/vbucket_manifest_entry.cc b/engines/ep/src/collections/vbucket_manifest_entry.cc
@@ -31,7 +31,7 @@ Collections::VB::ManifestEntry& Collections::VB::ManifestEntry::operator=(
     startSeqno = other.startSeqno;
     scopeID = other.scopeID;
     maxTtl = other.maxTtl;
-    diskCount = other.diskCount;
+    itemCount = other.itemCount;
     diskSize = other.diskSize;
     highSeqno.reset(other.highSeqno);
     persistedHighSeqno.store(other.persistedHighSeqno,
@@ -46,7 +46,7 @@ bool Collections::VB::ManifestEntry::operator==(
         const ManifestEntry& other) const {
     return scopeID == other.scopeID && startSeqno == other.startSeqno &&
            maxTtl == other.maxTtl && highSeqno == other.highSeqno &&
-           diskCount == other.diskCount && diskSize == other.diskSize &&
+           itemCount == other.itemCount && diskSize == other.diskSize &&
            persistedHighSeqno == other.persistedHighSeqno &&
            numOpsGet == other.numOpsGet && numOpsDelete == other.numOpsDelete &&
            numOpsStore == other.numOpsStore;
@@ -84,7 +84,7 @@ bool Collections::VB::ManifestEntry::addStats(const std::string& cid,
         add_casted_stat(buffer, getPersistedHighSeqno(), add_stat, cookie);
         checked_snprintf(
                 buffer, bsize, "vb_%d:%s:items", vbid.get(), cid.c_str());
-        add_casted_stat(buffer, getDiskCount(), add_stat, cookie);
+        add_casted_stat(buffer, getItemCount(), add_stat, cookie);
 
         if (getMaxTtl()) {
             checked_snprintf(
@@ -109,7 +109,7 @@ std::ostream& Collections::VB::operator<<(
        << ", startSeqno:" << manifestEntry.getStartSeqno()
        << ", highSeqno:" << manifestEntry.getHighSeqno()
        << ", persistedHighSeqno:" << manifestEntry.getPersistedHighSeqno()
-       << ", diskCount:" << manifestEntry.getDiskCount();
+       << ", itemCount:" << manifestEntry.getItemCount();
 
     if (manifestEntry.getMaxTtl()) {
         os << ", maxTtl:" << manifestEntry.getMaxTtl().value().count();
diff --git a/engines/ep/src/collections/vbucket_manifest_entry.h b/engines/ep/src/collections/vbucket_manifest_entry.h
@@ -42,7 +42,7 @@ class ManifestEntry {
         : startSeqno(startSeqno),
           scopeID(scopeID),
           maxTtl(std::move(maxTtl)),
-          diskCount(0),
+          itemCount(0),
           highSeqno(startSeqno),
           persistedHighSeqno(startSeqno) {
     }
@@ -81,24 +81,24 @@ class ManifestEntry {
         return maxTtl;
     }
 
-    /// increment how many items are stored on disk for this collection
-    void incrementDiskCount() const {
-        diskCount++;
+    /// increment how many items are stored for this collection
+    void incrementItemCount() const {
+        itemCount++;
     }
 
-    /// decrement how many items are stored on disk for this collection
-    void decrementDiskCount() const {
-        diskCount--;
+    /// decrement how many items are stored for this collection
+    void decrementItemCount() const {
+        itemCount--;
     }
 
     /// set how many items this collection has stored
-    void setDiskCount(uint64_t value) {
-        diskCount = value;
+    void setItemCount(uint64_t value) {
+        itemCount = value;
     }
 
-    /// @return how many items are stored on disk for this collection
-    uint64_t getDiskCount() const {
-        return diskCount;
+    /// @return how many items are stored for this collection
+    uint64_t getItemCount() const {
+        return itemCount;
     }
 
     /// decrement the tracked total size (bytes) on disk for this collection
@@ -180,7 +180,7 @@ class ManifestEntry {
         return numOpsGet.load();
     }
     AccumulatedStats getStatsForSummary() const {
-        return {getDiskCount(),
+        return {getItemCount(),
                 getDiskSize(),
                 getOpsStore(),
                 getOpsDelete(),
@@ -231,7 +231,7 @@ class ManifestEntry {
      *           we can do stats updates as long as the read lock is held.
      *           The write lock is really for the Manifest map being changed.
      */
-    mutable cb::NonNegativeCounter<uint64_t> diskCount;
+    mutable cb::NonNegativeCounter<uint64_t> itemCount;
 
     /**
      * The total size (bytes) of items in this collection on disk
diff --git a/engines/ep/src/collections/vbucket_manifest_handles.cc b/engines/ep/src/collections/vbucket_manifest_handles.cc
@@ -23,7 +23,7 @@
 namespace Collections::VB {
 
 PersistedStats StatsReadHandle::getPersistedStats() const {
-    return {itr->second.getDiskCount(),
+    return {itr->second.getItemCount(),
             itr->second.getPersistedHighSeqno(),
             itr->second.getDiskSize()};
 }
diff --git a/engines/ep/src/collections/vbucket_manifest_handles.h b/engines/ep/src/collections/vbucket_manifest_handles.h
@@ -153,12 +153,12 @@ class ReadHandle {
         manifest->setHighSeqno(collection, value);
     }
 
-    void incrementDiskCount(CollectionID collection) const {
-        manifest->incrementDiskCount(collection);
+    void incrementItemCount(CollectionID collection) const {
+        manifest->incrementItemCount(collection);
     }
 
-    void decrementDiskCount(CollectionID collection) const {
-        manifest->decrementDiskCount(collection);
+    void decrementItemCount(CollectionID collection) const {
+        manifest->decrementItemCount(collection);
     }
 
     bool addCollectionStats(Vbid vbid,
@@ -295,13 +295,13 @@ class CachingReadHandle : private ReadHandle {
      *
      * increment the key's collection item count by 1
      */
-    void incrementDiskCount() const {
+    void incrementItemCount() const {
         // We may be flushing keys written to a dropped collection so can
         // have an invalid iterator or the id is not mapped (system)
         if (!valid()) {
             return;
         }
-        return manifest->incrementDiskCount(itr);
+        return manifest->incrementItemCount(itr);
     }
 
     /**
@@ -313,13 +313,13 @@ class CachingReadHandle : private ReadHandle {
      *
      * decrement the key's collection item count by 1
      */
-    void decrementDiskCount() const {
+    void decrementItemCount() const {
         // We may be flushing keys written to a dropped collection so can
         // have an invalid iterator or the id is not mapped (system)
         if (!valid()) {
             return;
         }
-        return manifest->decrementDiskCount(itr);
+        return manifest->decrementItemCount(itr);
     }
 
     /**
diff --git a/engines/ep/src/ep_bucket.cc b/engines/ep/src/ep_bucket.cc
@@ -1526,7 +1526,7 @@ class EPDiskRollbackCB : public RollbackCB {
                     vb->incrNumTotalItems();
                     vb->getManifest()
                             .lock(preRbSeqnoItem->getKey())
-                            .incrementDiskCount();
+                            .incrementItemCount();
                 }
             }
         } else if (preRbSeqnoGetValue.getStatus() == ENGINE_KEY_ENOENT) {
@@ -1557,7 +1557,7 @@ class EPDiskRollbackCB : public RollbackCB {
             // Irrespective of if the in-memory delete succeeded; the document
             // doesn't exist on disk; so decrement the item count.
             vb.decrNumTotalItems();
-            vb.getManifest().lock(item.getKey()).decrementDiskCount();
+            vb.getManifest().lock(item.getKey()).decrementItemCount();
         }
     }
 
diff --git a/engines/ep/src/vbucket.cc b/engines/ep/src/vbucket.cc
@@ -3071,7 +3071,7 @@ void VBucket::collectionsRolledBack(KVStore& kvstore) {
         auto stats =
                 kvstore.getCollectionStats(*kvstoreContext, collection.first);
         if (stats) {
-            collection.second.setDiskCount(stats->itemCount);
+            collection.second.setItemCount(stats->itemCount);
             collection.second.setDiskSize(stats->diskSize);
             collection.second.resetPersistedHighSeqno(stats->highSeqno);
             collection.second.resetHighSeqno(
@@ -3763,9 +3763,9 @@ void VBucket::doCollectionsStats(
     cHandle.setHighSeqno(notifyCtx.bySeqno);
 
     if (notifyCtx.itemCountDifference == 1) {
-        cHandle.incrementDiskCount();
+        cHandle.incrementItemCount();
     } else if (notifyCtx.itemCountDifference == -1) {
-        cHandle.decrementDiskCount();
+        cHandle.decrementItemCount();
     }
 }
 
@@ -3775,9 +3775,9 @@ void VBucket::doCollectionsStats(const Collections::VB::ReadHandle& readHandle,
     readHandle.setHighSeqno(collection, notifyCtx.bySeqno);
 
     if (notifyCtx.itemCountDifference == 1) {
-        readHandle.incrementDiskCount(collection);
+        readHandle.incrementItemCount(collection);
     } else if (notifyCtx.itemCountDifference == -1) {
-        readHandle.decrementDiskCount(collection);
+        readHandle.decrementItemCount(collection);
     }
 }
 
diff --git a/engines/ep/src/warmup.cc b/engines/ep/src/warmup.cc
@@ -1167,7 +1167,7 @@ void Warmup::loadCollectionStatsForShard(uint16_t shardId) {
             auto stats = kvstore->getCollectionStats(*kvstoreContext,
                                                      collection.first);
             if (stats) {
-                collection.second.setDiskCount(stats->itemCount);
+                collection.second.setItemCount(stats->itemCount);
                 collection.second.setPersistedHighSeqno(stats->highSeqno);
                 collection.second.setDiskSize(stats->diskSize);
                 // Set the in memory high seqno - might be 0 in the case of the
diff --git a/engines/ep/tests/module_tests/ephemeral_vb_test.cc b/engines/ep/tests/module_tests/ephemeral_vb_test.cc
@@ -99,7 +99,7 @@ TEST_F(EphemeralVBucketTest, DoublePageOut) {
     // EphemeralVB::pageOut will delete the item so to prevent a stat counting
     // underflow we should increment it.
     ASSERT_EQ(0, readHandle.getItemCount(key.getCollectionID()));
-    readHandle.incrementDiskCount(key.getCollectionID());
+    readHandle.incrementItemCount(key.getCollectionID());
     ASSERT_EQ(1, readHandle.getItemCount(key.getCollectionID()));
 
     // Page out the item (once).
@@ -170,7 +170,7 @@ TEST_F(EphemeralVBucketTest, CreatePageoutCreate) {
         // EphemeralVB::pageOut will delete the item so to prevent a stat
         // counting underflow we should increment it.
         ASSERT_EQ(0, readHandle.getItemCount(key.getCollectionID()));
-        readHandle.incrementDiskCount(key.getCollectionID());
+        readHandle.incrementItemCount(key.getCollectionID());
         ASSERT_EQ(1, readHandle.getItemCount(key.getCollectionID()));
 
         auto lock_sv = lockAndFind(key);
@@ -203,7 +203,7 @@ TEST_F(EphemeralVBucketTest, CreatePageoutCreate) {
         // EphemeralVB::pageOut will delete the item so to prevent a stat
         // counting underflow we should increment it.
         ASSERT_EQ(0, readHandle.getItemCount(key.getCollectionID()));
-        readHandle.incrementDiskCount(key.getCollectionID());
+        readHandle.incrementItemCount(key.getCollectionID());
         ASSERT_EQ(1, readHandle.getItemCount(key.getCollectionID()));
 
         auto lock_sv = lockAndFind(key);

Original file line number	Diff line number	Diff line change
`@@ -739,9 +739,7 @@ uint64_t Manifest::getItemCount(CollectionID collection) const {`
`739`	`739`	`__FUNCTION__,`
`740`	`740`	`"failed find of collection:" + collection.to_string());`
`741`	`741`	`}`
`742`		`- // For now link through to disk count`
`743`		`- // @todo: ephemeral support`
`744`		`- return itr->second.getDiskCount();`
	`742`	`+ return itr->second.getItemCount();`
`745`	`743`	`}`
`746`	`744`
`747`	`745`	`uint64_t Manifest::getHighSeqno(CollectionID collection) const {`
`@@ -789,24 +787,24 @@ void Manifest::setPersistedHighSeqno(CollectionID collection,`
`789`	`787`	`itr->second.setPersistedHighSeqno(value);`
`790`	`788`	`}`
`791`	`789`
`792`		`-void Manifest::incrementDiskCount(CollectionID collection) const {`
	`790`	`+void Manifest::incrementItemCount(CollectionID collection) const {`
`793`	`791`	`auto itr = map.find(collection);`
`794`	`792`	`if (itr == map.end()) {`
`795`	`793`	`throwException<std::invalid_argument>(`
`796`	`794`	`__FUNCTION__,`
`797`	`795`	`"failed find of collection:" + collection.to_string());`
`798`	`796`	`}`
`799`		`- return itr->second.incrementDiskCount();`
	`797`	`+ return itr->second.incrementItemCount();`
`800`	`798`	`}`
`801`	`799`
`802`		`-void Manifest::decrementDiskCount(CollectionID collection) const {`
	`800`	`+void Manifest::decrementItemCount(CollectionID collection) const {`
`803`	`801`	`auto itr = map.find(collection);`
`804`	`802`	`if (itr == map.end()) {`
`805`	`803`	`throwException<std::invalid_argument>(`
`806`	`804`	`__FUNCTION__,`
`807`	`805`	`"failed find of collection:" + collection.to_string());`
`808`	`806`	`}`
`809`		`- return itr->second.decrementDiskCount();`
	`807`	`+ return itr->second.decrementItemCount();`
`810`	`808`	`}`
`811`	`809`
`812`	`810`	`bool Manifest::addCollectionStats(Vbid vbid,`
`@@ -874,7 +872,7 @@ bool Manifest::addScopeStats(Vbid vbid,`
`874`	`872`	`vbid.get(),`
`875`	`873`	`entry.getScopeID().to_string().c_str(),`
`876`	`874`	`cid.to_string().c_str());`
`877`		`- add_casted_stat(buffer, entry.getDiskCount(), add_stat, cookie);`
	`875`	`+ add_casted_stat(buffer, entry.getItemCount(), add_stat, cookie);`
`878`	`876`	`}`
`879`	`877`
`880`	`878`	`return true;`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@`
`23`	`23`	`namespace Collections::VB {`
`24`	`24`
`25`	`25`	`PersistedStats StatsReadHandle::getPersistedStats() const {`
`26`		`- return {itr->second.getDiskCount(),`
	`26`	`+ return {itr->second.getItemCount(),`
`27`	`27`	`itr->second.getPersistedHighSeqno(),`
`28`	`28`	`itr->second.getDiskSize()};`
`29`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -153,12 +153,12 @@ class ReadHandle {`
`153`	`153`	`manifest->setHighSeqno(collection, value);`
`154`	`154`	`}`
`155`	`155`
`156`		`- void incrementDiskCount(CollectionID collection) const {`
`157`		`- manifest->incrementDiskCount(collection);`
	`156`	`+ void incrementItemCount(CollectionID collection) const {`
	`157`	`+ manifest->incrementItemCount(collection);`
`158`	`158`	`}`
`159`	`159`
`160`		`- void decrementDiskCount(CollectionID collection) const {`
`161`		`- manifest->decrementDiskCount(collection);`
	`160`	`+ void decrementItemCount(CollectionID collection) const {`
	`161`	`+ manifest->decrementItemCount(collection);`
`162`	`162`	`}`
`163`	`163`
`164`	`164`	`bool addCollectionStats(Vbid vbid,`
`@@ -295,13 +295,13 @@ class CachingReadHandle : private ReadHandle {`
`295`	`295`	`*`
`296`	`296`	`* increment the key's collection item count by 1`
`297`	`297`	`*/`
`298`		`- void incrementDiskCount() const {`
	`298`	`+ void incrementItemCount() const {`
`299`	`299`	`// We may be flushing keys written to a dropped collection so can`
`300`	`300`	`// have an invalid iterator or the id is not mapped (system)`
`301`	`301`	`if (!valid()) {`
`302`	`302`	`return;`
`303`	`303`	`}`
`304`		`- return manifest->incrementDiskCount(itr);`
	`304`	`+ return manifest->incrementItemCount(itr);`
`305`	`305`	`}`
`306`	`306`
`307`	`307`	`/**`
`@@ -313,13 +313,13 @@ class CachingReadHandle : private ReadHandle {`
`313`	`313`	`*`
`314`	`314`	`* decrement the key's collection item count by 1`
`315`	`315`	`*/`
`316`		`- void decrementDiskCount() const {`
	`316`	`+ void decrementItemCount() const {`
`317`	`317`	`// We may be flushing keys written to a dropped collection so can`
`318`	`318`	`// have an invalid iterator or the id is not mapped (system)`
`319`	`319`	`if (!valid()) {`
`320`	`320`	`return;`
`321`	`321`	`}`
`322`		`- return manifest->decrementDiskCount(itr);`
	`322`	`+ return manifest->decrementItemCount(itr);`
`323`	`323`	`}`
`324`	`324`
`325`	`325`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -1526,7 +1526,7 @@ class EPDiskRollbackCB : public RollbackCB {`
`1526`	`1526`	`vb->incrNumTotalItems();`
`1527`	`1527`	`vb->getManifest()`
`1528`	`1528`	`.lock(preRbSeqnoItem->getKey())`
`1529`		`- .incrementDiskCount();`
	`1529`	`+ .incrementItemCount();`
`1530`	`1530`	`}`
`1531`	`1531`	`}`
`1532`	`1532`	`} else if (preRbSeqnoGetValue.getStatus() == ENGINE_KEY_ENOENT) {`
`@@ -1557,7 +1557,7 @@ class EPDiskRollbackCB : public RollbackCB {`
`1557`	`1557`	`// Irrespective of if the in-memory delete succeeded; the document`
`1558`	`1558`	`// doesn't exist on disk; so decrement the item count.`
`1559`	`1559`	`vb.decrNumTotalItems();`
`1560`		`- vb.getManifest().lock(item.getKey()).decrementDiskCount();`
	`1560`	`+ vb.getManifest().lock(item.getKey()).decrementItemCount();`
`1561`	`1561`	`}`
`1562`	`1562`	`}`
`1563`	`1563`