use serde::{Deserialize, Serialize};
use std::collections::BTreeMap;
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
pub enum SiliconUnit {
Fp32Alu,
Fp64Alu,
Tmu,
Rop,
TensorCore,
MemoryBandwidth,
CacheHierarchy,
SharedMemory,
SubgroupIntrinsics,
}
impl std::fmt::Display for SiliconUnit {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Fp32Alu => write!(f, "FP32 ALU"),
Self::Fp64Alu => write!(f, "FP64 ALU"),
Self::Tmu => write!(f, "TMU"),
Self::Rop => write!(f, "ROP"),
Self::TensorCore => write!(f, "Tensor"),
Self::MemoryBandwidth => write!(f, "Mem BW"),
Self::CacheHierarchy => write!(f, "Cache"),
Self::SharedMemory => write!(f, "LDS/Shared"),
Self::SubgroupIntrinsics => write!(f, "Subgroup"),
}
}
}
#[derive(Clone, Debug, Default, Serialize, Deserialize)]
pub struct UnitThroughput {
pub theoretical_peak: f64,
pub measured_peak: f64,
pub efficiency: f64,
pub unit: String,
}
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct CompositionEntry {
pub unit_a: SiliconUnit,
pub unit_b: SiliconUnit,
pub serial_ms: f64,
pub compound_ms: f64,
pub multiplier: f64,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum GpuVendorTag {
Nvidia,
Amd,
Intel,
Apple,
Software,
Unknown,
}
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct SiliconProfile {
pub adapter_name: String,
pub vendor: GpuVendorTag,
pub vram_bytes: u64,
pub boost_ghz: f64,
pub units: BTreeMap<SiliconUnit, UnitThroughput>,
pub compositions: Vec<CompositionEntry>,
pub df64_tflops: f64,
pub l2_bytes: u64,
pub infinity_cache_bytes: u64,
pub tmu_count: u32,
pub rop_count: u32,
pub subgroup_size: u32,
pub measured_at: String,
}
impl SiliconProfile {
#[must_use]
pub fn has_unit(&self, unit: SiliconUnit) -> bool {
self.units.get(&unit).is_some_and(|t| t.measured_peak > 0.0)
}
#[must_use]
pub fn measured_throughput(&self, unit: SiliconUnit) -> f64 {
self.units.get(&unit).map_or(0.0, |t| t.measured_peak)
}
#[must_use]
pub fn fp64_fp32_ratio(&self) -> f64 {
let fp32 = self.measured_throughput(SiliconUnit::Fp32Alu);
let fp64 = self.measured_throughput(SiliconUnit::Fp64Alu);
if fp32 > 0.0 { fp64 / fp32 } else { 0.0 }
}
#[must_use]
pub fn has_tensor_cores(&self) -> bool {
self.has_unit(SiliconUnit::TensorCore)
}
#[must_use]
pub const fn has_subgroup_intrinsics(&self) -> bool {
self.subgroup_size > 0
}
#[must_use]
pub fn best_composition(&self, unit: SiliconUnit) -> f64 {
self.compositions
.iter()
.filter(|c| c.unit_a == unit || c.unit_b == unit)
.map(|c| c.multiplier)
.fold(1.0f64, f64::max)
}
pub fn save(&self, path: &std::path::Path) -> std::io::Result<()> {
let json = serde_json::to_string_pretty(self).map_err(std::io::Error::other)?;
std::fs::write(path, json)
}
pub fn load(path: &std::path::Path) -> std::io::Result<Self> {
let json = std::fs::read_to_string(path)?;
serde_json::from_str(&json)
.map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))
}
}
#[must_use]
pub fn route_workload(
profile: &SiliconProfile,
preferred: &[SiliconUnit],
fallback: SiliconUnit,
) -> SiliconUnit {
preferred
.iter()
.find(|&&unit| profile.has_unit(unit))
.copied()
.unwrap_or(fallback)
}
#[cfg(test)]
mod tests {
use super::*;
fn test_profile() -> SiliconProfile {
let mut units = BTreeMap::new();
units.insert(
SiliconUnit::Fp32Alu,
UnitThroughput {
theoretical_peak: 35.58,
measured_peak: 32.0,
efficiency: 0.9,
unit: "TFLOPS".into(),
},
);
units.insert(
SiliconUnit::Fp64Alu,
UnitThroughput {
theoretical_peak: 0.556,
measured_peak: 0.52,
efficiency: 0.93,
unit: "TFLOPS".into(),
},
);
units.insert(
SiliconUnit::Tmu,
UnitThroughput {
theoretical_peak: 556.0,
measured_peak: 480.0,
efficiency: 0.86,
unit: "GT/s".into(),
},
);
SiliconProfile {
adapter_name: "NVIDIA GeForce RTX 3090".into(),
vendor: GpuVendorTag::Nvidia,
vram_bytes: 24 * 1024 * 1024 * 1024,
boost_ghz: 1.695,
units,
compositions: vec![CompositionEntry {
unit_a: SiliconUnit::Fp32Alu,
unit_b: SiliconUnit::Tmu,
serial_ms: 10.0,
compound_ms: 6.0,
multiplier: 1.67,
}],
df64_tflops: 4.2,
l2_bytes: 6 * 1024 * 1024,
infinity_cache_bytes: 0,
tmu_count: 328,
rop_count: 112,
subgroup_size: 32,
measured_at: "2026-03-29T12:00:00Z".into(),
}
}
#[test]
fn fp64_fp32_ratio_gaming() {
let p = test_profile();
let ratio = p.fp64_fp32_ratio();
assert!(
ratio < 0.05,
"gaming GPU should have low FP64:FP32 ratio: {ratio}"
);
}
#[test]
fn has_units() {
let p = test_profile();
assert!(p.has_unit(SiliconUnit::Fp32Alu));
assert!(p.has_unit(SiliconUnit::Tmu));
assert!(!p.has_unit(SiliconUnit::TensorCore));
}
#[test]
fn best_composition_found() {
let p = test_profile();
let c = p.best_composition(SiliconUnit::Tmu);
assert!((c - 1.67).abs() < 0.01);
}
#[test]
fn best_composition_missing() {
let p = test_profile();
let c = p.best_composition(SiliconUnit::Rop);
assert!((c - 1.0).abs() < 0.01, "should be serial fallback");
}
#[test]
fn route_workload_finds_tmu() {
let p = test_profile();
let unit = route_workload(
&p,
&[
SiliconUnit::TensorCore,
SiliconUnit::Tmu,
SiliconUnit::Fp32Alu,
],
SiliconUnit::Fp64Alu,
);
assert_eq!(unit, SiliconUnit::Tmu, "tensor cores missing → TMU first");
}
#[test]
fn route_workload_fallback() {
let p = test_profile();
let unit = route_workload(&p, &[SiliconUnit::TensorCore], SiliconUnit::Fp32Alu);
assert_eq!(unit, SiliconUnit::Fp32Alu, "should fallback");
}
#[test]
fn serde_round_trip() {
let p = test_profile();
let json = serde_json::to_string(&p).unwrap();
let restored: SiliconProfile = serde_json::from_str(&json).unwrap();
assert_eq!(restored.adapter_name, p.adapter_name);
assert_eq!(restored.tmu_count, p.tmu_count);
}
}