ttnn-visualizer 0.29.0__py3-none-any.whl → 0.31.0__py3-none-any.whl

ttnn_visualizer/views.py

@@ -9,6 +9,7 @@ import time
 from http import HTTPStatus
 from pathlib import Path
 from typing import List
+import shutil
 
 from flask import Blueprint
 from flask import request, current_app
@@ -19,7 +20,7 @@ from ttnn_visualizer.enums import ConnectionTestStates
 from ttnn_visualizer.exceptions import DataFormatError
 from ttnn_visualizer.exceptions import RemoteConnectionException
 from ttnn_visualizer.file_uploads import (
-    extract_report_name,
+    extract_profiler_name,
     extract_npe_name,
     save_uploaded_files,
     validate_files,
@@ -45,13 +46,13 @@ from ttnn_visualizer.sessions import (
     update_instance,
 )
 from ttnn_visualizer.sftp_operations import (
-    sync_remote_folders,
+    sync_remote_profiler_folders,
     read_remote_file,
     check_remote_path_for_reports,
-    get_remote_report_folders,
-    check_remote_path_exists,
     get_remote_profiler_folders,
-    sync_remote_profiler_folders,
+    check_remote_path_exists,
+    get_remote_performance_folders,
+    sync_remote_performance_folders,
     get_cluster_desc,
 )
 from ttnn_visualizer.ssh_client import get_client
@@ -168,12 +169,7 @@ def operation_detail(operation_id, session):
         )
 
 
-@api.route(
-    "operation-history",
-    methods=[
-        "GET",
-    ],
-)
+@api.route("operation-history", methods=["GET"])
 @with_session
 @timer
 def operation_history(session: Instance):
@@ -192,7 +188,7 @@ def operation_history(session: Instance):
         return json.loads(operation_history)
     else:
         operation_history_file = (
-            Path(str(session.report_path)).parent / operation_history_filename
+            Path(str(session.profiler_path)).parent / operation_history_filename
         )
         if not operation_history_file.exists():
             return []
@@ -205,17 +201,17 @@ def operation_history(session: Instance):
 @timer
 def get_config(session: Instance):
     if session.remote_connection and session.remote_connection.useRemoteQuerying:
-        if not session.remote_folder:
+        if not session.remote_profiler_folder:
             return {}
         config = read_remote_file(
             remote_connection=session.remote_connection,
-            remote_path=Path(session.remote_folder.remotePath, "config.json"),
+            remote_path=Path(session.remote_profiler_folder.remotePath, "config.json"),
         )
         if not config:
             return {}
         return config
     else:
-        config_file = Path(str(session.report_path)).parent.joinpath("config.json")
+        config_file = Path(str(session.profiler_path)).parent.joinpath("config.json")
         if not config_file.exists():
             return {}
         with open(config_file, "r") as file:
@@ -375,20 +371,124 @@ def get_operation_buffers(operation_id, session: Instance):
         return serialize_operation_buffers(operation, buffers)
 
 
-@api.route("/profiler/device-log", methods=["GET"])
+@api.route("/profiler", methods=["GET"])
+@with_session
+def get_profiler_data_list(session: Instance):
+    # Doesn't handle remote at the moment
+    # is_remote = True if session.remote_connection else False
+    # config_key = "REMOTE_DATA_DIRECTORY" if is_remote else "LOCAL_DATA_DIRECTORY"
+    config_key = 'LOCAL_DATA_DIRECTORY'
+    data_directory = Path(current_app.config[config_key])
+
+    # if is_remote:
+    #     connection = RemoteConnection.model_validate(session.remote_connection, strict=False)
+    #     path = data_directory / connection.host / current_app.config["PROFILER_DIRECTORY_NAME"]
+    # else:
+    path = data_directory / current_app.config["PROFILER_DIRECTORY_NAME"]
+
+    if not path.exists():
+        path.mkdir(parents=True, exist_ok=True)
+
+    directory_names = [directory.name for directory in path.iterdir() if directory.is_dir()]
+
+    valid_dirs = []
+
+    for dir_name in directory_names:
+        dir_path = Path(path) / dir_name
+        files = list(dir_path.glob("**/*"))
+
+        # Would like to use the existing validate_files function but there's a type difference I'm not sure how to handle
+        if not any(file.name == "db.sqlite" for file in files):
+            continue
+        if not any(file.name == "config.json" for file in files):
+            continue
+
+        valid_dirs.append(dir_name)
+
+    return jsonify(valid_dirs)
+
+
+@api.route("/profiler/<profiler_name>", methods=["DELETE"])
 @with_session
