Merge pull request #212 from elfenpiff/iox2-200-integrate-iox-atomic

[#200] integrate iox atomic

Author: elfenpiff

.github/workflows/build-test.yml

@@ -93,6 +93,46 @@ jobs:
         artifact-bin-name: cargo-nextest
         artifact-upload-name: ${{ runner.os }}-cargo-nextest
 
+  x86_32:
+    needs: [preflight-check, static-code-analysis, cargo-nextest]
+    if: ${{ needs.changes.outputs.source-code == 'true' }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest] # [windows-latest, ubuntu-latest, macos-latest]
+        toolchain: [stable] # [stable, 1.73.0, beta, nightly]
+        mode: 
+          - name: "release"
+            arg: "--release"
+          - name: "debug"
+            arg: ""
+    timeout-minutes: 60
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v4
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@v1
+        with:
+          toolchain: ${{ matrix.toolchain }}
+          targets: i686-unknown-linux-gnu
+          components: rustfmt, clippy
+
+      - name: Download artifact cargo-nextest
+        uses: ./.github/actions/download-cached-rust-tool
+        with:
+          artifact-bin-name: cargo-nextest
+          artifact-upload-name: ${{ runner.os }}-cargo-nextest
+
+      - name: Prepare system
+        run: ${{ matrix.os == 'windows-latest' && 'internal\scripts\ci_prepare_windows.bat' || ( matrix.os == 'ubuntu-latest' && './internal/scripts/ci_prepare_ubuntu.sh' || 'uname -a' ) }}
+
+      - name: Run cargo build
+        run: cargo build --workspace --all-targets ${{ matrix.mode.arg }} --target i686-unknown-linux-gnu
+
+      - name: Run cargo nextest
+        run: cargo nextest run --workspace --no-fail-fast ${{ matrix.mode.arg }} --target i686-unknown-linux-gnu
+
   x86_64:
     needs: [preflight-check, static-code-analysis, cargo-nextest]
     if: ${{ needs.changes.outputs.source-code == 'true' }}

clippy.toml

@@ -0,0 +1,26 @@
+disallowed-types = [
+    "std::sync::atomic::AtomicI8",
+    "std::sync::atomic::AtomicI16",
+    "std::sync::atomic::AtomicI32",
+    "std::sync::atomic::AtomicI64",
+    "std::sync::atomic::AtomicU8",
+    "std::sync::atomic::AtomicU16",
+    "std::sync::atomic::AtomicU32",
+    "std::sync::atomic::AtomicU64",
+    "std::sync::atomic::AtomicBool",
+    "std::sync::atomic::AtomicIsize",
+    "std::sync::atomic::AtomicPtr",
+    "std::sync::atomic::AtomicUsize",
+    "core::sync::atomic::AtomicI8",
+    "core::sync::atomic::AtomicI16",
+    "core::sync::atomic::AtomicI32",
+    "core::sync::atomic::AtomicI64",
+    "core::sync::atomic::AtomicU8",
+    "core::sync::atomic::AtomicU16",
+    "core::sync::atomic::AtomicU32",
+    "core::sync::atomic::AtomicU64",
+    "core::sync::atomic::AtomicBool",
+    "core::sync::atomic::AtomicIsize",
+    "core::sync::atomic::AtomicPtr",
+    "core::sync::atomic::AtomicUsize",
+]

doc/release-notes/iceoryx2-unreleased.md

@@ -40,9 +40,12 @@
         sample.send()?;
     }
     ```
- * Introduce `IoxAtomic` that supports up to 128bit atomics on 32-bit architecture with a ReadWriteLock [#200](https://github.com/eclipse-iceoryx/iceoryx2/issues/200)
+ * 32-bit support [#200](https://github.com/eclipse-iceoryx/iceoryx2/issues/200)
+    * Introduce `IoxAtomic` that supports up to 128bit atomics on 32-bit architecture with a ReadWriteLock
+    * add CI targets to officially support 32-bit
  * Example that demonstrates publish-subscribe communication with dynamic data [#205](https://github.com/eclipse-iceoryx/iceoryx2/issues/205)
 
+
 ### Bugfixes
 
  <!-- NOTE: Add new entries sorted by issue number to minimize the possibility of conflicts when merging. -->

iceoryx2-bb/container/Cargo.toml

@@ -15,6 +15,7 @@ version = { workspace = true }
 [dependencies]
 iceoryx2-bb-elementary = { workspace = true }
 iceoryx2-bb-log = { workspace = true }
+iceoryx2-pal-concurrency-sync = { workspace = true }
 
 [dev-dependencies]
 generic-tests = { workspace = true }

iceoryx2-bb/container/src/queue.rs

@@ -97,16 +97,15 @@
 //!
 use iceoryx2_bb_elementary::allocator::{AllocationError, BaseAllocator};
 use iceoryx2_bb_elementary::math::align_to;
+use iceoryx2_bb_elementary::math::unaligned_mem_size;
 use iceoryx2_bb_elementary::owning_pointer::OwningPointer;
 use iceoryx2_bb_elementary::pointer_trait::PointerTrait;
+pub use iceoryx2_bb_elementary::relocatable_container::RelocatableContainer;
 use iceoryx2_bb_elementary::relocatable_ptr::RelocatablePointer;
 use iceoryx2_bb_log::{fail, fatal_panic};
-use std::sync::atomic::AtomicBool;
-use std::{alloc::Layout, fmt::Debug, mem::MaybeUninit};
-
-use iceoryx2_bb_elementary::math::unaligned_mem_size;
-pub use iceoryx2_bb_elementary::relocatable_container::RelocatableContainer;
+use iceoryx2_pal_concurrency_sync::iox_atomic::IoxAtomicBool;
 use std::marker::PhantomData;
+use std::{alloc::Layout, fmt::Debug, mem::MaybeUninit};
 
 /// Queue with run-time fixed size capacity. In contrast to its counterpart the
 /// [`RelocatableQueue`] it is movable but is not shared memory compatible.
@@ -124,7 +123,7 @@ pub mod details {
         start: usize,
         len: usize,
         capacity: usize,
-        is_initialized: AtomicBool,
+        is_initialized: IoxAtomicBool,
         _phantom_data: PhantomData<T>,
     }
 
@@ -138,7 +137,7 @@ pub mod details {
                 start: 0,
                 len: 0,
                 capacity,
-                is_initialized: AtomicBool::new(true),
+                is_initialized: IoxAtomicBool::new(true),
                 _phantom_data: PhantomData,
             }
         }
@@ -200,7 +199,7 @@ pub mod details {
                 start: 0,
                 len: 0,
                 capacity,
-                is_initialized: AtomicBool::new(true),
+                is_initialized: IoxAtomicBool::new(true),
                 _phantom_data: PhantomData,
             }
         }
@@ -211,7 +210,7 @@ pub mod details {
                 start: 0,
                 len: 0,
                 capacity,
-                is_initialized: AtomicBool::new(false),
+                is_initialized: IoxAtomicBool::new(false),
                 _phantom_data: PhantomData,
             }
         }

iceoryx2-bb/container/src/vec.rs

@@ -75,13 +75,7 @@
 //! unsafe { vec.init(&bump_allocator).expect("vec init failed") };
 //! ```
 
