ttnn-visualizer 0.52.1__py3-none-any.whl → 0.54.0__py3-none-any.whl

ttnn_visualizer/app.py

@@ -265,6 +265,8 @@ def main():
 
     gunicorn_args = [
         "gunicorn",
+        "-t",
+        config.GUNICORN_TIMEOUT,
         "-k",
         config.GUNICORN_WORKER_CLASS,
         "-w",

ttnn_visualizer/csv_queries.py

@@ -4,6 +4,7 @@
 
 import csv
 import json
+import logging
 import os
 import tempfile
 from io import StringIO
@@ -16,6 +17,8 @@ from tt_perf_report import perf_report
 from ttnn_visualizer.exceptions import DataFormatError
 from ttnn_visualizer.models import Instance
 
+logger = logging.getLogger(__name__)
+
 
 class LocalCSVQueryRunner:
     def __init__(self, file_path: str, offset: int = 0):
@@ -432,38 +435,50 @@ class OpsPerformanceReportQueries:
     }
 
     DEFAULT_SIGNPOST = None
-    DEFAULT_IGNORE_SIGNPOSTS = None
+    DEFAULT_IGNORE_SIGNPOSTS = True
     DEFAULT_MIN_PERCENTAGE = 0.5
     DEFAULT_ID_RANGE = None
     DEFAULT_NO_ADVICE = False
     DEFAULT_TRACING_MODE = False
+    DEFAULT_RAW_OP_CODES = True
+    DEFAULT_NO_HOST_OPS = False
+    DEFAULT_NO_STACKED_REPORT = False
+    DEFAULT_NO_STACK_BY_IN0 = True
 
     @classmethod
-    def generate_report(cls, instance):
+    def generate_report(cls, instance, **kwargs):
         raw_csv = OpsPerformanceQueries.get_raw_csv(instance)
         csv_file = StringIO(raw_csv)
         csv_output_file = tempfile.mktemp(suffix=".csv")
         csv_stacked_output_file = tempfile.mktemp(suffix=".csv")
+        signpost = kwargs.get("signpost", cls.DEFAULT_SIGNPOST)
+        ignore_signposts = cls.DEFAULT_IGNORE_SIGNPOSTS
+        stack_by_in0 = kwargs.get("stack_by_in0", cls.DEFAULT_NO_STACK_BY_IN0)
+
+        if signpost:
+            ignore_signposts = False
+
         # perf_report currently generates a PNG alongside the CSV using the same temp name - we'll just delete it afterwards
         stacked_png_file = os.path.splitext(csv_output_file)[0] + ".png"
 
         try:
             perf_report.generate_perf_report(
                 csv_file,
-                cls.DEFAULT_SIGNPOST,
-                cls.DEFAULT_IGNORE_SIGNPOSTS,
+                signpost,
+                ignore_signposts,
                 cls.DEFAULT_MIN_PERCENTAGE,
                 cls.DEFAULT_ID_RANGE,
                 csv_output_file,
                 cls.DEFAULT_NO_ADVICE,
                 cls.DEFAULT_TRACING_MODE,
-                True,
-                True,
-                False,
-                True,  # no_stack_by_in0 - need to ask what this is
+                cls.DEFAULT_RAW_OP_CODES,
+                cls.DEFAULT_NO_HOST_OPS,
+                cls.DEFAULT_NO_STACKED_REPORT,
+                stack_by_in0,
                 csv_stacked_output_file,
             )
         except Exception as e:
+            logger.error(f"Error generating performance report: {e}")
             raise DataFormatError(f"Error generating performance report: {e}") from e
 
         ops_perf_results = []
@@ -472,56 +487,89 @@ class OpsPerformanceReportQueries:
         for row in ops_perf_results_reader:
             ops_perf_results.append(row)
 
+        # Returns a list of unique signposts in the order they appear
+        # TODO: Signpost names are not unique but tt-perf-report treats them as such
+        captured_signposts = set()
+        signposts = []
+        for index, row in enumerate(ops_perf_results):
+            if row.get("OP TYPE") == "signpost":
+                op_code = row["OP CODE"]
+                op_id = index + 2  # Match IDs with row numbers in ops perf results csv
+                if not any(s["op_code"] == op_code for s in signposts):
+                    captured_signposts.add(op_code)
+                    signposts.append({"id": op_id, "op_code": op_code})
+
         report = []
 