-def get_profiler_data(session: Instance):
-    if not session.profiler_path:
+def delete_profiler_report(profiler_name, session: Instance):
+    is_remote = bool(session.remote_connection)
+    config_key = "REMOTE_DATA_DIRECTORY" if is_remote else "LOCAL_DATA_DIRECTORY"
+    data_directory = Path(current_app.config[config_key])
+
+    if not profiler_name:
+        return Response(status=HTTPStatus.BAD_REQUEST, response="Report name is required.")
+
+    if is_remote:
+        connection = RemoteConnection.model_validate(session.remote_connection, strict=False)
+        path = data_directory / connection.host / current_app.config["PROFILER_DIRECTORY_NAME"]
+    else:
+        path = data_directory / current_app.config["PROFILER_DIRECTORY_NAME"] / profiler_name
+
+    if session.active_report.profiler_name == profiler_name:
+        instance_id = request.args.get("instanceId")
+        update_instance(instance_id=instance_id,profiler_name="")
+
+    if path.exists() and path.is_dir():
+        shutil.rmtree(path)
+    else:
+        return Response(status=HTTPStatus.NOT_FOUND, response=f"Report does not exist: {path}")
+
+    return Response(status=HTTPStatus.NO_CONTENT, response=f"Report deleted successfully: {path}")
+
+
+
+@api.route("/performance", methods=["GET"])
+@with_session
+def get_performance_data_list(session: Instance):
+    is_remote = True if session.remote_connection else False
+    config_key = "REMOTE_DATA_DIRECTORY" if is_remote else "LOCAL_DATA_DIRECTORY"
+    config_key = 'LOCAL_DATA_DIRECTORY'
+    data_directory = Path(current_app.config[config_key])
+
+    if is_remote:
+        connection = RemoteConnection.model_validate(session.remote_connection, strict=False)
+        path = data_directory / connection.host / current_app.config["PERFORMANCE_DIRECTORY_NAME"]
+    else:
+        path = data_directory / current_app.config["PERFORMANCE_DIRECTORY_NAME"]
+
+    if not path.exists():
+        path.mkdir(parents=True, exist_ok=True)
+
+    directory_names = [directory.name for directory in path.iterdir() if directory.is_dir()]
+
+    valid_dirs = []
+
+    for dir_name in directory_names:
+        dir_path = Path(path) / dir_name
+        files = list(dir_path.glob("**/*"))
+
+        # Would like to use the existing validate_files function but there's a type difference I'm not sure how to handle
+        if not any(file.name == "profile_log_device.csv" for file in files):
+            continue
+        if not any(file.name == "tracy_profile_log_host.tracy" for file in files):
+            continue
+        if not any(file.name.startswith("ops_perf_results") for file in files):
+            continue
+
+        valid_dirs.append(dir_name)
+
+    return jsonify(valid_dirs)
+
+
+@api.route("/performance/device-log", methods=["GET"])
+@with_session
+def get_performance_data(session: Instance):
+    if not session.performance_path:
         return Response(status=HTTPStatus.NOT_FOUND)
     with DeviceLogProfilerQueries(session) as csv:
         result = csv.get_all_entries(as_dict=True, limit=100)
         return jsonify(result)
 
 
-@api.route("/profiler/perf-results", methods=["GET"])
+@api.route("/performance/perf-results", methods=["GET"])
 @with_session
 def get_profiler_performance_data(session: Instance):
-    if not session.profiler_path:
+    if not session.performance_path:
         return Response(status=HTTPStatus.NOT_FOUND)
     with OpsPerformanceQueries(session) as csv:
         # result = csv.query_by_op_code(op_code="(torch) contiguous", as_dict=True)
@@ -396,10 +496,38 @@ def get_profiler_performance_data(session: Instance):
         return jsonify(result)
 
 
