use core::sync::atomic::{AtomicPtr, Ordering};
use std::hash::{Hash, Hasher};
use std::sync::{Arc, OnceLock};
use crate::backend::{Backend, BackendRef, CpuBackend, DispatchBackend};
const SLOTS: usize = 64;
const MASK: usize = SLOTS - 1;
struct Entry {
id: Backend,
current: AtomicPtr<BackendRef>,
}
static TABLE: [AtomicPtr<Entry>; SLOTS] = [const { AtomicPtr::new(core::ptr::null_mut()) }; SLOTS];
static CPU_READY: OnceLock<()> = OnceLock::new();
fn key_of(id: &Backend) -> u64 {
let mut h = std::hash::DefaultHasher::new();
id.hash(&mut h);
h.finish()
}
fn find(id: &Backend) -> Option<&'static Entry> {
let mut idx = (key_of(id) as usize) & MASK;
for _ in 0..SLOTS {
let p = TABLE[idx].load(Ordering::Acquire);
if p.is_null() {
return None;
}
let entry = unsafe { &*p };
if entry.id == *id {
return Some(entry);
}
idx = (idx + 1) & MASK;
}
None
}
fn install(id: Backend, b: BackendRef) {
let fresh = Box::into_raw(Box::new(b));
if let Some(entry) = find(&id) {
entry.current.store(fresh, Ordering::Release);
return;
}
let mut prepared: Option<&'static Entry> = None;
let mut idx = (key_of(&id) as usize) & MASK;
for _ in 0..SLOTS {
let p = TABLE[idx].load(Ordering::Acquire);
if p.is_null() {
let entry = *prepared.get_or_insert_with(|| {
&*Box::leak(Box::new(Entry {
id,
current: AtomicPtr::new(fresh),
}))
});
let node = entry as *const Entry as *mut Entry;
match TABLE[idx].compare_exchange(
core::ptr::null_mut(),
node,
Ordering::AcqRel,
Ordering::Acquire,
) {
Ok(_) => return,
Err(taken) => {
let other = unsafe { &*taken };
if other.id == id {
other.current.store(fresh, Ordering::Release);
return;
}
}
}
} else {
let other = unsafe { &*p };
if other.id == id {
other.current.store(fresh, Ordering::Release);
return;
}
}
idx = (idx + 1) & MASK;
}
panic!("backend table full at {SLOTS} distinct ids; {id:?} could not be registered");
}
fn ensure_cpu() {
CPU_READY.get_or_init(|| {
let cpu: Arc<dyn DispatchBackend> = Arc::new(CpuBackend::new());
install(Backend::Cpu, cpu);
});
}
pub fn register_backend(b: BackendRef) {
ensure_cpu();
let id = b.id();
install(id, b);
}
pub fn backend_by_id(id: &Backend) -> Option<BackendRef> {
ensure_cpu();
let entry = find(id)?;
let p = entry.current.load(Ordering::Acquire);
Some(unsafe { &*p }.clone())
}
pub fn backends() -> Vec<BackendRef> {
ensure_cpu();
let mut out = Vec::new();
for slot in TABLE.iter() {
let p = slot.load(Ordering::Acquire);
if p.is_null() {
continue;
}
let entry = unsafe { &*p };
let current = entry.current.load(Ordering::Acquire);
out.push(unsafe { &*current }.clone());
}
out
}
pub fn cpu_backend() -> BackendRef {
backend_by_id(&Backend::Cpu).expect("CPU backend is auto-registered")
}
pub fn ensure_default_registered() -> bool {
backend_by_id(&Backend::Cpu).is_some()
}
#[cfg(test)]
mod tests {
use super::*;
use crate::backend::{BackendCapabilities, KernelArg, KernelHandle};
struct StubBackend(Backend);
impl DispatchBackend for StubBackend {
fn id(&self) -> Backend {
self.0
}
fn capabilities(&self) -> BackendCapabilities {
BackendCapabilities {
simt_width: 32,
max_threads_in_flight: 1024,
launch_latency_ns: 10_000,
h2d_bw_bytes_per_sec: 25_000_000_000,
}
}
fn dispatch_parallel_for(&self, _count: u32, _work: &(dyn Fn(u32) + Send + Sync)) {}
fn dispatch_one(&self, _work: Box<dyn FnOnce() + Send>) {}
}
#[test]
fn cpu_backend_auto_registers() {
ensure_default_registered();
let b = backend_by_id(&Backend::Cpu);
assert!(b.is_some());
}
#[test]
fn cpu_backend_helper_is_infallible() {
let cpu = cpu_backend();
assert_eq!(cpu.id(), Backend::Cpu);
}
#[test]
fn register_then_lookup_round_trip() {
let stub = Arc::new(StubBackend(Backend::Cuda { device_id: 7 }));
register_backend(stub);
let found = backend_by_id(&Backend::Cuda { device_id: 7 });
assert!(found.is_some());
assert_eq!(
found.unwrap().id(),
Backend::Cuda { device_id: 7 }
);
}
#[test]
fn distinct_device_ids_register_independently() {
let a = Arc::new(StubBackend(Backend::Cuda { device_id: 100 }));
let b = Arc::new(StubBackend(Backend::Cuda { device_id: 101 }));
register_backend(a);
register_backend(b);
assert!(backend_by_id(&Backend::Cuda { device_id: 100 }).is_some());
assert!(backend_by_id(&Backend::Cuda { device_id: 101 }).is_some());
}
#[test]
fn missing_backend_lookup_returns_none() {
let res = backend_by_id(&Backend::Custom(999_999));
assert!(res.is_none());
}
#[test]
fn backends_snapshot_includes_cpu() {
let all = backends();
assert!(all.iter().any(|b| b.id() == Backend::Cpu));
}
#[test]
fn register_replaces_existing_id() {
let a = Arc::new(StubBackend(Backend::Custom(7777)));
register_backend(a);
let b = Arc::new(StubBackend(Backend::Custom(7777)));
register_backend(b);
let found = backend_by_id(&Backend::Custom(7777)).unwrap();
assert_eq!(found.id(), Backend::Custom(7777));
}
#[test]
fn stub_backend_kernel_methods_default_to_not_supported() {
let stub = StubBackend(Backend::Cuda { device_id: 0 });
let result = stub.register_kernel("k", b"");
assert!(result.is_err());
let launch = stub.dispatch_kernel(KernelHandle(0), 1, &[KernelArg::I32(0)]);
assert!(launch.is_err());
}
}