forge/profile/

report.rs

#![expect(
    clippy::cast_possible_truncation,
    clippy::cast_sign_loss,
    reason = "clamped non-negative percentages are converted to bounded text bar widths"
)]

use tabled::Tabled;
use wowlab_common::output::{self, fmt_duration, fmt_number, fmt_pct, truncate};

use super::{
    analyze::{ProfileAnalysis, clean_name},
    categories,
    monitor::{HostStats, RuntimeStats},
};

const BAR_WIDTH: usize = 40;
const MAX_FUNC_NAME_LEN: usize = 55;
const MAX_CATEGORY_FUNC_NAME_LEN: usize = 65;
const MAX_HOTSPOT_NAME_LEN: usize = 70;
const MAX_CALLER_NAME_LEN: usize = 60;
const MAX_TOP_HOTSPOT_NAME_LEN: usize = 75;
const MAX_CATEGORY_FUNCS: usize = 5;
const MAX_HOTSPOT_CONTEXTS: usize = 10;
const MAX_CALLER_CALLEE: usize = 3;
const MAX_SOURCE_FILES: usize = 15;

#[derive(Tabled)]
struct HotFunctionRow {
    #[tabled(rename = "Self%")]
    self_pct: String,
    #[tabled(rename = "Total%")]
    total_pct: String,
    #[tabled(rename = "Samples")]
    samples: String,
    #[tabled(rename = "Category")]
    category: String,
    #[tabled(rename = "Function")]
    name: String,
}

#[derive(Tabled)]
// #t(rust_similar_structs) bottleneck and hot-function rows are independent report tables with different columns
struct BottleneckRow {
    #[tabled(rename = "Self%")]
    self_pct: String,
    #[tabled(rename = "Total%")]
    total_pct: String,
    #[tabled(rename = "Category")]
    category: String,
    #[tabled(rename = "Function")]
    name: String,
}

#[derive(Tabled)]
struct SourceFileRow {
    #[tabled(rename = "%")]
    pct: String,
    #[tabled(rename = "File")]
    path: String,
}

#[derive(Tabled)]
struct SubsystemRow {
    #[tabled(rename = "%")]
    pct: String,
    #[tabled(rename = "Bar")]
    bar: String,
    #[tabled(rename = "Subsystem")]
    name: String,
}

pub(super) fn print_text(result: &ProfileAnalysis, host: &HostStats, process: &RuntimeStats) {
    output::separator();
    output::header("Engine Profile Results");
    output::blank();

    output::kv("Spec", &result.spec);
    output::kv_fmt("Iterations", fmt_number(f64::from(result.iterations)));
    output::kv("Duration", &fmt_duration(result.duration_sec));
    output::kv_fmt(
        "Throughput",
        format!("{} sims/sec", fmt_number(result.throughput)),
    );
    output::kv_fmt("Samples", result.total_samples);
    output::kv_fmt(
        "Unresolved",
        format!("{} symbols", result.unresolved_symbols),
    );
    output::blank();

    print_machine(host);
    print_process(process);
    print_observations(&result.observations);
    print_subsystem_breakdown(&result.categories);
    print_category_functions(result);
    print_bottlenecks(&result.bottlenecks);
    print_hot_functions(&result.functions);
    print_hotspot_context(&result.hotspot_context);
    print_source_files(&result.source_files);
    print_top_hotspots(&result.functions);
}

fn print_machine(host: &HostStats) {
    if host.platform.is_empty() {
        return;
    }

    output::subheader("Machine");
    output::kv("CPU", &host.cpu_model);
    output::kv_fmt(
        "Cores",
        format!(
            "{} physical / {} logical",
            host.physical_cpus, host.logical_cpus
        ),
    );
    output::kv_fmt("Memory", format!("{:.1} GB", host.memory_gb));
    output::blank();
}

fn print_process(process: &RuntimeStats) {
    if process.sample_count == 0 {
        return;
    }

    output::subheader("Process (clean run)");
    output::kv_fmt(
        "CPU",
        format!(
            "{:.0}% avg / {:.0}% peak ({} samples)",
            process.proc_cpu_pct_avg, process.proc_cpu_pct_max, process.sample_count
        ),
    );
    output::kv_fmt(
        "RSS",
        format!(
            "{:.1} MB avg / {:.1} MB peak",
            process.rss_mb_avg, process.rss_mb_max
        ),
    );

    if process.threads_max > 0 {
        output::kv_fmt(
            "Threads",
            format!(
                "{:.0} avg / {} peak",
                process.threads_avg, process.threads_max
            ),
        );
    }

    output::blank();
}

fn print_observations(observations: &[String]) {
    if observations.is_empty() {
        return;
    }

    output::subheader("Observations");

    for obs in observations {
        output::warning(obs);
    }

    output::blank();
}

fn print_subsystem_breakdown(categories: &[(String, f64)]) {
    output::subheader("Time Breakdown by Subsystem");
    let rows: Vec<SubsystemRow> = categories
        .iter()
        .filter(|(cat, _)| cat != "stdlib")
        .map(|(cat, pct)| {
            let bar_len = (*pct as usize).min(BAR_WIDTH);

            SubsystemRow {
                pct: format!("{pct:.1}%"),
                bar: format!("{}{}", "#".repeat(bar_len), ".".repeat(BAR_WIDTH - bar_len)),
                name: cat.clone(),
            }
        })
        .collect();

    output::table(rows);
    output::blank();
}