-@api.route("/profiler/perf-results/raw", methods=["GET"])
+@api.route("/performance/<performance_name>", methods=["DELETE"])
+@with_session
+def delete_performance_report(performance_name, session: Instance):
+    is_remote = bool(session.remote_connection)
+    config_key = "REMOTE_DATA_DIRECTORY" if is_remote else "LOCAL_DATA_DIRECTORY"
+    data_directory = Path(current_app.config[config_key])
+
+    if not performance_name:
+        return Response(status=HTTPStatus.BAD_REQUEST, response="Report name is required.")
+
+    if is_remote:
+        connection = RemoteConnection.model_validate(session.remote_connection, strict=False)
+        path = data_directory / connection.host / current_app.config["PERFORMANCE_DIRECTORY_NAME"]
+    else:
+        path = data_directory / current_app.config["PERFORMANCE_DIRECTORY_NAME"] / performance_name
+
+    if session.active_report.performance_name == performance_name:
+        instance_id = request.args.get("instanceId")
+        update_instance(instance_id=instance_id,performance_name="")
+
+    if path.exists() and path.is_dir():
+        shutil.rmtree(path)
+    else:
+        return Response(status=HTTPStatus.NOT_FOUND, response=f"Report does not exist: {path}")
+
+    return Response(status=HTTPStatus.NO_CONTENT, response=f"Report deleted successfully: {path}")
+
+
+@api.route("/performance/perf-results/raw", methods=["GET"])
 @with_session
-def get_profiler_perf_results_data_raw(session: Instance):
-    if not session.profiler_path:
+def get_performance_results_data_raw(session: Instance):
+    if not session.performance_path:
         return Response(status=HTTPStatus.NOT_FOUND)
     content = OpsPerformanceQueries.get_raw_csv(session)
     return Response(
@@ -409,12 +537,19 @@ def get_profiler_perf_results_data_raw(session: Instance):
     )
 
 
-@api.route("/profiler/perf-results/report", methods=["GET"])
+@api.route("/performance/perf-results/report", methods=["GET"])
 @with_session
-def get_profiler_perf_results_report(session: Instance):
-    if not session.profiler_path:
+def get_performance_results_report(session: Instance):
+    if not session.performance_path:
         return Response(status=HTTPStatus.NOT_FOUND)
 
+    name = request.args.get("name", None)
+    performance_path = Path(session.performance_path)
+    if name:
+        performance_path = performance_path.parent / name
+        session.performance_path = str(performance_path)
+        logger.info(f"************ Profiler path set to {session.performance_path}")
+
     try:
         report = OpsPerformanceReportQueries.generate_report(session)
     except DataFormatError:
@@ -423,10 +558,10 @@ def get_profiler_perf_results_report(session: Instance):
     return jsonify(report), 200
 
 
-@api.route("/profiler/device-log/raw", methods=["GET"])
+@api.route("/performance/device-log/raw", methods=["GET"])
 @with_session
-def get_profiler_data_raw(session: Instance):
-    if not session.profiler_path:
+def get_performance_data_raw(session: Instance):
+    if not session.performance_path:
         return Response(status=HTTPStatus.NOT_FOUND)
     content = DeviceLogProfilerQueries.get_raw_csv(session)
     return Response(
@@ -436,10 +571,10 @@ def get_profiler_data_raw(session: Instance):
     )
 
 
-@api.route("/profiler/device-log/zone/<zone>", methods=["GET"])
+@api.route("/performance/device-log/zone/<zone>", methods=["GET"])
 @with_session
 def get_zone_statistics(zone, session: Instance):
-    if not session.profiler_path:
+    if not session.performance_path:
         return Response(status=HTTPStatus.NOT_FOUND)
     with DeviceLogProfilerQueries(session) as csv:
         result = csv.query_zone_statistics(zone_name=zone, as_dict=True)
@@ -454,10 +589,10 @@ def get_devices(session: Instance):
         return serialize_devices(devices)
 
 
-@api.route("/local/upload/report", methods=["POST"])
-def create_report_files():
+@api.route("/local/upload/profiler", methods=["POST"])
+def create_profiler_files():
     files = request.files.getlist("files")
-    report_directory = current_app.config["LOCAL_DATA_DIRECTORY"]
+    profiler_directory = current_app.config["LOCAL_DATA_DIRECTORY"] / current_app.config["PROFILER_DIRECTORY_NAME"]
 
     if not validate_files(files, {"db.sqlite", "config.json"}):
         return StatusMessage(
@@ -465,23 +600,26 @@ def create_report_files():
             message="Invalid project directory.",
         ).model_dump()
 
