Struct rust_gpu_tools::Device
source · pub struct Device { /* private fields */ }
Expand description
A device that may have a CUDA and/or OpenCL GPU associated with it.
Implementations§
source§impl Device
impl Device
sourcepub fn compute_units(&self) -> u32
pub fn compute_units(&self) -> u32
Returns the number of compute units of the GPU.
sourcepub fn compute_capability(&self) -> Option<(u32, u32)>
pub fn compute_capability(&self) -> Option<(u32, u32)>
Returns the major and minor version of the compute capability (only available on Nvidia GPUs).
sourcepub fn unique_id(&self) -> UniqueId
pub fn unique_id(&self) -> UniqueId
Returns the best possible unique identifier, a UUID is preferred over a PCI ID.
sourcepub fn framework(&self) -> Framework
pub fn framework(&self) -> Framework
Returns the preferred framework (CUDA or OpenCL) to use.
CUDA will be be preferred over OpenCL. The returned framework will work on the device.
E.g. it won’t return Framework::Cuda
for an AMD device.
sourcepub fn cuda_device(&self) -> Option<&Device>
pub fn cuda_device(&self) -> Option<&Device>
Returns the underlying CUDA device if it is available.
sourcepub fn opencl_device(&self) -> Option<&Device>
pub fn opencl_device(&self) -> Option<&Device>
Returns the underlying OpenCL device if it is available.
sourcepub fn all() -> Vec<&'static Device>
pub fn all() -> Vec<&'static Device>
Returns all available GPUs that are supported.
Examples found in repository?
21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72
pub fn main() {
// Define some data that should be operated on.
let aa: Vec<u32> = vec![1, 2, 3, 4];
let bb: Vec<u32> = vec![5, 6, 7, 8];
// This is the core. Here we write the interaction with the GPU independent of whether it is
// CUDA or OpenCL.
let closures = program_closures!(|program, _args| -> Result<Vec<u32>, GPUError> {
// Make sure the input data has the same length.
assert_eq!(aa.len(), bb.len());
let length = aa.len();
// Copy the data to the GPU.
let aa_buffer = program.create_buffer_from_slice(&aa)?;
let bb_buffer = program.create_buffer_from_slice(&bb)?;
// The result buffer has the same length as the input buffers.
let result_buffer = unsafe { program.create_buffer::<u32>(length)? };
// Get the kernel.
let kernel = program.create_kernel("add", 1, 1)?;
// Execute the kernel.
kernel
.arg(&(length as u32))
.arg(&aa_buffer)
.arg(&bb_buffer)
.arg(&result_buffer)
.run()?;
// Get the resulting data.
let mut result = vec![0u32; length];
program.read_into_buffer(&result_buffer, &mut result)?;
Ok(result)
});
// Get the first available device.
let device = *Device::all().first().unwrap();
// First we run it on CUDA.
let cuda_program = cuda(device);
let cuda_result = cuda_program.run(closures, ()).unwrap();
assert_eq!(cuda_result, [6, 8, 10, 12]);
println!("CUDA result: {:?}", cuda_result);
// Then we run it on OpenCL.
let opencl_program = opencl(device);
let opencl_result = opencl_program.run(closures, ()).unwrap();
assert_eq!(opencl_result, [6, 8, 10, 12]);
println!("OpenCL result: {:?}", opencl_result);
}
sourcepub fn by_pci_id(pci_id: PciId) -> Option<&'static Device>
pub fn by_pci_id(pci_id: PciId) -> Option<&'static Device>
Returns the device matching the PCI ID if there is one.
sourcepub fn by_uuid(uuid: DeviceUuid) -> Option<&'static Device>
pub fn by_uuid(uuid: DeviceUuid) -> Option<&'static Device>
Returns the device matching the UUID if there is one.
sourcepub fn by_unique_id(unique_id: UniqueId) -> Option<&'static Device>
pub fn by_unique_id(unique_id: UniqueId) -> Option<&'static Device>
Returns the device matching the unique ID if there is one.