tenferro-gpu 0.3.0

CubeCL-backed CUDA and WebGPU provider backends for tenferro tensors.
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use tenferro_tensor::{DType, ErrorKind};
use thiserror::Error;

/// Structured errors owned by the CUDA backend.
#[derive(Debug, Error)]
#[non_exhaustive]
pub(crate) enum CudaError {
    /// The operation does not have a CUDA implementation for this dtype.
    #[error("{op} does not support dtype {dtype:?} on CUDA")]
    UnsupportedDType { op: &'static str, dtype: DType },
    /// The backend does not implement an operation or configuration.
    #[error("{op} is unsupported on CUDA: {detail}")]
    UnsupportedOperation {
        op: &'static str,
        detail: &'static str,
    },
    /// A CUDA library call returned a non-success status.
    #[error("{library} call {call} returned status {status}")]
    ProviderStatus {
        library: &'static str,
        call: &'static str,
        status: i32,
    },
    /// A CUDA provider reported a workspace size that cannot be represented
    /// by the host allocator.
    #[error("{op} workspace size {size} does not fit in usize")]
    WorkspaceSizeOverflow { op: &'static str, size: u64 },
    /// Integer arithmetic encountered a zero divisor.
    #[error("{op} detected division by zero for dtype {dtype:?} on CUDA")]
    DivisionByZero { op: &'static str, dtype: DType },
    /// Integer power received a negative exponent.
    #[error("{op} received a negative integer exponent for dtype {dtype:?} on CUDA")]
    NegativeIntegerExponent { op: &'static str, dtype: DType },
}

/// Construct an operation-level unsupported-dtype error without pretending it
/// is a conversion between two different dtypes.
pub(crate) fn unsupported_dtype(op: &'static str, dtype: DType) -> crate::Error {
    crate::Error::extension(
        op,
        "cuda",
        ErrorKind::Unsupported,
        CudaError::UnsupportedDType { op, dtype },
    )
}

/// Construct a typed CUDA numerical-domain failure.
pub(crate) fn division_by_zero(op: &'static str, dtype: DType) -> crate::Error {
    crate::Error::extension(
        op,
        "cuda",
        ErrorKind::NumericalFailure,
        CudaError::DivisionByZero { op, dtype },
    )
}

/// Construct a typed CUDA operation-capability failure.
pub(crate) fn unsupported_operation(op: &'static str, detail: &'static str) -> crate::Error {
    crate::Error::extension(
        op,
        "cuda",
        ErrorKind::Unsupported,
        CudaError::UnsupportedOperation { op, detail },
    )
}

/// Preserve a CUDA library status as a typed backend source.
pub(crate) fn provider_status(
    op: &'static str,
    library: &'static str,
    call: &'static str,
    status: i32,
) -> crate::Error {
    crate::Error::extension(
        op,
        "cuda",
        ErrorKind::BackendFailure,
        CudaError::ProviderStatus {
            library,
            call,
            status,
        },
    )
}

/// Preserve a CUDA workspace allocation overflow as a typed backend source.
pub(crate) fn workspace_size_overflow(op: &'static str, size: u64) -> crate::Error {
    crate::Error::extension(
        op,
        "cuda",
        ErrorKind::BackendFailure,
        CudaError::WorkspaceSizeOverflow { op, size },
    )
}

/// Construct a typed CUDA negative-exponent failure.
pub(crate) fn negative_integer_exponent(op: &'static str, dtype: DType) -> crate::Error {
    crate::Error::extension(
        op,
        "cuda",
        ErrorKind::NumericalFailure,
        CudaError::NegativeIntegerExponent { op, dtype },
    )
}

#[cfg(test)]
mod tests;