<img src=./images/logo-row.svg />
<div align="center">
# Tile Language
</div>
Tile Language (**tile-lang**) is a concise domain-specific language designed to streamline the development of high-performance GPU/CPU kernels (e.g., GEMM, Dequant GEMM, FlashAttention, LinearAttention). By employing a Pythonic syntax with an underlying compiler infrastructure on top of [TVM](https://tvm.apache.org/), tile-lang allows developers to focus on productivity without sacrificing the low-level optimizations necessary for state-of-the-art performance.
<img src=./images/MatmulExample.png />
## Latest News
- 01/20/2025 ✨: We are excited to announce that tile-lang, a dsl for high performance AI workloads, is now open source and available to the public!
## Tested Devices
Although tile-lang aims to be portable across a range of Devices, it has been specifically tested and validated on the following devices: for NVIDIA GPUs, this includes the H100 (with Auto TMA/WGMMA support), A100, V100, RTX 4090, RTX 3090, and RTX A6000; for AMD GPUs, it includes the MI250 (with Auto MatrixCore support) and the MI300X (with Async Copy support).
## OP Implementation Examples
**tile-lang** provides the building blocks to implement a wide variety of operators. Some examples include:
- [Matrix Multiplication](./examples/gemm/)
- [Dequantization GEMM](./examples/dequantize_gemm/)
- [Flash Attention](./examples/flash_attention/)
- [Flash Linear Attention](./examples/linear_attention/)
Within the `examples` directory, you will also find additional complex kernels—such as convolutions, forward/backward passes for FlashAttention, more operators will continuously be added.
## Benchmark Summary
TileLang achieves exceptional performance across a variety of computational patterns. Comprehensive benchmark scripts and settings are available at [tilelang-benchmark](https://github.com/tile-ai/tilelang-benchmark). Below are selected results showcasing its capabilities:
- Flash Attention Performance on H100
<div align="center"> <img src="./images/mha_performance_h100.png" alt="operator performance on H100" width=80% />
</div>
- Matmul Performance on GPUs (RTX 4090, A100, H100, MI300X)
<div>
<img src="./images/op_benchmark_consistent_gemm_fp16.png" alt="gemm fp16 performance on Gpus" />
</div>
- Dequantize Matmul Performance on A100
<div>
<img src="./images/op_benchmark_a100_wq_gemv.png" alt="dequantize gemv performance on A100" />
</div>
## Installation
### Method 1: Install with Pip
The quickest way to get started is to install the latest release from PyPI:
```bash
pip install tilelang
```
Alternatively, you can install directly from the GitHub repository:
```bash
pip install git+https://github.com/tile-ai/tilelang
```
Or install locally:
```bash
pip install . # with -e option if you want to install in editable mode
```
### Method 2: Build from Source
We currently provide three ways to install **tile-lang** from source:
- [Install from Source (using your own TVM installation)](./docs/get_started/Installation.rst#method-1-install-from-source-using-your-own-tvm-installation)
- [Install from Source (using the bundled TVM submodule)](./docs/get_started/Installation.rst#method-2-install-from-source-with-our-tvm-submodule)
- [Install Using the Provided Script](./docs/get_started/Installation.rst##method-3-install-using-the-provided-script)
## Quick Start
In this section, you’ll learn how to write and execute a straightforward GEMM (matrix multiplication) kernel using tile-lang, followed by techniques for layout optimizations, pipelining, and L2-cache–friendly swizzling.
### GEMM Example with Annotations (Layout, L2 Cache Swizzling, and Pipelining, etc.)
Below is an example that demonstrates more advanced features: layout annotation, parallelized copy, and swizzle for improved L2 cache locality. This snippet shows how to adapt your kernel to maximize performance on complex hardware.
```python
import tilelang
import tilelang.language as T
# `make_mma_swizzle_layout` is a python defined layout function
# specifically designed for for MMA operations
# which ensures the consistency with the nvidia CUTLASS Library.
# to avoid bank conflicts and maximize the performance.
from tilelang.intrinsics import (
make_mma_swizzle_layout as make_swizzle_layout,)
def matmul(M, N, K, block_M, block_N, block_K, dtype="float16", accum_dtype="float"):
# add decorator @tilelang.jit if you want to return a torch function
@T.prim_func
def main(
A: T.Buffer((M, K), dtype),
B: T.Buffer((K, N), dtype),
C: T.Buffer((M, N), dtype),
):
# Initialize Kernel Context
with T.Kernel(T.ceildiv(N, block_N), T.ceildiv(M, block_M), threads=128) as (bx, by):
A_shared = T.alloc_shared((block_M, block_K), dtype)
B_shared = T.alloc_shared((block_K, block_N), dtype)
C_local = T.alloc_fragment((block_M, block_N), accum_dtype)
# Apply layout optimizations or define your own layout (Optional)
# If not specified, we will deduce the layout automatically
# T.annotate_layout({
# A_shared: make_swizzle_layout(A_shared),
# B_shared: make_swizzle_layout(B_shared),
# })
# Enable rasterization for better L2 cache locality (Optional)
# T.use_swizzle(panel_size=10, enable=True)
# Clear local accumulation
T.clear(C_local)
for ko in T.Pipelined(T.ceildiv(K, block_K), num_stages=3):
# Copy tile of A
# This is a sugar syntax for parallelized copy
T.copy(A[by * block_M, ko * block_K], A_shared)
# Demonstrate parallelized copy from global to shared for B
for k, j in T.Parallel(block_K, block_N):
B_shared[k, j] = B[ko * block_K + k, bx * block_N + j]
# Perform a tile-level GEMM on the shared buffers
# Currently we dispatch to the cute/hip on Nvidia/AMD GPUs
T.gemm(A_shared, B_shared, C_local)
# Copy result back to global memory
T.copy(C_local, C[by * block_M, bx * block_N])
return main
# 1. Define the kernel (matmul) with the desired dimensions
func = matmul(1024, 1024, 1024, 128, 128, 32)
# 2. Compile the kernel into a torch function
# out_idx specifies the index of the output buffer in the argument list
# if out_idx is specified, the tensor will be created during runtime
# target currently can be "cuda" or "hip" or "cpu".
jit_kernel = tilelang.JITKernel(func, out_idx=[2], target="cuda")
# 3. Test the kernel in Python with PyTorch data
import torch
# Create random input tensors on the GPU
a = torch.randn(1024, 1024, device="cuda", dtype=torch.float16)
b = torch.randn(1024, 1024, device="cuda", dtype=torch.float16)
# Run the kernel through the JIT-compiled function
c = jit_kernel(a, b)
# Reference multiplication using PyTorch
ref_c = a @ b
# Validate correctness
torch.testing.assert_close(c, ref_c, rtol=1e-2, atol=1e-2)
print("Kernel output matches PyTorch reference.")
# 4. Retrieve and inspect the generated CUDA source (optional)
cuda_source = jit_kernel.get_kernel_source()
print("Generated CUDA kernel:\n", cuda_source)
# 5.Pofile latency with the profiler
profiler = jit_kernel.get_profiler()
latency = profiler.do_bench()
print(f"Latency: {latency} ms")
```
### Dive Deep into TileLang Beyond GEMM
In addition to GEMM, we provide a variety of examples to showcase the versatility and power of TileLang, including:
- [Dequantize GEMM](./examples/dequantize_gemm/): Achieve high-performance dequantization by **fine-grained control over per-thread operations**, with many features now adopted as default behaviors in [BitBLAS](https://github.com/microsoft/BitBLAS), which utilizing magic layout transformation and intrins to accelerate dequantize gemm.
- [FlashAttention](./examples/flash_attention/): Enable cross-operator fusion with simple and intuitive syntax, and we also provide an example of auto tuning.
- [LinearAttention](./examples/linear_attention/): Examples include RetNet and Mamba implementations.
- [Convolution](./examples/convolution/): Implementations of Convolution with IM2Col.
---
TileLang has now been used in project [BitBLAS](https://github.com/microsoft/BitBLAS) and [AttentionEngine](https://github.com/microsoft/AttentionEngine).
## Join the Discussion
Welcome to join our Discord community for discussions, support, and collaboration!
[](https://discord.gg/TUrHyJnKPG)
## Acknowledgements
We would like to express our gratitude to the [TVM](https://github.com/apache/tvm) community for their invaluable contributions. The initial version of this project was mainly developed by [LeiWang1999](https://github.com/LeiWang1999), [chengyupku](https://github.com/chengyupku) and [nox-410](https://github.com/nox-410) with supervision from Prof. [Zhi Yang](https://yangzhihome.github.io) at Peking University. Part of this work was carried out during an internship at Microsoft Research, where Dr. Lingxiao Ma, Dr. Yuqing Xia, Dr. Jilong Xue, and Dr. Fan Yang offered valuable advice and support. We deeply appreciate their mentorship and contributions.
Raw data
{
"_id": null,
"home_page": "https://github.com/tile-ai/tilelang",
"name": "tilelang",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.8",
"maintainer_email": null,
"keywords": "BLAS, CUDA, HIP, Code Generation, TVM",
"author": "Microsoft Research",
"author_email": null,
"download_url": null,
"platform": "Environment :: GPU :: NVIDIA CUDA",
"description": "<img src=./images/logo-row.svg />\n\n<div align=\"center\">\n\n# Tile Language\n\n</div>\n\nTile Language (**tile-lang**) is a concise domain-specific language designed to streamline the development of high-performance GPU/CPU kernels (e.g., GEMM, Dequant GEMM, FlashAttention, LinearAttention). By employing a Pythonic syntax with an underlying compiler infrastructure on top of [TVM](https://tvm.apache.org/), tile-lang allows developers to focus on productivity without sacrificing the low-level optimizations necessary for state-of-the-art performance.\n\n<img src=./images/MatmulExample.png />\n\n## Latest News\n- 01/20/2025 \u2728: We are excited to announce that tile-lang, a dsl for high performance AI workloads, is now open source and available to the public!\n\n## Tested Devices\nAlthough tile-lang aims to be portable across a range of Devices, it has been specifically tested and validated on the following devices: for NVIDIA GPUs, this includes the H100 (with Auto TMA/WGMMA support), A100, V100, RTX 4090, RTX 3090, and RTX A6000; for AMD GPUs, it includes the MI250 (with Auto MatrixCore support) and the MI300X (with Async Copy support).\n\n## OP Implementation Examples\n**tile-lang** provides the building blocks to implement a wide variety of operators. Some examples include:\n\n- [Matrix Multiplication](./examples/gemm/)\n- [Dequantization GEMM](./examples/dequantize_gemm/)\n- [Flash Attention](./examples/flash_attention/)\n- [Flash Linear Attention](./examples/linear_attention/)\n\nWithin the `examples` directory, you will also find additional complex kernels\u2014such as convolutions, forward/backward passes for FlashAttention, more operators will continuously be added.\n\n\n## Benchmark Summary\n\nTileLang achieves exceptional performance across a variety of computational patterns. Comprehensive benchmark scripts and settings are available at [tilelang-benchmark](https://github.com/tile-ai/tilelang-benchmark). Below are selected results showcasing its capabilities:\n\n- Flash Attention Performance on H100\n\n <div align=\"center\"> <img src=\"./images/mha_performance_h100.png\" alt=\"operator performance on H100\" width=80% />\n </div>\n\n- Matmul Performance on GPUs (RTX 4090, A100, H100, MI300X)\n\n <div>\n <img src=\"./images/op_benchmark_consistent_gemm_fp16.png\" alt=\"gemm fp16 performance on Gpus\" />\n </div>\n\n- Dequantize Matmul Performance on A100\n\n <div>\n <img src=\"./images/op_benchmark_a100_wq_gemv.png\" alt=\"dequantize gemv performance on A100\" />\n </div>\n\n## Installation\n### Method 1: Install with Pip\n\nThe quickest way to get started is to install the latest release from PyPI:\n\n```bash\npip install tilelang\n```\n\nAlternatively, you can install directly from the GitHub repository:\n\n```bash\npip install git+https://github.com/tile-ai/tilelang\n```\n\nOr install locally:\n\n```bash\npip install . # with -e option if you want to install in editable mode\n```\n\n### Method 2: Build from Source\nWe currently provide three ways to install **tile-lang** from source:\n - [Install from Source (using your own TVM installation)](./docs/get_started/Installation.rst#method-1-install-from-source-using-your-own-tvm-installation)\n - [Install from Source (using the bundled TVM submodule)](./docs/get_started/Installation.rst#method-2-install-from-source-with-our-tvm-submodule)\n - [Install Using the Provided Script](./docs/get_started/Installation.rst##method-3-install-using-the-provided-script)\n\n\n## Quick Start\n\nIn this section, you\u2019ll learn how to write and execute a straightforward GEMM (matrix multiplication) kernel using tile-lang, followed by techniques for layout optimizations, pipelining, and L2-cache\u2013friendly swizzling.\n\n### GEMM Example with Annotations (Layout, L2 Cache Swizzling, and Pipelining, etc.)\n\nBelow is an example that demonstrates more advanced features: layout annotation, parallelized copy, and swizzle for improved L2 cache locality. This snippet shows how to adapt your kernel to maximize performance on complex hardware.\n\n```python\nimport tilelang\nimport tilelang.language as T\n# `make_mma_swizzle_layout` is a python defined layout function\n# specifically designed for for MMA operations\n# which ensures the consistency with the nvidia CUTLASS Library.\n# to avoid bank conflicts and maximize the performance.\nfrom tilelang.intrinsics import (\n make_mma_swizzle_layout as make_swizzle_layout,)\n\ndef matmul(M, N, K, block_M, block_N, block_K, dtype=\"float16\", accum_dtype=\"float\"):\n # add decorator @tilelang.jit if you want to return a torch function\n @T.prim_func\n def main(\n A: T.Buffer((M, K), dtype),\n B: T.Buffer((K, N), dtype),\n C: T.Buffer((M, N), dtype),\n ):\n # Initialize Kernel Context\n with T.Kernel(T.ceildiv(N, block_N), T.ceildiv(M, block_M), threads=128) as (bx, by):\n A_shared = T.alloc_shared((block_M, block_K), dtype)\n B_shared = T.alloc_shared((block_K, block_N), dtype)\n C_local = T.alloc_fragment((block_M, block_N), accum_dtype)\n\n # Apply layout optimizations or define your own layout (Optional)\n # If not specified, we will deduce the layout automatically\n # T.annotate_layout({\n # A_shared: make_swizzle_layout(A_shared),\n # B_shared: make_swizzle_layout(B_shared),\n # })\n\n # Enable rasterization for better L2 cache locality (Optional)\n # T.use_swizzle(panel_size=10, enable=True)\n\n # Clear local accumulation\n T.clear(C_local)\n\n for ko in T.Pipelined(T.ceildiv(K, block_K), num_stages=3):\n # Copy tile of A\n # This is a sugar syntax for parallelized copy\n T.copy(A[by * block_M, ko * block_K], A_shared)\n\n # Demonstrate parallelized copy from global to shared for B\n for k, j in T.Parallel(block_K, block_N):\n B_shared[k, j] = B[ko * block_K + k, bx * block_N + j]\n\n # Perform a tile-level GEMM on the shared buffers\n # Currently we dispatch to the cute/hip on Nvidia/AMD GPUs\n T.gemm(A_shared, B_shared, C_local)\n\n # Copy result back to global memory\n T.copy(C_local, C[by * block_M, bx * block_N])\n\n return main\n\n\n# 1. Define the kernel (matmul) with the desired dimensions\nfunc = matmul(1024, 1024, 1024, 128, 128, 32)\n\n# 2. Compile the kernel into a torch function\n# out_idx specifies the index of the output buffer in the argument list\n# if out_idx is specified, the tensor will be created during runtime\n# target currently can be \"cuda\" or \"hip\" or \"cpu\".\njit_kernel = tilelang.JITKernel(func, out_idx=[2], target=\"cuda\")\n\n# 3. Test the kernel in Python with PyTorch data\nimport torch\n\n# Create random input tensors on the GPU\na = torch.randn(1024, 1024, device=\"cuda\", dtype=torch.float16)\nb = torch.randn(1024, 1024, device=\"cuda\", dtype=torch.float16)\n\n\n# Run the kernel through the JIT-compiled function\nc = jit_kernel(a, b)\n\n# Reference multiplication using PyTorch\nref_c = a @ b\n\n# Validate correctness\ntorch.testing.assert_close(c, ref_c, rtol=1e-2, atol=1e-2)\nprint(\"Kernel output matches PyTorch reference.\")\n\n# 4. Retrieve and inspect the generated CUDA source (optional)\ncuda_source = jit_kernel.get_kernel_source()\nprint(\"Generated CUDA kernel:\\n\", cuda_source)\n\n# 5.Pofile latency with the profiler\nprofiler = jit_kernel.get_profiler()\n\nlatency = profiler.do_bench()\n\nprint(f\"Latency: {latency} ms\")\n```\n\n### Dive Deep into TileLang Beyond GEMM\n\nIn addition to GEMM, we provide a variety of examples to showcase the versatility and power of TileLang, including:\n\n- [Dequantize GEMM](./examples/dequantize_gemm/): Achieve high-performance dequantization by **fine-grained control over per-thread operations**, with many features now adopted as default behaviors in [BitBLAS](https://github.com/microsoft/BitBLAS), which utilizing magic layout transformation and intrins to accelerate dequantize gemm.\n- [FlashAttention](./examples/flash_attention/): Enable cross-operator fusion with simple and intuitive syntax, and we also provide an example of auto tuning.\n- [LinearAttention](./examples/linear_attention/): Examples include RetNet and Mamba implementations.\n- [Convolution](./examples/convolution/): Implementations of Convolution with IM2Col.\n\n---\n\nTileLang has now been used in project [BitBLAS](https://github.com/microsoft/BitBLAS) and [AttentionEngine](https://github.com/microsoft/AttentionEngine).\n\n## Join the Discussion\n\nWelcome to join our Discord community for discussions, support, and collaboration!\n\n[](https://discord.gg/TUrHyJnKPG)\n\n## Acknowledgements\n\nWe would like to express our gratitude to the [TVM](https://github.com/apache/tvm) community for their invaluable contributions. The initial version of this project was mainly developed by [LeiWang1999](https://github.com/LeiWang1999), [chengyupku](https://github.com/chengyupku) and [nox-410](https://github.com/nox-410) with supervision from Prof. [Zhi Yang](https://yangzhihome.github.io) at Peking University. Part of this work was carried out during an internship at Microsoft Research, where Dr. Lingxiao Ma, Dr. Yuqing Xia, Dr. Jilong Xue, and Dr. Fan Yang offered valuable advice and support. We deeply appreciate their mentorship and contributions.\n",
"bugtrack_url": null,
"license": "MIT",
"summary": "A tile level programming language to generate high performance code.",
"version": "0.1.0",
"project_urls": {
"Homepage": "https://github.com/tile-ai/tilelang"
},
"split_keywords": [
"blas",
" cuda",
" hip",
" code generation",
" tvm"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "28d8134beef21b087176642d58b319b0eb69b567fc6bf5ac9015f73be7c60729",
"md5": "7f37532ca1b1f82bfde7c2bf83bbb4cb",
"sha256": "6cc3bbea5553167868981f27e0510c783e99eec7799939efa1989767243ba574"
},
"downloads": -1,
"filename": "tilelang-0.1.0-cp310-cp310-manylinux1_x86_64.whl",
"has_sig": false,
"md5_digest": "7f37532ca1b1f82bfde7c2bf83bbb4cb",
"packagetype": "bdist_wheel",
"python_version": "cp310",
"requires_python": ">=3.8",
"size": 73401410,
"upload_time": "2025-02-12T06:05:18",
"upload_time_iso_8601": "2025-02-12T06:05:18.542906Z",
"url": "https://files.pythonhosted.org/packages/28/d8/134beef21b087176642d58b319b0eb69b567fc6bf5ac9015f73be7c60729/tilelang-0.1.0-cp310-cp310-manylinux1_x86_64.whl",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-02-12 06:05:18",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "tile-ai",
"github_project": "tilelang",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"requirements": [
{
"name": "Cython",
"specs": []
},
{
"name": "decorator",
"specs": []
},
{
"name": "numpy",
"specs": [
[
">=",
"1.23.5"
]
]
},
{
"name": "tqdm",
"specs": [
[
">=",
"4.62.3"
]
]
},
{
"name": "typing_extensions",
"specs": [
[
">=",
"4.10.0"
]
]
},
{
"name": "attrs",
"specs": []
},
{
"name": "cloudpickle",
"specs": []
},
{
"name": "ml_dtypes",
"specs": []
},
{
"name": "psutil",
"specs": []
},
{
"name": "torch",
"specs": []
}
],
"lcname": "tilelang"
}
JSON
