ttnn-visualizer 0.26.0__py3-none-any.whl → 0.27.0__py3-none-any.whl

ttnn_visualizer/app.py

@@ -2,6 +2,7 @@
 #
 # SPDX-FileCopyrightText: © 2024 Tenstorrent AI ULC
 
+import argparse
 import logging
 import os
 import subprocess
@@ -19,7 +20,8 @@ from flask_cors import CORS
 from werkzeug.debug import DebuggedApplication
 from werkzeug.middleware.proxy_fix import ProxyFix
 
-from ttnn_visualizer.exceptions import DatabaseFileNotFoundException
+from ttnn_visualizer.exceptions import DatabaseFileNotFoundException, InvalidProfilerPath, InvalidReportPath
+from ttnn_visualizer.sessions import create_instance_from_local_paths
 from ttnn_visualizer.settings import Config, DefaultConfig
 
 logger = logging.getLogger(__name__)
@@ -135,9 +137,10 @@ def middleware(app: flask.Flask):
     return None
 
 
-def open_browser(host, port, protocol="http"):
-
-    url = f"{protocol}://{host}:{port}"
+def open_browser(host, port, instance_id=None):
+    url = f"http://{host}:{port}"
+    if instance_id:
+        url = f"{url}?instanceId={instance_id}"
 
     print(f"Launching browser with url: {url}")
     try:
@@ -149,6 +152,13 @@ def open_browser(host, port, protocol="http"):
         print(f"Could not open the default browser: {e}")
 
 
+def parse_args():
+    parser = argparse.ArgumentParser(description="A tool for visualizing the Tenstorrent Neural Network model (TT-NN)")
+    parser.add_argument("--report-path", type=str, help="Specify a report path", default=None)
+    parser.add_argument("--profiler-path", help="Specify a profiler path", default=None)
+    return parser.parse_args()
+
+
 def main():
 
     run_command = sys.argv[0].split("/")
@@ -156,6 +166,23 @@ def main():
         os.environ.setdefault("FLASK_ENV", "production")
 
     config = cast(DefaultConfig, Config())
+    args = parse_args()
+    instance_id = None
+
+    if args.report_path or args.profiler_path:
+        app = create_app()
+        app.app_context().push()
+        try:
+            session = create_instance_from_local_paths(
+                report_path=args.report_path,
+                profiler_path=args.profiler_path,
+            )
+        except InvalidReportPath:
+            sys.exit("Invalid report path")
+        except InvalidProfilerPath:
+            sys.exit("Invalid profiler path")
+
+        instance_id = session.instance_id
 
     # Check if DEBUG environment variable is set
     debug_mode = os.environ.get("DEBUG", "false").lower() == "true"
@@ -182,7 +209,7 @@ def main():
         flask_env = os.getenv("FLASK_ENV", "development")
         port = config.PORT if flask_env == "production" else config.DEV_SERVER_PORT
         host = config.HOST if flask_env == "production" else config.DEV_SERVER_HOST
-        threading.Timer(2, open_browser, [host, port]).start()
+        threading.Timer(2, open_browser, [host, port, instance_id]).start()
     try:
         subprocess.run(gunicorn_args)
     except KeyboardInterrupt:

ttnn_visualizer/csv_queries.py

@@ -12,7 +12,7 @@ import pandas as pd
 from tt_perf_report import perf_report
 
 from ttnn_visualizer.exceptions import DataFormatError
-from ttnn_visualizer.models import TabSession
+from ttnn_visualizer.models import Instance
 from ttnn_visualizer.ssh_client import get_client
 
 
@@ -278,7 +278,7 @@ class DeviceLogProfilerQueries:
         "source file",
     ]
 
