use ironaccelerator_core::{
BackendKind, BackendRegistry, CapabilityFlags, DeviceDescriptor, Result,
};
pub struct Runtime {
registry: BackendRegistry,
}
impl Runtime {
pub fn new() -> Self {
let mut registry = BackendRegistry::new();
#[cfg(feature = "rocm")]
ironaccelerator_rocm::register(&mut registry);
#[cfg(feature = "metal")]
ironaccelerator_metal::register(&mut registry);
#[cfg(feature = "qnn")]
ironaccelerator_qnn::register(&mut registry);
#[cfg(feature = "vulkan")]
ironaccelerator_vulkan::register(&mut registry);
#[cfg(feature = "opengl")]
ironaccelerator_opengl::register(&mut registry);
#[cfg(feature = "dx12")]
ironaccelerator_dx12::register(&mut registry);
#[cfg(feature = "webgpu")]
ironaccelerator_webgpu::register(&mut registry);
#[cfg(feature = "tpu")]
ironaccelerator_tpu::register(&mut registry);
#[cfg(feature = "levelzero")]
ironaccelerator_levelzero::register(&mut registry);
#[cfg(feature = "neuron")]
ironaccelerator_neuron::register(&mut registry);
#[cfg(feature = "fpga")]
ironaccelerator_fpga::register(&mut registry);
Self { registry }
}
pub fn registry(&self) -> &BackendRegistry {
&self.registry
}
pub fn available_backends(&self) -> Vec<BackendKind> {
self.registry.available().map(|b| b.kind()).collect()
}
pub fn devices(&self) -> Vec<DeviceDescriptor> {
self.registry
.available()
.flat_map(|b| b.enumerate().unwrap_or_default())
.collect()
}
pub fn devices_with(&self, required: CapabilityFlags) -> Vec<DeviceDescriptor> {
self.devices()
.into_iter()
.filter(|d| d.capability.flags.contains(required))
.collect()
}
pub fn capabilities(
&self,
backend: BackendKind,
device: u32,
) -> Option<Result<CapabilityFlags>> {
self.registry
.get(backend)
.filter(|b| b.is_available())
.map(|b| b.capabilities(device))
}
}
impl Default for Runtime {
fn default() -> Self {
Self::new()
}
}
pub fn init() -> Runtime {
Runtime::new()
}