cutile 0.0.0-alpha

cuTile Rust lets programmers safely author and execute tile kernels directly in Rust.
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use cuda_async::error::DeviceError;
use cutile_compiler::error::JITError;
use cuda_core::DriverError;
use std::{
    error,
    fmt::{self, Display, Formatter},
};

#[derive(Debug)]
pub struct TensorError(pub String);

impl Display for TensorError {
    fn fmt(&self, formatter: &mut Formatter) -> fmt::Result {
        let message = &self.0;
        write!(formatter, "{message}")
    }
}

impl error::Error for TensorError {}

#[derive(Debug)]
pub struct KernelLaunchError(pub String);

impl Display for KernelLaunchError {
    fn fmt(&self, formatter: &mut Formatter) -> fmt::Result {
        let message = &self.0;
        write!(formatter, "{message}")
    }
}

impl error::Error for KernelLaunchError {}

pub enum Error {
    Tensor(TensorError),
    KernelLaunch(KernelLaunchError),
    JIT(JITError),
    Device(DeviceError),
    Driver(DriverError),
    Anyhow(anyhow::Error),
}

impl fmt::Debug for Error {
    fn fmt(&self, formatter: &mut Formatter) -> fmt::Result {
        // Delegate to Display so that `.unwrap()` produces the same
        // user-facing output (including source locations from JITError).
        Display::fmt(self, formatter)
    }
}

impl Display for Error {
    fn fmt(&self, formatter: &mut Formatter) -> fmt::Result {
        match self {
            Self::Tensor(error) => write!(formatter, "error: {error}"),
            Self::KernelLaunch(error) => write!(formatter, "error: {error}"),
            Self::JIT(error) => write!(formatter, "error: {error}"),
            Self::Device(error) => write!(formatter, "error: {error}"),
            Self::Driver(error) => write!(formatter, "error: {error}"),
            Self::Anyhow(error) => write!(formatter, "error: {error}"),
        }
    }
}

impl error::Error for Error {}

// Tensor

pub fn tensor_error(err_str: &str) -> Error {
    return Error::Tensor(TensorError(err_str.to_string()));
}

pub fn tensor_error_result<R>(err_str: &str) -> Result<R, Error> {
    return Err(tensor_error(err_str));
}

// Kernel Launch

pub fn kernel_launch_error(err_str: &str) -> Error {
    return Error::KernelLaunch(KernelLaunchError(err_str.to_string()));
}

pub fn kernel_launch_error_result<R>(err_str: &str) -> Result<R, Error> {
    return Err(kernel_launch_error(err_str));
}

// anyhow

impl From<anyhow::Error> for Error {
    fn from(error: anyhow::Error) -> Self {
        Self::Anyhow(error)
    }
}

// Device

impl From<Error> for DeviceError {
    fn from(error: Error) -> Self {
        DeviceError::Anyhow(format!("{:?}", error))
    }
}

impl From<DeviceError> for Error {
    fn from(error: DeviceError) -> Self {
        Self::Device(error)
    }
}

// DriverError

impl From<DriverError> for Error {
    fn from(error: DriverError) -> Self {
        Self::Driver(error)
    }
}

// Syn

impl From<JITError> for Error {
    fn from(error: JITError) -> Self {
        Self::JIT(error)
    }
}