diff --git a/Builds/VisualStudio/stellar-core.vcxproj b/Builds/VisualStudio/stellar-core.vcxproj index 0aa028f9d2..933a344b6f 100644 --- a/Builds/VisualStudio/stellar-core.vcxproj +++ b/Builds/VisualStudio/stellar-core.vcxproj @@ -464,7 +464,6 @@ exit /b 0 - @@ -941,7 +940,6 @@ exit /b 0 - diff --git a/Builds/VisualStudio/stellar-core.vcxproj.filters b/Builds/VisualStudio/stellar-core.vcxproj.filters index 7782662115..5be5dae624 100644 --- a/Builds/VisualStudio/stellar-core.vcxproj.filters +++ b/Builds/VisualStudio/stellar-core.vcxproj.filters @@ -1278,9 +1278,6 @@ bucket - - bucket - overlay\tests @@ -2376,9 +2373,6 @@ main - - bucket - overlay diff --git a/src/bucket/BucketListSnapshot.cpp b/src/bucket/BucketListSnapshot.cpp index eae919bc06..99a44a8dfc 100644 --- a/src/bucket/BucketListSnapshot.cpp +++ b/src/bucket/BucketListSnapshot.cpp @@ -40,7 +40,7 @@ BucketListSnapshotData::Level::Level( template BucketListSnapshotData::BucketListSnapshotData( - BucketListBase const& bl, LedgerHeader const& header) + BucketListBase const& bl) : levels([&bl]() { std::vector v; v.reserve(BucketListBase::kNumLevels); @@ -50,17 +50,9 @@ BucketListSnapshotData::BucketListSnapshotData( } return v; }()) - , header(header) { } -template -uint32_t -BucketListSnapshotData::getLedgerSeq() const -{ - return header.ledgerSeq; -} - // // SearchableBucketListSnapshot // @@ -70,9 +62,11 @@ SearchableBucketListSnapshot::SearchableBucketListSnapshot( MetricsRegistry& metrics, std::shared_ptr const> data, std::map const>> - historicalSnapshots) + historicalSnapshots, + uint32_t ledgerSeq) : mData(std::move(data)) , mHistoricalSnapshots(std::move(historicalSnapshots)) + , mLedgerSeq(ledgerSeq) , mMetrics(metrics) , mBulkLoadMeter( metrics.NewMeter({BucketT::METRIC_STRING, "query", "loads"}, "query")) @@ -87,6 +81,39 @@ SearchableBucketListSnapshot::SearchableBucketListSnapshot( } } +template +SearchableBucketListSnapshot::SearchableBucketListSnapshot( + SearchableBucketListSnapshot const& other) + : mData(other.mData) + , mHistoricalSnapshots(other.mHistoricalSnapshots) + , mLedgerSeq(other.mLedgerSeq) + // mStreams intentionally left empty — each copy gets its own stream cache + , mMetrics(other.mMetrics) + , mPointTimers(other.mPointTimers) + , mBulkTimers(other.mBulkTimers) + , mBulkLoadMeter(other.mBulkLoadMeter) +{ +} + +template +SearchableBucketListSnapshot& +SearchableBucketListSnapshot::operator=( + SearchableBucketListSnapshot const& other) +{ + if (this != &other) + { + mData = other.mData; + mHistoricalSnapshots = other.mHistoricalSnapshots; + mLedgerSeq = other.mLedgerSeq; + mStreams.clear(); + mMetrics = other.mMetrics; + mPointTimers = other.mPointTimers; + mBulkTimers = other.mBulkTimers; + mBulkLoadMeter = other.mBulkLoadMeter; + } + return *this; +} + // File streams are fairly expensive to create, so they are lazily created and // stored in mStreams. template @@ -292,7 +319,7 @@ SearchableBucketListSnapshot::load(LedgerKey const& k) const auto timerIter = mPointTimers.find(k.type()); releaseAssert(timerIter != mPointTimers.end()); - auto timer = timerIter->second.TimeScope(); + auto timer = timerIter->second.get().TimeScope(); std::shared_ptr result{}; @@ -336,7 +363,7 @@ SearchableBucketListSnapshot::loadKeysInternal( return keys.empty() ? Loop::COMPLETE : Loop::INCOMPLETE; }; - if (!ledgerSeq || *ledgerSeq == mData->getLedgerSeq()) + if (!ledgerSeq || *ledgerSeq == mLedgerSeq) { loopAllBuckets(loadKeysLoop, *mData); } @@ -370,34 +397,18 @@ SearchableBucketListSnapshot::getBulkLoadTimer( { if (numEntries != 0) { - mBulkLoadMeter.Mark(numEntries); + mBulkLoadMeter.get().Mark(numEntries); } auto iter = mBulkTimers.find(label); if (iter == mBulkTimers.end()) { auto& metric = - mMetrics.NewTimer({BucketT::METRIC_STRING, "bulk", label}); + mMetrics.get().NewTimer({BucketT::METRIC_STRING, "bulk", label}); iter = mBulkTimers.emplace(label, metric).first; } - return iter->second; -} - -template -uint32_t -SearchableBucketListSnapshot::getLedgerSeq() const -{ - releaseAssert(mData); - return mData->getLedgerSeq(); -} - -template -LedgerHeader const& -SearchableBucketListSnapshot::getLedgerHeader() const -{ - releaseAssert(mData); - return mData->header; + return iter->second.get(); } template @@ -424,9 +435,10 @@ SearchableLiveBucketListSnapshot::SearchableLiveBucketListSnapshot( std::shared_ptr const> data, std::map const>> - historicalSnapshots) - : SearchableBucketListSnapshot(metrics, std::move(data), - std::move(historicalSnapshots)) + historicalSnapshots, + uint32_t ledgerSeq) + : SearchableBucketListSnapshot( + metrics, std::move(data), std::move(historicalSnapshots), ledgerSeq) { } @@ -855,9 +867,10 @@ SearchableHotArchiveBucketListSnapshot::SearchableHotArchiveBucketListSnapshot( std::shared_ptr const> data, std::map const>> - historicalSnapshots) + historicalSnapshots, + uint32_t ledgerSeq) : SearchableBucketListSnapshot( - metrics, std::move(data), std::move(historicalSnapshots)) + metrics, std::move(data), std::move(historicalSnapshots), ledgerSeq) { } diff --git a/src/bucket/BucketListSnapshot.h b/src/bucket/BucketListSnapshot.h index 0412a5f966..371932456a 100644 --- a/src/bucket/BucketListSnapshot.h +++ b/src/bucket/BucketListSnapshot.h @@ -13,7 +13,6 @@ #include "util/UnorderedSet.h" #include "util/XDRStream.h" #include "xdr/Stellar-ledger-entries.h" -#include "xdr/Stellar-ledger.h" #include #include @@ -34,7 +33,6 @@ class Timer; namespace stellar { -class BucketSnapshotManager; struct EvictionMetrics; struct EvictionResultCandidates; struct EvictionResultEntry; @@ -43,10 +41,12 @@ struct StateArchivalSettings; class EvictionStatistics; template class BucketListBase; template class BucketLevel; +class CompleteConstLedgerState; +class LedgerStateSnapshot; -// BucketListSnapshotData holds the immutable snapshot data that can be safely -// shared across threads. It contains bucket references and the ledger header, -// but no mutable state like file streams. +// BucketListSnapshotData holds the immutable bucket references that can be +// safely shared across threads. It contains only bucket pointers and no +// metadata (headers, sequence numbers, etc.) or mutable state (file streams). template struct BucketListSnapshotData { BUCKET_TYPE_ASSERT(BucketT); @@ -62,12 +62,8 @@ template struct BucketListSnapshotData }; std::vector const levels; - LedgerHeader const header; - BucketListSnapshotData(BucketListBase const& bl, - LedgerHeader const& header); - - uint32_t getLedgerSeq() const; + explicit BucketListSnapshotData(BucketListBase const& bl); }; // SearchableBucketListSnapshot provides BucketList lookup functionality. @@ -88,20 +84,27 @@ template class SearchableBucketListSnapshot std::map const>> mHistoricalSnapshots; + // Ledger sequence number for this snapshot, used internally to route + // queries between current and historical data. Not exposed publicly; + // callers should get ledger metadata from CompleteConstLedgerState. + uint32_t mLedgerSeq; + // Per-snapshot mutable stream cache mutable UnorderedMap> mStreams; - MetricsRegistry& mMetrics; + std::reference_wrapper mMetrics; // Tracks load times for each LedgerEntryType. We use // SimpleTimer since medida Timer overhead is too expensive for point loads. - UnorderedMap mPointTimers; + UnorderedMap> + mPointTimers; // Bulk load timers take significantly longer, so the timer overhead is // comparatively negligible. - mutable UnorderedMap mBulkTimers; - medida::Meter& mBulkLoadMeter; + mutable UnorderedMap> + mBulkTimers; + std::reference_wrapper mBulkLoadMeter; // Returns (lazily-constructed) file stream for bucket file. Note // this might be in some random position left over from a previous read -- @@ -151,9 +154,17 @@ template class SearchableBucketListSnapshot std::shared_ptr const> data, std::map const>> - historicalSnapshots); + historicalSnapshots, + uint32_t ledgerSeq); public: + // Copy: copies all state except mStreams, which is reset to empty. + // Each copy gets its own file stream cache, making copies safe to use + // from different threads. + SearchableBucketListSnapshot(SearchableBucketListSnapshot const& other); + SearchableBucketListSnapshot& + operator=(SearchableBucketListSnapshot const& other); + virtual ~SearchableBucketListSnapshot() = default; // Point load, returns nullptr if not found @@ -170,9 +181,6 @@ template class SearchableBucketListSnapshot loadKeysFromLedger(std::set const& inKeys, uint32_t ledgerSeq) const; - uint32_t getLedgerSeq() const; - LedgerHeader const& getLedgerHeader() const; - // Access to underlying data (for copying/refreshing) std::shared_ptr const> const& getSnapshotData() const; @@ -191,7 +199,8 @@ class SearchableLiveBucketListSnapshot std::shared_ptr const> data, std::map const>> - historicalSnapshots); + historicalSnapshots, + uint32_t ledgerSeq); Loop scanForEvictionInBucket( std::shared_ptr const& bucket, EvictionIterator& iter, @@ -200,6 +209,9 @@ class SearchableLiveBucketListSnapshot UnorderedSet& keysInEvictableEntries) const; public: + SearchableLiveBucketListSnapshot(SearchableLiveBucketListSnapshot const&) = + default; + std::vector loadKeys(std::set const& inKeys, std::string const& label) const; @@ -222,7 +234,9 @@ class SearchableLiveBucketListSnapshot LedgerEntryType type, std::function callback) const; - friend class BucketSnapshotManager; + friend class BucketSnapshotState; + friend class CompleteConstLedgerState; + friend class LedgerStateSnapshot; }; // Hot archive bucket list snapshot @@ -234,9 +248,13 @@ class SearchableHotArchiveBucketListSnapshot std::shared_ptr const> data, std::map const>> - historicalSnapshots); + historicalSnapshots, + uint32_t ledgerSeq); public: + SearchableHotArchiveBucketListSnapshot( + SearchableHotArchiveBucketListSnapshot const&) = default; + std::vector loadKeys(std::set const& inKeys) const; @@ -245,7 +263,7 @@ class SearchableHotArchiveBucketListSnapshot void scanAllEntries( std::function callback) const; - friend class BucketSnapshotManager; + friend class LedgerStateSnapshot; }; extern template struct BucketListSnapshotData; diff --git a/src/bucket/BucketManager.cpp b/src/bucket/BucketManager.cpp index 99dc31ca37..f190dbabfb 100644 --- a/src/bucket/BucketManager.cpp +++ b/src/bucket/BucketManager.cpp @@ -6,7 +6,6 @@ #include "bucket/BucketInputIterator.h" #include "bucket/BucketManager.h" #include "bucket/BucketOutputIterator.h" -#include "bucket/BucketSnapshotManager.h" #include "bucket/BucketUtils.h" #include "bucket/HotArchiveBucket.h" #include "bucket/HotArchiveBucketList.h" @@ -17,7 +16,7 @@ #include "history/HistoryManager.h" #include "historywork/VerifyBucketWork.h" #include "invariant/InvariantManager.h" -#include "ledger/LedgerManager.h" +#include "ledger/LedgerStateSnapshot.h" #include "ledger/LedgerTxn.h" #include "ledger/LedgerTypeUtils.h" #include "ledger/NetworkConfig.h" @@ -33,8 +32,9 @@ #include "util/MetricsRegistry.h" #include "util/ProtocolVersion.h" #include "util/TmpDir.h" -#include "util/UnorderedMap.h" #include "util/types.h" +#include "work/WorkScheduler.h" +#include "work/WorkSequence.h" #include "xdr/Stellar-ledger.h" #include #include @@ -49,7 +49,6 @@ #include "medida/counter.h" #include "medida/meter.h" #include "medida/timer.h" -#include "work/WorkScheduler.h" #include "xdrpp/printer.h" #include @@ -103,9 +102,6 @@ BucketManager::initialize() mLiveBucketList = std::make_unique(); mHotArchiveBucketList = std::make_unique(); - mSnapshotManager = std::make_unique( - mAppConnector, *mLiveBucketList, *mHotArchiveBucketList, LedgerHeader(), - mConfig.QUERY_SNAPSHOT_LEDGERS); // Create persistent publish directories // Note: HISTORY_FILE_TYPE_BUCKET is already tracked by BucketList in @@ -136,7 +132,6 @@ BucketManager::BucketManager(AppConnector& appConnector) : mAppConnector(appConnector) , mLiveBucketList(nullptr) , mHotArchiveBucketList(nullptr) - , mSnapshotManager(nullptr) , mTmpDirManager(nullptr) , mWorkDir(nullptr) , mLockedBucketDir(nullptr) @@ -318,13 +313,6 @@ BucketManager::getHotArchiveBucketList() return *mHotArchiveBucketList; } -BucketSnapshotManager& -BucketManager::getBucketSnapshotManager() const -{ - releaseAssert(mSnapshotManager); - return *mSnapshotManager; -} - medida::Timer& BucketManager::getMergeTimer() { @@ -1160,29 +1148,27 @@ BucketManager::maybeSetIndex( } void -BucketManager::startBackgroundEvictionScan( - SearchableSnapshotConstPtr lclSnapshot, SorobanNetworkConfig const& cfg) +BucketManager::startBackgroundEvictionScan(ApplyLedgerStateSnapshot lclSnapshot, + SorobanNetworkConfig const& cfg) { - releaseAssert(mSnapshotManager); releaseAssert(!mEvictionFuture.valid()); releaseAssert(mEvictionStatistics); // Start the eviction scan for then _next_ ledger - auto ledgerSeq = lclSnapshot->getLedgerSeq() + 1; - auto ledgerVers = lclSnapshot->getLedgerHeader().ledgerVersion; + auto ledgerSeq = lclSnapshot.getLedgerSeq() + 1; + auto ledgerVers = lclSnapshot.getLedgerHeader().ledgerVersion; auto const& sas = cfg.stateArchivalSettings(); using task_t = std::packaged_task()>; - // MSVC gotcha: searchableBL has to be shared_ptr because MSVC wants to - // copy this lambda, otherwise we could use unique_ptr. auto task = std::make_shared( - [lclSnapshot, iter = cfg.evictionIterator(), ledgerSeq, ledgerVers, sas, - &metrics = mBucketListEvictionMetrics, stats = mEvictionStatistics] { + [snap = std::move(lclSnapshot), iter = cfg.evictionIterator(), + ledgerSeq, ledgerVers, sas, &metrics = mBucketListEvictionMetrics, + stats = mEvictionStatistics]() mutable { auto timer = metrics.backgroundTime.TimeScope(); - return lclSnapshot->scanForEviction(ledgerSeq, metrics, iter, stats, - sas, ledgerVers); + return snap.scanForEviction(ledgerSeq, metrics, iter, stats, sas, + ledgerVers); }); mEvictionFuture = task->get_future(); @@ -1193,7 +1179,7 @@ BucketManager::startBackgroundEvictionScan( EvictedStateVectors BucketManager::resolveBackgroundEvictionScan( - SearchableSnapshotConstPtr lclSnapshot, AbstractLedgerTxn& ltx, + ApplyLedgerStateSnapshot const& lclSnapshot, AbstractLedgerTxn& ltx, LedgerKeySet const& modifiedKeys) { ZoneScoped; @@ -1203,7 +1189,7 @@ BucketManager::resolveBackgroundEvictionScan( auto ledgerSeq = ls.getLedgerHeader().current().ledgerSeq; auto ledgerVers = ls.getLedgerHeader().current().ledgerVersion; auto networkConfig = SorobanNetworkConfig::loadFromLedger(ls); - releaseAssert(ledgerSeq == lclSnapshot->getLedgerSeq() + 1); + releaseAssert(ledgerSeq == lclSnapshot.getLedgerSeq() + 1); if (!mEvictionFuture.valid()) { diff --git a/src/bucket/BucketManager.h b/src/bucket/BucketManager.h index 24da0e171c..2a768db71a 100644 --- a/src/bucket/BucketManager.h +++ b/src/bucket/BucketManager.h @@ -6,6 +6,7 @@ #include "bucket/BucketMergeMap.h" #include "history/HistoryArchive.h" +#include "ledger/LedgerStateSnapshot.h" #include "ledger/NetworkConfig.h" #include "main/Config.h" #include "util/ThreadAnnotations.h" @@ -19,7 +20,6 @@ #include #include #include -#include #include #include @@ -39,7 +39,6 @@ class AppConnector; class Bucket; class LiveBucketList; class HotArchiveBucketList; -class BucketSnapshotManager; class SearchableLiveBucketListSnapshot; struct BucketEntryCounters; enum class LedgerEntryTypeAndDurability : uint32_t; @@ -83,7 +82,6 @@ class BucketManager : NonMovableOrCopyable AppConnector& mAppConnector; std::unique_ptr mLiveBucketList; std::unique_ptr mHotArchiveBucketList; - std::unique_ptr mSnapshotManager; std::unique_ptr mTmpDirManager; std::unique_ptr mWorkDir; BucketMapT mSharedLiveBuckets; @@ -233,7 +231,6 @@ class BucketManager : NonMovableOrCopyable std::string const& getBucketDir() const; LiveBucketList& getLiveBucketList(); HotArchiveBucketList& getHotArchiveBucketList(); - BucketSnapshotManager& getBucketSnapshotManager() const; bool renameBucketDirFile(std::filesystem::path const& src, std::filesystem::path const& dst); @@ -341,7 +338,7 @@ class BucketManager : NonMovableOrCopyable // Scans BucketList for non-live entries to evict starting at the entry // pointed to by EvictionIterator. Evicts until `maxEntriesToEvict` entries // have been evicted or maxEvictionScanSize bytes have been scanned. - void startBackgroundEvictionScan(SearchableSnapshotConstPtr lclSnapshot, + void startBackgroundEvictionScan(ApplyLedgerStateSnapshot lclSnapshot, SorobanNetworkConfig const& networkConfig); // Returns a pair of vectors representing entries evicted this ledger, where @@ -350,7 +347,7 @@ class BucketManager : NonMovableOrCopyable // ContractCode). Note that when an entry is archived, its TTL key will be // included in the deleted keys vector. EvictedStateVectors - resolveBackgroundEvictionScan(SearchableSnapshotConstPtr lclSnapshot, + resolveBackgroundEvictionScan(ApplyLedgerStateSnapshot const& lclSnapshot, AbstractLedgerTxn& ltx, LedgerKeySet const& modifiedKeys); diff --git a/src/bucket/BucketSnapshotManager.cpp b/src/bucket/BucketSnapshotManager.cpp deleted file mode 100644 index cac2d6f0c0..0000000000 --- a/src/bucket/BucketSnapshotManager.cpp +++ /dev/null @@ -1,207 +0,0 @@ -// Copyright 2024 Stellar Development Foundation and contributors. Licensed -// under the Apache License, Version 2.0. See the COPYING file at the root -// of this distribution or at http://www.apache.org/licenses/LICENSE-2.0 - -#include "bucket/BucketSnapshotManager.h" -#include "bucket/BucketListSnapshot.h" -#include "bucket/HotArchiveBucketList.h" -#include "bucket/LiveBucketList.h" -#include "main/AppConnector.h" -#include "util/GlobalChecks.h" -#include "util/MetricsRegistry.h" - -namespace stellar -{ - -BucketSnapshotManager::BucketSnapshotManager( - AppConnector& app, LiveBucketList const& liveBL, - HotArchiveBucketList const& hotArchiveBL, LedgerHeader const& header, - uint32_t numHistoricalLedgers) - : mAppConnector(app) - , mCurrLiveSnapshot( - std::make_shared>(liveBL, header)) - , mCurrHotArchiveSnapshot( - std::make_shared>( - hotArchiveBL, header)) - , mNumHistoricalSnapshots(numHistoricalLedgers) -{ - releaseAssert(threadIsMain()); - releaseAssert(mCurrLiveSnapshot); - releaseAssert(mCurrHotArchiveSnapshot); -} - -SearchableSnapshotConstPtr -BucketSnapshotManager::copySearchableLiveBucketListSnapshot() const -{ - SharedLockShared guard(mSnapshotMutex); - // Can't use std::make_shared due to private constructor - return copySearchableLiveBucketListSnapshot(guard); -} - -SearchableHotArchiveSnapshotConstPtr -BucketSnapshotManager::copySearchableHotArchiveBucketListSnapshot() const -{ - SharedLockShared guard(mSnapshotMutex); - releaseAssert(mCurrHotArchiveSnapshot); - // Can't use std::make_shared due to private constructor - return copySearchableHotArchiveBucketListSnapshot(guard); -} - -SearchableSnapshotConstPtr -BucketSnapshotManager::copySearchableLiveBucketListSnapshot( - SharedLockShared const& guard) const -{ - // Can't use std::make_shared due to private constructor - return std::shared_ptr( - new SearchableLiveBucketListSnapshot(mAppConnector.getMetrics(), - mCurrLiveSnapshot, - mLiveHistoricalSnapshots)); -} - -SearchableSnapshotConstPtr -BucketSnapshotManager::copySearchableLiveBucketListSnapshot( - SearchableSnapshotConstPtr const& snapshot, MetricsRegistry& metrics) -{ - // Can't use std::make_shared due to private constructor - releaseAssert(snapshot); - return std::shared_ptr( - new SearchableLiveBucketListSnapshot( - metrics, snapshot->getSnapshotData(), - snapshot->getHistoricalSnapshots())); -} - -SearchableHotArchiveSnapshotConstPtr -BucketSnapshotManager::copySearchableHotArchiveBucketListSnapshot( - SearchableHotArchiveSnapshotConstPtr const& snapshot, - MetricsRegistry& metrics) -{ - releaseAssert(snapshot); - // Can't use std::make_shared due to private constructor - return std::shared_ptr( - new SearchableHotArchiveBucketListSnapshot( - metrics, snapshot->getSnapshotData(), - snapshot->getHistoricalSnapshots())); -} - -SearchableHotArchiveSnapshotConstPtr -BucketSnapshotManager::copySearchableHotArchiveBucketListSnapshot( - SharedLockShared const& guard) const -{ - releaseAssert(mCurrHotArchiveSnapshot); - // Can't use std::make_shared due to private constructor - return std::shared_ptr( - new SearchableHotArchiveBucketListSnapshot( - mAppConnector.getMetrics(), mCurrHotArchiveSnapshot, - mHotArchiveHistoricalSnapshots)); -} - -namespace -{ -template -bool -needsUpdate(std::shared_ptr const& snapshot, - std::shared_ptr const& currData) -{ - return !snapshot || snapshot->getLedgerSeq() < currData->getLedgerSeq(); -} -} - -void -BucketSnapshotManager::maybeCopySearchableBucketListSnapshot( - SearchableSnapshotConstPtr& snapshot) -{ - // The canonical snapshot held by the BucketSnapshotManager is not being - // modified. Rather, a thread is checking it's copy against the canonical - // snapshot, so use a shared lock. - SharedLockShared guard(mSnapshotMutex); - if (needsUpdate(snapshot, mCurrLiveSnapshot)) - { - snapshot = copySearchableLiveBucketListSnapshot(guard); - } -} - -void -BucketSnapshotManager::maybeCopySearchableHotArchiveBucketListSnapshot( - SearchableHotArchiveSnapshotConstPtr& snapshot) -{ - // The canonical snapshot held by the BucketSnapshotManager is not being - // modified. Rather, a thread is checking it's copy against the canonical - // snapshot, so use a shared lock. - SharedLockShared guard(mSnapshotMutex); - if (needsUpdate(snapshot, mCurrHotArchiveSnapshot)) - { - snapshot = copySearchableHotArchiveBucketListSnapshot(guard); - } -} - -void -BucketSnapshotManager::maybeCopyLiveAndHotArchiveSnapshots( - SearchableSnapshotConstPtr& liveSnapshot, - SearchableHotArchiveSnapshotConstPtr& hotArchiveSnapshot) -{ - // The canonical snapshot held by the BucketSnapshotManager is not being - // modified. Rather, a thread is checking it's copy against the canonical - // snapshot, so use a shared lock. For consistency we hold the lock while - // updating both snapshots. - SharedLockShared guard(mSnapshotMutex); - if (needsUpdate(liveSnapshot, mCurrLiveSnapshot)) - { - liveSnapshot = copySearchableLiveBucketListSnapshot(guard); - } - - if (needsUpdate(hotArchiveSnapshot, mCurrHotArchiveSnapshot)) - { - hotArchiveSnapshot = copySearchableHotArchiveBucketListSnapshot(guard); - } -} - -std::pair -BucketSnapshotManager::copySearchableBucketListSnapshots() const -{ - SharedLockShared guard(mSnapshotMutex); - return {copySearchableLiveBucketListSnapshot(guard), - copySearchableHotArchiveBucketListSnapshot(guard)}; -} - -void -BucketSnapshotManager::updateCurrentSnapshot( - LiveBucketList const& liveBL, HotArchiveBucketList const& hotArchiveBL, - LedgerHeader const& header) -{ - auto updateSnapshot = [numHistoricalSnapshots = mNumHistoricalSnapshots]( - auto& currentSnapshot, auto& historicalSnapshots, - auto newSnapshot) { - releaseAssert(newSnapshot); - releaseAssert(!currentSnapshot || newSnapshot->getLedgerSeq() >= - currentSnapshot->getLedgerSeq()); - - // First update historical snapshots - if (numHistoricalSnapshots != 0) - { - // If historical snapshots are full, delete the oldest one - if (historicalSnapshots.size() == numHistoricalSnapshots) - { - historicalSnapshots.erase(historicalSnapshots.begin()); - } - - historicalSnapshots.emplace(currentSnapshot->getLedgerSeq(), - std::move(currentSnapshot)); - } - - currentSnapshot = std::move(newSnapshot); - }; - - auto newLiveSnapshot = - std::make_shared>(liveBL, header); - auto newHotArchiveSnapshot = - std::make_shared>(hotArchiveBL, - header); - - // Updating canonical snapshots requires exclusive write access - SharedLockExclusive guard(mSnapshotMutex); - updateSnapshot(mCurrLiveSnapshot, mLiveHistoricalSnapshots, - std::move(newLiveSnapshot)); - updateSnapshot(mCurrHotArchiveSnapshot, mHotArchiveHistoricalSnapshots, - std::move(newHotArchiveSnapshot)); -} -} diff --git a/src/bucket/BucketSnapshotManager.h b/src/bucket/BucketSnapshotManager.h deleted file mode 100644 index 09fbaf1575..0000000000 --- a/src/bucket/BucketSnapshotManager.h +++ /dev/null @@ -1,130 +0,0 @@ -#pragma once - -// Copyright 2024 Stellar Development Foundation and contributors. Licensed -// under the Apache License, Version 2.0. See the COPYING file at the root -// of this distribution or at http://www.apache.org/licenses/LICENSE-2.0 - -#include "bucket/BucketListSnapshot.h" -#include "bucket/HotArchiveBucket.h" -#include "bucket/LiveBucket.h" -#include "util/NonCopyable.h" -#include "util/ThreadAnnotations.h" - -#include -#include -#include - -namespace medida -{ -class Meter; -class MetricsRegistry; -class Timer; -} - -namespace stellar -{ - -class AppConnector; -class LiveBucketList; -class HotArchiveBucketList; - -// This class serves as the boundary between non-threadsafe singleton classes -// (BucketManager, BucketList, Metrics, etc) and threadsafe, parallel BucketList -// snapshots. -class BucketSnapshotManager : NonMovableOrCopyable -{ - private: - AppConnector& mAppConnector; - - // Lock must be held when accessing any member variables holding snapshots - mutable SharedMutex mSnapshotMutex; - - // Snapshot that is maintained and periodically updated by BucketManager on - // the main thread. When background threads need to generate or refresh a - // snapshot, they will copy this snapshot. - std::shared_ptr const> - mCurrLiveSnapshot GUARDED_BY(mSnapshotMutex){}; - std::shared_ptr const> - mCurrHotArchiveSnapshot GUARDED_BY(mSnapshotMutex){}; - - // ledgerSeq that the snapshot is based on -> snapshot - std::map const>> - mLiveHistoricalSnapshots GUARDED_BY(mSnapshotMutex); - std::map const>> - mHotArchiveHistoricalSnapshots GUARDED_BY(mSnapshotMutex); - - uint32_t const mNumHistoricalSnapshots; - - public: - // Called by main thread to update snapshots whenever the BucketList - // is updated - void updateCurrentSnapshot(LiveBucketList const& liveBL, - HotArchiveBucketList const& hotArchiveBL, - LedgerHeader const& header) - LOCKS_EXCLUDED(mSnapshotMutex); - - // numHistoricalLedgers is the number of historical snapshots that the - // snapshot manager will maintain. If numHistoricalLedgers is 5, snapshots - // will be capable of querying state from ledger [lcl, lcl - 5]. - BucketSnapshotManager(AppConnector& app, LiveBucketList const& liveBL, - HotArchiveBucketList const& hotArchiveBL, - LedgerHeader const& header, - uint32_t numHistoricalLedgers); - - // Copy the most recent snapshot for the live bucket list - SearchableSnapshotConstPtr copySearchableLiveBucketListSnapshot() const - LOCKS_EXCLUDED(mSnapshotMutex); - - // Create a deep copy from an existing searchable snapshot - static SearchableSnapshotConstPtr copySearchableLiveBucketListSnapshot( - SearchableSnapshotConstPtr const& snapshot, MetricsRegistry& metrics); - - // Create a deep copy from an existing hot archive snapshot - static SearchableHotArchiveSnapshotConstPtr - copySearchableHotArchiveBucketListSnapshot( - SearchableHotArchiveSnapshotConstPtr const& snapshot, - MetricsRegistry& metrics); - - // Copy the most recent snapshot for the hot archive bucket list - SearchableHotArchiveSnapshotConstPtr - copySearchableHotArchiveBucketListSnapshot() const - LOCKS_EXCLUDED(mSnapshotMutex); - - // Copy the most recent snapshot for the live bucket list, while holding the - // lock - SearchableSnapshotConstPtr - copySearchableLiveBucketListSnapshot(SharedLockShared const& guard) const - REQUIRES_SHARED(mSnapshotMutex); - - // Copy the most recent snapshot for the hot archive bucket list, while - // holding the lock - SearchableHotArchiveSnapshotConstPtr - copySearchableHotArchiveBucketListSnapshot( - SharedLockShared const& guard) const REQUIRES_SHARED(mSnapshotMutex); - - // `maybeCopy` interface refreshes `snapshot` if a newer snapshot is - // available. It's a no-op otherwise. This is useful to avoid unnecessary - // copying. - void - maybeCopySearchableBucketListSnapshot(SearchableSnapshotConstPtr& snapshot) - LOCKS_EXCLUDED(mSnapshotMutex); - void maybeCopySearchableHotArchiveBucketListSnapshot( - SearchableHotArchiveSnapshotConstPtr& snapshot) - LOCKS_EXCLUDED(mSnapshotMutex); - - // This function is the same as snapshot refreshers above, but guarantees - // that both snapshots are consistent with the same lcl. This is required - // when querying both snapshot types as part of the same query. - void maybeCopyLiveAndHotArchiveSnapshots( - SearchableSnapshotConstPtr& liveSnapshot, - SearchableHotArchiveSnapshotConstPtr& hotArchiveSnapshot) - LOCKS_EXCLUDED(mSnapshotMutex); - - // Copy both live and hot archive snapshots atomically under a single lock. - // This guarantees both snapshots are from the same ledger. - std::pair - copySearchableBucketListSnapshots() const LOCKS_EXCLUDED(mSnapshotMutex); -}; -} diff --git a/src/bucket/BucketUtils.h b/src/bucket/BucketUtils.h index 16c404838d..4f8361215e 100644 --- a/src/bucket/BucketUtils.h +++ b/src/bucket/BucketUtils.h @@ -35,11 +35,6 @@ class SearchableHotArchiveBucketListSnapshot; std::is_same_v, \ "BucketT must be a Bucket type") -using SearchableSnapshotConstPtr = - std::shared_ptr; -using SearchableHotArchiveSnapshotConstPtr = - std::shared_ptr; - // A fine-grained merge-operation-counter structure for tracking various // events during merges. These are not medida counters because we do not // want or need to publish this level of granularity outside of testing, and diff --git a/src/bucket/test/BucketIndexTests.cpp b/src/bucket/test/BucketIndexTests.cpp index b506ed4759..4bb07c4949 100644 --- a/src/bucket/test/BucketIndexTests.cpp +++ b/src/bucket/test/BucketIndexTests.cpp @@ -6,13 +6,13 @@ // concerning key-value lookup based on the BucketList. #include "bucket/BucketIndexUtils.h" -#include "bucket/BucketInputIterator.h" #include "bucket/BucketManager.h" -#include "bucket/BucketSnapshotManager.h" #include "bucket/BucketUtils.h" #include "bucket/LiveBucket.h" #include "bucket/LiveBucketList.h" #include "bucket/test/BucketTestUtils.h" +#include "ledger/LedgerManager.h" +#include "ledger/LedgerStateSnapshot.h" #include "ledger/LedgerTypeUtils.h" #include "ledger/test/LedgerTestUtils.h" #include "main/Application.h" @@ -215,12 +215,10 @@ class BucketIndexTest } while (ledger < mApp->getConfig().QUERY_SNAPSHOT_LEDGERS + 2); ++ledger; - auto searchableBL = getBM() - .getBucketSnapshotManager() - .copySearchableLiveBucketListSnapshot(); + auto snap = getApp().getLedgerManager().copyLedgerStateSnapshot(); auto lk = LedgerEntryKey(canonicalEntry); - auto currentLoadedEntry = searchableBL->load(lk); + auto currentLoadedEntry = snap.loadLiveEntry(lk); REQUIRE(currentLoadedEntry); // Note: The definition of "historical snapshot" ledger is that the @@ -231,7 +229,7 @@ class BucketIndexTest for (uint32_t currLedger = ledger; currLedger > 0; --currLedger) { - auto loadRes = searchableBL->loadKeysFromLedger({lk}, currLedger); + auto loadRes = snap.loadLiveKeysFromLedger({lk}, currLedger); // If we query an older snapshot, should return if (currLedger < ledger - mApp->getConfig().QUERY_SNAPSHOT_LEDGERS) @@ -413,9 +411,7 @@ class BucketIndexTest virtual void run(std::optional expectedHitRate = std::nullopt) { - auto searchableBL = getBM() - .getBucketSnapshotManager() - .copySearchableLiveBucketListSnapshot(); + auto snap = getApp().getLedgerManager().copyLedgerStateSnapshot(); auto& hitMeter = getBM().getCacheHitMeter(); auto& missMeter = getBM().getCacheMissMeter(); @@ -483,7 +479,7 @@ class BucketIndexTest }; // Test bulk load lookup - auto loadResult = searchableBL->loadKeys(mKeysToSearch, "test"); + auto loadResult = snap.loadLiveKeys(mKeysToSearch, "test"); validateResults(mTestEntries, loadResult); if (expectedHitRate) @@ -517,7 +513,7 @@ class BucketIndexTest for (auto iter = mKeysToSearch.rbegin(); iter != mKeysToSearch.rend(); ++iter) { - auto entryPtr = searchableBL->load(*iter); + auto entryPtr = snap.loadLiveEntry(*iter); if (entryPtr) { loadResult.emplace_back(*entryPtr); @@ -532,7 +528,7 @@ class BucketIndexTest mKeysToSearch.size()); // Run bulk lookup again - auto loadResult2 = searchableBL->loadKeys(mKeysToSearch, "test"); + auto loadResult2 = snap.loadLiveKeys(mKeysToSearch, "test"); validateResults(mTestEntries, loadResult2); checkHitRate(expectedHitRate, startingHitCount, startingMissCount, @@ -544,9 +540,7 @@ class BucketIndexTest virtual void runPerf(size_t n) { - auto searchableBL = getBM() - .getBucketSnapshotManager() - .copySearchableLiveBucketListSnapshot(); + auto snap = getApp().getLedgerManager().copyLedgerStateSnapshot(); for (size_t i = 0; i < n; ++i) { LedgerKeySet searchSubset; @@ -577,7 +571,7 @@ class BucketIndexTest searchSubset.insert(addKeys.begin(), addKeys.end()); } - auto blLoad = searchableBL->loadKeys(searchSubset, "test"); + auto blLoad = snap.loadLiveKeys(searchSubset, "test"); validateResults(testEntriesSubset, blLoad); } } @@ -585,9 +579,7 @@ class BucketIndexTest void testInvalidKeys() { - auto searchableBL = getBM() - .getBucketSnapshotManager() - .copySearchableLiveBucketListSnapshot(); + auto snap = getApp().getLedgerManager().copyLedgerStateSnapshot(); // Load should return empty vector for keys not in bucket list auto keysNotInBL = @@ -597,12 +589,12 @@ class BucketIndexTest LedgerKeySet invalidKeys(keysNotInBL.begin(), keysNotInBL.end()); // Test bulk load - REQUIRE(searchableBL->loadKeys(invalidKeys, "test").size() == 0); + REQUIRE(snap.loadLiveKeys(invalidKeys, "test").size() == 0); // Test individual load for (auto const& key : invalidKeys) { - auto entryPtr = searchableBL->load(key); + auto entryPtr = snap.loadLiveEntry(key); REQUIRE(!entryPtr); } } @@ -756,12 +748,9 @@ class BucketIndexPoolShareTest : public BucketIndexTest virtual void run(std::optional expectedHitRate = std::nullopt) override { - auto searchableBL = getBM() - .getBucketSnapshotManager() - .copySearchableLiveBucketListSnapshot(); - auto loadResult = - searchableBL->loadPoolShareTrustLinesByAccountAndAsset( - mAccountToSearch.accountID, mAssetToSearch); + auto snap = getApp().getLedgerManager().copyLedgerStateSnapshot(); + auto loadResult = snap.loadPoolShareTrustLinesByAccountAndAsset( + mAccountToSearch.accountID, mAssetToSearch); validateResults(mTestEntries, loadResult); } }; @@ -1117,9 +1106,8 @@ TEST_CASE("soroban cache population", "[soroban][bucketindex]") auto const& inMemorySorobanState = lm.getInMemorySorobanStateForTesting(); - auto snapshot = test.getBM() - .getBucketSnapshotManager() - .copySearchableLiveBucketListSnapshot(); + auto snapshot = + test.getApp().getLedgerManager().copyLedgerStateSnapshot(); // First, test that the cache is maintained correctly via `addBatch` REQUIRE(codeEntries.size() == @@ -1129,12 +1117,12 @@ TEST_CASE("soroban cache population", "[soroban][bucketindex]") auto inMemoryEntry = inMemorySorobanState.get(k); REQUIRE(inMemoryEntry); - auto liveEntry = snapshot->load(k); + auto liveEntry = snapshot.loadLiveEntry(k); REQUIRE(liveEntry); REQUIRE(*liveEntry == *inMemoryEntry); auto ttlKey = getTTLKey(k); - auto ttlEntry = snapshot->load(ttlKey); + auto ttlEntry = snapshot.loadLiveEntry(ttlKey); REQUIRE(ttlEntry); auto inMemoryTTL = inMemorySorobanState.get(ttlKey); @@ -1149,12 +1137,12 @@ TEST_CASE("soroban cache population", "[soroban][bucketindex]") auto inMemoryEntry = inMemorySorobanState.get(k); REQUIRE(inMemoryEntry); - auto liveEntry = snapshot->load(k); + auto liveEntry = snapshot.loadLiveEntry(k); REQUIRE(liveEntry); REQUIRE(*liveEntry == *inMemoryEntry); auto ttlKey = getTTLKey(k); - auto ttlEntry = snapshot->load(ttlKey); + auto ttlEntry = snapshot.loadLiveEntry(ttlKey); REQUIRE(ttlEntry); auto inMemoryTTL = inMemorySorobanState.get(ttlKey); @@ -1327,9 +1315,7 @@ TEST_CASE("hot archive bucket lookups", "[bucket][bucketindex][archive]") auto ledger = 1; // Use snapshot across ledger to test update behavior - auto searchableBL = app->getBucketManager() - .getBucketSnapshotManager() - .copySearchableHotArchiveBucketListSnapshot(); + auto snap = app->getLedgerManager().copyLedgerStateSnapshot(); auto checkLoad = [&](LedgerKey const& k, @@ -1356,12 +1342,12 @@ TEST_CASE("hot archive bucket lookups", "[bucket][bucketindex][archive]") LedgerKeySet bulkLoadKeys; for (auto const& k : keysToSearch) { - auto entryPtr = searchableBL->load(k); + auto entryPtr = snap.loadArchiveEntry(k); checkLoad(k, entryPtr); bulkLoadKeys.emplace(k); } - auto bulkLoadResult = searchableBL->loadKeys(bulkLoadKeys); + auto bulkLoadResult = snap.loadArchiveKeys(bulkLoadKeys); for (auto entry : bulkLoadResult) { REQUIRE(entry.type() == HOT_ARCHIVE_ARCHIVED); @@ -1402,9 +1388,7 @@ TEST_CASE("hot archive bucket lookups", "[bucket][bucketindex][archive]") HotArchiveBucket::FIRST_PROTOCOL_SUPPORTING_PERSISTENT_EVICTION); addHotArchiveBatchAndUpdateSnapshot(*app, header, archivedEntries, restoredEntries); - app->getBucketManager() - .getBucketSnapshotManager() - .maybeCopySearchableHotArchiveBucketListSnapshot(searchableBL); + snap = app->getLedgerManager().copyLedgerStateSnapshot(); checkResult(); // Add a few batches so that entries are no longer in the top bucket @@ -1412,9 +1396,7 @@ TEST_CASE("hot archive bucket lookups", "[bucket][bucketindex][archive]") { header.ledgerSeq += 1; addHotArchiveBatchAndUpdateSnapshot(*app, header, {}, {}); - app->getBucketManager() - .getBucketSnapshotManager() - .maybeCopySearchableHotArchiveBucketListSnapshot(searchableBL); + snap = app->getLedgerManager().copyLedgerStateSnapshot(); } // Shadow entries via liveEntry @@ -1424,20 +1406,17 @@ TEST_CASE("hot archive bucket lookups", "[bucket][bucketindex][archive]") header.ledgerSeq += 1; addHotArchiveBatchAndUpdateSnapshot(*app, header, {}, {liveShadow1, liveShadow2}); - app->getBucketManager() - .getBucketSnapshotManager() - .maybeCopySearchableHotArchiveBucketListSnapshot(searchableBL); + snap = app->getLedgerManager().copyLedgerStateSnapshot(); // Point load for (auto const& k : {liveShadow1, liveShadow2}) { - auto entryPtr = searchableBL->load(k); + auto entryPtr = snap.loadArchiveEntry(k); REQUIRE(!entryPtr); } // Bulk load - auto bulkLoadResult = - searchableBL->loadKeys({liveShadow1, liveShadow2}); + auto bulkLoadResult = snap.loadArchiveKeys({liveShadow1, liveShadow2}); REQUIRE(bulkLoadResult.size() == 0); // Shadow via archivedEntries @@ -1446,12 +1425,10 @@ TEST_CASE("hot archive bucket lookups", "[bucket][bucketindex][archive]") header.ledgerSeq += 1; addHotArchiveBatchAndUpdateSnapshot(*app, header, {archivedShadow}, {}); - app->getBucketManager() - .getBucketSnapshotManager() - .maybeCopySearchableHotArchiveBucketListSnapshot(searchableBL); + snap = app->getLedgerManager().copyLedgerStateSnapshot(); // Point load - auto entryPtr = searchableBL->load(LedgerEntryKey(archivedShadow)); + auto entryPtr = snap.loadArchiveEntry(LedgerEntryKey(archivedShadow)); REQUIRE(entryPtr); REQUIRE(entryPtr->type() == HotArchiveBucketEntryType::HOT_ARCHIVE_ARCHIVED); @@ -1459,7 +1436,7 @@ TEST_CASE("hot archive bucket lookups", "[bucket][bucketindex][archive]") // Bulk load auto bulkLoadResult2 = - searchableBL->loadKeys({LedgerEntryKey(archivedShadow)}); + snap.loadArchiveKeys({LedgerEntryKey(archivedShadow)}); REQUIRE(bulkLoadResult2.size() == 1); REQUIRE(bulkLoadResult2[0].type() == HOT_ARCHIVE_ARCHIVED); REQUIRE(bulkLoadResult2[0].archivedEntry() == archivedShadow); @@ -1626,9 +1603,7 @@ TEST_CASE("getRangeForType bounds verification", "[bucket][bucketindex]") .getCurr(); verifyIndexBounds(bucket); - auto searchableBL = app->getBucketManager() - .getBucketSnapshotManager() - .copySearchableLiveBucketListSnapshot(); + auto snap = app->getLedgerManager().copyLedgerStateSnapshot(); auto verifyScanForType = [&](LedgerEntryType type, @@ -1641,7 +1616,7 @@ TEST_CASE("getRangeForType bounds verification", "[bucket][bucketindex]") expectedEntries.emplace(LedgerEntryKey(entry), entry); } - searchableBL->scanForEntriesOfType( + snap.scanLiveEntriesOfType( type, [&](BucketEntry const& be) { auto lk = getBucketLedgerKey(be); REQUIRE(lk.type() == type); @@ -1662,11 +1637,11 @@ TEST_CASE("getRangeForType bounds verification", "[bucket][bucketindex]") verifyScanForType(TRUSTLINE, trustlineEntries); // Verify that we don't call the callback for non-existent types - searchableBL->scanForEntriesOfType(CONTRACT_CODE, - [&](BucketEntry const& be) { - REQUIRE(false); - return Loop::INCOMPLETE; - }); + snap.scanLiveEntriesOfType(CONTRACT_CODE, + [&](BucketEntry const& be) { + REQUIRE(false); + return Loop::INCOMPLETE; + }); } }; diff --git a/src/bucket/test/BucketListTests.cpp b/src/bucket/test/BucketListTests.cpp index 3ace5ad01a..b58c7788bf 100644 --- a/src/bucket/test/BucketListTests.cpp +++ b/src/bucket/test/BucketListTests.cpp @@ -6,10 +6,6 @@ // concerning the sizes of levels in it, shadowing, the propagation and // archival of entries as they move between levels, and so forth. -// ASIO is somewhat particular about when it gets included -- it wants to be the -// first to include -- so we try to include it before everything -// else. -#include "util/asio.h" #include "bucket/BucketInputIterator.h" #include "bucket/BucketManager.h" #include "bucket/BucketOutputIterator.h" @@ -19,12 +15,12 @@ #include "bucket/LiveBucketList.h" #include "bucket/test/BucketTestUtils.h" #include "crypto/Hex.h" +#include "ledger/LedgerStateSnapshot.h" #include "ledger/LedgerTypeUtils.h" #include "ledger/test/LedgerTestUtils.h" #include "lib/util/stdrandom.h" #include "main/Application.h" #include "main/Config.h" -#include "test/Catch2.h" #include "test/TestUtils.h" #include "test/test.h" #include "util/Math.h" @@ -1213,15 +1209,14 @@ TEST_CASE_VERSIONS("eviction scan", "[bucketlist][archival][soroban]") auto checkArchivedBucketList = [&] { if (!tempOnly) { - auto archiveSnapshot = - bm.getBucketSnapshotManager() - .copySearchableHotArchiveBucketListSnapshot(); + auto archiveSnap = + app->getLedgerManager().copyLedgerStateSnapshot(); // Check that persisted entries have been inserted into // HotArchive for (auto const& k : persistentEntries) { - auto archivedEntry = archiveSnapshot->load(k); + auto archivedEntry = archiveSnap.loadArchiveEntry(k); REQUIRE(archivedEntry); auto seen = false; @@ -1237,14 +1232,14 @@ TEST_CASE_VERSIONS("eviction scan", "[bucketlist][archival][soroban]") // Make sure TTL keys are not archived auto ttl = getTTLKey(k); - auto archivedTTL = archiveSnapshot->load(ttl); + auto archivedTTL = archiveSnap.loadArchiveEntry(ttl); REQUIRE(!archivedTTL); } // Temp entries should not be archived for (auto const& k : tempEntries) { - auto archivedEntry = archiveSnapshot->load(k); + auto archivedEntry = archiveSnap.loadArchiveEntry(k); REQUIRE(!archivedEntry); } } @@ -1727,11 +1722,10 @@ TEST_CASE_VERSIONS("Searchable BucketListDB snapshots", "[bucketlist]") } closeLedger(*app); - auto searchableBL = bm.getBucketSnapshotManager() - .copySearchableLiveBucketListSnapshot(); + auto blSnap = app->getLedgerManager().copyLedgerStateSnapshot(); // Snapshot should automatically update with latest version - auto loadedEntry = searchableBL->load(LedgerEntryKey(entry)); + auto loadedEntry = blSnap.loadLiveEntry(LedgerEntryKey(entry)); REQUIRE((loadedEntry && *loadedEntry == entry)); } } diff --git a/src/bucket/test/BucketTestUtils.cpp b/src/bucket/test/BucketTestUtils.cpp index ae0d0f8e26..8b40088fa0 100644 --- a/src/bucket/test/BucketTestUtils.cpp +++ b/src/bucket/test/BucketTestUtils.cpp @@ -9,6 +9,7 @@ #include "bucket/LiveBucket.h" #include "crypto/Hex.h" #include "herder/Herder.h" +#include "ledger/LedgerManager.h" #include "ledger/LedgerTxn.h" #include "main/Application.h" #include "test/test.h" @@ -44,8 +45,7 @@ addLiveBatchAndUpdateSnapshot(Application& app, LedgerHeader header, liveBl.addBatch(app, header.ledgerSeq, header.ledgerVersion, initEntries, liveEntries, deadEntries); - app.getBucketManager().getBucketSnapshotManager().updateCurrentSnapshot( - liveBl, app.getBucketManager().getHotArchiveBucketList(), header); + app.getLedgerManager().updateCanonicalStateForTesting(header); } void @@ -57,8 +57,7 @@ addHotArchiveBatchAndUpdateSnapshot( auto& hotArchiveBl = app.getBucketManager().getHotArchiveBucketList(); hotArchiveBl.addBatch(app, header.ledgerSeq, header.ledgerVersion, archiveEntries, restoredEntries); - app.getBucketManager().getBucketSnapshotManager().updateCurrentSnapshot( - app.getBucketManager().getLiveBucketList(), hotArchiveBl, header); + app.getLedgerManager().updateCanonicalStateForTesting(header); } void @@ -173,11 +172,9 @@ countEntries(std::shared_ptr bucket) template size_t countEntries(std::shared_ptr bucket); template size_t countEntries(std::shared_ptr bucket); -void +std::optional LedgerManagerForBucketTests::finalizeLedgerTxnChanges( - SearchableSnapshotConstPtr lclSnapshot, - SearchableHotArchiveSnapshotConstPtr lclHotArchiveSnapshot, - AbstractLedgerTxn& ltx, + ApplyLedgerStateSnapshot const& lclSnapshot, AbstractLedgerTxn& ltx, std::unique_ptr const& ledgerCloseMeta, LedgerHeader lh, uint32_t initialLedgerVers) { @@ -262,14 +259,9 @@ LedgerManagerForBucketTests::finalizeLedgerTxnChanges( ltx, mApp); } - // Load the final Soroban config just before sealing the ltx. - std::optional finalSorobanConfig; - if (protocolVersionStartsFrom(lh.ledgerVersion, - SOROBAN_PROTOCOL_VERSION)) - { - finalSorobanConfig = - std::make_optional(SorobanNetworkConfig::loadFromLedger(ltx)); - } + // Seal the ltx and collect its entries, but don't load Soroban + // config yet -- test entries (including network config like eviction + // iterator) are added directly to the BucketList below, not via ltx. ltx.getAllEntries(init, live, dead); // Add dead entries from ltx to entries that will be added to BucketList @@ -310,6 +302,22 @@ LedgerManagerForBucketTests::finalizeLedgerTxnChanges( mApp.getBucketManager().addLiveBatch( mApp, lh, mTestInitEntries, mTestLiveEntries, mTestDeadEntries); + // Load the final Soroban config AFTER addLiveBatch so that test + // entries (e.g. stateArchivalSettings with eviction iterator) are + // visible. We load from a BucketList snapshot rather than ltx + // because test entries bypass ltx entirely. + std::optional finalSorobanConfig; + if (protocolVersionStartsFrom(lh.ledgerVersion, + SOROBAN_PROTOCOL_VERSION)) + { + auto liveData = + std::make_shared>( + mApp.getBucketManager().getLiveBucketList()); + LedgerSnapshot ls(mApp.getMetrics(), std::move(liveData), lh); + finalSorobanConfig = + std::make_optional(SorobanNetworkConfig::loadFromLedger(ls)); + } + mApplyState.updateInMemorySorobanState( mTestInitEntries, mTestLiveEntries, mTestDeadEntries, lh, finalSorobanConfig); @@ -322,12 +330,12 @@ LedgerManagerForBucketTests::finalizeLedgerTxnChanges( mTestArchiveEntries.clear(); mTestRestoredEntries.clear(); mTestDeletedEntries.clear(); + return finalSorobanConfig; } else { - LedgerManagerImpl::finalizeLedgerTxnChanges( - lclSnapshot, lclHotArchiveSnapshot, ltx, ledgerCloseMeta, lh, - initialLedgerVers); + return LedgerManagerImpl::finalizeLedgerTxnChanges( + lclSnapshot, ltx, ledgerCloseMeta, lh, initialLedgerVers); } } diff --git a/src/bucket/test/BucketTestUtils.h b/src/bucket/test/BucketTestUtils.h index 96b57f41f2..003d401d54 100644 --- a/src/bucket/test/BucketTestUtils.h +++ b/src/bucket/test/BucketTestUtils.h @@ -72,10 +72,8 @@ class LedgerManagerForBucketTests : public LedgerManagerImpl std::vector mTestDeletedEntries; protected: - void finalizeLedgerTxnChanges( - SearchableSnapshotConstPtr lclSnapshot, - SearchableHotArchiveSnapshotConstPtr lclHotArchiveSnapshot, - AbstractLedgerTxn& ltx, + std::optional finalizeLedgerTxnChanges( + ApplyLedgerStateSnapshot const& lclSnapshot, AbstractLedgerTxn& ltx, std::unique_ptr const& ledgerCloseMeta, LedgerHeader lh, uint32_t initialLedgerVers) override; diff --git a/src/herder/HerderImpl.cpp b/src/herder/HerderImpl.cpp index 644e03428a..8fa036f0e7 100644 --- a/src/herder/HerderImpl.cpp +++ b/src/herder/HerderImpl.cpp @@ -5,7 +5,6 @@ #include "herder/HerderImpl.h" #include "bucket/BucketManager.h" -#include "bucket/BucketSnapshotManager.h" #include "crypto/Hex.h" #include "crypto/KeyUtils.h" #include "crypto/SHA.h" @@ -29,10 +28,8 @@ #include "medida/counter.h" #include "medida/meter.h" #include "overlay/OverlayManager.h" -#include "process/ProcessManager.h" #include "scp/LocalNode.h" #include "scp/Slot.h" -#include "transactions/MutableTransactionResult.h" #include "transactions/TransactionUtils.h" #include "util/DebugMetaUtils.h" #include "util/Decoder.h" diff --git a/src/herder/test/HerderTests.cpp b/src/herder/test/HerderTests.cpp index 71b2b8b86d..71a911e87f 100644 --- a/src/herder/test/HerderTests.cpp +++ b/src/herder/test/HerderTests.cpp @@ -5054,7 +5054,7 @@ TEST_CASE("ledger state update flow with parallel apply", "[herder][parallel]") REQUIRE(lm.getLastClosedLedgerNum() == lcl); REQUIRE(lm.getLastClosedLedgerHAS().currentLedger == lastHeader.ledgerSeq); - REQUIRE(lm.getLastClosedSnapshot()->getLedgerHeader() == + REQUIRE(lm.copyLedgerStateSnapshot().getLedgerHeader() == lastHeader); // Apply state got committed, but has not yet been propagated to @@ -5107,7 +5107,7 @@ TEST_CASE("ledger state update flow with parallel apply", "[herder][parallel]") auto readOnly = lm.getLastClosedLedgerHeader(); REQUIRE(readOnly.header.ledgerSeq == lcl + 1); REQUIRE(lm.getLastClosedLedgerNum() == lcl + 1); - REQUIRE(lm.getLastClosedSnapshot()->getLedgerHeader() == + REQUIRE(lm.copyLedgerStateSnapshot().getLedgerHeader() == readOnly.header); auto has = lm.getLastClosedLedgerHAS(); REQUIRE(has.currentLedger == readOnly.header.ledgerSeq); diff --git a/src/herder/test/UpgradesTests.cpp b/src/herder/test/UpgradesTests.cpp index 3d736cada2..07d6aa4c43 100644 --- a/src/herder/test/UpgradesTests.cpp +++ b/src/herder/test/UpgradesTests.cpp @@ -14,6 +14,7 @@ #include "herder/Upgrades.h" #include "history/HistoryArchiveManager.h" #include "history/test/HistoryTestsUtils.h" +#include "ledger/LedgerStateSnapshot.h" #include "ledger/LedgerTxn.h" #include "ledger/LedgerTxnEntry.h" #include "ledger/LedgerTxnHeader.h" @@ -4056,8 +4057,7 @@ TEST_CASE("p24 upgrade fixes corrupted hot archive entries", }; auto runUpgradeAndGetSnapshot = [&]() { executeUpgrade(*app, makeProtocolVersionUpgrade(fixedProtocolVersion)); - return app->getAppConnector() - .copySearchableHotArchiveBucketListSnapshot(); + return app->getAppConnector().copyLedgerStateSnapshot(); }; auto const& corruptedEntries = p23_hot_archive_bug::internal::P23_CORRUPTED_HOT_ARCHIVE_ENTRIES; @@ -4077,10 +4077,10 @@ TEST_CASE("p24 upgrade fixes corrupted hot archive entries", BucketTestUtils::addHotArchiveBatchAndUpdateSnapshot( *app, app->getLedgerManager().getLastClosedLedgerHeader().header, allCorruptedEntries, {}); - auto hotArchiveSnapshot = runUpgradeAndGetSnapshot(); + auto snap = runUpgradeAndGetSnapshot(); for (auto const& [key, expectedEntry] : allExpectedFixedByKey) { - auto actual = hotArchiveSnapshot->load(key); + auto actual = snap.loadArchiveEntry(key); REQUIRE(actual); REQUIRE(actual->archivedEntry() == expectedEntry); } @@ -4092,8 +4092,8 @@ TEST_CASE("p24 upgrade fixes corrupted hot archive entries", BucketTestUtils::addHotArchiveBatchAndUpdateSnapshot( *app, app->getLedgerManager().getLastClosedLedgerHeader().header, allCorruptedEntries, {}); - auto hotArchiveSnapshot = runUpgradeAndGetSnapshot(); - auto actual = hotArchiveSnapshot->load(removedKey); + auto snap = runUpgradeAndGetSnapshot(); + auto actual = snap.loadArchiveEntry(removedKey); REQUIRE(!actual); } } diff --git a/src/invariant/ArchivedStateConsistency.cpp b/src/invariant/ArchivedStateConsistency.cpp index 102988a1a7..acaa41403c 100644 --- a/src/invariant/ArchivedStateConsistency.cpp +++ b/src/invariant/ArchivedStateConsistency.cpp @@ -4,11 +4,9 @@ #include "invariant/ArchivedStateConsistency.h" #include "bucket/BucketListSnapshot.h" -#include "bucket/BucketSnapshotManager.h" -#include "bucket/HotArchiveBucket.h" #include "bucket/LedgerCmp.h" #include "invariant/InvariantManager.h" -#include "ledger/LedgerManager.h" +#include "ledger/LedgerStateSnapshot.h" #include "ledger/LedgerTypeUtils.h" #include "main/Application.h" #include "transactions/TransactionUtils.h" @@ -40,8 +38,7 @@ ArchivedStateConsistency::getName() const std::string ArchivedStateConsistency::checkOnLedgerCommit( - SearchableSnapshotConstPtr lclLiveState, - SearchableHotArchiveSnapshotConstPtr lclHotArchiveState, + ApplyLedgerStateSnapshot const& lclSnapshot, std::vector const& persitentEvictedFromLive, std::vector const& tempAndTTLEvictedFromLive, UnorderedMap const& restoredFromArchive, @@ -51,14 +48,15 @@ ArchivedStateConsistency::checkOnLedgerCommit( LogSlowExecution::Mode::AUTOMATIC_RAII, "took", std::chrono::milliseconds(1)); + auto ledgerSeq = lclSnapshot.getLedgerSeq() + 1; + auto ledgerVers = lclSnapshot.getLedgerHeader().ledgerVersion; + if (protocolVersionIsBefore( - lclLiveState->getLedgerHeader().ledgerVersion, + ledgerVers, LiveBucket::FIRST_PROTOCOL_SUPPORTING_PERSISTENT_EVICTION)) { return std::string{}; } - auto ledgerSeq = lclLiveState->getLedgerSeq() + 1; - auto ledgerVers = lclLiveState->getLedgerHeader().ledgerVersion; // Collect all keys to preload LedgerKeySet allKeys; @@ -95,13 +93,13 @@ ArchivedStateConsistency::checkOnLedgerCommit( // Preload from both live and archived state UnorderedMap preloadedLiveEntries; auto preloadedLiveVector = - lclLiveState->loadKeys(allKeys, "ArchivedStateConsistency"); + lclSnapshot.loadLiveKeys(allKeys, "ArchivedStateConsistency"); for (auto const& entry : preloadedLiveVector) { preloadedLiveEntries[LedgerEntryKey(entry)] = entry; } - auto preloadedArchivedVector = lclHotArchiveState->loadKeys(allKeys); + auto preloadedArchivedVector = lclSnapshot.loadArchiveKeys(allKeys); UnorderedMap preloadedArchivedEntries; for (auto const& entry : preloadedArchivedVector) { diff --git a/src/invariant/ArchivedStateConsistency.h b/src/invariant/ArchivedStateConsistency.h index 9d0e622794..795c2d90be 100644 --- a/src/invariant/ArchivedStateConsistency.h +++ b/src/invariant/ArchivedStateConsistency.h @@ -34,8 +34,7 @@ class ArchivedStateConsistency : public Invariant virtual std::string getName() const override; virtual std::string checkOnLedgerCommit( - SearchableSnapshotConstPtr lclLiveState, - SearchableHotArchiveSnapshotConstPtr lclHotArchiveState, + ApplyLedgerStateSnapshot const& lclSnapshot, std::vector const& persitentEvictedFromLive, std::vector const& tempAndTTLEvictedFromLive, UnorderedMap const& restoredFromArchive, diff --git a/src/invariant/BucketListStateConsistency.cpp b/src/invariant/BucketListStateConsistency.cpp index 30dd33ec54..53bd905c86 100644 --- a/src/invariant/BucketListStateConsistency.cpp +++ b/src/invariant/BucketListStateConsistency.cpp @@ -8,6 +8,7 @@ #include "invariant/Invariant.h" #include "invariant/InvariantManager.h" #include "ledger/InMemorySorobanState.h" +#include "ledger/LedgerStateSnapshot.h" #include "ledger/LedgerTypeUtils.h" #include "ledger/NetworkConfig.h" #include "main/Application.h" @@ -35,15 +36,14 @@ BucketListStateConsistency::BucketListStateConsistency() : Invariant(true) // 7. The cached total entry sizes match the sum of actual entry sizes std::string BucketListStateConsistency::checkSnapshot( - SearchableSnapshotConstPtr liveSnapshot, - SearchableHotArchiveSnapshotConstPtr hotArchiveSnapshot, + ApplyLedgerStateSnapshot const& snapshot, InMemorySorobanState const& inMemorySnapshot, std::function isStopping) { LogSlowExecution logSlow("BucketListStateConsistency::checkSnapshot", LogSlowExecution::Mode::AUTOMATIC_RAII, "took", std::chrono::minutes(2)); - auto const& header = liveSnapshot->getLedgerHeader(); + auto const& header = snapshot.getLedgerHeader(); if (protocolVersionIsBefore(header.ledgerVersion, SOROBAN_PROTOCOL_VERSION)) { @@ -66,13 +66,14 @@ BucketListStateConsistency::checkSnapshot( std::string errorMsg; // Property 7: Track total entry sizes for validation - auto sorobanConfig = SorobanNetworkConfig::loadFromLedger(liveSnapshot); + LedgerSnapshot lsForConfig(snapshot); + auto sorobanConfig = SorobanNetworkConfig::loadFromLedger(lsForConfig); uint64_t expectedSorobanSize = 0; auto checkLiveEntry = [&seenLiveNonTTLKeys, &seenDeadKeys, &errorMsg, - &inMemorySnapshot, &hotArchiveSnapshot, - checkHotArchive, &isStopping, &expectedSorobanSize, - &header, &sorobanConfig](BucketEntry const& be) { + &inMemorySnapshot, &snapshot, checkHotArchive, + &isStopping, &expectedSorobanSize, &header, + &sorobanConfig](BucketEntry const& be) { if (isStopping()) { return Loop::COMPLETE; @@ -116,7 +117,7 @@ BucketListStateConsistency::checkSnapshot( } // Check property 5: live entry should not exist in hot archive - if (checkHotArchive && hotArchiveSnapshot->load(lk)) + if (checkHotArchive && snapshot.loadArchiveEntry(lk)) { errorMsg = fmt::format( FMT_STRING("BucketListStateConsistency invariant failed: " @@ -158,7 +159,7 @@ BucketListStateConsistency::checkSnapshot( }; // First check contract data entries. - liveSnapshot->scanForEntriesOfType(CONTRACT_DATA, checkLiveEntry); + snapshot.scanLiveEntriesOfType(CONTRACT_DATA, checkLiveEntry); // Note: All BucketList scans will exit early if isStopping() is true or if // there is an error, so we need to call shouldAbortInvariantScan after each @@ -175,7 +176,7 @@ BucketListStateConsistency::checkSnapshot( // keys since we will need them when checking TTL entries. seenDeadKeys.clear(); - liveSnapshot->scanForEntriesOfType(CONTRACT_CODE, checkLiveEntry); + snapshot.scanLiveEntriesOfType(CONTRACT_CODE, checkLiveEntry); if (shouldAbortInvariantScan(errorMsg, isStopping)) { return errorMsg; @@ -304,7 +305,7 @@ BucketListStateConsistency::checkSnapshot( }; seenDeadKeys.clear(); - liveSnapshot->scanForEntriesOfType(TTL, checkTTLEntry); + snapshot.scanLiveEntriesOfType(TTL, checkTTLEntry); if (shouldAbortInvariantScan(errorMsg, isStopping)) { return errorMsg; @@ -376,7 +377,7 @@ BucketListStateConsistency::checkSnapshot( return Loop::INCOMPLETE; }; - hotArchiveSnapshot->scanAllEntries(checkHotArchiveEntry); + snapshot.scanAllArchiveEntries(checkHotArchiveEntry); if (shouldAbortInvariantScan(errorMsg, isStopping)) { return errorMsg; diff --git a/src/invariant/BucketListStateConsistency.h b/src/invariant/BucketListStateConsistency.h index 6c555fe092..e8595470e1 100644 --- a/src/invariant/BucketListStateConsistency.h +++ b/src/invariant/BucketListStateConsistency.h @@ -19,8 +19,7 @@ class BucketListStateConsistency : public Invariant virtual std::string getName() const override; virtual std::string - checkSnapshot(SearchableSnapshotConstPtr liveSnapshot, - SearchableHotArchiveSnapshotConstPtr hotArchiveSnapshot, + checkSnapshot(ApplyLedgerStateSnapshot const& snapshot, InMemorySorobanState const& inMemorySnapshot, std::function isStopping) override; }; diff --git a/src/invariant/ConservationOfLumens.cpp b/src/invariant/ConservationOfLumens.cpp index 535a4532fb..f3d9795684 100644 --- a/src/invariant/ConservationOfLumens.cpp +++ b/src/invariant/ConservationOfLumens.cpp @@ -6,6 +6,7 @@ #include "invariant/Invariant.h" #include "invariant/InvariantManager.h" #include "ledger/LedgerManager.h" +#include "ledger/LedgerStateSnapshot.h" #include "ledger/LedgerTxn.h" #include "main/Application.h" #include "transactions/TransactionUtils.h" @@ -222,11 +223,9 @@ processEntryIfNew(LedgerEntry const& entry, LedgerKey const& key, // Scan live bucket list for entries that can hold the native asset static void -scanLiveBuckets( - std::shared_ptr const& liveSnapshot, - Asset const& asset, AssetContractInfo const& assetContractInfo, - int64_t& sumBalance, std::string& errorMsg, - std::function const& isStopping) +scanLiveBuckets(ApplyLedgerStateSnapshot const& snapshot, Asset const& asset, + AssetContractInfo const& assetContractInfo, int64_t& sumBalance, + std::string& errorMsg, std::function const& isStopping) { // Scan all entry types that can hold the native asset for (auto let : xdr::xdr_traits::enum_values()) @@ -239,7 +238,7 @@ scanLiveBuckets( std::unordered_set countedKeys; - liveSnapshot->scanForEntriesOfType( + snapshot.scanLiveEntriesOfType( type, [&](BucketEntry const& be) -> Loop { if (isStopping()) { @@ -271,15 +270,14 @@ scanLiveBuckets( } static void -scanHotArchiveBuckets( - std::shared_ptr const& - hotArchiveSnapshot, - Asset const& asset, AssetContractInfo const& assetContractInfo, - int64_t& sumBalance, std::string& errorMsg, - std::function const& isStopping) +scanHotArchiveBuckets(ApplyLedgerStateSnapshot const& snapshot, + Asset const& asset, + AssetContractInfo const& assetContractInfo, + int64_t& sumBalance, std::string& errorMsg, + std::function const& isStopping) { std::unordered_set countedKeys; - hotArchiveSnapshot->scanAllEntries([&](HotArchiveBucketEntry const& be) { + snapshot.scanAllArchiveEntries([&](HotArchiveBucketEntry const& be) { if (isStopping()) { return Loop::COMPLETE; @@ -312,8 +310,7 @@ scanHotArchiveBuckets( std::string ConservationOfLumens::checkSnapshot( - SearchableSnapshotConstPtr liveSnapshot, - SearchableHotArchiveSnapshotConstPtr hotArchiveSnapshot, + ApplyLedgerStateSnapshot const& snapshot, InMemorySorobanState const& inMemorySnapshot, std::function isStopping) { @@ -321,7 +318,7 @@ ConservationOfLumens::checkSnapshot( LogSlowExecution::Mode::AUTOMATIC_RAII, "took", std::chrono::seconds(90)); - auto const& header = liveSnapshot->getLedgerHeader(); + auto const& header = snapshot.getLedgerHeader(); // This invariant can fail prior to v24 due to bugs if (protocolVersionIsBefore(header.ledgerVersion, ProtocolVersion::V_24)) @@ -346,7 +343,7 @@ ConservationOfLumens::checkSnapshot( // Scan the Live BucketList for native balances using loopAllBuckets - scanLiveBuckets(liveSnapshot, nativeAsset, mLumenContractInfo, sumBalance, + scanLiveBuckets(snapshot, nativeAsset, mLumenContractInfo, sumBalance, errorMsg, isStopping); if (shouldAbortInvariantScan(errorMsg, isStopping)) @@ -355,8 +352,8 @@ ConservationOfLumens::checkSnapshot( } // Scan the Hot Archive for native balances - scanHotArchiveBuckets(hotArchiveSnapshot, nativeAsset, mLumenContractInfo, - sumBalance, errorMsg, isStopping); + scanHotArchiveBuckets(snapshot, nativeAsset, mLumenContractInfo, sumBalance, + errorMsg, isStopping); if (shouldAbortInvariantScan(errorMsg, isStopping)) { diff --git a/src/invariant/ConservationOfLumens.h b/src/invariant/ConservationOfLumens.h index 66bd4685e1..a58150f798 100644 --- a/src/invariant/ConservationOfLumens.h +++ b/src/invariant/ConservationOfLumens.h @@ -34,8 +34,7 @@ class ConservationOfLumens : public Invariant std::vector const& events, AppConnector& app) override; virtual std::string - checkSnapshot(SearchableSnapshotConstPtr liveSnapshot, - SearchableHotArchiveSnapshotConstPtr hotArchiveSnapshot, + checkSnapshot(ApplyLedgerStateSnapshot const& snapshot, InMemorySorobanState const& inMemorySnapshot, std::function isStopping) override; diff --git a/src/invariant/Invariant.h b/src/invariant/Invariant.h index 14a1ef0daa..3ad52bda9a 100644 --- a/src/invariant/Invariant.h +++ b/src/invariant/Invariant.h @@ -4,7 +4,6 @@ #pragma once -#include "bucket/BucketSnapshotManager.h" #include "bucket/BucketUtils.h" #include "ledger/LedgerStateSnapshot.h" #include "xdr/Stellar-ledger.h" @@ -74,8 +73,7 @@ class Invariant virtual std::string checkOnLedgerCommit( - SearchableSnapshotConstPtr lclLiveState, - SearchableHotArchiveSnapshotConstPtr lclHotArchiveState, + ApplyLedgerStateSnapshot const& lclSnapshot, std::vector const& persitentEvictedFromLive, std::vector const& tempAndTTLEvictedFromLive, UnorderedMap const& restoredFromArchive, @@ -85,8 +83,7 @@ class Invariant } virtual std::string - checkSnapshot(SearchableSnapshotConstPtr liveSnapshot, - SearchableHotArchiveSnapshotConstPtr hotArchiveSnapshot, + checkSnapshot(ApplyLedgerStateSnapshot const& snapshot, InMemorySorobanState const& inMemorySnapshot, std::function isStopping) { diff --git a/src/invariant/InvariantManager.h b/src/invariant/InvariantManager.h index c19c1bc707..b6f96152cc 100644 --- a/src/invariant/InvariantManager.h +++ b/src/invariant/InvariantManager.h @@ -16,6 +16,8 @@ class Application; class Bucket; class Invariant; class LedgerManager; +class LedgerStateSnapshot; +class ApplyLedgerStateSnapshot; struct EvictedStateVectors; struct LedgerTxnDelta; struct Operation; @@ -54,8 +56,7 @@ class InvariantManager AppConnector& app) = 0; virtual void checkOnLedgerCommit( - SearchableSnapshotConstPtr lclLiveState, - SearchableHotArchiveSnapshotConstPtr lclHotArchiveState, + ApplyLedgerStateSnapshot const& lclSnapshot, std::vector const& persitentEvictedFromLive, std::vector const& tempAndTTLEvictedFromLive, UnorderedMap const& restoredFromArchive, @@ -66,11 +67,10 @@ class InvariantManager // The invariant will periodically run on a background thread against the // given ledger state snapshot. These invariants will only run if // INVARIANT_EXTRA_CHECKS is enabled. - virtual void runStateSnapshotInvariant( - SearchableSnapshotConstPtr liveSnapshot, - SearchableHotArchiveSnapshotConstPtr hotArchiveSnapshot, - InMemorySorobanState const& inMemorySnapshot, - std::function isStopping) = 0; + virtual void + runStateSnapshotInvariant(ApplyLedgerStateSnapshot const& snapshot, + InMemorySorobanState const& inMemorySnapshot, + std::function isStopping) = 0; virtual void registerInvariant(std::shared_ptr invariant) = 0; diff --git a/src/invariant/InvariantManagerImpl.cpp b/src/invariant/InvariantManagerImpl.cpp index 41f397c7ff..a3bf676644 100644 --- a/src/invariant/InvariantManagerImpl.cpp +++ b/src/invariant/InvariantManagerImpl.cpp @@ -4,7 +4,6 @@ #include "invariant/InvariantManagerImpl.h" #include "bucket/BucketManager.h" -#include "bucket/BucketSnapshotManager.h" #include "bucket/BucketUtils.h" #include "bucket/LedgerCmp.h" #include "bucket/LiveBucket.h" @@ -15,6 +14,7 @@ #include "invariant/InvariantManagerImpl.h" #include "ledger/InMemorySorobanState.h" #include "ledger/LedgerManager.h" +#include "ledger/LedgerStateSnapshot.h" #include "ledger/LedgerTxn.h" #include "lib/util/finally.h" #include "main/Application.h" @@ -26,9 +26,7 @@ #include "util/MetricsRegistry.h" #include "util/ProtocolVersion.h" #include "util/XDRCereal.h" -#include #include -#include #include #include @@ -174,8 +172,7 @@ InvariantManagerImpl::checkOnOperationApply( void InvariantManagerImpl::checkOnLedgerCommit( - SearchableSnapshotConstPtr lclLiveState, - SearchableHotArchiveSnapshotConstPtr lclHotArchiveState, + ApplyLedgerStateSnapshot const& lclSnapshot, std::vector const& persitentEvictedFromLive, std::vector const& tempAndTTLEvictedFromLive, UnorderedMap const& restoredFromArchive, @@ -184,9 +181,8 @@ InvariantManagerImpl::checkOnLedgerCommit( for (auto invariant : mEnabled) { auto result = invariant->checkOnLedgerCommit( - lclLiveState, lclHotArchiveState, persitentEvictedFromLive, - tempAndTTLEvictedFromLive, restoredFromArchive, - restoredFromLiveState); + lclSnapshot, persitentEvictedFromLive, tempAndTTLEvictedFromLive, + restoredFromArchive, restoredFromLiveState); if (result.empty()) { continue; @@ -195,8 +191,7 @@ InvariantManagerImpl::checkOnLedgerCommit( auto message = fmt::format( FMT_STRING(R"(Invariant "{}" does not hold on ledger commit: {})"), invariant->getName(), result); - onInvariantFailure(invariant, message, - lclLiveState->getLedgerSeq() + 1); + onInvariantFailure(invariant, message, lclSnapshot.getLedgerSeq() + 1); } } @@ -333,8 +328,7 @@ InvariantManagerImpl::handleInvariantFailure(bool isStrict, // required state, then call this function in a background thread. void InvariantManagerImpl::runStateSnapshotInvariant( - SearchableSnapshotConstPtr liveSnapshot, - SearchableHotArchiveSnapshotConstPtr hotArchiveSnapshot, + ApplyLedgerStateSnapshot const& snapshot, InMemorySorobanState const& inMemorySnapshot, std::function isStopping) { @@ -346,12 +340,11 @@ InvariantManagerImpl::runStateSnapshotInvariant( { for (auto const& invariant : mEnabled) { - auto result = invariant->checkSnapshot( - liveSnapshot, hotArchiveSnapshot, inMemorySnapshot, isStopping); + auto result = invariant->checkSnapshot(snapshot, inMemorySnapshot, + isStopping); if (!result.empty()) { - auto ledgerSeq = liveSnapshot->getLedgerSeq(); - onInvariantFailure(invariant, result, ledgerSeq); + onInvariantFailure(invariant, result, snapshot.getLedgerSeq()); } } } diff --git a/src/invariant/InvariantManagerImpl.h b/src/invariant/InvariantManagerImpl.h index 55d9bd7e18..5aed7ecb9f 100644 --- a/src/invariant/InvariantManagerImpl.h +++ b/src/invariant/InvariantManagerImpl.h @@ -17,7 +17,6 @@ class Counter; namespace stellar { -class MetricsRegistry; class InvariantManagerImpl : public InvariantManager { @@ -62,8 +61,7 @@ class InvariantManagerImpl : public InvariantManager std::unordered_set const& shadowedKeys) override; virtual void checkOnLedgerCommit( - SearchableSnapshotConstPtr lclLiveState, - SearchableHotArchiveSnapshotConstPtr lclHotArchiveState, + ApplyLedgerStateSnapshot const& lclSnapshot, std::vector const& persitentEvictedFromLive, std::vector const& tempAndTTLEvictedFromLive, UnorderedMap const& restoredFromArchive, @@ -82,11 +80,9 @@ class InvariantManagerImpl : public InvariantManager bool shouldRunInvariantSnapshot() const override; void markStartOfInvariantSnapshot() override; - void runStateSnapshotInvariant( - SearchableSnapshotConstPtr liveSnapshot, - SearchableHotArchiveSnapshotConstPtr hotArchiveSnapshot, - InMemorySorobanState const& inMemorySnapshot, - std::function isStopping) override; + void runStateSnapshotInvariant(ApplyLedgerStateSnapshot const& snapshot, + InMemorySorobanState const& inMemorySnapshot, + std::function isStopping) override; #ifdef BUILD_TESTS void snapshotForFuzzer() override; diff --git a/src/invariant/test/ConservationOfLumensTests.cpp b/src/invariant/test/ConservationOfLumensTests.cpp index 93a7142158..b70e31efcc 100644 --- a/src/invariant/test/ConservationOfLumensTests.cpp +++ b/src/invariant/test/ConservationOfLumensTests.cpp @@ -7,6 +7,7 @@ #include "invariant/InvariantDoesNotHold.h" #include "invariant/InvariantManager.h" #include "invariant/test/InvariantTestUtils.h" +#include "ledger/LedgerStateSnapshot.h" #include "ledger/LedgerTxn.h" #include "ledger/LedgerTxnHeader.h" #include "ledger/test/LedgerTestUtils.h" @@ -19,7 +20,6 @@ #include "transactions/test/SorobanTxTestUtils.h" #include "util/Math.h" #include -#include #include using namespace stellar; @@ -332,15 +332,12 @@ TEST_CASE( // Verify the snapshot invariant passes { - auto ledgerState = - app.getLedgerManager().getLastClosedLedgerStateForTesting(); + auto snap = app.getLedgerManager().copyApplyLedgerStateSnapshot(); auto& inMemoryState = app.getLedgerManager().getInMemorySorobanStateForTesting(); REQUIRE_NOTHROW(app.getInvariantManager().runStateSnapshotInvariant( - ledgerState->getBucketSnapshot(), - ledgerState->getHotArchiveSnapshot(), inMemoryState, - []() { return false; })); + snap, inMemoryState, []() { return false; })); } // Now, manually modify totalCoins to be inconsistent. The invariant should @@ -354,18 +351,15 @@ TEST_CASE( closeLedger(test.getApp()); - auto ledgerState = - app.getLedgerManager().getLastClosedLedgerStateForTesting(); + auto snap = app.getLedgerManager().copyApplyLedgerStateSnapshot(); auto& inMemoryState = app.getLedgerManager().getInMemorySorobanStateForTesting(); Asset native(ASSET_TYPE_NATIVE); auto lumenInfo = getAssetContractInfo(native, app.getNetworkID()); ConservationOfLumens invariant(lumenInfo); - auto result = - invariant.checkSnapshot(ledgerState->getBucketSnapshot(), - ledgerState->getHotArchiveSnapshot(), - inMemoryState, []() { return false; }); + auto result = invariant.checkSnapshot(snap, inMemoryState, + []() { return false; }); REQUIRE_FALSE(result.empty()); REQUIRE(result.find("Total native asset supply mismatch") != std::string::npos); @@ -422,15 +416,12 @@ TEST_CASE("ConservationOfLumens snapshot invariant detects bucket corruption", app->getInvariantManager().enableInvariant("ConservationOfLumens"); - auto ledgerState = - app->getLedgerManager().getLastClosedLedgerStateForTesting(); + auto snap = app->getLedgerManager().copyApplyLedgerStateSnapshot(); auto& inMemoryState = app->getLedgerManager().getInMemorySorobanStateForTesting(); REQUIRE_NOTHROW(app->getInvariantManager().runStateSnapshotInvariant( - ledgerState->getBucketSnapshot(), - ledgerState->getHotArchiveSnapshot(), inMemoryState, - []() { return false; })); + snap, inMemoryState, []() { return false; })); } SECTION("Invariant fails when bucket balance doesn't match totalCoins") @@ -458,18 +449,15 @@ TEST_CASE("ConservationOfLumens snapshot invariant detects bucket corruption", BucketTestUtils::closeLedger(*app); - auto ledgerState = - app->getLedgerManager().getLastClosedLedgerStateForTesting(); + auto snap = app->getLedgerManager().copyApplyLedgerStateSnapshot(); auto& inMemoryState = app->getLedgerManager().getInMemorySorobanStateForTesting(); Asset native(ASSET_TYPE_NATIVE); auto lumenInfo = getAssetContractInfo(native, app->getNetworkID()); ConservationOfLumens invariant(lumenInfo); - auto result = - invariant.checkSnapshot(ledgerState->getBucketSnapshot(), - ledgerState->getHotArchiveSnapshot(), - inMemoryState, []() { return false; }); + auto result = invariant.checkSnapshot(snap, inMemoryState, + []() { return false; }); REQUIRE_FALSE(result.empty()); REQUIRE(result.find("Total native asset supply mismatch") != std::string::npos); @@ -521,15 +509,12 @@ TEST_CASE("ConservationOfLumens snapshot invariant detects bucket corruption", app->getInvariantManager().enableInvariant("ConservationOfLumens"); - auto ledgerState = - app->getLedgerManager().getLastClosedLedgerStateForTesting(); + auto snap = app->getLedgerManager().copyApplyLedgerStateSnapshot(); auto& inMemoryState = app->getLedgerManager().getInMemorySorobanStateForTesting(); REQUIRE_NOTHROW(app->getInvariantManager().runStateSnapshotInvariant( - ledgerState->getBucketSnapshot(), - ledgerState->getHotArchiveSnapshot(), inMemoryState, - []() { return false; })); + snap, inMemoryState, []() { return false; })); } SECTION("Invariant detects corrupted native balance in hot archive") @@ -580,16 +565,13 @@ TEST_CASE("ConservationOfLumens snapshot invariant detects bucket corruption", BucketTestUtils::closeLedger(*app); { - auto ledgerState = - app->getLedgerManager().getLastClosedLedgerStateForTesting(); + auto snap = app->getLedgerManager().copyApplyLedgerStateSnapshot(); auto& inMemoryState = app->getLedgerManager().getInMemorySorobanStateForTesting(); REQUIRE_NOTHROW( app->getInvariantManager().runStateSnapshotInvariant( - ledgerState->getBucketSnapshot(), - ledgerState->getHotArchiveSnapshot(), inMemoryState, - []() { return false; })); + snap, inMemoryState, []() { return false; })); } // Corrupt the other live balance by adding 123 stroops to the balance @@ -603,18 +585,15 @@ TEST_CASE("ConservationOfLumens snapshot invariant detects bucket corruption", BucketTestUtils::closeLedger(*app); { - auto ledgerState = - app->getLedgerManager().getLastClosedLedgerStateForTesting(); + auto snap = app->getLedgerManager().copyApplyLedgerStateSnapshot(); auto& inMemoryState = app->getLedgerManager().getInMemorySorobanStateForTesting(); Asset native(ASSET_TYPE_NATIVE); auto lumenInfo = getAssetContractInfo(native, app->getNetworkID()); ConservationOfLumens invariant(lumenInfo); - auto result = - invariant.checkSnapshot(ledgerState->getBucketSnapshot(), - ledgerState->getHotArchiveSnapshot(), - inMemoryState, []() { return false; }); + auto result = invariant.checkSnapshot(snap, inMemoryState, + []() { return false; }); REQUIRE_FALSE(result.empty()); REQUIRE(result.find("Total native asset supply mismatch") != std::string::npos); diff --git a/src/invariant/test/InvariantTests.cpp b/src/invariant/test/InvariantTests.cpp index ff68e4366f..a8de5500ec 100644 --- a/src/invariant/test/InvariantTests.cpp +++ b/src/invariant/test/InvariantTests.cpp @@ -2,10 +2,7 @@ // under the Apache License, Version 2.0. See the COPYING file at the root // of this distribution or at http://www.apache.org/licenses/LICENSE-2.0 -#include "util/asio.h" - #include "bucket/BucketManager.h" -#include "bucket/BucketSnapshotManager.h" #include "bucket/BucketUtils.h" #include "bucket/LiveBucket.h" #include "bucket/test/BucketTestUtils.h" @@ -371,35 +368,25 @@ TEST_CASE_VERSIONS("State archival eviction invariant", "[invariant][archival]") } // Make sure the entries have not been evicted - auto liveBL = app->getBucketManager() - .getBucketSnapshotManager() - .copySearchableLiveBucketListSnapshot(); - auto hotArchive = app->getBucketManager() - .getBucketSnapshotManager() - .copySearchableHotArchiveBucketListSnapshot(); - REQUIRE(liveBL->load(LedgerEntryKey(tempEntry))); - REQUIRE(liveBL->load(LedgerEntryKey(persistentEntry))); - REQUIRE(liveBL->load(getTTLKey(tempEntry))); - REQUIRE(liveBL->load(getTTLKey(persistentEntry))); - REQUIRE(!hotArchive->load(LedgerEntryKey(tempEntry))); - REQUIRE(!hotArchive->load(LedgerEntryKey(persistentEntry))); + auto snap = app->getLedgerManager().copyLedgerStateSnapshot(); + REQUIRE(snap.loadLiveEntry(LedgerEntryKey(tempEntry))); + REQUIRE(snap.loadLiveEntry(LedgerEntryKey(persistentEntry))); + REQUIRE(snap.loadLiveEntry(getTTLKey(tempEntry))); + REQUIRE(snap.loadLiveEntry(getTTLKey(persistentEntry))); + REQUIRE(!snap.loadArchiveEntry(LedgerEntryKey(tempEntry))); + REQUIRE(!snap.loadArchiveEntry(LedgerEntryKey(persistentEntry))); SECTION("Entries properly evicted") { closeLedger(*app); - liveBL = app->getBucketManager() - .getBucketSnapshotManager() - .copySearchableLiveBucketListSnapshot(); - hotArchive = app->getBucketManager() - .getBucketSnapshotManager() - .copySearchableHotArchiveBucketListSnapshot(); - REQUIRE(!liveBL->load(LedgerEntryKey(tempEntry))); - REQUIRE(!liveBL->load(LedgerEntryKey(persistentEntry))); - REQUIRE(!liveBL->load(getTTLKey(tempEntry))); - REQUIRE(!liveBL->load(getTTLKey(persistentEntry))); - REQUIRE(!hotArchive->load(LedgerEntryKey(tempEntry))); - REQUIRE(hotArchive->load(LedgerEntryKey(persistentEntry))); + snap = app->getLedgerManager().copyLedgerStateSnapshot(); + REQUIRE(!snap.loadLiveEntry(LedgerEntryKey(tempEntry))); + REQUIRE(!snap.loadLiveEntry(LedgerEntryKey(persistentEntry))); + REQUIRE(!snap.loadLiveEntry(getTTLKey(tempEntry))); + REQUIRE(!snap.loadLiveEntry(getTTLKey(persistentEntry))); + REQUIRE(!snap.loadArchiveEntry(LedgerEntryKey(tempEntry))); + REQUIRE(snap.loadArchiveEntry(LedgerEntryKey(persistentEntry))); } SECTION("invariant check") @@ -410,20 +397,18 @@ TEST_CASE_VERSIONS("State archival eviction invariant", "[invariant][archival]") auto ledgerVersion = lm.getLastClosedLedgerHeader().header.ledgerVersion; - auto snapshot = app->getBucketManager() - .getBucketSnapshotManager() - .copySearchableLiveBucketListSnapshot(); + auto applySnap = + app->getLedgerManager().copyApplyLedgerStateSnapshot(); + // Manually trigger eviction so we can test the invariant directly LedgerTxn ltx(app->getLedgerTxnRoot()); ltx.loadHeader().current().ledgerSeq++; auto evictedState = - app->getBucketManager().resolveBackgroundEvictionScan(snapshot, + app->getBucketManager().resolveBackgroundEvictionScan(applySnap, ltx, {}); - auto hotArchiveSnap = - app->getBucketManager() - .getBucketSnapshotManager() - .copySearchableHotArchiveBucketListSnapshot(); + applySnap = app->getLedgerManager().copyApplyLedgerStateSnapshot(); + // Persistent entry REQUIRE(evictedState.archivedEntries.size() == 1); // Temp entry, temp TTL, persistent TTL @@ -446,7 +431,7 @@ TEST_CASE_VERSIONS("State archival eviction invariant", "[invariant][archival]") REQUIRE_THROWS_AS( app->getInvariantManager().checkOnLedgerCommit( - snapshot, hotArchiveSnap, evictedState.archivedEntries, + applySnap, evictedState.archivedEntries, evictedState.deletedKeys, emptyMap, emptyMap), InvariantDoesNotHold); } @@ -464,7 +449,7 @@ TEST_CASE_VERSIONS("State archival eviction invariant", "[invariant][archival]") REQUIRE_THROWS_AS( app->getInvariantManager().checkOnLedgerCommit( - snapshot, hotArchiveSnap, evictedState.archivedEntries, + applySnap, evictedState.archivedEntries, evictedState.deletedKeys, emptyMap, emptyMap), InvariantDoesNotHold); } @@ -479,7 +464,7 @@ TEST_CASE_VERSIONS("State archival eviction invariant", "[invariant][archival]") REQUIRE_THROWS_AS( app->getInvariantManager().checkOnLedgerCommit( - snapshot, hotArchiveSnap, evictedState.archivedEntries, + applySnap, evictedState.archivedEntries, evictedState.deletedKeys, emptyMap, emptyMap), InvariantDoesNotHold); } @@ -499,7 +484,7 @@ TEST_CASE_VERSIONS("State archival eviction invariant", "[invariant][archival]") REQUIRE_THROWS_AS( app->getInvariantManager().checkOnLedgerCommit( - snapshot, hotArchiveSnap, evictedState.archivedEntries, + applySnap, evictedState.archivedEntries, evictedState.deletedKeys, emptyMap, emptyMap), InvariantDoesNotHold); } @@ -514,7 +499,7 @@ TEST_CASE_VERSIONS("State archival eviction invariant", "[invariant][archival]") REQUIRE_THROWS_AS( app->getInvariantManager().checkOnLedgerCommit( - snapshot, hotArchiveSnap, evictedState.archivedEntries, + applySnap, evictedState.archivedEntries, evictedState.deletedKeys, emptyMap, emptyMap), InvariantDoesNotHold); } @@ -534,7 +519,7 @@ TEST_CASE_VERSIONS("State archival eviction invariant", "[invariant][archival]") REQUIRE_THROWS_AS( app->getInvariantManager().checkOnLedgerCommit( - snapshot, hotArchiveSnap, evictedState.archivedEntries, + applySnap, evictedState.archivedEntries, evictedState.deletedKeys, emptyMap, emptyMap), InvariantDoesNotHold); } @@ -553,8 +538,7 @@ TEST_CASE_VERSIONS("State archival eviction invariant", "[invariant][archival]") { REQUIRE_THROWS_AS( app->getInvariantManager().checkOnLedgerCommit( - snapshot, hotArchiveSnap, - evictedState.archivedEntries, + applySnap, evictedState.archivedEntries, evictedState.deletedKeys, emptyMap, emptyMap), InvariantDoesNotHold); } @@ -562,8 +546,7 @@ TEST_CASE_VERSIONS("State archival eviction invariant", "[invariant][archival]") { REQUIRE_NOTHROW( app->getInvariantManager().checkOnLedgerCommit( - snapshot, hotArchiveSnap, - evictedState.archivedEntries, + applySnap, evictedState.archivedEntries, evictedState.deletedKeys, emptyMap, emptyMap)); } } @@ -574,7 +557,7 @@ TEST_CASE_VERSIONS("State archival eviction invariant", "[invariant][archival]") evictedState.deletedKeys.push_back(getTTLKey(liveTempEntry)); REQUIRE_THROWS_AS( app->getInvariantManager().checkOnLedgerCommit( - snapshot, hotArchiveSnap, evictedState.archivedEntries, + applySnap, evictedState.archivedEntries, evictedState.deletedKeys, emptyMap, emptyMap), InvariantDoesNotHold); } @@ -584,7 +567,7 @@ TEST_CASE_VERSIONS("State archival eviction invariant", "[invariant][archival]") // Valid eviction should always pass UnorderedMap emptyMap; REQUIRE_NOTHROW(app->getInvariantManager().checkOnLedgerCommit( - snapshot, hotArchiveSnap, evictedState.archivedEntries, + applySnap, evictedState.archivedEntries, evictedState.deletedKeys, emptyMap, emptyMap)); } } @@ -613,16 +596,8 @@ TEST_CASE("BucketList state consistency invariant", "[invariant]") {}, {}); closeLedger(*app); - auto getLiveSnapshot = [&]() { - return app->getBucketManager() - .getBucketSnapshotManager() - .copySearchableLiveBucketListSnapshot(); - }; - - auto getHotArchiveSnapshot = [&]() { - return app->getBucketManager() - .getBucketSnapshotManager() - .copySearchableHotArchiveBucketListSnapshot(); + auto makeSnap = [&]() { + return app->getLedgerManager().copyApplyLedgerStateSnapshot(); }; auto noopIsStopping = []() { return false; }; @@ -632,8 +607,7 @@ TEST_CASE("BucketList state consistency invariant", "[invariant]") SECTION("Valid state passes invariant") { auto result = invariant.checkSnapshot( - getLiveSnapshot(), getHotArchiveSnapshot(), - lm.getInMemorySorobanStateForTesting(), noopIsStopping); + makeSnap(), lm.getInMemorySorobanStateForTesting(), noopIsStopping); REQUIRE(result.empty()); } @@ -653,8 +627,7 @@ TEST_CASE("BucketList state consistency invariant", "[invariant]") } auto result = - invariant.checkSnapshot(getLiveSnapshot(), getHotArchiveSnapshot(), - modifiedState, noopIsStopping); + invariant.checkSnapshot(makeSnap(), modifiedState, noopIsStopping); REQUIRE(!result.empty()); }; @@ -701,8 +674,7 @@ TEST_CASE("BucketList state consistency invariant", "[invariant]") } auto result = - invariant.checkSnapshot(getLiveSnapshot(), getHotArchiveSnapshot(), - modifiedState, noopIsStopping); + invariant.checkSnapshot(makeSnap(), modifiedState, noopIsStopping); REQUIRE(!result.empty()); }; @@ -743,8 +715,7 @@ TEST_CASE("BucketList state consistency invariant", "[invariant]") } auto result = - invariant.checkSnapshot(getLiveSnapshot(), getHotArchiveSnapshot(), - modifiedState, noopIsStopping); + invariant.checkSnapshot(makeSnap(), modifiedState, noopIsStopping); REQUIRE(!result.empty()); }; @@ -774,8 +745,7 @@ TEST_CASE("BucketList state consistency invariant", "[invariant]") InternalContractDataMapEntry(entryCopy, wrongTTL)); auto result = - invariant.checkSnapshot(getLiveSnapshot(), getHotArchiveSnapshot(), - modifiedState, noopIsStopping); + invariant.checkSnapshot(makeSnap(), modifiedState, noopIsStopping); REQUIRE(!result.empty()); } @@ -790,8 +760,7 @@ TEST_CASE("BucketList state consistency invariant", "[invariant]") *app, lm.getLastClosedLedgerHeader().header, {phantomTTL}, {}, {}); auto result = invariant.checkSnapshot( - getLiveSnapshot(), getHotArchiveSnapshot(), - lm.getInMemorySorobanStateForTesting(), noopIsStopping); + makeSnap(), lm.getInMemorySorobanStateForTesting(), noopIsStopping); REQUIRE(!result.empty()); } @@ -803,8 +772,7 @@ TEST_CASE("BucketList state consistency invariant", "[invariant]") *app, lm.getLastClosedLedgerHeader().header, {dataEntry1}, {}); auto result = invariant.checkSnapshot( - getLiveSnapshot(), getHotArchiveSnapshot(), - lm.getInMemorySorobanStateForTesting(), noopIsStopping); + makeSnap(), lm.getInMemorySorobanStateForTesting(), noopIsStopping); REQUIRE(!result.empty()); } } diff --git a/src/ledger/InMemorySorobanState.cpp b/src/ledger/InMemorySorobanState.cpp index c7d1b40565..ded1ec1bcf 100644 --- a/src/ledger/InMemorySorobanState.cpp +++ b/src/ledger/InMemorySorobanState.cpp @@ -4,6 +4,7 @@ #include "ledger/InMemorySorobanState.h" #include "bucket/BucketListSnapshot.h" +#include "ledger/LedgerStateSnapshot.h" #include "ledger/LedgerTypeUtils.h" #include "ledger/SorobanMetrics.h" #include "util/GlobalChecks.h" @@ -444,15 +445,18 @@ InMemorySorobanState::getTTL(LedgerKey const& ledgerKey) const void InMemorySorobanState::initializeStateFromSnapshot( - SearchableSnapshotConstPtr snap, uint32_t ledgerVersion) + ApplyLedgerStateSnapshot const& snap) { releaseAssertOrThrow(mContractDataEntries.empty()); releaseAssertOrThrow(mContractCodeEntries.empty()); releaseAssertOrThrow(mPendingTTLs.empty()); + auto const& lclHeader = snap.getLedgerHeader(); + auto ledgerVersion = lclHeader.ledgerVersion; if (protocolVersionStartsFrom(ledgerVersion, SOROBAN_PROTOCOL_VERSION)) { - auto sorobanConfig = SorobanNetworkConfig::loadFromLedger(snap); + LedgerSnapshot ls(snap); + auto sorobanConfig = SorobanNetworkConfig::loadFromLedger(ls); // Check if entry is a DEADENTRY and add it to deletedKeys. Otherwise, // check if the entry is shadowed by a DEADENTRY. std::unordered_set deletedKeys; @@ -519,12 +523,12 @@ InMemorySorobanState::initializeStateFromSnapshot( return Loop::INCOMPLETE; }; - snap->scanForEntriesOfType(CONTRACT_DATA, contractDataHandler); - snap->scanForEntriesOfType(TTL, ttlHandler); - snap->scanForEntriesOfType(CONTRACT_CODE, contractCodeHandler); + snap.scanLiveEntriesOfType(CONTRACT_DATA, contractDataHandler); + snap.scanLiveEntriesOfType(TTL, ttlHandler); + snap.scanLiveEntriesOfType(CONTRACT_CODE, contractCodeHandler); } - mLastClosedLedgerSeq = snap->getLedgerSeq(); + mLastClosedLedgerSeq = lclHeader.ledgerSeq; checkUpdateInvariants(); } diff --git a/src/ledger/InMemorySorobanState.h b/src/ledger/InMemorySorobanState.h index 385e494841..0a85aa4840 100644 --- a/src/ledger/InMemorySorobanState.h +++ b/src/ledger/InMemorySorobanState.h @@ -10,8 +10,6 @@ #include #include -#include "bucket/BucketSnapshotManager.h" -#include "invariant/InvariantManagerImpl.h" #include "ledger/LedgerTypeUtils.h" #include "util/types.h" #include "xdr/Stellar-ledger-entries.h" @@ -19,6 +17,7 @@ namespace stellar { +class ApplyLedgerStateSnapshot; class InvariantManagerImpl; class SorobanMetrics; @@ -440,8 +439,7 @@ class InMemorySorobanState // is reading state when these functions are called. // Initialize the map from a bucket list snapshot - void initializeStateFromSnapshot(SearchableSnapshotConstPtr snap, - uint32_t ledgerVersion); + void initializeStateFromSnapshot(ApplyLedgerStateSnapshot const& snap); // Update the map with entries from a ledger close. ledgerSeq must be // exactly mLastClosedLedgerSeq + 1. diff --git a/src/ledger/LedgerManager.h b/src/ledger/LedgerManager.h index dbc885008d..5a785ce267 100644 --- a/src/ledger/LedgerManager.h +++ b/src/ledger/LedgerManager.h @@ -7,6 +7,7 @@ #include "catchup/LedgerApplyManager.h" #include "history/HistoryManager.h" #include "ledger/LedgerCloseMetaFrame.h" +#include "ledger/LedgerStateSnapshot.h" #include "ledger/NetworkConfig.h" #include "main/ApplicationImpl.h" #include "rust/RustBridge.h" @@ -229,8 +230,22 @@ class LedgerManager virtual LedgerHeaderHistoryEntry const& getLastClosedLedgerHeader() const = 0; - // Get bucketlist snapshot of LCL - virtual SearchableSnapshotConstPtr getLastClosedSnapshot() const = 0; + // Create a thread-safe copy of the current canonical ledger state + // snapshot. Can be called from any thread (except for apply, which must use + // copyApplyLedgerStateSnapshot instead). + virtual LedgerStateSnapshot copyLedgerStateSnapshot() const = 0; + + // Create a thread-safe copy of the current canonical ledger state + // snapshot, typed as an apply-time snapshot. Used by legacy (pre-V23) + // code paths that need an ApplyLedgerStateSnapshot but don't have + // access to ApplyState. + // TODO: Refactor such that this doesn't have to be a public function + virtual ApplyLedgerStateSnapshot copyApplyLedgerStateSnapshot() const = 0; + + // Refresh `snapshot` if its ledger seq differs from the current canonical + // state. No-op otherwise. Can be called from any thread. + virtual void + maybeUpdateLedgerStateSnapshot(LedgerStateSnapshot& snapshot) const = 0; // return the HAS that corresponds to the last closed ledger as persisted in // the database @@ -272,14 +287,13 @@ class LedgerManager virtual std::chrono::milliseconds getExpectedLedgerCloseTime() const = 0; #ifdef BUILD_TESTS + virtual void updateCanonicalStateForTesting(LedgerHeader const& header) = 0; virtual std::vector const& getLastClosedLedgerTxMeta() = 0; virtual std::optional const& getLastClosedLedgerCloseMeta() = 0; virtual void storeCurrentLedgerForTest(LedgerHeader const& header) = 0; virtual InMemorySorobanState const& getInMemorySorobanStateForTesting() = 0; - virtual CompleteConstLedgerStatePtr - getLastClosedLedgerStateForTesting() = 0; virtual void rebuildInMemorySorobanStateForTesting(uint32_t ledgerVersion) = 0; virtual ::rust::Box @@ -333,9 +347,7 @@ class LedgerManager advanceLedgerStateAndPublish(uint32_t ledgerSeq, bool calledViaExternalize, LedgerCloseData const& ledgerData, CompleteConstLedgerStatePtr newLedgerState, - bool upgradeApplied, - std::shared_ptr - inMemorySnapshotForInvariant) = 0; + bool upgradeApplied) = 0; virtual void assertSetupPhase() const = 0; #ifdef BUILD_TESTS diff --git a/src/ledger/LedgerManagerImpl.cpp b/src/ledger/LedgerManagerImpl.cpp index 33800cd267..235b81576b 100644 --- a/src/ledger/LedgerManagerImpl.cpp +++ b/src/ledger/LedgerManagerImpl.cpp @@ -4,7 +4,6 @@ #include "ledger/LedgerManagerImpl.h" #include "bucket/BucketManager.h" -#include "bucket/BucketSnapshotManager.h" #include "bucket/HotArchiveBucketList.h" #include "bucket/LiveBucketList.h" #include "catchup/AssumeStateWork.h" @@ -28,7 +27,6 @@ #include "ledger/LedgerTxn.h" #include "ledger/LedgerTxnEntry.h" #include "ledger/LedgerTxnHeader.h" -#include "ledger/LedgerTypeUtils.h" #include "ledger/P23HotArchiveBug.h" #include "ledger/SharedModuleCacheCompiler.h" #include "main/Application.h" @@ -50,12 +48,12 @@ #include "util/Logging.h" #include "util/MetricsRegistry.h" #include "util/ProtocolVersion.h" +#include "util/ThreadAnnotations.h" #include "util/XDRCereal.h" #include "util/XDRStream.h" #include "util/types.h" #include "work/WorkScheduler.h" #include "xdr/Stellar-ledger-entries.h" -#include "xdrpp/printer.h" #include #include @@ -77,7 +75,6 @@ #include "LedgerManagerImpl.h" #include #include -#include #include #include #include @@ -265,6 +262,13 @@ LedgerManagerImpl::ApplyState::getSorobanInMemoryStateSizeForTesting() const { return mInMemorySorobanState.getSize(); } + +void +LedgerManagerImpl::ApplyState::setLedgerStateForTesting( + CompleteConstLedgerStatePtr state) +{ + mLedgerState = std::move(state); +} #endif void @@ -334,13 +338,31 @@ LedgerManagerImpl::ApplyState::manuallyAdvanceLedgerHeader( LedgerManagerImpl::LedgerManagerImpl(Application& app) : mApp(app) , mApplyState(app) - , mLastClosedLedgerState(std::make_shared( - nullptr, nullptr, LedgerHeaderHistoryEntry(), HistoryArchiveState())) + , mNumHistoricalSnapshots(app.getConfig().QUERY_SNAPSHOT_LEDGERS) , mLastClose(mApp.getClock().now()) , mCatchupDuration( app.getMetrics().NewTimer({"ledger", "catchup", "duration"})) , mState(LM_BOOTING_STATE) { + // At this point, we haven't called assumeState yet, so the BucketLists are + // empty. We will create an "empty" snapshot that is not null, but + // references this empty BucketList (and a ledger header with ledgerSeq 0 + // and zero hash). + auto& bm = mApp.getBucketManager(); + LedgerHeaderHistoryEntry emptyLcl; + HistoryArchiveState emptyHas; + + auto initialState = std::make_shared( + bm.getLiveBucketList(), bm.getHotArchiveBucketList(), emptyLcl, + emptyHas, /*sorobanConfig*/ std::nullopt, /*prevState*/ nullptr, + mNumHistoricalSnapshots); + + mApplyState.setLedgerState(initialState); + { + SharedLockExclusive lock(mLedgerStateSnapshotMutex); + mLastClosedLedgerState = initialState; + } + setupLedgerCloseMetaStream(); } @@ -471,12 +493,15 @@ LedgerManagerImpl::startNewLedger(LedgerHeader const& genesisLedger) CLOG_INFO(Ledger, "Root account: {}", skey.getStrKeyPublic()); CLOG_INFO(Ledger, "Root account seed: {}", skey.getStrKeySeed().value); - auto& appConnector = mApp.getAppConnector(); - auto output = sealLedgerTxnAndStoreInBucketsAndDB( - appConnector.copySearchableLiveBucketListSnapshot(), - appConnector.copySearchableHotArchiveBucketListSnapshot(), ltx, - /*ledgerCloseMeta*/ nullptr, - /*initialLedgerVers*/ 0); + ApplyLedgerStateSnapshot snap = [&] { + SharedLockShared guard(mLedgerStateSnapshotMutex); + return ApplyLedgerStateSnapshot(mLastClosedLedgerState, + mApp.getMetrics()); + }(); + auto output = + sealLedgerTxnAndStoreInBucketsAndDB(snap, ltx, + /*ledgerCloseMeta*/ nullptr, + /*initialLedgerVers*/ 0); advanceLastClosedLedgerState(output); ltx.commit(); @@ -578,31 +603,23 @@ LedgerManagerImpl::loadLastKnownLedgerInternal(bool skipBuildingFullState) } // Step 4. Restore LedgerManager's LCL state - advanceLastClosedLedgerState( - advanceBucketListSnapshotAndMakeLedgerState(*latestLedgerHeader, has)); + advanceLastClosedLedgerState(advanceApplySnapshotAndMakeLedgerState( + *latestLedgerHeader, has, std::nullopt)); // Maybe truncate checkpoint files if we're restarting after a crash // in applyLedger (in which case any modifications to the ledger state have // been rolled back) mApp.getHistoryManager().restoreCheckpoint(latestLedgerHeader->ledgerSeq); - // Prime module cache with LCL state, not apply-state. This is acceptable - // here because we just started and there is no apply-state yet and no apply - // thread to hold such state. - auto const& snapshot = mLastClosedLedgerState->getBucketSnapshot(); + // Prime module cache if (!skipBuildingFullState) { mApplyState.compileAllContractsInLedger( - snapshot, latestLedgerHeader->ledgerVersion); - mApplyState.populateInMemorySorobanState( - snapshot, latestLedgerHeader->ledgerVersion); - } + latestLedgerHeader->ledgerVersion); + mApplyState.populateInMemorySorobanState(); - if (!skipBuildingFullState) - { - maybeRunSnapshotInvariantFromLedgerState( - mLastClosedLedgerState, maybeCopySorobanStateForInvariant(), - /* runInParallel */ false); + maybeRunSnapshotInvariantFromLedgerState(copyApplyLedgerStateSnapshot(), + /* runInParallel */ false); } mApplyState.markEndOfSetupPhase(); } @@ -628,7 +645,8 @@ LedgerManagerImpl::getDatabase() uint32_t LedgerManagerImpl::getLastMaxTxSetSize() const { - releaseAssert(threadIsMain()); + releaseAssert(!mApp.threadIsType(Application::ThreadType::APPLY)); + SharedLockShared guard(mLedgerStateSnapshotMutex); releaseAssert(mLastClosedLedgerState); return mLastClosedLedgerState->getLastClosedLedgerHeader() .header.maxTxSetSize; @@ -637,7 +655,8 @@ LedgerManagerImpl::getLastMaxTxSetSize() const uint32_t LedgerManagerImpl::getLastMaxTxSetSizeOps() const { - releaseAssert(threadIsMain()); + releaseAssert(!mApp.threadIsType(Application::ThreadType::APPLY)); + SharedLockShared guard(mLedgerStateSnapshotMutex); releaseAssert(mLastClosedLedgerState); auto n = mLastClosedLedgerState->getLastClosedLedgerHeader().header.maxTxSetSize; @@ -686,7 +705,8 @@ LedgerManagerImpl::maxSorobanTransactionResources() int64_t LedgerManagerImpl::getLastMinBalance(uint32_t ownerCount) const { - releaseAssert(threadIsMain()); + releaseAssert(!mApp.threadIsType(Application::ThreadType::APPLY)); + SharedLockShared guard(mLedgerStateSnapshotMutex); releaseAssert(mLastClosedLedgerState); auto const& lh = mLastClosedLedgerState->getLastClosedLedgerHeader().header; if (protocolVersionIsBefore(lh.ledgerVersion, ProtocolVersion::V_9)) @@ -698,7 +718,8 @@ LedgerManagerImpl::getLastMinBalance(uint32_t ownerCount) const uint32_t LedgerManagerImpl::getLastReserve() const { - releaseAssert(threadIsMain()); + releaseAssert(!mApp.threadIsType(Application::ThreadType::APPLY)); + SharedLockShared guard(mLedgerStateSnapshotMutex); releaseAssert(mLastClosedLedgerState); return mLastClosedLedgerState->getLastClosedLedgerHeader() .header.baseReserve; @@ -707,7 +728,8 @@ LedgerManagerImpl::getLastReserve() const uint32_t LedgerManagerImpl::getLastTxFee() const { - releaseAssert(threadIsMain()); + releaseAssert(!mApp.threadIsType(Application::ThreadType::APPLY)); + SharedLockShared guard(mLedgerStateSnapshotMutex); releaseAssert(mLastClosedLedgerState); return mLastClosedLedgerState->getLastClosedLedgerHeader().header.baseFee; } @@ -715,7 +737,11 @@ LedgerManagerImpl::getLastTxFee() const LedgerHeaderHistoryEntry const& LedgerManagerImpl::getLastClosedLedgerHeader() const { + // Must be main thread: returns a reference into mLastClosedLedgerState, + // which is only replaced on the main thread (advanceLastClosedLedgerState). + // A cross-thread caller could hold a dangling reference after replacement. releaseAssert(threadIsMain()); + SharedLockShared guard(mLedgerStateSnapshotMutex); releaseAssert(mLastClosedLedgerState); return mLastClosedLedgerState->getLastClosedLedgerHeader(); } @@ -723,7 +749,8 @@ LedgerManagerImpl::getLastClosedLedgerHeader() const HistoryArchiveState LedgerManagerImpl::getLastClosedLedgerHAS() const { - releaseAssert(threadIsMain()); + releaseAssert(!mApp.threadIsType(Application::ThreadType::APPLY)); + SharedLockShared guard(mLedgerStateSnapshotMutex); releaseAssert(mLastClosedLedgerState); return mLastClosedLedgerState->getLastClosedHistoryArchiveState(); } @@ -731,65 +758,42 @@ LedgerManagerImpl::getLastClosedLedgerHAS() const uint32_t LedgerManagerImpl::getLastClosedLedgerNum() const { - releaseAssert(threadIsMain()); + releaseAssert(!mApp.threadIsType(Application::ThreadType::APPLY)); + SharedLockShared guard(mLedgerStateSnapshotMutex); releaseAssert(mLastClosedLedgerState); return mLastClosedLedgerState->getLastClosedLedgerHeader().header.ledgerSeq; } -std::shared_ptr -LedgerManagerImpl::maybeCopySorobanStateForInvariant() -{ - std::shared_ptr inMemorySnapshotForInvariant = - nullptr; - if (mApp.getInvariantManager().shouldRunInvariantSnapshot()) - { - // The in memory state copy is expensive, so we need to mark - // that start of the invariant scan here, not in the callback, to ensure - // we don't trigger a race condition that creates two copies. - mApp.getInvariantManager().markStartOfInvariantSnapshot(); - inMemorySnapshotForInvariant = - std::make_shared( - mApplyState.getInMemorySorobanState()); - } - return inMemorySnapshotForInvariant; -} - void LedgerManagerImpl::maybeRunSnapshotInvariantFromLedgerState( - CompleteConstLedgerStatePtr const& ledgerState, - std::shared_ptr inMemorySnapshotForInvariant, - bool runInParallel) const + ApplyLedgerStateSnapshot const& ledgerState, bool runInParallel) { - releaseAssert(threadIsMain()); - - if (!inMemorySnapshotForInvariant || - !mApp.getConfig().INVARIANT_EXTRA_CHECKS || mApp.isStopping()) + if (!mApp.getConfig().INVARIANT_EXTRA_CHECKS || mApp.isStopping() || + !mApp.getInvariantManager().shouldRunInvariantSnapshot()) { return; } + // The in memory state copy is expensive, so we need to mark the start of + // the invariant scan here, not in the callback, to ensure we don't trigger + // a race condition that creates two copies. + mApp.getInvariantManager().markStartOfInvariantSnapshot(); + auto inMemorySnapshotForInvariant = + std::make_shared( + mApplyState.getInMemorySorobanState()); + // Verify consistency of all snapshot state. - auto ledgerSeq = ledgerState->getLastClosedLedgerHeader().header.ledgerSeq; + auto ledgerSeq = ledgerState.getLedgerSeq(); inMemorySnapshotForInvariant->assertLastClosedLedger(ledgerSeq); - // Copy snapshots from ledgerState to ensure consistency with the - // in-memory Soroban state - auto liveSnapshotCopy = - BucketSnapshotManager::copySearchableLiveBucketListSnapshot( - ledgerState->getBucketSnapshot(), mApp.getMetrics()); - auto hotArchiveSnapshotCopy = - BucketSnapshotManager::copySearchableHotArchiveBucketListSnapshot( - ledgerState->getHotArchiveSnapshot(), mApp.getMetrics()); - releaseAssertOrThrow(liveSnapshotCopy->getLedgerSeq() == ledgerSeq); - releaseAssertOrThrow(hotArchiveSnapshotCopy->getLedgerSeq() == ledgerSeq); - // Note: No race condition acquiring app by reference, as all worker // threads are joined before application destruction. - auto cb = [liveSnapshot = liveSnapshotCopy, - hotArchiveSnapshot = hotArchiveSnapshotCopy, &app = mApp, + // Make sure we make a new snapshot copy since invariant will run on another + // thread. + auto cb = [snap = ledgerState, &app = mApp, inMemorySnapshotForInvariant]() { app.getInvariantManager().runStateSnapshotInvariant( - liveSnapshot, hotArchiveSnapshot, *inMemorySnapshotForInvariant, + std::move(snap), *inMemorySnapshotForInvariant, [&app]() { return app.isStopping(); }); }; @@ -806,15 +810,21 @@ LedgerManagerImpl::maybeRunSnapshotInvariantFromLedgerState( SorobanNetworkConfig const& LedgerManagerImpl::getLastClosedSorobanNetworkConfig() const { + // Must be main thread: returns a reference into mLastClosedLedgerState, + // which is only replaced on the main thread (advanceLastClosedLedgerState). + // A cross-thread caller could hold a dangling reference after replacement. releaseAssert(threadIsMain()); - releaseAssert(hasLastClosedSorobanNetworkConfig()); + SharedLockShared guard(mLedgerStateSnapshotMutex); + releaseAssert(mLastClosedLedgerState); + releaseAssert(mLastClosedLedgerState->hasSorobanConfig()); return mLastClosedLedgerState->getSorobanConfig(); } bool LedgerManagerImpl::hasLastClosedSorobanNetworkConfig() const { - releaseAssert(threadIsMain()); + releaseAssert(!mApp.threadIsType(Application::ThreadType::APPLY)); + SharedLockShared guard(mLedgerStateSnapshotMutex); releaseAssert(mLastClosedLedgerState); return mLastClosedLedgerState->hasSorobanConfig(); } @@ -868,19 +878,12 @@ LedgerManagerImpl::getInMemorySorobanStateForTesting() return mApplyState.getInMemorySorobanStateForTesting(); } -CompleteConstLedgerStatePtr -LedgerManagerImpl::getLastClosedLedgerStateForTesting() -{ - return mLastClosedLedgerState; -} - void LedgerManagerImpl::rebuildInMemorySorobanStateForTesting(uint32_t ledgerVersion) { mApplyState.resetToSetupPhase(); mApplyState.getInMemorySorobanStateForTesting().clearForTesting(); - mApplyState.populateInMemorySorobanState( - mLastClosedLedgerState->getBucketSnapshot(), ledgerVersion); + mApplyState.populateInMemorySorobanState(); mApplyState.markEndOfSetupPhase(); } @@ -982,19 +985,19 @@ LedgerManagerImpl::ApplyState::finishPendingCompilation() void LedgerManagerImpl::ApplyState::compileAllContractsInLedger( - SearchableSnapshotConstPtr snap, uint32_t minLedgerVersion) + uint32_t minLedgerVersion) { assertSetupPhase(); - startCompilingAllContracts(snap, minLedgerVersion); + startCompilingAllContracts(minLedgerVersion); finishPendingCompilation(); } void -LedgerManagerImpl::ApplyState::populateInMemorySorobanState( - SearchableSnapshotConstPtr snap, uint32_t ledgerVersion) +LedgerManagerImpl::ApplyState::populateInMemorySorobanState() { assertSetupPhase(); - mInMemorySorobanState.initializeStateFromSnapshot(snap, ledgerVersion); + mInMemorySorobanState.initializeStateFromSnapshot( + copyLedgerStateSnapshot()); } void @@ -1052,7 +1055,7 @@ LedgerManagerImpl::ApplyState::assertSetupPhase() const void LedgerManagerImpl::ApplyState::startCompilingAllContracts( - SearchableSnapshotConstPtr snap, uint32_t minLedgerVersion) + uint32_t minLedgerVersion) { threadInvariant(); // Always stop a previous compilation before starting a new one. Can only @@ -1067,7 +1070,7 @@ LedgerManagerImpl::ApplyState::startCompilingAllContracts( } } mCompiler = std::make_unique( - snap, mAppConnector.getMetrics(), mNumCompilationThreads, versions); + copyLedgerStateSnapshot(), mNumCompilationThreads, versions); mCompiler->start(); } @@ -1081,9 +1084,10 @@ LedgerManagerImpl::ApplyState::assertWritablePhase() const void LedgerManagerImpl::ApplyState::maybeRebuildModuleCache( - SearchableSnapshotConstPtr snap, uint32_t minLedgerVersion) + uint32_t minLedgerVersion) { assertCommittingPhase(); + auto snap = copyLedgerStateSnapshot(); // There is (currently) a grow-only arena underlying the module cache, so as // entries are uploaded and evicted that arena will still grow. To cap this @@ -1120,7 +1124,8 @@ LedgerManagerImpl::ApplyState::maybeRebuildModuleCache( // linearTerm is in 1/128ths in the cost model, to reduce rounding error. uint64_t scale = 128; - auto sorobanConfig = SorobanNetworkConfig::loadFromLedger(snap); + LedgerSnapshot lsForConfig(snap); + auto sorobanConfig = SorobanNetworkConfig::loadFromLedger(lsForConfig); auto const& memParams = sorobanConfig.memCostParams(); if (memParams.size() > (size_t)stellar::VmInstantiation) { @@ -1140,7 +1145,7 @@ LedgerManagerImpl::ApplyState::maybeRebuildModuleCache( "Rebuilding module cache: worst-case estimate {} " "model-bytes consumed of {} limit", bytesConsumed, limit); - startCompilingAllContracts(snap, minLedgerVersion); + startCompilingAllContracts(minLedgerVersion); break; } } @@ -1332,19 +1337,15 @@ getMetaIOContext(Application& app) } // namespace void -LedgerManagerImpl::ledgerCloseComplete( - uint32_t lcl, bool calledViaExternalize, LedgerCloseData const& ledgerData, - bool upgradeApplied, - std::shared_ptr inMemorySnapshotForInvariant) +LedgerManagerImpl::ledgerCloseComplete(uint32_t lcl, bool calledViaExternalize, + LedgerCloseData const& ledgerData, + bool upgradeApplied) { // We just finished applying `lcl`, maybe change LM's state // Also notify Herder so it can trigger next ledger. releaseAssert(threadIsMain()); - // Kick off the snapshot invariant, if enabled - maybeRunSnapshotInvariantFromLedgerState(mLastClosedLedgerState, - inMemorySnapshotForInvariant); uint32_t latestHeardFromNetwork = mApp.getLedgerApplyManager().getLargestLedgerSeqHeard(); uint32_t latestQueuedToApply = @@ -1386,8 +1387,7 @@ void LedgerManagerImpl::advanceLedgerStateAndPublish( uint32_t ledgerSeq, bool calledViaExternalize, LedgerCloseData const& ledgerData, - CompleteConstLedgerStatePtr newLedgerState, bool upgradeApplied, - std::shared_ptr inMemorySnapshotForInvariant) + CompleteConstLedgerStatePtr newLedgerState, bool upgradeApplied) { #ifdef BUILD_TESTS if (mAdvanceLedgerStateAndPublishOverride) @@ -1425,7 +1425,7 @@ LedgerManagerImpl::advanceLedgerStateAndPublish( // Maybe set LedgerManager into synced state, maybe let // Herder trigger next ledger ledgerCloseComplete(ledgerSeq, calledViaExternalize, ledgerData, - upgradeApplied, inMemorySnapshotForInvariant); + upgradeApplied); CLOG_INFO(Ledger, "Ledger close complete: {}", ledgerSeq); } @@ -1693,11 +1693,9 @@ LedgerManagerImpl::applyLedger(LedgerCloseData const& ledgerData, auto maybeNewVersion = ltx.loadHeader().current().ledgerVersion; auto ledgerSeq = ltx.loadHeader().current().ledgerSeq; - auto& appConnector = mApp.getAppConnector(); + auto lclSnap = mApplyState.copyLedgerStateSnapshot(); auto appliedLedgerState = sealLedgerTxnAndStoreInBucketsAndDB( - appConnector.copySearchableLiveBucketListSnapshot(), - appConnector.copySearchableHotArchiveBucketListSnapshot(), ltx, - ledgerCloseMeta, initialLedgerVers); + lclSnap, ltx, ledgerCloseMeta, initialLedgerVers); // NB: from now on, the ledger state may not change, but LCL still hasn't // advanced properly. Hence when requesting the ledger state data (such as @@ -1800,14 +1798,12 @@ LedgerManagerImpl::applyLedger(LedgerCloseData const& ledgerData, .header.ledgerVersion, SOROBAN_PROTOCOL_VERSION)) { - // Copy the snapshot directly from `appliedLedgerState`, which holds - // the latest committed state, to avoid relying on - // BucketSnapshotManager. - auto latestSnapshot = - BucketSnapshotManager::copySearchableLiveBucketListSnapshot( - appliedLedgerState->getBucketSnapshot(), mApp.getMetrics()); + // Construct an ApplyLedgerStateSnapshot from `appliedLedgerState`, + // which holds the latest committed state, since the main thread has + // not yet updated the non-apply lcl snapshot + ApplyLedgerStateSnapshot snap(appliedLedgerState, mApp.getMetrics()); mApp.getBucketManager().startBackgroundEvictionScan( - latestSnapshot, appliedLedgerState->getSorobanConfig()); + std::move(snap), appliedLedgerState->getSorobanConfig()); } // At this point, we've committed all changes to the Apply State for this @@ -1817,10 +1813,12 @@ LedgerManagerImpl::applyLedger(LedgerCloseData const& ledgerData, mApplyState.markEndOfCommitting(); JITTER_INJECT_DELAY(); - // Step 5: copy the in-memory Soroban state if we should run the snapshot - // invariant for this ledger. At this point, commit has completed and - // in-memory state is immutable. - auto inMemorySnapshotForInvariant = maybeCopySorobanStateForInvariant(); + // Step 5: kick off the snapshot invariant, if the timer has fired. + // Both the apply-state snapshot and the in-memory Soroban state are + // captured here at the same point (after commit), so they are guaranteed + // to be from the same ledger. + maybeRunSnapshotInvariantFromLedgerState( + mApplyState.copyLedgerStateSnapshot()); // Steps 6, 7, 8 are done in `advanceLedgerStateAndPublish` // NB: appliedLedgerState is invalidated after this call. @@ -1828,18 +1826,16 @@ LedgerManagerImpl::applyLedger(LedgerCloseData const& ledgerData, { advanceLedgerStateAndPublish(ledgerSeq, calledViaExternalize, ledgerData, std::move(appliedLedgerState), - upgradeApplied, - inMemorySnapshotForInvariant); + upgradeApplied); } else { auto cb = [this, ledgerSeq, calledViaExternalize, ledgerData, appliedLedgerState = std::move(appliedLedgerState), - upgradeApplied, inMemorySnapshotForInvariant]() mutable { + upgradeApplied]() mutable { advanceLedgerStateAndPublish( ledgerSeq, calledViaExternalize, ledgerData, - std::move(appliedLedgerState), upgradeApplied, - inMemorySnapshotForInvariant); + std::move(appliedLedgerState), upgradeApplied); }; mApp.postOnMainThread(std::move(cb), "advanceLedgerStateAndPublish"); } @@ -1871,8 +1867,8 @@ LedgerManagerImpl::setLastClosedLedger( header.current(), /* appendToCheckpoint */ false); ltx.commit(); - auto output = - advanceBucketListSnapshotAndMakeLedgerState(lastClosed.header, has); + auto output = advanceApplySnapshotAndMakeLedgerState(lastClosed.header, has, + std::nullopt); advanceLastClosedLedgerState(output); auto ledgerVersion = lastClosed.header.ledgerVersion; @@ -1885,14 +1881,8 @@ LedgerManagerImpl::setLastClosedLedger( { // This should not be additionally conditionalized on lv >= anything, // since we want to support SOROBAN_TEST_EXTRA_PROTOCOL > lv. - // - // Again, since we are only called during catchup and just got a full - // bucket state, there's no tx-apply state to snapshot, in this one - // case we will prime the tx-apply-state's soroban module cache using - // a snapshot _from_ the LCL state. - auto const& snapshot = mLastClosedLedgerState->getBucketSnapshot(); - mApplyState.compileAllContractsInLedger(snapshot, ledgerVersion); - mApplyState.populateInMemorySorobanState(snapshot, ledgerVersion); + mApplyState.compileAllContractsInLedger(ledgerVersion); + mApplyState.populateInMemorySorobanState(); } mApplyState.markEndOfSetupPhase(); } @@ -1914,7 +1904,7 @@ LedgerManagerImpl::manuallyAdvanceLedgerHeader(LedgerHeader const& header) mApplyState.markStartOfCommitting(); mApplyState.manuallyAdvanceLedgerHeader(header); advanceLastClosedLedgerState( - advanceBucketListSnapshotAndMakeLedgerState(header, has)); + advanceApplySnapshotAndMakeLedgerState(header, has, std::nullopt)); mApplyState.markEndOfCommitting(); } @@ -2048,14 +2038,6 @@ LedgerManagerImpl::maybeResetLedgerCloseMetaDebugStream(uint32_t ledgerSeq) } } -SearchableSnapshotConstPtr -LedgerManagerImpl::getLastClosedSnapshot() const -{ - releaseAssert(threadIsMain()); - releaseAssert(mLastClosedLedgerState); - return mLastClosedLedgerState->getBucketSnapshot(); -} - void LedgerManagerImpl::advanceLastClosedLedgerState( CompleteConstLedgerStatePtr newLedgerState) @@ -2063,6 +2045,7 @@ LedgerManagerImpl::advanceLastClosedLedgerState( releaseAssert(threadIsMain()); releaseAssert(newLedgerState); + SharedLockExclusive lock(mLedgerStateSnapshotMutex); if (mLastClosedLedgerState) { CLOG_DEBUG( @@ -2075,26 +2058,118 @@ LedgerManagerImpl::advanceLastClosedLedgerState( } CompleteConstLedgerStatePtr -LedgerManagerImpl::advanceBucketListSnapshotAndMakeLedgerState( - LedgerHeader const& header, HistoryArchiveState const& has) +LedgerManagerImpl::buildLedgerState( + LedgerHeader const& header, HistoryArchiveState const& has, + CompleteConstLedgerStatePtr prevState, + std::optional sorobanConfig) { - auto ledgerHash = xdrSha256(header); + auto& bm = mApp.getBucketManager(); + + // If the caller didn't provide a SorobanNetworkConfig, load it from the + // BucketList (at this point the BucketList must have already been updated). + if (!sorobanConfig && protocolVersionStartsFrom(header.ledgerVersion, + SOROBAN_PROTOCOL_VERSION)) + { + auto liveData = std::make_shared>( + bm.getLiveBucketList()); + LedgerSnapshot ls(mApp.getMetrics(), std::move(liveData), header); + sorobanConfig = SorobanNetworkConfig::loadFromLedger(ls); + } LedgerHeaderHistoryEntry lcl; lcl.header = header; - lcl.hash = ledgerHash; + lcl.hash = xdrSha256(header); - auto& bm = mApp.getBucketManager(); - // Updating BL snapshot is thread-safe - bm.getBucketSnapshotManager().updateCurrentSnapshot( - bm.getLiveBucketList(), bm.getHotArchiveBucketList(), header); + return std::make_shared( + bm.getLiveBucketList(), bm.getHotArchiveBucketList(), lcl, has, + std::move(sorobanConfig), std::move(prevState), + mNumHistoricalSnapshots); +} + +CompleteConstLedgerStatePtr +LedgerManagerImpl::advanceApplySnapshotAndMakeLedgerState( + LedgerHeader const& header, HistoryArchiveState const& has, + std::optional sorobanConfig) +{ + auto state = buildLedgerState(header, has, mApplyState.getLedgerState(), + std::move(sorobanConfig)); + mApplyState.setLedgerState(state); + return state; +} + +LedgerStateSnapshot +LedgerManagerImpl::copyLedgerStateSnapshot() const +{ + // Apply thread must use the ApplyState's copyLedgerStateSnapshot. + releaseAssert(!mApp.threadIsType(Application::ThreadType::APPLY)); + + SharedLockShared guard(mLedgerStateSnapshotMutex); + releaseAssert(mLastClosedLedgerState); + return LedgerStateSnapshot(mLastClosedLedgerState, mApp.getMetrics()); +} + +ApplyLedgerStateSnapshot +LedgerManagerImpl::copyApplyLedgerStateSnapshot() const +{ + // Apply-thread state may be ahead of mLastClosedLedgerState during + // parallel ledger close, so always read from ApplyState. + mApplyState.threadInvariant(); + return mApplyState.copyLedgerStateSnapshot(); +} - return std::make_shared( - bm.getBucketSnapshotManager().copySearchableLiveBucketListSnapshot(), - bm.getBucketSnapshotManager() - .copySearchableHotArchiveBucketListSnapshot(), - lcl, has); +void +LedgerManagerImpl::maybeUpdateLedgerStateSnapshot( + LedgerStateSnapshot& snapshot) const +{ + SharedLockShared guard(mLedgerStateSnapshotMutex); + releaseAssert(mLastClosedLedgerState); + if (snapshot.getLedgerSeq() != + mLastClosedLedgerState->getLastClosedLedgerHeader().header.ledgerSeq) + { + snapshot = + LedgerStateSnapshot(mLastClosedLedgerState, mApp.getMetrics()); + } } + +void +LedgerManagerImpl::ApplyState::setLedgerState(CompleteConstLedgerStatePtr state) +{ + assertWritablePhase(); + mLedgerState = std::move(state); +} + +CompleteConstLedgerStatePtr +LedgerManagerImpl::ApplyState::getLedgerState() const +{ + releaseAssert(mLedgerState); + return mLedgerState; +} + +ApplyLedgerStateSnapshot +LedgerManagerImpl::ApplyState::copyLedgerStateSnapshot() const +{ + releaseAssert(mLedgerState); + return ApplyLedgerStateSnapshot(mLedgerState, mAppConnector.getMetrics()); +} + +#ifdef BUILD_TESTS +void +LedgerManagerImpl::updateCanonicalStateForTesting(LedgerHeader const& header) +{ + releaseAssert(threadIsMain()); + + HistoryArchiveState has; + has.currentLedger = header.ledgerSeq; + + SharedLockExclusive lock(mLedgerStateSnapshotMutex); + auto state = + buildLedgerState(header, has, mLastClosedLedgerState, std::nullopt); + + mApplyState.setLedgerStateForTesting(state); + + mLastClosedLedgerState = state; +} +#endif } std::vector @@ -2318,8 +2393,6 @@ LedgerManagerImpl::applySorobanStageClustersInParallel( std::vector>> threadFutures; - auto liveSnapshot = app.copySearchableLiveBucketListSnapshot(); - DeactivateScopeGuard globalStateDeactivateGuard(globalState); for (size_t i = 0; i < stage.numClusters(); ++i) @@ -2423,7 +2496,8 @@ LedgerManagerImpl::applySorobanStages(AppConnector& app, AbstractLedgerTxn& ltx, { ZoneScoped; GlobalParallelApplyLedgerState globalParState( - app, ltx, stages, mApplyState.getInMemorySorobanState(), sorobanConfig); + app, mApplyState.copyLedgerStateSnapshot(), ltx, stages, + mApplyState.getInMemorySorobanState(), sorobanConfig); // LedgerTxn is not passed into applySorobanStage, so there's no risk // of the header being updated while we apply the stages. auto const& header = ltx.loadHeader().current(); @@ -2825,11 +2899,9 @@ LedgerManagerImpl::storePersistentStateAndLedgerHeaderInDB( } // NB: This is a separate method so a testing subclass can override it. -void +std::optional LedgerManagerImpl::finalizeLedgerTxnChanges( - SearchableSnapshotConstPtr lclSnapshot, - SearchableHotArchiveSnapshotConstPtr lclHotArchiveSnapshot, - AbstractLedgerTxn& ltx, + ApplyLedgerStateSnapshot const& lclSnapshot, AbstractLedgerTxn& ltx, std::unique_ptr const& ledgerCloseMeta, LedgerHeader lh, uint32_t initialLedgerVers) { @@ -2868,9 +2940,9 @@ LedgerManagerImpl::finalizeLedgerTxnChanges( } mApp.getInvariantManager().checkOnLedgerCommit( - lclSnapshot, lclHotArchiveSnapshot, - evictedState.archivedEntries, evictedState.deletedKeys, - restoredHotArchiveKeyMap, ltx.getRestoredLiveBucketListKeys()); + lclSnapshot, evictedState.archivedEntries, + evictedState.deletedKeys, restoredHotArchiveKeyMap, + ltx.getRestoredLiveBucketListKeys()); bool isP24UpgradeLedger = protocolVersionIsBefore(initialLedgerVers, @@ -2880,7 +2952,7 @@ LedgerManagerImpl::finalizeLedgerTxnChanges( if (isP24UpgradeLedger && gIsProductionNetwork) { p23_hot_archive_bug::addHotArchiveBatchWithP23HotArchiveFix( - ltx, mApp, lh, evictedState.archivedEntries, + ltx, mApp, lclSnapshot, lh, evictedState.archivedEntries, restoredHotArchiveKeys); } else @@ -2894,7 +2966,8 @@ LedgerManagerImpl::finalizeLedgerTxnChanges( { mApp.getProtocol23CorruptionDataVerifier() ->verifyArchivalOfCorruptedEntry( - evictedState, mApp, lh.ledgerSeq, lh.ledgerVersion); + evictedState, lclSnapshot, lh.ledgerSeq, + lh.ledgerVersion); } } } @@ -2932,13 +3005,12 @@ LedgerManagerImpl::finalizeLedgerTxnChanges( deadEntries); mApplyState.updateInMemorySorobanState(initEntries, liveEntries, deadEntries, lh, finalSorobanConfig); + return finalSorobanConfig; } CompleteConstLedgerStatePtr LedgerManagerImpl::sealLedgerTxnAndStoreInBucketsAndDB( - SearchableSnapshotConstPtr lclSnapshot, - SearchableHotArchiveSnapshotConstPtr lclHotArchiveSnapshot, - AbstractLedgerTxn& ltx, + ApplyLedgerStateSnapshot const& lclSnapshot, AbstractLedgerTxn& ltx, std::unique_ptr const& ledgerCloseMeta, uint32_t initialLedgerVers) { @@ -2974,23 +3046,24 @@ LedgerManagerImpl::sealLedgerTxnAndStoreInBucketsAndDB( // protocol version prior to the upgrade. Due to this, we must check the // initial protocol version of ledger instead of the ledger version of // the current ltx header, which may have been modified via an upgrade. - finalizeLedgerTxnChanges(lclSnapshot, lclHotArchiveSnapshot, ltx, - ledgerCloseMeta, ledgerHeader, initialLedgerVers); + auto sorobanConfig = finalizeLedgerTxnChanges( + lclSnapshot, ltx, ledgerCloseMeta, ledgerHeader, initialLedgerVers); CompleteConstLedgerStatePtr res; - ltx.unsealHeader([this, &res](LedgerHeader& lh) { + ltx.unsealHeader([this, &res, sorobanConfig = std::move(sorobanConfig)]( + LedgerHeader& lh) mutable { mApp.getBucketManager().snapshotLedger(lh); auto has = storePersistentStateAndLedgerHeaderInDB( lh, /* appendToCheckpoint */ true); - res = advanceBucketListSnapshotAndMakeLedgerState(lh, has); + res = advanceApplySnapshotAndMakeLedgerState(lh, has, + std::move(sorobanConfig)); }); releaseAssert(res); if (protocolVersionStartsFrom( initialLedgerVers, REUSABLE_SOROBAN_MODULE_CACHE_PROTOCOL_VERSION)) { - mApplyState.maybeRebuildModuleCache(res->getBucketSnapshot(), - initialLedgerVers); + mApplyState.maybeRebuildModuleCache(initialLedgerVers); } return res; diff --git a/src/ledger/LedgerManagerImpl.h b/src/ledger/LedgerManagerImpl.h index faa7ba5ffb..b983e40476 100644 --- a/src/ledger/LedgerManagerImpl.h +++ b/src/ledger/LedgerManagerImpl.h @@ -4,8 +4,7 @@ #pragma once -#include "util/asio.h" - +#include "bucket/BucketListSnapshot.h" #include "bucket/BucketManager.h" #include "history/HistoryManager.h" #include "ledger/InMemorySorobanState.h" @@ -159,6 +158,9 @@ class LedgerManagerImpl : public LedgerManager AppConnector& mAppConnector; + // Ledger state snapshot that is the base for current ledger apply + CompleteConstLedgerStatePtr mLedgerState; + // The current reusable / inter-ledger soroban module cache. ::rust::Box mModuleCache; @@ -181,11 +183,10 @@ class LedgerManagerImpl : public LedgerManager Phase mPhase{Phase::SETTING_UP_STATE}; // Kicks off (on auxiliary threads) compilation of all contracts in the - // provided snapshot, for ledger protocols starting at minLedgerVersion - // and running through to Config::CURRENT_LEDGER_PROTOCOL_VERSION (to - // enable upgrades). - void startCompilingAllContracts(SearchableSnapshotConstPtr snap, - uint32_t minLedgerVersion); + // apply state snapshot, for ledger protocols starting at + // minLedgerVersion and running through to + // Config::CURRENT_LEDGER_PROTOCOL_VERSION (to enable upgrades). + void startCompilingAllContracts(uint32_t minLedgerVersion); // Checks if ApplyState can currently be modified. For functions that // are only called in ledgerClose, use the stronger @@ -211,6 +212,7 @@ class LedgerManagerImpl : public LedgerManager ::rust::Box const& getModuleCacheForTesting(); uint64_t getSorobanInMemoryStateSizeForTesting() const; + void setLedgerStateForTesting(CompleteConstLedgerStatePtr state); #endif ::rust::Box const& @@ -236,14 +238,12 @@ class LedgerManagerImpl : public LedgerManager // Equivalent to calling `startCompilingAllContracts` followed by // `finishPendingCompilation`. - void compileAllContractsInLedger(SearchableSnapshotConstPtr snap, - uint32_t minLedgerVersion); + void compileAllContractsInLedger(uint32_t minLedgerVersion); // Estimates the size of the arena underlying the module cache's shared // wasmi engine, from metrics, and rebuilds if it has likely built up a // lot of dead space inside of it. - void maybeRebuildModuleCache(SearchableSnapshotConstPtr snap, - uint32_t minLedgerVersion); + void maybeRebuildModuleCache(uint32_t minLedgerVersion); // Evicts a single contract from the module cache, if it is present. // This should be done whenever a contract LE is evicted from the @@ -258,12 +258,17 @@ class LedgerManagerImpl : public LedgerManager // Populates all live Soroban state into the cache from the provided // snapshot. - void populateInMemorySorobanState(SearchableSnapshotConstPtr snap, - uint32_t ledgerVersion); + void populateInMemorySorobanState(); void handleUpgradeAffectingSorobanInMemoryStateSize( AbstractLedgerTxn& upgradeLtx); + // Advance the ledger state to the provided snapshot. + void setLedgerState(CompleteConstLedgerStatePtr state); + + CompleteConstLedgerStatePtr getLedgerState() const; + ApplyLedgerStateSnapshot copyLedgerStateSnapshot() const; + // Throws if current state is not READY_TO_APPLY, advances to APPLYING void markStartOfApplying(); @@ -290,8 +295,21 @@ class LedgerManagerImpl : public LedgerManager // that gets accessed via the AppConnector, from inside transactions. ApplyState mApplyState; - // Cached LCL state output from last apply (or loaded from DB on startup). - CompleteConstLedgerStatePtr mLastClosedLedgerState; + // We maintain two (potentially different) ledger state snapshots, one for + // the apply thread, and one for everyone else, managed by the main thread. + // mLastClosedLedgerState is managed by the main thread and is copyable + // by all threads (except for apply). This is protected by + // mLedgerStateSnapshotMutex. + // When background apply is enabled, the apply thread will advance it's own + // snapshot immediately after applying a ledger, then post the result back + // to main thread. This means the apply snapshot may be ahead of + // mLastClosedLedgerState at any given point. + mutable SharedMutex mLedgerStateSnapshotMutex; + CompleteConstLedgerStatePtr + mLastClosedLedgerState GUARDED_BY(mLedgerStateSnapshotMutex); + + // Max number of historical snapshots to maintain. + uint32_t const mNumHistoricalSnapshots; VirtualClock::time_point mLastClose; @@ -382,9 +400,7 @@ class LedgerManagerImpl : public LedgerManager // On the ledger in which a protocol upgrade from vN to vN + 1 occurs, // initialLedgerVers must be vN. CompleteConstLedgerStatePtr sealLedgerTxnAndStoreInBucketsAndDB( - SearchableSnapshotConstPtr lclSnapshot, - SearchableHotArchiveSnapshotConstPtr lclHotArchiveSnapshot, - AbstractLedgerTxn& ltx, + ApplyLedgerStateSnapshot const& lclSnapshot, AbstractLedgerTxn& ltx, std::unique_ptr const& ledgerCloseMeta, uint32_t initialLedgerVers); @@ -392,22 +408,12 @@ class LedgerManagerImpl : public LedgerManager storePersistentStateAndLedgerHeaderInDB(LedgerHeader const& header, bool appendToCheckpoint); - // Copies in-memory Soroban state for snapshot invariant if required for - // this ledger, or returns nullptr otherwise. Should be called in - // READY_TO_APPLY phase when InMemorySorobanState is read only. - // Also clears the snapshot trigger flag to prevent race conditions. - std::shared_ptr - maybeCopySorobanStateForInvariant(); - - // Trigger snapshot invariant on background thread if - // inMemorySnapshotForInvariant is not null. - // If runInParallel is false, runs on the calling thread (this is useful in - // certain scenarios such as startup) + // If the invariant timer has fired, copies the in-memory Soroban state and + // the apply-state snapshot, then kicks off the snapshot invariant check. + // If runInParallel is false, runs on the calling thread (useful at + // startup). void maybeRunSnapshotInvariantFromLedgerState( - CompleteConstLedgerStatePtr const& ledgerState, - std::shared_ptr - inMemorySnapshotForInvariant, - bool runInParallel = true) const; + ApplyLedgerStateSnapshot const& ledgerState, bool runInParallel = true); static void prefetchTransactionData(AbstractLedgerTxnParent& rootLtx, ApplicableTxSetFrame const& txSet, @@ -451,19 +457,25 @@ class LedgerManagerImpl : public LedgerManager // NB: LedgerHeader is a copy here to prevent footguns in case ltx // invalidates any header references - virtual void finalizeLedgerTxnChanges( - SearchableSnapshotConstPtr lclSnapshot, - SearchableHotArchiveSnapshotConstPtr lclHotArchiveSnapshot, - AbstractLedgerTxn& ltx, + virtual std::optional finalizeLedgerTxnChanges( + ApplyLedgerStateSnapshot const& lclSnapshot, AbstractLedgerTxn& ltx, std::unique_ptr const& ledgerCloseMeta, LedgerHeader lh, uint32_t initialLedgerVers); - // Update bucket list snapshot, and construct LedgerState return - // value, which contains all information relevant to ledger state (HAS, - // ledger header, network config, bucketlist snapshot). + // Build a new CompleteConstLedgerState from the current BucketLists, + // copying then updating historical snapshots from prevState. If + // sorobanConfig is not provided, it is loaded from a temporary bucket + // snapshot when the protocol requires it. CompleteConstLedgerStatePtr - advanceBucketListSnapshotAndMakeLedgerState(LedgerHeader const& header, - HistoryArchiveState const& has); + buildLedgerState(LedgerHeader const& header, HistoryArchiveState const& has, + CompleteConstLedgerStatePtr prevState, + std::optional sorobanConfig); + + // Build a new ledger state and advance ApplyState snapshot to it. This does + // not yet publish or post the new snapshot to the main thread. + CompleteConstLedgerStatePtr advanceApplySnapshotAndMakeLedgerState( + LedgerHeader const& header, HistoryArchiveState const& has, + std::optional sorobanConfig); void logTxApplyMetrics(AbstractLedgerTxn& ltx, size_t numTxs, size_t numOps); @@ -514,7 +526,6 @@ class LedgerManagerImpl : public LedgerManager void storeCurrentLedgerForTest(LedgerHeader const& header) override; std::function mAdvanceLedgerStateAndPublishOverride; InMemorySorobanState const& getInMemorySorobanStateForTesting() override; - CompleteConstLedgerStatePtr getLastClosedLedgerStateForTesting() override; ::rust::Box getModuleCacheForTesting() override; void rebuildInMemorySorobanStateForTesting(uint32_t ledgerVersion) override; @@ -540,17 +551,14 @@ class LedgerManagerImpl : public LedgerManager void applyLedger(LedgerCloseData const& ledgerData, bool calledViaExternalize) override; - void advanceLedgerStateAndPublish( - uint32_t ledgerSeq, bool calledViaExternalize, - LedgerCloseData const& ledgerData, - CompleteConstLedgerStatePtr newLedgerState, bool queueRebuildNeeded, - std::shared_ptr - inMemorySnapshotForInvariant = nullptr) override; + void + advanceLedgerStateAndPublish(uint32_t ledgerSeq, bool calledViaExternalize, + LedgerCloseData const& ledgerData, + CompleteConstLedgerStatePtr newLedgerState, + bool queueRebuildNeeded) override; void ledgerCloseComplete(uint32_t lcl, bool calledViaExternalize, LedgerCloseData const& ledgerData, - bool queueRebuildNeeded, - std::shared_ptr - inMemorySnapshotForInvariant); + bool queueRebuildNeeded); void setLastClosedLedger(LedgerHeaderHistoryEntry const& lastClosed, bool rebuildInMemoryState) override; @@ -560,7 +568,13 @@ class LedgerManagerImpl : public LedgerManager void maybeResetLedgerCloseMetaDebugStream(uint32_t ledgerSeq); SorobanMetrics& getSorobanMetrics() override; - SearchableSnapshotConstPtr getLastClosedSnapshot() const override; + LedgerStateSnapshot copyLedgerStateSnapshot() const override; + ApplyLedgerStateSnapshot copyApplyLedgerStateSnapshot() const override; + void maybeUpdateLedgerStateSnapshot( + LedgerStateSnapshot& snapshot) const override; +#ifdef BUILD_TESTS + void updateCanonicalStateForTesting(LedgerHeader const& header) override; +#endif virtual bool isApplying() const override { diff --git a/src/ledger/LedgerStateSnapshot.cpp b/src/ledger/LedgerStateSnapshot.cpp index c1a78b9ef2..dd1052db1b 100644 --- a/src/ledger/LedgerStateSnapshot.cpp +++ b/src/ledger/LedgerStateSnapshot.cpp @@ -4,7 +4,8 @@ #include "ledger/LedgerStateSnapshot.h" #include "bucket/BucketManager.h" -#include "bucket/BucketSnapshotManager.h" +#include "bucket/HotArchiveBucketList.h" +#include "bucket/LiveBucketList.h" #include "ledger/LedgerManager.h" #include "ledger/LedgerTxn.h" #include "main/Application.h" @@ -168,10 +169,24 @@ LedgerTxnReadOnly::executeWithMaybeInnerSnapshot( return f(lsg); } -BucketSnapshotState::BucketSnapshotState(SearchableSnapshotConstPtr snapshot) - : mSnapshot(snapshot) - , mLedgerHeader(LedgerHeaderWrapper( - std::make_shared(mSnapshot->getLedgerHeader()))) +BucketSnapshotState::BucketSnapshotState(LedgerStateSnapshot const& snap) + : mLiveSnap(snap.mLiveSnapshot) + , mLedgerHeader(std::make_shared(snap.getLedgerHeader())) +{ +} + +BucketSnapshotState::BucketSnapshotState(ApplyLedgerStateSnapshot const& snap) + : mLiveSnap(static_cast(snap).mLiveSnapshot) + , mLedgerHeader(std::make_shared(snap.getLedgerHeader())) +{ +} + +BucketSnapshotState::BucketSnapshotState( + MetricsRegistry& metrics, + std::shared_ptr const> liveData, + LedgerHeader const& header) + : mLiveSnap(metrics, std::move(liveData), {}, header.ledgerSeq) + , mLedgerHeader(std::make_shared(header)) { } @@ -182,13 +197,13 @@ BucketSnapshotState::~BucketSnapshotState() LedgerHeaderWrapper BucketSnapshotState::getLedgerHeader() const { - return LedgerHeaderWrapper(std::get<1>(mLedgerHeader.mHeader)); + return LedgerHeaderWrapper(mLedgerHeader); } LedgerEntryWrapper BucketSnapshotState::getAccount(AccountID const& account) const { - return LedgerEntryWrapper(mSnapshot->load(accountKey(account))); + return LedgerEntryWrapper(mLiveSnap.load(accountKey(account))); } LedgerEntryWrapper @@ -209,7 +224,7 @@ BucketSnapshotState::getAccount(LedgerHeaderWrapper const& header, LedgerEntryWrapper BucketSnapshotState::load(LedgerKey const& key) const { - return LedgerEntryWrapper(mSnapshot->load(key)); + return LedgerEntryWrapper(mLiveSnap.load(key)); } void @@ -240,12 +255,28 @@ LedgerSnapshot::LedgerSnapshot(Application& app) } else #endif - mGetter = std::make_unique( - app.getLedgerManager().getLastClosedSnapshot()); + { + auto snap = app.getLedgerManager().copyLedgerStateSnapshot(); + mGetter = std::make_unique(snap); + } } -LedgerSnapshot::LedgerSnapshot(SearchableSnapshotConstPtr snapshot) - : mGetter(std::make_unique(snapshot)) +LedgerSnapshot::LedgerSnapshot(LedgerStateSnapshot const& snap) + : mGetter(std::make_unique(snap)) +{ +} + +LedgerSnapshot::LedgerSnapshot(ApplyLedgerStateSnapshot const& snap) + : mGetter(std::make_unique(snap)) +{ +} + +LedgerSnapshot::LedgerSnapshot( + MetricsRegistry& metrics, + std::shared_ptr const> liveData, + LedgerHeader const& header) + : mGetter(std::make_unique( + metrics, std::move(liveData), header)) { } @@ -279,44 +310,73 @@ CompleteConstLedgerState::checkInvariant() const { releaseAssert(mLastClosedHistoryArchiveState.currentLedger == mLastClosedLedgerHeader.header.ledgerSeq); - if (mLastClosedLedgerHeader.header.ledgerSeq > 0) + releaseAssert(mLiveBucketData); + releaseAssert(mHotArchiveBucketData); +} + +namespace +{ +// Build the next historical snapshot map by copying the previous map, +// evicting the oldest entry if at capacity, and inserting the previous +// state's current snapshot keyed by its ledger sequence number. +template +auto +rotateHistorical( + std::shared_ptr const> const& prevData, + std::map const>> const& + prevHistorical, + uint32_t prevLedgerSeq, uint32_t numHistorical) +{ + std::map const>> + result; + if (numHistorical == 0 || !prevData) { - releaseAssert(mBucketSnapshot->getLedgerHeader() == - mLastClosedLedgerHeader.header); + return result; } + result = prevHistorical; + if (result.size() == numHistorical) + { + result.erase(result.begin()); + } + result.emplace(prevLedgerSeq, prevData); + return result; } +} // anonymous namespace CompleteConstLedgerState::CompleteConstLedgerState( - SearchableSnapshotConstPtr searchableSnapshot, - SearchableHotArchiveSnapshotConstPtr hotArchiveSnapshot, - LedgerHeaderHistoryEntry const& lastClosedLedgerHeader, - HistoryArchiveState const& lastClosedHistoryArchiveState) - : mBucketSnapshot(searchableSnapshot) - , mHotArchiveSnapshot(hotArchiveSnapshot) - , mSorobanConfig( - protocolVersionStartsFrom(lastClosedLedgerHeader.header.ledgerVersion, - SOROBAN_PROTOCOL_VERSION) - ? std::make_optional( - SorobanNetworkConfig::loadFromLedger(searchableSnapshot)) - : std::nullopt) - , mLastClosedLedgerHeader(lastClosedLedgerHeader) - , mLastClosedHistoryArchiveState(lastClosedHistoryArchiveState) + LiveBucketList const& liveBL, HotArchiveBucketList const& hotArchiveBL, + LedgerHeaderHistoryEntry const& lcl, HistoryArchiveState const& has, + std::optional sorobanConfig, + CompleteConstLedgerStatePtr prevState, uint32_t numHistorical) + : mLiveBucketData( + std::make_shared>(liveBL)) + , mLiveHistoricalSnapshots( + prevState ? rotateHistorical( + prevState->mLiveBucketData, + prevState->mLiveHistoricalSnapshots, + prevState->mLastClosedLedgerHeader.header.ledgerSeq, + numHistorical) + : std::map const>>{}) + , mHotArchiveBucketData( + std::make_shared>( + hotArchiveBL)) + , mHotArchiveHistoricalSnapshots( + prevState ? rotateHistorical( + prevState->mHotArchiveBucketData, + prevState->mHotArchiveHistoricalSnapshots, + prevState->mLastClosedLedgerHeader.header.ledgerSeq, + numHistorical) + : std::map const>>{}) + , mSorobanConfig(std::move(sorobanConfig)) + , mLastClosedLedgerHeader(lcl) + , mLastClosedHistoryArchiveState(has) { checkInvariant(); } -SearchableSnapshotConstPtr -CompleteConstLedgerState::getBucketSnapshot() const -{ - return mBucketSnapshot; -} - -SearchableHotArchiveSnapshotConstPtr -CompleteConstLedgerState::getHotArchiveSnapshot() const -{ - return mHotArchiveSnapshot; -} - SorobanNetworkConfig const& CompleteConstLedgerState::getSorobanConfig() const { @@ -341,4 +401,130 @@ CompleteConstLedgerState::getLastClosedHistoryArchiveState() const return mLastClosedHistoryArchiveState; } +LedgerStateSnapshot::LedgerStateSnapshot(CompleteConstLedgerStatePtr state, + MetricsRegistry& metrics) + : mState(state) + , mLiveSnapshot(metrics, state->mLiveBucketData, + state->mLiveHistoricalSnapshots, + state->mLastClosedLedgerHeader.header.ledgerSeq) + , mHotArchiveSnapshot(metrics, state->mHotArchiveBucketData, + state->mHotArchiveHistoricalSnapshots, + state->mLastClosedLedgerHeader.header.ledgerSeq) + , mMetrics(metrics) +{ +} + +CompleteConstLedgerState const& +LedgerStateSnapshot::getState() const +{ + releaseAssert(mState); + return *mState; +} + +LedgerHeader const& +LedgerStateSnapshot::getLedgerHeader() const +{ + return mState->getLastClosedLedgerHeader().header; +} + +uint32_t +LedgerStateSnapshot::getLedgerSeq() const +{ + return mState->getLastClosedLedgerHeader().header.ledgerSeq; +} + +// === Live BucketList wrapper methods === + +std::shared_ptr +LedgerStateSnapshot::loadLiveEntry(LedgerKey const& k) const +{ + return mLiveSnapshot.load(k); +} + +std::vector +LedgerStateSnapshot::loadLiveKeys( + std::set const& inKeys, + std::string const& label) const +{ + return mLiveSnapshot.loadKeys(inKeys, label); +} + +std::optional> +LedgerStateSnapshot::loadLiveKeysFromLedger( + std::set const& inKeys, + uint32_t ledgerSeq) const +{ + return mLiveSnapshot.loadKeysFromLedger(inKeys, ledgerSeq); +} + +std::vector +LedgerStateSnapshot::loadPoolShareTrustLinesByAccountAndAsset( + AccountID const& accountID, Asset const& asset) const +{ + return mLiveSnapshot.loadPoolShareTrustLinesByAccountAndAsset(accountID, + asset); +} + +std::vector +LedgerStateSnapshot::loadInflationWinners(size_t maxWinners, + int64_t minBalance) const +{ + return mLiveSnapshot.loadInflationWinners(maxWinners, minBalance); +} + +std::unique_ptr +LedgerStateSnapshot::scanForEviction(uint32_t ledgerSeq, + EvictionMetrics& metrics, + EvictionIterator iter, + std::shared_ptr stats, + StateArchivalSettings const& sas, + uint32_t ledgerVers) const +{ + return mLiveSnapshot.scanForEviction(ledgerSeq, metrics, std::move(iter), + std::move(stats), sas, ledgerVers); +} + +void +LedgerStateSnapshot::scanLiveEntriesOfType( + LedgerEntryType type, + std::function callback) const +{ + mLiveSnapshot.scanForEntriesOfType(type, std::move(callback)); +} + +// === Hot Archive BucketList wrapper methods === + +std::shared_ptr +LedgerStateSnapshot::loadArchiveEntry(LedgerKey const& k) const +{ + return mHotArchiveSnapshot.load(k); +} + +std::vector +LedgerStateSnapshot::loadArchiveKeys( + std::set const& inKeys) const +{ + return mHotArchiveSnapshot.loadKeys(inKeys); +} + +std::optional> +LedgerStateSnapshot::loadArchiveKeysFromLedger( + std::set const& inKeys, + uint32_t ledgerSeq) const +{ + return mHotArchiveSnapshot.loadKeysFromLedger(inKeys, ledgerSeq); +} + +void +LedgerStateSnapshot::scanAllArchiveEntries( + std::function callback) const +{ + mHotArchiveSnapshot.scanAllEntries(std::move(callback)); +} + +ApplyLedgerStateSnapshot::ApplyLedgerStateSnapshot( + CompleteConstLedgerStatePtr state, MetricsRegistry& metrics) + : LedgerStateSnapshot(std::move(state), metrics) +{ +} } diff --git a/src/ledger/LedgerStateSnapshot.h b/src/ledger/LedgerStateSnapshot.h index cbbc5fb6ec..38f0881de1 100644 --- a/src/ledger/LedgerStateSnapshot.h +++ b/src/ledger/LedgerStateSnapshot.h @@ -5,11 +5,11 @@ #pragma once #include "bucket/BucketListSnapshot.h" -#include "bucket/BucketSnapshotManager.h" #include "history/HistoryArchive.h" #include "ledger/LedgerTxn.h" #include "ledger/NetworkConfig.h" #include "util/NonCopyable.h" +#include #include namespace stellar @@ -18,7 +18,15 @@ namespace stellar class Application; class TransactionFrame; class LedgerSnapshot; +class ApplyLedgerStateSnapshot; class CompleteConstLedgerState; +class EvictionStatistics; +struct EvictionMetrics; +struct EvictionResultCandidates; +struct InflationWinner; +struct StateArchivalSettings; +class LiveBucketList; +class HotArchiveBucketList; // NB: we can't use unique_ptr here, because this object gets passed to a // lambda, and std::function requires its callable to be copyable (C++23 fixes @@ -53,7 +61,6 @@ class LedgerEntryWrapper class LedgerHeaderWrapper { std::variant> mHeader; - friend class BucketSnapshotState; public: explicit LedgerHeaderWrapper(LedgerTxnHeader&& header); @@ -112,17 +119,105 @@ class LedgerTxnReadOnly : public AbstractLedgerStateSnapshot std::function f) const override; }; +// A copyable value type that provides searchable access to a +// CompleteConstLedgerState. Each instance maintains its own file stream cache +// for bucket I/O. Multiple LedgerStateSnapshot instances can safely wrap the +// same CompleteConstLedgerState. +class LedgerStateSnapshot +{ + std::shared_ptr mState; + SearchableLiveBucketListSnapshot mLiveSnapshot; + SearchableHotArchiveBucketListSnapshot mHotArchiveSnapshot; + std::reference_wrapper mMetrics; + + friend class CompleteConstLedgerState; + friend class BucketSnapshotState; + + public: + // Construct from CompleteConstLedgerState + explicit LedgerStateSnapshot(CompleteConstLedgerStatePtr state, + MetricsRegistry& metrics); + + CompleteConstLedgerState const& getState() const; + LedgerHeader const& getLedgerHeader() const; + uint32_t getLedgerSeq() const; + + // === Live BucketList methods === + std::shared_ptr loadLiveEntry(LedgerKey const& k) const; + std::vector + loadLiveKeys(std::set const& inKeys, + std::string const& label) const; + std::optional> + loadLiveKeysFromLedger(std::set const& inKeys, + uint32_t ledgerSeq) const; + std::vector + loadPoolShareTrustLinesByAccountAndAsset(AccountID const& accountID, + Asset const& asset) const; + std::vector loadInflationWinners(size_t maxWinners, + int64_t minBalance) const; + std::unique_ptr scanForEviction( + uint32_t ledgerSeq, EvictionMetrics& metrics, EvictionIterator iter, + std::shared_ptr stats, + StateArchivalSettings const& sas, uint32_t ledgerVers) const; + void scanLiveEntriesOfType( + LedgerEntryType type, + std::function callback) const; + + // === Hot Archive BucketList methods === + std::shared_ptr + loadArchiveEntry(LedgerKey const& k) const; + std::vector + loadArchiveKeys(std::set const& inKeys) const; + std::optional> loadArchiveKeysFromLedger( + std::set const& inKeys, + uint32_t ledgerSeq) const; + void scanAllArchiveEntries( + std::function callback) const; +}; + +// A strong typedef for LedgerStateSnapshot that represents a snapshot used +// during apply time. This is identical to LedgerStateSnapshot in practice, but +// is a distinct type to prevent accidental interchange between apply-time +// snapshots and other snapshots (e.g., from mLastClosedLedgerState). +class ApplyLedgerStateSnapshot : private LedgerStateSnapshot +{ + friend class BucketSnapshotState; + + public: + explicit ApplyLedgerStateSnapshot(CompleteConstLedgerStatePtr state, + MetricsRegistry& metrics); + + using LedgerStateSnapshot::getLedgerHeader; + using LedgerStateSnapshot::getLedgerSeq; + using LedgerStateSnapshot::getState; + using LedgerStateSnapshot::loadArchiveEntry; + using LedgerStateSnapshot::loadArchiveKeys; + using LedgerStateSnapshot::loadArchiveKeysFromLedger; + using LedgerStateSnapshot::loadInflationWinners; + using LedgerStateSnapshot::loadLiveEntry; + using LedgerStateSnapshot::loadLiveKeys; + using LedgerStateSnapshot::loadLiveKeysFromLedger; + using LedgerStateSnapshot::loadPoolShareTrustLinesByAccountAndAsset; + using LedgerStateSnapshot::scanAllArchiveEntries; + using LedgerStateSnapshot::scanForEviction; + using LedgerStateSnapshot::scanLiveEntriesOfType; +}; + // A concrete implementation of read-only BucketList snapshot wrapper class BucketSnapshotState : public AbstractLedgerStateSnapshot { - SearchableSnapshotConstPtr const mSnapshot; - // Store a copy of the header from mSnapshot. This is needed for - // validation flow where for certain validation scenarios the header needs - // to be modified - LedgerHeaderWrapper mLedgerHeader; + SearchableLiveBucketListSnapshot mLiveSnap; + // Store a copy of the header. This is needed for validation flow where + // for certain validation scenarios the header needs to be modified. + std::shared_ptr mLedgerHeader; public: - BucketSnapshotState(SearchableSnapshotConstPtr snapshot); + explicit BucketSnapshotState(LedgerStateSnapshot const& snap); + explicit BucketSnapshotState(ApplyLedgerStateSnapshot const& snap); + BucketSnapshotState( + MetricsRegistry& metrics, + std::shared_ptr const> liveData, + LedgerHeader const& header); ~BucketSnapshotState() override; LedgerHeaderWrapper getLedgerHeader() const override; @@ -152,7 +247,14 @@ class LedgerSnapshot : public NonMovableOrCopyable public: LedgerSnapshot(AbstractLedgerTxn& ltx); LedgerSnapshot(Application& app); - explicit LedgerSnapshot(SearchableSnapshotConstPtr snapshot); + explicit LedgerSnapshot(LedgerStateSnapshot const& snap); + explicit LedgerSnapshot(ApplyLedgerStateSnapshot const& snap); + // Construct from a lightweight live bucket snapshot + header, + // without requiring a full CompleteConstLedgerState. + LedgerSnapshot( + MetricsRegistry& metrics, + std::shared_ptr const> liveData, + LedgerHeader const& header); LedgerHeaderWrapper getLedgerHeader() const; LedgerEntryWrapper getAccount(AccountID const& account) const; LedgerEntryWrapper @@ -195,23 +297,40 @@ class LedgerSnapshot : public NonMovableOrCopyable class CompleteConstLedgerState : public NonMovableOrCopyable { private: - SearchableSnapshotConstPtr const mBucketSnapshot; - SearchableHotArchiveSnapshotConstPtr const mHotArchiveSnapshot; + // Raw immutable bucket data for the live and hot archive bucket lists + std::shared_ptr const> const + mLiveBucketData; + std::map const>> const + mLiveHistoricalSnapshots; + std::shared_ptr const> const + mHotArchiveBucketData; + std::map< + uint32_t, + std::shared_ptr const>> const + mHotArchiveHistoricalSnapshots; + std::optional const mSorobanConfig; LedgerHeaderHistoryEntry const mLastClosedLedgerHeader; HistoryArchiveState const mLastClosedHistoryArchiveState; void checkInvariant() const; + friend class LedgerStateSnapshot; + public: - CompleteConstLedgerState( - SearchableSnapshotConstPtr searchableSnapshot, - SearchableHotArchiveSnapshotConstPtr hotArchiveSnapshot, - LedgerHeaderHistoryEntry const& lastClosedLedgerHeader, - HistoryArchiveState const& lastClosedHistoryArchiveState); - - SearchableSnapshotConstPtr getBucketSnapshot() const; - SearchableHotArchiveSnapshotConstPtr getHotArchiveSnapshot() const; + // Construct a new ledger state, rotating historical snapshots from + // prevState. If prevState is null, history maps will be empty. + // sorobanConfig is nullopt for pre-Soroban protocol versions, or when + // building the empty initial state at startup. + CompleteConstLedgerState(LiveBucketList const& liveBL, + HotArchiveBucketList const& hotArchiveBL, + LedgerHeaderHistoryEntry const& lcl, + HistoryArchiveState const& has, + std::optional sorobanConfig, + CompleteConstLedgerStatePtr prevState, + uint32_t numHistoricalSnapshots); + SorobanNetworkConfig const& getSorobanConfig() const; bool hasSorobanConfig() const; LedgerHeaderHistoryEntry const& getLastClosedLedgerHeader() const; diff --git a/src/ledger/LedgerTxn.cpp b/src/ledger/LedgerTxn.cpp index 5523cd2c5d..7373084f06 100644 --- a/src/ledger/LedgerTxn.cpp +++ b/src/ledger/LedgerTxn.cpp @@ -2734,10 +2734,10 @@ LedgerTxnRoot::Impl::Impl(Application& app, , mEntryCache(entryCacheSize) , mBulkLoadBatchSize(prefetchBatchSize) , mChild(nullptr) + , mThreadInvariant() #ifdef BEST_OFFER_DEBUGGING , mBestOfferDebuggingEnabled(bestOfferDebuggingEnabled) #endif - , mThreadInvariant() { } @@ -2962,8 +2962,8 @@ LedgerTxnRoot::Impl::commitChild(EntryIterator iter, mPrefetchHits = 0; mPrefetchMisses = 0; - // std::shared_ptr<...>::reset does not throw - mSearchableBucketListSnapshot.reset(); + // std::optional<...>::reset does not throw + mLedgerStateSnapshot.reset(); mThreadInvariant.clearActiveThread(); } @@ -3070,8 +3070,8 @@ LedgerTxnRoot::Impl::prefetch(UnorderedSet const& keys) { insertIfNotLoaded(keysToSearch, key); } - auto blLoad = getSearchableLiveBucketListSnapshot().loadKeys(keysToSearch, - "prefetch"); + auto blLoad = + getLedgerStateSnapshot().loadLiveKeys(keysToSearch, "prefetch"); cacheResult(populateLoadedEntries(keysToSearch, blLoad)); return total; @@ -3342,18 +3342,16 @@ LedgerTxnRoot::Impl::areEntriesMissingInCacheForOffer(OfferEntry const& oe) return false; } -SearchableLiveBucketListSnapshot const& -LedgerTxnRoot::Impl::getSearchableLiveBucketListSnapshot() const +ApplyLedgerStateSnapshot const& +LedgerTxnRoot::Impl::getLedgerStateSnapshot() const { - if (!mSearchableBucketListSnapshot) + if (!mLedgerStateSnapshot) { - mSearchableBucketListSnapshot = - mApp.getBucketManager() - .getBucketSnapshotManager() - .copySearchableLiveBucketListSnapshot(); + mLedgerStateSnapshot = + mApp.getLedgerManager().copyApplyLedgerStateSnapshot(); } - return *mSearchableBucketListSnapshot; + return *mLedgerStateSnapshot; } std::shared_ptr @@ -3489,8 +3487,8 @@ LedgerTxnRoot::Impl::getPoolShareTrustLinesByAccountAndAsset( try { trustLines = - getSearchableLiveBucketListSnapshot() - .loadPoolShareTrustLinesByAccountAndAsset(account, asset); + getLedgerStateSnapshot().loadPoolShareTrustLinesByAccountAndAsset( + account, asset); } catch (std::exception& e) { @@ -3540,8 +3538,8 @@ LedgerTxnRoot::Impl::getInflationWinners(size_t maxWinners, int64_t minVotes) { try { - return getSearchableLiveBucketListSnapshot().loadInflationWinners( - maxWinners, minVotes); + return getLedgerStateSnapshot().loadInflationWinners(maxWinners, + minVotes); } catch (std::exception& e) { @@ -3626,7 +3624,7 @@ LedgerTxnRoot::Impl::getNewestVersion(InternalLedgerKey const& gkey) const } else { - entry = getSearchableLiveBucketListSnapshot().load(key); + entry = getLedgerStateSnapshot().loadLiveEntry(key); } } catch (std::exception& e) @@ -3695,7 +3693,7 @@ LedgerTxnRoot::Impl::rollbackChild() noexcept mChild = nullptr; mPrefetchHits = 0; mPrefetchMisses = 0; - mSearchableBucketListSnapshot.reset(); + mLedgerStateSnapshot.reset(); mThreadInvariant.clearActiveThread(); } diff --git a/src/ledger/LedgerTxnImpl.h b/src/ledger/LedgerTxnImpl.h index 7e9c9b1e3d..76de284b63 100644 --- a/src/ledger/LedgerTxnImpl.h +++ b/src/ledger/LedgerTxnImpl.h @@ -4,12 +4,11 @@ #pragma once -#include "bucket/BucketSnapshotManager.h" #include "database/Database.h" +#include "ledger/LedgerStateSnapshot.h" #include "ledger/LedgerTxn.h" #include "util/RandomEvictionCache.h" #include "util/UnorderedSet.h" -#include #include #ifdef USE_POSTGRES #include @@ -620,7 +619,7 @@ class LedgerTxnRoot::Impl mutable BestOffers mBestOffers; mutable uint64_t mPrefetchHits{0}; mutable uint64_t mPrefetchMisses{0}; - mutable SearchableSnapshotConstPtr mSearchableBucketListSnapshot; + mutable std::optional mLedgerStateSnapshot; size_t mBulkLoadBatchSize; std::unique_ptr mTransaction; @@ -689,8 +688,7 @@ class LedgerTxnRoot::Impl bool areEntriesMissingInCacheForOffer(OfferEntry const& oe); - SearchableLiveBucketListSnapshot const& - getSearchableLiveBucketListSnapshot() const; + ApplyLedgerStateSnapshot const& getLedgerStateSnapshot() const; public: // Constructor has the strong exception safety guarantee diff --git a/src/ledger/NetworkConfig.cpp b/src/ledger/NetworkConfig.cpp index f127ea2dc2..1f8500497c 100644 --- a/src/ledger/NetworkConfig.cpp +++ b/src/ledger/NetworkConfig.cpp @@ -1695,13 +1695,6 @@ SorobanNetworkConfig::loadFromLedger(LedgerSnapshot const& ls) return config; } -SorobanNetworkConfig -SorobanNetworkConfig::loadFromLedger(SearchableSnapshotConstPtr snapshot) -{ - LedgerSnapshot ls(snapshot); - return SorobanNetworkConfig::loadFromLedger(ls); -} - SorobanNetworkConfig SorobanNetworkConfig::loadFromLedger(AbstractLedgerTxn& ltx) { diff --git a/src/ledger/NetworkConfig.h b/src/ledger/NetworkConfig.h index 0999d57311..cd561396d6 100644 --- a/src/ledger/NetworkConfig.h +++ b/src/ledger/NetworkConfig.h @@ -262,8 +262,6 @@ class SorobanNetworkConfig public: // Static factory function to create a SorobanNetworkConfig from ledger static SorobanNetworkConfig loadFromLedger(LedgerSnapshot const& ls); - static SorobanNetworkConfig - loadFromLedger(SearchableSnapshotConstPtr snapshot); static SorobanNetworkConfig loadFromLedger(AbstractLedgerTxn& ltx); #ifdef BUILD_TESTS diff --git a/src/ledger/P23HotArchiveBug.cpp b/src/ledger/P23HotArchiveBug.cpp index 6a6d66f09a..09e871bb45 100644 --- a/src/ledger/P23HotArchiveBug.cpp +++ b/src/ledger/P23HotArchiveBug.cpp @@ -7,13 +7,11 @@ #include #include -#include "bucket/BucketListSnapshot.h" #include "bucket/BucketManager.h" #include "bucket/BucketUtils.h" +#include "ledger/LedgerStateSnapshot.h" #include "ledger/LedgerTxn.h" #include "ledger/LedgerTxnImpl.h" -#include "ledger/LedgerTypeUtils.h" -#include "main/AppConnector.h" #include "main/Application.h" #include @@ -36,7 +34,8 @@ using namespace internal; void addHotArchiveBatchWithP23HotArchiveFix( - AbstractLedgerTxn& ltx, Application& app, LedgerHeader header, + AbstractLedgerTxn& ltx, Application& app, + ApplyLedgerStateSnapshot const& snapshot, LedgerHeader header, std::vector const& archivedEntries, std::vector const& restoredEntries) { @@ -49,8 +48,6 @@ addHotArchiveBatchWithP23HotArchiveFix( auto updatedArchivedEntries = archivedEntries; updatedArchivedEntries.reserve(updatedArchivedEntries.size() + P23_CORRUPTED_HOT_ARCHIVE_ENTRIES_COUNT); - auto const& hotArchiveSnapshot = - app.getAppConnector().copySearchableHotArchiveBucketListSnapshot(); for (size_t i = 0; i < P23_CORRUPTED_HOT_ARCHIVE_ENTRIES_COUNT; ++i) { LedgerEntry corruptedEntry = @@ -68,7 +65,7 @@ addHotArchiveBatchWithP23HotArchiveFix( // Hot Archive that match our expectations for the corrupted entries. // Ensure that the entry exists in Hot Archive. - auto hotArchiveEntry = hotArchiveSnapshot->load(corruptedEntryKey); + auto hotArchiveEntry = snapshot.loadArchiveEntry(corruptedEntryKey); if (!hotArchiveEntry) { CLOG_WARNING( @@ -337,8 +334,9 @@ Protocol23CorruptionDataVerifier::verifyRestorationOfCorruptedEntry( void Protocol23CorruptionDataVerifier::verifyArchivalOfCorruptedEntry( - EvictedStateVectors const& evictedState, Application& app, - uint32_t ledgerSeq, uint32_t protocolVersion) + EvictedStateVectors const& evictedState, + ApplyLedgerStateSnapshot const& snapshot, uint32_t ledgerSeq, + uint32_t protocolVersion) { if (!protocolVersionEquals(protocolVersion, ProtocolVersion::V_23)) { @@ -348,13 +346,6 @@ Protocol23CorruptionDataVerifier::verifyArchivalOfCorruptedEntry( // p23 we haven't increased the number of threads. std::lock_guard lock(mMutex); - // This database can load the actual, correct version of a - // given ledger key. This tells us the value that should - // have been evicted. - auto liveDatabase = app.getBucketManager() - .getBucketSnapshotManager() - .copySearchableLiveBucketListSnapshot(); - // This is the set of all keys incorrectly evicted for this // ledger auto evictedKeysIter = mEvictedSeqToKeys.find(ledgerSeq); @@ -368,7 +359,7 @@ Protocol23CorruptionDataVerifier::verifyArchivalOfCorruptedEntry( { // Load the correct value from the live database. auto evictedLedgerKey = LedgerEntryKey(evictedEntry); - auto databaseEntry = liveDatabase->load(evictedLedgerKey); + auto databaseEntry = snapshot.loadLiveEntry(evictedLedgerKey); releaseAssert(databaseEntry != nullptr); // If there was a corruption diff --git a/src/ledger/P23HotArchiveBug.h b/src/ledger/P23HotArchiveBug.h index 690620217c..565df5f2d2 100644 --- a/src/ledger/P23HotArchiveBug.h +++ b/src/ledger/P23HotArchiveBug.h @@ -18,6 +18,7 @@ namespace stellar { class Application; class AbstractLedgerTxn; +class ApplyLedgerStateSnapshot; class Config; struct EvictedStateVectors; @@ -86,9 +87,11 @@ class Protocol23CorruptionDataVerifier // This should be called for every eviction that occurs during catchup, // non-corrupted evictions are ignored. // This is thread-safe. - void verifyArchivalOfCorruptedEntry(EvictedStateVectors const& evictedState, - Application& app, uint32_t ledgerSeq, - uint32_t protocolVersion); + void + verifyArchivalOfCorruptedEntry(EvictedStateVectors const& evictedState, + ApplyLedgerStateSnapshot const& snapshot, + uint32_t ledgerSeq, + uint32_t protocolVersion); // Verifies that the batch of Hot Archive fixes on protocol 24 upgrade // corresponds to the expected data (i.e. only entries that were never // restored have been fixed, and that the fix comes back to the correct @@ -171,7 +174,8 @@ class Protocol23CorruptionEventReconciler }; void addHotArchiveBatchWithP23HotArchiveFix( - AbstractLedgerTxn& ltx, Application& app, LedgerHeader header, + AbstractLedgerTxn& ltx, Application& app, + ApplyLedgerStateSnapshot const& snapshot, LedgerHeader header, std::vector const& archivedEntries, std::vector const& restoredEntries); diff --git a/src/ledger/SharedModuleCacheCompiler.cpp b/src/ledger/SharedModuleCacheCompiler.cpp index 3158c31459..e80120400f 100644 --- a/src/ledger/SharedModuleCacheCompiler.cpp +++ b/src/ledger/SharedModuleCacheCompiler.cpp @@ -3,7 +3,6 @@ // of this distribution or at http://www.apache.org/licenses/LICENSE-2.0 #include "ledger/SharedModuleCacheCompiler.h" -#include "bucket/BucketListSnapshot.h" #include "crypto/Hex.h" #include "crypto/SHA.h" #include "rust/RustBridge.h" @@ -19,14 +18,13 @@ namespace stellar size_t const SharedModuleCacheCompiler::BUFFERED_WASM_CAPACITY = 100 * 1024 * 1024; -// The snapshot is copied here to ensure the background loading thread has its -// own instance since snapshots themselves aren't thread safe. +// The snapshot is passed by copy here to ensure the background loading thread +// has its own instance since snapshots themselves aren't thread safe. SharedModuleCacheCompiler::SharedModuleCacheCompiler( - SearchableSnapshotConstPtr snap, MetricsRegistry& metrics, - size_t numThreads, std::vector const& ledgerVersions) + ApplyLedgerStateSnapshot snap, size_t numThreads, + std::vector const& ledgerVersions) : mModuleCache(rust_bridge::new_module_cache()) - , mSnap(BucketSnapshotManager::copySearchableLiveBucketListSnapshot( - snap, metrics)) + , mSnap(std::move(snap)) , mNumThreads(numThreads) , mLedgerVersions(ledgerVersions) , mStarted(std::chrono::steady_clock::now()) @@ -150,7 +148,7 @@ SharedModuleCacheCompiler::start() std::unordered_set seenContracts; size_t liveContracts{0}; // Note: this access is safe since we only have a single loading thread. - this->mSnap->scanForEntriesOfType( + this->mSnap.scanLiveEntriesOfType( CONTRACT_CODE, [&](BucketEntry const& entry) { Hash h; switch (entry.type()) diff --git a/src/ledger/SharedModuleCacheCompiler.h b/src/ledger/SharedModuleCacheCompiler.h index 40e7d71804..26bc76bd50 100644 --- a/src/ledger/SharedModuleCacheCompiler.h +++ b/src/ledger/SharedModuleCacheCompiler.h @@ -4,7 +4,7 @@ #pragma once -#include "bucket/BucketSnapshotManager.h" +#include "ledger/LedgerStateSnapshot.h" #include "rust/RustBridge.h" #include "util/NonCopyable.h" #include "xdrpp/types.h" @@ -25,7 +25,7 @@ namespace stellar class SharedModuleCacheCompiler : NonMovableOrCopyable { ::rust::Box mModuleCache; - stellar::SearchableSnapshotConstPtr mSnap; + ApplyLedgerStateSnapshot mSnap; std::deque> mWasms; size_t const mNumThreads; @@ -55,8 +55,7 @@ class SharedModuleCacheCompiler : NonMovableOrCopyable bool popAndCompileWasm(size_t thread, std::unique_lock& lock); public: - SharedModuleCacheCompiler(SearchableSnapshotConstPtr snap, - MetricsRegistry& metrics, size_t numThreads, + SharedModuleCacheCompiler(ApplyLedgerStateSnapshot snap, size_t numThreads, std::vector const& ledgerVersions); ~SharedModuleCacheCompiler(); void start(); diff --git a/src/main/AppConnector.cpp b/src/main/AppConnector.cpp index 249277e85f..a42e5c43a9 100644 --- a/src/main/AppConnector.cpp +++ b/src/main/AppConnector.cpp @@ -169,50 +169,25 @@ AppConnector::threadIsType(Application::ThreadType type) const return mApp.threadIsType(type); } -SearchableHotArchiveSnapshotConstPtr -AppConnector::copySearchableHotArchiveBucketListSnapshot() +LedgerStateSnapshot +AppConnector::copyLedgerStateSnapshot() { - return mApp.getBucketManager() - .getBucketSnapshotManager() - .copySearchableHotArchiveBucketListSnapshot(); + return mApp.getLedgerManager().copyLedgerStateSnapshot(); } -SearchableSnapshotConstPtr -AppConnector::copySearchableLiveBucketListSnapshot() +ApplyLedgerStateSnapshot +AppConnector::copyApplyLedgerStateSnapshot() { - return mApp.getBucketManager() - .getBucketSnapshotManager() - .copySearchableLiveBucketListSnapshot(); + return mApp.getLedgerManager().copyApplyLedgerStateSnapshot(); } void -AppConnector::maybeCopySearchableBucketListSnapshot( - SearchableSnapshotConstPtr& snapshot) +AppConnector::maybeUpdateLedgerStateSnapshot(LedgerStateSnapshot& snapshot) { - mApp.getBucketManager() - .getBucketSnapshotManager() - .maybeCopySearchableBucketListSnapshot(snapshot); + mApp.getLedgerManager().maybeUpdateLedgerStateSnapshot(snapshot); } -void -AppConnector::maybeCopyLiveAndHotArchiveSnapshots( - SearchableSnapshotConstPtr& liveSnapshot, - SearchableHotArchiveSnapshotConstPtr& hotArchiveSnapshot) -{ - mApp.getBucketManager() - .getBucketSnapshotManager() - .maybeCopyLiveAndHotArchiveSnapshots(liveSnapshot, hotArchiveSnapshot); -} - -std::pair -AppConnector::copySearchableBucketListSnapshots() -{ - return mApp.getBucketManager() - .getBucketSnapshotManager() - .copySearchableBucketListSnapshots(); -} - -SearchableSnapshotConstPtr& +LedgerStateSnapshot& AppConnector::getOverlayThreadSnapshot() { return mApp.getOverlayManager().getOverlayThreadSnapshot(); diff --git a/src/main/AppConnector.h b/src/main/AppConnector.h index 7f90a13daf..12b774c8c6 100644 --- a/src/main/AppConnector.h +++ b/src/main/AppConnector.h @@ -5,6 +5,7 @@ #pragma once #include "bucket/BucketUtils.h" +#include "ledger/LedgerStateSnapshot.h" #include "main/Application.h" #include "main/Config.h" #include "rust/RustBridge.h" @@ -72,25 +73,13 @@ class AppConnector bool isStopping() const; - SearchableHotArchiveSnapshotConstPtr - copySearchableHotArchiveBucketListSnapshot(); - - SearchableSnapshotConstPtr copySearchableLiveBucketListSnapshot(); - - // Refreshes `snapshot` if a newer snapshot is available. No-op otherwise. - void - maybeCopySearchableBucketListSnapshot(SearchableSnapshotConstPtr& snapshot); - - void maybeCopyLiveAndHotArchiveSnapshots( - SearchableSnapshotConstPtr& liveSnapshot, - SearchableHotArchiveSnapshotConstPtr& hotArchiveSnapshot); - - std::pair - copySearchableBucketListSnapshots(); + LedgerStateSnapshot copyLedgerStateSnapshot(); + ApplyLedgerStateSnapshot copyApplyLedgerStateSnapshot(); + void maybeUpdateLedgerStateSnapshot(LedgerStateSnapshot& snapshot); // Get a snapshot of ledger state for use by the overlay thread only. Must // only be called from the overlay thread. - SearchableSnapshotConstPtr& getOverlayThreadSnapshot(); + LedgerStateSnapshot& getOverlayThreadSnapshot(); // Protocol 23 data corruption bug data verifier. This typically is null, // unless a path to a CSV file containing the corruption data was provided diff --git a/src/main/ApplicationUtils.cpp b/src/main/ApplicationUtils.cpp index 81bb553abc..5aa85cf38b 100644 --- a/src/main/ApplicationUtils.cpp +++ b/src/main/ApplicationUtils.cpp @@ -26,7 +26,6 @@ #include "main/PersistentState.h" #include "main/StellarCoreVersion.h" #include "overlay/OverlayManager.h" -#include "scp/LocalNode.h" #include "util/GlobalChecks.h" #include "util/Logging.h" #include "util/XDRCereal.h" @@ -37,7 +36,6 @@ #include #include -#include #include #include #include @@ -485,8 +483,6 @@ getHotArchiveListBalanceForAsset(Application& app, AssetContractInfo const& assetContractInfo, int64_t& runningBalance) { - auto& bm = app.getBucketManager(); - std::map archived = app.getBucketManager().loadCompleteHotArchiveState(has); for (auto const& [_, entry] : archived) @@ -757,8 +753,7 @@ dumpLedger(Config cfg, std::string const& outputFile, auto& lm = app->getLedgerManager(); lm.partiallyLoadLastKnownLedgerForUtils(); - auto liveSnapshot = - app->getAppConnector().copySearchableLiveBucketListSnapshot(); + auto liveSnapshot = app->getAppConnector().copyLedgerStateSnapshot(); auto ttlGetter = [&liveSnapshot, includeAllStates, dumpHotArchive](LedgerKey const& key) -> uint32_t { if (includeAllStates || dumpHotArchive) @@ -767,7 +762,7 @@ dumpLedger(Config cfg, std::string const& outputFile, "TTL is undefined when `--include-all-states` or " "`--hot-archive` flag is set."); } - auto entry = liveSnapshot->load(key); + auto entry = liveSnapshot.loadLiveEntry(key); if (!entry) { throw std::runtime_error("No TTL entry found for key: " + @@ -897,12 +892,10 @@ dumpWasmBlob(Config cfg, std::string const& hash, std::string const& dir) LOG_INFO(DEFAULT_LOG, "Wrote {} bytes to {}", entry.code.size(), filename); }; - auto snap = app->getBucketManager() - .getBucketSnapshotManager() - .copySearchableLiveBucketListSnapshot(); + auto snap = app->getLedgerManager().copyLedgerStateSnapshot(); if (hash == "ALL") { - snap->scanForEntriesOfType( + snap.scanLiveEntriesOfType( CONTRACT_CODE, [&](BucketEntry const& entry) { if (entry.type() == INITENTRY || entry.type() == LIVEENTRY) { @@ -918,7 +911,7 @@ dumpWasmBlob(Config cfg, std::string const& hash, std::string const& dir) LedgerKey key; key.type(LedgerEntryType::CONTRACT_CODE); key.contractCode().hash = hexToBin256(hash); - auto entry = snap->load(key); + auto entry = snap.loadLiveEntry(key); if (entry && entry->data.type() == LedgerEntryType::CONTRACT_CODE) { auto const& codeEntry = entry->data.contractCode(); diff --git a/src/main/CommandHandler.cpp b/src/main/CommandHandler.cpp index 14d2e4ee56..18c4e00f18 100644 --- a/src/main/CommandHandler.cpp +++ b/src/main/CommandHandler.cpp @@ -3,8 +3,6 @@ // of this distribution or at http://www.apache.org/licenses/LICENSE-2.0 #include "main/CommandHandler.h" -#include "bucket/BucketManager.h" -#include "bucket/BucketSnapshotManager.h" #include "crypto/KeyUtils.h" #include "herder/Herder.h" #include "history/HistoryArchiveManager.h" diff --git a/src/main/QueryServer.cpp b/src/main/QueryServer.cpp index ae5f3fee87..f09628fc50 100644 --- a/src/main/QueryServer.cpp +++ b/src/main/QueryServer.cpp @@ -78,11 +78,8 @@ QueryServer::QueryServer(std::string const& address, unsigned short port, #ifdef BUILD_TESTS if (useMainThreadForTesting) { - auto [live, hotArchive] = - mAppConnector.copySearchableBucketListSnapshots(); - mBucketListSnapshots[std::this_thread::get_id()] = std::move(live); - mHotArchiveBucketListSnapshots[std::this_thread::get_id()] = - std::move(hotArchive); + mSnapshots.emplace(std::this_thread::get_id(), + mAppConnector.copyLedgerStateSnapshot()); } else #endif @@ -90,10 +87,7 @@ QueryServer::QueryServer(std::string const& address, unsigned short port, auto workerPids = mServer.start(); for (auto pid : workerPids) { - auto [live, hotArchive] = - mAppConnector.copySearchableBucketListSnapshots(); - mBucketListSnapshots[pid] = std::move(live); - mHotArchiveBucketListSnapshots[pid] = std::move(hotArchive); + mSnapshots.emplace(pid, mAppConnector.copyLedgerStateSnapshot()); } } } @@ -167,10 +161,6 @@ QueryServer::getLedgerEntryRaw(std::string const& params, std::string const& body, std::string& retStr) { ZoneScoped; - - auto& snapshotPtr = mBucketListSnapshots.at(std::this_thread::get_id()); - mAppConnector.maybeCopySearchableBucketListSnapshot(snapshotPtr); - Json::Value root; std::map> paramMap; @@ -181,7 +171,8 @@ QueryServer::getLedgerEntryRaw(std::string const& params, if (!keys.empty()) { - auto& bl = *snapshotPtr; + auto& snapshot = mSnapshots.at(std::this_thread::get_id()); + mAppConnector.maybeUpdateLedgerStateSnapshot(snapshot); LedgerKeySet orderedKeys; for (auto const& key : keys) @@ -199,7 +190,7 @@ QueryServer::getLedgerEntryRaw(std::string const& params, root["ledgerSeq"] = *snapshotLedger; auto loadedKeysOp = - bl.loadKeysFromLedger(orderedKeys, *snapshotLedger); + snapshot.loadLiveKeysFromLedger(orderedKeys, *snapshotLedger); // Return 404 if ledgerSeq not found if (!loadedKeysOp) @@ -213,8 +204,8 @@ QueryServer::getLedgerEntryRaw(std::string const& params, // Otherwise default to current ledger else { - loadedKeys = bl.loadKeys(orderedKeys, "query"); - root["ledgerSeq"] = bl.getLedgerSeq(); + loadedKeys = snapshot.loadLiveKeys(orderedKeys, "query"); + root["ledgerSeq"] = snapshot.getLedgerSeq(); } for (auto const& le : loadedKeys) @@ -247,13 +238,6 @@ QueryServer::getLedgerEntry(std::string const& params, std::string const& body, std::string& retStr) { ZoneScoped; - - auto& liveBl = mBucketListSnapshots.at(std::this_thread::get_id()); - auto& hotArchiveBl = - mHotArchiveBucketListSnapshots.at(std::this_thread::get_id()); - - mAppConnector.maybeCopyLiveAndHotArchiveSnapshots(liveBl, hotArchiveBl); - Json::Value root; std::map> paramMap; @@ -269,6 +253,8 @@ QueryServer::getLedgerEntry(std::string const& params, std::string const& body, return false; } + auto& snapshot = mSnapshots.at(std::this_thread::get_id()); + mAppConnector.maybeUpdateLedgerStateSnapshot(snapshot); LedgerKeySet keysToSearch; // Keep track of keys in their original order for response ordering @@ -297,10 +283,11 @@ QueryServer::getLedgerEntry(std::string const& params, std::string const& body, std::vector liveEntries; std::vector archivedEntries; uint32_t ledgerSeq = - snapshotLedger ? *snapshotLedger : liveBl->getLedgerSeq(); + snapshotLedger ? *snapshotLedger : snapshot.getLedgerSeq(); root["ledgerSeq"] = ledgerSeq; - auto liveEntriesOp = liveBl->loadKeysFromLedger(keysToSearch, ledgerSeq); + auto liveEntriesOp = + snapshot.loadLiveKeysFromLedger(keysToSearch, ledgerSeq); // Return 404 if ledgerSeq not found if (!liveEntriesOp) @@ -329,8 +316,8 @@ QueryServer::getLedgerEntry(std::string const& params, std::string const& body, // Only query archive for soroban keys we didn't find in the live bucketList if (!hotArchiveKeysToSearch.empty()) { - auto archivedEntriesOp = - hotArchiveBl->loadKeysFromLedger(hotArchiveKeysToSearch, ledgerSeq); + auto archivedEntriesOp = snapshot.loadArchiveKeysFromLedger( + hotArchiveKeysToSearch, ledgerSeq); if (!archivedEntriesOp) { retStr = "Ledger not found\n"; @@ -354,8 +341,8 @@ QueryServer::getLedgerEntry(std::string const& params, std::string const& body, { // We haven't updated the live snapshot so we know the have a snapshot // available for ledgerSeq - ttlEntries = - std::move(liveBl->loadKeysFromLedger(ttlKeys, ledgerSeq).value()); + ttlEntries = std::move( + snapshot.loadLiveKeysFromLedger(ttlKeys, ledgerSeq).value()); } std::unordered_map ttlMap; diff --git a/src/main/QueryServer.h b/src/main/QueryServer.h index e00ca7ba68..83008b7203 100644 --- a/src/main/QueryServer.h +++ b/src/main/QueryServer.h @@ -6,7 +6,7 @@ #include "lib/httpthreaded/server.hpp" -#include "bucket/BucketSnapshotManager.h" +#include "ledger/LedgerStateSnapshot.h" #include #include #include @@ -26,11 +26,7 @@ class QueryServer httpThreaded::server::server mServer; - std::unordered_map - mBucketListSnapshots; - - std::unordered_map - mHotArchiveBucketListSnapshots; + std::unordered_map mSnapshots; AppConnector& mAppConnector; diff --git a/src/main/test/QueryServerTests.cpp b/src/main/test/QueryServerTests.cpp index b4ba4b3185..bb15d14375 100644 --- a/src/main/test/QueryServerTests.cpp +++ b/src/main/test/QueryServerTests.cpp @@ -3,7 +3,6 @@ // of this distribution or at http://www.apache.org/licenses/LICENSE-2.0 #include "bucket/BucketIndexUtils.h" -#include "bucket/BucketManager.h" #include "bucket/test/BucketTestUtils.h" #include "ledger/LedgerTxnImpl.h" #include "ledger/LedgerTypeUtils.h" diff --git a/src/overlay/OverlayManager.h b/src/overlay/OverlayManager.h index bd2f453799..551c2133d1 100644 --- a/src/overlay/OverlayManager.h +++ b/src/overlay/OverlayManager.h @@ -5,6 +5,7 @@ #pragma once #include "crypto/BLAKE2.h" +#include "ledger/LedgerStateSnapshot.h" #include "overlay/Peer.h" /** @@ -214,6 +215,6 @@ class OverlayManager // Get a snapshot of ledger state for use by the overlay thread only. Caller // is responsible for updating the snapshot as needed. - virtual SearchableSnapshotConstPtr& getOverlayThreadSnapshot() = 0; + virtual LedgerStateSnapshot& getOverlayThreadSnapshot() = 0; }; } diff --git a/src/overlay/OverlayManagerImpl.cpp b/src/overlay/OverlayManagerImpl.cpp index 3cf558029e..fa201f90f9 100644 --- a/src/overlay/OverlayManagerImpl.cpp +++ b/src/overlay/OverlayManagerImpl.cpp @@ -9,7 +9,6 @@ #include "crypto/ShortHash.h" #include "database/Database.h" #include "herder/Herder.h" -#include "ledger/LedgerManager.h" #include "lib/util/finally.h" #include "lib/util/stdrandom.h" #include "main/Application.h" @@ -1432,18 +1431,17 @@ OverlayManagerImpl::recordMessageMetric(StellarMessage const& stellarMsg, } } -SearchableSnapshotConstPtr& +LedgerStateSnapshot& OverlayManagerImpl::getOverlayThreadSnapshot() { releaseAssert(mApp.threadIsType(Application::ThreadType::OVERLAY)); if (!mOverlayThreadSnapshot) { // Create a new snapshot - mOverlayThreadSnapshot = mApp.getBucketManager() - .getBucketSnapshotManager() - .copySearchableLiveBucketListSnapshot(); + mOverlayThreadSnapshot = + mApp.getLedgerManager().copyLedgerStateSnapshot(); } - return mOverlayThreadSnapshot; + return *mOverlayThreadSnapshot; } } diff --git a/src/overlay/OverlayManagerImpl.h b/src/overlay/OverlayManagerImpl.h index 3a62ddd45e..c4b41c0ab8 100644 --- a/src/overlay/OverlayManagerImpl.h +++ b/src/overlay/OverlayManagerImpl.h @@ -9,6 +9,7 @@ #include "PeerDoor.h" #include "PeerManager.h" #include "herder/TxSetFrame.h" +#include "ledger/LedgerStateSnapshot.h" #include "ledger/LedgerTxn.h" #include "overlay/Floodgate.h" #include "overlay/OverlayManager.h" @@ -167,7 +168,7 @@ class OverlayManagerImpl : public OverlayManager void recordMessageMetric(StellarMessage const& stellarMsg, Peer::pointer peer) override; - SearchableSnapshotConstPtr& getOverlayThreadSnapshot() override; + LedgerStateSnapshot& getOverlayThreadSnapshot() override; private: struct ResolvedPeers @@ -185,7 +186,7 @@ class OverlayManagerImpl : public OverlayManager mScheduledMessages; // Snapshot of ledger state for use ONLY by the overlay thread - SearchableSnapshotConstPtr mOverlayThreadSnapshot; + std::optional mOverlayThreadSnapshot; void triggerPeerResolution(); std::pair, bool> diff --git a/src/overlay/Peer.cpp b/src/overlay/Peer.cpp index e6d16ee3c3..95f9a07b30 100644 --- a/src/overlay/Peer.cpp +++ b/src/overlay/Peer.cpp @@ -67,7 +67,7 @@ populateSignatureCache(AppConnector& app, TransactionFrameBaseConstPtr tx) app.threadIsType(Application::ThreadType::OVERLAY)); auto& snapshot = app.getOverlayThreadSnapshot(); - app.maybeCopySearchableBucketListSnapshot(snapshot); + app.maybeUpdateLedgerStateSnapshot(snapshot); LedgerSnapshot ledgerSnapshot(snapshot); // Use ledgerSnapshot to check all transactions in `tx`. We use a lambda to diff --git a/src/simulation/ApplyLoad.cpp b/src/simulation/ApplyLoad.cpp index 3a2636b33d..b6b49f72ff 100644 --- a/src/simulation/ApplyLoad.cpp +++ b/src/simulation/ApplyLoad.cpp @@ -2,7 +2,6 @@ #include #include -#include #include #include #include @@ -20,15 +19,11 @@ #include "herder/HerderImpl.h" -#include "medida/metrics_registry.h" - #include "bucket/BucketListSnapshot.h" #include "bucket/BucketManager.h" -#include "bucket/BucketSnapshotManager.h" #include "util/GlobalChecks.h" #include "util/Logging.h" #include "util/XDRCereal.h" -#include "xdrpp/printer.h" #include namespace stellar diff --git a/src/simulation/test/LoadGeneratorTests.cpp b/src/simulation/test/LoadGeneratorTests.cpp index 148bcfd693..2482bce0e9 100644 --- a/src/simulation/test/LoadGeneratorTests.cpp +++ b/src/simulation/test/LoadGeneratorTests.cpp @@ -6,8 +6,8 @@ #include "crypto/SHA.h" #include "crypto/SecretKey.h" #include "ledger/LedgerManager.h" +#include "ledger/LedgerStateSnapshot.h" #include "main/Config.h" -#include "scp/QuorumSetUtils.h" #include "simulation/ApplyLoad.h" #include "simulation/LoadGenerator.h" #include "simulation/Topologies.h" @@ -954,16 +954,14 @@ TEST_CASE("apply load", "[loadgen][applyload][acceptance]") expectedArchivedEntries - 1}; std::set sampleKeys; - auto hotArchive = app->getBucketManager() - .getBucketSnapshotManager() - .copySearchableHotArchiveBucketListSnapshot(); + auto snap = app->getLedgerManager().copyLedgerStateSnapshot(); for (auto idx : sampleIndices) { sampleKeys.insert(ApplyLoad::getKeyForArchivedEntry(idx)); } - auto sampleEntries = hotArchive->loadKeys(sampleKeys); + auto sampleEntries = snap.loadArchiveKeys(sampleKeys); REQUIRE(sampleEntries.size() == sampleKeys.size()); al.execute(); diff --git a/src/transactions/InvokeHostFunctionOpFrame.cpp b/src/transactions/InvokeHostFunctionOpFrame.cpp index 62ed961c39..391fce2887 100644 --- a/src/transactions/InvokeHostFunctionOpFrame.cpp +++ b/src/transactions/InvokeHostFunctionOpFrame.cpp @@ -271,7 +271,8 @@ class InvokeHostFunctionApplyHelper : virtual LedgerAccessHelper rust::Vec mTtlEntryCxxBufs; rust::Vec mAutoRestoredRwEntryIndices; HostFunctionMetrics mMetrics; - SearchableHotArchiveSnapshotConstPtr mHotArchive; + // Used for hot archive access only + ApplyLedgerStateSnapshot mStateSnapshot; rust::Box const& mModuleCache; DiagnosticEventManager& mDiagnosticEvents; @@ -285,7 +286,7 @@ class InvokeHostFunctionApplyHelper : virtual LedgerAccessHelper std::optional& refundableFeeTracker, OperationMetaBuilder& opMeta, InvokeHostFunctionOpFrame const& opFrame, SorobanNetworkConfig const& sorobanConfig, - SearchableHotArchiveSnapshotConstPtr hotArchive, + ApplyLedgerStateSnapshot stateSnapshot, rust::Box const& moduleCache) : mApp(app) , mRes(res) @@ -298,7 +299,7 @@ class InvokeHostFunctionApplyHelper : virtual LedgerAccessHelper , mAppConfig(app.getConfig()) , mMetrics(app.getSorobanMetrics(), app.getConfig().DISABLE_SOROBAN_METRICS_FOR_TESTING) - , mHotArchive(hotArchive) + , mStateSnapshot(std::move(stateSnapshot)) , mModuleCache(moduleCache) , mDiagnosticEvents(mOpMeta.getDiagnosticEventManager()) { @@ -425,8 +426,7 @@ class InvokeHostFunctionApplyHelper : virtual LedgerAccessHelper continue; } - releaseAssertOrThrow(mHotArchive); - auto archiveEntry = mHotArchive->load(lk); + auto archiveEntry = mStateSnapshot.loadArchiveEntry(lk); if (archiveEntry) { releaseAssertOrThrow( @@ -981,11 +981,10 @@ class InvokeHostFunctionPreV23ApplyHelper OperationMetaBuilder& opMeta, InvokeHostFunctionOpFrame const& opFrame, SorobanNetworkConfig const& sorobanConfig, rust::Box const& moduleCache) - : InvokeHostFunctionApplyHelper(app, sorobanBasePrngSeed, res, - refundableFeeTracker, opMeta, opFrame, - sorobanConfig, - nullptr, // No hot archive before p23 - moduleCache) + : InvokeHostFunctionApplyHelper( + app, sorobanBasePrngSeed, res, refundableFeeTracker, opMeta, + opFrame, sorobanConfig, app.copyApplyLedgerStateSnapshot(), + moduleCache) , PreV23LedgerAccessHelper(ltx) { } @@ -1170,7 +1169,7 @@ class InvokeHostFunctionParallelApplyHelper : InvokeHostFunctionApplyHelper( app, sorobanBasePrngSeed, res, refundableFeeTracker, opMeta, opFrame, threadState.getSorobanConfig(), - threadState.getHotArchiveSnapshot(), threadState.getModuleCache()) + threadState.getSnapshot(), threadState.getModuleCache()) , ParallelLedgerAccessHelper(threadState, ledgerInfo) { ZoneScoped; diff --git a/src/transactions/ParallelApplyUtils.cpp b/src/transactions/ParallelApplyUtils.cpp index 9c26466bd5..0256fd7100 100644 --- a/src/transactions/ParallelApplyUtils.cpp +++ b/src/transactions/ParallelApplyUtils.cpp @@ -3,13 +3,11 @@ // of this distribution or at http://www.apache.org/licenses/LICENSE-2.0 #include "transactions/ParallelApplyUtils.h" -#include "bucket/BucketSnapshotManager.h" #include "bucket/BucketUtils.h" #include "ledger/LedgerEntryScope.h" #include "ledger/LedgerTxn.h" #include "ledger/NetworkConfig.h" #include "main/AppConnector.h" -#include "transactions/MutableTransactionResult.h" #include "transactions/ParallelApplyStage.h" #include "transactions/TransactionFrameBase.h" #include "util/GlobalChecks.h" @@ -297,18 +295,19 @@ ParallelLedgerAccessHelper::eraseLedgerEntryIfExists(LedgerKey const& key) // them are complete. class ThreadParalllelApplyLedgerState; GlobalParallelApplyLedgerState::GlobalParallelApplyLedgerState( - AppConnector& app, AbstractLedgerTxn& ltx, - std::vector const& stages, + AppConnector& app, ApplyLedgerStateSnapshot snapshot, + AbstractLedgerTxn& ltx, std::vector const& stages, InMemorySorobanState const& inMemoryState, SorobanNetworkConfig const& sorobanConfig) : LedgerEntryScope(ScopeIdT(0, ltx.getHeader().ledgerSeq)) - , mHotArchiveSnapshot(app.copySearchableHotArchiveBucketListSnapshot()) - , mLiveSnapshot(app.copySearchableLiveBucketListSnapshot()) + , mSnapshot(std::move(snapshot)) , mInMemorySorobanState(inMemoryState) , mSorobanConfig(sorobanConfig) { + releaseAssertOrThrow(mSnapshot.getLedgerSeq() == + mInMemorySorobanState.getLedgerSeq()); releaseAssertOrThrow(ltx.getHeader().ledgerSeq == - getSnapshotLedgerSeq() + 1); + mSnapshot.getLedgerSeq() + 1); // From now on, we will be using globalState, liveSnapshots, and the // hotArchive to collect all entries. Before we continue though, we need to @@ -445,11 +444,7 @@ GlobalParallelApplyLedgerState::commitChangesToLedgerTxn( uint32_t GlobalParallelApplyLedgerState::getSnapshotLedgerSeq() const { - releaseAssertOrThrow(mLiveSnapshot->getLedgerSeq() == - mHotArchiveSnapshot->getLedgerSeq()); - releaseAssertOrThrow(mLiveSnapshot->getLedgerSeq() == - mInMemorySorobanState.getLedgerSeq()); - return mLiveSnapshot->getLedgerSeq(); + return mInMemorySorobanState.getLedgerSeq(); } GlobalParallelApplyEntryMap const& @@ -599,11 +594,7 @@ ThreadParallelApplyLedgerState::ThreadParallelApplyLedgerState( AppConnector& app, GlobalParallelApplyLedgerState const& global, Cluster const& cluster, size_t clusterIdx) : LedgerEntryScope(ScopeIdT(clusterIdx, global.mScopeID.mLedger)) - // TODO: find a way to clone these from parent rather than asking the - // snapshot manager again. That might have changed! NB taking a shared - // pointer copy is not safe, the snapshot objects are not threadsafe. - , mHotArchiveSnapshot(app.copySearchableHotArchiveBucketListSnapshot()) - , mLiveSnapshot(app.copySearchableLiveBucketListSnapshot()) + , mSnapshot(global.mSnapshot) , mInMemorySorobanState(global.mInMemorySorobanState) , mSorobanConfig(global.mSorobanConfig) , mModuleCache(app.getModuleCache()) @@ -720,7 +711,7 @@ ThreadParallelApplyLedgerState::getLiveEntryOpt(LedgerKey const& key) const } else { - res = mLiveSnapshot->load(key); + res = mSnapshot.loadLiveEntry(key); } return scopeAdoptEntryOpt(res ? std::make_optional(*res) : std::nullopt); @@ -846,11 +837,7 @@ ThreadParallelApplyLedgerState::entryWasRestored(LedgerKey const& key) const uint32_t ThreadParallelApplyLedgerState::getSnapshotLedgerSeq() const { - releaseAssertOrThrow(mLiveSnapshot->getLedgerSeq() == - mHotArchiveSnapshot->getLedgerSeq()); - releaseAssertOrThrow(mLiveSnapshot->getLedgerSeq() == - mInMemorySorobanState.getLedgerSeq()); - return mLiveSnapshot->getLedgerSeq(); + return mInMemorySorobanState.getLedgerSeq(); } SorobanNetworkConfig const& @@ -859,10 +846,10 @@ ThreadParallelApplyLedgerState::getSorobanConfig() const return mSorobanConfig; } -SearchableHotArchiveSnapshotConstPtr const& -ThreadParallelApplyLedgerState::getHotArchiveSnapshot() const +ApplyLedgerStateSnapshot const& +ThreadParallelApplyLedgerState::getSnapshot() const { - return mHotArchiveSnapshot; + return mSnapshot; } rust::Box const& diff --git a/src/transactions/ParallelApplyUtils.h b/src/transactions/ParallelApplyUtils.h index 2f009dafd6..f687a8f466 100644 --- a/src/transactions/ParallelApplyUtils.h +++ b/src/transactions/ParallelApplyUtils.h @@ -6,6 +6,7 @@ #include "ledger/InMemorySorobanState.h" #include "ledger/LedgerEntryScope.h" +#include "ledger/LedgerStateSnapshot.h" #include "ledger/LedgerTxn.h" #include "ledger/LedgerTypeUtils.h" #include "transactions/ParallelApplyStage.h" @@ -70,9 +71,9 @@ class ParallelLedgerInfo class ThreadParallelApplyLedgerState : public LedgerEntryScope { - // Copies of snapshots from the global state. - SearchableHotArchiveSnapshotConstPtr mHotArchiveSnapshot; - SearchableSnapshotConstPtr mLiveSnapshot; + // Copy of the ledger state snapshot from the global state, with fresh + // file caches for thread safety. + ApplyLedgerStateSnapshot mSnapshot; // Reference to the live in-memory Soroban state. For Soroban entries // (CONTRACT_DATA, CONTRACT_CODE, TTL), query this in-memory state instead @@ -173,7 +174,7 @@ class ThreadParallelApplyLedgerState SorobanNetworkConfig const& getSorobanConfig() const; - SearchableHotArchiveSnapshotConstPtr const& getHotArchiveSnapshot() const; + ApplyLedgerStateSnapshot const& getSnapshot() const; rust::Box const& getModuleCache() const; }; @@ -181,20 +182,11 @@ class ThreadParallelApplyLedgerState class GlobalParallelApplyLedgerState : public LedgerEntryScope { - // Contains the hot archive state from the start of the ledger close. If a - // key is in here, it is "evicted". An invariant is that if a key is in here - // it is _not_ in the live snapshot. - SearchableHotArchiveSnapshotConstPtr mHotArchiveSnapshot; - - // Contains the live soroban state from the start of the ledger close. If a - // key is in here, it is either "archived" or "live", depending on its TTL. - // Classic entries are always live, soroban entries always have an - // associated TTL entry and if the TTL is in the past the entry is - // "archived", otherwise "live". An invariant is that if a key is in here it - // is _not_ in the hot archive snapshot. - // Note that only classic entries should be queried from mLiveSnapshot. For - // Soroban entries query mInMemorySorobanState instead. - SearchableSnapshotConstPtr mLiveSnapshot; + // Contains the full ledger state snapshot from the start of the ledger + // close, providing access to both the live bucket list and the hot archive + // bucket list. Note that this does not reflect changes from the classic + // apply phase, but is a snapshot of the start of the ledger. + ApplyLedgerStateSnapshot mSnapshot; // Contains an exact one-to-one in-memory mapping of the live snapshot for // CONTRACT_DATA, CONTRACT_CODE, and TTL entries. For these entry types, @@ -250,7 +242,9 @@ class GlobalParallelApplyLedgerState std::unordered_set const& readWriteSet); public: - GlobalParallelApplyLedgerState(AppConnector& app, AbstractLedgerTxn& ltx, + GlobalParallelApplyLedgerState(AppConnector& app, + ApplyLedgerStateSnapshot snapshot, + AbstractLedgerTxn& ltx, std::vector const& stages, InMemorySorobanState const& inMemoryState, SorobanNetworkConfig const& sorobanConfig); diff --git a/src/transactions/RestoreFootprintOpFrame.cpp b/src/transactions/RestoreFootprintOpFrame.cpp index 547d138268..6f8c39120a 100644 --- a/src/transactions/RestoreFootprintOpFrame.cpp +++ b/src/transactions/RestoreFootprintOpFrame.cpp @@ -288,7 +288,7 @@ class RestoreFootprintParallelApplyHelper : virtual public RestoreFootprintApplyHelper, virtual public ParallelLedgerAccessHelper { - SearchableHotArchiveSnapshotConstPtr mHotArchive; + ApplyLedgerStateSnapshot mSnapshot; public: RestoreFootprintParallelApplyHelper( @@ -299,14 +299,14 @@ class RestoreFootprintParallelApplyHelper : RestoreFootprintApplyHelper(app, res, refundableFeeTracker, opMeta, opFrame, threadState.getSorobanConfig()) , ParallelLedgerAccessHelper(threadState, ledgerInfo) - , mHotArchive(app.copySearchableHotArchiveBucketListSnapshot()) + , mSnapshot(threadState.getSnapshot()) { } std::optional getHotArchiveEntry(LedgerKey const& key) override { - auto ptr = mHotArchive->load(key); + auto ptr = mSnapshot.loadArchiveEntry(key); if (ptr) { return ptr->archivedEntry(); diff --git a/src/transactions/test/InvokeHostFunctionTests.cpp b/src/transactions/test/InvokeHostFunctionTests.cpp index 8dcb76abcf..dc6aa96e63 100644 --- a/src/transactions/test/InvokeHostFunctionTests.cpp +++ b/src/transactions/test/InvokeHostFunctionTests.cpp @@ -9,7 +9,6 @@ #include "util/ProtocolVersion.h" #include "util/UnorderedSet.h" #include "xdr/Stellar-transaction.h" -#include #include #include #include @@ -19,6 +18,7 @@ #include "crypto/SecretKey.h" #include "herder/Herder.h" #include "ledger/LedgerManager.h" +#include "ledger/LedgerStateSnapshot.h" #include "ledger/LedgerTxn.h" #include "ledger/LedgerTypeUtils.h" #include "ledger/test/LedgerTestUtils.h" @@ -44,8 +44,6 @@ #include #include #include -#include -#include #include "ledger/LedgerManagerImpl.h" @@ -4648,15 +4646,12 @@ TEST_CASE("persistent entry archival", "[tx][soroban][archival]") auto lk = client.getContract().getDataKey( makeSymbolSCVal("key"), ContractDataDurability::PERSISTENT); - auto hotArchive = test.getApp() - .getBucketManager() - .getBucketSnapshotManager() - .copySearchableHotArchiveBucketListSnapshot(); + auto snap = test.getApp().getLedgerManager().copyLedgerStateSnapshot(); if (evict) { - REQUIRE(hotArchive->load(lk)); - REQUIRE(!hotArchive->load(getTTLKey(lk))); + REQUIRE(snap.loadArchiveEntry(lk)); + REQUIRE(!snap.loadArchiveEntry(getTTLKey(lk))); { LedgerTxn ltx(test.getApp().getLedgerTxnRoot()); REQUIRE(!ltx.load(lk)); @@ -4665,8 +4660,8 @@ TEST_CASE("persistent entry archival", "[tx][soroban][archival]") } else { - REQUIRE(!hotArchive->load(lk)); - REQUIRE(!hotArchive->load(getTTLKey(lk))); + REQUIRE(!snap.loadArchiveEntry(lk)); + REQUIRE(!snap.loadArchiveEntry(getTTLKey(lk))); { LedgerTxn ltx(test.getApp().getLedgerTxnRoot()); REQUIRE(ltx.load(lk)); @@ -4729,14 +4724,11 @@ TEST_CASE("persistent entry archival", "[tx][soroban][archival]") client.get("key", ContractDataDurability::PERSISTENT, 123); - test.getApp() - .getBucketManager() - .getBucketSnapshotManager() - .maybeCopySearchableHotArchiveBucketListSnapshot( - hotArchive); + auto restoredSnap = + test.getApp().getLedgerManager().copyLedgerStateSnapshot(); // Restored entries are deleted from Hot Archive - REQUIRE(!hotArchive->load(lk)); + REQUIRE(!restoredSnap.loadArchiveEntry(lk)); }; SECTION("restore op") @@ -7385,11 +7377,9 @@ TEST_CASE("multiple version of same key in a single eviction scan", closeLedgerOn(test.getApp(), ledgerSeq, 2, 1, 2016); } - auto hotArchive = test.getApp() - .getBucketManager() - .getBucketSnapshotManager() - .copySearchableHotArchiveBucketListSnapshot(); - REQUIRE(hotArchive->load(lk)); + auto evictSnap = + test.getApp().getLedgerManager().copyLedgerStateSnapshot(); + REQUIRE(evictSnap.loadArchiveEntry(lk)); }; evictEntry(); @@ -7400,11 +7390,9 @@ TEST_CASE("multiple version of same key in a single eviction scan", // levels of the BucketList. test.invokeRestoreOp({lk}, 20166); - auto bl = test.getApp() - .getBucketManager() - .getBucketSnapshotManager() - .copySearchableLiveBucketListSnapshot(); - auto loadRes = bl->load(lk); + auto restoreSnap = + test.getApp().getLedgerManager().copyLedgerStateSnapshot(); + auto loadRes = restoreSnap.loadLiveEntry(lk); REQUIRE(loadRes); // Evict the entry again. If we "double evict" we'll throw during ledger @@ -7431,8 +7419,7 @@ TEST_CASE_VERSIONS("do not evict outdated keys", "[archival][soroban]") SorobanTest test(app, cfg, false); ContractStorageTestClient client(test); - auto& snapshotManager = - test.getApp().getBucketManager().getBucketSnapshotManager(); + auto& snapshotManager = test.getApp().getLedgerManager(); // WASM and instance should not expire test.invokeExtendOp(client.getContract().getKeys(), 10'000); @@ -7468,13 +7455,10 @@ TEST_CASE_VERSIONS("do not evict outdated keys", "[archival][soroban]") // Check the eviction results. // Entry should be archived and not in the live BucketList - auto liveBL = snapshotManager.copySearchableLiveBucketListSnapshot(); - REQUIRE(!liveBL->load(lk)); + auto evictionSnap = snapshotManager.copyLedgerStateSnapshot(); + REQUIRE(!evictionSnap.loadLiveEntry(lk)); - auto hotArchive = - snapshotManager.copySearchableHotArchiveBucketListSnapshot(); - - auto hotLoad = hotArchive->load(lk); + auto hotLoad = evictionSnap.loadArchiveEntry(lk); REQUIRE(hotLoad); REQUIRE(hotLoad->type() == HOT_ARCHIVE_ARCHIVED); @@ -7495,14 +7479,12 @@ TEST_CASE_VERSIONS("do not evict outdated keys", "[archival][soroban]") // Restore entry and make sure the correct value is restored test.invokeRestoreOp({lk}, 20166); - hotArchive = - snapshotManager.copySearchableHotArchiveBucketListSnapshot(); - auto hotLoadAfterRestore = hotArchive->load(lk); + auto restoreSnap = snapshotManager.copyLedgerStateSnapshot(); + auto hotLoadAfterRestore = restoreSnap.loadArchiveEntry(lk); REQUIRE(!hotLoadAfterRestore); // Check that restored value matches what was archived - liveBL = snapshotManager.copySearchableLiveBucketListSnapshot(); - auto liveLoadAfterRestore = liveBL->load(lk); + auto liveLoadAfterRestore = restoreSnap.loadLiveEntry(lk); REQUIRE(liveLoadAfterRestore); if (protocolVersionIsBefore(test.getLedgerVersion(), @@ -7532,8 +7514,7 @@ TEST_CASE("disable eviction scan", "[archival][soroban]") SorobanTest test(cfg, false); ContractStorageTestClient client(test); - auto& snapshotManager = - test.getApp().getBucketManager().getBucketSnapshotManager(); + auto& snapshotManager = test.getApp().getLedgerManager(); // WASM and instance should not expire test.invokeExtendOp(client.getContract().getKeys(), 10'000); @@ -7579,30 +7560,23 @@ TEST_CASE("disable eviction scan", "[archival][soroban]") REQUIRE(initialIterator == test.getNetworkCfg().evictionIterator()); } - auto liveBL = snapshotManager.copySearchableLiveBucketListSnapshot(); - auto hotArchive = - snapshotManager.copySearchableHotArchiveBucketListSnapshot(); - + auto snap = snapshotManager.copyLedgerStateSnapshot(); auto assertTemp = [&](bool isLive) { - liveBL = snapshotManager.copySearchableLiveBucketListSnapshot(); - hotArchive = - snapshotManager.copySearchableHotArchiveBucketListSnapshot(); - auto tempLiveLoad = liveBL->load(temporaryKey); + snap = snapshotManager.copyLedgerStateSnapshot(); + auto tempLiveLoad = snap.loadLiveEntry(temporaryKey); REQUIRE(static_cast(tempLiveLoad) == isLive); // Temp entries are never archived - REQUIRE(!hotArchive->load(temporaryKey)); + REQUIRE(!snap.loadArchiveEntry(temporaryKey)); }; auto assertPersistent = [&](bool isLive) { - liveBL = snapshotManager.copySearchableLiveBucketListSnapshot(); - hotArchive = - snapshotManager.copySearchableHotArchiveBucketListSnapshot(); + snap = snapshotManager.copyLedgerStateSnapshot(); - auto persistentLiveLoad = liveBL->load(persistentKey); + auto persistentLiveLoad = snap.loadLiveEntry(persistentKey); REQUIRE(static_cast(persistentLiveLoad) == isLive); - auto hotArchiveLoad = hotArchive->load(persistentKey); + auto hotArchiveLoad = snap.loadArchiveEntry(persistentKey); REQUIRE(static_cast(hotArchiveLoad) != isLive); }; @@ -7626,10 +7600,9 @@ TEST_CASE("disable eviction scan", "[archival][soroban]") initialIterator = iteratorAfterUpgrade; // Check that exactly one entry has been evicted - liveBL = snapshotManager.copySearchableLiveBucketListSnapshot(); - hotArchive = snapshotManager.copySearchableHotArchiveBucketListSnapshot(); + snap = snapshotManager.copyLedgerStateSnapshot(); - auto persistentLiveLoad = liveBL->load(persistentKey); + auto persistentLiveLoad = snap.loadLiveEntry(persistentKey); if (persistentLiveLoad) { // If perstent entry is live, assert that the temp entry is evicted. @@ -10023,17 +9996,11 @@ TEST_CASE("autorestore from another contract", "[tx][soroban][archival]") REQUIRE(client2.get("key2", ContractDataDurability::PERSISTENT, std::nullopt) == INVOKE_HOST_FUNCTION_ENTRY_ARCHIVED); - auto hotArchiveSnapshot = test.getApp() - .getBucketManager() - .getBucketSnapshotManager() - .copySearchableHotArchiveBucketListSnapshot(); - auto liveSnapshot = test.getApp() - .getBucketManager() - .getBucketSnapshotManager() - .copySearchableLiveBucketListSnapshot(); + auto archivedSnap = + test.getApp().getLedgerManager().copyLedgerStateSnapshot(); - REQUIRE(hotArchiveSnapshot->loadKeys({lk1, lk2}).size() == 2); - REQUIRE(liveSnapshot->loadKeys({lk1, lk2}, "load").size() == 0); + REQUIRE(archivedSnap.loadArchiveKeys({lk1, lk2}).size() == 2); + REQUIRE(archivedSnap.loadLiveKeys({lk1, lk2}, "load").size() == 0); // Now, invoke contract2, but also autorestore state from contract1. auto keysToRestore = client2.getContract().getKeys(); @@ -10058,17 +10025,11 @@ TEST_CASE("autorestore from another contract", "[tx][soroban][archival]") /*addContractKeys=*/false); REQUIRE(invocation.withExactNonRefundableResourceFee().invoke()); - liveSnapshot = test.getApp() - .getBucketManager() - .getBucketSnapshotManager() - .copySearchableLiveBucketListSnapshot(); - hotArchiveSnapshot = test.getApp() - .getBucketManager() - .getBucketSnapshotManager() - .copySearchableHotArchiveBucketListSnapshot(); - - REQUIRE(liveSnapshot->loadKeys({lk1, lk2}, "load").size() == 2); - REQUIRE(hotArchiveSnapshot->loadKeys({lk1, lk2}).size() == 0); + auto restoredSnap = + test.getApp().getLedgerManager().copyLedgerStateSnapshot(); + + REQUIRE(restoredSnap.loadLiveKeys({lk1, lk2}, "load").size() == 2); + REQUIRE(restoredSnap.loadArchiveKeys({lk1, lk2}).size() == 0); // Verify that the correct values were restored REQUIRE(client1.get("key1", ContractDataDurability::PERSISTENT, 111) == diff --git a/src/transactions/test/ParallelApplyTest.cpp b/src/transactions/test/ParallelApplyTest.cpp index d0614962b7..71201a15d2 100644 --- a/src/transactions/test/ParallelApplyTest.cpp +++ b/src/transactions/test/ParallelApplyTest.cpp @@ -10,7 +10,7 @@ #include -#include "bucket/BucketManager.h" +#include "ledger/LedgerStateSnapshot.h" #include "main/Application.h" #include "test/TestUtils.h" #include "test/TxTests.h" @@ -1121,11 +1121,8 @@ applyTestTransactions(TestConfig const& testConfig, uint32_t protocolVersion, std::optional>>> finalEntries; LedgerSnapshot ls(test.getApp()); - auto hotArchive = test.getApp() - .getBucketManager() - .getBucketSnapshotManager() - .copySearchableHotArchiveBucketListSnapshot(); - releaseAssert(hotArchive); + auto archiveSnap = + test.getApp().getLedgerManager().copyLedgerStateSnapshot(); for (auto const& k : allKeys) { std::optional liveEntry; @@ -1145,7 +1142,7 @@ applyTestTransactions(TestConfig const& testConfig, uint32_t protocolVersion, } else if (isSorobanEntry(k)) { - if (auto e = hotArchive->load(k)) + if (auto e = archiveSnap.loadArchiveEntry(k)) { archivedEntry = e->archivedEntry(); } diff --git a/src/transactions/test/SorobanTxTestUtils.cpp b/src/transactions/test/SorobanTxTestUtils.cpp index 885d3b0f0e..7e524add93 100644 --- a/src/transactions/test/SorobanTxTestUtils.cpp +++ b/src/transactions/test/SorobanTxTestUtils.cpp @@ -3,7 +3,7 @@ // of this distribution or at http://www.apache.org/licenses/LICENSE-2.0 #include "SorobanTxTestUtils.h" -#include "bucket/BucketManager.h" +#include "ledger/LedgerStateSnapshot.h" #include "ledger/LedgerTypeUtils.h" #include "rust/RustBridge.h" #include "test/Catch2.h" @@ -1443,12 +1443,8 @@ SorobanTest::getEntryExpirationStatus(LedgerKey const& key) } return ExpirationStatus::LIVE; } - auto hotArchive = getApp() - .getBucketManager() - .getBucketSnapshotManager() - .copySearchableHotArchiveBucketListSnapshot(); - releaseAssert(hotArchive); - if (hotArchive->load(key) != nullptr) + auto snap = getApp().getLedgerManager().copyLedgerStateSnapshot(); + if (snap.loadArchiveEntry(key) != nullptr) { return ExpirationStatus::HOT_ARCHIVE; }