Struct CudaSlice 

pub struct CudaSlice<T> { /* private fields */ }

Vec<T> on a cuda device. You can allocate and modify this with CudaStream.

This object is thread safe.

Implementations

impl<T> CudaSlice<T>

pub fn len(&self) -> usize

The number of elements of T in this object.

pub fn num_bytes(&self) -> usize

The number of bytes in this object.

pub fn is_empty(&self) -> bool

True if there are no elements in the object.

pub fn ordinal(&self) -> usize

The device ordinal this belongs to

pub fn context(&self) -> &Arc<CudaContext>

The context this belongs to

pub fn stream(&self) -> &Arc<CudaStream>

The stream this object was allocated on and later will be dropped on.

impl<T> CudaSlice<T>

where T: DeviceRepr,

pub fn try_clone(&self) -> Result<CudaSlice<T>, DriverError>

Allocates copy of self and schedules a device to device copy of memory.

impl<T> CudaSlice<T>

pub fn as_view(&self) -> CudaView<'_, T>

impl<T> CudaSlice<T>

pub fn as_view_mut(&mut self) -> CudaViewMut<'_, T>

impl<T> CudaSlice<T>

pub fn slice(&self, bounds: impl RangeBounds<usize>) -> CudaView<'_, T>

Creates a CudaView at the specified offset from the start of self.

Panics if range.start >= self.len.

Example

let mut slice = stream.alloc_zeros::<u8>(100).unwrap();
let mut view = slice.slice(0..50);
do_something(&view);

Like a normal slice, borrow checking prevents the underlying CudaSlice from being dropped.

let view = {
    let mut slice = stream.alloc_zeros::<u8>(100).unwrap();
    // cannot return view, since it borrows from slice
    slice.slice(0..50)
};
do_something(&view);

pub fn try_slice( &self, bounds: impl RangeBounds<usize>, ) -> Option<CudaView<'_, T>>

Fallible version of CudaSlice::slice().

pub fn slice_mut( &mut self, bounds: impl RangeBounds<usize>, ) -> CudaViewMut<'_, T>

Creates a CudaViewMut at the specified offset from the start of self.

Panics if range and 0...self.len() are not overlapping.

Example

let mut slice = stream.alloc_zeros::<u8>(100).unwrap();
let mut view = slice.slice_mut(0..50);
do_something(&mut view);

Like a normal mutable slice, borrow checking prevents the underlying CudaSlice from being dropped.

let mut view = {
    let mut slice = stream.alloc_zeros::<u8>(100).unwrap();
    // cannot return view, since it borrows from slice
    slice.slice_mut(0..50)
};
do_something(&mut view);

Like with normal mutable slices, one cannot mutably slice twice into the same CudaSlice:

let mut slice = stream.alloc_zeros::<u8>(100).unwrap();
let mut view1 = slice.slice_mut(0..50);
// cannot borrow twice from slice
let mut view2 = slice.slice_mut(50..100);
do_something(view1, view2);

If you need non-overlapping mutable views into a CudaSlice, you can use CudaSlice::split_at_mut().

pub fn try_slice_mut( &mut self, bounds: impl RangeBounds<usize>, ) -> Option<CudaViewMut<'_, T>>

Fallible version of CudaSlice::slice_mut

pub unsafe fn transmute<S>(&self, len: usize) -> Option<CudaView<'_, S>>

Reinterprets the slice of memory into a different type. len is the number of elements of the new type S that are expected. If not enough bytes are allocated in self for the view, then this returns None.

Safety

This is unsafe because not the memory for the view may not be a valid interpretation for the type S.

pub unsafe fn transmute_mut<S>( &mut self, len: usize, ) -> Option<CudaViewMut<'_, S>>

Reinterprets the slice of memory into a different type. len is the number of elements of the new type S that are expected. If not enough bytes are allocated in self for the view, then this returns None.

Safety

This is unsafe because not the memory for the view may not be a valid interpretation for the type S.

pub fn split_at(&self, mid: usize) -> (CudaView<'_, T>, CudaView<'_, T>)

pub fn try_split_at( &self, mid: usize, ) -> Option<(CudaView<'_, T>, CudaView<'_, T>)>

Fallible version of CudaSlice::split_at. Returns None if mid > self.len.

pub fn split_at_mut( &mut self, mid: usize, ) -> (CudaViewMut<'_, T>, CudaViewMut<'_, T>)

Splits the CudaSlice into two at the given index, returning two CudaViewMut for the two halves.

Panics if mid > self.len.

This method can be used to create non-overlapping mutable views into a CudaSlice.

let mut slice = stream.alloc_zeros::<u8>(100).unwrap();
// split the slice into two non-overlapping, mutable views
let (mut view1, mut view2) = slice.split_at_mut(50);
do_something(view1, view2);

pub fn try_split_at_mut( &mut self, mid: usize, ) -> Option<(CudaViewMut<'_, T>, CudaViewMut<'_, T>)>

Fallible version of CudaSlice::split_at_mut.

Returns None if mid > self.len.

impl<T> CudaSlice<T>

pub fn leak(self) -> u64

Takes ownership of the underlying sys::CUdeviceptr. It is up to the owner to free this value.

Drops the underlying host_buf if there is one.

Trait Implementations

impl<T> Clone for CudaSlice<T>

where T: DeviceRepr,

fn clone(&self) -> CudaSlice<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for CudaSlice<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> DevicePtr<T> for CudaSlice<T>

fn device_ptr<'a>(&'a self, stream: &'a CudaStream) -> (u64, SyncOnDrop<'a>)

Retrieve the device pointer with the intent to read the device memory associated with it.

impl<T> DevicePtrMut<T> for CudaSlice<T>

fn device_ptr_mut<'a>( &'a mut self, stream: &'a CudaStream, ) -> (u64, SyncOnDrop<'a>)

Retrieve the device pointer with the intent to modify the device memory associated with it.

impl<T> DeviceSlice<T> for CudaSlice<T>

fn len(&self) -> usize

fn stream(&self) -> &Arc<CudaStream>

fn num_bytes(&self) -> usize

fn is_empty(&self) -> bool

impl<T> Drop for CudaSlice<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, T> IntoKernelParamStorage for &'a CudaSlice<T>

type Storage = DeviceParamStorage<'a>

fn into_kernel_param_storage(self) -> Self::Storage

impl<T> IntoKernelParamStorage for &mut CudaSlice<T>

type Storage = DeviceParamStorage<'static>

fn into_kernel_param_storage(self) -> Self::Storage

impl<T> TryFrom<CudaSlice<T>> for Vec<T>

where T: Clone + Default + DeviceRepr,

type Error = DriverError

The type returned in the event of a conversion error.

fn try_from( value: CudaSlice<T>, ) -> Result<Vec<T>, <Vec<T> as TryFrom<CudaSlice<T>>>::Error>

Performs the conversion.

impl<T> Send for CudaSlice<T>

impl<T> Sync for CudaSlice<T>