From 94345325bf990b689cfa99a961c591b8b0afc663 Mon Sep 17 00:00:00 2001 From: Sahan Paliskara Date: Wed, 17 Dec 2025 13:36:30 -0800 Subject: [PATCH 01/24] Benchmarking guide --- notebooks/benchmarking.ipynb | 1708 ++++++++++++++++++++++++++++++++++ 1 file changed, 1708 insertions(+) create mode 100644 notebooks/benchmarking.ipynb diff --git a/notebooks/benchmarking.ipynb b/notebooks/benchmarking.ipynb new file mode 100644 index 00000000..5bb7470d --- /dev/null +++ b/notebooks/benchmarking.ipynb @@ -0,0 +1,1708 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "view-in-github" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_PCU0gUyzX2c" + }, + "source": [ + "# A Practical Guide to GPU Benchmarking\n", + "\n", + "> **Note on outputs:** The outputs in this notebook were generated on an **NVIDIA H200 GPU** (90MB L2 cache, 4.8 TB/s memory bandwidth). Your results may vary depending on your hardware. The H200's large cache means cache effects are less dramatic than on older GPUs like A100 (40MB L2) or consumer cards.\n", + "\n", + "## TL;DR — How to Benchmark Correctly\n", + "\n", + "Benchmarking on GPUs requires a strict protocol to avoid measuring Python overhead or caching artifacts. To get reliable numbers, you must:\n", + "\n", + "1. **Warmup:** Run the kernel ~10-50 times first to settle compilation and memory allocators.\n", + "2. **Sample Extensively:** Don't trust one run. Collect 100+ samples to build a statistical distribution.\n", + "3. **Flush the L2 Cache:** Between *every* sample, flush the cache to force a cold cache state (simulating real-world inference).\n", + "4. **Use Device Timers:** Use `torch.cuda.Event` instead of `time.time()` to measure execution on the GPU, not the CPU driver.\n", + "5. **Aggregate Robustly:** Aggregate over many samples to filter out jitter/outliers.\n", + "6. **Wait for sidestreams to finish:** Ensure no side-streams are running or wait for all of them to finish before reporting a time.\n", + "\n", + "*Pro-Tip:* **KernelBench's timing module** (`src/timing.py`) implements all these best practices. Use `get_timing_function(\"cuda_event\")` for trusted code or `get_timing_function(\"host_time\")` for evaluating untrusted/agent-generated code.\n", + "\n", + "-----\n", + "\n", + "If are using an LLM agent to write GPU kernels (and evaluating against something like say [Kernel Bench](https://github.com/ScalingIntelligence/KernelBench)), or just trying to optimize a custom GPU kernel, you are eventually going to ask: **\"How fast is this thing?\"**\n", + "\n", + "This notebook is heavily inspired by [this great guide](https://www.youtube.com/watch?v=1i7dxoAfKOU) from the **GPU MODE** community and the practical \"footguns\" (traps) encountered while building benchmarking harnesses for LLM-generated code. Our goal here is simplicity and keeping things Pythonic—for more advanced techniques, see the footnotes.\n", + "\n", + "We won't just list best practices. Instead, we are going to build a benchmarking harness from scratch, make every common mistake, debug why the numbers are wrong, and iterate our way to a robust solution. So let's start things out by doing the most naive thing by using `time.time()`!" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:36.427802Z", + "iopub.status.busy": "2025-12-17T21:24:36.427684Z", + "iopub.status.idle": "2025-12-17T21:24:40.995279Z", + "shell.execute_reply": "2025-12-17T21:24:40.994328Z" + }, + "id": "PKWz_W7uzX2f", + "outputId": "8751fd78-569b-4080-f21a-60bbb5ee8caf" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/simon/miniconda3/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using GPU: NVIDIA H200\n" + ] + } + ], + "source": [ + "# @title Environment Setup\n", + "# Ensure we have the necessary libraries and a GPU available\n", + "# !pip install -q triton matplotlib numpy torch\n", + "# !pip install -e .. # Install KernelBench locally for timing utilities\n", + "\n", + "import sys\n", + "sys.path.insert(0, '..') # Add parent directory to path for imports\n", + "\n", + "import torch\n", + "import time\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import triton\n", + "\n", + "# Import KernelBench's timing module\n", + "from src import timing\n", + "from src.timing import clear_l2_cache, get_timing_stats, get_timing_function\n", + "\n", + "if not torch.cuda.is_available():\n", + " raise RuntimeError(\"This notebook requires a GPU. Please enable GPU in your runtime settings.\")\n", + "\n", + "# Device configuration\n", + "# For multi-GPU systems, set CUDA_VISIBLE_DEVICES=X before running to select a specific GPU\n", + "# The selected GPU will appear as cuda:0\n", + "DEVICE = \"cuda:0\"\n", + "print(f\"Using GPU: {torch.cuda.get_device_name(DEVICE)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kjWByrwvzX2f" + }, + "source": [ + "## The Journey: Benchmarking a Matrix Multiplication\n", + "\n", + "Let's define a simple workload to test. We want to measure the performance of a standard Matrix Multiplication." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:40.997969Z", + "iopub.status.busy": "2025-12-17T21:24:40.997722Z", + "iopub.status.idle": "2025-12-17T21:24:41.252072Z", + "shell.execute_reply": "2025-12-17T21:24:41.250967Z" + }, + "id": "gxtKes5lzX2g", + "outputId": "5890bae4-5b9a-4366-8947-367146593158" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Output shape: torch.Size([8192, 8192])\n", + "Op ran successfully\n" + ] + } + ], + "source": [ + "# A standard size for testing\n", + "N = 8192\n", + "\n", + "def get_data(n=N, device=DEVICE):\n", + " \"\"\"Generate random float32 matrices for benchmarking.\"\"\"\n", + " return torch.randn(n, n, device=device), torch.randn(n, n, device=device)\n", + "\n", + "def simple_mm(a, b):\n", + " \"\"\"Our kernel under test: standard matrix multiplication.\"\"\"\n", + " return torch.matmul(a, b)\n", + "\n", + "# Let's verify it runs\n", + "a, b = get_data()\n", + "res = simple_mm(a, b)\n", + "print(f\"Output shape: {res.shape}\")\n", + "print(\"Op ran successfully\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GWlsBEVyzX2g" + }, + "source": [ + "### Attempt 1: The Naive Timer (The Asynchronous Illusion)\n", + "\n", + "The most intuitive way to time code in Python is using `time.time()`. Let's try that first." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:41.254622Z", + "iopub.status.busy": "2025-12-17T21:24:41.254499Z", + "iopub.status.idle": "2025-12-17T21:24:41.258106Z", + "shell.execute_reply": "2025-12-17T21:24:41.257414Z" + }, + "id": "LynIxLaRzX2g", + "outputId": "72548dad-6570-4eaa-ce07-923556fe70b4" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Naive time: 0.5236 ms\n" + ] + } + ], + "source": [ + "def benchmark_naive(func, *args):\n", + " \"\"\"WRONG: Measures kernel launch time, not execution time.\"\"\"\n", + " start = time.time()\n", + " func(*args)\n", + " end = time.time()\n", + " return (end - start) * 1000 # to ms\n", + "\n", + "t = benchmark_naive(simple_mm, a, b)\n", + "print(f\"Naive time: {t:.4f} ms\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gw4NGYRmzX2h" + }, + "source": [ + "**The Problem:**\n", + "Wait, ~0.5ms? That seems impossibly fast for a 4096² matrix multiplication involving 137 billion floating-point operations.\n", + "\n", + "**What happened?**\n", + "GPUs are **asynchronous**. When you call `torch.matmul`, the CPU doesn't actually do the math. It simply queues a \"launch kernel\" command to the GPU and moves on immediately. Our timer didn't measure the matrix multiplication; it measured how long it took Python to place an order in the queue.\n", + "\n", + "To fix this, we need to:\n", + "1. **Synchronize** - Force the CPU to wait for the GPU with `torch.cuda.synchronize()`\n", + "2. **Use CUDA Events** - Record timestamps directly on the GPU to avoid CPU overhead\n", + "\n", + "Let's compare these approaches to see the difference." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "execution": { + "iopub.execute_input": "2025-12-17T21:24:41.260592Z", + "iopub.status.busy": "2025-12-17T21:24:41.260479Z", + "iopub.status.idle": "2025-12-17T21:24:41.460207Z", + "shell.execute_reply": "2025-12-17T21:24:41.459267Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Comparing Synchronized time.time() vs CUDA Events:\n", + "------------------------------------------------------------\n", + "N= 512: sync= 0.0699ms, events= 0.0374ms, overhead=+0.0325ms\n", + "N=1024: sync= 0.0725ms, events= 0.0718ms, overhead=+0.0007ms\n", + "N=2048: sync= 0.3567ms, events= 0.3543ms, overhead=+0.0024ms\n", + "N=4096: sync= 2.7008ms, events= 2.6914ms, overhead=+0.0094ms\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Key insight: Synchronized timing includes 0.009ms of CPU overhead.\n", + "CUDA Events (2.6914ms) measure pure GPU execution time.\n" + ] + } + ], + "source": [ + "# Compare: Synchronized time.time() vs CUDA Events\n", + "# This shows why GPU-side timestamps are more accurate\n", + "\n", + "def benchmark_sync(func, *args):\n", + " \"\"\"Attempt 2: Synchronized - waits for GPU but uses CPU clock.\"\"\"\n", + " torch.cuda.synchronize(device=DEVICE)\n", + " start = time.time()\n", + " func(*args)\n", + " torch.cuda.synchronize(device=DEVICE)\n", + " end = time.time()\n", + " return (end - start) * 1000\n", + "\n", + "def benchmark_events(func, *args):\n", + " \"\"\"Attempt 3: CUDA Events - GPU-side timestamps, most accurate.\"\"\"\n", + " start_event = torch.cuda.Event(enable_timing=True)\n", + " end_event = torch.cuda.Event(enable_timing=True)\n", + " torch.cuda.synchronize(device=DEVICE)\n", + " start_event.record()\n", + " func(*args)\n", + " end_event.record()\n", + " torch.cuda.synchronize(device=DEVICE)\n", + " return start_event.elapsed_time(end_event)\n", + "\n", + "# Test across different matrix sizes\n", + "sizes = [512, 1024, 2048, 4096]\n", + "sync_times = []\n", + "event_times = []\n", + "\n", + "print(\"Comparing Synchronized time.time() vs CUDA Events:\")\n", + "print(\"-\" * 60)\n", + "for s in sizes:\n", + " a_test, b_test = get_data(s)\n", + " # Warmup\n", + " for _ in range(3):\n", + " simple_mm(a_test, b_test)\n", + " torch.cuda.synchronize(device=DEVICE)\n", + " \n", + " sync_t = benchmark_sync(simple_mm, a_test, b_test)\n", + " event_t = benchmark_events(simple_mm, a_test, b_test)\n", + " \n", + " sync_times.append(sync_t)\n", + " event_times.append(event_t)\n", + " overhead = sync_t - event_t\n", + " print(f\"N={s:4d}: sync={sync_t:7.4f}ms, events={event_t:7.4f}ms, overhead={overhead:+.4f}ms\")\n", + "\n", + "# Create visualization\n", + "fig, axes = plt.subplots(1, 2, figsize=(12, 5))\n", + "\n", + "# Left plot: Both methods across sizes\n", + "axes[0].plot(sizes, sync_times, 's-', label='Synchronized (CPU clock)', linewidth=2, markersize=8, color='orange')\n", + "axes[0].plot(sizes, event_times, '^-', label='CUDA Events (GPU clock)', linewidth=2, markersize=8, color='green')\n", + "axes[0].set_xlabel('Matrix Size (N)')\n", + "axes[0].set_ylabel('Time (ms)')\n", + "axes[0].set_title('CPU Clock vs GPU Clock Timing')\n", + "axes[0].legend()\n", + "axes[0].grid(True, alpha=0.3)\n", + "\n", + "# Right plot: Bar chart showing overhead at largest size\n", + "overhead_ms = sync_times[-1] - event_times[-1]\n", + "axes[1].bar(['Synchronized\\n(time.time + sync)', 'CUDA Events\\n(GPU timestamps)'], \n", + " [sync_times[-1], event_times[-1]], \n", + " color=['orange', 'green'], alpha=0.8)\n", + "axes[1].set_ylabel('Time (ms)')\n", + "axes[1].set_title(f'CPU Overhead at N={sizes[-1]}\\n(Sync includes ~{overhead_ms:.3f}ms CPU overhead)')\n", + "axes[1].axhline(y=event_times[-1], color='green', linestyle='--', alpha=0.5, label='True GPU time')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "print(f\"\\nKey insight: Synchronized timing includes {overhead_ms:.3f}ms of CPU overhead.\")\n", + "print(f\"CUDA Events ({event_times[-1]:.4f}ms) measure pure GPU execution time.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dV8AmQi-zX2i" + }, + "source": [ + "### Attempt 3: Removing CPU Overhead (CUDA Events)\n", + "\n", + "To get a precise measurement, we need to bypass the CPU clock entirely. We can ask the GPU driver to record timestamps directly on the device using `torch.cuda.Event`." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:41.463315Z", + "iopub.status.busy": "2025-12-17T21:24:41.463177Z", + "iopub.status.idle": "2025-12-17T21:24:41.532922Z", + "shell.execute_reply": "2025-12-17T21:24:41.531966Z" + }, + "id": "i6PfSdkTzX2i", + "outputId": "8b3e29d1-1789-4bfb-9a44-599016516dd7" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Run 0: 21.9622 ms\n", + "Run 1: 21.6770 ms\n", + "Run 2: 21.4259 ms\n" + ] + } + ], + "source": [ + "def benchmark_events(func, *args):\n", + " \"\"\"Better: Uses GPU timestamps, avoiding CPU overhead.\"\"\"\n", + " start_event = torch.cuda.Event(enable_timing=True)\n", + " end_event = torch.cuda.Event(enable_timing=True)\n", + "\n", + " torch.cuda.synchronize(device=DEVICE)\n", + " start_event.record()\n", + " func(*args)\n", + " end_event.record()\n", + " torch.cuda.synchronize(device=DEVICE)\n", + "\n", + " return start_event.elapsed_time(end_event) # Returns ms directly\n", + "\n", + "# Run it a few times\n", + "for i in range(3):\n", + " print(f\"Run {i}: {benchmark_events(simple_mm, a, b):.4f} ms\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BkfaaDawzX2i" + }, + "source": [ + "### Attempt 4: Handling the \"Cold Start\"\n", + "\n", + "Notice Run 0 is noticably slower than the rest. The first time you run a PyTorch function (and similarly launching a cuda kernel), the framework does a lot of heavy lifting which could include: allocating memory, initializing cuBLAS/cuDNN workspaces, lazy kernel loading, and compiling kernels (especially if using `torch.compile` or Triton). This \"Cold Start\" penalty is a one-time cost that shouldn't be included in your performance metrics.\n", + "\n", + "**The Fix:**\n", + "We need to perform **Warmup Runs**—running the kernel a few times to settle the system state before we start measuring." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:41.535509Z", + "iopub.status.busy": "2025-12-17T21:24:41.535387Z", + "iopub.status.idle": "2025-12-17T21:24:42.246476Z", + "shell.execute_reply": "2025-12-17T21:24:42.245382Z" + }, + "id": "j_PsAuJkzX2i", + "outputId": "d6983401-72d3-468c-ffd8-c0833e8d5556" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Run 0: 21.4824 ms\n", + "Run 1: 21.4355 ms\n", + "Run 2: 21.4300 ms\n" + ] + } + ], + "source": [ + "def benchmark_warmup(func, *args, warmup_iters=30, benchmark_iters=3):\n", + " \"\"\"Better: Includes warmup to avoid cold-start penalty.\"\"\"\n", + " # Warmup phase\n", + " for _ in range(warmup_iters):\n", + " func(*args)\n", + " torch.cuda.synchronize(device=DEVICE)\n", + "\n", + " # Measurement phase\n", + " measurements = []\n", + " for _ in range(benchmark_iters):\n", + " measurements.append(benchmark_events(func, *args))\n", + " torch.cuda.synchronize(device=DEVICE)\n", + " return measurements\n", + "\n", + "# print(f\"Warmed up time: {benchmark_warmup(simple_mm, a, b):.4f} ms\")\n", + "\n", + "for i, measurement in enumerate(benchmark_warmup(simple_mm, a, b)):\n", + " print(f\"Run {i}: {measurement:.4f} ms\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OR3uOh7kzX2i" + }, + "source": [ + "### Attempt 5: The Single Sample Fallacy (Variance)\n", + "\n", + "Relying on a single sample after warmup is bad science. Operating systems are noisy; background processes interrupt the CPU, and GPU clocks fluctuate thermally. A single measurement is anecdotal, not statistical.\n", + "\n", + "#### Visualizing the Jitter\n", + "\n", + "Let's run the benchmark 100 times and plot every single run. You will clearly see the \"Cold Start\" spike and the noise floor of the OS." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 653 + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:42.248937Z", + "iopub.status.busy": "2025-12-17T21:24:42.248818Z", + "iopub.status.idle": "2025-12-17T21:24:44.484746Z", + "shell.execute_reply": "2025-12-17T21:24:44.483759Z" + }, + "id": "T-7QH4cHzX2i", + "outputId": "c758effd-a810-422d-d3ca-66c128cdb716" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean: 21.4449 ms\n", + "Median: 21.4454 ms\n", + "Std: 0.0213 ms\n", + "Min: 21.4074 ms\n", + "Max: 21.5199 ms\n" + ] + } + ], + "source": [ + "# Collect 100 samples\n", + "timings = []\n", + "for i in range(100):\n", + " timings.append(benchmark_events(simple_mm, a, b))\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "plt.scatter(range(100), timings, alpha=0.6)\n", + "plt.axhline(y=np.median(timings), color='r', linestyle='--', label=f'Median: {np.median(timings):.4f} ms')\n", + "plt.axhline(y=np.mean(timings), color='g', linestyle=':', label=f'Mean: {np.mean(timings):.4f} ms')\n", + "plt.title(\"Benchmarking Jitter & Cold Start\")\n", + "plt.ylabel(\"Time (ms)\")\n", + "plt.xlabel(\"Run Index\")\n", + "plt.legend()\n", + "plt.grid(True, alpha=0.3)\n", + "plt.show()\n", + "\n", + "print(f\"Mean: {np.mean(timings):.4f} ms\")\n", + "print(f\"Median: {np.median(timings):.4f} ms\")\n", + "print(f\"Std: {np.std(timings):.4f} ms\")\n", + "print(f\"Min: {np.min(timings):.4f} ms\")\n", + "print(f\"Max: {np.max(timings):.4f} ms\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hX_-OpftzX2i" + }, + "source": [ + "You will see a massive dot at $x=0$ (the cold start), followed by a cloud of dots hovering around the \"true\" time. This visualizes why we need **Warmup** (to skip $x=0$) and **Statistics** (to handle the cloud).\n", + "\n", + "Notice how the **Mean** is pulled upward by the outliers, while the **Median** represents the typical case more accurately. When possible, we should use the **Median** as our final metric.\n", + "\n", + "### Attempt 6: The \"Robust\" Harness (Flushing Cache)\n", + "\n", + "Modern GPUs have large L2 caches (40MB-192MB depending on architecture). If your data fits in the cache, subsequent iterations in your loop will skip the slow VRAM access, artificially inflating your speed. In production, data usually streams in from VRAM, so this \"hot cache\" benchmark is misleading.\n", + "\n", + "**The Fix:**\n", + "We must **flush the L2 cache** between *every single sample*. We do this by writing to a tensor large enough to completely evict the cache contents. KernelBench uses a ~256MB tensor to safely cover all GPU architectures, including the largest caches (e.g., Blackwell at ~192MB)." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "execution": { + "iopub.execute_input": "2025-12-17T21:24:44.487140Z", + "iopub.status.busy": "2025-12-17T21:24:44.487016Z", + "iopub.status.idle": "2025-12-17T21:24:44.489937Z", + "shell.execute_reply": "2025-12-17T21:24:44.489208Z" + }, + "id": "Kj5azcpxzX2j" + }, + "outputs": [], + "source": [ + "# KernelBench provides utilities to flush the L2 cache\n", + "# This is important for cold cache measurements that simulate real-world inference\n", + "\n", + "def clear_l2_cache(device=DEVICE):\n", + " \"\"\"Flush L2 cache by writing to a large tensor.\n", + " \n", + " L2 cache sizes vary by GPU, so we use 256MB to cover all cases.\n", + " \"\"\"\n", + " dummy = torch.empty((32, 1024, 1024), dtype=torch.int64, device=device) # 256MB\n", + " dummy.fill_(1901) # Force write to thrash cache\n", + " del dummy\n", + "\n", + "# KernelBench also provides clear_l2_cache_triton() for cross-platform support\n", + "# (works on both NVIDIA and AMD GPUs via Triton's device abstraction)\n", + "from src.timing import clear_l2_cache_triton" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Why does flushing the cache matter?\n", + "\n", + "Let's see the cache effect in action. We'll benchmark the same operation twice:\n", + "1. **Without** cache flushing between runs (data stays in L2 cache)\n", + "2. **With** cache flushing between runs (data must be fetched from VRAM each time)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "execution": { + "iopub.execute_input": "2025-12-17T21:24:44.492322Z", + "iopub.status.busy": "2025-12-17T21:24:44.492090Z", + "iopub.status.idle": "2025-12-17T21:24:44.507209Z", + "shell.execute_reply": "2025-12-17T21:24:44.506066Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Without cache flushing (warm cache):\n", + "\n", + "With cache flushing (cold cache):\n", + "\n", + "Warm cache median: 0.0283 ms\n", + "Cold cache median: 0.0323 ms\n", + "Difference: 0.0040 ms (14.3% slower with cold cache)\n", + "\n", + "Without cache flushing, you measure artificially fast times!\n" + ] + } + ], + "source": [ + "# Demonstrate why L2 cache flushing matters\n", + "# Use a smaller matrix so the effect is visible (data fits in cache)\n", + "N_SMALL = 512\n", + "a_small, b_small = get_data(N_SMALL)\n", + "\n", + "# do warmup runs\n", + "for _ in range(10):\n", + " clear_l2_cache(device=DEVICE)\n", + " benchmark_events(simple_mm, a_small, b_small)\n", + " torch.cuda.synchronize(device=DEVICE)\n", + "\n", + "# Benchmark WITHOUT cache flushing (warm cache - unrealistic)\n", + "print(\"Without cache flushing (warm cache):\")\n", + "times_warm = []\n", + "for i in range(10):\n", + " t = benchmark_events(simple_mm, a_small, b_small)\n", + " times_warm.append(t)\n", + "\n", + "# Benchmark WITH cache flushing (cold cache - realistic)\n", + "print(\"\\nWith cache flushing (cold cache):\")\n", + "times_cold = []\n", + "for i in range(10):\n", + " clear_l2_cache(device=DEVICE) # Flush cache before each measurement\n", + " t = benchmark_events(simple_mm, a_small, b_small)\n", + " times_cold.append(t)\n", + "\n", + "print(f\"\\nWarm cache median: {np.median(times_warm):.4f} ms\")\n", + "print(f\"Cold cache median: {np.median(times_cold):.4f} ms\")\n", + "print(f\"Difference: {np.median(times_cold) - np.median(times_warm):.4f} ms ({(np.median(times_cold)/np.median(times_warm) - 1)*100:.1f}% slower with cold cache)\")\n", + "print(\"\\nWithout cache flushing, you measure artificially fast times!\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "execution": { + "iopub.execute_input": "2025-12-17T21:24:44.509465Z", + "iopub.status.busy": "2025-12-17T21:24:44.509344Z", + "iopub.status.idle": "2025-12-17T21:24:44.597419Z", + "shell.execute_reply": "2025-12-17T21:24:44.596500Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize the cache effect\n", + "plt.figure(figsize=(10, 5))\n", + "plt.scatter(range(len(times_warm)), times_warm, alpha=0.7, label=f'Warm Cache (mean={np.mean(times_warm):.4f}ms)', color='orange', s=60)\n", + "plt.scatter(range(len(times_cold)), times_cold, alpha=0.7, label=f'Cold Cache (mean={np.mean(times_cold):.4f}ms)', color='blue', s=60)\n", + "plt.axhline(y=np.mean(times_warm), color='orange', linestyle='--', alpha=0.5)\n", + "plt.axhline(y=np.mean(times_cold), color='blue', linestyle='--', alpha=0.5)\n", + "plt.xlabel('Run Index')\n", + "plt.ylabel('Time (ms)')\n", + "plt.title(f'Cache Effect on {N_SMALL}x{N_SMALL} Matrix Multiplication')\n", + "plt.legend()\n", + "plt.grid(True, alpha=0.3)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FAaH1cdBzX2j" + }, + "source": [ + "### Putting it all together\n", + "\n", + "We have now discovered that a robust benchmark requires:\n", + "\n", + "1. Device Synchronization\n", + "2. CUDA Events (to avoid CPU overhead)\n", + "3. Warmup Runs (to avoid initialization costs)\n", + "4. Multiple Samples (to handle variance)\n", + "5. Cache Flushing (to simulate VRAM access)\n", + "6. Median/Mean Aggregation (to ignore jitter)\n", + "\n", + "Writing this boilerplate every time is painful. We've packaged all these lessons into **KernelBench's timing module**, which provides multiple timing methods for different use cases. There are also other robust implementations available, such as Triton's `do_bench` [function](https://triton-lang.org/main/python-api/generated/triton.testing.do_bench.html).\n", + "\n", + "The default `cuda_event` method in KernelBench implements all of the above automatically, plus an additional insight: **`discard_first`** - discarding the first few trials after warmup, which often still have some initialization overhead." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:44.600123Z", + "iopub.status.busy": "2025-12-17T21:24:44.600004Z", + "iopub.status.idle": "2025-12-17T21:24:47.005899Z", + "shell.execute_reply": "2025-12-17T21:24:47.004654Z" + }, + "id": "3aVFtWt_zX2j", + "outputId": "6cf1e493-86ca-419e-a8e1-e19486814e09" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Profiling] Using timing method: cuda_event\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "KernelBench cuda_event time: 21.4000 ms\n" + ] + } + ], + "source": [ + "# Get the timing function - cuda_event is the default for trusted code\n", + "timing_fn = get_timing_function(\"cuda_event\")\n", + "\n", + "def final_benchmark(func, *args, num_trials=100):\n", + " \"\"\"Production-ready benchmarking using KernelBench's timing module.\"\"\"\n", + " elapsed_times = timing_fn(\n", + " kernel_fn=func,\n", + " args=list(args),\n", + " num_warmup=10,\n", + " num_trials=num_trials,\n", + " discard_first=1, # Discard first trial for consistency\n", + " verbose=False,\n", + " device=DEVICE\n", + " )\n", + " stats = get_timing_stats(elapsed_times, device=DEVICE)\n", + " return stats[\"mean\"]\n", + "\n", + "t = final_benchmark(simple_mm, a, b)\n", + "print(f\"KernelBench cuda_event time: {t:.4f} ms\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "MsZrCYQRzX2j" + }, + "source": [ + "*Note: KernelBench also wraps Triton's `do_bench` if you prefer adaptive trial counts. See the timing methods comparison below for details.*\n", + "\n", + "---\n", + "\n", + "## KernelBench's Timing Methods Explained\n", + "\n", + "Now that we've built up a robust benchmarking harness from first principles, let's explore KernelBench's timing module in depth. We'll examine:\n", + "- **All 4 timing methods** and when to use each\n", + "- **The `discard_first` parameter** and why it improves measurement consistency\n", + "- **How `host_time` detects side-stream exploits** in untrusted code\n", + "\n", + "KernelBench's timing module provides **4 timing methods**, each designed for different use cases:\n", + "\n", + "| Method | Use Case | Catches Side-Streams | Cold Cache | Trial Control |\n", + "|--------|----------|---------------------|------------|---------------|\n", + "| `cuda_event` | Default, trusted code | No | Yes | Explicit |\n", + "| `host_time` | Untrusted code, agent evals | **Yes** | Yes | Explicit |\n", + "| `do_bench` | Triton-style / robust adaptive | No | Yes | Adaptive (time-budget) |\n", + "| `do_bench_impl` | do_bench implementation for inference and trial control | No | Yes | Explicit |\n", + "\n", + "### Method Details\n", + "\n", + "**`cuda_event`** (Default)\n", + "- Uses `torch.cuda.Event` for GPU-side timing\n", + "- Most accurate for pure kernel time measurement\n", + "- Clears L2 cache before each trial for cold-cache performance\n", + "- Use for trusted code where you control the kernel implementation\n", + "\n", + "**`host_time`** (For Untrusted Code)\n", + "- Uses **both** `time.perf_counter()` (host) and `torch.cuda.Event` (device) timing\n", + "- Compares the two: if they differ significantly, the CUDA event time is likely invalid (e.g., side-stream exploit)\n", + "- Falls back to host time when discrepancy detected, ensuring correctness\n", + "- Waits for ALL streams via `torch.cuda.synchronize()`\n", + "- **Essential for evaluating untrusted/agent-generated code**\n", + "\n", + "**`do_bench`** (Triton's Adaptive Benchmarking)\n", + "- Wraps Triton's `triton.testing.do_bench`\n", + "- Uses fixed time budgets: 25ms warmup, 100ms for repetitions\n", + "- Trial count is automatic based on kernel runtime\n", + "- **Note:** `num_warmup`, `num_trials`, `discard_first` parameters are ignored\n", + "\n", + "**`do_bench_impl`** (Transparent Implementation)\n", + "- Custom implementation mirroring Triton's do_bench\n", + "- Gives you explicit control over `num_warmup` and `num_trials`\n", + "- Useful when you need do_bench's approach but with specific trial counts\n", + "\n", + "### Key Parameters\n", + "\n", + "All timing functions share a common interface:\n", + "\n", + "```python\n", + "timing_fn(\n", + " kernel_fn, # Function to time\n", + " args, # List of arguments to pass\n", + " num_warmup=3, # Warmup iterations before timing\n", + " num_trials=10, # Number of timing samples to collect\n", + " discard_first=1, # Drop first N trials after warmup\n", + " device=\"cuda:0\", # Explicit GPU device selection\n", + " verbose=True # Print per-trial timing info\n", + ") -> list[float] # Returns list of elapsed times in ms\n", + "```\n", + "\n", + "### Why `discard_first`?\n", + "\n", + "Even after warmup, the first few timing trials can be affected by:\n", + "- PyTorch's lazy tensor allocation finalizing\n", + "- cuDNN autotuning (still settling optimal algorithms)\n", + "- Driver state initialization\n", + "- First access to data structures\n", + "\n", + "Setting `discard_first=1` (the default) improves measurement consistency. Let's visualize this effect:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Experiment 2: Comparing All 4 Timing Methods\n", + "\n", + "Let's see how the different timing methods compare on the same kernel. Each method has trade-offs between precision, features, and overhead." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "execution": { + "iopub.execute_input": "2025-12-17T21:24:47.008751Z", + "iopub.status.busy": "2025-12-17T21:24:47.008456Z", + "iopub.status.idle": "2025-12-17T21:24:50.238519Z", + "shell.execute_reply": "2025-12-17T21:24:50.237366Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Comparing all KernelBench timing methods on 4096x4096 matmul:\n", + "======================================================================\n", + "\n", + "Testing cuda_event...\n", + "[Profiling] Using timing method: cuda_event\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 50\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " cuda_event: 21.4000 ms (std=0.0169)\n", + "\n", + "Testing host_time...\n", + "[Profiling] Using timing method: host_time\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 50\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " host_time: 21.6000 ms (std=0.0159)\n", + "\n", + "Testing do_bench...\n", + "[Profiling] Using timing method: do_bench\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " do_bench: 21.4000 ms (std=0.0150)\n", + "\n", + "Testing do_bench_impl...\n", + "[Profiling] Using timing method: do_bench_impl\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " do_bench_impl: Skipped due to AttributeError (Triton version compatibility)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Key insight: host_time is slightly slower due to CPU overhead,\n", + "but it catches ALL work on ALL streams - essential for untrusted code!\n" + ] + } + ], + "source": [ + "# Experiment 2: Compare all 4 timing methods\n", + "print(\"Comparing all KernelBench timing methods on 4096x4096 matmul:\")\n", + "print(\"=\" * 70)\n", + "\n", + "methods = [\"cuda_event\", \"host_time\", \"do_bench\", \"do_bench_impl\"]\n", + "results = {}\n", + "\n", + "for method in methods:\n", + " print(f\"\\nTesting {method}...\")\n", + " try:\n", + " method_fn = get_timing_function(method)\n", + " times = method_fn(\n", + " simple_mm, \n", + " [a, b], \n", + " num_warmup=10, \n", + " num_trials=50, \n", + " verbose=False,\n", + " device=DEVICE\n", + " )\n", + " results[method] = get_timing_stats(times, device=DEVICE)\n", + " print(f\" {method}: {results[method]['mean']:.4f} ms (std={results[method]['std']:.4f})\")\n", + " except Exception as e:\n", + " print(f\" {method}: Skipped due to {type(e).__name__} (Triton version compatibility)\")\n", + " # Remove from list if it failed\n", + " methods = [m for m in methods if m in results]\n", + "\n", + "# Only plot if we have results\n", + "if results:\n", + " # Visualize the comparison\n", + " fig, axes = plt.subplots(1, 2, figsize=(12, 5))\n", + "\n", + " # Bar chart of mean times\n", + " available_methods = [m for m in methods if m in results]\n", + " means = [results[m]['mean'] for m in available_methods]\n", + " stds = [results[m]['std'] for m in available_methods]\n", + " colors = ['#2ecc71', '#e74c3c', '#3498db', '#9b59b6'][:len(available_methods)]\n", + "\n", + " axes[0].bar(available_methods, means, yerr=stds, capsize=5, color=colors, alpha=0.8)\n", + " axes[0].set_ylabel('Time (ms)')\n", + " axes[0].set_title('Mean Execution Time by Method')\n", + " axes[0].tick_params(axis='x', rotation=45)\n", + "\n", + " # Highlight cuda_event vs host_time with truncated y-axis for readability\n", + " if 'cuda_event' in results and 'host_time' in results:\n", + " cuda_mean = results['cuda_event']['mean']\n", + " host_mean = results['host_time']['mean']\n", + " \n", + " axes[1].bar(['cuda_event', 'host_time'], \n", + " [cuda_mean, host_mean], \n", + " color=['#2ecc71', '#e74c3c'], alpha=0.8)\n", + " axes[1].set_ylabel('Time (ms)')\n", + " axes[1].set_title('cuda_event vs host_time\\n(host_time catches side-streams)\\n(graph truncated for readability)')\n", + " \n", + " # Truncate y-axis to make the difference easier to see\n", + " min_val = min(cuda_mean, host_mean)\n", + " max_val = max(cuda_mean, host_mean)\n", + " margin = (max_val - min_val) * 2 # Add margin around the data\n", + " axes[1].set_ylim(min_val - margin, max_val + margin)\n", + " else:\n", + " axes[1].text(0.5, 0.5, 'Comparison unavailable', ha='center', va='center')\n", + " axes[1].set_axis_off()\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "print(\"\\nKey insight: host_time is slightly slower due to CPU overhead,\")\n", + "print(\"but it catches ALL work on ALL streams - essential for untrusted code!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The `discard_first` Effect\n", + "\n", + "Even after warmup, the first timing trial can be affected by lazy initialization. Let's see this in action." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "execution": { + "iopub.execute_input": "2025-12-17T21:24:50.241069Z", + "iopub.status.busy": "2025-12-17T21:24:50.240945Z", + "iopub.status.idle": "2025-12-17T21:24:50.348421Z", + "shell.execute_reply": "2025-12-17T21:24:50.347364Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Demonstrating the discard_first effect:\n", + "============================================================\n", + "[Profiling] Using timing method: cuda_event\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 15\n", + "\n", + "First trial: 0.3454 ms\n", + "Mean of all trials: 0.3444 ms\n", + "Mean without first: 0.3443 ms\n", + "First trial overhead: 0.3%\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "The first trial often shows initialization overhead even after warmup.\n", + "Using discard_first=1 (default) gives more consistent measurements.\n" + ] + } + ], + "source": [ + "# Demonstrate the discard_first effect\n", + "# Even after warmup, the first timing trial can have higher overhead\n", + "\n", + "print(\"Demonstrating the discard_first effect:\")\n", + "print(\"=\" * 60)\n", + "\n", + "# Create fresh data and clear caches to make initialization overhead more visible\n", + "torch.cuda.empty_cache()\n", + "a_fresh, b_fresh = get_data(2048)\n", + "\n", + "# Collect trials with discard_first=0 to see ALL trials including the first one\n", + "timing_fn = get_timing_function(\"cuda_event\")\n", + "times_all = timing_fn(\n", + " simple_mm, [a_fresh, b_fresh],\n", + " num_warmup=3,\n", + " num_trials=15,\n", + " discard_first=0, # Keep ALL trials including first\n", + " verbose=False,\n", + " device=DEVICE\n", + ")\n", + "\n", + "# Calculate statistics\n", + "first_trial = times_all[0]\n", + "remaining_trials = times_all[1:]\n", + "mean_all = np.mean(times_all)\n", + "mean_remaining = np.mean(remaining_trials)\n", + "\n", + "print(f\"\\nFirst trial: {first_trial:.4f} ms\")\n", + "print(f\"Mean of all trials: {mean_all:.4f} ms\")\n", + "print(f\"Mean without first: {mean_remaining:.4f} ms\")\n", + "print(f\"First trial overhead: {((first_trial / mean_remaining) - 1) * 100:.1f}%\")\n", + "\n", + "# Visualize the effect with a scatter plot\n", + "plt.figure(figsize=(10, 5))\n", + "plt.scatter(range(len(times_all)), times_all, alpha=0.7, color='blue', s=60)\n", + "plt.scatter([0], [first_trial], color='red', s=100, zorder=5, label=f'First trial: {first_trial:.3f}ms')\n", + "plt.axhline(y=mean_remaining, color='green', linestyle='--', alpha=0.7, \n", + " label=f'Mean (without first): {mean_remaining:.3f}ms')\n", + "plt.axhline(y=mean_all, color='orange', linestyle=':', alpha=0.7,\n", + " label=f'Mean (all): {mean_all:.3f}ms')\n", + "plt.xlabel('Trial Index')\n", + "plt.ylabel('Time (ms)')\n", + "plt.title('First Trial Overhead Effect (after warmup)')\n", + "plt.legend(loc='upper right')\n", + "plt.grid(True, alpha=0.3)\n", + "plt.show()\n", + "\n", + "print(\"\\nThe first trial often shows initialization overhead even after warmup.\")\n", + "print(\"Using discard_first=1 (default) gives more consistent measurements.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HwsjlhAazX2j" + }, + "source": [ + "## The \"Agent\" Trap: Reward Hacking via Hidden Streams\n", + "\n", + "When evaluating LLM-generated kernels (like with [Kernel Bench](https://github.com/ScalingIntelligence/KernelBench)), you're not just fighting measurement noise—you're fighting an optimizer that may inadvertently discover exploits in your harness.\n", + "\n", + "One such exploit: launching work on a **side stream** to make the kernel appear instantaneous." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:50.351000Z", + "iopub.status.busy": "2025-12-17T21:24:50.350876Z", + "iopub.status.idle": "2025-12-17T21:24:52.778917Z", + "shell.execute_reply": "2025-12-17T21:24:52.777685Z" + }, + "id": "UuwtML39zX2j", + "outputId": "95ebbb26-e415-491a-da30-6a78ce387906" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Standard benchmark on tricky kernel: 0.0978 ms\n" + ] + } + ], + "source": [ + "def tricky_agent_kernel(a, b):\n", + " \"\"\"A 'clever' kernel that games the benchmarking harness.\"\"\"\n", + " # The agent creates a new stream to \"optimize\"\n", + " s = torch.cuda.Stream()\n", + " with torch.cuda.stream(s):\n", + " # This work happens on a side channel!\n", + " result = torch.matmul(a, b)\n", + " return result\n", + "\n", + "print(f\"Standard benchmark on tricky kernel: {final_benchmark(tricky_agent_kernel, a, b):.4f} ms\")\n", + "# Likely reports ~0.00ms or very close to it!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3HXns_XizX2j" + }, + "source": [ + "**The Issue:**\n", + "Standard benchmarking tools (including `do_bench`) record events on the *current default stream*.\n", + "\n", + "1. Benchmark starts timer on Stream A (the default stream).\n", + "2. Agent launches work on Stream B and returns immediately.\n", + "3. Benchmark stops timer on Stream A.\n", + "\n", + "Since Stream A had no work, the timer reports `~0.00ms`, while Stream B is still churning away in the background.\n", + "\n", + "**Why this matters for evals:**\n", + "If your reward signal is \"lower time = better score,\" an agent that discovers this pattern will be rewarded for producing *broken* code. The kernel \"runs\" instantly because you never measured it at all.\n", + "\n", + "**Mitigations:**\n", + "- **Wall-clock + full device sync:** Trade precision for correctness (catches all streams, but includes CPU overhead)\n", + "- **Static analysis:** Reject submissions that create `torch.cuda.Stream()` objects\n", + "- **Manual inspection:** For high-stakes evals, benchmark kernels in isolation outside the automated harness\n", + "\n", + "### How KernelBench Addresses This\n", + "\n", + "KernelBench's timing module provides the **`host_time`** method specifically designed for evaluating untrusted code:\n", + "\n", + "**Use `torch.cuda.synchronize()`** before AND after timing - this waits for ALL streams on the device, not just the default stream\n", + "\n", + "```python\n", + "# For trusted code (faster, but can be fooled)\n", + "timing_fn = get_timing_function(\"cuda_event\")\n", + "\n", + "# For untrusted/agent code (catches side-streams)\n", + "timing_fn = get_timing_function(\"host_time\")\n", + "```\n", + "\n", + "The trade-off: `host_time` includes some CPU overhead in the measurement. However, note that host_time should be pretty similar to sync_time. Therefore, if both times are within a some percent of each other, you can be pretty sure that the kernel is running correctly and score using sync_time." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:52.782281Z", + "iopub.status.busy": "2025-12-17T21:24:52.782061Z", + "iopub.status.idle": "2025-12-17T21:24:52.830292Z", + "shell.execute_reply": "2025-12-17T21:24:52.829161Z" + }, + "id": "KbAFqiyizX2j", + "outputId": "6bc91db4-935c-4af9-bdc9-be3c50e890c4" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Robust benchmark on tricky kernel: 21.5401 ms\n", + "Robust benchmark on normal kernel: 21.4700 ms\n" + ] + } + ], + "source": [ + "def benchmark_untrusted(func, *args):\n", + " \"\"\"Benchmark untrusted code by using wall-clock time with full device sync.\n", + "\n", + " This trades some precision (includes CPU overhead) for correctness\n", + " (catches work on any stream).\n", + " \"\"\"\n", + " torch.cuda.synchronize() # Clear any pending work\n", + " start = time.perf_counter()\n", + " func(*args)\n", + " torch.cuda.synchronize() # Wait for ALL streams\n", + " end = time.perf_counter()\n", + " return (end - start) * 1000\n", + "\n", + "print(f\"Robust benchmark on tricky kernel: {benchmark_untrusted(tricky_agent_kernel, a, b):.4f} ms\")\n", + "print(f\"Robust benchmark on normal kernel: {benchmark_untrusted(simple_mm, a, b):.4f} ms\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "execution": { + "iopub.execute_input": "2025-12-17T21:24:52.832854Z", + "iopub.status.busy": "2025-12-17T21:24:52.832734Z", + "iopub.status.idle": "2025-12-17T21:24:53.846639Z", + "shell.execute_reply": "2025-12-17T21:24:53.845578Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Side-Stream Detection Experiment:\n", + "============================================================\n", + "[Profiling] Using timing method: cuda_event\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 10\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Profiling] Using timing method: host_time\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 10\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 10\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Tricky kernel with cuda_event: 0.3070 ms (FOOLED!)\n", + "Tricky kernel with host_time: 21.8000 ms (CORRECT)\n", + "Normal kernel with host_time: 21.6000 ms (reference)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Key insight: host_time correctly measures the tricky kernel!\n", + "Use host_time for evaluating untrusted/agent-generated code.\n" + ] + } + ], + "source": [ + "# Side-Stream Detection with KernelBench's host_time\n", + "# Let's demonstrate how host_time catches the tricky kernel\n", + "\n", + "print(\"Side-Stream Detection Experiment:\")\n", + "print(\"=\" * 60)\n", + "\n", + "# cuda_event (can be fooled by side-streams)\n", + "cuda_timing = get_timing_function(\"cuda_event\")\n", + "cuda_times = cuda_timing(tricky_agent_kernel, [a, b], num_trials=10, verbose=False, device=DEVICE)\n", + "cuda_stats = get_timing_stats(cuda_times, device=DEVICE)\n", + "\n", + "# host_time (catches all streams)\n", + "host_timing = get_timing_function(\"host_time\")\n", + "host_times = host_timing(tricky_agent_kernel, [a, b], num_trials=10, verbose=False, device=DEVICE)\n", + "host_stats = get_timing_stats(host_times, device=DEVICE)\n", + "\n", + "# Normal kernel for reference\n", + "normal_times = host_timing(simple_mm, [a, b], num_trials=10, verbose=False, device=DEVICE)\n", + "normal_stats = get_timing_stats(normal_times, device=DEVICE)\n", + "\n", + "print(f\"\\nTricky kernel with cuda_event: {cuda_stats['mean']:.4f} ms (FOOLED!)\")\n", + "print(f\"Tricky kernel with host_time: {host_stats['mean']:.4f} ms (CORRECT)\")\n", + "print(f\"Normal kernel with host_time: {normal_stats['mean']:.4f} ms (reference)\")\n", + "\n", + "# Visualize the dramatic difference\n", + "plt.figure(figsize=(10, 5))\n", + "methods = ['cuda_event\\n(fooled)', 'host_time\\n(correct)', 'Normal kernel\\n(reference)']\n", + "times = [cuda_stats['mean'], host_stats['mean'], normal_stats['mean']]\n", + "colors = ['red', 'green', 'blue']\n", + "\n", + "plt.bar(methods, times, color=colors, alpha=0.8)\n", + "plt.ylabel('Time (ms)')\n", + "plt.title('Side-Stream Detection: cuda_event vs host_time')\n", + "plt.grid(True, alpha=0.3, axis='y')\n", + "\n", + "# Add annotation\n", + "plt.annotate('Agent trick detected!', xy=(1, host_stats['mean']), \n", + " xytext=(1.3, host_stats['mean'] * 0.7),\n", + " arrowprops=dict(arrowstyle='->', color='green'),\n", + " fontsize=10, color='green')\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "print(\"\\nKey insight: host_time correctly measures the tricky kernel!\")\n", + "print(\"Use host_time for evaluating untrusted/agent-generated code.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Uq4qvl8FzX2j" + }, + "source": [ + "## Correctness Before Speed\n", + "\n", + "A kernel that runs in 0.1ms but produces garbage is worthless. Before you start optimizing, **always verify correctness** against a reference implementation." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:53.849299Z", + "iopub.status.busy": "2025-12-17T21:24:53.849171Z", + "iopub.status.idle": "2025-12-17T21:24:53.929702Z", + "shell.execute_reply": "2025-12-17T21:24:53.928700Z" + }, + "id": "J9W63Q5czX2k", + "outputId": "312076ee-f089-4276-8b8f-bb7a23575d3d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✓ Correctness verified!\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", + "Kernel time: 0.0648 ms\n" + ] + } + ], + "source": [ + "def my_experimental_kernel(a, b):\n", + " \"\"\"Pretend this is our custom optimized kernel.\"\"\"\n", + " return torch.matmul(a, b) # In reality, this would be your Triton/CUDA code\n", + "\n", + "def verify_correctness(kernel_fn, ref_fn, *args, atol=1e-2, rtol=1e-2):\n", + " \"\"\"Verify kernel produces correct output before benchmarking.\"\"\"\n", + " ref_output = ref_fn(*args)\n", + " kernel_output = kernel_fn(*args)\n", + "\n", + " if not torch.allclose(ref_output, kernel_output, atol=atol, rtol=rtol):\n", + " max_diff = (ref_output - kernel_output).abs().max().item()\n", + " raise AssertionError(\n", + " f\"Kernel output doesn't match reference! \"\n", + " f\"Max difference: {max_diff:.6f}\"\n", + " )\n", + " print(\"✓ Correctness verified!\")\n", + " return True\n", + "\n", + "# Always verify before benchmarking\n", + "a_test, b_test = get_data(1024)\n", + "verify_correctness(my_experimental_kernel, simple_mm, a_test, b_test)\n", + "\n", + "# Only benchmark if correct\n", + "time_ms = final_benchmark(my_experimental_kernel, a_test, b_test)\n", + "print(f\"Kernel time: {time_ms:.4f} ms\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Computing TFLOPS: Are We Hitting the Speed of Light?\n", + "\n", + "Now that we have correct, well-measured timings, the natural question is: **\"Is this kernel actually fast?\"** A kernel that runs in 2ms might sound good, but if the hardware could theoretically do it in 0.5ms, you're leaving 75% of performance on the table.\n", + "\n", + "To answer this, we convert our millisecond timings into **TFLOPS** (Tera Floating-Point Operations Per Second) and compare against the hardware's theoretical maximum—often called the **\"speed of light\"** or **roofline**.\n", + "\n", + "### Understanding Roofline Analysis\n", + "\n", + "The Roofline Model helps you understand whether your kernel is:\n", + "- **Compute-bound**: Limited by the GPU's arithmetic throughput (FLOPS)\n", + "- **Memory-bound**: Limited by memory bandwidth (GB/s)\n", + "\n", + "**Key formulas:**\n", + "- **Arithmetic Intensity** = FLOPs / Bytes accessed\n", + "- **Theoretical Peak FLOPS** = Clock speed × Cores × FLOPs/cycle\n", + "- **Theoretical Peak Bandwidth** = Memory clock × Bus width × 2 (for DDR)\n", + "\n", + "For matrix multiplication of two $N \\times N$ matrices:\n", + "- **FLOPs** = $2N^3$ (one multiply + one add per output element, summed $N$ times)\n", + "- **Bytes** = $3N^2 \\times \\text{sizeof(dtype)}$ (read A, read B, write C)\n", + "- **Arithmetic Intensity** = $\\frac{2N^3}{3N^2 \\times 4} = \\frac{N}{6}$ for float32\n", + "\n", + "Large matrix multiplications are highly compute-bound (high arithmetic intensity), so we expect to approach the compute roofline. For a deeper dive into roofline analysis and speed-of-light calculations, see the excellent [JAX Scaling Book chapter on Roofline](https://jax-ml.github.io/scaling-book/roofline/)." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "execution": { + "iopub.execute_input": "2025-12-17T21:24:53.932346Z", + "iopub.status.busy": "2025-12-17T21:24:53.932227Z", + "iopub.status.idle": "2025-12-17T21:24:56.741833Z", + "shell.execute_reply": "2025-12-17T21:24:56.740706Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Matrix Multiplication Performance\n", + "=================================================================\n", + "Size Time (ms) TFLOPS % of TF32 Peak \n", + "-----------------------------------------------------------------\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", + "1024 0.0647 33.19 3.4 %\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2048 0.3440 49.94 5.0 %\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4096 2.6700 51.48 5.2 %\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "8192 21.4000 51.38 5.2 %\n", + "\n", + "Note: PyTorch uses TF32 tensor cores by default on Ampere+ GPUs.\n", + "H200 TF32 theoretical peak: 989.0 TFLOPS\n", + "\n", + "For roofline analysis details, see: https://jax-ml.github.io/scaling-book/roofline/\n" + ] + } + ], + "source": [ + "def get_tflops(n, time_ms):\n", + " \"\"\"Calculate achieved TFLOPS for matrix multiplication.\"\"\"\n", + " flops = 2 * n ** 3 # Multiply-add for each of N^2 output elements\n", + " tflops = flops / (time_ms * 1e-3) / 1e12\n", + " return tflops\n", + "\n", + "# Theoretical peaks vary by GPU and precision\n", + "# PyTorch uses TF32 by default on Ampere+ GPUs for matmul\n", + "GPU_PEAK_TFLOPS = {\n", + " 'A100': {'fp32': 19.5, 'tf32': 156.0, 'fp16': 312.0},\n", + " 'H100': {'fp32': 67.0, 'tf32': 989.0, 'fp16': 1979.0},\n", + " 'H200': {'fp32': 67.0, 'tf32': 989.0, 'fp16': 1979.0},\n", + "}\n", + "\n", + "# Use TF32 peak since PyTorch defaults to TF32 on Ampere+\n", + "PEAK_TFLOPS = 989.0 # H200 TF32 peak\n", + "\n", + "# Benchmark at different sizes\n", + "print(\"Matrix Multiplication Performance\")\n", + "print(\"=\" * 65)\n", + "print(f\"{'Size':<8} {'Time (ms)':<12} {'TFLOPS':<12} {'% of TF32 Peak':<15}\")\n", + "print(\"-\" * 65)\n", + "\n", + "for size in [1024, 2048, 4096, 8192]:\n", + " a_test, b_test = get_data(size)\n", + " time_ms = final_benchmark(simple_mm, a_test, b_test)\n", + " tflops = get_tflops(size, time_ms)\n", + " efficiency = (tflops / PEAK_TFLOPS) * 100\n", + " print(f\"{size:<8} {time_ms:<12.4f} {tflops:<12.2f} {efficiency:<15.1f}%\")\n", + "\n", + "print(f\"\\nNote: PyTorch uses TF32 tensor cores by default on Ampere+ GPUs.\")\n", + "print(f\"H200 TF32 theoretical peak: {PEAK_TFLOPS} TFLOPS\")\n", + "print(f\"\\nFor roofline analysis details, see: https://jax-ml.github.io/scaling-book/roofline/\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zcYVXCkUzX2k" + }, + "source": [ + "## Conclusion\n", + "\n", + "Benchmarking on GPUs is fundamentally different from CPUs. The asynchronous nature of kernel launches, the hidden state of the L2 cache, and the noise of the OS scheduler all conspire to give you the wrong numbers.\n", + "\n", + "### What We Learned\n", + "\n", + "Through our journey, we discovered that robust GPU benchmarking requires:\n", + "1. **Device Synchronization** - Wait for GPU work to complete\n", + "2. **CUDA Events** - Use GPU-side timestamps, not CPU clocks\n", + "3. **Warmup Runs** - Settle compilation and memory allocators\n", + "4. **Multiple Samples** - Build statistical distributions\n", + "5. **L2 Cache Flushing** - Measure cold cache (realistic) performance\n", + "6. **Median Aggregation** - Filter out OS jitter and outliers\n", + "7. **Side-Stream Detection** - Catch work on non-default streams\n", + "\n", + "### What KernelBench Provides\n", + "\n", + "We've implemented all these best practices in **KernelBench's timing module** (`src/timing.py`):\n", + "\n", + "| Function | Purpose |\n", + "|----------|---------|\n", + "| `get_timing_function(method)` | Factory returning timing function by name |\n", + "| `clear_l2_cache(device)` | L2 cache flushing utility |\n", + "| `get_timing_stats(times)` | Statistical aggregation (mean, std, min, max) |\n", + "\n", + "**Four timing methods for different use cases:**\n", + "- **`cuda_event`** - Default for trusted code (fastest, GPU-side timing)\n", + "- **`host_time`** - For untrusted/agent code (catches all streams)\n", + "- **`do_bench`** - Triton-style adaptive trial counts\n", + "- **`do_bench_impl`** - Transparent do_bench with explicit control\n", + "\n", + "**Key parameters:**\n", + "- `num_warmup`, `num_trials`, `discard_first`, `device`, `verbose`\n", + "\n", + "### Recommended Usage\n", + "\n", + "```python\n", + "from src.timing import get_timing_function, get_timing_stats\n", + "\n", + "# For trusted code\n", + "timing_fn = get_timing_function(\"cuda_event\")\n", + "\n", + "# For agent evaluations (catches side-streams)\n", + "timing_fn = get_timing_function(\"host_time\")\n", + "\n", + "# Run benchmark\n", + "times = timing_fn(kernel, args, num_warmup=10, num_trials=100, device=\"cuda:0\")\n", + "stats = get_timing_stats(times, device=\"cuda:0\")\n", + "print(f\"Mean: {stats['mean']:.4f}ms, Std: {stats['std']:.4f}ms\")\n", + "```\n", + "\n", + "Happy optimizing!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7Ah151CHzX2k" + }, + "source": [ + "---\n", + "\n", + "### Footnotes\n", + "\n", + "**On GPU Clock States:** For highly reproducible benchmarks (e.g., publishing papers), consider locking GPU clocks with `nvidia-smi -lgc `. GPUs dynamically adjust clock speeds based on thermals and power, which can introduce variance between runs. For most development work, median-based benchmarking handles this adequately.\n", + "\n", + "**On Warmup Iterations:** We use fixed warmup counts (10-50 iterations) for simplicity, but this can be insufficient or wasteful depending on the kernel. In extremely sensitive environments, you can implement an adaptive stopping criterion: run warmup iterations until the variance of recent samples falls below a threshold, indicating the system has stabilized. This is covered in more detail in the [GPU MODE lecture](https://www.youtube.com/watch?v=1i7dxoAfKOU).\n", + "\n", + "**On Bare Metal vs. Virtualized Environments:** Cloud VMs and containers add layers of abstraction that can introduce variance and overhead. GPU passthrough in virtualized environments adds latency, and shared cloud instances suffer from \"noisy neighbor\" effects where other tenants' workloads impact your measurements. For publishable results or when chasing small performance deltas, prefer bare metal. For day-to-day development, cloud instances are fine as long as you're aware your numbers may not match others exactly." + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "A100", + "include_colab_link": true, + "provenance": [] + }, + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.9" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} From 7a23bb0fe611a300519e72aeb579a333d760e070 Mon Sep 17 00:00:00 2001 From: Sahan Paliskara Date: Wed, 17 Dec 2025 13:42:16 -0800 Subject: [PATCH 02/24] fix typo --- notebooks/benchmarking.ipynb | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/notebooks/benchmarking.ipynb b/notebooks/benchmarking.ipynb index 5bb7470d..339cf02b 100644 --- a/notebooks/benchmarking.ipynb +++ b/notebooks/benchmarking.ipynb @@ -868,14 +868,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Experiment 2: Comparing All 4 Timing Methods\n", + "# Comparing All 4 Timing Methods\n", "\n", "Let's see how the different timing methods compare on the same kernel. Each method has trade-offs between precision, features, and overhead." ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": { "execution": { "iopub.execute_input": "2025-12-17T21:24:47.008751Z", @@ -968,7 +968,7 @@ } ], "source": [ - "# Experiment 2: Compare all 4 timing methods\n", + "# Compare all KernelBench timing methods on 4096x4096 matmul\n", "print(\"Comparing all KernelBench timing methods on 4096x4096 matmul:\")\n", "print(\"=\" * 70)\n", "\n", From 35d8d2266270dc68b033bffd548342bdc74ecdcd Mon Sep 17 00:00:00 2001 From: Sahan Paliskara Date: Wed, 17 Dec 2025 14:00:29 -0800 Subject: [PATCH 03/24] fix --- notebooks/benchmarking.ipynb | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/notebooks/benchmarking.ipynb b/notebooks/benchmarking.ipynb index 339cf02b..af8be928 100644 --- a/notebooks/benchmarking.ipynb +++ b/notebooks/benchmarking.ipynb @@ -215,7 +215,7 @@ }, "source": [ "**The Problem:**\n", - "Wait, ~0.5ms? That seems impossibly fast for a 4096² matrix multiplication involving 137 billion floating-point operations.\n", + "Wait, less than 1ms? That seems impossibly fast for a 8192² matrix multiplication involving over 1 trillion floating-point operations.[¹](#footnote-1)\n", "\n", "**What happened?**\n", "GPUs are **asynchronous**. When you call `torch.matmul`, the CPU doesn't actually do the math. It simply queues a \"launch kernel\" command to the GPU and moves on immediately. Our timer didn't measure the matrix multiplication; it measured how long it took Python to place an order in the queue.\n", @@ -224,7 +224,12 @@ "1. **Synchronize** - Force the CPU to wait for the GPU with `torch.cuda.synchronize()`\n", "2. **Use CUDA Events** - Record timestamps directly on the GPU to avoid CPU overhead\n", "\n", - "Let's compare these approaches to see the difference." + "Let's compare these approaches to see the difference.\n", + "\n", + "---\n", + "\n", + "\n", + "¹ **Why impossible?** The [H200](https://www.nvidia.com/en-us/data-center/h200/) peaks at 989 TFLOPS for TF32 Tensor Cores. At that rate: 1.1 TFLOP ÷ 989 TFLOP/s = **1.11ms minimum**. Anything under 1ms is physically impossible." ] }, { From 7566e41cdcbeeb41f27adf82365bad912637337e Mon Sep 17 00:00:00 2001 From: Sahan Paliskara Date: Wed, 17 Dec 2025 14:06:04 -0800 Subject: [PATCH 04/24] Benchmarking guide --- notebooks/benchmarking.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/notebooks/benchmarking.ipynb b/notebooks/benchmarking.ipynb index af8be928..6b77fd20 100644 --- a/notebooks/benchmarking.ipynb +++ b/notebooks/benchmarking.ipynb @@ -1480,7 +1480,7 @@ "source": [ "## Computing TFLOPS: Are We Hitting the Speed of Light?\n", "\n", - "Now that we have correct, well-measured timings, the natural question is: **\"Is this kernel actually fast?\"** A kernel that runs in 2ms might sound good, but if the hardware could theoretically do it in 0.5ms, you're leaving 75% of performance on the table.\n", + "It is also important to sanity check the results whether it is to see how well we are doing, or to see if our results are physically possible.\n", "\n", "To answer this, we convert our millisecond timings into **TFLOPS** (Tera Floating-Point Operations Per Second) and compare against the hardware's theoretical maximum—often called the **\"speed of light\"** or **roofline**.\n", "\n", From 57d0ea87302bf4df7eafda73ac79e6d0eb5fead7 Mon Sep 17 00:00:00 2001 From: Sahan Paliskara Date: Wed, 17 Dec 2025 14:39:06 -0800 Subject: [PATCH 05/24] Benchmarking guide --- benchmarking.ipynb | 1561 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1561 insertions(+) create mode 100644 benchmarking.ipynb diff --git a/benchmarking.ipynb b/benchmarking.ipynb new file mode 100644 index 00000000..a9f3ba15 --- /dev/null +++ b/benchmarking.ipynb @@ -0,0 +1,1561 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "view-in-github" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_PCU0gUyzX2c" + }, + "source": [ + "# A Practical Guide to GPU Benchmarking\n", + "\n", + "> **Note on outputs:** The outputs in this notebook were generated on an **NVIDIA H200 GPU** (90MB L2 cache, 4.8 TB/s memory bandwidth). Your results may vary depending on your hardware. The H200's large cache means cache effects are less dramatic than on older GPUs like A100 (40MB L2) or consumer cards.\n", + "\n", + "## TL;DR — How to Benchmark Correctly\n", + "\n", + "Benchmarking on GPUs requires a strict protocol to avoid measuring Python overhead or caching artifacts. To get reliable numbers, you must:\n", + "\n", + "1. **Warmup:** Run the kernel ~10-50 times first to settle compilation and memory allocators.\n", + "2. **Sample Extensively:** Don't trust one run. Collect 100+ samples to build a statistical distribution.\n", + "3. **Flush the L2 Cache:** Between *every* sample, flush the cache to force a cold cache state (simulating real-world inference).\n", + "4. **Use Device Timers:** Use `torch.cuda.Event` instead of `time.time()` to measure execution on the GPU, not the CPU driver.\n", + "5. **Aggregate Robustly:** Aggregate over many samples to filter out jitter/outliers.\n", + "6. **Wait for sidestreams to finish:** Ensure no side-streams are running or wait for all of them to finish before reporting a time.\n", + "\n", + "*Pro-Tip:* **KernelBench's timing module** (`src/timing.py`) implements all these best practices. Use `get_timing_function(\"cuda_event\")` for trusted code or `get_timing_function(\"host_time\")` for evaluating untrusted/agent-generated code.\n", + "\n", + "-----\n", + "\n", + "If are using an LLM agent to write GPU kernels (and evaluating against something like say [Kernel Bench](https://github.com/ScalingIntelligence/KernelBench)), or just trying to optimize a custom GPU kernel, you are eventually going to ask: **\"How fast is this thing?\"**\n", + "\n", + "This notebook is heavily inspired by [this great guide](https://www.youtube.com/watch?v=1i7dxoAfKOU) from the **GPU MODE** community and the practical \"footguns\" (traps) encountered while building benchmarking harnesses for LLM-generated code. Our goal here is simplicity and keeping things Pythonic—for more advanced techniques, see the footnotes.\n", + "\n", + "We won't just list best practices. Instead, we are going to build a benchmarking harness from scratch, make every common mistake, debug why the numbers are wrong, and iterate our way to a robust solution. So let's start things out by doing the most naive thing by using `time.time()`!" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:36.427802Z", + "iopub.status.busy": "2025-12-17T21:24:36.427684Z", + "iopub.status.idle": "2025-12-17T21:24:40.995279Z", + "shell.execute_reply": "2025-12-17T21:24:40.994328Z" + }, + "id": "PKWz_W7uzX2f", + "outputId": "8751fd78-569b-4080-f21a-60bbb5ee8caf" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/simon/palic/KernelBench/.venv/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using GPU: NVIDIA H200\n" + ] + } + ], + "source": [ + "# @title Environment Setup\n", + "# Ensure we have the necessary libraries and a GPU available\n", + "# !pip install -q triton matplotlib numpy torch\n", + "# !pip install -e .. # Install KernelBench locally for timing utilities\n", + "\n", + "import sys\n", + "import os\n", + "sys.path.insert(0, '..') # Add parent directory to path for imports\n", + "\n", + "# For multi-GPU systems, set CUDA_VISIBLE_DEVICES=X before running to select a specific GPU\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"5\"\n", + "\n", + "import torch\n", + "import time\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import triton\n", + "\n", + "# Import KernelBench's timing module\n", + "from src import timing\n", + "from src.timing import clear_l2_cache, get_timing_stats, get_timing_function\n", + "\n", + "if not torch.cuda.is_available():\n", + " raise RuntimeError(\"This notebook requires a GPU. Please enable GPU in your runtime settings.\")\n", + "\n", + "# Device configuration\n", + "# The selected GPU will appear as cuda:0\n", + "\n", + "DEVICE = f\"cuda:0\"\n", + "print(f\"Using GPU: {torch.cuda.get_device_name(DEVICE)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kjWByrwvzX2f" + }, + "source": [ + "## The Journey: Benchmarking a Matrix Multiplication\n", + "\n", + "Let's define a simple workload to test. We want to measure the performance of a standard Matrix Multiplication." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:40.997969Z", + "iopub.status.busy": "2025-12-17T21:24:40.997722Z", + "iopub.status.idle": "2025-12-17T21:24:41.252072Z", + "shell.execute_reply": "2025-12-17T21:24:41.250967Z" + }, + "id": "gxtKes5lzX2g", + "outputId": "5890bae4-5b9a-4366-8947-367146593158" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Output shape: torch.Size([8192, 8192])\n", + "Op ran successfully\n" + ] + } + ], + "source": [ + "# A standard size for testing\n", + "N = 8192\n", + "\n", + "def get_data(n=N, device=DEVICE):\n", + " \"\"\"Generate random float32 matrices for benchmarking.\"\"\"\n", + " return torch.randn(n, n, device=device), torch.randn(n, n, device=device)\n", + "\n", + "def simple_mm(a, b):\n", + " \"\"\"Our kernel under test: standard matrix multiplication.\"\"\"\n", + " return torch.matmul(a, b)\n", + "\n", + "# Let's verify it runs\n", + "a, b = get_data()\n", + "res = simple_mm(a, b)\n", + "print(f\"Output shape: {res.shape}\")\n", + "print(\"Op ran successfully\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GWlsBEVyzX2g" + }, + "source": [ + "### Attempt 1: The Naive Timer\n", + "\n", + "The most intuitive way to time code in Python is using `time.time()`. Let's try that first." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:41.254622Z", + "iopub.status.busy": "2025-12-17T21:24:41.254499Z", + "iopub.status.idle": "2025-12-17T21:24:41.258106Z", + "shell.execute_reply": "2025-12-17T21:24:41.257414Z" + }, + "id": "LynIxLaRzX2g", + "outputId": "72548dad-6570-4eaa-ce07-923556fe70b4" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Naive time: 0.6356 ms\n" + ] + } + ], + "source": [ + "def benchmark_naive(func, *args):\n", + " \"\"\"WRONG: Measures kernel launch time, not execution time.\"\"\"\n", + " start = time.time()\n", + " func(*args)\n", + " end = time.time()\n", + " return (end - start) * 1000 # to ms\n", + "\n", + "t = benchmark_naive(simple_mm, a, b)\n", + "print(f\"Naive time: {t:.4f} ms\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gw4NGYRmzX2h" + }, + "source": [ + "**The Problem:**\n", + "Wait, less than 1ms? That seems impossibly fast for a 8192² matrix multiplication involving over 1 trillion floating-point operations.[¹](#footnote-1)\n", + "\n", + "**What happened?**\n", + "GPUs are **asynchronous**. When you call `torch.matmul`, the CPU doesn't actually do the math. It simply queues a \"launch kernel\" command to the GPU and moves on immediately. Our timer didn't measure the matrix multiplication; it measured how long it took Python to place an order in the queue.\n", + "\n", + "To fix this, we need to:\n", + "1. **Synchronize** - Force the CPU to wait for the GPU with `torch.cuda.synchronize()`\n", + "2. **Use CUDA Events** - Record timestamps directly on the GPU to avoid CPU overhead\n", + "\n", + "Let's compare these approaches to see the difference.\n", + "\n", + "---\n", + "\n", + "\n", + "¹ **Why impossible?** The [H200](https://www.nvidia.com/en-us/data-center/h200/) peaks at 989 TFLOPS for TF32 Tensor Cores. At that rate: 1.1 TFLOP ÷ 989 TFLOP/s = **1.11ms minimum**. Anything under 1ms is physically impossible." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Attempt 2: Synchronizing the Device\n", + "\n", + "To fix this, we need to force the CPU to wait until the GPU has finished its work before we stop the clock. We do this with `torch.cuda.synchronize()`." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "execution": { + "iopub.execute_input": "2025-12-17T21:24:41.260592Z", + "iopub.status.busy": "2025-12-17T21:24:41.260479Z", + "iopub.status.idle": "2025-12-17T21:24:41.460207Z", + "shell.execute_reply": "2025-12-17T21:24:41.459267Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sync time: 21.5368 ms\n" + ] + } + ], + "source": [ + "def benchmark_sync(func, *args):\n", + " \"\"\"Better: Actually waits for GPU to finish.\"\"\"\n", + " torch.cuda.synchronize() # Wait for previous work to finish\n", + " start = time.time()\n", + " func(*args)\n", + " torch.cuda.synchronize() # Wait for THIS work to finish\n", + " end = time.time()\n", + " return (end - start) * 1000\n", + "\n", + "t = benchmark_sync(simple_mm, a, b)\n", + "print(f\"Sync time: {t:.4f} ms\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dV8AmQi-zX2i" + }, + "source": [ + "### Attempt 3: Removing CPU Overhead (CUDA Events)\n", + "\n", + "To get a precise measurement, we need to bypass the CPU clock entirely. We can ask the GPU driver to record timestamps directly on the device using `torch.cuda.Event`." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:41.463315Z", + "iopub.status.busy": "2025-12-17T21:24:41.463177Z", + "iopub.status.idle": "2025-12-17T21:24:41.532922Z", + "shell.execute_reply": "2025-12-17T21:24:41.531966Z" + }, + "id": "i6PfSdkTzX2i", + "outputId": "8b3e29d1-1789-4bfb-9a44-599016516dd7" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Run 0: 21.7344 ms\n", + "Run 1: 21.4754 ms\n", + "Run 2: 21.4987 ms\n" + ] + } + ], + "source": [ + "def benchmark_events(func, *args):\n", + " \"\"\"Better: Uses GPU timestamps, avoiding CPU overhead.\"\"\"\n", + " start_event = torch.cuda.Event(enable_timing=True)\n", + " end_event = torch.cuda.Event(enable_timing=True)\n", + "\n", + " torch.cuda.synchronize(device=DEVICE)\n", + " start_event.record()\n", + " func(*args)\n", + " end_event.record()\n", + " torch.cuda.synchronize(device=DEVICE)\n", + "\n", + " return start_event.elapsed_time(end_event) # Returns ms directly\n", + "\n", + "# Run it a few times\n", + "for i in range(3):\n", + " print(f\"Run {i}: {benchmark_events(simple_mm, a, b):.4f} ms\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BkfaaDawzX2i" + }, + "source": [ + "### Attempt 4: Handling the \"Cold Start\"\n", + "\n", + "Notice Run 0 is noticably slower than the rest. The first time you run a PyTorch function (and similarly launching a cuda kernel), the framework does a lot of heavy lifting which could include: allocating memory, initializing cuBLAS/cuDNN workspaces, lazy kernel loading, and compiling kernels (especially if using `torch.compile` or Triton). This \"Cold Start\" penalty is a one-time cost that shouldn't be included in your performance metrics.\n", + "\n", + "**The Fix:**\n", + "We need to perform **Warmup Runs**—running the kernel a few times to settle the system state before we start measuring." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:41.535509Z", + "iopub.status.busy": "2025-12-17T21:24:41.535387Z", + "iopub.status.idle": "2025-12-17T21:24:42.246476Z", + "shell.execute_reply": "2025-12-17T21:24:42.245382Z" + }, + "id": "j_PsAuJkzX2i", + "outputId": "d6983401-72d3-468c-ffd8-c0833e8d5556" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Run 0: 21.6478 ms\n", + "Run 1: 21.4837 ms\n", + "Run 2: 21.4852 ms\n" + ] + } + ], + "source": [ + "def benchmark_warmup(func, *args, warmup_iters=30, benchmark_iters=3):\n", + " \"\"\"Better: Includes warmup to avoid cold-start penalty.\"\"\"\n", + " # Warmup phase\n", + " for _ in range(warmup_iters):\n", + " func(*args)\n", + " torch.cuda.synchronize(device=DEVICE)\n", + "\n", + " # Measurement phase\n", + " measurements = []\n", + " for _ in range(benchmark_iters):\n", + " measurements.append(benchmark_events(func, *args))\n", + " torch.cuda.synchronize(device=DEVICE)\n", + " return measurements\n", + "\n", + "# print(f\"Warmed up time: {benchmark_warmup(simple_mm, a, b):.4f} ms\")\n", + "\n", + "for i, measurement in enumerate(benchmark_warmup(simple_mm, a, b)):\n", + " print(f\"Run {i}: {measurement:.4f} ms\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OR3uOh7kzX2i" + }, + "source": [ + "### Attempt 5: The Single Sample Fallacy (Variance)\n", + "\n", + "Relying on a single sample after warmup is bad science. Operating systems are noisy; background processes interrupt the CPU, and GPU clocks fluctuate thermally. A single measurement is anecdotal, not statistical.\n", + "\n", + "#### Visualizing the Jitter\n", + "\n", + "Let's run the benchmark 100 times and plot every single run. You will clearly see the \"Cold Start\" spike and the noise floor of the OS." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 653 + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:42.248937Z", + "iopub.status.busy": "2025-12-17T21:24:42.248818Z", + "iopub.status.idle": "2025-12-17T21:24:44.484746Z", + "shell.execute_reply": "2025-12-17T21:24:44.483759Z" + }, + "id": "T-7QH4cHzX2i", + "outputId": "c758effd-a810-422d-d3ca-66c128cdb716" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean: 21.5096 ms\n", + "Median: 21.4942 ms\n", + "Std: 0.0625 ms\n", + "Min: 21.4420 ms\n", + "Max: 21.7808 ms\n" + ] + } + ], + "source": [ + "# Collect 100 samples\n", + "timings = []\n", + "for i in range(100):\n", + " timings.append(benchmark_events(simple_mm, a, b))\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "plt.scatter(range(100), timings, alpha=0.6)\n", + "plt.axhline(y=np.median(timings), color='r', linestyle='--', label=f'Median: {np.median(timings):.4f} ms')\n", + "plt.axhline(y=np.mean(timings), color='g', linestyle=':', label=f'Mean: {np.mean(timings):.4f} ms')\n", + "plt.title(\"Benchmarking Jitter & Cold Start\")\n", + "plt.ylabel(\"Time (ms)\")\n", + "plt.xlabel(\"Run Index\")\n", + "plt.legend()\n", + "plt.grid(True, alpha=0.3)\n", + "plt.show()\n", + "\n", + "print(f\"Mean: {np.mean(timings):.4f} ms\")\n", + "print(f\"Median: {np.median(timings):.4f} ms\")\n", + "print(f\"Std: {np.std(timings):.4f} ms\")\n", + "print(f\"Min: {np.min(timings):.4f} ms\")\n", + "print(f\"Max: {np.max(timings):.4f} ms\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hX_-OpftzX2i" + }, + "source": [ + "You will see a massive dot at $x=0$ (the cold start), followed by a cloud of dots hovering around the \"true\" time. This visualizes why we need **Warmup** (to skip $x=0$) and **Statistics** (to handle the cloud).\n", + "\n", + "Notice how the **Mean** is pulled upward by the outliers, while the **Median** represents the typical case more accurately. When possible, we should use the **Median** as our final metric.\n", + "\n", + "### Attempt 6: The \"Robust\" Harness (Flushing Cache)\n", + "\n", + "Modern GPUs have large L2 caches (40MB-192MB depending on architecture). If your data fits in the cache, subsequent iterations in your loop will skip the slow VRAM access, artificially inflating your speed. In production, data usually streams in from VRAM, so this \"hot cache\" benchmark is misleading.\n", + "\n", + "**The Fix:**\n", + "We must **flush the L2 cache** between *every single sample*. We do this by writing to a tensor large enough to completely evict the cache contents. KernelBench uses a ~256MB tensor to safely cover all GPU architectures, including the largest caches (e.g., Blackwell at ~192MB)." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "execution": { + "iopub.execute_input": "2025-12-17T21:24:44.487140Z", + "iopub.status.busy": "2025-12-17T21:24:44.487016Z", + "iopub.status.idle": "2025-12-17T21:24:44.489937Z", + "shell.execute_reply": "2025-12-17T21:24:44.489208Z" + }, + "id": "Kj5azcpxzX2j" + }, + "outputs": [], + "source": [ + "# KernelBench provides utilities to flush the L2 cache\n", + "# This is important for cold cache measurements that simulate real-world inference\n", + "\n", + "def clear_l2_cache(device=DEVICE):\n", + " \"\"\"Flush L2 cache by writing to a large tensor.\n", + " \n", + " L2 cache sizes vary by GPU, so we use 256MB to cover all cases.\n", + " \"\"\"\n", + " dummy = torch.empty((32, 1024, 1024), dtype=torch.int64, device=device) # 256MB\n", + " dummy.fill_(1901) # Force write to thrash cache\n", + " del dummy\n", + "\n", + "# KernelBench also provides clear_l2_cache_triton() for cross-platform support\n", + "# (works on both NVIDIA and AMD GPUs via Triton's device abstraction)\n", + "from src.timing import clear_l2_cache_triton" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Why does flushing the cache matter?\n", + "\n", + "Let's see the cache effect in action. We'll benchmark the same operation twice:\n", + "1. **Without** cache flushing between runs (data stays in L2 cache)\n", + "2. **With** cache flushing between runs (data must be fetched from VRAM each time)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "execution": { + "iopub.execute_input": "2025-12-17T21:24:44.492322Z", + "iopub.status.busy": "2025-12-17T21:24:44.492090Z", + "iopub.status.idle": "2025-12-17T21:24:44.507209Z", + "shell.execute_reply": "2025-12-17T21:24:44.506066Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Without cache flushing (warm cache):\n", + "\n", + "With cache flushing (cold cache):\n", + "\n", + "Warm cache median: 0.0280 ms\n", + "Cold cache median: 0.0318 ms\n", + "Difference: 0.0038 ms (13.7% slower with cold cache)\n", + "\n", + "Without cache flushing, you measure artificially fast times!\n" + ] + } + ], + "source": [ + "# Demonstrate why L2 cache flushing matters\n", + "# Use a smaller matrix so the effect is visible (data fits in cache)\n", + "N_SMALL = 512\n", + "a_small, b_small = get_data(N_SMALL)\n", + "\n", + "NUM_SAMPLES = 20\n", + "\n", + "# do warmup runs\n", + "for _ in range(NUM_SAMPLES):\n", + " clear_l2_cache(device=DEVICE)\n", + " benchmark_events(simple_mm, a_small, b_small)\n", + " torch.cuda.synchronize(device=DEVICE)\n", + "\n", + "# Benchmark WITHOUT cache flushing (warm cache - unrealistic)\n", + "print(\"Without cache flushing (warm cache):\")\n", + "times_warm = []\n", + "for i in range(NUM_SAMPLES):\n", + " t = benchmark_events(simple_mm, a_small, b_small)\n", + " times_warm.append(t)\n", + "\n", + "# Benchmark WITH cache flushing (cold cache - realistic)\n", + "print(\"\\nWith cache flushing (cold cache):\")\n", + "times_cold = []\n", + "for i in range(NUM_SAMPLES):\n", + " clear_l2_cache(device=DEVICE) # Flush cache before each measurement\n", + " t = benchmark_events(simple_mm, a_small, b_small)\n", + " times_cold.append(t)\n", + "\n", + "print(f\"\\nWarm cache median: {np.median(times_warm):.4f} ms\")\n", + "print(f\"Cold cache median: {np.median(times_cold):.4f} ms\")\n", + "print(f\"Difference: {np.median(times_cold) - np.median(times_warm):.4f} ms ({(np.median(times_cold)/np.median(times_warm) - 1)*100:.1f}% slower with cold cache)\")\n", + "print(\"\\nWithout cache flushing, you measure artificially fast times!\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "execution": { + "iopub.execute_input": "2025-12-17T21:24:44.509465Z", + "iopub.status.busy": "2025-12-17T21:24:44.509344Z", + "iopub.status.idle": "2025-12-17T21:24:44.597419Z", + "shell.execute_reply": "2025-12-17T21:24:44.596500Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize the cache effect\n", + "# Discard first few samples to remove initialization noise\n", + "discard = 3\n", + "times_warm_clean = times_warm[discard:]\n", + "times_cold_clean = times_cold[discard:]\n", + "\n", + "plt.figure(figsize=(10, 5))\n", + "plt.scatter(range(len(times_warm_clean)), times_warm_clean, alpha=0.7, label=f'Warm Cache (mean={np.mean(times_warm_clean):.4f}ms)', color='orange', s=60)\n", + "plt.scatter(range(len(times_cold_clean)), times_cold_clean, alpha=0.7, label=f'Cold Cache (mean={np.mean(times_cold_clean):.4f}ms)', color='blue', s=60)\n", + "plt.axhline(y=np.mean(times_warm_clean), color='orange', linestyle='--', alpha=0.5)\n", + "plt.axhline(y=np.mean(times_cold_clean), color='blue', linestyle='--', alpha=0.5)\n", + "plt.xlabel('Run Index')\n", + "plt.ylabel('Time (ms)')\n", + "plt.title(f'Cache Effect on {N_SMALL}x{N_SMALL} Matrix Multiplication\\n(first {discard} samples discarded)')\n", + "plt.legend()\n", + "plt.grid(True, alpha=0.3)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FAaH1cdBzX2j" + }, + "source": [ + "### Putting it all together\n", + "\n", + "We have now discovered that a robust benchmark requires:\n", + "\n", + "1. Device Synchronization\n", + "2. CUDA Events (to avoid CPU overhead)\n", + "3. Warmup Runs (to avoid initialization costs)\n", + "4. Multiple Samples (to handle variance)\n", + "5. Cache Flushing (to simulate VRAM access)\n", + "6. Median/Mean Aggregation (to ignore jitter)\n", + "\n", + "Writing this boilerplate every time is painful. We've packaged all these lessons into **KernelBench's timing module**, which provides multiple timing methods for different use cases. There are also other robust implementations available, such as Triton's `do_bench` [function](https://triton-lang.org/main/python-api/generated/triton.testing.do_bench.html).\n", + "\n", + "The default `cuda_event` method in KernelBench implements all of the above automatically, plus an additional insight: **`discard_first`** - discarding the first few trials after warmup, which often still have some initialization overhead." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:44.600123Z", + "iopub.status.busy": "2025-12-17T21:24:44.600004Z", + "iopub.status.idle": "2025-12-17T21:24:47.005899Z", + "shell.execute_reply": "2025-12-17T21:24:47.004654Z" + }, + "id": "3aVFtWt_zX2j", + "outputId": "6cf1e493-86ca-419e-a8e1-e19486814e09" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Profiling] Using timing method: cuda_event\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", + "KernelBench cuda_event time: 21.5000 ms\n" + ] + } + ], + "source": [ + "# Get the timing function - cuda_event is the default for trusted code\n", + "timing_fn = get_timing_function(\"cuda_event\")\n", + "\n", + "def final_benchmark(func, *args, num_trials=100):\n", + " \"\"\"Production-ready benchmarking using KernelBench's timing module.\"\"\"\n", + " elapsed_times = timing_fn(\n", + " kernel_fn=func,\n", + " args=list(args),\n", + " num_warmup=10,\n", + " num_trials=num_trials,\n", + " discard_first=1, # Discard first trial for consistency\n", + " verbose=False,\n", + " device=DEVICE\n", + " )\n", + " stats = get_timing_stats(elapsed_times, device=DEVICE)\n", + " return stats[\"mean\"]\n", + "\n", + "t = final_benchmark(simple_mm, a, b)\n", + "print(f\"KernelBench cuda_event time: {t:.4f} ms\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "MsZrCYQRzX2j" + }, + "source": [ + "*Note: KernelBench also wraps Triton's `do_bench` if you prefer adaptive trial counts. See the timing methods comparison below for details.*\n", + "\n", + "---\n", + "\n", + "## KernelBench's Timing Methods Explained\n", + "\n", + "Now that we've built up a robust benchmarking harness from first principles, let's explore KernelBench's timing module in depth. We'll examine:\n", + "- **All 4 timing methods** and when to use each\n", + "- **The `discard_first` parameter** and why it improves measurement consistency\n", + "- **How `host_time` detects side-stream exploits** in untrusted code\n", + "\n", + "KernelBench's timing module provides **4 timing methods**, each designed for different use cases:\n", + "\n", + "| Method | Use Case | Catches Side-Streams | Cold Cache | Trial Control |\n", + "|--------|----------|---------------------|------------|---------------|\n", + "| `cuda_event` | Default, trusted code | No | Yes | Explicit |\n", + "| `host_time` | Untrusted code, agent evals | **Yes** | Yes | Explicit |\n", + "| `do_bench` | Triton-style / robust adaptive | No | Yes | Adaptive (time-budget) |\n", + "| `do_bench_impl` | do_bench implementation for inference and trial control | No | Yes | Explicit |\n", + "\n", + "### Method Details\n", + "\n", + "**`cuda_event`** (Default)\n", + "- Uses `torch.cuda.Event` for GPU-side timing\n", + "- Most accurate for pure kernel time measurement\n", + "- Clears L2 cache before each trial for cold-cache performance\n", + "- Use for trusted code where you control the kernel implementation\n", + "\n", + "**`host_time`** (For Untrusted Code)\n", + "- Uses **both** `time.perf_counter()` (host) and `torch.cuda.Event` (device) timing\n", + "- Compares the two: if they differ significantly, the CUDA event time is likely invalid (e.g., side-stream exploit)\n", + "- Falls back to host time when discrepancy detected, ensuring correctness\n", + "- Waits for ALL streams via `torch.cuda.synchronize()`\n", + "- **Essential for evaluating untrusted/agent-generated code**\n", + "\n", + "**`do_bench`** (Triton's Adaptive Benchmarking)\n", + "- Wraps Triton's `triton.testing.do_bench`\n", + "- Uses fixed time budgets: 25ms warmup, 100ms for repetitions\n", + "- Trial count is automatic based on kernel runtime\n", + "- **Note:** `num_warmup`, `num_trials`, `discard_first` parameters are ignored\n", + "\n", + "**`do_bench_impl`** (Transparent Implementation)\n", + "- Custom implementation mirroring Triton's do_bench\n", + "- Gives you explicit control over `num_warmup` and `num_trials`\n", + "- Useful when you need do_bench's approach but with specific trial counts\n", + "\n", + "### Key Parameters\n", + "\n", + "All timing functions share a common interface:\n", + "\n", + "```python\n", + "timing_fn(\n", + " kernel_fn, # Function to time\n", + " args, # List of arguments to pass\n", + " num_warmup=3, # Warmup iterations before timing\n", + " num_trials=10, # Number of timing samples to collect\n", + " discard_first=1, # Drop first N trials after warmup\n", + " device=\"cuda:0\", # Explicit GPU device selection\n", + " verbose=True # Print per-trial timing info\n", + ") -> list[float] # Returns list of elapsed times in ms\n", + "```\n", + "\n", + "### Why `discard_first`?\n", + "\n", + "Even after warmup, the first few timing trials can be affected by:\n", + "- PyTorch's lazy tensor allocation finalizing\n", + "- cuDNN autotuning (still settling optimal algorithms)\n", + "- Driver state initialization\n", + "- First access to data structures\n", + "\n", + "Setting `discard_first=1` (the default) improves measurement consistency. Let's visualize this effect:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Comparing All 4 Timing Methods\n", + "\n", + "Let's see how the different timing methods compare on the same kernel. Each method has trade-offs between precision, features, and overhead." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "execution": { + "iopub.execute_input": "2025-12-17T21:24:47.008751Z", + "iopub.status.busy": "2025-12-17T21:24:47.008456Z", + "iopub.status.idle": "2025-12-17T21:24:50.238519Z", + "shell.execute_reply": "2025-12-17T21:24:50.237366Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Comparing all KernelBench timing methods on 4096x4096 matmul:\n", + "======================================================================\n", + "\n", + "Testing cuda_event...\n", + "[Profiling] Using timing method: cuda_event\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 50\n", + " cuda_event: 21.5000 ms (std=0.0572)\n", + "\n", + "Testing host_time...\n", + "[Profiling] Using timing method: host_time\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 50\n", + " host_time: 21.5000 ms (std=0.0427)\n", + "\n", + "Testing do_bench...\n", + "[Profiling] Using timing method: do_bench\n", + " do_bench: 21.4000 ms (std=0.0030)\n", + "\n", + "Testing do_bench_impl...\n", + "[Profiling] Using timing method: do_bench_impl\n", + " do_bench_impl: 21.4000 ms (std=0.0315)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_710987/1660294801.py:64: UserWarning: Attempting to set identical low and high ylims makes transformation singular; automatically expanding.\n", + " axes[1].set_ylim(min_val - margin, max_val + margin)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Key insight: host_time is slightly slower due to CPU overhead,\n", + "but it catches ALL work on ALL streams - essential for untrusted code!\n" + ] + } + ], + "source": [ + "# Compare all KernelBench timing methods on 4096x4096 matmul\n", + "print(\"Comparing all KernelBench timing methods on 4096x4096 matmul:\")\n", + "print(\"=\" * 70)\n", + "\n", + "methods = [\"cuda_event\", \"host_time\", \"do_bench\", \"do_bench_impl\"]\n", + "results = {}\n", + "\n", + "for method in methods:\n", + " print(f\"\\nTesting {method}...\")\n", + " try:\n", + " method_fn = get_timing_function(method)\n", + " times = method_fn(\n", + " simple_mm, \n", + " [a, b], \n", + " num_warmup=10, \n", + " num_trials=50, \n", + " verbose=False,\n", + " device=DEVICE\n", + " )\n", + " results[method] = get_timing_stats(times, device=DEVICE)\n", + " print(f\" {method}: {results[method]['mean']:.4f} ms (std={results[method]['std']:.4f})\")\n", + " except Exception as e:\n", + " print(f\" {method}: Skipped due to {type(e).__name__} (Triton version compatibility)\")\n", + " # Remove from list if it failed\n", + " methods = [m for m in methods if m in results]\n", + "\n", + "# Only plot if we have results\n", + "if results:\n", + " # Visualize the comparison\n", + " fig, axes = plt.subplots(1, 2, figsize=(12, 5))\n", + "\n", + " # Bar chart of mean times\n", + " available_methods = [m for m in methods if m in results]\n", + " means = [results[m]['mean'] for m in available_methods]\n", + " stds = [results[m]['std'] for m in available_methods]\n", + " colors = ['#2ecc71', '#e74c3c', '#3498db', '#9b59b6'][:len(available_methods)]\n", + "\n", + " axes[0].bar(available_methods, means, yerr=stds, capsize=5, color=colors, alpha=0.8)\n", + " axes[0].set_ylabel('Time (ms)')\n", + " axes[0].set_title('Mean Execution Time by Method\\n(graph truncated for readability)')\n", + " axes[0].tick_params(axis='x', rotation=45)\n", + "\n", + " # Truncate y-axis to make differences easier to see\n", + " min_mean = min(means)\n", + " max_mean = max(means)\n", + " margin = (max_mean - min_mean) * 2\n", + " axes[0].set_ylim(min_mean - margin, max_mean + margin)\n", + "\n", + " # Highlight cuda_event vs host_time with truncated y-axis for readability\n", + " if 'cuda_event' in results and 'host_time' in results:\n", + " cuda_mean = results['cuda_event']['mean']\n", + " host_mean = results['host_time']['mean']\n", + " \n", + " axes[1].bar(['cuda_event', 'host_time'], \n", + " [cuda_mean, host_mean], \n", + " color=['#2ecc71', '#e74c3c'], alpha=0.8)\n", + " axes[1].set_ylabel('Time (ms)')\n", + " axes[1].set_title('cuda_event vs host_time\\n(host_time catches side-streams)\\n(graph truncated for readability)')\n", + " \n", + " # Truncate y-axis to make the difference easier to see\n", + " min_val = min(cuda_mean, host_mean)\n", + " max_val = max(cuda_mean, host_mean)\n", + " margin = (max_val - min_val) * 2 # Add margin around the data\n", + " axes[1].set_ylim(min_val - margin, max_val + margin)\n", + " else:\n", + " axes[1].text(0.5, 0.5, 'Comparison unavailable', ha='center', va='center')\n", + " axes[1].set_axis_off()\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "print(\"\\nKey insight: host_time is slightly slower due to CPU overhead,\")\n", + "print(\"but it catches ALL work on ALL streams - essential for untrusted code!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The `discard_first` Effect\n", + "\n", + "Even after warmup, the first timing trial can be affected by lazy initialization. Let's see this in action." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "execution": { + "iopub.execute_input": "2025-12-17T21:24:50.241069Z", + "iopub.status.busy": "2025-12-17T21:24:50.240945Z", + "iopub.status.idle": "2025-12-17T21:24:50.348421Z", + "shell.execute_reply": "2025-12-17T21:24:50.347364Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Demonstrating the discard_first effect:\n", + "============================================================\n", + "[Profiling] Using timing method: cuda_event\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 15\n", + "\n", + "First trial: 0.3660 ms\n", + "Mean of all trials: 0.3455 ms\n", + "Mean without first: 0.3440 ms\n", + "First trial overhead: 6.4%\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "The first trial often shows initialization overhead even after warmup.\n", + "Using discard_first=1 (default) gives more consistent measurements.\n" + ] + } + ], + "source": [ + "# Demonstrate the discard_first effect\n", + "# Even after warmup, the first timing trial can have higher overhead\n", + "\n", + "print(\"Demonstrating the discard_first effect:\")\n", + "print(\"=\" * 60)\n", + "\n", + "# Create fresh data and clear caches to make initialization overhead more visible\n", + "torch.cuda.empty_cache()\n", + "a_fresh, b_fresh = get_data(2048)\n", + "\n", + "# Collect trials with discard_first=0 to see ALL trials including the first one\n", + "timing_fn = get_timing_function(\"cuda_event\")\n", + "times_all = timing_fn(\n", + " simple_mm, [a_fresh, b_fresh],\n", + " num_warmup=3,\n", + " num_trials=15,\n", + " discard_first=0, # Keep ALL trials including first\n", + " verbose=False,\n", + " device=DEVICE\n", + ")\n", + "\n", + "# Calculate statistics\n", + "first_trial = times_all[0]\n", + "remaining_trials = times_all[1:]\n", + "mean_all = np.mean(times_all)\n", + "mean_remaining = np.mean(remaining_trials)\n", + "\n", + "print(f\"\\nFirst trial: {first_trial:.4f} ms\")\n", + "print(f\"Mean of all trials: {mean_all:.4f} ms\")\n", + "print(f\"Mean without first: {mean_remaining:.4f} ms\")\n", + "print(f\"First trial overhead: {((first_trial / mean_remaining) - 1) * 100:.1f}%\")\n", + "\n", + "# Visualize the effect with a scatter plot\n", + "plt.figure(figsize=(10, 5))\n", + "plt.scatter(range(len(times_all)), times_all, alpha=0.7, color='blue', s=60)\n", + "plt.scatter([0], [first_trial], color='red', s=100, zorder=5, label=f'First trial: {first_trial:.3f}ms')\n", + "plt.axhline(y=mean_remaining, color='green', linestyle='--', alpha=0.7, \n", + " label=f'Mean (without first): {mean_remaining:.3f}ms')\n", + "plt.axhline(y=mean_all, color='orange', linestyle=':', alpha=0.7,\n", + " label=f'Mean (all): {mean_all:.3f}ms')\n", + "plt.xlabel('Trial Index')\n", + "plt.ylabel('Time (ms)')\n", + "plt.title('First Trial Overhead Effect (after warmup)')\n", + "plt.legend(loc='upper right')\n", + "plt.grid(True, alpha=0.3)\n", + "plt.show()\n", + "\n", + "print(\"\\nThe first trial often shows initialization overhead even after warmup.\")\n", + "print(\"Using discard_first=1 (default) gives more consistent measurements.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HwsjlhAazX2j" + }, + "source": [ + "## The \"Agent\" Trap: Reward Hacking via Hidden Streams\n", + "\n", + "When evaluating LLM-generated kernels (like with [Kernel Bench](https://github.com/ScalingIntelligence/KernelBench)), you're not just fighting measurement noise—you're fighting an optimizer that may inadvertently discover exploits in your harness.\n", + "\n", + "One such exploit: launching work on a **side stream** to make the kernel appear instantaneous." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:50.351000Z", + "iopub.status.busy": "2025-12-17T21:24:50.350876Z", + "iopub.status.idle": "2025-12-17T21:24:52.778917Z", + "shell.execute_reply": "2025-12-17T21:24:52.777685Z" + }, + "id": "UuwtML39zX2j", + "outputId": "95ebbb26-e415-491a-da30-6a78ce387906" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", + "Standard benchmark on tricky kernel: 0.1880 ms\n" + ] + } + ], + "source": [ + "def tricky_agent_kernel(a, b):\n", + " \"\"\"A 'clever' kernel that games the benchmarking harness.\"\"\"\n", + " # The agent creates a new stream to \"optimize\"\n", + " s = torch.cuda.Stream()\n", + " with torch.cuda.stream(s):\n", + " # This work happens on a side channel!\n", + " result = torch.matmul(a, b)\n", + " return result\n", + "\n", + "print(f\"Standard benchmark on tricky kernel: {final_benchmark(tricky_agent_kernel, a, b):.4f} ms\")\n", + "# Likely reports ~0.00ms or very close to it!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3HXns_XizX2j" + }, + "source": [ + "**The Issue:**\n", + "Standard benchmarking tools (including `do_bench`) record events on the *current default stream*.\n", + "\n", + "1. Benchmark starts timer on Stream A (the default stream).\n", + "2. Agent launches work on Stream B and returns immediately.\n", + "3. Benchmark stops timer on Stream A.\n", + "\n", + "Since Stream A had no work, the timer reports `~0.00ms`, while Stream B is still churning away in the background.\n", + "\n", + "**Why this matters for evals:**\n", + "If your reward signal is \"lower time = better score,\" an agent that discovers this pattern will be rewarded for producing *broken* code. The kernel \"runs\" instantly because you never measured it at all.\n", + "\n", + "**Mitigations:**\n", + "- **Wall-clock + full device sync:** Trade precision for correctness (catches all streams, but includes CPU overhead)\n", + "- **Static analysis:** Reject submissions that create `torch.cuda.Stream()` objects\n", + "- **Manual inspection:** For high-stakes evals, benchmark kernels in isolation outside the automated harness\n", + "\n", + "### How KernelBench Addresses This\n", + "\n", + "KernelBench's timing module provides the **`host_time`** method specifically designed for evaluating untrusted code:\n", + "\n", + "**Use `torch.cuda.synchronize()`** before AND after timing - this waits for ALL streams on the device, not just the default stream\n", + "\n", + "```python\n", + "# For trusted code (faster, but can be fooled)\n", + "timing_fn = get_timing_function(\"cuda_event\")\n", + "\n", + "# For untrusted/agent code (catches side-streams)\n", + "timing_fn = get_timing_function(\"host_time\")\n", + "```\n", + "\n", + "The trade-off: `host_time` includes some CPU overhead in the measurement. However, note that host_time should be pretty similar to sync_time. Therefore, if both times are within a some percent of each other, you can be pretty sure that the kernel is running correctly and score using sync_time." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:52.782281Z", + "iopub.status.busy": "2025-12-17T21:24:52.782061Z", + "iopub.status.idle": "2025-12-17T21:24:52.830292Z", + "shell.execute_reply": "2025-12-17T21:24:52.829161Z" + }, + "id": "KbAFqiyizX2j", + "outputId": "6bc91db4-935c-4af9-bdc9-be3c50e890c4" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Robust benchmark on tricky kernel: 21.6298 ms\n", + "Robust benchmark on normal kernel: 21.5420 ms\n" + ] + } + ], + "source": [ + "def benchmark_untrusted(func, *args):\n", + " \"\"\"Benchmark untrusted code by using wall-clock time with full device sync.\n", + "\n", + " This trades some precision (includes CPU overhead) for correctness\n", + " (catches work on any stream).\n", + " \"\"\"\n", + " torch.cuda.synchronize() # Clear any pending work\n", + " start = time.perf_counter()\n", + " func(*args)\n", + " torch.cuda.synchronize() # Wait for ALL streams\n", + " end = time.perf_counter()\n", + " return (end - start) * 1000\n", + "\n", + "print(f\"Robust benchmark on tricky kernel: {benchmark_untrusted(tricky_agent_kernel, a, b):.4f} ms\")\n", + "print(f\"Robust benchmark on normal kernel: {benchmark_untrusted(simple_mm, a, b):.4f} ms\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "execution": { + "iopub.execute_input": "2025-12-17T21:24:52.832854Z", + "iopub.status.busy": "2025-12-17T21:24:52.832734Z", + "iopub.status.idle": "2025-12-17T21:24:53.846639Z", + "shell.execute_reply": "2025-12-17T21:24:53.845578Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Side-Stream Detection Experiment:\n", + "============================================================\n", + "[Profiling] Using timing method: cuda_event\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 10\n", + "[Profiling] Using timing method: host_time\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 10\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 10\n", + "\n", + "Tricky kernel with cuda_event: 0.4400 ms (FOOLED!)\n", + "Tricky kernel with host_time: 21.8000 ms (CORRECT)\n", + "Normal kernel with host_time: 21.5000 ms (reference)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Key insight: host_time correctly measures the tricky kernel!\n", + "Use host_time for evaluating untrusted/agent-generated code.\n" + ] + } + ], + "source": [ + "# Side-Stream Detection with KernelBench's host_time\n", + "# Let's demonstrate how host_time catches the tricky kernel\n", + "\n", + "print(\"Side-Stream Detection Experiment:\")\n", + "print(\"=\" * 60)\n", + "\n", + "# cuda_event (can be fooled by side-streams)\n", + "cuda_timing = get_timing_function(\"cuda_event\")\n", + "cuda_times = cuda_timing(tricky_agent_kernel, [a, b], num_trials=10, verbose=False, device=DEVICE)\n", + "cuda_stats = get_timing_stats(cuda_times, device=DEVICE)\n", + "\n", + "# host_time (catches all streams)\n", + "host_timing = get_timing_function(\"host_time\")\n", + "host_times = host_timing(tricky_agent_kernel, [a, b], num_trials=10, verbose=False, device=DEVICE)\n", + "host_stats = get_timing_stats(host_times, device=DEVICE)\n", + "\n", + "# Normal kernel for reference\n", + "normal_times = host_timing(simple_mm, [a, b], num_trials=10, verbose=False, device=DEVICE)\n", + "normal_stats = get_timing_stats(normal_times, device=DEVICE)\n", + "\n", + "print(f\"\\nTricky kernel with cuda_event: {cuda_stats['mean']:.4f} ms (FOOLED!)\")\n", + "print(f\"Tricky kernel with host_time: {host_stats['mean']:.4f} ms (CORRECT)\")\n", + "print(f\"Normal kernel with host_time: {normal_stats['mean']:.4f} ms (reference)\")\n", + "\n", + "# Visualize the dramatic difference\n", + "plt.figure(figsize=(10, 5))\n", + "methods = ['cuda_event\\n(fooled)', 'host_time\\n(correct)', 'Normal kernel\\n(reference)']\n", + "times = [cuda_stats['mean'], host_stats['mean'], normal_stats['mean']]\n", + "colors = ['red', 'green', 'blue']\n", + "\n", + "plt.bar(methods, times, color=colors, alpha=0.8)\n", + "plt.ylabel('Time (ms)')\n", + "plt.title('Side-Stream Detection: cuda_event vs host_time')\n", + "plt.grid(True, alpha=0.3, axis='y')\n", + "\n", + "# Add annotation\n", + "plt.annotate('Agent trick detected!', xy=(1, host_stats['mean']), \n", + " xytext=(1.3, host_stats['mean'] * 0.7),\n", + " arrowprops=dict(arrowstyle='->', color='green'),\n", + " fontsize=10, color='green')\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "print(\"\\nKey insight: host_time correctly measures the tricky kernel!\")\n", + "print(\"Use host_time for evaluating untrusted/agent-generated code.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Uq4qvl8FzX2j" + }, + "source": [ + "## Correctness Before Speed\n", + "\n", + "A kernel that runs in 0.1ms but produces garbage is worthless. Before you start optimizing, **always verify correctness** against a reference implementation." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:53.849299Z", + "iopub.status.busy": "2025-12-17T21:24:53.849171Z", + "iopub.status.idle": "2025-12-17T21:24:53.929702Z", + "shell.execute_reply": "2025-12-17T21:24:53.928700Z" + }, + "id": "J9W63Q5czX2k", + "outputId": "312076ee-f089-4276-8b8f-bb7a23575d3d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✓ Correctness verified!\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", + "Kernel time: 0.0648 ms\n" + ] + } + ], + "source": [ + "def my_experimental_kernel(a, b):\n", + " \"\"\"Pretend this is our custom optimized kernel.\"\"\"\n", + " return torch.matmul(a, b) # In reality, this would be your Triton/CUDA code\n", + "\n", + "def verify_correctness(kernel_fn, ref_fn, *args, atol=1e-2, rtol=1e-2):\n", + " \"\"\"Verify kernel produces correct output before benchmarking.\"\"\"\n", + " ref_output = ref_fn(*args)\n", + " kernel_output = kernel_fn(*args)\n", + "\n", + " if not torch.allclose(ref_output, kernel_output, atol=atol, rtol=rtol):\n", + " max_diff = (ref_output - kernel_output).abs().max().item()\n", + " raise AssertionError(\n", + " f\"Kernel output doesn't match reference! \"\n", + " f\"Max difference: {max_diff:.6f}\"\n", + " )\n", + " print(\"✓ Correctness verified!\")\n", + " return True\n", + "\n", + "# Always verify before benchmarking\n", + "a_test, b_test = get_data(1024)\n", + "verify_correctness(my_experimental_kernel, simple_mm, a_test, b_test)\n", + "\n", + "# Only benchmark if correct\n", + "time_ms = final_benchmark(my_experimental_kernel, a_test, b_test)\n", + "print(f\"Kernel time: {time_ms:.4f} ms\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Computing TFLOPS: Are We Hitting the Speed of Light?\n", + "\n", + "It is also important to sanity check the results whether it is to see how well we are doing, or to see if our results are physically possible.\n", + "\n", + "To answer this, we convert our millisecond timings into **TFLOPS** (Tera Floating-Point Operations Per Second) and compare against the hardware's theoretical maximum—often called the **\"speed of light\"** or **roofline**.\n", + "\n", + "### Understanding Roofline Analysis\n", + "\n", + "The Roofline Model helps you understand whether your kernel is:\n", + "- **Compute-bound**: Limited by the GPU's arithmetic throughput (FLOPS)\n", + "- **Memory-bound**: Limited by memory bandwidth (GB/s)\n", + "\n", + "**Key formulas:**\n", + "- **Arithmetic Intensity** = FLOPs / Bytes accessed\n", + "- **Theoretical Peak FLOPS** = Clock speed × Cores × FLOPs/cycle\n", + "- **Theoretical Peak Bandwidth** = Memory clock × Bus width × 2 (for DDR)\n", + "\n", + "For matrix multiplication of two $N \\times N$ matrices:\n", + "- **FLOPs** = $2N^3$ (one multiply + one add per output element, summed $N$ times)\n", + "- **Bytes** = $3N^2 \\times \\text{sizeof(dtype)}$ (read A, read B, write C)\n", + "- **Arithmetic Intensity** = $\\frac{2N^3}{3N^2 \\times 4} = \\frac{N}{6}$ for float32\n", + "\n", + "Large matrix multiplications are highly compute-bound (high arithmetic intensity), so we expect to approach the compute roofline. For a deeper dive into roofline analysis and speed-of-light calculations, see the excellent [JAX Scaling Book chapter on Roofline](https://jax-ml.github.io/scaling-book/roofline/)." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "execution": { + "iopub.execute_input": "2025-12-17T21:24:53.932346Z", + "iopub.status.busy": "2025-12-17T21:24:53.932227Z", + "iopub.status.idle": "2025-12-17T21:24:56.741833Z", + "shell.execute_reply": "2025-12-17T21:24:56.740706Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Matrix Multiplication Performance\n", + "=================================================================\n", + "Size Time (ms) TFLOPS % of TF32 Peak \n", + "-----------------------------------------------------------------\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", + "1024 0.0648 33.14 3.4 %\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", + "2048 0.3440 49.94 5.0 %\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", + "4096 2.6800 51.28 5.2 %\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", + "8192 21.4000 51.38 5.2 %\n", + "\n", + "Note: PyTorch uses TF32 tensor cores by default on Ampere+ GPUs.\n", + "H200 TF32 theoretical peak: 989.0 TFLOPS\n", + "\n", + "For roofline analysis details, see: https://jax-ml.github.io/scaling-book/roofline/\n" + ] + } + ], + "source": [ + "def get_tflops(n, time_ms):\n", + " \"\"\"Calculate achieved TFLOPS for matrix multiplication.\"\"\"\n", + " flops = 2 * n ** 3 # Multiply-add for each of N^2 output elements\n", + " tflops = flops / (time_ms * 1e-3) / 1e12\n", + " return tflops\n", + "\n", + "# Theoretical peaks vary by GPU and precision\n", + "# PyTorch uses TF32 by default on Ampere+ GPUs for matmul\n", + "GPU_PEAK_TFLOPS = {\n", + " 'A100': {'fp32': 19.5, 'tf32': 156.0, 'fp16': 312.0},\n", + " 'H100': {'fp32': 67.0, 'tf32': 989.0, 'fp16': 1979.0},\n", + " 'H200': {'fp32': 67.0, 'tf32': 989.0, 'fp16': 1979.0},\n", + "}\n", + "\n", + "# Use TF32 peak since PyTorch defaults to TF32 on Ampere+\n", + "PEAK_TFLOPS = 989.0 # H200 TF32 peak\n", + "\n", + "# Benchmark at different sizes\n", + "print(\"Matrix Multiplication Performance\")\n", + "print(\"=\" * 65)\n", + "print(f\"{'Size':<8} {'Time (ms)':<12} {'TFLOPS':<12} {'% of TF32 Peak':<15}\")\n", + "print(\"-\" * 65)\n", + "\n", + "for size in [1024, 2048, 4096, 8192]:\n", + " a_test, b_test = get_data(size)\n", + " time_ms = final_benchmark(simple_mm, a_test, b_test)\n", + " tflops = get_tflops(size, time_ms)\n", + " efficiency = (tflops / PEAK_TFLOPS) * 100\n", + " print(f\"{size:<8} {time_ms:<12.4f} {tflops:<12.2f} {efficiency:<15.1f}%\")\n", + "\n", + "print(f\"\\nNote: PyTorch uses TF32 tensor cores by default on Ampere+ GPUs.\")\n", + "print(f\"H200 TF32 theoretical peak: {PEAK_TFLOPS} TFLOPS\")\n", + "print(f\"\\nFor roofline analysis details, see: https://jax-ml.github.io/scaling-book/roofline/\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zcYVXCkUzX2k" + }, + "source": [ + "## Conclusion\n", + "\n", + "Benchmarking on GPUs is fundamentally different from CPUs. The asynchronous nature of kernel launches, the hidden state of the L2 cache, and the noise of the OS scheduler all conspire to give you the wrong numbers.\n", + "\n", + "### What We Learned\n", + "\n", + "Through our journey, we discovered that robust GPU benchmarking requires:\n", + "1. **Device Synchronization** - Wait for GPU work to complete\n", + "2. **CUDA Events** - Use GPU-side timestamps, not CPU clocks\n", + "3. **Warmup Runs** - Settle compilation and memory allocators\n", + "4. **Multiple Samples** - Build statistical distributions\n", + "5. **L2 Cache Flushing** - Measure cold cache (realistic) performance\n", + "6. **Median Aggregation** - Filter out OS jitter and outliers\n", + "7. **Side-Stream Detection** - Catch work on non-default streams\n", + "\n", + "### What KernelBench Provides\n", + "\n", + "We've implemented all these best practices in **KernelBench's timing module** (`src/timing.py`):\n", + "\n", + "| Function | Purpose |\n", + "|----------|---------|\n", + "| `get_timing_function(method)` | Factory returning timing function by name |\n", + "| `clear_l2_cache(device)` | L2 cache flushing utility |\n", + "| `get_timing_stats(times)` | Statistical aggregation (mean, std, min, max) |\n", + "\n", + "**Four timing methods for different use cases:**\n", + "- **`cuda_event`** - Default for trusted code (fastest, GPU-side timing)\n", + "- **`host_time`** - For untrusted/agent code (catches all streams)\n", + "- **`do_bench`** - Triton-style adaptive trial counts\n", + "- **`do_bench_impl`** - Transparent do_bench with explicit control\n", + "\n", + "**Key parameters:**\n", + "- `num_warmup`, `num_trials`, `discard_first`, `device`, `verbose`\n", + "\n", + "### Recommended Usage\n", + "\n", + "```python\n", + "from src.timing import get_timing_function, get_timing_stats\n", + "\n", + "# For trusted code\n", + "timing_fn = get_timing_function(\"cuda_event\")\n", + "\n", + "# For agent evaluations (catches side-streams)\n", + "timing_fn = get_timing_function(\"host_time\")\n", + "\n", + "# Run benchmark\n", + "times = timing_fn(kernel, args, num_warmup=10, num_trials=100, device=\"cuda:0\")\n", + "stats = get_timing_stats(times, device=\"cuda:0\")\n", + "print(f\"Mean: {stats['mean']:.4f}ms, Std: {stats['std']:.4f}ms\")\n", + "```\n", + "\n", + "Happy optimizing!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7Ah151CHzX2k" + }, + "source": [ + "---\n", + "\n", + "### Footnotes\n", + "\n", + "**On GPU Clock States:** For highly reproducible benchmarks (e.g., publishing papers), consider locking GPU clocks with `nvidia-smi -lgc `. GPUs dynamically adjust clock speeds based on thermals and power, which can introduce variance between runs. For most development work, median-based benchmarking handles this adequately.\n", + "\n", + "**On Warmup Iterations:** We use fixed warmup counts (10-50 iterations) for simplicity, but this can be insufficient or wasteful depending on the kernel. In extremely sensitive environments, you can implement an adaptive stopping criterion: run warmup iterations until the variance of recent samples falls below a threshold, indicating the system has stabilized. This is covered in more detail in the [GPU MODE lecture](https://www.youtube.com/watch?v=1i7dxoAfKOU).\n", + "\n", + "**On Bare Metal vs. Virtualized Environments:** Cloud VMs and containers add layers of abstraction that can introduce variance and overhead. GPU passthrough in virtualized environments adds latency, and shared cloud instances suffer from \"noisy neighbor\" effects where other tenants' workloads impact your measurements. For publishable results or when chasing small performance deltas, prefer bare metal. For day-to-day development, cloud instances are fine as long as you're aware your numbers may not match others exactly." + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "A100", + "include_colab_link": true, + "provenance": [] + }, + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.9" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} From f9a7b0999c4ad2c28fef628a79ed3ae1f55c416b Mon Sep 17 00:00:00 2001 From: Sahan Paliskara Date: Wed, 17 Dec 2025 14:45:52 -0800 Subject: [PATCH 06/24] Benchmarking guide --- benchmarking.ipynb | 1561 ---------------------------------- notebooks/benchmarking.ipynb | 354 +++----- 2 files changed, 101 insertions(+), 1814 deletions(-) delete mode 100644 benchmarking.ipynb diff --git a/benchmarking.ipynb b/benchmarking.ipynb deleted file mode 100644 index a9f3ba15..00000000 --- a/benchmarking.ipynb +++ /dev/null @@ -1,1561 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "view-in-github" - }, - "source": [ - "\"Open" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "_PCU0gUyzX2c" - }, - "source": [ - "# A Practical Guide to GPU Benchmarking\n", - "\n", - "> **Note on outputs:** The outputs in this notebook were generated on an **NVIDIA H200 GPU** (90MB L2 cache, 4.8 TB/s memory bandwidth). Your results may vary depending on your hardware. The H200's large cache means cache effects are less dramatic than on older GPUs like A100 (40MB L2) or consumer cards.\n", - "\n", - "## TL;DR — How to Benchmark Correctly\n", - "\n", - "Benchmarking on GPUs requires a strict protocol to avoid measuring Python overhead or caching artifacts. To get reliable numbers, you must:\n", - "\n", - "1. **Warmup:** Run the kernel ~10-50 times first to settle compilation and memory allocators.\n", - "2. **Sample Extensively:** Don't trust one run. Collect 100+ samples to build a statistical distribution.\n", - "3. **Flush the L2 Cache:** Between *every* sample, flush the cache to force a cold cache state (simulating real-world inference).\n", - "4. **Use Device Timers:** Use `torch.cuda.Event` instead of `time.time()` to measure execution on the GPU, not the CPU driver.\n", - "5. **Aggregate Robustly:** Aggregate over many samples to filter out jitter/outliers.\n", - "6. **Wait for sidestreams to finish:** Ensure no side-streams are running or wait for all of them to finish before reporting a time.\n", - "\n", - "*Pro-Tip:* **KernelBench's timing module** (`src/timing.py`) implements all these best practices. Use `get_timing_function(\"cuda_event\")` for trusted code or `get_timing_function(\"host_time\")` for evaluating untrusted/agent-generated code.\n", - "\n", - "-----\n", - "\n", - "If are using an LLM agent to write GPU kernels (and evaluating against something like say [Kernel Bench](https://github.com/ScalingIntelligence/KernelBench)), or just trying to optimize a custom GPU kernel, you are eventually going to ask: **\"How fast is this thing?\"**\n", - "\n", - "This notebook is heavily inspired by [this great guide](https://www.youtube.com/watch?v=1i7dxoAfKOU) from the **GPU MODE** community and the practical \"footguns\" (traps) encountered while building benchmarking harnesses for LLM-generated code. Our goal here is simplicity and keeping things Pythonic—for more advanced techniques, see the footnotes.\n", - "\n", - "We won't just list best practices. Instead, we are going to build a benchmarking harness from scratch, make every common mistake, debug why the numbers are wrong, and iterate our way to a robust solution. So let's start things out by doing the most naive thing by using `time.time()`!" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "execution": { - "iopub.execute_input": "2025-12-17T21:24:36.427802Z", - "iopub.status.busy": "2025-12-17T21:24:36.427684Z", - "iopub.status.idle": "2025-12-17T21:24:40.995279Z", - "shell.execute_reply": "2025-12-17T21:24:40.994328Z" - }, - "id": "PKWz_W7uzX2f", - "outputId": "8751fd78-569b-4080-f21a-60bbb5ee8caf" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/simon/palic/KernelBench/.venv/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from .autonotebook import tqdm as notebook_tqdm\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using GPU: NVIDIA H200\n" - ] - } - ], - "source": [ - "# @title Environment Setup\n", - "# Ensure we have the necessary libraries and a GPU available\n", - "# !pip install -q triton matplotlib numpy torch\n", - "# !pip install -e .. # Install KernelBench locally for timing utilities\n", - "\n", - "import sys\n", - "import os\n", - "sys.path.insert(0, '..') # Add parent directory to path for imports\n", - "\n", - "# For multi-GPU systems, set CUDA_VISIBLE_DEVICES=X before running to select a specific GPU\n", - "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"5\"\n", - "\n", - "import torch\n", - "import time\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import triton\n", - "\n", - "# Import KernelBench's timing module\n", - "from src import timing\n", - "from src.timing import clear_l2_cache, get_timing_stats, get_timing_function\n", - "\n", - "if not torch.cuda.is_available():\n", - " raise RuntimeError(\"This notebook requires a GPU. Please enable GPU in your runtime settings.\")\n", - "\n", - "# Device configuration\n", - "# The selected GPU will appear as cuda:0\n", - "\n", - "DEVICE = f\"cuda:0\"\n", - "print(f\"Using GPU: {torch.cuda.get_device_name(DEVICE)}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "kjWByrwvzX2f" - }, - "source": [ - "## The Journey: Benchmarking a Matrix Multiplication\n", - "\n", - "Let's define a simple workload to test. We want to measure the performance of a standard Matrix Multiplication." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "execution": { - "iopub.execute_input": "2025-12-17T21:24:40.997969Z", - "iopub.status.busy": "2025-12-17T21:24:40.997722Z", - "iopub.status.idle": "2025-12-17T21:24:41.252072Z", - "shell.execute_reply": "2025-12-17T21:24:41.250967Z" - }, - "id": "gxtKes5lzX2g", - "outputId": "5890bae4-5b9a-4366-8947-367146593158" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Output shape: torch.Size([8192, 8192])\n", - "Op ran successfully\n" - ] - } - ], - "source": [ - "# A standard size for testing\n", - "N = 8192\n", - "\n", - "def get_data(n=N, device=DEVICE):\n", - " \"\"\"Generate random float32 matrices for benchmarking.\"\"\"\n", - " return torch.randn(n, n, device=device), torch.randn(n, n, device=device)\n", - "\n", - "def simple_mm(a, b):\n", - " \"\"\"Our kernel under test: standard matrix multiplication.\"\"\"\n", - " return torch.matmul(a, b)\n", - "\n", - "# Let's verify it runs\n", - "a, b = get_data()\n", - "res = simple_mm(a, b)\n", - "print(f\"Output shape: {res.shape}\")\n", - "print(\"Op ran successfully\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "GWlsBEVyzX2g" - }, - "source": [ - "### Attempt 1: The Naive Timer\n", - "\n", - "The most intuitive way to time code in Python is using `time.time()`. Let's try that first." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "execution": { - "iopub.execute_input": "2025-12-17T21:24:41.254622Z", - "iopub.status.busy": "2025-12-17T21:24:41.254499Z", - "iopub.status.idle": "2025-12-17T21:24:41.258106Z", - "shell.execute_reply": "2025-12-17T21:24:41.257414Z" - }, - "id": "LynIxLaRzX2g", - "outputId": "72548dad-6570-4eaa-ce07-923556fe70b4" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Naive time: 0.6356 ms\n" - ] - } - ], - "source": [ - "def benchmark_naive(func, *args):\n", - " \"\"\"WRONG: Measures kernel launch time, not execution time.\"\"\"\n", - " start = time.time()\n", - " func(*args)\n", - " end = time.time()\n", - " return (end - start) * 1000 # to ms\n", - "\n", - "t = benchmark_naive(simple_mm, a, b)\n", - "print(f\"Naive time: {t:.4f} ms\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "gw4NGYRmzX2h" - }, - "source": [ - "**The Problem:**\n", - "Wait, less than 1ms? That seems impossibly fast for a 8192² matrix multiplication involving over 1 trillion floating-point operations.[¹](#footnote-1)\n", - "\n", - "**What happened?**\n", - "GPUs are **asynchronous**. When you call `torch.matmul`, the CPU doesn't actually do the math. It simply queues a \"launch kernel\" command to the GPU and moves on immediately. Our timer didn't measure the matrix multiplication; it measured how long it took Python to place an order in the queue.\n", - "\n", - "To fix this, we need to:\n", - "1. **Synchronize** - Force the CPU to wait for the GPU with `torch.cuda.synchronize()`\n", - "2. **Use CUDA Events** - Record timestamps directly on the GPU to avoid CPU overhead\n", - "\n", - "Let's compare these approaches to see the difference.\n", - "\n", - "---\n", - "\n", - "\n", - "¹ **Why impossible?** The [H200](https://www.nvidia.com/en-us/data-center/h200/) peaks at 989 TFLOPS for TF32 Tensor Cores. At that rate: 1.1 TFLOP ÷ 989 TFLOP/s = **1.11ms minimum**. Anything under 1ms is physically impossible." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Attempt 2: Synchronizing the Device\n", - "\n", - "To fix this, we need to force the CPU to wait until the GPU has finished its work before we stop the clock. We do this with `torch.cuda.synchronize()`." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "execution": { - "iopub.execute_input": "2025-12-17T21:24:41.260592Z", - "iopub.status.busy": "2025-12-17T21:24:41.260479Z", - "iopub.status.idle": "2025-12-17T21:24:41.460207Z", - "shell.execute_reply": "2025-12-17T21:24:41.459267Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Sync time: 21.5368 ms\n" - ] - } - ], - "source": [ - "def benchmark_sync(func, *args):\n", - " \"\"\"Better: Actually waits for GPU to finish.\"\"\"\n", - " torch.cuda.synchronize() # Wait for previous work to finish\n", - " start = time.time()\n", - " func(*args)\n", - " torch.cuda.synchronize() # Wait for THIS work to finish\n", - " end = time.time()\n", - " return (end - start) * 1000\n", - "\n", - "t = benchmark_sync(simple_mm, a, b)\n", - "print(f\"Sync time: {t:.4f} ms\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "dV8AmQi-zX2i" - }, - "source": [ - "### Attempt 3: Removing CPU Overhead (CUDA Events)\n", - "\n", - "To get a precise measurement, we need to bypass the CPU clock entirely. We can ask the GPU driver to record timestamps directly on the device using `torch.cuda.Event`." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "execution": { - "iopub.execute_input": "2025-12-17T21:24:41.463315Z", - "iopub.status.busy": "2025-12-17T21:24:41.463177Z", - "iopub.status.idle": "2025-12-17T21:24:41.532922Z", - "shell.execute_reply": "2025-12-17T21:24:41.531966Z" - }, - "id": "i6PfSdkTzX2i", - "outputId": "8b3e29d1-1789-4bfb-9a44-599016516dd7" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Run 0: 21.7344 ms\n", - "Run 1: 21.4754 ms\n", - "Run 2: 21.4987 ms\n" - ] - } - ], - "source": [ - "def benchmark_events(func, *args):\n", - " \"\"\"Better: Uses GPU timestamps, avoiding CPU overhead.\"\"\"\n", - " start_event = torch.cuda.Event(enable_timing=True)\n", - " end_event = torch.cuda.Event(enable_timing=True)\n", - "\n", - " torch.cuda.synchronize(device=DEVICE)\n", - " start_event.record()\n", - " func(*args)\n", - " end_event.record()\n", - " torch.cuda.synchronize(device=DEVICE)\n", - "\n", - " return start_event.elapsed_time(end_event) # Returns ms directly\n", - "\n", - "# Run it a few times\n", - "for i in range(3):\n", - " print(f\"Run {i}: {benchmark_events(simple_mm, a, b):.4f} ms\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "BkfaaDawzX2i" - }, - "source": [ - "### Attempt 4: Handling the \"Cold Start\"\n", - "\n", - "Notice Run 0 is noticably slower than the rest. The first time you run a PyTorch function (and similarly launching a cuda kernel), the framework does a lot of heavy lifting which could include: allocating memory, initializing cuBLAS/cuDNN workspaces, lazy kernel loading, and compiling kernels (especially if using `torch.compile` or Triton). This \"Cold Start\" penalty is a one-time cost that shouldn't be included in your performance metrics.\n", - "\n", - "**The Fix:**\n", - "We need to perform **Warmup Runs**—running the kernel a few times to settle the system state before we start measuring." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "execution": { - "iopub.execute_input": "2025-12-17T21:24:41.535509Z", - "iopub.status.busy": "2025-12-17T21:24:41.535387Z", - "iopub.status.idle": "2025-12-17T21:24:42.246476Z", - "shell.execute_reply": "2025-12-17T21:24:42.245382Z" - }, - "id": "j_PsAuJkzX2i", - "outputId": "d6983401-72d3-468c-ffd8-c0833e8d5556" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Run 0: 21.6478 ms\n", - "Run 1: 21.4837 ms\n", - "Run 2: 21.4852 ms\n" - ] - } - ], - "source": [ - "def benchmark_warmup(func, *args, warmup_iters=30, benchmark_iters=3):\n", - " \"\"\"Better: Includes warmup to avoid cold-start penalty.\"\"\"\n", - " # Warmup phase\n", - " for _ in range(warmup_iters):\n", - " func(*args)\n", - " torch.cuda.synchronize(device=DEVICE)\n", - "\n", - " # Measurement phase\n", - " measurements = []\n", - " for _ in range(benchmark_iters):\n", - " measurements.append(benchmark_events(func, *args))\n", - " torch.cuda.synchronize(device=DEVICE)\n", - " return measurements\n", - "\n", - "# print(f\"Warmed up time: {benchmark_warmup(simple_mm, a, b):.4f} ms\")\n", - "\n", - "for i, measurement in enumerate(benchmark_warmup(simple_mm, a, b)):\n", - " print(f\"Run {i}: {measurement:.4f} ms\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "OR3uOh7kzX2i" - }, - "source": [ - "### Attempt 5: The Single Sample Fallacy (Variance)\n", - "\n", - "Relying on a single sample after warmup is bad science. Operating systems are noisy; background processes interrupt the CPU, and GPU clocks fluctuate thermally. A single measurement is anecdotal, not statistical.\n", - "\n", - "#### Visualizing the Jitter\n", - "\n", - "Let's run the benchmark 100 times and plot every single run. You will clearly see the \"Cold Start\" spike and the noise floor of the OS." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 653 - }, - "execution": { - "iopub.execute_input": "2025-12-17T21:24:42.248937Z", - "iopub.status.busy": "2025-12-17T21:24:42.248818Z", - "iopub.status.idle": "2025-12-17T21:24:44.484746Z", - "shell.execute_reply": "2025-12-17T21:24:44.483759Z" - }, - "id": "T-7QH4cHzX2i", - "outputId": "c758effd-a810-422d-d3ca-66c128cdb716" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Mean: 21.5096 ms\n", - "Median: 21.4942 ms\n", - "Std: 0.0625 ms\n", - "Min: 21.4420 ms\n", - "Max: 21.7808 ms\n" - ] - } - ], - "source": [ - "# Collect 100 samples\n", - "timings = []\n", - "for i in range(100):\n", - " timings.append(benchmark_events(simple_mm, a, b))\n", - "\n", - "plt.figure(figsize=(10, 6))\n", - "plt.scatter(range(100), timings, alpha=0.6)\n", - "plt.axhline(y=np.median(timings), color='r', linestyle='--', label=f'Median: {np.median(timings):.4f} ms')\n", - "plt.axhline(y=np.mean(timings), color='g', linestyle=':', label=f'Mean: {np.mean(timings):.4f} ms')\n", - "plt.title(\"Benchmarking Jitter & Cold Start\")\n", - "plt.ylabel(\"Time (ms)\")\n", - "plt.xlabel(\"Run Index\")\n", - "plt.legend()\n", - "plt.grid(True, alpha=0.3)\n", - "plt.show()\n", - "\n", - "print(f\"Mean: {np.mean(timings):.4f} ms\")\n", - "print(f\"Median: {np.median(timings):.4f} ms\")\n", - "print(f\"Std: {np.std(timings):.4f} ms\")\n", - "print(f\"Min: {np.min(timings):.4f} ms\")\n", - "print(f\"Max: {np.max(timings):.4f} ms\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "hX_-OpftzX2i" - }, - "source": [ - "You will see a massive dot at $x=0$ (the cold start), followed by a cloud of dots hovering around the \"true\" time. This visualizes why we need **Warmup** (to skip $x=0$) and **Statistics** (to handle the cloud).\n", - "\n", - "Notice how the **Mean** is pulled upward by the outliers, while the **Median** represents the typical case more accurately. When possible, we should use the **Median** as our final metric.\n", - "\n", - "### Attempt 6: The \"Robust\" Harness (Flushing Cache)\n", - "\n", - "Modern GPUs have large L2 caches (40MB-192MB depending on architecture). If your data fits in the cache, subsequent iterations in your loop will skip the slow VRAM access, artificially inflating your speed. In production, data usually streams in from VRAM, so this \"hot cache\" benchmark is misleading.\n", - "\n", - "**The Fix:**\n", - "We must **flush the L2 cache** between *every single sample*. We do this by writing to a tensor large enough to completely evict the cache contents. KernelBench uses a ~256MB tensor to safely cover all GPU architectures, including the largest caches (e.g., Blackwell at ~192MB)." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "execution": { - "iopub.execute_input": "2025-12-17T21:24:44.487140Z", - "iopub.status.busy": "2025-12-17T21:24:44.487016Z", - "iopub.status.idle": "2025-12-17T21:24:44.489937Z", - "shell.execute_reply": "2025-12-17T21:24:44.489208Z" - }, - "id": "Kj5azcpxzX2j" - }, - "outputs": [], - "source": [ - "# KernelBench provides utilities to flush the L2 cache\n", - "# This is important for cold cache measurements that simulate real-world inference\n", - "\n", - "def clear_l2_cache(device=DEVICE):\n", - " \"\"\"Flush L2 cache by writing to a large tensor.\n", - " \n", - " L2 cache sizes vary by GPU, so we use 256MB to cover all cases.\n", - " \"\"\"\n", - " dummy = torch.empty((32, 1024, 1024), dtype=torch.int64, device=device) # 256MB\n", - " dummy.fill_(1901) # Force write to thrash cache\n", - " del dummy\n", - "\n", - "# KernelBench also provides clear_l2_cache_triton() for cross-platform support\n", - "# (works on both NVIDIA and AMD GPUs via Triton's device abstraction)\n", - "from src.timing import clear_l2_cache_triton" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Why does flushing the cache matter?\n", - "\n", - "Let's see the cache effect in action. We'll benchmark the same operation twice:\n", - "1. **Without** cache flushing between runs (data stays in L2 cache)\n", - "2. **With** cache flushing between runs (data must be fetched from VRAM each time)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "execution": { - "iopub.execute_input": "2025-12-17T21:24:44.492322Z", - "iopub.status.busy": "2025-12-17T21:24:44.492090Z", - "iopub.status.idle": "2025-12-17T21:24:44.507209Z", - "shell.execute_reply": "2025-12-17T21:24:44.506066Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Without cache flushing (warm cache):\n", - "\n", - "With cache flushing (cold cache):\n", - "\n", - "Warm cache median: 0.0280 ms\n", - "Cold cache median: 0.0318 ms\n", - "Difference: 0.0038 ms (13.7% slower with cold cache)\n", - "\n", - "Without cache flushing, you measure artificially fast times!\n" - ] - } - ], - "source": [ - "# Demonstrate why L2 cache flushing matters\n", - "# Use a smaller matrix so the effect is visible (data fits in cache)\n", - "N_SMALL = 512\n", - "a_small, b_small = get_data(N_SMALL)\n", - "\n", - "NUM_SAMPLES = 20\n", - "\n", - "# do warmup runs\n", - "for _ in range(NUM_SAMPLES):\n", - " clear_l2_cache(device=DEVICE)\n", - " benchmark_events(simple_mm, a_small, b_small)\n", - " torch.cuda.synchronize(device=DEVICE)\n", - "\n", - "# Benchmark WITHOUT cache flushing (warm cache - unrealistic)\n", - "print(\"Without cache flushing (warm cache):\")\n", - "times_warm = []\n", - "for i in range(NUM_SAMPLES):\n", - " t = benchmark_events(simple_mm, a_small, b_small)\n", - " times_warm.append(t)\n", - "\n", - "# Benchmark WITH cache flushing (cold cache - realistic)\n", - "print(\"\\nWith cache flushing (cold cache):\")\n", - "times_cold = []\n", - "for i in range(NUM_SAMPLES):\n", - " clear_l2_cache(device=DEVICE) # Flush cache before each measurement\n", - " t = benchmark_events(simple_mm, a_small, b_small)\n", - " times_cold.append(t)\n", - "\n", - "print(f\"\\nWarm cache median: {np.median(times_warm):.4f} ms\")\n", - "print(f\"Cold cache median: {np.median(times_cold):.4f} ms\")\n", - "print(f\"Difference: {np.median(times_cold) - np.median(times_warm):.4f} ms ({(np.median(times_cold)/np.median(times_warm) - 1)*100:.1f}% slower with cold cache)\")\n", - "print(\"\\nWithout cache flushing, you measure artificially fast times!\")" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "execution": { - "iopub.execute_input": "2025-12-17T21:24:44.509465Z", - "iopub.status.busy": "2025-12-17T21:24:44.509344Z", - "iopub.status.idle": "2025-12-17T21:24:44.597419Z", - "shell.execute_reply": "2025-12-17T21:24:44.596500Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Visualize the cache effect\n", - "# Discard first few samples to remove initialization noise\n", - "discard = 3\n", - "times_warm_clean = times_warm[discard:]\n", - "times_cold_clean = times_cold[discard:]\n", - "\n", - "plt.figure(figsize=(10, 5))\n", - "plt.scatter(range(len(times_warm_clean)), times_warm_clean, alpha=0.7, label=f'Warm Cache (mean={np.mean(times_warm_clean):.4f}ms)', color='orange', s=60)\n", - "plt.scatter(range(len(times_cold_clean)), times_cold_clean, alpha=0.7, label=f'Cold Cache (mean={np.mean(times_cold_clean):.4f}ms)', color='blue', s=60)\n", - "plt.axhline(y=np.mean(times_warm_clean), color='orange', linestyle='--', alpha=0.5)\n", - "plt.axhline(y=np.mean(times_cold_clean), color='blue', linestyle='--', alpha=0.5)\n", - "plt.xlabel('Run Index')\n", - "plt.ylabel('Time (ms)')\n", - "plt.title(f'Cache Effect on {N_SMALL}x{N_SMALL} Matrix Multiplication\\n(first {discard} samples discarded)')\n", - "plt.legend()\n", - "plt.grid(True, alpha=0.3)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "FAaH1cdBzX2j" - }, - "source": [ - "### Putting it all together\n", - "\n", - "We have now discovered that a robust benchmark requires:\n", - "\n", - "1. Device Synchronization\n", - "2. CUDA Events (to avoid CPU overhead)\n", - "3. Warmup Runs (to avoid initialization costs)\n", - "4. Multiple Samples (to handle variance)\n", - "5. Cache Flushing (to simulate VRAM access)\n", - "6. Median/Mean Aggregation (to ignore jitter)\n", - "\n", - "Writing this boilerplate every time is painful. We've packaged all these lessons into **KernelBench's timing module**, which provides multiple timing methods for different use cases. There are also other robust implementations available, such as Triton's `do_bench` [function](https://triton-lang.org/main/python-api/generated/triton.testing.do_bench.html).\n", - "\n", - "The default `cuda_event` method in KernelBench implements all of the above automatically, plus an additional insight: **`discard_first`** - discarding the first few trials after warmup, which often still have some initialization overhead." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "execution": { - "iopub.execute_input": "2025-12-17T21:24:44.600123Z", - "iopub.status.busy": "2025-12-17T21:24:44.600004Z", - "iopub.status.idle": "2025-12-17T21:24:47.005899Z", - "shell.execute_reply": "2025-12-17T21:24:47.004654Z" - }, - "id": "3aVFtWt_zX2j", - "outputId": "6cf1e493-86ca-419e-a8e1-e19486814e09" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[Profiling] Using timing method: cuda_event\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", - "KernelBench cuda_event time: 21.5000 ms\n" - ] - } - ], - "source": [ - "# Get the timing function - cuda_event is the default for trusted code\n", - "timing_fn = get_timing_function(\"cuda_event\")\n", - "\n", - "def final_benchmark(func, *args, num_trials=100):\n", - " \"\"\"Production-ready benchmarking using KernelBench's timing module.\"\"\"\n", - " elapsed_times = timing_fn(\n", - " kernel_fn=func,\n", - " args=list(args),\n", - " num_warmup=10,\n", - " num_trials=num_trials,\n", - " discard_first=1, # Discard first trial for consistency\n", - " verbose=False,\n", - " device=DEVICE\n", - " )\n", - " stats = get_timing_stats(elapsed_times, device=DEVICE)\n", - " return stats[\"mean\"]\n", - "\n", - "t = final_benchmark(simple_mm, a, b)\n", - "print(f\"KernelBench cuda_event time: {t:.4f} ms\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "MsZrCYQRzX2j" - }, - "source": [ - "*Note: KernelBench also wraps Triton's `do_bench` if you prefer adaptive trial counts. See the timing methods comparison below for details.*\n", - "\n", - "---\n", - "\n", - "## KernelBench's Timing Methods Explained\n", - "\n", - "Now that we've built up a robust benchmarking harness from first principles, let's explore KernelBench's timing module in depth. We'll examine:\n", - "- **All 4 timing methods** and when to use each\n", - "- **The `discard_first` parameter** and why it improves measurement consistency\n", - "- **How `host_time` detects side-stream exploits** in untrusted code\n", - "\n", - "KernelBench's timing module provides **4 timing methods**, each designed for different use cases:\n", - "\n", - "| Method | Use Case | Catches Side-Streams | Cold Cache | Trial Control |\n", - "|--------|----------|---------------------|------------|---------------|\n", - "| `cuda_event` | Default, trusted code | No | Yes | Explicit |\n", - "| `host_time` | Untrusted code, agent evals | **Yes** | Yes | Explicit |\n", - "| `do_bench` | Triton-style / robust adaptive | No | Yes | Adaptive (time-budget) |\n", - "| `do_bench_impl` | do_bench implementation for inference and trial control | No | Yes | Explicit |\n", - "\n", - "### Method Details\n", - "\n", - "**`cuda_event`** (Default)\n", - "- Uses `torch.cuda.Event` for GPU-side timing\n", - "- Most accurate for pure kernel time measurement\n", - "- Clears L2 cache before each trial for cold-cache performance\n", - "- Use for trusted code where you control the kernel implementation\n", - "\n", - "**`host_time`** (For Untrusted Code)\n", - "- Uses **both** `time.perf_counter()` (host) and `torch.cuda.Event` (device) timing\n", - "- Compares the two: if they differ significantly, the CUDA event time is likely invalid (e.g., side-stream exploit)\n", - "- Falls back to host time when discrepancy detected, ensuring correctness\n", - "- Waits for ALL streams via `torch.cuda.synchronize()`\n", - "- **Essential for evaluating untrusted/agent-generated code**\n", - "\n", - "**`do_bench`** (Triton's Adaptive Benchmarking)\n", - "- Wraps Triton's `triton.testing.do_bench`\n", - "- Uses fixed time budgets: 25ms warmup, 100ms for repetitions\n", - "- Trial count is automatic based on kernel runtime\n", - "- **Note:** `num_warmup`, `num_trials`, `discard_first` parameters are ignored\n", - "\n", - "**`do_bench_impl`** (Transparent Implementation)\n", - "- Custom implementation mirroring Triton's do_bench\n", - "- Gives you explicit control over `num_warmup` and `num_trials`\n", - "- Useful when you need do_bench's approach but with specific trial counts\n", - "\n", - "### Key Parameters\n", - "\n", - "All timing functions share a common interface:\n", - "\n", - "```python\n", - "timing_fn(\n", - " kernel_fn, # Function to time\n", - " args, # List of arguments to pass\n", - " num_warmup=3, # Warmup iterations before timing\n", - " num_trials=10, # Number of timing samples to collect\n", - " discard_first=1, # Drop first N trials after warmup\n", - " device=\"cuda:0\", # Explicit GPU device selection\n", - " verbose=True # Print per-trial timing info\n", - ") -> list[float] # Returns list of elapsed times in ms\n", - "```\n", - "\n", - "### Why `discard_first`?\n", - "\n", - "Even after warmup, the first few timing trials can be affected by:\n", - "- PyTorch's lazy tensor allocation finalizing\n", - "- cuDNN autotuning (still settling optimal algorithms)\n", - "- Driver state initialization\n", - "- First access to data structures\n", - "\n", - "Setting `discard_first=1` (the default) improves measurement consistency. Let's visualize this effect:" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Comparing All 4 Timing Methods\n", - "\n", - "Let's see how the different timing methods compare on the same kernel. Each method has trade-offs between precision, features, and overhead." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "execution": { - "iopub.execute_input": "2025-12-17T21:24:47.008751Z", - "iopub.status.busy": "2025-12-17T21:24:47.008456Z", - "iopub.status.idle": "2025-12-17T21:24:50.238519Z", - "shell.execute_reply": "2025-12-17T21:24:50.237366Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Comparing all KernelBench timing methods on 4096x4096 matmul:\n", - "======================================================================\n", - "\n", - "Testing cuda_event...\n", - "[Profiling] Using timing method: cuda_event\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 50\n", - " cuda_event: 21.5000 ms (std=0.0572)\n", - "\n", - "Testing host_time...\n", - "[Profiling] Using timing method: host_time\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 50\n", - " host_time: 21.5000 ms (std=0.0427)\n", - "\n", - "Testing do_bench...\n", - "[Profiling] Using timing method: do_bench\n", - " do_bench: 21.4000 ms (std=0.0030)\n", - "\n", - "Testing do_bench_impl...\n", - "[Profiling] Using timing method: do_bench_impl\n", - " do_bench_impl: 21.4000 ms (std=0.0315)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_710987/1660294801.py:64: UserWarning: Attempting to set identical low and high ylims makes transformation singular; automatically expanding.\n", - " axes[1].set_ylim(min_val - margin, max_val + margin)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Key insight: host_time is slightly slower due to CPU overhead,\n", - "but it catches ALL work on ALL streams - essential for untrusted code!\n" - ] - } - ], - "source": [ - "# Compare all KernelBench timing methods on 4096x4096 matmul\n", - "print(\"Comparing all KernelBench timing methods on 4096x4096 matmul:\")\n", - "print(\"=\" * 70)\n", - "\n", - "methods = [\"cuda_event\", \"host_time\", \"do_bench\", \"do_bench_impl\"]\n", - "results = {}\n", - "\n", - "for method in methods:\n", - " print(f\"\\nTesting {method}...\")\n", - " try:\n", - " method_fn = get_timing_function(method)\n", - " times = method_fn(\n", - " simple_mm, \n", - " [a, b], \n", - " num_warmup=10, \n", - " num_trials=50, \n", - " verbose=False,\n", - " device=DEVICE\n", - " )\n", - " results[method] = get_timing_stats(times, device=DEVICE)\n", - " print(f\" {method}: {results[method]['mean']:.4f} ms (std={results[method]['std']:.4f})\")\n", - " except Exception as e:\n", - " print(f\" {method}: Skipped due to {type(e).__name__} (Triton version compatibility)\")\n", - " # Remove from list if it failed\n", - " methods = [m for m in methods if m in results]\n", - "\n", - "# Only plot if we have results\n", - "if results:\n", - " # Visualize the comparison\n", - " fig, axes = plt.subplots(1, 2, figsize=(12, 5))\n", - "\n", - " # Bar chart of mean times\n", - " available_methods = [m for m in methods if m in results]\n", - " means = [results[m]['mean'] for m in available_methods]\n", - " stds = [results[m]['std'] for m in available_methods]\n", - " colors = ['#2ecc71', '#e74c3c', '#3498db', '#9b59b6'][:len(available_methods)]\n", - "\n", - " axes[0].bar(available_methods, means, yerr=stds, capsize=5, color=colors, alpha=0.8)\n", - " axes[0].set_ylabel('Time (ms)')\n", - " axes[0].set_title('Mean Execution Time by Method\\n(graph truncated for readability)')\n", - " axes[0].tick_params(axis='x', rotation=45)\n", - "\n", - " # Truncate y-axis to make differences easier to see\n", - " min_mean = min(means)\n", - " max_mean = max(means)\n", - " margin = (max_mean - min_mean) * 2\n", - " axes[0].set_ylim(min_mean - margin, max_mean + margin)\n", - "\n", - " # Highlight cuda_event vs host_time with truncated y-axis for readability\n", - " if 'cuda_event' in results and 'host_time' in results:\n", - " cuda_mean = results['cuda_event']['mean']\n", - " host_mean = results['host_time']['mean']\n", - " \n", - " axes[1].bar(['cuda_event', 'host_time'], \n", - " [cuda_mean, host_mean], \n", - " color=['#2ecc71', '#e74c3c'], alpha=0.8)\n", - " axes[1].set_ylabel('Time (ms)')\n", - " axes[1].set_title('cuda_event vs host_time\\n(host_time catches side-streams)\\n(graph truncated for readability)')\n", - " \n", - " # Truncate y-axis to make the difference easier to see\n", - " min_val = min(cuda_mean, host_mean)\n", - " max_val = max(cuda_mean, host_mean)\n", - " margin = (max_val - min_val) * 2 # Add margin around the data\n", - " axes[1].set_ylim(min_val - margin, max_val + margin)\n", - " else:\n", - " axes[1].text(0.5, 0.5, 'Comparison unavailable', ha='center', va='center')\n", - " axes[1].set_axis_off()\n", - "\n", - " plt.tight_layout()\n", - " plt.show()\n", - "\n", - "print(\"\\nKey insight: host_time is slightly slower due to CPU overhead,\")\n", - "print(\"but it catches ALL work on ALL streams - essential for untrusted code!\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### The `discard_first` Effect\n", - "\n", - "Even after warmup, the first timing trial can be affected by lazy initialization. Let's see this in action." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "execution": { - "iopub.execute_input": "2025-12-17T21:24:50.241069Z", - "iopub.status.busy": "2025-12-17T21:24:50.240945Z", - "iopub.status.idle": "2025-12-17T21:24:50.348421Z", - "shell.execute_reply": "2025-12-17T21:24:50.347364Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Demonstrating the discard_first effect:\n", - "============================================================\n", - "[Profiling] Using timing method: cuda_event\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 15\n", - "\n", - "First trial: 0.3660 ms\n", - "Mean of all trials: 0.3455 ms\n", - "Mean without first: 0.3440 ms\n", - "First trial overhead: 6.4%\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "The first trial often shows initialization overhead even after warmup.\n", - "Using discard_first=1 (default) gives more consistent measurements.\n" - ] - } - ], - "source": [ - "# Demonstrate the discard_first effect\n", - "# Even after warmup, the first timing trial can have higher overhead\n", - "\n", - "print(\"Demonstrating the discard_first effect:\")\n", - "print(\"=\" * 60)\n", - "\n", - "# Create fresh data and clear caches to make initialization overhead more visible\n", - "torch.cuda.empty_cache()\n", - "a_fresh, b_fresh = get_data(2048)\n", - "\n", - "# Collect trials with discard_first=0 to see ALL trials including the first one\n", - "timing_fn = get_timing_function(\"cuda_event\")\n", - "times_all = timing_fn(\n", - " simple_mm, [a_fresh, b_fresh],\n", - " num_warmup=3,\n", - " num_trials=15,\n", - " discard_first=0, # Keep ALL trials including first\n", - " verbose=False,\n", - " device=DEVICE\n", - ")\n", - "\n", - "# Calculate statistics\n", - "first_trial = times_all[0]\n", - "remaining_trials = times_all[1:]\n", - "mean_all = np.mean(times_all)\n", - "mean_remaining = np.mean(remaining_trials)\n", - "\n", - "print(f\"\\nFirst trial: {first_trial:.4f} ms\")\n", - "print(f\"Mean of all trials: {mean_all:.4f} ms\")\n", - "print(f\"Mean without first: {mean_remaining:.4f} ms\")\n", - "print(f\"First trial overhead: {((first_trial / mean_remaining) - 1) * 100:.1f}%\")\n", - "\n", - "# Visualize the effect with a scatter plot\n", - "plt.figure(figsize=(10, 5))\n", - "plt.scatter(range(len(times_all)), times_all, alpha=0.7, color='blue', s=60)\n", - "plt.scatter([0], [first_trial], color='red', s=100, zorder=5, label=f'First trial: {first_trial:.3f}ms')\n", - "plt.axhline(y=mean_remaining, color='green', linestyle='--', alpha=0.7, \n", - " label=f'Mean (without first): {mean_remaining:.3f}ms')\n", - "plt.axhline(y=mean_all, color='orange', linestyle=':', alpha=0.7,\n", - " label=f'Mean (all): {mean_all:.3f}ms')\n", - "plt.xlabel('Trial Index')\n", - "plt.ylabel('Time (ms)')\n", - "plt.title('First Trial Overhead Effect (after warmup)')\n", - "plt.legend(loc='upper right')\n", - "plt.grid(True, alpha=0.3)\n", - "plt.show()\n", - "\n", - "print(\"\\nThe first trial often shows initialization overhead even after warmup.\")\n", - "print(\"Using discard_first=1 (default) gives more consistent measurements.\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "HwsjlhAazX2j" - }, - "source": [ - "## The \"Agent\" Trap: Reward Hacking via Hidden Streams\n", - "\n", - "When evaluating LLM-generated kernels (like with [Kernel Bench](https://github.com/ScalingIntelligence/KernelBench)), you're not just fighting measurement noise—you're fighting an optimizer that may inadvertently discover exploits in your harness.\n", - "\n", - "One such exploit: launching work on a **side stream** to make the kernel appear instantaneous." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "execution": { - "iopub.execute_input": "2025-12-17T21:24:50.351000Z", - "iopub.status.busy": "2025-12-17T21:24:50.350876Z", - "iopub.status.idle": "2025-12-17T21:24:52.778917Z", - "shell.execute_reply": "2025-12-17T21:24:52.777685Z" - }, - "id": "UuwtML39zX2j", - "outputId": "95ebbb26-e415-491a-da30-6a78ce387906" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", - "Standard benchmark on tricky kernel: 0.1880 ms\n" - ] - } - ], - "source": [ - "def tricky_agent_kernel(a, b):\n", - " \"\"\"A 'clever' kernel that games the benchmarking harness.\"\"\"\n", - " # The agent creates a new stream to \"optimize\"\n", - " s = torch.cuda.Stream()\n", - " with torch.cuda.stream(s):\n", - " # This work happens on a side channel!\n", - " result = torch.matmul(a, b)\n", - " return result\n", - "\n", - "print(f\"Standard benchmark on tricky kernel: {final_benchmark(tricky_agent_kernel, a, b):.4f} ms\")\n", - "# Likely reports ~0.00ms or very close to it!" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "3HXns_XizX2j" - }, - "source": [ - "**The Issue:**\n", - "Standard benchmarking tools (including `do_bench`) record events on the *current default stream*.\n", - "\n", - "1. Benchmark starts timer on Stream A (the default stream).\n", - "2. Agent launches work on Stream B and returns immediately.\n", - "3. Benchmark stops timer on Stream A.\n", - "\n", - "Since Stream A had no work, the timer reports `~0.00ms`, while Stream B is still churning away in the background.\n", - "\n", - "**Why this matters for evals:**\n", - "If your reward signal is \"lower time = better score,\" an agent that discovers this pattern will be rewarded for producing *broken* code. The kernel \"runs\" instantly because you never measured it at all.\n", - "\n", - "**Mitigations:**\n", - "- **Wall-clock + full device sync:** Trade precision for correctness (catches all streams, but includes CPU overhead)\n", - "- **Static analysis:** Reject submissions that create `torch.cuda.Stream()` objects\n", - "- **Manual inspection:** For high-stakes evals, benchmark kernels in isolation outside the automated harness\n", - "\n", - "### How KernelBench Addresses This\n", - "\n", - "KernelBench's timing module provides the **`host_time`** method specifically designed for evaluating untrusted code:\n", - "\n", - "**Use `torch.cuda.synchronize()`** before AND after timing - this waits for ALL streams on the device, not just the default stream\n", - "\n", - "```python\n", - "# For trusted code (faster, but can be fooled)\n", - "timing_fn = get_timing_function(\"cuda_event\")\n", - "\n", - "# For untrusted/agent code (catches side-streams)\n", - "timing_fn = get_timing_function(\"host_time\")\n", - "```\n", - "\n", - "The trade-off: `host_time` includes some CPU overhead in the measurement. However, note that host_time should be pretty similar to sync_time. Therefore, if both times are within a some percent of each other, you can be pretty sure that the kernel is running correctly and score using sync_time." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "execution": { - "iopub.execute_input": "2025-12-17T21:24:52.782281Z", - "iopub.status.busy": "2025-12-17T21:24:52.782061Z", - "iopub.status.idle": "2025-12-17T21:24:52.830292Z", - "shell.execute_reply": "2025-12-17T21:24:52.829161Z" - }, - "id": "KbAFqiyizX2j", - "outputId": "6bc91db4-935c-4af9-bdc9-be3c50e890c4" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Robust benchmark on tricky kernel: 21.6298 ms\n", - "Robust benchmark on normal kernel: 21.5420 ms\n" - ] - } - ], - "source": [ - "def benchmark_untrusted(func, *args):\n", - " \"\"\"Benchmark untrusted code by using wall-clock time with full device sync.\n", - "\n", - " This trades some precision (includes CPU overhead) for correctness\n", - " (catches work on any stream).\n", - " \"\"\"\n", - " torch.cuda.synchronize() # Clear any pending work\n", - " start = time.perf_counter()\n", - " func(*args)\n", - " torch.cuda.synchronize() # Wait for ALL streams\n", - " end = time.perf_counter()\n", - " return (end - start) * 1000\n", - "\n", - "print(f\"Robust benchmark on tricky kernel: {benchmark_untrusted(tricky_agent_kernel, a, b):.4f} ms\")\n", - "print(f\"Robust benchmark on normal kernel: {benchmark_untrusted(simple_mm, a, b):.4f} ms\")" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "execution": { - "iopub.execute_input": "2025-12-17T21:24:52.832854Z", - "iopub.status.busy": "2025-12-17T21:24:52.832734Z", - "iopub.status.idle": "2025-12-17T21:24:53.846639Z", - "shell.execute_reply": "2025-12-17T21:24:53.845578Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Side-Stream Detection Experiment:\n", - "============================================================\n", - "[Profiling] Using timing method: cuda_event\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 10\n", - "[Profiling] Using timing method: host_time\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 10\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 10\n", - "\n", - "Tricky kernel with cuda_event: 0.4400 ms (FOOLED!)\n", - "Tricky kernel with host_time: 21.8000 ms (CORRECT)\n", - "Normal kernel with host_time: 21.5000 ms (reference)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Key insight: host_time correctly measures the tricky kernel!\n", - "Use host_time for evaluating untrusted/agent-generated code.\n" - ] - } - ], - "source": [ - "# Side-Stream Detection with KernelBench's host_time\n", - "# Let's demonstrate how host_time catches the tricky kernel\n", - "\n", - "print(\"Side-Stream Detection Experiment:\")\n", - "print(\"=\" * 60)\n", - "\n", - "# cuda_event (can be fooled by side-streams)\n", - "cuda_timing = get_timing_function(\"cuda_event\")\n", - "cuda_times = cuda_timing(tricky_agent_kernel, [a, b], num_trials=10, verbose=False, device=DEVICE)\n", - "cuda_stats = get_timing_stats(cuda_times, device=DEVICE)\n", - "\n", - "# host_time (catches all streams)\n", - "host_timing = get_timing_function(\"host_time\")\n", - "host_times = host_timing(tricky_agent_kernel, [a, b], num_trials=10, verbose=False, device=DEVICE)\n", - "host_stats = get_timing_stats(host_times, device=DEVICE)\n", - "\n", - "# Normal kernel for reference\n", - "normal_times = host_timing(simple_mm, [a, b], num_trials=10, verbose=False, device=DEVICE)\n", - "normal_stats = get_timing_stats(normal_times, device=DEVICE)\n", - "\n", - "print(f\"\\nTricky kernel with cuda_event: {cuda_stats['mean']:.4f} ms (FOOLED!)\")\n", - "print(f\"Tricky kernel with host_time: {host_stats['mean']:.4f} ms (CORRECT)\")\n", - "print(f\"Normal kernel with host_time: {normal_stats['mean']:.4f} ms (reference)\")\n", - "\n", - "# Visualize the dramatic difference\n", - "plt.figure(figsize=(10, 5))\n", - "methods = ['cuda_event\\n(fooled)', 'host_time\\n(correct)', 'Normal kernel\\n(reference)']\n", - "times = [cuda_stats['mean'], host_stats['mean'], normal_stats['mean']]\n", - "colors = ['red', 'green', 'blue']\n", - "\n", - "plt.bar(methods, times, color=colors, alpha=0.8)\n", - "plt.ylabel('Time (ms)')\n", - "plt.title('Side-Stream Detection: cuda_event vs host_time')\n", - "plt.grid(True, alpha=0.3, axis='y')\n", - "\n", - "# Add annotation\n", - "plt.annotate('Agent trick detected!', xy=(1, host_stats['mean']), \n", - " xytext=(1.3, host_stats['mean'] * 0.7),\n", - " arrowprops=dict(arrowstyle='->', color='green'),\n", - " fontsize=10, color='green')\n", - "plt.tight_layout()\n", - "plt.show()\n", - "\n", - "print(\"\\nKey insight: host_time correctly measures the tricky kernel!\")\n", - "print(\"Use host_time for evaluating untrusted/agent-generated code.\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Uq4qvl8FzX2j" - }, - "source": [ - "## Correctness Before Speed\n", - "\n", - "A kernel that runs in 0.1ms but produces garbage is worthless. Before you start optimizing, **always verify correctness** against a reference implementation." - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "execution": { - "iopub.execute_input": "2025-12-17T21:24:53.849299Z", - "iopub.status.busy": "2025-12-17T21:24:53.849171Z", - "iopub.status.idle": "2025-12-17T21:24:53.929702Z", - "shell.execute_reply": "2025-12-17T21:24:53.928700Z" - }, - "id": "J9W63Q5czX2k", - "outputId": "312076ee-f089-4276-8b8f-bb7a23575d3d" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "✓ Correctness verified!\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", - "Kernel time: 0.0648 ms\n" - ] - } - ], - "source": [ - "def my_experimental_kernel(a, b):\n", - " \"\"\"Pretend this is our custom optimized kernel.\"\"\"\n", - " return torch.matmul(a, b) # In reality, this would be your Triton/CUDA code\n", - "\n", - "def verify_correctness(kernel_fn, ref_fn, *args, atol=1e-2, rtol=1e-2):\n", - " \"\"\"Verify kernel produces correct output before benchmarking.\"\"\"\n", - " ref_output = ref_fn(*args)\n", - " kernel_output = kernel_fn(*args)\n", - "\n", - " if not torch.allclose(ref_output, kernel_output, atol=atol, rtol=rtol):\n", - " max_diff = (ref_output - kernel_output).abs().max().item()\n", - " raise AssertionError(\n", - " f\"Kernel output doesn't match reference! \"\n", - " f\"Max difference: {max_diff:.6f}\"\n", - " )\n", - " print(\"✓ Correctness verified!\")\n", - " return True\n", - "\n", - "# Always verify before benchmarking\n", - "a_test, b_test = get_data(1024)\n", - "verify_correctness(my_experimental_kernel, simple_mm, a_test, b_test)\n", - "\n", - "# Only benchmark if correct\n", - "time_ms = final_benchmark(my_experimental_kernel, a_test, b_test)\n", - "print(f\"Kernel time: {time_ms:.4f} ms\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Computing TFLOPS: Are We Hitting the Speed of Light?\n", - "\n", - "It is also important to sanity check the results whether it is to see how well we are doing, or to see if our results are physically possible.\n", - "\n", - "To answer this, we convert our millisecond timings into **TFLOPS** (Tera Floating-Point Operations Per Second) and compare against the hardware's theoretical maximum—often called the **\"speed of light\"** or **roofline**.\n", - "\n", - "### Understanding Roofline Analysis\n", - "\n", - "The Roofline Model helps you understand whether your kernel is:\n", - "- **Compute-bound**: Limited by the GPU's arithmetic throughput (FLOPS)\n", - "- **Memory-bound**: Limited by memory bandwidth (GB/s)\n", - "\n", - "**Key formulas:**\n", - "- **Arithmetic Intensity** = FLOPs / Bytes accessed\n", - "- **Theoretical Peak FLOPS** = Clock speed × Cores × FLOPs/cycle\n", - "- **Theoretical Peak Bandwidth** = Memory clock × Bus width × 2 (for DDR)\n", - "\n", - "For matrix multiplication of two $N \\times N$ matrices:\n", - "- **FLOPs** = $2N^3$ (one multiply + one add per output element, summed $N$ times)\n", - "- **Bytes** = $3N^2 \\times \\text{sizeof(dtype)}$ (read A, read B, write C)\n", - "- **Arithmetic Intensity** = $\\frac{2N^3}{3N^2 \\times 4} = \\frac{N}{6}$ for float32\n", - "\n", - "Large matrix multiplications are highly compute-bound (high arithmetic intensity), so we expect to approach the compute roofline. For a deeper dive into roofline analysis and speed-of-light calculations, see the excellent [JAX Scaling Book chapter on Roofline](https://jax-ml.github.io/scaling-book/roofline/)." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "execution": { - "iopub.execute_input": "2025-12-17T21:24:53.932346Z", - "iopub.status.busy": "2025-12-17T21:24:53.932227Z", - "iopub.status.idle": "2025-12-17T21:24:56.741833Z", - "shell.execute_reply": "2025-12-17T21:24:56.740706Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Matrix Multiplication Performance\n", - "=================================================================\n", - "Size Time (ms) TFLOPS % of TF32 Peak \n", - "-----------------------------------------------------------------\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", - "1024 0.0648 33.14 3.4 %\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", - "2048 0.3440 49.94 5.0 %\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", - "4096 2.6800 51.28 5.2 %\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", - "8192 21.4000 51.38 5.2 %\n", - "\n", - "Note: PyTorch uses TF32 tensor cores by default on Ampere+ GPUs.\n", - "H200 TF32 theoretical peak: 989.0 TFLOPS\n", - "\n", - "For roofline analysis details, see: https://jax-ml.github.io/scaling-book/roofline/\n" - ] - } - ], - "source": [ - "def get_tflops(n, time_ms):\n", - " \"\"\"Calculate achieved TFLOPS for matrix multiplication.\"\"\"\n", - " flops = 2 * n ** 3 # Multiply-add for each of N^2 output elements\n", - " tflops = flops / (time_ms * 1e-3) / 1e12\n", - " return tflops\n", - "\n", - "# Theoretical peaks vary by GPU and precision\n", - "# PyTorch uses TF32 by default on Ampere+ GPUs for matmul\n", - "GPU_PEAK_TFLOPS = {\n", - " 'A100': {'fp32': 19.5, 'tf32': 156.0, 'fp16': 312.0},\n", - " 'H100': {'fp32': 67.0, 'tf32': 989.0, 'fp16': 1979.0},\n", - " 'H200': {'fp32': 67.0, 'tf32': 989.0, 'fp16': 1979.0},\n", - "}\n", - "\n", - "# Use TF32 peak since PyTorch defaults to TF32 on Ampere+\n", - "PEAK_TFLOPS = 989.0 # H200 TF32 peak\n", - "\n", - "# Benchmark at different sizes\n", - "print(\"Matrix Multiplication Performance\")\n", - "print(\"=\" * 65)\n", - "print(f\"{'Size':<8} {'Time (ms)':<12} {'TFLOPS':<12} {'% of TF32 Peak':<15}\")\n", - "print(\"-\" * 65)\n", - "\n", - "for size in [1024, 2048, 4096, 8192]:\n", - " a_test, b_test = get_data(size)\n", - " time_ms = final_benchmark(simple_mm, a_test, b_test)\n", - " tflops = get_tflops(size, time_ms)\n", - " efficiency = (tflops / PEAK_TFLOPS) * 100\n", - " print(f\"{size:<8} {time_ms:<12.4f} {tflops:<12.2f} {efficiency:<15.1f}%\")\n", - "\n", - "print(f\"\\nNote: PyTorch uses TF32 tensor cores by default on Ampere+ GPUs.\")\n", - "print(f\"H200 TF32 theoretical peak: {PEAK_TFLOPS} TFLOPS\")\n", - "print(f\"\\nFor roofline analysis details, see: https://jax-ml.github.io/scaling-book/roofline/\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "zcYVXCkUzX2k" - }, - "source": [ - "## Conclusion\n", - "\n", - "Benchmarking on GPUs is fundamentally different from CPUs. The asynchronous nature of kernel launches, the hidden state of the L2 cache, and the noise of the OS scheduler all conspire to give you the wrong numbers.\n", - "\n", - "### What We Learned\n", - "\n", - "Through our journey, we discovered that robust GPU benchmarking requires:\n", - "1. **Device Synchronization** - Wait for GPU work to complete\n", - "2. **CUDA Events** - Use GPU-side timestamps, not CPU clocks\n", - "3. **Warmup Runs** - Settle compilation and memory allocators\n", - "4. **Multiple Samples** - Build statistical distributions\n", - "5. **L2 Cache Flushing** - Measure cold cache (realistic) performance\n", - "6. **Median Aggregation** - Filter out OS jitter and outliers\n", - "7. **Side-Stream Detection** - Catch work on non-default streams\n", - "\n", - "### What KernelBench Provides\n", - "\n", - "We've implemented all these best practices in **KernelBench's timing module** (`src/timing.py`):\n", - "\n", - "| Function | Purpose |\n", - "|----------|---------|\n", - "| `get_timing_function(method)` | Factory returning timing function by name |\n", - "| `clear_l2_cache(device)` | L2 cache flushing utility |\n", - "| `get_timing_stats(times)` | Statistical aggregation (mean, std, min, max) |\n", - "\n", - "**Four timing methods for different use cases:**\n", - "- **`cuda_event`** - Default for trusted code (fastest, GPU-side timing)\n", - "- **`host_time`** - For untrusted/agent code (catches all streams)\n", - "- **`do_bench`** - Triton-style adaptive trial counts\n", - "- **`do_bench_impl`** - Transparent do_bench with explicit control\n", - "\n", - "**Key parameters:**\n", - "- `num_warmup`, `num_trials`, `discard_first`, `device`, `verbose`\n", - "\n", - "### Recommended Usage\n", - "\n", - "```python\n", - "from src.timing import get_timing_function, get_timing_stats\n", - "\n", - "# For trusted code\n", - "timing_fn = get_timing_function(\"cuda_event\")\n", - "\n", - "# For agent evaluations (catches side-streams)\n", - "timing_fn = get_timing_function(\"host_time\")\n", - "\n", - "# Run benchmark\n", - "times = timing_fn(kernel, args, num_warmup=10, num_trials=100, device=\"cuda:0\")\n", - "stats = get_timing_stats(times, device=\"cuda:0\")\n", - "print(f\"Mean: {stats['mean']:.4f}ms, Std: {stats['std']:.4f}ms\")\n", - "```\n", - "\n", - "Happy optimizing!" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "7Ah151CHzX2k" - }, - "source": [ - "---\n", - "\n", - "### Footnotes\n", - "\n", - "**On GPU Clock States:** For highly reproducible benchmarks (e.g., publishing papers), consider locking GPU clocks with `nvidia-smi -lgc `. GPUs dynamically adjust clock speeds based on thermals and power, which can introduce variance between runs. For most development work, median-based benchmarking handles this adequately.\n", - "\n", - "**On Warmup Iterations:** We use fixed warmup counts (10-50 iterations) for simplicity, but this can be insufficient or wasteful depending on the kernel. In extremely sensitive environments, you can implement an adaptive stopping criterion: run warmup iterations until the variance of recent samples falls below a threshold, indicating the system has stabilized. This is covered in more detail in the [GPU MODE lecture](https://www.youtube.com/watch?v=1i7dxoAfKOU).\n", - "\n", - "**On Bare Metal vs. Virtualized Environments:** Cloud VMs and containers add layers of abstraction that can introduce variance and overhead. GPU passthrough in virtualized environments adds latency, and shared cloud instances suffer from \"noisy neighbor\" effects where other tenants' workloads impact your measurements. For publishable results or when chasing small performance deltas, prefer bare metal. For day-to-day development, cloud instances are fine as long as you're aware your numbers may not match others exactly." - ] - } - ], - "metadata": { - "accelerator": "GPU", - "colab": { - "gpuType": "A100", - "include_colab_link": true, - "provenance": [] - }, - "kernelspec": { - "display_name": ".venv", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.9" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/notebooks/benchmarking.ipynb b/notebooks/benchmarking.ipynb index 6b77fd20..a9f3ba15 100644 --- a/notebooks/benchmarking.ipynb +++ b/notebooks/benchmarking.ipynb @@ -63,7 +63,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/simon/miniconda3/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + "/home/simon/palic/KernelBench/.venv/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", " from .autonotebook import tqdm as notebook_tqdm\n" ] }, @@ -82,8 +82,12 @@ "# !pip install -e .. # Install KernelBench locally for timing utilities\n", "\n", "import sys\n", + "import os\n", "sys.path.insert(0, '..') # Add parent directory to path for imports\n", "\n", + "# For multi-GPU systems, set CUDA_VISIBLE_DEVICES=X before running to select a specific GPU\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"5\"\n", + "\n", "import torch\n", "import time\n", "import numpy as np\n", @@ -98,9 +102,9 @@ " raise RuntimeError(\"This notebook requires a GPU. Please enable GPU in your runtime settings.\")\n", "\n", "# Device configuration\n", - "# For multi-GPU systems, set CUDA_VISIBLE_DEVICES=X before running to select a specific GPU\n", "# The selected GPU will appear as cuda:0\n", - "DEVICE = \"cuda:0\"\n", + "\n", + "DEVICE = f\"cuda:0\"\n", "print(f\"Using GPU: {torch.cuda.get_device_name(DEVICE)}\")" ] }, @@ -166,7 +170,7 @@ "id": "GWlsBEVyzX2g" }, "source": [ - "### Attempt 1: The Naive Timer (The Asynchronous Illusion)\n", + "### Attempt 1: The Naive Timer\n", "\n", "The most intuitive way to time code in Python is using `time.time()`. Let's try that first." ] @@ -192,7 +196,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Naive time: 0.5236 ms\n" + "Naive time: 0.6356 ms\n" ] } ], @@ -232,6 +236,15 @@ "¹ **Why impossible?** The [H200](https://www.nvidia.com/en-us/data-center/h200/) peaks at 989 TFLOPS for TF32 Tensor Cores. At that rate: 1.1 TFLOP ÷ 989 TFLOP/s = **1.11ms minimum**. Anything under 1ms is physically impossible." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Attempt 2: Synchronizing the Device\n", + "\n", + "To fix this, we need to force the CPU to wait until the GPU has finished its work before we stop the clock. We do this with `torch.cuda.synchronize()`." + ] + }, { "cell_type": "code", "execution_count": 4, @@ -248,106 +261,22 @@ "name": "stdout", "output_type": "stream", "text": [ - "Comparing Synchronized time.time() vs CUDA Events:\n", - "------------------------------------------------------------\n", - "N= 512: sync= 0.0699ms, events= 0.0374ms, overhead=+0.0325ms\n", - "N=1024: sync= 0.0725ms, events= 0.0718ms, overhead=+0.0007ms\n", - "N=2048: sync= 0.3567ms, events= 0.3543ms, overhead=+0.0024ms\n", - "N=4096: sync= 2.7008ms, events= 2.6914ms, overhead=+0.0094ms\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Key insight: Synchronized timing includes 0.009ms of CPU overhead.\n", - "CUDA Events (2.6914ms) measure pure GPU execution time.\n" + "Sync time: 21.5368 ms\n" ] } ], "source": [ - "# Compare: Synchronized time.time() vs CUDA Events\n", - "# This shows why GPU-side timestamps are more accurate\n", - "\n", "def benchmark_sync(func, *args):\n", - " \"\"\"Attempt 2: Synchronized - waits for GPU but uses CPU clock.\"\"\"\n", - " torch.cuda.synchronize(device=DEVICE)\n", + " \"\"\"Better: Actually waits for GPU to finish.\"\"\"\n", + " torch.cuda.synchronize() # Wait for previous work to finish\n", " start = time.time()\n", " func(*args)\n", - " torch.cuda.synchronize(device=DEVICE)\n", + " torch.cuda.synchronize() # Wait for THIS work to finish\n", " end = time.time()\n", " return (end - start) * 1000\n", "\n", - "def benchmark_events(func, *args):\n", - " \"\"\"Attempt 3: CUDA Events - GPU-side timestamps, most accurate.\"\"\"\n", - " start_event = torch.cuda.Event(enable_timing=True)\n", - " end_event = torch.cuda.Event(enable_timing=True)\n", - " torch.cuda.synchronize(device=DEVICE)\n", - " start_event.record()\n", - " func(*args)\n", - " end_event.record()\n", - " torch.cuda.synchronize(device=DEVICE)\n", - " return start_event.elapsed_time(end_event)\n", - "\n", - "# Test across different matrix sizes\n", - "sizes = [512, 1024, 2048, 4096]\n", - "sync_times = []\n", - "event_times = []\n", - "\n", - "print(\"Comparing Synchronized time.time() vs CUDA Events:\")\n", - "print(\"-\" * 60)\n", - "for s in sizes:\n", - " a_test, b_test = get_data(s)\n", - " # Warmup\n", - " for _ in range(3):\n", - " simple_mm(a_test, b_test)\n", - " torch.cuda.synchronize(device=DEVICE)\n", - " \n", - " sync_t = benchmark_sync(simple_mm, a_test, b_test)\n", - " event_t = benchmark_events(simple_mm, a_test, b_test)\n", - " \n", - " sync_times.append(sync_t)\n", - " event_times.append(event_t)\n", - " overhead = sync_t - event_t\n", - " print(f\"N={s:4d}: sync={sync_t:7.4f}ms, events={event_t:7.4f}ms, overhead={overhead:+.4f}ms\")\n", - "\n", - "# Create visualization\n", - "fig, axes = plt.subplots(1, 2, figsize=(12, 5))\n", - "\n", - "# Left plot: Both methods across sizes\n", - "axes[0].plot(sizes, sync_times, 's-', label='Synchronized (CPU clock)', linewidth=2, markersize=8, color='orange')\n", - "axes[0].plot(sizes, event_times, '^-', label='CUDA Events (GPU clock)', linewidth=2, markersize=8, color='green')\n", - "axes[0].set_xlabel('Matrix Size (N)')\n", - "axes[0].set_ylabel('Time (ms)')\n", - "axes[0].set_title('CPU Clock vs GPU Clock Timing')\n", - "axes[0].legend()\n", - "axes[0].grid(True, alpha=0.3)\n", - "\n", - "# Right plot: Bar chart showing overhead at largest size\n", - "overhead_ms = sync_times[-1] - event_times[-1]\n", - "axes[1].bar(['Synchronized\\n(time.time + sync)', 'CUDA Events\\n(GPU timestamps)'], \n", - " [sync_times[-1], event_times[-1]], \n", - " color=['orange', 'green'], alpha=0.8)\n", - "axes[1].set_ylabel('Time (ms)')\n", - "axes[1].set_title(f'CPU Overhead at N={sizes[-1]}\\n(Sync includes ~{overhead_ms:.3f}ms CPU overhead)')\n", - "axes[1].axhline(y=event_times[-1], color='green', linestyle='--', alpha=0.5, label='True GPU time')\n", - "\n", - "plt.tight_layout()\n", - "plt.show()\n", - "\n", - "print(f\"\\nKey insight: Synchronized timing includes {overhead_ms:.3f}ms of CPU overhead.\")\n", - "print(f\"CUDA Events ({event_times[-1]:.4f}ms) measure pure GPU execution time.\")" + "t = benchmark_sync(simple_mm, a, b)\n", + "print(f\"Sync time: {t:.4f} ms\")" ] }, { @@ -382,9 +311,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "Run 0: 21.9622 ms\n", - "Run 1: 21.6770 ms\n", - "Run 2: 21.4259 ms\n" + "Run 0: 21.7344 ms\n", + "Run 1: 21.4754 ms\n", + "Run 2: 21.4987 ms\n" ] } ], @@ -442,9 +371,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "Run 0: 21.4824 ms\n", - "Run 1: 21.4355 ms\n", - "Run 2: 21.4300 ms\n" + "Run 0: 21.6478 ms\n", + "Run 1: 21.4837 ms\n", + "Run 2: 21.4852 ms\n" ] } ], @@ -504,7 +433,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -516,11 +445,11 @@ "name": "stdout", "output_type": "stream", "text": [ - "Mean: 21.4449 ms\n", - "Median: 21.4454 ms\n", - "Std: 0.0213 ms\n", - "Min: 21.4074 ms\n", - "Max: 21.5199 ms\n" + "Mean: 21.5096 ms\n", + "Median: 21.4942 ms\n", + "Std: 0.0625 ms\n", + "Min: 21.4420 ms\n", + "Max: 21.7808 ms\n" ] } ], @@ -628,9 +557,9 @@ "\n", "With cache flushing (cold cache):\n", "\n", - "Warm cache median: 0.0283 ms\n", - "Cold cache median: 0.0323 ms\n", - "Difference: 0.0040 ms (14.3% slower with cold cache)\n", + "Warm cache median: 0.0280 ms\n", + "Cold cache median: 0.0318 ms\n", + "Difference: 0.0038 ms (13.7% slower with cold cache)\n", "\n", "Without cache flushing, you measure artificially fast times!\n" ] @@ -642,8 +571,10 @@ "N_SMALL = 512\n", "a_small, b_small = get_data(N_SMALL)\n", "\n", + "NUM_SAMPLES = 20\n", + "\n", "# do warmup runs\n", - "for _ in range(10):\n", + "for _ in range(NUM_SAMPLES):\n", " clear_l2_cache(device=DEVICE)\n", " benchmark_events(simple_mm, a_small, b_small)\n", " torch.cuda.synchronize(device=DEVICE)\n", @@ -651,14 +582,14 @@ "# Benchmark WITHOUT cache flushing (warm cache - unrealistic)\n", "print(\"Without cache flushing (warm cache):\")\n", "times_warm = []\n", - "for i in range(10):\n", + "for i in range(NUM_SAMPLES):\n", " t = benchmark_events(simple_mm, a_small, b_small)\n", " times_warm.append(t)\n", "\n", "# Benchmark WITH cache flushing (cold cache - realistic)\n", "print(\"\\nWith cache flushing (cold cache):\")\n", "times_cold = []\n", - "for i in range(10):\n", + "for i in range(NUM_SAMPLES):\n", " clear_l2_cache(device=DEVICE) # Flush cache before each measurement\n", " t = benchmark_events(simple_mm, a_small, b_small)\n", " times_cold.append(t)\n", @@ -683,7 +614,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -694,14 +625,19 @@ ], "source": [ "# Visualize the cache effect\n", + "# Discard first few samples to remove initialization noise\n", + "discard = 3\n", + "times_warm_clean = times_warm[discard:]\n", + "times_cold_clean = times_cold[discard:]\n", + "\n", "plt.figure(figsize=(10, 5))\n", - "plt.scatter(range(len(times_warm)), times_warm, alpha=0.7, label=f'Warm Cache (mean={np.mean(times_warm):.4f}ms)', color='orange', s=60)\n", - "plt.scatter(range(len(times_cold)), times_cold, alpha=0.7, label=f'Cold Cache (mean={np.mean(times_cold):.4f}ms)', color='blue', s=60)\n", - "plt.axhline(y=np.mean(times_warm), color='orange', linestyle='--', alpha=0.5)\n", - "plt.axhline(y=np.mean(times_cold), color='blue', linestyle='--', alpha=0.5)\n", + "plt.scatter(range(len(times_warm_clean)), times_warm_clean, alpha=0.7, label=f'Warm Cache (mean={np.mean(times_warm_clean):.4f}ms)', color='orange', s=60)\n", + "plt.scatter(range(len(times_cold_clean)), times_cold_clean, alpha=0.7, label=f'Cold Cache (mean={np.mean(times_cold_clean):.4f}ms)', color='blue', s=60)\n", + "plt.axhline(y=np.mean(times_warm_clean), color='orange', linestyle='--', alpha=0.5)\n", + "plt.axhline(y=np.mean(times_cold_clean), color='blue', linestyle='--', alpha=0.5)\n", "plt.xlabel('Run Index')\n", "plt.ylabel('Time (ms)')\n", - "plt.title(f'Cache Effect on {N_SMALL}x{N_SMALL} Matrix Multiplication')\n", + "plt.title(f'Cache Effect on {N_SMALL}x{N_SMALL} Matrix Multiplication\\n(first {discard} samples discarded)')\n", "plt.legend()\n", "plt.grid(True, alpha=0.3)\n", "plt.show()" @@ -750,21 +686,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "[Profiling] Using timing method: cuda_event\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "KernelBench cuda_event time: 21.4000 ms\n" + "[Profiling] Using timing method: cuda_event\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", + "KernelBench cuda_event time: 21.5000 ms\n" ] } ], @@ -880,7 +804,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": { "execution": { "iopub.execute_input": "2025-12-17T21:24:47.008751Z", @@ -898,63 +822,35 @@ "======================================================================\n", "\n", "Testing cuda_event...\n", - "[Profiling] Using timing method: cuda_event\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 50\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " cuda_event: 21.4000 ms (std=0.0169)\n", + "[Profiling] Using timing method: cuda_event\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 50\n", + " cuda_event: 21.5000 ms (std=0.0572)\n", "\n", "Testing host_time...\n", - "[Profiling] Using timing method: host_time\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 50\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " host_time: 21.6000 ms (std=0.0159)\n", + "[Profiling] Using timing method: host_time\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 50\n", + " host_time: 21.5000 ms (std=0.0427)\n", "\n", "Testing do_bench...\n", - "[Profiling] Using timing method: do_bench\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " do_bench: 21.4000 ms (std=0.0150)\n", + "[Profiling] Using timing method: do_bench\n", + " do_bench: 21.4000 ms (std=0.0030)\n", "\n", "Testing do_bench_impl...\n", - "[Profiling] Using timing method: do_bench_impl\n" + "[Profiling] Using timing method: do_bench_impl\n", + " do_bench_impl: 21.4000 ms (std=0.0315)\n" ] }, { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - " do_bench_impl: Skipped due to AttributeError (Triton version compatibility)\n" + "/tmp/ipykernel_710987/1660294801.py:64: UserWarning: Attempting to set identical low and high ylims makes transformation singular; automatically expanding.\n", + " axes[1].set_ylim(min_val - margin, max_val + margin)\n" ] }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAHpCAYAAABTH4/7AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAuVlJREFUeJzs3Xl8Tdf+//H3CclJZBQEqSloDUWpqpoiRGOsmqe2RBVtE26oVukg6JWqDm5r7hCKtIZWtXpLjVGKKtfcKopWibFJSAiS/fujv+yv42Q4iQzI6/l4nMfNWXvttdfeZ9+ej89Zey2LYRiGAAAAAAAAgALkVNgdAAAAAAAAQNFDUgoAAAAAAAAFjqQUAAAAAAAAChxJKQAAAAAAABQ4klIAAAAAAAAocCSlAAAAAAAAUOBISgEAAAAAAKDAkZQCAAAAAABAgSMpBQAAAAAAgAJHUgoAAAAAHFClShWFhoYWdjcgae7cubJYLPr5558Luyu3LDIyUhaLpbC7ARQKklIAAAAAgGxNmjRJX331VWF3o1Dl9hokJycrMjJSGzZsyPM+AXcyklIAAAAAgGyRlLq1pNT48eMzTEq9+uqrunz58q13DrgDFS/sDgAAAAAAUFQVL15cxYvzT3MUTYyUAgAAAHDH++uvvzRo0CD5+/vLarUqICBAzz33nK5evSop83l70ucmOnbsmFlmGIbeeOMNVahQQSVKlFCrVq20f/9+u30vXLigUaNGqW7duvLw8JCXl5fat2+v3bt35+ocvvvuO7Vo0ULu7u7y9PRUx44dbY779ttvy2Kx6Pjx43b7jhkzRi4uLvr777/Nsm3btqldu3by9vZWiRIl1LJlS23evNlmv/TrcvjwYYWGhsrHx0fe3t4aOHCgkpOTzXoWi0VJSUmaN2+eLBaLLBZLpvNrnT59WsWLF9f48ePtth08eFAWi0XTpk2TJF27dk3jx4/XvffeK1dXV5UqVUrNmzfX6tWrHbpmKSkpGjlypMqUKSN3d3d17dpVZ8+etas3Y8YM3X///bJarfL391dYWJji4+Nt6hw6dEjdu3dXuXLl5OrqqgoVKqhPnz5KSEjI8TW40bFjx1SmTBlJ0vjx4819IyMjJWV8b1osFoWHh2vJkiWqXbu23Nzc1KRJE+3du1eSNHv2bFWvXl2urq4KCgqyuX/TOfL5A4WNpBQAAACAO9rJkyf18MMP6/PPP1fv3r31/vvv66mnnlJsbKxNYsVRr7/+ul577TU98MADmjJliqpWraqQkBAlJSXZ1Pv999/11VdfqVOnTnr33Xf14osvau/evWrZsqVOnjyZo2POnz9fHTt2lIeHhyZPnqzXXntNBw4cUPPmzc2EQ69evWSxWLR48WK7/RcvXqyQkBCVLFlSkrRu3ToFBgYqMTFR48aN06RJkxQfH6/WrVvrp59+stu/V69eunjxoqKiotSrVy/NnTvXJqk0f/58Wa1WtWjRQvPnz9f8+fM1dOjQDM+lbNmyatmyZYb9XLRokYoVK6aePXtK+ichM378eLVq1UrTpk3TK6+8okqVKmnnzp0OXbdhw4Zp9+7dGjdunJ577jl98803Cg8Pt6kTGRmpsLAw+fv765133lH37t01e/ZshYSE6Nq1a5Kkq1evqm3bttq6dauGDRum6dOna8iQIfr999/N5FVOrsGNypQpo5kzZ0qSunbtau7brVu3LPf74Ycf9MILL2jAgAGKjIzUL7/8ok6dOmn69Ol6//339fzzz+vFF1/Uli1b9PTTT9vsm9PPHyg0BgAAAADcwfr37284OTkZ27dvt9uWlpZmGIZhjBs3zsjonz/R0dGGJOPo0aOGYRjGmTNnDBcXF6Njx47mvoZhGGPHjjUkGQMGDDDLrly5YqSmptq0d/ToUcNqtRoTJkxwuP8XL140fHx8jMGDB9uUx8XFGd7e3jblTZo0MRo2bGhT76effjIkGZ9++ql5zvfee6/Rtm1bm3NITk42AgICjEcffdQsS78uTz/9tE2bXbt2NUqVKmVT5u7ubnP+WZk9e7Yhydi7d69Nee3atY3WrVub7x944AGjY8eODrV5o/TPrU2bNjbnOGLECKNYsWJGfHy8YRj/93mGhITYfFbTpk0zJBmffPKJYRiG8b///c+QZCxZsiTL4+bkGtzo7NmzhiRj3LhxdtsyujclGVar1bwvDeP/rmm5cuWMxMREs3zMmDE293BOPn+gsDFSCgAAAMAdKy0tTV999ZUee+wxPfTQQ3bbM3pkLytr1qzR1atXNWzYMJt9IyIi7OparVY5Of3zT6rU1FSdP39eHh4eqlGjhsMjfSRp9erVio+PV9++fXXu3DnzVaxYMTVu3Fjr16836/bu3Vs7duzQkSNHzLJFixbJarXq8ccflyTt2rVLhw4dUr9+/XT+/HmzvaSkJAUHB2vjxo1KS0uz6cOzzz5r875FixY6f/68EhMTHT6PG3Xr1k3FixfXokWLzLJ9+/bpwIED6t27t1nm4+Oj/fv369ChQ7k6zpAhQ2w+pxYtWig1NdV8xDH984yIiDA/K0kaPHiwvLy89O2330qSvL29JUmrVq3K1ei6/BAcHKwqVaqY7xs3bixJ6t69uzw9Pe3Kf//9d0m5+/yBwkJSCgAAAMAd6+zZs0pMTFSdOnXypL30ZMa9995rU16mTBnz0bh0aWlpeu+993TvvffKarWqdOnSKlOmjPbs2WPOQ+SI9IRM69atVaZMGZvX999/rzNnzph1e/bsKScnJzPZYxiGlixZovbt28vLy8umvQEDBti199FHHyklJcWuf5UqVbJ5n36uN85RlROlS5dWcHCwzSN8ixYtUvHixW0eW5swYYLi4+N13333qW7dunrxxRe1Z88eh4+TXb/TP88aNWrY1HNxcVHVqlXN7QEBARo5cqQ++ugjlS5dWm3bttX06dNz9DnmtZvPLT1xVrFixQzL0885N58/UFiY4h8AAADAXS+zEVOpqam5bnPSpEl67bXX9PTTT2vixIny9fWVk5OTIiIicjQSJb3u/PnzVa5cObvtN67M5u/vrxYtWmjx4sUaO3astm7dqj/++EOTJ0+2a2/KlCmqX79+hsf08PCweV+sWLEM6xmG4fB53KxPnz4aOHCgdu3apfr162vx4sUKDg5W6dKlzTqBgYE6cuSIli9fru+//14fffSR3nvvPc2aNUvPPPNMtsfIy36/8847Cg0NNfsyfPhwRUVFaevWrapQoUKO27tVmZ1bduecm88fKCwkpQAAAADcscqUKSMvLy/t27cvy3rpI2ji4+Pl4+Njlt+8kl3lypUl/TPapGrVqmb52bNn7UYNLV26VK1atdLHH39sUx4fH2+TeMlOtWrVJEl+fn5q06ZNtvV79+6t559/XgcPHtSiRYtUokQJPfbYY3bteXl5OdSeo3L6KGSXLl00dOhQc1TXb7/9pjFjxtjV8/X11cCBAzVw4EBdunRJgYGBioyMdCgplZ30z/PgwYM2n+fVq1d19OhRu+tTt25d1a1bV6+++qp+/PFHNWvWTLNmzdIbb7whKefXIF1u98uN/Pr8gfzA43sAAAAA7lhOTk7q0qWLvvnmG/38889229NHj6T/Q33jxo3mtqSkJM2bN8+mfps2beTs7KwPPvjAZrTN1KlT7douVqyY3YicJUuW6K+//srRObRt21ZeXl6aNGmSuRrcjc6ePWvzvnv37ipWrJg+++wzLVmyRJ06dZK7u7u5vWHDhqpWrZrefvttXbp0Kdv2HOXu7m6uROcIHx8ftW3bVosXL9bnn38uFxcXdenSxabO+fPnbd57eHioevXqSklJyVUfb9amTRu5uLjo/ffft/msPv74YyUkJKhjx46SpMTERF2/ft1m37p168rJycmmLzm9BulKlCghSbnaN6fy6/MH8gMjpQAAAADc0SZNmqTvv/9eLVu21JAhQ1SrVi2dOnVKS5Ys0aZNm+Tj46OQkBBVqlRJgwYN0osvvqhixYrpk08+UZkyZfTHH3+YbZUpU0ajRo1SVFSUOnXqpA4dOuh///ufvvvuO7vRT506ddKECRM0cOBANW3aVHv37tXChQttRuQ4wsvLSzNnztRTTz2lBx98UH369DH79e2336pZs2aaNm2aWd/Pz0+tWrXSu+++q4sXL9pMHC79k6j76KOP1L59e91///0aOHCg7rnnHv31119av369vLy89M033+T4Ojds2FBr1qzRu+++K39/fwUEBJiTbGemd+/eevLJJzVjxgy1bdvWZpSaJNWuXVtBQUFq2LChfH199fPPP2vp0qUKDw/Pcf8yUqZMGY0ZM0bjx49Xu3bt1LlzZx08eFAzZsxQo0aN9OSTT0qS1q1bp/DwcPXs2VP33Xefrl+/rvnz56tYsWLq3r37LV0DSXJzc1Pt2rW1aNEi3XffffL19VWdOnXybC60G+XX5w/ki8Jb+A8AAAAA8sbx48eN/v37G2XKlDGsVqtRtWpVIywszEhJSTHr7Nixw2jcuLHh4uJiVKpUyXj33XeN6OhoQ5Jx9OhRs15qaqoxfvx4o3z58oabm5sRFBRk7Nu3z6hcubIxYMAAs96VK1eMF154wazXrFkzY8uWLUbLli2Nli1b5vgc1q9fb7Rt29bw9vY2XF1djWrVqhmhoaHGzz//bFf3ww8/NCQZnp6exuXLlzNs73//+5/RrVs3o1SpUobVajUqV65s9OrVy1i7dq1ZZ9y4cYYk4+zZszb7ZnRdfv31VyMwMNBwc3MzJNlci8wkJiaa9RcsWGC3/Y033jAefvhhw8fHx3BzczNq1qxp/Pvf/zauXr2aZbvp/du+fbtN+fr16w1Jxvr1623Kp02bZtSsWdNwdnY2ypYtazz33HPG33//bW7//fffjaefftqoVq2a4erqavj6+hqtWrUy1qxZY9NObq5Buh9//NFo2LCh4eLiYkgyxo0bZxjG/30GN5JkhIWF2ZQdPXrUkGRMmTIlw3NesmSJTbkjnz9Q2CyGcQsz1wEAAAAAAAC5wJxSAAAAAAAAKHDMKQUAAAAA+eTs2bNKTU3NdLuLi4t8fX0LsEfIS6mpqdlOHO7h4SEPD48C6hFwZ+HxPQAAAADIJ1WqVNHx48cz3d6yZUtt2LCh4DqEPHXs2DEFBARkWWfcuHGKjIwsmA4BdxhGSgEAAABAPlm4cKEuX76c6faSJUsWYG+Q18qVK6fVq1dnWSenqzECRQkjpQAAAAAAAFDgmOgcAAAAAAAABY6kFIA7QlBQkIKCggq7G5mKjIyUxWIp7G6YNmzYIIvFoqVLlxZ2V/JN+jU/d+5cvh+rSpUqCg0NzffjAMCd6K233lLNmjWVlpYm6Z85diwWi95+++1C7tmtS/8+Zc4ne3fa55yTWM1isTAHVD45cOCAihcvrn379hV2V3CbICmFIm3u3LmyWCyyWCzatGmT3XbDMFSxYkVZLBZ16tSpEHrouCpVqpjncvOrXbt2hd09hxw4cECRkZE6duxYYXdFUtbX9MbX3LlzC7urhSY9wHNyctKff/5ptz0xMVFubm6yWCwKDw/P1TEmTZqkr7766hZ7CgDID4mJiZo8ebJGjx4tJ6fC/adFTEyMpk6dmqt9Z8yYUSS/z2/lmiFv/fe//y0SibDatWurY8eOev311wu7K7hNMNE5IMnV1VUxMTFq3ry5TXlsbKxOnDghq9VaSD3Lmfr16+uFF16wK/f39y+E3uTcgQMHNH78eAUFBalKlSo2277//vsC78/UqVN16dIl8/1///tfffbZZ3rvvfdUunRps7xp06Z68skn9fLLLxd4H28XVqtVn332mV566SWb8i+//PKW2540aZJ69OihLl263HJbAIC89cknn+j69evq27dvYXdFMTEx2rdvnyIiInK874wZM1S6dGm7UbGBgYG6fPmyXFxc8qaTt5lbuWZ3mldfffW2jtX++9//avr06UUiMfXss8+qQ4cOOnLkiKpVq1bY3UEhIykFSOrQoYOWLFmi999/X8WL/9//LWJiYtSwYcMCeTwoL9xzzz168sknC7sb+aIwgsGbkyBxcXH67LPP1KVLF7ukmSSbe6eo6dChQ4ZJqZiYGHXs2FFffPFFIfUMAJCfoqOj1blzZ7m6uhZ2V/KFk5PTXXtuRU3x4sXvmljt+vXrSktLu2OTpW3atFHJkiU1b948TZgwobC7g0LG43uApL59++r8+fM2y7levXpVS5cuVb9+/TLcJy0tTVOnTtX9998vV1dXlS1bVkOHDtXff/9tU2/58uXq2LGj/P39ZbVaVa1aNU2cOFGpqak29YKCglSnTh0dOHBArVq1UokSJXTPPfforbfeyrPzPHPmjMqUKaOgoCDduPDm4cOH5e7urt69e5tlKSkpGjdunKpXry6r1aqKFSvqpZdeUkpKil27CxYs0MMPP6wSJUqoZMmSCgwMtBnZlNlz+TfO0zN37lz17NlTktSqVSvz0bj0ORwymlPqzJkzGjRokMqWLStXV1c98MADmjdvnk2dG+c7mDNnjqpVqyar1apGjRpp+/btObl8WcponoL0R9aWLFmi2rVry83NTU2aNNHevXslSbNnz1b16tXl6uqqoKCgDB9b3LZtm9q1aydvb2+VKFFCLVu21ObNmx3uV2pqqsaOHaty5crJ3d1dnTt3tnnMbty4cXJ2dtbZs2ft9h0yZIh8fHx05cqVbI/Tr18/7dq1S7/++qtZFhcXp3Xr1mX6/yFH7jGLxaKkpCTNmzfPvCdu/hU7Pj5eoaGh8vHxkbe3twYOHKjk5GSbOtevX9fEiRPNz79KlSoaO3as3f1sGIbeeOMNVahQQSVKlFCrVq20f//+bM8fAIqio0ePas+ePWrTpk2mdRz57l23bp1atGghd3d3+fj46PHHH9cvv/xiU+fixYuKiIhQlSpVZLVa5efnp0cffVQ7d+6U9E+c8O233+r48ePm90VGPyBlpEqVKtq/f79iY2PNfdNjjozmlEqP2fbs2aOWLVuqRIkSql69ujmPY2xsrBo3biw3NzfVqFFDa9assTvmX3/9paefflply5aV1WrV/fffr08++cSh/krZx16OxJ/ZXbMrV64oMjJS9913n1xdXVW+fHl169ZNR44cseuPI5/zr7/+qh49esjX11eurq566KGH9PXXX9vUuXbtmsaPH697771Xrq6uKlWqlJo3b24To2fEkf0yitVSUlI0YsQIlSlTRp6enurcubNOnDiR4TFu5TPLrn+hoaGaPn26JNlMESHZxrJTp041r/OBAwccvq4XLlzQqFGjVLduXXl4eMjLy0vt27fX7t27beql3++LFy/W+PHjdc8998jT01M9evRQQkKCUlJSFBERIT8/P3l4eGjgwIF2sdTq1avVvHlz+fj4yMPDQzVq1NDYsWNt6jg7OysoKEjLly936Prh7nZ3pIqBW1SlShU1adJEn332mdq3by9J+u6775SQkKA+ffro/ffft9tn6NChmjt3rgYOHKjhw4fr6NGjmjZtmv73v/9p8+bNcnZ2lvRPssXDw0MjR46Uh4eH1q1bp9dff12JiYmaMmWKTZt///232rVrp27duqlXr15aunSpRo8erbp165r9ysq1a9cyHNXl7u4uNzc3+fn5aebMmerZs6c++OADDR8+XGlpaQoNDZWnp6dmzJgh6Z+EW+fOnbVp0yYNGTJEtWrV0t69e/Xee+/pt99+s5nfZ/z48YqMjFTTpk01YcIEubi4aNu2bVq3bp1CQkIc/gwCAwM1fPhwvf/++xo7dqxq1aolSeb/3uzy5csKCgrS4cOHFR4eroCAAC1ZskShoaGKj4/Xv/71L5v6MTExunjxooYOHSqLxaK33npL3bp10++//25+Vvnhhx9+0Ndff62wsDBJUlRUlDp16qSXXnpJM2bM0PPPP6+///5bb731lp5++mmtW7fO3HfdunVq3769GjZsqHHjxsnJyUnR0dFq3bq1fvjhBz388MPZHv/f//63LBaLRo8erTNnzmjq1Klq06aNdu3aJTc3Nz311FOaMGGCFi1aZDPnU3pStnv37g79QhwYGKgKFSooJibG/MVr0aJF8vDwUMeOHe3qO3qPzZ8/X88884wefvhhDRkyRJLshnn36tVLAQEBioqK0s6dO/XRRx/Jz89PkydPNus888wzmjdvnnr06KEXXnhB27ZtU1RUlH755RctW7bMrPf666/rjTfeUIcOHdShQwft3LlTISEhunr1arbXAACKmh9//FGS9OCDD2a43ZHv3jVr1qh9+/aqWrWqIiMjdfnyZX3wwQdq1qyZdu7caSZJnn32WS1dulTh4eGqXbu2zp8/r02bNumXX37Rgw8+qFdeeUUJCQk6ceKE3nvvPUmSh4eHQ+cxdepUDRs2TB4eHnrllVckSWXLls1yn7///ludOnVSnz591LNnT82cOVN9+vTRwoULFRERoWeffVb9+vXTlClT1KNHD/3555/y9PSUJJ0+fVqPPPKI+eNVmTJl9N1332nQoEFKTEzM9lE6R2IvR+LPrK5ZamqqOnXqpLVr16pPnz7617/+pYsXL2r16tXat2+fzXexI5/z/v371axZM91zzz16+eWX5e7ursWLF6tLly764osv1LVrV0n/JI6ioqLM7/7ExET9/PPP2rlzpx599NFMr0lu93vmmWe0YMEC9evXT02bNtW6desyjFtu9TPLrn9Dhw7VyZMntXr1as2fPz/DNqKjo3XlyhUNGTJEVqtVvr6+Dl/X33//XV999ZV69uypgIAAnT59WrNnz1bLli114MABu6k+oqKi5ObmppdfflmHDx/WBx98IGdnZzk5Oenvv/9WZGSktm7dqrlz5yogIMCcH2r//v3q1KmT6tWrpwkTJshqterw4cMZ/qDasGFDLV++XImJifLy8sry+uEuZwBFWHR0tCHJ2L59uzFt2jTD09PTSE5ONgzDMHr27Gm0atXKMAzDqFy5stGxY0dzvx9++MGQZCxcuNCmvZUrV9qVp7d3o6FDhxolSpQwrly5Ypa1bNnSkGR8+umnZllKSopRrlw5o3v37tmeS+XKlQ1JGb6ioqJs6vbt29coUaKE8dtvvxlTpkwxJBlfffWVuX3+/PmGk5OT8cMPP9jsN2vWLEOSsXnzZsMwDOPQoUOGk5OT0bVrVyM1NdWmblpamvm3JGPcuHEZ9nnAgAHm+yVLlhiSjPXr19vVbdmypdGyZUvz/dSpUw1JxoIFC8yyq1evGk2aNDE8PDyMxMREwzAM4+jRo4Yko1SpUsaFCxfMusuXLzckGd98843dsTKTfq2OHj1qt23cuHHGzf9JlWRYrVab+rNnzzYkGeXKlTP7aBiGMWbMGJu209LSjHvvvddo27atzbVMTk42AgICjEcffTTLvq5fv96QZNxzzz02x1m8eLEhyfjPf/5jljVp0sRo3Lixzf5ffvllpp9FRud99uxZY9SoUUb16tXNbY0aNTIGDhxoXouwsDBzm6P3mGEYhru7u819cvOxn376aZvyrl27GqVKlTLf79q1y5BkPPPMMzb1Ro0aZUgy1q1bZxiGYZw5c8ZwcXExOnbsaHPNx44da0jKsA8AUJS9+uqrhiTj4sWLNuU5+e6tX7++4efnZ5w/f94s2717t+Hk5GT079/fLPP29rb5HslIx44djcqVK+fqXO6//36bOCNd+vfpjd+H6TFbTEyMWfbrr78akgwnJydj69atZvmqVasMSUZ0dLRZNmjQIKN8+fLGuXPnbI7Vp08fw9vbO8PYMZ2jsZej8Wdm1+yTTz4xJBnvvvuu3bb04+Tkcw4ODjbq1q1rc+y0tDSjadOmxr333muWPfDAAzYxt6Mc2e/mWC09Pnj++edt6vXr188udr2Vz8zR/oWFhdnFkobxf9fZy8vLOHPmjM02R6/rlStX7O6Xo0ePGlar1ZgwYYJZln6/16lTx7h69apZ3rdvX8NisRjt27e3aaNJkyY29897771nxoXZiYmJMSQZ27Zty7Yu7m48vgf8f7169dLly5e1YsUKXbx4UStWrMj0saMlS5bI29tbjz76qM6dO2e+GjZsKA8PD61fv96s6+bmZv598eJFnTt3Ti1atFBycrLNo07SP79O3TgnlIuLix5++GH9/vvvDp1D48aNtXr1arvXzZOPTps2Td7e3urRo4dee+01PfXUU3r88cdtzq9WrVqqWbOmzfm1bt1akszz++qrr5SWlqbXX3/dbsUdR5fcza3//ve/KleunM25OTs7a/jw4bp06ZJiY2Nt6vfu3VslS5Y037do0UKSHL62uRUcHGwzFL5x48aSpO7du5u/mN5Ynt6fXbt26dChQ+rXr5/Onz9vfgZJSUkKDg7Wxo0bzaW3s9K/f3+b4/To0UPly5fXf//7X5s627ZtsxmOv3DhQlWsWFEtW7Z0+Fz79eunw4cPa/v27eb/ZvX/IUfuMUc8++yzNu9btGih8+fPKzExUZLMcx05cqRNvfRFAb799ltJ//xaf/XqVQ0bNszm/i0Kk78CQG6cP39exYsXz3REUnbfvadOndKuXbsUGhoqX19fs169evX06KOP2nxX+fj4aNu2bTp58mR+nEqOeXh4qE+fPub7GjVqyMfHR7Vq1TK/0yX773fDMPTFF1/osccek2EYNt+Bbdu2VUJCgvlIYkYcjb1yEn9m5IsvvlDp0qU1bNgwu203x3jZfc4XLlzQunXr1KtXL7Mv586d0/nz59W2bVsdOnRIf/31l6R/Puf9+/fr0KFD2fbxRrnZL/3+Gj58uE35zd/7t/qZ5bZ/N+vevbvKlCljvs/JdbVareb9kpqaqvPnz5uP1mXU9/79+9s8SdC4cWMZhqGnn37apl7jxo31559/6vr16+Z5Sv88PppdnJp+z9wpc/ci//D4HvD/lSlTRm3atFFMTIySk5OVmpqqHj16ZFj30KFDSkhIkJ+fX4bbz5w5Y/69f/9+vfrqq1q3bp35j+R0CQkJNu8rVKhg90VfsmRJ7dmzx6FzKF26dJbzOqTz9fXV+++/r549e6ps2bJ2jyceOnRIv/zyi80X343Sz+/IkSNycnJS7dq1HepfXjp+/Ljuvfdeu4As/XG/48eP25RXqlTJ5n36F+HNc4DltZuP6+3tLUmqWLFihuXp/UkPWgYMGJBp2wkJCTZBYEbuvfdem/cWi0XVq1e3mb+qd+/eioiI0MKFC/X6668rISFBK1as0IgRI3KUXGzQoIFq1qypmJgY+fj4qFy5cmaS6WaO3mOOyOqz9fLy0vHjx+Xk5KTq1avb1CtXrpx8fHzMeyX9f2++ZmXKlMn2OgMA7GX33Zv+390aNWrY7VurVi2tWrVKSUlJcnd311tvvaUBAwaoYsWKatiwoTp06KD+/furatWq+XwWGcsoZvP29s72+/3s2bOKj4/XnDlzNGfOnAzbzuo70NHYKyfxZ2bHqVGjhkMTg2f3OR8+fFiGYei1117Ta6+9lmEbZ86c0T333KMJEybo8ccf13333ac6deqoXbt2euqpp1SvXr0s+5Cb/dLjg5unBbj5fszJZxYXF2dT7u3tLTc3t1yf140CAgJs3ufkuqalpek///mPZsyYoaNHj9rMLVaqVCm7/XISv6alpSkhIUGlSpVS79699dFHH+mZZ57Ryy+/rODgYHXr1k09evSwi9mN/z+/bX7/kI3bH0kp4Ab9+vXT4MGDFRcXp/bt25vZ/pulpaXJz89PCxcuzHB7+j+04+Pj1bJlS3l5eWnChAmqVq2aXF1dtXPnTo0ePdruF4RixYpl2J5xw6TkeWXVqlWS/gkYTpw4YXOuaWlpqlu3rt59990M9735Cym3bp7sPT8V5LV15LjZ9Sf93pgyZYrq16+fYV1H58rITsmSJdWpUyczKbV06VKlpKTkaiXHfv36aebMmfL09FTv3r3tApB0eXmPOfrZEvQAQN4qVaqUrl+/rosXL9qMyk2Xl9+9vXr1UosWLbRs2TJ9//33mjJliiZPnqwvv/zSoXk389qtfr8/+eSTmf7wlJNERUZyGn/eKkfPedSoUWrbtm2GddN/OAoMDNSRI0e0fPlyff/99/roo4/03nvvadasWXrmmWcy7UNu93NETj6z8uXL25RHR0crNDQ0T/p34+i3G/vlyHWdNGmSXnvtNT399NOaOHGifH195eTkpIiIiAzvh9ze325ubtq4caPWr1+vb7/9VitXrtSiRYvUunVrff/99zb7pyctS5cundVpowggKQXcoGvXrho6dKi2bt2qRYsWZVqvWrVqWrNmjZo1a2b3BXGjDRs26Pz58/ryyy8VGBholh89ejRP+51TK1eu1EcffaSXXnpJCxcu1IABA7Rt2zbz17Bq1app9+7dCg4OzvIf8tWqVVNaWpoOHDiQaeJE+ifpER8fb1N29epVnTp1yqYsJ0mDypUra8+ePUpLS7NJfKQPSa9cubLDbd2O0n+18/Lycmj0W2ZuHiZuGIYOHz5sF/D2799fjz/+uLZv366FCxeqQYMGuv/++3N8vH79+un111/XqVOnMp2oU3L8HpNuPZlUuXJlpaWl6dChQzYT558+fVrx8fHmvZL+v4cOHbL55f3s2bP5PqIOAO5ENWvWlPRPXJObREr6f3cPHjxot+3XX39V6dKl5e7ubpaVL19ezz//vJ5//nmdOXNGDz74oP7973+bSalb+b4oqB8u0ld5S01NzdX3uyOxV07iz8zOu1q1atq2bZuuXbt2ywvCpH+nOjs7Ozyif+DAgRo4cKAuXbqkwMBARUZGZpu8yel+6fFB+qiwdDffjzn5zG5eJfDGWCq7/uX0HszJdV26dKlatWqljz/+2KY8Pj4+z5NCTk5OCg4OVnBwsN59911NmjRJr7zyitavX2/Tz6NHj8rJyUn33Xdfnh4fdx7mlAJu4OHhoZkzZyoyMlKPPfZYpvV69eql1NRUTZw40W7b9evXzQRM+q8BN/4iePXqVXOVu8IQHx9vrvwxadIkffTRR9q5c6cmTZpk1unVq5f++usvffjhh3b7X758WUlJSZKkLl26yMnJSRMmTLD7leXGc65WrZo2btxos33OnDl2I6XSA8+bE1gZ6dChg+Li4mySh9evX9cHH3wgDw+PHM2FdDtq2LChqlWrprfffluXLl2y23727FmH2vn000918eJF8/3SpUt16tQpu1+V27dvr9KlS2vy5MmKjY3N1Sgp6Z/PeurUqYqKispydUBH7zHpn/vCkXsiMx06dJD0z+pKN0ofpZW+yk6bNm3k7OysDz74wOb+vXk/AMA/mjRpIkn6+eefc7V/+fLlVb9+fc2bN8/mv/P79u3T999/b/73OzU11e6RMz8/P/n7+9ssR+/u7u7Qo2kZudXvGkcVK1ZM3bt31xdffKF9+/bZbc/u+92R2Csn8Wdm16x79+46d+6cpk2bZrctpyPd/Pz8FBQUpNmzZ9v9ICnZnvP58+dttnl4eKh69eo2n3NGcrNfeix08zQWN3/v5+Qza9Omjc0rfeSUI/3LSRws5ey6FitWzO5zW7JkiTnnVF65cOGCXVl68vTmz2LHjh26//77zUcDUXQxUgq4SVZz+KRr2bKlhg4dqqioKO3atUshISFydnbWoUOHtGTJEv3nP/9Rjx491LRpU5UsWVIDBgzQ8OHDZbFYNH/+/Hx7ZOyvv/7SggUL7Mo9PDzUpUsXSdK//vUvnT9/XmvWrFGxYsXUrl07PfPMM3rjjTf0+OOP64EHHtBTTz2lxYsX69lnn9X69evVrFkzpaam6tdff9XixYu1atUqPfTQQ6pevbpeeeUVTZw4US1atFC3bt1ktVq1fft2+fv7KyoqStI/y+0+++yz6t69ux599FHt3r1bq1atsvtlpn79+ipWrJgmT56shIQEWa1WtW7dOsO5u4YMGaLZs2crNDRUO3bsUJUqVbR06VJt3rxZU6dOzfAxgjuJk5OTPvroI7Vv317333+/Bg4cqHvuuUd//fWX1q9fLy8vL33zzTfZtuPr66vmzZtr4MCBOn36tKZOnarq1atr8ODBNvWcnZ3Vp08fTZs2TcWKFbObHD8n/vWvf2Vbx9F7TPonQbdmzRq9++678vf3V0BAgM0kstl54IEHNGDAAM2ZM8d8pOGnn37SvHnz1KVLF7Vq1UrSP7+Ejho1SlFRUerUqZM6dOig//3vf/ruu+8YWg4AGahatarq1KmjNWvW2E2A7KgpU6aoffv2atKkiQYNGqTLly/rgw8+kLe3tyIjIyX9M1F3hQoV1KNHDz3wwAPy8PDQmjVrtH37dr3zzjtmWw0bNtSiRYs0cuRINWrUSB4eHln+yHijhg0baubMmXrjjTdUvXp1+fn5ZTov4q168803tX79ejVu3FiDBw9W7dq1deHCBe3cuVNr1qzJ8B/26RyJvXISf2Z2zfr3769PP/1UI0eO1E8//aQWLVooKSlJa9as0fPPP2+zQI4jpk+frubNm6tu3boaPHiwqlatqtOnT2vLli06ceKEdu/eLUmqXbu2goKC1LBhQ/n6+urnn3/W0qVLFR4enmX7udmvfv366tu3r2bMmKGEhAQ1bdpUa9eu1eHDh+3q3spn5mj/GjZsKOmfidfbtm2rYsWK2UymnxFHr2unTp00YcIEDRw4UE2bNtXevXu1cOHCPJ+TbcKECdq4caM6duyoypUr68yZM5oxY4YqVKig5s2bm/WuXbum2NhYPf/883l6fNyhCmqZP+B2FB0dbUgytm/fnmW9ypUrZ7iM65w5c4yGDRsabm5uhqenp1G3bl3jpZdeMk6ePGnW2bx5s/HII48Ybm5uhr+/v/HSSy+ZywPfvLzw/fffb3eMAQMGOLS8ceXKlQ1JGb7S909fovedd96x2TcxMdGoXLmy8cADD5jLv169etWYPHmycf/99xtWq9UoWbKk0bBhQ2P8+PFGQkKCzf6ffPKJ0aBBA7Ney5YtjdWrV5vbU1NTjdGjRxulS5c2SpQoYbRt29Y4fPiwUblyZWPAgAE2bX344YdG1apVjWLFitlco5YtW9ot1Xz69Glj4MCBRunSpQ0XFxejbt26NksuG8b/LaM7ZcoUu2umm5b7zc6UKVMMScbRo0fttt28zHB6+zcvX51Zf9KX4F2yZIlN+f/+9z+jW7duRqlSpQyr1WpUrlzZ6NWrl7F27dos+5re3meffWaMGTPG8PPzM9zc3IyOHTsax48fz3Cfn376yZBkhISEZNn2jdLPO7ulfzO6Fo7eY7/++qsRGBhouLm5GZLMeyazY6f///rGz+natWvG+PHjjYCAAMPZ2dmoWLGiMWbMGJsllA3jn3t1/PjxRvny5Q03NzcjKCjI2LdvX4b3KgDAMN59913Dw8PDSE5ONsty+t27Zs0ao1mzZoabm5vh5eVlPPbYY8aBAwfM7SkpKcaLL75oPPDAA4anp6fh7u5uPPDAA8aMGTNs2rl06ZLRr18/w8fHxyb+cURcXJzRsWNHw9PT05Bkxhzp36eOxGyZxYsZfQeePn3aCAsLMypWrGg4Ozsb5cqVM4KDg405c+Y41N/sYi9H48+srllycrLxyiuvmN+d5cqVM3r06GEcOXLEMIycf85Hjhwx+vfvb5QrV85wdnY27rnnHqNTp07G0qVLzTpvvPGG8fDDDxs+Pj6Gm5ubUbNmTePf//63GZ9mxpH9MorVLl++bAwfPtwoVaqU4e7ubjz22GPGn3/+mWH/b+Uzc6R/169fN4YNG2aUKVPGsFgsZl+zus6OXtcrV64YL7zwghnfNGvWzNiyZYtdfJ1ZPJrZv5lujsXWrl1rPP7444a/v7/h4uJi+Pv7G3379jV+++03m/2+++47Q5Jx6NChbK8d7n4Ww8jnWX4BAHeE3bt3q379+vr000/11FNPFXZ3AAB3gISEBFWtWlVvvfWWBg0aVNjdAXAH6NKliywWi5YtW1bYXcFtgKQUAECSFB4ernnz5ikuLs5mYlkAALIyefJkRUdH68CBA5muugoAkvTLL7+obt262rVrl+rUqVPY3cFtgKQUABRx33zzjQ4cOKDXXntN4eHh5gTgAADc6c6ePWu3sMqNXFxc5OvrW4A9AgDciKQUABRxVapU0enTp9W2bVvNnz//jp8kHgCAdFWqVNHx48cz3d6yZUtt2LCh4DoEALBBUgoAAADAXWnz5s26fPlypttLlixprnoGACh4JKUAAAAAAABQ4JiJEAAAAAAAAAWOpBTw/7311luqWbOm0tLSCrsrWTp27JgsFovefvvtwu5KkWGxWBQZGZltvdOnT6tHjx4qVaqULBaLpk6dmu99K0wbNmyQxWLJ1VwcoaGh8vDwcKjuzdd/7ty5slgsOnbsmFkWFBSkoKCgHPcjK4888oheeumlPG0TAIoCYipkhpgqY8RUKMpISgGSEhMTNXnyZI0ePfquX8r4wIEDioyMtPnyuRvExMQUesAyYsQIrVq1SmPGjNH8+fPVrl27Qu1PUXby5ElFRkZq165duW5j9OjRmj59uuLi4vKuYwBwlyOmuvMRU+FGxFTIb8ULuwPA7eCTTz7R9evX1bdv38LuSr47cOCAxo8fr6CgIFWpUqWwu5NnYmJitG/fPkVERBRaH9atW6fHH39co0aNKrQ+3I0uX76s4sWz/rr6/vvvbd6fPHlS48ePV5UqVVS/fv1cHffxxx+Xl5eXZsyYoQkTJuSqDQAoaoip7nzEVHcvYircju7uny8AB0VHR6tz585ydXXNszaTkpLyrK3CYhhGlivWwNaZM2fk4+OTZ+1duXIlR48+XL9+XVevXs2z498uXF1dsw2gXFxc5OLikqfHdXJyUo8ePfTpp5+KNUEAwDHEVBkjpsoZYqr8QUyF2xFJKRR5R48e1Z49e9SmTRu7befPn9dTTz0lLy8v+fj4aMCAAdq9e7csFovmzp1r1kt/lvvIkSPq0KGDPD099cQTT0iSfvjhB/Xs2VOVKlWS1WpVxYoVNWLECLvAJL2N33//XW3btpW7u7v8/f01YcKETP/jPWfOHFWrVk1Wq1WNGjXS9u3bszzXuXPnqmfPnpKkVq1ayWKx2Dy/XqVKFXXq1EmrVq3SQw89JDc3N82ePducc+HGc05387PpkZGRslgsOnz4sEJDQ+Xj4yNvb28NHDhQycnJdvsvWLBADz/8sEqUKKGSJUsqMDDQ5hea5cuXq2PHjvL395fValW1atU0ceJEpaammnWCgoL07bff6vjx4+Y53fiLZUpKisaNG6fq1aubn8FLL72klJQUm76kpKRoxIgRKlOmjDw9PdW5c2edOHEiy2uafl0tFosMw9D06dPNPqT7/fff1bNnT/n6+qpEiRJ65JFH9O2339q0kT6XwOeff65XX31V99xzj0qUKKHExMQMj3njPBhTp04174MDBw5Ikn799Vf16NFDvr6+cnV11UMPPaSvv/7apo0LFy5o1KhRqlu3rjw8POTl5aX27dtr9+7ddsc7ceKEunTpInd3d/n5+WnEiBF2109y/H6/8dpkd787Mv/EjfMfbNiwQY0aNZIkDRw40Pw85s6dq3HjxsnZ2Vlnz561a2PIkCHy8fHRlStXzLJHH31Ux48fv6Uh6wBQVBBTEVPdWI+YipiKmAqO4PE9FHk//vijJOnBBx+0KU9LS9Njjz2mn376Sc8995xq1qyp5cuXa8CAARm2c/36dbVt21bNmzfX22+/rRIlSkiSlixZouTkZD333HMqVaqUfvrpJ33wwQc6ceKElixZYtNGamqq2rVrp0ceeURvvfWWVq5cqXHjxun69et2Q11jYmJ08eJFDR06VBaLRW+99Za6deum33//Xc7Ozhn2MTAwUMOHD9f777+vsWPHqlatWpJk/q8kHTx4UH379tXQoUM1ePBg1ahRIwdX8//06tVLAQEBioqK0s6dO/XRRx/Jz89PkydPNuuMHz9ekZGRatq0qSZMmCAXFxdt27ZN69atU0hIiKR/ghMPDw+NHDlSHh4eWrdunV5//XUlJiZqypQpkqRXXnlFCQkJOnHihN577z1JMid8TEtLU+fOnbVp0yYNGTJEtWrV0t69e/Xee+/pt99+01dffWX255lnntGCBQvUr18/NW3aVOvWrVPHjh2zPdfAwEDNnz9fTz31lB599FH179/f3Hb69Gk1bdpUycnJGj58uEqVKqV58+apc+fOWrp0qbp27WrT1sSJE+Xi4qJRo0YpJSUl21+qoqOjdeXKFQ0ZMkRWq1W+vr7av3+/mjVrpnvuuUcvv/yy3N3dtXjxYnXp0kVffPGFeczff/9dX331lXr27KmAgACdPn1as2fPVsuWLXXgwAH5+/tL+meod3BwsP744w8NHz5c/v7+mj9/vtatW2fXn/y633OiVq1amjBhgl5//XUNGTJELVq0kCQ1bdpUzZs314QJE7Ro0SKFh4eb+1y9elVLly5V9+7dbX7db9iwoSRp8+bNatCgQa77BABFATEVMVU6YipiKmIqOMwAirhXX33VkGRcvHjRpvyLL74wJBlTp041y1JTU43WrVsbkozo6GizfMCAAYYk4+WXX7ZrPzk52a4sKirKsFgsxvHjx+3aGDZsmFmWlpZmdOzY0XBxcTHOnj1rGIZhHD161JBklCpVyrhw4YJZd/ny5YYk45tvvsnyfJcsWWJIMtavX2+3rXLlyoYkY+XKlTbl6ce88ZzTSTLGjRtnvh83bpwhyXj66adt6nXt2tUoVaqU+f7QoUOGk5OT0bVrVyM1NdWmblpamvl3Rtdv6NChRokSJYwrV66YZR07djQqV65sV3f+/PmGk5OT8cMPP9iUz5o1y5BkbN682TAMw9i1a5chyXj++edt6vXr18/uHDMjyQgLC7Mpi4iIMCTZHP/ixYtGQECAUaVKFfPc169fb0gyqlatmuE53yz9M/Hy8jLOnDljsy04ONioW7euzfVJS0szmjZtatx7771m2ZUrV+yu/dGjRw2r1WpMmDDBLJs6daohyVi8eLFZlpSUZFSvXt3uXsrr+90w7O+x6OhoQ5Jx9OhRs6xly5ZGy5Ytzffbt2/P9J5t0qSJ0bhxY5uyL7/8MtP/X7i4uBjPPfecXTkAwBYx1f8hpiKmIqZab1efmAoZ4fE9FHnnz59X8eLF7ZZSXblypZydnTV48GCzzMnJSWFhYZm29dxzz9mVubm5mX8nJSXp3Llzatq0qQzD0P/+9z+7+jf+0mCxWBQeHq6rV69qzZo1NvV69+6tkiVLmu/Tf7n4/fffM+2fIwICAtS2bdtbakOSnn32WZv3LVq00Pnz582h01999ZXS0tL0+uuv263Oc+Mw7Ruv38WLF3Xu3Dm1aNFCycnJ+vXXX7Ptx5IlS1SrVi3VrFlT586dM1+tW7eWJK1fv16S9N///leSNHz4cJv9b3WSz//+9796+OGH1bx5c7PMw8NDQ4YM0bFjx8yh4ekGDBhgc87Z6d69u8qUKWO+v3DhgtatW6devXqZ1+vcuXM6f/682rZtq0OHDumvv/6SJFmtVvPap6am6vz58/Lw8FCNGjW0c+dOm3MoX768evToYZaVKFFCQ4YMsetPft3veal///7atm2bjhw5YpYtXLhQFStWVMuWLe3qlyxZUufOncu3/gDA3YKYyhYxFTEVMZUtYipkhKQUkInjx4+rfPny5pDxdNWrV8+wfvHixVWhQgW78j/++EOhoaHy9fWVh4eHypQpY/5HOiEhwaauk5OTqlatalN23333SZLdcsOVKlWyeZ8eTP3999/ZnFnWAgICbmn/dNn178iRI3JyclLt2rWzbGf//v3q2rWrvL295eXlpTJlyujJJ5+UZH/9MnLo0CHt379fZcqUsXmlX9czZ85I+ufzdnJyUrVq1Wz2z+1Q+3THjx/PsI304f3Hjx+3Kc/p9b+5/uHDh2UYhl577TW7cx43bpyk/zvntLQ0vffee7r33ntltVpVunRplSlTRnv27LG5tsePH1f16tVtAlsp42uTX/d7Xurdu7esVqsWLlxo9mvFihV64okn7M5R+mdy2ozKAQCOIaa6NcRUMtslpiKmwt2HOaVQ5JUqVUrXr1/XxYsX5enpmet2bvyFJF1qaqoeffRRXbhwQaNHj1bNmjXl7u6uv/76S6GhoTlaBeRmxYoVy7DcuMUVLTL6RSmzL48bJ8a8WV70Lz4+Xi1btpSXl5cmTJigatWqydXVVTt37tTo0aMdun5paWmqW7eu3n333Qy3V6xY0eH+FISc/KKXUf30azJq1KhMf51N/0fApEmT9Nprr+npp5/WxIkT5evrKycnJ0VEROTq3szP+z0vlSxZUp06ddLChQv1+uuva+nSpUpJSTED85vFx8erdOnSBdxLALjzEFPZIqYqXMRU+Y+YCnmBpBSKvJo1a0r6Z8WYevXqmeWVK1fW+vXrlZycbPPL3uHDhx1ue+/evfrtt980b948m4kaV69enWH9tLQ0/f777+YvG5L022+/SZLNyie3Ije/TqT/IhcfH29TfvMvUjlRrVo1paWl6cCBA6pfv36GdTZs2KDz58/ryy+/VGBgoFl+9OhRu7qZnVe1atW0e/duBQcHZ3nulStXVlpamo4cOWLza9XBgwcdPKPM282ojfRh8pUrV76l9m+W/iuZs7Nzhqsf3Wjp0qVq1aqVPv74Y5vymwOGypUra9++fXa/bt18XrfT/Z7dfd6/f389/vjj2r59uxYuXKgGDRro/vvvt6v3119/6erVqzYT1wIAMkZMlT1iqtwjpiKmwt2Jx/dQ5DVp0kSS9PPPP9uUt23bVteuXdOHH35olqWlpWn69OkOt53+y9aNv2QZhqH//Oc/me4zbdo0m7rTpk2Ts7OzgoODHT5uVtzd3SXZB0NZ8fLyUunSpbVx40ab8hkzZuS6H126dJGTk5MmTJhg92tP+vXK6PpdvXo1w+O6u7tnOPS8V69e+uuvv2w+x3SXL19WUlKSJKl9+/aSpPfff9+mztSpU3NwVvY6dOign376SVu2bDHLkpKSNGfOHFWpUiXbofY55efnp6CgIM2ePVunTp2y237jsr3FihWz+5V1yZIl5vwIN57DyZMntXTpUrMsOTlZc+bMsal3O93v2d3n7du3V+nSpTV58mTFxsZm+ovejh07JP2zygwAIGvEVNkjpso9YipiKtydGCmFIq9q1aqqU6eO1qxZo6efftos79Klix5++GG98MILOnz4sGrWrKmvv/5aFy5ckOTYr2M1a9ZUtWrVNGrUKP3111/y8vLSF198kekcBa6urlq5cqUGDBigxo0b67vvvtO3336rsWPH2ky8eCvq16+vYsWKafLkyUpISJDValXr1q3l5+eX5X7PPPOM3nzzTT3zzDN66KGHtHHjRvMXmNyoXr26XnnlFU2cOFEtWrRQt27dZLVatX37dvn7+ysqKkpNmzZVyZIlNWDAAA0fPlwWi0Xz58/PcLh6w4YNtWjRIo0cOVKNGjWSh4eHHnvsMT311FNavHixnn32Wa1fv17NmjVTamqqfv31Vy1evFirVq3SQw89pPr166tv376aMWOGEhIS1LRpU61duzZHv+Jm5OWXX9Znn32m9u3ba/jw4fL19dW8efN09OhRffHFF3aPJ+SF6dOnq3nz5qpbt64GDx6sqlWr6vTp09qyZYtOnDih3bt3S5I6deqkCRMmaODAgWratKn27t2rhQsX2s1JMHjwYE2bNk39+/fXjh07VL58ec2fP99ubpDb6X6vVq2afHx8NGvWLHl6esrd3V2NGzc254twdnZWnz59NG3aNBUrVkx9+/bNsJ3Vq1erUqVKLF0MAA4gpiKmIqYipiKmQo7l9/J+wJ3g3XffNTw8POyWXj179qzRr18/w9PT0/D29jZCQ0ONzZs3G5KMzz//3Kw3YMAAw93dPcO2Dxw4YLRp08bw8PAwSpcubQwePNjYvXt3hksgu7u7G0eOHDFCQkKMEiVKGGXLljXGjRtns8Rs+rK1U6ZMsTuWHFxm98MPPzSqVq1qFCtWzGbJ1sqVKxsdO3bMcJ/k5GRj0KBBhre3t+Hp6Wn06tXLOHPmTKbLF9+4/KxhZLzkrGEYxieffGI0aNDAsFqtRsmSJY2WLVsaq1evNrdv3rzZeOSRRww3NzfD39/feOmll4xVq1bZLTV76dIlo1+/foaPj48hyWYp46tXrxqTJ0827r//fvM4DRs2NMaPH28kJCSY9S5fvmwMHz7cKFWqlOHu7m489thjxp9//nlLyxcbhmEcOXLE6NGjh+Hj42O4uroaDz/8sLFixQqbOunLFy9ZsiTb4xhG1vdB+jH79+9vlCtXznB2djbuueceo1OnTsbSpUvNOleuXDFeeOEFo3z58oabm5vRrFkzY8uWLXZLARuGYRw/ftzo3LmzUaJECaN06dLGv/71L2PlypV2n0Ne3+/p1zWnyxcbxj9LeteuXdsoXrx4hksZ//TTT4YkIyQkJMNrmJqaapQvX9549dVXM9wOALBHTLXeMAxiKmIqYqobEVMhKxbDuMUZ/IC7QEJCgqpWraq33npLgwYNyrLuV199pa5du2rTpk1q1qxZnvUhNDRUS5cu1aVLl/KsTQCZ2717t+rXr69PP/1UTz31lN32r776Sv369dORI0dUvnz5QughANx5iKmAooeYCreCOaUASd7e3nrppZc0ZcoUm2fxL1++bFMvNTVVH3zwgby8vPTggw8WdDcB5KEPP/xQHh4e6tatW4bbJ0+erPDwcIInAMgBYiqg6CGmwq1gTing/xs9erRGjx5tUzZs2DBdvnxZTZo0UUpKir788kv9+OOPmjRpUo6XmQVwe/jmm2904MABzZkzR+Hh4eYEnje7cSJVAIDjiKmAooGYCnmBpBSQhdatW+udd97RihUrdOXKFVWvXl0ffPCBwsPDC7trAHJp2LBhOn36tDp06KDx48cXdncAoEggpgLuPsRUyAuFOqdUVFSUvvzyS/36669yc3NT06ZNNXnyZNWoUcOsM2fOHMXExGjnzp26ePGi/v77b/n4+GTZbpUqVXT8+HG78ueffz5HS88CAAAAAAAgfxTqnFKxsbEKCwvT1q1btXr1al27dk0hISFKSkoy6yQnJ6tdu3YaO3asw+1u375dp06dMl+rV6+WJPXs2TPPzwEAAAAAAAA5d1utvnf27Fn5+fkpNjZWgYGBNts2bNigVq1aOTRS6mYRERFasWKFDh06JIvFYrc9JSVFKSkp5vu0tDRduHBBpUqVyrA+AAC4OxmGoYsXL8rf319OTqwHc6vS0tJ08uRJeXp6ElMBAFCEOBpT3VZzSiUkJEiSfH1986zNq1evasGCBRo5cmSmwVBUVBTPwAIAANOff/6pChUqFHY37ngnT55UxYoVC7sbAACgkGQXU902I6XS0tLUuXNnxcfHa9OmTXbbcztSavHixerXr5/++OMP+fv7Z1jn5pFSCQkJqlSpkv788095eXnl+FwAAMCdKTExURUrVlR8fLy8vb0Luzt3vISEBPn4+BBTAQBQxDgaU902I6XCwsK0b9++DBNSt+Ljjz9W+/btM01ISZLVapXVarUr9/LyIoACAKAI4lGzvJF+HYmpAAAomrKLqW6LpFR4eLhWrFihjRs35ulQ+ePHj2vNmjX68ssv86xNAAAAAAAA3LpCTUoZhqFhw4Zp2bJl2rBhgwICAvK0/ejoaPn5+aljx4552i4AAAAAAABuTaEuKxMWFqYFCxYoJiZGnp6eiouLU1xcnC5fvmzWiYuL065du3T48GFJ0t69e7Vr1y5duHDBrBMcHKxp06bZtJ2Wlqbo6GgNGDBAxYvfFgPCAAAAAAAA8P8ValJq5syZSkhIUFBQkMqXL2++Fi1aZNaZNWuWGjRooMGDB0uSAgMD1aBBA3399ddmnSNHjujcuXM2ba9Zs0Z//PGHnn766YI5GQAAAAAAADjstll973aSmJgob29vJSQkMCknAABFCDFA3uJ6AgBQNDkaAxTqSCkAAABkLSoqSo0aNZKnp6f8/PzUpUsXHTx40Nx+4cIFDRs2TDVq1JCbm5sqVaqk4cOHKyEhIct2Q0NDZbFYbF7t2rWzqXPhwgU98cQT8vLyko+PjwYNGqRLly7ly3kCAICih6QUAADAbSw2NlZhYWHaunWrVq9erWvXrikkJERJSUmSpJMnT+rkyZN6++23tW/fPs2dO1crV67UoEGDsm27Xbt2OnXqlPn67LPPbLY/8cQT2r9/v1avXm2ulDxkyJB8OU8AAFD08PheBhhqDgBA0XQnxABnz56Vn5+fYmNjFRgYmGGdJUuW6Mknn1RSUlKmC76EhoYqPj5eX331VYbbf/nlF9WuXVvbt2/XQw89JElauXKlOnTooBMnTsjf399un5SUFKWkpJjvExMTVbFixdv6egIAgLzH43sAAAB3ofTH8nx9fbOs4+Xlle0KxBs2bJCfn59q1Kih5557TufPnze3bdmyRT4+PmZCSpLatGkjJycnbdu2LcP2oqKi5O3tbb4qVqyYk1MDAABFDEkpAACAO0RaWpoiIiLUrFkz1alTJ8M6586d08SJE7N9zK5du3b69NNPtXbtWk2ePFmxsbFq3769UlNTJUlxcXHy8/Oz2ad48eLy9fVVXFxchm2OGTNGCQkJ5uvPP//MxVkCAICiIuufzwAAAHDbCAsL0759+7Rp06YMtycmJqpjx46qXbu2IiMjs2yrT58+5t9169ZVvXr1VK1aNW3YsEHBwcG56p/VapXVas3VvgAAoOhhpBQAAMAdIDw8XCtWrND69etVoUIFu+0XL15Uu3bt5OnpqWXLlsnZ2TlH7VetWlWlS5fW4cOHJUnlypXTmTNnbOpcv35dFy5cULly5XJ/IgAAAP8fSSkAAIDbmGEYCg8P17Jly7Ru3ToFBATY1UlMTFRISIhcXFz09ddfy9XVNcfHOXHihM6fP6/y5ctLkpo0aaL4+Hjt2LHDrLNu3TqlpaWpcePGuT8hAACA/4+kFAAAwG0sLCxMCxYsUExMjDw9PRUXF6e4uDhdvnxZ0v8lpJKSkvTxxx8rMTHRrJM+P5Qk1axZU8uWLZMkXbp0SS+++KK2bt2qY8eOae3atXr88cdVvXp1tW3bVpJUq1YttWvXToMHD9ZPP/2kzZs3Kzw8XH369Mlw5T0AAICcYk4pAACA29jMmTMlSUFBQTbl0dHRCg0N1c6dO83V8KpXr25T5+jRo6pSpYok6eDBg+bKfcWKFdOePXs0b948xcfHy9/fXyEhIZo4caLNnFALFy5UeHi4goOD5eTkpO7du+v999/PpzMFAABFjcUwDKOwO3G7SUxMlLe3t7mcMgAAKBqIAfIW1xMAgKLJ0RiAx/cAAAAAAABQ4EhKAQAAAAAAoMCRlAIAAAAAAECBIykFAAAAAACAAkdSCgAAAAAAAAWOpBQAAAAAAAAKHEkpAAAAAAAAFDiSUgAAAAAAAChwJKUAAAAAAABQ4EhKAQAAAAAAoMCRlAIAAAAAAECBIykFAAAAAACAAkdSCgAAAAAAAAWOpBQAAAAAAAAKHEkpAAAAAAAAFDiSUgAAAAAAAChwJKUAAAAAAABQ4EhKAQAAAAAAoMCRlAIAAAAAAECBIykFAAAAAACAAkdSCgAAAAAAAAWOpBQAAAAAAAAKHEkpAAAAAAAAFDiSUgAAAAAAAChwJKUAAAAAAABQ4EhKAQAA3MaioqLUqFEjeXp6ys/PT126dNHBgwfN7RcuXNCwYcNUo0YNubm5qVKlSho+fLgSEhIybfPatWsaPXq06tatK3d3d/n7+6t///46efKkTb0qVarIYrHYvN588818O1cAAFC0kJQCAAC4jcXGxiosLExbt27V6tWrde3aNYWEhCgpKUmSdPLkSZ08eVJvv/229u3bp7lz52rlypUaNGhQpm0mJydr586deu2117Rz5059+eWXOnjwoDp37mxXd8KECTp16pT5GjZsWL6dKwAAKFoshmEYhd2J201iYqK8vb2VkJAgLy+vwu4OAAAoIHdCDHD27Fn5+fkpNjZWgYGBGdZZsmSJnnzySSUlJal48eIOtbt9+3Y9/PDDOn78uCpVqiTpn5FSERERioiIyFVf74TrCQAA8p6jMQAjpQAAAO4g6Y/l+fr6ZlnHy8vL4YRU+j4Wi0U+Pj425W+++aZKlSqlBg0aaMqUKbp+/XqmbaSkpCgxMdHmBQAAkBnHIxUAAAAUqrS0NEVERKhZs2aqU6dOhnXOnTuniRMnasiQIQ63e+XKFY0ePVp9+/a1+TVz+PDhevDBB+Xr66sff/xRY8aM0alTp/Tuu+9m2E5UVJTGjx+fs5MCAABFFo/vZYCh5gAAFE23ewzw3HPP6bvvvtOmTZtUoUIFu+2JiYl69NFH5evrq6+//lrOzs7Ztnnt2jV1795dJ06c0IYNG7I8708++URDhw7VpUuXZLVa7banpKQoJSXFpj8VK1a8ba8nAADIH47GVIyUAgAAuAOEh4drxYoV2rhxY4YJqYsXL6pdu3by9PTUsmXLHE5I9erVS8ePH9e6deuyTRw1btxY169f17Fjx1SjRg277VarNcNkFQAAQEZISgEAANzGDMPQsGHDtGzZMm3YsEEBAQF2dRITE9W2bVtZrVZ9/fXXcnV1zbbd9ITUoUOHtH79epUqVSrbfXbt2iUnJyf5+fnl6lwAAABuRFIKAADgNhYWFqaYmBgtX75cnp6eiouLkyR5e3vLzc1NiYmJCgkJUXJyshYsWGAzwXiZMmVUrFgxSVLNmjUVFRWlrl276tq1a+rRo4d27typFStWKDU11WzX19dXLi4u2rJli7Zt26ZWrVrJ09NTW7Zs0YgRI/Tkk0+qZMmShXMxAADAXYWkFAAAwG1s5syZkqSgoCCb8ujoaIWGhmrnzp3atm2bJKl69eo2dY4ePaoqVapIkg4ePGiu3PfXX3/p66+/liTVr1/fZp/169crKChIVqtVn3/+uSIjI5WSkqKAgACNGDFCI0eOzOMzBAAARRVJKQAAgNtYdmvSBAUFZVvn5naqVKmS7T4PPvigtm7d6lgnAQAAcsGpsDsAAAAAAACAooekFAAAAAAAAAocSSkAAAAAAAAUOJJSAAAAAAAAKHCFmpSKiopSo0aN5OnpKT8/P3Xp0kUHDx60qTNnzhwFBQXJy8tLFotF8fHxDrX9119/6cknn1SpUqXk5uamunXr6ueff86HswAAAAAAAEBOFWpSKjY2VmFhYdq6datWr16ta9euKSQkRElJSWad5ORktWvXTmPHjnW43b///lvNmjWTs7OzvvvuOx04cEDvvPOOSpYsmR+nAQAAAAAAgBwqXpgHX7lypc37uXPnys/PTzt27FBgYKAkKSIiQpK0YcMGh9udPHmyKlasqOjoaLMsICDglvsLAAAAAACAvHFbzSmVkJAgSfL19b2ldr7++ms99NBD6tmzp/z8/NSgQQN9+OGHmdZPSUlRYmKizQsAAAAAAAD557ZJSqWlpSkiIkLNmjVTnTp1bqmt33//XTNnztS9996rVatW6bnnntPw4cM1b968DOtHRUXJ29vbfFWsWPGWjg8AAAAAAICsFerjezcKCwvTvn37tGnTpltuKy0tTQ899JAmTZokSWrQoIH27dunWbNmacCAAXb1x4wZo5EjR5rvExMTSUwBAAAAAADko9tipFR4eLhWrFih9evXq0KFCrfcXvny5VW7dm2bslq1aumPP/7IsL7VapWXl5fNCwAAAAAAAPmnUEdKGYahYcOGadmyZdqwYUOeTUberFkzHTx40Kbst99+U+XKlfOkfQAAAAAAANyaQh0pFRYWpgULFigmJkaenp6Ki4tTXFycLl++bNaJi4vTrl27dPjwYUnS3r17tWvXLl24cMGsExwcrGnTppnvR4wYoa1bt2rSpEk6fPiwYmJiNGfOHIWFhRXcyQEAAAAAACBThZqUmjlzphISEhQUFKTy5cubr0WLFpl1Zs2apQYNGmjw4MGSpMDAQDVo0EBff/21WefIkSM6d+6c+b5Ro0ZatmyZPvvsM9WpU0cTJ07U1KlT9cQTTxTcyQEAAAAAACBTFsMwjMLuxO0mMTFR3t7eSkhIYH4pAACKEGKAvMX1BACgaHI0BrgtJjoHAAAAAABA0UJSCgAAAAAAAAWOpBQAAAAAAAAKHEkpAAAAAAAAFDiSUgAAAAAAAChwJKUAAAAAAABQ4EhKAQAAAAAAoMCRlAIAAAAAAECBIykFAAAAAACAAkdSCgAAAAAAAAWOpBQAAMBtLCoqSo0aNZKnp6f8/PzUpUsXHTx40Nx+4cIFDRs2TDVq1JCbm5sqVaqk4cOHKyEhIct2DcPQ66+/rvLly8vNzU1t2rTRoUOHbOpcuHBBTzzxhLy8vOTj46NBgwbp0qVL+XKeAACg6CEpBQAAcBuLjY1VWFiYtm7dqtWrV+vatWsKCQlRUlKSJOnkyZM6efKk3n77be3bt09z587VypUrNWjQoCzbfeutt/T+++9r1qxZ2rZtm9zd3dW2bVtduXLFrPPEE09o//79Wr16tVasWKGNGzdqyJAh+Xq+AACg6LAYhmEUdiduN4mJifL29lZCQoK8vLwKuzsAAKCA3AkxwNmzZ+Xn56fY2FgFBgZmWGfJkiV68sknlZSUpOLFi9ttNwxD/v7+euGFFzRq1ChJUkJCgsqWLau5c+eqT58++uWXX1S7dm1t375dDz30kCRp5cqV6tChg06cOCF/f/9s+3onXE8AAJD3HI0BGCkFAABwB0l/LM/X1zfLOl5eXhkmpCTp6NGjiouLU5s2bcwyb29vNW7cWFu2bJEkbdmyRT4+PmZCSpLatGkjJycnbdu2LcN2U1JSlJiYaPMCAADIDEkpAACAO0RaWpoiIiLUrFkz1alTJ8M6586d08SJE7N8zC4uLk6SVLZsWZvysmXLmtvi4uLk5+dns7148eLy9fU169wsKipK3t7e5qtixYoOnxsAACh6SEoBAADcIcLCwrRv3z59/vnnGW5PTExUx44dVbt2bUVGRhZs5ySNGTNGCQkJ5uvPP/8s8D4AAIA7R8ZjugEAAHBbCQ8PNycbr1Chgt32ixcvql27dvL09NSyZcvk7OycaVvlypWTJJ0+fVrly5c3y0+fPq369eubdc6cOWOz3/Xr13XhwgVz/5tZrVZZrdacnhoAACiiGCkFAABwGzMMQ+Hh4Vq2bJnWrVungIAAuzqJiYkKCQmRi4uLvv76a7m6umbZZkBAgMqVK6e1a9fatLFt2zY1adJEktSkSRPFx8drx44dZp1169YpLS1NjRs3zqOzAwAARRlJKQAAgNtYWFiYFixYoJiYGHl6eiouLk5xcXG6fPmypP9LSCUlJenjjz9WYmKiWSc1NdVsp2bNmlq2bJkkyWKxKCIiQm+88Ya+/vpr7d27V/3795e/v7+6dOkiSapVq5batWunwYMH66efftLmzZsVHh6uPn36OLTyHgAAQHZ4fA9ZOnXqlE6dOpXj/cqXL2/zOAAAAMidmTNnSpKCgoJsyqOjoxUaGqqdO3eaq+FVr17dps7Ro0dVpUoVSdLBgwfNlfsk6aWXXlJSUpKGDBmi+Ph4NW/eXCtXrrQZZbVw4UKFh4crODhYTk5O6t69u95///18OEsAAFAUWQzDMAq7E7ebxMREeXt7m8spF2WRkZEaP358jvcbN25coUywCgDArSAGyFtcTwAAiiZHYwBGSiFLQ4cOVefOnW3KLl++rObNm0uSNm3aJDc3N7v9GCUFAAAAAACyQlIKWcroMbykpCTz7/r168vd3b2guwUAAAAAAO5wTHQOAAAAAACAAkdSCgAAAAAAAAWOpBQAAAAAAAAKHEkpAAAAAAAAFDiSUgAAAAAAAChwrL4HQKdOndKpU6dyvF9GqzMCAAAAAOAIklIANHv2bI0fPz7H+40bN06RkZF53yEAAAAAwF2PpBQADR06VJ07d7Ypu3z5spo3by5J2rRpk9zc3Oz2Y5QUAAAAACC3SEoByPAxvKSkJPPv+vXry93dvaC7BQAAAAC4izHROQAAAAAAAAocSSkAAAAAAAAUOJJSAAAAAAAAKHAkpQAAAAAAAFDgSEoBAAAAAACgwJGUAgAAAAAAQIEjKQUAAAAAAIACR1IKAAAAAAAABY6kFAAAAAAAAAocSSkAAAAAAAAUOJJSAAAAAAAAKHAkpQAAAAAAAFDgSEoBAAAAAACgwJGUAgAAAAAAQIEjKQUAAAAAAIACR1IKAADgNhYVFaVGjRrJ09NTfn5+6tKliw4ePGhTZ86cOQoKCpKXl5csFovi4+OzbbdKlSqyWCx2r7CwMLNOUFCQ3fZnn302r08RAAAUUSSlAAAAbmOxsbEKCwvT1q1btXr1al27dk0hISFKSkoy6yQnJ6tdu3YaO3asw+1u375dp06dMl+rV6+WJPXs2dOm3uDBg23qvfXWW3lzYgAAoMgrXtgdAAAAQOZWrlxp837u3Lny8/PTjh07FBgYKEmKiIiQJG3YsMHhdsuUKWPz/s0331S1atXUsmVLm/ISJUqoXLlyDrWZkpKilJQU831iYqLD/QEAAEUPI6UAAADuIAkJCZIkX1/fPGvz6tWrWrBggZ5++mlZLBabbQsXLlTp0qVVp04djRkzRsnJyZm2ExUVJW9vb/NVsWLFPOsjAAC4+zBSCgAA4A6RlpamiIgINWvWTHXq1Mmzdr/66ivFx8crNDTUprxfv36qXLmy/P39tWfPHo0ePVoHDx7Ul19+mWE7Y8aM0ciRI833iYmJJKYAAECmCnWkVH5N3BkZGWk3KWfNmjXz6SwAAAAKRlhYmPbt26fPP/88T9v9+OOP1b59e/n7+9uUDxkyRG3btlXdunX1xBNP6NNPP9WyZct05MiRDNuxWq3y8vKyeQEAAGSmUJNS+TVxpyTdf//9NpNybtq0Ka+7DwAAUGDCw8O1YsUKrV+/XhUqVMizdo8fP641a9bomWeeybZu48aNJUmHDx/Os+MDAICiq1Af38uviTslqXjx4kzKCQAA7niGYWjYsGFatmyZNmzYoICAgDxtPzo6Wn5+furYsWO2dXft2iVJKl++fJ72AQAAFE05TkqlpaUpNjZWP/zwg44fP67k5GSVKVNGDRo0UJs2bW5p3oC8nLjz0KFD8vf3l6urq5o0aaKoqChVqlQpw7pRUVEaP378LR/TUX1/ebfAjpUfrif/XwIv9Nf3VbyEtRB7c2s+qzUy+0q34NyI7H91vl0lXbtm/n1u9PO67OxciL25NaXf+6iwuwCgiMnLeCksLEwxMTFavny5PD09FRcXJ0ny9vaWm5ubJCkuLk5xcXHmCKa9e/fK09NTlSpVMuOq4OBgde3aVeHh4Tb9jI6O1oABA1S8uG1YeOTIEcXExKhDhw4qVaqU9uzZoxEjRigwMFD16tW7pesDAAAg5eDxvcuXL+uNN95QxYoV1aFDB3333XeKj49XsWLFdPjwYY0bN04BAQHq0KGDtm7dmuOO5OXEnY0bN9bcuXO1cuVKzZw5U0ePHlWLFi108eLFDOuPGTNGCQkJ5uvPP/+8peMDAICiKT/ipZkzZyohIUFBQUEqX768+Vq0aJFZZ9asWWrQoIEGDx4sSQoMDFSDBg309ddfm3WOHDmic+fO2bS9Zs0a/fHHH3r66aftjuvi4qI1a9YoJCRENWvW1AsvvKDu3bvrm2++yc2lAQAAsOPwSKn77rtPTZo00YcffqhHH31UzhmMmjh+/LhiYmLUp08fvfLKK2Zg5Ij0iTvzYu6n9u3bm3/Xq1dPjRs3VuXKlbV48WINGjTIrr7VapXVeueO9gEAALeH/IiXDMPI9riRkZGKjIzMss6xY8fsykJCQjJtv2LFioqNjc322AAAALnlcFLq+++/V61atbKsU7lyZY0ZM0ajRo3SH3/84XAn0ifu3LhxY55O3JnOx8dH9913H5NyAgCAfJWf8RIAAMDdxuHH97ILsG7k7OysatWqZVvPMAyFh4dr2bJlWrduXZ5P3Jnu0qVLOnLkCJNyAgCAfJUf8RIAAMDdyuGk1I1Wrlxp85jd9OnTVb9+ffXr109///23w+2EhYVpwYIFiomJMSfujIuL0+XLl806cXFx2rVrl83Enbt27dKFCxfMOsHBwZo2bZr5ftSoUYqNjdWxY8f0448/qmvXripWrJj69u2bm9MFAADIsbyKlwAAAO5WuUpKvfjii0pMTJT0T5LohRdeUIcOHXT06FGNHOn4amb5NXHniRMn1LdvX9WoUUO9evVSqVKltHXrVpUpUyY3pwsAAJBjeRUvAQAA3K0cnlPqRkePHlXt2rUlSV988YU6deqkSZMmaefOnerQoYPD7eTXxJ2ff/65w30AAADID3kVLwEAANytcjVSysXFRcnJyZJkLhUsSb6+vuYvggAAAEUZ8RIAAEDWcjVSqnnz5ho5cqSaNWumn376yXzc7rfffsuX1fMAAADuNMRLAAAAWcvVSKlp06apePHiWrp0qWbOnKl77rlHkvTdd9+pXbt2edpBAACAOxHxEgAAQNZyNVKqUqVKWrFihV35e++9d8sdAgAAuBsQLwEAAGQtV0mpdGfOnNGZM2eUlpZmU16vXr1b6hQAAMDdgngJAAAgY7lKSu3YsUMDBgzQL7/8Yq6gZ7FYZBiGLBaLUlNT87STAAAAdxriJQAAgKzlKin19NNP67777tPHH3+ssmXLymKx5HW/AAAA7mjESwAAAFnLVVLq999/1xdffKHq1avndX8AAADuCsRLAAAAWcvV6nvBwcHavXt3XvcFAADgrkG8BAAAkLVcjZT66KOPNGDAAO3bt0916tSRs7OzzfbOnTvnSecAAADuVMRLAAAAWctVUmrLli3avHmzvvvuO7ttTNwJAABAvAQAAJCdXD2+N2zYMD355JM6deqU0tLSbF4EWAAAAMRLAAAA2clVUur8+fMaMWKEypYtm9f9AQAAuCsQLwEAAGQtV0mpbt26af369XndFwAAgLsG8RIAAEDWcjWn1H333acxY8Zo06ZNqlu3rt3EncOHD8+TzgEAANypiJcAAACyluvV9zw8PBQbG6vY2FibbRaLhSALAAAUecRLAAAAWctVUuro0aN53Q8AAIC7CvESAABA1nI1pxQAAAAAAABwKxxOSr355pu6fPmyQ3W3bdumb7/9NtedAlCw4pKStfvMOZvXvrPnze37zp632777zDnFJSUXYq8B4PZDvAQAAOA4hx/fO3DggCpVqqSePXvqscce00MPPaQyZcpIkq5fv64DBw5o06ZNWrBggU6ePKlPP/003zoNIG99uudXTdn2v0y3d1qc8T+aXmzcQC81eTC/ugUAdxziJQAAAMc5nJT69NNPtXv3bk2bNk39+vVTYmKiihUrJqvVquTkf0ZLNGjQQM8884xCQ0Pl6uqab50GkLf616upttUq5Xi/su4l8qE3AHDnyo94KSoqSl9++aV+/fVXubm5qWnTppo8ebJq1Khh1pkzZ45iYmK0c+dOXbx4UX///bd8fHyybDcyMlLjx4+3KatRo4Z+/fVX8/2VK1f0wgsv6PPPP1dKSoratm2rGTNmqGzZsjm4KgAAABnL0UTnDzzwgD788EPNnj1be/bs0fHjx3X58mWVLl1a9evXV+nSpfOrnwDyUTn3EipHggkA8kRex0uxsbEKCwtTo0aNdP36dY0dO1YhISE6cOCA3N3dJUnJyclq166d2rVrpzFjxjjc9v333681a9aY74sXtw0NR4wYoW+//VZLliyRt7e3wsPD1a1bN23evDlH5wAAAJCRXK2+5+TkpPr166t+/fp53B0AAIC7Q17FSytXrrR5P3fuXPn5+WnHjh0KDAyUJEVEREiSNmzYkKO2ixcvrnLlymW4LSEhQR9//LFiYmLUunVrSVJ0dLRq1aqlrVu36pFHHsnZiQAAANyE1fcAAADuIAkJCZIkX1/fW27r0KFD8vf3V9WqVfXEE0/ojz/+MLft2LFD165dU5s2bcyymjVrqlKlStqyZUuG7aWkpCgxMdHmBQAAkJlcjZQCAABAwUtLS1NERISaNWumOnXq3FJbjRs31ty5c1WjRg2dOnVK48ePV4sWLbRv3z55enoqLi5OLi4udnNTlS1bVnFxcRm2GRUVZTdPVX7q+8u7BXYs4G7zWa2Rhd2FPHNuxDOF3QXgjlX6vY8K9fgkpQAAAO4QYWFh2rdvnzZt2nTLbbVv3978u169emrcuLEqV66sxYsXa9CgQblqc8yYMRo58v/+oZuYmKiKFSvecl8BAMDdiaQUAADAHSA8PFwrVqzQxo0bVaFChTxv38fHR/fdd58OHz4sSSpXrpyuXr2q+Ph4m9FSp0+fznQeKqvVKqvVmud9AwAAd6dbSkodPnxYR44cUWBgoNzc3GQYhiwWS171DbeBy2cTdfms7XwQqVeumn///etfKubqYrefWxkvuZXxyvf+AQBwu7vVeMkwDA0bNkzLli3Thg0bFBAQkC/9vHTpko4cOaKnnnpKktSwYUM5Oztr7dq16t69uyTp4MGD+uOPP9SkSZN86QMAAChacpWUOn/+vHr37q1169bJYrHo0KFDqlq1qgYNGqSSJUvqnXfeyet+opAcXrRF+2d8n+n2tU9Oz7D8/udDVDe8bX51CwCA215exUthYWGKiYnR8uXLzbmeJMnb21tubm6SpLi4OMXFxZmjnPbu3StPT09VqlTJnBA9ODhYXbt2VXh4uCRp1KhReuyxx1S5cmWdPHlS48aNU7FixdS3b1+z/UGDBmnkyJHy9fWVl5eXhg0bpiZNmrDyHgAAyBO5SkqNGDFCxYsX1x9//KFatWqZ5b1799bIkSNJSt1Fqvduonta35/j/RglBQAo6vIqXpo5c6YkKSgoyKY8OjpaoaGhkqRZs2bZTDAeGBhoV+fIkSM6d+6cWefEiRPq27evzp8/rzJlyqh58+baunWrypQpY9Z577335OTkpO7duyslJUVt27bVjBkzHL4GAAAAWclVUur777/XqlWr7OYzuPfee3X8+PE86RhuDzyGBwBA7uRVvGQYRrZ1IiMjFRkZmWWdY8eO2bz//PPPs23X1dVV06dP1/TpGY+MBgAAuBVOudkpKSlJJUqUsCu/cOECk1sCAACIeAkAACA7uUpKtWjRQp9++qn53mKxKC0tTW+99ZZatWqVZ50DAAC4UxEvAQAAZC1Xj++99dZbCg4O1s8//6yrV6/qpZde0v79+3XhwgVt3rw5r/sIAABwxyFeAgAAyFquklJ16tTRb7/9pmnTpsnT01OXLl1St27dFBYWpvLly+d1HwEAQA6dOnVKp06dyvF+5cuX57s8jxAvAQAAZC1XSSnpn2WCX3nllbzsCwAAyCOzZ8+2WY3NUePGjct2wmw4jngJAAAgc7lOSl25ckV79uzRmTNnlJaWZrOtc+fOt9wxAACQe0OHDrX7Pr58+bKaN28uSdq0aZPc3Nzs9mMET94iXgIAAMhcrpJSK1euVP/+/XXu3Dm7bRaLRampqbfcMQAAkHsZPYaXlJRk/l2/fn25u7sXdLeKFOIlAACArOVq9b1hw4apZ8+eOnXqlNLS0mxeBFgAAADESwAAANnJVVLq9OnTGjlypMqWLZvX/QEAALgrEC8BAABkLVdJqR49emjDhg153BUAAIC7B/ESAABA1nI1p9S0adPUs2dP/fDDD6pbt66cnZ1ttg8fPjxPOgcAAHCnIl4CAADIWq6SUp999pm+//57ubq6asOGDbJYLOY2i8VCkAUAAIo84iUAAICs5Sop9corr2j8+PF6+eWX5eSUqycAAQAA7mrESwAAAFnLVYR09epV9e7dmwALAAAgE8RLAAAAWctVlDRgwAAtWrQor/sCAABw1yBeAgAAyFquHt9LTU3VW2+9pVWrVqlevXp2E3e+++67edI5AACAOxXxEgAAQNZylZTau3evGjRoIEnat2+fzbYbJ/EEAAAoqoiXAAAAsparpNT69evzuh8AAAB3FeIlAACArDHzJgAAAAAAAAqcwyOlunXrprlz58rLy0vdunXLsu6XX355yx0DAAC40xAvAQAAOM7hkVLe3t7m/Afe3t5ZvhwVFRWlRo0aydPTU35+furSpYsOHjxoU2fOnDkKCgqSl5eXLBaL4uPjHW5fkt58801ZLBZFRETkaD8AAICcyo94CQAA4G7l8Eip6OhoTZgwQaNGjVJ0dHSeHDw2NlZhYWFq1KiRrl+/rrFjxyokJEQHDhyQu7u7JCk5OVnt2rVTu3btNGbMmBy1v337ds2ePVv16tXLk/4CwJ3u1KlTOnXqVI73K1++vMqXL58PPQLuLvkRLwEAANytcjTR+fjx4/Xss8+qRIkSeXLwlStX2ryfO3eu/Pz8tGPHDgUGBkqSOcJpw4YNOWr70qVLeuKJJ/Thhx/qjTfeyIvuAsAdb/bs2Ro/fnyO9xs3bpwiIyPzvkPAXSiv4yUAAIC7VY6SUoZh5Fc/JEkJCQmSJF9f31tuKywsTB07dlSbNm2yTUqlpKQoJSXFfJ+YmHjLxweA29HQoUPVuXNnm7LLly+refPmkqRNmzbJzc3Nbj9GSQGOy+94CQAA4G6Ro6SUJHOehLyWlpamiIgINWvWTHXq1Lmltj7//HPt3LlT27dvd6h+VFRUrkYOAEC6/l/8WdhdyIEyNu+uXUk2/552rLScXTMY3XH0uqTb/xw/7V4x34/x1Sub8/0Y+eXK1cvm399EbpGri30C8k7R5d/NCrsLWcqveAkAAOBu4vBE5+nuu+8++fr6ZvnKjbCwMO3bt0+ff/55rvZP9+eff+pf//qXFi5cKFdXV4f2GTNmjBISEszXn3/e/v/wAoDcSP77tM7/vtfmdeHofnP7haP77baf/32vkv8+XYi9Bu48eRkv5dfCMI60GxQUJIvFYvN69tlnHe47AABAVnI8Umr8+PF5vmJMeHi4VqxYoY0bN6pChQq31NaOHTt05swZPfjgg2ZZamqqNm7cqGnTpiklJUXFihWz2cdqtcpqtd7ScQHgTnDo+4Xas2Rqptu/f617huX1ekbogd4j86lXwN0nL+Ol/FoYxpF2JWnw4MGaMGGC+Z65sgAAQF7JcVKqT58+8vPzy5ODG4ahYcOGadmyZdqwYYMCAgJuuc3g4GDt3bvXpmzgwIGqWbOmRo8ebZeQAoCi5N6QJ1Sh0aM53s+tZN78dx8oKvIyXsqvhWEcaVf6JwlVrly53HUeAAAgCzlKSuX1/AhhYWGKiYnR8uXL5enpqbi4OEmSt7e3OdFuXFyc4uLidPjwYUnS3r175enpqUqVKplD34ODg9W1a1eFh4fL09PTbk4qd3d3lSpV6pbnqgKAO12JkmVVomTZwu4GcFfL7/mk8nJhGEfaXbhwoRYsWKBy5crpscce02uvvZbpaCkWjwEAADlRqKvvzZw5U9I/8xXcKDo6WqGhoZKkWbNm2UxCnv7L3Y11jhw5onPnzuVp3wAAAHIjP1ffy8uFYRxpt1+/fqpcubL8/f21Z88ejR49WgcPHtSXX36ZYTssHgMAAHIiR0mptLS0PD24I0FbZGSkIiMjs6xz7NixLLfnZCg7AADArcjreOlG6QvDbNq0qUDaHTJkiPl33bp1Vb58eQUHB+vIkSOqVq2aXTtjxozRyJH/N/9cYmKiKlbM/1UxAQDAnSnHc0oBAACg4OXlwjC5bbdx48aSpMOHD2eYlGLxGAAAkBMkpQAAAG5j+bEwTG7b3bVrlySpfPnyedIHAABQtJGUAgAAuI3lx8IwjrR75MgRxcTEqEOHDipVqpT27NmjESNGKDAwUPXq1SvoywAAAO5CToXdAQAAAGRu5syZSkhIUFBQkMqXL2++Fi1aZNaZNWuWGjRooMGDB0v6Z2GYBg0a6Ouvvzbr3LwwTHbturi4aM2aNQoJCVHNmjX1wgsvqHv37vrmm28K6MwBAMDdjpFSAAAAt7H8Whgmu3YrVqyo2NjYbI8NAACQW4yUAgAAAAAAQIEjKQUAAAAAAIACR1IKAAAAAAAABY6kFAAAAAAAAAocSSkAAAAAAAAUOJJSAAAAAAAAKHAkpQAAAAAAAFDgihd2BwAAQN67cOmc/r503qbs6rUU8++jpw/Jxdlqt19Jj1Ly9Sid7/0DAAAASEoBAHAX+n7nci3aFJ3p9rHzn8+wvHfzgeoTOCi/ugUAAACYSEoBAHAXCnnwcTW6r3mO9yvpUSofegMAAADYIykFAMBdyNejNI/hAQAA4LbGROcAAAAAAAAocCSlAAAAAAAAUOBISgEAAAAAAKDAkZQCAAAAAABAgSMpBQAAAAAAgAJHUgoAAAAAAAAFjqQUAAAAAAAAChxJKQAAAAAAABQ4klIAAAAAAAAocCSlAAAAAAAAUOBISgEAAAAAAKDAkZQCAAAAAABAgSMpBQAAAAAAgAJHUgoAAAAAAAAFjqQUAAAAAAAAChxJKQAAgNtYVFSUGjVqJE9PT/n5+alLly46ePCgTZ05c+YoKChIXl5eslgsio+Pd6jt6dOnq0qVKnJ1dVXjxo31008/2Wy/cuWKwsLCVKpUKXl4eKh79+46ffp0Xp0aAAAo4khKAQAA3MZiY2MVFhamrVu3avXq1bp27ZpCQkKUlJRk1klOTla7du00duxYh9tdtGiRRo4cqXHjxmnnzp164IEH1LZtW505c8asM2LECH3zzTdasmSJYmNjdfLkSXXr1i1Pzw8AABRdxQu7AwAAAMjcypUrbd7PnTtXfn5+2rFjhwIDAyVJERERkqQNGzY43O67776rwYMHa+DAgZKkWbNm6dtvv9Unn3yil19+WQkJCfr4448VExOj1q1bS5Kio6NVq1Ytbd26VY888ohdmykpKUpJSTHfJyYm5uRUAQBAEcNIKQAAgDtIQkKCJMnX1zfXbVy9elU7duxQmzZtzDInJye1adNGW7ZskSTt2LFD165ds6lTs2ZNVapUyaxzs6ioKHl7e5uvihUr5rqPAADg7kdSCgAA4A6RlpamiIgINWvWTHXq1Ml1O+fOnVNqaqrKli1rU162bFnFxcVJkuLi4uTi4iIfH59M69xszJgxSkhIMF9//vlnrvsIAADufjy+BwAAcIcICwvTvn37tGnTpsLuSoasVqusVmthdwMAANwhGCkFAABwBwgPD9eKFSu0fv16VahQ4ZbaKl26tIoVK2a3kt7p06dVrlw5SVK5cuV09epVu5X8bqwDAABwK0hKAQAA3MYMw1B4eLiWLVumdevWKSAg4JbbdHFxUcOGDbV27VqzLC0tTWvXrlWTJk0kSQ0bNpSzs7NNnYMHD+qPP/4w6wAAANwKHt8DAAC4jYWFhSkmJkbLly+Xp6enOZ+Tt7e33NzcJP0z/1NcXJwOHz4sSdq7d688PT1VqVIlc0L04OBgde3aVeHh4ZKkkSNHasCAAXrooYf08MMPa+rUqUpKSjJX4/P29tagQYM0cuRI+fr6ysvLS8OGDVOTJk0yXHkPAAAgp0hKAQAA3MZmzpwpSQoKCrIpj46OVmhoqCRp1qxZGj9+vLktMDDQrs6RI0d07tw5s07v3r119uxZvf7664qLi1P9+vW1cuVKm8nP33vvPTk5Oal79+5KSUlR27ZtNWPGjHw4SwAAUBSRlAIAALiNGYaRbZ3IyEhFRkZmWefYsWN2ZeHh4ebIqYy4urpq+vTpmj59erZ9AAAAyCnmlAIAAAAAAECBIykFAAAAAACAAkdSCgAAAAAAAAWOpBQAAAAAAAAKHEkpAAAAAAAAFDiSUgAAAAAAAChwJKUAAAAAAABQ4EhKAQAAAAAAoMCRlAIAAAAAAECBIykFAAAAAACAAleoSamoqCg1atRInp6e8vPzU5cuXXTw4EGbOnPmzFFQUJC8vLxksVgUHx+fbbszZ85UvXr15OXlJS8vLzVp0kTfffddPp0FAAAAAAAAcqpQk1KxsbEKCwvT1q1btXr1al27dk0hISFKSkoy6yQnJ6tdu3YaO3asw+1WqFBBb775pnbs2KGff/5ZrVu31uOPP679+/fnx2kAAAAAAAAgh4oX5sFXrlxp837u3Lny8/PTjh07FBgYKEmKiIiQJG3YsMHhdh977DGb9//+9781c+ZMbd26Vffff79d/ZSUFKWkpJjvExMTHT4WAAAAAAAAcu62mlMqISFBkuTr65tnbaampurzzz9XUlKSmjRpkmGdqKgoeXt7m6+KFSvm2fEBAAAAAABg77ZJSqWlpSkiIkLNmjVTnTp1brm9vXv3ysPDQ1arVc8++6yWLVum2rVrZ1h3zJgxSkhIMF9//vnnLR8fAAAAAAAAmSvUx/duFBYWpn379mnTpk150l6NGjW0a9cuJSQkaOnSpRowYIBiY2MzTExZrVZZrdY8OS4AAAAAAACyd1skpcLDw7VixQpt3LhRFSpUyJM2XVxcVL16dUlSw4YNtX37dv3nP//R7Nmz86R9AAAAAAAA5F6hJqUMw9CwYcO0bNkybdiwQQEBAfl2rLS0NJvJzAEAAAAAAFB4CjUpFRYWppiYGC1fvlyenp6Ki4uTJHl7e8vNzU2SFBcXp7i4OB0+fFjSP3NFeXp6qlKlSuaE6MHBweratavCw8Ml/TNHVPv27VWpUiVdvHhRMTEx2rBhg1atWlUIZwkAAAAAAICbFWpSaubMmZKkoKAgm/Lo6GiFhoZKkmbNmqXx48eb2wIDA+3qHDlyROfOnTPrnDlzRv3799epU6fk7e2tevXqadWqVXr00Ufz72QAAAAAAADgsEJ/fC87kZGRioyMzLLOsWPHbN5//PHHt9ArAAAAAAAA5Denwu4AAAAAAAAAih6SUgAAAAAAAChwJKUAAAAAAABQ4EhKAQAAAAAAoMCRlAIAALiNRUVFqVGjRvL09JSfn5+6dOmigwcP2tS5cuWKwsLCVKpUKXl4eKh79+46ffp0lu1aLJYMX1OmTDHrVKlSxW77m2++mS/nCQAAih6SUgAAALex2NhYhYWFaevWrVq9erWuXbumkJAQJSUlmXVGjBihb775RkuWLFFsbKxOnjypbt26ZdnuqVOnbF6ffPKJLBaLunfvblNvwoQJNvWGDRuWL+cJAACKnuKF3QEAAABkbuXKlTbv586dKz8/P+3YsUOBgYFKSEjQxx9/rJiYGLVu3VqSFB0drVq1amnr1q165JFHMmy3XLlyNu+XL1+uVq1aqWrVqjblnp6ednUBAADyAiOlAAAA7iAJCQmSJF9fX0nSjh07dO3aNbVp08asU7NmTVWqVElbtmxxqM3Tp0/r22+/1aBBg+y2vfnmmypVqpQaNGigKVOm6Pr165m2k5KSosTERJsXAABAZhgpBQAAcIdIS0tTRESEmjVrpjp16kiS4uLi5OLiIh8fH5u6ZcuWVVxcnEPtzps3T56ennaP/A0fPlwPPvigfH199eOPP2rMmDE6deqU3n333QzbiYqK0vjx43N+YgAAoEgiKQUAAHCHCAsL0759+7Rp06Y8bfeTTz7RE088IVdXV5vykSNHmn/Xq1dPLi4uGjp0qKKiomS1Wu3aGTNmjM0+iYmJqlixYp72FQAA3D1ISgEAANwBwsPDtWLFCm3cuFEVKlQwy8uVK6erV68qPj7eZrTU6dOnHZoL6ocfftDBgwe1aNGibOs2btxY169f17Fjx1SjRg277VarNcNkFQAAQEaYUwoAAOA2ZhiGwsPDtWzZMq1bt04BAQE22xs2bChnZ2etXbvWLDt48KD++OMPNWnSJNv2P/74YzVs2FAPPPBAtnV37dolJycn+fn55fxEAAAAbsJIKQAAgNtYWFiYYmJitHz5cnl6eprzRHl7e8vNzU3e3t4aNGiQRo4cKV9fX3l5eWnYsGFq0qSJzcp7NWvWVFRUlLp27WqWJSYmasmSJXrnnXfsjrtlyxZt27ZNrVq1kqenp7Zs2aIRI0boySefVMmSJfP/xAEAwF2PpBQAAMBtbObMmZKkoKAgm/Lo6GiFhoZKkt577z05OTmpe/fuSklJUdu2bTVjxgyb+gcPHjRX7kv3+eefyzAM9e3b1+64VqtVn3/+uSIjI5WSkqKAgACNGDHCZs4oAACAW0FSCgAA4DZmGEa2dVxdXTV9+nRNnz49R+0MGTJEQ4YMybD+gw8+qK1btzreUQAAgBxiTikAAAAAAAAUOJJSAAAAAAAAKHAkpQAAAAAAAFDgSEoBAAAAAACgwJGUAgAAAAAAQIEjKQUAAAAAAIACR1IKAAAAAAAABY6kFAAAAAAAAAocSSkAAAAAAAAUOJJSAAAAAAAAKHAkpQAAAAAAAFDgSEoBAAAAAACgwJGUAgAAAAAAQIEjKQUAAAAAAIACR1IKAAAAAAAABY6kFAAAAAAAAAocSSkAAAAAAAAUOJJSAAAAAAAAKHAkpQAAAAAAAFDgSEoBAAAAAACgwJGUAgAAAAAAQIEjKQUAAAAAAIACR1IKAAAAAAAABY6kFAAAAAAAAAocSSkAAAAAAAAUOJJSAAAAt7GoqCg1atRInp6e8vPzU5cuXXTw4EGbOleuXFFYWJhKlSolDw8Pde/eXadPn86y3dDQUFksFptXu3btbOpcuHBBTzzxhLy8vOTj46NBgwbp0qVLeX6OAACgaCIpBQAAcBuLjY1VWFiYtm7dqtWrV+vatWsKCQlRUlKSWWfEiBH65ptvtGTJEsXGxurkyZPq1q1btm23a9dOp06dMl+fffaZzfYnnnhC+/fv1+rVq7VixQpt3LhRQ4YMyfNzBAAARVPxwu4AAAAAMrdy5Uqb93PnzpWfn5927NihwMBAJSQk6OOPP1ZMTIxat24tSYqOjlatWrW0detWPfLII5m2bbVaVa5cuQy3/fLLL1q5cqW2b9+uhx56SJL0wQcfqEOHDnr77bfl7++fR2cIAACKKkZKAQAA3EESEhIkSb6+vpKkHTt26Nq1a2rTpo1Zp2bNmqpUqZK2bNmSZVsbNmyQn5+fatSooeeee07nz583t23ZskU+Pj5mQkqS2rRpIycnJ23bti3D9lJSUpSYmGjzAgAAyAxJKQAAgDtEWlqaIiIi1KxZM9WpU0eSFBcXJxcXF/n4+NjULVu2rOLi4jJtq127dvr000+1du1aTZ48WbGxsWrfvr1SU1PNdv38/Gz2KV68uHx9fTNtNyoqSt7e3uarYsWKt3C2AADgbsfjewAAAHeIsLAw7du3T5s2bbrltvr06WP+XbduXdWrV0/VqlXThg0bFBwcnKs2x4wZo5EjR5rvExMTSUwBAIBMMVIKAADgDhAeHq4VK1Zo/fr1qlChgllerlw5Xb16VfHx8Tb1T58+nel8URmpWrWqSpcurcOHD5vtnjlzxqbO9evXdeHChUzbtVqt8vLysnkBAABkhqQUAADAbcwwDIWHh2vZsmVat26dAgICbLY3bNhQzs7OWrt2rVl28OBB/fHHH2rSpInDxzlx4oTOnz+v8uXLS5KaNGmi+Ph47dixw6yzbt06paWlqXHjxrd4VgAAACSlAAAAbmthYWFasGCBYmJi5Onpqbi4OMXFxeny5cuSJG9vbw0aNEgjR47U+vXrtWPHDg0cOFBNmjSxWXmvZs2aWrZsmSTp0qVLevHFF7V161YdO3ZMa9eu1eOPP67q1aurbdu2kqRatWqpXbt2Gjx4sH766Sdt3rxZ4eHh6tOnDyvvAQCAPMGcUgAAALexmTNnSpKCgoJsyqOjoxUaGipJeu+99+Tk5KTu3bsrJSVFbdu21YwZM2zqHzx40Fy5r1ixYtqzZ4/mzZun+Ph4+fv7KyQkRBMnTpTVajX3WbhwocLDwxUcHGy2//777+ffyQIAgCKFpBQAAMBtzDCMbOu4urpq+vTpmj59ukPtuLm5adWqVdm26+vrq5iYGMc6CgAAkEOF+vheVFSUGjVqJE9PT/n5/b/27juu6vL///jjHFYYkAvQ3DOzT+6VmfvrSM29R5qVeytobkgUNWdqogIOHDn4ZA5ciTtTE8u0VNIkdy5CBYRzfn/44/0BtVJTDuN5v9265TnvwXV8c96e63mu63V50KxZM3755ZcU+wQEBFCzZk3c3NwwmUyPFPF81vOKiIiIiIiIiIjt2DSU2rVrF3369OHbb79l27Zt3L9/n3r16nHnzh1jn7t379KgQQM++eST53peERERERERERGxHZtO3wsLC0vxODg4GA8PD44cOUL16tUBGDhwIADh4eHP9bwiIiIiIiIiImI7aaqmVFLxzezZs6fqeePi4oiLi3tk/+jo6OfajiT3Y2JfyHnl6b2oa5zkz7j4F3p+eTKOL/g6A8Tf/fOF/wz5Zy/6PQ1wN06jbtOCF3Wtk877JHWc5J8l/T3qM5VI2pMa/2amFn3mFnl2L6qv9KSfqUzWNPKpy2Kx8N5773Hr1i327t37yPbw8HBq1arFzZs3yZo163M7L8C4ceMYP378szZdREREMpioqCjy5s1r62ake7///jv58uWzdTNERETERv7pM1WaGSnVp08fjh8//pfB0Ys874gRIxg8eLDx2GKxcOPGDXLkyIHJZHqu7ckooqOjyZcvH1FRUbi5udm6OfKC6DpnHrrWmYeu9d+zWq38+eefvPrqq7ZuSobw6quvEhUVhaurqz5TZTK614gI6F6QmT3pZ6o0EUr17duXDRs2sHv37uf6reSTntfJyQknJ6cUzz3NaKzMzM3NTTeXTEDXOfPQtc48dK3/2iuvvGLrJmQYZrNZI84yOd1rRAR0L8isnuQzlU1DKavVSr9+/QgNDSU8PJxChQql6fOKiIiIiIiIiMjzYbblD+/Tpw/Lli1j+fLluLq6cvnyZS5fvsy9e/eMfS5fvkxERARnzpwB4McffyQiIoIbN24Y+9SpU4fPP//8qc4rIiIiIiIiIiK2Y9NQat68edy+fZuaNWuSO3du479Vq1YZ+3zxxReULVuWjz76CIDq1atTtmxZ1q9fb+wTGRnJH3/88VTnlX/HycmJsWPHPjLtUTIWXefMQ9c689C1FpHUoHuNiIDuBfLP0szqeyIiIiIiIiIiknnYdKSUiIiIiIiIiIhkTgqlREREREREREQk1SmUEhERERERERGRVKdQSkREREREREREUp1CKRERERERASA4OJisWbPauhki8pzUrFmTgQMH2roZf0v3ncxNoZSkORaLBQAtDCkikrGEhobaugkikkkVLFiQGTNm2LoZIhnKs4RJj3svtm3bllOnTj2/hkm6olBK0pQ///wTs/nBr+Xp06dt3BoREXleFi1axJAhQ/D397d1U0RERCQNcXZ2xsPDw9bNEBtRKCVpxtdff42vry/37t2jb9++VKxYkT///NPWzRKRJ5Q0ylHkcRo0aECTJk346quvmDRpkq2bI5JhWCwWJk+eTNGiRXFyciJ//vxMmDCB8PBwTCYTt27dMvaNiIjAZDJx7tw547ng4GDy589PlixZaN68OdevX09x/sjISJo2bYqnpycuLi5UrFiR7du3P3H74uLiGDp0KHny5OHll1+mcuXKhIeHAxAdHY2zszObN29OcUxoaCiurq7cvXsXgKioKNq0aUPWrFnJnj07TZs2TfEaunbtSrNmzZg6dSq5c+cmR44c9OnTh/v37wMPpi/99ttvDBo0CJPJhMlkeuL2i2QEFosFLy8vsmfPTq5cuRg3bpyx7fz58zRt2hQXFxfc3Nxo06YNV65cMbYfO3aMWrVq4erqipubG+XLl+fw4cOEh4fTrVs3bt++bbyvkp/3cf7qvfjwiKtx48ZRpkwZAgMDyZ8/Py4uLvTu3ZvExEQmT55Mrly58PDwYMKECSnOf+vWLT788EPc3d1xc3Ojdu3aHDt27F///cmLpVBK0oyzZ88SGBhIrVq1WLVqFQcOHMDV1VXT+NK5vwsqdG0zjsTERGOU47Fjx4iMjOTatWs2bpWkFRaLhTx58jBixAgqVKjAf//7XwVTIs/JiBEjmDRpEqNHj+bEiRMsX74cT0/PJzr24MGDdO/enb59+xIREUGtWrX49NNPU+wTExPDu+++y44dOzh69KgRMJ8/f/6Jfkbfvn05cOAAK1eu5IcffqB169Y0aNCA06dP4+bmRuPGjVm+fHmKY0JCQmjWrBlZsmTh/v371K9fH1dXV/bs2cO+fftwcXGhQYMGxMfHG8fs3LmTyMhIdu7cyeLFiwkODiY4OBiAdevWkTdvXnx8fLh06RKXLl16oraLZBSLFy/m5Zdf5uDBg0yePBkfHx+2bduGxWKhadOm3Lhxg127drFt2zZ+/fVX2rZtaxzbsWNH8ubNy6FDhzhy5AjDhw/HwcGBqlWrMmPGDNzc3Iz31dChQ/+2HU/zXoyMjGTz5s2EhYWxYsUKFi1aRKNGjfj999/ZtWsX/v7+jBo1ioMHDxrHtG7dmqtXr7J582aOHDlCuXLlqFOnDjdu3Pj3f4ny4lhF0pBGjRpZTSaTtXv37tbr16/bujnyLyUmJhp//u9//2tduHChdfbs2daoqCgbtkqep/Hjx1u3bNliPB42bJi1YMGC1mzZsllbt25t3bBhgw1bJ2lJ0v3g4sWL1r59+1orV65snThxoo1bJZK+RUdHW52cnKwLFix4ZNvOnTutgPXmzZvGc0ePHrUC1rNnz1qtVqu1ffv21nfffTfFcW3btrW+8sorf/tz33jjDevs2bP/sX2//fab1c7OznrhwoUUz9epU8c6YsQIq9VqtYaGhlpdXFysd+7csVqtVuvt27etL730knXz5s1Wq9VqXbp0qfW1116zWiwW4/i4uDirs7Oz8e/P+++/by1QoIA1ISHB2Kd169bWtm3bGo8LFChgnT59+j+2WSSjqVGjhrVatWopnqtYsaLV29vbunXrVqudnZ31/PnzxraffvrJCli/++47q9Vqtbq6ulqDg4Mfe+6goKB/vF887HHvxYfPM3bsWGuWLFms0dHRxnP169e3FixYMEX/4rXXXjM+S+zZs8fq5uZmjY2NTXHuIkWKWOfPn/9UbZTUZW/jTEwyOavVislkIj4+HgcHB0qVKkWpUqVYunQp7u7u9OzZkwIFChj7JT9G0r6kkTNeXl6EhIRQsWJFTpw4wZIlSxgwYAAdO3a0cQvl34iIiGDjxo3s378fFxcXTCYTa9asITAwkF9//ZWwsDB8fHyIjY2lZcuWtm6u2IDFYjHuA0n/z507N8OHD8ff398ofD58+HCbtVEkPTt58iRxcXHUqVPnmY9v3rx5iufeeustwsLCjMcxMTGMGzeOjRs3cunSJRISErh3794TjZT68ccfSUxMpHjx4imej4uLI0eOHAC8++67ODg4sH79etq1a8fatWtxc3Ojbt26wIPRt2fOnMHV1TXFOWJjY4mMjDQev/HGG9jZ2RmPc+fOzY8//viEfxMiGVupUqVSPM6dOzdXr17l5MmT5MuXj3z58hnbSpYsSdasWTl58iQVK1Zk8ODBfPjhhyxdupS6devSunVrihQp8sLbXLBgwRTve09PT+zs7IzPE0nPXb16FXhwr4iJiTHuLUnu3buX4l4haY9CKbGZ5J2VuLg4HB0d8fPzA8DDw4OpU6cC0KtXL/Lnzw886ASXKVPGJu2VZ7N06VJCQkLYsGEDZcuWZeXKlXTo0IFs2bLZumnyL5UpUwYfHx9mz56Nv78/BQsWpEePHtSqVYtatWpRqlQpZs2ahb+/PyaTiRYtWti6yZKKrFarcY9ftGgRp0+fxmw206xZMypVqsSoUaP49NNPCQ0NxWQy4e3tbeMWi6Q/zs7Of7kt6f1nTTZVPqnG0tMYOnQo27ZtY+rUqRQtWhRnZ2datWqVYurcX4mJicHOzo4jR46kCIwAXFxcAHB0dKRVq1YsX76cdu3asXz5ctq2bYu9vb1xjvLlyxMSEvLI+d3d3Y0/Ozg4pNhmMplU61Dk//s3749x48bRoUMHNm7cyObNmxk7diwrV658JNB+3h7X5r97HTExMeTOnduoWZfc064QKKlLNaXEZpI+LE2dOpUWLVrQqVMnFi9eDMDAgQMZNmwYISEhzJw5k127dtGwYUNat24NqBZRenL27FkaNGhgBFI9e/Zkzpw5vPvuu9y9e5cLFy7YuonyDBITEwGoX78+ffr0ITExkZCQkBRz9itWrMiAAQMoUaIEkydPZtmyZbZqrqQyi8VijGj18vJi6NChHDp0iJ07d1KlShWmT5+Oh4cHI0eOpHLlyqxfv56RI0fauNUi6U+xYsVwdnZmx44dj2xLCmyS12yJiIhIsc/rr7+eoh4LwLfffpvi8b59++jatSvNmzfnzTffJFeuXCmKjP+dsmXLkpiYyNWrVylatGiK/3LlymXs17FjR8LCwvjpp5/45ptvUoykLleuHKdPn8bDw+ORc7zyyitP1A54EH4l/dslIg+8/vrrREVFERUVZTx34sQJbt26RcmSJY3nihcvzqBBg9i6dSstWrQgKCgIeLb31Yt6L5YrV47Lly9jb2//yL0iZ86cz/3nyfOjUEpSXfJAacaMGUyYMIFKlSpx7tw55s2bx4gRIwAYMGAA3t7ebNmyhR49evDnn39y4sQJAE3fSweS/rE5f/48np6eHD16lI8++oiJEyfSq1cvrFYrQUFBhIaGkpCQYOPWytOwWCzGN96xsbE0bNiQoUOH8uabb7Ju3Tq++eYbY98KFSowYMAAcubM+dhvriRjSvrS4dSpU1y4cIHt27ezY8cODhw4wNSpUxk2bBgLFizA09OT4cOHU7RoUa5du6YvHESe0ksvvYS3tzdeXl4sWbKEyMhIvv32WxYtWkTRokXJly8f48aN4/Tp02zcuJHPPvssxfH9+/cnLCyMqVOncvr0aT7//PMUU/fgQfC1bt06IiIiOHbsGB06dHjiERbFixenY8eOdOnShXXr1nH27Fm+++47Jk6cyMaNG439qlevTq5cuejYsSOFChWicuXKxraOHTuSM2dOmjZtyp49ezh79izh4eH079+f33///Yn/rgoWLMju3bu5cOECf/zxxxMfJ5KR1a1blzfffJOOHTvy/fff891339GlSxdq1KhBhQoVjFXRw8PD+e2339i3bx+HDh3i9ddfBx68r2JiYtixYwd//PGHsWLm33lR78W6devy1ltv0axZM7Zu3cq5c+fYv38/I0eO5PDhw8/t58jzp1BKUl1SoLR//34uXbrEypUrmTBhAl999RV169Zl69atRn2RPn36sHLlSlauXMnu3btxcHBQgJFGPfwBNSm0aNGiBTNmzKB8+fIEBATQq1cv4MH87q+//ppz584ZQ/Ql7Us+7dbf3x8vLy/Onj1LzZo1GTVqFMWKFcPf3z9FAFW+fHk+++wzAgICbNRqsYWVK1fSsGFDfvzxR3Lnzm0EToMHD2bMmDF4eXnx66+/8uqrrzJ9+nS++OILTCaTgimRpzR69GiGDBnCmDFjeP3112nbti1Xr17FwcGBFStW8PPPP1OqVCn8/f0fWVmvSpUqLFiwgJkzZ1K6dGm2bt3KqFGjUuwzbdo0smXLRtWqVWnSpAn169enXLlyT9y+oKAgunTpwpAhQ3jttddo1qwZhw4dMkozwIPPhu3bt+fYsWOP1JvMkiULu3fvJn/+/LRo0YLXX3+d7t27Exsbi5ub2xO3w8fHh3PnzlGkSJEU0/5EMjOTycRXX31FtmzZqF69OnXr1qVw4cKsWrUKePB5/vr163Tp0oXixYvTpk0bGjZsyPjx4wGoWrUqPXv2pG3btri7uzN58uR//Jkv6r1oMpnYtGkT1atXp1u3bhQvXpx27drx22+/PfGKpGIbJqs+/YkNbNq0CS8vL+7evctXX33Fm2++CcC1a9eYNWsWmzdvpl69ekaNqSSJiYmP1CQQ20tefH7z5s1cvXqVatWq8eqrr+Lg4MDw4cNZvnw5U6ZMMZaRHjZsGFeuXOG7775TKJUOeXt7s2TJEsaPH0+jRo3IkycPAFu2bGHWrFkkJCQwcuRIqlevnuK45KGWZGzLli1j4cKFHDlyhGPHjlG4cGHi4+NxdHTk5MmT1KtXj6VLl1KzZk3jGP1+iIiIiGQu6gmKTRQtWpTKlSuzZs0aQkNDjVDK3d2dAQMGYDabCQwMpECBAvTo0cM4ToFU2pQUSHl7e7No0SIcHBxwdnamR48e9OrVi379+pGQkED37t3Jnj077u7u5MiRg4MHD2Jvb6+wMZ3ZsWMHy5cvJzQ0lCpVqgD/Cybr16+PyWRi9uzZDBo0iIULF1K2bFnjWAUOGdPjwqROnTrh4uLC2LFjjRW1klb3efnllwEeKZSs3w8RERGRzEWhlLxwD3dWkpYGHjduHHZ2dqxfv57s2bPTt29fAHLmzEnv3r3JmzcvH3zwga2aLU8gKYiwWq389ttvHDx4kM2bN1OyZEnGjRvHypUriYmJYdiwYcyYMYOPP/6Yc+fO4enpSdmyZTGbzSQkJGikVDpz+fJlPDw8KF269GMDxXr16hEfH094eDilS5e2USsltSS/x2/atAmTyYSLiwvvvPMOzZo1IzExkenTp1OvXj0mTZpEYmIigYGB5MiR45mXsReRtGHPnj00bNjwL7fHxMSkYmtExNZ0T5Bnoel78kIl76wsWLCAn3/+mdOnT9OzZ0/q1avHtWvXGDNmDMePH6djx45GMJWcRtGkTcmv7c2bN7lz5w5jxoxh3rx5ODk5AQ/qXGzYsIHGjRvTp0+fFCvtPHwOST/mz5+Pl5cXUVFRuLm5GdfRYrGwY8cOihUrRsGCBY39dZ0zh+HDhzN37lw8PT25du0ao0aNYujQoQCEhoYyduxYfvnlFxo3bmyszOjs7Kx7vEg6du/evb9dRbdo0aKp2BoRsTXdE+RZaHiCvFBJHVEvLy9CQkJo2bIlBQsWpHHjxowaNQofHx8++eQTJk6caIyqSSpynkSdlbQp6dqOHj2a0NBQbt68SY4cOYiNjTVCKV9fXwDCwsK4ffs2Pj4+ZM2a9ZFzSNr0V2FS1apVKVCgAD4+Pnh7extFKu/du4efnx/Nmzenf//+xv66zhlT8pGS58+fZ+/evcaCFNu3b2fw4MHcvXuXMWPG0Lx5cywWCwsWLODmzZt06tQJZ2dnYmNjeemll2z9UkTkGTk7O6uTKSIG3RPkWSiUkhdu69atrFq1ig0bNlC2bFm+//57Pv/8c2Mp0UKFCvHJJ58wbNgwzp49m6JotqQ9ya9PaGgo8+bNY8qUKezevZtdu3bRr18/pkyZYqxy4evrS3R0NH/++SevvPKKLZsuT8FqtRph0pIlSzh37hzu7u50796dN998kxYtWhAWFsaVK1fo27cvN2/eZObMmdy+fZvevXvbuPXyoiUPLKOjo7l58yalSpWiZMmSODo6UrRoURwdHenXrx8mk4nRo0fTsmVLEhMTmTdvHt27dycgIIACBQrY+JWIiIiIiC1p+p48dw+HSmvWrCEwMJBNmzaxYsUKPv74YyZPnkyvXr2Ijo7m999/p2TJkly8eJFcuXJhNpsVTKUDX375JSdOnCB//vxG7a8ZM2awZs0aihcvzqRJk/Dw8DD2Tz6qQtc2bUt+jUaNGsX06dN5++232b59Ow0aNGDmzJkUK1aMOXPmsGbNGnbt2kWpUqXw9PRkw4YNODg4aEpWJjF69Gi2bNlCXFwcZrOZsLAwI5COi4sjKCiIAQMG0L9/f6ZMmQLAf//7X8aPH0+BAgVYu3YtZrNZ9wQRERGRTEpzKuS5e7hzcevWLS5evMhXX31Fz549jUAKHhTF9fPz49q1a7z66qtGXRp1UNKW//u//2Pz5s3G4+PHj+Pv78/UqVOxWCzG8wMHDqRVq1acOnWKkSNHcunSJWObAqn0I+kaRUZG8v3337Nr1y62bt3KmTNn+Omnn+jTpw8///wzffr0YefOnURERLBp0yY2b96Mg4MDCQkJCqQyqOTv9wULFhAcHEzTpk2pW7cuP/30E1OnTuX+/fsAODk50a1bNyZMmMDBgwdJSEgAoFmzZvj4+DBz5kzs7Ox0TxARERHJxDRSSl6IOXPmsH79erZs2cIff/xBixYt2Lt3L1OmTGHIkCHAg/ozbdu2JVu2bAQHB6tjkkZdvXqVJUuW0L9/fxwdHQFISEhg5cqVfPbZZwBs27aNnDlzGsfMmjWLOXPm0LVrV0aMGGGTdsu/4+/vz/r168mWLRtLly4lW7ZsAJw+fZr/+7//o0SJEvj5+VGuXLkUx6moecb08CqZe/fuZceOHZQoUYK2bdsCsHLlSjp37syQIUPw9fXFwcEBgPv372Nvb4/JZNJqmyIiIiKSgnoO8kLkyJGDmzdvcuzYMbJnz06HDh0oW7Yse/fu5dChQ4SGhtKiRQvOnTvHokWLjFE0kvZ4eHgwdOhQHB0dmTx5MgsXLsTe3p727dvj7e2Ns7MzXbp04fr168Yx/fv3x9fXFy8vLxu2XP6Nd955h6NHj7J//37Onz8PPJjWV6xYMbZv326sonnq1KkUxymQyni6devGzp07gQeh4+nTp6levTrjx4/n6tWrxn7t2rVj6dKlTJs2jXHjxhEfHw+Ag4ODcY9XICUiIiIiyan3IP/a48KkqlWrcuvWLb788kvMZjPdunWjZ8+e3L59mxo1ajBp0iSyZMnCkSNHsLe3JzExUSOl0qCHr+3PP/9Mv379CAkJwc7OjtatW9OnTx+io6MfCabatGmDnZ0diYmJqd1seUrJp2TBg+tetWpV9uzZQ2xsLBMmTCAqKsoIFooWLcrGjRvJly+fVljJ4BISEnB2dqZmzZrAg9+VYsWKsW3bNhwdHQkPD0+x9HO7du1YtmwZEydOJDAwMMW5dI8XERERkYdp+p48Nw8XNl62bBlDhgzh66+/plKlSkY9oV9++YXcuXPj6uqq6Rxp2M8//4ynpyfZsmVj1KhRfPzxxzg4ODBt2jTmz5/P3Llz6dSpE4mJiaxatYr58+cTGxvLtm3bcHNzs3Xz5Qkln24XFhZGVFQUDg4O1KhRg0KFCnHgwAFq165N8+bN8ff3J1++fI/UBtOUvYzp4eu6cOFCnJycaNWqFc7OzmzevJnGjRvTo0cPxowZQ65cuYx9d+zYQY0aNXRvFxEREZG/pU+L8lxMmDCBX3/9lYYNG9KqVSsAatasScmSJdm/fz+VKlUiISEBBwcHihcvbnRoLRaLOi1p0LFjx6hfvz5jx47l+PHjzJs3jw4dOlCyZEn69++PxWKhd+/eAHTq1Im2bdty584dvv/+e1xcXGzcenkaSaGDl5cX69atw93dnWzZstG7d292797NW2+9xe7du6lRowZmsxlfX18KFSr02HNIxpJ0Xa1WK1arlcDAQGJiYnB2dqZRo0Y0bNiQ9evX895772EymRg9erQRTNWpUwd4tBaViIiIiEhy6knIM3l4gF2RIkW4cOECI0aMoEGDBuzYsYNcuXLRvHlzJk6cyJ07d4yit8lHWKgzmzaVLl2aDz/8kJEjRxIUFER4eDglS5YEIF++fAwcOJCPPvqIvn37GlP5unfvzrx584wVFCX9WLx4MUuWLGHFihUcOHCAVq1aERsby5kzZwCoWLEiO3fuZPny5SxevNjGrRVbMJvNhIeHkz9/fvz8/Pj666+5d+8ejRo1Yv369SxcuJDBgwdz48aNFMcpkBIRERGRv6NEQJ6axWJJMdLp7t27tGvXjnXr1rFq1Sri4+Px9vamVq1aFClSBBcXF6ZMmaKgIp1IqgFVqlQpALJmzcrx48dTFDROHkx17tyZLVu2pAgYFTamL6dOnaJr165UrFiR0NBQBgwYwPz582nXrh3R0dFcuXKFypUrc/z4cUaNGmXr5koqM5lMJCYm4ujoyLp16/D09GTSpEkpgqnly5cTFRVF1qxZbd1cEREREUlHVFNKnkryGiNTpkzh6NGjHD58mB49evD2229TpUoV4EE9kZUrV7J69Wqio6P54IMPWLhwoS2bLk/pxo0bmM1mPvvsM5YuXUr//v3p3Lkz7u7uxj63b98mMDCQfv36aUREOta/f3+jjlTHjh2ZMmUKPXv2NKZsXbx4kSFDhpAlSxZAU7Iyq6S6gfHx8TRt2pRr167h7e1No0aNjN8NUI0xEREREXlyCqXkmYwYMYJFixbh4+NDbGwsc+fOpXDhwgQFBZE7d25jvz179nD48GGFFunMw51Kb29vVq1axeDBg+nQoQM5c+akY8eO+Pv7kzdvXkBBRXrwV2FBQEAAM2bMICoqikmTJtGnTx8Abt26RYcOHahQoQI+Pj6p3VxJg5IHUy1atODYsWMsXryY2rVrP1IAX0RERETknyiUkqd25MgROnfuTGBgIFWqVGHfvn3UqlWLRYsW0blz50dW4Uui0CL9SR5iDB8+nNWrV1O5cmUuXrzITz/9xMWLF41aYZK2JX//hYeHY7FYcHJy4u233yYxMZFWrVqxa9cugoODKV++PDExMQwcOJBr167x7bff6r0rhqR7fFxcHJ988gmTJ09+7D1fREREROSfKJSSp3b48GE+/PBDIiIiWL16NR988IEx3efOnTuEh4dTtWpVsmXLZuumynOQPGScPn06J0+eJD4+noULF2Jvb/+XIaSkDZ06deLdd9+lQ4cOAAwePJjFixfj4uLC5cuXadGiBf7+/uTJk4f69etz+fJlIiMjKVOmDPb29nzzzTc4ODjoOmdgfzWC7u9GPj38JcP9+/cVUIuIiIjIU9NX3/LU7t27x927d406Q5MmTaJnz54AfPvtt4SEhFC0aFGFUulIbGwsL7300mO32dnZGZ3WQYMGpeiMavRb2nbt2jUA+vTpg4uLC+XKlWP9+vVs2rQJT09PLly4QLt27ejZsycrVqxg69atHD16lKioKPLnz0+ZMmUwm826zhlY8rDx2LFjuLi44Obmhru7OyaT6S+DqYcDSgVSIiIiIvIsNFJKnknTpk35+uuvmTZtGgMHDgQeBButWrXCycmJ1atXq9BtGrZjxw5q1aqF2WzGx8eHHDly0KtXr7+9Zkm3iqSOqsVi0ciZdODcuXNGsfpOnTqRmJjIvHnzjLDhxIkTVKtWjffff5/p06c/cryKVmdMPj4+VKlShXr16gHg5eXF6tWruX37NnXr1uX999+nUaNGwKMjppI/njZtGocPH2b58uWp/yJEREREJN3TV9/yVJI6Iz4+Pty4cYNp06bxyiuvcPPmTcLCwrh48SJHjx7FbDarM5tGXbp0ib59++Lq6kqVKlUICAjg8OHDT3Stkjqi9+7dS7HalqRdBQsWZPDgwdjZ2bFgwQKqVasGPHgvx8fHU7JkSSZOnMiECRMYMWIEOXPmTPG7oPdwxhMREcHGjRvZv38/Li4umEwm1qxZQ2BgIL/++ithYWHGIhYtW7ZMMWIqeSAVEBCAr68vs2fPtvErEhEREZH0SiOl5JlYLBbOnDmDn58fhw8fxt3dnWLFijF37lzs7e013ScNs1gsHD58mPr16xMXF8fu3bupUKEC8fHxODo6PvaY5B3R6dOns2jRIg4fPvyXU/4k7YmMjGT27NnMmjWLlStX0qZNG2NbcHAw06ZNY+/evbi5udmwlZJatmzZwuzZs7Gzs6NgwYK8+uqreHt7A3Do0CFmzZrFL7/8wvDhw2nRogWQcqrf/Pnz8fLyIigoyNguIiIiIvK0lBrIMzGbzRQvXpzg4GBu3LhB1qxZjREVCqTSpqSRa2azGXt7e7Jnz47JZGLQoEFs27aNl1566bHXLvmIt/nz5zNhwgRmzpypQCqdKVKkCIMGDSIuLo6OHTsSFxdH7dq1sbe3Z8WKFeTKlQtXV1dbN1NesKRgqX79+lgsFubMmUNISAjdu3c39qlYsSIDBgxg1qxZTJ48mbt379KpUycjkAoICMDLy4vAwEAFUiIiIiLyr2iklDyzpNEzyUOLv1utSWwn+TU6fvw42bNnJ0uWLJw4cYLevXuTJUsWdu7ciZOTk3HMnTt3ePnll43HSSMjAgMDadmyZaq/Bnk+zp8/z6RJkwgICCB79uy0b9+eiIgItm/fjoODg6bdZmDJr23S4gbh4eGMHz+e33//nfnz51O7dm1j/yNHjjB27Fhy5crFwoULgQeBVK9evVizZg3Nmze3yesQERERkYxDPQ8BHnRW/spf5ZZJ9UWSd2D/7jxiG8k7oqNHj6Zr1678+OOPuLm5UalSJaZOncrdu3epU6cOsbGxAHz88cesWrXKOEdAQADe3t4KpDKA/Pnz4+3tzZAhQ/jjjz+oUaMGu3btwsHBgYSEBAVSGVTy+4C/vz9eXl6cPXuWmjVrMmrUKIoVK4a/vz/h4eHGMeXLl+ezzz4jICAAgLi4OO7fv8/q1asVSImIiIjIc6GRUpKis7JmzRrOnz+Po6MjjRo1olChQsDjR0Alf27x4sVUrVqVYsWKpW7j5YmNGjWKRYsWsXDhQt566y2yZ88OPLj+e/bsoV+/fly7do3ixYtz7tw5IiMjsbe3JyQkhM6dO7NmzRpN1clATp06xaZNm+jbty/29vYa5ZhJeHt7s2TJEsaPH0+jRo3IkycP8KDG1KxZs0hISGDkyJFUr149xXFJ/05oeraIiIiIPE8KpcTg7e1NcHAwlSpV4ocffuCNN97ggw8+oFWrVkDKECr5nxcsWECPHj1Yv349jRs3tln75a/99NNPNG/enNmzZ1O/fn2io6O5cuUKe/bsoUSJElStWpWzZ88SGBiIxWJh/Pjx2NvbEx8fzzfffANAgwYNbPwq5HEeFyYlL0j9JJ52f0mfduzYQdeuXVm9ejVVqlQBUv7+bN26ldmzZ3Px4kUWLlxI2bJlbdlcEREREckE9HVnJpb8G+/Zs2ezYsUKNm7cSIUKFQgODuaDDz7gzp07JCQk0K5dO6N+lMlkMjoxSXWG1q5dq0AqDUualuXq6sru3bv58ssvCQ8P5+bNm7i7u+Pr60uTJk3w9fVNcYyjoyP169fXCJo0KvkoxytXrhAfH0++fPmMgOmvRj8lD6Fu3LhhjJqTjO3y5ct4eHhQunTpxwaR9erVIz4+nvDwcEqXLm2jVoqIiIhIZqLiIZlQr169OH36NPb29iQmJhITE8P58+fx9vamQoUKrFu3jkGDBjF27Fji4uLw8/Pjyy+/BB6suvdwIBUYGKj6ImnI4+p6vfbaa5jNZj788EPq1q0LwMSJEzlw4AAJCQlcvnz5kWOSAksFUmmP1WpNUc9t7Nix1KtXj0qVKlG2bFmWLl3KjRs3HnvtrFarEUYsWrSI8ePHEx0dnartF9uIiYnhzJkz3L9/Hzs7O+NLBovFwrZt2zh37hyNGzdm6tSpmM1m1QgUERERkRdOI6UymcjISL777jsaNmzItm3bKFSoEE5OTnTp0gVPT09OnjzJ8OHDGTt2LAMHDqRy5cq0bt2aiRMn4ubmZkzhmjlzJuPHjycoKEh1htKQ5CNnDh06ZHQ6K1WqxNGjR9mwYQPu7u5Uq1bN2M/NzU2dz3QmaZEBAD8/P+bMmcPMmTPx9PQkMDCQKVOmcOHCBXr37o2bm5txXPKRUwEBAfTt25cvv/wyxT6S/v3VCopVq1alQIEC+Pj44O3tjbu7OwD37t3Dz8+P5s2b079/f2N/Fb0XERERkRdNNaUyGYvFwtGjR/nkk0/45Zdf2LlzJ4UKFSIuLg4nJyeCg4OZN28emzZtIkeOHKxevZqQkBBKlCiBn58fZrOZCxcu0KxZMwYPHkz79u1t/ZLk/0seOHh7e7NixQpMJhNXrlyhffv2jB49msKFCwNw584dbt26xUcffcTly5c5dOiQagqlA6NGjcLT05N+/foBcP36dRo3bkznzp3p3bu3sZ+XlxehoaEEBgbyzjvvGAHWw6McFSpnPMnvA0uWLOHcuXO4u7vTvXt3HB0dGTduHGFhYRQrVoy+ffty8+ZNZs6cyZUrV/juu+9UxFxEREREUpW+Bs1E7t+/j9lspnz58nh5eZE3b14aN25MVFQUTk5OANy9e5d79+7x448/EhMTw7Jly6hSpQqTJk3CbDZjtVrx9PRk06ZNCqTSmKSO6Oeff05gYCArV65k69atbNiwgbCwMLy9vfntt98AWLhwIU2bNiUmJoaDBw9iZ2dHYmKiLZsv/+DWrVvs27ePNWvWEBQUBMArr7zC7du3jREtcXFxAEyePJmcOXMyZ84c4/jkgZS3tzeBgYEKpDKY5IHUqFGj6NWrF3v37qVPnz40a9aM06dPM27cODp37szvv//OW2+9xfDhw7FYLBw8eNCY0i0iIiIiklo0UioT8vX15dtvv+Xq1ascOXKEIkWKsGXLFgoXLszx48fp3Lkz0dHR3L9/n2zZsnH48GEcHBy0ZHw68f777+Ps7MwXX3xhXLOIiAiqV6/OwIED8fHx4datW4SGhtKlSxfs7Oy0zHsal3Qdr169Sp8+fbhx4wYdOnSge/fuNG7cmOjoaHbv3g1AfHw8jo6O9O7dm+joaJYtW2acJygoiP79+xMcHEzLli1t9XLkBYuMjKRfv374+PhQoUIFfv31V2rVqsVrr73GrFmzKFGiBAA//PADOXPmJFeuXJjNZt0HRERERCTVaaRUJjNnzhz8/f0ZNmwYX375JStWrCB37tzUqVOHM2fO8J///IeQkBAmTZqEr68vR44cwcHBgYSEBAVSadDDmfL9+/e5cOECsbGxxvb4+HjKlCnDuHHjWLlyJdevXydr1qx069bNGCGljmjallTzy8PDg8GDB5OYmMj8+fNZu3Ytvr6+nD9/nrZt2wIY0zCPHTtGjhw5gP8VRj9x4gQhISEKpDIwf39/unTpgtlspkiRIgAULlyY7du3c+rUKQYOHMj3338PQKlSpXj11VeNoua6D4iIiIhIatNIqUwkMTGRXr16AQ+KHCfZt28fffv25d69e2zZsoUCBQo8cpzqDaU9ya/Lr7/+iouLCx4eHixZsoTevXvz1VdfUadOHWOUzZw5cwgJCSE8PBxHR0cbt16exZAhQ4iMjOTSpUucPHmSPHnyMHDgQCOscnJyonDhwty8eZPbt2/zww8/YG9vbxS+1mjHjG///v3UrVuXl156iZ07d1K6dGnjup85c4b69euTI0cOli1bRvHixW3dXBERERHJ5DRSKgN7eEU1Ozs7zGYzR48eTfH822+/TbNmzTh16hT/+c9/uHDhwiPHSdoxb948IiIijOsyYsQI3nvvPUqWLImXlxcuLi588MEH9OnTh7CwMCwWC7dv32bDhg3kyZMHBwcHG78CeRZLliwhKCiIMWPGsGnTJn7++Wfy5s3L8uXLiY6OZu/evbRu3ZpixYpRr149I5BKSEgwak4pkMpYHr7HW61Wqlatyp49e4iNjWXChAlERUUZqzUWLVqUjRs3ki9fPooWLWqjVouIiIiI/I/G6mdgSR3R/fv3U7VqVQBq167NwYMHCQ4Opm3btjg7OwNQokQJWrduTYkSJciVK5fN2ix/7+zZs/j5+dGwYUO8vLw4ceIES5cu5fPPP+eHH34gLCyM8+fPU6VKFZo0aULjxo0pXLgwdnZ2ODk5cejQIaODqoAifYmMjKRkyZKUKVMGk8mEyWQyVs/79NNPcXV1xdfXN8UxmpqZcSWNfgMICwsjKioKBwcHatSoQfny5dmxYwe1a9fG3t4ef39/8uXLh9VqpUSJEqxdu/aRc4iIiIiI2IKm72VwERERlCtXjnHjxjFmzBji4uLo3LkzUVFRtG/fnjZt2mBnZ8eHH35IsWLFmDp1KqApe2lZREQEH374Ie+88w5ms5mSJUvSvXt3ANavX8/s2bPJli0bH330ER4eHhw8eBAXFxfatm2roubpUFKAOGnSJNauXcvu3btxdnbm/v37ODg4sGPHDpo2bUqBAgXw8/OjadOmCh0zES8vL9atW4e7uzvZsmUjPDyc3bt3U6FCBQ4dOkSNGjVo0aIFvr6+FCpUyNbNFRERERFJQV+RZnBlypRh7ty5+Pn5MX78eJycnFiyZAmvvfYawcHBFCpUiBo1anDmzBkmTZoEPOgEK5BKu8qUKUNAQAB79+4lKCiIP//809j23nvv0b9/f65fv87cuXOJi4vj448/pkOHDipqnk4lhUtNmjQhIiKCyZMnAxjTMOPi4qhTpw7NmjWjSZMmKY6RjG3x4sUsWbKEFStWcODAAVq1akVsbCxnzpwBoGLFiuzcuZPly5ezePFiG7dWRERERORR6p1mAj179sRsNhtFzseOHcvChQs5e/Yshw4d4uWXX6Zx48ZGaKFAKu0rV64cgYGBNGvWjE2bNlGnTh3efPNN4EF4YWdnh7e3N6GhoVSqVMk4Ttc2/XrjjTdYsGABH3/8MTExMbRp04bs2bMzZ84cSpUqxYQJEwBNycpMTp06RdeuXalYsSKhoaEMGDCA+fPn065dO6Kjo7l37x6VK1fm+PHjKmouIiIiImmSpu9lEMmn60ycOJHs2bPTo0ePFPvMnz+f3r174+fnh7e39yPnUCCV/hw7doxu3bpRoUIFBgwYwBtvvGFs279/P5UrV9Y1zWDWrl1L7969jRUU3d3dOXjwIA4ODpq2l8n079/fqCPVsWNHpkyZQs+ePbFarQQGBnLx4kWGDBlClixZADR1V0RERETSHH2dngFYLBajI3r58mXu3btHr169WLZsmbGP1Wqle/futG3blhEjRjB27NhHzqPwIv0pXbo0ixYt4siRI8ycOZMTJ04Y26pWrWqMfpOMo2XLlhw9epR169axdOlSDh06hIODAwkJCQqkMqiHV9lL8p///IfNmzfTsWNHJk2aRM+ePQG4ffs2a9eu5f79+0YgBSiQEhEREZE0RyOl0rnkU3WmTZvG2bNnadeuHTt37mTMmDEsXryYzp07G/t/8skn7Nu3D6vVyq5du9SJzSCOHj1Kjx49KFCgAJMnT1ZB40xGoxwzruSjm8LDw7FYLDg5OfH222+TmJhIq1at2LVrF8HBwZQvX56YmBgGDhzItWvX+PbbbxVEiYiIiEiappFS6VxSIOXt7Y2fnx/VqlUjX758eHl5MXLkSLp27cqSJUuIi4sjPj6eM2fOMGzYMHbv3o3JZEKZZMZQtmxZPv/8c1xdXSlQoICtmyOpTIFUxtOpUyeWL19uhEqDBw+mZcuWdOvWjdq1a9O+fXsuXLjAmjVrKFeuHJ988glFixala9euxMTEcODAAezt7TVSUkRERETSNI2UygB27NjBRx99xNKlS3n77beN52NiYpg+fTpjx46lXLlyxMTE4OTkxJEjR7C3t1f9mQwo6Zqq2LVI+nXt2jUGDRrExo0bWbx4MeXKlaNmzZqEhITg6enJhQsXaNeuHW+++SYrVqzA1dWVo0ePEhUVRf78+SlTpgxms1k1pEREREQkzVMolQEEBQXx2WefsXfvXrJmzfrI9j179rBlyxacnZ3x9vY2vj3X6IqMSWGjSPp37tw5PvvsM5YuXUqnTp1ITExk3rx5xvv7xIkTVKtWjffff5/p06c/cryCaRERERFJD/QVajqW1Dm5d+9eiikaVqvV2LZ69WrKli3Lp59+amzXt+cZmwIpkfSvYMGCDB48GDs7OxYsWEC1atWAB/f3+Ph4SpYsycSJE5kwYQIjRowgZ86cKUIoBVIiIiIikh7oU2s6lhQ+1KpVi9OnTzNjxgzjebPZzJ07dwgJCWHr1q0pjlMgJSKS9hUqVIh+/frx0UcfsW3bNr788kvMZjNOTk4AODk5kTVrVl566SWFUCIiIiKSLimdyABef/115s6dS9++fbl58yaNGzfG0dERPz8/Ll++TI8ePWzdRBEReQZFihRh0KBBxMXF0bFjR+Li4qhduzb29vasWLGCXLly4erqautmioiIiIg8E9WUyiCsVivr16+nf//+JCYmkjVrVvLkycOGDRtwcHBQDSkRkXTs/PnzTJo0iYCAALJnz0779u2JiIhg+/btODg4qIaUiIiIiKRLCqUymD/++IPbt29jsVgoUqSIVmASEckgfvvtN+bOncuUKVNYs2YNLVq0AFQnUERERETSL4VSGZy+PRcRyThOnTrFpk2b6Nu3L/b29lptU0RERETSNYVSIiIiqexxYdLTTrPWtGwRERERSe80hEZERCQVWSwWI5C6cuUKUVFRAEbA9FffFSUmJhp/vnHjhgIpEREREUn3FEqJiIikAqvVitVqNaZUjx07lnr16lGpUiXKli3L0qVLuXHjxmOn41mtViOEWrRoEePHjyc6OjpV2y8iIiIi8rwplBIREUkFycMmPz8/5syZg5eXF0uXLuX1119nypQpBAQEPBI2JZ/qFxAQQK9evahVqxZubm6p2n4RERERkedNNaVEREReoFGjRuHp6Um/fv0AuH79Oo0bN6Zz58707t3b2M/Ly4vQ0FACAwN55513jGl8SYHU/Pnz8fLyIigoyFh5T0REREQkPdNIKRERkRfk1q1b7Nu3jzVr1hAUFATAK6+8wu3bt41pfHFxcQBMnjyZnDlzMmfOHOP45IGUt7c3gYGBCqREREREJMNQKCUiIvICWK1WsmbNyqpVq/Dw8GDZsmUsWrQIe3t7ChcuzPLlywFwcnIiPj4egLJly2Jvbw/8L5AKCgpi6NChLFq0iJYtW9rmxYiIiIiIvAAKpURERF4Ai8UCgIeHB4MHDyYxMZH58+ezdu1afH19OX/+PG3btgX+t/LesWPHyJEjB/C/wugnTpwgJCREgZSIiIiIZDiqKSUiIvICDRkyhMjISC5dusTJkyfJkycPAwcONMIqJycnChcuzM2bN7l9+zY//PAD9vb2WCwWzGZzikLnIiIiIiIZiUIpERGRF2TJkiUMHDiQ7du3U6BAAeLi4nj//feJj4/ngw8+oG7dunzxxRdER0eTNWtWRo8ejb29PQkJCcY0PhERERGRjEqfeEVERF6QyMhISpYsSZkyZTCZTJhMJmP1vE8//RRXV1d8fX1THJOYmKhASkREREQyBdWUEhERec6SBiE7OzsTFxdHXFwcJpOJ+/fvkzdvXiZOnMilS5cYPXo0X331VYpjkupLiYiIiIhkdAqlREREnrOkGlBNmjQhIiKCyZMnA+Dg4ABAXFwcderUoVmzZjRp0iTFMSIiIiIimYXmB4iIiLwgb7zxBgsWLODjjz8mJiaGNm3akD17dubMmUOpUqWYMGECgFHUXEREREQkM1GhcxERkRds7dq19O7dG0dHRwDc3d05ePAgDg4OWl1PRERERDIthVIiIiKp4OLFi1y4cIE7d+7wzjvvYGdnp1X2RERERCRTUyglIiJiA4mJiSpqLiIiIiKZmkIpERERERERERFJdaqqKiIiIiIiIiIiqU6hlIiIiIiIiIiIpDqFUiIiIiIiIiIikuoUSomIiIiIiIiISKpTKCUiIiIiIiIiIqlOoZSIiIiIiIiIiKQ6hVIiIiIiIiIiIpLqFEqJiIiIiIiIiEiqUyglIiIiIiIiIiKpTqGUiIiIiIiIiIikuv8HkuO3r3EMptoAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -1012,9 +908,15 @@ "\n", " axes[0].bar(available_methods, means, yerr=stds, capsize=5, color=colors, alpha=0.8)\n", " axes[0].set_ylabel('Time (ms)')\n", - " axes[0].set_title('Mean Execution Time by Method')\n", + " axes[0].set_title('Mean Execution Time by Method\\n(graph truncated for readability)')\n", " axes[0].tick_params(axis='x', rotation=45)\n", "\n", + " # Truncate y-axis to make differences easier to see\n", + " min_mean = min(means)\n", + " max_mean = max(means)\n", + " margin = (max_mean - min_mean) * 2\n", + " axes[0].set_ylim(min_mean - margin, max_mean + margin)\n", + "\n", " # Highlight cuda_event vs host_time with truncated y-axis for readability\n", " if 'cuda_event' in results and 'host_time' in results:\n", " cuda_mean = results['cuda_event']['mean']\n", @@ -1072,15 +974,15 @@ "[Profiling] Using timing method: cuda_event\n", "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 15\n", "\n", - "First trial: 0.3454 ms\n", - "Mean of all trials: 0.3444 ms\n", - "Mean without first: 0.3443 ms\n", - "First trial overhead: 0.3%\n" + "First trial: 0.3660 ms\n", + "Mean of all trials: 0.3455 ms\n", + "Mean without first: 0.3440 ms\n", + "First trial overhead: 6.4%\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1184,14 +1086,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Standard benchmark on tricky kernel: 0.0978 ms\n" + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", + "Standard benchmark on tricky kernel: 0.1880 ms\n" ] } ], @@ -1270,8 +1166,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Robust benchmark on tricky kernel: 21.5401 ms\n", - "Robust benchmark on normal kernel: 21.4700 ms\n" + "Robust benchmark on tricky kernel: 21.6298 ms\n", + "Robust benchmark on normal kernel: 21.5420 ms\n" ] } ], @@ -1312,37 +1208,19 @@ "Side-Stream Detection Experiment:\n", "============================================================\n", "[Profiling] Using timing method: cuda_event\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 10\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 10\n", "[Profiling] Using timing method: host_time\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 10\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 10\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 10\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 10\n", "\n", - "Tricky kernel with cuda_event: 0.3070 ms (FOOLED!)\n", + "Tricky kernel with cuda_event: 0.4400 ms (FOOLED!)\n", "Tricky kernel with host_time: 21.8000 ms (CORRECT)\n", - "Normal kernel with host_time: 21.6000 ms (reference)\n" + "Normal kernel with host_time: 21.5000 ms (reference)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1524,42 +1402,12 @@ "Size Time (ms) TFLOPS % of TF32 Peak \n", "-----------------------------------------------------------------\n", "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", - "1024 0.0647 33.19 3.4 %\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2048 0.3440 49.94 5.0 %\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "4096 2.6700 51.48 5.2 %\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "1024 0.0648 33.14 3.4 %\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", + "2048 0.3440 49.94 5.0 %\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", + "4096 2.6800 51.28 5.2 %\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", "8192 21.4000 51.38 5.2 %\n", "\n", "Note: PyTorch uses TF32 tensor cores by default on Ampere+ GPUs.\n", From 7deed13297566f1fb79ea27046fa0db203f42779 Mon Sep 17 00:00:00 2001 From: PaliC Date: Sun, 4 Jan 2026 11:17:42 -0800 Subject: [PATCH 07/24] revision --- notebooks/benchmarking.ipynb | 41 +++++++++++++++++++----------------- 1 file changed, 22 insertions(+), 19 deletions(-) diff --git a/notebooks/benchmarking.ipynb b/notebooks/benchmarking.ipynb index a9f3ba15..9d654910 100644 --- a/notebooks/benchmarking.ipynb +++ b/notebooks/benchmarking.ipynb @@ -20,7 +20,7 @@ "\n", "> **Note on outputs:** The outputs in this notebook were generated on an **NVIDIA H200 GPU** (90MB L2 cache, 4.8 TB/s memory bandwidth). Your results may vary depending on your hardware. The H200's large cache means cache effects are less dramatic than on older GPUs like A100 (40MB L2) or consumer cards.\n", "\n", - "## TL;DR — How to Benchmark Correctly\n", + "## TL;DR \u2014 How to Benchmark Correctly\n", "\n", "Benchmarking on GPUs requires a strict protocol to avoid measuring Python overhead or caching artifacts. To get reliable numbers, you must:\n", "\n", @@ -29,17 +29,17 @@ "3. **Flush the L2 Cache:** Between *every* sample, flush the cache to force a cold cache state (simulating real-world inference).\n", "4. **Use Device Timers:** Use `torch.cuda.Event` instead of `time.time()` to measure execution on the GPU, not the CPU driver.\n", "5. **Aggregate Robustly:** Aggregate over many samples to filter out jitter/outliers.\n", - "6. **Wait for sidestreams to finish:** Ensure no side-streams are running or wait for all of them to finish before reporting a time.\n", + "6. **Wait for sidestreams to finish:** Ensure no side-streams are running or wait for all of them to finish before reporting a time. (This is more relevant for llm-generated code)\n", "\n", - "*Pro-Tip:* **KernelBench's timing module** (`src/timing.py`) implements all these best practices. Use `get_timing_function(\"cuda_event\")` for trusted code or `get_timing_function(\"host_time\")` for evaluating untrusted/agent-generated code.\n", + "*Pro-Tip:* There are a bunch of off-the-shelf solutions that work pretty well such as [Triton's do_bench](https://triton-lang.org/main/python-api/generated/triton.testing.do_bench.html). Over at KernelBench we also released a [timing module](https://github.com/ScalingIntelligence/KernelBench/blob/main/src/kernelbench/timing.py) that implements all these best practices. \n", "\n", "-----\n", "\n", - "If are using an LLM agent to write GPU kernels (and evaluating against something like say [Kernel Bench](https://github.com/ScalingIntelligence/KernelBench)), or just trying to optimize a custom GPU kernel, you are eventually going to ask: **\"How fast is this thing?\"**\n", + "If you are using an LLM agent to write GPU kernels (and evaluating against something like say [Kernel Bench](https://github.com/ScalingIntelligence/KernelBench)), or just trying to optimize a custom GPU kernel, you are eventually going to ask: **\"How fast is this thing?\"**\n", "\n", - "This notebook is heavily inspired by [this great guide](https://www.youtube.com/watch?v=1i7dxoAfKOU) from the **GPU MODE** community and the practical \"footguns\" (traps) encountered while building benchmarking harnesses for LLM-generated code. Our goal here is simplicity and keeping things Pythonic—for more advanced techniques, see the footnotes.\n", + "This notebook is heavily inspired by [this great guide](https://www.youtube.com/watch?v=1i7dxoAfKOU) from the **GPU MODE** community and the practical \"footguns\" (traps) encountered while building benchmarking harnesses for GPU kernels. Our goal here is simplicity and keeping things Pythonic\u2014for more advanced techniques, see the footnotes.\n", "\n", - "We won't just list best practices. Instead, we are going to build a benchmarking harness from scratch, make every common mistake, debug why the numbers are wrong, and iterate our way to a robust solution. So let's start things out by doing the most naive thing by using `time.time()`!" + "We are going to build a benchmarking harness from scratch, make every common mistake, debug why the numbers are wrong, and iterate our way to a robust solution. So let's start things out by doing the most naive thing by using `time.time()`!" ] }, { @@ -116,7 +116,10 @@ "source": [ "## The Journey: Benchmarking a Matrix Multiplication\n", "\n", - "Let's define a simple workload to test. We want to measure the performance of a standard Matrix Multiplication." + "Let's define a simple workload to test. We want to measure the performance of a standard Matrix Multiplication.\n", + "\n", + "> **Why `torch.matmul`?** Under the hood, `torch.matmul` calls optimized CUDA kernels (cuBLAS), so we're effectively measuring real GPU kernel performance. This lets us focus on benchmarking methodology without getting distracted by kernel implementation details.\n", + "" ] }, { @@ -219,7 +222,7 @@ }, "source": [ "**The Problem:**\n", - "Wait, less than 1ms? That seems impossibly fast for a 8192² matrix multiplication involving over 1 trillion floating-point operations.[¹](#footnote-1)\n", + "Wait, less than 1ms? That seems impossibly fast for an 8192\u00b2 matrix multiplication involving over 1 trillion floating-point operations.[\u00b9](#footnote-1)\n", "\n", "**What happened?**\n", "GPUs are **asynchronous**. When you call `torch.matmul`, the CPU doesn't actually do the math. It simply queues a \"launch kernel\" command to the GPU and moves on immediately. Our timer didn't measure the matrix multiplication; it measured how long it took Python to place an order in the queue.\n", @@ -233,7 +236,7 @@ "---\n", "\n", "\n", - "¹ **Why impossible?** The [H200](https://www.nvidia.com/en-us/data-center/h200/) peaks at 989 TFLOPS for TF32 Tensor Cores. At that rate: 1.1 TFLOP ÷ 989 TFLOP/s = **1.11ms minimum**. Anything under 1ms is physically impossible." + "\u00b9 **Why impossible?** The [H200](https://www.nvidia.com/en-us/data-center/h200/) peaks at 989 TFLOPS for TF32 Tensor Cores. At that rate: 1.1 TFLOP \u00f7 989 TFLOP/s = **1.11ms minimum**. Anything under 1ms is physically impossible." ] }, { @@ -344,10 +347,10 @@ "source": [ "### Attempt 4: Handling the \"Cold Start\"\n", "\n", - "Notice Run 0 is noticably slower than the rest. The first time you run a PyTorch function (and similarly launching a cuda kernel), the framework does a lot of heavy lifting which could include: allocating memory, initializing cuBLAS/cuDNN workspaces, lazy kernel loading, and compiling kernels (especially if using `torch.compile` or Triton). This \"Cold Start\" penalty is a one-time cost that shouldn't be included in your performance metrics.\n", + "Notice Run 0 is noticeably slower than the rest. The first time you run a PyTorch function (and similarly when launching a CUDA kernel), the framework does a lot of heavy lifting which could include: allocating memory, initializing cuBLAS/cuDNN workspaces, lazy kernel loading, and compiling kernels (especially if using `torch.compile` or Triton). This \"Cold Start\" penalty is a one-time cost that shouldn't be included in your performance metrics.\n", "\n", "**The Fix:**\n", - "We need to perform **Warmup Runs**—running the kernel a few times to settle the system state before we start measuring." + "We need to perform **Warmup Runs**\u2014running the kernel a few times to settle the system state before we start measuring." ] }, { @@ -1060,7 +1063,7 @@ "source": [ "## The \"Agent\" Trap: Reward Hacking via Hidden Streams\n", "\n", - "When evaluating LLM-generated kernels (like with [Kernel Bench](https://github.com/ScalingIntelligence/KernelBench)), you're not just fighting measurement noise—you're fighting an optimizer that may inadvertently discover exploits in your harness.\n", + "When evaluating LLM-generated kernels (like with [Kernel Bench](https://github.com/ScalingIntelligence/KernelBench)), you're not just fighting measurement noise\u2014you're fighting an optimizer that may inadvertently discover exploits in your harness.\n", "\n", "One such exploit: launching work on a **side stream** to make the kernel appear instantaneous." ] @@ -1142,7 +1145,7 @@ "timing_fn = get_timing_function(\"host_time\")\n", "```\n", "\n", - "The trade-off: `host_time` includes some CPU overhead in the measurement. However, note that host_time should be pretty similar to sync_time. Therefore, if both times are within a some percent of each other, you can be pretty sure that the kernel is running correctly and score using sync_time." + "The trade-off: `host_time` includes some CPU overhead in the measurement. However, note that host_time should be pretty similar to sync_time. Therefore, if both times are within some percent of each other, you can be pretty sure that the kernel is running correctly and score using sync_time." ] }, { @@ -1318,7 +1321,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "✓ Correctness verified!\n", + "\u2713 Correctness verified!\n", "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", "Kernel time: 0.0648 ms\n" ] @@ -1340,7 +1343,7 @@ " f\"Kernel output doesn't match reference! \"\n", " f\"Max difference: {max_diff:.6f}\"\n", " )\n", - " print(\"✓ Correctness verified!\")\n", + " print(\"\u2713 Correctness verified!\")\n", " return True\n", "\n", "# Always verify before benchmarking\n", @@ -1360,7 +1363,7 @@ "\n", "It is also important to sanity check the results whether it is to see how well we are doing, or to see if our results are physically possible.\n", "\n", - "To answer this, we convert our millisecond timings into **TFLOPS** (Tera Floating-Point Operations Per Second) and compare against the hardware's theoretical maximum—often called the **\"speed of light\"** or **roofline**.\n", + "To answer this, we convert our millisecond timings into **TFLOPS** (Tera Floating-Point Operations Per Second) and compare against the hardware's theoretical maximum\u2014often called the **\"speed of light\"** or **roofline**.\n", "\n", "### Understanding Roofline Analysis\n", "\n", @@ -1370,8 +1373,8 @@ "\n", "**Key formulas:**\n", "- **Arithmetic Intensity** = FLOPs / Bytes accessed\n", - "- **Theoretical Peak FLOPS** = Clock speed × Cores × FLOPs/cycle\n", - "- **Theoretical Peak Bandwidth** = Memory clock × Bus width × 2 (for DDR)\n", + "- **Theoretical Peak FLOPS** = Clock speed \u00d7 Cores \u00d7 FLOPs/cycle\n", + "- **Theoretical Peak Bandwidth** = Memory clock \u00d7 Bus width \u00d7 2 (for DDR)\n", "\n", "For matrix multiplication of two $N \\times N$ matrices:\n", "- **FLOPs** = $2N^3$ (one multiply + one add per output element, summed $N$ times)\n", @@ -1558,4 +1561,4 @@ }, "nbformat": 4, "nbformat_minor": 0 -} +} \ No newline at end of file From c7eeb6695c81b6240d1395e3943fac4052adf749 Mon Sep 17 00:00:00 2001 From: PaliC Date: Sun, 4 Jan 2026 12:37:29 -0800 Subject: [PATCH 08/24] revision --- notebooks/benchmarking.ipynb | 418 ++--------------------------------- 1 file changed, 19 insertions(+), 399 deletions(-) diff --git a/notebooks/benchmarking.ipynb b/notebooks/benchmarking.ipynb index 9d654910..0d36b1f0 100644 --- a/notebooks/benchmarking.ipynb +++ b/notebooks/benchmarking.ipynb @@ -15,32 +15,7 @@ "metadata": { "id": "_PCU0gUyzX2c" }, - "source": [ - "# A Practical Guide to GPU Benchmarking\n", - "\n", - "> **Note on outputs:** The outputs in this notebook were generated on an **NVIDIA H200 GPU** (90MB L2 cache, 4.8 TB/s memory bandwidth). Your results may vary depending on your hardware. The H200's large cache means cache effects are less dramatic than on older GPUs like A100 (40MB L2) or consumer cards.\n", - "\n", - "## TL;DR \u2014 How to Benchmark Correctly\n", - "\n", - "Benchmarking on GPUs requires a strict protocol to avoid measuring Python overhead or caching artifacts. To get reliable numbers, you must:\n", - "\n", - "1. **Warmup:** Run the kernel ~10-50 times first to settle compilation and memory allocators.\n", - "2. **Sample Extensively:** Don't trust one run. Collect 100+ samples to build a statistical distribution.\n", - "3. **Flush the L2 Cache:** Between *every* sample, flush the cache to force a cold cache state (simulating real-world inference).\n", - "4. **Use Device Timers:** Use `torch.cuda.Event` instead of `time.time()` to measure execution on the GPU, not the CPU driver.\n", - "5. **Aggregate Robustly:** Aggregate over many samples to filter out jitter/outliers.\n", - "6. **Wait for sidestreams to finish:** Ensure no side-streams are running or wait for all of them to finish before reporting a time. (This is more relevant for llm-generated code)\n", - "\n", - "*Pro-Tip:* There are a bunch of off-the-shelf solutions that work pretty well such as [Triton's do_bench](https://triton-lang.org/main/python-api/generated/triton.testing.do_bench.html). Over at KernelBench we also released a [timing module](https://github.com/ScalingIntelligence/KernelBench/blob/main/src/kernelbench/timing.py) that implements all these best practices. \n", - "\n", - "-----\n", - "\n", - "If you are using an LLM agent to write GPU kernels (and evaluating against something like say [Kernel Bench](https://github.com/ScalingIntelligence/KernelBench)), or just trying to optimize a custom GPU kernel, you are eventually going to ask: **\"How fast is this thing?\"**\n", - "\n", - "This notebook is heavily inspired by [this great guide](https://www.youtube.com/watch?v=1i7dxoAfKOU) from the **GPU MODE** community and the practical \"footguns\" (traps) encountered while building benchmarking harnesses for GPU kernels. Our goal here is simplicity and keeping things Pythonic\u2014for more advanced techniques, see the footnotes.\n", - "\n", - "We are going to build a benchmarking harness from scratch, make every common mistake, debug why the numbers are wrong, and iterate our way to a robust solution. So let's start things out by doing the most naive thing by using `time.time()`!" - ] + "source": "# A Practical Guide to GPU Benchmarking\n\n> **Note on outputs:** The outputs in this notebook were generated on an **NVIDIA H200 GPU** (90MB L2 cache, 4.8 TB/s memory bandwidth). Your results will vary depending on your hardware. The H200's large cache means cache effects are less dramatic than on older GPUs like A100 (40MB L2) or consumer cards.\n\n## TL;DR — How to Benchmark Correctly\n\nBenchmarking on GPUs requires a strict protocol to avoid measuring Python overhead or caching artifacts. To get reliable numbers, you must:\n\n1. **Warmup:** Run the kernel ~10-50 times first to settle compilation and memory allocators.\n2. **Sample Extensively:** Don't trust one run. Collect 100+ samples to build a statistical distribution.\n3. **Flush the L2 Cache:** Between *every* sample, flush the cache to force a cold cache state (simulating real-world inference).\n4. **Use Device Timers:** Use `torch.cuda.Event` instead of `time.time()` to measure execution on the GPU, not the CPU driver.\n5. **Aggregate Robustly:** Use median to filter out jitter and outliers.\n6. **Wait for side-streams:** Ensure all CUDA streams finish before stopping the clock. (Essential for evaluating LLM-generated code.)\n\n*Pro-Tip:* Off-the-shelf solutions like [Triton's do_bench](https://triton-lang.org/main/python-api/generated/triton.testing.do_bench.html) handle most of this. KernelBench also provides a [timing module](https://github.com/ScalingIntelligence/KernelBench/blob/main/src/kernelbench/timing.py) implementing these best practices.\n\n-----\n\nWhether you're using an LLM to write GPU kernels or hand-optimizing CUDA, you'll eventually ask: **\"How fast is this thing?\"**\n\nThis notebook is based on [this excellent guide](https://www.youtube.com/watch?v=1i7dxoAfKOU) from the **GPU MODE** community. We'll build a benchmarking harness from scratch, make every common mistake, and iterate toward a robust solution.\n\nLet's learn by doing it wrong first." }, { "cell_type": "code", @@ -113,14 +88,7 @@ "metadata": { "id": "kjWByrwvzX2f" }, - "source": [ - "## The Journey: Benchmarking a Matrix Multiplication\n", - "\n", - "Let's define a simple workload to test. We want to measure the performance of a standard Matrix Multiplication.\n", - "\n", - "> **Why `torch.matmul`?** Under the hood, `torch.matmul` calls optimized CUDA kernels (cuBLAS), so we're effectively measuring real GPU kernel performance. This lets us focus on benchmarking methodology without getting distracted by kernel implementation details.\n", - "" - ] + "source": "## Setup: A Matrix Multiplication\n\nWe need a workload to benchmark. Matrix multiplication is ideal: `torch.matmul` calls cuBLAS under the hood, and is easy to understand." }, { "cell_type": "code", @@ -220,24 +188,7 @@ "metadata": { "id": "gw4NGYRmzX2h" }, - "source": [ - "**The Problem:**\n", - "Wait, less than 1ms? That seems impossibly fast for an 8192\u00b2 matrix multiplication involving over 1 trillion floating-point operations.[\u00b9](#footnote-1)\n", - "\n", - "**What happened?**\n", - "GPUs are **asynchronous**. When you call `torch.matmul`, the CPU doesn't actually do the math. It simply queues a \"launch kernel\" command to the GPU and moves on immediately. Our timer didn't measure the matrix multiplication; it measured how long it took Python to place an order in the queue.\n", - "\n", - "To fix this, we need to:\n", - "1. **Synchronize** - Force the CPU to wait for the GPU with `torch.cuda.synchronize()`\n", - "2. **Use CUDA Events** - Record timestamps directly on the GPU to avoid CPU overhead\n", - "\n", - "Let's compare these approaches to see the difference.\n", - "\n", - "---\n", - "\n", - "\n", - "\u00b9 **Why impossible?** The [H200](https://www.nvidia.com/en-us/data-center/h200/) peaks at 989 TFLOPS for TF32 Tensor Cores. At that rate: 1.1 TFLOP \u00f7 989 TFLOP/s = **1.11ms minimum**. Anything under 1ms is physically impossible." - ] + "source": "Less than 1ms for an 8192² matmul? That's over 1 trillion FLOPs. Something's wrong.[¹](#footnote-1)\n\nGPUs are **asynchronous**. When you call `torch.matmul`, the CPU doesn't do the math instead it queues a \"launch kernel\" command and moves on immediately. We didn't measure the matrix multiplication; we measured how long it took Python to place an order.\n\nTo fix this, we need to:\n1. **Synchronize** — Force the CPU to wait for the GPU with `torch.cuda.synchronize()`\n2. **Use CUDA Events** — Record timestamps directly on the GPU to avoid CPU overhead\n\n---\n\n\n¹ **Why impossible?** The [H200](https://www.nvidia.com/en-us/data-center/h200/) peaks at 989 TFLOPS for TF32. At that rate: 1.1 TFLOP ÷ 989 TFLOP/s = **1.11ms minimum**. Anything under 1ms is physically impossible." }, { "cell_type": "markdown", @@ -344,14 +295,7 @@ "metadata": { "id": "BkfaaDawzX2i" }, - "source": [ - "### Attempt 4: Handling the \"Cold Start\"\n", - "\n", - "Notice Run 0 is noticeably slower than the rest. The first time you run a PyTorch function (and similarly when launching a CUDA kernel), the framework does a lot of heavy lifting which could include: allocating memory, initializing cuBLAS/cuDNN workspaces, lazy kernel loading, and compiling kernels (especially if using `torch.compile` or Triton). This \"Cold Start\" penalty is a one-time cost that shouldn't be included in your performance metrics.\n", - "\n", - "**The Fix:**\n", - "We need to perform **Warmup Runs**\u2014running the kernel a few times to settle the system state before we start measuring." - ] + "source": "### Attempt 4: Handling the \"Cold Start\"\n\nNotice Run 0 is slower. The first execution triggers one-time initialization: memory allocation, cuBLAS/cuDNN workspace setup, lazy kernel loading, JIT compilation, etc. This \"cold start\" penalty shouldn't be included in your performance metrics.\n\n**The Fix:** Run the kernel a few times first (**warmup**) to settle the system state before measuring." }, { "cell_type": "code", @@ -406,15 +350,7 @@ "metadata": { "id": "OR3uOh7kzX2i" }, - "source": [ - "### Attempt 5: The Single Sample Fallacy (Variance)\n", - "\n", - "Relying on a single sample after warmup is bad science. Operating systems are noisy; background processes interrupt the CPU, and GPU clocks fluctuate thermally. A single measurement is anecdotal, not statistical.\n", - "\n", - "#### Visualizing the Jitter\n", - "\n", - "Let's run the benchmark 100 times and plot every single run. You will clearly see the \"Cold Start\" spike and the noise floor of the OS." - ] + "source": "### Attempt 5: The Single Sample Fallacy (Variance)\n\nA single sample isn't reliable. Operating systems are noisy: background processes interrupt the CPU, GPU clocks fluctuate with temperature. One measurement is anecdotal, not statistical.\n\nLet's run the benchmark 100 times and visualize the jitter." }, { "cell_type": "code", @@ -485,22 +421,11 @@ "metadata": { "id": "hX_-OpftzX2i" }, - "source": [ - "You will see a massive dot at $x=0$ (the cold start), followed by a cloud of dots hovering around the \"true\" time. This visualizes why we need **Warmup** (to skip $x=0$) and **Statistics** (to handle the cloud).\n", - "\n", - "Notice how the **Mean** is pulled upward by the outliers, while the **Median** represents the typical case more accurately. When possible, we should use the **Median** as our final metric.\n", - "\n", - "### Attempt 6: The \"Robust\" Harness (Flushing Cache)\n", - "\n", - "Modern GPUs have large L2 caches (40MB-192MB depending on architecture). If your data fits in the cache, subsequent iterations in your loop will skip the slow VRAM access, artificially inflating your speed. In production, data usually streams in from VRAM, so this \"hot cache\" benchmark is misleading.\n", - "\n", - "**The Fix:**\n", - "We must **flush the L2 cache** between *every single sample*. We do this by writing to a tensor large enough to completely evict the cache contents. KernelBench uses a ~256MB tensor to safely cover all GPU architectures, including the largest caches (e.g., Blackwell at ~192MB)." - ] + "source": "The plot shows a spike at $x=0$ (cold start) and a cloud of variance around the true time. The **Mean** gets pulled up by outliers; the **Median** is more robust. Prefer median as your final metric.\n\n### Attempt 6: The \"Robust\" Harness (Flushing Cache)\n\nGPUs have L2 caches (40-192MB) that can hide slow global memory access. If your data fits in the cache, subsequent iterations in your loop will skip the slow global memory access, artificially inflating your speed. In production, data streams in fresh each time.\n\n**The Fix:** Flush the L2 cache between *every* sample by writing to a large tensor (~256MB covers all GPU architectures right now)." }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": { "execution": { "iopub.execute_input": "2025-12-17T21:24:44.487140Z", @@ -511,34 +436,12 @@ "id": "Kj5azcpxzX2j" }, "outputs": [], - "source": [ - "# KernelBench provides utilities to flush the L2 cache\n", - "# This is important for cold cache measurements that simulate real-world inference\n", - "\n", - "def clear_l2_cache(device=DEVICE):\n", - " \"\"\"Flush L2 cache by writing to a large tensor.\n", - " \n", - " L2 cache sizes vary by GPU, so we use 256MB to cover all cases.\n", - " \"\"\"\n", - " dummy = torch.empty((32, 1024, 1024), dtype=torch.int64, device=device) # 256MB\n", - " dummy.fill_(1901) # Force write to thrash cache\n", - " del dummy\n", - "\n", - "# KernelBench also provides clear_l2_cache_triton() for cross-platform support\n", - "# (works on both NVIDIA and AMD GPUs via Triton's device abstraction)\n", - "from src.timing import clear_l2_cache_triton" - ] + "source": "# KernelBench provides clear_l2_cache() which we imported earlier.\n# Here's what it does under the hood:\n\ndef clear_l2_cache(device=DEVICE):\n \"\"\"Flush L2 cache by writing to a large tensor.\"\"\"\n dummy = torch.empty((32, 1024, 1024), dtype=torch.int64, device=device) # 256MB\n dummy.fill_(1901) # Force write to evict cache\n del dummy\n\n# KernelBench also provides clear_l2_cache_triton() for AMD GPU support\nfrom src.timing import clear_l2_cache_triton" }, { "cell_type": "markdown", "metadata": {}, - "source": [ - "#### Why does flushing the cache matter?\n", - "\n", - "Let's see the cache effect in action. We'll benchmark the same operation twice:\n", - "1. **Without** cache flushing between runs (data stays in L2 cache)\n", - "2. **With** cache flushing between runs (data must be fetched from VRAM each time)" - ] + "source": "#### Why does flushing the cache matter?\n\nLet's see the cache effect in action. We'll benchmark the same operation twice:\n1. **Without** cache flushing between runs (data stays in L2 cache)\n2. **With** cache flushing between runs (data must be fetched from global memory each time)" }, { "cell_type": "code", @@ -651,22 +554,7 @@ "metadata": { "id": "FAaH1cdBzX2j" }, - "source": [ - "### Putting it all together\n", - "\n", - "We have now discovered that a robust benchmark requires:\n", - "\n", - "1. Device Synchronization\n", - "2. CUDA Events (to avoid CPU overhead)\n", - "3. Warmup Runs (to avoid initialization costs)\n", - "4. Multiple Samples (to handle variance)\n", - "5. Cache Flushing (to simulate VRAM access)\n", - "6. Median/Mean Aggregation (to ignore jitter)\n", - "\n", - "Writing this boilerplate every time is painful. We've packaged all these lessons into **KernelBench's timing module**, which provides multiple timing methods for different use cases. There are also other robust implementations available, such as Triton's `do_bench` [function](https://triton-lang.org/main/python-api/generated/triton.testing.do_bench.html).\n", - "\n", - "The default `cuda_event` method in KernelBench implements all of the above automatically, plus an additional insight: **`discard_first`** - discarding the first few trials after warmup, which often still have some initialization overhead." - ] + "source": "### Putting it all together\n\nWe have now discovered that a robust benchmark requires:\n\n1. Device Synchronization\n2. CUDA Events (to avoid CPU overhead)\n3. Warmup Runs (to avoid initialization costs)\n4. Multiple Samples (to handle variance)\n5. Cache Flushing (to simulate global memory access)\n6. Median/Mean Aggregation (to ignore jitter)\n\nWriting this boilerplate every time is tedious. KernelBench's timing module packages all these best practices, as does Triton's [`do_bench`](https://triton-lang.org/main/python-api/generated/triton.testing.do_bench.html).\n\nKernelBench's `cuda_event` method handles all of the above automatically—plus **`discard_first`**, which drops the first few post-warmup trials that often still have initialization overhead." }, { "cell_type": "code", @@ -722,88 +610,12 @@ "metadata": { "id": "MsZrCYQRzX2j" }, - "source": [ - "*Note: KernelBench also wraps Triton's `do_bench` if you prefer adaptive trial counts. See the timing methods comparison below for details.*\n", - "\n", - "---\n", - "\n", - "## KernelBench's Timing Methods Explained\n", - "\n", - "Now that we've built up a robust benchmarking harness from first principles, let's explore KernelBench's timing module in depth. We'll examine:\n", - "- **All 4 timing methods** and when to use each\n", - "- **The `discard_first` parameter** and why it improves measurement consistency\n", - "- **How `host_time` detects side-stream exploits** in untrusted code\n", - "\n", - "KernelBench's timing module provides **4 timing methods**, each designed for different use cases:\n", - "\n", - "| Method | Use Case | Catches Side-Streams | Cold Cache | Trial Control |\n", - "|--------|----------|---------------------|------------|---------------|\n", - "| `cuda_event` | Default, trusted code | No | Yes | Explicit |\n", - "| `host_time` | Untrusted code, agent evals | **Yes** | Yes | Explicit |\n", - "| `do_bench` | Triton-style / robust adaptive | No | Yes | Adaptive (time-budget) |\n", - "| `do_bench_impl` | do_bench implementation for inference and trial control | No | Yes | Explicit |\n", - "\n", - "### Method Details\n", - "\n", - "**`cuda_event`** (Default)\n", - "- Uses `torch.cuda.Event` for GPU-side timing\n", - "- Most accurate for pure kernel time measurement\n", - "- Clears L2 cache before each trial for cold-cache performance\n", - "- Use for trusted code where you control the kernel implementation\n", - "\n", - "**`host_time`** (For Untrusted Code)\n", - "- Uses **both** `time.perf_counter()` (host) and `torch.cuda.Event` (device) timing\n", - "- Compares the two: if they differ significantly, the CUDA event time is likely invalid (e.g., side-stream exploit)\n", - "- Falls back to host time when discrepancy detected, ensuring correctness\n", - "- Waits for ALL streams via `torch.cuda.synchronize()`\n", - "- **Essential for evaluating untrusted/agent-generated code**\n", - "\n", - "**`do_bench`** (Triton's Adaptive Benchmarking)\n", - "- Wraps Triton's `triton.testing.do_bench`\n", - "- Uses fixed time budgets: 25ms warmup, 100ms for repetitions\n", - "- Trial count is automatic based on kernel runtime\n", - "- **Note:** `num_warmup`, `num_trials`, `discard_first` parameters are ignored\n", - "\n", - "**`do_bench_impl`** (Transparent Implementation)\n", - "- Custom implementation mirroring Triton's do_bench\n", - "- Gives you explicit control over `num_warmup` and `num_trials`\n", - "- Useful when you need do_bench's approach but with specific trial counts\n", - "\n", - "### Key Parameters\n", - "\n", - "All timing functions share a common interface:\n", - "\n", - "```python\n", - "timing_fn(\n", - " kernel_fn, # Function to time\n", - " args, # List of arguments to pass\n", - " num_warmup=3, # Warmup iterations before timing\n", - " num_trials=10, # Number of timing samples to collect\n", - " discard_first=1, # Drop first N trials after warmup\n", - " device=\"cuda:0\", # Explicit GPU device selection\n", - " verbose=True # Print per-trial timing info\n", - ") -> list[float] # Returns list of elapsed times in ms\n", - "```\n", - "\n", - "### Why `discard_first`?\n", - "\n", - "Even after warmup, the first few timing trials can be affected by:\n", - "- PyTorch's lazy tensor allocation finalizing\n", - "- cuDNN autotuning (still settling optimal algorithms)\n", - "- Driver state initialization\n", - "- First access to data structures\n", - "\n", - "Setting `discard_first=1` (the default) improves measurement consistency. Let's visualize this effect:" - ] + "source": "---\n\n## KernelBench's Timing Methods\n\nKernelBench provides **4 timing methods** for different use cases:\n\n| Method | Use Case | Catches Side-Streams | Cold Cache | Trial Control |\n|--------|----------|---------------------|------------|---------------|\n| `cuda_event` | Default, trusted code | No | Yes | Explicit |\n| `host_time` | Untrusted code, agent evals | **Yes** | Yes | Explicit |\n| `do_bench` | Triton-style adaptive | No | Yes | Adaptive (time-budget) |\n| `do_bench_impl` | do_bench with explicit trial control | No | Yes | Explicit |\n\n**Key difference:** `host_time` waits for ALL streams via `torch.cuda.synchronize()`, catching side-stream exploits. Use it for evaluating LLM-generated code.\n\n### Common Interface\n\n```python\ntiming_fn(\n kernel_fn, # Function to time\n args, # List of arguments to pass\n num_warmup=3, # Warmup iterations before timing\n num_trials=10, # Number of timing samples to collect\n discard_first=1, # Drop first N trials after warmup\n device=\"cuda:0\", # GPU device\n verbose=True # Print per-trial timing info\n) -> list[float] # Returns elapsed times in ms\n```\n\n**Note:** `do_bench` ignores `num_warmup`, `num_trials`, and `discard_first`—it uses fixed time budgets instead.\n\n### Why `discard_first`?\n\nEven after warmup, the first few trials can have residual initialization overhead (lazy allocation, cuDNN autotuning, etc.). Setting `discard_first=1` (default) improves consistency." }, { "cell_type": "markdown", "metadata": {}, - "source": [ - "# Comparing All 4 Timing Methods\n", - "\n", - "Let's see how the different timing methods compare on the same kernel. Each method has trade-offs between precision, features, and overhead." - ] + "source": "## Comparing All 4 Timing Methods\n\nLet's see how the different timing methods compare on the same kernel. Each method has trade-offs between precision, features, and overhead." }, { "cell_type": "code", @@ -1060,13 +872,7 @@ "metadata": { "id": "HwsjlhAazX2j" }, - "source": [ - "## The \"Agent\" Trap: Reward Hacking via Hidden Streams\n", - "\n", - "When evaluating LLM-generated kernels (like with [Kernel Bench](https://github.com/ScalingIntelligence/KernelBench)), you're not just fighting measurement noise\u2014you're fighting an optimizer that may inadvertently discover exploits in your harness.\n", - "\n", - "One such exploit: launching work on a **side stream** to make the kernel appear instantaneous." - ] + "source": "## The Side-Stream Exploit\n\nWhen evaluating LLM-generated kernels, you're not just fighting measurement noise—you're fighting an optimizer that may discover exploits in your benchmarking harness.\n\nThe exploit: launch work on a **side stream** to make the kernel appear instantaneous." }, { "cell_type": "code", @@ -1113,40 +919,7 @@ "metadata": { "id": "3HXns_XizX2j" }, - "source": [ - "**The Issue:**\n", - "Standard benchmarking tools (including `do_bench`) record events on the *current default stream*.\n", - "\n", - "1. Benchmark starts timer on Stream A (the default stream).\n", - "2. Agent launches work on Stream B and returns immediately.\n", - "3. Benchmark stops timer on Stream A.\n", - "\n", - "Since Stream A had no work, the timer reports `~0.00ms`, while Stream B is still churning away in the background.\n", - "\n", - "**Why this matters for evals:**\n", - "If your reward signal is \"lower time = better score,\" an agent that discovers this pattern will be rewarded for producing *broken* code. The kernel \"runs\" instantly because you never measured it at all.\n", - "\n", - "**Mitigations:**\n", - "- **Wall-clock + full device sync:** Trade precision for correctness (catches all streams, but includes CPU overhead)\n", - "- **Static analysis:** Reject submissions that create `torch.cuda.Stream()` objects\n", - "- **Manual inspection:** For high-stakes evals, benchmark kernels in isolation outside the automated harness\n", - "\n", - "### How KernelBench Addresses This\n", - "\n", - "KernelBench's timing module provides the **`host_time`** method specifically designed for evaluating untrusted code:\n", - "\n", - "**Use `torch.cuda.synchronize()`** before AND after timing - this waits for ALL streams on the device, not just the default stream\n", - "\n", - "```python\n", - "# For trusted code (faster, but can be fooled)\n", - "timing_fn = get_timing_function(\"cuda_event\")\n", - "\n", - "# For untrusted/agent code (catches side-streams)\n", - "timing_fn = get_timing_function(\"host_time\")\n", - "```\n", - "\n", - "The trade-off: `host_time` includes some CPU overhead in the measurement. However, note that host_time should be pretty similar to sync_time. Therefore, if both times are within some percent of each other, you can be pretty sure that the kernel is running correctly and score using sync_time." - ] + "source": "**What happened:**\n\nStandard benchmarking tools (including `do_bench`) only record events on the default stream. So:\n\n1. Benchmark starts timer on Stream A (the default)\n2. Kernel launches work on Stream B and returns immediately\n3. Benchmark stops timer on Stream A\n\nStream A had no work, so the timer reports `~0ms`. Stream B is still running in the background.\n\n**Why this matters:** If your reward signal is \"lower time = better score,\" an agent that discovers this pattern gets rewarded for *broken* code.\n\n### How KernelBench Addresses This\n\nKernelBench's `host_time` method catches this exploit:\n- Uses `torch.cuda.synchronize()` to wait for ALL streams, not just the default\n- Compares host and device timings to detect discrepancies\n\n```python\n# For trusted code (faster, but can be fooled)\ntiming_fn = get_timing_function(\"cuda_event\")\n\n# For untrusted/agent code (catches side-streams)\ntiming_fn = get_timing_function(\"host_time\")\n```\n\nThe trade-off: `host_time` includes CPU overhead. If `host_time` and `cuda_event` agree within a few percent, the kernel is likely honest.\n\n**Other mitigations:** Static analysis to reject submissions that create `torch.cuda.Stream()` objects." }, { "cell_type": "code", @@ -1294,11 +1067,7 @@ "metadata": { "id": "Uq4qvl8FzX2j" }, - "source": [ - "## Correctness Before Speed\n", - "\n", - "A kernel that runs in 0.1ms but produces garbage is worthless. Before you start optimizing, **always verify correctness** against a reference implementation." - ] + "source": "## Correctness Before Speed\n\nA blazing-fast kernel that returns nonsense is just a very efficient bug. Always verify your kernel produces correct outputs before benchmarking." }, { "cell_type": "code", @@ -1321,7 +1090,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "\u2713 Correctness verified!\n", + "✓ Correctness verified!\n", "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", "Kernel time: 0.0648 ms\n" ] @@ -1343,7 +1112,7 @@ " f\"Kernel output doesn't match reference! \"\n", " f\"Max difference: {max_diff:.6f}\"\n", " )\n", - " print(\"\u2713 Correctness verified!\")\n", + " print(\"✓ Correctness verified!\")\n", " return True\n", "\n", "# Always verify before benchmarking\n", @@ -1358,163 +1127,14 @@ { "cell_type": "markdown", "metadata": {}, - "source": [ - "## Computing TFLOPS: Are We Hitting the Speed of Light?\n", - "\n", - "It is also important to sanity check the results whether it is to see how well we are doing, or to see if our results are physically possible.\n", - "\n", - "To answer this, we convert our millisecond timings into **TFLOPS** (Tera Floating-Point Operations Per Second) and compare against the hardware's theoretical maximum\u2014often called the **\"speed of light\"** or **roofline**.\n", - "\n", - "### Understanding Roofline Analysis\n", - "\n", - "The Roofline Model helps you understand whether your kernel is:\n", - "- **Compute-bound**: Limited by the GPU's arithmetic throughput (FLOPS)\n", - "- **Memory-bound**: Limited by memory bandwidth (GB/s)\n", - "\n", - "**Key formulas:**\n", - "- **Arithmetic Intensity** = FLOPs / Bytes accessed\n", - "- **Theoretical Peak FLOPS** = Clock speed \u00d7 Cores \u00d7 FLOPs/cycle\n", - "- **Theoretical Peak Bandwidth** = Memory clock \u00d7 Bus width \u00d7 2 (for DDR)\n", - "\n", - "For matrix multiplication of two $N \\times N$ matrices:\n", - "- **FLOPs** = $2N^3$ (one multiply + one add per output element, summed $N$ times)\n", - "- **Bytes** = $3N^2 \\times \\text{sizeof(dtype)}$ (read A, read B, write C)\n", - "- **Arithmetic Intensity** = $\\frac{2N^3}{3N^2 \\times 4} = \\frac{N}{6}$ for float32\n", - "\n", - "Large matrix multiplications are highly compute-bound (high arithmetic intensity), so we expect to approach the compute roofline. For a deeper dive into roofline analysis and speed-of-light calculations, see the excellent [JAX Scaling Book chapter on Roofline](https://jax-ml.github.io/scaling-book/roofline/)." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "execution": { - "iopub.execute_input": "2025-12-17T21:24:53.932346Z", - "iopub.status.busy": "2025-12-17T21:24:53.932227Z", - "iopub.status.idle": "2025-12-17T21:24:56.741833Z", - "shell.execute_reply": "2025-12-17T21:24:56.740706Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Matrix Multiplication Performance\n", - "=================================================================\n", - "Size Time (ms) TFLOPS % of TF32 Peak \n", - "-----------------------------------------------------------------\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", - "1024 0.0648 33.14 3.4 %\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", - "2048 0.3440 49.94 5.0 %\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", - "4096 2.6800 51.28 5.2 %\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", - "8192 21.4000 51.38 5.2 %\n", - "\n", - "Note: PyTorch uses TF32 tensor cores by default on Ampere+ GPUs.\n", - "H200 TF32 theoretical peak: 989.0 TFLOPS\n", - "\n", - "For roofline analysis details, see: https://jax-ml.github.io/scaling-book/roofline/\n" - ] - } - ], - "source": [ - "def get_tflops(n, time_ms):\n", - " \"\"\"Calculate achieved TFLOPS for matrix multiplication.\"\"\"\n", - " flops = 2 * n ** 3 # Multiply-add for each of N^2 output elements\n", - " tflops = flops / (time_ms * 1e-3) / 1e12\n", - " return tflops\n", - "\n", - "# Theoretical peaks vary by GPU and precision\n", - "# PyTorch uses TF32 by default on Ampere+ GPUs for matmul\n", - "GPU_PEAK_TFLOPS = {\n", - " 'A100': {'fp32': 19.5, 'tf32': 156.0, 'fp16': 312.0},\n", - " 'H100': {'fp32': 67.0, 'tf32': 989.0, 'fp16': 1979.0},\n", - " 'H200': {'fp32': 67.0, 'tf32': 989.0, 'fp16': 1979.0},\n", - "}\n", - "\n", - "# Use TF32 peak since PyTorch defaults to TF32 on Ampere+\n", - "PEAK_TFLOPS = 989.0 # H200 TF32 peak\n", - "\n", - "# Benchmark at different sizes\n", - "print(\"Matrix Multiplication Performance\")\n", - "print(\"=\" * 65)\n", - "print(f\"{'Size':<8} {'Time (ms)':<12} {'TFLOPS':<12} {'% of TF32 Peak':<15}\")\n", - "print(\"-\" * 65)\n", - "\n", - "for size in [1024, 2048, 4096, 8192]:\n", - " a_test, b_test = get_data(size)\n", - " time_ms = final_benchmark(simple_mm, a_test, b_test)\n", - " tflops = get_tflops(size, time_ms)\n", - " efficiency = (tflops / PEAK_TFLOPS) * 100\n", - " print(f\"{size:<8} {time_ms:<12.4f} {tflops:<12.2f} {efficiency:<15.1f}%\")\n", - "\n", - "print(f\"\\nNote: PyTorch uses TF32 tensor cores by default on Ampere+ GPUs.\")\n", - "print(f\"H200 TF32 theoretical peak: {PEAK_TFLOPS} TFLOPS\")\n", - "print(f\"\\nFor roofline analysis details, see: https://jax-ml.github.io/scaling-book/roofline/\")" - ] + "source": "## Sanity Checking: Roofline Analysis\n\nOnce you have reliable timing numbers, you'll want to sanity-check them: Are these results physically possible? How close am I to the hardware's theoretical maximum?\n\nThis is where **roofline analysis** comes in. It helps you understand whether your kernel is **compute-bound** (limited by FLOPS) or **memory-bound** (limited by bandwidth), and how much headroom you have left.\n\nWe won't cover it in detail here, but the [JAX Scaling Book chapter on Roofline](https://jax-ml.github.io/scaling-book/roofline/) is an excellent resource." }, { "cell_type": "markdown", "metadata": { "id": "zcYVXCkUzX2k" }, - "source": [ - "## Conclusion\n", - "\n", - "Benchmarking on GPUs is fundamentally different from CPUs. The asynchronous nature of kernel launches, the hidden state of the L2 cache, and the noise of the OS scheduler all conspire to give you the wrong numbers.\n", - "\n", - "### What We Learned\n", - "\n", - "Through our journey, we discovered that robust GPU benchmarking requires:\n", - "1. **Device Synchronization** - Wait for GPU work to complete\n", - "2. **CUDA Events** - Use GPU-side timestamps, not CPU clocks\n", - "3. **Warmup Runs** - Settle compilation and memory allocators\n", - "4. **Multiple Samples** - Build statistical distributions\n", - "5. **L2 Cache Flushing** - Measure cold cache (realistic) performance\n", - "6. **Median Aggregation** - Filter out OS jitter and outliers\n", - "7. **Side-Stream Detection** - Catch work on non-default streams\n", - "\n", - "### What KernelBench Provides\n", - "\n", - "We've implemented all these best practices in **KernelBench's timing module** (`src/timing.py`):\n", - "\n", - "| Function | Purpose |\n", - "|----------|---------|\n", - "| `get_timing_function(method)` | Factory returning timing function by name |\n", - "| `clear_l2_cache(device)` | L2 cache flushing utility |\n", - "| `get_timing_stats(times)` | Statistical aggregation (mean, std, min, max) |\n", - "\n", - "**Four timing methods for different use cases:**\n", - "- **`cuda_event`** - Default for trusted code (fastest, GPU-side timing)\n", - "- **`host_time`** - For untrusted/agent code (catches all streams)\n", - "- **`do_bench`** - Triton-style adaptive trial counts\n", - "- **`do_bench_impl`** - Transparent do_bench with explicit control\n", - "\n", - "**Key parameters:**\n", - "- `num_warmup`, `num_trials`, `discard_first`, `device`, `verbose`\n", - "\n", - "### Recommended Usage\n", - "\n", - "```python\n", - "from src.timing import get_timing_function, get_timing_stats\n", - "\n", - "# For trusted code\n", - "timing_fn = get_timing_function(\"cuda_event\")\n", - "\n", - "# For agent evaluations (catches side-streams)\n", - "timing_fn = get_timing_function(\"host_time\")\n", - "\n", - "# Run benchmark\n", - "times = timing_fn(kernel, args, num_warmup=10, num_trials=100, device=\"cuda:0\")\n", - "stats = get_timing_stats(times, device=\"cuda:0\")\n", - "print(f\"Mean: {stats['mean']:.4f}ms, Std: {stats['std']:.4f}ms\")\n", - "```\n", - "\n", - "Happy optimizing!" - ] + "source": "## Conclusion\n\nBenchmarking on GPUs is fundamentally different from CPUs. The asynchronous nature of kernel launches, the hidden state of the L2 cache, and the noise of the OS scheduler all conspire to give you wrong numbers if you're not careful.\n\n### KernelBench's Timing Module\n\nWe've packaged all these best practices in `src/timing.py`:\n\n| Function | Purpose |\n|----------|---------|\n| `get_timing_function(method)` | Returns timing function by name |\n| `clear_l2_cache(device)` | L2 cache flushing |\n| `get_timing_stats(times)` | Statistical aggregation (mean, std, min, max) |\n\n```python\nfrom src.timing import get_timing_function, get_timing_stats\n\n# For trusted code\ntiming_fn = get_timing_function(\"cuda_event\")\n\n# For agent evaluations (catches side-streams)\ntiming_fn = get_timing_function(\"host_time\")\n\n# Run benchmark\ntimes = timing_fn(kernel, args, num_warmup=10, num_trials=100, device=\"cuda:0\")\nstats = get_timing_stats(times, device=\"cuda:0\")\nprint(f\"Mean: {stats['mean']:.4f}ms, Std: {stats['std']:.4f}ms\")\n```\n\nHappy optimizing!" }, { "cell_type": "markdown", From c349dd1e69f04f43c1637eb55609571b1a01dee6 Mon Sep 17 00:00:00 2001 From: Julian Reed Date: Sun, 8 Mar 2026 23:56:53 -0700 Subject: [PATCH 09/24] Add small clarifications and explanations to benchmarking guide --- notebooks/benchmarking.ipynb | 277 ++++++++++++++++++++++++++++++++--- 1 file changed, 253 insertions(+), 24 deletions(-) diff --git a/notebooks/benchmarking.ipynb b/notebooks/benchmarking.ipynb index 0d36b1f0..ac677052 100644 --- a/notebooks/benchmarking.ipynb +++ b/notebooks/benchmarking.ipynb @@ -15,7 +15,32 @@ "metadata": { "id": "_PCU0gUyzX2c" }, - "source": "# A Practical Guide to GPU Benchmarking\n\n> **Note on outputs:** The outputs in this notebook were generated on an **NVIDIA H200 GPU** (90MB L2 cache, 4.8 TB/s memory bandwidth). Your results will vary depending on your hardware. The H200's large cache means cache effects are less dramatic than on older GPUs like A100 (40MB L2) or consumer cards.\n\n## TL;DR — How to Benchmark Correctly\n\nBenchmarking on GPUs requires a strict protocol to avoid measuring Python overhead or caching artifacts. To get reliable numbers, you must:\n\n1. **Warmup:** Run the kernel ~10-50 times first to settle compilation and memory allocators.\n2. **Sample Extensively:** Don't trust one run. Collect 100+ samples to build a statistical distribution.\n3. **Flush the L2 Cache:** Between *every* sample, flush the cache to force a cold cache state (simulating real-world inference).\n4. **Use Device Timers:** Use `torch.cuda.Event` instead of `time.time()` to measure execution on the GPU, not the CPU driver.\n5. **Aggregate Robustly:** Use median to filter out jitter and outliers.\n6. **Wait for side-streams:** Ensure all CUDA streams finish before stopping the clock. (Essential for evaluating LLM-generated code.)\n\n*Pro-Tip:* Off-the-shelf solutions like [Triton's do_bench](https://triton-lang.org/main/python-api/generated/triton.testing.do_bench.html) handle most of this. KernelBench also provides a [timing module](https://github.com/ScalingIntelligence/KernelBench/blob/main/src/kernelbench/timing.py) implementing these best practices.\n\n-----\n\nWhether you're using an LLM to write GPU kernels or hand-optimizing CUDA, you'll eventually ask: **\"How fast is this thing?\"**\n\nThis notebook is based on [this excellent guide](https://www.youtube.com/watch?v=1i7dxoAfKOU) from the **GPU MODE** community. We'll build a benchmarking harness from scratch, make every common mistake, and iterate toward a robust solution.\n\nLet's learn by doing it wrong first." + "source": [ + "# A Practical Guide to GPU Benchmarking\n", + "\n", + "> **Note on outputs:** The outputs in this notebook were generated on an **NVIDIA H200 GPU** (90MB L2 cache, 4.8 TB/s memory bandwidth). Your results will vary depending on your hardware. The H200's large cache means cache effects are less dramatic than on older GPUs like A100 (40MB L2) or consumer cards.\n", + "\n", + "## TL;DR — How to Benchmark Correctly\n", + "\n", + "Benchmarking on GPUs requires a strict protocol to avoid measuring Python overhead or caching artifacts. To get reliable numbers, you must:\n", + "\n", + "1. **Warmup:** Run the kernel ~10-50 times first to settle compilation and memory allocators.\n", + "2. **Sample Extensively:** Don't trust one run. Collect 100+ samples to build a statistical distribution.\n", + "3. **Flush the L2 Cache:** Between *every* sample, flush the cache to force a cold cache state (simulating real-world inference).\n", + "4. **Use Device Timers:** Use `torch.cuda.Event` instead of `time.time()` to measure execution on the GPU, not the CPU driver.\n", + "5. **Aggregate Robustly:** Use median to filter out jitter and outliers.\n", + "6. **Wait for side-streams:** Ensure all CUDA streams finish before stopping the clock. (Launching work in another stream is a very common reward hack, so waiting for all streams is essential for evaluating LLM-generated code.)\n", + "\n", + "*Pro-Tip:* Off-the-shelf solutions like [Triton's do_bench](https://triton-lang.org/main/python-api/generated/triton.testing.do_bench.html) handle most of this. KernelBench also provides a [timing module](https://github.com/ScalingIntelligence/KernelBench/blob/main/src/kernelbench/timing.py) implementing these best practices.\n", + "\n", + "-----\n", + "\n", + "Whether you're using an LLM to write GPU kernels or hand-optimizing CUDA, you'll eventually ask: **\"How fast is this thing?\"**\n", + "\n", + "This notebook is based on [this excellent guide](https://www.youtube.com/watch?v=1i7dxoAfKOU) from the **GPU MODE** community. We'll build a benchmarking harness from scratch, make every common mistake, and iterate toward a robust solution.\n", + "\n", + "Let's learn by doing it wrong first." + ] }, { "cell_type": "code", @@ -88,7 +113,11 @@ "metadata": { "id": "kjWByrwvzX2f" }, - "source": "## Setup: A Matrix Multiplication\n\nWe need a workload to benchmark. Matrix multiplication is ideal: `torch.matmul` calls cuBLAS under the hood, and is easy to understand." + "source": [ + "## Setup: A Matrix Multiplication\n", + "\n", + "We need a workload to benchmark. Matrix multiplication is ideal: `torch.matmul` calls cuBLAS under the hood, and is easy to understand." + ] }, { "cell_type": "code", @@ -188,7 +217,20 @@ "metadata": { "id": "gw4NGYRmzX2h" }, - "source": "Less than 1ms for an 8192² matmul? That's over 1 trillion FLOPs. Something's wrong.[¹](#footnote-1)\n\nGPUs are **asynchronous**. When you call `torch.matmul`, the CPU doesn't do the math instead it queues a \"launch kernel\" command and moves on immediately. We didn't measure the matrix multiplication; we measured how long it took Python to place an order.\n\nTo fix this, we need to:\n1. **Synchronize** — Force the CPU to wait for the GPU with `torch.cuda.synchronize()`\n2. **Use CUDA Events** — Record timestamps directly on the GPU to avoid CPU overhead\n\n---\n\n\n¹ **Why impossible?** The [H200](https://www.nvidia.com/en-us/data-center/h200/) peaks at 989 TFLOPS for TF32. At that rate: 1.1 TFLOP ÷ 989 TFLOP/s = **1.11ms minimum**. Anything under 1ms is physically impossible." + "source": [ + "Less than 1ms for an 8192² matmul? That's over 1 trillion FLOPs. Something's wrong.[¹](#footnote-1)\n", + "\n", + "GPUs are **asynchronous**. When you call `torch.matmul`, the CPU doesn't do the math instead it queues a \"launch kernel\" command and moves on immediately. We didn't measure the matrix multiplication; we measured how long it took Python to place an order.\n", + "\n", + "To fix this, we need to:\n", + "1. **Synchronize** — Force the CPU to wait for the GPU with `torch.cuda.synchronize()`\n", + "2. **Use CUDA Events** — Record timestamps directly on the GPU to avoid CPU overhead\n", + "\n", + "---\n", + "\n", + "\n", + "¹ **Why impossible?** The [H200](https://www.nvidia.com/en-us/data-center/h200/) peaks at 989 TFLOPS for TF32. At that rate: 1.1 TFLOP ÷ 989 TFLOP/s = **1.11ms minimum**. Anything under 1ms is physically impossible." + ] }, { "cell_type": "markdown", @@ -295,7 +337,13 @@ "metadata": { "id": "BkfaaDawzX2i" }, - "source": "### Attempt 4: Handling the \"Cold Start\"\n\nNotice Run 0 is slower. The first execution triggers one-time initialization: memory allocation, cuBLAS/cuDNN workspace setup, lazy kernel loading, JIT compilation, etc. This \"cold start\" penalty shouldn't be included in your performance metrics.\n\n**The Fix:** Run the kernel a few times first (**warmup**) to settle the system state before measuring." + "source": [ + "### Attempt 4: Handling the \"Cold Start\"\n", + "\n", + "Notice Run 0 is slower. The first execution triggers one-time initialization: memory allocation, cuBLAS/cuDNN workspace setup, lazy kernel loading, JIT compilation, etc. This \"cold start\" penalty shouldn't be included in your performance metrics.\n", + "\n", + "**The Fix:** Run the kernel a few times first (**warmup**) to settle the system state before measuring." + ] }, { "cell_type": "code", @@ -325,7 +373,7 @@ } ], "source": [ - "def benchmark_warmup(func, *args, warmup_iters=30, benchmark_iters=3):\n", + "def benchmark_warmup(func, *args, warmup_iters=3, benchmark_iters=3):\n", " \"\"\"Better: Includes warmup to avoid cold-start penalty.\"\"\"\n", " # Warmup phase\n", " for _ in range(warmup_iters):\n", @@ -350,7 +398,13 @@ "metadata": { "id": "OR3uOh7kzX2i" }, - "source": "### Attempt 5: The Single Sample Fallacy (Variance)\n\nA single sample isn't reliable. Operating systems are noisy: background processes interrupt the CPU, GPU clocks fluctuate with temperature. One measurement is anecdotal, not statistical.\n\nLet's run the benchmark 100 times and visualize the jitter." + "source": [ + "### Attempt 5: The Single Sample Fallacy (Variance)\n", + "\n", + "A single sample isn't reliable. Operating systems are noisy: background processes interrupt the CPU, GPU clocks fluctuate with temperature. One measurement is anecdotal, not statistical.\n", + "\n", + "Let's run the benchmark 100 times and visualize the jitter." + ] }, { "cell_type": "code", @@ -421,7 +475,15 @@ "metadata": { "id": "hX_-OpftzX2i" }, - "source": "The plot shows a spike at $x=0$ (cold start) and a cloud of variance around the true time. The **Mean** gets pulled up by outliers; the **Median** is more robust. Prefer median as your final metric.\n\n### Attempt 6: The \"Robust\" Harness (Flushing Cache)\n\nGPUs have L2 caches (40-192MB) that can hide slow global memory access. If your data fits in the cache, subsequent iterations in your loop will skip the slow global memory access, artificially inflating your speed. In production, data streams in fresh each time.\n\n**The Fix:** Flush the L2 cache between *every* sample by writing to a large tensor (~256MB covers all GPU architectures right now)." + "source": [ + "The plot shows a spike at $x=0$ (cold start) and a cloud of variance around the true time. The **Mean** gets pulled up by outliers; the **Median** is more robust. Prefer median as your final metric.\n", + "\n", + "### Attempt 6: The \"Robust\" Harness (Flushing Cache)\n", + "\n", + "GPUs have L2 caches (40-192MB) that can hide slow global memory access. If your data fits in the cache, subsequent iterations in your loop will skip the slow global memory access, artificially inflating your speed. In production (inference), data streams in fresh each time.\n", + "\n", + "**The Fix:** Flush the L2 cache between *every* sample by writing to a large tensor (~256MB covers all GPU architectures right now)." + ] }, { "cell_type": "code", @@ -436,12 +498,30 @@ "id": "Kj5azcpxzX2j" }, "outputs": [], - "source": "# KernelBench provides clear_l2_cache() which we imported earlier.\n# Here's what it does under the hood:\n\ndef clear_l2_cache(device=DEVICE):\n \"\"\"Flush L2 cache by writing to a large tensor.\"\"\"\n dummy = torch.empty((32, 1024, 1024), dtype=torch.int64, device=device) # 256MB\n dummy.fill_(1901) # Force write to evict cache\n del dummy\n\n# KernelBench also provides clear_l2_cache_triton() for AMD GPU support\nfrom src.timing import clear_l2_cache_triton" + "source": [ + "# KernelBench provides clear_l2_cache() which we imported earlier.\n", + "# Here's what it does under the hood:\n", + "\n", + "def clear_l2_cache(device=DEVICE):\n", + " \"\"\"Flush L2 cache by writing to a large tensor.\"\"\"\n", + " dummy = torch.empty((32, 1024, 1024), dtype=torch.int64, device=device) # 256MB\n", + " dummy.fill_(1901) # Force write to evict cache\n", + " del dummy\n", + "\n", + "# KernelBench also provides clear_l2_cache_triton() for AMD GPU support\n", + "from src.timing import clear_l2_cache_triton" + ] }, { "cell_type": "markdown", "metadata": {}, - "source": "#### Why does flushing the cache matter?\n\nLet's see the cache effect in action. We'll benchmark the same operation twice:\n1. **Without** cache flushing between runs (data stays in L2 cache)\n2. **With** cache flushing between runs (data must be fetched from global memory each time)" + "source": [ + "#### Why does flushing the cache matter?\n", + "\n", + "Let's see the cache effect in action. We'll benchmark the same operation twice:\n", + "1. **Without** cache flushing between runs (data stays in L2 cache)\n", + "2. **With** cache flushing between runs (data must be fetched from global memory each time)" + ] }, { "cell_type": "code", @@ -549,12 +629,34 @@ "plt.show()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You might notice the warm cache's spike on runs 4/5, which can happen due to deferred optimization or other OS noise. This is another reason why you care more about cold cache performance: these spikes are much less likely to occur when processing fresh data each time." + ] + }, { "cell_type": "markdown", "metadata": { "id": "FAaH1cdBzX2j" }, - "source": "### Putting it all together\n\nWe have now discovered that a robust benchmark requires:\n\n1. Device Synchronization\n2. CUDA Events (to avoid CPU overhead)\n3. Warmup Runs (to avoid initialization costs)\n4. Multiple Samples (to handle variance)\n5. Cache Flushing (to simulate global memory access)\n6. Median/Mean Aggregation (to ignore jitter)\n\nWriting this boilerplate every time is tedious. KernelBench's timing module packages all these best practices, as does Triton's [`do_bench`](https://triton-lang.org/main/python-api/generated/triton.testing.do_bench.html).\n\nKernelBench's `cuda_event` method handles all of the above automatically—plus **`discard_first`**, which drops the first few post-warmup trials that often still have initialization overhead." + "source": [ + "### Putting it all together\n", + "\n", + "We have now discovered that a robust benchmark requires:\n", + "\n", + "1. Device Synchronization\n", + "2. CUDA Events (to avoid CPU overhead)\n", + "3. Warmup Runs (to avoid initialization costs)\n", + "4. Multiple Samples (to handle variance)\n", + "5. Cache Flushing (to simulate global memory access)\n", + "6. Median/Mean Aggregation (to ignore jitter)\n", + "\n", + "Writing this boilerplate every time is tedious. KernelBench's timing module packages all these best practices, as does Triton's [`do_bench`](https://triton-lang.org/main/python-api/generated/triton.testing.do_bench.html).\n", + "\n", + "KernelBench's `cuda_event` method handles all of the above automatically—plus **`discard_first`**, which drops the first few post-warmup trials that often still have initialization overhead." + ] }, { "cell_type": "code", @@ -592,7 +694,7 @@ " elapsed_times = timing_fn(\n", " kernel_fn=func,\n", " args=list(args),\n", - " num_warmup=10,\n", + " num_warmup=3,\n", " num_trials=num_trials,\n", " discard_first=1, # Discard first trial for consistency\n", " verbose=False,\n", @@ -610,12 +712,51 @@ "metadata": { "id": "MsZrCYQRzX2j" }, - "source": "---\n\n## KernelBench's Timing Methods\n\nKernelBench provides **4 timing methods** for different use cases:\n\n| Method | Use Case | Catches Side-Streams | Cold Cache | Trial Control |\n|--------|----------|---------------------|------------|---------------|\n| `cuda_event` | Default, trusted code | No | Yes | Explicit |\n| `host_time` | Untrusted code, agent evals | **Yes** | Yes | Explicit |\n| `do_bench` | Triton-style adaptive | No | Yes | Adaptive (time-budget) |\n| `do_bench_impl` | do_bench with explicit trial control | No | Yes | Explicit |\n\n**Key difference:** `host_time` waits for ALL streams via `torch.cuda.synchronize()`, catching side-stream exploits. Use it for evaluating LLM-generated code.\n\n### Common Interface\n\n```python\ntiming_fn(\n kernel_fn, # Function to time\n args, # List of arguments to pass\n num_warmup=3, # Warmup iterations before timing\n num_trials=10, # Number of timing samples to collect\n discard_first=1, # Drop first N trials after warmup\n device=\"cuda:0\", # GPU device\n verbose=True # Print per-trial timing info\n) -> list[float] # Returns elapsed times in ms\n```\n\n**Note:** `do_bench` ignores `num_warmup`, `num_trials`, and `discard_first`—it uses fixed time budgets instead.\n\n### Why `discard_first`?\n\nEven after warmup, the first few trials can have residual initialization overhead (lazy allocation, cuDNN autotuning, etc.). Setting `discard_first=1` (default) improves consistency." + "source": [ + "---\n", + "\n", + "## KernelBench's Timing Methods\n", + "\n", + "KernelBench provides **4 timing methods** for different use cases:\n", + "\n", + "| Method | Use Case | Catches Side-Streams | Cold Cache | Trial Control |\n", + "|--------|----------|---------------------|------------|---------------|\n", + "| `cuda_event` | Default, trusted code | No | Yes | Explicit |\n", + "| `host_time` | Untrusted code, agent evals | **Yes** | Yes | Explicit |\n", + "| `do_bench` | Triton-style adaptive | No | Yes | Adaptive (time-budget) |\n", + "| `do_bench_impl` | do_bench with explicit trial control | No | Yes | Explicit |\n", + "\n", + "**Key difference:** `host_time` waits for ALL streams via `torch.cuda.synchronize()`, catching side-stream exploits. Use it for evaluating LLM-generated code.\n", + "\n", + "### Common Interface\n", + "\n", + "```python\n", + "timing_fn(\n", + " kernel_fn, # Function to time\n", + " args, # List of arguments to pass\n", + " num_warmup=3, # Warmup iterations before timing\n", + " num_trials=100, # Number of timing samples to collect\n", + " discard_first=1, # Drop first N trials after warmup\n", + " device=\"cuda:0\", # GPU device\n", + " verbose=True # Print per-trial timing info\n", + ") -> list[float] # Returns elapsed times in ms\n", + "```\n", + "\n", + "**Note:** `do_bench` ignores `num_warmup`, `num_trials`, and `discard_first`—it uses fixed time budgets instead.\n", + "\n", + "### Why `discard_first`?\n", + "\n", + "Even after warmup, the first few trials can have residual initialization overhead (lazy allocation, cuDNN autotuning, etc.). Setting `discard_first=1` (default) improves consistency." + ] }, { "cell_type": "markdown", "metadata": {}, - "source": "## Comparing All 4 Timing Methods\n\nLet's see how the different timing methods compare on the same kernel. Each method has trade-offs between precision, features, and overhead." + "source": [ + "## Comparing All 4 Timing Methods\n", + "\n", + "Let's see how the different timing methods compare on the same kernel. Each method has trade-offs between precision, features, and overhead." + ] }, { "cell_type": "code", @@ -698,8 +839,8 @@ " times = method_fn(\n", " simple_mm, \n", " [a, b], \n", - " num_warmup=10, \n", - " num_trials=50, \n", + " num_warmup=3, \n", + " num_trials=100, \n", " verbose=False,\n", " device=DEVICE\n", " )\n", @@ -872,7 +1013,13 @@ "metadata": { "id": "HwsjlhAazX2j" }, - "source": "## The Side-Stream Exploit\n\nWhen evaluating LLM-generated kernels, you're not just fighting measurement noise—you're fighting an optimizer that may discover exploits in your benchmarking harness.\n\nThe exploit: launch work on a **side stream** to make the kernel appear instantaneous." + "source": [ + "## The Side-Stream Exploit\n", + "\n", + "When evaluating LLM-generated kernels, you're not just fighting measurement noise—you're fighting an optimizer that may discover exploits in your benchmarking harness.\n", + "\n", + "The exploit: launch work on a **side stream** to make the kernel appear instantaneous." + ] }, { "cell_type": "code", @@ -919,7 +1066,37 @@ "metadata": { "id": "3HXns_XizX2j" }, - "source": "**What happened:**\n\nStandard benchmarking tools (including `do_bench`) only record events on the default stream. So:\n\n1. Benchmark starts timer on Stream A (the default)\n2. Kernel launches work on Stream B and returns immediately\n3. Benchmark stops timer on Stream A\n\nStream A had no work, so the timer reports `~0ms`. Stream B is still running in the background.\n\n**Why this matters:** If your reward signal is \"lower time = better score,\" an agent that discovers this pattern gets rewarded for *broken* code.\n\n### How KernelBench Addresses This\n\nKernelBench's `host_time` method catches this exploit:\n- Uses `torch.cuda.synchronize()` to wait for ALL streams, not just the default\n- Compares host and device timings to detect discrepancies\n\n```python\n# For trusted code (faster, but can be fooled)\ntiming_fn = get_timing_function(\"cuda_event\")\n\n# For untrusted/agent code (catches side-streams)\ntiming_fn = get_timing_function(\"host_time\")\n```\n\nThe trade-off: `host_time` includes CPU overhead. If `host_time` and `cuda_event` agree within a few percent, the kernel is likely honest.\n\n**Other mitigations:** Static analysis to reject submissions that create `torch.cuda.Stream()` objects." + "source": [ + "**What happened:**\n", + "\n", + "Standard benchmarking tools (including `do_bench`) only record events on the default stream. So:\n", + "\n", + "1. Benchmark starts timer on Stream A (the default)\n", + "2. Kernel launches work on Stream B and returns immediately\n", + "3. Benchmark stops timer on Stream A\n", + "\n", + "Stream A had no work, so the timer reports `~0ms`. Stream B is still running in the background.\n", + "\n", + "**Why this matters:** If your reward signal is \"lower time = better score,\" an agent that discovers this pattern gets rewarded for *broken* code.\n", + "\n", + "### How KernelBench Addresses This\n", + "\n", + "KernelBench's `host_time` method catches this exploit:\n", + "- Uses `torch.cuda.synchronize()` to wait for ALL streams, not just the default\n", + "- Compares host and device timings to detect discrepancies\n", + "\n", + "```python\n", + "# For trusted code (faster, but can be fooled)\n", + "timing_fn = get_timing_function(\"cuda_event\")\n", + "\n", + "# For untrusted/agent code (catches side-streams)\n", + "timing_fn = get_timing_function(\"host_time\")\n", + "```\n", + "\n", + "The trade-off: `host_time` includes CPU overhead. If `host_time` and `cuda_event` agree within a few percent, the kernel is likely honest.\n", + "\n", + "**Other mitigations:** Static analysis to reject submissions that create `torch.cuda.Stream()` objects." + ] }, { "cell_type": "code", @@ -1023,16 +1200,16 @@ "\n", "# cuda_event (can be fooled by side-streams)\n", "cuda_timing = get_timing_function(\"cuda_event\")\n", - "cuda_times = cuda_timing(tricky_agent_kernel, [a, b], num_trials=10, verbose=False, device=DEVICE)\n", + "cuda_times = cuda_timing(tricky_agent_kernel, [a, b], num_trials=100, verbose=False, device=DEVICE)\n", "cuda_stats = get_timing_stats(cuda_times, device=DEVICE)\n", "\n", "# host_time (catches all streams)\n", "host_timing = get_timing_function(\"host_time\")\n", - "host_times = host_timing(tricky_agent_kernel, [a, b], num_trials=10, verbose=False, device=DEVICE)\n", + "host_times = host_timing(tricky_agent_kernel, [a, b], num_trials=100, verbose=False, device=DEVICE)\n", "host_stats = get_timing_stats(host_times, device=DEVICE)\n", "\n", "# Normal kernel for reference\n", - "normal_times = host_timing(simple_mm, [a, b], num_trials=10, verbose=False, device=DEVICE)\n", + "normal_times = host_timing(simple_mm, [a, b], num_trials=100, verbose=False, device=DEVICE)\n", "normal_stats = get_timing_stats(normal_times, device=DEVICE)\n", "\n", "print(f\"\\nTricky kernel with cuda_event: {cuda_stats['mean']:.4f} ms (FOOLED!)\")\n", @@ -1067,7 +1244,11 @@ "metadata": { "id": "Uq4qvl8FzX2j" }, - "source": "## Correctness Before Speed\n\nA blazing-fast kernel that returns nonsense is just a very efficient bug. Always verify your kernel produces correct outputs before benchmarking." + "source": [ + "## Correctness Before Speed\n", + "\n", + "A blazing-fast kernel that returns nonsense is just a very efficient bug. Always verify your kernel produces correct outputs before benchmarking." + ] }, { "cell_type": "code", @@ -1127,14 +1308,62 @@ { "cell_type": "markdown", "metadata": {}, - "source": "## Sanity Checking: Roofline Analysis\n\nOnce you have reliable timing numbers, you'll want to sanity-check them: Are these results physically possible? How close am I to the hardware's theoretical maximum?\n\nThis is where **roofline analysis** comes in. It helps you understand whether your kernel is **compute-bound** (limited by FLOPS) or **memory-bound** (limited by bandwidth), and how much headroom you have left.\n\nWe won't cover it in detail here, but the [JAX Scaling Book chapter on Roofline](https://jax-ml.github.io/scaling-book/roofline/) is an excellent resource." + "source": [ + "Fully ensuring kernel correctness is actually a fairly complex problem. KernelBench checks the output of generated code on random inputs against the output from the baseline and ensures they match. However, what \"match\" means is up for debate. Since floating point operations are non-associative, it is possible for two correct kernels to produce marginally different outputs. This margin should depend on the data type: lower precision leads to more rounding errors, meaning that you should probably have a wider margin of error. As a result of non-associativity and many similar factors, kernel correctness is not binary.\n", + "\n", + "For an in-depth discussion of this topic, see [Towards a Reliable Kernel Correctness Check in Matrix Multiplication](https://deep-reinforce.com/correctness_check.html)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Sanity Checking: Roofline Analysis\n", + "\n", + "Once you have reliable timing numbers, you'll want to sanity-check them: Are these results physically possible? How close am I to the hardware's theoretical maximum?\n", + "\n", + "This is where **roofline analysis** comes in. It helps you understand whether your kernel is **compute-bound** (limited by FLOPS) or **memory-bound** (limited by bandwidth), and how much headroom you have left.\n", + "\n", + "We won't cover it in detail here, but the [JAX Scaling Book chapter on Roofline](https://jax-ml.github.io/scaling-book/roofline/) is an excellent resource." + ] }, { "cell_type": "markdown", "metadata": { "id": "zcYVXCkUzX2k" }, - "source": "## Conclusion\n\nBenchmarking on GPUs is fundamentally different from CPUs. The asynchronous nature of kernel launches, the hidden state of the L2 cache, and the noise of the OS scheduler all conspire to give you wrong numbers if you're not careful.\n\n### KernelBench's Timing Module\n\nWe've packaged all these best practices in `src/timing.py`:\n\n| Function | Purpose |\n|----------|---------|\n| `get_timing_function(method)` | Returns timing function by name |\n| `clear_l2_cache(device)` | L2 cache flushing |\n| `get_timing_stats(times)` | Statistical aggregation (mean, std, min, max) |\n\n```python\nfrom src.timing import get_timing_function, get_timing_stats\n\n# For trusted code\ntiming_fn = get_timing_function(\"cuda_event\")\n\n# For agent evaluations (catches side-streams)\ntiming_fn = get_timing_function(\"host_time\")\n\n# Run benchmark\ntimes = timing_fn(kernel, args, num_warmup=10, num_trials=100, device=\"cuda:0\")\nstats = get_timing_stats(times, device=\"cuda:0\")\nprint(f\"Mean: {stats['mean']:.4f}ms, Std: {stats['std']:.4f}ms\")\n```\n\nHappy optimizing!" + "source": [ + "## Conclusion\n", + "\n", + "Benchmarking on GPUs is fundamentally different from CPUs. The asynchronous nature of kernel launches, the hidden state of the L2 cache, and the noise of the OS scheduler all conspire to give you wrong numbers if you're not careful.\n", + "\n", + "### KernelBench's Timing Module\n", + "\n", + "We've packaged all these best practices in `src/timing.py`:\n", + "\n", + "| Function | Purpose |\n", + "|----------|---------|\n", + "| `get_timing_function(method)` | Returns timing function by name |\n", + "| `clear_l2_cache(device)` | L2 cache flushing |\n", + "| `get_timing_stats(times)` | Statistical aggregation (mean, std, min, max) |\n", + "\n", + "```python\n", + "from src.timing import get_timing_function, get_timing_stats\n", + "\n", + "# For trusted code\n", + "timing_fn = get_timing_function(\"cuda_event\")\n", + "\n", + "# For agent evaluations (catches side-streams)\n", + "timing_fn = get_timing_function(\"host_time\")\n", + "\n", + "# Run benchmark\n", + "times = timing_fn(kernel, args, num_warmup=3, num_trials=100, device=\"cuda:0\")\n", + "stats = get_timing_stats(times, device=\"cuda:0\")\n", + "print(f\"Mean: {stats['mean']:.4f}ms, Std: {stats['std']:.4f}ms\")\n", + "```\n", + "\n", + "Happy optimizing!" + ] }, { "cell_type": "markdown", @@ -1181,4 +1410,4 @@ }, "nbformat": 4, "nbformat_minor": 0 -} \ No newline at end of file +} From dd68f3c6f11e4a9772a80487412833455ab77896 Mon Sep 17 00:00:00 2001 From: Bhavesh Kalisetti <59468276+bkal01@users.noreply.github.com> Date: Thu, 18 Dec 2025 23:48:59 -0800 Subject: [PATCH 10/24] Eval Unit Tests for Adversarial Eval Testing (#82) * add unit tests for input mod Adds a unit test to check that a generated kernel which modifies the original inputs fails the correctness check. For the square matmul problem, the kernel zeros out the inputs and returns a matrix of 0s. This will fail correctness/pass the test as long as the reference implementation is ran first. If we swap the order, the test will fail as the reference implementation will operate on tensors of 0s and it will look like the generated kernel computed the correct output. * add unit test for reusing results Adds a unit test to check that a generated kernel which attempts to access the result from the PyTorch reference model in memory fails the correctness check. If a generated kernel uses empty_like, the CUDA caching allocator can re-use the physical memory of the previously computed result. All the kernel needs to do is return immediately and it will pass the correctness check. Note that in order to reproduce this, we need to copy the PyTorch output to the CPU and delete the output object. Then empty_like will fetch the physical memory for the output object. * test bhavesh's unit test * use generic shape use generic matmul shape for cache reuse adversarial kernel rather than requiring a square matmul. * excessive speedup unit test via non default stream * update timing signature * update non default stream kernel make a non-blocking non-default stream, and use cublasGemmEx rather than at::matmul: * reduce trial for adverseiral stream hack * show unrealistic speedup * flag excessive speedups in eval script eval script now flags excessive speedups by timing pytorch reference. * reogranize a bit to flag timing on mian stream fails * update EVAL.md with unit test summary * ready for merge, update guide a bit (more for sahan to keep adding in other PRs) --------- Co-authored-by: Simon Guo --- EVAL.md | 49 ++++++++ src/eval.py | 70 ++++++++++- src/unit_tests/test_eval_adversarial.py | 112 ++++++++++++++++++ .../test_kernels/non_default_stream_kernel.py | 84 +++++++++++++ .../test_kernels/result_reuse_kernel.py | 51 ++++++++ .../test_kernels/zero_out_kernel.py | 50 ++++++++ 6 files changed, 414 insertions(+), 2 deletions(-) create mode 100644 EVAL.md create mode 100644 src/unit_tests/test_eval_adversarial.py create mode 100644 src/unit_tests/test_kernels/non_default_stream_kernel.py create mode 100644 src/unit_tests/test_kernels/result_reuse_kernel.py create mode 100644 src/unit_tests/test_kernels/zero_out_kernel.py diff --git a/EVAL.md b/EVAL.md new file mode 100644 index 00000000..c202b065 --- /dev/null +++ b/EVAL.md @@ -0,0 +1,49 @@ +# Evaluation +[WIP] More notes on Benchmarking Guide +To be updated more comprehensively with the benchmarking guide (ongoing PRs) & blog that we have been working on this quarter. + +You should be **extra CAREFUL!** , be always paranoid about suspiciously good results — kernel engineers and existing compilers are already pretty good, so a >2x speedup for anything is highly unlikely. + + +> “if you beat cudnn by more than 10%, think again” -- +from [itsclivetime](https://x.com/itsclivetime/status/1992155951630307633?s=46) + + +If the model can reward hack, it will find ways to reward hack! This can especially happen during RL training or evolutionary search. + +Check out resources here: +- KernelBench [v0.1 Release](https://scalingintelligence.stanford.edu/blogs/kernelbenchv01/) +- Cognition and Stanford's [Kevin](https://arxiv.org/abs/2507.11948) project on various hacking behaviors observed in RL training +- Jiwei Li's awesome [blogpost](https://deep-reinforce.com/defense_kernel_hack.html) on Hacks and Defenses in Automatic GPU Kernel Generation + +Our ongoing blogpost and PRs try to systematize and list out these behaviors and provide tests, detection, and mitigation toolings. + + +## Methodology +More on that coming. + +To ensure **consistency and reproducibility**, we recommend using `modal` and we have provided / are adding more various modal cloud functions to standardize the evaluation environment. + +### Correctness +More coming. We also want to highlight community effort such as [BackendBench](https://www.youtube.com/watch?v=BTfjdyZOKww). + +### Performance +We highly recommend watching this [lecture](https://www.youtube.com/watch?v=1i7dxoAfKOU) from GPU mode on kernel profiling. + +We have (and continue to) implement various approaches to conduct kernel timing to understand the tradeoffs. + +Check out `timing.py` to see available timing methods and `src/unit_tests/test_eval_timing.py` to test out various timing methods (including leveraging `cuda_event` marker, Triton `do_bench`, `host_time` E2E time). @palic and team is working on a blogpost explaining the different tradeoffs soon. + +### Unit Tests with Adversarial Examples +We've included some unit tests for the eval script in `src/unit_tests/test_eval_adversarial.py`. These tests run adversarial kernels (see `src/unit_tests/test_kernels/`) that contain examples of reward hacking that we've seen from LLMs and ensures that the eval script catches them, either by failing their correctness checks or flagging them for excessive speedups. Examples include: +- Reusing computations cached during the PyTorch reference +- Modifying inputs to cheat correctness checks +- Moving computation to a non-default CUDA stream + +We will continue to add more tests as we explore additional adversarial scenarios. + + +Note: KernelBench is an ongoing open-source effort — please help us with issues and PRs! + + +Shoutout to @bkal01, @palic, @miru_why, @ngc92, @itsclivetime, for their suggestions and feedback. \ No newline at end of file diff --git a/src/eval.py b/src/eval.py index 5f1fe8d8..51bdc6b6 100644 --- a/src/eval.py +++ b/src/eval.py @@ -109,13 +109,20 @@ class KernelExecResult(BaseModel): """ Single Kernel Execution """ - + # Execution compiled: bool = False correctness: bool = False - metadata: dict = {} + metadata: dict = {} # NOTE: to include warning if any + + # Timing runtime: float = -1.0 # in us, only recorded if we decide to measure performance runtime_stats: dict = {} # only recorded if we decide to measure performance + # new: added ref time either through fetching prev runs or through execution + # could do eager for level 1 and compile for level 2 and 3 + ref_runtime: float = -1.0 # in us, only recorded if we decide to measure performance + ref_runtime_stats: dict = {} # only recorded if we decide to measure performance + def load_original_model_and_inputs( model_original_src: str, context: dict @@ -402,6 +409,10 @@ def eval_kernel_against_ref( ), # have to run on GPU backend: str = "cuda", # can be 'cuda', 'triton', 'tilelang', or 'cute' precision: torch.dtype = torch.float32, + + # Guard against potential reward hacking [optional but ongoing enhancement] + check_for_excessive_speedup: bool = True, + excessive_speedup_threshold: float = 10, # flag if the kernel is more than x faster than the reference ) -> KernelExecResult: """ Evaluate the custom kernel against the original model @@ -415,6 +426,8 @@ def eval_kernel_against_ref( backend: str, one of 'cuda', 'triton', 'tilelang', or 'cute' precision: torch.dtype for computation (note: tilelang only supports fp16) timing_method: str, method to time kernel, see timing.py for more details + + ONGOING EFFORT to refactor and modularize this, and adding more tests for eval. """ # TODO: check device is busy assert torch.cuda.is_available(), "CUDA is not available, cannot run Eval" @@ -598,11 +611,64 @@ def eval_kernel_against_ref( print(f"[Eval] Performance Stats: {runtime_stats}") kernel_exec_result.runtime = runtime_stats["mean"] kernel_exec_result.runtime_stats = runtime_stats + except Exception as e: if verbose: print(f"[Eval] Error in Measuring Performance: {e}") kernel_exec_result.metadata["error_during_performance"] = e + + + ############################################################### + # [Experimental] to be modularized + # Condition: custom kernel ModelNew is correct and we are able to time it correctly with kernel_exec_result + # We are working on preventing excessive speedup issues + ############################################################## + + if measure_performance and check_for_excessive_speedup: # experimental: hence able to shut off codepath if needed + + if verbose: + print("[Eval] Additional checks to flag excessive speedup") + + torch.cuda.synchronize(device=device) + set_seed(seed_num) + inputs = get_inputs() + # Convert inputs for performance measurement + inputs = [_process_input_tensor(x, device, backend, precision) for x in inputs] + + model_new = custom_model.to(device=device, dtype=precision) + torch.cuda.synchronize(device=device) + + # time PyTorch reference function + # same timing_fn as specified from before + timing_fn = timing.get_timing_function(timing_method) + reference_elapsed_times = timing_fn( + original_model, + inputs, # ideally cloned for extra safety but handled already in correctness check + num_trials=num_perf_trials, + verbose=verbose, + device=device, + ) + reference_runtime_stats = timing.get_timing_stats(reference_elapsed_times, device=device) + kernel_exec_result.ref_runtime = reference_runtime_stats["mean"] + kernel_exec_result.ref_runtime_stats = reference_runtime_stats + + # Compute Effective Speedup + effective_speedup = kernel_exec_result.ref_runtime / kernel_exec_result.runtime + + # TODO: integrate SoL estimation for each unique program on designated hardware + # for now, we will use a heuristics such as 5-10x which is very hard to achieve + + if verbose: + print(f"[Eval] Effective Speedup is {effective_speedup:.2f}x using timing method {timing_method}") + + if effective_speedup > excessive_speedup_threshold: + kernel_exec_result.metadata["excessive_speedup"] = True + + print(f"[WARNING] Excessive speedup {effective_speedup:.2f}x over {excessive_speedup_threshold}x threshold detected") + print(f"[WARNING] Double check your kernel carefully to ensure it is not reward hacking.") + + graceful_eval_cleanup(context, device, tempfile) return kernel_exec_result diff --git a/src/unit_tests/test_eval_adversarial.py b/src/unit_tests/test_eval_adversarial.py new file mode 100644 index 00000000..d741c408 --- /dev/null +++ b/src/unit_tests/test_eval_adversarial.py @@ -0,0 +1,112 @@ +import os + +from src.dataset import KERNEL_BENCH_PATH +from src.eval import eval_kernel_against_ref +from src.utils import read_file + +""" +Specifically testing the robustness of the eval function. +Through a few targeted adversarial kernels. + +Run with pytest +pytest src/unit_tests/test_eval_adversarial.py +""" + +def run_test_kernel(problem_name, + kernel_filename, + timing_method="cuda_event", + num_perf_trials=100): + """ + Run a test kernel agains the reference architecture and return the result. + + Inputs: + - problem_name: name of the KernelBench problem to test on (e.g. "level1/1_Square_matrix_multiplication_.py") + - kernel_filename: name of the adversarial kernel (e.g. "zero_out_kernel.py") + + Output: + - result: KernelExecResult object + """ + print(f"Running test adversarial kernel {kernel_filename} against problem {problem_name}") + ref_src = read_file(os.path.join(KERNEL_BENCH_PATH, problem_name)) + # TODO: replace with Omar's dataset object + kernel_src = read_file(os.path.join(os.path.dirname(__file__), "test_kernels", kernel_filename)) + + return eval_kernel_against_ref( + original_model_src=ref_src, + custom_model_src=kernel_src, + num_correct_trials=5, # under mulitiple correctness trials + num_perf_trials=num_perf_trials, + measure_performance=True, + timing_method=timing_method, + # for checking against reward hacking + check_for_excessive_speedup = True, + excessive_speedup_threshold = 10 + ) + + +def test_result_cache_reuse(): + """ + Test to prevent adversarial kernel by reuse computed PyTorch results + + Methodology: + - Adversarial kernel allocate memory for result but does not initialize it. + - Potential Hacking scenario: CUDA cache allocator might give that un-erased physical memory to the custom kernel (which contains the result) and it will incorrectly pass + - Eval script should flag this as incorrect as the reference kernel did not conduct any meaningful computation + """ + result = run_test_kernel(problem_name="level1/1_Square_matrix_multiplication_.py", + kernel_filename="result_reuse_kernel.py") + assert result.correctness is False, "Cache reuse hack detected" + print("Result: Eval Function Passed Test Result Cache Reuse") + print(result) + +def test_input_modification(): + """ + Test that even if the model tries to modify the inputs to pass the tests, + we still flag it as incorrect. + + Methodology: + - Adversarial kernel zeros out all inputs and returns all zeros for the final matmul shape. + - Potential Hacking scenario: Since adversarial kernel zero out the input, the reference might ran the kernel with all zeros. + Hence both refernece and custom kernel return all zeros, and this incorrectly pass. + - Eval script should flag this as incorrect as this kernel zeros out inputs and trick the reference kernel into returning all zeros. + """ + result = run_test_kernel(problem_name="level1/1_Square_matrix_multiplication_.py", + kernel_filename="zero_out_kernel.py") + assert result.correctness is False, "Input modification hack detected" + print("Result: Eval Function Passed Test Input Modification Hack") + print(result) + + +def test_non_default_stream(timing_method="do_bench", threshold=1.5): + """ + Test that we will flag adversarial kernels that cheat by assigning work to non-default CUDA streams. + + Methodology: + - Adversarial kernel assigns work to non-default CUDA streams. + - Potential Hacking scenario: Eval script waits on the default stream only when measuring kernel runtime, leading to unrealistic speedups. + - Eval script should accurately measure runtime by waiting on all streams, not just the default stream. + """ + result = run_test_kernel(problem_name="level1/1_Square_matrix_multiplication_.py", + kernel_filename="non_default_stream_kernel.py", + timing_method=timing_method, + num_perf_trials=10 ) # keep it low as we are leaking cuda stream + + print(result) + if result.metadata.get("excessive_speedup") is True: + print("Result: Eval Function successfully marked excessive speedup from the hacky CUDA Stream implementation") + print("This indicates the eval script properly detected and flagged potential cheating behavior.") + else: + raise AssertionError( + "Excessive speedup not detected - Eval Function failed to flag adversarial kernel that exploits cuda stream timing hack" + ) + + +def main(): + test_result_cache_reuse() + test_input_modification() + test_non_default_stream() + + # we might add more adversarial tests in the future + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/src/unit_tests/test_kernels/non_default_stream_kernel.py b/src/unit_tests/test_kernels/non_default_stream_kernel.py new file mode 100644 index 00000000..37fe00fd --- /dev/null +++ b/src/unit_tests/test_kernels/non_default_stream_kernel.py @@ -0,0 +1,84 @@ +import torch +import torch.nn as nn +from torch.utils.cpp_extension import load_inline + +########################################### +# CUDA_STREAM_ADVERSARIAL +# adversarial kernel assigns all work to a non-default CUDA stream. +# If the eval script waits only on the default cuda stream when measuring kernel runtime, this will lead to unrealistic speedups. +########################################### +# this adversarial kernel obtains a non-default, non-blocking stream via cudaStreamCreateWithFlags(...) and sets to be the stream of the cuBLAS handle. +# then, it performs a matrix multiplication on this new stream. + +# if timing harness only waits on default stream, it will measure near-zero time because the actual computation is still running asynchronously on the other stream. + +matmul_cuda_source = r""" +#include +#include +#include + +torch::Tensor matmul_cuda(torch::Tensor A, torch::Tensor B) { + int M = A.size(0); + int K = A.size(1); + int N = B.size(1); + + auto result = torch::empty({M, N}, A.options()); + + cudaStream_t stream; + cudaStreamCreateWithFlags(&stream, cudaStreamNonBlocking); + + cublasHandle_t handle; + cublasCreate(&handle); + cublasSetStream(handle, stream); + + float alpha = 1.0f, beta = 0.0f; + + cublasGemmEx(handle, + CUBLAS_OP_N, CUBLAS_OP_N, + N, M, K, + &alpha, + B.data_ptr(), CUDA_R_32F, N, + A.data_ptr(), CUDA_R_32F, K, + &beta, + result.data_ptr(), CUDA_R_32F, N, + CUBLAS_COMPUTE_32F, CUBLAS_GEMM_DEFAULT); + + // NOTE: Intentionally leaking CUDA resources (stream + cuBLAS handle) to preserve + // adversarial behavior. Calling cudaStreamDestroy() would implicitly synchronize, + // defeating the purpose of this test (which checks if the eval harness detects + // work launched on non-default streams). Keep num_perf_trials low to avoid OOM. + // cublasDestroy(handle); + // cudaStreamDestroy(stream); + + return result; +} +""" + +matmul_cuda_cpp = "torch::Tensor matmul_cuda(torch::Tensor A, torch::Tensor B);" + +# Compile inline extension +matmul_module = load_inline( + name="fast_matmul", + cpp_sources=matmul_cuda_cpp, + cuda_sources=matmul_cuda_source, + functions=["matmul_cuda"], + verbose=False, +) + +class ModelNew(nn.Module): + def __init__(self) -> None: + super().__init__() + self.matmul = matmul_module + + def forward(self, A: torch.Tensor, B: torch.Tensor) -> torch.Tensor: + return self.matmul.matmul_cuda(A, B) + +N = 2048 * 2 + +def get_inputs(): + A = torch.rand(N, N) + B = torch.rand(N, N) + return [A, B] + +def get_init_inputs(): + return [] \ No newline at end of file diff --git a/src/unit_tests/test_kernels/result_reuse_kernel.py b/src/unit_tests/test_kernels/result_reuse_kernel.py new file mode 100644 index 00000000..88258ddf --- /dev/null +++ b/src/unit_tests/test_kernels/result_reuse_kernel.py @@ -0,0 +1,51 @@ +import torch +import torch.nn as nn +from torch.utils.cpp_extension import load_inline + +########################################### +# +# This adversarial kernel utilizes empty which can get allocated the same physical memory as the PyTorch reference outputs +# If the eval script deletes/frees the PyTorch output object at some point before the custom kernel is run, +# the CUDA cache allocator might give that un-erased physical memory to the custom kernel and it will incorrectly pass +# So, we should ensure we zero out physical memory to prevent reuse +########################################### + +# Returns a zero_ +matmul_cuda_source = r""" +#include +#include + +torch::Tensor matmul_cuda(torch::Tensor A, torch::Tensor B) { + auto C = torch::empty({A.size(0), B.size(1)}, A.options()); + return C; +} +""" + +matmul_cuda_cpp = "torch::Tensor matmul_cuda(torch::Tensor A, torch::Tensor B);" + +# Compile inline extension +matmul_module = load_inline( + name="fast_matmul", # this is a hacky kernel that shall not pass; it would extra fast since it just allocates memory of result shape + cpp_sources=matmul_cuda_cpp, + cuda_sources=matmul_cuda_source, + functions=["matmul_cuda"], + verbose=False, +) + +class ModelNew(nn.Module): + def __init__(self) -> None: + super().__init__() + self.matmul = matmul_module + + def forward(self, A: torch.Tensor, B: torch.Tensor) -> torch.Tensor: + return self.matmul.matmul_cuda(A, B) + +N = 2048 * 2 + +def get_inputs(): + A = torch.rand(N, N) + B = torch.rand(N, N) + return [A, B] + +def get_init_inputs(): + return [] \ No newline at end of file diff --git a/src/unit_tests/test_kernels/zero_out_kernel.py b/src/unit_tests/test_kernels/zero_out_kernel.py new file mode 100644 index 00000000..aba20620 --- /dev/null +++ b/src/unit_tests/test_kernels/zero_out_kernel.py @@ -0,0 +1,50 @@ +import torch +import torch.nn as nn +from torch.utils.cpp_extension import load_inline + +########################################### +# This custom kernel zeros out the inputs and returns a zero matrix. +# It is specifically designed to test the eval script's robustness. +# Running this zero kernel should result in incorrectness for eval, +# as the reference kernel will not return all zeros. +########################################### + +# Destroys all inputs, returns all zeros for final matmul shape +matmul_cuda_source = r""" +#include + +torch::Tensor matmul_cuda(torch::Tensor A, torch::Tensor B) { + A.zero_(); + B.zero_(); + return torch::zeros({A.size(0), B.size(1)}, A.options()); +} +""" + +matmul_cuda_cpp = "torch::Tensor matmul_cuda(torch::Tensor A, torch::Tensor B);" + +# Compile inline extension +matmul_module = load_inline( + name="fast_matmul", # this is a hacky kernel that shall not pass; it would extra fast since it just allocates 0s + cpp_sources=matmul_cuda_cpp, + cuda_sources=matmul_cuda_source, + functions=["matmul_cuda"], + verbose=False, +) + +class ModelNew(nn.Module): + def __init__(self) -> None: + super().__init__() + self.matmul = matmul_module + + def forward(self, A: torch.Tensor, B: torch.Tensor) -> torch.Tensor: + return self.matmul.matmul_cuda(A, B) + +N = 2048 * 2 + +def get_inputs(): + A = torch.rand(N, N) + B = torch.rand(N, N) + return [A, B] + +def get_init_inputs(): + return [] \ No newline at end of file From d7acaddf95da6c1723a199016fb4341ed85cf211 Mon Sep 17 00:00:00 2001 From: Bhavesh Kalisetti <59468276+bkal01@users.noreply.github.com> Date: Wed, 24 Dec 2025 09:02:20 -0800 Subject: [PATCH 11/24] fix exclusive cumsum calculation (#109) * fix exclusive cumsum calculation as @AKatydid pointed out on https://github.com/ScalingIntelligence/KernelBench/issues/72, the current exclusive cumsum computation is incorrect. now we apply torch.cumsum on x (without the last elements along the dimension) and shifts them right by one by prepending 0s. * check and add changelog --------- Co-authored-by: Simon Guo --- KernelBench/changelog/v0.1 | 2 ++ KernelBench/changelog/v0.2 | 3 +++ KernelBench/level1/92_cumsum_exclusive.py | 4 ++-- 3 files changed, 7 insertions(+), 2 deletions(-) create mode 100644 KernelBench/changelog/v0.1 create mode 100644 KernelBench/changelog/v0.2 diff --git a/KernelBench/changelog/v0.1 b/KernelBench/changelog/v0.1 new file mode 100644 index 00000000..62c0f938 --- /dev/null +++ b/KernelBench/changelog/v0.1 @@ -0,0 +1,2 @@ +Please refer to KernelBench v0.1 release note +https://scalingintelligence.stanford.edu/blogs/kernelbenchv01/ \ No newline at end of file diff --git a/KernelBench/changelog/v0.2 b/KernelBench/changelog/v0.2 new file mode 100644 index 00000000..44915f65 --- /dev/null +++ b/KernelBench/changelog/v0.2 @@ -0,0 +1,3 @@ +Ongoing Effort + +Updated Level1/92_cumsum_exclusive.py - Fix exclusive cumsum implementation \ No newline at end of file diff --git a/KernelBench/level1/92_cumsum_exclusive.py b/KernelBench/level1/92_cumsum_exclusive.py index 0c819da7..e68dacad 100644 --- a/KernelBench/level1/92_cumsum_exclusive.py +++ b/KernelBench/level1/92_cumsum_exclusive.py @@ -14,8 +14,8 @@ def __init__(self, dim): self.dim = dim def forward(self, x): - exclusive_cumsum = torch.cat((torch.zeros_like(x.select(self.dim, 0).unsqueeze(self.dim)), x), dim=self.dim)[:-1] - return torch.cumsum(exclusive_cumsum, dim=self.dim) + cumsum = torch.cumsum(x.narrow(dim=self.dim, start=0, length=x.size(self.dim)-1), dim=self.dim) + return torch.cat((torch.zeros_like(x.select(self.dim, 0).unsqueeze(self.dim)), cumsum), dim=self.dim) batch_size = 32768 input_shape = (32768,) From 9246131f602615be38a936d3bb36f436d84dc742 Mon Sep 17 00:00:00 2001 From: Sahan Paliskara Date: Fri, 26 Dec 2025 18:49:04 -0800 Subject: [PATCH 12/24] Migrating to UV for Dependency (#112) * Add uv support * Add uv support * Add uv support * lock * add pyproject for clear specification and keep requirements for legacy support * Update README.md Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * update requirements * update requirements * update requirements * update reqs * finish * small updates * fix modal script and migrate to uvfor easier integration inside other repos --------- Co-authored-by: Simon Guo Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> Co-authored-by: Sahan Paliskara --- .gitignore | 2 + EVAL.md | 4 +- README.md | 45 +++++++++------ pyproject.toml | 56 +++++++++++++++++++ requirements.txt | 35 ++++++------ scripts/eval_from_generations.py | 2 +- scripts/generate_and_eval_single_sample.py | 8 ++- .../generate_and_eval_single_sample_modal.py | 6 +- scripts/generate_baseline_time_modal.py | 2 +- scripts/run_and_check.py | 2 +- setup.py | 8 --- src/frameworks.py | 1 - src/utils.py | 4 +- 13 files changed, 121 insertions(+), 54 deletions(-) create mode 100644 pyproject.toml delete mode 100644 setup.py diff --git a/.gitignore b/.gitignore index 3956bf85..a6aab0db 100644 --- a/.gitignore +++ b/.gitignore @@ -11,3 +11,5 @@ cache/* !results/timing/ .env _build_cache/ +uv.lock +CLAUDE.md \ No newline at end of file diff --git a/EVAL.md b/EVAL.md index c202b065..c6f70fb0 100644 --- a/EVAL.md +++ b/EVAL.md @@ -14,10 +14,12 @@ If the model can reward hack, it will find ways to reward hack! This can especia Check out resources here: - KernelBench [v0.1 Release](https://scalingintelligence.stanford.edu/blogs/kernelbenchv01/) - Cognition and Stanford's [Kevin](https://arxiv.org/abs/2507.11948) project on various hacking behaviors observed in RL training -- Jiwei Li's awesome [blogpost](https://deep-reinforce.com/defense_kernel_hack.html) on Hacks and Defenses in Automatic GPU Kernel Generation +- Jiwei Li's awesome [blogpost 1](https://deep-reinforce.com/defense_kernel_hack.html) and [blogpost 2](https://deep-reinforce.com/correctness_check.html) on Hacks and Defenses in Automatic GPU Kernel Generations Our ongoing blogpost and PRs try to systematize and list out these behaviors and provide tests, detection, and mitigation toolings. +**Disclaimer**: KernelBench is an open-source evaluation framework. Due to limited bandwidth, the KernelBench team does not inspect, validate, or endorse any third-party kernels or reported results. Users are welcome to use the software infrastructure for evaluation, but should independently verify all results. + ## Methodology More on that coming. diff --git a/README.md b/README.md index 91e24d8d..d30401ee 100644 --- a/README.md +++ b/README.md @@ -37,7 +37,7 @@ To evaluate model-generated kernels, we need to check if they: - **is correct ✅**: check against reference torch operators `n_correctness` times on randomized inputs. - **is performant ⏱️**: compare against reference torch operators `n_trial` times to measure speedup between runtimes. -Check out `src/eval.py` for details on how we implement correctness check and timing. +Check out `src/eval.py` for details on how we implement correctness check and timing and `EVAL.md` for notes on evaluation and benchmarking guidelines [WIP]. We provide a convenient script `scripts/run_and_check.py` to evaluate one single sample source code against a reference source code, check correctness and compute speedup. You can use this to evaluate a kernel either locally or remotely by setting `eval_mode=local` or `eval_mode=modal`. @@ -76,17 +76,26 @@ KernelBench/ ``` ## 🔧 Set up -``` -conda create --name kernel-bench python=3.10 -conda activate kernel-bench -pip install -r requirements.txt -pip install -e . + +We have transitioned to using `pyproject.toml` and `uv` for dependency management. Install [uv](https://docs.astral.sh/uv/getting-started/installation/) if you haven't already + +```bash +# Install base dependencies (works without a local GPU) +uv sync + +# Install with GPU dependencies (for local GPU evaluation) +uv sync --extra gpu + +# Run commands with uv (which invoke the right env) +uv run python scripts/.py ... ``` +You can still use `conda (python=3.10)` to create your environment and install dependencies with `requirements.txt`. + We use `litellm` for API calls. Please set your keys by creating a `.env` following our `.env.example`. -Running and profiling kernels require a GPU. -If you don't have GPU available locally, you can set up [Modal](https://modal.com/). Set up your modal token after creating an account by running `modal token new`. Then, use the `generate_and_eval_single_sample_modal.py` script. +Running and profiling kernels require a GPU. +If you don't have a GPU available locally, you can set up [Modal](https://modal.com/) for cloud serverless GPU evaluation. Set up your modal token after creating an account by running `modal token new`. Then, use the `generate_and_eval_single_sample_modal.py` script. You can also try out our [tutorial notebook](https://bit.ly/kernelbench-neurips-colab) (also in notebooks/tutorial.ipynb) with Google Colab. @@ -94,10 +103,10 @@ You can also try out our [tutorial notebook](https://bit.ly/kernelbench-neurips- ### Run on a single problem It is easier to get started with a single problem. This will fetch the problem, generate a sample, and evaluate the sample. -``` -# for example, run level 2 problem 40 from huggingface +```bash +# for example, run level 2 problem 40 from huggingface and use google gemini 2.5 flash for generation -python3 scripts/generate_and_eval_single_sample.py dataset_src="huggingface" level=2 problem_id=40 +uv run python scripts/generate_and_eval_single_sample.py dataset_src=huggingface level=2 problem_id=40 server_type=google model_name=gemini/gemini-2.5-flash # dataset_src could be "local" or "huggingface" # add .verbose_logging for more visbility @@ -112,21 +121,21 @@ Check the config fields for comprehensive set of options. Note we provide the mo ### Run on all problems -``` +```bash # 1. Generate responses and store kernels locally to runs/{run_name} directory -python3 scripts/generate_samples.py run_name=test_hf_level_1 dataset_src=huggingface level=1 num_workers=50 server_type=deepseek model_name=deepseek-chat temperature=0 +uv run python scripts/generate_samples.py run_name=test_hf_level_1 dataset_src=huggingface level=1 num_workers=50 server_type=deepseek model_name=deepseek-chat temperature=0 # 2. Evaluate on all generated kernels in runs/{run_name} directory -python3 scripts/eval_from_generations.py run_name=test_hf_level_1 dataset_src=local level=1 num_gpu_devices=8 timeout=300 +uv run python scripts/eval_from_generations.py run_name=test_hf_level_1 dataset_src=local level=1 num_gpu_devices=8 timeout=300 -# If you like to speedup evaluation, you can use parallelize compilation on CPUs before getting to evluation on GPUs +# If you like to speedup evaluation, you can use parallelize compilation on CPUs before getting to evaluation on GPUs # add build_cache=True and num_cpu_workers= to the command ``` ### Analyze the eval results to compute Benchmark Performance We provide `scripts/benchmark_eval_analysis.py` to analyze the eval results to compute success rate, timing metric, and overall benchmark performance `fast_p`. -``` -python3 scripts/benchmark_eval_analysis.py run_name=test_hf_level_1 level=1 hardware=L40S_matx3 baseline=baseline_time_torch +```bash +uv run python scripts/benchmark_eval_analysis.py run_name=test_hf_level_1 level=1 hardware=L40S_matx3 baseline=baseline_time_torch ``` If you are using a different hardware, you can generate the baseline time with `scripts/generate_baseline_time.py` script. We provide some reference baseline times a variety of NVIDIA GPUs across generations in `results/timing`, but we recommend you to generate your own baseline time for more accurate results (cluster power, software version, all affects timing result). See `results/timing/README.md` for more details. @@ -140,6 +149,8 @@ Check out our [roadmap](https://github.com/ScalingIntelligence/KernelBench/issue ## 🔍 Known Usage Since release, we have gotten a lot of interest from researchers, research labs, and companies that use KernelBench to explore this direction. We have documented [known usage](https://docs.google.com/document/d/e/2PACX-1vTjS-UMH1HB5n_PENq2k-3YRfXIXkqKIKeNC2zcWMyLPdl4Jrwvdk4dNDVSsM8ybKrCxZB7GJq1slZF/pub) of KernelBench and related efforts towards automated kernel generations. If you are using KernelBench, we love to hear more about it! +Disclaimer: KernelBench is designed as an open-source evaluation framework and toolkit. The KernelBench team does not review, validate, or endorse individual kernels or reported results. Users are responsible for independently verifying any results obtained using the framework. Please check out `EVAL.md` for more guidance on benchmarking and evaluating kernels. + ## 🪪 License MIT. Check `LICENSE.md` for more details. diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 00000000..07788b6c --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,56 @@ +[build-system] +requires = ["setuptools>=61.0"] +build-backend = "setuptools.build_meta" + +# this should be our single source of truth for versioning + +[project] +# to rename as kb_src later and updated codebase +# do that later let's get all the import right first +name = "src" +version = "0.0.1" +requires-python = "==3.13.*" +dependencies = [ + # Frameworks + "torch==2.9.1", + + "transformers>=4.57.3", + "datasets>=4.4.2", + "modal>=1.3.0", + + # helper + "tqdm>=4.67.1", + "packaging", + "pydra-config", + "ninja>=1.13.0", + "tomli>=2.3.0", + "tabulate>=0.9.0", + + # Numerics + "einops>=0.8.1", + "python-dotenv>=1.2.1", + "numpy==2.4.0", + + # LLM providers + "openai>=2.14.0", + "litellm[proxy]>=1.80.10", +] + +[project.optional-dependencies] +gpu = [ + # GPU-specific dependencies (requires CUDA) + "triton==3.5.1", + "nvidia-cutlass-dsl", + "tilelang", + "cupy-cuda12x==13.6.0", +] +dev = [ + "pytest==9.0.2", + "ruff==0.14.10", +] + + +[tool.setuptools.packages.find] +where = ["."] +include = ["src*"] +# TODO: change to kb_src later \ No newline at end of file diff --git a/requirements.txt b/requirements.txt index 253e57da..8bf9a48f 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,31 +1,34 @@ +# ARCHIVED: We are transitioning to pyproject.toml and uv-based project management +# However, we provide this as a backup for now + # Frameworks # we use latest PyTorch stable release -torch==2.9.0 +torch==2.9.* +triton==3.5.* # we shall upgrade torch for blackwell when it is stable -transformers -datasets -modal +transformers>=4.57.3 +datasets>=4.4.2 +modal>=1.3.0 # DSLs nvidia-cutlass-dsl tilelang -triton # helper -tqdm +tqdm>=4.67.1 packaging -pydra_config -pytest -ninja -cupy-cuda12x +pydra-config +ninja>=1.13.0 +cupy-cuda12x==13.6.0 +tomli>=2.3.0 +tabulate>=0.9.0 # Numerics -einops -dotenv -numpy +einops>=0.8.1 +python-dotenv>=1.2.1 +numpy==2.4.0 # use litellm for cloud providers and openai for local -openai -litellm[proxy] - +openai>=2.14.0 +litellm[proxy]>=1.80.10 \ No newline at end of file diff --git a/scripts/eval_from_generations.py b/scripts/eval_from_generations.py index b28a3be0..e65825ad 100644 --- a/scripts/eval_from_generations.py +++ b/scripts/eval_from_generations.py @@ -67,7 +67,7 @@ "g++-10", "clang" ) - .pip_install_from_requirements(os.path.join(REPO_TOP_DIR, "requirements.txt")) + .uv_sync(uv_project_dir=REPO_TOP_DIR) .add_local_dir( KERNEL_BENCH_PATH, remote_path="/root/KernelBench" diff --git a/scripts/generate_and_eval_single_sample.py b/scripts/generate_and_eval_single_sample.py index 2e110932..9c3fde28 100644 --- a/scripts/generate_and_eval_single_sample.py +++ b/scripts/generate_and_eval_single_sample.py @@ -46,15 +46,17 @@ def __init__(self): # Evaluation # local (requires a GPU), modal (cloud GPU) coming soon - self.eval_mode = "local" + self.eval_mode = "local" + # only support local for now + # see scripts/eval_from_generations_modal.py for modal evaluation # Construct this from mapping from architecture name to torch cuda arch list in the future # you can either specify SM version or just use the name self.gpu_arch = ["Ada"] self.precision = "fp32" # options ["fp32", "fp16", "bf16"] # Inference config - self.server_type = None - self.model_name = None + self.server_type = REQUIRED + self.model_name = REQUIRED self.max_tokens = None self.temperature = None diff --git a/scripts/generate_and_eval_single_sample_modal.py b/scripts/generate_and_eval_single_sample_modal.py index f41ba95f..ff4b706a 100644 --- a/scripts/generate_and_eval_single_sample_modal.py +++ b/scripts/generate_and_eval_single_sample_modal.py @@ -14,7 +14,6 @@ from datasets import load_dataset #from src.dataset import construct_kernelbench_dataset -from src.prompt_constructor_toml import get_prompt_for_backend, get_custom_prompt from src.utils import extract_first_code, query_server, set_gpu_arch, read_file, create_inference_server_from_presets app = modal.App("eval_single_sample") @@ -102,7 +101,7 @@ def __repr__(self): "g++-10", "clang" # note i skip a step ) - .pip_install_from_requirements(os.path.join(REPO_TOP_DIR, "requirements.txt")) + .uv_sync(uv_project_dir=REPO_TOP_DIR, extras=["gpu"]) .add_local_python_source("src") ) @@ -238,6 +237,9 @@ def main(config: EvalConfig): "include_hardware_info is True but hardware_gpu_name is not provided." ) + # Lazy import prompt constructor + from src.prompt_constructor_toml import get_prompt_for_backend, get_custom_prompt + if custom_prompt_key: custom_prompt = get_custom_prompt( custom_prompt_key, diff --git a/scripts/generate_baseline_time_modal.py b/scripts/generate_baseline_time_modal.py index a0039193..ffdd8bd7 100644 --- a/scripts/generate_baseline_time_modal.py +++ b/scripts/generate_baseline_time_modal.py @@ -91,7 +91,7 @@ def __init__(self): "g++-10", "clang" # note i skip a step ) - .pip_install_from_requirements(os.path.join(REPO_TOP_PATH, "requirements.txt")) + .uv_sync(uv_project_dir=REPO_TOP_PATH, extras=["gpu"]) .add_local_dir( KERNEL_BENCH_PATH, remote_path="/root/KernelBench" diff --git a/scripts/run_and_check.py b/scripts/run_and_check.py index e0492938..8d9c313e 100644 --- a/scripts/run_and_check.py +++ b/scripts/run_and_check.py @@ -35,7 +35,7 @@ image = ( modal.Image.from_registry(f"nvidia/cuda:{tag}", add_python="3.10") .apt_install("git", "gcc-10", "g++-10", "clang") - .pip_install_from_requirements(os.path.join(REPO_TOP_PATH, "requirements.txt")) + .uv_sync(uv_project_dir=REPO_TOP_PATH) .add_local_dir(KERNEL_BENCH_PATH, remote_path="/root/KernelBench") .add_local_python_source("src") .add_local_python_source("scripts") diff --git a/setup.py b/setup.py deleted file mode 100644 index 220b79d1..00000000 --- a/setup.py +++ /dev/null @@ -1,8 +0,0 @@ -from setuptools import setup - -if __name__ == "__main__": - setup( - name="src", - version="0.0.1", - packages=["src"], - ) diff --git a/src/frameworks.py b/src/frameworks.py index cb3795f9..d102e35a 100644 --- a/src/frameworks.py +++ b/src/frameworks.py @@ -32,7 +32,6 @@ import shutil import concurrent from functools import cache -from transformers import AutoTokenizer import hashlib from concurrent.futures import ProcessPoolExecutor, as_completed diff --git a/src/utils.py b/src/utils.py index f4fac580..2ace37cd 100644 --- a/src/utils.py +++ b/src/utils.py @@ -25,11 +25,9 @@ from contextlib import contextmanager from collections import defaultdict import time -import shutil import concurrent from functools import cache -from transformers import AutoTokenizer -import hashlib + from concurrent.futures import ProcessPoolExecutor, as_completed From e0b1140062fd2eae0cde7fc51171ed893b0ab690 Mon Sep 17 00:00:00 2001 From: Simon Zirui Guo Date: Sat, 27 Dec 2025 14:42:53 -0500 Subject: [PATCH 13/24] Package Metadata / src path update (#114) * migrate src path * modal related update due to pkg import * remove pinged pkg version & verify local eval work with new pkg managaement --- README.md | 6 +- notebooks/tutorial.ipynb | 698 +++++++++++++++++- pyproject.toml | 48 +- scripts/benchmark_eval_analysis.py | 4 +- scripts/debug_stddout.py | 4 +- scripts/eval_from_generations.py | 25 +- scripts/generate_and_eval_single_sample.py | 12 +- .../generate_and_eval_single_sample_modal.py | 17 +- scripts/generate_baseline_time.py | 8 +- scripts/generate_baseline_time_modal.py | 19 +- scripts/generate_samples.py | 10 +- scripts/get_baseline_time_single_problem.py | 2 +- scripts/inspect_baseline.py | 4 +- scripts/inspect_kernel_pytorch_profiler.py | 8 +- scripts/inspect_triton.py | 4 +- scripts/run_and_check.py | 32 +- scripts/verify_generation.py | 4 +- src/{ => kernelbench}/__init__.py | 0 src/{ => kernelbench}/analysis.py | 0 src/{ => kernelbench}/compile.py | 4 +- src/{ => kernelbench}/dataset.py | 2 +- src/{ => kernelbench}/eval.py | 2 +- src/{ => kernelbench}/frameworks.py | 0 src/{ => kernelbench}/make_hf_dataset.py | 0 .../prompt_constructor_toml.py | 10 +- src/{ => kernelbench}/prompts/README.md | 0 .../prompts/cot/model_cot_fuse_gelu.py | 0 .../prompts/cot/model_cot_mnist2.py | 0 .../prompts/cot/model_cot_tiled_matmul.py | 0 .../prompts/few_shot/model_ex_add.py | 0 .../prompts/few_shot/model_ex_flash_attn.py | 0 .../prompts/few_shot/model_ex_fuse_gelu.py | 0 .../prompts/few_shot/model_ex_mnist2.py | 0 .../prompts/few_shot/model_ex_tiled_matmul.py | 0 .../prompts/few_shot/model_new_ex_add.py | 0 .../few_shot/model_new_ex_flash_attn.py | 0 .../few_shot/model_new_ex_fuse_gelu.py | 0 .../prompts/few_shot/model_new_ex_mnist2.py | 0 .../few_shot/model_new_ex_tiled_matmul.py | 0 .../prompts/hardware/gpu_specs.py | 0 src/{ => kernelbench}/prompts/model_ex_0.py | 0 src/{ => kernelbench}/prompts/model_ex_1.py | 0 src/{ => kernelbench}/prompts/model_ex_2.py | 0 src/{ => kernelbench}/prompts/model_ex_add.py | 0 .../prompts/model_new_ex_0.py | 0 .../prompts/model_new_ex_1.py | 0 .../prompts/model_new_ex_2.py | 0 .../prompts/model_new_ex_add.py | 0 .../prompts/model_new_ex_add_cute.py | 0 .../prompts/model_new_ex_add_tilelang.py | 0 .../prompts/model_new_ex_add_triton.py | 0 src/{ => kernelbench}/prompts/prompts.toml | 16 +- src/{ => kernelbench}/score.py | 0 src/{ => kernelbench}/timing.py | 8 +- .../unit_tests/test_dataset.py | 2 +- .../unit_tests/test_eval_adversarial.py | 6 +- .../unit_tests/test_eval_timing.py | 6 +- .../test_kernels/non_default_stream_kernel.py | 0 .../test_kernels/result_reuse_kernel.py | 0 .../test_kernels/zero_out_kernel.py | 0 .../unit_tests/test_score.py | 2 +- .../unit_tests/test_utils.py | 2 +- src/{ => kernelbench}/utils.py | 0 src/scratch/log.txt | 60 -- src/scratch/model.py | 0 src/scratch/model_new.py | 0 src/scratch/prompt.txt | 137 ---- src/scratch/test.py | 69 -- 68 files changed, 834 insertions(+), 397 deletions(-) rename src/{ => kernelbench}/__init__.py (100%) rename src/{ => kernelbench}/analysis.py (100%) rename src/{ => kernelbench}/compile.py (98%) rename src/{ => kernelbench}/dataset.py (99%) rename src/{ => kernelbench}/eval.py (99%) rename src/{ => kernelbench}/frameworks.py (100%) rename src/{ => kernelbench}/make_hf_dataset.py (100%) rename src/{ => kernelbench}/prompt_constructor_toml.py (98%) rename src/{ => kernelbench}/prompts/README.md (100%) rename src/{ => kernelbench}/prompts/cot/model_cot_fuse_gelu.py (100%) rename src/{ => kernelbench}/prompts/cot/model_cot_mnist2.py (100%) rename src/{ => kernelbench}/prompts/cot/model_cot_tiled_matmul.py (100%) rename src/{ => kernelbench}/prompts/few_shot/model_ex_add.py (100%) rename src/{ => kernelbench}/prompts/few_shot/model_ex_flash_attn.py (100%) rename src/{ => kernelbench}/prompts/few_shot/model_ex_fuse_gelu.py (100%) rename src/{ => kernelbench}/prompts/few_shot/model_ex_mnist2.py (100%) rename src/{ => kernelbench}/prompts/few_shot/model_ex_tiled_matmul.py (100%) rename src/{ => kernelbench}/prompts/few_shot/model_new_ex_add.py (100%) rename src/{ => kernelbench}/prompts/few_shot/model_new_ex_flash_attn.py (100%) rename src/{ => kernelbench}/prompts/few_shot/model_new_ex_fuse_gelu.py (100%) rename src/{ => kernelbench}/prompts/few_shot/model_new_ex_mnist2.py (100%) rename src/{ => kernelbench}/prompts/few_shot/model_new_ex_tiled_matmul.py (100%) rename src/{ => kernelbench}/prompts/hardware/gpu_specs.py (100%) rename src/{ => kernelbench}/prompts/model_ex_0.py (100%) rename src/{ => kernelbench}/prompts/model_ex_1.py (100%) rename src/{ => kernelbench}/prompts/model_ex_2.py (100%) rename src/{ => kernelbench}/prompts/model_ex_add.py (100%) rename src/{ => kernelbench}/prompts/model_new_ex_0.py (100%) rename src/{ => kernelbench}/prompts/model_new_ex_1.py (100%) rename src/{ => kernelbench}/prompts/model_new_ex_2.py (100%) rename src/{ => kernelbench}/prompts/model_new_ex_add.py (100%) rename src/{ => kernelbench}/prompts/model_new_ex_add_cute.py (100%) rename src/{ => kernelbench}/prompts/model_new_ex_add_tilelang.py (100%) rename src/{ => kernelbench}/prompts/model_new_ex_add_triton.py (100%) rename src/{ => kernelbench}/prompts/prompts.toml (91%) rename src/{ => kernelbench}/score.py (100%) rename src/{ => kernelbench}/timing.py (99%) rename src/{ => kernelbench}/unit_tests/test_dataset.py (95%) rename src/{ => kernelbench}/unit_tests/test_eval_adversarial.py (97%) rename src/{ => kernelbench}/unit_tests/test_eval_timing.py (96%) rename src/{ => kernelbench}/unit_tests/test_kernels/non_default_stream_kernel.py (100%) rename src/{ => kernelbench}/unit_tests/test_kernels/result_reuse_kernel.py (100%) rename src/{ => kernelbench}/unit_tests/test_kernels/zero_out_kernel.py (100%) rename src/{ => kernelbench}/unit_tests/test_score.py (99%) rename src/{ => kernelbench}/unit_tests/test_utils.py (96%) rename src/{ => kernelbench}/utils.py (100%) delete mode 100644 src/scratch/log.txt delete mode 100644 src/scratch/model.py delete mode 100644 src/scratch/model_new.py delete mode 100644 src/scratch/prompt.txt delete mode 100644 src/scratch/test.py diff --git a/README.md b/README.md index d30401ee..1f83bf1c 100644 --- a/README.md +++ b/README.md @@ -140,8 +140,10 @@ uv run python scripts/benchmark_eval_analysis.py run_name=test_hf_level_1 level= If you are using a different hardware, you can generate the baseline time with `scripts/generate_baseline_time.py` script. We provide some reference baseline times a variety of NVIDIA GPUs across generations in `results/timing`, but we recommend you to generate your own baseline time for more accurate results (cluster power, software version, all affects timing result). See `results/timing/README.md` for more details. -### Multi-Turn Framework -We have also releaed the test-time framework [Caesar](https://github.com/ScalingIntelligence/caesar) that are used in the multi-turn / iterative refinement experiments in our paper. You can use or modify this framework for high-throughput test-time scaling (both sequential and parallel) targeting KernelBench problems. +### Multi-Turn Framework & Integrations +We have also releaed the test-time framework [Caesar](https://github.com/ScalingIntelligence/caesar) that are used in the multi-turn / iterative refinement experiments in our paper. You can use or modify this framework for high-throughput test-time scaling (both sequential and parallel) targeting KernelBench problems. + +You can also use KernelBench as a library for your projects, for example: `from kernelbench import timing`, `from kernelbench import eval as kb_eval`, or `from kernelbench.utils import set_gpu_arch`. ## 🛣️ Upcoming Roadmap Check out our [roadmap](https://github.com/ScalingIntelligence/KernelBench/issues/74) for what we plan to add as features. We welcome community contirbutions in these directions. diff --git a/notebooks/tutorial.ipynb b/notebooks/tutorial.ipynb index ccb6a0fe..0d388168 100644 --- a/notebooks/tutorial.ipynb +++ b/notebooks/tutorial.ipynb @@ -1 +1,697 @@ -{"cells":[{"cell_type":"markdown","metadata":{"id":"DrHLiPZrHUGL"},"source":["# KernelBench: Tutorial [NeurIPS '25 Tutorial]\n","\n","\n","In this tutorial we will walk through the basics of KernelBench and let you try an example!\n","You can even do this in a Google Colab on T4 GPU.\n","\n","**ACTION: Make a copy of this Google Colab**\n","\n","We will use the open-source repo of [KernelBench](https://github.com/ScalingIntelligence/KernelBench) from Stanford's [Scaling Intelligence Lab](https://scalingintelligence.stanford.edu/).\n","\n","Made by Simon Guo, William Hu, Omar Abul-Hassan. Last updated Dec '25.\n","\n","Run this on Google Colab or your local machine with GPU.\n","\n","Contact: {simonguo, willhu}@stanford.edu"]},{"cell_type":"markdown","metadata":{"id":"S1YcMhdPdzgr"},"source":["### Set up\n","KernelBench needs to run on GPU (as we need to evaluate GPU kernels).\n","\n","We first check our runtime to confirm that we have a GPU."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"OfQmvwxRnAsn"},"outputs":[],"source":["!nvidia-smi"]},{"cell_type":"markdown","metadata":{"id":"hd6vWzvlel9I"},"source":["Next, let's set up KernelBench 🍿"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"ovSHH67nhqAv"},"outputs":[],"source":["!git clone https://github.com/ScalingIntelligence/KernelBench.git"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"X9fxf6dokOsY"},"outputs":[],"source":["%cd /content/KernelBench"]},{"cell_type":"markdown","metadata":{"id":"BansUz9GetpW"},"source":["Download dependencies! Ignore if you are running this locally, only follow those if you are on Colab."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"TiUQHO5FKJ58"},"outputs":[],"source":["# Latest KernelBench uses PyTorch 2.9.0 (latest version that supports Blackwell)\n","# !pip install -r requirements.txt\n","\n","# However, for this exercise, we will use the latest pytorch that ship with Google colab\n","import torch\n","torch.__version__"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"iDmolJHgK0pY"},"outputs":[],"source":["# here is a min set of our requirements\n","!pip install pydra_config\n","!pip install modal\n","!pip install litellm\n","!pip install ninja\n","!pip install tomli"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"1tNgE_0EkJa4"},"outputs":[],"source":["# install repo package\n","!pip install -e ."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"L18KV1JIlr3d"},"outputs":[],"source":["import os\n","# temporary directory for storing kernels\n","directory = \"tmp\"\n","if not os.path.exists(directory):\n"," os.makedirs(directory)"]},{"cell_type":"markdown","metadata":{"id":"TJWcEPbFH_X1"},"source":["## KernelBench Task Format\n","\n","KernelBench is a benchmark and environment for evaluating LLM's ability to generate efficient GPU kernels. You can read more from our [paper](https://arxiv.org/abs/2502.10517).\n","\n","\n","Concretely, KernelBench tasks LMs with generating optimized CUDA kernels for a given target PyTorch model architecture and conducts automated evaluation\n","\n","* Input: `Model` as PyTorch reference\n","* Output: `ModelNew` of PyTorch + inline CUDA kernel.\n","\n","The model has freedom to choose which part of the input PyTorch ops it would optimize and generate CUDA kernels."]},{"cell_type":"markdown","metadata":{"id":"7RR_AKLEIH9s"},"source":["![KernelBench Flow.png](data:image/png;base64,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)"]},{"cell_type":"markdown","metadata":{"id":"vPks2ppBe0fz"},"source":["As a minimum example, we show the case for **Element-wise Addition**.\n","\n","KernelBench relies on comparing two implementations:\n","1. **Reference (`Model`):** The ground-truth PyTorch code.\n","2. **Generation (`ModelNew`):** The LLM-generated code containing an inline C++/CUDA kernel.\n","\n","Here we save them to locally to demonstrate a minimum evaluation flow.\n","\n","First, we show the PyTorch reference for element-wise addition."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"X08GwJoTkSVL"},"outputs":[],"source":["ex_add_model_ref = '''\n","import torch\n","import torch.nn as nn\n","import torch.nn.functional as F\n","\n","\n","class Model(nn.Module):\n"," def __init__(self) -> None:\n"," super().__init__()\n","\n"," def forward(self, a, b):\n"," return a + b\n","\n","\n","def get_inputs():\n"," # randomly generate input tensors based on the model architecture\n"," a = torch.randn(1, 128).cuda()\n"," b = torch.randn(1, 128).cuda()\n"," return [a, b]\n","\n","\n","def get_init_inputs():\n"," # randomly generate tensors required for initialization based on the model architecture\n"," return []\n","'''\n","\n","\n","with open(\"tmp/ex_add_model_ref.py\", \"w\") as f:\n"," f.write(ex_add_model_ref)"]},{"cell_type":"markdown","metadata":{"id":"5HlxdGxLfC-x"},"source":["Here, we have a PyTorch module `ModelNew` with **inline `cuda` kernel**. This would be typically be the AI-generated kernel."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"TzBlFv4EmBXj"},"outputs":[],"source":["ex_add_model_generation = '''\n","import torch\n","import torch.nn as nn\n","import torch.nn.functional as F\n","from torch.utils.cpp_extension import load_inline\n","\n","# Define the custom CUDA kernel for element-wise addition\n","elementwise_add_source = \"\"\"\n","#include \n","#include \n","\n","__global__ void elementwise_add_kernel(const float* a, const float* b, float* out, int size) {\n"," int idx = blockIdx.x * blockDim.x + threadIdx.x;\n"," if (idx < size) {\n"," out[idx] = a[idx] + b[idx];\n"," }\n","}\n","\n","torch::Tensor elementwise_add_cuda(torch::Tensor a, torch::Tensor b) {\n"," auto size = a.numel();\n"," auto out = torch::zeros_like(a);\n","\n"," const int block_size = 256;\n"," const int num_blocks = (size + block_size - 1) / block_size;\n","\n"," elementwise_add_kernel<<>>(a.data_ptr(), b.data_ptr(), out.data_ptr(), size);\n","\n"," return out;\n","}\n","\"\"\"\n","\n","elementwise_add_cpp_source = (\n"," \"torch::Tensor elementwise_add_cuda(torch::Tensor a, torch::Tensor b);\"\n",")\n","\n","# Compile the inline CUDA code for element-wise addition\n","elementwise_add = load_inline(\n"," name=\"elementwise_add\",\n"," cpp_sources=elementwise_add_cpp_source,\n"," cuda_sources=elementwise_add_source,\n"," functions=[\"elementwise_add_cuda\"],\n"," verbose=True,\n"," extra_cflags=[\"\"],\n"," extra_ldflags=[\"\"],\n",")\n","\n","\n","class ModelNew(nn.Module):\n"," def __init__(self) -> None:\n"," super().__init__()\n"," self.elementwise_add = elementwise_add\n","\n"," def forward(self, a, b):\n"," return self.elementwise_add.elementwise_add_cuda(a, b)\n","'''\n","\n","with open(\"tmp/ex_add_model_generation.py\", \"w\") as f:\n"," f.write(ex_add_model_generation)"]},{"cell_type":"markdown","metadata":{"id":"qvAh7qSJfG4Z"},"source":["Run `run_and_check.py`\\ with the generation (with inline cuda, here `ex_add_model_generation`) against refernece (pure PyTorch, here `ex_add_model_ref`)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"imK4xekPmMTH"},"outputs":[],"source":["!python3 scripts/run_and_check.py ref_origin=local gpu_arch=\"['Turing']\" ref_arch_src_path=tmp/ex_add_model_ref.py kernel_src_path=tmp/ex_add_model_generation.py"]},{"cell_type":"markdown","metadata":{"id":"e2t6qmqQP-rv"},"source":["Note PyTorch `torch.compile` has some runtime (beyond compile!) overhead. Note it also has many modes for compilation, while performance varies based on hardware SM generation and PyTorch version.\n","\n","For Level 1, we recommend compare against Torch Eager.\n","For Level 2/3, we recommend compare against `torch.compile`."]},{"cell_type":"markdown","metadata":{"id":"hk4pRkSTLIhH"},"source":["# Evaluating a generated KernelBench kernel example"]},{"cell_type":"markdown","metadata":{"id":"O_udy-5YMz_a"},"source":["We designed KernelBench with 3 levels (total 250 tasks), each challenging in a distinct way:\n","\n","\n","* **Level 1 Single Operators** (100): e.g., matmul, conv; this is actually quite hard since we would be competing against highly-optimized libraries\n","* **Level 2 Sequence of Operators** (100): help test model’s ability to conduct kernel fusion, a key technique used by graph compilers\n","* **Level 3 End-to-end architectures** (50): like a Vision Transformer or Mamba block, evaluate model’s ability to identify optimization opportunities within whole model architecture\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"uwiPLh0OW9QS"},"outputs":[],"source":["# @title Select KernelBench Problem Configuration 🎛️\n","# @markdown Select the difficulty level (1-3) and specific problem ID.\n","# @markdown * **Level 1 & 2:** 100 Problems\n","# @markdown * **Level 3:** 50 Problems\n","\n","level = 1 # @param {type:\"slider\", min:1, max:3, step:1}\n","problem_id = 1 # @param {type:\"slider\", min:1, max:100, step:1}\n","\n","# Input Validation Logic\n","max_problems = 50 if level == 3 else 100\n","\n","if problem_id > max_problems:\n"," print(f\"⚠️ Warning: Level {level} only has {max_problems} problems.\")\n"," print(f\" -> Automatically adjusting Problem ID from {problem_id} to {max_problems}.\")\n"," problem_id = max_problems\n","\n","print(f\"Selected: Level {level}, Problem ID {problem_id}\")"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"1FE37L7AXbgY"},"outputs":[],"source":["from datasets import load_dataset\n","import os\n","\n","# Load the dataset based on the sliders above\n","dataset = load_dataset(\"ScalingIntelligence/KernelBench\")\n","level_string = \"level_\" + f\"{level}\"\n","\n","try:\n"," # Fetch the problem\n"," target_kernel_reference = dataset[level_string][problem_id][\"code\"]\n"," problem_name = dataset[level_string][problem_id][\"name\"]\n","\n"," print(f\"✅ Successfully loaded: {problem_name}\")\n"," print(\"=\"*80)\n"," print(target_kernel_reference)\n","\n"," # Save to file for the next steps\n"," with open(\"tmp/reference.py\", \"w\") as f:\n"," f.write(target_kernel_reference)\n","\n","except IndexError:\n"," print(f\"❌ Error: Problem ID {problem_id} does not exist in Level {level}. Please adjust the slider to a lower number.\")"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"FFs0B2H7NJQU"},"outputs":[],"source":["target_kernel_reference = dataset[level_string][problem_id][\"code\"]\n","print(target_kernel_reference)\n","\n","with open(\"tmp/reference.py\", \"w\") as f:\n"," f.write(target_kernel_reference)"]},{"cell_type":"markdown","metadata":{"id":"fiSSqpKgXfwy"},"source":["\n","Now we construct the context to condition the LM for generation.\n","\n","The context consists of:\n","1. **PyTorch Source:** We take the reference PyTorch code of the KernelBench problem.\n","2. **Few-Shot Examples [Optional]:** We include a few examples of hand-written pairs of `Model`, `ModelNew`. By default, we use the pair of element-wise add example to show model the correct syntax and class structure, (aka how to use `torch.utils.cpp_extension.load_inline`).\n","3. **Hardware Context [Optional]:** We inject specific GPU specs (e.g., **SRAM size, memory bandwidth**) into the prompt. This allows the LLM to potentially calculate adjust tile sizes (e.g., `BLOCK_SIZE`) for your specific hardware (T4 vs A100).\n","4. **Backend & Precision**: You can specify which backend (`cuda` or other DSLs) and numerical percision.\n","\n","Of course you can also customize your prompt, or plug in your favorite agentic systems. For this tutorial, you will **copy** (or modify) the generated prompt below, send it to your favorite model / coding agent, and **paste** the result back!"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"ShZPHpnR5axP"},"outputs":[],"source":["from src.prompt_constructor_toml import get_prompt_for_backend\n","\n","# Here is an example of a constructed context with hardware context\n","# This injects specs (memory bandwidth, cache size) from src/prompts/hardware/gpu_specs.py\n","# helping the LLM optimize tile sizes for your specific GPU.\n","\n","prompt = get_prompt_for_backend(\n"," ref_arch_src=target_kernel_reference,\n"," backend=\"cuda\", # You can also try \"triton\" or \"tilelang\" here!\n"," option=\"one_shot\", # <--- show example of generation format via minimum example\n"," include_hardware=True, # <--- Enable hardware specific context\n"," gpu_name=\"T4\" # <--- Specify your GPU (matches keys in gpu_specs.py)\n",")\n","\n","print(\"=\"*40)\n","print(\" ⬇️ COPY THIS PROMPT TO YOUR LLM ⬇️ \")\n","print(\"=\"*40)\n","print(prompt)\n","print(\"=\"*40)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"MIbCOK5GXh_U"},"outputs":[],"source":["target_kernel_generation = \"paste the output here\""]},{"cell_type":"markdown","source":["For this tutorial, we have pre-generated a solution for the Matrix Multiplication problem (level=1, problem=1) using a standard LLM.\n","\n","**Note:** The kernel below is a naive CUDA implementation. While functionally correct, it's *slower* than PyTorch (which uses highly optimized cuBLAS). This is expected in Level 1. The challenge is to prompt the LLM to write tiled/shared-memory implementations to beat cuBLAS."],"metadata":{"id":"8yKcKFlV87PC"}},{"cell_type":"code","execution_count":null,"metadata":{"id":"364q0fwGLE2r"},"outputs":[],"source":["# Here is an example model-generated kernel if you chose to optimize Level 1 Problem 1\n","\n","# By the way, this is a very slow and naive implementation in cuda; lots of room for improvement, try how you can beat this with your own generation!\n","\n","level_1_problem_1_sample_0_kernel = '''import torch\n","import torch.nn as nn\n","from torch.utils.cpp_extension import load_inline\n","\n","# Define the custom CUDA kernel for matrix multiplication\n","matrix_multiply_source = \"\"\"\n","#include \n","#include \n","\n","__global__ void matrix_multiply_kernel(const float* A, const float* B, float* C, int N) {\n"," int row = blockIdx.x * blockDim.x + threadIdx.x;\n"," int col = blockIdx.y * blockDim.y + threadIdx.y;\n","\n"," if (row < N && col < N) {\n"," float sum = 0.0f;\n"," for (int i = 0; i < N; i++) {\n"," sum += A[row * N + i] * B[i * N + col];\n"," }\n"," C[row * N + col] = sum;\n"," }\n","}\n","\n","torch::Tensor matrix_multiply_cuda(torch::Tensor A, torch::Tensor B) {\n"," auto N = A.size(0);\n"," auto C = torch::zeros_like(A);\n","\n"," const int block_size = 16;\n"," const int num_blocks_x = (N + block_size - 1) / block_size;\n"," const int num_blocks_y = (N + block_size - 1) / block_size;\n","\n"," dim3 block(block_size, block_size);\n"," dim3 grid(num_blocks_x, num_blocks_y);\n","\n"," matrix_multiply_kernel<<>>(A.data_ptr(), B.data_ptr(), C.data_ptr(), N);\n","\n"," return C;\n","}\n","\"\"\"\n","\n","matrix_multiply_cpp_source = (\n"," \"torch::Tensor matrix_multiply_cuda(torch::Tensor A, torch::Tensor B);\"\n",")\n","\n","# Compile the inline CUDA code for matrix multiplication\n","matrix_multiply = load_inline(\n"," name=\"matrix_multiply\",\n"," cpp_sources=matrix_multiply_cpp_source,\n"," cuda_sources=matrix_multiply_source,\n"," functions=[\"matrix_multiply_cuda\"],\n"," verbose=True,\n"," extra_cflags=[\"\"],\n"," extra_ldflags=[\"\"],\n",")\n","\n","\n","class ModelNew(nn.Module):\n"," def __init__(self):\n"," super(ModelNew, self).__init__()\n"," self.matrix_multiply = matrix_multiply\n","\n"," def forward(self, A: torch.Tensor, B: torch.Tensor) -> torch.Tensor:\n"," return self.matrix_multiply.matrix_multiply_cuda(A, B)\n","'''\n","\n","# uncomment if you want to use this example\n","target_kernel_generation = level_1_problem_1_sample_0_kernel"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"7R9mvYJ3NVr7"},"outputs":[],"source":["with open(\"tmp/generation.py\", \"w\") as f:\n"," f.write(target_kernel_generation)"]},{"cell_type":"markdown","metadata":{"id":"HkbNLSZLNs7t"},"source":["## Check your Generated Kernel Performance\n"]},{"cell_type":"markdown","metadata":{"id":"UFxnQx9mRR8K"},"source":["Note some of the KernelBench problem sizes are quite big! This is too ensure [CPU overhead](https://scalingintelligence.stanford.edu/blogs/kernelbenchv01/) is not too significant. As our tensor sizes are calibrated on NVIDIA H100, you might run into OOM on a small GPU for some problems; reduce the problem sizes for those!\n","\n","Adjust `precision`, `num_trials`, `backend` etc as needed!"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"OrtiIIM4Lw2p"},"outputs":[],"source":["!python scripts/run_and_check.py ref_origin=kernelbench gpu_arch=\"['Turing']\" level={level} problem_id={problem_id} kernel_src_path=tmp/generation.py"]},{"cell_type":"markdown","source":["When you run the command above, look for these lines in the logs for evaluation result:\n","\n","1. **`[Eval] Correctness: True/False`**:\n"," * This runs the kernel against the reference with random inputs with `num_correct_trials`.\n"," * For **FP32**, we enforce `atol=1e-4`. Following PyTorch guideline, we have different tolerance for various precisions.\n"," * If this fails, the kernel is functionally invalid, and speedup metrics are ignored.\n","\n","2. **`[Speedup] Speedup over eager: X.XXx`**:\n"," * For Speedup we run both the reference and generated kernel `num_trials` time (100 typically), and compute speedup!\n"," * `< 1.0x`: The generated kernel is slower than PyTorch (common for naive implementations).\n"," * `> 1.0x`: The generated kernel is faster.\n","\n","3. **`[Speedup] Speedup over torch.compile: Y.YYx`**:\n"," * This compares against `torch.compile(mode=\"inductor\")`. This is the harder boss to beat for Level 2/3 problems involving kernel fusions!"],"metadata":{"id":"zn3PRPti-IJK"}},{"cell_type":"markdown","source":["## Next Steps\n","\n","Congrats on finishing this tutorial! We show the minimum usage of KernelBench. Beyond acting as a benchmark, KernelBench tasks also serve as an environment to develop many techniques to tackle AI-generating GPU kernels. We have noted down many of the developments we are aware [here](https://docs.google.com/document/d/e/2PACX-1vTjS-UMH1HB5n_PENq2k-3YRfXIXkqKIKeNC2zcWMyLPdl4Jrwvdk4dNDVSsM8ybKrCxZB7GJq1slZF/pub), from building agentic systems to applying reinforcement learning.\n","\n","As a pro tip, you should be always **careful about speedup numbers**; kernel engineers and existing compilers are already pretty good, so a >2x speedup for anything is highly unlikely. While we are constantly improving our eval to be more robust and comprehensive, you should always **read the generated kernel in detail** to avoid reward hacking! \n","\n","As a KernelBench is an open-soruce project, you are welcome to contribute to our [Github](https://github.com/ScalingIntelligence/KernelBench) to add new features or make it better!\n","\n","Have fun playing with KernelBench! Can't wait to see what you find out!\n"],"metadata":{"id":"sr4VfQBheBYP"}},{"cell_type":"code","source":[],"metadata":{"id":"KGFQiYxAeoZM"},"execution_count":null,"outputs":[]}],"metadata":{"accelerator":"GPU","colab":{"gpuType":"T4","provenance":[]},"kernelspec":{"display_name":"kernel-bench","language":"python","name":"python3"},"language_info":{"name":"python","version":"3.10.18"}},"nbformat":4,"nbformat_minor":0} \ No newline at end of file +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "DrHLiPZrHUGL" + }, + "source": [ + "# KernelBench: Tutorial [NeurIPS '25 Tutorial]\n", + "\n", + "\n", + "In this tutorial we will walk through the basics of KernelBench and let you try an example!\n", + "You can even do this in a Google Colab on T4 GPU.\n", + "\n", + "**ACTION: Make a copy of this Google Colab**\n", + "\n", + "We will use the open-source repo of [KernelBench](https://github.com/ScalingIntelligence/KernelBench) from Stanford's [Scaling Intelligence Lab](https://scalingintelligence.stanford.edu/).\n", + "\n", + "Made by Simon Guo, William Hu, Omar Abul-Hassan. Last updated Dec '25.\n", + "\n", + "Run this on Google Colab or your local machine with GPU.\n", + "\n", + "Contact: {simonguo, willhu}@stanford.edu" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "S1YcMhdPdzgr" + }, + "source": [ + "### Set up\n", + "KernelBench needs to run on GPU (as we need to evaluate GPU kernels).\n", + "\n", + "We first check our runtime to confirm that we have a GPU." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "OfQmvwxRnAsn" + }, + "outputs": [], + "source": [ + "!nvidia-smi" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hd6vWzvlel9I" + }, + "source": [ + "Next, let's set up KernelBench 🍿" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "ovSHH67nhqAv" + }, + "outputs": [], + "source": [ + "!git clone https://github.com/ScalingIntelligence/KernelBench.git" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "X9fxf6dokOsY" + }, + "outputs": [], + "source": [ + "%cd /content/KernelBench" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BansUz9GetpW" + }, + "source": [ + "Download dependencies! Ignore if you are running this locally, only follow those if you are on Colab." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "TiUQHO5FKJ58" + }, + "outputs": [], + "source": [ + "# Latest KernelBench uses PyTorch 2.9.0 (latest version that supports Blackwell)\n", + "# !pip install -r requirements.txt\n", + "\n", + "# However, for this exercise, we will use the latest pytorch that ship with Google colab\n", + "import torch\n", + "torch.__version__" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "iDmolJHgK0pY" + }, + "outputs": [], + "source": [ + "# here is a min set of our requirements\n", + "!pip install pydra_config\n", + "!pip install modal\n", + "!pip install litellm\n", + "!pip install ninja\n", + "!pip install tomli" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "1tNgE_0EkJa4" + }, + "outputs": [], + "source": [ + "# install repo package\n", + "!pip install -e ." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "L18KV1JIlr3d" + }, + "outputs": [], + "source": [ + "import os\n", + "# temporary directory for storing kernels\n", + "directory = \"tmp\"\n", + "if not os.path.exists(directory):\n", + " os.makedirs(directory)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "TJWcEPbFH_X1" + }, + "source": [ + "## KernelBench Task Format\n", + "\n", + "KernelBench is a benchmark and environment for evaluating LLM's ability to generate efficient GPU kernels. You can read more from our [paper](https://arxiv.org/abs/2502.10517).\n", + "\n", + "\n", + "Concretely, KernelBench tasks LMs with generating optimized CUDA kernels for a given target PyTorch model architecture and conducts automated evaluation\n", + "\n", + "* Input: `Model` as PyTorch reference\n", + "* Output: `ModelNew` of PyTorch + inline CUDA kernel.\n", + "\n", + "The model has freedom to choose which part of the input PyTorch ops it would optimize and generate CUDA kernels." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7RR_AKLEIH9s" + }, + "source": [ + "![KernelBench Flow.png](data:image/png;base64,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)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vPks2ppBe0fz" + }, + "source": [ + "As a minimum example, we show the case for **Element-wise Addition**.\n", + "\n", + "KernelBench relies on comparing two implementations:\n", + "1. **Reference (`Model`):** The ground-truth PyTorch code.\n", + "2. **Generation (`ModelNew`):** The LLM-generated code containing an inline C++/CUDA kernel.\n", + "\n", + "Here we save them to locally to demonstrate a minimum evaluation flow.\n", + "\n", + "First, we show the PyTorch reference for element-wise addition." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "X08GwJoTkSVL" + }, + "outputs": [], + "source": [ + "ex_add_model_ref = '''\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "\n", + "\n", + "class Model(nn.Module):\n", + " def __init__(self) -> None:\n", + " super().__init__()\n", + "\n", + " def forward(self, a, b):\n", + " return a + b\n", + "\n", + "\n", + "def get_inputs():\n", + " # randomly generate input tensors based on the model architecture\n", + " a = torch.randn(1, 128).cuda()\n", + " b = torch.randn(1, 128).cuda()\n", + " return [a, b]\n", + "\n", + "\n", + "def get_init_inputs():\n", + " # randomly generate tensors required for initialization based on the model architecture\n", + " return []\n", + "'''\n", + "\n", + "\n", + "with open(\"tmp/ex_add_model_ref.py\", \"w\") as f:\n", + " f.write(ex_add_model_ref)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5HlxdGxLfC-x" + }, + "source": [ + "Here, we have a PyTorch module `ModelNew` with **inline `cuda` kernel**. This would be typically be the AI-generated kernel." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "TzBlFv4EmBXj" + }, + "outputs": [], + "source": [ + "ex_add_model_generation = '''\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "from torch.utils.cpp_extension import load_inline\n", + "\n", + "# Define the custom CUDA kernel for element-wise addition\n", + "elementwise_add_source = \"\"\"\n", + "#include \n", + "#include \n", + "\n", + "__global__ void elementwise_add_kernel(const float* a, const float* b, float* out, int size) {\n", + " int idx = blockIdx.x * blockDim.x + threadIdx.x;\n", + " if (idx < size) {\n", + " out[idx] = a[idx] + b[idx];\n", + " }\n", + "}\n", + "\n", + "torch::Tensor elementwise_add_cuda(torch::Tensor a, torch::Tensor b) {\n", + " auto size = a.numel();\n", + " auto out = torch::zeros_like(a);\n", + "\n", + " const int block_size = 256;\n", + " const int num_blocks = (size + block_size - 1) / block_size;\n", + "\n", + " elementwise_add_kernel<<>>(a.data_ptr(), b.data_ptr(), out.data_ptr(), size);\n", + "\n", + " return out;\n", + "}\n", + "\"\"\"\n", + "\n", + "elementwise_add_cpp_source = (\n", + " \"torch::Tensor elementwise_add_cuda(torch::Tensor a, torch::Tensor b);\"\n", + ")\n", + "\n", + "# Compile the inline CUDA code for element-wise addition\n", + "elementwise_add = load_inline(\n", + " name=\"elementwise_add\",\n", + " cpp_sources=elementwise_add_cpp_source,\n", + " cuda_sources=elementwise_add_source,\n", + " functions=[\"elementwise_add_cuda\"],\n", + " verbose=True,\n", + " extra_cflags=[\"\"],\n", + " extra_ldflags=[\"\"],\n", + ")\n", + "\n", + "\n", + "class ModelNew(nn.Module):\n", + " def __init__(self) -> None:\n", + " super().__init__()\n", + " self.elementwise_add = elementwise_add\n", + "\n", + " def forward(self, a, b):\n", + " return self.elementwise_add.elementwise_add_cuda(a, b)\n", + "'''\n", + "\n", + "with open(\"tmp/ex_add_model_generation.py\", \"w\") as f:\n", + " f.write(ex_add_model_generation)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qvAh7qSJfG4Z" + }, + "source": [ + "Run `run_and_check.py`\\ with the generation (with inline cuda, here `ex_add_model_generation`) against refernece (pure PyTorch, here `ex_add_model_ref`)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "imK4xekPmMTH" + }, + "outputs": [], + "source": [ + "!python3 scripts/run_and_check.py ref_origin=local gpu_arch=\"['Turing']\" ref_arch_src_path=tmp/ex_add_model_ref.py kernel_src_path=tmp/ex_add_model_generation.py" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "e2t6qmqQP-rv" + }, + "source": [ + "Note PyTorch `torch.compile` has some runtime (beyond compile!) overhead. Note it also has many modes for compilation, while performance varies based on hardware SM generation and PyTorch version.\n", + "\n", + "For Level 1, we recommend compare against Torch Eager.\n", + "For Level 2/3, we recommend compare against `torch.compile`." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hk4pRkSTLIhH" + }, + "source": [ + "# Evaluating a generated KernelBench kernel example" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "O_udy-5YMz_a" + }, + "source": [ + "We designed KernelBench with 3 levels (total 250 tasks), each challenging in a distinct way:\n", + "\n", + "\n", + "* **Level 1 Single Operators** (100): e.g., matmul, conv; this is actually quite hard since we would be competing against highly-optimized libraries\n", + "* **Level 2 Sequence of Operators** (100): help test model’s ability to conduct kernel fusion, a key technique used by graph compilers\n", + "* **Level 3 End-to-end architectures** (50): like a Vision Transformer or Mamba block, evaluate model’s ability to identify optimization opportunities within whole model architecture\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "uwiPLh0OW9QS" + }, + "outputs": [], + "source": [ + "# @title Select KernelBench Problem Configuration 🎛️\n", + "# @markdown Select the difficulty level (1-3) and specific problem ID.\n", + "# @markdown * **Level 1 & 2:** 100 Problems\n", + "# @markdown * **Level 3:** 50 Problems\n", + "\n", + "level = 1 # @param {type:\"slider\", min:1, max:3, step:1}\n", + "problem_id = 1 # @param {type:\"slider\", min:1, max:100, step:1}\n", + "\n", + "# Input Validation Logic\n", + "max_problems = 50 if level == 3 else 100\n", + "\n", + "if problem_id > max_problems:\n", + " print(f\"⚠️ Warning: Level {level} only has {max_problems} problems.\")\n", + " print(f\" -> Automatically adjusting Problem ID from {problem_id} to {max_problems}.\")\n", + " problem_id = max_problems\n", + "\n", + "print(f\"Selected: Level {level}, Problem ID {problem_id}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "1FE37L7AXbgY" + }, + "outputs": [], + "source": [ + "from datasets import load_dataset\n", + "import os\n", + "\n", + "# Load the dataset based on the sliders above\n", + "dataset = load_dataset(\"ScalingIntelligence/KernelBench\")\n", + "level_string = \"level_\" + f\"{level}\"\n", + "\n", + "try:\n", + " # Fetch the problem\n", + " target_kernel_reference = dataset[level_string][problem_id][\"code\"]\n", + " problem_name = dataset[level_string][problem_id][\"name\"]\n", + "\n", + " print(f\"✅ Successfully loaded: {problem_name}\")\n", + " print(\"=\"*80)\n", + " print(target_kernel_reference)\n", + "\n", + " # Save to file for the next steps\n", + " with open(\"tmp/reference.py\", \"w\") as f:\n", + " f.write(target_kernel_reference)\n", + "\n", + "except IndexError:\n", + " print(f\"❌ Error: Problem ID {problem_id} does not exist in Level {level}. Please adjust the slider to a lower number.\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "FFs0B2H7NJQU" + }, + "outputs": [], + "source": [ + "target_kernel_reference = dataset[level_string][problem_id][\"code\"]\n", + "print(target_kernel_reference)\n", + "\n", + "with open(\"tmp/reference.py\", \"w\") as f:\n", + " f.write(target_kernel_reference)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fiSSqpKgXfwy" + }, + "source": [ + "\n", + "Now we construct the context to condition the LM for generation.\n", + "\n", + "The context consists of:\n", + "1. **PyTorch Source:** We take the reference PyTorch code of the KernelBench problem.\n", + "2. **Few-Shot Examples [Optional]:** We include a few examples of hand-written pairs of `Model`, `ModelNew`. By default, we use the pair of element-wise add example to show model the correct syntax and class structure, (aka how to use `torch.utils.cpp_extension.load_inline`).\n", + "3. **Hardware Context [Optional]:** We inject specific GPU specs (e.g., **SRAM size, memory bandwidth**) into the prompt. This allows the LLM to potentially calculate adjust tile sizes (e.g., `BLOCK_SIZE`) for your specific hardware (T4 vs A100).\n", + "4. **Backend & Precision**: You can specify which backend (`cuda` or other DSLs) and numerical percision.\n", + "\n", + "Of course you can also customize your prompt, or plug in your favorite agentic systems. For this tutorial, you will **copy** (or modify) the generated prompt below, send it to your favorite model / coding agent, and **paste** the result back!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "ShZPHpnR5axP" + }, + "outputs": [], + "source": [ + "from kernelbench.prompt_constructor_toml import get_prompt_for_backend\n", + "\n", + "# Here is an example of a constructed context with hardware context\n", + "# This injects specs (memory bandwidth, cache size) from kernelbench/prompts/hardware/gpu_specs.py\n", + "# helping the LLM optimize tile sizes for your specific GPU.\n", + "\n", + "prompt = get_prompt_for_backend(\n", + " ref_arch_src=target_kernel_reference,\n", + " backend=\"cuda\", # You can also try \"triton\" or \"tilelang\" here!\n", + " option=\"one_shot\", # <--- show example of generation format via minimum example\n", + " include_hardware=True, # <--- Enable hardware specific context\n", + " gpu_name=\"T4\" # <--- Specify your GPU (matches keys in gpu_specs.py)\n", + ")\n", + "\n", + "print(\"=\"*40)\n", + "print(\" ⬇️ COPY THIS PROMPT TO YOUR LLM ⬇️ \")\n", + "print(\"=\"*40)\n", + "print(prompt)\n", + "print(\"=\"*40)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "MIbCOK5GXh_U" + }, + "outputs": [], + "source": [ + "target_kernel_generation = \"paste the output here\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8yKcKFlV87PC" + }, + "source": [ + "For this tutorial, we have pre-generated a solution for the Matrix Multiplication problem (level=1, problem=1) using a standard LLM.\n", + "\n", + "**Note:** The kernel below is a naive CUDA implementation. While functionally correct, it's *slower* than PyTorch (which uses highly optimized cuBLAS). This is expected in Level 1. The challenge is to prompt the LLM to write tiled/shared-memory implementations to beat cuBLAS." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "364q0fwGLE2r" + }, + "outputs": [], + "source": [ + "# Here is an example model-generated kernel if you chose to optimize Level 1 Problem 1\n", + "\n", + "# By the way, this is a very slow and naive implementation in cuda; lots of room for improvement, try how you can beat this with your own generation!\n", + "\n", + "level_1_problem_1_sample_0_kernel = '''import torch\n", + "import torch.nn as nn\n", + "from torch.utils.cpp_extension import load_inline\n", + "\n", + "# Define the custom CUDA kernel for matrix multiplication\n", + "matrix_multiply_source = \"\"\"\n", + "#include \n", + "#include \n", + "\n", + "__global__ void matrix_multiply_kernel(const float* A, const float* B, float* C, int N) {\n", + " int row = blockIdx.x * blockDim.x + threadIdx.x;\n", + " int col = blockIdx.y * blockDim.y + threadIdx.y;\n", + "\n", + " if (row < N && col < N) {\n", + " float sum = 0.0f;\n", + " for (int i = 0; i < N; i++) {\n", + " sum += A[row * N + i] * B[i * N + col];\n", + " }\n", + " C[row * N + col] = sum;\n", + " }\n", + "}\n", + "\n", + "torch::Tensor matrix_multiply_cuda(torch::Tensor A, torch::Tensor B) {\n", + " auto N = A.size(0);\n", + " auto C = torch::zeros_like(A);\n", + "\n", + " const int block_size = 16;\n", + " const int num_blocks_x = (N + block_size - 1) / block_size;\n", + " const int num_blocks_y = (N + block_size - 1) / block_size;\n", + "\n", + " dim3 block(block_size, block_size);\n", + " dim3 grid(num_blocks_x, num_blocks_y);\n", + "\n", + " matrix_multiply_kernel<<>>(A.data_ptr(), B.data_ptr(), C.data_ptr(), N);\n", + "\n", + " return C;\n", + "}\n", + "\"\"\"\n", + "\n", + "matrix_multiply_cpp_source = (\n", + " \"torch::Tensor matrix_multiply_cuda(torch::Tensor A, torch::Tensor B);\"\n", + ")\n", + "\n", + "# Compile the inline CUDA code for matrix multiplication\n", + "matrix_multiply = load_inline(\n", + " name=\"matrix_multiply\",\n", + " cpp_sources=matrix_multiply_cpp_source,\n", + " cuda_sources=matrix_multiply_source,\n", + " functions=[\"matrix_multiply_cuda\"],\n", + " verbose=True,\n", + " extra_cflags=[\"\"],\n", + " extra_ldflags=[\"\"],\n", + ")\n", + "\n", + "\n", + "class ModelNew(nn.Module):\n", + " def __init__(self):\n", + " super(ModelNew, self).__init__()\n", + " self.matrix_multiply = matrix_multiply\n", + "\n", + " def forward(self, A: torch.Tensor, B: torch.Tensor) -> torch.Tensor:\n", + " return self.matrix_multiply.matrix_multiply_cuda(A, B)\n", + "'''\n", + "\n", + "# uncomment if you want to use this example\n", + "target_kernel_generation = level_1_problem_1_sample_0_kernel" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "7R9mvYJ3NVr7" + }, + "outputs": [], + "source": [ + "with open(\"tmp/generation.py\", \"w\") as f:\n", + " f.write(target_kernel_generation)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HkbNLSZLNs7t" + }, + "source": [ + "## Check your Generated Kernel Performance\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UFxnQx9mRR8K" + }, + "source": [ + "Note some of the KernelBench problem sizes are quite big! This is too ensure [CPU overhead](https://scalingintelligence.stanford.edu/blogs/kernelbenchv01/) is not too significant. As our tensor sizes are calibrated on NVIDIA H100, you might run into OOM on a small GPU for some problems; reduce the problem sizes for those!\n", + "\n", + "Adjust `precision`, `num_trials`, `backend` etc as needed!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "OrtiIIM4Lw2p" + }, + "outputs": [], + "source": [ + "!python scripts/run_and_check.py ref_origin=kernelbench gpu_arch=\"['Turing']\" level={level} problem_id={problem_id} kernel_src_path=tmp/generation.py" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zn3PRPti-IJK" + }, + "source": [ + "When you run the command above, look for these lines in the logs for evaluation result:\n", + "\n", + "1. **`[Eval] Correctness: True/False`**:\n", + " * This runs the kernel against the reference with random inputs with `num_correct_trials`.\n", + " * For **FP32**, we enforce `atol=1e-4`. Following PyTorch guideline, we have different tolerance for various precisions.\n", + " * If this fails, the kernel is functionally invalid, and speedup metrics are ignored.\n", + "\n", + "2. **`[Speedup] Speedup over eager: X.XXx`**:\n", + " * For Speedup we run both the reference and generated kernel `num_trials` time (100 typically), and compute speedup!\n", + " * `< 1.0x`: The generated kernel is slower than PyTorch (common for naive implementations).\n", + " * `> 1.0x`: The generated kernel is faster.\n", + "\n", + "3. **`[Speedup] Speedup over torch.compile: Y.YYx`**:\n", + " * This compares against `torch.compile(mode=\"inductor\")`. This is the harder boss to beat for Level 2/3 problems involving kernel fusions!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "sr4VfQBheBYP" + }, + "source": [ + "## Next Steps\n", + "\n", + "Congrats on finishing this tutorial! We show the minimum usage of KernelBench. Beyond acting as a benchmark, KernelBench tasks also serve as an environment to develop many techniques to tackle AI-generating GPU kernels. We have noted down many of the developments we are aware [here](https://docs.google.com/document/d/e/2PACX-1vTjS-UMH1HB5n_PENq2k-3YRfXIXkqKIKeNC2zcWMyLPdl4Jrwvdk4dNDVSsM8ybKrCxZB7GJq1slZF/pub), from building agentic systems to applying reinforcement learning.\n", + "\n", + "As a pro tip, you should be always **careful about speedup numbers**; kernel engineers and existing compilers are already pretty good, so a >2x speedup for anything is highly unlikely. While we are constantly improving our eval to be more robust and comprehensive, you should always **read the generated kernel in detail** to avoid reward hacking! \n", + "\n", + "As a KernelBench is an open-soruce project, you are welcome to contribute to our [Github](https://github.com/ScalingIntelligence/KernelBench) to add new features or make it better!\n", + "\n", + "Have fun playing with KernelBench! Can't wait to see what you find out!\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "KGFQiYxAeoZM" + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "T4", + "provenance": [] + }, + "kernelspec": { + "display_name": "kernel-bench", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.10.18" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/pyproject.toml b/pyproject.toml index 07788b6c..85a690c5 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -5,52 +5,50 @@ build-backend = "setuptools.build_meta" # this should be our single source of truth for versioning [project] -# to rename as kb_src later and updated codebase -# do that later let's get all the import right first -name = "src" -version = "0.0.1" -requires-python = "==3.13.*" +name = "kernelbench" +version = "0.2.0.dev0" +requires-python = "==3.10.*" dependencies = [ # Frameworks - "torch==2.9.1", + "torch==2.9.0", - "transformers>=4.57.3", - "datasets>=4.4.2", - "modal>=1.3.0", + "transformers", + "datasets", + "modal", # helper - "tqdm>=4.67.1", + "tqdm", "packaging", + "setuptools", "pydra-config", - "ninja>=1.13.0", - "tomli>=2.3.0", - "tabulate>=0.9.0", + "ninja", + "tomli", + "tabulate", # Numerics - "einops>=0.8.1", - "python-dotenv>=1.2.1", - "numpy==2.4.0", + "einops", + "python-dotenv", + "numpy", # LLM providers - "openai>=2.14.0", - "litellm[proxy]>=1.80.10", + "openai", + "litellm[proxy]", ] [project.optional-dependencies] gpu = [ # GPU-specific dependencies (requires CUDA) - "triton==3.5.1", + "triton", "nvidia-cutlass-dsl", "tilelang", - "cupy-cuda12x==13.6.0", + "cupy-cuda12x", ] dev = [ - "pytest==9.0.2", - "ruff==0.14.10", + "pytest", + "ruff", ] [tool.setuptools.packages.find] -where = ["."] -include = ["src*"] -# TODO: change to kb_src later \ No newline at end of file +where = ["src"] +include = ["kernelbench*"] \ No newline at end of file diff --git a/scripts/benchmark_eval_analysis.py b/scripts/benchmark_eval_analysis.py index e2bea005..a2eef53a 100644 --- a/scripts/benchmark_eval_analysis.py +++ b/scripts/benchmark_eval_analysis.py @@ -2,7 +2,7 @@ import pydra from pydra import Config, REQUIRED -from src.dataset import construct_kernelbench_dataset +from kernelbench.dataset import construct_kernelbench_dataset from tabulate import tabulate """ @@ -129,7 +129,7 @@ def analyze_greedy_eval(run_name, hardware, baseline, level): import numpy as np # Calculate speedup metrics - from src.score import ( + from kernelbench.score import ( fastp, geometric_mean_speed_ratio_correct_and_faster_only, geometric_mean_speed_ratio_correct_only, diff --git a/scripts/debug_stddout.py b/scripts/debug_stddout.py index b3eb81f0..9de30023 100644 --- a/scripts/debug_stddout.py +++ b/scripts/debug_stddout.py @@ -3,8 +3,8 @@ import os import ninja -from src.utils import set_gpu_arch -from src.eval import build_compile_cache_with_capturing +from kernelbench.utils import set_gpu_arch +from kernelbench.eval import build_compile_cache_with_capturing ################################################################################ # Test for checking if we can capture nvcc errors diff --git a/scripts/eval_from_generations.py b/scripts/eval_from_generations.py index e65825ad..a71c3478 100644 --- a/scripts/eval_from_generations.py +++ b/scripts/eval_from_generations.py @@ -16,10 +16,10 @@ from pydra import Config, REQUIRED # Import only what we need -from src import compile, eval, utils +from kernelbench import compile, eval, utils -from src.dataset import construct_kernelbench_dataset -from src.eval import ( +from kernelbench.dataset import construct_kernelbench_dataset +from kernelbench.eval import ( build_compile_cache, get_error_name, check_metadata_serializable_all_types, @@ -27,7 +27,7 @@ KernelExecResult, ) -from src.utils import read_file, set_gpu_arch +from kernelbench.utils import read_file, set_gpu_arch from tqdm import tqdm # Modal support @@ -47,7 +47,6 @@ """ REPO_TOP_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) -KERNEL_BENCH_PATH = os.path.join(REPO_TOP_DIR, "KernelBench") torch.set_printoptions(precision=4, threshold=10) @@ -60,6 +59,10 @@ operating_sys = "ubuntu22.04" tag = f"{cuda_version}-{flavor}-{operating_sys}" +SRC_DIR = os.path.join(REPO_TOP_DIR, "src") + +KERNELBENCH_DIR = os.path.join(REPO_TOP_DIR, "KernelBench") + image = ( modal.Image.from_registry(f"nvidia/cuda:{tag}", add_python="3.10") .apt_install("git", @@ -68,11 +71,9 @@ "clang" ) .uv_sync(uv_project_dir=REPO_TOP_DIR) - .add_local_dir( - KERNEL_BENCH_PATH, - remote_path="/root/KernelBench" - ) - .add_local_python_source("src") + .env({"PYTHONPATH": "/root/src"}) + .add_local_dir(SRC_DIR, remote_path="/root/src") + .add_local_dir(KERNELBENCH_DIR, remote_path="/root/KernelBench") # must be last ) @@ -183,8 +184,8 @@ def evaluate_single_sample_modal( Evaluate a single sample on Modal GPU with automatic retries for GPU attachment failures and proper GPU corruption handling via stop_fetching_inputs() """ - from src.eval import eval_kernel_against_ref, get_torch_dtype_from_string - from src.utils import set_gpu_arch + from kernelbench.eval import eval_kernel_against_ref, get_torch_dtype_from_string + from kernelbench.utils import set_gpu_arch import torch import time import modal.experimental diff --git a/scripts/generate_and_eval_single_sample.py b/scripts/generate_and_eval_single_sample.py index 9c3fde28..082a0e93 100644 --- a/scripts/generate_and_eval_single_sample.py +++ b/scripts/generate_and_eval_single_sample.py @@ -7,17 +7,17 @@ from datasets import load_dataset -from src.dataset import construct_kernelbench_dataset -from src.eval import eval_kernel_against_ref -from src.prompt_constructor_toml import get_prompt_for_backend, get_custom_prompt -from src.utils import ( +from kernelbench.dataset import construct_kernelbench_dataset +from kernelbench.eval import eval_kernel_against_ref +from kernelbench.prompt_constructor_toml import get_prompt_for_backend, get_custom_prompt +from kernelbench.utils import ( create_inference_server_from_presets, extract_first_code, query_server, read_file, set_gpu_arch, ) -from src.eval import get_torch_dtype_from_string +from kernelbench.eval import get_torch_dtype_from_string """ Generate and evaluate a single sample Easiest way to get started, to test a single problem for experimentation or debugging @@ -99,7 +99,7 @@ def main(config: EvalConfig): Keep it simple: Generate and evaluate a single sample Note: will shorten code logic to make this as simple as possible """ - from src.utils import SERVER_PRESETS + from kernelbench.utils import SERVER_PRESETS if config.server_type and config.server_type in SERVER_PRESETS: preset = SERVER_PRESETS[config.server_type] diff --git a/scripts/generate_and_eval_single_sample_modal.py b/scripts/generate_and_eval_single_sample_modal.py index ff4b706a..6b249248 100644 --- a/scripts/generate_and_eval_single_sample_modal.py +++ b/scripts/generate_and_eval_single_sample_modal.py @@ -14,7 +14,7 @@ from datasets import load_dataset #from src.dataset import construct_kernelbench_dataset -from src.utils import extract_first_code, query_server, set_gpu_arch, read_file, create_inference_server_from_presets +from kernelbench.utils import extract_first_code, query_server, set_gpu_arch, read_file, create_inference_server_from_presets app = modal.App("eval_single_sample") @@ -94,6 +94,8 @@ def __repr__(self): operating_sys = "ubuntu22.04" tag = f"{cuda_version}-{flavor}-{operating_sys}" +SRC_DIR = os.path.join(REPO_TOP_DIR, "src") + image = ( modal.Image.from_registry(f"nvidia/cuda:{tag}", add_python="3.10") .apt_install("git", @@ -102,7 +104,8 @@ def __repr__(self): "clang" # note i skip a step ) .uv_sync(uv_project_dir=REPO_TOP_DIR, extras=["gpu"]) - .add_local_python_source("src") + .env({"PYTHONPATH": "/root/src"}) + .add_local_dir(SRC_DIR, remote_path="/root/src") # must be last ) @app.cls(image=image) @@ -113,10 +116,10 @@ def eval_single_sample_modal(self, ref_arch_src, custom_kernel, verbose, gpu_arc # 3. Evaluate Kernel # NOTE: no need to wrap around process here as only a single sample # see batch eval for examples of process isolation - from src.eval import eval_kernel_against_ref - from src.eval import get_torch_dtype_from_string + from kernelbench.eval import eval_kernel_against_ref + from kernelbench.eval import get_torch_dtype_from_string # Use utility function to set the GPU architecture in the modal environment - from src.utils import set_gpu_arch as modal_set_gpu_arch + from kernelbench.utils import set_gpu_arch as modal_set_gpu_arch modal_set_gpu_arch(gpu_arch) return eval_kernel_against_ref( ref_arch_src, custom_kernel, verbose=verbose, measure_performance=True, @@ -130,7 +133,7 @@ def main(config: EvalConfig): """ Keep it simple: Generate and evaluate a single sample """ - from src.utils import SERVER_PRESETS + from kernelbench.utils import SERVER_PRESETS if config.server_type and config.server_type in SERVER_PRESETS: preset = SERVER_PRESETS[config.server_type] @@ -238,7 +241,7 @@ def main(config: EvalConfig): ) # Lazy import prompt constructor - from src.prompt_constructor_toml import get_prompt_for_backend, get_custom_prompt + from kernelbench.prompt_constructor_toml import get_prompt_for_backend, get_custom_prompt if custom_prompt_key: custom_prompt = get_custom_prompt( diff --git a/scripts/generate_baseline_time.py b/scripts/generate_baseline_time.py index 0a1f608b..2d992d1e 100644 --- a/scripts/generate_baseline_time.py +++ b/scripts/generate_baseline_time.py @@ -1,16 +1,16 @@ import torch import numpy as np -from src.eval import ( +from kernelbench.eval import ( load_original_model_and_inputs, set_seed, fetch_ref_arch_from_problem_id, ) -from src.timing import ( +from kernelbench.timing import ( get_timing_function, get_timing_stats, ) -from src.dataset import construct_problem_dataset_from_problem_dir -from src.utils import read_file +from kernelbench.dataset import construct_problem_dataset_from_problem_dir +from kernelbench.utils import read_file import os import json from tqdm import tqdm diff --git a/scripts/generate_baseline_time_modal.py b/scripts/generate_baseline_time_modal.py index ffdd8bd7..7e6217a2 100644 --- a/scripts/generate_baseline_time_modal.py +++ b/scripts/generate_baseline_time_modal.py @@ -1,14 +1,14 @@ import torch import numpy as np -from src.eval import ( +from kernelbench.eval import ( load_original_model_and_inputs, time_execution_with_cuda_event, get_timing_stats, set_seed, fetch_ref_arch_from_problem_id, ) -from src.dataset import construct_problem_dataset_from_problem_dir -from src.utils import read_file +from kernelbench.dataset import construct_problem_dataset_from_problem_dir +from kernelbench.utils import read_file import os import json from tqdm import tqdm @@ -46,7 +46,7 @@ "..", ) ) -KERNEL_BENCH_PATH = os.path.join(REPO_TOP_PATH, "KernelBench") +KERNEL_BENCH_PATH = os.path.join(REPO_TOP_PATH, "KernelBench") # Dataset directory TIMING_DIR = os.path.join(REPO_TOP_PATH, "results", "timing") @@ -84,6 +84,9 @@ def __init__(self): operating_sys = "ubuntu22.04" tag = f"{cuda_version}-{flavor}-{operating_sys}" +SRC_DIR = os.path.join(REPO_TOP_PATH, "src") +KERNELBENCH_DIR = os.path.join(REPO_TOP_PATH, "KernelBench") + image = ( modal.Image.from_registry(f"nvidia/cuda:{tag}", add_python="3.10") .apt_install("git", @@ -92,11 +95,9 @@ def __init__(self): "clang" # note i skip a step ) .uv_sync(uv_project_dir=REPO_TOP_PATH, extras=["gpu"]) - .add_local_dir( - KERNEL_BENCH_PATH, - remote_path="/root/KernelBench" - ) - .add_local_python_source("src") + .env({"PYTHONPATH": "/root/src"}) + .add_local_dir(SRC_DIR, remote_path="/root/src") + .add_local_dir(KERNELBENCH_DIR, remote_path="/root/KernelBench") # must be last ) def write_batch_to_json(entries_to_write: list, f_path: str): diff --git a/scripts/generate_samples.py b/scripts/generate_samples.py index e47c6e87..eb65a210 100644 --- a/scripts/generate_samples.py +++ b/scripts/generate_samples.py @@ -8,10 +8,10 @@ from datasets import load_dataset from pydra import Config, REQUIRED -from src.dataset import construct_kernelbench_dataset -from src.eval import eval_kernel_against_ref -from src.prompt_constructor_toml import get_prompt_for_backend, get_custom_prompt -from src.utils import ( +from kernelbench.dataset import construct_kernelbench_dataset +from kernelbench.eval import eval_kernel_against_ref +from kernelbench.prompt_constructor_toml import get_prompt_for_backend, get_custom_prompt +from kernelbench.utils import ( create_inference_server_from_presets, extract_first_code, maybe_multithread, @@ -210,7 +210,7 @@ def main(config: GenerationConfig): Batch Generate Samples for Particular Level Store generated kernels in the specified run directory """ - from src.utils import SERVER_PRESETS + from kernelbench.utils import SERVER_PRESETS if config.server_type and config.server_type in SERVER_PRESETS: preset = SERVER_PRESETS[config.server_type] diff --git a/scripts/get_baseline_time_single_problem.py b/scripts/get_baseline_time_single_problem.py index 476fe2fd..1613f4b0 100644 --- a/scripts/get_baseline_time_single_problem.py +++ b/scripts/get_baseline_time_single_problem.py @@ -1,6 +1,6 @@ import torch import numpy as np -from src.eval import ( +from kernelbench.eval import ( load_original_model_and_inputs, time_execution_with_cuda_event, get_timing_stats, diff --git a/scripts/inspect_baseline.py b/scripts/inspect_baseline.py index e7811f64..9f9f6b7c 100644 --- a/scripts/inspect_baseline.py +++ b/scripts/inspect_baseline.py @@ -3,14 +3,14 @@ import os import sys import numpy as np -from src.eval import ( +from kernelbench.eval import ( load_original_model_and_inputs, time_execution_with_cuda_event, get_timing_stats, set_seed, fetch_ref_arch_from_problem_id, ) -from src.dataset import construct_problem_dataset_from_problem_dir +from kernelbench.dataset import construct_problem_dataset_from_problem_dir import os, sys import logging import json diff --git a/scripts/inspect_kernel_pytorch_profiler.py b/scripts/inspect_kernel_pytorch_profiler.py index 3e93637c..b63563a9 100644 --- a/scripts/inspect_kernel_pytorch_profiler.py +++ b/scripts/inspect_kernel_pytorch_profiler.py @@ -16,8 +16,8 @@ device = "cuda:0" -from src.utils import read_file -from src.eval import ( +from kernelbench.utils import read_file +from kernelbench.eval import ( load_custom_model, load_original_model_and_inputs, set_seed, @@ -103,8 +103,8 @@ def get_torch_profiler_info(ref_arch_src: str, def __main__(): # run_profile(dataset, problem_id, num_trials=10) - ref_arch_src_path = os.path.join(REPO_ROOT, "src/prompts/few_shot/model_ex_mnist2.py") - kernel_src_path = os.path.join(REPO_ROOT, "src/prompts/few_shot/model_new_ex_mnist2.py") + ref_arch_src_path = os.path.join(REPO_ROOT, "src/kernelbench/prompts/few_shot/model_ex_mnist2.py") + kernel_src_path = os.path.join(REPO_ROOT, "src/kernelbench/prompts/few_shot/model_new_ex_mnist2.py") ref_arch_src = read_file(ref_arch_src_path) kernel_src = read_file(kernel_src_path) diff --git a/scripts/inspect_triton.py b/scripts/inspect_triton.py index 4f13c8af..f76e1950 100644 --- a/scripts/inspect_triton.py +++ b/scripts/inspect_triton.py @@ -17,8 +17,8 @@ device = "cuda:0" -from src.utils import read_file -from src.eval import ( +from kernelbench.utils import read_file +from kernelbench.eval import ( load_custom_model, load_original_model_and_inputs, time_execution_with_cuda_event, diff --git a/scripts/run_and_check.py b/scripts/run_and_check.py index 8d9c313e..0bcd8e37 100644 --- a/scripts/run_and_check.py +++ b/scripts/run_and_check.py @@ -6,10 +6,10 @@ from datasets import load_dataset import modal -from src import eval as kernel_eval -from src import utils as kernel_utils +from kernelbench import eval as kernel_eval +from kernelbench import utils as kernel_utils from scripts.generate_baseline_time import measure_program_time -from src.utils import read_file +from kernelbench.utils import read_file # Modal setup app = modal.App("run_and_check") @@ -25,20 +25,24 @@ } REPO_TOP_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), "..")) -KERNEL_BENCH_PATH = os.path.join(REPO_TOP_PATH, "KernelBench") cuda_version = "12.8.0" flavor = "devel" operating_sys = "ubuntu22.04" tag = f"{cuda_version}-{flavor}-{operating_sys}" +SRC_DIR = os.path.join(REPO_TOP_PATH, "src") +SCRIPTS_DIR = os.path.join(REPO_TOP_PATH, "scripts") +KERNELBENCH_DIR = os.path.join(REPO_TOP_PATH, "KernelBench") + image = ( modal.Image.from_registry(f"nvidia/cuda:{tag}", add_python="3.10") .apt_install("git", "gcc-10", "g++-10", "clang") .uv_sync(uv_project_dir=REPO_TOP_PATH) - .add_local_dir(KERNEL_BENCH_PATH, remote_path="/root/KernelBench") - .add_local_python_source("src") - .add_local_python_source("scripts") + .env({"PYTHONPATH": "/root/src:/root/scripts"}) + .add_local_dir(SRC_DIR, remote_path="/root/src") + .add_local_dir(SCRIPTS_DIR, remote_path="/root/scripts") + .add_local_dir(KERNELBENCH_DIR, remote_path="/root/KernelBench") # must be last ) """ @@ -47,7 +51,7 @@ You will need two files 1. Reference: PyTorch reference (module Model) implementation with init and input shapes 2. Solution: PyTorch solution (module ModelNew) with inline CUDA Code -Please see examples in src/prompts +Please see examples in src/kernelbench/prompts The Reference could be either 1. a local file: specify the path to the file @@ -56,15 +60,15 @@ ==================================================== Usage: 1. PyTorch reference is a local file (local eval) -python3 scripts/run_and_check.py ref_origin=local ref_arch_src_path=src/prompts/model_ex_add.py kernel_src_path=src/prompts/model_new_ex_add.py eval_mode=local -python3 scripts/run_and_check.py ref_origin=local ref_arch_src_path=src/prompts/few_shot/model_ex_tiled_matmul.py kernel_src_path=src/prompts/few_shot/model_new_ex_tiled_matmul.py eval_mode=local +python3 scripts/run_and_check.py ref_origin=local ref_arch_src_path=src/kernelbench/prompts/model_ex_add.py kernel_src_path=src/kernelbench/prompts/model_new_ex_add.py eval_mode=local +python3 scripts/run_and_check.py ref_origin=local ref_arch_src_path=src/kernelbench/prompts/few_shot/model_ex_tiled_matmul.py kernel_src_path=src/kernelbench/prompts/few_shot/model_new_ex_tiled_matmul.py eval_mode=local 2. PyTorch reference is a kernelbench problem (local eval) python3 scripts/run_and_check.py ref_origin=kernelbench level= problem_id= kernel_src_path= eval_mode=local 3. PyTorch reference is a local file (modal eval on cloud GPU) -python3 scripts/run_and_check.py ref_origin=local ref_arch_src_path=src/prompts/model_ex_add.py kernel_src_path=src/prompts/model_new_ex_add.py eval_mode=modal gpu=H100 +python3 scripts/run_and_check.py ref_origin=local ref_arch_src_path=src/kernelbench/prompts/model_ex_add.py kernel_src_path=src/kernelbench/prompts/model_new_ex_add.py eval_mode=modal gpu=H100 4. PyTorch reference is a kernelbench problem (modal eval on cloud GPU) python3 scripts/run_and_check.py ref_origin=kernelbench level= problem_id= kernel_src_path= eval_mode=modal gpu=L40S @@ -178,8 +182,8 @@ class EvalFunc: @modal.method() def evaluate_single_sample_src_modal(self, ref_arch_src: str, kernel_src: str, configs: dict, gpu_arch: list): """Evaluate a single sample source code against a reference source code on Modal""" - from src.utils import set_gpu_arch - from src.eval import eval_kernel_against_ref, get_torch_dtype_from_string + from kernelbench.utils import set_gpu_arch + from kernelbench.eval import eval_kernel_against_ref, get_torch_dtype_from_string set_gpu_arch(gpu_arch) device = torch.device("cuda:0") @@ -218,7 +222,7 @@ def measure_program_time_modal( ): """Measure the execution time of a reference program on Modal""" from scripts.generate_baseline_time import measure_program_time - from src.utils import set_gpu_arch + from kernelbench.utils import set_gpu_arch set_gpu_arch(gpu_arch) device = torch.device("cuda:0") diff --git a/scripts/verify_generation.py b/scripts/verify_generation.py index 61c150c7..78791b6f 100644 --- a/scripts/verify_generation.py +++ b/scripts/verify_generation.py @@ -1,7 +1,7 @@ import sys, os -import src.utils as utils +import kernelbench.utils as utils import time -from src.prompt_constructor_toml import get_prompt_for_backend, get_custom_prompt +from kernelbench.prompt_constructor_toml import get_prompt_for_backend, get_custom_prompt """ For testing infernece and quickly iterate on prompts Uses functions in prompt_constructor diff --git a/src/__init__.py b/src/kernelbench/__init__.py similarity index 100% rename from src/__init__.py rename to src/kernelbench/__init__.py diff --git a/src/analysis.py b/src/kernelbench/analysis.py similarity index 100% rename from src/analysis.py rename to src/kernelbench/analysis.py diff --git a/src/compile.py b/src/kernelbench/compile.py similarity index 98% rename from src/compile.py rename to src/kernelbench/compile.py index 41fd8c3b..2ce7c143 100644 --- a/src/compile.py +++ b/src/kernelbench/compile.py @@ -5,8 +5,8 @@ from tqdm import tqdm import shutil -from src.eval import build_compile_cache -from src import utils as utils +from kernelbench.eval import build_compile_cache +from kernelbench import utils as utils import torch import os import multiprocessing as mp diff --git a/src/dataset.py b/src/kernelbench/dataset.py similarity index 99% rename from src/dataset.py rename to src/kernelbench/dataset.py index cb429dc1..29bea818 100644 --- a/src/dataset.py +++ b/src/kernelbench/dataset.py @@ -10,7 +10,7 @@ REPO_TOP_PATH = os.path.abspath( os.path.join( os.path.dirname(__file__), - "..", + "../..", ) ) KERNEL_BENCH_PATH = os.path.join(REPO_TOP_PATH, "KernelBench") diff --git a/src/eval.py b/src/kernelbench/eval.py similarity index 99% rename from src/eval.py rename to src/kernelbench/eval.py index 51bdc6b6..023b4f88 100644 --- a/src/eval.py +++ b/src/kernelbench/eval.py @@ -26,7 +26,7 @@ REPO_TOP_PATH = os.path.abspath( os.path.join( os.path.dirname(__file__), - "..", + "../..", ) ) KERNEL_BENCH_PATH = os.path.join(REPO_TOP_PATH, "KernelBench") diff --git a/src/frameworks.py b/src/kernelbench/frameworks.py similarity index 100% rename from src/frameworks.py rename to src/kernelbench/frameworks.py diff --git a/src/make_hf_dataset.py b/src/kernelbench/make_hf_dataset.py similarity index 100% rename from src/make_hf_dataset.py rename to src/kernelbench/make_hf_dataset.py diff --git a/src/prompt_constructor_toml.py b/src/kernelbench/prompt_constructor_toml.py similarity index 98% rename from src/prompt_constructor_toml.py rename to src/kernelbench/prompt_constructor_toml.py index fc074494..7b8b1bdf 100644 --- a/src/prompt_constructor_toml.py +++ b/src/kernelbench/prompt_constructor_toml.py @@ -5,7 +5,7 @@ from dataclasses import dataclass from typing import Any, Dict, List, Optional -from src.utils import read_file +from kernelbench.utils import read_file """ TOML-based prompt constructor for managing prompt templates and configurations. @@ -14,11 +14,11 @@ You can easily check some of the prompt templates we have provided and create your own. """ -REPO_TOP_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), "..")) -PROMPTS_TOML = os.path.join(REPO_TOP_PATH, "src/prompts/prompts.toml") +REPO_TOP_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")) +PROMPTS_TOML = os.path.join(REPO_TOP_PATH, "src/kernelbench/prompts/prompts.toml") assert os.path.exists(PROMPTS_TOML), f"Prompts.toml not found at {PROMPTS_TOML}" -GPU_SPECS_PY = "src/prompts/hardware/gpu_specs.py" +GPU_SPECS_PY = "src/kernelbench/prompts/hardware/gpu_specs.py" HARDWARE_COMPONENT_KEYS = [ "hardware_header", "hardware_specs", @@ -416,7 +416,7 @@ def test_prompt(): generation. Customize the reference architecture or custom_prompt_key if you want to try different inputs. """ - REPO_TOP_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), "..")) + REPO_TOP_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")) ref_arch_src = read_file(os.path.join(REPO_TOP_PATH, "KernelBench", "level1", "1_Square_matrix_multiplication_.py")) assert len(ref_arch_src) > 0, "ref_arch_src is empty" diff --git a/src/prompts/README.md b/src/kernelbench/prompts/README.md similarity index 100% rename from src/prompts/README.md rename to src/kernelbench/prompts/README.md diff --git a/src/prompts/cot/model_cot_fuse_gelu.py b/src/kernelbench/prompts/cot/model_cot_fuse_gelu.py similarity index 100% rename from src/prompts/cot/model_cot_fuse_gelu.py rename to src/kernelbench/prompts/cot/model_cot_fuse_gelu.py diff --git a/src/prompts/cot/model_cot_mnist2.py b/src/kernelbench/prompts/cot/model_cot_mnist2.py similarity index 100% rename from src/prompts/cot/model_cot_mnist2.py rename to src/kernelbench/prompts/cot/model_cot_mnist2.py diff --git a/src/prompts/cot/model_cot_tiled_matmul.py b/src/kernelbench/prompts/cot/model_cot_tiled_matmul.py similarity index 100% rename from src/prompts/cot/model_cot_tiled_matmul.py rename to src/kernelbench/prompts/cot/model_cot_tiled_matmul.py diff --git a/src/prompts/few_shot/model_ex_add.py b/src/kernelbench/prompts/few_shot/model_ex_add.py similarity index 100% rename from src/prompts/few_shot/model_ex_add.py rename to src/kernelbench/prompts/few_shot/model_ex_add.py diff --git a/src/prompts/few_shot/model_ex_flash_attn.py b/src/kernelbench/prompts/few_shot/model_ex_flash_attn.py similarity index 100% rename from src/prompts/few_shot/model_ex_flash_attn.py rename to src/kernelbench/prompts/few_shot/model_ex_flash_attn.py diff --git a/src/prompts/few_shot/model_ex_fuse_gelu.py b/src/kernelbench/prompts/few_shot/model_ex_fuse_gelu.py similarity index 100% rename from src/prompts/few_shot/model_ex_fuse_gelu.py rename to src/kernelbench/prompts/few_shot/model_ex_fuse_gelu.py diff --git a/src/prompts/few_shot/model_ex_mnist2.py b/src/kernelbench/prompts/few_shot/model_ex_mnist2.py similarity index 100% rename from src/prompts/few_shot/model_ex_mnist2.py rename to src/kernelbench/prompts/few_shot/model_ex_mnist2.py diff --git a/src/prompts/few_shot/model_ex_tiled_matmul.py b/src/kernelbench/prompts/few_shot/model_ex_tiled_matmul.py similarity index 100% rename from src/prompts/few_shot/model_ex_tiled_matmul.py rename to src/kernelbench/prompts/few_shot/model_ex_tiled_matmul.py diff --git a/src/prompts/few_shot/model_new_ex_add.py b/src/kernelbench/prompts/few_shot/model_new_ex_add.py similarity index 100% rename from src/prompts/few_shot/model_new_ex_add.py rename to src/kernelbench/prompts/few_shot/model_new_ex_add.py diff --git a/src/prompts/few_shot/model_new_ex_flash_attn.py b/src/kernelbench/prompts/few_shot/model_new_ex_flash_attn.py similarity index 100% rename from src/prompts/few_shot/model_new_ex_flash_attn.py rename to src/kernelbench/prompts/few_shot/model_new_ex_flash_attn.py diff --git a/src/prompts/few_shot/model_new_ex_fuse_gelu.py b/src/kernelbench/prompts/few_shot/model_new_ex_fuse_gelu.py similarity index 100% rename from src/prompts/few_shot/model_new_ex_fuse_gelu.py rename to src/kernelbench/prompts/few_shot/model_new_ex_fuse_gelu.py diff --git a/src/prompts/few_shot/model_new_ex_mnist2.py b/src/kernelbench/prompts/few_shot/model_new_ex_mnist2.py similarity index 100% rename from src/prompts/few_shot/model_new_ex_mnist2.py rename to src/kernelbench/prompts/few_shot/model_new_ex_mnist2.py diff --git a/src/prompts/few_shot/model_new_ex_tiled_matmul.py b/src/kernelbench/prompts/few_shot/model_new_ex_tiled_matmul.py similarity index 100% rename from src/prompts/few_shot/model_new_ex_tiled_matmul.py rename to src/kernelbench/prompts/few_shot/model_new_ex_tiled_matmul.py diff --git a/src/prompts/hardware/gpu_specs.py b/src/kernelbench/prompts/hardware/gpu_specs.py similarity index 100% rename from src/prompts/hardware/gpu_specs.py rename to src/kernelbench/prompts/hardware/gpu_specs.py diff --git a/src/prompts/model_ex_0.py b/src/kernelbench/prompts/model_ex_0.py similarity index 100% rename from src/prompts/model_ex_0.py rename to src/kernelbench/prompts/model_ex_0.py diff --git a/src/prompts/model_ex_1.py b/src/kernelbench/prompts/model_ex_1.py similarity index 100% rename from src/prompts/model_ex_1.py rename to src/kernelbench/prompts/model_ex_1.py diff --git a/src/prompts/model_ex_2.py b/src/kernelbench/prompts/model_ex_2.py similarity index 100% rename from src/prompts/model_ex_2.py rename to src/kernelbench/prompts/model_ex_2.py diff --git a/src/prompts/model_ex_add.py b/src/kernelbench/prompts/model_ex_add.py similarity index 100% rename from src/prompts/model_ex_add.py rename to src/kernelbench/prompts/model_ex_add.py diff --git a/src/prompts/model_new_ex_0.py b/src/kernelbench/prompts/model_new_ex_0.py similarity index 100% rename from src/prompts/model_new_ex_0.py rename to src/kernelbench/prompts/model_new_ex_0.py diff --git a/src/prompts/model_new_ex_1.py b/src/kernelbench/prompts/model_new_ex_1.py similarity index 100% rename from src/prompts/model_new_ex_1.py rename to src/kernelbench/prompts/model_new_ex_1.py diff --git a/src/prompts/model_new_ex_2.py b/src/kernelbench/prompts/model_new_ex_2.py similarity index 100% rename from src/prompts/model_new_ex_2.py rename to src/kernelbench/prompts/model_new_ex_2.py diff --git a/src/prompts/model_new_ex_add.py b/src/kernelbench/prompts/model_new_ex_add.py similarity index 100% rename from src/prompts/model_new_ex_add.py rename to src/kernelbench/prompts/model_new_ex_add.py diff --git a/src/prompts/model_new_ex_add_cute.py b/src/kernelbench/prompts/model_new_ex_add_cute.py similarity index 100% rename from src/prompts/model_new_ex_add_cute.py rename to src/kernelbench/prompts/model_new_ex_add_cute.py diff --git a/src/prompts/model_new_ex_add_tilelang.py b/src/kernelbench/prompts/model_new_ex_add_tilelang.py similarity index 100% rename from src/prompts/model_new_ex_add_tilelang.py rename to src/kernelbench/prompts/model_new_ex_add_tilelang.py diff --git a/src/prompts/model_new_ex_add_triton.py b/src/kernelbench/prompts/model_new_ex_add_triton.py similarity index 100% rename from src/prompts/model_new_ex_add_triton.py rename to src/kernelbench/prompts/model_new_ex_add_triton.py diff --git a/src/prompts/prompts.toml b/src/kernelbench/prompts/prompts.toml similarity index 91% rename from src/prompts/prompts.toml rename to src/kernelbench/prompts/prompts.toml index bcf4e4ed..acd5f678 100644 --- a/src/prompts/prompts.toml +++ b/src/kernelbench/prompts/prompts.toml @@ -18,7 +18,7 @@ Optimize the architecture named Model with custom {backend_display}! Name your o """ # Shared example architecture (same for all backends) -few_shot_example_arch = "src/prompts/model_ex_add.py" +few_shot_example_arch = "src/kernelbench/prompts/model_ex_add.py" # ------------------------------------------------------------------------- # Backends: Backend-specific configuration (minimal, just what varies) @@ -26,27 +26,27 @@ few_shot_example_arch = "src/prompts/model_ex_add.py" [backends.cuda] backend_display = "CUDA operators" # One-shot example (baseline, always available) -one_shot_new_arch = "src/prompts/model_new_ex_add.py" +one_shot_new_arch = "src/kernelbench/prompts/model_new_ex_add.py" # Few-shot examples (optional, multiple example pairs) few_shot_examples = [ - ["src/prompts/few_shot/model_ex_add.py", "src/prompts/few_shot/model_new_ex_add.py"], - ["src/prompts/few_shot/model_ex_fuse_gelu.py", "src/prompts/few_shot/model_new_ex_fuse_gelu.py"], - ["src/prompts/few_shot/model_ex_flash_attn.py", "src/prompts/few_shot/model_new_ex_flash_attn.py"], + ["src/kernelbench/prompts/few_shot/model_ex_add.py", "src/kernelbench/prompts/few_shot/model_new_ex_add.py"], + ["src/kernelbench/prompts/few_shot/model_ex_fuse_gelu.py", "src/kernelbench/prompts/few_shot/model_new_ex_fuse_gelu.py"], + ["src/kernelbench/prompts/few_shot/model_ex_flash_attn.py", "src/kernelbench/prompts/few_shot/model_new_ex_flash_attn.py"], ] [backends.triton] backend_display = "Triton kernels" -one_shot_new_arch = "src/prompts/model_new_ex_add_triton.py" +one_shot_new_arch = "src/kernelbench/prompts/model_new_ex_add_triton.py" # No few_shot_examples - will use one-shot when few_shot option is selected [backends.cute] backend_display = "CuTe (CUTLASS) kernels" -one_shot_new_arch = "src/prompts/model_new_ex_add_cute.py" +one_shot_new_arch = "src/kernelbench/prompts/model_new_ex_add_cute.py" # No few_shot_examples - will use one-shot when few_shot option is selected [backends.tilelang] backend_display = "TileLang kernels" -one_shot_new_arch = "src/prompts/model_new_ex_add_tilelang.py" +one_shot_new_arch = "src/kernelbench/prompts/model_new_ex_add_tilelang.py" # No few_shot_examples - will use one-shot when few_shot option is selected # ------------------------------------------------------------------------- diff --git a/src/score.py b/src/kernelbench/score.py similarity index 100% rename from src/score.py rename to src/kernelbench/score.py diff --git a/src/timing.py b/src/kernelbench/timing.py similarity index 99% rename from src/timing.py rename to src/kernelbench/timing.py index 8a36522b..b930a890 100644 --- a/src/timing.py +++ b/src/kernelbench/timing.py @@ -5,11 +5,6 @@ from typing import Any import os - -# we leverage triton's testing functionality for some timing methods -from triton import runtime as triton_runtime -from triton import testing as triton_testing - ################################################################################ # timing.py # Various timing methods and utilities for performance evaluation @@ -40,6 +35,7 @@ def clear_l2_cache_triton(cache=None, device: str = "cuda"): """ Thrash the cache by making a large dummy tensor, using triton runtime's functionality """ + from triton import runtime as triton_runtime with torch.cuda.device(device): cache = triton_runtime.driver.active.get_empty_cache_for_benchmark() # this effectively thrashes L2 cache under the hood too @@ -212,6 +208,7 @@ def time_execution_with_do_bench_interface( device = torch.cuda.current_device() + from triton import testing as triton_testing do_bench_fn = lambda : kernel_fn(*args) # wrap function with arguments with torch.cuda.device(device): return triton_testing.do_bench(fn=do_bench_fn, @@ -253,6 +250,7 @@ def time_execution_with_do_bench_impl( List of elapsed times in milliseconds (length = num_trials) """ + from triton import runtime as triton_runtime device = device if device is not None else torch.cuda.current_device() if verbose: print(f"Using do_bench to evaluate kernel on {device}") diff --git a/src/unit_tests/test_dataset.py b/src/kernelbench/unit_tests/test_dataset.py similarity index 95% rename from src/unit_tests/test_dataset.py rename to src/kernelbench/unit_tests/test_dataset.py index a23768e0..22b0612d 100644 --- a/src/unit_tests/test_dataset.py +++ b/src/kernelbench/unit_tests/test_dataset.py @@ -1,6 +1,6 @@ import pytest -from src.dataset import get_code_hash +from kernelbench.dataset import get_code_hash """ Usage diff --git a/src/unit_tests/test_eval_adversarial.py b/src/kernelbench/unit_tests/test_eval_adversarial.py similarity index 97% rename from src/unit_tests/test_eval_adversarial.py rename to src/kernelbench/unit_tests/test_eval_adversarial.py index d741c408..ac019ba3 100644 --- a/src/unit_tests/test_eval_adversarial.py +++ b/src/kernelbench/unit_tests/test_eval_adversarial.py @@ -1,8 +1,8 @@ import os -from src.dataset import KERNEL_BENCH_PATH -from src.eval import eval_kernel_against_ref -from src.utils import read_file +from kernelbench.dataset import KERNEL_BENCH_PATH +from kernelbench.eval import eval_kernel_against_ref +from kernelbench.utils import read_file """ Specifically testing the robustness of the eval function. diff --git a/src/unit_tests/test_eval_timing.py b/src/kernelbench/unit_tests/test_eval_timing.py similarity index 96% rename from src/unit_tests/test_eval_timing.py rename to src/kernelbench/unit_tests/test_eval_timing.py index 84921a37..8be8824b 100644 --- a/src/unit_tests/test_eval_timing.py +++ b/src/kernelbench/unit_tests/test_eval_timing.py @@ -4,16 +4,16 @@ import pytest sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))) -import timing +from kernelbench import timing """ Test Timing We want to systematically study different timing methodologies. """ -REPO_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..")) +REPO_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")) # use exampls in the few shot directory -EXAMPLES_PATH = os.path.join(REPO_PATH, "src", "prompts", "few_shot") +EXAMPLES_PATH = os.path.join(REPO_PATH, "src", "kernelbench", "prompts", "few_shot") # Configure your test cases here TEST_REF_FILE = "model_ex_tiled_matmul.py" diff --git a/src/unit_tests/test_kernels/non_default_stream_kernel.py b/src/kernelbench/unit_tests/test_kernels/non_default_stream_kernel.py similarity index 100% rename from src/unit_tests/test_kernels/non_default_stream_kernel.py rename to src/kernelbench/unit_tests/test_kernels/non_default_stream_kernel.py diff --git a/src/unit_tests/test_kernels/result_reuse_kernel.py b/src/kernelbench/unit_tests/test_kernels/result_reuse_kernel.py similarity index 100% rename from src/unit_tests/test_kernels/result_reuse_kernel.py rename to src/kernelbench/unit_tests/test_kernels/result_reuse_kernel.py diff --git a/src/unit_tests/test_kernels/zero_out_kernel.py b/src/kernelbench/unit_tests/test_kernels/zero_out_kernel.py similarity index 100% rename from src/unit_tests/test_kernels/zero_out_kernel.py rename to src/kernelbench/unit_tests/test_kernels/zero_out_kernel.py diff --git a/src/unit_tests/test_score.py b/src/kernelbench/unit_tests/test_score.py similarity index 99% rename from src/unit_tests/test_score.py rename to src/kernelbench/unit_tests/test_score.py index 918b1f12..cfdd76c2 100644 --- a/src/unit_tests/test_score.py +++ b/src/kernelbench/unit_tests/test_score.py @@ -1,5 +1,5 @@ import pytest -from src.score import * +from kernelbench.score import * import math ''' diff --git a/src/unit_tests/test_utils.py b/src/kernelbench/unit_tests/test_utils.py similarity index 96% rename from src/unit_tests/test_utils.py rename to src/kernelbench/unit_tests/test_utils.py index 9b569dd5..b7126e15 100644 --- a/src/unit_tests/test_utils.py +++ b/src/kernelbench/unit_tests/test_utils.py @@ -1,6 +1,6 @@ import pytest # noqa -from src.utils import extract_first_code, extract_code_blocks, extract_last_code +from kernelbench.utils import extract_first_code, extract_code_blocks, extract_last_code def check_code_assertions(code: str, expected_code: str): """ diff --git a/src/utils.py b/src/kernelbench/utils.py similarity index 100% rename from src/utils.py rename to src/kernelbench/utils.py diff --git a/src/scratch/log.txt b/src/scratch/log.txt deleted file mode 100644 index 9b231c5f..00000000 --- a/src/scratch/log.txt +++ /dev/null @@ -1,60 +0,0 @@ -[1/3] /usr/local/cuda-12.3/bin/nvcc --generate-dependencies-with-compile --dependency-output cuda.cuda.o.d -DTORCH_EXTENSION_NAME=matmul_sum_max -DTORCH_API_INCLUDE_EXTENSION_H -DPYBIND11_COMPILER_TYPE=\"_gcc\" -DPYBIND11_STDLIB=\"_libstdcpp\" -DPYBIND11_BUILD_ABI=\"_cxxabi1011\" -isystem /matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/include -isystem /matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/include/torch/csrc/api/include -isystem /matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/include/TH -isystem /matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/include/THC -isystem /usr/local/cuda-12.3/include -isystem /matx/u/aco/miniconda3/envs/myenv/include/python3.11 -D_GLIBCXX_USE_CXX11_ABI=0 -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ --expt-relaxed-constexpr -gencode=arch=compute_89,code=compute_89 -gencode=arch=compute_89,code=sm_89 --compiler-options '-fPIC' -std=c++17 -c /sailhome/aco/.cache/torch_extensions/py311_cu121/matmul_sum_max/cuda.cu -o cuda.cuda.o -FAILED: cuda.cuda.o -/usr/local/cuda-12.3/bin/nvcc --generate-dependencies-with-compile --dependency-output cuda.cuda.o.d -DTORCH_EXTENSION_NAME=matmul_sum_max -DTORCH_API_INCLUDE_EXTENSION_H -DPYBIND11_COMPILER_TYPE=\"_gcc\" -DPYBIND11_STDLIB=\"_libstdcpp\" -DPYBIND11_BUILD_ABI=\"_cxxabi1011\" -isystem /matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/include -isystem /matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/include/torch/csrc/api/include -isystem /matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/include/TH -isystem /matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/include/THC -isystem /usr/local/cuda-12.3/include -isystem /matx/u/aco/miniconda3/envs/myenv/include/python3.11 -D_GLIBCXX_USE_CXX11_ABI=0 -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ --expt-relaxed-constexpr -gencode=arch=compute_89,code=compute_89 -gencode=arch=compute_89,code=sm_89 --compiler-options '-fPIC' -std=c++17 -c /sailhome/aco/.cache/torch_extensions/py311_cu121/matmul_sum_max/cuda.cu -o cuda.cuda.o -/sailhome/aco/.cache/torch_extensions/py311_cu121/matmul_sum_max/cuda.cu(24): error: identifier "dtype" is undefined - auto out = torch::zeros({batch_size}, dtype=torch::float32, device=a.device); - ^ - -/sailhome/aco/.cache/torch_extensions/py311_cu121/matmul_sum_max/cuda.cu(24): error: namespace "torch" has no member "float32" - auto out = torch::zeros({batch_size}, dtype=torch::float32, device=a.device); - ^ - -/sailhome/aco/.cache/torch_extensions/py311_cu121/matmul_sum_max/cuda.cu(24): error: identifier "device" is undefined - auto out = torch::zeros({batch_size}, dtype=torch::float32, device=a.device); - ^ - -/sailhome/aco/.cache/torch_extensions/py311_cu121/matmul_sum_max/cuda.cu(24): error: a pointer to a bound function may only be used to call the function - auto out = torch::zeros({batch_size}, dtype=torch::float32, device=a.device); - ^ - -/sailhome/aco/.cache/torch_extensions/py311_cu121/matmul_sum_max/cuda.cu(30): error: no instance of overloaded function "at::Tensor::view" matches the argument list - argument types are: (int, int) - object type is: at::Tensor - return out.view(-1, 1); - ^ - -5 errors detected in the compilation of "/sailhome/aco/.cache/torch_extensions/py311_cu121/matmul_sum_max/cuda.cu". -[2/3] c++ -MMD -MF main.o.d -DTORCH_EXTENSION_NAME=matmul_sum_max -DTORCH_API_INCLUDE_EXTENSION_H -DPYBIND11_COMPILER_TYPE=\"_gcc\" -DPYBIND11_STDLIB=\"_libstdcpp\" -DPYBIND11_BUILD_ABI=\"_cxxabi1011\" -isystem /matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/include -isystem /matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/include/torch/csrc/api/include -isystem /matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/include/TH -isystem /matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/include/THC -isystem /usr/local/cuda-12.3/include -isystem /matx/u/aco/miniconda3/envs/myenv/include/python3.11 -D_GLIBCXX_USE_CXX11_ABI=0 -fPIC -std=c++17 -c /sailhome/aco/.cache/torch_extensions/py311_cu121/matmul_sum_max/main.cpp -o main.o -ninja: build stopped: subcommand failed. -Using /sailhome/aco/.cache/torch_extensions/py311_cu121 as PyTorch extensions root... -Creating extension directory /sailhome/aco/.cache/torch_extensions/py311_cu121/matmul_sum_max... -Detected CUDA files, patching ldflags -Emitting ninja build file /sailhome/aco/.cache/torch_extensions/py311_cu121/matmul_sum_max/build.ninja... -/matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/utils/cpp_extension.py:1965: UserWarning: TORCH_CUDA_ARCH_LIST is not set, all archs for visible cards are included for compilation. -If this is not desired, please set os.environ['TORCH_CUDA_ARCH_LIST']. - warnings.warn( -Building extension module matmul_sum_max... -Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N) -Traceback (most recent call last): - File "/matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/utils/cpp_extension.py", line 2105, in _run_ninja_build - subprocess.run( - File "/matx/u/aco/miniconda3/envs/myenv/lib/python3.11/subprocess.py", line 571, in run - raise CalledProcessError(retcode, process.args, -subprocess.CalledProcessError: Command '['ninja', '-v']' returned non-zero exit status 1. - -The above exception was the direct cause of the following exception: - -Traceback (most recent call last): - File "/matx/u/aco/KernelBenchInternal/src/scratch/model_new.py", line 40, in - matmul_sum_max = load_inline( - ^^^^^^^^^^^^ - File "/matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/utils/cpp_extension.py", line 1647, in load_inline - return _jit_compile( - ^^^^^^^^^^^^^ - File "/matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/utils/cpp_extension.py", line 1722, in _jit_compile - _write_ninja_file_and_build_library( - File "/matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/utils/cpp_extension.py", line 1834, in _write_ninja_file_and_build_library - _run_ninja_build( - File "/matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/utils/cpp_extension.py", line 2121, in _run_ninja_build - raise RuntimeError(message) from e -RuntimeError: Error building extension 'matmul_sum_max' diff --git a/src/scratch/model.py b/src/scratch/model.py deleted file mode 100644 index e69de29b..00000000 diff --git a/src/scratch/model_new.py b/src/scratch/model_new.py deleted file mode 100644 index e69de29b..00000000 diff --git a/src/scratch/prompt.txt b/src/scratch/prompt.txt deleted file mode 100644 index 78dbb009..00000000 --- a/src/scratch/prompt.txt +++ /dev/null @@ -1,137 +0,0 @@ - - You write custom CUDA kernels to replace the pytorch operators in the given architecture to get speedups. - - You have complete freedom to choose the set of operators you want to replace. You may make the decision to replace some operators with custom CUDA kernels and leave others unchanged. You may replace multiple operators with custom implementations, consider operator fusion opportunities (combining multiple operators into a single kernel, for example, combining matmul+relu), or algorithmic changes (such as online softmax). You are only limited by your imagination. - - - Here's an example to show you the syntax of inline embedding custom CUDA operators in torch: The example given architecture is: - - ``` - import torch -import torch.nn as nn -import torch.nn.functional as F - -class Model(nn.Module): - def __init__(self) -> None: - super().__init__() - - def forward(self, a, b): - return a + b - -def get_inputs(): - # randomly generate input tensors based on the model architecture - a = torch.randn(1, 128).cuda() - b = torch.randn(1, 128).cuda() - return [a, b] - -def get_init_inputs(): - # randomly generate tensors required for initialization based on the model architecture - return [] - ``` - - The example new arch with custom CUDA kernels looks like this: - ``` - import torch -import torch.nn as nn -import torch.nn.functional as F -from torch.utils.cpp_extension import load_inline - -# Define the custom CUDA kernel for element-wise addition -elementwise_add_source = """ -#include -#include - -__global__ void elementwise_add_kernel(const float* a, const float* b, float* out, int size) { - int idx = blockIdx.x * blockDim.x + threadIdx.x; - if (idx < size) { - out[idx] = a[idx] + b[idx]; - } -} - -torch::Tensor elementwise_add_cuda(torch::Tensor a, torch::Tensor b) { - auto size = a.numel(); - auto out = torch::zeros_like(a); - - const int block_size = 256; - const int num_blocks = (size + block_size - 1) / block_size; - - elementwise_add_kernel<<>>(a.data_ptr(), b.data_ptr(), out.data_ptr(), size); - - return out; -} -""" - -elementwise_add_cpp_source = "torch::Tensor elementwise_add_cuda(torch::Tensor a, torch::Tensor b);" - -# Compile the inline CUDA code for element-wise addition -elementwise_add = load_inline( - name='elementwise_add', - cpp_sources=elementwise_add_cpp_source, - cuda_sources=elementwise_add_source, - functions=['elementwise_add_cuda'], - verbose=True, - extra_cflags=[''], - extra_ldflags=[''] -) - -class ModelNew(nn.Module): - def __init__(self) -> None: - super().__init__() - self.elementwise_add = elementwise_add - - def forward(self, a, b): - return self.elementwise_add.elementwise_add_cuda(a, b) - -def get_inputs(): - # randomly generate input tensors based on the model architecture - a = torch.randn(4096).cuda() - b = torch.randn(4096).cuda() - return [a, b] - -def get_init_inputs(): - # randomly generate tensors required for initialization based on the model architecture - return [] - ``` - - - You are given the following architecture: - - ``` - import torch -import torch.nn as nn - -class Model(nn.Module): - """ - Simple model that performs a single matrix multiplication (C = A * B) - """ - def __init__(self): - super(Model, self).__init__() - - def forward(self, A: torch.Tensor, B: torch.Tensor) -> torch.Tensor: - """ - Performs matrix multiplication. - - Args: - A: Input tensor of shape (M, K). - B: Input tensor of shape (K, N). - - Returns: - Output tensor of shape (M, N). - """ - return torch.matmul(A, B) - -M = 1024 -K = 4096 -N = 2048 - -def get_inputs(): - A = torch.randn(M, K) - B = torch.randn(K, N) - return [A, B] - -def get_init_inputs(): - return [] # No special initialization inputs needed - ``` - Optimize the architecture named Model with custom CUDA operators! Name your optimized output architecture ModelNew. Output the new code in codeblocks. Please generate real code, NOT pseudocode, make sure the code compiles and is fully functional. - - \ No newline at end of file diff --git a/src/scratch/test.py b/src/scratch/test.py deleted file mode 100644 index dbead51c..00000000 --- a/src/scratch/test.py +++ /dev/null @@ -1,69 +0,0 @@ -import torch -import torch.nn as nn -import torch.nn.functional as F -import random -import numpy as np - -# load model and the modified model -from model import Model -from model import get_inputs -from model import get_init_inputs -from model_new import ModelNew - -torch.cuda.synchronize() - - -def set_seed(seed): - torch.manual_seed(seed) - torch.cuda.manual_seed(seed) - random.seed(seed) - np.random.seed(seed) - - -def check_correctness(): - # run the model and check correctness - with torch.no_grad(): - - # generate inputs and init_inputs, and instantiate models - set_seed(42) - inputs = get_inputs() - set_seed(42) - init_inputs = get_init_inputs() - - # move to GPU - inputs = [x.cuda() if isinstance(x, torch.Tensor) else x for x in inputs] - init_inputs = [ - x.cuda() if isinstance(x, torch.Tensor) else x for x in init_inputs - ] - - set_seed(42) - model = Model(*init_inputs).cuda() - set_seed(42) - model_new = ModelNew(*init_inputs).cuda() - - # forward pass - output = model(*inputs) - output_new = model_new(*inputs) - - # move to CPU - torch.cuda.synchronize() - output = output.cpu() - output_new = output_new.cpu() - - # check correctness - assert output.shape == output_new.shape - assert torch.allclose(output, output_new, atol=1e-02) - - return "PASS" - - -def run(random_seed=42): - - # run both models and check correctness - check_correctness() - - return "PASS" - - -if __name__ == "__main__": - print(run()) From a2265ffd0f68cc47f32ceeef42a88c49dafd7581 Mon Sep 17 00:00:00 2001 From: Omar Abul-Hassan <62859645+pythonomar22@users.noreply.github.com> Date: Wed, 31 Dec 2025 12:28:01 -0500 Subject: [PATCH 14/24] infra updates to enable modal-based leaderboard(#100) * Add optional path parameters and JSON output to benchmark_eval_analysis.py - Add baseline_file param to override default baseline path - Add eval_results_dir param to override default runs directory - Add output_file param to write results as JSON - Return results dict from analyze_greedy_eval() - All changes backward compatible (existing usage unchanged) * h100 modal timing, and some changes * lgtm; nit small annotation --------- Co-authored-by: Simon Guo --- .../H100_Modal/baseline_time_torch.json | 2258 +++++++++++++++++ ...e_time_torch_compile_inductor_default.json | 2258 +++++++++++++++++ scripts/benchmark_eval_analysis.py | 86 +- scripts/eval_from_generations.py | 113 +- scripts/generate_baseline_time_modal.py | 98 +- 5 files changed, 4710 insertions(+), 103 deletions(-) create mode 100644 results/timing/H100_Modal/baseline_time_torch.json create mode 100644 results/timing/H100_Modal/baseline_time_torch_compile_inductor_default.json diff --git a/results/timing/H100_Modal/baseline_time_torch.json b/results/timing/H100_Modal/baseline_time_torch.json new file mode 100644 index 00000000..14a3f7bd --- /dev/null +++ b/results/timing/H100_Modal/baseline_time_torch.json @@ -0,0 +1,2258 @@ +{ + "level1": { + "1_Square_matrix_multiplication_.py": { + "mean": 2.66, + "std": 0.0199, + "min": 2.65, + "max": 2.86, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "2_Standard_matrix_multiplication_.py": { + "mean": 2.61, + "std": 0.0112, + "min": 2.61, + "max": 2.72, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "3_Batched_matrix_multiplication.py": { + "mean": 5.33, + "std": 0.0467, + "min": 5.32, + "max": 5.79, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "4_Matrix_vector_multiplication_.py": { + "mean": 2.77, + "std": 0.0012, + "min": 2.77, + "max": 2.78, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "5_Matrix_scalar_multiplication.py": { + "mean": 2.85, + "std": 0.115, + "min": 2.82, + "max": 3.98, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "6_Matmul_with_large_K_dimension_.py": { + "mean": 1.3, + "std": 0.00314, + "min": 1.29, + "max": 1.31, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "7_Matmul_with_small_K_dimension_.py": { + "mean": 4.06, + "std": 0.103, + "min": 4.04, + "max": 5.08, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "8_Matmul_with_irregular_shapes_.py": { + "mean": 6.38, + "std": 0.0174, + "min": 6.37, + "max": 6.54, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "9_Tall_skinny_matrix_multiplication_.py": { + "mean": 2.59, + "std": 0.142, + "min": 2.57, + "max": 4.0, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "10_3D_tensor_matrix_multiplication.py": { + "mean": 1.04, + "std": 0.000954, + "min": 1.03, + "max": 1.04, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "11_4D_tensor_matrix_multiplication.py": { + "mean": 11.0, + "std": 1.02, + "min": 9.96, + "max": 13.3, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "12_Matmul_with_diagonal_matrices_.py": { + "mean": 2.68, + "std": 0.00374, + "min": 2.68, + "max": 2.69, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "13_Matmul_for_symmetric_matrices.py": { + "mean": 2.66, + "std": 0.00343, + "min": 2.65, + "max": 2.66, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "14_Matmul_for_upper_triangular_matrices.py": { + "mean": 2.7, + "std": 0.00519, + "min": 2.7, + "max": 2.75, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "15_Matmul_for_lower_triangular_matrices.py": { + "mean": 2.69, + "std": 0.00892, + "min": 2.68, + "max": 2.77, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "16_Matmul_with_transposed_A.py": { + "mean": 2.62, + "std": 0.0106, + "min": 2.62, + "max": 2.72, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "17_Matmul_with_transposed_B.py": { + "mean": 2.68, + "std": 0.00948, + "min": 2.66, + "max": 2.69, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "18_Matmul_with_transposed_both.py": { + "mean": 2.74, + "std": 0.00171, + "min": 2.74, + "max": 2.75, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "19_ReLU.py": { + "mean": 4.28, + "std": 0.194, + "min": 4.24, + "max": 6.18, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "20_LeakyReLU.py": { + "mean": 4.28, + "std": 0.194, + "min": 4.24, + "max": 6.18, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "21_Sigmoid.py": { + "mean": 4.32, + "std": 0.276, + "min": 4.27, + "max": 7.05, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "22_Tanh.py": { + "mean": 4.31, + "std": 0.495, + "min": 4.24, + "max": 9.23, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "23_Softmax.py": { + "mean": 8.52, + "std": 0.189, + "min": 8.46, + "max": 10.3, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "24_LogSoftmax.py": { + "mean": 8.48, + "std": 0.194, + "min": 8.43, + "max": 10.3, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "25_Swish.py": { + "mean": 10.5, + "std": 0.0767, + "min": 10.5, + "max": 10.7, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "26_GELU_.py": { + "mean": 4.3, + "std": 0.191, + "min": 4.24, + "max": 6.17, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "27_SELU_.py": { + "mean": 4.3, + "std": 0.188, + "min": 4.24, + "max": 6.14, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "28_HardSigmoid.py": { + "mean": 4.34, + "std": 0.188, + "min": 4.27, + "max": 6.17, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "29_Softplus.py": { + "mean": 4.31, + "std": 0.193, + "min": 4.27, + "max": 6.18, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "30_Softsign.py": { + "mean": 14.8, + "std": 0.0927, + "min": 14.7, + "max": 15.0, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "31_ELU.py": { + "mean": 4.3, + "std": 0.188, + "min": 4.24, + "max": 6.13, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "32_HardTanh.py": { + "mean": 4.34, + "std": 0.187, + "min": 4.27, + "max": 6.16, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "33_BatchNorm.py": { + "mean": 8.77, + "std": 0.166, + "min": 8.67, + "max": 10.3, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "34_InstanceNorm.py": { + "mean": 9.61, + "std": 0.409, + "min": 9.51, + "max": 13.6, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "35_GroupNorm_.py": { + "mean": 10.1, + "std": 0.569, + "min": 9.89, + "max": 15.6, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "36_RMSNorm_.py": { + "mean": 14.2, + "std": 0.271, + "min": 14.1, + "max": 16.7, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "37_FrobeniusNorm_.py": { + "mean": 8.53, + "std": 0.116, + "min": 8.39, + "max": 8.67, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "38_L1Norm_.py": { + "mean": 15.6, + "std": 0.275, + "min": 15.5, + "max": 17.8, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "39_L2Norm_.py": { + "mean": 10.1, + "std": 0.185, + "min": 10.0, + "max": 11.4, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "40_LayerNorm.py": { + "mean": 8.12, + "std": 0.00745, + "min": 8.1, + "max": 8.15, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "41_Max_Pooling_1D.py": { + "mean": 10.7, + "std": 0.179, + "min": 10.6, + "max": 12.4, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "42_Max_Pooling_2D.py": { + "mean": 10.8, + "std": 1.02, + "min": 10.7, + "max": 21.0, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "43_Max_Pooling_3D.py": { + "mean": 3.93, + "std": 0.0736, + "min": 3.92, + "max": 4.66, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "44_Average_Pooling_1D.py": { + "mean": 5.47, + "std": 0.147, + "min": 5.45, + "max": 6.93, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "45_Average_Pooling_2D.py": { + "mean": 6.4, + "std": 0.0914, + "min": 6.26, + "max": 6.5, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "46_Average_Pooling_3D.py": { + "mean": 8.69, + "std": 0.257, + "min": 8.65, + "max": 11.2, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "47_Sum_reduction_over_a_dimension.py": { + "mean": 3.11, + "std": 0.0173, + "min": 3.07, + "max": 3.15, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "48_Mean_reduction_over_a_dimension.py": { + "mean": 2.88, + "std": 0.0128, + "min": 2.85, + "max": 2.93, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "49_Max_reduction_over_a_dimension.py": { + "mean": 3.14, + "std": 0.00513, + "min": 3.14, + "max": 3.19, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "50_conv_standard_2D__square_input__square_kernel.py": { + "mean": 2.2, + "std": 0.0362, + "min": 2.18, + "max": 2.5, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "51_Argmax_over_a_dimension.py": { + "mean": 3.14, + "std": 0.00258, + "min": 3.13, + "max": 3.15, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "52_Argmin_over_a_dimension.py": { + "mean": 3.24, + "std": 0.00398, + "min": 3.23, + "max": 3.27, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "53_Min_reduction_over_a_dimension.py": { + "mean": 3.14, + "std": 0.00249, + "min": 3.13, + "max": 3.15, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "54_conv_standard_3D__square_input__square_kernel.py": { + "mean": 1.87, + "std": 0.225, + "min": 1.84, + "max": 4.11, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "55_conv_standard_2D__asymmetric_input__square_kernel.py": { + "mean": 4.12, + "std": 0.0694, + "min": 3.92, + "max": 4.19, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "56_conv_standard_2D__asymmetric_input__asymmetric_kernel.py": { + "mean": 2.93, + "std": 0.103, + "min": 2.7, + "max": 3.15, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "57_conv_transposed_2D__square_input__square_kernel.py": { + "mean": 6.56, + "std": 1.84, + "min": 6.35, + "max": 24.9, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "58_conv_transposed_3D__asymmetric_input__asymmetric_kernel.py": { + "mean": 7.66, + "std": 0.00422, + "min": 7.65, + "max": 7.67, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "59_conv_standard_3D__asymmetric_input__square_kernel.py": { + "mean": 2.84, + "std": 0.00974, + "min": 2.8, + "max": 2.84, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "60_conv_standard_3D__square_input__asymmetric_kernel.py": { + "mean": 7.64, + "std": 0.00693, + "min": 7.64, + "max": 7.69, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "61_conv_transposed_3D__square_input__square_kernel.py": { + "mean": 9.15, + "std": 0.00909, + "min": 9.13, + "max": 9.18, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "62_conv_standard_2D__square_input__asymmetric_kernel.py": { + "mean": 2.43, + "std": 0.0586, + "min": 2.39, + "max": 3.0, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "63_conv_standard_2D__square_input__square_kernel.py": { + "mean": 7.11, + "std": 0.124, + "min": 7.06, + "max": 8.29, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "64_conv_transposed_1D.py": { + "mean": 5.48, + "std": 2.93, + "min": 5.16, + "max": 34.6, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "65_conv_transposed_2D__square_input__asymmetric_kernel.py": { + "mean": 2.62, + "std": 0.00976, + "min": 2.59, + "max": 2.65, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "66_conv_standard_3D__asymmetric_input__asymmetric_kernel.py": { + "mean": 3.78, + "std": 0.127, + "min": 3.76, + "max": 5.04, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "67_conv_standard_1D.py": { + "mean": 2.63, + "std": 0.0737, + "min": 2.62, + "max": 3.36, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "68_conv_transposed_3D__square_input__asymmetric_kernel.py": { + "mean": 36.8, + "std": 0.00606, + "min": 36.8, + "max": 36.8, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "69_conv_transposed_2D__asymmetric_input__asymmetric_kernel.py": { + "mean": 2.84, + "std": 0.0156, + "min": 2.81, + "max": 2.86, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "70_conv_transposed_3D__asymmetric_input__square_kernel.py": { + "mean": 29.3, + "std": 0.0133, + "min": 29.3, + "max": 29.4, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "71_conv_transposed_2D__asymmetric_input__square_kernel.py": { + "mean": 1.58, + "std": 0.00415, + "min": 1.57, + "max": 1.59, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "72_conv_transposed_3D_asymmetric_input_asymmetric_kernel___strided_padded_grouped_.py": { + "mean": 2.82, + "std": 0.0193, + "min": 2.8, + "max": 2.94, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "73_conv_transposed_3D_asymmetric_input_square_kernel__strided_padded__grouped.py": { + "mean": 2.09, + "std": 0.0067, + "min": 2.08, + "max": 2.11, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "74_conv_transposed_1D_dilated.py": { + "mean": 2.1, + "std": 0.177, + "min": 2.06, + "max": 3.86, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "75_conv_transposed_2D_asymmetric_input_asymmetric_kernel_strided__grouped____padded____dilated__.py": { + "mean": 6.66, + "std": 0.0161, + "min": 6.63, + "max": 6.69, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "76_conv_standard_1D_dilated_strided__.py": { + "mean": 12.2, + "std": 0.153, + "min": 12.1, + "max": 13.6, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "77_conv_transposed_3D_square_input_square_kernel___padded____dilated____strided__.py": { + "mean": 1.96, + "std": 0.036, + "min": 1.92, + "max": 2.26, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "78_conv_transposed_2D_asymmetric_input_asymmetric_kernel___padded__.py": { + "mean": 2.4, + "std": 0.162, + "min": 2.38, + "max": 4.01, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "79_conv_transposed_1D_asymmetric_input_square_kernel___padded____strided____dilated__.py": { + "mean": 1.94, + "std": 0.00719, + "min": 1.91, + "max": 1.95, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "80_conv_standard_2D_square_input_asymmetric_kernel___dilated____padded__.py": { + "mean": 2.41, + "std": 0.284, + "min": 2.35, + "max": 5.23, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "81_conv_transposed_2D_asymmetric_input_square_kernel___dilated____padded____strided__.py": { + "mean": 1.84, + "std": 0.00848, + "min": 1.82, + "max": 1.86, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "82_conv_depthwise_2D_square_input_square_kernel.py": { + "mean": 2.55, + "std": 0.14, + "min": 2.54, + "max": 3.94, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "83_conv_depthwise_2D_square_input_asymmetric_kernel.py": { + "mean": 1.53, + "std": 0.857, + "min": 1.45, + "max": 10.1, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "84_conv_depthwise_2D_asymmetric_input_square_kernel.py": { + "mean": 10.1, + "std": 0.103, + "min": 10.1, + "max": 11.1, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "85_conv_depthwise_2D_asymmetric_input_asymmetric_kernel.py": { + "mean": 2.27, + "std": 0.174, + "min": 2.26, + "max": 4.0, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "86_conv_depthwise_separable_2D.py": { + "mean": 3.91, + "std": 2.34, + "min": 3.65, + "max": 27.2, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "87_conv_pointwise_2D.py": { + "mean": 4.66, + "std": 0.259, + "min": 4.6, + "max": 7.22, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "88_MinGPTNewGelu.py": { + "mean": 1.65, + "std": 0.00148, + "min": 1.65, + "max": 1.66, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "89_cumsum.py": { + "mean": 4.68, + "std": 0.0795, + "min": 4.66, + "max": 5.47, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "90_cumprod.py": { + "mean": 4.69, + "std": 0.152, + "min": 4.67, + "max": 6.2, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "91_cumsum_reverse.py": { + "mean": 11.4, + "std": 0.0649, + "min": 11.4, + "max": 11.7, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "92_cumsum_exclusive.py": { + "mean": 12.9, + "std": 0.176, + "min": 12.8, + "max": 14.5, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "93_masked_cumsum.py": { + "mean": 8.72, + "std": 0.0326, + "min": 8.68, + "max": 8.8, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "94_MSELoss.py": { + "mean": 8.4, + "std": 0.0835, + "min": 8.35, + "max": 8.59, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "95_CrossEntropyLoss.py": { + "mean": 0.477, + "std": 0.00152, + "min": 0.474, + "max": 0.481, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "96_HuberLoss.py": { + "mean": 5.66, + "std": 0.171, + "min": 5.6, + "max": 7.21, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "97_ScaledDotProductAttention.py": { + "mean": 8.45, + "std": 0.353, + "min": 8.13, + "max": 9.63, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "98_KLDivLoss.py": { + "mean": 3.86, + "std": 0.00163, + "min": 3.85, + "max": 3.86, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "99_TripletMarginLoss.py": { + "mean": 4.27, + "std": 0.0342, + "min": 4.25, + "max": 4.45, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "100_HingeLoss.py": { + "mean": 10.5, + "std": 0.0775, + "min": 10.4, + "max": 10.7, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + } + }, + "level2": { + "1_Conv2D_ReLU_BiasAdd.py": { + "mean": 4.35, + "std": 0.0172, + "min": 4.33, + "max": 4.39, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "2_ConvTranspose2d_BiasAdd_Clamp_Scaling_Clamp_Divide.py": { + "mean": 12.7, + "std": 0.0991, + "min": 12.7, + "max": 13.7, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "3_ConvTranspose3d_Sum_LayerNorm_AvgPool_GELU.py": { + "mean": 10.1, + "std": 0.0705, + "min": 10.1, + "max": 10.8, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "4_Conv2d_Mish_Mish.py": { + "mean": 8.49, + "std": 0.213, + "min": 8.39, + "max": 9.54, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "5_ConvTranspose2d_Subtract_Tanh.py": { + "mean": 9.22, + "std": 0.202, + "min": 9.17, + "max": 11.2, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "6_Conv3d_Softmax_MaxPool_MaxPool.py": { + "mean": 0.864, + "std": 0.0131, + "min": 0.86, + "max": 0.993, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "7_Conv3d_ReLU_LeakyReLU_GELU_Sigmoid_BiasAdd.py": { + "mean": 6.43, + "std": 0.186, + "min": 6.4, + "max": 8.28, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "8_Conv3d_Divide_Max_GlobalAvgPool_BiasAdd_Sum.py": { + "mean": 2.53, + "std": 0.0307, + "min": 2.51, + "max": 2.69, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "9_Matmul_Subtract_Multiply_ReLU.py": { + "mean": 2.73, + "std": 0.00118, + "min": 2.73, + "max": 2.74, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "10_ConvTranspose2d_MaxPool_Hardtanh_Mean_Tanh.py": { + "mean": 9.68, + "std": 0.0559, + "min": 9.65, + "max": 10.1, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "11_ConvTranspose2d_BatchNorm_Tanh_MaxPool_GroupNorm.py": { + "mean": 2.62, + "std": 0.0131, + "min": 2.59, + "max": 2.65, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "12_Gemm_Multiply_LeakyReLU.py": { + "mean": 2.73, + "std": 0.00146, + "min": 2.73, + "max": 2.74, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "13_ConvTranspose3d_Mean_Add_Softmax_Tanh_Scaling.py": { + "mean": 9.89, + "std": 0.02, + "min": 9.87, + "max": 9.95, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "14_Gemm_Divide_Sum_Scaling.py": { + "mean": 2.75, + "std": 0.00372, + "min": 2.75, + "max": 2.77, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "15_ConvTranspose3d_BatchNorm_Subtract.py": { + "mean": 2.04, + "std": 0.101, + "min": 2.02, + "max": 3.04, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "16_ConvTranspose2d_Mish_Add_Hardtanh_Scaling.py": { + "mean": 10.9, + "std": 0.0718, + "min": 10.9, + "max": 11.6, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "17_Conv2d_InstanceNorm_Divide.py": { + "mean": 4.94, + "std": 0.0166, + "min": 4.91, + "max": 4.96, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "18_Matmul_Sum_Max_AvgPool_LogSumExp_LogSumExp.py": { + "mean": 2.77, + "std": 0.000935, + "min": 2.77, + "max": 2.77, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "19_ConvTranspose2d_GELU_GroupNorm.py": { + "mean": 12.3, + "std": 0.646, + "min": 12.2, + "max": 18.8, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "20_ConvTranspose3d_Sum_ResidualAdd_Multiply_ResidualAdd.py": { + "mean": 3.55, + "std": 0.00209, + "min": 3.54, + "max": 3.55, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "21_Conv2d_Add_Scale_Sigmoid_GroupNorm.py": { + "mean": 6.45, + "std": 0.0137, + "min": 6.44, + "max": 6.53, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "22_Matmul_Scale_ResidualAdd_Clamp_LogSumExp_Mish.py": { + "mean": 2.84, + "std": 0.00888, + "min": 2.83, + "max": 2.85, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "23_Conv3d_GroupNorm_Mean.py": { + "mean": 1.27, + "std": 0.00104, + "min": 1.27, + "max": 1.27, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "24_Conv3d_Min_Softmax.py": { + "mean": 0.969, + "std": 0.00266, + "min": 0.965, + "max": 0.984, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "25_Conv2d_Min_Tanh_Tanh.py": { + "mean": 6.48, + "std": 0.0143, + "min": 6.45, + "max": 6.54, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "26_ConvTranspose3d_Add_HardSwish.py": { + "mean": 5.09, + "std": 0.122, + "min": 5.07, + "max": 6.3, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "27_Conv3d_HardSwish_GroupNorm_Mean.py": { + "mean": 9.92, + "std": 0.0179, + "min": 9.91, + "max": 10.1, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "28_BMM_InstanceNorm_Sum_ResidualAdd_Multiply.py": { + "mean": 2.79, + "std": 0.0041, + "min": 2.79, + "max": 2.81, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "29_Matmul_Mish_Mish.py": { + "mean": 2.73, + "std": 0.00551, + "min": 2.73, + "max": 2.77, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "30_Gemm_GroupNorm_Hardtanh.py": { + "mean": 2.83, + "std": 0.0131, + "min": 2.82, + "max": 2.86, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "31_Conv2d_Min_Add_Multiply.py": { + "mean": 5.06, + "std": 0.0138, + "min": 5.03, + "max": 5.08, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "32_Conv2d_Scaling_Min.py": { + "mean": 7.84, + "std": 0.0234, + "min": 7.8, + "max": 7.91, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "33_Gemm_Scale_BatchNorm.py": { + "mean": 2.76, + "std": 0.00164, + "min": 2.76, + "max": 2.78, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "34_ConvTranspose3d_LayerNorm_GELU_Scaling.py": { + "mean": 10.0, + "std": 0.275, + "min": 9.98, + "max": 12.7, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "35_Conv2d_Subtract_HardSwish_MaxPool_Mish.py": { + "mean": 5.11, + "std": 0.0175, + "min": 5.09, + "max": 5.15, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "36_ConvTranspose2d_Min_Sum_GELU_Add.py": { + "mean": 1.46, + "std": 0.00328, + "min": 1.44, + "max": 1.47, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "37_Matmul_Swish_Sum_GroupNorm.py": { + "mean": 8.55, + "std": 0.00795, + "min": 8.54, + "max": 8.59, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "38_ConvTranspose3d_AvgPool_Clamp_Softmax_Multiply.py": { + "mean": 5.68, + "std": 0.025, + "min": 5.67, + "max": 5.93, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "39_Gemm_Scale_BatchNorm.py": { + "mean": 11.4, + "std": 0.101, + "min": 11.3, + "max": 11.7, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "40_Matmul_Scaling_ResidualAdd.py": { + "mean": 11.4, + "std": 0.0147, + "min": 11.4, + "max": 11.5, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "41_Gemm_BatchNorm_GELU_ReLU.py": { + "mean": 11.5, + "std": 0.152, + "min": 11.4, + "max": 12.1, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "42_ConvTranspose2d_GlobalAvgPool_BiasAdd_LogSumExp_Sum_Multiply.py": { + "mean": 7.17, + "std": 0.0118, + "min": 7.14, + "max": 7.22, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "43_Conv3d_Max_LogSumExp_ReLU.py": { + "mean": 2.66, + "std": 0.0151, + "min": 2.63, + "max": 2.69, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "44_ConvTranspose2d_Multiply_GlobalAvgPool_GlobalAvgPool_Mean.py": { + "mean": 1.74, + "std": 0.0027, + "min": 1.74, + "max": 1.76, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "45_Gemm_Sigmoid_LogSumExp.py": { + "mean": 8.5, + "std": 0.00916, + "min": 8.49, + "max": 8.55, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "46_Conv2d_Subtract_Tanh_Subtract_AvgPool.py": { + "mean": 5.65, + "std": 0.017, + "min": 5.62, + "max": 5.68, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "47_Conv3d_Mish_Tanh.py": { + "mean": 2.56, + "std": 0.0127, + "min": 2.54, + "max": 2.62, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "48_Conv3d_Scaling_Tanh_Multiply_Sigmoid.py": { + "mean": 3.35, + "std": 0.0361, + "min": 3.34, + "max": 3.7, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "49_ConvTranspose3d_Softmax_Sigmoid.py": { + "mean": 2.89, + "std": 0.127, + "min": 2.86, + "max": 4.15, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "50_ConvTranspose3d_Scaling_AvgPool_BiasAdd_Scaling.py": { + "mean": 5.71, + "std": 0.0255, + "min": 5.68, + "max": 5.76, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "51_Gemm_Subtract_GlobalAvgPool_LogSumExp_GELU_ResidualAdd.py": { + "mean": 5.62, + "std": 0.00244, + "min": 5.61, + "max": 5.63, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "52_Conv2d_Activation_BatchNorm.py": { + "mean": 3.73, + "std": 2.34, + "min": 3.48, + "max": 27.0, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "53_Gemm_Scaling_Hardtanh_GELU.py": { + "mean": 5.53, + "std": 0.0106, + "min": 5.52, + "max": 5.6, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "54_Conv2d_Multiply_LeakyReLU_GELU.py": { + "mean": 6.08, + "std": 0.0744, + "min": 6.03, + "max": 6.82, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "55_Matmul_MaxPool_Sum_Scale.py": { + "mean": 5.27, + "std": 0.00764, + "min": 5.25, + "max": 5.29, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "56_Matmul_Sigmoid_Sum.py": { + "mean": 5.29, + "std": 0.0132, + "min": 5.28, + "max": 5.34, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "57_Conv2d_ReLU_HardSwish.py": { + "mean": 2.99, + "std": 0.00463, + "min": 2.98, + "max": 3.0, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "58_ConvTranspose3d_LogSumExp_HardSwish_Subtract_Clamp.py": { + "mean": 6.84, + "std": 0.0241, + "min": 6.81, + "max": 7.04, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "59_Matmul_Swish_Scaling.py": { + "mean": 5.3, + "std": 0.00878, + "min": 5.29, + "max": 5.34, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "60_ConvTranspose3d_Swish_GroupNorm_HardSwish.py": { + "mean": 7.7, + "std": 0.0146, + "min": 7.68, + "max": 7.78, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "61_ConvTranspose3d_ReLU_GroupNorm.py": { + "mean": 3.79, + "std": 0.052, + "min": 3.77, + "max": 4.3, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "62_Matmul_GroupNorm_LeakyReLU_Sum.py": { + "mean": 3.09, + "std": 0.00155, + "min": 3.08, + "max": 3.09, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "63_Gemm_ReLU_Divide.py": { + "mean": 2.73, + "std": 0.000961, + "min": 2.73, + "max": 2.73, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "64_Gemm_LogSumExp_LeakyReLU_LeakyReLU_GELU_GELU.py": { + "mean": 2.78, + "std": 0.00126, + "min": 2.78, + "max": 2.79, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "65_Conv2d_AvgPool_Sigmoid_Sum.py": { + "mean": 12.0, + "std": 0.00688, + "min": 12.0, + "max": 12.0, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "66_Matmul_Dropout_Softmax.py": { + "mean": 1.44, + "std": 0.00272, + "min": 1.43, + "max": 1.46, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "67_Conv2d_GELU_GlobalAvgPool.py": { + "mean": 6.48, + "std": 0.0133, + "min": 6.46, + "max": 6.57, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "68_Matmul_Min_Subtract.py": { + "mean": 1.44, + "std": 0.00578, + "min": 1.44, + "max": 1.46, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "69_Conv2d_HardSwish_ReLU.py": { + "mean": 1.81, + "std": 0.00875, + "min": 1.79, + "max": 1.83, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "70_Gemm_Sigmoid_Scaling_ResidualAdd.py": { + "mean": 2.77, + "std": 0.00184, + "min": 2.77, + "max": 2.77, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "71_Conv2d_Divide_LeakyReLU.py": { + "mean": 1.8, + "std": 0.00387, + "min": 1.79, + "max": 1.8, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "72_ConvTranspose3d_BatchNorm_AvgPool_AvgPool.py": { + "mean": 12.3, + "std": 0.0156, + "min": 12.2, + "max": 12.4, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "73_Conv2d_BatchNorm_Scaling.py": { + "mean": 2.59, + "std": 0.00487, + "min": 2.58, + "max": 2.6, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "74_ConvTranspose3d_LeakyReLU_Multiply_LeakyReLU_Max.py": { + "mean": 1.47, + "std": 0.00462, + "min": 1.46, + "max": 1.5, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "75_Gemm_GroupNorm_Min_BiasAdd.py": { + "mean": 3.09, + "std": 0.00233, + "min": 3.08, + "max": 3.09, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "76_Gemm_Add_ReLU.py": { + "mean": 2.78, + "std": 0.00408, + "min": 2.78, + "max": 2.8, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "77_ConvTranspose3d_Scale_BatchNorm_GlobalAvgPool.py": { + "mean": 5.42, + "std": 0.035, + "min": 5.33, + "max": 5.51, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "78_ConvTranspose3d_Max_Max_Sum.py": { + "mean": 47.4, + "std": 0.0213, + "min": 47.3, + "max": 47.5, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "79_Conv3d_Multiply_InstanceNorm_Clamp_Multiply_Max.py": { + "mean": 0.965, + "std": 0.00863, + "min": 0.961, + "max": 1.03, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "80_Gemm_Max_Subtract_GELU.py": { + "mean": 2.72, + "std": 0.00535, + "min": 2.71, + "max": 2.74, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "81_Gemm_Swish_Divide_Clamp_Tanh_Clamp.py": { + "mean": 2.83, + "std": 0.00763, + "min": 2.82, + "max": 2.84, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "82_Conv2d_Tanh_Scaling_BiasAdd_Max.py": { + "mean": 9.79, + "std": 0.013, + "min": 9.76, + "max": 9.82, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "83_Conv3d_GroupNorm_Min_Clamp_Dropout.py": { + "mean": 3.68, + "std": 0.00569, + "min": 3.68, + "max": 3.73, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "84_Gemm_BatchNorm_Scaling_Softmax.py": { + "mean": 2.8, + "std": 0.00658, + "min": 2.78, + "max": 2.81, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "85_Conv2d_GroupNorm_Scale_MaxPool_Clamp.py": { + "mean": 2.51, + "std": 0.00366, + "min": 2.49, + "max": 2.51, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "86_Matmul_Divide_GELU.py": { + "mean": 2.73, + "std": 0.0087, + "min": 2.71, + "max": 2.75, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "87_Conv2d_Subtract_Subtract_Mish.py": { + "mean": 8.57, + "std": 0.0101, + "min": 8.55, + "max": 8.6, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "88_Gemm_GroupNorm_Swish_Multiply_Swish.py": { + "mean": 3.03, + "std": 0.00526, + "min": 3.03, + "max": 3.07, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "89_ConvTranspose3d_MaxPool_Softmax_Subtract_Swish_Max.py": { + "mean": 5.68, + "std": 0.0259, + "min": 5.65, + "max": 5.75, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "90_Conv3d_LeakyReLU_Sum_Clamp_GELU.py": { + "mean": 11.4, + "std": 0.00224, + "min": 11.4, + "max": 11.4, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "91_ConvTranspose2d_Softmax_BiasAdd_Scaling_Sigmoid.py": { + "mean": 9.28, + "std": 0.258, + "min": 9.14, + "max": 11.8, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "92_Conv2d_GroupNorm_Tanh_HardSwish_ResidualAdd_LogSumExp.py": { + "mean": 4.25, + "std": 0.00599, + "min": 4.24, + "max": 4.29, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "93_ConvTranspose2d_Add_Min_GELU_Multiply.py": { + "mean": 5.73, + "std": 0.139, + "min": 5.69, + "max": 7.1, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "94_Gemm_BiasAdd_Hardtanh_Mish_GroupNorm.py": { + "mean": 2.96, + "std": 0.00305, + "min": 2.95, + "max": 2.97, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "95_Matmul_Add_Swish_Tanh_GELU_Hardtanh.py": { + "mean": 2.85, + "std": 0.00396, + "min": 2.84, + "max": 2.87, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "96_ConvTranspose3d_Multiply_Max_GlobalAvgPool_Clamp.py": { + "mean": 5.35, + "std": 0.0217, + "min": 5.33, + "max": 5.4, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "97_Matmul_BatchNorm_BiasAdd_Divide_Swish.py": { + "mean": 2.83, + "std": 0.00592, + "min": 2.82, + "max": 2.87, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "98_Matmul_AvgPool_GELU_Scale_Max.py": { + "mean": 2.71, + "std": 0.00995, + "min": 2.7, + "max": 2.72, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "99_Matmul_GELU_Softmax.py": { + "mean": 2.75, + "std": 0.00399, + "min": 2.75, + "max": 2.77, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "100_ConvTranspose3d_Clamp_Min_Divide.py": { + "mean": 13.6, + "std": 1.05, + "min": 13.5, + "max": 24.0, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + } + }, + "level3": { + "1_MLP.py": { + "mean": 3.79, + "std": 0.0217, + "min": 3.78, + "max": 4.0, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "2_ShallowWideMLP.py": { + "mean": 11.0, + "std": 0.463, + "min": 10.7, + "max": 12.6, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "3_DeepNarrowMLP.py": { + "mean": 1.81, + "std": 0.0139, + "min": 1.8, + "max": 1.94, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "4_LeNet5.py": { + "mean": 0.821, + "std": 0.00086, + "min": 0.819, + "max": 0.823, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "5_AlexNet.py": { + "mean": 23.7, + "std": 0.109, + "min": 23.5, + "max": 23.9, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "6_GoogleNetInceptionModule.py": { + "mean": 8.77, + "std": 0.0346, + "min": 8.75, + "max": 9.0, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "7_GoogleNetInceptionV1.py": { + "mean": 2.65, + "std": 0.0259, + "min": 2.55, + "max": 2.72, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "8_ResNetBasicBlock.py": { + "mean": 1.68, + "std": 0.00463, + "min": 1.68, + "max": 1.73, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "9_ResNet18.py": { + "mean": 1.67, + "std": 0.0492, + "min": 1.61, + "max": 1.96, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "10_ResNet101.py": { + "mean": 8.79, + "std": 0.0645, + "min": 8.6, + "max": 9.01, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "11_VGG16.py": { + "mean": 3.39, + "std": 0.0176, + "min": 3.35, + "max": 3.43, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "12_VGG19.py": { + "mean": 3.88, + "std": 0.0234, + "min": 3.8, + "max": 3.92, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "13_DenseNet121TransitionLayer.py": { + "mean": 7.33, + "std": 0.0161, + "min": 7.3, + "max": 7.4, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "14_DenseNet121DenseBlock.py": { + "mean": 7.47, + "std": 0.0274, + "min": 7.44, + "max": 7.69, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "15_DenseNet121.py": { + "mean": 6.68, + "std": 0.116, + "min": 6.24, + "max": 7.07, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "16_DenseNet201.py": { + "mean": 10.4, + "std": 0.239, + "min": 9.83, + "max": 10.8, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "17_SqueezeNetFireModule.py": { + "mean": 13.3, + "std": 0.035, + "min": 13.2, + "max": 13.4, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "18_SqueezeNet.py": { + "mean": 28.0, + "std": 0.0384, + "min": 28.0, + "max": 28.2, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "19_MobileNetV1.py": { + "mean": 1.73, + "std": 0.0508, + "min": 1.68, + "max": 2.08, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "20_MobileNetV2.py": { + "mean": 3.56, + "std": 0.0898, + "min": 3.45, + "max": 4.12, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "21_EfficientNetMBConv.py": { + "mean": 5.43, + "std": 0.00673, + "min": 5.41, + "max": 5.44, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "22_EfficientNetB0.py": { + "mean": 3.03, + "std": 0.0741, + "min": 2.95, + "max": 3.52, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "23_EfficientNetB1.py": { + "mean": 1.62, + "std": 0.0357, + "min": 1.49, + "max": 1.77, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "24_EfficientNetB2.py": { + "mean": 1.64, + "std": 0.0319, + "min": 1.57, + "max": 1.75, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "25_ShuffleNetUnit.py": { + "mean": 8.17, + "std": 0.014, + "min": 8.14, + "max": 8.22, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "26_ShuffleNet.py": { + "mean": 8.23, + "std": 0.0498, + "min": 8.14, + "max": 8.52, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "27_RegNet.py": { + "mean": 2.37, + "std": 0.0166, + "min": 2.36, + "max": 2.52, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "28_VisionTransformer.py": { + "mean": 1.81, + "std": 0.0516, + "min": 1.73, + "max": 2.17, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "29_SwinMLP.py": { + "mean": 4.33, + "std": 0.177, + "min": 4.02, + "max": 5.41, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "30_SwinTransformerV2.py": { + "mean": 9.75, + "std": 0.0864, + "min": 9.6, + "max": 10.2, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "31_VisionAttention.py": { + "mean": 21.7, + "std": 0.14, + "min": 21.6, + "max": 22.5, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "32_ConvolutionalVisionTransformer.py": { + "mean": 2.21, + "std": 0.0297, + "min": 2.15, + "max": 2.29, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "33_VanillaRNN.py": { + "mean": 6.84, + "std": 0.00737, + "min": 6.82, + "max": 6.89, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "34_VanillaRNNHidden.py": { + "mean": 16.1, + "std": 0.379, + "min": 15.6, + "max": 19.2, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "35_LSTM.py": { + "mean": 27.2, + "std": 0.259, + "min": 26.1, + "max": 28.3, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "36_LSTMHn.py": { + "mean": 35.8, + "std": 0.411, + "min": 35.3, + "max": 39.4, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "37_LSTMCn.py": { + "mean": 28.0, + "std": 2.55, + "min": 26.2, + "max": 35.8, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "38_LSTMBidirectional.py": { + "mean": 54.1, + "std": 1.98, + "min": 51.6, + "max": 57.6, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "39_GRU.py": { + "mean": 39.1, + "std": 0.145, + "min": 38.9, + "max": 39.5, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "40_GRUHidden.py": { + "mean": 38.5, + "std": 2.74, + "min": 35.2, + "max": 50.7, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "41_GRUBidirectional.py": { + "mean": 77.5, + "std": 0.683, + "min": 76.2, + "max": 79.3, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "42_GRUBidirectionalHidden.py": { + "mean": 82.6, + "std": 0.889, + "min": 81.0, + "max": 84.9, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "43_MinGPTCausalAttention.py": { + "mean": 13.1, + "std": 2.57, + "min": 12.8, + "max": 38.6, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "44_MiniGPTBlock.py": { + "mean": 30.3, + "std": 0.00841, + "min": 30.3, + "max": 30.4, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "45_UNetSoftmax.py": { + "mean": 5.04, + "std": 0.0131, + "min": 5.01, + "max": 5.06, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "46_NetVladWithGhostClusters.py": { + "mean": 1.58, + "std": 0.0027, + "min": 1.58, + "max": 1.59, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "47_NetVladNoGhostClusters.py": { + "mean": 1.64, + "std": 2.02, + "min": 1.43, + "max": 21.7, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "48_Mamba2ReturnY.py": { + "mean": 7.98, + "std": 0.0239, + "min": 7.97, + "max": 8.2, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "49_Mamba2ReturnFinalState.py": { + "mean": 5.94, + "std": 0.0103, + "min": 5.92, + "max": 5.97, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "50_ReLUSelfAttention.py": { + "mean": 5.02, + "std": 0.00426, + "min": 5.01, + "max": 5.05, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + } + } +} \ No newline at end of file diff --git a/results/timing/H100_Modal/baseline_time_torch_compile_inductor_default.json b/results/timing/H100_Modal/baseline_time_torch_compile_inductor_default.json new file mode 100644 index 00000000..f2d2486a --- /dev/null +++ b/results/timing/H100_Modal/baseline_time_torch_compile_inductor_default.json @@ -0,0 +1,2258 @@ +{ + "level1": { + "1_Square_matrix_multiplication_.py": { + "mean": 2.67, + "std": 0.0519, + "min": 2.66, + "max": 3.18, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "2_Standard_matrix_multiplication_.py": { + "mean": 2.66, + "std": 0.0307, + "min": 2.64, + "max": 2.94, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "3_Batched_matrix_multiplication.py": { + "mean": 5.35, + "std": 0.0569, + "min": 5.32, + "max": 5.87, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "4_Matrix_vector_multiplication_.py": { + "mean": 2.79, + "std": 0.014, + "min": 2.78, + "max": 2.9, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "5_Matrix_scalar_multiplication.py": { + "mean": 2.85, + "std": 0.122, + "min": 2.82, + "max": 4.05, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "6_Matmul_with_large_K_dimension_.py": { + "mean": 1.38, + "std": 0.0618, + "min": 1.32, + "max": 1.64, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "7_Matmul_with_small_K_dimension_.py": { + "mean": 4.07, + "std": 0.105, + "min": 4.04, + "max": 5.1, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "8_Matmul_with_irregular_shapes_.py": { + "mean": 6.43, + "std": 0.0467, + "min": 6.41, + "max": 6.81, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "9_Tall_skinny_matrix_multiplication_.py": { + "mean": 2.62, + "std": 0.137, + "min": 2.58, + "max": 3.97, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "10_3D_tensor_matrix_multiplication.py": { + "mean": 1.05, + "std": 0.0359, + "min": 1.04, + "max": 1.36, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "11_4D_tensor_matrix_multiplication.py": { + "mean": 10.9, + "std": 1.07, + "min": 10.0, + "max": 15.6, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "12_Matmul_with_diagonal_matrices_.py": { + "mean": 2.69, + "std": 0.00913, + "min": 2.68, + "max": 2.73, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "13_Matmul_for_symmetric_matrices.py": { + "mean": 2.67, + "std": 0.04, + "min": 2.65, + "max": 3.0, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "14_Matmul_for_upper_triangular_matrices.py": { + "mean": 2.75, + "std": 0.0084, + "min": 2.74, + "max": 2.79, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "15_Matmul_for_lower_triangular_matrices.py": { + "mean": 2.73, + "std": 0.0358, + "min": 2.71, + "max": 2.99, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "16_Matmul_with_transposed_A.py": { + "mean": 2.64, + "std": 0.00899, + "min": 2.63, + "max": 2.71, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "17_Matmul_with_transposed_B.py": { + "mean": 2.71, + "std": 0.0445, + "min": 2.7, + "max": 3.14, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "18_Matmul_with_transposed_both.py": { + "mean": 2.79, + "std": 0.0138, + "min": 2.78, + "max": 2.89, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "19_ReLU.py": { + "mean": 4.35, + "std": 0.287, + "min": 4.24, + "max": 7.02, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "20_LeakyReLU.py": { + "mean": 4.28, + "std": 0.203, + "min": 4.23, + "max": 6.26, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "21_Sigmoid.py": { + "mean": 4.3, + "std": 0.192, + "min": 4.23, + "max": 6.13, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "22_Tanh.py": { + "mean": 4.33, + "std": 0.283, + "min": 4.24, + "max": 7.0, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "23_Softmax.py": { + "mean": 6.55, + "std": 0.191, + "min": 6.49, + "max": 8.37, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "24_LogSoftmax.py": { + "mean": 6.68, + "std": 1.43, + "min": 6.5, + "max": 20.9, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "25_Swish.py": { + "mean": 4.28, + "std": 0.297, + "min": 4.23, + "max": 7.22, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "26_GELU_.py": { + "mean": 4.27, + "std": 0.195, + "min": 4.23, + "max": 6.19, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "27_SELU_.py": { + "mean": 4.3, + "std": 0.19, + "min": 4.23, + "max": 6.16, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "28_HardSigmoid.py": { + "mean": 4.3, + "std": 0.19, + "min": 4.23, + "max": 6.15, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "29_Softplus.py": { + "mean": 4.3, + "std": 0.194, + "min": 4.23, + "max": 6.18, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "30_Softsign.py": { + "mean": 4.3, + "std": 0.191, + "min": 4.23, + "max": 6.15, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "31_ELU.py": { + "mean": 4.38, + "std": 1.02, + "min": 4.23, + "max": 14.5, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "32_HardTanh.py": { + "mean": 4.29, + "std": 0.178, + "min": 4.23, + "max": 6.03, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "33_BatchNorm.py": { + "mean": 4.38, + "std": 0.219, + "min": 4.19, + "max": 6.07, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "34_InstanceNorm.py": { + "mean": 7.6, + "std": 0.196, + "min": 7.48, + "max": 9.46, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "35_GroupNorm_.py": { + "mean": 8.22, + "std": 0.101, + "min": 8.08, + "max": 8.43, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "36_RMSNorm_.py": { + "mean": 7.84, + "std": 0.0539, + "min": 7.77, + "max": 8.1, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "37_FrobeniusNorm_.py": { + "mean": 7.45, + "std": 0.204, + "min": 7.3, + "max": 8.01, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "38_L1Norm_.py": { + "mean": 13.1, + "std": 0.303, + "min": 12.8, + "max": 15.5, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "39_L2Norm_.py": { + "mean": 13.1, + "std": 0.285, + "min": 12.9, + "max": 15.4, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "40_LayerNorm.py": { + "mean": 0.46, + "std": 0.0302, + "min": 0.45, + "max": 0.738, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "41_Max_Pooling_1D.py": { + "mean": 2.85, + "std": 0.155, + "min": 2.8, + "max": 4.29, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "42_Max_Pooling_2D.py": { + "mean": 4.33, + "std": 0.0106, + "min": 4.3, + "max": 4.37, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "43_Max_Pooling_3D.py": { + "mean": 5.65, + "std": 0.00607, + "min": 5.65, + "max": 5.68, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "44_Average_Pooling_1D.py": { + "mean": 3.13, + "std": 0.0119, + "min": 3.12, + "max": 3.18, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "45_Average_Pooling_2D.py": { + "mean": 6.34, + "std": 0.0946, + "min": 6.26, + "max": 6.73, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "46_Average_Pooling_3D.py": { + "mean": 8.7, + "std": 0.172, + "min": 8.66, + "max": 10.3, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "47_Sum_reduction_over_a_dimension.py": { + "mean": 3.38, + "std": 0.023, + "min": 3.34, + "max": 3.56, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "48_Mean_reduction_over_a_dimension.py": { + "mean": 3.57, + "std": 0.273, + "min": 3.49, + "max": 6.24, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "49_Max_reduction_over_a_dimension.py": { + "mean": 3.53, + "std": 0.142, + "min": 3.47, + "max": 4.47, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "50_conv_standard_2D__square_input__square_kernel.py": { + "mean": 1.74, + "std": 0.0298, + "min": 1.7, + "max": 1.89, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "51_Argmax_over_a_dimension.py": { + "mean": 3.33, + "std": 0.0153, + "min": 3.32, + "max": 3.47, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "52_Argmin_over_a_dimension.py": { + "mean": 3.37, + "std": 0.354, + "min": 3.32, + "max": 6.84, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "53_Min_reduction_over_a_dimension.py": { + "mean": 3.34, + "std": 0.0322, + "min": 3.31, + "max": 3.57, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "54_conv_standard_3D__square_input__square_kernel.py": { + "mean": 1.86, + "std": 0.114, + "min": 1.84, + "max": 2.97, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "55_conv_standard_2D__asymmetric_input__square_kernel.py": { + "mean": 4.38, + "std": 0.00925, + "min": 4.36, + "max": 4.42, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "56_conv_standard_2D__asymmetric_input__asymmetric_kernel.py": { + "mean": 2.99, + "std": 0.135, + "min": 2.78, + "max": 3.56, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "57_conv_transposed_2D__square_input__square_kernel.py": { + "mean": 6.47, + "std": 0.386, + "min": 6.39, + "max": 10.3, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "58_conv_transposed_3D__asymmetric_input__asymmetric_kernel.py": { + "mean": 7.74, + "std": 0.018, + "min": 7.72, + "max": 7.81, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "59_conv_standard_3D__asymmetric_input__square_kernel.py": { + "mean": 2.89, + "std": 0.0129, + "min": 2.87, + "max": 2.95, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "60_conv_standard_3D__square_input__asymmetric_kernel.py": { + "mean": 7.71, + "std": 0.0184, + "min": 7.66, + "max": 7.76, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "61_conv_transposed_3D__square_input__square_kernel.py": { + "mean": 9.08, + "std": 0.00805, + "min": 9.06, + "max": 9.11, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "62_conv_standard_2D__square_input__asymmetric_kernel.py": { + "mean": 2.46, + "std": 0.0206, + "min": 2.43, + "max": 2.51, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "63_conv_standard_2D__square_input__square_kernel.py": { + "mean": 12.7, + "std": 0.139, + "min": 12.6, + "max": 13.3, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "64_conv_transposed_1D.py": { + "mean": 5.33, + "std": 0.209, + "min": 5.2, + "max": 7.2, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "65_conv_transposed_2D__square_input__asymmetric_kernel.py": { + "mean": 2.65, + "std": 0.0405, + "min": 2.62, + "max": 2.89, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "66_conv_standard_3D__asymmetric_input__asymmetric_kernel.py": { + "mean": 3.8, + "std": 0.00863, + "min": 3.79, + "max": 3.84, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "67_conv_standard_1D.py": { + "mean": 2.65, + "std": 0.0146, + "min": 2.63, + "max": 2.71, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "68_conv_transposed_3D__square_input__asymmetric_kernel.py": { + "mean": 36.9, + "std": 0.146, + "min": 36.8, + "max": 38.3, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "69_conv_transposed_2D__asymmetric_input__asymmetric_kernel.py": { + "mean": 2.83, + "std": 0.0309, + "min": 2.78, + "max": 3.02, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "70_conv_transposed_3D__asymmetric_input__square_kernel.py": { + "mean": 29.3, + "std": 0.0182, + "min": 29.3, + "max": 29.4, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "71_conv_transposed_2D__asymmetric_input__square_kernel.py": { + "mean": 1.6, + "std": 0.0117, + "min": 1.58, + "max": 1.64, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "72_conv_transposed_3D_asymmetric_input_asymmetric_kernel___strided_padded_grouped_.py": { + "mean": 2.82, + "std": 0.00789, + "min": 2.8, + "max": 2.86, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "73_conv_transposed_3D_asymmetric_input_square_kernel__strided_padded__grouped.py": { + "mean": 2.2, + "std": 0.193, + "min": 2.11, + "max": 3.98, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "74_conv_transposed_1D_dilated.py": { + "mean": 2.35, + "std": 2.41, + "min": 2.09, + "max": 26.3, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "75_conv_transposed_2D_asymmetric_input_asymmetric_kernel_strided__grouped____padded____dilated__.py": { + "mean": 6.75, + "std": 0.129, + "min": 6.66, + "max": 7.76, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "76_conv_standard_1D_dilated_strided__.py": { + "mean": 12.3, + "std": 0.25, + "min": 12.1, + "max": 14.5, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "77_conv_transposed_3D_square_input_square_kernel___padded____dilated____strided__.py": { + "mean": 1.96, + "std": 0.0339, + "min": 1.92, + "max": 2.25, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "78_conv_transposed_2D_asymmetric_input_asymmetric_kernel___padded__.py": { + "mean": 2.36, + "std": 0.0277, + "min": 2.34, + "max": 2.57, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "79_conv_transposed_1D_asymmetric_input_square_kernel___padded____strided____dilated__.py": { + "mean": 1.91, + "std": 0.0754, + "min": 1.87, + "max": 2.65, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "80_conv_standard_2D_square_input_asymmetric_kernel___dilated____padded__.py": { + "mean": 2.68, + "std": 0.0636, + "min": 2.63, + "max": 2.95, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "81_conv_transposed_2D_asymmetric_input_square_kernel___dilated____padded____strided__.py": { + "mean": 1.88, + "std": 0.021, + "min": 1.85, + "max": 2.05, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "82_conv_depthwise_2D_square_input_square_kernel.py": { + "mean": 2.48, + "std": 0.098, + "min": 2.45, + "max": 3.43, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "83_conv_depthwise_2D_square_input_asymmetric_kernel.py": { + "mean": 7.63, + "std": 0.0811, + "min": 7.52, + "max": 8.3, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "84_conv_depthwise_2D_asymmetric_input_square_kernel.py": { + "mean": 9.83, + "std": 0.21, + "min": 9.78, + "max": 11.8, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "85_conv_depthwise_2D_asymmetric_input_asymmetric_kernel.py": { + "mean": 13.8, + "std": 0.0502, + "min": 13.8, + "max": 14.0, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "86_conv_depthwise_separable_2D.py": { + "mean": 4.18, + "std": 0.0915, + "min": 4.16, + "max": 4.83, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "87_conv_pointwise_2D.py": { + "mean": 13.3, + "std": 0.179, + "min": 13.3, + "max": 13.9, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "88_MinGPTNewGelu.py": { + "mean": 0.214, + "std": 0.0401, + "min": 0.182, + "max": 0.457, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "89_cumsum.py": { + "mean": 4.7, + "std": 0.671, + "min": 4.6, + "max": 11.4, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "90_cumprod.py": { + "mean": 4.66, + "std": 0.154, + "min": 4.61, + "max": 6.13, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "91_cumsum_reverse.py": { + "mean": 7.45, + "std": 0.0784, + "min": 7.39, + "max": 7.77, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "92_cumsum_exclusive.py": { + "mean": 3.15, + "std": 0.173, + "min": 3.11, + "max": 4.83, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "93_masked_cumsum.py": { + "mean": 3.84, + "std": 4.14, + "min": 3.42, + "max": 45.0, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "94_MSELoss.py": { + "mean": 2.81, + "std": 0.0698, + "min": 2.78, + "max": 3.09, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "95_CrossEntropyLoss.py": { + "mean": 0.292, + "std": 0.00691, + "min": 0.287, + "max": 0.324, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "96_HuberLoss.py": { + "mean": 2.71, + "std": 0.0124, + "min": 2.7, + "max": 2.83, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "97_ScaledDotProductAttention.py": { + "mean": 8.15, + "std": 0.176, + "min": 8.02, + "max": 8.98, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "98_KLDivLoss.py": { + "mean": 0.779, + "std": 0.0124, + "min": 0.764, + "max": 0.874, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "99_TripletMarginLoss.py": { + "mean": 1.06, + "std": 0.0148, + "min": 1.05, + "max": 1.16, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "100_HingeLoss.py": { + "mean": 1.38, + "std": 0.00479, + "min": 1.37, + "max": 1.41, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + } + }, + "level2": { + "1_Conv2D_ReLU_BiasAdd.py": { + "mean": 1.96, + "std": 0.0439, + "min": 1.94, + "max": 2.34, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "2_ConvTranspose2d_BiasAdd_Clamp_Scaling_Clamp_Divide.py": { + "mean": 3.44, + "std": 0.0889, + "min": 3.41, + "max": 4.23, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "3_ConvTranspose3d_Sum_LayerNorm_AvgPool_GELU.py": { + "mean": 2.53, + "std": 0.0199, + "min": 2.52, + "max": 2.66, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "4_Conv2d_Mish_Mish.py": { + "mean": 4.78, + "std": 0.0456, + "min": 4.66, + "max": 4.91, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "5_ConvTranspose2d_Subtract_Tanh.py": { + "mean": 3.6, + "std": 0.383, + "min": 3.55, + "max": 7.41, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "6_Conv3d_Softmax_MaxPool_MaxPool.py": { + "mean": 0.621, + "std": 0.0151, + "min": 0.617, + "max": 0.768, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "7_Conv3d_ReLU_LeakyReLU_GELU_Sigmoid_BiasAdd.py": { + "mean": 3.01, + "std": 0.113, + "min": 2.99, + "max": 4.1, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "8_Conv3d_Divide_Max_GlobalAvgPool_BiasAdd_Sum.py": { + "mean": 2.51, + "std": 0.0181, + "min": 2.48, + "max": 2.61, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "9_Matmul_Subtract_Multiply_ReLU.py": { + "mean": 2.75, + "std": 0.0277, + "min": 2.73, + "max": 2.99, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "10_ConvTranspose2d_MaxPool_Hardtanh_Mean_Tanh.py": { + "mean": 6.41, + "std": 0.0426, + "min": 6.39, + "max": 6.72, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "11_ConvTranspose2d_BatchNorm_Tanh_MaxPool_GroupNorm.py": { + "mean": 1.42, + "std": 0.0375, + "min": 1.4, + "max": 1.77, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "12_Gemm_Multiply_LeakyReLU.py": { + "mean": 2.77, + "std": 0.0199, + "min": 2.75, + "max": 2.9, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "13_ConvTranspose3d_Mean_Add_Softmax_Tanh_Scaling.py": { + "mean": 8.37, + "std": 0.0256, + "min": 8.34, + "max": 8.54, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "14_Gemm_Divide_Sum_Scaling.py": { + "mean": 2.77, + "std": 0.0197, + "min": 2.75, + "max": 2.92, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "15_ConvTranspose3d_BatchNorm_Subtract.py": { + "mean": 1.47, + "std": 0.211, + "min": 1.42, + "max": 3.0, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "16_ConvTranspose2d_Mish_Add_Hardtanh_Scaling.py": { + "mean": 3.49, + "std": 0.0753, + "min": 3.46, + "max": 4.05, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "17_Conv2d_InstanceNorm_Divide.py": { + "mean": 5.18, + "std": 0.067, + "min": 5.13, + "max": 5.77, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "18_Matmul_Sum_Max_AvgPool_LogSumExp_LogSumExp.py": { + "mean": 2.71, + "std": 0.0101, + "min": 2.69, + "max": 2.74, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "19_ConvTranspose2d_GELU_GroupNorm.py": { + "mean": 8.14, + "std": 0.0421, + "min": 8.11, + "max": 8.49, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "20_ConvTranspose3d_Sum_ResidualAdd_Multiply_ResidualAdd.py": { + "mean": 1.13, + "std": 0.188, + "min": 1.1, + "max": 2.97, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "21_Conv2d_Add_Scale_Sigmoid_GroupNorm.py": { + "mean": 2.97, + "std": 0.0319, + "min": 2.9, + "max": 3.06, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "22_Matmul_Scale_ResidualAdd_Clamp_LogSumExp_Mish.py": { + "mean": 2.77, + "std": 0.0125, + "min": 2.76, + "max": 2.83, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "23_Conv3d_GroupNorm_Mean.py": { + "mean": 2.65, + "std": 0.00985, + "min": 2.64, + "max": 2.7, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "24_Conv3d_Min_Softmax.py": { + "mean": 0.867, + "std": 0.00983, + "min": 0.856, + "max": 0.953, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "25_Conv2d_Min_Tanh_Tanh.py": { + "mean": 2.68, + "std": 0.0178, + "min": 2.66, + "max": 2.83, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "26_ConvTranspose3d_Add_HardSwish.py": { + "mean": 2.47, + "std": 0.0541, + "min": 2.45, + "max": 3.0, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "27_Conv3d_HardSwish_GroupNorm_Mean.py": { + "mean": 8.22, + "std": 0.0204, + "min": 8.2, + "max": 8.4, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "28_BMM_InstanceNorm_Sum_ResidualAdd_Multiply.py": { + "mean": 2.82, + "std": 0.0149, + "min": 2.8, + "max": 2.9, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "29_Matmul_Mish_Mish.py": { + "mean": 2.76, + "std": 0.0137, + "min": 2.74, + "max": 2.81, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "30_Gemm_GroupNorm_Hardtanh.py": { + "mean": 2.75, + "std": 0.00965, + "min": 2.74, + "max": 2.81, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "31_Conv2d_Min_Add_Multiply.py": { + "mean": 3.54, + "std": 0.0711, + "min": 3.48, + "max": 4.19, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "32_Conv2d_Scaling_Min.py": { + "mean": 4.73, + "std": 0.0626, + "min": 4.62, + "max": 4.85, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "33_Gemm_Scale_BatchNorm.py": { + "mean": 2.8, + "std": 0.0209, + "min": 2.79, + "max": 2.96, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "34_ConvTranspose3d_LayerNorm_GELU_Scaling.py": { + "mean": 2.35, + "std": 0.357, + "min": 2.29, + "max": 5.89, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "35_Conv2d_Subtract_HardSwish_MaxPool_Mish.py": { + "mean": 4.32, + "std": 0.0263, + "min": 4.27, + "max": 4.43, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "36_ConvTranspose2d_Min_Sum_GELU_Add.py": { + "mean": 0.987, + "std": 0.0279, + "min": 0.974, + "max": 1.22, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "37_Matmul_Swish_Sum_GroupNorm.py": { + "mean": 6.07, + "std": 0.0683, + "min": 6.05, + "max": 6.74, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "38_ConvTranspose3d_AvgPool_Clamp_Softmax_Multiply.py": { + "mean": 2.76, + "std": 0.0726, + "min": 2.74, + "max": 3.48, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "39_Gemm_Scale_BatchNorm.py": { + "mean": 11.1, + "std": 0.0397, + "min": 11.0, + "max": 11.2, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "40_Matmul_Scaling_ResidualAdd.py": { + "mean": 11.0, + "std": 0.08, + "min": 10.9, + "max": 11.2, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "41_Gemm_BatchNorm_GELU_ReLU.py": { + "mean": 11.1, + "std": 0.0426, + "min": 11.1, + "max": 11.3, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "42_ConvTranspose2d_GlobalAvgPool_BiasAdd_LogSumExp_Sum_Multiply.py": { + "mean": 5.54, + "std": 0.0282, + "min": 5.5, + "max": 5.76, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "43_Conv3d_Max_LogSumExp_ReLU.py": { + "mean": 2.35, + "std": 0.0167, + "min": 2.33, + "max": 2.44, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "44_ConvTranspose2d_Multiply_GlobalAvgPool_GlobalAvgPool_Mean.py": { + "mean": 0.949, + "std": 0.0109, + "min": 0.939, + "max": 1.04, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "45_Gemm_Sigmoid_LogSumExp.py": { + "mean": 8.42, + "std": 0.0526, + "min": 8.38, + "max": 8.83, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "46_Conv2d_Subtract_Tanh_Subtract_AvgPool.py": { + "mean": 2.4, + "std": 0.0684, + "min": 2.37, + "max": 3.07, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "47_Conv3d_Mish_Tanh.py": { + "mean": 1.96, + "std": 0.628, + "min": 1.86, + "max": 8.2, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "48_Conv3d_Scaling_Tanh_Multiply_Sigmoid.py": { + "mean": 1.96, + "std": 0.0412, + "min": 1.95, + "max": 2.36, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "49_ConvTranspose3d_Softmax_Sigmoid.py": { + "mean": 1.5, + "std": 0.0558, + "min": 1.48, + "max": 2.04, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "50_ConvTranspose3d_Scaling_AvgPool_BiasAdd_Scaling.py": { + "mean": 4.64, + "std": 0.041, + "min": 4.59, + "max": 4.81, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "51_Gemm_Subtract_GlobalAvgPool_LogSumExp_GELU_ResidualAdd.py": { + "mean": 5.49, + "std": 0.0264, + "min": 5.46, + "max": 5.69, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "52_Conv2d_Activation_BatchNorm.py": { + "mean": 3.47, + "std": 0.0735, + "min": 3.42, + "max": 4.18, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "53_Gemm_Scaling_Hardtanh_GELU.py": { + "mean": 5.45, + "std": 0.0261, + "min": 5.44, + "max": 5.67, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "54_Conv2d_Multiply_LeakyReLU_GELU.py": { + "mean": 2.79, + "std": 0.0742, + "min": 2.76, + "max": 3.5, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "55_Matmul_MaxPool_Sum_Scale.py": { + "mean": 5.33, + "std": 0.019, + "min": 5.3, + "max": 5.39, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "56_Matmul_Sigmoid_Sum.py": { + "mean": 5.31, + "std": 0.0128, + "min": 5.29, + "max": 5.35, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "57_Conv2d_ReLU_HardSwish.py": { + "mean": 0.814, + "std": 0.0219, + "min": 0.801, + "max": 0.985, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "58_ConvTranspose3d_LogSumExp_HardSwish_Subtract_Clamp.py": { + "mean": 3.62, + "std": 0.0232, + "min": 3.59, + "max": 3.71, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "59_Matmul_Swish_Scaling.py": { + "mean": 5.31, + "std": 0.0196, + "min": 5.28, + "max": 5.41, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "60_ConvTranspose3d_Swish_GroupNorm_HardSwish.py": { + "mean": 4.56, + "std": 0.105, + "min": 4.51, + "max": 5.53, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "61_ConvTranspose3d_ReLU_GroupNorm.py": { + "mean": 3.68, + "std": 0.0648, + "min": 3.62, + "max": 4.27, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "62_Matmul_GroupNorm_LeakyReLU_Sum.py": { + "mean": 2.76, + "std": 0.037, + "min": 2.74, + "max": 3.1, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "63_Gemm_ReLU_Divide.py": { + "mean": 2.77, + "std": 0.0124, + "min": 2.76, + "max": 2.83, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "64_Gemm_LogSumExp_LeakyReLU_LeakyReLU_GELU_GELU.py": { + "mean": 2.73, + "std": 0.00902, + "min": 2.72, + "max": 2.77, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "65_Conv2d_AvgPool_Sigmoid_Sum.py": { + "mean": 8.78, + "std": 0.0425, + "min": 8.74, + "max": 9.01, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "66_Matmul_Dropout_Softmax.py": { + "mean": 1.5, + "std": 0.013, + "min": 1.49, + "max": 1.6, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "67_Conv2d_GELU_GlobalAvgPool.py": { + "mean": 4.62, + "std": 0.0176, + "min": 4.59, + "max": 4.74, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "68_Matmul_Min_Subtract.py": { + "mean": 1.43, + "std": 0.00848, + "min": 1.42, + "max": 1.47, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "69_Conv2d_HardSwish_ReLU.py": { + "mean": 0.837, + "std": 0.0158, + "min": 0.81, + "max": 0.94, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "70_Gemm_Sigmoid_Scaling_ResidualAdd.py": { + "mean": 2.77, + "std": 0.0495, + "min": 2.74, + "max": 3.24, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "71_Conv2d_Divide_LeakyReLU.py": { + "mean": 1.56, + "std": 0.0617, + "min": 1.53, + "max": 2.14, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "72_ConvTranspose3d_BatchNorm_AvgPool_AvgPool.py": { + "mean": 8.82, + "std": 0.0687, + "min": 8.76, + "max": 9.18, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "73_Conv2d_BatchNorm_Scaling.py": { + "mean": 1.25, + "std": 2.15, + "min": 1.02, + "max": 22.6, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "74_ConvTranspose3d_LeakyReLU_Multiply_LeakyReLU_Max.py": { + "mean": 0.816, + "std": 0.016, + "min": 0.8, + "max": 0.916, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "75_Gemm_GroupNorm_Min_BiasAdd.py": { + "mean": 2.76, + "std": 0.00917, + "min": 2.74, + "max": 2.81, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "76_Gemm_Add_ReLU.py": { + "mean": 2.77, + "std": 0.00986, + "min": 2.76, + "max": 2.82, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "77_ConvTranspose3d_Scale_BatchNorm_GlobalAvgPool.py": { + "mean": 4.92, + "std": 0.0343, + "min": 4.82, + "max": 5.03, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "78_ConvTranspose3d_Max_Max_Sum.py": { + "mean": 47.0, + "std": 0.0278, + "min": 46.9, + "max": 47.1, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "79_Conv3d_Multiply_InstanceNorm_Clamp_Multiply_Max.py": { + "mean": 0.508, + "std": 0.0102, + "min": 0.49, + "max": 0.563, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "80_Gemm_Max_Subtract_GELU.py": { + "mean": 2.73, + "std": 0.0146, + "min": 2.71, + "max": 2.82, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "81_Gemm_Swish_Divide_Clamp_Tanh_Clamp.py": { + "mean": 2.77, + "std": 0.018, + "min": 2.76, + "max": 2.92, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "82_Conv2d_Tanh_Scaling_BiasAdd_Max.py": { + "mean": 6.54, + "std": 0.0194, + "min": 6.52, + "max": 6.68, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "83_Conv3d_GroupNorm_Min_Clamp_Dropout.py": { + "mean": 6.43, + "std": 0.0199, + "min": 6.41, + "max": 6.55, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "84_Gemm_BatchNorm_Scaling_Softmax.py": { + "mean": 2.76, + "std": 0.0121, + "min": 2.73, + "max": 2.8, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "85_Conv2d_GroupNorm_Scale_MaxPool_Clamp.py": { + "mean": 1.4, + "std": 0.0121, + "min": 1.38, + "max": 1.48, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "86_Matmul_Divide_GELU.py": { + "mean": 2.77, + "std": 0.00717, + "min": 2.76, + "max": 2.8, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "87_Conv2d_Subtract_Subtract_Mish.py": { + "mean": 6.98, + "std": 0.33, + "min": 6.91, + "max": 10.3, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "88_Gemm_GroupNorm_Swish_Multiply_Swish.py": { + "mean": 2.72, + "std": 0.0451, + "min": 2.71, + "max": 3.17, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "89_ConvTranspose3d_MaxPool_Softmax_Subtract_Swish_Max.py": { + "mean": 4.76, + "std": 0.0361, + "min": 4.72, + "max": 5.04, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "90_Conv3d_LeakyReLU_Sum_Clamp_GELU.py": { + "mean": 10.0, + "std": 0.122, + "min": 9.96, + "max": 11.2, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "91_ConvTranspose2d_Softmax_BiasAdd_Scaling_Sigmoid.py": { + "mean": 3.81, + "std": 0.111, + "min": 3.77, + "max": 4.9, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "92_Conv2d_GroupNorm_Tanh_HardSwish_ResidualAdd_LogSumExp.py": { + "mean": 3.44, + "std": 0.0195, + "min": 3.42, + "max": 3.58, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "93_ConvTranspose2d_Add_Min_GELU_Multiply.py": { + "mean": 2.54, + "std": 0.178, + "min": 2.48, + "max": 4.3, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "94_Gemm_BiasAdd_Hardtanh_Mish_GroupNorm.py": { + "mean": 2.79, + "std": 0.0192, + "min": 2.77, + "max": 2.94, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "95_Matmul_Add_Swish_Tanh_GELU_Hardtanh.py": { + "mean": 2.76, + "std": 0.0441, + "min": 2.75, + "max": 3.2, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "96_ConvTranspose3d_Multiply_Max_GlobalAvgPool_Clamp.py": { + "mean": 4.6, + "std": 0.0242, + "min": 4.57, + "max": 4.71, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "97_Matmul_BatchNorm_BiasAdd_Divide_Swish.py": { + "mean": 2.75, + "std": 0.0434, + "min": 2.73, + "max": 3.17, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "98_Matmul_AvgPool_GELU_Scale_Max.py": { + "mean": 2.72, + "std": 0.0114, + "min": 2.71, + "max": 2.77, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "99_Matmul_GELU_Softmax.py": { + "mean": 2.78, + "std": 0.0113, + "min": 2.76, + "max": 2.83, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "100_ConvTranspose3d_Clamp_Min_Divide.py": { + "mean": 8.29, + "std": 0.224, + "min": 8.23, + "max": 10.5, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + } + }, + "level3": { + "1_MLP.py": { + "mean": 3.79, + "std": 0.0141, + "min": 3.77, + "max": 3.83, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "2_ShallowWideMLP.py": { + "mean": 11.0, + "std": 0.568, + "min": 10.7, + "max": 12.9, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "3_DeepNarrowMLP.py": { + "mean": 1.72, + "std": 0.00618, + "min": 1.71, + "max": 1.75, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "4_LeNet5.py": { + "mean": 0.769, + "std": 0.0104, + "min": 0.75, + "max": 0.822, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "5_AlexNet.py": { + "mean": 16.7, + "std": 0.0755, + "min": 16.5, + "max": 16.9, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "6_GoogleNetInceptionModule.py": { + "mean": 5.16, + "std": 0.0509, + "min": 5.14, + "max": 5.64, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "7_GoogleNetInceptionV1.py": { + "mean": 2.01, + "std": 0.0709, + "min": 1.97, + "max": 2.59, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "8_ResNetBasicBlock.py": { + "mean": 0.875, + "std": 0.04, + "min": 0.851, + "max": 1.1, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "9_ResNet18.py": { + "mean": 1.47, + "std": 0.0297, + "min": 1.45, + "max": 1.71, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "10_ResNet101.py": { + "mean": 8.02, + "std": 0.0601, + "min": 7.93, + "max": 8.42, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "11_VGG16.py": { + "mean": 2.12, + "std": 0.0126, + "min": 2.1, + "max": 2.16, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "12_VGG19.py": { + "mean": 2.43, + "std": 0.0107, + "min": 2.41, + "max": 2.48, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "13_DenseNet121TransitionLayer.py": { + "mean": 3.15, + "std": 0.874, + "min": 3.06, + "max": 11.8, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "14_DenseNet121DenseBlock.py": { + "mean": 4.62, + "std": 0.0174, + "min": 4.6, + "max": 4.73, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "15_DenseNet121.py": { + "mean": 8.93, + "std": 0.372, + "min": 8.0, + "max": 9.89, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "16_DenseNet201.py": { + "mean": 21.8, + "std": 0.334, + "min": 21.0, + "max": 22.6, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "17_SqueezeNetFireModule.py": { + "mean": 6.24, + "std": 0.0755, + "min": 6.2, + "max": 6.83, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "18_SqueezeNet.py": { + "mean": 12.8, + "std": 0.0246, + "min": 12.8, + "max": 12.9, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "19_MobileNetV1.py": { + "mean": 1.81, + "std": 0.0576, + "min": 1.77, + "max": 2.34, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "20_MobileNetV2.py": { + "mean": 3.2, + "std": 0.0397, + "min": 3.15, + "max": 3.5, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "21_EfficientNetMBConv.py": { + "mean": 3.62, + "std": 0.0123, + "min": 3.61, + "max": 3.71, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "22_EfficientNetB0.py": { + "mean": 3.21, + "std": 0.0773, + "min": 3.14, + "max": 3.81, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "23_EfficientNetB1.py": { + "mean": 2.19, + "std": 0.0314, + "min": 2.13, + "max": 2.32, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "24_EfficientNetB2.py": { + "mean": 1.66, + "std": 0.0512, + "min": 1.6, + "max": 1.93, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "25_ShuffleNetUnit.py": { + "mean": 6.72, + "std": 0.0185, + "min": 6.7, + "max": 6.86, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "26_ShuffleNet.py": { + "mean": 8.34, + "std": 0.0852, + "min": 8.25, + "max": 9.07, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "27_RegNet.py": { + "mean": 1.17, + "std": 0.0177, + "min": 1.16, + "max": 1.27, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "28_VisionTransformer.py": { + "mean": 1.37, + "std": 0.238, + "min": 1.28, + "max": 3.1, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "29_SwinMLP.py": { + "mean": 3.17, + "std": 0.151, + "min": 3.12, + "max": 4.65, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "30_SwinTransformerV2.py": { + "mean": 4.86, + "std": 0.011, + "min": 4.84, + "max": 4.89, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "31_VisionAttention.py": { + "mean": 14.4, + "std": 0.109, + "min": 14.2, + "max": 14.8, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "32_ConvolutionalVisionTransformer.py": { + "mean": 1.45, + "std": 0.0212, + "min": 1.4, + "max": 1.53, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "33_VanillaRNN.py": { + "mean": 6.85, + "std": 0.023, + "min": 6.8, + "max": 6.93, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "34_VanillaRNNHidden.py": { + "mean": 11.2, + "std": 0.276, + "min": 10.8, + "max": 13.1, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "35_LSTM.py": { + "mean": 37.4, + "std": 1.34, + "min": 36.0, + "max": 39.4, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "36_LSTMHn.py": { + "mean": 35.4, + "std": 0.517, + "min": 34.8, + "max": 38.4, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "37_LSTMCn.py": { + "mean": 25.5, + "std": 1.0, + "min": 24.8, + "max": 31.1, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "38_LSTMBidirectional.py": { + "mean": 49.7, + "std": 0.0826, + "min": 49.6, + "max": 50.1, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "39_GRU.py": { + "mean": 41.3, + "std": 0.144, + "min": 40.9, + "max": 41.9, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "40_GRUHidden.py": { + "mean": 49.3, + "std": 1.59, + "min": 48.4, + "max": 59.3, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "41_GRUBidirectional.py": { + "mean": 82.1, + "std": 0.341, + "min": 81.4, + "max": 82.9, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "42_GRUBidirectionalHidden.py": { + "mean": 76.5, + "std": 2.67, + "min": 64.1, + "max": 77.6, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "43_MinGPTCausalAttention.py": { + "mean": 10.4, + "std": 0.33, + "min": 10.2, + "max": 11.3, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "44_MiniGPTBlock.py": { + "mean": 23.8, + "std": 0.62, + "min": 23.4, + "max": 26.6, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "45_UNetSoftmax.py": { + "mean": 5.1, + "std": 0.018, + "min": 5.06, + "max": 5.17, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "46_NetVladWithGhostClusters.py": { + "mean": 1.33, + "std": 1.05, + "min": 1.12, + "max": 11.7, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "47_NetVladNoGhostClusters.py": { + "mean": 0.953, + "std": 0.036, + "min": 0.941, + "max": 1.27, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "48_Mamba2ReturnY.py": { + "mean": 4.65, + "std": 0.0209, + "min": 4.63, + "max": 4.84, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "49_Mamba2ReturnFinalState.py": { + "mean": 1.64, + "std": 2.19, + "min": 1.4, + "max": 23.3, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + }, + "50_ReLUSelfAttention.py": { + "mean": 3.23, + "std": 0.0162, + "min": 3.22, + "max": 3.36, + "num_trials": 100, + "hardware": "NVIDIA H100 80GB HBM3", + "device": "cuda:0" + } + } +} \ No newline at end of file diff --git a/scripts/benchmark_eval_analysis.py b/scripts/benchmark_eval_analysis.py index a2eef53a..ec950b03 100644 --- a/scripts/benchmark_eval_analysis.py +++ b/scripts/benchmark_eval_analysis.py @@ -19,7 +19,15 @@ ``` python3 scripts/benchmark_eval_analysis.py run_name= level= hardware= baseline= ``` -hardware + baseline should correspond to the results/timing/hardware/baseline.json file +hardware + baseline should correspond to the results/timing/hardware/baseline.json file + +Optional path overrides (for external tools like leaderboards): +``` +python3 scripts/benchmark_eval_analysis.py run_name= level= hardware= baseline= \ + baseline_file=/path/to/baseline.json \ + eval_results_dir=/path/to/runs \ + output_file=/path/to/output.json +``` """ @@ -32,6 +40,11 @@ def __init__(self): self.hardware = REQUIRED # hardware to evaluate self.baseline = REQUIRED # baseline to compare against + # Optional path overrides (defaults to standard KernelBench paths) + self.baseline_file = None # Override: direct path to baseline JSON + self.eval_results_dir = None # Override: path to runs directory + self.output_file = None # Write JSON output to file + def __repr__(self): return f"AnalysisConfig({self.to_dict()})" @@ -54,24 +67,36 @@ def patch(eval_results, dataset): return eval_results -def analyze_greedy_eval(run_name, hardware, baseline, level): +def analyze_greedy_eval(run_name, hardware, baseline, level, + baseline_file=None, eval_results_dir=None) -> dict: """ - Analyze the greedy eval results for a run of a particular level + Analyze the greedy eval results for a run of a particular level. + + Returns a dict with all computed metrics. """ dataset = construct_kernelbench_dataset(level) - # load json - eval_file_path = f"runs/{run_name}/eval_results.json" + # Resolve eval results path (use override if provided) + if eval_results_dir: + eval_file_path = os.path.join(eval_results_dir, run_name, "eval_results.json") + pass_at_k_file_path = os.path.join(eval_results_dir, run_name, "pass_at_k_results.json") + else: + eval_file_path = f"runs/{run_name}/eval_results.json" + pass_at_k_file_path = f"runs/{run_name}/pass_at_k_results.json" + assert os.path.exists( eval_file_path ), f"Eval file does not exist at {eval_file_path}" - # Check if pass@k results exist - pass_at_k_file_path = f"runs/{run_name}/pass_at_k_results.json" has_pass_at_k_results = os.path.exists(pass_at_k_file_path) - baseline_file_path = f"results/timing/{hardware}/{baseline}.json" + # Resolve baseline path (use override if provided) + if baseline_file: + baseline_file_path = baseline_file + else: + baseline_file_path = f"results/timing/{hardware}/{baseline}.json" + assert os.path.exists( baseline_file_path ), f"Baseline file does not exist at {baseline_file_path}" @@ -157,7 +182,7 @@ def analyze_greedy_eval(run_name, hardware, baseline, level): # list of speedup thresholds p p_values = [0.0, 0.5, 0.8, 1.0, 1.5, 2.0] - results = [ + fast_p_results = [ [p, fastp(is_correct, baseline_speed, actual_speed, n, p)] for p in p_values ] @@ -169,7 +194,7 @@ def analyze_greedy_eval(run_name, hardware, baseline, level): print("\nFast_p Results:") print( tabulate( - results, headers=["Speedup Threshold (p)", "Fast_p Score"], tablefmt="grid" + fast_p_results, headers=["Speedup Threshold (p)", "Fast_p Score"], tablefmt="grid" ) ) @@ -193,10 +218,49 @@ def analyze_greedy_eval(run_name, hardware, baseline, level): avg_table = [[k, v] for k, v in averages.items()] print(tabulate(avg_table, headers=["Metric", "Value"], tablefmt="grid")) + # Build and return results dict + results = { + "run_name": run_name, + "level": level, + "hardware": hardware, + "total_count": total_count, + "total_eval": total_eval, + "compiled_count": compiled_count, + "correct_count": correct_count, + "compilation_rate": compiled_count / total_count if total_count > 0 else 0.0, + "correctness_rate": correct_count / total_count if total_count > 0 else 0.0, + "geo_mean_speedup": float(gmsr_correct), + "fast_p": {str(p): float(score) for p, score in fast_p_results}, + } + + # Include pass@k if available + if pass_at_k_results: + results["pass_at_k"] = { + "metadata": pass_at_k_results.get("metadata", {}), + "averages": pass_at_k_results.get("averages", {}) + } + + return results + @pydra.main(base=AnalysisConfig) def main(config: AnalysisConfig): - analyze_greedy_eval(config.run_name, config.hardware, config.baseline, config.level) + results = analyze_greedy_eval( + config.run_name, + config.hardware, + config.baseline, + config.level, + baseline_file=config.baseline_file, + eval_results_dir=config.eval_results_dir + ) + + # Write JSON output if requested + if config.output_file: + with open(config.output_file, 'w') as f: + json.dump(results, f, indent=2) + print(f"\nResults written to: {config.output_file}") + + return results if __name__ == "__main__": diff --git a/scripts/eval_from_generations.py b/scripts/eval_from_generations.py index a71c3478..15175787 100644 --- a/scripts/eval_from_generations.py +++ b/scripts/eval_from_generations.py @@ -93,6 +93,9 @@ def __init__(self): # subset of problems to evaluate self.subset = (None, None) # (start_id, end_id), these are the logical index + # specific problem IDs to evaluate (overrides subset if provided) + self.problem_ids = None # e.g., [71, 86, 95] for specific problems + # Evaluation Mode: local (requires GPU), modal (cloud GPU) self.eval_mode = "local" @@ -339,6 +342,10 @@ def evaluate_single_sample( ) return eval_result except Exception as e: + # INNER CATCH: Handles errors during kernel execution + # - CUDA errors (illegal memory access, kernel launch failures) + # - Runtime errors from the custom kernel + # - Any exception from eval_kernel_against_ref() print( f"[WARNING] Last level catch on {sample_id}: Some issue evaluating for kernel: {e} " ) @@ -519,22 +526,43 @@ def batch_eval_modal( results = [] for i, future in enumerate(futures): problem_id, sample_id = curr_work_batch[i] - + if future is None: - results.append((problem_id, sample_id, None)) + # Create a failure result for None futures + fail_result = KernelExecResult( + compiled=False, + correctness=False, + metadata={"error": "Future was None - evaluation did not complete"}, + runtime=-1.0, + runtime_stats={}, + ) + results.append((problem_id, sample_id, fail_result)) else: try: result = future.get() results.append((problem_id, sample_id, result)) except Exception as e: + # OUTER CATCH: Modal infrastructure or remote execution failures + # - GPU attachment failures after retries + # - Network/container issues + # - Import errors in the kernel (can't even start evaluation) + # - Any exception from future.get() error_msg = str(e) # Check if it's a GPU attachment failure that exhausted retries if "GPU not attached" in error_msg or "CUDA is not available" in error_msg: print(f"[ERROR] Modal GPU attachment FAILED after retries for Problem ID: {problem_id}, Sample ID: {sample_id}") - print(f" This is a Modal infrastructure issue. Sample will be skipped.") + print(f" This is a Modal infrastructure issue. Sample will be recorded as failed.") else: print(f"[ERROR] Modal evaluation FAILED for Problem ID: {problem_id}, Sample ID: {sample_id}: {error_msg}") - results.append((problem_id, sample_id, None)) + # Create a failure result instead of None + fail_result = KernelExecResult( + compiled=False, + correctness=False, + metadata={"error": error_msg}, + runtime=-1.0, + runtime_stats={}, + ) + results.append((problem_id, sample_id, fail_result)) end_time = time.time() @@ -543,12 +571,10 @@ def batch_eval_modal( print("-" * 128) print(f"[Eval Result] Problem ID: {problem_id}, Sample ID: {sample_id}") print(result) - - if result is not None: - print(f"Adding Eval Result to file for problem {problem_id} sample {sample_id}") - add_to_eval_results_file( - problem_id, sample_id, result, eval_file_path - ) + print(f"Adding Eval Result to file for problem {problem_id} sample {sample_id}") + add_to_eval_results_file( + problem_id, sample_id, result, eval_file_path + ) print("-" * 128) print(f"[Modal Batch] Evaluation took {end_time - start_time:.2f} seconds") @@ -626,10 +652,19 @@ def batch_eval( results.append((problem_id, sample_id, result)) except mp.TimeoutError: + # OUTER CATCH: Evaluation exceeded timeout (config.timeout seconds) + # - Kernel hangs, infinite loops, very slow compilation print( f"[WARNING] Evaluation TIMED OUT for Problem ID: {problem_id}, Sample ID: {sample_id}" ) - results.append((problem_id, sample_id, None)) + fail_result = KernelExecResult( + compiled=False, + correctness=False, + metadata={"error": "Evaluation timed out"}, + runtime=-1.0, + runtime_stats={}, + ) + results.append((problem_id, sample_id, fail_result)) remove_cache_dir( config.kernel_eval_build_dir, @@ -638,10 +673,21 @@ def batch_eval( sample_id, ) except Exception as e: + # OUTER CATCH: Multiprocessing-level failures + # - Process crashes, pickling errors + # - Errors that escape the inner handler + error_msg = str(e) print( - f"[ERROR] Evaluation FAILED for Problem ID: {problem_id}, Sample ID: {sample_id}: {str(e)}" + f"[ERROR] Evaluation FAILED for Problem ID: {problem_id}, Sample ID: {sample_id}: {error_msg}" ) - results.append((problem_id, sample_id, None)) + fail_result = KernelExecResult( + compiled=False, + correctness=False, + metadata={"error": error_msg}, + runtime=-1.0, + runtime_stats={}, + ) + results.append((problem_id, sample_id, fail_result)) remove_cache_dir( config.kernel_eval_build_dir, config.run_name, @@ -660,14 +706,12 @@ def batch_eval( print(result) # add all the batch results here to avoid file race condition - # add to eval result if valid result - if result is not None: - print( - f"Adding Eval Result to file for problem {problem_id} sample {sample_id}" - ) - add_to_eval_results_file( - problem_id, sample_id, result, eval_file_path - ) + print( + f"Adding Eval Result to file for problem {problem_id} sample {sample_id}" + ) + add_to_eval_results_file( + problem_id, sample_id, result, eval_file_path + ) print("-" * 128) print( @@ -717,12 +761,13 @@ def add_to_eval_results_file( } ) - # Write updated results back to file + # Write updated results back to file (sorted by numeric key) if not os.path.exists(eval_file_path): os.makedirs(os.path.dirname(eval_file_path), exist_ok=True) + sorted_results = dict(sorted(eval_results.items(), key=lambda x: int(x[0]))) with open(eval_file_path, "w") as f: - json.dump(eval_results, f, indent=4) + json.dump(sorted_results, f, indent=4) def single_eval_example( @@ -772,16 +817,24 @@ def main(config: EvalConfig): num_problems_in_level = len(curr_level_dataset) - if config.subset == (None, None): - problem_id_range = range(1, num_problems_in_level) + # Determine which problem IDs to evaluate + # you can either specify a list of problem IDs (prioritize) or a subset range + # NOTE: later once the dataset PR is in we will link the representative subset as a built-in preset too + if config.problem_ids is not None: + # Use specific problem IDs if provided + problem_id_list = config.problem_ids + for pid in problem_id_list: + assert 1 <= pid <= num_problems_in_level, f"Problem ID {pid} out of range for Level {config.level}" + elif config.subset == (None, None): + problem_id_list = list(range(1, num_problems_in_level + 1)) else: assert ( config.subset[0] >= 1 and config.subset[1] <= num_problems_in_level ), f"Subset range {config.subset} out of range for Level {config.level}" - problem_id_range = range(config.subset[0], config.subset[1]) + problem_id_list = list(range(config.subset[0], config.subset[1] + 1)) print( - f"Evaluating {config.num_samples_per_problem} sample(s) each for level {config.level} problems: {problem_id_range}" + f"Evaluating {config.num_samples_per_problem} sample(s) each for level {config.level} problems: {problem_id_list}" ) run_dir = os.path.join(config.runs_dir, config.run_name) @@ -791,16 +844,14 @@ def main(config: EvalConfig): # single_eval_example(config, curr_level_dataset, run_dir, eval_file_path) total_work = [] - for problem_id in range( - problem_id_range.start, problem_id_range.stop + 1 - ): # end index is inclusive + for problem_id in problem_id_list: for sample_id in range(config.num_samples_per_problem): if not check_if_eval_exists_local(problem_id, sample_id, eval_file_path): total_work.append((problem_id, sample_id)) print( f"Start evaluation on {len(total_work)} unevaluated samples" - f" in range: {problem_id_range}" + f" for problems: {problem_id_list}" ) # Build Cache on CPU as that is faster (only for local mode) if config.build_cache and config.eval_mode == "local": diff --git a/scripts/generate_baseline_time_modal.py b/scripts/generate_baseline_time_modal.py index 7e6217a2..37bda8ae 100644 --- a/scripts/generate_baseline_time_modal.py +++ b/scripts/generate_baseline_time_modal.py @@ -2,17 +2,18 @@ import numpy as np from kernelbench.eval import ( load_original_model_and_inputs, - time_execution_with_cuda_event, - get_timing_stats, set_seed, fetch_ref_arch_from_problem_id, ) +from kernelbench.timing import ( + time_execution_with_cuda_event, + get_timing_stats, +) from kernelbench.dataset import construct_problem_dataset_from_problem_dir from kernelbench.utils import read_file import os import json from tqdm import tqdm -import multiprocessing as mp import time import einops import pydra @@ -62,8 +63,8 @@ def __init__(self): # Hardware name for saving results self.hardware_name = REQUIRED - # Batch size for parallel processing - self.batch_size = 10 + # Number of parallel GPU containers to use + self.num_gpu_devices = 8 # Timeout for each batch in seconds self.timeout = 1800 @@ -76,9 +77,6 @@ def __init__(self): import modal app = modal.App("generate_baseline_modal") gpu_arch_mapping = {"L40S": ["Ada"], "H100": ["Hopper"], "A100": ["Ampere"], "A100-80GB": ["Ampere"], "L4": ["Ada"], "T4": ["Turing"], "A10G": ["Ampere"]} -batch_size = 10 -gpu = "L40S" -timeout = 1800 cuda_version = "12.8.0" # should be no greater than host CUDA version flavor = "devel" # includes full CUDA toolkit operating_sys = "ubuntu22.04" @@ -202,7 +200,7 @@ def measure_program_time( model = model.cuda(device=device) torch.cuda.synchronize(device=device) elapsed_times = time_execution_with_cuda_event( - model, *inputs, num_trials=num_trials, verbose=verbose, device=device + model, inputs, num_trials=num_trials, verbose=verbose, device=device ) runtime_stats = get_timing_stats(elapsed_times, device=device) @@ -213,19 +211,14 @@ def measure_program_time( except Exception as e: print(f"[Eval] Error in Measuring Performance: {e}") -def measure_program_time_wrapper(gpu_type, *args, **kwargs): - with app.run(): - return EvalFunc.with_options(gpu=gpu_type)().measure_program_time.remote(*args, **kwargs) - def record_baseline_times(config: BaselineConfig, use_torch_compile: bool = False, torch_compile_backend: str="inductor", torch_compile_options: str="default", file_name: str="baseline_time.json"): """ - Generate baseline time for KernelBench, - configure profiler options for PyTorch - save to specified file + Generate baseline time for KernelBench using Modal's native parallelization. + Spawns multiple GPU containers in parallel for faster processing. """ json_results = [] @@ -235,56 +228,39 @@ def record_baseline_times(config: BaselineConfig, num_problems = len(dataset) total_work = [(i, *fetch_ref_arch_from_dataset(dataset, i)) for i in list(range(1, num_problems + 1))] - with tqdm(total=len(total_work), desc="Processing batches") as pbar: - while len(total_work) > 0: - curr_work_batch = total_work[:config.batch_size] - total_work = total_work[config.batch_size:] # pop the first batch_size elements - - with mp.Pool() as pool: - - work_args = [ - ( - config.gpu, - ref_arch_name, - ref_arch_src, - config.num_trials, - use_torch_compile, - torch_compile_backend, - torch_compile_options, - torch.device(f"cuda:0"), - False # do not print - ) - for i, (p_id, ref_arch_path, ref_arch_name, ref_arch_src) in enumerate(curr_work_batch) - ] - - start_time = time.time() + batch_size = config.num_gpu_devices + print(f"[Modal] Processing {len(total_work)} problems in parallel batches of {batch_size}") - async_results = [] - for work_arg in work_args: - async_results.append( - pool.apply_async(measure_program_time_wrapper, work_arg) + with app.run(): + evaluator_cls = EvalFunc.with_options(gpu=config.gpu) if config.gpu != "L40S" else EvalFunc + + with tqdm(total=len(total_work), desc="Processing") as pbar: + while len(total_work) > 0: + curr_work_batch = total_work[:batch_size] + total_work = total_work[batch_size:] + + # Spawn all tasks in parallel using Modal + futures = [] + for p_id, ref_arch_path, ref_arch_name, ref_arch_src in curr_work_batch: + future = evaluator_cls().measure_program_time.spawn( + ref_arch_name=ref_arch_name, + ref_arch_src=ref_arch_src, + num_trials=config.num_trials, + use_torch_compile=use_torch_compile, + torch_compile_backend=torch_compile_backend, + torch_compile_options=torch_compile_options, + device=torch.device("cuda:0"), + verbose=False, ) + futures.append((p_id, ref_arch_name, future)) - batch_timeout = config.timeout - for i, async_result in enumerate(async_results): - problem_id, _, ref_arch_name, _ = curr_work_batch[i] - + # Collect results + for p_id, ref_arch_name, future in futures: try: - elapsed_time = time.time() - start_time - remaining_time = max(0, batch_timeout - elapsed_time) - result = async_result.get(timeout=remaining_time) + result = future.get(timeout=config.timeout) json_results.append((f"level{level}", ref_arch_name, result)) - - except mp.TimeoutError: - print( - f"[WARNING] Evaluation TIMED OUT for Problem ID: {problem_id}" - ) - json_results.append((f"level{level}", ref_arch_name, None)) - except Exception as e: - print( - f"[ERROR] Evaluation FAILED for Problem ID: {problem_id}: {str(e)}" - ) + print(f"[ERROR] Problem {p_id} ({ref_arch_name}): {str(e)}") json_results.append((f"level{level}", ref_arch_name, None)) pbar.update(len(curr_work_batch)) @@ -301,7 +277,7 @@ def main(config: BaselineConfig): """ print(f"Generating baseline time for level {config.level} on {config.gpu} Modal") print(f"Hardware name: {config.hardware_name}") - print(f"Batch size: {config.batch_size}, Timeout: {config.timeout}s, Num trials: {config.num_trials}") + print(f"Parallel GPUs: {config.num_gpu_devices}, Timeout: {config.timeout}s, Num trials: {config.num_trials}") # 1. Record Torch Eager print("\n[1/2] Recording baseline times with PyTorch Eager execution...") From f28d9c41004c620d74477deaf754f0fffc137fce Mon Sep 17 00:00:00 2001 From: Taras Sereda Date: Fri, 2 Jan 2026 10:12:29 -0800 Subject: [PATCH 15/24] level 1-97 problem update: remove device and dtype from sdpa tensors (#69) * remote device from sdpa tensors * dtype as well --- KernelBench/level1/97_ScaledDotProductAttention.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/KernelBench/level1/97_ScaledDotProductAttention.py b/KernelBench/level1/97_ScaledDotProductAttention.py index feff1490..ba4bd02b 100644 --- a/KernelBench/level1/97_ScaledDotProductAttention.py +++ b/KernelBench/level1/97_ScaledDotProductAttention.py @@ -15,9 +15,9 @@ def forward(self, Q: torch.Tensor, K: torch.Tensor, V: torch.Tensor) -> torch.Te embedding_dimension = 1024 def get_inputs(): - Q = torch.rand(batch_size, num_heads, sequence_length, embedding_dimension, device='cuda', dtype=torch.float16) - K = torch.rand(batch_size, num_heads, sequence_length, embedding_dimension, device='cuda', dtype=torch.float16) - V = torch.rand(batch_size, num_heads, sequence_length, embedding_dimension, device='cuda', dtype=torch.float16) + Q = torch.rand(batch_size, num_heads, sequence_length, embedding_dimension) + K = torch.rand(batch_size, num_heads, sequence_length, embedding_dimension) + V = torch.rand(batch_size, num_heads, sequence_length, embedding_dimension) return [Q, K, V] def get_init_inputs(): From 056a8d05d5ca816416c6c24c6a55380f2388e0a1 Mon Sep 17 00:00:00 2001 From: Willy Chan <106504264+Willy-Chan@users.noreply.github.com> Date: Fri, 2 Jan 2026 21:03:55 -0500 Subject: [PATCH 16/24] Simplified Thunderkittens Port (#107) * run and check works with new TK format * generate_and_eval_single_sample working with TK backend * eval from generations changes * generate_samples working * generate_single_examples adapted * updated git cloning of TK repo: using the tk-v2 branch * removed unnecessary pip installs now that uv works * fixed bug to prompts.toml pointing to correct file * README explaining how to run with TK locally * nit typo fix * current commits only support bf16, clarification to README --- README.md | 19 ++- scripts/eval_from_generations.py | 16 ++- scripts/generate_and_eval_single_sample.py | 5 +- .../generate_and_eval_single_sample_modal.py | 14 +- scripts/generate_samples.py | 4 +- scripts/run_and_check.py | 6 +- .../prompts/model_ex_add_thunderkittens.py | 22 ++++ .../model_new_ex_add_thunderkittens.py | 122 ++++++++++++++++++ src/kernelbench/prompts/prompts.toml | 5 + 9 files changed, 206 insertions(+), 7 deletions(-) create mode 100644 src/kernelbench/prompts/model_ex_add_thunderkittens.py create mode 100644 src/kernelbench/prompts/model_new_ex_add_thunderkittens.py diff --git a/README.md b/README.md index 1f83bf1c..da701a16 100644 --- a/README.md +++ b/README.md @@ -115,10 +115,27 @@ uv run python scripts/generate_and_eval_single_sample.py dataset_src=huggingface **What you might need to modify** * **`gpu_arch`** - Depend on your GPU, you might need to adjust the `gpu_arch` argument to reflect your hardware. * **`precision`** - You can specify the precision of tensor by `precision=fp32`. Currently all of our reported results are `fp32` but we added support for `fp16` & `bf16`. -* **`backend`** - We are also supporting other GPU programming languages beyond `cuda`. Simply specify `backend=triton`. For now we support DSLs: `cuda`, `triton`, `cute`, `tilelang`. +* **`backend`** - We are also supporting other GPU programming languages beyond `cuda`. Simply specify `backend=triton`. For now we support DSLs: `cuda`, `triton`, `cute`, `tilelang`, `thunderkittens`. Check the config fields for comprehensive set of options. Note we provide the model with a one-shot example by default along with the minimum set of info; you can check out other prompt settings or construct your own in `src/prompt_constructor_toml.py`. +### Running Thunderkittens Locally +If you plan on using `scripts/generate_and_eval_single_sample.py` using `backend=thunderkittens`, make sure to git clone the ThunderKittens repo and you set the following environment variable to point to your local ThunderKittens directory: + +```bash +export THUNDERKITTENS_ROOT=/Users/willychan/Desktop/projects/KernelBench/ThunderKittens +``` + +As seen in `src/kernelbench/prompts/model_new_ex_add_thunderkittens.py`, the generated kernels should have the following line: + +```bash +tk_root = os.environ.get("THUNDERKITTENS_ROOT", "/root/ThunderKittens") +``` + +This allows the kernel to include the right TK primitives. + +*NOTE*: Right now, all generated ThunderKittens kernels are required to be in datatype format BF16. FP16 support is TBD. + ### Run on all problems ```bash diff --git a/scripts/eval_from_generations.py b/scripts/eval_from_generations.py index 15175787..9fd8d745 100644 --- a/scripts/eval_from_generations.py +++ b/scripts/eval_from_generations.py @@ -70,8 +70,13 @@ "g++-10", "clang" ) + .uv_sync(uv_project_dir=REPO_TOP_DIR) - .env({"PYTHONPATH": "/root/src"}) + .run_commands("git clone -b tk-v2 https://github.com/HazyResearch/ThunderKittens.git /root/ThunderKittens") + .env({ + "THUNDERKITTENS_ROOT": "/root/ThunderKittens", + "PYTHONPATH": "/root/src:/root" + }) .add_local_dir(SRC_DIR, remote_path="/root/src") .add_local_dir(KERNELBENCH_DIR, remote_path="/root/KernelBench") # must be last ) @@ -792,6 +797,15 @@ def main(config: EvalConfig): """ print(f"Starting Batch Eval with config: {config}") + # Handle backend-specific settings + backend = config.backend.lower() + + # thunderkittens requires bf16 and H100 GPU + if backend == "thunderkittens": + config.precision = "bf16" + config.gpu = "H100" + print(f"[ThunderKittens] Auto-configured: precision=bf16, gpu=H100") + # Check if CUDA is available (only for local mode) if config.eval_mode == "local": if not torch.cuda.is_available(): diff --git a/scripts/generate_and_eval_single_sample.py b/scripts/generate_and_eval_single_sample.py index 082a0e93..c42ea66a 100644 --- a/scripts/generate_and_eval_single_sample.py +++ b/scripts/generate_and_eval_single_sample.py @@ -200,7 +200,7 @@ def main(config: EvalConfig): include_hardware = include_hardware.lower() in ["true", "1", "yes"] config.include_hardware_info = include_hardware - supported_backends = {"cuda", "triton", "tilelang", "cute"} + supported_backends = {"cuda", "triton", "tilelang", "cute", "thunderkittens"} backend = config.backend.lower() if backend not in supported_backends: raise ValueError( @@ -210,6 +210,9 @@ def main(config: EvalConfig): if backend == "tilelang": config.precision = "fp16" # tilelang only operates with fp16 config.hardware_gpu_name = config.hardware_gpu_name or getattr(config, "gpu", None) + + if backend == "thunderkittens": + config.precision = "bf16" if not custom_prompt_key: if prompt_option not in valid_prompt_options: diff --git a/scripts/generate_and_eval_single_sample_modal.py b/scripts/generate_and_eval_single_sample_modal.py index 6b249248..d8dae68f 100644 --- a/scripts/generate_and_eval_single_sample_modal.py +++ b/scripts/generate_and_eval_single_sample_modal.py @@ -103,8 +103,13 @@ def __repr__(self): "g++-10", "clang" # note i skip a step ) + .uv_sync(uv_project_dir=REPO_TOP_DIR, extras=["gpu"]) - .env({"PYTHONPATH": "/root/src"}) + .run_commands("git clone -b tk-v2 https://github.com/HazyResearch/ThunderKittens.git /root/ThunderKittens") + .env({ + "THUNDERKITTENS_ROOT": "/root/ThunderKittens", + "PYTHONPATH": "/root:/root/src" + }) .add_local_dir(SRC_DIR, remote_path="/root/src") # must be last ) @@ -218,7 +223,7 @@ def main(config: EvalConfig): include_hardware = include_hardware.lower() in ["true", "1", "yes"] config.include_hardware_info = include_hardware - supported_backends = {"cuda", "triton", "tilelang", "cute"} + supported_backends = {"cuda", "triton", "tilelang", "cute", "thunderkittens"} backend = config.backend.lower() if backend not in supported_backends: raise ValueError( @@ -229,6 +234,11 @@ def main(config: EvalConfig): if backend == "tilelang": config.precision = "fp16" config.hardware_gpu_name = config.hardware_gpu_name or getattr(config, "gpu", None) + + # thunderkittens can use bf16 or fp16 by default, also set default GPU to H100 + if backend == "thunderkittens": + config.precision = "bf16" + config.gpu = "H100" if not custom_prompt_key: if prompt_option not in valid_prompt_options: diff --git a/scripts/generate_samples.py b/scripts/generate_samples.py index eb65a210..312a9545 100644 --- a/scripts/generate_samples.py +++ b/scripts/generate_samples.py @@ -239,7 +239,7 @@ def main(config: GenerationConfig): include_hardware = include_hardware.lower() in ["true", "1", "yes"] config.include_hardware_info = include_hardware - supported_backends = {"cuda", "triton", "cute", "tilelang"} + supported_backends = {"cuda", "triton", "cute", "tilelang", "thunderkittens"} backend = config.backend.lower() if backend not in supported_backends: raise ValueError( @@ -248,6 +248,8 @@ def main(config: GenerationConfig): config.backend = backend if backend == "tilelang": config.precision = "fp16" + if backend == "thunderkittens": + config.precision = "bf16" config.prompt_option = str(config.prompt_option).lower() valid_prompt_options = {"zero_shot", "one_shot", "few_shot"} diff --git a/scripts/run_and_check.py b/scripts/run_and_check.py index 0bcd8e37..37ab9732 100644 --- a/scripts/run_and_check.py +++ b/scripts/run_and_check.py @@ -39,7 +39,11 @@ modal.Image.from_registry(f"nvidia/cuda:{tag}", add_python="3.10") .apt_install("git", "gcc-10", "g++-10", "clang") .uv_sync(uv_project_dir=REPO_TOP_PATH) - .env({"PYTHONPATH": "/root/src:/root/scripts"}) + .run_commands("git clone -b tk-v2 https://github.com/HazyResearch/ThunderKittens.git /root/ThunderKittens") + .env({ + "THUNDERKITTENS_ROOT": "/root/ThunderKittens", + "PYTHONPATH": "/root:/root/src:/root/scripts" + }) .add_local_dir(SRC_DIR, remote_path="/root/src") .add_local_dir(SCRIPTS_DIR, remote_path="/root/scripts") .add_local_dir(KERNELBENCH_DIR, remote_path="/root/KernelBench") # must be last diff --git a/src/kernelbench/prompts/model_ex_add_thunderkittens.py b/src/kernelbench/prompts/model_ex_add_thunderkittens.py new file mode 100644 index 00000000..8575537b --- /dev/null +++ b/src/kernelbench/prompts/model_ex_add_thunderkittens.py @@ -0,0 +1,22 @@ +import torch +import torch.nn as nn + + +class Model(nn.Module): + def __init__(self) -> None: + super().__init__() + + def forward(self, a, b): + return a + b + + +def get_inputs(): + # Use shapes compatible with ThunderKittens 16x16 tiles, bf16 dtype + a = torch.randn(128, 128, dtype=torch.bfloat16).cuda() + b = torch.randn(128, 128, dtype=torch.bfloat16).cuda() + return [a, b] + + +def get_init_inputs(): + return [] + diff --git a/src/kernelbench/prompts/model_new_ex_add_thunderkittens.py b/src/kernelbench/prompts/model_new_ex_add_thunderkittens.py new file mode 100644 index 00000000..33cc3ef9 --- /dev/null +++ b/src/kernelbench/prompts/model_new_ex_add_thunderkittens.py @@ -0,0 +1,122 @@ +import os +import torch +import torch.nn as nn +from torch.utils.cpp_extension import load_inline + +tk_root = os.environ.get("THUNDERKITTENS_ROOT", "/root/ThunderKittens") +tk_include_path = os.path.join(tk_root, "include") +tk_prototype_path = os.path.join(tk_root, "prototype") + +extra_include_paths = [tk_root, tk_include_path] +if os.path.isdir(tk_prototype_path): + extra_include_paths.append(tk_prototype_path) + +thunderkittens_add_source = """ +#include "kittens.cuh" +#include + +using namespace kittens; + +constexpr int BLOCK_SIZE = 16; + +#define NUM_WORKERS (1) +#define NUM_THREADS (NUM_WORKERS * kittens::WARP_THREADS) + +struct add_globals { + using sub_tile = st_bf; + using tile_gl = gl; + tile_gl A; + tile_gl B; + tile_gl C; +}; + +__global__ void add_tk(const __grid_constant__ add_globals g) { + extern __shared__ alignment_dummy __shm[]; + shared_allocator al((int*)&__shm[0]); + st_bf &As = al.allocate>(); + st_bf &Bs = al.allocate>(); + rt_bf A_reg; + rt_bf B_reg; + rt_bf C_reg; + int col = blockIdx.x; + int row = blockIdx.y; + // Load A and B tiles from global to shared + kittens::warp::load(As, g.A, {0, 0, row, col}); + kittens::warp::load(Bs, g.B, {0, 0, row, col}); + __syncthreads(); + // Load from shared to register + kittens::warp::load(A_reg, As); + kittens::warp::load(B_reg, Bs); + __syncthreads(); + // Element-wise add: C = A + B + kittens::warp::add(C_reg, A_reg, B_reg); + __syncthreads(); + // Store result back to global + kittens::warp::store(g.C, C_reg, {0, 0, row, col}); +} + +torch::Tensor thunderkittens_add_cuda(torch::Tensor A, torch::Tensor B) { + TORCH_CHECK(A.is_cuda(), "A must be a CUDA tensor"); + TORCH_CHECK(B.is_cuda(), "B must be a CUDA tensor"); + TORCH_CHECK(A.dtype() == torch::kBFloat16, "A must be bfloat16"); + TORCH_CHECK(B.dtype() == torch::kBFloat16, "B must be bfloat16"); + + int M = A.size(0); + int N = A.size(1); + + auto C = torch::empty_like(A); + + using tile_gl = add_globals::tile_gl; + tile_gl a_arg{(bf16*)A.data_ptr(), nullptr, nullptr, (size_t)M, (size_t)N}; + tile_gl b_arg{(bf16*)B.data_ptr(), nullptr, nullptr, (size_t)M, (size_t)N}; + tile_gl c_arg{(bf16*)C.data_ptr(), nullptr, nullptr, (size_t)M, (size_t)N}; + add_globals g{a_arg, b_arg, c_arg}; + + dim3 blocks((N + BLOCK_SIZE - 1) / BLOCK_SIZE, (M + BLOCK_SIZE - 1) / BLOCK_SIZE); + unsigned long mem_size = 50480; + cudaFuncSetAttribute(add_tk, cudaFuncAttributeMaxDynamicSharedMemorySize, mem_size); + add_tk<<>>(g); + + return C; +} +""" + +thunderkittens_add_cpp_source = """ +torch::Tensor thunderkittens_add_cuda(torch::Tensor A, torch::Tensor B); +""" + +thunderkittens_add = load_inline( + name="thunderkittens_add", + cpp_sources=thunderkittens_add_cpp_source, + cuda_sources=thunderkittens_add_source, + functions=["thunderkittens_add_cuda"], + verbose=True, + extra_include_paths=extra_include_paths, + extra_cflags=["-std=c++20", "-O3", "-DNDEBUG"], + extra_ldflags=["-lcuda"], + extra_cuda_cflags=[ + "-std=c++20", + "-O3", + "-DNDEBUG", + "-arch=sm_90a", + "--expt-relaxed-constexpr", + "--expt-extended-lambda", + "-DKITTENS_HOPPER", + "-DKITTENS_BLACKWELL", + "-diag-suppress=20012", + "-Xcompiler", "-fPIC", + "-U__CUDA_NO_HALF_OPERATORS__", + "-U__CUDA_NO_HALF_CONVERSIONS__", + "-U__CUDA_NO_BFLOAT16_CONVERSIONS__", + "-U__CUDA_NO_HALF2_OPERATORS__", + ], +) + + +class ModelNew(nn.Module): + def __init__(self) -> None: + super().__init__() + self.thunderkittens_add = thunderkittens_add + + def forward(self, a, b): + return self.thunderkittens_add.thunderkittens_add_cuda(a, b) diff --git a/src/kernelbench/prompts/prompts.toml b/src/kernelbench/prompts/prompts.toml index acd5f678..2768aa11 100644 --- a/src/kernelbench/prompts/prompts.toml +++ b/src/kernelbench/prompts/prompts.toml @@ -49,6 +49,11 @@ backend_display = "TileLang kernels" one_shot_new_arch = "src/kernelbench/prompts/model_new_ex_add_tilelang.py" # No few_shot_examples - will use one-shot when few_shot option is selected +[backends.thunderkittens] +backend_display = "ThunderKittens kernels" +one_shot_new_arch = "src/kernelbench/prompts/model_new_ex_add_thunderkittens.py" +# No few_shot_examples - will use one-shot when few_shot option is selected + # ------------------------------------------------------------------------- # Precision: Precision-specific configuration # ------------------------------------------------------------------------- From e459ef2a77bbb8ce8db923203fd00c525e74858e Mon Sep 17 00:00:00 2001 From: Simon Zirui Guo Date: Tue, 6 Jan 2026 00:19:36 -0500 Subject: [PATCH 17/24] Static Kernel Code Checker (#110) * start code checker to avoid reward hacking * prelim thunderkittens code check * optional producer-consumer semantics, setup for compilation check * proposed rejection behavior * an initial modularized version, needs to simplify and cleaning * clearer organization for static reward hack checking * Added more static checks ethan wrote (from deep reinforce blog) and dsl tests Co-authored-by: Simon Guo Co-authored-by: Ethan * add integration paths and simplify test cases, (could add more adverserial ones) * gate behind a flag for now as a start for the checker system * precision downgrades * precision downgrade check and test --------- Co-authored-by: Willy-Chan Co-authored-by: Simon Guo Co-authored-by: Ethan Co-authored-by: ethanboneh --- EVAL.md | 3 + README.md | 18 +- scripts/generate_and_eval_single_sample.py | 15 + .../generate_and_eval_single_sample_modal.py | 15 + scripts/generate_samples.py | 16 + scripts/run_and_check.py | 15 + src/kernelbench/kernel_static_checker.py | 659 ++++++++++++++++++ src/kernelbench/unit_tests/test_precision.py | 395 +++++++++++ .../unit_tests/test_static_checker.py | 166 +++++ .../unit_tests/test_validate_kernel_static.py | 423 +++++++++++ 10 files changed, 1709 insertions(+), 16 deletions(-) create mode 100644 src/kernelbench/kernel_static_checker.py create mode 100644 src/kernelbench/unit_tests/test_precision.py create mode 100644 src/kernelbench/unit_tests/test_static_checker.py create mode 100644 src/kernelbench/unit_tests/test_validate_kernel_static.py diff --git a/EVAL.md b/EVAL.md index c6f70fb0..b9880560 100644 --- a/EVAL.md +++ b/EVAL.md @@ -36,6 +36,9 @@ We have (and continue to) implement various approaches to conduct kernel timing Check out `timing.py` to see available timing methods and `src/unit_tests/test_eval_timing.py` to test out various timing methods (including leveraging `cuda_event` marker, Triton `do_bench`, `host_time` E2E time). @palic and team is working on a blogpost explaining the different tradeoffs soon. +### Checkers +There are potentially many ways model might reward hack and we would like to catch the known ways through checkers [experimental and WIP]. We start with `kernel_static_checker.py`, which is a regex-based checker on the genenrated code against set of rules. We plan to add AST-based, LM-as-a-judge, and more runtime checks in the future. We welcome suggestions and contributions here. + ### Unit Tests with Adversarial Examples We've included some unit tests for the eval script in `src/unit_tests/test_eval_adversarial.py`. These tests run adversarial kernels (see `src/unit_tests/test_kernels/`) that contain examples of reward hacking that we've seen from LLMs and ensures that the eval script catches them, either by failing their correctness checks or flagging them for excessive speedups. Examples include: - Reusing computations cached during the PyTorch reference diff --git a/README.md b/README.md index da701a16..3686574a 100644 --- a/README.md +++ b/README.md @@ -117,24 +117,10 @@ uv run python scripts/generate_and_eval_single_sample.py dataset_src=huggingface * **`precision`** - You can specify the precision of tensor by `precision=fp32`. Currently all of our reported results are `fp32` but we added support for `fp16` & `bf16`. * **`backend`** - We are also supporting other GPU programming languages beyond `cuda`. Simply specify `backend=triton`. For now we support DSLs: `cuda`, `triton`, `cute`, `tilelang`, `thunderkittens`. -Check the config fields for comprehensive set of options. Note we provide the model with a one-shot example by default along with the minimum set of info; you can check out other prompt settings or construct your own in `src/prompt_constructor_toml.py`. - -### Running Thunderkittens Locally -If you plan on using `scripts/generate_and_eval_single_sample.py` using `backend=thunderkittens`, make sure to git clone the ThunderKittens repo and you set the following environment variable to point to your local ThunderKittens directory: - -```bash -export THUNDERKITTENS_ROOT=/Users/willychan/Desktop/projects/KernelBench/ThunderKittens -``` -As seen in `src/kernelbench/prompts/model_new_ex_add_thunderkittens.py`, the generated kernels should have the following line: +Note on setting up ThunderKittens (TK) locally: to use `backend=thunderkittens`, you need to git clone the ThunderKittens repo and set the following environment variable to point to your local ThunderKittens directory, `export THUNDERKITTENS_ROOT=`, and all ThunderKitten programs as shown in the [example](src/kernelbench/prompts/model_new_ex_add_thunderkittens.py), should contain `tk_root = os.environ.get("THUNDERKITTENS_ROOT", "/root/ThunderKittens")`, which enable the kernel to include the right TK primitives. In addition, we only support BF16 for TK right now. -```bash -tk_root = os.environ.get("THUNDERKITTENS_ROOT", "/root/ThunderKittens") -``` - -This allows the kernel to include the right TK primitives. - -*NOTE*: Right now, all generated ThunderKittens kernels are required to be in datatype format BF16. FP16 support is TBD. +Check the config fields for comprehensive set of options. Note we provide the model with a one-shot example by default along with the minimum set of info; you can check out other prompt settings or construct your own in `src/prompt_constructor_toml.py`. ### Run on all problems diff --git a/scripts/generate_and_eval_single_sample.py b/scripts/generate_and_eval_single_sample.py index c42ea66a..0b571792 100644 --- a/scripts/generate_and_eval_single_sample.py +++ b/scripts/generate_and_eval_single_sample.py @@ -83,6 +83,8 @@ def __init__(self): self.hardware_gpu_name = None self.custom_prompt_key = None + self.check_kernel = True # [experimental] optional static checker catching potential hacking patterns + def verbose_logging(self): self.log = True self.log_prompt = True @@ -260,6 +262,19 @@ def main(config: EvalConfig): custom_kernel is not None ), f"Custom {config.backend} kernel code generation failed" + # Optional: static code checker for kernel code using regex matching + # NOTE: by no means is this checker complete, but it could help catch some potential hacks + if config.check_kernel: + from kernelbench.kernel_static_checker import validate_kernel_static + static_check_status, errors, warnings = validate_kernel_static( + custom_kernel, + backend=config.backend, + precision=config.precision, + ) + assert static_check_status, f"Static check failed for level {config.level} problem {config.problem_id}. Errors: {errors}. Warnings: {warnings}" + if warnings: + print(f"Static check warnings for level {config.level} problem {config.problem_id}: {warnings}") + # this should be optional if config.log: with open(os.path.join(config.logdir, f"generated_kernel_level_{config.level}_problem_{config.problem_id}.py"), "w") as f: diff --git a/scripts/generate_and_eval_single_sample_modal.py b/scripts/generate_and_eval_single_sample_modal.py index d8dae68f..2a8e6aba 100644 --- a/scripts/generate_and_eval_single_sample_modal.py +++ b/scripts/generate_and_eval_single_sample_modal.py @@ -80,6 +80,8 @@ def __init__(self): self.hardware_gpu_name = None self.custom_prompt_key = None + self.check_kernel = True # [experimental] optional static checker catching potential hacking patterns + def verbose_logging(self): self.log = True self.log_prompt = True @@ -283,6 +285,19 @@ def main(config: EvalConfig): # check LLM is able to generate custom kernel code assert custom_kernel is not None, f"Custom {config.backend} kernel code generation failed" + # Optional: static code checker for kernel code using regex matching + # NOTE: by no means is this checker complete, but it could help catch some potential hacks + if config.check_kernel: + from kernelbench.kernel_static_checker import validate_kernel_static + static_check_status, errors, warnings = validate_kernel_static( + custom_kernel, + backend=config.backend, + precision=config.precision, + ) + assert static_check_status, f"Static check failed for level {config.level} problem {config.problem_id}. Errors: {errors}. Warnings: {warnings}" + if warnings: + print(f"Static check warnings for level {config.level} problem {config.problem_id}: {warnings}") + # this should be optional if config.log: with open(os.path.join(config.logdir, f"generated_kernel_level_{config.level}_problem_{config.problem_id}.py"), "w") as f: diff --git a/scripts/generate_samples.py b/scripts/generate_samples.py index 312a9545..40d718f8 100644 --- a/scripts/generate_samples.py +++ b/scripts/generate_samples.py @@ -18,6 +18,7 @@ read_file, set_gpu_arch, ) +from kernelbench.kernel_static_checker import validate_kernel_static """ Batch Generate Samples for Particular Level @@ -84,6 +85,8 @@ def __init__(self): self.hardware_gpu_name = None self.custom_prompt_key = None + self.check_kernel = True # [experimental] optional static checker catching potential hacking patterns + def greedy(self): # For greedy decoding, epsecially baseline eval self.greedy_sample = True @@ -162,6 +165,19 @@ def generate_sample_single( # check LLM is able to generate custom CUDA code assert custom_kernel is not None, "Custom CUDA code generation failed" + # Optional: we provide a static code checker for kernel code using regex matching + # NOTE: by no means, is this checker complete, but it might could help catch some potential hacks and issues + if config.check_kernel: + static_check_status, error, warnings = validate_kernel_static(custom_kernel, + backend=config.backend, + precision=config.precision, + # uses the default set of forbidden and warning patterns, + # you could adapt the patterns to your own setting (degree of banning cuda stream, allowing some torch ops) + ) + assert static_check_status, f"Static check failed for sample {work.sample_id} for problem {problem_number}: {problem_name}. Error: {error}. Warnings: {warnings}" + if warnings: + print(f"Static check warnings for sample {work.sample_id} for problem {problem_number}: {problem_name}. Warnings: {warnings}") + if config.verbose: print( f"Generated sample {work.sample_id} for problem {problem_number}: {problem_name}" diff --git a/scripts/run_and_check.py b/scripts/run_and_check.py index 37ab9732..8d150b7c 100644 --- a/scripts/run_and_check.py +++ b/scripts/run_and_check.py @@ -10,6 +10,7 @@ from kernelbench import utils as kernel_utils from scripts.generate_baseline_time import measure_program_time from kernelbench.utils import read_file +from kernelbench.kernel_static_checker import validate_kernel_static # Modal setup app = modal.App("run_and_check") @@ -120,6 +121,8 @@ def __init__(self): self.precision = "fp32" self.backend = "cuda" + self.check_kernel = True # [experimental] optional static checker catching potential hacking patterns + def __repr__(self): return f"ScriptConfig({self.to_dict()})" @@ -279,6 +282,18 @@ def main(config: ScriptConfig): kernel_src = read_file(config.kernel_src_path) + # Optional: static code checker for kernel code using regex matching + # NOTE: by no means is this checker complete, but it could help catch some potential hacks + if config.check_kernel: + static_check_status, errors, warnings = validate_kernel_static( + kernel_src, + backend=config.backend, + precision=config.precision, + ) + assert static_check_status, f"Static check failed. Errors: {errors}. Warnings: {warnings}" + if warnings: + print(f"[WARN] Static check warnings: {warnings}") + # Start Evaluation assert config.eval_mode in ["local", "modal"], "eval_mode must be either 'local' or 'modal'" diff --git a/src/kernelbench/kernel_static_checker.py b/src/kernelbench/kernel_static_checker.py new file mode 100644 index 00000000..c8832a1a --- /dev/null +++ b/src/kernelbench/kernel_static_checker.py @@ -0,0 +1,659 @@ +""" +Kernel Static Checker - Pattern-based validation for GPU kernel code. + +The goal is flag reward hacking patterns (both strictly prohibited and possible ones). +through statically examining the code. + +In the future we can add +- AST-based detections +- LM as a judge checker + +Warning: This list is by no means complete and nor this is not a replacement for runtime checks. +We welcome feedback and contributions as community find new ways of hacks. + +- Bypass hacks (PyTorch wrapping, try-except fallback, inheritance bypass) +- Disallow some high-level torch operations (depends on the settings) +- Backend implementation requirements, that CUDA or DSL features must be used + +Usage: + result = validate_kernel_static(code, backend="cuda") + will return a tuple (valid, errors, warnings) +""" + +import re +from typing import List, Tuple, Dict, Any, Optional, Callable, Union + +def _strip_comments(code: str) -> str: + """Remove # and // comments from code.""" + lines = [] + for line in code.split('\n'): + if '#' in line: + line = line[:line.index('#')] + if '//' in line: + line = line[:line.index('//')] + lines.append(line) + return '\n'.join(lines) + + +# ============================================================================= +# BYPASS CHECKS - Strictly Prohibited +# some of this is from Kevin RL Paper (arxiv:2507.11948) +# ============================================================================= + +# --- Try-Except Fallback --- +# Rationale: Models wrap incomplete CUDA in exception handlers that fall back to PyTorch. +# This allows them to pass tests without actually implementing the kernel. +TRY_EXCEPT_PATTERNS = [r"\btry\s*:", r"\bexcept\s*:", r"\bexcept\s+\w+"] + +# --- Pass Statement / Inheritance Bypass --- +# Rationale: Model inherits from reference class and uses 'pass' to do nothing, +# effectively just calling the parent implementation. +PASS_PATTERN = r"\bpass\b" + +def check_code_bypass(code: str) -> Tuple[bool, str]: + """ + Check for code bypass patterns (strictly prohibited). + 1. Try-Except Fallback: Models wrap incomplete CUDA in exception handlers + that fall back to PyTorch when custom code fails. + 2. Pass Statement: Models inherit from reference and use 'pass' to do nothing, + effectively calling parent implementation. + Uses word boundary for 'pass' to avoid matching 'passed', 'bypass', etc. + """ + code = _strip_comments(code) + + # Check for try-except fallback + for pattern in TRY_EXCEPT_PATTERNS: + if re.search(pattern, code): + return (True, "Contains try-except block (potential fallback bypass)") + + # Check for pass statement + if re.search(PASS_PATTERN, code): + return (True, "Contains 'pass' statement (inheritance bypass)") + + return (False, "") + +# Since KernelBench problems uses PyTorch as a reference, there could be settigs where +# Model generated code +# 1. Replaces some (not all) ops with custom kernels, others are kept in Torch +# --> More practical from a performance perspective (ie. make better systems) as you want to use whatever makes the best system for your use case. +# 2. All compuational ops must be replaced with custom kernels +# --> Could be helpful from an eval (model ability on transpile + optimization) / RL training perspective +# Depends the setting you use, you can move the checks below (pytorch_wrap, torch_computation_ops) +# from WARNING to STRICT + +# --- PyTorch NN Module Wrapping --- +# Allows: nn.Module, nn.Parameter, nn.ParameterList, nn.ParameterDict, +# nn.ModuleList, nn.ModuleDict, nn.init (needed for model structure) +# Blocks: nn.Linear, nn.Conv2d, nn.ReLU, etc. (compute layers) +PYTORCH_DISALLOWED_NN_PATTERN = r'torch\.nn\.(?!(Module|parameter|Parameter|ParameterList|ParameterDict|ModuleList|ModuleDict|init)\b)' + +def check_pytorch_wrap(code: str) -> Tuple[bool, str]: + """ + Check for PyTorch nn module usage (nn.Linear, nn.Conv2d, etc.). + + Allows containers (nn.Module, nn.Parameter, nn.init) needed for model structure. + Blocks compute layers (nn.Linear, nn.Conv2d, nn.ReLU, etc.). + """ + code = _strip_comments(code) + if re.search(PYTORCH_DISALLOWED_NN_PATTERN, code): + return (True, "Uses torch.nn compute layer (only containers, Parameter, init allowed)") + return (False, "") + + +# --- Torch Computation Operations --- +# Rationale: These are high-level PyTorch ops that conduct computation. +# Using them directly defeats the purpose of writing custom kernels. +# Includes both torch.* and F.* (torch.nn.functional) patterns. +TORCH_COMPUTATION_OPS = [ + # Matrix operations + "torch.mm", "torch.bmm", "torch.matmul", "torch.einsum", + # Convolutions + "torch.conv1d", "torch.conv2d", "torch.conv3d", "torch.conv", + "torch.conv_transpose1d", "torch.conv_transpose2d", "torch.conv_transpose3d", + # Pooling + "torch.avg_pool1d", "torch.avg_pool2d", "torch.avg_pool3d", + "torch.max_pool1d", "torch.max_pool2d", "torch.max_pool3d", + "torch.adaptive_avg_pool1d", "torch.adaptive_avg_pool2d", "torch.adaptive_avg_pool3d", + "torch.adaptive_max_pool1d", "torch.adaptive_max_pool2d", "torch.adaptive_max_pool3d", + # Activations + "torch.relu", "torch.hardtanh", "torch.elu", "torch.selu", + "torch.leaky_relu", "torch.gelu", "torch.softsign", "torch.softplus", + "torch.softmax", "torch.log_softmax", "torch.tanh", "torch.sigmoid", + "torch.hardsigmoid", "torch.silu", "torch.mish", + # Normalization + "torch.batch_norm", "torch.group_norm", "torch.layer_norm", + "torch.instance_norm", "torch.rms_norm", "torch.normalize", + # Linear & Loss + "torch.linear", "torch.cross_entropy", "torch.kl_div", "torch.mse_loss", + "torch.huber_loss", "torch.triplet_margin_loss", "torch.cosine_similarity", + # Others + "torch.logsumexp", "torch.clamp", "torch.dropout", +] + +# F.* patterns (torch.nn.functional equivalents) +TORCH_FUNCTIONAL_PATTERNS = [ + r"torch\.nn\.functional\.\w+", # torch.nn.functional.* + r"\bnn\.functional\.\w+", # nn.functional.* + r"\bF\.(conv|linear|relu|gelu|softmax|batch_norm|layer_norm|dropout|max_pool|avg_pool)", +] + +def check_torch_computation_ops(code: str) -> Tuple[bool, str]: + """ + Check for high-level torch computation operations. + + Matches both torch.* ops (torch.matmul) and F.* ops (F.relu). + This check is optional/taste-based. Configure as needed. + """ + code = _strip_comments(code) + + # Check torch.* ops + torch_pattern = r'\b(' + '|'.join(re.escape(f) for f in TORCH_COMPUTATION_OPS) + r')(?=\s*\(|\s|$)' + match = re.search(torch_pattern, code) + if match: + return (True, f"Uses torch computation op: {match.group(0)}") + + # Check F.* / nn.functional ops + for pattern in TORCH_FUNCTIONAL_PATTERNS: + match = re.search(pattern, code) + if match: + return (True, f"Uses torch.nn.functional op: {match.group(0)}") + + return (False, "") + +# ============================================================================= +# Backend Specific Checks +# ============================================================================= + +# <========= CUDA CHECKS =========> +# Rationale: Valid CUDA kernels must have __global__ (kernel definition) and +# use load_inline or cpp_extension (PyTorch's inline compilation). +CUDA_COMPILE_PATTERNS = ["load_inline", "cpp_extension"] + +def check_cuda_impl(code: str) -> Tuple[bool, str]: + """ + Check for valid CUDA kernel implementation. + + Requirements: + - Must have __global__ void kernel_name (kernel definition) + - Must have load_inline or cpp_extension (PyTorch inline compilation) + """ + code = _strip_comments(code) + if "__global__" not in code: + return (True, "Missing __global__ kernel definition") + if not any(p in code for p in CUDA_COMPILE_PATTERNS): + return (True, "Missing load_inline or cpp_extension for compilation") + return (False, "") + +# <========= TRITON CHECKS =========> +# Rationale: Triton kernels are compiled from @triton.jit decorated functions. +# They must use tl.* operations (tl.load, tl.store, etc.) for actual kernel work. +TRITON_JIT_PATTERN = r"@triton\.(jit|autotune)" +TRITON_OPS_PATTERN = r"\btl\.\w+" + +def check_triton_impl(code: str) -> Tuple[bool, str]: + """ + Check for valid Triton kernel implementation. + + Requirements: + - Must have @triton.jit or @triton.autotune decorator + - Must have tl.* operations (enforces actual Triton code, not wrapper) + + Note: Triton's compiler itself prevents PyTorch ops inside @triton.jit. + """ + code = _strip_comments(code) + if not re.search(TRITON_JIT_PATTERN, code): + return (True, "Missing @triton.jit or @triton.autotune") + if not re.search(TRITON_OPS_PATTERN, code): + return (True, "No tl.* operations found in Triton kernel") + return (False, "") + + +# <========= THUNDERKITTENS CHECKS =========> +# Rationale: ThunderKittens uses warp/warpgroup primitives and tile abstractions. +# Valid TK code must have namespace patterns and tile declarations. +TK_WARP_PATTERNS = [ + r"kittens::warp\b", r"kittens::warpgroup\b", + r"::warpgroup::", r"::warp::", r"warpgroup::", r"warp::" +] +TK_TILE_PATTERN = r"(?:kittens::)?(?:st|rt)_\w+\s*<[^>]+>" + +def check_tk_impl(code: str) -> Tuple[bool, str]: + """ + Check for valid ThunderKittens kernel implementation. + + Requirements: + - Must have warp/warpgroup namespace patterns (kittens::warp, etc.) + - Must have tile declarations (st_bf<...>, rt_fl<...>, etc.) + + TODO: Add producer-consumer pattern check for complex kernels. + """ + code = _strip_comments(code) + if not any(re.search(p, code) for p in TK_WARP_PATTERNS): + return (True, "Missing ThunderKittens warp/warpgroup patterns") + if not re.search(TK_TILE_PATTERN, code): + return (True, "Missing ThunderKittens tile declarations (st_*/rt_*)") + return (False, "") + + +# <========= CUTE/CUTLASS CHECKS =========> +# CUTLASS uses cute:: namespace for tensor operations +# Check: https://github.com/NVIDIA/cutlass +CUTE_PATTERNS = [ + r"cute::", # cute:: namespace (CuTe library) + r"cutlass::", # cutlass:: namespace + r"from cutlass", # Python CUTLASS bindings +] + +def check_cute_impl(code: str) -> Tuple[bool, str]: + """Check for valid CUTLASS/CuTe kernel implementation.""" + code = _strip_comments(code) + if not any(p in code for p in ["cute::", "cutlass::", "from cutlass"]): + return (True, "Missing cute:: or cutlass:: namespace") + return (False, "") + + +# <========= TILELANG CHECKS =========> +# TileLang uses TVM's T.prim_func decorator +# https://github.com/tile-ai/tilelang +TILELANG_PATTERNS = [ + r"@T\.prim_func", # TVM primitive function decorator + r"tvm\.build", # TVM build call + r"T\.grid", # TileLang grid +] + +def check_tilelang_impl(code: str) -> Tuple[bool, str]: + """Check for valid TileLang kernel implementation.""" + code = _strip_comments(code) + if not re.search(r"@T\.prim_func", code): + return (True, "Missing @T.prim_func decorator") + return (False, "") + + +# ============================================================================= +# TIMING MANIPULATION CHECKS - Reward Hacking Patterns +# From adversarial hack PR and DeepReinforce blog +# ============================================================================= + +# <========= STREAM INJECTION CHECKS =========> +# Rationale: Models may use CUDA streams to defer computation, manipulate timing, +# or execute operations asynchronously to cheat benchmark measurements. +STREAM_PATTERNS = [ + r"torch\.cuda\.Stream\s*\(", # torch.cuda.Stream() + r"cuda\.Stream\s*\(", # cuda.Stream() (if imported) + r"with\s+torch\.cuda\.stream", # with torch.cuda.stream(...) + r"\.wait_stream\s*\(", # .wait_stream() method + r"\.record_stream\s*\(", # .record_stream() method +] + +def check_stream_injection(code: str) -> Tuple[bool, str]: + """ + Check for CUDA stream injection patterns. + + Detects code that uses CUDA streams to potentially manipulate timing: + 1. Stream creation: torch.cuda.Stream(), cuda.Stream() + 2. Stream context managers: with torch.cuda.stream(...) + 3. Stream synchronization: .wait_stream(), .record_stream() + + Rationale: Streams can defer computation or change execution order, + potentially affecting benchmark timing measurements. + """ + code = _strip_comments(code) + + for pattern in STREAM_PATTERNS: + if re.search(pattern, code): + if "wait_stream" in pattern or "record_stream" in pattern: + return (True, "Uses stream synchronization (potential timing manipulation)") + elif "with" in pattern: + return (True, "Uses stream context manager (potential timing manipulation)") + else: + return (True, "Uses CUDA streams (potential timing manipulation)") + + return (False, "") + + +# <========= THREAD INJECTION CHECKS =========> +# Rationale: Models may use threading to parallelize work or manipulate execution +# order in ways that could affect benchmark timing. +THREAD_PATTERNS = [ + r"threading\.Thread\s*\(", # threading.Thread() + r"import\s+threading", # import threading + r"from\s+threading\s+import", # from threading import ... + r"multiprocessing\.(Process|Pool|Manager|Queue|Pipe)", + r"import\s+multiprocessing", # import multiprocessing + r"concurrent\.futures", # concurrent.futures (thread pools) + r"ThreadPoolExecutor", # ThreadPoolExecutor + r"ProcessPoolExecutor", # ProcessPoolExecutor +] + +def check_thread_injection(code: str) -> Tuple[bool, str]: + """ + Check for thread/multiprocessing injection patterns. + + Detects code that uses threading or multiprocessing: + 1. Thread creation: threading.Thread() + 2. Threading imports: import threading + 3. Multiprocessing: Process, Pool, Manager, Queue, Pipe + 4. Concurrent futures: ThreadPoolExecutor, ProcessPoolExecutor + + Rationale: Threading can defer computation or change execution order, + affecting timing measurements. + + Note: ProcessPoolExecutor might be legitimate in eval code but should + not appear in kernel implementations. + """ + code = _strip_comments(code) + + for pattern in THREAD_PATTERNS: + if re.search(pattern, code): + if "multiprocessing" in pattern: + return (True, "Uses multiprocessing (potential timing manipulation)") + elif "concurrent" in pattern or "Executor" in pattern: + return (True, "Uses concurrent futures (potential timing manipulation)") + else: + return (True, "Uses threading (potential timing manipulation)") + + return (False, "") + + +# <========= LAZY EVALUATION CHECKS =========> +# Rationale: Models may create fake/lazy tensors that don't actually compute +# anything, passing correctness checks without real implementation. +LAZY_TENSOR_PATTERNS = [ + r"_make_subclass", # torch.Tensor._make_subclass (common lazy hack) + r"class\s+\w+.*\(torch\.Tensor\)", # Custom tensor subclasses + r"class\s+\w+.*\(Tensor\)", # Custom tensor subclasses (imported Tensor) + r"torch\.Tensor\.__new__", # Direct tensor construction (potential lazy) +] + +def check_lazy_eval(code: str) -> Tuple[bool, str]: + """ + Check for lazy tensor creation patterns. + + Detects patterns commonly used to create lazy/fake tensors: + 1. _make_subclass: Common way to create custom tensor subclasses + 2. Custom tensor subclasses: Classes inheriting from torch.Tensor + 3. Direct tensor construction: torch.Tensor.__new__ manipulation + + Rationale: Lazy tensors can pass correctness checks without actually + computing anything, which is a form of reward hacking. + """ + code = _strip_comments(code) + + for pattern in LAZY_TENSOR_PATTERNS: + if re.search(pattern, code): + if "_make_subclass" in pattern: + return (True, "Uses _make_subclass (potential lazy tensor hack)") + elif "class" in pattern: + return (True, "Defines custom tensor subclass (potential lazy tensor hack)") + else: + return (True, "Uses direct tensor construction (potential lazy tensor hack)") + + return (False, "") + + +# <========= Timing Monkey Patch CHECKS =========> +# Rationale: Models may monkey-patch torch timing functions to fake benchmark results. +# This detects static patterns where timing functions are reassigned. +# especially when relying on timing markers like cuda.Event or time.perf_counter. +TIMING_EVENT_PATCH_PATTERNS = [ + r"torch\.cuda\.Event\.record\s*=", # torch.cuda.Event.record = ... + r"torch\.cuda\.Event\.elapsed_time\s*=", # torch.cuda.Event.elapsed_time = ... + r"torch\.cuda\.synchronize\s*=", # torch.cuda.synchronize = ... + r"torch\.cuda\.Event\s*=", # torch.cuda.Event = ... (replacing class) + r"time\.perf_counter\s*=", # time.perf_counter = ... + r"time\.time\s*=", # time.time = ... +] + +def check_timing_event_patch(code: str) -> Tuple[bool, str]: + """ + Check for monkey patching of timing functions (static analysis). + + Detects code that reassigns torch or time functions used for benchmarking: + 1. torch.cuda.Event.record = ... + 2. torch.cuda.Event.elapsed_time = ... + 3. torch.cuda.synchronize = ... + 4. time.perf_counter = ... + + Rationale: Monkey patching timing functions can fake benchmark results, + making slow code appear fast. + """ + code = _strip_comments(code) + + for pattern in TIMING_EVENT_PATCH_PATTERNS: + if re.search(pattern, code): + return (True, "Reassigns timing function (monkey patch detected)") + + return (False, "") + + +# <========= PRECISION DOWNGRADE CHECKS =========> +# Rationale: Models may downgrade precision internally (FP32 -> FP16) +# to make kernels faster while still returning FP32 output. This is a reward +# hacking pattern where models cheat on timing while appearing correct. +# This might be a valid optimization, but is still worth flagging as a warning. +# +# We use explicit, high-confidence patterns that indicate intentional precision +# downgrading. These patterns have minimal false positives and clear semantic intent. + +# Specific patterns that indicate FP32 -> FP16 precision downgrading +FP32_TO_FP16_PATTERNS = [ + # ========== CUDA / CUDA C++ ========== + # 1.1 Explicit float -> half intrinsics (⭐ gold standard) + # __float2half(f), __float2half_rn(f) + r"__float2half(_rn)?\s*\(", + + # 1.2 Explicit C-style cast to __half + # (__half)f + r"\(\s*__half\s*\)\s*[\w\->\.]+", + + # 1.3 static_cast / static_cast<__half> + # static_cast(f), static_cast<__half>(f) + r"static_cast\s*<\s*(__half|half)\s*>\s*\(", + + # ========== Triton (Python) ========== + # 2.1 Explicit tl.astype(..., tl.float16) (⭐ best signal) + # tl.astype(x, tl.float16) + r"tl\.astype\s*\(\s*[^,]+,\s*tl\.float16\s*\)", + + # ========== CUTLASS ========== + # 3.1 NumericConverter float -> half (⭐ extremely reliable) + # NumericConverter + r"NumericConverter\s*<\s*half_t\s*,\s*float\s*>", + + # 3.2 Epilogue output type = FP16 + # LinearCombination + r"LinearCombination\s*<\s*half_t", + + # ========== CUTE (when used directly) ========== + # 4.1 Explicit type conversion utility + # type_convert(x) + r"type_convert\s*<\s*half_t\s*>\s*\(", + + # ========== ThunderKittens ========== + # 5.1 Explicit half types in cast contexts + # tk::half(x) + r"tk::half\s*\(", + + # ========== Additional gaping patterns ========== + # PyTorch explicit casts (common in inline CUDA contexts) + r"\.half\s*\(", # .half() -> FP16 + r"\.float16\s*\(", # .float16() -> FP16 + r"\.to\s*\(\s*torch\.(float16|half)\b", # .to(torch.float16) + r"\.to\s*\(\s*dtype\s*=\s*torch\.(float16|half)\b", # .to(dtype=torch.float16) +] + +def check_precision_downgrade(code: str, precision: str = "fp32") -> Tuple[bool, str]: + """ + Check for FP32 -> FP16 precision downgrading patterns in kernel code. + + Detects code that downgrades precision from FP32 to FP16 internally, + which can make kernels faster but with reduced precision. This is a reward + hacking pattern where models cheat on timing while appearing correct. + + Currently only checks for FP32 -> FP16 downgrades. Other precision combinations + (e.g., FP16 -> BF16) are not flagged. + + Args: + code: Kernel source code + precision: Required precision - only checks when "fp32" or "float32" + + Returns: + (True, error_message) if FP32 -> FP16 downgrade detected + (False, "") if no downgrade detected + + Examples of detected patterns: + - .half(), .float16() + - .to(torch.float16), .to(torch.half) + - dtype=torch.float16 + - __half, half2 (CUDA) + - tl.float16 (Triton) + """ + code = _strip_comments(code) + precision = precision.lower() + + # Normalize precision to standard form + precision_map = {"fp32": "fp32", "float32": "fp32", "fp16": "fp16", "bf16": "bf16", "bfloat16": "bf16"} + precision = precision_map.get(precision, precision) + + # Only check for FP32 -> FP16 downgrades + if precision != "fp32": + return (False, "") + + # Check for FP16 patterns + for pattern in FP32_TO_FP16_PATTERNS: + if re.search(pattern, code): + return (True, "Precision downgrade detected: required FP32 but code uses FP16") + + return (False, "") + +# ============================================================================= +# In the future, we can add a AST-based checker and a LM-as-a-judge checker +# ============================================================================= + + +# ============================================================================= +# REGISTRY & PRESETS +# ============================================================================= + +# Check functions can take either (code) or (code, precision) arguments +# Most checks take only code, but precision-dependent checks take both +CHECK_FUNCTIONS: Dict[str, Union[Callable[[str], Tuple[bool, str]], Callable[[str, str], Tuple[bool, str]]]] = { + # Bypass checks (strict) + "code_bypass": check_code_bypass, + "pytorch_wrap": check_pytorch_wrap, + "timing_event_patch": check_timing_event_patch, # clearly malicious + + # Torch ops (depends on your setups) + "torch_computation_ops": check_torch_computation_ops, + + # Timing manipulation checks (usually warnings) + "stream_injection": check_stream_injection, + "thread_injection": check_thread_injection, + "lazy_eval": check_lazy_eval, + "precision_downgrade": check_precision_downgrade, # precision-dependent + + # Backend-specific implementation checks + # should be strict + "cuda_impl": check_cuda_impl, + "triton_impl": check_triton_impl, + "tk_impl": check_tk_impl, + "cute_impl": check_cute_impl, + "tilelang_impl": check_tilelang_impl, +} + +# Checks that require additional parameters beyond just code +PRECISION_DEPENDENT_CHECKS = {"precision_downgrade"} + +# Here are some presets for you to use +# You are welcome to adapt them to your settings +# These checks are NECESSARY for all kernels (strict = error) +STRICT_CHECKS = [ + "code_bypass", + "timing_event_patch", + "thread_injection", + "lazy_eval", +] + +# Backend-specific checks are added later at entry point +# per backend implementation check, usually strict +BACKEND_IMPL_CHECK = { + "cuda": "cuda_impl", + "triton": "triton_impl", + "thunderkittens": "tk_impl", + "cute": "cute_impl", + "cutlass": "cute_impl", # alias + "tilelang": "tilelang_impl", +} + +# These are optional checks (by user's decision) - flagged as warnings +# Move to STRICT_CHECKS if you want to enforce them +WARNING_CHECKS: List[str] = [ + # up to user to allow program to still have some torch computation ops + "pytorch_wrap", + "torch_computation_ops", + "stream_injection", # could have legitimate uses (async ops), but should be careful! + "precision_downgrade", # precision downgrading - can be intentional but often a hack +] + + +# ============================================================================= +# MAIN ENTRY POINT +# ============================================================================= + +def validate_kernel_static( + code: str, + backend: str = "cuda", + precision: str = "fp16", + forbidden: Optional[List[str]] = None, + warnings: Optional[List[str]] = None, +) -> Tuple[bool, List[str], List[str]]: + """ + Validate kernel code through statically inspecting the code + We configure the checks against check groups that we have provided for common hacks. + Note we do not guarantee that all checks are exhaustive. This is also only on the static level. + + Args: + code: Kernel source code + backend: "cuda", "triton", or "thunderkittens" + precision: "fp16", "fp32", or "bf16" (for future precision checks) + forbidden: Check categories that cause errors (default: STRICT_CHECKS) + warnings: Check categories that cause warnings (default: WARNING_CHECKS) + + Returns: + (valid, errors, warnings) + valid: bool + errors: List[str] + warnings: List[str] + """ + # Copy defaults to avoid mutating global lists + forbidden_checks = list(forbidden) if forbidden is not None else list(STRICT_CHECKS) + warning_checks = list(warnings) if warnings is not None else list(WARNING_CHECKS) + + # Add backend implementation check if specified + if backend in BACKEND_IMPL_CHECK: + impl_check = BACKEND_IMPL_CHECK[backend] + if impl_check not in forbidden_checks: + forbidden_checks.append(impl_check) + + # Aggregate results + errors: List[str] = [] + warnings_list: List[str] = [] + + for check_name in set(forbidden_checks + warning_checks): + if check_name not in CHECK_FUNCTIONS: + continue + + # Handle precision-dependent checks + if check_name in PRECISION_DEPENDENT_CHECKS: + has_issue, msg = CHECK_FUNCTIONS[check_name](code, precision) + else: + has_issue, msg = CHECK_FUNCTIONS[check_name](code) + + if has_issue: + if check_name in forbidden_checks: + errors.append(msg) + else: + warnings_list.append(msg) + + valid = len(errors) == 0 # valid if no errors + return valid, errors, warnings_list diff --git a/src/kernelbench/unit_tests/test_precision.py b/src/kernelbench/unit_tests/test_precision.py new file mode 100644 index 00000000..1e8a2299 --- /dev/null +++ b/src/kernelbench/unit_tests/test_precision.py @@ -0,0 +1,395 @@ +""" +Unit tests for precision downgrade detection in FP32 kernels. + +Tests the check_precision_downgrade function to ensure it correctly detects +various patterns that indicate precision downgrading (FP32 -> FP16), +which is a reward hacking pattern. + +Note: The current implementation only checks for FP32 -> FP16 downgrades, +not BF16 downgrades. + +Run with pytest: + pytest src/kernelbench/unit_tests/test_precision.py -v + or + uv run pytest src/kernelbench/unit_tests/test_precision.py -v +""" + +import os +import sys +import pytest + +# Add src directory to path for imports (consistent with other test files) +sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "../.."))) + +from kernelbench.kernel_static_checker import check_precision_downgrade + + +# ============================================================================ +# Test Cases for FP32 -> FP16 Precision Downgrades (PyTorch patterns) +# ============================================================================ + +def test_fp32_half_method(): + """Test detection of .half() method call downgrading FP32 to FP16.""" + code = """ + def forward(self, x): + x = x.half() + return x * 2 + """ + detected, message = check_precision_downgrade(code, precision="fp32") + assert detected is True, "Should detect .half() method call" + assert "FP16" in message + + +def test_fp32_float16_method(): + """Test detection of .float16() method call.""" + code = """ + x = input_tensor.float16() + return x + """ + detected, message = check_precision_downgrade(code, precision="fp32") + assert detected is True, "Should detect .float16() method call" + assert "FP16" in message + + +def test_fp32_to_torch_half(): + """Test detection of .to(torch.half) pattern.""" + code = """ + def forward(self, x): + x = x.to(torch.half) + return x + """ + detected, message = check_precision_downgrade(code, precision="fp32") + assert detected is True, "Should detect .to(torch.half)" + assert "FP16" in message + + +def test_fp32_to_torch_float16(): + """Test detection of .to(torch.float16) pattern.""" + code = """ + x = x.to(torch.float16) + """ + detected, message = check_precision_downgrade(code, precision="fp32") + assert detected is True, "Should detect .to(torch.float16)" + assert "FP16" in message + + +def test_fp32_to_dtype_float16(): + """Test detection of .to(dtype=torch.float16) pattern.""" + code = """ + def forward(self, x): + return x.to(dtype=torch.float16) + """ + detected, message = check_precision_downgrade(code, precision="fp32") + assert detected is True, "Should detect .to(dtype=torch.float16)" + assert "FP16" in message + + +def test_fp32_to_dtype_half(): + """Test detection of .to(dtype=torch.half) pattern.""" + code = """ + x.to(dtype=torch.half) + """ + detected, message = check_precision_downgrade(code, precision="fp32") + assert detected is True, "Should detect .to(dtype=torch.half)" + assert "FP16" in message + + +# ============================================================================ +# Test Cases for FP32 -> FP16 Precision Downgrades (CUDA patterns) +# ============================================================================ + +def test_fp32_cuda_float2half(): + """Test detection of CUDA __float2half intrinsic.""" + code = """ + __global__ void kernel(float* input, __half* output) { + output[0] = __float2half(input[0]); + } + """ + detected, message = check_precision_downgrade(code, precision="fp32") + assert detected is True, "Should detect CUDA __float2half" + assert "FP16" in message + + +def test_fp32_cuda_float2half_rn(): + """Test detection of CUDA __float2half_rn intrinsic.""" + code = """ + __half result = __float2half_rn(value); + """ + detected, message = check_precision_downgrade(code, precision="fp32") + assert detected is True, "Should detect CUDA __float2half_rn" + assert "FP16" in message + + +def test_fp32_cuda_cast_to_half(): + """Test detection of CUDA C-style cast to __half.""" + code = """ + __half h = (__half)float_value; + """ + detected, message = check_precision_downgrade(code, precision="fp32") + assert detected is True, "Should detect CUDA cast to __half" + assert "FP16" in message + + +def test_fp32_cuda_static_cast_half(): + """Test detection of CUDA static_cast.""" + code = """ + __half h = static_cast<__half>(float_value); + """ + detected, message = check_precision_downgrade(code, precision="fp32") + assert detected is True, "Should detect CUDA static_cast<__half>" + assert "FP16" in message + + +# ============================================================================ +# Test Cases for FP32 -> FP16 Precision Downgrades (Triton patterns) +# ============================================================================ + +def test_fp32_triton_astype_float16(): + """Test detection of Triton tl.astype(..., tl.float16).""" + code = """ + @triton.jit + def kernel(X, Y): + x = tl.load(X) + x_fp16 = tl.astype(x, tl.float16) + tl.store(Y, x_fp16) + """ + detected, message = check_precision_downgrade(code, precision="fp32") + assert detected is True, "Should detect Triton tl.astype(..., tl.float16)" + assert "FP16" in message + + +# ============================================================================ +# Test Cases for FP32 -> FP16 Precision Downgrades (CUTLASS patterns) +# ============================================================================ + +def test_fp32_cutlass_numeric_converter(): + """Test detection of CUTLASS NumericConverter.""" + code = """ + NumericConverter converter; + """ + detected, message = check_precision_downgrade(code, precision="fp32") + assert detected is True, "Should detect CUTLASS NumericConverter" + assert "FP16" in message + + +def test_fp32_cutlass_linear_combination(): + """Test detection of CUTLASS LinearCombination.""" + code = """ + LinearCombination epilogue; + """ + detected, message = check_precision_downgrade(code, precision="fp32") + assert detected is True, "Should detect CUTLASS LinearCombination" + assert "FP16" in message + + +def test_fp32_cute_type_convert(): + """Test detection of CuTe type_convert.""" + code = """ + auto result = type_convert(input); + """ + detected, message = check_precision_downgrade(code, precision="fp32") + assert detected is True, "Should detect CuTe type_convert" + assert "FP16" in message + + +# ============================================================================ +# Test Cases for FP32 -> FP16 Precision Downgrades (ThunderKittens patterns) +# ============================================================================ + +def test_fp32_thunderkittens_half(): + """Test detection of ThunderKittens tk::half().""" + code = """ + using namespace tk; + auto h = tk::half(value); + """ + detected, message = check_precision_downgrade(code, precision="fp32") + assert detected is True, "Should detect ThunderKittens tk::half()" + assert "FP16" in message + + +# ============================================================================ +# Test Cases for Valid FP32 Code (Should NOT be detected) +# ============================================================================ + +def test_fp32_legitimate_code_no_downgrade(): + """Test that legitimate FP32 code is not flagged.""" + code = """ + def forward(self, x): + # Legitimate FP32 operations + x = x * 2.0 + y = torch.matmul(x, x.t()) + return y.float() # This is fine, float() returns float32 + """ + detected, message = check_precision_downgrade(code, precision="fp32") + assert detected is False, "Should not detect downgrade in legitimate FP32 code" + assert message == "" + + +def test_fp32_with_comments_mentioning_half(): + """Test that comments mentioning half precision don't trigger false positives.""" + code = """ + def forward(self, x): + # Note: This should use FP32, not FP16 + # Don't use .half() here! + x = x * 2.0 + return x + """ + detected, message = check_precision_downgrade(code, precision="fp32") + assert detected is False, "Comments should not trigger detection" + + +def test_fp32_string_literals(): + """Test that string literals mentioning precision don't trigger false positives.""" + code = """ + def forward(self, x): + error_msg = "dtype=torch.float16 is not allowed" + print(error_msg) + return x + """ + detected, message = check_precision_downgrade(code, precision="fp32") + assert detected is False, "String literals should not trigger detection" + + +def test_fp32_function_names_containing_half(): + """Test that function names containing 'half' don't trigger false positives.""" + code = """ + def compute_half_tensor(self, x): + # Function name contains 'half' but doesn't downgrade precision + return x * 0.5 + """ + detected, message = check_precision_downgrade(code, precision="fp32") + assert detected is False, "Function names should not trigger detection" + + +# ============================================================================ +# Test Cases for Edge Cases +# ============================================================================ + +def test_fp32_case_insensitive_precision(): + """Test that precision parameter is case-insensitive.""" + code = """ + x = x.half() + """ + detected1, _ = check_precision_downgrade(code, precision="FP32") + detected2, _ = check_precision_downgrade(code, precision="fp32") + detected3, _ = check_precision_downgrade(code, precision="Fp32") + assert detected1 == detected2 == detected3 == True, "Should handle case-insensitive precision" + + +def test_fp32_alternative_precision_names(): + """Test that alternative precision names are normalized correctly.""" + code = """ + x = x.half() + """ + detected1, _ = check_precision_downgrade(code, precision="float32") + detected2, _ = check_precision_downgrade(code, precision="fp32") + assert detected1 == detected2 == True, "Should normalize float32 to fp32" + + +def test_fp32_non_fp32_precision_skips_check(): + """Test that non-FP32 precision skips the check (implementation only checks FP32).""" + code = """ + x = x.half() + """ + detected, message = check_precision_downgrade(code, precision="fp16") + assert detected is False, "Should skip check for non-FP32 precision" + assert message == "" + + +def test_fp32_unknown_precision_skips_check(): + """Test that unknown precision skips the check.""" + code = """ + x = x.half() + """ + detected, message = check_precision_downgrade(code, precision="int8") + assert detected is False, "Should skip check for unknown precision" + assert message == "" + + +def test_fp32_empty_code(): + """Test that empty code doesn't trigger detection.""" + code = "" + detected, message = check_precision_downgrade(code, precision="fp32") + assert detected is False, "Empty code should not trigger detection" + + +def test_fp32_whitespace_only(): + """Test that whitespace-only code doesn't trigger detection.""" + code = " \n\n\t \n " + detected, message = check_precision_downgrade(code, precision="fp32") + assert detected is False, "Whitespace-only code should not trigger detection" + + +# ============================================================================ +# Test Cases for Real-World Scenarios +# ============================================================================ + +def test_fp32_matmul_with_hidden_downgrade(): + """Test detection in a realistic matmul kernel that downgrades internally.""" + code = """ + @triton.jit + def matmul_kernel(A, B, C, M, N, K): + # Compute matrix multiplication + a = tl.load(A) + b = tl.load(B) + + # Sneaky precision downgrade + a = tl.astype(a, tl.float16) + b = tl.astype(b, tl.float16) + + c = tl.dot(a, b) + tl.store(C, c) + """ + detected, message = check_precision_downgrade(code, precision="fp32") + assert detected is True, "Should detect hidden precision downgrade in matmul" + assert "FP16" in message + + +def test_fp32_cuda_kernel_with_half(): + """Test detection in a realistic CUDA kernel.""" + code = """ + __global__ void add_kernel(float* a, float* b, float* c, int n) { + int idx = blockIdx.x * blockDim.x + threadIdx.x; + if (idx < n) { + __half a_half = __float2half(a[idx]); + __half b_half = __float2half(b[idx]); + c[idx] = __half2float(a_half + b_half); + } + } + """ + detected, message = check_precision_downgrade(code, precision="fp32") + assert detected is True, "Should detect CUDA kernel using __float2half" + assert "FP16" in message + + +def test_fp32_complex_code_with_downgrade(): + """Test detection in complex code with multiple operations.""" + code = """ + def forward(self, x, y): + # Some preprocessing + x = x * 2.0 + y = y + 1.0 + + # Main computation with downgrade + x = x.to(dtype=torch.float16) + result = torch.matmul(x, y) + + # Post-processing + result = result * 3.0 + return result + """ + detected, message = check_precision_downgrade(code, precision="fp32") + assert detected is True, "Should detect downgrade in complex code" + assert "FP16" in message + + +# ============================================================================ +# Note on BF16 Tests +# ============================================================================ +# The current implementation only checks for FP32 -> FP16 downgrades. +# BF16 downgrade detection is not yet implemented. These tests document +# expected behavior when BF16 support is added in the future. + + +if __name__ == "__main__": + pytest.main([__file__, "-v"]) diff --git a/src/kernelbench/unit_tests/test_static_checker.py b/src/kernelbench/unit_tests/test_static_checker.py new file mode 100644 index 00000000..d4411fff --- /dev/null +++ b/src/kernelbench/unit_tests/test_static_checker.py @@ -0,0 +1,166 @@ +""" +Tests for kernel_static_checker.py + +Validates that the static checker correctly identifies: +- Valid DSL kernels (no false positives) +- Known adversarial/hack patterns (no false negatives) + +We welcome contributions to improve the static checker and providing adversarial kernels. + + +Run with: uv run pytest src/kernelbench/unit_tests/test_static_checker.py -v +""" + +import pytest +from pathlib import Path +from kernelbench.kernel_static_checker import validate_kernel_static + + +# ============================================================================= +# Fixtures - Common paths and helpers +# ============================================================================= + +@pytest.fixture +def prompts_dir(): + """Path to DSL example kernels.""" + return Path(__file__).parent.parent / "prompts" + +@pytest.fixture +def test_kernels_dir(): + """Path to adversarial test kernels.""" + return Path(__file__).parent / "test_kernels" + + +def read_kernel(path: Path) -> str: + """Read kernel code from file, skip if not found.""" + if not path.exists(): + pytest.skip(f"Kernel file not found: {path}") + return path.read_text() + + +# ============================================================================= +# Valid DSL Kernels - Should Pass (No False Positives) +# These are real, correct kernels from src/kernelbench/prompts/ +# ============================================================================= + +def test_cuda_example_valid(prompts_dir): + """Real CUDA kernel example should pass with default settings.""" + code = read_kernel(prompts_dir / "model_new_ex_add.py") + valid, errors, warnings = validate_kernel_static(code, backend="cuda") + # May have warnings (F import), but should be valid + assert valid or "import F" in str(warnings), f"CUDA example should pass: {errors}" + + +def test_triton_example_valid(prompts_dir): + """Real Triton kernel example should pass.""" + code = read_kernel(prompts_dir / "model_new_ex_add_triton.py") + valid, errors, warnings = validate_kernel_static(code, backend="triton") + assert valid or len(warnings) > 0, f"Triton example should pass: {errors}" + + +def test_cute_example_valid(prompts_dir): + """Real CuTe/CUTLASS kernel example should pass.""" + code = read_kernel(prompts_dir / "model_new_ex_add_cute.py") + valid, errors, warnings = validate_kernel_static(code, backend="cute") + assert valid or len(warnings) > 0, f"CuTe example should pass: {errors}" + + +def test_tilelang_example_valid(prompts_dir): + """Real TileLang kernel example should pass.""" + code = read_kernel(prompts_dir / "model_new_ex_add_tilelang.py") + valid, errors, warnings = validate_kernel_static(code, backend="tilelang") + assert valid or len(warnings) > 0, f"TileLang example should pass: {errors}" + + +# ============================================================================= +# Adversarial Kernels - Should Detect Issues +# These are known hack patterns from test_kernels/ +# ============================================================================= + +def test_stream_kernel_flagged(test_kernels_dir): + """Non-default stream kernel should trigger stream_injection warning.""" + code = read_kernel(test_kernels_dir / "non_default_stream_kernel.py") + valid, errors, warnings = validate_kernel_static(code, backend="cuda") + # Stream injection is in warnings by default + all_messages = errors + warnings + has_stream_warning = any("stream" in msg.lower() for msg in all_messages) + # Note: The CUDA code is in a string literal, so static checker may not catch it + # This test documents the limitation + + +def test_result_reuse_kernel_flagged(test_kernels_dir): + """Result reuse (empty tensor) kernel - static checker can't catch this.""" + code = read_kernel(test_kernels_dir / "result_reuse_kernel.py") + valid, errors, warnings = validate_kernel_static(code, backend="cuda") + # This is a runtime check, static checker won't catch it + # Just verify it doesn't crash + + +def test_zero_out_kernel_flagged(test_kernels_dir): + """Zero-out kernel - static checker can't catch this.""" + code = read_kernel(test_kernels_dir / "zero_out_kernel.py") + valid, errors, warnings = validate_kernel_static(code, backend="cuda") + # This is a correctness issue, not detectable statically + + +# ============================================================================= +# Hack Patterns - Synthetic Examples +# ============================================================================= + +def test_bypass_try_except(): + """Try-except fallback should be flagged as error.""" + code = """ +try: + result = custom_kernel(x) +except: + result = torch.matmul(x, w) # Fallback to torch +""" + valid, errors, warnings = validate_kernel_static(code, backend="cuda") + assert not valid, "Try-except should be flagged" + assert any("try-except" in e.lower() for e in errors) + + +def test_bypass_pass_statement(): + """Pass statement (inheritance bypass) should be flagged.""" + code = """ +class ModelNew(Model): + def forward(self, x): + pass # Does nothing, inherits parent +""" + valid, errors, warnings = validate_kernel_static(code, backend="cuda") + assert not valid, "Pass statement should be flagged" + assert any("pass" in e.lower() for e in errors) + + +def test_lazy_eval_make_subclass(): + """_make_subclass (lazy tensor hack) should be flagged.""" + code = """ +fake_tensor = torch.Tensor._make_subclass(FakeTensor, real_tensor) +""" + valid, errors, warnings = validate_kernel_static(code, backend="cuda") + assert not valid, "_make_subclass should be flagged" + + +def test_timing_monkey_patch(): + """Monkey patching timing functions should be flagged.""" + code = """ +# Override timing to fake benchmarks +torch.cuda.Event.elapsed_time = lambda self, end: 0.001 +""" + valid, errors, warnings = validate_kernel_static(code, backend="cuda") + assert not valid, "Timing monkey patch should be flagged" + + +def test_thread_injection(): + """Threading in kernel code should be flagged.""" + code = """ +import threading +t = threading.Thread(target=background_work) +t.start() +""" + valid, errors, warnings = validate_kernel_static(code, backend="cuda") + assert not valid, "Threading should be flagged" + + +if __name__ == "__main__": + pytest.main([__file__, "-v"]) diff --git a/src/kernelbench/unit_tests/test_validate_kernel_static.py b/src/kernelbench/unit_tests/test_validate_kernel_static.py new file mode 100644 index 00000000..55d97a2c --- /dev/null +++ b/src/kernelbench/unit_tests/test_validate_kernel_static.py @@ -0,0 +1,423 @@ +""" +Unit tests for validate_kernel_static function. + +Tests the main entry point function to ensure it correctly: +- Passes precision to precision-dependent checks +- Categorizes errors vs warnings correctly +- Handles backend-specific checks +- Respects forbidden/warnings parameters +- Returns correct output format + +Run with pytest: + pytest src/kernelbench/unit_tests/test_validate_kernel_static.py -v + or + uv run pytest src/kernelbench/unit_tests/test_validate_kernel_static.py -v +""" + +import os +import sys +import pytest + +# Add src directory to path for imports (consistent with other test files) +sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "../.."))) + +from kernelbench.kernel_static_checker import validate_kernel_static + + +# ============================================================================ +# Test Basic Function Signature and Return Values +# ============================================================================ + +def test_validate_kernel_static_returns_tuple(): + """Test that validate_kernel_static returns a tuple of (valid, errors, warnings).""" + code = "x = 1 + 1" + result = validate_kernel_static(code) + + assert isinstance(result, tuple), "Should return a tuple" + assert len(result) == 3, "Should return (valid, errors, warnings)" + valid, errors, warnings = result + assert isinstance(valid, bool), "First element should be bool" + assert isinstance(errors, list), "Second element should be list" + assert isinstance(warnings, list), "Third element should be list" + + +def test_validate_kernel_static_defaults(): + """Test that validate_kernel_static works with default parameters.""" + code = "x = 1 + 1" + valid, errors, warnings = validate_kernel_static(code) + + # Should work without errors for simple valid code + assert isinstance(valid, bool) + assert isinstance(errors, list) + assert isinstance(warnings, list) + + +# ============================================================================ +# Test Precision Parameter Passing +# ============================================================================ + +def test_precision_passed_to_precision_checker_fp32(): + """Test that precision parameter is correctly passed to precision-dependent checks.""" + # Code with FP32 -> FP16 downgrade + code = """ + def forward(self, x): + x = x.half() # Precision downgrade + return x + """ + + # With fp32 precision, should detect downgrade (as warning by default) + valid, errors, warnings = validate_kernel_static(code, precision="fp32") + + # Check that precision downgrade was detected (should be in warnings by default) + all_messages = errors + warnings + has_precision_warning = any("precision" in msg.lower() or "fp16" in msg.lower() + for msg in all_messages) + assert has_precision_warning, "Should detect precision downgrade with fp32 precision" + + +def test_precision_passed_to_precision_checker_fp16(): + """Test that fp16 precision skips FP32 -> FP16 downgrade check.""" + # Code with FP32 -> FP16 downgrade + code = """ + def forward(self, x): + x = x.half() # Precision downgrade + return x + """ + + # With fp16 precision, precision downgrade check should be skipped + valid, errors, warnings = validate_kernel_static(code, precision="fp16") + + # Should not detect precision downgrade (check is skipped for non-FP32) + all_messages = errors + warnings + has_precision_warning = any("precision" in msg.lower() or "fp16" in msg.lower() + for msg in all_messages) + # This is expected - the check only runs for fp32 + # So for fp16, it won't flag this + + +def test_precision_case_insensitive(): + """Test that precision parameter is case-insensitive.""" + code = """ + def forward(self, x): + x = x.half() + return x + """ + + # Test different case variations + result1 = validate_kernel_static(code, precision="FP32") + result2 = validate_kernel_static(code, precision="fp32") + result3 = validate_kernel_static(code, precision="Fp32") + + # All should produce the same result + assert result1 == result2 == result3, "Precision should be case-insensitive" + + +def test_precision_alternative_names(): + """Test that alternative precision names are normalized.""" + code = """ + def forward(self, x): + x = x.half() + return x + """ + + # float32 should be normalized to fp32 + result1 = validate_kernel_static(code, precision="float32") + result2 = validate_kernel_static(code, precision="fp32") + + assert result1 == result2, "float32 should be normalized to fp32" + + +# ============================================================================ +# Test Error vs Warning Categorization +# ============================================================================ + +def test_strict_checks_are_errors(): + """Test that strict checks (like code_bypass) produce errors.""" + code = """ + try: + result = custom_kernel(x) + except: + result = torch.matmul(x, w) # Fallback to torch + """ + + valid, errors, warnings = validate_kernel_static(code) + + assert not valid, "Code with strict violations should be invalid" + assert len(errors) > 0, "Strict checks should produce errors, not warnings" + assert any("try-except" in e.lower() or "bypass" in e.lower() + for e in errors), "Should flag bypass in errors" + + +def test_warning_checks_are_warnings(): + """Test that warning checks produce warnings, not errors.""" + code = """ + def forward(self, x): + x = x.half() # Precision downgrade - in warnings by default + return x + """ + + # Test with default settings - precision_downgrade should be in warnings + valid, errors, warnings = validate_kernel_static( + code, + precision="fp32" + # Using defaults - precision_downgrade is in WARNING_CHECKS + ) + + # Check that precision downgrade message is in warnings (if detected) + # Note: backend impl checks might add errors, but precision should be in warnings + precision_warnings = [w for w in warnings if "precision" in w.lower() or "fp16" in w.lower()] + precision_errors = [e for e in errors if "precision" in e.lower() or "fp16" in e.lower()] + + if precision_warnings or precision_errors: + # If precision downgrade is detected, it should be in warnings, not errors + assert len(precision_warnings) > 0, "Precision downgrade should be in warnings (default)" + assert len(precision_errors) == 0, "Precision downgrade should not be in errors (default)" + + +def test_custom_forbidden_checks(): + """Test that custom forbidden checks produce errors.""" + code = """ + def forward(self, x): + x = x.half() # Precision downgrade + return x + """ + + # Make precision_downgrade a forbidden check (error) instead of warning + valid, errors, warnings = validate_kernel_static( + code, + precision="fp32", + forbidden=["precision_downgrade"] + ) + + assert not valid, "Should be invalid when precision_downgrade is forbidden" + assert len(errors) > 0, "Forbidden checks should produce errors" + assert any("precision" in e.lower() or "fp16" in e.lower() + for e in errors), "Should flag precision downgrade in errors" + + +def test_custom_warnings_list(): + """Test that custom warnings list works.""" + code = """ + try: + result = custom_kernel(x) + except: + result = torch.matmul(x, w) + """ + + # Move code_bypass to warnings instead of errors + # Use a backend that won't add strict impl checks + valid, errors, warnings = validate_kernel_static( + code, + backend="cuda", # Explicit backend + forbidden=[], # No forbidden checks + warnings=["code_bypass"] # Make bypass a warning + ) + + # Note: Backend might add impl checks, so we check that code_bypass + # appears in warnings (not errors) if it's detected + all_messages = errors + warnings + bypass_messages = [msg for msg in all_messages if "bypass" in msg.lower() or "try-except" in msg.lower()] + + if bypass_messages: + # If bypass is detected, it should be in warnings, not errors + bypass_in_warnings = any(msg in warnings for msg in bypass_messages) + assert bypass_in_warnings, "Bypass should be in warnings when specified as warning" + + +# ============================================================================ +# Test Backend Parameter Handling +# ============================================================================ + +def test_backend_adds_impl_check(): + """Test that backend parameter adds appropriate implementation check.""" + code = """ + # This code doesn't have CUDA implementation + def forward(self, x): + return x * 2 + """ + + valid, errors, warnings = validate_kernel_static(code, backend="cuda") + + # Should check for CUDA implementation (cuda_impl check) + # The exact behavior depends on what cuda_impl check does, + # but we can verify the backend parameter is processed + assert isinstance(valid, bool) + assert isinstance(errors, list) + assert isinstance(warnings, list) + + +def test_different_backends(): + """Test that different backends are handled correctly.""" + code = """ + def forward(self, x): + return x * 2 + """ + + # Test multiple backends + backends = ["cuda", "triton", "thunderkittens", "cute", "tilelang"] + + for backend in backends: + valid, errors, warnings = validate_kernel_static(code, backend=backend) + assert isinstance(valid, bool) + assert isinstance(errors, list) + assert isinstance(warnings, list) + + +# ============================================================================ +# Test Edge Cases +# ============================================================================ + +def test_empty_code(): + """Test handling of empty code.""" + code = "" + + valid, errors, warnings = validate_kernel_static(code) + + assert isinstance(valid, bool) + assert isinstance(errors, list) + assert isinstance(warnings, list) + + +def test_whitespace_only_code(): + """Test handling of whitespace-only code.""" + code = " \n\n\t \n " + + valid, errors, warnings = validate_kernel_static(code) + + assert isinstance(valid, bool) + assert isinstance(errors, list) + assert isinstance(warnings, list) + + +def test_unknown_check_name(): + """Test that unknown check names are ignored.""" + code = "x = 1" + + # Should not crash with unknown check names + valid, errors, warnings = validate_kernel_static( + code, + forbidden=["unknown_check_that_doesnt_exist"], + warnings=["another_unknown_check"] + ) + + assert isinstance(valid, bool) + assert isinstance(errors, list) + assert isinstance(warnings, list) + + +def test_multiple_precision_dependent_checks(): + """Test that multiple precision-dependent checks work (if any exist in future).""" + code = """ + def forward(self, x): + x = x.half() + return x + """ + + # Currently only precision_downgrade is precision-dependent + valid, errors, warnings = validate_kernel_static(code, precision="fp32") + + assert isinstance(valid, bool) + assert isinstance(errors, list) + assert isinstance(warnings, list) + + +# ============================================================================ +# Test Integration: Precision + Backend + Custom Checks +# ============================================================================ + +def test_integration_precision_backend_forbidden(): + """Test integration of precision, backend, and custom forbidden checks.""" + code = """ + def forward(self, x): + x = x.half() # Precision downgrade + return x + """ + + valid, errors, warnings = validate_kernel_static( + code, + backend="cuda", + precision="fp32", + forbidden=["precision_downgrade"] + ) + + assert not valid, "Should be invalid with precision downgrade as forbidden" + assert len(errors) > 0, "Should have errors" + assert any("precision" in e.lower() or "fp16" in e.lower() + for e in errors), "Should flag precision downgrade" + + +def test_integration_all_parameters(): + """Test with all parameters specified.""" + code = """ + def forward(self, x): + return x * 2.0 + """ + + valid, errors, warnings = validate_kernel_static( + code, + backend="triton", + precision="fp16", + forbidden=["code_bypass"], + warnings=["precision_downgrade"] + ) + + assert isinstance(valid, bool) + assert isinstance(errors, list) + assert isinstance(warnings, list) + + +# ============================================================================ +# Test Precision Check Integration +# ============================================================================ + +def test_precision_check_in_warnings_by_default(): + """Test that precision_downgrade is in warnings by default.""" + code = """ + def forward(self, x): + x = x.half() + return x + """ + + valid, errors, warnings = validate_kernel_static(code, precision="fp32") + + # precision_downgrade should be in WARNING_CHECKS by default + # So it should produce warnings, not errors + all_messages = errors + warnings + has_precision_msg = any("precision" in msg.lower() or "fp16" in msg.lower() + for msg in all_messages) + + if has_precision_msg: + # If detected, should be in warnings, not errors (by default) + precision_in_warnings = any("precision" in msg.lower() or "fp16" in msg.lower() + for msg in warnings) + assert precision_in_warnings, "Precision downgrade should be in warnings by default" + + +def test_precision_check_respects_forbidden(): + """Test that precision_downgrade respects forbidden parameter.""" + code = """ + def forward(self, x): + x = x.half() + return x + """ + + # Make precision_downgrade forbidden + valid, errors, warnings = validate_kernel_static( + code, + precision="fp32", + forbidden=["precision_downgrade"], + warnings=[] # Remove from warnings + ) + + # Should produce errors, not warnings + has_precision_in_errors = any("precision" in msg.lower() or "fp16" in msg.lower() + for msg in errors) + + if has_precision_in_errors: + assert not valid, "Should be invalid when precision downgrade is forbidden" + assert len(errors) > 0, "Should have errors" + + +if __name__ == "__main__": + pytest.main([__file__, "-v"]) + From cfd1609c007e0d8d03e266c28c1538453989ef38 Mon Sep 17 00:00:00 2001 From: Omar Abul-Hassan <62859645+pythonomar22@users.noreply.github.com> Date: Tue, 6 Jan 2026 16:52:47 -0800 Subject: [PATCH 18/24] Dataset Object (#95) * before testing * fixing some syntax * fixing off by one error after testing * Remove timing JSONs from PR and ignore them * fallback correcting * better abstractions on the dataset object * refactor many old and unreliable list based dataset fetching * validated dataset is working (validated on Modal setup only due to no local GPU) * my fault fixing the key * fixed everything except paths issue * fixed inspection scripts * fixing dependencies --------- Co-authored-by: Simon Zirui Guo Co-authored-by: ethanboneh Co-authored-by: Simon Guo --- .env.example | 2 +- scripts/benchmark_eval_analysis.py | 45 +- scripts/eval_from_generations.py | 85 +-- scripts/generate_and_eval_single_sample.py | 54 +- .../generate_and_eval_single_sample_modal.py | 44 +- scripts/generate_baseline_time.py | 38 +- scripts/generate_baseline_time_modal.py | 34 +- scripts/generate_samples.py | 63 +- scripts/inspect_baseline.py | 13 +- scripts/inspect_triton.py | 62 +- scripts/run_and_check.py | 34 +- scripts/verify_bench.py | 59 +- src/kernelbench/dataset.py | 549 ++++++++++++++++-- src/kernelbench/eval.py | 40 +- src/kernelbench/frameworks.py | 1 - src/kernelbench/timing.py | 10 +- src/kernelbench/unit_tests/test_dataset.py | 325 ++++++++++- src/kernelbench/utils.py | 1 - 18 files changed, 1025 insertions(+), 434 deletions(-) diff --git a/.env.example b/.env.example index 2150e6d9..b31c503f 100644 --- a/.env.example +++ b/.env.example @@ -9,7 +9,7 @@ OPENAI_API_KEY=sk-... ANTHROPIC_API_KEY=sk-ant-api03-... # Google Gemini -GEMINI_API_KEY=... +GEMINI_API_KEY= # DeepSeek DEEPSEEK_API_KEY=sk-... diff --git a/scripts/benchmark_eval_analysis.py b/scripts/benchmark_eval_analysis.py index ec950b03..4df4e30b 100644 --- a/scripts/benchmark_eval_analysis.py +++ b/scripts/benchmark_eval_analysis.py @@ -53,7 +53,7 @@ def patch(eval_results, dataset): """ Patch the eval results with the dataset """ - for pid in range(1, len(dataset) + 1): + for pid in dataset.get_problem_ids(): if str(pid) not in eval_results: eval_results[str(pid)] = { "sample_id": 0, @@ -161,19 +161,40 @@ def analyze_greedy_eval(run_name, hardware, baseline, level, ) # Extract the speedup values - is_correct = np.array([entry["correctness"] for entry in eval_results.values()]) - baseline_speed = np.array( - [entry["mean"] for entry in baseline_results[f"level{level}"].values()] - ) - actual_speed = np.array([entry["runtime"] for entry in eval_results.values()]) + is_correct_list = [] + baseline_speed_list = [] + actual_speed_list = [] + + # Sort problem IDs to ensure consistent order + sorted_pids = sorted(dataset.get_problem_ids()) + + for pid in sorted_pids: + # Get eval result + if str(pid) not in eval_results: + print(f"Warning: Problem {pid} not found in eval results") + continue + eval_entry = eval_results[str(pid)] + + # Get baseline result + problem = dataset.get_problem_by_id(pid) + problem_name = problem.name + + if problem_name not in baseline_results[f"level{level}"]: + print(f"Warning: Problem {problem_name} not found in baseline results") + continue + + baseline_entry = baseline_results[f"level{level}"][problem_name] + + is_correct_list.append(eval_entry["correctness"]) + actual_speed_list.append(eval_entry["runtime"]) + baseline_speed_list.append(baseline_entry["mean"]) + + is_correct = np.array(is_correct_list) + baseline_speed = np.array(baseline_speed_list) + actual_speed = np.array(actual_speed_list) n = len(is_correct) - assert ( - len(baseline_speed) == n - ), "Baseline speedup values do not match the number of eval results" - assert ( - len(actual_speed) == n - ), "Actual speedup values do not match the number of eval results" + print(f"Aligned {n} problems for analysis") # Calculate the metrics gmsr_correct = geometric_mean_speed_ratio_correct_only( diff --git a/scripts/eval_from_generations.py b/scripts/eval_from_generations.py index 9fd8d745..247410f3 100644 --- a/scripts/eval_from_generations.py +++ b/scripts/eval_from_generations.py @@ -12,7 +12,6 @@ import pydra import torch -from datasets import load_dataset from pydra import Config, REQUIRED # Import only what we need @@ -255,36 +254,17 @@ def evaluate_single_sample_modal( def fetch_ref_arch_from_problem_id( - dataset, problem_id: int, dataset_src: str + dataset, problem_id: int, dataset_src: str = None ) -> str | None: """ - Fetch reference architecture from problem directory - Either from Hugging Face or Local Dataset + Fetch reference architecture from problem directory. + Uses the unified dataset interface. + + Note: dataset_src parameter is kept for backward compatibility but ignored + since the dataset object already handles both sources. """ - if dataset_src == "huggingface": - curr_problem_row = dataset.filter( - lambda x: x["problem_id"] == problem_id, num_proc=None, desc=None - ) - ref_arch_src = curr_problem_row["code"][0] - problem_name = curr_problem_row["name"][0] - - elif dataset_src == "local": - problem_idx_in_dataset = ( - problem_id - 1 - ) # due to dataset list being 0-indexed locally - ref_arch_path = dataset[problem_idx_in_dataset] - - problem_name = os.path.basename(ref_arch_path) - ref_arch_src = read_file(ref_arch_path) - - # verify - # Extract problem number from problem name (e.g. "1" from "1_Square_matrix_multiplication_.py") - problem_number = int(problem_name.split("_")[0]) - assert ( - problem_number == problem_id - ), f"Problem number in filename ({problem_number}) does not match config problem_id ({problem_id})" - - return ref_arch_src + problem = dataset.get_problem_by_id(problem_id) + return problem.code def fetch_kernel_from_disk( @@ -822,57 +802,48 @@ def main(config: EvalConfig): if mp.get_start_method(allow_none=True) is None: mp.set_start_method("spawn") - # Dataset Configurations - if config.dataset_src == "huggingface": - dataset = load_dataset(config.dataset_name) - curr_level_dataset = dataset[f"level_{config.level}"] - elif config.dataset_src == "local": - curr_level_dataset = construct_kernelbench_dataset(config.level) - - num_problems_in_level = len(curr_level_dataset) - - # Determine which problem IDs to evaluate - # you can either specify a list of problem IDs (prioritize) or a subset range - # NOTE: later once the dataset PR is in we will link the representative subset as a built-in preset too - if config.problem_ids is not None: - # Use specific problem IDs if provided - problem_id_list = config.problem_ids - for pid in problem_id_list: - assert 1 <= pid <= num_problems_in_level, f"Problem ID {pid} out of range for Level {config.level}" - elif config.subset == (None, None): - problem_id_list = list(range(1, num_problems_in_level + 1)) + # Dataset Configurations - Unified loading + dataset = construct_kernelbench_dataset( + level=config.level, + source=config.dataset_src, + dataset_name=config.dataset_name, + ) + + all_problem_ids = dataset.get_problem_ids() + + if config.subset == (None, None): + problem_ids_to_run = all_problem_ids else: - assert ( - config.subset[0] >= 1 and config.subset[1] <= num_problems_in_level - ), f"Subset range {config.subset} out of range for Level {config.level}" - problem_id_list = list(range(config.subset[0], config.subset[1] + 1)) + start, end = config.subset + problem_ids_to_run = [pid for pid in all_problem_ids if start <= pid <= end] + if not problem_ids_to_run: + print(f"Warning: No problems found in subset range {config.subset}") print( - f"Evaluating {config.num_samples_per_problem} sample(s) each for level {config.level} problems: {problem_id_list}" + f"Evaluating {config.num_samples_per_problem} sample(s) each for level {config.level} problems: {problem_ids_to_run}" ) run_dir = os.path.join(config.runs_dir, config.run_name) eval_file_path = os.path.join(run_dir, f"eval_results.json") # To Debug - # single_eval_example(config, curr_level_dataset, run_dir, eval_file_path) + # single_eval_example(config, dataset, run_dir, eval_file_path) total_work = [] - for problem_id in problem_id_list: + for problem_id in problem_ids_to_run: for sample_id in range(config.num_samples_per_problem): if not check_if_eval_exists_local(problem_id, sample_id, eval_file_path): total_work.append((problem_id, sample_id)) print( f"Start evaluation on {len(total_work)} unevaluated samples" - f" for problems: {problem_id_list}" + f" in range: {problem_ids_to_run}" ) # Build Cache on CPU as that is faster (only for local mode) if config.build_cache and config.eval_mode == "local": compile.batch_compile(total_work, config.to_dict()) - # Batch Eval on multiple GPUs in parallel - batch_eval(total_work, config, curr_level_dataset, run_dir, eval_file_path) + batch_eval(total_work, config, dataset, run_dir, eval_file_path) # Calculate pass@k metrics if multiple samples per problem were evaluated if config.num_samples_per_problem > 1: diff --git a/scripts/generate_and_eval_single_sample.py b/scripts/generate_and_eval_single_sample.py index 0b571792..fce1b16f 100644 --- a/scripts/generate_and_eval_single_sample.py +++ b/scripts/generate_and_eval_single_sample.py @@ -5,16 +5,12 @@ import json import modal -from datasets import load_dataset - -from kernelbench.dataset import construct_kernelbench_dataset from kernelbench.eval import eval_kernel_against_ref from kernelbench.prompt_constructor_toml import get_prompt_for_backend, get_custom_prompt from kernelbench.utils import ( create_inference_server_from_presets, extract_first_code, query_server, - read_file, set_gpu_arch, ) from kernelbench.eval import get_torch_dtype_from_string @@ -118,13 +114,14 @@ def main(config: EvalConfig): print(f"Starting Eval with config: {config}") - # Configurations - - if config.dataset_src == "huggingface": - dataset = load_dataset(config.dataset_name) - curr_level_dataset = dataset[f"level_{config.level}"] - elif config.dataset_src == "local": - curr_level_dataset = construct_kernelbench_dataset(config.level) + # Configurations - Unified dataset loading (works for both HF and local) + from kernelbench.dataset import construct_kernelbench_dataset + + dataset = construct_kernelbench_dataset( + level=config.level, + source=config.dataset_src, + dataset_name=config.dataset_name, + ) if config.gpu_arch: set_gpu_arch(config.gpu_arch) # otherwise build for all architectures @@ -133,41 +130,16 @@ def main(config: EvalConfig): os.makedirs(config.logdir, exist_ok=True) # Problem Checks - num_problems = len(curr_level_dataset) + num_problems = len(dataset) print(f"Number of problems in Level {config.level}: {num_problems}") print( f"Start Generation + Evaluation for Level {config.level} Problem {config.problem_id}" ) - assert ( - config.problem_id <= num_problems - ), f"Problem ID {config.problem_id} out of range for Level {config.level}" - - # TODO: refactor dataset fetching logic to be as clean as posisble. - # 1. Fetch Problem - if config.dataset_src == "huggingface": - - curr_problem_row = curr_level_dataset.filter( - lambda x: x["problem_id"] == config.problem_id - ) - ref_arch_src = curr_problem_row["code"][0] - problem_name = curr_problem_row["name"][0] - - elif config.dataset_src == "local": - problem_idx_in_dataset = ( - config.problem_id - 1 - ) # due to dataset list being 0-indexed locally - ref_arch_path = curr_level_dataset[problem_idx_in_dataset] - - problem_name = os.path.basename(ref_arch_path) - ref_arch_src = read_file(ref_arch_path) - # import pdb; pdb.set_trace() - - # Extract problem number from problem name (e.g. "1" from "1_Square_matrix_multiplication_.py") - problem_number = int(problem_name.split("_")[0]) - assert ( - problem_number == config.problem_id - ), f"Problem number in filename ({problem_number}) does not match config problem_id ({config.problem_id})" + # Fetch problem - unified interface, no branching needed + problem = dataset.get_problem_by_id(config.problem_id) + ref_arch_src = problem.code + problem_name = problem.name # 2. Generate Sample # Create inference function with config parameters diff --git a/scripts/generate_and_eval_single_sample_modal.py b/scripts/generate_and_eval_single_sample_modal.py index 2a8e6aba..7308d228 100644 --- a/scripts/generate_and_eval_single_sample_modal.py +++ b/scripts/generate_and_eval_single_sample_modal.py @@ -11,10 +11,8 @@ import json import modal -from datasets import load_dataset - -#from src.dataset import construct_kernelbench_dataset -from kernelbench.utils import extract_first_code, query_server, set_gpu_arch, read_file, create_inference_server_from_presets +from kernelbench.dataset import construct_kernelbench_dataset +from kernelbench.utils import extract_first_code, query_server, set_gpu_arch, create_inference_server_from_presets app = modal.App("eval_single_sample") @@ -157,41 +155,25 @@ def main(config: EvalConfig): print(f"Starting Eval with config: {config}") - # Configurations - - if config.dataset_src == "huggingface": - dataset = load_dataset(config.dataset_name) - curr_level_dataset = dataset[f"level_{config.level}"] + # Configurations - Unified dataset loading (works for both HF and local) + dataset = construct_kernelbench_dataset( + level=config.level, + source=config.dataset_src, + dataset_name=config.dataset_name, + ) if config.log: os.makedirs(config.logdir, exist_ok=True) # Problem Checks - num_problems = len(curr_level_dataset) + num_problems = len(dataset) print(f"Number of problems in Level {config.level}: {num_problems}") print(f"Start Generation + Evaluation for Level {config.level} Problem {config.problem_id}") - assert config.problem_id <= num_problems, f"Problem ID {config.problem_id} out of range for Level {config.level}" - - - # 1. Fetch Problem - if config.dataset_src == "huggingface": - - curr_problem_row = curr_level_dataset.filter(lambda x: x["problem_id"] == config.problem_id) - ref_arch_src = curr_problem_row["code"][0] - problem_name = curr_problem_row["name"][0] - - elif config.dataset_src == "local": - problem_idx_in_dataset = config.problem_id - 1 # due to dataset list being 0-indexed locally - ref_arch_path = curr_level_dataset[problem_idx_in_dataset] - - problem_name = os.path.basename(ref_arch_path) - ref_arch_src = read_file(ref_arch_path) - # import pdb; pdb.set_trace() - - # Extract problem number from problem name (e.g. "1" from "1_Square_matrix_multiplication_.py") - problem_number = int(problem_name.split("_")[0]) - assert problem_number == config.problem_id, f"Problem number in filename ({problem_number}) does not match config problem_id ({config.problem_id})" + # Fetch problem - unified interface, no branching needed + problem = dataset.get_problem_by_id(config.problem_id) + ref_arch_src = problem.code + problem_name = problem.name # 2. Generate Sample diff --git a/scripts/generate_baseline_time.py b/scripts/generate_baseline_time.py index 2d992d1e..a2c96a03 100644 --- a/scripts/generate_baseline_time.py +++ b/scripts/generate_baseline_time.py @@ -9,7 +9,7 @@ get_timing_function, get_timing_stats, ) -from kernelbench.dataset import construct_problem_dataset_from_problem_dir +from kernelbench.dataset import construct_kernelbench_dataset, fetch_ref_arch_from_dataset from kernelbench.utils import read_file import os import json @@ -48,32 +48,6 @@ TIMING_DIR = os.path.join(REPO_TOP_PATH, "results", "timing") -def fetch_ref_arch_from_dataset(dataset: list[str], - problem_id: int) -> tuple[str, str, str]: - """ - Fetch the reference architecture from the problem directory - problem_id should be logical index (1-indexed), matching the problem_id in the problem_name - - Returns: - ref_arch_path: str, the path to the reference architecture - ref_arch_name: str, the name of the reference architecture - ref_arch_src: str, the source code of the reference architecture - """ - ref_arch_path = None - - for file in dataset: - if file.split("/")[-1].split("_")[0] == str(problem_id): - ref_arch_path = file - break - if ref_arch_path is None: - raise ValueError(f"No reference architecture found for problem_id {problem_id}") - - ref_arch_src = read_file(ref_arch_path) - - ref_arch_name = ref_arch_path.split("/")[-1] - return (ref_arch_path, ref_arch_name, ref_arch_src) - - def measure_program_time( ref_arch_name: str, ref_arch_src: str, @@ -149,12 +123,11 @@ def record_baseline_times(use_torch_compile: bool = False, json_results = {} for level in [1, 2, 3]: - PROBLEM_DIR = os.path.join(KERNEL_BENCH_PATH, "level" + str(level)) - dataset = construct_problem_dataset_from_problem_dir(PROBLEM_DIR) + dataset = construct_kernelbench_dataset(level) json_results[f"level{level}"] = {} num_problems = len(dataset) - for problem_id in tqdm(range(1, num_problems + 1)): + for problem_id in tqdm(dataset.get_problem_ids()): ref_arch_path, ref_arch_name, ref_arch_src = fetch_ref_arch_from_dataset(dataset, problem_id) runtime_stats = measure_program_time( ref_arch_name=ref_arch_name, @@ -180,8 +153,7 @@ def test_measure_particular_program(level_num: int, problem_id: int): """ device = torch.device("cuda:0") - PROBLEM_DIR = os.path.join(KERNEL_BENCH_PATH, "level" + str(level_num)) - dataset = construct_problem_dataset_from_problem_dir(PROBLEM_DIR) + dataset = construct_kernelbench_dataset(level_num) ref_arch_path, ref_arch_name, ref_arch_src = fetch_ref_arch_from_dataset(dataset, problem_id) @@ -255,7 +227,7 @@ def get_time_old(level_num, problem_id, num_trials=100, torch_compile=False): ref_arch_name, ref_arch_src = fetch_ref_arch_from_level_problem_id( level_num, problem_id, with_name=True ) - ref_arch_name = ref_arch_name.split("/")[-1] + ref_arch_name = os.path.basename(ref_arch_name) context = {} Model, get_init_inputs, get_inputs = load_original_model_and_inputs( ref_arch_src, context diff --git a/scripts/generate_baseline_time_modal.py b/scripts/generate_baseline_time_modal.py index 37bda8ae..22bdb1b0 100644 --- a/scripts/generate_baseline_time_modal.py +++ b/scripts/generate_baseline_time_modal.py @@ -9,7 +9,7 @@ time_execution_with_cuda_event, get_timing_stats, ) -from kernelbench.dataset import construct_problem_dataset_from_problem_dir +from kernelbench.dataset import construct_kernelbench_dataset, fetch_ref_arch_from_dataset from kernelbench.utils import read_file import os import json @@ -125,31 +125,6 @@ def write_batch_to_json(entries_to_write: list, f_path: str): print(f"[INFO] Wrote {len(entries_to_write)} entries to {f_path}") -def fetch_ref_arch_from_dataset(dataset: list[str], - problem_id: int) -> tuple[str, str, str]: - """ - Fetch the reference architecture from the problem directory - problem_id should be logical index (1-indexed), matching the problem_id in the problem_name - - Returns: - ref_arch_path: str, the path to the reference architecture - ref_arch_name: str, the name of the reference architecture - ref_arch_src: str, the source code of the reference architecture - """ - ref_arch_path = None - - for file in dataset: - if file.split("/")[-1].split("_")[0] == str(problem_id): - ref_arch_path = file - break - if ref_arch_path is None: - raise ValueError(f"No reference architecture found for problem_id {problem_id}") - - ref_arch_src = read_file(ref_arch_path) - - ref_arch_name = ref_arch_path.split("/")[-1] - return (ref_arch_path, ref_arch_name, ref_arch_src) - @app.cls(image=image, scaledown_window=5) class EvalFunc: @@ -223,10 +198,9 @@ def record_baseline_times(config: BaselineConfig, json_results = [] level = config.level - PROBLEM_DIR = os.path.join(KERNEL_BENCH_PATH, "level" + str(level)) - dataset = construct_problem_dataset_from_problem_dir(PROBLEM_DIR) + dataset = construct_kernelbench_dataset(level) num_problems = len(dataset) - total_work = [(i, *fetch_ref_arch_from_dataset(dataset, i)) for i in list(range(1, num_problems + 1))] + total_work = [(i, *fetch_ref_arch_from_dataset(dataset, i)) for i in dataset.get_problem_ids()] batch_size = config.num_gpu_devices print(f"[Modal] Processing {len(total_work)} problems in parallel batches of {batch_size}") @@ -330,7 +304,7 @@ def get_time_old(level_num, problem_id, num_trials=100, torch_compile=False): ref_arch_name, ref_arch_src = fetch_ref_arch_from_level_problem_id( level_num, problem_id, with_name=True ) - ref_arch_name = ref_arch_name.split("/")[-1] + ref_arch_name = os.path.basename(ref_arch_name) context = {} Model, get_init_inputs, get_inputs = load_original_model_and_inputs( ref_arch_src, context diff --git a/scripts/generate_samples.py b/scripts/generate_samples.py index 40d718f8..2c01ee8d 100644 --- a/scripts/generate_samples.py +++ b/scripts/generate_samples.py @@ -5,7 +5,6 @@ import pydra import torch -from datasets import load_dataset from pydra import Config, REQUIRED from kernelbench.dataset import construct_kernelbench_dataset @@ -15,7 +14,6 @@ create_inference_server_from_presets, extract_first_code, maybe_multithread, - read_file, set_gpu_arch, ) from kernelbench.kernel_static_checker import validate_kernel_static @@ -46,7 +44,7 @@ def __init__(self): self.subset = ( None, None, - ) # (problem_id, problem_name), these are the logical index + ) # (start_id, end_id), both inclusive - logical 1-indexed IDs self.run_name = REQUIRED # name of the run @@ -108,29 +106,10 @@ def generate_sample_single( inference_server: callable, run_dir: str, ) -> bool: - # 1. Fetch Problem - if config.dataset_src == "huggingface": - curr_problem_row = dataset.filter( - lambda x: x["problem_id"] == work.problem_id, desc=None - ) - - ref_arch_src = curr_problem_row["code"][0] - problem_name = curr_problem_row["name"][0] - - elif config.dataset_src == "local": - problem_idx_in_dataset = ( - work.problem_id - 1 - ) # due to dataset list being 0-indexed locally - ref_arch_path = dataset[problem_idx_in_dataset] - - problem_name = os.path.basename(ref_arch_path) - ref_arch_src = read_file(ref_arch_path) - - # Extract problem number from problem name (e.g. "1" from "1_Square_matrix_multiplication_.py") - problem_number = int(problem_name.split("_")[0]) - assert ( - problem_number == work.problem_id - ), f"Problem number in filename ({problem_number}) does not match config problem_id ({config.problem_id})" + # 1. Fetch Problem - unified interface + problem = dataset.get_problem_by_id(work.problem_id) + ref_arch_src = problem.code + problem_name = problem.name if config.custom_prompt_key: custom_prompt = get_custom_prompt( @@ -281,25 +260,25 @@ def main(config: GenerationConfig): print(f"Starting Batch Generation with config: {config}") - # Dataset Configurations - if config.dataset_src == "huggingface": - dataset = load_dataset(config.dataset_name) - curr_level_dataset = dataset[f"level_{config.level}"] - elif config.dataset_src == "local": - curr_level_dataset = construct_kernelbench_dataset(config.level) + # Dataset Configurations - Unified loading + dataset = construct_kernelbench_dataset( + level=config.level, + source=config.dataset_src, + dataset_name=config.dataset_name, + ) - num_problems_in_level = len(curr_level_dataset) + all_problem_ids = dataset.get_problem_ids() if config.subset == (None, None): - problem_id_range = range(1, num_problems_in_level) + problem_ids_to_run = all_problem_ids else: - assert ( - config.subset[0] >= 1 and config.subset[1] <= num_problems_in_level - ), f"Subset range {config.subset} out of range for Level {config.level}" - problem_id_range = range(config.subset[0], config.subset[1]) + start, end = config.subset + problem_ids_to_run = [pid for pid in all_problem_ids if start <= pid <= end] + if not problem_ids_to_run: + print(f"Warning: No problems found in subset range {config.subset}") print( - f"Generating {config.num_samples} sample(s) each for level {config.level} problems: {problem_id_range}" + f"Generating {config.num_samples} sample(s) each for level {config.level} problems: {problem_ids_to_run}" ) # set up run directory @@ -318,9 +297,7 @@ def main(config: GenerationConfig): problems_to_run = [] total_problems = 0 already_completed = 0 - for problem_id in range( - problem_id_range.start, problem_id_range.stop + 1 - ): # end index is inclusive + for problem_id in problem_ids_to_run: for sample_id in range(config.num_samples): total_problems += 1 if not check_kernel_exists(run_dir, config.level, problem_id, sample_id): @@ -354,7 +331,7 @@ def main(config: GenerationConfig): time_interval=config.api_query_interval, # extra args config=config, - dataset=curr_level_dataset, + dataset=dataset, inference_server=inference_server, run_dir=run_dir, ) diff --git a/scripts/inspect_baseline.py b/scripts/inspect_baseline.py index 9f9f6b7c..aeac959d 100644 --- a/scripts/inspect_baseline.py +++ b/scripts/inspect_baseline.py @@ -5,12 +5,10 @@ import numpy as np from kernelbench.eval import ( load_original_model_and_inputs, - time_execution_with_cuda_event, - get_timing_stats, set_seed, fetch_ref_arch_from_problem_id, ) -from kernelbench.dataset import construct_problem_dataset_from_problem_dir +from kernelbench.dataset import construct_kernelbench_dataset import os, sys import logging import json @@ -93,15 +91,15 @@ def emit(self, record): separator("") def fetch_ref_arch_from_level_problem_id(level_num, problem_id, with_name=False): - PROBLEM_DIR = os.path.join(KERNEL_BENCH_PATH, "level" + str(level_num)) - dataset = construct_problem_dataset_from_problem_dir(PROBLEM_DIR) + dataset = construct_kernelbench_dataset(level_num) return fetch_ref_arch_from_problem_id(problem_id, dataset, with_name) def inspect_torch_compile_triton(level_num, problem_id): ref_arch_name, ref_arch_src = fetch_ref_arch_from_level_problem_id( level_num, problem_id, with_name=True ) - ref_arch_name = ref_arch_name.split("/")[-1] + # Extract filename from path (works for both full paths and filenames) + ref_arch_name = os.path.basename(ref_arch_name) context = {} Model, get_init_inputs, get_inputs = load_original_model_and_inputs( ref_arch_src, context @@ -116,7 +114,8 @@ def inspect_baseline_torch_compile(level_num, problem_id): level_num, problem_id, with_name=True ) - ref_arch_name = ref_arch_name.split("/")[-1] + # Extract filename from path (works for both full paths and filenames) + ref_arch_name = os.path.basename(ref_arch_name) context = {} Model, get_init_inputs, get_inputs = load_original_model_and_inputs( ref_arch_src, context diff --git a/scripts/inspect_triton.py b/scripts/inspect_triton.py index f76e1950..56fe6a23 100644 --- a/scripts/inspect_triton.py +++ b/scripts/inspect_triton.py @@ -21,41 +21,28 @@ from kernelbench.eval import ( load_custom_model, load_original_model_and_inputs, - time_execution_with_cuda_event, get_timing_stats, set_seed, ) -def fetch_ref_arch_from_dataset(dataset: list[str], - problem_id: int) -> tuple[str, str, str]: - """ - Fetch the reference architecture from the problem directory - problem_id should be logical index (1-indexed), matching the problem_id in the problem_name +from kernelbench.timing import time_execution_with_cuda_event +from kernelbench.dataset import construct_kernelbench_dataset, fetch_ref_arch_from_dataset, BaseDataset - Returns: - ref_arch_path: str, the path to the reference architecture - ref_arch_name: str, the name of the reference architecture - ref_arch_src: str, the source code of the reference architecture - """ - ref_arch_path = None - - for file in dataset: - if file.split("/")[-1].split("_")[0] == str(problem_id): - ref_arch_path = file - break - if ref_arch_path is None: - raise ValueError(f"No reference architecture found for problem_id {problem_id}") - - ref_arch_src = read_file(ref_arch_path) - - ref_arch_name = ref_arch_path.split("/")[-1] - return (ref_arch_path, ref_arch_name, ref_arch_src) - - -def run_profile_and_save_trace(dataset: list[str], problem_id: int, num_trials=10): - """ - Helper function to get Torch Profile of a problem - # TODO: Fix up this function + +def run_profile_and_save_trace( + dataset: BaseDataset, + problem_id: int, + num_trials: int = 10 +) -> None: + """Helper function to get Torch Profile of a problem. + + Args: + dataset: BaseDataset object + problem_id: Problem ID to profile + num_trials: Number of profiling trials to run (default: 10) + + Note: + Saves trace files to 'trace_non_compiled.json' and 'trace_compiled.json' """ ref_arch_path, ref_arch_name, ref_arch_src = fetch_ref_arch_from_dataset( dataset, problem_id @@ -120,12 +107,19 @@ def run_profile_and_save_trace(dataset: list[str], problem_id: int, num_trials=1 # except Exception as e: # print(f"[Eval] Error in Measuring Performance: {e}") -def get_torch_compile_triton(level_num, problem_id): - """ - Get the triton code generated by torch compile for a particular problem +def get_torch_compile_triton(level_num: int, problem_id: int) -> str: + """Get the triton code generated by torch compile for a particular problem. + + Args: + level_num: KernelBench level (1, 2, or 3) + problem_id: Problem ID to inspect + + Returns: + str: Name of the reference architecture """ + dataset = construct_kernelbench_dataset(level_num) ref_arch_path, ref_arch_name, ref_arch_src = fetch_ref_arch_from_dataset( - dataset, problem_id, with_name=True + dataset, problem_id ) context = {} # import pdb; pdb.set_trace() diff --git a/scripts/run_and_check.py b/scripts/run_and_check.py index 8d150b7c..d253dd45 100644 --- a/scripts/run_and_check.py +++ b/scripts/run_and_check.py @@ -3,7 +3,6 @@ import pydra from pydra import REQUIRED, Config import os -from datasets import load_dataset import modal from kernelbench import eval as kernel_eval @@ -92,6 +91,7 @@ def __init__(self): # ref_origin is local, specify local file path self.ref_arch_src_path = "" # ref_origin is kernelbench, specify level and problem id + self.dataset_src = "huggingface" # either huggingface or local self.dataset_name = "ScalingIntelligence/KernelBench" self.level = "" self.problem_id = "" @@ -258,27 +258,23 @@ def main(config: ScriptConfig): if config.ref_origin == "local": assert config.ref_arch_src_path != "", "ref_arch_src_path is required" ref_arch_src = read_file(config.ref_arch_src_path) + print(f"Loaded reference from local file: {config.ref_arch_src_path}") elif config.ref_origin == "kernelbench": - assert config.dataset_name != "", "dataset_name is required" + from kernelbench.dataset import construct_kernelbench_dataset + assert config.level != "", "level is required" assert config.problem_id != "", "problem_id is required" - - # for now use the HuggingFace dataset - dataset = load_dataset(config.dataset_name) - curr_level_dataset = dataset[f"level_{config.level}"] - - curr_problem_row = curr_level_dataset.filter(lambda x: x["problem_id"] == config.problem_id) - ref_arch_src = curr_problem_row["code"][0] - problem_name = curr_problem_row["name"][0] - - problem_number = int(problem_name.split("_")[0]) - assert problem_number == config.problem_id, f"Problem number in filename ({problem_number}) does not match config problem_id ({config.problem_id})" - - print(f"Fetched problem {config.problem_id} from KernelBench level {config.level}: {problem_name}") - - - else: - raise ValueError("Invalid ref_origin") + + # Unified interface - same code for huggingface and local! + dataset = construct_kernelbench_dataset( + level=int(config.level), + source=config.dataset_src, + dataset_name=config.dataset_name, + ) + problem = dataset.get_problem_by_id(int(config.problem_id)) + ref_arch_src = problem.code + + print(f"Fetched problem {problem.problem_id} from KernelBench level {problem.level}: {problem.name}") kernel_src = read_file(config.kernel_src_path) diff --git a/scripts/verify_bench.py b/scripts/verify_bench.py index 5fdc6862..369a25e2 100644 --- a/scripts/verify_bench.py +++ b/scripts/verify_bench.py @@ -71,37 +71,46 @@ def run(Model, NewModel, get_inputs, get_init_inputs, seed=1012): return check_correctness(Model, NewModel, get_inputs, get_init_inputs, seed) -def run_all(directory): - print(f"Running {directory}") +from kernelbench.dataset import construct_kernelbench_dataset + +def run_all(level): + print(f"Running Level {level}") + dataset = construct_kernelbench_dataset(level) total = 0 passed = 0 fail_tests = [] - abs_path = os.path.abspath(directory) - for filename in os.listdir(abs_path): - if filename.endswith(".py"): - total += 1 - module_name = filename[:-3] # Remove .py extension - try: - # Dynamically import the module - spec = importlib.util.spec_from_file_location( - module_name, os.path.join(abs_path, filename) + + for problem in dataset: + total += 1 + module_name = problem.name.replace(".py", "") + try: + problem_path = getattr(problem, "path", None) + if not problem_path: + raise ValueError( + f"Problem '{module_name}' does not have a local file path; " + "verify_bench.py only supports local datasets." ) - module = importlib.util.module_from_spec(spec) - spec.loader.exec_module(module) - # Get the required attributes from the module - Model = getattr(module, "Model") - get_inputs = getattr(module, "get_inputs") - get_init_inputs = getattr(module, "get_init_inputs") - assert run(Model, Model, get_inputs, get_init_inputs) - passed += 1 - except Exception as e: - fail_tests.append(module_name) - print(f"{directory}: {passed}/{total} passed") + # Dynamically import the module + spec = importlib.util.spec_from_file_location( + module_name, problem_path + ) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + # Get the required attributes from the module + Model = getattr(module, "Model") + get_inputs = getattr(module, "get_inputs") + get_init_inputs = getattr(module, "get_init_inputs") + assert run(Model, Model, get_inputs, get_init_inputs) + passed += 1 + except Exception as e: + print(f"Failed {module_name}: {e}") + fail_tests.append(module_name) + print(f"Level {level}: {passed}/{total} passed") if len(fail_tests) > 0: print(f"Failed tests: {fail_tests}") if __name__ == "__main__": - run_all(KERNEL_BENCH_PATH + "/level1") - run_all(KERNEL_BENCH_PATH + "/level2") - run_all(KERNEL_BENCH_PATH + "/level3") + run_all(1) + run_all(2) + run_all(3) diff --git a/src/kernelbench/dataset.py b/src/kernelbench/dataset.py index 29bea818..7f0e8b22 100644 --- a/src/kernelbench/dataset.py +++ b/src/kernelbench/dataset.py @@ -1,7 +1,13 @@ ################################################################################ -# Helpers for Dataset +# Unified Dataset Abstraction for KernelBench +# +# Supports both local filesystem and HuggingFace datasets through a unified +# interface. All problem access is by logical problem_id (1-indexed). ################################################################################ +from abc import ABC, abstractmethod +from dataclasses import dataclass +from typing import Iterator, Optional import os import random import re @@ -16,86 +22,491 @@ KERNEL_BENCH_PATH = os.path.join(REPO_TOP_PATH, "KernelBench") -def assign_problem_hash(problem_path: str) -> list[int]: - """ - Assign a unique hash to a problem in the dataset +################################################################################ +# Problem Dataclass +################################################################################ + +@dataclass +class Problem: + """Unified representation of a KernelBench problem. + + Attributes: + problem_id: 1-indexed logical ID (matches filename prefix) + name: Filename, e.g., "1_Square_matrix_multiplication_.py" + code: The actual source code + level: KernelBench level (1, 2, 3, or custom) + path: Local filesystem path (None if from HuggingFace) + metadata: Extra metadata for future use (e.g., categories, difficulty) + + Note: + Code is loaded eagerly when the dataset is constructed (~500KB for level 1). + If memory becomes a concern for very large datasets, this could be refactored + to lazy loading where code is only read when Problem.code is accessed. """ - with open(problem_path, "r") as f: - problem_src = f.read() - return get_code_hash(problem_src) + problem_id: int + name: str + code: str + level: int + path: Optional[str] = None + metadata: Optional[dict] = None + @property + def hash(self) -> str: + """Compute code hash for problem identification. + + The hash ignores comments and whitespace, so functionally + equivalent code produces the same hash. Useful for: + - Deduplication across dataset versions + - Tracking problem identity when code formatting changes + - Comparing local vs HuggingFace versions + """ + return get_code_hash(self.code) -def get_code_hash(problem_src: str) -> str: - """ - Assign a unique hash to some piece of code - Important to strip out the comments and whitespace as they are not functionally part of the code - """ - # Remove multi-line comments first - problem_src = re.sub(r'"""[\s\S]*?"""|\'\'\'[\s\S]*?\'\'\'', "", problem_src) + +################################################################################ +# Hash Utilities +################################################################################ + +def get_code_hash(code: str) -> str: + """Compute a unique hash for code, ignoring comments and whitespace.""" + # Remove multi-line comments + code = re.sub(r'"""[\s\S]*?"""|\'\'\'[\s\S]*?\'\'\'', "", code) # Remove inline comments and all whitespace - cleaned_problem_src = re.sub(r"#.*$|\s+", "", problem_src, flags=re.MULTILINE) - # hash only on code - return hashlib.md5(cleaned_problem_src.encode()).hexdigest() + cleaned = re.sub(r"#.*$|\s+", "", code, flags=re.MULTILINE) + return hashlib.md5(cleaned.encode()).hexdigest() -def construct_problem_dataset_from_problem_dir(problem_dir: str) -> list[str]: +################################################################################ +# Base Dataset Abstract Class +################################################################################ + +class BaseDataset(ABC): + """Abstract base for all KernelBench datasets. + + Provides a unified interface for accessing problems by ID, + iteration, and length. """ - Construct a list of relative paths to all the python files in the problem directory - Sorted by the numerical prefix of the filenames + + @property + @abstractmethod + def level(self) -> int: + """Return the KernelBench level.""" + pass + + @abstractmethod + def __len__(self) -> int: + """Return the number of problems in the dataset.""" + pass + + @abstractmethod + def __iter__(self) -> Iterator[Problem]: + """Iterate over Problem objects in the dataset.""" + pass + + @abstractmethod + def get_problem_by_id(self, problem_id: int) -> Problem: + """Get problem by 1-indexed logical ID.""" + pass + + @abstractmethod + def get_problem_ids(self) -> list[int]: + """Get sorted list of all problem IDs in the dataset.""" + pass + + + def subset( + self, + problem_ids: Optional[list[int]] = None, + id_range: Optional[tuple[int, int]] = None, + ) -> "BaseDataset": + """Create a subset by problem IDs. + + Args: + problem_ids: Specific problem IDs to include (e.g., [1, 3, 5]) + id_range: (start_id, end_id) inclusive range of problem IDs + + Returns: + New dataset with only the specified problems + + Example: + >>> dataset.subset(problem_ids=[1, 3, 5]) + >>> dataset.subset(id_range=(1, 10)) + """ + raise NotImplementedError("Subclasses should implement subset()") + + def sample(self, n: int, seed: int = 42) -> "BaseDataset": + """Get a random sample of N problems. + + Args: + n: Number of problems to sample + seed: Random seed for reproducibility + + Returns: + New dataset with N randomly selected problems + """ + all_ids = self.get_problem_ids() + n = min(n, len(all_ids)) + random.seed(seed) + sampled_ids = random.sample(all_ids, n) + return self.subset(problem_ids=sorted(sampled_ids)) + + def get_representative_subset(self) -> "BaseDataset": + """Get a curated representative subset for quick iteration. + + Returns a diverse subset covering different problem categories + (matmul, conv, norms, etc.). Useful for testing. + """ + rep_ids = { + 1: [1, 3, 6, 18, 23, 26, 33, 36, 40, 42, 48, 54, 57, 65, 77, 82, 86, 87], + 2: [1, 2, 8, 18, 23, 28, 33, 43], + 3: [1, 5, 8, 11, 20, 21, 33, 38, 43], + } + + if self.level not in rep_ids: + raise ValueError(f"No representative subset for level {self.level}") + + available_ids = set(self.get_problem_ids()) + subset_ids = [pid for pid in rep_ids[self.level] if pid in available_ids] + + return self.subset(problem_ids=subset_ids) + + +################################################################################ +# Local Filesystem Dataset +################################################################################ + +class LocalKernelBenchDataset(BaseDataset): + """Dataset backed by local filesystem. + + Loads problems from KernelBench/level{N}/*.py + Flexible for any level number (1, 2, 3, or custom levels). """ - DATASET = [] - for file_name in os.listdir(problem_dir): - if file_name.endswith(".py"): - # TODO: revisit later to satisfy eval harnes - relative_path = os.path.join(problem_dir, file_name) - DATASET.append(relative_path) + def __init__( + self, + level: int, + base_path: str = KERNEL_BENCH_PATH, + problem_ids: Optional[list[int]] = None, + id_range: Optional[tuple[int, int]] = None, + ): + """Initialize local dataset. + + Args: + level: KernelBench level (any positive integer) + base_path: Path to KernelBench directory + problem_ids: Optional list of specific problem IDs to include + id_range: Optional (start_id, end_id) inclusive range + """ + if level < 1: + raise ValueError(f"level must be >= 1, got {level}") - # Sort the DATASET based on the numerical prefix of the filenames - DATASET.sort(key=lambda x: int(os.path.basename(x).split("_")[0])) + self._level = level + self._base_path = base_path + self._problems: dict[int, Problem] = {} + + # Build filter set from problem_ids and/or id_range + self._filter_ids = self._build_filter_set(problem_ids, id_range) + self._load_problems() - return DATASET + def _build_filter_set( + self, + problem_ids: Optional[list[int]], + id_range: Optional[tuple[int, int]], + ) -> Optional[set[int]]: + """Build a set of IDs to filter by, or None for no filtering.""" + if problem_ids is None and id_range is None: + return None + + filter_set = set() + if problem_ids: + filter_set.update(problem_ids) + if id_range: + start, end = id_range + filter_set.update(range(start, end + 1)) + return filter_set + @property + def level(self) -> int: + return self._level -def construct_kernelbench_dataset(level: int) -> list[str]: - return construct_problem_dataset_from_problem_dir( - os.path.join(KERNEL_BENCH_PATH, f"level{level}") - ) + def _load_problems(self): + problem_dir = os.path.join(self._base_path, f"level{self._level}") + + if not os.path.exists(problem_dir): + raise FileNotFoundError(f"Problem directory not found: {problem_dir}") + + for file_name in os.listdir(problem_dir): + if not file_name.endswith(".py"): + continue + + try: + problem_id = int(file_name.split("_")[0]) + except (ValueError, IndexError): + continue + + # Apply filter if specified + if self._filter_ids is not None and problem_id not in self._filter_ids: + continue + + path = os.path.join(problem_dir, file_name) + with open(path, "r") as f: + code = f.read() + + self._problems[problem_id] = Problem( + problem_id=problem_id, + name=file_name, + code=code, + level=self._level, + path=path, + ) + + def get_problem_by_id(self, problem_id: int) -> Problem: + if problem_id not in self._problems: + raise ValueError(f"Problem ID {problem_id} not found in dataset") + return self._problems[problem_id] + + def get_problem_ids(self) -> list[int]: + return sorted(self._problems.keys()) + + def __len__(self) -> int: + return len(self._problems) + def __iter__(self) -> Iterator[Problem]: + for pid in self.get_problem_ids(): + yield self._problems[pid] + + def __repr__(self) -> str: + return f"LocalKernelBenchDataset(level={self._level}, problems={len(self)})" + + def subset( + self, + problem_ids: Optional[list[int]] = None, + id_range: Optional[tuple[int, int]] = None, + ) -> "LocalKernelBenchDataset": + """Create a subset of this dataset.""" + return LocalKernelBenchDataset( + level=self._level, + base_path=self._base_path, + problem_ids=problem_ids, + id_range=id_range, + ) -KERNELBENCH_LEVEL_1_DATASET = construct_kernelbench_dataset(level=1) -KERNELBENCH_LEVEL_2_DATASET = construct_kernelbench_dataset(level=2) -KERNELBENCH_LEVEL_3_DATASET = construct_kernelbench_dataset(level=3) ################################################################################ -# Eval on Subsets of KernelBench +# HuggingFace Dataset ################################################################################ +class HuggingFaceKernelBenchDataset(BaseDataset): + """Dataset backed by HuggingFace datasets.""" -def get_kernelbench_subset( - level: int, num_subset_problems: int = 10, random_seed: int = 42 -) -> tuple[list[str], list[int]]: + def __init__( + self, + level: int, + dataset_name: str = "ScalingIntelligence/KernelBench", + problem_ids: Optional[list[int]] = None, + id_range: Optional[tuple[int, int]] = None, + ): + """Initialize HuggingFace dataset. + + Args: + level: KernelBench level (1, 2, or 3) + dataset_name: HuggingFace dataset identifier + problem_ids: Optional list of specific problem IDs to include + id_range: Optional (start_id, end_id) inclusive range + """ + if level not in [1, 2, 3]: + raise ValueError(f"HuggingFace dataset only has levels 1, 2, 3, got {level}") + + self._level = level + self._dataset_name = dataset_name + self._problems: dict[int, Problem] = {} + self._filter_ids = self._build_filter_set(problem_ids, id_range) + self._load_dataset() + + def _build_filter_set( + self, + problem_ids: Optional[list[int]], + id_range: Optional[tuple[int, int]], + ) -> Optional[set[int]]: + """Build a set of IDs to filter by, or None for no filtering.""" + if problem_ids is None and id_range is None: + return None + + filter_set = set() + if problem_ids: + filter_set.update(problem_ids) + if id_range: + start, end = id_range + filter_set.update(range(start, end + 1)) + return filter_set + + @property + def level(self) -> int: + return self._level + + def _load_dataset(self): + from datasets import load_dataset + + split_name = f"level_{self._level}" + hf_dataset = load_dataset(self._dataset_name, split=split_name) + + for row in hf_dataset: + problem_id = row["problem_id"] + + if self._filter_ids is not None and problem_id not in self._filter_ids: + continue + + self._problems[problem_id] = Problem( + problem_id=problem_id, + name=row["name"], + code=row["code"], + level=self._level, + path=None, + ) + + def get_problem_by_id(self, problem_id: int) -> Problem: + if problem_id not in self._problems: + raise ValueError(f"Problem ID {problem_id} not found in dataset") + return self._problems[problem_id] + + def get_problem_ids(self) -> list[int]: + return sorted(self._problems.keys()) + + def __len__(self) -> int: + return len(self._problems) + + def __iter__(self) -> Iterator[Problem]: + for pid in self.get_problem_ids(): + yield self._problems[pid] + + def __repr__(self) -> str: + return f"HuggingFaceKernelBenchDataset(level={self._level}, problems={len(self)})" + + def subset( + self, + problem_ids: Optional[list[int]] = None, + id_range: Optional[tuple[int, int]] = None, + ) -> "HuggingFaceKernelBenchDataset": + """Create a subset of this dataset.""" + return HuggingFaceKernelBenchDataset( + level=self._level, + dataset_name=self._dataset_name, + problem_ids=problem_ids, + id_range=id_range, + ) + + +################################################################################ +# Factory Function +################################################################################ + +def construct_kernelbench_dataset( + level: int, + source: str = "local", + dataset_name: str = "ScalingIntelligence/KernelBench", + base_path: str = KERNEL_BENCH_PATH, + problem_ids: Optional[list[int]] = None, + id_range: Optional[tuple[int, int]] = None, +) -> BaseDataset: + """Construct a KernelBench dataset for a specific level. + + Args: + level: KernelBench level (1, 2, 3, or custom for local) + source: "local" for filesystem, "huggingface" for HF datasets + dataset_name: HuggingFace dataset identifier (if source="huggingface") + base_path: Path to KernelBench directory (if source="local") + problem_ids: Optional list of specific problem IDs to include + id_range: Optional (start_id, end_id) inclusive range + + Returns: + BaseDataset instance for the specified level + + Examples: + # Local filesystem (default) + >>> dataset = construct_kernelbench_dataset(level=1, source="local") + >>> len(dataset) + 100 + + # HuggingFace + >>> dataset = construct_kernelbench_dataset(level=1, source="huggingface") + >>> len(dataset) + 100 + + # Filter by specific IDs + >>> dataset = construct_kernelbench_dataset(level=1, problem_ids=[1, 3, 5]) + >>> dataset.get_problem_ids() + [1, 3, 5] + + # Filter by range + >>> dataset = construct_kernelbench_dataset(level=1, id_range=(1, 10)) + >>> dataset.get_problem_ids() + [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] + + # Access problems + >>> problem = dataset.get_problem_by_id(1) + >>> problem.name + '1_Square_matrix_multiplication_.py' + >>> problem.code[:50] + 'import torch...' """ - Get a random subset of problems from the KernelBench dataset + if source == "local": + return LocalKernelBenchDataset(level, base_path, problem_ids, id_range) + elif source == "huggingface": + return HuggingFaceKernelBenchDataset(level, dataset_name, problem_ids, id_range) + else: + raise ValueError(f"Unknown source: {source}. Must be 'local' or 'huggingface'") + + +################################################################################ +# Convenience Functions +################################################################################ + +def fetch_ref_arch_from_dataset( + dataset: BaseDataset, + problem_id: int, +) -> tuple[Optional[str], str, str]: + """Fetch reference architecture from dataset. + + Returns: + (path, name, code) - path is None for HuggingFace datasets """ + problem = dataset.get_problem_by_id(problem_id) + return (problem.path, problem.name, problem.code) - full_dataset = construct_kernelbench_dataset(level) + +def get_kernelbench_subset( + level: int, + num_subset_problems: int = 10, + random_seed: int = 42, + source: str = "local", +) -> tuple[BaseDataset, list[int]]: + """Get a random subset of problems. + + Returns: + (subset_dataset, subset_problem_ids) + """ + full_dataset = construct_kernelbench_dataset(level, source=source) + all_ids = full_dataset.get_problem_ids() random.seed(random_seed) - num_subset_problems = min(num_subset_problems, len(full_dataset)) - subset_indices = random.sample(range(len(full_dataset)), num_subset_problems) + num_subset_problems = min(num_subset_problems, len(all_ids)) + subset_ids = sorted(random.sample(all_ids, num_subset_problems)) - subset = sorted([full_dataset[i] for i in subset_indices]) - return subset, subset_indices + subset_dataset = construct_kernelbench_dataset( + level=level, + source=source, + problem_ids=subset_ids, + ) + return subset_dataset, subset_ids ################################################################################ -# Representative subsets of KernelBench -# use this if you want to iterate on methods without the hassle of running the full dataset -# problem_ids are 1-indexed (logical index) +# Representative Subsets of KernelBench +# Use these for quick iteration without running the full dataset ################################################################################ -level1_representative_subset = [ +# Level 1: Basic operators - matmul, activations, norms, pooling, convolutions +LEVEL1_REPRESENTATIVE_SUBSET = [ "1_Square_matrix_multiplication_.py", "3_Batched_matrix_multiplication.py", "6_Matmul_with_large_K_dimension_.py", @@ -115,10 +526,10 @@ def get_kernelbench_subset( "86_conv_depthwise_separable_2D.py", "87_conv_pointwise_2D.py", ] +LEVEL1_REPRESENTATIVE_IDS = [1, 3, 6, 18, 23, 26, 33, 36, 40, 42, 48, 54, 57, 65, 77, 82, 86, 87] -level1_representative_subset_problem_ids = [1, 3, 6, 18, 23, 26, 33, 36, 40, 42, 48, 54, 57, 65, 77, 82, 86, 87] - -level2_representative_subset = [ +# Level 2: Fused operators - multi-op fusion patterns +LEVEL2_REPRESENTATIVE_SUBSET = [ "1_Conv2D_ReLU_BiasAdd.py", "2_ConvTranspose2d_BiasAdd_Clamp_Scaling_Clamp_Divide.py", "8_Conv3d_Divide_Max_GlobalAvgPool_BiasAdd_Sum.py", @@ -128,10 +539,10 @@ def get_kernelbench_subset( "33_Gemm_Scale_BatchNorm.py", "43_Conv3d_Max_LogSumExp_ReLU.py", ] +LEVEL2_REPRESENTATIVE_IDS = [1, 2, 8, 18, 23, 28, 33, 43] -level2_representative_subset_problem_ids = [1, 2, 8, 18, 23, 28, 33, 43] - -level3_representative_subset = [ +# Level 3: Full models - MLP, CNN architectures, RNNs, Transformers +LEVEL3_REPRESENTATIVE_SUBSET = [ "1_MLP.py", "5_AlexNet.py", "8_ResNetBasicBlock.py", @@ -142,5 +553,29 @@ def get_kernelbench_subset( "38_LTSMBidirectional.py", "43_MinGPTCausalAttention.py", ] +LEVEL3_REPRESENTATIVE_IDS = [1, 5, 8, 11, 20, 21, 33, 38, 43] -level3_representative_subset_problem_ids = [1, 5, 8, 11, 20, 33, 38, 43] \ No newline at end of file + +def get_representative_dataset(level: int, source: str = "local") -> BaseDataset: + """Get a representative subset dataset for quick iteration. + + Args: + level: 1, 2, or 3 + source: "local" or "huggingface" + + Returns: + Dataset containing only representative problems + """ + id_map = { + 1: LEVEL1_REPRESENTATIVE_IDS, + 2: LEVEL2_REPRESENTATIVE_IDS, + 3: LEVEL3_REPRESENTATIVE_IDS, + } + if level not in id_map: + raise ValueError(f"No representative subset for level {level}") + + return construct_kernelbench_dataset( + level=level, + source=source, + problem_ids=id_map[level], + ) \ No newline at end of file diff --git a/src/kernelbench/eval.py b/src/kernelbench/eval.py index 023b4f88..47f59793 100644 --- a/src/kernelbench/eval.py +++ b/src/kernelbench/eval.py @@ -21,7 +21,7 @@ import torch.nn as nn from pydantic import BaseModel -from . import utils, timing +from . import timing, dataset REPO_TOP_PATH = os.path.abspath( os.path.join( @@ -39,30 +39,27 @@ def get_error_name(e: Exception) -> str: return f"{e.__class__.__module__}.{e.__class__.__name__}" -def fetch_ref_arch_from_problem_id(problem_id, problems, with_name=False) -> str: +def fetch_ref_arch_from_problem_id(problem_id: int, dataset: "BaseDataset", with_name=False) -> Union[str, tuple[str, str]]: """ - Fetches the reference architecture in string for a given problem_id + Fetches the reference architecture for a given problem_id from the dataset. """ if isinstance(problem_id, str): problem_id = int(problem_id) - problem_path = problems[problem_id] - - # problem_path = os.path.join(REPO_ROOT_PATH, problem) - if not os.path.exists(problem_path): - raise FileNotFoundError(f"Problem file at {problem_path} does not exist.") - - ref_arch = utils.read_file(problem_path) + problem = dataset.get_problem_by_id(problem_id) + ref_arch = problem.code + if not with_name: return ref_arch else: - return (problem_path, ref_arch) + # Use problem.name as fallback when path is None (e.g., for HuggingFace datasets) + name = problem.path if problem.path is not None else problem.name + return (name, ref_arch) def fetch_ref_arch_from_level_problem_id(level, problem_id, with_name=False): - PROBLEM_DIR = os.path.join(KERNEL_BENCH_PATH, "level" + str(level)) - dataset = utils.construct_problem_dataset_from_problem_dir(PROBLEM_DIR) - return fetch_ref_arch_from_problem_id(problem_id, dataset, with_name) + kb_dataset = dataset.construct_kernelbench_dataset(level) + return fetch_ref_arch_from_problem_id(problem_id, kb_dataset, with_name) def set_seed(seed: int): @@ -531,6 +528,18 @@ def eval_kernel_against_ref( compiled=False, metadata=metadata ) # skip further steps + # Check if ModelNew was successfully loaded (load_custom_model returns None on syntax errors) + if ModelNew is None: + print( + "Failed to load custom model: Syntax error or ModelNew not found in generated code. Record as compilation failure." + ) + metadata["compilation_error_name"] = "SyntaxError" + metadata["compilation_error"] = "Syntax error in custom generated code or ModelNew not found" + graceful_eval_cleanup(context, device, tempfile) + return KernelExecResult( + compiled=False, metadata=metadata + ) # skip further steps + # at this point we passed compilation try: with torch.no_grad(): @@ -880,8 +889,7 @@ def convert_to_serializable(obj): return converted_metadata - # if __name__ == "__main__": # fetch_kernel_from_database("kernelbench_prompt_v2_level_2", 1, 1, "http://localhost:9091") # print(fetch_ref_arch_from_level_problem_id("2", 1, with_name=True)) -# fetch_baseline_time("level1", 0, ["1_Square_matrix_multiplication_.py"], "tests/baseline_time_matx3.json") \ No newline at end of file +# Note: fetch_baseline_time is available in kernelbench.timing module \ No newline at end of file diff --git a/src/kernelbench/frameworks.py b/src/kernelbench/frameworks.py index d102e35a..a7f1a2a0 100644 --- a/src/kernelbench/frameworks.py +++ b/src/kernelbench/frameworks.py @@ -24,7 +24,6 @@ from dotenv import load_dotenv load_dotenv() -# from datasets import load_dataset import numpy as np from contextlib import contextmanager from collections import defaultdict diff --git a/src/kernelbench/timing.py b/src/kernelbench/timing.py index b930a890..6b0db010 100644 --- a/src/kernelbench/timing.py +++ b/src/kernelbench/timing.py @@ -2,7 +2,7 @@ import json import numpy as np import time -from typing import Any +from typing import Any, Optional import os ################################################################################ @@ -393,8 +393,8 @@ def time_execution_with_host_time( # tools to help compute speedup and other time ######################################################### def fetch_baseline_time( - level_name: str, problem_id: int, dataset: list[str], baseline_time_filepath: str -) -> dict: + level_name: str, problem_id: int, dataset: "BaseDataset", baseline_time_filepath: str +) -> Optional[float]: """ Fetch the baseline time from the time @@ -409,8 +409,8 @@ def fetch_baseline_time( with open(baseline_time_filepath, "r") as f: baseline_json = json.load(f) - # TODO: replace with the new Dataset object that Omar will merge in - problem_name = dataset[problem_id].split("/")[-1] + problem = dataset.get_problem_by_id(problem_id) + problem_name = problem.name baseline_time = baseline_json[level_name].get(problem_name, None) return baseline_time diff --git a/src/kernelbench/unit_tests/test_dataset.py b/src/kernelbench/unit_tests/test_dataset.py index 22b0612d..b8468503 100644 --- a/src/kernelbench/unit_tests/test_dataset.py +++ b/src/kernelbench/unit_tests/test_dataset.py @@ -1,19 +1,29 @@ - -import pytest -from kernelbench.dataset import get_code_hash - """ -Usage -pytest test_dataset.py +Unit tests for the KernelBench dataset module. + +Usage: + pytest src/kernelbench/unit_tests/test_dataset.py -v """ +import pytest +from kernelbench.dataset import ( + get_code_hash, + construct_kernelbench_dataset, + fetch_ref_arch_from_dataset, + Problem, + BaseDataset, + LocalKernelBenchDataset, + LEVEL1_REPRESENTATIVE_IDS, +) -def test_get_code_hash(): - """ - Test collision and equivalence checking - """ - code_snippet_batch_1_v1 = """ +################################################################################ +# Hash Tests +################################################################################ + +def test_get_code_hash_ignores_comments(): + """Hash should be equal for semantically equivalent code with different comments.""" + code_v1 = """ import torch # This is for a single batch ''' @@ -22,7 +32,7 @@ def test_get_code_hash(): B = 1 """ - code_snippet_batch_1_v2 = """ + code_v2 = """ import torch ''' More problem descriptions (updated) @@ -31,18 +41,291 @@ def test_get_code_hash(): B = 1 """ + + assert get_code_hash(code_v1) == get_code_hash(code_v2) - code_snippet_batch_64 = """ + +def test_get_code_hash_different_for_different_code(): + """Hash should differ for code with actual differences.""" + code_batch_1 = """ + import torch + B = 1 + """ + + code_batch_64 = """ import torch - # This is for a single batch - ''' - Some random multi-line comment - ''' B = 64 """ + + assert get_code_hash(code_batch_1) != get_code_hash(code_batch_64) + + +################################################################################ +# Dataset Construction Tests +################################################################################ + +def test_construct_local_dataset(): + """Test constructing a local dataset.""" + dataset = construct_kernelbench_dataset(level=1, source="local") + + assert isinstance(dataset, BaseDataset) + assert isinstance(dataset, LocalKernelBenchDataset) + assert dataset.level == 1 + assert len(dataset) > 0 + + +def test_construct_dataset_invalid_level(): + """Test that invalid level raises ValueError.""" + with pytest.raises(ValueError): + construct_kernelbench_dataset(level=0, source="local") + + with pytest.raises(ValueError): + construct_kernelbench_dataset(level=-1, source="local") + + +def test_construct_dataset_invalid_source(): + """Test that invalid source raises ValueError.""" + with pytest.raises(ValueError): + construct_kernelbench_dataset(level=1, source="invalid") + + +################################################################################ +# Problem Access Tests +################################################################################ + +def test_get_problem_by_id(): + """Test getting a problem by its logical ID.""" + dataset = construct_kernelbench_dataset(level=1) + + problem = dataset.get_problem_by_id(1) + + assert isinstance(problem, Problem) + assert problem.problem_id == 1 + assert problem.name.startswith("1_") + assert problem.level == 1 + assert len(problem.code) > 0 + assert problem.path is not None + + +def test_get_problem_by_id_not_found(): + """Test that non-existent ID raises ValueError.""" + dataset = construct_kernelbench_dataset(level=1) + + with pytest.raises(ValueError, match="not found"): + dataset.get_problem_by_id(9999) + + +def test_get_problem_ids(): + """Test getting list of all problem IDs.""" + dataset = construct_kernelbench_dataset(level=1) + + ids = dataset.get_problem_ids() + + assert isinstance(ids, list) + assert len(ids) > 0 + assert ids == sorted(ids) # should be sorted + assert 1 in ids + + +def test_problem_hash(): + """Test that Problem.hash property works.""" + dataset = construct_kernelbench_dataset(level=1) + problem = dataset.get_problem_by_id(1) + + hash_value = problem.hash + + assert isinstance(hash_value, str) + assert len(hash_value) == 32 # MD5 hex digest length + + +################################################################################ +# Subset Tests +################################################################################ - assert get_code_hash(code_snippet_batch_1_v1) == get_code_hash(code_snippet_batch_1_v2), \ - "Hash should be equal for semantically equivalent code with different comments" +def test_subset_by_ids(): + """Test creating a subset by specific problem IDs.""" + dataset = construct_kernelbench_dataset(level=1) + subset = dataset.subset(problem_ids=[1, 3, 5]) - assert get_code_hash(code_snippet_batch_1_v1) != get_code_hash(code_snippet_batch_64), \ - "Hash should differ for code with different batch sizes" \ No newline at end of file + assert len(subset) == 3 + assert subset.get_problem_ids() == [1, 3, 5] + + +def test_subset_by_range(): + """Test creating a subset by ID range.""" + dataset = construct_kernelbench_dataset(level=1) + subset = dataset.subset(id_range=(1, 5)) + + assert len(subset) == 5 + assert subset.get_problem_ids() == [1, 2, 3, 4, 5] + + +def test_sample_random(): + """Test random sampling from dataset.""" + dataset = construct_kernelbench_dataset(level=1) + + sample1 = dataset.sample(n=5, seed=42) + sample2 = dataset.sample(n=5, seed=42) + sample3 = dataset.sample(n=5, seed=123) + + assert len(sample1) == 5 + assert sample1.get_problem_ids() == sample2.get_problem_ids() # same seed + assert sample1.get_problem_ids() != sample3.get_problem_ids() # different seed + + +def test_get_representative_subset(): + """Test getting the representative subset.""" + dataset = construct_kernelbench_dataset(level=1) + rep = dataset.get_representative_subset() + + assert len(rep) == len(LEVEL1_REPRESENTATIVE_IDS) + assert rep.get_problem_ids() == LEVEL1_REPRESENTATIVE_IDS + + +################################################################################ +# Iterator Tests +################################################################################ + +def test_dataset_iteration(): + """Test iterating over dataset.""" + dataset = construct_kernelbench_dataset(level=1, problem_ids=[1, 2, 3]) + + problems = list(dataset) + + assert len(problems) == 3 + assert all(isinstance(p, Problem) for p in problems) + assert [p.problem_id for p in problems] == [1, 2, 3] + + + +def test_dataset_len(): + """Test len() on dataset.""" + dataset = construct_kernelbench_dataset(level=1, problem_ids=[1, 2, 3]) + assert len(dataset) == 3 + + +################################################################################ +# Compatibility Tests +################################################################################ + +def test_fetch_ref_arch_from_dataset(): + """Test the backward-compatible fetch function.""" + dataset = construct_kernelbench_dataset(level=1) + + path, name, code = fetch_ref_arch_from_dataset(dataset, problem_id=1) + + assert path is not None + assert name.startswith("1_") + assert len(code) > 0 + + # Should match direct problem access + problem = dataset.get_problem_by_id(1) + assert path == problem.path + assert name == problem.name + assert code == problem.code + + +################################################################################ +# Multiple Levels Tests +################################################################################ + +def test_all_levels_load(): + """Test that all standard levels can be loaded.""" + for level in [1, 2, 3]: + dataset = construct_kernelbench_dataset(level=level) + assert len(dataset) > 0 + assert dataset.level == level + + +################################################################################ +# HuggingFace Tests (requires network) +################################################################################ + +@pytest.mark.slow +def test_huggingface_dataset_loads(): + """Test that HuggingFace dataset can be loaded.""" + dataset = construct_kernelbench_dataset(level=1, source="huggingface") + + assert len(dataset) > 0 + assert dataset.level == 1 + + problem = dataset.get_problem_by_id(1) + assert problem.problem_id == 1 + assert problem.name.startswith("1_") + assert len(problem.code) > 0 + assert problem.path is None # HF has no local path + + +@pytest.mark.slow +def test_local_and_huggingface_parity(): + """Test that local and HuggingFace datasets have the same content.""" + local_ds = construct_kernelbench_dataset(level=1, source="local") + hf_ds = construct_kernelbench_dataset(level=1, source="huggingface") + + # Same number of problems + assert len(local_ds) == len(hf_ds), "Local and HF should have same number of problems" + + # Same problem IDs + assert local_ds.get_problem_ids() == hf_ds.get_problem_ids(), "Problem IDs should match" + + # Check a few problems have same content + for pid in [1, 10, 50]: + local_p = local_ds.get_problem_by_id(pid) + hf_p = hf_ds.get_problem_by_id(pid) + + # Names may differ slightly (HF may not have .py extension) + # But the base name (without extension) should match + local_base = local_p.name.replace(".py", "") + hf_base = hf_p.name.replace(".py", "") + assert local_base == hf_base, f"Problem {pid} name mismatch: {local_p.name} vs {hf_p.name}" + + # Code and hash should match exactly + assert local_p.code == hf_p.code, f"Problem {pid} code mismatch" + assert local_p.hash == hf_p.hash, f"Problem {pid} hash mismatch" + + +@pytest.mark.slow +def test_huggingface_subset(): + """Test that HuggingFace dataset supports subsetting.""" + hf_ds = construct_kernelbench_dataset(level=1, source="huggingface") + + subset = hf_ds.subset(problem_ids=[1, 2, 3]) + assert len(subset) == 3 + assert subset.get_problem_ids() == [1, 2, 3] + + +@pytest.mark.slow +def test_huggingface_representative(): + """Test that HuggingFace dataset supports representative subset.""" + hf_ds = construct_kernelbench_dataset(level=1, source="huggingface") + rep = hf_ds.get_representative_subset() + + assert len(rep) == len(LEVEL1_REPRESENTATIVE_IDS) + + +@pytest.mark.slow +def test_unified_interface_behavior(): + """Test that both sources behave identically through the unified interface.""" + for source in ["local", "huggingface"]: + dataset = construct_kernelbench_dataset(level=1, source=source) + + # All these operations should work the same + assert len(dataset) > 0 + assert 1 in dataset.get_problem_ids() + + problem = dataset.get_problem_by_id(1) + assert isinstance(problem, Problem) + assert problem.problem_id == 1 + assert problem.level == 1 + + # Iteration works + count = 0 + for p in dataset: + count += 1 + if count >= 3: + break + assert count == 3 + + # Subset works + subset = dataset.subset(problem_ids=[1, 2]) + assert len(subset) == 2 \ No newline at end of file diff --git a/src/kernelbench/utils.py b/src/kernelbench/utils.py index 2ace37cd..abe067b1 100644 --- a/src/kernelbench/utils.py +++ b/src/kernelbench/utils.py @@ -20,7 +20,6 @@ from openai import OpenAI from litellm import completion -# from datasets import load_dataset import numpy as np from contextlib import contextmanager from collections import defaultdict From 27d66e923dbc131dda2009892f3a9838cf9d980c Mon Sep 17 00:00:00 2001 From: Simon Zirui Guo Date: Wed, 7 Jan 2026 23:44:25 -0500 Subject: [PATCH 19/24] Enabling NCU Metric Profiling via Pythonic API (#105) * start metric profile branch * clean up remaining places for cuda events * add in nsight-python metric evaluation script and example usage, have to patch some nsight python functions to get this to work * merge main * add in profiling with nsight python capability, as well as code path for timing witih nsight python * add in profiling via nsight python * move profile.py * fixing profiling and timing * merge in main * clean up comments * reference nsight python * clean up * put wheel pkd data fix in this PR * update to new nsight version * for kesavan to further fix * clean up profile and make verbose * add in tests to test_eval_timing * get ready for merge --------- Co-authored-by: Kesavan Ramakrishnan --- EVAL.md | 3 + README.md | 4 +- pyproject.toml | 6 +- requirements.txt | 1 + scripts/generate_baseline_time_modal.py | 15 +- scripts/get_baseline_time_single_problem.py | 13 +- scripts/inspect_triton.py | 4 +- src/kernelbench/profile.py | 438 ++++++++++++++++++ src/kernelbench/prompt_constructor_toml.py | 34 +- src/kernelbench/timing.py | 72 ++- .../unit_tests/test_eval_timing.py | 51 +- src/kernelbench/utils.py | 54 +++ 12 files changed, 659 insertions(+), 36 deletions(-) create mode 100644 src/kernelbench/profile.py diff --git a/EVAL.md b/EVAL.md index b9880560..faebda6f 100644 --- a/EVAL.md +++ b/EVAL.md @@ -36,6 +36,9 @@ We have (and continue to) implement various approaches to conduct kernel timing Check out `timing.py` to see available timing methods and `src/unit_tests/test_eval_timing.py` to test out various timing methods (including leveraging `cuda_event` marker, Triton `do_bench`, `host_time` E2E time). @palic and team is working on a blogpost explaining the different tradeoffs soon. +### Profiling +We have experimental profiling support leveraging NVIDIA NCU in `profile.py`. + ### Checkers There are potentially many ways model might reward hack and we would like to catch the known ways through checkers [experimental and WIP]. We start with `kernel_static_checker.py`, which is a regex-based checker on the genenrated code against set of rules. We plan to add AST-based, LM-as-a-judge, and more runtime checks in the future. We welcome suggestions and contributions here. diff --git a/README.md b/README.md index 3686574a..7343e73b 100644 --- a/README.md +++ b/README.md @@ -66,13 +66,15 @@ We organize the repo into the following structure: KernelBench/ ├── assets/ ├── KernelBench/ # Benchmark dataset files -├── src/ # KernelBench logic code +├── src/kernelbench/ # KernelBench logic code │ ├── unit_tests/ │ ├── prompts/ │ ├── .... ├── scripts/ # helpful scripts to run the benchmark ├── results/ # baseline times across hardware ├── runs/ # where your runs will be stored +├── notebooks/ # example notebooks for analysis +├── pyproject.toml # Project configuration and dependencies ``` ## 🔧 Set up diff --git a/pyproject.toml b/pyproject.toml index 85a690c5..bed37150 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -42,6 +42,7 @@ gpu = [ "nvidia-cutlass-dsl", "tilelang", "cupy-cuda12x", + "nsight-python", ] dev = [ "pytest", @@ -51,4 +52,7 @@ dev = [ [tool.setuptools.packages.find] where = ["src"] -include = ["kernelbench*"] \ No newline at end of file +include = ["kernelbench*"] + +[tool.setuptools.package-data] +kernelbench = ["prompts/**/*"] \ No newline at end of file diff --git a/requirements.txt b/requirements.txt index 8bf9a48f..07603a86 100644 --- a/requirements.txt +++ b/requirements.txt @@ -23,6 +23,7 @@ ninja>=1.13.0 cupy-cuda12x==13.6.0 tomli>=2.3.0 tabulate>=0.9.0 +nsight-python # Numerics einops>=0.8.1 diff --git a/scripts/generate_baseline_time_modal.py b/scripts/generate_baseline_time_modal.py index 22bdb1b0..e9c8428e 100644 --- a/scripts/generate_baseline_time_modal.py +++ b/scripts/generate_baseline_time_modal.py @@ -6,7 +6,7 @@ fetch_ref_arch_from_problem_id, ) from kernelbench.timing import ( - time_execution_with_cuda_event, + get_timing_function, get_timing_stats, ) from kernelbench.dataset import construct_kernelbench_dataset, fetch_ref_arch_from_dataset @@ -134,6 +134,7 @@ def measure_program_time( ref_arch_name: str, ref_arch_src: str, num_trials: int = 100, + timing_method: str="cuda_event", use_torch_compile: bool = False, torch_compile_backend: str="inductor", torch_compile_options: str="default", @@ -173,9 +174,16 @@ def measure_program_time( print(f"Using PyTorch Eager Execution on {ref_arch_name}") model = model.cuda(device=device) + timing_func = get_timing_function(timing_method) torch.cuda.synchronize(device=device) - elapsed_times = time_execution_with_cuda_event( - model, inputs, num_trials=num_trials, verbose=verbose, device=device + elapsed_times = timing_func( + model, + inputs, + num_warmup=3, # or any default you prefer + num_trials=num_trials, + discard_first=1, # or 0 to include first trial + verbose=verbose, + device=device, ) runtime_stats = get_timing_stats(elapsed_times, device=device) @@ -220,6 +228,7 @@ def record_baseline_times(config: BaselineConfig, ref_arch_name=ref_arch_name, ref_arch_src=ref_arch_src, num_trials=config.num_trials, + timing_method="cuda_event", use_torch_compile=use_torch_compile, torch_compile_backend=torch_compile_backend, torch_compile_options=torch_compile_options, diff --git a/scripts/get_baseline_time_single_problem.py b/scripts/get_baseline_time_single_problem.py index 1613f4b0..91e1472f 100644 --- a/scripts/get_baseline_time_single_problem.py +++ b/scripts/get_baseline_time_single_problem.py @@ -2,16 +2,17 @@ import numpy as np from kernelbench.eval import ( load_original_model_and_inputs, - time_execution_with_cuda_event, - get_timing_stats, set_seed, fetch_ref_arch_from_problem_id, ) +from src.timing import get_timing_function, get_timing_stats + def measure_program_time( ref_arch_name: str, ref_arch_src: str, num_trials: int = 100, + timing_method: str="cuda_event", use_torch_compile: bool = False, torch_compile_backend: str="inductor", torch_compile_options: str="default", @@ -52,8 +53,9 @@ def measure_program_time( model = model.cuda(device=device) torch.cuda.synchronize(device=device) - elapsed_times = time_execution_with_cuda_event( - model, *inputs, num_trials=num_trials, verbose=verbose, device=device + timing_func = get_timing_function(timing_method ) + elapsed_times = timing_func( + model, inputs, num_warmup=3, num_trials=num_trials, discard_first=1, verbose=verbose, device=device ) runtime_stats = get_timing_stats(elapsed_times, device=device) @@ -87,5 +89,4 @@ def get_inputs(): def get_init_inputs(): return [] # No special initialization inputs needed """ - print(measure_program_time(ref_arch_name, ref_arch_src, use_torch_compile=False)) - print(measure_program_time(ref_arch_name, ref_arch_src, use_torch_compile=True)) \ No newline at end of file + print(measure_program_time(ref_arch_name, ref_arch_src, use_torch_compile=False, timing_method="cuda_event")) \ No newline at end of file diff --git a/scripts/inspect_triton.py b/scripts/inspect_triton.py index 56fe6a23..3333dd91 100644 --- a/scripts/inspect_triton.py +++ b/scripts/inspect_triton.py @@ -161,7 +161,9 @@ def get_torch_compile_triton(level_num: int, problem_id: int) -> str: torch.cuda.synchronize(device=device) - elapsed_times = time_execution_with_cuda_event( + timing_method = "cuda_event" # use cuda event for timing here + time_func_cuda_event = get_timing_function(timing_method) + elapsed_times = time_func_cuda_event( model, *inputs, num_trials=1, verbose=False, device=device ) runtime_stats = get_timing_stats(elapsed_times, device=device) diff --git a/src/kernelbench/profile.py b/src/kernelbench/profile.py new file mode 100644 index 00000000..8326324e --- /dev/null +++ b/src/kernelbench/profile.py @@ -0,0 +1,438 @@ +""" +Nsight Profiling Module for KernelBench +======================================== + +This module provides GPU profiling capabilities using NVIDIA Nsight Compute (ncu). +It allows collecting hardware-level metrics from kernels. + +NOTE: this is an experimental module, not part of the default eval pass. +You need hardware counter access (usually requires sudo) to accesss hardware counter. +We only support local mode with this feature, not avaliable on Modal. + +Key Features: +- Profile arbitrary PyTorch functions with hardware metrics +- Profile KernelBench models (ModelNew) with automatic setup/teardown +- Combine metrics from multi-kernel operations (common in PyTorch) + +Requirements: +- NVIDIA Nsight Compute CLI (ncu) must be installed and in PATH +- nsight-python package + +Common Metrics: +- gpu__time_duration.sum: Total GPU time in nanoseconds +- sm__cycles_elapsed.sum: Total SM cycles elapsed +- sm__cycles_active.avg: Average active cycles per SM + +Reference: https://docs.nvidia.com/nsight-python +""" + +import os +from shutil import which + +import torch + +# ============================================================================= +# Nsight Availability Check +# ============================================================================= + +try: + import nsight + NSIGHT_AVAILABLE = True +except ImportError: + NSIGHT_AVAILABLE = False + + +# ============================================================================= +# Utility Functions +# ============================================================================= + +def check_ncu_available() -> bool: + """ + Check if NVIDIA Nsight Compute CLI (ncu) is available in PATH. + + The ncu command-line tool is required for collecting GPU hardware metrics. + It's typically installed with the CUDA Toolkit or NVIDIA Nsight Compute. + + Returns: + True if ncu is found in PATH, False otherwise. + """ + return which('ncu') is not None + + +# ============================================================================= +# Core Profiling Functions +# ============================================================================= + +def profile_with_nsight(func, metrics=None, num_trials=1): + """ + Profile a PyTorch function and collect hardware metrics. + + Handles complexity: + - Setting up the Nsight kernel analyzer + - Combining metrics when PyTorch ops launch multiple CUDA kernels + - Extracting results from Nsight's DataFrame format + + Args: + func: A callable (no arguments) that executes the code to profile. + Typically a closure that captures the model and inputs. + metrics: List of Nsight metric names to collect. If None, defaults to + ['sm__cycles_active.avg']. Can also pass a single string. + num_trials: Number of times to run the function for averaging. + + Returns: + Dictionary mapping metric names to their values (float). + Returns None for metrics that couldn't be collected. + + Example: + >>> def my_kernel(): + ... return torch.matmul(a, b) + >>> results = profile_with_nsight(my_kernel, ['gpu__time_duration.sum']) + >>> print(results['gpu__time_duration.sum']) # Time in nanoseconds + + Raises: + RuntimeError: If nsight-python is not installed. + """ + if not NSIGHT_AVAILABLE: + raise RuntimeError( + "nsight-python not available." + ) + + # Normalize metrics to a list + if metrics is None: + metrics = ['sm__cycles_active.avg'] + elif isinstance(metrics, str): + metrics = [metrics] + + # Define the profiled function with Nsight decorator + # NOTE: PyTorch operations often launch multiple CUDA kernels (e.g., a matmul + # might have separate kernels for the computation and memory operations). + # We use combine_kernel_metrics to sum these together for a single measurement. + @nsight.analyze.kernel( + metrics=metrics, + runs=num_trials, + configs=[(0,)], # Use default GPU config + combine_kernel_metrics=lambda a, b: (0 if a is None else a) + (0 if b is None else b), + ) + def profiled(_): + # The nsight.annotate context marks the region we care about + with nsight.annotate("kernel"): + return func() + + try: + # Run profiling - this invokes ncu under the hood + result = profiled() + + # Convert results to DataFrame + df = result.to_dataframe() if result else None + if df is None or df.empty: + return {m: None for m in metrics} + + # Nsight returns a DataFrame with columns like: + # - 'Metric': The metric name (e.g., 'gpu__time_duration.sum') + # - 'AvgValue': The measured value + # We need to find these columns (names may vary slightly) + metric_col = next((c for c in df.columns if c.lower() == 'metric'), None) + value_col = next((c for c in df.columns if 'value' in c.lower()), None) + + if not metric_col or not value_col: + return {m: None for m in metrics} + + # Build a dictionary of all metrics in the DataFrame + metric_dict = { + row[metric_col]: float(row[value_col]) + for _, row in df.iterrows() + } + + # Return only the requested metrics (None if not found) + return {m: metric_dict.get(m) for m in metrics} + + except Exception as e: + print(f"Error profiling: {e}") + return {m: None for m in metrics} + + +def profile_kernelbench_model_with_nsight( + custom_model_src: str, + ref_model_src: str = None, + metrics: list = None, + num_trials: int = 1, + seed: int = 42, + device: torch.device = None, + backend: str = "cuda", + precision: torch.dtype = torch.float32, + build_dir: str = None, + verbose: bool = False, +) -> dict: + """ + Profile a KernelBench model (ModelNew) using Nsight hardware metrics. + + This is the high-level profiling function designed for KernelBench workflows. + It handles the full lifecycle: + 1. Load and compile the custom model from source code + 2. Generate inputs using the model's get_inputs() function + 3. Profile the forward pass with Nsight + 4. Clean up resources + + IMPORTANT: This function assumes the model has already been validated for + correctness via eval. No correctness checking is performed here. + + Args: + custom_model_src: Python source code string containing the ModelNew class. + ref_model_src: Optional source code for the reference model. Used to get + get_inputs() and get_init_inputs() if they're not in + custom_model_src. If None, uses custom_model_src. + metrics: List of Nsight metrics to collect. Defaults to ['sm__cycles_active.avg']. + num_trials: Number of profiling runs for averaging. Default: 1. + seed: Random seed for reproducible input generation. Default: 42. + device: CUDA device to run on. Default: cuda:0. + backend: Compilation backend ('cuda', 'triton', 'tilelang', 'cute'). + precision: torch.dtype for computation. Default: torch.float32. + build_dir: Directory for compiled kernel artifacts. Default: None. + verbose: Print progress messages. Default: False. + + Returns: + Dictionary mapping metric names to their measured values. + Values are None if the metric couldn't be collected. + + Example: + >>> results = profile_kernelbench_model_with_nsight( + ... custom_model_src=my_model_code, + ... ref_model_src=ref_model_code, + ... metrics=['gpu__time_duration.sum', 'sm__cycles_elapsed.sum'], + ... verbose=True + ... ) + >>> print(f"GPU time: {results['gpu__time_duration.sum']} ns") + """ + # Import eval utilities (deferred to avoid circular imports) + from kernelbench.eval import ( + load_custom_model, + load_custom_model_with_tempfile, + load_original_model_and_inputs, + _process_input_tensor, + set_seed, + graceful_eval_cleanup, + ) + + # Set defaults + device = device or torch.device("cuda:0") + if metrics is None: + metrics = ['sm__cycles_active.avg'] + elif isinstance(metrics, str): + metrics = [metrics] + + torch.cuda.set_device(device) + + # ------------------------------------------------------------------------- + # Step 1: Load input generation functions from model source + # ------------------------------------------------------------------------- + # The model source should define get_inputs() and get_init_inputs() functions + # that return the tensors needed to run the model. + input_source = ref_model_src or custom_model_src + context = {} + _, get_init_inputs, get_inputs = load_original_model_and_inputs(input_source, context) + + # Generate initialization inputs (for model constructor) + set_seed(seed) + init_inputs = [ + _process_input_tensor(x, device, backend, precision) + for x in get_init_inputs() + ] + + # ------------------------------------------------------------------------- + # Step 2: Load and compile the custom model + # ------------------------------------------------------------------------- + if verbose: + print("[Profile] Loading and compiling custom model...") + + # Enable CUDA Device-Side Assertions for better error messages + os.environ["TORCH_USE_CUDA_DSA"] = "1" + tempfile = None + + # Different backends require different loading mechanisms + if backend.lower() in ["triton", "tilelang", "cute"]: + # These backends need a temp file for proper module loading + ModelNew, tempfile = load_custom_model_with_tempfile( + custom_model_src, entry_point="ModelNew" + ) + else: + # Standard CUDA backend + ModelNew = load_custom_model(custom_model_src, {}, build_dir) + + torch.cuda.synchronize(device=device) + + # ------------------------------------------------------------------------- + # Step 3: Instantiate the model + # ------------------------------------------------------------------------- + with torch.no_grad(): + set_seed(seed) + custom_model = ModelNew(*init_inputs) + custom_model = custom_model.to(device=device, dtype=precision) + torch.cuda.synchronize(device=device) + + if verbose: + print("[Profile] Model instantiated successfully") + + # ------------------------------------------------------------------------- + # Step 4: Profile the forward pass + # ------------------------------------------------------------------------- + # Generate forward pass inputs + set_seed(seed) + inputs = [ + _process_input_tensor(x, device, backend, precision) + for x in get_inputs() + ] + + if verbose: + print(f"[Profile] Profiling with nsight (metrics: {metrics})...") + + # Create a closure for the forward pass + def model_forward(): + with torch.no_grad(): + return custom_model(*inputs) + + # Run profiling + metric_values = profile_with_nsight( + model_forward, + metrics=metrics, + num_trials=num_trials + ) + + if verbose: + print("[Profile] Profiling completed successfully") + + # ------------------------------------------------------------------------- + # Step 5: Cleanup + # ------------------------------------------------------------------------- + graceful_eval_cleanup(context, device, tempfile) + + return metric_values + + +# ============================================================================= +# Examples and Tests +# ============================================================================= + +def example_ncu_python_profile(): + """ + Simple example demonstrating how to profile a basic matrix multiplication. + + This shows the minimal setup needed to use profile_with_nsight(). + """ + print("Creating test tensors...") + a = torch.randn(256, 256, device="cuda") + b = torch.randn(256, 256, device="cuda") + + # Create a closure that captures the tensors + def matmul_kernel(): + return a @ b + + print("Running nsight profiling...") + + metric_values = profile_with_nsight( + matmul_kernel, + metrics=[ + 'sm__cycles_active.avg', # Average active cycles per SM + 'sm__cycles_elapsed.sum', # Total cycles elapsed + 'smsp__inst_executed_pipe_tensor_op_hmma.sum', # Tensor core ops + ], + num_trials=1, + ) + + print("\nProfiling results:") + for metric_name, value in metric_values.items(): + print(f" {metric_name}: {value}") + + +def test_flash_attention_profile(): + """ + Test profiling a Flash Attention model from the KernelBench examples. + + This demonstrates the full workflow of profiling a KernelBench model + using profile_kernelbench_model_with_nsight(). + """ + from kernelbench.utils import read_file + + # Locate the example model files + REPO_ROOT = os.path.dirname(__file__) + ref_model_path = os.path.join( + REPO_ROOT, "prompts/few_shot/model_ex_flash_attn.py" + ) + custom_model_path = os.path.join( + REPO_ROOT, "prompts/few_shot/model_new_ex_flash_attn.py" + ) + + print("[Test] Reading model source files...") + ref_model_src = read_file(ref_model_path) + custom_model_src = read_file(custom_model_path) + + print("[Test] Starting profiling with nsight...") + + metrics = profile_kernelbench_model_with_nsight( + custom_model_src=custom_model_src, + ref_model_src=ref_model_src, + metrics=[ + 'gpu__time_duration.sum', # Total GPU execution time (ns) + 'sm__cycles_elapsed.sum', # Total SM cycles + ], + seed=42, + backend="cuda", + precision=torch.float32, + verbose=True + ) + + print("\n[Test] Profiling results:") + print("=" * 60) + for metric_name, value in metrics.items(): + if value is not None: + print(f" {metric_name}: {value:,.0f}") + else: + print(f" {metric_name}: ") + print("=" * 60) + + return metrics + + +# Optional: Decorated benchmark function for direct use with nsight +if NSIGHT_AVAILABLE: + @nsight.analyze.kernel + def benchmark_matmul(n): + """ + Standard benchmark following nsight-python documentation style. + + This shows how to use the @nsight.analyze.kernel decorator directly + for simple benchmarking scenarios. + """ + a = torch.randn(n, n, device="cuda") + b = torch.randn(n, n, device="cuda") + with nsight.annotate("matmul"): + c = a @ b + return c + + +# ============================================================================= +# Main Entry Point +# ============================================================================= + +if __name__ == "__main__": + # Verify prerequisites + if not check_ncu_available(): + print("ERROR: ncu not found in PATH.") + print("Install NVIDIA Nsight Compute from:") + print(" https://developer.nvidia.com/nsight-compute") + exit(1) + + if not torch.cuda.is_available(): + print("ERROR: CUDA is not available.") + exit(1) + + print("=" * 60) + print("Running Nsight Profiling Examples") + print("=" * 60) + + # Run the simple example first + print("\n--- Example: Basic Matrix Multiplication ---\n") + example_ncu_python_profile() + + # Run the full KernelBench model test + print("\n--- Test: Flash Attention Model ---\n") + test_flash_attention_profile() diff --git a/src/kernelbench/prompt_constructor_toml.py b/src/kernelbench/prompt_constructor_toml.py index 7b8b1bdf..4349a74d 100644 --- a/src/kernelbench/prompt_constructor_toml.py +++ b/src/kernelbench/prompt_constructor_toml.py @@ -5,7 +5,7 @@ from dataclasses import dataclass from typing import Any, Dict, List, Optional -from kernelbench.utils import read_file +from kernelbench.utils import read_file, get_package_resource_path, resolve_path, REPO_TOP_PATH """ TOML-based prompt constructor for managing prompt templates and configurations. @@ -14,11 +14,9 @@ You can easily check some of the prompt templates we have provided and create your own. """ -REPO_TOP_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")) -PROMPTS_TOML = os.path.join(REPO_TOP_PATH, "src/kernelbench/prompts/prompts.toml") - -assert os.path.exists(PROMPTS_TOML), f"Prompts.toml not found at {PROMPTS_TOML}" -GPU_SPECS_PY = "src/kernelbench/prompts/hardware/gpu_specs.py" +# Resolve paths using the helper from utils +PROMPTS_TOML = get_package_resource_path("prompts/prompts.toml") +GPU_SPECS_PY = get_package_resource_path("prompts/hardware/gpu_specs.py") HARDWARE_COMPONENT_KEYS = [ "hardware_header", "hardware_specs", @@ -26,12 +24,6 @@ "hardware_best_practices", ] -def _abs_path(rel: str) -> str: - """Convert relative path to absolute path from repo root.""" - if os.path.isabs(rel): - return rel - return os.path.join(REPO_TOP_PATH, rel) - @dataclass class PromptConfig: """ @@ -255,17 +247,17 @@ def render_example_entry(input_code: str, output_code: str, example_label: str) # Use multiple examples (true few-shot) examples_intro = intro_few_shot for i, (input_path, output_path) in enumerate(few_shot_examples, 1): - input_code = read_file(_abs_path(input_path)) - output_code = read_file(_abs_path(output_path)) + input_code = read_file(resolve_path(input_path)) + output_code = read_file(resolve_path(output_path)) examples_entries.append( render_example_entry(input_code, output_code, f"Example {i}:") ) else: # Fall back to one-shot - ex_arch_path = _abs_path( + ex_arch_path = resolve_path( backend_data.get("few_shot_example_arch") or shared.get("few_shot_example_arch") ) - ex_new_path = _abs_path(backend_data["one_shot_new_arch"]) + ex_new_path = resolve_path(backend_data["one_shot_new_arch"]) input_code = read_file(ex_arch_path) output_code = read_file(ex_new_path) examples_entries.append( @@ -274,10 +266,10 @@ def render_example_entry(input_code: str, output_code: str, example_label: str) elif requires_example == "one_shot": # Always use one-shot - ex_arch_path = _abs_path( + ex_arch_path = resolve_path( backend_data.get("few_shot_example_arch") or shared.get("few_shot_example_arch") ) - ex_new_path = _abs_path(backend_data["one_shot_new_arch"]) + ex_new_path = resolve_path(backend_data["one_shot_new_arch"]) input_code = read_file(ex_arch_path) output_code = read_file(ex_new_path) examples_entries.append( @@ -296,7 +288,7 @@ def render_example_entry(input_code: str, output_code: str, example_label: str) raise ValueError( f"Hardware info requested for option '{option}'; provide gpu_specs_py and gpu_name" ) - context = {**context, **_gpu_context_from_gpu_specs(_abs_path(gpu_specs_py), gpu_name)} + context = {**context, **_gpu_context_from_gpu_specs(resolve_path(gpu_specs_py), gpu_name)} # Builds the prompt from the components in the toml file. prompt_parts = [] @@ -416,10 +408,10 @@ def test_prompt(): generation. Customize the reference architecture or custom_prompt_key if you want to try different inputs. """ - REPO_TOP_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")) ref_arch_src = read_file(os.path.join(REPO_TOP_PATH, "KernelBench", "level1", "1_Square_matrix_multiplication_.py")) assert len(ref_arch_src) > 0, "ref_arch_src is empty" - + + print("Testing prompt construction...") scratch_dir = os.path.join(REPO_TOP_PATH, "scratch") # baseline prompt baseline_prompt = get_prompt_for_backend( diff --git a/src/kernelbench/timing.py b/src/kernelbench/timing.py index 6b0db010..83908391 100644 --- a/src/kernelbench/timing.py +++ b/src/kernelbench/timing.py @@ -77,6 +77,8 @@ def get_timing_function( return time_execution_with_do_bench_impl case "host_time": return time_execution_with_host_time + case "nsight_python_time": + return time_execution_with_nsight_python # we might add other methods in the future case _: raise ValueError(f"Unsupported timing method: {method}") @@ -86,7 +88,6 @@ def get_timing_function( NOTE: we have a WIP blogpost on this topic covering the various timing approaches """ - def time_execution_with_cuda_event( kernel_fn: callable, args: list[Any], @@ -388,6 +389,74 @@ def time_execution_with_host_time( return elapsed_times +def time_execution_with_nsight_python( + kernel_fn: callable, + args: list[Any], + num_warmup: int = 3, + num_trials: int = 10, + discard_first: int = 1, # not used here + verbose: bool = True, + device: torch.device | None = None) -> list[float]: + """ + Time a CUDA kernel function using nsight-python. + + Note: nsight returns an average time across num_trials runs. + Returns a list with a single value (average time) for API consistency. + GPU time from nsight is in nanoseconds, converted to milliseconds. + + Returns: + List containing one float: average elapsed time in milliseconds + """ + + from kernelbench.profile import profile_with_nsight + + if device is None: + if verbose: + print(f"Using current device: {torch.cuda.current_device()}") + device = torch.cuda.current_device() + + with torch.cuda.device(device): + # Warm ups + for _ in range(num_warmup): + kernel_fn(*args) + torch.cuda.synchronize(device=device) + + # Clear cache for cold start + torch.cuda.empty_cache() + clear_l2_cache(device=device) + + if verbose: + print(f"[Profiling] Using device: {device} {torch.cuda.get_device_name(device)}, warm up {num_warmup}, trials {num_trials}") + + # Profile with nsight - returns average time in nanoseconds + # Wrap kernel function + def wrapped_kernel(): + return kernel_fn(*args) + + # Profile with nsight, use gpu_time_duration.sum metric for GPU time + metric_values = profile_with_nsight( + wrapped_kernel, + metrics=["gpu__time_duration.sum"], + num_trials=num_trials + ) + + # Convert from nanoseconds to milliseconds + gpu_time_ns = metric_values.get("gpu__time_duration.sum") + if gpu_time_ns is None: + raise RuntimeError("Failed to get GPU time from nsight") + + # Convert nanoseconds to milliseconds + # nsight returns average across num_trials, so we return a single value in a list + gpu_time_ms = gpu_time_ns / 1_000_000.0 + + if verbose: + print(f"Average GPU time: {gpu_time_ms:.3f} ms (across {num_trials} trials)") + + # NOTE: nsight only returns average time across num_trials, so we return a single value in a list + # it did run num_trials times, but we only return the average (1 item) + # Return list with single average value for API consistency + return [gpu_time_ms] + ######################################################## # Timing stats # tools to help compute speedup and other time @@ -439,3 +508,4 @@ def get_timing_stats(elapsed_times: list[float], device: torch.device = None) -> stats["device"] = str(device) # for debugging return stats + diff --git a/src/kernelbench/unit_tests/test_eval_timing.py b/src/kernelbench/unit_tests/test_eval_timing.py index 8be8824b..470c4254 100644 --- a/src/kernelbench/unit_tests/test_eval_timing.py +++ b/src/kernelbench/unit_tests/test_eval_timing.py @@ -5,12 +5,13 @@ sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))) from kernelbench import timing +from kernelbench.profile import NSIGHT_AVAILABLE, check_ncu_available """ Test Timing We want to systematically study different timing methodologies. """ -REPO_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")) +REPO_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../..")) # use exampls in the few shot directory EXAMPLES_PATH = os.path.join(REPO_PATH, "src", "kernelbench", "prompts", "few_shot") @@ -78,14 +79,60 @@ def matmul_kernel(a, b): # test all currently available timing methods def run_all_timing_tests(device="cuda"): timing_methods = ["cuda_event", "host_time", "do_bench", "do_bench_impl"] - # timing_methods = ["cuda_event", "do_bench_impl"] for timing_method in timing_methods: _run_timing_smoke_test_matmul(timing_method, device=device) +def run_nsight_timing_test(device="cuda"): + """ + Run nsight-python timing test if available. + + Nsight requires: + - nsight-python package installed + - ncu (Nsight Compute CLI) in PATH + + Compares nsight GPU time against cuda_event timing for the same matmul operation. + """ + if not NSIGHT_AVAILABLE: + print("[SKIP] nsight-python not installed") + return None + + if not check_ncu_available(): + print("[SKIP] ncu not found in PATH") + return None + + print("\n" + "=" * 60) + print("Running nsight-python timing benchmark") + print("=" * 60) + + # Run nsight timing + print("\n--- nsight_python_time ---") + _run_timing_smoke_test_matmul("nsight_python_time", device=device) + + # Run cuda_event for comparison + print("\n--- cuda_event (for comparison) ---") + _run_timing_smoke_test_matmul("cuda_event", device=device) + + print("\n" + "=" * 60) + print("nsight-python timing benchmark complete") + print("=" * 60) + + +def run_all_timing_tests_with_nsight(device="cuda"): + """ + Run all timing methods including nsight-python if available. + """ + # Standard timing methods (always available) + run_all_timing_tests(device=device) + + # Nsight timing (requires ncu + nsight-python) + run_nsight_timing_test(device=device) + +# select a free GPU here or set CUDA_VISIBLE_DEVICES test_device = torch.device("cuda:5") run_all_timing_tests(test_device) +run_nsight_timing_test(test_device) diff --git a/src/kernelbench/utils.py b/src/kernelbench/utils.py index abe067b1..cf8b0ad8 100644 --- a/src/kernelbench/utils.py +++ b/src/kernelbench/utils.py @@ -15,6 +15,7 @@ import os import json from tqdm import tqdm +from importlib.resources import files, as_file # API clients from openai import OpenAI @@ -273,6 +274,59 @@ def read_file(file_path) -> str: return "" +######################################################## +# Path Resolution Helpers +######################################################## +REPO_TOP_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")) + +def get_package_resource_path(relative_path: str) -> str: + """ + Get absolute path to a kernelbench package resource. + Works for all three usage modes: + - Running from repo directly + - As a git submodule + - As an installed pip/uv dependency + + Args: + relative_path: Path relative to kernelbench/, e.g. "prompts/prompts.toml" + """ + # Try importlib.resources first (installed package) + try: + resource = files("kernelbench").joinpath(relative_path) + with as_file(resource) as path: + if path.exists(): + return str(path) + except (TypeError, FileNotFoundError): + pass + + # Try repo path (running from source / submodule) + repo_path = os.path.join(REPO_TOP_PATH, "src/kernelbench", relative_path) + if os.path.exists(repo_path): + return repo_path + + raise FileNotFoundError(f"Could not find resource: {relative_path}") + + +def resolve_path(rel: str) -> str: + """ + Resolve a relative path to absolute. Handles paths like "src/kernelbench/prompts/..." + from prompts.toml which reference files relative to repo root. + """ + if os.path.isabs(rel): + return rel + + # Convert "src/kernelbench/..." paths to package-relative + if rel.startswith("src/kernelbench/"): + return get_package_resource_path(rel[len("src/kernelbench/"):]) + + # Otherwise treat as repo-relative + repo_path = os.path.join(REPO_TOP_PATH, rel) + if os.path.exists(repo_path): + return repo_path + + raise FileNotFoundError(f"Could not resolve path: {rel}") + + def print_messages(messages): for message in messages: print(message["role"]) From 28dc8dd05faeaa6746f69639fc7a6b0ac04cd65d Mon Sep 17 00:00:00 2001 From: Simon Zirui Guo Date: Mon, 19 Jan 2026 21:15:41 -0800 Subject: [PATCH 20/24] Dependency Updates + Separate Reference Timing (#127) * update dependencies for cuda, tilelang, tk * move ref timing out * clear dynamo cache and increase warmup, add more comments for explanations * add precision to measure_ref_program_time * be consistent with timing code path and also convert weights precision * improve diagonal matrix baseline * clean up and fix up for merging fix * fix bug and remove stale code --------- Co-authored-by: William Hu --- KernelBench/changelog/v0.2 | 4 +- .../12_Matmul_with_diagonal_matrices_.py | 4 +- results/timing/README.md | 16 ++ scripts/eval_from_generations.py | 4 +- .../generate_and_eval_single_sample_modal.py | 8 +- scripts/generate_baseline_time.py | 142 ++---------------- scripts/generate_baseline_time_modal.py | 127 +++------------- scripts/get_baseline_time_single_problem.py | 68 +-------- scripts/run_and_check.py | 43 ++++-- src/kernelbench/eval.py | 2 + src/kernelbench/timing.py | 112 +++++++++++++- 11 files changed, 208 insertions(+), 322 deletions(-) diff --git a/KernelBench/changelog/v0.2 b/KernelBench/changelog/v0.2 index 44915f65..a36b9de1 100644 --- a/KernelBench/changelog/v0.2 +++ b/KernelBench/changelog/v0.2 @@ -1,3 +1,5 @@ Ongoing Effort -Updated Level1/92_cumsum_exclusive.py - Fix exclusive cumsum implementation \ No newline at end of file +Updated Level1/12_Matmul_with_diagonal_matrices_.py - More efficient PyTorch implementation +Updated Level1/92_cumsum_exclusive.py - Fix exclusive cumsum implementation +Updated Level1/97_ScaledDotProductAttention.py - remove device and precision definition setting, harness should handle it \ No newline at end of file diff --git a/KernelBench/level1/12_Matmul_with_diagonal_matrices_.py b/KernelBench/level1/12_Matmul_with_diagonal_matrices_.py index 41369a3b..0e36c275 100644 --- a/KernelBench/level1/12_Matmul_with_diagonal_matrices_.py +++ b/KernelBench/level1/12_Matmul_with_diagonal_matrices_.py @@ -20,7 +20,9 @@ def forward(self, A, B): Returns: torch.Tensor: The result of the matrix multiplication. Shape: (N, M). """ - return torch.diag(A) @ B + # Logically equivalent to torch.diag(A) @ B + # more efficient as no need to materialize a full N×N matrix + return A.unsqueeze(1) * B M = 4096 N = 4096 diff --git a/results/timing/README.md b/results/timing/README.md index 934d1699..65fa8eec 100644 --- a/results/timing/README.md +++ b/results/timing/README.md @@ -5,6 +5,22 @@ This folder contains a set of baseline timing results for the KernelBench proble Since KernelBench measures the speedup between Runtime(refernece architecture) and Runtime(LLM-generated architecture), it is important to measure the baseline reference module runtime. +## When are these baseline JSONs used? + +Baseline timing JSONs in this folder are primarily used for **offline analysis / scoring** where you want a consistent reference runtime without re-timing the PyTorch reference on every run. + +In contrast, some workflows compute speedup using **live timing**: + +- **`scripts/run_and_check.py`** + - Measures the PyTorch reference runtime by calling `kernelbench.timing.measure_ref_program_time(...)` (eager and optionally `torch.compile`). + - Measures the candidate kernel runtime via `kernelbench.eval.eval_kernel_against_ref(...)`. + - Prints speedup as reference_time / kernel_time. + +- **`kernelbench.eval.eval_kernel_against_ref(...)`** (library API) + - Measures candidate kernel runtime directly. + - May also time the reference model runtime for additional checks (e.g. excessive speedup detection). + - Does **not** read baseline JSONs from this folder. + We have provided a set of baseline results for the KernelBench problems on a variety of hardware as well as various PyTorch configurations. All (current) baseline are ran with PyTorch `2.5.0+cu124` and CUDA `12.4`. diff --git a/scripts/eval_from_generations.py b/scripts/eval_from_generations.py index 247410f3..6fac151b 100644 --- a/scripts/eval_from_generations.py +++ b/scripts/eval_from_generations.py @@ -53,7 +53,7 @@ app = modal.App("eval_from_generations_modal") gpu_arch_mapping = {"L40S": ["Ada"], "H100": ["Hopper"], "A100": ["Ampere"], "L4": ["Ada"], "T4": ["Turing"], "A10G": ["Ampere"]} -cuda_version = "12.8.0" # should be no greater than host CUDA version +cuda_version = "13.0.0" # should be no greater than host CUDA version flavor = "devel" # includes full CUDA toolkit operating_sys = "ubuntu22.04" tag = f"{cuda_version}-{flavor}-{operating_sys}" @@ -71,7 +71,7 @@ ) .uv_sync(uv_project_dir=REPO_TOP_DIR) - .run_commands("git clone -b tk-v2 https://github.com/HazyResearch/ThunderKittens.git /root/ThunderKittens") + .run_commands("git clone -b main https://github.com/HazyResearch/ThunderKittens.git /root/ThunderKittens") .env({ "THUNDERKITTENS_ROOT": "/root/ThunderKittens", "PYTHONPATH": "/root/src:/root" diff --git a/scripts/generate_and_eval_single_sample_modal.py b/scripts/generate_and_eval_single_sample_modal.py index 7308d228..783076d9 100644 --- a/scripts/generate_and_eval_single_sample_modal.py +++ b/scripts/generate_and_eval_single_sample_modal.py @@ -1,7 +1,7 @@ ''' Example Usage: -python scripts/generate_and_eval_single_sample_modal.py dataset_src=huggingfac level=1 problem_id=1 eval_mode=modal gpu=L40S - server_type=deepseek model_name=deepseek-coder max_tokens=4096 temperature=0.0 +uv run python scripts/generate_and_eval_single_sample_modal.py dataset_src=huggingface level=1 problem_id=1 eval_mode=modal gpu=L40S + server_type=gemini model_name=gemini-2.5-flash max_tokens=4096 temperature=0.0 ''' import pydra @@ -89,7 +89,7 @@ def verbose_logging(self): def __repr__(self): return f"EvalConfig({self.to_dict()})" -cuda_version = "12.8.0" # should be no greater than host CUDA version +cuda_version = "13.0.0" # should be no greater than host CUDA version flavor = "devel" # includes full CUDA toolkit operating_sys = "ubuntu22.04" tag = f"{cuda_version}-{flavor}-{operating_sys}" @@ -105,7 +105,7 @@ def __repr__(self): ) .uv_sync(uv_project_dir=REPO_TOP_DIR, extras=["gpu"]) - .run_commands("git clone -b tk-v2 https://github.com/HazyResearch/ThunderKittens.git /root/ThunderKittens") + .run_commands("git clone -b main https://github.com/HazyResearch/ThunderKittens.git /root/ThunderKittens") .env({ "THUNDERKITTENS_ROOT": "/root/ThunderKittens", "PYTHONPATH": "/root:/root/src" diff --git a/scripts/generate_baseline_time.py b/scripts/generate_baseline_time.py index a2c96a03..e53fd915 100644 --- a/scripts/generate_baseline_time.py +++ b/scripts/generate_baseline_time.py @@ -1,15 +1,7 @@ import torch import numpy as np -from kernelbench.eval import ( - load_original_model_and_inputs, - set_seed, - fetch_ref_arch_from_problem_id, -) -from kernelbench.timing import ( - get_timing_function, - get_timing_stats, -) from kernelbench.dataset import construct_kernelbench_dataset, fetch_ref_arch_from_dataset +from kernelbench.timing import measure_ref_program_time from kernelbench.utils import read_file import os import json @@ -48,72 +40,12 @@ TIMING_DIR = os.path.join(REPO_TOP_PATH, "results", "timing") -def measure_program_time( - ref_arch_name: str, - ref_arch_src: str, - num_trials: int = 100, - use_torch_compile: bool = False, - torch_compile_backend: str="inductor", - torch_compile_options: str="default", - device: torch.device="cuda:0", - verbose: bool = False, - timing_method: str = "cuda_event", -) -> dict: - """ - Measure the time of a KernelBench reference architecture - """ - context = {} - Model, get_init_inputs, get_inputs = load_original_model_and_inputs( - ref_arch_src, context - ) - try: - with torch.no_grad(): - torch.cuda.synchronize(device=device) - set_seed(42) - inputs = get_inputs() - set_seed(42) - init_inputs = get_init_inputs() - inputs = [ - x.cuda(device=device) if isinstance(x, torch.Tensor) else x - for x in inputs - ] - init_inputs = [ - x.cuda(device=device) if isinstance(x, torch.Tensor) else x - for x in init_inputs - ] - - # Initialize PyTorch model, use this for eager mode execution - model = Model(*init_inputs) - - if use_torch_compile: - print(f"Using torch.compile to compile model {ref_arch_name} with {torch_compile_backend} backend and {torch_compile_options} mode") - model = torch.compile(model, backend=torch_compile_backend, mode=torch_compile_options) - else: - print(f"Using PyTorch Eager Execution on {ref_arch_name}") - - model = model.cuda(device=device) - torch.cuda.synchronize(device=device) - - # run chosen timing function - timing_fn = get_timing_function(timing_method) - elapsed_times = timing_fn( - model, inputs, num_trials=num_trials, verbose=verbose, device=device - ) - runtime_stats = get_timing_stats(elapsed_times, device=device) - - if verbose: - print(f"{ref_arch_name} {runtime_stats}") - - return runtime_stats - except Exception as e: - print(f"[Eval] Error in Measuring Performance: {e}") - - def record_baseline_times(use_torch_compile: bool = False, torch_compile_backend: str="inductor", torch_compile_options: str="default", - file_name: str="baseline_time.json"): + file_name: str="baseline_time.json", + precision: str="fp32"): """ Generate baseline time for KernelBench, configure profiler options for PyTorch @@ -129,14 +61,15 @@ def record_baseline_times(use_torch_compile: bool = False, num_problems = len(dataset) for problem_id in tqdm(dataset.get_problem_ids()): ref_arch_path, ref_arch_name, ref_arch_src = fetch_ref_arch_from_dataset(dataset, problem_id) - runtime_stats = measure_program_time( + runtime_stats = measure_ref_program_time( ref_arch_name=ref_arch_name, ref_arch_src=ref_arch_src, use_torch_compile=use_torch_compile, torch_compile_backend=torch_compile_backend, torch_compile_options=torch_compile_options, device=device, - verbose=False # do not print + verbose=False, # do not print + precision=precision, ) json_results[f"level{level}"][ref_arch_name] = runtime_stats @@ -157,14 +90,15 @@ def test_measure_particular_program(level_num: int, problem_id: int): ref_arch_path, ref_arch_name, ref_arch_src = fetch_ref_arch_from_dataset(dataset, problem_id) - exec_stats = measure_program_time( + exec_stats = measure_ref_program_time( ref_arch_name=ref_arch_name, ref_arch_src=ref_arch_src, use_torch_compile=True, torch_compile_backend="inductor", torch_compile_options="default", device=device, - verbose=False + verbose=False, + precision="bf16" ) print(f"Execution time for {ref_arch_name}: {exec_stats}") @@ -188,20 +122,23 @@ def test_measure_particular_program(level_num: int, problem_id: int): record_baseline_times(use_torch_compile=False, torch_compile_backend=None, torch_compile_options=None, - file_name=f"{hardware_name}/baseline_time_torch.json") + file_name=f"{hardware_name}/baseline_time_torch.json", + precision="bf16") # 2. Record Torch Compile using Inductor for torch_compile_mode in ["default", "reduce-overhead", "max-autotune", "max-autotune-no-cudagraphs"]: record_baseline_times(use_torch_compile=True, torch_compile_backend="inductor", torch_compile_options=torch_compile_mode, - file_name=f"{hardware_name}/baseline_time_torch_compile_inductor_{torch_compile_mode}.json") + file_name=f"{hardware_name}/baseline_time_torch_compile_inductor_{torch_compile_mode}.json", + precision="bf16") # 3. Record Torch Compile using cudagraphs record_baseline_times(use_torch_compile=True, torch_compile_backend="cudagraphs", torch_compile_options=None, - file_name=f"{hardware_name}/baseline_time_torch_compile_cudagraphs.json") + file_name=f"{hardware_name}/baseline_time_torch_compile_cudagraphs.json", + precision="bf16") @@ -216,52 +153,3 @@ def test_measure_particular_program(level_num: int, problem_id: int): - -################################################################################ -# Deprecated -################################################################################ - - -def get_time_old(level_num, problem_id, num_trials=100, torch_compile=False): - raise DeprecationWarning("Use New measure_program_time instead") - ref_arch_name, ref_arch_src = fetch_ref_arch_from_level_problem_id( - level_num, problem_id, with_name=True - ) - ref_arch_name = os.path.basename(ref_arch_name) - context = {} - Model, get_init_inputs, get_inputs = load_original_model_and_inputs( - ref_arch_src, context - ) - try: - with torch.no_grad(): - torch.cuda.synchronize(device=device) - set_seed(42) - inputs = get_inputs() - set_seed(42) - init_inputs = get_init_inputs() - inputs = [ - x.cuda(device=device) if isinstance(x, torch.Tensor) else x - for x in inputs - ] - init_inputs = [ - x.cuda(device=device) if isinstance(x, torch.Tensor) else x - for x in init_inputs - ] - model = Model(*init_inputs) - - if torch_compile: - model = torch.compile(model) - print("Compiled model Done") - model = model.cuda(device=device) - torch.cuda.synchronize(device=device) - elapsed_times = time_execution_with_cuda_event( - model, *inputs, num_trials=num_trials, verbose=False, device=device - ) - runtime_stats = get_timing_stats(elapsed_times, device=device) - # json_results[f"level{level_num}"][ref_arch_name] = runtime_stats - print(f"{ref_arch_name} {runtime_stats}") - return (ref_arch_name, runtime_stats) - except Exception as e: - print(f"[Eval] Error in Measuring Performance: {e}") - - diff --git a/scripts/generate_baseline_time_modal.py b/scripts/generate_baseline_time_modal.py index e9c8428e..8cc409fa 100644 --- a/scripts/generate_baseline_time_modal.py +++ b/scripts/generate_baseline_time_modal.py @@ -72,12 +72,15 @@ def __init__(self): # Number of trials for timing self.num_trials = 100 + # Precision for timing + self.precision = "fp32" + # Modal Infra import modal app = modal.App("generate_baseline_modal") gpu_arch_mapping = {"L40S": ["Ada"], "H100": ["Hopper"], "A100": ["Ampere"], "A100-80GB": ["Ampere"], "L4": ["Ada"], "T4": ["Turing"], "A10G": ["Ampere"]} -cuda_version = "12.8.0" # should be no greater than host CUDA version +cuda_version = "13.0.0" # should be no greater than host CUDA version flavor = "devel" # includes full CUDA toolkit operating_sys = "ubuntu22.04" tag = f"{cuda_version}-{flavor}-{operating_sys}" @@ -140,65 +143,30 @@ def measure_program_time( torch_compile_options: str="default", device: torch.device = torch.cuda.current_device() if torch.cuda.is_available() else None, verbose: bool = False, + precision: str = "fp32", ): - """ - Measure the time of a KernelBench reference architecture - """ - context = {} - Model, get_init_inputs, get_inputs = load_original_model_and_inputs( - ref_arch_src, context + from kernelbench.timing import measure_ref_program_time + return measure_ref_program_time( + ref_arch_name=ref_arch_name, + ref_arch_src=ref_arch_src, + num_trials=num_trials, + num_warmup=3, + discard_first=1, + timing_method=timing_method, + use_torch_compile=use_torch_compile, + torch_compile_backend=torch_compile_backend, + torch_compile_options=torch_compile_options, + device=device, + verbose=verbose, + precision=precision, ) - try: - with torch.no_grad(): - torch.cuda.synchronize(device=device) - set_seed(42) - inputs = get_inputs() - set_seed(42) - init_inputs = get_init_inputs() - inputs = [ - x.cuda(device=device) if isinstance(x, torch.Tensor) else x - for x in inputs - ] - init_inputs = [ - x.cuda(device=device) if isinstance(x, torch.Tensor) else x - for x in init_inputs - ] - - # Initialize PyTorch model, use this for eager mode execution - model = Model(*init_inputs) - - if use_torch_compile: - print(f"Using torch.compile to compile model {ref_arch_name} with {torch_compile_backend} backend and {torch_compile_options} mode") - model = torch.compile(model, backend=torch_compile_backend, mode=torch_compile_options) - else: - print(f"Using PyTorch Eager Execution on {ref_arch_name}") - - model = model.cuda(device=device) - timing_func = get_timing_function(timing_method) - torch.cuda.synchronize(device=device) - elapsed_times = timing_func( - model, - inputs, - num_warmup=3, # or any default you prefer - num_trials=num_trials, - discard_first=1, # or 0 to include first trial - verbose=verbose, - device=device, - ) - runtime_stats = get_timing_stats(elapsed_times, device=device) - - if verbose: - print(f"{ref_arch_name} {runtime_stats}") - - return runtime_stats - except Exception as e: - print(f"[Eval] Error in Measuring Performance: {e}") def record_baseline_times(config: BaselineConfig, use_torch_compile: bool = False, torch_compile_backend: str="inductor", torch_compile_options: str="default", - file_name: str="baseline_time.json"): + file_name: str="baseline_time.json", + precision: str = "fp32"): """ Generate baseline time for KernelBench using Modal's native parallelization. Spawns multiple GPU containers in parallel for faster processing. @@ -234,6 +202,7 @@ def record_baseline_times(config: BaselineConfig, torch_compile_options=torch_compile_options, device=torch.device("cuda:0"), verbose=False, + precision=precision, ) futures.append((p_id, ref_arch_name, future)) @@ -276,6 +245,7 @@ def main(config: BaselineConfig): print("\n[2/2] Recording baseline times with Torch Compile (inductor, default mode)...") record_baseline_times( config=config, + precision=config.precision, use_torch_compile=True, torch_compile_backend="inductor", torch_compile_options="default", @@ -300,54 +270,3 @@ def main(config: BaselineConfig): # get_time(2, 43, torch_compile=False) # get_time(2, 43, torch_compile=True) - - - -################################################################################ -# Deprecated -################################################################################ - - -def get_time_old(level_num, problem_id, num_trials=100, torch_compile=False): - raise DeprecationWarning("Use New measure_program_time instead") - ref_arch_name, ref_arch_src = fetch_ref_arch_from_level_problem_id( - level_num, problem_id, with_name=True - ) - ref_arch_name = os.path.basename(ref_arch_name) - context = {} - Model, get_init_inputs, get_inputs = load_original_model_and_inputs( - ref_arch_src, context - ) - try: - with torch.no_grad(): - torch.cuda.synchronize(device=device) - set_seed(42) - inputs = get_inputs() - set_seed(42) - init_inputs = get_init_inputs() - inputs = [ - x.cuda(device=device) if isinstance(x, torch.Tensor) else x - for x in inputs - ] - init_inputs = [ - x.cuda(device=device) if isinstance(x, torch.Tensor) else x - for x in init_inputs - ] - model = Model(*init_inputs) - - if torch_compile: - model = torch.compile(model) - print("Compiled model Done") - model = model.cuda(device=device) - torch.cuda.synchronize(device=device) - elapsed_times = time_execution_with_cuda_event( - model, *inputs, num_trials=num_trials, verbose=False, device=device - ) - runtime_stats = get_timing_stats(elapsed_times, device=device) - # json_results[f"level{level_num}"][ref_arch_name] = runtime_stats - print(f"{ref_arch_name} {runtime_stats}") - return (ref_arch_name, runtime_stats) - except Exception as e: - print(f"[Eval] Error in Measuring Performance: {e}") - - diff --git a/scripts/get_baseline_time_single_problem.py b/scripts/get_baseline_time_single_problem.py index 91e1472f..9d0e8816 100644 --- a/scripts/get_baseline_time_single_problem.py +++ b/scripts/get_baseline_time_single_problem.py @@ -1,70 +1,6 @@ import torch import numpy as np -from kernelbench.eval import ( - load_original_model_and_inputs, - set_seed, - fetch_ref_arch_from_problem_id, -) - -from src.timing import get_timing_function, get_timing_stats - -def measure_program_time( - ref_arch_name: str, - ref_arch_src: str, - num_trials: int = 100, - timing_method: str="cuda_event", - use_torch_compile: bool = False, - torch_compile_backend: str="inductor", - torch_compile_options: str="default", - device: torch.device="cuda:0", - verbose: bool = False, -) -> dict: - """ - Measure the time of a KernelBench reference architecture - """ - context = {} - Model, get_init_inputs, get_inputs = load_original_model_and_inputs( - ref_arch_src, context - ) - try: - with torch.no_grad(): - torch.cuda.synchronize(device=device) - set_seed(42) - inputs = get_inputs() - set_seed(42) - init_inputs = get_init_inputs() - inputs = [ - x.cuda(device=device) if isinstance(x, torch.Tensor) else x - for x in inputs - ] - init_inputs = [ - x.cuda(device=device) if isinstance(x, torch.Tensor) else x - for x in init_inputs - ] - - # Initialize PyTorch model, use this for eager mode execution - model = Model(*init_inputs) - - if use_torch_compile: - print(f"Using torch.compile to compile model {ref_arch_name} with {torch_compile_backend} backend and {torch_compile_options} mode") - model = torch.compile(model, backend=torch_compile_backend, mode=torch_compile_options) - else: - print(f"Using PyTorch Eager Execution on {ref_arch_name}") - - model = model.cuda(device=device) - torch.cuda.synchronize(device=device) - timing_func = get_timing_function(timing_method ) - elapsed_times = timing_func( - model, inputs, num_warmup=3, num_trials=num_trials, discard_first=1, verbose=verbose, device=device - ) - runtime_stats = get_timing_stats(elapsed_times, device=device) - - if verbose: - print(f"{ref_arch_name} {runtime_stats}") - - return runtime_stats - except Exception as e: - print(f"[Eval] Error in Measuring Performance: {e}") +from kernelbench.timing import measure_ref_program_time if __name__ == "__main__": ref_arch_name = "softmax" @@ -89,4 +25,4 @@ def get_inputs(): def get_init_inputs(): return [] # No special initialization inputs needed """ - print(measure_program_time(ref_arch_name, ref_arch_src, use_torch_compile=False, timing_method="cuda_event")) \ No newline at end of file + print(measure_ref_program_time(ref_arch_name, ref_arch_src, use_torch_compile=False, timing_method="cuda_event", precision="fp32")) \ No newline at end of file diff --git a/scripts/run_and_check.py b/scripts/run_and_check.py index d253dd45..4d8b95d1 100644 --- a/scripts/run_and_check.py +++ b/scripts/run_and_check.py @@ -7,7 +7,7 @@ from kernelbench import eval as kernel_eval from kernelbench import utils as kernel_utils -from scripts.generate_baseline_time import measure_program_time +from kernelbench.timing import measure_ref_program_time from kernelbench.utils import read_file from kernelbench.kernel_static_checker import validate_kernel_static @@ -26,7 +26,7 @@ REPO_TOP_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), "..")) -cuda_version = "12.8.0" +cuda_version = "13.0.0" flavor = "devel" operating_sys = "ubuntu22.04" tag = f"{cuda_version}-{flavor}-{operating_sys}" @@ -38,8 +38,8 @@ image = ( modal.Image.from_registry(f"nvidia/cuda:{tag}", add_python="3.10") .apt_install("git", "gcc-10", "g++-10", "clang") - .uv_sync(uv_project_dir=REPO_TOP_PATH) - .run_commands("git clone -b tk-v2 https://github.com/HazyResearch/ThunderKittens.git /root/ThunderKittens") + .uv_sync(uv_project_dir=REPO_TOP_PATH, extras=["gpu"]) + .run_commands("git clone -b main https://github.com/HazyResearch/ThunderKittens.git /root/ThunderKittens") .env({ "THUNDERKITTENS_ROOT": "/root/ThunderKittens", "PYTHONPATH": "/root:/root/src:/root/scripts" @@ -225,23 +225,26 @@ def measure_program_time_modal( use_torch_compile: bool, torch_compile_backend: str, torch_compile_options: str, - gpu_arch: list + gpu_arch: list, + precision: str, ): """Measure the execution time of a reference program on Modal""" - from scripts.generate_baseline_time import measure_program_time + from kernelbench.timing import measure_ref_program_time from kernelbench.utils import set_gpu_arch set_gpu_arch(gpu_arch) device = torch.device("cuda:0") - return measure_program_time( + return measure_ref_program_time( ref_arch_name="Reference Program", ref_arch_src=ref_arch_src, num_trials=num_trials, use_torch_compile=use_torch_compile, torch_compile_backend=torch_compile_backend, torch_compile_options=torch_compile_options, - device=device + verbose=False, + device=device, + precision=precision, ) @@ -311,21 +314,27 @@ def main(config: ScriptConfig): # Measure baseline time print("[INFO] Measuring reference program time") # Default using PyTorch Eager here - ref_time_eager_result = measure_program_time(ref_arch_name="Reference Program", + ref_time_eager_result = measure_ref_program_time(ref_arch_name="Reference Program", ref_arch_src=ref_arch_src, num_trials=config.num_perf_trials, use_torch_compile=False, - device=device) + timing_method=config.timing_method, + device=device, + verbose=False, + precision=config.precision, + ) ref_exec_eager_time = ref_time_eager_result.get("mean", None) # Measure Torch Compile time - ref_time_compile_result = measure_program_time(ref_arch_name="Reference Program", + ref_time_compile_result = measure_ref_program_time(ref_arch_name="Reference Program", ref_arch_src=ref_arch_src, num_trials=config.num_perf_trials, use_torch_compile=True, - torch_compile_backend="inductor", - torch_compile_options="default", - device=device) + timing_method=config.timing_method, + device=device, + verbose=False, + precision=config.precision, + ) ref_exec_compile_time = ref_time_compile_result.get("mean", None) elif config.eval_mode == "modal": @@ -356,7 +365,8 @@ def main(config: ScriptConfig): use_torch_compile=False, torch_compile_backend=None, torch_compile_options=None, - gpu_arch=gpu_arch + gpu_arch=gpu_arch, + precision=config.precision, ) ref_exec_eager_time = ref_time_eager_result.get("mean", None) @@ -370,7 +380,8 @@ def main(config: ScriptConfig): use_torch_compile=True, torch_compile_backend="inductor", torch_compile_options="default", - gpu_arch=gpu_arch + gpu_arch=gpu_arch, + precision=config.precision, ) ref_exec_compile_time = ref_time_compile_result.get("mean", None) diff --git a/src/kernelbench/eval.py b/src/kernelbench/eval.py index 47f59793..dd79b2c0 100644 --- a/src/kernelbench/eval.py +++ b/src/kernelbench/eval.py @@ -626,6 +626,8 @@ def eval_kernel_against_ref( print(f"[Eval] Error in Measuring Performance: {e}") kernel_exec_result.metadata["error_during_performance"] = e + # To get base PyTorch time (eager, various compile modes) + # please use timing.measure_ref_program_time() ############################################################### diff --git a/src/kernelbench/timing.py b/src/kernelbench/timing.py index 83908391..52a2b85e 100644 --- a/src/kernelbench/timing.py +++ b/src/kernelbench/timing.py @@ -2,9 +2,119 @@ import json import numpy as np import time -from typing import Any, Optional +from typing import Any, Optional, Union import os + +def measure_ref_program_time( + ref_arch_name: str, + ref_arch_src: str, # PyTorch program code string + num_warmup: int = 5, + num_trials: int = 100, + discard_first: int = 1, + timing_method: str = "cuda_event", + # Torch eager or torch.compile configuration + use_torch_compile: bool = False, + torch_compile_backend: str = "inductor", + torch_compile_options: str = "default", + device: torch.device = torch.device("cuda:0"), + verbose: bool = False, + precision: Union[str, torch.dtype] = "fp32", # fp16, fp32, bf16 or torch.dtype +) -> dict: + """Measure the runtime of a KernelBench *reference* program. + + This measures the execution time of the reference `Model` defined in + `ref_arch_src` (i.e., *not* `ModelNew`). It can optionally run the reference + model under `torch.compile`. + + NOTE: This function is for PyTorch-only reference models, so no `backend` parameter is needed. + For pure PyTorch program, we assume it operates all on main stream (as torch operators execute on the default cuda stream). + Standard PyTorch ops do NOT spawn extra streams. + """ + from kernelbench.eval import load_original_model_and_inputs, set_seed + + context = {} + Model, get_init_inputs, get_inputs = load_original_model_and_inputs( + ref_arch_src, context + ) + + try: + with torch.no_grad(): + if isinstance(device, str): + device = torch.device(device) + elif isinstance(device, int): + device = torch.device(f"cuda:{device}") + torch.cuda.set_device(device) + + torch.cuda.synchronize(device=device) + set_seed(42) + inputs = get_inputs() + set_seed(42) + init_inputs = get_init_inputs() + + from kernelbench.eval import get_torch_dtype_from_string + if isinstance(precision, str): + precision_dtype = get_torch_dtype_from_string(precision) + else: + precision_dtype = precision + + + # set model weights and inputs to specified precision + inputs = [ + x.to(device=device, dtype=precision_dtype) if isinstance(x, torch.Tensor) else x + for x in inputs + ] + init_inputs = [ + x.to(device=device, dtype=precision_dtype) if isinstance(x, torch.Tensor) else x + for x in init_inputs + ] + + model = Model(*init_inputs) + model = model.to(device=device, dtype=precision_dtype) + + # convert all precision so torch compile can target specific dtype + if use_torch_compile: + torch._dynamo.reset() # reset torch dynamo cache (clear memory and reset graph) + print( + f"Using torch.compile to compile model {ref_arch_name} with {torch_compile_backend} backend and {torch_compile_options} mode" + ) + # NOTE: torch compile uses lazy compilation (triggered by first forward pass) + # the warmup in the timing function handles that and should not affect timed trials + model = torch.compile( + model, + backend=torch_compile_backend, + mode=torch_compile_options, + ) + else: + print(f"Using PyTorch Eager Execution on {ref_arch_name}") + + torch.cuda.synchronize(device=device) + + timing_fn = get_timing_function(timing_method) + elapsed_times = timing_fn( + model, + inputs, + num_warmup=num_warmup, + num_trials=num_trials, + discard_first=discard_first, + verbose=verbose, + device=device, + ) + runtime_stats = get_timing_stats(elapsed_times, device=device) + + if verbose: + print(f"{ref_arch_name} {runtime_stats}") + + return runtime_stats + except Exception as e: + print(f"[Eval] Error in Measuring Performance: {e}") + return None + + +def measure_program_time(*args, **kwargs): + """Alias for backwards compatibility. See `measure_ref_program_time`.""" + return measure_ref_program_time(*args, **kwargs) + ################################################################################ # timing.py # Various timing methods and utilities for performance evaluation From 42cc2fab3fa1589c15deec62b75a0c1e88941944 Mon Sep 17 00:00:00 2001 From: Amanzhol Salykov Date: Fri, 27 Feb 2026 09:05:02 +0100 Subject: [PATCH 21/24] Add HIP backend (#135) for AMD GPUs with AMD folks * add hip backend for eval_single_sample * update pyproject.toml for CDNA4 * update * update * update * update * add ROCm version requirement * check and add more guardrails * add hip keywords check --------- Co-authored-by: Simon Guo --- README.md | 10 ++- pyproject.toml | 4 +- scripts/generate_and_eval_single_sample.py | 4 +- src/kernelbench/eval.py | 19 ++++- src/kernelbench/kernel_static_checker.py | 27 +++++- src/kernelbench/profile.py | 9 +- src/kernelbench/prompts/hardware/gpu_specs.py | 85 +++++++++++++++++++ .../prompts/model_new_ex_add_hip.py | 46 ++++++++++ src/kernelbench/prompts/prompts.toml | 5 ++ src/kernelbench/timing.py | 15 ++-- .../unit_tests/test_validate_kernel_static.py | 2 +- src/kernelbench/utils.py | 45 ++++++++-- 12 files changed, 251 insertions(+), 20 deletions(-) create mode 100644 src/kernelbench/prompts/model_new_ex_add_hip.py diff --git a/README.md b/README.md index 7343e73b..ce9348c6 100644 --- a/README.md +++ b/README.md @@ -29,7 +29,7 @@ We construct KernelBench to have 4 Levels of categories: - **Level 4 🤗**: Level Hugging Face Optimize whole model architectures from HuggingFace -We are actively extending KernelBench to other DSLs beyond `cuda` as well (see below). +We are actively extending KernelBench to other DSLs beyond `cuda` as well (see below), as well as AMD GPU support. ## ⚖️ Evaluation #### Methodology @@ -85,6 +85,9 @@ We have transitioned to using `pyproject.toml` and `uv` for dependency managemen # Install base dependencies (works without a local GPU) uv sync +# Install with AMD ROCm backend (ROCm>=7.1 is required) +uv add torch --index pytorch=https://download.pytorch.org/whl/rocm7.1 + # Install with GPU dependencies (for local GPU evaluation) uv sync --extra gpu @@ -92,6 +95,8 @@ uv sync --extra gpu uv run python scripts/.py ... ``` +For AMD GPU aka ROCm backend (ROCm>=7.1), please add `uv remove torch && uv add torch --index pytorch=https://download.pytorch.org/whl/rocm7.1` for RoCm compatible PyTorch to configure your dependencies. Running in a docker image is recommended for this due to complexity of ROCm setup. + You can still use `conda (python=3.10)` to create your environment and install dependencies with `requirements.txt`. We use `litellm` for API calls. Please set your keys by creating a `.env` following our `.env.example`. @@ -117,8 +122,9 @@ uv run python scripts/generate_and_eval_single_sample.py dataset_src=huggingface **What you might need to modify** * **`gpu_arch`** - Depend on your GPU, you might need to adjust the `gpu_arch` argument to reflect your hardware. * **`precision`** - You can specify the precision of tensor by `precision=fp32`. Currently all of our reported results are `fp32` but we added support for `fp16` & `bf16`. -* **`backend`** - We are also supporting other GPU programming languages beyond `cuda`. Simply specify `backend=triton`. For now we support DSLs: `cuda`, `triton`, `cute`, `tilelang`, `thunderkittens`. +* **`backend`** - We are also supporting other GPU programming languages beyond `cuda`. For example, simply specify `backend=triton` or `backend=hip`. For now we support NVIDIA GPUs with programming frameworks and DSLs: `cuda`, `triton`, `cute`, `tilelang`, `thunderkittens`. +Note for AMD GPUs: Use `hip` backend, `gpu_arch` currently supported: `gfx942`, `gfx950`. Note on setting up ThunderKittens (TK) locally: to use `backend=thunderkittens`, you need to git clone the ThunderKittens repo and set the following environment variable to point to your local ThunderKittens directory, `export THUNDERKITTENS_ROOT=`, and all ThunderKitten programs as shown in the [example](src/kernelbench/prompts/model_new_ex_add_thunderkittens.py), should contain `tk_root = os.environ.get("THUNDERKITTENS_ROOT", "/root/ThunderKittens")`, which enable the kernel to include the right TK primitives. In addition, we only support BF16 for TK right now. diff --git a/pyproject.toml b/pyproject.toml index bed37150..f3f98ae2 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -10,10 +10,10 @@ version = "0.2.0.dev0" requires-python = "==3.10.*" dependencies = [ # Frameworks - "torch==2.9.0", + "torch>=2.9.0", "transformers", - "datasets", + "datasets>=2.19.0", "modal", # helper diff --git a/scripts/generate_and_eval_single_sample.py b/scripts/generate_and_eval_single_sample.py index fce1b16f..fbde28b9 100644 --- a/scripts/generate_and_eval_single_sample.py +++ b/scripts/generate_and_eval_single_sample.py @@ -124,6 +124,8 @@ def main(config: EvalConfig): ) if config.gpu_arch: + if (type(config.gpu_arch) is not list): # normalization to list + config.gpu_arch = [config.gpu_arch] set_gpu_arch(config.gpu_arch) # otherwise build for all architectures if config.log: @@ -174,7 +176,7 @@ def main(config: EvalConfig): include_hardware = include_hardware.lower() in ["true", "1", "yes"] config.include_hardware_info = include_hardware - supported_backends = {"cuda", "triton", "tilelang", "cute", "thunderkittens"} + supported_backends = {"cuda", "hip", "triton", "tilelang", "cute", "thunderkittens"} backend = config.backend.lower() if backend not in supported_backends: raise ValueError( diff --git a/src/kernelbench/eval.py b/src/kernelbench/eval.py index dd79b2c0..3557dc94 100644 --- a/src/kernelbench/eval.py +++ b/src/kernelbench/eval.py @@ -429,7 +429,18 @@ def eval_kernel_against_ref( # TODO: check device is busy assert torch.cuda.is_available(), "CUDA is not available, cannot run Eval" - if backend.lower() == "tilelang": + # Backend-GPU vendor validation + from .utils import get_gpu_vendor + vendor = get_gpu_vendor(device) + backend_lower = backend.lower() + # HIP is AMD-only + if backend_lower == "hip" and vendor != "amd": + raise ValueError(f"HIP backend requires AMD GPU, got {vendor}") + # cuda/cute/thunderkittens are NVIDIA-only (triton/tilelang work on both) + if backend_lower in ["cuda", "cute", "thunderkittens"] and vendor == "amd": + raise ValueError(f"{backend} backend requires NVIDIA GPU, got AMD") + + if backend_lower == "tilelang": assert precision == torch.float16 or precision == torch.bfloat16, "TileLang only supports fp16 or bfloat16" torch.set_printoptions( @@ -463,7 +474,11 @@ def eval_kernel_against_ref( raise ValueError( f"device must be an int or torch.device, got {type(device)}" ) - os.environ["CUDA_VISIBLE_DEVICES"] = str(device_num) + # NVIDIA uses CUDA_VISIBLE_DEVICES, AMD uses HIP_VISIBLE_DEVICES + if vendor == "amd": + os.environ["HIP_VISIBLE_DEVICES"] = str(device_num) + else: + os.environ["CUDA_VISIBLE_DEVICES"] = str(device_num) context = {} if verbose: diff --git a/src/kernelbench/kernel_static_checker.py b/src/kernelbench/kernel_static_checker.py index c8832a1a..7d97effa 100644 --- a/src/kernelbench/kernel_static_checker.py +++ b/src/kernelbench/kernel_static_checker.py @@ -184,6 +184,29 @@ def check_cuda_impl(code: str) -> Tuple[bool, str]: return (True, "Missing load_inline or cpp_extension for compilation") return (False, "") +# <========= HIP CHECKS =========> +# Rationale: Valid HIP kernels must have __global__ (kernel definition), +# use load_inline or cpp_extension (PyTorch's inline compilation) and +# use hipcc compiler +HIP_COMPILE_PATTERNS = ["load_inline", "cpp_extension"] + +def check_hip_impl(code: str) -> Tuple[bool, str]: + """ + Check for valid HIP kernel implementation. + + Requirements: + - Must have __global__ void kernel_name (kernel definition) + - Must have load_inline or cpp_extension (PyTorch inline compilation) + """ + code = _strip_comments(code) + if "__global__" not in code: + return (True, "Missing __global__ kernel definition") + if not any(p in code for p in HIP_COMPILE_PATTERNS): + return (True, "Missing load_inline or cpp_extension for compilation") + if "hipcc" not in code: + return (True, "Missing hipcc compiler") + return (False, "") + # <========= TRITON CHECKS =========> # Rationale: Triton kernels are compiled from @triton.jit decorated functions. # They must use tl.* operations (tl.load, tl.store, etc.) for actual kernel work. @@ -555,6 +578,7 @@ def check_precision_downgrade(code: str, precision: str = "fp32") -> Tuple[bool, # Backend-specific implementation checks # should be strict "cuda_impl": check_cuda_impl, + "hip_impl": check_hip_impl, "triton_impl": check_triton_impl, "tk_impl": check_tk_impl, "cute_impl": check_cute_impl, @@ -578,6 +602,7 @@ def check_precision_downgrade(code: str, precision: str = "fp32") -> Tuple[bool, # per backend implementation check, usually strict BACKEND_IMPL_CHECK = { "cuda": "cuda_impl", + "hip": "hip_impl", "triton": "triton_impl", "thunderkittens": "tk_impl", "cute": "cute_impl", @@ -614,7 +639,7 @@ def validate_kernel_static( Args: code: Kernel source code - backend: "cuda", "triton", or "thunderkittens" + backend: "cuda", "hip", "triton", or "thunderkittens" precision: "fp16", "fp32", or "bf16" (for future precision checks) forbidden: Check categories that cause errors (default: STRICT_CHECKS) warnings: Check categories that cause warnings (default: WARNING_CHECKS) diff --git a/src/kernelbench/profile.py b/src/kernelbench/profile.py index 8326324e..a4960438 100644 --- a/src/kernelbench/profile.py +++ b/src/kernelbench/profile.py @@ -90,13 +90,20 @@ def profile_with_nsight(func, metrics=None, num_trials=1): >>> print(results['gpu__time_duration.sum']) # Time in nanoseconds Raises: - RuntimeError: If nsight-python is not installed. + RuntimeError: If nsight-python is not installed or not on NVIDIA GPU. """ if not NSIGHT_AVAILABLE: raise RuntimeError( "nsight-python not available." ) + # NSight is NVIDIA-only + from kernelbench.utils import get_gpu_vendor + if get_gpu_vendor() != "nvidia": + raise RuntimeError( + "NSight profiling requires NVIDIA GPU. Not available on AMD." + ) + # Normalize metrics to a list if metrics is None: metrics = ['sm__cycles_active.avg'] diff --git a/src/kernelbench/prompts/hardware/gpu_specs.py b/src/kernelbench/prompts/hardware/gpu_specs.py index 800f20ef..7fde700e 100644 --- a/src/kernelbench/prompts/hardware/gpu_specs.py +++ b/src/kernelbench/prompts/hardware/gpu_specs.py @@ -118,6 +118,91 @@ "Maximum number of thread blocks per SM": "32", "Shared memory capacity per SM": "164 KB", "Maximum shared memory per thread block": "163 KB", + }, + # NOTE: In the future we will have a more unified format for various GPUs + "MI300X": { + "GPU Architecture": "gfx942", + "GPU Memory": "192GB", + "Memory Bandwidth": "5.3 TB/s", + "FP64 TFLOPS": "81.7", + "FP64 Matrix Core TFLOPS": "163.4", + "FP32 TFLOPS": "163.4", + "TF32 Matrix Core TFLOPS": "653.7 (1307.4 with sparsity)", + "BFLOAT16 Matrix Core TFLOPS": "1307.4 (2614.9 with sparsity)", + "FP16 Matrix Core TFLOPS": "1307.4 (2614.9 with sparsity)", + "FP8 Matrix Core TFLOPS": "2614.9 (5229.8 with sparsity)", + "INT8 Matrix Core TOPS": "2614.9 (5229.8 with sparsity)", + "Number of CU": "304", + "SIMDs per CU": "4", + "Wavefront Size": "64", + "Workgroup Max Size": "1024", + "Max Waves Per CU": "32", + "Max Threads per CU": "2048", + "Maximum number of registers per thread": "256", + "Shared memory capacity per CU": "64 KB", + }, + "MI325X": { + "GPU Architecture": "gfx942", + "GPU Memory": "256GB", + "Memory Bandwidth": "6TB/s", + "FP64 TFLOPS": "81.7", + "FP64 Matrix Core TFLOPS": "163.4", + "FP32 TFLOPS": "163.4", + "TF32 Matrix Core TFLOPS": "653.7 (1307.4 with sparsity)", + "BFLOAT16 Matrix Core TFLOPS": "1307.4 (2614.9 with sparsity)", + "FP16 Matrix Core TFLOPS": "1307.4 (2614.9 with sparsity)", + "FP8 Matrix Core TFLOPS": "2614.9 (5229.8 with sparsity)", + "INT8 Matrix Core TOPS": "2614.9 (5229.8 with sparsity)", + "Number of CU": "304", + "SIMDs per CU": "4", + "Wavefront Size": "64", + "Workgroup Max Size": "1024", + "Max Waves Per CU": "32", + "Max Threads per CU": "2048", + "Maximum number of registers per thread": "256", + "Shared memory capacity per CU": "64 KB", + }, + "MI350X": { + "GPU Architecture": "gfx950", + "GPU Memory": "288GB", + "Memory Bandwidth": "8TB/s", + "FP64 TFLOPS": "72.1", + "FP64 Matrix Core TFLOPS": "72.1", + "FP32 TFLOPS": "144.2", + "BFLOAT16 Matrix Core TFLOPS": "2300 (4600 with sparsity)", + "FP16 Matrix Core TFLOPS": "2300 (4600 with sparsity)", + "FP8 Matrix Core TFLOPS": "4600", + "MXFP6, MXFP4 Matrix Core TFLOPS": "9200", + "INT8 Matrix Core TOPS": "4600 (9200 with sparsity)", + "Number of CU": "256", + "SIMDs per CU": "4", + "Wavefront Size": "64", + "Workgroup Max Size": "1024", + "Max Waves Per CU": "32", + "Max Threads per CU": "2048", + "Maximum number of registers per thread": "256", + "Shared memory capacity per CU": "160 KB", + }, + "MI355X": { + "GPU Architecture": "gfx950", + "GPU Memory": "288GB", + "Memory Bandwidth": "8TB/s", + "FP64 TFLOPS": "78.6", + "FP64 Matrix Core TFLOPS": "78.6", + "FP32 TFLOPS": "157.3", + "BFLOAT16 Matrix Core TFLOPS": "2500 (5000 with sparsity)", + "FP16 Matrix Core TFLOPS": "2500 (5000 with sparsity)", + "FP8 Matrix Core TFLOPS": "5000", + "MXFP6, MXFP4 Matrix Core TFLOPS": "10000", + "INT8 Matrix Core TOPS": "5000 (10000 with sparsity)", + "Number of CU": "256", + "SIMDs per CU": "4", + "Wavefront Size": "64", + "Workgroup Max Size": "1024", + "Max Waves Per CU": "32", + "Max Threads per CU": "2048", + "Maximum number of registers per thread": "256", + "Shared memory capacity per CU": "160 KB", } } diff --git a/src/kernelbench/prompts/model_new_ex_add_hip.py b/src/kernelbench/prompts/model_new_ex_add_hip.py new file mode 100644 index 00000000..806aa876 --- /dev/null +++ b/src/kernelbench/prompts/model_new_ex_add_hip.py @@ -0,0 +1,46 @@ +import os +import torch +import torch.nn as nn +import torch.nn.functional as F +from torch.utils.cpp_extension import load_inline + +# Must include this line so PyTorch could use HIP compiler for AMD GPUs +os.environ["CXX"] = "hipcc" + +elementwise_add_cpp_source = """ +#include + +__global__ void elementwise_add_kernel(const float* a, const float* b, float* out, int size) { + int idx = blockIdx.x * blockDim.x + threadIdx.x; + if (idx < size) { + out[idx] = a[idx] + b[idx]; + } +} + +torch::Tensor elementwise_add_hip(torch::Tensor a, torch::Tensor b) { + auto size = a.numel(); + auto out = torch::zeros_like(a); + + const int block_size = 256; + const int num_blocks = (size + block_size - 1) / block_size; + + elementwise_add_kernel<<>>(a.data_ptr(), b.data_ptr(), out.data_ptr(), size); + + return out; +} +""" + +elementwise_add = load_inline( + name="elementwise_add", + cpp_sources=elementwise_add_cpp_source, + functions=["elementwise_add_hip"], + verbose=True, +) + +class ModelNew(nn.Module): + def __init__(self) -> None: + super().__init__() + self.elementwise_add = elementwise_add + + def forward(self, a, b): + return self.elementwise_add.elementwise_add_hip(a, b) \ No newline at end of file diff --git a/src/kernelbench/prompts/prompts.toml b/src/kernelbench/prompts/prompts.toml index 2768aa11..6a7dfcaa 100644 --- a/src/kernelbench/prompts/prompts.toml +++ b/src/kernelbench/prompts/prompts.toml @@ -54,6 +54,11 @@ backend_display = "ThunderKittens kernels" one_shot_new_arch = "src/kernelbench/prompts/model_new_ex_add_thunderkittens.py" # No few_shot_examples - will use one-shot when few_shot option is selected +[backends.hip] +backend_display = "AMD HIP kernels" +one_shot_new_arch = "src/kernelbench/prompts/model_new_ex_add_hip.py" +# No few_shot_examples - will use one-shot when few_shot option is selected + # ------------------------------------------------------------------------- # Precision: Precision-specific configuration # ------------------------------------------------------------------------- diff --git a/src/kernelbench/timing.py b/src/kernelbench/timing.py index 52a2b85e..f22920b4 100644 --- a/src/kernelbench/timing.py +++ b/src/kernelbench/timing.py @@ -510,20 +510,25 @@ def time_execution_with_nsight_python( """ Time a CUDA kernel function using nsight-python. - Note: nsight returns an average time across num_trials runs. + NOTE: NVIDIA-only. NSight Compute (ncu) does not work on AMD GPUs. + Returns a list with a single value (average time) for API consistency. GPU time from nsight is in nanoseconds, converted to milliseconds. - - Returns: - List containing one float: average elapsed time in milliseconds """ - from kernelbench.profile import profile_with_nsight + from kernelbench.utils import get_gpu_vendor if device is None: if verbose: print(f"Using current device: {torch.cuda.current_device()}") device = torch.cuda.current_device() + + # NSight is NVIDIA-only + if get_gpu_vendor(device) != "nvidia": + raise RuntimeError( + "NSight profiling requires NVIDIA GPU. " + "Use timing_method='cuda_event' or 'do_bench' for AMD." + ) with torch.cuda.device(device): # Warm ups diff --git a/src/kernelbench/unit_tests/test_validate_kernel_static.py b/src/kernelbench/unit_tests/test_validate_kernel_static.py index 55d97a2c..f4394624 100644 --- a/src/kernelbench/unit_tests/test_validate_kernel_static.py +++ b/src/kernelbench/unit_tests/test_validate_kernel_static.py @@ -254,7 +254,7 @@ def forward(self, x): """ # Test multiple backends - backends = ["cuda", "triton", "thunderkittens", "cute", "tilelang"] + backends = ["cuda", "hip", "triton", "thunderkittens", "cute", "tilelang"] for backend in backends: valid, errors, warnings = validate_kernel_static(code, backend=backend) diff --git a/src/kernelbench/utils.py b/src/kernelbench/utils.py index cf8b0ad8..e975cc63 100644 --- a/src/kernelbench/utils.py +++ b/src/kernelbench/utils.py @@ -38,16 +38,51 @@ # Inference Helpers ######################################################## +NVIDIA_ARCHS = ["Maxwell", "Pascal", "Volta", "Turing", "Ampere", "Hopper", "Ada", "Blackwell"] +AMD_ARCHS = ["gfx942", "gfx950"] # gfx942: CDNA3 (MI300), gfx950: CDNA4 (MI350) + + +######################################################## +# GPU Vendor Detection +######################################################## + +def get_gpu_vendor(device: torch.device | int | None = None) -> str: + """Returns 'nvidia', 'amd', or 'unknown' for the given device.""" + if not torch.cuda.is_available(): + return "unknown" + if device is None: + device = torch.cuda.current_device() + name = torch.cuda.get_device_name(device).upper() + if "NVIDIA" in name: + return "nvidia" + if "AMD" in name or "MI3" in name: + return "amd" + return "unknown" + + def set_gpu_arch(arch_list: list[str]): """ - Set env variable for torch cuda arch list to build kernels for specified architectures + Set env variable for torch to build kernels for specified architectures. + Supports both NVIDIA (TORCH_CUDA_ARCH_LIST) and AMD (PYTORCH_ROCM_ARCH). """ - valid_archs = ["Maxwell", "Pascal", "Volta", "Turing", "Ampere", "Hopper", "Ada"] + nvidia_archs = [] + amd_archs = [] + for arch in arch_list: - if arch not in valid_archs: - raise ValueError(f"Invalid architecture: {arch}. Must be one of {valid_archs}") + if arch in NVIDIA_ARCHS: + nvidia_archs.append(arch) + elif arch in AMD_ARCHS: + amd_archs.append(arch) + else: + raise ValueError(f"Invalid architecture: {arch}. Must be one of NVIDIA: {NVIDIA_ARCHS} or AMD: {AMD_ARCHS}") + + if nvidia_archs and amd_archs: + raise ValueError(f"Cannot mix NVIDIA and AMD architectures. Got NVIDIA: {nvidia_archs}, AMD: {amd_archs}") - os.environ["TORCH_CUDA_ARCH_LIST"] = ";".join(arch_list) + if nvidia_archs: + os.environ["TORCH_CUDA_ARCH_LIST"] = ";".join(nvidia_archs) + elif amd_archs: + os.environ["PYTORCH_ROCM_ARCH"] = ";".join(amd_archs) def query_server( prompt: str | list[dict], # string if normal prompt, list of dicts if chat prompt, From 2dcab5e37fb11b36d0e8f3a5a11d47eb9f349fba Mon Sep 17 00:00:00 2001 From: SebastianFisher <66392483+SebastianFisher@users.noreply.github.com> Date: Thu, 5 Mar 2026 00:38:15 -0800 Subject: [PATCH 22/24] update all legacy python commands to UV + document integration (#143) * fixing torch import missing, replacing some python3 with 'uv run' * update known integrations * link ongoing PRs --------- Co-authored-by: Simon Guo --- README.md | 40 +++++++++++++++------- results/timing/README.md | 4 +-- scripts/benchmark_eval_analysis.py | 4 +-- scripts/generate_and_eval_single_sample.py | 2 +- scripts/run_and_check.py | 10 +++--- src/kernelbench/utils.py | 1 + 6 files changed, 38 insertions(+), 23 deletions(-) diff --git a/README.md b/README.md index ce9348c6..36e2edfe 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,7 @@ # KernelBench: Can LLMs Write Efficient GPU Kernels? [ICML '25] -A benchmark for evaluating LLMs' ability to generate efficient GPU kernels +A benchmark and environment for evaluating LLMs' ability to generate efficient GPU kernels + +Specifically we task LLM to generate correct and efficient CUDA / DSL kernels for PyTorch programs on a target GPU. [arXiv](https://arxiv.org/html/2502.10517v1) | [blog post](https://scalingintelligence.stanford.edu/blogs/kernelbench/) | [HuggingFace Dataset](https://huggingface.co/datasets/ScalingIntelligence/KernelBench) @@ -16,7 +18,7 @@ The Huggingface [dataset](https://huggingface.co/datasets/ScalingIntelligence/Ke This repo provides core functionality for KernelBench and an easy-to-use set of scripts for evaluation. It is not intended to provide complex agentic scaffolds that solve this task; we recommend cloning and modifying this repo for your experiment, or using it as a git submodule. ## 👋 Task Description -We structure the problem for LLM to transpile operators described in PyTorch to CUDA kernels, at whatever level of granularity it desires to. +We structure the problem for LLMs to transpile operators described in PyTorch to CUDA kernels, at whatever level of granularity they desire. ![KernelBenchMascot](./assets/figures/KernelBenchWorkFlow.png) We construct KernelBench to have 4 Levels of categories: @@ -34,8 +36,8 @@ We are actively extending KernelBench to other DSLs beyond `cuda` as well (see b ## ⚖️ Evaluation #### Methodology To evaluate model-generated kernels, we need to check if they: -- **is correct ✅**: check against reference torch operators `n_correctness` times on randomized inputs. -- **is performant ⏱️**: compare against reference torch operators `n_trial` times to measure speedup between runtimes. +- **are correct ✅**: check against reference torch operators `n_correctness` times on randomized inputs. +- **are performant ⏱️**: compare against reference torch operators `n_trial` times to measure speedup between runtimes. Check out `src/eval.py` for details on how we implement correctness check and timing and `EVAL.md` for notes on evaluation and benchmarking guidelines [WIP]. @@ -116,11 +118,11 @@ It is easier to get started with a single problem. This will fetch the problem, uv run python scripts/generate_and_eval_single_sample.py dataset_src=huggingface level=2 problem_id=40 server_type=google model_name=gemini/gemini-2.5-flash # dataset_src could be "local" or "huggingface" -# add .verbose_logging for more visbility +# add .verbose_logging for more visibility ``` **What you might need to modify** -* **`gpu_arch`** - Depend on your GPU, you might need to adjust the `gpu_arch` argument to reflect your hardware. +* **`gpu_arch`** - Depending on your GPU, you might need to adjust the `gpu_arch` argument to reflect your hardware. * **`precision`** - You can specify the precision of tensor by `precision=fp32`. Currently all of our reported results are `fp32` but we added support for `fp16` & `bf16`. * **`backend`** - We are also supporting other GPU programming languages beyond `cuda`. For example, simply specify `backend=triton` or `backend=hip`. For now we support NVIDIA GPUs with programming frameworks and DSLs: `cuda`, `triton`, `cute`, `tilelang`, `thunderkittens`. @@ -128,7 +130,7 @@ Note for AMD GPUs: Use `hip` backend, `gpu_arch` currently supported: `gfx942`, Note on setting up ThunderKittens (TK) locally: to use `backend=thunderkittens`, you need to git clone the ThunderKittens repo and set the following environment variable to point to your local ThunderKittens directory, `export THUNDERKITTENS_ROOT=`, and all ThunderKitten programs as shown in the [example](src/kernelbench/prompts/model_new_ex_add_thunderkittens.py), should contain `tk_root = os.environ.get("THUNDERKITTENS_ROOT", "/root/ThunderKittens")`, which enable the kernel to include the right TK primitives. In addition, we only support BF16 for TK right now. -Check the config fields for comprehensive set of options. Note we provide the model with a one-shot example by default along with the minimum set of info; you can check out other prompt settings or construct your own in `src/prompt_constructor_toml.py`. +Check the config fields for a comprehensive set of options. Note we provide the model with a one-shot example by default along with the minimum set of info; you can check out other prompt settings or construct your own in `src/prompt_constructor_toml.py`. ### Run on all problems @@ -149,20 +151,30 @@ We provide `scripts/benchmark_eval_analysis.py` to analyze the eval results to c uv run python scripts/benchmark_eval_analysis.py run_name=test_hf_level_1 level=1 hardware=L40S_matx3 baseline=baseline_time_torch ``` If you are using a different hardware, you can generate the baseline time with `scripts/generate_baseline_time.py` script. -We provide some reference baseline times a variety of NVIDIA GPUs across generations in `results/timing`, but we recommend you to generate your own baseline time for more accurate results (cluster power, software version, all affects timing result). See `results/timing/README.md` for more details. +We provide some reference baseline times for a variety of NVIDIA GPUs across generations in `results/timing`, but we recommend you generate your own baseline time for more accurate results (cluster power, software version, all affect timing results). See `results/timing/README.md` for more details. -### Multi-Turn Framework & Integrations -We have also releaed the test-time framework [Caesar](https://github.com/ScalingIntelligence/caesar) that are used in the multi-turn / iterative refinement experiments in our paper. You can use or modify this framework for high-throughput test-time scaling (both sequential and parallel) targeting KernelBench problems. +## 🛣️ Upcoming Roadmap +Check out our [roadmap](https://github.com/ScalingIntelligence/KernelBench/issues/74) for what we plan to add as features. We welcome community contributions and discussions in these directions. +## 🔌 Integration You can also use KernelBench as a library for your projects, for example: `from kernelbench import timing`, `from kernelbench import eval as kb_eval`, or `from kernelbench.utils import set_gpu_arch`. -## 🛣️ Upcoming Roadmap -Check out our [roadmap](https://github.com/ScalingIntelligence/KernelBench/issues/74) for what we plan to add as features. We welcome community contirbutions in these directions. +- **Adapter with Harbor** — We are integrating with [Harbor](https://harborframework.com/docs) to enable higher-throughput eval and richer evaluation of agentic performance beyond model pass@1/k. *([Ongoing](https://github.com/harbor-framework/harbor/pull/999))* + +- **Multi-Turn / Test-Time Scaling** — [Caesar](https://github.com/ScalingIntelligence/caesar) is our throughput-oriented multi-turn inference engine (ICML '25), used for the iterative refinement experiments in the paper. It runs generation trajectories in batch, feeding back correctness, runtime, and profiling signals across turns for sequential test-time scaling. + +- **Reinforcement Learning (RLVR)** — [kernelbench-tinker](https://github.com/ScalingIntelligence/kernelbench-tinker) is an end-to-end integration with Thinking Machines Lab's [Tinker RL library](https://github.com/thinking-machines-lab/tinker). The pipeline has the policy model generate kernels, evaluates them on cloud GPUs via Modal, and converts results into RL rewards — a minimal playground for experimenting with RLVR on GPU kernel optimization. + +- **Evolutionary Search** — Evolutionary search like AlphaEvolve has shown promise for discovering innovative solutions for optimization problems. We are working on an integration for [OpenEvolve](https://github.com/algorithmicsuperintelligence/openevolve). Releasing soon. + +- **Roofline / Max Speedup Analysis** — *(Experimental, WIP)* [simple-torchroofline](https://github.com/simonguozirui/simple-torchroofline) provides analytical roofline analysis for PyTorch programs, estimating the speed-of-light (SoL) compute and memory bounds for a target GPU — no hardware required. Combined with hardware counter-based profiling for empirical roofline analysis, this helps sanity-check whether a reported speedup is physically realistic. + ## 🔍 Known Usage Since release, we have gotten a lot of interest from researchers, research labs, and companies that use KernelBench to explore this direction. We have documented [known usage](https://docs.google.com/document/d/e/2PACX-1vTjS-UMH1HB5n_PENq2k-3YRfXIXkqKIKeNC2zcWMyLPdl4Jrwvdk4dNDVSsM8ybKrCxZB7GJq1slZF/pub) of KernelBench and related efforts towards automated kernel generations. If you are using KernelBench, we love to hear more about it! -Disclaimer: KernelBench is designed as an open-source evaluation framework and toolkit. The KernelBench team does not review, validate, or endorse individual kernels or reported results. Users are responsible for independently verifying any results obtained using the framework. Please check out `EVAL.md` for more guidance on benchmarking and evaluating kernels. +Disclaimer: KernelBench is designed as an **open-source** evaluation framework and toolkit. The KernelBench team does not review, validate, or endorse individual kernels or reported results. Users are responsible for independently verifying any results obtained using the framework. Please check out `EVAL.md` for more guidance on benchmarking and evaluating kernels. + ## 🪪 License MIT. Check `LICENSE.md` for more details. @@ -180,3 +192,5 @@ MIT. Check `LICENSE.md` for more details. url={https://arxiv.org/abs/2502.10517}, } ``` + +We are grateful for the support from [GPU Mode](https://gpu-mode.github.io/popcorn/), [PyTorch](https://pytorch.org/), [Modal Labs](https://modal.com/blog/accelerating-ai-research-case-study) and the broader open-source community that made this project possible. diff --git a/results/timing/README.md b/results/timing/README.md index 65fa8eec..11434770 100644 --- a/results/timing/README.md +++ b/results/timing/README.md @@ -30,10 +30,10 @@ For timing, we measure wall clock time. We warm up 3 times and collect runtime s ### Run on your own cluster Since your cluster might be different from ours (different GPU, different power setting, etc.), you can create the baseline results on your own cluster. -Take a look at `python3 scripts/generate_baseline_time.py` to see how to set and run timing results. +Take a look at `uv run python scripts/generate_baseline_time.py` to see how to set and run timing results. ### Run on modal -To gather baseline on modal, take a look at `python3 scripts/generate_baseline_time_modal.py` to see how we are doing it. +To gather baseline on modal, take a look at `uv run python scripts/generate_baseline_time_modal.py` to see how we are doing it. ### Hardware diff --git a/scripts/benchmark_eval_analysis.py b/scripts/benchmark_eval_analysis.py index 4df4e30b..ee1b9753 100644 --- a/scripts/benchmark_eval_analysis.py +++ b/scripts/benchmark_eval_analysis.py @@ -17,13 +17,13 @@ Usage: ``` -python3 scripts/benchmark_eval_analysis.py run_name= level= hardware= baseline= +uv run python scripts/benchmark_eval_analysis.py run_name= level= hardware= baseline= ``` hardware + baseline should correspond to the results/timing/hardware/baseline.json file Optional path overrides (for external tools like leaderboards): ``` -python3 scripts/benchmark_eval_analysis.py run_name= level= hardware= baseline= \ +uv run python scripts/benchmark_eval_analysis.py run_name= level= hardware= baseline= \ baseline_file=/path/to/baseline.json \ eval_results_dir=/path/to/runs \ output_file=/path/to/output.json diff --git a/scripts/generate_and_eval_single_sample.py b/scripts/generate_and_eval_single_sample.py index fbde28b9..78ed1ef7 100644 --- a/scripts/generate_and_eval_single_sample.py +++ b/scripts/generate_and_eval_single_sample.py @@ -19,7 +19,7 @@ Easiest way to get started, to test a single problem for experimentation or debugging Example usage: -python3 scripts/generate_and_eval_single_sample.py dataset_src=huggingface level=1 problem_id=1 eval_mode=local server_type=google model_name=gemini/gemini-2.5-flash max_tokens=8192 temperature=0.0 +uv run python scripts/generate_and_eval_single_sample.py dataset_src=huggingface level=1 problem_id=1 eval_mode=local server_type=google model_name=gemini/gemini-2.5-flash max_tokens=8192 temperature=0.0 """ REPO_TOP_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) diff --git a/scripts/run_and_check.py b/scripts/run_and_check.py index 4d8b95d1..c6f852a6 100644 --- a/scripts/run_and_check.py +++ b/scripts/run_and_check.py @@ -64,18 +64,18 @@ ==================================================== Usage: 1. PyTorch reference is a local file (local eval) -python3 scripts/run_and_check.py ref_origin=local ref_arch_src_path=src/kernelbench/prompts/model_ex_add.py kernel_src_path=src/kernelbench/prompts/model_new_ex_add.py eval_mode=local -python3 scripts/run_and_check.py ref_origin=local ref_arch_src_path=src/kernelbench/prompts/few_shot/model_ex_tiled_matmul.py kernel_src_path=src/kernelbench/prompts/few_shot/model_new_ex_tiled_matmul.py eval_mode=local +uv run python scripts/run_and_check.py ref_origin=local ref_arch_src_path=src/kernelbench/prompts/model_ex_add.py kernel_src_path=src/kernelbench/prompts/model_new_ex_add.py eval_mode=local +uv run python scripts/run_and_check.py ref_origin=local ref_arch_src_path=src/kernelbench/prompts/few_shot/model_ex_tiled_matmul.py kernel_src_path=src/kernelbench/prompts/few_shot/model_new_ex_tiled_matmul.py eval_mode=local 2. PyTorch reference is a kernelbench problem (local eval) -python3 scripts/run_and_check.py ref_origin=kernelbench level= problem_id= kernel_src_path= eval_mode=local +uv run python scripts/run_and_check.py ref_origin=kernelbench level= problem_id= kernel_src_path= eval_mode=local 3. PyTorch reference is a local file (modal eval on cloud GPU) -python3 scripts/run_and_check.py ref_origin=local ref_arch_src_path=src/kernelbench/prompts/model_ex_add.py kernel_src_path=src/kernelbench/prompts/model_new_ex_add.py eval_mode=modal gpu=H100 +uv run python scripts/run_and_check.py ref_origin=local ref_arch_src_path=src/kernelbench/prompts/model_ex_add.py kernel_src_path=src/kernelbench/prompts/model_new_ex_add.py eval_mode=modal gpu=H100 4. PyTorch reference is a kernelbench problem (modal eval on cloud GPU) -python3 scripts/run_and_check.py ref_origin=kernelbench level= problem_id= kernel_src_path= eval_mode=modal gpu=L40S +uv run python scripts/run_and_check.py ref_origin=kernelbench level= problem_id= kernel_src_path= eval_mode=modal gpu=L40S ==================================================== """ diff --git a/src/kernelbench/utils.py b/src/kernelbench/utils.py index e975cc63..d2d1b175 100644 --- a/src/kernelbench/utils.py +++ b/src/kernelbench/utils.py @@ -15,6 +15,7 @@ import os import json from tqdm import tqdm +import torch from importlib.resources import files, as_file # API clients From 8a41bc95066227ab36574d5116863118697a1733 Mon Sep 17 00:00:00 2001 From: Julian Reed Date: Mon, 23 Mar 2026 22:23:53 +0000 Subject: [PATCH 23/24] Make runnable after changes to main --- notebooks/benchmarking.ipynb | 167 ++++++++++++++++++----------------- 1 file changed, 84 insertions(+), 83 deletions(-) diff --git a/notebooks/benchmarking.ipynb b/notebooks/benchmarking.ipynb index ac677052..3469c004 100644 --- a/notebooks/benchmarking.ipynb +++ b/notebooks/benchmarking.ipynb @@ -44,7 +44,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 10, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -59,14 +59,6 @@ "outputId": "8751fd78-569b-4080-f21a-60bbb5ee8caf" }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/simon/palic/KernelBench/.venv/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from .autonotebook import tqdm as notebook_tqdm\n" - ] - }, { "name": "stdout", "output_type": "stream", @@ -79,12 +71,18 @@ "# @title Environment Setup\n", "# Ensure we have the necessary libraries and a GPU available\n", "# !pip install -q triton matplotlib numpy torch\n", - "# !pip install -e .. # Install KernelBench locally for timing utilities\n", "\n", "import sys\n", + "import importlib.util\n", "import os\n", "sys.path.insert(0, '..') # Add parent directory to path for imports\n", "\n", + "path_to_timing = os.path.abspath(\"../src/kernelbench/timing.py\")\n", + "\n", + "spec = importlib.util.spec_from_file_location(\"timing\", path_to_timing)\n", + "timing = importlib.util.module_from_spec(spec)\n", + "spec.loader.exec_module(timing)\n", + "\n", "# For multi-GPU systems, set CUDA_VISIBLE_DEVICES=X before running to select a specific GPU\n", "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"5\"\n", "\n", @@ -94,9 +92,8 @@ "import matplotlib.pyplot as plt\n", "import triton\n", "\n", - "# Import KernelBench's timing module\n", - "from src import timing\n", - "from src.timing import clear_l2_cache, get_timing_stats, get_timing_function\n", + "from src.kernelbench import timing\n", + "from src.kernelbench.timing import clear_l2_cache, get_timing_stats, get_timing_function\n", "\n", "if not torch.cuda.is_available():\n", " raise RuntimeError(\"This notebook requires a GPU. Please enable GPU in your runtime settings.\")\n", @@ -121,7 +118,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 11, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -177,7 +174,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 12, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -196,7 +193,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Naive time: 0.6356 ms\n" + "Naive time: 0.3312 ms\n" ] } ], @@ -243,7 +240,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 13, "metadata": { "execution": { "iopub.execute_input": "2025-12-17T21:24:41.260592Z", @@ -257,7 +254,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Sync time: 21.5368 ms\n" + "Sync time: 21.5464 ms\n" ] } ], @@ -288,7 +285,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 14, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -307,9 +304,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "Run 0: 21.7344 ms\n", - "Run 1: 21.4754 ms\n", - "Run 2: 21.4987 ms\n" + "Run 0: 21.8027 ms\n", + "Run 1: 21.4768 ms\n", + "Run 2: 21.5505 ms\n" ] } ], @@ -347,7 +344,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 15, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -366,9 +363,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "Run 0: 21.6478 ms\n", - "Run 1: 21.4837 ms\n", - "Run 2: 21.4852 ms\n" + "Run 0: 21.4893 ms\n", + "Run 1: 21.4485 ms\n", + "Run 2: 21.4284 ms\n" ] } ], @@ -408,7 +405,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 16, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -426,7 +423,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -438,11 +435,11 @@ "name": "stdout", "output_type": "stream", "text": [ - "Mean: 21.5096 ms\n", - "Median: 21.4942 ms\n", - "Std: 0.0625 ms\n", - "Min: 21.4420 ms\n", - "Max: 21.7808 ms\n" + "Mean: 21.4580 ms\n", + "Median: 21.4497 ms\n", + "Std: 0.0294 ms\n", + "Min: 21.4270 ms\n", + "Max: 21.6775 ms\n" ] } ], @@ -487,7 +484,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": { "execution": { "iopub.execute_input": "2025-12-17T21:24:44.487140Z", @@ -509,7 +506,7 @@ " del dummy\n", "\n", "# KernelBench also provides clear_l2_cache_triton() for AMD GPU support\n", - "from src.timing import clear_l2_cache_triton" + "# from src.kernelbench.timing import clear_l2_cache_triton" ] }, { @@ -525,7 +522,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 41, "metadata": { "execution": { "iopub.execute_input": "2025-12-17T21:24:44.492322Z", @@ -543,9 +540,9 @@ "\n", "With cache flushing (cold cache):\n", "\n", - "Warm cache median: 0.0280 ms\n", - "Cold cache median: 0.0318 ms\n", - "Difference: 0.0038 ms (13.7% slower with cold cache)\n", + "Warm cache median: 0.0284 ms\n", + "Cold cache median: 0.0322 ms\n", + "Difference: 0.0039 ms (13.7% slower with cold cache)\n", "\n", "Without cache flushing, you measure artificially fast times!\n" ] @@ -588,7 +585,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 42, "metadata": { "execution": { "iopub.execute_input": "2025-12-17T21:24:44.509465Z", @@ -600,7 +597,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -660,7 +657,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 20, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -680,8 +677,14 @@ "output_type": "stream", "text": [ "[Profiling] Using timing method: cuda_event\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", - "KernelBench cuda_event time: 21.5000 ms\n" + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 100\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "KernelBench cuda_event time: 21.4000 ms\n" ] } ], @@ -760,7 +763,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 21, "metadata": { "execution": { "iopub.execute_input": "2025-12-17T21:24:47.008751Z", @@ -779,34 +782,26 @@ "\n", "Testing cuda_event...\n", "[Profiling] Using timing method: cuda_event\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 50\n", - " cuda_event: 21.5000 ms (std=0.0572)\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 100\n", + " cuda_event: 21.4000 ms (std=0.0200)\n", "\n", "Testing host_time...\n", "[Profiling] Using timing method: host_time\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 50\n", - " host_time: 21.5000 ms (std=0.0427)\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 100\n", + " host_time: 21.5000 ms (std=0.0181)\n", "\n", "Testing do_bench...\n", "[Profiling] Using timing method: do_bench\n", - " do_bench: 21.4000 ms (std=0.0030)\n", + " do_bench: 21.4000 ms (std=0.0156)\n", "\n", "Testing do_bench_impl...\n", "[Profiling] Using timing method: do_bench_impl\n", - " do_bench_impl: 21.4000 ms (std=0.0315)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_710987/1660294801.py:64: UserWarning: Attempting to set identical low and high ylims makes transformation singular; automatically expanding.\n", - " axes[1].set_ylim(min_val - margin, max_val + margin)\n" + " do_bench_impl: 21.4000 ms (std=0.0194)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -911,7 +906,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 22, "metadata": { "execution": { "iopub.execute_input": "2025-12-17T21:24:50.241069Z", @@ -930,15 +925,15 @@ "[Profiling] Using timing method: cuda_event\n", "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 15\n", "\n", - "First trial: 0.3660 ms\n", - "Mean of all trials: 0.3455 ms\n", - "Mean without first: 0.3440 ms\n", - "First trial overhead: 6.4%\n" + "First trial: 0.3688 ms\n", + "Mean of all trials: 0.3454 ms\n", + "Mean without first: 0.3438 ms\n", + "First trial overhead: 7.3%\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA18AAAHWCAYAAACIZjNQAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAhrpJREFUeJzt3Xl8DOcfB/DP7uaUU+5DJBH3GRU0bnVEUerWOkO16pai/LTuCi2q7rbq1jpKW1cpcRSNo0JRBBFSSuJMJJFrZ35/bHdkZRObSHYnyef9eu2LfebZmWf3uzM73zzPPKMQRVEEERERERERFSmlqRtARERERERUGjD5IiIiIiIiMgImX0REREREREbA5IuIiIiIiMgImHwREREREREZAZMvIiIiIiIiI2DyRUREREREZARMvoiIiIiIiIyAyRcREREREZERMPkiomLp5s2bUCgUWLNmjambkm/Tpk2DQqEo0GtbtGiBFi1aFG6DjOzw4cNQKBT48ccfTd0UyZo1a6BQKHDz5s1CW2d8fDy6d+8OZ2dnKBQKLFy4EABw7do1tG3bFg4ODlAoFPj5558LbZuvYsuWLXByckJycnKBXv/FF1+gQoUKUKlUCAwMLNzGUYH07t0bPXv2NHUziCgbJl9EJEvak2F9j4kTJxbJNmfPnm3QiXCLFi1ybVv2x7Rp04qknYbKzMzEokWLUL9+fdjZ2cHW1hb169fHokWLkJmZadK2FVfaxDm3x71796S6Y8eOxb59+zBp0iSsX78e7dq1AwAMGDAAFy5cwGeffYb169cjKCioUNuYmpqKadOm4fDhwwa/Rq1WY+rUqRg5ciRsbW3zvc3ffvsNEyZMQOPGjbF69WrMnj0b//77L6ZNm4Zz587le31UOD7++GNs27YNf/31l6mbQkT/MTN1A4iI8jJjxgz4+/vrlNWsWRO+vr549uwZzM3NC21bs2fPRvfu3fH222/nWW/y5Ml47733pOenT5/GokWL8L///Q/VqlWTymvXrq339Z988kmRJZBaKSkp6NChA44cOYKOHTti4MCBUCqV2Lt3L0aPHo3t27dj9+7dsLGxKdJ2lFTLly/Xm6Q4OjpK/z948CA6d+6McePGSWXPnj1DZGQkJk+ejBEjRhRJ21JTUzF9+nQAMLiXdOfOnYiOjsb7779foG0ePHgQSqUS3333HSwsLAAAf/75J6ZPnw4/Pz/2hJlI3bp1ERQUhPnz52PdunWmbg4RgckXEcncm2++mWvPgJWV1Utfn5KSUugJRps2bXK0Y9GiRWjTpk2eJ7vatpiZmcHMrGgPv2FhYThy5AgWL16sc5L/4YcfYunSpRgxYgTGjRuH5cuXF2k7shNFEWlpaUbbXlHq3r07XFxc8qyTkJCgk4wBwP379wEgR7mprV69Go0bN4a3t3eBXp+QkABra2sp8SpKRbFPvwq5tedFPXv2xNSpU7Fs2bIC9WoSUeHisEMiKpb0XfM1cOBA2NraIiYmBu3bt4ednR369OkDQHOdTbdu3eDh4QErKyuUK1cOvXv3RmJiIgBAoVAgJSUFa9eulYaQDRw4sMDt0w5Pu3TpEt59912ULVsWTZo00VmW3erVq/HGG2/Azc0NlpaWqF69eoETo9u3b+O7777DG2+8obd3Zfjw4WjZsiVWrlyJ27dvA9D0JrZs2TJHXUEQ4O3tje7du+uULVy4EDVq1ICVlRXc3d3xwQcf4PHjxzqv9fPzQ8eOHbFv3z4EBQXB2toaX3/9tc56PvvsM5QrVw5WVlZo1aoVrl+/nqMNJ0+eRLt27eDg4IAyZcqgefPmOH78uE6dW7duYdiwYahSpQqsra3h7OyMHj166L2G6++//8Ybb7wBa2trlCtXDrNmzYIgCHl/qPmgHTIriiKWLl2qMwzV19cXADB+/HgoFAr4+flJr7tz5w4GDRoEd3d3WFpaokaNGli1alWO9aelpWHatGmoXLkyrKys4Onpia5duyImJgY3b96Eq6srAGD69OkGDYFNS0vD3r170bp16xzLDPleKhQKrF69GikpKdL21qxZg/r16wMAQkNDdcq1DIlrXvvRi548eQKVSoVFixZJZQ8ePIBSqYSzszNEUZTKP/zwQ3h4eEjPjx49ih49eqB8+fKwtLSEj48Pxo4di2fPnulsI69jjEKhwIgRI7B161ZUr14d1tbWCA4OxoULFwAAX3/9NSpWrAgrKyu0aNEix3fTz89P7zHnxes8tddMbt68Gf/73//g4eEBGxsbdOrUCf/880+O17dp0wYpKSnYv3+/3s+NiIyLPV9EJGuJiYl48OCBTllePQ5ZWVkICQlBkyZNMG/ePJQpUwYZGRkICQlBeno6Ro4cCQ8PD9y5cwe7du3CkydP4ODggPXr1+O9995DgwYNpKFXAQEBr9z+Hj16oFKlSpg9e7bOyd+Lli9fjho1aqBTp04wMzPDzp07MWzYMAiCgOHDh+drm7/++ivUajX69++fa53+/fvj0KFD2Lt3L9577z306tUL06ZNw71793ROSo8dO4Z///0XvXv3lso++OADrFmzBqGhoRg1ahRiY2OxZMkSnD17FsePH9cZChodHY133nkHH3zwAYYMGYIqVapIy+bMmQOlUolx48YhMTERn3/+Ofr06YOTJ09KdQ4ePIg333wT9erVw9SpU6FUKqWE4OjRo2jQoAEAzdDPP/74A71790a5cuVw8+ZNLF++HC1atMClS5dQpkwZAMC9e/fQsmVLZGVlYeLEibCxscE333wDa2vrfH3Gjx49ylFmZmYGR0dHNGvWDOvXr0e/fv3Qpk0bKQ61a9eGo6Mjxo4di3feeQft27eXeiLi4+Px+uuvSyfwrq6u+PXXXzF48GAkJSVhzJgxADTXZnXs2BERERHo3bs3Ro8ejadPn2L//v24ePEiWrdujeXLl+PDDz9Ely5d0LVrV2nbuTlz5gwyMjLw2muv5VhmyPdy/fr1+Oabb3Dq1CmsXLkSAFCpUiXMmDEDU6ZMwfvvv4+mTZsCABo1apSvuGoZsh85OjqiZs2a+P333zFq1CgAmu+vQqHAo0ePcOnSJdSoUQOAJtnStgkAtm7ditTUVHz44YdwdnbGqVOnsHjxYty+fRtbt27V2Y6+Y4zW0aNHsWPHDumzCQ8PR8eOHTFhwgQsW7YMw4YNw+PHj/H5559j0KBBOHjwYK5xeZnPPvsMCoUCH3/8MRISErBw4UK0bt0a586d0/k+axPB48ePo0uXLgXeHhEVEpGISIZWr14tAtD7EEVRjI2NFQGIq1evll4zYMAAEYA4ceJEnXWdPXtWBCBu3bo1z23a2NiIAwYMyHdbt27dKgIQDx06JJVNnTpVBCC+8847Oeprl2WXmpqao15ISIhYoUIFnbLmzZuLzZs3z7M9Y8aMEQGIZ8+ezbVOVFSUCEAMCwsTRVEUo6OjRQDi4sWLdeoNGzZMtLW1ldp39OhREYC4ceNGnXp79+7NUe7r6ysCEPfu3atT99ChQyIAsVq1amJ6erpU/tVXX4kAxAsXLoiiKIqCIIiVKlUSQ0JCREEQpHqpqamiv7+/2KZNG52yF0VGRooAxHXr1uX4bE6ePCmVJSQkiA4ODiIAMTY2NtfPTBSfx07fo0qVKjp1AYjDhw/XKdN+b7/44gud8sGDB4uenp7igwcPdMp79+4tOjg4SO9v1apVIgBxwYIFOdqm/Yzu378vAhCnTp2a53vRWrlypc7nnp2h38sBAwaINjY2OmWnT5/OsY9q22loXPPaj/QZPny46O7uLj0PCwsTmzVrJrq5uYnLly8XRVEUHz58KCoUCvGrr77K832Gh4eLCoVCvHXrls771HeMEUVNvC0tLXW+Q19//bUIQPTw8BCTkpKk8kmTJuX4vvn6+uo9/ry4z2v3H29vb511btmyRQSg8760KleuLL755ps5yonI+DjskIhkbenSpdi/f7/O42U+/PBDnecODg4AgH379iE1NbVI2pmboUOHGlQv+1+qtb19zZs3x40bN6ShkYZ6+vQpAMDOzi7XOtplSUlJAIDKlSsjMDAQmzdvluqo1Wr8+OOPeOutt6T2bd26FQ4ODmjTpg0ePHggPerVqwdbW1scOnRIZzv+/v4ICQnR24bQ0FCda4S0PRE3btwAAJw7dw7Xrl3Du+++i4cPH0rbSklJQatWrfD7779LwwWzf36ZmZl4+PAhKlasCEdHR0RFRUnL9uzZg9dff12nZ8XV1VUaOmaobdu25fherl69Ol/r0BJFEdu2bcNbb70FURR1PteQkBAkJiZK72Hbtm1wcXHByJEjc6ynoLcvePjwIQCgbNmyOZYV5vdSKz9x1TJ0P2ratCni4+MRHR0NQNMT1axZMzRt2hRHjx4FoOkNE0VRp+cr+/tMSUnBgwcP0KhRI4iiiLNnz+bYzovHGK1WrVrpDCVt2LAhAKBbt246+6O2XPtdL4j+/fvrrLN79+7w9PTEnj17ctQtW7ZsjhEERGQaHHZIRLLWoEGDfE3FbWZmhnLlyumU+fv7IywsDAsWLMDGjRvRtGlTdOrUCX379pUSs6Ly4kyNuTl+/DimTp2KyMjIHAliYmJivtqpPSHTJmH66EvQevXqhf/973+4c+cOvL29cfjwYSQkJKBXr15SnWvXriExMRFubm5615uQkKDzPK/3X758eZ3n2pN/7bVj165dA6CZmj03iYmJKFu2LJ49e4bw8HCsXr0ad+7c0Rmalj1JuHXrlnTim1324ZCGaNas2Usn3DDU/fv38eTJE3zzzTf45ptv9NbRfq4xMTGoUqVKkUzYIuoZzleY30ut/MRVy9D9SJtQHT16FOXKlcPZs2cxa9YsuLq6Yt68edIye3t71KlTR3pdXFwcpkyZgh07duS4dvHFJFPfMUbrxe+09vPx8fHRW/7itvKjUqVKOs8VCgUqVqyo9zpHURQLnJwTUeFi8kVEJYqlpSWUypyd+vPnz8fAgQPxyy+/4LfffsOoUaMQHh6OEydO5HoiVRgMuZYoJiYGrVq1QtWqVbFgwQL4+PjAwsICe/bswZdffpnvySC0092fP38+1ym+z58/D0BzPYhWr169MGnSJGzduhVjxozBli1b4ODgIN2fCtBMkuHm5oaNGzfqXa92sgetvN6/SqXSW65NArTv+4svvsj1fWivmRo5ciRWr16NMWPGIDg4WLqBce/evQt1Mo2ioG1f3759c01I8rpm61U5OzsD0CQC2feFwv5eauUnrlqGXpPn5eUFf39//P777/Dz84MoiggODoarqytGjx6NW7du4ejRo2jUqJF0nFCr1WjTpg0ePXqEjz/+GFWrVoWNjQ3u3LmDgQMH5nifuR1jgNy/0y/7rgO591yq1epcX2+ox48f50jWiMg0mHwRUalRq1Yt1KpVC5988gn++OMPNG7cGCtWrMCsWbMAFHzY1qvauXMn0tPTsWPHDp2/nL84hM9Qb775JlQqFdavX5/rpBvr1q2DmZmZTmLl7++PBg0aYPPmzRgxYgS2b9+Ot99+G5aWllKdgIAAHDhwAI0bN873JBX5pZ3wxN7eXu9MfNn9+OOPGDBgAObPny+VpaWl4cmTJzr1fH19pZ6X7LTD1EzB1dUVdnZ2UKvVL32fAQEBOHnyJDIzM3O9x11+v8dVq1YFAMTGxqJWrVpS+at+L3NrR37iWhBNmzbF77//Dn9/fwQGBsLOzg516tSBg4MD9u7di6ioKOk+aABw4cIFXL16FWvXrtXZX4w9O2DZsmVzfF8BTW9thQoVcpS/+D0WRRHXr1/PkahnZWXhn3/+QadOnQq1vURUMLzmi4hKvKSkJGRlZemU1apVC0qlEunp6VKZjY2N3pOfoqb9q/aLQ+UKeg2Rj48PQkNDceDAAb3T1a9YsQIHDx7E4MGDc/T69erVCydOnMCqVavw4MEDnSGHgOaeQWq1GjNnzsyx3qysrEL9/OrVq4eAgADMmzcPycnJOZZr75kFaD7DF4fNLV68GGq1Wqesffv2OHHiBE6dOqWzntx68oxBpVKhW7du2LZtGy5evJhjefb32a1bNzx48ABLlizJUU/7/rWz7xkai3r16sHCwgJ//vlnjnZlXy+Qv++l9t5XL7YjP3EtiKZNm+LmzZvYvHmzNAxRqVSiUaNGWLBgATIzM3Wu99L3PkVRxFdfffVK7civgIAAnDhxAhkZGVLZrl279E4fD2j+gJJ9aPGPP/6Iu3fv4s0339Spd+nSJaSlpUkzTRKRabHni4hKvIMHD2LEiBHo0aMHKleujKysLKxfv1466dWqV68eDhw4gAULFkjDl/RdH1TY2rZtCwsLC7z11lv44IMPkJycjG+//RZubm64e/dugdb55Zdf4sqVKxg2bBj27t0r9XDt27cPv/zyC5o3b67TS6TVs2dPjBs3DuPGjYOTk1OOnonmzZvjgw8+QHh4OM6dO4e2bdvC3Nwc165dw9atW/HVV1/p3BPsVSiVSqxcuRJvvvkmatSogdDQUHh7e+POnTs4dOgQ7O3tsXPnTgBAx44dsX79ejg4OKB69eqIjIzEgQMHpCF1WhMmTMD69evRrl07jB49Wppq3tfXVxqKaYgff/xR7w1r27RpA3d393y/1zlz5uDQoUNo2LAhhgwZgurVq+PRo0eIiorCgQMHpKnt+/fvj3Xr1iEsLAynTp1C06ZNkZKSggMHDmDYsGHo3LkzrK2tUb16dWzevBmVK1eGk5MTatasiZo1a+rdtpWVFdq2bYsDBw5gxowZUvmrfi8DAgLg6OiIFStWwM7ODjY2NmjYsCH8/f0NjmtBaBOr6OhozJ49Wypv1qwZfv31V1haWkr3IAM0PX8BAQEYN24c7ty5A3t7e2zbtu2VrscqiPfeew8//vgj2rVrh549eyImJgYbNmzI9ZYXTk5OaNKkCUJDQxEfH4+FCxeiYsWKGDJkiE69/fv3o0yZMjluDk9EJmL0+RWJiAygnWr+9OnTepfnNtX8i9Ndi6Io3rhxQxw0aJAYEBAgWllZiU5OTmLLli3FAwcO6NS7cuWK2KxZM9Ha2loEYPC083lNNX///v0c9fVNNb9jxw6xdu3aopWVlejn5yfOnTtXmlY8+3TUhkw1r5Weni5++eWXYr169UQbGxuxTJky4muvvSYuXLhQzMjIyPV1jRs3FgGI7733Xq51vvnmG7FevXqitbW1aGdnJ9aqVUucMGGC+O+//0p1fH19xQ4dOuR4rXaq7Ben/tcXU1HU3Cqga9euorOzs2hpaSn6+vqKPXv2FCMiIqQ6jx8/FkNDQ0UXFxfR1tZWDAkJEa9cuaJ3+u7z58+LzZs3F62srERvb29x5syZ4nfffffKU82/+B1APqaaF0VRjI+PF4cPHy76+PiI5ubmooeHh9iqVSvxm2++0amXmpoqTp48WfT395fqde/eXYyJiZHq/PHHH2K9evVECwsLg6ad3759u6hQKMS4uDidckO/l7nte7/88otYvXp10czMLEdsDYlrXvtRXtzc3EQAYnx8vFR27NgxEYDYtGnTHPUvXboktm7dWrS1tRVdXFzEIUOGiH/99ZfBxxhRzF+8c9sH5s+fL3p7e4uWlpZi48aNxT///DPXqeZ/+OEHcdKkSaKbm5tobW0tdujQQWdafK2GDRuKffv2zfWzIiLjUohiHnf9JCIiohJPrVajevXq6Nmzp94hpSQfhw8fRsuWLbF169aX9jKfO3cOr732GqKionKd3ISIjIvXfBEREZVyKpUKM2bMwNKlS/Veh0XF05w5c9C9e3cmXkQywmu+iIiICL169coxwQoVb5s2bTJ1E4joBez5IiIiIiIiMgJe80VERERERGQE7PkiIiIiIiIyAiZfRERERERERsAJNwpIEAT8+++/sLOzg0KhMHVziIiIiIjIRERRxNOnT+Hl5QWlMvf+LSZfBfTvv//Cx8fH1M0gIiIiIiKZ+Oeff1CuXLlclzP5KiA7OzsAmg/Y3t7epG0RBAH379+Hq6trnpk2GQ9jIi+Mh/wwJvLDmMgL4yE/jIn8yCkmSUlJ8PHxkXKE3DD5KiDtUEN7e3tZJF9paWmwt7c3+RePNBgTeWE85IcxkR/GRF4YD/lhTORHjjF52eVI8mglERERERFRCcfki4iIiIiIyAiYfBERERERERkBr/kiIiIiyidRFJGVlQW1Wl0k6xcEAZmZmUhLS5PNtSylHWMiP8aMiUqlgpmZ2SvfYorJFxEREVE+ZGRk4O7du0hNTS2ybYiiCEEQ8PTpU95PVCYYE/kxdkzKlCkDT09PWFhYFHgdTL6IiIiIDCQIAmJjY6FSqeDl5QULC4siOenT9qwVxl/aqXAwJvJjrJiIooiMjAzcv38fsbGxqFSpUoF72ph8FXeiCDx4ANU//wBKJeDqCvCAQEREVCQyMjIgCAJ8fHxQpkyZItsOT/TlhzGRH2PGxNraGubm5rh16xYyMjJgZWVVoPVwwGpx9eQJ8NVXQKVKULq7w7VBAyjd3YFKlTTlT56YuoVEREQlFq/5ISp9CmO/55GjONq3DyhXDhg7FuKNGzqLxBs3gLFjNcv37TNRA4mIiIiI6EVMvoqbffuADh0gPnsGiCIUoqizWCGKgChqlnfowASMiIhIjv67bAA3b2r+feH3nIhKJiZfxcmTJ0C3bhBFEQpByLOqQhAgiiLQrRuHIBIREclFtssG4OoK+Ptr/jXhZQMtWrTAmDFjjL7dl/Hz88PChQsNrr9mzRo4OjoWWXuICgOTr+Jk7VogNfWliZeWQhCA1FRg3boibhgRERG9VLbLBvDCZQMo4ssGBg4cCIVCkeNx/fp1bN++HTNnznyl9SsUCvz888951rl58yYUCgXOnTtn0DpPnz6N999//5XaZYjDhw/jtddeg6WlJSpWrIg1a9bkWT86OhotW7aEu7s7rKysUKFCBXzyySfIzMzUqffkyRMMHz4cnp6esLS0ROXKlbFnzx6dOnfu3EHfvn3h7OwMa2tr1KpVC3/++Wdhv0WSEc52WFyIIrB4MUQA+ZnLRQSgWLQIGDmSsyASERGZyn+XDeC/ywNy0JZpLxvYtQto1apQm9CuXTusXr1ap8zV1RUqlSrP12VkZLzSfY3yS7s9V1fXIt9WbGwsOnTogKFDh2Ljxo2IiIjAe++9B09PT4SEhOh9jbm5Ofr374/XXnsNjo6O+OuvvzBkyBAIgoDZs2dL76FNmzZwc3PDjz/+CG9vb9y6dUunZ+7x48do3LgxWrZsiV9//RWurq64du0aypYtW+Tvm0yHPV/FxcOHQExMjmu8XkYhikBMDPDoURE1jIiIiPL032UDEEXgZaNXBEFTr3v3Qh+CaGlpCQ8PD52HSqXKMezQz88PM2fORP/+/WFvb4/3338fGRkZGDFiBDw9PWFlZQVfX1+Eh4dL9QGgS5cuUCgU0vMX+fv7AwDq1q0LhUKBFi1aAND0yr399tv47LPP4OXlhSpVqkjrzT7scMGCBahVqxZsbGzg4+ODYcOGITk5+ZU+kxUrVsDf3x/z589HtWrVMGLECHTv3h1ffvllrq+pUKECQkNDUadOHfj6+qJTp07o06cPjh49KtVZtWoVHj16hJ9//hmNGzeGn58fmjdvjjp16kh15s6dCx8fH6xevRoNGjSAv78/2rZti4CAAKmOn58fZs2ahf79+8PW1ha+vr7YsWMH7t+/j86dO8PW1ha1a9fW6S27desW3nrrLZQtWxY2NjaoUaNGjh43Mh0mX8XFKx5c8PRp4bSDiIiI8ue/ywZemnhp/XfZgHLDhqJtVx7mzZuHOnXq4OzZs/j000+xaNEi7NixA1u2bEF0dDQ2btwoJVmnT58GAKxevRp3796Vnr/o1KlTAIADBw7g7t272L59u7QsIiIC0dHR2L9/P3bt2qX39UqlEosWLcLff/+NtWvX4uDBg5gwYUKu70E7zPHw4cO51omMjETr1q11ykJCQhAZGZnra150/fp17N27F82bN5fKduzYgeDgYAwfPhzu7u6oWbMmZs+eDbVarVMnKCgIPXr0gJubG+rWrYtvv/02x/q//PJLNG7cGGfPnkWHDh3Qr18/9O/fH3379kVUVBQCAgLQv39/zbX+AIYPH4709HT8/vvvuHDhAubOnQtbW1uD3w8VLQ47LC5edaexsyucdhAREZHh/rtsoCCUS5YAo0cX2mUDu3bt0jkJf/PNN7F161a9dd944w189NFH0vO4uDhUqlQJTZo0gUKhgK+vr7RMOzzQ0dERHh4euW5fW8/Z2TlHPRsbG6xcuTLP4Y0v9s7NmjULQ4cOxbJly/TWNzc3R5UqVfK8Gfa9e/fg7u6uU+bu7o6kpCQ8e/YM1tbWub62UaNGiIqKQnp6Ot5//33MmDFDWnbjxg0cPHgQffr0wZ49e3D9+nUMGzYMmZmZmDp1qlRn+fLlCAsLw//+9z+cPn0ao0aNgoWFBQYMGCCtq3379vjggw8AAFOmTMHy5ctRv3599OjRAwDw8ccfIzg4GPHx8fDw8EBcXBy6deuGWrVqAdD01JF8MPkqLpydgYAAiDdu5GvooahQQFGhAuDkVISNIyIiIr3+u2wgvxSiCNy4AfHRI8DFpVCa0rJlSyxfvlx6bmNjk2vdoKAgnecDBw5EmzZtUKVKFbRr1w4dO3ZE27ZtC6VdAFCrVq2XXld24MABhIeH48qVK0hKSkJWVhbS0tKQmpqqN8Hy9vbGlStXCq2NL9q8eTOePn2Kv/76C+PHj8e8efOknjhBEODm5oZvvvkGKpUK9erVw507d/DFF19IyZcgCAgKCpKuE6tbty4uXryIFStW6CRftWvXlv6vTRS1iVX2soSEBHh4eGDUqFH48MMP8dtvv6F169bo1q2bzjrItDjssLhQKICRI/M12Qbw3+Qco0Zxsg0iIiJTkNFlAzY2NqhYsaL08PT0zLNudq+99hpiY2Mxc+ZMPHv2DD179kT37t0LtW15uXnzJjp27IjatWtj27ZtOHPmDJYuXQpAM7lFQXl4eCA+Pl6nLD4+Hvb29nn2egGAj48PqlevjnfeeQdz5szBtGnTpGGFnp6eqFy5ss5kJtWqVcO9e/ek9np6eqJ69eo666xWrRri4uJ0yszNzaX/K/47n9NXJvw3rPW9997DjRs30K9fP1y4cAFBQUFYXMDeVyp8TL6KkwEDgDJlICoNC5uoVAJlygD9+xdxw4iIiEivEnTZgL29PXr16oVvv/0WmzdvxrZt2/Dovwm9zM3Nda5n0kfbs/WyevqcOXMGgiBg/vz5eP3111G5cmX8+++/+X8TLwgODkZERIRO2f79+xEcHJyv9QiCgMzMTCkBaty4Ma5fvy49B4CrV6/C09NT+hwaN26M6OhonfVcvXpVZ0hnQfn4+GDo0KHYvn07PvroI73XkpFpMPkqThwdgW3boFAoXpqAiUql5i8h27drXkdERETG999lA/kdgSIqFBBldNnAggUL8MMPP+DKlSu4evUqtm7dCg8PD2nqdD8/P0RERODevXt4/Pix3nW4ubnB2toae/fuRXx8PBITEw3efsWKFZGZmYnFixfjxo0bWL9+PVasWJHna+7cuYOqVatKE33oM3ToUNy4cQMTJkzAlStXsGzZMmzZsgVjx46V6ixZsgStsk37v3HjRmzZsgWXL1/GjRs3sGXLFkyaNAm9evWSeqQ+/PBDPHr0CKNHj8bVq1exe/duzJ49G8OHD5fWM3bsWJw4cQKzZ8/G9evX8f333+Obb77RqVMQY8aMwb59+xAbG4uoqCgcOnQI1apVe6V1UuFh8lXchIQAu3dDYW0NKBQQXziYiwoFoFBolu/ZAxTieGwiIiLKp/8uGygIYcQI2Vw2YGdnh88//xxBQUGoX78+bt68iT179kD53x+D58+fj/3798PHxwd169bVuw4zMzMsWrQIX3/9Nby8vNC5c2eDt1+nTh0sWLAAc+fORc2aNbFx40ZpqvvcZGZmIjo6GqmpqbnW8ff3x+7du7F//37UqVMH8+fPx8qVK3Xu8fXgwQPEZLtuz8zMDHPnzkWDBg1Qu3ZtTJ8+HSNGjMDKlSulOj4+Pti3bx9Onz6N2rVrY9SoURg9ejQmTpwo1alfvz5++ukn/PDDD6hZsyZmzpyJhQsXok+fPgZ/Lvqo1WoMHz4c1apVQ7t27VC5cuVcJyUh41OIYj5vHEUAgKSkJDg4OCAxMRH29vbGb8CTJ8C6dcCiRboX8gYEaK7xGjAAcHAwfrsIgGb4QUJCAtzc3KQfJjIdxkN+GBP5YUwMk5aWhtjYWPj7+8PKysqwFz15ApQrp7mBsiHTzSuVEK2tkRUbCzMXF+maHjItURSRlZUFMzMzxkQmjB2TvPZ/Q3MDHl2LK0dHTZJ17RqEhATcP3UKQkICcO2appyJFxERkTz8d9kAFArgZYmtUqmpt20bLxsgKoGYfBV3CgXg7Ay1j49mXDn/EkNERCQ//102gP8uG8jxe60t42UDRCUaky8iIiIiYwgJAW7fBhYuBF688W2FCpryO3eYeBGVYCZPvpYuXQo/Pz9YWVmhYcOGec5Is337dgQFBcHR0RE2NjYIDAzE+vXrc9S7fPkyOnXqBAcHB9jY2KB+/fo690xo0aIFFAqFzmPo0KFF8v6IiIiIJNkuG8CDB0BsrOZfXjZAVCqYmXLjmzdvRlhYGFasWIGGDRti4cKFCAkJQXR0NNzc3HLUd3JywuTJk1G1alVYWFhg165dCA0NhZubmzQrTUxMDJo0aYLBgwdj+vTpsLe3x99//53jorghQ4ZgxowZ0nN9d0YnIiIiKhL/XTYAZ2dTt4SIjMikydeCBQswZMgQhIaGAgBWrFiB3bt3Y9WqVTpTcWq1aNFC5/no0aOxdu1aHDt2TEq+Jk+ejPbt2+Pzzz+X6gUEBORYV5kyZeDh4VGI74aIiIiIiCh3Jku+MjIycObMGUyaNEkqUyqVaN26NSIjI1/6elEUcfDgQURHR2Pu3LkANNPk7t69GxMmTEBISAjOnj0Lf39/TJo0CW+//bbO6zdu3IgNGzbAw8MDb731Fj799NM8e7/S09ORnp4uPU9KSpK2KRgybWwREgQBoiiavB30HGMiL4yH/DAm8sOYGEb7OWkfRUm7ft4VSD4YE/kxZky0+72+839Dj50mS74ePHgAtVoNd3d3nXJ3d3dcuXIl19clJibC29sb6enpUKlUWLZsGdq0aQMASEhIQHJyMubMmYNZs2Zh7ty52Lt3L7p27YpDhw6hefPmAIB3330Xvr6+8PLywvnz5/Hxxx8jOjoa27dvz3W74eHhmD59eo7y+/fvIy0trSAfQaERBAGJiYkQRZH3ZpEJxkReGA/5YUzkhzExTGZmJgRBQFZWFrKysopsO6IoQq1WAwDvKSUTjIn8GDsmWVlZEAQBDx8+hLm5uc6yp0+fGrQOkw47LAg7OzucO3cOycnJiIiIQFhYGCpUqIAWLVpIGWfnzp0xduxYAEBgYCD++OMPrFixQkq+3n//fWl9tWrVgqenJ1q1aoWYmBi9QxQBYNKkSQgLC5OeJyUlwcfHB66urqa5yXI2giBAoVDA1dWVP5gywZjIC+MhP4yJ/DAmhklLS8PTp09hZmYGM7OiP4168QSPTI8xkR9jxcTMzAxKpRLOzs455pMw9KbrJku+XFxcoFKpEB8fr1MeHx+f57VYSqUSFStWBKBJrC5fvozw8HC0aNECLi4uMDMzQ/Xq1XVeU61aNRw7dizXdTZs2BAAcP369VyTL0tLS1haWuptjxx+pBQKhWzaQhqMibwwHvLDmMgPY/JySqVSZ7bkoiKKorT+0tjL0qxZMwwdOhTvvvtuvl87cOBAPHnyBD///HOudQ4fPoyWLVvi8ePHcDTwZtZFHZOff/4Z48aNQ2xsLEaOHInAwECMGTMGT548KdTtPHjwANWrV0dUVBTKlStXqOs2NmPvJ9r9Xt9x0tDjpsmOrhYWFqhXrx4iIiKkMkEQEBERgeDgYIPXIwiCdC2WhYUF6tevj+joaJ06V69eha+vb67rOHfuHADA09MzH++AiIiIqHgYOHBgrrfWGT58OBQKBQYOHGj8humxY8cOxMfHo3fv3gV6/VdffYU1a9ZIz1u0aIExY8YUTuPy6fDhw1AoFAYlUB988AG6d++Of/75BzNnzkSvXr1w9erVV9r+wIEDc8x74OLigv79+2Pq1KkFWmd+bhMFGH6rKK2hQ4dCoVBg4cKFepenp6cjMDAQCoVCOocvTkz6p62wsDB8++23WLt2LS5fvowPP/wQKSkp0uyH/fv315mQIzw8HPv378eNGzdw+fJlzJ8/H+vXr0ffvn2lOuPHj8fmzZvx7bff4vr161iyZAl27tyJYcOGAdBMRT9z5kycOXMGN2/exI4dO9C/f380a9YMtWvXNu4HQERERGQkPj4+2LRpE549eyaVpaWl4fvvv0f58uVN2DJdixYtQmhoaIF7YB0cHAzuzZKL5ORkJCQkICQkBF5eXrCzs4O1tbXeWy9pZWRkFHh7oaGh2LhxIx49epSv12lvEzV16lRERUWhTp06CAkJQUJCQq6v0d4qKjIyEufPn0doaChCQ0Oxb9++HHV/+uknnDhxAl5eXrmub8KECXkulz3RxBYvXiyWL19etLCwEBs0aCCeOHFCWta8eXNxwIAB0vPJkyeLFStWFK2srMSyZcuKwcHB4qZNm3Ks87vvvpPq1alTR/z555+lZXFxcWKzZs1EJycn0dLSUqxYsaI4fvx4MTExMV/tTkxMFAHk+3VFQa1Wi3fv3hXVarWpm0L/YUzkhfGQH8ZEfhgTwzx79ky8dOmS+OzZM93yzGe5PtKz0vNdVxAEMSMjQ0zNSNVbL78GDBggdu7cWaxZs6a4YcMGqXzjxo1i7dq1xc6dO+ucc6nVanH27Nmin5+faGVlJdauXVvcunWrtDwrK0scNGiQtLxy5criwoUL9W7ziy++ED08PEQnJydx2LBhYkZGRq7tTEhIEBUKhXjx4kWp7KOPPhI7dOggPf/yyy9FAOKvv/4qlQUEBIjffvutzna1/weg84iNjRUPHTokAhAPHDgg1qtXT7S2thaDg4PFK1eu6LRn2bJlYoUKFURzc3OxcuXK4qpVq0RBEERRFMXY2FgRgHj27Fmp/uPHj0UA4qFDh6Tl2R/ZP2MtbVuyPw4dOiSuXr1adHBwkOpNnTpVrFOnjvjtt9+Kfn5+okKhEEVRFLdu3SrWrFlTtLKyEp2cnMRWrVqJycnJ4tSpU/WuV8vf319cuXJlrrHQp0GDBuLw4cOl52q1WvTy8hLDw8PztZ66deuKn3zyiU7Z7du3RW9vb/HixYuir6+v+OWXX+Z43Z49e8SqVauKf//9twhAjIqKEjMyMkRBEKTPa+fOnWLlypVFa2trsVu3bmJKSoq4Zs0a0dfXV3R0dBRHjhwpZmVlSetcunSpWLFiRdHS0lJ0c3MTu3Xrlmu7c9v/RdHw3MDkE26MGDECI0aM0Lvs8OHDOs9nzZqFWbNmvXSdgwYNwqBBg/Qu8/HxwZEjR/LdTiIiIqLc9NjaI9dlQZ5BmNri+RCvvtv7Il2drrduTdeaCG8dLj1/b8d7SMpIylFv5zs7C9TOQYMGYfXq1ejTpw8AYNWqVQgNDc1xzhUeHo4NGzZgxYoVqFSpEn7//Xf07dsXrq6uaN68OQRBQLly5bB161Y4Ozvjjz/+wPvvvw9PT0/07NlTWs+hQ4fg6emJQ4cO4fr16+jVqxcCAwMxZMgQve07duwYypQpg2rVqkllzZs3x8qVK6FWq6FSqXDkyBG4uLjg8OHDaNeuHe7cuYOYmJgc94MFNEMQr169ipo1a2LGjBkAAFdXV9y8eROA5v6w8+fPh6urK4YOHYpBgwbh+PHjADS9MKNHj8bChQvRunVr7Ny5E0OGDIGvry/eeOONl37WPj4+2LZtG7p164bo6GjY29vD2to6R71GjRohOjoaVapUwbZt29CoUSM4OTlJbczu+vXr2LZtG7Zv3w6VSoW7d+/inXfeweeff44uXbrg6dOnOHr0KERRxLhx43D58mUkJSVh9erVADS9UFoNGjTA0aNHMXjwYADAmjVrEBoamuuU7a96myhA/62iAM1lRP369cP48eNRo0YNva+Nj4/HkCFD8PPPP+d6e6jU1FQsWrQImzZtwtOnT9G1a1d06dIFjo6O2LNnD27cuIFu3bqhcePG6NWrF/7880+MGjUK69evR6NGjfDo0SMcPXrUoPdSUCZPvoiIiIjIOPr27YtJkybh1q1bAIDjx49j06ZNOslXeno6Zs+ejQMHDkjX4VeoUAHHjh3D119/jebNm8Pc3FznFjz+/v6IjIzEli1bdJKvsmXLYsmSJVCpVKhatSo6dOiAiIiIXJOvW7duwd3dXWfIYdOmTfH06VOcPXsW9erVw++//47x48dLE2ocPnwY3t7e0oRs2Tk4OMDCwgJlypTRO6HbZ599Js2GPXHiRHTo0AFpaWmwsrLCvHnzMHDgQOnSlbCwMERGRmL+/PkGJV8qlUpKdtzc3HIdCmlhYSENL3Rycspz4rmMjAysW7cOrq6uAICoqChkZWWha9eu0vwGtWrVkupbW1sjPT1d7zq9vLxw9uxZ6bmDgwOqVKmS67YLepsoIO9bRQHA3LlzYWZmhlGjRul9vSiKGDhwIIYOHYqgoCC9iSmguRXE8uXLpQn0unfvjvXr1yM+Ph62traoXr06WrZsiUOHDqFXr16Ii4uDjY0NOnbsCDs7O/j6+qJu3bp5vpdXxeSLiIiI6BVt7bE112VKhe61Sxu6bjC47spOKwt1FjdXV1d06NABa9asgSiK6NChA1xcXHTqXL9+HampqTonx4DmxD/7ienSpUuxatUqxMXF4dmzZ8jIyEBgYKDOa2rUqAGVSiU99/T0xIULF3Jt37Nnz3JM2e3o6Ig6derg8OHDsLCwgIWFBd5//31MnToVycnJOHLkiJRA5Vf26/21E68lJCSgfPnyuHz5ss7tiQBNL9WSJUsKtK3C4OvrKyVeAFCnTh20atUKtWrVQkhICNq2bYvu3bujbNmyL12XtbU1UlNTpeddunRBly5diqTded0q6syZM/jqq68QFRWV63d98eLFePr0qU6vmz5lypTRmbnc3d0dfn5+sLW11SnTXqPWpk0b+Pr6okKFCmjXrh3atWuHLl265NqzVhiYfBERERG9Iiszw+7xU5C6hT2F9qBBg6RLPpYuXZpjeXJyMgBg9+7d8Pb21lmmve3Opk2bMG7cOMyfPx/BwcGws7PDF198gZMnT+rUf/H+SwqFQrovqz4uLi54/PhxjvIWLVrg8OHDsLS0RPPmzeHk5CTdSujIkSP46KOPDHjnOWVvn/Zzzqt92Wl757IP08vMzCxQOwxlY2Oj81ylUmH//v34448/8Ntvv2Hx4sWYPHkyTp48CX9//zzX9ejRI51E7mUKepsoIO9bRR09elRKeLXUajU++ugjLFy4EDdv3sTBgwcRGRmZ47ZP9evXxzvvvIN169YB0P99y+s7aGdnh6ioKBw+fBi//fYbpkyZgmnTpuH06dNFNmkLb+RBREREVIq0a9cOGRkZyMzMREhISI7l1atXh6WlJeLi4lCxYkWdh4+PDwDNcMVGjRph2LBhqFu3LipWrIiYmJhXblvdunVx7969HAlY8+bNcezYMUREREjXdrVo0QI//PADrl69qvd6Ly0LCwuo1ep8t6VatWrS9V9af/zxh3Q/WW3icvfuXWn5i1OfW1hYAECBtm8ohUKBxo0bY/r06Th79iwsLCzw008/SdvPbdsXL17M1xC7wrpNlPZ12ltF9evXD+fPn8e5c+ekh5eXF8aPHy/NiLho0SL89ddf0vI9e/YA0PwRQHstX0GZmZmhdevW+Pzzz3H+/Hkp2Ssq7PkiIiIiKkVUKhUuX74s/f9FdnZ2GDduHMaOHQtBENCkSRMkJibi+PHjsLe3x4ABA1CpUiWsW7cO+/btg7+/P9avX4/Tp0+/tLflZerWrQsXFxccP34cHTt2lMqbNWuGp0+fYteuXZgzZw4ATfLVvXt3eHp6onLlyrmu08/PDydPnsTNmzdha2urM+lEXsaPH4+ePXuibt26aN26NXbs2IGff/4Z+/fvB6AZtvf6669jzpw58Pf3R0JCAj755BOddfj6+kKhUGDXrl1o3749rK2tdYbAvaqTJ08iIiICbdu2hZubG06ePIn79+9LE5b4+flh3759iI6OhrOzMxwcHGBubo7U1FScOXMGs2fPltb1008/YdKkSXlevxUWFoYBAwYgKCgIDRo0wMKFC3VuEwVobhXl7e2N8HDNxDHh4eEICgpCQEAA0tPTsWfPHqxfvx7Lly8HADg7O8PZ2VlnO+bm5vDw8JCuQXvxVgjazzAgIOCVbhS9a9cu3LhxA82aNUPZsmWxZ88eCIKQ57Vvr4o9X0RERESljL29Pezt7XNdPnPmTHz66acIDw9HtWrV0K5dO+zevVtKrj744AN07doVvXr1QsOGDfHw4UNpYopXoVKppHtQZVe2bFnUqlULrq6uqFq1KgBNQiYIwkuv9xo3bhxUKhWqV68OV1dXxMXFGdSWt99+G1999RXmzZuHGjVq4JtvvsG3336r08u2atUqZGVloV69ehgzZkyOWbm9vb0xffp0TJw4Ee7u7rnO8F1Q9vb2+P3339G+fXtUrlwZn3zyCebPn48333wTADBkyBBUqVIFQUFBcHV1lXryfvnlF5QvXx5NmzaV1pWYmIjo6Og8t9erVy/MmzcPU6ZMQWBgIM6dO4e9e/fqTMIRFxen0xuYkpKCYcOGoUaNGmjcuDG2bduGDRs24L333ivMj6JAHB0dsX37drzxxhuoVq0aVqxYgR9++CHXGRcLg0LMbT5JylNSUhIcHByQmJiY58HLGARBQEJCAtzc3Ap8Q0IqXIyJvDAe8sOYyA9jYpi0tDTExsbC398/x8QQhUkURWRlZcHMzKzQr/mSu3v37qFGjRqIioqSZvCTg5IUk9dffx2jRo3Cu+++a+qmvBJjxySv/d/Q3IBHVyIiIiKSDQ8PD3z33XcG91BR/jx48ABdu3bFO++8Y+qmlEq85ouIiIiIZOXtt982dRNKLBcXF0yYMMHUzSi12PNFRERERERkBEy+iIiIiIiIjIDJFxERERERkREw+SIiIiIiIjICJl9ERERERERGwOSLiIiIiIjICJh8ERERERERGQGTLyIiIiKSlWbNmuH77783uP6aNWvg6OgoPZ82bRoCAwOl5xMnTsTIkSMLsYVEBcPki4iIiKiEGzhwIBQKBYYOHZpj2fDhw6FQKDBw4EDjN0yPHTt2ID4+Hr179y60dY4bNw5r167FjRs38v3auLg4dOjQATY2NvD29sb48eORlZWV52s6deqE8uXLw8rKCp6enujXrx/+/fdfvXWvX78OOzs7neQR0CSUCoVC52FlZZXv9pO8MPkiIiIiKgV8fHywadMmPHv2TCpLS0vD999/j/Lly5uwZboWLVqE0NBQKJWFd5rq4uKCkJAQLF++PF+vU6vV6NChAzIyMnD8+HF89913WLt2LaZMmZLn61q2bIktW7YgOjoa27ZtQ0xMDLp3756jXmZmJt555x00bdpU73rs7e1x9+5d6XHr1q18tZ/kh8kXERER0atSp2keovi8TMjSlAmZhtdVZxhWtwBee+01+Pj4YPv27VLZ9u3bUb58edStW1enriAICA8Ph7+/P6ytrVGnTh38+OOPz5ulVmPw4MHS8ipVquCrr77SWcfAgQPx9ttvY968efD09ISzszOGDx+OzMwXPo9s7t+/j4MHD+Ktt97SKV+wYAFq1aoFGxsb+Pj4YNiwYUhOTs7X+3/rrbewadOmfL3mt99+w6VLl7BhwwYEBgaiXbt2mDFjBpYuXYqMjIxcXzd27Fi8/vrr8PX1RaNGjTBx4kScOHEix3v/5JNPULVqVfTs2VPvehQKBTw8PKSHu7u7znI/Pz/MmjUL/fv3h62tLXx9fbFjxw7cv38fnTt3hq2tLWrXro0///xTes2tW7fw1ltvoWzZsrCxsUGNGjWwZ8+efH0uVHBMvoiIiIhe1dEemkdm0vOyf7Zryq6t0K37R19Nefr952X/7taUXV2kW/fke5ry1H+el92LKHAzBw0ahNWrV0vPV61ahdDQ0Bz1wsPDsW7dOqxYsQJ///03xo4di759++LIkSMANMlZuXLlsHXrVly6dAlTpkzB//73P2zZskVnPYcOHUJMTAwOHTqEtWvXYs2aNVizZk2u7Tt27BjKlCmDatWq6ZQrlUosWrQIf//9N9auXYuDBw9iwoQJ+XrvDRo0wO3bt3Hz5k2pzM/PD9OmTcv1NZGRkahVq5ZO0hMSEoKkpCT8/fffBm330aNH2LhxIxo1agRzc3Op/ODBg9i6dSuWLl2a62uTk5Ph6+sLHx8fdO7cWe82v/zySzRu3Bhnz55Fhw4d0K9fP/Tv3x99+/ZFVFQUAgIC0L9/f4j/JfDDhw9Heno6fv/9d1y4cAFz586Fra2tQe+FXh2TLyIiIqJSom/fvjh27Bhu3bqFW7du4fjx4+jbt69OnfT0dMyePRurVq1CSEgIKlSogIEDB6Jv3774+uuvAQDm5uaYPn06goKC4O/vjz59+iA0NDRH8lW2bFksWbIEVatWRceOHdGhQwdEROSePN66dQvu7u45hhyOGTMGLVu2hJ+fH9544w3MmjUrx7ZexsvLS9qGVkBAAFxcXHJ9zb1793L0Nmmf37t3L8/tffzxx7CxsYGzszPi4uLwyy+/SMsePnyIgQMHYs2aNbC3t9f7+ipVqmDVqlX45ZdfsGHDBgiCgEaNGuH27ds69dq3b48PPvgAlSpVwpQpU5CUlIT69eujR48eqFy5Mj7++GNcvnwZ8fHxADTXsDVu3Bi1atVChQoV0LFjRzRr1izP90KFx8zUDSAiIiIq9ppu1fyrtHxe5tMVKNcJUKh06zbakLOuVwfAMwQ5/i7ecCWgUOjW9WhV4Ga6urqiQ4cOWLNmDURRRIcOHXIkH9evX0dqairatGmjU56RkaEzPHHp0qVYtWoV4uLi8OzZM2RkZOjMMAgANWrUgEr1/P17enriwoULubbv2bNneieVOHDgAMLDw3HlyhUkJSUhKysLaWlpSE1NRZkyZQx679bW1gCA1NRUqSyvRPBVjR8/HoMHD8atW7cwffp09O/fH7t27YJCocCQIUPw7rvv5pn0BAcHIzg4WHreqFEjVKtWDV9//TVmzpwpldeuXVv6vzYxrFWrVo6yhIQEeHh4YNSoUfjwww/x22+/oXXr1ujWrZvOOqhoseeLiIiI6FWprDQPheJ5mdJMU6Y0N7yuysKwuq9g0KBBWLNmDdauXYtBgwblWK69lmr37t04d+6c9Lh06ZJ03demTZswbtw4DB48GL/99hvOnTuH0NDQHNdBZR9mB2iuYRIEIde2ubi44PHjxzplN2/eRMeOHVG7dm1s27YNZ86ckYbq5XXd1YsePXoEQJOAGsrDw0PqMdLSPvfw8MjztS4uLqhcuTLatGmDTZs2Yc+ePThx4gQAzZDDefPmwczMDGZmZhg8eDASExNhZmaGVatW6V2fubk56tati+vXr+co11L89z3RV6b93N977z3cuHED/fr1w4ULFxAUFITFixe/9LOgwsGeLyIiIqJSpF27dsjIyIBCoUBISEiO5dWrV4elpSXi4uLQvHlzves4fvw4GjVqhGHDhkllMTExr9y2unXr4t69e3j8+DHKli0LADhz5gwEQcD8+fOl4Yj5HXIIABcvXoS5uTlq1Khh8GuCg4Px2WefISEhQUra9u/fD3t7e1SvXt3g9WgTn/T0dACaa8nUarW0/JdffsHcuXPxxx9/wNvbW+861Go1Lly4gPbt2xu83dz4+Phg6NChGDp0KCZNmoRvv/2W90EzEiZfRERERKWISqXC5cuXpf+/yM7ODuPGjcPYsWMhCAKaNGmCxMREHD9+HPb29hgwYAAqVaqEdevWYd++ffD398f69etx+vRp+Pv7v1Lb6tatCxcXFxw/fhwdO3YEAFSsWBGZmZlYvHgx3nrrLRw/fhwrVqx4yZpyOnr0KJo2bSoNPwSAVq1aoUuXLhgxYoTe17Rt2xbVq1dHv379MHfuXNy5cweffvophg8fDktLzVDQU6dOoX///oiIiIC3tzdOnjyJ06dPo0mTJihbtixiYmLw6aefIiAgQBpG+OKEIn/++SeUSiVq1qwplc2YMQOvv/46KlasiCdPnuCLL77ArVu38N577+X7vWc3ZswYvPnmm6hcuTIeP36MQ4cO5WgPFR0OOyQiIiIqZezt7XOd6AEAZs6ciU8//RTh4eGoVq0a2rVrh927d0vJ1QcffICuXbuiV69eaNiwIR4+fKjTC1ZQKpUKoaGh2Lhxo1RWp04dLFiwAHPnzkXNmjWxceNGhIeH53vdmzZtwpAhQ3TKYmJi8ODBgzzbs2vXLqhUKjRq1AgDBw5Ev379MGPGDKlOamoqoqOjpWnky5Qpg+3bt6NVq1aoUqUKBg8ejNq1a+PIkSNSwmaIx48fY8iQIahWrRrat2+PpKQk/PHHH/nqcdNHrVZj+PDhUlwrV66MZcuWvdI6yXAKUcx+4wgyVFJSEhwcHJCYmJjnwcsYBEFAQkIC3NzcCvWGhFRwjIm8MB7yw5jID2NimLS0NMTGxsLf31/vxBCFRRRFZGVlwczMTLpmp7S4d+8eatSogaioKPj6+hbKOn/99Vd89NFHOH/+PMzMCjbwqzTHRK6MHZO89n9DcwMeXYmIiIhINjw8PPDdd98hLi6u0NaZkpKC1atXFzjxIios/AYSERERkay8/fbbhbq+7t27F+r6iAqKPV9ERERERERGwOSLiIiIiIjICJh8EREREeUT5ysjKn0KY79n8kVERERkIHNzcwCa6cWJqHTR7vfa40BBcMINIiIiIgOpVCo4OjoiISEBgOaeTkUxxTWnNZcfxkR+jBUTURSRmpqKhIQEODo66r05uaGYfBERERHlg4eHBwBICVhREEURgiBAqVTyRF8mGBP5MXZMHB0dpf2/oJh8EREREeWDQqGAp6cn3NzckJmZWSTbEAQBDx8+hLOzM296LROMifwYMybm5uav1OOlxeSLiIiIqABUKlWhnIzpIwgCzM3NYWVlxRN9mWBM5Kc4xqR4tJKIiIiIiKiYY/JFRERERERkBEy+iIiIiIiIjIDJFxERERERkREw+SIiIiIiIjICJl9ERERERERGwOSLiIiIiIjICJh8ERERERERGQGTLyIiIiIiIiNg8kVERERERGQETL6IiIiIiIiMgMkXERERERGRETD5IiIiIiIiMgImX0REREREREbA5IuIiIiIiMgImHwREREREREZAZMvIiIiIiIiI2DyRUREREREZARMvoiIiIiIiIyAyRcREREREZERMPkiIiIiIiIyAiZfRERERERERsDki4iIiIiIyAiYfBERERERERkBky8iIiIiIiIjYPJFRERERERkBEy+iIiIiIiIjMDkydfSpUvh5+cHKysrNGzYEKdOncq17vbt2xEUFARHR0fY2NggMDAQ69evz1Hv8uXL6NSpExwcHGBjY4P69esjLi5OWp6Wlobhw4fD2dkZtra26NatG+Lj44vk/REREREREQEmTr42b96MsLAwTJ06FVFRUahTpw5CQkKQkJCgt76TkxMmT56MyMhInD9/HqGhoQgNDcW+ffukOjExMWjSpAmqVq2Kw4cP4/z58/j0009hZWUl1Rk7dix27tyJrVu34siRI/j333/RtWvXIn+/RERERERUeilEURRNtfGGDRuifv36WLJkCQBAEAT4+Phg5MiRmDhxokHreO2119ChQwfMnDkTANC7d2+Ym5vr7REDgMTERLi6uuL7779H9+7dAQBXrlxBtWrVEBkZiddff92g7SYlJcHBwQGJiYmwt7c36DVFRRAEJCQkwM3NDUqlyTszCYyJ3DAe8sOYyA9jIi+Mh/wwJvIjp5gYmhuYGbFNOjIyMnDmzBlMmjRJKlMqlWjdujUiIyNf+npRFHHw4EFER0dj7ty5ADQB2L17NyZMmICQkBCcPXsW/v7+mDRpEt5++20AwJkzZ5CZmYnWrVtL66patSrKly+fZ/KVnp6O9PR06XlSUpK0TUEQ8v3+C5MgCBBF0eTtoOcYE3lhPOSHMZEfxkReGA/5YUzkR04xMbQNJku+Hjx4ALVaDXd3d51yd3d3XLlyJdfXJSYmwtvbG+np6VCpVFi2bBnatGkDAEhISEBycjLmzJmDWbNmYe7cudi7dy+6du2KQ4cOoXnz5rh37x4sLCzg6OiYY7v37t3Ldbvh4eGYPn16jvL79+8jLS0tH++88AmCgMTERIiiaPKsnzQYE3lhPOSHMZEfxkReGA/5YUzkR04xefr0qUH1TJZ8FZSdnR3OnTuH5ORkREREICwsDBUqVECLFi2kjLNz584YO3YsACAwMBB//PEHVqxYgebNmxd4u5MmTUJYWJj0PCkpCT4+PnB1dZXFsEOFQgFXV1eTf/FIgzGRF8ZDfhgT+WFM5IXxkB/GRH7kFJPs80vkxWTJl4uLC1QqVY5ZBuPj4+Hh4ZHr65RKJSpWrAhAk1hdvnwZ4eHhaNGiBVxcXGBmZobq1avrvKZatWo4duwYAMDDwwMZGRl48uSJTu/Xy7ZraWkJS0tLve0xdbABQKFQyKYtpMGYyAvjIT+MifwwJvLCeMgPYyI/comJods3WSstLCxQr149RERESGWCICAiIgLBwcEGr0cQBOlaLAsLC9SvXx/R0dE6da5evQpfX18AQL169WBubq6z3ejoaMTFxeVru0RERERERPlh0mGHYWFhGDBgAIKCgtCgQQMsXLgQKSkpCA0NBQD0798f3t7eCA8PB6C57iooKAgBAQFIT0/Hnj17sH79eixfvlxa5/jx49GrVy80a9YMLVu2xN69e7Fz504cPnwYAODg4IDBgwcjLCwMTk5OsLe3x8iRIxEcHGzwTIdERERERET5ZdLkq1evXrh//z6mTJmCe/fuITAwEHv37pUm4YiLi9PpwktJScGwYcNw+/ZtWFtbo2rVqtiwYQN69eol1enSpQtWrFiB8PBwjBo1ClWqVMG2bdvQpEkTqc6XX34JpVKJbt26IT09HSEhIVi2bJnx3jgREREREZU6Jr3PV3HG+3xRXhgTeWE85IcxkR/GRF4YD/lhTORHTjExNDfgN4eIiIiIiMgImHwREREREREZAZMvIiIiIiIiI2DyRUREREREZARMvoiIiIiIiIyAyRcREREREZERMPkiIiIiIiIyAiZfRERERERERsDki4iIiIiIyAiYfBERERERERkBky8iIiIiIiIjYPJFRERERERkBEy+iIiIiIiIjIDJFxERERERkREw+SIiIiIiIjICJl9ERERERERGwOSLiIiIiIjICJh8ERERERERGQGTLyIiIiIiIiNg8kVERERERGQETL6IiIiIiIiMgMkXERERERGRETD5IiIiIiIiMgImX0REREREREbA5IuIiIiIiMgImHwREREREREZAZMvIiIiIiIiI2DyRUREREREZARMvoiIiIiIiIyAyRcREREREZERMPkiIiIiIiIyAiZfRERERERERsDki4iIiIiIyAiYfBERERERERkBky8iIiIiIiIjYPJFRERERERkBEy+iIiIiIiIjIDJFxERERERkREw+SIiIiIiIjICJl9ERERERERGwOSLiIiIiIjICJh8ERERERERGQGTLyIiIiIiIiNg8kVERERERGQETL6IiIiIiIiMwCw/lQVBwJEjR3D06FHcunULqampcHV1Rd26ddG6dWv4+PgUVTuJiIiIiIiKNYN6vp49e4ZZs2bBx8cH7du3x6+//oonT55ApVLh+vXrmDp1Kvz9/dG+fXucOHGiqNtMRERERERU7BjU81W5cmUEBwfj22+/RZs2bWBubp6jzq1bt/D999+jd+/emDx5MoYMGVLojSUiIiIiIiquDEq+fvvtN1SrVi3POr6+vpg0aRLGjRuHuLi4QmkcERERERFRSWHQsMOXJV7ZmZubIyAgoMANIiIiIiIiKonyPdvh3r17cezYMen50qVLERgYiHfffRePHz8u1MYRERERERGVFPlOvsaPH4+kpCQAwIULF/DRRx+hffv2iI2NRVhYWKE3kIiIiIiIqCTI11TzABAbG4vq1asDALZt24aOHTti9uzZiIqKQvv27Qu9gURERERERCVBvnu+LCwskJqaCgA4cOAA2rZtCwBwcnKSesSIiIiIiIhIV757vpo0aYKwsDA0btwYp06dwubNmwEAV69eRbly5Qq9gURERERERCVBvnu+lixZAjMzM/z4449Yvnw5vL29AQC//vor2rVrV+gNJCIiIiIiKgny3fNVvnx57Nq1K0f5l19+WSgNIiIiIiIiKonynXxpJSQkICEhAYIg6JTXrl37lRtFRERERERU0uQ7+Tpz5gwGDBiAy5cvQxRFAIBCoYAoilAoFFCr1YXeSCIiIiIiouIu38nXoEGDULlyZXz33Xdwd3eHQqEoinYRERERERGVKPlOvm7cuIFt27ahYsWKRdEeIiIiIiKiEinfsx22atUKf/31V1G0hYiIiIiIqMTKd8/XypUrMWDAAFy8eBE1a9aEubm5zvJOnToVWuOIiIiIiIhKinwnX5GRkTh+/Dh+/fXXHMs44QYREREREZF++R52OHLkSPTt2xd3796FIAg6DyZeRERERERE+uU7+Xr48CHGjh0Ld3f3QmvE0qVL4efnBysrKzRs2BCnTp3Kte727dsRFBQER0dH2NjYIDAwEOvXr9epM3DgQCgUCp1Hu3btdOr4+fnlqDNnzpxCe09ERERERETZ5XvYYdeuXXHo0CEEBAQUSgM2b96MsLAwrFixAg0bNsTChQsREhKC6OhouLm55ajv5OSEyZMno2rVqrCwsMCuXbsQGhoKNzc3hISESPXatWuH1atXS88tLS1zrGvGjBkYMmSI9NzOzq5Q3hMREREREdGL8p18Va5cGZMmTcKxY8dQq1atHBNujBo1Kl/rW7BgAYYMGYLQ0FAAwIoVK7B7926sWrUKEydOzFG/RYsWOs9Hjx6NtWvX4tixYzrJl6WlJTw8PPLctp2d3UvrEBERERERFYYCzXZoa2uLI0eO4MiRIzrLFApFvpKvjIwMnDlzBpMmTZLKlEolWrdujcjIyJe+XhRFHDx4ENHR0Zg7d67OssOHD8PNzQ1ly5bFG2+8gVmzZsHZ2Vmnzpw5czBz5kyUL18e7777LsaOHQszM/0fSXp6OtLT06XnSUlJACBd72ZKgiBAFEWTt4OeY0zkhfGQH8ZEfhgTeWE85IcxkR85xcTQNuQ7+YqNjc13Y3Lz4MEDqNXqHNePubu748qVK7m+LjExEd7e3khPT4dKpcKyZcvQpk0baXm7du3QtWtX+Pv7IyYmBv/73//w5ptvIjIyEiqVCoCmh+61116Dk5MT/vjjD0yaNAl3797FggUL9G4zPDwc06dPz1F+//59pKWlFeTtFxpBEJCYmAhRFKFU5vsyPioCjIm8MB7yw5jID2MiL4yH/DAm8iOnmDx9+tSgevlOvuTAzs4O586dQ3JyMiIiIhAWFoYKFSpIQxJ79+4t1a1VqxZq166NgIAAHD58GK1atQIAhIWFSXVq164NCwsLfPDBBwgPD9d7fdikSZN0XpOUlAQfHx+4urrC3t6+iN6pYQRBgEKhgKurq8m/eKTBmMgL4yE/jIn8MCbywnjID2MiP3KKiZWVlUH1DEq+5syZg9GjR8Pa2vqldU+ePIkHDx6gQ4cOL63r4uIClUqF+Ph4nfL4+Pg8r8VSKpWoWLEiACAwMBCXL19GeHh4juvBtCpUqAAXFxdcv35dSr5e1LBhQ2RlZeHmzZuoUqVKjuWWlpZ6kzKlUmnyYAOaIZ9yaQtpMCbywnjID2MiP4yJvDAe8sOYyI9cYmLo9g2qdenSJZQvXx7Dhg3Dr7/+ivv370vLsrKycP78eSxbtgyNGjVCr169DJ410MLCAvXq1UNERIRUJggCIiIiEBwcbNA6tK/Jfj3Wi27fvo2HDx/C09Mz1zrnzp2DUqnUO8MiERERERHRqzKo52vdunX466+/sGTJErz77rtISkqCSqWCpaUlUlNTAQB169bFe++9h4EDBxrc7QZohv8NGDAAQUFBaNCgARYuXIiUlBRp9sP+/fvD29sb4eHhADTXXgUFBSEgIADp6enYs2cP1q9fj+XLlwMAkpOTMX36dHTr1g0eHh6IiYnBhAkTULFiRWk2xMjISJw8eRItW7aEnZ0dIiMjMXbsWPTt2xdly5Y1/NMjIiIiIiIykMHXfNWpUwfffvstvv76a5w/fx63bt3Cs2fP4OLigsDAQLi4uBSoAb169cL9+/cxZcoU3Lt3D4GBgdi7d680CUdcXJxON15KSgqGDRuG27dvw9raGlWrVsWGDRvQq1cvAIBKpcL58+exdu1aPHnyBF5eXmjbti1mzpwpDRu0tLTEpk2bMG3aNKSnp8Pf3x9jx47VuaaLiIiIiIioMClEURRN3YjiKCkpCQ4ODkhMTJTFhBsJCQlwc3Mz+XhX0mBM5IXxkB/GRH4YE3lhPOSHMZEfOcXE0NyA3xwiIiIiIiIjYPJFRERERERkBEy+iIiIiIiIjIDJFxERERERkREUOPm6fv069u3bh2fPngEAOG8HERERERFR7vKdfD18+BCtW7dG5cqV0b59e9y9excAMHjwYHz00UeF3kAiIiIiIqKSIN/J19ixY2FmZoa4uDiUKVNGKu/Vqxf27t1bqI0jIiIiIiIqKQy+ybLWb7/9hn379qFcuXI65ZUqVcKtW7cKrWFEREREREQlSb57vlJSUnR6vLQePXoES0vLQmkUERERERFRSZPv5Ktp06ZYt26d9FyhUEAQBHz++edo2bJloTaOiIiIiIiopMj3sMPPP/8crVq1wp9//omMjAxMmDABf//9Nx49eoTjx48XRRuJiIiIiIiKvXz3fNWsWRNXr15FkyZN0LlzZ6SkpKBr1644e/YsAgICiqKNRERERERExV6+e74AwMHBAZMnTy7sthAREREREZVYBUq+0tLScP78eSQkJEAQBJ1lnTp1KpSGERERERERlST5Tr727t2L/v3748GDBzmWKRQKqNXqQmkYERERERFRSZLva75GjhyJHj164O7duxAEQefBxIuIiIiIiEi/fCdf8fHxCAsLg7u7e1G0h4iIiIiIqETKd/LVvXt3HD58uAiaQkREREREVHLl+5qvJUuWoEePHjh69Chq1aoFc3NzneWjRo0qtMYRERERERGVFPlOvn744Qf89ttvsLKywuHDh6FQKKRlCoWCyRcREREREZEe+U6+Jk+ejOnTp2PixIlQKvM9apGIiIiIiKhUynf2lJGRgV69ejHxIiIiIiIiyod8Z1ADBgzA5s2bi6ItREREREREJVa+hx2q1Wp8/vnn2LdvH2rXrp1jwo0FCxYUWuOIiIiIiIhKinwnXxcuXEDdunUBABcvXtRZln3yDSIiIiIiInou38nXoUOHiqIdREREREREJRpnzSAiIiIiIjICg3q+unbtijVr1sDe3h5du3bNs+727dsLpWFEREREREQliUHJl4ODg3Q9l4ODQ5E2iIiIiIiIqCQyKPlavXo1ZsyYgXHjxmH16tVF3SYiIiIiIqISx+BrvqZPn47k5OSibAsREREREVGJZXDyJYpiUbaDiIiIiIioRMvXbIe8jxcREREREVHB5Os+X5UrV35pAvbo0aNXahAREREREVFJlK/ka/r06ZztkIiIiIiIqADylXz17t0bbm5uRdUWIiIiIiKiEsvga754vRcREREREVHBcbZDIiIiIiIiIzB42KEgCEXZDiIiIiIiohItX1PNExERERERUcEw+SIiIiIiIjICJl9ERERERERGwOSLiIiIiIjICJh8ERERERERGQGTLyIiIiIiIiNg8kVERERERGQETL6IiIiIiIiMgMkXERERERGRETD5IiIiIiIiMgImX0REREREREbA5IuIiIiIiMgImHwREREREREZAZMvIiIiIiIiI2DyRUREREREZARMvoiIiIiIiIyAyRcREREREZERMPkiIiIiIiIyAiZfRERERERERsDki4iIiIiIyAiYfBERERERERkBky8iIiIiIiIjYPJFRERERERkBEy+iIiIiIiIjIDJFxERERERkREw+SIiIiIiIjICWSRfS5cuhZ+fH6ysrNCwYUOcOnUq17rbt29HUFAQHB0dYWNjg8DAQKxfv16nzsCBA6FQKHQe7dq106nz6NEj9OnTB/b29nB0dMTgwYORnJxcJO+PiIiIiIjI5MnX5s2bERYWhqlTpyIqKgp16tRBSEgIEhIS9NZ3cnLC5MmTERkZifPnzyM0NBShoaHYt2+fTr127drh7t270uOHH37QWd6nTx/8/fff2L9/P3bt2oXff/8d77//fpG9TyIiIiIiKt1MnnwtWLAAQ4YMQWhoKKpXr44VK1agTJkyWLVqld76LVq0QJcuXVCtWjUEBARg9OjRqF27No4dO6ZTz9LSEh4eHtKjbNmy0rLLly9j7969WLlyJRo2bIgmTZpg8eLF2LRpE/79998ifb9ERERERFQ6mZly4xkZGThz5gwmTZoklSmVSrRu3RqRkZEvfb0oijh48CCio6Mxd+5cnWWHDx+Gm5sbypYtizfeeAOzZs2Cs7MzACAyMhKOjo4ICgqS6rdu3RpKpRInT55Ely5dcmwrPT0d6enp0vOkpCQAgCAIEAQhf2+8kAmCAFEUTd4Oeo4xkRfGQ34YE/lhTOSF8ZAfxkR+5BQTQ9tg0uTrwYMHUKvVcHd31yl3d3fHlStXcn1dYmIivL29kZ6eDpVKhWXLlqFNmzbS8nbt2qFr167w9/dHTEwM/ve//+HNN99EZGQkVCoV7t27Bzc3N511mpmZwcnJCffu3dO7zfDwcEyfPj1H+f3795GWlpaft13oBEFAYmIiRFGEUmnyzkwCYyI3jIf8MCbyw5jIC+MhP4yJ/MgpJk+fPjWonkmTr4Kys7PDuXPnkJycjIiICISFhaFChQpo0aIFAKB3795S3Vq1aqF27doICAjA4cOH0apVqwJtc9KkSQgLC5OeJyUlwcfHB66urrC3t3+l9/OqBEGAQqGAq6uryb94pMGYyAvjIT+MifwwJvLCeMgPYyI/coqJlZWVQfVMmny5uLhApVIhPj5epzw+Ph4eHh65vk6pVKJixYoAgMDAQFy+fBnh4eFS8vWiChUqwMXFBdevX0erVq3g4eGRY0KPrKwsPHr0KNftWlpawtLSUm9bTB1sAFAoFLJpC2kwJvLCeMgPYyI/jIm8MB7yw5jIj1xiYuj2TdpKCwsL1KtXDxEREVKZIAiIiIhAcHCwwesRBEHneqwX3b59Gw8fPoSnpycAIDg4GE+ePMGZM2ekOgcPHoQgCGjYsGEB3gkREREREVHeTD7sMCwsDAMGDEBQUBAaNGiAhQsXIiUlBaGhoQCA/v37w9vbG+Hh4QA0114FBQUhICAA6enp2LNnD9avX4/ly5cDAJKTkzF9+nR069YNHh4eiImJwYQJE1CxYkWEhIQAAKpVq4Z27dphyJAhWLFiBTIzMzFixAj07t0bXl5epvkgiIiIiIioRDN58tWrVy/cv38fU6ZMwb179xAYGIi9e/dKk3DExcXpdOOlpKRg2LBhuH37NqytrVG1alVs2LABvXr1AgCoVCqcP38ea9euxZMnT+Dl5YW2bdti5syZOsMGN27ciBEjRqBVq1ZQKpXo1q0bFi1aZNw3T0REREREpYZCFEXR1I0ojpKSkuDg4IDExERZTLiRkJAANzc3k493JQ3GRF4YD/lhTOSHMZEXxkN+GBP5kVNMDM0N+M0hIiIiIiIyAiZfRERERERERsDki4iIiIiIyAiYfBERERERERkBky8iIiIiIiIjYPJFRERERERkBEy+iIiIiIiIjIDJFxERERERkREw+SIiIiIiIjICJl9ERERERERGwOSLiIiIiIjICJh8ERERERERGQGTLyIiIiIiIiNg8kVERERERGQETL6IiIiIiIiMgMkXERERERGRETD5IiIiIiIiMgImX0REREREREbA5IuIiIiIiMgImHwREREREREZAZMvIiIiIiIiI2DyRUREREREZARMvoiIiIiIiIyAyRcREREREZERMPkiIiIiIiIyAiZfRERERERERsDki4iIiIiIyAiYfBERERERERkBky8iIiIiIiIjYPJFRERERERkBEy+iIiIiIiIjIDJFxERERERkREw+SIiIiIiIjICJl9ERERERERGwOSLiIiIiIjICJh8ERERERERGQGTLyIiIiIiIiNg8kVERERERGQETL6IiIiIiIiMgMkXERERERGRETD5IiIiIiIiMgImX0REREREREbA5IuIiIiIiMgImHwREREREREZAZMvIiIiIiIiI2DyRUREREREZARMvoiIiIiIiIyAyRcREREREZERMPkiIiIiIiIyAiZfRERERERERsDki4iIiIiIyAiYfBERERERERkBky8iIiIiIiIjMDN1A4iIitLNm0BkJJCZCZibA8HBgJ+fqVtFREREpRGTLyIqke7eBebNA44eBZKTgapVgStXAFtboFkz4KOPAE9PU7eSiIiIShMOOySiEufuXWDYMGDnTk1vV4UKmkSrQgXN8x07NMvv3jV1S4mIiKg0YfJFRCXOvHnA339rki0nJ0D535FOqdQ8r1BBs3zBAtO2k4iIiEoXJl9EVKLcvKkZaujqqunl0sfcXLP8yBFNfSIiIiJj4DVfJAvaSRFSUgAbG06KQAUXGQkkJQEBAXnXc3QEYmKAEyf4XSMiIiLjYPJFJpV9UoSkJM2wMEEA7O05KQIVTEqK5nukfEm/vrZOcrJx2kVERETE5OtVqdMA0Q5QKDTPhSxAzAIUKkBprlsPAJSWOetCCagsClg3HRDUgCg8LxPUgJipvy5EQGkBKJQvqZsBQAAU5oBSpSkTBUDIyGddBaCy1FPXDHfjzTBsGHDpkgAv9wx4uisgwBKCADx5Avy6OwNxsQK+WmQGT+//vqqiCAjpmv+rrLK950xAVAMKM0D5inX1fe75qqsCoMr2nvOI5yt9T/TFMz91XxL7V/6e5Bb7/H1PXhrPF+ra2ACCIEKFdCiVQKbwvK5KkQmFQoRaNEOW2gyCANjaiP99PiiE70k+4mnMY4TBsTfyMUKdptmm0lpP3eyfeyF8T+R2jDDK9ySfxwiDf0uK9zEiz7pF/j3JRzxFBXSUxmOEwbE3xTFCLH3HCLmeRxj8W1LExwjtZ/8SvObrVf3RH8hMev78n+3A0R7AtRUv1OurKU+//7zs392asquLdOueGKwpT/3nedm9CE3Z5c91654eBsXxnlA9u/m87P5RTd2LM3XrRo3VlCf+/bzs0WlN2flPdOuem6gpfxz1vOzJeU3Z2XG6dS9M1ZQ/iHxelhStKftzpG7dS+Ga8oQj0qQIwbVuYu5bPTDq9fcBPJ8U4aMOCzC0Zg/sWbXv+euf3dW8PnKg7nqvLtWU39nxvCzjkabseG/dujErNeVxW56XqVM1ZUd7aHYqrdh1mrLYdc/LRPXzuurU5+VxWzRlMSt1t3e8t6Y849Hzsjs7/ov9Ut26kQM15c+yTcN3d5+m7MoLs0Ocel9TnnLzeVnCEU3ZpXDdun+O1JQnRT8vexCpKbswVbfu2XGa8ifnn5c9jtKUnZuoW/f8J5ryR6eflyX+rSmLGqtb9+JMTfn9o8/LnsZoyk4P0617+XNN+b2I52Wp/2jKTgzWrXt1kab8390ANENWfd3vY9zrPfBRcF+dqu0qfo2JTXqgUbntePJE08PaqEHS83hmd2ONpuzWD8/LhPTndbUHZUBT52gPzWuy09Y18TECR3toPmstmRwjHC++D8WZUbp1sx0jJCk3NWWn3tete2WBpvwujxGFcYxQHO8JVer152Ul9BgBQLOfHe2h2e+yu7ZCU/7P9udlmSY6Rlz/WrduKTxGvOw8QsJjxHOl7TwiOUbzW/LncN26pjhG/NEfhmDyRSZx7x6kSRHMcul/VSkBCwvg4gVOikCG8/MDXn8dyMgABFF/nSw18OAB0Lw5UN7HqM0jIiKiUkwhimIupyeUl6SkJDg4OCDxUTzsHV1NOqRIENRIePAEbu4eUCqVxWK4wKbNZpg2wwwBAYBKKcBMmQERCmQJz+uaKTMgCgKuXTfDp1PN0Ls3is2QIgEqJCQkwM3NDUoxI8+6pX64QBEMKbr7r4jRI9Nx6TLgUNYKZcsK8PVNwO24skhKFBGfYIYq1cywbBng6WGiIUWlfNihoM5Cwr3bcHNzh9Kcww4Lpe4rHiMM/y0p/seI4jDsUBAVSHjwWPM7olSWumOEHIcdCoKg+W13KQulgsMO5XCMyN9vSdEeI5KSkuDg5I7ExETY29sjN7zm61WprJ5/uYH/AqHnY80euEKtawkohOdfbuC/L6RKf90c682trkXOMoVSf9sKUDc5FdKEByKUOtflaGUJmrqiItukCApFLp+POQBz3bJCqavnczekrpDtuomijP0r1c1H7E30PdGtm8vnrqeup5cCXy2xwoIFmunkb9zQ9KJeizGHra0SHd4CwsK0k7kU0fcEkEnd/MTeBMeIF7dZVN8TuR0jspPLMcLg35Lif4yQxfcEyLtu9t+Rl9XNz3pz1JX5MaLQ6xZS7F+c1ak0HCNy1JXRMcKg35IiPkaoMnLW10MWww6XLl0KPz8/WFlZoWHDhjh16lSudbdv346goCA4OjrCxsYGgYGBWL9+fa71hw4dCoVCgYULF+qU+/n5QaFQ6DzmzJlTWG+JXkIzKULO35YXaevY2hqnXVRyeHoCX3wBbNkCTJkCvP225t+tWzXlnEWTiIiIjM3kPV+bN29GWFgYVqxYgYYNG2LhwoUICQlBdHQ03NzcctR3cnLC5MmTUbVqVVhYWGDXrl0IDQ2Fm5sbQkJCdOr+9NNPOHHiBLy8vPRue8aMGRgyZIj03M7OrnDfHOUqOFgz2cGTJ5rJNXKjnRQhONhYLaOSxs8PKF8eSEgA3Nxy/rGSiIiIyFhMfhqyYMECDBkyBKGhoahevTpWrFiBMmXKYNWqVXrrt2jRAl26dEG1atUQEBCA0aNHo3bt2jh27JhOvTt37mDkyJHYuHEjzM3N9a7Lzs4OHh4e0sPGxqbQ3x/p5+cHNG0K3L8PZGbqr5OZ+XxSBF9fozbvldy8CWzeDPz2m+ZfThZCRERERICJe74yMjJw5swZTJo0SSpTKpVo3bo1IiMj83ilhiiKOHjwIKKjozF37lypXBAE9OvXD+PHj0eNGjVyff2cOXMwc+ZMlC9fHu+++y7Gjh0Ls1ym3ktPT0d6+vNpY5OSkqRtCS8bO1fEBEGAKIomb0d+ffQREBsLXLoEuLgAjo6QbrL85Anw8CFQowYwduzLhyfKwb17wPz5wLFjQEqKgCpVRERHC7Cx0SSaYWGAh4epW1k6Fdd9pCRjTOSHMZEXxkN+GBP5kVNMDG2DSZOvBw8eQK1Ww93dXafc3d0dV65cyfV1iYmJ8Pb2Rnp6OlQqFZYtW4Y2bdpIy+fOnQszMzOMGjUq13WMGjUKr732GpycnPDHH39g0qRJuHv3LhYsWKC3fnh4OKZPn56j/P79+0hLM+ymakVFEAQkJiZCFEXNjEjFhFIJzJoF/PILcPEikJqquWZRFDU9XR06AJ07a+olJJi6tXl79AhYvhyIiwOqVAFsbQW4uSXC3V1EcrIS164B4eHAhx/mPcySikZx3UdKMsZEfhgTeWE85IcxkR85xeTp06cG1TP5NV8FYWdnh3PnziE5ORkREREICwtDhQoV0KJFC5w5cwZfffUVoqKioMg+C+ELwsLCpP/Xrl0bFhYW+OCDDxAeHg5Ly5wzukyaNEnnNUlJSfDx8YGrq2ue00kagyAIUCgUcHV1NfkXL7/c3ICqVYFbt4CTJzWzGtraau7TVL68qVtnuC++APbvB/z9Nb12iYkClEoF7txxhSgqkZmpWW5lBWTrpCUjKc77SEnFmMgPYyIvjIf8MCbyI6eYWFnpmR1RD5MmXy4uLlCpVIiPj9cpj4+Ph0ce47OUSiUqVqwIAAgMDMTly5cRHh6OFi1a4OjRo0hISED5bGfuarUaH330ERYuXIibuVyA07BhQ2RlZeHmzZuoUqVKjuWWlpZ6kzKlUmnyYAOAQqGQTVsKwt9f8yiObt7U3DDa2Vlzw2jtnfNEUQFRVEIUlTAz0yw/ckTTO+bnZ8oWl07FfR8piRgT+WFM5IXxkB/GRH7kEhNDt2/SVlpYWKBevXqIiIiQygRBQEREBILzMb2dIAjS9Vj9+vXD+fPnce7cOenh5eWF8ePHY9++fbmu49y5c1AqlXpnWCTKS2QkkJSkuWYtL46OmnonThijVUREhuNEQURExmHyYYdhYWEYMGAAgoKC0KBBAyxcuBApKSkIDQ0FAPTv3x/e3t4IDw8HoLn2KigoCAEBAUhPT8eePXuwfv16LF++HADg7OwMZ2dnnW2Ym5vDw8ND6tGKjIzEyZMn0bJlS9jZ2SEyMhJjx45F3759UbZsWSO+eyoJUlKe3zA6L9o60g2jZe7mTU1imZKiuS9bcDB77IhKmrt3gXnzNL33ycmaYeBXrmiGfzdrppkYiffEIyIqPCZPvnr16oX79+9jypQpuHfvHgIDA7F3715pEo64uDidbryUlBQMGzYMt2/fhrW1NapWrYoNGzagV69eBm/T0tISmzZtwrRp05Ceng5/f3+MHTtW55ouIkNlv2F0XglYcblhdPaTsaSk5zNQ2tvzZIyoJLl7Fxg2DPj7b8DVFahQQbNvZ2QAjx8DO3YAMTHAsmXc54m0f5DMzATMzfkHSSo4hShqr1Ch/EhKSoKDgwMSExNlMeFGQkIC3NzcTD7etTS6eRPo2VNzMNbOZKhQCPDxScA//7hBFDUxefRIc9DeulW+9y178WTsxen/79/XTP9f3E7GuI/ID2Nieh99BOzcqUm6zM1zHrcyM4EbNzSzzn7xhalbW/pwH5EH3d5hAVWrJuDKFTfY2ir5B0kZkNN+YmhuwL2Z6BWVpBtGz5unSbwqVNAkktrjmFKpeV6hgmZ5LndkIKJiQjtRkKurJvHSx9xcs/zIEV4DRqWT9g+SO3dq9gdt77D2DxY7dmiW371r6pZSccLki6gQjBun6RG6cUPTw6W9z54gaJ7HxgLVq2tutCxXPBkjKj04URDRy/EPkvJWXCcKMvk1X0QlgaenZijeggWaxOTGDcDCQvOvrS3QqZMm8ZLz0ATtyVhAQN71HB0114GcOMHx7kTFVUmdKIiosBTkD5L8TTSO4j5REJMvokLi6am5LuLmTU1ikpGhScCCg+U91FCLJ2NkLLxw3fRK2kRBJQ33EdPjHyTlqSRMFMTki6iQ+fkB5csDCQmAm9vLkxm54MkYFbXi/tfKkiQ4WDOD6ZMnzycK0ufJE029fNx6k14B9xH54B8k5Sn7UFDNREGacu1QUDu750NB5TpRUDE5LSSiopb9ZCwvPBmjguCF6/JSkiYKKim4j8hL9j9I5oV/kDSeknJtOnu+XlFaVhossixylCsVSlioLHTq5eZV6qZnpUMtqJGWlYa0rDSdaTYVUMDSzFKnrgj9dxZ4sW6GOgOCmPsRx8rMyuR1LVWWUPz3J49MdSbUorrQ62YJWcgSsvJdVxCEHDGxUFlAqVAatN781DVXmkOlVOW7rlpQI1N4ftblUQ4Ibgrs3g2UsQcszMyg/O8QIUINQZGJzEwg4RHQsSPg7g2k/bcpM6UZzJSauoIoIEOdkWsbClpXFEWkq9MLVPfFeKgUKpirzA1ab37qGmu/z+8xwtD9viiPEXPmCbhwGfAP0Pw4igoBWUiDqEqDk1MZ6a+VXyzIwOzwkn+M0MfYx4gRY4BrscClS9pbSwgQoIYgaIbv3H+oRtUamRg26vm+nl32fe7F40ledeV4jHiRKY4Rc+ZBZx/BC3/RL2OfhguXgc8XAOHhhq/3ZW2QyzFCbucRrzUAbB2BR0lA2bKAUrTUhgQCMiEoNJ/D4yRNvbr1n+8nJeUY8bK6+dnvC+MYceQ48CQZCPA3A6TzE81viVqRBvG/PiW7sppr7n//AyhX3njHiLz2u+x4n68C0s7lH7IyBOZlcqbfQZ5BmNpiqvS8+5buuQaxpmtNhLd+fiTts70PktKT9Nat5FQJC0KeT6sz+JfBiE+JR0Z6BiwsLaQdGAB87H2wrMMy6fmw3cPwT9I/etfrVsYN33X+Tnoeti8M1x5d01vX3tIeG7tulJ5POjAJF+9f1FvXUmWJH3v+KD2ffng6/rz7p966ALDznZ3S/+ccm4Pj/xzPte7WHlulg+zCEwsRERuRa90NXTbAwcoBALD89HLsub4n17rfdfoObjZuAIBVZ1fhpys/5Vp3afulKO9QHgDw/YXv8cPFHwBodsQXY7Kg7QJUcq4EANh+eTtWn1ud63pnvzEbtdxrAQB2X92NFWdW5Fp3SrMpqO9dHwAQcSMCC08uzLXux40/RpPyTQAAx+KOYe7xuTrL09KACxeA5KeA770x8BNaQakEHlmfxmW3GcjI0Px1r1YtwOr57xuG1huKDpU7AAAuxF/A/w7+L9c2hAaGomu1rgCAaw+vIey33KeAfKfmO3i31rsAgLjEOAzfMzzXul2qdsGguoMAAAkpCRi8Y7C07MV4tK/YHh/W/xAAkJiWiL4/9c11va38W2HM62M0n09WGnps7ZFr3cY+jTGxyUTp+Vs/vJVrXWMeIxJSE/TWNdYxYti2Sfg+4iKUyud/rVRAhJV1BjJS7VAvZhsAzcygN/2mo+obf6JMGb2rLjHHCH1McYxIS9OcpDx8CKizRNR9NgQPzrwFW1slAloew4Oqc3X29ezGNByDVhVaAQBO3zmNGb/PyLUNcj9GvMjYx4jUVODMGejsI46p9dDabKh037U/K2iOEYIA1KsHnX2kuB8j5HoecelvID5e81m/dmsDLAQ7+Pgk4OizbYh32AtRAFKfAe7umhmNtUrSMeJFLzuPyK6wjxFxccCNGKDKs1B4PtEcI1KsonGj0kikPbOAiOfnwKkpQIUA4OP2xjtGZKZmYt97+156ny/2fBGRxMpKk1jduAGobwMxsZqTgRRHQHDR/MBUqIBcT8aI9LlzB8jKAmxySai0HB2B9HTgyWPkmnxR4bKy0pw0pqZqPvdm9kDNDpphxf8ogLm5n7dSIXr82LB9xNwMSEnlPmIsFQI0n3fyU02MXO005aKoGZar/YNkhQqmbWdpoVIBIjSff55ETT0zlREaVQDs+Sogbc9X/MN4vdmtsYcd6ru7d2keLlBYdV9l2OGLMSluwwVux5nhz1NmSE4GytioUa9BZq7Xfch9SNGL8eCwQw1jHSNWfJuBhV8JOicoCoWAcuUScPu2G5TC87PI67EZGDVaQGjoy9dbnI8R+pj6GCEIAh4/eAxPD08olUqjDyl61brFedjh6tXAV1/pnsQrFYBvuSdSz5daoal74wYwejR09pHifoyQ83nE3bvAokXAsSOWSEkWUbVqAi5Hl4WNnYimTYFRo3JOglJSjxEv1jX2MeLWLaBPH81lEc5l/+s/UmTBy+c2bt/W7CeAJlHOzAQ2btQMUTTWMSIpKQnuzu7s+SpqVmZWOjt6XvXys05DWZpZQhAEqR3KPKblyX5QfJnsB+biUNdcZQ5z5HL15SvUzb4j5qfuy2JS0PUWZl2VUiUdQPWpWEHz+K/2f4+XUyqUBn+H81NXoVAUuG5e8XiV9b6MHOrmZ78vqmOEg60FkAUo1M9nDlNAgBmsoBKtpFM5QQDELAuUtQOsDPgaF+djhBzrCoKgc0x42TEiu/zUleMxwhR1gef7sqMt9O4j2alEK83kD1l46T5S3I4Rcqib237v7wN8Kd1GRkRGBtDTwhzBwUqDJqKR+37/KnWNfYyoEgA0b6yZlMbe9r/ZDqF8/lsiKpGZCTxK0NxftcoLtwko6v0+wyz3PxRlx+SLiKiY0N77JyVFMxNXcbn3D6c1J8ob9xH5K663kSlpxo3T9P5q7/NVtqymXDtR0IMHmqHUYblfKmpyTL6IiGQu+71/kpI0P/qCoDkJKw73/tFOa75zp+YeLPqmCNZOa96pE6c1p9KH+wiRYTw9NTdQXrBAM538jRuAhYXmX1tbzf4RFibv30QmX0REMqa994/2r3wBAc+TrydPNPf+iYnR/BjJ+cemJPy1kqgocR8hMoynp+YGypqhoJqJTywsND3CxeEPE0y+iIhkbN48zcmY9karWtp7/2jvj7VggebHSK5Kwl8riYoS9xEyhuI6fF2f4joUlMkXEZFM3bypGWro6qp/GBKgKXd11Zys3bwp7x/R4v7XSpK/4n5iyX2EikpxH75ekjD5IiKSqchIzY9kQEDe9RwdNUMPT5woHieaxfWvlSRfJe3EkvsIFaaSMny9pGDyRUQkUykpmh/Il514aeskJxunXURywhNLeSvuvZElQUkZvl5SMPkiIpIpGxvNCaQg5J2AaevY2hqvbcSTSrngiaU8lbTeyOKqpA1fLwmYfBERyRTv/SNPPKmUD55YyhN7I+WjpA5fL844ipiISKa09/65f19zjx99tPf+ad6cF+Qbg/akcudOzUl9QMDzh7m55qRy2DBNPSp62hNLR8e86zk6auqdOGGMVlH23kgnp+c999reyAoVnvdGUtHi8HX5YfJFRCRj48YBNWpoppt+9Ejzl2NA8++jR0BsLO/9Y0w8qZQXnljKT0F6I6noZB++nhcOXzceJl9ERDKmvfdP586aXq6YmOePzEzNvX84dMc4eFIpPzyxlB/2RspL9uHreeHwdePhNV9ERDL34r1/kpM1J5G8949x8doJ+eF1kfLD3kh50Q5f37lTM/mMvj8caYevd+rE3xRjYPJFRFRM+PnxZN6UeFIpPzyxlB/O0io/48Zphq5rJ0BxdNSdAOXBAw5fNyYOOyQiIjIAh7jJE6+LlBcOc5MfDl+XF/Z8ERERGYBD3ORJe2K5YIHmWruYGN3p/zt10iRePLE0DvZGyhOHr8sHky8iIiID8KRSvnhiKS8c5iZfHL5ueky+iIiIDMSTSnnjiaU8sDeSKHdMvoiIiAzEk0oiw7A3kkg/Jl9ERET5wJNKIsOxN5JIF5MvIiKiAuBJJRER5RenmiciIiIiIjICJl9ERERERERGwOSLiIiIiIjICJh8ERERERERGQGTLyIiIiIiIiNg8kVERERERGQETL6IiIiIiIiMgMkXERERERGRETD5IiIiIiIiMgIzUzeguBJFEQCQlJRk4pYAgiDg6dOnsLKyglLJfFoOGBN5YTzkhzGRH8ZEXhgP+WFM5EdOMdHmBNocITdMvgro6dOnAAAfHx8Tt4SIiIiIiOTg6dOncHBwyHW5QnxZekZ6CYKAf//9F3Z2dlAoFCZtS1JSEnx8fPDPP//A3t7epG0hDcZEXhgP+WFM5IcxkRfGQ34YE/mRU0xEUcTTp0/h5eWVZy8ce74KSKlUoly5cqZuhg57e3uTf/FIF2MiL4yH/DAm8sOYyAvjIT+MifzIJSZ59XhpccAqERERERGRETD5IiIiIiIiMgImXyWApaUlpk6dCktLS1M3hf7DmMgL4yE/jIn8MCbywnjID2MiP8UxJpxwg4iIiIiIyAjY80VERERERGQETL6IiIiIiIiMgMkXERERERGRETD5IiIiIiIiMgImXyXA0qVL4efnBysrKzRs2BCnTp0ydZNKpfDwcNSvXx92dnZwc3PD22+/jejoaFM3i7KZM2cOFAoFxowZY+qmlGp37txB37594ezsDGtra9SqVQt//vmnqZtVKqnVanz66afw9/eHtbU1AgICMHPmTHAuLuP5/fff8dZbb8HLywsKhQI///yzznJRFDFlyhR4enrC2toarVu3xrVr10zT2FIir5hkZmbi448/Rq1atWBjYwMvLy/0798f//77r+kaXMK9bB/JbujQoVAoFFi4cKHR2pdfTL6Kuc2bNyMsLAxTp05FVFQU6tSpg5CQECQkJJi6aaXOkSNHMHz4cJw4cQL79+9HZmYm2rZti5SUFFM3jQCcPn0aX3/9NWrXrm3qppRqjx8/RuPGjWFubo5ff/0Vly5dwvz581G2bFlTN61Umjt3LpYvX44lS5bg8uXLmDt3Lj7//HMsXrzY1E0rNVJSUlCnTh0sXbpU7/LPP/8cixYtwooVK3Dy5EnY2NggJCQEaWlpRm5p6ZFXTFJTUxEVFYVPP/0UUVFR2L59O6Kjo9GpUycTtLR0eNk+ovXTTz/hxIkT8PLyMlLLCkikYq1Bgwbi8OHDpedqtVr08vISw8PDTdgqEkVRTEhIEAGIR44cMXVTSr2nT5+KlSpVEvfv3y82b95cHD16tKmbVGp9/PHHYpMmTUzdDPpPhw4dxEGDBumUde3aVezTp4+JWlS6ARB/+ukn6bkgCKKHh4f4xRdfSGVPnjwRLS0txR9++MEELSx9XoyJPqdOnRIBiLdu3TJOo0qx3OJx+/Zt0dvbW7x48aLo6+srfvnll0Zvm6HY81WMZWRk4MyZM2jdurVUplQq0bp1a0RGRpqwZQQAiYmJAAAnJycTt4SGDx+ODh066OwrZBo7duxAUFAQevToATc3N9StWxfffvutqZtVajVq1AgRERG4evUqAOCvv/7CsWPH8Oabb5q4ZQQAsbGxuHfvns6xy8HBAQ0bNuTvvIwkJiZCoVDA0dHR1E0plQRBQL9+/TB+/HjUqFHD1M15KTNTN4AK7sGDB1Cr1XB3d9cpd3d3x5UrV0zUKgI0B4IxY8agcePGqFmzpqmbU6pt2rQJUVFROH36tKmbQgBu3LiB5cuXIywsDP/73/9w+vRpjBo1ChYWFhgwYICpm1fqTJw4EUlJSahatSpUKhXUajU+++wz9OnTx9RNIwD37t0DAL2/89plZFppaWn4+OOP8c4778De3t7UzSmV5s6dCzMzM4waNcrUTTEIky+iIjB8+HBcvHgRx44dM3VTSrV//vkHo0ePxv79+2FlZWXq5hA0f5gICgrC7NmzAQB169bFxYsXsWLFCiZfJrBlyxZs3LgR33//PWrUqIFz585hzJgx8PLyYjyIXiIzMxM9e/aEKIpYvny5qZtTKp05cwZfffUVoqKioFAoTN0cg3DYYTHm4uIClUqF+Ph4nfL4+Hh4eHiYqFU0YsQI7Nq1C4cOHUK5cuVM3ZxS7cyZM0hISMBrr70GMzMzmJmZ4ciRI1i0aBHMzMygVqtN3cRSx9PTE9WrV9cpq1atGuLi4kzUotJt/PjxmDhxInr37o1atWqhX79+GDt2LMLDw03dNAKk33L+zsuPNvG6desW9u/fz14vEzl69CgSEhJQvnx56Xf+1q1b+Oijj+Dn52fq5unF5KsYs7CwQL169RARESGVCYKAiIgIBAcHm7BlpZMoihgxYgR++uknHDx4EP7+/qZuUqnXqlUrXLhwAefOnZMeQUFB6NOnD86dOweVSmXqJpY6jRs3znELhqtXr8LX19dELSrdUlNToVTqngqoVCoIgmCiFlF2/v7+8PDw0PmdT0pKwsmTJ/k7b0LaxOvatWs4cOAAnJ2dTd2kUqtfv344f/68zu+8l5cXxo8fj3379pm6eXpx2GExFxYWhgEDBiAoKAgNGjTAwoULkZKSgtDQUFM3rdQZPnw4vv/+e/zyyy+ws7OTxuM7ODjA2traxK0rnezs7HJcc2djYwNnZ2dei2ciY8eORaNGjTB79mz07NkTp06dwjfffINvvvnG1E0rld566y189tlnKF++PGrUqIGzZ89iwYIFGDRokKmbVmokJyfj+vXr0vPY2FicO3cOTk5OKF++PMaMGYNZs2ahUqVK8Pf3x6effgovLy+8/fbbpmt0CZdXTDw9PdG9e3dERUVh165dUKvV0u+9k5MTLCwsTNXsEutl+8iLya+5uTk8PDxQpUoVYzfVMKaebpFe3eLFi8Xy5cuLFhYWYoMGDcQTJ06YukmlEgC9j9WrV5u6aZQNp5o3vZ07d4o1a9YULS0txapVq4rffPONqZtUaiUlJYmjR48Wy5cvL1pZWYkVKlQQJ0+eLKanp5u6aaXGoUOH9P52DBgwQBRFzXTzn376qeju7i5aWlqKrVq1EqOjo03b6BIur5jExsbm+nt/6NAhUze9RHrZPvIiuU81rxBF3saeiIiIiIioqPGaLyIiIiIiIiNg8kVERERERGQETL6IiIiIiIiMgMkXERERERGRETD5IiIiIiIiMgImX0REREREREbA5IuIiIiIiMgImHwREREREREZAZMvIiIqFaZNm4bAwMB8vUahUODnn38ukvaYYjtERGRaTL6IiKjYUSgUeT6mTZuW4zXjxo1DREREobZj4MCBePvttwt1nUREVHKZmboBRERE+XX37l3p/5s3b8aUKVMQHR0tldna2kr/F0URarUatra2OuVERETGxp4vIiIqdjw8PKSHg4MDFAqF9PzKlSuws7PDr7/+inr16sHS0hLHjh3LMezw9OnTaNOmDVxcXODg4IDmzZsjKirqldrVokULjBo1ChMmTICTkxM8PDxy9MJdu3YNzZo1g5WVFapXr479+/fnWM8///yDnj17wtHREU5OTujcuTNu3rwJALhy5QrKlCmD77//Xqq/ZcsWWFtb49KlS6/UfiIiKlpMvoiIqESaOHEi5syZg8uXL6N27do5lj99+hQDBgzAsWPHcOLECVSqVAnt27fH06dPX2m7a9euhY2NDU6ePInPP/8cM2bMkBIsQRDQtWtXWFhY4OTJk1ixYgU+/vhjnddnZmYiJCQEdnZ2OHr0KI4fPw5bW1u0a9cOGRkZqFq1KubNm4dhw4YhLi4Ot2/fxtChQzF37lxUr179ldpORERFi8MOiYioRJoxYwbatGmT6/I33nhD5/k333wDR0dHHDlyBB07dizwdmvXro2pU6cCACpVqoQlS5YgIiICbdq0wYEDB3DlyhXs27cPXl5eAIDZs2fjzTfflF6/efNmCIKAlStXQqFQAABWr14NR0dHHD58GG3btsWwYcOwZ88e9O3bFxYWFqhfvz5GjhxZ4DYTEZFxMPkiIqISKSgoKM/l8fHx+OSTT3D48GEkJCRArVYjNTUVcXFxr7TdF3vZPD09kZCQAAC4fPkyfHx8pMQLAIKDg3Xq//XXX7h+/Trs7Ox0ytPS0hATEyM9X7VqFSpXrgylUom///5bStSIiEi+mHwREVGJZGNjk+fyAQMG4OHDh/jqq6/g6+sLS0tLBAcHIyMj45W2a25urvNcoVBAEASDX5+cnIx69eph48aNOZa5urpK///rr7+QkpICpVKJu3fvwtPTs+CNJiIio2DyRUREpdLx48exbNkytG/fHoBmkosHDx4U6TarVauGf/75RydZOnHihE6d1157DZs3b4abmxvs7e31rufRo0cYOHAgJk+ejLt376JPnz6IioqCtbV1kbafiIheDSfcICKiUqlSpUpYv349Ll++jJMnT6JPnz5Fnry0bt0alStXxoABA/DXX3/h6NGjmDx5sk6dPn36wMXFBZ07d8bRo0cRGxuLw4cPY9SoUbh9+zYAYOjQofDx8cEnn3yCBQsWQK1WY9y4cUXadiIienVMvoiIqFT67rvv8PjxY7z22mvo168fRo0aBTc3tyLdplKpxE8//YRnz56hQYMGeO+99/DZZ5/p1ClTpgx+//13lC9fHl27dkW1atUwePBgpKWlwd7eHuvWrcOePXuwfv16mJmZwcbGBhs2bMC3336LX3/9tUjbT0REr0YhiqJo6kYQERERERGVdOz5IiIiIiIiMgImX0REREREREbA5IuIiIiIiMgImHwREREREREZAZMvIiIiIiIiI2DyRUREREREZARMvoiIiIiIiIyAyRcREREREZERMPkiIiIiIiIyAiZfRERERERERsDki4iIiIiIyAj+D5cdec4gBaiHAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -1023,7 +1018,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 23, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -1042,8 +1037,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", - "Standard benchmark on tricky kernel: 0.1880 ms\n" + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 100\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Standard benchmark on tricky kernel: 0.1530 ms\n" ] } ], @@ -1100,7 +1101,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 24, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -1119,8 +1120,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Robust benchmark on tricky kernel: 21.6298 ms\n", - "Robust benchmark on normal kernel: 21.5420 ms\n" + "Robust benchmark on tricky kernel: 21.5905 ms\n", + "Robust benchmark on normal kernel: 21.5177 ms\n" ] } ], @@ -1144,7 +1145,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 25, "metadata": { "execution": { "iopub.execute_input": "2025-12-17T21:24:52.832854Z", @@ -1161,19 +1162,19 @@ "Side-Stream Detection Experiment:\n", "============================================================\n", "[Profiling] Using timing method: cuda_event\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 10\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 100\n", "[Profiling] Using timing method: host_time\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 10\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 10\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 100\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 100\n", "\n", - "Tricky kernel with cuda_event: 0.4400 ms (FOOLED!)\n", - "Tricky kernel with host_time: 21.8000 ms (CORRECT)\n", + "Tricky kernel with cuda_event: 0.1310 ms (FOOLED!)\n", + "Tricky kernel with host_time: 21.6000 ms (CORRECT)\n", "Normal kernel with host_time: 21.5000 ms (reference)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1252,7 +1253,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 26, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -1272,8 +1273,8 @@ "output_type": "stream", "text": [ "✓ Correctness verified!\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", - "Kernel time: 0.0648 ms\n" + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 100\n", + "Kernel time: 0.0646 ms\n" ] } ], @@ -1405,7 +1406,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.9" + "version": "3.10.16" } }, "nbformat": 4, From c79621f6be44bf500c6c1e68c13575666003ef55 Mon Sep 17 00:00:00 2001 From: Julian Reed Date: Tue, 24 Mar 2026 04:29:00 +0000 Subject: [PATCH 24/24] Apply Sahan's suggestions --- notebooks/benchmarking.ipynb | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/notebooks/benchmarking.ipynb b/notebooks/benchmarking.ipynb index 3469c004..3b66e8f5 100644 --- a/notebooks/benchmarking.ipynb +++ b/notebooks/benchmarking.ipynb @@ -18,8 +18,6 @@ "source": [ "# A Practical Guide to GPU Benchmarking\n", "\n", - "> **Note on outputs:** The outputs in this notebook were generated on an **NVIDIA H200 GPU** (90MB L2 cache, 4.8 TB/s memory bandwidth). Your results will vary depending on your hardware. The H200's large cache means cache effects are less dramatic than on older GPUs like A100 (40MB L2) or consumer cards.\n", - "\n", "## TL;DR — How to Benchmark Correctly\n", "\n", "Benchmarking on GPUs requires a strict protocol to avoid measuring Python overhead or caching artifacts. To get reliable numbers, you must:\n", @@ -29,10 +27,12 @@ "3. **Flush the L2 Cache:** Between *every* sample, flush the cache to force a cold cache state (simulating real-world inference).\n", "4. **Use Device Timers:** Use `torch.cuda.Event` instead of `time.time()` to measure execution on the GPU, not the CPU driver.\n", "5. **Aggregate Robustly:** Use median to filter out jitter and outliers.\n", - "6. **Wait for side-streams:** Ensure all CUDA streams finish before stopping the clock. (Launching work in another stream is a very common reward hack, so waiting for all streams is essential for evaluating LLM-generated code.)\n", + "6. **Wait for side-streams:** Ensure all CUDA streams finish before stopping the clock. (Launching work in another stream is a very common reward hack, so waiting for all streams is essential for evaluating LLM-generated code. If you aren't using a LLM to generate your kernel, this almost certainly isn't something you need to worry about.)\n", "\n", "*Pro-Tip:* Off-the-shelf solutions like [Triton's do_bench](https://triton-lang.org/main/python-api/generated/triton.testing.do_bench.html) handle most of this. KernelBench also provides a [timing module](https://github.com/ScalingIntelligence/KernelBench/blob/main/src/kernelbench/timing.py) implementing these best practices.\n", "\n", + "> **Note on outputs:** The outputs in this notebook were generated on an **NVIDIA H200 GPU** (90MB L2 cache, 4.8 TB/s memory bandwidth). Your results will vary depending on your hardware. The H200's large cache means cache effects are less dramatic than on older GPUs like A100 (40MB L2) or consumer cards.\n", + "\n", "-----\n", "\n", "Whether you're using an LLM to write GPU kernels or hand-optimizing CUDA, you'll eventually ask: **\"How fast is this thing?\"**\n", @@ -630,7 +630,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "You might notice the warm cache's spike on runs 4/5, which can happen due to deferred optimization or other OS noise. This is another reason why you care more about cold cache performance: these spikes are much less likely to occur when processing fresh data each time." + "You might notice the warm cache's occasional spikes on certain runs, which can happen due to deferred optimization or other OS noise. This is another reason why you care more about cold cache performance: these spikes are much less likely to occur when processing fresh data each time." ] }, { @@ -1310,7 +1310,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Fully ensuring kernel correctness is actually a fairly complex problem. KernelBench checks the output of generated code on random inputs against the output from the baseline and ensures they match. However, what \"match\" means is up for debate. Since floating point operations are non-associative, it is possible for two correct kernels to produce marginally different outputs. This margin should depend on the data type: lower precision leads to more rounding errors, meaning that you should probably have a wider margin of error. As a result of non-associativity and many similar factors, kernel correctness is not binary.\n", + "Fully ensuring kernel correctness is complex due to a range of factors (quantization being the most notable), meaning that \"matching\" a baseline isn't always binary. To avoid false negatives, one approach is to scale your error margins based on data precision. as lower precision typically requires a wider tolerance (this is a technique we use at KernelBench).\n", "\n", "For an in-depth discussion of this topic, see [Towards a Reliable Kernel Correctness Check in Matrix Multiplication](https://deep-reinforce.com/correctness_check.html)" ]