520 lines
22 KiB
Rust
520 lines
22 KiB
Rust
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<dyn std::any::Any + Send>) -> String {
|
|
if let Some(message) = payload.downcast_ref::<String>() {
|
|
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<CrashReport> {
|
|
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<u32, String>,
|
|
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<u32, String>,
|
|
next_handle: &mut u32,
|
|
vm: &mut VirtualMachine,
|
|
signals: &InputSignals,
|
|
platform: &mut dyn RuntimePlatform,
|
|
) -> Option<CrashReport> {
|
|
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();
|
|
}
|
|
}
|