X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Frouting%2Frouter.rs;h=75bd47fb91b5798a1d580a4343b1059b1c764fb9;hb=694e70f5b57ba6cb8392e3de98a301bd0de23b87;hp=7bd1cebc532de093c4ce81f315f3759eb0501494;hpb=c92db69183143a58b3017ec450bdbf15a035bd9f;p=rust-lightning diff --git a/lightning/src/routing/router.rs b/lightning/src/routing/router.rs index 7bd1cebc..75bd47fb 100644 --- a/lightning/src/routing/router.rs +++ b/lightning/src/routing/router.rs @@ -9,18 +9,21 @@ //! The router finds paths within a [`NetworkGraph`] for a payment. -use bitcoin::secp256k1::PublicKey; +use bitcoin::secp256k1::{PublicKey, Secp256k1, self}; use bitcoin::hashes::Hash; use bitcoin::hashes::sha256::Hash as Sha256; use crate::blinded_path::{BlindedHop, BlindedPath}; +use crate::blinded_path::payment::{ForwardNode, ForwardTlvs, PaymentConstraints, PaymentRelay, ReceiveTlvs}; use crate::ln::PaymentHash; use crate::ln::channelmanager::{ChannelDetails, PaymentId}; -use crate::ln::features::{Bolt11InvoiceFeatures, Bolt12InvoiceFeatures, ChannelFeatures, NodeFeatures}; +use crate::ln::features::{BlindedHopFeatures, Bolt11InvoiceFeatures, Bolt12InvoiceFeatures, ChannelFeatures, NodeFeatures}; use crate::ln::msgs::{DecodeError, ErrorAction, LightningError, MAX_VALUE_MSAT}; use crate::offers::invoice::{BlindedPayInfo, Bolt12Invoice}; +use crate::onion_message::{DefaultMessageRouter, Destination, MessageRouter, OnionMessagePath}; use crate::routing::gossip::{DirectedChannelInfo, EffectiveCapacity, ReadOnlyNetworkGraph, NetworkGraph, NodeId, RoutingFees}; use crate::routing::scoring::{ChannelUsage, LockableScore, ScoreLookUp}; +use crate::sign::EntropySource; use crate::util::ser::{Writeable, Readable, ReadableArgs, Writer}; use crate::util::logger::{Level, Logger}; use crate::util::chacha20::ChaCha20; @@ -33,7 +36,7 @@ use core::{cmp, fmt}; use core::ops::Deref; /// A [`Router`] implemented using [`find_route`]. -pub struct DefaultRouter>, L: Deref, S: Deref, SP: Sized, Sc: ScoreLookUp> where +pub struct DefaultRouter> + Clone, L: Deref, S: Deref, SP: Sized, Sc: ScoreLookUp> where L::Target: Logger, S::Target: for <'a> LockableScore<'a, ScoreLookUp = Sc>, { @@ -41,21 +44,23 @@ pub struct DefaultRouter>, L: Deref, S: Deref, logger: L, random_seed_bytes: Mutex<[u8; 32]>, scorer: S, - score_params: SP + score_params: SP, + message_router: DefaultMessageRouter, } -impl>, L: Deref, S: Deref, SP: Sized, Sc: ScoreLookUp> DefaultRouter where +impl> + Clone, L: Deref, S: Deref, SP: Sized, Sc: ScoreLookUp> DefaultRouter where L::Target: Logger, S::Target: for <'a> LockableScore<'a, ScoreLookUp = Sc>, { /// Creates a new router. pub fn new(network_graph: G, logger: L, random_seed_bytes: [u8; 32], scorer: S, score_params: SP) -> Self { let random_seed_bytes = Mutex::new(random_seed_bytes); - Self { network_graph, logger, random_seed_bytes, scorer, score_params } + let message_router = DefaultMessageRouter::new(network_graph.clone()); + Self { network_graph, logger, random_seed_bytes, scorer, score_params, message_router } } } -impl< G: Deref>, L: Deref, S: Deref, SP: Sized, Sc: ScoreLookUp> Router for DefaultRouter where +impl> + Clone, L: Deref, S: Deref, SP: Sized, Sc: ScoreLookUp> Router for DefaultRouter where L::Target: Logger, S::Target: for <'a> LockableScore<'a, ScoreLookUp = Sc>, { @@ -78,10 +83,109 @@ impl< G: Deref>, L: Deref, S: Deref, SP: Sized, Sc: Sco &random_seed_bytes ) } + + fn create_blinded_payment_paths< + ES: EntropySource + ?Sized, T: secp256k1::Signing + secp256k1::Verification + >( + &self, recipient: PublicKey, first_hops: Vec, tlvs: ReceiveTlvs, + amount_msats: u64, entropy_source: &ES, secp_ctx: &Secp256k1 + ) -> Result, ()> { + // Limit the number of blinded paths that are computed. + const MAX_PAYMENT_PATHS: usize = 3; + + // Ensure peers have at least three channels so that it is more difficult to infer the + // recipient's node_id. + const MIN_PEER_CHANNELS: usize = 3; + + let network_graph = self.network_graph.deref().read_only(); + let paths = first_hops.into_iter() + .filter(|details| details.counterparty.features.supports_route_blinding()) + .filter(|details| amount_msats <= details.inbound_capacity_msat) + .filter(|details| amount_msats >= details.inbound_htlc_minimum_msat.unwrap_or(0)) + .filter(|details| amount_msats <= details.inbound_htlc_maximum_msat.unwrap_or(u64::MAX)) + .filter(|details| network_graph + .node(&NodeId::from_pubkey(&details.counterparty.node_id)) + .map(|node_info| node_info.channels.len() >= MIN_PEER_CHANNELS) + .unwrap_or(false) + ) + .filter_map(|details| { + let short_channel_id = match details.get_inbound_payment_scid() { + Some(short_channel_id) => short_channel_id, + None => return None, + }; + let payment_relay: PaymentRelay = match details.counterparty.forwarding_info { + Some(forwarding_info) => forwarding_info.into(), + None => return None, + }; + + // Avoid exposing esoteric CLTV expiry deltas + let cltv_expiry_delta = match payment_relay.cltv_expiry_delta { + 0..=40 => 40u32, + 41..=80 => 80u32, + 81..=144 => 144u32, + 145..=216 => 216u32, + _ => return None, + }; + + let payment_constraints = PaymentConstraints { + max_cltv_expiry: tlvs.payment_constraints.max_cltv_expiry + cltv_expiry_delta, + htlc_minimum_msat: details.inbound_htlc_minimum_msat.unwrap_or(0), + }; + Some(ForwardNode { + tlvs: ForwardTlvs { + short_channel_id, + payment_relay, + payment_constraints, + features: BlindedHopFeatures::empty(), + }, + node_id: details.counterparty.node_id, + htlc_maximum_msat: details.inbound_htlc_maximum_msat.unwrap_or(u64::MAX), + }) + }) + .map(|forward_node| { + BlindedPath::new_for_payment( + &[forward_node], recipient, tlvs.clone(), u64::MAX, entropy_source, secp_ctx + ) + }) + .take(MAX_PAYMENT_PATHS) + .collect::, _>>(); + + match paths { + Ok(paths) if !paths.is_empty() => Ok(paths), + _ => { + if network_graph.nodes().contains_key(&NodeId::from_pubkey(&recipient)) { + BlindedPath::one_hop_for_payment(recipient, tlvs, entropy_source, secp_ctx) + .map(|path| vec![path]) + } else { + Err(()) + } + }, + } + } +} + +impl< G: Deref> + Clone, L: Deref, S: Deref, SP: Sized, Sc: ScoreLookUp> MessageRouter for DefaultRouter where + L::Target: Logger, + S::Target: for <'a> LockableScore<'a, ScoreLookUp = Sc>, +{ + fn find_path( + &self, sender: PublicKey, peers: Vec, destination: Destination + ) -> Result { + self.message_router.find_path(sender, peers, destination) + } + + fn create_blinded_paths< + ES: EntropySource + ?Sized, T: secp256k1::Signing + secp256k1::Verification + >( + &self, recipient: PublicKey, peers: Vec, entropy_source: &ES, + secp_ctx: &Secp256k1 + ) -> Result, ()> { + self.message_router.create_blinded_paths(recipient, peers, entropy_source, secp_ctx) + } } /// A trait defining behavior for routing a payment. -pub trait Router { +pub trait Router: MessageRouter { /// Finds a [`Route`] for a payment between the given `payer` and a payee. /// /// The `payee` and the payment's value are given in [`RouteParameters::payment_params`] @@ -105,6 +209,16 @@ pub trait Router { ) -> Result { self.find_route(payer, route_params, first_hops, inflight_htlcs) } + + /// Creates [`BlindedPath`]s for payment to the `recipient` node. The channels in `first_hops` + /// are assumed to be with the `recipient`'s peers. The payment secret and any constraints are + /// given in `tlvs`. + fn create_blinded_payment_paths< + ES: EntropySource + ?Sized, T: secp256k1::Signing + secp256k1::Verification + >( + &self, recipient: PublicKey, first_hops: Vec, tlvs: ReceiveTlvs, + amount_msats: u64, entropy_source: &ES, secp_ctx: &Secp256k1 + ) -> Result, ()>; } /// [`ScoreLookUp`] implementation that factors in in-flight HTLC liquidity. @@ -997,14 +1111,94 @@ impl cmp::PartialOrd for RouteGraphNode { // While RouteGraphNode can be laid out with fewer bytes, performance appears to be improved // substantially when it is laid out at exactly 64 bytes. -// -// Thus, we use `#[repr(C)]` on the struct to force a suboptimal layout and check that it stays 64 -// bytes here. -#[cfg(any(ldk_bench, not(any(test, fuzzing))))] const _GRAPH_NODE_SMALL: usize = 64 - core::mem::size_of::(); -#[cfg(any(ldk_bench, not(any(test, fuzzing))))] const _GRAPH_NODE_FIXED_SIZE: usize = core::mem::size_of::() - 64; +/// A [`CandidateRouteHop::FirstHop`] entry. +#[derive(Clone, Debug)] +pub struct CandidateFirstHop<'a> { + /// Channel details of the first hop + /// + /// [`ChannelDetails::get_outbound_payment_scid`] MUST be `Some` (indicating the channel + /// has been funded and is able to pay), and accessor methods may panic otherwise. + /// + /// [`find_route`] validates this prior to constructing a [`CandidateRouteHop`]. + pub details: &'a ChannelDetails, + /// The node id of the payer, which is also the source side of this candidate route hop. + pub payer_node_id: &'a NodeId, + /// A unique ID which describes the payer. It will not conlict with any + /// [`NodeInfo::node_counter`]s, but may be equal to one if the payer is a public node. + payer_node_counter: u32, + /// A unique ID which describes the first hop counterparty. It will not conlict with any + /// [`NodeInfo::node_counter`]s, but may be equal to one if the counterparty is a public node. + target_node_counter: u32, +} + +/// A [`CandidateRouteHop::PublicHop`] entry. +#[derive(Clone, Debug)] +pub struct CandidatePublicHop<'a> { + /// Information about the channel, including potentially its capacity and + /// direction-specific information. + pub info: DirectedChannelInfo<'a>, + /// The short channel ID of the channel, i.e. the identifier by which we refer to this + /// channel. + pub short_channel_id: u64, +} + +/// A [`CandidateRouteHop::PrivateHop`] entry. +#[derive(Clone, Debug)] +pub struct CandidatePrivateHop<'a> { + /// Information about the private hop communicated via BOLT 11. + pub hint: &'a RouteHintHop, + /// Node id of the next hop in BOLT 11 route hint. + pub target_node_id: &'a NodeId, + /// A unique ID which describes the source node of the hop (further from the payment target). + /// It will not conlict with any [`NodeInfo::node_counter`]s, but may be equal to one if the + /// node is a public node. + source_node_counter: u32, + /// A unique ID which describes the destination node of the hop (towards the payment target). + /// It will not conlict with any [`NodeInfo::node_counter`]s, but may be equal to one if the + /// node is a public node. + target_node_counter: u32, + +} + +/// A [`CandidateRouteHop::Blinded`] entry. +#[derive(Clone, Debug)] +pub struct CandidateBlindedPath<'a> { + /// Information about the blinded path including the fee, HTLC amount limits, and + /// cryptographic material required to build an HTLC through the given path. + pub hint: &'a (BlindedPayInfo, BlindedPath), + /// Index of the hint in the original list of blinded hints. + /// + /// This is used to cheaply uniquely identify this blinded path, even though we don't have + /// a short channel ID for this hop. + hint_idx: usize, + /// A unique ID which describes the introduction point of the blinded path. + /// It will not conlict with any [`NodeInfo::node_counter`]s, but will generally be equal to + /// one from the public network graph (assuming the introduction point is a public node). + source_node_counter: u32, +} + +/// A [`CandidateRouteHop::OneHopBlinded`] entry. +#[derive(Clone, Debug)] +pub struct CandidateOneHopBlindedPath<'a> { + /// Information about the blinded path including the fee, HTLC amount limits, and + /// cryptographic material required to build an HTLC terminating with the given path. + /// + /// Note that the [`BlindedPayInfo`] is ignored here. + pub hint: &'a (BlindedPayInfo, BlindedPath), + /// Index of the hint in the original list of blinded hints. + /// + /// This is used to cheaply uniquely identify this blinded path, even though we don't have + /// a short channel ID for this hop. + hint_idx: usize, + /// A unique ID which describes the introduction point of the blinded path. + /// It will not conlict with any [`NodeInfo::node_counter`]s, but will generally be equal to + /// one from the public network graph (assuming the introduction point is a public node). + source_node_counter: u32, +} + /// A wrapper around the various hop representations. /// /// Can be used to examine the properties of a hop, @@ -1012,36 +1206,14 @@ const _GRAPH_NODE_FIXED_SIZE: usize = core::mem::size_of::() - 6 #[derive(Clone, Debug)] pub enum CandidateRouteHop<'a> { /// A hop from the payer, where the outbound liquidity is known. - FirstHop { - /// Channel details of the first hop - /// - /// [`ChannelDetails::get_outbound_payment_scid`] MUST be `Some` (indicating the channel - /// has been funded and is able to pay), and accessor methods may panic otherwise. - /// - /// [`find_route`] validates this prior to constructing a [`CandidateRouteHop`]. - details: &'a ChannelDetails, - /// The node id of the payer, which is also the source side of this candidate route hop. - payer_node_id: &'a NodeId, - }, + FirstHop(CandidateFirstHop<'a>), /// A hop found in the [`ReadOnlyNetworkGraph`]. - PublicHop { - /// Information about the channel, including potentially its capacity and - /// direction-specific information. - info: DirectedChannelInfo<'a>, - /// The short channel ID of the channel, i.e. the identifier by which we refer to this - /// channel. - short_channel_id: u64, - }, + PublicHop(CandidatePublicHop<'a>), /// A private hop communicated by the payee, generally via a BOLT 11 invoice. /// /// Because BOLT 11 route hints can take multiple hops to get to the destination, this may not /// terminate at the payee. - PrivateHop { - /// Information about the private hop communicated via BOLT 11. - hint: &'a RouteHintHop, - /// Node id of the next hop in BOLT 11 route hint. - target_node_id: &'a NodeId - }, + PrivateHop(CandidatePrivateHop<'a>), /// A blinded path which starts with an introduction point and ultimately terminates with the /// payee. /// @@ -1050,16 +1222,7 @@ pub enum CandidateRouteHop<'a> { /// /// Because blinded paths are "all or nothing", and we cannot use just one part of a blinded /// path, the full path is treated as a single [`CandidateRouteHop`]. - Blinded { - /// Information about the blinded path including the fee, HTLC amount limits, and - /// cryptographic material required to build an HTLC through the given path. - hint: &'a (BlindedPayInfo, BlindedPath), - /// Index of the hint in the original list of blinded hints. - /// - /// This is used to cheaply uniquely identify this blinded path, even though we don't have - /// a short channel ID for this hop. - hint_idx: usize, - }, + Blinded(CandidateBlindedPath<'a>), /// Similar to [`Self::Blinded`], but the path here only has one hop. /// /// While we treat this similarly to [`CandidateRouteHop::Blinded`] in many respects (e.g. @@ -1071,18 +1234,7 @@ pub enum CandidateRouteHop<'a> { /// /// This primarily exists to track that we need to included a blinded path at the end of our /// [`Route`], even though it doesn't actually add an additional hop in the payment. - OneHopBlinded { - /// Information about the blinded path including the fee, HTLC amount limits, and - /// cryptographic material required to build an HTLC terminating with the given path. - /// - /// Note that the [`BlindedPayInfo`] is ignored here. - hint: &'a (BlindedPayInfo, BlindedPath), - /// Index of the hint in the original list of blinded hints. - /// - /// This is used to cheaply uniquely identify this blinded path, even though we don't have - /// a short channel ID for this hop. - hint_idx: usize, - }, + OneHopBlinded(CandidateOneHopBlindedPath<'a>), } impl<'a> CandidateRouteHop<'a> { @@ -1104,11 +1256,11 @@ impl<'a> CandidateRouteHop<'a> { #[inline] fn short_channel_id(&self) -> Option { match self { - CandidateRouteHop::FirstHop { details, .. } => details.get_outbound_payment_scid(), - CandidateRouteHop::PublicHop { short_channel_id, .. } => Some(*short_channel_id), - CandidateRouteHop::PrivateHop { hint, .. } => Some(hint.short_channel_id), - CandidateRouteHop::Blinded { .. } => None, - CandidateRouteHop::OneHopBlinded { .. } => None, + CandidateRouteHop::FirstHop(hop) => hop.details.get_outbound_payment_scid(), + CandidateRouteHop::PublicHop(hop) => Some(hop.short_channel_id), + CandidateRouteHop::PrivateHop(hop) => Some(hop.hint.short_channel_id), + CandidateRouteHop::Blinded(_) => None, + CandidateRouteHop::OneHopBlinded(_) => None, } } @@ -1120,22 +1272,22 @@ impl<'a> CandidateRouteHop<'a> { #[inline] pub fn globally_unique_short_channel_id(&self) -> Option { match self { - CandidateRouteHop::FirstHop { details, .. } => if details.is_public { details.short_channel_id } else { None }, - CandidateRouteHop::PublicHop { short_channel_id, .. } => Some(*short_channel_id), - CandidateRouteHop::PrivateHop { .. } => None, - CandidateRouteHop::Blinded { .. } => None, - CandidateRouteHop::OneHopBlinded { .. } => None, + CandidateRouteHop::FirstHop(hop) => if hop.details.is_public { hop.details.short_channel_id } else { None }, + CandidateRouteHop::PublicHop(hop) => Some(hop.short_channel_id), + CandidateRouteHop::PrivateHop(_) => None, + CandidateRouteHop::Blinded(_) => None, + CandidateRouteHop::OneHopBlinded(_) => None, } } // NOTE: This may alloc memory so avoid calling it in a hot code path. fn features(&self) -> ChannelFeatures { match self { - CandidateRouteHop::FirstHop { details, .. } => details.counterparty.features.to_context(), - CandidateRouteHop::PublicHop { info, .. } => info.channel().features.clone(), - CandidateRouteHop::PrivateHop { .. } => ChannelFeatures::empty(), - CandidateRouteHop::Blinded { .. } => ChannelFeatures::empty(), - CandidateRouteHop::OneHopBlinded { .. } => ChannelFeatures::empty(), + CandidateRouteHop::FirstHop(hop) => hop.details.counterparty.features.to_context(), + CandidateRouteHop::PublicHop(hop) => hop.info.channel().features.clone(), + CandidateRouteHop::PrivateHop(_) => ChannelFeatures::empty(), + CandidateRouteHop::Blinded(_) => ChannelFeatures::empty(), + CandidateRouteHop::OneHopBlinded(_) => ChannelFeatures::empty(), } } @@ -1147,11 +1299,11 @@ impl<'a> CandidateRouteHop<'a> { #[inline] pub fn cltv_expiry_delta(&self) -> u32 { match self { - CandidateRouteHop::FirstHop { .. } => 0, - CandidateRouteHop::PublicHop { info, .. } => info.direction().cltv_expiry_delta as u32, - CandidateRouteHop::PrivateHop { hint, .. } => hint.cltv_expiry_delta as u32, - CandidateRouteHop::Blinded { hint, .. } => hint.0.cltv_expiry_delta as u32, - CandidateRouteHop::OneHopBlinded { .. } => 0, + CandidateRouteHop::FirstHop(_) => 0, + CandidateRouteHop::PublicHop(hop) => hop.info.direction().cltv_expiry_delta as u32, + CandidateRouteHop::PrivateHop(hop) => hop.hint.cltv_expiry_delta as u32, + CandidateRouteHop::Blinded(hop) => hop.hint.0.cltv_expiry_delta as u32, + CandidateRouteHop::OneHopBlinded(_) => 0, } } @@ -1159,30 +1311,52 @@ impl<'a> CandidateRouteHop<'a> { #[inline] pub fn htlc_minimum_msat(&self) -> u64 { match self { - CandidateRouteHop::FirstHop { details, .. } => details.next_outbound_htlc_minimum_msat, - CandidateRouteHop::PublicHop { info, .. } => info.direction().htlc_minimum_msat, - CandidateRouteHop::PrivateHop { hint, .. } => hint.htlc_minimum_msat.unwrap_or(0), - CandidateRouteHop::Blinded { hint, .. } => hint.0.htlc_minimum_msat, + CandidateRouteHop::FirstHop(hop) => hop.details.next_outbound_htlc_minimum_msat, + CandidateRouteHop::PublicHop(hop) => hop.info.direction().htlc_minimum_msat, + CandidateRouteHop::PrivateHop(hop) => hop.hint.htlc_minimum_msat.unwrap_or(0), + CandidateRouteHop::Blinded(hop) => hop.hint.0.htlc_minimum_msat, CandidateRouteHop::OneHopBlinded { .. } => 0, } } + #[inline(always)] + fn src_node_counter(&self) -> u32 { + match self { + CandidateRouteHop::FirstHop { payer_node_counter, .. } => *payer_node_counter, + CandidateRouteHop::PublicHop { info, .. } => info.source_counter(), + CandidateRouteHop::PrivateHop { source_node_counter, .. } => *source_node_counter, + CandidateRouteHop::Blinded { source_node_counter, .. } => *source_node_counter, + CandidateRouteHop::OneHopBlinded { source_node_counter, .. } => *source_node_counter, + } + } + + #[inline] + fn target_node_counter(&self) -> Option { + match self { + CandidateRouteHop::FirstHop { target_node_counter, .. } => Some(*target_node_counter), + CandidateRouteHop::PublicHop { info, .. } => Some(info.target_counter()), + CandidateRouteHop::PrivateHop { target_node_counter, .. } => Some(*target_node_counter), + CandidateRouteHop::Blinded { .. } => None, + CandidateRouteHop::OneHopBlinded { .. } => None, + } + } + /// Returns the fees that must be paid to route an HTLC over this channel. #[inline] pub fn fees(&self) -> RoutingFees { match self { - CandidateRouteHop::FirstHop { .. } => RoutingFees { + CandidateRouteHop::FirstHop(_) => RoutingFees { base_msat: 0, proportional_millionths: 0, }, - CandidateRouteHop::PublicHop { info, .. } => info.direction().fees, - CandidateRouteHop::PrivateHop { hint, .. } => hint.fees, - CandidateRouteHop::Blinded { hint, .. } => { + CandidateRouteHop::PublicHop(hop) => hop.info.direction().fees, + CandidateRouteHop::PrivateHop(hop) => hop.hint.fees, + CandidateRouteHop::Blinded(hop) => { RoutingFees { - base_msat: hint.0.fee_base_msat, - proportional_millionths: hint.0.fee_proportional_millionths + base_msat: hop.hint.0.fee_base_msat, + proportional_millionths: hop.hint.0.fee_proportional_millionths } }, - CandidateRouteHop::OneHopBlinded { .. } => + CandidateRouteHop::OneHopBlinded(_) => RoutingFees { base_msat: 0, proportional_millionths: 0 }, } } @@ -1193,17 +1367,17 @@ impl<'a> CandidateRouteHop<'a> { /// cached! fn effective_capacity(&self) -> EffectiveCapacity { match self { - CandidateRouteHop::FirstHop { details, .. } => EffectiveCapacity::ExactLiquidity { - liquidity_msat: details.next_outbound_htlc_limit_msat, + CandidateRouteHop::FirstHop(hop) => EffectiveCapacity::ExactLiquidity { + liquidity_msat: hop.details.next_outbound_htlc_limit_msat, }, - CandidateRouteHop::PublicHop { info, .. } => info.effective_capacity(), - CandidateRouteHop::PrivateHop { hint: RouteHintHop { htlc_maximum_msat: Some(max), .. }, .. } => + CandidateRouteHop::PublicHop(hop) => hop.info.effective_capacity(), + CandidateRouteHop::PrivateHop(CandidatePrivateHop { hint: RouteHintHop { htlc_maximum_msat: Some(max), .. }, .. }) => EffectiveCapacity::HintMaxHTLC { amount_msat: *max }, - CandidateRouteHop::PrivateHop { hint: RouteHintHop { htlc_maximum_msat: None, .. }, .. } => + CandidateRouteHop::PrivateHop(CandidatePrivateHop { hint: RouteHintHop { htlc_maximum_msat: None, .. }, .. }) => EffectiveCapacity::Infinite, - CandidateRouteHop::Blinded { hint, .. } => - EffectiveCapacity::HintMaxHTLC { amount_msat: hint.0.htlc_maximum_msat }, - CandidateRouteHop::OneHopBlinded { .. } => EffectiveCapacity::Infinite, + CandidateRouteHop::Blinded(hop) => + EffectiveCapacity::HintMaxHTLC { amount_msat: hop.hint.0.htlc_maximum_msat }, + CandidateRouteHop::OneHopBlinded(_) => EffectiveCapacity::Infinite, } } @@ -1213,14 +1387,14 @@ impl<'a> CandidateRouteHop<'a> { #[inline] fn id(&self) -> CandidateHopId { match self { - CandidateRouteHop::Blinded { hint_idx, .. } => CandidateHopId::Blinded(*hint_idx), - CandidateRouteHop::OneHopBlinded { hint_idx, .. } => CandidateHopId::Blinded(*hint_idx), + CandidateRouteHop::Blinded(hop) => CandidateHopId::Blinded(hop.hint_idx), + CandidateRouteHop::OneHopBlinded(hop) => CandidateHopId::Blinded(hop.hint_idx), _ => CandidateHopId::Clear((self.short_channel_id().unwrap(), self.source() < self.target().unwrap())), } } fn blinded_path(&self) -> Option<&'a BlindedPath> { match self { - CandidateRouteHop::Blinded { hint, .. } | CandidateRouteHop::OneHopBlinded { hint, .. } => { + CandidateRouteHop::Blinded(CandidateBlindedPath { hint, .. }) | CandidateRouteHop::OneHopBlinded(CandidateOneHopBlindedPath { hint, .. }) => { Some(&hint.1) }, _ => None, @@ -1234,11 +1408,11 @@ impl<'a> CandidateRouteHop<'a> { #[inline] pub fn source(&self) -> NodeId { match self { - CandidateRouteHop::FirstHop { payer_node_id, .. } => **payer_node_id, - CandidateRouteHop::PublicHop { info, .. } => *info.source(), - CandidateRouteHop::PrivateHop { hint, .. } => hint.src_node_id.into(), - CandidateRouteHop::Blinded { hint, .. } => hint.1.introduction_node_id.into(), - CandidateRouteHop::OneHopBlinded { hint, .. } => hint.1.introduction_node_id.into(), + CandidateRouteHop::FirstHop(hop) => *hop.payer_node_id, + CandidateRouteHop::PublicHop(hop) => *hop.info.source(), + CandidateRouteHop::PrivateHop(hop) => hop.hint.src_node_id.into(), + CandidateRouteHop::Blinded(hop) => hop.hint.1.introduction_node_id.into(), + CandidateRouteHop::OneHopBlinded(hop) => hop.hint.1.introduction_node_id.into(), } } /// Returns the target node id of this hop, if known. @@ -1253,11 +1427,11 @@ impl<'a> CandidateRouteHop<'a> { #[inline] pub fn target(&self) -> Option { match self { - CandidateRouteHop::FirstHop { details, .. } => Some(details.counterparty.node_id.into()), - CandidateRouteHop::PublicHop { info, .. } => Some(*info.target()), - CandidateRouteHop::PrivateHop { target_node_id, .. } => Some(**target_node_id), - CandidateRouteHop::Blinded { .. } => None, - CandidateRouteHop::OneHopBlinded { .. } => None, + CandidateRouteHop::FirstHop(hop) => Some(hop.details.counterparty.node_id.into()), + CandidateRouteHop::PublicHop(hop) => Some(*hop.info.target()), + CandidateRouteHop::PrivateHop(hop) => Some(*hop.target_node_id), + CandidateRouteHop::Blinded(_) => None, + CandidateRouteHop::OneHopBlinded(_) => None, } } } @@ -1307,20 +1481,57 @@ fn iter_equal(mut iter_a: I1, mut iter_b: I2) } } +#[cfg(target_feature = "sse")] +#[inline(always)] +unsafe fn do_prefetch(ptr: *const T) { + #[cfg(target_arch = "x86_64")] + use core::arch::x86_64::*; + #[cfg(target_arch = "x86")] + use core::arch::x86::*; + _mm_prefetch(ptr as *const i8, _MM_HINT_T0); +} + +#[cfg(not(target_feature = "sse"))] +#[inline(always)] +unsafe fn do_prefetch(_: *const T) {} + +#[inline(always)] +fn prefetch_first_byte(t: &T) { + // While X86's prefetch should be safe even on an invalid memory address (the ISA says + // "PREFETCHh instruction is merely a hint and does not affect program behavior"), we take + // an extra step towards safety here by requiring the pointer be valid (as Rust references + // are always valid when accessed). + // + // Note that a pointer in Rust could be to a zero sized type, in which case the pointer could + // be NULL (or some other bogus value), so we explicitly check for that here. + if ::core::mem::size_of::() != 0 { + unsafe { do_prefetch(t) } + } +} + /// It's useful to keep track of the hops associated with the fees required to use them, /// so that we can choose cheaper paths (as per Dijkstra's algorithm). /// Fee values should be updated only in the context of the whole path, see update_value_and_recompute_fees. /// These fee values are useful to choose hops as we traverse the graph "payee-to-payer". #[derive(Clone)] -#[repr(C)] // Force fields to appear in the order we define them. +#[repr(align(128))] struct PathBuildingHop<'a> { candidate: CandidateRouteHop<'a>, + target_node_counter: Option, /// If we've already processed a node as the best node, we shouldn't process it again. Normally /// we'd just ignore it if we did as all channels would have a higher new fee, but because we /// may decrease the amounts in use as we walk the graph, the actual calculated fee may /// decrease as well. Thus, we have to explicitly track which nodes have been processed and /// avoid processing them again. was_processed: bool, + /// When processing a node as the next best-score candidate, we want to quickly check if it is + /// a direct counterparty of ours, using our local channel information immediately if we can. + /// + /// In order to do so efficiently, we cache whether a node is a direct counterparty here at the + /// start of a route-finding pass. Unlike all other fields in this struct, this field is never + /// updated after being initialized - it is set at the start of a route-finding pass and only + /// read thereafter. + is_first_hop_target: bool, /// Used to compare channels when choosing the for routing. /// Includes paying for the use of a hop and the following hops, as well as /// an estimated cost of reaching this hop. @@ -1333,11 +1544,6 @@ struct PathBuildingHop<'a> { /// channel scoring. path_penalty_msat: u64, - // The last 16 bytes are on the next cache line by default in glibc's malloc. Thus, we should - // only place fields which are not hot there. Luckily, the next three fields are only read if - // we end up on the selected path, and only in the final path layout phase, so we don't care - // too much if reading them is slow. - fee_msat: u64, /// All the fees paid *after* this channel on the way to the destination @@ -1354,28 +1560,20 @@ struct PathBuildingHop<'a> { value_contribution_msat: u64, } -// Checks that the entries in the `find_route` `dist` map fit in (exactly) two standard x86-64 -// cache lines. Sadly, they're not guaranteed to actually lie on a cache line (and in fact, -// generally won't, because at least glibc's malloc will align to a nice, big, round -// boundary...plus 16), but at least it will reduce the amount of data we'll need to load. -// -// Note that these assertions only pass on somewhat recent rustc, and thus are gated on the -// ldk_bench flag. -#[cfg(ldk_bench)] -const _NODE_MAP_SIZE_TWO_CACHE_LINES: usize = 128 - core::mem::size_of::<(NodeId, PathBuildingHop)>(); -#[cfg(ldk_bench)] -const _NODE_MAP_SIZE_EXACTLY_CACHE_LINES: usize = core::mem::size_of::<(NodeId, PathBuildingHop)>() - 128; +const _NODE_MAP_SIZE_TWO_CACHE_LINES: usize = 128 - core::mem::size_of::>(); +const _NODE_MAP_SIZE_EXACTLY_TWO_CACHE_LINES: usize = core::mem::size_of::>() - 128; impl<'a> core::fmt::Debug for PathBuildingHop<'a> { fn fmt(&self, f: &mut core::fmt::Formatter) -> Result<(), core::fmt::Error> { let mut debug_struct = f.debug_struct("PathBuildingHop"); debug_struct - .field("node_id", &self.candidate.target()) + .field("source_node_id", &self.candidate.source()) + .field("target_node_id", &self.candidate.target()) .field("short_channel_id", &self.candidate.short_channel_id()) .field("total_fee_msat", &self.total_fee_msat) .field("next_hops_fee_msat", &self.next_hops_fee_msat) .field("hop_use_fee_msat", &self.hop_use_fee_msat) - .field("total_fee_msat - (next_hops_fee_msat + hop_use_fee_msat)", &(&self.total_fee_msat - (&self.next_hops_fee_msat + &self.hop_use_fee_msat))) + .field("total_fee_msat - (next_hops_fee_msat + hop_use_fee_msat)", &(&self.total_fee_msat.saturating_sub(self.next_hops_fee_msat).saturating_sub(self.hop_use_fee_msat))) .field("path_penalty_msat", &self.path_penalty_msat) .field("path_htlc_minimum_msat", &self.path_htlc_minimum_msat) .field("cltv_expiry_delta", &self.candidate.cltv_expiry_delta()); @@ -1552,17 +1750,17 @@ struct LoggedCandidateHop<'a>(&'a CandidateRouteHop<'a>); impl<'a> fmt::Display for LoggedCandidateHop<'a> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self.0 { - CandidateRouteHop::Blinded { hint, .. } | CandidateRouteHop::OneHopBlinded { hint, .. } => { + CandidateRouteHop::Blinded(CandidateBlindedPath { hint, .. }) | CandidateRouteHop::OneHopBlinded(CandidateOneHopBlindedPath { hint, .. }) => { "blinded route hint with introduction node id ".fmt(f)?; hint.1.introduction_node_id.fmt(f)?; " and blinding point ".fmt(f)?; hint.1.blinding_point.fmt(f) }, - CandidateRouteHop::FirstHop { .. } => { + CandidateRouteHop::FirstHop(_) => { "first hop with SCID ".fmt(f)?; self.0.short_channel_id().unwrap().fmt(f) }, - CandidateRouteHop::PrivateHop { .. } => { + CandidateRouteHop::PrivateHop(_) => { "route hint with SCID ".fmt(f)?; self.0.short_channel_id().unwrap().fmt(f) }, @@ -1796,11 +1994,42 @@ where L::Target: Logger { first_hops.map(|hops| hops.len()).unwrap_or(0), if first_hops.is_some() { "" } else { "not " }, max_total_routing_fee_msat); + let private_hop_targets_node_counter_offset = network_graph.max_node_counter() + 2; + let mut private_node_id_to_node_counter = HashMap::new(); + + let mut private_hop_key_cache = HashMap::with_capacity( + payment_params.payee.unblinded_route_hints().iter().map(|path| path.0.len()).sum() + ); + + // Because we store references to private hop node_ids in `dist`, below, we need them to exist + // (as `NodeId`, not `PublicKey`) for the lifetime of `dist`. Thus, we calculate all the keys + // we'll need here and simply fetch them when routing. + let payee_node_counter = payee_node_id_opt + .and_then(|payee| network_nodes.get(&payee)) + .map(|node| node.node_counter) + .unwrap_or(private_hop_targets_node_counter_offset); + private_node_id_to_node_counter.insert(maybe_dummy_payee_node_id, payee_node_counter); + private_hop_key_cache.insert(maybe_dummy_payee_pk, (NodeId::from_pubkey(&maybe_dummy_payee_pk), payee_node_counter)); + + for route in payment_params.payee.unblinded_route_hints().iter() { + for hop in route.0.iter() { + let hop_node_id = NodeId::from_pubkey(&hop.src_node_id); + let node_counter = if let Some(node) = network_nodes.get(&hop_node_id) { + node.node_counter + } else { + let next_node_counter = private_hop_targets_node_counter_offset + private_node_id_to_node_counter.len() as u32; + *private_node_id_to_node_counter.entry(hop_node_id) + .or_insert(next_node_counter) + }; + private_hop_key_cache.insert(hop.src_node_id, (hop_node_id, node_counter)); + } + } + // Step (1). // Prepare the data we'll use for payee-to-payer search by // inserting first hops suggested by the caller as targets. // Our search will then attempt to reach them while traversing from the payee node. - let mut first_hop_targets: HashMap<_, Vec<&ChannelDetails>> = + let mut first_hop_targets: HashMap<_, (Vec<&ChannelDetails>, u32)> = HashMap::with_capacity(if first_hops.is_some() { first_hops.as_ref().unwrap().len() } else { 0 }); if let Some(hops) = first_hops { for chan in hops { @@ -1810,30 +2039,26 @@ where L::Target: Logger { if chan.counterparty.node_id == *our_node_pubkey { return Err(LightningError{err: "First hop cannot have our_node_pubkey as a destination.".to_owned(), action: ErrorAction::IgnoreError}); } + let counterparty_node_id = NodeId::from_pubkey(&chan.counterparty.node_id); first_hop_targets - .entry(NodeId::from_pubkey(&chan.counterparty.node_id)) - .or_insert(Vec::new()) - .push(chan); + .entry(counterparty_node_id) + .or_insert_with(|| { + let node_counter = if let Some(node) = network_nodes.get(&counterparty_node_id) { + node.node_counter + } else { + let next_node_counter = private_hop_targets_node_counter_offset + private_node_id_to_node_counter.len() as u32; + *private_node_id_to_node_counter.entry(counterparty_node_id) + .or_insert(next_node_counter) + }; + (Vec::new(), node_counter) + }) + .0.push(chan); } if first_hop_targets.is_empty() { return Err(LightningError{err: "Cannot route when there are no outbound routes away from us".to_owned(), action: ErrorAction::IgnoreError}); } } - let mut private_hop_key_cache = HashMap::with_capacity( - payment_params.payee.unblinded_route_hints().iter().map(|path| path.0.len()).sum() - ); - - // Because we store references to private hop node_ids in `dist`, below, we need them to exist - // (as `NodeId`, not `PublicKey`) for the lifetime of `dist`. Thus, we calculate all the keys - // we'll need here and simply fetch them when routing. - private_hop_key_cache.insert(maybe_dummy_payee_pk, NodeId::from_pubkey(&maybe_dummy_payee_pk)); - for route in payment_params.payee.unblinded_route_hints().iter() { - for hop in route.0.iter() { - private_hop_key_cache.insert(hop.src_node_id, NodeId::from_pubkey(&hop.src_node_id)); - } - } - // The main heap containing all candidate next-hops sorted by their score (max(fee, // htlc_minimum)). Ideally this would be a heap which allowed cheap score reduction instead of // adding duplicate entries when we find a better path to a given node. @@ -1841,7 +2066,15 @@ where L::Target: Logger { // Map from node_id to information about the best current path to that node, including feerate // information. - let mut dist: HashMap = HashMap::with_capacity(network_nodes.len()); + let dist_len = private_hop_targets_node_counter_offset + private_hop_key_cache.len() as u32 + 1; + let mut dist: Vec> = vec![None; dist_len as usize]; + let payer_node_counter = network_nodes + .get(&our_node_id) + .map(|node| node.node_counter) + .or_else(|| { + private_node_id_to_node_counter.get(&our_node_id).map(|counter| *counter) + }) + .unwrap_or(network_graph.max_node_counter() + 1); // During routing, if we ignore a path due to an htlc_minimum_msat limit, we set this, // indicating that we may wish to try again with a higher value, potentially paying to meet an @@ -1888,7 +2121,7 @@ where L::Target: Logger { // when we want to stop looking for new paths. let mut already_collected_value_msat = 0; - for (_, channels) in first_hop_targets.iter_mut() { + for (_, (channels, _)) in first_hop_targets.iter_mut() { sort_first_hop_channels(channels, &used_liquidities, recommended_value_msat, our_node_pubkey); } @@ -1934,6 +2167,8 @@ where L::Target: Logger { // if the amount being transferred over this path is lower. // We do this for now, but this is a subject for removal. if let Some(mut available_value_contribution_msat) = htlc_maximum_msat.checked_sub($next_hops_fee_msat) { + let cltv_expiry_delta = $candidate.cltv_expiry_delta(); + let htlc_minimum_msat = $candidate.htlc_minimum_msat(); let used_liquidity_msat = used_liquidities .get(&$candidate.id()) .map_or(0, |used_liquidity_msat| { @@ -1956,7 +2191,7 @@ where L::Target: Logger { .checked_sub(2*MEDIAN_HOP_CLTV_EXPIRY_DELTA) .unwrap_or(payment_params.max_total_cltv_expiry_delta - final_cltv_expiry_delta); let hop_total_cltv_delta = ($next_hops_cltv_delta as u32) - .saturating_add($candidate.cltv_expiry_delta()); + .saturating_add(cltv_expiry_delta); let exceeds_cltv_delta_limit = hop_total_cltv_delta > max_total_cltv_expiry_delta; let value_contribution_msat = cmp::min(available_value_contribution_msat, $next_hops_value_contribution); @@ -1967,13 +2202,13 @@ where L::Target: Logger { None => unreachable!(), }; #[allow(unused_comparisons)] // $next_hops_path_htlc_minimum_msat is 0 in some calls so rustc complains - let over_path_minimum_msat = amount_to_transfer_over_msat >= $candidate.htlc_minimum_msat() && + let over_path_minimum_msat = amount_to_transfer_over_msat >= htlc_minimum_msat && amount_to_transfer_over_msat >= $next_hops_path_htlc_minimum_msat; #[allow(unused_comparisons)] // $next_hops_path_htlc_minimum_msat is 0 in some calls so rustc complains let may_overpay_to_meet_path_minimum_msat = - ((amount_to_transfer_over_msat < $candidate.htlc_minimum_msat() && - recommended_value_msat >= $candidate.htlc_minimum_msat()) || + ((amount_to_transfer_over_msat < htlc_minimum_msat && + recommended_value_msat >= htlc_minimum_msat) || (amount_to_transfer_over_msat < $next_hops_path_htlc_minimum_msat && recommended_value_msat >= $next_hops_path_htlc_minimum_msat)); @@ -1981,10 +2216,10 @@ where L::Target: Logger { |scid| payment_params.previously_failed_channels.contains(&scid)); let (should_log_candidate, first_hop_details) = match $candidate { - CandidateRouteHop::FirstHop { details, .. } => (true, Some(details)), - CandidateRouteHop::PrivateHop { .. } => (true, None), - CandidateRouteHop::Blinded { .. } => (true, None), - CandidateRouteHop::OneHopBlinded { .. } => (true, None), + CandidateRouteHop::FirstHop(hop) => (true, Some(hop.details)), + CandidateRouteHop::PrivateHop(_) => (true, None), + CandidateRouteHop::Blinded(_) => (true, None), + CandidateRouteHop::OneHopBlinded(_) => (true, None), _ => (false, None), }; @@ -2048,19 +2283,25 @@ where L::Target: Logger { // payment path (upstream to the payee). To avoid that, we recompute // path fees knowing the final path contribution after constructing it. let curr_min = cmp::max( - $next_hops_path_htlc_minimum_msat, $candidate.htlc_minimum_msat() + $next_hops_path_htlc_minimum_msat, htlc_minimum_msat ); - let path_htlc_minimum_msat = compute_fees_saturating(curr_min, $candidate.fees()) + let candidate_fees = $candidate.fees(); + let src_node_counter = $candidate.src_node_counter(); + let path_htlc_minimum_msat = compute_fees_saturating(curr_min, candidate_fees) .saturating_add(curr_min); - let hm_entry = dist.entry(src_node_id); - let old_entry = hm_entry.or_insert_with(|| { + + let dist_entry = &mut dist[src_node_counter as usize]; + let old_entry = if let Some(hop) = dist_entry { + hop + } else { // If there was previously no known way to access the source node // (recall it goes payee-to-payer) of short_channel_id, first add a // semi-dummy record just to compute the fees to reach the source node. // This will affect our decision on selecting short_channel_id // as a way to reach the $candidate.target() node. - PathBuildingHop { + *dist_entry = Some(PathBuildingHop { candidate: $candidate.clone(), + target_node_counter: None, fee_msat: 0, next_hops_fee_msat: u64::max_value(), hop_use_fee_msat: u64::max_value(), @@ -2068,10 +2309,12 @@ where L::Target: Logger { path_htlc_minimum_msat, path_penalty_msat: u64::max_value(), was_processed: false, + is_first_hop_target: false, #[cfg(all(not(ldk_bench), any(test, fuzzing)))] value_contribution_msat, - } - }); + }); + dist_entry.as_mut().unwrap() + }; #[allow(unused_mut)] // We only use the mut in cfg(test) let mut should_process = !old_entry.was_processed; @@ -2091,7 +2334,7 @@ where L::Target: Logger { if src_node_id != our_node_id { // Note that `u64::max_value` means we'll always fail the // `old_entry.total_fee_msat > total_fee_msat` check below - hop_use_fee_msat = compute_fees_saturating(amount_to_transfer_over_msat, $candidate.fees()); + hop_use_fee_msat = compute_fees_saturating(amount_to_transfer_over_msat, candidate_fees); total_fee_msat = total_fee_msat.saturating_add(hop_use_fee_msat); } @@ -2153,6 +2396,7 @@ where L::Target: Logger { path_length_to_node, }; targets.push(new_graph_node); + old_entry.target_node_counter = $candidate.target_node_counter(); old_entry.next_hops_fee_msat = $next_hops_fee_msat; old_entry.hop_use_fee_msat = hop_use_fee_msat; old_entry.total_fee_msat = total_fee_msat; @@ -2230,34 +2474,42 @@ where L::Target: Logger { let fee_to_target_msat; let next_hops_path_htlc_minimum_msat; let next_hops_path_penalty_msat; - let skip_node = if let Some(elem) = dist.get_mut(&$node_id) { + let is_first_hop_target; + let skip_node = if let Some(elem) = &mut dist[$node.node_counter as usize] { let was_processed = elem.was_processed; elem.was_processed = true; fee_to_target_msat = elem.total_fee_msat; next_hops_path_htlc_minimum_msat = elem.path_htlc_minimum_msat; next_hops_path_penalty_msat = elem.path_penalty_msat; + is_first_hop_target = elem.is_first_hop_target; was_processed } else { // Entries are added to dist in add_entry!() when there is a channel from a node. // Because there are no channels from payee, it will not have a dist entry at this point. // If we're processing any other node, it is always be the result of a channel from it. debug_assert_eq!($node_id, maybe_dummy_payee_node_id); + fee_to_target_msat = 0; next_hops_path_htlc_minimum_msat = 0; next_hops_path_penalty_msat = 0; + is_first_hop_target = false; false }; if !skip_node { - if let Some(first_channels) = first_hop_targets.get(&$node_id) { - for details in first_channels { - let candidate = CandidateRouteHop::FirstHop { - details, payer_node_id: &our_node_id, - }; - add_entry!(&candidate, fee_to_target_msat, - $next_hops_value_contribution, - next_hops_path_htlc_minimum_msat, next_hops_path_penalty_msat, - $next_hops_cltv_delta, $next_hops_path_length); + if is_first_hop_target { + if let Some((first_channels, peer_node_counter)) = first_hop_targets.get(&$node_id) { + for details in first_channels { + debug_assert_eq!(*peer_node_counter, $node.node_counter); + let candidate = CandidateRouteHop::FirstHop(CandidateFirstHop { + details, payer_node_id: &our_node_id, payer_node_counter, + target_node_counter: $node.node_counter, + }); + add_entry!(&candidate, fee_to_target_msat, + $next_hops_value_contribution, + next_hops_path_htlc_minimum_msat, next_hops_path_penalty_msat, + $next_hops_cltv_delta, $next_hops_path_length); + } } } @@ -2270,14 +2522,21 @@ where L::Target: Logger { if !features.requires_unknown_bits() { for chan_id in $node.channels.iter() { let chan = network_channels.get(chan_id).unwrap(); + // Calling chan.as_directed_to, below, will require access to memory two + // cache lines away from chan.features (in the form of `one_to_two` or + // `two_to_one`, depending on our direction). Thus, while we're looking at + // feature flags, go ahead and prefetch that memory, reducing the price we + // pay for it later. + prefetch_first_byte(&chan.one_to_two); + prefetch_first_byte(&chan.two_to_one); if !chan.features.requires_unknown_bits() { if let Some((directed_channel, source)) = chan.as_directed_to(&$node_id) { if first_hops.is_none() || *source != our_node_id { if directed_channel.direction().enabled { - let candidate = CandidateRouteHop::PublicHop { + let candidate = CandidateRouteHop::PublicHop(CandidatePublicHop { info: directed_channel, short_channel_id: *chan_id, - }; + }); add_entry!(&candidate, fee_to_target_msat, $next_hops_value_contribution, @@ -2301,16 +2560,47 @@ where L::Target: Logger { // For every new path, start from scratch, except for used_liquidities, which // helps to avoid reusing previously selected paths in future iterations. targets.clear(); - dist.clear(); + for e in dist.iter_mut() { + *e = None; + } + for (node_id, (chans, peer_node_counter)) in first_hop_targets.iter() { + // In order to avoid looking up whether each node is a first-hop target, we store a + // dummy entry in dist for each first-hop target, allowing us to do this lookup for + // free since we're already looking at the `was_processed` flag. + // + // Note that all the fields (except `is_first_hop_target`) will be overwritten whenever + // we find a path to the target, so are left as dummies here. + dist[*peer_node_counter as usize] = Some(PathBuildingHop { + candidate: CandidateRouteHop::FirstHop { + details: &chans[0], + payer_node_id: &our_node_id, + target_node_counter: u32::max_value(), + payer_node_counter: u32::max_value(), + }, + target_node_counter: None, + fee_msat: 0, + next_hops_fee_msat: u64::max_value(), + hop_use_fee_msat: u64::max_value(), + total_fee_msat: u64::max_value(), + path_htlc_minimum_msat: u64::max_value(), + path_penalty_msat: u64::max_value(), + was_processed: false, + is_first_hop_target: true, + #[cfg(all(not(ldk_bench), any(test, fuzzing)))] + value_contribution_msat: 0, + }); + } hit_minimum_limit = false; // If first hop is a private channel and the only way to reach the payee, this is the only // place where it could be added. - payee_node_id_opt.map(|payee| first_hop_targets.get(&payee).map(|first_channels| { + payee_node_id_opt.map(|payee| first_hop_targets.get(&payee).map(|(first_channels, peer_node_counter)| { + debug_assert_eq!(*peer_node_counter, payee_node_counter); for details in first_channels { - let candidate = CandidateRouteHop::FirstHop { - details, payer_node_id: &our_node_id, - }; + let candidate = CandidateRouteHop::FirstHop(CandidateFirstHop { + details, payer_node_id: &our_node_id, payer_node_counter, + target_node_counter: payee_node_counter, + }); let added = add_entry!(&candidate, 0, path_value_msat, 0, 0u64, 0, 0).is_some(); log_trace!(logger, "{} direct route to payee via {}", @@ -2337,29 +2627,42 @@ where L::Target: Logger { // it matters only if the fees are exactly the same. for (hint_idx, hint) in payment_params.payee.blinded_route_hints().iter().enumerate() { let intro_node_id = NodeId::from_pubkey(&hint.1.introduction_node_id); - let have_intro_node_in_graph = + let intro_node_counter_opt = // Only add the hops in this route to our candidate set if either // we have a direct channel to the first hop or the first hop is // in the regular network graph. - first_hop_targets.get(&intro_node_id).is_some() || - network_nodes.get(&intro_node_id).is_some(); - if !have_intro_node_in_graph || our_node_id == intro_node_id { continue } + network_nodes.get(&intro_node_id).map(|node| node.node_counter) + .or( + first_hop_targets.get(&intro_node_id).map(|(_, node_counter)| *node_counter) + ); + if intro_node_counter_opt.is_none() || our_node_id == intro_node_id { continue } let candidate = if hint.1.blinded_hops.len() == 1 { - CandidateRouteHop::OneHopBlinded { hint, hint_idx } - } else { CandidateRouteHop::Blinded { hint, hint_idx } }; + CandidateRouteHop::OneHopBlinded(CandidateOneHopBlindedPath { + hint, + hint_idx, + source_node_counter: intro_node_counter_opt.unwrap(), + }) + } else { + CandidateRouteHop::Blinded(CandidateBlindedPath { + hint, + hint_idx, + source_node_counter: intro_node_counter_opt.unwrap(), + }) + }; let mut path_contribution_msat = path_value_msat; if let Some(hop_used_msat) = add_entry!(&candidate, 0, path_contribution_msat, 0, 0_u64, 0, 0) { path_contribution_msat = hop_used_msat; } else { continue } - if let Some(first_channels) = first_hop_targets.get_mut(&NodeId::from_pubkey(&hint.1.introduction_node_id)) { + if let Some((first_channels, peer_node_counter)) = first_hop_targets.get_mut(&NodeId::from_pubkey(&hint.1.introduction_node_id)) { sort_first_hop_channels(first_channels, &used_liquidities, recommended_value_msat, our_node_pubkey); for details in first_channels { - let first_hop_candidate = CandidateRouteHop::FirstHop { - details, payer_node_id: &our_node_id, - }; + let first_hop_candidate = CandidateRouteHop::FirstHop(CandidateFirstHop { + details, payer_node_id: &our_node_id, payer_node_counter, + target_node_counter: *peer_node_counter, + }); let blinded_path_fee = match compute_fees(path_contribution_msat, candidate.fees()) { Some(fee) => fee, None => continue @@ -2398,9 +2701,10 @@ where L::Target: Logger { let mut aggregate_path_contribution_msat = path_value_msat; for (idx, (hop, prev_hop_id)) in hop_iter.zip(prev_hop_iter).enumerate() { - let target = private_hop_key_cache.get(&prev_hop_id).unwrap(); + let (target, private_target_node_counter) = private_hop_key_cache.get(&prev_hop_id).unwrap(); + let (_src_id, private_source_node_counter) = private_hop_key_cache.get(&hop.src_node_id).unwrap(); - if let Some(first_channels) = first_hop_targets.get(&target) { + if let Some((first_channels, _)) = first_hop_targets.get(&target) { if first_channels.iter().any(|d| d.outbound_scid_alias == Some(hop.short_channel_id)) { log_trace!(logger, "Ignoring route hint with SCID {} (and any previous) due to it being a direct channel of ours.", hop.short_channel_id); @@ -2411,11 +2715,15 @@ where L::Target: Logger { let candidate = network_channels .get(&hop.short_channel_id) .and_then(|channel| channel.as_directed_to(&target)) - .map(|(info, _)| CandidateRouteHop::PublicHop { + .map(|(info, _)| CandidateRouteHop::PublicHop(CandidatePublicHop { info, short_channel_id: hop.short_channel_id, }) - .unwrap_or_else(|| CandidateRouteHop::PrivateHop { hint: hop, target_node_id: target }); + .unwrap_or_else(|| CandidateRouteHop::PrivateHop(CandidatePrivateHop { + hint: hop, target_node_id: target, + source_node_counter: *private_source_node_counter, + target_node_counter: *private_target_node_counter, + })); if let Some(hop_used_msat) = add_entry!(&candidate, aggregate_next_hops_fee_msat, aggregate_path_contribution_msat, @@ -2451,13 +2759,14 @@ where L::Target: Logger { .saturating_add(1); // Searching for a direct channel between last checked hop and first_hop_targets - if let Some(first_channels) = first_hop_targets.get_mut(&target) { + if let Some((first_channels, peer_node_counter)) = first_hop_targets.get_mut(&target) { sort_first_hop_channels(first_channels, &used_liquidities, recommended_value_msat, our_node_pubkey); for details in first_channels { - let first_hop_candidate = CandidateRouteHop::FirstHop { - details, payer_node_id: &our_node_id, - }; + let first_hop_candidate = CandidateRouteHop::FirstHop(CandidateFirstHop { + details, payer_node_id: &our_node_id, payer_node_counter, + target_node_counter: *peer_node_counter, + }); add_entry!(&first_hop_candidate, aggregate_next_hops_fee_msat, aggregate_path_contribution_msat, aggregate_next_hops_path_htlc_minimum_msat, aggregate_next_hops_path_penalty_msat, @@ -2498,13 +2807,14 @@ where L::Target: Logger { // Note that we *must* check if the last hop was added as `add_entry` // always assumes that the third argument is a node to which we have a // path. - if let Some(first_channels) = first_hop_targets.get_mut(&NodeId::from_pubkey(&hop.src_node_id)) { + if let Some((first_channels, peer_node_counter)) = first_hop_targets.get_mut(&NodeId::from_pubkey(&hop.src_node_id)) { sort_first_hop_channels(first_channels, &used_liquidities, recommended_value_msat, our_node_pubkey); for details in first_channels { - let first_hop_candidate = CandidateRouteHop::FirstHop { - details, payer_node_id: &our_node_id, - }; + let first_hop_candidate = CandidateRouteHop::FirstHop(CandidateFirstHop { + details, payer_node_id: &our_node_id, payer_node_counter, + target_node_counter: *peer_node_counter, + }); add_entry!(&first_hop_candidate, aggregate_next_hops_fee_msat, aggregate_path_contribution_msat, @@ -2539,15 +2849,17 @@ where L::Target: Logger { // Since we're going payee-to-payer, hitting our node as a target means we should stop // traversing the graph and arrange the path out of what we found. if node_id == our_node_id { - let mut new_entry = dist.remove(&our_node_id).unwrap(); + let mut new_entry = dist[payer_node_counter as usize].take().unwrap(); let mut ordered_hops: Vec<(PathBuildingHop, NodeFeatures)> = vec!((new_entry.clone(), default_node_features.clone())); 'path_walk: loop { let mut features_set = false; - let target = ordered_hops.last().unwrap().0.candidate.target().unwrap_or(maybe_dummy_payee_node_id); - if let Some(first_channels) = first_hop_targets.get(&target) { + let candidate = &ordered_hops.last().unwrap().0.candidate; + let target = candidate.target().unwrap_or(maybe_dummy_payee_node_id); + let target_node_counter = candidate.target_node_counter(); + if let Some((first_channels, _)) = first_hop_targets.get(&target) { for details in first_channels { - if let CandidateRouteHop::FirstHop { details: last_hop_details, .. } + if let CandidateRouteHop::FirstHop(CandidateFirstHop { details: last_hop_details, .. }) = ordered_hops.last().unwrap().0.candidate { if details.get_outbound_payment_scid() == last_hop_details.get_outbound_payment_scid() { @@ -2576,11 +2888,12 @@ where L::Target: Logger { // save this path for the payment route. Also, update the liquidity // remaining on the used hops, so that we take them into account // while looking for more paths. - if target == maybe_dummy_payee_node_id { + if target_node_counter.is_none() { break 'path_walk; } + if target_node_counter == Some(payee_node_counter) { break 'path_walk; } - new_entry = match dist.remove(&target) { + new_entry = match dist[target_node_counter.unwrap() as usize].take() { Some(payment_hop) => payment_hop, // We can't arrive at None because, if we ever add an entry to targets, // we also fill in the entry in dist (see add_entry!). @@ -2814,12 +3127,12 @@ where L::Target: Logger { .filter(|(h, _)| h.candidate.short_channel_id().is_some()) { let target = hop.candidate.target().expect("target is defined when short_channel_id is defined"); - let maybe_announced_channel = if let CandidateRouteHop::PublicHop { .. } = hop.candidate { + let maybe_announced_channel = if let CandidateRouteHop::PublicHop(_) = hop.candidate { // If we sourced the hop from the graph we're sure the target node is announced. true - } else if let CandidateRouteHop::FirstHop { details, .. } = hop.candidate { + } else if let CandidateRouteHop::FirstHop(first_hop) = &hop.candidate { // If this is a first hop we also know if it's announced. - details.is_public + first_hop.details.is_public } else { // If we sourced it any other way, we double-check the network graph to see if // there are announced channels between the endpoints. If so, the hop might be @@ -3049,7 +3362,7 @@ mod tests { use crate::routing::utxo::UtxoResult; use crate::routing::router::{get_route, build_route_from_hops_internal, add_random_cltv_offset, default_node_features, BlindedTail, InFlightHtlcs, Path, PaymentParameters, Route, RouteHint, RouteHintHop, RouteHop, RoutingFees, - DEFAULT_MAX_TOTAL_CLTV_EXPIRY_DELTA, MAX_PATH_LENGTH_ESTIMATE, RouteParameters, CandidateRouteHop}; + DEFAULT_MAX_TOTAL_CLTV_EXPIRY_DELTA, MAX_PATH_LENGTH_ESTIMATE, RouteParameters, CandidateRouteHop, CandidatePublicHop}; use crate::routing::scoring::{ChannelUsage, FixedPenaltyScorer, ScoreLookUp, ProbabilisticScorer, ProbabilisticScoringFeeParameters, ProbabilisticScoringDecayParameters}; use crate::routing::test_utils::{add_channel, add_or_update_node, build_graph, build_line_graph, id_to_feature_flags, get_nodes, update_channel}; use crate::chain::transaction::OutPoint; @@ -6780,11 +7093,11 @@ mod tests { #[test] #[cfg(not(feature = "no-std"))] fn generate_routes() { - use crate::routing::scoring::{ProbabilisticScorer, ProbabilisticScoringFeeParameters}; + use crate::routing::scoring::ProbabilisticScoringFeeParameters; let logger = ln_test_utils::TestLogger::new(); - let graph = match super::bench_utils::read_network_graph(&logger) { - Ok(f) => f, + let (graph, mut scorer) = match super::bench_utils::read_graph_scorer(&logger) { + Ok(res) => res, Err(e) => { eprintln!("{}", e); return; @@ -6792,7 +7105,6 @@ mod tests { }; let params = ProbabilisticScoringFeeParameters::default(); - let mut scorer = ProbabilisticScorer::new(ProbabilisticScoringDecayParameters::default(), &graph, &logger); let features = super::Bolt11InvoiceFeatures::empty(); super::bench_utils::generate_test_routes(&graph, &mut scorer, ¶ms, features, random_init_seed(), 0, 2); @@ -6801,11 +7113,11 @@ mod tests { #[test] #[cfg(not(feature = "no-std"))] fn generate_routes_mpp() { - use crate::routing::scoring::{ProbabilisticScorer, ProbabilisticScoringFeeParameters}; + use crate::routing::scoring::ProbabilisticScoringFeeParameters; let logger = ln_test_utils::TestLogger::new(); - let graph = match super::bench_utils::read_network_graph(&logger) { - Ok(f) => f, + let (graph, mut scorer) = match super::bench_utils::read_graph_scorer(&logger) { + Ok(res) => res, Err(e) => { eprintln!("{}", e); return; @@ -6813,7 +7125,6 @@ mod tests { }; let params = ProbabilisticScoringFeeParameters::default(); - let mut scorer = ProbabilisticScorer::new(ProbabilisticScoringDecayParameters::default(), &graph, &logger); let features = channelmanager::provided_bolt11_invoice_features(&UserConfig::default()); super::bench_utils::generate_test_routes(&graph, &mut scorer, ¶ms, features, random_init_seed(), 0, 2); @@ -6825,8 +7136,8 @@ mod tests { use crate::routing::scoring::{ProbabilisticScorer, ProbabilisticScoringFeeParameters}; let logger = ln_test_utils::TestLogger::new(); - let graph = match super::bench_utils::read_network_graph(&logger) { - Ok(f) => f, + let (graph, mut scorer) = match super::bench_utils::read_graph_scorer(&logger) { + Ok(res) => res, Err(e) => { eprintln!("{}", e); return; @@ -6834,7 +7145,7 @@ mod tests { }; let params = ProbabilisticScoringFeeParameters::default(); - let mut scorer = ProbabilisticScorer::new(ProbabilisticScoringDecayParameters::default(), &graph, &logger); + let mut scorer = ProbabilisticScorer::new(ProbabilisticScoringDecayParameters::default(), &*graph, &logger); let features = channelmanager::provided_bolt11_invoice_features(&UserConfig::default()); super::bench_utils::generate_test_routes(&graph, &mut scorer, ¶ms, features, random_init_seed(), 1_000_000, 2); @@ -6863,10 +7174,10 @@ mod tests { let channels = network_graph.channels(); let channel = channels.get(&5).unwrap(); let info = channel.as_directed_from(&NodeId::from_pubkey(&nodes[3])).unwrap(); - let candidate: CandidateRouteHop = CandidateRouteHop::PublicHop { + let candidate: CandidateRouteHop = CandidateRouteHop::PublicHop(CandidatePublicHop { info: info.0, short_channel_id: 5, - }; + }); assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &scorer_params), 456); // Then check we can get a normal route @@ -8160,7 +8471,6 @@ mod tests { pub(crate) mod bench_utils { use super::*; use std::fs::File; - use std::time::Duration; use bitcoin::hashes::Hash; use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey}; @@ -8172,46 +8482,63 @@ pub(crate) mod bench_utils { use crate::ln::channelmanager::{self, ChannelCounterparty, ChannelDetails}; use crate::ln::features::Bolt11InvoiceFeatures; use crate::routing::gossip::NetworkGraph; + use crate::routing::scoring::ProbabilisticScorer; use crate::util::config::UserConfig; use crate::util::ser::ReadableArgs; use crate::util::test_utils::TestLogger; + use crate::sync::Arc; /// Tries to open a network graph file, or panics with a URL to fetch it. - pub(crate) fn get_route_file() -> Result { - let res = File::open("net_graph-2023-01-18.bin") // By default we're run in RL/lightning - .or_else(|_| File::open("lightning/net_graph-2023-01-18.bin")) // We may be run manually in RL/ - .or_else(|_| { // Fall back to guessing based on the binary location - // path is likely something like .../rust-lightning/target/debug/deps/lightning-... - let mut path = std::env::current_exe().unwrap(); - path.pop(); // lightning-... - path.pop(); // deps - path.pop(); // debug - path.pop(); // target - path.push("lightning"); - path.push("net_graph-2023-01-18.bin"); - File::open(path) - }) - .or_else(|_| { // Fall back to guessing based on the binary location for a subcrate - // path is likely something like .../rust-lightning/bench/target/debug/deps/bench.. - let mut path = std::env::current_exe().unwrap(); - path.pop(); // bench... - path.pop(); // deps - path.pop(); // debug - path.pop(); // target - path.pop(); // bench - path.push("lightning"); - path.push("net_graph-2023-01-18.bin"); - File::open(path) - }) - .map_err(|_| "Please fetch https://bitcoin.ninja/ldk-net_graph-v0.0.113-2023-01-18.bin and place it at lightning/net_graph-2023-01-18.bin"); + pub(crate) fn get_graph_scorer_file() -> Result<(std::fs::File, std::fs::File), &'static str> { + let load_file = |fname, err_str| { + File::open(fname) // By default we're run in RL/lightning + .or_else(|_| File::open(&format!("lightning/{}", fname))) // We may be run manually in RL/ + .or_else(|_| { // Fall back to guessing based on the binary location + // path is likely something like .../rust-lightning/target/debug/deps/lightning-... + let mut path = std::env::current_exe().unwrap(); + path.pop(); // lightning-... + path.pop(); // deps + path.pop(); // debug + path.pop(); // target + path.push("lightning"); + path.push(fname); + File::open(path) + }) + .or_else(|_| { // Fall back to guessing based on the binary location for a subcrate + // path is likely something like .../rust-lightning/bench/target/debug/deps/bench.. + let mut path = std::env::current_exe().unwrap(); + path.pop(); // bench... + path.pop(); // deps + path.pop(); // debug + path.pop(); // target + path.pop(); // bench + path.push("lightning"); + path.push(fname); + File::open(path) + }) + .map_err(|_| err_str) + }; + let graph_res = load_file( + "net_graph-2023-12-10.bin", + "Please fetch https://bitcoin.ninja/ldk-net_graph-v0.0.118-2023-12-10.bin and place it at lightning/net_graph-2023-12-10.bin" + ); + let scorer_res = load_file( + "scorer-2023-12-10.bin", + "Please fetch https://bitcoin.ninja/ldk-scorer-v0.0.118-2023-12-10.bin and place it at scorer-2023-12-10.bin" + ); #[cfg(require_route_graph_test)] - return Ok(res.unwrap()); + return Ok((graph_res.unwrap(), scorer_res.unwrap())); #[cfg(not(require_route_graph_test))] - return res; + return Ok((graph_res?, scorer_res?)); } - pub(crate) fn read_network_graph(logger: &TestLogger) -> Result, &'static str> { - get_route_file().map(|mut f| NetworkGraph::read(&mut f, logger).unwrap()) + pub(crate) fn read_graph_scorer(logger: &TestLogger) + -> Result<(Arc>, ProbabilisticScorer>, &TestLogger>), &'static str> { + let (mut graph_file, mut scorer_file) = get_graph_scorer_file()?; + let graph = Arc::new(NetworkGraph::read(&mut graph_file, logger).unwrap()); + let scorer_args = (Default::default(), Arc::clone(&graph), logger); + let scorer = ProbabilisticScorer::read(&mut scorer_file, scorer_args).unwrap(); + Ok((graph, scorer)) } pub(crate) fn payer_pubkey() -> PublicKey { @@ -8271,9 +8598,7 @@ pub(crate) mod bench_utils { let nodes = graph.read_only().nodes().clone(); let mut route_endpoints = Vec::new(); - // Fetch 1.5x more routes than we need as after we do some scorer updates we may end up - // with some routes we picked being un-routable. - for _ in 0..route_count * 3 / 2 { + for _ in 0..route_count { loop { seed = seed.overflowing_mul(6364136223846793005).0.overflowing_add(1).0; let src = PublicKey::from_slice(nodes.unordered_keys() @@ -8291,37 +8616,6 @@ pub(crate) mod bench_utils { get_route(&payer, &route_params, &graph.read_only(), Some(&[&first_hop]), &TestLogger::new(), scorer, score_params, &random_seed_bytes).is_ok(); if path_exists { - // ...and seed the scorer with success and failure data... - seed = seed.overflowing_mul(6364136223846793005).0.overflowing_add(1).0; - let mut score_amt = seed % 1_000_000_000; - loop { - // Generate fail/success paths for a wider range of potential amounts with - // MPP enabled to give us a chance to apply penalties for more potential - // routes. - let mpp_features = channelmanager::provided_bolt11_invoice_features(&UserConfig::default()); - let params = PaymentParameters::from_node_id(dst, 42) - .with_bolt11_features(mpp_features).unwrap(); - let route_params = RouteParameters::from_payment_params_and_value( - params.clone(), score_amt); - let route_res = get_route(&payer, &route_params, &graph.read_only(), - Some(&[&first_hop]), &TestLogger::new(), scorer, score_params, - &random_seed_bytes); - if let Ok(route) = route_res { - for path in route.paths { - if seed & 0x80 == 0 { - scorer.payment_path_successful(&path, Duration::ZERO); - } else { - let short_channel_id = path.hops[path.hops.len() / 2].short_channel_id; - scorer.payment_path_failed(&path, short_channel_id, Duration::ZERO); - } - seed = seed.overflowing_mul(6364136223846793005).0.overflowing_add(1).0; - } - break; - } - // If we couldn't find a path with a higer amount, reduce and try again. - score_amt /= 100; - } - route_endpoints.push((first_hop, params, amt_msat)); break; } @@ -8351,7 +8645,7 @@ pub mod benches { use crate::ln::channelmanager; use crate::ln::features::Bolt11InvoiceFeatures; use crate::routing::gossip::NetworkGraph; - use crate::routing::scoring::{FixedPenaltyScorer, ProbabilisticScorer, ProbabilisticScoringFeeParameters, ProbabilisticScoringDecayParameters}; + use crate::routing::scoring::{FixedPenaltyScorer, ProbabilisticScoringFeeParameters}; use crate::util::config::UserConfig; use crate::util::logger::{Logger, Record}; use crate::util::test_utils::TestLogger; @@ -8365,7 +8659,7 @@ pub mod benches { pub fn generate_routes_with_zero_penalty_scorer(bench: &mut Criterion) { let logger = TestLogger::new(); - let network_graph = bench_utils::read_network_graph(&logger).unwrap(); + let (network_graph, _) = bench_utils::read_graph_scorer(&logger).unwrap(); let scorer = FixedPenaltyScorer::with_penalty(0); generate_routes(bench, &network_graph, scorer, &Default::default(), Bolt11InvoiceFeatures::empty(), 0, "generate_routes_with_zero_penalty_scorer"); @@ -8373,7 +8667,7 @@ pub mod benches { pub fn generate_mpp_routes_with_zero_penalty_scorer(bench: &mut Criterion) { let logger = TestLogger::new(); - let network_graph = bench_utils::read_network_graph(&logger).unwrap(); + let (network_graph, _) = bench_utils::read_graph_scorer(&logger).unwrap(); let scorer = FixedPenaltyScorer::with_penalty(0); generate_routes(bench, &network_graph, scorer, &Default::default(), channelmanager::provided_bolt11_invoice_features(&UserConfig::default()), 0, @@ -8382,18 +8676,16 @@ pub mod benches { pub fn generate_routes_with_probabilistic_scorer(bench: &mut Criterion) { let logger = TestLogger::new(); - let network_graph = bench_utils::read_network_graph(&logger).unwrap(); + let (network_graph, scorer) = bench_utils::read_graph_scorer(&logger).unwrap(); let params = ProbabilisticScoringFeeParameters::default(); - let scorer = ProbabilisticScorer::new(ProbabilisticScoringDecayParameters::default(), &network_graph, &logger); generate_routes(bench, &network_graph, scorer, ¶ms, Bolt11InvoiceFeatures::empty(), 0, "generate_routes_with_probabilistic_scorer"); } pub fn generate_mpp_routes_with_probabilistic_scorer(bench: &mut Criterion) { let logger = TestLogger::new(); - let network_graph = bench_utils::read_network_graph(&logger).unwrap(); + let (network_graph, scorer) = bench_utils::read_graph_scorer(&logger).unwrap(); let params = ProbabilisticScoringFeeParameters::default(); - let scorer = ProbabilisticScorer::new(ProbabilisticScoringDecayParameters::default(), &network_graph, &logger); generate_routes(bench, &network_graph, scorer, ¶ms, channelmanager::provided_bolt11_invoice_features(&UserConfig::default()), 0, "generate_mpp_routes_with_probabilistic_scorer"); @@ -8401,9 +8693,8 @@ pub mod benches { pub fn generate_large_mpp_routes_with_probabilistic_scorer(bench: &mut Criterion) { let logger = TestLogger::new(); - let network_graph = bench_utils::read_network_graph(&logger).unwrap(); + let (network_graph, scorer) = bench_utils::read_graph_scorer(&logger).unwrap(); let params = ProbabilisticScoringFeeParameters::default(); - let scorer = ProbabilisticScorer::new(ProbabilisticScoringDecayParameters::default(), &network_graph, &logger); generate_routes(bench, &network_graph, scorer, ¶ms, channelmanager::provided_bolt11_invoice_features(&UserConfig::default()), 100_000_000, "generate_large_mpp_routes_with_probabilistic_scorer"); @@ -8411,11 +8702,9 @@ pub mod benches { pub fn generate_routes_with_nonlinear_probabilistic_scorer(bench: &mut Criterion) { let logger = TestLogger::new(); - let network_graph = bench_utils::read_network_graph(&logger).unwrap(); + let (network_graph, scorer) = bench_utils::read_graph_scorer(&logger).unwrap(); let mut params = ProbabilisticScoringFeeParameters::default(); params.linear_success_probability = false; - let scorer = ProbabilisticScorer::new( - ProbabilisticScoringDecayParameters::default(), &network_graph, &logger); generate_routes(bench, &network_graph, scorer, ¶ms, channelmanager::provided_bolt11_invoice_features(&UserConfig::default()), 0, "generate_routes_with_nonlinear_probabilistic_scorer"); @@ -8423,11 +8712,9 @@ pub mod benches { pub fn generate_mpp_routes_with_nonlinear_probabilistic_scorer(bench: &mut Criterion) { let logger = TestLogger::new(); - let network_graph = bench_utils::read_network_graph(&logger).unwrap(); + let (network_graph, scorer) = bench_utils::read_graph_scorer(&logger).unwrap(); let mut params = ProbabilisticScoringFeeParameters::default(); params.linear_success_probability = false; - let scorer = ProbabilisticScorer::new( - ProbabilisticScoringDecayParameters::default(), &network_graph, &logger); generate_routes(bench, &network_graph, scorer, ¶ms, channelmanager::provided_bolt11_invoice_features(&UserConfig::default()), 0, "generate_mpp_routes_with_nonlinear_probabilistic_scorer"); @@ -8435,11 +8722,9 @@ pub mod benches { pub fn generate_large_mpp_routes_with_nonlinear_probabilistic_scorer(bench: &mut Criterion) { let logger = TestLogger::new(); - let network_graph = bench_utils::read_network_graph(&logger).unwrap(); + let (network_graph, scorer) = bench_utils::read_graph_scorer(&logger).unwrap(); let mut params = ProbabilisticScoringFeeParameters::default(); params.linear_success_probability = false; - let scorer = ProbabilisticScorer::new( - ProbabilisticScoringDecayParameters::default(), &network_graph, &logger); generate_routes(bench, &network_graph, scorer, ¶ms, channelmanager::provided_bolt11_invoice_features(&UserConfig::default()), 100_000_000, "generate_large_mpp_routes_with_nonlinear_probabilistic_scorer"); @@ -8450,14 +8735,23 @@ pub mod benches { score_params: &S::ScoreParams, features: Bolt11InvoiceFeatures, starting_amount: u64, bench_name: &'static str, ) { - let payer = bench_utils::payer_pubkey(); - let keys_manager = KeysManager::new(&[0u8; 32], 42, 42); - let random_seed_bytes = keys_manager.get_secure_random_bytes(); - // First, get 100 (source, destination) pairs for which route-getting actually succeeds... let route_endpoints = bench_utils::generate_test_routes(graph, &mut scorer, score_params, features, 0xdeadbeef, starting_amount, 50); // ...then benchmark finding paths between the nodes we learned. + do_route_bench(bench, graph, scorer, score_params, bench_name, route_endpoints); + } + + #[inline(never)] + fn do_route_bench( + bench: &mut Criterion, graph: &NetworkGraph<&TestLogger>, scorer: S, + score_params: &S::ScoreParams, bench_name: &'static str, + route_endpoints: Vec<(ChannelDetails, PaymentParameters, u64)>, + ) { + let payer = bench_utils::payer_pubkey(); + let keys_manager = KeysManager::new(&[0u8; 32], 42, 42); + let random_seed_bytes = keys_manager.get_secure_random_bytes(); + let mut idx = 0; bench.bench_function(bench_name, |b| b.iter(|| { let (first_hop, params, amt) = &route_endpoints[idx % route_endpoints.len()];