Struct rustacuda::memory::UnifiedPointer[][src]

#[repr(transparent)]
pub struct UnifiedPointer<T>(_)
where
    T: ?Sized
;
Expand description

A pointer to unified memory.

UnifiedPointer can be safely dereferenced by the CPU, as the memory allocation it points to is shared between the CPU and the GPU. It can also be safely copied to the device (eg. as part of a kernel launch).

UnifiedPointer is guaranteed to have an equivalent internal representation to a raw pointer. Thus, it can be safely reinterpreted or transmuted to *mut T. It is also safe to pass a UnifiedPointer through an FFI boundary to C code expecting a *mut T. It is thus possible to pass a UnifiedPointer to a CUDA kernel written in C.

Implementations

Wrap the given raw pointer in a UnifiedPointer. The given pointer is assumed to be a valid, unified-memory pointer or null.

Safety

The given pointer must have been allocated with cuda_malloc_unified or be null.

Examples

use rustacuda::memory::*;
use std::ptr;
unsafe {
    let null : *mut u64 = ptr::null_mut();
    assert!(UnifiedPointer::wrap(null).is_null());
}

Returns the contained pointer as a raw pointer.

Examples

use rustacuda::memory::*;
unsafe {
    let unified_ptr = cuda_malloc_unified::<u64>(1).unwrap();
    let ptr: *const u64 = unified_ptr.as_raw();
    cuda_free_unified(unified_ptr);
}

Returns the contained pointer as a mutable raw pointer.

Examples

use rustacuda::memory::*;
unsafe {
    let mut unified_ptr = cuda_malloc_unified::<u64>(1).unwrap();
    let ptr: *mut u64 = unified_ptr.as_raw_mut();
    *ptr = 5u64;
    cuda_free_unified(unified_ptr);
}

Returns true if the pointer is null.

Examples

use rustacuda::memory::*;
use std::ptr;
unsafe {
    let null : *mut u64 = ptr::null_mut();
    assert!(UnifiedPointer::wrap(null).is_null());
}

Returns a null unified pointer.

Examples:

use rustacuda::memory::*;
let ptr : UnifiedPointer<u64> = UnifiedPointer::null();
assert!(ptr.is_null());

Calculates the offset from a unified pointer.

count is in units of T; eg. a count of 3 represents a pointer offset of 3 * size_of::<T>() bytes.

Safety

If any of the following conditions are violated, the result is Undefined Behavior:

  • Both the starting and resulting pointer must be either in bounds or one byte past the end of the same allocated object.

  • The computed offset, in bytes, cannot overflow an isize.

  • The offset being in bounds cannot rely on “wrapping around” the address space. That is, the infinite-precision sum, in bytes must fit in a usize.

Consider using wrapping_offset instead if these constraints are difficult to satisfy. The only advantage of this method is that it enables more aggressive compiler optimizations.

Examples

use rustacuda::memory::*;
unsafe {
    let mut unified_ptr = cuda_malloc_unified::<u64>(5).unwrap();
    let offset = unified_ptr.offset(1); // Points to the 2nd u64 in the buffer
    cuda_free_unified(unified_ptr); // Must free the buffer using the original pointer
}

Calculates the offset from a unified pointer using wrapping arithmetic.

count is in units of T; eg. a count of 3 represents a pointer offset of 3 * size_of::<T>() bytes.

Safety

The resulting pointer does not need to be in bounds, but it is potentially hazardous to dereference (which requires unsafe). In particular, the resulting pointer may not be used to access a different allocated object than the one self points to. In other words, x.wrapping_offset(y.wrapping_offset_from(x)) is not the same as y, and dereferencing it is undefined behavior unless x and y point into the same allocated object.

Always use .offset(count) instead when possible, because offset allows the compiler to optimize better. If you need to cross object boundaries, cast the pointer to an integer and do the arithmetic there.

Examples

use rustacuda::memory::*;
unsafe {
    let mut unified_ptr = cuda_malloc_unified::<u64>(5).unwrap();
    let offset = unified_ptr.wrapping_offset(1); // Points to the 2nd u64 in the buffer
    cuda_free_unified(unified_ptr); // Must free the buffer using the original pointer
}

Calculates the offset from a pointer (convenience for .offset(count as isize)).

