implements PLN-0092

This commit is contained in:
2026-06-05 09:44:29 +01:00
parent dcfc258aeb
commit 3521eec319
7 changed files with 135 additions and 16 deletions
@@ -156,7 +156,7 @@ impl VirtualMachineRuntime {
self.current_cartridge_title = cartridge.title.clone();
self.current_cartridge_app_version = cartridge.app_version.clone();
self.current_cartridge_app_mode = cartridge.app_mode;
self.render_manager.set_active_app_mode(cartridge.app_mode);
self.render_manager.transition_render_owner(cartridge.app_mode, cartridge.app_id);
Ok(())
}
Err(e) => {
@@ -1,12 +1,13 @@
use prometeu_hal::app_mode::AppMode;
use prometeu_hal::{
FrameId, Game2DFramePacket, RenderSubmission, RenderSubmissionPacket, ShellUiFramePacket,
FrameId, Game2DFramePacket, RenderOwnership, RenderSubmission, RenderSubmissionPacket,
ShellUiFramePacket,
};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RenderTransitionState {
Idle,
Pending { from: AppMode, to: AppMode },
Pending { from: RenderOwnership, to: RenderOwnership },
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -64,6 +65,7 @@ pub struct RenderHandoff {
last_consumed: Option<RenderSubmission>,
replaced_before_consume: u64,
discarded_pending: u64,
stale_epoch_discards: u64,
}
impl RenderHandoff {
@@ -89,6 +91,11 @@ impl RenderHandoff {
self.last_consumed = Some(submission);
}
pub fn record_stale_epoch_discard(&mut self, submission: RenderSubmission) {
self.stale_epoch_discards = self.stale_epoch_discards.wrapping_add(1);
self.last_consumed = Some(submission);
}
pub fn discard_pending(&mut self) -> Option<RenderSubmission> {
let discarded = self.pending.take();
if discarded.is_some() {
@@ -104,11 +111,17 @@ impl RenderHandoff {
pub fn discarded_pending(&self) -> u64 {
self.discarded_pending
}
pub fn stale_epoch_discards(&self) -> u64 {
self.stale_epoch_discards
}
}
#[derive(Debug, Clone)]
pub struct RenderManager {
active_app_mode: AppMode,
active_app_id: u32,
active_ownership: RenderOwnership,
active_policy: RenderPolicy,
next_frame_id: FrameId,
handoff: RenderHandoff,
@@ -119,6 +132,8 @@ impl RenderManager {
pub fn new(active_app_mode: AppMode) -> Self {
Self {
active_app_mode,
active_app_id: 0,
active_ownership: RenderOwnership::new(0, active_app_mode, 0),
active_policy: RenderPolicy::for_app_mode(active_app_mode),
next_frame_id: FrameId::ZERO,
handoff: RenderHandoff::default(),
@@ -130,6 +145,10 @@ impl RenderManager {
self.active_app_mode
}
pub fn active_ownership(&self) -> RenderOwnership {
self.active_ownership
}
pub fn active_render_policy(&self) -> RenderPolicy {
self.active_policy
}
@@ -158,19 +177,31 @@ impl RenderManager {
self.handoff.discarded_pending()
}
pub fn stale_epoch_discards(&self) -> u64 {
self.handoff.stale_epoch_discards()
}
pub fn discard_pending_submission(&mut self) -> Option<RenderSubmission> {
self.handoff.discard_pending()
}
pub fn set_active_app_mode(&mut self, app_mode: AppMode) {
if self.active_app_mode == app_mode {
self.transition_render_owner(app_mode, self.active_app_id);
}
pub fn transition_render_owner(&mut self, app_mode: AppMode, app_id: u32) {
if self.active_app_mode == app_mode && self.active_app_id == app_id {
return;
}
let previous = self.active_app_mode;
let previous = self.active_ownership;
self.active_app_mode = app_mode;
self.active_app_id = app_id;
self.active_ownership =
RenderOwnership::new(self.active_ownership.epoch.wrapping_add(1), app_mode, app_id);
self.active_policy = RenderPolicy::for_app_mode(app_mode);
self.transition_state = RenderTransitionState::Pending { from: previous, to: app_mode };
self.transition_state =
RenderTransitionState::Pending { from: previous, to: self.active_ownership };
}
pub fn acknowledge_transition(&mut self) {
@@ -184,10 +215,10 @@ impl RenderManager {
let frame_id = self.next_frame_id;
let submission = match (self.active_app_mode, packet) {
(AppMode::Game, RenderSubmissionPacket::Game2D(packet)) => {
RenderSubmission::game2d(frame_id, packet)
RenderSubmission::game2d(frame_id, packet).with_ownership(self.active_ownership)
}
(AppMode::Shell, RenderSubmissionPacket::ShellUi(packet)) => {
RenderSubmission::shell_ui(frame_id, packet)
RenderSubmission::shell_ui(frame_id, packet).with_ownership(self.active_ownership)
}
(active, _) => {
return Err(RenderSubmissionError::PacketAppModeMismatch { active });
@@ -212,6 +243,10 @@ impl RenderManager {
let Some(submission) = self.handoff.take_latest() else {
return false;
};
if submission.ownership != self.active_ownership {
self.handoff.record_stale_epoch_discard(submission);
return false;
}
surface.consume_submission(&submission);
self.handoff.record_consumed(submission);
true
@@ -277,19 +312,45 @@ mod tests {
#[test]
fn app_mode_switch_records_noop_transition_placeholder() {
let mut manager = RenderManager::new(AppMode::Game);
let previous = manager.active_ownership();
manager.set_active_app_mode(AppMode::Shell);
assert_eq!(manager.active_app_mode(), AppMode::Shell);
assert_eq!(
manager.transition_state(),
RenderTransitionState::Pending { from: AppMode::Game, to: AppMode::Shell }
RenderTransitionState::Pending {
from: previous,
to: RenderOwnership::new(1, AppMode::Shell, 0)
}
);
manager.acknowledge_transition();
assert_eq!(manager.transition_state(), RenderTransitionState::Idle);
}
#[test]
fn transition_render_owner_increments_epoch_for_same_mode_app_swap() {
let mut manager = RenderManager::new(AppMode::Game);
manager.transition_render_owner(AppMode::Game, 7);
let first_owner = manager.active_ownership();
manager.transition_render_owner(AppMode::Game, 8);
assert_eq!(first_owner, RenderOwnership::new(1, AppMode::Game, 7));
assert_eq!(manager.active_ownership(), RenderOwnership::new(2, AppMode::Game, 8));
}
#[test]
fn close_frame_stamps_submission_with_active_ownership() {
let mut manager = RenderManager::new(AppMode::Game);
manager.transition_render_owner(AppMode::Game, 42);
let submission = manager.close_compat_frame();
assert_eq!(submission.ownership, RenderOwnership::new(1, AppMode::Game, 42));
}
#[test]
fn render_policy_maps_game_to_frame_scheduled_worker_capable() {
let policy = RenderPolicy::for_app_mode(AppMode::Game);
@@ -382,4 +443,21 @@ mod tests {
FrameId::ZERO
);
}
#[test]
fn publish_latest_discards_stale_epoch_before_present() {
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));
assert!(surface.seen.is_empty());
assert_eq!(manager.stale_epoch_discards(), 1);
assert_eq!(
manager.latest_complete_submission().expect("stale consumed for diagnostics").ownership,
RenderOwnership::new(0, AppMode::Game, 0)
);
}
}
@@ -241,7 +241,10 @@ impl VirtualMachineRuntime {
if run.reason == LogicalFrameEndingReason::FrameSync
|| run.reason == LogicalFrameEndingReason::EndOfRom
{
self.render_manager.set_active_app_mode(self.current_cartridge_app_mode);
self.render_manager.transition_render_owner(
self.current_cartridge_app_mode,
self.current_app_id,
);
if self.current_cartridge_app_mode == AppMode::Game {
let mut packet = hw.close_game2d_packet();
packet.gfx2d = std::mem::take(&mut self.gfx2d_commands);