-    report_name = extract_report_name(files)
-    logger.info(f"Writing report files to {report_directory}/{report_name}")
+    if not profiler_directory.exists():
+        profiler_directory.mkdir(parents=True, exist_ok=True)
+
+    profiler_name = extract_profiler_name(files)
+    logger.info(f"Writing report files to {profiler_directory}/{profiler_name}")
 
-    save_uploaded_files(files, report_directory, report_name)
+    save_uploaded_files(files, profiler_directory, profiler_name)
 
     instance_id = request.args.get("instanceId")
-    update_instance(instance_id=instance_id, report_name=report_name, clear_remote=True)
+    update_instance(instance_id=instance_id, profiler_name=profiler_name, clear_remote=True)
 
     return StatusMessage(
         status=ConnectionTestStates.OK, message="Success."
     ).model_dump()
 
 
-@api.route("/local/upload/profile", methods=["POST"])
+@api.route("/local/upload/performance", methods=["POST"])
 def create_profile_files():
     files = request.files.getlist("files")
-    report_directory = Path(current_app.config["LOCAL_DATA_DIRECTORY"])
+    data_directory = Path(current_app.config["LOCAL_DATA_DIRECTORY"])
     instance_id = request.args.get("instanceId")
 
     if not validate_files(
@@ -494,10 +632,10 @@ def create_profile_files():
             message="Invalid project directory.",
         ).model_dump()
 
-    logger.info(f"Writing profile files to {report_directory} / 'profiles'")
+    logger.info(f"Writing profile files to {data_directory} / {current_app.config['PERFORMANCE_DIRECTORY_NAME']}")
 
-    # Construct the base directory with report_name first
-    target_directory = report_directory / "profiles"
+    # Construct the base directory with profiler_name first
+    target_directory = data_directory / current_app.config["PERFORMANCE_DIRECTORY_NAME"]
     target_directory.mkdir(parents=True, exist_ok=True)
 
     if files:
@@ -516,11 +654,11 @@ def create_profile_files():
 
     save_uploaded_files(
         updated_files,
-        str(report_directory),
+        str(data_directory),
     )
 
     update_instance(
-        instance_id=instance_id, profile_name=profiler_folder_name, clear_remote=True
+        instance_id=instance_id, performance_name=profiler_folder_name, clear_remote=True
     )
 
     return StatusMessage(
@@ -531,7 +669,7 @@ def create_profile_files():
 @api.route("/local/upload/npe", methods=["POST"])
 def create_npe_files():
     files = request.files.getlist("files")
-    report_directory = current_app.config["LOCAL_DATA_DIRECTORY"]
+    data_directory = current_app.config["LOCAL_DATA_DIRECTORY"]
 
     for file in files:
         if not file.filename.endswith(".json"):
@@ -541,7 +679,7 @@ def create_npe_files():
             ).model_dump()
 
     npe_name = extract_npe_name(files)
-    target_directory = report_directory / "npe"
+    target_directory = data_directory / current_app.config["NPE_DIRECTORY_NAME"]
     target_directory.mkdir(parents=True, exist_ok=True)
 
     save_uploaded_files(files, target_directory, npe_name)
@@ -554,22 +692,18 @@ def create_npe_files():
     ).model_dump()
 
 
-@api.route("/remote/folder", methods=["POST"])
-def get_remote_folders():
+@api.route("/remote/profiler", methods=["POST"])
+def get_remote_folders_profiler():
     connection = RemoteConnection.model_validate(request.json, strict=False)
     try:
