SERVER-23243 Replace Listener::getElapsedTimeMillis() in scoped_timer.cpp

Author: WaleyChen

src/mongo/db/exec/SConscript

@@ -112,6 +112,7 @@ env.CppUnitTest(
         "exec",
         "$BUILD_DIR/mongo/db/serveronly",
         "$BUILD_DIR/mongo/dbtests/mocklib",
+        "$BUILD_DIR/mongo/util/clock_source_mock",
         "$BUILD_DIR/mongo/util/ntservice_mock",
     ],
     NO_CRUTCH = True,
@@ -127,6 +128,7 @@ env.CppUnitTest(
         "$BUILD_DIR/mongo/db/serveronly",
         "$BUILD_DIR/mongo/dbtests/mocklib",
         "$BUILD_DIR/mongo/db/query/collation/collator_interface_mock",
+        "$BUILD_DIR/mongo/util/clock_source_mock",
         "$BUILD_DIR/mongo/util/ntservice_mock",
     ],
     NO_CRUTCH = True,

src/mongo/db/exec/cached_plan.cpp

@@ -74,7 +74,7 @@ Status CachedPlanStage::pickBestPlan(PlanYieldPolicy* yieldPolicy) {
     // Adds the amount of time taken by pickBestPlan() to executionTimeMillis. There's lots of
     // execution work that happens here, so this is needed for the time accounting to
     // make sense.
-    ScopedTimer timer(&_commonStats.executionTimeMillis);
+    ScopedTimer timer(getClock(), &_commonStats.executionTimeMillis);
 
     // If we work this many times during the trial period, then we will replan the
     // query from scratch.

src/mongo/db/exec/multi_plan.cpp

@@ -203,7 +203,7 @@ Status MultiPlanStage::pickBestPlan(PlanYieldPolicy* yieldPolicy) {
     // Adds the amount of time taken by pickBestPlan() to executionTimeMillis. There's lots of
     // execution work that happens here, so this is needed for the time accounting to
     // make sense.
-    ScopedTimer timer(&_commonStats.executionTimeMillis);
+    ScopedTimer timer(getClock(), &_commonStats.executionTimeMillis);
 
     size_t numWorks = getTrialPeriodWorks(getOpCtx(), _collection);
     size_t numResults = getTrialPeriodNumToReturn(*_query);

src/mongo/db/exec/plan_stage.cpp

@@ -33,11 +33,14 @@
 #include "mongo/db/exec/plan_stage.h"
 
 #include "mongo/db/exec/scoped_timer.h"
+#include "mongo/db/operation_context.h"
+#include "mongo/db/service_context.h"
 
 namespace mongo {
 
 PlanStage::StageState PlanStage::work(WorkingSetID* out) {
-    ScopedTimer timer(&_commonStats.executionTimeMillis);
+    invariant(_opCtx);
+    ScopedTimer timer(getClock(), &_commonStats.executionTimeMillis);
     ++_commonStats.works;
 
     StageState workResult = doWork(out);
@@ -102,4 +105,8 @@ void PlanStage::reattachToOperationContext(OperationContext* opCtx) {
     doReattachToOperationContext();
 }
 
+ClockSource* PlanStage::getClock() const {
+    return _opCtx->getServiceContext()->getFastClockSource();
+}
+
 }  // namespace mongo

src/mongo/db/exec/plan_stage.h

@@ -37,9 +37,10 @@
 
 namespace mongo {
 
+class ClockSource;
 class Collection;
-class RecordId;
 class OperationContext;
+class RecordId;
 
 /**
  * A PlanStage ("stage") is the basic building block of a "Query Execution Plan."  A stage is
@@ -357,6 +358,8 @@ class PlanStage {
      */
     virtual void doInvalidate(OperationContext* txn, const RecordId& dl, InvalidationType type) {}
 
+    ClockSource* getClock() const;
+
     OperationContext* getOpCtx() const {
         return _opCtx;
     }

src/mongo/db/exec/queued_data_stage_test.cpp

@@ -31,9 +31,14 @@
 //
 
 #include "mongo/db/exec/queued_data_stage.h"
+
 #include "mongo/db/exec/working_set.h"
+#include "mongo/db/operation_context_noop.h"
+#include "mongo/db/service_context.h"
+#include "mongo/db/service_context_noop.h"
 #include "mongo/stdx/memory.h"
 #include "mongo/unittest/unittest.h"
+#include "mongo/util/clock_source_mock.h"
 
 using namespace mongo;
 
@@ -42,12 +47,38 @@ namespace {
 using std::unique_ptr;
 using stdx::make_unique;
 
+class QueuedDataStageTest : public unittest::Test {
+public:
+    QueuedDataStageTest() {
+        _service = stdx::make_unique<ServiceContextNoop>();
+        _service.get()->setFastClockSource(stdx::make_unique<ClockSourceMock>());
+        _client = _service.get()->makeClient("test");
+        _opCtxNoop.reset(new OperationContextNoop(_client.get(), 0));
+        _opCtx = _opCtxNoop.get();
+    }
+
+protected:
+    OperationContext* getOpCtx() {
+        return _opCtx;
+    }
+
+private:
+    OperationContext* _opCtx;
+
+    // Members of a class are destroyed in reverse order of declaration.
+    // The UniqueClient must be destroyed before the ServiceContextNoop is destroyed.
+    // The OperationContextNoop must be destroyed before the UniqueClient is destroyed.
+    std::unique_ptr<ServiceContextNoop> _service;
+    ServiceContext::UniqueClient _client;
+    std::unique_ptr<OperationContextNoop> _opCtxNoop;
+};
+
 //
 // Basic test that we get out valid stats objects.
 //
-TEST(QueuedDataStageTest, getValidStats) {
+TEST_F(QueuedDataStageTest, getValidStats) {
     WorkingSet ws;
-    auto mock = make_unique<QueuedDataStage>(nullptr, &ws);
+    auto mock = make_unique<QueuedDataStage>(getOpCtx(), &ws);
     const CommonStats* commonStats = mock->getCommonStats();
     ASSERT_EQUALS(commonStats->works, static_cast<size_t>(0));
     const SpecificStats* specificStats = mock->getSpecificStats();
@@ -59,10 +90,10 @@ TEST(QueuedDataStageTest, getValidStats) {
 //
 // Test that our stats are updated as we perform operations.
 //
-TEST(QueuedDataStageTest, validateStats) {
+TEST_F(QueuedDataStageTest, validateStats) {
     WorkingSet ws;
     WorkingSetID wsID;
-    auto mock = make_unique<QueuedDataStage>(nullptr, &ws);
+    auto mock = make_unique<QueuedDataStage>(getOpCtx(), &ws);
 
     // make sure that we're at all zero
     const CommonStats* stats = mock->getCommonStats();

src/mongo/db/exec/scoped_timer.cpp

@@ -29,16 +29,15 @@
 #include "mongo/platform/basic.h"
 
 #include "mongo/db/exec/scoped_timer.h"
-
-#include "mongo/util/net/listen.h"
+#include "mongo/util/clock_source.h"
 
 namespace mongo {
 
-ScopedTimer::ScopedTimer(long long* counter)
-    : _counter(counter), _start(Listener::getElapsedTimeMillis()) {}
+ScopedTimer::ScopedTimer(ClockSource* cs, long long* counter)
+    : _clock(cs), _counter(counter), _start(cs->now()) {}
 
 ScopedTimer::~ScopedTimer() {
-    long long elapsed = Listener::getElapsedTimeMillis() - _start;
+    long long elapsed = durationCount<Milliseconds>(_clock->now() - _start);
     *_counter += elapsed;
 }
 

src/mongo/db/exec/scoped_timer.h

@@ -30,8 +30,12 @@
 
 #include "mongo/base/disallow_copying.h"
 
+#include "mongo/util/time_support.h"
+
 namespace mongo {
 
+class ClockSource;
+
 /**
  * This class increments a counter by a rough estimate of the time elapsed since its
  * construction when it goes out of scope.
@@ -40,19 +44,17 @@ class ScopedTimer {
     MONGO_DISALLOW_COPYING(ScopedTimer);
 
 public:
-    ScopedTimer(long long* counter);
+    ScopedTimer(ClockSource* cs, long long* counter);
 
     ~ScopedTimer();
 
 private:
-    // Default constructor disallowed.
-    ScopedTimer();
-
+    ClockSource* const _clock;
     // Reference to the counter that we are incrementing with the elapsed time.
     long long* _counter;
 
     // Time at which the timer was constructed.
-    long long _start;
+    const Date_t _start;
 };
 
 }  // namespace mongo