v29.4-roots.4 · Commit 7: [PATCH 07/37] release: establish Roots maintenance and assurance

src/node/miner.cpp

Before: src/node/miner.cpp · After: src/node/miner.cpp

File metadata

index aabe3fef4d97e3fb612f1a37d4e40ef3b3be6ea9..e039935a8165fe7185cdc28939485bd83aa0d3be 100644

Download original patch · Release notes

Diff rows 1–142 of 142. Line numbers refer to the original before/after files.

+ Added− RemovedUnmarked lines are context.

Scroll the code area horizontally to read long lines. Before is on the left; after is on the right. Unified view fits narrow screens more easily.

src/node/miner.cpp CHANGED Viewed

@@ -25,7 +25,10 @@
 #include <validation.h>
 #include <algorithm>
 #include <utility>
 namespace node {
@@ -93,6 +96,111 @@ BlockAssembler::BlockAssembler(Chainstate& chainstate, const CTxMemPool* mempool
     fNeedSizeAccounting = m_options.nBlockMaxSize < MAX_BLOCK_SERIALIZED_SIZE;
 }
 void ApplyArgsManOptions(const ArgsManager& args, BlockAssembler::Options& options)
 {
     // Block resource limits
@@ -165,8 +273,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock()
     if (m_mempool) {
         LOCK(m_mempool->cs);
         addPriorityTxs(*m_mempool, nPackagesSelected);
-        // addPackageTxs acquires the same recursive mempool lock.
-        addPackageTxs(nPackagesSelected, nDescendantsUpdated);
     }
     const auto time_1{SteadyClock::now()};
@@ -325,10 +432,9 @@ void BlockAssembler::SortForBlock(const CTxMemPool::setEntries& package, std::ve
 // Each time through the loop, we compare the best transaction in
 // mapModifiedTxs with the next transaction in the mempool to decide what
 // transaction package to work on next.
-void BlockAssembler::addPackageTxs(int& nPackagesSelected, int& nDescendantsUpdated)
 {
-    const auto& mempool{*Assert(m_mempool)};
-    LOCK(mempool.cs);
     // mapModifiedTx will store sorted packages after they are modified
     // because some of their txs are already in the block

 #include <validation.h>
 #include <algorithm>
+#include <cassert>
+#include <map>
 #include <utility>
+#include <vector>
 namespace node {
     fNeedSizeAccounting = m_options.nBlockMaxSize < MAX_BLOCK_SERIALIZED_SIZE;
 }
+namespace {
+using TxCoinAgePriority = std::pair<double, CTxMemPool::txiter>;
+struct TxCoinAgePriorityCompare {
+    bool operator()(const TxCoinAgePriority& a, const TxCoinAgePriority& b) const
+    {
+        if (a.first == b.first) {
+            return CompareTxMemPoolEntryByScore{}(*b.second, *a.second);
+        }
+        return a.first < b.first;
+    }
+};
+} // namespace
+bool BlockAssembler::isStillDependent(const CTxMemPool& mempool, CTxMemPool::txiter iter)
+{
+    assert(iter != mempool.mapTx.end());
+    for (const auto& parent : iter->GetMemPoolParentsConst()) {
+        const auto parent_it{mempool.mapTx.iterator_to(parent)};
+        if (!inBlock.count(parent_it)) return true;
+    }
+    return false;
+}
+bool BlockAssembler::TestForBlock(CTxMemPool::txiter iter)
+{
+    const auto package_size{iter->GetSizeWithAncestors()};
+    const int64_t package_sigops{iter->GetSigOpCostWithAncestors()};
+    if (!TestPackage(package_size, package_sigops)) {
+        if (nBlockWeight > m_options.nBlockMaxWeight - 400 || nBlockSigOpsCost > MAX_BLOCK_SIGOPS_COST - 8 || lastFewTxs > 50) {
+            blockFinished = true;
+            return false;
+        }
+        if (nBlockWeight > m_options.nBlockMaxWeight - 4000) ++lastFewTxs;
+        return false;
+    }
+    CTxMemPool::setEntries package;
+    package.insert(iter);
+    if (!TestPackageTransactions(package)) {
+        if (nBlockSize > m_options.nBlockMaxSize - 100 || lastFewTxs > 50) {
+            blockFinished = true;
+            return false;
+        }
+        if (nBlockSize > m_options.nBlockMaxSize - 1000) ++lastFewTxs;
+        return false;
+    }
+    return true;
+}
+void BlockAssembler::addPriorityTxs(const CTxMemPool& mempool, int& packages_selected)
+{
+    AssertLockHeld(mempool.cs);
+    uint64_t priority_size{static_cast<uint64_t>(gArgs.GetIntArg("-blockprioritysize", DEFAULT_BLOCK_PRIORITY_SIZE))};
+    priority_size = std::min<uint64_t>(priority_size, m_options.nBlockMaxSize);
+    if (priority_size == 0) return;
+    const bool previous_size_accounting{fNeedSizeAccounting};
+    fNeedSizeAccounting = true;
+    std::vector<TxCoinAgePriority> priorities;
+    std::map<CTxMemPool::txiter, double, CompareIteratorByHash> waiting;
+    priorities.reserve(mempool.mapTx.size());
+    for (auto iter{mempool.mapTx.begin()}; iter != mempool.mapTx.end(); ++iter) {
+        double priority{iter->GetPriority(nHeight)};
+        CAmount fee_delta{0};
+        mempool.ApplyDeltas(iter->GetTx().GetHash(), priority, fee_delta);
+        priorities.emplace_back(priority, iter);
+    }
+    TxCoinAgePriorityCompare compare;
+    std::make_heap(priorities.begin(), priorities.end(), compare);
+    while (!priorities.empty() && !blockFinished) {
+        const CTxMemPool::txiter iter{priorities.front().second};
+        const double priority{priorities.front().first};
+        std::pop_heap(priorities.begin(), priorities.end(), compare);
+        priorities.pop_back();
+        if (inBlock.count(iter)) {
+            assert(false);
+            continue;
+        }
+        if (isStillDependent(mempool, iter)) {
+            waiting.emplace(iter, priority);
+            continue;
+        }
+        if (!TestForBlock(iter)) continue;
+        AddToBlock(iter);
+        ++packages_selected;
+        if (nBlockSize >= priority_size || priority <= MINIMUM_TX_PRIORITY) break;
+        for (const auto& child : iter->GetMemPoolChildrenConst()) {
+            const auto child_iter{mempool.mapTx.iterator_to(child)};
+            const auto waiting_iter{waiting.find(child_iter)};
+            if (waiting_iter == waiting.end()) continue;
+            priorities.emplace_back(waiting_iter->second, child_iter);
+            std::push_heap(priorities.begin(), priorities.end(), compare);
+            waiting.erase(waiting_iter);
+        }
+    }
+    fNeedSizeAccounting = previous_size_accounting;
+}
 void ApplyArgsManOptions(const ArgsManager& args, BlockAssembler::Options& options)
 {
     // Block resource limits
     if (m_mempool) {
         LOCK(m_mempool->cs);
         addPriorityTxs(*m_mempool, nPackagesSelected);
+        addPackageTxs(*m_mempool, nPackagesSelected, nDescendantsUpdated);
     }
     const auto time_1{SteadyClock::now()};
 // Each time through the loop, we compare the best transaction in
 // mapModifiedTxs with the next transaction in the mempool to decide what
 // transaction package to work on next.
+void BlockAssembler::addPackageTxs(const CTxMemPool& mempool, int& nPackagesSelected, int& nDescendantsUpdated)
 {
+    AssertLockHeld(mempool.cs);
     // mapModifiedTx will store sorted packages after they are modified
     // because some of their txs are already in the block