SERVER-32682 Change GlobalLock timeout type to Milliseconds

3 files changed, 55 insertions, 55 deletions

diff --git a/src/mongo/db/concurrency/d_concurrency.cpp b/src/mongo/db/concurrency/d_concurrency.cpp
index 7ff9c8b861f..5eda7623996 100644
--- a/src/mongo/db/concurrency/d_concurrency.cpp
+++ b/src/mongo/db/concurrency/d_concurrency.cpp
@@ -136,14 +136,14 @@ bool Lock::ResourceMutex::isAtLeastReadLocked(Locker* locker) {
     return locker->isLockHeldForMode(_rid, MODE_IS);
 }
 
-Lock::GlobalLock::GlobalLock(OperationContext* opCtx, LockMode lockMode, unsigned timeoutMs)
+Lock::GlobalLock::GlobalLock(OperationContext* opCtx, LockMode lockMode, Milliseconds timeoutMs)
     : GlobalLock(opCtx, lockMode, timeoutMs, EnqueueOnly()) {
     waitForLock(timeoutMs);
 }
 
 Lock::GlobalLock::GlobalLock(OperationContext* opCtx,
                              LockMode lockMode,
-                             unsigned timeoutMs,
+                             Milliseconds timeoutMs,
                              EnqueueOnly enqueueOnly)
     : _opCtx(opCtx),
       _result(LOCK_INVALID),
@@ -161,17 +161,17 @@ Lock::GlobalLock::GlobalLock(GlobalLock&& otherLock)
     otherLock._result = LOCK_INVALID;
 }
 
