tt-perf-report 1.0.6__tar.gz → 1.1.0__tar.gz

{tt_perf_report-1.0.6/src/tt_perf_report.egg-info → tt_perf_report-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: tt-perf-report
-Version: 1.0.6
+Version: 1.1.0
 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,8 @@ 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.6 → tt_perf_report-1.1.0}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tt-perf-report"
-version = "1.0.6"
+version = "1.1.0"
 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.6 → tt_perf_report-1.1.0}/src/tt_perf_report/perf_report.py

@@ -2,17 +2,32 @@
 # 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 : str, is_physical : bool = True):
+    if "[" 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:
+        # back compatible
+        return int(input)
 
 def set_color_output(force_color, force_no_color):
     global color_output
@@ -71,7 +86,7 @@ class Cell:
         if self.raw_value is None or pd.isna(self.raw_value):
             return ""
 
-        if isinstance(self.raw_value, str) and ("Matmul" in self.raw_value or "OptimizedConvNew" in self.raw_value):
+        if isinstance(self.raw_value, str) and ("Matmul" in self.raw_value or "OptimizedConvNew" in self.raw_value or "HaloDeviceOperation" in self.raw_value):
             parts = self.raw_value.split(maxsplit=1)
             op_name = parts[0]
             size = parts[1] if len(parts) > 1 else ""
@@ -212,28 +227,28 @@ def analyze_matmul(row):
     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["INPUT_0_W_PAD[LOGICAL]"])
+            * get_value_physical_logical(row["INPUT_0_Y_PAD[LOGICAL]"])
+            * get_value_physical_logical(row["INPUT_0_Z_PAD[LOGICAL]"])
+            * get_value_physical_logical(row["INPUT_0_X_PAD[LOGICAL]"])
             * 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["INPUT_1_W_PAD[LOGICAL]"])
+            * get_value_physical_logical(row["INPUT_1_Y_PAD[LOGICAL]"])
+            * get_value_physical_logical(row["INPUT_1_Z_PAD[LOGICAL]"])
+            * get_value_physical_logical(row["INPUT_1_X_PAD[LOGICAL]"])
             * 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["OUTPUT_0_W_PAD[LOGICAL]"])
+            * get_value_physical_logical(row["OUTPUT_0_Y_PAD[LOGICAL]"])
+            * get_value_physical_logical(row["OUTPUT_0_Z_PAD[LOGICAL]"])
+            * get_value_physical_logical(row["OUTPUT_0_X_PAD[LOGICAL]"])
             * get_datatype_size(row["OUTPUT_0_DATATYPE"])
         )
 
@@ -253,8 +268,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["INPUT_0_Y_PAD[LOGICAL]"]), get_value_physical_logical(row["INPUT_0_X_PAD[LOGICAL]"]), get_value_physical_logical(row["INPUT_1_X_PAD[LOGICAL]"])
+    W, Z = get_value_physical_logical(row["INPUT_0_W_PAD[LOGICAL]"]), get_value_physical_logical(row["INPUT_0_Z_PAD[LOGICAL]"])
 
     flops = (M * K * N * W * Z * 2) / duration_s
 
@@ -276,6 +291,42 @@ def analyze_matmul(row):
         core_count,  # Return the potentially adjusted core count
     )
 
+def analyze_halo(row):
+    attributes = row["ATTRIBUTES"] if pd.notna(row["ATTRIBUTES"]) else ""
+
+    try:
+        window_hw = attributes.split("window_hw=")[1].split(";")[0:2]
+        window_hw = ",".join(window_hw[0:2])
+    except (IndexError, AttributeError):
+        window_hw = "x"
+
+    try:
+        stride_hw = attributes.split("stride_hw=")[1].split(";")[0:2]
+        stride_hw = ",".join(stride_hw[0:2])
+    except (IndexError, AttributeError):
+        stride_hw = "x"
+
+    try:
+        pad_hw = attributes.split("padding=")[1].split(";")[0:4]
+        pad_hw = ",".join(pad_hw[0:4])
+    except (IndexError, AttributeError):
+        pad_hw = "x"
+
+    try:
+        dilation_hw = attributes.split("dilation_hw=")[1].split(";")[0:2]
+        dilation_hw = ",".join(dilation_hw[0:2])
+    except (IndexError, AttributeError):
+        dilation_hw = "x"
+
+    try:
+        memory_layout = attributes.split("memory_layout=")[1].split(";")[0].split("::")[1]
+    except (IndexError, AttributeError):
+        memory_layout = "x"
+
+    config = f"w={window_hw} s={stride_hw} p={pad_hw} d={dilation_hw} | {memory_layout}"
+
+    return config
+
 def analyze_conv(row):
     duration_s = row["DEVICE KERNEL DURATION [ns]"] * 1e-9
 
@@ -287,10 +338,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["OUTPUT_0_Y_PAD[LOGICAL]"])
+    CH_IN = get_value_physical_logical(row["INPUT_0_X_PAD[LOGICAL]"])
     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["INPUT_1_X_PAD[LOGICAL]"])
 
     M, K, N = NHW, CH_IN * W[0] * W[1], CH_OUT
     flops = (M * K * N * 2) / duration_s
