mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Change generic LANES to N

Browse Source
This commit is contained in:
Caleb Zulawski 2023-10-20 20:58:04 -04:00
parent 0f59409064
commit 32b195ab2b
20 changed files with 313 additions and 314 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
crates/core_simd/src/fmt.rs
View File

@ -1,9 +1,9 @@
use crate::simd::{LaneCount, Simd, SimdElement, SupportedLaneCount};
use core::fmt;
impl<T, const LANES: usize> fmt::Debug for Simd<T, LANES>
impl<T, const N: usize> fmt::Debug for Simd<T, N>
where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
T: SimdElement + fmt::Debug,
{
/// A `Simd<T, N>` has a debug format like the one for `[T]`:

16
crates/core_simd/src/iter.rs
View File

@ -6,9 +6,9 @@ use core::{
macro_rules! impl_traits {
{ $type:ty } => {
impl<const LANES: usize> Sum<Self> for Simd<$type, LANES>
impl<const N: usize> Sum<Self> for Simd<$type, N>
where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
@ -16,9 +16,9 @@ macro_rules! impl_traits {
}
}
impl<const LANES: usize> Product<Self> for Simd<$type, LANES>
impl<const N: usize> Product<Self> for Simd<$type, N>
where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
fn product<I: Iterator<Item = Self>>(iter: I) -> Self {
@ -26,9 +26,9 @@ macro_rules! impl_traits {
}
}
impl<'a, const LANES: usize> Sum<&'a Self> for Simd<$type, LANES>
impl<'a, const N: usize> Sum<&'a Self> for Simd<$type, N>
where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self {
@ -36,9 +36,9 @@ macro_rules! impl_traits {
}
}
impl<'a, const LANES: usize> Product<&'a Self> for Simd<$type, LANES>
impl<'a, const N: usize> Product<&'a Self> for Simd<$type, N>
where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self {

8
crates/core_simd/src/lane_count.rs
View File

@ -4,11 +4,11 @@ mod sealed {
use sealed::Sealed;
/// Specifies the number of lanes in a SIMD vector as a type.
pub struct LaneCount<const LANES: usize>;
pub struct LaneCount<const N: usize>;
impl<const LANES: usize> LaneCount<LANES> {
impl<const N: usize> LaneCount<N> {
/// The number of bytes in a bitmask with this many lanes.
pub const BITMASK_LEN: usize = (LANES + 7) / 8;
pub const BITMASK_LEN: usize = (N + 7) / 8;
}
/// Statically guarantees that a lane count is marked as supported.
@ -21,7 +21,7 @@ pub trait SupportedLaneCount: Sealed {
type BitMask: Copy + Default + AsRef<[u8]> + AsMut<[u8]>;
}
impl<const LANES: usize> Sealed for LaneCount<LANES> {}
impl<const N: usize> Sealed for LaneCount<N> {}
macro_rules! supported_lane_count {
($($lanes:literal),+) => {

165
crates/core_simd/src/masks.rs
View File

@ -31,9 +31,9 @@ mod sealed {
/// prevent us from ever removing that bound, or from implementing `MaskElement` on
/// non-`PartialEq` types in the future.
pub trait Sealed {
fn valid<const LANES: usize>(values: Simd<Self, LANES>) -> bool
fn valid<const N: usize>(values: Simd<Self, N>) -> bool
where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
Self: SimdElement;
fn eq(self, other: Self) -> bool;
@ -55,9 +55,9 @@ macro_rules! impl_element {
{ $ty:ty } => {
impl Sealed for $ty {
#[inline]
fn valid<const LANES: usize>(value: Simd<Self, LANES>) -> bool
fn valid<const N: usize>(value: Simd<Self, N>) -> bool
where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
(value.simd_eq(Simd::splat(0 as _)) | value.simd_eq(Simd::splat(-1 as _))).all()
}
@ -80,30 +80,30 @@ impl_element! { i32 }
impl_element! { i64 }
impl_element! { isize }
/// A SIMD vector mask for `LANES` elements of width specified by `Element`.
/// A SIMD vector mask for `N` elements of width specified by `Element`.
///
/// Masks represent boolean inclusion/exclusion on a per-element basis.
///
/// The layout of this type is unspecified, and may change between platforms
/// and/or Rust versions, and code should not assume that it is equivalent to
/// `[T; LANES]`.
/// `[T; N]`.
#[repr(transparent)]
pub struct Mask<T, const LANES: usize>(mask_impl::Mask<T, LANES>)
pub struct Mask<T, const N: usize>(mask_impl::Mask<T, N>)
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount;
LaneCount<N>: SupportedLaneCount;
impl<T, const LANES: usize> Copy for Mask<T, LANES>
impl<T, const N: usize> Copy for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
}
impl<T, const LANES: usize> Clone for Mask<T, LANES>
impl<T, const N: usize> Clone for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
fn clone(&self) -> Self {
@ -111,10 +111,10 @@ where
}
}
impl<T, const LANES: usize> Mask<T, LANES>
impl<T, const N: usize> Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
/// Construct a mask by setting all elements to the given value.
#[inline]
@ -124,7 +124,7 @@ where
/// Converts an array of bools to a SIMD mask.
#[inline]
pub fn from_array(array: [bool; LANES]) -> Self {
pub fn from_array(array: [bool; N]) -> Self {
// SAFETY: Rust's bool has a layout of 1 byte (u8) with a value of
// true: 0b_0000_0001
// false: 0b_0000_0000
@ -132,16 +132,15 @@ where
// This would be hypothetically valid as an "in-place" transmute,
// but these are "dependently-sized" types, so copy elision it is!
unsafe {
let bytes: [u8; LANES] = mem::transmute_copy(&array);
let bools: Simd<i8, LANES> =
intrinsics::simd_ne(Simd::from_array(bytes), Simd::splat(0u8));
let bytes: [u8; N] = mem::transmute_copy(&array);
let bools: Simd<i8, N> = intrinsics::simd_ne(Simd::from_array(bytes), Simd::splat(0u8));
Mask::from_int_unchecked(intrinsics::simd_cast(bools))
}
}
/// Converts a SIMD mask to an array of bools.
#[inline]
pub fn to_array(self) -> [bool; LANES] {
pub fn to_array(self) -> [bool; N] {
// This follows mostly the same logic as from_array.
// SAFETY: Rust's bool has a layout of 1 byte (u8) with a value of
// true: 0b_0000_0001
@ -153,7 +152,7 @@ where
// This would be hypothetically valid as an "in-place" transmute,
// but these are "dependently-sized" types, so copy elision it is!
unsafe {
let mut bytes: Simd<i8, LANES> = intrinsics::simd_cast(self.to_int());
let mut bytes: Simd<i8, N> = intrinsics::simd_cast(self.to_int());
bytes &= Simd::splat(1i8);
mem::transmute_copy(&bytes)
}
@ -166,7 +165,7 @@ where
/// All elements must be either 0 or -1.
#[inline]
#[must_use = "method returns a new mask and does not mutate the original value"]
pub unsafe fn from_int_unchecked(value: Simd<T, LANES>) -> Self {
pub unsafe fn from_int_unchecked(value: Simd<T, N>) -> Self {
// Safety: the caller must confirm this invariant
unsafe { Self(mask_impl::Mask::from_int_unchecked(value)) }
}
@ -179,7 +178,7 @@ where
#[inline]
#[must_use = "method returns a new mask and does not mutate the original value"]
#[track_caller]
pub fn from_int(value: Simd<T, LANES>) -> Self {
pub fn from_int(value: Simd<T, N>) -> Self {
assert!(T::valid(value), "all values must be either 0 or -1",);
// Safety: the validity has been checked
unsafe { Self::from_int_unchecked(value) }
@ -189,14 +188,14 @@ where
/// represents `true`.
#[inline]
#[must_use = "method returns a new vector and does not mutate the original value"]
pub fn to_int(self) -> Simd<T, LANES> {
pub fn to_int(self) -> Simd<T, N> {
self.0.to_int()
}
/// Converts the mask to a mask of any other element size.
#[inline]
#[must_use = "method returns a new mask and does not mutate the original value"]
pub fn cast<U: MaskElement>(self) -> Mask<U, LANES> {
pub fn cast<U: MaskElement>(self) -> Mask<U, N> {
Mask(self.0.convert())
}
@ -219,7 +218,7 @@ where
#[must_use = "method returns a new bool and does not mutate the original value"]
#[track_caller]
pub fn test(&self, index: usize) -> bool {
assert!(index < LANES, "element index out of range");
assert!(index < N, "element index out of range");
// Safety: the element index has been checked
unsafe { self.test_unchecked(index) }
}
@ -243,7 +242,7 @@ where
#[inline]
#[track_caller]
pub fn set(&mut self, index: usize, value: bool) {
assert!(index < LANES, "element index out of range");
assert!(index < N, "element index out of range");
// Safety: the element index has been checked
unsafe {
self.set_unchecked(index, value);
@ -266,32 +265,32 @@ where
}
// vector/array conversion
impl<T, const LANES: usize> From<[bool; LANES]> for Mask<T, LANES>
impl<T, const N: usize> From<[bool; N]> for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
fn from(array: [bool; LANES]) -> Self {
fn from(array: [bool; N]) -> Self {
Self::from_array(array)
}
}
impl<T, const LANES: usize> From<Mask<T, LANES>> for [bool; LANES]
impl<T, const N: usize> From<Mask<T, N>> for [bool; N]
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
fn from(vector: Mask<T, LANES>) -> Self {
fn from(vector: Mask<T, N>) -> Self {
vector.to_array()
}
}
impl<T, const LANES: usize> Default for Mask<T, LANES>
impl<T, const N: usize> Default for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
#[must_use = "method returns a defaulted mask with all elements set to false (0)"]
@ -300,10 +299,10 @@ where
}
}
impl<T, const LANES: usize> PartialEq for Mask<T, LANES>
impl<T, const N: usize> PartialEq for Mask<T, N>
where
T: MaskElement + PartialEq,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
#[must_use = "method returns a new bool and does not mutate the original value"]
@ -312,10 +311,10 @@ where
}
}
impl<T, const LANES: usize> PartialOrd for Mask<T, LANES>
impl<T, const N: usize> PartialOrd for Mask<T, N>
where
T: MaskElement + PartialOrd,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
#[must_use = "method returns a new Ordering and does not mutate the original value"]
@ -324,23 +323,23 @@ where
}
}
impl<T, const LANES: usize> fmt::Debug for Mask<T, LANES>
impl<T, const N: usize> fmt::Debug for Mask<T, N>
where
T: MaskElement + fmt::Debug,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_list()
.entries((0..LANES).map(|i| self.test(i)))
.entries((0..N).map(|i| self.test(i)))
.finish()
}
}
impl<T, const LANES: usize> core::ops::BitAnd for Mask<T, LANES>
impl<T, const N: usize> core::ops::BitAnd for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
type Output = Self;
#[inline]
@ -350,10 +349,10 @@ where
}
}
impl<T, const LANES: usize> core::ops::BitAnd<bool> for Mask<T, LANES>
impl<T, const N: usize> core::ops::BitAnd<bool> for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
type Output = Self;
#[inline]
@ -363,23 +362,23 @@ where
}
}
impl<T, const LANES: usize> core::ops::BitAnd<Mask<T, LANES>> for bool
impl<T, const N: usize> core::ops::BitAnd<Mask<T, N>> for bool
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
type Output = Mask<T, LANES>;
type Output = Mask<T, N>;
#[inline]
#[must_use = "method returns a new mask and does not mutate the original value"]
fn bitand(self, rhs: Mask<T, LANES>) -> Mask<T, LANES> {
fn bitand(self, rhs: Mask<T, N>) -> Mask<T, N> {
Mask::splat(self) & rhs
}
}
impl<T, const LANES: usize> core::ops::BitOr for Mask<T, LANES>
impl<T, const N: usize> core::ops::BitOr for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
type Output = Self;
#[inline]
@ -389,10 +388,10 @@ where
}
}
impl<T, const LANES: usize> core::ops::BitOr<bool> for Mask<T, LANES>
impl<T, const N: usize> core::ops::BitOr<bool> for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
type Output = Self;
#[inline]
@ -402,23 +401,23 @@ where
}
}
impl<T, const LANES: usize> core::ops::BitOr<Mask<T, LANES>> for bool
impl<T, const N: usize> core::ops::BitOr<Mask<T, N>> for bool
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
type Output = Mask<T, LANES>;
type Output = Mask<T, N>;
#[inline]
#[must_use = "method returns a new mask and does not mutate the original value"]
fn bitor(self, rhs: Mask<T, LANES>) -> Mask<T, LANES> {
fn bitor(self, rhs: Mask<T, N>) -> Mask<T, N> {
Mask::splat(self) | rhs
}
}
impl<T, const LANES: usize> core::ops::BitXor for Mask<T, LANES>
impl<T, const N: usize> core::ops::BitXor for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
type Output = Self;
#[inline]
@ -428,10 +427,10 @@ where
}
}
impl<T, const LANES: usize> core::ops::BitXor<bool> for Mask<T, LANES>
impl<T, const N: usize> core::ops::BitXor<bool> for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
type Output = Self;
#[inline]
@ -441,25 +440,25 @@ where
}
}
impl<T, const LANES: usize> core::ops::BitXor<Mask<T, LANES>> for bool
impl<T, const N: usize> core::ops::BitXor<Mask<T, N>> for bool
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
type Output = Mask<T, LANES>;
type Output = Mask<T, N>;
#[inline]
#[must_use = "method returns a new mask and does not mutate the original value"]
fn bitxor(self, rhs: Mask<T, LANES>) -> Self::Output {
fn bitxor(self, rhs: Mask<T, N>) -> Self::Output {
Mask::splat(self) ^ rhs
}
}
impl<T, const LANES: usize> core::ops::Not for Mask<T, LANES>
impl<T, const N: usize> core::ops::Not for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
type Output = Mask<T, LANES>;
type Output = Mask<T, N>;
#[inline]
#[must_use = "method returns a new mask and does not mutate the original value"]
fn not(self) -> Self::Output {
@ -467,10 +466,10 @@ where
}
}
impl<T, const LANES: usize> core::ops::BitAndAssign for Mask<T, LANES>
impl<T, const N: usize> core::ops::BitAndAssign for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
fn bitand_assign(&mut self, rhs: Self) {
@ -478,10 +477,10 @@ where
}
}
impl<T, const LANES: usize> core::ops::BitAndAssign<bool> for Mask<T, LANES>
impl<T, const N: usize> core::ops::BitAndAssign<bool> for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
fn bitand_assign(&mut self, rhs: bool) {
@ -489,10 +488,10 @@ where
}
}
impl<T, const LANES: usize> core::ops::BitOrAssign for Mask<T, LANES>
impl<T, const N: usize> core::ops::BitOrAssign for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
fn bitor_assign(&mut self, rhs: Self) {
@ -500,10 +499,10 @@ where
}
}
impl<T, const LANES: usize> core::ops::BitOrAssign<bool> for Mask<T, LANES>
impl<T, const N: usize> core::ops::BitOrAssign<bool> for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
fn bitor_assign(&mut self, rhs: bool) {
@ -511,10 +510,10 @@ where
}
}
impl<T, const LANES: usize> core::ops::BitXorAssign for Mask<T, LANES>
impl<T, const N: usize> core::ops::BitXorAssign for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
fn bitxor_assign(&mut self, rhs: Self) {
@ -522,10 +521,10 @@ where
}
}
impl<T, const LANES: usize> core::ops::BitXorAssign<bool> for Mask<T, LANES>
impl<T, const N: usize> core::ops::BitXorAssign<bool> for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
fn bitxor_assign(&mut self, rhs: bool) {
@ -536,12 +535,12 @@ where
macro_rules! impl_from {
{ $from:ty => $($to:ty),* } => {
$(
impl<const LANES: usize> From<Mask<$from, LANES>> for Mask<$to, LANES>
impl<const N: usize> From<Mask<$from, N>> for Mask<$to, N>
where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
fn from(value: Mask<$from, LANES>) -> Self {
fn from(value: Mask<$from, N>) -> Self {
value.cast()
}
}

74
crates/core_simd/src/masks/bitmask.rs
View File

@ -6,25 +6,25 @@ use core::marker::PhantomData;
/// A mask where each lane is represented by a single bit.
#[repr(transparent)]
pub struct Mask<T, const LANES: usize>(
<LaneCount<LANES> as SupportedLaneCount>::BitMask,
pub struct Mask<T, const N: usize>(
<LaneCount<N> as SupportedLaneCount>::BitMask,
PhantomData<T>,
)
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount;
LaneCount<N>: SupportedLaneCount;
impl<T, const LANES: usize> Copy for Mask<T, LANES>
impl<T, const N: usize> Copy for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
}
impl<T, const LANES: usize> Clone for Mask<T, LANES>
impl<T, const N: usize> Clone for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
fn clone(&self) -> Self {
@ -32,10 +32,10 @@ where
}
}
impl<T, const LANES: usize> PartialEq for Mask<T, LANES>
impl<T, const N: usize> PartialEq for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
fn eq(&self, other: &Self) -> bool {
@ -43,10 +43,10 @@ where
}
}
impl<T, const LANES: usize> PartialOrd for Mask<T, LANES>
impl<T, const N: usize> PartialOrd for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
@ -54,17 +54,17 @@ where
}
}
impl<T, const LANES: usize> Eq for Mask<T, LANES>
impl<T, const N: usize> Eq for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
}
impl<T, const LANES: usize> Ord for Mask<T, LANES>
impl<T, const N: usize> Ord for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
fn cmp(&self, other: &Self) -> core::cmp::Ordering {
@ -72,22 +72,22 @@ where
}
}
impl<T, const LANES: usize> Mask<T, LANES>
impl<T, const N: usize> Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
#[must_use = "method returns a new mask and does not mutate the original value"]
pub fn splat(value: bool) -> Self {
let mut mask = <LaneCount<LANES> as SupportedLaneCount>::BitMask::default();
let mut mask = <LaneCount<N> as SupportedLaneCount>::BitMask::default();
if value {
mask.as_mut().fill(u8::MAX)
} else {
mask.as_mut().fill(u8::MIN)
}
if LANES % 8 > 0 {
*mask.as_mut().last_mut().unwrap() &= u8::MAX >> (8 - LANES % 8);
if N % 8 > 0 {
*mask.as_mut().last_mut().unwrap() &= u8::MAX >> (8 - N % 8);
}
Self(mask, PhantomData)
}
@ -107,7 +107,7 @@ where
#[inline]
#[must_use = "method returns a new vector and does not mutate the original value"]
pub fn to_int(self) -> Simd<T, LANES> {
pub fn to_int(self) -> Simd<T, N> {
unsafe {
intrinsics::simd_select_bitmask(self.0, Simd::splat(T::TRUE), Simd::splat(T::FALSE))
}
@ -115,7 +115,7 @@ where
#[inline]
#[must_use = "method returns a new mask and does not mutate the original value"]
pub unsafe fn from_int_unchecked(value: Simd<T, LANES>) -> Self {
pub unsafe fn from_int_unchecked(value: Simd<T, N>) -> Self {
unsafe { Self(intrinsics::simd_bitmask(value), PhantomData) }
}
@ -140,7 +140,7 @@ where
#[inline]
pub fn to_bitmask_integer<U>(self) -> U
where
super::Mask<T, LANES>: ToBitMask<BitMask = U>,
super::Mask<T, N>: ToBitMask<BitMask = U>,
{
// Safety: these are the same types
unsafe { core::mem::transmute_copy(&self.0) }
@ -149,7 +149,7 @@ where
#[inline]
pub fn from_bitmask_integer<U>(bitmask: U) -> Self
where
super::Mask<T, LANES>: ToBitMask<BitMask = U>,
super::Mask<T, N>: ToBitMask<BitMask = U>,
{
// Safety: these are the same types
unsafe { Self(core::mem::transmute_copy(&bitmask), PhantomData) }
@ -157,7 +157,7 @@ where
#[inline]
#[must_use = "method returns a new mask and does not mutate the original value"]
pub fn convert<U>(self) -> Mask<U, LANES>
pub fn convert<U>(self) -> Mask<U, N>
where
U: MaskElement,
{
@ -178,11 +178,11 @@ where
}
}
impl<T, const LANES: usize> core::ops::BitAnd for Mask<T, LANES>
impl<T, const N: usize> core::ops::BitAnd for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
<LaneCount<LANES> as SupportedLaneCount>::BitMask: AsRef<[u8]> + AsMut<[u8]>,
LaneCount<N>: SupportedLaneCount,
<LaneCount<N> as SupportedLaneCount>::BitMask: AsRef<[u8]> + AsMut<[u8]>,
{
type Output = Self;
#[inline]
@ -195,11 +195,11 @@ where
}
}
impl<T, const LANES: usize> core::ops::BitOr for Mask<T, LANES>
impl<T, const N: usize> core::ops::BitOr for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
<LaneCount<LANES> as SupportedLaneCount>::BitMask: AsRef<[u8]> + AsMut<[u8]>,
LaneCount<N>: SupportedLaneCount,
<LaneCount<N> as SupportedLaneCount>::BitMask: AsRef<[u8]> + AsMut<[u8]>,
{
type Output = Self;
#[inline]
@ -212,10 +212,10 @@ where
}
}
impl<T, const LANES: usize> core::ops::BitXor for Mask<T, LANES>
impl<T, const N: usize> core::ops::BitXor for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
type Output = Self;
#[inline]
@ -228,10 +228,10 @@ where
}
}
impl<T, const LANES: usize> core::ops::Not for Mask<T, LANES>
impl<T, const N: usize> core::ops::Not for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
type Output = Self;
#[inline]
@ -240,8 +240,8 @@ where
for x in self.0.as_mut() {
*x = !*x;
}
if LANES % 8 > 0 {
*self.0.as_mut().last_mut().unwrap() &= u8::MAX >> (8 - LANES % 8);
if N % 8 > 0 {
*self.0.as_mut().last_mut().unwrap() &= u8::MAX >> (8 - N % 8);
}
self
}

82
crates/core_simd/src/masks/full_masks.rs
View File

@ -5,22 +5,22 @@ use crate::simd::intrinsics;
use crate::simd::{LaneCount, Simd, SupportedLaneCount, ToBitMask};
#[repr(transparent)]
pub struct Mask<T, const LANES: usize>(Simd<T, LANES>)
pub struct Mask<T, const N: usize>(Simd<T, N>)
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount;
LaneCount<N>: SupportedLaneCount;
impl<T, const LANES: usize> Copy for Mask<T, LANES>
impl<T, const N: usize> Copy for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
}
impl<T, const LANES: usize> Clone for Mask<T, LANES>
impl<T, const N: usize> Clone for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
#[must_use = "method returns a new mask and does not mutate the original value"]
@ -29,10 +29,10 @@ where
}
}
impl<T, const LANES: usize> PartialEq for Mask<T, LANES>
impl<T, const N: usize> PartialEq for Mask<T, N>
where
T: MaskElement + PartialEq,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
fn eq(&self, other: &Self) -> bool {
@ -40,10 +40,10 @@ where
}
}
impl<T, const LANES: usize> PartialOrd for Mask<T, LANES>
impl<T, const N: usize> PartialOrd for Mask<T, N>
where
T: MaskElement + PartialOrd,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
@ -51,17 +51,17 @@ where
}
}
impl<T, const LANES: usize> Eq for Mask<T, LANES>
impl<T, const N: usize> Eq for Mask<T, N>
where
T: MaskElement + Eq,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
}
impl<T, const LANES: usize> Ord for Mask<T, LANES>
impl<T, const N: usize> Ord for Mask<T, N>
where
T: MaskElement + Ord,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
fn cmp(&self, other: &Self) -> core::cmp::Ordering {
@ -98,10 +98,10 @@ macro_rules! impl_reverse_bits {
impl_reverse_bits! { u8, u16, u32, u64 }
impl<T, const LANES: usize> Mask<T, LANES>
impl<T, const N: usize> Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
#[must_use = "method returns a new mask and does not mutate the original value"]
@ -122,19 +122,19 @@ where
#[inline]
#[must_use = "method returns a new vector and does not mutate the original value"]
pub fn to_int(self) -> Simd<T, LANES> {
pub fn to_int(self) -> Simd<T, N> {
self.0
}
#[inline]
#[must_use = "method returns a new mask and does not mutate the original value"]
pub unsafe fn from_int_unchecked(value: Simd<T, LANES>) -> Self {
pub unsafe fn from_int_unchecked(value: Simd<T, N>) -> Self {
Self(value)
}
#[inline]
#[must_use = "method returns a new mask and does not mutate the original value"]
pub fn convert<U>(self) -> Mask<U, LANES>
pub fn convert<U>(self) -> Mask<U, N>
where
U: MaskElement,
{
@ -144,18 +144,18 @@ where
#[inline]
#[must_use = "method returns a new array and does not mutate the original value"]
pub fn to_bitmask_array<const N: usize>(self) -> [u8; N]
pub fn to_bitmask_array<const M: usize>(self) -> [u8; M]
where
super::Mask<T, LANES>: ToBitMaskArray,
super::Mask<T, N>: ToBitMaskArray,
{
// Safety: Bytes is the right size array
unsafe {
// Compute the bitmask
let bitmask: <super::Mask<T, LANES> as ToBitMaskArray>::BitMaskArray =
let bitmask: <super::Mask<T, N> as ToBitMaskArray>::BitMaskArray =
intrinsics::simd_bitmask(self.0);
// Transmute to the return type
let mut bitmask: [u8; N] = core::mem::transmute_copy(&bitmask);
let mut bitmask: [u8; M] = core::mem::transmute_copy(&bitmask);
// LLVM assumes bit order should match endianness
if cfg!(target_endian = "big") {
@ -170,9 +170,9 @@ where
#[inline]
#[must_use = "method returns a new mask and does not mutate the original value"]
pub fn from_bitmask_array<const N: usize>(mut bitmask: [u8; N]) -> Self
pub fn from_bitmask_array<const M: usize>(mut bitmask: [u8; M]) -> Self
where
super::Mask<T, LANES>: ToBitMaskArray,
super::Mask<T, N>: ToBitMaskArray,
{
// Safety: Bytes is the right size array
unsafe {
@ -184,7 +184,7 @@ where
}
// Transmute to the bitmask
let bitmask: <super::Mask<T, LANES> as ToBitMaskArray>::BitMaskArray =
let bitmask: <super::Mask<T, N> as ToBitMaskArray>::BitMaskArray =
core::mem::transmute_copy(&bitmask);
// Compute the regular mask
@ -199,14 +199,14 @@ where
#[inline]
pub(crate) fn to_bitmask_integer<U: ReverseBits>(self) -> U
where
super::Mask<T, LANES>: ToBitMask<BitMask = U>,
super::Mask<T, N>: ToBitMask<BitMask = U>,
{
// Safety: U is required to be the appropriate bitmask type
let bitmask: U = unsafe { intrinsics::simd_bitmask(self.0) };
// LLVM assumes bit order should match endianness
if cfg!(target_endian = "big") {
bitmask.reverse_bits(LANES)
bitmask.reverse_bits(N)
} else {
bitmask
}
@ -215,11 +215,11 @@ where
#[inline]
pub(crate) fn from_bitmask_integer<U: ReverseBits>(bitmask: U) -> Self
where
super::Mask<T, LANES>: ToBitMask<BitMask = U>,
super::Mask<T, N>: ToBitMask<BitMask = U>,
{
// LLVM assumes bit order should match endianness
let bitmask = if cfg!(target_endian = "big") {
bitmask.reverse_bits(LANES)
bitmask.reverse_bits(N)
} else {
bitmask
};
@ -249,21 +249,21 @@ where
}
}
impl<T, const LANES: usize> From<Mask<T, LANES>> for Simd<T, LANES>
impl<T, const N: usize> From<Mask<T, N>> for Simd<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
fn from(value: Mask<T, LANES>) -> Self {
fn from(value: Mask<T, N>) -> Self {
value.0
}
}
impl<T, const LANES: usize> core::ops::BitAnd for Mask<T, LANES>
impl<T, const N: usize> core::ops::BitAnd for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
type Output = Self;
#[inline]
@ -274,10 +274,10 @@ where
}
}
impl<T, const LANES: usize> core::ops::BitOr for Mask<T, LANES>
impl<T, const N: usize> core::ops::BitOr for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
type Output = Self;
#[inline]
@ -288,10 +288,10 @@ where
}
}
impl<T, const LANES: usize> core::ops::BitXor for Mask<T, LANES>
impl<T, const N: usize> core::ops::BitXor for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
type Output = Self;
#[inline]
@ -302,10 +302,10 @@ where
}
}
impl<T, const LANES: usize> core::ops::Not for Mask<T, LANES>
impl<T, const N: usize> core::ops::Not for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
type Output = Self;
#[inline]

4
crates/core_simd/src/masks/to_bitmask.rs
View File

@ -7,10 +7,10 @@ mod sealed {
}
pub use sealed::Sealed;
impl<T, const LANES: usize> Sealed for Mask<T, LANES>
impl<T, const N: usize> Sealed for Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
}

8
crates/core_simd/src/ops.rs
View File

@ -9,10 +9,10 @@ mod deref;
mod shift_scalar;
mod unary;
impl<I, T, const LANES: usize> core::ops::Index<I> for Simd<T, LANES>
impl<I, T, const N: usize> core::ops::Index<I> for Simd<T, N>
where
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
I: core::slice::SliceIndex<[T]>,
{
type Output = I::Output;
@ -22,10 +22,10 @@ where
}
}
impl<I, T, const LANES: usize> core::ops::IndexMut<I> for Simd<T, LANES>
impl<I, T, const N: usize> core::ops::IndexMut<I> for Simd<T, N>
where
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
I: core::slice::SliceIndex<[T]>,
{
#[inline]

26
crates/core_simd/src/ops/assign.rs
View File

@ -8,7 +8,7 @@ use core::ops::{ShlAssign, ShrAssign}; // non-commutative bit binary op-assignme
// Arithmetic
macro_rules! assign_ops {
($(impl<T, U, const LANES: usize> $assignTrait:ident<U> for Simd<T, LANES>
($(impl<T, U, const N: usize> $assignTrait:ident<U> for Simd<T, N>
where
Self: $trait:ident,
{
@ -16,11 +16,11 @@ macro_rules! assign_ops {
$call:ident
}
})*) => {
$(impl<T, U, const LANES: usize> $assignTrait<U> for Simd<T, LANES>
$(impl<T, U, const N: usize> $assignTrait<U> for Simd<T, N>
where
Self: $trait<U, Output = Self>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
fn $assign_call(&mut self, rhs: U) {
@ -32,7 +32,7 @@ macro_rules! assign_ops {
assign_ops! {
// Arithmetic
impl<T, U, const LANES: usize> AddAssign<U> for Simd<T, LANES>
impl<T, U, const N: usize> AddAssign<U> for Simd<T, N>
where
Self: Add,
{
@ -41,7 +41,7 @@ assign_ops! {
}
}
impl<T, U, const LANES: usize> MulAssign<U> for Simd<T, LANES>
impl<T, U, const N: usize> MulAssign<U> for Simd<T, N>
where
Self: Mul,
{
@ -50,7 +50,7 @@ assign_ops! {
}
}
impl<T, U, const LANES: usize> SubAssign<U> for Simd<T, LANES>
impl<T, U, const N: usize> SubAssign<U> for Simd<T, N>
where
Self: Sub,
{
@ -59,7 +59,7 @@ assign_ops! {
}
}
impl<T, U, const LANES: usize> DivAssign<U> for Simd<T, LANES>
impl<T, U, const N: usize> DivAssign<U> for Simd<T, N>
where
Self: Div,
{
@ -67,7 +67,7 @@ assign_ops! {
div
}
}
impl<T, U, const LANES: usize> RemAssign<U> for Simd<T, LANES>
impl<T, U, const N: usize> RemAssign<U> for Simd<T, N>
where
Self: Rem,
{
@ -77,7 +77,7 @@ assign_ops! {
}
// Bitops
impl<T, U, const LANES: usize> BitAndAssign<U> for Simd<T, LANES>
impl<T, U, const N: usize> BitAndAssign<U> for Simd<T, N>
where
Self: BitAnd,
{
@ -86,7 +86,7 @@ assign_ops! {
}
}
impl<T, U, const LANES: usize> BitOrAssign<U> for Simd<T, LANES>
impl<T, U, const N: usize> BitOrAssign<U> for Simd<T, N>
where
Self: BitOr,
{
@ -95,7 +95,7 @@ assign_ops! {
}
}
impl<T, U, const LANES: usize> BitXorAssign<U> for Simd<T, LANES>
impl<T, U, const N: usize> BitXorAssign<U> for Simd<T, N>
where
Self: BitXor,
{
@ -104,7 +104,7 @@ assign_ops! {
}
}
impl<T, U, const LANES: usize> ShlAssign<U> for Simd<T, LANES>
impl<T, U, const N: usize> ShlAssign<U> for Simd<T, N>
where
Self: Shl,
{
@ -113,7 +113,7 @@ assign_ops! {
}
}
impl<T, U, const LANES: usize> ShrAssign<U> for Simd<T, LANES>
impl<T, U, const N: usize> ShrAssign<U> for Simd<T, N>
where
Self: Shr,
{

46
crates/core_simd/src/ops/deref.rs
View File

@ -5,16 +5,16 @@
use super::*;
macro_rules! deref_lhs {
(impl<T, const LANES: usize> $trait:ident for $simd:ty {
(impl<T, const N: usize> $trait:ident for $simd:ty {
fn $call:ident
}) => {
impl<T, const LANES: usize> $trait<$simd> for &$simd
impl<T, const N: usize> $trait<$simd> for &$simd
where
T: SimdElement,
$simd: $trait<$simd, Output = $simd>,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
type Output = Simd<T, LANES>;
type Output = Simd<T, N>;
#[inline]
#[must_use = "operator returns a new vector without mutating the inputs"]
@ -26,16 +26,16 @@ macro_rules! deref_lhs {
}
macro_rules! deref_rhs {
(impl<T, const LANES: usize> $trait:ident for $simd:ty {
(impl<T, const N: usize> $trait:ident for $simd:ty {
fn $call:ident
}) => {
impl<T, const LANES: usize> $trait<&$simd> for $simd
impl<T, const N: usize> $trait<&$simd> for $simd
where
T: SimdElement,
$simd: $trait<$simd, Output = $simd>,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
type Output = Simd<T, LANES>;
type Output = Simd<T, N>;
#[inline]
#[must_use = "operator returns a new vector without mutating the inputs"]
@ -47,25 +47,25 @@ macro_rules! deref_rhs {
}
macro_rules! deref_ops {
($(impl<T, const LANES: usize> $trait:ident for $simd:ty {
($(impl<T, const N: usize> $trait:ident for $simd:ty {
fn $call:ident
})*) => {
$(
deref_rhs! {
impl<T, const LANES: usize> $trait for $simd {
impl<T, const N: usize> $trait for $simd {
fn $call
}
}
deref_lhs! {
impl<T, const LANES: usize> $trait for $simd {
impl<T, const N: usize> $trait for $simd {
fn $call
}
}
impl<'lhs, 'rhs, T, const LANES: usize> $trait<&'rhs $simd> for &'lhs $simd
impl<'lhs, 'rhs, T, const N: usize> $trait<&'rhs $simd> for &'lhs $simd
where
T: SimdElement,
$simd: $trait<$simd, Output = $simd>,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
type Output = $simd;
@ -81,44 +81,44 @@ macro_rules! deref_ops {
deref_ops! {
// Arithmetic
impl<T, const LANES: usize> Add for Simd<T, LANES> {
impl<T, const N: usize> Add for Simd<T, N> {
fn add
}
impl<T, const LANES: usize> Mul for Simd<T, LANES> {
impl<T, const N: usize> Mul for Simd<T, N> {
fn mul
}
impl<T, const LANES: usize> Sub for Simd<T, LANES> {
impl<T, const N: usize> Sub for Simd<T, N> {
fn sub
}
impl<T, const LANES: usize> Div for Simd<T, LANES> {
impl<T, const N: usize> Div for Simd<T, N> {
fn div
}
impl<T, const LANES: usize> Rem for Simd<T, LANES> {
impl<T, const N: usize> Rem for Simd<T, N> {
fn rem
}
// Bitops
impl<T, const LANES: usize> BitAnd for Simd<T, LANES> {
impl<T, const N: usize> BitAnd for Simd<T, N> {
fn bitand
}
impl<T, const LANES: usize> BitOr for Simd<T, LANES> {
impl<T, const N: usize> BitOr for Simd<T, N> {
fn bitor
}
impl<T, const LANES: usize> BitXor for Simd<T, LANES> {
impl<T, const N: usize> BitXor for Simd<T, N> {
fn bitxor
}
impl<T, const LANES: usize> Shl for Simd<T, LANES> {
impl<T, const N: usize> Shl for Simd<T, N> {
fn shl
}
impl<T, const LANES: usize> Shr for Simd<T, LANES> {
impl<T, const N: usize> Shr for Simd<T, N> {
fn shr
}
}

46
crates/core_simd/src/ops/unary.rs
View File

@ -3,11 +3,11 @@ use crate::simd::{LaneCount, Simd, SimdElement, SupportedLaneCount};
use core::ops::{Neg, Not}; // unary ops
macro_rules! neg {
($(impl<const LANES: usize> Neg for Simd<$scalar:ty, LANES>)*) => {
$(impl<const LANES: usize> Neg for Simd<$scalar, LANES>
($(impl<const N: usize> Neg for Simd<$scalar:ty, N>)*) => {
$(impl<const N: usize> Neg for Simd<$scalar, N>
where
$scalar: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
type Output = Self;
@ -22,27 +22,27 @@ macro_rules! neg {
}
neg! {
impl<const LANES: usize> Neg for Simd<f32, LANES>
impl<const N: usize> Neg for Simd<f32, N>
impl<const LANES: usize> Neg for Simd<f64, LANES>
impl<const N: usize> Neg for Simd<f64, N>
impl<const LANES: usize> Neg for Simd<i8, LANES>
impl<const N: usize> Neg for Simd<i8, N>
impl<const LANES: usize> Neg for Simd<i16, LANES>
impl<const N: usize> Neg for Simd<i16, N>
impl<const LANES: usize> Neg for Simd<i32, LANES>
impl<const N: usize> Neg for Simd<i32, N>
impl<const LANES: usize> Neg for Simd<i64, LANES>
impl<const N: usize> Neg for Simd<i64, N>
impl<const LANES: usize> Neg for Simd<isize, LANES>
impl<const N: usize> Neg for Simd<isize, N>
}
macro_rules! not {
($(impl<const LANES: usize> Not for Simd<$scalar:ty, LANES>)*) => {
$(impl<const LANES: usize> Not for Simd<$scalar, LANES>
($(impl<const N: usize> Not for Simd<$scalar:ty, N>)*) => {
$(impl<const N: usize> Not for Simd<$scalar, N>
where
$scalar: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
type Output = Self;
@ -56,23 +56,23 @@ macro_rules! not {
}
not! {
impl<const LANES: usize> Not for Simd<i8, LANES>
impl<const N: usize> Not for Simd<i8, N>
impl<const LANES: usize> Not for Simd<i16, LANES>
impl<const N: usize> Not for Simd<i16, N>
impl<const LANES: usize> Not for Simd<i32, LANES>
impl<const N: usize> Not for Simd<i32, N>
impl<const LANES: usize> Not for Simd<i64, LANES>
impl<const N: usize> Not for Simd<i64, N>
impl<const LANES: usize> Not for Simd<isize, LANES>
impl<const N: usize> Not for Simd<isize, N>
impl<const LANES: usize> Not for Simd<u8, LANES>
impl<const N: usize> Not for Simd<u8, N>
impl<const LANES: usize> Not for Simd<u16, LANES>
impl<const N: usize> Not for Simd<u16, N>
impl<const LANES: usize> Not for Simd<u32, LANES>
impl<const N: usize> Not for Simd<u32, N>
impl<const LANES: usize> Not for Simd<u64, LANES>
impl<const N: usize> Not for Simd<u64, N>
impl<const LANES: usize> Not for Simd<usize, LANES>
impl<const N: usize> Not for Simd<usize, N>
}

10
crates/core_simd/src/select.rs
View File

@ -1,10 +1,10 @@
use crate::simd::intrinsics;
use crate::simd::{LaneCount, Mask, MaskElement, Simd, SimdElement, SupportedLaneCount};
impl<T, const LANES: usize> Mask<T, LANES>
impl<T, const N: usize> Mask<T, N>
where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
/// Choose elements from two vectors.
///
@ -25,9 +25,9 @@ where
#[must_use = "method returns a new vector and does not mutate the original inputs"]
pub fn select<U>(
self,
true_values: Simd<U, LANES>,
false_values: Simd<U, LANES>,
) -> Simd<U, LANES>
true_values: Simd<U, N>,
false_values: Simd<U, N>,
) -> Simd<U, N>
where
U: SimdElement<Mask = T>,
{

22
crates/core_simd/src/simd/cmp/eq.rs
View File

@ -21,11 +21,11 @@ pub trait SimdPartialEq {
macro_rules! impl_number {
{ $($number:ty),* } => {
$(
impl<const LANES: usize> SimdPartialEq for Simd<$number, LANES>
impl<const N: usize> SimdPartialEq for Simd<$number, N>
where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
type Mask = Mask<<$number as SimdElement>::Mask, LANES>;
type Mask = Mask<<$number as SimdElement>::Mask, N>;
#[inline]
fn simd_eq(self, other: Self) -> Self::Mask {
@ -50,9 +50,9 @@ impl_number! { f32, f64, u8, u16, u32, u64, usize, i8, i16, i32, i64, isize }
macro_rules! impl_mask {
{ $($integer:ty),* } => {
$(
impl<const LANES: usize> SimdPartialEq for Mask<$integer, LANES>
impl<const N: usize> SimdPartialEq for Mask<$integer, N>
where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
type Mask = Self;
@ -76,11 +76,11 @@ macro_rules! impl_mask {
impl_mask! { i8, i16, i32, i64, isize }
impl<T, const LANES: usize> SimdPartialEq for Simd<*const T, LANES>
impl<T, const N: usize> SimdPartialEq for Simd<*const T, N>
where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
type Mask = Mask<isize, LANES>;
type Mask = Mask<isize, N>;
#[inline]
fn simd_eq(self, other: Self) -> Self::Mask {
@ -93,11 +93,11 @@ where
}
}
impl<T, const LANES: usize> SimdPartialEq for Simd<*mut T, LANES>
impl<T, const N: usize> SimdPartialEq for Simd<*mut T, N>
where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
type Mask = Mask<isize, LANES>;
type Mask = Mask<isize, N>;
#[inline]
fn simd_eq(self, other: Self) -> Self::Mask {

36
crates/core_simd/src/simd/cmp/ord.rs
View File

@ -49,9 +49,9 @@ pub trait SimdOrd: SimdPartialOrd {
macro_rules! impl_integer {
{ $($integer:ty),* } => {
$(
impl<const LANES: usize> SimdPartialOrd for Simd<$integer, LANES>
impl<const N: usize> SimdPartialOrd for Simd<$integer, N>
where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
fn simd_lt(self, other: Self) -> Self::Mask {
@ -82,9 +82,9 @@ macro_rules! impl_integer {
}
}
impl<const LANES: usize> SimdOrd for Simd<$integer, LANES>
impl<const N: usize> SimdOrd for Simd<$integer, N>
where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
fn simd_max(self, other: Self) -> Self {
@ -115,9 +115,9 @@ impl_integer! { u8, u16, u32, u64, usize, i8, i16, i32, i64, isize }
macro_rules! impl_float {
{ $($float:ty),* } => {
$(
impl<const LANES: usize> SimdPartialOrd for Simd<$float, LANES>
impl<const N: usize> SimdPartialOrd for Simd<$float, N>
where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
fn simd_lt(self, other: Self) -> Self::Mask {
@ -156,9 +156,9 @@ impl_float! { f32, f64 }
macro_rules! impl_mask {
{ $($integer:ty),* } => {
$(
impl<const LANES: usize> SimdPartialOrd for Mask<$integer, LANES>
impl<const N: usize> SimdPartialOrd for Mask<$integer, N>
where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
fn simd_lt(self, other: Self) -> Self::Mask {
@ -189,9 +189,9 @@ macro_rules! impl_mask {
}
}
impl<const LANES: usize> SimdOrd for Mask<$integer, LANES>
impl<const N: usize> SimdOrd for Mask<$integer, N>
where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
fn simd_max(self, other: Self) -> Self {
@ -219,9 +219,9 @@ macro_rules! impl_mask {
impl_mask! { i8, i16, i32, i64, isize }
impl<T, const LANES: usize> SimdPartialOrd for Simd<*const T, LANES>
impl<T, const N: usize> SimdPartialOrd for Simd<*const T, N>
where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
fn simd_lt(self, other: Self) -> Self::Mask {
@ -244,9 +244,9 @@ where
}
}
impl<T, const LANES: usize> SimdOrd for Simd<*const T, LANES>
impl<T, const N: usize> SimdOrd for Simd<*const T, N>
where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
fn simd_max(self, other: Self) -> Self {
@ -269,9 +269,9 @@ where
}
}
impl<T, const LANES: usize> SimdPartialOrd for Simd<*mut T, LANES>
impl<T, const N: usize> SimdPartialOrd for Simd<*mut T, N>
where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
fn simd_lt(self, other: Self) -> Self::Mask {
@ -294,9 +294,9 @@ where
}
}
impl<T, const LANES: usize> SimdOrd for Simd<*mut T, LANES>
impl<T, const N: usize> SimdOrd for Simd<*mut T, N>
where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
#[inline]
fn simd_max(self, other: Self) -> Self {

18
crates/core_simd/src/simd/num/float.rs
View File

@ -240,20 +240,20 @@ pub trait SimdFloat: Copy + Sealed {
macro_rules! impl_trait {
{ $($ty:ty { bits: $bits_ty:ty, mask: $mask_ty:ty }),* } => {
$(
impl<const LANES: usize> Sealed for Simd<$ty, LANES>
impl<const N: usize> Sealed for Simd<$ty, N>
where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
}
impl<const LANES: usize> SimdFloat for Simd<$ty, LANES>
impl<const N: usize> SimdFloat for Simd<$ty, N>
where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
type Mask = Mask<<$mask_ty as SimdElement>::Mask, LANES>;
type Mask = Mask<<$mask_ty as SimdElement>::Mask, N>;
type Scalar = $ty;
type Bits = Simd<$bits_ty, LANES>;
type Cast<T: SimdElement> = Simd<T, LANES>;
type Bits = Simd<$bits_ty, N>;
type Cast<T: SimdElement> = Simd<T, N>;
#[inline]
fn cast<T: SimdCast>(self) -> Self::Cast<T>
@ -273,14 +273,14 @@ macro_rules! impl_trait {
}
#[inline]
fn to_bits(self) -> Simd<$bits_ty, LANES> {
fn to_bits(self) -> Simd<$bits_ty, N> {
assert_eq!(core::mem::size_of::<Self>(), core::mem::size_of::<Self::Bits>());
// Safety: transmuting between vector types is safe
unsafe { core::mem::transmute_copy(&self) }
}
#[inline]
fn from_bits(bits: Simd<$bits_ty, LANES>) -> Self {
fn from_bits(bits: Simd<$bits_ty, N>) -> Self {
assert_eq!(core::mem::size_of::<Self>(), core::mem::size_of::<Self::Bits>());
// Safety: transmuting between vector types is safe
unsafe { core::mem::transmute_copy(&bits) }

14
crates/core_simd/src/simd/num/int.rs
View File

@ -219,20 +219,20 @@ pub trait SimdInt: Copy + Sealed {
macro_rules! impl_trait {
{ $($ty:ident ($unsigned:ident)),* } => {
$(
impl<const LANES: usize> Sealed for Simd<$ty, LANES>
impl<const N: usize> Sealed for Simd<$ty, N>
where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
}
impl<const LANES: usize> SimdInt for Simd<$ty, LANES>
impl<const N: usize> SimdInt for Simd<$ty, N>
where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
type Mask = Mask<<$ty as SimdElement>::Mask, LANES>;
type Mask = Mask<<$ty as SimdElement>::Mask, N>;
type Scalar = $ty;
type Unsigned = Simd<$unsigned, LANES>;
type Cast<T: SimdElement> = Simd<T, LANES>;
type Unsigned = Simd<$unsigned, N>;
type Cast<T: SimdElement> = Simd<T, N>;
#[inline]
fn cast<T: SimdCast>(self) -> Self::Cast<T> {

10
crates/core_simd/src/simd/num/uint.rs
View File

@ -101,18 +101,18 @@ pub trait SimdUint: Copy + Sealed {
macro_rules! impl_trait {
{ $($ty:ident ($signed:ident)),* } => {
$(
impl<const LANES: usize> Sealed for Simd<$ty, LANES>
impl<const N: usize> Sealed for Simd<$ty, N>
where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
}
impl<const LANES: usize> SimdUint for Simd<$ty, LANES>
impl<const N: usize> SimdUint for Simd<$ty, N>
where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
type Scalar = $ty;
type Cast<T: SimdElement> = Simd<T, LANES>;
type Cast<T: SimdElement> = Simd<T, N>;
#[inline]
fn cast<T: SimdCast>(self) -> Self::Cast<T> {

18
crates/core_simd/src/simd/ptr/const_ptr.rs
View File

@ -77,20 +77,20 @@ pub trait SimdConstPtr: Copy + Sealed {
fn wrapping_sub(self, count: Self::Usize) -> Self;
}
impl<T, const LANES: usize> Sealed for Simd<*const T, LANES> where
LaneCount<LANES>: SupportedLaneCount
impl<T, const N: usize> Sealed for Simd<*const T, N> where
LaneCount<N>: SupportedLaneCount
{
}
impl<T, const LANES: usize> SimdConstPtr for Simd<*const T, LANES>
impl<T, const N: usize> SimdConstPtr for Simd<*const T, N>
where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
type Usize = Simd<usize, LANES>;
type Isize = Simd<isize, LANES>;
type CastPtr<U> = Simd<*const U, LANES>;
type MutPtr = Simd<*mut T, LANES>;
type Mask = Mask<isize, LANES>;
type Usize = Simd<usize, N>;
type Isize = Simd<isize, N>;
type CastPtr<U> = Simd<*const U, N>;
type MutPtr = Simd<*mut T, N>;
type Mask = Mask<isize, N>;
#[inline]
fn is_null(self) -> Self::Mask {

16
crates/core_simd/src/simd/ptr/mut_ptr.rs
View File

@ -74,18 +74,18 @@ pub trait SimdMutPtr: Copy + Sealed {
fn wrapping_sub(self, count: Self::Usize) -> Self;
}
impl<T, const LANES: usize> Sealed for Simd<*mut T, LANES> where LaneCount<LANES>: SupportedLaneCount
impl<T, const N: usize> Sealed for Simd<*mut T, N> where LaneCount<N>: SupportedLaneCount
{}
impl<T, const LANES: usize> SimdMutPtr for Simd<*mut T, LANES>
impl<T, const N: usize> SimdMutPtr for Simd<*mut T, N>
where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
type Usize = Simd<usize, LANES>;
type Isize = Simd<isize, LANES>;
type CastPtr<U> = Simd<*mut U, LANES>;
type ConstPtr = Simd<*const T, LANES>;
type Mask = Mask<isize, LANES>;
type Usize = Simd<usize, N>;
type Isize = Simd<isize, N>;
type CastPtr<U> = Simd<*mut U, N>;
type ConstPtr = Simd<*const T, N>;
type Mask = Mask<isize, N>;
#[inline]
fn is_null(self) -> Self::Mask {

4
crates/core_simd/src/swizzle.rs
View File

@ -179,10 +179,10 @@ pub trait Swizzle<const N: usize> {
}
}
impl<T, const LANES: usize> Simd<T, LANES>
impl<T, const N: usize> Simd<T, N>
where
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
LaneCount<N>: SupportedLaneCount,
{
/// Reverse the order of the elements in the vector.
#[inline]