Trait slipstream::iterators::Vectorizable

pub trait Vectorizable<V>: Sized {
    type Padding;
    type Vectorizer: Vectorizer<V>;
    fn create(
        self, 
        pad: Option<Self::Padding>
    ) -> (Self::Vectorizer, usize, Option<V>);

    fn vectorize(self) -> VectorizedIter<Self::Vectorizer, (), V> { ... }
    fn vectorize_pad(
        self, 
        pad: Self::Padding
    ) -> VectorizedIter<Self::Vectorizer, Option<V>, V> { ... }
}

A trait describing things with direct support for splitting into vectors.

This supports vectorized iteration over shared and mutable slices as well as types composed of them (tuples and short fixed-sized arrays).

Note that, unlike normal iterators, shared slices return owned values (vectors) and mutable slices return proxy objects that allow writing the data back. It is not possible to directly borrow from the slice because of alignment. The tuples and arrays return tuples and arrays of the inner values.

Already pre-vectorized inputs are also supported (this is useful in combination with other not vectorized inputs).

Type hints

Oftentimes, the compiler can infer the type of the base type, but not the length of the vector. It is therefore needed to provide a type hint.

Furthermore, for tuples and arrays, the inner type really needs to be the slice, not something that can coerce into it (eg. vec or array).

Examples

let data = [1, 2, 3, 4];
let v = data.vectorize().collect::<Vec<u32x2>>();
assert_eq!(vec![u32x2::new([1, 2]), u32x2::new([3, 4])], v);

let data = [1, 2, 3, 4];
for v in data.vectorize() {
    let v: u32x2 = v; // Type hint
    println!("{:?}", v);
}

let input = [1, 2, 3, 4];
let mut output = [0; 4];
let mul = u32x2::splat(2);
// We have to force the coercion to slice by [..]
for (i, mut o) in (&input[..], &mut output[..]).vectorize() {
    *o = mul * i;
}
assert_eq!(output, [2, 4, 6, 8]);

let vectorized = [u32x2::new([1, 2]), u32x2::new([3, 4])];
let not_vectorized = [1, 2, 3, 4];
for (v, n) in (&vectorized[..], &not_vectorized[..]).vectorize() {
    assert_eq!(v, n);
}

Associated Types

type Padding

The input type provided by user to fill in the padding/uneven end.

Note that this doesn't necessarily have to be the same type as the type returned by the resulting iterator. For example, in case of mutable slices, the input is the vector, while the output is MutProxy.

type Vectorizer: Vectorizer<V>

An internal type managing the splitting into vectors.

Not of direct interest of the users of this crate.

Loading content...

Required methods

fn create(
    self,
    pad: Option<Self::Padding>
) -> (Self::Vectorizer, usize, Option<V>)

Internal method to create the vectorizer and kick of the iteration.

Loading content...

Provided methods

fn vectorize(self) -> VectorizedIter<Self::Vectorizer, (), V>

Vectorize a slice or composite of slices

This variant assumes the input is divisible by the size of the vector. Prefer this if possible over vectorize_pad, as it is usually significantly faster.

Panics

• If the slice length isn't divisible by the vector size.
• If the parts of the composite produce different number of vectors. It is not mandated for the slices to be of equal length, only to produce the same number of vectors.

Examples

let longer = [1, 2, 3, 4, 5, 6, 7, 8];
let shorter = [1, 2, 3, 4];
for i in (&shorter[..], &longer[..]).vectorize() {
    let (s, l): (u32x2, u32x4) = i;
    println!("s: {:?}, l: {:?})", s, l);
}

fn vectorize_pad(
    self,
    pad: Self::Padding
) -> VectorizedIter<Self::Vectorizer, Option<V>, V>

Vectorizes a slice or composite of slices, padding the odd end if needed.

While the vectorize assumes the input can be split into vectors without leftover, this version deals with the uneven rest by producing a padding vector (if needed). The unused lanes are taken from the pad parameter. This is at the cost of some performance (TODO: figure out why it is so much slower).

For mutable slices, padding is used as usual, but the added lanes are not stored anywhere.

The padding is produced at the end.

In case of composites, this still assumes they produce the same number of full vectors and that they all either do or don't need a padding.

Panics

If the above assumption about number of vectors and same padding behaviour is violated.

let data = [1, 2, 3, 4, 5, 6];
let v = data.vectorize_pad(i32x4::splat(-1)).collect::<Vec<_>>();
assert_eq!(v, vec![i32x4::new([1, 2, 3, 4]), i32x4::new([5, 6, -1, -1])]);

