SERVER-42165 Replace uses of stdx::mutex with mongo::Mutex

10 files changed, 66 insertions, 66 deletions

diff --git a/src/mongo/util/concurrency/notification.h b/src/mongo/util/concurrency/notification.h
index 44bc7efc9ac..50e6b5e2302 100644
--- a/src/mongo/util/concurrency/notification.h
+++ b/src/mongo/util/concurrency/notification.h
@@ -32,8 +32,8 @@
 #include <boost/optional.hpp>
 
 #include "mongo/db/operation_context.h"
-#include "mongo/stdx/condition_variable.h"
-#include "mongo/stdx/mutex.h"
+#include "mongo/platform/condition_variable.h"
+#include "mongo/platform/mutex.h"
 #include "mongo/util/assert_util.h"
 #include "mongo/util/duration.h"
 #include "mongo/util/time_support.h"
@@ -59,7 +59,7 @@ public:
      * block).
      */
     explicit operator bool() const {
-        stdx::unique_lock<stdx::mutex> lock(_mutex);
+        stdx::unique_lock<Latch> lock(_mutex);
         return !!_value;
     }
 
@@ -68,7 +68,7 @@ public:
      * If the wait is interrupted, throws an exception.
      */
     T& get(OperationContext* opCtx) {
-        stdx::unique_lock<stdx::mutex> lock(_mutex);
+        stdx::unique_lock<Latch> lock(_mutex);
         opCtx->waitForConditionOrInterrupt(_condVar, lock, [this]() -> bool { return !!_value; });
         return _value.get();
     }
