triton_forward_backward.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "!pip install triton\n",
        "!pip install torch"
      ],
      "metadata": {
        "id": "PCcpCakAkZkB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "150b0706-3910-4d53-8165-34bbbd722fbe"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: triton in /usr/local/lib/python3.11/dist-packages (3.2.0)\n",
            "Requirement already satisfied: torch in /usr/local/lib/python3.11/dist-packages (2.6.0+cu124)\n",
            "Requirement already satisfied: filelock in /usr/local/lib/python3.11/dist-packages (from torch) (3.17.0)\n",
            "Requirement already satisfied: typing-extensions>=4.10.0 in /usr/local/lib/python3.11/dist-packages (from torch) (4.12.2)\n",
            "Requirement already satisfied: networkx in /usr/local/lib/python3.11/dist-packages (from torch) (3.4.2)\n",
            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.11/dist-packages (from torch) (3.1.6)\n",
            "Requirement already satisfied: fsspec in /usr/local/lib/python3.11/dist-packages (from torch) (2024.10.0)\n",
            "Collecting nvidia-cuda-nvrtc-cu12==12.4.127 (from torch)\n",
            "  Downloading nvidia_cuda_nvrtc_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n",
            "Collecting nvidia-cuda-runtime-cu12==12.4.127 (from torch)\n",
            "  Downloading nvidia_cuda_runtime_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n",
            "Collecting nvidia-cuda-cupti-cu12==12.4.127 (from torch)\n",
            "  Downloading nvidia_cuda_cupti_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)\n",
            "Collecting nvidia-cudnn-cu12==9.1.0.70 (from torch)\n",
            "  Downloading nvidia_cudnn_cu12-9.1.0.70-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)\n",
            "Collecting nvidia-cublas-cu12==12.4.5.8 (from torch)\n",
            "  Downloading nvidia_cublas_cu12-12.4.5.8-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n",
            "Collecting nvidia-cufft-cu12==11.2.1.3 (from torch)\n",
            "  Downloading nvidia_cufft_cu12-11.2.1.3-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n",
            "Collecting nvidia-curand-cu12==10.3.5.147 (from torch)\n",
            "  Downloading nvidia_curand_cu12-10.3.5.147-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n",
            "Collecting nvidia-cusolver-cu12==11.6.1.9 (from torch)\n",
            "  Downloading nvidia_cusolver_cu12-11.6.1.9-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)\n",
            "Collecting nvidia-cusparse-cu12==12.3.1.170 (from torch)\n",
            "  Downloading nvidia_cusparse_cu12-12.3.1.170-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)\n",
            "Requirement already satisfied: nvidia-cusparselt-cu12==0.6.2 in /usr/local/lib/python3.11/dist-packages (from torch) (0.6.2)\n",
            "Requirement already satisfied: nvidia-nccl-cu12==2.21.5 in /usr/local/lib/python3.11/dist-packages (from torch) (2.21.5)\n",
            "Requirement already satisfied: nvidia-nvtx-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch) (12.4.127)\n",
            "Collecting nvidia-nvjitlink-cu12==12.4.127 (from torch)\n",
            "  Downloading nvidia_nvjitlink_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n",
            "Requirement already satisfied: triton==3.2.0 in /usr/local/lib/python3.11/dist-packages (from torch) (3.2.0)\n",
            "Requirement already satisfied: sympy==1.13.1 in /usr/local/lib/python3.11/dist-packages (from torch) (1.13.1)\n",
            "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.11/dist-packages (from sympy==1.13.1->torch) (1.3.0)\n",
            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.11/dist-packages (from jinja2->torch) (3.0.2)\n",
            "Downloading nvidia_cublas_cu12-12.4.5.8-py3-none-manylinux2014_x86_64.whl (363.4 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m363.4/363.4 MB\u001b[0m \u001b[31m3.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading nvidia_cuda_cupti_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (13.8 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.8/13.8 MB\u001b[0m \u001b[31m68.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading nvidia_cuda_nvrtc_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (24.6 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m24.6/24.6 MB\u001b[0m \u001b[31m45.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading nvidia_cuda_runtime_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (883 kB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m883.7/883.7 kB\u001b[0m \u001b[31m30.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading nvidia_cudnn_cu12-9.1.0.70-py3-none-manylinux2014_x86_64.whl (664.8 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m664.8/664.8 MB\u001b[0m \u001b[31m2.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading nvidia_cufft_cu12-11.2.1.3-py3-none-manylinux2014_x86_64.whl (211.5 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m211.5/211.5 MB\u001b[0m \u001b[31m6.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading nvidia_curand_cu12-10.3.5.147-py3-none-manylinux2014_x86_64.whl (56.3 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m56.3/56.3 MB\u001b[0m \u001b[31m16.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading nvidia_cusolver_cu12-11.6.1.9-py3-none-manylinux2014_x86_64.whl (127.9 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m127.9/127.9 MB\u001b[0m \u001b[31m7.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading nvidia_cusparse_cu12-12.3.1.170-py3-none-manylinux2014_x86_64.whl (207.5 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m207.5/207.5 MB\u001b[0m \u001b[31m5.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading nvidia_nvjitlink_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (21.1 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m21.1/21.1 MB\u001b[0m \u001b[31m93.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hInstalling collected packages: nvidia-nvjitlink-cu12, nvidia-curand-cu12, nvidia-cufft-cu12, nvidia-cuda-runtime-cu12, nvidia-cuda-nvrtc-cu12, nvidia-cuda-cupti-cu12, nvidia-cublas-cu12, nvidia-cusparse-cu12, nvidia-cudnn-cu12, nvidia-cusolver-cu12\n",
            "  Attempting uninstall: nvidia-nvjitlink-cu12\n",
            "    Found existing installation: nvidia-nvjitlink-cu12 12.5.82\n",
            "    Uninstalling nvidia-nvjitlink-cu12-12.5.82:\n",
            "      Successfully uninstalled nvidia-nvjitlink-cu12-12.5.82\n",
            "  Attempting uninstall: nvidia-curand-cu12\n",
            "    Found existing installation: nvidia-curand-cu12 10.3.6.82\n",
            "    Uninstalling nvidia-curand-cu12-10.3.6.82:\n",
            "      Successfully uninstalled nvidia-curand-cu12-10.3.6.82\n",
            "  Attempting uninstall: nvidia-cufft-cu12\n",
            "    Found existing installation: nvidia-cufft-cu12 11.2.3.61\n",
            "    Uninstalling nvidia-cufft-cu12-11.2.3.61:\n",
            "      Successfully uninstalled nvidia-cufft-cu12-11.2.3.61\n",
            "  Attempting uninstall: nvidia-cuda-runtime-cu12\n",
            "    Found existing installation: nvidia-cuda-runtime-cu12 12.5.82\n",
            "    Uninstalling nvidia-cuda-runtime-cu12-12.5.82:\n",
            "      Successfully uninstalled nvidia-cuda-runtime-cu12-12.5.82\n",
            "  Attempting uninstall: nvidia-cuda-nvrtc-cu12\n",
            "    Found existing installation: nvidia-cuda-nvrtc-cu12 12.5.82\n",
            "    Uninstalling nvidia-cuda-nvrtc-cu12-12.5.82:\n",
            "      Successfully uninstalled nvidia-cuda-nvrtc-cu12-12.5.82\n",
            "  Attempting uninstall: nvidia-cuda-cupti-cu12\n",
            "    Found existing installation: nvidia-cuda-cupti-cu12 12.5.82\n",
            "    Uninstalling nvidia-cuda-cupti-cu12-12.5.82:\n",
            "      Successfully uninstalled nvidia-cuda-cupti-cu12-12.5.82\n",
            "  Attempting uninstall: nvidia-cublas-cu12\n",
            "    Found existing installation: nvidia-cublas-cu12 12.5.3.2\n",
            "    Uninstalling nvidia-cublas-cu12-12.5.3.2:\n",
            "      Successfully uninstalled nvidia-cublas-cu12-12.5.3.2\n",
            "  Attempting uninstall: nvidia-cusparse-cu12\n",
            "    Found existing installation: nvidia-cusparse-cu12 12.5.1.3\n",
            "    Uninstalling nvidia-cusparse-cu12-12.5.1.3:\n",
            "      Successfully uninstalled nvidia-cusparse-cu12-12.5.1.3\n",
            "  Attempting uninstall: nvidia-cudnn-cu12\n",
            "    Found existing installation: nvidia-cudnn-cu12 9.3.0.75\n",
            "    Uninstalling nvidia-cudnn-cu12-9.3.0.75:\n",
            "      Successfully uninstalled nvidia-cudnn-cu12-9.3.0.75\n",
            "  Attempting uninstall: nvidia-cusolver-cu12\n",
            "    Found existing installation: nvidia-cusolver-cu12 11.6.3.83\n",
            "    Uninstalling nvidia-cusolver-cu12-11.6.3.83:\n",
            "      Successfully uninstalled nvidia-cusolver-cu12-11.6.3.83\n",
            "Successfully installed nvidia-cublas-cu12-12.4.5.8 nvidia-cuda-cupti-cu12-12.4.127 nvidia-cuda-nvrtc-cu12-12.4.127 nvidia-cuda-runtime-cu12-12.4.127 nvidia-cudnn-cu12-9.1.0.70 nvidia-cufft-cu12-11.2.1.3 nvidia-curand-cu12-10.3.5.147 nvidia-cusolver-cu12-11.6.1.9 nvidia-cusparse-cu12-12.3.1.170 nvidia-nvjitlink-cu12-12.4.127\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "\n",
        "import triton\n",
        "import triton.language as tl\n",
        "\n",
        "from typing import List, Tuple"
      ],
      "metadata": {
        "id": "KJxHBJ66w7kY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "@triton.jit\n",
        "def forward_kernel(input_ptr, input_low_ptr, input_range_ptr, output_ptr, levels: int, n_elements:int, BLOCK_SIZE: tl.constexpr):\n",
        "    pid = tl.program_id(axis=0)\n",
        "    block_start = pid * BLOCK_SIZE\n",
        "    offsets = block_start + tl.arange(0, BLOCK_SIZE)\n",
        "    mask = offsets < n_elements\n",
        "\n",
        "    input_ = tl.load(input_ptr + offsets, mask=mask)\n",
        "    input_low = tl.load(input_low_ptr + offsets, mask=mask)\n",
        "    input_range = tl.load(input_range_ptr + offsets, mask=mask)\n",
        "\n",
        "    scale = (levels - 1) / input_range\n",
        "    zero_point = -1 * input_low * scale\n",
        "\n",
        "    input_max = input_low + input_range\n",
        "    output = tl.clamp(input_, input_low, input_max)\n",
        "    output -= input_low\n",
        "    output *= scale\n",
        "    output -= zero_point\n",
        "    output = output / scale\n",
        "    tl.store(output_ptr + offsets, output, mask=mask)\n",
        "\n",
        "\n",
        "def forward_triton(\n",
        "    input_: torch.Tensor, input_low: torch.Tensor, input_range: torch.Tensor, levels: int\n",
        ") -> torch.Tensor:\n",
        "    output = torch.empty_like(input_)\n",
        "    n_elements = output.numel()\n",
        "    BLOCK_SIZE = n_elements\n",
        "    grid = lambda meta: (triton.cdiv(n_elements, meta['BLOCK_SIZE']), )\n",
        "    forward_kernel[grid](input_, input_low, input_range, output, levels, n_elements, BLOCK_SIZE=1024)\n",
        "    return output\n",
        "\n",
        "\n",
        "def forward(\n",
        "    input_: torch.Tensor, input_low: torch.Tensor, input_range: torch.Tensor, levels: int\n",
        ") -> torch.Tensor:\n",
        "    scale = (levels - 1) / input_range\n",
        "    output = input_.clip(min=input_low, max=input_low + input_range)\n",
        "    zero_point = (-input_low * scale)\n",
        "    output -= input_low\n",
        "    output *= scale\n",
        "    output -= zero_point\n",
        "    output = output / scale\n",
        "    return output\n"
      ],
      "metadata": {
        "id": "QUCduYYIJas7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# https://triton-lang.org/main/getting-started/tutorials/01-vector-add.html\n",
        "\n",
        "@triton.testing.perf_report(\n",
        "    triton.testing.Benchmark(\n",
        "        x_names=['size'],\n",
        "        x_vals=[2**i for i in range(12, 28, 1)],\n",
        "        x_log=True,\n",
        "        line_arg='provider',\n",
        "        line_vals=['triton', 'torch'],\n",
        "        line_names=['Triton', 'Torch'],\n",
        "        styles=[('blue', '-'), ('green', '-')],\n",
        "        ylabel='GB/s',\n",
        "        plot_name='vector-add-performance',\n",
        "        args={},\n",
        "    ))\n",
        "def benchmark(size, provider):\n",
        "    input = torch.rand(size, device='cuda', dtype=torch.float32)\n",
        "    input_low = torch.rand(size, device='cuda', dtype=torch.float32)\n",
        "    input_range = torch.rand(size, device='cuda', dtype=torch.float32)\n",
        "    levels = 10\n",
        "    quantiles = [0.5, 0.2, 0.8]\n",
        "    if provider == 'torch':\n",
        "        ms, min_ms, max_ms = triton.testing.do_bench(lambda: forward(input, input_low, input_range, levels), quantiles=quantiles)\n",
        "    if provider == 'triton':\n",
        "        ms, min_ms, max_ms = triton.testing.do_bench(lambda: forward_triton(input, input_low, input_range, levels), quantiles=quantiles)\n",
        "    gbps = lambda ms: 3 * input.numel() * input.element_size() * 1e-9 / (ms * 1e-3)\n",
        "    return gbps(ms), gbps(max_ms), gbps(min_ms)\n",
        "\n",
        "\n",
        "benchmark.run(print_data=True, show_plots=True)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 772
        },
        "id": "HcF3s6AdkmeT",
        "outputId": "181761dd-0cee-46cd-e62f-5d599426294a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "vector-add-performance:\n",
            "           size      Triton      Torch\n",
            "0        4096.0    6.508474   1.200000\n",
            "1        8192.0   12.590164   4.079681\n",
            "2       16384.0   31.999999   8.545202\n",
            "3       32768.0   59.219275  15.999999\n",
            "4       65536.0   86.840989  26.800436\n",
            "5      131072.0  116.473930  45.322269\n",
            "6      262144.0  141.038735  38.072810\n",
            "7      524288.0  161.684218  31.916881\n",
            "8     1048576.0  170.666661  24.692520\n",
            "9     2097152.0  177.044581  25.283950\n",
            "10    4194304.0  180.768180  25.786770\n",
            "11    8388608.0  182.715884  25.896733\n",
            "12   16777216.0  184.781963  26.126007\n",
            "13   33554432.0  185.886132  26.086035\n",
            "14   67108864.0  186.753815  26.149680\n",
            "15  134217728.0  187.391426  26.217827\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def fp32_accum_wrapper(func):\n",
        "    def wrapper(tensor_to_sum, ret_tensor):\n",
        "        half = tensor_to_sum.dtype == np.float16\n",
        "        if half:\n",
        "            tensor_to_sum = tensor_to_sum.astype(np.float32)\n",
        "        retval = func(tensor_to_sum, ret_tensor)\n",
        "        if half:\n",
        "            retval = retval.astype(np.float16)\n",
        "        return retval\n",
        "\n",
        "    return wrapper\n",
        "\n",
        "\n",
        "@fp32_accum_wrapper\n",
        "def sum_like(tensor_to_sum, ref_tensor):\n",
        "    \"\"\"Warning: may modify tensor_to_sum\"\"\"\n",
        "    if ref_tensor.size == 1:\n",
        "        return tensor_to_sum.sum()\n",
        "\n",
        "    for dim, size in enumerate(ref_tensor.shape):\n",
        "        if size == 1:\n",
        "            if isinstance(tensor_to_sum, np.ndarray):\n",
        "                tensor_to_sum = tensor_to_sum.sum(dim, keepdims=True)\n",
        "            else:\n",
        "                tensor_to_sum = tensor_to_sum.sum(dim, keepdim=True)\n",
        "    return tensor_to_sum"
      ],
      "metadata": {
        "id": "zrByLHGhIrEa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "@triton.jit\n",
        "def backward_kernel(\n",
        "    grad_output_ptr: torch.Tensor,\n",
        "    input_ptr: torch.Tensor,\n",
        "    input_low_ptr: torch.Tensor,\n",
        "    input_range_ptr: torch.Tensor,\n",
        "    output_ptr: torch.Tensor,\n",
        "    grad_input_ptr: torch.Tensor,\n",
        "    grad_low_ptr: torch.Tensor,\n",
        "    grad_range_ptr: torch.Tensor,\n",
        "    mask_lo_ptr: torch.Tensor,\n",
        "    mask_hi_ptr: torch.Tensor,\n",
        "    range_sign_ptr: torch.Tensor,\n",
        "    level_low: int,\n",
        "    level_high: int,\n",
        "    n_elements: int,\n",
        "    is_asymmetric,\n",
        "    BLOCK_SIZE: tl.constexpr\n",
        ") -> List[torch.Tensor]:\n",
        "    # is_asymmetric is unused, present only to correspond to the CPU signature of calling \"backward\"\n",
        "    # sum_like not implemented yet\n",
        "\n",
        "\n",
        "\n",
        "    pid = tl.program_id(axis=0)\n",
        "    block_start = pid * BLOCK_SIZE\n",
        "    offsets = block_start + tl.arange(0, BLOCK_SIZE)\n",
        "    mask = offsets < n_elements\n",
        "\n",
        "    grad_output = tl.load(grad_output_ptr + offsets, mask=mask)\n",
        "    input_ = tl.load(input_ptr + offsets, mask=mask)\n",
        "    input_low = tl.load(input_low_ptr + offsets, mask=mask)\n",
        "    input_range = tl.load(input_range_ptr + offsets, mask=mask)\n",
        "    output = tl.load(output_ptr + offsets, mask=mask)\n",
        "\n",
        "    mask_lo = tl.load(mask_lo_ptr + offsets, mask=mask)\n",
        "    mask_hi = tl.load(mask_hi_ptr + offsets, mask=mask)\n",
        "    range_sign = tl.load(range_sign_ptr + offsets, mask=mask)\n",
        "\n",
        "    mask_in = 1 - mask_hi - mask_lo\n",
        "\n",
        "    err = (output - input_) / (input_range * range_sign)\n",
        "    grad_range = grad_output * (err * mask_in + range_sign * (level_low / level_high) * mask_lo + mask_hi)\n",
        "\n",
        "    grad_input = grad_output * mask_in\n",
        "\n",
        "    grad_low = grad_output * (mask_hi + mask_lo)\n",
        "\n",
        "\n",
        "    tl.store(grad_input_ptr + offsets, grad_input, mask=mask)\n",
        "    tl.store(grad_low_ptr + offsets, grad_low, mask=mask)\n",
        "    tl.store(grad_range_ptr + offsets, grad_range, mask=mask)\n",
        "\n",
        "\n",
        "def backward_triton(\n",
        "    grad_output: torch.Tensor,\n",
        "    input_: torch.Tensor,\n",
        "    input_low: torch.Tensor,\n",
        "    input_range: torch.Tensor,\n",
        "    output: torch.Tensor,\n",
        "    level_low: int,\n",
        "    level_high: int,\n",
        "    is_asymmetric: bool = False,\n",
        ") -> List[torch.Tensor]:\n",
        "\n",
        "    mask_hi = input_ > (input_low + input_range)\n",
        "    mask_lo = input_ < input_low\n",
        "    mask_hi = mask_hi.type(input_.dtype)\n",
        "    mask_lo = mask_lo.type(input_.dtype)\n",
        "    range_sign = torch.sign(input_range)\n",
        "\n",
        "    grad_input = torch.empty_like(input_)\n",
        "    grad_low = torch.empty_like(input_)\n",
        "    grad_range = torch.empty_like(input_)\n",
        "\n",
        "    n_elements = input_.numel()\n",
        "    # how to pass this tuple to kernel, can use pointer and n_dims maybe\n",
        "    # input_shape = input_.shape\n",
        "    BLOCK_SIZE = n_elements\n",
        "    grid = lambda meta: (triton.cdiv(n_elements, meta['BLOCK_SIZE']), )\n",
        "    backward_kernel[grid](grad_output, input_, input_low, input_range, output, grad_input, grad_low, grad_range, mask_lo, mask_hi, range_sign, level_low, level_high, n_elements, is_asymmetric=False, BLOCK_SIZE=1024)\n",
        "    return [grad_input, grad_low, grad_range]\n",
        "\n",
        "def backward(\n",
        "    grad_output: torch.Tensor,\n",
        "    input_: torch.Tensor,\n",
        "    input_low: torch.Tensor,\n",
        "    input_range: torch.Tensor,\n",
        "    output: torch.Tensor,\n",
        "    level_low: int,\n",
        "    level_high: int,\n",
        "    is_asymmetric: bool = False,\n",
        ") -> List[torch.Tensor]:\n",
        "    # is_asymmetric is unused, present only to correspond to the CPU signature of calling \"backward\"\n",
        "    mask_hi = input_ > (input_low + input_range)\n",
        "    mask_hi = mask_hi.type(input_.dtype)\n",
        "    mask_lo = input_ < input_low\n",
        "    mask_lo = mask_lo.type(input_.dtype)\n",
        "\n",
        "    mask_in = 1 - mask_hi - mask_lo\n",
        "    range_sign = torch.sign(input_range)\n",
        "    err = (output - input_) * torch.reciprocal(input_range * range_sign)\n",
        "    grad_range = grad_output * (err * mask_in + range_sign * (level_low / level_high) * mask_lo + mask_hi)\n",
        "    grad_range = sum_like(grad_range, input_range)\n",
        "\n",
        "    grad_input = grad_output * mask_in\n",
        "\n",
        "    grad_low = grad_output * (mask_hi + mask_lo)\n",
        "    grad_low = sum_like(grad_low, input_low)\n",
        "    return [grad_input, grad_low, grad_range]\n"
      ],
      "metadata": {
        "id": "WGncCXjb271h"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "CZzWt9MhZG7u"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "torch.manual_seed(1000)\n",
        "size = 5000\n",
        "grad_output = torch.rand(size, device='cuda')\n",
        "input_ = torch.rand(size, device='cuda')\n",
        "input_low = torch.rand(size, device='cuda')\n",
        "input_range = torch.rand(size, device='cuda')\n",
        "output = torch.rand(size, device='cuda')\n",
        "level_low = 10\n",
        "level_high = 50\n",
        "is_asymmetric = False\n",
        "\n",
        "grad_input_torch, grad_low_torch, grad_range_torch = backward(grad_output, input_, input_low, input_range, output, level_low, level_high, is_asymmetric)\n",
        "grad_input_triton, grad_low_triton, grad_range_triton = backward_triton(grad_output, input_, input_low, input_range, output, level_low, level_high, is_asymmetric)\n",
        "print(f'the maximum difference between torch and triton is '\n",
        "      f'{torch.max(torch.abs(grad_input_torch - grad_range_triton)), torch.max(torch.abs(grad_low_torch - grad_low_triton)), torch.max(torch.abs(grad_range_torch - grad_range_triton))}')\n",
        "print(torch.allclose(grad_input_torch, grad_range_triton), torch.allclose(grad_low_torch, grad_low_triton), torch.allclose(grad_range_torch, grad_range_triton))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MLuBrF4VK4Yo",
        "outputId": "1520e1a4-7751-4dcd-edc2-2bba6a487e0f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "the maximum difference between torch and triton is (tensor(13.4639, device='cuda:0'), tensor(0., device='cuda:0'), tensor(4.7684e-07, device='cuda:0'))\n",
            "False True True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# https://triton-lang.org/main/getting-started/tutorials/01-vector-add.html\n",
        "\n",
        "@triton.testing.perf_report(\n",
        "    triton.testing.Benchmark(\n",
        "        x_names=['size'],\n",
        "        x_vals=[2**i for i in range(12, 28, 1)],\n",
        "        x_log=True,\n",
        "        line_arg='provider',\n",
        "        line_vals=['triton', 'torch'],\n",
        "        line_names=['Triton', 'Torch'],\n",
        "        styles=[('blue', '-'), ('green', '-')],\n",
        "        ylabel='GB/s',\n",
        "        plot_name='vector-add-performance',\n",
        "        args={},\n",
        "    ))\n",
        "def benchmark(size, provider):\n",
        "    grad_output = torch.rand(size, device='cuda', dtype=torch.float32)\n",
        "    input_ = torch.rand(size, device='cuda', dtype=torch.float32)\n",
        "    input_low = torch.rand(size, device='cuda', dtype=torch.float32)\n",
        "    input_range = torch.rand(size, device='cuda', dtype=torch.float32)\n",
        "    output = torch.rand(size, device='cuda', dtype=torch.float32)\n",
        "    level_low = 10\n",
        "    level_high = 50\n",
        "    is_asymmetric = False\n",
        "    input = torch.rand(size, device='cuda', dtype=torch.float32)\n",
        "    input_low = torch.rand(size, device='cuda', dtype=torch.float32)\n",
        "    input_range = torch.rand(size, device='cuda', dtype=torch.float32)\n",
        "    levels = 10\n",
        "    quantiles = [0.5, 0.2, 0.8]\n",
        "    if provider == 'torch':\n",
        "        ms, min_ms, max_ms = triton.testing.do_bench(lambda: backward(grad_output, input_, input_low, input_range, output, level_low, level_high, is_asymmetric), quantiles=quantiles)\n",
        "    if provider == 'triton':\n",
        "        ms, min_ms, max_ms = triton.testing.do_bench(lambda: backward_triton(grad_output, input_, input_low, input_range, output, level_low, level_high, is_asymmetric), quantiles=quantiles)\n",
        "    gbps = lambda ms: 3 * input.numel() * input.element_size() * 1e-9 / (ms * 1e-3)\n",
        "    return gbps(ms), gbps(max_ms), gbps(min_ms)\n",
        "\n",
        "\n",
        "benchmark.run(print_data=True, show_plots=True)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 767
        },
        "outputId": "4f17bcec-c0db-4340-8ac3-ba3880019974",
        "id": "AHrTos2sZEjN"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "vector-add-performance:\n",
            "           size     Triton      Torch\n",
            "0        4096.0   1.268373   0.557937\n",
            "1        8192.0   3.719128   1.700055\n",
            "2       16384.0   9.061947   4.363636\n",
            "3       32768.0  16.362183   7.937984\n",
            "4       65536.0  28.313365  13.649542\n",
            "5      131072.0  42.778067  21.342596\n",
            "6      262144.0  36.368478  18.211189\n",
            "7      524288.0  31.346940  15.022005\n",
            "8     1048576.0  31.374452  12.769241\n",
            "9     2097152.0  32.083550  13.045019\n",
            "10    4194304.0  32.594165  13.277203\n",
            "11    8388608.0  32.790886  13.384368\n",
            "12   16777216.0  32.909408  13.423290\n",
            "13   33554432.0  32.845752  13.453703\n",
            "14   67108864.0  32.985153  13.481379\n",
            "15  134217728.0  33.047561  13.506892\n"
          ]
        }
      ]
    }
  ]
}