[eclipse-iceoryx#139] Add bitset benchmark

Author: elfenpiff

Cargo.toml

@@ -20,7 +20,8 @@ members = [
 
     "examples",
 
-    "benchmarks/publish-subscribe"
+    "benchmarks/publish-subscribe",
+    "benchmarks/mpmc-bitset"
 ]
 
 [workspace.package]

benchmarks/mpmc-bitset/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "mpmc-bitset-benchmark"
+description = "iceoryx2: [internal] benchmark for the mpmc::bitset"
+categories = { workspace = true }
+edition = { workspace = true }
+homepage = { workspace = true }
+keywords = { workspace = true }
+license = { workspace = true }
+repository = { workspace = true }
+rust-version = { workspace = true }
+version = { workspace = true }
+
+[dependencies]
+iceoryx2-bb-lock-free = { workspace = true }

benchmarks/mpmc-bitset/src/main.rs

@@ -0,0 +1,81 @@
+// Copyright (c) 2024 Contributors to the Eclipse Foundation
+//
+// See the NOTICE file(s) distributed with this work for additional
+// information regarding copyright ownership.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Apache Software License 2.0 which is available at
+// https://www.apache.org/licenses/LICENSE-2.0, or the MIT license
+// which is available at https://opensource.org/licenses/MIT.
+//
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use std::{sync::Barrier, time::Instant};
+
+use iceoryx2_bb_lock_free::mpmc::bit_set::BitSet;
+
+struct Config {
+    capacity: usize,
+    iterations: usize,
+}
+
+fn perform_benchmark(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
+    let bit = config.capacity - 1;
+    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 {
+                let mut has_update = false;
+                while !has_update {
+                    sut_b_a.reset_all(|_| {
+                        has_update = true;
+                    });
+                }
+                sut_a_b.set(bit);
+            }
+        });
+
+        let t2 = s.spawn(|| {
+            barrier.wait();
+            for _ in 0..config.iterations {
+                let mut has_update = false;
+                while !has_update {
+                    sut_a_b.reset_all(|_| {
+                        has_update = true;
+                    });
+                }
+                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!(
+            "Capacity: {}, Iterations: {}, Time: {}, Latency: {} ns",
+            config.capacity,
+            config.iterations,
+            stop.as_secs_f64(),
+            stop.as_nanos() / (config.iterations as u128 * 2)
+        );
+    });
+}
+
+fn main() {
+    perform_benchmark(Config {
+        capacity: 256,
+        iterations: 1000000,
+    })
+}