Add non-soroban testonly ledgerstateconfig mode

ThomasBrady · ThomasBrady · commit 8df021920a5c · 2025-02-06T14:29:36.000-08:00
diff --git a/src/bucket/InMemoryIndex.cpp b/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)
diff --git a/src/bucket/LiveBucketIndex.cpp b/src/bucket/LiveBucketIndex.cpp
@@ -188,7 +188,12 @@ LiveBucketIndex::getContractEntryRange() const
 {
     if (mDiskIndex)
     {
-        // Get the smallest and largest possible contract entry keys
+        // 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());
 
diff --git a/src/catchup/PopulateLedgerCacheWork.cpp b/src/catchup/PopulateLedgerCacheWork.cpp
@@ -69,45 +69,62 @@ 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();
 }
diff --git a/src/ledger/LedgerManagerImpl.cpp b/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();
diff --git a/src/ledger/LedgerStateCache.cpp b/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;
 }
 
 }
diff --git a/src/ledger/LedgerStateCache.h b/src/ledger/LedgerStateCache.h
@@ -32,7 +32,14 @@ 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 +58,17 @@ 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
diff --git a/src/main/Config.cpp b/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);
 
diff --git a/src/main/Config.h b/src/main/Config.h
@@ -202,9 +202,11 @@ 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;
diff --git a/src/util/types.cpp b/src/util/types.cpp
@@ -76,9 +76,30 @@ 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 +108,10 @@ 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;

Original file line number	Diff line number	Diff line change
`@@ -162,6 +162,9 @@ InMemoryIndex::InMemoryIndex(BucketManager const& bm,`
`162`	`162`	`mOfferRange = std::nullopt;`
`163`	`163`	`}`
`164`	`164`
	`165`	`+ // TODO These bounds include config setting entries,`
	`166`	`+ // which are not contract entries.`
	`167`	`+ // Possibly consider adding more granular ranges for each contract type.`
`165`	`168`	`if (firstContractEntry)`
`166`	`169`	`{`
`167`	`170`	`if (lastContractEntry)`
Original file line number	Diff line number	Diff line change
`@@ -188,7 +188,12 @@ LiveBucketIndex::getContractEntryRange() const`
`188`	`188`	`{`
`189`	`189`	`if (mDiskIndex)`
`190`	`190`	`{`
`191`		`- // Get the smallest and largest possible contract entry keys`
	`191`	`+ // TODO These bounds include config setting entries,`
	`192`	`+ // which are not contract entries.`
	`193`	`+ // Possibly consider adding a function to get the range of`
	`194`	`+ // each contract type individually, or one for CONTRACT_DATA and`
	`195`	`+ // CONTRACT_CODE. and one for TTL. Get the smallest and largest possible`
	`196`	`+ // contract entry keys`
`192`	`197`	`LedgerKey upperBound(TTL /9/);`
`193`	`198`	`upperBound.ttl().keyHash.fill(std::numeric_limits<uint8_t>::max());`
`194`	`199`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,6 @@ LedgerEntryHash::operator()(LedgerEntry const& entry) const`
`22`	`22`	`std::optional<LedgerEntry>`
`23`	`23`	`LedgerStateCache::getEntry(LedgerKey const& key) const`
`24`	`24`	`{`
`25`		`- // TODO support other types, for test mode.`
`26`	`25`	`if (!supportedKeyType(key.type()))`
`27`	`26`	`{`
`28`	`27`	`return std::nullopt;`
`@@ -104,12 +103,20 @@ LedgerStateCache::size() const`
`104`	`103`	`return mState.size();`
`105`	`104`	`}`
`106`	`105`
	`106`	`+LedgerStateCache::Mode`
	`107`	`+LedgerStateCache::getMode() const`
	`108`	`+{`
	`109`	`+ return mMode;`
	`110`	`+}`
	`111`	`+`
`107`	`112`	`bool`
`108`		`-LedgerStateCache::supportedKeyType(LedgerEntryType type)`
	`113`	`+LedgerStateCache::supportedKeyType(LedgerEntryType type) const`
`109`	`114`	`{`
`110`		`- // TODO support other types`
`111`		`- // possibly do something more sophisticated here`
`112`		`- return type == CONTRACT_DATA \|\| type == CONTRACT_CODE \|\| type == TTL;`
	`115`	`+ if (mMode == Mode::SOROBAN_ONLY)`
	`116`	`+ {`
	`117`	`+ return type == CONTRACT_DATA \|\| type == CONTRACT_CODE \|\| type == TTL;`
	`118`	`+ }`
	`119`	`+ return true;`
`113`	`120`	`}`
`114`	`121`
`115`	`122`	`}`