layers/profiling/stats.py

#!/usr/bin/env python3
import json
import subprocess
import tempfile
import os
import sys
import argparse
import pandas as pd
from statistics import median
from concurrent.futures import ThreadPoolExecutor, as_completed
import math
import csv

def validate_json(json_data):
    """Validate the JSON data structure."""
    if not isinstance(json_data, dict):
        raise ValueError("JSON data must be a dictionary.")
    if "zone" not in json_data:
        raise ValueError("JSON data must contain a 'zone' key.")
    if not isinstance(json_data["zone"], list) or not all(isinstance(item, str) for item in json_data["zone"]):
        raise ValueError("The 'zone' key must be an array of strings.")

def run_tracy_export(tracy_csvexport_path, tracy_file, args, filter_substring=None):
    """Run tracy-csvexport with the given arguments and filter."""
    command = [tracy_csvexport_path] + args  # e.g., "-g" or "-u"
    if filter_substring:
        command.extend(["-f", filter_substring])
    command.append(tracy_file)  # File name is always the last argument

    with tempfile.NamedTemporaryFile(mode='w+', delete=False, suffix=".csv") as tmp_file:
        subprocess.run(command, stdout=tmp_file)
        tmp_file_path = tmp_file.name

    return tmp_file_path

def process_csv(file_path, columns, verbose=False):
    """Process the CSV file and extract relevant data."""
    try:
        df = pd.read_csv(file_path, skiprows=1, header=None)
        if df.empty:  # Skip processing if the CSV is empty
            return None
        df.columns = columns
        return df
    except pd.errors.EmptyDataError:
        return None

def compute_statistics(data):
    """Compute statistics (count, average, median, min, max) for the given data list."""
    stats = {
        "count": len(data),
        "average": sum(data) / len(data),
        "median": median(data),
        "min": min(data),
        "max": max(data)
    }
    return stats

def process_gpu_data_substring(substring, tracy_file, tracy_csvexport_path, verbose=False):
    """
    Process GPU data for a single zone substring.
    Returns a dictionary mapping zone names to lists of GPU times.
    """
    result = {}
    if verbose:
        print(f"Processing GPU zone {substring}...")
    csv_file = run_tracy_export(tracy_csvexport_path, tracy_file, ["-g"], substring)
    df = process_csv(csv_file, ["name", "source_file", "time_start", "gpu_time"], verbose)
    os.remove(csv_file)

    if df is not None:
        for _, row in df.iterrows():
            name = row["name"]
            gpu_time = row["gpu_time"]
            result.setdefault(name, []).append(gpu_time)
    return result

def process_unwrap_data_substring(substring, tracy_file, tracy_csvexport_path, verbose=False):
    """
    Process CPU data for a single zone substring.
    Returns a dictionary mapping zone names to lists of execution times.
    """
    result = {}
    if verbose:
        print(f"Processing CPU zone {substring}...")
    csv_file = run_tracy_export(tracy_csvexport_path, tracy_file, ["-u"], substring)
    df = process_csv(csv_file, ["name", "source_file", "source_line", "time_start", "exec_time", "thread", "value"], verbose)
    os.remove(csv_file)

    if df is not None:
        for _, row in df.iterrows():
            name = row["name"]
            exec_time = row["exec_time"]
            result.setdefault(name, []).append(exec_time)
    return result