-        remote_folders: List[RemoteReportFolder] = get_remote_report_folders(
+        remote_folders: List[RemoteReportFolder] = get_remote_profiler_folders(
             RemoteConnection.model_validate(connection, strict=False)
         )
 
         for rf in remote_folders:
             directory_name = Path(rf.remotePath).name
             remote_data_directory = current_app.config["REMOTE_DATA_DIRECTORY"]
-            local_path = (
-                Path(remote_data_directory)
-                .joinpath(connection.host)
-                .joinpath(directory_name)
-            )
+            local_path = remote_data_directory / current_app.config["PROFILER_DIRECTORY_NAME"] / connection.host / directory_name
             logger.info(f"Checking last synced for {directory_name}")
             rf.lastSynced = read_last_synced_file(str(local_path))
             if not rf.lastSynced:
@@ -580,33 +714,28 @@ def get_remote_folders():
         return Response(status=e.http_status, response=e.message)
 
 
-@api.route("/remote/profiles", methods=["POST"])
-def get_remote_profile_folders():
+@api.route("/remote/performance", methods=["POST"])
+def get_remote_folders_performance():
     request_body = request.get_json()
     connection = RemoteConnection.model_validate(
         request_body.get("connection"), strict=False
     )
 
     try:
-        remote_profile_folders: List[RemoteReportFolder] = get_remote_profiler_folders(
+        remote_performance_folders: List[RemoteReportFolder] = get_remote_performance_folders(
             RemoteConnection.model_validate(connection, strict=False)
         )
 
-        for rf in remote_profile_folders:
-            profile_name = Path(rf.remotePath).name
+        for rf in remote_performance_folders:
+            performance_name = Path(rf.remotePath).name
             remote_data_directory = current_app.config["REMOTE_DATA_DIRECTORY"]
-            local_path = (
-                Path(remote_data_directory)
-                .joinpath(connection.host)
-                .joinpath("profiler")
-                .joinpath(profile_name)
-            )
-            logger.info(f"Checking last synced for {profile_name}")
+            local_path = remote_data_directory / current_app.config["PERFORMANCE_DIRECTORY_NAME"] / connection.host / performance_name
+            logger.info(f"Checking last synced for {performance_name}")
             rf.lastSynced = read_last_synced_file(str(local_path))
             if not rf.lastSynced:
-                logger.info(f"{profile_name} not yet synced")
+                logger.info(f"{performance_name} not yet synced")
 
-        return [r.model_dump() for r in remote_profile_folders]
+        return [r.model_dump() for r in remote_performance_folders]
     except RemoteConnectionException as e:
         return Response(status=e.http_status, response=e.message)
 
@@ -674,8 +803,8 @@ def test_remote_folder():
     # Test Directory Configuration
     if not has_failures():
         try:
-            check_remote_path_exists(connection, "reportPath")
-            add_status(ConnectionTestStates.OK.value, "Report folder path exists")
+            check_remote_path_exists(connection, "profilerPath")
+            add_status(ConnectionTestStates.OK.value, "Memory folder path exists")
         except RemoteConnectionException as e:
             add_status(ConnectionTestStates.FAILED.value, e.message)
 
@@ -737,7 +866,7 @@ def sync_remote_folder():
     if profile:
         profile_folder = RemoteReportFolder.model_validate(profile, strict=False)
         try:
-            sync_remote_profiler_folders(
+            sync_remote_performance_folders(
                 connection,
                 remote_dir,
                 profile=profile_folder,
@@ -753,19 +882,19 @@ def sync_remote_folder():
             return Response(status=e.http_status, response=e.message)
 
     try:
-        remote_folder = RemoteReportFolder.model_validate(folder, strict=False)
+        remote_profiler_folder = RemoteReportFolder.model_validate(folder, strict=False)
 
-        sync_remote_folders(
+        sync_remote_profiler_folders(
             connection,
-            remote_folder.remotePath,
+            remote_profiler_folder.remotePath,
             remote_dir,
             exclude_patterns=[r"/tensors(/|$)"],
             sid=instance_id,
         )
 
-        remote_folder.lastSynced = int(time.time())
+        remote_profiler_folder.lastSynced = int(time.time())
 
-        return remote_folder.model_dump()
+        return remote_profiler_folder.model_dump()
 
     except RemoteConnectionException as e:
         return Response(status=e.http_status, response=e.message)
@@ -808,15 +937,15 @@ def use_remote_folder():
 
     connection = RemoteConnection.model_validate(connection, strict=False)
     folder = RemoteReportFolder.model_validate(folder, strict=False)
-    profile_name = None
-    remote_profile_folder = None
+    performance_name = None
+    remote_performance_folder = None
     if profile:
-        remote_profile_folder = RemoteReportFolder.model_validate(profile, strict=False)
-        profile_name = remote_profile_folder.testName
-    report_data_directory = current_app.config["REMOTE_DATA_DIRECTORY"]
-    report_folder = Path(folder.remotePath).name
+        remote_performance_folder = RemoteReportFolder.model_validate(profile, strict=False)
+        performance_name = remote_performance_folder.testName
+    data_directory = current_app.config["REMOTE_DATA_DIRECTORY"]
+    profiler_name = Path(folder.remotePath).name
 
-    connection_directory = Path(report_data_directory, connection.host, report_folder)
+    connection_directory = Path(data_directory, connection.host, current_app.config["PROFILER_DIRECTORY_NAME"], profiler_name)
 
     if not connection.useRemoteQuerying and not connection_directory.exists():
         return Response(
@@ -824,18 +953,18 @@ def use_remote_folder():
             response=f"{connection_directory} does not exist.",
         )
 
-    remote_path = f"{Path(report_data_directory).name}/{connection.host}/{connection_directory.name}"
+    remote_path = f"{Path(data_directory).name}/{connection.host}/{connection_directory.name}"
 
     instance_id = request.args.get("instanceId")
-    current_app.logger.info(f"Setting active report for {instance_id} - {remote_path}")
+    current_app.logger.info(f"Setting active reports for {instance_id} - {remote_path}")
 
     update_instance(
         instance_id=instance_id,
-        report_name=report_folder,
-        profile_name=profile_name,
+        profiler_name=profiler_name,
+        performance_name=performance_name,
         remote_connection=connection,
-        remote_folder=folder,
-        remote_profile_folder=remote_profile_folder,
+        remote_profiler_folder=folder,
+        remote_performance_folder=remote_performance_folder,
     )
 
     return Response(status=HTTPStatus.OK)
@@ -853,6 +982,35 @@ def get_instance(session: Instance):
     return session.model_dump()
 
 
+@api.route("/session", methods=["PUT"])
+def update_current_instance():
+    try:
+        update_data = request.get_json()
+
+        if not update_data:
+            return Response(status=HTTPStatus.BAD_REQUEST, response="No data provided.")
+
+        update_instance(
+            instance_id=update_data.get("instance_id"),
+            profiler_name=update_data["active_report"].get("profiler_name"),
+            performance_name=update_data["active_report"].get("performance_name"),
+            npe_name=update_data["active_report"].get("npe_name"),
+            # Doesn't handle remote at the moment
+            remote_connection=None,
+            remote_profiler_folder=None,
+            remote_performance_folder=None,
+        )
+
+        return Response(status=HTTPStatus.OK)
+    except Exception as e:
+        logger.error(f"Error updating session: {str(e)}")
+
+        return Response(
+            status=HTTPStatus.INTERNAL_SERVER_ERROR,
+            response="An error occurred while updating the session.",
+        )
+
+
 @api.route("/npe", methods=["GET"])
 @with_session
 @timer
@@ -862,9 +1020,12 @@ def get_npe_data(session: Instance):
         return Response(status=HTTPStatus.NOT_FOUND)
 
     npe_file = Path(f"{session.npe_path}/{session.active_report.npe_name}.json")
+
     if not npe_file.exists():
         logger.error(f"NPE file does not exist: {npe_file}")
         return Response(status=HTTPStatus.NOT_FOUND)
+
     with open(npe_file, "r") as file:
         npe_data = json.load(file)
+
     return jsonify(npe_data)

{ttnn_visualizer-0.29.0.dist-info → ttnn_visualizer-0.31.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ttnn_visualizer
-Version: 0.29.0
+Version: 0.31.0
 Summary: TT-NN Visualizer
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
@@ -123,13 +123,13 @@ You may test the application using the following sample reports.
 Unzip the files into their own directories and select them with the local folder selector, or load the NPE data on the `/npe` route.
 
 **Segformer encoder**
-[report](https://github.com/user-attachments/files/17996493/segformer_encoder.zip)
+[memory report](https://github.com/user-attachments/files/17996493/segformer_encoder.zip)
 
 **Segformer decoder**
-[report](https://github.com/user-attachments/files/17996491/segformer_decoder_good.zip)
+[memory report](https://github.com/user-attachments/files/17996491/segformer_decoder_good.zip)
 
 **Llama mlp**
-[report + performance trace](https://github.com/user-attachments/files/18770763/llama_attn_32l_10iter_30jan.zip)
+[memory + performance report](https://github.com/user-attachments/files/18770763/llama_attn_32l_10iter_30jan.zip)
 
 ### NPE report