use super::*; use crate::CrashReport; use crate::fs::{FsBackend, FsState, VirtualFS}; use prometeu_hal::cartridge::Cartridge; use prometeu_hal::log::{LogLevel, LogSource}; use prometeu_hal::{FrameId, RenderWorkerBackend, RenderWorkerError, RenderWorkerFrameSink}; use std::collections::HashMap; impl VirtualMachineRuntime { pub fn new_with_log_counter( cap_config: Option, logs_count: Arc, ) -> Self { let boot_time = Instant::now(); let atomic_telemetry = Arc::new(AtomicTelemetry::new(logs_count)); Self { tick_index: 0, logical_frame_index: 0, logical_frame_active: false, logical_frame_remaining_cycles: 0, last_frame_cpu_time_us: 0, current_app_id: 0, current_cartridge_title: String::new(), current_cartridge_app_version: String::new(), current_cartridge_app_mode: AppMode::Game, frame_scheduler: FrameScheduler::default(), render_capabilities: RenderRuntimeCapabilities::default(), render_manager: RenderManager::new(AppMode::Game), render_worker_handoff: Arc::new(RenderWorkerHandoff::default()), render_worker_ownership: RenderWorkerOwnership::default(), render_worker_controller: None, gfx2d_commands: Vec::new(), gfxui_commands: Vec::new(), logs_written_this_frame: HashMap::new(), game_lifecycle_events_delivered: Vec::new(), atomic_telemetry, last_crash_report: None, certifier: Certifier::new(cap_config.unwrap_or_default()), paused: false, debug_step_request: false, inspection_active: false, frame_start_heap_allocations: 0, frame_start_string_materializations: 0, needs_prepare_entry_call: false, boot_time, } } pub fn log( &self, log_service: &mut LogService, level: LogLevel, source: LogSource, tag: u16, msg: String, ) { let ts_ms = self.boot_time.elapsed().as_millis() as u64; let frame = self.logical_frame_index; log_service.log(ts_ms, frame, level, source, tag, msg); } pub fn mount_fs( &mut self, log_service: &mut LogService, fs: &mut VirtualFS, fs_state: &mut FsState, backend: Box, ) { self.log( log_service, LogLevel::Info, LogSource::Fs, 0, "Attempting to mount filesystem".to_string(), ); match fs.mount(backend) { Ok(_) => { *fs_state = FsState::Mounted; self.log( log_service, LogLevel::Info, LogSource::Fs, 0, "Filesystem mounted successfully".to_string(), ); } Err(e) => { let err_msg = format!("Failed to mount filesystem: {:?}", e); self.log(log_service, LogLevel::Error, LogSource::Fs, 0, err_msg); *fs_state = FsState::Error(e); } } } pub fn unmount_fs(&mut self, fs: &mut VirtualFS, fs_state: &mut FsState) { fs.unmount(); *fs_state = FsState::Unmounted; } pub(crate) fn update_fs( &mut self, log_service: &mut LogService, fs: &mut VirtualFS, fs_state: &mut FsState, ) { if *fs_state == FsState::Mounted && !fs.is_healthy() { self.log( log_service, LogLevel::Error, LogSource::Fs, 0, "Filesystem became unhealthy, unmounting".to_string(), ); self.unmount_fs(fs, fs_state); } } pub(crate) fn clear_cartridge_state(&mut self) { self.logical_frame_index = 0; self.logical_frame_active = false; self.logical_frame_remaining_cycles = 0; self.last_frame_cpu_time_us = 0; self.atomic_telemetry.reset(); self.current_app_id = 0; self.current_cartridge_title.clear(); self.current_cartridge_app_version.clear(); self.current_cartridge_app_mode = AppMode::Game; self.frame_scheduler = FrameScheduler::default(); self.render_capabilities = RenderRuntimeCapabilities::default(); self.render_manager = RenderManager::new(AppMode::Game); let _ = self.stop_render_worker(); self.render_worker_handoff = Arc::new(RenderWorkerHandoff::default()); self.render_worker_ownership = RenderWorkerOwnership::new(self.render_manager.active_ownership()); self.gfx2d_commands.clear(); self.gfxui_commands.clear(); self.logs_written_this_frame.clear(); self.game_lifecycle_events_delivered.clear(); self.last_crash_report = None; self.paused = false; self.debug_step_request = false; self.inspection_active = false; self.frame_start_heap_allocations = 0; self.frame_start_string_materializations = 0; self.needs_prepare_entry_call = false; } pub fn reset(&mut self, vm: &mut VirtualMachine) { *vm = VirtualMachine::default(); self.clear_cartridge_state(); } pub fn set_render_runtime_capabilities(&mut self, capabilities: RenderRuntimeCapabilities) { self.render_capabilities = capabilities; } pub fn start_render_worker(&mut self, config: RenderWorkerConfig, backend: B, sink: S) where B: RenderWorkerBackend, S: RenderWorkerFrameSink, { let _ = self.stop_render_worker(); self.render_worker_handoff = Arc::new(RenderWorkerHandoff::default()); self.render_worker_ownership.set(self.render_manager.active_ownership()); self.render_worker_controller = Some(RenderWorkerController::start( config, Arc::clone(&self.render_worker_handoff), self.render_worker_ownership.clone(), backend, sink, )); self.render_capabilities.game_render_worker = true; } pub fn stop_render_worker(&mut self) -> Result<(), RenderWorkerError> { if let Some(mut controller) = self.render_worker_controller.take() { controller.stop() } else { Ok(()) } } pub(crate) fn sync_render_worker_ownership(&self) { self.render_worker_ownership.set(self.render_manager.active_ownership()); } pub fn record_repeated_render_worker_frame(&self, frame_id: FrameId) { if let Some(controller) = self.render_worker_controller.as_ref() { controller.record_repeated_frame(frame_id); } } pub fn deliver_game_lifecycle_events(&mut self, events: I) where I: IntoIterator, { self.game_lifecycle_events_delivered.extend(events); } pub fn delivered_game_lifecycle_events(&self) -> &[GameLifecycleEvent] { &self.game_lifecycle_events_delivered } pub fn take_delivered_game_lifecycle_events(&mut self) -> Vec { std::mem::take(&mut self.game_lifecycle_events_delivered) } pub fn initialize_vm( &mut self, log_service: &mut LogService, vm: &mut VirtualMachine, cartridge: &Cartridge, ) -> Result<(), CrashReport> { self.clear_cartridge_state(); vm.set_capabilities(cartridge.capabilities); match vm.initialize(cartridge.program.clone()) { Ok(_) => { if let Some(count) = cartridge.memcard_slots { if !(1..=64).contains(&count) || cartridge.capabilities & prometeu_hal::syscalls::caps::MEMCARD == 0 { return Err(CrashReport::VmPanic { message: "Invalid memcard capability/count".into(), pc: None, }); } vm.require_memcard_boot().map_err(|error| CrashReport::VmInit { error })?; } else if cartridge.capabilities & prometeu_hal::syscalls::caps::MEMCARD != 0 { return Err(CrashReport::VmPanic { message: "Memcard capability requires a slot count".into(), pc: None, }); } self.current_app_id = cartridge.app_id; 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.transition_render_owner(cartridge.app_mode, cartridge.app_id); Ok(()) } Err(e) => { let report = CrashReport::VmInit { error: e }; self.last_crash_report = Some(report.clone()); self.log( log_service, LogLevel::Error, LogSource::Vm, report.log_tag(), format!("Failed to initialize VM: {}", report), ); Err(report) } } } } #[cfg(test)] mod tests { use super::*; use crate::os::{GameLifecycleEvent, GameLifecycleEventKind}; use crate::task::TaskId; #[test] fn vm_runtime_records_and_drains_delivered_game_lifecycle_events() { let mut runtime = VirtualMachineRuntime::new(None); let pause = GameLifecycleEvent { task_id: TaskId(7), kind: GameLifecycleEventKind::Pause }; let resume = GameLifecycleEvent { task_id: TaskId(7), kind: GameLifecycleEventKind::ResumeForeground, }; runtime.deliver_game_lifecycle_events([pause, resume]); assert_eq!(runtime.delivered_game_lifecycle_events(), &[pause, resume]); assert_eq!(runtime.take_delivered_game_lifecycle_events(), vec![pause, resume]); assert!(runtime.delivered_game_lifecycle_events().is_empty()); } }