Benchmark onion message pathfinding

Author: valentinewallace

lightning/src/routing/onion_message.rs

@@ -186,3 +186,72 @@ mod tests {
 		assert_eq!(path.len(), 19);
 	}
 }
+
+#[cfg(all(test, feature = "_bench_unstable", not(feature = "no-std")))]
+mod benches {
+	use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey};
+	use routing::gossip::NetworkGraph;
+	use routing::router::bench_utils;
+	use super::find_path;
+	use test::Bencher;
+	use util::logger::{Logger, Record};
+	use util::ser::ReadableArgs;
+
+	struct DummyLogger {}
+	impl Logger for DummyLogger {
+		fn log(&self, _record: &Record) {}
+	}
+
+	fn read_network_graph(logger: &DummyLogger) -> NetworkGraph<&DummyLogger> {
+		let mut d = bench_utils::get_route_file().unwrap();
+		NetworkGraph::read(&mut d, logger).unwrap()
+	}
+
+	#[bench]
+	fn generate_simple_routes(bench: &mut Bencher) {
+		let logger = DummyLogger {};
+		let network_graph = read_network_graph(&logger);
+		generate_routes(bench, &network_graph);
+	}
+
+	fn payer_pubkey() -> PublicKey {
+		let secp_ctx = Secp256k1::new();
+		PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap())
+	}
+
+	fn generate_routes(
+		bench: &mut Bencher, graph: &NetworkGraph<&DummyLogger>,
+	) {
+		let nodes = graph.read_only().nodes().clone();
+		let payer = payer_pubkey();
+
+		// Get 100 (source, destination) pairs for which route-getting actually succeeds...
+		let mut routes = Vec::new();
+		let mut route_endpoints = Vec::new();
+		let mut seed: usize = 0xdeadbeef;
+		'load_endpoints: for _ in 0..150 {
+			loop {
+				seed *= 0xdeadbeef;
+				let src = PublicKey::from_slice(nodes.keys().skip(seed % nodes.len()).next().unwrap().as_slice()).unwrap();
+				let first_hop = bench_utils::first_hop(src);
+				seed *= 0xdeadbeef;
+				let dst = PublicKey::from_slice(nodes.keys().skip(seed % nodes.len()).next().unwrap().as_slice()).unwrap();
+				if let Ok(route) = find_path(&payer, &dst, &graph, Some(&[&first_hop]), &DummyLogger{}) {
+					routes.push(route);
+					route_endpoints.push((first_hop, dst));
+					continue 'load_endpoints;
+				}
+			}
+		}
+		route_endpoints.truncate(100);
+		assert_eq!(route_endpoints.len(), 100);
+
+		// Benchmark finding paths between the nodes we learned.
+		let mut idx = 0;
+		bench.iter(|| {
+			let (first_hop, dst) = &route_endpoints[idx % route_endpoints.len()];
+			assert!(find_path(&payer, &dst, &graph, Some(&[first_hop]), &DummyLogger{}).is_ok());
+			idx += 1;
+		});
+	}
+}

lightning/src/routing/router.rs

@@ -5388,6 +5388,7 @@ mod tests {
 #[cfg(all(test, not(feature = "no-std")))]
 pub(crate) mod bench_utils {
 	use std::fs::File;
+
 	/// Tries to open a network graph file, or panics with a URL to fetch it.
 	pub(crate) fn get_route_file() -> Result<std::fs::File, &'static str> {
 		let res = File::open("net_graph-2021-05-31.bin") // By default we're run in RL/lightning
@@ -5410,41 +5411,15 @@ pub(crate) mod bench_utils {
 		#[cfg(not(require_route_graph_test))]
 		return res;
 	}
-}
-
-#[cfg(all(test, feature = "_bench_unstable", not(feature = "no-std")))]
-mod benches {
-	use super::*;
-	use bitcoin::hashes::Hash;
-	use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey};
-	use chain::transaction::OutPoint;
-	use chain::keysinterface::{KeysManager,KeysInterface};
-	use ln::channelmanager::{self, ChannelCounterparty, ChannelDetails};
-	use ln::features::{InitFeatures, InvoiceFeatures};
-	use routing::gossip::NetworkGraph;
-	use routing::scoring::{FixedPenaltyScorer, ProbabilisticScorer, ProbabilisticScoringParameters};
-	use util::logger::{Logger, Record};
-	use util::ser::ReadableArgs;
-
-	use test::Bencher;
-
-	struct DummyLogger {}
-	impl Logger for DummyLogger {
-		fn log(&self, _record: &Record) {}
-	}
-
-	fn read_network_graph(logger: &DummyLogger) -> NetworkGraph<&DummyLogger> {
-		let mut d = bench_utils::get_route_file().unwrap();
-		NetworkGraph::read(&mut d, logger).unwrap()
-	}
-
-	fn payer_pubkey() -> PublicKey {
-		let secp_ctx = Secp256k1::new();
-		PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap())
-	}
 
 	#[inline]
-	fn first_hop(node_id: PublicKey) -> ChannelDetails {
+	#[cfg(all(test, feature = "_bench_unstable", not(feature = "no-std")))]
+	pub(crate) fn first_hop(node_id: PublicKey) -> ChannelDetails {
+		use bitcoin::hashes::Hash;
+		use bitcoin::secp256k1::PublicKey;
+		use chain::transaction::OutPoint;
+		use ln::channelmanager::{self, ChannelCounterparty, ChannelDetails};
+
 		ChannelDetails {
 			channel_id: [0; 32],
 			counterparty: ChannelCounterparty {
@@ -5480,6 +5455,36 @@ mod benches {
 			config: None,
 		}
 	}
+}
+
+#[cfg(all(test, feature = "_bench_unstable", not(feature = "no-std")))]
+mod benches {
+	use super::*;
+	use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey};
+	use chain::keysinterface::{KeysManager,KeysInterface};
+	use ln::channelmanager;
+	use ln::features::InvoiceFeatures;
+	use routing::gossip::NetworkGraph;
+	use routing::scoring::{FixedPenaltyScorer, ProbabilisticScorer, ProbabilisticScoringParameters};
+	use util::logger::{Logger, Record};
+	use util::ser::ReadableArgs;
+
+	use test::Bencher;
+
+	struct DummyLogger {}
+	impl Logger for DummyLogger {
+		fn log(&self, _record: &Record) {}
+	}
+
+	fn read_network_graph(logger: &DummyLogger) -> NetworkGraph<&DummyLogger> {
+		let mut d = bench_utils::get_route_file().unwrap();
+		NetworkGraph::read(&mut d, logger).unwrap()
+	}
+
+	fn payer_pubkey() -> PublicKey {
+		let secp_ctx = Secp256k1::new();
+		PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap())
+	}
 
 	#[bench]
 	fn generate_routes_with_zero_penalty_scorer(bench: &mut Bencher) {
@@ -5535,7 +5540,7 @@ mod benches {
 				seed *= 0xdeadbeef;
 				let dst = PublicKey::from_slice(nodes.keys().skip(seed % nodes.len()).next().unwrap().as_slice()).unwrap();
 				let params = PaymentParameters::from_node_id(dst).with_features(features.clone());
-				let first_hop = first_hop(src);
+				let first_hop = bench_utils::first_hop(src);
 				let amt = seed as u64 % 1_000_000;
 				if let Ok(route) = get_route(&payer, &params, &graph.read_only(), Some(&[&first_hop]), amt, 42, &DummyLogger{}, &scorer, &random_seed_bytes) {
 					routes.push(route);