tt-perf-report 1.0.7__tar.gz → 1.1.1__tar.gz

{tt_perf_report-1.0.7/src/tt_perf_report.egg-info → tt_perf_report-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tt-perf-report
-Version: 1.0.7
+Version: 1.1.1
 Summary: This tool analyzes performance traces from TT-Metal operations, providing insights into throughput, bottlenecks, and optimization opportunities.
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -218,6 +218,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: LICENSE_understanding.txt
 Requires-Dist: pandas
+Requires-Dist: matplotlib
 Dynamic: license-file
 
 # Performance Report Analysis Tool

{tt_perf_report-1.0.7 → tt_perf_report-1.1.1}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tt-perf-report"
-version = "1.0.7"
+version = "1.1.1"
 description = "This tool analyzes performance traces from TT-Metal operations, providing insights into throughput, bottlenecks, and optimization opportunities."
 license = {file = "LICENSE"}
 readme = "README.md"
 keywords = ["tenstorrent", "tt-metal"]
-dependencies = ["pandas"]
+dependencies = ["pandas", "matplotlib"]
 
 [project.scripts]
 tt-perf-report = "tt_perf_report.perf_report:main"

{tt_perf_report-1.0.7 → tt_perf_report-1.1.1}/src/tt_perf_report/perf_report.py

@@ -2,18 +2,54 @@
 # SPDX-License-Identifier: Apache-2.0
 
 # SPDX-FileCopyrightText: © 2025 Tenstorrent AI ULC
-import csv
-import sys
 import argparse
+import csv
+from collections import defaultdict
+import os
 import re
+import sys
 from typing import Any, Optional, Union
-from collections import defaultdict
+
+import matplotlib.pyplot as plt
 import pandas as pd
 
 # Global variable to store color preference
 color_output = None  # None means auto-detect, True forces color, False forces no color
 
 
+def get_value_physical_logical(input, is_physical : bool = True):
+    # Handle numeric inputs (old format)
+    if isinstance(input, (int, float)):
+        return int(input)
+
+    # Handle string inputs (new format)
+    if isinstance(input, str) and "[" in input and "]" in input:
+        physical_part = input.split("[")[0]
+        logical_part = input.split("[")[1].split("]")[0]
+        
+        if is_physical:
+            return int(physical_part)
+        else:
+            return int(logical_part)
+    else:
+        # backwards compatibility - convert string to int
+        return int(input)
+
+
+def detect_csv_format(df):
+    """Detect if CSV uses v1 (old) or v2 (new) format by checking for _PAD[LOGICAL] columns"""
+    v2_columns = [col for col in df.columns if "_PAD[LOGICAL]" in col]
+    return "v2" if v2_columns else "v1"
+
+
+def get_column_name(base_name, csv_format):
+    """Get the appropriate column name based on CSV format version"""
+    if csv_format == "v2":
+        return f"{base_name}_PAD[LOGICAL]"
+    else:
+        return base_name
+
+
 def set_color_output(force_color, force_no_color):
     global color_output
     if force_no_color:
@@ -205,35 +241,35 @@ def evaluate_fidelity(input_0_datatype, input_1_datatype, output_datatype, math_
         )
 
 
-def analyze_matmul(row):
+def analyze_matmul(row, csv_format="v2"):
     input_0_from_dram = "DRAM" in row["INPUT_0_MEMORY"]
     input_1_from_dram = "DRAM" in row["INPUT_1_MEMORY"]
 
     total_data_size_bytes = 0
     if input_0_from_dram:
         total_data_size_bytes += (
-            row["INPUT_0_W"]
-            * row["INPUT_0_Y"]
-            * row["INPUT_0_Z"]
-            * row["INPUT_0_X"]
+            get_value_physical_logical(row[get_column_name("INPUT_0_W", csv_format)])
+            * get_value_physical_logical(row[get_column_name("INPUT_0_Y", csv_format)])
+            * get_value_physical_logical(row[get_column_name("INPUT_0_Z", csv_format)])
+            * get_value_physical_logical(row[get_column_name("INPUT_0_X", csv_format)])
             * get_datatype_size(row["INPUT_0_DATATYPE"])
         )
     if input_1_from_dram:
         total_data_size_bytes += (
-            row["INPUT_1_W"]
-            * row["INPUT_1_Y"]
-            * row["INPUT_1_Z"]
-            * row["INPUT_1_X"]
+            get_value_physical_logical(row[get_column_name("INPUT_1_W", csv_format)])
+            * get_value_physical_logical(row[get_column_name("INPUT_1_Y", csv_format)])
+            * get_value_physical_logical(row[get_column_name("INPUT_1_Z", csv_format)])
+            * get_value_physical_logical(row[get_column_name("INPUT_1_X", csv_format)])
             * get_datatype_size(row["INPUT_1_DATATYPE"])
         )
 
     # Always include output if it's written to DRAM
     if "DRAM" in row["OUTPUT_0_MEMORY"]:
         total_data_size_bytes += (
-            row["OUTPUT_0_W"]
-            * row["OUTPUT_0_Y"]
-            * row["OUTPUT_0_Z"]
-            * row["OUTPUT_0_X"]
+            get_value_physical_logical(row[get_column_name("OUTPUT_0_W", csv_format)])
+            * get_value_physical_logical(row[get_column_name("OUTPUT_0_Y", csv_format)])
+            * get_value_physical_logical(row[get_column_name("OUTPUT_0_Z", csv_format)])
+            * get_value_physical_logical(row[get_column_name("OUTPUT_0_X", csv_format)])
             * get_datatype_size(row["OUTPUT_0_DATATYPE"])
         )
 
@@ -253,8 +289,8 @@ def analyze_matmul(row):
 
     peak_flops_value = tflops_per_core(math_fidelity) * 1e12 * core_count
 
-    M, K, N = int(row["INPUT_0_Y"]), int(row["INPUT_0_X"]), int(row["INPUT_1_X"])
-    W, Z = int(row["INPUT_0_W"]), int(row["INPUT_0_Z"])
+    M, K, N = get_value_physical_logical(row[get_column_name("INPUT_0_Y", csv_format)]), get_value_physical_logical(row[get_column_name("INPUT_0_X", csv_format)]), get_value_physical_logical(row[get_column_name("INPUT_1_X", csv_format)])
+    W, Z = get_value_physical_logical(row[get_column_name("INPUT_0_W", csv_format)]), get_value_physical_logical(row[get_column_name("INPUT_0_Z", csv_format)])
 
     flops = (M * K * N * W * Z * 2) / duration_s
 
@@ -312,7 +348,7 @@ def analyze_halo(row):
 
     return config
 
-def analyze_conv(row):
+def analyze_conv(row, csv_format="v2"):
     duration_s = row["DEVICE KERNEL DURATION [ns]"] * 1e-9
 
     core_count = 64 # we decided to normalize to the max core count
@@ -323,10 +359,10 @@ def analyze_conv(row):
 
     peak_flops_value = tflops_per_core(math_fidelity) * 1e12 * core_count
 
-    NHW = int(row["OUTPUT_0_Y"])
-    CH_IN = int(row["INPUT_0_X"])
+    NHW = get_value_physical_logical(row[get_column_name("OUTPUT_0_Y", csv_format)])
+    CH_IN = get_value_physical_logical(row[get_column_name("INPUT_0_X", csv_format)])
     W = [int(x) for x in (attributes.split("window_hw")[1].split("; ")[0][2:-1].split(";"))]
-    CH_OUT = int(row["INPUT_1_X"])
+    CH_OUT = get_value_physical_logical(row[get_column_name("INPUT_1_X", csv_format)])
 
     M, K, N = NHW, CH_IN * W[0] * W[1], CH_OUT
     flops = (M * K * N * 2) / duration_s
@@ -372,7 +408,7 @@ def analyze_conv(row):
         config,
     )
 
