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(())
-        }
-    }
 }
 
 fn handle_action(
@@ -199,8 +199,8 @@ impl ProfilerSession {
         }
     }
 
-    async fn start_profiling(&mut self, file_path: PathBuf) -> Result<()> {
-        let program = ProgramState::new(file_path).await?;
+    async fn start_profiling(&mut self, file_path: PathBuf) {
+        let program = ProgramState::new(file_path).await;
         let recording = if self.recording.is_some() {
             Some(Recording::new(&program))
         } else {
@@ -208,14 +208,12 @@ impl ProfilerSession {
         };
         self.program = Some(program);
         self.recording = recording;
-        Ok(())
     }
 
-    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<()> {

src/profiler/recording.rs

@@ -17,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));
 
+        if let Some(symbol_file) = state.symbol_file() {
             let lib = profile.add_lib(symbol_file.library_info().clone());
             profile.add_lib_mapping(process, lib, 0x00000000, 0xffffffff, 0);
+        }
 
         let mut me = Self {
             profile,

src/profiler/state.rs

@@ -5,7 +5,8 @@ use anyhow::{Result, bail};
 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> {
-        let symbol_file = SymbolFile::load(&file_path).await?;
+    pub async fn new(file_path: PathBuf) -> Self {
+        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 {
-        &self.symbol_file
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+
+    pub fn symbol_file(&self) -> Option<&SymbolFile> {
+        self.symbol_file.as_ref()
     }
 
     pub fn current_stack(&self) -> Option<(u16, &[StackFrame])> {