custos 0.7.0

A minimal OpenCL, WGPU, CUDA and host CPU array manipulation engine.
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

pub type CudaResult<T> = std::result::Result<T, CudaErrorKind>;

pub enum CudaErrorKind {
    InvalidAllocSize,
    InvalidDeviceIdx,
    InvalidValue,
    OutOfMemory,
    NotInitialized,
    Deinitialized,
    ProfilerDisaled,
    ProfilerNotInitialized,
    ProfilerAlreadyStarted,
    ProfilerAlreadyStopped,
    NoDevice,
    InvalidDevice,
    InvalidImage,
    InvalidContext,
    ContextAlreadyCurrent,
    MapFailed,
    UnmapFailed,
    ArrayIsMapped,
    AlreadyMapped,
    NoBinaryForGPU,
    AlreadyAcquired,
    NotMapped,
    NotMappedAsArray,
    NotMappedAsPointer,
    ECCUncorrectable,
    UnsupportedLlimit,
    ContextAlreadyInUse,
    PeerAccessUnsupported,
    InvalidPTX,
    InvalidGraphicsContext,
    NVLINKUncorrectable,
    JITCompilerNotFound,
    InvalidSource,
    FileNotFound,
    SharedObjectSymbolNotFound,
    SharedObjectInitFailed,
    OperatingSystem,
    InvalidHandle,
    IllegalState,
    NotFound,
    NotReady,
    IllegalAddress,
    LaunchOutOfResources,
    LaunchTimeout,
    LaunchIncompatibleTexturing,
    Unknown,
}

impl CudaErrorKind {
    pub fn as_str(&self) -> &'static str {
        match self {
            CudaErrorKind::InvalidDeviceIdx => "Invalid device idx, specific CUDA device not found",
            _ => "Unknown",
        }
    }
}

impl From<u32> for CudaErrorKind {
    fn from(value: u32) -> Self {
        println!("cuda value: {value}");
        CudaErrorKind::Unknown
        /*match value {
            _ => CudaErrorKind::Unknown,
        }*/
    }
}

impl core::fmt::Debug for CudaErrorKind {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl core::fmt::Display for CudaErrorKind {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{self:?}")
    }
}

impl std::error::Error for CudaErrorKind {}