j2k-cuda-runtime 0.7.2

CUDA codec engine and Driver API runtime for j2k device adapters
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

// SPDX-License-Identifier: MIT OR Apache-2.0

use crate::{driver::CuDevicePtr, error::CudaError};

pub(crate) fn validate_device_allocation(ptr: CuDevicePtr, len: usize) -> Result<(), CudaError> {
    if len != 0 && ptr == 0 {
        return Err(CudaError::InternalInvariant {
            what: "CUDA returned null for a nonzero device allocation",
        });
    }
    Ok(())
}

pub(crate) fn validate_resource_handle<T>(
    ptr: *mut T,
    what: &'static str,
) -> Result<(), CudaError> {
    if ptr.is_null() {
        return Err(CudaError::InternalInvariant { what });
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::{validate_device_allocation, validate_resource_handle};
    use crate::error::CudaError;
    use std::ffi::c_void;

    #[test]
    fn nonzero_null_device_allocation_is_rejected() {
        assert!(matches!(
            validate_device_allocation(0, 1),
            Err(CudaError::InternalInvariant { .. })
        ));
        validate_device_allocation(0, 0).expect("zero-byte allocation may use the null sentinel");
        validate_device_allocation(1, 1).expect("nonzero device allocation");
    }

    #[test]
    fn null_resource_handle_is_rejected() {
        assert!(matches!(
            validate_resource_handle::<c_void>(
                std::ptr::null_mut(),
                "CUDA returned a null test handle",
            ),
            Err(CudaError::InternalInvariant { .. })
        ));
        validate_resource_handle(
            std::ptr::without_provenance_mut::<c_void>(1),
            "CUDA returned a null test handle",
        )
        .expect("non-null resource handle");
    }
}