#![allow(clippy::missing_errors_doc)]
use std::collections::HashMap;
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Arc, Mutex};
use std::thread::JoinHandle;
use wasmtime::{Engine, Instance, Module, Store, Val};
use crate::backend::{
Backend, BackendCapabilities, BackendError, DispatchBackend, KernelArg, KernelHandle,
};
use crate::sched::notify_ring::{NotifyHub, NotifySender};
type WorkItem = Box<dyn FnOnce() + Send + 'static>;
struct KernelEntry {
store: Store<()>,
func: wasmtime::Func,
}
pub struct WasmBackend {
device_id: u32,
engine: Engine,
caps: BackendCapabilities,
next_handle: AtomicU64,
kernels: Mutex<HashMap<u64, Arc<Mutex<KernelEntry>>>>,
worker_hub: NotifyHub<WorkItem>,
worker_tx: NotifySender<WorkItem>,
worker_handle: Mutex<Option<JoinHandle<()>>>,
}
impl std::fmt::Debug for WasmBackend {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("WasmBackend")
.field("device_id", &self.device_id)
.finish()
}
}
impl WasmBackend {
pub fn new() -> Result<Self, BackendError> {
Self::with_device(0)
}
pub fn with_device(device_id: u32) -> Result<Self, BackendError> {
let engine = Engine::default();
const WASM_WORKER_RING_CAPACITY: usize = 1024;
let worker_hub = NotifyHub::<WorkItem>::new(WASM_WORKER_RING_CAPACITY, 1);
let worker_tx = worker_hub.sender();
let hub_for_worker = worker_hub.clone();
let worker_handle = std::thread::Builder::new()
.name(format!("flynnel-wasm-{device_id}"))
.spawn(move || {
let rx = hub_for_worker.register_consumer();
while let Some(work) = rx.recv() {
work();
}
})
.map_err(|_| BackendError::DeviceUnavailable(Backend::Wasm { device_id }))?;
Ok(Self {
device_id,
engine,
caps: probe_capabilities(),
next_handle: AtomicU64::new(1),
kernels: Mutex::new(HashMap::new()),
worker_hub,
worker_tx,
worker_handle: Mutex::new(Some(worker_handle)),
})
}
}
fn probe_capabilities() -> BackendCapabilities {
let threads = std::thread::available_parallelism()
.map(std::num::NonZeroUsize::get)
.unwrap_or(1) as u32;
BackendCapabilities {
simt_width: 1,
max_threads_in_flight: threads,
launch_latency_ns: 5_000,
h2d_bw_bytes_per_sec: 0,
}
}
impl DispatchBackend for WasmBackend {
fn id(&self) -> Backend {
Backend::Wasm { device_id: self.device_id }
}
fn capabilities(&self) -> BackendCapabilities {
self.caps
}
fn dispatch_parallel_for(
&self,
count: u32,
work: &(dyn Fn(u32) + Send + Sync),
) {
let plan = crate::sched::JobPlan::new(0, count);
let mut indices: Vec<u32> = (0..count).collect();
crate::sched::par_iter::for_each_chunk(
&plan,
indices.as_mut_slice(),
move |slice: &mut [u32]| {
for i in slice.iter() {
work(*i);
}
},
);
}
fn dispatch_one(&self, work: Box<dyn FnOnce() + Send>) {
drop(self.worker_tx.send(work));
}
fn register_kernel(
&self,
name: &str,
source: &[u8],
) -> Result<KernelHandle, BackendError> {
let module = Module::new(&self.engine, source).map_err(|e| {
BackendError::KernelCompile(format!("wasm module compile failed: {e}"))
})?;
let mut store: Store<()> = Store::new(&self.engine, ());
let instance = Instance::new(&mut store, &module, &[]).map_err(|e| {
BackendError::KernelCompile(format!(
"wasm instance create failed for kernel `{name}`: {e}"
))
})?;
let func = instance
.get_func(&mut store, name)
.ok_or_else(|| {
BackendError::KernelCompile(format!(
"wasm export `{name}` not found in module"
))
})?;
let handle_id = self.next_handle.fetch_add(1, Ordering::SeqCst);
let entry = KernelEntry { store, func };
let mut guard = self.kernels.lock().unwrap();
guard.insert(handle_id, Arc::new(Mutex::new(entry)));
Ok(KernelHandle(handle_id))
}
fn dispatch_kernel(
&self,
handle: KernelHandle,
_count: u32,
args: &[KernelArg<'_>],
) -> Result<(), BackendError> {
let mut vals: Vec<Val> = Vec::with_capacity(args.len());
for a in args {
match a {
KernelArg::I32(v) => vals.push(Val::I32(*v)),
KernelArg::I64(v) => vals.push(Val::I64(*v)),
KernelArg::U32(v) => vals.push(Val::I32(*v as i32)),
KernelArg::U64(v) => vals.push(Val::I64(*v as i64)),
KernelArg::F32(v) => vals.push(Val::F32(v.to_bits())),
KernelArg::F64(v) => vals.push(Val::F64(v.to_bits())),
KernelArg::DevicePtr(p) => vals.push(Val::I32(*p as i32)),
KernelArg::HostSlice(_) => {
return Err(BackendError::NotSupported);
}
}
}
let entry_arc = {
let guard = self.kernels.lock().unwrap();
guard
.get(&handle.0)
.cloned()
.ok_or_else(|| {
BackendError::Launch(format!(
"wasm kernel handle {} not registered",
handle.0
))
})?
};
let mut entry = entry_arc.lock().unwrap();
let func_ty = entry.func.ty(&entry.store);
let expected_params = func_ty.params().len();
if expected_params != vals.len() {
return Err(BackendError::Launch(format!(
"wasm kernel arg count mismatch: function expects {} \
params, caller provided {}",
expected_params,
vals.len(),
)));
}
let n_results = func_ty.results().len();
let mut results: Vec<Val> = (0..n_results).map(|_| Val::I32(0)).collect();
let KernelEntry { ref mut store, ref func } = *entry;
func.call(store, &vals, &mut results).map_err(|e| {
BackendError::Launch(format!("wasm kernel call failed: {e}"))
})?;
Ok(())
}
}
impl Drop for WasmBackend {
fn drop(&mut self) {
self.worker_hub.shutdown();
let mut handle_guard = self.worker_handle.lock().unwrap();
if let Some(handle) = handle_guard.take() {
handle.join().ok();
}
}
}
#[cfg(test)]
mod tests {
use super::*;
const ADD_WASM: &[u8] = &[
0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x01, 0x07, 0x01, 0x60, 0x02, 0x7f, 0x7f, 0x01, 0x7f,
0x03, 0x02, 0x01, 0x00,
0x07, 0x07, 0x01, 0x03, 0x61, 0x64, 0x64, 0x00, 0x00,
0x0a, 0x09, 0x01, 0x07, 0x00, 0x20, 0x00, 0x20, 0x01, 0x6a, 0x0b,
];
#[test]
fn wasm_backend_constructs() {
WasmBackend::new().expect("wasm backend should init");
}
#[test]
fn wasm_backend_reports_correct_id_and_caps() {
let b = WasmBackend::with_device(7).expect("init");
assert_eq!(b.id(), Backend::Wasm { device_id: 7 });
let caps = b.capabilities();
assert_eq!(caps.simt_width, 1);
assert!(caps.max_threads_in_flight >= 1);
}
#[test]
fn wasm_backend_dispatches_kernel_with_add_module() {
let b = WasmBackend::new().expect("init");
let handle = b
.register_kernel("add", ADD_WASM)
.expect("register `add` export");
b.dispatch_kernel(handle, 1, &[KernelArg::I32(3), KernelArg::I32(4)])
.expect("dispatch_kernel should succeed on valid args");
}
#[test]
fn wasm_backend_rejects_arity_mismatch() {
let b = WasmBackend::new().expect("init");
let handle = b.register_kernel("add", ADD_WASM).expect("register");
let err = b
.dispatch_kernel(handle, 1, &[KernelArg::I32(3)])
.expect_err("arity mismatch must error");
assert!(matches!(err, BackendError::Launch(_)));
}
#[test]
fn wasm_backend_register_kernel_with_missing_export_errors() {
let b = WasmBackend::new().expect("init");
let err = b
.register_kernel("does_not_exist", ADD_WASM)
.expect_err("missing export must error");
assert!(matches!(err, BackendError::KernelCompile(_)));
}
#[test]
fn wasm_backend_register_invalid_module_errors() {
let b = WasmBackend::new().expect("init");
let err = b
.register_kernel("x", b"not a wasm module")
.expect_err("invalid bytes must error");
assert!(matches!(err, BackendError::KernelCompile(_)));
}
#[test]
fn wasm_backend_host_slice_arg_returns_not_supported() {
let b = WasmBackend::new().expect("init");
let handle = b.register_kernel("add", ADD_WASM).expect("register");
let buf: [u8; 4] = [1, 2, 3, 4];
let err = b
.dispatch_kernel(handle, 1, &[KernelArg::HostSlice(&buf)])
.expect_err("HostSlice must be unsupported in reference impl");
assert!(matches!(err, BackendError::NotSupported));
}
}