typedef

Author: marta-lokhova

src/bucket/BucketSnapshotManager.cpp

@@ -52,7 +52,7 @@ BucketSnapshotManager::BucketSnapshotManager(
     }
 }
 
-std::shared_ptr<SearchableLiveBucketListSnapshot const>
+SearchableSnapshotConstPtr
 BucketSnapshotManager::copySearchableLiveBucketListSnapshot() const
 {
     std::map<uint32_t, SnapshotPtrT<LiveBucket>> historicalSnapshots;
@@ -118,7 +118,7 @@ BucketSnapshotManager::recordBulkLoadMetrics(std::string const& label,
 
 void
 BucketSnapshotManager::maybeCopySearchableBucketListSnapshot(
-    std::shared_ptr<SearchableLiveBucketListSnapshot const>& snapshot)
+    SearchableSnapshotConstPtr& snapshot)
 {
     // The canonical snapshot held by the BucketSnapshotManager is not being
     // modified. Rather, a thread is checking it's copy against the canonical

src/bucket/BucketSnapshotManager.h

@@ -32,6 +32,8 @@ class SearchableHotArchiveBucketListSnapshot;
 
 template <class BucketT>
 using SnapshotPtrT = std::unique_ptr<BucketListSnapshot<BucketT> const>;
+using SearchableSnapshotConstPtr =
+    std::shared_ptr<SearchableLiveBucketListSnapshot const>;
 
 // This class serves as the boundary between non-threadsafe singleton classes
 // (BucketManager, BucketList, Metrics, etc) and threadsafe, parallel BucketList
@@ -80,14 +82,13 @@ class BucketSnapshotManager : NonMovableOrCopyable
                           SnapshotPtrT<HotArchiveBucket>&& hotArchiveSnapshot,
                           uint32_t numHistoricalLedgers);
 
-    std::shared_ptr<SearchableLiveBucketListSnapshot const>
-    copySearchableLiveBucketListSnapshot() const;
+    SearchableSnapshotConstPtr copySearchableLiveBucketListSnapshot() const;
 
     std::shared_ptr<SearchableHotArchiveBucketListSnapshot const>
     copySearchableHotArchiveBucketListSnapshot() const;
 
-    void maybeCopySearchableBucketListSnapshot(
-        std::shared_ptr<SearchableLiveBucketListSnapshot const>& snapshot);
+    void
+    maybeCopySearchableBucketListSnapshot(SearchableSnapshotConstPtr& snapshot);
 
     // All metric recording functions must only be called by the main thread
     void startPointLoadTimer() const;

src/bucket/SearchableBucketList.h

@@ -36,7 +36,7 @@ class SearchableLiveBucketListSnapshot
                                    std::shared_ptr<EvictionStatistics> stats,
                                    StateArchivalSettings const& sas) const;
 
-    friend std::shared_ptr<SearchableLiveBucketListSnapshot const>
+    friend SearchableSnapshotConstPtr
     BucketSnapshotManager::copySearchableLiveBucketListSnapshot() const;
 };
 

src/ledger/LedgerManager.h

@@ -97,8 +97,7 @@ class LedgerManager
     getLastClosedLedgerHeader() const = 0;
 
     // Get bucketlist snapshot
-    virtual std::shared_ptr<SearchableLiveBucketListSnapshot const>
-    getCurrentLedgerStateSnaphot() = 0;
+    virtual SearchableSnapshotConstPtr getCurrentLedgerStateSnaphot() = 0;
 
     // return the HAS that corresponds to the last closed ledger as persisted in
     // the database

src/ledger/LedgerManagerImpl.cpp

@@ -1261,7 +1261,7 @@ LedgerManagerImpl::maybeResetLedgerCloseMetaDebugStream(uint32_t ledgerSeq)
     }
 }
 
