tritonparse 0.2.4.dev20251006071528__py3-none-any.whl → 0.2.4.dev20251008071501__py3-none-any.whl

tritonparse/__main__.py

@@ -1,4 +1,4 @@
-from .run import main
+from .cli import main
 
 
 if __name__ == "__main__":

tritonparse/cli.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+#  Copyright (c) Meta Platforms, Inc. and affiliates.
+import argparse
+from importlib.metadata import PackageNotFoundError, version
+
+from .common import is_fbcode
+from .reproducer.cli import _add_reproducer_args
+from .reproducer.orchestrator import reproduce
+from .utils import _add_parse_args, unified_parse
+
+
+def _get_package_version() -> str:
+    try:
+        return version("tritonparse")
+    except PackageNotFoundError:
+        return "0+unknown"
+
+
+def main():
+    pkg_version = _get_package_version()
+
+    # Use different command name for fbcode vs OSS
+    prog_name = "tritonparse" if is_fbcode() else "tritonparseoss"
+
+    parser = argparse.ArgumentParser(
+        prog=prog_name,
+        description=(
+            "TritonParse: parse structured logs and generate minimal reproducers"
+        ),
+        epilog=(
+            "Examples:\n"
+            f"  {prog_name} parse /path/to/logs --out parsed_output\n"
+            f"  {prog_name} reproduce /path/to/trace.ndjson --line 2 --out-dir repro_output\n"
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {pkg_version}",
+        help="Show program's version number and exit",
+    )
+
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # parse subcommand
+    parse_parser = subparsers.add_parser(
+        "parse",
+        help="Parse triton structured logs",
+        conflict_handler="resolve",
+    )
+    _add_parse_args(parse_parser)
+    parse_parser.set_defaults(func="parse")
+
+    # reproduce subcommand
+    repro_parser = subparsers.add_parser(
+        "reproduce",
+        help="Build reproducer from trace file",
+    )
+    _add_reproducer_args(repro_parser)
+    repro_parser.set_defaults(func="reproduce")
+
+    args = parser.parse_args()
+
+    if args.func == "parse":
+        parse_args = {
+            k: v for k, v in vars(args).items() if k not in ["command", "func"]
+        }
+        unified_parse(**parse_args)
+    elif args.func == "reproduce":
+        reproduce(
+            input_path=args.input,
+            line_index=args.line,
+            out_dir=args.out_dir,
+            template=args.template,
+        )
+    else:
+        raise RuntimeError(f"Unknown command: {args.func}")
+
+
+if __name__ == "__main__":
+    # Do not add code here, it won't be run. Add them to the function called below.
+    main()  # pragma: no cover

tritonparse/context_manager.py

@@ -17,6 +17,8 @@ class TritonParseManager:
         self,
         enable_trace_launch=False,
         split_inductor_compilations=True,
+        enable_tensor_blob_storage=False,
+        tensor_storage_quota=None,
         **parse_kwargs,
     ):
         """
@@ -25,17 +27,28 @@ class TritonParseManager:
         Args:
             enable_trace_launch: Whether to enable trace launch
             split_inductor_compilations: Whether to split inductor compilations in the output
+            enable_tensor_blob_storage: Whether to enable tensor blob storage
+            tensor_storage_quota: Storage quota in bytes for tensor blobs (default: 100GB)
             **parse_kwargs: Additional keyword arguments to pass to unified_parse
         """
         self.enable_trace_launch = enable_trace_launch
         self.split_inductor_compilations = split_inductor_compilations
+        self.enable_tensor_blob_storage = enable_tensor_blob_storage
+        self.tensor_storage_quota = tensor_storage_quota
         self.parse_kwargs = parse_kwargs
         self.dir_path = None
         self.output_link = None
 
     def __enter__(self):
         self.dir_path = createUniqueTempDirectory()
-        init(self.dir_path, enable_trace_launch=self.enable_trace_launch)
+        init_kwargs = {
+            "enable_trace_launch": self.enable_trace_launch,
+            "enable_tensor_blob_storage": self.enable_tensor_blob_storage,
+        }
+        if self.tensor_storage_quota is not None:
+            init_kwargs["tensor_storage_quota"] = self.tensor_storage_quota
+
+        init(self.dir_path, **init_kwargs)
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):

tritonparse/reproducer/templates/example.py

@@ -3,13 +3,16 @@ This file is automatically generated by TritonParse reproducer.
 It contains a smallest testing example for a Triton kernel.
 """
 
+import gzip
 import hashlib
 import importlib
+import io
 import json
 import logging
 import sys
 from functools import lru_cache
 from pathlib import Path
+from typing import Union
 
 import torch
 
@@ -42,13 +45,14 @@ def _get_triton_tensor_types():
     )
 
 
-def load_tensor(tensor_file_path: str, device: str = None) -> torch.Tensor:
+def load_tensor(tensor_file_path: Union[str, Path], device: str = None) -> torch.Tensor:
     """
     Load a tensor from its file path and verify its integrity using the hash in the filename.
 
     Args:
-        tensor_file_path (str): Direct path to the tensor .bin file. The filename should be
-                               the hash of the file contents followed by .bin extension.
+        tensor_file_path (str | Path): Direct path to the tensor file. Supports both:
+                               - .bin.gz: gzip-compressed tensor (hash is of uncompressed data)
+                               - .bin: uncompressed tensor (for backward compatibility)
         device (str, optional): Device to load the tensor to (e.g., 'cuda:0', 'cpu').
                                If None, keeps the tensor on its original device.
 
@@ -65,13 +69,26 @@ def load_tensor(tensor_file_path: str, device: str = None) -> torch.Tensor:
     if not blob_path.exists():
         raise FileNotFoundError(f"Tensor blob not found: {blob_path}")
 
-    # Extract expected hash from filename (remove .bin extension)
-    expected_hash = blob_path.stem
+    # Detect compression by file extension
+    is_compressed = blob_path.name.endswith(".bin.gz")
 
-    # Compute actual hash of file contents
-    with open(blob_path, "rb") as f:
-        file_contents = f.read()
-        computed_hash = hashlib.blake2b(file_contents).hexdigest()
+    # Read file contents (decompress if needed)
+    try:
+        with open(blob_path, "rb") as f:
+            file_obj = gzip.GzipFile(fileobj=f, mode="rb") if is_compressed else f
+            file_contents = file_obj.read()
+    except (OSError, gzip.BadGzipFile) as e:
+        if is_compressed:
+            raise RuntimeError(f"Failed to decompress gzip file {blob_path}: {str(e)}")
+        else:
+            raise RuntimeError(f"Failed to read file {blob_path}: {str(e)}")
+
+    # Extract expected hash from filename
+    # abc123.bin.gz -> abc123 or abc123.bin -> abc123
+    expected_hash = blob_path.name.removesuffix(".bin.gz" if is_compressed else ".bin")
+
+    # Compute hash of uncompressed data
+    computed_hash = hashlib.blake2b(file_contents).hexdigest()
 
     # Verify hash matches filename
     if computed_hash != expected_hash:
