implements PLN-0093

This commit is contained in:
2026-06-05 09:47:49 +01:00
parent 3521eec319
commit c88c927fee
5 changed files with 258 additions and 3 deletions
@@ -29,6 +29,23 @@ pub struct TelemetryFrame {
// Log Pressure from the last completed logical frame
pub logs_count: u32,
// Render handoff/presentation telemetry
pub produced_submissions: u64,
pub replaced_before_consume: u64,
pub consumed_submissions: u64,
pub presented_frames: u64,
pub repeated_presents: u64,
pub render_errors: u64,
pub present_errors: u64,
pub stale_epoch_discards: u64,
pub shutdown_discards: u64,
pub last_produced_frame_id: u64,
pub last_consumed_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,
}
/// Thread-safe, atomic telemetry storage for real-time monitoring by the host.
@@ -62,6 +79,23 @@ pub struct AtomicTelemetry {
pub current_logs_count: Arc<AtomicU32>,
// Persisted log count from the last completed logical frame
pub logs_count: AtomicU32,
// Render handoff/presentation telemetry
pub produced_submissions: AtomicU64,
pub replaced_before_consume: AtomicU64,
pub consumed_submissions: AtomicU64,
pub presented_frames: AtomicU64,
pub repeated_presents: AtomicU64,
pub render_errors: AtomicU64,
pub present_errors: AtomicU64,
pub stale_epoch_discards: AtomicU64,
pub shutdown_discards: AtomicU64,
pub last_produced_frame_id: AtomicU64,
pub last_consumed_frame_id: AtomicU64,
pub last_presented_frame_id: AtomicU64,
pub last_dropped_frame_id: AtomicU64,
pub last_error_frame_id: AtomicU64,
pub active_render_epoch: AtomicU64,
}
impl AtomicTelemetry {
@@ -91,6 +125,21 @@ impl AtomicTelemetry {
vm_string_materializations: self.vm_string_materializations.load(Ordering::Relaxed),
logs_count: self.logs_count.load(Ordering::Relaxed),
vm_steps: self.vm_steps.load(Ordering::Relaxed),
produced_submissions: self.produced_submissions.load(Ordering::Relaxed),
replaced_before_consume: self.replaced_before_consume.load(Ordering::Relaxed),
consumed_submissions: self.consumed_submissions.load(Ordering::Relaxed),
presented_frames: self.presented_frames.load(Ordering::Relaxed),
repeated_presents: self.repeated_presents.load(Ordering::Relaxed),
render_errors: self.render_errors.load(Ordering::Relaxed),
present_errors: self.present_errors.load(Ordering::Relaxed),
stale_epoch_discards: self.stale_epoch_discards.load(Ordering::Relaxed),
shutdown_discards: self.shutdown_discards.load(Ordering::Relaxed),
last_produced_frame_id: self.last_produced_frame_id.load(Ordering::Relaxed),
last_consumed_frame_id: self.last_consumed_frame_id.load(Ordering::Relaxed),
last_presented_frame_id: self.last_presented_frame_id.load(Ordering::Relaxed),
last_dropped_frame_id: self.last_dropped_frame_id.load(Ordering::Relaxed),
last_error_frame_id: self.last_error_frame_id.load(Ordering::Relaxed),
active_render_epoch: self.active_render_epoch.load(Ordering::Relaxed),
}
}
@@ -113,6 +162,21 @@ impl AtomicTelemetry {
self.vm_steps.store(0, Ordering::Relaxed);
self.logs_count.store(0, Ordering::Relaxed);
self.current_logs_count.store(0, Ordering::Relaxed);
self.produced_submissions.store(0, Ordering::Relaxed);
self.replaced_before_consume.store(0, Ordering::Relaxed);
self.consumed_submissions.store(0, Ordering::Relaxed);
self.presented_frames.store(0, Ordering::Relaxed);
self.repeated_presents.store(0, Ordering::Relaxed);
self.render_errors.store(0, Ordering::Relaxed);
self.present_errors.store(0, Ordering::Relaxed);
self.stale_epoch_discards.store(0, Ordering::Relaxed);
self.shutdown_discards.store(0, Ordering::Relaxed);
self.last_produced_frame_id.store(0, Ordering::Relaxed);
self.last_consumed_frame_id.store(0, Ordering::Relaxed);
self.last_presented_frame_id.store(0, Ordering::Relaxed);
self.last_dropped_frame_id.store(0, Ordering::Relaxed);
self.last_error_frame_id.store(0, Ordering::Relaxed);
self.active_render_epoch.store(0, Ordering::Relaxed);
}
}
@@ -1,8 +1,10 @@
use prometeu_hal::app_mode::AppMode;
use prometeu_hal::telemetry::AtomicTelemetry;
use prometeu_hal::{
FrameId, Game2DFramePacket, RenderOwnership, RenderSubmission, RenderSubmissionPacket,
ShellUiFramePacket,
};
use std::sync::atomic::Ordering;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RenderTransitionState {
@@ -59,6 +61,78 @@ pub trait RenderSurface {
fn consume_submission(&mut self, submission: &RenderSubmission);
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct RenderTelemetrySnapshot {
pub produced_submissions: u64,
pub replaced_before_consume: u64,
pub consumed_submissions: u64,
pub presented_frames: u64,
pub repeated_presents: u64,
pub render_errors: u64,
pub present_errors: u64,
pub stale_epoch_discards: u64,
pub shutdown_discards: u64,
pub last_produced_frame_id: u64,
pub last_consumed_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,
}
#[derive(Debug, Clone, Default)]
struct RenderTelemetry {
snapshot: RenderTelemetrySnapshot,
}
impl RenderTelemetry {
fn record_produced(&mut self, frame_id: FrameId) {
self.snapshot.produced_submissions = self.snapshot.produced_submissions.wrapping_add(1);
self.snapshot.last_produced_frame_id = frame_id.get();
}
fn record_replaced_before_consume(&mut self, frame_id: FrameId) {
self.snapshot.replaced_before_consume =
self.snapshot.replaced_before_consume.wrapping_add(1);
self.snapshot.last_dropped_frame_id = frame_id.get();
}
fn record_consumed(&mut self, frame_id: FrameId) {
self.snapshot.consumed_submissions = self.snapshot.consumed_submissions.wrapping_add(1);
self.snapshot.last_consumed_frame_id = frame_id.get();
}
fn record_presented(&mut self, frame_id: FrameId) {
self.snapshot.presented_frames = self.snapshot.presented_frames.wrapping_add(1);
self.snapshot.last_presented_frame_id = frame_id.get();
}
fn record_repeated_present(&mut self, frame_id: FrameId) {
self.snapshot.repeated_presents = self.snapshot.repeated_presents.wrapping_add(1);
self.snapshot.last_presented_frame_id = frame_id.get();
}
fn record_render_error(&mut self, frame_id: FrameId) {
self.snapshot.render_errors = self.snapshot.render_errors.wrapping_add(1);
self.snapshot.last_error_frame_id = frame_id.get();
}
fn record_present_error(&mut self, frame_id: FrameId) {
self.snapshot.present_errors = self.snapshot.present_errors.wrapping_add(1);
self.snapshot.last_error_frame_id = frame_id.get();
}
fn record_stale_epoch_discard(&mut self, frame_id: FrameId) {
self.snapshot.stale_epoch_discards = self.snapshot.stale_epoch_discards.wrapping_add(1);
self.snapshot.last_dropped_frame_id = frame_id.get();
}
fn record_shutdown_discard(&mut self, frame_id: FrameId) {
self.snapshot.shutdown_discards = self.snapshot.shutdown_discards.wrapping_add(1);
self.snapshot.last_dropped_frame_id = frame_id.get();
}
}
#[derive(Debug, Clone, Default)]
pub struct RenderHandoff {
pending: Option<RenderSubmission>,
@@ -125,6 +199,7 @@ pub struct RenderManager {
active_policy: RenderPolicy,
next_frame_id: FrameId,
handoff: RenderHandoff,
telemetry: RenderTelemetry,
transition_state: RenderTransitionState,
}
@@ -137,6 +212,7 @@ impl RenderManager {
active_policy: RenderPolicy::for_app_mode(active_app_mode),
next_frame_id: FrameId::ZERO,
handoff: RenderHandoff::default(),
telemetry: RenderTelemetry::default(),
transition_state: RenderTransitionState::Idle,
}
}
@@ -182,7 +258,52 @@ impl RenderManager {
}
pub fn discard_pending_submission(&mut self) -> Option<RenderSubmission> {
self.handoff.discard_pending()
let discarded = self.handoff.discard_pending();
if let Some(submission) = discarded.as_ref() {
self.telemetry.record_shutdown_discard(submission.frame_id);
}
discarded
}
pub fn render_telemetry(&self) -> RenderTelemetrySnapshot {
let mut snapshot = self.telemetry.snapshot;
snapshot.active_render_epoch = self.active_ownership.epoch;
snapshot
}
pub fn sync_telemetry(&self, telemetry: &AtomicTelemetry) {
let snapshot = self.render_telemetry();
telemetry.produced_submissions.store(snapshot.produced_submissions, Ordering::Relaxed);
telemetry
.replaced_before_consume
.store(snapshot.replaced_before_consume, Ordering::Relaxed);
telemetry.consumed_submissions.store(snapshot.consumed_submissions, Ordering::Relaxed);
telemetry.presented_frames.store(snapshot.presented_frames, Ordering::Relaxed);
telemetry.repeated_presents.store(snapshot.repeated_presents, Ordering::Relaxed);
telemetry.render_errors.store(snapshot.render_errors, Ordering::Relaxed);
telemetry.present_errors.store(snapshot.present_errors, Ordering::Relaxed);
telemetry.stale_epoch_discards.store(snapshot.stale_epoch_discards, Ordering::Relaxed);
telemetry.shutdown_discards.store(snapshot.shutdown_discards, Ordering::Relaxed);
telemetry.last_produced_frame_id.store(snapshot.last_produced_frame_id, Ordering::Relaxed);
telemetry.last_consumed_frame_id.store(snapshot.last_consumed_frame_id, Ordering::Relaxed);
telemetry
.last_presented_frame_id
.store(snapshot.last_presented_frame_id, Ordering::Relaxed);
telemetry.last_dropped_frame_id.store(snapshot.last_dropped_frame_id, Ordering::Relaxed);
telemetry.last_error_frame_id.store(snapshot.last_error_frame_id, Ordering::Relaxed);
telemetry.active_render_epoch.store(snapshot.active_render_epoch, Ordering::Relaxed);
}
pub fn record_repeated_present(&mut self, frame_id: FrameId) {
self.telemetry.record_repeated_present(frame_id);
}
pub fn record_render_error(&mut self, frame_id: FrameId) {
self.telemetry.record_render_error(frame_id);
}
pub fn record_present_error(&mut self, frame_id: FrameId) {
self.telemetry.record_present_error(frame_id);
}
pub fn set_active_app_mode(&mut self, app_mode: AppMode) {
@@ -226,6 +347,10 @@ impl RenderManager {
};
self.next_frame_id = self.next_frame_id.next();
if let Some(replaced) = self.handoff.pending_submission() {
self.telemetry.record_replaced_before_consume(replaced.frame_id);
}
self.telemetry.record_produced(frame_id);
self.handoff.publish(submission);
Ok(self.handoff.pending_submission().expect("submission was just stored"))
}
@@ -244,10 +369,13 @@ impl RenderManager {
return false;
};
if submission.ownership != self.active_ownership {
self.telemetry.record_stale_epoch_discard(submission.frame_id);
self.handoff.record_stale_epoch_discard(submission);
return false;
}
self.telemetry.record_consumed(submission.frame_id);
surface.consume_submission(&submission);
self.telemetry.record_presented(submission.frame_id);
self.handoff.record_consumed(submission);
true
}
@@ -262,6 +390,8 @@ impl Default for RenderManager {
#[cfg(test)]
mod tests {
use super::*;
use std::sync::Arc;
use std::sync::atomic::AtomicU32;
#[derive(Default)]
struct RecordingSurface {
@@ -460,4 +590,64 @@ mod tests {
RenderOwnership::new(0, AppMode::Game, 0)
);
}
#[test]
fn render_telemetry_counts_produced_replaced_consumed_and_presented() {
let mut manager = RenderManager::new(AppMode::Game);
let mut surface = RecordingSurface::default();
manager.close_compat_frame();
manager.close_compat_frame();
assert!(manager.publish_latest(&mut surface));
let telemetry = manager.render_telemetry();
assert_eq!(telemetry.produced_submissions, 2);
assert_eq!(telemetry.replaced_before_consume, 1);
assert_eq!(telemetry.consumed_submissions, 1);
assert_eq!(telemetry.presented_frames, 1);
assert_eq!(telemetry.last_produced_frame_id, 1);
assert_eq!(telemetry.last_dropped_frame_id, 0);
assert_eq!(telemetry.last_consumed_frame_id, 1);
assert_eq!(telemetry.last_presented_frame_id, 1);
}
#[test]
fn render_telemetry_counts_stale_repeat_and_error_hooks() {
let mut manager = RenderManager::new(AppMode::Game);
let mut surface = RecordingSurface::default();
manager.close_compat_frame();
manager.transition_render_owner(AppMode::Shell, 1);
assert!(!manager.publish_latest(&mut surface));
manager.record_repeated_present(FrameId::new(9));
manager.record_render_error(FrameId::new(10));
manager.record_present_error(FrameId::new(11));
let telemetry = manager.render_telemetry();
assert_eq!(telemetry.stale_epoch_discards, 1);
assert_eq!(telemetry.repeated_presents, 1);
assert_eq!(telemetry.render_errors, 1);
assert_eq!(telemetry.present_errors, 1);
assert_eq!(telemetry.last_presented_frame_id, 9);
assert_eq!(telemetry.last_error_frame_id, 11);
}
#[test]
fn render_telemetry_syncs_to_atomic_telemetry() {
let mut manager = RenderManager::new(AppMode::Game);
let mut surface = RecordingSurface::default();
let atomic = AtomicTelemetry::new(Arc::new(AtomicU32::new(0)));
manager.transition_render_owner(AppMode::Game, 5);
manager.close_compat_frame();
assert!(manager.publish_latest(&mut surface));
manager.sync_telemetry(&atomic);
let snapshot = atomic.snapshot();
assert_eq!(snapshot.produced_submissions, 1);
assert_eq!(snapshot.consumed_submissions, 1);
assert_eq!(snapshot.presented_frames, 1);
assert_eq!(snapshot.last_presented_frame_id, 0);
assert_eq!(snapshot.active_render_epoch, 1);
}
}
@@ -304,6 +304,7 @@ impl VirtualMachineRuntime {
self.atomic_telemetry
.host_cpu_time_us
.store(start.elapsed().as_micros() as u64, Ordering::Relaxed);
self.render_manager.sync_telemetry(&self.atomic_telemetry);
let current_frame_logs =
self.atomic_telemetry.current_logs_count.load(Ordering::Relaxed);