|
| 1 | +// Copyright (c) 2023 The Bitcoin Core developers |
| 2 | +// Distributed under the MIT software license, see the accompanying |
| 3 | +// file COPYING or http://www.opensource.org/licenses/mit-license.php. |
| 4 | + |
| 5 | +#ifndef BITCOIN_KERNEL_DISCONNECTED_TRANSACTIONS_H |
| 6 | +#define BITCOIN_KERNEL_DISCONNECTED_TRANSACTIONS_H |
| 7 | + |
| 8 | +#include <core_memusage.h> |
| 9 | +#include <memusage.h> |
| 10 | +#include <primitives/transaction.h> |
| 11 | +#include <util/hasher.h> |
| 12 | + |
| 13 | +#include <list> |
| 14 | +#include <unordered_map> |
| 15 | + |
| 16 | +/** |
| 17 | + * DisconnectedBlockTransactions |
| 18 | +
|
| 19 | + * During the reorg, it's desirable to re-add previously confirmed transactions |
| 20 | + * to the mempool, so that anything not re-confirmed in the new chain is |
| 21 | + * available to be mined. However, it's more efficient to wait until the reorg |
| 22 | + * is complete and process all still-unconfirmed transactions at that time, |
| 23 | + * since we expect most confirmed transactions to (typically) still be |
| 24 | + * confirmed in the new chain, and re-accepting to the memory pool is expensive |
| 25 | + * (and therefore better to not do in the middle of reorg-processing). |
| 26 | + * Instead, store the disconnected transactions (in order!) as we go, remove any |
| 27 | + * that are included in blocks in the new chain, and then process the remaining |
| 28 | + * still-unconfirmed transactions at the end. |
| 29 | + * |
| 30 | + * Order of queuedTx: |
| 31 | + * The front of the list should be the most recently-confirmed transactions (transactions at the |
| 32 | + * end of vtx of blocks closer to the tip). If memory usage grows too large, we trim from the front |
| 33 | + * of the list. After trimming, transactions can be re-added to the mempool from the back of the |
| 34 | + * list to the front without running into missing inputs. |
| 35 | + */ |
| 36 | +class DisconnectedBlockTransactions { |
| 37 | +private: |
| 38 | + /** Cached dynamic memory usage for the CTransactions (memory for the shared pointers is |
| 39 | + * included in the container calculations). */ |
| 40 | + uint64_t cachedInnerUsage = 0; |
| 41 | + std::list<CTransactionRef> queuedTx; |
| 42 | + using TxList = decltype(queuedTx); |
| 43 | + std::unordered_map<uint256, TxList::iterator, SaltedTxidHasher> iters_by_txid; |
| 44 | + |
| 45 | +public: |
| 46 | + // It's almost certainly a logic bug if we don't clear out queuedTx before |
| 47 | + // destruction, as we add to it while disconnecting blocks, and then we |
| 48 | + // need to re-process remaining transactions to ensure mempool consistency. |
| 49 | + // For now, assert() that we've emptied out this object on destruction. |
| 50 | + // This assert() can always be removed if the reorg-processing code were |
| 51 | + // to be refactored such that this assumption is no longer true (for |
| 52 | + // instance if there was some other way we cleaned up the mempool after a |
| 53 | + // reorg, besides draining this object). |
| 54 | + ~DisconnectedBlockTransactions() { |
| 55 | + assert(queuedTx.empty()); |
| 56 | + assert(iters_by_txid.empty()); |
| 57 | + assert(cachedInnerUsage == 0); |
| 58 | + } |
| 59 | + |
| 60 | + size_t DynamicMemoryUsage() const { |
| 61 | + return cachedInnerUsage + memusage::DynamicUsage(iters_by_txid) + memusage::DynamicUsage(queuedTx); |
| 62 | + } |
| 63 | + |
| 64 | + /** Add transactions from the block, iterating through vtx in reverse order. Callers should call |
| 65 | + * this function for blocks in descending order by block height. |
| 66 | + * We assume that callers never pass multiple transactions with the same txid, otherwise things |
| 67 | + * can go very wrong in removeForBlock due to queuedTx containing an item without a |
| 68 | + * corresponding entry in iters_by_txid. |
| 69 | + */ |
| 70 | + void AddTransactionsFromBlock(const std::vector<CTransactionRef>& vtx) |
| 71 | + { |
| 72 | + iters_by_txid.reserve(iters_by_txid.size() + vtx.size()); |
| 73 | + for (auto block_it = vtx.rbegin(); block_it != vtx.rend(); ++block_it) { |
| 74 | + auto it = queuedTx.insert(queuedTx.end(), *block_it); |
| 75 | + iters_by_txid.emplace((*block_it)->GetHash(), it); |
| 76 | + cachedInnerUsage += RecursiveDynamicUsage(**block_it); |
| 77 | + } |
| 78 | + } |
| 79 | + |
| 80 | + /** Remove any entries that are in this block. */ |
| 81 | + void removeForBlock(const std::vector<CTransactionRef>& vtx) |
| 82 | + { |
| 83 | + // Short-circuit in the common case of a block being added to the tip |
| 84 | + if (queuedTx.empty()) { |
| 85 | + return; |
| 86 | + } |
| 87 | + for (const auto& tx : vtx) { |
| 88 | + auto iter = iters_by_txid.find(tx->GetHash()); |
| 89 | + if (iter != iters_by_txid.end()) { |
| 90 | + auto list_iter = iter->second; |
| 91 | + iters_by_txid.erase(iter); |
| 92 | + cachedInnerUsage -= RecursiveDynamicUsage(**list_iter); |
| 93 | + queuedTx.erase(list_iter); |
| 94 | + } |
| 95 | + } |
| 96 | + } |
| 97 | + |
| 98 | + /** Remove the first entry and update memory usage. */ |
| 99 | + CTransactionRef take_first() |
| 100 | + { |
| 101 | + CTransactionRef first_tx; |
| 102 | + if (!queuedTx.empty()) { |
| 103 | + first_tx = queuedTx.front(); |
| 104 | + cachedInnerUsage -= RecursiveDynamicUsage(*queuedTx.front()); |
| 105 | + iters_by_txid.erase(queuedTx.front()->GetHash()); |
| 106 | + queuedTx.pop_front(); |
| 107 | + } |
| 108 | + return first_tx; |
| 109 | + } |
| 110 | + |
| 111 | + size_t size() const { return queuedTx.size(); } |
| 112 | + |
| 113 | + void clear() |
| 114 | + { |
| 115 | + cachedInnerUsage = 0; |
| 116 | + iters_by_txid.clear(); |
| 117 | + queuedTx.clear(); |
| 118 | + } |
| 119 | + |
| 120 | + /** Clear all data structures and return the list of transactions. */ |
| 121 | + std::list<CTransactionRef> take() |
| 122 | + { |
| 123 | + std::list<CTransactionRef> ret = std::move(queuedTx); |
| 124 | + clear(); |
| 125 | + return ret; |
| 126 | + } |
| 127 | +}; |
| 128 | +#endif // BITCOIN_KERNEL_DISCONNECTED_TRANSACTIONS_H |
0 commit comments