From 2733b4d6aadd5654e98d210969227e923904c127 Mon Sep 17 00:00:00 2001
From: "coderabbitai[bot]"
 <136622811+coderabbitai[bot]@users.noreply.github.com>
Date: Sat, 12 Sep 2026 13:08:17 +0000
Subject: [PATCH] =?UTF-8?q?=F0=9F=93=9D=20CodeRabbit=20Chat:=20Update=20Ru?=
 =?UTF-8?q?st=20benchmarks=20to=20use=20the=20built-in=20Itme=20pattern?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 rust/benches/normal/add_bench.rs         | 38 +++++++++------------
 rust/benches/normal/assign_bench.rs      | 38 +++++++++------------
 rust/benches/normal/concat_bench.rs      | 38 +++++++++------------
 rust/benches/normal/dead_code_bench.rs   | 41 +++++++++++-----------
 rust/benches/normal/io_bench.rs          | 40 ++++++++++------------
 rust/benches/optimize/assign_bench.rs    | 41 ++++++++++------------
 rust/benches/optimize/concat_bench.rs    | 41 ++++++++++------------
 rust/benches/optimize/dead_code_bench.rs | 43 +++++++++++-------------
 rust/benches/optimize/io_bench.rs        | 43 +++++++++++-------------
 9 files changed, 159 insertions(+), 204 deletions(-)

diff --git a/rust/benches/normal/add_bench.rs b/rust/benches/normal/add_bench.rs
index d5434da9..554327e0 100644
--- a/rust/benches/normal/add_bench.rs
+++ b/rust/benches/normal/add_bench.rs
@@ -8,11 +8,14 @@
  * http://www.apache.org/licenses/LICENSE-2.0
  */
 
-use criterion::{Bencher, Criterion, criterion_group, criterion_main};
 use lightvm::{LightVM, types::capability::Capability};
