WIP version

.gitignore

@@ -0,0 +1,12 @@
+.DS_Store
+.venv
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+*.pyw
+*.pyz
+*.pywz
+*.pyzw
+*.pyzwz
+*.pyzwzw

benchmark_data_reader.py

@@ -0,0 +1,224 @@
+#!/usr/bin/env python3
+"""
+Benchmark Data Reader for LLM Inference Performance Dashboard
+
+This module provides functionality to read benchmark result files and convert them
+into a flattened Polars DataFrame for analysis and visualization.
+"""
+
+import json
+import polars as pl
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class BenchmarkDataReader:
+    """Reader for benchmark result JSON files that flattens data into a Polars DataFrame."""
+
+    def __init__(self, benchmark_dir: str = "benchmark_results"):
+        """
+        Initialize the benchmark data reader.
+
+        Args:
+            benchmark_dir: Directory containing benchmark result files
+        """
+        self.benchmark_dir = Path(benchmark_dir)
+
+    def read_benchmark_files(self) -> pl.DataFrame:
+        """
+        Read all benchmark files and return a flattened Polars DataFrame.
+
+        Returns:
+            Polars DataFrame where each row represents a benchmark scenario with all metrics
+        """
+        all_records = []
+
+        # Find all individual model benchmark files (exclude summary files)
+        benchmark_files = list(self.benchmark_dir.rglob("*_benchmark_*.json"))
+        benchmark_files = [f for f in benchmark_files if "summary" not in f.name]
+
+        logger.info(f"Found {len(benchmark_files)} benchmark files")
+
+        for file_path in benchmark_files:
+            try:
+                records = self._process_benchmark_file(file_path)
+                all_records.extend(records)
+                logger.debug(f"Processed {len(records)} scenarios from {file_path}")
+            except Exception as e:
+                logger.error(f"Error processing {file_path}: {e}")
+                continue
+
+        if not all_records:
+            logger.warning("No benchmark data found")
+            return pl.DataFrame()
+
+        # Create DataFrame from all records
+        df = pl.DataFrame(all_records)
+        logger.info(f"Created DataFrame with {len(df)} rows and {len(df.columns)} columns")
+
+        return df
+
+    def _process_benchmark_file(self, file_path: Path) -> List[Dict[str, Any]]:
+        """
+        Process a single benchmark file and extract all scenarios.
+
+        Args:
+            file_path: Path to the benchmark JSON file
+
+        Returns:
+            List of flattened records, one per benchmark scenario
+        """
+        with open(file_path, 'r') as f:
+            data = json.load(f)
+
+        records = []
+        model_name = data.get("model_name", "unknown")
+
+        for scenario in data.get("benchmark_scenarios", []):
+            record = self._flatten_scenario(scenario, model_name, file_path)
+            records.append(record)
+
+        return records
+
+    def _flatten_scenario(self, scenario: Dict[str, Any], model_name: str, file_path: Path) -> Dict[str, Any]:
+        """
+        Flatten a single benchmark scenario into a flat record.
+
+        Args:
+            scenario: Scenario data from benchmark file
+            model_name: Name of the model being benchmarked
+            file_path: Path to the original file
+
+        Returns:
+            Flattened dictionary with all metrics and metadata
+        """
+        record = {
+            # File metadata
+            "file_path": str(file_path),
+            "model_name": model_name,
+
+            # Scenario metadata
+            "scenario_name": scenario.get("scenario_name", "unknown"),
+        }
+
+        # Add metadata fields
+        metadata = scenario.get("metadata", {})
+        record.update({
+            "timestamp": metadata.get("timestamp"),
+            "commit_id": metadata.get("commit_id"),
+        })
+
+        # Add hardware info
+        hw_info = metadata.get("hardware_info", {})
+        record.update({
+            "gpu_name": hw_info.get("gpu_name"),
+            "gpu_memory_total_mb": hw_info.get("gpu_memory_total_mb"),
+            "cpu_count": hw_info.get("cpu_count"),
+            "memory_total_mb": hw_info.get("memory_total_mb"),
+            "python_version": hw_info.get("python_version"),
+            "torch_version": hw_info.get("torch_version"),
+            "cuda_version": hw_info.get("cuda_version"),
+        })
+
+        # Add config info
+        config = metadata.get("config", {})
+        record.update({
+            "config_name": config.get("name"),
+            "model_id": config.get("model_id"),
+            "variant": config.get("variant"),
+            "warmup_iterations": config.get("warmup_iterations"),
+            "measurement_iterations": config.get("measurement_iterations"),
+            "num_tokens_to_generate": config.get("num_tokens_to_generate"),
+            "device": config.get("device"),
+            "torch_dtype": config.get("torch_dtype"),
+            "compile_mode": config.get("compile_mode"),
+            "use_cache": config.get("use_cache"),
+            "batch_size": config.get("batch_size"),
+            "sequence_length": config.get("sequence_length"),
+            "attn_implementation": config.get("attn_implementation"),
+            "sdpa_backend": config.get("sdpa_backend"),
+        })
+
+        # Add measurement statistics for each metric
+        measurements = scenario.get("measurements", {})
+        for metric_name, metric_data in measurements.items():
+            if isinstance(metric_data, dict):
+                # Add statistics for this metric
+                for stat_name, stat_value in metric_data.items():
+                    if stat_name != "measurements":  # Skip raw measurements array
+                        record[f"{metric_name}_{stat_name}"] = stat_value
+
+        # Add GPU metrics
+        gpu_metrics = scenario.get("gpu_metrics", {})
+        for gpu_metric, value in gpu_metrics.items():
+            record[f"gpu_{gpu_metric}"] = value
+
+        return record
+
+    def get_summary_statistics(self, df: pl.DataFrame) -> Dict[str, Any]:
+        """
+        Generate summary statistics from the benchmark DataFrame.
+
+        Args:
+            df: Benchmark DataFrame
+
+        Returns:
+            Dictionary with summary statistics
+        """
+        if df.is_empty():
+            return {}
+
+        return {
+            "total_scenarios": len(df),
+            "unique_models": df["model_name"].n_unique(),
+            "unique_scenarios": df["scenario_name"].n_unique(),
+            "unique_hardware": df["gpu_name"].n_unique(),
+            "date_range": {
+                "earliest": df["timestamp"].min(),
+                "latest": df["timestamp"].max(),
+            },
+            "performance_metrics": {
+                "avg_latency_seconds": df.select(pl.col("latency_seconds_mean").mean()).item(),
+                "avg_tokens_per_second": df.select(pl.col("tokens_per_second_mean").mean()).item(),
+                "avg_time_to_first_token": df.select(pl.col("time_to_first_token_seconds_mean").mean()).item(),
+            } if "latency_seconds_mean" in df.columns else None
+        }
+
+
+def main():
+    """Example usage of the BenchmarkDataReader."""
+    logging.basicConfig(level=logging.INFO)
+
+    # Create reader and load data
+    reader = BenchmarkDataReader()
+    df = reader.read_benchmark_files()
+
+    if df.is_empty():
+        print("No benchmark data found!")
+        return
+
+    # Display basic info
+    print(f"\nLoaded benchmark data: {len(df)} scenarios")
+    print(f"Columns: {len(df.columns)}")
+    print("\nColumn names:")
+    for col in sorted(df.columns):
+        print(f"  - {col}")
+
+    # Show summary statistics
+    summary = reader.get_summary_statistics(df)
+    print(f"\nSummary Statistics:")
+    for key, value in summary.items():
+        print(f"  {key}: {value}")
+
+    # Show sample data
+    print(f"\nSample data (first 3 rows):")
+    print(df.head(3))
+
+    return df
+
+
+if __name__ == "__main__":
+    df = main()

benchmark_results/Qwen2-7B/Qwen2-7B_benchmark_20250916_143929.json