-def analyze_op(row, prev_row):
+def analyze_op(row, prev_row, csv_format="v2"):
     op_code = Cell(row["OP CODE"])
     cores = Cell(int(row["CORE COUNT"]) if pd.notna(row["CORE COUNT"]) else None)
     device_time = Cell(
@@ -425,7 +461,7 @@ def analyze_op(row, prev_row):
             math_fidelity,
             is_dram_sharded,
             adjusted_core_count,  # Get the potentially adjusted core count
-        ) = analyze_matmul(row)
+        ) = analyze_matmul(row, csv_format)
         op_code = Cell(f"{op_code.raw_value} {size}")
         dram_speed = Cell(dram_speed, unit="GB/s", decimals=0)
         dram_percentage = Cell(dram_percentage, unit="%", decimals=1)
@@ -446,7 +482,7 @@ def analyze_op(row, prev_row):
             memory_info,
             math_fidelity,
             config,
-        ) = analyze_conv(row)
+        ) = analyze_conv(row, csv_format)
         op_code = Cell(f"{op_code.raw_value} {size} {config}")
         dram_speed = Cell(None, unit="GB/s", decimals=0)
         dram_percentage = Cell(None, unit="%", decimals=1)
@@ -800,6 +836,93 @@ def generate_matmul_advice(op_data):
     return advice
 
 
