mod accum;
mod display;
mod emit;
mod picture;
mod polling;
use super::{
Output, ProducerSink, StreamOutcome, StreamSpec, TimeoutCache, TimeoutRead, TimeoutWrite,
tracer::SharedState,
};
use crate::cli::ComputeMode;
use emit::{emit_final, emit_progress_heartbeat, emit_tick_or_heartbeat};
use indicatrix::renderer::gpu_backend::GpuBackend;
use indicatrix_net::messages::{
Done, ErrorMsg, NetError, PayloadEncoding, RenderRequest, Stats, StreamEvent,
adaptive::PeerLink, error_codes,
};
use std::{
io::{Read, Write},
sync::{
Arc, Mutex,
atomic::{AtomicBool, Ordering},
mpsc,
},
time::{Duration, Instant},
};
pub(in crate::stream_emit) use accum::{EmitterAccum, PendingDelta};
pub(in crate::stream_emit) use emit::effective_cadence_ms;
#[cfg(test)]
pub(in crate::stream_emit) use emit::emit_tick;
pub(in crate::stream_emit) use polling::{ClientPoll, poll_for_client_message};
pub use polling::{RawPoll, poll_raw_client_message};
const EMITTER_POLL: Duration = Duration::from_millis(20);
const WRITE_TIMEOUT: Duration = Duration::from_secs(10);
fn spawn_producer(
request: &RenderRequest,
producer: impl FnOnce(ProducerSink) + Send + 'static,
) -> (
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::new(pixel_count)));
let cancel = Arc::new(AtomicBool::new(false));
let (progress_tx, progress_rx) = mpsc::channel::<()>();
let sink = ProducerSink::new(
Arc::clone(&state),
Arc::clone(&cancel),
progress_tx,
request.first_sample,
pixel_count,
);
let handle = std::thread::spawn(move || producer(sink));
(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),
reclaimed_samples: 0,
}
};
indicatrix_net::messages::write_stream_event(
stream,
&StreamEvent::Done(Done {
request_id: request.request_id,
cancelled: true,
stats,
}),
None,
)
}
fn answer_ping<S: Write>(stream: &mut S, polled: ClientPoll) -> Result<ClientPoll, NetError> {
if let ClientPoll::Ping(nonce) = polled {
indicatrix_net::messages::write_stream_event(stream, &StreamEvent::Pong { nonce }, None)?;
}
Ok(polled)
}
fn route_contribution<S: Read + Write + TimeoutRead>(
stream: &mut S,
spec: &StreamSpec<'_>,
request: &RenderRequest,
header: &indicatrix_net::messages::ContributionHeader,
timeouts: &mut TimeoutCache,
) -> Result<(), NetError> {
match spec.contribution {
Some(slot) if header.request_id == request.request_id => {
slot.receive(stream, header, request.request_id, timeouts)
}
_ => indicatrix_net::messages::discard_contribution_payload(stream, header),
}
}
struct LoopFlags<'a> {
cancelled: &'a mut bool,
peer_closed: &'a mut bool,
pipelined_next: &'a mut Option<RenderRequest>,
}
fn poll_once<S: Read + Write + TimeoutRead>(
stream: &mut S,
spec: &StreamSpec<'_>,
request: &RenderRequest,
cancel: &Arc<AtomicBool>,
timeouts: &mut TimeoutCache,
flags: &mut LoopFlags<'_>,
) -> Option<Result<StreamOutcome, NetError>> {
match poll_for_client_message(stream, request.request_id, EMITTER_POLL, timeouts)
.and_then(|polled| answer_ping(stream, polled))
{
Ok(ClientPoll::Cancelled) => {
cancel.store(true, Ordering::Relaxed);
*flags.cancelled = true;
}
Ok(ClientPoll::NextRequest(next)) => {
cancel.store(true, Ordering::Relaxed);
*flags.cancelled = true;
*flags.pipelined_next = Some(*next);
}
Ok(ClientPoll::Closed) => {
cancel.store(true, Ordering::Relaxed);
*flags.peer_closed = true;
}
Ok(ClientPoll::Contribution(header)) => {
if let Err(e) = route_contribution(stream, spec, request, &header, timeouts) {
cancel.store(true, Ordering::Relaxed);
return Some(Err(e));
}
}
Ok(ClientPoll::Pending | ClientPoll::Stale | ClientPoll::Ping(_)) => {}
Err(e) => {
cancel.store(true, Ordering::Relaxed);
return Some(Err(e));
}
}
None
}
struct StreamLoopOutcome {
result: Result<StreamOutcome, NetError>,
peer_closed: bool,
cancelled: bool,
pipelined_next: Option<RenderRequest>,
emission_count: u32,
stalled: bool,
}
struct StallWatch {
timeout: Option<Duration>,
samples_done: u32,
since: Instant,
}
impl StallWatch {
fn new(timeout: Option<Duration>) -> Self {
Self {
timeout,
samples_done: 0,
since: Instant::now(),
}
}
fn observe(&mut self, samples_done: u32) -> Option<Duration> {
if samples_done != self.samples_done {
self.samples_done = samples_done;
self.since = Instant::now();
}
self.timeout.filter(|window| self.since.elapsed() > *window)
}
}
struct HeartbeatPace<'a> {
bound: Duration,
last_emit: &'a mut Instant,
emission_count: &'a mut u32,
}
fn fail_stalled<S: Write>(
stream: &mut S,
request: &RenderRequest,
state: &Arc<Mutex<SharedState>>,
cancel: &AtomicBool,
progress_rx: &mpsc::Receiver<()>,
window: Duration,
pace: &mut HeartbeatPace<'_>,
) -> ErrorMsg {
let samples_done = state
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.samples_done;
tracing::warn!(
request_id = request.request_id,
samples_done,
?window,
"render lane made no progress; failing the request"
);
cancel.store(true, Ordering::Relaxed);
let give_up = Instant::now() + window / 4;
wait_for_tracer_until(stream, request, state, progress_rx, pace, Some(give_up));
ErrorMsg {
code: error_codes::PRODUCER_STALLED,
message: format!(
"the render lane made no progress for {window:.1?} (after {samples_done} samples); \
the request was abandoned"
),
request_id: Some(request.request_id),
}
}
fn finished_outcome<S: Write>(
stream: &mut S,
spec: &StreamSpec<'_>,
state: &Arc<Mutex<SharedState>>,
emitter_accum: &mut EmitterAccum,
streaming_start: Instant,
emission_count: &mut u32,
) -> Result<StreamOutcome, NetError> {
let (panicked, failed) = {
let mut guard = state
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
(guard.panicked, guard.failed.take())
};
if panicked {
return Ok(StreamOutcome::TracePanicked);
}
if let Some(error) = failed {
return Ok(StreamOutcome::Failed(ErrorMsg {
request_id: Some(spec.request.request_id),
..error
}));
}
emit_final(
stream,
spec,
state,
emitter_accum,
streaming_start,
emission_count,
)
}
fn run_stream_loop<S: Read + Write + TimeoutRead + TimeoutWrite>(
stream: &mut S,
spec: &StreamSpec<'_>,
state: &Arc<Mutex<SharedState>>,
cancel: &Arc<AtomicBool>,
progress_rx: &mpsc::Receiver<()>,
emitter_accum: &mut EmitterAccum,
streaming_start: Instant,
) -> StreamLoopOutcome {
let request = spec.request;
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 stalled = false;
let mut stall_watch = StallWatch::new(spec.stall_timeout);
let mut timeouts = TimeoutCache::new();
let result = loop {
let _ = progress_rx.recv_timeout(EMITTER_POLL);
let mut flags = LoopFlags {
cancelled: &mut cancelled,
peer_closed: &mut peer_closed,
pipelined_next: &mut pipelined_next,
};
if let Some(outcome) = poll_once(stream, spec, request, cancel, &mut timeouts, &mut flags) {
break outcome;
}
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, samples_done) = {
let guard = state
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
(guard.finished, guard.samples_done)
};
if !finished && let Some(window) = stall_watch.observe(samples_done) {
stalled = true;
let mut pace = HeartbeatPace {
bound: cadence.min(super::HEARTBEAT_INTERVAL),
last_emit: &mut last_emit,
emission_count: &mut emission_count,
};
let error = fail_stalled(
stream,
request,
state,
cancel,
progress_rx,
window,
&mut pace,
);
break Ok(StreamOutcome::Failed(error));
}
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 {
break finished_outcome(
stream,
spec,
state,
emitter_accum,
streaming_start,
&mut emission_count,
);
}
};
StreamLoopOutcome {
result,
peer_closed,
cancelled,
pipelined_next,
emission_count,
stalled,
}
}
pub fn run_stream<S: Read + Write + TimeoutRead + TimeoutWrite>(
stream: &mut S,
request: &RenderRequest,
threads: usize,
gpu: &Arc<GpuBackend>,
compute_mode: ComputeMode,
payload_encoding: PayloadEncoding,
link: Option<&Arc<PeerLink>>,
) -> Result<(StreamOutcome, Option<RenderRequest>), NetError> {
run_stream_with(
stream,
&StreamSpec {
request,
payload_encoding,
link,
output: Output::Radiance,
contribution: None,
stall_timeout: Some(super::PRODUCER_STALL_TIMEOUT),
},
super::local_tracer(request, threads, gpu, compute_mode),
)
}
pub fn run_stream_with<S: Read + Write + TimeoutRead + TimeoutWrite>(
stream: &mut S,
spec: &StreamSpec<'_>,
producer: impl FnOnce(ProducerSink) + Send + 'static,
) -> Result<(StreamOutcome, Option<RenderRequest>), NetError> {
let request = spec.request;
let (state, cancel, progress_rx, tracer_handle) = spawn_producer(request, producer);
let link = spec.link.map_or_else(
|| Arc::new(PeerLink::fixed(spec.payload_encoding)),
Arc::clone,
);
let mut emitter_accum = EmitterAccum::with_link(
request.scene.width as usize * request.scene.height as usize,
link,
);
let _ = stream.set_write_timeout(Some(WRITE_TIMEOUT));
let streaming_start = Instant::now();
let StreamLoopOutcome {
result,
peer_closed,
cancelled,
pipelined_next,
emission_count,
stalled,
} = run_stream_loop(
stream,
spec,
&state,
&cancel,
&progress_rx,
&mut emitter_accum,
streaming_start,
);
emitter_accum.link().release_buffers();
if stalled {
drop(tracer_handle);
} else {
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(in crate::stream_emit) 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,
) {
let mut pace = HeartbeatPace {
bound: heartbeat_bound,
last_emit,
emission_count,
};
wait_for_tracer_until(stream, request, state, progress_rx, &mut pace, None);
}
fn wait_for_tracer_until<S: Write>(
stream: &mut S,
request: &RenderRequest,
state: &Arc<Mutex<SharedState>>,
progress_rx: &mpsc::Receiver<()>,
pace: &mut HeartbeatPace<'_>,
give_up: Option<Instant>,
) {
while !state
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.finished
{
if give_up.is_some_and(|deadline| Instant::now() >= deadline) {
break;
}
let _ = progress_rx.recv_timeout(EMITTER_POLL);
if pace.last_emit.elapsed() >= pace.bound {
if emit_progress_heartbeat(stream, request, state, pace.emission_count).is_err() {
break;
}
*pace.last_emit = Instant::now();
}
}
}