Support reusable module cache with multithreaded pre-compilation

Author: graydon

src/catchup/AssumeStateWork.cpp

@@ -9,6 +9,7 @@
 #include "crypto/Hex.h"
 #include "history/HistoryArchive.h"
 #include "invariant/InvariantManager.h"
+#include "ledger/LedgerManager.h"
 #include "work/WorkSequence.h"
 #include "work/WorkWithCallback.h"
 
@@ -78,6 +79,10 @@ AssumeStateWork::doWork()
             // now referenced by BucketList
             buckets.clear();
 
+            // Compile all live BL entries once we assume a new state.
+            app.getLedgerManager().compileAllContractsInLedger(
+                maxProtocolVersion);
+
             // Check invariants after state has been assumed
             app.getInvariantManager().checkAfterAssumeState(has.currentLedger);
 

src/ledger/LedgerManager.h

@@ -7,6 +7,7 @@
 #include "catchup/LedgerApplyManager.h"
 #include "history/HistoryManager.h"
 #include "ledger/NetworkConfig.h"
+#include "rust/RustBridge.h"
 #include <memory>
 
 namespace stellar
@@ -200,6 +201,12 @@ class LedgerManager
     virtual void manuallyAdvanceLedgerHeader(LedgerHeader const& header) = 0;
 
     virtual SorobanMetrics& getSorobanMetrics() = 0;
+    virtual rust_bridge::SorobanModuleCache& getModuleCache() = 0;
+
+    // Compiles all contracts in the current ledger, for ledger protocols
+    // starting at minLedgerVersion and running through to
+    // Config::CURRENT_LEDGER_PROTOCOL_VERSION (to enable upgrades).
+    virtual void compileAllContractsInLedger(uint32_t minLedgerVersion) = 0;
 
     virtual ~LedgerManager()
     {

src/ledger/LedgerManagerImpl.cpp

@@ -20,12 +20,15 @@
 #include "history/HistoryManager.h"
 #include "ledger/FlushAndRotateMetaDebugWork.h"
 #include "ledger/LedgerHeaderUtils.h"
+#include "ledger/LedgerManager.h"
 #include "ledger/LedgerTxn.h"
 #include "ledger/LedgerTxnEntry.h"
 #include "ledger/LedgerTxnHeader.h"
+#include "ledger/SharedModuleCacheCompiler.h"
 #include "main/Application.h"
 #include "main/Config.h"
 #include "main/ErrorMessages.h"
+#include "rust/RustBridge.h"
 #include "transactions/MutableTransactionResult.h"
 #include "transactions/OperationFrame.h"
 #include "transactions/TransactionFrameBase.h"
@@ -41,8 +44,10 @@
 #include "util/XDRCereal.h"
 #include "util/XDRStream.h"
 #include "work/WorkScheduler.h"
+#include "xdr/Stellar-ledger-entries.h"
 #include "xdrpp/printer.h"
 
+#include <cstdint>
 #include <fmt/format.h>
 
 #include "xdr/Stellar-ledger-entries.h"
@@ -125,6 +130,27 @@ LedgerManager::ledgerAbbrev(LedgerHeaderHistoryEntry const& he)
     return ledgerAbbrev(he.header, he.hash);
 }
 
+static std::vector<uint32_t>
+getModuleCacheProtocols()
+{
+    std::vector<uint32_t> ledgerVersions;
+    for (uint32_t i = (uint32_t)REUSABLE_SOROBAN_MODULE_CACHE_PROTOCOL_VERSION;
+         i <= Config::CURRENT_LEDGER_PROTOCOL_VERSION; i++)
+    {
+        ledgerVersions.push_back(i);
+    }
+    auto extra = getenv("SOROBAN_TEST_EXTRA_PROTOCOL");
+    if (extra)
+    {
+        uint32_t proto = static_cast<uint32_t>(atoi(extra));
+        if (proto > 0)
+        {
+            ledgerVersions.push_back(proto);
+        }
+    }
+    return ledgerVersions;
+}
+
 LedgerManagerImpl::LedgerManagerImpl(Application& app)
     : mApp(app)
     , mSorobanMetrics(app.getMetrics())
@@ -157,6 +183,8 @@ LedgerManagerImpl::LedgerManagerImpl(Application& app)
     , mCatchupDuration(
           app.getMetrics().NewTimer({"ledger", "catchup", "duration"}))
     , mState(LM_BOOTING_STATE)
+    , mModuleCache(::rust_bridge::new_module_cache())
+    , mModuleCacheProtocols(getModuleCacheProtocols())
 
 {
     setupLedgerCloseMetaStream();
@@ -405,6 +433,9 @@ LedgerManagerImpl::loadLastKnownLedger(bool restoreBucketlist)
         updateNetworkConfig(ltx);
         mSorobanNetworkConfigReadOnly = mSorobanNetworkConfigForApply;
     }
+
+    // Prime module cache with ledger content.
+    compileAllContractsInLedger(latestLedgerHeader->ledgerVersion);
 }
 
 Database&
