[eclipse-iceoryx#139] Add and test bitset reset_next

Author: elfenpiff

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

@@ -61,6 +61,8 @@ pub type BitSet = details::BitSet<OwningPointer<BitsetElement>>;
 pub type RelocatableBitSet = details::BitSet<RelocatablePointer<BitsetElement>>;
 
 pub mod details {
+    use std::sync::atomic::AtomicUsize;
+
     use super::*;
 
     #[derive(Debug)]
@@ -69,6 +71,7 @@ pub mod details {
         data_ptr: PointerType,
         capacity: usize,
         array_capacity: usize,
+        reset_position: AtomicUsize,
         is_memory_initialized: AtomicBool,
     }
 
@@ -95,6 +98,7 @@ pub mod details {
                 capacity,
                 array_capacity,
                 is_memory_initialized: AtomicBool::new(true),
+                reset_position: AtomicUsize::new(0),
             }
         }
     }
@@ -106,6 +110,7 @@ pub mod details {
                 capacity,
                 array_capacity: Self::array_capacity(capacity),
                 is_memory_initialized: AtomicBool::new(false),
+                reset_position: AtomicUsize::new(0),
             }
         }
 
@@ -152,6 +157,7 @@ pub mod details {
                 capacity,
                 array_capacity: Self::array_capacity(capacity),
                 is_memory_initialized: AtomicBool::new(true),
+                reset_position: AtomicUsize::new(0),
             }
         }
     }
@@ -180,7 +186,10 @@ pub mod details {
             );
         }
 
