use super::{
StreamOutcome, TimeoutCache, TimeoutRead, TimeoutWrite,
downsample::downsample_preview,
tracer::{SharedState, TracerJob, run_tracer},
};
use crate::cli::ComputeMode;
use glam::Vec3;
use indicatrix::renderer::gpu_backend::GpuBackend;
use indicatrix_net::{
messages::{
ClientMessage, Done, FrameHeader, NetError, PreviewConfig, PreviewHeader, Progress,
RenderRequest, Stats, StreamEvent, TransferMode,
},
radiance,
};
use std::{
io::{Read, Write},
sync::{
Arc, Mutex,
atomic::{AtomicBool, Ordering},
mpsc,
},
time::{Duration, Instant},
};
const EMITTER_POLL: Duration = Duration::from_millis(20);
const WRITE_TIMEOUT: Duration = Duration::from_secs(10);
pub(super) struct PendingDelta {
buffer: Vec<Vec3>,
range: Option<(u32, u32)>,
}
impl PendingDelta {
pub(super) fn new(pixel_count: usize) -> Self {
Self {
buffer: vec![Vec3::ZERO; pixel_count],
range: None,
}
}
pub(super) fn add(&mut self, first_sample: u32, samples: u32, contribution: &[Vec3]) {
debug_assert_eq!(contribution.len(), self.buffer.len());
match self.range {
None => {
self.buffer.copy_from_slice(contribution);
self.range = Some((first_sample, samples));
}
Some((range_first, range_samples)) => {
debug_assert_eq!(
first_sample,
range_first + range_samples,
"sub-batches must coalesce in contiguous sample order"
);
for (acc, c) in self.buffer.iter_mut().zip(contribution) {
*acc += *c;
}
self.range = Some((range_first, range_samples + samples));
}
}
}
pub(super) fn swap_with(&mut self, spare: &mut Vec<Vec3>) -> Option<(u32, u32)> {
debug_assert_eq!(
spare.len(),
self.buffer.len(),
"swap_with's spare buffer must match this delta's pixel count"
);
std::mem::swap(&mut self.buffer, spare);
self.range.take()
}
}
pub(super) struct EmitterAccum {
running_total: Vec<Vec3>,
spare: Vec<Vec3>,
}
impl EmitterAccum {
pub(super) fn new(pixel_count: usize) -> Self {
Self {
running_total: vec![Vec3::ZERO; pixel_count],
spare: vec![Vec3::ZERO; pixel_count],
}
}
#[cfg(test)]
pub(super) fn from_running_total(running_total: Vec<Vec3>) -> Self {
let spare = vec![Vec3::ZERO; running_total.len()];
Self {
running_total,
spare,
}
}
pub(super) fn swap_and_fold(
&mut self,
state: &Mutex<SharedState>,
) -> (Option<(u32, u32)>, u32) {
let (range, samples_done) = {
let mut guard = state
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
let range = guard.pending_delta.swap_with(&mut self.spare);
(range, guard.samples_done)
};
if range.is_some() {
for (total, c) in self.running_total.iter_mut().zip(self.spare.iter()) {
*total += *c;
}
}
(range, samples_done)
}
pub(super) fn delta(&self) -> &[Vec3] {
&self.spare
}
pub(super) fn running_total(&self) -> &[Vec3] {
&self.running_total
}
}
pub(super) enum ClientPoll {
Pending,
Cancelled,
Stale,
Closed,
NextRequest(Box<RenderRequest>),
}
pub(super) fn poll_for_client_message<S: Read + TimeoutRead>(
stream: &mut S,
request_id: u32,
poll_timeout: Duration,
timeouts: &mut TimeoutCache,
) -> Result<ClientPoll, NetError> {
timeouts
.apply(stream, Some(poll_timeout))
.map_err(|e| NetError::Framing(indicatrix_net::framing::FramingError::Io(e)))?;
let mut len_bytes = [0u8; indicatrix_net::framing::LEN_PREFIX_BYTES];
let n = match stream.read(&mut len_bytes) {
Ok(0) => return Ok(ClientPoll::Closed),
Ok(n) => n,
Err(e) if super::is_stream_timeout(&e) => {
return Ok(ClientPoll::Pending);
}
Err(e) => {
return Err(NetError::Framing(
indicatrix_net::framing::FramingError::Io(e),
));
}
};
timeouts
.apply(stream, Some(super::FRAME_REMAINDER_TIMEOUT))
.map_err(|e| NetError::Framing(indicatrix_net::framing::FramingError::Io(e)))?;
if n < len_bytes.len() {
stream
.read_exact(&mut len_bytes[n..])
.map_err(|e| NetError::Framing(indicatrix_net::framing::FramingError::Io(e)))?;
}
let len = u32::from_le_bytes(len_bytes);
if len > indicatrix_net::framing::MAX_FRAME_LEN {
return Err(NetError::Framing(
indicatrix_net::framing::FramingError::FrameTooLarge {
len,
max: indicatrix_net::framing::MAX_FRAME_LEN,
},
));
}
let mut payload = vec![0u8; len as usize];
stream
.read_exact(&mut payload)
.map_err(|e| NetError::Framing(indicatrix_net::framing::FramingError::Io(e)))?;
let msg: ClientMessage = postcard::from_bytes(&payload)?;
Ok(match msg {
ClientMessage::Cancel(cancel) if cancel.request_id == request_id => ClientPoll::Cancelled,
ClientMessage::Cancel(_) => ClientPoll::Stale,
ClientMessage::RenderRequest(next) => ClientPoll::NextRequest(next),
ClientMessage::Library(_) => {
tracing::debug!(
"received a LibraryRequest while request_id={request_id} was streaming -- library requests \
are not serviced mid-stream in this phase; ignoring"
);
ClientPoll::Stale
}
ClientMessage::TiltCurvesRequest(_) => {
tracing::debug!(
"received a TiltCurvesRequest while request_id={request_id} was streaming -- \
TILT_CURVES is not serviced mid-stream in this phase; ignoring"
);
ClientPoll::Stale
}
})
}
pub(super) fn effective_cadence_ms(elapsed: Duration, emission_count: u32) -> u32 {
if emission_count < 2 {
0
} else {
(elapsed.as_millis() / u128::from(emission_count - 1)) as u32
}
}
fn spawn_tracer(
request: &RenderRequest,
threads: usize,
gpu: &Arc<GpuBackend>,
compute_mode: ComputeMode,
) -> (
Arc<Mutex<SharedState>>,
Arc<AtomicBool>,
mpsc::Receiver<()>,
std::thread::JoinHandle<()>,
) {
let pixel_count = request.scene.width as usize * request.scene.height as usize;
let state = Arc::new(Mutex::new(SharedState {
pending_delta: PendingDelta::new(pixel_count),
samples_done: 0,
finished: false,
panicked: false,
}));
let cancel = Arc::new(AtomicBool::new(false));
let (progress_tx, progress_rx) = mpsc::channel::<()>();
let job = TracerJob {
scene: request.scene.clone(),
first_sample: request.first_sample,
samples: request.samples,
threads,
compute_mode,
};
let tracer_state = Arc::clone(&state);
let tracer_cancel = Arc::clone(&cancel);
let tracer_gpu = Arc::clone(gpu);
let handle = std::thread::spawn(move || {
run_tracer(
&job,
&tracer_gpu,
&tracer_state,
&tracer_cancel,
&progress_tx,
);
});
(state, cancel, progress_rx, handle)
}
fn write_cancelled_done<S: Write>(
stream: &mut S,
request: &RenderRequest,
state: &Arc<Mutex<SharedState>>,
streaming_start: Instant,
emission_count: u32,
) -> Result<(), NetError> {
let stats = {
let guard = state
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
Stats {
samples_done: guard.samples_done,
requested_cadence_ms: request.stream.cadence_ms,
effective_cadence_ms: effective_cadence_ms(streaming_start.elapsed(), emission_count),
}
};
indicatrix_net::messages::write_stream_event(
stream,
&StreamEvent::Done(Done {
request_id: request.request_id,
cancelled: true,
stats,
}),
None,
)
}
struct StreamLoopOutcome {
result: Result<StreamOutcome, NetError>,
peer_closed: bool,
cancelled: bool,
pipelined_next: Option<RenderRequest>,
emission_count: u32,
}
fn run_stream_loop<S: Read + Write + TimeoutRead + TimeoutWrite>(
stream: &mut S,
request: &RenderRequest,
state: &Arc<Mutex<SharedState>>,
cancel: &Arc<AtomicBool>,
progress_rx: &mpsc::Receiver<()>,
emitter_accum: &mut EmitterAccum,
streaming_start: Instant,
) -> StreamLoopOutcome {
let cadence = Duration::from_millis(u64::from(request.stream.cadence_ms));
let mut last_emit = Instant::now()
.checked_sub(cadence)
.unwrap_or_else(Instant::now);
let mut emission_count: u32 = 0;
let mut cancelled = false;
let mut peer_closed = false;
let mut pipelined_next: Option<RenderRequest> = None;
let mut timeouts = TimeoutCache::new();
let result = loop {
let _ = progress_rx.recv_timeout(EMITTER_POLL);
match poll_for_client_message(stream, request.request_id, EMITTER_POLL, &mut timeouts) {
Ok(ClientPoll::Cancelled) => {
cancel.store(true, Ordering::Relaxed);
cancelled = true;
}
Ok(ClientPoll::NextRequest(next)) => {
cancel.store(true, Ordering::Relaxed);
cancelled = true;
pipelined_next = Some(*next);
}
Ok(ClientPoll::Closed) => {
cancel.store(true, Ordering::Relaxed);
peer_closed = true;
}
Ok(ClientPoll::Pending | ClientPoll::Stale) => {}
Err(e) => {
cancel.store(true, Ordering::Relaxed);
break Err(e);
}
}
if cancelled || peer_closed {
wait_for_tracer_to_stop(
stream,
request,
state,
progress_rx,
cadence.min(super::HEARTBEAT_INTERVAL),
&mut last_emit,
&mut emission_count,
);
break Ok(StreamOutcome::Completed);
}
let finished = state
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.finished;
if !finished
&& let Err(e) = emit_tick_or_heartbeat(
stream,
request,
state,
emitter_accum,
cadence,
&mut last_emit,
&mut emission_count,
)
{
cancel.store(true, Ordering::Relaxed);
break Err(e);
}
if finished {
let panicked = state
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.panicked;
if panicked {
break Ok(StreamOutcome::TracePanicked);
}
let r = emit_final(
stream,
request,
state,
emitter_accum,
streaming_start,
&mut emission_count,
);
break r.map(|()| StreamOutcome::Completed);
}
};
StreamLoopOutcome {
result,
peer_closed,
cancelled,
pipelined_next,
emission_count,
}
}
pub fn run_stream<S: Read + Write + TimeoutRead + TimeoutWrite>(
stream: &mut S,
request: &RenderRequest,
threads: usize,
gpu: &Arc<GpuBackend>,
compute_mode: ComputeMode,
) -> Result<(StreamOutcome, Option<RenderRequest>), NetError> {
let (state, cancel, progress_rx, tracer_handle) =
spawn_tracer(request, threads, gpu, compute_mode);
let mut emitter_accum =
EmitterAccum::new(request.scene.width as usize * request.scene.height as usize);
let _ = stream.set_write_timeout(Some(WRITE_TIMEOUT));
let streaming_start = Instant::now();
let StreamLoopOutcome {
result,
peer_closed,
cancelled,
pipelined_next,
emission_count,
} = run_stream_loop(
stream,
request,
&state,
&cancel,
&progress_rx,
&mut emitter_accum,
streaming_start,
);
let _ = tracer_handle.join();
let _ = stream.set_read_timeout(None);
if peer_closed {
let _ = stream.set_write_timeout(None);
return Ok((StreamOutcome::Completed, None));
}
if cancelled {
let cancelled_done_result =
write_cancelled_done(stream, request, &state, streaming_start, emission_count);
let _ = stream.set_write_timeout(None);
cancelled_done_result?;
return Ok((StreamOutcome::Completed, pipelined_next));
}
let _ = stream.set_write_timeout(None);
result.map(|outcome| (outcome, None))
}
pub(super) fn wait_for_tracer_to_stop<S: Write>(
stream: &mut S,
request: &RenderRequest,
state: &Arc<Mutex<SharedState>>,
progress_rx: &mpsc::Receiver<()>,
heartbeat_bound: Duration,
last_emit: &mut Instant,
emission_count: &mut u32,
) {
while !state
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.finished
{
let _ = progress_rx.recv_timeout(EMITTER_POLL);
if last_emit.elapsed() >= heartbeat_bound {
if emit_progress_heartbeat(stream, request, state, emission_count).is_err() {
break;
}
*last_emit = Instant::now();
}
}
}
fn emit_tick_or_heartbeat<S: Write>(
stream: &mut S,
request: &RenderRequest,
state: &Arc<Mutex<SharedState>>,
emitter_accum: &mut EmitterAccum,
cadence: Duration,
last_emit: &mut Instant,
emission_count: &mut u32,
) -> Result<(), NetError> {
if last_emit.elapsed() >= cadence {
emit_tick(stream, request, state, emitter_accum, emission_count)?;
*last_emit = Instant::now();
return Ok(());
}
maybe_emit_heartbeat_backstop(
stream,
request,
state,
super::HEARTBEAT_INTERVAL,
last_emit,
emission_count,
)
}
fn maybe_emit_heartbeat_backstop<S: Write>(
stream: &mut S,
request: &RenderRequest,
state: &Arc<Mutex<SharedState>>,
heartbeat_interval: Duration,
last_emit: &mut Instant,
emission_count: &mut u32,
) -> Result<(), NetError> {
if last_emit.elapsed() < heartbeat_interval {
return Ok(());
}
emit_progress_heartbeat(stream, request, state, emission_count)?;
*last_emit = Instant::now();
Ok(())
}
fn emit_progress_heartbeat<S: Write>(
stream: &mut S,
request: &RenderRequest,
state: &Arc<Mutex<SharedState>>,
emission_count: &mut u32,
) -> Result<(), NetError> {
let samples_done = state
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.samples_done;
indicatrix_net::messages::write_stream_event(
stream,
&StreamEvent::Progress(Progress {
request_id: request.request_id,
samples_done,
}),
None,
)?;
*emission_count += 1;
Ok(())
}
pub(super) fn emit_tick<S: Write>(
stream: &mut S,
request: &RenderRequest,
state: &Arc<Mutex<SharedState>>,
emitter: &mut EmitterAccum,
emission_count: &mut u32,
) -> Result<(), NetError> {
let (range, samples_done) = emitter.swap_and_fold(state);
let frame_sent_this_tick =
range.is_some() && matches!(request.stream.transfer_mode, TransferMode::LiveProgressive);
if let Some((first_sample, samples)) = range
&& frame_sent_this_tick
{
let xyz_bytes = radiance::as_bytes(emitter.delta());
let header = FrameHeader::for_payload(request.request_id, first_sample, samples, xyz_bytes);
indicatrix_net::messages::write_stream_event(
stream,
&StreamEvent::Frame(header),
Some(xyz_bytes),
)?;
*emission_count += 1;
}
if let Some(cfg) = request.stream.preview
&& samples_done > 0
{
let full_scale_and_redundant = frame_sent_this_tick
&& cfg.width == request.scene.width
&& cfg.height == request.scene.height;
if !full_scale_and_redundant {
write_preview(stream, request, cfg, emitter.running_total(), samples_done)?;
}
}
indicatrix_net::messages::write_stream_event(
stream,
&StreamEvent::Progress(Progress {
request_id: request.request_id,
samples_done,
}),
None,
)?;
*emission_count += 1;
Ok(())
}
fn emit_final<S: Write>(
stream: &mut S,
request: &RenderRequest,
state: &Arc<Mutex<SharedState>>,
emitter: &mut EmitterAccum,
streaming_start: Instant,
emission_count: &mut u32,
) -> Result<(), NetError> {
let (range, _samples_done) = emitter.swap_and_fold(state);
match request.stream.transfer_mode {
TransferMode::FinalOnly => {
let xyz_bytes = radiance::as_bytes(emitter.running_total());
let header = FrameHeader::for_payload(
request.request_id,
request.first_sample,
request.samples,
xyz_bytes,
);
indicatrix_net::messages::write_stream_event(
stream,
&StreamEvent::Frame(header),
Some(xyz_bytes),
)?;
*emission_count += 1;
}
TransferMode::LiveProgressive => {
if let Some((first_sample, samples)) = range {
let xyz_bytes = radiance::as_bytes(emitter.delta());
let header =
FrameHeader::for_payload(request.request_id, first_sample, samples, xyz_bytes);
indicatrix_net::messages::write_stream_event(
stream,
&StreamEvent::Frame(header),
Some(xyz_bytes),
)?;
*emission_count += 1;
}
}
}
let stats = Stats {
samples_done: request.samples,
requested_cadence_ms: request.stream.cadence_ms,
effective_cadence_ms: effective_cadence_ms(streaming_start.elapsed(), *emission_count),
};
indicatrix_net::messages::write_stream_event(
stream,
&StreamEvent::Done(Done {
request_id: request.request_id,
cancelled: false,
stats,
}),
None,
)?;
Ok(())
}
fn write_preview<S: Write>(
stream: &mut S,
request: &RenderRequest,
cfg: PreviewConfig,
running_total: &[Vec3],
samples_done: u32,
) -> Result<(), NetError> {
let preview_buffer = downsample_preview(
running_total,
request.scene.width,
request.scene.height,
cfg.width,
cfg.height,
);
let xyz_bytes = radiance::as_bytes(&preview_buffer);
let header = PreviewHeader::for_payload(
request.request_id,
cfg.width,
cfg.height,
samples_done,
xyz_bytes,
);
indicatrix_net::messages::write_stream_event(
stream,
&StreamEvent::Preview(header),
Some(xyz_bytes),
)
}