From 87753249fb9ac26acd1eb0135fefded871c24e6c Mon Sep 17 00:00:00 2001 From: Khem Raj Date: Fri, 18 Apr 2025 17:54:42 -0700 Subject: [PATCH] Upgrade radium to 1.0 Upstream-Status: Submitted [https:\/\/github.com\/ferrilab\/bitvec\/pull\/220] Signed-off-by: Khem Raj --- Cargo.toml | 2 +- src\/macros\/tests.rs | 256 ++++++++++++++++++++++---------------------- src\/mem.rs | 28 ++--- src\/serdes.rs | 58 +++++----- src\/store.rs | 61 +++++------ 5 files changed, 207 insertions(+), 198 deletions(-) --- a\/Cargo.toml +++ b\/Cargo.toml @@ -55,7 +55,7 @@ version = "^2.0" default-features = false [dependencies.radium] -version = "0.7" +version = "1" [dependencies.serde] version = "1" --- a\/src\/macros\/tests.rs +++ b\/src\/macros\/tests.rs @@ -231,50 +231,52 @@ fn compile_bits() { let _: &BitSlice = bits![u64, crate::order::Msb0; 1; 100]; } - radium::if_atomic! { - if atomic(8) { - let _: &BitSlice = bits![AtomicU8, LocalBits; 0, 1]; - let _: &BitSlice = bits![AtomicU8, Lsb0; 0, 1]; - let _: &BitSlice = bits![AtomicU8, Msb0; 0, 1]; - let _: &BitSlice = bits![RadiumU8, LocalBits; 1; 100]; - let _: &BitSlice = bits![RadiumU8, Lsb0; 1; 100]; - let _: &BitSlice = bits![RadiumU8, Msb0; 1; 100]; - } - if atomic(16) { - let _: &BitSlice = bits![AtomicU16, LocalBits; 0, 1]; - let _: &BitSlice = bits![AtomicU16, Lsb0; 0, 1]; - let _: &BitSlice = bits![AtomicU16, Msb0; 0, 1]; - let _: &BitSlice = bits![RadiumU16, LocalBits; 1; 100]; - let _: &BitSlice = bits![RadiumU16, Lsb0; 1; 100]; - let _: &BitSlice = bits![RadiumU16, Msb0; 1; 100]; - } - if atomic(32) { - let _: &BitSlice = bits![AtomicU32, LocalBits; 0, 1]; - let _: &BitSlice = bits![AtomicU32, Lsb0; 0, 1]; - let _: &BitSlice = bits![AtomicU32, Msb0; 0, 1]; - let _: &BitSlice = bits![RadiumU32, LocalBits; 1; 100]; - let _: &BitSlice = bits![RadiumU32, Lsb0; 1; 100]; - let _: &BitSlice = bits![RadiumU32, Msb0; 1; 100]; - } - if atomic(size) { - let _: &BitSlice = bits![AtomicUsize, LocalBits; 0, 1]; - let _: &BitSlice = bits![AtomicUsize, Lsb0; 0, 1]; - let _: &BitSlice = bits![AtomicUsize, Msb0; 0, 1]; - let _: &BitSlice = bits![RadiumUsize, LocalBits; 1; 100]; - let _: &BitSlice = bits![RadiumUsize, Lsb0; 1; 100]; - let _: &BitSlice = bits![RadiumUsize, Msb0; 1; 100]; - } + #[cfg(target_has_atomic = "8")] + { + let _: &BitSlice = bits![AtomicU8, LocalBits; 0, 1]; + let _: &BitSlice = bits![AtomicU8, Lsb0; 0, 1]; + let _: &BitSlice = bits![AtomicU8, Msb0; 0, 1]; + let _: &BitSlice = bits![RadiumU8, LocalBits; 1; 100]; + let _: &BitSlice = bits![RadiumU8, Lsb0; 1; 100]; + let _: &BitSlice = bits![RadiumU8, Msb0; 1; 100]; + } + #[cfg(target_has_atomic = "16")] + { + let _: &BitSlice = bits![AtomicU16, LocalBits; 0, 1]; + let _: &BitSlice = bits![AtomicU16, Lsb0; 0, 1]; + let _: &BitSlice = bits![AtomicU16, Msb0; 0, 1]; + let _: &BitSlice = bits![RadiumU16, LocalBits; 1; 100]; + let _: &BitSlice = bits![RadiumU16, Lsb0; 1; 100]; + let _: &BitSlice = bits![RadiumU16, Msb0; 1; 100]; + } + #[cfg(target_has_atomic = "32")] + { + let _: &BitSlice = bits![AtomicU32, LocalBits; 0, 1]; + let _: &BitSlice = bits![AtomicU32, Lsb0; 0, 1]; + let _: &BitSlice = bits![AtomicU32, Msb0; 0, 1]; + let _: &BitSlice = bits![RadiumU32, LocalBits; 1; 100]; + let _: &BitSlice = bits![RadiumU32, Lsb0; 1; 100]; + let _: &BitSlice = bits![RadiumU32, Msb0; 1; 100]; + } + #[cfg(target_has_atomic = "ptr")] + { + let _: &BitSlice = bits![AtomicUsize, LocalBits; 0, 1]; + let _: &BitSlice = bits![AtomicUsize, Lsb0; 0, 1]; + let _: &BitSlice = bits![AtomicUsize, Msb0; 0, 1]; + let _: &BitSlice = bits![RadiumUsize, LocalBits; 1; 100]; + let _: &BitSlice = bits![RadiumUsize, Lsb0; 1; 100]; + let _: &BitSlice = bits![RadiumUsize, Msb0; 1; 100]; } + #[cfg(target_pointer_width = "64")] - radium::if_atomic! { - if atomic(64) { - let _: &BitSlice = bits![AtomicU64, LocalBits; 0, 1]; - let _: &BitSlice = bits![AtomicU64, Lsb0; 0, 1]; - let _: &BitSlice = bits![AtomicU64, Msb0; 0, 1]; - let _: &BitSlice = bits![RadiumU64, LocalBits; 1; 100]; - let _: &BitSlice = bits![RadiumU64, Lsb0; 1; 100]; - let _: &BitSlice = bits![RadiumU64, Msb0; 1; 100]; - } + #[cfg(target_has_atomic = "64")] + { + let _: &BitSlice = bits![AtomicU64, LocalBits; 0, 1]; + let _: &BitSlice = bits![AtomicU64, Lsb0; 0, 1]; + let _: &BitSlice = bits![AtomicU64, Msb0; 0, 1]; + let _: &BitSlice = bits![RadiumU64, LocalBits; 1; 100]; + let _: &BitSlice = bits![RadiumU64, Lsb0; 1; 100]; + let _: &BitSlice = bits![RadiumU64, Msb0; 1; 100]; } } @@ -346,50 +348,51 @@ fn compile_bitvec() { bitvec![Cell, crate::order::Msb0; 1; 100]; let _: BitVec = bitvec![u64, crate::order::Msb0; 1; 100]; } - radium::if_atomic! { - if atomic(8) { - let _: BitVec =bitvec![AtomicU8, LocalBits; 0, 1]; - let _: BitVec =bitvec![AtomicU8, Lsb0; 0, 1]; - let _: BitVec =bitvec![AtomicU8, Msb0; 0, 1]; - let _: BitVec =bitvec![RadiumU8, LocalBits; 1; 100]; - let _: BitVec =bitvec![RadiumU8, Lsb0; 1; 100]; - let _: BitVec =bitvec![RadiumU8, Msb0; 1; 100]; - } - if atomic(16) { - let _: BitVec =bitvec![AtomicU16, LocalBits; 0, 1]; - let _: BitVec =bitvec![AtomicU16, Lsb0; 0, 1]; - let _: BitVec =bitvec![AtomicU16, Msb0; 0, 1]; - let _: BitVec =bitvec![RadiumU16, LocalBits; 1; 100]; - let _: BitVec =bitvec![RadiumU16, Lsb0; 1; 100]; - let _: BitVec =bitvec![RadiumU16, Msb0; 1; 100]; - } - if atomic(32) { - let _: BitVec =bitvec![AtomicU32, LocalBits; 0, 1]; - let _: BitVec =bitvec![AtomicU32, Lsb0; 0, 1]; - let _: BitVec =bitvec![AtomicU32, Msb0; 0, 1]; - let _: BitVec =bitvec![RadiumU32, LocalBits; 1; 100]; - let _: BitVec =bitvec![RadiumU32, Lsb0; 1; 100]; - let _: BitVec =bitvec![RadiumU32, Msb0; 1; 100]; - } - if atomic(size) { - let _: BitVec =bitvec![AtomicUsize, LocalBits; 0, 1]; - let _: BitVec =bitvec![AtomicUsize, Lsb0; 0, 1]; - let _: BitVec =bitvec![AtomicUsize, Msb0; 0, 1]; - let _: BitVec =bitvec![RadiumUsize, LocalBits; 1; 100]; - let _: BitVec =bitvec![RadiumUsize, Lsb0; 1; 100]; - let _: BitVec =bitvec![RadiumUsize, Msb0; 1; 100]; - } + #[cfg(target_has_atomic = "8")] + { + let _: BitVec =bitvec![AtomicU8, LocalBits; 0, 1]; + let _: BitVec =bitvec![AtomicU8, Lsb0; 0, 1]; + let _: BitVec =bitvec![AtomicU8, Msb0; 0, 1]; + let _: BitVec =bitvec![RadiumU8, LocalBits; 1; 100]; + let _: BitVec =bitvec![RadiumU8, Lsb0; 1; 100]; + let _: BitVec =bitvec![RadiumU8, Msb0; 1; 100]; + } + #[cfg(target_has_atomic = "16")] + { + let _: BitVec =bitvec![AtomicU16, LocalBits; 0, 1]; + let _: BitVec =bitvec![AtomicU16, Lsb0; 0, 1]; + let _: BitVec =bitvec![AtomicU16, Msb0; 0, 1]; + let _: BitVec =bitvec![RadiumU16, LocalBits; 1; 100]; + let _: BitVec =bitvec![RadiumU16, Lsb0; 1; 100]; + let _: BitVec =bitvec![RadiumU16, Msb0; 1; 100]; + } + #[cfg(target_has_atomic = "32")] + { + let _: BitVec =bitvec![AtomicU32, LocalBits; 0, 1]; + let _: BitVec =bitvec![AtomicU32, Lsb0; 0, 1]; + let _: BitVec =bitvec![AtomicU32, Msb0; 0, 1]; + let _: BitVec =bitvec![RadiumU32, LocalBits; 1; 100]; + let _: BitVec =bitvec![RadiumU32, Lsb0; 1; 100]; + let _: BitVec =bitvec![RadiumU32, Msb0; 1; 100]; + } + #[cfg(target_has_atomic = "ptr")] + { + let _: BitVec =bitvec![AtomicUsize, LocalBits; 0, 1]; + let _: BitVec =bitvec![AtomicUsize, Lsb0; 0, 1]; + let _: BitVec =bitvec![AtomicUsize, Msb0; 0, 1]; + let _: BitVec =bitvec![RadiumUsize, LocalBits; 1; 100]; + let _: BitVec =bitvec![RadiumUsize, Lsb0; 1; 100]; + let _: BitVec =bitvec![RadiumUsize, Msb0; 1; 100]; } #[cfg(target_pointer_width = "64")] - radium::if_atomic! { - if atomic(64) { - let _: BitVec =bitvec![AtomicU64, LocalBits; 0, 1]; - let _: BitVec =bitvec![AtomicU64, Lsb0; 0, 1]; - let _: BitVec =bitvec![AtomicU64, Msb0; 0, 1]; - let _: BitVec =bitvec![RadiumU64, LocalBits; 1; 100]; - let _: BitVec =bitvec![RadiumU64, Lsb0; 1; 100]; - let _: BitVec =bitvec![RadiumU64, Msb0; 1; 100]; - } + #[cfg(target_has_atomic = "64")] + { + let _: BitVec =bitvec![AtomicU64, LocalBits; 0, 1]; + let _: BitVec =bitvec![AtomicU64, Lsb0; 0, 1]; + let _: BitVec =bitvec![AtomicU64, Msb0; 0, 1]; + let _: BitVec =bitvec![RadiumU64, LocalBits; 1; 100]; + let _: BitVec =bitvec![RadiumU64, Lsb0; 1; 100]; + let _: BitVec =bitvec![RadiumU64, Msb0; 1; 100]; } } @@ -461,50 +464,51 @@ fn compile_bitbox() { bitbox![Cell, crate::order::Msb0; 1; 100]; let _: BitBox = bitbox![u64, crate::order::Msb0; 1; 100]; } - radium::if_atomic! { - if atomic(8) { - let _: BitBox =bitbox![AtomicU8, LocalBits; 0, 1]; - let _: BitBox =bitbox![AtomicU8, Lsb0; 0, 1]; - let _: BitBox =bitbox![AtomicU8, Msb0; 0, 1]; - let _: BitBox =bitbox![RadiumU8, LocalBits; 1; 100]; - let _: BitBox =bitbox![RadiumU8, Lsb0; 1; 100]; - let _: BitBox =bitbox![RadiumU8, Msb0; 1; 100]; - } - if atomic(16) { - let _: BitBox =bitbox![AtomicU16, LocalBits; 0, 1]; - let _: BitBox =bitbox![AtomicU16, Lsb0; 0, 1]; - let _: BitBox =bitbox![AtomicU16, Msb0; 0, 1]; - let _: BitBox =bitbox![RadiumU16, LocalBits; 1; 100]; - let _: BitBox =bitbox![RadiumU16, Lsb0; 1; 100]; - let _: BitBox =bitbox![RadiumU16, Msb0; 1; 100]; - } - if atomic(32) { - let _: BitBox =bitbox![AtomicU32, LocalBits; 0, 1]; - let _: BitBox =bitbox![AtomicU32, Lsb0; 0, 1]; - let _: BitBox =bitbox![AtomicU32, Msb0; 0, 1]; - let _: BitBox =bitbox![RadiumU32, LocalBits; 1; 100]; - let _: BitBox =bitbox![RadiumU32, Lsb0; 1; 100]; - let _: BitBox =bitbox![RadiumU32, Msb0; 1; 100]; - } - if atomic(size) { - let _: BitBox =bitbox![AtomicUsize, LocalBits; 0, 1]; - let _: BitBox =bitbox![AtomicUsize, Lsb0; 0, 1]; - let _: BitBox =bitbox![AtomicUsize, Msb0; 0, 1]; - let _: BitBox =bitbox![RadiumUsize, LocalBits; 1; 100]; - let _: BitBox =bitbox![RadiumUsize, Lsb0; 1; 100]; - let _: BitBox =bitbox![RadiumUsize, Msb0; 1; 100]; - } + #[cfg(target_has_atomic = "8")] + { + let _: BitBox =bitbox![AtomicU8, LocalBits; 0, 1]; + let _: BitBox =bitbox![AtomicU8, Lsb0; 0, 1]; + let _: BitBox =bitbox![AtomicU8, Msb0; 0, 1]; + let _: BitBox =bitbox![RadiumU8, LocalBits; 1; 100]; + let _: BitBox =bitbox![RadiumU8, Lsb0; 1; 100]; + let _: BitBox =bitbox![RadiumU8, Msb0; 1; 100]; + } + #[cfg(target_has_atomic = "16")] + { + let _: BitBox =bitbox![AtomicU16, LocalBits; 0, 1]; + let _: BitBox =bitbox![AtomicU16, Lsb0; 0, 1]; + let _: BitBox =bitbox![AtomicU16, Msb0; 0, 1]; + let _: BitBox =bitbox![RadiumU16, LocalBits; 1; 100]; + let _: BitBox =bitbox![RadiumU16, Lsb0; 1; 100]; + let _: BitBox =bitbox![RadiumU16, Msb0; 1; 100]; + } + #[cfg(target_has_atomic = "32")] + { + let _: BitBox =bitbox![AtomicU32, LocalBits; 0, 1]; + let _: BitBox =bitbox![AtomicU32, Lsb0; 0, 1]; + let _: BitBox =bitbox![AtomicU32, Msb0; 0, 1]; + let _: BitBox =bitbox![RadiumU32, LocalBits; 1; 100]; + let _: BitBox =bitbox![RadiumU32, Lsb0; 1; 100]; + let _: BitBox =bitbox![RadiumU32, Msb0; 1; 100]; + } + #[cfg(target_has_atomic = "ptr")] + { + let _: BitBox =bitbox![AtomicUsize, LocalBits; 0, 1]; + let _: BitBox =bitbox![AtomicUsize, Lsb0; 0, 1]; + let _: BitBox =bitbox![AtomicUsize, Msb0; 0, 1]; + let _: BitBox =bitbox![RadiumUsize, LocalBits; 1; 100]; + let _: BitBox =bitbox![RadiumUsize, Lsb0; 1; 100]; + let _: BitBox =bitbox![RadiumUsize, Msb0; 1; 100]; } #[cfg(target_pointer_width = "64")] - radium::if_atomic! { - if atomic(64) { - let _: BitBox =bitbox![AtomicU64, LocalBits; 0, 1]; - let _: BitBox =bitbox![AtomicU64, Lsb0; 0, 1]; - let _: BitBox =bitbox![AtomicU64, Msb0; 0, 1]; - let _: BitBox =bitbox![RadiumU64, LocalBits; 1; 100]; - let _: BitBox =bitbox![RadiumU64, Lsb0; 1; 100]; - let _: BitBox =bitbox![RadiumU64, Msb0; 1; 100]; - } + #[cfg(target_has_atomic = "64")] + { + let _: BitBox =bitbox![AtomicU64, LocalBits; 0, 1]; + let _: BitBox =bitbox![AtomicU64, Lsb0; 0, 1]; + let _: BitBox =bitbox![AtomicU64, Msb0; 0, 1]; + let _: BitBox =bitbox![RadiumU64, LocalBits; 1; 100]; + let _: BitBox =bitbox![RadiumU64, Lsb0; 1; 100]; + let _: BitBox =bitbox![RadiumU64, Msb0; 1; 100]; } } --- a\/src\/mem.rs +++ b\/src\/mem.rs @@ -101,30 +101,30 @@ macro_rules! element { } } - radium::if_atomic!( if atomic($size) { - use core::sync::atomic::$atom; - impl BitElement<$atom> { - \/\/\/ Creates a new element wrapper from a raw integer. - pub const fn new(elem: $bare) -> Self { - Self { - elem: <$atom>::new(elem), - } + #[cfg(target_has_atomic = $size)] + use core::sync::atomic::$atom; + #[cfg(target_has_atomic = $size)] + impl BitElement<$atom> { + \/\/\/ Creates a new element wrapper from a raw integer. + pub const fn new(elem: $bare) -> Self { + Self { + elem: <$atom>::new(elem), } } - }); + } )+ }; } element! { - 8, u8 => AtomicU8; - 16, u16 => AtomicU16; - 32, u32 => AtomicU32; + "8", u8 => AtomicU8; + "16", u16 => AtomicU16; + "32", u32 => AtomicU32; } #[cfg(target_pointer_width = "64")] -element!(64, u64 => AtomicU64); +element!("64", u64 => AtomicU64); -element!(size, usize => AtomicUsize); +element!("ptr", usize => AtomicUsize); #[cfg(test)] mod tests { --- a\/src\/serdes.rs +++ b\/src\/serdes.rs @@ -112,36 +112,39 @@ mod tests { Msb0 @ RadiumU8, RadiumU16, RadiumU32, RadiumUsize; LocalBits @ RadiumU8, RadiumU16, RadiumU32, RadiumUsize; } - radium::if_atomic! { - if atomic(8) { - check_impl! { - Lsb0 @ AtomicU8; - Msb0 @ AtomicU8; - LocalBits @ AtomicU8; - } + #[cfg(target_has_atomic = "8")] + { + check_impl! { + Lsb0 @ AtomicU8; + Msb0 @ AtomicU8; + LocalBits @ AtomicU8; } - if atomic(16) { - check_impl! { - Lsb0 @ AtomicU16; - Msb0 @ AtomicU16; - LocalBits @ AtomicU16; - } + } + #[cfg(target_has_atomic = "16")] + { + check_impl! { + Lsb0 @ AtomicU16; + Msb0 @ AtomicU16; + LocalBits @ AtomicU16; } - if atomic(32) { - check_impl! { - Lsb0 @ AtomicU32; - Msb0 @ AtomicU32; - LocalBits @ AtomicU32; - } + } + #[cfg(target_has_atomic = "32")] + { + check_impl! { + Lsb0 @ AtomicU32; + Msb0 @ AtomicU32; + LocalBits @ AtomicU32; } - if atomic(ptr) { - check_impl! { - Lsb0 @ AtomicUsize; - Msb0 @ AtomicUsize; - LocalBits @ AtomicUsize; - } + } + #[cfg(target_has_atomic = "ptr")] + { + check_impl! { + Lsb0 @ AtomicUsize; + Msb0 @ AtomicUsize; + LocalBits @ AtomicUsize; } } + #[cfg(target_pointer_width = "64")] check_impl! { Lsb0 @ u64, RadiumU64; @@ -149,12 +152,13 @@ mod tests { LocalBits @ u64, RadiumU64; } #[cfg(target_pointer_width = "64")] - radium::if_atomic!(if atomic(64) { + #[cfg(target_has_atomic = "64")] + { check_impl! { Lsb0 @ AtomicU64; Msb0 @ AtomicU64; LocalBits @ AtomicU64; } - }); + } } } --- a\/src\/store.rs +++ b\/src\/store.rs @@ -199,49 +199,49 @@ store!(usize => BitSafeUsize); \/\/\/ Generates `BitStore` implementations for atomic types. macro_rules! atomic { ($($size:tt, $base:ty => $atom:ident);+ $(;)?) => { $( - radium::if_atomic!(if atomic($size) { - use core::sync::atomic::$atom; + #[cfg(target_has_atomic = $size)] + use core::sync::atomic::$atom; - impl BitStore for $atom { - type Mem = $base; - type Access = Self; - type Alias = Self; - type Unalias = Self; - - const ZERO: Self = ::new(0); - - #[inline] - fn new(value: Self::Mem) -> Self { ::new(value) } - - #[inline] - fn load_value(&self) -> Self::Mem { - self.load(core::sync::atomic::Ordering::Relaxed) - } - - #[inline] - fn store_value(&mut self, value: Self::Mem) { - *self = Self::new(value); - } - - const ALIGNED_TO_SIZE: [(); 1] - = [(); mem::aligned_to_size::() as usize]; + #[cfg(target_has_atomic = $size)] + impl BitStore for $atom { + type Mem = $base; + type Access = Self; + type Alias = Self; + type Unalias = Self; + + const ZERO: Self = ::new(0); + + #[inline] + fn new(value: Self::Mem) -> Self { ::new(value) } + + #[inline] + fn load_value(&self) -> Self::Mem { + self.load(core::sync::atomic::Ordering::Relaxed) + } - const ALIAS_WIDTH: [(); 1] = [()]; + #[inline] + fn store_value(&mut self, value: Self::Mem) { + *self = Self::new(value); } - }); + + const ALIGNED_TO_SIZE: [(); 1] + = [(); mem::aligned_to_size::() as usize]; + + const ALIAS_WIDTH: [(); 1] = [()]; + } )+ }; } atomic! { - 8, u8 => AtomicU8; - 16, u16 => AtomicU16; - 32, u32 => AtomicU32; + "8", u8 => AtomicU8; + "16", u16 => AtomicU16; + "32", u32 => AtomicU32; } #[cfg(target_pointer_width = "64")] -atomic!(64, u64 => AtomicU64); +atomic!("64", u64 => AtomicU64); -atomic!(size, usize => AtomicUsize); +atomic!("ptr", usize => AtomicUsize); #[cfg(test)] mod tests { @@ -265,11 +265,12 @@ mod tests { cell.store_value(39); assert_eq!(cell.load_value(), 39); - radium::if_atomic!(if atomic(size) { + #[cfg(target_has_atomic = "ptr")] + { let mut atom = AtomicUsize::new(0); atom.store_value(57); assert_eq!(atom.load_value(), 57); - }); + } } \/\/\/ Unaliased `BitSlice`s are universally threadsafe, because they satisfy

Other Versions#

Patches#