perf(tui): optimize render complexity to O(1) and fix 100% CPU lock during scans

- Fix 100% CPU core utilization (100.3% CPU in htop) caused by unthrottled per-frame O(42N) iterations over scan logs in the UI renderer.
- Fix UI freezes, stuck progress counters, and buffered keyboard input latency during large CIDR scans.
- Introduce incremental HashMap indexing (app.port_stats and filtered_log_indices) for instantaneous O(1) TUI frame rendering.
- Add 60 FPS frame rate cap (16ms poll timeout) and batch background event channel drains (2000 events/frame) for smooth input handling.
- Bump version to 1.4.6.

Author: gondimcodes

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "ampscan"
-version = "1.4.5"
+version = "1.4.6"
 edition = "2021"
 description = "DDoS Amplification Port Testing Tool with TUI"
 authors = ["Marcelo Gondim"]

Cargo.toml

@@ -266,5 +266,5 @@ Below is the complete list of standard command-line instructions to manually and
 This repository supports build and test automation via **Woodpecker CI** hosted on Codeberg:
 
 * **Continuous Integration (CI):** On every `push` or `pull_request` sent to the `main` branch, the complete unit and integration test suite is executed automatically (with parallelism limited to `-j 1` to respect Codeberg's shared resource guidelines).
-* **Continuous Delivery (CD):** When creating and pushing a version tag (e.g., `v1.4.5`), the pipeline compiles the binary (`ampscan`) in production mode (Release) for Linux x86_64, compresses it into a `.tar.gz` file, and attaches the final file directly to the Releases page on Codeberg.
+* **Continuous Delivery (CD):** When creating and pushing a version tag (e.g., `v1.4.6`), the pipeline compiles the binary (`ampscan`) in production mode (Release) for Linux x86_64, compresses it into a `.tar.gz` file, and attaches the final file directly to the Releases page on Codeberg.
 

README.md

@@ -1,6 +1,6 @@
 # Technology Stack & Architecture — AmpScan
 
-This document provides a comprehensive overview of the technology stack, external crates, system libraries, and architectural decisions powering **ampscan** (v1.4.5).
+This document provides a comprehensive overview of the technology stack, external crates, system libraries, and architectural decisions powering **ampscan** (v1.4.6).
 
 ---
 

TECH_STACK.md

@@ -71,6 +71,8 @@ pub struct App {
     // Scan Data & Logs
     pub stats: ScanStats,
     pub logs: Vec<ProbeResult>,
+    pub filtered_log_indices: Vec<usize>,
+    pub port_stats: std::collections::HashMap<u16, (usize, usize)>,
     pub selected_log_index: usize,
 
     // DB Data Cache for TUI
@@ -116,6 +118,8 @@ impl App {
             is_scanning: false,
             stats: ScanStats::default(),
             logs: Vec::new(),
+            filtered_log_indices: Vec::new(),
+            port_stats: std::collections::HashMap::new(),
             selected_log_index: 0,
             prefixes: Vec::new(),
             ports: Vec::new(),
@@ -133,7 +137,7 @@ impl App {
             pdf_output,
             pdf_client_name,
             pdf_recipient,
-            status_message: Some("Ready - Press [S] to start scanning target".to_string()),
+            status_message: None,
         }
     }
 
@@ -153,23 +157,45 @@ impl App {
         self.active_tab = Tab::ALL[prev_idx];
     }
 
+    pub fn clear_scan_data(&mut self) {
+        self.logs.clear();
+        self.filtered_log_indices.clear();
+        self.port_stats.clear();
+        self.selected_log_index = 0;
+        self.stats = ScanStats::default();
+        self.stats.start_time = Some(std::time::Instant::now());
+    }
+
     pub fn get_filtered_findings_count(&self) -> usize {
-        self.logs
-            .iter()
-            .filter(|log| {
-                log.status == crate::scanner::result::PortStatus::Open
-                    || log.status == crate::scanner::result::PortStatus::OpenProtected
-            })
-            .count()
+        self.filtered_log_indices.len()
     }
 
     pub fn add_probe_result(&mut self, result: ProbeResult) {
+        let is_finding = matches!(
+            result.status,
+            crate::scanner::result::PortStatus::Open | crate::scanner::result::PortStatus::OpenProtected
+        );
+
         match &result.status {
-            crate::scanner::result::PortStatus::Open => self.stats.vulnerable_count += 1,
-            crate::scanner::result::PortStatus::OpenProtected => self.stats.protected_count += 1,
+            crate::scanner::result::PortStatus::Open => {
+                self.stats.vulnerable_count += 1;
+                let entry = self.port_stats.entry(result.port).or_default();
+                entry.0 += 1;
+            }
+            crate::scanner::result::PortStatus::OpenProtected => {
+                self.stats.protected_count += 1;
+                let entry = self.port_stats.entry(result.port).or_default();
+                entry.1 += 1;
+            }
             _ => self.stats.closed_count += 1,
         }
         self.stats.completed_probes += 1;
+        
+        let new_idx = self.logs.len();
         self.logs.push(result);
+
+        if is_finding {
+            self.filtered_log_indices.push(new_idx);
+        }
     }
 }

src/tui/app.rs

@@ -10,7 +10,7 @@ pub enum UserAction {
 }
 
 pub fn handle_events(app: &mut App) -> io::Result<UserAction> {
-    if event::poll(Duration::from_millis(50))? {
+    if event::poll(Duration::from_millis(16))? {
         if let Event::Key(key) = event::read()? {
             if key.kind == event::KeyEventKind::Press {
                 // Handle text input on SingleTarget and Settings tabs

src/tui/events.rs

@@ -63,70 +63,77 @@ pub async fn run_tui(
 
     // Main TUI Event Loop
     loop {
-        // Drain any incoming scan events from background task
-        while let Ok(tui_event) = rx.try_recv() {
-            match tui_event {
-                TuiEvent::ScanStarted(total) => {
-                    app.stats.total_probes = total;
-                }
-                TuiEvent::ProbeCompleted(res) => {
-                    app.add_probe_result(res);
-                }
-                TuiEvent::ScanFinished => {
-                    app.is_scanning = false;
-
-                    // If --pdf flag was supplied via CLI, generate PDF report automatically
-                    if app.pdf_export {
-                        let scan_id = uuid::Uuid::new_v4().to_string();
-                        let prefixes: Vec<String> = app.prefixes.iter().map(|p| p.prefix.clone()).collect();
-                        let mut report = crate::scanner::result::ScanReport::new(scan_id, prefixes);
-                        
-                        // Calculate total unique IPs tested from logs
-                        let mut unique_ips: Vec<_> = app.logs.iter().map(|l| l.ip).collect();
-                        unique_ips.sort();
-                        unique_ips.dedup();
-                        
-                        report.total_ips = unique_ips.len();
-                        report.total_probes = app.stats.total_probes.max(app.logs.len());
-                        report.results = app.logs.clone();
-                        
-                        // Preserve start time if available
-                        if let Some(start_inst) = app.stats.start_time {
-                            let elapsed = start_inst.elapsed();
-                            report.started_at = chrono::Utc::now() - chrono::Duration::from_std(elapsed).unwrap_or_default();
+        // Drain incoming scan events from background task in batches to ensure smooth 60 FPS rendering
+        let mut processed = 0;
+        while processed < 2000 {
+            match rx.try_recv() {
+                Ok(tui_event) => {
+                    processed += 1;
+                    match tui_event {
+                        TuiEvent::ScanStarted(total) => {
+                            app.stats.total_probes = total;
+                        }
+                        TuiEvent::ProbeCompleted(res) => {
+                            app.add_probe_result(res);
                         }
-                        
-                        report.finalize();
+                        TuiEvent::ScanFinished => {
+                            app.is_scanning = false;
 
-                        let app_config = crate::report::AppConfig::load();
-                        match crate::report::generate_pdf(
-                            &report,
-                            &app.pdf_output,
-                            app.pdf_client_name.as_deref(),
-                            app.pdf_recipient.as_deref(),
-                            &app_config,
-                        ) {
-                            Ok(_) => {
-                                app.status_message = Some(format!(
-                                    "Scan completed! PDF report generated: {}",
-                                    app.pdf_output
-                                ));
-                            }
-                            Err(e) => {
-                                app.status_message = Some(format!(
-                                    "Scan completed! PDF report error: {}",
-                                    e
-                                ));
+                            // If --pdf flag was supplied via CLI, generate PDF report automatically
+                            if app.pdf_export {
+                                let scan_id = uuid::Uuid::new_v4().to_string();
+                                let prefixes: Vec<String> = app.prefixes.iter().map(|p| p.prefix.clone()).collect();
+                                let mut report = crate::scanner::result::ScanReport::new(scan_id, prefixes);
+                                
+                                // Calculate total unique IPs tested from logs
+                                let mut unique_ips: Vec<_> = app.logs.iter().map(|l| l.ip).collect();
+                                unique_ips.sort();
+                                unique_ips.dedup();
+                                
+                                report.total_ips = unique_ips.len();
+                                report.total_probes = app.stats.total_probes.max(app.logs.len());
+                                report.results = app.logs.clone();
+                                
+                                // Preserve start time if available
+                                if let Some(start_inst) = app.stats.start_time {
+                                    let elapsed = start_inst.elapsed();
+                                    report.started_at = chrono::Utc::now() - chrono::Duration::from_std(elapsed).unwrap_or_default();
+                                }
+                                
+                                report.finalize();
+
+                                let app_config = crate::report::AppConfig::load();
+                                match crate::report::generate_pdf(
+                                    &report,
+                                    &app.pdf_output,
+                                    app.pdf_client_name.as_deref(),
+                                    app.pdf_recipient.as_deref(),
+                                    &app_config,
+                                ) {
+                                    Ok(_) => {
+                                        app.status_message = Some(format!(
+                                            "Scan completed! PDF report generated: {}",
+                                            app.pdf_output
+                                        ));
+                                    }
+                                    Err(e) => {
+                                        app.status_message = Some(format!(
+                                            "Scan completed! PDF report error: {}",
+                                            e
+                                        ));
+                                    }
+                                }
+                            } else {
+                                app.status_message = Some("Scan completed!".to_string());
                             }
                         }
-                    } else {
-                        app.status_message = Some("Scan completed!".to_string());
+                        TuiEvent::ScanError(msg) => {
+                            app.is_scanning = false;
+                            app.status_message = Some(format!("Scan error: {}", msg));
+                        }
                     }
                 }
-                TuiEvent::ScanError(msg) => {
-                    app.is_scanning = false;
-                    app.status_message = Some(format!("Scan error: {}", msg));
-                }
+                Err(_) => break,
             }
         }
 
@@ -146,9 +153,7 @@ pub async fn run_tui(
                             app.status_message = Some(format!("Invalid IP or CIDR Prefix: '{}'", target_str));
                         } else {
                             app.is_scanning = true;
-                            app.logs.clear();
-                            app.stats = app::ScanStats::default();
-                            app.stats.start_time = Some(std::time::Instant::now());
+                            app.clear_scan_data();
 
                             let db_path = app.db_path.clone();
                             let db_key = app.db_key.clone();
@@ -195,9 +200,7 @@ pub async fn run_tui(
                 events::UserAction::StartFullScan => {
                     if !app.is_scanning {
                         app.is_scanning = true;
-                        app.logs.clear();
-                        app.stats = app::ScanStats::default();
-                        app.stats.start_time = Some(std::time::Instant::now());
+                        app.clear_scan_data();
 
                         let db_path = app.db_path.clone();
                         let db_key = app.db_key.clone();

src/tui/mod.rs

@@ -210,14 +210,7 @@ fn render_results_viewer(frame: &mut Frame, app: &App, area: Rect) {
         .map(|h| Span::styled(*h, Style::default().fg(Color::Cyan).add_modifier(Modifier::BOLD)));
     let header = Row::new(header_cells).height(1).bottom_margin(1);
 
-    // Filter logs to ONLY show Vulnerable (Open) and Open/Protected findings
-    let filtered_logs: Vec<_> = app
-        .logs
-        .iter()
-        .filter(|log| log.status == PortStatus::Open || log.status == PortStatus::OpenProtected)
-        .collect();
-
-    let total_findings = filtered_logs.len();
+    let total_findings = app.filtered_log_indices.len();
 
     // Dynamically calculate visible rows based on left component height
     let visible_height = (left_area.height as usize).saturating_sub(4);
@@ -237,31 +230,39 @@ fn render_results_viewer(frame: &mut Frame, app: &App, area: Rect) {
         ideal_start.min(max_start)
     };
 
-    let rows = filtered_logs.iter().enumerate().skip(start_idx).take(visible_height).map(|(idx, log)| {
-        let is_selected = idx == selected_idx;
-        let (status_str, status_style) = match &log.status {
-            PortStatus::Open => ("VULNERABLE", Style::default().fg(Color::Red).add_modifier(Modifier::BOLD)),
-            PortStatus::OpenProtected => ("Open/Protected", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
-            _ => ("Other", Style::default().fg(Color::DarkGray)),
-        };
-
-        let latency_str = log.response_time_ms.map(|ms| format!("{} ms", ms)).unwrap_or_else(|| "-".to_string());
-
-        let row_style = if is_selected {
-            Style::default().bg(Color::DarkGray).fg(Color::White).add_modifier(Modifier::BOLD)
-        } else {
-            Style::default()
-        };
-
-        Row::new(vec![
-            Span::raw((idx + 1).to_string()),
-            Span::raw(log.ip.to_string()),
-            Span::raw(log.port.to_string()),
-            Span::raw(log.service_name.clone()),
-            Span::styled(status_str, status_style),
-            Span::raw(latency_str),
-        ]).style(row_style)
-    });
+    let rows = app
+        .filtered_log_indices
+        .iter()
+        .skip(start_idx)
+        .take(visible_height)
+        .enumerate()
+        .map(|(rel_idx, &log_idx)| {
+            let abs_idx = start_idx + rel_idx;
+            let is_selected = abs_idx == selected_idx;
+            let log = &app.logs[log_idx];
+            let (status_str, status_style) = match &log.status {
+                PortStatus::Open => ("VULNERABLE", Style::default().fg(Color::Red).add_modifier(Modifier::BOLD)),
+                PortStatus::OpenProtected => ("Open/Protected", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
+                _ => ("Other", Style::default().fg(Color::DarkGray)),
+            };
+
+            let latency_str = log.response_time_ms.map(|ms| format!("{} ms", ms)).unwrap_or_else(|| "-".to_string());
+
+            let row_style = if is_selected {
+                Style::default().bg(Color::DarkGray).fg(Color::White).add_modifier(Modifier::BOLD)
+            } else {
+                Style::default()
+            };
+
+            Row::new(vec![
+                Span::raw((abs_idx + 1).to_string()),
+                Span::raw(log.ip.to_string()),
+                Span::raw(log.port.to_string()),
+                Span::raw(log.service_name.clone()),
+                Span::styled(status_str, status_style),
+                Span::raw(latency_str),
+            ]).style(row_style)
+        });
 
     let display_counter = if total_findings == 0 { 0 } else { selected_idx + 1 };
     let title_text = if total_findings == 0 {
@@ -302,8 +303,7 @@ fn render_results_viewer(frame: &mut Frame, app: &App, area: Rect) {
 
     if !app.ports.is_empty() {
         for port in &app.ports {
-            let vuln = app.logs.iter().filter(|l| l.port == port.port && l.status == PortStatus::Open).count();
-            let prot = app.logs.iter().filter(|l| l.port == port.port && l.status == PortStatus::OpenProtected).count();
+            let (vuln, prot) = app.port_stats.get(&port.port).copied().unwrap_or((0, 0));
             stats_list.push(PortStat {
                 display_name: format!("{} ({}/{})", port.name, port.port, port.protocol),
                 vulnerable: vuln,