[eclipse-iceoryx#139] Adjust benchmark; add small optimization

Author: elfenpiff

benchmarks/mpmc-bitset/src/main.rs

@@ -19,7 +19,7 @@ struct Config {
     iterations: usize,
 }
 
-fn perform_benchmark(config: Config) {
+fn perform_benchmark_reset_all(config: Config) {
     let sut_a_b = BitSet::new(config.capacity);
     let sut_b_a = BitSet::new(config.capacity);
     // worst case bit - iterate over all bitset to see if its set
@@ -64,7 +64,50 @@ fn perform_benchmark(config: Config) {
 
         let stop = start.elapsed();
         println!(
-            "Capacity: {}, Iterations: {}, Time: {}, Latency: {} ns",
+            "Bitset::reset_all()  ::: Capacity: {}, Iterations: {}, Time: {}, Latency: {} ns",
+            config.capacity,
+            config.iterations,
+            stop.as_secs_f64(),
+            stop.as_nanos() / (config.iterations as u128 * 2)
+        );
+    });
+}
+
+fn perform_benchmark_reset_next(config: Config) {
+    let sut_a_b = BitSet::new(config.capacity);
+    let sut_b_a = BitSet::new(config.capacity);
+    let bit = 0;
+    let barrier = Barrier::new(3);
+
+    std::thread::scope(|s| {
+        let t1 = s.spawn(|| {
+            barrier.wait();
+            sut_a_b.set(bit);
+
+            for _ in 0..config.iterations {
+                while sut_b_a.reset_next().is_none() {}
+                sut_a_b.set(bit);
+            }
+        });
+
+        let t2 = s.spawn(|| {
+            barrier.wait();
+            for _ in 0..config.iterations {
+                while sut_a_b.reset_next().is_none() {}
+                sut_b_a.set(bit);
+            }
+        });
+
+        std::thread::sleep(std::time::Duration::from_millis(100));
+        let start = Instant::now();
+        barrier.wait();
+
+        t1.join().expect("thread failure");
+        t2.join().expect("thread failure");
+
+        let stop = start.elapsed();
+        println!(
+            "Bitset::reset_next() ::: Capacity: {}, Iterations: {}, Time: {}, Latency: {} ns",
             config.capacity,
             config.iterations,
             stop.as_secs_f64(),
@@ -74,8 +117,13 @@ fn perform_benchmark(config: Config) {
 }
 
 fn main() {
-    perform_benchmark(Config {
+    perform_benchmark_reset_all(Config {
         capacity: 256,
-        iterations: 1000000,
-    })
+        iterations: 2000000,
+    });
+
+    perform_benchmark_reset_next(Config {
+        capacity: 256,
+        iterations: 2000000,
+    });
 }

iceoryx2-bb/lock-free/src/mpmc/bit_set.rs

@@ -39,7 +39,7 @@
 use std::{
     alloc::Layout,
     fmt::Debug,
-    sync::atomic::{AtomicBool, AtomicU8, Ordering},
+    sync::atomic::{AtomicBool, AtomicIsize, AtomicU8, AtomicUsize, Ordering},
 };
 
 use iceoryx2_bb_elementary::{
@@ -59,7 +59,6 @@ pub type RelocatableBitSet = details::BitSet<RelocatablePointer<details::BitsetE
 
 #[doc(hidden)]
 pub mod details {
-    use std::sync::atomic::AtomicUsize;
 
     use super::*;
 
@@ -87,7 +86,7 @@ pub mod details {
         capacity: usize,
         array_capacity: usize,
         reset_position: AtomicUsize,
-        active_bits: AtomicUsize,
+        active_bits: AtomicIsize,
         is_memory_initialized: AtomicBool,
     }
 
@@ -115,7 +114,7 @@ pub mod details {
                 array_capacity,
                 is_memory_initialized: AtomicBool::new(true),
                 reset_position: AtomicUsize::new(0),
-                active_bits: AtomicUsize::new(0),
+                active_bits: AtomicIsize::new(0),
             }
         }
     }
@@ -128,7 +127,7 @@ pub mod details {
                 array_capacity: Self::array_capacity(capacity),
                 is_memory_initialized: AtomicBool::new(false),
                 reset_position: AtomicUsize::new(0),
-                active_bits: AtomicUsize::new(0),
+                active_bits: AtomicIsize::new(0),
             }
         }
 
@@ -176,7 +175,7 @@ pub mod details {
                 array_capacity: Self::array_capacity(capacity),
                 is_memory_initialized: AtomicBool::new(true),
                 reset_position: AtomicUsize::new(0),
-                active_bits: AtomicUsize::new(0),
+                active_bits: AtomicIsize::new(0),
             }
         }
     }
@@ -277,14 +276,17 @@ pub mod details {
         /// [`None`].
         pub fn reset_next(&self) -> Option<usize> {
             self.verify_init("reset_next");
-            if self.active_bits.load(Ordering::Relaxed) == 0 {
+            let active_bits = self.active_bits.load(Ordering::Relaxed);
+            if active_bits <= 0 {
                 return None;
             }
 
             let current_position = self.reset_position.load(Ordering::Relaxed);
             for pos in (current_position..self.capacity).chain(0..current_position) {
                 if self.clear_bit(Id::new(pos)) {
-                    self.reset_position.store(pos + 1, Ordering::Relaxed);
+                    if active_bits != 1 {
+                        self.reset_position.store(pos + 1, Ordering::Relaxed);
+                    }
                     return Some(pos);
                 }
             }
@@ -308,7 +310,7 @@ pub mod details {
                     }
                 }
 
-                if self.active_bits.fetch_sub(counter, Ordering::Relaxed) == counter {
+                if self.active_bits.fetch_sub(counter, Ordering::Relaxed) <= counter {
                     return;
                 }
             }