Struct PackedMemory

pub struct PackedMemory<P>(/* private fields */);

A packed memory implementation that uses slices of packed fields.

Trait Implementations

impl<P: PackedField> ComputeMemory<<P as PackedField>::Scalar> for PackedMemory<P>

const ALIGNMENT: usize = P::WIDTH

The required alignment of indices for the split methods. This must be a power of two.

type FSlice<'a> = PackedMemorySlice<'a, P>

An opaque handle to an immutable slice of elements stored in a compute memory.

type FSliceMut<'a> = PackedMemorySliceMut<'a, P>

An opaque handle to a mutable slice of elements stored in a compute memory.

fn as_const<'a>(data: &'a Self::FSliceMut<'_>) -> Self::FSlice<'a>

Borrows a mutable memory slice as immutable.

fn slice( data: Self::FSlice<'_>, range: impl RangeBounds<usize>, ) -> Self::FSlice<'_>

Borrows a subslice of an immutable memory slice.

fn slice_mut<'a>( data: &'a mut Self::FSliceMut<'_>, range: impl RangeBounds<usize>, ) -> Self::FSliceMut<'a>

Borrows a subslice of a mutable memory slice.

fn split_at_mut( data: Self::FSliceMut<'_>, mid: usize, ) -> (Self::FSliceMut<'_>, Self::FSliceMut<'_>)

Splits a mutable slice into two disjoint subslices.

fn narrow<'a>(data: &'a Self::FSlice<'_>) -> Self::FSlice<'a>

Borrows an immutable memory slice, narrowing the lifetime.

fn narrow_mut<'a, 'b: 'a>(data: Self::FSliceMut<'b>) -> Self::FSliceMut<'a>

Borrows a mutable memory slice, narrowing the lifetime.

fn to_owned_mut<'a>(data: &'a mut Self::FSliceMut<'_>) -> Self::FSliceMut<'a>

fn slice_chunks_mut<'a>( data: Self::FSliceMut<'a>, chunk_len: usize, ) -> impl Iterator<Item = Self::FSliceMut<'a>>

Splits a mutable slice into equal chunks.

fn split_half<'a>( data: Self::FSlice<'a>, ) -> (Self::FSlice<'a>, Self::FSlice<'a>)

Splits an immutable slice of power-two length into two equal halves.

fn split_half_mut<'a>( data: Self::FSliceMut<'a>, ) -> (Self::FSliceMut<'a>, Self::FSliceMut<'a>)

Splits a mutable slice of power-two length into two equal halves.

fn split_at( data: Self::FSlice<'_>, mid: usize, ) -> (Self::FSlice<'_>, Self::FSlice<'_>)

Splits an immutable slice into two disjoint subslices.

fn split_at_mut_borrowed<'a>( data: &'a mut Self::FSliceMut<'_>, mid: usize, ) -> (Self::FSliceMut<'a>, Self::FSliceMut<'a>)

fn slice_chunks<'a>( data: Self::FSlice<'a>, chunk_len: usize, ) -> impl Iterator<Item = Self::FSlice<'a>>

Splits slice into equal chunks.