src/emulator/shrooms_vb_core.rs

@@ -1,4 +1,4 @@
-use std::{borrow::Cow, ffi::c_void, ptr, slice};
+use std::{ffi::c_void, ptr, slice};
 
 use anyhow::{Result, anyhow};
 use bitflags::bitflags;
@@ -191,9 +191,6 @@ extern "C" fn on_frame(sim: *mut VB) -> c_int {
     // There is no way for the userdata to be null or otherwise invalid.
     let data: &mut VBState = unsafe { &mut *vb_get_user_data(sim).cast() };
     data.frame_seen = true;
-    if data.monitor.enabled {
-        data.monitor.event = Some(SimEvent::Marker(Cow::Borrowed("Frame Drawn")));
-    }
     1
 }
 
@@ -331,7 +328,6 @@ pub enum SimEvent {
     Halt,
     Interrupt(u16, u32),
     Reti,
-    Marker(Cow<'static, str>),
 }
 
 struct EventMonitor {

src/profiler.rs

@@ -134,13 +134,13 @@ async fn handle_event(event: ProfileEvent, session: &mut ProfilerSession) -> Res
     match event {
         ProfileEvent::Start { file_path } => session.start_profiling(file_path).await,
         ProfileEvent::Update { cycles, event } => {
-            session.track_elapsed_cycles(cycles);
+            session.track_elapsed_cycles(cycles)?;
             if let Some(event) = event {
                 session.track_event(event)?;
             }
+            Ok(())
         }
     }
-    Ok(())
 }
 
 fn handle_action(
@@ -199,40 +199,24 @@ impl ProfilerSession {
         }
     }
 
-    async fn start_profiling(&mut self, file_path: PathBuf) {
+    async fn start_profiling(&mut self, file_path: PathBuf) -> Result<()> {
-        let program = ProgramState::new(file_path).await;
+        self.program = Some(ProgramState::new(file_path).await?);
-        let recording = if self.recording.is_some() {
+        self.recording = None;
-            Some(Recording::new(&program))
+        Ok(())
-        } else {
-            None
-        };
-        self.program = Some(program);
-        self.recording = recording;
     }
 
-    fn track_elapsed_cycles(&mut self, cycles: u32) {
+    fn track_elapsed_cycles(&mut self, cycles: u32) -> Result<()> {
         if let (Some(state), Some(recording)) = (&self.program, &mut self.recording) {
             recording.track_elapsed_cycles(state, cycles);
         }
+        Ok(())
     }
 
     fn track_event(&mut self, event: SimEvent) -> Result<()> {
-        let Some(program) = &mut self.program else {
+        if let Some(program) = &mut self.program {
-            return Ok(());
+            program.track_event(event)?;
-        };
-        match event {
-            SimEvent::Call(address) => program.track_call(address),
-            SimEvent::Return => program.track_return(),
-            SimEvent::Halt => program.track_halt(),
-            SimEvent::Interrupt(code, address) => program.track_interrupt(code, address),
-            SimEvent::Reti => program.track_reti(),
-            SimEvent::Marker(name) => {
-                if let Some(recording) = &mut self.recording {
-                    recording.track_marker(name);
-                };
-                Ok(())
-            }
         }
+        Ok(())
     }
 
     fn start_recording(&mut self) {

src/profiler/recording.rs

@@ -1,9 +1,8 @@
-use std::{borrow::Cow, collections::HashMap};
+use std::collections::HashMap;
 
 use fxprof_processed_profile::{
-    CategoryHandle, CpuDelta, Frame, FrameFlags, FrameInfo, MarkerTiming, ProcessHandle, Profile,
+    CategoryHandle, CpuDelta, Frame, FrameFlags, FrameInfo, ProcessHandle, Profile,
-    ReferenceTimestamp, SamplingInterval, StackHandle, StaticSchemaMarker, StringHandle,
+    ReferenceTimestamp, SamplingInterval, StackHandle, ThreadHandle, Timestamp,
-    ThreadHandle, Timestamp,
 };
 
 use crate::profiler::state::{ProgramState, RESET_CODE, StackFrame};
@@ -17,17 +16,17 @@ pub struct Recording {
 
 impl Recording {
     pub fn new(state: &ProgramState) -> Self {
+        let symbol_file = state.symbol_file();
+
+        let name = &symbol_file.name();
         let reference_timestamp = ReferenceTimestamp::from_millis_since_unix_epoch(0.0);
         let interval = SamplingInterval::from_hz(20_000_000.0);
-        let mut profile = Profile::new(state.name(), reference_timestamp, interval);
+        let mut profile = Profile::new(name, reference_timestamp, interval);
 
-        let process =
+        let process = profile.add_process(name, 1, Timestamp::from_nanos_since_reference(0));
-            profile.add_process(state.name(), 1, Timestamp::from_nanos_since_reference(0));
 
-        if let Some(symbol_file) = state.symbol_file() {
+        let lib = profile.add_lib(symbol_file.library_info().clone());
-            let lib = profile.add_lib(symbol_file.library_info().clone());
+        profile.add_lib_mapping(process, lib, 0x00000000, 0xffffffff, 0);
-            profile.add_lib_mapping(process, lib, 0x00000000, 0xffffffff, 0);
-        }
 
         let mut me = Self {
             profile,
@@ -73,15 +72,6 @@ impl Recording {
         }
     }
 
-    pub fn track_marker(&mut self, name: Cow<'static, str>) {
-        let Some(thread) = self.threads.get(&RESET_CODE) else {
-            return;
-        };
-        let timing = MarkerTiming::Instant(Timestamp::from_nanos_since_reference(self.now * 50));
-        let marker = SimpleMarker(name);
-        self.profile.add_marker(*thread, timing, marker);
-    }
-
     pub fn finish(self) -> Vec<u8> {
         serde_json::to_vec(&self.profile).expect("could not serialize profile")
     }
@@ -102,29 +92,6 @@ impl Recording {
     }
 }
 
-struct SimpleMarker(Cow<'static, str>);
-
-impl StaticSchemaMarker for SimpleMarker {
-    const UNIQUE_MARKER_TYPE_NAME: &'static str = "Simple";
-    const FIELDS: &'static [fxprof_processed_profile::StaticSchemaMarkerField] = &[];
-
-    fn name(&self, profile: &mut Profile) -> StringHandle {
-        profile.intern_string(&self.0)
-    }
-
-    fn category(&self, _profile: &mut Profile) -> CategoryHandle {
-        CategoryHandle::OTHER
-    }
-
-    fn string_field_value(&self, _field_index: u32) -> StringHandle {
-        unreachable!()
-    }
-
-    fn number_field_value(&self, _field_index: u32) -> f64 {
-        unreachable!()
-    }
-}
-
 fn thread_name_for_code(code: u16) -> std::borrow::Cow<'static, str> {
     match code {
         RESET_CODE => "Main".into(),

src/profiler/state.rs

@@ -2,11 +2,10 @@ use std::{collections::HashMap, path::PathBuf};
 
 use anyhow::{Result, bail};
 
-use crate::profiler::symbols::SymbolFile;
+use crate::{emulator::SimEvent, profiler::symbols::SymbolFile};
 
 pub struct ProgramState {
-    name: String,
+    symbol_file: SymbolFile,
-    symbol_file: Option<SymbolFile>,
     call_stacks: HashMap<u16, Vec<StackFrame>>,
     context_stack: Vec<u16>,
 }
@@ -17,17 +16,8 @@ pub struct StackFrame {
 
 pub const RESET_CODE: u16 = 0xfff0;
 impl ProgramState {
-    pub async fn new(file_path: PathBuf) -> Self {
+    pub async fn new(file_path: PathBuf) -> Result<Self> {
-        let symbol_file = SymbolFile::load(&file_path).await.ok();
+        let symbol_file = SymbolFile::load(&file_path).await?;
-        let name = symbol_file
-            .as_ref()
-            .map(|f| f.name().to_string())
-            .or_else(|| {
-                file_path
-                    .file_stem()
-                    .map(|s| s.to_string_lossy().into_owned())
-            })
-            .unwrap_or_else(|| "game".to_string());
         let mut call_stacks = HashMap::new();
         call_stacks.insert(
             RESET_CODE,
@@ -35,20 +25,15 @@ impl ProgramState {
                 address: 0xfffffff0,
             }],
         );
-        Self {
+        Ok(Self {
-            name,
             symbol_file,
             call_stacks,
             context_stack: vec![RESET_CODE],
-        }
+        })
     }
 
-    pub fn name(&self) -> &str {
+    pub fn symbol_file(&self) -> &SymbolFile {
-        &self.name
+        &self.symbol_file
-    }
-
-    pub fn symbol_file(&self) -> Option<&SymbolFile> {
-        self.symbol_file.as_ref()
     }
 
     pub fn current_stack(&self) -> Option<(u16, &[StackFrame])> {
@@ -57,66 +42,62 @@ impl ProgramState {
         Some((*code, call_stack))
     }
 
-    pub fn track_call(&mut self, address: u32) -> Result<()> {
+    pub fn track_event(&mut self, event: SimEvent) -> Result<()> {
-        let Some(code) = self.context_stack.last() else {
+        match event {
-            bail!("How did we call anything when we're halted?");
+            SimEvent::Call(address) => {
-        };
+                let Some(code) = self.context_stack.last() else {
-        let Some(stack) = self.call_stacks.get_mut(code) else {
+                    bail!("How did we call anything when we're halted?");
-            bail!("missing stack {code:04x}");
+                };
-        };
+                let Some(stack) = self.call_stacks.get_mut(code) else {
-        stack.push(StackFrame { address });
+                    bail!("missing stack {code:04x}");
-        Ok(())
+                };
-    }
+                stack.push(StackFrame { address });
+            }
+            SimEvent::Return => {
+                let Some(code) = self.context_stack.last() else {
+                    bail!("how did we return when we're halted?");
+                };
+                let Some(stack) = self.call_stacks.get_mut(code) else {
+                    bail!("missing stack {code:04x}");
+                };
+                if stack.pop().is_none() {
+                    bail!("returned from {code:04x} but stack was empty");
+                }
+                if stack.is_empty() {
+                    bail!("returned to oblivion");
+                }
+            }
+            SimEvent::Halt => {
+                let Some(RESET_CODE) = self.context_stack.pop() else {
+                    bail!("halted when not in an interrupt");
+                };
+            }
+            SimEvent::Interrupt(code, address) => {
+                // if the CPU was halted before, wake it up now
+                if self.context_stack.is_empty() {
+                    self.context_stack.push(RESET_CODE);
+                }
 
-    pub fn track_return(&mut self) -> Result<()> {
+                self.context_stack.push(code);
-        let Some(code) = self.context_stack.last() else {
+                if self
-            bail!("how did we return when we're halted?");
+                    .call_stacks
-        };
+                    .insert(code, vec![StackFrame { address }])
-        let Some(stack) = self.call_stacks.get_mut(code) else {
+                    .is_some()
-            bail!("missing stack {code:04x}");
+                {
-        };
+                    bail!("{code:04x} fired twice");
-        if stack.pop().is_none() {
+                }
-            bail!("returned from {code:04x} but stack was empty");
+            }
-        }
+            SimEvent::Reti => {
-        if stack.is_empty() {
+                let Some(code) = self.context_stack.pop() else {
-            bail!("returned to oblivion");
+                    bail!("RETI when halted");
-        }
+                };
-        Ok(())
+                if code == RESET_CODE {
-    }
+                    bail!("RETI when not in interrupt");
-
+                }
-    pub fn track_halt(&mut self) -> Result<()> {
+                if self.call_stacks.remove(&code).is_none() {
-        let Some(RESET_CODE) = self.context_stack.pop() else {
+                    bail!("{code:04x} popped but never called");
-            bail!("halted when not in an interrupt");
+                }
-        };
+            }
-        Ok(())
-    }
-
-    pub fn track_interrupt(&mut self, code: u16, address: u32) -> Result<()> {
-        // if the CPU was halted before, wake it up now
-        if self.context_stack.is_empty() {
-            self.context_stack.push(RESET_CODE);
-        }
-
-        self.context_stack.push(code);
-        if self
-            .call_stacks
-            .insert(code, vec![StackFrame { address }])
-            .is_some()
-        {
-            bail!("{code:04x} fired twice");
-        }
-        Ok(())
-    }
-
-    pub fn track_reti(&mut self) -> Result<()> {
-        let Some(code) = self.context_stack.pop() else {
-            bail!("RETI when halted");
-        };
-        if code == RESET_CODE {
-            bail!("RETI when not in interrupt");
-        }
-        if self.call_stacks.remove(&code).is_none() {
-            bail!("{code:04x} popped but never called");
         }
         Ok(())
     }