MB-41804: Correct replica overhead tracking

Mad-hatter uses MemoryTrackingAllocator to accurately account for the
overhead of checkpoint overheads.

This should be used in tracking replica overhead instead of the
approximate/manual accounting based on sizeof.

Additionally, expelling was not present in alice, where replica
overhead tracking was introduced. Replica overhead must also be
adjusted during expelling.

Change-Id: I6c39874618c4a6479b55324c1e42f5fc3edaa13c
Reviewed-on: http://review.couchbase.org/c/kv_engine/+/140256
Well-Formed: Build Bot <[email protected]>
Reviewed-by: Dave Rigby <[email protected]>
Tested-by: Build Bot <[email protected]>

Author: jameseh96

engines/ep/src/checkpoint.cc

@@ -203,7 +203,11 @@ Checkpoint::Checkpoint(EPStats& st,
       highCompletedSeqno(highCompletedSeqno),
       memOverheadChangedCallback(memOverheadChangedCallback) {
     stats.coreLocal.get()->memOverhead.fetch_add(sizeof(Checkpoint));
-    memOverheadChangedCallback(sizeof(Checkpoint));
+    // the memOverheadChangedCallback uses the accurately tracked overhead
+    // from trackingAllocator. The above memOverhead stat is "manually"
+    // accounted in queueDirty, and approximates the overhead based on
+    // key sizes and the size of queued_item and index_entry.
+    memOverheadChangedCallback(getMemoryOverhead());
 }
 
 Checkpoint::~Checkpoint() {
@@ -216,9 +220,9 @@ Checkpoint::~Checkpoint() {
      * of queued_items in the checkpoint.
      */
     auto queueMemOverhead = sizeof(queued_item) * toWrite.size();
-    auto overhead = sizeof(Checkpoint) + keyIndexMemUsage + queueMemOverhead;
-    stats.coreLocal.get()->memOverhead.fetch_sub(overhead);
-    memOverheadChangedCallback(-ssize_t(overhead));
+    stats.coreLocal.get()->memOverhead.fetch_sub(
+            sizeof(Checkpoint) + keyIndexMemUsage + queueMemOverhead);
+    memOverheadChangedCallback(-getMemoryOverhead());
 }
 
 QueueDirtyStatus Checkpoint::queueDirty(const queued_item& qi,
@@ -231,6 +235,14 @@ QueueDirtyStatus Checkpoint::queueDirty(const queued_item& qi,
     }
 
     QueueDirtyStatus rv;
+    // trigger the memOverheadChangedCallback if the overhead is different
+    // when this helper is destroyed
+    auto overheadCheck = gsl::finally([pre = getMemoryOverhead(), this]() {
+        auto post = getMemoryOverhead();
+        if (pre != post) {
+            memOverheadChangedCallback(post - pre);
+        }
+    });
 
     // Check if the item is a meta item
     if (qi->isCheckPointMetaItem()) {
@@ -388,9 +400,8 @@ QueueDirtyStatus Checkpoint::queueDirty(const queued_item& qi,
              * item to the queue (toWrite).  This is approximated to the
              * addition to metaKeyIndex / keyIndex plus sizeof(queued_item).
              */
-            auto overhead = indexKeyUsage + sizeof(queued_item);
-            stats.coreLocal.get()->memOverhead.fetch_add(overhead);
-            memOverheadChangedCallback(overhead);
+            stats.coreLocal.get()->memOverhead.fetch_add(indexKeyUsage +
+                                                         sizeof(queued_item));
             /**
              *  Update the total metaKeyIndex / keyIndex memory usage which is
              *  used when the checkpoint is destructed to manually account

engines/ep/src/checkpoint_manager.cc

@@ -571,6 +571,15 @@ size_t CheckpointManager::removeClosedUnrefCheckpoints(
 
 CheckpointManager::ExpelResult
 CheckpointManager::expelUnreferencedCheckpointItems() {
+    // trigger the overheadChangedCallback if the overhead is different
+    // when this helper is destroyed - which occurs _after_ the destruction
+    // of expelledItems (declared below)
+    auto overheadCheck = gsl::finally([pre = getMemoryOverhead(), this]() {
+        auto post = getMemoryOverhead();
+        if (pre != post) {
+            overheadChangedCallback(post - pre);
+        }
+    });
     CheckpointQueue expelledItems;
     {
         LockHolder lh(queueLock);

engines/ep/tests/module_tests/ephemeral_bucket_test.cc

@@ -241,7 +241,7 @@ TEST_F(EphemeralBucketStatTest, ReplicaMemoryTrackingStateChange) {
     setVBucketStateAndRunPersistTask(vbid, vbucket_state_active);
 
     EXPECT_EQ(0, stats.replicaHTMemory);
-    EXPECT_LT(stats.replicaCheckpointOverhead, 80);
+    EXPECT_EQ(0, stats.replicaCheckpointOverhead);
 }
 
 TEST_F(EphemeralBucketStatTest, ReplicaCheckpointMemoryTracking) {