@@ -80,12 +97,11 @@ def load_tensor(tensor_file_path: str, device: str = None) -> torch.Tensor:
         )
 
     try:
-        # Load the tensor using torch.load (tensors are saved with torch.save)
-        # If device is None, keep tensor on its original device, otherwise move to specified device
-        tensor = torch.load(blob_path, map_location=device)
+        # Load the tensor from memory buffer
+        tensor = torch.load(io.BytesIO(file_contents), map_location=device)
         return tensor
     except Exception as e:
-        raise RuntimeError(f"Failed to load tensor from {blob_path}: {str(e)}") from e
+        raise RuntimeError(f"Failed to load tensor from {blob_path}: {str(e)}")
 
 
 def create_args_from_json_file(json_path):
@@ -126,6 +142,171 @@ def create_args_from_json(data):
     return grid, args_dict
 
 
+def _apply_stride_and_offset(tensor, shape, stride, storage_offset):
+    """
+    Apply custom stride and storage offset to a tensor if needed.
+
+    Args:
+        tensor: The base contiguous tensor
+        shape: The desired shape
+        stride: The desired stride (or None for contiguous)
+        storage_offset: The desired storage offset
+
+    Returns:
+        torch.Tensor: The strided tensor view or original tensor if contiguous
+    """
+    if stride is None:
+        return tensor
+
+    # Calculate expected contiguous stride
+    expected_contiguous_stride = []
+    s = 1
+    for dim_size in reversed(shape):
+        expected_contiguous_stride.insert(0, s)
+        s *= dim_size
+
+    # If stride matches contiguous stride and no storage offset, return as-is
+    if tuple(stride) == tuple(expected_contiguous_stride) and storage_offset == 0:
+        return tensor
+
+    # Calculate required storage size
+    if len(shape) > 0 and len(stride) > 0:
+        max_offset = storage_offset
+        for dim_stride, dim_size in zip(stride, shape):
+            if dim_size > 0:
+                max_offset += dim_stride * (dim_size - 1)
+        storage_size = max_offset + 1
+    else:
+        storage_size = storage_offset + 1
+
+    # Create larger storage tensor and create strided view
+    storage_tensor = torch.empty(storage_size, dtype=tensor.dtype, device=tensor.device)
+
+    # Create strided view
+    strided_view = storage_tensor.as_strided(
+        size=shape, stride=stride, storage_offset=storage_offset
+    )
+
+    # Copy data from the base tensor into the strided layout
+    strided_view.copy_(tensor.flatten()[: strided_view.numel()].view(shape))
+
+    return strided_view
+
+
+def _create_base_tensor(arg_info) -> torch.Tensor:
+    if arg_info.get("blob_path"):
+        return load_tensor(arg_info.get("blob_path"), arg_info.get("device"))
+
+    # Extract basic tensor properties
+    dtype_str = arg_info.get("dtype")
+    try:
+        torch_dtype = getattr(torch, dtype_str.split(".")[-1])
+    except AttributeError:
+        logging.error(f"Unsupported dtype: {dtype_str}. Defaulting to float32.")
+        torch_dtype = torch.float32
+
+    shape = arg_info.get("shape", [])
+    device = arg_info.get("device", "cpu")
+
+    # Extract statistical information if available
+    mean = arg_info.get("mean")
+    std = arg_info.get("std")
+    min_val = arg_info.get("min")
+    max_val = arg_info.get("max")
+    has_stats = (
+        mean is not None
+        and std is not None
+        and min_val is not None
+        and max_val is not None
+    )
+
+    if arg_info.get("tensor_capture_error", False):
+        logging.error(
+            f"Error: Tensor '{arg_info.get('name', '')}' had capture error. Generating random tensor instead."
+        )
+
+    # Use a dummy tensor to check properties of the dtype
+    tensor_props = torch.empty(0, dtype=torch_dtype)
+
+    # Case 1: Floating point types
+    if tensor_props.is_floating_point():
+        if has_stats:
+            # Generate tensor with statistical properties matching original data
+            if std == 0 or min_val == max_val:
+                # Constant tensor
+                return torch.full(shape, mean, dtype=torch_dtype, device=device)
+            # Generate normal distribution with mean and std, then clamp to [min, max]
+            tensor = torch.randn(shape, dtype=torch.float32, device=device) * std + mean
+            tensor = torch.clamp(tensor, min=min_val, max=max_val)
+            return tensor.to(torch_dtype)
+        else:
+            # Fallback to original random generation
+            if torch_dtype in [torch.float8_e4m3fn, torch.float8_e5m2]:
+                tmp = torch.rand(shape, dtype=torch.float32, device=device)
+                return tmp.to(torch_dtype)
+            else:
+                return torch.empty(shape, dtype=torch_dtype, device=device).random_()
+
+    # Case 2: Integer types
+    elif torch_dtype in [
+        torch.int8,
+        torch.int16,
+        torch.int32,
+        torch.int64,
+        torch.uint8,
+        torch.bool,
+    ]:
+        if has_stats and torch_dtype != torch.bool:
+            # Generate tensor with statistical properties, then round for integers
+            if std == 0 or min_val == max_val:
+                # Constant tensor
+                return torch.full(shape, int(mean), dtype=torch_dtype, device=device)
+            tensor = torch.randn(shape, dtype=torch.float32, device=device) * std + mean
+            tensor = torch.clamp(tensor, min=min_val, max=max_val)
+            return torch.round(tensor).to(torch_dtype)
+        else:
+            # Fallback to original random generation
+            return torch.empty(shape, dtype=torch_dtype, device=device).random_()
+
+    # Case 3: Complex numbers need special handling
+    elif tensor_props.is_complex():
+        # Complex types: fallback to original logic for now
+        # TODO: Could be improved to use statistical info if available
+        float_dtype = torch.float32 if torch_dtype == torch.complex64 else torch.float64
+        real_part = torch.rand(shape, dtype=float_dtype, device=device)
+        imag_part = torch.rand(shape, dtype=float_dtype, device=device)
+        return torch.complex(real_part, imag_part)
+
+    # Case 4: Handle other unsigned integers (like uint32) which fail with random_()
+    elif "uint" in str(torch_dtype):
+        if has_stats:
+            # Generate tensor with statistical properties for unsigned integers
+            if std == 0 or min_val == max_val:
+                return torch.full(shape, int(mean), dtype=torch_dtype, device=device)
+            tensor = torch.randn(shape, dtype=torch.float32, device=device) * std + mean
+            tensor = torch.clamp(tensor, min=min_val, max=max_val)
+            return torch.round(tensor).to(torch_dtype)
+        else:
+            # Fallback to original random generation
+            return torch.randint(0, 1000, shape, dtype=torch_dtype, device=device)
+
+    # Case 5: If we don't know how to handle the type, raise an error
+    else:
+        raise NotImplementedError(
+            f"Random data generation not implemented for dtype: {torch_dtype}"
+        )
+
+
+def _create_tensor(arg_info) -> torch.Tensor:
+    tensor = _create_base_tensor(arg_info)
+
+    # Apply stride and storage offset if needed
+    shape = arg_info.get("shape", [])
+    stride = arg_info.get("stride")
+    storage_offset = arg_info.get("storage_offset", 0)
+    return _apply_stride_and_offset(tensor, shape, stride, storage_offset)
+
+
 def _create_arg_from_info(arg_info):
     """
     Recursively construct a kernel argument from its JSON schema.
@@ -150,121 +331,7 @@ def _create_arg_from_info(arg_info):
         return arg_info.get("value")
 
     elif arg_type == "tensor":
-        if arg_info.get("blob_path"):
-            return load_tensor(arg_info.get("blob_path"), arg_info.get("device"))
-
-        # Extract basic tensor properties
-        dtype_str = arg_info.get("dtype")
-        try:
-            torch_dtype = getattr(torch, dtype_str.split(".")[-1])
-        except AttributeError:
-            logging.error(f"Unsupported dtype: {dtype_str}. Defaulting to float32.")
-            torch_dtype = torch.float32
-
-        shape = arg_info.get("shape", [])
-        device = arg_info.get("device", "cpu")
-
-        # Extract statistical information if available
-        mean = arg_info.get("mean")
-        std = arg_info.get("std")
-        min_val = arg_info.get("min")
-        max_val = arg_info.get("max")
-        has_stats = (
-            mean is not None
-            and std is not None
-            and min_val is not None
-            and max_val is not None
-        )
-
-        if arg_info.get("tensor_capture_error", False):
-            logging.error(
-                f"Error: Tensor '{arg_info.get('name', '')}' had capture error. Generating random tensor instead."
-            )
-
-        # Use a dummy tensor to check properties of the dtype
-        tensor_props = torch.empty(0, dtype=torch_dtype)
-
-        # Case 1: Floating point types
-        if tensor_props.is_floating_point():
-            if has_stats:
-                # Generate tensor with statistical properties matching original data
-                if std == 0 or min_val == max_val:
-                    # Constant tensor
-                    return torch.full(shape, mean, dtype=torch_dtype, device=device)
-                # Generate normal distribution with mean and std, then clamp to [min, max]
-                tensor = (
-                    torch.randn(shape, dtype=torch.float32, device=device) * std + mean
-                )
-                tensor = torch.clamp(tensor, min=min_val, max=max_val)
-                return tensor.to(torch_dtype)
-            else:
-                # Fallback to original random generation
-                if torch_dtype in [torch.float8_e4m3fn, torch.float8_e5m2]:
-                    tmp = torch.rand(shape, dtype=torch.float32, device=device)
-                    return tmp.to(torch_dtype)
-                else:
-                    return torch.empty(
-                        shape, dtype=torch_dtype, device=device
-                    ).random_()
-
-        # Case 2: Integer types
-        elif torch_dtype in [
-            torch.int8,
-            torch.int16,
-            torch.int32,
-            torch.int64,
-            torch.uint8,
-            torch.bool,
-        ]:
-            if has_stats and torch_dtype != torch.bool:
-                # Generate tensor with statistical properties, then round for integers
-                if std == 0 or min_val == max_val:
-                    # Constant tensor
-                    return torch.full(
-                        shape, int(mean), dtype=torch_dtype, device=device
-                    )
-                tensor = (
-                    torch.randn(shape, dtype=torch.float32, device=device) * std + mean
-                )
-                tensor = torch.clamp(tensor, min=min_val, max=max_val)
-                return torch.round(tensor).to(torch_dtype)
-            else:
-                # Fallback to original random generation
-                return torch.empty(shape, dtype=torch_dtype, device=device).random_()
-
-        # Case 3: Complex numbers need special handling
-        elif tensor_props.is_complex():
-            # Complex types: fallback to original logic for now
-            # TODO: Could be improved to use statistical info if available
-            float_dtype = (
-                torch.float32 if torch_dtype == torch.complex64 else torch.float64
-            )
-            real_part = torch.rand(shape, dtype=float_dtype, device=device)
-            imag_part = torch.rand(shape, dtype=float_dtype, device=device)
-            return torch.complex(real_part, imag_part)
-
-        # Case 4: Handle other unsigned integers (like uint32) which fail with random_()
-        elif "uint" in str(torch_dtype):
-            if has_stats:
-                # Generate tensor with statistical properties for unsigned integers
-                if std == 0 or min_val == max_val:
-                    return torch.full(
-                        shape, int(mean), dtype=torch_dtype, device=device
-                    )
-                tensor = (
-                    torch.randn(shape, dtype=torch.float32, device=device) * std + mean
-                )
-                tensor = torch.clamp(tensor, min=min_val, max=max_val)
-                return torch.round(tensor).to(torch_dtype)
-            else:
-                # Fallback to original random generation
-                return torch.randint(0, 1000, shape, dtype=torch_dtype, device=device)
-
-        # Case 5: If we don't know how to handle the type, raise an error
-        else:
-            raise NotImplementedError(
-                f"Random data generation not implemented for dtype: {torch_dtype}"
-            )
+        return _create_tensor(arg_info)
 
     elif arg_type == "triton_kernels.tensor.Tensor":
         if not TRITON_KERNELS_CUSTOM_TYPES:

tritonparse/structured_logging.py

@@ -3,6 +3,7 @@
 import atexit
 import fnmatch
 import gzip
+import hashlib
 import importlib
 import inspect
 import io
@@ -11,6 +12,7 @@ import logging
 import math
 import os
 import subprocess
+import tempfile
 from collections import defaultdict
 from collections.abc import Mapping
 from dataclasses import asdict, is_dataclass
@@ -62,8 +64,31 @@ TRITONPARSE_DUMP_SASS = os.getenv("TRITONPARSE_DUMP_SASS", None) in [
 
 # The flag to mark if launch is traced. It is used to avoid initilizing the launch hook twice.
 _trace_launch_enabled = False
+# Enable tensor blob storage
+TRITONPARSE_SAVE_TENSOR_BLOBS = os.getenv("TRITONPARSE_SAVE_TENSOR_BLOBS", "0") in [
+    "1",
+    "true",
+    "True",
+]
+# Tensor size limit in bytes (default 10GB)
+TRITONPARSE_TENSOR_SIZE_LIMIT = int(
+    os.getenv("TRITONPARSE_TENSOR_SIZE_LIMIT", str(10 * 1024 * 1024 * 1024))
+)
+# Tensor storage quota in bytes (default 100GB) - tracks compressed size for current run
+TRITONPARSE_TENSOR_STORAGE_QUOTA = int(
+    os.getenv("TRITONPARSE_TENSOR_STORAGE_QUOTA", str(100 * 1024 * 1024 * 1024))
+)
+# Compression threshold in bytes (default 1MB) - only compress blobs >= this size
+TRITONPARSE_COMPRESSION_THRESHOLD = 1 * 1024 * 1024
+# Compression level for gzip (0-9, higher = better compression but slower)
+TRITONPARSE_COMPRESSION_LEVEL = 4
+# Log statistics every N saved blobs
+TRITONPARSE_STATS_LOG_FREQUENCY = 100
 
 TRITON_TRACE_HANDLER = None
+# Global tensor blob manager instance
+TENSOR_BLOB_MANAGER = None
+
 if importlib.util.find_spec("torch") is not None:
     TORCH_INSTALLED = True
     import torch
@@ -72,6 +97,267 @@ else:
     TORCH_INSTALLED = False
 
 
+class TensorBlobManager:
+    """
+    Manager for storing tensor data as content-addressed blobs.
+
+    Uses BLAKE2b hashing for content addressing and stores blobs in a two-level
+    directory structure to avoid filesystem limitations with large numbers of files.
+    """
+
+    def __init__(
+        self,
+        root_dir: Optional[str] = None,
+        storage_quota: Optional[int] = None,
+    ):
+        self.root_dir = None
+        self.hash_to_path_cache = {}  # In-memory cache for hash -> path mapping
+        self.compression_threshold = TRITONPARSE_COMPRESSION_THRESHOLD
+        self.storage_quota = (
+            storage_quota
+            if storage_quota is not None
+            else TRITONPARSE_TENSOR_STORAGE_QUOTA
+        )
+
+        # Resource statistics (tracks current run only)
+        self.total_compressed_bytes = 0  # Total compressed size written in this run
+        self.total_uncompressed_bytes = (
+            0  # Total uncompressed size (for compression ratio)
+        )
+        self.blob_count = 0  # Total blob references (including dedup hits)
+        self.blob_saved_count = 0  # Actual blobs saved (excluding dedup hits)
+        self.storage_disabled = False  # Whether storage has been disabled due to quota
+        self.storage_disabled_reason = None  # Reason for disabling storage
+
+        if root_dir:
+            self.set_root_dir(root_dir)
+
+    def set_root_dir(self, root_dir: str):
+        """Set the root directory for blob storage."""
+        self.root_dir = Path(root_dir) / "saved_tensors"
+        self.root_dir.mkdir(parents=True, exist_ok=True)
+        log.debug(f"TensorBlobManager: using root directory {self.root_dir}")
+
+    def _compute_hash(self, data: bytes) -> str:
+        """Compute BLAKE2b hash of the data."""
+        return hashlib.blake2b(data).hexdigest()
+
+    def _get_blob_path(self, hash_hex: str, extension: str = ".bin.gz") -> Path:
+        """Get the file path for a given hash using two-level directory structure."""
+        if not self.root_dir:
+            raise ValueError("Root directory not set")
+
+        # Two-level directory: first 2 chars / full_hash{extension}
+        subdir = hash_hex[:2]
+        filename = f"{hash_hex}{extension}"
+        return (self.root_dir / subdir / filename).resolve()
+
+    def _get_tensor_size_bytes(self, tensor) -> int:
+        """Get tensor size in bytes before serialization."""
+        if hasattr(tensor, "numel") and hasattr(tensor, "element_size"):
+            return tensor.numel() * tensor.element_size()
+        return 0
+
+    def _log_statistics(self, final: bool = False):
+        """Print statistics about tensor blob storage.
+
+        Args:
+            final: If True, this is the final statistics message (e.g., when storage is disabled)
+        """
+        prefix = "📊 Final" if final else "📊"
+        compression_ratio = (
+            self.total_uncompressed_bytes / max(1, self.total_compressed_bytes)
+            if self.total_compressed_bytes > 0
+            else 0.0
+        )
+        dedup_count = self.blob_count - self.blob_saved_count
+
+        log.info(
+            f"{prefix} Tensor blob stats: "
+            f"{self.blob_saved_count} saved ({self.blob_count} total, {dedup_count} dedup), "
+            f"{self.total_compressed_bytes / 1024**3:.2f}GB compressed "
+            f"({self.total_uncompressed_bytes / 1024**3:.2f}GB uncompressed), "
+            f"compression ratio: {compression_ratio:.2f}x"
+        )
+
+    def _disable_storage(self, reason: str):
+        """Disable blob storage and log warning with statistics.
+
+        Args:
+            reason: The reason why storage is being disabled
+        """
+        if not self.storage_disabled:  # Only disable once
+            self.storage_disabled = True
+            self.storage_disabled_reason = reason
+            log.warning(f"⚠️  TENSOR BLOB STORAGE DISABLED: {reason}")
+            self._log_statistics(final=True)
+
+    def save_tensor_blob(self, tensor) -> Dict[str, Any]:
+        """
+        Save tensor as a blob and return metadata.
+
+        Args:
+            tensor: PyTorch tensor to save
+
+        Returns:
+            Dictionary with blob metadata or error information:
+            - Success: {'tensor_hash': str, 'blob_path': str, 'blob_size': int,
+                       'blob_size_uncompressed': int, 'compression': str,
+                       'compression_ratio': float, 'serialization_method': str}
+            - Dedup hit: Same as success but from cache (not counted in quota)
+            - Error: {'error': str, 'tensor_hash': None}
+        """
+        # Early exit: Check if storage is disabled
+        if self.storage_disabled:
+            return {"error": self.storage_disabled_reason, "tensor_hash": None}
+
+        # Early exit: Check if root directory is set
+        if not self.root_dir:
+            return {"error": "Blob storage not initialized", "tensor_hash": None}
+
+        try:
+            # Check tensor size before serialization
+            tensor_size = self._get_tensor_size_bytes(tensor)
+            if tensor_size > TRITONPARSE_TENSOR_SIZE_LIMIT:
+                log.warning(
+                    f"Tensor size {tensor_size} bytes exceeds limit {TRITONPARSE_TENSOR_SIZE_LIMIT} bytes, skipping blob storage"
+                )
+                return {
+                    "error": f"Tensor size {tensor_size} bytes exceeds limit {TRITONPARSE_TENSOR_SIZE_LIMIT} bytes",
+                    "tensor_hash": None,
+                }
+
+            # Serialize tensor using torch.save
+            import io
+
+            buffer = io.BytesIO()
+            if TORCH_INSTALLED:
+                torch.save(tensor.cpu(), buffer)
+            else:
+                return {
+                    "error": "PyTorch not available for tensor serialization",
+                    "tensor_hash": None,
+                }
+
+            blob_data = buffer.getvalue()
+            uncompressed_size = len(blob_data)
+
+            # Compute hash on uncompressed data for content addressing
+            hash_hex = self._compute_hash(blob_data)
+
+            # Check for deduplication (before compression to save work)
+            if hash_hex in self.hash_to_path_cache:
+                blob_path = self.hash_to_path_cache[hash_hex]
+                try:
+                    # Try to access the file - handles race condition where file might be deleted
+                    disk_size = blob_path.stat().st_size
+                    compression = (
+                        "gzip" if str(blob_path).endswith(".bin.gz") else "none"
+                    )
+                    compression_ratio = uncompressed_size / max(1, disk_size)
+
+                    # Deduplication hit - increment count but don't add to quota
+                    self.blob_count += 1
+
+                    return {
+                        "tensor_hash": hash_hex,
+                        "blob_path": str(blob_path),
+                        "blob_size": disk_size,
+                        "blob_size_uncompressed": uncompressed_size,
+                        "compression": compression,
+                        "compression_ratio": compression_ratio,
+                        "serialization_method": "torch_save",
+                        "deduplicated": True,
+                    }
+                except (FileNotFoundError, OSError):
+                    # File was deleted or inaccessible - remove from cache and continue to save
+                    log.debug(
+                        f"Cached blob file no longer exists: {blob_path}, will re-save"
+                    )
+                    self.hash_to_path_cache.pop(hash_hex, None)
+
+            # Decide whether to compress based on size threshold
+            if uncompressed_size >= self.compression_threshold:
+                # Compress the data
+                data_to_write = gzip.compress(
+                    blob_data, compresslevel=TRITONPARSE_COMPRESSION_LEVEL
+                )
+                file_extension = ".bin.gz"
+                compression = "gzip"
+            else:
+                # Don't compress small files (overhead not worth it)
+                data_to_write = blob_data
+                file_extension = ".bin"
+                compression = "none"
+
+            disk_size = len(data_to_write)
+
+            # Check quota BEFORE writing
+            if self.total_compressed_bytes + disk_size > self.storage_quota:
+                self._disable_storage(
+                    f"Storage quota would be exceeded: "
+                    f"{(self.total_compressed_bytes + disk_size) / 1024**3:.2f}GB > "
+                    f"{self.storage_quota / 1024**3:.2f}GB limit"
+                )
+                return {"error": self.storage_disabled_reason, "tensor_hash": None}
+
+            # Create blob file path with appropriate extension
+            blob_path = self._get_blob_path(hash_hex, extension=file_extension)
+            blob_path.parent.mkdir(parents=True, exist_ok=True)
+
+            # Atomic write using temporary file + rename
+            with tempfile.NamedTemporaryFile(
+                mode="wb",
+                dir=blob_path.parent,
+                prefix=f".tmp_{hash_hex}_",
+                delete=False,
+            ) as tmp_file:
+                tmp_file.write(data_to_write)
+                tmp_path = Path(tmp_file.name)
+
+            # Atomic rename
+            tmp_path.rename(blob_path)
+
+            # Update cache and statistics
+            self.hash_to_path_cache[hash_hex] = blob_path
+            self.total_compressed_bytes += disk_size
+            self.total_uncompressed_bytes += uncompressed_size
+            self.blob_count += 1
+            self.blob_saved_count += 1
+
+            # Log progress periodically
+            if self.blob_saved_count % TRITONPARSE_STATS_LOG_FREQUENCY == 0:
+                self._log_statistics()
+
+            log.debug(
+                f"Saved tensor blob: {hash_hex} -> {blob_path} ({disk_size} bytes, compression={compression})"
+            )
+
+            compression_ratio = uncompressed_size / max(1, disk_size)
+
+            return {
+                "tensor_hash": hash_hex,
+                "blob_path": str(blob_path),
+                "blob_size": disk_size,
+                "blob_size_uncompressed": uncompressed_size,
+                "compression": compression,
+                "compression_ratio": compression_ratio,
+                "serialization_method": "torch_save",
+            }
+
+        except OSError as e:
+            # Disk full, permission errors, etc. - disable storage to avoid repeated failures
+            error_msg = f"Failed to save tensor blob (I/O error): {str(e)}"
+            log.error(error_msg)
+            self._disable_storage(error_msg)
+            return {"error": error_msg, "tensor_hash": None}
+        except Exception as e:
+            # Other unexpected errors - log but don't disable storage
+            error_msg = f"Failed to save tensor blob: {str(e)}"
+            log.error(error_msg)
+            return {"error": error_msg, "tensor_hash": None}
+
+
 class TritonLogRecord(logging.LogRecord):
     """
     Custom LogRecord class for structured logging of Triton operations.
