era_cudart 0.1.0

CUDA bindings for ZKsync
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

// Unified Addressing
// https://docs.nvidia.com/cuda/cuda-runtime-api/group__CUDART__UNIFIED.html

use std::mem::MaybeUninit;
use std::os::raw::c_void;

use cudart_sys::*;

use crate::result::{CudaResult, CudaResultWrap};
use crate::slice::CudaSlice;

pub fn pointer_get_attributes<T>(
    slice: &(impl CudaSlice<T> + ?Sized),
) -> CudaResult<CudaPointerAttributes> {
    let mut attributes = MaybeUninit::<CudaPointerAttributes>::uninit();
    unsafe {
        cudaPointerGetAttributes(
            attributes.as_mut_ptr(),
            slice.as_c_void_ptr() as *mut c_void,
        )
        .wrap_maybe_uninit(attributes)
    }
}

#[cfg(test)]
mod tests {
    use serial_test::serial;

    use crate::memory::*;

    use super::*;

    #[test]
    #[serial]
    fn pointer_is_unregistered() {
        let values = [0u32];
        let attributes = pointer_get_attributes(&values).unwrap();
        assert_eq!(attributes.type_, CudaMemoryType::Unregistered);
    }

    #[test]
    #[serial]
    fn pointer_is_host() {
        let values = [0u32];
        let registration =
            HostRegistration::register(&values, CudaHostRegisterFlags::DEFAULT).unwrap();
        let attributes = pointer_get_attributes(&registration).unwrap();
        assert_eq!(attributes.type_, CudaMemoryType::Host);
    }

    #[test]
    #[serial]
    fn pointer_is_device() {
        let allocation = DeviceAllocation::<u32>::alloc(1).unwrap();
        let attributes = pointer_get_attributes(&allocation).unwrap();
        assert_eq!(attributes.type_, CudaMemoryType::Device);
    }
}