Fix panic when using --per-cpu-threads.

Author: mstange

samply/src/linux_shared/converter.rs

@@ -878,7 +878,6 @@ where
                 }
                 if let (Some(cpus), Some(cpu_index)) = (&mut self.cpus, common.cpu) {
                     let combined_thread = cpus.combined_thread_handle();
-                    let idle_frame_label = cpus.idle_frame_label();
                     let cpu = cpus.get_mut(cpu_index as usize, &mut self.profile);
                     if let Some(idle_cpu_sample) = self
                         .context_switch_handler
@@ -902,7 +901,7 @@ where
                             UnresolvedStackHandle::EMPTY,
                             cpu_delta,
                             0,
-                            Some(idle_frame_label),
+                            Some(cpu.idle_frame),
                         );
 
                         // Emit a "rest sample" with a CPU delta of zero covering the rest of the paused range.
@@ -916,7 +915,7 @@ where
                             UnresolvedStackHandle::EMPTY,
                             CpuDelta::from_nanos(0),
                             0,
-                            Some(idle_frame_label),
+                            Some(cpu.idle_frame),
                         );
                     }
                     if self.should_emit_cswitch_markers {

samply/src/shared/per_cpu.rs

@@ -12,22 +12,23 @@ pub struct Cpus {
     process_handle: ProcessHandle,
     combined_thread_handle: ThreadHandle,
     cpus: Vec<Cpu>,
-    idle_frame_label: FrameHandle,
 }
 
 pub struct Cpu {
     pub name: StringHandle,
     pub thread_handle: ThreadHandle,
     pub context_switch_data: ThreadContextSwitchData,
+    pub idle_frame: FrameHandle,
     current_tid: Option<(i32, StringHandle, u64)>,
 }
 
 impl Cpu {
-    pub fn new(name: StringHandle, thread_handle: ThreadHandle) -> Self {
+    pub fn new(name: StringHandle, thread_handle: ThreadHandle, idle_frame: FrameHandle) -> Self {
         Self {
             name,
             thread_handle,
             context_switch_data: Default::default(),
+            idle_frame,
             current_tid: None,
         }
     }
@@ -113,38 +114,36 @@ impl Cpus {
     pub fn new(start_time: Timestamp, profile: &mut Profile) -> Self {
         let process_handle = profile.add_process("CPU", 0, start_time);
         let combined_thread_handle = profile.add_thread(process_handle, 0, start_time, true);
-        let idle_string = profile.handle_for_string("<Idle>");
-        let idle_frame_label = profile.handle_for_frame_with_label(
-            combined_thread_handle,
-            idle_string,
-            CategoryHandle::OTHER,
-            FrameFlags::empty(),
-        );
         Self {
             start_time,
             process_handle,
             combined_thread_handle,
             cpus: Vec::new(),
-            idle_frame_label,
         }
     }
 
     pub fn combined_thread_handle(&self) -> ThreadHandle {
         self.combined_thread_handle
     }
 
-    pub fn idle_frame_label(&self) -> FrameHandle {
-        self.idle_frame_label
-    }
-
     pub fn get_mut(&mut self, cpu: usize, profile: &mut Profile) -> &mut Cpu {
         while self.cpus.len() <= cpu {
             let i = self.cpus.len();
             let thread = profile.add_thread(self.process_handle, i as u32, self.start_time, false);
             let name = format!("CPU {i}");
             profile.set_thread_name(thread, &name);
-            self.cpus
-                .push(Cpu::new(profile.handle_for_string(&name), thread));
+            let idle_string = profile.handle_for_string("<Idle>");
+            let idle_frame = profile.handle_for_frame_with_label(
+                thread,
+                idle_string,
+                CategoryHandle::OTHER,
+                FrameFlags::empty(),
+            );
+            self.cpus.push(Cpu::new(
+                profile.handle_for_string(&name),
+                thread,
+                idle_frame,
+            ));
         }
         &mut self.cpus[cpu]
     }

samply/src/windows/profile_context.rs

@@ -1640,7 +1640,6 @@ impl ProfileContext {
             }
             if let Some(cpus) = &mut self.cpus {
                 let combined_thread = cpus.combined_thread_handle();
-                let idle_frame_label = cpus.idle_frame_label();
                 let cpu = cpus.get_mut(cpu_index as usize, &mut self.profile);
 
                 if let Some(idle_cpu_sample) = self
@@ -1660,7 +1659,7 @@ impl ProfileContext {
                         .convert_time(idle_cpu_sample.begin_timestamp);
                     let stack =
                         self.profile
-                            .handle_for_stack(cpu.thread_handle, idle_frame_label, None);
+                            .handle_for_stack(cpu.thread_handle, cpu.idle_frame, None);
                     self.profile.add_sample(
                         cpu.thread_handle,
                         begin_timestamp,