Commit d6df37ba authored by Boqun Feng's avatar Boqun Feng Committed by Peter Zijlstra
Browse files

rust: sync: atomic: Add Atomic<u{32,64}> 



Add generic atomic support for basic unsigned types that have an
`AtomicImpl` with the same size and alignment.

Unit tests are added including Atomic<i32> and Atomic<i64>.

Signed-off-by: default avatarBoqun Feng <boqun.feng@gmail.com>
Signed-off-by: default avatarPeter Zijlstra (Intel) <peterz@infradead.org>
Reviewed-by: default avatarAlice Ryhl <aliceryhl@google.com>
Reviewed-by: default avatarAndreas Hindborg <a.hindborg@kernel.org>
Reviewed-by: default avatarBenno Lossin <lossin@kernel.org>
Reviewed-by: default avatarElle Rhumsaa <elle@weathered-steel.dev>
Link: https://lore.kernel.org/all/20250719030827.61357-8-boqun.feng@gmail.com/
parent d1320543

rust/kernel/sync/atomic/predefine.rs

+95 −0
Original line number Diff line number Diff line
@@ -27,3 +27,98 @@ fn rhs_into_delta(rhs: i64) -> i64 { 
        rhs

    }

}



// SAFETY: `u32` and `i32` has the same size and alignment, and `u32` is round-trip transmutable to

// `i32`.

unsafe impl super::AtomicType for u32 {

    type Repr = i32;

}



// SAFETY: The wrapping add result of two `i32`s is a valid `u32`.

unsafe impl super::AtomicAdd<u32> for u32 {

    fn rhs_into_delta(rhs: u32) -> i32 {

        rhs as i32

    }

}



// SAFETY: `u64` and `i64` has the same size and alignment, and `u64` is round-trip transmutable to

// `i64`.

unsafe impl super::AtomicType for u64 {

    type Repr = i64;

}



// SAFETY: The wrapping add result of two `i64`s is a valid `u64`.

unsafe impl super::AtomicAdd<u64> for u64 {

    fn rhs_into_delta(rhs: u64) -> i64 {

        rhs as i64

    }

}



use crate::macros::kunit_tests;



#[kunit_tests(rust_atomics)]

mod tests {

    use super::super::*;



    // Call $fn($val) with each $type of $val.

    macro_rules! for_each_type {

        ($val:literal in [$($type:ty),*] $fn:expr) => {

            $({

                let v: $type = $val;



                $fn(v);

            })*

        }

    }



    #[test]

    fn atomic_basic_tests() {

        for_each_type!(42 in [i32, i64, u32, u64] |v| {

            let x = Atomic::new(v);



            assert_eq!(v, x.load(Relaxed));

        });

    }



    #[test]

    fn atomic_xchg_tests() {

        for_each_type!(42 in [i32, i64, u32, u64] |v| {

            let x = Atomic::new(v);



            let old = v;

            let new = v + 1;



            assert_eq!(old, x.xchg(new, Full));

            assert_eq!(new, x.load(Relaxed));

        });

    }



    #[test]

    fn atomic_cmpxchg_tests() {

        for_each_type!(42 in [i32, i64, u32, u64] |v| {

            let x = Atomic::new(v);



            let old = v;

            let new = v + 1;



            assert_eq!(Err(old), x.cmpxchg(new, new, Full));

            assert_eq!(old, x.load(Relaxed));

            assert_eq!(Ok(old), x.cmpxchg(old, new, Relaxed));

            assert_eq!(new, x.load(Relaxed));

        });

    }



    #[test]

    fn atomic_arithmetic_tests() {

        for_each_type!(42 in [i32, i64, u32, u64] |v| {

            let x = Atomic::new(v);



            assert_eq!(v, x.fetch_add(12, Full));

            assert_eq!(v + 12, x.load(Relaxed));



            x.add(13, Relaxed);



            assert_eq!(v + 25, x.load(Relaxed));

        });

    }

}