-use std::{
-    alloc::Layout,
-    mem::MaybeUninit,
-    ops::Deref,
-    ops::DerefMut,
-    sync::atomic::{AtomicBool, Ordering},
-};
+use std::{alloc::Layout, mem::MaybeUninit, ops::Deref, ops::DerefMut, sync::atomic::Ordering};
 
 use iceoryx2_bb_elementary::{
     math::{align_to, unaligned_mem_size},
@@ -90,6 +84,7 @@ use iceoryx2_bb_elementary::{
     relocatable_ptr::RelocatablePointer,
 };
 use iceoryx2_bb_log::{fail, fatal_panic};
+use iceoryx2_pal_concurrency_sync::iox_atomic::IoxAtomicBool;
 
 /// **Non-movable** relocatable vector with runtime fixed size capacity.
 #[repr(C)]
@@ -98,7 +93,7 @@ pub struct RelocatableVec<T> {
     data_ptr: RelocatablePointer<MaybeUninit<T>>,
     capacity: usize,
     len: usize,
-    is_initialized: AtomicBool,
+    is_initialized: IoxAtomicBool,
 }
 
 unsafe impl<T: Send> Send for RelocatableVec<T> {}
@@ -115,7 +110,7 @@ impl<T> RelocatableContainer for RelocatableVec<T> {
             data_ptr: RelocatablePointer::new(distance_to_data),
             capacity,
             len: 0,
-            is_initialized: AtomicBool::new(true),
+            is_initialized: IoxAtomicBool::new(true),
         }
     }
 