-void Lock::GlobalLock::_enqueue(LockMode lockMode, unsigned timeoutMs) {
+void Lock::GlobalLock::_enqueue(LockMode lockMode, Milliseconds timeoutMs) {
     if (_opCtx->lockState()->shouldConflictWithSecondaryBatchApplication()) {
         _pbwm.lock(MODE_IS);
     }
 
-    _result = _opCtx->lockState()->lockGlobalBegin(lockMode, Milliseconds(timeoutMs));
+    _result = _opCtx->lockState()->lockGlobalBegin(lockMode, timeoutMs);
 }
 
-void Lock::GlobalLock::waitForLock(unsigned timeoutMs) {
+void Lock::GlobalLock::waitForLock(Milliseconds timeoutMs) {
     if (_result == LOCK_WAITING) {
-        _result = _opCtx->lockState()->lockGlobalComplete(Milliseconds(timeoutMs));
+        _result = _opCtx->lockState()->lockGlobalComplete(timeoutMs);
     }
 
     if (_result != LOCK_OK && _opCtx->lockState()->shouldConflictWithSecondaryBatchApplication()) {
@@ -194,7 +194,7 @@ Lock::DBLock::DBLock(OperationContext* opCtx, StringData db, LockMode mode)
     : _id(RESOURCE_DATABASE, db),
       _opCtx(opCtx),
       _mode(mode),
-      _globalLock(opCtx, isSharedLockMode(_mode) ? MODE_IS : MODE_IX, UINT_MAX) {
+      _globalLock(opCtx, isSharedLockMode(_mode) ? MODE_IS : MODE_IX, Milliseconds::max()) {
     massert(28539, "need a valid database name", !db.empty() && nsIsDbOnly(db));
 
     // Need to acquire the flush lock
diff --git a/src/mongo/db/concurrency/d_concurrency.h b/src/mongo/db/concurrency/d_concurrency.h
index 3bcad53b749..0d942cc7705 100644
--- a/src/mongo/db/concurrency/d_concurrency.h
+++ b/src/mongo/db/concurrency/d_concurrency.h
@@ -181,7 +181,7 @@ public:
     public:
         class EnqueueOnly {};
 
-        GlobalLock(OperationContext* opCtx, LockMode lockMode, unsigned timeoutMs);
+        GlobalLock(OperationContext* opCtx, LockMode lockMode, Milliseconds timeoutMs);
         GlobalLock(GlobalLock&&);
 
         /**
@@ -193,7 +193,7 @@ public:
          */
         GlobalLock(OperationContext* opCtx,
                    LockMode lockMode,
-                   unsigned timeoutMs,
+                   Milliseconds timeoutMs,
                    EnqueueOnly enqueueOnly);
 
         ~GlobalLock() {
@@ -209,14 +209,14 @@ public:
          * Waits for lock to be granted. Sets that the global lock was taken on the
          * GlobalLockAcquisitionTracker.
          */
-        void waitForLock(unsigned timeoutMs);
+        void waitForLock(Milliseconds timeoutMs);
 
         bool isLocked() const {
             return _result == LOCK_OK;
         }
 
     private:
-        void _enqueue(LockMode lockMode, unsigned timeoutMs);
+        void _enqueue(LockMode lockMode, Milliseconds timeoutMs);
         void _unlock();
 
         OperationContext* const _opCtx;
@@ -234,7 +234,7 @@ public:
      */
     class GlobalWrite : public GlobalLock {
     public:
-        explicit GlobalWrite(OperationContext* opCtx, unsigned timeoutMs = UINT_MAX)
+        explicit GlobalWrite(OperationContext* opCtx, Milliseconds timeoutMs = Milliseconds::max())
             : GlobalLock(opCtx, MODE_X, timeoutMs) {
             if (isLocked()) {
                 opCtx->lockState()->lockMMAPV1Flush();
@@ -251,7 +251,7 @@ public:
      */
     class GlobalRead : public GlobalLock {
     public:
-        explicit GlobalRead(OperationContext* opCtx, unsigned timeoutMs = UINT_MAX)
+        explicit GlobalRead(OperationContext* opCtx, Milliseconds timeoutMs = Milliseconds::max())
             : GlobalLock(opCtx, MODE_S, timeoutMs) {
             if (isLocked()) {
                 opCtx->lockState()->lockMMAPV1Flush();
diff --git a/src/mongo/db/concurrency/d_concurrency_test.cpp b/src/mongo/db/concurrency/d_concurrency_test.cpp
index 2b62a387ce7..2d437ac5628 100644
--- a/src/mongo/db/concurrency/d_concurrency_test.cpp
+++ b/src/mongo/db/concurrency/d_concurrency_test.cpp
@@ -468,19 +468,19 @@ TEST_F(DConcurrencyTestFixture,
 TEST_F(DConcurrencyTestFixture, GlobalLockS_Timeout) {
     auto clients = makeKClientsWithLockers<MMAPV1LockerImpl>(2);
 
-    Lock::GlobalLock globalWrite(clients[0].second.get(), MODE_X, 0);
+    Lock::GlobalLock globalWrite(clients[0].second.get(), MODE_X, Milliseconds(0));
     ASSERT(globalWrite.isLocked());
 
-    Lock::GlobalLock globalReadTry(clients[1].second.get(), MODE_S, 1);
+    Lock::GlobalLock globalReadTry(clients[1].second.get(), MODE_S, Milliseconds(1));
     ASSERT(!globalReadTry.isLocked());
 }
 
 TEST_F(DConcurrencyTestFixture, GlobalLockX_Timeout) {
     auto clients = makeKClientsWithLockers<MMAPV1LockerImpl>(2);
-    Lock::GlobalLock globalWrite(clients[0].second.get(), MODE_X, 0);
+    Lock::GlobalLock globalWrite(clients[0].second.get(), MODE_X, Milliseconds(0));
     ASSERT(globalWrite.isLocked());
 
-    Lock::GlobalLock globalWriteTry(clients[1].second.get(), MODE_X, 1);
+    Lock::GlobalLock globalWriteTry(clients[1].second.get(), MODE_X, Milliseconds(1));
     ASSERT(!globalWriteTry.isLocked());
 }
 
@@ -490,7 +490,7 @@ TEST_F(DConcurrencyTestFixture, GlobalLockXSetsGlobalLockTakenOnOperationContext
     ASSERT_FALSE(GlobalLockAcquisitionTracker::get(opCtx).getGlobalExclusiveLockTaken());
 
     {
-        Lock::GlobalLock globalWrite(opCtx, MODE_X, 0);
+        Lock::GlobalLock globalWrite(opCtx, MODE_X, Milliseconds(0));
         ASSERT(globalWrite.isLocked());
     }
     ASSERT_TRUE(GlobalLockAcquisitionTracker::get(opCtx).getGlobalExclusiveLockTaken());
@@ -501,7 +501,7 @@ TEST_F(DConcurrencyTestFixture, GlobalLockIXSetsGlobalLockTakenOnOperationContex
     auto opCtx = clients[0].second.get();
     ASSERT_FALSE(GlobalLockAcquisitionTracker::get(opCtx).getGlobalExclusiveLockTaken());
     {
-        Lock::GlobalLock globalWrite(opCtx, MODE_IX, 0);
+        Lock::GlobalLock globalWrite(opCtx, MODE_IX, Milliseconds(0));
         ASSERT(globalWrite.isLocked());
     }
     ASSERT_TRUE(GlobalLockAcquisitionTracker::get(opCtx).getGlobalExclusiveLockTaken());
@@ -512,7 +512,7 @@ TEST_F(DConcurrencyTestFixture, GlobalLockSDoesNotSetGlobalLockTakenOnOperationC
     auto opCtx = clients[0].second.get();
     ASSERT_FALSE(GlobalLockAcquisitionTracker::get(opCtx).getGlobalExclusiveLockTaken());
     {
-        Lock::GlobalLock globalRead(opCtx, MODE_S, 0);
+        Lock::GlobalLock globalRead(opCtx, MODE_S, Milliseconds(0));
         ASSERT(globalRead.isLocked());
     }
     ASSERT_FALSE(GlobalLockAcquisitionTracker::get(opCtx).getGlobalExclusiveLockTaken());
@@ -523,7 +523,7 @@ TEST_F(DConcurrencyTestFixture, GlobalLockISDoesNotSetGlobalLockTakenOnOperation
     auto opCtx = clients[0].second.get();
     ASSERT_FALSE(GlobalLockAcquisitionTracker::get(opCtx).getGlobalExclusiveLockTaken());
     {
-        Lock::GlobalLock globalRead(opCtx, MODE_IS, 0);
+        Lock::GlobalLock globalRead(opCtx, MODE_IS, Milliseconds(0));
         ASSERT(globalRead.isLocked());
     }
     ASSERT_FALSE(GlobalLockAcquisitionTracker::get(opCtx).getGlobalExclusiveLockTaken());
@@ -551,13 +551,13 @@ TEST_F(DConcurrencyTestFixture, GlobalLockXDoesNotSetGlobalLockTakenWhenLockAcqu
     auto clients = makeKClientsWithLockers<MMAPV1LockerImpl>(2);
 
     // Take a global lock so that the next one times out.
-    Lock::GlobalLock globalWrite0(clients[0].second.get(), MODE_X, 0);
+    Lock::GlobalLock globalWrite0(clients[0].second.get(), MODE_X, Milliseconds(0));
     ASSERT(globalWrite0.isLocked());
 
     auto opCtx = clients[1].second.get();
     ASSERT_FALSE(GlobalLockAcquisitionTracker::get(opCtx).getGlobalExclusiveLockTaken());
     {
-        Lock::GlobalLock globalWrite1(opCtx, MODE_X, 1);
+        Lock::GlobalLock globalWrite1(opCtx, MODE_X, Milliseconds(1));
         ASSERT_FALSE(globalWrite1.isLocked());
     }
     ASSERT_FALSE(GlobalLockAcquisitionTracker::get(opCtx).getGlobalExclusiveLockTaken());
@@ -567,7 +567,7 @@ TEST_F(DConcurrencyTestFixture, GlobalLockS_NoTimeoutDueToGlobalLockS) {
     auto clients = makeKClientsWithLockers<MMAPV1LockerImpl>(2);
 
     Lock::GlobalRead globalRead(clients[0].second.get());
-    Lock::GlobalLock globalReadTry(clients[1].second.get(), MODE_S, 1);
+    Lock::GlobalLock globalReadTry(clients[1].second.get(), MODE_S, Milliseconds(1));
 
     ASSERT(globalReadTry.isLocked());
 }
@@ -576,7 +576,7 @@ TEST_F(DConcurrencyTestFixture, GlobalLockX_TimeoutDueToGlobalLockS) {
     auto clients = makeKClientsWithLockers<MMAPV1LockerImpl>(2);
 
     Lock::GlobalRead globalRead(clients[0].second.get());
-    Lock::GlobalLock globalWriteTry(clients[1].second.get(), MODE_X, 1);
+    Lock::GlobalLock globalWriteTry(clients[1].second.get(), MODE_X, Milliseconds(1));
 
     ASSERT(!globalWriteTry.isLocked());
 }
@@ -585,7 +585,7 @@ TEST_F(DConcurrencyTestFixture, GlobalLockS_TimeoutDueToGlobalLockX) {
     auto clients = makeKClientsWithLockers<MMAPV1LockerImpl>(2);
 
     Lock::GlobalWrite globalWrite(clients[0].second.get());
-    Lock::GlobalLock globalReadTry(clients[1].second.get(), MODE_S, 1);
+    Lock::GlobalLock globalReadTry(clients[1].second.get(), MODE_S, Milliseconds(1));
 
     ASSERT(!globalReadTry.isLocked());
 }
@@ -594,7 +594,7 @@ TEST_F(DConcurrencyTestFixture, GlobalLockX_TimeoutDueToGlobalLockX) {
     auto clients = makeKClientsWithLockers<MMAPV1LockerImpl>(2);
 
     Lock::GlobalWrite globalWrite(clients[0].second.get());
-    Lock::GlobalLock globalWriteTry(clients[1].second.get(), MODE_X, 1);
+    Lock::GlobalLock globalWriteTry(clients[1].second.get(), MODE_X, Milliseconds(1));
 
     ASSERT(!globalWriteTry.isLocked());
 }
@@ -978,11 +978,11 @@ TEST_F(DConcurrencyTestFixture, Throttling) {
     bool overlongWait;
     int tries = 0;
     const int maxTries = 15;
-    const int timeoutMillis = 42;
+    const Milliseconds timeoutMillis = Milliseconds(42);
 
     do {
         // Test that throttling will correctly handle timeouts.
-        Lock::GlobalRead R1(opctx1, 0);
+        Lock::GlobalRead R1(opctx1, Milliseconds(0));
         ASSERT(R1.isLocked());
 
         Date_t t1 = Date_t::now();
@@ -993,7 +993,7 @@ TEST_F(DConcurrencyTestFixture, Throttling) {
         Date_t t2 = Date_t::now();
 
         // Test that the timeout did result in at least the requested wait.
-        ASSERT_GTE(t2 - t1, Milliseconds(timeoutMillis));
+        ASSERT_GTE(t2 - t1, timeoutMillis);
 
         // Timeouts should be reasonably immediate. In maxTries attempts at least one test should be
         // able to complete within a second, as the theoretical test duration is less than 50 ms.
@@ -1011,14 +1011,14 @@ TEST_F(DConcurrencyTestFixture, CompatibleFirstWithSXIS) {
     // Build a queue of MODE_S <- MODE_X <- MODE_IS, with MODE_S granted.
     Lock::GlobalRead lockS(opctx1);
     ASSERT(lockS.isLocked());
-    Lock::GlobalLock lockX(opctx2, MODE_X, UINT_MAX, Lock::GlobalLock::EnqueueOnly());
+    Lock::GlobalLock lockX(opctx2, MODE_X, Milliseconds::max(), Lock::GlobalLock::EnqueueOnly());
     ASSERT(!lockX.isLocked());
 
     // A MODE_IS should be granted due to compatibleFirst policy.
-    Lock::GlobalLock lockIS(opctx3, MODE_IS, 0);
+    Lock::GlobalLock lockIS(opctx3, MODE_IS, Milliseconds(0));
     ASSERT(lockIS.isLocked());
 
-    lockX.waitForLock(0);
+    lockX.waitForLock(Milliseconds(0));
     ASSERT(!lockX.isLocked());
 }
 
@@ -1035,25 +1035,25 @@ TEST_F(DConcurrencyTestFixture, CompatibleFirstWithXSIXIS) {
     lockX.emplace(opctx1);
     ASSERT(lockX->isLocked());
     boost::optional<Lock::GlobalLock> lockS;
-    lockS.emplace(opctx2, MODE_S, UINT_MAX, Lock::GlobalLock::EnqueueOnly());
+    lockS.emplace(opctx2, MODE_S, Milliseconds::max(), Lock::GlobalLock::EnqueueOnly());
     ASSERT(!lockS->isLocked());
-    Lock::GlobalLock lockIX(opctx3, MODE_IX, UINT_MAX, Lock::GlobalLock::EnqueueOnly());
+    Lock::GlobalLock lockIX(opctx3, MODE_IX, Milliseconds::max(), Lock::GlobalLock::EnqueueOnly());
     ASSERT(!lockIX.isLocked());
-    Lock::GlobalLock lockIS(opctx4, MODE_IS, UINT_MAX, Lock::GlobalLock::EnqueueOnly());
+    Lock::GlobalLock lockIS(opctx4, MODE_IS, Milliseconds::max(), Lock::GlobalLock::EnqueueOnly());
     ASSERT(!lockIS.isLocked());
 
 
     // Now release the MODE_X and ensure that MODE_S will switch policy to compatibleFirst
     lockX.reset();
-    lockS->waitForLock(0);
+    lockS->waitForLock(Milliseconds(0));
     ASSERT(lockS->isLocked());
     ASSERT(!lockIX.isLocked());
-    lockIS.waitForLock(0);
+    lockIS.waitForLock(Milliseconds(0));
     ASSERT(lockIS.isLocked());
 
     // Now release the MODE_S and ensure that MODE_IX gets locked.
     lockS.reset();
-    lockIX.waitForLock(0);
+    lockIX.waitForLock(Milliseconds(0));
     ASSERT(lockIX.isLocked());
 }
 
@@ -1072,32 +1072,32 @@ TEST_F(DConcurrencyTestFixture, CompatibleFirstWithXSXIXIS) {
     ASSERT(lockXgranted->isLocked());
 
     boost::optional<Lock::GlobalLock> lockX;
-    lockX.emplace(opctx3, MODE_X, UINT_MAX, Lock::GlobalLock::EnqueueOnly());
+    lockX.emplace(opctx3, MODE_X, Milliseconds::max(), Lock::GlobalLock::EnqueueOnly());
     ASSERT(!lockX->isLocked());
 
     // Now request MODE_S: it will be first in the pending list due to EnqueueAtFront policy.
     boost::optional<Lock::GlobalLock> lockS;
-    lockS.emplace(opctx2, MODE_S, UINT_MAX, Lock::GlobalLock::EnqueueOnly());
+    lockS.emplace(opctx2, MODE_S, Milliseconds::max(), Lock::GlobalLock::EnqueueOnly());
     ASSERT(!lockS->isLocked());
 
-    Lock::GlobalLock lockIX(opctx4, MODE_IX, UINT_MAX, Lock::GlobalLock::EnqueueOnly());
+    Lock::GlobalLock lockIX(opctx4, MODE_IX, Milliseconds::max(), Lock::GlobalLock::EnqueueOnly());
     ASSERT(!lockIX.isLocked());
-    Lock::GlobalLock lockIS(opctx5, MODE_IS, UINT_MAX, Lock::GlobalLock::EnqueueOnly());
+    Lock::GlobalLock lockIS(opctx5, MODE_IS, Milliseconds::max(), Lock::GlobalLock::EnqueueOnly());
     ASSERT(!lockIS.isLocked());
 
 
     // Now release the granted MODE_X and ensure that MODE_S will switch policy to compatibleFirst,
     // not locking the MODE_X or MODE_IX, but instead granting the final MODE_IS.
     lockXgranted.reset();
-    lockS->waitForLock(0);
+    lockS->waitForLock(Milliseconds(0));
     ASSERT(lockS->isLocked());
 
-    lockX->waitForLock(0);
+    lockX->waitForLock(Milliseconds(0));
     ASSERT(!lockX->isLocked());
-    lockIX.waitForLock(0);
+    lockIX.waitForLock(Milliseconds(0));
     ASSERT(!lockIX.isLocked());
 
-    lockIS.waitForLock(0);
+    lockIS.waitForLock(Milliseconds(0));
     ASSERT(lockIS.isLocked());
 }
 
@@ -1131,7 +1131,7 @@ TEST_F(DConcurrencyTestFixture, CompatibleFirstStress) {
         OperationContext* opCtx = clientOpctxPairs[0].second.get();
         for (int iters = 0; (t.micros() < endTime); iters++) {
             busyWait(0, iters % 20);
-            Lock::GlobalRead readLock(opCtx, iters % 2);
+            Lock::GlobalRead readLock(opCtx, Milliseconds(iters % 2));
             if (!readLock.isLocked()) {
                 timeoutCount[0]++;
                 continue;
@@ -1163,27 +1163,27 @@ TEST_F(DConcurrencyTestFixture, CompatibleFirstStress) {
                         auto interval = readOnlyInterval.load();
                         lock.emplace(opCtx,
                                      iters % 20 ? MODE_IS : MODE_S,
-                                     0,
+                                     Milliseconds(0),
                                      Lock::GlobalLock::EnqueueOnly());
                         // If thread 0 is holding the MODE_S lock while we tried to acquire a
                         // MODE_IS or MODE_S lock, the CompatibleFirst policy guarantees success.
                         auto newInterval = readOnlyInterval.load();
                         invariant(!interval || interval != newInterval || lock->isLocked());
-                        lock->waitForLock(0);
+                        lock->waitForLock(Milliseconds(0));
                         break;
                     }
                     case 5:
                         busyWait(threadId, iters % 150);
-                        lock.emplace(opCtx, MODE_X, iters % 2);
+                        lock.emplace(opCtx, MODE_X, Milliseconds(iters % 2));
                         busyWait(threadId, iters % 10);
                         break;
                     case 6:
-                        lock.emplace(opCtx, iters % 25 ? MODE_IX : MODE_S, iters % 2);
+                        lock.emplace(opCtx, iters % 25 ? MODE_IX : MODE_S, Milliseconds(iters % 2));
                         busyWait(threadId, iters % 100);
                         break;
                     case 7:
                         busyWait(threadId, iters % 100);
-                        lock.emplace(opCtx, iters % 20 ? MODE_IS : MODE_X, 0);
+                        lock.emplace(opCtx, iters % 20 ? MODE_IS : MODE_X, Milliseconds(0));
                         break;
                     default:
                         MONGO_UNREACHABLE;
@@ -1294,12 +1294,12 @@ TEST_F(DConcurrencyTestFixture, TestGlobalLockAbandonSnapshot) {
                            OperationContext::RecoveryUnitState::kActiveUnitOfWork);
 
     {
-        Lock::GlobalLock gw1(opCtx, MODE_IS, 0);
+        Lock::GlobalLock gw1(opCtx, MODE_IS, Milliseconds(0));
         ASSERT(gw1.isLocked());
         ASSERT(recovUnitBorrowed->activeTransaction);
 
         {
-            Lock::GlobalLock gw2(opCtx, MODE_S, 0);
+            Lock::GlobalLock gw2(opCtx, MODE_S, Milliseconds(0));
             ASSERT(gw2.isLocked());
             ASSERT(recovUnitBorrowed->activeTransaction);
         }