-    def __init__(self, session: TabSession):
+    def __init__(self, session: Instance):
         """
         Initialize the profiler with a session object.
         The session determines whether to use a local or remote runner.
@@ -366,7 +366,7 @@ class DeviceLogProfilerQueries:
         )
 
     @staticmethod
-    def get_raw_csv(session: TabSession):
+    def get_raw_csv(session: Instance):
         from ttnn_visualizer.sftp_operations import read_remote_file
 
         if (
@@ -455,7 +455,7 @@ class OpsPerformanceQueries:
         "HWCommandQueue_write_buffer_TT_HOST_FUNC [ns]",
     ]
 
-    def __init__(self, session: TabSession):
+    def __init__(self, session: Instance):
         """
         Initialize the performance profiler with a session object.
         """
@@ -571,6 +571,10 @@ class OpsPerformanceReportQueries:
         "raw_op_code"
     ]
 
+    PASSTHROUGH_COLUMNS = {
+        "pm_ideal_ns": "PM IDEAL [ns]",
+    }
+
     DEFAULT_SIGNPOST = None
     DEFAULT_IGNORE_SIGNPOSTS = None
     DEFAULT_MIN_PERCENTAGE = 0.5
@@ -596,6 +600,12 @@ class OpsPerformanceReportQueries:
             True,
         )
 
+        ops_perf_results = []
+        ops_perf_results_reader = csv.DictReader(StringIO(raw_csv))
+
+        for row in ops_perf_results_reader:
+            ops_perf_results.append(row)
+
         report = []
 
         try:
@@ -610,6 +620,12 @@ class OpsPerformanceReportQueries:
                         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

ttnn_visualizer/decorators.py

@@ -19,7 +19,7 @@ from ttnn_visualizer.exceptions import (
     NoProjectsException,
     RemoteSqliteException,
 )
-from ttnn_visualizer.sessions import get_or_create_tab_session
+from ttnn_visualizer.sessions import get_or_create_instance
 
 
 def with_session(func):
@@ -27,18 +27,18 @@ def with_session(func):
     def wrapper(*args, **kwargs):
         from flask import current_app
 
-        tab_id = request.args.get("tabId")
+        instance_id = request.args.get("instanceId")
 
-        if not tab_id:
-            current_app.logger.error("No tabId present on request, returning 404")
+        if not instance_id:
+            current_app.logger.error("No instanceId present on request, returning 404")
             abort(404)
 
-        session_query_data = get_or_create_tab_session(tab_id=tab_id)
+        session_query_data = get_or_create_instance(instance_id=instance_id)
         session = session_query_data.to_pydantic()
 
         if not session.active_report:
             current_app.logger.error(
-                f"No active report exists for tabId {tab_id}, returning 404"
+                f"No active report exists for instanceId {instance_id}, returning 404"
             )
             # Raise 404 if report_path is missing or does not exist
             abort(404)

ttnn_visualizer/exceptions.py

@@ -38,3 +38,10 @@ class DatabaseFileNotFoundException(Exception):
 
 class DataFormatError(Exception):
     pass
+
+
+class InvalidReportPath(Exception):
+    pass
+
+class InvalidProfilerPath(Exception):
+    pass

ttnn_visualizer/models.py

@@ -192,8 +192,8 @@ class RemoteReportFolder(SerializeableModel):
     lastSynced: Optional[int] = None
 
 
-class TabSession(BaseModel):
-    tab_id: str
+class Instance(BaseModel):
+    instance_id: str
     report_path: Optional[str] = None
     profiler_path: Optional[str] = None
     npe_path: Optional[str] = None
@@ -203,11 +203,11 @@ class TabSession(BaseModel):
     remote_profile_folder: Optional[RemoteReportFolder] = None
 
 
-class TabSessionTable(db.Model):
-    __tablename__ = "tab_sessions"
+class InstanceTable(db.Model):
+    __tablename__ = "instances"
 
     id = Column(Integer, primary_key=True)
-    tab_id = Column(String, unique=True, nullable=False)
+    instance_id = Column(String, unique=True, nullable=False)
     report_path = Column(String)
     profiler_path = Column(String, nullable=True)
     npe_path = Column(String, nullable=True)
@@ -218,7 +218,7 @@ class TabSessionTable(db.Model):
 
     def __init__(
         self,
-        tab_id,
+        instance_id,
         active_report,
         remote_connection=None,
         remote_folder=None,
@@ -227,7 +227,7 @@ class TabSessionTable(db.Model):
         profiler_path=None,
         npe_path=None,
     ):
-        self.tab_id = tab_id
+        self.instance_id = instance_id
         self.active_report = active_report
         self.report_path = report_path
         self.npe_path = npe_path
@@ -239,7 +239,7 @@ class TabSessionTable(db.Model):
     def to_dict(self):
         return {
             "id": self.id,
-            "tab_id": self.tab_id,
+            "instance_id": self.instance_id,
             "active_report": self.active_report,
             "remote_connection": self.remote_connection,
             "remote_folder": self.remote_folder,
@@ -249,9 +249,9 @@ class TabSessionTable(db.Model):
             "npe_path": self.npe_path
         }
 
-    def to_pydantic(self) -> TabSession:
-        return TabSession(
-            tab_id=str(self.tab_id),
+    def to_pydantic(self) -> Instance:
+        return Instance(
+            instance_id=str(self.instance_id),
             report_path=str(self.report_path) if self.report_path is not None else None,
             profiler_path=(
                 str(self.profiler_path) if self.profiler_path is not None else None

ttnn_visualizer/queries.py

@@ -13,7 +13,7 @@ from ttnn_visualizer.models import (
     DeviceOperation,
     Buffer,
     BufferPage,
-    TabSession,
+    Instance,
     Tensor,
     OperationArgument,
     StackTrace,
@@ -31,7 +31,7 @@ import paramiko
 
 
 class LocalQueryRunner:
-    def __init__(self, session: Optional[TabSession] = None, connection=None):
+    def __init__(self, session: Optional[Instance] = None, connection=None):
 
         if connection:
             self.connection = connection
@@ -66,7 +66,7 @@ class LocalQueryRunner:
 class RemoteQueryRunner:
     column_delimiter = "|||"
 
-    def __init__(self, session: TabSession):
+    def __init__(self, session: Instance):
         self.session = session
         self._validate_session()
         self.ssh_client = self._get_ssh_client(self.session.remote_connection)
@@ -165,11 +165,11 @@ class RemoteQueryRunner:
 
 class DatabaseQueries:
 
-    session: Optional[TabSession] = None
+    session: Optional[Instance] = None
     ssh_client = None
     query_runner: LocalQueryRunner | RemoteQueryRunner
 
-    def __init__(self, session: Optional[TabSession] = None, connection=None):
+    def __init__(self, session: Optional[Instance] = None, connection=None):
         self.session = session
 
         if connection:

ttnn_visualizer/sessions.py

@@ -2,13 +2,18 @@
 #
 # SPDX-FileCopyrightText: © 2024 Tenstorrent AI ULC
 
+import json
+import random
+import string
 from logging import getLogger
+from pathlib import Path
 
 from flask import request
 
+from ttnn_visualizer.exceptions import InvalidReportPath, InvalidProfilerPath
 from ttnn_visualizer.utils import get_report_path, get_profiler_path, get_npe_path
 from ttnn_visualizer.models import (
-    TabSessionTable,
+    InstanceTable,
 )
 from ttnn_visualizer.extensions import db
 
@@ -16,10 +21,9 @@ logger = getLogger(__name__)
 
 from flask import jsonify, current_app
 from sqlalchemy.exc import SQLAlchemyError
-import json
 
 
-def update_existing_tab_session(
+def update_existing_instance(
     session_data,
     report_name,
     profile_name,
@@ -66,12 +70,12 @@ def handle_sqlalchemy_error(error):
     db.session.rollback()
 
 
-def commit_and_log_session(session_data, tab_id):
+def commit_and_log_session(session_data, instance_id):
     db.session.commit()
 
-    session_data = TabSessionTable.query.filter_by(tab_id=tab_id).first()
+    session_data = InstanceTable.query.filter_by(instance_id=instance_id).first()
     current_app.logger.info(
-        f"Session data for tab {tab_id}: {json.dumps(session_data.to_dict(), indent=4)}"
+        f"Session data for instance {instance_id}: {json.dumps(session_data.to_dict(), indent=4)}"
     )
 
 
@@ -99,8 +103,8 @@ def update_paths(
         )
 
 
-def create_new_tab_session(
-    tab_id,
+def create_new_instance(
+    instance_id,
     report_name,
     profile_name,
     npe_name,
@@ -122,8 +126,8 @@ def create_new_tab_session(
         remote_folder = None
         remote_profile_folder = None
 
-    session_data = TabSessionTable(
-        tab_id=tab_id,
+    session_data = InstanceTable(
+        instance_id=instance_id,
         active_report=active_report,
         report_path=get_report_path(
             active_report,
@@ -142,8 +146,8 @@ def create_new_tab_session(
     return session_data
 
 
-def update_tab_session(
-    tab_id,
+def update_instance(
+    instance_id,
     report_name=None,
     profile_name=None,
     npe_name=None,
@@ -153,10 +157,10 @@ def update_tab_session(
     clear_remote=False,
 ):
     try:
-        session_data = get_or_create_tab_session(tab_id)
+        session_data = get_or_create_instance(instance_id)
 
         if session_data:
-            update_existing_tab_session(
+            update_existing_instance(
                 session_data,
                 report_name,
                 profile_name,
@@ -167,8 +171,8 @@ def update_tab_session(
                 clear_remote,
             )
         else:
-            session_data = create_new_tab_session(
-                tab_id,
+            session_data = create_new_instance(
+                instance_id,
                 report_name,
                 profile_name,
                 npe_name,
@@ -178,7 +182,7 @@ def update_tab_session(
                 clear_remote,
             )
 
-        commit_and_log_session(session_data, tab_id)
+        commit_and_log_session(session_data, instance_id)
         return jsonify({"message": "Tab session updated successfully"}), 200
 
     except SQLAlchemyError as e:
@@ -186,8 +190,8 @@ def update_tab_session(
         return jsonify({"error": "Failed to update tab session"}), 500
 
 
-def get_or_create_tab_session(
-    tab_id,
+def get_or_create_instance(
+    instance_id,
     report_name=None,
     profile_name=None,
     npe_name=None,
@@ -196,16 +200,16 @@ def get_or_create_tab_session(
 ):
     """
     Retrieve an existing tab session or create a new one if it doesn't exist.