-use std::time::Duration;
-fn bench_vm_execution(c: &mut Criterion) {
-  let mut vm = LightVM::new(vec![Capability::Control, Capability::Observe]);
+fn main() {
+  let capabilities = vec![
+    Capability::Control,
+    Capability::Debug,
+    Capability::Observe,
+  ];
+  let mut vm = LightVM::new(capabilities.clone());
   let raw = r#"[
     ["val", "x"],
     ["push", 5],
@@ -20,22 +23,13 @@ fn bench_vm_execution(c: &mut Criterion) {
     ["add", "i16"],
     ["set", "x"]
   ]"#;
-  vm.load(raw.into());
-  let mut group = c.benchmark_group("LightVM Execution");
-  group.bench_function("add_bench", |b: &mut Bencher| {
-    b.iter(|| vm.run(None));
-  });
-  group.finish();
+  let benchmark = vm.tools().bench("add_bench").expect("benchmark requires debug capability");
+  benchmark.run(
+    || {
+      let mut vm = LightVM::new(capabilities.clone());
+      vm.load(raw.into());
+      vm
+    },
+    |vm| vm.run(None),
+  );
 }
-fn custom_config() -> Criterion {
-  Criterion::default()
-    .sample_size(300)
-    .measurement_time(Duration::from_secs(15))
-    .warm_up_time(Duration::from_secs(3))
-}
-criterion_group! {
-  name = benches;
-  config = custom_config();
-  targets = bench_vm_execution
-}
-criterion_main!(benches);
diff --git a/rust/benches/normal/assign_bench.rs b/rust/benches/normal/assign_bench.rs
index 9dcde579..9bda722f 100644
--- a/rust/benches/normal/assign_bench.rs
+++ b/rust/benches/normal/assign_bench.rs
@@ -8,28 +8,22 @@
  * http://www.apache.org/licenses/LICENSE-2.0
  */
 
-use criterion::{Bencher, Criterion, criterion_group, criterion_main};
 use lightvm::{LightVM, types::capability::Capability};
-use std::time::Duration;
-fn bench_vm_execution(c: &mut Criterion) {
-  let mut vm = LightVM::new(vec![Capability::Control, Capability::Observe]);
+fn main() {
+  let capabilities = vec![
+    Capability::Control,
+    Capability::Debug,
+    Capability::Observe,
+  ];
+  let mut vm = LightVM::new(capabilities.clone());
   let raw = r#"[["val", "x"], ["push", 5], ["set", "x"]]"#;
-  vm.load(raw.into());
-  let mut group = c.benchmark_group("LightVM Execution");
-  group.bench_function("assign_bench", |b: &mut Bencher| {
-    b.iter(|| vm.run(None));
-  });
-  group.finish();
+  let benchmark = vm.tools().bench("assign_bench").expect("benchmark requires debug capability");
+  benchmark.run(
+    || {
+      let mut vm = LightVM::new(capabilities.clone());
+      vm.load(raw.into());
+      vm
+    },
+    |vm| vm.run(None),
+  );
 }
-fn custom_config() -> Criterion {
-  Criterion::default()
-    .sample_size(300)
-    .measurement_time(Duration::from_secs(15))
-    .warm_up_time(Duration::from_secs(3))
-}
-criterion_group! {
-  name = benches;
-  config = custom_config();
-  targets = bench_vm_execution
-}
-criterion_main!(benches);
diff --git a/rust/benches/normal/concat_bench.rs b/rust/benches/normal/concat_bench.rs
index 3dae8715..a060516c 100644
--- a/rust/benches/normal/concat_bench.rs
+++ b/rust/benches/normal/concat_bench.rs
@@ -8,33 +8,27 @@
  * http://www.apache.org/licenses/LICENSE-2.0
  */
 
-use criterion::{Bencher, Criterion, criterion_group, criterion_main};
 use lightvm::{LightVM, types::capability::Capability};
-use std::time::Duration;
-fn bench_vm_execution(c: &mut Criterion) {
-  let mut vm = LightVM::new(vec![Capability::Control, Capability::Observe]);
+fn main() {
+  let capabilities = vec![
+    Capability::Control,
+    Capability::Debug,
+    Capability::Observe,
+  ];
+  let mut vm = LightVM::new(capabilities.clone());
   let raw = r#"[
     ["val", "x"],
     ["push", "Hello from "],
     ["push", "LightVM!"],
     ["set", "x"]
   ]"#;
-  vm.load(raw.into());
-  let mut group = c.benchmark_group("LightVM Execution");
-  group.bench_function("concat_bench", |b: &mut Bencher| {
-    b.iter(|| vm.run(None));
-  });
-  group.finish();
+  let benchmark = vm.tools().bench("concat_bench").expect("benchmark requires debug capability");
+  benchmark.run(
+    || {
+      let mut vm = LightVM::new(capabilities.clone());
+      vm.load(raw.into());
+      vm
+    },
+    |vm| vm.run(None),
+  );
 }
-fn custom_config() -> Criterion {
-  Criterion::default()
-    .sample_size(300)
-    .measurement_time(Duration::from_secs(15))
-    .warm_up_time(Duration::from_secs(3))
-}
-criterion_group! {
-  name = benches;
-  config = custom_config();
-  targets = bench_vm_execution
-}
-criterion_main!(benches);
diff --git a/rust/benches/normal/dead_code_bench.rs b/rust/benches/normal/dead_code_bench.rs
index 18cccd1e..936059b2 100644
--- a/rust/benches/normal/dead_code_bench.rs
+++ b/rust/benches/normal/dead_code_bench.rs
@@ -8,11 +8,14 @@
  * http://www.apache.org/licenses/LICENSE-2.0
  */
 
-use criterion::{Bencher, Criterion, criterion_group, criterion_main};
 use lightvm::{LightVM, types::capability::Capability};
-use std::time::Duration;
-fn bench_vm_execution(c: &mut Criterion) {
-  let mut vm = LightVM::new(vec![Capability::Control, Capability::Observe]);
+fn main() {
+  let capabilities = vec![
+    Capability::Control,
+    Capability::Debug,
+    Capability::Observe,
+  ];
+  let mut vm = LightVM::new(capabilities.clone());
   let raw = r#"[
     ["push", 5],
     ["push", 8],
@@ -21,22 +24,16 @@ fn bench_vm_execution(c: &mut Criterion) {
     ["push", 9],
     ["set", "x"]
   ]"#;
-  vm.load(raw.into());
-  let mut group = c.benchmark_group("LightVM Execution");
-  group.bench_function("dead_code_bench", |b: &mut Bencher| {
-    b.iter(|| vm.run(None));
-  });
-  group.finish();
+  let benchmark = vm
+    .tools()
+    .bench("dead_code_bench")
+    .expect("benchmark requires debug capability");
+  benchmark.run(
+    || {
+      let mut vm = LightVM::new(capabilities.clone());
+      vm.load(raw.into());
+      vm
+    },
+    |vm| vm.run(None),
+  );
 }
-fn custom_config() -> Criterion {
-  Criterion::default()
-    .sample_size(300)
-    .measurement_time(Duration::from_secs(15))
-    .warm_up_time(Duration::from_secs(3))
-}
-criterion_group! {
-  name = benches;
-  config = custom_config();
-  targets = bench_vm_execution
-}
-criterion_main!(benches);
diff --git a/rust/benches/normal/io_bench.rs b/rust/benches/normal/io_bench.rs
index eba68e04..c48f8127 100644
--- a/rust/benches/normal/io_bench.rs
+++ b/rust/benches/normal/io_bench.rs
@@ -8,31 +8,25 @@
  * http://www.apache.org/licenses/LICENSE-2.0
  */
 
-use criterion::{Bencher, Criterion, criterion_group, criterion_main};
 use lightvm::{LightVM, types::capability::Capability};
-use std::time::Duration;
-fn bench_vm_execution(c: &mut Criterion) {
-  let mut vm = LightVM::new(vec![Capability::Control, Capability::Observe]);
+fn main() {
+  let capabilities = vec![
+    Capability::Control,
+    Capability::Debug,
+    Capability::Observe,
+  ];
+  let mut vm = LightVM::new(capabilities.clone());
   let raw = r#"[["push", "Hello from LightVM!"], ["println"]]"#;
-  vm.load(raw.into());
-  let mut group = c.benchmark_group("LightVM Execution");
-  group.bench_function("io_bench", |b: &mut Bencher| {
-    b.iter(|| {
+  let benchmark = vm.tools().bench("io_bench").expect("benchmark requires debug capability");
+  benchmark.run(
+    || {
+      let mut vm = LightVM::new(capabilities.clone());
+      vm.load(raw.into());
+      vm
+    },
+    |vm| {
       let _sink = std::io::sink();
       vm.run(None)
-    });
-  });
-  group.finish();
+    },
+  );
 }
-fn custom_config() -> Criterion {
-  Criterion::default()
-    .sample_size(300)
-    .measurement_time(Duration::from_secs(15))
-    .warm_up_time(Duration::from_secs(3))
-}
-criterion_group! {
-  name = benches;
-  config = custom_config();
-  targets = bench_vm_execution
-}
-criterion_main!(benches);
diff --git a/rust/benches/optimize/assign_bench.rs b/rust/benches/optimize/assign_bench.rs
index a6460e88..d9e0838c 100644
--- a/rust/benches/optimize/assign_bench.rs
+++ b/rust/benches/optimize/assign_bench.rs
@@ -8,29 +8,24 @@
  * http://www.apache.org/licenses/LICENSE-2.0
  */
 
-use criterion::{Bencher, Criterion, criterion_group, criterion_main};
 use lightvm::{LightVM, types::capability::Capability};
-use std::time::Duration;
-fn bench_vm_execution(c: &mut Criterion) {
-  let mut vm = LightVM::new(vec![Capability::Control, Capability::Observe]);
+fn main() {
+  let capabilities = vec![
+    Capability::Control,
+    Capability::Debug,
+    Capability::Observe,
+  ];
+  let mut vm = LightVM::new(capabilities.clone());
   let raw = r#"[["val", "x"], ["push", 5], ["set", "x"]]"#;
-  let optimized_json = LightVM::tools().optimize_bytecode(raw);
-  vm.load(optimized_json.clone());
-  let mut group = c.benchmark_group("LightVM Execution");
-  group.bench_function("assign_bench", |b: &mut Bencher| {
-    b.iter(|| vm.run(None));
-  });
-  group.finish();
+  let tools = vm.tools();
+  let optimized_json = tools.optimize_bytecode(raw);
+  let benchmark = tools.bench("assign_bench").expect("benchmark requires debug capability");
+  benchmark.run(
+    || {
+      let mut vm = LightVM::new(capabilities.clone());
+      vm.load(optimized_json.clone());
+      vm
+    },
+    |vm| vm.run(None),
+  );
 }
-fn custom_config() -> Criterion {
-  Criterion::default()
-    .sample_size(300)
-    .measurement_time(Duration::from_secs(15))
-    .warm_up_time(Duration::from_secs(3))
-}
-criterion_group! {
-  name = benches;
-  config = custom_config();
-  targets = bench_vm_execution
-}
-criterion_main!(benches);
diff --git a/rust/benches/optimize/concat_bench.rs b/rust/benches/optimize/concat_bench.rs
index c6bb5d93..a4a54f38 100644
--- a/rust/benches/optimize/concat_bench.rs
+++ b/rust/benches/optimize/concat_bench.rs
@@ -8,34 +8,29 @@
  * http://www.apache.org/licenses/LICENSE-2.0
  */
 
-use criterion::{Bencher, Criterion, criterion_group, criterion_main};
 use lightvm::{LightVM, types::capability::Capability};
-use std::time::Duration;
-fn bench_vm_execution(c: &mut Criterion) {
-  let mut vm = LightVM::new(vec![Capability::Control, Capability::Observe]);
+fn main() {
+  let capabilities = vec![
+    Capability::Control,
+    Capability::Debug,
+    Capability::Observe,
+  ];
+  let mut vm = LightVM::new(capabilities.clone());
   let raw = r#"[
     ["val", "x"],
     ["push", "Hello from "],
     ["push", "LightVM!"],
     ["set", "x"]
   ]"#;
-  let optimized_json = LightVM::tools().optimize_bytecode(raw);
-  vm.load(optimized_json.clone());
-  let mut group = c.benchmark_group("LightVM Execution");
-  group.bench_function("concat_bench", |b: &mut Bencher| {
-    b.iter(|| vm.run(None));
-  });
-  group.finish();
+  let tools = vm.tools();
+  let optimized_json = tools.optimize_bytecode(raw);
+  let benchmark = tools.bench("concat_bench").expect("benchmark requires debug capability");
+  benchmark.run(
+    || {
+      let mut vm = LightVM::new(capabilities.clone());
+      vm.load(optimized_json.clone());
+      vm
+    },
+    |vm| vm.run(None),
+  );
 }
-fn custom_config() -> Criterion {
-  Criterion::default()
-    .sample_size(300)
-    .measurement_time(Duration::from_secs(15))
-    .warm_up_time(Duration::from_secs(3))
-}
-criterion_group! {
-  name = benches;
-  config = custom_config();
-  targets = bench_vm_execution
-}
-criterion_main!(benches);
diff --git a/rust/benches/optimize/dead_code_bench.rs b/rust/benches/optimize/dead_code_bench.rs
index 67428a81..c72db9c8 100644
--- a/rust/benches/optimize/dead_code_bench.rs
+++ b/rust/benches/optimize/dead_code_bench.rs
@@ -8,11 +8,14 @@
  * http://www.apache.org/licenses/LICENSE-2.0
  */
 
-use criterion::{Bencher, Criterion, criterion_group, criterion_main};
 use lightvm::{LightVM, types::capability::Capability};
-use std::time::Duration;
-fn bench_vm_execution(c: &mut Criterion) {
-  let mut vm = LightVM::new(vec![Capability::Control, Capability::Observe]);
+fn main() {
+  let capabilities = vec![
+    Capability::Control,
+    Capability::Debug,
+    Capability::Observe,
+  ];
+  let mut vm = LightVM::new(capabilities.clone());
   let raw = r#"[
     ["push", 5],
     ["push", 8],
@@ -21,23 +24,17 @@ fn bench_vm_execution(c: &mut Criterion) {
     ["push", 9],
     ["set", "x"]
   ]"#;
-  let optimized_json = LightVM::tools().optimize_bytecode(raw);
-  vm.load(optimized_json.clone());
-  let mut group = c.benchmark_group("LightVM Execution");
-  group.bench_function("dead_code_bench", |b: &mut Bencher| {
-    b.iter(|| vm.run(None));
-  });
-  group.finish();
+  let tools = vm.tools();
+  let optimized_json = tools.optimize_bytecode(raw);
+  let benchmark = tools
+    .bench("dead_code_bench")
+    .expect("benchmark requires debug capability");
+  benchmark.run(
+    || {
+      let mut vm = LightVM::new(capabilities.clone());
+      vm.load(optimized_json.clone());
+      vm
+    },
+    |vm| vm.run(None),
+  );
 }
-fn custom_config() -> Criterion {
-  Criterion::default()
-    .sample_size(300)
-    .measurement_time(Duration::from_secs(15))
-    .warm_up_time(Duration::from_secs(3))
-}
-criterion_group! {
-  name = benches;
-  config = custom_config();
-  targets = bench_vm_execution
-}
-criterion_main!(benches);
diff --git a/rust/benches/optimize/io_bench.rs b/rust/benches/optimize/io_bench.rs
index 839019b9..567486a9 100644
--- a/rust/benches/optimize/io_bench.rs
+++ b/rust/benches/optimize/io_bench.rs
@@ -8,32 +8,27 @@
  * http://www.apache.org/licenses/LICENSE-2.0
  */
 
-use criterion::{Bencher, Criterion, criterion_group, criterion_main};
 use lightvm::{LightVM, types::capability::Capability};
-use std::time::Duration;
-fn bench_vm_execution(c: &mut Criterion) {
-  let mut vm = LightVM::new(vec![Capability::Control, Capability::Observe]);
+fn main() {
+  let capabilities = vec![
+    Capability::Control,
+    Capability::Debug,
+    Capability::Observe,
+  ];
+  let mut vm = LightVM::new(capabilities.clone());
   let raw = r#"[["push", "Hello from LightVM!"], ["println"]]"#;
-  let optimized_json = LightVM::tools().optimize_bytecode(raw);
-  vm.load(optimized_json.clone());
-  let mut group = c.benchmark_group("LightVM Execution");
-  group.bench_function("io_bench", |b: &mut Bencher| {
-    b.iter(|| {
+  let tools = vm.tools();
+  let optimized_json = tools.optimize_bytecode(raw);
+  let benchmark = tools.bench("io_bench").expect("benchmark requires debug capability");
+  benchmark.run(
+    || {
+      let mut vm = LightVM::new(capabilities.clone());
+      vm.load(optimized_json.clone());
+      vm
+    },
+    |vm| {
       let _sink = std::io::sink();
       vm.run(None)
-    });
-  });
-  group.finish();
+    },
+  );
 }
-fn custom_config() -> Criterion {
-  Criterion::default()
-    .sample_size(300)
-    .measurement_time(Duration::from_secs(15))
-    .warm_up_time(Duration::from_secs(3))
-}
-criterion_group! {
-  name = benches;
-  config = custom_config();
-  targets = bench_vm_execution
-}
-criterion_main!(benches);