+def generate_stacked_report(rows, visible_headers, stack_by_input0_layout:bool = False):
+    if stack_by_input0_layout:
+        visible_headers.append("Input 0 Memory")
+
+    # Create a pandas DataFrame from rows and headers
+    data = {header: [row[header].raw_value for row in rows] for header in visible_headers}
+    df = pd.DataFrame(data)
+
+    if (stack_by_input0_layout):
+        df["OP Code Joined"] = df["OP Code"].str.split().str[0] \
+            + " (in0:" + df["Input 0 Memory"].str.split('_').str[-2].str.lower() + "_" + df["Input 0 Memory"].str.split('_').str[-1].str.lower() + ")"
+    else:
+        df["OP Code Joined"] = df["OP Code"].str.split().str[0]
+
+    # Group by the joined OP Code and aggregate the data
+    stacked_df = df.groupby("OP Code Joined").agg(
+        Device_Time_Sum_us=("Device Time", "sum"),
+        Ops_Count=("Device Time", "count"),
+        Flops_min=("FLOPs %", "min"),
+        Flops_max=("FLOPs %", "max"),
+        Flops_mean=("FLOPs %", "mean"),
+        Flops_std=("FLOPs %", "std"),
+    ).reset_index()
+
+    # Calculate the percentage of device time
+    total_device_time = stacked_df["Device_Time_Sum_us"].sum()
+    stacked_df["%"] = (stacked_df["Device_Time_Sum_us"] / total_device_time) * 100
+    # Reorder columns to move Device_Time_Percentage to be the 3rd column
+    cols = stacked_df.columns.tolist()
+    cols.insert(0, cols.pop(cols.index("%")))
+    stacked_df = stacked_df[cols]
+    # Sort the stacked dataframe by "Device_Time_Sum_us" in descending order
+    stacked_df = stacked_df.sort_values(by="Device_Time_Sum_us", ascending=False)
+
+    return stacked_df
+
+
+def print_stacked_report(stacked_df: pd.DataFrame):
+    print("\n📊 Stacked report 📊\n============\n")
+    print(stacked_df.to_string(index=False, float_format="%.2f"))
+
+
+def dump_stacked_report(stacked_df: pd.DataFrame, output_file: str):
+    stacked_df.to_csv(output_file, index=False, float_format="%.1f")
+
+
+def plot_stacked_report(stacked_df: pd.DataFrame, output_file: str, threshold: float = 0.02):
+    # Prepare data for the stacked bar plot
+    device_time_sum = stacked_df["Device_Time_Sum_us"]
+    total_sum = device_time_sum.sum()
+
+    # Create a stacked bar plot
+    plt.figure(figsize=(6, 8), dpi=300)
+    width = 0.5
+    bottom = 0
+    colors = plt.cm.tab20.colors + plt.cm.tab20b.colors + plt.cm.tab20c.colors
+
+    for i, row in stacked_df.iterrows():
+        color = colors[i % len(colors)]
+        bar = plt.bar(1, row["Device_Time_Sum_us"], width, label=row["OP Code Joined"], bottom=bottom, color=color)
+
+        text = f"({row['%']:.1f}%) {row['OP Code Joined']} total={row['Device_Time_Sum_us']:.1f}us; {row['Ops_Count']} ops"
+        if not pd.isna(row["Flops_mean"]):
+            text += f"\n Util [{row['Flops_min']:.1f} - {row['Flops_max']:.1f}] {row['Flops_mean']:.1f} ± {row['Flops_std']:.1f} %"
+
+        # Add overlay text if the data is significant
+        if row["Device_Time_Sum_us"] >= total_sum * threshold:
+            plt.text(
+            bar[0].get_x() + bar[0].get_width() / 2,
+            bottom + row["Device_Time_Sum_us"] / 2,
+            text,
+            ha="center",
+            va="center",
+            fontsize=6,
+            color="white"
+            )
+        bottom += row["Device_Time_Sum_us"]
+
+    # Set plot labels and title
+    plt.xlim(1 - width / 2 - 0.05, 1 + width / 2 + 0.05)
+    plt.ylabel("Device Time [us]")
+    plt.title(f"Stacked Device Time (Total: {total_sum:.1f} us)")
+    plt.tight_layout()
+
+    # Save the plot to a file
+    plt.savefig(output_file)
+
 def merge_device_rows(df):
     block_by_device = defaultdict(list)
 
