Struct cuda_oxide::mem::DeviceBox

pub struct DeviceBox<'a> { /* fields omitted */ }

An owned device-allocated buffer

Implementations

impl<'a> DeviceBox<'a>

pub fn alloc(handle: &Rc<Handle<'a>>, size: u64) -> CudaResult<Self>

Allocate an uninitialized buffer of size size on the device

pub fn new(handle: &Rc<Handle<'a>>, input: &[u8]) -> CudaResult<Self>

Allocate a new initialized buffer on the device matching the size and content of input.

pub fn new_stream<'b>(
    handle: &Rc<Handle<'a>>,
    input: &'b [u8],
    stream: &'b mut Stream<'a>
) -> CudaResult<Self>

Allocates a new uninitialized buffer on the device, then asynchronously fills it with input. input must not be dropped or mutated until stream.sync is called. Does not allocate the memory asynchronously.

pub fn new_stream_buf(
    handle: &Rc<Handle<'a>>,
    input: Vec<u8>,
    stream: &mut Stream<'a>
) -> CudaResult<Self>

Allocates a new uninitialized buffer on the device, then synchronously fills it with input. input will be dropped when the stream is synced or dropped. Does not allocate the memory asynchronously.

pub fn new_ffi<T>(handle: &Rc<Handle<'a>>, input: &[T]) -> CudaResult<Self>

Allocates a new initialized buffer on the device matching the size and content of input. Note that memory is directly copied, so [T] must be Sized should not contain any pointers, references, unsized types, or other non-FFI safe types.

pub fn new_ffi_stream<'b, T>(
    handle: &Rc<Handle<'a>>,
    input: &'b [T],
    stream: &'b mut Stream<'a>
) -> CudaResult<Self>

Allocates a new uninitialized buffer on the device, then synchronously fills it with input. Note that memory is directly copied, so [T] must be Sized should not contain any pointers, references, unsized types, or other non-FFI safe types. input must not be dropped or mutated until stream.sync is called. Does not allocate the memory asynchronously.

pub fn new_ffi_stream_buf<'b, T>(
    handle: &Rc<Handle<'a>>,
    input: Vec<T>,
    stream: &'b mut Stream<'a>
) -> CudaResult<Self>

Allocates a new uninitialized buffer on the device, then synchronously fills it with input. Note that memory is directly copied, so [T] must be Sized should not contain any pointers, references, unsized types, or other non-FFI safe types. input will be dropped when the stream is synced or dropped. Does not allocate the memory asynchronously.

pub fn leak(self)

Leaks the DeviceBox, similar to Box::leak.

pub unsafe fn from_raw(raw: DevicePtr<'a>) -> Self

Constructs a DeviceBox from a device pointer.

Methods from Deref<Target = DevicePtr<'a>>

pub fn as_raw(&self) -> u64

pub fn copy_to<'b>(&self, target: &DevicePtr<'b>) -> CudaResult<()>

Synchronously copies data from self to target. Panics if length is not equal.

pub fn copy_to_stream<'b, 'c: 'b + 'a>(
    &self,
    target: &DevicePtr<'b>,
    stream: &mut Stream<'c>
) -> CudaResult<()> where
    'a: 'b, 

Asynchronously copies data from self to target. Panics if length is not equal.

pub fn copy_from<'b>(&self, source: &DevicePtr<'b>) -> CudaResult<()>

Synchronously copies data from source to self. Panics if length is not equal.

pub fn copy_from_stream<'b: 'a, 'c: 'a + 'b>(
    &self,
    source: &DevicePtr<'b>,
    stream: &mut Stream<'c>
) -> CudaResult<()>

Asynchronously copies data from source to self. Panics if length is not equal.

pub fn subslice(&self, from: u64, to: u64) -> Self

Gets a subslice of this slice from [from:to]

pub fn len(&self) -> u64

Gets the length of this slice

pub fn is_empty(&self) -> bool

Check if the slice’s length is 0

pub fn load(&self) -> CudaResult<Vec<u8>>

Synchronously loads the data from this slice into a local buffer

pub unsafe fn load_stream(&self, stream: &mut Stream<'a>) -> CudaResult<Vec<u8>>

Asynchronously loads the data from this slice into a local buffer. The contents of the buffer are undefined until stream.sync is called. The output must not be dropped until the stream is synced.

pub fn store(&self, data: &[u8]) -> CudaResult<()>

Synchronously stores host data from data to self.

pub fn store_stream<'b>(
    &self,
    data: &'b [u8],
    stream: &'b mut Stream<'a>
) -> CudaResult<()>

Asynchronously stores host data from data to self. The data must not be dropped or mutated until stream.sync is called.

pub fn store_stream_buf(
    &self,
    data: Vec<u8>,
    stream: &mut Stream<'a>
) -> CudaResult<()>

Asynchronously stores host data from data to self. data will be dropped once the Stream is synced or dropped.

pub fn memset_d8(&self, data: u8) -> CudaResult<()>

Synchronously set the contents of self to data repeated to fill length

pub fn memset_d8_stream(
    &self,
    data: u8,
    stream: &mut Stream<'a>
) -> CudaResult<()>

Asynchronously set the contents of self to data repeated to fill length

pub fn memset_d16(&self, data: u16) -> CudaResult<()>

Synchronously set the contents of self to data repeated to fill length. Panics if Self::len is not a multiple of 2.

pub fn memset_d16_stream(
    &self,
    data: u16,
    stream: &mut Stream<'a>
) -> CudaResult<()>

Asynchronously set the contents of self to data repeated to fill length. Panics if Self::len is not a multiple of 2.

pub fn memset_d32(&self, data: u32) -> CudaResult<()>

Synchronously set the contents of self to data repeated to fill length. Panics if Self::len is not a multiple of 4.

pub fn memset_d32_stream(
    &self,
    data: u32,
    stream: &mut Stream<'a>
) -> CudaResult<()>

Asynchronously set the contents of self to data repeated to fill length. Panics if Self::len is not a multiple of 4.

pub fn handle(&self) -> &Rc<Handle<'a>>

Gets a reference to the owning handle

Trait Implementations

impl<'a> AsRef<DevicePtr<'a>> for DeviceBox<'a>

fn as_ref(&self) -> &DevicePtr<'a>

Performs the conversion.

impl<'a> Deref for DeviceBox<'a>

type Target = DevicePtr<'a>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a> DerefMut for DeviceBox<'a>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'a> Drop for DeviceBox<'a>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, 'b> KernelParameters for &'b DeviceBox<'a>

WARNING: this is unsafe!

fn params(&self, out: &mut Vec<Vec<u8>>)