def main(tracy_csvexport_path, tracy_file, zones_override, zones_json, verbose, csv_path):
    # Determine the zone substrings to use.
    if zones_override:
        zone_substrings = [z.strip() for z in zones_override.split(',') if z.strip()]
    elif zones_json:
        try:
            with open(zones_json, 'r') as f:
                json_data = json.load(f)
            validate_json(json_data)
            zone_substrings = json_data["zone"]
        except Exception as e:
            print(f"Error loading JSON file '{zones_json}': {e}")
            sys.exit(1)
    else:
        print("No zone substrings provided (--zones or --zones_json). Exiting.")
        sys.exit(0)

    results = {}

    # Process GPU data in parallel.
    with ThreadPoolExecutor() as executor:
        gpu_futures = {
            executor.submit(process_gpu_data_substring, substring, tracy_file, tracy_csvexport_path, verbose): substring
            for substring in zone_substrings
        }
        for future in as_completed(gpu_futures):
            substring = gpu_futures[future]
            try:
                gpu_result = future.result()
                for key, times in gpu_result.items():
                    results.setdefault(key, []).extend(times)
            except Exception as exc:
                print(f"GPU data processing generated an exception for zone {substring}: {exc}")

    # Process CPU data in parallel.
    with ThreadPoolExecutor() as executor:
        cpu_futures = {
            executor.submit(process_unwrap_data_substring, substring, tracy_file, tracy_csvexport_path, verbose): substring
            for substring in zone_substrings
        }
        for future in as_completed(cpu_futures):
            substring = cpu_futures[future]
            try:
                cpu_result = future.result()
                for key, times in cpu_result.items():
                    results.setdefault(key, []).extend(times)
            except Exception as exc:
                print(f"CPU data processing generated an exception for zone {substring}: {exc}")

    # Prepare table rows: one header row and three data rows per zone.
    headers = ["Zone Name", "Count", "Avg (ms)", "Median (ms)", "Min (ms)", "Max (ms)"]
    data_rows = []
    for zone_name, times in results.items():
        if not times:
            continue

        overall_stats = compute_statistics(times)
        sorted_times = sorted(times, reverse=True)

        # Compute stats for the top 25% zone times.
        top25_count = max(1, math.ceil(len(times) * 0.25))
        top25_stats = compute_statistics(sorted_times[:top25_count])

        # Compute stats for the top 10% zone times.
        top10_count = max(1, math.ceil(len(times) * 0.10))
        top10_stats = compute_statistics(sorted_times[:top10_count])

        overall_row = [
            zone_name,
            str(overall_stats["count"]),
            f"{overall_stats['average'] / 1e6:.2f}",
            f"{overall_stats['median'] / 1e6:.2f}",
            f"{overall_stats['min'] / 1e6:.2f}",
            f"{overall_stats['max'] / 1e6:.2f}"
        ]
        top25_row = [
            f"{zone_name} (top 25%)",
            str(top25_stats["count"]),
            f"{top25_stats['average'] / 1e6:.2f}",
            f"{top25_stats['median'] / 1e6:.2f}",
            f"{top25_stats['min'] / 1e6:.2f}",
            f"{top25_stats['max'] / 1e6:.2f}"
        ]
        top10_row = [
            f"{zone_name} (top 10%)",
            str(top10_stats["count"]),
            f"{top10_stats['average'] / 1e6:.2f}",
            f"{top10_stats['median'] / 1e6:.2f}",
            f"{top10_stats['min'] / 1e6:.2f}",
            f"{top10_stats['max'] / 1e6:.2f}"
        ]
        data_rows.append(overall_row)
        data_rows.append(top25_row)
        data_rows.append(top10_row)

    # Branch based on the csv_path option.
    if csv_path:
        # CSV mode now writes a CSV file with the exact same table as printed to stdout.
        try:
            with open(csv_path, 'w', newline='') as csvfile:
                writer = csv.writer(csvfile)
                writer.writerow(headers)
                writer.writerows(data_rows)
            print(f"CSV exported to {csv_path}")
        except Exception as e:
            print(f"Error writing CSV file: {e}")
        return
    else:
        # Normal stdout printing mode: print a formatted table.
        col_widths = [len(h) for h in headers]
        for row in data_rows:
            for i, cell in enumerate(row):
                col_widths[i] = max(col_widths[i], len(cell))
        fmt = " | ".join("{:<" + str(w) + "}" for w in col_widths)
        sep_line = "-" * (sum(col_widths) + 3 * (len(col_widths) - 1))
        
        print("\nZone Execution Time Statistics:")
        print(fmt.format(*headers))
        print(sep_line)
        for row in data_rows:
            print(fmt.format(*row))

if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        description="Process tracy files and compute zone statistics. "
                    "Zones may be provided via --zones (comma separated) or --zones_json (JSON file). "
                    "Optionally export the table to CSV using --csv."
    )
    # New mandatory positional argument for tracy-csvexport executable:
    parser.add_argument("tracy_csvexport_path", help="Path to the tracy-csvexport executable.")
    # The .tracy file to process is now the second positional argument:
    parser.add_argument("tracy_file", help="Path to the .tracy file to process.")
    parser.add_argument("--zones", help="Comma separated list of zone substrings.")
    parser.add_argument("--zones_json", help="Path to a JSON file containing zone substrings (key 'zone').")
    parser.add_argument("--csv", help="Path to export CSV file. In CSV mode the table is identical to the printed table.")
    parser.add_argument("--verbose", "-v", action="store_true", help="Enable verbose output.")
    args = parser.parse_args()

    main(args.tracy_csvexport_path, args.tracy_file, args.zones, args.zones_json, args.verbose, args.csv)