@@ -283,6 +569,11 @@ def _log_torch_tensor_info(tensor_value):
         except (RuntimeError, ValueError, TypeError) as e:
             log.error(f"Unable to compute tensor statistics: {e}")
             arg_info["tensor_capture_error"] = str(e)
+
+    # Add tensor blob storage if enabled
+    if TRITONPARSE_SAVE_TENSOR_BLOBS and TENSOR_BLOB_MANAGER is not None:
+        blob_info = TENSOR_BLOB_MANAGER.save_tensor_blob(tensor_value)
+        arg_info.update(blob_info)
     return arg_info
 
 
@@ -726,7 +1017,7 @@ def init_logs():
            DEBUG:tritonparse_trace:
        lines by blocking propagation to the root logger.
     """
-    global TRITON_TRACE_HANDLER, triton_trace_folder
+    global TRITON_TRACE_HANDLER, triton_trace_folder, TENSOR_BLOB_MANAGER
 
     # Basic logger settings (safe to run on every call)
     triton_trace_log.setLevel(logging.DEBUG)
@@ -752,6 +1043,16 @@ def init_logs():
         TRITON_TRACE_HANDLER.setFormatter(TritonJsonFormatter())
         triton_trace_log.addHandler(TRITON_TRACE_HANDLER)
 
+    # Initialize tensor blob manager if enabled
+    if TRITONPARSE_SAVE_TENSOR_BLOBS and root_dir:
+        if TENSOR_BLOB_MANAGER is None:
+            TENSOR_BLOB_MANAGER = TensorBlobManager(
+                root_dir=root_dir, storage_quota=TRITONPARSE_TENSOR_STORAGE_QUOTA
+            )
+        elif TENSOR_BLOB_MANAGER.root_dir is None:
+            # Update root_dir if it wasn't set during initialization
+            TENSOR_BLOB_MANAGER.set_root_dir(root_dir)
+
 
 def trace_structured_triton(
     name: str,
@@ -1153,6 +1454,8 @@ def init(
     enable_trace_launch: bool = False,
     enable_more_tensor_information: bool = False,
     enable_sass_dump: Optional[bool] = False,
+    enable_tensor_blob_storage: bool = False,
+    tensor_storage_quota: Optional[int] = None,
 ):
     """
     This function is a wrapper around init_basic() that also sets up the compilation listener. Its arguments have higher priority than the environment variables for same settings.
