AGENT: Add peer rotation

Author: rustaceanrob

src/CMakeLists.txt

@@ -204,6 +204,7 @@ add_library(bitcoin_node STATIC EXCLUDE_FROM_ALL
   kernel/mempool_removal_reason.cpp
   mapport.cpp
   net.cpp
+  net_ibd_peer.cpp
   net_processing.cpp
   netgroup.cpp
   node/abort.cpp

src/init.cpp

@@ -2111,6 +2111,11 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     connOptions.whitelist_relay = args.GetBoolArg("-whitelistrelay", DEFAULT_WHITELISTRELAY);
     connOptions.m_capture_messages = args.GetBoolArg("-capturemessages", false);
 
+    // Set up IBD check callback for preferential peer selection during IBD
+    connOptions.m_is_in_ibd_callback = [&node]() {
+        return node.chainman->IsInitialBlockDownload();
+    };
+
     // Port to bind to if `-bind=addr` is provided without a `:port` suffix.
     const uint16_t default_bind_port =
         static_cast<uint16_t>(args.GetIntArg("-port", Params().GetDefaultPort()));

src/net.cpp

@@ -7,6 +7,8 @@
 
 #include <net.h>
 
+#include <net_ibd_peer.h>
+
 #include <addrdb.h>
 #include <addrman.h>
 #include <banman.h>
@@ -37,6 +39,10 @@
 #include <util/translation.h>
 #include <util/vector.h>
 
+// Forward declarations for IBD peer selection
+std::chrono::seconds GetNextIBDEpoch();
+void EvaluateIBDPeers(CConnman& connman);
+
 #include <algorithm>
 #include <array>
 #include <cmath>
@@ -2560,6 +2566,8 @@ void CConnman::ThreadOpenConnections(const std::vector<std::string> connect, std
     auto next_feeler = start + rng.rand_exp_duration(FEELER_INTERVAL);
     auto next_extra_block_relay = start + rng.rand_exp_duration(EXTRA_BLOCK_RELAY_ONLY_PEER_INTERVAL);
     auto next_extra_network_peer{start + rng.rand_exp_duration(EXTRA_NETWORK_PEER_INTERVAL)};
+    // Next IBD peer evaluation timestamp
+    auto next_ibd_peer_eval = start + GetNextIBDEpoch();
     const bool dnsseed = gArgs.GetBoolArg("-dnsseed", DEFAULT_DNSSEED);
     bool add_fixed_seeds = gArgs.GetBoolArg("-fixedseeds", DEFAULT_FIXEDSEEDS);
     const bool use_seednodes{!gArgs.GetArgs("-seednode").empty()};
@@ -2593,6 +2601,13 @@ void CConnman::ThreadOpenConnections(const std::vector<std::string> connect, std
 
         PerformReconnections();
 
+        // Evaluate IBD peers periodically to find better connections
+        auto now_ibd = GetTime<std::chrono::microseconds>();
+        if (now_ibd > next_ibd_peer_eval) {
+            EvaluateIBDPeers(*this);
+            next_ibd_peer_eval = now_ibd + GetNextIBDEpoch();
+        }
+
         CountingSemaphoreGrant<> grant(*semOutbound);
         if (m_interrupt_net->interrupted()) {
             return;
@@ -4222,3 +4237,65 @@ std::function<void(const CAddress& addr,
                    std::span<const unsigned char> data,
                    bool is_incoming)>
     CaptureMessage = CaptureMessageToFile;
+
+// IBD Peer Selection Implementation
+//
+// During Initial Block Download, we want to connect to the best possible peers
+// (low latency, high bandwidth) to speed up sync. This function is called
+// periodically to evaluate our peers and potentially swap to better ones.
+
+std::chrono::seconds GetNextIBDEpoch()
+{
+    // Configurable epoch length
+    static const auto epoch_length = std::chrono::seconds{gArgs.GetArg("-ibd-peer-epoch", DEFAULT_IBD_PEER_EPOCH_LENGTH.count())};
+    return epoch_length;
+}
+
+void EvaluateIBDPeers(CConnman& connman)
+{
+    // Only run if IBD check callback is available
+    if (!connman.IsInIBD()) return;
+
+    // Get all full outbound relay peers
+    std::vector<CNode*> outbound_peers;
+    connman.ForEachNode([&outbound_peers](CNode* node) {
+        if (node->IsFullOutboundConn() && node->fSuccessfullyConnected) {
+            outbound_peers.push_back(node);
+        }
+    });
+
+    // Need minimum peers to consider swapping
+    if (outbound_peers.size() < IBD_PEER_MIN_PEERS) {
+        return;
+    }
+
+    // Calculate scores for all peers
+    std::vector<IBDPeerScore> scores;
+    for (const CNode* node : outbound_peers) {
+        auto score = CalculateIBDScore(node);
+        if (score) {
+            scores.push_back(*score);
+        }
+    }
+
+    if (scores.empty()) return;
+
+    // Sort by score (highest first)
+    std::sort(scores.begin(), scores.end(), [](const IBDPeerScore& a, const IBDPeerScore& b) {
+        return a.CalculateScore() > b.CalculateScore();
+    });
+
+    // Log scores for debugging
+    for (const auto& score : scores) {
+        LogIBDPeerScore(score);
+    }
+
+    // If the lowest scoring peer is below threshold, try to find a better one
+    const auto& lowest = scores.back();
+    if (lowest.CalculateScore() < IBD_PEER_SCORE_THRESHOLD) {
+        // Mark this peer for potential eviction
+        // We'll request a new outbound connection attempt
+        connman.SetTryNewOutboundPeer(true);
+        LogDebug(BCLog::NET, "IBD: Low scoring peer detected, attempting to find better peer\n");
+    }
+}

src/net.h

@@ -1099,6 +1099,9 @@ class CConnman
         bool whitelist_forcerelay = DEFAULT_WHITELISTFORCERELAY;
         bool whitelist_relay = DEFAULT_WHITELISTRELAY;
         bool m_capture_messages = false;
+        //! Callback to check if we're in Initial Block Download.
+        //! If set, used for preferential peer selection during IBD.
+        std::function<bool()> m_is_in_ibd_callback;
     };
 
     void Init(const Options& connOptions) EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex, !m_total_bytes_sent_mutex)
@@ -1115,6 +1118,7 @@ class CConnman
         m_client_interface = connOptions.uiInterface;
         m_banman = connOptions.m_banman;
         m_msgproc = connOptions.m_msgproc;
+        m_is_in_ibd_callback = connOptions.m_is_in_ibd_callback;
         nSendBufferMaxSize = connOptions.nSendBufferMaxSize;
         nReceiveFloodSize = connOptions.nReceiveFloodSize;
         m_peer_connect_timeout = std::chrono::seconds{connOptions.m_peer_connect_timeout};
@@ -1165,6 +1169,7 @@ class CConnman
 
     void Interrupt() EXCLUSIVE_LOCKS_REQUIRED(!mutexMsgProc);
     bool GetNetworkActive() const { return fNetworkActive; };
+    bool IsInIBD() const { return m_is_in_ibd_callback && m_is_in_ibd_callback(); };
     bool GetUseAddrmanOutgoing() const { return m_use_addrman_outgoing; };
     void SetNetworkActive(bool active);
 
@@ -1684,6 +1689,8 @@ class CConnman
     NetEventsInterface* m_msgproc;
     /** Pointer to this node's banman. May be nullptr - check existence before dereferencing. */
     BanMan* m_banman;
+    /** Callback to check if we're in Initial Block Download. */
+    std::function<bool()> m_is_in_ibd_callback;
 
     /**
      * Addresses that were saved during the previous clean shutdown. We'll

src/net_ibd_peer.cpp

@@ -0,0 +1,93 @@
+// Copyright (c) 2024 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <net_ibd_peer.h>
+
+#include <logging.h>
+#include <net.h>
+
+#include <algorithm>
+#include <cmath>
+#include <limits>
+
+std::chrono::microseconds GetPeerMinPing(const CNode* node)
+{
+    if (!node) return std::chrono::microseconds::max();
+    return node->m_min_ping_time.load();
+}
+
+uint64_t GetPeerTotalBytes(const CNode* node)
+{
+    if (!node) return 0;
+    // These are plain uint64_t members in CNode, not atomic
+    return node->nSendBytes + node->nRecvBytes;
+}
+
+std::optional<IBDPeerScore> CalculateIBDScore(const CNode* node)
+{
+    if (!node) return std::nullopt;
+
+    // Only score outbound full relay peers
+    if (!node->IsFullOutboundConn()) return std::nullopt;
+
+    // Need at least one successful ping
+    auto min_ping = GetPeerMinPing(node);
+    if (min_ping == std::chrono::microseconds::max() || min_ping.count() <= 0) {
+        return std::nullopt;
+    }
+
+    IBDPeerScore score;
+    score.node_id = node->GetId();
+    score.min_ping = min_ping;
+    score.total_bytes = GetPeerTotalBytes(node);
+    // m_connected is a const member, access it directly
+    score.connected_time = node->m_connected;
+
+    return score;
+}
+
+double IBDPeerScore::CalculateScore() const
+{
+    // Normalize ping time: assume 0ms - 5000ms range, lower is better
+    // Normalize to [0, 1] where 1 is best (lowest ping)
+    constexpr double MAX_PING_US = 5'000'000.0; // 5 seconds
+    double ping_val = static_cast<double>(min_ping.count());
+    double ping_score = 1.0 - (std::min(ping_val, MAX_PING_US) / MAX_PING_US);
+
+    // Normalize bandwidth: assume 0 - 100MB range, higher is better
+    constexpr double MAX_BYTES = 100'000'000.0; // 100 MB
+    double bandwidth_score = std::min(static_cast<double>(total_bytes), MAX_BYTES) / MAX_BYTES;
+
+    // Connection stability: longer is better, cap at 10 minutes
+    constexpr auto MAX_STABLE_TIME = std::chrono::minutes{10};
+    double stability_score = 1.0;
+    if (connected_time > std::chrono::seconds{1}) {
+        stability_score = std::min(
+            static_cast<double>(connected_time.count()) / static_cast<double>(MAX_STABLE_TIME.count()),
+            1.0
+        );
+    }
+
+    // Weighted score: bandwidth 50%, latency 35%, stability 15%
+    // During IBD, bandwidth is critical
+    double final_score = (bandwidth_score * 0.5) + (ping_score * 0.35) + (stability_score * 0.15);
+
+    return final_score;
+}
+
+bool IBDPeerScore::ShouldReplace() const
+{
+    return poor_epoch_count >= IBD_PEER_EPOCHS_BEFORE_DISCONNECT;
+}
+
+void LogIBDPeerScore(const IBDPeerScore& score)
+{
+    LogDebug(BCLog::NET, "IBD Peer %lld: ping=%lluus, bytes=%llu, time=%lds, score=%.2f, poor_epochs=%d\n",
+        static_cast<long long>(score.node_id),
+        static_cast<unsigned long long>(score.min_ping.count()),
+        static_cast<unsigned long long>(score.total_bytes),
+        static_cast<long>(score.connected_time.count()),
+        score.CalculateScore(),
+        score.poor_epoch_count);
+}

src/net_ibd_peer.h

@@ -0,0 +1,82 @@
+// Copyright (c) 2024 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_NET_IBD_PEER_H
+#define BITCOIN_NET_IBD_PEER_H
+
+#include <chrono>
+#include <cstdint>
+#include <optional>
+
+class CNode;
+
+/**
+ * IBD peer scoring constants and configuration.
+ * These can be adjusted to tune the preferential peer behavior during Initial Block Download.
+ */
+
+// Default epoch duration: how often we evaluate peer quality during IBD
+static constexpr std::chrono::seconds DEFAULT_IBD_PEER_EPOCH_LENGTH{60};
+
+// Minimum number of full relay peers required before we consider swapping
+static constexpr int IBD_PEER_MIN_PEERS{2};
+
+// Score threshold below which we try to find a better peer (lower = stricter)
+static constexpr double IBD_PEER_SCORE_THRESHOLD{0.5};
+
+// Number of epochs a peer must perform poorly before we disconnect
+static constexpr int IBD_PEER_EPOCHS_BEFORE_DISCONNECT{3};
+
+// Maximum attempts to find a better peer per epoch
+static constexpr int IBD_PEER_MAX_SWAP_ATTEMPTS{5};
+
+/**
+ * IBDPeerScore - tracks peer quality metrics during Initial Block Download
+ */
+struct IBDPeerScore {
+    int64_t node_id{0};
+    std::chrono::microseconds min_ping{std::chrono::microseconds::max()};
+    uint64_t total_bytes{0};
+    std::chrono::seconds connected_time{std::chrono::seconds::zero()};
+    int poor_epoch_count{0};  // Number of epochs peer scored below threshold
+
+    /**
+     * Calculate a normalized score for this peer.
+     * Higher is better. Range: [0.0, 1.0]
+     * 
+     * Score is based on:
+     * - Latency (ping time) - lower is better
+     * - Bandwidth (total bytes transferred) - higher is better
+     * - Connection stability (time connected) - longer is better
+     */
+    double CalculateScore() const;
+
+    /**
+     * Check if this peer should be considered for replacement.
+     */
+    bool ShouldReplace() const;
+};
+
+/**
+ * Get the minimum ping time for a peer in microseconds.
+ */
+std::chrono::microseconds GetPeerMinPing(const CNode* node);
+
+/**
+ * Get total bytes transferred (send + receive) for a peer.
+ */
+uint64_t GetPeerTotalBytes(const CNode* node);
+
+/**
+ * Calculate peer score for IBD purposes.
+ * Returns nullopt if not enough data to score.
+ */
+std::optional<IBDPeerScore> CalculateIBDScore(const CNode* node);
+
+/**
+ * Log IBD peer scoring information.
+ */
+void LogIBDPeerScore(const IBDPeerScore& score);
+
+#endif // BITCOIN_NET_IBD_PEER_H