@@ -124,7 +119,7 @@ impl<T> RelocatableContainer for RelocatableVec<T> {
             data_ptr: RelocatablePointer::new_uninit(),
             capacity,
             len: 0,
-            is_initialized: AtomicBool::new(false),
+            is_initialized: IoxAtomicBool::new(false),
         }
     }
 

iceoryx2-bb/elementary/Cargo.toml

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

iceoryx2-bb/elementary/src/bump_allocator.rs

@@ -11,21 +11,22 @@
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 
 use crate::{allocator::BaseAllocator, math::align};
-use std::sync::atomic::{AtomicUsize, Ordering};
+use iceoryx2_pal_concurrency_sync::iox_atomic::IoxAtomicUsize;
+use std::sync::atomic::Ordering;
 
 /// Simple BumpAllocator for testing purposes. Do not use this in production. If you are looking
 /// for a production ready BumpAllocator use the one from iceoryx2_bb_memory::bump_allocator
 #[doc(hidden)]
 pub struct BumpAllocator {
     start: usize,
-    pos: AtomicUsize,
+    pos: IoxAtomicUsize,
 }
 
 impl BumpAllocator {
     pub fn new(start: usize) -> Self {
         Self {
             start,
-            pos: AtomicUsize::new(start),
+            pos: IoxAtomicUsize::new(start),
         }
     }
 }

iceoryx2-bb/elementary/src/lazy_singleton.rs

@@ -33,29 +33,33 @@
 //! println!("{}", LAZY_GLOBAL.get());
 //! ```
 
-use std::{
-    cell::UnsafeCell,
-    sync::atomic::{AtomicBool, Ordering},
-};
+use iceoryx2_pal_concurrency_sync::iox_atomic::IoxAtomicBool;
+use std::{cell::UnsafeCell, sync::atomic::Ordering};
 
 /// The lazy initialized singleton building block of type T
 #[derive(Debug)]
 pub struct LazySingleton<T> {
     data: UnsafeCell<Option<T>>,
-    is_initialized: AtomicBool,
-    is_finalized: AtomicBool,
+    is_initialized: IoxAtomicBool,
+    is_finalized: IoxAtomicBool,
 }
 
 unsafe impl<T: Send> Send for LazySingleton<T> {}
 unsafe impl<T: Send + Sync> Sync for LazySingleton<T> {}
 