@@ -1163,9 +1466,14 @@ def init(
         enable_more_tensor_information (bool): Whether to enable more tensor information logging.
             It only works when enable_trace_launch/TRITON_TRACE_LAUNCH is True.
         enable_sass_dump (Optional[bool]): Whether to enable SASS dumping.
+        enable_tensor_blob_storage (bool): Whether to enable tensor blob storage.
+        tensor_storage_quota (Optional[int]): Storage quota in bytes for tensor blobs (default: 100GB).
     """
     global TRITON_TRACE_LAUNCH, TRITONPARSE_MORE_TENSOR_INFORMATION
     global TORCHINDUCTOR_RUN_JIT_POST_COMPILE_HOOK, TRITONPARSE_DUMP_SASS
+    global TRITONPARSE_SAVE_TENSOR_BLOBS, TRITONPARSE_TENSOR_STORAGE_QUOTA
+
+    # Set global flags BEFORE calling init_basic, so init_logs() can see them
     if enable_trace_launch:
         TRITON_TRACE_LAUNCH = True
         TORCHINDUCTOR_RUN_JIT_POST_COMPILE_HOOK = True
@@ -1173,6 +1481,12 @@ def init(
         TRITONPARSE_MORE_TENSOR_INFORMATION = True
     if enable_sass_dump:
         TRITONPARSE_DUMP_SASS = True
+    if enable_tensor_blob_storage:
+        TRITONPARSE_SAVE_TENSOR_BLOBS = True
+
+    # Set the quota in global var for TensorBlobManager creation in init_logs()
+    if tensor_storage_quota is not None:
+        TRITONPARSE_TENSOR_STORAGE_QUOTA = tensor_storage_quota
 
     init_basic(trace_folder)
     from triton import knobs
@@ -1202,7 +1516,7 @@ def clear_logging_config():
     """
     global TRITON_TRACE_HANDLER, triton_trace_folder, _KERNEL_ALLOWLIST_PATTERNS
     global _trace_launch_enabled
-
+    global TENSOR_BLOB_MANAGER
     # 1. Clean up the log handler
     if TRITON_TRACE_HANDLER is not None:
         if TRITON_TRACE_HANDLER in triton_trace_log.handlers:
@@ -1215,7 +1529,10 @@ def clear_logging_config():
     _KERNEL_ALLOWLIST_PATTERNS = None
     _trace_launch_enabled = False
 
-    # 3. Reset Triton knobs
+    # 3. Reset tensor blob manager and related flags
+    TENSOR_BLOB_MANAGER = None
+
+    # 4. Reset Triton knobs
     # Check if triton was actually imported and used
     from triton import knobs
 

tritonparse/tools/load_tensor.py

@@ -6,19 +6,23 @@ import tritonparse.tools.load_tensor as load_tensor
 tensor = load_tensor.load_tensor(tensor_file_path, device)
 """
 
+import gzip
 import hashlib
+import io
 from pathlib import Path
+from typing import Union
 
 import torch
 
 
-def load_tensor(tensor_file_path: str, device: str = None) -> torch.Tensor:
+def load_tensor(tensor_file_path: Union[str, Path], device: str = None) -> torch.Tensor:
     """
     Load a tensor from its file path and verify its integrity using the hash in the filename.
 
     Args:
-        tensor_file_path (str): Direct path to the tensor .bin file. The filename should be
-                               the hash of the file contents followed by .bin extension.
+        tensor_file_path (str | Path): Direct path to the tensor file. Supports both:
+                               - .bin.gz: gzip-compressed tensor (hash is of uncompressed data)
+                               - .bin: uncompressed tensor (for backward compatibility)
         device (str, optional): Device to load the tensor to (e.g., 'cuda:0', 'cpu').
                                If None, keeps the tensor on its original device.
 
@@ -35,13 +39,26 @@ def load_tensor(tensor_file_path: str, device: str = None) -> torch.Tensor:
     if not blob_path.exists():
         raise FileNotFoundError(f"Tensor blob not found: {blob_path}")
 
-    # Extract expected hash from filename (remove .bin extension)
-    expected_hash = blob_path.stem
+    # Detect compression by file extension
+    is_compressed = blob_path.name.endswith(".bin.gz")
 
-    # Compute actual hash of file contents
-    with open(blob_path, "rb") as f:
-        file_contents = f.read()
-        computed_hash = hashlib.blake2b(file_contents).hexdigest()
+    # Read file contents (decompress if needed)
+    try:
+        with open(blob_path, "rb") as f:
+            file_obj = gzip.GzipFile(fileobj=f, mode="rb") if is_compressed else f
+            file_contents = file_obj.read()
+    except (OSError, gzip.BadGzipFile) as e:
+        if is_compressed:
+            raise RuntimeError(f"Failed to decompress gzip file {blob_path}: {str(e)}")
+        else:
+            raise RuntimeError(f"Failed to read file {blob_path}: {str(e)}")
+
+    # Extract expected hash from filename
+    # abc123.bin.gz -> abc123 or abc123.bin -> abc123
+    expected_hash = blob_path.name.removesuffix(".bin.gz" if is_compressed else ".bin")
+
+    # Compute hash of uncompressed data
+    computed_hash = hashlib.blake2b(file_contents).hexdigest()
 
     # Verify hash matches filename
     if computed_hash != expected_hash:
@@ -50,9 +67,8 @@ def load_tensor(tensor_file_path: str, device: str = None) -> torch.Tensor:
         )
 
     try:
