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
/// Result returned by the native CUDA adapter.
pub type Result<T> = std::result::Result<T, Error>;
/// CUDA adapter initialization or execution failure.
#[derive(Debug, thiserror::Error)]
pub enum Error {
/// Mircuda rejected the native operation.
#[error(transparent)]
Native(#[from] mircuda::Error),
/// Model tensor metadata is invalid.
#[error(transparent)]
Model(#[from] models::ModelsError),
/// Backend-neutral session or K/V planning failed.
#[error(transparent)]
Runtime(#[from] runtime::RuntimeError),
/// Checkpoint payload I/O failed.
#[error(transparent)]
Io(#[from] std::io::Error),
/// A checkpoint dimension or offset cannot be represented by the target
/// ABI.
#[error(transparent)]
IntegerConversion(#[from] std::num::TryFromIntError),
/// A finite model scalar cannot be represented by a native kernel scalar.
#[error(transparent)]
FloatConversion(#[from] std::num::ParseFloatError),
/// The configured CUDA device ordinal is unavailable.
#[error("CUDA device ordinal {0} is unavailable")]
DeviceUnavailable(usize),
/// Safetensors storage type is not implemented by the CUDA loader.
#[error("unsupported CUDA tensor dtype {0}")]
UnsupportedDType(String),
/// Tensor shape and payload byte count disagree.
#[error("invalid tensor payload size for {name}: expected {expected}, got {actual}")]
InvalidTensorSize {
name: String,
expected: usize,
actual: usize,
},
/// A device-side dtype conversion received incompatible buffer lengths.
#[error("invalid CUDA tensor conversion lengths: input {input}, output {output}")]
InvalidTensorConversion { input: usize, output: usize },
/// A completed upload contains the same tensor name more than once.
#[error("duplicate CUDA tensor: {0}")]
DuplicateTensor(String),
/// A requested CUDA tensor is not present in the completed set.
#[error("CUDA tensor is missing: {0}")]
MissingTensor(String),
/// A diagnostic host read requested the wrong tensor storage type.
#[error("CUDA tensor {name} is not {expected}")]
DTypeMismatch { name: String, expected: &'static str },
/// A dense projection received a weight with a different checkpoint shape.
#[error("invalid linear weight {name}: expected {expected:?}, got {actual:?}")]
InvalidLinearWeight {
name: String,
expected: [usize; 2],
actual: Vec<usize>,
},
/// A packed affine tensor has a shape incompatible with its linear plan.
#[error("invalid quantized tensor {name}: expected {expected:?}, got {actual:?}")]
InvalidQuantizedTensor {
name: String,
expected: Vec<usize>,
actual: Vec<usize>,
},
/// An expert or matrix index is outside the uploaded tensor bank.
#[error("quantized matrix index {index} exceeds matrix count {matrices}")]
InvalidMatrixIndex { index: usize, matrices: usize },
/// Model metadata names a gated activation without a native CUDA
/// implementation.
#[error("unsupported gated activation: {0}")]
UnsupportedGatedActivation(String),
/// An affine quantized GEMV shape or format is not representable.
#[error("invalid affine quantized GEMV: {0}")]
InvalidQuantizedGemv(&'static str),
/// An NVFP4 checkpoint matrix violates the native block layout.
#[error("invalid NVFP4 matrix: {0}")]
InvalidNvFp4(&'static str),
/// A normalization or rotary operation has invalid fixed geometry.
#[error("invalid CUDA decoder kernel: {0}")]
InvalidDecoderKernel(&'static str),
/// A fixed-shape vision primitive received invalid geometry or storage.
#[error("invalid CUDA vision kernel: {0}")]
InvalidVisionKernel(&'static str),
/// The model-level CUDA execution planner rejected a request.
#[error("invalid CUDA execution plan: {0}")]
InvalidExecutionPlan(&'static str),
/// A token identifier is outside the model vocabulary.
#[error("token {token} exceeds CUDA model vocabulary {vocab}")]
InvalidToken { token: u32, vocab: usize },
/// Sampling policy cannot execute entirely on CUDA.
#[error("invalid CUDA sampling policy: {0}")]
InvalidSampling(String),
/// Checkpoint metadata describes a decoder layer outside the native CUDA
/// capability set.
#[error("unsupported CUDA decoder layer: {0}")]
UnsupportedDecoderLayer(String),
/// Semantic lowering found no CUDA implementation for one concrete
/// operation, storage representation, and geometry.
#[error("missing CUDA capability for {operation} with {storage} at {geometry}: {requirement}")]
MissingCapability {
operation: &'static str,
storage: String,
geometry: String,
requirement: &'static str,
},
/// A structurally discovered vision contract has no complete CUDA path.
#[error("unsupported CUDA vision contract: {0}")]
UnsupportedVisionContract(String),
/// The model/session registry cannot be accessed consistently.
#[error("CUDA inference state failed: {0}")]
State(String),
/// Paged KV storage or attention received an incompatible geometry.
#[error("invalid CUDA paged KV operation: {0}")]
InvalidPagedKv(&'static str),
/// Routed-expert selection received incompatible geometry or tensors.
#[error("invalid CUDA router: {0}")]
InvalidRouter(&'static str),
/// A quantized GEMV buffer does not match the fixed execution shape.
#[error("quantized GEMV {operand} length mismatch: expected at least {expected}, got {actual}")]
QuantizedGemvLengthMismatch {
operand: &'static str,
expected: usize,
actual: usize,
},
}
impl From<Error> for runtime::RuntimeError {
fn from(value: Error) -> Self {
Self::Backend(value.to_string())
}
}