implements PLN-0058
Intrepid/Prometeu/Runtime/pipeline/head This commit looks good
Intrepid/Prometeu/Runtime/pipeline/pr-master This commit looks good

This commit is contained in:
2026-05-15 06:55:26 +01:00
parent bfe900797f
commit 4d2ea6400d
19 changed files with 499 additions and 281 deletions
@@ -58,11 +58,7 @@ impl HostDebugger {
// Pre-load cartridge metadata so the Handshake message can contain
// valid information about the App being debugged.
if let Ok(cartridge) = CartridgeLoader::load(path) {
let _ = firmware.os.vm_runtime.initialize_vm(
&mut firmware.os.log_service,
&mut firmware.vm,
&cartridge,
);
let _ = firmware.os.vm().initialize(&mut firmware.vm, &cartridge);
}
match TcpListener::bind(format!("127.0.0.1:{}", debug_port)) {
@@ -121,10 +117,10 @@ impl HostDebugger {
protocol_version: DEVTOOLS_PROTOCOL_VERSION,
runtime_version: "0.1".to_string(),
cartridge: HandshakeCartridge {
app_id: firmware.os.vm_runtime.current_app_id,
title: firmware.os.vm_runtime.current_cartridge_title.clone(),
app_version: firmware.os.vm_runtime.current_cartridge_app_version.clone(),
app_mode: firmware.os.vm_runtime.current_cartridge_app_mode,
app_id: firmware.os.vm().current_app_id(),
title: firmware.os.vm().current_cartridge_title(),
app_version: firmware.os.vm().current_cartridge_app_version(),
app_mode: firmware.os.vm().current_cartridge_app_mode(),
},
};
self.send_response(handshake);
@@ -142,7 +138,7 @@ impl HostDebugger {
println!("[Debugger] Connection closed by remote.");
self.stream = None;
// Resume VM execution if it was paused waiting for the debugger.
firmware.os.vm_runtime.paused = false;
firmware.os.vm().set_paused(false);
self.waiting_for_start = false;
}
Ok(n) => {
@@ -169,7 +165,7 @@ impl HostDebugger {
Err(e) => {
eprintln!("[Debugger] Connection error: {}", e);
self.stream = None;
firmware.os.vm_runtime.paused = false;
firmware.os.vm().set_paused(false);
self.waiting_for_start = false;
}
}
@@ -194,27 +190,23 @@ impl HostDebugger {
println!("[Debugger] Starting execution...");
self.waiting_for_start = false;
}
firmware.os.vm_runtime.paused = false;
firmware.os.vm().set_paused(false);
}
DebugCommand::Pause => {
firmware.os.vm_runtime.paused = true;
firmware.os.vm().set_paused(true);
}
DebugCommand::Resume => {
firmware.os.vm_runtime.paused = false;
firmware.os.vm().set_paused(false);
}
DebugCommand::Step => {
// Execute exactly one instruction and keep paused.
firmware.os.vm_runtime.paused = true;
let _ = firmware.os.vm_runtime.debug_step_instruction(
&mut firmware.os.log_service,
&mut firmware.vm,
hardware,
);
firmware.os.vm().set_paused(true);
let _ = firmware.os.vm().debug_step_instruction(&mut firmware.vm, hardware);
}
DebugCommand::StepFrame => {
// Execute until the end of the current logical frame.
firmware.os.vm_runtime.paused = false;
firmware.os.vm_runtime.debug_step_request = true;
firmware.os.vm().set_paused(false);
firmware.os.vm().request_debug_step();
}
DebugCommand::GetState => {
// Return detailed VM register and stack state.
@@ -223,8 +215,8 @@ impl HostDebugger {
let resp = DebugResponse::GetState {
pc: firmware.vm.pc(),
stack_top,
frame_index: firmware.os.vm_runtime.logical_frame_index,
app_id: firmware.os.vm_runtime.current_app_id,
frame_index: firmware.os.vm().logical_frame_index(),
app_id: firmware.os.vm().current_app_id(),
};
self.send_response(resp);
}
@@ -309,14 +301,14 @@ impl HostDebugger {
/// Scans the system for new information to push to the debugger client.
fn stream_events(&mut self, firmware: &mut Firmware) {
if let Some(report) = firmware.os.vm_runtime.last_crash_report.as_ref() {
if let Some(report) = firmware.os.vm().last_crash_report() {
self.stream_fault(report);
} else {
self.last_fault_summary = None;
}
// 1. Process and send new log entries.
let new_events = firmware.os.log_service.get_after(self.last_log_seq);
let new_events = firmware.os.logs_after(self.last_log_seq);
for event in new_events {
self.last_log_seq = event.seq;
@@ -324,17 +316,17 @@ impl HostDebugger {
if event.tag == 0xDEB1 {
self.send_event(DebugEvent::BreakpointHit {
pc: firmware.vm.pc(),
frame_index: firmware.os.vm_runtime.logical_frame_index,
frame_index: firmware.os.vm().logical_frame_index(),
});
}
if (0xCA01..=0xCA07).contains(&event.tag)
&& let Some(cert_event) = Self::cert_event_from_snapshot(
event.tag,
firmware.os.vm_runtime.atomic_telemetry.snapshot(),
&firmware.os.vm_runtime.certifier.config,
firmware.os.vm_runtime.logical_frame_index,
)
&& let Some(cert_event) = {
let telemetry = firmware.os.vm().telemetry_snapshot();
let cert_config = *firmware.os.vm().cert_config();
let frame_index = firmware.os.vm().logical_frame_index();
Self::cert_event_from_snapshot(event.tag, telemetry, &cert_config, frame_index)
}
{
self.send_event(cert_event);
}
@@ -347,9 +339,9 @@ impl HostDebugger {
}
// 2. Send telemetry snapshots at the completion of every frame.
let current_frame = firmware.os.vm_runtime.logical_frame_index;
let current_frame = firmware.os.vm().logical_frame_index();
if current_frame > self.last_telemetry_frame {
let tel = firmware.os.vm_runtime.atomic_telemetry.snapshot();
let tel = firmware.os.vm().telemetry_snapshot();
self.send_event(Self::telemetry_event_from_snapshot(tel));
self.last_telemetry_frame = current_frame;
}
@@ -407,14 +399,14 @@ mod tests {
let mut hardware = Hardware::new();
debugger.handle_command(DebugCommand::Pause, &mut firmware, &mut hardware);
assert!(firmware.os.vm_runtime.paused);
assert!(firmware.os.vm().paused());
debugger.handle_command(DebugCommand::Resume, &mut firmware, &mut hardware);
assert!(!firmware.os.vm_runtime.paused);
assert!(!firmware.os.vm().paused());
debugger.handle_command(DebugCommand::StepFrame, &mut firmware, &mut hardware);
assert!(!firmware.os.vm_runtime.paused);
assert!(firmware.os.vm_runtime.debug_step_request);
assert!(!firmware.os.vm().paused());
assert!(firmware.os.vm().debug_step_requested());
}
#[test]
@@ -424,11 +416,11 @@ mod tests {
let mut hardware = Hardware::new();
debugger.waiting_for_start = true;
firmware.os.vm_runtime.paused = true;
firmware.os.vm().set_paused(true);
debugger.handle_command(DebugCommand::Start, &mut firmware, &mut hardware);
assert!(!debugger.waiting_for_start);
assert!(!firmware.os.vm_runtime.paused);
assert!(!firmware.os.vm().paused());
}
}
@@ -57,9 +57,9 @@ struct FrameCanvas<'a> {
height: usize,
}
pub(crate) fn capture_snapshot(stats: &HostStats, firmware: &Firmware) -> OverlaySnapshot {
let tel = firmware.os.vm_runtime.atomic_telemetry.snapshot();
let recent_logs = firmware.os.log_service.get_recent(10);
pub(crate) fn capture_snapshot(stats: &HostStats, firmware: &mut Firmware) -> OverlaySnapshot {
let tel = firmware.os.vm().telemetry_snapshot();
let recent_logs = firmware.os.recent_logs(10);
let violations_count =
recent_logs.iter().filter(|e| e.tag >= 0xCA01 && e.tag <= 0xCA07).count();
@@ -75,7 +75,7 @@ pub(crate) fn capture_snapshot(stats: &HostStats, firmware: &Firmware) -> Overla
});
}
if let Some(report) = firmware.os.vm_runtime.last_crash_report.as_ref() {
if let Some(report) = firmware.os.vm().last_crash_report() {
footer.push(OverlayMetric {
label: "CRASH",
value: truncate_value(&report.summary(), 28),
@@ -86,9 +86,8 @@ pub(crate) fn capture_snapshot(stats: &HostStats, firmware: &Firmware) -> Overla
let cycles_ratio = ratio(tel.cycles_used, tel.cycles_budget);
let heap_total_bytes = firmware
.os
.vm_runtime
.certifier
.config
.vm()
.cert_config()
.max_heap_bytes
.or(if tel.heap_max_bytes > 0 { Some(tel.heap_max_bytes) } else { None })
.unwrap_or(OVERLAY_HEAP_FALLBACK_BYTES);
@@ -153,7 +153,7 @@ impl HostRunner {
let mut firmware = Firmware::new(cap_config);
if let Some(root) = &fs_root {
let backend = HostDirBackend::new(root);
firmware.os.mount_fs(Box::new(backend));
firmware.os.fs().mount(Box::new(backend));
}
Self {
@@ -203,8 +203,8 @@ impl HostRunner {
}
}
fn machine_running(&self) -> bool {
!self.firmware.os.vm_runtime.paused && !self.debugger.waiting_for_start
fn machine_running(&mut self) -> bool {
!self.firmware.os.vm().paused() && !self.debugger.waiting_for_start
}
}
@@ -266,7 +266,7 @@ impl ApplicationHandler for HostRunner {
WindowEvent::RedrawRequested => {
let overlay_snapshot =
self.overlay_enabled.then(|| capture_snapshot(&self.stats, &self.firmware));
self.overlay_enabled.then(|| capture_snapshot(&self.stats, &mut self.firmware));
// Get Pixels directly from the field (not via helper that gets the entire &mut self)
let pixels = self.pixels.as_mut().expect("pixels not initialized");
@@ -320,25 +320,25 @@ impl ApplicationHandler for HostRunner {
fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
let was_debugger_connected = self.debugger.stream.is_some();
let was_waiting_for_start = self.debugger.waiting_for_start;
let was_paused = self.firmware.os.vm_runtime.paused;
let was_paused = self.firmware.os.vm().paused();
// 1. Process pending debug commands from the network.
self.debugger.check_commands(&mut self.firmware, &mut self.hardware);
// Sync inspection mode state. This is host-owned overlay/debugger control,
// not a guest-visible debug ABI switch.
self.firmware.os.vm_runtime.inspection_active =
self.overlay_enabled || self.debugger.stream.is_some();
self.firmware
.os
.vm()
.set_inspection_active(self.overlay_enabled || self.debugger.stream.is_some());
// 2. Maintain filesystem connection if it was lost (e.g., directory removed).
if let Some(root) = &self.fs_root {
use prometeu_system::fs::FsState;
if matches!(self.firmware.os.fs_state, FsState::Unmounted | FsState::Error(_))
&& std::path::Path::new(root).exists()
{
let backend = HostDirBackend::new(root);
self.firmware.os.mount_fs(Box::new(backend));
}
// 2. Maintain a filesystem connection if it was lost (e.g., directory removed).
if let Some(root) = &self.fs_root
&& self.firmware.os.fs().needs_mount()
&& std::path::Path::new(root).exists()
{
let backend = HostDirBackend::new(root);
self.firmware.os.fs().mount(Box::new(backend));
}
// 3. Timing Management (The heart of determinism).
@@ -362,13 +362,13 @@ impl ApplicationHandler for HostRunner {
// Unless the debugger is waiting for a 'start' command, advance the system.
if !self.debugger.waiting_for_start {
self.firmware.tick(&self.input.signals, &mut self.hardware);
self.stats.record_host_cpu_time(self.firmware.os.vm_runtime.last_frame_cpu_time_us);
self.stats.record_host_cpu_time(self.firmware.os.vm().last_frame_cpu_time_us());
}
// Sync pause state with audio.
// We do this AFTER firmware.tick to avoid MasterPause/Resume commands
// being cleared by the OS if a new logical frame starts in this tick.
let is_paused = self.firmware.os.vm_runtime.paused || self.debugger.waiting_for_start;
let is_paused = self.firmware.os.vm().paused() || self.debugger.waiting_for_start;
if is_paused != self.last_paused_state {
self.last_paused_state = is_paused;
let cmd =
@@ -383,11 +383,11 @@ impl ApplicationHandler for HostRunner {
self.stats.record_frame();
}
self.presentation.note_published_frame(self.firmware.os.vm_runtime.logical_frame_index);
self.presentation.note_published_frame(self.firmware.os.vm().logical_frame_index());
if was_debugger_connected != self.debugger.stream.is_some()
|| was_waiting_for_start != self.debugger.waiting_for_start
|| was_paused != self.firmware.os.vm_runtime.paused
|| was_paused != self.firmware.os.vm().paused()
{
self.invalidate_host_surface();
}
@@ -396,14 +396,14 @@ impl ApplicationHandler for HostRunner {
self.audio.update_stats(&mut self.stats);
// Update technical statistics displayed in the window title.
self.stats.update(now, self.window, &self.hardware, &self.firmware);
self.stats.update(now, self.window, &self.hardware, &mut self.firmware);
// Synchronize system logs to the host console.
let last_seq = self.log_sink.last_seq().unwrap_or(u64::MAX);
let new_events = if last_seq == u64::MAX {
self.firmware.os.log_service.get_recent(4096)
self.firmware.os.recent_logs(4096)
} else {
self.firmware.os.log_service.get_after(last_seq)
self.firmware.os.logs_after(last_seq)
};
self.log_sink.process_events(new_events);
@@ -813,7 +813,7 @@ mod tests {
stream.write_all(b"{\"type\":\"pause\"}\n").expect("Should write pause");
std::thread::sleep(std::time::Duration::from_millis(50));
runner.debugger.check_commands(&mut runner.firmware, &mut runner.hardware);
assert!(runner.firmware.os.vm_runtime.paused, "VM should be paused");
assert!(runner.firmware.os.vm().paused(), "VM should be paused");
}
// 2. Disconnect (stream goes out of scope)
@@ -821,7 +821,7 @@ mod tests {
runner.debugger.check_commands(&mut runner.firmware, &mut runner.hardware);
// 3. Check if unpaused
assert!(!runner.firmware.os.vm_runtime.paused, "VM should have unpaused after disconnect");
assert!(!runner.firmware.os.vm().paused(), "VM should have unpaused after disconnect");
assert!(!runner.debugger.waiting_for_start, "VM should have left waiting_for_start state");
}
}
@@ -65,7 +65,7 @@ impl HostStats {
now: Instant,
window: Option<&Window>,
_hardware: &Hardware,
firmware: &Firmware,
firmware: &mut Firmware,
) {
let stats_elapsed = now.duration_since(self.last_stats_update);
if stats_elapsed >= Duration::from_secs(1) {
@@ -88,14 +88,9 @@ impl HostStats {
self.current_fps,
cpu_load_core,
cpu_load_audio,
firmware.os.vm_runtime.tick_index,
firmware.os.vm_runtime.logical_frame_index,
firmware
.os
.vm_runtime
.atomic_telemetry
.completed_logical_frames
.load(std::sync::atomic::Ordering::Relaxed),
firmware.os.vm().tick_index(),
firmware.os.vm().logical_frame_index(),
firmware.os.vm().completed_logical_frames(),
);
window.set_title(&title);
}