@@ -300,12 +351,40 @@ def analyze_conv(row):
 
     flops_percentage = (flops / peak_flops_value) * 100
 
+    try:
+        act_block_h_ntiles = int(attributes.split("act_block_h_ntiles")[1][1:].split(";")[0])
+    except (IndexError, ValueError):
+        act_block_h_ntiles = "x"
+
+    try:
+        enable_act_double_buffer = "true" == attributes.split("enable_act_double_buffer': '")[1].split("'")[0]
+    except (IndexError, ValueError):
+        enable_act_double_buffer = "x"
+
+    try:
+        enable_split_reader = "true" == attributes.split("enable_split_reader': '")[1].split("'")[0]
+    except (IndexError, ValueError):
+        enable_split_reader = "x"
+
+    try:
+        per_core_out_matrix_height_ntile = int(attributes.split("per_core_out_matrix_height_ntile")[1][1:].split(";")[0])
+    except (IndexError, ValueError):
+        per_core_out_matrix_height_ntile = "x"
+
+    config = f"[ABH={per_core_out_matrix_height_ntile}|{act_block_h_ntiles}"
+    if (enable_act_double_buffer):
+        config += " ADB"
+    if (enable_split_reader):
+        config += " SR"
+    config += "]"
+
     return (
         flops,
         flops_percentage,
         size,
         memory_info,
-        math_fidelity
+        math_fidelity,
+        config,
     )
 
 def analyze_op(row, prev_row):
@@ -381,8 +460,9 @@ def analyze_op(row, prev_row):
             size,
             memory_info,
             math_fidelity,
+            config,
         ) = analyze_conv(row)
-        op_code = Cell(f"{op_code.raw_value} {size}")
+        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)
         flops = Cell(flops / 1e12 if pd.notna(flops) else None, unit="TFLOPs", decimals=1)
@@ -392,6 +472,13 @@ def analyze_op(row, prev_row):
             if math_fidelity
             else None
         )
+    elif "HaloDeviceOperation" in op_code.raw_value:
+        config = analyze_halo(row)
+        op_code = Cell(f"{op_code.raw_value} {config}")
+        dram_speed = Cell(None, unit="GB/s", decimals=0)
+        dram_percentage = Cell(None, unit="%", decimals=1)
+        flops = Cell(None, unit="TFLOPs", decimals=1)
+        flops_percentage = Cell(None, unit="%", decimals=1)
 
     output = {
         "ID": None,
@@ -728,6 +815,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)
 
@@ -765,10 +939,17 @@ def merge_device_rows(df):
         if not blocks:
             break
 
-        if "AllGather" in op_name or "ReduceScatter" in op_name:
-            # For collective ops, take the row with minimum duration
-            min_duration_block = min(blocks, key=lambda x: x[1]["DEVICE KERNEL DURATION [ns]"])
-            merged_blocks.append(min_duration_block[1])
+        if "AllGather" in op_name or "ReduceScatter" in op_name or "AllReduce" in op_name:
+            # For collective ops, take the average duration over all rows within a block
+            device_kernel_durations = [d["DEVICE KERNEL DURATION [ns]"] 
+                             for _, d in blocks 
+                             if pd.notna(d["DEVICE KERNEL DURATION [ns]"])]
+            # Use the first block's data but update its duration with the average
+            base_block = blocks[0][1].copy()
+            base_block["DEVICE KERNEL DURATION [ns]"] = (
+                sum(device_kernel_durations) / len(device_kernel_durations) if device_kernel_durations else float("nan")
+            )
+            merged_blocks.append(base_block)
         else:
             # For non-collective ops, take the row with maximum duration
             max_duration_block = max(blocks, key=lambda x: x[1]["DEVICE KERNEL DURATION [ns]"])
@@ -822,7 +1003,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():
@@ -845,6 +1026,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()
 
@@ -863,7 +1050,7 @@ 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)
 
     # Add a column for original row numbers
@@ -891,6 +1078,7 @@ def generate_perf_report(csv_file, signpost, ignore_signposts, min_percentage,
     for _, row in df.iterrows():
         op_data, current_gap = analyze_op(row, prev_row)
         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:
             op_data["Raw OP Code"] = Cell(row["OP CODE"])
         rows.append(op_data)
@@ -941,6 +1129,7 @@ def generate_perf_report(csv_file, signpost, ignore_signposts, min_percentage,
             "Inner Dim Block Size",
             "Output Subblock H",
             "Output Subblock W",
+            "Global Call Count",
         ]
         if not no_advice:
             all_headers.append("Advice")
@@ -965,6 +1154,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.6 → tt_perf_report-1.1.0/src/tt_perf_report.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: tt-perf-report
-Version: 1.0.6
+Version: 1.1.0
 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,8 @@ 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.0/src/tt_perf_report.egg-info/requires.txt

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

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

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