Disk read resource (#4733)

# Description

Adds support for p23 disk read resource in `checkValid`. Also changes
`Resource` to use disk read entries in p23.

# Checklist
- [x] Reviewed the
[contributing](https://github.com/stellar/stellar-core/blob/master/CONTRIBUTING.md#submitting-changes)
document
- [x] Rebased on top of master (no merge commits)
- [x] Ran `clang-format` v8.0.0 (via `make format` or the Visual Studio
extension)
- [x] Compiles
- [ ] Ran all tests
- [ ] If change impacts performance, include supporting evidence per the
[performance
document](https://github.com/stellar/stellar-core/blob/master/performance-eval/performance-eval.md)

Author: dmkozh

src/herder/ParallelTxSetBuilder.cpp

@@ -348,7 +348,7 @@ buildSurgePricedParallelSorobanPhase(
     TxFrameList const& txFrames, Config const& cfg,
     SorobanNetworkConfig const& sorobanCfg,
     std::shared_ptr<SurgePricingLaneConfig> laneConfig,
-    std::vector<bool>& hadTxNotFittingLane)
+    std::vector<bool>& hadTxNotFittingLane, uint32_t ledgerVersion)
 {
     ZoneScoped;
     // Simplify the transactions to the minimum necessary amount of data.
@@ -431,7 +431,7 @@ buildSurgePricedParallelSorobanPhase(
         stellar::rand_uniform<size_t>(0, std::numeric_limits<size_t>::max()));
     for (auto const& tx : txFrames)
     {
-        queue.add(tx);
+        queue.add(tx, ledgerVersion);
     }
 
     ParallelPartitionConfig partitionCfg(cfg, sorobanCfg);
@@ -466,7 +466,7 @@ buildSurgePricedParallelSorobanPhase(
 
     std::vector<Resource> laneLeftUntilLimitUnused;
     queue.popTopTxs(/* allowGaps */ true, visitor, laneLeftUntilLimitUnused,
-                    hadTxNotFittingLane);
+                    hadTxNotFittingLane, ledgerVersion);
     // There is only a single fee lane for Soroban, so there is only a single
     // flag that indicates whether there was a transaction that didn't fit into
     // lane (and thus all transactions are surge priced at once).

src/herder/ParallelTxSetBuilder.h

@@ -24,6 +24,6 @@ TxStageFrameList buildSurgePricedParallelSorobanPhase(
     TxFrameList const& txFrames, Config const& cfg,
     SorobanNetworkConfig const& sorobanCfg,
     std::shared_ptr<SurgePricingLaneConfig> laneConfig,
-    std::vector<bool>& hadTxNotFittingLane);
+    std::vector<bool>& hadTxNotFittingLane, uint32_t ledgerVersion);
 
 } // namespace stellar

src/herder/SurgePricingUtils.cpp

@@ -150,7 +150,7 @@ std::vector<TransactionFrameBasePtr>
 SurgePricingPriorityQueue::getMostTopTxsWithinLimits(
     std::vector<TransactionFrameBasePtr> const& txs,
     std::shared_ptr<SurgePricingLaneConfig> laneConfig,
-    std::vector<bool>& hadTxNotFittingLane)
+    std::vector<bool>& hadTxNotFittingLane, uint32_t ledgerVersion)
 {
     ZoneScoped;
 
@@ -159,7 +159,7 @@ SurgePricingPriorityQueue::getMostTopTxsWithinLimits(
         stellar::rand_uniform<size_t>(0, std::numeric_limits<size_t>::max()));
     for (auto const& tx : txs)
     {
-        queue.add(tx);
+        queue.add(tx, ledgerVersion);
     }
     std::vector<TransactionFrameBasePtr> outTxs;
     auto visitor = [&outTxs](TransactionFrameBasePtr const& tx) {
@@ -168,63 +168,67 @@ SurgePricingPriorityQueue::getMostTopTxsWithinLimits(
     };
     std::vector<Resource> laneLeftUntilLimit;
     queue.popTopTxs(/* allowGaps */ true, visitor, laneLeftUntilLimit,
-                    hadTxNotFittingLane);
+                    hadTxNotFittingLane, ledgerVersion);
     return outTxs;
 }
 
 void
 SurgePricingPriorityQueue::visitTopTxs(
     std::vector<TransactionFrameBasePtr> const& txs,
     std::function<VisitTxResult(TransactionFrameBasePtr const&)> const& visitor,
-    std::vector<Resource>& laneLeftUntilLimit)
+    std::vector<Resource>& laneLeftUntilLimit, uint32_t ledgerVersion)
 {
     ZoneScoped;
 
     for (auto const& tx : txs)
     {
-        add(tx);
+        add(tx, ledgerVersion);
     }
     std::vector<bool> hadTxNotFittingLane;
     popTopTxs(/* allowGaps */ false, visitor, laneLeftUntilLimit,
-              hadTxNotFittingLane);
+              hadTxNotFittingLane, ledgerVersion);
 }
 
 void