@@ -78,7 +78,7 @@ public:
      * This variant of get cannot be interrupted.
      */
     T& get() {
-        stdx::unique_lock<stdx::mutex> lock(_mutex);
+        stdx::unique_lock<Latch> lock(_mutex);
         while (!_value) {
             _condVar.wait(lock);
         }
@@ -91,7 +91,7 @@ public:
      * call. Must only be called once for the lifetime of the notification.
      */
     void set(T value) {
-        stdx::lock_guard<stdx::mutex> lock(_mutex);
+        stdx::lock_guard<Latch> lock(_mutex);
         invariant(!_value);
         _value = std::move(value);
         _condVar.notify_all();
@@ -104,13 +104,13 @@ public:
      * If the wait is interrupted, throws an exception.
      */
     bool waitFor(OperationContext* opCtx, Milliseconds waitTimeout) {
-        stdx::unique_lock<stdx::mutex> lock(_mutex);
+        stdx::unique_lock<Latch> lock(_mutex);
         return opCtx->waitForConditionOrInterruptFor(
             _condVar, lock, waitTimeout, [&]() { return !!_value; });
     }
 
 private:
-    mutable stdx::mutex _mutex;
+    mutable Mutex _mutex = MONGO_MAKE_LATCH("Notification::_mutex");
     stdx::condition_variable _condVar;
 
     // Protected by mutex and only moves from not-set to set once
diff --git a/src/mongo/util/concurrency/spin_lock.h b/src/mongo/util/concurrency/spin_lock.h
index 7f237dc3175..5c5a17b4b74 100644
--- a/src/mongo/util/concurrency/spin_lock.h
+++ b/src/mongo/util/concurrency/spin_lock.h
@@ -37,7 +37,7 @@
 
 #include "mongo/config.h"
 #include "mongo/platform/compiler.h"
-#include "mongo/stdx/mutex.h"
+#include "mongo/platform/mutex.h"
 
 namespace mongo {
 
@@ -86,7 +86,7 @@ public:
     }
 
 private:
-    stdx::mutex _mutex;
+    stdx::mutex _mutex;  // NOLINT
 };
 
 #else
diff --git a/src/mongo/util/concurrency/thread_pool.cpp b/src/mongo/util/concurrency/thread_pool.cpp
index fd8d23377ea..ceaf9fcaf7e 100644
--- a/src/mongo/util/concurrency/thread_pool.cpp
+++ b/src/mongo/util/concurrency/thread_pool.cpp
@@ -79,7 +79,7 @@ ThreadPool::Options cleanUpOptions(ThreadPool::Options&& options) {
 ThreadPool::ThreadPool(Options options) : _options(cleanUpOptions(std::move(options))) {}
 
 ThreadPool::~ThreadPool() {
-    stdx::unique_lock<stdx::mutex> lk(_mutex);
+    stdx::unique_lock<Latch> lk(_mutex);
     _shutdown_inlock();
     if (shutdownComplete != _state) {
         _join_inlock(&lk);
@@ -94,7 +94,7 @@ ThreadPool::~ThreadPool() {
 }
 
 void ThreadPool::startup() {
-    stdx::lock_guard<stdx::mutex> lk(_mutex);
+    stdx::lock_guard<Latch> lk(_mutex);
     if (_state != preStart) {
         severe() << "Attempting to start pool " << _options.poolName
                  << ", but it has already started";
@@ -110,7 +110,7 @@ void ThreadPool::startup() {
 }
 
 void ThreadPool::shutdown() {
-    stdx::lock_guard<stdx::mutex> lk(_mutex);
+    stdx::lock_guard<Latch> lk(_mutex);
     _shutdown_inlock();
 }
 
@@ -130,11 +130,11 @@ void ThreadPool::_shutdown_inlock() {
 }
 
 void ThreadPool::join() {
-    stdx::unique_lock<stdx::mutex> lk(_mutex);
+    stdx::unique_lock<Latch> lk(_mutex);
     _join_inlock(&lk);
 }
 
-void ThreadPool::_join_inlock(stdx::unique_lock<stdx::mutex>* lk) {
+void ThreadPool::_join_inlock(stdx::unique_lock<Latch>* lk) {
     _stateChange.wait(*lk, [this] {
         switch (_state) {
             case preStart:
@@ -177,7 +177,7 @@ void ThreadPool::_drainPendingTasks() {
             << _options.threadNamePrefix << _nextThreadId++;
         setThreadName(threadName);
         _options.onCreateThread(threadName);
-        stdx::unique_lock<stdx::mutex> lock(_mutex);
+        stdx::unique_lock<Latch> lock(_mutex);
         while (!_pendingTasks.empty()) {
             _doOneTask(&lock);
         }
@@ -186,7 +186,7 @@ void ThreadPool::_drainPendingTasks() {
 }
 
 void ThreadPool::schedule(Task task) {
-    stdx::unique_lock<stdx::mutex> lk(_mutex);
+    stdx::unique_lock<Latch> lk(_mutex);
 
     switch (_state) {
         case joinRequired:
@@ -221,7 +221,7 @@ void ThreadPool::schedule(Task task) {
 }
 
 void ThreadPool::waitForIdle() {
-    stdx::unique_lock<stdx::mutex> lk(_mutex);
+    stdx::unique_lock<Latch> lk(_mutex);
     // If there are any pending tasks, or non-idle threads, the pool is not idle.
     while (!_pendingTasks.empty() || _numIdleThreads < _threads.size()) {
         _poolIsIdle.wait(lk);
@@ -229,7 +229,7 @@ void ThreadPool::waitForIdle() {
 }
 
 ThreadPool::Stats ThreadPool::getStats() const {
-    stdx::lock_guard<stdx::mutex> lk(_mutex);
+    stdx::lock_guard<Latch> lk(_mutex);
     Stats result;
     result.options = _options;
     result.numThreads = _threads.size();
@@ -257,7 +257,7 @@ void ThreadPool::_workerThreadBody(ThreadPool* pool, const std::string& threadNa
 }
 
 void ThreadPool::_consumeTasks() {
-    stdx::unique_lock<stdx::mutex> lk(_mutex);
+    stdx::unique_lock<Latch> lk(_mutex);
     while (_state == running) {
         if (_pendingTasks.empty()) {
             if (_threads.size() > _options.minThreads) {
@@ -331,7 +331,7 @@ void ThreadPool::_consumeTasks() {
     fassertFailedNoTrace(28703);
 }
 
-void ThreadPool::_doOneTask(stdx::unique_lock<stdx::mutex>* lk) noexcept {
+void ThreadPool::_doOneTask(stdx::unique_lock<Latch>* lk) noexcept {
     invariant(!_pendingTasks.empty());
     LOG(3) << "Executing a task on behalf of pool " << _options.poolName;
     Task task = std::move(_pendingTasks.front());
diff --git a/src/mongo/util/concurrency/thread_pool.h b/src/mongo/util/concurrency/thread_pool.h
index bbae97d1ebe..c382df9544d 100644
--- a/src/mongo/util/concurrency/thread_pool.h
+++ b/src/mongo/util/concurrency/thread_pool.h
@@ -34,8 +34,8 @@
 #include <string>
 #include <vector>
 
-#include "mongo/stdx/condition_variable.h"
-#include "mongo/stdx/mutex.h"
+#include "mongo/platform/condition_variable.h"
+#include "mongo/platform/mutex.h"
 #include "mongo/stdx/thread.h"
 #include "mongo/util/concurrency/thread_pool_interface.h"
 #include "mongo/util/time_support.h"
@@ -189,7 +189,7 @@ private:
     /**
      * Implementation of join once _mutex is owned by "lk".
      */
-    void _join_inlock(stdx::unique_lock<stdx::mutex>* lk);
+    void _join_inlock(stdx::unique_lock<Latch>* lk);
 
     /**
      * Runs the remaining tasks on a new thread as part of the join process, blocking until
@@ -201,7 +201,7 @@ private:
      * Executes one task from _pendingTasks. "lk" must own _mutex, and _pendingTasks must have at
      * least one entry.
      */
-    void _doOneTask(stdx::unique_lock<stdx::mutex>* lk) noexcept;
+    void _doOneTask(stdx::unique_lock<Latch>* lk) noexcept;
 
     /**
      * Changes the lifecycle state (_state) of the pool and wakes up any threads waiting for a state
@@ -213,7 +213,7 @@ private:
     const Options _options;
 
     // Mutex guarding all non-const member variables.
-    mutable stdx::mutex _mutex;
+    mutable Mutex _mutex = MONGO_MAKE_LATCH("ThreadPool::_mutex");
 
     // This variable represents the lifecycle state of the pool.
     //
diff --git a/src/mongo/util/concurrency/thread_pool_test.cpp b/src/mongo/util/concurrency/thread_pool_test.cpp
index 1d85b8b95df..5812a860eab 100644
--- a/src/mongo/util/concurrency/thread_pool_test.cpp
+++ b/src/mongo/util/concurrency/thread_pool_test.cpp
@@ -34,8 +34,8 @@
 #include <boost/optional.hpp>
 
 #include "mongo/base/init.h"
-#include "mongo/stdx/condition_variable.h"
-#include "mongo/stdx/mutex.h"
+#include "mongo/platform/condition_variable.h"
+#include "mongo/platform/mutex.h"
 #include "mongo/stdx/thread.h"
 #include "mongo/unittest/barrier.h"
 #include "mongo/unittest/death_test.h"
@@ -70,7 +70,7 @@ protected:
     }
 
     void blockingWork() {
-        stdx::unique_lock<stdx::mutex> lk(mutex);
+        stdx::unique_lock<Latch> lk(mutex);
         ++count1;
         cv1.notify_all();
         while (!flag2) {
@@ -78,7 +78,7 @@ protected:
         }
     }
 
-    stdx::mutex mutex;
+    Mutex mutex = MONGO_MAKE_LATCH("ThreadPoolTest::mutex");
     stdx::condition_variable cv1;
     stdx::condition_variable cv2;
     size_t count1 = 0U;
@@ -86,7 +86,7 @@ protected:
 
 private:
     void tearDown() override {
-        stdx::unique_lock<stdx::mutex> lk(mutex);
+        stdx::unique_lock<Latch> lk(mutex);
         flag2 = true;
         cv2.notify_all();
         lk.unlock();
@@ -103,7 +103,7 @@ TEST_F(ThreadPoolTest, MinPoolSize0) {
     auto& pool = makePool(options);
     pool.startup();
     ASSERT_EQ(0U, pool.getStats().numThreads);
-    stdx::unique_lock<stdx::mutex> lk(mutex);
+    stdx::unique_lock<Latch> lk(mutex);
     pool.schedule([this](auto status) {
         ASSERT_OK(status);
         blockingWork();
@@ -155,7 +155,7 @@ TEST_F(ThreadPoolTest, MaxPoolSize20MinPoolSize15) {
     options.maxIdleThreadAge = Milliseconds(100);
     auto& pool = makePool(options);
     pool.startup();
-    stdx::unique_lock<stdx::mutex> lk(mutex);
+    stdx::unique_lock<Latch> lk(mutex);
     for (size_t i = 0U; i < 30U; ++i) {
         pool.schedule([this, i](auto status) {
             ASSERT_OK(status) << i;
@@ -223,7 +223,7 @@ DEATH_TEST(ThreadPoolTest,
     // mutex-lock is blocked waiting for the mutex, so the independent thread must be blocked inside
     // of join(), until the pool thread finishes. At this point, if we destroy the pool, its
     // destructor should trigger a fatal error due to double-join.
-    stdx::mutex mutex;
+    auto mutex = MONGO_MAKE_LATCH();
     ThreadPool::Options options;
     options.minThreads = 2;
     options.poolName = "DoubleJoinPool";
@@ -233,10 +233,10 @@ DEATH_TEST(ThreadPoolTest,
     while (pool->getStats().numThreads < 2U) {
         sleepmillis(50);
     }
-    stdx::unique_lock<stdx::mutex> lk(mutex);
+    stdx::unique_lock<Latch> lk(mutex);
     pool->schedule([&mutex](auto status) {
         ASSERT_OK(status);
-        stdx::lock_guard<stdx::mutex> lk(mutex);
+        stdx::lock_guard<Latch> lk(mutex);
     });
     stdx::thread t([&pool] {
         pool->shutdown();
diff --git a/src/mongo/util/concurrency/thread_pool_test_common.cpp b/src/mongo/util/concurrency/thread_pool_test_common.cpp
index 5f32e649c65..33ff3cb303b 100644
--- a/src/mongo/util/concurrency/thread_pool_test_common.cpp
+++ b/src/mongo/util/concurrency/thread_pool_test_common.cpp
@@ -35,8 +35,8 @@
 
 #include <memory>
 
-#include "mongo/stdx/condition_variable.h"
-#include "mongo/stdx/mutex.h"
+#include "mongo/platform/condition_variable.h"
+#include "mongo/platform/mutex.h"
 #include "mongo/unittest/death_test.h"
 #include "mongo/util/assert_util.h"
 #include "mongo/util/concurrency/thread_pool_interface.h"
@@ -203,10 +203,10 @@ COMMON_THREAD_POOL_TEST(RepeatedScheduleDoesntSmashStack) {
     auto& pool = getThreadPool();
     std::function<void()> func;
     std::size_t n = 0;
-    stdx::mutex mutex;
+    auto mutex = MONGO_MAKE_LATCH();
     stdx::condition_variable condvar;
     func = [&pool, &n, &func, &condvar, &mutex, depth]() {
-        stdx::unique_lock<stdx::mutex> lk(mutex);
+        stdx::unique_lock<Latch> lk(mutex);
         if (n < depth) {
             n++;
             lk.unlock();
@@ -223,7 +223,7 @@ COMMON_THREAD_POOL_TEST(RepeatedScheduleDoesntSmashStack) {
     pool.startup();
     pool.join();
 
-    stdx::unique_lock<stdx::mutex> lk(mutex);
+    stdx::unique_lock<Latch> lk(mutex);
     condvar.wait(lk, [&n, depth] { return n == depth; });
 }
 
diff --git a/src/mongo/util/concurrency/ticketholder.cpp b/src/mongo/util/concurrency/ticketholder.cpp
index e30746807ae..a6abd154b2e 100644
--- a/src/mongo/util/concurrency/ticketholder.cpp
+++ b/src/mongo/util/concurrency/ticketholder.cpp
@@ -128,7 +128,7 @@ void TicketHolder::release() {
 }
 
 Status TicketHolder::resize(int newSize) {
-    stdx::lock_guard<stdx::mutex> lk(_resizeMutex);
+    stdx::lock_guard<Latch> lk(_resizeMutex);
 
     if (newSize < 5)
         return Status(ErrorCodes::BadValue,
@@ -174,12 +174,12 @@ TicketHolder::TicketHolder(int num) : _outof(num), _num(num) {}
 TicketHolder::~TicketHolder() = default;
 
 bool TicketHolder::tryAcquire() {
-    stdx::lock_guard<stdx::mutex> lk(_mutex);
+    stdx::lock_guard<Latch> lk(_mutex);
     return _tryAcquire();
 }
 
 void TicketHolder::waitForTicket(OperationContext* opCtx) {
-    stdx::unique_lock<stdx::mutex> lk(_mutex);
+    stdx::unique_lock<Latch> lk(_mutex);
 
     if (opCtx) {
         opCtx->waitForConditionOrInterrupt(_newTicket, lk, [this] { return _tryAcquire(); });
@@ -189,7 +189,7 @@ void TicketHolder::waitForTicket(OperationContext* opCtx) {
 }
 
 bool TicketHolder::waitForTicketUntil(OperationContext* opCtx, Date_t until) {
-    stdx::unique_lock<stdx::mutex> lk(_mutex);
+    stdx::unique_lock<Latch> lk(_mutex);
 
     if (opCtx) {
         return opCtx->waitForConditionOrInterruptUntil(
@@ -202,14 +202,14 @@ bool TicketHolder::waitForTicketUntil(OperationContext* opCtx, Date_t until) {
 
 void TicketHolder::release() {
     {
-        stdx::lock_guard<stdx::mutex> lk(_mutex);
+        stdx::lock_guard<Latch> lk(_mutex);
         _num++;
     }
     _newTicket.notify_one();
 }
 
 Status TicketHolder::resize(int newSize) {
-    stdx::lock_guard<stdx::mutex> lk(_mutex);
+    stdx::lock_guard<Latch> lk(_mutex);
 
     int used = _outof.load() - _num;
     if (used > newSize) {
diff --git a/src/mongo/util/concurrency/ticketholder.h b/src/mongo/util/concurrency/ticketholder.h
index 8ab3d4a39d9..d67e6bd04d1 100644
--- a/src/mongo/util/concurrency/ticketholder.h
+++ b/src/mongo/util/concurrency/ticketholder.h
@@ -33,8 +33,8 @@
 #endif
 
 #include "mongo/db/operation_context.h"
-#include "mongo/stdx/condition_variable.h"
-#include "mongo/stdx/mutex.h"
+#include "mongo/platform/condition_variable.h"
+#include "mongo/platform/mutex.h"
 #include "mongo/util/concurrency/mutex.h"
 #include "mongo/util/time_support.h"
 
@@ -87,13 +87,13 @@ private:
 
     // You can read _outof without a lock, but have to hold _resizeMutex to change.
     AtomicWord<int> _outof;
-    stdx::mutex _resizeMutex;
+    Mutex _resizeMutex = MONGO_MAKE_LATCH("TicketHolder::_resizeMutex");
 #else
     bool _tryAcquire();
 
     AtomicWord<int> _outof;
     int _num;
-    stdx::mutex _mutex;
+    Mutex _mutex = MONGO_MAKE_LATCH("TicketHolder::_mutex");
     stdx::condition_variable _newTicket;
 #endif
 };
diff --git a/src/mongo/util/concurrency/with_lock.h b/src/mongo/util/concurrency/with_lock.h
index d5c55a16cb3..9d7f24bed8e 100644
--- a/src/mongo/util/concurrency/with_lock.h
+++ b/src/mongo/util/concurrency/with_lock.h
@@ -29,7 +29,7 @@
 
 #pragma once
 
-#include "mongo/stdx/mutex.h"
+#include "mongo/platform/mutex.h"
 #include "mongo/util/assert_util.h"
 
 #include <utility>
@@ -56,7 +56,7 @@ namespace mongo {
  *
  * A call to such a function looks like this:
  *
- *     stdx::lock_guard<stdx::mutex> lk(_mutex);
+ *     stdx::lock_guard<Latch> lk(_mutex);
  *     _clobber(lk, opCtx);  // instead of _clobber_inlock(opCtx)
  *
  * Note that the formal argument need not (and should not) be named unless it is needed to pass
@@ -68,11 +68,11 @@ namespace mongo {
  *
  */
 struct WithLock {
-    template <typename Mutex>
-    WithLock(stdx::lock_guard<Mutex> const&) noexcept {}
+    template <typename LatchT>
+    WithLock(stdx::lock_guard<LatchT> const&) noexcept {}
 
-    template <typename Mutex>
-    WithLock(stdx::unique_lock<Mutex> const& lock) noexcept {
+    template <typename LatchT>
+    WithLock(stdx::unique_lock<LatchT> const& lock) noexcept {
         invariant(lock.owns_lock());
     }
 
@@ -88,9 +88,9 @@ struct WithLock {
 
     // No moving a lock_guard<> or unique_lock<> in.
     template <typename Mutex>
-    WithLock(stdx::lock_guard<Mutex>&&) = delete;
+    WithLock(stdx::lock_guard<Latch>&&) = delete;
     template <typename Mutex>
-    WithLock(stdx::unique_lock<Mutex>&&) = delete;
+    WithLock(stdx::unique_lock<Latch>&&) = delete;
 
     /*
      * Produces a WithLock without benefit of any actual lock, for use in cases where a lock is not
diff --git a/src/mongo/util/concurrency/with_lock_test.cpp b/src/mongo/util/concurrency/with_lock_test.cpp
index 0bfe2b3829e..5724f899471 100644
--- a/src/mongo/util/concurrency/with_lock_test.cpp
+++ b/src/mongo/util/concurrency/with_lock_test.cpp
@@ -31,7 +31,7 @@
 
 #include "mongo/platform/basic.h"
 
-#include "mongo/stdx/mutex.h"
+#include "mongo/platform/mutex.h"
 #include "mongo/unittest/unittest.h"
 #include "mongo/util/concurrency/with_lock.h"
 #include "mongo/util/log.h"
@@ -46,15 +46,15 @@ struct Beerp {
     explicit Beerp(int i) {
         _blerp(WithLock::withoutLock(), i);
     }
-    Beerp(stdx::lock_guard<stdx::mutex> const& lk, int i) {
+    Beerp(stdx::lock_guard<Latch> const& lk, int i) {
         _blerp(lk, i);
     }
     int bleep(char n) {
-        stdx::lock_guard<stdx::mutex> lk(_m);
+        stdx::lock_guard<Latch> lk(_m);
         return _bloop(lk, n - '0');
     }
     int bleep(int i) {
-        stdx::unique_lock<stdx::mutex> lk(_m);
+        stdx::unique_lock<Latch> lk(_m);
         return _bloop(lk, i);
     }
 
@@ -66,7 +66,7 @@ private:
         log() << i << " bleep" << (i == 1 ? "\n" : "s\n");
         return i;
     }
-    stdx::mutex _m;
+    Mutex _m = MONGO_MAKE_LATCH("Beerp::_m");
 };
 
 TEST(WithLockTest, OverloadSet) {
@@ -74,8 +74,8 @@ TEST(WithLockTest, OverloadSet) {
     ASSERT_EQ(1, b.bleep('1'));
     ASSERT_EQ(2, b.bleep(2));
 
-    stdx::mutex m;
-    stdx::lock_guard<stdx::mutex> lk(m);
+    auto m = MONGO_MAKE_LATCH();
+    stdx::lock_guard<Latch> lk(m);
     Beerp(lk, 3);
 }