@@ -0,0 +1,1045 @@
+{
+  "model_name": "Qwen2-7B",
+  "benchmark_scenarios": [
+    {
+      "scenario_name": "eager_eager_attn",
+      "metadata": {
+        "timestamp": "2025-09-16T14:32:57.577651",
+        "commit_id": null,
+        "hardware_info": {
+          "gpu_name": "NVIDIA A100-SXM4-80GB",
+          "gpu_memory_total_mb": 81920,
+          "cpu_count": 128,
+          "memory_total_mb": 515624,
+          "python_version": "3.10.12",
+          "torch_version": "2.8.0+cu126",
+          "cuda_version": "12.6"
+        },
+        "config": {
+          "name": "eager",
+          "model_id": "Qwen/Qwen2-7B",
+          "variant": "eager",
+          "warmup_iterations": 3,
+          "measurement_iterations": 5,
+          "num_tokens_to_generate": 100,
+          "device": "cuda",
+          "torch_dtype": "float16",
+          "compile_mode": null,
+          "compile_options": {},
+          "use_cache": true,
+          "batch_size": 1,
+          "sequence_length": null,
+          "attn_implementation": "eager",
+          "sdpa_backend": null,
+          "custom_params": {}
+        }
+      },
+      "measurements": {
+        "latency_seconds": {
+          "name": "latency_seconds",
+          "measurements": [
+            3.080421630859375,
+            3.11809912109375,
+            3.0738232421875,
+            3.063243896484375,
+            3.067010498046875
+          ],
+          "mean": 3.080519677734375,
+          "median": 3.0738232421875,
+          "std": 0.019687645766066797,
+          "min": 3.063243896484375,
+          "max": 3.11809912109375,
+          "p25": 3.067010498046875,
+          "p75": 3.080421630859375,
+          "p90": 3.103028125,
+          "p95": 3.110563623046875,
+          "p99": 3.116592021484375,
+          "unit": "seconds"
+        },
+        "time_to_first_token_seconds": {
+          "name": "time_to_first_token_seconds",
+          "measurements": [
+            0.034482784271240234,
+            0.033048095703125,
+            0.03294166564941406,
+            0.032885345458984375,
+            0.03293324661254883
+          ],
+          "mean": 0.033258227539062504,
+          "median": 0.03294166564941406,
+          "std": 0.0006145827295027316,
+          "min": 0.032885345458984375,
+          "max": 0.034482784271240234,
+          "p25": 0.03293324661254883,
+          "p75": 0.033048095703125,
+          "p90": 0.03390890884399414,
+          "p95": 0.03419584655761719,
+          "p99": 0.03442539672851563,
+          "unit": "seconds"
+        },
+        "tokens_per_second": {
+          "name": "tokens_per_second",
+          "measurements": [
+            32.463088493539125,
+            32.070821393555484,
+            32.5327750234703,
+            32.64513155964109,
+            32.60504001002987
+          ],
+          "mean": 32.46337129604717,
+          "median": 32.5327750234703,
+          "std": 0.20592192755845912,
+          "min": 32.070821393555484,
+          "max": 32.64513155964109,
+          "p25": 32.463088493539125,
+          "p75": 32.60504001002987,
+          "p90": 32.6290949397966,
+          "p95": 32.637113249718844,
+          "p99": 32.64352789765664,
+          "unit": "tokens/sec"
+        },
+        "time_per_output_token_seconds": {
+          "name": "time_per_output_token_seconds",
+          "measurements": [
+            0.030804216308593747,
+            0.031180991210937502,
+            0.030738232421874997,
+            0.03063243896484375,
+            0.03067010498046875
+          ],
+          "mean": 0.030805196777343745,
+          "median": 0.030738232421874997,
+          "std": 0.0001968764576606682,
+          "min": 0.03063243896484375,
+          "max": 0.031180991210937502,
+          "p25": 0.03067010498046875,
+          "p75": 0.030804216308593747,
+          "p90": 0.03103028125,
+          "p95": 0.03110563623046875,
+          "p99": 0.03116592021484375,
+          "unit": "seconds/token"
+        }
+      },
+      "gpu_metrics": {
+        "gpu_utilization_mean": 49,
+        "gpu_utilization_max": 50,
+        "gpu_utilization_min": 46,
+        "gpu_memory_used_mean": 15356,
+        "gpu_memory_used_max": 15356,
+        "gpu_memory_used_min": 15356,
+        "sample_count": 12,
+        "gpu_monitoring_status": "success"
+      }
+    },
+    {
+      "scenario_name": "compiled_compile_max-autotune_eager_attn",
+      "metadata": {
+        "timestamp": "2025-09-16T14:33:40.254963",
+        "commit_id": null,
+        "hardware_info": {
+          "gpu_name": "NVIDIA A100-SXM4-80GB",
+          "gpu_memory_total_mb": 81920,
+          "cpu_count": 128,
+          "memory_total_mb": 515624,
+          "python_version": "3.10.12",
+          "torch_version": "2.8.0+cu126",
+          "cuda_version": "12.6"
+        },
+        "config": {
+          "name": "compiled",
+          "model_id": "Qwen/Qwen2-7B",
+          "variant": "compiled",
+          "warmup_iterations": 3,
+          "measurement_iterations": 5,
+          "num_tokens_to_generate": 100,
+          "device": "cuda",
+          "torch_dtype": "float16",
+          "compile_mode": "max-autotune",
+          "compile_options": {},
+          "use_cache": true,
+          "batch_size": 1,
+          "sequence_length": null,
+          "attn_implementation": "eager",
+          "sdpa_backend": null,
+          "custom_params": {}
+        }
+      },
+      "measurements": {
+        "latency_seconds": {
+          "name": "latency_seconds",
+          "measurements": [
+            6.4204189453125,
+            7.5098984375,
+            7.9186865234375,
+            6.87070166015625,
+            8.3134296875
+          ],
+          "mean": 7.406627050781251,
+          "median": 7.5098984375,
+          "std": 0.6862919723296647,
+          "min": 6.4204189453125,
+          "max": 8.3134296875,
+          "p25": 6.87070166015625,
+          "p75": 7.9186865234375,
+          "p90": 8.155532421875,
+          "p95": 8.2344810546875,
+          "p99": 8.297639960937499,
+          "unit": "seconds"
+        },
+        "time_to_first_token_seconds": {
+          "name": "time_to_first_token_seconds",
+          "measurements": [
+            0.03493379211425781,
+            0.03398665618896484,
+            0.043259166717529295,
+            0.03372019195556641,
+            0.04352550506591797
+          ],
+          "mean": 0.037885062408447266,
+          "median": 0.03493379211425781,
+          "std": 0.0045155133437484955,
+          "min": 0.03372019195556641,
+          "max": 0.04352550506591797,
+          "p25": 0.03398665618896484,
+          "p75": 0.043259166717529295,
+          "p90": 0.0434189697265625,
+          "p95": 0.04347223739624024,
+          "p99": 0.043514851531982424,
+          "unit": "seconds"
+        },
+        "tokens_per_second": {
+          "name": "tokens_per_second",
+          "measurements": [
+            15.575307600917423,
+            13.315759305167035,
+            12.628356950868415,
+            14.55455424296881,
+            12.02872986949768
+          ],
+          "mean": 13.620541593883871,
+          "median": 13.315759305167035,
+          "std": 1.2887728229714563,
+          "min": 12.02872986949768,
+          "max": 15.575307600917423,
+          "p25": 12.628356950868415,
+          "p75": 14.55455424296881,
+          "p90": 15.167006257737977,
+          "p95": 15.3711569293277,
+          "p99": 15.534477466599478,
+          "unit": "tokens/sec"
+        },
+        "time_per_output_token_seconds": {
+          "name": "time_per_output_token_seconds",
+          "measurements": [
+            0.064204189453125,
+            0.07509898437500001,
+            0.079186865234375,
+            0.0687070166015625,
+            0.083134296875
+          ],
+          "mean": 0.0740662705078125,
+          "median": 0.07509898437500001,
+          "std": 0.006862919723296648,
+          "min": 0.064204189453125,
+          "max": 0.083134296875,
+          "p25": 0.0687070166015625,
+          "p75": 0.079186865234375,
+          "p90": 0.08155532421875,
+          "p95": 0.082344810546875,
+          "p99": 0.082976399609375,
+          "unit": "seconds/token"
+        }
+      },
+      "gpu_metrics": {
+        "gpu_utilization_mean": 66,
+        "gpu_utilization_max": 100,
+        "gpu_utilization_min": 0,
+        "gpu_memory_used_mean": 71715.41176470589,
+        "gpu_memory_used_max": 78882,
+        "gpu_memory_used_min": 46602,
+        "sample_count": 17,
+        "gpu_monitoring_status": "success"
+      }
+    },
+    {
+      "scenario_name": "eager_sdpa_default",
+      "metadata": {
+        "timestamp": "2025-09-16T14:35:10.602807",
+        "commit_id": null,
+        "hardware_info": {
+          "gpu_name": "NVIDIA A100-SXM4-80GB",
+          "gpu_memory_total_mb": 81920,
+          "cpu_count": 128,
+          "memory_total_mb": 515624,
+          "python_version": "3.10.12",
+          "torch_version": "2.8.0+cu126",
+          "cuda_version": "12.6"
+        },
+        "config": {
+          "name": "eager",
+          "model_id": "Qwen/Qwen2-7B",
+          "variant": "eager",
+          "warmup_iterations": 3,
+          "measurement_iterations": 5,
+          "num_tokens_to_generate": 100,
+          "device": "cuda",
+          "torch_dtype": "float16",
+          "compile_mode": null,
+          "compile_options": {},
+          "use_cache": true,
+          "batch_size": 1,
+          "sequence_length": null,
+          "attn_implementation": "sdpa",
+          "sdpa_backend": null,
+          "custom_params": {}
+        }
+      },
+      "measurements": {
+        "latency_seconds": {
+          "name": "latency_seconds",
+          "measurements": [
+            2.3900068359375,
+            2.379837158203125,
+            2.39191650390625,
+            2.394760986328125,
+            2.38983203125
+          ],
+          "mean": 2.3892707031250002,
+          "median": 2.3900068359375,
+          "std": 0.0050396869347048,
+          "min": 2.379837158203125,
+          "max": 2.394760986328125,
+          "p25": 2.38983203125,
+          "p75": 2.39191650390625,
+          "p90": 2.393623193359375,
+          "p95": 2.39419208984375,
+          "p99": 2.3946472070312503,
+          "unit": "seconds"
+        },
+        "time_to_first_token_seconds": {
+          "name": "time_to_first_token_seconds",
+          "measurements": [
+            0.026343584060668945,
+            0.025955039978027342,
+            0.02592620849609375,
+            0.025973472595214844,
+            0.025634336471557616
+          ],
+          "mean": 0.025966528320312498,
+          "median": 0.025955039978027342,
+          "std": 0.0002255341876090389,
+          "min": 0.025634336471557616,
+          "max": 0.026343584060668945,
+          "p25": 0.02592620849609375,
+          "p75": 0.025973472595214844,
+          "p90": 0.026195539474487304,
+          "p95": 0.026269561767578126,
+          "p99": 0.02632877960205078,
+          "unit": "seconds"
+        },
+        "tokens_per_second": {
+          "name": "tokens_per_second",
+          "measurements": [
+            41.8408845097609,
+            42.01968174810083,
+            41.80747941522604,
+            41.757820747418094,
+            41.84394496867425
+          ],
+          "mean": 41.853962277836025,
+          "median": 41.8408845097609,
+          "std": 0.08847391447544005,
+          "min": 41.757820747418094,
+          "max": 42.01968174810083,
+          "p25": 41.80747941522604,
+          "p75": 41.84394496867425,
+          "p90": 41.9493870363302,
+          "p95": 41.984534392215515,
+          "p99": 42.01265227692377,
+          "unit": "tokens/sec"
+        },
+        "time_per_output_token_seconds": {
+          "name": "time_per_output_token_seconds",
+          "measurements": [
+            0.023900068359375002,
+            0.023798371582031252,
+            0.023919165039062502,
+            0.02394760986328125,
+            0.023898320312500002
+          ],
+          "mean": 0.02389270703125,
+          "median": 0.023900068359375002,
+          "std": 5.0396869347047166e-05,
+          "min": 0.023798371582031252,
+          "max": 0.02394760986328125,
+          "p25": 0.023898320312500002,
+          "p75": 0.023919165039062502,
+          "p90": 0.02393623193359375,
+          "p95": 0.0239419208984375,
+          "p99": 0.0239464720703125,
+          "unit": "seconds/token"
+        }
+      },
+      "gpu_metrics": {
+        "gpu_utilization_mean": 60.25,
+        "gpu_utilization_max": 61,
+        "gpu_utilization_min": 60,
+        "gpu_memory_used_mean": 15466,
+        "gpu_memory_used_max": 15466,
+        "gpu_memory_used_min": 15466,
+        "sample_count": 8,
+        "gpu_monitoring_status": "success"
+      }
+    },
+    {
+      "scenario_name": "eager_sdpa_math",
+      "metadata": {
+        "timestamp": "2025-09-16T14:35:47.417716",
+        "commit_id": null,
+        "hardware_info": {
+          "gpu_name": "NVIDIA A100-SXM4-80GB",
+          "gpu_memory_total_mb": 81920,
+          "cpu_count": 128,
+          "memory_total_mb": 515624,
+          "python_version": "3.10.12",
+          "torch_version": "2.8.0+cu126",
+          "cuda_version": "12.6"
+        },
+        "config": {
+          "name": "eager",
+          "model_id": "Qwen/Qwen2-7B",
+          "variant": "eager",
+          "warmup_iterations": 3,
+          "measurement_iterations": 5,
+          "num_tokens_to_generate": 100,
+          "device": "cuda",
+          "torch_dtype": "float16",
+          "compile_mode": null,
+          "compile_options": {},
+          "use_cache": true,
+          "batch_size": 1,
+          "sequence_length": null,
+          "attn_implementation": "sdpa",
+          "sdpa_backend": "math",
+          "custom_params": {}
+        }
+      },
+      "measurements": {
+        "latency_seconds": {
+          "name": "latency_seconds",
+          "measurements": [
+            2.9385849609375,
+            2.911900390625,
+            2.9431630859375,
+            2.923252197265625,
+            2.91033935546875
+          ],
+          "mean": 2.925447998046875,
+          "median": 2.923252197265625,
+          "std": 0.013439006075182301,
+          "min": 2.91033935546875,
+          "max": 2.9431630859375,
+          "p25": 2.911900390625,
+          "p75": 2.9385849609375,
+          "p90": 2.9413318359375,
+          "p95": 2.9422474609375,
+          "p99": 2.9429799609375,
+          "unit": "seconds"
+        },
+        "time_to_first_token_seconds": {
+          "name": "time_to_first_token_seconds",
+          "measurements": [
+            0.033364158630371094,
+            0.032983425140380856,
+            0.03354035186767578,
+            0.03323625564575195,
+            0.033615966796875
+          ],
+          "mean": 0.03334803161621094,
+          "median": 0.033364158630371094,
+          "std": 0.00022559617485054417,
+          "min": 0.032983425140380856,
+          "max": 0.033615966796875,
+          "p25": 0.03323625564575195,
+          "p75": 0.03354035186767578,
+          "p90": 0.033585720825195314,
+          "p95": 0.033600843811035154,
+          "p99": 0.03361294219970703,
+          "unit": "seconds"
+        },
+        "tokens_per_second": {
+          "name": "tokens_per_second",
+          "measurements": [
+            34.029984271101995,
+            34.34183405516023,
+            33.97705022796809,
+            34.20847509959585,
+            34.36025417863809
+          ],
+          "mean": 34.18351956649285,
+          "median": 34.20847509959585,
+          "std": 0.1569229452732795,
+          "min": 33.97705022796809,
+          "max": 34.36025417863809,
+          "p25": 34.029984271101995,
+          "p75": 34.34183405516023,
+          "p90": 34.35288612924694,
+          "p95": 34.35657015394251,
+          "p99": 34.35951737369897,
+          "unit": "tokens/sec"
+        },
+        "time_per_output_token_seconds": {
+          "name": "time_per_output_token_seconds",
+          "measurements": [
+            0.029385849609375,
+            0.02911900390625,
+            0.029431630859375,
+            0.029232521972656248,
+            0.0291033935546875
+          ],
+          "mean": 0.02925447998046875,
+          "median": 0.029232521972656248,
+          "std": 0.00013439006075182346,
+          "min": 0.0291033935546875,
+          "max": 0.029431630859375,
+          "p25": 0.02911900390625,
+          "p75": 0.029385849609375,
+          "p90": 0.029413318359375,
+          "p95": 0.029422474609375,
+          "p99": 0.029429799609374998,
+          "unit": "seconds/token"
+        }
+      },
+      "gpu_metrics": {
+        "gpu_utilization_mean": 54.77777777777778,
+        "gpu_utilization_max": 55,
+        "gpu_utilization_min": 54,
+        "gpu_memory_used_mean": 15466,
+        "gpu_memory_used_max": 15466,
+        "gpu_memory_used_min": 15466,
+        "sample_count": 9,
+        "gpu_monitoring_status": "success"
+      }
+    },
+    {
+      "scenario_name": "eager_sdpa_flash_attention",
+      "metadata": {
+        "timestamp": "2025-09-16T14:36:28.763857",
+        "commit_id": null,
+        "hardware_info": {
+          "gpu_name": "NVIDIA A100-SXM4-80GB",
+          "gpu_memory_total_mb": 81920,
+          "cpu_count": 128,
+          "memory_total_mb": 515624,
+          "python_version": "3.10.12",
+          "torch_version": "2.8.0+cu126",
+          "cuda_version": "12.6"
+        },
+        "config": {
+          "name": "eager",
+          "model_id": "Qwen/Qwen2-7B",
+          "variant": "eager",
+          "warmup_iterations": 3,
+          "measurement_iterations": 5,
+          "num_tokens_to_generate": 100,
+          "device": "cuda",
+          "torch_dtype": "float16",
+          "compile_mode": null,
+          "compile_options": {},
+          "use_cache": true,
+          "batch_size": 1,
+          "sequence_length": null,
+          "attn_implementation": "sdpa",
+          "sdpa_backend": "flash_attention",
+          "custom_params": {}
+        }
+      },
+      "measurements": {
+        "latency_seconds": {
+          "name": "latency_seconds",
+          "measurements": [
+            2.40218310546875,
+            2.39602734375,
+            2.416225341796875,
+            2.421543701171875,
+            2.434317138671875
+          ],
+          "mean": 2.414059326171875,
+          "median": 2.416225341796875,
+          "std": 0.013691482522836295,
+          "min": 2.39602734375,
+          "max": 2.434317138671875,
+          "p25": 2.40218310546875,
+          "p75": 2.421543701171875,
+          "p90": 2.429207763671875,
+          "p95": 2.431762451171875,
+          "p99": 2.433806201171875,
+          "unit": "seconds"
+        },
+        "time_to_first_token_seconds": {
+          "name": "time_to_first_token_seconds",
+          "measurements": [
+            0.02634345626831055,
+            0.025819807052612304,
+            0.02593836784362793,
+            0.025983327865600585,
+            0.02601523208618164
+          ],
+          "mean": 0.026020038223266602,
+          "median": 0.025983327865600585,
+          "std": 0.0001747756011493655,
+          "min": 0.025819807052612304,
+          "max": 0.02634345626831055,
+          "p25": 0.02593836784362793,
+          "p75": 0.02601523208618164,
+          "p90": 0.026212166595458986,
+          "p95": 0.026277811431884766,
+          "p99": 0.026330327301025393,
+          "unit": "seconds"
+        },
+        "tokens_per_second": {
+          "name": "tokens_per_second",
+          "measurements": [
+            41.62879997463245,
+            41.73575074627109,
+            41.386868298315655,
+            41.29597163644261,
+            41.07928191088464
+          ],
+          "mean": 41.42533451330929,
+          "median": 41.386868298315655,
+          "std": 0.23482897559273794,
+          "min": 41.07928191088464,
+          "max": 41.73575074627109,
+          "p25": 41.29597163644261,
+          "p75": 41.62879997463245,
+          "p90": 41.692970437615635,
+          "p95": 41.71436059194336,
+          "p99": 41.731472715405545,
+          "unit": "tokens/sec"
+        },
+        "time_per_output_token_seconds": {
+          "name": "time_per_output_token_seconds",
+          "measurements": [
+            0.0240218310546875,
+            0.023960273437500002,
+            0.02416225341796875,
+            0.02421543701171875,
+            0.02434317138671875
+          ],
+          "mean": 0.02414059326171875,
+          "median": 0.02416225341796875,
+          "std": 0.0001369148252283633,
+          "min": 0.023960273437500002,
+          "max": 0.02434317138671875,
+          "p25": 0.0240218310546875,
+          "p75": 0.02421543701171875,
+          "p90": 0.02429207763671875,
+          "p95": 0.02431762451171875,
+          "p99": 0.02433806201171875,
+          "unit": "seconds/token"
+        }
+      },
+      "gpu_metrics": {
+        "gpu_utilization_mean": 59.625,
+        "gpu_utilization_max": 60,
+        "gpu_utilization_min": 59,
+        "gpu_memory_used_mean": 15571.5,
+        "gpu_memory_used_max": 15888,
+        "gpu_memory_used_min": 15466,
+        "sample_count": 8,
+        "gpu_monitoring_status": "success"
+      }
+    },
+    {
+      "scenario_name": "compiled_compile_max-autotune_sdpa_default",
+      "metadata": {
+        "timestamp": "2025-09-16T14:37:19.442972",
+        "commit_id": null,
+        "hardware_info": {
+          "gpu_name": "NVIDIA A100-SXM4-80GB",
+          "gpu_memory_total_mb": 81920,
+          "cpu_count": 128,
+          "memory_total_mb": 515624,
+          "python_version": "3.10.12",
+          "torch_version": "2.8.0+cu126",
+          "cuda_version": "12.6"
+        },
+        "config": {
+          "name": "compiled",
+          "model_id": "Qwen/Qwen2-7B",
+          "variant": "compiled",
+          "warmup_iterations": 3,
+          "measurement_iterations": 5,
+          "num_tokens_to_generate": 100,
+          "device": "cuda",
+          "torch_dtype": "float16",
+          "compile_mode": "max-autotune",
+          "compile_options": {},
+          "use_cache": true,
+          "batch_size": 1,
+          "sequence_length": null,
+          "attn_implementation": "sdpa",
+          "sdpa_backend": null,
+          "custom_params": {}
+        }
+      },
+      "measurements": {
+        "latency_seconds": {
+          "name": "latency_seconds",
+          "measurements": [
+            3.05654345703125,
+            3.02232568359375,
+            3.01347021484375,
+            3.01363623046875,
+            2.980415283203125
+          ],
+          "mean": 3.0172781738281254,
+          "median": 3.01363623046875,
+          "std": 0.024305871011531265,
+          "min": 2.980415283203125,
+          "max": 3.05654345703125,
+          "p25": 3.01347021484375,
+          "p75": 3.02232568359375,
+          "p90": 3.04285634765625,
+          "p95": 3.0496999023437503,
+          "p99": 3.0551747460937504,
+          "unit": "seconds"
+        },
+        "time_to_first_token_seconds": {
+          "name": "time_to_first_token_seconds",
+          "measurements": [
+            0.033438655853271486,
+            0.03183209609985352,
+            0.03240959930419922,
+            0.03159875106811524,
+            0.031626720428466794
+          ],
+          "mean": 0.03218116455078125,
+          "median": 0.03183209609985352,
+          "std": 0.0006930987441051968,
+          "min": 0.03159875106811524,
+          "max": 0.033438655853271486,
+          "p25": 0.031626720428466794,
+          "p75": 0.03240959930419922,
+          "p90": 0.03302703323364258,
+          "p95": 0.033232844543457034,
+          "p99": 0.03339749359130859,
+          "unit": "seconds"
+        },
+        "tokens_per_second": {
+          "name": "tokens_per_second",
+          "measurements": [
+            32.71669498758826,
+            33.0871026053993,
+            33.18433330033263,
+            33.18250523701917,
+            33.55237122946422
+          ],
+          "mean": 33.14460147196072,
+          "median": 33.18250523701917,
+          "std": 0.2667214156192523,
+          "min": 32.71669498758826,
+          "max": 33.55237122946422,
+          "p25": 33.0871026053993,
+          "p75": 33.18433330033263,
+          "p90": 33.40515605781159,
+          "p95": 33.478763643637905,
+          "p99": 33.53764971229896,
+          "unit": "tokens/sec"
+        },
+        "time_per_output_token_seconds": {
+          "name": "time_per_output_token_seconds",
+          "measurements": [
+            0.0305654345703125,
+            0.0302232568359375,
+            0.0301347021484375,
+            0.030136362304687497,
+            0.029804152832031253
+          ],
+          "mean": 0.03017278173828125,
+          "median": 0.030136362304687497,
+          "std": 0.0002430587101153121,
+          "min": 0.029804152832031253,
+          "max": 0.0305654345703125,
+          "p25": 0.0301347021484375,
+          "p75": 0.0302232568359375,
+          "p90": 0.0304285634765625,
+          "p95": 0.030496999023437502,
+          "p99": 0.0305517474609375,
+          "unit": "seconds/token"
+        }
+      },
+      "gpu_metrics": {
+        "gpu_utilization_mean": 50.22222222222222,
+        "gpu_utilization_max": 51,
+        "gpu_utilization_min": 49,
+        "gpu_memory_used_mean": 15608.666666666666,
+        "gpu_memory_used_max": 15888,
+        "gpu_memory_used_min": 15466,
+        "sample_count": 9,
+        "gpu_monitoring_status": "success"
+      }
+    },
+    {
+      "scenario_name": "compiled_compile_max-autotune_sdpa_math",
+      "metadata": {
+        "timestamp": "2025-09-16T14:38:01.815515",
+        "commit_id": null,
+        "hardware_info": {
+          "gpu_name": "NVIDIA A100-SXM4-80GB",
+          "gpu_memory_total_mb": 81920,
+          "cpu_count": 128,
+          "memory_total_mb": 515624,
+          "python_version": "3.10.12",
+          "torch_version": "2.8.0+cu126",
+          "cuda_version": "12.6"
+        },
+        "config": {
+          "name": "compiled",
+          "model_id": "Qwen/Qwen2-7B",
+          "variant": "compiled",
+          "warmup_iterations": 3,
+          "measurement_iterations": 5,
+          "num_tokens_to_generate": 100,
+          "device": "cuda",
+          "torch_dtype": "float16",
+          "compile_mode": "max-autotune",
+          "compile_options": {},
+          "use_cache": true,
+          "batch_size": 1,
+          "sequence_length": null,
+          "attn_implementation": "sdpa",
+          "sdpa_backend": "math",
+          "custom_params": {}
+        }
+      },
+      "measurements": {
+        "latency_seconds": {
+          "name": "latency_seconds",
+          "measurements": [
+            3.39007763671875,
+            3.416772216796875,
+            3.38962255859375,
+            3.387712890625,
+            3.40566162109375
+          ],
+          "mean": 3.397969384765625,
+          "median": 3.39007763671875,
+          "std": 0.011400542606022364,
+          "min": 3.387712890625,
+          "max": 3.416772216796875,
+          "p25": 3.38962255859375,
+          "p75": 3.40566162109375,
+          "p90": 3.412327978515625,
+          "p95": 3.41455009765625,
+          "p99": 3.41632779296875,
+          "unit": "seconds"
+        },
+        "time_to_first_token_seconds": {
+          "name": "time_to_first_token_seconds",
+          "measurements": [
+            0.03628326416015625,
+            0.036549503326416016,
+            0.03622611236572266,
+            0.035679134368896484,
+            0.03579260635375976
+          ],
+          "mean": 0.036106124114990236,
+          "median": 0.03622611236572266,
+          "std": 0.0003234113575358685,
+          "min": 0.035679134368896484,
+          "max": 0.036549503326416016,
+          "p25": 0.03579260635375976,
+          "p75": 0.03628326416015625,
+          "p90": 0.03644300765991211,
+          "p95": 0.03649625549316406,
+          "p99": 0.03653885375976563,
+          "unit": "seconds"
+        },
+        "tokens_per_second": {
+          "name": "tokens_per_second",
+          "measurements": [
+            29.497849523230926,
+            29.26738853365739,
+            29.501809794860144,
+            29.518440088808994,
+            29.3628701632091
+          ],
+          "mean": 29.42967162075331,
+          "median": 29.497849523230926,
+          "std": 0.09851925553726182,
+          "min": 29.26738853365739,
+          "max": 29.518440088808994,
+          "p25": 29.3628701632091,
+          "p75": 29.501809794860144,
+          "p90": 29.511787971229452,
+          "p95": 29.515114030019223,
+          "p99": 29.51777487705104,
+          "unit": "tokens/sec"
+        },
+        "time_per_output_token_seconds": {
+          "name": "time_per_output_token_seconds",
+          "measurements": [
+            0.033900776367187496,
+            0.03416772216796875,
+            0.0338962255859375,
+            0.03387712890625,
+            0.0340566162109375
+          ],
+          "mean": 0.03397969384765625,
+          "median": 0.033900776367187496,
+          "std": 0.00011400542606022352,
+          "min": 0.03387712890625,
+          "max": 0.03416772216796875,
+          "p25": 0.0338962255859375,
+          "p75": 0.0340566162109375,
+          "p90": 0.03412327978515625,
+          "p95": 0.0341455009765625,
+          "p99": 0.0341632779296875,
+          "unit": "seconds/token"
+        }
+      },
+      "gpu_metrics": {
+        "gpu_utilization_mean": 49.36363636363637,
+        "gpu_utilization_max": 50,
+        "gpu_utilization_min": 49,
+        "gpu_memory_used_mean": 15473.454545454546,
+        "gpu_memory_used_max": 15548,
+        "gpu_memory_used_min": 15466,
+        "sample_count": 11,
+        "gpu_monitoring_status": "success"
+      }
+    },
+    {
+      "scenario_name": "compiled_compile_max-autotune_sdpa_efficient_attention",
+      "metadata": {
+        "timestamp": "2025-09-16T14:38:59.784157",
+        "commit_id": null,
+        "hardware_info": {
+          "gpu_name": "NVIDIA A100-SXM4-80GB",
+          "gpu_memory_total_mb": 81920,
+          "cpu_count": 128,
+          "memory_total_mb": 515624,
+          "python_version": "3.10.12",
+          "torch_version": "2.8.0+cu126",
+          "cuda_version": "12.6"
+        },
+        "config": {
+          "name": "compiled",
+          "model_id": "Qwen/Qwen2-7B",
+          "variant": "compiled",
+          "warmup_iterations": 3,
+          "measurement_iterations": 5,
+          "num_tokens_to_generate": 100,
+          "device": "cuda",
+          "torch_dtype": "float16",
+          "compile_mode": "max-autotune",
+          "compile_options": {},
+          "use_cache": true,
+          "batch_size": 1,
+          "sequence_length": null,
+          "attn_implementation": "sdpa",
+          "sdpa_backend": "efficient_attention",
+          "custom_params": {}
+        }
+      },
+      "measurements": {
+        "latency_seconds": {
+          "name": "latency_seconds",
+          "measurements": [
+            3.035596923828125,
+            3.00609326171875,
+            3.00232421875,
+            3.015933837890625,
+            2.995167724609375
+          ],
+          "mean": 3.011023193359375,
+          "median": 3.00609326171875,
+          "std": 0.013995391622824113,
+          "min": 2.995167724609375,
+          "max": 3.035596923828125,
+          "p25": 3.00232421875,
+          "p75": 3.015933837890625,
+          "p90": 3.027731689453125,
+          "p95": 3.031664306640625,
+          "p99": 3.034810400390625,
+          "unit": "seconds"
+        },
+        "time_to_first_token_seconds": {
+          "name": "time_to_first_token_seconds",
+          "measurements": [
+            0.03213036727905273,
+            0.032091232299804685,
+            0.031181343078613283,
+            0.03160671997070313,
+            0.0317238712310791
+          ],
+          "mean": 0.03174670677185058,
+          "median": 0.0317238712310791,
+          "std": 0.00034803651999392436,
+          "min": 0.031181343078613283,
+          "max": 0.03213036727905273,
+          "p25": 0.03160671997070313,
+          "p75": 0.032091232299804685,
+          "p90": 0.03211471328735351,
+          "p95": 0.032122540283203126,
+          "p99": 0.03212880187988281,
+          "unit": "seconds"
+        },
+        "tokens_per_second": {
+          "name": "tokens_per_second",
+          "measurements": [
+            32.94245003842347,
+            33.26576765712999,
+            33.30752867244777,
+            33.1572260450982,
+            33.38711190640979
+          ],
+          "mean": 33.212016863901844,
+          "median": 33.26576765712999,
+          "std": 0.15384292930056287,
+          "min": 32.94245003842347,
+          "max": 33.38711190640979,
+          "p25": 33.1572260450982,
+          "p75": 33.30752867244777,
+          "p90": 33.35527861282498,
+          "p95": 33.37119525961739,
+          "p99": 33.383928577051314,
+          "unit": "tokens/sec"
+        },
+        "time_per_output_token_seconds": {
+          "name": "time_per_output_token_seconds",
+          "measurements": [
+            0.030355969238281252,
+            0.0300609326171875,
+            0.0300232421875,
+            0.030159338378906247,
+            0.029951677246093752
+          ],
+          "mean": 0.030110231933593752,
+          "median": 0.0300609326171875,
+          "std": 0.0001399539162282414,
+          "min": 0.029951677246093752,
+          "max": 0.030355969238281252,
+          "p25": 0.0300232421875,
+          "p75": 0.030159338378906247,
+          "p90": 0.03027731689453125,
+          "p95": 0.030316643066406253,
+          "p99": 0.03034810400390625,
+          "unit": "seconds/token"
+        }
+      },
+      "gpu_metrics": {
+        "gpu_utilization_mean": 50.4,
+        "gpu_utilization_max": 51,
+        "gpu_utilization_min": 50,
+        "gpu_memory_used_mean": 15466,
+        "gpu_memory_used_max": 15466,
+        "gpu_memory_used_min": 15466,
+        "sample_count": 10,
+        "gpu_monitoring_status": "success"
+      }
+    }
+  ]
+}