Loading content...

Implementors

impl<'a, B, S> Vectorizable<&'a mut Packed1<B, S>> for &'a mut [Packed1<B, S>] where
    B: Repr,
    S: ArrayLength<B>,
    S::ArrayType: Copy, 

type Padding = ()

type Vectorizer = &'a mut [Packed1<B, S>]

fn create(
    self,
    _pad: Option<()>
) -> (Self::Vectorizer, usize, Option<&'a mut Packed1<B, S>>)

impl<'a, B, S> Vectorizable<&'a mut Packed16<B, S>> for &'a mut [Packed16<B, S>] where
    B: Repr,
    S: ArrayLength<B>,
    S::ArrayType: Copy, 

type Padding = ()

type Vectorizer = &'a mut [Packed16<B, S>]

fn create(
    self,
    _pad: Option<()>
) -> (Self::Vectorizer, usize, Option<&'a mut Packed16<B, S>>)

impl<'a, B, S> Vectorizable<&'a mut Packed2<B, S>> for &'a mut [Packed2<B, S>] where
    B: Repr,
    S: ArrayLength<B>,
    S::ArrayType: Copy, 

type Padding = ()

type Vectorizer = &'a mut [Packed2<B, S>]

fn create(
    self,
    _pad: Option<()>
) -> (Self::Vectorizer, usize, Option<&'a mut Packed2<B, S>>)

impl<'a, B, S> Vectorizable<&'a mut Packed32<B, S>> for &'a mut [Packed32<B, S>] where
    B: Repr,
    S: ArrayLength<B>,
    S::ArrayType: Copy, 

type Padding = ()

type Vectorizer = &'a mut [Packed32<B, S>]

fn create(
    self,
    _pad: Option<()>
) -> (Self::Vectorizer, usize, Option<&'a mut Packed32<B, S>>)

impl<'a, B, S> Vectorizable<&'a mut Packed4<B, S>> for &'a mut [Packed4<B, S>] where
    B: Repr,
    S: ArrayLength<B>,
    S::ArrayType: Copy, 

type Padding = ()

type Vectorizer = &'a mut [Packed4<B, S>]

fn create(
    self,
    _pad: Option<()>
) -> (Self::Vectorizer, usize, Option<&'a mut Packed4<B, S>>)

impl<'a, B, S> Vectorizable<&'a mut Packed8<B, S>> for &'a mut [Packed8<B, S>] where
    B: Repr,
    S: ArrayLength<B>,
    S::ArrayType: Copy, 

type Padding = ()

type Vectorizer = &'a mut [Packed8<B, S>]

fn create(
    self,
    _pad: Option<()>
) -> (Self::Vectorizer, usize, Option<&'a mut Packed8<B, S>>)

impl<'a, B, S> Vectorizable<Packed1<B, S>> for &'a [Packed1<B, S>] where
    B: Repr,
    S: ArrayLength<B>,
    S::ArrayType: Copy, 

type Padding = ()

type Vectorizer = &'a [Packed1<B, S>]

fn create(
    self,
    _pad: Option<()>
) -> (Self::Vectorizer, usize, Option<Packed1<B, S>>)

impl<'a, B, S> Vectorizable<Packed16<B, S>> for &'a [Packed16<B, S>] where
    B: Repr,
    S: ArrayLength<B>,
    S::ArrayType: Copy, 

type Padding = ()

type Vectorizer = &'a [Packed16<B, S>]

fn create(
    self,
    _pad: Option<()>
) -> (Self::Vectorizer, usize, Option<Packed16<B, S>>)

impl<'a, B, S> Vectorizable<Packed2<B, S>> for &'a [Packed2<B, S>] where
    B: Repr,
    S: ArrayLength<B>,
    S::ArrayType: Copy, 

type Padding = ()

type Vectorizer = &'a [Packed2<B, S>]

fn create(
    self,
    _pad: Option<()>
) -> (Self::Vectorizer, usize, Option<Packed2<B, S>>)

impl<'a, B, S> Vectorizable<Packed32<B, S>> for &'a [Packed32<B, S>] where
    B: Repr,
    S: ArrayLength<B>,
    S::ArrayType: Copy, 

type Padding = ()

type Vectorizer = &'a [Packed32<B, S>]

fn create(
    self,
    _pad: Option<()>
) -> (Self::Vectorizer, usize, Option<Packed32<B, S>>)

impl<'a, B, S> Vectorizable<Packed4<B, S>> for &'a [Packed4<B, S>] where
    B: Repr,
    S: ArrayLength<B>,
    S::ArrayType: Copy, 

type Padding = ()

type Vectorizer = &'a [Packed4<B, S>]

fn create(
    self,
    _pad: Option<()>
) -> (Self::Vectorizer, usize, Option<Packed4<B, S>>)

impl<'a, B, S> Vectorizable<Packed8<B, S>> for &'a [Packed8<B, S>] where
    B: Repr,
    S: ArrayLength<B>,
    S::ArrayType: Copy, 

type Padding = ()

type Vectorizer = &'a [Packed8<B, S>]

fn create(
    self,
    _pad: Option<()>
) -> (Self::Vectorizer, usize, Option<Packed8<B, S>>)

impl<'a, B, V> Vectorizable<MutProxy<'a, B, V>> for &'a mut [B] where
    B: Repr,
    V: Vector<Base = B> + Deref<Target = [B]> + DerefMut,
    V::Lanes: ArrayLength<B>,
    V::Mask: AsRef<[B::Mask]>, 

type Vectorizer = WriteVectorizer<'a, B, V>

type Padding = V

fn create(
    self,
    pad: Option<V>
) -> (Self::Vectorizer, usize, Option<MutProxy<'a, B, V>>)

impl<'a, B, V> Vectorizable<V> for &'a [B] where
    B: Repr,
    V: Vector<Base = B> + Deref<Target = [B]> + DerefMut,
    V::Lanes: ArrayLength<B>,
    V::Mask: AsRef<[B::Mask]>, 

type Vectorizer = ReadVectorizer<'a, B, V>

type Padding = V

fn create(self, pad: Option<V>) -> (Self::Vectorizer, usize, Option<V>)

impl<A, AR, B, BR> Vectorizable<(AR, BR)> for (A, B) where
    A: Vectorizable<AR>,
    B: Vectorizable<BR>, 

type Vectorizer = (A::Vectorizer, B::Vectorizer)

type Padding = (A::Padding, B::Padding)

fn create(
    self,
    pad: Option<Self::Padding>
) -> (Self::Vectorizer, usize, Option<(AR, BR)>)

impl<A, AR, B, BR, C, CR> Vectorizable<(AR, BR, CR)> for (A, B, C) where
    A: Vectorizable<AR>,
    B: Vectorizable<BR>,
    C: Vectorizable<CR>, 

type Vectorizer = (A::Vectorizer, B::Vectorizer, C::Vectorizer)

type Padding = (A::Padding, B::Padding, C::Padding)

fn create(
    self,
    pad: Option<Self::Padding>
) -> (Self::Vectorizer, usize, Option<(AR, BR, CR)>)

impl<A, AR, B, BR, C, CR, D, DR> Vectorizable<(AR, BR, CR, DR)> for (A, B, C, D) where
    A: Vectorizable<AR>,
    B: Vectorizable<BR>,
    C: Vectorizable<CR>,
    D: Vectorizable<DR>, 

type Vectorizer = (A::Vectorizer, B::Vectorizer, C::Vectorizer, D::Vectorizer)

type Padding = (A::Padding, B::Padding, C::Padding, D::Padding)

fn create(
    self,
    pad: Option<Self::Padding>
) -> (Self::Vectorizer, usize, Option<(AR, BR, CR, DR)>)

impl<A, AR, B, BR, C, CR, D, DR, E, ER> Vectorizable<(AR, BR, CR, DR, ER)> for (A, B, C, D, E) where
    A: Vectorizable<AR>,
    B: Vectorizable<BR>,
    C: Vectorizable<CR>,
    D: Vectorizable<DR>,
    E: Vectorizable<ER>, 

type Vectorizer = (A::Vectorizer, B::Vectorizer, C::Vectorizer, D::Vectorizer, E::Vectorizer)

type Padding = (A::Padding, B::Padding, C::Padding, D::Padding, E::Padding)

fn create(
    self,
    pad: Option<Self::Padding>
) -> (Self::Vectorizer, usize, Option<(AR, BR, CR, DR, ER)>)

impl<A, AR, B, BR, C, CR, D, DR, E, ER, F, FR> Vectorizable<(AR, BR, CR, DR, ER, FR)> for (A, B, C, D, E, F) where
    A: Vectorizable<AR>,
    B: Vectorizable<BR>,
    C: Vectorizable<CR>,
    D: Vectorizable<DR>,
    E: Vectorizable<ER>,
    F: Vectorizable<FR>, 

type Vectorizer = (A::Vectorizer, B::Vectorizer, C::Vectorizer, D::Vectorizer, E::Vectorizer, F::Vectorizer)

type Padding = (A::Padding, B::Padding, C::Padding, D::Padding, E::Padding, F::Padding)

fn create(
    self,
    pad: Option<Self::Padding>
) -> (Self::Vectorizer, usize, Option<(AR, BR, CR, DR, ER, FR)>)

impl<A, AR, B, BR, C, CR, D, DR, E, ER, F, FR, G, GR> Vectorizable<(AR, BR, CR, DR, ER, FR, GR)> for (A, B, C, D, E, F, G) where
    A: Vectorizable<AR>,
    B: Vectorizable<BR>,
    C: Vectorizable<CR>,
    D: Vectorizable<DR>,
    E: Vectorizable<ER>,
    F: Vectorizable<FR>,
    G: Vectorizable<GR>, 

type Vectorizer = (A::Vectorizer, B::Vectorizer, C::Vectorizer, D::Vectorizer, E::Vectorizer, F::Vectorizer, G::Vectorizer)

type Padding = (A::Padding, B::Padding, C::Padding, D::Padding, E::Padding, F::Padding, G::Padding)

fn create(
    self,
    pad: Option<Self::Padding>
) -> (Self::Vectorizer, usize, Option<(AR, BR, CR, DR, ER, FR, GR)>)

impl<A, AR, B, BR, C, CR, D, DR, E, ER, F, FR, G, GR, H, HR> Vectorizable<(AR, BR, CR, DR, ER, FR, GR, HR)> for (A, B, C, D, E, F, G, H) where
    A: Vectorizable<AR>,
    B: Vectorizable<BR>,
    C: Vectorizable<CR>,
    D: Vectorizable<DR>,
    E: Vectorizable<ER>,
    F: Vectorizable<FR>,
    G: Vectorizable<GR>,
    H: Vectorizable<HR>, 

type Vectorizer = (A::Vectorizer, B::Vectorizer, C::Vectorizer, D::Vectorizer, E::Vectorizer, F::Vectorizer, G::Vectorizer, H::Vectorizer)

type Padding = (A::Padding, B::Padding, C::Padding, D::Padding, E::Padding, F::Padding, G::Padding, H::Padding)

fn create(
    self,
    pad: Option<Self::Padding>
) -> (Self::Vectorizer, usize, Option<(AR, BR, CR, DR, ER, FR, GR, HR)>)

impl<T, TR> Vectorizable<[TR; 10]> for [T; 10] where
    T: Vectorizable<TR> + Copy,
    T::Padding: Copy, 

type Vectorizer = [T::Vectorizer; 10]

type Padding = [T::Padding; 10]

fn create(
    self,
    pad: Option<Self::Padding>
) -> (Self::Vectorizer, usize, Option<[TR; 10]>)

impl<T, TR> Vectorizable<[TR; 11]> for [T; 11] where
    T: Vectorizable<TR> + Copy,
    T::Padding: Copy, 

type Vectorizer = [T::Vectorizer; 11]

type Padding = [T::Padding; 11]

fn create(
    self,
    pad: Option<Self::Padding>
) -> (Self::Vectorizer, usize, Option<[TR; 11]>)

impl<T, TR> Vectorizable<[TR; 12]> for [T; 12] where
    T: Vectorizable<TR> + Copy,
    T::Padding: Copy, 

type Vectorizer = [T::Vectorizer; 12]

type Padding = [T::Padding; 12]

fn create(
    self,
    pad: Option<Self::Padding>
) -> (Self::Vectorizer, usize, Option<[TR; 12]>)

impl<T, TR> Vectorizable<[TR; 13]> for [T; 13] where
    T: Vectorizable<TR> + Copy,
    T::Padding: Copy, 

type Vectorizer = [T::Vectorizer; 13]

type Padding = [T::Padding; 13]

fn create(
    self,
    pad: Option<Self::Padding>
) -> (Self::Vectorizer, usize, Option<[TR; 13]>)

impl<T, TR> Vectorizable<[TR; 14]> for [T; 14] where
    T: Vectorizable<TR> + Copy,
    T::Padding: Copy, 

type Vectorizer = [T::Vectorizer; 14]

type Padding = [T::Padding; 14]

fn create(
    self,
    pad: Option<Self::Padding>
) -> (Self::Vectorizer, usize, Option<[TR; 14]>)

impl<T, TR> Vectorizable<[TR; 15]> for [T; 15] where
    T: Vectorizable<TR> + Copy,
    T::Padding: Copy, 

type Vectorizer = [T::Vectorizer; 15]

type Padding = [T::Padding; 15]

fn create(
    self,
    pad: Option<Self::Padding>
) -> (Self::Vectorizer, usize, Option<[TR; 15]>)

impl<T, TR> Vectorizable<[TR; 16]> for [T; 16] where
    T: Vectorizable<TR> + Copy,
    T::Padding: Copy, 

type Vectorizer = [T::Vectorizer; 16]

type Padding = [T::Padding; 16]

fn create(
    self,
    pad: Option<Self::Padding>
) -> (Self::Vectorizer, usize, Option<[TR; 16]>)

impl<T, TR> Vectorizable<[TR; 1]> for [T; 1] where
    T: Vectorizable<TR> + Copy,
    T::Padding: Copy, 

type Vectorizer = [T::Vectorizer; 1]

type Padding = [T::Padding; 1]

fn create(
    self,
    pad: Option<Self::Padding>
) -> (Self::Vectorizer, usize, Option<[TR; 1]>)

impl<T, TR> Vectorizable<[TR; 2]> for [T; 2] where
    T: Vectorizable<TR> + Copy,
    T::Padding: Copy, 

type Vectorizer = [T::Vectorizer; 2]

type Padding = [T::Padding; 2]

fn create(
    self,
    pad: Option<Self::Padding>
) -> (Self::Vectorizer, usize, Option<[TR; 2]>)

impl<T, TR> Vectorizable<[TR; 3]> for [T; 3] where
    T: Vectorizable<TR> + Copy,
    T::Padding: Copy, 

type Vectorizer = [T::Vectorizer; 3]

type Padding = [T::Padding; 3]

fn create(
    self,
    pad: Option<Self::Padding>
) -> (Self::Vectorizer, usize, Option<[TR; 3]>)

impl<T, TR> Vectorizable<[TR; 4]> for [T; 4] where
    T: Vectorizable<TR> + Copy,
    T::Padding: Copy, 

type Vectorizer = [T::Vectorizer; 4]

type Padding = [T::Padding; 4]

fn create(
    self,
    pad: Option<Self::Padding>
) -> (Self::Vectorizer, usize, Option<[TR; 4]>)

impl<T, TR> Vectorizable<[TR; 5]> for [T; 5] where
    T: Vectorizable<TR> + Copy,
    T::Padding: Copy, 

type Vectorizer = [T::Vectorizer; 5]

type Padding = [T::Padding; 5]

fn create(
    self,
    pad: Option<Self::Padding>
) -> (Self::Vectorizer, usize, Option<[TR; 5]>)

impl<T, TR> Vectorizable<[TR; 6]> for [T; 6] where
    T: Vectorizable<TR> + Copy,
    T::Padding: Copy, 

type Vectorizer = [T::Vectorizer; 6]

type Padding = [T::Padding; 6]

fn create(
    self,
    pad: Option<Self::Padding>
) -> (Self::Vectorizer, usize, Option<[TR; 6]>)

impl<T, TR> Vectorizable<[TR; 7]> for [T; 7] where
    T: Vectorizable<TR> + Copy,
    T::Padding: Copy, 

type Vectorizer = [T::Vectorizer; 7]

type Padding = [T::Padding; 7]

fn create(
    self,
    pad: Option<Self::Padding>
) -> (Self::Vectorizer, usize, Option<[TR; 7]>)

impl<T, TR> Vectorizable<[TR; 8]> for [T; 8] where
    T: Vectorizable<TR> + Copy,
    T::Padding: Copy, 

type Vectorizer = [T::Vectorizer; 8]

type Padding = [T::Padding; 8]

fn create(
    self,
    pad: Option<Self::Padding>
) -> (Self::Vectorizer, usize, Option<[TR; 8]>)

impl<T, TR> Vectorizable<[TR; 9]> for [T; 9] where
    T: Vectorizable<TR> + Copy,
    T::Padding: Copy, 

type Vectorizer = [T::Vectorizer; 9]

type Padding = [T::Padding; 9]

fn create(
    self,
    pad: Option<Self::Padding>
) -> (Self::Vectorizer, usize, Option<[TR; 9]>)

Loading content...