use super::{
emitter::PendingDelta,
sizing::{next_batch_size, remember_converged_subbatch, seeded_batch_size},
};
use crate::{
cli::ComputeMode,
render_core,
render_core::hybrid::{CachedCalibration, JobKey},
};
use glam::Vec3;
use indicatrix::renderer::gpu_backend::GpuBackend;
use indicatrix_dispatch::SampleRange;
use indicatrix_net::{SceneState, messages::ErrorMsg};
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) failed: Option<ErrorMsg>,
pub(super) final_total: Option<Vec<Vec3>>,
pub(super) reclaimed_samples: u32,
}
impl SharedState {
pub(super) fn new(pixel_count: usize) -> Self {
Self {
pending_delta: PendingDelta::new(pixel_count),
samples_done: 0,
finished: false,
panicked: false,
failed: None,
final_total: None,
reclaimed_samples: 0,
}
}
}
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: &AtomicBool,
progress_tx: &mpsc::Sender<()>,
) {
let reporter = Reporter { state, progress_tx };
let key = render_core::hybrid::job_key(gpu, &job.scene, job.threads, job.compute_mode);
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
let mut produced: u32 = 0;
let mut batch_size: u32 = seeded_batch_size(key);
let mut gpu_frac: Option<f64> = if matches!(job.compute_mode, ComputeMode::Hybrid)
&& job.samples >= render_core::hybrid::HYBRID_MIN_SPP
&& render_core::scene_uses_gpu(&job.scene)
{
calibrate_hybrid_split(key, gpu, job, &reporter, cancel, &mut produced)
} else {
None
};
let started_on_split_path = gpu_frac.is_some();
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);
}
remember_converged_subbatch(key, batch_size);
if started_on_split_path {
render_core::hybrid::finalize_split_cache(key, gpu_frac);
}
}));
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(());
}
pub struct TracedRange {
pub sum: Vec<Vec3>,
pub done: u32,
pub panicked: bool,
}
pub fn trace_range(
scene: &SceneState,
(first_sample, samples): (u32, u32),
threads: usize,
compute_mode: ComputeMode,
gpu: &GpuBackend,
cancel: &AtomicBool,
) -> TracedRange {
let pixel_count = scene.width as usize * scene.height as usize;
let state = Arc::new(Mutex::new(SharedState::new(pixel_count)));
let (progress_tx, _progress_rx) = mpsc::channel();
let job = TracerJob {
scene: scene.clone(),
first_sample,
samples,
threads,
compute_mode,
};
run_tracer(&job, gpu, &state, cancel, &progress_tx);
let mut guard = state
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
let mut sum = vec![Vec3::ZERO; pixel_count];
let range = guard.pending_delta.swap_with(&mut sum);
let panicked = guard.panicked;
drop(guard);
TracedRange {
sum,
done: range.map_or(0, |(_, n)| n),
panicked,
}
}
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(
key: JobKey,
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_cached(
key,
gpu,
&job.scene,
SampleRange::new(job.first_sample, job.samples),
job.threads,
&mut calib_buf,
cancel,
) {
CachedCalibration::Split { gpu_frac, consumed } => {
if consumed > 0 {
reporter.fold_and_notify(job.first_sample, consumed, &calib_buf, produced);
}
Some(gpu_frac)
}
CachedCalibration::GpuOnly { consumed } => {
if consumed > 0 {
reporter.fold_and_notify(job.first_sample, consumed, &calib_buf, produced);
}
None
}
CachedCalibration::GpuDeclined => None,
CachedCalibration::Cancelled { consumed } => {
if consumed > 0 {
reporter.fold_and_notify(job.first_sample, consumed, &calib_buf, produced);
}
None
}
}
}