use crate::sched::call_site::Placement;
use crate::sched::notify_ring::{NotifyHub, NotifySendResult};
use crate::sched::plan::JobPlan;
pub fn join_hybrid<RA, RB, A, B>(plan: &JobPlan, cpu_work: A, gpu_work: B) -> (RA, RB)
where
A: FnOnce() -> RA,
B: FnOnce() -> RB + Send + 'static,
RA: 'static,
RB: Send + 'static,
{
let backend = plan.pick_backend();
let hub = NotifyHub::<std::thread::Result<RB>>::new(2, 1);
let tx_for_backend = hub.sender();
let rx = hub.register_consumer();
backend.dispatch_one(Box::new(move || {
let result =
std::panic::catch_unwind(std::panic::AssertUnwindSafe(gpu_work));
drop(tx_for_backend.send(result));
}));
let cpu_outcome =
std::panic::catch_unwind(std::panic::AssertUnwindSafe(cpu_work));
let gpu_outcome = rx.recv().expect("GPU half disconnected before sending");
match (cpu_outcome, gpu_outcome) {
(Ok(a), Ok(b)) => (a, b),
(Err(p), _) => std::panic::resume_unwind(p),
(_, Err(p)) => std::panic::resume_unwind(p),
}
}
fn run_on_backend<R, G>(plan: &JobPlan, work: G) -> (R, u64)
where
R: Send + 'static,
G: FnOnce() -> R + Send + 'static,
{
let backend = plan.pick_backend();
let hub = NotifyHub::<std::thread::Result<R>>::new(2, 1);
let tx = hub.sender();
let rx = hub.register_consumer();
let t0 = std::time::Instant::now();
backend.dispatch_one(Box::new(move || {
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(work));
drop(tx.send(result));
}));
let outcome = rx.recv().expect("backend half disconnected before sending");
let wall_ns = t0.elapsed().as_nanos() as u64;
match outcome {
Ok(r) => (r, wall_ns),
Err(p) => std::panic::resume_unwind(p),
}
}
#[track_caller]
pub fn hybrid_auto<R, C, G>(plan: &JobPlan, cpu_impl: C, gpu_impl: G) -> (R, Placement)
where
R: Send + 'static,
C: FnOnce() -> R,
G: FnOnce() -> R + Send + 'static,
{
let plan_owned = plan.with_site_if_none(crate::sched::call_site::caller_site());
let plan = &plan_owned;
let site = plan
.site
.expect("with_site_if_none attached a site above")
.get();
let batch = plan.batch_size;
match site.choose_placement(batch) {
Placement::Cpu => {
let t0 = std::time::Instant::now();
let r = cpu_impl();
site.record_placement(batch, Some(t0.elapsed().as_nanos() as u64), None);
(r, Placement::Cpu)
}
Placement::Backend => {
let (r, wall_ns) = run_on_backend(plan, gpu_impl);
site.record_placement(batch, None, Some(wall_ns));
(r, Placement::Backend)
}
Placement::Race => {
let ((cpu_r, cpu_ns), (_gpu_r, gpu_ns)) = join_hybrid(
plan,
|| {
let t0 = std::time::Instant::now();
let r = cpu_impl();
(r, t0.elapsed().as_nanos() as u64)
},
move || {
let t0 = std::time::Instant::now();
let r = gpu_impl();
(r, t0.elapsed().as_nanos() as u64)
},
);
site.record_placement(batch, Some(cpu_ns), Some(gpu_ns));
(cpu_r, Placement::Race)
}
}
}
#[derive(Debug, Clone, Copy)]
pub struct SplitReport {
pub cpu_items: usize,
pub backend_items: usize,
pub cpu_ns: u64,
pub backend_ns: u64,
pub cpu_share_per_mille: u32,
}
#[track_caller]
pub fn hybrid_auto_split<T, CF, GF>(
plan: &JobPlan,
items: &mut [T],
cpu_fn: CF,
gpu_fn: GF,
) -> SplitReport
where
T: Send + 'static,
CF: FnOnce(&mut [T]),
GF: FnOnce(&mut [T]) + Send + 'static,
{
let plan_owned = plan.with_site_if_none(crate::sched::call_site::caller_site());
let plan = &plan_owned;
let site = plan
.site
.expect("with_site_if_none attached a site above")
.get();
let n = items.len();
let share = site.split_cpu_share_per_mille();
let mid = ((n as u64 * share as u64) / 1000) as usize;
let mid = mid.clamp(usize::from(n > 1), n.saturating_sub(usize::from(n > 1)));
let (cpu_part, backend_part) = items.split_at_mut(mid);
let cpu_items = cpu_part.len();
let backend_items = backend_part.len();
let backend_addr = backend_part.as_mut_ptr() as usize;
let backend_len = backend_part.len();
let (cpu_ns_out, backend_ns_out) = join_hybrid(
plan,
|| {
let t0 = std::time::Instant::now();
if !cpu_part.is_empty() {
cpu_fn(cpu_part);
}
t0.elapsed().as_nanos() as u64
},
move || {
let t0 = std::time::Instant::now();
if backend_len > 0 {
let slice: &mut [T] = unsafe {
std::slice::from_raw_parts_mut(backend_addr as *mut T, backend_len)
};
gpu_fn(slice);
}
t0.elapsed().as_nanos() as u64
},
);
site.record_split(cpu_items, cpu_ns_out, backend_items, backend_ns_out);
SplitReport {
cpu_items,
backend_items,
cpu_ns: cpu_ns_out,
backend_ns: backend_ns_out,
cpu_share_per_mille: share,
}
}
#[track_caller]
pub fn hybrid_auto_split_ranges<CF, GF>(
plan: &JobPlan,
n: usize,
cpu_fn: CF,
gpu_fn: GF,
) -> SplitReport
where
CF: FnOnce(std::ops::Range<usize>),
GF: FnOnce(std::ops::Range<usize>) + Send + 'static,
{
let plan_owned = plan.with_site_if_none(crate::sched::call_site::caller_site());
let plan = &plan_owned;
let site = plan
.site
.expect("with_site_if_none attached a site above")
.get();
let n_key = n.min(u32::MAX as usize) as u32;
let share = site.split_cpu_share_per_mille_for(n_key);
let mid = ((n as u64 * share as u64) / 1000) as usize;
let mid = mid.clamp(usize::from(n > 1), n.saturating_sub(usize::from(n > 1)));
let cpu_items = mid;
let backend_items = n - mid;
let (cpu_ns_out, backend_ns_out) = join_hybrid(
plan,
|| {
let t0 = std::time::Instant::now();
if cpu_items > 0 {
cpu_fn(0..mid);
}
t0.elapsed().as_nanos() as u64
},
move || {
let t0 = std::time::Instant::now();
if backend_items > 0 {
gpu_fn(mid..n);
}
t0.elapsed().as_nanos() as u64
},
);
site.record_split_for(n_key, cpu_items, cpu_ns_out, backend_items, backend_ns_out);
SplitReport {
cpu_items,
backend_items,
cpu_ns: cpu_ns_out,
backend_ns: backend_ns_out,
cpu_share_per_mille: share,
}
}
pub fn hybrid_pipeline<I, F1, F2, F3, A, B, R>(
_plan: &JobPlan,
inputs: I,
pre_cpu: F1,
gpu: F2,
post_cpu: F3,
) -> Vec<R>
where
I: IntoIterator + Send + 'static,
I::Item: Send + 'static,
F1: FnMut(I::Item) -> A + Send + 'static,
F2: FnMut(A) -> B + Send + 'static,
F3: FnMut(B) -> R + Send + 'static,
A: Send + 'static,
B: Send + 'static,
R: Send + 'static,
{
let hub_ab = NotifyHub::<A>::new(2, 1);
let hub_bc = NotifyHub::<B>::new(2, 1);
let hub_out = NotifyHub::<R>::new(2, 1);
let tx_ab = hub_ab.sender();
let tx_bc = hub_bc.sender();
let tx_out = hub_out.sender();
let hub_ab_for_gpu = hub_ab.clone();
let hub_bc_for_post = hub_bc.clone();
let hub_ab_shutdown = hub_ab.clone();
let hub_bc_shutdown = hub_bc.clone();
let hub_out_shutdown = hub_out.clone();
let pre_handle = std::thread::Builder::new()
.name("flynnel-hybrid-pre".into())
.spawn({
let mut pre_cpu = pre_cpu;
move || {
let _ab_shutdown = hub_ab_shutdown.shutdown_on_drop();
for item in inputs.into_iter() {
let a = pre_cpu(item);
if !matches!(tx_ab.send(a), NotifySendResult::Ok) {
break;
}
}
}
})
.expect("spawn flynnel-hybrid-pre");
let gpu_handle = std::thread::Builder::new()
.name("flynnel-hybrid-gpu".into())
.spawn({
let mut gpu = gpu;
move || {
let _bc_shutdown = hub_bc_shutdown.shutdown_on_drop();
let rx_ab = hub_ab_for_gpu.register_consumer();
while let Some(a) = rx_ab.recv() {
let b = gpu(a);
if !matches!(tx_bc.send(b), NotifySendResult::Ok) {
break;
}
}
}
})
.expect("spawn flynnel-hybrid-gpu");
let post_handle = std::thread::Builder::new()
.name("flynnel-hybrid-post".into())
.spawn({
let mut post_cpu = post_cpu;
move || {
let _out_shutdown = hub_out_shutdown.shutdown_on_drop();
let rx_bc = hub_bc_for_post.register_consumer();
while let Some(b) = rx_bc.recv() {
let r = post_cpu(b);
if !matches!(tx_out.send(r), NotifySendResult::Ok) {
break;
}
}
}
})
.expect("spawn flynnel-hybrid-post");
let rx_out = hub_out.register_consumer();
let mut results = Vec::new();
while let Some(r) = rx_out.recv() {
results.push(r);
}
pre_handle
.join()
.unwrap_or_else(|p| std::panic::resume_unwind(p));
gpu_handle
.join()
.unwrap_or_else(|p| std::panic::resume_unwind(p));
post_handle
.join()
.unwrap_or_else(|p| std::panic::resume_unwind(p));
results
}
#[cfg(test)]
mod tests {
use super::*;
use crate::backend::{
Backend, BackendCapabilities, DispatchBackend, register_backend,
};
use std::sync::Arc;
use std::sync::atomic::{AtomicU32, Ordering};
struct ThreadStub;
impl DispatchBackend for ThreadStub {
fn id(&self) -> Backend {
Backend::Custom(424242)
}
fn capabilities(&self) -> BackendCapabilities {
BackendCapabilities {
simt_width: 64,
max_threads_in_flight: 8192,
launch_latency_ns: 5000,
h2d_bw_bytes_per_sec: 10_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>) {
std::thread::spawn(work);
}
}
fn install_stub() {
register_backend(Arc::new(ThreadStub));
}
#[test]
fn hybrid_returns_both_results_in_caller_order() {
install_stub();
let plan = JobPlan::new(8, 64).with_backend(Backend::Custom(424242));
let (a, b) = join_hybrid(&plan, || 7u32, || 11u32);
assert_eq!(a, 7);
assert_eq!(b, 11);
}
#[test]
fn hybrid_runs_both_halves_to_completion() {
install_stub();
let plan = JobPlan::new(8, 64).with_backend(Backend::Custom(424242));
let cpu_seen = Arc::new(AtomicU32::new(0));
let gpu_seen = Arc::new(AtomicU32::new(0));
let c = Arc::clone(&cpu_seen);
let g = Arc::clone(&gpu_seen);
let (cr, gr) = join_hybrid(
&plan,
move || {
c.store(1, Ordering::SeqCst);
100u32
},
move || {
g.store(1, Ordering::SeqCst);
200u32
},
);
assert_eq!(cr, 100);
assert_eq!(gr, 200);
assert_eq!(cpu_seen.load(Ordering::SeqCst), 1);
assert_eq!(gpu_seen.load(Ordering::SeqCst), 1);
}
#[test]
fn hybrid_with_no_hint_falls_back_to_cpu_backend() {
let plan = JobPlan::new(8, 64);
let (a, b) = join_hybrid(&plan, || 1u32 + 2, || 3u32 + 4);
assert_eq!(a, 3);
assert_eq!(b, 7);
}
#[test]
fn hybrid_with_unregistered_hint_falls_back_to_cpu() {
let plan = JobPlan::new(8, 64).with_backend(Backend::Custom(987_654_321));
let (a, b) = join_hybrid(&plan, || "left", || "right");
assert_eq!(a, "left");
assert_eq!(b, "right");
}
#[test]
#[cfg(panic = "unwind")]
fn hybrid_propagates_cpu_panic() {
install_stub();
let plan = JobPlan::new(8, 64).with_backend(Backend::Custom(424242));
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
join_hybrid::<u32, u32, _, _>(
&plan,
|| panic!("cpu side"),
|| 42u32,
);
}));
assert!(result.is_err());
}
#[test]
fn pipeline_emits_results_in_order() {
let plan = JobPlan::new(8, 64);
let out = hybrid_pipeline(
&plan,
0..8i32,
|seed| seed * 2,
|a| a + 100,
|b| b - 50,
);
let expected: Vec<i32> = (0..8).map(|i| i * 2 + 50).collect();
assert_eq!(out, expected);
}
#[test]
fn pipeline_handles_empty_input() {
let plan = JobPlan::new(8, 64);
let out: Vec<u32> = hybrid_pipeline(
&plan,
std::iter::empty::<u32>(),
|x| x,
|x| x,
|x| x,
);
assert!(out.is_empty());
}
#[test]
fn pipeline_actually_overlaps_stages() {
use std::time::{Duration, Instant};
const N: usize = 8;
const STAGE_MS: u64 = 30;
let plan = JobPlan::new(8, 64);
let t0 = Instant::now();
let out = hybrid_pipeline(
&plan,
(0..N).collect::<Vec<usize>>(),
|x| { std::thread::sleep(Duration::from_millis(STAGE_MS)); x },
|x| { std::thread::sleep(Duration::from_millis(STAGE_MS)); x },
|x| { std::thread::sleep(Duration::from_millis(STAGE_MS)); x },
);
let elapsed = t0.elapsed();
assert_eq!(out.len(), N);
let pipelined_ms = (N as u64 + 2) * STAGE_MS;
assert!(
elapsed.as_millis() < (pipelined_ms * 2) as u128,
"pipeline did not overlap: {} ms exceeds 2x ideal {} ms",
elapsed.as_millis(),
pipelined_ms
);
let sequential_ms = 3 * N as u64 * STAGE_MS;
assert!(
elapsed.as_millis() < sequential_ms as u128,
"pipeline took {} ms, not faster than sequential {} ms",
elapsed.as_millis(),
sequential_ms
);
}
#[test]
#[cfg(panic = "unwind")]
fn pipeline_propagates_stage_panic() {
let plan = JobPlan::new(8, 64);
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
hybrid_pipeline::<_, _, _, _, i32, i32, i32>(
&plan,
0..4i32,
|x| x + 1,
|x| {
if x == 2 {
panic!("gpu stage boom");
}
x + 1
},
|x| x + 1,
)
}));
assert!(result.is_err());
}
}