feat(pipeline): per-type stall counters, branch accuracy, speculative Gantt, FU stall fix

Four improvements to the pipeline simulator:

1. Per-type stall breakdown — stall_by_type[5] tracks RAW, Load-Use, Branch,
   FU, and MemLatency stall cycles separately. The Execution panel now shows a
   second stats line: "Stalls — RAW:N  Load-Use:N  Branch:N  FU:N  Mem:N".

2. Branch prediction accuracy — branches_executed counter added; the stats
   panel now shows "branches:N  mispred:N (X%)" so misprediction rate is
   immediately visible.

3. Speculative Gantt cells — instructions fetched while a branch is unresolved
   now show in orange in the timing diagram (GanttCell::Speculative) instead of
   the same color as committed instructions.  Flushed speculative instructions
   still show ◀FL.

4. FU stall not counted — FunctionalUnits mode stalls were never incremented
   in stall_count; fixed by adding the increment to the FU early-return path.
   Also cleaned up the outdated FMA "WORKAROUND" comments in stage_ex.

Author: Gaok1

src/ui/pipeline/mod.rs

@@ -348,6 +348,9 @@ pub enum HazardType {
 }
 
 impl HazardType {
+    /// Number of stall-causing hazard types (WAW/WAR are informational, not counted).
+    pub const STALL_TYPE_COUNT: usize = 5;
+
     pub fn label(self) -> &'static str {
         match self {
             Self::Raw => "RAW",
@@ -359,6 +362,19 @@ impl HazardType {
             Self::War => "WAR",
         }
     }
+
+    /// Index into the `stall_by_type` array.  Returns `None` for WAW/WAR which
+    /// are informational only and do not cause pipeline stalls in an in-order pipeline.
+    pub fn as_stall_index(self) -> Option<usize> {
+        match self {
+            Self::Raw => Some(0),
+            Self::LoadUse => Some(1),
+            Self::BranchFlush => Some(2),
+            Self::FuBusy => Some(3),
+            Self::MemLatency => Some(4),
+            Self::Waw | Self::War => None,
+        }
+    }
     pub fn color(self) -> Color {
         match self {
             Self::Raw | Self::LoadUse => Color::Rgb(225, 180, 80),
@@ -540,11 +556,12 @@ pub const MAX_GANTT_COLS: usize = 20;
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
 pub enum GanttCell {
-    Empty,          // instruction not in pipeline yet / already done
-    InStage(Stage), // instruction is in this stage
-    Stall,          // stalled in current stage
-    Bubble,         // NOP bubble occupies this slot
-    Flush,          // instruction was flushed
+    Empty,               // instruction not in pipeline yet / already done
+    InStage(Stage),      // instruction is in this stage
+    Speculative(Stage),  // instruction is in this stage but was fetched speculatively
+    Stall,               // stalled in current stage
+    Bubble,              // NOP bubble occupies this slot
+    Flush,               // instruction was flushed (branch misprediction)
 }
 
 #[derive(Clone)]
@@ -746,7 +763,12 @@ pub struct PipelineSimState {
     pub cycle_count: u64,
     pub instr_committed: u64,
     pub stall_count: u64,
+    /// Stall cycles broken down by hazard type (indexed by HazardType::as_stall_index).
+    /// Indices: 0=RAW, 1=LoadUse, 2=BranchFlush, 3=FuBusy, 4=MemLatency.
+    pub stall_by_type: [u64; HazardType::STALL_TYPE_COUNT],
     pub flush_count: u64,
+    /// Total branch and jump instructions committed.
+    pub branches_executed: u64,
     pub class_counts: [u64; InstrClass::COUNT],
 
     // ── Gantt history ──
@@ -802,7 +824,9 @@ impl PipelineSimState {
             cycle_count: 0,
             instr_committed: 0,
             stall_count: 0,
+            stall_by_type: [0; HazardType::STALL_TYPE_COUNT],
             flush_count: 0,
+            branches_executed: 0,
             class_counts: [0; InstrClass::COUNT],
             gantt: VecDeque::new(),
             speed: PipelineSpeed::Normal,

src/ui/pipeline/sim.rs

@@ -47,6 +47,9 @@ pub fn pipeline_tick(
     if let Some((stall_stage, hazard)) = stall {
         insert_stall(state, stall_stage, hazard, cpu, mem, console);
         state.stall_count += 1;
+        if let Some(idx) = hazard.as_stall_index() {
+            state.stall_by_type[idx] += 1;
+        }
     } else {
         advance_stages(state, cpu, mem, cpi, console);
     }
@@ -434,17 +437,12 @@ fn stage_ex(slot: &mut PipeSlot) {
                 _ => 0x000,
             };
         }
+        // Fused multiply-add family: rs3 is read at ID and stored in slot.mem_addr
+        // (the FP ALU instructions never use mem_addr for actual addressing).
+        // Forwarding for rs3 is handled in apply_forwarding_to_id (same field).
         Instruction::FmaddS { .. } => {
             let a = f32::from_bits(slot.rs1_val);
             let b = f32::from_bits(slot.rs2_val);
-            // rs3 is not in our slot — we only have rs1/rs2. For fused ops, we stored rs3's
-            // value... actually we don't have an rs3_val field. We'll need the instruction's rs3.
-            // For now, use the decoded instruction to get rs3 index and read from the slot's
-            // existing values. But we need a workaround here.
-            // Actually: fmadd uses rs1, rs2, rs3 — but we only read rs1, rs2 at ID.
-            // For rs3, we need to handle it specially at ID stage.
-            // WORKAROUND: store rs3 value in mem_addr field (reusing unused field for FP arith)
-            // This is set in stage_id via special handling.
             let c = f32::from_bits(slot.mem_addr.unwrap_or(0));
             slot.alu_result = (a * b + c).to_bits();
         }
@@ -1481,6 +1479,9 @@ fn commit_wb(
 
     state.instr_committed += 1;
     state.class_counts[slot.class.as_usize()] += 1;
+    if matches!(slot.class, InstrClass::Branch | InstrClass::Jump) {
+        state.branches_executed += 1;
+    }
 
     Some(CommitInfo {
         pc: slot.pc,
@@ -2087,6 +2088,8 @@ fn advance_stages(
                     s.hazard = Some(HazardType::MemLatency);
                 }
             }
+            state.stall_count += 1;
+            state.stall_by_type[HazardType::FuBusy.as_stall_index().unwrap()] += 1;
             return;
         }
     }
@@ -2145,6 +2148,7 @@ fn advance_stages(
             s.hazard = Some(HazardType::MemLatency);
         }
         state.stall_count += 1;
+        state.stall_by_type[HazardType::MemLatency.as_stall_index().unwrap()] += 1;
     }
 
     let ex_producer = state.stages[Stage::EX as usize].clone();
@@ -2303,6 +2307,7 @@ fn update_gantt(state: &mut PipelineSimState) {
             None => continue,
             Some(s) if s.is_bubble && s.hazard == Some(HazardType::BranchFlush) => GanttCell::Flush,
             Some(s) if s.is_bubble => GanttCell::Bubble,
+            Some(s) if s.is_speculative => GanttCell::Speculative(stage),
             Some(_) => GanttCell::InStage(stage),
         };
         if let Some(slot) = maybe_slot {
@@ -2317,15 +2322,20 @@ fn update_gantt(state: &mut PipelineSimState) {
             };
             let row = state.gantt.iter_mut().find(|r| r.pc == pc && !r.done);
             if let Some(row) = row {
-                let emit_cell = if let GanttCell::InStage(s) = cell {
-                    if row.last_stage == Some(s) {
-                        GanttCell::Stall
-                    } else {
+                let emit_cell = match cell {
+                    GanttCell::InStage(s) => {
+                        if row.last_stage == Some(s) {
+                            GanttCell::Stall
+                        } else {
+                            row.last_stage = Some(s);
+                            GanttCell::InStage(s)
+                        }
+                    }
+                    GanttCell::Speculative(s) => {
                         row.last_stage = Some(s);
-                        GanttCell::InStage(s)
+                        GanttCell::Speculative(s)
                     }
-                } else {
-                    cell
+                    _ => cell,
                 };
                 let expected_len = (cycle - row.first_cycle) as usize;
                 while row.cells.len() < expected_len {
@@ -2340,10 +2350,9 @@ fn update_gantt(state: &mut PipelineSimState) {
                     row.cells.pop_front();
                 }
             } else {
-                let initial_stage = if let GanttCell::InStage(s) = cell {
-                    Some(s)
-                } else {
-                    None
+                let initial_stage = match cell {
+                    GanttCell::InStage(s) | GanttCell::Speculative(s) => Some(s),
+                    _ => None,
                 };
                 let mut new_row = GanttRow {
                     pc,

src/ui/view/pipeline/main_view.rs

@@ -941,13 +941,21 @@ fn render_gantt(f: &mut Frame, area: Rect, app: &App) {
 }
 
 fn cell_to_span(cell: GanttCell) -> (&'static str, Style) {
+    // Speculative stages: same label as InStage but in orange — shows instruction
+    // was fetched/decoded speculatively while a branch was unresolved.
+    let spec_style = Style::default().fg(Color::Rgb(220, 140, 40));
     match cell {
         GanttCell::Empty => ("·", Style::default().fg(theme::BORDER)),
         GanttCell::InStage(Stage::IF) => ("IF", Style::default().fg(theme::ACCENT)),
         GanttCell::InStage(Stage::ID) => ("ID", Style::default().fg(theme::LABEL_Y)),
         GanttCell::InStage(Stage::EX) => ("EX", Style::default().fg(theme::RUNNING)),
         GanttCell::InStage(Stage::MEM) => ("MM", Style::default().fg(theme::LABEL_Y)),
         GanttCell::InStage(Stage::WB) => ("WB", Style::default().fg(theme::ACCENT)),
+        GanttCell::Speculative(Stage::IF) => ("IF", spec_style),
+        GanttCell::Speculative(Stage::ID) => ("ID", spec_style),
+        GanttCell::Speculative(Stage::EX) => ("EX", spec_style),
+        GanttCell::Speculative(Stage::MEM) => ("MM", spec_style),
+        GanttCell::Speculative(Stage::WB) => ("WB", spec_style),
         GanttCell::Stall => ("──", Style::default().fg(theme::PAUSED)),
         GanttCell::Bubble => (
             "NOP",

src/ui/view/pipeline/mod.rs

@@ -167,20 +167,36 @@ fn render_exec_controls(f: &mut Frame, area: Rect, app: &App) {
     ));
     let line1 = Line::from(spans);
 
-    let cpi_str = if p.instr_committed > 0 {
-        format!(
-            " Cycle:{}  CPI:{:.2}  instrs:{}  stalls:{}  flushes:{}",
-            p.cycle_count,
-            p.cycle_count as f64 / p.instr_committed as f64,
-            p.instr_committed,
-            p.stall_count,
-            p.flush_count,
-        )
+    let (cpi_str, stall_str) = if p.instr_committed > 0 {
+        let cpi = p.cycle_count as f64 / p.instr_committed as f64;
+        let branch_str = if p.branches_executed > 0 {
+            let mispredict_pct =
+                p.flush_count as f64 / p.branches_executed as f64 * 100.0;
+            format!(
+                "  branches:{}  mispred:{} ({:.0}%)",
+                p.branches_executed, p.flush_count, mispredict_pct
+            )
+        } else {
+            String::new()
+        };
+        let main = format!(
+            " Cycle:{}  CPI:{cpi:.2}  instrs:{}  stalls:{}{}",
+            p.cycle_count, p.instr_committed, p.stall_count, branch_str,
+        );
+        let [raw, lu, br, fu, mem] = p.stall_by_type;
+        let detail = format!(
+            " Stalls — RAW:{raw}  Load-Use:{lu}  Branch:{br}  FU:{fu}  Mem:{mem}"
+        );
+        (main, detail)
     } else {
-        format!(" Cycle:{}  (nenhuma instrução committed)", p.cycle_count)
+        (
+            format!(" Cycle:{}  (no instructions committed)", p.cycle_count),
+            String::new(),
+        )
     };
 
     let line2 = Line::from(Span::styled(cpi_str, Style::default().fg(theme::LABEL)));
+    let line3 = Line::from(Span::styled(stall_str, Style::default().fg(theme::LABEL)));
 
     let block = Block::default()
         .borders(Borders::ALL)
@@ -189,7 +205,7 @@ fn render_exec_controls(f: &mut Frame, area: Rect, app: &App) {
         .title(Span::styled("Execução", Style::default().fg(theme::LABEL)));
     let inner = block.inner(area);
     f.render_widget(block, area);
-    f.render_widget(Paragraph::new(vec![line1, line2]), inner);
+    f.render_widget(Paragraph::new(vec![line1, line2, line3]), inner);
 
     // Record button geometry for mouse
     // speed <label>   state <label>   reset