Struct CpuMemory

pub struct CpuMemory;

Trait Implementations

impl<F: 'static + Sync + Send + Debug> ComputeMemory<F> for CpuMemory

const ALIGNMENT: usize = 1usize

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

type FSlice<'a> = &'a [F]

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

type FSliceMut<'a> = &'a mut [F]

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

fn narrow<'a>(data: &'a &[F]) -> &'a [F]

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 as_const<'a>(data: &'a &mut [F]) -> &'a [F]

Borrows a mutable memory slice as immutable.

fn to_const(data: Self::FSliceMut<'_>) -> Self::FSlice<'_>

Converts a mutable memory slice to an immutable slice.

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 &mut [F], range: impl RangeBounds<usize>, ) -> &'a mut [F]

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 to_owned_mut<'a>(data: &'a mut &mut [F]) -> &'a mut [F]

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_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.

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 slice_power_of_two_mut<'a>( input: &'a mut Self::FSliceMut<'_>, n: usize, ) -> Self::FSliceMut<'a>

Slices off the first n elements, mutably, where n is a power of two.

impl Debug for CpuMemory

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.