Add non-soroban testonly ledgerstateconfig mode

Author: ThomasBrady

src/bucket/InMemoryIndex.cpp

@@ -162,6 +162,9 @@ InMemoryIndex::InMemoryIndex(BucketManager const& bm,
         mOfferRange = std::nullopt;
     }
 
+    // TODO These bounds include config setting entries,
+    // which are not contract entries.
+    // Possibly consider adding more granular ranges for each contract type.
     if (firstContractEntry)
     {
         if (lastContractEntry)

src/bucket/LiveBucketIndex.cpp

@@ -188,6 +188,11 @@ LiveBucketIndex::getContractEntryRange() const
 {
     if (mDiskIndex)
     {
+        // TODO These bounds include config setting entries,
+        // which are not contract entries.
+        // Possibly consider adding a function to get the range of 
+        // each contract type individually, or one for CONTRACT_DATA and CONTRACT_CODE.
+        // and one for TTL.
         // Get the smallest and largest possible contract entry keys
         LedgerKey upperBound(TTL /*9*/);
         upperBound.ttl().keyHash.fill(std::numeric_limits<uint8_t>::max());

src/catchup/PopulateLedgerCacheWork.cpp

@@ -69,45 +69,61 @@ PopulateLedgerCacheWork::doWork()
                    mBucketToProcessIndex);
         return advance();
     }
-
-    auto contractEntryRange = bucket->getContractEntryRange();
     auto ledgerStateCache = mApp.getLedgerManager().getLedgerStateCache();
-    if (ledgerStateCache && contractEntryRange)
+    if (!ledgerStateCache)
     {
-        auto cache = ledgerStateCache.value();
-        auto [lowerBound, upperBound] = *contractEntryRange;
-        for (LiveBucketInputIterator iter(bucket);
-             iter && iter.pos() < upperBound; ++iter)
+        CLOG_DEBUG(Ledger, "LedgerStateCache is not enabled");
+        return State::WORK_FAILURE;
+    }
+
+    auto cache = ledgerStateCache.value();
+    std::streamoff upperBound = 0;
+    std::streamoff lowerBound = std::numeric_limits<std::streamoff>::max();
+    if (cache->getMode() == LedgerStateCache::Mode::SOROBAN_ONLY)
+    {
+        // Update the bounds to only iterate over soroban state.
+        auto contractEntryRange = bucket->getContractEntryRange();
+        if (contractEntryRange)
         {
-            if (iter.pos() < lowerBound)
-            {
-                iter.seek(lowerBound);
-            }
-            BucketEntry const& entry = *iter;
-            if (entry.type() == LIVEENTRY || entry.type() == INITENTRY)
+            lowerBound = std::get<0>(*contractEntryRange);
+            upperBound = std::get<1>(*contractEntryRange);
+        }
+    }
+    
+    for (LiveBucketInputIterator iter(bucket); iter && iter.pos() < upperBound; ++iter)
+    {
+        if (iter.pos() < lowerBound)
+        {
+            iter.seek(lowerBound);
+        }
+        BucketEntry const& entry = *iter;
+        if (entry.type() == LIVEENTRY || entry.type() == INITENTRY)
+        {
+            auto const& e = entry.liveEntry();
+            auto const& k = LedgerEntryKey(e);
+            if (!cache->supportedKeyType(k.type()))
             {
-                auto const& e = entry.liveEntry();
-                auto const& k = LedgerEntryKey(e);
-                // If the key is not in the dead keys set and not already in the
-                // cache, add it.
-                if (mDeadKeys.find(k) == mDeadKeys.end() && !cache->getEntry(k))
-                {
-                    cache->addEntry(e);
-                }
+                continue;
             }
-            else if (entry.type() == DEADENTRY)
+            // If the key is not in the dead keys set and not already in the
+            // cache, add it.
+            if (mDeadKeys.find(k) == mDeadKeys.end() && !cache->getEntry(k))
             {
-                if (!cache->getEntry(entry.deadEntry()))
-                {
-                    mDeadKeys.insert(entry.deadEntry());
-                }
+                cache->addEntry(e);
             }
-            else
+        }
+        else if (entry.type() == DEADENTRY)
+        {
+            if (!cache->getEntry(entry.deadEntry()))
             {
-                releaseAssert(false);
-                continue;
+                mDeadKeys.insert(entry.deadEntry());
             }
         }
+        else
+        {
+            releaseAssert(false);
+            continue;
+        }
     }
     return advance();
 }

