use super::{resolve_facet_finishes, scene_uses_gpu, trace_into};
use crate::cli::ComputeMode;
use glam::Vec3;
use indicatrix::{
optics::raytracer::{Camera, DEFAULT_FOV_DEG},
renderer::gpu_backend::{GpuAccumulate, GpuBackend, GpuSceneRef},
};
use indicatrix_dispatch::SampleRange;
use indicatrix_net::SceneState;
use std::{
collections::BTreeMap,
sync::{
LazyLock, Mutex,
atomic::{AtomicBool, Ordering},
},
thread,
time::Instant,
};
pub const HYBRID_MIN_SPP: u32 = 8;
fn cpu_threads_beside_gpu(threads: usize) -> usize {
super::effective_thread_count(threads)
.saturating_sub(1)
.max(1)
}
const HYBRID_MAX_GPU_SHARE: f64 = 0.7;
fn cpu_is_worth_splitting_with(gpu_share_frac: f64) -> bool {
gpu_share_frac < HYBRID_MAX_GPU_SHARE
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum CalibrationOutcome {
Split(f64, u32),
GpuDeclined,
GpuDominates { gpu_share_frac: f64 },
Cancelled { consumed: u32 },
}
fn scene_pieces(scene: &SceneState) -> (Camera, Vec<indicatrix::optics::raytracer::FacetFinish>) {
let camera = Camera::new(scene.yaw, scene.pitch, scene.distance, DEFAULT_FOV_DEG);
(camera, resolve_facet_finishes(scene))
}
#[must_use]
pub fn calibrate(
gpu: &GpuBackend,
scene: &SceneState,
first_sample: u32,
samples: u32,
threads: usize,
out: &mut [Vec3],
cancel: &AtomicBool,
) -> CalibrationOutcome {
if samples < 3 || !scene_uses_gpu(scene) {
return CalibrationOutcome::GpuDeclined;
}
if cancel.load(Ordering::Relaxed) {
return CalibrationOutcome::Cancelled { consumed: 0 };
}
let (camera, facet_finishes) = scene_pieces(scene);
let hdr_map = crate::assets::resolved_hdr_map(scene);
let environment = crate::assets::environment_source(scene, hdr_map.as_deref());
let gpu_scene = GpuSceneRef {
camera: &camera,
width: scene.width,
height: scene.height,
planes: &scene.planes,
facet_finishes: &facet_finishes,
material: &scene.material,
max_bounces: scene.max_bounces,
environment,
};
match gpu.try_accumulate_cancellable(&gpu_scene, first_sample, 1, out, cancel) {
GpuAccumulate::Done => {}
GpuAccumulate::Declined => return CalibrationOutcome::GpuDeclined,
GpuAccumulate::Cancelled => return CalibrationOutcome::Cancelled { consumed: 0 },
}
if cancel.load(Ordering::Relaxed) {
return CalibrationOutcome::Cancelled { consumed: 1 };
}
let start = Instant::now();
match gpu.try_accumulate_cancellable(&gpu_scene, first_sample + 1, 1, out, cancel) {
GpuAccumulate::Done => {}
GpuAccumulate::Declined => return CalibrationOutcome::GpuDeclined,
GpuAccumulate::Cancelled => return CalibrationOutcome::Cancelled { consumed: 1 },
}
let gpu_time = start.elapsed().as_secs_f64().max(1e-9);
if cancel.load(Ordering::Relaxed) {
return CalibrationOutcome::Cancelled { consumed: 2 };
}
let start = Instant::now();
let _ = trace_into(
scene,
SampleRange::new(first_sample + 2, 1),
threads,
&camera,
environment,
out,
cancel,
);
let cpu_time = start.elapsed().as_secs_f64().max(1e-9);
let frac = (cpu_time / (gpu_time + cpu_time)).clamp(0.0, 1.0);
if !cpu_is_worth_splitting_with(frac) {
return CalibrationOutcome::GpuDominates {
gpu_share_frac: frac,
};
}
CalibrationOutcome::Split(frac, 3)
}
pub fn hybrid_trace(
gpu: &GpuBackend,
scene: &SceneState,
first_sample: u32,
samples: u32,
threads: usize,
gpu_frac: &mut Option<f64>,
cancel: &AtomicBool,
) -> Option<Vec<Vec3>> {
let width = scene.width;
let height = scene.height;
let mut buffer = vec![Vec3::ZERO; width as usize * height as usize];
if samples == 0 || width == 0 || height == 0 {
return Some(buffer);
}
if !scene_uses_gpu(scene) {
*gpu_frac = None;
}
let frac = gpu_frac.unwrap_or(0.0);
let gpu_share = ((f64::from(samples) * frac).round() as u32).min(samples);
let cpu_share = samples - gpu_share;
let (camera, facet_finishes) = scene_pieces(scene);
let hdr_map = crate::assets::resolved_hdr_map(scene);
let environment = crate::assets::environment_source(scene, hdr_map.as_deref());
if gpu_share == 0 {
if !trace_into(
scene,
SampleRange::new(first_sample, samples),
threads,
&camera,
environment,
&mut buffer,
cancel,
) {
return None;
}
return Some(buffer);
}
let gpu_scene = GpuSceneRef {
camera: &camera,
width,
height,
planes: &scene.planes,
facet_finishes: &facet_finishes,
material: &scene.material,
max_bounces: scene.max_bounces,
environment,
};
let mut gpu_buf = vec![Vec3::ZERO; width as usize * height as usize];
let (gpu_outcome, gpu_elapsed, cpu_elapsed) = if cpu_share == 0 {
let start = Instant::now();
let outcome = gpu.try_accumulate_cancellable(
&gpu_scene,
first_sample,
gpu_share,
&mut gpu_buf,
cancel,
);
(outcome, start.elapsed(), std::time::Duration::ZERO)
} else {
let cpu = CpuShare {
scene,
first_sample: first_sample + gpu_share,
samples: cpu_share,
threads: cpu_threads_beside_gpu(threads),
buffer: &mut buffer,
};
dispatch_concurrently(
gpu,
&gpu_scene,
first_sample,
gpu_share,
&mut gpu_buf,
cancel,
cpu,
)
};
match gpu_outcome {
GpuAccumulate::Cancelled => return None,
GpuAccumulate::Declined => {
if !trace_into(
scene,
SampleRange::new(first_sample, gpu_share),
threads,
&camera,
environment,
&mut buffer,
cancel,
) {
return None;
}
*gpu_frac = None;
return Some(buffer);
}
GpuAccumulate::Done => {}
}
for (b, g) in buffer.iter_mut().zip(&gpu_buf) {
*b += *g;
}
if cpu_share > 0 {
*gpu_frac = Some(blend_gpu_frac(
frac,
gpu_share,
cpu_share,
gpu_elapsed,
cpu_elapsed,
));
}
Some(buffer)
}
struct CpuShare<'a> {
scene: &'a SceneState,
first_sample: u32,
samples: u32,
threads: usize,
buffer: &'a mut [Vec3],
}
#[expect(
clippy::needless_pass_by_value,
reason = "CpuShare::buffer is an exclusive &mut [Vec3] that must be MOVED into \
trace_into below; taking `&CpuShare` instead would make that reborrow \
impossible from behind a shared reference, so by-value is the only option"
)]
fn dispatch_concurrently(
gpu: &GpuBackend,
gpu_scene: &GpuSceneRef<'_>,
first_sample: u32,
gpu_share: u32,
gpu_buf: &mut [Vec3],
cancel: &AtomicBool,
cpu: CpuShare<'_>,
) -> (GpuAccumulate, std::time::Duration, std::time::Duration) {
thread::scope(|scope| {
let gpu_handle = scope.spawn(move || {
let start = Instant::now();
let outcome =
gpu.try_accumulate_cancellable(gpu_scene, first_sample, gpu_share, gpu_buf, cancel);
(outcome, start.elapsed())
});
let cpu_start = Instant::now();
let _ = trace_into(
cpu.scene,
SampleRange::new(cpu.first_sample, cpu.samples),
cpu.threads,
gpu_scene.camera,
gpu_scene.environment,
cpu.buffer,
cancel,
);
let cpu_elapsed = cpu_start.elapsed();
let (outcome, gpu_elapsed) = gpu_handle
.join()
.unwrap_or_else(|payload| std::panic::resume_unwind(payload));
(outcome, gpu_elapsed, cpu_elapsed)
})
}
fn blend_gpu_frac(
frac: f64,
gpu_share: u32,
cpu_share: u32,
gpu_elapsed: std::time::Duration,
cpu_elapsed: std::time::Duration,
) -> f64 {
let gpu_rate = f64::from(gpu_share) / gpu_elapsed.as_secs_f64().max(1e-9);
let cpu_rate = f64::from(cpu_share) / cpu_elapsed.as_secs_f64().max(1e-9);
let measured_frac = gpu_rate / (gpu_rate + cpu_rate);
let updated = frac.mul_add(0.7, measured_frac * 0.3).clamp(0.0, 1.0);
if cpu_is_worth_splitting_with(updated) {
updated
} else {
1.0
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub struct JobKey {
compute_mode: u8,
gpu_id: usize,
threads: usize,
resolution_bucket: u32,
}
const fn compute_mode_tag(mode: ComputeMode) -> u8 {
match mode {
ComputeMode::Hybrid => 0,
ComputeMode::OnlyGpu => 1,
ComputeMode::OnlyCpu => 2,
}
}
#[must_use]
pub fn job_key(
gpu: &GpuBackend,
scene: &SceneState,
threads: usize,
compute_mode: ComputeMode,
) -> JobKey {
let pixels = u64::from(scene.width) * u64::from(scene.height);
JobKey {
compute_mode: compute_mode_tag(compute_mode),
gpu_id: std::ptr::from_ref(gpu) as usize,
threads: super::effective_thread_count(threads),
resolution_bucket: pixels.max(1).ilog2(),
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
enum CachedDecision {
GpuOnly,
Split {
gpu_frac: f64,
},
}
static CALIBRATION_CACHE: LazyLock<Mutex<BTreeMap<JobKey, CachedDecision>>> =
LazyLock::new(|| Mutex::new(BTreeMap::new()));
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum CachedCalibration {
Split {
gpu_frac: f64,
consumed: u32,
},
GpuOnly {
consumed: u32,
},
GpuDeclined,
Cancelled {
consumed: u32,
},
}
#[must_use]
pub fn calibrate_cached(
key: JobKey,
gpu: &GpuBackend,
scene: &SceneState,
range: SampleRange,
threads: usize,
out: &mut [Vec3],
cancel: &AtomicBool,
) -> CachedCalibration {
let cached = CALIBRATION_CACHE
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.get(&key)
.copied();
if let Some(decision) = cached {
tracing::debug!(
?key,
?decision,
"hybrid split: cache hit, reusing calibration decision"
);
return match decision {
CachedDecision::GpuOnly => CachedCalibration::GpuOnly { consumed: 0 },
CachedDecision::Split { gpu_frac } => CachedCalibration::Split {
gpu_frac,
consumed: 0,
},
};
}
let SampleRange {
first_sample,
samples,
} = range;
match calibrate(gpu, scene, first_sample, samples, threads, out, cancel) {
CalibrationOutcome::Split(gpu_frac, consumed) => {
CALIBRATION_CACHE
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.insert(key, CachedDecision::Split { gpu_frac });
tracing::info!(
?key,
gpu_frac,
"hybrid split: calibrated and cached a new decision"
);
CachedCalibration::Split { gpu_frac, consumed }
}
CalibrationOutcome::GpuDominates { gpu_share_frac } => {
CALIBRATION_CACHE
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.insert(key, CachedDecision::GpuOnly);
tracing::info!(
?key,
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) -- cached for this resource profile"
);
CachedCalibration::GpuOnly { consumed: 0 }
}
CalibrationOutcome::GpuDeclined => CachedCalibration::GpuDeclined,
CalibrationOutcome::Cancelled { consumed } => CachedCalibration::Cancelled { consumed },
}
}
pub fn finalize_split_cache(key: JobKey, gpu_frac: Option<f64>) {
let mut cache = CALIBRATION_CACHE
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
match gpu_frac {
Some(frac) => {
cache.insert(key, CachedDecision::Split { gpu_frac: frac });
}
None => {
cache.remove(&key);
}
}
}
pub fn calibrate_now(
gpu: &GpuBackend,
scene: &SceneState,
threads: usize,
compute_mode: ComputeMode,
) {
let key = job_key(gpu, scene, threads, compute_mode);
let pixel_count = scene.width as usize * scene.height as usize;
let mut throwaway = vec![Vec3::ZERO; pixel_count];
let never_cancel = AtomicBool::new(false);
let _ = calibrate_cached(
key,
gpu,
scene,
SampleRange::new(0, HYBRID_MIN_SPP),
threads,
&mut throwaway,
&never_cancel,
);
}
#[cfg(test)]
mod tests;