-        try:
-            with open(csv_output_file, newline="") as csvfile:
-                reader = csv.reader(csvfile, delimiter=",")
-                next(reader, None)
-                for row in reader:
-                    processed_row = {
-                        column: row[index]
-                        for index, column in enumerate(cls.REPORT_COLUMNS)
-                        if index < len(row)
-                    }
-                    if "advice" in processed_row and processed_row["advice"]:
-                        processed_row["advice"] = processed_row["advice"].split(" • ")
-                    else:
-                        processed_row["advice"] = []
-
-                    for key, value in cls.PASSTHROUGH_COLUMNS.items():
-                        op_id = int(row[0])
-                        idx = (
-                            op_id - 2
-                        )  # IDs in result column one correspond to row numbers in ops perf results csv
-                        processed_row[key] = ops_perf_results[idx][value]
-
-                    report.append(processed_row)
-        except csv.Error as e:
-            raise DataFormatError() from e
-        finally:
-            os.unlink(csv_output_file)
+        if os.path.exists(csv_output_file):
+            try:
+                with open(csv_output_file, newline="") as csvfile:
+                    reader = csv.reader(csvfile, delimiter=",")
+                    next(reader, None)
+                    for row in reader:
+                        processed_row = {
+                            column: row[index]
+                            for index, column in enumerate(cls.REPORT_COLUMNS)
+                            if index < len(row)
+                        }
+                        if "advice" in processed_row and processed_row["advice"]:
+                            processed_row["advice"] = processed_row["advice"].split(
+                                " • "
+                            )
+                        else:
+                            processed_row["advice"] = []
+
+                            # Get the op type from the raw file for this row as it is not returned from tt-perf-report
+                            op_id = int(row[0])
+                            raw_idx = op_id - 2
+                            if 0 <= raw_idx < len(ops_perf_results):
+                                processed_row["op_type"] = ops_perf_results[
+                                    raw_idx
+                                ].get("OP TYPE")
+                            else:
+                                processed_row["op_type"] = None
+
+                        report.append(processed_row)
+            except csv.Error as e:
+                raise DataFormatError() from e
+            finally:
+                os.unlink(csv_output_file)
 
         stacked_report = []
 
-        try:
-            with open(csv_stacked_output_file, newline="") as csvfile:
-                reader = csv.reader(csvfile, delimiter=",")
-                next(reader, None)
-
-                for row in reader:
-                    processed_row = {
-                        column: row[index]
-                        for index, column in enumerate(cls.STACKED_REPORT_COLUMNS)
-                        if index < len(row)
-                    }
+        if os.path.exists(csv_stacked_output_file):
+            try:
+                with open(csv_stacked_output_file, newline="") as csvfile:
+                    reader = csv.reader(csvfile, delimiter=",")
+                    next(reader, None)
+
+                    for row in reader:
+                        processed_row = {
+                            column: row[index]
+                            for index, column in enumerate(cls.STACKED_REPORT_COLUMNS)
+                            if index < len(row)
+                        }
+
+                        if "op_code" in processed_row and any(
+                            processed_row["op_code"] in signpost["op_code"]
+                            for signpost in signposts
+                        ):
+                            processed_row["op_type"] = "signpost"
+                        else:
+                            processed_row["op_type"] = "unknown"
+
+                        stacked_report.append(processed_row)
+            except csv.Error as e:
+                raise DataFormatError() from e
+            finally:
+                os.unlink(csv_stacked_output_file)
+                if os.path.exists(stacked_png_file):
+                    os.unlink(stacked_png_file)
 
                     stacked_report.append(processed_row)
-        except csv.Error as e:
-            raise DataFormatError() from e
-        finally:
-            os.unlink(csv_stacked_output_file)
-            if os.path.exists(stacked_png_file):
-                os.unlink(stacked_png_file)
-
-        return {"report": report, "stacked_report": stacked_report}
+
+        return {
+            "report": report,
+            "stacked_report": stacked_report,
+            "signposts": signposts,
+        }

ttnn_visualizer/serializers.py