benchmark_results/benchmark_summary_20250916_144139.json

@@ -0,0 +1,17 @@
+{
+  "run_metadata": {
+    "timestamp": "2025-09-16T14:41:39.732037",
+    "total_benchmarks": 6,
+    "successful_benchmarks": 5,
+    "failed_benchmarks": 1
+  },
+  "benchmark_results": {
+    "gpt2": "benchmark_results/gpt2/gpt2_benchmark_20250916_143134.json",
+    "qwen2": "benchmark_results/Qwen2-7B/Qwen2-7B_benchmark_20250916_143929.json",
+    "llama": "completed",
+    "bert": "benchmark_results/bert-base-uncased/bert-base-uncased_benchmark_20250916_144120.json",
+    "mistral3": "completed",
+    "gemma3": null
+  },
+  "output_directory": "benchmark_results"
+}

benchmark_results/benchmark_summary_20250916_144602.json

@@ -0,0 +1,12 @@
+{
+  "run_metadata": {
+    "timestamp": "2025-09-16T14:46:02.029823",
+    "total_benchmarks": 1,
+    "successful_benchmarks": 1,
+    "failed_benchmarks": 0
+  },
+  "benchmark_results": {
+    "gemma3": "completed"
+  },
+  "output_directory": "benchmark_results"
+}

benchmark_results/bert-base-uncased/bert-base-uncased_benchmark_20250916_144120.json