@@ -568,6 +599,30 @@ LedgerManagerImpl::getSorobanMetrics()
     return mSorobanMetrics;
 }
 
+rust_bridge::SorobanModuleCache&
+LedgerManagerImpl::getModuleCache()
+{
+    return *mModuleCache;
+}
+
+void
+LedgerManagerImpl::compileAllContractsInLedger(uint32_t minLedgerVersion)
+{
+    auto& moduleCache = getModuleCache();
+    moduleCache.clear();
+    std::vector<uint32_t> versions;
+    for (auto const& v : mModuleCacheProtocols)
+    {
+        if (v >= minLedgerVersion)
+        {
+            versions.push_back(v);
+        }
+    }
+    auto compiler = std::make_shared<SharedModuleCacheCompiler>(
+        mApp, moduleCache, versions);
+    compiler->run();
+}
+
 void
 LedgerManagerImpl::publishSorobanMetrics()
 {
@@ -1812,6 +1867,8 @@ LedgerManagerImpl::transferLedgerEntriesToBucketList(
                 ledgerCloseMeta->populateEvictedEntries(evictedState);
             }
 
+            evictFromModuleCache(lh.ledgerVersion, evictedState);
+
             ltxEvictions.commit();
         }
 
@@ -1822,6 +1879,8 @@ LedgerManagerImpl::transferLedgerEntriesToBucketList(
     ltx.getAllEntries(initEntries, liveEntries, deadEntries);
     if (blEnabled)
     {
+        addAnyContractsToModuleCache(lh.ledgerVersion, initEntries);
+        addAnyContractsToModuleCache(lh.ledgerVersion, liveEntries);
         mApp.getBucketManager().addLiveBatch(mApp, lh, initEntries, liveEntries,
                                              deadEntries);
     }
@@ -1882,4 +1941,43 @@ LedgerManagerImpl::ledgerClosed(
 
     return res;
 }
+
+void
+LedgerManagerImpl::evictFromModuleCache(uint32_t ledgerVersion,
+                                        EvictedStateVectors const& evictedState)
+{
+    ::rust::Vec<CxxBuf> contractCodeKeys;
+    for (auto const& entry : evictedState.archivedEntries)
+    {
+        if (entry.data.type() == CONTRACT_CODE)
+        {
+            Hash const& hash = entry.data.contractCode().hash;
+            ::rust::Slice<uint8_t const> slice{hash.data(), hash.size()};
+            mModuleCache->evict_contract_code(slice);
+        }
+    }
+}
+
+void
+LedgerManagerImpl::addAnyContractsToModuleCache(
+    uint32_t ledgerVersion, std::vector<LedgerEntry> const& le)
+{
+    for (auto const& e : le)
+    {
+        if (e.data.type() == CONTRACT_CODE)
+        {
+            for (auto const& v : mModuleCacheProtocols)
+            {
+                if (v >= ledgerVersion)
+                {
+                    auto const& wasm = e.data.contractCode().code;
+                    auto slice =
+                        rust::Slice<const uint8_t>(wasm.data(), wasm.size());
+                    mModuleCache->compile(ledgerVersion, slice);
+                }
+            }
+        }
+    }
+}
+
 }

src/ledger/LedgerManagerImpl.h

@@ -11,6 +11,7 @@
 #include "ledger/NetworkConfig.h"
 #include "ledger/SorobanMetrics.h"
 #include "main/PersistentState.h"
+#include "rust/RustBridge.h"
 #include "transactions/TransactionFrame.h"
 #include "util/XDRStream.h"
 #include "xdr/Stellar-ledger.h"
@@ -152,6 +153,12 @@ class LedgerManagerImpl : public LedgerManager
     // Update cached ledger state values managed by this class.
     void advanceLedgerPointers(CloseLedgerOutput const& output);
 
+    // The reusable / inter-ledger soroban module cache.
+    ::rust::Box<rust_bridge::SorobanModuleCache> mModuleCache;
+
+    // Protocol versions to compile each contract for in the module cache.
+    std::vector<uint32_t> mModuleCacheProtocols;
+
   protected:
     // initialLedgerVers must be the ledger version at the start of the ledger
     // and currLedgerVers is the ledger version in the current ltx header. These
@@ -175,6 +182,11 @@ class LedgerManagerImpl : public LedgerManager
     void logTxApplyMetrics(AbstractLedgerTxn& ltx, size_t numTxs,
                            size_t numOps);
 
+    void evictFromModuleCache(uint32_t ledgerVersion,
+                              EvictedStateVectors const& evictedState);
+    void addAnyContractsToModuleCache(uint32_t ledgerVersion,
+                                      std::vector<LedgerEntry> const& le);
+
   public:
     LedgerManagerImpl(Application& app);
 
@@ -251,5 +263,7 @@ class LedgerManagerImpl : public LedgerManager
     {
         return mCurrentlyApplyingLedger;
     }
+    rust_bridge::SorobanModuleCache& getModuleCache() override;
+    void compileAllContractsInLedger(uint32_t minLedgerVersion) override;
 };
 }