@@ -901,7 +1024,7 @@ def main():
     args, id_range = parse_args()
     generate_perf_report(
         args.csv_file, args.signpost, args.ignore_signposts, args.min_percentage, id_range, args.csv, args.no_advice,
-        args.tracing_mode, args.raw_op_codes, args.no_host_ops)
+        args.tracing_mode, args.raw_op_codes, args.no_host_ops, args.no_stacked_report, args.no_stack_by_in0, args.stacked_csv)
 
 
 def parse_args():
@@ -924,6 +1047,12 @@ def parse_args():
     parser.add_argument("--tracing-mode", action="store_true", help="Do not sort when in tracing mode")
     parser.add_argument("--raw-op-codes", action="store_true", help="Include raw op codes in output")
     parser.add_argument("--no-host-ops", action="store_true", help="Do not include host ops in output")
+    parser.add_argument("--no-stacked-report", action="store_true", help="Do not generate a stacked report")
+    parser.add_argument("--no-stack-by-in0", action="store_true",
+        help="Do not group the stacked report by the layout of Input 0 (extracted from the Input 0 Memory column)"
+        )
+    parser.add_argument("--stacked-csv", type=str, 
+                help="Output filename for the stacked report CSV; Defaults to OUTPUT_FILE_stacked.csv", metavar="STACKED_FILE")
 
     args = parser.parse_args()
 
@@ -942,9 +1071,15 @@ def parse_args():
 
 def generate_perf_report(csv_file, signpost, ignore_signposts, min_percentage,
                          id_range, csv_output_file, no_advice, tracing_mode,
-                         raw_op_codes, no_host_ops):
+                         raw_op_codes, no_host_ops, no_stacked_report, no_stack_by_in0, stacked_report_file):
     df = pd.read_csv(csv_file, low_memory=False)
 
+    # Detect CSV format version
+    csv_format = detect_csv_format(df)
+
+    if csv_format != "v2":
+        print(colored(f"Detected CSV format: v1 (legacy format)", "cyan"))
+
     # Add a column for original row numbers
     df["ORIGINAL_ROW"] = df.index + 2  # +2 to match Excel row numbers (1-based + header)
 
@@ -968,7 +1103,7 @@ def generate_perf_report(csv_file, signpost, ignore_signposts, min_percentage,
     device_ops = 0
     host_ops = 0
     for _, row in df.iterrows():
-        op_data, current_gap = analyze_op(row, prev_row)
+        op_data, current_gap = analyze_op(row, prev_row, csv_format)
         op_data["ID"] = Cell(row["ORIGINAL_ROW"])  # Use the original row number
         op_data["Global Call Count"] = Cell(row["GLOBAL CALL COUNT"])
         if raw_op_codes:
@@ -1046,6 +1181,22 @@ def generate_perf_report(csv_file, signpost, ignore_signposts, min_percentage,
         if not no_advice:
             print_advice_section(rows, visible_headers, col_widths)
 
+    # handle stacked report generation
+    if not(no_stacked_report):
+        stacked_report = generate_stacked_report(rows, visible_headers, not(no_stack_by_in0))
+
+        if not(csv_output_file):
+            print_stacked_report(stacked_report)
+        if stacked_report_file or csv_output_file:
+            if not stacked_report_file:
+                base_stacked_report_file = f"{os.path.splitext(csv_output_file)[0]}_stacked"
+            else:
+                base_stacked_report_file = os.path.splitext(stacked_report_file)[0]
+            print(colored(f"Writing CSV stacked report to {base_stacked_report_file}.csv", "cyan"))
+            dump_stacked_report(stacked_report, f"{base_stacked_report_file}.csv")
+            print(colored(f"Plotting PNG stacked report to {base_stacked_report_file}.png", "cyan"))
+            plot_stacked_report(stacked_report, f"{base_stacked_report_file}.png")
+
 
 def is_host_op(op_data):
     return "(torch)" in op_data["OP Code"].raw_value

{tt_perf_report-1.0.7 → tt_perf_report-1.1.1/src/tt_perf_report.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tt-perf-report
-Version: 1.0.7
+Version: 1.1.1
 Summary: This tool analyzes performance traces from TT-Metal operations, providing insights into throughput, bottlenecks, and optimization opportunities.
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -218,6 +218,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: LICENSE_understanding.txt
 Requires-Dist: pandas
+Requires-Dist: matplotlib
 Dynamic: license-file
 
 # Performance Report Analysis Tool

tt_perf_report-1.1.1/src/tt_perf_report.egg-info/requires.txt

@@ -0,0 +1,2 @@
+pandas
+matplotlib

tt_perf_report-1.0.7/src/tt_perf_report.egg-info/requires.txt

@@ -1 +0,0 @@
-pandas