Wrap std atomic types in newtype

Author: taiki-e

bench/benches/imp/intrinsics.rs

@@ -347,14 +347,6 @@ macro_rules! atomic128 {
             v: UnsafeCell<$int_type>,
         }
 
-        impl crate::utils::AtomicRepr for $atomic_type {
-            const IS_ALWAYS_LOCK_FREE: bool = true;
-            #[inline]
-            fn is_lock_free() -> bool {
-                true
-            }
-        }
-
         // Send is implicitly implemented.
         // SAFETY: any data races are prevented by atomic intrinsics.
         unsafe impl Sync for $atomic_type {}
@@ -365,6 +357,15 @@ macro_rules! atomic128 {
                 Self { v: UnsafeCell::new(v) }
             }
 
+            #[inline]
+            pub(crate) fn is_lock_free() -> bool {
+                Self::is_always_lock_free()
+            }
+            #[inline]
+            pub(crate) const fn is_always_lock_free() -> bool {
+                true
+            }
+
             #[inline]
             pub(crate) fn get_mut(&mut self) -> &mut $int_type {
                 self.v.get_mut()

bench/benches/imp/spinlock_fallback.rs

@@ -82,14 +82,6 @@ macro_rules! atomic_int {
             v: UnsafeCell<$int_type>,
         }
 
-        impl crate::utils::AtomicRepr for $atomic_type {
-            const IS_ALWAYS_LOCK_FREE: bool = false;
-            #[inline]
-            fn is_lock_free() -> bool {
-                false
-            }
-        }
-
         // Send is implicitly implemented.
         // SAFETY: any data races are prevented by the lock.
         unsafe impl Sync for $atomic_type {}
@@ -100,6 +92,15 @@ macro_rules! atomic_int {
                 Self { v: UnsafeCell::new(v) }
             }
 
+            #[inline]
+            pub(crate) fn is_lock_free() -> bool {
+                Self::is_always_lock_free()
+            }
+            #[inline]
+            pub(crate) const fn is_always_lock_free() -> bool {
+                false
+            }
+
             #[inline]
             pub(crate) fn get_mut(&mut self) -> &mut $int_type {
                 // SAFETY: This is safe because the mutable reference guarantees that no other

src/imp/atomic128/macros.rs

@@ -5,14 +5,6 @@ macro_rules! atomic128 {
             v: core::cell::UnsafeCell<$int_type>,
         }
 
-        impl crate::utils::AtomicRepr for $atomic_type {
-            const IS_ALWAYS_LOCK_FREE: bool = true;
-            #[inline]
-            fn is_lock_free() -> bool {
-                true
-            }
-        }
-
         // Send is implicitly implemented.
         // SAFETY: any data races are prevented by atomic intrinsics.
         unsafe impl Sync for $atomic_type {}
@@ -23,6 +15,15 @@ macro_rules! atomic128 {
                 Self { v: core::cell::UnsafeCell::new(v) }
             }
 
+            #[inline]
+            pub(crate) fn is_lock_free() -> bool {
+                Self::is_always_lock_free()
+            }
+            #[inline]
+            pub(crate) const fn is_always_lock_free() -> bool {
+                true
+            }
+
             #[inline]
             pub(crate) fn get_mut(&mut self) -> &mut $int_type {
                 self.v.get_mut()

src/imp/atomic128/powerpc64.rs

@@ -754,14 +754,6 @@ macro_rules! atomic128 {
             v: core::cell::UnsafeCell<$int_type>,
         }
 
-        impl crate::utils::AtomicRepr for $atomic_type {
-            const IS_ALWAYS_LOCK_FREE: bool = true;
-            #[inline]
-            fn is_lock_free() -> bool {
-                true
-            }
-        }
-
         // Send is implicitly implemented.
         // SAFETY: any data races are prevented by atomic intrinsics.
         unsafe impl Sync for $atomic_type {}
@@ -772,6 +764,15 @@ macro_rules! atomic128 {
                 Self { v: core::cell::UnsafeCell::new(v) }
             }
 
+            #[inline]
+            pub(crate) fn is_lock_free() -> bool {
+                Self::is_always_lock_free()
+            }
+            #[inline]
+            pub(crate) const fn is_always_lock_free() -> bool {
+                true
+            }
+
             #[inline]
             pub(crate) fn get_mut(&mut self) -> &mut $int_type {
                 self.v.get_mut()

src/imp/atomic128/x86_64.rs

@@ -408,17 +408,6 @@ macro_rules! atomic128 {
             v: UnsafeCell<$int_type>,
         }
 
-        impl crate::utils::AtomicRepr for $atomic_type {
-            const IS_ALWAYS_LOCK_FREE: bool = cfg!(any(
-                target_feature = "cmpxchg16b",
-                portable_atomic_target_feature = "cmpxchg16b",
-            ));
-            #[inline]
-            fn is_lock_free() -> bool {
-                detect::has_cmpxchg16b()
-            }
-        }
-
         // Send is implicitly implemented.
         // SAFETY: any data races are prevented by atomic operations.
         unsafe impl Sync for $atomic_type {}
@@ -429,6 +418,18 @@ macro_rules! atomic128 {
                 Self { v: UnsafeCell::new(v) }
             }
 
+            #[inline]
+            pub(crate) fn is_lock_free() -> bool {
+                detect::has_cmpxchg16b()
+            }
+            #[inline]
+            pub(crate) const fn is_always_lock_free() -> bool {
+                cfg!(any(
+                    target_feature = "cmpxchg16b",
+                    portable_atomic_target_feature = "cmpxchg16b",
+                ))
+            }
+
             #[inline]
             pub(crate) fn get_mut(&mut self) -> &mut $int_type {
                 self.v.get_mut()
@@ -602,7 +603,6 @@ atomic128!(AtomicU128, u128);
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::utils::AtomicRepr;
 
     test_atomic_int!(i128);
     test_atomic_int!(u128);