#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum WgslOpClass {
F64Fma,
F64MulAdd,
F64Transcend,
F32Fma,
I32Arith,
SharedMem,
GlobalMem,
}
#[derive(Debug, Clone)]
pub enum LatencyModel {
Sm70,
Rdna2,
Conservative,
AppleM,
Measured {
dfma_cycles: u32,
ffma_cycles: u32,
smem_cycles: u32,
},
}
impl LatencyModel {
#[must_use]
pub const fn measured(dfma_cycles: u32, ffma_cycles: u32, smem_cycles: u32) -> Self {
Self::Measured {
dfma_cycles,
ffma_cycles,
smem_cycles,
}
}
#[must_use]
pub fn raw_latency(&self, op: WgslOpClass) -> u32 {
match self {
Self::Sm70 => match op {
WgslOpClass::F64Fma => 8,
WgslOpClass::F64MulAdd => 16,
WgslOpClass::F64Transcend => 20,
WgslOpClass::F32Fma => 4,
WgslOpClass::I32Arith => 6,
WgslOpClass::SharedMem => 25,
WgslOpClass::GlobalMem => 300,
},
Self::Rdna2 => match op {
WgslOpClass::F64Fma => 4,
WgslOpClass::F64MulAdd => 8,
WgslOpClass::F64Transcend => 16,
WgslOpClass::F32Fma => 4,
WgslOpClass::I32Arith => 4,
WgslOpClass::SharedMem => 20,
WgslOpClass::GlobalMem => 200,
},
Self::Conservative => match op {
WgslOpClass::F64Fma => 8,
WgslOpClass::F64MulAdd => 16,
WgslOpClass::F64Transcend => 20,
WgslOpClass::F32Fma => 4,
WgslOpClass::I32Arith => 6,
WgslOpClass::SharedMem => 30,
WgslOpClass::GlobalMem => 800,
},
Self::AppleM => match op {
WgslOpClass::F64Fma => 16,
WgslOpClass::F64MulAdd => 32,
WgslOpClass::F64Transcend => 40,
WgslOpClass::F32Fma => 4,
WgslOpClass::I32Arith => 4,
WgslOpClass::SharedMem => 20,
WgslOpClass::GlobalMem => 250,
},
Self::Measured {
dfma_cycles,
ffma_cycles,
smem_cycles,
} => match op {
WgslOpClass::F64Fma => *dfma_cycles,
WgslOpClass::F64MulAdd => dfma_cycles * 2,
WgslOpClass::F64Transcend => dfma_cycles + 12,
WgslOpClass::F32Fma => *ffma_cycles,
WgslOpClass::I32Arith => Self::Conservative.raw_latency(op),
WgslOpClass::SharedMem => *smem_cycles,
WgslOpClass::GlobalMem => Self::Conservative.raw_latency(op),
},
}
}
#[must_use]
pub fn war_latency(&self, _op: WgslOpClass) -> u32 {
0
}
#[must_use]
pub fn needs_scoreboard(&self, op: WgslOpClass) -> bool {
match self {
Self::Conservative | Self::Measured { .. } => true,
Self::Sm70 | Self::Rdna2 | Self::AppleM => matches!(
op,
WgslOpClass::F64Fma
| WgslOpClass::F64MulAdd
| WgslOpClass::F64Transcend
| WgslOpClass::SharedMem
| WgslOpClass::GlobalMem
),
}
}
#[must_use]
pub fn f64_ilp_fill_width(&self) -> u32 {
self.raw_latency(WgslOpClass::F64Fma)
}
}
#[must_use]
pub fn model_for_arch(arch: super::driver_profile::GpuArch) -> LatencyModel {
use super::driver_profile::GpuArch;
match arch {
GpuArch::Volta | GpuArch::Turing | GpuArch::Ampere | GpuArch::Ada | GpuArch::Blackwell => {
LatencyModel::Sm70
}
GpuArch::Rdna2 | GpuArch::Rdna3 | GpuArch::Cdna2 => LatencyModel::Rdna2,
GpuArch::IntelArc => LatencyModel::Conservative,
GpuArch::AppleM => LatencyModel::AppleM,
GpuArch::Software | GpuArch::Unknown => LatencyModel::Conservative,
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_sm70_dfma_latency() {
let m = LatencyModel::Sm70;
assert_eq!(m.raw_latency(WgslOpClass::F64Fma), 8);
assert_eq!(m.raw_latency(WgslOpClass::F32Fma), 4);
assert_eq!(m.f64_ilp_fill_width(), 8);
}
#[test]
fn test_rdna2_dfma_latency() {
let m = LatencyModel::Rdna2;
assert_eq!(m.raw_latency(WgslOpClass::F64Fma), 4);
assert_eq!(m.raw_latency(WgslOpClass::F32Fma), 4);
assert_eq!(m.f64_ilp_fill_width(), 4);
}
#[test]
fn test_conservative_is_max() {
let conservative = LatencyModel::Conservative;
let sm70 = LatencyModel::Sm70;
let rdna2 = LatencyModel::Rdna2;
for op in [
WgslOpClass::F64Fma,
WgslOpClass::F32Fma,
WgslOpClass::I32Arith,
WgslOpClass::SharedMem,
] {
assert!(
conservative.raw_latency(op) >= sm70.raw_latency(op),
"Conservative should be >= SM70 for {op:?}"
);
assert!(
conservative.raw_latency(op) >= rdna2.raw_latency(op),
"Conservative should be >= RDNA2 for {op:?}"
);
}
}
#[test]
fn test_measured_model() {
let m = LatencyModel::measured(8, 4, 25);
assert_eq!(m.raw_latency(WgslOpClass::F64Fma), 8);
assert_eq!(m.raw_latency(WgslOpClass::F32Fma), 4);
assert_eq!(m.raw_latency(WgslOpClass::F64MulAdd), 16);
assert_eq!(m.raw_latency(WgslOpClass::SharedMem), 25);
}
#[test]
fn test_model_for_arch() {
use super::super::driver_profile::GpuArch;
let model = model_for_arch(GpuArch::Volta);
assert_eq!(model.raw_latency(WgslOpClass::F64Fma), 8);
let model = model_for_arch(GpuArch::Rdna2);
assert_eq!(model.raw_latency(WgslOpClass::F64Fma), 4);
let model = model_for_arch(GpuArch::Unknown);
assert_eq!(model.raw_latency(WgslOpClass::F64Fma), 8);
}
#[test]
fn test_scoreboard_classification() {
let m = LatencyModel::Sm70;
assert!(m.needs_scoreboard(WgslOpClass::F64Fma));
assert!(m.needs_scoreboard(WgslOpClass::GlobalMem));
assert!(!m.needs_scoreboard(WgslOpClass::F32Fma));
assert!(!m.needs_scoreboard(WgslOpClass::I32Arith));
}
#[test]
fn test_war_latency_zero_on_register_renamed_gpus() {
for op in [WgslOpClass::F64Fma, WgslOpClass::SharedMem] {
assert_eq!(LatencyModel::Sm70.war_latency(op), 0);
assert_eq!(LatencyModel::Rdna2.war_latency(op), 0);
}
}
}