Merge pull request #87 from zz85/group_by_pids

Group by process/PIDs + TUI support

Author: zz85

profile-bee-tui/src/app.rs

@@ -4,6 +4,7 @@ use crate::state::{FlameGraphState, UpdateMode};
 use crate::view::FlameGraphView;
 use std::collections::HashMap;
 use std::error;
+use std::sync::atomic::AtomicBool;
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
@@ -59,6 +60,8 @@ pub struct App {
     next_flamegraph: Arc<Mutex<Option<ParsedFlameGraph>>>,
     /// Shared update mode for the profiling thread
     update_mode_handle: Arc<Mutex<UpdateMode>>,
+    /// Shared pid-mode flag for the profiling thread (toggled with 'p')
+    pid_mode_handle: Arc<AtomicBool>,
     /// Stack positions from last render (for mouse click handling)
     pub stack_positions: Vec<StackPosition>,
     /// Last click for double-click detection
@@ -83,6 +86,7 @@ impl App {
             dirty: true,
             next_flamegraph: Arc::new(Mutex::new(None)),
             update_mode_handle: Arc::new(Mutex::new(UpdateMode::default())),
+            pid_mode_handle: Arc::new(AtomicBool::new(false)),
             stack_positions: Vec::new(),
             last_click: None,
             process_output: None,
@@ -114,6 +118,7 @@ impl App {
             debug: false,
             dirty: true,
             update_mode_handle,
+            pid_mode_handle: Arc::new(AtomicBool::new(false)),
             stack_positions: Vec::new(),
             last_click: None,
             process_output: None,
@@ -151,6 +156,10 @@ impl App {
         self.update_mode_handle.clone()
     }
 
+    pub fn get_pid_mode_handle(&self) -> Arc<AtomicBool> {
+        self.pid_mode_handle.clone()
+    }
+
     /// Update flamegraph with new data
     pub fn update_flamegraph(&self, data: String) {
         let tic = std::time::Instant::now();

profile-bee-tui/src/handler.rs

@@ -26,13 +26,21 @@ pub fn handle_key_events(key_event: KeyEvent, app: &mut App) -> AppResult<()> {
 pub fn handle_command(key_event: KeyEvent, app: &mut App) -> AppResult<()> {
     let mut key_handled = handle_command_generic(key_event, app)?;
     if !key_handled {
-        match app.flamegraph_state().view_kind {
+        let view = app.flamegraph_state().view_kind;
+        let tree_mode = app.flamegraph_view.state.tree_mode;
+        match view {
             ViewKind::FlameGraph => {
                 key_handled = handle_command_flamegraph(key_event, app)?;
             }
+            ViewKind::Table | ViewKind::ProcessList if tree_mode => {
+                key_handled = handle_command_tree_view(key_event, app)?;
+            }
             ViewKind::Table => {
                 key_handled = handle_command_table(key_event, app)?;
             }
+            ViewKind::ProcessList => {
+                key_handled = handle_command_process_list(key_event, app)?;
+            }
             ViewKind::Output => {
                 key_handled = handle_command_output(key_event, app)?;
             }
@@ -90,6 +98,15 @@ pub fn handle_command_generic(key_event: KeyEvent, app: &mut App) -> AppResult<b
         KeyCode::Char('?') => {
             app.toggle_debug();
         }
+        KeyCode::Char('t') => {
+            app.flamegraph_view.state.tree_mode = !app.flamegraph_view.state.tree_mode;
+            let mode_str = if app.flamegraph_view.state.tree_mode {
+                "on"
+            } else {
+                "off"
+            };
+            app.set_transient_message(&format!("Tree mode: {}", mode_str));
+        }
         _ => {
             key_handled = false;
         }
@@ -142,6 +159,15 @@ fn handle_command_flamegraph(key_event: KeyEvent, app: &mut App) -> AppResult<bo
         KeyCode::Char('#') => {
             app.search_selected();
         }
+        KeyCode::Char('p') => {
+            let new_val = !app.flamegraph_view.state.pid_mode;
+            app.flamegraph_view.state.pid_mode = new_val;
+            // Sync to shared handle so profiling thread picks it up
+            app.get_pid_mode_handle()
+                .store(new_val, std::sync::atomic::Ordering::Relaxed);
+            let mode_str = if new_val { "on" } else { "off" };
+            app.set_transient_message(&format!("PID mode: {}", mode_str));
+        }
         _ => {
             key_handled = false;
         }
@@ -228,6 +254,114 @@ fn handle_command_output(key_event: KeyEvent, app: &mut App) -> AppResult<bool>
     Ok(key_handled)
 }
 
+fn handle_command_process_list(key_event: KeyEvent, app: &mut App) -> AppResult<bool> {
+    let process_count = app.flamegraph_view.get_process_list().len();
+    let mut key_handled = true;
+    match key_event.code {
+        KeyCode::Down | KeyCode::Char('j') => {
+            if process_count > 0 {
+                let state = &mut app.flamegraph_view.state.process_list_state;
+                state.selected = (state.selected + 1).min(process_count.saturating_sub(1));
+            }
+        }
+        KeyCode::Up | KeyCode::Char('k') => {
+            let state = &mut app.flamegraph_view.state.process_list_state;
+            state.selected = state.selected.saturating_sub(1);
+        }
+        KeyCode::Char('G') => {
+            if process_count > 0 {
+                app.flamegraph_view.state.process_list_state.selected =
+                    process_count.saturating_sub(1);
+            }
+        }
+        KeyCode::Char('g') => {
+            app.flamegraph_view.state.process_list_state.selected = 0;
+        }
+        KeyCode::Enter => {
+            let processes = app.flamegraph_view.get_process_list();
+            let selected = app.flamegraph_view.state.process_list_state.selected;
+            if let Some(entry) = processes.get(selected) {
+                app.flamegraph_view.zoom_to_process(entry.stack_id);
+            }
+        }
+        KeyCode::Esc | KeyCode::Char('p') => {
+            app.flamegraph_view.state.view_kind = ViewKind::FlameGraph;
+        }
+        _ => {
+            key_handled = false;
+        }
+    }
+    Ok(key_handled)
+}
+
+fn handle_command_tree_view(key_event: KeyEvent, app: &mut App) -> AppResult<bool> {
+    let rows = app.flamegraph_view.get_tree_rows();
+    let row_count = rows.len();
+    let mut key_handled = true;
+    match key_event.code {
+        KeyCode::Down | KeyCode::Char('j') => {
+            if row_count > 0 {
+                let state = &mut app.flamegraph_view.state.tree_view_state;
+                state.selected = (state.selected + 1).min(row_count.saturating_sub(1));
+            }
+        }
+        KeyCode::Up | KeyCode::Char('k') => {
+            let state = &mut app.flamegraph_view.state.tree_view_state;
+            state.selected = state.selected.saturating_sub(1);
+        }
+        KeyCode::Char('G') => {
+            if row_count > 0 {
+                app.flamegraph_view.state.tree_view_state.selected = row_count.saturating_sub(1);
+            }
+        }
+        KeyCode::Char('g') => {
+            app.flamegraph_view.state.tree_view_state.selected = 0;
+        }
+        KeyCode::Enter | KeyCode::Right | KeyCode::Char('l') => {
+            // Expand the selected node (or collapse if already expanded)
+            let selected = app.flamegraph_view.state.tree_view_state.selected;
+            if let Some(row) = rows.get(selected) {
+                if row.has_children {
+                    app.flamegraph_view
+                        .state
+                        .tree_view_state
+                        .toggle_expanded(row.stack_id);
+                }
+            }
+        }
+        KeyCode::Left | KeyCode::Char('h') => {
+            // Collapse the selected node, or move to parent
+            let selected = app.flamegraph_view.state.tree_view_state.selected;
+            if let Some(row) = rows.get(selected) {
+                if row.is_expanded {
+                    // Collapse it
+                    app.flamegraph_view
+                        .state
+                        .tree_view_state
+                        .expanded
+                        .remove(&row.stack_id);
+                } else if row.depth > 0 {
+                    // Move cursor to parent (find the row with depth-1 above us)
+                    for i in (0..selected).rev() {
+                        if rows[i].depth < row.depth {
+                            app.flamegraph_view.state.tree_view_state.selected = i;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        KeyCode::Esc => {
+            // Collapse all and reset
+            app.flamegraph_view.state.tree_view_state.expanded.clear();
+        }
+        _ => {
+            key_handled = false;
+        }
+    }
+    Ok(key_handled)
+}
+
 pub fn handle_input_buffer(key_event: KeyEvent, app: &mut App) -> AppResult<()> {
     if let Some(input) = app.input_buffer.as_mut() {
         match key_event.code {

profile-bee-tui/src/state.rs

@@ -45,6 +45,7 @@ pub enum ViewKind {
     FlameGraph,
     Table,
     Output,
+    ProcessList,
 }
 
 #[derive(Default, Debug, Clone)]
@@ -69,11 +70,44 @@ pub struct FlameGraphState {
     pub zoom: Option<ZoomState>,
     pub search_pattern: Option<SearchPattern>,
     pub freeze: bool,
+    /// When true, stacks are prefixed with "process_name (pid)" root frames
+    /// to split the flamegraph by process. Toggled with 'p'.
+    pub pid_mode: bool,
+    /// When true, the Top/Processes views show an expandable tree instead
+    /// of a flat list. Toggled with 't'.
+    pub tree_mode: bool,
     pub view_kind: ViewKind,
     pub table_state: TableState,
+    pub process_list_state: TableState,
+    pub tree_view_state: TreeViewState,
     pub update_mode: UpdateMode,
 }
 
+/// State for the expandable call-tree view (like `perf report`).
+#[derive(Debug, Clone, Default)]
+pub struct TreeViewState {
+    /// Currently selected row in the flattened tree.
+    pub selected: usize,
+    /// Scroll offset for rendering.
+    pub offset: usize,
+    /// Set of expanded node IDs.
+    pub expanded: std::collections::HashSet<StackIdentifier>,
+}
+
+impl TreeViewState {
+    pub fn reset(&mut self) {
+        self.selected = 0;
+        self.offset = 0;
+        self.expanded.clear();
+    }
+
+    pub fn toggle_expanded(&mut self, id: StackIdentifier) {
+        if !self.expanded.remove(&id) {
+            self.expanded.insert(id);
+        }
+    }
+}
+
 impl Default for FlameGraphState {
     fn default() -> Self {
         Self {
@@ -84,8 +118,12 @@ impl Default for FlameGraphState {
             zoom: None,
             search_pattern: None,
             freeze: false,
+            pid_mode: false,
+            tree_mode: false,
             view_kind: ViewKind::FlameGraph,
             table_state: TableState::default(),
+            process_list_state: TableState::default(),
+            tree_view_state: TreeViewState::default(),
             update_mode: UpdateMode::default(),
         }
     }
@@ -123,7 +161,8 @@ impl FlameGraphState {
     pub fn toggle_view_kind(&mut self) {
         self.view_kind = match self.view_kind {
             ViewKind::FlameGraph => ViewKind::Table,
-            ViewKind::Table => ViewKind::FlameGraph,
+            ViewKind::Table => ViewKind::ProcessList,
+            ViewKind::ProcessList => ViewKind::FlameGraph,
             ViewKind::Output => ViewKind::FlameGraph,
         };
     }
@@ -133,7 +172,8 @@ impl FlameGraphState {
     pub fn toggle_view_kind_with_output(&mut self) {
         self.view_kind = match self.view_kind {
             ViewKind::FlameGraph => ViewKind::Table,
-            ViewKind::Table => ViewKind::Output,
+            ViewKind::Table => ViewKind::ProcessList,
+            ViewKind::ProcessList => ViewKind::Output,
             ViewKind::Output => ViewKind::FlameGraph,
         };
     }
@@ -163,6 +203,15 @@ impl FlameGraphState {
         if let Some(p) = &self.search_pattern {
             new.set_hits(p);
         }
+
+        // Remap expanded tree node IDs from old to new flamegraph.
+        // Nodes are matched by full name so expanded state survives data refreshes.
+        let old_expanded = std::mem::take(&mut self.tree_view_state.expanded);
+        for old_id in old_expanded {
+            if let Some(new_id) = Self::get_new_stack_id(&old_id, old, new) {
+                self.tree_view_state.expanded.insert(new_id);
+            }
+        }
     }
 
     fn get_new_stack_id(