-SurgePricingPriorityQueue::add(TransactionFrameBasePtr tx)
+SurgePricingPriorityQueue::add(TransactionFrameBasePtr tx,
+                               uint32_t ledgerVersion)
 {
     releaseAssert(tx != nullptr);
     auto lane = mLaneConfig->getLane(*tx);
     bool inserted = mTxSortedSets[lane].insert(tx).second;
     if (inserted)
     {
-        mLaneCurrentCount[lane] += mLaneConfig->getTxResources(*tx);
+        mLaneCurrentCount[lane] +=
+            mLaneConfig->getTxResources(*tx, ledgerVersion);
     }
 }
 
 void
-SurgePricingPriorityQueue::erase(TransactionFrameBasePtr tx)
+SurgePricingPriorityQueue::erase(TransactionFrameBasePtr tx,
+                                 uint32_t ledgerVersion)
 {
     releaseAssert(tx != nullptr);
     auto lane = mLaneConfig->getLane(*tx);
     auto it = mTxSortedSets[lane].find(tx);
     if (it != mTxSortedSets[lane].end())
     {
-        erase(lane, it);
+        erase(lane, it, ledgerVersion);
     }
 }
 
 void
-SurgePricingPriorityQueue::erase(Iterator const& it)
+SurgePricingPriorityQueue::erase(Iterator const& it, uint32_t ledgerVersion)
 {
     auto innerIt = it.getInnerIter();
-    erase(innerIt.first, innerIt.second);
+    erase(innerIt.first, innerIt.second, ledgerVersion);
 }
 
 void
 SurgePricingPriorityQueue::erase(
-    size_t lane, SurgePricingPriorityQueue::TxSortedSet::iterator iter)
+    size_t lane, SurgePricingPriorityQueue::TxSortedSet::iterator iter,
+    uint32_t ledgerVersion)
 {
-    auto res = mLaneConfig->getTxResources(*(*iter));
+    auto res = mLaneConfig->getTxResources(*(*iter), ledgerVersion);
     releaseAssert(res <= mLaneCurrentCount[lane]);
     mLaneCurrentCount[lane] -= res;
     mTxSortedSets[lane].erase(iter);
@@ -235,7 +239,7 @@ SurgePricingPriorityQueue::popTopTxs(
     bool allowGaps,
     std::function<VisitTxResult(TransactionFrameBasePtr const&)> const& visitor,
     std::vector<Resource>& laneLeftUntilLimit,
-    std::vector<bool>& hadTxNotFittingLane)
+    std::vector<bool>& hadTxNotFittingLane, uint32_t ledgerVersion)
 {
     ZoneScoped;
 
@@ -251,7 +255,7 @@ SurgePricingPriorityQueue::popTopTxs(
         while (!currIt.isEnd())
         {
             auto const& currTx = *(*currIt);
-            auto curr = mLaneConfig->getTxResources(currTx);
+            auto curr = mLaneConfig->getTxResources(currTx, ledgerVersion);
             auto lane = mLaneConfig->getLane(currTx);
             if (anyGreater(curr, laneLeftUntilLimit[lane]) ||
                 anyGreater(curr, laneLeftUntilLimit[GENERIC_LANE]))
@@ -261,7 +265,7 @@ SurgePricingPriorityQueue::popTopTxs(
                     // If gaps are allowed we just erase the iterator and
                     // continue in the main loop.
                     gapSkipped = true;
-                    erase(currIt);
+                    erase(currIt, ledgerVersion);
                     if (anyGreater(curr, laneLeftUntilLimit[lane]))
                     {
                         hadTxNotFittingLane[lane] = true;
@@ -311,7 +315,7 @@ SurgePricingPriorityQueue::popTopTxs(
         // we can visit it and remove it from the queue.
         auto const& tx = *currIt;
         auto visitRes = visitor(tx);
-        auto res = mLaneConfig->getTxResources(*tx);
+        auto res = mLaneConfig->getTxResources(*tx, ledgerVersion);
         auto lane = mLaneConfig->getLane(*tx);
         // Only account for resource counts when transaction was actually
         // processed by the visitor.
@@ -333,22 +337,23 @@ SurgePricingPriorityQueue::popTopTxs(
             hadTxNotFittingLane[GENERIC_LANE] = true;
             hadTxNotFittingLane[lane] = true;
         }
-        erase(currIt);
+        erase(currIt, ledgerVersion);
     }
 }
 
 std::pair<bool, int64_t>
 SurgePricingPriorityQueue::canFitWithEviction(
     TransactionFrameBase const& tx, std::optional<Resource> txDiscount,
-    std::vector<std::pair<TransactionFrameBasePtr, bool>>& txsToEvict) const
+    std::vector<std::pair<TransactionFrameBasePtr, bool>>& txsToEvict,
+    uint32_t ledgerVersion) const
 {
     ZoneScoped;
 
     // This only makes sense when the lowest fee rate tx is on top.
     releaseAssert(!mComparator.isGreater());
 
     auto lane = mLaneConfig->getLane(tx);
-    auto txNewResources = mLaneConfig->getTxResources(tx);
+    auto txNewResources = mLaneConfig->getTxResources(tx, ledgerVersion);
     if (txDiscount)
     {
         txNewResources = subtractNonNegative(txNewResources, *txDiscount);
@@ -442,7 +447,7 @@ SurgePricingPriorityQueue::canFitWithEviction(
         // the transaction by evicting some transactions.
         releaseAssert(!iter.isEnd());
         auto const& evictTx = *(*iter);
-        auto evict = mLaneConfig->getTxResources(evictTx);
+        auto evict = mLaneConfig->getTxResources(evictTx, ledgerVersion);
         auto evictLane = mLaneConfig->getLane(evictTx);
 
         // Evicted tx must have a strictly lower fee than the new tx.
@@ -596,10 +601,11 @@ DexLimitingLaneConfig::updateGenericLaneLimit(Resource const& limit)
 }
 
 Resource
-DexLimitingLaneConfig::getTxResources(TransactionFrameBase const& tx)
+DexLimitingLaneConfig::getTxResources(TransactionFrameBase const& tx,
+                                      uint32_t ledgerVersion)
 {
     releaseAssert(!tx.isSoroban());
-    return tx.getResources(mUseByteLimit);
+    return tx.getResources(mUseByteLimit, ledgerVersion);
 }
 
 size_t
@@ -645,9 +651,10 @@ SorobanGenericLaneConfig::updateGenericLaneLimit(Resource const& limit)
 }
 
 Resource
-SorobanGenericLaneConfig::getTxResources(TransactionFrameBase const& tx)
+SorobanGenericLaneConfig::getTxResources(TransactionFrameBase const& tx,
+                                         uint32_t ledgerVersion)
 {
     releaseAssert(tx.isSoroban());
-    return tx.getResources(/* useByteLimitInClassic */ false);
+    return tx.getResources(/* useByteLimitInClassic */ false, ledgerVersion);
 }
 } // namespace stellar

src/herder/SurgePricingUtils.h

@@ -55,7 +55,8 @@ class SurgePricingLaneConfig
     // configuration).
     virtual void updateGenericLaneLimit(Resource const& limit) = 0;
 
-    virtual Resource getTxResources(TransactionFrameBase const& tx) = 0;
+    virtual Resource getTxResources(TransactionFrameBase const& tx,
+                                    uint32_t ledgerVersion) = 0;
 
     virtual ~SurgePricingLaneConfig() = default;
 };
@@ -76,7 +77,8 @@ class DexLimitingLaneConfig : public SurgePricingLaneConfig
     size_t getLane(TransactionFrameBase const& tx) const override;
     std::vector<Resource> const& getLaneLimits() const override;
     virtual void updateGenericLaneLimit(Resource const& limit) override;
-    virtual Resource getTxResources(TransactionFrameBase const& tx) override;
+    virtual Resource getTxResources(TransactionFrameBase const& tx,
+                                    uint32_t ledgerVersion) override;
 
   private:
     std::vector<Resource> mLaneLimits;
@@ -91,7 +93,8 @@ class SorobanGenericLaneConfig : public SurgePricingLaneConfig
     size_t getLane(TransactionFrameBase const& tx) const override;
     std::vector<Resource> const& getLaneLimits() const override;
     virtual void updateGenericLaneLimit(Resource const& limit) override;
-    virtual Resource getTxResources(TransactionFrameBase const& tx) override;
+    virtual Resource getTxResources(TransactionFrameBase const& tx,
+                                    uint32_t ledgerVersion) override;
 
   private:
     std::vector<Resource> mLaneLimits;
@@ -117,7 +120,7 @@ class SurgePricingPriorityQueue
     static std::vector<TransactionFrameBasePtr> getMostTopTxsWithinLimits(
         std::vector<TransactionFrameBasePtr> const& txs,
         std::shared_ptr<SurgePricingLaneConfig> laneConfig,
-        std::vector<bool>& hadTxNotFittingLane);
+        std::vector<bool>& hadTxNotFittingLane, uint32_t ledgerVersion);
 
     // Returns total amount of resources in all the transactions in this queue.
     Resource totalResources() const;
@@ -154,7 +157,8 @@ class SurgePricingPriorityQueue
         std::vector<TransactionFrameBasePtr> const& txs,
         std::function<VisitTxResult(TransactionFrameBasePtr const&)> const&
             visitor,
-        std::vector<Resource>& laneResourcesLeftUntilLimit);
+        std::vector<Resource>& laneResourcesLeftUntilLimit,
+        uint32_t ledgerVersion);
 
     // Creates a `SurgePricingPriorityQueue` for the provided lane
     // configuration.
