trench-mark 1.0.0__tar.gz

trench_mark-1.0.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: trench-mark
+Version: 1.0.0
+Summary: Automated TensorRT performance profiling for Jetson edge devices.
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: pyyaml

trench_mark-1.0.0/pyproject.toml

@@ -0,0 +1,17 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "trench-mark"
+version = "1.0.0"
+description = "Automated TensorRT performance profiling for Jetson edge devices."
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = [
+    "pyyaml",
+]
+
+[project.scripts]
+# Terminal Command = "python_folder_name.file_name:function_name"
+trench-mark = "trench_mark.cli:main"

trench_mark-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

trench_mark-1.0.0/src/trench-mark/cli.py

@@ -0,0 +1,373 @@
+import argparse
+import os
+import re
+import shutil
+import subprocess
+import sys
+import threading
+from datetime import datetime
+import yaml
+
+class MemoryProfiler:
+    def __init__(self):
+        self.running = False
+        self.max_ram = 0
+        self.thread = None
+        self.process = None
+
+    def start(self):
+        self.running = True
+        self.thread = threading.Thread(target=self._monitor, daemon=True)
+        self.thread.start()
+
+    def _monitor(self):
+        if not shutil.which("tegrastats"):
+            if logger:
+                logger.write("Warning: 'tegrastats' binary not found. Memory profiling disabled.")
+            return
+        try:
+            self.process = subprocess.Popen(
+                ["tegrastats"],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+                bufsize=1,
+            )
+            while self.running:
+                line = self.process.stdout.readline()
+                if not line:
+                    break
+                match = re.search(r"RAM\s+(\d+)/\d+MB", line)
+                if match:
+                    ram = int(match.group(1))
+                    self.max_ram = max(self.max_ram, ram)
+        except Exception as e:
+            if logger:
+                logger.write(f"Memory profiler error: {e}")
+
+    def stop(self):
+        self.running = False
+        if self.process:
+            try:
+                self.process.terminate()
+            except Exception:
+                pass
+        if self.thread and self.thread.is_alive():
+            self.thread.join(timeout=2)
+        return self.max_ram
+
+class Logger:
+    def __init__(self, log_dir="logs"):
+        self.log_dir = log_dir
+        os.makedirs(self.log_dir, exist_ok=True)
+        timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+        self.log_file = os.path.join(self.log_dir, f"benchmark_{timestamp}.log")
+        with open(self.log_file, "w", encoding="utf-8") as f:
+            f.write("=" * 90 + "\n")
+            f.write("TENSORRT BENCHMARK LOG\n")
+            f.write("=" * 90 + "\n")
+            f.write(f"Started: {datetime.now()}\n")
+            f.write(f"Working Directory: {os.getcwd()}\n")
+            f.write("=" * 90 + "\n\n")
+
+    def write(self, message):
+        try:
+            with open(self.log_file, "a", encoding="utf-8") as f:
+                f.write(message)
+                if not message.endswith("\n"):
+                    f.write("\n")
+        except Exception:
+            pass
+
+    def command(self, cmd, output, returncode):
+        self.write("\n" + "=" * 90)
+        self.write("COMMAND")
+        self.write("=" * 90)
+        self.write(" ".join(cmd))
+        self.write("\nRETURN CODE")
+        self.write("=" * 90)
+        self.write(str(returncode))
+        self.write("\nOUTPUT")
+        self.write("=" * 90)
+        self.write(output if output else "[No output]")
+        self.write("\n" + "=" * 90 + "\n")
+
+logger = None
+
+def run_command(cmd, dry_run=False):
+    global logger
+    if logger:
+        logger.write(f"\nExecuting command: {' '.join(cmd)}")
+
+    if dry_run:
+        simulated_output = (
+            f"[DRY-RUN] Command validated: {' '.join(cmd)}\n"
+            "&&&& PASSED TensorRT.trtexec [DRY-RUN]\n"
+            "mean: 12.50 ms\n"
+            "Throughput: 80.00 qps\n"
+        )
+        if logger:
+            logger.command(cmd, simulated_output, 0)
+        return simulated_output
+
+    try:
+        result = subprocess.run(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+        )
+        output = result.stdout
+        if logger:
+            logger.command(cmd, output, result.returncode)
+        return output
+    except Exception as e:
+        error = f"Command execution failed: {e}"
+        if logger:
+            logger.command(cmd, error, -1)
+        return error
+
+def extract_metrics(log):
+    latency_match = re.search(r"mean\s*[=:]\s*([\d\.]+)\s*ms", log, re.IGNORECASE)
+    throughput_match = re.search(r"Throughput\s*[=:]\s*([\d\.]+)\s*qps", log, re.IGNORECASE)
+    latency = float(latency_match.group(1)) if latency_match else None
+    throughput = float(throughput_match.group(1)) if throughput_match else None
+    return {"latency_ms": latency, "fps": throughput}
+
+def log_system_information():
+    global logger
+    if not logger:
+        return
+    logger.write("\n" + "=" * 90)
+    logger.write("SYSTEM INFORMATION")
+    logger.write("=" * 90)
+    commands = [
+        ["uname", "-a"],
+        ["cat", "/etc/nv_tegra_release"],
+        ["python3", "--version"],
+        ["trtexec", "--help"],
+    ]
+    for cmd in commands:
+        try:
+            result = subprocess.run(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+            )
+            logger.command(cmd, result.stdout, result.returncode)
+        except Exception as e:
+            logger.write(f"Failed to execute {' '.join(cmd)}: {e}")
+
+def parse_arguments():
+    parser = argparse.ArgumentParser(
+        prog="trt-benchmark",
+        description="Automated, memory-safe TensorRT profiling pipeline for Jetson edge devices.",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument("-m", "--model", type=str, default=None, help="Path to the ONNX model file.")
+    parser.add_argument("-c", "--config", type=str, default="config.yaml", help="Path to config YAML file (used if CLI options are omitted).")
+    parser.add_argument("-s", "--input-shape", type=str, default="3x640x640", help="Input tensor shape in CHW format (e.g., 3x640x640).")
+    parser.add_argument("--input-name", type=str, default="images", help="Input binding name in the ONNX model.")
+    parser.add_argument("-p", "--precisions", nargs="+", choices=["fp32", "fp16", "int8"], default=["fp32", "fp16", "int8"], help="Precision levels to evaluate.")
+    parser.add_argument("-b", "--batch-sizes", nargs="+", type=int, default=[1, 4, 8], help="Batch sizes to benchmark.")
+    parser.add_argument("-i", "--iterations", type=int, default=500, help="Number of inference cycles per run.")
+    parser.add_argument("-w", "--warmup", type=int, default=50, help="Warmup duration in milliseconds.")
+    parser.add_argument("--workspace", type=int, default=2048, help="Max workspace size in MB for TensorRT builder.")
+    parser.add_argument("--dry-run", action="store_true", help="Simulate execution without running trtexec or compiling engines.")
+    return parser.parse_args()
+
+def load_configuration(args):
+    config = {
+        "model_name": None,
+        "onnx_path": None,
+        "input_shape": args.input_shape,
+        "input_name": args.input_name,
+        "batch_sizes": args.batch_sizes,
+        "precisions": args.precisions,
+        "iterations": args.iterations,
+        "warmup": args.warmup,
+        "workspace": args.workspace,
+    }
+
+    if args.model:
+        config["onnx_path"] = args.model
+        config["model_name"] = os.path.splitext(os.path.basename(args.model))[0]
+        return config
+
+    if os.path.exists(args.config):
+        try:
+            with open(args.config, "r", encoding="utf-8") as f:
+                file_cfg = yaml.safe_load(f)
+            config["model_name"] = file_cfg.get("model", {}).get("name", "model")
+            config["onnx_path"] = file_cfg.get("model", {}).get("onnx_path")
+            config["input_shape"] = file_cfg.get("model", {}).get("input_shape", args.input_shape)
+            config["batch_sizes"] = file_cfg.get("benchmarks", {}).get("batch_sizes", args.batch_sizes)
+            config["precisions"] = file_cfg.get("benchmarks", {}).get("precisions", args.precisions)
+            config["iterations"] = file_cfg.get("settings", {}).get("iterations", args.iterations)
+            config["warmup"] = file_cfg.get("settings", {}).get("warmup", args.warmup)
+            return config
+        except Exception as e:
+            if logger:
+                logger.write(f"Failed to read {args.config}: {e}")
+
+    return config
+
+def main():
+    global logger
+    args = parse_arguments()
+    logger = Logger()
+    config = load_configuration(args)
+
+    if not config["onnx_path"]:
+        error_msg = f"No ONNX model specified. Provide --model path/to/model.onnx or ensure valid config file exists at '{args.config}'."
+        print(f"Error: {error_msg}")
+        logger.write(f"FATAL: {error_msg}")
+        sys.exit(1)
+
+    if not args.dry_run and not os.path.exists(config["onnx_path"]):
+        error_msg = f"ONNX file '{config['onnx_path']}' does not exist."
+        print(f"Error: {error_msg}")
+        logger.write(f"FATAL: {error_msg}")
+        sys.exit(1)
+
+    if not args.dry_run:
+        log_system_information()
+
+    model_name = config["model_name"]
+    onnx_path = config["onnx_path"]
+    batch_sizes = sorted(config["batch_sizes"])
+    precisions = config["precisions"]
+    iterations = config["iterations"]
+    warmup = config["warmup"]
+    input_name = config["input_name"]
+    input_shape = config["input_shape"]
+    workspace = config["workspace"]
+
+    # FIX 1: Strip accidental '1x' if passed via CLI or YAML
+    if input_shape.startswith("1x"):
+        input_shape = input_shape[2:]
+
+    min_shape = f"{input_name}:1x{input_shape}"
+    opt_shape = f"{input_name}:1x{input_shape}"
+    max_batch = max(batch_sizes)
+    max_shape = f"{input_name}:{max_batch}x{input_shape}"
+
+    # FIX 2: Isolate engine binaries in a models directory
+    models_dir = "models"
+    os.makedirs(models_dir, exist_ok=True)
+
+    print("\nTENSORRT EDGE BENCHMARK")
+    print(f"Target Model: {onnx_path}")
+    if args.dry_run:
+        print("[DRY-RUN MODE ENABLED: Simulating commands]")
+    print("=" * 75)
+    print(f"{'Precision':<10} | {'Batch':<7} | {'Latency (ms)':<15} | {'Throughput (FPS)':<18} | {'Peak RAM (MB)'}")
+    print("-" * 75)
+
+    logger.write("\nBenchmark Configuration Details:")
+    logger.write(f"Model: {model_name}")
+    logger.write(f"ONNX Path: {onnx_path}")
+    logger.write(f"Input Name: {input_name}")
+    logger.write(f"Input Shape: {input_shape}")
+    logger.write(f"Shape Profile: MIN={min_shape}, OPT={opt_shape}, MAX={max_shape}")
+    logger.write(f"Batch Matrix: {batch_sizes}")
+    logger.write(f"Precisions: {precisions}")
+    logger.write(f"Iterations: {iterations}, Warmup: {warmup} ms\n")
+
+    for precision in precisions:
+        engine_path = os.path.join(models_dir, f"{model_name}_{precision}.engine")
+
+        # FIX 3: 0-Byte engine check to prevent deserialization crashes
+        is_corrupted = not args.dry_run and os.path.exists(engine_path) and os.path.getsize(engine_path) == 0
+
+        if not os.path.exists(engine_path) or is_corrupted or args.dry_run:
+            logger.write("\n" + "#" * 90)
+            logger.write(f"BUILDING {precision.upper()} ENGINE")
+            logger.write("#" * 90)
+
+            print(f"Building {precision.upper()} engine... (Saving to {engine_path})")
+
+            # FIX 4: Jetson Memory Safety & Faster Compilation Flags
+            build_cmd = [
+                "trtexec",
+                f"--onnx={onnx_path}",
+                f"--saveEngine={engine_path}",
+                f"--minShapes={min_shape}",
+                f"--optShapes={opt_shape}",
+                f"--maxShapes={max_shape}",
+                "--tempdir=.",
+                "--tempfileControls=in_memory:deny,temporary:allow",
+                f"--memPoolSize=workspace:{workspace}",
+                "--builderOptimizationLevel=1",
+                "--timingCacheFile=trt.cache"
+            ]
+
+            if precision == "fp16":
+                build_cmd.append("--fp16")
+            elif precision == "int8":
+                build_cmd.extend(["--int8", "--fp16"])
+
+            run_command(build_cmd, dry_run=args.dry_run)
+
+            if not args.dry_run and (not os.path.exists(engine_path) or os.path.getsize(engine_path) == 0):
+                print(f"{precision.upper()} engine build failed or returned 0 bytes.")
+                logger.write(f"\n{precision.upper()} ENGINE BUILD FAILED.")
+                continue
+
+            logger.write(f"\n{precision.upper()} engine ready: {engine_path}")
+        else:
+            logger.write(f"\nFound existing valid {precision.upper()} engine in {models_dir}/. Skipping compilation.")
+
+        for bs in batch_sizes:
+            logger.write("\n" + "-" * 90)
+            logger.write(f"RUNNING INFERENCE | Precision={precision.upper()} | Batch={bs}")
+            logger.write("-" * 90)
+
+            shape = f"{input_name}:{bs}x{input_shape}"
+            infer_cmd = [
+                "trtexec",
+                f"--loadEngine={engine_path}",
+                f"--shapes={shape}",
+                f"--iterations={iterations}",
+                f"--warmUp={warmup}",
+                "--noDataTransfers",
+            ]
+
+            profiler = MemoryProfiler()
+            if not args.dry_run:
+                profiler.start()
+
+            infer_log = run_command(infer_cmd, dry_run=args.dry_run)
+
+            peak_ram = profiler.stop() if not args.dry_run else 0
+            metrics = extract_metrics(infer_log)
+
+            logger.write(f"\nExtracted metrics for {precision.upper()} Batch {bs}:")
+            logger.write(f"Latency: {metrics['latency_ms']}")
+            logger.write(f"Throughput: {metrics['fps']}")
+            logger.write(f"Peak RAM: {peak_ram} MB")
+
+            if metrics["latency_ms"] is not None and metrics["fps"] is not None:
+                print(f"{precision.upper():<10} | {bs:<7} | {metrics['latency_ms']:<15.2f} | {metrics['fps']:<18.2f} | {peak_ram}")
+            else:
+                print(f"{precision.upper():<10} | {bs:<7} | {'FAILED':<15} | {'FAILED':<18} | {peak_ram}")
+                logger.write("\nMetric extraction failed. Full trtexec output saved above.")
+
+    logger.write("\n" + "=" * 90)
+    logger.write("BENCHMARK COMPLETED")
+    logger.write(f"Completed: {datetime.now()}")
+    logger.write("=" * 90)
+    print("=" * 75)
+    print(f"Full execution log saved to: {logger.log_file}")
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as e:
+        if logger:
+            logger.write("\n" + "=" * 90)
+            logger.write("UNHANDLED EXCEPTION")
+            logger.write("=" * 90)
+            logger.write(str(e))
+        print(f"Benchmark failed: {e}")

trench_mark-1.0.0/src/trench_mark.egg-info/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: trench-mark
+Version: 1.0.0
+Summary: Automated TensorRT performance profiling for Jetson edge devices.
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: pyyaml

trench_mark-1.0.0/src/trench_mark.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+src/trench-mark/__init__.py
+src/trench-mark/cli.py
+src/trench_mark.egg-info/PKG-INFO
+src/trench_mark.egg-info/SOURCES.txt
+src/trench_mark.egg-info/dependency_links.txt
+src/trench_mark.egg-info/entry_points.txt
+src/trench_mark.egg-info/requires.txt
+src/trench_mark.egg-info/top_level.txt

trench_mark-1.0.0/src/trench_mark.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

trench_mark-1.0.0/src/trench_mark.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+trench-mark = trench_mark.cli:main

trench_mark-1.0.0/src/trench_mark.egg-info/requires.txt

@@ -0,0 +1 @@
+pyyaml

trench_mark-1.0.0/src/trench_mark.egg-info/top_level.txt

@@ -0,0 +1 @@
+trench-mark