cutile 0.0.1

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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

/*
 * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: Apache-2.0
 */

//! Error types for the cutile crate, covering tensor, kernel launch, JIT, and device errors.

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

/// An error originating from an invalid tensor operation (e.g. shape mismatch).
#[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 {}

/// An error raised when a kernel launch fails (e.g. mismatched grid dimensions).
#[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 {}

/// Unified error type aggregating all error sources in the cutile crate.
pub enum Error {
    /// A tensor-related error (shape, rank, size, etc.).
    Tensor(TensorError),
    /// A kernel launch configuration error (grid, block, shared memory, etc.).
    KernelLaunch(KernelLaunchError),
    /// A JIT compilation error from the cutile compiler.
    JIT(JITError),
    /// An asynchronous device execution error.
    Device(DeviceError),
    /// A low-level CUDA driver error.
    Driver(DriverError),
    /// A catch-all error from `anyhow`.
    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

/// Creates a `Error::Tensor` from the given message string.
pub fn tensor_error(err_str: &str) -> Error {
    Error::Tensor(TensorError(err_str.to_string()))
}

/// Returns `Err(Error::Tensor(...))` with the given message string.
pub fn tensor_error_result<R>(err_str: &str) -> Result<R, Error> {
    Err(tensor_error(err_str))
}

// Kernel Launch

/// Creates a `Error::KernelLaunch` from the given message string.
pub fn kernel_launch_error(err_str: &str) -> Error {
    Error::KernelLaunch(KernelLaunchError(err_str.to_string()))
}

/// Returns `Err(Error::KernelLaunch(...))` with the given message string.
pub fn kernel_launch_error_result<R>(err_str: &str) -> Result<R, Error> {
    Err(kernel_launch_error(err_str))
}

// anyhow

/// Converts an `anyhow::Error` into `Error::Anyhow`.
impl From<anyhow::Error> for Error {
    fn from(error: anyhow::Error) -> Self {
        Self::Anyhow(error)
    }
}

// Device

/// Converts an `Error` into a `DeviceError` by formatting via `Debug`.
impl From<Error> for DeviceError {
    fn from(error: Error) -> Self {
        DeviceError::Anyhow(format!("{:?}", error))
    }
}

/// Converts a `DeviceError` into `Error::Device`.
impl From<DeviceError> for Error {
    fn from(error: DeviceError) -> Self {
        Self::Device(error)
    }
}

// DriverError

/// Converts a `DriverError` into `Error::Driver`.
impl From<DriverError> for Error {
    fn from(error: DriverError) -> Self {
        Self::Driver(error)
    }
}

// Syn

/// Converts a `JITError` into `Error::JIT`.
impl From<JITError> for Error {
    fn from(error: JITError) -> Self {
        Self::JIT(error)
    }
}