204 lines
6.9 KiB
Rust
204 lines
6.9 KiB
Rust
use std::fmt;
|
|
|
|
use crate::{OwnedRgba8888Frame, RenderSubmission};
|
|
|
|
/// Typed failure surface for the real render worker and its backend.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub enum RenderWorkerError {
|
|
BackendUnavailable,
|
|
RenderFailed,
|
|
PublishFailed,
|
|
PresentFailed,
|
|
ShutdownTimeout,
|
|
StaleSubmissionDiscarded,
|
|
WorkerPanic,
|
|
InternalFailure,
|
|
}
|
|
|
|
impl fmt::Display for RenderWorkerError {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
match self {
|
|
Self::BackendUnavailable => f.write_str("render backend unavailable"),
|
|
Self::RenderFailed => f.write_str("render failed"),
|
|
Self::PublishFailed => f.write_str("render publish failed"),
|
|
Self::PresentFailed => f.write_str("render present failed"),
|
|
Self::ShutdownTimeout => f.write_str("render worker shutdown timed out"),
|
|
Self::StaleSubmissionDiscarded => f.write_str("stale render submission discarded"),
|
|
Self::WorkerPanic => f.write_str("render worker panicked"),
|
|
Self::InternalFailure => f.write_str("internal render worker failure"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl std::error::Error for RenderWorkerError {}
|
|
|
|
pub trait RenderWorkerBackend: Send + 'static {
|
|
fn render(
|
|
&self,
|
|
submission: &RenderSubmission,
|
|
) -> Result<OwnedRgba8888Frame, RenderWorkerError>;
|
|
}
|
|
|
|
pub trait RenderWorkerFrameSink: Send + 'static {
|
|
fn publish(&self, frame: OwnedRgba8888Frame) -> Result<(), RenderWorkerError>;
|
|
}
|
|
|
|
/// Snapshot of render worker handoff, render, publish, and shutdown counters.
|
|
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
|
|
pub struct RenderWorkerTelemetry {
|
|
pub produced_submissions: u64,
|
|
pub replaced_before_consume: u64,
|
|
pub consumed_submissions: u64,
|
|
pub published_frames: u64,
|
|
pub presented_frames: u64,
|
|
pub repeated_frames: u64,
|
|
pub stale_submission_discards: u64,
|
|
pub render_failures: u64,
|
|
pub publish_failures: u64,
|
|
pub present_failures: u64,
|
|
pub shutdown_timeouts: u64,
|
|
pub worker_panics: u64,
|
|
pub last_produced_frame_id: u64,
|
|
pub last_consumed_frame_id: u64,
|
|
pub last_published_frame_id: u64,
|
|
pub last_presented_frame_id: u64,
|
|
pub last_dropped_frame_id: u64,
|
|
pub last_error_frame_id: u64,
|
|
pub active_render_epoch: u64,
|
|
}
|
|
|
|
impl RenderWorkerTelemetry {
|
|
pub fn record_produced(&mut self, frame_id: u64) {
|
|
self.produced_submissions += 1;
|
|
self.last_produced_frame_id = frame_id;
|
|
}
|
|
|
|
pub fn record_replaced_before_consume(&mut self, frame_id: u64) {
|
|
self.replaced_before_consume += 1;
|
|
self.last_dropped_frame_id = frame_id;
|
|
}
|
|
|
|
pub fn record_consumed(&mut self, frame_id: u64) {
|
|
self.consumed_submissions += 1;
|
|
self.last_consumed_frame_id = frame_id;
|
|
}
|
|
|
|
pub fn record_published(&mut self, frame_id: u64) {
|
|
self.published_frames += 1;
|
|
self.last_published_frame_id = frame_id;
|
|
}
|
|
|
|
pub fn record_presented(&mut self, frame_id: u64) {
|
|
self.presented_frames += 1;
|
|
self.last_presented_frame_id = frame_id;
|
|
}
|
|
|
|
pub fn record_repeated_frame(&mut self, frame_id: u64) {
|
|
self.repeated_frames += 1;
|
|
self.last_presented_frame_id = frame_id;
|
|
}
|
|
|
|
pub fn record_stale_submission_discarded(&mut self, frame_id: u64) {
|
|
self.stale_submission_discards += 1;
|
|
self.last_dropped_frame_id = frame_id;
|
|
}
|
|
|
|
pub fn record_error(&mut self, error: RenderWorkerError, frame_id: u64) {
|
|
match error {
|
|
RenderWorkerError::BackendUnavailable | RenderWorkerError::RenderFailed => {
|
|
self.render_failures += 1;
|
|
}
|
|
RenderWorkerError::PublishFailed => {
|
|
self.publish_failures += 1;
|
|
}
|
|
RenderWorkerError::PresentFailed => {
|
|
self.present_failures += 1;
|
|
}
|
|
RenderWorkerError::ShutdownTimeout => {
|
|
self.shutdown_timeouts += 1;
|
|
}
|
|
RenderWorkerError::WorkerPanic => {
|
|
self.worker_panics += 1;
|
|
}
|
|
RenderWorkerError::StaleSubmissionDiscarded => {
|
|
self.stale_submission_discards += 1;
|
|
self.last_dropped_frame_id = frame_id;
|
|
}
|
|
RenderWorkerError::InternalFailure => {
|
|
self.render_failures += 1;
|
|
}
|
|
}
|
|
self.last_error_frame_id = frame_id;
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn render_worker_error_is_copy_equatable_and_debuggable() {
|
|
let error = RenderWorkerError::ShutdownTimeout;
|
|
let copied = error;
|
|
|
|
assert_eq!(copied, RenderWorkerError::ShutdownTimeout);
|
|
assert_eq!(format!("{:?}", error), "ShutdownTimeout");
|
|
assert_eq!(error.to_string(), "render worker shutdown timed out");
|
|
}
|
|
|
|
#[test]
|
|
fn render_worker_telemetry_defaults_to_zero() {
|
|
assert_eq!(
|
|
RenderWorkerTelemetry::default(),
|
|
RenderWorkerTelemetry {
|
|
produced_submissions: 0,
|
|
replaced_before_consume: 0,
|
|
consumed_submissions: 0,
|
|
published_frames: 0,
|
|
presented_frames: 0,
|
|
repeated_frames: 0,
|
|
stale_submission_discards: 0,
|
|
render_failures: 0,
|
|
publish_failures: 0,
|
|
present_failures: 0,
|
|
shutdown_timeouts: 0,
|
|
worker_panics: 0,
|
|
last_produced_frame_id: 0,
|
|
last_consumed_frame_id: 0,
|
|
last_published_frame_id: 0,
|
|
last_presented_frame_id: 0,
|
|
last_dropped_frame_id: 0,
|
|
last_error_frame_id: 0,
|
|
active_render_epoch: 0,
|
|
}
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn render_worker_telemetry_records_counters_and_frame_ids() {
|
|
let mut telemetry = RenderWorkerTelemetry::default();
|
|
|
|
telemetry.record_produced(10);
|
|
telemetry.record_replaced_before_consume(10);
|
|
telemetry.record_consumed(11);
|
|
telemetry.record_published(11);
|
|
telemetry.record_presented(11);
|
|
telemetry.record_repeated_frame(11);
|
|
telemetry.record_error(RenderWorkerError::PublishFailed, 12);
|
|
telemetry.record_error(RenderWorkerError::WorkerPanic, 13);
|
|
telemetry.record_stale_submission_discarded(14);
|
|
|
|
assert_eq!(telemetry.produced_submissions, 1);
|
|
assert_eq!(telemetry.replaced_before_consume, 1);
|
|
assert_eq!(telemetry.consumed_submissions, 1);
|
|
assert_eq!(telemetry.published_frames, 1);
|
|
assert_eq!(telemetry.presented_frames, 1);
|
|
assert_eq!(telemetry.repeated_frames, 1);
|
|
assert_eq!(telemetry.publish_failures, 1);
|
|
assert_eq!(telemetry.worker_panics, 1);
|
|
assert_eq!(telemetry.stale_submission_discards, 1);
|
|
assert_eq!(telemetry.last_error_frame_id, 13);
|
|
assert_eq!(telemetry.last_dropped_frame_id, 14);
|
|
}
|
|
}
|