[−][src]Trait rustacuda_core::DeviceCopy
Marker trait for types which can safely be copied to or from a CUDA device.
A type can be safely copied if its value can be duplicated simply by copying bits and if it does not contain a reference to memory which is not accessible to the device. Additionally, the DeviceCopy trait does not imply copy semantics as the Copy trait does.
How can I implement DeviceCopy?
There are two ways to implement DeviceCopy on your type. The simplest is to use derive:
#[macro_use] extern crate rustacuda; #[derive(Clone, DeviceCopy)] struct MyStruct(u64);
This is safe because the DeviceCopy derive macro will check that all fields of the struct,
enum or union implement DeviceCopy. For example, this fails to compile, because Vec cannot
be copied to the device:
#[derive(Clone, DeviceCopy)] struct MyStruct(Vec<u64>);
You can also implement DeviceCopy unsafely:
use rustacuda::memory::DeviceCopy; #[derive(Clone)] struct MyStruct(u64); unsafe impl DeviceCopy for MyStruct { }
What is the difference between DeviceCopy and Copy?
DeviceCopy is stricter than Copy. DeviceCopy must only be implemented for types which
do not contain references or raw pointers to non-device-accessible memory. DeviceCopy also
does not imply copy semantics - that is, DeviceCopy values are not implicitly copied on
assignment the way that Copy values are. This is helpful, as it may be desirable to implement
DeviceCopy for large structures that would be inefficient to copy for every assignment.
When can't my type be DeviceCopy?
Some types cannot be safely copied to the device. For example, copying &T would create an
invalid reference on the device which would segfault if dereferenced. Generalizing this, any
type implementing Drop cannot be DeviceCopy since it is responsible for some resource that
would not be available on the device.