SERVER-99656: Add throughput probing state metrics (#31765)

GitOrigin-RevId: 13f4d503dd23c784b91d96260fd14d9a06793929

Author: dom-hernandez

src/mongo/db/admission/throughput_probing.cpp

@@ -196,7 +196,6 @@ std::pair<int32_t, int32_t> newReadWriteConcurrencies(double stableConcurrency,
 
 void ThroughputProbing::_probeStable(OperationContext* opCtx, double throughput) {
     invariant(_state == ProbingState::kStable);
-
     LOGV2_DEBUG(7346000, 3, "Throughput Probing: stable", "throughput"_attr = throughput);
 
     // Record the baseline reading.
@@ -218,6 +217,8 @@ void ThroughputProbing::_probeStable(OperationContext* opCtx, double throughput)
         _state = ProbingState::kDown;
         _decreaseConcurrency(opCtx);
     }
+    // Due to the time resize concurrency takes, increment after increase/decrease
+    _stats.timesProbedStable.fetchAndAdd(1);
 }
 
 void ThroughputProbing::_probeUp(OperationContext* opCtx, double throughput) {
@@ -249,6 +250,8 @@ void ThroughputProbing::_probeUp(OperationContext* opCtx, double throughput) {
         _state = ProbingState::kStable;
         _resetConcurrency(opCtx);
     }
+    // Due to the time resize concurrency takes, increment after reset
+    _stats.timesProbedUp.fetchAndAdd(1);
 }
 
 void ThroughputProbing::_probeDown(OperationContext* opCtx, double throughput) {
@@ -280,6 +283,8 @@ void ThroughputProbing::_probeDown(OperationContext* opCtx, double throughput) {
         _state = ProbingState::kStable;
         _resetConcurrency(opCtx);
     }
+    // Due to the time resize concurrency takes, increment after reset
+    _stats.timesProbedDown.fetchAndAdd(1);
 }
 
 void ThroughputProbing::_resize(OperationContext* opCtx,
@@ -375,6 +380,9 @@ void ThroughputProbing::Stats::serialize(BSONObjBuilder& builder) const {
     builder.append("totalAmountDecreased", static_cast<long long>(totalAmountDecreased.load()));
     builder.append("totalAmountIncreased", static_cast<long long>(totalAmountIncreased.load()));
     builder.append("resizeDurationMicros", static_cast<long long>(resizeDurationMicros.load()));
+    builder.append("timesProbedStable", static_cast<long long>(timesProbedStable.load()));
+    builder.append("timesProbedUp", static_cast<long long>(timesProbedUp.load()));
+    builder.append("timesProbedDown", static_cast<long long>(timesProbedDown.load()));
 }
 
 ThroughputProbingTicketHolderManager::ThroughputProbingTicketHolderManager(

src/mongo/db/admission/throughput_probing.h

@@ -109,6 +109,9 @@ class ThroughputProbing {
         AtomicWord<int64_t> totalAmountDecreased;
         AtomicWord<int64_t> totalAmountIncreased;
         AtomicWord<int64_t> resizeDurationMicros;
+        AtomicWord<int64_t> timesProbedStable;
+        AtomicWord<int64_t> timesProbedUp;
+        AtomicWord<int64_t> timesProbedDown;
     } _stats;
 
     PeriodicJobAnchor _job;

src/mongo/db/admission/throughput_probing_test.cpp

@@ -145,17 +145,23 @@ class ThroughputProbingTest : public ServiceContextTest {
             return !concurrencyIncreased() && !concurrencyDecreased();
         }
 
+        bool probeIncemented(std::string a) const {
+            return _stats[a].Long() > _prevStats[a].Long();
+        }
+
         std::string toString() const {
             return str::stream() << "Stats: " << _stats << ", previous stats: " << _prevStats;
         }
 
     private:
         BSONObj _stats =
             BSON("timesDecreased" << 0ll << "timesIncreased" << 0ll << "totalAmountDecreased" << 0ll
-                                  << "totalAmountIncreased" << 0ll);
+                                  << "totalAmountIncreased" << 0ll << "timesProbedStable" << 0ll
+                                  << "timesProbedUp" << 0ll << "timesProbedDown" << 0ll);
         BSONObj _prevStats =
             BSON("timesDecreased" << 0ll << "timesIncreased" << 0ll << "totalAmountDecreased" << 0ll
-                                  << "totalAmountIncreased" << 0ll);
+                                  << "totalAmountIncreased" << 0ll << "timesProbedStable" << 0ll
+                                  << "timesProbedUp" << 0ll << "timesProbedDown" << 0ll);
     } _statsTester;
 };
 
