[eclipse-iceoryx#139] Provide id tracker impl

Author: elfenpiff

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

@@ -52,19 +52,20 @@ use iceoryx2_bb_elementary::{
 
 use iceoryx2_bb_log::{fail, fatal_panic};
 
-type BitsetElement = AtomicU8;
-const BITSET_ELEMENT_BITSIZE: usize = core::mem::size_of::<BitsetElement>() * 8;
-
 /// This BitSet variant's data is stored in the heap.
-pub type BitSet = details::BitSet<OwningPointer<BitsetElement>>;
+pub type BitSet = details::BitSet<OwningPointer<details::BitsetElement>>;
 /// This BitSet variant can be stored inside shared memory.
-pub type RelocatableBitSet = details::BitSet<RelocatablePointer<BitsetElement>>;
+pub type RelocatableBitSet = details::BitSet<RelocatablePointer<details::BitsetElement>>;
 
+#[doc(hidden)]
 pub mod details {
     use std::sync::atomic::AtomicUsize;
 
     use super::*;
 
+    pub type BitsetElement = AtomicU8;
+    const BITSET_ELEMENT_BITSIZE: usize = core::mem::size_of::<BitsetElement>() * 8;
+
     #[derive(Debug)]
     #[repr(C)]
     pub struct BitSet<PointerType: PointerTrait<BitsetElement>> {
@@ -295,9 +296,9 @@ pub struct FixedSizeBitSet<const CAPACITY: usize> {
     bitset: RelocatableBitSet,
     // TODO: we waste here some memory since rust does us not allow to perform const operations
     //       on generic parameters. Whenever this is supported, change this line into
-    //       data: [BitsetElement; Self::array_capacity(CAPACITY)]
+    //       data: [`details::BitsetElement; Self::array_capacity(CAPACITY)`]
     //       For now we can live with it, since the bitsets are usually rather small
-    data: [BitsetElement; CAPACITY],
+    data: [details::BitsetElement; CAPACITY],
 }
 
 unsafe impl<const CAPACITY: usize> Send for FixedSizeBitSet<CAPACITY> {}
@@ -309,10 +310,11 @@ impl<const CAPACITY: usize> Default for FixedSizeBitSet<CAPACITY> {
             bitset: unsafe {
                 RelocatableBitSet::new(
                     CAPACITY,
-                    align_to::<BitsetElement>(std::mem::size_of::<RelocatableBitSet>()) as _,
+                    align_to::<details::BitsetElement>(std::mem::size_of::<RelocatableBitSet>())
+                        as _,
                 )
             },
-            data: core::array::from_fn(|_| BitsetElement::new(0)),
+            data: core::array::from_fn(|_| details::BitsetElement::new(0)),
         }
     }
 }

iceoryx2-cal/Cargo.toml

@@ -32,4 +32,5 @@ ouroboros = { workspace = true }
 
 [dev-dependencies]
 iceoryx2-pal-posix = { workspace = true }
+pin-init = { workspace = true }
 generic-tests = { workspace = true }

iceoryx2-cal/src/event/id_tracker/bitset.rs renamed to iceoryx2-cal/src/event/id_tracker/bit_set.rs

@@ -10,21 +10,25 @@
 //
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 
-use iceoryx2_bb_lock_free::mpmc::bit_set::RelocatableBitSet;
+use std::fmt::Debug;
+
+use iceoryx2_bb_elementary::relocatable_ptr::PointerTrait;
+use iceoryx2_bb_lock_free::mpmc::bit_set::details::*;
 use iceoryx2_bb_log::fail;
 
 use super::IdTracker;
 use crate::event::{NotifierNotifyError, TriggerId};
 
-impl IdTracker for RelocatableBitSet {
+impl<PointerType: PointerTrait<BitsetElement> + Debug> IdTracker for BitSet<PointerType> {
     fn trigger_id_max(&self) -> TriggerId {
         TriggerId::new(self.capacity() as u64)
     }
 
     fn add(&self, id: TriggerId) -> Result<(), NotifierNotifyError> {
-        if self.trigger_id_max() >= id {
+        if self.trigger_id_max() <= id {
             fail!(from self, with NotifierNotifyError::TriggerIdOutOfBounds,
-                "Unable to set bit {:?} since it is out of bounds.", id);
+                "Unable to set bit {:?} since it is out of bounds (max = {:?}).",
+                id, self.trigger_id_max());
         }
         self.set(id.as_u64() as usize);
 

iceoryx2-cal/src/event/id_tracker/mod.rs

@@ -10,13 +10,11 @@
 //
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 
-pub mod bitset;
-pub mod queue;
+pub mod bit_set;
 
 use super::{NotifierNotifyError, TriggerId};
-use iceoryx2_bb_elementary::relocatable_container::RelocatableContainer;
 
-pub trait IdTracker: RelocatableContainer {
+pub trait IdTracker: Send + Sync {
     fn trigger_id_max(&self) -> TriggerId;
     fn add(&self, id: TriggerId) -> Result<(), NotifierNotifyError>;
     fn acquire(&self) -> Option<TriggerId>;

iceoryx2-cal/src/event/id_tracker/queue.rs

@@ -80,7 +80,7 @@ impl std::fmt::Display for ListenerCreateError {
 
 impl std::error::Error for ListenerCreateError {}
 
-#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct TriggerId(u64);
 
 impl TriggerId {

iceoryx2-cal/src/event/mod.rs

@@ -0,0 +1,126 @@
+// 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
+
+#[generic_tests::define]
+mod event_id_tracker {
+    use std::collections::HashSet;
+
+    use iceoryx2_bb_lock_free::mpmc::bit_set::BitSet;
+    use iceoryx2_bb_testing::assert_that;
+    use iceoryx2_cal::event::{id_tracker::IdTracker, TriggerId};
+
+    trait NewSut {
+        fn new_sut(capacity: usize) -> Self;
+    }
+
+    impl NewSut for BitSet {
+        fn new_sut(capacity: usize) -> Self {
+            BitSet::new(capacity)
+        }
+    }
+    #[test]
+    fn max_trigger_id_must_be_at_least_capacity<Sut: IdTracker + NewSut>() {
+        const CAPACITY: usize = 5234;
+
+        let sut = Sut::new_sut(CAPACITY);
+        assert_that!(sut.trigger_id_max().as_u64(), ge CAPACITY as u64);
+    }
+
+    #[test]
+    fn add_and_acquire_works<Sut: IdTracker + NewSut>() {
+        const CAPACITY: usize = 1234;
+
+        let sut = Sut::new_sut(CAPACITY);
+
+        assert_that!(sut.acquire(), eq None);
+        for i in 0..CAPACITY {
+            let id = TriggerId::new(i as u64);
+            assert_that!(sut.add(id), is_ok);
+            assert_that!(sut.acquire(), eq Some(id));
+            assert_that!(sut.acquire(), is_none);
+        }
+    }
+
+    #[test]
+    fn add_until_full_and_then_acquire_works<Sut: IdTracker + NewSut>() {
+        const CAPACITY: usize = 1234;
+
+        let sut = Sut::new_sut(CAPACITY);
+
+        for i in 0..CAPACITY {
+            let id = TriggerId::new((i as u64).min(sut.trigger_id_max().as_u64()));
+            assert_that!(sut.add(id), is_ok);
+        }
+
+        let mut ids = HashSet::new();
+        for _ in 0..CAPACITY {
+            let result = sut.acquire().unwrap();
+            assert_that!(result, le sut.trigger_id_max());
+            assert_that!(ids.insert(result), eq true);
+        }
+
+        assert_that!(sut.acquire(), is_none);
+    }
+
+    #[test]
+    fn add_and_acquire_all_works<Sut: IdTracker + NewSut>() {
+        const CAPACITY: usize = 3234;
+
+        let sut = Sut::new_sut(CAPACITY);
+
+        for i in 0..CAPACITY {
+            let id = TriggerId::new((i as u64).min(sut.trigger_id_max().as_u64()));
+            assert_that!(sut.add(id), is_ok);
+        }
+
+        let mut ids = HashSet::new();
+        sut.acquire_all(|id| {
+            assert_that!(id, le sut.trigger_id_max());
+            assert_that!(ids.insert(id), eq true);
+        });
+
+        let mut callback_called = false;
+        sut.acquire_all(|_| callback_called = true);
+        assert_that!(callback_called, eq false);
+
+        assert_that!(ids, len CAPACITY);
+    }
+
+    #[test]
+    fn add_acquire_and_acquire_all_works<Sut: IdTracker + NewSut>() {
+        const CAPACITY: usize = 234;
+
+        let sut = Sut::new_sut(CAPACITY);
+
+        for i in 0..CAPACITY {
+            let id = TriggerId::new((i as u64).min(sut.trigger_id_max().as_u64()));
+            assert_that!(sut.add(id), is_ok);
+        }
+
+        let mut ids = HashSet::new();
+        for _ in 0..CAPACITY / 2 {
+            let result = sut.acquire().unwrap();
+            assert_that!(result, le sut.trigger_id_max());
+            assert_that!(ids.insert(result), eq true);
+        }
+
+        sut.acquire_all(|id| {
+            assert_that!(id, le sut.trigger_id_max());
+            assert_that!(ids.insert(id), eq true);
+        });
+
+        assert_that!(ids, len CAPACITY);
+    }
+
+    #[instantiate_tests(<BitSet>)]
+    mod bitset {}
+}