Profile without ELF data

src/emulator/shrooms_vb_core.rs

@@ -1,4 +1,4 @@
-use std::{ffi::c_void, ptr, slice};
+use std::{borrow::Cow, ffi::c_void, ptr, slice};
 
 use anyhow::{Result, anyhow};
 use bitflags::bitflags;
@@ -191,6 +191,9 @@ 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
 }
 
@@ -328,6 +331,7 @@ 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,24 +199,40 @@ impl ProfilerSession {
         }
     }
 
-    async fn start_profiling(&mut self, file_path: PathBuf) -> Result<()> {
+    async fn start_profiling(&mut self, file_path: PathBuf) {
-        self.program = Some(ProgramState::new(file_path).await?);
+        let program = ProgramState::new(file_path).await;
-        self.recording = None;
+        let recording = if self.recording.is_some() {
-        Ok(())
+            Some(Recording::new(&program))
+        } else {
+            None
+        };
+        self.program = Some(program);
+        self.recording = recording;
     }
 
-    fn track_elapsed_cycles(&mut self, cycles: u32) -> Result<()> {
+    fn track_elapsed_cycles(&mut self, cycles: u32) {
         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<()> {
-        if let Some(program) = &mut self.program {
+        let Some(program) = &mut self.program else {
-            program.track_event(event)?;
+            return Ok(());
+        };
+        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,8 +1,9 @@
-use std::collections::HashMap;
+use std::{borrow::Cow, collections::HashMap};
 
 use fxprof_processed_profile::{
-    CategoryHandle, CpuDelta, Frame, FrameFlags, FrameInfo, ProcessHandle, Profile,
+    CategoryHandle, CpuDelta, Frame, FrameFlags, FrameInfo, MarkerTiming, ProcessHandle, Profile,
-    ReferenceTimestamp, SamplingInterval, StackHandle, ThreadHandle, Timestamp,
+    ReferenceTimestamp, SamplingInterval, StackHandle, StaticSchemaMarker, StringHandle,
+    ThreadHandle, Timestamp,
 };
 
 use crate::profiler::state::{ProgramState, RESET_CODE, StackFrame};
@@ -16,17 +17,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(name, reference_timestamp, interval);
+        let mut profile = Profile::new(state.name(), reference_timestamp, interval);
 
-        let process = profile.add_process(name, 1, Timestamp::from_nanos_since_reference(0));
+        let process =
+            profile.add_process(state.name(), 1, Timestamp::from_nanos_since_reference(0));
 
-        let lib = profile.add_lib(symbol_file.library_info().clone());
+        if let Some(symbol_file) = state.symbol_file() {
-        profile.add_lib_mapping(process, lib, 0x00000000, 0xffffffff, 0);
+            let lib = profile.add_lib(symbol_file.library_info().clone());
+            profile.add_lib_mapping(process, lib, 0x00000000, 0xffffffff, 0);
+        }
 
         let mut me = Self {
             profile,
@@ -72,6 +73,15 @@ 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")
     }
@@ -92,6 +102,29 @@ 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,10 +2,11 @@ use std::{collections::HashMap, path::PathBuf};
 
 use anyhow::{Result, bail};
 
-use crate::{emulator::SimEvent, profiler::symbols::SymbolFile};
+use crate::profiler::symbols::SymbolFile;
 
 pub struct ProgramState {
-    symbol_file: SymbolFile,
+    name: String,
+    symbol_file: Option<SymbolFile>,
     call_stacks: HashMap<u16, Vec<StackFrame>>,
     context_stack: Vec<u16>,
 }
@@ -16,8 +17,17 @@ pub struct StackFrame {
 
 pub const RESET_CODE: u16 = 0xfff0;
 impl ProgramState {
-    pub async fn new(file_path: PathBuf) -> Result<Self> {
+    pub async fn new(file_path: PathBuf) -> Self {
-        let symbol_file = SymbolFile::load(&file_path).await?;
+        let symbol_file = SymbolFile::load(&file_path).await.ok();
+        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,
@@ -25,15 +35,20 @@ impl ProgramState {
                 address: 0xfffffff0,
             }],
         );
-        Ok(Self {
+        Self {
+            name,
             symbol_file,
             call_stacks,
             context_stack: vec![RESET_CODE],
-        })
+        }
     }
 
-    pub fn symbol_file(&self) -> &SymbolFile {
+    pub fn name(&self) -> &str {
-        &self.symbol_file
+        &self.name
+    }
+
+    pub fn symbol_file(&self) -> Option<&SymbolFile> {
+        self.symbol_file.as_ref()
     }
 
     pub fn current_stack(&self) -> Option<(u16, &[StackFrame])> {
@@ -42,62 +57,66 @@ impl ProgramState {
         Some((*code, call_stack))
     }
 
-    pub fn track_event(&mut self, event: SimEvent) -> Result<()> {
+    pub fn track_call(&mut self, address: u32) -> Result<()> {
-        match event {
+        let Some(code) = self.context_stack.last() else {
-            SimEvent::Call(address) => {
+            bail!("How did we call anything when we're halted?");
-                let Some(code) = self.context_stack.last() else {
+        };
-                    bail!("How did we call anything when we're halted?");
+        let Some(stack) = self.call_stacks.get_mut(code) else {
-                };
+            bail!("missing stack {code:04x}");
-                let Some(stack) = self.call_stacks.get_mut(code) else {
+        };
-                    bail!("missing stack {code:04x}");
+        stack.push(StackFrame { address });
-                };
+        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);
-                }
 
-                self.context_stack.push(code);
+    pub fn track_return(&mut self) -> Result<()> {
-                if self
+        let Some(code) = self.context_stack.last() else {
-                    .call_stacks
+            bail!("how did we return when we're halted?");
-                    .insert(code, vec![StackFrame { address }])
+        };
-                    .is_some()
+        let Some(stack) = self.call_stacks.get_mut(code) else {
-                {
+            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 => {
+        }
-                let Some(code) = self.context_stack.pop() else {
+        if stack.is_empty() {
-                    bail!("RETI when halted");
+            bail!("returned to oblivion");
-                };
+        }
-                if code == RESET_CODE {
+        Ok(())
-                    bail!("RETI when not in interrupt");
+    }
-                }
+
-                if self.call_stacks.remove(&code).is_none() {
+    pub fn track_halt(&mut self) -> Result<()> {
-                    bail!("{code:04x} popped but never called");
+        let Some(RESET_CODE) = self.context_stack.pop() else {
-                }
+            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(())
     }