Add benchmark support

Author: Spxg

client/js-sys/benches/interpo.rs

@@ -0,0 +1,19 @@
+use js_bindgen_test::{Criterion, bench};
+use js_sys::js_sys;
+
+js_bindgen::embed_js!(module = "interpo", name = "bench", "(value) => value");
+
+#[js_sys]
+extern "js-sys" {
+	#[js_sys(js_embed = "bench")]
+	fn interpo(value: u128) -> u128;
+}
+
+#[bench]
+fn bench_interpo_u128(c: &mut Criterion) {
+	c.bench_function("bench_interpo_u128", |b| {
+		b.iter(|| {
+			assert_eq!(interpo(4242), 4242);
+		})
+	});
+}

client/js-sys/tests/array.rs

@@ -7,7 +7,7 @@ use js_sys::{JsArray, JsValue};
 fn js_value() {
 	let rust_array = [JsValue::UNDEFINED; 42];
 	let js_array = JsArray::from(&rust_array);
-	assert_eq!(rust_array.len(), js_array.length().try_into().unwrap());
+	assert_eq!(rust_array.len(), usize::try_from(js_array.length()).unwrap());
 
 	let returned_array: [JsValue; 42] = js_array.to_array().unwrap();
 	assert!(rust_array == returned_array);
@@ -17,7 +17,7 @@ fn js_value() {
 fn u32() {
 	let rust_array: [u32; 42] = array::from_fn(|i| i.try_into().unwrap());
 	let js_array = JsArray::from(&rust_array);
-	assert_eq!(rust_array.len(), js_array.length().try_into().unwrap());
+	assert_eq!(rust_array.len(), usize::try_from(js_array.length()).unwrap());
 
 	let returned_array: [u32; 42] = js_array.to_array().unwrap();
 	assert_eq!(rust_array, returned_array);

client/test/Cargo.toml

@@ -8,5 +8,15 @@ rust-version = "1.87"
 js-bindgen-test-macro = { workspace = true }
 js-sys = { workspace = true, features = ["macro"] }
 
+async-trait = "0.1.89"
+cast = "0.3"
+libm = "0.2.11"
+nu-ansi-term = { version = "0.50", default-features = false }
+num-traits = { version = "0.2", default-features = false, features = ["libm"] }
+once_cell = "1.21.4"
+oorandom = "11.1.5"
+serde = { version = "1.0", default-features = false, features = ["derive"] }
+serde_json = { version = "1.0", default-features = false, features = ["alloc"] }
+
 [lints]
 workspace = true

client/test/src/criterion/analysis.rs

@@ -0,0 +1,157 @@
+use alloc::vec::Vec;
+
+use super::benchmark::BenchmarkConfig;
+use super::estimate::{
+	ConfidenceInterval, Distributions, Estimate, Estimates, PointEstimates, build_estimates,
+};
+use super::measurement::Measurement;
+use super::report::{BenchmarkId, Report};
+use super::routine::Routine;
+use super::stats::bivariate::Data;
+use super::stats::bivariate::regression::Slope;
+use super::stats::univariate::Sample;
+use super::stats::{Distribution, Tails};
+use super::{Criterion, SavedSample, baseline, compare};
+
+// Common analysis procedure
+pub(crate) async fn common<M: Measurement>(
+	id: &BenchmarkId,
+	routine: &mut dyn Routine<M>,
+	config: &BenchmarkConfig,
+	criterion: &Criterion<M>,
+) {
+	criterion.report.benchmark_start(id);
+
+	let (sampling_mode, iters, times);
+	let sample = routine
+		.sample(&criterion.measurement, id, config, criterion)
+		.await;
+	sampling_mode = sample.0;
+	iters = sample.1;
+	times = sample.2;
+
+	criterion.report.analysis(id);
+
+	if times.contains(&0.0) {
+		return;
+	}
+
+	let avg_times = iters
+		.iter()
+		.zip(times.iter())
+		.map(|(&iters, &elapsed)| elapsed / iters)
+		.collect::<Vec<f64>>();
+	let avg_times = Sample::new(&avg_times);
+	let labeled_sample = super::stats::univariate::outliers::tukey::classify(avg_times);
+
+	let data = Data::new(&iters, &times);
+	let (mut distributions, mut estimates) = estimates(avg_times, config);
+	if sampling_mode.is_linear() {
+		let (distribution, slope) = regression(&data, config);
+
+		estimates.slope = Some(slope);
+		distributions.slope = Some(distribution);
+	}
+
+	let comparison = compare::common(id, avg_times, config).map(
+		|(t_value, t_distribution, relative_estimates, ..)| {
+			let p_value = t_distribution.p_value(t_value, Tails::Two);
+			super::report::ComparisonData {
+				p_value,
+				relative_estimates,
+				significance_threshold: config.significance_level,
+				noise_threshold: config.noise_threshold,
+			}
+		},
+	);
+
+	let measurement_data = super::report::MeasurementData {
+		avg_times: labeled_sample,
+		absolute_estimates: estimates.clone(),
+		comparison,
+	};
+
+	criterion
+		.report
+		.measurement_complete(id, &measurement_data, criterion.measurement.formatter());
+
+	baseline::write(
+		id.desc(),
+		baseline::BenchmarkBaseline {
+			file: criterion.location.as_ref().map(|l| l.file.clone()),
+			module_path: criterion.location.as_ref().map(|l| l.module_path.clone()),
+			iters: data.x().as_ref().to_vec(),
+			times: data.y().as_ref().to_vec(),
+			sample: SavedSample {
+				sampling_mode,
+				iters: data.x().as_ref().to_vec(),
+				times: data.y().as_ref().to_vec(),
+			},
+			estimates,
+		},
+	);
+}
+
+// Performs a simple linear regression on the sample
+fn regression(
+	data: &Data<'_, f64, f64>,
+	config: &BenchmarkConfig,
+) -> (Distribution<f64>, Estimate) {
+	let cl = config.confidence_level;
+
+	let distribution = data.bootstrap(config.nresamples, |d| (Slope::fit(&d).0,)).0;
+
+	let point = Slope::fit(data);
+	let (lb, ub) = distribution.confidence_interval(config.confidence_level);
+	let se = distribution.std_dev(None);
+
+	(
+		distribution,
+		Estimate {
+			confidence_interval: ConfidenceInterval {
+				confidence_level: cl,
+				lower_bound: lb,
+				upper_bound: ub,
+			},
+			point_estimate: point.0,
+			standard_error: se,
+		},
+	)
+}
+
+// Estimates the statistics of the population from the sample
+fn estimates(avg_times: &Sample<f64>, config: &BenchmarkConfig) -> (Distributions, Estimates) {
+	fn stats(sample: &Sample<f64>) -> (f64, f64, f64, f64) {
+		let mean = sample.mean();
+		let std_dev = sample.std_dev(Some(mean));
+		let median = sample.percentiles().median();
+		let mad = sample.median_abs_dev(Some(median));
+
+		(mean, std_dev, median, mad)
+	}
+
+	let cl = config.confidence_level;
+	let nresamples = config.nresamples;
+
+	let (mean, std_dev, median, mad) = stats(avg_times);
+	let points = PointEstimates {
+		mean,
+		median,
+		std_dev,
+		median_abs_dev: mad,
+	};
+
+	let (dist_mean, dist_stddev, dist_median, dist_mad) = avg_times.bootstrap(nresamples, stats);
+
+	let distributions = Distributions {
+		mean: dist_mean,
+		slope: None,
+		median: dist_median,
+		median_abs_dev: dist_mad,
+		std_dev: dist_stddev,
+	};
+
+	let estimates = build_estimates(&distributions, &points, cl);
+
+	(distributions, estimates)
+}

client/test/src/criterion/baseline.rs

@@ -0,0 +1,74 @@
+//! Record previous benchmark data
+
+use crate::console_log;
+use alloc::collections::BTreeMap;
+use alloc::string::String;
+use alloc::vec::Vec;
+use core::cell::RefCell;
+use js_sys::{JsString, js_sys};
+
+use serde::{Deserialize, Serialize};
+
+use super::SavedSample;
+use super::estimate::Estimates;
+use crate::utils::LazyCell;
+
+#[cfg_attr(target_feature = "atomics", thread_local)]
+static BASELINE: LazyCell<RefCell<BTreeMap<String, BenchmarkBaseline>>> =
+	LazyCell::new(|| RefCell::new(BTreeMap::new()));
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub(crate) struct BenchmarkBaseline {
+	pub(crate) file: Option<String>,
+	pub(crate) module_path: Option<String>,
+	pub(crate) iters: Vec<f64>,
+	pub(crate) times: Vec<f64>,
+	pub(crate) sample: SavedSample,
+	pub(crate) estimates: Estimates,
+}
+
+/// Write the corresponding benchmark ID and corresponding data into the table.
+pub(crate) fn write(id: &str, baseline: BenchmarkBaseline) {
+	BASELINE.borrow_mut().insert(id.into(), baseline);
+}
+
+/// Read the data corresponding to the benchmark ID from the table.
+pub(crate) fn read(id: &str) -> Option<BenchmarkBaseline> {
+	BASELINE.borrow().get(id).cloned()
+}
+
+#[js_sys]
+extern "js-sys" {
+	#[js_sys(js_import)]
+	fn import_bench_baseline() -> JsString;
+
+	#[js_sys(js_import)]
+	fn dump_bench_baseline(baseline: &JsString);
+}
+
+/// Used to read previous benchmark data before the benchmark, for later
+/// comparison.
+pub(crate) fn import_baseline() {
+	match serde_json::from_str(&String::from(&import_bench_baseline())) {
+		Ok(prev) => {
+			*BASELINE.borrow_mut() = prev;
+		}
+		Err(e) => {
+			console_log!("Failed to import previous benchmark {e:?}");
+		}
+	}
+}
+
+/// Used to read benchmark data, and then the runner stores it on the local
+/// disk.
+pub(crate) fn dump_baseline() {
+	let baseline = BASELINE.borrow();
+	if !baseline.is_empty() {
+		let baseline = JsString::from(
+			serde_json::to_string(&*baseline)
+				.unwrap_or_default()
+				.as_str(),
+		);
+		dump_bench_baseline(&baseline);
+	}
+}