-std::shared_ptr<SearchableLiveBucketListSnapshot const>
+SearchableSnapshotConstPtr
 LedgerManagerImpl::getCurrentLedgerStateSnaphot()
 {
     if (!mReadOnlyLedgerStateSnapshot)

src/ledger/LedgerManagerImpl.h

@@ -51,12 +51,18 @@ class LedgerManagerImpl : public LedgerManager
   private:
     LedgerHeaderHistoryEntry mLastClosedLedger;
 
-    // TODO: better comment
     // Read-only Soroban network configuration, accessible by main thread only.
+    // This config has to match the read-only ledger state snapshot managed by
+    // LedgerManager. Today this is only accessed by the main thread, but it can
+    // be used by multiple threads as long snapshot consistency
+    // requirement is preserved (though synchronization should be added in this
+    // case)
     std::shared_ptr<SorobanNetworkConfig const> mSorobanNetworkConfigReadOnly;
 
     // Latest Soroban config during apply (should not be used outside of
-    // application, as it may be in half-valid state).
+    // application, as it may be in half-valid state). Note that access to this
+    // variable is not synchronized, since it should only be used by one thread
+    // (main or ledger close).
     std::shared_ptr<SorobanNetworkConfig> mSorobanNetworkConfigForApply;
 
     SorobanMetrics mSorobanMetrics;
@@ -75,8 +81,7 @@ class LedgerManagerImpl : public LedgerManager
     medida::Timer& mMetaStreamWriteTime;
     VirtualClock::time_point mLastClose;
     bool mRebuildInMemoryState{false};
-    std::shared_ptr<SearchableLiveBucketListSnapshot const>
-        mReadOnlyLedgerStateSnapshot;
+    SearchableSnapshotConstPtr mReadOnlyLedgerStateSnapshot;
 
     std::unique_ptr<VirtualClock::time_point> mStartCatchup;
     medida::Timer& mCatchupDuration;
@@ -211,7 +216,6 @@ class LedgerManagerImpl : public LedgerManager
     void maybeResetLedgerCloseMetaDebugStream(uint32_t ledgerSeq);
 
     SorobanMetrics& getSorobanMetrics() override;
-    std::shared_ptr<SearchableLiveBucketListSnapshot const>
-    getCurrentLedgerStateSnaphot() override;
+    SearchableSnapshotConstPtr getCurrentLedgerStateSnaphot() override;
 };
 }

src/ledger/LedgerStateSnapshot.cpp

@@ -163,8 +163,7 @@ LedgerTxnReadOnly::executeWithMaybeInnerSnapshot(
     return f(lsg);
 }
 
-BucketSnapshotState::BucketSnapshotState(
-    std::shared_ptr<SearchableLiveBucketListSnapshot const> snapshot)
+BucketSnapshotState::BucketSnapshotState(SearchableSnapshotConstPtr snapshot)
     : mSnapshot(snapshot)
     , mLedgerHeader(LedgerHeaderWrapper(
           std::make_shared<LedgerHeader>(mSnapshot->getLedgerHeader())))

src/ledger/LedgerStateSnapshot.h

@@ -106,15 +106,14 @@ class LedgerTxnReadOnly : public AbstractLedgerStateSnapshot
 // A concrete implementation of read-only BucketList snapshot wrapper
 class BucketSnapshotState : public AbstractLedgerStateSnapshot
 {
-    std::shared_ptr<SearchableLiveBucketListSnapshot const> const mSnapshot;
+    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;
 
   public:
-    BucketSnapshotState(
-        std::shared_ptr<SearchableLiveBucketListSnapshot const> snapshot);
+    BucketSnapshotState(SearchableSnapshotConstPtr snapshot);
     ~BucketSnapshotState() override;
 
     LedgerHeaderWrapper getLedgerHeader() const override;

src/ledger/LedgerTxnImpl.h

@@ -4,6 +4,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 "bucket/BucketSnapshotManager.h"
 #include "database/Database.h"
 #include "ledger/LedgerTxn.h"
 #include "util/RandomEvictionCache.h"
@@ -616,8 +617,7 @@ class LedgerTxnRoot::Impl
     mutable BestOffers mBestOffers;
     mutable uint64_t mPrefetchHits{0};
     mutable uint64_t mPrefetchMisses{0};
-    mutable std::shared_ptr<SearchableLiveBucketListSnapshot const>
-        mSearchableBucketListSnapshot;
+    mutable SearchableSnapshotConstPtr mSearchableBucketListSnapshot;
 
     size_t mBulkLoadBatchSize;
     std::unique_ptr<soci::transaction> mTransaction;

src/main/QueryServer.h

@@ -6,6 +6,7 @@
 
 #include "lib/httpthreaded/server.hpp"
 
+#include "bucket/BucketSnapshotManager.h"
 #include <functional>
 #include <memory>
 #include <string>
@@ -25,8 +26,7 @@ class QueryServer
 
     httpThreaded::server::server mServer;
 
-    std::unordered_map<std::thread::id,
-                       std::shared_ptr<SearchableLiveBucketListSnapshot const>>
+    std::unordered_map<std::thread::id, SearchableSnapshotConstPtr>
         mBucketListSnapshots;
 
     BucketSnapshotManager& mBucketSnapshotManager;