[prep/refactor] make TxOrphanage a virtual class implemented by TxOrphanageImpl

Author: glozow

src/node/txdownloadman_impl.cpp

@@ -97,7 +97,7 @@ void TxDownloadManagerImpl::ActiveTipChange()
 
 void TxDownloadManagerImpl::BlockConnected(const std::shared_ptr<const CBlock>& pblock)
 {
-    m_orphanage.EraseForBlock(*pblock);
+    m_orphanage->EraseForBlock(*pblock);
 
     for (const auto& ptx : pblock->vtx) {
         RecentConfirmedTransactionsFilter().insert(ptx->GetHash().ToUint256());
@@ -137,7 +137,7 @@ bool TxDownloadManagerImpl::AlreadyHaveTx(const GenTxid& gtxid, bool include_rec
     // While we won't query by txid, we can try to "guess" what the wtxid is based on the txid.
     // A non-segwit transaction's txid == wtxid. Query this txhash "casted" to a wtxid. This will
     // help us find non-segwit transactions, saving bandwidth, and should have no false positives.
-    if (m_orphanage.HaveTx(Wtxid::FromUint256(hash))) return true;
+    if (m_orphanage->HaveTx(Wtxid::FromUint256(hash))) return true;
 
     if (include_reconsiderable && RecentRejectsReconsiderableFilter().contains(hash)) return true;
 
@@ -157,7 +157,7 @@ void TxDownloadManagerImpl::ConnectedPeer(NodeId nodeid, const TxDownloadConnect
 
 void TxDownloadManagerImpl::DisconnectedPeer(NodeId nodeid)
 {
-    m_orphanage.EraseForPeer(nodeid);
+    m_orphanage->EraseForPeer(nodeid);
     m_txrequest.DisconnectedPeer(nodeid);
 
     if (auto it = m_peer_info.find(nodeid); it != m_peer_info.end()) {
@@ -174,7 +174,7 @@ bool TxDownloadManagerImpl::AddTxAnnouncement(NodeId peer, const GenTxid& gtxid,
     // - exists in orphanage
     // - peer can be an orphan resolution candidate
     if (const auto* wtxid = std::get_if<Wtxid>(&gtxid)) {
-        if (auto orphan_tx{m_orphanage.GetTx(*wtxid)}) {
+        if (auto orphan_tx{m_orphanage->GetTx(*wtxid)}) {
             auto unique_parents{GetUniqueParents(*orphan_tx)};
             std::erase_if(unique_parents, [&](const auto& txid) {
                 return AlreadyHaveTx(txid, /*include_reconsiderable=*/false);
@@ -187,7 +187,7 @@ bool TxDownloadManagerImpl::AddTxAnnouncement(NodeId peer, const GenTxid& gtxid,
             }
 
             if (MaybeAddOrphanResolutionCandidate(unique_parents, *wtxid, peer, now)) {
-                m_orphanage.AddAnnouncer(orphan_tx->GetWitnessHash(), peer);
+                m_orphanage->AddAnnouncer(orphan_tx->GetWitnessHash(), peer);
             }
 
             // Return even if the peer isn't an orphan resolution candidate. This would be caught by AlreadyHaveTx.
@@ -227,7 +227,7 @@ bool TxDownloadManagerImpl::MaybeAddOrphanResolutionCandidate(const std::vector<
 {
     auto it_peer = m_peer_info.find(nodeid);
     if (it_peer == m_peer_info.end()) return false;
-    if (m_orphanage.HaveTxFromPeer(wtxid, nodeid)) return false;
+    if (m_orphanage->HaveTxFromPeer(wtxid, nodeid)) return false;
 
     const auto& peer_entry = m_peer_info.at(nodeid);
     const auto& info = peer_entry.m_connection_info;
@@ -305,7 +305,7 @@ std::optional<PackageToValidate> TxDownloadManagerImpl::Find1P1CPackage(const CT
     // children instead of the real one provided by the honest peer. Since we track all announcers
     // of an orphan, this does not exclude parent + orphan pairs that we happened to request from
     // different peers.
-    const auto cpfp_candidates_same_peer{m_orphanage.GetChildrenFromSamePeer(ptx, nodeid)};
+    const auto cpfp_candidates_same_peer{m_orphanage->GetChildrenFromSamePeer(ptx, nodeid)};
 
     // These children should be sorted from newest to oldest. In the (probably uncommon) case
     // of children that replace each other, this helps us accept the highest feerate (probably the
@@ -327,9 +327,9 @@ void TxDownloadManagerImpl::MempoolAcceptedTx(const CTransactionRef& tx)
     m_txrequest.ForgetTxHash(tx->GetHash());
     m_txrequest.ForgetTxHash(tx->GetWitnessHash());
 
-    m_orphanage.AddChildrenToWorkSet(*tx, m_opts.m_rng);
+    m_orphanage->AddChildrenToWorkSet(*tx, m_opts.m_rng);
     // If it came from the orphanage, remove it. No-op if the tx is not in txorphanage.
-    m_orphanage.EraseTx(tx->GetWitnessHash());
+    m_orphanage->EraseTx(tx->GetWitnessHash());
 }
 
 std::vector<Txid> TxDownloadManagerImpl::GetUniqueParents(const CTransaction& tx)
@@ -398,7 +398,7 @@ node::RejectedTxTodo TxDownloadManagerImpl::MempoolRejectedTx(const CTransaction
                 const auto& wtxid = ptx->GetWitnessHash();
                 // Potentially flip add_extra_compact_tx to false if tx is already in orphanage, which
                 // means it was already added to vExtraTxnForCompact.
-                add_extra_compact_tx &= !m_orphanage.HaveTx(wtxid);
+                add_extra_compact_tx &= !m_orphanage->HaveTx(wtxid);
 
                 // If there is no candidate for orphan resolution, AddTx will not be called. This means
                 // that if a peer is overloading us with invs and orphans, they will eventually not be
@@ -411,7 +411,7 @@ node::RejectedTxTodo TxDownloadManagerImpl::MempoolRejectedTx(const CTransaction
 
                 for (const auto& nodeid : orphan_resolution_candidates) {
                     if (MaybeAddOrphanResolutionCandidate(unique_parents, ptx->GetWitnessHash(), nodeid, now)) {
-                        m_orphanage.AddTx(ptx, nodeid);
+                        m_orphanage->AddTx(ptx, nodeid);
                     }
                 }
 
@@ -422,7 +422,7 @@ node::RejectedTxTodo TxDownloadManagerImpl::MempoolRejectedTx(const CTransaction
                 // DoS prevention: do not allow m_orphanage to grow unbounded (see CVE-2012-3789)
                 // Note that, if the orphanage reaches capacity, it's possible that we immediately evict
                 // the transaction we just added.
-                m_orphanage.LimitOrphans(m_opts.m_rng);
+                m_orphanage->LimitOrphans(m_opts.m_rng);
             } else {
                 unique_parents.clear();
                 LogDebug(BCLog::MEMPOOL, "not keeping orphan with rejected parents %s (wtxid=%s)\n",
@@ -491,7 +491,7 @@ node::RejectedTxTodo TxDownloadManagerImpl::MempoolRejectedTx(const CTransaction
 
     // If the tx failed in ProcessOrphanTx, it should be removed from the orphanage unless the
     // tx was still missing inputs. If the tx was not in the orphanage, EraseTx does nothing and returns 0.
-    if (state.GetResult() != TxValidationResult::TX_MISSING_INPUTS && m_orphanage.EraseTx(ptx->GetWitnessHash()) > 0) {
+    if (state.GetResult() != TxValidationResult::TX_MISSING_INPUTS && m_orphanage->EraseTx(ptx->GetWitnessHash()) > 0) {
         LogDebug(BCLog::TXPACKAGES, "   removed orphan tx %s (wtxid=%s)\n", ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString());
     }
 
@@ -561,28 +561,28 @@ std::pair<bool, std::optional<PackageToValidate>> TxDownloadManagerImpl::Receive
 
 bool TxDownloadManagerImpl::HaveMoreWork(NodeId nodeid)
 {
-    return m_orphanage.HaveTxToReconsider(nodeid);
+    return m_orphanage->HaveTxToReconsider(nodeid);
 }
 
 CTransactionRef TxDownloadManagerImpl::GetTxToReconsider(NodeId nodeid)
 {
-    return m_orphanage.GetTxToReconsider(nodeid);
+    return m_orphanage->GetTxToReconsider(nodeid);
 }
 
 void TxDownloadManagerImpl::CheckIsEmpty(NodeId nodeid)
 {
     assert(m_txrequest.Count(nodeid) == 0);
-    assert(m_orphanage.UsageByPeer(nodeid) == 0);
+    assert(m_orphanage->UsageByPeer(nodeid) == 0);
 }
 void TxDownloadManagerImpl::CheckIsEmpty()
 {
-    assert(m_orphanage.TotalOrphanUsage() == 0);
-    assert(m_orphanage.Size() == 0);
+    assert(m_orphanage->TotalOrphanUsage() == 0);
+    assert(m_orphanage->Size() == 0);
     assert(m_txrequest.Size() == 0);
     assert(m_num_wtxid_peers == 0);
 }
 std::vector<TxOrphanage::OrphanTxBase> TxDownloadManagerImpl::GetOrphanTransactions() const
 {
-    return m_orphanage.GetOrphanTransactions();
+    return m_orphanage->GetOrphanTransactions();
 }
 } // namespace node

src/node/txdownloadman_impl.h

@@ -22,7 +22,7 @@ class TxDownloadManagerImpl {
     TxDownloadOptions m_opts;
 
     /** Manages unvalidated tx data (orphan transactions for which we are downloading ancestors). */
-    TxOrphanage m_orphanage;
+    std::unique_ptr<TxOrphanage> m_orphanage;
     /** Tracks candidates for requesting and downloading transaction data. */
     TxRequestTracker m_txrequest;
 
@@ -128,7 +128,7 @@ class TxDownloadManagerImpl {
         return *m_lazy_recent_confirmed_transactions;
     }
 
-    TxDownloadManagerImpl(const TxDownloadOptions& options) : m_opts{options}, m_txrequest{options.m_deterministic_txrequest} {}
+    TxDownloadManagerImpl(const TxDownloadOptions& options) : m_opts{options}, m_orphanage{MakeTxOrphanage()}, m_txrequest{options.m_deterministic_txrequest} {}
 
     struct PeerInfo {
         /** Information relevant to scheduling tx requests. */

src/node/txorphanage.cpp

@@ -12,8 +12,85 @@
 
 #include <cassert>
 
-namespace node{
-bool TxOrphanage::AddTx(const CTransactionRef& tx, NodeId peer)
+namespace node {
+
+class TxOrphanageImpl final : public TxOrphanage {
+private:
+    struct OrphanTx : public OrphanTxBase {
+        NodeSeconds nTimeExpire;
+        size_t list_pos;
+    };
+
+    /** Total usage (weight) of all entries in m_orphans. */
+    int64_t m_total_orphan_usage{0};
+
+    /** Total number of <peer, tx> pairs. Can be larger than m_orphans.size() because multiple peers
+     * may have announced the same orphan. */
+    unsigned int m_total_announcements{0};
+
+    /** Map from wtxid to orphan transaction record. Limited by
+     *  DEFAULT_MAX_ORPHAN_TRANSACTIONS */
+    std::map<Wtxid, OrphanTx> m_orphans;
+
+    struct PeerOrphanInfo {
+        /** List of transactions that should be reconsidered: added to in AddChildrenToWorkSet,
+         * removed from one-by-one with each call to GetTxToReconsider. The wtxids may refer to
+         * transactions that are no longer present in orphanage; these are lazily removed in
+         * GetTxToReconsider. */
+        std::set<Wtxid> m_work_set;
+
+        /** Total weight of orphans for which this peer is an announcer.
+         * If orphans are provided by different peers, its weight will be accounted for in each
+         * PeerOrphanInfo, so the total of all peers' m_total_usage may be larger than
+         * m_total_orphan_size. If a peer is removed as an announcer, even if the orphan still
+         * remains in the orphanage, this number will be decremented. */
+        int64_t m_total_usage{0};
+    };
+    std::map<NodeId, PeerOrphanInfo> m_peer_orphanage_info;
+
+    using OrphanMap = decltype(m_orphans);
+
+    struct IteratorComparator
+    {
+        template<typename I>
+        bool operator()(const I& a, const I& b) const
+        {
+            return a->first < b->first;
+        }
+    };
+
+    /** Index from the parents' COutPoint into the m_orphans. Used
+     *  to remove orphan transactions from the m_orphans */
+    std::map<COutPoint, std::set<OrphanMap::iterator, IteratorComparator>> m_outpoint_to_orphan_it;
+
+    /** Orphan transactions in vector for quick random eviction */
+    std::vector<OrphanMap::iterator> m_orphan_list;
+
+    /** Timestamp for the next scheduled sweep of expired orphans */
+    NodeSeconds m_next_sweep{0s};
+
+public:
+    bool AddTx(const CTransactionRef& tx, NodeId peer) override;
+    bool AddAnnouncer(const Wtxid& wtxid, NodeId peer) override;
+    CTransactionRef GetTx(const Wtxid& wtxid) const override;
+    bool HaveTx(const Wtxid& wtxid) const override;
+    bool HaveTxFromPeer(const Wtxid& wtxid, NodeId peer) const override;
+    CTransactionRef GetTxToReconsider(NodeId peer) override;
+    int EraseTx(const Wtxid& wtxid) override;
+    void EraseForPeer(NodeId peer) override;
+    void EraseForBlock(const CBlock& block) override;
+    void LimitOrphans(FastRandomContext& rng) override;
+    void AddChildrenToWorkSet(const CTransaction& tx, FastRandomContext& rng) override;
+    bool HaveTxToReconsider(NodeId peer) override;
+    std::vector<CTransactionRef> GetChildrenFromSamePeer(const CTransactionRef& parent, NodeId nodeid) const override;
+    size_t Size() const override { return m_orphans.size(); }
+    std::vector<OrphanTxBase> GetOrphanTransactions() const override;
+    int64_t TotalOrphanUsage() const override { return m_total_orphan_usage; }
+    int64_t UsageByPeer(NodeId peer) const override;
+    void SanityCheck() const override;
+};
+
+bool TxOrphanageImpl::AddTx(const CTransactionRef& tx, NodeId peer)
 {
     const Txid& hash = tx->GetHash();
     const Wtxid& wtxid = tx->GetWitnessHash();
@@ -53,7 +130,7 @@ bool TxOrphanage::AddTx(const CTransactionRef& tx, NodeId peer)
     return true;
 }
 
-bool TxOrphanage::AddAnnouncer(const Wtxid& wtxid, NodeId peer)
+bool TxOrphanageImpl::AddAnnouncer(const Wtxid& wtxid, NodeId peer)
 {
     const auto it = m_orphans.find(wtxid);
     if (it != m_orphans.end()) {
@@ -70,7 +147,7 @@ bool TxOrphanage::AddAnnouncer(const Wtxid& wtxid, NodeId peer)
     return false;
 }
 
-int TxOrphanage::EraseTx(const Wtxid& wtxid)
+int TxOrphanageImpl::EraseTx(const Wtxid& wtxid)
 {
     std::map<Wtxid, OrphanTx>::iterator it = m_orphans.find(wtxid);
     if (it == m_orphans.end())
@@ -116,7 +193,7 @@ int TxOrphanage::EraseTx(const Wtxid& wtxid)
     return 1;
 }
 
-void TxOrphanage::EraseForPeer(NodeId peer)
+void TxOrphanageImpl::EraseForPeer(NodeId peer)
 {
     // Zeroes out this peer's m_total_usage.
     m_peer_orphanage_info.erase(peer);
@@ -141,7 +218,7 @@ void TxOrphanage::EraseForPeer(NodeId peer)
     if (nErased > 0) LogDebug(BCLog::TXPACKAGES, "Erased %d orphan transaction(s) from peer=%d\n", nErased, peer);
 }
 
-void TxOrphanage::LimitOrphans(FastRandomContext& rng)
+void TxOrphanageImpl::LimitOrphans(FastRandomContext& rng)
 {
     unsigned int nEvicted = 0;
     auto nNow{Now<NodeSeconds>()};
@@ -173,7 +250,7 @@ void TxOrphanage::LimitOrphans(FastRandomContext& rng)
     if (nEvicted > 0) LogDebug(BCLog::TXPACKAGES, "orphanage overflow, removed %u tx\n", nEvicted);
 }
 
-void TxOrphanage::AddChildrenToWorkSet(const CTransaction& tx, FastRandomContext& rng)
+void TxOrphanageImpl::AddChildrenToWorkSet(const CTransaction& tx, FastRandomContext& rng)
 {
     for (unsigned int i = 0; i < tx.vout.size(); i++) {
         const auto it_by_prev = m_outpoint_to_orphan_it.find(COutPoint(tx.GetHash(), i));
@@ -201,24 +278,25 @@ void TxOrphanage::AddChildrenToWorkSet(const CTransaction& tx, FastRandomContext
     }
 }
 
-bool TxOrphanage::HaveTx(const Wtxid& wtxid) const
+bool TxOrphanageImpl::HaveTx(const Wtxid& wtxid) const
 {
     return m_orphans.count(wtxid);
 }
 
-CTransactionRef TxOrphanage::GetTx(const Wtxid& wtxid) const
+CTransactionRef TxOrphanageImpl::GetTx(const Wtxid& wtxid) const
 {
     auto it = m_orphans.find(wtxid);
     return it != m_orphans.end() ? it->second.tx : nullptr;
 }
 
-bool TxOrphanage::HaveTxFromPeer(const Wtxid& wtxid, NodeId peer) const
+
+bool TxOrphanageImpl::HaveTxFromPeer(const Wtxid& wtxid, NodeId peer) const
 {
     auto it = m_orphans.find(wtxid);
     return (it != m_orphans.end() && it->second.announcers.contains(peer));
 }
 
-CTransactionRef TxOrphanage::GetTxToReconsider(NodeId peer)
+CTransactionRef TxOrphanageImpl::GetTxToReconsider(NodeId peer)
 {
     auto peer_it = m_peer_orphanage_info.find(peer);
     if (peer_it == m_peer_orphanage_info.end()) return nullptr;
@@ -236,7 +314,7 @@ CTransactionRef TxOrphanage::GetTxToReconsider(NodeId peer)
     return nullptr;
 }
 
-bool TxOrphanage::HaveTxToReconsider(NodeId peer)
+bool TxOrphanageImpl::HaveTxToReconsider(NodeId peer)
 {
     auto peer_it = m_peer_orphanage_info.find(peer);
     if (peer_it == m_peer_orphanage_info.end()) return false;
@@ -245,7 +323,7 @@ bool TxOrphanage::HaveTxToReconsider(NodeId peer)
     return !work_set.empty();
 }
 
-void TxOrphanage::EraseForBlock(const CBlock& block)
+void TxOrphanageImpl::EraseForBlock(const CBlock& block)
 {
     std::vector<Wtxid> vOrphanErase;
 
@@ -273,7 +351,7 @@ void TxOrphanage::EraseForBlock(const CBlock& block)
     }
 }
 
-std::vector<CTransactionRef> TxOrphanage::GetChildrenFromSamePeer(const CTransactionRef& parent, NodeId nodeid) const
+std::vector<CTransactionRef> TxOrphanageImpl::GetChildrenFromSamePeer(const CTransactionRef& parent, NodeId nodeid) const
 {
     // First construct a vector of iterators to ensure we do not return duplicates of the same tx
     // and so we can sort by nTimeExpire.
@@ -313,7 +391,7 @@ std::vector<CTransactionRef> TxOrphanage::GetChildrenFromSamePeer(const CTransac
     return children_found;
 }
 
-std::vector<TxOrphanage::OrphanTxBase> TxOrphanage::GetOrphanTransactions() const
+std::vector<TxOrphanage::OrphanTxBase> TxOrphanageImpl::GetOrphanTransactions() const
 {
     std::vector<OrphanTxBase> ret;
     ret.reserve(m_orphans.size());
@@ -323,7 +401,13 @@ std::vector<TxOrphanage::OrphanTxBase> TxOrphanage::GetOrphanTransactions() cons
     return ret;
 }
 
-void TxOrphanage::SanityCheck() const
+int64_t TxOrphanageImpl::UsageByPeer(NodeId peer) const
+{
+    auto peer_it = m_peer_orphanage_info.find(peer);
+    return peer_it == m_peer_orphanage_info.end() ? 0 : peer_it->second.m_total_usage;
+}
+
+void TxOrphanageImpl::SanityCheck() const
 {
     // Check that cached m_total_announcements is correct
     unsigned int counted_total_announcements{0};
@@ -362,4 +446,10 @@ void TxOrphanage::SanityCheck() const
         }
     }
 }
+
+std::unique_ptr<TxOrphanage> MakeTxOrphanage() noexcept
+{
+    return std::make_unique<TxOrphanageImpl>();
+}
+
 } // namespace node