Files
prometeu-runtime/crates/console/prometeu-system/src/services/vm_runtime/tick.rs
T
bquarkz e0e01ed1de
Intrepid/Prometeu/Runtime/pipeline/pr-master This commit looks good
feat(audio): add guest voice controls and reliable lifecycle delivery
2026-10-14 09:08:27 +01:00

658 lines
28 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)
}
#[allow(clippy::too_many_arguments)]
pub fn debug_step_instruction(
&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,
) -> Option<CrashReport> {
if !platform.audio().ready() {
return None;
}
if vm.memcard_boot_result() == Some(0) && memcard.session.boot_pending() {
return None;
}
let was_memcard_boot = vm.memcard_boot_active();
if was_memcard_boot {
platform.audio_mut().begin_lifecycle();
}
if vm.call_stack_is_empty()
&& let Err(error) = vm.prepare_boot_call()
{
let report = CrashReport::VmInit { error };
platform.audio_mut().abort_frame();
self.last_crash_report = Some(report.clone());
return Some(report);
}
let step_result = {
let mut ctx = HostContext::new_platform(Some(platform));
let mut host = VmRuntimeHost {
runtime: self,
log_service,
fs,
fs_state,
memcard,
open_files,
next_handle,
};
vm.step(&mut host, &mut ctx)
};
// run_budget derives these terminal reasons after executing an instruction;
// single stepping must observe the same publication/cancellation boundary.
let step_result = if step_result.is_ok() && vm.is_halted() {
Err(LogicalFrameEndingReason::Halted)
} else if step_result.is_ok() && !was_memcard_boot && vm.call_stack_is_empty() {
Err(LogicalFrameEndingReason::EndOfRom)
} else {
step_result
};
if was_memcard_boot
&& step_result == Err(LogicalFrameEndingReason::LifecycleComplete)
&& let Err(error) = memcard.session.finish_boot(
vm.memcard_boot_result() == Some(0),
&memcard.lane,
Instant::now(),
)
{
let report = CrashReport::VmPanic {
message: format!("Memcard bootstrap failed: {error:?}: {}", memcard.diagnostic),
pc: Some(vm.pc() as u32),
};
platform.audio_mut().abort_frame();
self.last_crash_report = Some(report.clone());
return Some(report);
}
if was_memcard_boot {
match &step_result {
Err(LogicalFrameEndingReason::LifecycleComplete) => {
platform.audio_mut().finish_lifecycle(true)
}
Err(
LogicalFrameEndingReason::Trap(_)
| LogicalFrameEndingReason::Panic(_)
| LogicalFrameEndingReason::Halted,
) => platform.audio_mut().finish_lifecycle(false),
_ => {}
}
}
match &step_result {
Err(LogicalFrameEndingReason::FrameSync | LogicalFrameEndingReason::EndOfRom) => {
platform.audio_mut().finish_frame()
}
Err(LogicalFrameEndingReason::Halted) => platform.audio_mut().reset(),
Err(LogicalFrameEndingReason::Trap(_) | LogicalFrameEndingReason::Panic(_)) => {
platform.audio_mut().abort_frame()
}
_ => {}
}
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),
);
platform.audio_mut().abort_frame();
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),
);
platform.audio_mut().abort_frame();
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;
}
if !platform.audio().lifecycle_ready() {
return LogicalFrameEndingReason::BudgetExhausted;
}
platform.audio_mut().begin_lifecycle();
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))
});
match &reason {
LogicalFrameEndingReason::LifecycleComplete => {
platform.audio_mut().finish_lifecycle(true)
}
LogicalFrameEndingReason::BudgetExhausted | LogicalFrameEndingReason::Breakpoint => {}
_ => {
platform.audio_mut().finish_lifecycle(false);
platform.audio_mut().abort_frame();
}
}
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> {
if vm.memcard_boot_active() {
let reason = self.tick_lifecycle(
log_service,
fs,
fs_state,
mem_card,
open_files,
next_handle,
vm,
platform,
false,
);
let failure = match reason {
LogicalFrameEndingReason::LifecycleComplete => {
let ready = vm.memcard_boot_result() == Some(0);
mem_card.session.finish_boot(ready, &mem_card.lane, Instant::now()).err().map(
|error| CrashReport::VmPanic {
message: format!(
"Memcard bootstrap failed: {error:?}: {}",
mem_card.diagnostic
),
pc: Some(vm.pc() as u32),
},
)
}
LogicalFrameEndingReason::BudgetExhausted
| LogicalFrameEndingReason::Breakpoint => None,
LogicalFrameEndingReason::Trap(trap) => Some(CrashReport::VmTrap { trap }),
other => Some(CrashReport::VmPanic {
message: format!("Memcard bootstrap stopped: {other:?}"),
pc: Some(vm.pc() as u32),
}),
};
if let Some(report) = &failure {
platform.audio_mut().abort_frame();
self.last_crash_report = Some(report.clone());
}
return failure;
}
if vm.memcard_boot_result() == Some(0) {
if let Some(error) = mem_card.session.boot_error() {
return Some(CrashReport::VmPanic {
message: format!("Memcard registration failed: {error:?}"),
pc: Some(vm.pc() as u32),
});
}
if mem_card.session.boot_pending() {
return None;
}
}
let start = Instant::now();
self.tick_index += 1;
if self.paused && !self.debug_step_request {
return None;
}
if !platform.audio().ready() {
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 };
platform.audio_mut().abort_frame();
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::Halted {
platform.audio_mut().reset();
}
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(),
);
platform.audio_mut().abort_frame();
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(),
);
platform.audio_mut().abort_frame();
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();
// Entry return is the runtime's successful implicit frame end.
platform.audio_mut().finish_frame();
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(),
);
platform.audio_mut().abort_frame();
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().begin_frame();
self.logs_written_this_frame.clear();
}
}