X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Frouting%2Frouter.rs;h=7f11f31983c5636774dbed527275294b88482703;hb=b530cdc25227acf512b6cf32ac4fcf815c67dff9;hp=92c657c5515ed957d327c89997d59312c14d21e7;hpb=d67385f348bf1dd26a7c21cd8d860dab43572771;p=rust-lightning diff --git a/lightning/src/routing/router.rs b/lightning/src/routing/router.rs index 92c657c55..7f11f3198 100644 --- a/lightning/src/routing/router.rs +++ b/lightning/src/routing/router.rs @@ -1174,7 +1174,7 @@ impl<'a> CandidateRouteHop<'a> { } } - #[inline] + #[inline(always)] fn src_node_counter(&self) -> u32 { match self { CandidateRouteHop::FirstHop { payer_node_counter, .. } => *payer_node_counter, @@ -1260,7 +1260,7 @@ impl<'a> CandidateRouteHop<'a> { /// Source node id refers to the node forwarding the HTLC through this hop. /// /// For [`Self::FirstHop`] we return payer's node id. - #[inline] + #[inline(always)] pub fn source(&self) -> NodeId { match self { CandidateRouteHop::FirstHop { payer_node_id, .. } => **payer_node_id, @@ -1279,7 +1279,7 @@ impl<'a> CandidateRouteHop<'a> { /// /// For [`Self::OneHopBlinded`] we return `None` because the target is the same as the source, /// and such a return value would be somewhat nonsensical. - #[inline] + #[inline(always)] pub fn target(&self) -> Option { match self { CandidateRouteHop::FirstHop { details, .. } => Some(details.counterparty.node_id.into()), @@ -1336,6 +1336,34 @@ 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. @@ -1988,6 +2016,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| { @@ -2010,7 +2040,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); @@ -2020,7 +2050,6 @@ where L::Target: Logger { // Can't overflow due to how the values were computed right above. None => unreachable!(), }; - let htlc_minimum_msat = $candidate.htlc_minimum_msat(); #[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 >= htlc_minimum_msat && amount_to_transfer_over_msat >= $next_hops_path_htlc_minimum_msat; @@ -2103,12 +2132,14 @@ 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 dist_entry = &mut dist[$candidate.src_node_counter() as usize]; + let dist_entry = &mut dist[src_node_counter as usize]; let old_entry = if let Some(hop) = dist_entry { hop } else { @@ -2152,7 +2183,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); } @@ -2340,6 +2371,13 @@ 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 { @@ -6904,11 +6942,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; @@ -6916,7 +6954,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); @@ -6925,11 +6962,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; @@ -6937,7 +6974,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); @@ -6949,8 +6985,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; @@ -6958,7 +6994,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); @@ -8284,7 +8320,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}; @@ -8296,46 +8331,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 { @@ -8395,9 +8447,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() @@ -8415,37 +8465,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; } @@ -8475,7 +8494,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; @@ -8489,7 +8508,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"); @@ -8497,7 +8516,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, @@ -8506,18 +8525,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"); @@ -8525,9 +8542,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"); @@ -8535,11 +8551,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"); @@ -8547,11 +8561,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"); @@ -8559,11 +8571,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"); @@ -8574,14 +8584,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()];