fn print_category_functions(result: &ProfileAnalysis) {
    output::subheader("Per-Category Function Breakdown");

    for (cat, pct) in &result.categories {
        if cat == "stdlib" {
            continue;
        }

        let Some(funcs) = result.category_functions.get(cat) else {
            continue;
        };

        if funcs.is_empty() {
            continue;
        }

        let desc = categories::description(cat);

        // #t(rust_alloc_in_loop) category header formatted once per category
        output::info(&format!("  [{}] {}  {}", cat, fmt_pct(*pct / 100.0), desc));

        // #t(block: rust_alloc_in_loop) per-function detail lines, bounded by MAX_CATEGORY_FUNCS
        for f in funcs.iter().take(MAX_CATEGORY_FUNCS) {
            output::detail(&format!(
                "{} self  {} total  {}",
                fmt_pct(f.self_pct / 100.0),
                fmt_pct(f.total_pct / 100.0),
                truncate(&f.name, MAX_CATEGORY_FUNC_NAME_LEN),
            ));
        }

        output::blank();
    }
}

fn print_bottlenecks(bottlenecks: &[super::analyze::Function]) {
    if bottlenecks.is_empty() {
        return;
    }

    output::subheader("Bottleneck Parents (high total%, low self%)");
    let rows: Vec<BottleneckRow> = bottlenecks
        .iter()
        .map(|f| BottleneckRow {
            self_pct: format!("{:.1}", f.self_pct),
            total_pct: format!("{:.1}", f.total_pct),
            category: f.category.clone(),
            name: truncate(&clean_name(&f.name), MAX_FUNC_NAME_LEN),
        })
        .collect();

    output::table(rows);
    output::blank();
}

fn print_hot_functions(functions: &[super::analyze::Function]) {
    output::subheader("Hot Functions (excluding stdlib)");
    let rows: Vec<HotFunctionRow> = functions
        .iter()
        .map(|f| HotFunctionRow {
            self_pct: format!("{:.1}", f.self_pct),
            total_pct: format!("{:.1}", f.total_pct),
            samples: f.self_samples.to_string(),
            category: f.category.clone(),
            name: truncate(&clean_name(&f.name), MAX_FUNC_NAME_LEN),
        })
        .collect();

    output::table(rows);
    output::blank();
}

// #t(fn: rust_alloc_in_loop) formatting caller/callee detail lines per hotspot
fn print_hotspot_context(contexts: &[super::analyze::HotspotContext]) {
    if contexts.is_empty() {
        return;
    }

    output::subheader("Hotspot Context (callers/callees)");

    for ctx in contexts.iter().take(MAX_HOTSPOT_CONTEXTS) {
        output::info(&format!(
            "  [{} self, {} total] {}",
            fmt_pct(ctx.self_pct / 100.0),
            fmt_pct(ctx.total_pct / 100.0),
            truncate(&ctx.name, MAX_HOTSPOT_NAME_LEN),
        ));

        for c in ctx.callers.iter().take(MAX_CALLER_CALLEE) {
            output::detail(&format!(
                "<- {}  {}",
                fmt_pct(c.pct / 100.0),
                truncate(&c.name, MAX_CALLER_NAME_LEN)
            ));
        }

        for c in ctx.callees.iter().take(MAX_CALLER_CALLEE) {
            output::detail(&format!(
                "-> {}  {}",
                fmt_pct(c.pct / 100.0),
                truncate(&c.name, MAX_CALLER_NAME_LEN)
            ));
        }

        output::blank();
    }
}

fn print_source_files(files: &[(String, f64)]) {
    if files.is_empty() {
        return;
    }

    output::subheader("Hot Source Files");
    let rows: Vec<SourceFileRow> = files
        .iter()
        .take(MAX_SOURCE_FILES)
        .map(|(path, pct)| SourceFileRow {
            pct: format!("{pct:.1}%"),
            path: path.clone(),
        })
        .collect();

    output::table(rows);
    output::blank();
}

fn print_top_hotspots(functions: &[super::analyze::Function]) {
    output::separator();
    output::header("Top 10 Hotspots");

    // #t(block: rust_alloc_in_loop) report formatting, bounded by analysis results
    for (i, f) in functions.iter().take(MAX_HOTSPOT_CONTEXTS).enumerate() {
        output::info(&format!(
            "  {:>2}. [{}] [{}] {}",
            i + 1,
            fmt_pct(f.self_pct / 100.0),
            f.category,
            truncate(&clean_name(&f.name), MAX_TOP_HOTSPOT_NAME_LEN),
        ));
    }

    output::blank();
}

pub(super) fn print_json(result: &ProfileAnalysis, host: &HostStats, process: &RuntimeStats) {
    #[derive(serde::Serialize)]
    struct JsonOutput<'a> {
        host: &'a HostStats,
        process: &'a RuntimeStats,
        #[serde(flatten)]
        analysis: &'a ProfileAnalysis,
        category_descriptions: wowlab_types::sim::FastMap<&'static str, &'static str>,
    }

    let descriptions: wowlab_types::sim::FastMap<&str, &str> = categories::CATEGORIES
        .iter()
        .map(|c| (c.name, c.description))
        .chain([
            ("stdlib", categories::description("stdlib")),
            ("other", categories::description("other")),
        ])
        .collect();

    output::json(&JsonOutput {
        host,
        process,
        analysis: result,
        category_descriptions: descriptions,
    });
}

pub(super) fn print_bench_summary(bench_output: &str) {
    output::separator();
    output::header("Benchmark Results");
    output::blank();

    for line in bench_output.lines() {
        output::detail(line);
    }

    output::blank();
}