-    Uses the TabSession model to manage session data and supports conditional updates.
+    Uses the Instance model to manage session data and supports conditional updates.
     """
     try:
         # Query the database for the tab session
-        session_data = TabSessionTable.query.filter_by(tab_id=tab_id).first()
+        session_data = InstanceTable.query.filter_by(instance_id=instance_id).first()
 
         # If session doesn't exist, initialize it
         if not session_data:
-            session_data = TabSessionTable(
-                tab_id=tab_id,
+            session_data = InstanceTable(
+                instance_id=instance_id,
                 active_report={},
                 remote_connection=None,
                 remote_folder=None,
@@ -215,8 +219,8 @@ def get_or_create_tab_session(
 
         # Update the session if any new data is provided
         if report_name or profile_name or npe_name or remote_connection or remote_folder:
-            update_tab_session(
-                tab_id=tab_id,
+            update_instance(
+                instance_id=instance_id,
                 report_name=report_name,
                 profile_name=profile_name,
                 npe_name=npe_name,
@@ -225,7 +229,7 @@ def get_or_create_tab_session(
             )
 
         # Query again to get the updated session data
-        session_data = TabSessionTable.query.filter_by(tab_id=tab_id).first()
+        session_data = InstanceTable.query.filter_by(instance_id=instance_id).first()
 
         return session_data
 
@@ -235,20 +239,20 @@ def get_or_create_tab_session(
         return None
 
 
-def get_tab_session():
+def get_instance():
     """