-        # Load the tensor using torch.load (tensors are saved with torch.save)
-        # If device is None, keep tensor on its original device, otherwise move to specified device
-        tensor = torch.load(blob_path, map_location=device)
+        # Load the tensor from memory buffer
+        tensor = torch.load(io.BytesIO(file_contents), map_location=device)
         return tensor
     except Exception as e:
         raise RuntimeError(f"Failed to load tensor from {blob_path}: {str(e)}")

{tritonparse-0.2.4.dev20251006071528.dist-info → tritonparse-0.2.4.dev20251008071501.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tritonparse
-Version: 0.2.4.dev20251006071528
+Version: 0.2.4.dev20251008071501
 Summary: TritonParse: A Compiler Tracer, Visualizer, and mini-Reproducer Generator for Triton Kernels
 Author-email: Yueming Hao <yhao@meta.com>
 License-Expression: BSD-3-Clause
@@ -27,13 +27,22 @@ Dynamic: license-file
 
 ## ✨ Key Features
 
-- **🚀 Launch Difference Analysis** - Automatically detect and visualize variations in kernel launch parameters, helping you pinpoint performance bottlenecks and debug launch configurations.
-- **🔍 Interactive Visualization** - Explore Triton kernels with detailed metadata and stack traces
-- **📊 Multi-format IR Support** - View TTGIR, TTIR, LLIR, PTX, and AMDGCN in one place
-- **🔄 Side-by-side Comparison** - Compare IR stages with synchronized highlighting
-- **📝 Structured Logging** - Capture detailed compilation and launch events with source mapping
-- **🌐 Ready-to-use Interface** - No installation required, works in your browser
-- **🔒 Privacy-first** - All processing happens locally in your browser, no data uploaded
+### 🔍 Visualization & Analysis
+- **🚀 Launch Difference Analysis** - Detect and visualize kernel launch parameter variations
+- **📊 IR Code View** - Side-by-side IR viewing with synchronized highlighting and line mapping
+- **🔄 File Diff View** - Compare kernels across different trace files side-by-side
+- **📝 Multi-format IR Support** - View TTGIR, TTIR, LLIR, PTX, and AMDGCN
+- **🎯 Interactive Code Views** - Click-to-highlight corresponding lines across IR stages
+
+### 📊 Structured Logging & Analysis
+- **📝 Compilation & Launch Tracing** - Capture detailed events with source mapping
+- **🔍 Stack Trace Integration** - Full Python stack traces for debugging
+- **📈 Metadata Extraction** - Comprehensive kernel statistics
+
+### 🛠️ Developer Tools
+- **🔧 Reproducer Generation** - Generate standalone Python scripts to reproduce kernels
+- **🌐 Browser-based Interface** - No installation required, works in your browser
+- **🔒 Privacy-first** - All processing happens locally, no data uploaded
 
 ## 🚀 Quick Start
 
@@ -41,22 +50,22 @@ Dynamic: license-file
 
 ```python
 import tritonparse.structured_logging
+import tritonparse.utils
 
-# Initialize logging with launch tracing enabled
+# Initialize logging
 tritonparse.structured_logging.init("./logs/", enable_trace_launch=True)
 
 # Your Triton/PyTorch code here
 # ... your kernels ...
 
 # Parse and generate trace files
-import tritonparse.utils
-tritonparse.utils.unified_parse("./logs/")
+tritonparse.utils.unified_parse("./logs/", out="./parsed_output")
 ```
-The example terminal output is:
-```bash
-tritonparse log file list: /tmp/tmp1gan7zky/log_file_list.json
-INFO:tritonparse:Copying parsed logs from /tmp/tmp1gan7zky to /scratch/findhao/tritonparse/tests/parsed_output
 
+<details>
+<summary>📝 Example output (click to expand)</summary>
+
+```bash
 ================================================================================
 📁 TRITONPARSE PARSING RESULTS
 ================================================================================
@@ -64,13 +73,13 @@ INFO:tritonparse:Copying parsed logs from /tmp/tmp1gan7zky to /scratch/findhao/t
 📊 Total files generated: 2
 
 📄 Generated files:
---------------------------------------------------
    1. 📝 dedicated_log_triton_trace_findhao__mapped.ndjson.gz (7.2KB)
    2. 📝 log_file_list.json (181B)
 ================================================================================
 ✅ Parsing completed successfully!
 ================================================================================
 ```
+</details>
 
 ### 2. Visualize Results
 
@@ -106,18 +115,13 @@ pip install triton
 
 | 📖 Guide | Description |
 |----------|-------------|
-| **[🏠 Wiki Home](https://github.com/meta-pytorch/tritonparse/wiki)** | Complete documentation and navigation |
-| **[📦 Installation Guide](https://github.com/meta-pytorch/tritonparse/wiki/01.-Installation)** | Detailed setup for all scenarios |
-| **[📋 Usage Guide](https://github.com/meta-pytorch/tritonparse/wiki/02.-Usage-Guide)** | Complete workflow and examples |
-| **[🌐 Web Interface Guide](https://github.com/meta-pytorch/tritonparse/wiki/03.-Web-Interface-Guide)** | Master the visualization interface |
-| **[🔧 Developer Guide](https://github.com/meta-pytorch/tritonparse/wiki/04.-Developer-Guide)** | Contributing and development setup |
-| **[❓ FAQ](https://github.com/meta-pytorch/tritonparse/wiki/06.-FAQ)** | Frequently asked questions |
-
-## 🛠️ Tech Stack
-
-- **Frontend**: React 19, TypeScript, Vite, Tailwind CSS, Monaco Editor
-- **Backend**: Python with Triton integration, structured logging
-- **Deployment**: GitHub Pages, automatic deployment
+| **[🏠 Wiki Home](https://github.com/meta-pytorch/tritonparse/wiki)** | Complete documentation and quick navigation |
+| **[📦 Installation](https://github.com/meta-pytorch/tritonparse/wiki/01.-Installation)** | Setup guide for all scenarios |
+| **[📋 Usage Guide](https://github.com/meta-pytorch/tritonparse/wiki/02.-Usage-Guide)** | Complete workflow, examples, and reproducer |
+| **[🌐 Web Interface](https://github.com/meta-pytorch/tritonparse/wiki/03.-Web-Interface-Guide)** | Master the visualization interface |
+| **[🔧 Developer Guide](https://github.com/meta-pytorch/tritonparse/wiki/04.-Developer-Guide)** | Contributing and architecture overview |
+| **[📝 Code Formatting](https://github.com/meta-pytorch/tritonparse/wiki/05.-Code-Formatting)** | Formatting standards and tools |
+| **[❓ FAQ](https://github.com/meta-pytorch/tritonparse/wiki/06.-FAQ)** | Quick answers and troubleshooting |
 
 ## 📊 Understanding Triton Compilation
 
@@ -130,9 +134,10 @@ Each stage can be inspected and compared to understand optimization transformati
 ## 🤝 Contributing
 
 We welcome contributions! Please see our **[Developer Guide](https://github.com/meta-pytorch/tritonparse/wiki/04.-Developer-Guide)** for:
-- Development setup
-- Code formatting standards
-- Pull request process
+- Development setup and prerequisites
+- Code formatting standards (**[Formatting Guide](https://github.com/meta-pytorch/tritonparse/wiki/05.-Code-Formatting)**)
+- Pull request and code review process
+- Testing guidelines
 - Architecture overview
 
 ## 📞 Support & Community

{tritonparse-0.2.4.dev20251006071528.dist-info → tritonparse-0.2.4.dev20251008071501.dist-info}/RECORD

@@ -1,7 +1,8 @@
 tritonparse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tritonparse/__main__.py,sha256=YDBolsfpyAINExxCt7CDhHFno6nzEceE9Hzr3BUs6Hg,62
+tritonparse/__main__.py,sha256=wu5N2wk8mvBgyvr2ghmQf4prezAe0_i-p123VVreyYc,62
+tritonparse/cli.py,sha256=ODfLvbMrrRm5JX6-3XDCu9f59gkJ00sg0R_uzNoVNgw,2471
 tritonparse/common.py,sha256=9coQbzpyHWAAdv6lx2YQTualiIH49ULJuZTA7VB_V7A,13946
-tritonparse/context_manager.py,sha256=M-zRZX8PX8onqBdDeIJ37VGVXmKZ_dFMC6eeZQchyNw,1583
+tritonparse/context_manager.py,sha256=MqAWI8uD1uCeCbmkcEWPejc5_IeY---BdajhsSR9T_E,2221
 tritonparse/event_diff.py,sha256=yOD6uNxLJroatfx2nEGr-erw24ObOrHU9P6V5pzr8do,4907
 tritonparse/extract_source_mappings.py,sha256=Z6UxFj2cCE5NCWLQTYPKqUpLfbYhqP8xgCl5mvud9KI,1451
 tritonparse/ir_parser.py,sha256=1j1tP9jpUN7wH3e01bKUkUPgTMlNXUdp8LKRCC-WTro,9324
@@ -9,7 +10,7 @@ tritonparse/mapper.py,sha256=prrczfi13P7Aa042OrEBsmRF1HW3jDhwxicANgPkWIM,4150
 tritonparse/shared_vars.py,sha256=fCAW24mx9nENYoNbTy-tZjiN5-w6oGTO_av-Pw1J1TY,653
 tritonparse/source_type.py,sha256=nmYEQS8rfkIN9BhNhQbkmEvKnvS-3zAxRGLY4TaZdi8,1676
 tritonparse/sourcemap_utils.py,sha256=qsQmTDuEe9yuUVyxSHRbjTR38gi0hvJEijnPkrJVAV4,2037
-tritonparse/structured_logging.py,sha256=y5FKi3mA-iR4SyzCUOfxlZnDpqRhCQC2rKFh2Nrb3kE,46869
+tritonparse/structured_logging.py,sha256=L1xkkCx8Jr9YQbM0Kgtf2g6L3aWMkYOEeFFEOSo8Lkk,60306
 tritonparse/tp_logger.py,sha256=vXzY7hMDmVnRBGBhIjFZe3nHZzG5NKKPONGUszJhGgU,242
 tritonparse/trace_processor.py,sha256=brQBt26jdB6-quJXP5-warp2j31JSjOOFJa5ayiUZ5k,12963
 tritonparse/utils.py,sha256=Jnlptcd79llSDev-_1XyyOnv2izUqv0PEL74A8GF2tc,4565
@@ -20,18 +21,18 @@ tritonparse/reproducer/placeholder_replacer.py,sha256=x9ddhIXVcYoEf6mBpByECPdZeA
 tritonparse/reproducer/utils.py,sha256=UTclw48vH49g6Z2ljJL5DOZ6Rl4UDudyr0PeUySa3p8,13857
 tritonparse/reproducer/ingestion/ndjson.py,sha256=pEujTl5xXW2E2DEW8ngxXQ8qP9oawb90wBVTWHDs1jk,7372
 tritonparse/reproducer/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tritonparse/reproducer/templates/example.py,sha256=bN75A6sDu9eG7-gePj_VAG5YINVh47rtu8neGp9kV_g,11838
+tritonparse/reproducer/templates/example.py,sha256=gOYKKKptvzyI4mq4eUygi1NrIEQkChm4d1bJXed1w5U,13904
 tritonparse/reproducer/templates/loader.py,sha256=HqjfThdDVg7q2bYWry78sIaVRkUpkcA8KQDt83YrlVE,1920
 tritonparse/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tritonparse/tools/decompress_bin_ndjson.py,sha256=kpt7DM_sSA334F1X45xdkP2OR9LuB27Pc50EkGr6CPM,4144
 tritonparse/tools/disasm.py,sha256=c4HmNNoPPeXPQBQkPVcMaHwDHbHNZNxuqXn4UIIs1Z0,2434
 tritonparse/tools/format_fix.py,sha256=Ol0Sjui8D7OzHwbamAfGnq8V5Y63uwNaFTKSORN5HkQ,3867
-tritonparse/tools/load_tensor.py,sha256=tfdmNVd9gsZqO6msQBhbXIhOvUzgc83yF64k2GDWPNk,2122
+tritonparse/tools/load_tensor.py,sha256=94-TiSYlpXJx4MPmGK1ovmZlTt56Q_B3KQeCPaA6Cnw,2734
 tritonparse/tools/prettify_ndjson.py,sha256=r2YlHwFDTHgML7KljRmMsHaDg29q8gOQAgyDKWJhxRM,11062
 tritonparse/tools/readme.md,sha256=w6PWYfYnRgoPArLjxG9rVrpcLUkoVMGuRlbpF-o0IQM,110
-tritonparse-0.2.4.dev20251006071528.dist-info/licenses/LICENSE,sha256=4ZciugpyN7wcM4L-9pyDh_etvMUeIfBhDTyH1zeZlQM,1515
-tritonparse-0.2.4.dev20251006071528.dist-info/METADATA,sha256=kahkkaHP-X648az1B_nNVaN2Ns0WH58s17FghtgLkgk,6580
-tritonparse-0.2.4.dev20251006071528.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tritonparse-0.2.4.dev20251006071528.dist-info/entry_points.txt,sha256=7P8TuH_nMXcPl1r8udA96SW8ccvAznZqTpCWLWDnV2o,53
-tritonparse-0.2.4.dev20251006071528.dist-info/top_level.txt,sha256=ITcTKgp3vf_bXV9vixuQU9IrZa3L1EfDSZwvRzRaoJU,12
-tritonparse-0.2.4.dev20251006071528.dist-info/RECORD,,
+tritonparse-0.2.4.dev20251008071501.dist-info/licenses/LICENSE,sha256=4ZciugpyN7wcM4L-9pyDh_etvMUeIfBhDTyH1zeZlQM,1515
+tritonparse-0.2.4.dev20251008071501.dist-info/METADATA,sha256=X2CK43nr0PhdprpuK3wPsCqtJbqfJwxkbDHafqKq1ec,6766
+tritonparse-0.2.4.dev20251008071501.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tritonparse-0.2.4.dev20251008071501.dist-info/entry_points.txt,sha256=wEXdaieDoRRCCdhEv2p_C68iytnaXU_2pwt5CqjfbWY,56
+tritonparse-0.2.4.dev20251008071501.dist-info/top_level.txt,sha256=ITcTKgp3vf_bXV9vixuQU9IrZa3L1EfDSZwvRzRaoJU,12
+tritonparse-0.2.4.dev20251008071501.dist-info/RECORD,,

tritonparse-0.2.4.dev20251008071501.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tritonparseoss = tritonparse.cli:main

tritonparse-0.2.4.dev20251006071528.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-tritonparse = tritonparse.run:main