mod late;
mod limits;
mod plan;
mod producer;
mod served;
pub use limits::job_bytes;
use limits::{MemoryBudget, ViewerQueues};
pub use plan::InteractivePin;
use plan::{Ask, JobPlan, Route, WorkerPick};
use super::{LaneTimeouts, Registry, WorkerInfo};
use crate::{
assets::{AssetCache, HeldAsset},
cli::ComputeMode,
stream_emit::{self, Output, StreamOutcome, StreamSpec, TimeoutRead, TimeoutWrite},
validate,
};
use indicatrix::renderer::gpu_backend::GpuBackend;
use indicatrix_dispatch::{ChunkPolicy, PoolConfig, SampleRange};
use indicatrix_net::messages::{
ErrorMsg, FinalImageRequest, NetError, PayloadEncoding, PreviewConfig, RenderCapability,
RenderRequest, RequestIntent, StreamConfig, StreamEvent, TransferMode, adaptive::PeerLink,
error_codes,
};
use std::{
collections::BTreeMap,
io::{Read, Write},
sync::{
Arc, Mutex, PoisonError,
atomic::{AtomicU32, Ordering},
},
time::{Duration, Instant},
};
pub struct OwnLaneSetup {
pub gpu: Arc<GpuBackend>,
pub threads: usize,
pub compute_mode: ComputeMode,
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct JobConfig {
pub batch: PoolConfig,
pub interactive: PoolConfig,
pub lane_wait: Duration,
pub lane: LaneTimeouts,
pub contribution_wait: Duration,
pub whole_image_secs: f64,
pub whole_image_pixel_samples: u64,
pub jobs_per_viewer: u32,
}
impl Default for JobConfig {
fn default() -> Self {
Self {
batch: PoolConfig {
policy: ChunkPolicy::EXPORT,
pause_after_failures: 1,
retire_after_failures: 4,
backoff_initial: Duration::from_secs(1),
backoff_max: Duration::from_secs(8),
},
interactive: PoolConfig::INTERACTIVE,
lane_wait: Duration::from_secs(30),
lane: LaneTimeouts::default(),
contribution_wait: stream_emit::DEFAULT_CONTRIBUTION_WAIT,
whole_image_secs: crate::cli::DEFAULT_WHOLE_IMAGE_SECS,
whole_image_pixel_samples: crate::cli::DEFAULT_WHOLE_IMAGE_PIXEL_SAMPLES,
jobs_per_viewer: crate::cli::DEFAULT_JOBS_PER_VIEWER,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub enum LaneKey {
Own,
Worker(WorkerIdentity),
}
impl LaneKey {
#[must_use]
pub fn for_worker(info: &WorkerInfo) -> Self {
Self::Worker(
info.label
.clone()
.map_or_else(|| WorkerIdentity::Id(info.worker_id), WorkerIdentity::Label),
)
}
}
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub enum WorkerIdentity {
Label(String),
Id(u32),
}
#[derive(Debug, Default)]
pub struct RateBook {
rates: BTreeMap<LaneKey, f64>,
}
impl RateBook {
#[must_use]
pub fn get(&self, key: &LaneKey, pixels: u32) -> Option<f64> {
self.rates
.get(key)
.map(|&pixel_rate| pixel_rate / f64::from(pixels.max(1)))
}
#[must_use]
pub fn worker(&self, info: &WorkerInfo, pixels: u32) -> Option<f64> {
self.get(&LaneKey::for_worker(info), pixels)
}
pub fn set(&mut self, key: LaneKey, pixels: u32, rate: f64) {
self.rates.insert(key, rate * f64::from(pixels.max(1)));
}
}
pub struct Coordinator {
registry: Option<Arc<Registry>>,
own: Option<OwnLaneSetup>,
interactive_workers: u32,
interactive_pin: Option<InteractivePin>,
budget: MemoryBudget,
queues: ViewerQueues,
config: Mutex<JobConfig>,
assets: Option<Arc<AssetCache>>,
rates: Arc<Mutex<RateBook>>,
}
impl Coordinator {
#[must_use]
pub fn new(
registry: Option<Arc<Registry>>,
own: Option<OwnLaneSetup>,
interactive_workers: u32,
max_job_bytes: u64,
) -> Self {
Self {
registry,
own,
interactive_workers,
interactive_pin: None,
budget: MemoryBudget::new(max_job_bytes),
queues: ViewerQueues::default(),
config: Mutex::new(JobConfig::default()),
assets: None,
rates: Arc::new(Mutex::new(RateBook::default())),
}
}
#[must_use]
pub fn with_assets(mut self, assets: Option<Arc<AssetCache>>) -> Self {
self.assets = assets;
self
}
#[must_use]
pub fn with_small_pictures(
self,
whole_image_secs: f64,
whole_image_pixel_samples: u64,
jobs_per_viewer: u32,
) -> Self {
self.set_job_config(JobConfig {
whole_image_secs,
whole_image_pixel_samples,
jobs_per_viewer: jobs_per_viewer.max(1),
..self.job_config()
});
self
}
#[must_use]
pub const fn assets(&self) -> Option<&Arc<AssetCache>> {
self.assets.as_ref()
}
#[must_use]
pub fn with_interactive_pin(mut self, label: Option<String>) -> Self {
self.interactive_pin = label.map(InteractivePin::new);
self
}
#[must_use]
pub const fn interactive_pin(&self) -> Option<&InteractivePin> {
self.interactive_pin.as_ref()
}
#[must_use]
pub fn job_config(&self) -> JobConfig {
*self.config.lock().unwrap_or_else(PoisonError::into_inner)
}
pub fn set_job_config(&self, config: JobConfig) {
*self.config.lock().unwrap_or_else(PoisonError::into_inner) = config;
}
#[must_use]
pub const fn registry(&self) -> Option<&Arc<Registry>> {
self.registry.as_ref()
}
#[must_use]
pub const fn own(&self) -> Option<&OwnLaneSetup> {
self.own.as_ref()
}
#[must_use]
pub const fn budget(&self) -> &MemoryBudget {
&self.budget
}
#[must_use]
pub const fn rates(&self) -> &Arc<Mutex<RateBook>> {
&self.rates
}
}
pub struct ViewerSession {
pub coordinator: Arc<Coordinator>,
pub viewer: Arc<str>,
pub payload_encoding: PayloadEncoding,
pub link: Option<Arc<PeerLink>>,
pub advertised: Option<RenderCapability>,
pub own_capability: Option<RenderCapability>,
pub rates: Arc<Mutex<RateBook>>,
}
fn write_error<S: Write>(stream: &mut S, error: ErrorMsg) -> Result<(), NetError> {
tracing::info!("coordinator: refusing/failing a request: {}", error.message);
indicatrix_net::messages::write_stream_event(stream, &StreamEvent::Error(error), None)
}
fn report<S: Write>(stream: &mut S, outcome: StreamOutcome) -> Result<(), NetError> {
match outcome {
StreamOutcome::Completed => Ok(()),
StreamOutcome::TracePanicked => write_error(
stream,
ErrorMsg {
code: error_codes::TRACE_PANIC,
message: "internal error while tracing this request".to_string(),
request_id: None,
},
),
StreamOutcome::Failed(error) => write_error(stream, error),
}
}
pub fn serve_render<S: Read + Write + TimeoutRead + TimeoutWrite>(
stream: &mut S,
mut request: RenderRequest,
session: &ViewerSession,
asset: Option<Arc<HeldAsset>>,
) -> Result<Option<RenderRequest>, NetError> {
if let Err(message) =
validate::validate_request(&request.scene, request.first_sample, request.samples)
.and_then(|()| validate::validate_stream_config(&mut request.stream, &request.scene))
{
write_error(
stream,
ErrorMsg {
code: error_codes::VALIDATION_FAILED,
message,
request_id: Some(request.request_id),
},
)?;
return Ok(None);
}
let ask = Ask {
intent: request.intent,
transfer_mode: request.stream.transfer_mode,
pixels: request.scene.width * request.scene.height,
samples: request.samples,
hdr: request.scene.hdr().is_some(),
};
stream_request(
stream,
&request,
Output::Radiance,
ask,
session,
asset,
None,
)
}
pub fn serve_final_image<S: Read + Write + TimeoutRead + TimeoutWrite>(
stream: &mut S,
request: &FinalImageRequest,
session: &ViewerSession,
asset: Option<Arc<HeldAsset>>,
) -> Result<Option<RenderRequest>, NetError> {
let checked = if request.output_matches_scene() {
validate::validate_request(&request.scene, request.first_sample, request.samples)
} else {
Err(format!(
"FinalImageRequest output {}x{} must equal the scene's {}x{} (no server-side scaling in v14)",
request.width, request.height, request.scene.width, request.scene.height
))
};
let checked = checked.and_then(|()| {
if request.viewer_share_valid() {
Ok(())
} else {
Err(format!(
"FinalImageRequest viewer_samples ({}) must be at most half of samples ({})",
request.viewer_samples, request.samples
))
}
});
if let Err(message) = checked {
write_error(
stream,
ErrorMsg {
code: error_codes::VALIDATION_FAILED,
message,
request_id: Some(request.request_id),
},
)?;
return Ok(None);
}
let slot = request.reserved_range().map(|(first, samples)| {
Arc::new(stream_emit::ContributionSlot::new(
SampleRange::new(first, samples),
request.width,
request.height,
))
});
let as_render = RenderRequest {
request_id: request.request_id,
scene: request.scene.clone(),
first_sample: request.first_sample,
samples: request.samples,
stream: StreamConfig {
transfer_mode: TransferMode::FinalOnly,
cadence_ms: 1000,
preview: Some(final_image_preview_config(request.width, request.height)),
},
intent: RequestIntent::Batch,
};
let ask = Ask {
intent: RequestIntent::Batch,
transfer_mode: TransferMode::FinalOnly,
pixels: request.scene.width * request.scene.height,
samples: request.server_samples(),
hdr: request.scene.hdr().is_some(),
};
let output = Output::FinalImage(request.color_space.into());
stream_request(
stream,
&as_render,
output,
ask,
session,
asset,
slot.as_ref(),
)
}
const FINAL_IMAGE_PREVIEW_MAX_LONG_EDGE: u32 = 360;
#[must_use]
fn final_image_preview_config(width: u32, height: u32) -> PreviewConfig {
let long_edge = width.max(height).max(1);
let scale = (f64::from(FINAL_IMAGE_PREVIEW_MAX_LONG_EDGE) / f64::from(long_edge)).min(1.0);
PreviewConfig {
width: ((f64::from(width) * scale).round() as u32).max(1),
height: ((f64::from(height) * scale).round() as u32).max(1),
}
}
fn stream_request<S: Read + Write + TimeoutRead + TimeoutWrite>(
stream: &mut S,
request: &RenderRequest,
output: Output,
ask: Ask,
session: &ViewerSession,
asset: Option<Arc<HeldAsset>>,
slot: Option<&Arc<stream_emit::ContributionSlot>>,
) -> Result<Option<RenderRequest>, NetError> {
let started = Instant::now();
let coordinator = &session.coordinator;
if ask.hdr && asset.is_none() {
write_error(
stream,
ErrorMsg {
code: error_codes::ASSET_FAILED,
message: "internal error: the coordinator does not hold this scene's HDR map"
.to_string(),
request_id: Some(request.request_id),
},
)?;
return Ok(None);
}
let mut route = match plan::plan(coordinator, ask) {
Ok(route) => route,
Err(refusal) => {
write_error(stream, refusal)?;
return Ok(None);
}
};
if slot.is_some() && matches!(route, Route::Direct) {
route = Route::Job(JobPlan {
own: true,
workers: WorkerPick::None,
fifo: true,
whole_image: false,
pool: coordinator.job_config().batch,
});
}
let direct = matches!(route, Route::Direct);
let spec = StreamSpec {
request,
payload_encoding: session.payload_encoding,
link: session.link.as_ref(),
output,
contribution: slot.map(Arc::as_ref),
stall_timeout: direct.then_some(stream_emit::PRODUCER_STALL_TIMEOUT),
};
let lanes_run = Arc::new(AtomicU32::new(0));
let (outcome, next) = match (route, coordinator.own.as_ref()) {
(Route::Direct, Some(own)) => stream_emit::run_stream_with(
stream,
&spec,
stream_emit::local_tracer(request, own.threads, &own.gpu, own.compute_mode),
)?,
(Route::Job(plan), _) => {
let viewer_samples = slot.map_or(0, |s| s.reserved().samples);
let job = producer::Job {
coordinator: Arc::clone(coordinator),
viewer: Arc::clone(&session.viewer),
rates: Arc::clone(&session.rates),
scene: request.scene.clone(),
range: SampleRange::new(request.first_sample, request.samples - viewer_samples),
plan,
asset,
contribution: slot.cloned(),
lanes_run: Arc::clone(&lanes_run),
};
stream_emit::run_stream_with(stream, &spec, move |sink| producer::run(&job, sink))?
}
(Route::Direct, None) => {
write_error(
stream,
ErrorMsg {
code: error_codes::NO_RENDER_CAPACITY,
message: "internal error: the coordinator planned a direct route with no own \
render lane"
.to_string(),
request_id: Some(request.request_id),
},
)?;
return Ok(None);
}
};
let how = served::Served::new(route, lanes_run.load(Ordering::Relaxed));
served::log(request, ask, how, started.elapsed(), &outcome);
report(stream, outcome)?;
Ok(next)
}
pub(super) fn over_budget(coordinator: &Coordinator, bytes: u64) -> ErrorMsg {
const MIB: u64 = 1024 * 1024;
ErrorMsg {
code: error_codes::CONNECTION_LIMIT_REACHED,
request_id: None,
message: format!(
"coordinator busy: this job needs {} MiB of in-flight buffers but {} of {} MiB are already in \
use (--max-job-memory-mib); try again later",
bytes.div_ceil(MIB),
coordinator.budget.in_use().div_ceil(MIB),
coordinator.budget.cap() / MIB
),
}
}
#[cfg(test)]
mod tests;