#![allow(clippy::missing_errors_doc)]
use core::sync::atomic::{AtomicU32, Ordering};
use crate::backend::{Backend, BackendRef, backend_by_id, cpu_backend};
const fn encode_backend(b: Backend) -> u32 {
match b {
Backend::Cpu => 0u32,
Backend::Cuda { device_id } => (1u32 << 24) | (device_id & 0x00FF_FFFF),
Backend::Rocm { device_id } => (2u32 << 24) | (device_id & 0x00FF_FFFF),
Backend::Metal { device_id } => (3u32 << 24) | (device_id & 0x00FF_FFFF),
Backend::Tpu { device_id } => (4u32 << 24) | (device_id & 0x00FF_FFFF),
Backend::Ane => 5u32 << 24,
Backend::Wasm { device_id } => (6u32 << 24) | (device_id & 0x00FF_FFFF),
Backend::SharedMemoryWorker { backend_id } => {
(7u32 << 24) | (backend_id & 0x00FF_FFFF)
}
Backend::Custom(id) => (8u32 << 24) | (id & 0x00FF_FFFF),
}
}
fn decode_backend(tag: u32) -> Backend {
let variant = (tag >> 24) & 0xFF;
let device_id = tag & 0x00FF_FFFF;
match variant {
0 => Backend::Cpu,
1 => Backend::Cuda { device_id },
2 => Backend::Rocm { device_id },
3 => Backend::Metal { device_id },
4 => Backend::Tpu { device_id },
5 => Backend::Ane,
6 => Backend::Wasm { device_id },
7 => Backend::SharedMemoryWorker { backend_id: device_id },
_ => Backend::Custom(device_id),
}
}
static ACTIVE_BACKEND_TAG: AtomicU32 = AtomicU32::new(0);
#[unsafe(no_mangle)]
pub static __flynnel_marker_adaptive_backend: u8 = 0;
#[inline]
pub fn active_backend_id() -> Backend {
decode_backend(ACTIVE_BACKEND_TAG.load(Ordering::Acquire))
}
pub fn resolve_active_backend() -> (BackendRef, bool) {
let active = active_backend_id();
match backend_by_id(&active) {
Some(b) => (b, false),
None => {
core::hint::cold_path();
(cpu_backend(), true)
}
}
}
#[inline]
pub fn migrate_backend(backend: Backend) {
ACTIVE_BACKEND_TAG.store(encode_backend(backend), Ordering::Release);
}
#[cfg(test)]
mod tests {
use super::*;
fn restore_default() {
migrate_backend(Backend::Cpu);
}
struct TestGuard;
impl TestGuard {
fn new() -> Self {
restore_default();
Self
}
}
impl Drop for TestGuard {
fn drop(&mut self) {
restore_default();
}
}
#[test]
fn encode_decode_round_trip_all_variants() {
let cases = [
Backend::Cpu,
Backend::Cuda { device_id: 0 },
Backend::Cuda { device_id: 7 },
Backend::Rocm { device_id: 1 },
Backend::Metal { device_id: 2 },
Backend::Tpu { device_id: 3 },
Backend::Ane,
Backend::Wasm { device_id: 4 },
Backend::SharedMemoryWorker { backend_id: 5 },
Backend::Custom(12345),
];
for b in cases {
let tag = encode_backend(b);
let back = decode_backend(tag);
assert_eq!(b, back, "round trip failed for {b:?} (tag={tag:#x})");
}
}
#[test]
fn the_global_tag_defaults_migrates_resolves_and_falls_back() {
let _g = TestGuard::new();
assert_eq!(active_backend_id(), Backend::Cpu);
migrate_backend(Backend::Cuda { device_id: 0 });
assert_eq!(active_backend_id(), Backend::Cuda { device_id: 0 });
migrate_backend(Backend::Tpu { device_id: 3 });
assert_eq!(active_backend_id(), Backend::Tpu { device_id: 3 });
migrate_backend(Backend::Cpu);
assert_eq!(active_backend_id(), Backend::Cpu);
migrate_backend(Backend::Custom(0x00ABCDEF));
let (resolved, fell_back) = resolve_active_backend();
assert!(fell_back, "should fall back to CPU when Custom unregistered");
assert_eq!(resolved.id(), Backend::Cpu);
migrate_backend(Backend::Cpu);
let (resolved, fell_back) = resolve_active_backend();
assert!(!fell_back);
assert_eq!(resolved.id(), Backend::Cpu);
}
}