@@ -0,0 +1,655 @@
+{
+  "model_name": "bert-base-uncased",
+  "benchmark_scenarios": [
+    {
+      "scenario_name": "eager_eager_attn",
+      "metadata": {
+        "timestamp": "2025-09-16T14:39:55.683061",
+        "commit_id": null,
+        "hardware_info": {
+          "gpu_name": "NVIDIA A100-SXM4-80GB",
+          "gpu_memory_total_mb": 81920,
+          "cpu_count": 128,
+          "memory_total_mb": 515624,
+          "python_version": "3.10.12",
+          "torch_version": "2.8.0+cu126",
+          "cuda_version": "12.6"
+        },
+        "config": {
+          "name": "eager",
+          "model_id": "bert-base-uncased",
+          "variant": "eager",
+          "warmup_iterations": 3,
+          "measurement_iterations": 5,
+          "num_tokens_to_generate": 100,
+          "device": "cuda",
+          "torch_dtype": "float16",
+          "compile_mode": null,
+          "compile_options": {},
+          "use_cache": true,
+          "batch_size": 1,
+          "sequence_length": null,
+          "attn_implementation": "eager",
+          "sdpa_backend": null,
+          "custom_params": {}
+        }
+      },
+      "measurements": {
+        "latency_seconds": {
+          "name": "latency_seconds",
+          "measurements": [
+            0.7486727905273437,
+            0.7513528442382813,
+            0.7562908935546875,
+            0.7610662841796875,
+            0.7663279418945312
+          ],
+          "mean": 0.7567421508789062,
+          "median": 0.7562908935546875,
+          "std": 0.006402317610379491,
+          "min": 0.7486727905273437,
+          "max": 0.7663279418945312,
+          "p25": 0.7513528442382813,
+          "p75": 0.7610662841796875,
+          "p90": 0.7642232788085938,
+          "p95": 0.7652756103515624,
+          "p99": 0.7661174755859375,
+          "unit": "seconds"
+        },
+        "time_to_first_token_seconds": {
+          "name": "time_to_first_token_seconds",
+          "measurements": [
+            0.00977513599395752,
+            0.009344575881958007,
+            0.009353856086730956,
+            0.009663392066955566,
+            0.009657343864440919
+          ],
+          "mean": 0.009558860778808593,
+          "median": 0.009657343864440919,
+          "std": 0.00017626435705335133,
+          "min": 0.009344575881958007,
+          "max": 0.00977513599395752,
+          "p25": 0.009353856086730956,
+          "p75": 0.009663392066955566,
+          "p90": 0.009730438423156738,
+          "p95": 0.009752787208557129,
+          "p99": 0.009770666236877442,
+          "unit": "seconds"
+        },
+        "tokens_per_second": {
+          "name": "tokens_per_second",
+          "measurements": [
+            133.56969996139816,
+            133.09326073208604,
+            132.22425504819196,
+            131.39460002197396,
+            130.49243611394098
+          ],
+          "mean": 132.1548503755182,
+          "median": 132.22425504819196,
+          "std": 1.1161390714177948,
+          "min": 130.49243611394098,
+          "max": 133.56969996139816,
+          "p25": 131.39460002197396,
+          "p75": 133.09326073208604,
+          "p90": 133.3791242696733,
+          "p95": 133.47441211553573,
+          "p99": 133.55064239222568,
+          "unit": "tokens/sec"
+        },
+        "time_per_output_token_seconds": {
+          "name": "time_per_output_token_seconds",
+          "measurements": [
+            0.007486727905273437,
+            0.007513528442382813,
+            0.0075629089355468745,
+            0.007610662841796875,
+            0.007663279418945313
+          ],
+          "mean": 0.0075674215087890625,
+          "median": 0.0075629089355468745,
+          "std": 6.402317610379502e-05,
+          "min": 0.007486727905273437,
+          "max": 0.007663279418945313,
+          "p25": 0.007513528442382813,
+          "p75": 0.007610662841796875,
+          "p90": 0.007642232788085937,
+          "p95": 0.007652756103515625,
+          "p99": 0.007661174755859375,
+          "unit": "seconds/token"
+        }
+      },
+      "gpu_metrics": {
+        "gpu_utilization_mean": 17,
+        "gpu_utilization_max": 17,
+        "gpu_utilization_min": 17,
+        "gpu_memory_used_mean": 994,
+        "gpu_memory_used_max": 994,
+        "gpu_memory_used_min": 994,
+        "sample_count": 3,
+        "gpu_monitoring_status": "success"
+      }
+    },
+    {
+      "scenario_name": "eager_sdpa_default",
+      "metadata": {
+        "timestamp": "2025-09-16T14:40:13.059054",
+        "commit_id": null,
+        "hardware_info": {
+          "gpu_name": "NVIDIA A100-SXM4-80GB",
+          "gpu_memory_total_mb": 81920,
+          "cpu_count": 128,
+          "memory_total_mb": 515624,
+          "python_version": "3.10.12",
+          "torch_version": "2.8.0+cu126",
+          "cuda_version": "12.6"
+        },
+        "config": {
+          "name": "eager",
+          "model_id": "bert-base-uncased",
+          "variant": "eager",
+          "warmup_iterations": 3,
+          "measurement_iterations": 5,
+          "num_tokens_to_generate": 100,
+          "device": "cuda",
+          "torch_dtype": "float16",
+          "compile_mode": null,
+          "compile_options": {},
+          "use_cache": true,
+          "batch_size": 1,
+          "sequence_length": null,
+          "attn_implementation": "sdpa",
+          "sdpa_backend": null,
+          "custom_params": {}
+        }
+      },
+      "measurements": {
+        "latency_seconds": {
+          "name": "latency_seconds",
+          "measurements": [
+            0.6406459350585938,
+            0.643911376953125,
+            0.6423768920898437,
+            0.6458036499023437,
+            0.6438418579101562
+          ],
+          "mean": 0.6433159423828125,
+          "median": 0.6438418579101562,
+          "std": 0.001722241140854726,
+          "min": 0.6406459350585938,
+          "max": 0.6458036499023437,
+          "p25": 0.6423768920898437,
+          "p75": 0.643911376953125,
+          "p90": 0.6450467407226562,
+          "p95": 0.6454251953125,
+          "p99": 0.645727958984375,
+          "unit": "seconds"
+        },
+        "time_to_first_token_seconds": {
+          "name": "time_to_first_token_seconds",
+          "measurements": [
+            0.008202624320983887,
+            0.007760159969329834,
+            0.007827231884002686,
+            0.007747360229492187,
+            0.0077948799133300785
+          ],
+          "mean": 0.007866451263427733,
+          "median": 0.0077948799133300785,
+          "std": 0.00017038395233635333,
+          "min": 0.007747360229492187,
+          "max": 0.008202624320983887,
+          "p25": 0.007760159969329834,
+          "p75": 0.007827231884002686,
+          "p90": 0.008052467346191406,
+          "p95": 0.008127545833587647,
+          "p99": 0.00818760862350464,
+          "unit": "seconds"
+        },
+        "tokens_per_second": {
+          "name": "tokens_per_second",
+          "measurements": [
+            156.09246001202513,
+            155.30087459113142,
+            155.67185126269123,
+            154.84582661482582,
+            155.31764325573613
+          ],
+          "mean": 155.44573114728195,
+          "median": 155.31764325573613,
+          "std": 0.4163325375145587,
+          "min": 154.84582661482582,
+          "max": 156.09246001202513,
+          "p25": 155.30087459113142,
+          "p75": 155.67185126269123,
+          "p90": 155.92421651229157,
+          "p95": 156.00833826215836,
+          "p99": 156.07563566205178,
+          "unit": "tokens/sec"
+        },
+        "time_per_output_token_seconds": {
+          "name": "time_per_output_token_seconds",
+          "measurements": [
+            0.006406459350585938,
+            0.006439113769531249,
+            0.006423768920898437,
+            0.0064580364990234375,
+            0.006438418579101562
+          ],
+          "mean": 0.006433159423828124,
+          "median": 0.006438418579101562,
+          "std": 1.722241140854737e-05,
+          "min": 0.006406459350585938,
+          "max": 0.0064580364990234375,
+          "p25": 0.006423768920898437,
+          "p75": 0.006439113769531249,
+          "p90": 0.006450467407226562,
+          "p95": 0.006454251953125,
+          "p99": 0.00645727958984375,
+          "unit": "seconds/token"
+        }
+      },
+      "gpu_metrics": {
+        "gpu_utilization_mean": 18,
+        "gpu_utilization_max": 18,
+        "gpu_utilization_min": 18,
+        "gpu_memory_used_mean": 994,
+        "gpu_memory_used_max": 994,
+        "gpu_memory_used_min": 994,
+        "sample_count": 2,
+        "gpu_monitoring_status": "success"
+      }
+    },
+    {
+      "scenario_name": "eager_sdpa_math",
+      "metadata": {
+        "timestamp": "2025-09-16T14:40:27.225113",
+        "commit_id": null,
+        "hardware_info": {
+          "gpu_name": "NVIDIA A100-SXM4-80GB",
+          "gpu_memory_total_mb": 81920,
+          "cpu_count": 128,
+          "memory_total_mb": 515624,
+          "python_version": "3.10.12",
+          "torch_version": "2.8.0+cu126",
+          "cuda_version": "12.6"
+        },
+        "config": {
+          "name": "eager",
+          "model_id": "bert-base-uncased",
+          "variant": "eager",
+          "warmup_iterations": 3,
+          "measurement_iterations": 5,
+          "num_tokens_to_generate": 100,
+          "device": "cuda",
+          "torch_dtype": "float16",
+          "compile_mode": null,
+          "compile_options": {},
+          "use_cache": true,
+          "batch_size": 1,
+          "sequence_length": null,
+          "attn_implementation": "sdpa",
+          "sdpa_backend": "math",
+          "custom_params": {}
+        }
+      },
+      "measurements": {
+        "latency_seconds": {
+          "name": "latency_seconds",
+          "measurements": [
+            0.862056884765625,
+            0.836093505859375,
+            0.8566436767578125,
+            0.8781635131835938,
+            0.8709642333984375
+          ],
+          "mean": 0.8607843627929688,
+          "median": 0.862056884765625,
+          "std": 0.014381012780551117,
+          "min": 0.836093505859375,
+          "max": 0.8781635131835938,
+          "p25": 0.8566436767578125,
+          "p75": 0.8709642333984375,
+          "p90": 0.8752838012695313,
+          "p95": 0.8767236572265625,
+          "p99": 0.8778755419921875,
+          "unit": "seconds"
+        },
+        "time_to_first_token_seconds": {
+          "name": "time_to_first_token_seconds",
+          "measurements": [
+            0.01033017635345459,
+            0.010489888191223144,
+            0.010407615661621093,
+            0.010832351684570312,
+            0.010516511917114257
+          ],
+          "mean": 0.010515308761596679,
+          "median": 0.010489888191223144,
+          "std": 0.00017148508991502497,
+          "min": 0.01033017635345459,
+          "max": 0.010832351684570312,
+          "p25": 0.010407615661621093,
+          "p75": 0.010516511917114257,
+          "p90": 0.010706015777587891,
+          "p95": 0.010769183731079102,
+          "p99": 0.01081971809387207,
+          "unit": "seconds"
+        },
+        "tokens_per_second": {
+          "name": "tokens_per_second",
+          "measurements": [
+            116.00162560871824,
+            119.60384729602156,
+            116.73465025560643,
+            113.87400922348893,
+            114.81527732752865
+          ],
+          "mean": 116.20588194227278,
+          "median": 116.00162560871824,
+          "std": 1.9615757286128912,
+          "min": 113.87400922348893,
+          "max": 119.60384729602156,
+          "p25": 114.81527732752865,
+          "p75": 116.73465025560643,
+          "p90": 118.4561684798555,
+          "p95": 119.03000788793852,
+          "p99": 119.48907941440496,
+          "unit": "tokens/sec"
+        },
+        "time_per_output_token_seconds": {
+          "name": "time_per_output_token_seconds",
+          "measurements": [
+            0.008620568847656251,
+            0.00836093505859375,
+            0.008566436767578125,
+            0.008781635131835937,
+            0.008709642333984375
+          ],
+          "mean": 0.008607843627929688,
+          "median": 0.008620568847656251,
+          "std": 0.0001438101278055114,
+          "min": 0.00836093505859375,
+          "max": 0.008781635131835937,
+          "p25": 0.008566436767578125,
+          "p75": 0.008709642333984375,
+          "p90": 0.008752838012695312,
+          "p95": 0.008767236572265625,
+          "p99": 0.008778755419921874,
+          "unit": "seconds/token"
+        }
+      },
+      "gpu_metrics": {
+        "gpu_utilization_mean": 19.333333333333332,
+        "gpu_utilization_max": 20,
+        "gpu_utilization_min": 19,
+        "gpu_memory_used_mean": 1140.3333333333333,
+        "gpu_memory_used_max": 1416,
+        "gpu_memory_used_min": 994,
+        "sample_count": 3,
+        "gpu_monitoring_status": "success"
+      }
+    },
+    {
+      "scenario_name": "eager_sdpa_flash_attention",
+      "metadata": {
+        "timestamp": "2025-09-16T14:40:42.533371",
+        "commit_id": null,
+        "hardware_info": {
+          "gpu_name": "NVIDIA A100-SXM4-80GB",
+          "gpu_memory_total_mb": 81920,
+          "cpu_count": 128,
+          "memory_total_mb": 515624,
+          "python_version": "3.10.12",
+          "torch_version": "2.8.0+cu126",
+          "cuda_version": "12.6"
+        },
+        "config": {
+          "name": "eager",
+          "model_id": "bert-base-uncased",
+          "variant": "eager",
+          "warmup_iterations": 3,
+          "measurement_iterations": 5,
+          "num_tokens_to_generate": 100,
+          "device": "cuda",
+          "torch_dtype": "float16",
+          "compile_mode": null,
+          "compile_options": {},
+          "use_cache": true,
+          "batch_size": 1,
+          "sequence_length": null,
+          "attn_implementation": "sdpa",
+          "sdpa_backend": "flash_attention",
+          "custom_params": {}
+        }
+      },
+      "measurements": {
+        "latency_seconds": {
+          "name": "latency_seconds",
+          "measurements": [
+            0.6530625,
+            0.6555455932617188,
+            0.6554682006835938,
+            0.653178955078125,
+            0.6511043090820312
+          ],
+          "mean": 0.6536719116210937,
+          "median": 0.653178955078125,
+          "std": 0.0016699885485986382,
+          "min": 0.6511043090820312,
+          "max": 0.6555455932617188,
+          "p25": 0.6530625,
+          "p75": 0.6554682006835938,
+          "p90": 0.6555146362304688,
+          "p95": 0.6555301147460938,
+          "p99": 0.6555424975585938,
+          "unit": "seconds"
+        },
+        "time_to_first_token_seconds": {
+          "name": "time_to_first_token_seconds",
+          "measurements": [
+            0.008492608070373536,
+            0.008032447814941406,
+            0.008033151626586915,
+            0.008091520309448243,
+            0.008013664245605468
+          ],
+          "mean": 0.008132678413391114,
+          "median": 0.008033151626586915,
+          "std": 0.00018185679739098057,
+          "min": 0.008013664245605468,
+          "max": 0.008492608070373536,
+          "p25": 0.008032447814941406,
+          "p75": 0.008091520309448243,
+          "p90": 0.008332172966003418,
+          "p95": 0.008412390518188477,
+          "p99": 0.008476564559936523,
+          "unit": "seconds"
+        },
+        "tokens_per_second": {
+          "name": "tokens_per_second",
+          "measurements": [
+            153.1247009283185,
+            152.54469106022376,
+            152.5627023488082,
+            153.0974003717546,
+            153.58522222189936
+          ],
+          "mean": 152.98294338620087,
+          "median": 153.0974003717546,
+          "std": 0.3910506435112546,
+          "min": 152.54469106022376,
+          "max": 153.58522222189936,
+          "p25": 152.5627023488082,
+          "p75": 153.1247009283185,
+          "p90": 153.401013704467,
+          "p95": 153.49311796318318,
+          "p99": 153.56680137015613,
+          "unit": "tokens/sec"
+        },
+        "time_per_output_token_seconds": {
+          "name": "time_per_output_token_seconds",
+          "measurements": [
+            0.006530625,
+            0.006555455932617188,
+            0.006554682006835938,
+            0.006531789550781249,
+            0.006511043090820312
+          ],
+          "mean": 0.0065367191162109374,
+          "median": 0.006531789550781249,
+          "std": 1.6699885485986405e-05,
+          "min": 0.006511043090820312,
+          "max": 0.006555455932617188,
+          "p25": 0.006530625,
+          "p75": 0.006554682006835938,
+          "p90": 0.006555146362304688,
+          "p95": 0.006555301147460938,
+          "p99": 0.006555424975585938,
+          "unit": "seconds/token"
+        }
+      },
+      "gpu_metrics": {
+        "gpu_utilization_mean": 17.5,
+        "gpu_utilization_max": 18,
+        "gpu_utilization_min": 17,
+        "gpu_memory_used_mean": 1416,
+        "gpu_memory_used_max": 1416,
+        "gpu_memory_used_min": 1416,
+        "sample_count": 2,
+        "gpu_monitoring_status": "success"
+      }
+    },
+    {
+      "scenario_name": "eager_sdpa_efficient_attention",
+      "metadata": {
+        "timestamp": "2025-09-16T14:40:55.420871",
+        "commit_id": null,
+        "hardware_info": {
+          "gpu_name": "NVIDIA A100-SXM4-80GB",
+          "gpu_memory_total_mb": 81920,
+          "cpu_count": 128,
+          "memory_total_mb": 515624,
+          "python_version": "3.10.12",
+          "torch_version": "2.8.0+cu126",
+          "cuda_version": "12.6"
+        },
+        "config": {
+          "name": "eager",
+          "model_id": "bert-base-uncased",
+          "variant": "eager",
+          "warmup_iterations": 3,
+          "measurement_iterations": 5,
+          "num_tokens_to_generate": 100,
+          "device": "cuda",
+          "torch_dtype": "float16",
+          "compile_mode": null,
+          "compile_options": {},
+          "use_cache": true,
+          "batch_size": 1,
+          "sequence_length": null,
+          "attn_implementation": "sdpa",
+          "sdpa_backend": "efficient_attention",
+          "custom_params": {}
+        }
+      },
+      "measurements": {
+        "latency_seconds": {
+          "name": "latency_seconds",
+          "measurements": [
+            0.6364302978515625,
+            0.6355804443359375,
+            0.6347394409179687,
+            0.6406351928710937,
+            0.636865478515625
+          ],
+          "mean": 0.6368501708984375,
+          "median": 0.6364302978515625,
+          "std": 0.0020283148486413094,
+          "min": 0.6347394409179687,
+          "max": 0.6406351928710937,
+          "p25": 0.6355804443359375,
+          "p75": 0.636865478515625,
+          "p90": 0.6391273071289062,
+          "p95": 0.63988125,
+          "p99": 0.6404844042968749,
+          "unit": "seconds"
+        },
+        "time_to_first_token_seconds": {
+          "name": "time_to_first_token_seconds",
+          "measurements": [
+            0.008025568008422851,
+            0.007955679893493653,
+            0.00798521614074707,
+            0.007934783935546875,
+            0.008005632400512695
+          ],
+          "mean": 0.007981376075744628,
+          "median": 0.00798521614074707,
+          "std": 3.282427033399499e-05,
+          "min": 0.007934783935546875,
+          "max": 0.008025568008422851,
+          "p25": 0.007955679893493653,
+          "p75": 0.008005632400512695,
+          "p90": 0.008017593765258789,
+          "p95": 0.00802158088684082,
+          "p99": 0.008024770584106444,
+          "unit": "seconds"
+        },
+        "tokens_per_second": {
+          "name": "tokens_per_second",
+          "measurements": [
+            157.1263975608582,
+            157.3364959403074,
+            157.5449602680726,
+            156.09507737443585,
+            157.01903050715688
+          ],
+          "mean": 157.0243923301662,
+          "median": 157.1263975608582,
+          "std": 0.49848966782029014,
+          "min": 156.09507737443585,
+          "max": 157.5449602680726,
+          "p25": 157.01903050715688,
+          "p75": 157.3364959403074,
+          "p90": 157.4615745369665,
+          "p95": 157.50326740251955,
+          "p99": 157.53662169496198,
+          "unit": "tokens/sec"
+        },
+        "time_per_output_token_seconds": {
+          "name": "time_per_output_token_seconds",
+          "measurements": [
+            0.006364302978515625,
+            0.006355804443359375,
+            0.006347394409179688,
+            0.006406351928710937,
+            0.00636865478515625
+          ],
+          "mean": 0.006368501708984375,
+          "median": 0.006364302978515625,
+          "std": 2.028314848641316e-05,
+          "min": 0.006347394409179688,
+          "max": 0.006406351928710937,
+          "p25": 0.006355804443359375,
+          "p75": 0.00636865478515625,
+          "p90": 0.006391273071289063,
+          "p95": 0.0063988125,
+          "p99": 0.00640484404296875,
+          "unit": "seconds/token"
+        }
+      },
+      "gpu_metrics": {
+        "gpu_utilization_mean": 18.5,
+        "gpu_utilization_max": 19,
+        "gpu_utilization_min": 18,
+        "gpu_memory_used_mean": 994,
+        "gpu_memory_used_max": 994,
+        "gpu_memory_used_min": 994,
+        "sample_count": 2,
+        "gpu_monitoring_status": "success"
+      }
+    }
+  ]
+}