@@ -190,14 +190,25 @@ def serialize_operation(
 
 
 def serialize_operation_buffers(operation: Operation, operation_buffers):
-    buffer_data = [b.to_dict() for b in operation_buffers]
-    for b in buffer_data:
-        b.pop("operation_id")
-        b.update({"size": b.pop("max_size_per_bank")})
+    buffer_data = []
+    for b in operation_buffers:
+        buffer_dict = {
+            "device_id": b.device_id,
+            "address": b.address,
+            "buffer_type": (
+                b.buffer_type.value
+                if hasattr(b.buffer_type, "value")
+                else b.buffer_type
+            ),
+            "buffer_layout": b.buffer_layout,
+            "size": b.max_size_per_bank,
+        }
+        buffer_data.append(buffer_dict)
+
     return {
         "id": operation.operation_id,
         "name": operation.name,
-        "buffers": list(buffer_data),
+        "buffers": buffer_data,
     }
 
 
@@ -206,14 +217,33 @@ def serialize_devices(devices):
 
 
 def serialize_operations_buffers(operations, buffers):
-    buffer_dict = defaultdict(list)
+    # Pre-serialize all buffers once using optimized method with defaultdict
+    serialized_buffers = defaultdict(list)
     for b in buffers:
-        buffer_dict[b.operation_id].append(b)
+        buffer_dict = {
+            "device_id": b.device_id,
+            "address": b.address,
+            "buffer_type": (
+                b.buffer_type.value
+                if hasattr(b.buffer_type, "value")
+                else b.buffer_type
+            ),
+            "buffer_layout": b.buffer_layout,
+            "size": b.max_size_per_bank,
+        }
+        serialized_buffers[b.operation_id].append(buffer_dict)
 
     results = []
     for operation in operations:
-        operation_buffers = buffer_dict.get(operation.operation_id, [])
-        results.append(serialize_operation_buffers(operation, operation_buffers))
+        operation_buffers = serialized_buffers[operation.operation_id]
+        results.append(
+            {
+                "id": operation.operation_id,
+                "name": operation.name,
+                "buffers": operation_buffers,
+            }
+        )
+
     return results
 
 

ttnn_visualizer/settings.py

@@ -68,6 +68,7 @@ class DefaultConfig(object):
     # Gunicorn settings
     GUNICORN_WORKER_CLASS = os.getenv("GUNICORN_WORKER_CLASS", "gevent")
     GUNICORN_WORKERS = os.getenv("GUNICORN_WORKERS", "1")
+    GUNICORN_TIMEOUT = os.getenv("GUNICORN_TIMEOUT", "60")
     PORT = os.getenv("PORT", "8000")
     HOST = os.getenv("HOST", "localhost")
     DEV_SERVER_PORT = "5173"

ttnn_visualizer/static/assets/{allPaths-DOFQJGIv.js → allPaths-ClJTDoXf.js}

@@ -1 +1 @@
-import{I as s}from"./index-CnPrfHYh.js";import{I as r}from"./index-Cnc1EkDo.js";import{p as n,I as c}from"./index-WayH7MCF.js";function p(t,a){const o=n(t);return a===c.STANDARD?s[o]:r[o]}export{s as IconSvgPaths16,r as IconSvgPaths20,p as getIconPaths};
+import{I as s}from"./index-CnPrfHYh.js";import{I as r}from"./index-Cnc1EkDo.js";import{p as n,I as c}from"./index-eW1dMfMf.js";function p(t,a){const o=n(t);return a===c.STANDARD?s[o]:r[o]}export{s as IconSvgPaths16,r as IconSvgPaths20,p as getIconPaths};

ttnn_visualizer/static/assets/allPathsLoader-DLMimLnJ.js

@@ -0,0 +1,2 @@
+const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/allPaths-ClJTDoXf.js","assets/index-CnPrfHYh.js","assets/index-Cnc1EkDo.js","assets/index-eW1dMfMf.js","assets/index-DdmYzvVg.css"])))=>i.map(i=>d[i]);
+import{_ as e}from"./index-eW1dMfMf.js";const s=async(t,a)=>{const{getIconPaths:o}=await e(async()=>{const{getIconPaths:r}=await import("./allPaths-ClJTDoXf.js");return{getIconPaths:r}},__vite__mapDeps([0,1,2,3,4]));return o(t,a)};export{s as allPathsLoader};