@@ -167,9 +171,9 @@ class SurgePricingPriorityQueue
         size_t comparisonSeed);
 
     // Adds a transaction to this queue.
-    void add(TransactionFrameBasePtr tx);
+    void add(TransactionFrameBasePtr tx, uint32_t ledgerVersion);
     // Erases a transaction from this queue.
-    void erase(TransactionFrameBasePtr tx);
+    void erase(TransactionFrameBasePtr tx, uint32_t ledgerVersion);
 
     // Checks whether a provided transaction could fit into this queue without
     // violating the `laneConfig` limits while evicting some lower fee rate
@@ -184,8 +188,8 @@ class SurgePricingPriorityQueue
     // limit (as opposed to 'generic' lane's limit).
     std::pair<bool, int64_t> canFitWithEviction(
         TransactionFrameBase const& tx, std::optional<Resource> txDiscount,
-        std::vector<std::pair<TransactionFrameBasePtr, bool>>& txsToEvict)
-        const;
+        std::vector<std::pair<TransactionFrameBasePtr, bool>>& txsToEvict,
+        uint32_t ledgerVersion) const;
 
     // Generalized method for visiting and popping the top transactions in the
     // queue until the lane limits are reached.
@@ -196,7 +200,7 @@ class SurgePricingPriorityQueue
         std::function<VisitTxResult(TransactionFrameBasePtr const&)> const&
             visitor,
         std::vector<Resource>& laneResourcesLeftUntilLimit,
-        std::vector<bool>& hadTxNotFittingLane);
+        std::vector<bool>& hadTxNotFittingLane, uint32_t ledgerVersion);
 
   private:
     class TxComparator
@@ -250,9 +254,10 @@ class SurgePricingPriorityQueue
         std::vector<LaneIter> mutable mIters;
     };
 
-    void erase(Iterator const& it);
+    void erase(Iterator const& it, uint32_t ledgerVersion);
     void erase(size_t lane,
-               SurgePricingPriorityQueue::TxSortedSet::iterator iter);
+               SurgePricingPriorityQueue::TxSortedSet::iterator iter,
+               uint32_t ledgerVersion);
 
     Iterator getTop() const;