benchmark_results/gpt2/gpt2_benchmark_20250916_143134.json

@@ -0,0 +1,1175 @@
+{
+  "model_name": "gpt2",
+  "benchmark_scenarios": [
+    {
+      "scenario_name": "eager_eager_attn",
+      "metadata": {
+        "timestamp": "2025-09-16T14:29:02.079552",
+        "commit_id": null,
+        "hardware_info": {
+          "gpu_name": "NVIDIA A100-SXM4-80GB",
+          "gpu_memory_total_mb": 81920,
+          "cpu_count": 128,
+          "memory_total_mb": 515624,
+          "python_version": "3.10.12",
+          "torch_version": "2.8.0+cu126",
+          "cuda_version": "12.6"
+        },
+        "config": {
+          "name": "eager",
+          "model_id": "gpt2",
+          "variant": "eager",
+          "warmup_iterations": 3,
+          "measurement_iterations": 5,
+          "num_tokens_to_generate": 100,
+          "device": "cuda",
+          "torch_dtype": "float16",
+          "compile_mode": null,
+          "compile_options": {},
+          "use_cache": true,
+          "batch_size": 1,
+          "sequence_length": null,
+          "attn_implementation": "eager",
+          "sdpa_backend": null,
+          "custom_params": {}
+        }
+      },
+      "measurements": {
+        "latency_seconds": {
+          "name": "latency_seconds",
+          "measurements": [
+            1.0541953125,
+            1.0639735107421875,
+            1.0578663330078124,
+            1.0600103759765624,
+            1.060989990234375
+          ],
+          "mean": 1.0594071044921873,
+          "median": 1.0600103759765624,
+          "std": 0.0032636875565412596,
+          "min": 1.0541953125,
+          "max": 1.0639735107421875,
+          "p25": 1.0578663330078124,
+          "p75": 1.060989990234375,
+          "p90": 1.0627801025390624,
+          "p95": 1.063376806640625,
+          "p99": 1.063854169921875,
+          "unit": "seconds"
+        },
+        "time_to_first_token_seconds": {
+          "name": "time_to_first_token_seconds",
+          "measurements": [
+            0.012086463928222655,
+            0.012136608123779298,
+            0.011906720161437989,
+            0.011981280326843261,
+            0.011886783599853516
+          ],
+          "mean": 0.011999571228027342,
+          "median": 0.011981280326843261,
+          "std": 9.798609987804252e-05,
+          "min": 0.011886783599853516,
+          "max": 0.012136608123779298,
+          "p25": 0.011906720161437989,
+          "p75": 0.012086463928222655,
+          "p90": 0.01211655044555664,
+          "p95": 0.01212657928466797,
+          "p99": 0.012134602355957032,
+          "unit": "seconds"
+        },
+        "tokens_per_second": {
+          "name": "tokens_per_second",
+          "measurements": [
+            94.85908238659522,
+            93.98730230627997,
+            94.52990125479444,
+            94.33869919232853,
+            94.25159607576485
+          ],
+          "mean": 94.3933162431526,
+          "median": 94.33869919232853,
+          "std": 0.29103556854877793,
+          "min": 93.98730230627997,
+          "max": 94.85908238659522,
+          "p25": 94.25159607576485,
+          "p75": 94.52990125479444,
+          "p90": 94.72740993387491,
+          "p95": 94.79324616023506,
+          "p99": 94.84591514132319,
+          "unit": "tokens/sec"
+        },
+        "time_per_output_token_seconds": {
+          "name": "time_per_output_token_seconds",
+          "measurements": [
+            0.010541953125000001,
+            0.010639735107421874,
+            0.010578663330078125,
+            0.010600103759765625,
+            0.010609899902343749
+          ],
+          "mean": 0.010594071044921875,
+          "median": 0.010600103759765625,
+          "std": 3.2636875565412244e-05,
+          "min": 0.010541953125000001,
+          "max": 0.010639735107421874,
+          "p25": 0.010578663330078125,
+          "p75": 0.010609899902343749,
+          "p90": 0.010627801025390625,
+          "p95": 0.010633768066406249,
+          "p99": 0.010638541699218748,
+          "unit": "seconds/token"
+        }
+      },
+      "gpu_metrics": {
+        "gpu_utilization_mean": 15.5,
+        "gpu_utilization_max": 16,
+        "gpu_utilization_min": 15,
+        "gpu_memory_used_mean": 32022,
+        "gpu_memory_used_max": 32022,
+        "gpu_memory_used_min": 32022,
+        "sample_count": 4,
+        "gpu_monitoring_status": "success"
+      }
+    },
+    {
+      "scenario_name": "compiled_compile_max-autotune_eager_attn",
+      "metadata": {
+        "timestamp": "2025-09-16T14:29:18.852198",
+        "commit_id": null,
+        "hardware_info": {
+          "gpu_name": "NVIDIA A100-SXM4-80GB",
+          "gpu_memory_total_mb": 81920,
+          "cpu_count": 128,
+          "memory_total_mb": 515624,
+          "python_version": "3.10.12",
+          "torch_version": "2.8.0+cu126",
+          "cuda_version": "12.6"
+        },
+        "config": {
+          "name": "compiled",
+          "model_id": "gpt2",
+          "variant": "compiled",
+          "warmup_iterations": 3,
+          "measurement_iterations": 5,
+          "num_tokens_to_generate": 100,
+          "device": "cuda",
+          "torch_dtype": "float16",
+          "compile_mode": "max-autotune",
+          "compile_options": {},
+          "use_cache": true,
+          "batch_size": 1,
+          "sequence_length": null,
+          "attn_implementation": "eager",
+          "sdpa_backend": null,
+          "custom_params": {}
+        }
+      },
+      "measurements": {
+        "latency_seconds": {
+          "name": "latency_seconds",
+          "measurements": [
+            2.321836669921875,
+            2.480459228515625,
+            3.250630126953125,
+            2.559803466796875,
+            3.32717822265625
+          ],
+          "mean": 2.78798154296875,
+          "median": 2.559803466796875,
+          "std": 0.41682202980379135,
+          "min": 2.321836669921875,
+          "max": 3.32717822265625,
+          "p25": 2.480459228515625,
+          "p75": 3.250630126953125,
+          "p90": 3.296558984375,
+          "p95": 3.311868603515625,
+          "p99": 3.324116298828125,
+          "unit": "seconds"
+        },
+        "time_to_first_token_seconds": {
+          "name": "time_to_first_token_seconds",
+          "measurements": [
+            0.013586976051330567,
+            0.012644543647766113,
+            0.012610912322998047,
+            0.012712160110473632,
+            0.012882143974304198
+          ],
+          "mean": 0.012887347221374513,
+          "median": 0.012712160110473632,
+          "std": 0.00036209609931866615,
+          "min": 0.012610912322998047,
+          "max": 0.013586976051330567,
+          "p25": 0.012644543647766113,
+          "p75": 0.012882143974304198,
+          "p90": 0.01330504322052002,
+          "p95": 0.013446009635925293,
+          "p99": 0.013558782768249513,
+          "unit": "seconds"
+        },
+        "tokens_per_second": {
+          "name": "tokens_per_second",
+          "measurements": [
+            43.06935164537857,
+            40.3151153828248,
+            30.76326622670289,
+            39.06549908893267,
+            30.055498475872174
+          ],
+          "mean": 36.653746163942216,
+          "median": 39.06549908893267,
+          "std": 5.265297652854161,
+          "min": 30.055498475872174,
+          "max": 43.06935164537857,
+          "p25": 30.76326622670289,
+          "p75": 40.3151153828248,
+          "p90": 41.96765714035706,
+          "p95": 42.51850439286781,
+          "p99": 42.95918219487642,
+          "unit": "tokens/sec"
+        },
+        "time_per_output_token_seconds": {
+          "name": "time_per_output_token_seconds",
+          "measurements": [
+            0.02321836669921875,
+            0.02480459228515625,
+            0.03250630126953125,
+            0.02559803466796875,
+            0.0332717822265625
+          ],
+          "mean": 0.0278798154296875,
+          "median": 0.02559803466796875,
+          "std": 0.004168220298037914,
+          "min": 0.02321836669921875,
+          "max": 0.0332717822265625,
+          "p25": 0.02480459228515625,
+          "p75": 0.03250630126953125,
+          "p90": 0.03296558984375,
+          "p95": 0.03311868603515625,
+          "p99": 0.033241162988281246,
+          "unit": "seconds/token"
+        }
+      },
+      "gpu_metrics": {
+        "gpu_utilization_mean": 4,
+        "gpu_utilization_max": 25,
+        "gpu_utilization_min": 0,
+        "gpu_memory_used_mean": 32112.5,
+        "gpu_memory_used_max": 32126,
+        "gpu_memory_used_min": 32096,
+        "sample_count": 8,
+        "gpu_monitoring_status": "success"
+      }
+    },
+    {
+      "scenario_name": "eager_sdpa_default",
+      "metadata": {
+        "timestamp": "2025-09-16T14:29:57.578821",
+        "commit_id": null,
+        "hardware_info": {
+          "gpu_name": "NVIDIA A100-SXM4-80GB",
+          "gpu_memory_total_mb": 81920,
+          "cpu_count": 128,
+          "memory_total_mb": 515624,
+          "python_version": "3.10.12",
+          "torch_version": "2.8.0+cu126",
+          "cuda_version": "12.6"
+        },
+        "config": {
+          "name": "eager",
+          "model_id": "gpt2",
+          "variant": "eager",
+          "warmup_iterations": 3,
+          "measurement_iterations": 5,
+          "num_tokens_to_generate": 100,
+          "device": "cuda",
+          "torch_dtype": "float16",
+          "compile_mode": null,
+          "compile_options": {},
+          "use_cache": true,
+          "batch_size": 1,
+          "sequence_length": null,
+          "attn_implementation": "sdpa",
+          "sdpa_backend": null,
+          "custom_params": {}
+        }
+      },
+      "measurements": {
+        "latency_seconds": {
+          "name": "latency_seconds",
+          "measurements": [
+            0.6811693725585938,
+            0.6940160522460938,
+            0.6914998168945312,
+            0.6926322021484375,
+            0.6934620971679688
+          ],
+          "mean": 0.690555908203125,
+          "median": 0.6926322021484375,
+          "std": 0.004769225150243603,
+          "min": 0.6811693725585938,
+          "max": 0.6940160522460938,
+          "p25": 0.6914998168945312,
+          "p75": 0.6934620971679688,
+          "p90": 0.6937944702148438,
+          "p95": 0.6939052612304688,
+          "p99": 0.6939938940429687,
+          "unit": "seconds"
+        },
+        "time_to_first_token_seconds": {
+          "name": "time_to_first_token_seconds",
+          "measurements": [
+            0.008297727584838868,
+            0.008120736122131348,
+            0.008297151565551757,
+            0.00855510425567627,
+            0.008345760345458985
+          ],
+          "mean": 0.008323295974731446,
+          "median": 0.008297727584838868,
+          "std": 0.00013900179397777972,
+          "min": 0.008120736122131348,
+          "max": 0.00855510425567627,
+          "p25": 0.008297151565551757,
+          "p75": 0.008345760345458985,
+          "p90": 0.008471366691589356,
+          "p95": 0.008513235473632813,
+          "p99": 0.008546730499267578,
+          "unit": "seconds"
+        },
+        "tokens_per_second": {
+          "name": "tokens_per_second",
+          "measurements": [
+            146.80636568315182,
+            144.0888862388166,
+            144.6131980903361,
+            144.3767697918398,
+            144.20398808873648
+          ],
+          "mean": 144.81784157857618,
+          "median": 144.3767697918398,
+          "std": 1.009835965606756,
+          "min": 144.0888862388166,
+          "max": 146.80636568315182,
+          "p25": 144.20398808873648,
+          "p75": 144.6131980903361,
+          "p90": 145.92909864602555,
+          "p95": 146.3677321645887,
+          "p99": 146.7186389794392,
+          "unit": "tokens/sec"
+        },
+        "time_per_output_token_seconds": {
+          "name": "time_per_output_token_seconds",
+          "measurements": [
+            0.006811693725585937,
+            0.006940160522460937,
+            0.006914998168945312,
+            0.0069263220214843746,
+            0.006934620971679688
+          ],
+          "mean": 0.00690555908203125,
+          "median": 0.0069263220214843746,
+          "std": 4.7692251502436116e-05,
+          "min": 0.006811693725585937,
+          "max": 0.006940160522460937,
+          "p25": 0.006914998168945312,
+          "p75": 0.006934620971679688,
+          "p90": 0.006937944702148437,
+          "p95": 0.006939052612304687,
+          "p99": 0.006939938940429687,
+          "unit": "seconds/token"
+        }
+      },
+      "gpu_metrics": {
+        "gpu_utilization_mean": 20,
+        "gpu_utilization_max": 20,
+        "gpu_utilization_min": 20,
+        "gpu_memory_used_mean": 32154,
+        "gpu_memory_used_max": 32154,
+        "gpu_memory_used_min": 32154,
+        "sample_count": 3,
+        "gpu_monitoring_status": "success"
+      }
+    },
+    {
+      "scenario_name": "eager_sdpa_math",
+      "metadata": {
+        "timestamp": "2025-09-16T14:30:10.004302",
+        "commit_id": null,
+        "hardware_info": {
+          "gpu_name": "NVIDIA A100-SXM4-80GB",
+          "gpu_memory_total_mb": 81920,
+          "cpu_count": 128,
+          "memory_total_mb": 515624,
+          "python_version": "3.10.12",
+          "torch_version": "2.8.0+cu126",
+          "cuda_version": "12.6"
+        },
+        "config": {
+          "name": "eager",
+          "model_id": "gpt2",
+          "variant": "eager",
+          "warmup_iterations": 3,
+          "measurement_iterations": 5,
+          "num_tokens_to_generate": 100,
+          "device": "cuda",
+          "torch_dtype": "float16",
+          "compile_mode": null,
+          "compile_options": {},
+          "use_cache": true,
+          "batch_size": 1,
+          "sequence_length": null,
+          "attn_implementation": "sdpa",
+          "sdpa_backend": "math",
+          "custom_params": {}
+        }
+      },
+      "measurements": {
+        "latency_seconds": {
+          "name": "latency_seconds",
+          "measurements": [
+            0.8700221557617187,
+            0.8757317504882812,
+            0.8745044555664062,
+            0.8775747680664062,
+            0.8737710571289062
+          ],
+          "mean": 0.8743208374023437,
+          "median": 0.8745044555664062,
+          "std": 0.0025057285698685374,
+          "min": 0.8700221557617187,
+          "max": 0.8775747680664062,
+          "p25": 0.8737710571289062,
+          "p75": 0.8757317504882812,
+          "p90": 0.8768375610351562,
+          "p95": 0.8772061645507813,
+          "p99": 0.8775010473632813,
+          "unit": "seconds"
+        },
+        "time_to_first_token_seconds": {
+          "name": "time_to_first_token_seconds",
+          "measurements": [
+            0.011120479583740234,
+            0.011192288398742676,
+            0.011178720474243163,
+            0.011525568008422851,
+            0.011380319595336913
+          ],
+          "mean": 0.011279475212097167,
+          "median": 0.011192288398742676,
+          "std": 0.00015084026086821458,
+          "min": 0.011120479583740234,
+          "max": 0.011525568008422851,
+          "p25": 0.011178720474243163,
+          "p75": 0.011380319595336913,
+          "p90": 0.011467468643188476,
+          "p95": 0.011496518325805663,
+          "p99": 0.011519758071899413,
+          "unit": "seconds"
+        },
+        "tokens_per_second": {
+          "name": "tokens_per_second",
+          "measurements": [
+            114.93960163859086,
+            114.1902185734879,
+            114.350475133064,
+            113.95040472771772,
+            114.4464550343273
+          ],
+          "mean": 114.37543102143755,
+          "median": 114.350475133064,
+          "std": 0.3283006832948525,
+          "min": 113.95040472771772,
+          "max": 114.93960163859086,
+          "p25": 114.1902185734879,
+          "p75": 114.4464550343273,
+          "p90": 114.74234299688544,
+          "p95": 114.84097231773815,
+          "p99": 114.91987577442032,
+          "unit": "tokens/sec"
+        },
+        "time_per_output_token_seconds": {
+          "name": "time_per_output_token_seconds",
+          "measurements": [
+            0.008700221557617188,
+            0.008757317504882811,
+            0.008745044555664062,
+            0.008775747680664062,
+            0.008737710571289062
+          ],
+          "mean": 0.008743208374023436,
+          "median": 0.008745044555664062,
+          "std": 2.5057285698684983e-05,
+          "min": 0.008700221557617188,
+          "max": 0.008775747680664062,
+          "p25": 0.008737710571289062,
+          "p75": 0.008757317504882811,
+          "p90": 0.008768375610351561,
+          "p95": 0.008772061645507812,
+          "p99": 0.008775010473632812,
+          "unit": "seconds/token"
+        }
+      },
+      "gpu_metrics": {
+        "gpu_utilization_mean": 21.333333333333332,
+        "gpu_utilization_max": 22,
+        "gpu_utilization_min": 21,
+        "gpu_memory_used_mean": 32132,
+        "gpu_memory_used_max": 32132,
+        "gpu_memory_used_min": 32132,
+        "sample_count": 3,
+        "gpu_monitoring_status": "success"
+      }
+    },
+    {
+      "scenario_name": "eager_sdpa_flash_attention",
+      "metadata": {
+        "timestamp": "2025-09-16T14:30:23.342107",
+        "commit_id": null,
+        "hardware_info": {
+          "gpu_name": "NVIDIA A100-SXM4-80GB",
+          "gpu_memory_total_mb": 81920,
+          "cpu_count": 128,
+          "memory_total_mb": 515624,
+          "python_version": "3.10.12",
+          "torch_version": "2.8.0+cu126",
+          "cuda_version": "12.6"
+        },
+        "config": {
+          "name": "eager",
+          "model_id": "gpt2",
+          "variant": "eager",
+          "warmup_iterations": 3,
+          "measurement_iterations": 5,
+          "num_tokens_to_generate": 100,
+          "device": "cuda",
+          "torch_dtype": "float16",
+          "compile_mode": null,
+          "compile_options": {},
+          "use_cache": true,
+          "batch_size": 1,
+          "sequence_length": null,
+          "attn_implementation": "sdpa",
+          "sdpa_backend": "flash_attention",
+          "custom_params": {}
+        }
+      },
+      "measurements": {
+        "latency_seconds": {
+          "name": "latency_seconds",
+          "measurements": [
+            0.7245529174804688,
+            0.7257909545898438,
+            0.7065213012695313,
+            0.6885786743164063,
+            0.6876067504882812
+          ],
+          "mean": 0.7066101196289063,
+          "median": 0.7065213012695313,
+          "std": 0.01658986059009694,
+          "min": 0.6876067504882812,
+          "max": 0.7257909545898438,
+          "p25": 0.6885786743164063,
+          "p75": 0.7245529174804688,
+          "p90": 0.7252957397460937,
+          "p95": 0.7255433471679688,
+          "p99": 0.7257414331054688,
+          "unit": "seconds"
+        },
+        "time_to_first_token_seconds": {
+          "name": "time_to_first_token_seconds",
+          "measurements": [
+            0.008233535766601562,
+            0.008958335876464843,
+            0.009003999710083008,
+            0.00853872013092041,
+            0.008412192344665528
+          ],
+          "mean": 0.008629356765747071,
+          "median": 0.00853872013092041,
+          "std": 0.0003035240483883572,
+          "min": 0.008233535766601562,
+          "max": 0.009003999710083008,
+          "p25": 0.008412192344665528,
+          "p75": 0.008958335876464843,
+          "p90": 0.008985734176635743,
+          "p95": 0.008994866943359376,
+          "p99": 0.009002173156738283,
+          "unit": "seconds"
+        },
+        "tokens_per_second": {
+          "name": "tokens_per_second",
+          "measurements": [
+            138.01614428347895,
+            137.78071959647338,
+            141.5385492557866,
+            145.22668756664015,
+            145.43196373361417
+          ],
+          "mean": 141.59881288719868,
+          "median": 141.5385492557866,
+          "std": 3.3248008213166687,
+          "min": 137.78071959647338,
+          "max": 145.43196373361417,
+          "p25": 138.01614428347895,
+          "p75": 145.22668756664015,
+          "p90": 145.34985326682457,
+          "p95": 145.39090850021935,
+          "p99": 145.42375268693522,
+          "unit": "tokens/sec"
+        },
+        "time_per_output_token_seconds": {
+          "name": "time_per_output_token_seconds",
+          "measurements": [
+            0.007245529174804688,
+            0.0072579095458984375,
+            0.0070652130126953126,
+            0.006885786743164063,
+            0.006876067504882812
+          ],
+          "mean": 0.007066101196289062,
+          "median": 0.0070652130126953126,
+          "std": 0.00016589860590096936,
+          "min": 0.006876067504882812,
+          "max": 0.0072579095458984375,
+          "p25": 0.006885786743164063,
+          "p75": 0.007245529174804688,
+          "p90": 0.007252957397460937,
+          "p95": 0.007255433471679688,
+          "p99": 0.007257414331054687,
+          "unit": "seconds/token"
+        }
+      },
+      "gpu_metrics": {
+        "gpu_utilization_mean": 20,
+        "gpu_utilization_max": 20,
+        "gpu_utilization_min": 20,
+        "gpu_memory_used_mean": 922,
+        "gpu_memory_used_max": 922,
+        "gpu_memory_used_min": 922,
+        "sample_count": 2,
+        "gpu_monitoring_status": "success"
+      }
+    },
+    {
+      "scenario_name": "eager_sdpa_efficient_attention",
+      "metadata": {
+        "timestamp": "2025-09-16T14:30:35.101570",
+        "commit_id": null,
+        "hardware_info": {
+          "gpu_name": "NVIDIA A100-SXM4-80GB",
+          "gpu_memory_total_mb": 81920,
+          "cpu_count": 128,
+          "memory_total_mb": 515624,
+          "python_version": "3.10.12",
+          "torch_version": "2.8.0+cu126",
+          "cuda_version": "12.6"
+        },
+        "config": {
+          "name": "eager",
+          "model_id": "gpt2",
+          "variant": "eager",
+          "warmup_iterations": 3,
+          "measurement_iterations": 5,
+          "num_tokens_to_generate": 100,
+          "device": "cuda",
+          "torch_dtype": "float16",
+          "compile_mode": null,
+          "compile_options": {},
+          "use_cache": true,
+          "batch_size": 1,
+          "sequence_length": null,
+          "attn_implementation": "sdpa",
+          "sdpa_backend": "efficient_attention",
+          "custom_params": {}
+        }
+      },
+      "measurements": {
+        "latency_seconds": {
+          "name": "latency_seconds",
+          "measurements": [
+            0.688720458984375,
+            0.6877328491210938,
+            0.688767822265625,
+            0.6873019409179687,
+            0.6927123413085937
+          ],
+          "mean": 0.6890470825195312,
+          "median": 0.688720458984375,
+          "std": 0.0019178904999505159,
+          "min": 0.6873019409179687,
+          "max": 0.6927123413085937,
+          "p25": 0.6877328491210938,
+          "p75": 0.688767822265625,
+          "p90": 0.6911345336914062,
+          "p95": 0.6919234375,
+          "p99": 0.6925545605468749,
+          "unit": "seconds"
+        },
+        "time_to_first_token_seconds": {
+          "name": "time_to_first_token_seconds",
+          "measurements": [
+            0.008227007865905762,
+            0.008864255905151367,
+            0.008487392425537109,
+            0.008654623985290528,
+            0.008882783889770507
+          ],
+          "mean": 0.008623212814331056,
+          "median": 0.008654623985290528,
+          "std": 0.0002457198061479278,
+          "min": 0.008227007865905762,
+          "max": 0.008882783889770507,
+          "p25": 0.008487392425537109,
+          "p75": 0.008864255905151367,
+          "p90": 0.008875372695922852,
+          "p95": 0.00887907829284668,
+          "p99": 0.008882042770385741,
+          "unit": "seconds"
+        },
+        "tokens_per_second": {
+          "name": "tokens_per_second",
+          "measurements": [
+            145.19679021509756,
+            145.40529818780306,
+            145.18680572367788,
+            145.49646093889797,
+            144.360066995618
+          ],
+          "mean": 145.1290844122189,
+          "median": 145.19679021509756,
+          "std": 0.4026321335295338,
+          "min": 144.360066995618,
+          "max": 145.49646093889797,
+          "p25": 145.18680572367788,
+          "p75": 145.40529818780306,
+          "p90": 145.45999583846,
+          "p95": 145.47822838867899,
+          "p99": 145.49281442885416,
+          "unit": "tokens/sec"
+        },
+        "time_per_output_token_seconds": {
+          "name": "time_per_output_token_seconds",
+          "measurements": [
+            0.006887204589843749,
+            0.006877328491210938,
+            0.006887678222656251,
+            0.006873019409179687,
+            0.006927123413085937
+          ],
+          "mean": 0.006890470825195312,
+          "median": 0.006887204589843749,
+          "std": 1.917890499950527e-05,
+          "min": 0.006873019409179687,
+          "max": 0.006927123413085937,
+          "p25": 0.006877328491210938,
+          "p75": 0.006887678222656251,
+          "p90": 0.006911345336914063,
+          "p95": 0.006919234375,
+          "p99": 0.00692554560546875,
+          "unit": "seconds/token"
+        }
+      },
+      "gpu_metrics": {
+        "gpu_utilization_mean": 20,
+        "gpu_utilization_max": 20,
+        "gpu_utilization_min": 20,
+        "gpu_memory_used_mean": 922,
+        "gpu_memory_used_max": 922,
+        "gpu_memory_used_min": 922,
+        "sample_count": 3,
+        "gpu_monitoring_status": "success"
+      }
+    },
+    {
+      "scenario_name": "compiled_compile_max-autotune_sdpa_default",
+      "metadata": {
+        "timestamp": "2025-09-16T14:30:49.306518",
+        "commit_id": null,
+        "hardware_info": {
+          "gpu_name": "NVIDIA A100-SXM4-80GB",
+          "gpu_memory_total_mb": 81920,
+          "cpu_count": 128,
+          "memory_total_mb": 515624,
+          "python_version": "3.10.12",
+          "torch_version": "2.8.0+cu126",
+          "cuda_version": "12.6"
+        },
+        "config": {
+          "name": "compiled",
+          "model_id": "gpt2",
+          "variant": "compiled",
+          "warmup_iterations": 3,
+          "measurement_iterations": 5,
+          "num_tokens_to_generate": 100,
+          "device": "cuda",
+          "torch_dtype": "float16",
+          "compile_mode": "max-autotune",
+          "compile_options": {},
+          "use_cache": true,
+          "batch_size": 1,
+          "sequence_length": null,
+          "attn_implementation": "sdpa",
+          "sdpa_backend": null,
+          "custom_params": {}
+        }
+      },
+      "measurements": {
+        "latency_seconds": {
+          "name": "latency_seconds",
+          "measurements": [
+            0.9974157104492187,
+            1.0014816284179688,
+            1.0079267578125,
+            1.012246337890625,
+            1.056821044921875
+          ],
+          "mean": 1.0151782958984374,
+          "median": 1.0079267578125,
+          "std": 0.021440185962401076,
+          "min": 0.9974157104492187,
+          "max": 1.056821044921875,
+          "p25": 1.0014816284179688,
+          "p75": 1.012246337890625,
+          "p90": 1.038991162109375,
+          "p95": 1.047906103515625,
+          "p99": 1.055038056640625,
+          "unit": "seconds"
+        },
+        "time_to_first_token_seconds": {
+          "name": "time_to_first_token_seconds",
+          "measurements": [
+            0.011328672409057617,
+            0.01172815990447998,
+            0.011475808143615722,
+            0.012047455787658692,
+            0.011731488227844238
+          ],
+          "mean": 0.01166231689453125,
+          "median": 0.01172815990447998,
+          "std": 0.0002463964687920149,
+          "min": 0.011328672409057617,
+          "max": 0.012047455787658692,
+          "p25": 0.011475808143615722,
+          "p75": 0.011731488227844238,
+          "p90": 0.01192106876373291,
+          "p95": 0.011984262275695802,
+          "p99": 0.012034817085266113,
+          "unit": "seconds"
+        },
+        "tokens_per_second": {
+          "name": "tokens_per_second",
+          "measurements": [
+            100.25909854072955,
+            99.85205635571076,
+            99.21355815280633,
+            98.79018205033523,
+            94.62339956278261
+          ],
+          "mean": 98.5476589324729,
+          "median": 99.21355815280633,
+          "std": 2.0264515294178453,
+          "min": 94.62339956278261,
+          "max": 100.25909854072955,
+          "p25": 98.79018205033523,
+          "p75": 99.85205635571076,
+          "p90": 100.09628166672204,
+          "p95": 100.1776901037258,
+          "p99": 100.2428168533288,
+          "unit": "tokens/sec"
+        },
+        "time_per_output_token_seconds": {
+          "name": "time_per_output_token_seconds",
+          "measurements": [
+            0.009974157104492187,
+            0.010014816284179688,
+            0.010079267578125,
+            0.01012246337890625,
+            0.010568210449218749
+          ],
+          "mean": 0.010151782958984374,
+          "median": 0.010079267578125,
+          "std": 0.00021440185962401083,
+          "min": 0.009974157104492187,
+          "max": 0.010568210449218749,
+          "p25": 0.010014816284179688,
+          "p75": 0.01012246337890625,
+          "p90": 0.01038991162109375,
+          "p95": 0.010479061035156249,
+          "p99": 0.010550380566406248,
+          "unit": "seconds/token"
+        }
+      },
+      "gpu_metrics": {
+        "gpu_utilization_mean": 16,
+        "gpu_utilization_max": 16,
+        "gpu_utilization_min": 16,
+        "gpu_memory_used_mean": 922,
+        "gpu_memory_used_max": 922,
+        "gpu_memory_used_min": 922,
+        "sample_count": 4,
+        "gpu_monitoring_status": "success"
+      }
+    },
+    {
+      "scenario_name": "compiled_compile_max-autotune_sdpa_math",
+      "metadata": {
+        "timestamp": "2025-09-16T14:31:03.520152",
+        "commit_id": null,
+        "hardware_info": {
+          "gpu_name": "NVIDIA A100-SXM4-80GB",
+          "gpu_memory_total_mb": 81920,
+          "cpu_count": 128,
+          "memory_total_mb": 515624,
+          "python_version": "3.10.12",
+          "torch_version": "2.8.0+cu126",
+          "cuda_version": "12.6"
+        },
+        "config": {
+          "name": "compiled",
+          "model_id": "gpt2",
+          "variant": "compiled",
+          "warmup_iterations": 3,
+          "measurement_iterations": 5,
+          "num_tokens_to_generate": 100,
+          "device": "cuda",
+          "torch_dtype": "float16",
+          "compile_mode": "max-autotune",
+          "compile_options": {},
+          "use_cache": true,
+          "batch_size": 1,
+          "sequence_length": null,
+          "attn_implementation": "sdpa",
+          "sdpa_backend": "math",
+          "custom_params": {}
+        }
+      },
+      "measurements": {
+        "latency_seconds": {
+          "name": "latency_seconds",
+          "measurements": [
+            1.1809921875,
+            1.17560693359375,
+            1.179835693359375,
+            1.1900877685546876,
+            1.196610107421875
+          ],
+          "mean": 1.1846265380859375,
+          "median": 1.1809921875,
+          "std": 0.007628170617298067,
+          "min": 1.17560693359375,
+          "max": 1.196610107421875,
+          "p25": 1.179835693359375,
+          "p75": 1.1900877685546876,
+          "p90": 1.1940011718749999,
+          "p95": 1.1953056396484374,
+          "p99": 1.1963492138671874,
+          "unit": "seconds"
+        },
+        "time_to_first_token_seconds": {
+          "name": "time_to_first_token_seconds",
+          "measurements": [
+            0.015000831604003907,
+            0.013680319786071777,
+            0.013097855567932129,
+            0.013719264030456544,
+            0.014447936058044434
+          ],
+          "mean": 0.013989241409301759,
+          "median": 0.013719264030456544,
+          "std": 0.0006628128808923555,
+          "min": 0.013097855567932129,
+          "max": 0.015000831604003907,
+          "p25": 0.013680319786071777,
+          "p75": 0.014447936058044434,
+          "p90": 0.014779673385620118,
+          "p95": 0.014890252494812012,
+          "p99": 0.014978715782165529,
+          "unit": "seconds"
+        },
+        "tokens_per_second": {
+          "name": "tokens_per_second",
+          "measurements": [
+            84.67456521595322,
+            85.06244488904709,
+            84.75756460229437,
+            84.02741599591926,
+            83.56940943399884
+          ],
+          "mean": 84.41828002744255,
+          "median": 84.67456521595322,
+          "std": 0.542051743851163,
+          "min": 83.56940943399884,
+          "max": 85.06244488904709,
+          "p25": 84.02741599591926,
+          "p75": 84.75756460229437,
+          "p90": 84.940492774346,
+          "p95": 85.00146883169654,
+          "p99": 85.05024967757697,
+          "unit": "tokens/sec"
+        },
+        "time_per_output_token_seconds": {
+          "name": "time_per_output_token_seconds",
+          "measurements": [
+            0.011809921875,
+            0.011756069335937501,
+            0.01179835693359375,
+            0.011900877685546875,
+            0.011966101074218749
+          ],
+          "mean": 0.011846265380859375,
+          "median": 0.011809921875,
+          "std": 7.62817061729803e-05,
+          "min": 0.011756069335937501,
+          "max": 0.011966101074218749,
+          "p25": 0.01179835693359375,
+          "p75": 0.011900877685546875,
+          "p90": 0.011940011718749999,
+          "p95": 0.011953056396484375,
+          "p99": 0.011963492138671874,
+          "unit": "seconds/token"
+        }
+      },
+      "gpu_metrics": {
+        "gpu_utilization_mean": 18,
+        "gpu_utilization_max": 18,
+        "gpu_utilization_min": 18,
+        "gpu_memory_used_mean": 922,
+        "gpu_memory_used_max": 922,
+        "gpu_memory_used_min": 922,
+        "sample_count": 4,
+        "gpu_monitoring_status": "success"
+      }
+    },
+    {
+      "scenario_name": "compiled_compile_max-autotune_sdpa_efficient_attention",
+      "metadata": {
+        "timestamp": "2025-09-16T14:31:21.084642",
+        "commit_id": null,
+        "hardware_info": {
+          "gpu_name": "NVIDIA A100-SXM4-80GB",
+          "gpu_memory_total_mb": 81920,
+          "cpu_count": 128,
+          "memory_total_mb": 515624,
+          "python_version": "3.10.12",
+          "torch_version": "2.8.0+cu126",
+          "cuda_version": "12.6"
+        },
+        "config": {
+          "name": "compiled",
+          "model_id": "gpt2",
+          "variant": "compiled",
+          "warmup_iterations": 3,
+          "measurement_iterations": 5,
+          "num_tokens_to_generate": 100,
+          "device": "cuda",
+          "torch_dtype": "float16",
+          "compile_mode": "max-autotune",
+          "compile_options": {},
+          "use_cache": true,
+          "batch_size": 1,
+          "sequence_length": null,
+          "attn_implementation": "sdpa",
+          "sdpa_backend": "efficient_attention",
+          "custom_params": {}
+        }
+      },
+      "measurements": {
+        "latency_seconds": {
+          "name": "latency_seconds",
+          "measurements": [
+            0.9932705688476563,
+            0.988389404296875,
+            0.9866908569335937,
+            1.03518359375,
+            0.9851827392578125
+          ],
+          "mean": 0.9977434326171875,
+          "median": 0.988389404296875,
+          "std": 0.01891666180211917,
+          "min": 0.9851827392578125,
+          "max": 1.03518359375,
+          "p25": 0.9866908569335937,
+          "p75": 0.9932705688476563,
+          "p90": 1.0184183837890626,
+          "p95": 1.0268009887695313,
+          "p99": 1.0335070727539062,
+          "unit": "seconds"
+        },
+        "time_to_first_token_seconds": {
+          "name": "time_to_first_token_seconds",
+          "measurements": [
+            0.011541312217712402,
+            0.011281023979187012,
+            0.011197983741760254,
+            0.010969951629638671,
+            0.011184351921081543
+          ],
+          "mean": 0.011234924697875976,
+          "median": 0.011197983741760254,
+          "std": 0.00018446214946782157,
+          "min": 0.010969951629638671,
+          "max": 0.011541312217712402,
+          "p25": 0.011184351921081543,
+          "p75": 0.011281023979187012,
+          "p90": 0.011437196922302245,
+          "p95": 0.011489254570007323,
+          "p99": 0.011530900688171386,
+          "unit": "seconds"
+        },
+        "tokens_per_second": {
+          "name": "tokens_per_second",
+          "measurements": [
+            100.67750232045543,
+            101.17469851990012,
+            101.34886656472808,
+            96.60122185451705,
+            101.50401140334128
+          ],
+          "mean": 100.26126013258839,
+          "median": 101.17469851990012,
+          "std": 1.8509903249618553,
+          "min": 96.60122185451705,
+          "max": 101.50401140334128,
+          "p25": 100.67750232045543,
+          "p75": 101.34886656472808,
+          "p90": 101.441953467896,
+          "p95": 101.47298243561865,
+          "p99": 101.49780560979676,
+          "unit": "tokens/sec"
+        },
+        "time_per_output_token_seconds": {
+          "name": "time_per_output_token_seconds",
+          "measurements": [
+            0.009932705688476562,
+            0.00988389404296875,
+            0.009866908569335937,
+            0.0103518359375,
+            0.009851827392578125
+          ],
+          "mean": 0.009977434326171875,
+          "median": 0.00988389404296875,
+          "std": 0.00018916661802119162,
+          "min": 0.009851827392578125,
+          "max": 0.0103518359375,
+          "p25": 0.009866908569335937,
+          "p75": 0.009932705688476562,
+          "p90": 0.010184183837890624,
+          "p95": 0.010268009887695313,
+          "p99": 0.010335070727539062,
+          "unit": "seconds/token"
+        }
+      },
+      "gpu_metrics": {
+        "gpu_utilization_mean": 15.333333333333334,
+        "gpu_utilization_max": 16,
+        "gpu_utilization_min": 14,
+        "gpu_memory_used_mean": 922,
+        "gpu_memory_used_max": 922,
+        "gpu_memory_used_min": 922,
+        "sample_count": 3,
+        "gpu_monitoring_status": "success"
+      }
+    }
+  ]
+}

