add benchmarks

Author: lucarlig

Cargo.toml

@@ -7,3 +7,6 @@ edition = "2021"
 
 [[bench]]
 name = "bench"
+
+[profile.bench]
+opt-level = 0

benches/bench.rs

@@ -1,9 +1,9 @@
 #![feature(test)]
+
 extern crate test;
 
 use speculate::*;
-use std::sync::mpsc;
-use std::sync::Arc;
+use std::sync::{mpsc, Arc};
 use test::{black_box, Bencher};
 
 #[bench]
@@ -17,26 +17,113 @@ fn bench_direct_2048(b: &mut Bencher) {
 }
 
 #[bench]
-async fn test_spec_correct_2048() {
-    let (sender, receiver) = mpsc::channel::<Option<(usize, isize)>>(10);
-    let (res_sender, res_receiver) = mpsc::channel::<Vec<isize>>(1);
+fn test_spec_correct_2048(b: &mut Bencher) {
+    let v = (0..2048).collect::<Vec<_>>();
+    let v_arc = Arc::new(v);
 
-    // Assuming the receiver is processed elsewhere and not directly within the closures
-    let processed_data = process_receiver_data(&receiver); // Pseudocode
+    b.iter(|| {
+        let (tx, rx) = mpsc::channel();
+        let (tx2, rx2) = mpsc::channel();
+        tx.send(v_arc.clone()).unwrap();
+        tx2.send(v_arc.clone()).unwrap();
 
-    let loop_body = Arc::new(move |idx: usize, val: isize| -> isize {
-        // Use processed data instead of directly accessing the receiver
-        val + 1 // Example operation
+        spec(
+            move || {
+                let local_arc = rx.recv().unwrap();
+                local_arc.iter().fold(0, |old, &new| old + new)
+            },
+            || 2096128,
+            move |x| {
+                let local_arc = rx2.recv().unwrap();
+                local_arc.iter().fold(x, |old, &new| old + new)
+            },
+        );
     });
+}
+
+#[bench]
+fn bench_spec_wrong_2048(b: &mut Bencher) {
+    let v = (0..2048).collect::<Vec<_>>();
+    let v_arc = Arc::new(v);
+
+    b.iter(|| {
+        let (tx, rx) = mpsc::channel();
+        let (tx2, rx2) = mpsc::channel();
+        tx.send(v_arc.clone()).unwrap();
+        tx2.send(v_arc.clone()).unwrap();
+        tx2.send(v_arc.clone()).unwrap();
 
-    let predictor = Arc::new(move |idx: usize| -> isize {
-        idx as isize * 2 // Directly return a prediction
+        spec(
+            move || {
+                let local_arc = rx.recv().unwrap();
+                local_arc.iter().fold(0, |old, &new| old + new)
+            },
+            || 0, // Incorrect result of `fold`
+            move |x| {
+                let local_arc = rx2.recv().unwrap();
+                local_arc.iter().fold(x, |old, &new| old + new)
+            },
+        );
     });
+}
 
-    // Assuming spec is properly defined to accept the closures
-    spec(5, loop_body, predictor).await;
+#[bench]
+fn bench_direct_65536(b: &mut Bencher) {
+    let v: Vec<usize> = (0..65536).collect();
+    b.iter(|| {
+        // Use black_box to prevent compiler optimizations regarding these computations
+        let val = v.iter().fold(0, |old, new| old + *new);
+        black_box(v.iter().fold(val, |old, new| old + *new));
+    });
+}
+
+#[bench]
+fn bench_spec_correct_65536(b: &mut Bencher) {
+    let v = (0..65536).collect::<Vec<_>>();
+    let v_arc = Arc::new(v);
 
-    // Example operations
-    sender.send(None).await.unwrap();
-    let results = res_receiver.recv().await.unwrap();
+    b.iter(|| {
+        let (tx, rx) = mpsc::channel();
+        let (tx2, rx2) = mpsc::channel();
+        tx.send(v_arc.clone()).unwrap();
+        tx2.send(v_arc.clone()).unwrap();
+
+        spec(
+            move || {
+                let local_arc = rx.recv().unwrap();
+                local_arc.iter().fold(0, |old, &new| old + new)
+            },
+            || 2147450880,
+            move |x| {
+                let local_arc = rx2.recv().unwrap();
+                local_arc.iter().fold(x, |old, &new| old + new)
+            },
+        );
+    });
+}
+
+#[bench]
+fn bench_spec_wrong_65536(b: &mut Bencher) {
+    let v = (0..65536).collect::<Vec<_>>();
+    let v_arc = Arc::new(v);
+
+    b.iter(|| {
+        let (tx, rx) = mpsc::channel();
+        let (tx2, rx2) = mpsc::channel();
+        tx.send(v_arc.clone()).unwrap();
+        tx2.send(v_arc.clone()).unwrap();
+        tx2.send(v_arc.clone()).unwrap();
+
+        spec(
+            move || {
+                let local_arc = rx.recv().unwrap();
+                local_arc.iter().fold(0, |old, &new| old + new)
+            },
+            || 0, // Incorrect result of `fold`
+            move |x| {
+                let local_arc = rx2.recv().unwrap();
+                local_arc.iter().fold(x, |old, &new| old + new)
+            },
+        );
+    });
 }