{ "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": [ "# Check that a Tesla T4 is connected\n", "!nvidia-smi\n", "\n", "# Install or upgrade Triton and PyTorch\n", "!pip install --upgrade torch triton\n", "\n", "\n", "import torch\n", "from scipy.sparse import random\n", "import numpy as np\n", "\n", "# Import the Triton components we defined earlier\n", "import triton\n", "import triton.language as tl" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 2512 }, "id": "rwvTr0EkChRq", "outputId": "18710eec-772e-4854-ae66-535cbad8d050" }, "execution_count": 1, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Tue Sep 15 03:10:24 2026 \n", "+-----------------------------------------------------------------------------------------+\n", "| NVIDIA-SMI 580.82.07 Driver Version: 580.82.07 CUDA Version: 13.0 |\n", "+-----------------------------------------+------------------------+----------------------+\n", "| GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC |\n", "| Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. |\n", "| | | MIG M. |\n", "|=========================================+========================+======================|\n", "| 0 Tesla T4 Off | 00000000:00:04.0 Off | 0 |\n", "| N/A 43C P8 9W / 70W | 0MiB / 15360MiB | 0% Default |\n", "| | | N/A |\n", "+-----------------------------------------+------------------------+----------------------+\n", "\n", "+-----------------------------------------------------------------------------------------+\n", "| Processes: |\n", "| GPU GI CI PID Type Process name GPU Memory |\n", "| ID ID Usage |\n", "|=========================================================================================|\n", "| No running processes found |\n", "+-----------------------------------------------------------------------------------------+\n", "Requirement already satisfied: torch in /usr/local/lib/python3.13/dist-packages (2.11.0+cu128)\n", "Collecting torch\n", " Downloading torch-2.14.0-cp313-cp313-manylinux_2_28_x86_64.whl.metadata (37 kB)\n", "Requirement already satisfied: triton in /usr/local/lib/python3.13/dist-packages (3.6.0)\n", "Collecting triton\n", " Downloading triton-3.8.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl.metadata (978 bytes)\n", "Requirement already satisfied: filelock in /usr/local/lib/python3.13/dist-packages (from torch) (3.32.5)\n", "Requirement already satisfied: typing-extensions>=4.10.0 in /usr/local/lib/python3.13/dist-packages (from torch) (4.16.0)\n", "Requirement already satisfied: setuptools>=77.0.3 in /usr/local/lib/python3.13/dist-packages (from torch) (80.10.2)\n", "Requirement already satisfied: sympy>=1.13.3 in /usr/local/lib/python3.13/dist-packages (from torch) (1.14.0)\n", "Requirement already satisfied: networkx>=2.5.1 in /usr/local/lib/python3.13/dist-packages (from torch) (3.6.1)\n", "Requirement already satisfied: jinja2 in /usr/local/lib/python3.13/dist-packages (from torch) (3.1.6)\n", "Requirement already satisfied: fsspec>=0.8.5 in /usr/local/lib/python3.13/dist-packages (from torch) (2025.12.0)\n", "Collecting cuda-toolkit==13.0.3 (from cuda-toolkit[cublas,cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==13.0.3; platform_system == \"Linux\"->torch)\n", " Downloading cuda_toolkit-13.0.3.0-py2.py3-none-any.whl.metadata (17 kB)\n", "Collecting cuda-bindings<14,>=13.0.3 (from torch)\n", " Downloading cuda_bindings-13.4.1-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl.metadata (2.4 kB)\n", "Collecting nvidia-cudnn-cu13==9.24.0.43 (from torch)\n", " Downloading nvidia_cudnn_cu13-9.24.0.43-py3-none-manylinux_2_27_x86_64.whl.metadata (1.9 kB)\n", "Collecting nvidia-cusparselt-cu13==0.8.1 (from torch)\n", " Downloading nvidia_cusparselt_cu13-0.8.1-py3-none-manylinux2014_x86_64.whl.metadata (12 kB)\n", "Collecting nvidia-nccl-cu13==2.30.7 (from torch)\n", " Downloading nvidia_nccl_cu13-2.30.7-py3-none-manylinux_2_18_x86_64.whl.metadata (2.1 kB)\n", "Collecting nvidia-nvshmem-cu13==3.4.5 (from torch)\n", " Downloading nvidia_nvshmem_cu13-3.4.5-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl.metadata (2.1 kB)\n", "Collecting nvidia-cublas==13.1.1.3.* (from cuda-toolkit[cublas,cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==13.0.3; platform_system == \"Linux\"->torch)\n", " Downloading nvidia_cublas-13.1.1.3-py3-none-manylinux_2_27_x86_64.whl.metadata (1.8 kB)\n", "Collecting nvidia-cuda-nvrtc==13.0.88.* (from cuda-toolkit[cublas,cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==13.0.3; platform_system == \"Linux\"->torch)\n", " Downloading nvidia_cuda_nvrtc-13.0.88-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl.metadata (1.7 kB)\n", "Collecting nvidia-cuda-runtime==13.0.96.* (from cuda-toolkit[cublas,cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==13.0.3; platform_system == \"Linux\"->torch)\n", " Downloading nvidia_cuda_runtime-13.0.96-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl.metadata (1.7 kB)\n", "Collecting nvidia-cufft==12.0.0.61.* (from cuda-toolkit[cublas,cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==13.0.3; platform_system == \"Linux\"->torch)\n", " Downloading nvidia_cufft-12.0.0.61-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl.metadata (1.8 kB)\n", "Collecting nvidia-nvjitlink<14,>=13.0.88 (from cuda-toolkit[cublas,cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==13.0.3; platform_system == \"Linux\"->torch)\n", " Downloading nvidia_nvjitlink-13.4.52-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl.metadata (1.8 kB)\n", "Collecting nvidia-cufile==1.15.1.6.* (from cuda-toolkit[cublas,cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==13.0.3; platform_system == \"Linux\"->torch)\n", " Downloading nvidia_cufile-1.15.1.6-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl.metadata (1.7 kB)\n", "Collecting nvidia-cuda-cupti==13.0.85.* (from cuda-toolkit[cublas,cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==13.0.3; platform_system == \"Linux\"->torch)\n", " Downloading nvidia_cuda_cupti-13.0.85-py3-none-manylinux_2_25_x86_64.whl.metadata (1.7 kB)\n", "Collecting nvidia-curand==10.4.0.35.* (from cuda-toolkit[cublas,cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==13.0.3; platform_system == \"Linux\"->torch)\n", " Downloading nvidia_curand-10.4.0.35-py3-none-manylinux_2_27_x86_64.whl.metadata (1.7 kB)\n", "Collecting nvidia-cusolver==12.0.4.66.* (from cuda-toolkit[cublas,cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==13.0.3; platform_system == \"Linux\"->torch)\n", " Downloading nvidia_cusolver-12.0.4.66-py3-none-manylinux_2_27_x86_64.whl.metadata (1.8 kB)\n", "Collecting nvidia-cusparse==12.6.3.3.* (from cuda-toolkit[cublas,cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==13.0.3; platform_system == \"Linux\"->torch)\n", " Downloading nvidia_cusparse-12.6.3.3-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl.metadata (1.8 kB)\n", "Collecting nvidia-nvtx==13.0.85.* (from cuda-toolkit[cublas,cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==13.0.3; platform_system == \"Linux\"->torch)\n", " Downloading nvidia_nvtx-13.0.85-py3-none-manylinux1_x86_64.manylinux_2_5_x86_64.whl.metadata (1.8 kB)\n", "Requirement already satisfied: cuda-pathfinder>=1.4.2 in /usr/local/lib/python3.13/dist-packages (from cuda-bindings<14,>=13.0.3->torch) (1.8.0)\n", "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.13/dist-packages (from sympy>=1.13.3->torch) (1.3.0)\n", "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.13/dist-packages (from jinja2->torch) (3.0.3)\n", "Downloading torch-2.14.0-cp313-cp313-manylinux_2_28_x86_64.whl (554.6 MB)\n", "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m554.6/554.6 MB\u001b[0m \u001b[31m2.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25hDownloading cuda_toolkit-13.0.3.0-py2.py3-none-any.whl (2.5 kB)\n", "Downloading nvidia_cudnn_cu13-9.24.0.43-py3-none-manylinux_2_27_x86_64.whl (553.1 MB)\n", "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m553.1/553.1 MB\u001b[0m \u001b[31m2.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25hDownloading nvidia_cusparselt_cu13-0.8.1-py3-none-manylinux2014_x86_64.whl (170.1 MB)\n", "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m170.1/170.1 MB\u001b[0m \u001b[31m6.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25hDownloading nvidia_nccl_cu13-2.30.7-py3-none-manylinux_2_18_x86_64.whl (216.0 MB)\n", "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m216.0/216.0 MB\u001b[0m \u001b[31m5.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25hDownloading nvidia_nvshmem_cu13-3.4.5-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl (60.4 MB)\n", "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m60.4/60.4 MB\u001b[0m \u001b[31m19.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25hDownloading nvidia_cublas-13.1.1.3-py3-none-manylinux_2_27_x86_64.whl (423.1 MB)\n", "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m423.1/423.1 MB\u001b[0m \u001b[31m4.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25hDownloading nvidia_cuda_cupti-13.0.85-py3-none-manylinux_2_25_x86_64.whl (10.7 MB)\n", "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m10.7/10.7 MB\u001b[0m \u001b[31m59.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25hDownloading nvidia_cuda_nvrtc-13.0.88-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl (90.2 MB)\n", "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m90.2/90.2 MB\u001b[0m \u001b[31m9.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25hDownloading nvidia_cuda_runtime-13.0.96-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl (2.2 MB)\n", "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.2/2.2 MB\u001b[0m \u001b[31m73.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25hDownloading nvidia_cufft-12.0.0.61-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl (214.1 MB)\n", "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m214.1/214.1 MB\u001b[0m \u001b[31m6.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25hDownloading nvidia_cufile-1.15.1.6-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl (1.2 MB)\n", "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.2/1.2 MB\u001b[0m \u001b[31m54.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25hDownloading nvidia_curand-10.4.0.35-py3-none-manylinux_2_27_x86_64.whl (59.5 MB)\n", "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m59.5/59.5 MB\u001b[0m \u001b[31m13.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25hDownloading nvidia_cusolver-12.0.4.66-py3-none-manylinux_2_27_x86_64.whl (200.9 MB)\n", "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m200.9/200.9 MB\u001b[0m \u001b[31m6.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25hDownloading nvidia_cusparse-12.6.3.3-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl (145.9 MB)\n", "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m145.9/145.9 MB\u001b[0m \u001b[31m7.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25hDownloading nvidia_nvtx-13.0.85-py3-none-manylinux1_x86_64.manylinux_2_5_x86_64.whl (148 kB)\n", "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m148.0/148.0 kB\u001b[0m \u001b[31m16.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25hDownloading triton-3.8.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (248.0 MB)\n", "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m248.0/248.0 MB\u001b[0m \u001b[31m5.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25hDownloading cuda_bindings-13.4.1-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl (6.9 MB)\n", "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m6.9/6.9 MB\u001b[0m \u001b[31m104.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25hDownloading nvidia_nvjitlink-13.4.52-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl (42.5 MB)\n", "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m42.5/42.5 MB\u001b[0m \u001b[31m16.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25hInstalling collected packages: nvidia-cusparselt-cu13, cuda-toolkit, triton, nvidia-nvtx, nvidia-nvshmem-cu13, nvidia-nvjitlink, nvidia-nccl-cu13, nvidia-curand, nvidia-cufile, nvidia-cuda-runtime, nvidia-cuda-nvrtc, nvidia-cuda-cupti, cuda-bindings, nvidia-cusparse, nvidia-cufft, nvidia-cublas, nvidia-cusolver, nvidia-cudnn-cu13, torch\n", " Attempting uninstall: cuda-toolkit\n", " Found existing installation: cuda-toolkit 12.8.1\n", " Uninstalling cuda-toolkit-12.8.1:\n", " Successfully uninstalled cuda-toolkit-12.8.1\n", " Attempting uninstall: triton\n", " Found existing installation: triton 3.6.0\n", " Uninstalling triton-3.6.0:\n", " Successfully uninstalled triton-3.6.0\n", " Attempting uninstall: nvidia-nccl-cu13\n", " Found existing installation: nvidia-nccl-cu13 2.31.2\n", " Uninstalling nvidia-nccl-cu13-2.31.2:\n", " Successfully uninstalled nvidia-nccl-cu13-2.31.2\n", " Attempting uninstall: cuda-bindings\n", " Found existing installation: cuda-bindings 12.9.7\n", " Uninstalling cuda-bindings-12.9.7:\n", " Successfully uninstalled cuda-bindings-12.9.7\n", " Attempting uninstall: torch\n", " Found existing installation: torch 2.11.0+cu128\n", " Uninstalling torch-2.11.0+cu128:\n", " Successfully uninstalled torch-2.11.0+cu128\n", "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", "cuda-python 12.9.7 requires cuda-bindings~=12.9.7, but you have cuda-bindings 13.4.1 which is incompatible.\n", "cudf-cu12 26.2.1 requires cuda-toolkit[nvcc,nvrtc]==12.*, but you have cuda-toolkit 13.0.3.0 which is incompatible.\n", "libcuml-cu12 26.2.0 requires cuda-toolkit[cublas,cufft,curand,cusolver,cusparse]==12.*, but you have cuda-toolkit 13.0.3.0 which is incompatible.\n", "torchvision 0.26.0+cu128 requires torch==2.11.0, but you have torch 2.14.0 which is incompatible.\n", "cuml-cu12 26.2.0 requires cuda-toolkit[cublas,cufft,curand,cusolver,cusparse]==12.*, but you have cuda-toolkit 13.0.3.0 which is incompatible.\n", "libraft-cu12 26.2.0 requires cuda-toolkit[cublas,curand,cusolver,cusparse]==12.*, but you have cuda-toolkit 13.0.3.0 which is incompatible.\n", "libcuvs-cu12 26.2.0 requires cuda-toolkit[cublas,curand,cusolver,cusparse]==12.*, but you have cuda-toolkit 13.0.3.0 which is incompatible.\u001b[0m\u001b[31m\n", "\u001b[0mSuccessfully installed cuda-bindings-13.4.1 cuda-toolkit-13.0.3.0 nvidia-cublas-13.1.1.3 nvidia-cuda-cupti-13.0.85 nvidia-cuda-nvrtc-13.0.88 nvidia-cuda-runtime-13.0.96 nvidia-cudnn-cu13-9.24.0.43 nvidia-cufft-12.0.0.61 nvidia-cufile-1.15.1.6 nvidia-curand-10.4.0.35 nvidia-cusolver-12.0.4.66 nvidia-cusparse-12.6.3.3 nvidia-cusparselt-cu13-0.8.1 nvidia-nccl-cu13-2.30.7 nvidia-nvjitlink-13.4.52 nvidia-nvshmem-cu13-3.4.5 nvidia-nvtx-13.0.85 torch-2.14.0 triton-3.8.0\n" ] }, { "output_type": "display_data", "data": { "application/vnd.colab-display-data+json": { "pip_warning": { "packages": [ "cuda" ] }, "id": "6fc02fabeaf94077a7156df521f1280a" } }, "metadata": {} } ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 0 }, "id": "MyzuPSaQCXRG", "outputId": "5f6e4944-f226-4a0a-f423-40f832a16726" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Triton smoke test completed.\n" ] } ], "source": [ "\n", "\"\"\"\n", "Triton translations of the CUDA.jl kernels in\n", "AlexandreChern/IJHPCA_revision/CUDA_kernels_second_new.jl.\n", "\n", "IMPORTANT:\n", "- All PDE vectors/coefficient arrays are 1-D CUDA tensors containing the\n", " Julia column-major storage, i.e. linear index k in Julia maps to k-1 here.\n", "- Floating point arrays should normally be torch.float32.\n", "- Nr1/Ns1 are the Julia dimensions.\n", "- The four face kernels are intentionally separate, matching the Julia code.\n", "- The large `cuda_knl_2_x` Julia kernel writes neighboring output entries\n", " from boundary threads. Here it is represented by the race-free decomposition\n", " x_interior + x_f1 + x_f2 + x_f3 + x_f4.\n", "\"\"\"\n", "\n", "import torch\n", "import triton\n", "import triton.language as tl\n", "\n", "\n", "# ---------------------------------------------------------------------------\n", "# Utility: 2-D interior variable-coefficient operator\n", "# ---------------------------------------------------------------------------\n", "\n", "@triton.jit\n", "def x_interior_kernel(\n", " hr, hs, x_ptr, nr1, ns1,\n", " crr_ptr, css_ptr, crs_ptr, out_ptr,\n", "):\n", " # Julia:\n", " # i = global x coordinate, j = global y coordinate\n", " # global_index = (j-1)*Nr1 + i\n", " pid_i = tl.program_id(0)\n", " pid_j = tl.program_id(1)\n", "\n", " # Julia source: i runs over Ns1 (slow/column dimension), j over Nr1.\n", " i = pid_i + 2 # Julia i: 2..Ns1-1\n", " j = pid_j + 2 # Julia j: 2..Nr1-1\n", "\n", " if i <= ns1 - 1 and j <= nr1 - 1:\n", " g = (i - 1) * nr1 + (j - 1) # 0-based flat offset\n", "\n", " crr_m = tl.load(crr_ptr + g - 1)\n", " crr_0 = tl.load(crr_ptr + g)\n", " crr_p = tl.load(crr_ptr + g + 1)\n", "\n", " css_m = tl.load(css_ptr + g - nr1)\n", " css_0 = tl.load(css_ptr + g)\n", " css_p = tl.load(css_ptr + g + nr1)\n", "\n", " crs_m = tl.load(crs_ptr + g - 1)\n", " crs_p = tl.load(crs_ptr + g + 1)\n", " crs_d = tl.load(crs_ptr + g - nr1)\n", " crs_u = tl.load(crs_ptr + g + nr1)\n", "\n", " xm = tl.load(x_ptr + g - 1)\n", " x0 = tl.load(x_ptr + g)\n", " xp = tl.load(x_ptr + g + 1)\n", " xd = tl.load(x_ptr + g - nr1)\n", " xu = tl.load(x_ptr + g + nr1)\n", "\n", " xdm = tl.load(x_ptr + g - nr1 - 1)\n", " xdp = tl.load(x_ptr + g - nr1 + 1)\n", " xum = tl.load(x_ptr + g + nr1 - 1)\n", " xup = tl.load(x_ptr + g + nr1 + 1)\n", "\n", " arr = (\n", " (-0.5 * crr_m - 0.5 * crr_0) * xm\n", " + (0.5 * crr_m + crr_0 + 0.5 * crr_p) * x0\n", " + (-0.5 * crr_0 - 0.5 * crr_p) * xp\n", " )\n", "\n", " ass = (\n", " (-0.5 * css_m - 0.5 * css_0) * xd\n", " + (0.5 * css_m + css_0 + 0.5 * css_p) * x0\n", " + (-0.5 * css_0 - 0.5 * css_p) * xu\n", " )\n", "\n", " ars = (\n", " 0.5 * crs_m * (-0.5 * xdm + 0.5 * xum)\n", " - 0.5 * crs_p * (-0.5 * xdp + 0.5 * xup)\n", " )\n", "\n", " asr = (\n", " 0.5 * crs_d * (-0.5 * xdm + 0.5 * xdp)\n", " - 0.5 * crs_u * (-0.5 * xum + 0.5 * xup)\n", " )\n", "\n", " y = hs * (1.0 / hr) * (arr + ass + ars + asr)\n", " tl.store(out_ptr + g, y)\n", "\n", "\n", "# ---------------------------------------------------------------------------\n", "# Face 1: left boundary (Julia cuda_knl_2_x_f1)\n", "# ---------------------------------------------------------------------------\n", "\n", "@triton.jit\n", "def x_f1_kernel(\n", " hr, hs, x_ptr, nr1, ns1,\n", " crr_ptr, css_ptr, crs_ptr, psi1_ptr, psi2_ptr,\n", " out_ptr,\n", "):\n", " i0 = tl.program_id(0) + 1 # Julia i = 1..Ns1\n", "\n", " if i0 <= ns1:\n", " g = (i0 - 1) * nr1 # j=1 in Julia, 0-based\n", "\n", " if i0 >= 2 and i0 <= ns1 - 1:\n", " crr0 = tl.load(crr_ptr + g)\n", " crr1 = tl.load(crr_ptr + g + 1)\n", "\n", " cssm = tl.load(css_ptr + g - nr1)\n", " css0 = tl.load(css_ptr + g)\n", " cssp = tl.load(css_ptr + g + nr1)\n", "\n", " crs0 = tl.load(crs_ptr + g)\n", " crs1 = tl.load(crs_ptr + g + 1)\n", " crsd = tl.load(crs_ptr + g - nr1)\n", " crsu = tl.load(crs_ptr + g + nr1)\n", "\n", " x0 = tl.load(x_ptr + g)\n", " x1 = tl.load(x_ptr + g + 1)\n", " xd = tl.load(x_ptr + g - nr1)\n", " xu = tl.load(x_ptr + g + nr1)\n", " xu1 = tl.load(x_ptr + g + nr1 + 1)\n", "\n", " x2 = tl.load(x_ptr + g + 2 * 0 + 2)\n", "\n", " arr = (0.5 * crr0 + 0.5 * crr1) * x0 + (-0.5 * crr0 - 0.5 * crr1) * x1\n", " ass = (\n", " (-0.5 * cssm - 0.5 * css0) * xd\n", " + (0.5 * cssm + css0 + 0.5 * cssp) * x0\n", " + (-0.5 * css0 - 0.5 * cssp) * xu\n", " )\n", " ars = (\n", " -0.5 * crs0 * (-0.5 * xd + 0.5 * xu)\n", " -0.5 * crs1 * (-0.5 * xu1 + 0.5 * tl.load(x_ptr + g + 1 - nr1))\n", " )\n", " asr = (\n", " 0.5 * crsd * (-0.5 * xd + 0.5 * x1)\n", " -0.5 * crsu * (-0.5 * xu + 0.5 * xu1)\n", " )\n", "\n", " mod = (\n", " -hs * (1.0 / hr) * crr0 * (1.5 * x0 - 2.0 * x1 + 0.5 * x2)\n", " + crs0 * (-0.5 * xd + 0.5 * xu)\n", " + crr0 * (4.0 + crr0 / tl.load(psi1_ptr + i0 - 1)) * x0\n", " - hs * crr0 * ((1.0 / hr) * 1.5 * x0)\n", " + 0.5 * crsd * xd\n", " - 0.5 * crsu * xu\n", " )\n", "\n", " y = hs * (1.0 / hr) * (arr + ass * 0.5 * (hr / hs) * (hs / hr) + ars + asr) + mod\n", " # The expression above deliberately keeps the Julia factors explicit.\n", " # Reconstruct exact Julia scaling for the first three terms:\n", " y = (\n", " hs * (1.0 / hr) * arr\n", " + hr * 0.5 * (1.0 / hs) * ass\n", " + ars + asr + mod\n", " )\n", " tl.store(out_ptr + g, y)\n", "\n", " # The Julia f1 kernel also writes the two neighboring entries.\n", " tl.store(\n", " out_ptr + g + 1,\n", " -hs * (crr0 * (1.0 / hr) * (-2.0) * x0)\n", " )\n", " tl.store(\n", " out_ptr + g + 2,\n", " -hs * (crr0 * (1.0 / hr) * 0.5 * x0)\n", " )\n", "\n", " # Julia special corner i==1\n", " if i0 == 1:\n", " crr0 = tl.load(crr_ptr + g)\n", " crr1 = tl.load(crr_ptr + g + 1)\n", " crs0 = tl.load(crs_ptr + g)\n", " crs1 = tl.load(crs_ptr + g + 1)\n", " crsu = tl.load(crs_ptr + g + nr1)\n", " css0 = tl.load(css_ptr + g)\n", " cssu = tl.load(css_ptr + g + nr1)\n", "\n", " x0 = tl.load(x_ptr + g)\n", " x1 = tl.load(x_ptr + g + 1)\n", " xu = tl.load(x_ptr + g + nr1)\n", " xu1 = tl.load(x_ptr + g + nr1 + 1)\n", " x2 = tl.load(x_ptr + g + 2)\n", "\n", " y = (\n", " hs * 0.5 * (1.0 / hr) *\n", " ((0.5 * crr0 + 0.5 * crr1) * x0\n", " + (-0.5 * crr0 - 0.5 * crr1) * x1)\n", " + (-0.5 * crs0 * (-0.5 * x0 + 0.5 * xu)\n", " - 0.5 * crs1 * (-0.5 * x1 + 0.5 * xu1))\n", " - hs * 0.5 * (1.0 / hr) * crr0 * (1.5 * x0 - 2.0 * x1 + 0.5 * x2)\n", " + 0.5 * crs0 * (-x0 + xu)\n", " + 0.5 * crr0 * (4.0 + crr0 / tl.load(psi1_ptr)) * x0\n", " - hs * 0.5 * crr0 * ((1.0 / hr) * 1.5 * x0)\n", " - 0.5 * crsu * xu\n", " - 0.5 * crs0 * x0\n", " + hr * 0.5 * (1.0 / hs) *\n", " ((0.5 * css0 + 0.5 * cssu) * x0\n", " + (-0.5 * css0 - 0.5 * cssu) * xu)\n", " - 0.5 * (crs0 * (-0.5 * x0 + 0.5 * x1)\n", " + crsu * (-0.5 * xu + 0.5 * xu1))\n", " )\n", " tl.store(out_ptr + g, y)\n", " tl.store(out_ptr + g + 1, -hs * 0.5 * crr0 * (1.0 / hr) * (-2.0) * x0)\n", " tl.store(out_ptr + g + 2, -hs * 0.5 * crr0 * (1.0 / hr) * 0.5 * x0)\n", "\n", " # Julia special corner i==Ns1\n", " if i0 == ns1:\n", " g = (ns1 - 1) * nr1\n", " crr0 = tl.load(crr_ptr + g)\n", " crr1 = tl.load(crr_ptr + g + 1)\n", " crs0 = tl.load(crs_ptr + g)\n", " crs1 = tl.load(crs_ptr + g + 1)\n", " crsd = tl.load(crs_ptr + g - nr1)\n", " cssd = tl.load(css_ptr + g - nr1)\n", " css0 = tl.load(css_ptr + g)\n", "\n", " x0 = tl.load(x_ptr + g)\n", " x1 = tl.load(x_ptr + g + 1)\n", " xd = tl.load(x_ptr + g - nr1)\n", " xd1 = tl.load(x_ptr + g - nr1 + 1)\n", " x2 = tl.load(x_ptr + g + 2)\n", "\n", " y = (\n", " hs * 0.5 * (1.0 / hr) *\n", " ((0.5 * crr0 + 0.5 * crr1) * x0\n", " + (-0.5 * crr0 - 0.5 * crr1) * x1)\n", " + (-0.5 * crs0 * (-0.5 * xd + 0.5 * x0)\n", " - 0.5 * crs1 * (-0.5 * xd1 + 0.5 * x1))\n", " - hs * 0.5 * (1.0 / hr) * crr0 * (1.5 * x0 - 2.0 * x1 + 0.5 * x2)\n", " + 0.5 * crs0 * (-xd + x0)\n", " + 0.5 * crr0 * (4.0 + crr0 / tl.load(psi1_ptr + ns1 - 1)) * x0\n", " - hs * 0.5 * crr0 * ((1.0 / hr) * 1.5 * x0)\n", " + 0.5 * crsd * xd\n", " + 0.5 * crs0 * x0\n", " + hr * 0.5 * (1.0 / hs) *\n", " ((-0.5 * cssd - 0.5 * css0) * xd\n", " + (0.5 * cssd + 0.5 * css0) * x0)\n", " )\n", " tl.store(out_ptr + g, y)\n", " tl.store(out_ptr + g + 1, -hs * 0.5 * crr0 * (1.0 / hr) * (-2.0) * x0)\n", " tl.store(out_ptr + g + 2, -hs * 0.5 * crr0 * (1.0 / hr) * 0.5 * x0)\n", "\n", "\n", "# ---------------------------------------------------------------------------\n", "# Face 2 (right), face 3 (bottom), face 4 (top)\n", "#\n", "# These use the same mathematical expressions as the Julia source, with\n", "# one Triton program per face coordinate.\n", "# ---------------------------------------------------------------------------\n", "\n", "@triton.jit\n", "def x_f2_kernel(\n", " hr, hs, x_ptr, nr1, ns1,\n", " crr_ptr, css_ptr, crs_ptr, psi1_ptr, psi2_ptr,\n", " out_ptr,\n", "):\n", " j = tl.program_id(0) + 1\n", " if j <= ns1:\n", " g = j * nr1 - 1\n", " if j >= 2 and j <= ns1 - 1:\n", " crrm = tl.load(crr_ptr + g - 1)\n", " crr0 = tl.load(crr_ptr + g)\n", " cssm = tl.load(css_ptr + g - nr1)\n", " css0 = tl.load(css_ptr + g)\n", " cssp = tl.load(css_ptr + g + nr1)\n", " crsm = tl.load(crs_ptr + g - 1)\n", " crs0 = tl.load(crs_ptr + g)\n", " crsd = tl.load(crs_ptr + g - nr1)\n", " crsu = tl.load(crs_ptr + g + nr1)\n", " x_m = tl.load(x_ptr + g - 1)\n", " x0 = tl.load(x_ptr + g)\n", " x_d = tl.load(x_ptr + g - nr1)\n", " x_u = tl.load(x_ptr + g + nr1)\n", " x_dm = tl.load(x_ptr + g - nr1 - 1)\n", " x_um = tl.load(x_ptr + g + nr1 - 1)\n", " y = (\n", " hs * (1.0 / hr) * ((-0.5*crrm-0.5*crr0)*x_m + (0.5*crrm+0.5*crr0)*x0)\n", " + hr * 0.5 * (1.0 / hs) *\n", " ((-0.5*cssm-0.5*css0)*x_d\n", " + (0.5*cssm+css0+0.5*cssp)*x0\n", " + (-0.5*css0-0.5*cssp)*x_u)\n", " + 0.5*crsm*(-0.5*x_dm+0.5*x_um)\n", " + 0.5*crs0*(-0.5*x_d+0.5*x_u)\n", " - hs*(1.0/hr)*crr0*(1.5*x0-2.0*x_m+0.5*tl.load(x_ptr+g-2))\n", " - crs0*(-0.5*tl.load(x_ptr+g-nr1)+0.5*tl.load(x_ptr+g+nr1))\n", " + crr0*(4.0+crr0/tl.load(psi2_ptr+j-1))*x0\n", " - hs*crr0*((1.0/hr)*1.5*x0)\n", " - 0.5*crsd* x_d + 0.5*crsu*x_u\n", " )\n", " tl.store(out_ptr+g, y)\n", " tl.store(out_ptr+g-1, -hs*crr0*(1.0/hr)*(-2.0)*x0)\n", " tl.store(out_ptr+g-2, -hs*crr0*(1.0/hr)*0.5*x0)\n", "\n", " if j == 1:\n", " g = nr1 - 1\n", " # exact right/bottom corner from f2\n", " crra = tl.load(crr_ptr+g-1); crr0 = tl.load(crr_ptr+g)\n", " crsa = tl.load(crs_ptr+g-1); crs0 = tl.load(crs_ptr+g)\n", " crsd = tl.load(crs_ptr+g-nr1); crsu = tl.load(crs_ptr+g+nr1)\n", " cssd = tl.load(css_ptr+g-nr1); css0 = tl.load(css_ptr+g)\n", " x0 = tl.load(x_ptr+g); xm = tl.load(x_ptr+g-1)\n", " xd = tl.load(x_ptr+g-nr1); xd_m = tl.load(x_ptr+g-nr1-1)\n", " x2m = tl.load(x_ptr+g-2)\n", " y = (\n", " hs*0.5*(1.0/hr)*((-0.5*crra-0.5*crr0)*xm+(0.5*crra+0.5*crr0)*x0)\n", " + 0.5*crsa*(-0.5*xm+0.5*x0)\n", " + 0.5*crs0*(-0.5*xd+0.5*x0)\n", " - hs*0.5*(1.0/hr)*crr0*(1.5*x0-2*xm+0.5*x2m)\n", " - 0.5*crs0*(-xd+x0)\n", " + 0.5*crr0*(4.0+crr0/tl.load(psi2_ptr))*x0\n", " - hs*0.5*crr0*((1.0/hr)*1.5*x0)\n", " + 0.5*crsu*xd\n", " + 0.5*crs0*x0\n", " )\n", " tl.store(out_ptr+g, y)\n", " tl.store(out_ptr+g-1, -hs*0.5*crr0*(1.0/hr)*(-2)*x0)\n", " tl.store(out_ptr+g-2, -hs*0.5*crr0*(1.0/hr)*0.5*x0)\n", "\n", " if j == ns1:\n", " g = ns1*nr1 - 1\n", " crrm=tl.load(crr_ptr+g-1); crr0=tl.load(crr_ptr+g)\n", " crsm=tl.load(crs_ptr+g-1); crs0=tl.load(crs_ptr+g)\n", " crsd=tl.load(crs_ptr+g-nr1)\n", " cssd=tl.load(css_ptr+g-nr1); css0=tl.load(css_ptr+g)\n", " x0=tl.load(x_ptr+g); xm=tl.load(x_ptr+g-1)\n", " xd=tl.load(x_ptr+g-nr1); xdm=tl.load(x_ptr+g-nr1-1)\n", " x2m=tl.load(x_ptr+g-2)\n", " y=(\n", " hs*0.5*(1.0/hr)*((-0.5*crrm-0.5*crr0)*xm+(0.5*crrm+0.5*crr0)*x0)\n", " + 0.5*crsm*(-0.5*xdm+0.5*xm)\n", " + 0.5*crs0*(-0.5*xd+0.5*x0)\n", " - hs*0.5*(1.0/hr)*crr0*(1.5*x0-2*xm+0.5*x2m)\n", " - 0.5*crs0*(-xd+x0)\n", " + 0.5*crr0*(4.0+crr0/tl.load(psi2_ptr+ns1-1))*x0\n", " - hs*0.5*crr0*((1.0/hr)*1.5*x0)\n", " - 0.5*crsd*xd\n", " - 0.5*crs0*x0\n", " + hr*0.5*(1.0/hs)*((-0.5*cssd-0.5*css0)*xd+(0.5*cssd+0.5*css0)*x0)\n", " )\n", " tl.store(out_ptr+g,y)\n", " tl.store(out_ptr+g-1,-hs*0.5*crr0*(1.0/hr)*(-2)*x0)\n", " tl.store(out_ptr+g-2,-hs*0.5*crr0*(1.0/hr)*0.5*x0)\n", "\n", "\n", "@triton.jit\n", "def x_f3_kernel(hr, hs, x_ptr, nr1, ns1, crr_ptr, css_ptr, crs_ptr,\n", " psi1_ptr, psi2_ptr, out_ptr):\n", " i = tl.program_id(0) + 1\n", " if i <= nr1:\n", " g = i - 1\n", " if i >= 2 and i <= nr1 - 1:\n", " cm=tl.load(crr_ptr+g-1); c0=tl.load(crr_ptr+g); cp=tl.load(crr_ptr+g+1)\n", " s0=tl.load(css_ptr+g); su=tl.load(css_ptr+g+nr1)\n", " rm=tl.load(crs_ptr+g-1); rp=tl.load(crs_ptr+g+1); r0=tl.load(crs_ptr+g); ru=tl.load(crs_ptr+g+nr1)\n", " xm=tl.load(x_ptr+g-1); x0=tl.load(x_ptr+g); xp=tl.load(x_ptr+g+1)\n", " xu=tl.load(x_ptr+g+nr1); xum=tl.load(x_ptr+g+nr1-1); xup=tl.load(x_ptr+g+nr1+1)\n", " y=(\n", " hs*0.5*(1/hr)*((-0.5*cm-0.5*c0)*xm+(0.5*cm+c0+0.5*cp)*x0+(-0.5*c0-0.5*cp)*xp)\n", " + hr*(1/hs)*((0.5*s0+0.5*su)*x0+(-0.5*s0-0.5*su)*xu)\n", " + 0.5*rm*(-0.5*xm+0.5*xum)\n", " -0.5*rp*(-0.5*xp+0.5*xup)\n", " -0.5*r0*(-0.5*xm+0.5*xp)\n", " -0.5*ru*(-0.5*xum+0.5*xup)\n", " )\n", " tl.store(out_ptr+g,y)\n", " if i == 1:\n", " s0=tl.load(css_ptr+g); su=tl.load(css_ptr+g+nr1)\n", " r0=tl.load(crs_ptr+g); ru=tl.load(crs_ptr+g+nr1)\n", " x0=tl.load(x_ptr+g); x1=tl.load(x_ptr+g+1); xu=tl.load(x_ptr+g+nr1); xu1=tl.load(x_ptr+g+nr1+1)\n", " y=hr*0.5*(1/hs)*((0.5*s0+0.5*su)*x0+(-0.5*s0-0.5*su)*xu) \\\n", " -0.5*(r0*(-0.5*x0+0.5*x1)+ru*(-0.5*xu+0.5*xu1))\n", " tl.store(out_ptr+g,y)\n", " if i == nr1:\n", " s0=tl.load(css_ptr+g); su=tl.load(css_ptr+g+nr1)\n", " r0=tl.load(crs_ptr+g); rm=tl.load(crs_ptr+g-1); ru=tl.load(crs_ptr+g+nr1)\n", " x0=tl.load(x_ptr+g); xm=tl.load(x_ptr+g-1); xu=tl.load(x_ptr+g+nr1); xum=tl.load(x_ptr+g+nr1-1)\n", " y=hr*0.5*(1/hs)*((0.5*s0+0.5*su)*x0+(-0.5*s0-0.5*su)*xu) \\\n", " -0.5*(r0*(-0.5*xm+0.5*x0)+ru*(-0.5*xum+0.5*xu))\n", " tl.store(out_ptr+g,y)\n", "\n", "\n", "@triton.jit\n", "def x_f4_kernel(hr, hs, x_ptr, nr1, ns1, crr_ptr, css_ptr, crs_ptr,\n", " psi1_ptr, psi2_ptr, out_ptr):\n", " i = tl.program_id(0) + 1\n", " if i <= nr1:\n", " g = (ns1-1)*nr1 + i - 1\n", " if i >= 2 and i <= nr1 - 1:\n", " cm=tl.load(crr_ptr+g-1); c0=tl.load(crr_ptr+g); cp=tl.load(crr_ptr+g+1)\n", " sm=tl.load(css_ptr+g-nr1); s0=tl.load(css_ptr+g)\n", " rm=tl.load(crs_ptr+g-1); rp=tl.load(crs_ptr+g+1); rd=tl.load(crs_ptr+g-nr1); r0=tl.load(crs_ptr+g)\n", " xm=tl.load(x_ptr+g-1); x0=tl.load(x_ptr+g); xp=tl.load(x_ptr+g+1)\n", " xd=tl.load(x_ptr+g-nr1); xdm=tl.load(x_ptr+g-nr1-1); xdp=tl.load(x_ptr+g-nr1+1)\n", " y=(\n", " hs*0.5*(1/hr)*((-0.5*cm-0.5*c0)*xm+(0.5*cm+c0+0.5*cp)*x0+(-0.5*c0-0.5*cp)*xp)\n", " + hr*(1/hs)*((-0.5*sm-0.5*s0)*xd+(0.5*sm+0.5*s0)*x0)\n", " + 0.5*rm*(-0.5*xdm+0.5*xm)\n", " -0.5*rp*(-0.5*xdp+0.5*xp)\n", " +0.5*rd*(-0.5*xm+0.5*xp)\n", " +0.5*r0*(-0.5*xm+0.5*xp)\n", " )\n", " tl.store(out_ptr+g,y)\n", " if i == 1:\n", " sm=tl.load(css_ptr+g-nr1); s0=tl.load(css_ptr+g)\n", " rd=tl.load(crs_ptr+g-nr1); r0=tl.load(crs_ptr+g)\n", " x0=tl.load(x_ptr+g); xp=tl.load(x_ptr+g+1); xd=tl.load(x_ptr+g-nr1); xdp=tl.load(x_ptr+g+1-nr1)\n", " y=hr*0.5*(1/hs)*((-0.5*sm-0.5*s0)*xd+(0.5*sm+0.5*s0)*x0) \\\n", " +0.5*(rd*(-0.5*xd+0.5*xdp)+r0*(-0.5*x0+0.5*xp))\n", " tl.store(out_ptr+g,y)\n", " if i == nr1:\n", " sm=tl.load(css_ptr+g-nr1); s0=tl.load(css_ptr+g)\n", " rd=tl.load(crs_ptr+g-nr1); r0=tl.load(crs_ptr+g)\n", " x0=tl.load(x_ptr+g); xm=tl.load(x_ptr+g-1); xd=tl.load(x_ptr+g-nr1)\n", " xdm=tl.load(x_ptr+g-1-nr1)\n", " y=hr*0.5*(1/hs)*((-0.5*sm-0.5*s0)*xd+(0.5*sm+0.5*s0)*x0) \\\n", " +0.5*(rd*(-0.5*xdm+0.5*xd)+r0*(-0.5*xm+0.5*x0))\n", " tl.store(out_ptr+g,y)\n", "\n", "\n", "# ---------------------------------------------------------------------------\n", "# H and H^{-1}\n", "# ---------------------------------------------------------------------------\n", "\n", "@triton.jit\n", "def H_kernel(hr, hs, x_ptr, nr1, ns1, out_ptr, inverse: tl.constexpr):\n", " pid_x = tl.program_id(0)\n", " pid_y = tl.program_id(1)\n", " i = pid_x + 1\n", " j = pid_y + 1\n", " if i <= ns1 and j <= nr1:\n", " g = (i - 1) * nr1 + (j - 1)\n", " boundary_x = (i == 1) | (i == ns1)\n", " boundary_y = (j == 1) | (j == nr1)\n", " corner = boundary_x & boundary_y\n", " edge = boundary_x | boundary_y\n", " val = tl.load(x_ptr + g)\n", " if inverse:\n", " scale = 1.0 / (hr * hs)\n", " out = tl.where(corner, 4.0 * scale * val,\n", " tl.where(edge, 2.0 * scale * val, scale * val))\n", " else:\n", " scale = hr * hs\n", " out = tl.where(corner, 0.25 * scale * val,\n", " tl.where(edge, 0.5 * scale * val, scale * val))\n", " tl.store(out_ptr + g, out)\n", "\n", "\n", "# ---------------------------------------------------------------------------\n", "# Prolongation / restriction\n", "# ---------------------------------------------------------------------------\n", "\n", "@triton.jit\n", "def prolongation_2d_kernel(idata_ptr, odata_ptr, nx, ny):\n", " pid_x = tl.program_id(0)\n", " pid_y = tl.program_id(1)\n", " i = pid_x + 1\n", " j = pid_y + 1\n", "\n", " # Julia source uses 1-based column-major indexing.\n", " if i <= nx - 1 and j <= ny - 1:\n", " g = (i - 1) * nx + (j - 1)\n", " o_stride = 2 * nx - 1\n", " o00 = (2*i - 2) * (2*nx - 1) + (2*j - 2)\n", " o01 = o00 + 1\n", " o10 = o00 + (2*ny - 1)\n", " o11 = o10 + 1\n", "\n", " a = tl.load(idata_ptr + g)\n", " b = tl.load(idata_ptr + g + 1)\n", " c = tl.load(idata_ptr + ny)\n", " d = tl.load(idata_ptr + ny + 1)\n", "\n", " tl.store(odata_ptr + o00, a)\n", " tl.store(odata_ptr + o01, 0.5*(a+b))\n", " tl.store(odata_ptr + o10, 0.5*(a+c))\n", " tl.store(odata_ptr + o11, 0.25*(a+c+b+d))\n", "\n", " if j <= ny - 1 and i == nx:\n", " g = (i - 1) * nx + (j - 1)\n", " o_stride = 2 * nx - 1\n", " o00 = (2*i - 2) * o_stride + (2*j - 2)\n", " a = tl.load(idata_ptr + g)\n", " b = tl.load(idata_ptr + g + 1)\n", " tl.store(odata_ptr + o00, a)\n", " tl.store(odata_ptr + o00 + 1, 0.5*(a+b))\n", "\n", " if i <= nx - 1 and j == ny:\n", " g = (i - 1) * nx + (j - 1)\n", " o_stride = 2 * nx - 1\n", " o00 = (2*i - 2) * o_stride + (2*j - 2)\n", " a = tl.load(idata_ptr + g)\n", " c = tl.load(idata_ptr + ny)\n", " tl.store(odata_ptr + o00, a)\n", " tl.store(odata_ptr + o00 + o_stride, 0.5*(a+c))\n", "\n", " if i == nx and j == ny:\n", " g = (i - 1) * nx + (j - 1)\n", " o_stride = 2 * nx - 1\n", " o00 = (2*i - 2) * o_stride + (2*j - 2)\n", " tl.store(odata_ptr + o00, tl.load(idata_ptr + g))\n", "\n", "\n", "@triton.jit\n", "def restriction_2d_kernel(idata_ptr, odata_ptr, nx, ny):\n", " # This follows the exact indexing formulas in the Julia restriction kernel.\n", " pid_x = tl.program_id(0)\n", " pid_y = tl.program_id(1)\n", " i = pid_x + 1\n", " j = pid_y + 1\n", "\n", " nox = (nx + 1) // 2\n", " noy = (ny + 1) // 2\n", "\n", " if i <= nox and j <= noy:\n", " # Interior\n", " if i >= 2 and i <= nox-1 and j >= 2 and j <= noy-1:\n", " a = (2*i - 2) * nx + (2*j - 2)\n", " v = (\n", " 4.0 * tl.load(idata_ptr + a)\n", " + 2.0 * (\n", " tl.load(idata_ptr + a + nx)\n", " + tl.load(idata_ptr + a - nx)\n", " + tl.load(idata_ptr + a + 1)\n", " + tl.load(idata_ptr + a - 1)\n", " )\n", " + tl.load(idata_ptr + a - nx - 1)\n", " + tl.load(idata_ptr + a + nx + 1)\n", " + tl.load(idata_ptr + a - nx + 1)\n", " + tl.load(idata_ptr + a + nx - 1)\n", " ) / 16.0\n", " tl.store(odata_ptr + (i-1)*noy + (j-1), v)\n", "\n", " # Four corners\n", " if i == 1 and j == 1:\n", " v = (tl.load(idata_ptr) + tl.load(idata_ptr+nx)\n", " + tl.load(idata_ptr+1) + tl.load(idata_ptr+nx+1)) / 4.0\n", " tl.store(odata_ptr, v)\n", "\n", " if i == nox and j == 1:\n", " a = (2*i-2)*ny\n", " v = (tl.load(idata_ptr+a) + tl.load(idata_ptr+a-nx)\n", " + tl.load(idata_ptr+a+1) + tl.load(idata_ptr+a-nx+1)) / 4.0\n", " tl.store(odata_ptr + (i-1)*noy, v)\n", "\n", " if i == 1 and j == noy:\n", " a = 2*j-2\n", " v = (tl.load(idata_ptr+a) + tl.load(idata_ptr+a+nx)\n", " + tl.load(idata_ptr+a-1) + tl.load(idata_ptr+a+nx-1)) / 4.0\n", " tl.store(odata_ptr + (j-1), v)\n", "\n", " if i == nox and j == noy:\n", " a = (2*i-2)*ny + (2*j-2)\n", " v = (tl.load(idata_ptr+a) + tl.load(idata_ptr+a-nx)\n", " + tl.load(idata_ptr+a-1) + tl.load(idata_ptr+a-nx-1)) / 4.0\n", " tl.store(odata_ptr + (i-1)*noy + (j-1), v)\n", "\n", " # Bottom/top edges\n", " if i >= 2 and i <= nox-1 and j == 1:\n", " a = (2*i-2)*ny\n", " v = (\n", " 2*tl.load(idata_ptr+a)\n", " + tl.load(idata_ptr+a-nx)\n", " + tl.load(idata_ptr+a+nx)\n", " + 2*tl.load(idata_ptr+a+1)\n", " + tl.load(idata_ptr+a-nx+1)\n", " + tl.load(idata_ptr+a+nx+1)\n", " ) / 8.0\n", " tl.store(odata_ptr+(i-1)*noy, v)\n", "\n", " if i >= 2 and i <= nox-1 and j == noy:\n", " a = (2*i-2)*ny + (2*j-2)\n", " v = (\n", " 2*tl.load(idata_ptr+a)\n", " + tl.load(idata_ptr+a-nx)\n", " + tl.load(idata_ptr+a+nx)\n", " + 2*tl.load(idata_ptr+a-1)\n", " + tl.load(idata_ptr+a-nx-1)\n", " + tl.load(idata_ptr+a+nx-1)\n", " ) / 8.0\n", " tl.store(odata_ptr+(i-1)*noy+(j-1), v)\n", "\n", " # Left/right edges\n", " if i == 1 and j >= 2 and j <= noy-1:\n", " a = 2*j-2\n", " v = (\n", " 2*tl.load(idata_ptr+a)\n", " + tl.load(idata_ptr+a-1)\n", " + tl.load(idata_ptr+a+1)\n", " + 2*tl.load(idata_ptr+a+nx)\n", " + tl.load(idata_ptr+a+nx-1)\n", " + tl.load(idata_ptr+a+nx+1)\n", " ) / 8.0\n", " tl.store(odata_ptr+(j-1), v)\n", "\n", " if i == nox and j >= 2 and j <= noy-1:\n", " a = (2*i-2)*ny + (2*j-2)\n", " v = (\n", " 2*tl.load(idata_ptr+a)\n", " + tl.load(idata_ptr+a-1)\n", " + tl.load(idata_ptr+a+1)\n", " + 2*tl.load(idata_ptr+a-nx)\n", " + tl.load(idata_ptr+a-nx-1)\n", " + tl.load(idata_ptr+a-nx+1)\n", " ) / 8.0\n", " tl.store(odata_ptr+(i-1)*noy+(j-1), v)\n", "\n", "\n", "# ---------------------------------------------------------------------------\n", "# Python launch wrappers\n", "# ---------------------------------------------------------------------------\n", "\n", "def launch_x_interior(hr, hs, x, Nr1, Ns1, crr, css, crs, out):\n", " grid = (max(Ns1-2, 0), max(Nr1-2, 0))\n", " x_interior_kernel[grid](hr, hs, x, Nr1, Ns1, crr, css, crs, out)\n", " return out\n", "\n", "\n", "def launch_x_f1(hr, hs, x, Nr1, Ns1, crr, css, crs, psi1, psi2, out):\n", " x_f1_kernel[(Ns1,)](hr, hs, x, Nr1, Ns1, crr, css, crs, psi1, psi2, out)\n", " return out\n", "\n", "\n", "def launch_x_f2(hr, hs, x, Nr1, Ns1, crr, css, crs, psi1, psi2, out):\n", " x_f2_kernel[(Ns1,)](hr, hs, x, Nr1, Ns1, crr, css, crs, psi1, psi2, out)\n", " return out\n", "\n", "\n", "def launch_x_f3(hr, hs, x, Nr1, Ns1, crr, css, crs, psi1, psi2, out):\n", " x_f3_kernel[(Nr1,)](hr, hs, x, Nr1, Ns1, crr, css, crs, psi1, psi2, out)\n", " return out\n", "\n", "\n", "def launch_x_f4(hr, hs, x, Nr1, Ns1, crr, css, crs, psi1, psi2, out):\n", " x_f4_kernel[(Nr1,)](hr, hs, x, Nr1, Ns1, crr, css, crs, psi1, psi2, out)\n", " return out\n", "\n", "\n", "def launch_H(hr, hs, x, Nr1, Ns1, out):\n", " H_kernel[(Ns1, Nr1)](hr, hs, x, Nr1, Ns1, out, inverse=False)\n", " return out\n", "\n", "\n", "def launch_H_inverse(hr, hs, x, Nr1, Ns1, out):\n", " H_kernel[(Ns1, Nr1)](hr, hs, x, Nr1, Ns1, out, inverse=True)\n", " return out\n", "\n", "\n", "def launch_prolongation(x, out, Nx, Ny):\n", " grid = ((Nx + 15)//16, (Ny + 15)//16)\n", " prolongation_2d_kernel[grid](x, out, Nx, Ny)\n", " return out\n", "\n", "\n", "def launch_restriction(x, out, Nx, Ny):\n", " nox = (Nx + 1)//2\n", " noy = (Ny + 1)//2\n", " grid = ((nox + 15)//16, (noy + 15)//16)\n", " restriction_2d_kernel[grid](x, out, Nx, Ny)\n", " return out\n", "\n", "\n", "# ---------------------------------------------------------------------------\n", "# Smoke test\n", "# ---------------------------------------------------------------------------\n", "\n", "def smoke_test():\n", " assert torch.cuda.is_available(), \"CUDA GPU is required\"\n", "\n", " device = \"cuda\"\n", " Nr1, Ns1 = 64, 48\n", " n = Nr1 * Ns1\n", "\n", " hr = 0.1\n", " hs = 0.2\n", "\n", " x = torch.randn(n, device=device, dtype=torch.float32)\n", " crr = torch.rand(n, device=device, dtype=torch.float32) + 1.0\n", " css = torch.rand(n, device=device, dtype=torch.float32) + 1.0\n", " crs = torch.rand(n, device=device, dtype=torch.float32) * 0.1\n", " psi1 = torch.rand(Ns1, device=device, dtype=torch.float32) + 1.0\n", " psi2 = torch.rand(Ns1, device=device, dtype=torch.float32) + 1.0\n", "\n", " out = torch.empty_like(x)\n", "\n", " launch_x_interior(hr, hs, x, Nr1, Ns1, crr, css, crs, out)\n", " launch_x_f1(hr, hs, x, Nr1, Ns1, crr, css, crs, psi1, psi2, out)\n", " launch_x_f2(hr, hs, x, Nr1, Ns1, crr, css, crs, psi1, psi2, out)\n", " launch_x_f3(hr, hs, x, Nr1, Ns1, crr, css, crs, psi1, psi2, out)\n", " launch_x_f4(hr, hs, x, Nr1, Ns1, crr, css, crs, psi1, psi2, out)\n", "\n", " h_out = torch.empty_like(x)\n", " launch_H(hr, hs, x, Nr1, Ns1, h_out)\n", " launch_H_inverse(hr, hs, x, Nr1, Ns1, h_out)\n", "\n", " # For transfer kernels use dimensions for which the formulas are valid.\n", " nx, ny = 17, 17\n", " fine_x = 2*nx - 1\n", " fine_y = 2*ny - 1\n", " coarse = torch.randn(nx*ny, device=device)\n", " fine = torch.empty(fine_x*fine_y, device=device)\n", " launch_prolongation(coarse, fine, nx, ny)\n", "\n", " restricted = torch.empty(((fine_x+1)//2)*((fine_y+1)//2),\n", " device=device)\n", " launch_restriction(fine, restricted, fine_x, fine_y)\n", "\n", " torch.cuda.synchronize()\n", " print(\"Triton smoke test completed.\")\n", "\n", "\n", "if __name__ == \"__main__\":\n", " smoke_test()\n" ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 564 }, "id": "f75a1335", "outputId": "621b44d6-498c-46f5-8724-270d550c2b22" }, "source": [ "import time\n", "import matplotlib.pyplot as plt\n", "\n", "def benchmark_kernel(kernel_func, *args, repeats=100):\n", " # Warmup\n", " for _ in range(10):\n", " kernel_func(*args)\n", " torch.cuda.synchronize()\n", "\n", " start_time = time.perf_counter()\n", " for _ in range(repeats):\n", " kernel_func(*args)\n", " torch.cuda.synchronize()\n", " end_time = time.perf_counter()\n", "\n", " return (end_time - start_time) / repeats * 1e6 # Time in microseconds\n", "\n", "def run_benchmarks():\n", " sizes = [32, 64, 128, 256, 512]\n", " interior_times = []\n", " f1_times = []\n", " h_times = []\n", "\n", " device = \"cuda\"\n", "\n", " for N in sizes:\n", " Nr1, Ns1 = N, N\n", " n = Nr1 * Ns1\n", " hr, hs = 0.1, 0.2\n", "\n", " x = torch.randn(n, device=device, dtype=torch.float32)\n", " crr = torch.rand(n, device=device, dtype=torch.float32) + 1.0\n", " css = torch.rand(n, device=device, dtype=torch.float32) + 1.0\n", " crs = torch.rand(n, device=device, dtype=torch.float32) * 0.1\n", " psi1 = torch.rand(Ns1, device=device, dtype=torch.float32) + 1.0\n", " psi2 = torch.rand(Ns1, device=device, dtype=torch.float32) + 1.0\n", " out = torch.empty_like(x)\n", "\n", " t_int = benchmark_kernel(launch_x_interior, hr, hs, x, Nr1, Ns1, crr, css, crs, out)\n", " t_f1 = benchmark_kernel(launch_x_f1, hr, hs, x, Nr1, Ns1, crr, css, crs, psi1, psi2, out)\n", " t_h = benchmark_kernel(launch_H, hr, hs, x, Nr1, Ns1, out)\n", "\n", " interior_times.append(t_int)\n", " f1_times.append(t_f1)\n", " h_times.append(t_h)\n", "\n", " # Plotting\n", " plt.figure(figsize=(10, 6))\n", " plt.plot(sizes, interior_times, marker='o', label='Interior Kernel')\n", " plt.plot(sizes, f1_times, marker='s', label='Face 1 Kernel')\n", " plt.plot(sizes, h_times, marker='^', label='H Matrix Kernel')\n", "\n", " plt.title('Triton Kernel Execution Time vs. Grid Dimension')\n", " plt.xlabel('Grid Dimension (N x N)')\n", " plt.ylabel('Execution Time (microseconds)')\n", " plt.yscale('log')\n", " plt.grid(True, which=\"both\", ls=\"--\")\n", " plt.legend()\n", " plt.show()\n", "\n", "run_benchmarks()" ], "execution_count": 6, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} } ] }, { "cell_type": "markdown", "source": [], "metadata": { "id": "Vab8kOlBFDYF" } }, { "cell_type": "code", "source": [ "!jupyter nbconvert --to markdown Triton_SBP_SAT.ipynb" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "nhYP3mb6EzEM", "outputId": "3f86ea02-3c97-43ab-8048-1d29b5d16829" }, "execution_count": 7, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "[NbConvertApp] WARNING | pattern 'Triton_SBP_SAT.ipynb' matched no files\n", "This application is used to convert notebook files (*.ipynb)\n", " to various other formats.\n", "\n", " WARNING: THE COMMANDLINE INTERFACE MAY CHANGE IN FUTURE RELEASES.\n", "\n", "Options\n", "=======\n", "The options below are convenience aliases to configurable class-options,\n", "as listed in the \"Equivalent to\" description-line of the aliases.\n", "To see all configurable class-options for some , use:\n", " --help-all\n", "\n", "--debug\n", " set log level to logging.DEBUG (maximize logging output)\n", " Equivalent to: [--Application.log_level=10]\n", "--show-config\n", " Show the application's configuration (human-readable format)\n", " Equivalent to: [--Application.show_config=True]\n", "--show-config-json\n", " Show the application's configuration (json format)\n", " Equivalent to: [--Application.show_config_json=True]\n", "--generate-config\n", " generate default config file\n", " Equivalent to: [--JupyterApp.generate_config=True]\n", "-y\n", " Answer yes to any questions instead of prompting.\n", " Equivalent to: [--JupyterApp.answer_yes=True]\n", "--execute\n", " Execute the notebook prior to export.\n", " Equivalent to: [--ExecutePreprocessor.enabled=True]\n", "--allow-errors\n", " Continue notebook execution even if one of the cells throws an error and include the error message in the cell output (the default behaviour is to abort conversion). This flag is only relevant if '--execute' was specified, too.\n", " Equivalent to: [--ExecutePreprocessor.allow_errors=True]\n", "--stdin\n", " read a single notebook file from stdin. Write the resulting notebook with default basename 'notebook.*'\n", " Equivalent to: [--NbConvertApp.from_stdin=True]\n", "--stdout\n", " Write notebook output to stdout instead of files.\n", " Equivalent to: [--NbConvertApp.writer_class=StdoutWriter]\n", "--inplace\n", " Run nbconvert in place, overwriting the existing notebook (only\n", " relevant when converting to notebook format)\n", " Equivalent to: [--NbConvertApp.use_output_suffix=False --NbConvertApp.export_format=notebook --FilesWriter.build_directory=]\n", "--clear-output\n", " Clear output of current file and save in place,\n", " overwriting the existing notebook.\n", " Equivalent to: [--NbConvertApp.use_output_suffix=False --NbConvertApp.export_format=notebook --FilesWriter.build_directory= --ClearOutputPreprocessor.enabled=True]\n", "--coalesce-streams\n", " Coalesce consecutive stdout and stderr outputs into one stream (within each cell).\n", " Equivalent to: [--NbConvertApp.use_output_suffix=False --NbConvertApp.export_format=notebook --FilesWriter.build_directory= --CoalesceStreamsPreprocessor.enabled=True]\n", "--no-prompt\n", " Exclude input and output prompts from converted document.\n", " Equivalent to: [--TemplateExporter.exclude_input_prompt=True --TemplateExporter.exclude_output_prompt=True]\n", "--no-input\n", " Exclude input cells and output prompts from converted document.\n", " This mode is ideal for generating code-free reports.\n", " Equivalent to: [--TemplateExporter.exclude_output_prompt=True --TemplateExporter.exclude_input=True --TemplateExporter.exclude_input_prompt=True]\n", "--allow-chromium-download\n", " Whether to allow downloading chromium if no suitable version is found on the system.\n", " Equivalent to: [--WebPDFExporter.allow_chromium_download=True]\n", "--disable-chromium-sandbox\n", " Disable chromium security sandbox when converting to PDF..\n", " Equivalent to: [--WebPDFExporter.disable_sandbox=True]\n", "--show-input\n", " Shows code input. This flag is only useful for dejavu users.\n", " Equivalent to: [--TemplateExporter.exclude_input=False]\n", "--embed-images\n", " Embed the images as base64 dataurls in the output. This flag is only useful for the HTML/WebPDF/Slides exports.\n", " Equivalent to: [--HTMLExporter.embed_images=True]\n", "--sanitize-html\n", " Whether the HTML in Markdown cells and cell outputs should be sanitized..\n", " Equivalent to: [--HTMLExporter.sanitize_html=True]\n", "--log-level=\n", " Set the log level by value or name.\n", " Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']\n", " Default: 30\n", " Equivalent to: [--Application.log_level]\n", "--config=\n", " Full path of a config file.\n", " Default: ''\n", " Equivalent to: [--JupyterApp.config_file]\n", "--to=\n", " The export format to be used, either one of the built-in formats\n", " ['asciidoc', 'custom', 'html', 'latex', 'markdown', 'notebook', 'pdf', 'python', 'qtpdf', 'qtpng', 'rst', 'script', 'slides', 'webpdf']\n", " or a dotted object name that represents the import path for an\n", " ``Exporter`` class\n", " Default: ''\n", " Equivalent to: [--NbConvertApp.export_format]\n", "--template=\n", " Name of the template to use\n", " Default: ''\n", " Equivalent to: [--TemplateExporter.template_name]\n", "--template-file=\n", " Name of the template file to use\n", " Default: None\n", " Equivalent to: [--TemplateExporter.template_file]\n", "--theme=\n", " Template specific theme(e.g. the name of a JupyterLab CSS theme distributed\n", " as prebuilt extension for the lab template)\n", " Default: 'light'\n", " Equivalent to: [--HTMLExporter.theme]\n", "--sanitize_html=\n", " Whether the HTML in Markdown cells and cell outputs should be sanitized.This\n", " should be set to True by nbviewer or similar tools.\n", " Default: False\n", " Equivalent to: [--HTMLExporter.sanitize_html]\n", "--writer=\n", " Writer class used to write the\n", " results of the conversion\n", " Default: 'FilesWriter'\n", " Equivalent to: [--NbConvertApp.writer_class]\n", "--post=\n", " PostProcessor class used to write the\n", " results of the conversion\n", " Default: ''\n", " Equivalent to: [--NbConvertApp.postprocessor_class]\n", "--output=\n", " Overwrite base name use for output files.\n", " Supports pattern replacements '{notebook_name}'.\n", " Default: '{notebook_name}'\n", " Equivalent to: [--NbConvertApp.output_base]\n", "--output-dir=\n", " Directory to write output(s) to. Defaults\n", " to output to the directory of each notebook. To recover\n", " previous default behaviour (outputting to the current\n", " working directory) use . as the flag value.\n", " Default: ''\n", " Equivalent to: [--FilesWriter.build_directory]\n", "--reveal-prefix=\n", " The URL prefix for reveal.js (version 3.x).\n", " This defaults to the reveal CDN, but can be any url pointing to a copy\n", " of reveal.js.\n", " For speaker notes to work, this must be a relative path to a local\n", " copy of reveal.js: e.g., \"reveal.js\".\n", " If a relative path is given, it must be a subdirectory of the\n", " current directory (from which the server is run).\n", " See the usage documentation\n", " (https://nbconvert.readthedocs.io/en/latest/usage.html#reveal-js-html-slideshow)\n", " for more details.\n", " Default: ''\n", " Equivalent to: [--SlidesExporter.reveal_url_prefix]\n", "--nbformat=\n", " The nbformat version to write.\n", " Use this to downgrade notebooks.\n", " Choices: any of [1, 2, 3, 4]\n", " Default: 4\n", " Equivalent to: [--NotebookExporter.nbformat_version]\n", "\n", "Examples\n", "--------\n", "\n", " The simplest way to use nbconvert is\n", "\n", " > jupyter nbconvert mynotebook.ipynb --to html\n", "\n", " Options include ['asciidoc', 'custom', 'html', 'latex', 'markdown', 'notebook', 'pdf', 'python', 'qtpdf', 'qtpng', 'rst', 'script', 'slides', 'webpdf'].\n", "\n", " > jupyter nbconvert --to latex mynotebook.ipynb\n", "\n", " Both HTML and LaTeX support multiple output templates. LaTeX includes\n", " 'base', 'article' and 'report'. HTML includes 'basic', 'lab' and\n", " 'classic'. You can specify the flavor of the format used.\n", "\n", " > jupyter nbconvert --to html --template lab mynotebook.ipynb\n", "\n", " You can also pipe the output to stdout, rather than a file\n", "\n", " > jupyter nbconvert mynotebook.ipynb --stdout\n", "\n", " PDF is generated via latex\n", "\n", " > jupyter nbconvert mynotebook.ipynb --to pdf\n", "\n", " You can get (and serve) a Reveal.js-powered slideshow\n", "\n", " > jupyter nbconvert myslides.ipynb --to slides --post serve\n", "\n", " Multiple notebooks can be given at the command line in a couple of\n", " different ways:\n", "\n", " > jupyter nbconvert notebook*.ipynb\n", " > jupyter nbconvert notebook1.ipynb notebook2.ipynb\n", "\n", " or you can specify the notebooks list in a config file, containing::\n", "\n", " c.NbConvertApp.notebooks = [\"my_notebook.ipynb\"]\n", "\n", " > jupyter nbconvert --config mycfg.py\n", "\n", "To see all available configurables, use `--help-all`.\n", "\n" ] } ] }, { "cell_type": "code", "source": [], "metadata": { "id": "i17bc7ECJct8" }, "execution_count": null, "outputs": [] } ] }