pub trait MatrixModeBackend {
type Config;
type Context;
unsafe fn enter(config: &Self::Config) -> Self::Context;
unsafe fn exit(ctx: Self::Context);
}
struct RegionGuard<B: MatrixModeBackend> {
ctx: Option<B::Context>,
}
impl<B: MatrixModeBackend> Drop for RegionGuard<B> {
fn drop(&mut self) {
if let Some(ctx) = self.ctx.take() {
unsafe { B::exit(ctx) };
}
}
}
pub fn run_in_region<B, F, R>(config: &B::Config, op: F) -> R
where
B: MatrixModeBackend,
F: FnOnce(&mut B::Context) -> R,
{
let mut guard = RegionGuard::<B> {
ctx: Some(unsafe { B::enter(config) }),
};
let result = op(guard
.ctx
.as_mut()
.expect("ctx populated in RegionGuard init"));
drop(guard);
result
}
#[derive(Debug, Copy, Clone, Default)]
pub struct ScalarFallback;
#[derive(Debug)]
pub struct ScalarContext;
#[derive(Debug, Copy, Clone, Default)]
pub struct ScalarConfig;
impl MatrixModeBackend for ScalarFallback {
type Config = ScalarConfig;
type Context = ScalarContext;
unsafe fn enter(_config: &Self::Config) -> Self::Context {
ScalarContext
}
unsafe fn exit(_ctx: Self::Context) {
}
}
#[cfg(test)]
mod tests {
use super::*;
use core::sync::atomic::{AtomicU32, Ordering};
use std::sync::Arc;
struct CountBackend;
impl MatrixModeBackend for CountBackend {
type Config = Arc<AtomicU32>; type Context = (Arc<AtomicU32>, Arc<AtomicU32>);
unsafe fn enter(config: &Self::Config) -> Self::Context {
config.fetch_add(1, Ordering::SeqCst);
(Arc::clone(config), Arc::new(AtomicU32::new(0)))
}
unsafe fn exit(ctx: Self::Context) {
ctx.1.fetch_add(1, Ordering::SeqCst);
}
}
#[test]
fn scalar_fallback_runs_body() {
let result = run_in_region::<ScalarFallback, _, _>(
&ScalarConfig,
|_ctx| 42u32,
);
assert_eq!(result, 42);
}
#[test]
fn enter_exit_paired_on_normal_return() {
let enter_ct = Arc::new(AtomicU32::new(0));
let exit_ct_outer = Arc::new(AtomicU32::new(0));
let exit_ct_clone = Arc::clone(&exit_ct_outer);
run_in_region::<CountBackend, _, _>(&enter_ct, |ctx| {
let _ = ctx;
exit_ct_clone.store(0, Ordering::SeqCst);
});
assert_eq!(enter_ct.load(Ordering::SeqCst), 1);
}
#[test]
fn enter_exit_paired_even_on_panic() {
let enter_ct = Arc::new(AtomicU32::new(0));
let result = std::panic::catch_unwind(|| {
run_in_region::<CountBackend, _, _>(&enter_ct, |_ctx| -> u32 {
panic!("intentional test panic inside mode region");
});
});
assert!(result.is_err(), "panic should propagate to caller");
assert_eq!(enter_ct.load(Ordering::SeqCst), 1,
"enter should have fired exactly once before the panic");
}
#[test]
fn scalar_fallback_is_default_constructible() {
let _: ScalarFallback = Default::default();
let _: ScalarConfig = Default::default();
}
#[test]
fn region_returns_op_result_unchanged() {
let v = run_in_region::<ScalarFallback, _, _>(
&ScalarConfig,
|_ctx| ("hello".to_string(), 99_i64, vec![1u8, 2, 3]),
);
assert_eq!(v.0, "hello");
assert_eq!(v.1, 99);
assert_eq!(v.2, vec![1, 2, 3]);
}
}