src/ledger/LedgerManagerImpl.cpp

@@ -158,14 +158,20 @@ LedgerManagerImpl::LedgerManagerImpl(Application& app)
     , mLastClose(mApp.getClock().now())
     , mCatchupDuration(
           app.getMetrics().NewTimer({"ledger", "catchup", "duration"}))
+    , mLedgerStateCache{
 #ifdef BUILD_TESTS
-    , mLedgerStateCache
-{
-    app.getConfig().IN_MEMORY_SOROBAN_STATE_FOR_TESTING
-        ? std::make_shared<LedgerStateCache>()
+    app.getConfig().USE_LEDGER_STATE_CACHE_FOR_TESTING
+        ? std::make_shared<LedgerStateCache>(LedgerStateCache::Mode::ALL_ENTRIES)
+        : (app.getConfig().USE_SOROBAN_LEDGER_STATE_CACHE
+               ? std::make_shared<LedgerStateCache>(
+                     LedgerStateCache::Mode::SOROBAN_ONLY)
+               : std::optional<std::shared_ptr<LedgerStateCache>>(std::nullopt))
+#else
+    app.getConfig().USE_SOROBAN_LEDGER_STATE_CACHE 
+        ? std::make_shared<LedgerStateCache>(LedgerStateCache::Mode::SOROBAN_ONLY)
         : std::optional<std::shared_ptr<LedgerStateCache>>(std::nullopt)
-}
 #endif
+}
 , mState(LM_BOOTING_STATE)
 {
     setupLedgerCloseMetaStream();

src/ledger/LedgerStateCache.cpp

@@ -22,7 +22,6 @@ LedgerEntryHash::operator()(LedgerEntry const& entry) const
 std::optional<LedgerEntry>
 LedgerStateCache::getEntry(LedgerKey const& key) const
 {
-    // TODO support other types, for test mode.
     if (!supportedKeyType(key.type()))
     {
         return std::nullopt;
@@ -104,12 +103,20 @@ LedgerStateCache::size() const
     return mState.size();
 }
 
+LedgerStateCache::Mode
+LedgerStateCache::getMode() const
+{
+    return mMode;
+}
+
 bool
-LedgerStateCache::supportedKeyType(LedgerEntryType type)
+LedgerStateCache::supportedKeyType(LedgerEntryType type) const
 {
-    // TODO support other types
-    // possibly do something more sophisticated here
-    return type == CONTRACT_DATA || type == CONTRACT_CODE || type == TTL;
+    if (mMode == Mode::SOROBAN_ONLY)
+    {
+        return type == CONTRACT_DATA || type == CONTRACT_CODE || type == TTL;
+    }
+    return true;
 }
 
 }

src/ledger/LedgerStateCache.h

@@ -32,7 +32,12 @@ class PopulateLedgerCacheWork;
 
 class LedgerStateCache
 {
+  enum class Mode {
+    ALL_ENTRIES,
+    SOROBAN_ONLY
+  };
   private:
+    Mode mMode;
     std::unordered_set<LedgerEntry, LedgerEntryHash, LedgerEntryEqual> mState;
     mutable std::shared_mutex mMutex;
 
@@ -51,15 +56,15 @@ class LedgerStateCache
     void addEntry(LedgerEntry const& entry);
 
   public:
-    LedgerStateCache() = default;
+    LedgerStateCache(Mode mode) : mMode(mode) {}
 
     // Read an entry from the cache
     // Acquires a shared lock on the cache.
     std::optional<LedgerEntry> getEntry(LedgerKey const& key) const;
 
     size_t size() const;
-    // TODO support other types
-    static bool supportedKeyType(LedgerEntryType type);
+    Mode getMode() const;
+    bool supportedKeyType(LedgerEntryType type) const;
 
     // TODO Find a way to limit access to just the methods we need
     // PopulateLedgerCacheWork::doWork() / addEntry() and

src/main/Config.cpp

@@ -66,7 +66,7 @@ static const std::unordered_set<std::string> TESTING_ONLY_OPTIONS = {
     "ARTIFICIALLY_SLEEP_MAIN_THREAD_FOR_TESTING",
     "ARTIFICIALLY_SKIP_CONNECTION_ADJUSTMENT_FOR_TESTING",
     "ARTIFICIALLY_DELAY_LEDGER_CLOSE_FOR_TESTING",
-    "IN_MEMORY_SOROBAN_STATE_FOR_TESTING"};
+    "USE_LEDGER_STATE_CACHE_FOR_TESTING"};
 
 // Options that should only be used for testing
 static const std::unordered_set<std::string> TESTING_SUGGESTED_OPTIONS = {
@@ -283,8 +283,9 @@ Config::Config() : NODE_SEED(SecretKey::random())
     ENTRY_CACHE_SIZE = 100000;
     PREFETCH_BATCH_SIZE = 1000;
 #ifdef BUILD_TESTS
-    IN_MEMORY_SOROBAN_STATE_FOR_TESTING = true;
+    USE_LEDGER_STATE_CACHE_FOR_TESTING = true;
 #endif
+    USE_SOROBAN_LEDGER_STATE_CACHE = true;
 
     HISTOGRAM_WINDOW_SIZE = std::chrono::seconds(30);
 

src/main/Config.h

@@ -202,10 +202,12 @@ class Config : public std::enable_shared_from_this<Config>
     // successful transactions.
     bool CATCHUP_SKIP_KNOWN_RESULTS_FOR_TESTING;
 
-    // Whether to use an in-memory ledger state cache for Soroban state.
-    bool IN_MEMORY_SOROBAN_STATE_FOR_TESTING;
+    // Whether to use an in-memory ledger state cache for testing.
+    bool USE_LEDGER_STATE_CACHE_FOR_TESTING;
 #endif // BUILD_TESTS
-
+    // Whether to use an in-memory ledger state cache for Soroban state.
+    bool USE_SOROBAN_LEDGER_STATE_CACHE;
+    
     // Interval between automatic maintenance executions
     std::chrono::seconds AUTOMATIC_MAINTENANCE_PERIOD;
 

src/util/types.cpp

@@ -76,9 +76,29 @@ KeyToDummyLedgerEntry(LedgerKey const& k)
 {
     LedgerEntry e;
     e.data.type(k.type());
-    // TODO support other types
     switch (k.type())
     {
+    case ACCOUNT:
+        e.data.account().accountID = k.account().accountID;
+        break;
+    case TRUSTLINE:
+        e.data.trustLine().accountID = k.trustLine().accountID;
+        e.data.trustLine().asset = k.trustLine().asset;
+        break;
+    case OFFER:
+        e.data.offer().sellerID = k.offer().sellerID;
+        e.data.offer().offerID = k.offer().offerID;
+        break;
+    case DATA:
+        e.data.data().accountID = k.data().accountID;
+        e.data.data().dataName = k.data().dataName;
+        break;
+    case CLAIMABLE_BALANCE:
+        e.data.claimableBalance().balanceID = k.claimableBalance().balanceID;
+        break;
+    case LIQUIDITY_POOL:
+        e.data.liquidityPool().liquidityPoolID = k.liquidityPool().liquidityPoolID;
+        break;
     case CONTRACT_DATA:
         e.data.contractData().contract = k.contractData().contract;
         e.data.contractData().key = k.contractData().key;
@@ -87,6 +107,9 @@ KeyToDummyLedgerEntry(LedgerKey const& k)
     case CONTRACT_CODE:
         e.data.contractCode().hash = k.contractCode().hash;
         break;
+    case CONFIG_SETTING:
+        e.data.configSetting().configSettingID(k.configSetting().configSettingID);
+        break;
     case TTL:
         e.data.ttl().keyHash = k.ttl().keyHash;
         break;