dashboard.py

@@ -0,0 +1,541 @@
+#!/usr/bin/env python3
+"""
+LLM Inference Performance Dashboard
+
+A Gradio-based dashboard for visualizing and analyzing LLM inference benchmark results.
+Provides filtering, comparison, and historical analysis capabilities.
+"""
+
+import gradio as gr
+import plotly.graph_objects as go
+import plotly.express as px
+from plotly.subplots import make_subplots
+import pandas as pd
+import polars as pl
+from datetime import datetime
+from typing import List, Dict, Any, Optional, Tuple
+import logging
+
+from benchmark_data_reader import BenchmarkDataReader
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class BenchmarkDashboard:
+    """Main dashboard class for LLM inference performance visualization."""
+
+    def __init__(self):
+        """Initialize the dashboard and load data."""
+        self.reader = BenchmarkDataReader()
+        self.df = None
+        self.load_data()
+
+    def load_data(self) -> None:
+        """Load benchmark data from files."""
+        try:
+            self.df = self.reader.read_benchmark_files()
+            if not self.df.is_empty():
+                # Convert to pandas for easier plotting with plotly
+                self.df_pandas = self.df.to_pandas()
+                # Convert timestamp to datetime
+                self.df_pandas['timestamp'] = pd.to_datetime(self.df_pandas['timestamp'])
+                logger.info(f"Loaded {len(self.df_pandas)} benchmark scenarios")
+            else:
+                logger.warning("No benchmark data loaded")
+                self.df_pandas = pd.DataFrame()
+        except Exception as e:
+            logger.error(f"Error loading data: {e}")
+            self.df_pandas = pd.DataFrame()
+
+    def get_filter_options(self) -> Tuple[List[str], List[str], List[str], List[str], str, str]:
+        """Get unique values for filter dropdowns and date range."""
+        if self.df_pandas.empty:
+            return [], [], [], [], "", ""
+
+        models = sorted(self.df_pandas['model_name'].dropna().unique().tolist())
+        scenarios = sorted(self.df_pandas['scenario_name'].dropna().unique().tolist())
+        gpus = sorted(self.df_pandas['gpu_name'].dropna().unique().tolist())
+
+        # Get benchmark runs grouped by date (or commit_id if available)
+        benchmark_runs = []
+
+        # Group by commit_id if available, otherwise group by date
+        if self.df_pandas['commit_id'].notna().any():
+            # Group by commit_id
+            for commit_id in self.df_pandas['commit_id'].dropna().unique():
+                commit_data = self.df_pandas[self.df_pandas['commit_id'] == commit_id]
+                date_str = commit_data['timestamp'].min().strftime('%Y-%m-%d')
+                models_count = len(commit_data['model_name'].unique())
+                scenarios_count = len(commit_data['scenario_name'].unique())
+                run_id = f"Commit {commit_id[:8]} ({date_str}) - {models_count} models, {scenarios_count} scenarios"
+                benchmark_runs.append(run_id)
+        else:
+            # Group by date since commit_id is not available
+            self.df_pandas['date'] = self.df_pandas['timestamp'].dt.date
+            for date in sorted(self.df_pandas['date'].unique()):
+                date_data = self.df_pandas[self.df_pandas['date'] == date]
+                models_count = len(date_data['model_name'].unique())
+                scenarios_count = len(date_data['scenario_name'].unique())
+
+                # Check if any commit_id exists for this date (even if null)
+                unique_commits = date_data['commit_id'].dropna().unique()
+                if len(unique_commits) > 0:
+                    commit_display = f"Commit {unique_commits[0][:8]}"
+                else:
+                    commit_display = "No commit ID"
+
+                run_id = f"{date} - {commit_display} - {models_count} models, {scenarios_count} scenarios"
+                benchmark_runs.append(run_id)
+
+        benchmark_runs = sorted(benchmark_runs)
+
+        # Get date range
+        min_date = self.df_pandas['timestamp'].min().strftime('%Y-%m-%d')
+        max_date = self.df_pandas['timestamp'].max().strftime('%Y-%m-%d')
+
+        return models, scenarios, gpus, benchmark_runs, min_date, max_date
+
+    def filter_data(self, selected_models: List[str], selected_scenarios: List[str],
+                   selected_gpus: List[str], selected_run: str = None,
+                   start_date: str = None, end_date: str = None) -> pd.DataFrame:
+        """Filter data based on user selections."""
+        if self.df_pandas.empty:
+            return pd.DataFrame()
+
+        filtered_df = self.df_pandas.copy()
+
+        if selected_models:
+            filtered_df = filtered_df[filtered_df['model_name'].isin(selected_models)]
+        if selected_scenarios:
+            filtered_df = filtered_df[filtered_df['scenario_name'].isin(selected_scenarios)]
+        if selected_gpus:
+            filtered_df = filtered_df[filtered_df['gpu_name'].isin(selected_gpus)]
+
+        # Filter by date range
+        if start_date and end_date:
+            start_datetime = pd.to_datetime(start_date)
+            end_datetime = pd.to_datetime(end_date) + pd.Timedelta(days=1)  # Include end date
+            filtered_df = filtered_df[
+                (filtered_df['timestamp'] >= start_datetime) &
+                (filtered_df['timestamp'] < end_datetime)
+            ]
+
+        # Filter by specific benchmark run (commit or date-based grouping)
+        if selected_run:
+            if selected_run.startswith("Commit "):
+                # Extract commit_id from the run_id format: "Commit 12345678 (2025-09-16) - models"
+                try:
+                    commit_id_part = selected_run.split('Commit ')[1].split(' ')[0]  # Get commit hash
+                    # Find all data with this commit_id
+                    filtered_df = filtered_df[filtered_df['commit_id'] == commit_id_part]
+                except (IndexError, ValueError):
+                    # Fallback if parsing fails
+                    logger.warning(f"Failed to parse commit from: {selected_run}")
+            else:
+                # Date-based grouping format: "2025-09-16 - X models, Y scenarios"
+                try:
+                    date_str = selected_run.split(' - ')[0]
+                    selected_date = pd.to_datetime(date_str).date()
+
+                    # Add date column if not exists
+                    if 'date' not in filtered_df.columns:
+                        filtered_df = filtered_df.copy()
+                        filtered_df['date'] = filtered_df['timestamp'].dt.date
+
+                    # Filter by date
+                    filtered_df = filtered_df[filtered_df['date'] == selected_date]
+                except (IndexError, ValueError) as e:
+                    logger.warning(f"Failed to parse date from: {selected_run}, error: {e}")
+                    # Return empty dataframe if parsing fails
+                    filtered_df = filtered_df.iloc[0:0]
+
+        return filtered_df
+
+    def create_performance_comparison_chart(self, filtered_df: pd.DataFrame,
+                                          metric: str = "tokens_per_second_mean") -> go.Figure:
+        """Create performance comparison chart."""
+        if filtered_df.empty:
+            fig = go.Figure()
+            fig.add_annotation(text="No data available for selected filters",
+                             xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False)
+            return fig
+
+        # Create bar chart comparing performance across models and scenarios
+        fig = px.bar(
+            filtered_df,
+            x='scenario_name',
+            y=metric,
+            color='model_name',
+            title=f'Performance Comparison: {metric.replace("_", " ").title()}',
+            labels={
+                metric: metric.replace("_", " ").title(),
+                'scenario_name': 'Benchmark Scenario',
+                'model_name': 'Model'
+            },
+            hover_data=['gpu_name', 'timestamp']
+        )
+
+        fig.update_layout(
+            xaxis_tickangle=-45,
+            height=500,
+            showlegend=True,
+            plot_bgcolor='rgba(235, 242, 250, 1.0)',
+            paper_bgcolor='rgba(245, 248, 252, 0.7)'
+        )
+
+        return fig
+
+    def create_historical_trend_chart(self, filtered_df: pd.DataFrame,
+                                    metric: str = "tokens_per_second_mean") -> go.Figure:
+        """Create historical trend chart showing performance across different benchmark runs for the same scenarios."""
+        if filtered_df.empty:
+            fig = go.Figure()
+            fig.add_annotation(text="No data available for selected filters",
+                             xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False)
+            return fig
+
+        fig = go.Figure()
+
+        # Group by model and scenario combination to show trends across benchmark runs
+        for model in filtered_df['model_name'].unique():
+            model_data = filtered_df[filtered_df['model_name'] == model]
+
+            for scenario in model_data['scenario_name'].unique():
+                scenario_data = model_data[model_data['scenario_name'] == scenario]
+
+                # Sort by timestamp to show chronological progression
+                scenario_data = scenario_data.sort_values('timestamp')
+
+                # Only show trends if we have multiple data points for this model-scenario combination
+                if len(scenario_data) > 1:
+                    fig.add_trace(go.Scatter(
+                        x=scenario_data['timestamp'],
+                        y=scenario_data[metric],
+                        mode='lines+markers',
+                        name=f'{model} - {scenario}',
+                        line=dict(width=2),
+                        marker=dict(size=6),
+                        hovertemplate=f'<b>{model}</b><br>' +
+                                     f'Scenario: {scenario}<br>' +
+                                     'Time: %{x}<br>' +
+                                     f'{metric.replace("_", " ").title()}: %{{y}}<br>' +
+                                     '<extra></extra>'
+                    ))
+
+        # If no trends found (all scenarios have only single runs), show a message
+        if len(fig.data) == 0:
+            fig.add_annotation(
+                text="No historical trends available.<br>Each scenario only has one benchmark run.<br>Historical trends require multiple runs of the same scenario over time.",
+                xref="paper", yref="paper", x=0.5, y=0.5,
+                showarrow=False,
+                font=dict(size=14)
+            )
+
+        fig.update_layout(
+            title=f'Historical Trends Across Benchmark Runs: {metric.replace("_", " ").title()}',
+            xaxis_title='Timestamp',
+            yaxis_title=metric.replace("_", " ").title(),
+            height=500,
+            hovermode='closest',
+            showlegend=True,
+            plot_bgcolor='rgba(235, 242, 250, 1.0)',
+            paper_bgcolor='rgba(245, 248, 252, 0.7)'
+        )
+
+        return fig
+
+    def create_gpu_comparison_chart(self, filtered_df: pd.DataFrame) -> go.Figure:
+        """Create GPU utilization and memory usage comparison."""
+        if filtered_df.empty:
+            fig = go.Figure()
+            fig.add_annotation(text="No data available for selected filters",
+                             xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False)
+            return fig
+
+        # Create subplots for GPU metrics
+        fig = make_subplots(
+            rows=2, cols=2,
+            subplot_titles=('GPU Utilization Mean (%)', 'GPU Memory Used (MB)',
+                          'GPU Utilization vs Performance', 'Memory Usage vs Performance'),
+            specs=[[{"secondary_y": False}, {"secondary_y": False}],
+                   [{"secondary_y": False}, {"secondary_y": False}]]
+        )
+
+        # GPU Utilization bar chart
+        gpu_util_data = filtered_df.groupby(['model_name', 'gpu_name'])['gpu_gpu_utilization_mean'].mean().reset_index()
+        for model in gpu_util_data['model_name'].unique():
+            model_data = gpu_util_data[gpu_util_data['model_name'] == model]
+            fig.add_trace(
+                go.Bar(x=model_data['gpu_name'], y=model_data['gpu_gpu_utilization_mean'],
+                      name=f'{model} - Utilization', showlegend=True),
+                row=1, col=1
+            )
+
+        # GPU Memory Usage bar chart
+        gpu_mem_data = filtered_df.groupby(['model_name', 'gpu_name'])['gpu_gpu_memory_used_mean'].mean().reset_index()
+        for model in gpu_mem_data['model_name'].unique():
+            model_data = gpu_mem_data[gpu_mem_data['model_name'] == model]
+            fig.add_trace(
+                go.Bar(x=model_data['gpu_name'], y=model_data['gpu_gpu_memory_used_mean'],
+                      name=f'{model} - Memory', showlegend=True),
+                row=1, col=2
+            )
+
+        # GPU Utilization vs Performance scatter
+        fig.add_trace(
+            go.Scatter(x=filtered_df['gpu_gpu_utilization_mean'],
+                      y=filtered_df['tokens_per_second_mean'],
+                      mode='markers',
+                      text=filtered_df['model_name'],
+                      name='Util vs Performance',
+                      showlegend=True),
+            row=2, col=1
+        )
+
+        # Memory Usage vs Performance scatter
+        fig.add_trace(
+            go.Scatter(x=filtered_df['gpu_gpu_memory_used_mean'],
+                      y=filtered_df['tokens_per_second_mean'],
+                      mode='markers',
+                      text=filtered_df['model_name'],
+                      name='Memory vs Performance',
+                      showlegend=True),
+            row=2, col=2
+        )
+
+        fig.update_layout(
+            height=800,
+            title_text="GPU Performance Analysis",
+            plot_bgcolor='rgba(235, 242, 250, 1.0)',
+            paper_bgcolor='rgba(245, 248, 252, 0.7)'
+        )
+        return fig
+
+    def create_metrics_summary_table(self, filtered_df: pd.DataFrame) -> pd.DataFrame:
+        """Create summary statistics table."""
+        if filtered_df.empty:
+            return pd.DataFrame({'Message': ['No data available for selected filters']})
+
+        # Key performance metrics
+        metrics_cols = [
+            'tokens_per_second_mean', 'latency_seconds_mean',
+            'time_to_first_token_seconds_mean', 'time_per_output_token_seconds_mean'
+        ]
+
+        summary_data = []
+        for model in filtered_df['model_name'].unique():
+            model_data = filtered_df[filtered_df['model_name'] == model]
+
+            row = {'Model': model, 'Scenarios': len(model_data)}
+            for metric in metrics_cols:
+                if metric in model_data.columns:
+                    row[f'{metric.replace("_", " ").title()} (Avg)'] = f"{model_data[metric].mean():.2f}"
+                    row[f'{metric.replace("_", " ").title()} (Best)'] = f"{model_data[metric].min() if 'latency' in metric or 'time' in metric else model_data[metric].max():.2f}"
+
+            summary_data.append(row)
+
+        return pd.DataFrame(summary_data)
+
+    def update_dashboard(self, selected_models: List[str], selected_scenarios: List[str],
+                        selected_gpus: List[str], selected_run: str, metric: str):
+        """Update all dashboard components based on current filters."""
+        filtered_df = self.filter_data(
+            selected_models, selected_scenarios, selected_gpus, selected_run
+        )
+
+        # Create charts
+        perf_chart = self.create_performance_comparison_chart(filtered_df, metric)
+        gpu_chart = self.create_gpu_comparison_chart(filtered_df)
+        summary_table = self.create_metrics_summary_table(filtered_df)
+
+        # Summary stats
+        if not filtered_df.empty:
+            summary_text = f"""
+            **Data Summary:**
+            - Total Scenarios: {len(filtered_df)}
+            - Models: {', '.join(filtered_df['model_name'].unique())}
+            - Date Range: {filtered_df['timestamp'].min().strftime('%Y-%m-%d')} to {filtered_df['timestamp'].max().strftime('%Y-%m-%d')}
+            - Benchmark Runs: {len(filtered_df.groupby(['timestamp', 'file_path']))}
+            """
+        else:
+            summary_text = "No data available for current selection."
+
+        return perf_chart, gpu_chart, summary_table, summary_text
+
+    def update_historical_trends(self, selected_models: List[str], selected_scenarios: List[str],
+                                selected_gpus: List[str], start_date: str, end_date: str, metric: str):
+        """Update historical trends chart with date filtering."""
+        filtered_df = self.filter_data(
+            selected_models, selected_scenarios, selected_gpus,
+            start_date=start_date, end_date=end_date
+        )
+        trend_chart = self.create_historical_trend_chart(filtered_df, metric)
+        return trend_chart
+
+
+def create_gradio_interface() -> gr.Interface:
+    """Create the Gradio interface."""
+    dashboard = BenchmarkDashboard()
+    models, scenarios, gpus, benchmark_runs, min_date, max_date = dashboard.get_filter_options()
+
+    # Performance metrics options
+    metric_options = [
+        "tokens_per_second_mean",
+        "latency_seconds_mean",
+        "time_to_first_token_seconds_mean",
+        "time_per_output_token_seconds_mean"
+    ]
+
+    with gr.Blocks(title="LLM Inference Performance Dashboard", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# 🚀 LLM Inference Performance Dashboard")
+        gr.Markdown("Analyze and compare LLM inference performance across models, scenarios, and hardware configurations.")
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("## Filters")
+
+                model_filter = gr.CheckboxGroup(
+                    choices=models,
+                    value=models,
+                    label="Select Models",
+                    interactive=True
+                )
+                scenario_filter = gr.CheckboxGroup(
+                    choices=scenarios,
+                    value=scenarios[:5] if len(scenarios) > 5 else scenarios,  # Limit initial selection
+                    label="Select Scenarios",
+                    interactive=True
+                )
+                gpu_filter = gr.CheckboxGroup(
+                    choices=gpus,
+                    value=gpus,
+                    label="Select GPUs",
+                    interactive=True
+                )
+                metric_selector = gr.Dropdown(
+                    choices=metric_options,
+                    value="tokens_per_second_mean",
+                    label="Primary Metric",
+                    interactive=True
+                )
+
+                gr.Markdown("### Benchmark Run Selection")
+
+                # Search field for filtering benchmark runs
+                run_search = gr.Textbox(
+                    value="",
+                    label="Search Benchmark Runs",
+                    placeholder="Search by date, commit ID, etc.",
+                    interactive=True
+                )
+
+                # Filtered benchmark run selector
+                benchmark_run_selector = gr.Dropdown(
+                    choices=benchmark_runs,
+                    value=benchmark_runs[0] if benchmark_runs else None,
+                    label="Select Benchmark Run",
+                    info="Choose specific daily run (all models from same commit/date)",
+                    interactive=True,
+                    allow_custom_value=False
+                )
+
+            with gr.Column(scale=3):
+                with gr.Tabs():
+                    with gr.TabItem("Performance Comparison"):
+                        perf_plot = gr.Plot(label="Performance Comparison")
+
+                    with gr.TabItem("Historical Trends"):
+                        with gr.Row():
+                            with gr.Column(scale=1):
+                                gr.Markdown("### Date Range for Historical Analysis")
+                                start_date = gr.Textbox(
+                                    value=min_date,
+                                    label="Start Date (YYYY-MM-DD)",
+                                    placeholder="2025-01-01",
+                                    interactive=True
+                                )
+                                end_date = gr.Textbox(
+                                    value=max_date,
+                                    label="End Date (YYYY-MM-DD)",
+                                    placeholder="2025-12-31",
+                                    interactive=True
+                                )
+                            with gr.Column(scale=3):
+                                trend_plot = gr.Plot(label="Historical Trends")
+
+                    with gr.TabItem("GPU Analysis"):
+                        gpu_plot = gr.Plot(label="GPU Performance Analysis")
+
+                    with gr.TabItem("Summary Statistics"):
+                        summary_table = gr.Dataframe(label="Performance Summary")
+
+        with gr.Row():
+            summary_text = gr.Markdown("", label="Summary")
+
+        # Function to filter benchmark runs based on search
+        def filter_benchmark_runs(search_text):
+            if not search_text:
+                return gr.Dropdown(choices=benchmark_runs, value=benchmark_runs[0] if benchmark_runs else None)
+
+            # Filter runs that contain the search text (case insensitive)
+            filtered_runs = [run for run in benchmark_runs if search_text.lower() in run.lower()]
+            return gr.Dropdown(choices=filtered_runs, value=filtered_runs[0] if filtered_runs else None)
+
+        # Update function for main dashboard (excluding historical trends)
+        def update_main(models_selected, scenarios_selected, gpus_selected, run_selected, metric):
+            return dashboard.update_dashboard(
+                models_selected, scenarios_selected, gpus_selected, run_selected, metric
+            )
+
+        # Update function for historical trends
+        def update_trends(models_selected, scenarios_selected, gpus_selected, start_dt, end_dt, metric):
+            return dashboard.update_historical_trends(
+                models_selected, scenarios_selected, gpus_selected, start_dt, end_dt, metric
+            )
+
+        # Set up interactivity for main dashboard
+        main_inputs = [model_filter, scenario_filter, gpu_filter, benchmark_run_selector, metric_selector]
+        main_outputs = [perf_plot, gpu_plot, summary_table, summary_text]
+
+        # Set up interactivity for historical trends
+        trends_inputs = [model_filter, scenario_filter, gpu_filter, start_date, end_date, metric_selector]
+        trends_outputs = [trend_plot]
+
+        # Update main dashboard on filter changes
+        for input_component in main_inputs:
+            input_component.change(fn=update_main, inputs=main_inputs, outputs=main_outputs)
+
+        # Update historical trends on filter changes
+        for input_component in trends_inputs:
+            input_component.change(fn=update_trends, inputs=trends_inputs, outputs=trends_outputs)
+
+        # Connect search field to filter benchmark runs
+        run_search.change(fn=filter_benchmark_runs, inputs=[run_search], outputs=[benchmark_run_selector])
+
+        # Initial load
+        demo.load(fn=update_main, inputs=main_inputs, outputs=main_outputs)
+        demo.load(fn=update_trends, inputs=trends_inputs, outputs=trends_outputs)
+
+    return demo
+
+
+def main():
+    """Launch the dashboard."""
+    logger.info("Starting LLM Inference Performance Dashboard")
+
+    try:
+        demo = create_gradio_interface()
+        demo.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False,
+            show_error=True
+        )
+    except Exception as e:
+        logger.error(f"Error launching dashboard: {e}")
+        raise
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,5 @@
+polars>=1.33.0
+gradio>=4.0.0
+plotly>=5.17.0
+pandas>=2.0.0
+pyarrow>=21.0.0