use super::{emitter::PendingDelta, sizing::next_batch_size};
use crate::{cli::ComputeMode, render_core, render_core::hybrid::CalibrationOutcome};
use glam::Vec3;
use indicatrix::renderer::gpu_backend::GpuBackend;
use indicatrix_net::SceneState;
use std::{
sync::{
Arc, Mutex,
atomic::{AtomicBool, Ordering},
mpsc,
},
time::Instant,
};
pub(super) struct SharedState {
pub(super) pending_delta: PendingDelta,
pub(super) samples_done: u32,
pub(super) finished: bool,
pub(super) panicked: bool,
}
pub(super) struct TracerJob {
pub(super) scene: SceneState,
pub(super) first_sample: u32,
pub(super) samples: u32,
pub(super) threads: usize,
pub(super) compute_mode: ComputeMode,
}
pub(super) fn run_tracer(
job: &TracerJob,
gpu: &GpuBackend,
state: &Arc<Mutex<SharedState>>,
cancel: &Arc<AtomicBool>,
progress_tx: &mpsc::Sender<()>,
) {
let reporter = Reporter { state, progress_tx };
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
let mut produced: u32 = 0;
let mut batch_size: u32 = 1;
let mut gpu_frac: Option<f64> = if matches!(job.compute_mode, ComputeMode::Hybrid)
&& job.samples >= render_core::hybrid::HYBRID_MIN_SPP
{
calibrate_hybrid_split(gpu, job, &reporter, cancel, &mut produced)
} else {
None
};
while produced < job.samples {
if cancel.load(Ordering::Relaxed) {
break;
}
let this_batch = batch_size.min(job.samples - produced);
let batch_first = job.first_sample + produced;
let start = Instant::now();
let dispatch_outcome = if gpu_frac.is_some() {
render_core::hybrid::hybrid_trace(
gpu,
&job.scene,
batch_first,
this_batch,
job.threads,
&mut gpu_frac,
cancel,
)
} else {
render_core::trace_samples_with_gpu_cancellable(
gpu,
&job.scene,
batch_first,
this_batch,
job.threads,
cancel,
)
};
let Some(buf) = dispatch_outcome else {
break;
};
let elapsed = start.elapsed();
reporter.fold_and_notify(batch_first, this_batch, &buf, &mut produced);
batch_size = next_batch_size(batch_size, elapsed);
}
}));
let mut guard = state
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
guard.finished = true;
guard.panicked = result.is_err();
drop(guard);
let _ = progress_tx.send(());
}
struct Reporter<'a> {
state: &'a Arc<Mutex<SharedState>>,
progress_tx: &'a mpsc::Sender<()>,
}
impl Reporter<'_> {
fn fold_and_notify(
&self,
first_sample: u32,
consumed: u32,
contribution: &[Vec3],
produced: &mut u32,
) {
let mut guard = self
.state
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
guard
.pending_delta
.add(first_sample, consumed, contribution);
*produced += consumed;
guard.samples_done = *produced;
drop(guard);
let _ = self.progress_tx.send(());
}
}
fn calibrate_hybrid_split(
gpu: &GpuBackend,
job: &TracerJob,
reporter: &Reporter<'_>,
cancel: &AtomicBool,
produced: &mut u32,
) -> Option<f64> {
let pixel_count = job.scene.width as usize * job.scene.height as usize;
let mut calib_buf = vec![Vec3::ZERO; pixel_count];
match render_core::hybrid::calibrate(
gpu,
&job.scene,
job.first_sample,
job.samples,
job.threads,
&mut calib_buf,
cancel,
) {
CalibrationOutcome::Split(frac, consumed) => {
reporter.fold_and_notify(job.first_sample, consumed, &calib_buf, produced);
Some(frac)
}
CalibrationOutcome::GpuDeclined => None,
CalibrationOutcome::GpuDominates { gpu_share_frac } => {
tracing::info!(
gpu_share_pct = gpu_share_frac * 100.0,
"hybrid CPU+GPU split declined: measured GPU share exceeds the hybrid \
cutoff, so this job runs GPU-only (splitting measured slower on this \
hardware)"
);
None
}
CalibrationOutcome::Cancelled { consumed } => {
if consumed > 0 {
reporter.fold_and_notify(job.first_sample, consumed, &calib_buf, produced);
}
None
}
}
}