count is in units of T; e.g. a count of 3 represents a pointer offset of 3 * size_of::<T>() bytes.

Safety

If any of the following conditions are violated, the result is Undefined Behavior:

  • Both the starting and resulting pointer must be either in bounds or one byte past the end of an allocated object.

  • The computed offset, in bytes, cannot overflow an isize.

  • The offset being in bounds cannot rely on “wrapping around” the address space. That is, the infinite-precision sum must fit in a usize.

Consider using wrapping_offset instead if these constraints are difficult to satisfy. The only advantage of this method is that it enables more aggressive compiler optimizations.

Examples

use rustacuda::memory::*;
unsafe {
    let mut unified_ptr = cuda_malloc_unified::<u64>(5).unwrap();
    let offset = unified_ptr.add(1); // Points to the 2nd u64 in the buffer
    cuda_free_unified(unified_ptr); // Must free the buffer using the original pointer
}

Calculates the offset from a pointer (convenience for .offset((count as isize).wrapping_neg())).

count is in units of T; e.g. a count of 3 represents a pointer offset of 3 * size_of::<T>() bytes.

Safety

If any of the following conditions are violated, the result is Undefined Behavior:

  • Both the starting and resulting pointer must be either in bounds or one byte past the end of an allocated object.

  • The computed offset, in bytes, cannot overflow an isize.

  • The offset being in bounds cannot rely on “wrapping around” the address space. That is, the infinite-precision sum must fit in a usize.

Consider using wrapping_offset instead if these constraints are difficult to satisfy. The only advantage of this method is that it enables more aggressive compiler optimizations.

Examples

use rustacuda::memory::*;
unsafe {
    let mut unified_ptr = cuda_malloc_unified::<u64>(5).unwrap();
    let offset = unified_ptr.add(4).sub(3); // Points to the 2nd u64 in the buffer
    cuda_free_unified(unified_ptr); // Must free the buffer using the original pointer
}

Calculates the offset from a pointer using wrapping arithmetic. (convenience for .wrapping_offset(count as isize))

count is in units of T; e.g. a count of 3 represents a pointer offset of 3 * size_of::<T>() bytes.

Safety

The resulting pointer does not need to be in bounds, but it is potentially hazardous to dereference.

Always use .add(count) instead when possible, because add allows the compiler to optimize better.

Examples

use rustacuda::memory::*;
unsafe {
    let mut unified_ptr = cuda_malloc_unified::<u64>(5).unwrap();
    let offset = unified_ptr.wrapping_add(1); // Points to the 2nd u64 in the buffer
    cuda_free_unified(unified_ptr); // Must free the buffer using the original pointer
}

Calculates the offset from a pointer using wrapping arithmetic. (convenience for .wrapping_offset((count as isize).wrapping_sub()))

count is in units of T; e.g. a count of 3 represents a pointer offset of 3 * size_of::<T>() bytes.

Safety

The resulting pointer does not need to be in bounds, but it is potentially hazardous to dereference (which requires unsafe).

Always use .sub(count) instead when possible, because sub allows the compiler to optimize better.

Examples

use rustacuda::memory::*;
unsafe {
    let mut unified_ptr = cuda_malloc_unified::<u64>(5).unwrap();
    let offset = unified_ptr.wrapping_add(4).wrapping_sub(3); // Points to the 2nd u64 in the buffer
    cuda_free_unified(unified_ptr); // Must free the buffer using the original pointer
}

Trait Implementations

Returns a copy of the value. Read more

Performs copy-assignment from source. Read more

Formats the value using the given formatter. Read more

Feeds this value into the given Hasher. Read more

Feeds a slice of this type into the given Hasher. Read more

This method returns an Ordering between self and other. Read more

Compares and returns the maximum of two values. Read more

Compares and returns the minimum of two values. Read more

Restrict a value to a certain interval. Read more

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method returns an ordering between self and other values if one exists. Read more

This method tests less than (for self and other) and is used by the < operator. Read more

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

This method tests greater than (for self and other) and is used by the > operator. Read more

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

Formats the value using the given formatter.

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Performs the conversion.

Performs the conversion.

The resulting type after obtaining ownership.

Creates owned data from borrowed data, usually by cloning. Read more

🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.