[#1178] Add loom test setup

Cargo.toml

@@ -122,6 +122,7 @@ human-panic = { version = "2.0.2" }
 lazy_static = { version = "1.4.0" }
 libc = { version = "0.2.169", features = ['extra_traits'] }
 log = { version = "0.4.21" }
+loom = { version = "0.7.2" }
 once_cell = { version = "1.19.0" }
 postcard = { version = "1.1.3", default-features = false, features = ["alloc"] }
 proc-macro2 = { version = "1.0.84" }
@@ -164,3 +165,8 @@ strip = true
 lto = true
 # opt-level = "z"
 panic = "abort"
+
+[workspace.lints.rust]
+unexpected_cfgs = { level = "warn", check-cfg = [
+  'cfg(loom)',
+] }

iceoryx2-bb/elementary/Cargo.toml

@@ -10,6 +10,9 @@ repository = { workspace = true }
 rust-version = { workspace = true }
 version = { workspace = true }
 
+[lints]
+workspace = true
+
 [dependencies]
 iceoryx2-bb-elementary-traits = { workspace = true }
 iceoryx2-pal-concurrency-sync = { workspace = true }

iceoryx2-bb/elementary/src/lazy_singleton.rs

@@ -55,6 +55,7 @@ impl<T> Default for LazySingleton<T> {
 
 impl<T> LazySingleton<T> {
     /// Creates a new [`LazySingleton`] where the underlying value is not yet initialized.
+    #[cfg(not(all(test, loom)))]
     pub const fn new() -> Self {
         Self {
             data: UnsafeCell::new(None),
@@ -63,6 +64,16 @@ impl<T> LazySingleton<T> {
         }
     }
 
+    /// Creates a new [`LazySingleton`] where the underlying value is not yet initialized.
+    #[cfg(all(test, loom))]
+    pub fn new() -> Self {
+        Self {
+            data: UnsafeCell::new(None),
+            is_initialized: IoxAtomicBool::new(false),
+            is_finalized: IoxAtomicBool::new(false),
+        }
+    }
+
     /// Returns true if the underlying value was initialized, otherwise false.
     pub fn is_initialized(&self) -> bool {
         self.is_initialized.load(Ordering::Relaxed)

iceoryx2-bb/elementary/src/unique_id.rs

@@ -75,7 +75,12 @@ pub struct UniqueId {
 
 impl Default for UniqueId {
     fn default() -> Self {
+        #[cfg(not(all(test, loom)))]
         static COUNTER: IoxAtomicU64 = IoxAtomicU64::new(0);
+        #[cfg(all(test, loom))]
+        static COUNTER: std::sync::LazyLock<IoxAtomicU64> = std::sync::LazyLock::new(|| {
+            unimplemented!("loom does not provide const-initialization for atomic variables.")
+        });
 
         UniqueId {
             value: COUNTER.fetch_add(1, Ordering::Relaxed),
@@ -105,7 +110,12 @@ pub struct TypedUniqueId<T> {
 
 impl<T> Default for TypedUniqueId<T> {
     fn default() -> Self {
+        #[cfg(not(all(test, loom)))]
         static COUNTER: IoxAtomicU64 = IoxAtomicU64::new(0);
+        #[cfg(all(test, loom))]
+        static COUNTER: std::sync::LazyLock<IoxAtomicU64> = std::sync::LazyLock::new(|| {
+            unimplemented!("loom does not provide const-initialization for atomic variables.")
+        });
 
         Self {
             value: COUNTER.fetch_add(1, Ordering::Relaxed),

iceoryx2-bb/lock-free/Cargo.toml

@@ -10,6 +10,9 @@ repository = { workspace = true }
 rust-version = { workspace = true }
 version = { workspace = true }
 
+[lints]
+workspace = true
+
 [dependencies]
 iceoryx2-bb-log = { workspace = true }
 iceoryx2-bb-elementary = { workspace = true }
@@ -21,3 +24,6 @@ iceoryx2-bb-posix = { workspace = true }
 iceoryx2-bb-testing = { workspace = true }
 iceoryx2-pal-testing = { workspace = true }
 generic-tests = { workspace = true }
+
+[target.'cfg(loom)'.dev-dependencies]
+loom = { workspace = true }

iceoryx2-bb/lock-free/src/spsc/index_queue.rs

@@ -42,16 +42,21 @@
 //! }
 //! ```
 
-use core::{alloc::Layout, cell::UnsafeCell, fmt::Debug, sync::atomic::Ordering};
+#[cfg(all(test, loom))]
+use loom::cell::UnsafeCell;
+
+#[cfg(not(all(test, loom)))]
+use core::cell::UnsafeCell;
+
+use core::{alloc::Layout, fmt::Debug};
 use iceoryx2_bb_elementary::math::unaligned_mem_size;
 use iceoryx2_bb_elementary::{bump_allocator::BumpAllocator, relocatable_ptr::RelocatablePointer};
 use iceoryx2_bb_elementary_traits::{
     owning_pointer::OwningPointer, pointer_trait::PointerTrait,
     relocatable_container::RelocatableContainer,
 };
 use iceoryx2_bb_log::{fail, fatal_panic};
-use iceoryx2_pal_concurrency_sync::iox_atomic::IoxAtomicBool;
-use iceoryx2_pal_concurrency_sync::iox_atomic::IoxAtomicU64;
+use iceoryx2_pal_concurrency_sync::iox_atomic::{fence, IoxAtomicBool, IoxAtomicU64, Ordering};
 
 /// The [`Producer`] of the [`IndexQueue`]/[`FixedSizeIndexQueue`] which can add values to it
 /// via [`Producer::push()`].
@@ -195,11 +200,19 @@ pub mod details {
         }
 
         unsafe fn at(&self, position: u64) -> *mut u64 {
-            (*self
+            let cell = &*self
                 .data_ptr
                 .as_ptr()
-                .add((position % self.capacity as u64) as usize))
-            .get()
+                .add((position % self.capacity as u64) as usize);
+
+            #[cfg(all(test, loom))]
+            {
+                cell.get_mut().deref() as *mut u64
+            }
+            #[cfg(not(all(test, loom)))]
+            {
+                cell.get()
+            }
         }
 
         /// Acquires the [`Producer`] of the [`IndexQueue`]. This is threadsafe and lock-free without
@@ -309,7 +322,7 @@ pub mod details {
             let value = unsafe { *self.at(read_position) };
             // prevent that `out` and `read_position` statements are reordered according to
             // the AS-IF rule.
-            core::sync::atomic::fence(Ordering::AcqRel);
+            fence(Ordering::AcqRel);
             self.read_position
                 .store(read_position + 1, Ordering::Relaxed);
 

iceoryx2-bb/log/Cargo.toml

@@ -10,6 +10,9 @@ repository = { workspace = true }
 rust-version = { workspace = true }
 version = { workspace = true }
 
+[lints]
+workspace = true
+
 [features]
 default = []
 std = []

iceoryx2-bb/log/src/lib.rs

@@ -197,8 +197,20 @@ static DEFAULT_LOGGER: logger::null::Logger = logger::null::Logger::new();
 const DEFAULT_LOG_LEVEL: LogLevel = LogLevel::Info;
 
 static mut LOGGER: Option<&'static dyn Log> = None;
+
+#[cfg(not(all(test, loom)))]
 static LOG_LEVEL: IoxAtomicU8 = IoxAtomicU8::new(DEFAULT_LOG_LEVEL as u8);
+#[cfg(all(test, loom))]
+static LOG_LEVEL: std::sync::LazyLock<IoxAtomicU8> = std::sync::LazyLock::new(|| {
+    unimplemented!("loom does not provide const-initialization for atomic variables.")
+});
+
+#[cfg(not(all(test, loom)))]
 static INIT: Once = Once::new();
+#[cfg(all(test, loom))]
+static INIT: std::sync::LazyLock<Once> = std::sync::LazyLock::new(|| {
+    unimplemented!("loom does not provide const-initialization for atomic variables.")
+});
 
 pub trait Log: Send + Sync {
     /// logs a message

iceoryx2-bb/posix/Cargo.toml

@@ -10,6 +10,9 @@ repository = { workspace = true }
 rust-version = { workspace = true }
 version = { workspace = true }
 
+[lints]
+workspace = true
+
 [features]
 # Use https://crates.io/crates/libc for the platform abstraction. This simplifies
 # cross-compilation since bindgen is not required anymore. Unfortunately, the libc crate

iceoryx2-bb/posix/src/signal.rs

@@ -270,8 +270,14 @@ impl Drop for SignalGuard {
     }
 }
 
+#[cfg(not(all(test, loom)))]
 static LAST_SIGNAL: IoxAtomicUsize = IoxAtomicUsize::new(posix::MAX_SIGNAL_VALUE);
 
+#[cfg(all(test, loom))]
+static LAST_SIGNAL: std::sync::LazyLock<IoxAtomicUsize> = std::sync::LazyLock::new(|| {
+    unimplemented!("loom does not provide const-initialization for atomic variables.")
+});
+
 /// Manages POSIX signal handling. It provides an interface to register custom callbacks for
 /// signals, to perform a blocking wait until a certain signal arrived (for instance like CTRL+c) and
 /// tracks signals which were received by the process.