use core::fmt;
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum Variant {
#[default]
Correct,
Faithful,
Fast,
}
impl Variant {
pub const ALL: [Variant; 3] = [Variant::Correct, Variant::Faithful, Variant::Fast];
pub fn requires_bit_exact(self) -> bool {
matches!(self, Variant::Correct)
}
}
impl fmt::Display for Variant {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Variant::Correct => f.write_str("correct"),
Variant::Faithful => f.write_str("faithful"),
Variant::Fast => f.write_str("fast"),
}
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum SchedTier {
#[default]
Inline,
Local,
Hierarchical,
Federated,
}
impl SchedTier {
pub const ALL: [SchedTier; 4] = [
SchedTier::Inline,
SchedTier::Local,
SchedTier::Hierarchical,
SchedTier::Federated,
];
pub fn spin_rounds(self) -> u32 {
match self {
SchedTier::Inline => 0,
SchedTier::Local => 8,
SchedTier::Hierarchical => 32,
SchedTier::Federated => 0,
}
}
}
impl fmt::Display for SchedTier {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
SchedTier::Inline => f.write_str("inline"),
SchedTier::Local => f.write_str("local"),
SchedTier::Hierarchical => f.write_str("hierarchical"),
SchedTier::Federated => f.write_str("federated"),
}
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum HwClass {
#[default]
Scalar,
Sse2,
Avx2,
Avx512f,
Avx512Bf16,
Avx512Vnni,
Avx512Vbmi2,
AvxVnniVex,
Gfni,
Avx512Fp16,
Avx10_2,
Neon,
Sve2,
Sme,
AmxBf16,
AmxInt8,
AmxFp16,
TensorCoreHopper,
TensorCoreBlackwell,
}
impl HwClass {
pub fn is_matrix_extension(self) -> bool {
matches!(
self,
HwClass::Sme
| HwClass::AmxBf16
| HwClass::AmxInt8
| HwClass::AmxFp16
| HwClass::TensorCoreHopper
| HwClass::TensorCoreBlackwell
)
}
}
impl fmt::Display for HwClass {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let s = match self {
HwClass::Scalar => "scalar",
HwClass::Sse2 => "sse2",
HwClass::Avx2 => "avx2",
HwClass::Avx512f => "avx512f",
HwClass::Avx512Bf16 => "avx512bf16",
HwClass::Avx512Vnni => "avx512vnni",
HwClass::Avx512Vbmi2 => "avx512vbmi2",
HwClass::AvxVnniVex => "avx-vnni",
HwClass::Gfni => "gfni",
HwClass::Avx512Fp16 => "avx512fp16",
HwClass::Avx10_2 => "avx10.2",
HwClass::Neon => "neon",
HwClass::Sve2 => "sve2",
HwClass::Sme => "sme",
HwClass::AmxBf16 => "amx-bf16",
HwClass::AmxInt8 => "amx-int8",
HwClass::AmxFp16 => "amx-fp16",
HwClass::TensorCoreHopper => "tc-hopper",
HwClass::TensorCoreBlackwell => "tc-blackwell",
};
f.write_str(s)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn variant_all_has_three_variants() {
assert_eq!(Variant::ALL.len(), 3);
assert_eq!(Variant::ALL[0], Variant::Correct);
}
#[test]
fn variant_correct_requires_bit_exact() {
assert!(Variant::Correct.requires_bit_exact());
assert!(!Variant::Faithful.requires_bit_exact());
assert!(!Variant::Fast.requires_bit_exact());
}
#[test]
fn sched_tier_all_has_four_variants() {
assert_eq!(SchedTier::ALL.len(), 4);
}
#[test]
fn sched_tier_spin_rounds_documented_floor() {
assert_eq!(SchedTier::Inline.spin_rounds(), 0);
assert_eq!(SchedTier::Local.spin_rounds(), 8);
assert_eq!(SchedTier::Hierarchical.spin_rounds(), 32);
assert_eq!(SchedTier::Federated.spin_rounds(), 0);
}
#[test]
fn sched_tier_default_is_inline() {
assert_eq!(SchedTier::default(), SchedTier::Inline);
}
#[test]
fn hw_class_matrix_extension_classifier() {
assert!(!HwClass::Scalar.is_matrix_extension());
assert!(!HwClass::Avx2.is_matrix_extension());
assert!(!HwClass::Avx512f.is_matrix_extension());
assert!(!HwClass::Neon.is_matrix_extension());
assert!(!HwClass::Avx512Vbmi2.is_matrix_extension());
assert!(!HwClass::AvxVnniVex.is_matrix_extension());
assert!(!HwClass::Gfni.is_matrix_extension());
assert!(!HwClass::Avx512Fp16.is_matrix_extension());
assert!(!HwClass::Avx10_2.is_matrix_extension());
assert!(!HwClass::Sve2.is_matrix_extension());
assert!(HwClass::Sme.is_matrix_extension());
assert!(HwClass::AmxBf16.is_matrix_extension());
assert!(HwClass::AmxInt8.is_matrix_extension());
assert!(HwClass::AmxFp16.is_matrix_extension());
assert!(HwClass::TensorCoreHopper.is_matrix_extension());
assert!(HwClass::TensorCoreBlackwell.is_matrix_extension());
}
#[test]
fn hw_class_default_is_scalar() {
assert_eq!(HwClass::default(), HwClass::Scalar);
}
#[test]
fn sched_tier_display_round_trip() {
assert_eq!(format!("{}", SchedTier::Inline), "inline");
assert_eq!(format!("{}", SchedTier::Local), "local");
assert_eq!(format!("{}", SchedTier::Hierarchical), "hierarchical");
assert_eq!(format!("{}", SchedTier::Federated), "federated");
}
#[test]
fn hw_class_display_for_every_variant() {
assert!(!format!("{}", HwClass::Scalar).is_empty());
assert!(!format!("{}", HwClass::Avx512f).is_empty());
assert!(!format!("{}", HwClass::AmxBf16).is_empty());
assert!(!format!("{}", HwClass::TensorCoreBlackwell).is_empty());
assert_eq!(format!("{}", HwClass::Avx512Vbmi2), "avx512vbmi2");
assert_eq!(format!("{}", HwClass::AvxVnniVex), "avx-vnni");
assert_eq!(format!("{}", HwClass::Gfni), "gfni");
assert_eq!(format!("{}", HwClass::Avx512Fp16), "avx512fp16");
assert_eq!(format!("{}", HwClass::Avx10_2), "avx10.2");
assert_eq!(format!("{}", HwClass::Sve2), "sve2");
}
}