Benchmark payments across stores

Run the existing payments benchmark once per configured store backend so
filesystem, SQLite, and optional PostgreSQL results are reported under the
same payment flow.

AI-assisted-by: OpenAI Codex

Author: benthecarman

benches/payments.rs

@@ -8,7 +8,8 @@ use bitcoin::hex::DisplayHex;
 use bitcoin::Amount;
 use common::{
 	expect_channel_ready_event, generate_blocks_and_wait, premine_and_distribute_funds,
-	random_chain_source, setup_bitcoind_and_electrsd, setup_two_nodes_with_store,
+	setup_bitcoind_and_electrsd, setup_two_nodes_with_store, store_bench_configs,
+	wait_for_payment_success, TestChainSource,
 };
 use criterion::{criterion_group, criterion_main, Criterion};
 use ldk_node::{Event, Node};
@@ -102,7 +103,7 @@ async fn send_payments(node_a: Arc<Node>, node_b: Arc<Node>) -> std::time::Durat
 	// Send back the money for the next iteration.
 	let mut preimage_bytes = [0u8; 32];
 	rand::rng().fill_bytes(&mut preimage_bytes);
-	node_b
+	let return_payment_id = node_b
 		.spontaneous_payment()
 		.send_with_preimage(
 			amount_msat * total_payments,
@@ -112,78 +113,92 @@ async fn send_payments(node_a: Arc<Node>, node_b: Arc<Node>) -> std::time::Durat
 		)
 		.ok()
 		.unwrap();
+	wait_for_payment_success(&node_b, return_payment_id).await;
 
 	duration
 }
 
 fn payment_benchmark(c: &mut Criterion) {
 	// Set up two nodes. Because this is slow, we reuse the same nodes for each sample.
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
-	let chain_source = random_chain_source(&bitcoind, &electrsd);
-
-	let (node_a, node_b) =
-		setup_two_nodes_with_store(&chain_source, false, false, common::TestStoreType::Sqlite);
-
-	let runtime =
-		tokio::runtime::Builder::new_multi_thread().worker_threads(4).enable_all().build().unwrap();
-
-	let node_a = Arc::new(node_a);
-	let node_b = Arc::new(node_b);
-
-	// Fund the nodes and setup a channel between them. The criterion function cannot be async, so we need to execute
-	// the setup using a runtime.
-	let node_a_cloned = Arc::clone(&node_a);
-	let node_b_cloned = Arc::clone(&node_b);
-	runtime.block_on(async move {
-		let address_a = node_a_cloned.onchain_payment().new_address().unwrap();
-		let premine_sat = 25_000_000;
-		premine_and_distribute_funds(
-			&bitcoind.client,
-			&electrsd.client,
-			vec![address_a],
-			Amount::from_sat(premine_sat),
-		)
-		.await;
-		node_a_cloned.sync_wallets().unwrap();
-		node_b_cloned.sync_wallets().unwrap();
-		open_channel_push_amt(
-			&node_a_cloned,
-			&node_b_cloned,
-			16_000_000,
-			Some(1_000_000_000),
-			false,
-			&electrsd,
-		)
-		.await;
-		generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 6).await;
-		node_a_cloned.sync_wallets().unwrap();
-		node_b_cloned.sync_wallets().unwrap();
-		expect_channel_ready_event!(node_a_cloned, node_b_cloned.node_id());
-		expect_channel_ready_event!(node_b_cloned, node_a_cloned.node_id());
-	});
+	let chain_source = TestChainSource::BitcoindRpcSync(&bitcoind);
+
+	let store_configs = store_bench_configs();
+
+	let runtime = benchmark_runtime();
 
 	let mut group = c.benchmark_group("payments");
 	group.sample_size(10);
 
