Benchmark onion message pathfinding

Author: valentinewallace

lightning/src/routing/onion_message.rs

@@ -183,3 +183,71 @@ 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::test_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 = test_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 first_hop = PublicKey::from_slice(nodes.keys().skip(seed % nodes.len()).next().unwrap().as_slice()).unwrap();
+				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;
+		});
+	}
+}