-    Middleware to retrieve or create a tab session based on the tab_id.
+    Middleware to retrieve or create a tab session based on the instance_id.
     """
-    tab_id = request.args.get("tabId", None)
+    instance_id = request.args.get("instanceId", None)
 
-    current_app.logger.info(f"get_tab_session: Received tab_id: {tab_id}")
-    if not tab_id:
-        current_app.logger.error("get_tab_session: No tab_id found")
-        return jsonify({"error": "tabId is required"}), 400
+    current_app.logger.info(f"get_instance: Received instance_id: {instance_id}")
+    if not instance_id:
+        current_app.logger.error("get_instance: No instance_id found")
+        return jsonify({"error": "instanceId is required"}), 400
 
-    active_report = get_or_create_tab_session(tab_id)
+    active_report = get_or_create_instance(instance_id)
     current_app.logger.info(
-        f"get_tab_session: Session retrieved: {active_report.active_report}"
+        f"get_instance: Session retrieved: {active_report.active_report}"
     )
 
     return jsonify({"active_report": active_report.active_report}), 200
@@ -258,5 +262,39 @@ def init_sessions(app):
     """
     Initializes session middleware and hooks it into Flask.
     """
-    app.before_request(get_tab_session)
+    app.before_request(get_instance)
     app.logger.info("Sessions middleware initialized.")
+
+
+def create_random_instance_id():
+    return ''.join(random.choices(string.ascii_lowercase + string.digits, k=10))
+
+
+def create_instance_from_local_paths(report_path, profiler_path):
+    _report_path = Path(report_path)
+    _profiler_path = Path(profiler_path)
+
+    if not _report_path.exists():
+        raise InvalidReportPath()
+
+    if not _profiler_path.exists():
+        raise InvalidProfilerPath()
+
+    report_name = _report_path.parts[-2] if len(_report_path.parts) > 2 else ""
+    profile_name = _profiler_path.parts[-1] if len(_profiler_path.parts) > 2 else ""
+    session_data = InstanceTable(
+        instance_id=create_random_instance_id(),
+        active_report={
+            "report_name": report_name,
+            "profile_name": profile_name,
+            "npe_name": None,
+        },
+        report_path=report_path,
+        profiler_path=profiler_path,
+        remote_connection=None,
+        remote_folder=None,
+        remote_profile_folder=None,
+    )
+    db.session.add(session_data)
+    db.session.commit()
+    return session_data

ttnn_visualizer/sockets.py

@@ -51,7 +51,7 @@ debounce_delay = 0.5  # Delay in seconds (adjust as needed)
 last_emit_time = 0
 
 
-def emit_file_status(progress: FileProgress, tab_id=None):
+def emit_file_status(progress: FileProgress, instance_id=None):
     """Debounced emit for file status updates using a debounce timer."""
     global debounce_timer, last_emit_time
 
@@ -59,10 +59,10 @@ def emit_file_status(progress: FileProgress, tab_id=None):
         global last_emit_time
         last_emit_time = time.time()
         data = progress.to_dict()
-        data.update({"tab_id": tab_id})
+        data.update({"instance_id": instance_id})
         try:
             if socketio is not None and hasattr(socketio, "emit"):
-                socketio.emit(Messages.FILE_TRANSFER_PROGRESS, data, to=tab_id)
+                socketio.emit(Messages.FILE_TRANSFER_PROGRESS, data, to=instance_id)
         except NameError:
             pass  # Can silently pass since we know the NameError is from sockets being disabled
 
@@ -89,30 +89,30 @@ def register_handlers(socketio_instance):
 
         sid = getattr(request, "sid", "")
 
-        tab_id = request.args.get("tabId")
-        print(f"Received tabId: {tab_id}, socket ID: {sid}")  # Log for debugging
+        instance_id = request.args.get("instanceId")
+        print(f"Received instanceId: {instance_id}, socket ID: {sid}")  # Log for debugging
 
-        if tab_id:
-            join_room(tab_id)  # Join the room identified by the tabId
-            tab_clients[tab_id] = sid  # Store the socket ID associated with this tabId
-            print(f"Joined room: {tab_id}")
+        if instance_id:
+            join_room(instance_id)  # Join the room identified by the instanceId
+            tab_clients[instance_id] = sid  # Store the socket ID associated with this instanceId
+            print(f"Joined room: {instance_id}")
         else:
-            print("No tabId provided, disconnecting client.")
+            print("No instanceId provided, disconnecting client.")
             disconnect()
 
     @socketio.on("disconnect")
     def handle_disconnect():
         from flask import request
 
-        tab_id = None
-        # Find and remove the socket ID associated with this tabId
+        instance_id = None
+        # Find and remove the socket ID associated with this instanceId
         sid = getattr(request, "sid", "")
         for key, value in tab_clients.items():
 
             if value == sid:
-                tab_id = key
+                instance_id = key
                 break
-        if tab_id:
-            leave_room(tab_id)
-            del tab_clients[tab_id]
-            print(f"Client disconnected from tabId: {tab_id}, Socket ID: {sid}")
+        if instance_id:
+            leave_room(instance_id)
+            del tab_clients[instance_id]
+            print(f"Client disconnected from instanceId: {instance_id}, Socket ID: {sid}")

ttnn_visualizer/static/assets/{allPaths-egCeGMYd.js → allPaths-DfvpbqXZ.js}

@@ -1 +1 @@
-import{I as n}from"./index-BVMreIQm.js";import{I as e}from"./index-Do7YB6C4.js";import{p as r,I as s}from"./index-rIoXC5rS.js";function I(o,t){var a=r(o);return t===s.STANDARD?n[a]:e[a]}function p(o){return r(o)}export{n as IconSvgPaths16,e as IconSvgPaths20,I as getIconPaths,p as iconNameToPathsRecordKey};
+import{I as n}from"./index-BVMreIQm.js";import{I as e}from"./index-Do7YB6C4.js";import{p as r,I as s}from"./index-CeYOVqR1.js";function I(o,t){var a=r(o);return t===s.STANDARD?n[a]:e[a]}function p(o){return r(o)}export{n as IconSvgPaths16,e as IconSvgPaths20,I as getIconPaths,p as iconNameToPathsRecordKey};

ttnn_visualizer/static/assets/{allPathsLoader-ChZ_kotC.js → allPathsLoader-C1wkx2sM.js}

@@ -1,2 +1,2 @@
-const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/allPaths-egCeGMYd.js","assets/index-BVMreIQm.js","assets/index-Do7YB6C4.js","assets/index-rIoXC5rS.js","assets/index-S-_ELv4m.css"])))=>i.map(i=>d[i]);
-import{_ as o,a as n,b as i}from"./index-rIoXC5rS.js";var _=function(e,a){return o(void 0,void 0,void 0,function(){var t;return n(this,function(r){switch(r.label){case 0:return[4,i(()=>import("./allPaths-egCeGMYd.js"),__vite__mapDeps([0,1,2,3,4]))];case 1:return t=r.sent().getIconPaths,[2,t(e,a)]}})})};export{_ as allPathsLoader};
+const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/allPaths-DfvpbqXZ.js","assets/index-BVMreIQm.js","assets/index-Do7YB6C4.js","assets/index-CeYOVqR1.js","assets/index-BTfoVg9a.css"])))=>i.map(i=>d[i]);
+import{_ as o,a as n,b as i}from"./index-CeYOVqR1.js";var _=function(e,a){return o(void 0,void 0,void 0,function(){var t;return n(this,function(r){switch(r.label){case 0:return[4,i(()=>import("./allPaths-DfvpbqXZ.js"),__vite__mapDeps([0,1,2,3,4]))];case 1:return t=r.sent().getIconPaths,[2,t(e,a)]}})})};export{_ as allPathsLoader};