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
use core::fmt;
/// Errors returned by data movement CPU reference kernels.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum DataMovementError {
/// Element size was zero.
ZeroElementSize,
/// Input byte length was not divisible by the element size.
MisalignedElements {
/// Input byte length.
data_len: usize,
/// Element byte width.
element_size: usize,
},
/// Index byte buffer was not a sequence of little-endian u32 values.
MisalignedIndices {
/// Index buffer byte length.
len: usize,
},
/// An index selected an element outside the input.
IndexOutOfBounds {
/// Position in the index list.
position: usize,
/// Rejected index value.
index: u32,
/// Number of addressable elements.
element_count: usize,
},
/// Mask length did not match the data length.
MaskLengthMismatch {
/// Data byte length.
data_len: usize,
/// Mask element count.
mask_len: usize,
},
/// Unknown partition predicate id.
UnknownPredicate {
/// Rejected predicate id.
id: u32,
},
/// Requested output would exceed the configured allocation cap.
OutputTooLarge {
/// Requested output bytes.
requested: usize,
/// Maximum allowed output bytes.
max: usize,
},
}
impl fmt::Display for DataMovementError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::ZeroElementSize => {
f.write_str("Fix: pass an element_size greater than zero.")
}
Self::MisalignedElements {
data_len,
element_size,
} => write!(
f,
"Fix: make data length {data_len} divisible by element_size {element_size}."
),
Self::MisalignedIndices { len } => write!(
f,
"Fix: encode indices as little-endian u32 words; got {len} bytes."
),
Self::IndexOutOfBounds {
position,
index,
element_count,
} => write!(
f,
"Fix: index[{position}]={index} must be less than element count {element_count}."
),
Self::MaskLengthMismatch { data_len, mask_len } => write!(
f,
"Fix: pass one mask entry per data byte; data has {data_len} bytes but mask has {mask_len} entries."
),
Self::UnknownPredicate { id } => write!(
f,
"Fix: choose a registered partition predicate id; {id} is not registered."
),
Self::OutputTooLarge { requested, max } => write!(
f,
"Fix: split the request; output would be {requested} bytes, exceeding {max}."
),
}
}
}
impl std::error::Error for DataMovementError {}