rten-gemm 0.25.0

Machine-learning oriented matrix multiplication
Documentation 
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

use std::error::Error;
use std::fmt;
use std::fmt::Display;

/// Errors with matrix multiplication inputs.
#[derive(Clone, Debug, PartialEq)]
pub enum GemmError {
    /// Number of LHS and RHS batch inputs do not match.
    BatchSizeMismatch,
    /// Number of columns in LHS does not match rows of RHS.
    KSizeMismatch,
    /// Bias vector length does not match the corresponding output matrix size.
    WrongBiasSize,
    /// Quantization parameter size does not match corresponding input size.
    WrongQuantParamSize,
    /// The buffer provided for the output is too short.
    OutputSizeMismatch,
    /// The data was packed with a kernel that uses a different layout than
    /// the current kernel.
    PackedDataKernelMismatch,
    /// The data was packed with different cache blocking parameters than are
    /// currently being used.
    PackedDataBlockingMismatch,
    /// Block-quantized inputs are not supported for this data type.
    BlockQuantizedInputNotSupported,
    /// Quantization element size is not supported.
    QuantBitsNotSupported,
}

impl Display for GemmError {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Self::BatchSizeMismatch => {
                write!(fmt, "batches of `a` and `b` matrices must have same length")
            }
            Self::KSizeMismatch => {
                write!(fmt, "columns of matrix `a` must match rows of matrix `b`")
            }
            Self::WrongBiasSize => write!(fmt, "bias vector length is incorrect"),
            Self::WrongQuantParamSize => {
                write!(fmt, "quantization parameter size does not match input")
            }
            Self::OutputSizeMismatch => write!(fmt, "output buffer has wrong length"),
            Self::PackedDataKernelMismatch => {
                write!(fmt, "matrix was packed with a different kernel")
            }
            Self::PackedDataBlockingMismatch => {
                write!(fmt, "matrix was packed with a different blocking size")
            }
            Self::BlockQuantizedInputNotSupported => {
                write!(fmt, "block-quantized inputs not supported for data type")
            }
            Self::QuantBitsNotSupported => {
                write!(
                    fmt,
                    "quantized input has an unsupported number of bits per element"
                )
            }
        }
    }
}

impl Error for GemmError {}

/// Errors with block-quantized inputs.
#[derive(Copy, Clone, Debug, PartialEq)]
pub enum BlockQuantizedError {
    /// The block size is unsupported.
    UnsupportedBlockSize,
    /// The number of bits per element is unsupported.
    UnsupportedElementSize,
}

impl Display for BlockQuantizedError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Self::UnsupportedBlockSize => write!(f, "block size is unsupported"),
            Self::UnsupportedElementSize => write!(f, "unsupported bits-per-element"),
        }
    }
}

impl Error for BlockQuantizedError {}