-        fn set_bit(&self, index: usize, bit: usize) -> bool {
+        fn set_bit(&self, id: usize) -> bool {
+            let index = id / BITSET_ELEMENT_BITSIZE;
+            let bit = id % BITSET_ELEMENT_BITSIZE;
+
             let data_ref = unsafe { &(*self.data_ptr.as_ptr().add(index)) };
             let mut current = data_ref.load(Ordering::Relaxed);
             let bit = 1 << bit;
@@ -204,7 +213,36 @@ pub mod details {
             }
         }
 
+        fn clear_bit(&self, id: usize) -> bool {
+            let index = id / BITSET_ELEMENT_BITSIZE;
+            let bit = id % BITSET_ELEMENT_BITSIZE;
+
+            let data_ref = unsafe { &(*self.data_ptr.as_ptr().add(index)) };
+            let mut current = data_ref.load(Ordering::Relaxed);
+            let bit = 1 << bit;
+
+            loop {
+                if current & bit == 0 {
+                    return false;
+                }
+
+                let current_with_bit = current & !bit;
+
+                match data_ref.compare_exchange(
+                    current,
+                    current_with_bit,
+                    Ordering::Relaxed,
+                    Ordering::Relaxed,
+                ) {
+                    Ok(_) => return true,
+                    Err(v) => current = v,
+                }
+            }
+        }
+
         /// Sets a bit in the BitSet
+        /// If the bit was successfully set it returns true, if the bit was already set it
+        /// returns false.
         pub fn set(&self, id: usize) -> bool {
             self.verify_init("set");
             debug_assert!(
@@ -213,14 +251,29 @@ pub mod details {
                 id
             );
 
-            let bitset_index = id / BITSET_ELEMENT_BITSIZE;
-            let bit = id % BITSET_ELEMENT_BITSIZE;
-            self.set_bit(bitset_index, bit)
+            self.set_bit(id)
+        }
+
+        /// Resets the next set bit and returns the bit index. If no bit was set it returns
+        /// [`None`].
+        pub fn reset_next(&self) -> Option<usize> {
+            let mut current_position = self.reset_position.load(Ordering::Relaxed);
+            for _ in 0..self.capacity {
+                current_position = (current_position + 1) % self.capacity;
+
+                if self.clear_bit(current_position) {
+                    self.reset_position
+                        .store(current_position, Ordering::Relaxed);
+                    return Some(current_position);
+                }
+            }
+
+            None
         }
 
         /// Reset every set bit in the BitSet and call the provided callback for every bit that
-        /// was set.
-        pub fn reset<F: FnMut(usize)>(&self, mut callback: F) {
+        /// was set. This is the most efficient way to acquire all bits that were set.
+        pub fn reset_all<F: FnMut(usize)>(&self, mut callback: F) {
             self.verify_init("set");
             for i in 0..self.array_capacity {
                 let value = unsafe { (*self.data_ptr.as_ptr().add(i)).swap(0, Ordering::Relaxed) };
@@ -282,7 +335,13 @@ impl<const CAPACITY: usize> FixedSizeBitSet<CAPACITY> {
 
     /// Reset every set bit in the BitSet and call the provided callback for every bit that
     /// was set.
-    pub fn reset<F: FnMut(usize)>(&self, callback: F) {
-        self.bitset.reset(callback)
+    pub fn reset_next(&self) -> Option<usize> {
+        self.bitset.reset_next()
+    }
+
+    /// Reset every set bit in the BitSet and call the provided callback for every bit that
+    /// was set.
+    pub fn reset_all<F: FnMut(usize)>(&self, callback: F) {
+        self.bitset.reset_all(callback)
     }
 }

iceoryx2-bb/lock-free/tests/bitset_tests.rs

@@ -37,7 +37,7 @@ fn bit_set_create_fill_and_reset_works() {
 
     let mut id_set = HashSet::new();
     let mut counter = 0;
-    sut.reset(|id| {
+    sut.reset_all(|id| {
         assert_that!(id, lt CAPACITY);
         assert_that!(id_set.insert(id), eq true);
         counter += 1;
@@ -46,7 +46,7 @@ fn bit_set_create_fill_and_reset_works() {
     assert_that!(counter, eq CAPACITY);
 
     let mut counter = 0;
-    sut.reset(|_| {
+    sut.reset_all(|_| {
         counter += 1;
     });
 
@@ -67,7 +67,7 @@ fn fixed_size_bit_set_create_fill_and_reset_works() {
 
     let mut id_set = HashSet::new();
     let mut counter = 0;
-    sut.reset(|id| {
+    sut.reset_all(|id| {
         assert_that!(id % 2 == 0, eq true);
         assert_that!(id, lt CAPACITY);
         assert_that!(id_set.insert(id), eq true);
@@ -77,7 +77,7 @@ fn fixed_size_bit_set_create_fill_and_reset_works() {
     assert_that!(counter, eq CAPACITY / 2);
 
     let mut counter = 0;
-    sut.reset(|_| {
+    sut.reset_all(|_| {
         counter += 1;
     });
 
@@ -92,12 +92,12 @@ fn bit_set_set_single_bit_works() {
     assert_that!(sut.set(55), eq true);
     assert_that!(sut.set(55), eq false);
 
-    sut.reset(|id| {
+    sut.reset_all(|id| {
         assert_that!(id, eq 55);
     });
 
     let mut counter = 0;
-    sut.reset(|_| {
+    sut.reset_all(|_| {
         counter += 1;
     });
 
@@ -113,6 +113,39 @@ fn bit_set_set_bit_outside_of_bitset_leads_to_panic() {
     sut.set(CAPACITY);
 }
 
+#[test]
+fn bit_set_set_and_reset_next_works() {
+    const CAPACITY: usize = 1551;
+    let sut = BitSet::new(CAPACITY);
+
+    assert_that!(sut.reset_next(), eq None);
+    for i in 0..CAPACITY {
+        assert_that!(sut.set(i), eq true);
+        assert_that!(sut.reset_next(), eq Some(i));
+    }
+    assert_that!(sut.reset_next(), eq None);
+}
+
+#[test]
+fn bit_set_reset_next_is_fair() {
+    const CAPACITY: usize = 1551;
+    let sut = BitSet::new(CAPACITY);
+
+    assert_that!(sut.set(0), eq true);
+    assert_that!(sut.reset_next(), eq Some(0));
+
+    for i in 1..CAPACITY {
+        assert_that!(sut.set(i - 1), eq true);
+        assert_that!(sut.set(i), eq true);
+        assert_that!(sut.reset_next(), eq Some(i));
+    }
+
+    for i in 0..CAPACITY - 1 {
+        assert_that!(sut.reset_next(), eq Some(i));
+    }
+    assert_that!(sut.reset_next(), eq None);
+}
+
 #[test]
 fn bit_set_concurrent_set_and_reset_works() {
     let _watchdog = Watchdog::new(Duration::from_secs(10));
@@ -154,12 +187,12 @@ fn bit_set_concurrent_set_and_reset_works() {
 
                 barrier.wait();
                 while keep_running.load(Ordering::Relaxed) {
-                    sut.reset(|id| {
+                    sut.reset_all(|id| {
                         id_counter[id] += 1;
                     });
                 }
 
-                sut.reset(|id| {
+                sut.reset_all(|id| {
                     id_counter[id] += 1;
                 });