use crate::device::device_types::Device;
const FALLBACK_SYSTEM_MEMORY_GB_64BIT: usize = 8;
const FALLBACK_SYSTEM_MEMORY_GB_32BIT: usize = 2;
#[derive(Debug, Clone)]
pub struct DeviceInfo {
pub device: Device,
pub name: String,
pub available: bool,
pub capabilities: Vec<Capability>,
pub memory_gb: usize,
pub compute_units: usize,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Capability {
Compute,
WGSL,
ParallelExecution,
SparseEvents,
LowPower,
MatrixOps,
Memory,
AutoSelection,
}
#[must_use]
pub fn is_gpu_available() -> bool {
true
}
#[must_use]
pub fn is_npu_available() -> bool {
if (0..16).any(|i| std::path::Path::new(&format!("/dev/akida{i}")).exists()) {
return true;
}
let iommu_groups = std::path::Path::new("/sys/kernel/iommu_groups");
if iommu_groups.exists()
&& let Ok(entries) = std::fs::read_dir(iommu_groups)
{
for entry in entries.flatten() {
let devices_dir = entry.path().join("devices");
if let Ok(devices) = std::fs::read_dir(devices_dir) {
for dev in devices.flatten() {
let vendor_path = dev.path().join("vendor");
if let Ok(vendor) = std::fs::read_to_string(vendor_path) {
if vendor.trim() == "0x1e7c" {
return true;
}
}
}
}
}
}
false
}
#[must_use]
pub fn estimate_system_memory() -> usize {
detect_system_memory_gb().unwrap_or(if cfg!(target_pointer_width = "64") {
FALLBACK_SYSTEM_MEMORY_GB_64BIT
} else {
FALLBACK_SYSTEM_MEMORY_GB_32BIT
})
}
#[must_use]
pub fn detect_system_memory_bytes() -> Option<u64> {
#[cfg(target_os = "linux")]
{
detect_memory_linux()
}
#[cfg(target_os = "macos")]
{
detect_memory_macos()
}
#[cfg(not(any(target_os = "linux", target_os = "macos")))]
{
None
}
}
fn detect_system_memory_gb() -> Option<usize> {
detect_system_memory_bytes().map(|bytes| (bytes / (1024 * 1024 * 1024)) as usize)
}
#[cfg(target_os = "linux")]
fn detect_memory_linux() -> Option<u64> {
let contents = std::fs::read_to_string("/proc/meminfo").ok()?;
for line in contents.lines() {
if let Some(rest) = line.strip_prefix("MemTotal:") {
let kb_str = rest.trim().strip_suffix("kB")?.trim();
let kb: u64 = kb_str.parse().ok()?;
return Some(kb * 1024);
}
}
None
}
#[cfg(target_os = "macos")]
fn detect_memory_macos() -> Option<u64> {
let output = std::process::Command::new("sysctl")
.arg("-n")
.arg("hw.memsize")
.output()
.ok()?;
if !output.status.success() {
return None;
}
let s = String::from_utf8_lossy(&output.stdout);
s.trim().parse::<u64>().ok()
}
#[must_use]
pub fn build_device_info(device: Device) -> DeviceInfo {
match device {
Device::CPU => DeviceInfo {
device,
name: "CPU".to_string(),
available: true,
capabilities: vec![Capability::Compute, Capability::Memory],
memory_gb: estimate_system_memory(),
compute_units: std::thread::available_parallelism().map_or(4, std::num::NonZero::get),
},
Device::GPU => DeviceInfo {
device,
name: "GPU (wgpu)".to_string(),
available: is_gpu_available(),
capabilities: vec![
Capability::Compute,
Capability::WGSL,
Capability::ParallelExecution,
],
memory_gb: 0,
compute_units: 0,
},
Device::NPU => DeviceInfo {
device,
name: "NPU (Akida)".to_string(),
available: is_npu_available(),
capabilities: vec![
Capability::Compute,
Capability::SparseEvents,
Capability::LowPower,
],
memory_gb: 0,
compute_units: 0,
},
Device::TPU => DeviceInfo {
device,
name: "TPU".to_string(),
available: false,
capabilities: vec![Capability::Compute, Capability::MatrixOps],
memory_gb: 0,
compute_units: 0,
},
Device::Sovereign => DeviceInfo {
device,
name: "Sovereign (IPC: shader.compile primal + compute.dispatch primal)".to_string(),
available: is_sovereign_available(),
capabilities: vec![
Capability::Compute,
Capability::WGSL,
Capability::ParallelExecution,
],
memory_gb: 0,
compute_units: 0,
},
Device::Auto => DeviceInfo {
device,
name: "Auto (smart selection)".to_string(),
available: true,
capabilities: vec![Capability::AutoSelection],
memory_gb: 0,
compute_units: 0,
},
}
}
fn is_sovereign_available() -> bool {
#[cfg(feature = "sovereign-dispatch")]
{
crate::device::sovereign_device::SovereignDevice::with_auto_device()
.is_ok_and(|d| d.has_dispatch())
}
#[cfg(not(feature = "sovereign-dispatch"))]
false
}