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.

Author: benthecarman

benches/payments.rs

@@ -18,6 +18,12 @@ use tokio::task::{self};
 
 use crate::common::open_channel_push_amt;
 
+#[derive(Clone, Copy)]
+struct StoreBenchConfig {
+	name: &'static str,
+	store_type: common::TestStoreType,
+}
+
 fn spawn_payment(node_a: Arc<Node>, node_b: Arc<Node>, amount_msat: u64) {
 	let mut preimage_bytes = [0u8; 32];
 	rand::rng().fill_bytes(&mut preimage_bytes);
@@ -121,74 +127,100 @@ fn payment_benchmark(c: &mut Criterion) {
 	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,
-		true,
-		false,
-		common::TestStoreType::Sqlite,
-	);
+	let store_configs = store_bench_configs();
 
 	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 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, true, 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 store_bench_configs() -> Vec<StoreBenchConfig> {
+	#[cfg(not(feature = "postgres"))]
+	{
+		vec![
+			StoreBenchConfig { name: "sqlite", store_type: common::TestStoreType::Sqlite },
+			StoreBenchConfig {
+				name: "filesystem",
+				store_type: common::TestStoreType::FilesystemStore,
+			},
+		]
+	}
+
+	#[cfg(feature = "postgres")]
+	{
+		vec![
+			StoreBenchConfig { name: "sqlite", store_type: common::TestStoreType::Sqlite },
+			StoreBenchConfig {
+				name: "filesystem",
+				store_type: common::TestStoreType::FilesystemStore,
+			},
+			StoreBenchConfig { name: "postgres", store_type: common::TestStoreType::Postgres },
+		]
+	}
 }
 
 criterion_group!(benches, payment_benchmark);

tests/common/mod.rs

@@ -417,6 +417,8 @@ pub(crate) enum TestStoreType {
 	TestSyncStore,
 	Sqlite,
 	FilesystemStore,
+	#[cfg(feature = "postgres")]
+	Postgres,
 }
 
 impl Default for TestStoreType {
@@ -596,6 +598,29 @@ 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 => {
+			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("TEST_POSTGRES_URL")
+				.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()
+		},
 	};
 
 	if config.recovery_mode {

tests/integration_tests_rust.rs

@@ -2568,6 +2568,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();