pub use super::pcie_probe::PcieLinkInfo;
use super::types::HardwareType;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MixedSubstrate {
GpuOnly,
CpuOnly,
NpuOnly,
GpuToCpu,
CpuToGpu,
GpuToNpu,
NpuToGpu,
}
#[derive(Debug, Clone, Copy)]
pub struct TransferCost {
pub latency_us: f64,
pub bandwidth_gbps: f64,
}
impl TransferCost {
#[must_use]
pub fn estimated_us(&self, bytes: usize) -> f64 {
self.latency_us + (bytes as f64) / (self.bandwidth_gbps * 1000.0)
}
}
pub const PCIE4_X16_BANDWIDTH_GBPS: f64 = 31.5;
pub const PCIE_DMA_LATENCY_US: f64 = 5.0;
pub const GPU_DISPATCH_OVERHEAD_US: f64 = 1500.0;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum BandwidthTier {
PciE3x16,
PciE4x16,
PciE5x16,
HighBandwidthInterconnect,
SharedMemory,
Unknown,
}
impl BandwidthTier {
#[must_use]
pub const fn bandwidth_gbps(self) -> f64 {
match self {
Self::PciE3x16 => 15.75,
Self::PciE4x16 => 31.5,
Self::PciE5x16 => 63.0,
Self::HighBandwidthInterconnect => 300.0,
Self::SharedMemory => 1000.0,
Self::Unknown => 15.75,
}
}
#[must_use]
pub const fn latency_us(self) -> f64 {
match self {
Self::SharedMemory => 0.1,
Self::HighBandwidthInterconnect => 1.0,
_ => PCIE_DMA_LATENCY_US,
}
}
#[must_use]
pub const fn transfer_cost(self) -> TransferCost {
TransferCost {
latency_us: self.latency_us(),
bandwidth_gbps: self.bandwidth_gbps(),
}
}
#[must_use]
pub fn detect_from_adapter_name(name: &str) -> Self {
let lower = name.to_lowercase();
if lower.contains("a100")
|| lower.contains("h100")
|| lower.contains("h200")
|| lower.contains("mi250")
|| lower.contains("mi300")
{
return Self::HighBandwidthInterconnect;
}
if lower.contains("apple") || lower.contains("llvmpipe") || lower.contains("swiftshader") {
return Self::SharedMemory;
}
if lower.contains("b100") || lower.contains("b200") {
return Self::PciE5x16;
}
if lower.contains("rtx 30")
|| lower.contains("rtx 40")
|| lower.contains("rx 6")
|| lower.contains("rx 7")
|| lower.contains("arc")
|| lower.contains("a770")
|| lower.contains("a750")
|| lower.contains("mi2")
{
return Self::PciE4x16;
}
if lower.contains("rtx 20")
|| lower.contains("titan v")
|| lower.contains("v100")
|| lower.contains("gv100")
{
return Self::PciE3x16;
}
Self::Unknown
}
}
#[must_use]
pub fn mixed_substrate(
compute_us: f64,
data_bytes: usize,
source: HardwareType,
target: HardwareType,
) -> MixedSubstrate {
mixed_substrate_with_tier(
compute_us,
data_bytes,
source,
target,
BandwidthTier::PciE4x16,
)
}
#[must_use]
pub fn mixed_substrate_with_tier(
compute_us: f64,
data_bytes: usize,
source: HardwareType,
target: HardwareType,
tier: BandwidthTier,
) -> MixedSubstrate {
if source == target {
return match source {
HardwareType::GPU => MixedSubstrate::GpuOnly,
HardwareType::CPU => MixedSubstrate::CpuOnly,
HardwareType::NPU => MixedSubstrate::NpuOnly,
_ => MixedSubstrate::CpuOnly,
};
}
let cost = tier.transfer_cost();
let transfer_us = cost.estimated_us(data_bytes) + GPU_DISPATCH_OVERHEAD_US;
if compute_us > transfer_us {
match (source, target) {
(HardwareType::GPU, HardwareType::CPU) => MixedSubstrate::GpuToCpu,
(HardwareType::CPU, HardwareType::GPU) => MixedSubstrate::CpuToGpu,
(HardwareType::GPU, HardwareType::NPU) => MixedSubstrate::GpuToNpu,
(HardwareType::NPU, HardwareType::GPU) => MixedSubstrate::NpuToGpu,
_ => match source {
HardwareType::GPU => MixedSubstrate::GpuOnly,
HardwareType::NPU => MixedSubstrate::NpuOnly,
_ => MixedSubstrate::CpuOnly,
},
}
} else {
match source {
HardwareType::GPU => MixedSubstrate::GpuOnly,
HardwareType::CPU => MixedSubstrate::CpuOnly,
HardwareType::NPU => MixedSubstrate::NpuOnly,
_ => MixedSubstrate::CpuOnly,
}
}
}
pub struct PcieBridge {
pub p2p_available: bool,
pub source_label: String,
pub target_label: String,
pub tier: BandwidthTier,
}
impl PcieBridge {
#[must_use]
pub fn detect_p2p() -> Self {
let probed = PcieLinkInfo::probe_all_gpus();
let p2p_available = Self::any_shared_numa(&probed);
let tier = probed
.first()
.map_or(BandwidthTier::Unknown, PcieLinkInfo::bandwidth_tier);
Self {
p2p_available,
source_label: probed
.first()
.map_or_else(|| "gpu".to_string(), |i| i.bdf_address.clone()),
target_label: probed
.get(1)
.map_or_else(|| "npu".to_string(), |i| i.bdf_address.clone()),
tier,
}
}
#[must_use]
pub fn detect_with_adapter(adapter_name: &str) -> Self {
let probed = PcieLinkInfo::probe_all_gpus();
let tier = probed
.iter()
.find(|p| {
adapter_name
.to_lowercase()
.contains(&p.bdf_address.to_lowercase())
})
.map_or_else(
|| BandwidthTier::detect_from_adapter_name(adapter_name),
PcieLinkInfo::bandwidth_tier,
);
Self {
p2p_available: Self::any_shared_numa(&probed),
source_label: "gpu".to_string(),
target_label: "npu".to_string(),
tier,
}
}
#[must_use]
pub fn transfer_cost(&self) -> TransferCost {
self.tier.transfer_cost()
}
#[must_use]
pub fn probe_gpu_links() -> Vec<PcieLinkInfo> {
PcieLinkInfo::probe_all_gpus()
}
fn any_shared_numa(links: &[PcieLinkInfo]) -> bool {
if links.len() < 2 {
return false;
}
for (i, a) in links.iter().enumerate() {
for b in &links[i + 1..] {
if let (Some(na), Some(nb)) = (a.numa_node, b.numa_node)
&& na == nb
{
return true;
}
}
}
false
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_transfer_cost_estimated_us() {
let cost = TransferCost {
latency_us: 5.0,
bandwidth_gbps: 31.5,
};
let us = cost.estimated_us(1_000_000);
assert!(us > 5.0);
assert!(us < 100.0);
}
#[test]
fn test_bandwidth_tier_detect_additional_adapters() {
assert_eq!(
BandwidthTier::detect_from_adapter_name("NVIDIA H200"),
BandwidthTier::HighBandwidthInterconnect
);
assert_eq!(
BandwidthTier::detect_from_adapter_name("NVIDIA B100"),
BandwidthTier::PciE5x16
);
assert_eq!(
BandwidthTier::detect_from_adapter_name("SwiftShader"),
BandwidthTier::SharedMemory
);
assert_eq!(
BandwidthTier::detect_from_adapter_name("Intel Arc A770"),
BandwidthTier::PciE4x16
);
assert_eq!(
BandwidthTier::detect_from_adapter_name("AMD MI250"),
BandwidthTier::HighBandwidthInterconnect
);
}
#[test]
fn test_bandwidth_tier_latency() {
assert!((BandwidthTier::SharedMemory.latency_us() - 0.1).abs() < 0.01);
assert!((BandwidthTier::HighBandwidthInterconnect.latency_us() - 1.0).abs() < 0.01);
assert!((BandwidthTier::PciE4x16.latency_us() - PCIE_DMA_LATENCY_US).abs() < 0.01);
}
#[test]
fn test_mixed_substrate_gpu_to_npu() {
let sub = mixed_substrate_with_tier(
100_000.0,
1_048_576,
HardwareType::GPU,
HardwareType::NPU,
BandwidthTier::PciE4x16,
);
assert_eq!(sub, MixedSubstrate::GpuToNpu);
}
#[test]
fn test_mixed_substrate_npu_to_gpu() {
let sub = mixed_substrate_with_tier(
100_000.0,
1_048_576,
HardwareType::NPU,
HardwareType::GPU,
BandwidthTier::PciE4x16,
);
assert_eq!(sub, MixedSubstrate::NpuToGpu);
}
#[test]
fn test_mixed_substrate_unknown_hardware_type() {
let sub = mixed_substrate_with_tier(
100.0,
1024,
HardwareType::Custom,
HardwareType::Custom,
BandwidthTier::PciE4x16,
);
assert_eq!(sub, MixedSubstrate::CpuOnly);
}
#[test]
fn test_mixed_substrate_same_gpu() {
let sub = mixed_substrate_with_tier(
100.0,
1024,
HardwareType::GPU,
HardwareType::GPU,
BandwidthTier::PciE4x16,
);
assert_eq!(sub, MixedSubstrate::GpuOnly);
}
#[test]
fn test_mixed_substrate_same_cpu() {
let sub = mixed_substrate_with_tier(
100.0,
1024,
HardwareType::CPU,
HardwareType::CPU,
BandwidthTier::PciE3x16,
);
assert_eq!(sub, MixedSubstrate::CpuOnly);
}
#[test]
fn test_mixed_substrate_same_npu() {
let sub = mixed_substrate_with_tier(
100.0,
1024,
HardwareType::NPU,
HardwareType::NPU,
BandwidthTier::PciE4x16,
);
assert_eq!(sub, MixedSubstrate::NpuOnly);
}
#[test]
fn test_mixed_substrate_gpu_to_cpu() {
let sub = mixed_substrate_with_tier(
100_000.0,
1_048_576,
HardwareType::GPU,
HardwareType::CPU,
BandwidthTier::PciE4x16,
);
assert_eq!(sub, MixedSubstrate::GpuToCpu);
}
#[test]
fn test_mixed_substrate_cpu_to_gpu() {
let sub = mixed_substrate_with_tier(
100_000.0,
1_048_576,
HardwareType::CPU,
HardwareType::GPU,
BandwidthTier::PciE4x16,
);
assert_eq!(sub, MixedSubstrate::CpuToGpu);
}
#[test]
fn test_mixed_substrate_transfer_cost_dominates() {
let sub = mixed_substrate_with_tier(
1.0,
1_000_000_000,
HardwareType::CPU,
HardwareType::GPU,
BandwidthTier::PciE3x16,
);
assert_eq!(sub, MixedSubstrate::CpuOnly);
}
#[test]
fn test_mixed_substrate_default_tier() {
let sub = mixed_substrate(100_000.0, 1024, HardwareType::GPU, HardwareType::GPU);
assert_eq!(sub, MixedSubstrate::GpuOnly);
}
#[test]
fn test_bandwidth_tier_bandwidth_values() {
assert!((BandwidthTier::PciE3x16.bandwidth_gbps() - 15.75).abs() < 0.01);
assert!((BandwidthTier::PciE4x16.bandwidth_gbps() - 31.5).abs() < 0.01);
assert!((BandwidthTier::PciE5x16.bandwidth_gbps() - 63.0).abs() < 0.01);
assert!((BandwidthTier::HighBandwidthInterconnect.bandwidth_gbps() - 300.0).abs() < 0.01);
assert!((BandwidthTier::SharedMemory.bandwidth_gbps() - 1000.0).abs() < 0.01);
assert!((BandwidthTier::Unknown.bandwidth_gbps() - 15.75).abs() < 0.01);
}
#[test]
fn test_bandwidth_tier_transfer_cost() {
let cost = BandwidthTier::PciE4x16.transfer_cost();
assert!((cost.latency_us - PCIE_DMA_LATENCY_US).abs() < 0.01);
assert!((cost.bandwidth_gbps - 31.5).abs() < 0.01);
}
#[test]
fn test_bandwidth_tier_detect_pcie3_adapters() {
assert_eq!(
BandwidthTier::detect_from_adapter_name("NVIDIA TITAN V"),
BandwidthTier::PciE3x16
);
assert_eq!(
BandwidthTier::detect_from_adapter_name("Tesla V100"),
BandwidthTier::PciE3x16
);
assert_eq!(
BandwidthTier::detect_from_adapter_name("GeForce RTX 2080"),
BandwidthTier::PciE3x16
);
}
#[test]
fn test_bandwidth_tier_detect_unknown() {
assert_eq!(
BandwidthTier::detect_from_adapter_name("SomeUnknownGPU"),
BandwidthTier::Unknown
);
}
#[test]
fn test_pcie_link_info_bandwidth_all_gens() {
let make_link = |pcie_gen: u8, width: u8| PcieLinkInfo {
bdf_address: String::new(),
pcie_gen,
lane_width: width,
numa_node: None,
vendor_id: 0,
};
assert!((make_link(1, 16).bandwidth_gbps() - 4.0).abs() < 0.1);
assert!((make_link(2, 16).bandwidth_gbps() - 8.0).abs() < 0.1);
assert!((make_link(3, 16).bandwidth_gbps() - 15.76).abs() < 0.1);
assert!((make_link(4, 16).bandwidth_gbps() - 31.504).abs() < 0.1);
assert!((make_link(5, 16).bandwidth_gbps() - 63.008).abs() < 0.1);
assert!((make_link(6, 16).bandwidth_gbps() - 121.008).abs() < 0.1);
assert!(make_link(0, 16).bandwidth_gbps() > 0.0);
}
#[test]
fn test_pcie_link_info_bandwidth_tier() {
let make = |pcie_gen: u8, width: u8| PcieLinkInfo {
bdf_address: String::new(),
pcie_gen,
lane_width: width,
numa_node: None,
vendor_id: 0,
};
assert_eq!(make(5, 16).bandwidth_tier(), BandwidthTier::PciE5x16);
assert_eq!(make(4, 16).bandwidth_tier(), BandwidthTier::PciE4x16);
assert_eq!(make(3, 16).bandwidth_tier(), BandwidthTier::PciE3x16);
assert_eq!(make(2, 16).bandwidth_tier(), BandwidthTier::Unknown);
}
#[test]
fn test_pcie_bridge_any_shared_numa_none() {
let links: Vec<PcieLinkInfo> = vec![];
assert!(!PcieBridge::any_shared_numa(&links));
}
#[test]
fn test_pcie_bridge_any_shared_numa_single() {
let links = vec![PcieLinkInfo {
bdf_address: "0000:01:00.0".into(),
pcie_gen: 4,
lane_width: 16,
numa_node: Some(0),
vendor_id: 0x10de,
}];
assert!(!PcieBridge::any_shared_numa(&links));
}
#[test]
fn test_pcie_bridge_any_shared_numa_match() {
let links = vec![
PcieLinkInfo {
bdf_address: "0000:01:00.0".into(),
pcie_gen: 4,
lane_width: 16,
numa_node: Some(0),
vendor_id: 0x10de,
},
PcieLinkInfo {
bdf_address: "0000:02:00.0".into(),
pcie_gen: 4,
lane_width: 16,
numa_node: Some(0),
vendor_id: 0x10de,
},
];
assert!(PcieBridge::any_shared_numa(&links));
}
#[test]
fn test_pcie_bridge_any_shared_numa_no_match() {
let links = vec![
PcieLinkInfo {
bdf_address: "0000:01:00.0".into(),
pcie_gen: 4,
lane_width: 16,
numa_node: Some(0),
vendor_id: 0x10de,
},
PcieLinkInfo {
bdf_address: "0000:41:00.0".into(),
pcie_gen: 4,
lane_width: 16,
numa_node: Some(1),
vendor_id: 0x10de,
},
];
assert!(!PcieBridge::any_shared_numa(&links));
}
#[test]
fn test_transfer_cost_zero_bytes() {
let cost = TransferCost {
latency_us: 5.0,
bandwidth_gbps: 31.5,
};
assert!((cost.estimated_us(0) - 5.0).abs() < 1e-10);
}
}