-	group.bench_function("payments", |b| {
-		// Use custom timing so that sending back the money at the end of each iteration isn't included in the
-		// measurement.
-		b.to_async(&runtime).iter_custom(|iter| {
+	for store_config in store_configs {
+		let (node_a, node_b) =
+			setup_two_nodes_with_store(&chain_source, false, false, store_config.store_type);
+
+		let node_a = Arc::new(node_a);
+		let node_b = Arc::new(node_b);
+
+		// Fund the nodes and setup a channel between them. The criterion function cannot be async,
+		// so we need to execute the setup using a runtime.
+		let node_a_cloned = Arc::clone(&node_a);
+		let node_b_cloned = Arc::clone(&node_b);
+		runtime.block_on(async {
+			let address_a = node_a_cloned.onchain_payment().new_address().unwrap();
+			let premine_sat = 25_000_000;
+			premine_and_distribute_funds(
+				&bitcoind.client,
+				&electrsd.client,
+				vec![address_a],
+				Amount::from_sat(premine_sat),
+			)
+			.await;
+			node_a_cloned.sync_wallets().unwrap();
+			node_b_cloned.sync_wallets().unwrap();
+			open_channel_push_amt(
+				&node_a_cloned,
+				&node_b_cloned,
+				16_000_000,
+				Some(1_000_000_000),
+				false,
+				&electrsd,
+			)
+			.await;
+			generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 6).await;
+			node_a_cloned.sync_wallets().unwrap();
+			node_b_cloned.sync_wallets().unwrap();
+			expect_channel_ready_event!(node_a_cloned, node_b_cloned.node_id());
+			expect_channel_ready_event!(node_b_cloned, node_a_cloned.node_id());
+		});
+
+		group.bench_function(store_config.name, |b| {
+			// Use custom timing so that sending back the money at the end of each iteration isn't
+			// included in the measurement.
 			let node_a = Arc::clone(&node_a);
 			let node_b = Arc::clone(&node_b);
-
-			async move {
-				let mut total = Duration::ZERO;
-				for _i in 0..iter {
-					let node_a = Arc::clone(&node_a);
-					let node_b = Arc::clone(&node_b);
-
-					total += send_payments(node_a, node_b).await;
+			b.to_async(&runtime).iter_custom(|iter| {
+				let node_a = Arc::clone(&node_a);
+				let node_b = Arc::clone(&node_b);
+
+				async move {
+					let mut total = Duration::ZERO;
+					for _i in 0..iter {
+						let node_a = Arc::clone(&node_a);
+						let node_b = Arc::clone(&node_b);
+
+						total += send_payments(node_a, node_b).await;
+					}
+					total
 				}
-				total
-			}
+			});
 		});
-	});
+	}
+}
+
+fn benchmark_runtime() -> tokio::runtime::Runtime {
+	let mut builder = tokio::runtime::Builder::new_multi_thread();
+	builder.worker_threads(4).enable_all();
+	#[cfg(tokio_unstable)]
+	builder.enable_eager_driver_handoff();
+	builder.build().unwrap()
 }
 
 criterion_group!(benches, payment_benchmark);

tests/common/mod.rs

@@ -52,6 +52,7 @@ use ldk_node::{
 	PendingSweepBalance, UserChannelId,
 };
 use lightning::io;
+use lightning::ln::channelmanager::PaymentId;
 use lightning::ln::msgs::SocketAddress;
 use lightning::routing::gossip::NodeAlias;
 use lightning::util::persist::{KVStore, PageToken, PaginatedKVStore, PaginatedListResponse};
@@ -308,6 +309,26 @@ macro_rules! expect_payment_successful_event {
 
 pub(crate) use expect_payment_successful_event;
 
+pub async fn wait_for_payment_success(node: &Node, expected_payment_id: PaymentId) {
+	loop {
+		match node.next_event_async().await {
+			Event::PaymentSuccessful { payment_id: Some(payment_id), .. }
+				if payment_id == expected_payment_id =>
+			{
+				node.event_handled().unwrap();
+				break;
+			},
+			Event::PaymentFailed { payment_id, payment_hash, .. } => {
+				node.event_handled().unwrap();
+				panic!("Return payment {:?} failed with hash {:?}", payment_id, payment_hash);
+			},
+			_ => {
+				node.event_handled().unwrap();
+			},
+		}
+	}
+}
+
 pub(crate) fn setup_bitcoind_and_electrsd() -> (BitcoinD, ElectrsD) {
 	let bitcoind_exe =
 		env::var("BITCOIND_EXE").ok().or_else(|| corepc_node::downloaded_exe_path().ok()).expect(
@@ -535,6 +556,33 @@ pub(crate) enum TestStoreType {
 	TestSyncStore,
 	Sqlite,
 	FilesystemStore,
+	#[cfg(feature = "postgres")]
+	Postgres,
+}
+
+#[derive(Clone, Copy)]
+pub(crate) struct StoreBenchConfig {
+	pub(crate) name: &'static str,
+	pub(crate) store_type: TestStoreType,
+}
+
+pub(crate) fn store_bench_configs() -> Vec<StoreBenchConfig> {
+	#[cfg(not(feature = "postgres"))]
+	{
+		vec![
+			StoreBenchConfig { name: "sqlite", store_type: TestStoreType::Sqlite },
+			StoreBenchConfig { name: "filesystem", store_type: TestStoreType::FilesystemStore },
+		]
+	}
+
+	#[cfg(feature = "postgres")]
+	{
+		vec![
+			StoreBenchConfig { name: "sqlite", store_type: TestStoreType::Sqlite },
+			StoreBenchConfig { name: "filesystem", store_type: TestStoreType::FilesystemStore },
+			StoreBenchConfig { name: "postgres", store_type: TestStoreType::Postgres },
+		]
+	}
 }
 
 impl Default for TestStoreType {
@@ -729,6 +777,31 @@ pub(crate) fn setup_node(chain_source: &TestChainSource, config: TestConfig) ->
 		TestStoreType::FilesystemStore => {
 			builder.build_with_fs_store(config.node_entropy.into()).unwrap()
 		},
+		#[cfg(feature = "postgres")]
+		TestStoreType::Postgres => {
+			use ldk_node::io::postgres_store::POSTGRES_TEST_URL_ENV_VAR;
+
+			let table_name = format!(
+				"test_{}",
+				config
+					.node_config
+					.storage_dir_path
+					.chars()
+					.filter(|c| c.is_ascii_alphanumeric())
+					.collect::<String>()
+			);
+			let connection_string = std::env::var(POSTGRES_TEST_URL_ENV_VAR)
+				.unwrap_or_else(|_| "host=localhost user=postgres password=postgres".to_string());
+			builder
+				.build_with_postgres_store(
+					config.node_entropy.into(),
+					connection_string,
+					None,
+					Some(table_name),
+					None,
+				)
+				.unwrap()
+		},
 	};
 
 	node.start().unwrap();

tests/integration_tests_rust.rs

@@ -3714,6 +3714,8 @@ async fn build_0_7_0_node(
 		TestStoreType::FilesystemStore => builder_old.build_with_fs_store().unwrap(),
 		TestStoreType::Sqlite => builder_old.build().unwrap(),
 		TestStoreType::TestSyncStore => panic!("TestSyncStore not supported in v0.7.0 builder"),
+		#[cfg(feature = "postgres")]
+		TestStoreType::Postgres => panic!("Postgres not supported in v0.7.0 builder"),
 	};
 
 	node_old.start().unwrap();