Struct rustacuda::memory::LockedBuffer

pub struct LockedBuffer<T: DeviceCopy> { /* fields omitted */ }

Fixed-size host-side buffer in page-locked memory.

See the module-level documentation for more details on page-locked memory.

Implementations

impl<T: DeviceCopy + Clone> LockedBuffer<T>

pub fn new(value: &T, size: usize) -> CudaResult<Self>

Allocate a new page-locked buffer large enough to hold size T's and initialized with clones of value.

Errors

If the allocation fails, returns the error from CUDA. If size is large enough that size * mem::sizeof::<T>() overflows usize, then returns InvalidMemoryAllocation.

Examples

use rustacuda::memory::*;
let mut buffer = LockedBuffer::new(&0u64, 5).unwrap();
buffer[0] = 1;

pub fn from_slice(slice: &[T]) -> CudaResult<Self>

Allocate a new page-locked buffer of the same size as slice, initialized with a clone of the data in slice.

Errors

If the allocation fails, returns the error from CUDA.

Examples

use rustacuda::memory::*;
let values = [0u64; 5];
let mut buffer = LockedBuffer::from_slice(&values).unwrap();
buffer[0] = 1;

impl<T: DeviceCopy> LockedBuffer<T>

pub unsafe fn uninitialized(size: usize) -> CudaResult<Self>

Allocate a new page-locked buffer large enough to hold size T's, but without initializing the contents.

Errors

If the allocation fails, returns the error from CUDA. If size is large enough that size * mem::sizeof::<T>() overflows usize, then returns InvalidMemoryAllocation.

Safety

The caller must ensure that the contents of the buffer are initialized before reading from the buffer.

Examples

use rustacuda::memory::*;
let mut buffer = unsafe { LockedBuffer::uninitialized(5).unwrap() };
for i in buffer.iter_mut() {
    *i = 0u64;
}

pub fn as_slice(&self) -> &[T]

Extracts a slice containing the entire buffer.

Equivalent to &s[..].

Examples

use rustacuda::memory::*;
let buffer = LockedBuffer::new(&0u64, 5).unwrap();
let sum : u64 = buffer.as_slice().iter().sum();

pub fn as_mut_slice(&mut self) -> &mut [T]

Extracts a mutable slice of the entire buffer.

Equivalent to &mut s[..].

Examples

use rustacuda::memory::*;
let mut buffer = LockedBuffer::new(&0u64, 5).unwrap();
for i in buffer.as_mut_slice() {
    *i = 12u64;
}

pub unsafe fn from_raw_parts(ptr: *mut T, size: usize) -> LockedBuffer<T>

Creates a LockedBuffer<T> directly from the raw components of another locked buffer.

Safety

This is highly unsafe, due to the number of invariants that aren't checked:

• ptr needs to have been previously allocated via LockedBuffer or cuda_malloc_locked.
• ptr's T needs to have the same size and alignment as it was allocated with.
• capacity needs to be the capacity that the pointer was allocated with.

Violating these may cause problems like corrupting the CUDA driver's internal data structures.

The ownership of ptr is effectively transferred to the LockedBuffer<T> which may then deallocate, reallocate or change the contents of memory pointed to by the pointer at will. Ensure that nothing else uses the pointer after calling this function.

Examples

use std::mem;
use rustacuda::memory::*;

let mut buffer = LockedBuffer::new(&0u64, 5).unwrap();
let ptr = buffer.as_mut_ptr();
let size = buffer.len();

mem::forget(buffer);

let buffer = unsafe { LockedBuffer::from_raw_parts(ptr, size) };

pub fn drop(buf: LockedBuffer<T>) -> DropResult<LockedBuffer<T>>

Destroy a LockedBuffer, returning an error.

Deallocating page-locked memory can return errors from previous asynchronous work. This function destroys the given buffer and returns the error and the un-destroyed buffer on failure.

Example

use rustacuda::memory::*;
let x = LockedBuffer::new(&0u64, 5).unwrap();
match LockedBuffer::drop(x) {
    Ok(()) => println!("Successfully destroyed"),
    Err((e, buf)) => {
        println!("Failed to destroy buffer: {:?}", e);
        // Do something with buf
    },
}

Trait Implementations

impl<T: DeviceCopy> AsMut<[T]> for LockedBuffer<T>

fn as_mut(&mut self) -> &mut [T]

Performs the conversion.

impl<T: DeviceCopy> AsRef<[T]> for LockedBuffer<T>

fn as_ref(&self) -> &[T]

Performs the conversion.

impl<T: Debug + DeviceCopy> Debug for LockedBuffer<T>

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

Formats the value using the given formatter.

impl<T: DeviceCopy> Deref for LockedBuffer<T>

type Target = [T]

The resulting type after dereferencing.

fn deref(&self) -> &[T]

Dereferences the value.

impl<T: DeviceCopy> DerefMut for LockedBuffer<T>

fn deref_mut(&mut self) -> &mut [T]

Mutably dereferences the value.

impl<T: DeviceCopy> Drop for LockedBuffer<T>

fn drop(&mut self)

Executes the destructor for this type.