cuest-cudarc 0.1.0

Safe Rust wrapper for cuEST built on cudarc
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

//! Internal wrapper around the type-erased `cuestParameters_t` objects.
//!
//! Every cuEST creation and compute call takes a parameters handle created
//! with `cuestParametersCreate` and destroyed with `cuestParametersDestroy`
//! (right after use, per the cuEST lifetime rules).

use crate::error::{status_check, CuestError};
use cuest_ffi::ffi;
use std::ffi::{c_char, c_int, c_void, CStr};
use std::ptr;

/// Owns a cuEST parameters handle of one specific parameter type.
///
/// The C API declares parameters as `void*`.
pub(crate) struct CuestParameters {
    raw: *mut c_void,
    type_: ffi::cuestParametersType_t,
}

impl CuestParameters {
    /// Create a parameters object with cuEST defaults.
    pub(crate) fn create(type_: ffi::cuestParametersType_t) -> Result<Self, CuestError> {
        let mut raw: *mut c_void = ptr::null_mut();
        status_check(
            unsafe { ffi::cuestParametersCreate(type_, &mut raw) },
            "cuestParametersCreate",
        )?;
        Ok(Self { raw, type_ })
    }

    /// The raw handle for FFI calls.
    pub(crate) fn raw(&self) -> *mut c_void {
        self.raw
    }

    fn configure_raw(
        &self,
        attribute: c_int,
        value: *const c_void,
        size: usize,
    ) -> Result<(), CuestError> {
        status_check(
            unsafe { ffi::cuestParametersConfigure(self.type_, self.raw, attribute, value, size) },
            "cuestParametersConfigure",
        )
    }

    pub(crate) fn configure_u64(&self, attribute: c_int, value: u64) -> Result<(), CuestError> {
        let bytes = value.to_ne_bytes();
        self.configure_raw(attribute, bytes.as_ptr() as *const c_void, bytes.len())
    }

    pub(crate) fn configure_i32(&self, attribute: c_int, value: i32) -> Result<(), CuestError> {
        let bytes = value.to_ne_bytes();
        self.configure_raw(attribute, bytes.as_ptr() as *const c_void, bytes.len())
    }

    /// Configure a `const char*` attribute: the value is the address of the
    /// string pointer (`&str, sizeof(char *)`), as in the cuEST C examples —
    /// not the string bytes themselves.
    pub(crate) fn configure_cstr(&self, attribute: c_int, value: &CStr) -> Result<(), CuestError> {
        let ptr: *const c_char = value.as_ptr();
        self.configure_raw(
            attribute,
            ptr::addr_of!(ptr) as *const c_void,
            size_of::<*const c_char>(),
        )
    }

    /// Configure a `cudaStream_t` attribute (a plain pointer value).
    pub(crate) fn configure_ptr(
        &self,
        attribute: c_int,
        value: *mut c_void,
    ) -> Result<(), CuestError> {
        self.configure_raw(
            attribute,
            ptr::addr_of!(value) as *const c_void,
            size_of::<*mut c_void>(),
        )
    }
}

impl Drop for CuestParameters {
    fn drop(&mut self) {
        // Drop cannot report failure; a leak here only wastes a small handle.
        let _ = unsafe { ffi::cuestParametersDestroy(self.type_, self.raw) };
    }
}