@@ -208,6 +214,9 @@ TEST_F(ThroughputProbingTest, ProbeUpSucceeds) {
     ASSERT_GT(_readTicketHolder.outof(), initialSize);
     ASSERT_LT(_writeTicketHolder.outof(), size);
     ASSERT_GT(_writeTicketHolder.outof(), initialSize);
+    ASSERT_TRUE(_statsTester.probeIncemented("timesProbedUp"));
+    ASSERT_FALSE(_statsTester.probeIncemented("timesProbedDown"));
+    ASSERT_FALSE(_statsTester.probeIncemented("timesProbedStable"));
     ASSERT(_statsTester.concurrencyIncreased()) << _statsTester.toString();
 }
 
@@ -231,6 +240,9 @@ TEST_F(ThroughputProbingTest, ProbeUpFails) {
     _run();
     ASSERT_EQ(_readTicketHolder.outof(), size);
     ASSERT_EQ(_writeTicketHolder.outof(), size);
+    ASSERT_TRUE(_statsTester.probeIncemented("timesProbedUp"));
+    ASSERT_FALSE(_statsTester.probeIncemented("timesProbedDown"));
+    ASSERT_FALSE(_statsTester.probeIncemented("timesProbedStable"));
     ASSERT(_statsTester.concurrencyKept()) << _statsTester.toString();
 }
 
@@ -259,6 +271,9 @@ TEST_F(ThroughputProbingTest, ProbeDownSucceeds) {
     ASSERT_GT(_readTicketHolder.outof(), size);
     ASSERT_LT(_writeTicketHolder.outof(), initialSize);
     ASSERT_GT(_writeTicketHolder.outof(), size);
+    ASSERT_TRUE(_statsTester.probeIncemented("timesProbedDown"));
+    ASSERT_FALSE(_statsTester.probeIncemented("timesProbedUp"));
+    ASSERT_FALSE(_statsTester.probeIncemented("timesProbedStable"));
     ASSERT(_statsTester.concurrencyDecreased()) << _statsTester.toString();
 }
 
@@ -282,6 +297,9 @@ TEST_F(ThroughputProbingTest, ProbeDownFails) {
     _run();
     ASSERT_EQ(_readTicketHolder.outof(), size);
     ASSERT_EQ(_writeTicketHolder.outof(), size);
+    ASSERT_TRUE(_statsTester.probeIncemented("timesProbedDown"));
+    ASSERT_FALSE(_statsTester.probeIncemented("timesProbedUp"));
+    ASSERT_FALSE(_statsTester.probeIncemented("timesProbedStable"));
     ASSERT(_statsTester.concurrencyKept()) << _statsTester.toString();
 }
 
@@ -295,6 +313,8 @@ TEST_F(ThroughputProbingMaxConcurrencyTest, NoProbeUp) {
     // Stable. Probe down since concurrency is already at its maximum allowed value, even though
     // ticktes are exhausted.
     _run();
+    ASSERT_TRUE(_statsTester.probeIncemented("timesProbedStable"));
+    ASSERT_FALSE(_statsTester.probeIncemented("timesProbedUp"));
     ASSERT_LT(_readTicketHolder.outof(), size);
     ASSERT_LT(_writeTicketHolder.outof(), size);
 }
@@ -309,6 +329,8 @@ TEST_F(ThroughputProbingMinConcurrencyTest, NoProbeDown) {
     // Stable. Do not probe in either direction since tickets are not exhausted but concurrency is
     // already at its minimum allowed value.
     _run();
+    ASSERT_TRUE(_statsTester.probeIncemented("timesProbedStable"));
+    ASSERT_FALSE(_statsTester.probeIncemented("timesProbedDown"));
     ASSERT_EQ(_readTicketHolder.outof(), size);
     ASSERT_EQ(_writeTicketHolder.outof(), size);
 }