use super::dispatch::VmRuntimeHost; use super::render_manager::{RenderConsumeOutcome, RenderConsumerPath, RenderSurface}; use super::*; use crate::CrashReport; use crate::fs::{FsState, VirtualFS}; use crate::services::memcard::MemcardService; use prometeu_hal::asset::{BankTelemetry, BankType}; use prometeu_hal::log::{LogLevel, LogService, LogSource}; use prometeu_hal::{ FrameId, HostContext, InputSignals, RenderSubmission, RenderSubmissionPacket, RenderSubmissionSink, RuntimePlatform, ShellUiFramePacket, }; use prometeu_vm::LogicalFrameEndingReason; use std::collections::HashMap; use std::panic::{AssertUnwindSafe, catch_unwind}; use std::sync::atomic::Ordering; struct HardwareRenderSurface<'a> { sink: &'a mut dyn RenderSubmissionSink, } impl RenderSurface for HardwareRenderSurface<'_> { fn consume_submission(&mut self, submission: &RenderSubmission) { self.sink .submit_render_submission(submission.clone()) .expect("local render submission sink should publish"); } } impl VirtualMachineRuntime { fn host_panic_payload_to_string(payload: Box) -> String { if let Some(message) = payload.downcast_ref::() { return message.clone(); } if let Some(message) = payload.downcast_ref::<&str>() { return (*message).to_string(); } "host panic without string payload".to_string() } fn refresh_internal_allocation_telemetry(&self, vm: &VirtualMachine) { let heap_allocations = vm.heap().allocation_count().saturating_sub(self.frame_start_heap_allocations); let string_materializations = string_materialization_count().saturating_sub(self.frame_start_string_materializations); self.atomic_telemetry.vm_heap_allocations.store(heap_allocations, Ordering::Relaxed); self.atomic_telemetry .vm_string_materializations .store(string_materializations, Ordering::Relaxed); } fn bank_telemetry_summary( platform: &dyn RuntimePlatform, ) -> (BankTelemetry, BankTelemetry, BankTelemetry) { let telemetry = platform.assets().bank_telemetry(); let glyph = telemetry.iter().find(|entry| entry.bank_type == BankType::GLYPH).cloned().unwrap_or( BankTelemetry { bank_type: BankType::GLYPH, used_slots: 0, total_slots: 0 }, ); let sounds = telemetry.iter().find(|entry| entry.bank_type == BankType::SOUNDS).cloned().unwrap_or( BankTelemetry { bank_type: BankType::SOUNDS, used_slots: 0, total_slots: 0 }, ); let scenes = telemetry.iter().find(|entry| entry.bank_type == BankType::SCENE).cloned().unwrap_or( BankTelemetry { bank_type: BankType::SCENE, used_slots: 0, total_slots: 0 }, ); (glyph, sounds, scenes) } pub fn debug_step_instruction( &mut self, log_service: &mut LogService, vm: &mut VirtualMachine, platform: &mut dyn RuntimePlatform, ) -> Option { if vm.call_stack_is_empty() && let Err(error) = vm.prepare_boot_call() { let report = CrashReport::VmInit { error }; self.last_crash_report = Some(report.clone()); return Some(report); } let step_result = { let mut ctx = HostContext::new_platform(Some(platform)); let mut fs = VirtualFS::new(); let mut fs_state = FsState::Unmounted; let mut memcard = MemcardService::new(); let mut open_files = HashMap::new(); let mut next_handle = 1; let mut host = VmRuntimeHost { runtime: self, log_service, fs: &mut fs, fs_state: &mut fs_state, memcard: &mut memcard, open_files: &mut open_files, next_handle: &mut next_handle, }; vm.step(&mut host, &mut ctx) }; match step_result { Ok(()) | Err( LogicalFrameEndingReason::LifecycleComplete | LogicalFrameEndingReason::FrameSync | LogicalFrameEndingReason::BudgetExhausted | LogicalFrameEndingReason::Halted | LogicalFrameEndingReason::EndOfRom | LogicalFrameEndingReason::Breakpoint, ) => None, Err(LogicalFrameEndingReason::Trap(trap)) => { let report = CrashReport::VmTrap { trap }; self.log( log_service, LogLevel::Error, LogSource::Vm, report.log_tag(), format!("PVM Fault during Step: {}", report), ); self.last_crash_report = Some(report.clone()); Some(report) } Err(LogicalFrameEndingReason::Panic(message)) => { let report = CrashReport::VmPanic { message, pc: Some(vm.pc() as u32) }; self.log( log_service, LogLevel::Error, LogSource::Vm, report.log_tag(), format!("PVM Fault during Step: {}", report), ); self.last_crash_report = Some(report.clone()); Some(report) } } } /// Uses the session's real services, outside logical-frame accounting. #[allow(clippy::too_many_arguments)] pub(crate) fn tick_lifecycle( &mut self, log_service: &mut LogService, fs: &mut VirtualFS, fs_state: &mut FsState, memcard: &mut MemcardService, open_files: &mut HashMap, next_handle: &mut u32, vm: &mut VirtualMachine, platform: &mut dyn RuntimePlatform, single_step: bool, ) -> LogicalFrameEndingReason { if self.paused && !single_step && !self.debug_step_request { return LogicalFrameEndingReason::Breakpoint; } let result = catch_unwind(AssertUnwindSafe(|| { let mut ctx = HostContext::new_platform(Some(platform)); let mut host = VmRuntimeHost { runtime: self, log_service, fs, fs_state, memcard, open_files, next_handle, }; if single_step { vm.step(&mut host, &mut ctx) .err() .unwrap_or(LogicalFrameEndingReason::BudgetExhausted) } else { vm.run_budget(VirtualMachine::LIFECYCLE_SLICE, &mut host, &mut ctx) .map(|report| report.reason) .unwrap_or_else(LogicalFrameEndingReason::Panic) } })); let reason = result.unwrap_or_else(|payload| { LogicalFrameEndingReason::Panic(Self::host_panic_payload_to_string(payload)) }); if reason == LogicalFrameEndingReason::Breakpoint || single_step || self.debug_step_request { self.paused = true; self.debug_step_request = false; } reason } #[allow(clippy::too_many_arguments)] pub fn tick( &mut self, log_service: &mut LogService, fs: &mut VirtualFS, fs_state: &mut FsState, mem_card: &mut MemcardService, open_files: &mut HashMap, next_handle: &mut u32, vm: &mut VirtualMachine, signals: &InputSignals, platform: &mut dyn RuntimePlatform, ) -> Option { let start = Instant::now(); self.tick_index += 1; if self.paused && !self.debug_step_request { return None; } self.update_fs(log_service, fs, fs_state); if !self.logical_frame_active { if RenderManager::policy_for_app_mode(self.current_cartridge_app_mode) .uses_frame_scheduler() { self.frame_scheduler .authorize_game_frame() .expect("logical frame cannot start while another Game frame is active"); } self.logical_frame_active = true; self.logical_frame_remaining_cycles = Self::CYCLES_PER_LOGICAL_FRAME; self.begin_logical_frame(signals, platform); if self.needs_prepare_entry_call || vm.call_stack_is_empty() { if let Err(error) = vm.prepare_boot_call() { let report = CrashReport::VmInit { error }; self.last_crash_report = Some(report.clone()); return Some(report); } self.needs_prepare_entry_call = false; } self.atomic_telemetry.frame_index.store(self.logical_frame_index, Ordering::Relaxed); self.atomic_telemetry.cycles_budget.store( self.certifier .config .cycles_budget_per_frame .unwrap_or(Self::CYCLES_PER_LOGICAL_FRAME), Ordering::Relaxed, ); self.atomic_telemetry.cycles_used.store(0, Ordering::Relaxed); self.atomic_telemetry.syscalls.store(0, Ordering::Relaxed); self.atomic_telemetry.vm_steps.store(0, Ordering::Relaxed); self.atomic_telemetry.vm_heap_allocations.store(0, Ordering::Relaxed); self.atomic_telemetry.vm_string_materializations.store(0, Ordering::Relaxed); self.frame_start_heap_allocations = vm.heap().allocation_count(); self.frame_start_string_materializations = string_materialization_count(); } let budget = std::cmp::min(Self::SLICE_PER_TICK, self.logical_frame_remaining_cycles); if budget > 0 { let run_result = { let mut ctx = HostContext::new_platform(Some(platform)); let mut host = VmRuntimeHost { runtime: self, log_service, fs, fs_state, memcard: mem_card, open_files, next_handle, }; vm.run_budget(budget, &mut host, &mut ctx) }; match run_result { Ok(run) => { self.logical_frame_remaining_cycles = self.logical_frame_remaining_cycles.saturating_sub(run.cycles_used); self.atomic_telemetry.cycles_used.fetch_add(run.cycles_used, Ordering::Relaxed); self.atomic_telemetry.vm_steps.fetch_add(run.steps_executed, Ordering::Relaxed); if run.reason == LogicalFrameEndingReason::Breakpoint { self.paused = true; self.debug_step_request = false; self.log( log_service, LogLevel::Info, LogSource::Vm, 0xDEB1, format!("Breakpoint hit at PC 0x{:X}", vm.pc()), ); } if let LogicalFrameEndingReason::Panic(err) = run.reason { let report = CrashReport::VmPanic { message: err, pc: Some(vm.pc() as u32) }; self.log( log_service, LogLevel::Error, LogSource::Vm, report.log_tag(), report.summary(), ); self.last_crash_report = Some(report.clone()); return Some(report); } if let LogicalFrameEndingReason::Trap(trap) = &run.reason { let report = CrashReport::VmTrap { trap: trap.clone() }; self.log( log_service, LogLevel::Error, LogSource::Vm, report.log_tag(), report.summary(), ); self.last_crash_report = Some(report.clone()); return Some(report); } if run.reason == LogicalFrameEndingReason::FrameSync || run.reason == LogicalFrameEndingReason::EndOfRom { self.render_manager.transition_render_owner( self.current_cartridge_app_mode, self.current_app_id, ); self.sync_render_worker_ownership(); if self.current_cartridge_app_mode == AppMode::Game { let mut packet = platform.game2d_frame_composer().close_game2d_packet(); packet.gfx2d = std::mem::take(&mut self.gfx2d_commands); self.render_manager .close_frame_with_packet(RenderSubmissionPacket::Game2D(packet)) .expect("game packet must match Game app mode"); } else { let packet = ShellUiFramePacket::new(std::mem::take(&mut self.gfxui_commands)); self.render_manager .close_frame_with_packet(RenderSubmissionPacket::ShellUi(packet)) .expect("shell packet must match Shell app mode"); } let render_outcome = catch_unwind(AssertUnwindSafe(|| { let mut surface = HardwareRenderSurface { sink: platform.render_submission_sink() }; match self .render_manager .active_render_policy() .resolve_consumer_path(self.render_capabilities) { RenderConsumerPath::LocalSynchronous => { self.render_manager.consume_latest(&mut surface) } RenderConsumerPath::RealWorker if self.render_worker_controller.is_some() && self.current_cartridge_app_mode == AppMode::Game => { RenderConsumeOutcome::NoSubmission } RenderConsumerPath::RealWorker => { self.render_manager.consume_latest(&mut surface) } } })); let render_outcome = match render_outcome { Ok(outcome) => outcome, Err(payload) => { let message = Self::host_panic_payload_to_string(payload); let frame_id = self .render_manager .pending_submission() .map(|submission| submission.frame_id) .unwrap_or(FrameId::ZERO); self.render_manager.record_render_error(frame_id); RenderConsumeOutcome::PresentFailed { frame_id, message } } }; if let RenderConsumeOutcome::PresentFailed { message, .. } = &render_outcome { self.log( log_service, LogLevel::Error, LogSource::Vm, 0, format!("Render publication failed: {}", message), ); } // 1. Snapshot full telemetry at logical frame end let (glyph_bank, sound_bank, scene_bank) = Self::bank_telemetry_summary(platform); self.atomic_telemetry .glyph_slots_used .store(glyph_bank.used_slots as u32, Ordering::Relaxed); self.atomic_telemetry .glyph_slots_total .store(glyph_bank.total_slots as u32, Ordering::Relaxed); self.atomic_telemetry .sound_slots_used .store(sound_bank.used_slots as u32, Ordering::Relaxed); self.atomic_telemetry .sound_slots_total .store(sound_bank.total_slots as u32, Ordering::Relaxed); self.atomic_telemetry .scene_slots_used .store(scene_bank.used_slots as u32, Ordering::Relaxed); self.atomic_telemetry .scene_slots_total .store(scene_bank.total_slots as u32, Ordering::Relaxed); self.atomic_telemetry .heap_used_bytes .store(vm.heap().used_bytes.load(Ordering::Relaxed), Ordering::Relaxed); self.refresh_internal_allocation_telemetry(vm); 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); self.atomic_telemetry .logs_count .store(current_frame_logs, Ordering::Relaxed); let ts_ms = self.boot_time.elapsed().as_millis() as u64; let telemetry_snapshot = self.atomic_telemetry.snapshot(); let violations = self.certifier.evaluate(&telemetry_snapshot, log_service, ts_ms) as u32; self.atomic_telemetry.violations.store(violations, Ordering::Relaxed); self.atomic_telemetry .completed_logical_frames .fetch_add(1, Ordering::Relaxed); log_service.reset_count(); self.logical_frame_index += 1; self.logical_frame_active = false; self.logical_frame_remaining_cycles = 0; if RenderManager::policy_for_app_mode(self.current_cartridge_app_mode) .uses_frame_scheduler() { self.frame_scheduler.complete_game_frame(); } self.needs_prepare_entry_call = run.reason == LogicalFrameEndingReason::EndOfRom; if self.debug_step_request { self.paused = true; self.debug_step_request = false; } } else if run.reason == LogicalFrameEndingReason::BudgetExhausted && RenderManager::policy_for_app_mode(self.current_cartridge_app_mode) .uses_frame_scheduler() { self.frame_scheduler.record_logical_frame_overrun(); } } Err(e) => { let report = CrashReport::VmPanic { message: e, pc: Some(vm.pc() as u32) }; self.log( log_service, LogLevel::Error, LogSource::Vm, report.log_tag(), report.summary(), ); self.last_crash_report = Some(report.clone()); return Some(report); } } } self.last_frame_cpu_time_us = start.elapsed().as_micros() as u64; // 2. High-frequency telemetry update (only if inspection is active) if self.inspection_active { let (glyph_bank, sound_bank, scene_bank) = Self::bank_telemetry_summary(platform); self.atomic_telemetry .glyph_slots_used .store(glyph_bank.used_slots as u32, Ordering::Relaxed); self.atomic_telemetry .glyph_slots_total .store(glyph_bank.total_slots as u32, Ordering::Relaxed); self.atomic_telemetry .sound_slots_used .store(sound_bank.used_slots as u32, Ordering::Relaxed); self.atomic_telemetry .sound_slots_total .store(sound_bank.total_slots as u32, Ordering::Relaxed); self.atomic_telemetry .scene_slots_used .store(scene_bank.used_slots as u32, Ordering::Relaxed); self.atomic_telemetry .scene_slots_total .store(scene_bank.total_slots as u32, Ordering::Relaxed); self.atomic_telemetry .heap_used_bytes .store(vm.heap().used_bytes.load(Ordering::Relaxed), Ordering::Relaxed); self.refresh_internal_allocation_telemetry(vm); self.atomic_telemetry.frame_index.store(self.logical_frame_index, Ordering::Relaxed); self.atomic_telemetry .host_cpu_time_us .store(start.elapsed().as_micros() as u64, Ordering::Relaxed); } None } pub(crate) fn begin_logical_frame( &mut self, _signals: &InputSignals, platform: &mut dyn RuntimePlatform, ) { platform.game2d_frame_composer().begin_frame(); platform.audio_mut().clear_commands(); self.logs_written_this_frame.clear(); } }