diff options
29 files changed, 124 insertions, 116 deletions
diff --git a/src/mongo/db/catalog/catalog_control_test.cpp b/src/mongo/db/catalog/catalog_control_test.cpp index 59afeb15a25..827afdaed4b 100644 --- a/src/mongo/db/catalog/catalog_control_test.cpp +++ b/src/mongo/db/catalog/catalog_control_test.cpp @@ -81,7 +81,7 @@ public: return false; } void clearDropPendingState() final {} - Timestamp getAllCommittedTimestamp() const final { + Timestamp getAllDurableTimestamp() const final { return {}; } Timestamp getOldestOpenReadTimestamp() const final { diff --git a/src/mongo/db/commands/dbhash.cpp b/src/mongo/db/commands/dbhash.cpp index 473b323f6b5..5153192234d 100644 --- a/src/mongo/db/commands/dbhash.cpp +++ b/src/mongo/db/commands/dbhash.cpp @@ -166,16 +166,16 @@ public: // down. This isn't an actual concern because the testing infrastructure won't use the // $_internalReadAtClusterTime option in any test suite where clean shutdown is expected // to occur concurrently with tests running. - auto allCommittedTime = storageEngine->getAllCommittedTimestamp(); - invariant(!allCommittedTime.isNull()); + auto allDurableTime = storageEngine->getAllDurableTimestamp(); + invariant(!allDurableTime.isNull()); uassert(ErrorCodes::InvalidOptions, str::stream() << "$_internalReadAtClusterTime value must not be greater" - " than the all-committed timestamp. Requested clusterTime: " + " than the all_durable timestamp. Requested clusterTime: " << targetClusterTime.toString() - << "; all-committed timestamp: " - << allCommittedTime.toString(), - allCommittedTime >= targetClusterTime); + << "; all_durable timestamp: " + << allDurableTime.toString(), + allDurableTime >= targetClusterTime); // The $_internalReadAtClusterTime option causes any storage-layer cursors created // during plan execution to read from a consistent snapshot of data at the supplied diff --git a/src/mongo/db/commands/find_cmd.cpp b/src/mongo/db/commands/find_cmd.cpp index 43413cda5f1..52250811dbd 100644 --- a/src/mongo/db/commands/find_cmd.cpp +++ b/src/mongo/db/commands/find_cmd.cpp @@ -338,17 +338,17 @@ public: // shutting down. This isn't an actual concern because the testing infrastructure // won't use the $_internalReadAtClusterTime option in any test suite where clean // shutdown is expected to occur concurrently with tests running. - auto allCommittedTime = storageEngine->getAllCommittedTimestamp(); - invariant(!allCommittedTime.isNull()); + auto allDurableTime = storageEngine->getAllDurableTimestamp(); + invariant(!allDurableTime.isNull()); uassert(ErrorCodes::InvalidOptions, str::stream() << "$_internalReadAtClusterTime value must not be greater" - " than the all-committed timestamp. Requested" + " than the all_durable timestamp. Requested" " clusterTime: " << targetClusterTime->toString() - << "; all-committed timestamp: " - << allCommittedTime.toString(), - allCommittedTime >= targetClusterTime); + << "; all_durable timestamp: " + << allDurableTime.toString(), + allDurableTime >= targetClusterTime); // The $_internalReadAtClusterTime option causes any storage-layer cursors created // during plan execution to read from a consistent snapshot of data at the supplied diff --git a/src/mongo/db/repl/initial_syncer.cpp b/src/mongo/db/repl/initial_syncer.cpp index 6ecbbed4437..1b8bd562bc4 100644 --- a/src/mongo/db/repl/initial_syncer.cpp +++ b/src/mongo/db/repl/initial_syncer.cpp @@ -515,7 +515,7 @@ void InitialSyncer::_startInitialSyncAttemptCallback( auto storageEngine = getGlobalServiceContext()->getStorageEngine(); if (storageEngine) { // Set the oldestTimestamp to one because WiredTiger does not allow us to set it to zero - // since that would also set the all committed point to zero. We specifically don't set + // since that would also set the all_durable point to zero. We specifically don't set // the stable timestamp here because that will trigger taking a first stable checkpoint even // though the initialDataTimestamp is still set to kAllowUnstableCheckpointsSentinel. storageEngine->setOldestTimestamp(kTimestampOne); @@ -803,7 +803,7 @@ void InitialSyncer::_lastOplogEntryFetcherCallbackForBeginApplyingTimestamp( auto filterBob = BSONObjBuilder(queryBob.subobjStart("filter")); filterBob.append("_id", FeatureCompatibilityVersionParser::kParameterName); filterBob.done(); - // As part of reading the FCV, we ensure the source node "all committed" timestamp has advanced + // As part of reading the FCV, we ensure the source node's all_durable timestamp has advanced // to at least the timestamp of the last optime that we found in the lastOplogEntryFetcher. // When document locking is used, there could be oplog "holes" which would result in // inconsistent initial sync data if we didn't do this. diff --git a/src/mongo/db/repl/replication_coordinator_impl.cpp b/src/mongo/db/repl/replication_coordinator_impl.cpp index 99bacd646cb..0e33068b3cf 100644 --- a/src/mongo/db/repl/replication_coordinator_impl.cpp +++ b/src/mongo/db/repl/replication_coordinator_impl.cpp @@ -3462,26 +3462,26 @@ boost::optional<OpTimeAndWallTime> ReplicationCoordinatorImpl::_chooseStableOpTi if (_readWriteAbility->canAcceptNonLocalWrites(lk) && _storage->supportsDocLocking(_service)) { // If the storage engine supports document level locking, then it is possible for oplog // writes to commit out of order. In that case, we don't want to set the stable timestamp - // ahead of the all committed timestamp. This is not a problem for oplog application - // because we only set lastApplied between batches when the all committed timestamp cannot - // be behind. During oplog application the all committed timestamp can jump around since + // ahead of the all_durable timestamp. This is not a problem for oplog application + // because we only set lastApplied between batches when the all_durable timestamp cannot + // be behind. During oplog application the all_durable timestamp can jump around since // we first write oplog entries to the oplog and then go back and apply them. // // We must construct an upper bound for the stable optime candidates such that the upper // bound is at most 'maximumStableOpTime' and any candidate with a timestamp higher than the - // all committed is greater than the upper bound. If the timestamp of 'maximumStableOpTime' - // is <= the all committed, then we use 'maximumStableOpTime'. Otherwise, we construct an - // optime using the all committed and the term of 'maximumStableOpTime'. We must argue that - // there are no stable optime candidates with a timestamp greater than the all committed and + // all_durable is greater than the upper bound. If the timestamp of 'maximumStableOpTime' + // is <= the all_durable, then we use 'maximumStableOpTime'. Otherwise, we construct an + // optime using the all_durable and the term of 'maximumStableOpTime'. We must argue that + // there are no stable optime candidates with a timestamp greater than the all_durable and // a term less than that of 'maximumStableOpTime'. Suppose there were. The - // 'maximumStableOpTime' is either the commit point or the lastApplied, so the all committed + // 'maximumStableOpTime' is either the commit point or the lastApplied, so the all_durable // can only be behind 'maximumStableOpTime' on a primary. If there is a candidate with a - // higher timestamp than the all committed but a lower term than 'maximumStableOpTime', then - // the all committed corresponds to a write in an earlier term than the current one. But + // higher timestamp than the all_durable but a lower term than 'maximumStableOpTime', then + // the all_durable corresponds to a write in an earlier term than the current one. But // this is not possible on a primary, since on step-up, the primary storage commits a 'new // primary' oplog entry in the new term before accepting any new writes, so the all - // committed must be in the current term. - maximumStableTimestamp = std::min(_storage->getAllCommittedTimestamp(_service), + // durable must be in the current term. + maximumStableTimestamp = std::min(_storage->getAllDurableTimestamp(_service), maximumStableOpTime.opTime.getTimestamp()); } diff --git a/src/mongo/db/repl/replication_coordinator_impl_test.cpp b/src/mongo/db/repl/replication_coordinator_impl_test.cpp index 4efee18a386..f355d04bba0 100644 --- a/src/mongo/db/repl/replication_coordinator_impl_test.cpp +++ b/src/mongo/db/repl/replication_coordinator_impl_test.cpp @@ -4260,7 +4260,7 @@ TEST_F(StableOpTimeTest, SetMyLastAppliedSetsStableOpTimeForStorage) { ASSERT_EQUALS(Timestamp::min(), getStorageInterface()->getStableTimestamp()); ASSERT_OK(getReplCoord()->setFollowerMode(MemberState::RS_SECONDARY)); - getStorageInterface()->allCommittedTimestamp = Timestamp(1, 1); + getStorageInterface()->allDurableTimestamp = Timestamp(1, 1); replCoordSetMyLastAppliedOpTime(OpTimeWithTermOne(1, 1), Date_t() + Seconds(100)); replCoordSetMyLastDurableOpTime(OpTimeWithTermOne(1, 1), Date_t() + Seconds(100)); simulateSuccessfulV1Election(); @@ -4274,7 +4274,7 @@ TEST_F(StableOpTimeTest, SetMyLastAppliedSetsStableOpTimeForStorage) { stableTimestamp = getStorageInterface()->getStableTimestamp(); ASSERT_EQUALS(Timestamp(1, 1), getStorageInterface()->getStableTimestamp()); - getStorageInterface()->allCommittedTimestamp = Timestamp(3, 1); + getStorageInterface()->allDurableTimestamp = Timestamp(3, 1); // Check that the stable timestamp is updated for the storage engine when we set the applied // optime. @@ -4329,7 +4329,7 @@ TEST_F(StableOpTimeTest, SetMyLastAppliedSetsStableOpTimeForStorageDisableMajori // Check that the stable timestamp is updated for the storage engine when we set the applied // optime, even though the last committed optime is unset. - getStorageInterface()->allCommittedTimestamp = Timestamp(1, 1); + getStorageInterface()->allDurableTimestamp = Timestamp(1, 1); replCoordSetMyLastAppliedOpTime(OpTime({1, 1}, 1), Date_t() + Seconds(100)); ASSERT_EQUALS(Timestamp(1, 1), getStorageInterface()->getStableTimestamp()); } @@ -4366,7 +4366,7 @@ TEST_F(StableOpTimeTest, AdvanceCommitPointSetsStableOpTimeForStorage) { long long term = 2; getStorageInterface()->supportsDocLockingBool = true; - getStorageInterface()->allCommittedTimestamp = Timestamp(2, 1); + getStorageInterface()->allDurableTimestamp = Timestamp(2, 1); // Add three stable optime candidates. replCoordSetMyLastAppliedOpTime(OpTime({2, 1}, term), Date_t() + Seconds(1)); @@ -4387,7 +4387,7 @@ TEST_F(StableOpTimeTest, AdvanceCommitPointSetsStableOpTimeForStorage) { stableTimestamp = getStorageInterface()->getStableTimestamp(); ASSERT_EQUALS(Timestamp(2, 1), stableTimestamp); - getStorageInterface()->allCommittedTimestamp = Timestamp(4, 4); + getStorageInterface()->allDurableTimestamp = Timestamp(4, 4); // Check that the stable timestamp is updated when we advance the commit point. replCoordAdvanceCommitPoint(OpTime({3, 2}, term), Date_t() + Seconds(3), false); diff --git a/src/mongo/db/repl/storage_interface.h b/src/mongo/db/repl/storage_interface.h index a1cdd60ed92..cb178adf519 100644 --- a/src/mongo/db/repl/storage_interface.h +++ b/src/mongo/db/repl/storage_interface.h @@ -398,12 +398,16 @@ public: bool primaryOnly = false) = 0; /** - * Returns the all committed timestamp. All transactions with timestamps earlier than the - * all committed timestamp are committed. Only storage engines that support document level - * locking must provide an implementation. Other storage engines may provide a no-op - * implementation. + * Returns the all_durable timestamp. All transactions with timestamps earlier than the + * all_durable timestamp are committed. Only storage engines that support document level locking + * must provide an implementation. Other storage engines may provide a no-op implementation. + * + * The all_durable timestamp only includes non-prepared transactions that have been given a + * commit_timestamp and prepared transactions that have been given a durable_timestamp. + * Previously, the deprecated all_committed timestamp would also include prepared transactions + * that were prepared but not committed which could make the stable timestamp briefly jump back. */ - virtual Timestamp getAllCommittedTimestamp(ServiceContext* serviceCtx) const = 0; + virtual Timestamp getAllDurableTimestamp(ServiceContext* serviceCtx) const = 0; /** * Returns the oldest read timestamp in use by an open transaction. Storage engines that support diff --git a/src/mongo/db/repl/storage_interface_impl.cpp b/src/mongo/db/repl/storage_interface_impl.cpp index 7cfa35ba7af..03d8bc66e55 100644 --- a/src/mongo/db/repl/storage_interface_impl.cpp +++ b/src/mongo/db/repl/storage_interface_impl.cpp @@ -1214,8 +1214,8 @@ bool StorageInterfaceImpl::supportsDocLocking(ServiceContext* serviceCtx) const return serviceCtx->getStorageEngine()->supportsDocLocking(); } -Timestamp StorageInterfaceImpl::getAllCommittedTimestamp(ServiceContext* serviceCtx) const { - return serviceCtx->getStorageEngine()->getAllCommittedTimestamp(); +Timestamp StorageInterfaceImpl::getAllDurableTimestamp(ServiceContext* serviceCtx) const { + return serviceCtx->getStorageEngine()->getAllDurableTimestamp(); } Timestamp StorageInterfaceImpl::getOldestOpenReadTimestamp(ServiceContext* serviceCtx) const { diff --git a/src/mongo/db/repl/storage_interface_impl.h b/src/mongo/db/repl/storage_interface_impl.h index 733d11bd5f8..85d7c9186c3 100644 --- a/src/mongo/db/repl/storage_interface_impl.h +++ b/src/mongo/db/repl/storage_interface_impl.h @@ -172,7 +172,7 @@ public: bool supportsDocLocking(ServiceContext* serviceCtx) const override; - Timestamp getAllCommittedTimestamp(ServiceContext* serviceCtx) const override; + Timestamp getAllDurableTimestamp(ServiceContext* serviceCtx) const override; Timestamp getOldestOpenReadTimestamp(ServiceContext* serviceCtx) const override; diff --git a/src/mongo/db/repl/storage_interface_mock.cpp b/src/mongo/db/repl/storage_interface_mock.cpp index d171032c575..77936b4453d 100644 --- a/src/mongo/db/repl/storage_interface_mock.cpp +++ b/src/mongo/db/repl/storage_interface_mock.cpp @@ -90,8 +90,8 @@ Timestamp StorageInterfaceMock::getInitialDataTimestamp() const { return _initialDataTimestamp; } -Timestamp StorageInterfaceMock::getAllCommittedTimestamp(ServiceContext* serviceCtx) const { - return allCommittedTimestamp; +Timestamp StorageInterfaceMock::getAllDurableTimestamp(ServiceContext* serviceCtx) const { + return allDurableTimestamp; } Timestamp StorageInterfaceMock::getOldestOpenReadTimestamp(ServiceContext* serviceCtx) const { diff --git a/src/mongo/db/repl/storage_interface_mock.h b/src/mongo/db/repl/storage_interface_mock.h index ebf54b3cc5d..f4ac2aa763c 100644 --- a/src/mongo/db/repl/storage_interface_mock.h +++ b/src/mongo/db/repl/storage_interface_mock.h @@ -310,7 +310,7 @@ public: return boost::none; } - Timestamp getAllCommittedTimestamp(ServiceContext* serviceCtx) const override; + Timestamp getAllDurableTimestamp(ServiceContext* serviceCtx) const override; Timestamp getOldestOpenReadTimestamp(ServiceContext* serviceCtx) const override; @@ -403,7 +403,7 @@ public: }; bool supportsDocLockingBool = false; - Timestamp allCommittedTimestamp = Timestamp::min(); + Timestamp allDurableTimestamp = Timestamp::min(); Timestamp oldestOpenReadTimestamp = Timestamp::min(); private: diff --git a/src/mongo/db/storage/biggie/biggie_kv_engine.h b/src/mongo/db/storage/biggie/biggie_kv_engine.h index fcb76c638d1..97c836b523a 100644 --- a/src/mongo/db/storage/biggie/biggie_kv_engine.h +++ b/src/mongo/db/storage/biggie/biggie_kv_engine.h @@ -135,7 +135,7 @@ public: void setJournalListener(mongo::JournalListener* jl) final {} - virtual Timestamp getAllCommittedTimestamp() const override { + virtual Timestamp getAllDurableTimestamp() const override { RecordId id = _visibilityManager->getAllCommittedRecord(); return Timestamp(id.repr()); } diff --git a/src/mongo/db/storage/devnull/devnull_kv_engine.h b/src/mongo/db/storage/devnull/devnull_kv_engine.h index 5f52ed44b7d..d0645b897b2 100644 --- a/src/mongo/db/storage/devnull/devnull_kv_engine.h +++ b/src/mongo/db/storage/devnull/devnull_kv_engine.h @@ -121,7 +121,7 @@ public: void setJournalListener(JournalListener* jl) final {} - virtual Timestamp getAllCommittedTimestamp() const override { + virtual Timestamp getAllDurableTimestamp() const override { return Timestamp(); } diff --git a/src/mongo/db/storage/ephemeral_for_test/ephemeral_for_test_engine.h b/src/mongo/db/storage/ephemeral_for_test/ephemeral_for_test_engine.h index 3eabcae6654..3a76d268efb 100644 --- a/src/mongo/db/storage/ephemeral_for_test/ephemeral_for_test_engine.h +++ b/src/mongo/db/storage/ephemeral_for_test/ephemeral_for_test_engine.h @@ -112,7 +112,7 @@ public: _journalListener = jl; } - virtual Timestamp getAllCommittedTimestamp() const override { + virtual Timestamp getAllDurableTimestamp() const override { MONGO_UNREACHABLE; } diff --git a/src/mongo/db/storage/kv/kv_drop_pending_ident_reaper_test.cpp b/src/mongo/db/storage/kv/kv_drop_pending_ident_reaper_test.cpp index 7356d68e685..f58c2abb0b4 100644 --- a/src/mongo/db/storage/kv/kv_drop_pending_ident_reaper_test.cpp +++ b/src/mongo/db/storage/kv/kv_drop_pending_ident_reaper_test.cpp @@ -117,7 +117,7 @@ public: } void cleanShutdown() override {} void setJournalListener(JournalListener* jl) override {} - Timestamp getAllCommittedTimestamp() const override { + Timestamp getAllDurableTimestamp() const override { return {}; } Timestamp getOldestOpenReadTimestamp() const override { diff --git a/src/mongo/db/storage/kv/kv_engine.h b/src/mongo/db/storage/kv/kv_engine.h index 0503c6f5e6f..d8b5772cd3b 100644 --- a/src/mongo/db/storage/kv/kv_engine.h +++ b/src/mongo/db/storage/kv/kv_engine.h @@ -373,9 +373,9 @@ public: } /** - * See `StorageEngine::getAllCommittedTimestamp` + * See `StorageEngine::getAllDurableTimestamp` */ - virtual Timestamp getAllCommittedTimestamp() const = 0; + virtual Timestamp getAllDurableTimestamp() const = 0; /** * See `StorageEngine::getOldestOpenReadTimestamp` diff --git a/src/mongo/db/storage/kv/kv_engine_test_harness.cpp b/src/mongo/db/storage/kv/kv_engine_test_harness.cpp index e39bae73f0c..17ad60721d7 100644 --- a/src/mongo/db/storage/kv/kv_engine_test_harness.cpp +++ b/src/mongo/db/storage/kv/kv_engine_test_harness.cpp @@ -229,7 +229,7 @@ TEST(KVEngineTestHarness, TemporaryRecordStoreSimple) { } } -TEST(KVEngineTestHarness, AllCommittedTimestamp) { +TEST(KVEngineTestHarness, AllDurableTimestamp) { std::unique_ptr<KVHarnessHelper> helper(KVHarnessHelper::create()); KVEngine* engine = helper->getEngine(); if (!engine->supportsDocLocking()) @@ -258,17 +258,17 @@ TEST(KVEngineTestHarness, AllCommittedTimestamp) { auto t12Doc = BSON("ts" << t12); auto t21Doc = BSON("ts" << t21); - Timestamp allCommitted = engine->getAllCommittedTimestamp(); + Timestamp allDurable = engine->getAllDurableTimestamp(); MyOperationContext opCtx1(engine); WriteUnitOfWork uow1(&opCtx1); ASSERT_EQ(invariant(rs->insertRecord( &opCtx1, t11Doc.objdata(), t11Doc.objsize(), Timestamp::min())), RecordId(1, 1)); - Timestamp lastAllCommitted = allCommitted; - allCommitted = engine->getAllCommittedTimestamp(); - ASSERT_GTE(allCommitted, lastAllCommitted); - ASSERT_LT(allCommitted, t11); + Timestamp lastAllDurable = allDurable; + allDurable = engine->getAllDurableTimestamp(); + ASSERT_GTE(allDurable, lastAllDurable); + ASSERT_LT(allDurable, t11); MyOperationContext opCtx2(engine); WriteUnitOfWork uow2(&opCtx2); @@ -277,26 +277,26 @@ TEST(KVEngineTestHarness, AllCommittedTimestamp) { RecordId(2, 1)); uow2.commit(); - lastAllCommitted = allCommitted; - allCommitted = engine->getAllCommittedTimestamp(); - ASSERT_GTE(allCommitted, lastAllCommitted); - ASSERT_LT(allCommitted, t11); + lastAllDurable = allDurable; + allDurable = engine->getAllDurableTimestamp(); + ASSERT_GTE(allDurable, lastAllDurable); + ASSERT_LT(allDurable, t11); ASSERT_EQ(invariant(rs->insertRecord( &opCtx1, t12Doc.objdata(), t12Doc.objsize(), Timestamp::min())), RecordId(1, 2)); - lastAllCommitted = allCommitted; - allCommitted = engine->getAllCommittedTimestamp(); - ASSERT_GTE(allCommitted, lastAllCommitted); - ASSERT_LT(allCommitted, t11); + lastAllDurable = allDurable; + allDurable = engine->getAllDurableTimestamp(); + ASSERT_GTE(allDurable, lastAllDurable); + ASSERT_LT(allDurable, t11); uow1.commit(); - lastAllCommitted = allCommitted; - allCommitted = engine->getAllCommittedTimestamp(); - ASSERT_GTE(allCommitted, lastAllCommitted); - ASSERT_LTE(allCommitted, t21); + lastAllDurable = allDurable; + allDurable = engine->getAllDurableTimestamp(); + ASSERT_GTE(allDurable, lastAllDurable); + ASSERT_LTE(allDurable, t21); } } diff --git a/src/mongo/db/storage/mobile/mobile_kv_engine.h b/src/mongo/db/storage/mobile/mobile_kv_engine.h index a09d4187200..3762ccf0878 100644 --- a/src/mongo/db/storage/mobile/mobile_kv_engine.h +++ b/src/mongo/db/storage/mobile/mobile_kv_engine.h @@ -128,7 +128,7 @@ public: _journalListener = jl; } - virtual Timestamp getAllCommittedTimestamp() const override { + virtual Timestamp getAllDurableTimestamp() const override { MONGO_UNREACHABLE; } diff --git a/src/mongo/db/storage/recovery_unit.h b/src/mongo/db/storage/recovery_unit.h index dcc8a37482f..1aea3e085ef 100644 --- a/src/mongo/db/storage/recovery_unit.h +++ b/src/mongo/db/storage/recovery_unit.h @@ -242,8 +242,8 @@ public: * a point in time. Any point in time returned will reflect one of the following: * - when using ReadSource::kProvided, the timestamp provided. * - when using ReadSource::kNoOverlap, the timestamp chosen by the storage engine. - * - when using ReadSource::kAllCommittedSnapshot, the timestamp chosen using the storage - * engine's all-committed timestamp. + * - when using ReadSource::kAllDurableSnapshot, the timestamp chosen using the storage + * engine's all_durable timestamp. * - when using ReadSource::kLastApplied, the timestamp chosen using the storage engine's last * applied timestamp. Can return boost::none if no timestamp has been established. * - when using ReadSource::kMajorityCommitted, the majority committed timestamp chosen by the @@ -370,10 +370,10 @@ public: */ kLastApplied, /** - * Read from the all-committed timestamp. New transactions will always read from the same + * Read from the all_durable timestamp. New transactions will always read from the same * timestamp and never advance. */ - kAllCommittedSnapshot, + kAllDurableSnapshot, /** * Read from the timestamp provided to setTimestampReadSource. */ diff --git a/src/mongo/db/storage/storage_engine.h b/src/mongo/db/storage/storage_engine.h index 7722aaaa956..1b0bf3e6216 100644 --- a/src/mongo/db/storage/storage_engine.h +++ b/src/mongo/db/storage/storage_engine.h @@ -500,12 +500,16 @@ public: }; /** - * Returns the all committed timestamp. All transactions with timestamps earlier than the - * all committed timestamp are committed. Only storage engines that support document level - * locking must provide an implementation. Other storage engines may provide a no-op - * implementation. + * Returns the all_durable timestamp. All transactions with timestamps earlier than the + * all_durable timestamp are committed. Only storage engines that support document level locking + * must provide an implementation. Other storage engines may provide a no-op implementation. + * + * The all_durable timestamp only includes non-prepared transactions that have been given a + * commit_timestamp and prepared transactions that have been given a durable_timestamp. + * Previously, the deprecated all_committed timestamp would also include prepared transactions + * that were prepared but not committed which could make the stable timestamp briefly jump back. */ - virtual Timestamp getAllCommittedTimestamp() const = 0; + virtual Timestamp getAllDurableTimestamp() const = 0; /** * Returns the oldest read timestamp in use by an open transaction. Storage engines that support diff --git a/src/mongo/db/storage/storage_engine_impl.cpp b/src/mongo/db/storage/storage_engine_impl.cpp index f9498194fc4..57dcb407253 100644 --- a/src/mongo/db/storage/storage_engine_impl.cpp +++ b/src/mongo/db/storage/storage_engine_impl.cpp @@ -805,8 +805,8 @@ void StorageEngineImpl::replicationBatchIsComplete() const { return _engine->replicationBatchIsComplete(); } -Timestamp StorageEngineImpl::getAllCommittedTimestamp() const { - return _engine->getAllCommittedTimestamp(); +Timestamp StorageEngineImpl::getAllDurableTimestamp() const { + return _engine->getAllDurableTimestamp(); } Timestamp StorageEngineImpl::getOldestOpenReadTimestamp() const { diff --git a/src/mongo/db/storage/storage_engine_impl.h b/src/mongo/db/storage/storage_engine_impl.h index db471036501..54182dd4676 100644 --- a/src/mongo/db/storage/storage_engine_impl.h +++ b/src/mongo/db/storage/storage_engine_impl.h @@ -139,7 +139,7 @@ public: virtual boost::optional<Timestamp> getLastStableRecoveryTimestamp() const override; - virtual Timestamp getAllCommittedTimestamp() const override; + virtual Timestamp getAllDurableTimestamp() const override; virtual Timestamp getOldestOpenReadTimestamp() const override; diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_kv_engine.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_kv_engine.cpp index 422f838ba5f..026e7d59c74 100644 --- a/src/mongo/db/storage/wiredtiger/wiredtiger_kv_engine.cpp +++ b/src/mongo/db/storage/wiredtiger/wiredtiger_kv_engine.cpp @@ -1761,8 +1761,8 @@ StatusWith<Timestamp> WiredTigerKVEngine::recoverToStableTimestamp(OperationCont return {stableTimestamp}; } -Timestamp WiredTigerKVEngine::getAllCommittedTimestamp() const { - return Timestamp(_oplogManager->fetchAllCommittedValue(_conn)); +Timestamp WiredTigerKVEngine::getAllDurableTimestamp() const { + return Timestamp(_oplogManager->fetchAllDurableValue(_conn)); } Timestamp WiredTigerKVEngine::getOldestOpenReadTimestamp() const { diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_kv_engine.h b/src/mongo/db/storage/wiredtiger/wiredtiger_kv_engine.h index 625cb5a565a..c1502094ec5 100644 --- a/src/mongo/db/storage/wiredtiger/wiredtiger_kv_engine.h +++ b/src/mongo/db/storage/wiredtiger/wiredtiger_kv_engine.h @@ -230,7 +230,7 @@ public: */ boost::optional<Timestamp> getLastStableRecoveryTimestamp() const override; - Timestamp getAllCommittedTimestamp() const override; + Timestamp getAllDurableTimestamp() const override; Timestamp getOldestOpenReadTimestamp() const override; diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_oplog_manager.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_oplog_manager.cpp index 28dd48f261f..e3ec7e9097d 100644 --- a/src/mongo/db/storage/wiredtiger/wiredtiger_oplog_manager.cpp +++ b/src/mongo/db/storage/wiredtiger/wiredtiger_oplog_manager.cpp @@ -207,7 +207,7 @@ void WiredTigerOplogManager::_oplogJournalThreadLoop(WiredTigerSessionCache* ses _opsWaitingForJournal = false; lk.unlock(); - const uint64_t newTimestamp = fetchAllCommittedValue(sessionCache->conn()); + const uint64_t newTimestamp = fetchAllDurableValue(sessionCache->conn()); // The newTimestamp may actually go backward during secondary batch application, // where we commit data file changes separately from oplog changes, so ignore @@ -249,11 +249,11 @@ void WiredTigerOplogManager::_setOplogReadTimestamp(WithLock, uint64_t newTimest LOG(2) << "Setting new oplogReadTimestamp: " << Timestamp(newTimestamp); } -uint64_t WiredTigerOplogManager::fetchAllCommittedValue(WT_CONNECTION* conn) { - // Fetch the latest all_committed value from the storage engine. This value will be a - // timestamp that has no holes (uncommitted transactions with lower timestamps) behind it. +uint64_t WiredTigerOplogManager::fetchAllDurableValue(WT_CONNECTION* conn) { + // Fetch the latest all_durable value from the storage engine. This value will be a timestamp + // that has no holes (uncommitted transactions with lower timestamps) behind it. char buf[(2 * 8 /*bytes in hex*/) + 1 /*nul terminator*/]; - auto wtstatus = conn->query_timestamp(conn, buf, "get=all_committed"); + auto wtstatus = conn->query_timestamp(conn, buf, "get=all_durable"); if (wtstatus == WT_NOTFOUND) { // Treat this as lowest possible timestamp; we need to see all preexisting data but no new // (timestamped) data. diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_oplog_manager.h b/src/mongo/db/storage/wiredtiger/wiredtiger_oplog_manager.h index f71ba7e5214..9a82985fc28 100644 --- a/src/mongo/db/storage/wiredtiger/wiredtiger_oplog_manager.h +++ b/src/mongo/db/storage/wiredtiger/wiredtiger_oplog_manager.h @@ -41,7 +41,7 @@ class WiredTigerRecordStore; class WiredTigerSessionCache; -// Manages oplog visibility, by periodically querying WiredTiger's all_committed timestamp value and +// Manages oplog visibility, by periodically querying WiredTiger's all_durable timestamp value and // then using that timestamp for all transactions that read the oplog collection. class WiredTigerOplogManager { WiredTigerOplogManager(const WiredTigerOplogManager&) = delete; @@ -78,9 +78,9 @@ public: void waitForAllEarlierOplogWritesToBeVisible(const WiredTigerRecordStore* oplogRecordStore, OperationContext* opCtx); - // Returns the all committed timestamp. All transactions with timestamps earlier than the - // all committed timestamp are committed. - uint64_t fetchAllCommittedValue(WT_CONNECTION* conn); + // Returns the all_durable timestamp. All transactions with timestamps earlier than the + // all_durable timestamp are committed. + uint64_t fetchAllDurableValue(WT_CONNECTION* conn); private: void _oplogJournalThreadLoop(WiredTigerSessionCache* sessionCache, diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.cpp index 3f26c7b8614..33f1548411c 100644 --- a/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.cpp +++ b/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.cpp @@ -425,7 +425,7 @@ boost::optional<Timestamp> WiredTigerRecoveryUnit::getPointInTimeReadTimestamp() // opened. case ReadSource::kNoOverlap: case ReadSource::kLastApplied: - case ReadSource::kAllCommittedSnapshot: + case ReadSource::kAllDurableSnapshot: break; } @@ -441,7 +441,7 @@ boost::optional<Timestamp> WiredTigerRecoveryUnit::getPointInTimeReadTimestamp() } return boost::none; case ReadSource::kNoOverlap: - case ReadSource::kAllCommittedSnapshot: + case ReadSource::kAllDurableSnapshot: invariant(!_readAtTimestamp.isNull()); return _readAtTimestamp; @@ -501,9 +501,9 @@ void WiredTigerRecoveryUnit::_txnOpen() { _readAtTimestamp = _beginTransactionAtNoOverlapTimestamp(session); break; } - case ReadSource::kAllCommittedSnapshot: { + case ReadSource::kAllDurableSnapshot: { if (_readAtTimestamp.isNull()) { - _readAtTimestamp = _beginTransactionAtAllCommittedTimestamp(session); + _readAtTimestamp = _beginTransactionAtAllDurableTimestamp(session); break; } // Intentionally continue to the next case to read at the _readAtTimestamp. @@ -527,17 +527,17 @@ void WiredTigerRecoveryUnit::_txnOpen() { LOG(3) << "WT begin_transaction for snapshot id " << _mySnapshotId; } -Timestamp WiredTigerRecoveryUnit::_beginTransactionAtAllCommittedTimestamp(WT_SESSION* session) { +Timestamp WiredTigerRecoveryUnit::_beginTransactionAtAllDurableTimestamp(WT_SESSION* session) { WiredTigerBeginTxnBlock txnOpen(session, _prepareConflictBehavior, _roundUpPreparedTimestamps, RoundUpReadTimestamp::kRound); - Timestamp txnTimestamp = Timestamp(_oplogManager->fetchAllCommittedValue(session->connection)); + Timestamp txnTimestamp = Timestamp(_oplogManager->fetchAllDurableValue(session->connection)); auto status = txnOpen.setReadSnapshot(txnTimestamp); fassert(50948, status); // Since this is not in a critical section, we might have rounded to oldest between - // calling getAllCommitted and setReadSnapshot. We need to get the actual read timestamp we + // calling getAllDurable and setReadSnapshot. We need to get the actual read timestamp we // used. auto readTimestamp = _getTransactionReadTimestamp(session); txnOpen.done(); @@ -547,7 +547,7 @@ Timestamp WiredTigerRecoveryUnit::_beginTransactionAtAllCommittedTimestamp(WT_SE Timestamp WiredTigerRecoveryUnit::_beginTransactionAtNoOverlapTimestamp(WT_SESSION* session) { auto lastApplied = _sessionCache->snapshotManager().getLocalSnapshot(); - Timestamp allCommitted = Timestamp(_oplogManager->fetchAllCommittedValue(session->connection)); + Timestamp allDurable = Timestamp(_oplogManager->fetchAllDurableValue(session->connection)); // When using timestamps for reads and writes, it's important that readers and writers don't // overlap with the timestamps they use. In other words, at any point in the system there should @@ -555,13 +555,13 @@ Timestamp WiredTigerRecoveryUnit::_beginTransactionAtNoOverlapTimestamp(WT_SESSI // at, or earlier than T. This time T is called the no-overlap point. Using the `kNoOverlap` // ReadSource will compute the most recent known time that is safe to read at. - // The no-overlap point is computed as the minimum of the storage engine's all-committed time + // The no-overlap point is computed as the minimum of the storage engine's all_durable time // and replication's last applied time. On primaries, the last applied time is updated as // transactions commit, which is not necessarily in the order they appear in the oplog. Thus - // the all-committed time is an appropriate value to read at. + // the all_durable time is an appropriate value to read at. - // On secondaries, however, the all-committed time, as computed by the storage engine, can - // advance before oplog application completes a batch. This is because the all-committed time + // On secondaries, however, the all_durable time, as computed by the storage engine, can + // advance before oplog application completes a batch. This is because the all_durable time // is only computed correctly if the storage engine is informed of commit timestamps in // increasing order. Because oplog application processes a batch of oplog entries out of order, // the timestamping requirement is not satisfied. Secondaries, however, only update the last @@ -569,11 +569,11 @@ Timestamp WiredTigerRecoveryUnit::_beginTransactionAtNoOverlapTimestamp(WT_SESSI // secondaries. // By taking the minimum of the two values, storage can compute a legal time to read at without - // knowledge of the replication state. The no-overlap point is the minimum of the all-committed + // knowledge of the replication state. The no-overlap point is the minimum of the all_durable // time, which represents the point where no transactions will commit any earlier, and // lastApplied, which represents the highest optime a node has applied, a point no readers // should read afterward. - Timestamp readTimestamp = (lastApplied) ? std::min(*lastApplied, allCommitted) : allCommitted; + Timestamp readTimestamp = (lastApplied) ? std::min(*lastApplied, allDurable) : allDurable; WiredTigerBeginTxnBlock txnOpen(session, _prepareConflictBehavior, @@ -582,7 +582,7 @@ Timestamp WiredTigerRecoveryUnit::_beginTransactionAtNoOverlapTimestamp(WT_SESSI auto status = txnOpen.setReadSnapshot(readTimestamp); fassert(51066, status); - // We might have rounded to oldest between calling getAllCommitted and setReadSnapshot. We need + // We might have rounded to oldest between calling getAllDurable and setReadSnapshot. We need // to get the actual read timestamp we used. readTimestamp = _getTransactionReadTimestamp(session); txnOpen.done(); diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.h b/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.h index 7ed61acf29b..81483c51cd7 100644 --- a/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.h +++ b/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.h @@ -208,10 +208,10 @@ private: void _txnOpen(); /** - * Starts a transaction at the current all-committed timestamp. + * Starts a transaction at the current all_durable timestamp. * Returns the timestamp the transaction was started at. */ - Timestamp _beginTransactionAtAllCommittedTimestamp(WT_SESSION* session); + Timestamp _beginTransactionAtAllDurableTimestamp(WT_SESSION* session); /** * Starts a transaction at the no-overlap timestamp. Returns the timestamp the transaction diff --git a/src/mongo/db/transaction_participant.cpp b/src/mongo/db/transaction_participant.cpp index 5d9b45eeda0..46d2a49a6c0 100644 --- a/src/mongo/db/transaction_participant.cpp +++ b/src/mongo/db/transaction_participant.cpp @@ -598,10 +598,10 @@ void TransactionParticipant::Participant::_setReadSnapshot(OperationContext* opC o(lk).transactionMetricsObserver.onChooseReadTimestamp(readTimestamp); } else if (readConcernArgs.getOriginalLevel() == repl::ReadConcernLevel::kSnapshotReadConcern) { // For transactions with read concern level specified as 'snapshot', we will use - // 'kAllCommittedSnapshot' which ensures a snapshot with no 'holes'; that is, it is a state + // 'kAllDurableSnapshot' which ensures a snapshot with no 'holes'; that is, it is a state // of the system that could be reconstructed from the oplog. opCtx->recoveryUnit()->setTimestampReadSource( - RecoveryUnit::ReadSource::kAllCommittedSnapshot); + RecoveryUnit::ReadSource::kAllDurableSnapshot); const auto readTimestamp = repl::StorageInterface::get(opCtx)->getPointInTimeReadTimestamp(opCtx); @@ -661,10 +661,10 @@ TransactionParticipant::OplogSlotReserver::~OplogSlotReserver() { _recoveryUnit->abortUnitOfWork(); } - // After releasing the oplog hole, the "all committed timestamp" can advance past - // this oplog hole, if there are no other open holes. Check if we can advance the stable - // timestamp any further since a majority write may be waiting on the stable timestamp to - // advance beyond this oplog hole to acknowledge the write to the user. + // After releasing the oplog hole, the all_durable timestamp can advance past this oplog hole, + // if there are no other open holes. Check if we can advance the stable timestamp any further + // since a majority write may be waiting on the stable timestamp to advance beyond this oplog + // hole to acknowledge the write to the user. auto replCoord = repl::ReplicationCoordinator::get(_opCtx); replCoord->attemptToAdvanceStableTimestamp(); } |