283 lines
10 KiB
Rust
283 lines
10 KiB
Rust
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<CertificationConfig>,
|
|
logs_count: Arc<AtomicU32>,
|
|
) -> 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<dyn FsBackend>,
|
|
) {
|
|
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<B, S>(&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<I>(&mut self, events: I)
|
|
where
|
|
I: IntoIterator<Item = GameLifecycleEvent>,
|
|
{
|
|
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<GameLifecycleEvent> {
|
|
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());
|
|
}
|
|
}
|