test: use runtime arguments in Divan benchmarks (#1)

This greatly reduces compile times and is not limited to arrays/slices.

crates/mabo-benches/Cargo.toml

@@ -28,7 +28,7 @@ mabo-parser = { path = "../mabo-parser" }
 mimalloc.workspace = true
 
 [dev-dependencies]
-divan = "0.1.8"
+divan = "0.1.11"
 indoc.workspace = true
 
 [lints]

crates/mabo-benches/benches/compiler.rs

@@ -9,18 +9,18 @@ fn main() {
     divan::main();
 }
 
-#[divan::bench(consts = [1, 10, 100, 1000])]
-fn validate_large_schema<const N: usize>(bencher: Bencher<'_, '_>) {
-    let schema = mabo_benches::generate_schema(N);
+#[divan::bench(args = [1, 10, 100, 1000])]
+fn validate_large_schema(bencher: Bencher<'_, '_>, n: usize) {
+    let schema = mabo_benches::generate_schema(n);
     let schema = mabo_parser::Schema::parse(&schema, None).unwrap();
     mabo_compiler::validate_schema(&schema).unwrap();
 
     bencher.bench(|| mabo_compiler::validate_schema(black_box(&schema)));
 }
 
-#[divan::bench(consts = [1, 10, 100, 1000])]
-fn resolve_large_schema<const N: usize>(bencher: Bencher<'_, '_>) {
-    let schema = mabo_benches::generate_schema(N);
+#[divan::bench(args = [1, 10, 100, 1000])]
+fn resolve_large_schema(bencher: Bencher<'_, '_>, n: usize) {
+    let schema = mabo_benches::generate_schema(n);
     let schema = mabo_parser::Schema::parse(&schema, None).unwrap();
     mabo_compiler::validate_schema(&schema).unwrap();
 
@@ -29,9 +29,9 @@ fn resolve_large_schema<const N: usize>(bencher: Bencher<'_, '_>) {
     bencher.bench(|| mabo_compiler::resolve_schemas(black_box(list)));
 }
 
-#[divan::bench(consts = [1, 10, 100, 1000])]
-fn simplify_large_schema<const N: usize>(bencher: Bencher<'_, '_>) {
-    let schema = mabo_benches::generate_schema(N);
+#[divan::bench(args = [1, 10, 100, 1000])]
+fn simplify_large_schema(bencher: Bencher<'_, '_>, n: usize) {
+    let schema = mabo_benches::generate_schema(n);
     let schema = mabo_parser::Schema::parse(&schema, None).unwrap();
     let _ = mabo_compiler::simplify_schema(&schema);
 

crates/mabo-benches/benches/parser.rs

@@ -48,17 +48,17 @@ fn basic(bencher: Bencher<'_, '_>) {
     bencher.bench(|| mabo_parser::Schema::parse(black_box(input), None));
 }
 
-#[divan::bench(consts = [1, 10, 100, 1000])]
-fn large_schema<const N: usize>(bencher: Bencher<'_, '_>) {
-    let schema = mabo_benches::generate_schema(N);
+#[divan::bench(args = [1, 10, 100, 1000])]
+fn large_schema(bencher: Bencher<'_, '_>, n: usize) {
+    let schema = mabo_benches::generate_schema(n);
     mabo_parser::Schema::parse(&schema, None).unwrap();
 
     bencher.bench(|| mabo_parser::Schema::parse(black_box(&schema), None));
 }
 
-#[divan::bench(consts = [1, 10, 100, 1000])]
-fn print<const N: usize>(bencher: Bencher<'_, '_>) {
-    let schema = mabo_benches::generate_schema(N);
+#[divan::bench(args = [1, 10, 100, 1000])]
+fn print(bencher: Bencher<'_, '_>, n: usize) {
+    let schema = mabo_benches::generate_schema(n);
     let schema = mabo_parser::Schema::parse(&schema, None).unwrap();
 
     bencher.bench(|| black_box(&schema).to_string());

crates/mabo-benches/benches/varint.rs

@@ -49,32 +49,32 @@ impl Signed for Bincode {
 
 #[divan::bench(
     types = [Leb128, Bincode],
-    consts = [
+    args = [
         1,
-        u8::MAX as u128,
-        u16::MAX as u128,
-        u32::MAX as u128,
-        u64::MAX as u128,
+        u8::MAX.into(),
+        u16::MAX.into(),
+        u32::MAX.into(),
+        u64::MAX.into(),
         u128::MAX,
     ],
 )]
-fn unsigned<const N: u128, T: Unsigned>() -> u128 {
+fn unsigned<T: Unsigned>(n: u128) -> u128 {
     let mut buf = [0; 19];
-    T::run(black_box(N), black_box(&mut buf))
+    T::run(n, black_box(&mut buf))
 }
 
 #[divan::bench(
     types = [Leb128, Bincode],
-    consts = [
+    args = [
         -1,
-        i8::MIN as i128,
-        i16::MIN as i128,
-        i32::MIN as i128,
-        i64::MIN as i128,
+        i8::MIN.into(),
+        i16::MIN.into(),
+        i32::MIN.into(),
+        i64::MIN.into(),
         i128::MIN,
     ],
 )]
-fn signed<const N: i128, T: Signed>() -> i128 {
+fn signed<T: Signed>(n: i128) -> i128 {
     let mut buf = [0; 19];
-    T::run(black_box(N), black_box(&mut buf))
+    T::run(n, black_box(&mut buf))
 }