+impl<T> Default for LazySingleton<T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl<T> LazySingleton<T> {
     /// Creates a new [`LazySingleton`] where the underlying value is not yet initialized.
     pub const fn new() -> Self {
         Self {
             data: UnsafeCell::new(None),
-            is_initialized: AtomicBool::new(false),
-            is_finalized: AtomicBool::new(false),
+            is_initialized: IoxAtomicBool::new(false),
+            is_finalized: IoxAtomicBool::new(false),
         }
     }
 

iceoryx2-bb/elementary/src/package_version.rs

@@ -10,10 +10,8 @@
 //
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 
-use std::{
-    fmt::Display,
-    sync::atomic::{AtomicU64, Ordering},
-};
+use iceoryx2_pal_concurrency_sync::iox_atomic::IoxAtomicU64;
+use std::{fmt::Display, sync::atomic::Ordering};
 
 /// Represents the crates version acquired through the internal environment variables set by cargo,
 /// ("CARGO_PKG_VERSION_{MAJOR|MINOR|PATCH}").
@@ -65,7 +63,7 @@ impl PackageVersion {
 
     /// Returns the current [`PackageVersion`]
     pub fn get() -> PackageVersion {
-        static PACKAGE_VERSION: AtomicU64 = AtomicU64::new(0);
+        static PACKAGE_VERSION: IoxAtomicU64 = IoxAtomicU64::new(0);
 
         if PACKAGE_VERSION.load(Ordering::Relaxed) == 0 {
             let major = option_env!("CARGO_PKG_VERSION_MAJOR")

iceoryx2-bb/elementary/src/relocatable_ptr.rs

@@ -65,7 +65,8 @@
 //! ```
 
 pub use crate::pointer_trait::PointerTrait;
-use std::{marker::PhantomData, ptr::NonNull, sync::atomic::AtomicIsize};
+use iceoryx2_pal_concurrency_sync::iox_atomic::IoxAtomicIsize;
+use std::{marker::PhantomData, ptr::NonNull};
 
 /// A [`RelocatablePointer`] stores only the distance from its memory starting position to the
 /// memory location it is pointing to. When the [`RelocatablePointer`] is now shared between
@@ -83,7 +84,7 @@ use std::{marker::PhantomData, ptr::NonNull, sync::atomic::AtomicIsize};
 #[repr(C)]
 #[derive(Debug)]
 pub struct RelocatablePointer<T> {
-    distance: AtomicIsize,
+    distance: IoxAtomicIsize,
     _phantom: PhantomData<T>,
 }
 
@@ -92,7 +93,7 @@ impl<T> RelocatablePointer<T> {
     /// destination starting from the memory location of this [`RelocatablePointer`].
     pub fn new(distance: isize) -> Self {
         Self {
-            distance: AtomicIsize::new(distance),
+            distance: IoxAtomicIsize::new(distance),
             _phantom: PhantomData,
         }
     }

iceoryx2-bb/elementary/src/unique_id.rs

@@ -63,10 +63,8 @@
 //! }
 //! ```
 
-use std::{
-    marker::PhantomData,
-    sync::atomic::{AtomicU64, Ordering},
-};
+use iceoryx2_pal_concurrency_sync::iox_atomic::IoxAtomicU64;
+use std::{marker::PhantomData, sync::atomic::Ordering};
 
 /// A building block to generate global unique ids
 #[derive(Debug, Eq, Hash, PartialEq)]
@@ -76,7 +74,7 @@ pub struct UniqueId {
 
 impl Default for UniqueId {
     fn default() -> Self {
-        static COUNTER: AtomicU64 = AtomicU64::new(0);
+        static COUNTER: IoxAtomicU64 = IoxAtomicU64::new(0);
 
         UniqueId {
             value: COUNTER.fetch_add(1, Ordering::Relaxed),
@@ -106,7 +104,7 @@ pub struct TypedUniqueId<T> {
 
 impl<T> Default for TypedUniqueId<T> {
     fn default() -> Self {
-        static COUNTER: AtomicU64 = AtomicU64::new(0);
+        static COUNTER: IoxAtomicU64 = IoxAtomicU64::new(0);
 
         Self {
             value: COUNTER.fetch_add(1, Ordering::Relaxed),

iceoryx2-bb/lock-free/Cargo.toml

@@ -13,6 +13,7 @@ version = { workspace = true }
 [dependencies]
 iceoryx2-bb-log = { workspace = true }
 iceoryx2-bb-elementary = { workspace = true }
+iceoryx2-pal-concurrency-sync = { workspace = true }
 
 tiny-fn = { workspace = true }