criterion: cuprate-helper

Cargo.toml

@@ -3,14 +3,13 @@ resolver = "2"
 members = [
 	# Binaries
 	"binaries/cuprated",
-
 	# Benchmarks
 	"benches/benchmark/bin",
 	"benches/benchmark/lib",
 	"benches/benchmark/example",
 	"benches/criterion/example",
 	"benches/criterion/cuprate-json-rpc",
-
+	"benches/criterion/cuprate-helper",
 	# Consensus
 	"consensus",
 	"consensus/context",

benches/benchmark/bin/Cargo.toml

@@ -40,4 +40,4 @@ tracing-subscriber = { workspace = true, features = ["fmt", "std", "env-filter"]
 [dev-dependencies]
 
 [lints]
-workspace = true
+workspace = true

benches/criterion/cuprate-helper/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name        = "cuprate-criterion-helper"
+version     = "0.0.0"
+edition     = "2021"
+description = "Criterion benchmarks for cuprate-helper"
+license     = "MIT"
+authors     = ["hinto-janai"]
+repository  = "https://github.com/Cuprate/cuprate/tree/main/benches/criterion/example"
+keywords    = ["cuprate", "helper", "criterion", "benchmark"]
+
+[dependencies]
+cuprate-constants = { path = "../../../constants", features = ["block"] }
+cuprate-helper    = { path = "../../../helper", features = ["cast", "map", "num", "tx"] }
+cuprate-test-utils = { path = "../../../test-utils" }
+
+criterion     = { workspace = true }
+function_name = { workspace = true }
+monero-serai  = { workspace = true }
+serde_json    = { workspace = true, features = ["default"] }
+
+[[bench]]
+name    = "main"
+harness = false
+
+[lints]
+workspace = true

benches/criterion/cuprate-helper/benches/cast.rs

@@ -0,0 +1,40 @@
+//! Benchmarks for `cuprate_helper::cast`.
+#![allow(unused_attributes, unused_crate_dependencies)]
+
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use function_name::named;
+
+use cuprate_helper::cast::{
+    i32_to_isize, i64_to_isize, isize_to_i64, u32_to_usize, u64_to_usize, usize_to_u64,
+};
+
+criterion_group! {
+    name = benches;
+    config = Criterion::default();
+    targets = integer, unsigned,
+}
+criterion_main!(benches);
+
+/// Benchmark integer casts.
+#[named]
+fn integer(c: &mut Criterion) {
+    c.bench_function(function_name!(), |b| {
+        b.iter(|| {
+            black_box(i32_to_isize(black_box(0)));
+            black_box(i64_to_isize(black_box(0)));
+            black_box(isize_to_i64(black_box(0)));
+        });
+    });
+}
+
+/// Benchmark unsigned integer casts.
+#[named]
+fn unsigned(c: &mut Criterion) {
+    c.bench_function(function_name!(), |b| {
+        b.iter(|| {
+            black_box(u32_to_usize(black_box(0)));
+            black_box(u64_to_usize(black_box(0)));
+            black_box(usize_to_u64(black_box(0)));
+        });
+    });
+}

benches/criterion/cuprate-helper/benches/main.rs

@@ -0,0 +1,14 @@
+//! `cuprate_helper` benchmarks.
+#![allow(unused_crate_dependencies)]
+
+mod cast;
+mod map;
+mod num;
+mod tx;
+
+criterion::criterion_main! {
+    cast::benches,
+    map::benches,
+    num::benches,
+    tx::benches,
+}

benches/criterion/cuprate-helper/benches/map.rs

@@ -0,0 +1,70 @@
+//! Benchmarks for `cuprate_helper::cast`.
+#![allow(unused_attributes, unused_crate_dependencies)]
+
+use criterion::black_box as b;
+use criterion::{criterion_group, criterion_main, Criterion};
+use function_name::named;
+
+use cuprate_constants::block::MAX_BLOCK_HEIGHT;
+use cuprate_helper::map;
+
+criterion_group! {
+    name = benches;
+    config = Criterion::default();
+    targets =
+        combine_low_high_bits_to_u128,
+        split_u128_into_low_high_bits,
+        timelock_to_u64,
+        u64_to_timelock,
+}
+criterion_main!(benches);
+
+/// Benchmark [`curpate_helper::map::combine_low_high_bits_to_u128`].
+#[named]
+fn combine_low_high_bits_to_u128(c: &mut Criterion) {
+    c.bench_function(function_name!(), |bench| {
+        bench.iter(|| {
+            b(map::combine_low_high_bits_to_u128(b(0), b(0)));
+        });
+    });
+}
+
+/// Benchmark [`curpate_helper::map::split_u128_into_low_high_bits`].
+#[named]
+fn split_u128_into_low_high_bits(c: &mut Criterion) {
+    c.bench_function(function_name!(), |bench| {
+        bench.iter(|| {
+            b(map::split_u128_into_low_high_bits(b(0)));
+        });
+    });
+}
+
+/// Benchmark [`curpate_helper::map::timelock_to_u64`].
+#[named]
+fn timelock_to_u64(c: &mut Criterion) {
+    c.bench_function(function_name!(), |bench| {
+        bench.iter(|| {
+            b(map::timelock_to_u64(b(
+                monero_serai::transaction::Timelock::None,
+            )));
+            b(map::timelock_to_u64(b(
+                monero_serai::transaction::Timelock::Time(0),
+            )));
+            b(map::timelock_to_u64(b(
+                monero_serai::transaction::Timelock::Block(0),
+            )));
+        });
+    });
+}
+
+/// Benchmark [`curpate_helper::map::u64_to_timelock`].
+#[named]
+fn u64_to_timelock(c: &mut Criterion) {
+    c.bench_function(function_name!(), |bench| {
+        bench.iter(|| {
+            b(map::u64_to_timelock(b(0)));
+            b(map::u64_to_timelock(b(MAX_BLOCK_HEIGHT)));
+            b(map::u64_to_timelock(b(MAX_BLOCK_HEIGHT + 1)));
+        });
+    });
+}

benches/criterion/cuprate-helper/benches/num.rs

@@ -0,0 +1,64 @@
+//! Benchmarks for `cuprate_helper::cast`.
+#![allow(unused_attributes, unused_crate_dependencies)]
+
+use criterion::black_box as b;
+use criterion::{criterion_group, criterion_main, Criterion};
+use function_name::named;
+
+use cuprate_helper::num;
+
+criterion_group! {
+    name = benches;
+    config = Criterion::default();
+    targets =
+        cmp_float,
+        cmp_float_nan,
+        get_mid,
+        median,
+}
+criterion_main!(benches);
+
+/// Benchmark [`curpate_helper::num::cmp_float`].
+#[named]
+fn cmp_float(c: &mut Criterion) {
+    c.bench_function(function_name!(), |bench| {
+        bench.iter(|| {
+            b(num::cmp_float(b(0.0), b(0.0)));
+        });
+    });
+}
+
+/// Benchmark [`curpate_helper::num::cmp_float_nan`].
+#[named]
+fn cmp_float_nan(c: &mut Criterion) {
+    c.bench_function(function_name!(), |bench| {
+        bench.iter(|| {
+            b(num::cmp_float_nan(b(0.0), b(0.0)));
+        });
+    });
+}
+
+/// Benchmark [`curpate_helper::num::get_mid`].
+#[named]
+fn get_mid(c: &mut Criterion) {
+    c.bench_function(function_name!(), |bench| {
+        bench.iter(|| {
+            b(num::get_mid(b(0_u8), b(0_u8)));
+            b(num::get_mid(b(1_i64), b(10_i64)));
+            b(num::get_mid(b(0.0_f32), b(0.0_f32)));
+            b(num::get_mid(b(0.0_f64), b(10.0_f64)));
+        });
+    });
+}
+
+/// Benchmark [`curpate_helper::num::median`].
+#[named]
+fn median(c: &mut Criterion) {
+    c.bench_function(function_name!(), |bench| {
+        bench.iter(|| {
+            b(num::median(b(vec![0_u8, 1, 2, 3, 4, 5])));
+            b(num::median(b(vec![0.0_f32, 1.0, 2.0, 3.0, 4.0, 5.0])));
+            b(num::median(b(vec![0_u64; 100])));
+        });
+    });
+}

benches/criterion/cuprate-helper/benches/tx.rs

@@ -0,0 +1,28 @@
+//! Benchmarks for `cuprate_helper::cast`.
+#![allow(unused_attributes, unused_crate_dependencies)]
+
+use criterion::black_box as b;
+use criterion::{criterion_group, criterion_main, Criterion};
+use function_name::named;
+
+use cuprate_helper::tx;
+use cuprate_test_utils::data::{TX_V1_SIG0, TX_V1_SIG2, TX_V2_RCT3};
+
+criterion_group! {
+    name = benches;
+    config = Criterion::default();
+    targets = tx_fee,
+}
+criterion_main!(benches);
+
+/// Benchmark [`curpate_helper::tx::tx_fee`].
+#[named]
+fn tx_fee(c: &mut Criterion) {
+    c.bench_function(function_name!(), |bench| {
+        bench.iter(|| {
+            b(tx::tx_fee(b(&TX_V1_SIG0.tx)));
+            b(tx::tx_fee(b(&TX_V1_SIG2.tx)));
+            b(tx::tx_fee(b(&TX_V2_RCT3.tx)));
+        });
+    });
+}

benches/criterion/cuprate-helper/src/lib.rs

@@ -0,0 +1 @@
+#![allow(unused_crate_dependencies, reason = "used in benchmarks")]

benches/criterion/cuprate-json-rpc/Cargo.toml

@@ -20,4 +20,4 @@ name    = "main"
 harness = false
 
 [lints]
-workspace = true
+workspace = true