Add files using upload-large-folder tool

sglang_repo/.gitignore

@@ -0,0 +1,229 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+.idea/
+
+# MacOS
+.DS_Store
+
+# Vim
+*.swp
+
+# Documentation
+docs/_build
+
+# SGL
+benchmark/mmlu/data
+benchmark/mmlu/data.tar
+benchmark/llava_bench/images
+benchmark/llava_bench/mme_pack
+*.jsonl
+tmp*.txt
+
+# Plots
+*.png
+*.pdf
+
+# personnal
+work_dirs/
+*.csv
+
+!logo.png
+
+# Prerequisites
+*.d
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.dll
+
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app
+
+compile_commands.json
+
+*.iml
+
+# VSCode
+.vscode
+
+1

sglang_repo/.gitmodules

@@ -0,0 +1,12 @@
+[submodule "sgl-kernel/3rdparty/cutlass"]
+	path = sgl-kernel/3rdparty/cutlass
+	url = https://github.com/NVIDIA/cutlass.git
+[submodule "sgl-kernel/3rdparty/cccl"]
+	path = sgl-kernel/3rdparty/cccl
+	url = https://github.com/NVIDIA/cccl.git
+[submodule "sgl-kernel/3rdparty/flashinfer"]
+	path = sgl-kernel/3rdparty/flashinfer
+	url = https://github.com/flashinfer-ai/flashinfer.git
+[submodule "sgl-kernel/3rdparty/turbomind"]
+	path = sgl-kernel/3rdparty/turbomind
+	url = https://github.com/InternLM/turbomind

sglang_repo/sgl-kernel/3rdparty/flashinfer/.gitignore

@@ -0,0 +1,185 @@
+# ci
+flashinfer-whl/
+dist/
+
+# Compile commands json file
+compile_commands.json
+
+# Generated files
+csrc/generated/
+docs/generated/
+flashinfer/_build_meta.py
+flashinfer/data/
+flashinfer/jit/aot_config.py
+src/generated/
+csrc/aot_default_additional_params.h
+
+# DS_Store files
+.DS_store
+
+# Microbenchmark files
+microbenchmark/
+
+# vscode
+.vscode/
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

sglang_repo/sgl-kernel/3rdparty/flashinfer/.gitmodules

@@ -0,0 +1,18 @@
+[submodule "3rdparty/nvbench"]
+	path = 3rdparty/nvbench
+	url = https://github.com/NVIDIA/nvbench.git
+[submodule "3rdparty/googletest"]
+	path = 3rdparty/googletest
+	url = https://github.com/google/googletest.git
+[submodule "3rdparty/mscclpp"]
+	path = 3rdparty/mscclpp
+	url = https://github.com/microsoft/mscclpp.git
+[submodule "3rdparty/cutlass"]
+	path = 3rdparty/cutlass
+	url = https://github.com/NVIDIA/cutlass.git
+[submodule "3rdparty/composable_kernels"]
+	path = 3rdparty/composable_kernels
+	url = https://github.com/ROCm/composable_kernel.git
+[submodule "3rdparty/spdlog"]
+	path = 3rdparty/spdlog
+	url = https://github.com/gabime/spdlog.git

sglang_repo/sgl-kernel/3rdparty/flashinfer/.pre-commit-config.yaml

@@ -0,0 +1,61 @@
+# To use:
+#
+#     pre-commit run -a
+#
+# Or:
+#
+#     pre-commit install  # (runs every time you commit in git)
+#
+# To update this file:
+#
+#     pre-commit autoupdate
+#
+# See https://github.com/pre-commit/pre-commit
+# Note the pre-commit hooks shoule only be used for formatting, but not for linting.
+# For linting consider using CI.
+repos:
+  # Standard hooks
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: check-added-large-files
+      - id: check-case-conflict
+      - id: check-merge-conflict
+      - id: check-symlinks
+      - id: end-of-file-fixer
+      - id: mixed-line-ending
+      - id: requirements-txt-fixer
+      - id: trailing-whitespace
+
+  # Changes tabs to spaces
+  - repo: https://github.com/Lucas-C/pre-commit-hooks
+    rev: v1.5.5
+    hooks:
+      - id: remove-tabs
+      - id: remove-crlf
+
+  # Formatters
+  - repo: https://github.com/psf/black-pre-commit-mirror
+    rev: 24.8.0
+    hooks:
+      - id: black
+
+  - repo: https://github.com/pycqa/isort
+    rev: 5.13.2
+    hooks:
+      - id: isort
+        args: ["--profile=black"] # <-- this one
+
+  - repo: https://github.com/pre-commit/mirrors-clang-format
+    rev: v19.1.1
+    hooks:
+      - id: clang-format
+        types_or: [c++, c, cuda]
+        exclude: |
+          (?x)^(3rdparty/.* src/generated/.* flashinfer/jit/aot_config.py)$
+
+  - repo: https://github.com/cheshirekow/cmake-format-precommit
+    rev: v0.6.13
+    hooks:
+      - id: cmake-format
+        additional_dependencies: [pyyaml>=5.1]

sglang_repo/sgl-kernel/3rdparty/flashinfer/CHANGELOG.md

@@ -0,0 +1,374 @@
+# Changelog
+
+## [0.2.0.post1](https://github.com/flashinfer-ai/flashinfer/compare/v0.2.0...v0.2.0.post1) (2024-12-22)
+
+### Bug Fixes
+
+* bug fix on determine_attention_backend condition ([#688](https://github.com/flashinfer-ai/flashinfer/pull/688)) ([bcf7a3e](https://github.com/flashinfer-ai/flashinfer/commit/bcf7a3ee0d919eca45d2f07241479b5776975bc3))
+* accelerate plan speed of fa3 template ([#690](https://github.com/flashinfer-ai/flashinfer/pull/690)) ([db8f04d](https://github.com/flashinfer-ai/flashinfer/commit/db8f04d30989f57acef3fbde41cbd3ce373727f1))
+
+## [0.2.0](https://github.com/flashinfer-ai/flashinfer/compare/v0.1.6...v0.2.0) (2024-12-17)
+
+### Release Blog
+
+[FlashInfer 0.2 - Efficient and Customizable Kernels for LLM Inference Serving](https://flashinfer.ai/2024/12/16/flashinfer-v02-release.html)
+
+### Features
+
+* add `rotary_dim` argument to rope APIs for partial apply rope ([#599](https://github.com/flashinfer-ai/flashinfer/issues/599)) ([eb9bc71](https://github.com/flashinfer-ai/flashinfer/commit/eb9bc710ce875dd276109b6b62745fc1282f1541))
+* add a `use_softmax` field in variant class ([#533](https://github.com/flashinfer-ai/flashinfer/issues/533)) ([d81af97](https://github.com/flashinfer-ai/flashinfer/commit/d81af9775e56bb30152b17770e804823cddfc279))
+* add an option `non_blocking` to plan function ([#622](https://github.com/flashinfer-ai/flashinfer/issues/622)) ([560af6f](https://github.com/flashinfer-ai/flashinfer/commit/560af6f687524a2415eb94ad333b65b9461a47b1))
+* add gemma_rmsnorm and gemma_fused_add_rmsnorm ([#477](https://github.com/flashinfer-ai/flashinfer/issues/477)) ([1a6b17e](https://github.com/flashinfer-ai/flashinfer/commit/1a6b17e2b78fc811d50030b9326a4d01f1ff956f))
+* add group size 3 to GQA decode dispatch ([#558](https://github.com/flashinfer-ai/flashinfer/issues/558)) ([6227562](https://github.com/flashinfer-ai/flashinfer/commit/62275625f9332e40a69789467835cbb376f2940d))
+* add JIT compilation support for FA3 templates ([#672](https://github.com/flashinfer-ai/flashinfer/issues/672)) ([d4e8d79](https://github.com/flashinfer-ai/flashinfer/commit/d4e8d79b340589633943bebd827da17b3f4c29ad))
+* allow the cascade kernels to be executed using varying sequence lengths ([#627](https://github.com/flashinfer-ai/flashinfer/issues/627)) ([92ac440](https://github.com/flashinfer-ai/flashinfer/commit/92ac4401d434e988ec8aeb769ecf3ff575c32983))
+* CUDAGraph compatibility of multi-level cascade inference APIs ([#586](https://github.com/flashinfer-ai/flashinfer/issues/586)) ([2332e8a](https://github.com/flashinfer-ai/flashinfer/commit/2332e8ae477656b2be060465b30c30b5dee389b9))
+* fix the maximal grid dimension in prefill planning with CUDA graphs ([#639](https://github.com/flashinfer-ai/flashinfer/issues/639)) ([86ca89a](https://github.com/flashinfer-ai/flashinfer/commit/86ca89a60f1bf1eb566cb9e45d21e4c8f174c251))
+* improve the precision of the FusedAddRMSNormKernel function ([#587](https://github.com/flashinfer-ai/flashinfer/issues/587)) ([c7dc921](https://github.com/flashinfer-ai/flashinfer/commit/c7dc921f9323d2f767fd8e9d9d0ab4c1d95ad1b5))
+* JIT compilation ([#507](https://github.com/flashinfer-ai/flashinfer/issues/507)) ([3613a5b](https://github.com/flashinfer-ai/flashinfer/commit/3613a5bd829234863a96bc23e3bd2a1da345a592))
+* modify group-gemm stage number ([#497](https://github.com/flashinfer-ai/flashinfer/issues/497)) ([52dab1d](https://github.com/flashinfer-ai/flashinfer/commit/52dab1d4a4d7e5d910a8c695de911d979d6f2038))
+* non-contiguous query with paged kv cache ([#553](https://github.com/flashinfer-ai/flashinfer/issues/553)) ([89f2c4a](https://github.com/flashinfer-ai/flashinfer/commit/89f2c4a816ff133e09cb9fc1d7c3de43d4431ffd))
+* pass a dynamic token count to the cascade kernels ([#635](https://github.com/flashinfer-ai/flashinfer/issues/635)) ([5fe9f7d](https://github.com/flashinfer-ai/flashinfer/commit/5fe9f7d1d1ab8aa13cb6073a6447e383ad52b484))
+* simplify prefill JIT compilation ([#605](https://github.com/flashinfer-ai/flashinfer/issues/605)) ([fe4f898](https://github.com/flashinfer-ai/flashinfer/commit/fe4f8980223a92cc918f2e6041df854fcebefbc9))
+* specify gemm backend ([#648](https://github.com/flashinfer-ai/flashinfer/issues/648)) ([0cc1a51](https://github.com/flashinfer-ai/flashinfer/commit/0cc1a51757e73a4f4a1be9f2e7ac0e0f2c156056))
+* support cached cos/sin in rope APIs ([#585](https://github.com/flashinfer-ai/flashinfer/issues/585)) ([83e541d](https://github.com/flashinfer-ai/flashinfer/commit/83e541d8fa2b15ff23c8c68c136fa5023e2c977d))
+* support huggingface transformer style rope interface ([#568](https://github.com/flashinfer-ai/flashinfer/issues/568)) ([4f40420](https://github.com/flashinfer-ai/flashinfer/commit/4f40420e24d65cabd8be731e12f96a5ef0795a4b))
+* support sm90 cutlass group gemm ([#509](https://github.com/flashinfer-ai/flashinfer/issues/509)) ([794bdda](https://github.com/flashinfer-ai/flashinfer/commit/794bdda1ea2d62d4d2c0e858553058ad890ee5e3))
+* torch custom_op fix for rope ([#569](https://github.com/flashinfer-ai/flashinfer/issues/569)) ([3e104bc](https://github.com/flashinfer-ai/flashinfer/commit/3e104bc7769735af83ffc709fe1f7a641f2471da))
+* torch custom_op support: norm ([#552](https://github.com/flashinfer-ai/flashinfer/issues/552)) ([f6e0010](https://github.com/flashinfer-ai/flashinfer/commit/f6e0010833f54a5b8181a9232588649f0b3c182e))
+* torch.compile and custom_op support ([#554](https://github.com/flashinfer-ai/flashinfer/issues/554)) ([9bf916f](https://github.com/flashinfer-ai/flashinfer/commit/9bf916f236139f5b6410e298615d0db152e82409))
+* warmup for jit kernel tests ([#629](https://github.com/flashinfer-ai/flashinfer/issues/629)) ([8f5f349](https://github.com/flashinfer-ai/flashinfer/commit/8f5f3491c523f5c43623d3cd3eaa42854f47ad76))
+
+
+### Bug Fixes
+
+* AOT compiler flags on non-sm90 ([#522](https://github.com/flashinfer-ai/flashinfer/issues/522)) ([0aa4726](https://github.com/flashinfer-ai/flashinfer/commit/0aa47269f9f06f20e4a15662931972c9a2de482f))
+* batch decode kernel redundant store output to gmem ([#505](https://github.com/flashinfer-ai/flashinfer/issues/505)) ([90e42a7](https://github.com/flashinfer-ai/flashinfer/commit/90e42a7307dad08bc1f800efb3d73a3bd22a0824))
+* compatible with torch 2.2 ([#478](https://github.com/flashinfer-ai/flashinfer/issues/478)) ([ac41d1b](https://github.com/flashinfer-ai/flashinfer/commit/ac41d1bdc72ed4614c9eafb8644d45b234260005))
+* https://github.com/flashinfer-ai/flashinfer/issues/452 ([b53a46f](https://github.com/flashinfer-ai/flashinfer/commit/b53a46f8b073e66fbc8fe888e87517b3aea8bd2d))
+* remove redundant load ([#495](https://github.com/flashinfer-ai/flashinfer/issues/495)) ([2de16b0](https://github.com/flashinfer-ai/flashinfer/commit/2de16b0f4afbb9d3c5725187ee2f14ef08fa364f))
+* update bmm fp8 test ([#487](https://github.com/flashinfer-ai/flashinfer/issues/487)) ([45eac04](https://github.com/flashinfer-ai/flashinfer/commit/45eac04f9420b2372737d16d51f4d07bf928d293))
+
+
+### Performance Improvements
+
+* accelerate JIT compilation speed ([#618](https://github.com/flashinfer-ai/flashinfer/issues/618)) ([eaf73fd](https://github.com/flashinfer-ai/flashinfer/commit/eaf73fd0246f32f214f1db6ed8143bf8a503aae4))
+* Dense and sparse customizable flashattention-3 template ([#667](https://github.com/flashinfer-ai/flashinfer/issues/667)) ([51236c9](https://github.com/flashinfer-ai/flashinfer/commit/51236c913107f2f6098ac039a4aaa4841a443c25))
+* fix prefill kernel performance degradation (step 1) ([#602](https://github.com/flashinfer-ai/flashinfer/issues/602)) ([595cf60](https://github.com/flashinfer-ai/flashinfer/commit/595cf602e73688d2f96f8cf1aad7cb2fce689d41))
+* fix the performance issue of `append_paged_kv_cache` ([#588](https://github.com/flashinfer-ai/flashinfer/issues/588)) ([e15f7c9](https://github.com/flashinfer-ai/flashinfer/commit/e15f7c984bc4152c0b65cfec916ace37c98668cd))
+* improve parallelism in RoPE with pos_ids ([#609](https://github.com/flashinfer-ai/flashinfer/issues/609)) ([ff05155](https://github.com/flashinfer-ai/flashinfer/commit/ff05155581f5e085b573f803aed398434859e22f))
+* improve plan performance by using non-blocking memcpy ([#547](https://github.com/flashinfer-ai/flashinfer/issues/547)) ([41ebe6d](https://github.com/flashinfer-ai/flashinfer/commit/41ebe6dce7c505801853a27246feea2e06500620))
+* reduce the read and write of shared memory in the FusedAddRMSNormKernel ([#592](https://github.com/flashinfer-ai/flashinfer/issues/592)) ([2043ca2](https://github.com/flashinfer-ai/flashinfer/commit/2043ca2181d1e9119a1fb8b86a739c245be5b536))
+* reduce total_num_tiles_q by one ([#644](https://github.com/flashinfer-ai/flashinfer/issues/644)) ([553ace5](https://github.com/flashinfer-ai/flashinfer/commit/553ace5eb91fc07681fa9edf8b6c09827a72617a))
+* remove unnecessary contiguous operation in block sparse attention ([#561](https://github.com/flashinfer-ai/flashinfer/issues/561)) ([7a7ad46](https://github.com/flashinfer-ai/flashinfer/commit/7a7ad4659a7b7e1a78eebbb9bb8af6c21130f14e))
+* speedup jit compilation of prefill attention kernels ([#632](https://github.com/flashinfer-ai/flashinfer/issues/632)) ([a059586](https://github.com/flashinfer-ai/flashinfer/commit/a0595866db384b4a782c1ec70df72251b17de287))
+* use cuda-core implementation for io-bound block-sparse attention ([#560](https://github.com/flashinfer-ai/flashinfer/issues/560)) ([3fbf028](https://github.com/flashinfer-ai/flashinfer/commit/3fbf02800e6166d2bf9e1de1cfa6ac826fa4618d))
+
+## [0.1.6](https://github.com/flashinfer-ai/flashinfer/compare/v0.1.5...v0.1.6) (2024-08-27)
+
+### SM75 Support
+
+Starting from [0.1.6](https://github.com/flashinfer-ai/flashinfer/compare/v0.1.5...v0.1.6), our pre-built wheels include experimental support sm75 (Turing architecture GPUs such as Tesla T4, Quadro RTX 6000 and RTX 2080).
+
+### API Changes
+
+#### `plan`/`run`
+
+Since [0.1.6](https://github.com/flashinfer-ai/flashinfer/compare/v0.1.5...v0.1.6) on, `begin_forward`/`forward`/`end_forward` APIs are replaced with the new `plan`/`run` API.
+- `forward` is renamed to `run`, which is more precise and consistent with the naming convention of cutlass's python API.
+- `begin_forward` is renamed to `plan`, which is consistent with the naming convention of nvmath API.
+- `end_forward` is deprecated and has no effect after this PR.
+
+There is some slight difference between the old `forward` and the new `run` API:
+- All extra arguments such as `causal` and `logits_soft_cap` will be provided in `plan` (previously `begin_forward`) API, and cached until next `plan` call, and we only need to provide query and KV-Cache tensors in `run` API.
+
+The old `begin_forward`/`forward`/`end_forward` APIs are still functional, but we will gradually deprecate them in future releases.
+
+Check [#466](https://github.com/flashinfer-ai/flashinfer/pull/466) for more details.
+
+#### `MultiLevelCascadeAttentionWrapper`
+
+Since [0.1.6](https://github.com/flashinfer-ai/flashinfer/compare/v0.1.5...v0.1.6) on, we introduce a new `MultiLevelCascadeAttentionWrapper` API for cascade inference,
+which supports multi-level cascade inference where all levels' KV-Cache can be managed in a unified Paged KV-Cache.
+
+See [documentation](https://docs.flashinfer.ai/api/python/cascade.html#flashinfer.cascade.MultiLevelCascadeAttentionWrapper) and [tutorial](https://docs.flashinfer.ai/tutorials/kv_layout.html#multi-level-cascade-inference-data-layout) on API usage and layout explanation.
+
+The old `BatchDecodeWithSharedPrefixPagedKVCacheWrapper` and `BatchPrefillWithSharedPrefixPagedKVCacheWrapper` will be deprecated in future releases.
+
+### Features
+
+* sm75 support ([#448](https://github.com/flashinfer-ai/flashinfer/pull/448), [#449](https://github.com/flashinfer-ai/flashinfer/pull/449))
+* add `MultiLevelCascadeAttentionWrapper` API ([#462](https://github.com/flashinfer-ai/flashinfer/issues/462)) ([1e37989](https://github.com/flashinfer-ai/flashinfer/commit/1e379898a589cdd4ff18a4621fcbe18d63501545))
+* add accept num, emit num metric for ChainSpeculativeSampling ([#450](https://github.com/flashinfer-ai/flashinfer/issues/450)) ([fa38b5e](https://github.com/flashinfer-ai/flashinfer/commit/fa38b5e34b9591bd5ab07186bea229ea95307755))
+* support bmm fp8 ([#469](https://github.com/flashinfer-ai/flashinfer/issues/469)) ([f1c0b68](https://github.com/flashinfer-ai/flashinfer/commit/f1c0b68d0f4a77ff3bf705307b3529b996fc9826))
+
+### Refactor
+
+* refactor: replace `begin_forward`/`forward`/`end_forward` with `plan`/`run` [#466](https://github.com/flashinfer-ai/flashinfer/pull/466)
+
+### Misc
+
+* misc: improve error handling of sampling kernels ([#456](https://github.com/flashinfer-ai/flashinfer/pull/456)) ([0dce178](https://github.com/flashinfer-ai/flashinfer/commit/0dce178389e5e85b1d40212b1d12d1754304e46))
+
+### Performance Improvements
+
+* slight optimization on f16->f8 fragment layout swizzling ([#453](https://github.com/flashinfer-ai/flashinfer/issues/453)) ([0d61871](https://github.com/flashinfer-ai/flashinfer/commit/0d618712faff20a84bbd513d02ac01e16be19306))
+* slight optimization on fragment layout swizzle ([#458](https://github.com/flashinfer-ai/flashinfer/issues/458)) ([7c397cb](https://github.com/flashinfer-ai/flashinfer/commit/7c397cbd81d4fa5da8aef9f105576dbe67f6c22b))
+* use persistent kernel for merging attention states ([#459](https://github.com/flashinfer-ai/flashinfer/issues/459)) ([be6bf5b](https://github.com/flashinfer-ai/flashinfer/commit/be6bf5bb26f1f1b3edf094d903544600c574ee09))
+
+### Acknowledgement
+
+We thank [@LiuXiaoxuanPKU](https://github.com/LiuXiaoxuanPKU) on enhance of speculative sampling operator, [@merrymercy](https://github.com/merrymercy) on API change suggestion and [@zhyncs](https://github.com/zhyncs) on integrating fp8 BMM cublas implementation.
+
+## [0.1.5](https://github.com/flashinfer-ai/flashinfer/compare/v0.1.4...v0.1.5) (2024-08-13)
+
+
+### Bugfix
+
+* resolve cu121 compile wired issue ([#446](https://github.com/flashinfer-ai/flashinfer/issues/446)) ([5f0159e](https://github.com/flashinfer-ai/flashinfer/commit/5f0159e6abeb7308d965bb1b9aef05547b8a57b3))
+* Fix PagedPrefill python api and some typos ([#441](https://github.com/flashinfer-ai/flashinfer/pull/441)) ([3fff008](https://github.com/flashinfer-ai/flashinfer/commit/3fff008dc9af56c325d9c487bddf69ff014f3989))
+* fix prefill kernels' lse result for empty kv-cache ([#440](https://github.com/flashinfer-ai/flashinfer/pull/440)) ([6ac28f4](https://github.com/flashinfer-ai/flashinfer/commit/6ac28f4dd3a9a34a2b4abcbe0a815fc59a2d74ad))
+
+### Features
+
+* decouple float and int workspace buffer ([#442](https://github.com/flashinfer-ai/flashinfer/issues/442)) ([a7ee566](https://github.com/flashinfer-ai/flashinfer/commit/a7ee5662bf967ab1ee16910c73761d326fbeb9a0))
+
+
+### Performance Improvements
+
+* faster fp8->fp16 dequantization for pre sm_90 arch ([#439](https://github.com/flashinfer-ai/flashinfer/issues/439)) ([c93f647](https://github.com/flashinfer-ai/flashinfer/commit/c93f647a0dd6b58c9ac20b39438316202358463c))
+
+### Acknowledgement
+
+We thank contributions and feedbacks from the community: [@comaniac](https://github.com/comaniac), [@hnyls2002](https://github.com/hnyls2002), [@jianfei-wangg](https://github.com/jianfei-wangg), [@Yard1](https://github.com/Yard1).
+
+
+
+## [0.1.4](https://github.com/flashinfer-ai/flashinfer/compare/v0.1.3...v0.1.4) (2024-08-09)
+
+
+### Features
+
+* append attention kernels for fp8 kv-cache ([#420](https://github.com/flashinfer-ai/flashinfer/issues/420)) ([906c2f5](https://github.com/flashinfer-ai/flashinfer/commit/906c2f5df3b35df45a4fb2614815308b662099ea))
+* support min_p sampling ([#422](https://github.com/flashinfer-ai/flashinfer/pull/422)) ([d52f2da](https://github.com/flashinfer-ai/flashinfer/commit/d52f2da6825f0fd7f614bf3a2db3b75c8fef961b))
+* deterministic sampling ([#417](https://github.com/flashinfer-ai/flashinfer/issues/417)) ([0dd801d](https://github.com/flashinfer-ai/flashinfer/commit/0dd801d2027af89f3603cbbf68a76e9503bb2f57))
+* more sampling operator options ([#431](https://github.com/flashinfer-ai/flashinfer/issues/431)) ([68df9c4](https://github.com/flashinfer-ai/flashinfer/commit/68df9c487e672b4a4ea3be97aed63a48aac5945b))
+* support fused add rmsnorm ([#419](https://github.com/flashinfer-ai/flashinfer/issues/419)) ([b781513](https://github.com/flashinfer-ai/flashinfer/commit/b78151383d4a75094195cba29aba45d694d5fdb7))
+* support fused silu mul ([#427](https://github.com/flashinfer-ai/flashinfer/issues/427)) ([ea0ba9a](https://github.com/flashinfer-ai/flashinfer/commit/ea0ba9a51238597bd7863b6e3c9bfda574df4df5))
+
+### Bug Fixes
+
+* fix dispatch fp16 type when enable fp8 ([#430](https://github.com/flashinfer-ai/flashinfer/pull/430)) ([daa5566](https://github.com/flashinfer-ai/flashinfer/commit/daa556697fed849810745f0aae0015d8e4460050))
+* improve numerical stability of sampling kernels ([#429](https://github.com/flashinfer-ai/flashinfer/pull/429)) ([898d8ea](https://github.com/flashinfer-ai/flashinfer/commit/898d8ea8a21f5850288bc4a860399678131a2d30))
+
+### Other improvements
+
+* break up `_kernels` into multiple modules ([#428](https://github.com/flashinfer-ai/flashinfer/pull/428)) ([8e482d9](https://github.com/flashinfer-ai/flashinfer/commit/8e482d92cb0ad046ec5f57509f9473e76bd668fe))
+
+### Acknowledgement
+
+We thank contributions and feedbacks from the community: [@comaniac](https://github.com/comaniac), [@esmeetu](https://github.com/esmeetu), [@LiuXiaoxuanPKU](https://github.com/LiuXiaoxuanPKU), [@peng1999](https://github.com/peng1999), [@xslingcn](https://github.com/xslingcn), [@Yard1](https://github.com/Yard1), [@zhyncs](https://github.com/zhyncs).
+
+
+## [0.1.3](https://github.com/flashinfer-ai/flashinfer/compare/v0.1.2...v0.1.3) (2024-07-31)
+
+### Bugfix
+
+* bugfix: Fix cudagraph mode of BatchPrefillWithRaggedKVCacheWrapper ([#412](https://github.com/flashinfer-ai/flashinfer/pull/412)) ([9907bc](https://github.com/flashinfer-ai/flashinfer/commit/9907bc163eec7677870014b6ed5bb1789cc584f0))
+* fix cu118 cub usage for sampling kernels ([#410](https://github.com/flashinfer-ai/flashinfer/pull/410)) ([58d359](https://github.com/flashinfer-ai/flashinfer/commit/58d35930740083f27e65c9818ab857f9f4880aff))
+
+### MiscBreak up _kernels into multiple modules
+
+* enhance allocator error info and add shape check for prefill begin forward functions ([#413](https://github.com/flashinfer-ai/flashinfer/pull/413)) ([5e36c5](https://github.com/flashinfer-ai/flashinfer/commit/5e36c527bb10c9331a17d4ecd609120406280979))
+
+## [0.1.2](https://github.com/flashinfer-ai/flashinfer/compare/v0.1.1...v0.1.2) (2024-07-29)
+
+### Bugfix
+* Fix the sampling kernel bug for cu118 ([#386](https://github.com/flashinfer-ai/flashinfer/pull/386), [#387](https://github.com/flashinfer-ai/flashinfer/pull/387)) ([0cd499](https://github.com/flashinfer-ai/flashinfer/commit/0cd49949e6c05a0c8f63d050ff96c8f6168cf914), [dc3f18](https://github.com/flashinfer-ai/flashinfer/commit/dc3f184eda83b9feb5c901606b3d8aede23a4a5f))
+
+### Features
+
+* add llama 3.1 style rope ([#401](https://github.com/flashinfer-ai/flashinfer/issues/401)) ([4c89dec](https://github.com/flashinfer-ai/flashinfer/commit/4c89decadc8ae9f261cae97c350064156e66bc09))
+* non-inplace rope operators ([#405](https://github.com/flashinfer-ai/flashinfer/issues/405)) ([74ffba1](https://github.com/flashinfer-ai/flashinfer/commit/74ffba1d1b946fcd3536b7637a4e1a999e5a5d3e))
+* sliding window attention ([#406](https://github.com/flashinfer-ai/flashinfer/issues/406)) ([28cffd3](https://github.com/flashinfer-ai/flashinfer/commit/28cffd366888649a1e9d871efec32e67b88070cb))
+* support non-contiguous (packed) input for prefill kernels ([#404](https://github.com/flashinfer-ai/flashinfer/issues/404)) ([68c3719](https://github.com/flashinfer-ai/flashinfer/commit/68c3719113f90bed5bf1a5d4990f8e2c0b0f5fd3))
+
+
+### Performance Improvements
+
+* slight optimization on merge states ([#313](https://github.com/flashinfer-ai/flashinfer/issues/313)) ([701c813](https://github.com/flashinfer-ai/flashinfer/commit/701c813cb1266f8dd2b93d17978d35fd6fb975dd))
+
+## [0.1.1](https://github.com/flashinfer-ai/flashinfer/compare/v0.1.0...v0.1.1) (2024-07-20)
+
+### Bugfix
+
+* fix the invalid kernel configuration for architectures with small shared memory size ([#385](https://github.com/flashinfer-ai/flashinfer/pull/385)) ([cdac57](https://github.com/flashinfer-ai/flashinfer/commit/cdac577011e8ab50aa26dfef0cecf77d92d2f804))
+
+### Features
+
+* expose decoupled kv-cache to pytorch api ([#383](https://github.com/flashinfer-ai/flashinfer/issues/383)) ([457a0ae](https://github.com/flashinfer-ai/flashinfer/commit/457a0ae0c8a43bd95a803167e28be19555a2ebf8))
+
+
+### Performance Improvements
+
+* use stmatrix in epilogue for sm90+ ([#380](https://github.com/flashinfer-ai/flashinfer/issues/380)) ([c6f20d1](https://github.com/flashinfer-ai/flashinfer/commit/c6f20d1406a3a8c4f134c4a764d16e157a184338))
+
+## [0.1.0](https://github.com/flashinfer-ai/flashinfer/compare/v0.0.9...v0.1.0) (2024-07-17)
+
+
+### Features
+
+* Add mask to `merge_state_in_place` ([#372](https://github.com/flashinfer-ai/flashinfer/issues/372)) ([e14fa81](https://github.com/flashinfer-ai/flashinfer/commit/e14fa8194cfc09c271e6f2c102060698f18297a9))
+* expose pytorch api for block sparse attention ([#375](https://github.com/flashinfer-ai/flashinfer/issues/375)) ([4bba6fa](https://github.com/flashinfer-ai/flashinfer/commit/4bba6fa3aa848d2e43248bca8d959fd58a27cfa4))
+* Fused GPU sampling kernel for joint top-k & top-p sampling ([#374](https://github.com/flashinfer-ai/flashinfer/issues/374)) ([6e028eb](https://github.com/flashinfer-ai/flashinfer/commit/6e028eb997173658832a66c7480cc9224d637a15))
+
+## [0.0.9](https://github.com/flashinfer-ai/flashinfer/compare/v0.0.8...v0.0.9) (2024-07-12)
+
+### Bugfix
+
+* fix the decode kernel segfault in cudagraph mode ([#368](https://github.com/flashinfer-ai/flashinfer/pull/368))([c69cfa](https://github.com/flashinfer-ai/flashinfer/commit/c69cfabc540e4a7edd991713df10d575ff3b0c21))
+- fix decode kernels output for empty kv cache ([#363](https://github.com/flashinfer-ai/flashinfer/pull/363))([ac72b1](https://github.com/flashinfer-ai/flashinfer/commit/ac72b1cc14a6474d601f371c8d69e2600ac28d2f))
+- check gpu id in PyTorch APIs and use input tensor's gpu default stream ([#361](https://github.com/flashinfer-ai/flashinfer/pull/361))([1b84fa](https://github.com/flashinfer-ai/flashinfer/commit/1b84fab3e4f53fb4fa26952fdb46fa8018634057))
+
+### Performance Improvements
+
+* accelerate alibi ([#365](https://github.com/flashinfer-ai/flashinfer/issues/365)) ([4f0a9f9](https://github.com/flashinfer-ai/flashinfer/commit/4f0a9f987ad2036f3c466257459de823be85fcc6))
+* accelerate gqa performance ([#356](https://github.com/flashinfer-ai/flashinfer/issues/356)) ([e56ddad](https://github.com/flashinfer-ai/flashinfer/commit/e56ddadf4bdbb164c3f1a03f9f69cb8a25621ef5))
+* Optimize tensor conversions in C++ code to avoid unnecessary copies ([#366](https://github.com/flashinfer-ai/flashinfer/issues/366)) ([1116237](https://github.com/flashinfer-ai/flashinfer/commit/1116237ac1e5690cf404841327b58b1d268d9951))
+
+### Acknowledgement
+
+We thank [@Yard1](https://github.com/Yard1), [@Ying1123](https://github.com/Ying1123) and [@zhyncs](https://github.com/zhyncs) for their contributions.
+
+## [0.0.8](https://github.com/flashinfer-ai/flashinfer/compare/v0.0.7...v0.0.8) (2024-07-03)
+
+### Bugfix
+
+* fix prefill/append kernel behavior for empty kv-cache ([#353](https://github.com/flashinfer-ai/flashinfer/pull/353)) ([7adc8c](https://github.com/flashinfer-ai/flashinfer/commit/7adc8cf01a029645307c321a7754d0b0a4f0f4de))
+* fix decode attention kernel with logits cap ([#350](https://github.com/flashinfer-ai/flashinfer/pull/350)) ([f5f7a2](https://github.com/flashinfer-ai/flashinfer/commit/f5f7a2a23249fd0be5b30fd8fb3957ac3bb527ca))
+
+
+## [0.0.7](https://github.com/flashinfer-ai/flashinfer/compare/v0.0.6...v0.0.7) (2024-06-28)
+
+### Breaking Changes
+* `batch_decode_with_padded_kv_cache` was removed, we encourage user to use `BatchDecodeWithPagedKVCacheWrapper` instead. ([#343](https://github.com/flashinfer-ai/flashinfer/pull/343))
+
+### Bugfix
+
+* fix the `forward_return_lse` function in `BatchPrefillWithRaggedKVCache` class ([#337](https://github.com/flashinfer-ai/flashinfer/pull/337))
+* fix the scheduler behavior of large page size ([#333](https://github.com/flashinfer-ai/flashinfer/pull/333))
+
+### Features
+
+* customize `logits_soft_cap` value ([#339](https://github.com/flashinfer-ai/flashinfer/issues/339)) ([a2498f5](https://github.com/flashinfer-ai/flashinfer/commit/a2498f511b354ce049bda6be320a24b73c719be3))
+
+
+### Performance Improvements
+
+* change minimal `kv_chunk_size` back to 128 ([#329](https://github.com/flashinfer-ai/flashinfer/issues/329)) ([f237f5f](https://github.com/flashinfer-ai/flashinfer/commit/f237f5f80199e2c433fcca750713c6e774693b58))
+* more options for kv tile size ([#336](https://github.com/flashinfer-ai/flashinfer/issues/336)) ([bf2a6c7](https://github.com/flashinfer-ai/flashinfer/commit/bf2a6c7c05a82e0ee0ea04381d04b84327355b69))
+
+## [0.0.6](https://github.com/flashinfer-ai/flashinfer/compare/v0.0.5...v0.0.6) (2024-06-21)
+
+### Bugfix
+
+Fix some bug in v0.0.5 that might lead to crashes and instable performance.
+
+### Performance Improvements
+
+* use 1x4 warp layout for small query length ([#322](https://github.com/flashinfer-ai/flashinfer/issues/322)) ([4e89b4d](https://github.com/flashinfer-ai/flashinfer/commit/4e89b4dfdeb0c07b290ace9f82edf31e63136cfd))
+
+## [0.0.5](https://github.com/flashinfer-ai/flashinfer/compare/v0.0.4...v0.0.5) (2024-06-20)
+
+### Highlights
+
+* Support any GQA group size support for tensor-cores kernels.
+* Support any page size support for tensor-cores kernels.
+* Support CUDA-Graph for prefill/decode APIs.
+* Add an option to accelerate decode kernels with Tensor Cores.
+* Support custom attention mask. (https://docs.flashinfer.ai/tutorials/kv_layout.html#mask-layout-2d-ragged-tensor)
+* Support logits cap in Grok-1 models.
+* Fused GPU-sampling kernels: top-p, top-k, speculative verification. (https://docs.flashinfer.ai/api/python/sampling.html)
+* PyTorch wrapper of group-gemm cutlass kernels. (https://docs.flashinfer.ai/api/python/group_gemm.html)
+
+### Acknowledgement
+
+We thank [@ibsidorenko](https://github.com/ibsidorenko), [@LiuXiaoxuanPKU](https://github.com/LiuXiaoxuanPKU), [@Yard1](https://github.com/Yard1) [@AgrawalAmey](https://github.com/AgrawalAmey), [@xuzhenqi](https://github.com/xuzhenqi), [@mgerstgrasser](https://github.com/mgerstgrasser), [@esmeetu](https://github.com/esmeetu), [@yz-tang](https://github.com/yz-tang), [@HSQ79815](https://github.com/HSQ79815), [@Qubitium](https://github.com/Qubitium), [@shreygupta2809](https://github.com/shreygupta2809), [@sighingnow](https://github.com/sighingnow), [@vinx13](https://github.com/vinx13),
+[@tqchen](https://github.com/tqchen), [@merrymercy](https://github.com/merrymercy), [@comaniac](https://github.com/comaniac) and many others for their contributions and helpful discussions for 0.0.5 release.
+
+### Refactor
+
+* support any GQA group size for tensor-cores kernels ([#301](https://github.com/flashinfer-ai/flashinfer/pull/301)) ([c111ca](https://github.com/flashinfer-ai/flashinfer/commit/c111ca630d57bc4c301fff2599253a5d782a95c8))
+* support any page size for tensor-cores kernels ([#306](https://github.com/flashinfer-ai/flashinfer/pull/306)) ([82fd8c](https://github.com/flashinfer-ai/flashinfer/commit/82fd8c7ee2d569b1876d547f73c7ad4b085a771e))
+
+
+### Features
+
+* add `use_tensor_cores` option to decode kernels to accelerate GQA ([#317](https://github.com/flashinfer-ai/flashinfer/issues/317)) ([3b50dd5](https://github.com/flashinfer-ai/flashinfer/commit/3b50dd59b0e1f23905e583d5af069e43ff5e15a4))
+* add group gemm operators ([#282](https://github.com/flashinfer-ai/flashinfer/issues/282)) ([e08ba42](https://github.com/flashinfer-ai/flashinfer/commit/e08ba4226f694d5469cce4233f1854c965f05197))
+* initial support of distributed operators ([#289](https://github.com/flashinfer-ai/flashinfer/issues/289)) ([03553da](https://github.com/flashinfer-ai/flashinfer/commit/03553dac1dffff9a6867be0d5676d69d6eeae18c))
+* initial support of logits hook ([#298](https://github.com/flashinfer-ai/flashinfer/issues/298)) ([ab1e2ad](https://github.com/flashinfer-ai/flashinfer/commit/ab1e2ad89f27319f5b4874c5e8b526c1cae43598))
+* Separate Q and KV dtypes for decode ([#286](https://github.com/flashinfer-ai/flashinfer/issues/286)) ([5602659](https://github.com/flashinfer-ai/flashinfer/commit/5602659d8cd0616ec8214d056ea5c4078b21342b))
+* support cuda graph for batched multi-query(prefill/append) attention ([#275](https://github.com/flashinfer-ai/flashinfer/issues/275)) ([83ceb67](https://github.com/flashinfer-ai/flashinfer/commit/83ceb67a5773b0447f5f0344411abfdbc53cf5f4))
+* support cuda graph for batched multi-query(prefill/append) attention ([#277](https://github.com/flashinfer-ai/flashinfer/issues/277)) ([24cc583](https://github.com/flashinfer-ai/flashinfer/commit/24cc583cb6b1a205aa8aad53f56472305b73f5f4))
+* support custom attention mask in prefill/append attention kernels ([#266](https://github.com/flashinfer-ai/flashinfer/issues/266)) ([7304282](https://github.com/flashinfer-ai/flashinfer/commit/7304282a8068942100f8e59adff533ce28f4d3e5))
+* fused speculative sampilng kernels ([#259](https://github.com/flashinfer-ai/flashinfer/pull/259)) ([cea2bb](https://github.com/flashinfer-ai/flashinfer/commit/cea2bb9a836ba6d34d6667b8983ad79fa35cf933))
+* expose sampling APIs in pytorch ([#238](https://github.com/flashinfer-ai/flashinfer/pull/238)) ([092902](https://github.com/flashinfer-ai/flashinfer/commit/0929023e5325a30357750eacec27b0d3a20d1254))
+
+
+### Performance Improvements
+
+* initial cuda graph support ([#256](https://github.com/flashinfer-ai/flashinfer/issues/256)) ([7e9cc7f](https://github.com/flashinfer-ai/flashinfer/commit/7e9cc7ff42ca283c317061a877305d09a395fad2))
+* split kv-cache for prefill/append kernels ([#310](https://github.com/flashinfer-ai/flashinfer/issues/310)) ([f0bb0a3](https://github.com/flashinfer-ai/flashinfer/commit/f0bb0a3a723cbe1a138c604680e6b573d877f210))
+* use packed bit array for attention mask ([#308](https://github.com/flashinfer-ai/flashinfer/issues/308)) ([3d43dc9](https://github.com/flashinfer-ai/flashinfer/commit/3d43dc9dc1a2ae804eaa7e40b4555e471fd03fe3))
+
+## [0.0.4](https://github.com/flashinfer-ai/flashinfer/compare/v0.0.3...v0.0.4) (2024-05-01)
+
+
+### Features
+
+* pytorch 2.3 support
+* gpu sampling kernels (top-p, top-k)
+* more gqa group sizes
+* add mma instructions for fp8 ([#179](https://github.com/flashinfer-ai/flashinfer/issues/179)) ([d305798](https://github.com/flashinfer-ai/flashinfer/commit/d3057983e6d47e857ec3956de94eb11f62d9d83e))
+* mma rowsum for fp8 ([#180](https://github.com/flashinfer-ai/flashinfer/issues/180)) ([5af935c](https://github.com/flashinfer-ai/flashinfer/commit/5af935ca783d3487034110902c6406089c31acbc))
+* support any num_heads for get_alibi_slope ([#200](https://github.com/flashinfer-ai/flashinfer/issues/200)) ([b217a6f](https://github.com/flashinfer-ai/flashinfer/commit/b217a6fefb7bd091469467d32b8aedde4a25cad7))
+
+### Bug Fixes
+
+* fix python package dispatch error message ([#182](https://github.com/flashinfer-ai/flashinfer/issues/182)) ([8eed01c](https://github.com/flashinfer-ai/flashinfer/commit/8eed01c094ceb47375a1d4da8748c43a2947e959))
+
+## [0.0.3](https://github.com/flashinfer-ai/flashinfer/compare/v0.0.2...v0.0.3) (2024-03-08)
+
+
+### Features
+
+* adding `sm_scale` field for all attention APIs ([#145](https://github.com/flashinfer-ai/flashinfer/issues/145)) ([85d4018](https://github.com/flashinfer-ai/flashinfer/commit/85d4018de4766dafd1be60cf6d953cd9236a4058))
+* enable `head_dim=256` for attention kernels ([#132](https://github.com/flashinfer-ai/flashinfer/issues/132)) ([0372acc](https://github.com/flashinfer-ai/flashinfer/commit/0372acc44d0d393af7fd9fb3dcef0ff25953d4e1))
+* pytorch api of fp8 kv-cache ([#156](https://github.com/flashinfer-ai/flashinfer/issues/156)) ([66ee066](https://github.com/flashinfer-ai/flashinfer/commit/66ee06683eaea7efe724c46df528ae47aa75eca2))
+* support ALiBi ([#146](https://github.com/flashinfer-ai/flashinfer/issues/146)) ([383518b](https://github.com/flashinfer-ai/flashinfer/commit/383518bdf1824f68d33a2eaafd72a780f195bdd4))
+
+
+### Bug Fixes
+
+* bugfix to pr 135 ([#136](https://github.com/flashinfer-ai/flashinfer/issues/136)) ([3d55c71](https://github.com/flashinfer-ai/flashinfer/commit/3d55c71a62052c590c130897d3a3db49b14fcc34))
+* fix bugs introduced in [#132](https://github.com/flashinfer-ai/flashinfer/issues/132) ([#135](https://github.com/flashinfer-ai/flashinfer/issues/135)) ([9b7b0b9](https://github.com/flashinfer-ai/flashinfer/commit/9b7b0b913e1fbef7aac6351109911c7ac08a8904))
+* fix FindThrust.cmake ([#161](https://github.com/flashinfer-ai/flashinfer/issues/161)) ([30fa584](https://github.com/flashinfer-ai/flashinfer/commit/30fa5843aeb1ac48816967a63db140cff6044e13))
+
+
+### Misc
+* add stream argument in BeginForwardFunction of TVMWrapper ([#164](https://github.com/flashinfer-ai/flashinfer/pull/164)) ([fabfcb5](https://github.com/flashinfer-ai/flashinfer/tree/fabfcb5751dcc003137a5a7d2d5514f3afe2e302))
+
+
+### Performance Improvements
+
+* multiple q by sm_scale in decode kernels ([#144](https://github.com/flashinfer-ai/flashinfer/issues/144)) ([660c559](https://github.com/flashinfer-ai/flashinfer/commit/660c559348ba9710d0d81b53f710f7e4951eee2b))
+
+## [0.0.2](https://github.com/flashinfer-ai/flashinfer/compare/v0.0.1...v0.0.2) (2024-02-17)
+
+
+### Bug Fixes
+
+* add python 3.9 wheels to ci/cd ([#114](https://github.com/flashinfer-ai/flashinfer/issues/114)) ([2d8807d](https://github.com/flashinfer-ai/flashinfer/commit/2d8807d1fb3359ace8a03b73c92bd0679b9d4b33))
+* version names cannot include multiple `+` ([#118](https://github.com/flashinfer-ai/flashinfer/issues/118)) ([af6bd10](https://github.com/flashinfer-ai/flashinfer/commit/af6bd10db03fa1353699631f6b31eee52d343569))
+* version naming issue ([#117](https://github.com/flashinfer-ai/flashinfer/issues/117)) ([c849a90](https://github.com/flashinfer-ai/flashinfer/commit/c849a90e6b6756a2ca87733782607796d8c7b85a))

sglang_repo/sgl-kernel/3rdparty/flashinfer/LICENSE

@@ -0,0 +1,223 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+-------------------------------------------------------------------------------------------------
+Some of the code in this project are adapted from other open-source projects with different
+licenses. This product also bundles some third-party components under other open source licenses.
+This section summarizes those components and their licenses.
+See licenses/ for text of these licenses.
+
+BSD 3-Clause License
+--------------------
+
+include/flashinfer/attention/hopper/epilogue.cuh
+include/flashinfer/attention/hopper/mainloop.cuh
+include/flashinfer/attention/hopper/kernel_traits.cuh
+include/flashinfer/attention/hopper/named_barrier.cuh
+include/flashinfer/attention/hopper/tile_scheduler.cuh
+include/flashinfer/attention/hopper/utils.cuh
+
+BSD 3-Clause "New" License
+--------------------------
+
+3rdparty/cutlass
+include/flashinfer/attention/hopper/block_sparse_gather.cuh

sglang_repo/sgl-kernel/3rdparty/flashinfer/README.md

@@ -0,0 +1,169 @@
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://github.com/flashinfer-ai/web-data/blob/main/logo/FlashInfer-black-background.png?raw=true">
+    <img alt="FlashInfer" src="https://github.com/flashinfer-ai/web-data/blob/main/logo/FlashInfer-white-background.png?raw=true" width=55%>
+  </picture>
+</p>
+<h1 align="center">
+Kernel Library for LLM Serving
+</h1>
+
+<p align="center">
+| <a href="https://flashinfer.ai"><b>Blog</b></a> | <a href="https://docs.flashinfer.ai"><b>Documentation</b></a> | <a href="https://join.slack.com/t/flashinfer/shared_invite/zt-2r93kj2aq-wZnC2n_Z2~mf73N5qnVGGA"><b>Slack</b></a>|  <a href="https://github.com/orgs/flashinfer-ai/discussions"><b>Discussion Forum</b></a> |
+</p>
+
+[![Release](https://github.com/flashinfer-ai/flashinfer/actions/workflows/release_wheel.yml/badge.svg)](https://github.com/flashinfer-ai/flashinfer/actions/workflows/release_wheel.yml)
+[![Documentation](https://github.com/flashinfer-ai/flashinfer/actions/workflows/build-doc.yml/badge.svg)](https://github.com/flashinfer-ai/flashinfer/actions/workflows/build-doc.yml)
+
+
+FlashInfer is a library and kernel generator for Large Language Models that provides high-performance implementation of LLM GPU kernels such as FlashAttention, SparseAttention, PageAttention, Sampling, and more. FlashInfer focuses on LLM serving and inference, and delivers state-of-the-art performance across diverse scenarios.
+
+Check our [v0.2 release blog](https://flashinfer.ai/2024/12/16/flashinfer-v02-release.html) for new features!
+
+The core features of FlashInfer include:
+1. **Efficient Sparse/Dense Attention Kernels**: Efficient single/batch attention for sparse(paged)/dense KV-storage on CUDA Cores and Tensor Cores (both FA2 & FA3) templates. The vector-sparse attention can achieve 90% of the bandwidth of dense kernels with same problem size.
+2. **Load-Balanced Scheduling**: FlashInfer decouples `plan`/`run` stage of attention computation where we schedule the computation of variable-length inputs in `plan` stage to alleviate load-imbalance issue.
+3. **Memory Efficiency**: FlashInfer offers [Cascade Attention](https://docs.flashinfer.ai/api/cascade.html#flashinfer.cascade.MultiLevelCascadeAttentionWrapper) for hierical KV-Cache, and implements Head-Query fusion for accelerating Grouped-Query Attention, and efficient kernels for low-precision attention and fused-RoPE attention for compressed KV-Cache.
+4. **Customizable Attention**: Bring your own attention variants through JIT-compilation.
+5. **CUDAGraph and torch.compile Compatibility**: FlashInfer kernels can be captured by CUDAGraphs and torch.compile for low-latency inference.
+6. **Efficient LLM-specific Operators**: High-Performance [fused kernel for Top-P, Top-K/Min-P sampling](https://docs.flashinfer.ai/api/sampling.html) without the need to sorting.
+
+FlashInfer support PyTorch, TVM and C++ (header-only) APIs, and can be easily integrated into existing projects.
+
+## News
+- [Dec 16, 2024] [Blog Post](https://flashinfer.ai/2024/12/16/flashinfer-v02-release.html) FlashInfer 0.2 - Efficient and Customizable Kernels for LLM Inference Serving
+- [Sept 2024] We've launched a [Slack](https://join.slack.com/t/flashinfer/shared_invite/zt-2r93kj2aq-wZnC2n_Z2~mf73N5qnVGGA) workspace for Flashinfer users and developers. Join us for timely support, discussions, updates and knowledge sharing!
+- [Jan 31, 2024] [Blog Post](https://flashinfer.ai/2024/01/08/cascade-inference.html) Cascade Inference: Memory-Efficient Shared Prefix Batch Decoding
+- [Jan 31, 2024] [Blog Post](https://flashinfer.ai/2024/01/03/introduce-flashinfer.html) Accelerating Self-Attentions for LLM Serving with FlashInfer
+
+## Getting Started
+
+Using our PyTorch API is the easiest way to get started:
+
+### Installation
+
+We provide prebuilt wheels for Linux. You can install FlashInfer with the following command:
+
+```bash
+# For CUDA 12.4 & torch 2.4
+pip install flashinfer -i https://flashinfer.ai/whl/cu124/torch2.4
+# For other CUDA & torch versions, please check https://docs.flashinfer.ai/installation.html
+```
+
+We also offer nightly-built wheels to try the latest features from the main branch:
+
+```bash
+pip install flashinfer -i https://flashinfer.ai/whl/nightly/cu124/torch2.4
+```
+
+Alternatively, you can build FlashInfer from source:
+
+```bash
+git clone https://github.com/flashinfer-ai/flashinfer.git --recursive
+cd flashinfer
+pip install -e . -v
+```
+
+By default, FlashInfer uses Just-In-Time (JIT) compilation for its kernels. To pre-compile essential kernels, set the environment variable `FLASHINFER_ENABLE_AOT=1` before running the installation command:
+
+```bash
+FLASHINFER_ENABLE_AOT=1 pip install -e . -v
+```
+
+For more details, refer to the [Install from Source documentation](https://docs.flashinfer.ai/installation.html#install-from-source).
+
+### Trying it out
+
+Below is a minimal example of using FlashInfer's single-request decode/append/prefill attention kernels:
+
+```python
+import torch
+import flashinfer
+
+kv_len = 2048
+num_kv_heads = 32
+head_dim = 128
+
+k = torch.randn(kv_len, num_kv_heads, head_dim).half().to(0)
+v = torch.randn(kv_len, num_kv_heads, head_dim).half().to(0)
+
+# decode attention
+
+num_qo_heads = 32
+q = torch.randn(num_qo_heads, head_dim).half().to(0)
+
+o = flashinfer.single_decode_with_kv_cache(q, k, v) # decode attention without RoPE on-the-fly
+o_rope_on_the_fly = flashinfer.single_decode_with_kv_cache(q, k, v, pos_encoding_mode="ROPE_LLAMA") # decode with LLaMA style RoPE on-the-fly
+
+# append attention
+append_qo_len = 128
+q = torch.randn(append_qo_len, num_qo_heads, head_dim).half().to(0) # append attention, the last 128 tokens in the KV-Cache are the new tokens
+o = flashinfer.single_prefill_with_kv_cache(q, k, v, causal=True) # append attention without RoPE on-the-fly, apply causal mask
+o_rope_on_the_fly = flashinfer.single_prefill_with_kv_cache(q, k, v, causal=True, pos_encoding_mode="ROPE_LLAMA") # append attention with LLaMA style RoPE on-the-fly, apply causal mask
+
+# prefill attention
+qo_len = 2048
+q = torch.randn(qo_len, num_qo_heads, head_dim).half().to(0) # prefill attention
+o = flashinfer.single_prefill_with_kv_cache(q, k, v, causal=False) # prefill attention without RoPE on-the-fly, do not apply causal mask
+```
+
+Check out [documentation](https://docs.flashinfer.ai/) for usage of batch decode/append/prefill kernels and shared-prefix cascading kernels.
+
+## Run Benchmarks
+
+We profile FlashInfer kernel performance with [nvbench](https://github.com/NVIDIA/nvbench) and you can compile and run the benchmarks with the following commands:
+
+```bash
+mkdir build
+cp cmake/config.cmake build # you can modify the config.cmake to enable/disable benchmarks and change CUDA architectures
+cd build
+cmake ..
+make -j12
+```
+
+You can run `./bench_{single/batch}_{prefill/decode}` to benchmark the performance (e.g. `./bench_single_prefill` for single-request prefill attention). `./bench_{single/batch}_{prefill/decode} --help` will show you the available options.
+
+## C++ API and TVM Bindings
+
+FlashInfer also provides C++ API and TVM bindings, please refer to [documentation](https://docs.flashinfer.ai/) for more details.
+
+## Adoption
+
+We are thrilled to share that FlashInfer is being adopted by many cutting-edge projects, including but not limited to:
+- [MLC-LLM](https://github.com/mlc-ai/mlc-llm)
+- [Punica](https://github.com/punica-ai/punica)
+- [SGLang](https://github.com/sgl-project/sglang)
+- [ScaleLLM](https://github.com/vectorch-ai/ScaleLLM)
+- [vLLM](https://github.com/vllm-project/vllm)
+- [TGI](https://github.com/huggingface/text-generation-inference)
+- [lorax](https://github.com/predibase/lorax)
+
+## Acknowledgement
+
+FlashInfer is inspired by [FlashAttention 1&2](https://github.com/dao-AILab/flash-attention/), [vLLM](https://github.com/vllm-project/vllm), [stream-K](https://arxiv.org/abs/2301.03598), [cutlass](https://github.com/nvidia/cutlass) and [AITemplate](https://github.com/facebookincubator/AITemplate) projects.
+
+## Citation
+
+If you find FlashInfer helpful in your project or research, please consider citing our [paper](https://arxiv.org/abs/2501.01005):
+
+```bibtex
+@article{ye2025flashinfer,
+    title = {FlashInfer: Efficient and Customizable Attention Engine for LLM Inference Serving},
+    author = {
+      Ye, Zihao and
+      Chen, Lequn and
+      Lai, Ruihang and
+      Lin, Wuwei and
+      Zhang, Yineng and
+      Wang, Stephanie and
+      Chen, Tianqi and
+      Kasikci, Baris and
+      Grover, Vinod and
+      Krishnamurthy, Arvind and
+      Ceze, Luis
+    },
+    journal = {arXiv preprint arXiv:2501.01005},
+    year = {2025},
+    url = {https://arxiv.org/abs/2501.01005}
+}
+```

sglang_repo/sgl-kernel/3rdparty/flashinfer/custom_backend.py

@@ -0,0 +1,41 @@
+import os
+from pathlib import Path
+
+from setuptools import build_meta as orig
+from setuptools.build_meta import *  # noqa: F403
+
+
+def _get_requires_for_build():
+    requires = []
+    if os.environ.get("FLASHINFER_ENABLE_AOT", "0") == "1":
+        requires += ["torch", "ninja"]
+    return requires
+
+
+def get_requires_for_build_wheel(config_settings=None):
+    return _get_requires_for_build()
+
+
+def get_requires_for_build_editable(config_settings=None):
+    return _get_requires_for_build()
+
+
+def build_editable(wheel_directory, config_settings=None, metadata_directory=None):
+    root = Path(__file__).parent.resolve()
+    data_dir = root / "flashinfer" / "data"
+    data_dir.mkdir(parents=True, exist_ok=True)
+
+    def ln(src: str, dst: str) -> None:
+        src: Path = root / src
+        dst: Path = data_dir / dst
+        if dst.exists():
+            if dst.is_symlink():
+                dst.unlink()
+            elif dst.is_dir():
+                dst.rmdir()
+        dst.symlink_to(src, target_is_directory=True)
+
+    ln("3rdparty/cutlass", "cutlass")
+    ln("csrc", "csrc")
+    ln("include", "include")
+    return orig.build_editable(wheel_directory, config_settings, metadata_directory)

sglang_repo/sgl-kernel/3rdparty/flashinfer/pyproject.toml

@@ -0,0 +1,116 @@
+# Copyright (c) 2024 by FlashInfer team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+[project]
+name = "flashinfer-python"
+description = "FlashInfer: Kernel Library for LLM Serving"
+requires-python = ">=3.8,<4.0"
+authors = [{ name = "FlashInfer team" }]
+license = { text = "Apache License 2.0" }
+readme = "README.md"
+urls = { Homepage = "https://github.com/flashinfer-ai/flashinfer" }
+dynamic = ["dependencies", "version"]
+
+[build-system]
+requires = ["setuptools"]
+build-backend = "custom_backend"
+backend-path = ["."]
+
+[tool.codespell]
+ignore-words-list = "3nd"
+skip = [
+    "build",
+    "3rdparty",
+    "dist",
+    ".venv"
+]
+
+[tool.setuptools]
+packages = [
+    "flashinfer",
+    "flashinfer.data",
+    "flashinfer.data.csrc",
+    "flashinfer.data.cutlass",
+    "flashinfer.data.include",
+    "flashinfer.jit",
+    "flashinfer.triton",
+    "flashinfer.triton.kernels",
+]
+include-package-data = false
+
+[tool.setuptools.package-dir]
+"flashinfer.data" = "."
+"flashinfer.data.cutlass" = "3rdparty/cutlass"
+
+[tool.setuptools.package-data]
+"flashinfer.data" = [
+    "csrc/**",
+    "include/**",
+    "version.txt"
+]
+"flashinfer.data.cutlass" = [
+    "include/**",
+    "tools/util/include/**"
+]
+
+[tool.mypy]
+ignore_missing_imports = false
+show_column_numbers = true
+show_error_context = true
+follow_imports = "skip"
+ignore_errors = false
+strict_optional = false
+
+
+[tool.ruff.lint]
+select = [
+    # pycodestyle
+    "E",
+    # Pyflakes
+    "F",
+    # pyupgrade
+    # "UP",
+    # flake8-bugbear
+    "B",
+    # flake8-simplify
+    "SIM",
+    # isort
+    # "I",
+]
+ignore = [
+    # Module level import not at top of file
+    "E402",
+    # star imports
+    "F405", "F403",
+    # ambiguous name
+    "E741",
+    # line too long
+    "E501",
+    # key in dict.keys()
+    "SIM118",
+    # memory leaks
+    "B019",
+    # No such file or directory
+    "E902",
+    # nested `if` statements
+    "SIM102",
+    # `if`-`else`-block
+    "SIM108",
+    # assign `lambda` expressions
+    "E731",
+    # Loop control variable overrides iterable it iterates
+    "B020",
+    # Return te negated condition directly
+    "SIM103",
+]

sglang_repo/sgl-kernel/3rdparty/flashinfer/setup.py

@@ -0,0 +1,279 @@
+"""
+Copyright (c) 2023 by FlashInfer team.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import argparse
+import os
+import platform
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+import setuptools
+
+root = Path(__file__).parent.resolve()
+gen_dir = root / "csrc" / "generated"
+
+head_dims = os.environ.get("FLASHINFER_HEAD_DIMS", "64,128,256").split(",")
+head_dims = list(map(int, head_dims))
+SM90_ALLOWED_HEAD_DIMS = {64, 128, 256}
+head_dims_sm90 = [d for d in head_dims if d in SM90_ALLOWED_HEAD_DIMS]
+
+mask_modes = [0, 1, 2]
+
+enable_aot = os.environ.get("FLASHINFER_ENABLE_AOT", "0") == "1"
+enable_f16 = os.environ.get("FLASHINFER_ENABLE_F16", "1") == "1"
+enable_bf16 = os.environ.get("FLASHINFER_ENABLE_BF16", "1") == "1"
+enable_fp8 = os.environ.get("FLASHINFER_ENABLE_FP8", "1") == "1"
+enable_fp8_e4m3 = (
+    os.environ.get("FLASHINFER_ENABLE_FP8_E4M3", "1" if enable_fp8 else "0") == "1"
+)
+enable_fp8_e5m2 = (
+    os.environ.get("FLASHINFER_ENABLE_FP8_E5M2", "1" if enable_fp8 else "0") == "1"
+)
+enable_sm90 = os.environ.get("FLASHINFER_ENABLE_SM90", "1") == "1"
+
+
+def write_if_different(path: Path, content: str) -> None:
+    if path.exists() and path.read_text() == content:
+        return
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(content)
+
+
+def get_version():
+    package_version = (root / "version.txt").read_text().strip()
+    local_version = os.environ.get("FLASHINFER_LOCAL_VERSION")
+    if local_version is None:
+        return package_version
+    return f"{package_version}+{local_version}"
+
+
+def generate_build_meta(aot_build_meta: dict) -> None:
+    build_meta_str = f"__version__ = {get_version()!r}\n"
+    if len(aot_build_meta) != 0:
+        build_meta_str += f"build_meta = {aot_build_meta!r}\n"
+    write_if_different(root / "flashinfer" / "_build_meta.py", build_meta_str)
+
+
+def generate_cuda() -> None:
+    try:  # no aot_build_utils in sdist
+        sys.path.append(str(root))
+        from aot_build_utils import generate_dispatch_inc
+        from aot_build_utils.generate import get_instantiation_cu
+        from aot_build_utils.generate_aot_default_additional_params_header import (
+            get_aot_default_additional_params_header_str,
+        )
+        from aot_build_utils.generate_sm90 import get_sm90_instantiation_cu
+    except ImportError:
+        return
+
+    # dispatch.inc
+    write_if_different(
+        gen_dir / "dispatch.inc",
+        generate_dispatch_inc.get_dispatch_inc_str(
+            argparse.Namespace(
+                head_dims=head_dims,
+                head_dims_sm90=head_dims_sm90,
+                pos_encoding_modes=[0],
+                use_fp16_qk_reductions=[0],
+                mask_modes=mask_modes,
+            )
+        ),
+    )
+
+    # _kernels
+    aot_kernel_uris = get_instantiation_cu(
+        argparse.Namespace(
+            path=gen_dir,
+            head_dims=head_dims,
+            pos_encoding_modes=[0],
+            use_fp16_qk_reductions=[0],
+            mask_modes=mask_modes,
+            enable_f16=enable_f16,
+            enable_bf16=enable_bf16,
+            enable_fp8_e4m3=enable_fp8_e4m3,
+            enable_fp8_e5m2=enable_fp8_e5m2,
+        )
+    )
+
+    # _kernels_sm90
+    if enable_sm90:
+        aot_kernel_uris += get_sm90_instantiation_cu(
+            argparse.Namespace(
+                path=gen_dir,
+                head_dims=head_dims_sm90,
+                pos_encoding_modes=[0],
+                use_fp16_qk_reductions=[0],
+                mask_modes=mask_modes,
+                enable_f16=enable_f16,
+                enable_bf16=enable_bf16,
+            )
+        )
+    aot_config_str = f"""prebuilt_ops_uri = set({aot_kernel_uris})"""
+    write_if_different(root / "flashinfer" / "jit" / "aot_config.py", aot_config_str)
+    write_if_different(
+        root / "csrc" / "aot_default_additional_params.h",
+        get_aot_default_additional_params_header_str(),
+    )
+
+
+ext_modules = []
+cmdclass = {}
+install_requires = ["torch", "ninja"]
+generate_build_meta({})
+
+if enable_aot:
+    import torch
+    import torch.utils.cpp_extension as torch_cpp_ext
+    from packaging.version import Version
+
+    generate_cuda()
+
+    def get_cuda_version() -> Version:
+        if torch_cpp_ext.CUDA_HOME is None:
+            nvcc = "nvcc"
+        else:
+            nvcc = os.path.join(torch_cpp_ext.CUDA_HOME, "bin/nvcc")
+        txt = subprocess.check_output([nvcc, "--version"], text=True)
+        return Version(re.findall(r"release (\d+\.\d+),", txt)[0])
+
+    class NinjaBuildExtension(torch_cpp_ext.BuildExtension):
+        def __init__(self, *args, **kwargs) -> None:
+            # do not override env MAX_JOBS if already exists
+            if not os.environ.get("MAX_JOBS"):
+                max_num_jobs_cores = max(1, os.cpu_count())
+                os.environ["MAX_JOBS"] = str(max_num_jobs_cores)
+
+            super().__init__(*args, **kwargs)
+
+    # cuda arch check for fp8 at the moment.
+    for cuda_arch_flags in torch_cpp_ext._get_cuda_arch_flags():
+        arch = int(re.search(r"compute_(\d+)", cuda_arch_flags).group(1))
+        if arch < 75:
+            raise RuntimeError("FlashInfer requires sm75+")
+
+    cuda_version = get_cuda_version()
+    torch_full_version = Version(torch.__version__)
+    torch_version = f"{torch_full_version.major}.{torch_full_version.minor}"
+    cmdclass["build_ext"] = NinjaBuildExtension
+    install_requires = [f"torch == {torch_version}.*"]
+
+    aot_build_meta = {}
+    aot_build_meta["cuda_major"] = cuda_version.major
+    aot_build_meta["cuda_minor"] = cuda_version.minor
+    aot_build_meta["torch"] = torch_version
+    aot_build_meta["python"] = platform.python_version()
+    aot_build_meta["TORCH_CUDA_ARCH_LIST"] = os.environ.get("TORCH_CUDA_ARCH_LIST")
+    generate_build_meta(aot_build_meta)
+
+    if enable_f16:
+        torch_cpp_ext.COMMON_NVCC_FLAGS.append("-DFLASHINFER_ENABLE_F16")
+    if enable_bf16:
+        torch_cpp_ext.COMMON_NVCC_FLAGS.append("-DFLASHINFER_ENABLE_BF16")
+    if enable_fp8_e4m3:
+        torch_cpp_ext.COMMON_NVCC_FLAGS.append("-DFLASHINFER_ENABLE_FP8_E4M3")
+    if enable_fp8_e5m2:
+        torch_cpp_ext.COMMON_NVCC_FLAGS.append("-DFLASHINFER_ENABLE_FP8_E5M2")
+
+    for flag in [
+        "-D__CUDA_NO_HALF_OPERATORS__",
+        "-D__CUDA_NO_HALF_CONVERSIONS__",
+        "-D__CUDA_NO_BFLOAT16_CONVERSIONS__",
+        "-D__CUDA_NO_HALF2_OPERATORS__",
+    ]:
+        try:
+            torch_cpp_ext.COMMON_NVCC_FLAGS.remove(flag)
+        except ValueError:
+            pass
+
+    cutlass = root / "3rdparty" / "cutlass"
+    include_dirs = [
+        root.resolve() / "include",
+        cutlass.resolve() / "include",  # for group gemm
+        cutlass.resolve() / "tools" / "util" / "include",
+    ]
+    cxx_flags = [
+        "-O3",
+        "-Wno-switch-bool",
+    ]
+    nvcc_flags = [
+        "-O3",
+        "-std=c++17",
+        "--threads=1",
+        "-Xfatbin",
+        "-compress-all",
+        "-use_fast_math",
+    ]
+    sm90a_flags = "-gencode arch=compute_90a,code=sm_90a".split()
+    kernel_sources = [
+        "csrc/bmm_fp8.cu",
+        "csrc/cascade.cu",
+        "csrc/group_gemm.cu",
+        "csrc/norm.cu",
+        "csrc/page.cu",
+        "csrc/quantization.cu",
+        "csrc/rope.cu",
+        "csrc/sampling.cu",
+        "csrc/renorm.cu",
+        "csrc/activation.cu",
+        "csrc/batch_decode.cu",
+        "csrc/batch_prefill.cu",
+        "csrc/single_decode.cu",
+        "csrc/single_prefill.cu",
+        "csrc/flashinfer_ops.cu",
+    ]
+    kernel_sm90_sources = [
+        "csrc/group_gemm_sm90.cu",
+        "csrc/single_prefill_sm90.cu",
+        "csrc/batch_prefill_sm90.cu",
+        "csrc/flashinfer_ops_sm90.cu",
+    ]
+    decode_sources = list(gen_dir.glob("*decode_head*.cu"))
+    prefill_sources = [
+        f for f in gen_dir.glob("*prefill_head*.cu") if "_sm90" not in f.name
+    ]
+    prefill_sm90_sources = list(gen_dir.glob("*prefill_head*_sm90.cu"))
+    ext_modules = [
+        torch_cpp_ext.CUDAExtension(
+            name="flashinfer._kernels",
+            sources=kernel_sources + decode_sources + prefill_sources,
+            include_dirs=include_dirs,
+            extra_compile_args={
+                "cxx": cxx_flags,
+                "nvcc": nvcc_flags,
+            },
+        )
+    ]
+    if enable_sm90:
+        ext_modules += [
+            torch_cpp_ext.CUDAExtension(
+                name="flashinfer._kernels_sm90",
+                sources=kernel_sm90_sources + prefill_sm90_sources,
+                include_dirs=include_dirs,
+                extra_compile_args={
+                    "cxx": cxx_flags,
+                    "nvcc": nvcc_flags + sm90a_flags,
+                },
+            ),
+        ]
+
+setuptools.setup(
+    version=get_version(),
+    ext_modules=ext_modules,
+    cmdclass=cmdclass,
+    install_requires=install_requires,
+)

sglang_repo/sgl-kernel/3rdparty/flashinfer/src/bench_batch_decode_mla.cu

@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) 2023 by FlashInfer team.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <thrust/device_vector.h>
+
+#include <cstddef>
+#include <cstdint>
+#include <nvbench/nvbench.cuh>
+#include <unordered_set>
+#include <vector>
+
+#include "flashinfer_ops.cuh"
+#include "utils.h"
+
+using utils::vec_bytes;
+using namespace flashinfer;
+
+std::unordered_set<int> dev_to_bench{0};
+
+template <typename T>
+void bench_flashinfer_batch_decode_mla(nvbench::state& state) {
+  int dev_id = state.get_device().value().get_id();
+  if (dev_to_bench.count(dev_id) == 0) return;
+
+  cudaSetDevice(dev_id);
+  cudaStream_t stream;
+  cudaStreamCreate(&stream);
+  state.set_cuda_stream(nvbench::make_cuda_stream_view(stream));
+
+  constexpr size_t head_dim_ckv = 512;
+  constexpr size_t head_dim_kpe = head_dim_ckv / 8;
+  const size_t num_qo_heads = state.get_int64("num_qo_heads");
+  ;
+
+  size_t batch_size = state.get_int64("batch_size");
+  size_t seqlen = state.get_int64("seqlen");
+  size_t page_size = state.get_int64("page_size");
+
+  auto pages_per_seq = (seqlen + page_size - 1) / page_size;
+  auto num_pages = pages_per_seq * batch_size;
+  std::vector<int32_t> kv_indptr_host{0};
+  std::vector<int32_t> kv_indicies_host;
+  std::vector<int32_t> kv_last_page_len_host;
+  for (size_t i = 0; i < batch_size; ++i) {
+    for (size_t p = 0; p < pages_per_seq; ++p) {
+      kv_indicies_host.push_back(i * pages_per_seq + p);
+    }
+    kv_indptr_host.push_back(kv_indptr_host.back() + pages_per_seq);
+    kv_last_page_len_host.push_back((seqlen - 1) % page_size + 1);
+  }
+  thrust::device_vector<int32_t> kv_indptr(kv_indptr_host);
+  thrust::device_vector<int32_t> kv_indices(kv_indicies_host);
+  thrust::device_vector<int32_t> kv_last_page_len(kv_last_page_len_host);
+
+  thrust::device_vector<T> q_nope(batch_size * num_qo_heads * head_dim_ckv);
+  thrust::device_vector<T> q_pe(batch_size * num_qo_heads * head_dim_kpe);
+  thrust::device_vector<T> ckv_data(num_pages * page_size * head_dim_ckv);
+  thrust::device_vector<T> kpe_data(num_pages * page_size * head_dim_kpe);
+  thrust::device_vector<T> o(q_nope.size());
+
+  flashinfer::paged_kv_mla_t<T, int32_t> paged_kv_mla(
+      page_size, head_dim_ckv, head_dim_kpe, batch_size, thrust::raw_pointer_cast(ckv_data.data()),
+      thrust::raw_pointer_cast(kpe_data.data()), thrust::raw_pointer_cast(kv_indices.data()),
+      thrust::raw_pointer_cast(kv_indptr.data()),
+      thrust::raw_pointer_cast(kv_last_page_len.data()));
+
+  state.add_global_memory_reads<uint8_t>(vec_bytes(q_nope) + vec_bytes(q_pe) + vec_bytes(ckv_data) +
+                                             vec_bytes(kpe_data) + vec_bytes(kv_indptr) +
+                                             vec_bytes(kv_indices) + vec_bytes(kv_last_page_len),
+                                         "Read");
+  state.add_global_memory_writes<uint8_t>(vec_bytes(o), "Write");
+
+  flashinfer::BatchDecodeHandler handler;
+  handler.SetCUDAStream(stream);
+  size_t float_workspace_size_in_bytes = 32 * 1024 * 1024;
+  thrust::device_vector<char> float_buffer(float_workspace_size_in_bytes);
+  size_t int_workspace_size_in_bytes = 8 * 1024 * 1024;
+  thrust::device_vector<char> int_buffer(int_workspace_size_in_bytes);
+  flashinfer::BatchDecodeHandlerPlanMLA<T, T, T, int32_t>(
+      &handler, (void*)thrust::raw_pointer_cast(float_buffer.data()), float_workspace_size_in_bytes,
+      (void*)thrust::raw_pointer_cast(int_buffer.data()), int_workspace_size_in_bytes,
+      kv_indptr_host.data(), kv_last_page_len_host.data(), batch_size, num_qo_heads, head_dim_ckv,
+      page_size);
+
+  state.exec([&](nvbench::launch&) {
+    cudaError_t status = flashinfer::BatchDecodeWithPagedKVCacheWrapperMLA<T, T, T, int32_t>(
+        &handler, thrust::raw_pointer_cast(q_nope.data()), thrust::raw_pointer_cast(q_pe.data()),
+        /*q_rope_offset=*/nullptr, paged_kv_mla, thrust::raw_pointer_cast(o.data()),
+        /*lse=*/nullptr, num_qo_heads, std::sqrt(192.0));
+    if (status != cudaSuccess) {
+      state.skip("CUDA error: " + std::string(cudaGetErrorString(status)));
+    }
+  });
+
+  cudaStreamDestroy(stream);
+}
+
+#define STR_HELPER(x) #x
+#define STR(x) STR_HELPER(x)
+
+#define BENCH_FLASHINFER_BATCH_DECODE(dtype)                                                    \
+  auto bench_flashinfer_batch_decode_mla_##dtype##_ = bench_flashinfer_batch_decode_mla<dtype>; \
+  NVBENCH_BENCH(bench_flashinfer_batch_decode_mla_##dtype##_)                                   \
+      .set_name("bench_flashinfer_batch_decode_mla_" STR(dtype))                                \
+      .add_int64_axis("page_size", {64})                                                        \
+      .add_int64_axis("batch_size", {16, 256})                                                  \
+      .add_int64_axis("seqlen", {1024, 16384})                                                  \
+      .add_int64_axis("num_qo_heads", {8, 16, 32, 40, 64, 128})
+
+BENCH_FLASHINFER_BATCH_DECODE(half);

sglang_repo/sgl-kernel/3rdparty/flashinfer/src/bench_cascade.cu

@@ -0,0 +1,386 @@
+/*
+ * Copyright (c) 2023 by FlashInfer team.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <thrust/device_vector.h>
+
+#include <cstddef>
+#include <flashinfer/attention/cascade.cuh>
+#include <nvbench/nvbench.cuh>
+
+#include "flashinfer_ops.cuh"
+#include "utils.h"
+
+using namespace flashinfer;
+
+constexpr QKVLayout kv_layout = QKVLayout::kNHD;
+
+template <typename T>
+void bench_merge_states(nvbench::state& state) {
+  const auto num_index_sets = state.get_int64("num_index_sets");
+  const auto seq_len = state.get_int64("seq_len");
+  const auto num_heads = state.get_int64("num_heads");
+  const auto head_dim = state.get_int64("head_dim");
+
+  std::vector<T> V_host(seq_len * num_index_sets * num_heads * head_dim);
+  std::vector<float> S_host(seq_len * num_index_sets * num_heads);
+
+  utils::vec_normal_(V_host);
+  utils::vec_uniform_(S_host, 5, 10);
+
+  thrust::device_vector<T> V_device(V_host);
+  thrust::device_vector<float> S_device(S_host);
+  thrust::device_vector<T> V_merged(seq_len * num_heads * head_dim);
+  thrust::device_vector<float> S_merged(seq_len * num_heads);
+
+  state.add_global_memory_reads<T>(V_host.size(), "Read");
+  state.add_global_memory_writes<T>(V_merged.size(), "Write");
+
+  state.exec(nvbench::exec_tag::timer, [&](nvbench::launch& launch, auto& timer) {
+    timer.start();
+    cudaError_t status = MergeStates(
+        thrust::raw_pointer_cast(V_device.data()), thrust::raw_pointer_cast(S_device.data()),
+        thrust::raw_pointer_cast(V_merged.data()), thrust::raw_pointer_cast(S_merged.data()),
+        num_index_sets, seq_len, num_heads, head_dim);
+    timer.stop();
+  });
+}
+
+template <typename T>
+void bench_two_level_single_prefix_cascade_decode(nvbench::state& state) {
+  const auto batch_size = state.get_int64("batch_size");
+  const auto shared_prefix_length = state.get_int64("shared_prefix_length");
+  const auto unique_kv_length = state.get_int64("unique_kv_length");
+  const auto num_kv_heads = state.get_int64("num_kv_heads");
+  const auto num_qo_heads = state.get_int64("num_qo_heads");
+  const auto use_cascade = state.get_int64("use_cascade");
+  const auto head_dim = state.get_int64("head_dim");
+
+  constexpr uint32_t page_size = 16;
+
+  auto [testcase_float_data, testcase_int_data] = utils::create_shared_prefix_testcase_data<T>(
+      batch_size, shared_prefix_length, unique_kv_length,
+      /*qo_append_length=*/1, num_qo_heads, num_kv_heads, head_dim, page_size);
+
+  std::vector<T> q_h = std::move(testcase_float_data[0]),
+                 shared_k_h = std::move(testcase_float_data[1]),
+                 shared_v_h = std::move(testcase_float_data[2]),
+                 k_data_h = std::move(testcase_float_data[3]),
+                 v_data_h = std::move(testcase_float_data[4]);
+
+  std::vector<int32_t> kv_indices_combined_h = std::move(testcase_int_data[1]),
+                       kv_indices_unique_h = std::move(testcase_int_data[2]),
+                       kv_indptr_combined_h = std::move(testcase_int_data[3]),
+                       kv_indptr_unique_h = std::move(testcase_int_data[4]),
+                       kv_last_page_len_combined_h = std::move(testcase_int_data[5]),
+                       kv_last_page_len_unique_h = std::move(testcase_int_data[6]);
+
+  thrust::device_vector<T> k_data_d(k_data_h), v_data_d(v_data_h);
+  thrust::device_vector<T> q_d(q_h);
+
+  state.add_global_memory_reads<T>(k_data_h.size() + v_data_h.size() + q_h.size(), "Read");
+  state.add_global_memory_writes<T>(q_h.size(), "Write");
+
+  if (use_cascade) {
+    thrust::device_vector<T> shared_k_d(shared_k_h), shared_v_d(shared_v_h),
+        o_cascade_0_d(q_h.size()), o_cascade_1_d(q_h.size());
+    thrust::device_vector<T> tmp_0_d(16 * 1024 * 1024);
+    thrust::device_vector<float> lse_cascade_0_d(batch_size * num_qo_heads),
+        lse_cascade_1_d(batch_size * num_qo_heads);
+    thrust::device_vector<int32_t> kv_indptr_unique_d(kv_indptr_unique_h),
+        kv_indices_unique_d(kv_indices_unique_h),
+        kv_last_page_len_unique_d(kv_last_page_len_unique_h);
+    paged_kv_t<T, int32_t> paged_kv_casacde_d(
+        num_kv_heads, page_size, head_dim, batch_size, kv_layout,
+        thrust::raw_pointer_cast(k_data_d.data()), thrust::raw_pointer_cast(v_data_d.data()),
+        thrust::raw_pointer_cast(kv_indices_unique_d.data()),
+        thrust::raw_pointer_cast(kv_indptr_unique_d.data()),
+        thrust::raw_pointer_cast(kv_last_page_len_unique_d.data()));
+    BatchDecodeHandler cascade_handler;
+    size_t float_workspace_size_in_bytes = 32 * 1024 * 1024;
+    thrust::device_vector<char> float_buffer(float_workspace_size_in_bytes);
+    size_t int_workspace_size_in_bytes = 8 * 1024 * 1024;
+    thrust::device_vector<char> int_buffer(int_workspace_size_in_bytes);
+    BatchDecodeHandlerPlan<T, T, T, int32_t>(
+        &cascade_handler, (void*)thrust::raw_pointer_cast(float_buffer.data()),
+        float_workspace_size_in_bytes, (void*)thrust::raw_pointer_cast(int_buffer.data()),
+        int_workspace_size_in_bytes, kv_indptr_unique_h.data(), kv_last_page_len_unique_h.data(),
+        batch_size, num_qo_heads, num_kv_heads, head_dim, page_size, PosEncodingMode::kNone);
+
+    state.exec(nvbench::exec_tag::timer, [&](nvbench::launch& launch, auto& timer) {
+      timer.start();
+      cudaError_t status = SinglePrefillWithKVCache(
+          thrust::raw_pointer_cast(q_d.data()), thrust::raw_pointer_cast(shared_k_d.data()),
+          thrust::raw_pointer_cast(shared_v_d.data()),
+          thrust::raw_pointer_cast(o_cascade_0_d.data()), thrust::raw_pointer_cast(tmp_0_d.data()),
+          thrust::raw_pointer_cast(lse_cascade_0_d.data()), num_qo_heads, num_kv_heads,
+          /*qo_len=*/batch_size, /*kv_len=*/shared_prefix_length, head_dim,
+          /*causal=*/false, /*kv_layout=*/QKVLayout::kNHD,
+          /*pos_encoding_mode=*/PosEncodingMode::kNone, /*use_fp16_qk_reduction=*/false);
+
+      if (status != cudaSuccess) {
+        state.skip("Cascade implementation prefill failed with error: " +
+                   std::string(cudaGetErrorString(status)));
+      }
+
+      status = BatchDecodeWithPagedKVCacheWrapper<T, T, T, int32_t>(
+          &cascade_handler, thrust::raw_pointer_cast(q_d.data()),
+          /*q_rope_offset=*/nullptr, paged_kv_casacde_d,
+          thrust::raw_pointer_cast(o_cascade_1_d.data()),
+          /*lse=*/thrust::raw_pointer_cast(lse_cascade_1_d.data()), num_qo_heads,
+          PosEncodingMode::kNone);
+
+      if (status != cudaSuccess) {
+        state.skip("Cascade implementation decode failed with error: " +
+                   std::string(cudaGetErrorString(status)));
+      }
+
+      status = MergeStateInPlace(thrust::raw_pointer_cast(o_cascade_0_d.data()),
+                                 thrust::raw_pointer_cast(lse_cascade_0_d.data()),
+                                 thrust::raw_pointer_cast(o_cascade_1_d.data()),
+                                 thrust::raw_pointer_cast(lse_cascade_1_d.data()), batch_size,
+                                 num_qo_heads, head_dim);
+
+      if (status != cudaSuccess) {
+        state.skip("Cascade implementation merge failed with error: " +
+                   std::string(cudaGetErrorString(status)));
+      }
+      timer.stop();
+    });
+  } else {
+    thrust::device_vector<T> o_baseline_d(q_h.size());
+    thrust::device_vector<int32_t> kv_indptr_combined_d(kv_indptr_combined_h),
+        kv_indices_combined_d(kv_indices_combined_h),
+        kv_last_page_len_combined_d(kv_last_page_len_combined_h);
+    paged_kv_t<T, int32_t> paged_kv_baseline_d(
+        num_kv_heads, page_size, head_dim, batch_size, kv_layout,
+        thrust::raw_pointer_cast(k_data_d.data()), thrust::raw_pointer_cast(v_data_d.data()),
+        thrust::raw_pointer_cast(kv_indices_combined_d.data()),
+        thrust::raw_pointer_cast(kv_indptr_combined_d.data()),
+        thrust::raw_pointer_cast(kv_last_page_len_combined_d.data()));
+    BatchDecodeHandler baseline_handler;
+    size_t float_workspace_size_in_bytes = 32 * 1024 * 1024;
+    thrust::device_vector<char> float_buffer(float_workspace_size_in_bytes);
+    size_t int_workspace_size_in_bytes = 8 * 1024 * 1024;
+    thrust::device_vector<char> int_buffer(int_workspace_size_in_bytes);
+    BatchDecodeHandlerPlan<T, T, T, int32_t>(
+        &baseline_handler, (void*)thrust::raw_pointer_cast(float_buffer.data()),
+        float_workspace_size_in_bytes, (void*)thrust::raw_pointer_cast(int_buffer.data()),
+        int_workspace_size_in_bytes, kv_indptr_combined_h.data(),
+        kv_last_page_len_combined_h.data(), batch_size, num_qo_heads, num_kv_heads, head_dim,
+        page_size, PosEncodingMode::kNone);
+
+    state.exec(nvbench::exec_tag::timer, [&](nvbench::launch& launch, auto& timer) {
+      timer.start();
+      cudaError_t status = BatchDecodeWithPagedKVCacheWrapper<T, T, T, int32_t>(
+          &baseline_handler, thrust::raw_pointer_cast(q_d.data()),
+          /*q_rope_offset=*/nullptr, paged_kv_baseline_d,
+          thrust::raw_pointer_cast(o_baseline_d.data()),
+          /*lse=*/nullptr, num_qo_heads, PosEncodingMode::kNone);
+      if (status != cudaSuccess) {
+        state.skip("Cascade implementation decode failed with error: " +
+                   std::string(cudaGetErrorString(status)));
+      }
+      timer.stop();
+    });
+  }
+}
+
+template <typename T>
+void bench_two_level_single_prefix_cascade_append(nvbench::state& state) {
+  const auto batch_size = state.get_int64("batch_size");
+  const auto shared_prefix_length = state.get_int64("shared_prefix_length");
+  const auto unique_kv_length = state.get_int64("unique_kv_length");
+  const auto qo_append_length = state.get_int64("qo_append_length");
+  const auto num_kv_heads = state.get_int64("num_kv_heads");
+  const auto num_qo_heads = state.get_int64("num_qo_heads");
+  const auto use_cascade = state.get_int64("use_cascade");
+  const auto head_dim = state.get_int64("head_dim");
+
+  constexpr uint32_t page_size = 16;
+
+  auto [testcase_float_data, testcase_int_data] = utils::create_shared_prefix_testcase_data<T>(
+      batch_size, shared_prefix_length, unique_kv_length, qo_append_length, num_qo_heads,
+      num_kv_heads, head_dim, page_size);
+
+  std::vector<T> q_h = std::move(testcase_float_data[0]),
+                 shared_k_h = std::move(testcase_float_data[1]),
+                 shared_v_h = std::move(testcase_float_data[2]),
+                 k_data_h = std::move(testcase_float_data[3]),
+                 v_data_h = std::move(testcase_float_data[4]);
+
+  std::vector<int32_t> qo_indptr_h = std::move(testcase_int_data[0]),
+                       kv_indices_combined_h = std::move(testcase_int_data[1]),
+                       kv_indices_unique_h = std::move(testcase_int_data[2]),
+                       kv_indptr_combined_h = std::move(testcase_int_data[3]),
+                       kv_indptr_unique_h = std::move(testcase_int_data[4]),
+                       kv_last_page_len_combined_h = std::move(testcase_int_data[5]),
+                       kv_last_page_len_unique_h = std::move(testcase_int_data[6]);
+
+  thrust::device_vector<T> k_data_d(k_data_h), v_data_d(k_data_h);
+  thrust::device_vector<T> q_d(q_h);
+  thrust::device_vector<int32_t> qo_indptr_d(qo_indptr_h);
+
+  state.add_global_memory_reads<T>(k_data_h.size() + v_data_h.size() + q_h.size(), "Read");
+  state.add_global_memory_writes<T>(q_h.size(), "Write");
+
+  if (use_cascade) {
+    thrust::device_vector<T> shared_k_d(shared_k_h), shared_v_d(shared_v_h),
+        o_cascade_0_d(q_h.size()), o_cascade_1_d(q_h.size());
+    thrust::device_vector<T> tmp_0_d(8 * 1024 * 1024);
+    thrust::device_vector<float> lse_cascade_0_d((batch_size * qo_append_length) * num_qo_heads),
+        lse_cascade_1_d((batch_size * qo_append_length) * num_qo_heads);
+    thrust::device_vector<int32_t> kv_indptr_unique_d(kv_indptr_unique_h),
+        kv_indices_unique_d(kv_indices_unique_h),
+        kv_last_page_len_unique_d(kv_last_page_len_unique_h);
+    paged_kv_t<T, int32_t> paged_kv_casacde_d(
+        num_kv_heads, page_size, head_dim, batch_size, kv_layout,
+        thrust::raw_pointer_cast(k_data_d.data()), thrust::raw_pointer_cast(v_data_d.data()),
+        thrust::raw_pointer_cast(kv_indices_unique_d.data()),
+        thrust::raw_pointer_cast(kv_indptr_unique_d.data()),
+        thrust::raw_pointer_cast(kv_last_page_len_unique_d.data()));
+    BatchPrefillHandler cascade_handler;
+    size_t float_workspace_size_in_bytes = 32 * 1024 * 1024;
+    thrust::device_vector<char> float_buffer(float_workspace_size_in_bytes);
+    size_t int_workspace_size_in_bytes = 8 * 1024 * 1024;
+    thrust::device_vector<char> int_buffer(int_workspace_size_in_bytes);
+    cascade_handler.Plan<T, int32_t>(
+        (void*)thrust::raw_pointer_cast(float_buffer.data()), float_workspace_size_in_bytes,
+        (void*)thrust::raw_pointer_cast(int_buffer.data()), int_workspace_size_in_bytes,
+        qo_indptr_h.data(), kv_indptr_unique_h.data(),
+        /*total_num_rows=*/batch_size * qo_append_length, batch_size, num_qo_heads, num_kv_heads,
+        head_dim, page_size);
+    state.exec(nvbench::exec_tag::timer, [&](nvbench::launch& launch, auto& timer) {
+      timer.start();
+      cudaError_t status = SinglePrefillWithKVCache(
+          thrust::raw_pointer_cast(q_d.data()), thrust::raw_pointer_cast(shared_k_d.data()),
+          thrust::raw_pointer_cast(shared_v_d.data()),
+          thrust::raw_pointer_cast(o_cascade_0_d.data()), thrust::raw_pointer_cast(tmp_0_d.data()),
+          thrust::raw_pointer_cast(lse_cascade_0_d.data()), num_qo_heads, num_kv_heads,
+          /*qo_len=*/batch_size * qo_append_length,
+          /*kv_len=*/shared_prefix_length, head_dim,
+          /*causal=*/false, /*kv_layout=*/QKVLayout::kNHD,
+          /*pos_encoding_mode=*/PosEncodingMode::kNone, /*use_fp16_qk_reduction=*/false);
+
+      if (status != cudaSuccess) {
+        state.skip("Cascade implementation prefill failed with error: " +
+                   std::string(cudaGetErrorString(status)));
+      }
+
+      status = BatchPrefillWithPagedKVCacheWrapper<T, T, T, int32_t>(
+          &cascade_handler, thrust::raw_pointer_cast(q_d.data()),
+          thrust::raw_pointer_cast(qo_indptr_d.data()),
+          /*q_rope_offset=*/nullptr, paged_kv_casacde_d,
+          thrust::raw_pointer_cast(o_cascade_1_d.data()),
+          thrust::raw_pointer_cast(lse_cascade_1_d.data()), num_qo_heads, /*causal=*/true,
+          PosEncodingMode::kNone, /*use_fp16_qk_reduction=*/false);
+
+      if (status != cudaSuccess) {
+        state.skip("Cascade implementation unique kv prefill failed with error: " +
+                   std::string(cudaGetErrorString(status)));
+      }
+
+      status = MergeStateInPlace(thrust::raw_pointer_cast(o_cascade_0_d.data()),
+                                 thrust::raw_pointer_cast(lse_cascade_0_d.data()),
+                                 thrust::raw_pointer_cast(o_cascade_1_d.data()),
+                                 thrust::raw_pointer_cast(lse_cascade_1_d.data()),
+                                 batch_size * qo_append_length, num_qo_heads, head_dim);
+      if (status != cudaSuccess) {
+        state.skip("Cascade implementation merge failed with error: " +
+                   std::string(cudaGetErrorString(status)));
+      }
+      timer.stop();
+    });
+  } else {
+    thrust::device_vector<T> o_baseline_d(q_h.size());
+    thrust::device_vector<int32_t> kv_indptr_combined_d(kv_indptr_combined_h),
+        kv_indices_combined_d(kv_indices_combined_h),
+        kv_last_page_len_combined_d(kv_last_page_len_combined_h);
+    paged_kv_t<T, int32_t> paged_kv_baseline_d(
+        num_kv_heads, page_size, head_dim, batch_size, kv_layout,
+        thrust::raw_pointer_cast(k_data_d.data()), thrust::raw_pointer_cast(v_data_d.data()),
+        thrust::raw_pointer_cast(kv_indices_combined_d.data()),
+        thrust::raw_pointer_cast(kv_indptr_combined_d.data()),
+        thrust::raw_pointer_cast(kv_last_page_len_combined_d.data()));
+    BatchPrefillHandler baseline_handler;
+    size_t float_workspace_size_in_bytes = 32 * 1024 * 1024;
+    thrust::device_vector<char> float_buffer(float_workspace_size_in_bytes);
+    size_t int_workspace_size_in_bytes = 8 * 1024 * 1024;
+    thrust::device_vector<char> int_buffer(int_workspace_size_in_bytes);
+    baseline_handler.Plan<T, int32_t>(
+        (void*)thrust::raw_pointer_cast(float_buffer.data()), float_workspace_size_in_bytes,
+        (void*)thrust::raw_pointer_cast(int_buffer.data()), int_workspace_size_in_bytes,
+        qo_indptr_h.data(), kv_indptr_combined_h.data(),
+        /*total_num_rows=*/batch_size * qo_append_length, batch_size, num_qo_heads, num_kv_heads,
+        head_dim, page_size);
+    state.exec(nvbench::exec_tag::timer, [&](nvbench::launch& launch, auto& timer) {
+      timer.start();
+      cudaError_t status = BatchPrefillWithPagedKVCacheWrapper<T, T, T, int32_t>(
+          &baseline_handler, thrust::raw_pointer_cast(q_d.data()),
+          thrust::raw_pointer_cast(qo_indptr_d.data()),
+          /*q_rope_offset=*/nullptr, paged_kv_baseline_d,
+          thrust::raw_pointer_cast(o_baseline_d.data()),
+          /*lse=*/nullptr, num_qo_heads, /*causal=*/true, PosEncodingMode::kNone,
+          /*use_fp16_qk_reduction=*/false);
+
+      if (status != cudaSuccess) {
+        state.skip("Baseline implementation failed with error: " +
+                   std::string(cudaGetErrorString(status)));
+      }
+      timer.stop();
+    });
+  }
+}
+
+#define STR_HELPER(x) #x
+#define STR(x) STR_HELPER(x)
+#define BENCH_FLASHINFER_MERGE_KERNELS(T)                            \
+  auto bench_flashinfer_merge_states_##T##_ = bench_merge_states<T>; \
+  NVBENCH_BENCH(bench_flashinfer_merge_states_##T##_)                \
+      .set_name("flashinfer_merge_states_" STR(T))                   \
+      .add_int64_axis("num_index_sets", {2, 16, 64, 128, 256})       \
+      .add_int64_axis("seq_len", {1, 2, 4, 8, 16, 32, 64, 128, 256}) \
+      .add_int64_axis("num_heads", {32})                             \
+      .add_int64_axis("head_dim", {128})
+
+#define BENCH_FLASHINFER_TWO_LEVEL_SINGLE_PREFIX_CASCADE_DECODE_KERNELS(T)      \
+  auto bench_flashinfer_two_level_single_prefix_cascade_decode_##T##_ =         \
+      bench_two_level_single_prefix_cascade_decode<T>;                          \
+  NVBENCH_BENCH(bench_flashinfer_two_level_single_prefix_cascade_decode_##T##_) \
+      .set_name("flashinfer_two_level_single_prefix_cascade_decode_" STR(T))    \
+      .add_int64_axis("batch_size", {1, 8, 16, 64, 128, 256})                   \
+      .add_int64_axis("shared_prefix_length", {1024, 2048, 8192, 32768})        \
+      .add_int64_axis("unique_kv_length", {128, 256, 512, 1024, 2048})          \
+      .add_int64_axis("num_kv_heads", {32})                                     \
+      .add_int64_axis("num_qo_heads", {32})                                     \
+      .add_int64_axis("use_cascade", {1, 0})                                    \
+      .add_int64_axis("head_dim", {128})
+
+#define BENCH_FLASHINFER_TWO_LEVEL_SINGLE_PREFIX_CASCADE_APPEND_KERNELS(T)      \
+  auto bench_flashinfer_two_level_single_prefix_cascade_append_##T##_ =         \
+      bench_two_level_single_prefix_cascade_append<T>;                          \
+  NVBENCH_BENCH(bench_flashinfer_two_level_single_prefix_cascade_append_##T##_) \
+      .set_name("flashinfer_two_level_single_prefix_cascade_append_" STR(T))    \
+      .add_int64_axis("batch_size", {1, 8, 16, 64, 128, 256})                   \
+      .add_int64_axis("shared_prefix_length", {1024, 2048, 8192, 32768})        \
+      .add_int64_axis("unique_kv_length", {128, 256, 512, 1024, 2048})          \
+      .add_int64_axis("qo_append_length", {128})                                \
+      .add_int64_axis("num_kv_heads", {32})                                     \
+      .add_int64_axis("num_qo_heads", {32})                                     \
+      .add_int64_axis("use_cascade", {1, 0})                                    \
+      .add_int64_axis("head_dim", {128})
+
+BENCH_FLASHINFER_MERGE_KERNELS(half);
+BENCH_FLASHINFER_TWO_LEVEL_SINGLE_PREFIX_CASCADE_DECODE_KERNELS(half);
+BENCH_FLASHINFER_TWO_LEVEL_SINGLE_PREFIX_CASCADE_APPEND_KERNELS(half);

sglang_repo/sgl-kernel/3rdparty/flashinfer/src/bench_norm.cu

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2024 by FlashInfer team.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <thrust/device_vector.h>
+
+#include <flashinfer/norm.cuh>
+#include <nvbench/nvbench.cuh>
+
+#include "utils.h"
+
+using namespace flashinfer;
+
+template <typename T>
+void bench_rms_norm(nvbench::state& state) {
+  size_t batch_size = state.get_int64("batch_size");
+  size_t hidden_dim = state.get_int64("hidden_dim");
+
+  thrust::device_vector<T> x(batch_size * hidden_dim);
+  thrust::device_vector<T> w(hidden_dim);
+  thrust::device_vector<T> y(batch_size * hidden_dim);
+
+  state.add_global_memory_reads<T>(batch_size * hidden_dim + hidden_dim, "Read");
+  state.add_global_memory_writes<T>(batch_size * hidden_dim, "Write");
+
+  state.exec(nvbench::exec_tag::timer, [&](nvbench::launch& launch, auto& timer) {
+    timer.start();
+    cudaError_t status =
+        norm::RMSNorm<T>(thrust::raw_pointer_cast(x.data()), thrust::raw_pointer_cast(w.data()),
+                         thrust::raw_pointer_cast(y.data()), batch_size, hidden_dim, 1e-5);
+    timer.stop();
+    if (status != cudaSuccess) {
+      state.skip("RMSNorm kernel launch failed");
+    }
+  });
+}
+
+auto bench_rms_norm_f16 = bench_rms_norm<half>;
+NVBENCH_BENCH(bench_rms_norm_f16)
+    .set_name("bench_rms_norm_f16")
+    .add_int64_axis("batch_size", {32, 128, 512, 2048})
+    .add_int64_axis("hidden_dim", {3072, 4096, 32768});

sglang_repo/sgl-kernel/3rdparty/flashinfer/src/bench_sampling.cu

@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) 2024 by FlashInfer team.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <thrust/device_vector.h>
+
+#include <flashinfer/sampling.cuh>
+#include <nvbench/nvbench.cuh>
+
+#include "utils.h"
+
+using namespace flashinfer;
+
+template <typename T>
+void bench_sampling_with_probability(nvbench::state& state) {
+  size_t batch_size = state.get_int64("batch_size");
+  size_t vocab_size = state.get_int64("vocab_size");
+  bool deterministic = state.get_int64("determinisic");
+
+  std::vector<T> probs_h(batch_size * vocab_size);
+  std::vector<T> uniform_samples_h(batch_size);
+  utils::vec_uniform_<T>(uniform_samples_h, 0, 1);
+  utils::vec_uniform_<T>(probs_h, 0, 1);
+
+  // normalize the probs_h
+  for (uint32_t i = 0; i < batch_size; ++i) {
+    T sum = 0;
+    for (uint32_t j = 0; j < vocab_size; ++j) {
+      sum += probs_h[i * vocab_size + j];
+    }
+    for (uint32_t j = 0; j < vocab_size; ++j) {
+      probs_h[i * vocab_size + j] /= sum;
+    }
+  }
+
+  thrust::device_vector<T> probs_d(probs_h);
+  thrust::device_vector<T> uniform_samples_d(uniform_samples_h);
+  thrust::device_vector<int32_t> output_d(batch_size);
+
+  state.add_global_memory_reads<T>(batch_size * vocab_size, "Read");
+  state.add_global_memory_writes<int32_t>(batch_size, "Write");
+
+  state.exec(nvbench::exec_tag::timer, [&](nvbench::launch& launch, auto& timer) {
+    timer.start();
+    cudaError_t status = sampling::SamplingFromProb<T>(
+        thrust::raw_pointer_cast(probs_d.data()),
+        thrust::raw_pointer_cast(uniform_samples_d.data()),
+        thrust::raw_pointer_cast(output_d.data()), batch_size, vocab_size, deterministic);
+    timer.stop();
+    if (status != cudaSuccess) {
+      state.skip("CUDA error: " + std::string(cudaGetErrorString(status)));
+    }
+  });
+}
+
+template <typename T>
+void bench_top_p_sampling_with_probability(nvbench::state& state) {
+  size_t batch_size = state.get_int64("batch_size");
+  size_t vocab_size = state.get_int64("vocab_size");
+  bool deterministic = state.get_int64("determinisic");
+  double p = state.get_float64("p");
+  constexpr uint32_t max_top_p_rounds = 32;
+
+  std::vector<T> probs_h(batch_size * vocab_size);
+  std::vector<T> uniform_samples_h(max_top_p_rounds * batch_size);
+  utils::vec_uniform_<T>(uniform_samples_h, 0, 1);
+  utils::vec_uniform_<T>(probs_h, 0, 1);
+
+  // normalize the probs_h
+  for (uint32_t i = 0; i < batch_size; ++i) {
+    T sum = 0;
+    for (uint32_t j = 0; j < vocab_size; ++j) {
+      sum += probs_h[i * vocab_size + j];
+    }
+    for (uint32_t j = 0; j < vocab_size; ++j) {
+      probs_h[i * vocab_size + j] /= sum;
+    }
+  }
+
+  thrust::device_vector<T> probs_d(probs_h);
+  thrust::device_vector<T> uniform_samples_d(uniform_samples_h);
+  thrust::device_vector<int32_t> output_d(batch_size);
+  thrust::device_vector<bool> success_d(batch_size);
+
+  state.add_global_memory_reads<T>(batch_size * vocab_size, "Read");
+  state.add_global_memory_writes<int32_t>(batch_size, "Write");
+
+  state.exec(nvbench::exec_tag::timer, [&](nvbench::launch& launch, auto& timer) {
+    timer.start();
+    cudaError_t status = sampling::TopPSamplingFromProb<T, int32_t>(
+        thrust::raw_pointer_cast(probs_d.data()),
+        thrust::raw_pointer_cast(uniform_samples_d.data()),
+        thrust::raw_pointer_cast(output_d.data()), thrust::raw_pointer_cast(success_d.data()),
+        /*top_p_arr=*/nullptr, batch_size, p, vocab_size, max_top_p_rounds, deterministic);
+    timer.stop();
+    if (status != cudaSuccess) {
+      state.skip("CUDA error: " + std::string(cudaGetErrorString(status)));
+    }
+  });
+}
+
+template <typename T>
+void bench_top_k_sampling_with_probability(nvbench::state& state) {
+  size_t batch_size = state.get_int64("batch_size");
+  size_t vocab_size = state.get_int64("vocab_size");
+  size_t k = state.get_int64("k");
+  bool deterministic = state.get_int64("determinisic");
+  constexpr uint32_t max_top_k_rounds = 32;
+
+  std::vector<T> probs_h(batch_size * vocab_size);
+  std::vector<T> uniform_samples_h(max_top_k_rounds * batch_size);
+  utils::vec_uniform_<T>(uniform_samples_h, 0, 1);
+  utils::vec_uniform_<T>(probs_h, 0, 1);
+
+  // normalize the probs_h
+  for (uint32_t i = 0; i < batch_size; ++i) {
+    T sum = 0;
+    for (uint32_t j = 0; j < vocab_size; ++j) {
+      sum += probs_h[i * vocab_size + j];
+    }
+    for (uint32_t j = 0; j < vocab_size; ++j) {
+      probs_h[i * vocab_size + j] /= sum;
+    }
+  }
+
+  thrust::device_vector<T> probs_d(probs_h);
+  thrust::device_vector<T> uniform_samples_d(uniform_samples_h);
+  thrust::device_vector<int32_t> output_d(batch_size);
+  thrust::device_vector<bool> success_d(batch_size);
+
+  state.add_global_memory_reads<T>(batch_size * vocab_size, "Read");
+  state.add_global_memory_writes<int32_t>(batch_size, "Write");
+
+  state.exec(nvbench::exec_tag::timer, [&](nvbench::launch& launch, auto& timer) {
+    timer.start();
+    cudaError_t status = sampling::TopKSamplingFromProb<T, int32_t>(
+        thrust::raw_pointer_cast(probs_d.data()),
+        thrust::raw_pointer_cast(uniform_samples_d.data()),
+        thrust::raw_pointer_cast(output_d.data()), thrust::raw_pointer_cast(success_d.data()),
+        /*top_k_arr=*/nullptr, batch_size, k, vocab_size, max_top_k_rounds, deterministic);
+    timer.stop();
+    if (status != cudaSuccess) {
+      state.skip("CUDA error: " + std::string(cudaGetErrorString(status)));
+    }
+  });
+}
+
+auto bench_sampling_with_probability_f32 = bench_sampling_with_probability<float>;
+NVBENCH_BENCH(bench_sampling_with_probability_f32)
+    .set_name("bench_sampling_with_probability_f32")
+    .add_int64_axis("batch_size", {16, 32, 128, 512, 2048})
+    .add_int64_axis("vocab_size", {32000, 32001, 32002, 128000, 256000})
+    .add_int64_axis("determinisic", {0, 1});
+
+auto bench_top_p_sampling_with_probability_f32 = bench_top_p_sampling_with_probability<float>;
+NVBENCH_BENCH(bench_top_p_sampling_with_probability_f32)
+    .set_name("bench_top_p_sampling_with_probability_f32")
+    .add_int64_axis("batch_size", {16, 32, 128, 512, 2048})
+    .add_int64_axis("vocab_size", {32000, 32001, 32002, 128000, 256000})
+    .add_float64_axis("p", {0.1, 0.5, 0.9, 1.0})
+    .add_int64_axis("determinisic", {0, 1});
+
+auto bench_top_k_sampling_with_probability_f32 = bench_top_k_sampling_with_probability<float>;
+NVBENCH_BENCH(bench_top_k_sampling_with_probability_f32)
+    .set_name("bench_top_k_sampling_with_probability_f32")
+    .add_int64_axis("batch_size", {16, 32, 128, 512, 2048})
+    .add_int64_axis("vocab_size", {32000, 32001, 32002, 128000, 256000})
+    .add_int64_axis("k", {16, 32, 128, 1024})
+    .add_int64_axis("determinisic", {0, 1});

sglang_repo/sgl-kernel/3rdparty/flashinfer/src/bench_single_decode.cu

@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) 2023 by FlashInfer team.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <thrust/device_vector.h>
+
+#include <nvbench/nvbench.cuh>
+
+#include "flashinfer_ops.cuh"
+
+using flashinfer::PosEncodingMode;
+using flashinfer::QKVLayout;
+
+template <typename dtype_qo, typename dtype_kv>
+void bench_flashinfer_single_decode(nvbench::state& state) {
+  size_t seq_len = state.get_int64("seq_len");
+  size_t num_qo_heads = state.get_int64("num_qo_heads");
+  size_t num_kv_heads = state.get_int64("num_kv_heads");
+  size_t head_dim = state.get_int64("head_dim");
+  size_t pos_encoding_mode = state.get_int64("pos_encoding_mode");
+  size_t kv_layout = state.get_int64("kv_layout");
+  bool cooperative = state.get_int64("cooperative");
+  // Allocate input data:
+  thrust::device_vector<dtype_qo> Q(num_qo_heads * head_dim);
+  thrust::device_vector<dtype_kv> K(seq_len * num_kv_heads * head_dim);
+  thrust::device_vector<dtype_kv> V(seq_len * num_kv_heads * head_dim);
+  thrust::device_vector<dtype_qo> O(num_qo_heads * head_dim);
+  thrust::device_vector<dtype_qo> tmp(16 * 1024 * 1024);
+
+  // Provide throughput information:
+  state.add_global_memory_reads<dtype_kv>(
+      num_qo_heads * head_dim + 2 * seq_len * num_kv_heads * head_dim, "Read");
+  state.add_global_memory_writes<dtype_qo>(num_qo_heads * head_dim, "Write");
+
+  state.exec(nvbench::exec_tag::timer, [&](nvbench::launch& launch, auto& timer) {
+    timer.start();
+    cudaError_t status = flashinfer::SingleDecodeWithKVCache(
+        thrust::raw_pointer_cast(Q.data()), thrust::raw_pointer_cast(K.data()),
+        thrust::raw_pointer_cast(V.data()), thrust::raw_pointer_cast(O.data()),
+        cooperative ? thrust::raw_pointer_cast(tmp.data()) : nullptr, num_qo_heads, num_kv_heads,
+        seq_len, head_dim, QKVLayout(kv_layout), PosEncodingMode(pos_encoding_mode),
+        /*maybe_sm_scale=*/std::nullopt,
+        /*rope_scale=*/1.f,
+        /*rope_theta=*/1e4, launch.get_stream());
+    if (status != cudaSuccess) {
+      state.skip("CUDA error: " + std::string(cudaGetErrorString(status)));
+    }
+    timer.stop();
+  });
+}
+
+// Use prefill kernel for decoding, useful in GQA on GPUs with low non-tensor performance such as
+// A100
+template <typename dtype_in, typename dtype_out>
+void bench_flashinfer_single_decode_with_prefill(nvbench::state& state) {
+  size_t seq_len = state.get_int64("seq_len");
+  size_t num_qo_heads = state.get_int64("num_qo_heads");
+  size_t num_kv_heads = state.get_int64("num_kv_heads");
+  size_t head_dim = state.get_int64("head_dim");
+  size_t pos_encoding_mode = state.get_int64("pos_encoding_mode");
+  size_t kv_layout = state.get_int64("kv_layout");
+  bool cooperative = state.get_int64("cooperative");
+  // Allocate input data:
+  thrust::device_vector<dtype_in> Q(num_qo_heads * head_dim);
+  thrust::device_vector<dtype_in> K(seq_len * num_kv_heads * head_dim);
+  thrust::device_vector<dtype_in> V(seq_len * num_kv_heads * head_dim);
+  thrust::device_vector<dtype_out> O(num_qo_heads * head_dim);
+  thrust::device_vector<dtype_out> tmp(16 * 1024 * 1024);
+
+  // Provide throughput information:
+  state.add_global_memory_reads<dtype_in>(
+      num_qo_heads * head_dim + 2 * seq_len * num_kv_heads * head_dim, "Read");
+  state.add_global_memory_writes<dtype_out>(num_qo_heads * head_dim, "Write");
+
+  state.exec(nvbench::exec_tag::timer, [&](nvbench::launch& launch, auto& timer) {
+    timer.start();
+    cudaError_t status = flashinfer::SinglePrefillWithKVCache(
+        thrust::raw_pointer_cast(Q.data()), thrust::raw_pointer_cast(K.data()),
+        thrust::raw_pointer_cast(V.data()), thrust::raw_pointer_cast(O.data()),
+        /*tmp=*/cooperative ? thrust::raw_pointer_cast(tmp.data()) : nullptr,
+        /*lse=*/nullptr, num_qo_heads, num_kv_heads,
+        /*qo_len=*/1,
+        /*kv_len=*/seq_len, head_dim,
+        /*causal=*/false, QKVLayout(kv_layout), PosEncodingMode(pos_encoding_mode),
+        /*use_fp16_qk_reduction=*/false,
+        /*maybe_sm_scale=*/std::nullopt,
+        /*rope_scale=*/1.f,
+        /*rope_theta=*/1e4, launch.get_stream());
+    if (status != cudaSuccess) {
+      state.skip("CUDA error: " + std::string(cudaGetErrorString(status)));
+    }
+    timer.stop();
+  });
+}
+
+#define STR_HELPER(x) #x
+#define STR(x) STR_HELPER(x)
+#define BENCH_FLASHINFER_SINGLE_DECODE(dtype_qo, dtype_kv)                                  \
+  auto bench_flashinfer_single_decode_##dtype_qo##_##dtype_kv##_ =                          \
+      bench_flashinfer_single_decode<dtype_qo, dtype_kv>;                                   \
+  NVBENCH_BENCH(bench_flashinfer_single_decode_##dtype_qo##_##dtype_kv##_)                  \
+      .set_name(("bench_flashinfer_single_decode_" STR(dtype_qo) "_" STR(dtype_kv)))        \
+      .add_int64_axis("seq_len",                                                            \
+                      {32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536}) \
+      .add_int64_axis("num_qo_heads", {32})                                                 \
+      .add_int64_axis("num_kv_heads", {32, 4})                                              \
+      .add_int64_axis("head_dim", {128})                                                    \
+      .add_int64_axis("pos_encoding_mode", {0, 1})                                          \
+      .add_int64_axis("kv_layout", {0, 1})                                                  \
+      .add_int64_axis("cooperative", {1})
+
+#define BENCH_FLASHINFER_SINGLE_DECODE_WITH_PREFILL(dtype_in, dtype_out)                           \
+  auto bench_flashinfer_single_decode_with_prefill_##dtype_in##_##dtype_out##_ =                   \
+      bench_flashinfer_single_decode_with_prefill<dtype_in, dtype_out>;                            \
+  NVBENCH_BENCH(bench_flashinfer_single_decode_with_prefill_##dtype_in##_##dtype_out##_)           \
+      .set_name(("bench_flashinfer_single_decode_with_prefill_" STR(dtype_in) "_" STR(dtype_out))) \
+      .add_int64_axis("seq_len",                                                                   \
+                      {32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536})        \
+      .add_int64_axis("num_qo_heads", {32})                                                        \
+      .add_int64_axis("num_kv_heads", {32, 4})                                                     \
+      .add_int64_axis("head_dim", {128})                                                           \
+      .add_int64_axis("pos_encoding_mode", {0, 1})                                                 \
+      .add_int64_axis("kv_layout", {0, 1})                                                         \
+      .add_int64_axis("cooperative", {1})
+
+BENCH_FLASHINFER_SINGLE_DECODE(half, half);
+BENCH_FLASHINFER_SINGLE_DECODE(half, __nv_fp8_e5m2);
+// Use prefill kernel for decoding, useful in GQA on GPUs with low non-tensor performance such as
+// A100
+BENCH_FLASHINFER_SINGLE_DECODE_WITH_PREFILL(half, half);

sglang_repo/sgl-kernel/3rdparty/flashinfer/src/bench_single_prefill.cu

@@ -0,0 +1,217 @@
+/*
+ * Copyright (c) 2023 by FlashInfer team.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <thrust/device_vector.h>
+
+#include <nvbench/nvbench.cuh>
+
+#include "flashinfer_ops.cuh"
+
+using flashinfer::PosEncodingMode;
+using flashinfer::QKVLayout;
+
+inline uint32_t ceil_div(uint32_t a, uint32_t b) { return (a + b - 1) / b; }
+
+template <bool append>
+void bench_flashinfer_single_prefill_fp8(nvbench::state& state) {
+  size_t kv_len = state.get_int64("kv_len");
+  size_t qo_len = kv_len;
+  if (append) {
+    qo_len = state.get_int64("qo_len");
+    if (qo_len > kv_len) {
+      state.skip("qo_len > kv_len");
+    }
+  }
+  size_t num_qo_heads = state.get_int64("num_qo_heads");
+  size_t num_kv_heads = state.get_int64("num_kv_heads");
+  size_t head_dim = state.get_int64("head_dim");
+  size_t pos_encoding_mode = state.get_int64("pos_encoding_mode");
+  size_t kv_layout = state.get_int64("kv_layout");
+  bool causal = state.get_int64("causal");
+  bool cooperative = state.get_int64("cooperative");
+  bool use_fp16_qk_reduction = state.get_int64("use_fp16_qk_reduction");
+  // Allocate input data:
+  thrust::device_vector<half> Q(qo_len * num_qo_heads * head_dim);
+  thrust::device_vector<__nv_fp8_e4m3> K(kv_len * num_kv_heads * head_dim);
+  thrust::device_vector<__nv_fp8_e4m3> V(kv_len * num_kv_heads * head_dim);
+  thrust::device_vector<half> O(qo_len * num_qo_heads * head_dim);
+  thrust::device_vector<half> tmp(16 * 1024 * 1024);
+
+  // Provide throughput information:
+  state.add_global_memory_reads<uint8_t>(
+      (qo_len * num_qo_heads * sizeof(half) + 2 * kv_len * num_kv_heads) * head_dim, "Read");
+  state.add_global_memory_writes<half>(qo_len * num_qo_heads * head_dim, "Write");
+
+  state.exec(nvbench::exec_tag::timer, [&](nvbench::launch& launch, auto& timer) {
+    timer.start();
+    cudaError_t status;
+    status = flashinfer::SinglePrefillWithKVCache<half, __nv_fp8_e4m3, half>(
+        thrust::raw_pointer_cast(Q.data()), thrust::raw_pointer_cast(K.data()),
+        thrust::raw_pointer_cast(V.data()), thrust::raw_pointer_cast(O.data()),
+        /*tmp=*/cooperative ? thrust::raw_pointer_cast(tmp.data()) : nullptr,
+        /*lse=*/nullptr, num_qo_heads, num_kv_heads, qo_len, kv_len, head_dim, causal,
+        QKVLayout(kv_layout), PosEncodingMode(pos_encoding_mode), use_fp16_qk_reduction,
+        /*maybe_sm_scale=*/std::nullopt,
+        /*rope_scale=*/1.f,
+        /*rope_theta=*/1e4, launch.get_stream());
+    if (status != cudaSuccess) {
+      state.skip("CUDA error: " + std::string(cudaGetErrorString(status)));
+    }
+    timer.stop();
+  });
+
+  const auto measured_mean = static_cast<nvbench::float32_t>(
+      state.get_summary("nv/cold/time/gpu/mean").get_float64("value"));
+  auto& summ = state.add_summary("nv/tflops");
+  summ.set_string("description", "Achieved TFlops/s");
+  summ.set_string("name", "TFlops/s");
+  float tflops;
+  if (causal) {
+    tflops = qo_len * (2 * kv_len - qo_len) * 2 * num_qo_heads * head_dim / measured_mean / 1e12;
+  } else {
+    tflops = qo_len * kv_len * 4 * num_qo_heads * head_dim / measured_mean / 1e12;
+  }
+  summ.set_float64("value", tflops);
+}
+
+template <typename dtype_in, typename dtype_out, bool append>
+void bench_flashinfer_single_prefill(nvbench::state& state) {
+  size_t kv_len = state.get_int64("kv_len");
+  size_t qo_len = kv_len;
+  if (append) {
+    qo_len = state.get_int64("qo_len");
+    if (qo_len > kv_len) {
+      state.skip("qo_len > kv_len");
+    }
+  }
+  size_t num_qo_heads = state.get_int64("num_qo_heads");
+  size_t num_kv_heads = state.get_int64("num_kv_heads");
+  size_t head_dim = state.get_int64("head_dim");
+  size_t pos_encoding_mode = state.get_int64("pos_encoding_mode");
+  size_t kv_layout = state.get_int64("kv_layout");
+  bool causal = state.get_int64("causal");
+  bool cooperative = state.get_int64("cooperative");
+  bool custom_mask = state.get_int64("custom_mask");
+  bool use_fp16_qk_reduction = state.get_int64("use_fp16_qk_reduction");
+  // Allocate input data:
+  thrust::device_vector<dtype_in> Q(qo_len * num_qo_heads * head_dim);
+  thrust::device_vector<dtype_in> K(kv_len * num_kv_heads * head_dim);
+  thrust::device_vector<dtype_in> V(kv_len * num_kv_heads * head_dim);
+  thrust::device_vector<uint8_t> mask(ceil_div(qo_len * kv_len, 8));
+  thrust::device_vector<dtype_out> O(qo_len * num_qo_heads * head_dim);
+  thrust::device_vector<dtype_out> tmp(16 * 1024 * 1024);
+
+  // Provide throughput information:
+  state.add_global_memory_reads<dtype_in>(
+      (qo_len * num_qo_heads + 2 * kv_len * num_kv_heads) * head_dim, "Read");
+  state.add_global_memory_writes<dtype_out>(qo_len * num_qo_heads * head_dim, "Write");
+
+  state.exec(nvbench::exec_tag::timer, [&](nvbench::launch& launch, auto& timer) {
+    timer.start();
+    cudaError_t status;
+    if (custom_mask) {
+      status = flashinfer::SinglePrefillWithKVCacheCustomMask<dtype_in, dtype_out>(
+          thrust::raw_pointer_cast(Q.data()), thrust::raw_pointer_cast(K.data()),
+          thrust::raw_pointer_cast(V.data()), thrust::raw_pointer_cast(mask.data()),
+          thrust::raw_pointer_cast(O.data()),
+          /*tmp=*/cooperative ? thrust::raw_pointer_cast(tmp.data()) : nullptr,
+          /*lse=*/nullptr, num_qo_heads, num_kv_heads, qo_len, kv_len, head_dim,
+          QKVLayout(kv_layout), PosEncodingMode(pos_encoding_mode), use_fp16_qk_reduction,
+          /*maybe_sm_scale=*/std::nullopt,
+          /*rope_scale=*/1.f,
+          /*rope_theta=*/1e4, launch.get_stream());
+    } else {
+      status = flashinfer::SinglePrefillWithKVCache<dtype_in, dtype_in, dtype_out>(
+          thrust::raw_pointer_cast(Q.data()), thrust::raw_pointer_cast(K.data()),
+          thrust::raw_pointer_cast(V.data()), thrust::raw_pointer_cast(O.data()),
+          /*tmp=*/cooperative ? thrust::raw_pointer_cast(tmp.data()) : nullptr,
+          /*lse=*/nullptr, num_qo_heads, num_kv_heads, qo_len, kv_len, head_dim, causal,
+          QKVLayout(kv_layout), PosEncodingMode(pos_encoding_mode), use_fp16_qk_reduction,
+          /*maybe_sm_scale=*/std::nullopt,
+          /*rope_scale=*/1.f,
+          /*rope_theta=*/1e4, launch.get_stream());
+    }
+    if (status != cudaSuccess) {
+      state.skip("CUDA error: " + std::string(cudaGetErrorString(status)));
+    }
+    timer.stop();
+  });
+
+  const auto measured_mean = static_cast<nvbench::float32_t>(
+      state.get_summary("nv/cold/time/gpu/mean").get_float64("value"));
+  auto& summ = state.add_summary("nv/tflops");
+  summ.set_string("description", "Achieved TFlops/s");
+  summ.set_string("name", "TFlops/s");
+  float tflops;
+  if (causal) {
+    tflops = qo_len * (2 * kv_len - qo_len) * 2 * num_qo_heads * head_dim / measured_mean / 1e12;
+  } else {
+    tflops = qo_len * kv_len * 4 * num_qo_heads * head_dim / measured_mean / 1e12;
+  }
+  summ.set_float64("value", tflops);
+}
+
+#define STR_HELPER(x) #x
+#define STR(x) STR_HELPER(x)
+#define BENCH_FLASHINFER_PREFILL(dtype_in, dtype_out)                                       \
+  auto bench_flashinfer_single_prefill_##dtype_in##_##dtype_out##_ =                        \
+      bench_flashinfer_single_prefill<dtype_in, dtype_out, false>;                          \
+  NVBENCH_BENCH(bench_flashinfer_single_prefill_##dtype_in##_##dtype_out##_)                \
+      .set_name(("bench_flashinfer_single_prefill_" STR(dtype_in) "_" STR(dtype_out)))      \
+      .add_int64_axis("kv_len",                                                             \
+                      {32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536}) \
+      .add_int64_axis("num_qo_heads", {32})                                                 \
+      .add_int64_axis("num_kv_heads", {32})                                                 \
+      .add_int64_axis("head_dim", {128})                                                    \
+      .add_int64_axis("causal", {0, 1})                                                     \
+      .add_int64_axis("kv_layout", {0, 1})                                                  \
+      .add_int64_axis("pos_encoding_mode", {0, 1})                                          \
+      .add_int64_axis("use_fp16_qk_reduction", {0, 1})                                      \
+      .add_int64_axis("custom_mask", {0})                                                   \
+      .add_int64_axis("cooperative", {1})
+
+auto bench_flashinfer_single_prefill_fp8_kv = bench_flashinfer_single_prefill_fp8<false>;
+NVBENCH_BENCH(bench_flashinfer_single_prefill_fp8_kv)
+    .set_name(("bench_flashinfer_single_prefill_fp8_kv"))
+    .add_int64_axis("kv_len", {32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536})
+    .add_int64_axis("num_qo_heads", {32})
+    .add_int64_axis("num_kv_heads", {32})
+    .add_int64_axis("head_dim", {128})
+    .add_int64_axis("causal", {0, 1})
+    .add_int64_axis("kv_layout", {0, 1})
+    .add_int64_axis("pos_encoding_mode", {0, 1})
+    .add_int64_axis("use_fp16_qk_reduction", {0, 1})
+    .add_int64_axis("custom_mask", {0})
+    .add_int64_axis("cooperative", {1});
+
+#define BENCH_FLASHINFER_APPEND_PREFILL(dtype_in, dtype_out)                                  \
+  auto bench_flashinfer_single_append_prefill_##dtype_in##_##dtype_out##_ =                   \
+      bench_flashinfer_single_prefill<dtype_in, dtype_out, true>;                             \
+  NVBENCH_BENCH(bench_flashinfer_single_append_prefill_##dtype_in##_##dtype_out##_)           \
+      .set_name(("bench_flashinfer_single_append_prefill_" STR(dtype_in) "_" STR(dtype_out))) \
+      .add_int64_axis("qo_len", {128})                                                        \
+      .add_int64_axis("kv_len", {128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536}) \
+      .add_int64_axis("num_qo_heads", {32})                                                   \
+      .add_int64_axis("num_kv_heads", {32})                                                   \
+      .add_int64_axis("head_dim", {128})                                                      \
+      .add_int64_axis("causal", {0, 1})                                                       \
+      .add_int64_axis("kv_layout", {0, 1})                                                    \
+      .add_int64_axis("pos_encoding_mode", {0, 1})                                            \
+      .add_int64_axis("use_fp16_qk_reduction", {0, 1})                                        \
+      .add_int64_axis("custom_mask", {0})                                                     \
+      .add_int64_axis("cooperative", {0, 1})
+
+BENCH_FLASHINFER_PREFILL(half, half);
+BENCH_FLASHINFER_APPEND_PREFILL(half, half);

sglang_repo/sgl-kernel/3rdparty/flashinfer/src/cpu_reference.h

@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) 2023 by FlashInfer team.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <flashinfer/exception.h>
+
+#include <flashinfer/page.cuh>
+#include <flashinfer/pos_enc.cuh>
+
+#include "utils.h"
+
+namespace cpu_reference {
+
+using namespace flashinfer;
+
+template <typename T>
+inline std::vector<T> rms_norm(const T* input, const T* weight, size_t batch_size, size_t d,
+                               float eps = 1e-5) {
+  std::vector<T> output(batch_size * d);
+  for (size_t i = 0; i < batch_size; ++i) {
+    float sum = 0;
+    for (size_t j = 0; j < d; ++j) {
+      sum += float(input[i * d + j]) * float(input[i * d + j]);
+    }
+    float rms_rcp = 1.f / (std::sqrt(sum / float(d)) + eps);
+    for (size_t j = 0; j < d; ++j) {
+      output[i * d + j] = (float(input[i * d + j]) * rms_rcp) * float(weight[j]);
+    }
+  }
+  return std::move(output);
+}
+
+template <typename T>
+inline std::vector<T> exclusive_prefix_sum(const T* input, size_t batch_size, size_t d) {
+  std::vector<T> output(batch_size * d);
+  for (size_t i = 0; i < batch_size; ++i) {
+    for (size_t j = 0; j < d; ++j) {
+      output[i * d + j] = (j == 0) ? 0 : output[i * d + j - 1] + input[i * d + j - 1];
+    }
+  }
+  return std::move(output);
+}
+
+template <typename T>
+inline std::vector<float> apply_llama_rope(const T* input, size_t D, size_t offset,
+                                           float rope_scale, float rope_theta) {
+  std::vector<float> rst(D);
+  std::vector<float> permuted_input(D);
+  for (size_t k = 0; k < D; ++k) {
+    permuted_input[k] = (k < D / 2) ? -float(input[k + D / 2]) : float(input[k - D / 2]);
+  }
+
+  for (size_t k = 0; k < D; ++k) {
+    float inv_freq =
+        (offset / rope_scale) / (std::pow(rope_theta, float(2 * (k % (D / 2))) / float(D)));
+    float cos = std::cos(inv_freq);
+    float sin = std::sin(inv_freq);
+    rst[k] = cos * float(input[k]) + sin * permuted_input[k];
+  }
+  return std::move(rst);
+}
+
+template <typename dtype_q, typename dtype_kv, typename dtype_out>
+std::vector<dtype_out> single_mha(const std::vector<dtype_q>& q, const std::vector<dtype_kv>& k,
+                                  const std::vector<dtype_kv>& v, size_t qo_len, size_t kv_len,
+                                  size_t num_qo_heads, size_t num_kv_heads, size_t head_dim,
+                                  bool causal = true, QKVLayout kv_layout = QKVLayout::kHND,
+                                  PosEncodingMode pos_encoding_mode = PosEncodingMode::kNone,
+                                  float rope_scale = 1.f, float rope_theta = 1e4) {
+  assert(qo_len <= kv_len);
+  assert(num_qo_heads % num_kv_heads == 0);
+  float sm_scale = 1.f / std::sqrt(float(head_dim));
+  std::vector<dtype_out> o(qo_len * num_qo_heads * head_dim);
+  std::vector<float> att(kv_len);
+  std::vector<float> q_rotary_local(head_dim);
+  std::vector<float> k_rotary_local(head_dim);
+  DISPATCH_head_dim(head_dim, HEAD_DIM, {
+    tensor_info_t info(qo_len, kv_len, num_qo_heads, num_kv_heads, kv_layout, HEAD_DIM);
+    for (size_t qo_head_idx = 0; qo_head_idx < num_qo_heads; ++qo_head_idx) {
+      const size_t kv_head_idx = qo_head_idx / info.get_group_size();
+      for (size_t q_idx = 0; q_idx < qo_len; ++q_idx) {
+        float max_val = -5e4;
+        if (pos_encoding_mode == PosEncodingMode::kRoPELlama) {
+          q_rotary_local = std::move(cpu_reference::apply_llama_rope(
+              q.data() + info.get_q_elem_offset(q_idx, qo_head_idx, 0), head_dim,
+              q_idx + kv_len - qo_len, rope_scale, rope_theta));
+        }
+        for (size_t kv_idx = 0; kv_idx < kv_len; ++kv_idx) {
+          att[kv_idx] = 0.;
+          switch (pos_encoding_mode) {
+            case PosEncodingMode::kNone: {
+              for (size_t feat_idx = 0; feat_idx < head_dim; ++feat_idx) {
+                att[kv_idx] += float(q[info.get_q_elem_offset(q_idx, qo_head_idx, feat_idx)]) *
+                               float(k[info.get_kv_elem_offset(kv_idx, kv_head_idx, feat_idx)]) *
+                               sm_scale;
+              }
+              break;
+            }
+            case PosEncodingMode::kRoPELlama: {
+              k_rotary_local = std::move(cpu_reference::apply_llama_rope(
+                  k.data() + info.get_kv_elem_offset(kv_idx, kv_head_idx, 0), head_dim, kv_idx,
+                  rope_scale, rope_theta));
+              for (size_t feat_idx = 0; feat_idx < head_dim; ++feat_idx) {
+                att[kv_idx] += q_rotary_local[feat_idx] * k_rotary_local[feat_idx] * sm_scale;
+              }
+              break;
+            }
+            default: {
+              std::ostringstream err_msg;
+              err_msg << "Unsupported rotary mode.";
+              FLASHINFER_ERROR(err_msg.str());
+            }
+          }
+          // apply mask
+          if (causal && kv_idx > kv_len + q_idx - qo_len) {
+            att[kv_idx] = -5e4;
+          }
+          max_val = std::max(max_val, att[kv_idx]);
+        }
+        // exp minus max
+        float denom = 0;
+        for (size_t kv_idx = 0; kv_idx < kv_len; ++kv_idx) {
+          att[kv_idx] = std::exp(att[kv_idx] - max_val);
+          denom += att[kv_idx];
+        }
+
+        // divide by denom
+        for (size_t kv_idx = 0; kv_idx < kv_len; ++kv_idx) {
+          att[kv_idx] /= denom;
+        }
+
+        for (size_t feat_idx = 0; feat_idx < head_dim; ++feat_idx) {
+          float o_float = 0.;
+          for (size_t kv_idx = 0; kv_idx < kv_len; ++kv_idx) {
+            o_float +=
+                att[kv_idx] * float(v[info.get_kv_elem_offset(kv_idx, kv_head_idx, feat_idx)]);
+          }
+          o[info.get_o_elem_offset(q_idx, qo_head_idx, feat_idx)] = dtype_out(o_float);
+        }
+      }
+    }
+  });
+  return std::move(o);
+}
+
+template <typename T, typename IdxType>
+void append_paged_kv_cache(paged_kv_t<T, IdxType> page_cpu, const std::vector<std::vector<T>>& keys,
+                           const std::vector<std::vector<T>>& values,
+                           const std::vector<IdxType>& append_indptr) {
+  size_t batch_size = page_cpu.batch_size;
+  size_t num_heads = page_cpu.num_heads;
+  size_t head_dim = page_cpu.head_dim;
+  size_t page_size = page_cpu.page_size;
+  for (size_t i = 0; i < batch_size; ++i) {
+    const std::vector<T>& ki = keys[i];
+    const std::vector<T>& vi = values[i];
+    size_t append_seq_len = append_indptr[i + 1] - append_indptr[i];
+    size_t num_pages_i = page_cpu.indptr[i + 1] - page_cpu.indptr[i];
+    size_t seq_len = (num_pages_i - 1) * page_size + page_cpu.last_page_len[i];
+    assert(append_seq_len <= seq_len);
+    size_t append_start = seq_len - append_seq_len;
+
+    for (size_t j = 0; j < append_seq_len; ++j) {
+      size_t page_seq_idx = j + append_start;
+      size_t page_idx = page_cpu.indices[page_cpu.indptr[i] + page_seq_idx / page_size];
+      size_t entry_idx = page_seq_idx % page_size;
+      for (size_t h = 0; h < num_heads; ++h) {
+        std::copy(ki.begin() + (j * num_heads + h) * head_dim,
+                  ki.begin() + (j * num_heads + h + 1) * head_dim,
+                  page_cpu.k_data + page_cpu.get_elem_offset(page_idx, h, entry_idx, 0));
+        std::copy(vi.begin() + (j * num_heads + h) * head_dim,
+                  vi.begin() + (j * num_heads + h + 1) * head_dim,
+                  page_cpu.v_data + page_cpu.get_elem_offset(page_idx, h, entry_idx, 0));
+      }
+    }
+  }
+}
+
+}  // namespace cpu_reference

sglang_repo/sgl-kernel/3rdparty/flashinfer/src/flashinfer_ops.cuh

@@ -0,0 +1,647 @@
+/*
+ * Copyright (c) 2024 by FlashInfer team.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <flashinfer/attention/default_decode_params.cuh>
+#include <flashinfer/attention/default_prefill_params.cuh>
+#include <flashinfer/attention/scheduler.cuh>
+#include <flashinfer/attention/variants.cuh>
+#include <optional>
+
+#include "flashinfer/allocator.h"
+#include "flashinfer/attention/mask.cuh"
+#include "flashinfer/attention/scheduler.cuh"
+#include "flashinfer/exception.h"
+#include "flashinfer/layout.cuh"
+#include "utils.h"
+
+namespace flashinfer {
+
+template <uint32_t HEAD_DIM, PosEncodingMode POS_ENCODING_MODE, typename AttentionVariant,
+          typename Params>
+cudaError_t BatchDecodeWithPagedKVCacheDispatched(Params params, typename Params::DTypeO* tmp_v,
+                                                  float* tmp_s, cudaStream_t stream);
+
+template <uint32_t HEAD_DIM_CKV, uint32_t HEAD_DIM_KPE, typename AttentionVariant, typename Params>
+cudaError_t BatchDecodeWithPagedKVCacheDispatchedMLA(Params params, typename Params::DTypeO* tmp_v,
+                                                     float* tmp_s, cudaStream_t stream);
+
+class BatchDecodeHandler {
+ public:
+  template <uint32_t GROUP_SIZE, uint32_t HEAD_DIM, PosEncodingMode POS_ENCODING_MODE,
+            typename DTypeQ, typename DTypeKV, typename DTypeO, typename IdType>
+  cudaError_t PlanDispatched(void* float_buffer, size_t float_workspace_size_in_bytes,
+                             void* int_buffer, size_t int_workspace_size_in_bytes, IdType* indptr_h,
+                             IdType* last_page_len_h, uint32_t batch_size, uint32_t num_qo_heads,
+                             uint32_t page_size) {
+    int_buffer_ = int_buffer;
+    float_buffer_ = float_buffer;
+    using Params = BatchDecodeParams<DTypeQ, DTypeKV, DTypeO, IdType>;
+    using AttentionVariant =
+        DefaultAttention</*use_custom_mask=*/false, /*use_sliding_window=*/false,
+                         /*use_logits_soft_cap=*/false, /*use_alibi=*/false>;
+
+    auto work_estimation_func =
+        BatchDecodeWithPagedKVCacheWorkEstimationDispatched<GROUP_SIZE, HEAD_DIM, POS_ENCODING_MODE,
+                                                            AttentionVariant, Params>;
+    return DecodePlan<HEAD_DIM, POS_ENCODING_MODE, AttentionVariant, Params>(
+        float_buffer, float_workspace_size_in_bytes, int_buffer, page_locked_buffer_,
+        int_workspace_size_in_bytes, plan_info_, indptr_h, batch_size, num_qo_heads, page_size,
+        cuda_graph_enabled_, stream_, work_estimation_func);
+  }
+
+  template <uint32_t HEAD_DIM_CKV, uint32_t HEAD_DIM_KPE, typename DTypeQ, typename DTypeKV,
+            typename DTypeO, typename IdType>
+  cudaError_t PlanDispatchedMLA(void* float_buffer, size_t float_workspace_size_in_bytes,
+                                void* int_buffer, size_t int_workspace_size_in_bytes,
+                                IdType* indptr_h, IdType* last_page_len_h, uint32_t batch_size,
+                                uint32_t num_qo_heads, uint32_t page_size) {
+    int_buffer_ = int_buffer;
+    float_buffer_ = float_buffer;
+    using Params = BatchDecodeParamsMLA<DTypeQ, DTypeKV, DTypeO, IdType>;
+    using AttentionVariant =
+        DefaultAttention</*use_custom_mask=*/false, /*use_sliding_window=*/false,
+                         /*use_logits_soft_cap=*/false, /*use_alibi=*/false>;
+
+    auto work_estimation_func =
+        BatchDecodeWithPagedKVCacheWorkEstimationDispatchedMLA<HEAD_DIM_CKV, HEAD_DIM_KPE,
+                                                               AttentionVariant, Params>;
+    return DecodePlan<HEAD_DIM_CKV, flashinfer::PosEncodingMode::kRoPELlama, AttentionVariant,
+                      Params>(float_buffer, float_workspace_size_in_bytes, int_buffer,
+                              page_locked_buffer_, int_workspace_size_in_bytes, plan_info_,
+                              indptr_h, batch_size, num_qo_heads, page_size, cuda_graph_enabled_,
+                              stream_, work_estimation_func);
+  }
+
+  void UpdatePageLockedBufferSize(size_t int_workspace_size_in_bytes) {
+    cudaFreeHost(page_locked_buffer_);
+    cudaMallocHost(&page_locked_buffer_, int_workspace_size_in_bytes);
+  }
+
+  cudaStream_t GetCUDAStream() const { return stream_; }
+
+  void SetCUDAStream(cudaStream_t stream) { stream_ = stream; }
+
+  /*!
+   * \brief Constructor of BatchDecodeHandler
+   * \param enable_cuda_graph A boolean indicates whether to enable CUDA graph
+   * \param batch_size If enable_cuda_graph is true, we must specify a fixed batch_size
+   */
+  BatchDecodeHandler(bool enable_cuda_graph = false, uint32_t batch_size = 0)
+      : cuda_graph_enabled_(enable_cuda_graph), stream_(nullptr) {
+    cudaMallocHost(&page_locked_buffer_, 8 * 1024 * 1024);
+  }
+  ~BatchDecodeHandler() { cudaFreeHost(page_locked_buffer_); }
+
+  bool IsCUDAGraphEnabled() const { return cuda_graph_enabled_; }
+
+  DecodePlanInfo GetPlanInfo() const { return plan_info_; }
+
+  template <typename IdType>
+  IdType* GetRequestIndices() {
+    return GetPtrFromBaseOffset<IdType>(int_buffer_, plan_info_.request_indices_offset);
+  }
+
+  template <typename IdType>
+  IdType* GetKVTileIndices() {
+    return GetPtrFromBaseOffset<IdType>(int_buffer_, plan_info_.kv_tile_indices_offset);
+  }
+
+  template <typename IdType>
+  IdType* GetOIndptr() {
+    return GetPtrFromBaseOffset<IdType>(int_buffer_, plan_info_.o_indptr_offset);
+  }
+
+  template <typename IdType>
+  IdType* GetKVChunkSizePtr() {
+    return GetPtrFromBaseOffset<IdType>(int_buffer_, plan_info_.kv_chunk_size_ptr_offset);
+  }
+
+  template <typename DTypeO>
+  DTypeO* GetTmpV() {
+    if (plan_info_.split_kv) {
+      return GetPtrFromBaseOffset<DTypeO>(float_buffer_, plan_info_.v_offset);
+    }
+    return nullptr;
+  }
+
+  float* GetTmpS() {
+    if (plan_info_.split_kv) {
+      return GetPtrFromBaseOffset<float>(float_buffer_, plan_info_.s_offset);
+    }
+    return nullptr;
+  }
+
+  bool* GetBlockValidMask() {
+    if (plan_info_.split_kv && plan_info_.enable_cuda_graph) {
+      return GetPtrFromBaseOffset<bool>(int_buffer_, plan_info_.block_valid_mask_offset);
+    }
+    return nullptr;
+  }
+
+ protected:
+  void* page_locked_buffer_;
+  void* int_buffer_;
+  void* float_buffer_;
+  DecodePlanInfo plan_info_;
+  bool cuda_graph_enabled_;
+  cudaStream_t stream_;
+};
+
+template <uint32_t CTA_TILE_Q, uint32_t HEAD_DIM, PosEncodingMode POS_ENCODING_MODE,
+          bool USE_FP16_QK_REDUCTION, MaskMode MASK_MODE, typename AttentionVariant,
+          typename Params>
+cudaError_t BatchPrefillWithRaggedKVCacheDispatched(Params params, typename Params::DTypeO* tmp_v,
+                                                    float* tmp_s, cudaStream_t stream);
+
+template <uint32_t CTA_TILE_Q, uint32_t HEAD_DIM, PosEncodingMode POS_ENCODING_MODE,
+          bool USE_FP16_QK_REDUCTION, MaskMode MASK_MODE, typename AttentionVariant,
+          typename Params>
+cudaError_t BatchPrefillWithPagedKVCacheDispatched(Params params, typename Params::DTypeO* tmp_v,
+                                                   float* tmp_s, cudaStream_t stream);
+
+class BatchPrefillHandler {
+ public:
+  void UpdatePageLockedBufferSize(size_t int_workspace_size_in_bytes) {
+    cudaFreeHost(page_locked_buffer_);
+    cudaMallocHost(&page_locked_buffer_, int_workspace_size_in_bytes);
+  }
+
+  template <typename DTypeO, typename IdType>
+  cudaError_t Plan(void* float_buffer, size_t float_workspace_size_in_bytes, void* int_buffer,
+                   size_t int_workspace_size_in_bytes, IdType* qo_indptr_h, IdType* kv_indptr_h,
+                   uint32_t total_num_rows, uint32_t batch_size, uint32_t num_qo_heads,
+                   uint32_t num_kv_heads, uint32_t head_dim, uint32_t page_size) {
+    int_buffer_ = int_buffer;
+    float_buffer_ = float_buffer;
+    return PrefillPlan<IdType>(float_buffer, float_workspace_size_in_bytes, int_buffer,
+                               page_locked_buffer_, int_workspace_size_in_bytes, plan_info_,
+                               qo_indptr_h, kv_indptr_h, total_num_rows, batch_size, num_qo_heads,
+                               num_kv_heads, head_dim, page_size, enable_cuda_graph_,
+                               sizeof(DTypeO), stream_);
+  }
+
+  cudaStream_t GetCUDAStream() const { return stream_; }
+
+  void SetCUDAStream(cudaStream_t stream) { stream_ = stream; }
+
+  bool IsCUDAGraphEnabled() const { return enable_cuda_graph_; }
+
+  BatchPrefillHandler(bool enable_cuda_graph = false)
+      : enable_cuda_graph_(enable_cuda_graph), stream_(nullptr) {
+    cudaMallocHost(&page_locked_buffer_, 8 * 1024 * 1024);
+  }
+  ~BatchPrefillHandler() { cudaFreeHost(page_locked_buffer_); }
+
+  PrefillPlanInfo GetPlanInfo() const { return plan_info_; }
+
+  template <typename IdType>
+  IdType* GetRequestIndices() {
+    return GetPtrFromBaseOffset<IdType>(int_buffer_, plan_info_.request_indices_offset);
+  }
+
+  template <typename IdType>
+  IdType* GetQOTileIndices() {
+    return GetPtrFromBaseOffset<IdType>(int_buffer_, plan_info_.qo_tile_indices_offset);
+  }
+
+  template <typename IdType>
+  IdType* GetKVTileIndices() {
+    return GetPtrFromBaseOffset<IdType>(int_buffer_, plan_info_.kv_tile_indices_offset);
+  }
+
+  template <typename IdType>
+  IdType* GetOIndptr() {
+    return GetPtrFromBaseOffset<IdType>(int_buffer_, plan_info_.o_indptr_offset);
+  }
+
+  template <typename IdType>
+  IdType* GetKVChunkSizePtr() {
+    return GetPtrFromBaseOffset<IdType>(int_buffer_, plan_info_.kv_chunk_size_ptr_offset);
+  }
+
+  template <typename IdType>
+  IdType* GetMergeIndptr() {
+    if (plan_info_.split_kv) {
+      return GetPtrFromBaseOffset<IdType>(int_buffer_, plan_info_.merge_indptr_offset);
+    }
+    return nullptr;
+  }
+
+  template <typename DTypeO>
+  DTypeO* GetTmpV() {
+    if (plan_info_.split_kv) {
+      return GetPtrFromBaseOffset<DTypeO>(float_buffer_, plan_info_.v_offset);
+    }
+    return nullptr;
+  }
+
+  float* GetTmpS() {
+    if (plan_info_.split_kv) {
+      return GetPtrFromBaseOffset<float>(float_buffer_, plan_info_.s_offset);
+    }
+    return nullptr;
+  }
+
+  uint32_t* GetTotalNumRows() {
+    if (plan_info_.enable_cuda_graph) {
+      return GetPtrFromBaseOffset<uint32_t>(int_buffer_, plan_info_.total_num_rows_offset);
+    }
+    return nullptr;
+  }
+
+  bool* GetBlockValidMask() {
+    if (plan_info_.split_kv && plan_info_.enable_cuda_graph) {
+      return GetPtrFromBaseOffset<bool>(int_buffer_, plan_info_.block_valid_mask_offset);
+    }
+    return nullptr;
+  }
+
+ protected:
+  void* page_locked_buffer_;
+  void* int_buffer_;
+  void* float_buffer_;
+  PrefillPlanInfo plan_info_;
+  bool enable_cuda_graph_;
+  cudaStream_t stream_;
+};
+
+template <uint32_t HEAD_DIM, PosEncodingMode POS_ENCODING_MODE, bool USE_FP16_QK_REDUCTION,
+          MaskMode MASK_MODE, typename AttentionVariant, typename Params>
+cudaError_t SinglePrefillWithKVCacheDispatched(Params params, typename Params::DTypeO* tmp,
+                                               cudaStream_t stream);
+
+template <typename DTypeIn, typename DTypeO>
+cudaError_t SinglePrefillWithKVCacheCustomMask(
+    DTypeIn* q, DTypeIn* k, DTypeIn* v, uint8_t* custom_mask, DTypeO* o, DTypeO* tmp, float* lse,
+    uint32_t num_qo_heads, uint32_t num_kv_heads, uint32_t qo_len, uint32_t kv_len,
+    uint32_t head_dim, QKVLayout kv_layout = QKVLayout::kNHD,
+    PosEncodingMode pos_encoding_mode = PosEncodingMode::kNone, bool use_fp16_qk_reduction = false,
+    std::optional<float> maybe_sm_scale = std::nullopt, float rope_scale = 1.f,
+    float rope_theta = 1e4, cudaStream_t stream = nullptr) {
+  const float sm_scale = maybe_sm_scale.value_or(1.f / std::sqrt(float(head_dim)));
+  auto [qo_stride_n, qo_stride_h, kv_stride_n, kv_stride_h] =
+      get_qkv_strides(kv_layout, kv_len, num_qo_heads, num_kv_heads, head_dim);
+  DISPATCH_use_fp16_qk_reduction(
+      use_fp16_qk_reduction, USE_FP16_QK_REDUCTION,
+      {DISPATCH_head_dim(
+          head_dim, HEAD_DIM, {DISPATCH_pos_encoding_mode(pos_encoding_mode, POS_ENCODING_MODE, {
+            using Params = SinglePrefillParams<DTypeIn, DTypeIn, DTypeO>;
+            using AttentionVariant = DefaultAttention<
+                /*use_custom_mask=*/true, /*use_sliding_window=*/false,
+                /*use_logits_soft_cap=*/false, /*use_alibi=*/false>;
+            Params params(q, k, v, custom_mask, o, lse,
+                          /*alibi_slopes=*/nullptr, num_qo_heads, num_kv_heads, qo_len, kv_len,
+                          qo_stride_n, qo_stride_h, kv_stride_n, kv_stride_h, head_dim,
+                          /*window_left=*/-1,
+                          /*logits_soft_cap=*/0.f, sm_scale, rope_scale, rope_theta);
+            return SinglePrefillWithKVCacheDispatched<HEAD_DIM, POS_ENCODING_MODE,
+                                                      USE_FP16_QK_REDUCTION, MaskMode::kCustom,
+                                                      AttentionVariant>(params, tmp, stream);
+          })})});
+  return cudaSuccess;
+}
+
+/*!
+ * \brief FlashAttention prefill CUDA function for a single request.
+ * \tparam DTypeIn The data type of input
+ * \tparam DTypeO The data type of output
+ * \param q The query tensor.
+ * \param k The key tensor.
+ * \param v The value tensor.
+ * \param o The output tensor.
+ * \param tmp The temporary storage (only used for cooperative kernel).
+ * \param lse The logsumexp values.
+ * \param num_qo_heads The number of query and output heads.
+ * \param num_kv_heads The number of key and value heads.
+ * \param qo_len The length of query and output.
+ * \param kv_len The length of key and value.
+ * \param head_dim The dimension of each head.
+ * \param causal Whether to use causal attention.
+ * \param kv_layout The layout of input and output.
+ * \param pos_encoding_mode The positional encoding mode.
+ * \param use_fp16_qk_reduction Whether to allow accumulating q*k^T with fp16.
+ * \param rope_scale The scaling factor used in RoPE interpolation.
+ * \param rope_theta The theta used in RoPE.
+ * \param stream The cuda stream to execute the kernel on.
+ * \return status Indicates whether CUDA calls are successful
+ */
+template <typename DTypeQ, typename DTypeKV, typename DTypeO>
+cudaError_t SinglePrefillWithKVCache(DTypeQ* q, DTypeKV* k, DTypeKV* v, DTypeO* o, DTypeO* tmp,
+                                     float* lse, uint32_t num_qo_heads, uint32_t num_kv_heads,
+                                     uint32_t qo_len, uint32_t kv_len, uint32_t head_dim,
+                                     bool causal = true, QKVLayout kv_layout = QKVLayout::kNHD,
+                                     PosEncodingMode pos_encoding_mode = PosEncodingMode::kNone,
+                                     bool use_fp16_qk_reduction = false,
+                                     std::optional<float> maybe_sm_scale = std::nullopt,
+                                     float rope_scale = 1.f, float rope_theta = 1e4,
+                                     cudaStream_t stream = nullptr) {
+  const float sm_scale = maybe_sm_scale.value_or(1.f / std::sqrt(float(head_dim)));
+  const MaskMode mask_mode = causal ? MaskMode::kCausal : MaskMode::kNone;
+  auto [qo_stride_n, qo_stride_h, kv_stride_n, kv_stride_h] =
+      get_qkv_strides(kv_layout, kv_len, num_qo_heads, num_kv_heads, head_dim);
+  DISPATCH_use_fp16_qk_reduction(
+      use_fp16_qk_reduction, USE_FP16_QK_REDUCTION,
+      {DISPATCH_mask_mode(
+          mask_mode, MASK_MODE,
+          {DISPATCH_head_dim(
+              head_dim, HEAD_DIM,
+              {DISPATCH_pos_encoding_mode(pos_encoding_mode, POS_ENCODING_MODE, {
+                using Params = SinglePrefillParams<DTypeQ, DTypeKV, DTypeO>;
+                using AttentionVariant = DefaultAttention<
+                    /*use_custom_mask=*/(MASK_MODE == MaskMode::kCustom),
+                    /*use_sliding_window=*/false,
+                    /*use_logits_soft_cap=*/false, /*use_alibi=*/false>;
+                Params params(q, k, v, /*custom_mask=*/nullptr, o, lse,
+                              /*alibi_slopes=*/nullptr, num_qo_heads, num_kv_heads, qo_len, kv_len,
+                              qo_stride_n, qo_stride_h, kv_stride_n, kv_stride_h, head_dim,
+                              /*window_left=*/-1,
+                              /*logits_soft_cap=*/0.f, sm_scale, rope_scale, rope_theta);
+                return SinglePrefillWithKVCacheDispatched<HEAD_DIM, POS_ENCODING_MODE,
+                                                          USE_FP16_QK_REDUCTION, MASK_MODE,
+                                                          AttentionVariant, Params>(params, tmp,
+                                                                                    stream);
+              })})})});
+  return cudaSuccess;
+}
+
+template <typename DTypeQ, typename DTypeKV, typename DTypeO, typename IdType>
+cudaError_t BatchPrefillWithRaggedKVCacheWrapper(
+    BatchPrefillHandler* handler, DTypeQ* q, IdType* qo_indptr, DTypeKV* k, DTypeKV* v,
+    IdType* kv_indptr, IdType* q_rope_offset, IdType* k_rope_offset, DTypeO* o, float* lse,
+    const uint32_t batch_size, const uint32_t num_qo_heads, const uint32_t num_kv_heads,
+    const uint32_t head_dim, bool causal = true, QKVLayout kv_layout = QKVLayout::kNHD,
+    PosEncodingMode pos_encoding_mode = PosEncodingMode::kNone, bool use_fp16_qk_reduction = false,
+    std::optional<float> maybe_sm_scale = std::nullopt, const float rope_scale = 1.f,
+    const float rope_theta = 1e4, cudaStream_t stream = nullptr) {
+  const float sm_scale = maybe_sm_scale.value_or(1.f / std::sqrt(float(head_dim)));
+  const MaskMode mask_mode = causal ? MaskMode::kCausal : MaskMode::kNone;
+  auto [qo_stride_n, qo_stride_h, kv_stride_n, kv_stride_h] =
+      get_qkv_strides(kv_layout, 0, num_qo_heads, num_kv_heads, head_dim);
+  auto plan_info = handler->GetPlanInfo();
+  DISPATCH_head_dim(
+      head_dim, HEAD_DIM,
+      {DISPATCH_mask_mode(
+          mask_mode, MASK_MODE,
+          {DISPATCH_pos_encoding_mode(
+              pos_encoding_mode, POS_ENCODING_MODE,
+              {DISPATCH_use_fp16_qk_reduction(use_fp16_qk_reduction, USE_FP16_QK_REDUCTION, {
+                using Params = BatchPrefillRaggedParams<DTypeQ, DTypeKV, DTypeO, IdType>;
+                using AttentionVariant = DefaultAttention<
+                    /*use_custom_mask=*/(MASK_MODE == MaskMode::kCustom),
+                    /*use_sliding_window=*/false,
+                    /*use_logits_soft_cap=*/false, /*use_alibi=*/false>;
+                Params params(q, k, v, /*custom_mask=*/nullptr, qo_indptr, kv_indptr,
+                              /*mask_indptr=*/nullptr, q_rope_offset, k_rope_offset, o, lse,
+                              /*alibi_slopes=*/nullptr, num_qo_heads, num_kv_heads, qo_stride_n,
+                              qo_stride_h, kv_stride_n, kv_stride_h, /*window_left=*/-1,
+                              /*logits_soft_cap=*/0.f, sm_scale, rope_scale, rope_theta);
+                params.request_indices = handler->GetRequestIndices<IdType>();
+                params.qo_tile_indices = handler->GetQOTileIndices<IdType>();
+                params.kv_tile_indices = handler->GetKVTileIndices<IdType>();
+                params.o_indptr = handler->GetOIndptr<IdType>();
+                params.kv_chunk_size_ptr = handler->GetKVChunkSizePtr<IdType>();
+                params.merge_indptr = handler->GetMergeIndptr<IdType>();
+                params.block_valid_mask = handler->GetBlockValidMask();
+                params.max_total_num_rows = plan_info.total_num_rows;
+                params.total_num_rows = handler->GetTotalNumRows();
+                params.padded_batch_size = plan_info.padded_batch_size;
+
+                DISPATCH_CTA_TILE_Q(plan_info.cta_tile_q, CTA_TILE_Q, {
+                  BatchPrefillWithRaggedKVCacheDispatched<CTA_TILE_Q, HEAD_DIM, POS_ENCODING_MODE,
+                                                          USE_FP16_QK_REDUCTION, MASK_MODE,
+                                                          AttentionVariant>(
+                      params, handler->GetTmpV<DTypeO>(), handler->GetTmpS(), stream);
+                });
+              })})})});
+  return cudaSuccess;
+}
+
+template <typename DTypeQ, typename DTypeKV, typename DTypeO, typename IdType>
+cudaError_t BatchPrefillWithPagedKVCacheWrapper(
+    BatchPrefillHandler* handler, DTypeQ* q, IdType* qo_indptr, IdType* q_rope_offset,
+    paged_kv_t<DTypeKV, IdType> paged_kv, DTypeO* o, float* lse, uint32_t num_qo_heads,
+    bool causal = true, PosEncodingMode pos_encoding_mode = PosEncodingMode::kNone,
+    bool use_fp16_qk_reduction = false, std::optional<float> maybe_sm_scale = std::nullopt,
+    float rope_scale = 1.f, float rope_theta = 1e4, cudaStream_t stream = nullptr) {
+  const float sm_scale = maybe_sm_scale.value_or(1.f / std::sqrt(float(paged_kv.head_dim)));
+  const uint32_t num_kv_heads = paged_kv.num_heads;
+  const uint32_t head_dim = paged_kv.head_dim;
+  const MaskMode mask_mode = causal ? MaskMode::kCausal : MaskMode::kNone;
+  auto plan_info = handler->GetPlanInfo();
+  DISPATCH_head_dim(
+      head_dim, HEAD_DIM,
+      {DISPATCH_mask_mode(
+          mask_mode, MASK_MODE,
+          {DISPATCH_pos_encoding_mode(
+              pos_encoding_mode, POS_ENCODING_MODE,
+              {DISPATCH_use_fp16_qk_reduction(use_fp16_qk_reduction, USE_FP16_QK_REDUCTION, {
+                using Params = BatchPrefillPagedParams<DTypeQ, DTypeKV, DTypeO, IdType>;
+                using AttentionVariant = DefaultAttention<
+                    /*use_custom_mask=*/(MASK_MODE == MaskMode::kCustom),
+                    /*use_sliding_window=*/false,
+                    /*use_logits_soft_cap=*/false,
+                    /*use_alibi=*/false>;
+                Params params(q, paged_kv, /*custom_mask=*/nullptr, qo_indptr,
+                              /*mask_indptr=*/nullptr, q_rope_offset, o, lse,
+                              /*alibi_slopes=*/nullptr, num_qo_heads,
+                              /*q_stride_n*/ num_qo_heads * HEAD_DIM, /*q_stride_h*/ HEAD_DIM,
+                              /*window_left=*/-1, /*logits_soft_cap=*/0.f, sm_scale, rope_scale,
+                              rope_theta);
+                params.request_indices = handler->GetRequestIndices<IdType>();
+                params.qo_tile_indices = handler->GetQOTileIndices<IdType>();
+                params.kv_tile_indices = handler->GetKVTileIndices<IdType>();
+                params.o_indptr = handler->GetOIndptr<IdType>();
+                params.kv_chunk_size_ptr = handler->GetKVChunkSizePtr<IdType>();
+                params.merge_indptr = handler->GetMergeIndptr<IdType>();
+                params.block_valid_mask = handler->GetBlockValidMask();
+                params.max_total_num_rows = plan_info.total_num_rows;
+                params.total_num_rows = handler->GetTotalNumRows();
+                params.padded_batch_size = plan_info.padded_batch_size;
+                DISPATCH_CTA_TILE_Q(plan_info.cta_tile_q, CTA_TILE_Q, {
+                  return BatchPrefillWithPagedKVCacheDispatched<
+                      CTA_TILE_Q, HEAD_DIM, POS_ENCODING_MODE, USE_FP16_QK_REDUCTION, MASK_MODE,
+                      AttentionVariant>(params, handler->GetTmpV<DTypeO>(), handler->GetTmpS(),
+                                        stream);
+                })
+              })})})});
+  return cudaSuccess;
+}
+
+template <uint32_t HEAD_DIM, PosEncodingMode POS_ENCODING_MODE, typename AttentionVariant,
+          typename Params>
+cudaError_t SingleDecodeWithKVCacheDispatched(Params params, typename Params::DTypeO* tmp,
+                                              cudaStream_t stream);
+
+template <typename DTypeQ, typename DTypeKV, typename DTypeO>
+cudaError_t SingleDecodeWithKVCache(DTypeQ* q, DTypeKV* k, DTypeKV* v, DTypeO* o, DTypeO* tmp,
+                                    uint32_t num_qo_heads, uint32_t num_kv_heads, uint32_t seq_len,
+                                    uint32_t head_dim, QKVLayout kv_layout = QKVLayout::kNHD,
+                                    PosEncodingMode pos_encoding_mode = PosEncodingMode::kNone,
+                                    std::optional<float> maybe_sm_scale = std::nullopt,
+                                    float rope_scale = 1.f, float rope_theta = 1e4,
+                                    cudaStream_t stream = nullptr) {
+  float sm_scale = maybe_sm_scale.value_or(1.f / std::sqrt(float(head_dim)));
+  if (num_qo_heads % num_kv_heads != 0) {
+    std::ostringstream err_msg;
+    err_msg << "num_qo_heads " << num_qo_heads << " is not a multiple of num_kv_heads "
+            << num_kv_heads;
+    FLASHINFER_ERROR(err_msg.str());
+  }
+
+  DISPATCH_head_dim(
+      head_dim, HEAD_DIM, {DISPATCH_pos_encoding_mode(pos_encoding_mode, POS_ENCODING_MODE, {
+        using Params = SingleDecodeParams<DTypeQ, DTypeKV, DTypeO>;
+        using AttentionVariant = DefaultAttention<
+            /*use_custom_mask=*/false, /*use_sliding_window=*/false,
+            /*use_logits_soft_cap=*/false, /*use_alibi=*/false>;
+        Params params(q, k, v, o, /*alibi_slopes=*/nullptr, seq_len, num_qo_heads, num_kv_heads,
+                      kv_layout, head_dim, /*window_left=*/-1, /*logits_soft_cap=*/0.f, sm_scale,
+                      rope_scale, rope_theta);
+
+        SingleDecodeWithKVCacheDispatched<HEAD_DIM, POS_ENCODING_MODE, AttentionVariant>(
+            params, tmp, stream);
+      })});
+  return cudaSuccess;
+}
+
+/*!
+ * \brief Wrapper of BatchDecodeWithPagedKVCache function, and caches the temporary buffer
+ *   for cooperative kernels.
+ * \tparam DTypeQ The data type of query tensor.
+ * \tparam DTypeKV The data type of key-value tensor.
+ * \tparam DTypeO The data type of output tensor.
+ * \tparam IdType The data type of index tensor.
+ * \param handler The handler for the batch decode forward request.
+ * \param q The input tensor.
+ * \param paged_kv The paged key-value tensor.
+ * \param o The output tensor.
+ * \param lse The logsumexp values.
+ * \param num_qo_heads The number of heads.
+ * \param pos_encoding_mode The positional encoding mode.
+ * \param rope_scale The scale of rope.
+ * \param rope_theta The theta of rope.
+ * \param stream The CUDA stream.
+ */
+template <typename DTypeQ, typename DTypeKV, typename DTypeO, typename IdType>
+cudaError_t BatchDecodeWithPagedKVCacheWrapper(
+    BatchDecodeHandler* handler, DTypeQ* q, IdType* q_rope_offset,
+    paged_kv_t<DTypeKV, IdType> paged_kv, DTypeO* o, float* lse, uint32_t num_qo_heads,
+    PosEncodingMode pos_encoding_mode = PosEncodingMode::kNone,
+    std::optional<float> maybe_sm_scale = std::nullopt, float rope_scale = 1.f,
+    float rope_theta = 1e4, cudaStream_t stream = nullptr) {
+  float sm_scale = maybe_sm_scale.value_or(1.f / std::sqrt(float(paged_kv.head_dim)));
+  const uint32_t num_kv_heads = paged_kv.num_heads;
+  if (num_qo_heads % num_kv_heads != 0) {
+    std::ostringstream err_msg;
+    err_msg << "num_qo_heads " << num_qo_heads << " is not a multiple of num_kv_heads "
+            << num_kv_heads;
+    FLASHINFER_ERROR(err_msg.str());
+  }
+
+  DISPATCH_head_dim(
+      paged_kv.head_dim, HEAD_DIM,
+      {DISPATCH_pos_encoding_mode(pos_encoding_mode, POS_ENCODING_MODE, {
+        using Params = BatchDecodeParams<DTypeQ, DTypeKV, DTypeO, IdType>;
+        using AttentionVariant = DefaultAttention<
+            /*use_custom_mask=*/false, /*use_sliding_window=*/false,
+            /*use_logits_soft_cap=*/false, /*use_alibi=*/false>;
+        Params params(q, q_rope_offset, paged_kv, o, lse, /*alibi_slopes=*/nullptr, num_qo_heads,
+                      /*q_stride_n*/ num_qo_heads * HEAD_DIM, /*q_stride_h*/ HEAD_DIM,
+                      /*window_left=*/-1, /*logits_soft_cap=*/0.f, sm_scale, rope_scale,
+                      rope_theta);
+        params.request_indices = handler->GetRequestIndices<IdType>();
+        params.kv_tile_indices = handler->GetKVTileIndices<IdType>();
+        params.o_indptr = handler->GetOIndptr<IdType>();
+        params.kv_chunk_size_ptr = handler->GetKVChunkSizePtr<IdType>();
+        params.block_valid_mask = handler->GetBlockValidMask();
+        params.padded_batch_size = handler->GetPlanInfo().padded_batch_size;
+
+        return BatchDecodeWithPagedKVCacheDispatched<HEAD_DIM, POS_ENCODING_MODE, AttentionVariant>(
+            params, handler->GetTmpV<DTypeO>(), handler->GetTmpS(), stream);
+      })});
+  return cudaSuccess;
+}
+
+template <typename DTypeQ, typename DTypeKV, typename DTypeO, typename IdType>
+cudaError_t BatchDecodeHandlerPlan(BatchDecodeHandler* handler, void* float_buffer,
+                                   size_t float_workspace_size_in_bytes, void* int_buffer,
+                                   size_t int_workspace_size_in_bytes, IdType* indptr_h,
+                                   IdType* last_page_len_h, uint32_t batch_size,
+                                   uint32_t num_qo_heads, uint32_t num_kv_heads, uint32_t head_dim,
+                                   uint32_t page_size, PosEncodingMode pos_encoding_mode) {
+  if (num_qo_heads % num_kv_heads != 0) {
+    std::ostringstream err_msg;
+    err_msg << "num_qo_heads " << num_qo_heads << " should be divisible by num_kv_heads "
+            << num_kv_heads;
+    FLASHINFER_ERROR(err_msg.str());
+  }
+  DISPATCH_head_dim(head_dim, HEAD_DIM, {
+    DISPATCH_pos_encoding_mode(pos_encoding_mode, POS_ENCODING_MODE, {
+      DISPATCH_GQA_GROUP_SIZE(num_qo_heads / num_kv_heads, GROUP_SIZE, {
+        return handler->PlanDispatched<GROUP_SIZE, HEAD_DIM, POS_ENCODING_MODE, DTypeQ, DTypeKV,
+                                       DTypeO, IdType>(
+            float_buffer, float_workspace_size_in_bytes, int_buffer, int_workspace_size_in_bytes,
+            indptr_h, last_page_len_h, batch_size, num_qo_heads, page_size);
+      });
+    });
+  });
+}
+
+template <typename DTypeQ, typename DTypeKV, typename DTypeO, typename IdType>
+cudaError_t BatchDecodeWithPagedKVCacheWrapperMLA(
+    BatchDecodeHandler* handler, DTypeQ* q_nope, DTypeQ* q_pe, IdType* q_rope_offset,
+    paged_kv_mla_t<DTypeKV, IdType> paged_kv, DTypeO* o, float* lse, uint32_t num_qo_heads,
+    float sm_scale, float rope_scale = 1.f, float rope_theta = 1e4, cudaStream_t stream = nullptr) {
+  DISPATCH_head_dim(paged_kv.head_dim_ckv, HEAD_DIM_CKV, {
+    // fixme: head_dim_ckv(kv_lora_rank) is 8 times the size of head_dim_kpe(qk_rope_head_dim) for
+    // all MLA model (DeepSeek-V2-Lite, DeepSeek-V2.5, MiniCPM3) at the time Oct.2024
+    constexpr auto HEAD_DIM_KPE = HEAD_DIM_CKV / 8;
+    using Params = BatchDecodeParamsMLA<DTypeQ, DTypeKV, DTypeO, IdType>;
+    using AttentionVariant = DefaultAttention<
+        /*use_custom_mask=*/false, /*use_sliding_window=*/false,
+        /*use_logits_soft_cap=*/false, /*use_alibi=*/false>;
+    Params params(q_nope, q_pe, q_rope_offset, paged_kv, o, lse, num_qo_heads,
+                  /*window_left=*/-1, /*logits_soft_cap=*/0.f, sm_scale, rope_scale, rope_theta);
+    params.request_indices = handler->GetRequestIndices<IdType>();
+    params.kv_tile_indices = handler->GetKVTileIndices<IdType>();
+    params.o_indptr = handler->GetOIndptr<IdType>();
+    params.kv_chunk_size_ptr = handler->GetKVChunkSizePtr<IdType>();
+    params.block_valid_mask = handler->GetBlockValidMask();
+    params.padded_batch_size = handler->GetPlanInfo().padded_batch_size;
+
+    return BatchDecodeWithPagedKVCacheDispatchedMLA<HEAD_DIM_CKV, HEAD_DIM_KPE, AttentionVariant>(
+        params, handler->GetTmpV<DTypeO>(), handler->GetTmpS(), stream);
+  });
+  return cudaSuccess;
+}
+
+template <typename DTypeQ, typename DTypeKV, typename DTypeO, typename IdType>
+cudaError_t BatchDecodeHandlerPlanMLA(BatchDecodeHandler* handler, void* float_buffer,
+                                      size_t float_workspace_size_in_bytes, void* int_buffer,
+                                      size_t int_workspace_size_in_bytes, IdType* indptr_h,
+                                      IdType* last_page_len_h, uint32_t batch_size,
+                                      uint32_t num_qo_heads, uint32_t head_dim_ckv,
+                                      uint32_t page_size) {
+  DISPATCH_head_dim(head_dim_ckv, HEAD_DIM_CKV, {
+    // fixme: head_dim_ckv(kv_lora_rank) is 8 times the size of head_dim_kpe(qk_rope_head_dim) for
+    // all MLA model (DeepSeek-V2-Lite, DeepSeek-V2.5, MiniCPM3) at the time Oct.2024
+    constexpr auto HEAD_DIM_KPE = HEAD_DIM_CKV / 8;
+    return handler->PlanDispatchedMLA<HEAD_DIM_CKV, HEAD_DIM_KPE, DTypeQ, DTypeKV, DTypeO, IdType>(
+        float_buffer, float_workspace_size_in_bytes, int_buffer, int_workspace_size_in_bytes,
+        indptr_h, last_page_len_h, batch_size, num_qo_heads, page_size);
+  });
+}
+
+}  // namespace flashinfer

sglang_repo/sgl-kernel/3rdparty/flashinfer/src/test_batch_decode.cu

@@ -0,0 +1,182 @@
+/*
+ * Copyright (c) 2023 by FlashInfer team.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <gtest/gtest.h>
+
+#include <type_traits>
+
+#include "cpu_reference.h"
+#include "flashinfer_ops.cuh"
+#include "utils.h"
+
+using namespace flashinfer;
+
+constexpr QKVLayout kv_layout = QKVLayout::kNHD;
+
+template <typename DTypeQO, typename DTypeKV>
+void _TestBatchDecodingKernelCorrectness(size_t page_size, size_t batch_size, size_t num_qo_heads,
+                                         size_t num_kv_heads, size_t head_dim,
+                                         flashinfer::PosEncodingMode pos_encoding_mode) {
+  std::vector<int32_t> seq_lens(batch_size);
+  utils::vec_randint_(seq_lens, 1, 1024);
+  std::vector<int32_t> append_indptr{0};
+  for (size_t i = 0; i < batch_size; ++i) {
+    append_indptr.push_back(append_indptr.back() + seq_lens[i]);
+  }
+  std::vector<DTypeQO> q;
+  std::vector<DTypeQO> o_ref;
+  std::vector<DTypeKV> k_data;
+  std::vector<DTypeKV> v_data;
+  std::vector<int32_t> kv_indptr{0};
+  std::vector<int32_t> kv_indices;
+  std::vector<int32_t> kv_last_page_len;
+  size_t page_counter = 0;
+
+  std::vector<std::vector<DTypeKV>> keys, values;
+  for (size_t i = 0; i < batch_size; ++i) {
+    size_t seq_len = seq_lens[i];
+    size_t num_pages = (seq_len + page_size - 1) / page_size;
+    size_t last_page_len = (seq_len - 1) % page_size + 1;
+    std::vector<DTypeQO> qi(num_qo_heads * head_dim);
+    std::vector<DTypeKV> ki(seq_len * num_kv_heads * head_dim),
+        vi(seq_len * num_kv_heads * head_dim);
+    utils::vec_normal_(qi);
+    utils::vec_normal_(ki);
+    utils::vec_normal_(vi);
+
+    // compute reference output
+    std::vector<DTypeQO> o_ref_i = cpu_reference::single_mha<DTypeQO, DTypeKV, DTypeQO>(
+        qi, ki, vi, 1, seq_len, num_qo_heads, num_kv_heads, head_dim, false, QKVLayout::kNHD,
+        pos_encoding_mode);
+    keys.push_back(ki);
+    values.push_back(vi);
+    // append new q and o_ref
+    q.insert(q.end(), qi.begin(), qi.end());
+    o_ref.insert(o_ref.end(), o_ref_i.begin(), o_ref_i.end());
+    // append new kv_indptr, kv_indices and kv_last_page_len
+    kv_last_page_len.push_back(last_page_len);
+    kv_indptr.push_back(kv_indptr.back() + num_pages);
+    for (size_t j = 0; j < num_pages; ++j) {
+      kv_indices.push_back(page_counter++);
+    }
+  }
+  k_data.resize(page_counter * num_kv_heads * page_size * head_dim);
+  v_data.resize(page_counter * num_kv_heads * page_size * head_dim);
+  utils::vec_zero_(k_data);
+  utils::vec_zero_(v_data);
+  assert(q.size() == batch_size * num_qo_heads * head_dim);
+  assert(o_ref.size() == batch_size * num_qo_heads * head_dim);
+
+  flashinfer::paged_kv_t<DTypeKV, int32_t> paged_kv_cpu(
+      num_kv_heads, page_size, head_dim, batch_size, kv_layout, k_data.data(), v_data.data(),
+      kv_indices.data(), kv_indptr.data(), kv_last_page_len.data());
+  cpu_reference::append_paged_kv_cache<DTypeKV, int32_t>(paged_kv_cpu, keys, values, append_indptr);
+
+  // copy data to device
+  thrust::device_vector<DTypeKV> k_data_device(k_data);
+  thrust::device_vector<DTypeKV> v_data_device(v_data);
+  thrust::device_vector<int32_t> kv_indptr_device(kv_indptr);
+  thrust::device_vector<int32_t> kv_indices_device(kv_indices);
+  thrust::device_vector<int32_t> kv_last_page_len_device(kv_last_page_len);
+  thrust::device_vector<DTypeQO> q_device(q);
+  thrust::device_vector<DTypeQO> o_device(o_ref.size());
+
+  // create paged_kv object
+  flashinfer::paged_kv_t<DTypeKV, int32_t> paged_kv(
+      num_kv_heads, page_size, head_dim, batch_size, kv_layout,
+      thrust::raw_pointer_cast(k_data_device.data()),
+      thrust::raw_pointer_cast(v_data_device.data()),
+      thrust::raw_pointer_cast(kv_indices_device.data()),
+      thrust::raw_pointer_cast(kv_indptr_device.data()),
+      thrust::raw_pointer_cast(kv_last_page_len_device.data()));
+  flashinfer::BatchDecodeHandler handler;
+  size_t float_workspace_size_in_bytes = 32 * 1024 * 1024;
+  thrust::device_vector<char> float_buffer(float_workspace_size_in_bytes);
+  size_t int_workspace_size_in_bytes = 8 * 1024 * 1024;
+  thrust::device_vector<char> int_buffer(int_workspace_size_in_bytes);
+  BatchDecodeHandlerPlan<DTypeQO, DTypeKV, DTypeQO, int32_t>(
+      &handler, (void*)thrust::raw_pointer_cast(float_buffer.data()), float_workspace_size_in_bytes,
+      (void*)thrust::raw_pointer_cast(int_buffer.data()), int_workspace_size_in_bytes,
+      kv_indptr.data(), kv_last_page_len.data(), batch_size, num_qo_heads, num_kv_heads, head_dim,
+      page_size, pos_encoding_mode);
+
+  cudaError_t status =
+      flashinfer::BatchDecodeWithPagedKVCacheWrapper<DTypeQO, DTypeKV, DTypeQO, int32_t>(
+          &handler, thrust::raw_pointer_cast(q_device.data()), /*q_rope_offset=*/nullptr, paged_kv,
+          thrust::raw_pointer_cast(o_device.data()), /*lse=*/nullptr, num_qo_heads,
+          pos_encoding_mode);
+  EXPECT_EQ(status, cudaSuccess) << "CUDA error: " + std::string(cudaGetErrorString(status));
+  // compare result
+  thrust::host_vector<DTypeQO> o_host = o_device;
+  size_t num_result_errors_atol_1e_3_rtol_1e_3 = 0;
+  bool nan_detected = false;
+  for (size_t i = 0; i < batch_size * num_qo_heads * head_dim; ++i) {
+    if (std::isnan(float(o_host[i]))) {
+      nan_detected = true;
+    }
+    num_result_errors_atol_1e_3_rtol_1e_3 +=
+        (!utils::isclose(float(o_host[i]), float(o_ref[i]), 1e-3, 1e-3));
+  }
+  float result_accuracy = 1. - float(num_result_errors_atol_1e_3_rtol_1e_3) /
+                                   float(batch_size * num_qo_heads * head_dim);
+  std::cout << "page_size=" << page_size << ", num_qo_heads=" << num_qo_heads
+            << ", num_kv_heads=" << num_kv_heads << ", batch_size=" << batch_size
+            << ", head_dim=" << head_dim
+            << ", pos_encoding_mode=" << flashinfer::PosEncodingModeToString(pos_encoding_mode)
+            << ", result accuracy (atol=1e-3, rtol=1e-3): " << result_accuracy << std::endl;
+  EXPECT_GT(result_accuracy, 0.90) << "Result correctness test failed.";
+  EXPECT_EQ(nan_detected, false) << "NaN detected.";
+}
+
+template <typename DTypeQO, typename DTypeKV>
+void TestBatchDecodeKernelCorrectness() {
+  for (size_t page_size : {1, 3, 7, 16}) {
+    for (size_t batch_size : {1, 2, 4, 8}) {
+      for (size_t num_qo_heads : {32}) {
+        for (size_t num_kv_heads : {32, 8, 4}) {
+          for (size_t head_dim : {64, 128, 256}) {
+            for (size_t pos_encoding_mode : {0U, 1U}) {
+              _TestBatchDecodingKernelCorrectness<DTypeQO, DTypeKV>(
+                  page_size, batch_size, num_qo_heads, num_kv_heads, head_dim,
+                  flashinfer::PosEncodingMode(pos_encoding_mode));
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+TEST(FlashInferCorrectnessTest, BatchDecodeKernelCorrectnessTestFP16) {
+  TestBatchDecodeKernelCorrectness<half, half>();
+}
+
+#ifdef FLASHINFER_ENABLE_BF16
+TEST(FlashInferCorrectnessTest, TestBatchDecodeKernelCorrectnessBF16) {
+  TestBatchDecodeKernelCorrectness<__nv_bfloat16, __nv_bfloat16>();
+}
+#endif
+
+#ifdef FLASHINFER_ENABLE_FP8_E4M3
+TEST(FlashInferCorrectnessTest, TestBatchDecodeKernelCorrectnessE4M3) {
+  TestBatchDecodeKernelCorrectness<half, __nv_fp8_e4m3>();
+}
+#endif
+
+#ifdef FLASHINFER_ENABLE_FP8_E5M2
+TEST(FlashInferCorrectnessTest, TestBatchDecodeKernelCorrectnessE5M2) {
+  TestBatchDecodeKernelCorrectness<half, __nv_fp8_e5m2>();
+}
+#endif

sglang_repo/sgl-kernel/3rdparty/flashinfer/src/test_batch_prefill.cu

@@ -0,0 +1,811 @@
+/*
+ * Copyright (c) 2023 by FlashInfer team.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <gtest/gtest.h>
+
+#include <cstdint>
+
+#include "cpu_reference.h"
+#include "flashinfer/pos_enc.cuh"
+#include "flashinfer_ops.cuh"
+#include "utils.h"
+
+using namespace flashinfer;
+constexpr QKVLayout kv_layout = QKVLayout::kNHD;
+
+template <typename DTypeQO, typename DTypeKV>
+void _TestBatchPagedPrefillKernelOneHotCorrectness(size_t num_kv_heads, size_t num_qo_heads,
+                                                   size_t page_size, size_t head_dim, bool causal,
+                                                   PosEncodingMode pos_encoding_mode,
+                                                   bool use_fp16_qk_reduction) {
+  uint32_t batch_size = 9;
+  std::vector<int32_t> q_lens(batch_size), kv_lens(batch_size);
+  utils::vec_randint_(q_lens, 1, 15);
+  utils::vec_randint_(kv_lens, 15, 257);
+  std::vector<int32_t> append_indptr{0};
+  for (size_t request_idx = 0; request_idx < batch_size; ++request_idx) {
+    append_indptr.push_back(append_indptr.back() + kv_lens[request_idx]);
+  }
+  std::vector<DTypeKV> k_data;
+  std::vector<DTypeKV> v_data;
+  std::vector<int32_t> kv_indptr{0};
+  std::vector<int32_t> kv_indices;
+  std::vector<int32_t> kv_last_page_len;
+  size_t page_counter = 0;
+
+  std::vector<std::vector<DTypeKV>> key, value;
+  for (uint32_t request_idx = 0; request_idx < batch_size; ++request_idx) {
+    size_t kv_len = kv_lens[request_idx];
+    size_t num_pages = (kv_len + page_size - 1) / page_size;
+    size_t last_page_len = (kv_len - 1) % page_size + 1;
+    std::vector<DTypeKV> k(kv_len * num_kv_heads * head_dim), v(kv_len * num_kv_heads * head_dim);
+    utils::vec_normal_(k);
+    utils::vec_normal_(v);
+    key.push_back(k);
+    value.push_back(v);
+    kv_last_page_len.push_back(last_page_len);
+    kv_indptr.push_back(kv_indptr.back() + num_pages);
+    for (size_t j = 0; j < num_pages; ++j) {
+      kv_indices.push_back(page_counter++);
+    }
+  }
+
+  k_data.resize(page_counter * num_kv_heads * page_size * head_dim);
+  v_data.resize(page_counter * num_kv_heads * page_size * head_dim);
+  flashinfer::paged_kv_t<DTypeKV, int32_t> paged_kv_cpu(
+      num_kv_heads, page_size, head_dim, batch_size, kv_layout, k_data.data(), v_data.data(),
+      kv_indices.data(), kv_indptr.data(), kv_last_page_len.data());
+  cpu_reference::append_paged_kv_cache<DTypeKV, int32_t>(paged_kv_cpu, key, value, append_indptr);
+
+  // copy data to device
+  thrust::device_vector<DTypeKV> k_data_device(k_data);
+  thrust::device_vector<DTypeKV> v_data_device(v_data);
+  thrust::device_vector<int32_t> kv_indptr_device(kv_indptr);
+  thrust::device_vector<int32_t> kv_indices_device(kv_indices);
+  thrust::device_vector<int32_t> kv_last_page_len_device(kv_last_page_len);
+
+  // create paged_kv object
+  flashinfer::paged_kv_t<DTypeKV, int32_t> paged_kv = paged_kv_cpu;
+  paged_kv.k_data = thrust::raw_pointer_cast(k_data_device.data());
+  paged_kv.v_data = thrust::raw_pointer_cast(v_data_device.data());
+  paged_kv.indices = thrust::raw_pointer_cast(kv_indices_device.data());
+  paged_kv.indptr = thrust::raw_pointer_cast(kv_indptr_device.data());
+  paged_kv.last_page_len = thrust::raw_pointer_cast(kv_last_page_len_device.data());
+
+  BatchPrefillHandler handler;
+  size_t float_workspace_size_in_bytes = 128 * 1024 * 1024;
+  thrust::device_vector<char> float_buffer(float_workspace_size_in_bytes);
+  size_t int_workspace_size_in_bytes = 8 * 1024 * 1024;
+  thrust::device_vector<char> int_buffer(int_workspace_size_in_bytes);
+
+  for (uint32_t request_idx = 0; request_idx < batch_size; ++request_idx) {
+    // create one-hot queries
+    int32_t q_len = q_lens[request_idx], kv_len = kv_lens[request_idx];
+    std::vector<int32_t> q_indptr{0};
+    for (uint32_t i = 0; i < batch_size; ++i) {
+      q_indptr.push_back(i >= request_idx ? q_len : 0);
+    }
+    std::vector<DTypeQO> q(q_len * num_qo_heads * head_dim);
+    utils::vec_normal_(q);
+
+    std::vector<DTypeQO> o_ref = cpu_reference::single_mha<DTypeQO, DTypeKV, DTypeQO>(
+        q, key[request_idx], value[request_idx], q_len, kv_len, num_qo_heads, num_kv_heads,
+        head_dim, causal, QKVLayout::kNHD, pos_encoding_mode);
+
+    thrust::device_vector<int32_t> q_indptr_device(q_indptr);
+    thrust::device_vector<DTypeQO> q_device(q);
+    thrust::device_vector<DTypeQO> o_device(q_len * num_qo_heads * head_dim);
+
+    handler.Plan<DTypeQO, int32_t>(
+        (void*)thrust::raw_pointer_cast(float_buffer.data()), float_workspace_size_in_bytes,
+        (void*)thrust::raw_pointer_cast(int_buffer.data()), int_workspace_size_in_bytes,
+        q_indptr.data(), kv_indptr.data(), /*total_num_rows=*/q_indptr.back(), batch_size,
+        num_qo_heads, num_kv_heads, head_dim, page_size);
+
+    for (uint32_t num_runs = 0; num_runs < 10; ++num_runs) {
+      auto status =
+          flashinfer::BatchPrefillWithPagedKVCacheWrapper<DTypeQO, DTypeKV, DTypeQO, int32_t>(
+              &handler, thrust::raw_pointer_cast(q_device.data()),
+              thrust::raw_pointer_cast(q_indptr_device.data()), /*q_rope_offset=*/nullptr, paged_kv,
+              thrust::raw_pointer_cast(o_device.data()),
+              /*lse=*/nullptr, num_qo_heads, causal, pos_encoding_mode, use_fp16_qk_reduction);
+      EXPECT_EQ(status, cudaSuccess) << "CUDA error: " + std::string(cudaGetErrorString(status));
+    }
+
+    thrust::host_vector<DTypeQO> o_host(o_device);
+    size_t num_result_errors_atol_1e_3_rtol_1e_3 = 0;
+    bool nan_detected = false;
+    for (size_t i = 0; i < q_len * num_qo_heads * head_dim; ++i) {
+      if (std::isnan(float(o_host[i]))) {
+        nan_detected = true;
+      }
+      num_result_errors_atol_1e_3_rtol_1e_3 +=
+          (!utils::isclose(float(o_host[i]), float(o_ref[i]), 1e-3, 1e-3));
+    }
+    float result_accuracy = 1. - float(num_result_errors_atol_1e_3_rtol_1e_3) /
+                                     max(float(q_len * num_qo_heads * head_dim), 1.f);
+    std::cout << "request_idx=" << request_idx << ", page_size=" << page_size
+              << ", num_qo_heads=" << num_qo_heads << ", num_kv_heads=" << num_kv_heads
+              << ", q_len=" << q_len << ", kv_len=" << kv_len << ", head_dim=" << head_dim
+              << ", causal=" << causal
+              << ", pos_encoding_mode=" << PosEncodingModeToString(pos_encoding_mode)
+              << ", result_accuracy=" << result_accuracy << std::endl;
+    EXPECT_GT(result_accuracy, 0.99) << "Result correctness test failed.";
+    EXPECT_EQ(nan_detected, false) << "NaN detected in output.";
+  }
+}
+
+template <typename DTypeQO, typename DTypeKV>
+void _TestBatchRaggedPrefillKernelCorrectness(size_t num_kv_heads, size_t num_qo_heads,
+                                              size_t head_dim, bool causal,
+                                              PosEncodingMode pos_encoding_mode,
+                                              bool use_fp16_qk_reduction) {
+  uint32_t batch_size = 9;
+  std::vector<int32_t> q_lens(batch_size), kv_lens(batch_size);
+  utils::vec_randint_(q_lens, 10, 15);
+  utils::vec_randint_(kv_lens, 128, 2048);
+  std::vector<int32_t> append_indptr{0}, kv_indptr{0};
+
+  for (uint32_t request_idx = 0; request_idx < batch_size; ++request_idx) {
+    append_indptr.push_back(append_indptr.back() + q_lens[request_idx]);
+    kv_indptr.push_back(kv_indptr.back() + kv_lens[request_idx]);
+  }
+
+  std::vector<DTypeQO> queries;
+  std::vector<DTypeKV> keys;
+  std::vector<DTypeKV> values;
+  std::vector<DTypeKV> output_refs;
+
+  BatchPrefillHandler handler;
+  size_t float_workspace_size_in_bytes = 128 * 1024 * 1024;
+  thrust::device_vector<char> float_buffer(float_workspace_size_in_bytes);
+  size_t int_workspace_size_in_bytes = 8 * 1024 * 1024;
+  thrust::device_vector<char> int_buffer(int_workspace_size_in_bytes);
+
+  for (uint32_t request_idx = 0; request_idx < batch_size; ++request_idx) {
+    std::vector<DTypeQO> q(q_lens[request_idx] * num_qo_heads * head_dim);
+    std::vector<DTypeKV> k(kv_lens[request_idx] * num_kv_heads * head_dim),
+        v(kv_lens[request_idx] * num_kv_heads * head_dim);
+    uint32_t q_len = q_lens[request_idx], kv_len = kv_lens[request_idx];
+    utils::vec_normal_(q);
+    utils::vec_normal_(k);
+    utils::vec_normal_(v);
+    std::vector<DTypeQO> o_ref = cpu_reference::single_mha<DTypeQO, DTypeKV, DTypeQO>(
+        q, k, v, q_len, kv_len, num_qo_heads, num_kv_heads, head_dim, causal, QKVLayout::kNHD,
+        pos_encoding_mode);
+    // NOTE(Zihao): The following code is only compatible with kv_layout = QKVLayout::kNHD
+    std::copy(q.begin(), q.end(), std::back_inserter(queries));
+    std::copy(k.begin(), k.end(), std::back_inserter(keys));
+    std::copy(v.begin(), v.end(), std::back_inserter(values));
+    std::copy(o_ref.begin(), o_ref.end(), std::back_inserter(output_refs));
+  }
+
+  thrust::device_vector<DTypeQO> queries_device(queries);
+  thrust::device_vector<DTypeKV> keys_device(keys);
+  thrust::device_vector<DTypeKV> values_device(values);
+  thrust::device_vector<DTypeQO> output_device(queries.size());
+  thrust::device_vector<int32_t> append_indptr_device(append_indptr);
+  thrust::device_vector<int32_t> kv_indptr_device(kv_indptr);
+
+  handler.Plan<DTypeQO, int32_t>(
+      (void*)thrust::raw_pointer_cast(float_buffer.data()), float_workspace_size_in_bytes,
+      (void*)thrust::raw_pointer_cast(int_buffer.data()), int_workspace_size_in_bytes,
+      append_indptr.data(), kv_indptr.data(), /*total_num_rows=*/append_indptr.back(), batch_size,
+      num_qo_heads, num_kv_heads, head_dim, /*page_size=*/1);
+
+  auto status = BatchPrefillWithRaggedKVCacheWrapper<DTypeQO, DTypeKV, DTypeQO, int32_t>(
+      &handler, thrust::raw_pointer_cast(queries_device.data()),
+      thrust::raw_pointer_cast(append_indptr_device.data()),
+      thrust::raw_pointer_cast(keys_device.data()), thrust::raw_pointer_cast(values_device.data()),
+      thrust::raw_pointer_cast(kv_indptr_device.data()),
+      /*q_rope_offset=*/nullptr,
+      /*k_rope_offset=*/nullptr, thrust::raw_pointer_cast(output_device.data()),
+      /*lse=*/nullptr, batch_size, num_qo_heads, num_kv_heads, head_dim, causal, kv_layout,
+      pos_encoding_mode, use_fp16_qk_reduction);
+
+  EXPECT_EQ(status, cudaSuccess) << "CUDA error: " + std::string(cudaGetErrorString(status));
+
+  thrust::host_vector<DTypeQO> output_host(output_device);
+  size_t num_result_errors_atol_1e_3_rtol_1e_3 = 0;
+  bool nan_detected = false;
+  for (size_t i = 0; i < output_refs.size(); ++i) {
+    if (std::isnan(float(output_host[i]))) {
+      nan_detected = true;
+    }
+    num_result_errors_atol_1e_3_rtol_1e_3 +=
+        (!utils::isclose(float(output_host[i]), float(output_refs[i]), 1e-3, 1e-3));
+  }
+
+  float result_accuracy =
+      1. - float(num_result_errors_atol_1e_3_rtol_1e_3) / max(float(output_refs.size()), 1.f);
+  std::cout << "num_qo_heads=" << num_qo_heads << ", num_kv_heads=" << num_kv_heads
+            << ", head_dim=" << head_dim << ", causal=" << causal
+            << ", pos_encoding_mode=" << PosEncodingModeToString(pos_encoding_mode)
+            << ", result_accuracy=" << result_accuracy << std::endl;
+
+  EXPECT_GT(result_accuracy, 0.99) << "Result correctness test failed.";
+  EXPECT_EQ(nan_detected, false) << "NaN detected in output.";
+}
+
+template <typename DTypeQO, typename DTypeKV>
+void _TestBatchPagedPrefillKernelShortContextCorrectness(size_t num_kv_heads, size_t num_qo_heads,
+                                                         size_t page_size, size_t head_dim,
+                                                         bool causal,
+                                                         PosEncodingMode pos_encoding_mode,
+                                                         bool use_fp16_qk_reduction) {
+  const uint32_t batch_size = 7;
+  std::vector<int32_t> q_lens(batch_size);
+  utils::vec_randint_(q_lens, 1, 64);
+  std::vector<int32_t> kv_lens(q_lens);
+
+  std::vector<int32_t> q_indptr{0};
+  for (uint32_t request_idx = 0; request_idx < batch_size; ++request_idx) {
+    q_indptr.push_back(q_indptr.back() + q_lens[request_idx]);
+  }
+  std::vector<int32_t> append_indptr{0};
+  for (uint32_t request_idx = 0; request_idx < batch_size; ++request_idx) {
+    append_indptr.push_back(append_indptr.back() + kv_lens[request_idx]);
+  }
+  std::vector<DTypeKV> k_data;
+  std::vector<DTypeKV> v_data;
+  std::vector<int32_t> kv_indptr{0};
+  std::vector<int32_t> kv_indices;
+  std::vector<int32_t> kv_last_page_len;
+  size_t page_counter = 0;
+  std::vector<std::vector<DTypeKV>> key, value;
+  for (uint32_t request_idx = 0; request_idx < batch_size; ++request_idx) {
+    size_t kv_len = kv_lens[request_idx];
+    size_t num_pages = (kv_len + page_size - 1) / page_size;
+    size_t last_page_len = (kv_len - 1) % page_size + 1;
+    std::vector<DTypeKV> k(kv_len * num_kv_heads * head_dim), v(kv_len * num_kv_heads * head_dim);
+    utils::vec_normal_(k);
+    utils::vec_normal_(v);
+    key.push_back(k);
+    value.push_back(v);
+    kv_last_page_len.push_back(last_page_len);
+    kv_indptr.push_back(kv_indptr.back() + num_pages);
+    for (size_t j = 0; j < num_pages; ++j) {
+      kv_indices.push_back(page_counter++);
+    }
+  }
+
+  k_data.resize(page_counter * num_kv_heads * page_size * head_dim);
+  v_data.resize(page_counter * num_kv_heads * page_size * head_dim);
+  flashinfer::paged_kv_t<DTypeKV, int32_t> paged_kv_cpu(
+      num_kv_heads, page_size, head_dim, batch_size, kv_layout, k_data.data(), v_data.data(),
+      kv_indices.data(), kv_indptr.data(), kv_last_page_len.data());
+  cpu_reference::append_paged_kv_cache<DTypeKV, int32_t>(paged_kv_cpu, key, value, append_indptr);
+
+  // copy data to device
+  thrust::device_vector<DTypeKV> k_data_device(k_data);
+  thrust::device_vector<DTypeKV> v_data_device(v_data);
+  thrust::device_vector<int32_t> kv_indptr_device(kv_indptr);
+  thrust::device_vector<int32_t> kv_indices_device(kv_indices);
+  thrust::device_vector<int32_t> kv_last_page_len_device(kv_last_page_len);
+
+  // create paged_kv object
+  flashinfer::paged_kv_t<DTypeKV, int32_t> paged_kv = paged_kv_cpu;
+  paged_kv.k_data = thrust::raw_pointer_cast(k_data_device.data());
+  paged_kv.v_data = thrust::raw_pointer_cast(v_data_device.data());
+  paged_kv.indices = thrust::raw_pointer_cast(kv_indices_device.data());
+  paged_kv.indptr = thrust::raw_pointer_cast(kv_indptr_device.data());
+  paged_kv.last_page_len = thrust::raw_pointer_cast(kv_last_page_len_device.data());
+
+  std::vector<std::vector<DTypeQO>> q, o_ref;
+  for (uint32_t request_idx = 0; request_idx < batch_size; ++request_idx) {
+    int32_t q_len = q_lens[request_idx];
+    std::vector<DTypeQO> qi(q_len * num_qo_heads * head_dim);
+    utils::vec_normal_(qi);
+    q.push_back(qi);
+  }
+  for (uint32_t request_idx = 0; request_idx < batch_size; ++request_idx) {
+    int32_t q_len = q_lens[request_idx], kv_len = kv_lens[request_idx];
+    std::vector<DTypeQO> o_ref_i = cpu_reference::single_mha<DTypeQO, DTypeKV, DTypeQO>(
+        q[request_idx], key[request_idx], value[request_idx], q_len, kv_len, num_qo_heads,
+        num_kv_heads, head_dim, causal, QKVLayout::kNHD, pos_encoding_mode);
+    o_ref.push_back(o_ref_i);
+  }
+
+  std::vector<DTypeQO> q_concat, o_concat_ref;
+  for (uint32_t request_idx = 0; request_idx < batch_size; ++request_idx) {
+    q_concat.insert(q_concat.end(), q[request_idx].begin(), q[request_idx].end());
+    o_concat_ref.insert(o_concat_ref.end(), o_ref[request_idx].begin(), o_ref[request_idx].end());
+  }
+  thrust::device_vector<DTypeQO> q_device(q_concat);
+
+  thrust::device_vector<int32_t> q_indptr_device(q_indptr);
+  thrust::device_vector<DTypeQO> o_device(o_concat_ref.size());
+
+  BatchPrefillHandler handler;
+  size_t float_workspace_size_in_bytes = 32 * 1024 * 1024;
+  thrust::device_vector<char> float_buffer(float_workspace_size_in_bytes);
+  size_t int_workspace_size_in_bytes = 8 * 1024 * 1024;
+  thrust::device_vector<char> int_buffer(int_workspace_size_in_bytes);
+
+  handler.Plan<DTypeQO, int32_t>(
+      (void*)thrust::raw_pointer_cast(float_buffer.data()), float_workspace_size_in_bytes,
+      (void*)thrust::raw_pointer_cast(int_buffer.data()), int_workspace_size_in_bytes,
+      q_indptr.data(), kv_indptr.data(), /*total_num_rows=*/q_indptr.back(), batch_size,
+      num_qo_heads, num_kv_heads, head_dim, page_size);
+
+  auto status = BatchPrefillWithPagedKVCacheWrapper<DTypeQO, DTypeKV, DTypeQO, int32_t>(
+      &handler, thrust::raw_pointer_cast(q_device.data()),
+      thrust::raw_pointer_cast(q_indptr_device.data()),
+      /*q_rope_offset=*/nullptr, paged_kv, thrust::raw_pointer_cast(o_device.data()),
+      /*lse=*/nullptr, num_qo_heads, causal, pos_encoding_mode, use_fp16_qk_reduction);
+  EXPECT_EQ(status, cudaSuccess) << "CUDA error: " + std::string(cudaGetErrorString(status));
+
+  thrust::host_vector<DTypeQO> o_host(o_device);
+  size_t num_result_errors_atol_1e_3_rtol_1e_3 = 0;
+  bool nan_detected = false;
+  for (size_t i = 0; i < o_concat_ref.size(); ++i) {
+    if (std::isnan(float(o_host[i]))) {
+      nan_detected = true;
+    }
+    num_result_errors_atol_1e_3_rtol_1e_3 +=
+        (!utils::isclose(float(o_host[i]), float(o_concat_ref[i]), 1e-3, 1e-3));
+  }
+  float result_accuracy =
+      1. - float(num_result_errors_atol_1e_3_rtol_1e_3) / max(float(o_concat_ref.size()), 1.f);
+  std::cout << "page_size=" << page_size << ", num_qo_heads=" << num_qo_heads
+            << ", num_kv_heads=" << num_kv_heads << ", head_dim=" << head_dim
+            << ", causal=" << causal
+            << ", pos_encoding_mode=" << PosEncodingModeToString(pos_encoding_mode)
+            << ", result_accuracy=" << result_accuracy << std::endl;
+  EXPECT_GT(result_accuracy, 0.99) << "Result correctness test failed.";
+  EXPECT_EQ(nan_detected, false) << "NaN detected in output.";
+}
+
+template <typename DTypeQO, typename DTypeKV>
+void _TestBatchPagedPrefillKernelQMinMaxKVMinMaxCorrectness(
+    size_t batch_size, size_t num_kv_heads, size_t num_qo_heads, size_t page_size, size_t head_dim,
+    bool use_fp16_qk_reduction, uint32_t q_len_min, uint32_t q_len_max, uint32_t kv_len_min,
+    uint32_t kv_len_max) {
+  std::vector<int32_t> q_lens(batch_size);
+  utils::vec_randint_(q_lens, q_len_min, q_len_max);
+  std::vector<int32_t> kv_lens(batch_size);
+  utils::vec_randint_(kv_lens, kv_len_min, kv_len_max);
+
+  std::vector<int32_t> q_indptr{0};
+  for (uint32_t request_idx = 0; request_idx < batch_size; ++request_idx) {
+    q_indptr.push_back(q_indptr.back() + q_lens[request_idx]);
+  }
+  std::vector<int32_t> append_indptr{0};
+  for (uint32_t request_idx = 0; request_idx < batch_size; ++request_idx) {
+    append_indptr.push_back(append_indptr.back() + kv_lens[request_idx]);
+  }
+  std::vector<DTypeKV> k_data;
+  std::vector<DTypeKV> v_data;
+  std::vector<int32_t> kv_indptr{0};
+  std::vector<int32_t> kv_indices;
+  std::vector<int32_t> kv_last_page_len;
+  size_t page_counter = 0;
+  std::vector<std::vector<DTypeKV>> key, value;
+  for (uint32_t request_idx = 0; request_idx < batch_size; ++request_idx) {
+    size_t kv_len = kv_lens[request_idx];
+    size_t num_pages = (kv_len + page_size - 1) / page_size;
+    size_t last_page_len = num_pages == 0 ? 0 : (kv_len - 1) % page_size + 1;
+    std::vector<DTypeKV> k(kv_len * num_kv_heads * head_dim), v(kv_len * num_kv_heads * head_dim);
+    utils::vec_normal_(k);
+    utils::vec_normal_(v);
+    key.push_back(k);
+    value.push_back(v);
+    kv_last_page_len.push_back(last_page_len);
+    kv_indptr.push_back(kv_indptr.back() + num_pages);
+    for (size_t j = 0; j < num_pages; ++j) {
+      kv_indices.push_back(page_counter++);
+    }
+  }
+
+  k_data.resize(page_counter * num_kv_heads * page_size * head_dim);
+  v_data.resize(page_counter * num_kv_heads * page_size * head_dim);
+  flashinfer::paged_kv_t<DTypeKV, int32_t> paged_kv_cpu(
+      num_kv_heads, page_size, head_dim, batch_size, kv_layout, k_data.data(), v_data.data(),
+      kv_indices.data(), kv_indptr.data(), kv_last_page_len.data());
+  cpu_reference::append_paged_kv_cache<DTypeKV, int32_t>(paged_kv_cpu, key, value, append_indptr);
+
+  // copy data to device
+  thrust::device_vector<DTypeKV> k_data_device(k_data);
+  thrust::device_vector<DTypeKV> v_data_device(v_data);
+  thrust::device_vector<int32_t> kv_indptr_device(kv_indptr);
+  thrust::device_vector<int32_t> kv_indices_device(kv_indices);
+  thrust::device_vector<int32_t> kv_last_page_len_device(kv_last_page_len);
+
+  // create paged_kv object
+  flashinfer::paged_kv_t<DTypeKV, int32_t> paged_kv = paged_kv_cpu;
+  paged_kv.k_data = thrust::raw_pointer_cast(k_data_device.data());
+  paged_kv.v_data = thrust::raw_pointer_cast(v_data_device.data());
+  paged_kv.indices = thrust::raw_pointer_cast(kv_indices_device.data());
+  paged_kv.indptr = thrust::raw_pointer_cast(kv_indptr_device.data());
+  paged_kv.last_page_len = thrust::raw_pointer_cast(kv_last_page_len_device.data());
+
+  std::vector<std::vector<DTypeQO>> q, o_ref;
+  for (uint32_t request_idx = 0; request_idx < batch_size; ++request_idx) {
+    int32_t q_len = q_lens[request_idx];
+    std::vector<DTypeQO> qi(q_len * num_qo_heads * head_dim);
+    utils::vec_normal_(qi);
+    q.push_back(qi);
+  }
+  for (uint32_t request_idx = 0; request_idx < batch_size; ++request_idx) {
+    int32_t q_len = q_lens[request_idx], kv_len = kv_lens[request_idx];
+    std::vector<DTypeQO> o_ref_i = cpu_reference::single_mha<DTypeQO, DTypeKV, DTypeQO>(
+        q[request_idx], key[request_idx], value[request_idx], q_len, kv_len, num_qo_heads,
+        num_kv_heads, head_dim, /*causal=*/false, QKVLayout::kNHD,
+        /*pos_encoding_mode*/ PosEncodingMode::kNone);
+    o_ref.push_back(o_ref_i);
+  }
+
+  std::vector<DTypeQO> q_concat, o_concat_ref;
+  for (uint32_t request_idx = 0; request_idx < batch_size; ++request_idx) {
+    q_concat.insert(q_concat.end(), q[request_idx].begin(), q[request_idx].end());
+    o_concat_ref.insert(o_concat_ref.end(), o_ref[request_idx].begin(), o_ref[request_idx].end());
+  }
+  thrust::device_vector<DTypeQO> q_device(q_concat);
+
+  thrust::device_vector<int32_t> q_indptr_device(q_indptr);
+  thrust::device_vector<DTypeQO> o_device(o_concat_ref.size());
+
+  BatchPrefillHandler handler;
+  size_t float_workspace_size_in_bytes = 32 * 1024 * 1024;
+  thrust::device_vector<char> float_buffer(float_workspace_size_in_bytes);
+  size_t int_workspace_size_in_bytes = 8 * 1024 * 1024;
+  thrust::device_vector<char> int_buffer(int_workspace_size_in_bytes);
+
+  handler.Plan<DTypeQO, int32_t>(
+      (void*)thrust::raw_pointer_cast(float_buffer.data()), float_workspace_size_in_bytes,
+      (void*)thrust::raw_pointer_cast(int_buffer.data()), int_workspace_size_in_bytes,
+      q_indptr.data(), kv_indptr.data(), /*total_num_rows=*/q_indptr.back(), batch_size,
+      num_qo_heads, num_kv_heads, head_dim, page_size);
+
+  auto status = BatchPrefillWithPagedKVCacheWrapper<DTypeQO, DTypeKV, DTypeQO, int32_t>(
+      &handler, thrust::raw_pointer_cast(q_device.data()),
+      thrust::raw_pointer_cast(q_indptr_device.data()),
+      /*q_rope_offset=*/nullptr, paged_kv, thrust::raw_pointer_cast(o_device.data()),
+      /*lse=*/nullptr, num_qo_heads, /*causal=*/false,
+      /*pos_encoding_mode*/ PosEncodingMode::kNone);
+  EXPECT_EQ(status, cudaSuccess) << "CUDA error: " + std::string(cudaGetErrorString(status));
+
+  thrust::host_vector<DTypeQO> o_host(o_device);
+  size_t num_result_errors_atol_1e_3_rtol_1e_3 = 0;
+  bool nan_detected = false;
+  for (size_t i = 0; i < o_concat_ref.size(); ++i) {
+    if (std::isnan(float(o_host[i]))) {
+      nan_detected = true;
+    }
+    num_result_errors_atol_1e_3_rtol_1e_3 +=
+        (!utils::isclose(float(o_host[i]), float(o_concat_ref[i]), 1e-3, 1e-3));
+  }
+  float result_accuracy =
+      1. - float(num_result_errors_atol_1e_3_rtol_1e_3) / max(float(o_concat_ref.size()), 1.f);
+  std::cout << "batch_size=" << batch_size << ", page_size=" << page_size
+            << ", num_qo_heads=" << num_qo_heads << ", num_kv_heads=" << num_kv_heads
+            << ", head_dim=" << head_dim << ", result_accuracy=" << result_accuracy << std::endl;
+  EXPECT_GT(result_accuracy, 0.99) << "Result correctness test failed.";
+  EXPECT_EQ(nan_detected, false) << "NaN detected in output.";
+}
+
+template <typename DTypeQO, typename DTypeKV>
+void _TestBatchPagedPrefillKernelLongContextCorrectness(size_t num_kv_heads, size_t num_qo_heads,
+                                                        size_t page_size, size_t head_dim,
+                                                        bool causal,
+                                                        PosEncodingMode pos_encoding_mode,
+                                                        bool use_fp16_qk_reduction) {
+  std::vector<std::vector<std::vector<DTypeKV>>> keys, values;
+  std::vector<int32_t> q_lens{33}, kv_lens{32768};
+  std::vector<int32_t> q_indptr{0, 33};
+  std::vector<int32_t> append_indptr{0, 32768};
+  std::vector<DTypeKV> k_data;
+  std::vector<DTypeKV> v_data;
+  std::vector<int32_t> kv_indptr{0};
+  std::vector<int32_t> kv_indices;
+  std::vector<int32_t> kv_last_page_len;
+  size_t page_counter = 0;
+
+  size_t num_pages = (kv_lens[0] + page_size - 1) / page_size;
+  size_t last_page_len = (kv_lens[0] - 1) % page_size + 1;
+  std::vector<DTypeKV> k(kv_lens[0] * num_kv_heads * head_dim),
+      v(kv_lens[0] * num_kv_heads * head_dim);
+  utils::vec_normal_(k);
+  utils::vec_normal_(v);
+  kv_last_page_len.push_back(last_page_len);
+  kv_indptr.push_back(kv_indptr.back() + num_pages);
+  for (size_t j = 0; j < num_pages; ++j) {
+    kv_indices.push_back(page_counter++);
+  }
+
+  k_data.resize(page_counter * 1 * num_kv_heads * page_size * head_dim);
+  v_data.resize(page_counter * 1 * num_kv_heads * page_size * head_dim);
+  flashinfer::paged_kv_t<DTypeKV, int32_t> paged_kv_cpu(
+      num_kv_heads, page_size, head_dim, 1, kv_layout, k_data.data(), v_data.data(),
+      kv_indices.data(), kv_indptr.data(), kv_last_page_len.data());
+  cpu_reference::append_paged_kv_cache<DTypeKV, int32_t>(paged_kv_cpu, {k}, {v}, append_indptr);
+
+  // copy data to device
+  thrust::device_vector<DTypeKV> k_data_device(k_data);
+  thrust::device_vector<DTypeKV> v_data_device(v_data);
+  thrust::device_vector<int32_t> kv_indptr_device(kv_indptr);
+  thrust::device_vector<int32_t> kv_indices_device(kv_indices);
+  thrust::device_vector<int32_t> kv_last_page_len_device(kv_last_page_len);
+
+  // create paged_kv object
+  flashinfer::paged_kv_t<DTypeKV, int32_t> paged_kv = paged_kv_cpu;
+  paged_kv.k_data = thrust::raw_pointer_cast(k_data_device.data());
+  paged_kv.v_data = thrust::raw_pointer_cast(v_data_device.data());
+  paged_kv.indices = thrust::raw_pointer_cast(kv_indices_device.data());
+  paged_kv.indptr = thrust::raw_pointer_cast(kv_indptr_device.data());
+  paged_kv.last_page_len = thrust::raw_pointer_cast(kv_last_page_len_device.data());
+
+  // create one-hot queries
+  std::vector<DTypeQO> q(q_lens[0] * num_qo_heads * head_dim);
+  utils::vec_normal_(q);
+
+  std::vector<DTypeQO> o_ref = cpu_reference::single_mha<DTypeQO, DTypeKV, DTypeQO>(
+      q, k, v, q_lens[0], kv_lens[0], num_qo_heads, num_kv_heads, head_dim, causal, QKVLayout::kNHD,
+      pos_encoding_mode);
+
+  thrust::device_vector<int32_t> q_indptr_device(q_indptr);
+  thrust::device_vector<DTypeQO> q_device(q);
+  thrust::device_vector<DTypeQO> o_device(q_lens[0] * num_qo_heads * head_dim);
+
+  BatchPrefillHandler handler;
+  size_t float_workspace_size_in_bytes = 32 * 1024 * 1024;
+  thrust::device_vector<char> float_buffer(float_workspace_size_in_bytes);
+  size_t int_workspace_size_in_bytes = 8 * 1024 * 1024;
+  thrust::device_vector<char> int_buffer(int_workspace_size_in_bytes);
+
+  handler.Plan<DTypeQO, int32_t>(
+      (void*)thrust::raw_pointer_cast(float_buffer.data()), float_workspace_size_in_bytes,
+      (void*)thrust::raw_pointer_cast(int_buffer.data()), int_workspace_size_in_bytes,
+      append_indptr.data(), kv_indptr.data(), /*total_num_rows=*/append_indptr.back(),
+      /*batch_size=*/1, num_qo_heads, num_kv_heads, head_dim, page_size);
+
+  auto status = BatchPrefillWithPagedKVCacheWrapper<DTypeQO, DTypeKV, DTypeQO, int32_t>(
+      &handler, thrust::raw_pointer_cast(q_device.data()),
+      thrust::raw_pointer_cast(q_indptr_device.data()),
+      /*q_rope_offset=*/nullptr, paged_kv, thrust::raw_pointer_cast(o_device.data()),
+      /*lse=*/nullptr, num_qo_heads, causal, pos_encoding_mode, use_fp16_qk_reduction);
+  EXPECT_EQ(status, cudaSuccess) << "CUDA error: " + std::string(cudaGetErrorString(status));
+
+  thrust::host_vector<DTypeQO> o_host(o_device);
+  size_t num_result_errors_atol_1e_3_rtol_1e_3 = 0;
+  bool nan_detected = false;
+  for (size_t i = 0; i < q_lens[0] * num_qo_heads * head_dim; ++i) {
+    if (std::isnan(float(o_host[i]))) {
+      nan_detected = true;
+    }
+    num_result_errors_atol_1e_3_rtol_1e_3 +=
+        (!utils::isclose(float(o_host[i]), float(o_ref[i]), 1e-3, 1e-3));
+  }
+  float result_accuracy = 1. - float(num_result_errors_atol_1e_3_rtol_1e_3) /
+                                   max(float(q_lens[0] * num_qo_heads * head_dim), 1.f);
+  std::cout << "page_size=" << page_size << ", num_qo_heads=" << num_qo_heads
+            << ", num_kv_heads=" << num_kv_heads << ", q_len=" << q_lens[0]
+            << ", kv_len=" << kv_lens[0] << ", head_dim=" << head_dim << ", causal=" << causal
+            << ", pos_encoding_mode=" << PosEncodingModeToString(pos_encoding_mode)
+            << ", result_accuracy=" << result_accuracy << std::endl;
+  EXPECT_GT(result_accuracy, 0.99) << "Result correctness test failed.";
+  EXPECT_EQ(nan_detected, false) << "NaN detected in output.";
+}
+
+template <typename T>
+void TestBatchPagedPrefillKernelOneHotCorrectness(bool use_fp16_qk_reduction) {
+  for (size_t num_kv_heads : {4, 8, 32}) {
+    for (size_t num_qo_heads : {32}) {
+      for (size_t page_size : {1, 16}) {
+        for (size_t head_dim : {64, 128, 256}) {
+          for (size_t causal : {false, true}) {
+            for (size_t pos_encoding_mode : {0, 1}) {
+              _TestBatchPagedPrefillKernelOneHotCorrectness<T, T>(
+                  num_kv_heads, num_qo_heads, page_size, head_dim, causal,
+                  PosEncodingMode(pos_encoding_mode), use_fp16_qk_reduction);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+template <typename T>
+void TestBatchPagedPrefillKernelShortContextCorrectness(bool use_fp16_qk_reduction) {
+  for (size_t num_kv_heads : {4, 8, 32}) {
+    for (size_t num_qo_heads : {32}) {
+      for (size_t page_size : {1, 16}) {
+        for (size_t head_dim : {64, 128, 256}) {
+          for (size_t causal : {false, true}) {
+            for (size_t pos_encoding_mode : {0, 1}) {
+              _TestBatchPagedPrefillKernelShortContextCorrectness<T, T>(
+                  num_kv_heads, num_qo_heads, page_size, head_dim, causal,
+                  PosEncodingMode(pos_encoding_mode), use_fp16_qk_reduction);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+template <typename DTypeKV>
+void TestBatchPagedPrefillFP8KernelShortContextCorrectness(bool use_fp16_qk_reduction) {
+  for (size_t num_kv_heads : {4, 8, 32}) {
+    for (size_t num_qo_heads : {32}) {
+      for (size_t page_size : {1, 16}) {
+        for (size_t head_dim : {64, 128, 256}) {
+          for (size_t causal : {false, true}) {
+            for (size_t pos_encoding_mode : {0}) {
+              _TestBatchPagedPrefillKernelShortContextCorrectness<half, DTypeKV>(
+                  num_kv_heads, num_qo_heads, page_size, head_dim, causal,
+                  PosEncodingMode(pos_encoding_mode), use_fp16_qk_reduction);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+template <typename T>
+void TestBatchPagedPrefillKernelLongContextCorrectness(bool use_fp16_qk_reduction) {
+  for (size_t num_kv_heads : {1, 2, 8}) {
+    for (size_t group_size : {1, 3, 4, 5, 6, 7, 8}) {
+      size_t num_qo_heads = num_kv_heads * group_size;
+      for (size_t page_size : {1, 16}) {
+        for (size_t head_dim : {64, 128, 256}) {
+          for (size_t causal : {false, true}) {
+            for (size_t pos_encoding_mode : {0, 1}) {
+              _TestBatchPagedPrefillKernelLongContextCorrectness<T, T>(
+                  num_kv_heads, num_qo_heads, page_size, head_dim, causal,
+                  PosEncodingMode(pos_encoding_mode), use_fp16_qk_reduction);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+template <typename DTypeKV>
+void TestBatchPagedPrefillFP8KernelLongContextCorrectness(bool use_fp16_qk_reduction) {
+  for (size_t num_kv_heads : {1, 2, 8}) {
+    for (size_t group_size : {1, 3, 4, 5, 6, 7, 8}) {
+      size_t num_qo_heads = num_kv_heads * group_size;
+      for (size_t page_size : {1, 16}) {
+        for (size_t head_dim : {64, 128, 256}) {
+          for (size_t causal : {false, true}) {
+            for (size_t pos_encoding_mode : {0}) {
+              _TestBatchPagedPrefillKernelLongContextCorrectness<half, DTypeKV>(
+                  num_kv_heads, num_qo_heads, page_size, head_dim, causal,
+                  PosEncodingMode(pos_encoding_mode), use_fp16_qk_reduction);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+template <typename T>
+void TestBatchPagedPrefillKernelZeroContextCorrectness(bool use_fp16_qk_reduction) {
+  for (size_t batch_size : {1, 4, 7, 11, 19, 37, 99}) {
+    for (size_t num_kv_heads : {1, 4}) {
+      for (size_t group_size : {1, 8}) {
+        size_t num_qo_heads = num_kv_heads * group_size;
+        for (size_t page_size : {1, 16}) {
+          for (size_t head_dim : {64, 128, 256}) {
+            for (size_t kv_len_max : {0, 3}) {
+              _TestBatchPagedPrefillKernelQMinMaxKVMinMaxCorrectness<T, T>(
+                  batch_size, num_kv_heads, num_qo_heads, page_size, head_dim,
+                  use_fp16_qk_reduction,
+                  /*q_len_min=*/1, /*q_len_max=*/3, /*kv_len_min=*/0, kv_len_max);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+template <typename T>
+void TestBatchRaggedPrefillKernelCorrectness(bool use_fp16_qk_reduction) {
+  for (size_t num_kv_heads : {4, 8, 32}) {
+    for (size_t num_qo_heads : {32}) {
+      for (size_t head_dim : {64, 128, 256}) {
+        for (size_t causal : {false, true}) {
+          for (size_t pos_encoding_mode : {0, 1}) {
+            _TestBatchRaggedPrefillKernelCorrectness<T, T>(
+                num_kv_heads, num_qo_heads, head_dim, causal, PosEncodingMode(pos_encoding_mode),
+                use_fp16_qk_reduction);
+          }
+        }
+      }
+    }
+  }
+}
+
+template <typename DTypeKV>
+void TestBatchRaggedPrefillFP8KernelCorrectness(bool use_fp16_qk_reduction) {
+  for (size_t num_kv_heads : {4, 8, 32}) {
+    for (size_t num_qo_heads : {32}) {
+      for (size_t head_dim : {64, 128, 256}) {
+        for (size_t causal : {false, true}) {
+          for (size_t pos_encoding_mode : {0}) {
+            _TestBatchRaggedPrefillKernelCorrectness<half, DTypeKV>(
+                num_kv_heads, num_qo_heads, head_dim, causal, PosEncodingMode(pos_encoding_mode),
+                use_fp16_qk_reduction);
+          }
+        }
+      }
+    }
+  }
+}
+
+TEST(FlashInferCorrectnessTest, BatchPagedPrefillShortContextTestFP16) {
+  TestBatchPagedPrefillKernelShortContextCorrectness<half>(false);
+}
+
+TEST(FlashInferCorrectnessTest, BatchPagedPrefillShortContextTestFP16QKHalfAccum) {
+  TestBatchPagedPrefillKernelShortContextCorrectness<half>(false);
+}
+
+TEST(FlashInferCorrectnessTest, BatchPagedPrefillLongContextTestFP16) {
+  TestBatchPagedPrefillKernelLongContextCorrectness<half>(false);
+}
+
+TEST(FlashInferCorrectnessTest, BatchPagedPrefillZeroContextTestFP16) {
+  TestBatchPagedPrefillKernelZeroContextCorrectness<half>(false);
+}
+
+TEST(FlashInferCorrectnessTest, BatchPagedPrefillLongContextTestFP16QKHalfAccum) {
+  TestBatchPagedPrefillKernelLongContextCorrectness<half>(true);
+}
+
+TEST(FlashInferCorrectnessTest, BatchPagedPrefillKernelCorrectnessTestOneHotFP16) {
+  TestBatchPagedPrefillKernelOneHotCorrectness<half>(false);
+}
+
+TEST(FlashInferCorrectnessTest, BatchPagedPrefillKernelCorrectnessTestOneHotFP16QKHalfAccum) {
+  TestBatchPagedPrefillKernelOneHotCorrectness<half>(true);
+}
+
+TEST(FlashInferCorrectnessTest, BatchRaggedPrefillTestFP16) {
+  TestBatchRaggedPrefillKernelCorrectness<half>(false);
+}
+
+TEST(FlashInferCorrectnessTest, BatchRaggedPrefillTestFP16QKHalfAccum) {
+  TestBatchRaggedPrefillKernelCorrectness<half>(true);
+}
+
+#ifdef FLASHINFER_ENABLE_FP8_E4M3
+
+TEST(FlashInferCorrectnessTest, BatchPagedPrefillShortContextTestE4M3) {
+  TestBatchPagedPrefillFP8KernelShortContextCorrectness<__nv_fp8_e4m3>(false);
+}
+
+TEST(FlashInferCorrectnessTest, BatchPagedPrefillLongContextTestE4M3) {
+  TestBatchPagedPrefillFP8KernelLongContextCorrectness<__nv_fp8_e4m3>(false);
+}
+
+#endif
+
+#ifdef FLASHINFER_ENABLE_FP8_E5M2
+
+TEST(FlashInferCorrectnessTest, BatchPagedPrefillShortContextTestE5M2) {
+  TestBatchPagedPrefillFP8KernelShortContextCorrectness<__nv_fp8_e5m2>(false);
+}
+
+TEST(FlashInferCorrectnessTest, BatchPagedPrefillLongContextTestE5M2) {
+  TestBatchPagedPrefillFP8KernelLongContextCorrectness<__nv_fp8_e5m2>(false);
+}
+#endif

sglang_repo/sgl-kernel/3rdparty/flashinfer/src/test_cascade.cu

@@ -0,0 +1,657 @@
+/*
+ * Copyright (c) 2023 by FlashInfer team.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <gtest/gtest.h>
+
+#include <flashinfer/attention/cascade.cuh>
+
+#include "flashinfer_ops.cuh"
+#include "utils.h"
+
+using namespace flashinfer;
+constexpr QKVLayout kv_layout = QKVLayout::kHND;
+
+bool is_prime(int x) {
+  for (int i = 2; i < int(std::sqrt(x)); ++i) {
+    if (x % i == 0) return false;
+  }
+  return true;
+}
+
+template <typename T>
+void _TestVariableLengthMergeKernelCorrectness(size_t seq_len, size_t num_heads, size_t head_dim,
+                                               bool sparse_s) {
+  const uint32_t max_num_index_sets = 512;
+  std::vector<int32_t> lengths(seq_len);
+  utils::vec_randint_(lengths, 1, max_num_index_sets);
+  std::vector<int32_t> indptr{0};
+  for (size_t i = 0; i < seq_len; ++i) {
+    indptr.push_back(indptr.back() + lengths[i]);
+  }
+  std::vector<T> V_padded_host(seq_len * max_num_index_sets * num_heads * head_dim);
+  std::vector<T> V_ragged_host(indptr.back() * num_heads * head_dim);
+  std::vector<float> S_padded_host(seq_len * max_num_index_sets * num_heads);
+  std::vector<float> S_ragged_host(indptr.back() * num_heads);
+
+  utils::vec_normal_(V_ragged_host);
+  for (uint32_t j = 0; j < seq_len; ++j) {
+    std::copy(V_ragged_host.begin() + indptr[j] * num_heads * head_dim,
+              V_ragged_host.begin() + indptr[j + 1] * num_heads * head_dim,
+              V_padded_host.begin() + j * max_num_index_sets * num_heads * head_dim);
+  }
+  if (sparse_s) {
+    for (uint32_t i = 0; i < max_num_index_sets; ++i) {
+      float fill_val = is_prime(i) ? 10 : -10;
+      for (uint32_t j = 0; j < seq_len; ++j) {
+        if (i < lengths[j]) {
+          std::fill(S_ragged_host.begin() + (indptr[j] + i) * num_heads,
+                    S_ragged_host.begin() + (indptr[j] + i + 1) * num_heads, fill_val);
+          std::fill(S_padded_host.begin() + (j * max_num_index_sets + i) * num_heads,
+                    S_padded_host.begin() + (j * max_num_index_sets + i + 1) * num_heads, fill_val);
+        } else {
+          std::fill(S_padded_host.begin() + (j * max_num_index_sets + i) * num_heads,
+                    S_padded_host.begin() + (j * max_num_index_sets + i + 1) * num_heads, -5e4);
+        }
+      }
+    }
+  } else {
+    utils::vec_uniform_(S_ragged_host, -10, 10);
+    for (uint32_t j = 0; j < seq_len; ++j) {
+      std::copy(S_ragged_host.begin() + indptr[j] * num_heads,
+                S_ragged_host.begin() + indptr[j + 1] * num_heads,
+                S_padded_host.begin() + (j * max_num_index_sets) * num_heads);
+      std::fill(
+          S_padded_host.begin() + (j * max_num_index_sets + indptr[j + 1] - indptr[j]) * num_heads,
+          S_padded_host.begin() + (j + 1) * max_num_index_sets * num_heads, -5e4);
+    }
+  }
+
+  thrust::device_vector<T> V_padded_device(V_padded_host);
+  thrust::device_vector<T> V_ragged_device(V_ragged_host);
+  thrust::device_vector<float> S_padded_device(S_padded_host);
+  thrust::device_vector<float> S_ragged_device(S_ragged_host);
+  thrust::device_vector<int32_t> indptr_device(indptr);
+  thrust::device_vector<T> V_merged_0_device(seq_len * num_heads * head_dim);
+  thrust::device_vector<T> V_merged_1_device(seq_len * num_heads * head_dim);
+  thrust::device_vector<float> S_merged_0_device(seq_len * num_heads);
+  thrust::device_vector<float> S_merged_1_device(seq_len * num_heads);
+
+  // Method 0: use MergeStates on padded data
+  MergeStates(thrust::raw_pointer_cast(V_padded_device.data()),
+              thrust::raw_pointer_cast(S_padded_device.data()),
+              thrust::raw_pointer_cast(V_merged_0_device.data()),
+              thrust::raw_pointer_cast(S_merged_0_device.data()), max_num_index_sets, seq_len,
+              num_heads, head_dim);
+
+  // Method 1: use VariableLengthMergeStates on ragged data
+  VariableLengthMergeStates(thrust::raw_pointer_cast(V_ragged_device.data()),
+                            thrust::raw_pointer_cast(S_ragged_device.data()),
+                            thrust::raw_pointer_cast(indptr_device.data()),
+                            thrust::raw_pointer_cast(V_merged_1_device.data()),
+                            thrust::raw_pointer_cast(S_merged_1_device.data()), seq_len, nullptr,
+                            num_heads, head_dim);
+
+  thrust::host_vector<T> V_merged_0_host(V_merged_0_device), V_merged_1_host(V_merged_1_device);
+  thrust::host_vector<float> S_merged_0_host(S_merged_0_device), S_merged_1_host(S_merged_1_device);
+
+  // Compare results
+  size_t num_V_result_errors_atol_1e_3_rtol_1e_3 = 0, num_S_result_errors_atol_1e_3_rtol_1e_3 = 0;
+  for (size_t i = 0; i < seq_len * num_heads * head_dim; ++i) {
+    EXPECT_FALSE(std::isnan(float(V_merged_0_host[i]))) << "V_merged_0_host[" << i << "] is nan";
+    EXPECT_FALSE(std::isnan(float(V_merged_1_host[i]))) << "V_merged_1_host[" << i << "] is nan";
+    num_V_result_errors_atol_1e_3_rtol_1e_3 +=
+        (!utils::isclose(float(V_merged_0_host[i]), float(V_merged_1_host[i]), 1e-3, 1e-3));
+  }
+  for (size_t i = 0; i < seq_len * num_heads; ++i) {
+    EXPECT_FALSE(std::isnan(float(S_merged_0_host[i]))) << "S_merged_0_host[" << i << "] is nan";
+    EXPECT_FALSE(std::isnan(float(S_merged_1_host[i]))) << "S_merged_1_host[" << i << "] is nan";
+    num_S_result_errors_atol_1e_3_rtol_1e_3 +=
+        (!utils::isclose(float(S_merged_0_host[i]), float(S_merged_1_host[i]), 1e-3, 1e-3));
+  }
+  float V_result_accuracy =
+      1.0 - float(num_V_result_errors_atol_1e_3_rtol_1e_3) / (seq_len * num_heads * head_dim);
+  float S_result_accuracy =
+      1.0 - float(num_S_result_errors_atol_1e_3_rtol_1e_3) / (seq_len * num_heads);
+  std::cout << "seq_len=" << seq_len << ", num_heads=" << num_heads << ", head_dim=" << head_dim
+            << ", sparse_s=" << sparse_s
+            << ", V accuracy (atol=1e-3, rtol=1e-3)=" << V_result_accuracy
+            << ", S accuracy (atol=1e-3, rtol=1e-3)=" << S_result_accuracy << std::endl;
+
+  EXPECT_GT(V_result_accuracy, 0.99) << "V result correctness test failed.";
+  EXPECT_GT(S_result_accuracy, 0.99) << "S result correctness test failed.";
+}
+
+template <typename T>
+void _TestVariableLengthMergeKernelPaddedCorrectness(size_t max_seq_len, size_t seq_len) {
+  ASSERT_LE(seq_len, max_seq_len);
+
+  const size_t num_heads = 4;
+  const size_t head_dim = 64;
+  const uint32_t max_num_index_sets = 512;
+
+  std::vector<int32_t> lengths(max_seq_len);
+  utils::vec_randint_(lengths, 1, max_num_index_sets);
+  std::vector<int32_t> indptr(max_seq_len + 1, 0);
+  for (size_t i = 0; i < seq_len; ++i) {
+    indptr[i + 1] = indptr[i] + lengths[i];
+  }
+
+  uint32_t last_indptr = indptr[seq_len];
+  std::vector<T> V_ragged_host(last_indptr * num_heads * head_dim);
+  std::vector<float> S_ragged_host(last_indptr * num_heads);
+
+  utils::vec_normal_(V_ragged_host);
+  utils::vec_uniform_(S_ragged_host, -10, 10);
+
+  thrust::device_vector<T> V_ragged_device(V_ragged_host);
+  thrust::device_vector<float> S_ragged_device(S_ragged_host);
+  thrust::device_vector<int32_t> indptr_device(indptr);
+  thrust::device_vector<T> V_merged_0_device(max_seq_len * num_heads * head_dim);
+  thrust::device_vector<T> V_merged_1_device(max_seq_len * num_heads * head_dim);
+  thrust::device_vector<float> S_merged_0_device(max_seq_len * num_heads);
+  thrust::device_vector<float> S_merged_1_device(max_seq_len * num_heads);
+  thrust::device_vector<uint32_t> seq_len_device(
+      std::vector<uint32_t>{static_cast<uint32_t>(seq_len)});
+
+  // Reference: use VariableLengthMergeStates on the precisely-sized input.
+  VariableLengthMergeStates(thrust::raw_pointer_cast(V_ragged_device.data()),
+                            thrust::raw_pointer_cast(S_ragged_device.data()),
+                            thrust::raw_pointer_cast(indptr_device.data()),
+                            thrust::raw_pointer_cast(V_merged_0_device.data()),
+                            thrust::raw_pointer_cast(S_merged_0_device.data()), seq_len, nullptr,
+                            num_heads, head_dim);
+  // Expected: use VariableLengthMergeStates on a padded input
+  VariableLengthMergeStates(thrust::raw_pointer_cast(V_ragged_device.data()),
+                            thrust::raw_pointer_cast(S_ragged_device.data()),
+                            thrust::raw_pointer_cast(indptr_device.data()),
+                            thrust::raw_pointer_cast(V_merged_1_device.data()),
+                            thrust::raw_pointer_cast(S_merged_1_device.data()), max_seq_len,
+                            thrust::raw_pointer_cast(seq_len_device.data()), num_heads, head_dim);
+
+  thrust::host_vector<T> V_merged_0_host(V_merged_0_device), V_merged_1_host(V_merged_1_device);
+  thrust::host_vector<float> S_merged_0_host(S_merged_0_device), S_merged_1_host(S_merged_1_device);
+
+  // Compare results
+  size_t num_V_result_errors_atol_1e_3_rtol_1e_3 = 0, num_S_result_errors_atol_1e_3_rtol_1e_3 = 0;
+  for (size_t i = 0; i < seq_len * num_heads * head_dim; ++i) {
+    EXPECT_FALSE(std::isnan(float(V_merged_1_host[i]))) << "V_merged_1_host[" << i << "] is nan";
+    num_V_result_errors_atol_1e_3_rtol_1e_3 +=
+        (!utils::isclose(float(V_merged_0_host[i]), float(V_merged_1_host[i]), 1e-3, 1e-3));
+  }
+  for (size_t i = 0; i < seq_len * num_heads; ++i) {
+    EXPECT_FALSE(std::isnan(float(S_merged_0_host[i]))) << "S_merged_0_host[" << i << "] is nan";
+    EXPECT_FALSE(std::isnan(float(S_merged_1_host[i]))) << "S_merged_1_host[" << i << "] is nan";
+    num_S_result_errors_atol_1e_3_rtol_1e_3 +=
+        (!utils::isclose(float(S_merged_0_host[i]), float(S_merged_1_host[i]), 1e-3, 1e-3));
+  }
+  float V_result_accuracy =
+      1.0 - float(num_V_result_errors_atol_1e_3_rtol_1e_3) / (seq_len * num_heads * head_dim);
+  float S_result_accuracy =
+      1.0 - float(num_S_result_errors_atol_1e_3_rtol_1e_3) / (seq_len * num_heads);
+  std::cout << "seq_len=" << seq_len << ", num_heads=" << num_heads << ", head_dim=" << head_dim
+            << ", V accuracy (atol=1e-3, rtol=1e-3)=" << V_result_accuracy
+            << ", S accuracy (atol=1e-3, rtol=1e-3)=" << S_result_accuracy << std::endl;
+
+  EXPECT_GT(V_result_accuracy, 0.99) << "V result correctness test failed.";
+  EXPECT_GT(S_result_accuracy, 0.99) << "S result correctness test failed.";
+}
+
+template <typename T>
+void _TestMergeKernelCorrectness(size_t num_index_sets, size_t seq_len, size_t num_heads,
+                                 size_t head_dim, bool sparse_s) {
+  std::vector<T> V_host(seq_len * num_index_sets * num_heads * head_dim);
+  std::vector<float> V_host_trans_f32(num_index_sets * seq_len * num_heads * head_dim);
+  std::vector<float> S_host(seq_len * num_index_sets * num_heads);
+  std::vector<float> S_host_trans(num_index_sets * seq_len * num_heads);
+
+  utils::vec_normal_(V_host);
+  if (sparse_s) {
+    for (uint32_t i = 0; i < num_index_sets; ++i) {
+      float fill_val = is_prime(i) ? 10 : -10;
+      for (uint32_t j = 0; j < seq_len; ++j) {
+        for (uint32_t k = 0; k < num_heads; ++k) {
+          S_host[(j * num_index_sets + i) * num_heads + k] = fill_val;
+        }
+      }
+    }
+  } else {
+    utils::vec_uniform_(S_host, -10, 10);
+  }
+
+  for (uint32_t i = 0; i < num_index_sets; ++i) {
+    for (uint32_t j = 0; j < seq_len; ++j) {
+      std::transform(V_host.begin() + (j * num_index_sets + i) * num_heads * head_dim,
+                     V_host.begin() + (j * num_index_sets + i + 1) * num_heads * head_dim,
+                     V_host_trans_f32.begin() + (i * seq_len + j) * num_heads * head_dim,
+                     [](T x) { return static_cast<float>(x); });
+      std::copy(S_host.begin() + (j * num_index_sets + i) * num_heads,
+                S_host.begin() + (j * num_index_sets + i + 1) * num_heads,
+                S_host_trans.begin() + (i * seq_len + j) * num_heads);
+    }
+  }
+
+  thrust::device_vector<T> V_device(V_host);
+  thrust::device_vector<float> V_device_trans_f32(V_host_trans_f32);
+  thrust::device_vector<float> S_device(S_host);
+  thrust::device_vector<float> S_device_trans(S_host_trans);
+
+  thrust::device_vector<float> V_merged_0_device(seq_len * num_heads * head_dim);
+  thrust::device_vector<float> S_merged_0_device(seq_len * num_heads);
+  thrust::device_vector<T> V_merged_1_device(seq_len * num_heads * head_dim);
+  thrust::device_vector<float> S_merged_1_device(seq_len * num_heads);
+
+  if (num_index_sets > 1) {
+    // Method 0: use MergeState
+    MergeState(thrust::raw_pointer_cast(V_device_trans_f32.data()),
+               thrust::raw_pointer_cast(S_device_trans.data()),
+               thrust::raw_pointer_cast(V_device_trans_f32.data() + seq_len * num_heads * head_dim),
+               thrust::raw_pointer_cast(S_device_trans.data() + seq_len * num_heads),
+               thrust::raw_pointer_cast(V_merged_0_device.data()),
+               thrust::raw_pointer_cast(S_merged_0_device.data()), seq_len, num_heads, head_dim);
+    for (uint i = 2; i < num_index_sets; ++i) {
+      MergeStateInPlace(
+          thrust::raw_pointer_cast(V_merged_0_device.data()),
+          thrust::raw_pointer_cast(S_merged_0_device.data()),
+          thrust::raw_pointer_cast(V_device_trans_f32.data() + i * seq_len * num_heads * head_dim),
+          thrust::raw_pointer_cast(S_device_trans.data() + i * seq_len * num_heads), seq_len,
+          num_heads, head_dim);
+    }
+  } else {
+    V_merged_0_device = V_device;
+    S_merged_0_device = S_device;
+  }
+
+  // Method 1: use MergeStates
+  MergeStates(thrust::raw_pointer_cast(V_device.data()), thrust::raw_pointer_cast(S_device.data()),
+              thrust::raw_pointer_cast(V_merged_1_device.data()),
+              thrust::raw_pointer_cast(S_merged_1_device.data()), num_index_sets, seq_len,
+              num_heads, head_dim);
+
+  thrust::host_vector<float> V_merged_0_host(V_merged_0_device);
+  thrust::host_vector<T> V_merged_1_host(V_merged_1_device);
+  thrust::host_vector<float> S_merged_0_host(S_merged_0_device), S_merged_1_host(S_merged_1_device);
+  size_t num_V_result_errors_atol_1e_3_rtol_1e_3 = 0, num_S_result_errors_atol_1e_3_rtol_1e_3 = 0;
+  for (size_t i = 0; i < seq_len * num_heads * head_dim; ++i) {
+    EXPECT_FALSE(std::isnan(float(V_merged_0_host[i]))) << "V_merged_0_host[" << i << "] is nan";
+    EXPECT_FALSE(std::isnan(float(V_merged_1_host[i]))) << "V_merged_1_host[" << i << "] is nan";
+    num_V_result_errors_atol_1e_3_rtol_1e_3 +=
+        (!utils::isclose(float(V_merged_0_host[i]), float(V_merged_1_host[i]), 1e-3, 1e-3));
+  }
+  for (size_t i = 0; i < seq_len * num_heads; ++i) {
+    EXPECT_FALSE(std::isnan(float(S_merged_0_host[i]))) << "S_merged_0_host[" << i << "] is nan";
+    EXPECT_FALSE(std::isnan(float(S_merged_1_host[i]))) << "S_merged_1_host[" << i << "] is nan";
+    num_S_result_errors_atol_1e_3_rtol_1e_3 +=
+        (!utils::isclose(float(S_merged_0_host[i]), float(S_merged_1_host[i]), 1e-3, 1e-3));
+  }
+  float V_result_accuracy =
+      1.0 - float(num_V_result_errors_atol_1e_3_rtol_1e_3) / (seq_len * num_heads * head_dim);
+  float S_result_accuracy =
+      1.0 - float(num_S_result_errors_atol_1e_3_rtol_1e_3) / (seq_len * num_heads);
+  std::cout << "num_index_sets=" << num_index_sets << ", seq_len=" << seq_len
+            << ", num_heads=" << num_heads << ", head_dim=" << head_dim << ", sparse_s=" << sparse_s
+            << ", V accuracy (atol=1e-3, rtol=1e-3)=" << V_result_accuracy
+            << ", S accuracy (atol=1e-3, rtol=1e-3)=" << S_result_accuracy << std::endl;
+  EXPECT_GT(V_result_accuracy, 0.99) << "V result correctness test failed.";
+  EXPECT_GT(S_result_accuracy, 0.99) << "S result correctness test failed.";
+}
+
+template <typename T>
+void _TestTwoLevelSinglePrefixCascadeDecodeCorrectness(size_t batch_size,
+                                                       size_t shared_prefix_length,
+                                                       size_t unique_kv_length, size_t num_qo_heads,
+                                                       size_t num_kv_heads, size_t head_dim) {
+  constexpr uint32_t page_size = 16;
+  auto [testcase_float_data, testcase_int_data] = utils::create_shared_prefix_testcase_data<T>(
+      batch_size, shared_prefix_length, unique_kv_length,
+      /*qo_append_length=*/1, num_qo_heads, num_kv_heads, head_dim, page_size);
+
+  std::vector<T> q_h = std::move(testcase_float_data[0]),
+                 shared_k_h = std::move(testcase_float_data[1]),
+                 shared_v_h = std::move(testcase_float_data[2]),
+                 k_data_h = std::move(testcase_float_data[3]),
+                 v_data_h = std::move(testcase_float_data[3]);
+
+  std::vector<int32_t> kv_indices_combined_h = std::move(testcase_int_data[1]),
+                       kv_indices_unique_h = std::move(testcase_int_data[2]),
+                       kv_indptr_combined_h = std::move(testcase_int_data[3]),
+                       kv_indptr_unique_h = std::move(testcase_int_data[4]),
+                       kv_last_page_len_combined_h = std::move(testcase_int_data[5]),
+                       kv_last_page_len_unique_h = std::move(testcase_int_data[6]);
+
+  thrust::device_vector<T> shared_k_d(shared_k_h), shared_v_d(shared_v_h), k_data_d(k_data_h),
+      v_data_d(v_data_h), q_d(q_h), o_baseline_d(q_h.size()), o_cascade_0_d(q_h.size()),
+      o_cascade_1_d(q_h.size());
+  thrust::device_vector<T> tmp_0_d(16 * 1024 * 1024);
+  thrust::device_vector<float> lse_cascade_0_d(batch_size * num_qo_heads),
+      lse_cascade_1_d(batch_size * num_qo_heads);
+
+  thrust::device_vector<int32_t> kv_indptr_combined_d(kv_indptr_combined_h),
+      kv_indptr_unique_d(kv_indptr_unique_h), kv_indices_combined_d(kv_indices_combined_h),
+      kv_indices_unique_d(kv_indices_unique_h),
+      kv_last_page_len_combined_d(kv_last_page_len_combined_h),
+      kv_last_page_len_unique_d(kv_last_page_len_unique_h);
+
+  paged_kv_t<T, int32_t> paged_kv_baseline_d(
+      num_kv_heads, page_size, head_dim, batch_size, kv_layout,
+      thrust::raw_pointer_cast(k_data_d.data()), thrust::raw_pointer_cast(v_data_d.data()),
+      thrust::raw_pointer_cast(kv_indices_combined_d.data()),
+      thrust::raw_pointer_cast(kv_indptr_combined_d.data()),
+      thrust::raw_pointer_cast(kv_last_page_len_combined_d.data()));
+
+  paged_kv_t<T, int32_t> paged_kv_casacde_d(
+      num_kv_heads, page_size, head_dim, batch_size, kv_layout,
+      thrust::raw_pointer_cast(k_data_d.data()), thrust::raw_pointer_cast(v_data_d.data()),
+      thrust::raw_pointer_cast(kv_indices_unique_d.data()),
+      thrust::raw_pointer_cast(kv_indptr_unique_d.data()),
+      thrust::raw_pointer_cast(kv_last_page_len_unique_d.data()));
+
+  BatchDecodeHandler baseline_handler, cascade_handler;
+
+  size_t float_workspace_size_in_bytes = 32 * 1024 * 1024;
+  thrust::device_vector<char> float_buffer(float_workspace_size_in_bytes);
+  size_t int_workspace_size_in_bytes = 8 * 1024 * 1024;
+  thrust::device_vector<char> int_buffer(int_workspace_size_in_bytes);
+
+  BatchDecodeHandlerPlan<T, T, T, int32_t>(
+      &baseline_handler, (void*)thrust::raw_pointer_cast(float_buffer.data()),
+      float_workspace_size_in_bytes, (void*)thrust::raw_pointer_cast(int_buffer.data()),
+      int_workspace_size_in_bytes, kv_indptr_combined_h.data(), kv_last_page_len_combined_h.data(),
+      batch_size, num_qo_heads, num_kv_heads, head_dim, page_size, PosEncodingMode::kNone);
+
+  BatchDecodeHandlerPlan<T, T, T, int32_t>(
+      &cascade_handler, (void*)thrust::raw_pointer_cast(float_buffer.data()),
+      float_workspace_size_in_bytes, (void*)thrust::raw_pointer_cast(int_buffer.data()),
+      int_workspace_size_in_bytes, kv_indptr_unique_h.data(), kv_last_page_len_unique_h.data(),
+      batch_size, num_qo_heads, num_kv_heads, head_dim, page_size, PosEncodingMode::kNone);
+
+  // Compute result using baseline implementation
+  cudaError_t status = BatchDecodeWithPagedKVCacheWrapper<T, T, T, int32_t>(
+      &baseline_handler, thrust::raw_pointer_cast(q_d.data()),
+      /*q_rope_offset=*/nullptr, paged_kv_baseline_d, thrust::raw_pointer_cast(o_baseline_d.data()),
+      /*lse=*/nullptr, num_qo_heads, PosEncodingMode::kNone);
+
+  EXPECT_EQ(status, cudaSuccess) << "Baseline implementation failed with error: "
+                                 << cudaGetErrorString(status);
+
+  // Compute result using cascade implementation
+  status = SinglePrefillWithKVCache(
+      thrust::raw_pointer_cast(q_d.data()), thrust::raw_pointer_cast(shared_k_d.data()),
+      thrust::raw_pointer_cast(shared_v_d.data()), thrust::raw_pointer_cast(o_cascade_0_d.data()),
+      thrust::raw_pointer_cast(tmp_0_d.data()), thrust::raw_pointer_cast(lse_cascade_0_d.data()),
+      num_qo_heads, num_kv_heads, /*qo_len=*/batch_size, /*kv_len=*/shared_prefix_length, head_dim,
+      /*causal=*/false, /*kv_layout=*/QKVLayout::kNHD,
+      /*pos_encoding_mode=*/PosEncodingMode::kNone, /*use_fp16_qk_reduction=*/false);
+
+  EXPECT_EQ(status, cudaSuccess) << "Cascade implementation prefill failed with error: "
+                                 << cudaGetErrorString(status);
+
+  status = BatchDecodeWithPagedKVCacheWrapper<T, T, T, int32_t>(
+      &cascade_handler, thrust::raw_pointer_cast(q_d.data()),
+      /*q_rope_offset=*/nullptr, paged_kv_casacde_d, thrust::raw_pointer_cast(o_cascade_1_d.data()),
+      /*lse=*/thrust::raw_pointer_cast(lse_cascade_1_d.data()), num_qo_heads,
+      PosEncodingMode::kNone);
+
+  EXPECT_EQ(status, cudaSuccess) << "Cascade implementation decode failed with error: "
+                                 << cudaGetErrorString(status);
+
+  status = MergeStateInPlace(thrust::raw_pointer_cast(o_cascade_0_d.data()),
+                             thrust::raw_pointer_cast(lse_cascade_0_d.data()),
+                             thrust::raw_pointer_cast(o_cascade_1_d.data()),
+                             thrust::raw_pointer_cast(lse_cascade_1_d.data()), batch_size,
+                             num_qo_heads, head_dim);
+
+  EXPECT_EQ(status, cudaSuccess) << "Cascade implementation merge failed with error: "
+                                 << cudaGetErrorString(status);
+
+  thrust::host_vector<T> o_baseline_h(o_baseline_d), o_cascade_h(o_cascade_0_d);
+  size_t num_result_errors_atol_1e_3_rtol_1e_3 = 0;
+  for (size_t i = 0; i < o_baseline_h.size(); ++i) {
+    EXPECT_FALSE(std::isnan(float(o_baseline_h[i]))) << "o_baseline_h[" << i << "] is nan";
+    EXPECT_FALSE(std::isnan(float(o_cascade_h[i]))) << "o_cascade_h[" << i << "] is nan";
+    num_result_errors_atol_1e_3_rtol_1e_3 +=
+        (!utils::isclose(float(o_baseline_h[i]), float(o_cascade_h[i]), 1e-3, 1e-3));
+  }
+  float result_accuracy =
+      1. - float(num_result_errors_atol_1e_3_rtol_1e_3) / float(o_baseline_h.size());
+  std::cout << "batch_size=" << batch_size << ", shared_prefix_length=" << shared_prefix_length
+            << ", unique_kv_length=" << unique_kv_length << ", num_qo_heads=" << num_qo_heads
+            << ", num_kv_heads=" << num_kv_heads << ", head_dim=" << head_dim
+            << ", result_accuracy (atol=1e-3, rtol=1e-3)=" << result_accuracy << std::endl;
+  EXPECT_GT(result_accuracy, 0.90) << "Result correctness test failed.";
+}
+
+template <typename T>
+void _TestTwoLevelSinglePrefixCascadeAppendCorrectness(size_t batch_size,
+                                                       size_t shared_prefix_length,
+                                                       size_t unique_kv_length,
+                                                       size_t qo_append_length, size_t num_qo_heads,
+                                                       size_t num_kv_heads, size_t head_dim) {
+  constexpr uint32_t page_size = 16;
+
+  auto [testcase_float_data, testcase_int_data] = utils::create_shared_prefix_testcase_data<T>(
+      batch_size, shared_prefix_length, unique_kv_length, qo_append_length, num_qo_heads,
+      num_kv_heads, head_dim, page_size);
+
+  std::vector<T> q_h = std::move(testcase_float_data[0]),
+                 shared_k_h = std::move(testcase_float_data[1]),
+                 shared_v_h = std::move(testcase_float_data[2]),
+                 k_data_h = std::move(testcase_float_data[3]),
+                 v_data_h = std::move(testcase_float_data[4]);
+
+  std::vector<int32_t> qo_indptr_h = std::move(testcase_int_data[0]),
+                       kv_indices_combined_h = std::move(testcase_int_data[1]),
+                       kv_indices_unique_h = std::move(testcase_int_data[2]),
+                       kv_indptr_combined_h = std::move(testcase_int_data[3]),
+                       kv_indptr_unique_h = std::move(testcase_int_data[4]),
+                       kv_last_page_len_combined_h = std::move(testcase_int_data[5]),
+                       kv_last_page_len_unique_h = std::move(testcase_int_data[6]);
+
+  thrust::device_vector<T> shared_k_d(shared_k_h), shared_v_d(shared_v_h), k_data_d(k_data_h),
+      v_data_d(v_data_h), q_d(q_h), o_baseline_d(q_h.size()), o_cascade_0_d(q_h.size()),
+      o_cascade_1_d(q_h.size());
+  thrust::device_vector<T> tmp_0_d(16 * 1024 * 1024);
+  thrust::device_vector<float> lse_cascade_0_d((batch_size * qo_append_length) * num_qo_heads),
+      lse_cascade_1_d((batch_size * qo_append_length) * num_qo_heads);
+
+  thrust::device_vector<int32_t> qo_indptr_d(qo_indptr_h),
+      kv_indptr_combined_d(kv_indptr_combined_h), kv_indptr_unique_d(kv_indptr_unique_h),
+      kv_indices_combined_d(kv_indices_combined_h), kv_indices_unique_d(kv_indices_unique_h),
+      kv_last_page_len_combined_d(kv_last_page_len_combined_h),
+      kv_last_page_len_unique_d(kv_last_page_len_unique_h);
+
+  paged_kv_t<T, int32_t> paged_kv_baseline_d(
+      num_kv_heads, page_size, head_dim, batch_size, kv_layout,
+      thrust::raw_pointer_cast(k_data_d.data()), thrust::raw_pointer_cast(v_data_d.data()),
+      thrust::raw_pointer_cast(kv_indices_combined_d.data()),
+      thrust::raw_pointer_cast(kv_indptr_combined_d.data()),
+      thrust::raw_pointer_cast(kv_last_page_len_combined_d.data()));
+
+  paged_kv_t<T, int32_t> paged_kv_casacde_d(
+      num_kv_heads, page_size, head_dim, batch_size, kv_layout,
+      thrust::raw_pointer_cast(k_data_d.data()), thrust::raw_pointer_cast(v_data_d.data()),
+      thrust::raw_pointer_cast(kv_indices_unique_d.data()),
+      thrust::raw_pointer_cast(kv_indptr_unique_d.data()),
+      thrust::raw_pointer_cast(kv_last_page_len_unique_d.data()));
+
+  BatchPrefillHandler baseline_handler, cascade_handler;
+  size_t float_workspace_size_in_bytes = 32 * 1024 * 1024;
+  thrust::device_vector<char> float_buffer(float_workspace_size_in_bytes);
+  size_t int_workspace_size_in_bytes = 8 * 1024 * 1024;
+  thrust::device_vector<char> int_buffer(int_workspace_size_in_bytes);
+
+  baseline_handler.Plan<T, int32_t>(
+      (void*)thrust::raw_pointer_cast(float_buffer.data()), float_workspace_size_in_bytes,
+      (void*)thrust::raw_pointer_cast(int_buffer.data()), int_workspace_size_in_bytes,
+      qo_indptr_h.data(), kv_indptr_combined_h.data(), /*total_num_rows=*/qo_indptr_h.back(),
+      batch_size, num_qo_heads, num_kv_heads, head_dim, page_size);
+  cascade_handler.Plan<T, int32_t>(
+      (void*)thrust::raw_pointer_cast(float_buffer.data()), float_workspace_size_in_bytes,
+      (void*)thrust::raw_pointer_cast(int_buffer.data()), int_workspace_size_in_bytes,
+      qo_indptr_h.data(), kv_indptr_unique_h.data(), /*total_num_rows=*/qo_indptr_h.back(),
+      batch_size, num_qo_heads, num_kv_heads, head_dim, page_size);
+
+  cudaError_t status = BatchPrefillWithPagedKVCacheWrapper<T, T, T, int32_t>(
+      &baseline_handler, thrust::raw_pointer_cast(q_d.data()),
+      thrust::raw_pointer_cast(qo_indptr_d.data()),
+      /*q_rope_offset=*/nullptr, paged_kv_baseline_d, thrust::raw_pointer_cast(o_baseline_d.data()),
+      /*lse=*/nullptr, num_qo_heads, /*causal=*/true, PosEncodingMode::kNone,
+      /*use_fp16_qk_reduction=*/false);
+
+  EXPECT_EQ(status, cudaSuccess) << "Baseline implementation failed with error: "
+                                 << cudaGetErrorString(status);
+
+  status = SinglePrefillWithKVCache(
+      thrust::raw_pointer_cast(q_d.data()), thrust::raw_pointer_cast(shared_k_d.data()),
+      thrust::raw_pointer_cast(shared_v_d.data()), thrust::raw_pointer_cast(o_cascade_0_d.data()),
+      thrust::raw_pointer_cast(tmp_0_d.data()), thrust::raw_pointer_cast(lse_cascade_0_d.data()),
+      num_qo_heads, num_kv_heads, /*qo_len=*/batch_size * qo_append_length,
+      /*kv_len=*/shared_prefix_length, head_dim,
+      /*causal=*/false, /*kv_layout=*/QKVLayout::kNHD,
+      /*pos_encoding_mode=*/PosEncodingMode::kNone, /*use_fp16_qk_reduction=*/false);
+
+  EXPECT_EQ(status, cudaSuccess)
+      << "Cascade implementation shared prefix prefill failed with error: "
+      << cudaGetErrorString(status);
+
+  status = BatchPrefillWithPagedKVCacheWrapper<T, T, T, int32_t>(
+      &cascade_handler, thrust::raw_pointer_cast(q_d.data()),
+      thrust::raw_pointer_cast(qo_indptr_d.data()),
+      /*r_rope_position=*/nullptr, paged_kv_casacde_d,
+      thrust::raw_pointer_cast(o_cascade_1_d.data()),
+      thrust::raw_pointer_cast(lse_cascade_1_d.data()), num_qo_heads, /*causal=*/true,
+      PosEncodingMode::kNone, /*use_fp16_qk_reduction=*/false);
+
+  EXPECT_EQ(status, cudaSuccess) << "Cascade implementation unique kv prefill failed with error: "
+                                 << cudaGetErrorString(status);
+
+  status = MergeStateInPlace(thrust::raw_pointer_cast(o_cascade_0_d.data()),
+                             thrust::raw_pointer_cast(lse_cascade_0_d.data()),
+                             thrust::raw_pointer_cast(o_cascade_1_d.data()),
+                             thrust::raw_pointer_cast(lse_cascade_1_d.data()),
+                             batch_size * qo_append_length, num_qo_heads, head_dim);
+  EXPECT_EQ(status, cudaSuccess) << "Cascade implementation merge failed with error: "
+                                 << cudaGetErrorString(status);
+
+  thrust::host_vector<T> o_baseline_h(o_baseline_d), o_cascade_h(o_cascade_0_d);
+  size_t num_result_errors_atol_1e_3_rtol_1e_3 = 0;
+  for (size_t i = 0; i < o_baseline_h.size(); ++i) {
+    EXPECT_FALSE(std::isnan(float(o_baseline_h[i]))) << "o_baseline_h[" << i << "] is nan";
+    EXPECT_FALSE(std::isnan(float(o_cascade_h[i]))) << "o_cascade_h[" << i << "] is nan";
+    num_result_errors_atol_1e_3_rtol_1e_3 +=
+        (!utils::isclose(float(o_baseline_h[i]), float(o_cascade_h[i]), 1e-3, 1e-3));
+  }
+  float result_accuracy =
+      1. - float(num_result_errors_atol_1e_3_rtol_1e_3) / float(o_baseline_h.size());
+  std::cout << "batch_size=" << batch_size << ", shared_prefix_length=" << shared_prefix_length
+            << ", unique_kv_length=" << unique_kv_length
+            << ", qo_append_length=" << qo_append_length << ", num_qo_heads=" << num_qo_heads
+            << ", num_kv_heads=" << num_kv_heads << ", head_dim=" << head_dim
+            << ", result_accuracy (atol=1e-3, rtol=1e-3)=" << result_accuracy << std::endl;
+  EXPECT_GT(result_accuracy, 0.90) << "Result correctness test failed.";
+}
+
+template <typename T>
+void TestMergeKernelCorrectness() {
+  for (size_t num_index_sets : {1, 2, 9, 81, 513}) {
+    for (size_t seq_len : {4, 16, 77}) {
+      for (size_t num_heads : {1, 21, 32}) {
+        for (size_t head_dim : {64, 128, 256}) {
+          for (bool sparse_s : {false, true}) {
+            _TestMergeKernelCorrectness<T>(num_index_sets, seq_len, num_heads, head_dim, sparse_s);
+          }
+        }
+      }
+    }
+  }
+}
+
+template <typename T>
+void TestVariableLengthMergeKernelCorrectness() {
+  for (size_t seq_len : {1, 3, 77, 191}) {
+    for (size_t num_heads : {1, 4, 32}) {
+      for (size_t head_dim : {64, 128, 256}) {
+        for (bool sparse_s : {false, true}) {
+          _TestVariableLengthMergeKernelCorrectness<T>(seq_len, num_heads, head_dim, sparse_s);
+        }
+      }
+    }
+  }
+}
+
+template <typename T>
+void TestVariableLengthMergeKernelPaddedCorrectness() {
+  _TestVariableLengthMergeKernelPaddedCorrectness<T>(8, 1);
+  _TestVariableLengthMergeKernelPaddedCorrectness<T>(128, 77);
+}
+
+template <typename T>
+void TestTwoLevelSinglePrefixCascadeDecodeCorrectness() {
+  for (size_t batch_size : {1, 8, 16, 64, 128}) {
+    for (size_t shared_prefix_length : {1024, 2048, 8192, 32768}) {
+      for (size_t unique_kv_length : {128, 256, 512, 1024}) {
+        for (size_t num_qo_heads : {32}) {
+          for (size_t num_kv_heads : {32}) {
+            for (size_t head_dim : {128}) {
+              _TestTwoLevelSinglePrefixCascadeDecodeCorrectness<T>(batch_size, shared_prefix_length,
+                                                                   unique_kv_length, num_qo_heads,
+                                                                   num_kv_heads, head_dim);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+template <typename T>
+void TestTwoLevelSinglePrefixCascadeAppendCorrectness() {
+  for (size_t batch_size : {1, 8, 16, 64, 128}) {
+    for (size_t shared_prefix_length : {1024, 2048, 8192, 32768}) {
+      for (size_t unique_kv_length : {128, 256, 512, 1024}) {
+        for (size_t qo_append_length : {128}) {
+          for (size_t num_qo_heads : {32}) {
+            for (size_t num_kv_heads : {32}) {
+              for (size_t head_dim : {128}) {
+                _TestTwoLevelSinglePrefixCascadeAppendCorrectness<T>(
+                    batch_size, shared_prefix_length, unique_kv_length, qo_append_length,
+                    num_qo_heads, num_kv_heads, head_dim);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+TEST(FlashInferCorrectnessTest, MergeKernelCorrectnessTestFP16) {
+  TestMergeKernelCorrectness<half>();
+}
+
+TEST(FlashInferCorrectnessTest, VariableLengthMergeKernelCorrectnessTestFP16) {
+  TestVariableLengthMergeKernelCorrectness<half>();
+}
+
+TEST(FlashInferCorrectnessTest, VariableLengthMergeKernelPaddedCorrectnessTestFP16) {
+  TestVariableLengthMergeKernelPaddedCorrectness<half>();
+}
+
+TEST(FlashInferCorrectnessTest, TwoLevelSinglePrefixCascadeDecodeTestFP16) {
+  TestTwoLevelSinglePrefixCascadeDecodeCorrectness<half>();
+}
+
+TEST(FlashInferCorrectnessTest, TwoLevelSinglePrefixCascadeAppendTestFP16) {
+  TestTwoLevelSinglePrefixCascadeAppendCorrectness<half>();
+}

sglang_repo/sgl-kernel/3rdparty/flashinfer/src/test_fastdiv.cu

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2023 by FlashInfer team.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <gtest/gtest.h>
+
+#include <flashinfer/fastdiv.cuh>
+
+#include "gtest/gtest.h"
+#include "utils.h"
+
+using namespace flashinfer;
+
+__global__ void test_fastdiv_kernel_0(uint_fastdiv fd, uint32_t* q, uint32_t* r) {
+  uint32_t global_rank = blockIdx.x * blockDim.x + threadIdx.x;
+  q[global_rank] = global_rank / fd;
+  r[global_rank] = global_rank % fd;
+}
+
+__global__ void test_fastdiv_kernel_1(uint_fastdiv fd, uint32_t* q, uint32_t* r) {
+  uint32_t global_rank = blockIdx.x * blockDim.x + threadIdx.x;
+  fd.divmod(global_rank, q[global_rank], r[global_rank]);
+}
+
+void _TestFastDivU32Correctness(uint32_t d) {
+  uint_fastdiv fd(d);
+  thrust::device_vector<uint32_t> q(1024 * 1024), r(1024 * 1024);
+
+  {
+    test_fastdiv_kernel_0<<<1024, 1024>>>(fd, thrust::raw_pointer_cast(q.data()),
+                                          thrust::raw_pointer_cast(r.data()));
+
+    thrust::host_vector<uint32_t> q_h(q), r_h(r);
+
+    for (size_t i = 0; i < q_h.size(); ++i) {
+      EXPECT_EQ(q_h[i], i / d);
+      EXPECT_EQ(r_h[i], i % d);
+    }
+  }
+
+  {
+    test_fastdiv_kernel_1<<<1024, 1024>>>(fd, thrust::raw_pointer_cast(q.data()),
+                                          thrust::raw_pointer_cast(r.data()));
+
+    thrust::host_vector<uint32_t> q_h(q), r_h(r);
+
+    for (size_t i = 0; i < q_h.size(); ++i) {
+      EXPECT_EQ(q_h[i], i / d);
+      EXPECT_EQ(r_h[i], i % d);
+    }
+  }
+
+  std::cout << "FastDivU32 correctness test passed for d = " << d << std::endl;
+}
+
+void TestFastDivU32Correctness() {
+  for (uint32_t d = 1; d < 127; ++d) {
+    _TestFastDivU32Correctness(d);
+  }
+}
+
+TEST(FlashInferCorrectnessTest, TestFastDivU32Correctness) { TestFastDivU32Correctness(); }

sglang_repo/sgl-kernel/3rdparty/flashinfer/src/test_norm.cu

@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2024 by FlashInfer team.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <gtest/gtest.h>
+
+#include <flashinfer/norm.cuh>
+
+#include "cpu_reference.h"
+#include "utils.h"
+
+using namespace flashinfer;
+
+template <typename T>
+void _TestRMSNormCorrectness(uint32_t batch_size, uint32_t d) {
+  std::vector<T> x_host(batch_size * d);
+  std::vector<T> w_host(d);
+
+  utils::vec_normal_(x_host);
+  utils::vec_normal_(w_host);
+
+  std::vector<T> y_ref_host =
+      std::move(cpu_reference::rms_norm<T>(x_host.data(), w_host.data(), batch_size, d, 1e-5));
+
+  thrust::device_vector<T> x_device(x_host);
+  thrust::device_vector<T> w_device(w_host);
+  thrust::device_vector<T> y_device(batch_size * d);
+
+  cudaError_t status = norm::RMSNorm<T>(
+      thrust::raw_pointer_cast(x_device.data()), thrust::raw_pointer_cast(w_device.data()),
+      thrust::raw_pointer_cast(y_device.data()), batch_size, d, 1e-6);
+  EXPECT_EQ(status, cudaSuccess) << "RMSNorm kernel launch failed, error message: "
+                                 << cudaGetErrorString(status);
+
+  thrust::host_vector<T> y_host(y_device);
+  bool nan_detected = false;
+  size_t num_result_errors_atol_1e_3_rtol_1e_3 = 0;
+  for (uint i = 0; i < batch_size * d; i++) {
+    if (isnan(float(y_host[i]))) {
+      nan_detected = true;
+    }
+    num_result_errors_atol_1e_3_rtol_1e_3 +=
+        (!utils::isclose(float(y_host[i]), float(y_ref_host[i]), 1e-3, 1e-3));
+    if (!utils::isclose(float(y_host[i]), float(y_ref_host[i]), 1e-3, 1e-3)) {
+      std::cout << "i: " << i << ", y_host[i]: " << float(y_host[i])
+                << ", y_ref_host[i]: " << float(y_ref_host[i]) << std::endl;
+    }
+  }
+  float result_accuracy = 1.0f - float(num_result_errors_atol_1e_3_rtol_1e_3) / (batch_size * d);
+  std::cout << "batch_size: " << batch_size << ", d: " << d
+            << ", RMSNorm correctness: " << result_accuracy << std::endl;
+  EXPECT_GT(result_accuracy, 0.99f) << "RMSNorm correctness test failed";
+  EXPECT_FALSE(nan_detected) << "Nan detected in RMSNorm output";
+}
+
+template <typename T>
+void TestRMSNormCorrectness() {
+  for (size_t batch_size : {1, 3, 7, 19, 733}) {
+    for (size_t d : {37, 128, 512, 1002, 3072, 4096, 8192, 16384}) {
+      _TestRMSNormCorrectness<T>(batch_size, d);
+    }
+  }
+}
+
+TEST(FlashInferCorrectnessTests, TestRMSNormFP16) { TestRMSNormCorrectness<half>(); }

sglang_repo/sgl-kernel/3rdparty/flashinfer/src/test_page.cu

@@ -0,0 +1,208 @@
+/*
+ * Copyright (c) 2023 by FlashInfer team.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <gtest/gtest.h>
+
+#include <flashinfer/page.cuh>
+#include <type_traits>
+
+#include "cpu_reference.h"
+#include "utils.h"
+
+using namespace flashinfer;
+
+template <typename T>
+void _TestAppendPagedKVKernelCorrectness(size_t page_size, size_t batch_size, size_t num_heads,
+                                         size_t head_dim, QKVLayout kv_layout) {
+  // number of conversation rounds
+  size_t num_conv_rounds = 3;
+  size_t max_decode_len = 1;
+  size_t max_prefill_len = 128;
+  size_t max_num_pages =
+      num_conv_rounds * batch_size * ((max_decode_len + max_prefill_len) / page_size + 1);
+  std::vector<T> k_data_cpu(max_num_pages * page_size * num_heads * head_dim);
+  std::vector<T> v_data_cpu(max_num_pages * page_size * num_heads * head_dim);
+  utils::vec_zero_(k_data_cpu);
+  utils::vec_zero_(v_data_cpu);
+  thrust::device_vector<T> k_data_gpu(k_data_cpu), v_data_gpu(v_data_cpu);
+  std::vector<int32_t> seq_len(batch_size);
+  utils::vec_fill_(seq_len, 0);
+  std::vector<std::vector<int32_t>> page_indices(batch_size);
+  std::vector<int32_t> last_page_len(batch_size);
+  utils::vec_fill_(last_page_len, 0);
+  size_t page_counter = 0;
+
+  for (size_t round = 0; round < 2 * num_conv_rounds; ++round) {
+    std::vector<int32_t> append_len(batch_size);
+    std::vector<int32_t> append_indptr{0};
+    std::vector<int32_t> batch_indices;
+    std::vector<int32_t> positions;
+    std::vector<std::vector<T>> keys;
+    std::vector<std::vector<T>> values;
+    if (round % 2 == 0) {
+      utils::vec_randint_(append_len, 1, max_prefill_len + 1);
+    } else {
+      utils::vec_fill_<int32_t>(append_len, max_decode_len);
+    }
+    for (size_t i = 0; i < batch_size; ++i) {
+      append_indptr.push_back(append_indptr.back() + append_len[i]);
+      seq_len[i] += append_len[i];
+      for (size_t j = 0; j < append_len[i]; ++j) {
+        if (last_page_len[i] % page_size == 0) {
+          page_indices[i].push_back(page_counter++);
+          last_page_len[i] = 1;
+        } else {
+          last_page_len[i] += 1;
+        }
+        batch_indices.push_back(i);
+        positions.push_back(seq_len[i] - append_len[i] + j);
+      }
+      std::vector<T> ki(append_len[i] * num_heads * head_dim),
+          vi(append_len[i] * num_heads * head_dim);
+      utils::vec_normal_(ki);
+      utils::vec_normal_(vi);
+      keys.push_back(ki);
+      values.push_back(vi);
+    }
+
+    std::vector<int32_t> indptr_cpu{0};
+    std::vector<int32_t> indices_cpu;
+    for (size_t i = 0; i < batch_size; ++i) {
+      for (size_t j = 0; j < page_indices[i].size(); ++j) {
+        indices_cpu.push_back(page_indices[i][j]);
+      }
+      indptr_cpu.push_back(indptr_cpu.back() + page_indices[i].size());
+    }
+    paged_kv_t<T, int32_t> paged_kv_cpu(num_heads, page_size, head_dim, batch_size, kv_layout,
+                                        /*k_data=*/k_data_cpu.data(),
+                                        /*v_data=*/v_data_cpu.data(), indices_cpu.data(),
+                                        indptr_cpu.data(), last_page_len.data());
+    cpu_reference::append_paged_kv_cache(paged_kv_cpu, keys, values, append_indptr);
+
+    thrust::device_vector<int32_t> indptr_gpu(indptr_cpu);
+    thrust::device_vector<int32_t> indices_gpu(indices_cpu);
+    thrust::device_vector<int32_t> last_page_len_gpu(last_page_len);
+    paged_kv_t<T, int32_t> paged_kv_gpu(num_heads, page_size, head_dim, batch_size, kv_layout,
+                                        /*k_data=*/thrust::raw_pointer_cast(k_data_gpu.data()),
+                                        /*v_data=*/thrust::raw_pointer_cast(v_data_gpu.data()),
+                                        thrust::raw_pointer_cast(indices_gpu.data()),
+                                        thrust::raw_pointer_cast(indptr_gpu.data()),
+                                        thrust::raw_pointer_cast(last_page_len_gpu.data()));
+
+    thrust::device_vector<int32_t> batch_indices_gpu(batch_indices);
+    thrust::device_vector<int32_t> positions_gpu(positions);
+    thrust::device_vector<T> keys_gpu(append_indptr.back() * num_heads * head_dim);
+    thrust::device_vector<T> values_gpu(append_indptr.back() * num_heads * head_dim);
+    for (size_t i = 0; i < batch_size; ++i) {
+      thrust::device_vector<T> ki(keys[i]);
+      thrust::device_vector<T> vi(values[i]);
+      thrust::copy(ki.begin(), ki.end(),
+                   keys_gpu.begin() + append_indptr[i] * num_heads * head_dim);
+      thrust::copy(vi.begin(), vi.end(),
+                   values_gpu.begin() + append_indptr[i] * num_heads * head_dim);
+    }
+
+    if (round % 2 == 0) {
+      // call prefill kernel
+      cudaError_t status =
+          AppendPagedKVCache(paged_kv_gpu, thrust::raw_pointer_cast(keys_gpu.data()),
+                             thrust::raw_pointer_cast(values_gpu.data()),
+                             thrust::raw_pointer_cast(batch_indices_gpu.data()),
+                             thrust::raw_pointer_cast(positions_gpu.data()),
+                             /*nnz=*/append_indptr.back(),
+                             /*append_k_stride_n=*/num_heads * head_dim,
+                             /*append_k_stride_h=*/head_dim,
+                             /*append_v_stride_n=*/num_heads * head_dim,
+                             /*append_v_stride_h=*/head_dim);
+      EXPECT_EQ(status, cudaSuccess) << "AppendPagedKVCache kernel launch failed, error message: "
+                                     << cudaGetErrorString(status);
+    } else {
+      // call decode kernel
+      cudaError_t status =
+          AppendPagedKVCacheDecode(paged_kv_gpu, thrust::raw_pointer_cast(keys_gpu.data()),
+                                   thrust::raw_pointer_cast(values_gpu.data()));
+      EXPECT_EQ(status, cudaSuccess)
+          << "AppendPagedKVCacheDecode kernel launch failed, error message: "
+          << cudaGetErrorString(status);
+    }
+  }
+
+  thrust::host_vector<T> k_data_gpu_h(k_data_gpu), v_data_gpu_h(v_data_gpu);
+  size_t num_result_errors_atol_1e_3_rtol_1e_3 = 0;
+  bool nan_detected = false;
+  for (size_t i = 0; i < k_data_cpu.size(); ++i) {
+    if (std::isnan(float(k_data_gpu_h[i]))) {
+      nan_detected = true;
+    }
+    num_result_errors_atol_1e_3_rtol_1e_3 +=
+        (!utils::isclose(float(k_data_cpu[i]), float(k_data_gpu_h[i]), 1e-3, 1e-3));
+  }
+  for (size_t i = 0; i < v_data_cpu.size(); ++i) {
+    if (std::isnan(float(v_data_gpu_h[i]))) {
+      nan_detected = true;
+    }
+    num_result_errors_atol_1e_3_rtol_1e_3 +=
+        (!utils::isclose(float(v_data_cpu[i]), float(v_data_gpu_h[i]), 1e-3, 1e-3));
+  }
+  float result_accuracy = 1. - float(num_result_errors_atol_1e_3_rtol_1e_3) /
+                                   float(k_data_cpu.size() + v_data_cpu.size());
+  std::cout << "kv_layout=" << QKVLayoutToString(kv_layout) << ", page_size=" << page_size
+            << ", batch_size=" << batch_size << ", num_heads=" << num_heads
+            << ", head_dim=" << head_dim << ", result_accuracy=" << result_accuracy << std::endl;
+  EXPECT_GT(result_accuracy, 0.99) << "Result correctness test failed.";
+  EXPECT_EQ(nan_detected, false) << "Nan detected in the result.";
+}
+
+template <typename T>
+void TestAppendPagedKVKernelCorrectness() {
+  for (size_t page_size : {1, 3, 7, 17}) {
+    for (size_t batch_size : {1, 2, 3, 5, 7, 23, 79, 91}) {
+      for (size_t num_heads : {32}) {
+        for (QKVLayout kv_layout : {QKVLayout::kNHD, QKVLayout::kHND}) {
+          for (size_t head_dim : {64, 128, 256}) {
+            _TestAppendPagedKVKernelCorrectness<T>(page_size, batch_size, num_heads, head_dim,
+                                                   kv_layout);
+          }
+        }
+      }
+    }
+  }
+}
+
+TEST(FlashInferCorrectnessTest, AppendPagedKVKernelCorrectnessTestFP16) {
+  TestAppendPagedKVKernelCorrectness<half>();
+}
+
+TEST(FlashInferCorrectnessTest, AppendPagedKVKernelCorrectnessTestFP32) {
+  TestAppendPagedKVKernelCorrectness<float>();
+}
+
+#ifdef FLASHINFER_ENABLE_BF16
+TEST(FlashInferCorrectnessTest, AppendPagedKVKernelCorrectnessTestBF16) {
+  TestAppendPagedKVKernelCorrectness<__nv_bfloat16>();
+}
+#endif
+
+#ifdef FLASHINFER_ENABLE_FP8_E4M3
+TEST(FlashInferCorrectnessTest, AppendPagedKVKernelCorrectnessTestE4M3) {
+  TestAppendPagedKVKernelCorrectness<__nv_fp8_e4m3>();
+}
+#endif
+
+#ifdef FLASHINFER_ENABLE_FP8_E5M2
+TEST(FlashInferCorrectnessTest, AppendPagedKVKernelCorrectnessTestE5M2) {
+  TestAppendPagedKVKernelCorrectness<__nv_fp8_e5m2>();
+}
+#endif

sglang_repo/sgl-kernel/3rdparty/flashinfer/src/test_single_prefill.cu

@@ -0,0 +1,276 @@
+/*
+ * Copyright (c) 2023 by FlashInfer team.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <gtest/gtest.h>
+
+#include <cstdint>
+
+#include "cpu_reference.h"
+#include "flashinfer_ops.cuh"
+#include "utils.h"
+
+using namespace flashinfer;
+
+template <typename DTypeQ, typename DTypeKV, typename DTypeO>
+void _TestSinglePrefillKernelCorrectness(size_t qo_len, size_t kv_len, size_t num_qo_heads,
+                                         size_t num_kv_heads, size_t head_dim, bool causal,
+                                         QKVLayout kv_layout, PosEncodingMode pos_encoding_mode,
+                                         bool use_fp16_qk_reduction, float rtol = 1e-3,
+                                         float atol = 1e-3) {
+  std::vector<DTypeQ> q(qo_len * num_qo_heads * head_dim);
+  std::vector<DTypeKV> k(kv_len * num_kv_heads * head_dim);
+  std::vector<DTypeKV> v(kv_len * num_kv_heads * head_dim);
+  std::vector<DTypeO> o(qo_len * num_qo_heads * head_dim);
+
+  utils::vec_normal_(q);
+  utils::vec_normal_(k);
+  utils::vec_normal_(v);
+  utils::vec_zero_(o);
+
+  thrust::device_vector<DTypeQ> q_d(q);
+  thrust::device_vector<DTypeKV> k_d(k);
+  thrust::device_vector<DTypeKV> v_d(v);
+  thrust::device_vector<DTypeO> o_d(o);
+  thrust::device_vector<DTypeO> tmp_d(16 * 1024 * 1024);
+
+  cudaError_t status = flashinfer::SinglePrefillWithKVCache<DTypeQ, DTypeKV, DTypeO>(
+      thrust::raw_pointer_cast(q_d.data()), thrust::raw_pointer_cast(k_d.data()),
+      thrust::raw_pointer_cast(v_d.data()), thrust::raw_pointer_cast(o_d.data()),
+      thrust::raw_pointer_cast(tmp_d.data()),
+      /*lse=*/nullptr, num_qo_heads, num_kv_heads, qo_len, kv_len, head_dim, causal, kv_layout,
+      pos_encoding_mode, use_fp16_qk_reduction);
+
+  EXPECT_EQ(status, cudaSuccess) << "SinglePrefillWithKVCache kernel launch failed, error message: "
+                                 << cudaGetErrorString(status);
+
+  thrust::host_vector<DTypeO> o_h(o_d);
+  std::vector<DTypeO> o_ref = cpu_reference::single_mha<DTypeQ, DTypeKV, DTypeO>(
+      q, k, v, qo_len, kv_len, num_qo_heads, num_kv_heads, head_dim, causal, kv_layout,
+      pos_encoding_mode);
+  size_t num_results_error_atol = 0;
+  bool nan_detected = false;
+
+  for (size_t i = 0; i < o_ref.size(); ++i) {
+    if (isnan(float(o_h[i]))) {
+      nan_detected = true;
+    }
+    num_results_error_atol += (!utils::isclose(float(o_ref[i]), float(o_h[i]), rtol, atol));
+    if (!utils::isclose(float(o_ref[i]), float(o_h[i]), rtol, atol)) {
+      std::cout << "i=" << i << ", o_ref[i]=" << float(o_ref[i]) << ", o_h[i]=" << float(o_h[i])
+                << std::endl;
+    }
+  }
+
+  float result_accuracy = 1. - float(num_results_error_atol) / float(o_ref.size());
+  std::cout << "num_qo_heads=" << num_qo_heads << ", num_kv_heads=" << num_kv_heads
+            << ", qo_len=" << qo_len << ", kv_len=" << kv_len << ", head_dim=" << head_dim
+            << ", causal=" << causal << ", kv_layout=" << QKVLayoutToString(kv_layout)
+            << ", pos_encoding_mode=" << PosEncodingModeToString(pos_encoding_mode)
+            << ", result_accuracy=" << result_accuracy << std::endl;
+  EXPECT_GT(result_accuracy, 0.90) << "Result correctness test failed.";
+  EXPECT_FALSE(nan_detected) << "Nan detected in the result.";
+}
+
+template <typename DTypeIn, typename DTypeO>
+void TestSinglePrefillKernelLongContextCorrectness(bool use_fp16_qk_reduction) {
+  for (size_t qo_len : {1, 31, 63, 127}) {
+    for (size_t kv_len : {31717}) {
+      for (size_t num_heads : {1}) {
+        for (size_t head_dim : {64, 128, 256}) {
+          for (bool causal : {false, true}) {
+            for (size_t pos_encoding_mode : {0, 1}) {
+              for (size_t kv_layout : {0, 1}) {
+                _TestSinglePrefillKernelCorrectness<DTypeIn, DTypeIn, DTypeO>(
+                    qo_len, kv_len, num_heads, num_heads, head_dim, causal, QKVLayout(kv_layout),
+                    PosEncodingMode(pos_encoding_mode), use_fp16_qk_reduction);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+template <typename DTypeKV>
+void TestSinglePrefillFP8KernelLongContextCorrectness(bool use_fp16_qk_reduction) {
+  for (size_t qo_len : {1, 31, 63, 127}) {
+    for (size_t kv_len : {31717}) {
+      for (size_t num_heads : {1}) {
+        for (size_t head_dim : {64, 128, 256}) {
+          for (bool causal : {false, true}) {
+            for (size_t pos_encoding_mode : {0}) {
+              for (size_t kv_layout : {0, 1}) {
+                _TestSinglePrefillKernelCorrectness<half, DTypeKV, half>(
+                    qo_len, kv_len, num_heads, num_heads, head_dim, causal, QKVLayout(kv_layout),
+                    PosEncodingMode(pos_encoding_mode), use_fp16_qk_reduction);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+template <typename DTypeIn, typename DTypeO>
+void TestSinglePrefillKernelShortContextCorrectness(bool use_fp16_qk_reduction) {
+  float rtol = std::is_same<DTypeO, nv_bfloat16>::value ? 1e-2 : 1e-3;
+  float atol = std::is_same<DTypeO, nv_bfloat16>::value ? 1e-2 : 1e-3;
+  for (size_t qkv_len : {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37}) {
+    for (size_t num_qo_heads : {32}) {
+      for (size_t num_kv_heads : {4, 8, 32}) {
+        for (size_t head_dim : {64, 128, 256}) {
+          for (bool causal : {false, true}) {
+            for (size_t pos_encoding_mode : {0, 1}) {
+              for (size_t kv_layout : {0, 1}) {
+                _TestSinglePrefillKernelCorrectness<DTypeIn, DTypeIn, DTypeO>(
+                    qkv_len, qkv_len, num_qo_heads, num_kv_heads, head_dim, causal,
+                    QKVLayout(kv_layout), PosEncodingMode(pos_encoding_mode), use_fp16_qk_reduction,
+                    rtol, atol);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+template <typename DTypeKV>
+void TestSinglePrefillFP8KernelShortContextCorrectness(bool use_fp16_qk_reduction) {
+  float rtol = 1e-3;
+  float atol = 1e-3;
+  for (size_t qkv_len : {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37}) {
+    for (size_t num_qo_heads : {32}) {
+      for (size_t num_kv_heads : {4, 8, 32}) {
+        for (size_t head_dim : {64, 128, 256}) {
+          for (bool causal : {false, true}) {
+            for (size_t pos_encoding_mode : {0}) {
+              for (size_t kv_layout : {0, 1}) {
+                _TestSinglePrefillKernelCorrectness<half, DTypeKV, half>(
+                    qkv_len, qkv_len, num_qo_heads, num_kv_heads, head_dim, causal,
+                    QKVLayout(kv_layout), PosEncodingMode(pos_encoding_mode), use_fp16_qk_reduction,
+                    rtol, atol);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+template <typename DTypeIn, typename DTypeO>
+void TestSinglePrefillKernelCorrectness(bool use_fp16_qk_reduction) {
+  for (size_t qo_len : {399, 400, 401}) {
+    for (size_t kv_len : {533, 534, 535}) {
+      for (size_t num_heads : {12}) {
+        for (size_t head_dim : {64, 128, 256}) {
+          for (bool causal : {false, true}) {
+            for (size_t pos_encoding_mode : {0, 1}) {
+              for (size_t kv_layout : {0, 1}) {
+                _TestSinglePrefillKernelCorrectness<DTypeIn, DTypeIn, DTypeO>(
+                    qo_len, kv_len, num_heads, num_heads, head_dim, causal, QKVLayout(kv_layout),
+                    PosEncodingMode(pos_encoding_mode), use_fp16_qk_reduction);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+template <typename DTypeKV>
+void TestSinglePrefillFP8KernelCorrectness(bool use_fp16_qk_reduction) {
+  for (size_t qo_len : {399, 400, 401}) {
+    for (size_t kv_len : {533, 534, 535}) {
+      for (size_t num_heads : {12}) {
+        for (size_t head_dim : {64, 128, 256}) {
+          for (bool causal : {false, true}) {
+            for (size_t pos_encoding_mode : {0}) {
+              for (size_t kv_layout : {0, 1}) {
+                _TestSinglePrefillKernelCorrectness<half, DTypeKV, half>(
+                    qo_len, kv_len, num_heads, num_heads, head_dim, causal, QKVLayout(kv_layout),
+                    PosEncodingMode(pos_encoding_mode), use_fp16_qk_reduction);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+TEST(FlashInferCorrectnessTest, TestSinglePrefillKernelLongContextCorrectnessFP16) {
+  TestSinglePrefillKernelLongContextCorrectness<half, half>(false);
+}
+
+TEST(FlashInferCorrectnessTest, TestSinglePrefillKernelLongContextCorrectnessFP16QKHalfAccum) {
+  TestSinglePrefillKernelLongContextCorrectness<half, half>(true);
+}
+
+TEST(FlashInferCorrectnessTest, TestSinglePrefillKernelShortContextCorrectnessFP16) {
+  TestSinglePrefillKernelShortContextCorrectness<half, half>(false);
+}
+
+TEST(FlashInferCorrectnessTest, TestSinglePrefillKernelShortContextCorrectnessFP16QKHalfAccum) {
+  TestSinglePrefillKernelShortContextCorrectness<half, half>(true);
+}
+
+TEST(FlashInferCorrectnessTest, TestSinglePrefillKernelCorrectnessTestFP16) {
+  TestSinglePrefillKernelCorrectness<half, half>(false);
+}
+
+TEST(FlashInferCorrectnessTest, TestSinglePrefillKernelCorrectnessTestFP16QKHalfAccum) {
+  TestSinglePrefillKernelCorrectness<half, half>(true);
+}
+
+#ifdef FLASHINFER_ENABLE_BF16
+TEST(FlashInferCorrectnessTest, TestSinglePrefillKernelLongContextCorrectnessBF16) {
+  TestSinglePrefillKernelLongContextCorrectness<nv_bfloat16, nv_bfloat16>(false);
+}
+TEST(FlashInferCorrectnessTest, TestSinglePrefillKernelShortContextCorrectnessBF16) {
+  TestSinglePrefillKernelShortContextCorrectness<nv_bfloat16, nv_bfloat16>(false);
+}
+TEST(FlashInferCorrectnessTest, TestSinglePrefillKernelCorrectnessTestBF16) {
+  TestSinglePrefillKernelCorrectness<nv_bfloat16, nv_bfloat16>(false);
+}
+#endif
+
+#ifdef FLASHINFER_ENABLE_FP8_E4M3
+TEST(FlashInferCorrectnessTest, TestSinglePrefillKernelShortContextCorrectnessE4M3) {
+  TestSinglePrefillFP8KernelShortContextCorrectness<__nv_fp8_e4m3>(false);
+}
+TEST(FlashInferCorrectnessTest, TestSinglePrefillKernelCorrectnessTestE4M3) {
+  TestSinglePrefillFP8KernelCorrectness<__nv_fp8_e4m3>(false);
+}
+TEST(FlashInferCorrectnessTest, TestSinglePrefillKernelLongContextCorrectnessE4M3) {
+  TestSinglePrefillFP8KernelLongContextCorrectness<__nv_fp8_e4m3>(false);
+}
+#endif
+
+#ifdef FLASHINFER_ENABLE_FP8_E5M2
+TEST(FlashInferCorrectnessTest, TestSinglePrefillKernelShortContextCorrectnessE5M2) {
+  TestSinglePrefillFP8KernelShortContextCorrectness<__nv_fp8_e5m2>(false);
+}
+TEST(FlashInferCorrectnessTest, TestSinglePrefillKernelCorrectnessTestE5M2) {
+  TestSinglePrefillFP8KernelCorrectness<__nv_fp8_e5m2>(false);
+}
+TEST(FlashInferCorrectnessTest, TestSinglePrefillKernelLongContextCorrectnessE5M2) {
+  TestSinglePrefillFP8KernelLongContextCorrectness<__nv_fp8_e5m2>(false);
+}
+#endif

sglang_repo/sgl-kernel/3rdparty/flashinfer/src/tvm_wrapper.cu

@@ -0,0 +1,830 @@
+/*
+ * Copyright (c) 2023 by FlashInfer team.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <dlpack/dlpack.h>
+#include <tvm/runtime/logging.h>
+#include <tvm/runtime/module.h>
+#include <tvm/runtime/ndarray.h>
+#include <tvm/runtime/packed_func.h>
+#include <tvm/runtime/registry.h>
+
+#include <flashinfer/attention/cascade.cuh>
+#include <flashinfer/sampling.cuh>
+#include <optional>
+
+#include "flashinfer_ops.cuh"
+
+using tvm::runtime::Array;
+using tvm::runtime::DataType;
+using tvm::runtime::NDArray;
+using tvm::runtime::ShapeTuple;
+using namespace flashinfer;
+
+#define DISPATCH_TVM_CUDA_DTYPE(dl_dtype, cuda_dtype, ...)   \
+  if (dl_dtype.code == kDLFloat && dl_dtype.bits == 16) {    \
+    using cuda_dtype = half;                                 \
+    __VA_ARGS__                                              \
+  } else {                                                   \
+    LOG(FATAL) << "Unsupported data type " << dl_dtype.code; \
+  }
+
+#define DISPATCH_TVM_CUDA_IDTYPE(dl_dtype, cuda_dtype, ...)  \
+  if (dl_dtype.code == kDLInt && dl_dtype.bits == 32) {      \
+    using cuda_dtype = int32_t;                              \
+    __VA_ARGS__                                              \
+  } else {                                                   \
+    LOG(FATAL) << "Unsupported data type " << dl_dtype.code; \
+  }
+
+int _FlashInferSinglePrefillWithKVCache(DLTensor* q, DLTensor* k, DLTensor* v, DLTensor* tmp,
+                                        bool causal, int64_t kv_layout, int64_t pos_encoding_mode,
+                                        bool use_fp16_qk_reduction, double rope_scale,
+                                        double rope_theta, DLTensor* o) {
+  // `tmp` is user-provided scratch space of at least 16MB, e.g. 4 * 1024 * 1024 float32.
+  CHECK_EQ(q->device.device_type, kDLCUDA) << "The device of q matrix must be CUDA.";
+  CHECK_EQ(k->device.device_type, kDLCUDA) << "The device of k matrix must be CUDA.";
+  CHECK_EQ(v->device.device_type, kDLCUDA) << "The device of v matrix must be CUDA.";
+  CHECK_EQ(o->device.device_type, kDLCUDA) << "The device of o matrix must be CUDA.";
+
+  size_t dev_id = q->device.device_id;
+  CHECK_EQ(k->device.device_id, dev_id) << "The device id of q and k matrix doesn't match.";
+  CHECK_EQ(v->device.device_id, dev_id) << "The device id of q and v matrix doesn't match.";
+  CHECK_EQ(o->device.device_id, dev_id) << "The device id of q and o matrix doesn't match.";
+
+  CHECK_GE(q->ndim, 3);
+  size_t qo_len = q->shape[q->ndim - 3];
+  size_t num_qo_heads = q->shape[q->ndim - 2];
+  size_t head_dim = q->shape[q->ndim - 1];
+
+  CHECK_GE(k->ndim, 3);
+  size_t kv_len = k->shape[k->ndim - 3];
+  size_t num_kv_heads = k->shape[k->ndim - 2];
+  CHECK_EQ(head_dim, k->shape[k->ndim - 1]);
+
+  CHECK_GE(v->ndim, 3);
+  CHECK_EQ(kv_len, v->shape[v->ndim - 3]);
+  CHECK_EQ(num_kv_heads, v->shape[v->ndim - 2]);
+  CHECK_EQ(head_dim, v->shape[v->ndim - 1]);
+
+  CHECK_GE(o->ndim, 2);
+  CHECK_EQ(qo_len, o->shape[o->ndim - 2]);
+  CHECK_EQ(num_qo_heads * head_dim, o->shape[o->ndim - 1]);
+
+  CHECK(q->dtype.lanes == 1 && k->dtype.lanes == 1 && v->dtype.lanes == 1);
+  CHECK(q->dtype.bits == k->dtype.bits && q->dtype.code == k->dtype.code);
+  CHECK(q->dtype.bits == v->dtype.bits && q->dtype.code == v->dtype.code);
+
+  DISPATCH_TVM_CUDA_DTYPE(
+      q->dtype, dtype_in, {DISPATCH_TVM_CUDA_DTYPE(o->dtype, dtype_out, {
+        cudaError_t status = SinglePrefillWithKVCache(
+            (dtype_in*)q->data, (dtype_in*)k->data, (dtype_in*)v->data, (dtype_out*)o->data,
+            (dtype_out*)tmp->data, /*lse=*/nullptr, num_qo_heads, num_kv_heads, qo_len, kv_len,
+            head_dim, causal, QKVLayout(kv_layout), PosEncodingMode(pos_encoding_mode),
+            use_fp16_qk_reduction, std::nullopt, rope_scale, rope_theta, 0);
+        if (status != cudaSuccess) {
+          LOG(FATAL) << "FlashInfer CUDA kernel error " << cudaGetErrorString(status);
+        }
+      })});
+  return 0;
+}
+
+int _FlashInferSingleDecodeWithKVCache(DLTensor* q, DLTensor* k, DLTensor* v, DLTensor* tmp,
+                                       int64_t kv_layout, int64_t pos_encoding_mode,
+                                       double rope_scale, double rope_theta, DLTensor* o) {
+  // `tmp` is user-provided scratch space of at least 16MB, e.g. 4 * 1024 * 1024 float32.
+  CHECK_EQ(q->device.device_type, kDLCUDA) << "The device of q matrix must be CUDA.";
+  CHECK_EQ(k->device.device_type, kDLCUDA) << "The device of k matrix must be CUDA.";
+  CHECK_EQ(v->device.device_type, kDLCUDA) << "The device of v matrix must be CUDA.";
+  CHECK_EQ(o->device.device_type, kDLCUDA) << "The device of o matrix must be CUDA.";
+
+  size_t dev_id = q->device.device_id;
+  CHECK_EQ(k->device.device_id, dev_id) << "The device id of q and k matrix doesn't match.";
+  CHECK_EQ(v->device.device_id, dev_id) << "The device id of q and v matrix doesn't match.";
+  CHECK_EQ(o->device.device_id, dev_id) << "The device id of q and o matrix doesn't match.";
+
+  CHECK_GE(q->ndim, 2);
+  size_t num_qo_heads = q->shape[q->ndim - 2];
+  size_t head_dim = q->shape[q->ndim - 1];
+
+  CHECK_GE(k->ndim, 3);
+  size_t seq_len = k->shape[k->ndim - 3];
+  size_t num_kv_heads = k->shape[k->ndim - 2];
+  CHECK_EQ(head_dim, k->shape[k->ndim - 1]);
+
+  CHECK_GE(v->ndim, 3);
+  CHECK_EQ(seq_len, v->shape[v->ndim - 3]);
+  CHECK_EQ(num_kv_heads, v->shape[v->ndim - 2]);
+  CHECK_EQ(head_dim, v->shape[v->ndim - 1]);
+
+  CHECK_GE(o->ndim, 1);
+  CHECK_EQ(num_qo_heads * head_dim, o->shape[o->ndim - 1]);
+
+  CHECK(q->dtype.lanes == 1 && k->dtype.lanes == 1 && v->dtype.lanes == 1);
+  CHECK(q->dtype.bits == k->dtype.bits && q->dtype.code == k->dtype.code);
+  CHECK(q->dtype.bits == v->dtype.bits && q->dtype.code == v->dtype.code);
+
+  DISPATCH_TVM_CUDA_DTYPE(
+      q->dtype, dtype_in, {DISPATCH_TVM_CUDA_DTYPE(o->dtype, dtype_out, {
+        cudaError_t status = SingleDecodeWithKVCache(
+            (dtype_in*)q->data, (dtype_in*)k->data, (dtype_in*)v->data, (dtype_out*)o->data,
+            (dtype_out*)tmp->data, num_qo_heads, num_kv_heads, seq_len, head_dim,
+            QKVLayout(kv_layout), PosEncodingMode(pos_encoding_mode), rope_scale, rope_theta, 0);
+        if (status != cudaSuccess) {
+          LOG(FATAL) << "FlashInfer CUDA kernel error " << cudaGetErrorString(status);
+        }
+      })});
+  return 0;
+}
+
+constexpr uint32_t max_num_handlers = 8;
+thread_local BatchPrefillHandler batch_prefill_paged_kv_handlers[max_num_handlers];
+thread_local BatchPrefillHandler batch_prefill_ragged_kv_handler;
+
+void _FlashInferAttentionPrefillWithPagedKVCache(int64_t handler_id, DLTensor* q_data,
+                                                 DLTensor* qo_indptr,          //
+                                                 DLTensor* pages,              //
+                                                 DLTensor* page_table_indptr,  //
+                                                 DLTensor* page_table_values,  //
+                                                 DLTensor* last_page_len,      //
+                                                 DLTensor* k_rope_offset,      //
+                                                 DLTensor* q_rope_offset,      //
+                                                 DLTensor* output,             //
+                                                 DLTensor* lse,                //
+                                                 int64_t causal,               //
+                                                 int64_t pos_encoding_mode,    //
+                                                 double rope_scale,            //
+                                                 double rope_theta,
+                                                 double attn_score_scaling_factor = 1.0f) {
+  CHECK(handler_id < max_num_handlers) << "The handler id must be less than " << max_num_handlers;
+  CHECK_EQ(q_data->device.device_type, kDLCUDA) << "The device of q_data must be CUDA.";
+  CHECK_EQ(pages->device.device_type, kDLCUDA) << "The device of kv pages must be CUDA.";
+  CHECK_EQ(page_table_indptr->device.device_type, kDLCUDA)
+      << "The device of page_table_indptr matrix must be CUDA.";
+  CHECK_EQ(page_table_values->device.device_type, kDLCUDA)
+      << "The device of page_table_values matrix must be CUDA.";
+  CHECK_EQ(last_page_len->device.device_type, kDLCUDA)
+      << "The device of last_page_len matrix must be CUDA.";
+  CHECK_EQ(q_rope_offset->device.device_type, kDLCUDA)
+      << "The device of q_rope_offset matrix must be CUDA.";
+  CHECK_EQ(k_rope_offset->device.device_type, kDLCUDA)
+      << "The device of k_rope_offset matrix must be CUDA.";
+  CHECK_EQ(qo_indptr->device.device_type, kDLCUDA)
+      << "The device of qo_indptr matrix must be CUDA.";
+  CHECK_EQ(output->device.device_type, kDLCUDA) << "The device of output must be CUDA.";
+
+  int32_t dev_id = q_data->device.device_id;
+  CHECK_EQ(pages->device.device_id, dev_id);
+  CHECK_EQ(page_table_indptr->device.device_id, dev_id);
+  CHECK_EQ(page_table_values->device.device_id, dev_id);
+  CHECK_EQ(last_page_len->device.device_id, dev_id);
+  CHECK_EQ(q_rope_offset->device.device_id, dev_id);
+  CHECK_EQ(k_rope_offset->device.device_id, dev_id);
+  CHECK_EQ(qo_indptr->device.device_id, dev_id);
+  CHECK_EQ(output->device.device_id, dev_id);
+
+  CHECK(q_data->dtype.lanes == 1 && pages->dtype.lanes == 1 && output->dtype.lanes == 1);
+  CHECK(q_data->dtype.bits == pages->dtype.bits && q_data->dtype.code == pages->dtype.code);
+  CHECK(page_table_indptr->dtype.lanes == 1 && page_table_values->dtype.lanes == 1 &&
+        last_page_len->dtype.lanes == 1 && q_rope_offset->dtype.lanes == 1 &&
+        k_rope_offset->dtype.lanes == 1 && qo_indptr->dtype.lanes == 1);
+  CHECK(page_table_indptr->dtype.bits == page_table_values->dtype.bits &&
+        page_table_indptr->dtype.bits == last_page_len->dtype.bits &&
+        page_table_indptr->dtype.bits == qo_indptr->dtype.bits &&
+        page_table_indptr->dtype.code == page_table_values->dtype.code &&
+        page_table_indptr->dtype.code == last_page_len->dtype.code &&
+        page_table_indptr->dtype.code == q_rope_offset->dtype.code &&
+        page_table_indptr->dtype.code == k_rope_offset->dtype.code &&
+        page_table_indptr->dtype.code == qo_indptr->dtype.code);
+
+  CHECK_EQ(pages->ndim, 5);
+  CHECK_EQ(pages->shape[1], 2);
+  int64_t nhead_kv = pages->shape[2];
+  int64_t nhead_qo = q_data->shape[1];
+  int64_t nfeat = pages->shape[4];
+  int64_t page_size = pages->shape[3];
+
+  CHECK_EQ(last_page_len->ndim, 1);
+  int64_t num_total_seqs = last_page_len->shape[0];
+
+  CHECK_EQ(qo_indptr->ndim, 1);
+  CHECK_EQ(qo_indptr->shape[0], num_total_seqs + 1);
+
+  CHECK_EQ(page_table_indptr->ndim, 1);
+  CHECK_EQ(page_table_indptr->shape[0], num_total_seqs + 1);
+  CHECK_EQ(page_table_values->ndim, 1);
+
+  CHECK_EQ(q_data->ndim, 3);
+  CHECK_EQ(output->ndim, 3);
+  CHECK_EQ(q_data->shape[2], nfeat);
+  CHECK_EQ(output->shape[1], nhead_qo);
+  CHECK_EQ(output->shape[2], nfeat);
+  CHECK_EQ(q_rope_offset->ndim, 1);
+  CHECK_EQ(q_rope_offset->shape[0], q_data->shape[0]);
+
+  CHECK_EQ(k_rope_offset->ndim, 1);
+  CHECK_EQ(k_rope_offset->shape[0], num_total_seqs);
+
+  constexpr QKVLayout kv_layout = QKVLayout::kHND;
+  const float sm_scale = attn_score_scaling_factor / std::sqrt(static_cast<float>(nfeat));
+
+  DISPATCH_TVM_CUDA_DTYPE(
+      pages->dtype, dtype_in,
+      {DISPATCH_TVM_CUDA_DTYPE(
+          output->dtype, dtype_out, {DISPATCH_TVM_CUDA_IDTYPE(page_table_values->dtype, dtype_idx, {
+            paged_kv_t<dtype_in, dtype_idx> cache(
+                nhead_kv, page_size, nfeat, num_total_seqs, kv_layout,
+                /*k_data=*/static_cast<dtype_in*>(pages->data),
+                /*v_data=*/static_cast<dtype_in*>(pages->data) + pages->strides[1],
+                static_cast<dtype_idx*>(page_table_values->data) +
+                    page_table_values->byte_offset / sizeof(dtype_idx),
+                static_cast<dtype_idx*>(page_table_indptr->data) +
+                    page_table_indptr->byte_offset / sizeof(dtype_idx),
+                static_cast<dtype_idx*>(last_page_len->data) +
+                    last_page_len->byte_offset / sizeof(dtype_idx),
+                static_cast<dtype_idx*>(k_rope_offset->data) +
+                    k_rope_offset->byte_offset / sizeof(dtype_idx));
+            cudaError_t status =
+                BatchPrefillWithPagedKVCacheWrapper<dtype_in, dtype_in, dtype_out, dtype_idx>(
+                    &batch_prefill_paged_kv_handlers[handler_id],
+                    static_cast<dtype_in*>(q_data->data),
+                    static_cast<dtype_idx*>(qo_indptr->data) +
+                        qo_indptr->byte_offset / sizeof(dtype_idx),
+                    static_cast<dtype_idx*>(q_rope_offset->data) +
+                        q_rope_offset->byte_offset / sizeof(dtype_idx),
+                    cache, static_cast<dtype_out*>(output->data),
+                    /*lse=*/static_cast<float*>(lse->data), nhead_qo,
+                    /*causal=*/causal, PosEncodingMode(pos_encoding_mode),
+                    /*use_fp16_qk_reduction=*/false, sm_scale, rope_scale, rope_theta,
+                    /*stream=*/0);
+            if (status != cudaSuccess) {
+              LOG(FATAL) << "FlashInfer CUDA kernel error " << cudaGetErrorString(status);
+            }
+          })})});
+}
+
+void _FlashInferAttentionPrefillWithPagedKVCachePlan(
+    int64_t handler_idx, DLTensor* float_workspace_buffer, DLTensor* int_workspace_buffer,
+    DLTensor* qo_indptr, DLTensor* kv_indptr, int64_t batch_size, int64_t num_qo_heads,
+    int64_t num_kv_heads, int64_t head_dim, int64_t page_size, TVMStreamHandle copy_stream) {
+  CHECK_EQ(float_workspace_buffer->ndim, 1) << "The float workspace buffer must be a 1-D tensor";
+  size_t float_workspace_size_in_bytes =
+      float_workspace_buffer->shape[0] * float_workspace_buffer->dtype.bits / 8;
+  CHECK_EQ(int_workspace_buffer->ndim, 1) << "The int workspace buffer must be a 1-D tensor";
+  size_t int_workspace_size_in_bytes =
+      int_workspace_buffer->shape[0] * int_workspace_buffer->dtype.bits / 8;
+  CHECK(handler_idx < max_num_handlers) << "The handler id must be less than " << max_num_handlers;
+
+  // NOTE(Zihao): here we presume the input data type is half, in the future we should
+  //   leave a parameter for the input data type.
+  using dtype_in = half;
+  cudaStream_t original_stream = batch_prefill_paged_kv_handlers[handler_idx].GetCUDAStream();
+  batch_prefill_paged_kv_handlers[handler_idx].SetCUDAStream(
+      static_cast<cudaStream_t>(copy_stream));
+  DISPATCH_TVM_CUDA_IDTYPE(qo_indptr->dtype, dtype_idx, {
+    cudaError_t status = batch_prefill_paged_kv_handlers[handler_idx].Plan<dtype_in, dtype_idx>(
+        static_cast<void*>(float_workspace_buffer->data), float_workspace_size_in_bytes,
+        static_cast<void*>(int_workspace_buffer->data), int_workspace_size_in_bytes,
+        static_cast<dtype_idx*>(qo_indptr->data) + qo_indptr->byte_offset / sizeof(dtype_idx),
+        static_cast<dtype_idx*>(kv_indptr->data) + kv_indptr->byte_offset / sizeof(dtype_idx),
+        batch_size, num_qo_heads, num_kv_heads, head_dim, page_size);
+    if (status != cudaSuccess) {
+      LOG(FATAL) << "FlashInfer prefill Plan error " << cudaGetErrorString(status);
+    }
+  });
+  batch_prefill_paged_kv_handlers[handler_idx].SetCUDAStream(original_stream);
+}
+
+// Creates a pool of handlers with a fixed size to independently handle decoding forward passes.
+thread_local BatchDecodeHandler batch_decode_handlers[max_num_handlers];
+
+void _FlashInferAttentionDecodeWithPagedKVCache(int64_t handler_id, DLTensor* q_data,
+                                                DLTensor* pages,
+                                                DLTensor* page_table_indptr,    //
+                                                DLTensor* page_table_values,    //
+                                                DLTensor* last_page_len,        //
+                                                DLTensor* k_rope_offset,        //
+                                                DLTensor* q_rope_offset,        //
+                                                DLTensor* output,               //
+                                                DLTensor* lse,                  //
+                                                int64_t pos_encoding_mode = 0,  //
+                                                double rope_scale = 1.0f,       //
+                                                double rope_theta = 1e4,
+                                                double attn_score_scaling_factor = 1.0f) {
+  CHECK_LT(handler_id, max_num_handlers) << "The handler id must be less than " << max_num_handlers;
+  CHECK_EQ(q_data->device.device_type, kDLCUDA) << "The device of q_data must be CUDA.";
+  CHECK_EQ(pages->device.device_type, kDLCUDA) << "The device of kv pages must be CUDA.";
+  CHECK_EQ(page_table_indptr->device.device_type, kDLCUDA)
+      << "The device of page_table_indptr matrix must be CUDA.";
+  CHECK_EQ(page_table_values->device.device_type, kDLCUDA)
+      << "The device of page_table_values matrix must be CUDA.";
+  CHECK_EQ(last_page_len->device.device_type, kDLCUDA)
+      << "The device of last_page_len matrix must be CUDA.";
+  CHECK_EQ(q_rope_offset->device.device_type, kDLCUDA)
+      << "The device of q_rope_offset matrix must be CUDA.";
+  CHECK_EQ(k_rope_offset->device.device_type, kDLCUDA)
+      << "The device of k_rope_offset matrix must be CUDA.";
+  CHECK_EQ(output->device.device_type, kDLCUDA) << "The device of output must be CUDA.";
+
+  int32_t dev_id = q_data->device.device_id;
+  CHECK_EQ(pages->device.device_id, dev_id);
+  CHECK_EQ(page_table_indptr->device.device_id, dev_id);
+  CHECK_EQ(page_table_values->device.device_id, dev_id);
+  CHECK_EQ(last_page_len->device.device_id, dev_id);
+  CHECK_EQ(q_rope_offset->device.device_id, dev_id);
+  CHECK_EQ(k_rope_offset->device.device_id, dev_id);
+  CHECK_EQ(output->device.device_id, dev_id);
+
+  CHECK(q_data->dtype.lanes == 1 && pages->dtype.lanes == 1 && output->dtype.lanes == 1);
+  CHECK(q_data->dtype.bits == pages->dtype.bits && q_data->dtype.code == pages->dtype.code);
+  CHECK(page_table_indptr->dtype.lanes == 1 && page_table_values->dtype.lanes == 1 &&
+        last_page_len->dtype.lanes == 1 && q_rope_offset->dtype.lanes == 1 &&
+        k_rope_offset->dtype.lanes == 1);
+  CHECK(page_table_indptr->dtype.bits == page_table_values->dtype.bits &&
+        page_table_indptr->dtype.bits == last_page_len->dtype.bits &&
+        page_table_indptr->dtype.code == page_table_values->dtype.code &&
+        page_table_indptr->dtype.code == last_page_len->dtype.code &&
+        page_table_indptr->dtype.code == q_rope_offset->dtype.code &&
+        page_table_indptr->dtype.code == k_rope_offset->dtype.code);
+
+  CHECK_EQ(pages->ndim, 5);
+  CHECK_EQ(pages->shape[1], 2);
+  int64_t nhead_kv = pages->shape[2];
+  int64_t nfeat = pages->shape[4];
+  int64_t page_size = pages->shape[3];
+
+  CHECK_EQ(last_page_len->ndim, 1);
+  int64_t num_total_seqs = last_page_len->shape[0];
+
+  CHECK_EQ(page_table_indptr->ndim, 1);
+  CHECK_EQ(page_table_indptr->shape[0], num_total_seqs + 1);
+  CHECK_EQ(page_table_values->ndim, 1);
+
+  CHECK_EQ(q_data->ndim, 3);
+  CHECK_EQ(output->ndim, 3);
+  CHECK_GE(q_data->shape[0], 1);
+  CHECK_EQ(q_data->shape[0], output->shape[0]);
+  CHECK_EQ(q_data->shape[2], nfeat);
+  int64_t nhead_qo = q_data->shape[1];
+  CHECK_EQ(output->shape[1], nhead_qo);
+  CHECK_EQ(output->shape[2], nfeat);
+  CHECK_EQ(q_rope_offset->ndim, 1);
+  CHECK_EQ(q_rope_offset->shape[0], num_total_seqs);
+
+  CHECK_EQ(k_rope_offset->ndim, 1);
+  CHECK_EQ(k_rope_offset->shape[0], num_total_seqs);
+
+  constexpr QKVLayout kv_layout = QKVLayout::kHND;
+  const float sm_scale = attn_score_scaling_factor / std::sqrt(static_cast<float>(nfeat));
+
+  DISPATCH_TVM_CUDA_DTYPE(
+      pages->dtype, dtype_in,
+      {DISPATCH_TVM_CUDA_DTYPE(
+          output->dtype, dtype_out, {DISPATCH_TVM_CUDA_IDTYPE(page_table_values->dtype, dtype_idx, {
+            paged_kv_t<dtype_in, dtype_idx> cache(
+                nhead_kv, page_size, nfeat, num_total_seqs, kv_layout,
+                /*k_data=*/static_cast<dtype_in*>(pages->data),
+                /*v_data=*/static_cast<dtype_in*>(pages->data) + pages->strides[1],
+                static_cast<dtype_idx*>(page_table_values->data) +
+                    page_table_values->byte_offset / sizeof(dtype_idx),
+                static_cast<dtype_idx*>(page_table_indptr->data) +
+                    page_table_indptr->byte_offset / sizeof(dtype_idx),
+                static_cast<dtype_idx*>(last_page_len->data) +
+                    last_page_len->byte_offset / sizeof(dtype_idx),
+                static_cast<dtype_idx*>(k_rope_offset->data) +
+                    k_rope_offset->byte_offset / sizeof(dtype_idx));
+            cudaError_t status =
+                BatchDecodeWithPagedKVCacheWrapper<dtype_in, dtype_in, dtype_out, dtype_idx>(
+                    &batch_decode_handlers[handler_id], static_cast<dtype_in*>(q_data->data),
+                    static_cast<dtype_idx*>(q_rope_offset->data) +
+                        q_rope_offset->byte_offset / sizeof(dtype_idx),
+                    cache, static_cast<dtype_out*>(output->data),
+                    /*lse=*/static_cast<float*>(lse->data), nhead_qo,
+                    PosEncodingMode(pos_encoding_mode), sm_scale, rope_scale, rope_theta,
+                    /*stream=*/0);
+            if (status != cudaSuccess) {
+              LOG(FATAL) << "FlashInfer CUDA kernel error " << cudaGetErrorString(status);
+            }
+          })})});
+}
+
+void _FlashInferAttentionDecodeWithPagedKVCachePlan(
+    int64_t handler_idx, DLTensor* float_workspace_buffer, DLTensor* int_workspace_buffer,
+    DLTensor* page_table_indptr, DLTensor* last_page_len, int64_t num_qo_heads,
+    int64_t num_kv_heads, int64_t head_dim, int64_t page_size, int64_t pos_encoding_mode,
+    TVMStreamHandle copy_stream) {
+  CHECK_EQ(float_workspace_buffer->ndim, 1) << "The float workspace buffer must be a 1-D tensor";
+  size_t float_workspace_size_in_bytes =
+      float_workspace_buffer->shape[0] * float_workspace_buffer->dtype.bits / 8;
+  CHECK_EQ(int_workspace_buffer->ndim, 1) << "The int workspace buffer must be a 1-D tensor";
+  size_t int_workspace_size_in_bytes =
+      int_workspace_buffer->shape[0] * int_workspace_buffer->dtype.bits / 8;
+  CHECK_LT(handler_idx, max_num_handlers)
+      << "The handler id must be less than " << max_num_handlers;
+  // NOTE(Zihao): here we presume the input data type is half, in the future we should
+  //   leave a parameter for the input data type.
+  using dtype_in = half;
+  const uint32_t batch_size = page_table_indptr->shape[0] - 1;
+  cudaStream_t original_stream = batch_decode_handlers[handler_idx].GetCUDAStream();
+  batch_decode_handlers[handler_idx].SetCUDAStream(static_cast<cudaStream_t>(copy_stream));
+  DISPATCH_TVM_CUDA_IDTYPE(page_table_indptr->dtype, dtype_idx, {
+    cudaError_t status = BatchDecodeHandlerPlan<dtype_in, dtype_in, dtype_in, dtype_idx>(
+        batch_decode_handlers + handler_idx, static_cast<void*>(float_workspace_buffer->data),
+        float_workspace_size_in_bytes, static_cast<void*>(int_workspace_buffer->data),
+        int_workspace_size_in_bytes,
+        static_cast<dtype_idx*>(page_table_indptr->data) +
+            page_table_indptr->byte_offset / sizeof(dtype_idx),
+        static_cast<dtype_idx*>(last_page_len->data) +
+            last_page_len->byte_offset / sizeof(dtype_idx),
+        batch_size, num_qo_heads, num_kv_heads, head_dim, page_size,
+        PosEncodingMode(pos_encoding_mode));
+    if (status != cudaSuccess) {
+      LOG(FATAL) << "FlashInfer decode Plan error " << cudaGetErrorString(status);
+    }
+  });
+  batch_decode_handlers[handler_idx].SetCUDAStream(original_stream);
+}
+
+void _FlashInferAttentionPrefillWithRaggedKVCache(
+    DLTensor* q_data, DLTensor* qo_indptr, DLTensor* k_data, DLTensor* v_data, DLTensor* kv_indptr,
+    DLTensor* q_rope_offset_map, DLTensor* k_rope_offset, DLTensor* output, DLTensor* lse,
+    int64_t causal = 1, int64_t pos_encoding_mode = 0, double rope_scale = 1.0f,
+    double rope_theta = 1e4, double attn_score_scaling_factor = 1.0f) {
+  CHECK_EQ(q_data->device.device_type, kDLCUDA) << "The device of q_data must be CUDA.";
+  CHECK_EQ(qo_indptr->device.device_type, kDLCUDA) << "The device of qo_indptr must be CUDA.";
+  CHECK_EQ(k_data->device.device_type, kDLCUDA) << "The device of k_data must be CUDA.";
+  CHECK_EQ(v_data->device.device_type, kDLCUDA) << "The device of v_data must be CUDA.";
+  CHECK_EQ(kv_indptr->device.device_type, kDLCUDA) << "The device of kv_indptr must be CUDA.";
+  CHECK_EQ(output->device.device_type, kDLCUDA) << "The device of output must be CUDA.";
+  CHECK_EQ(lse->device.device_type, kDLCUDA) << "The lse of output must be CUDA.";
+  CHECK_EQ(q_rope_offset_map->device.device_type, kDLCUDA)
+      << "The device of q_rope_offset_map must be CUDA.";
+  CHECK_EQ(k_rope_offset->device.device_type, kDLCUDA)
+      << "The device of k_rope_offset must be CUDA.";
+
+  int dev_id = q_data->device.device_id;
+  CHECK_EQ(qo_indptr->device.device_id, dev_id);
+  CHECK_EQ(k_data->device.device_id, dev_id);
+  CHECK_EQ(v_data->device.device_id, dev_id);
+  CHECK_EQ(kv_indptr->device.device_id, dev_id);
+  CHECK_EQ(output->device.device_id, dev_id);
+  CHECK_EQ(lse->device.device_id, dev_id);
+  CHECK_EQ(q_rope_offset_map->device.device_id, dev_id);
+  CHECK_EQ(k_rope_offset->device.device_id, dev_id);
+
+  CHECK(q_data->dtype.lanes == 1 && qo_indptr->dtype.lanes == 1 && k_data->dtype.lanes == 1 &&
+        v_data->dtype.lanes == 1 && kv_indptr->dtype.lanes == 1 && output->dtype.lanes == 1 &&
+        lse->dtype.lanes == 1 && q_rope_offset_map->dtype.lanes == 1 &&
+        k_rope_offset->dtype.lanes == 1);
+  CHECK(q_data->dtype.bits == k_data->dtype.bits && q_data->dtype.code == v_data->dtype.code);
+  CHECK(qo_indptr->dtype.bits == kv_indptr->dtype.bits);
+  CHECK(lse->dtype.bits == 32);
+  CHECK(q_data->dtype.code == k_data->dtype.code && q_data->dtype.code == v_data->dtype.code);
+  CHECK(qo_indptr->dtype.code == kv_indptr->dtype.code);
+  CHECK(q_rope_offset_map->dtype.code == kv_indptr->dtype.code);
+  CHECK(k_rope_offset->dtype.code == kv_indptr->dtype.code);
+  CHECK(lse->dtype.code == kDLFloat);
+
+  CHECK_EQ(q_data->ndim, 3);  // qo_nnz, nhead_qo, nfeat
+  CHECK_EQ(output->ndim, 3);  // qo_nnz, nhead_qo, nfeat
+  CHECK_EQ(lse->ndim, 2);     // qo_nnz, nhead_qo
+  CHECK_EQ(k_data->ndim, 3);  // kv_nnz, nhead_kv, nfeat
+  CHECK_EQ(v_data->ndim, 3);  // kv_nnz, nhead_kv, nfeat
+  int64_t nhead_qo = q_data->shape[1];
+  int64_t nfeat = q_data->shape[2];
+  int64_t nhead_kv = k_data->shape[1];
+  CHECK_EQ(output->shape[0], q_data->shape[0]);
+  CHECK_EQ(output->shape[1], nhead_qo);
+  CHECK_EQ(output->shape[2], nfeat);
+  CHECK_EQ(lse->shape[0], q_data->shape[0]);
+  CHECK_EQ(lse->shape[1], nhead_qo);
+  CHECK_EQ(k_data->shape[2], nfeat);
+  CHECK_EQ(v_data->shape[0], k_data->shape[0]);
+  CHECK_EQ(v_data->shape[1], nhead_kv);
+  CHECK_EQ(v_data->shape[2], nfeat);
+
+  CHECK_EQ(qo_indptr->ndim, 1);
+  CHECK_EQ(kv_indptr->ndim, 1);
+  int64_t batch_size = qo_indptr->shape[0] - 1;
+  CHECK_EQ(kv_indptr->shape[0], batch_size + 1);
+
+  CHECK_EQ(q_rope_offset_map->ndim, 1);
+  CHECK_EQ(q_rope_offset_map->shape[0], q_data->shape[0]);
+  CHECK_EQ(k_rope_offset->ndim, 1);
+  CHECK_EQ(k_rope_offset->shape[0], batch_size);
+
+  const float sm_scale = attn_score_scaling_factor / std::sqrt(static_cast<float>(nfeat));
+
+  DISPATCH_TVM_CUDA_DTYPE(
+      q_data->dtype, dtype_in,
+      {DISPATCH_TVM_CUDA_DTYPE(
+          output->dtype, dtype_out, {DISPATCH_TVM_CUDA_IDTYPE(qo_indptr->dtype, dtype_idx, {
+            cudaError_t status =
+                BatchPrefillWithRaggedKVCacheWrapper<dtype_in, dtype_in, dtype_out, dtype_idx>(
+                    &batch_prefill_ragged_kv_handler, static_cast<dtype_in*>(q_data->data),
+                    static_cast<dtype_idx*>(qo_indptr->data) +
+                        qo_indptr->byte_offset / sizeof(dtype_idx),
+                    static_cast<dtype_in*>(k_data->data), static_cast<dtype_in*>(v_data->data),
+                    static_cast<dtype_idx*>(kv_indptr->data) +
+                        kv_indptr->byte_offset / sizeof(dtype_idx),
+                    static_cast<dtype_idx*>(q_rope_offset_map->data) +
+                        q_rope_offset_map->byte_offset / sizeof(dtype_idx),
+                    static_cast<dtype_idx*>(k_rope_offset->data) +
+                        k_rope_offset->byte_offset / sizeof(dtype_idx),
+                    static_cast<dtype_out*>(output->data),
+                    /*lse=*/static_cast<float*>(lse->data), batch_size, nhead_qo, nhead_kv, nfeat,
+                    /*causal=*/bool(causal), QKVLayout::kNHD, PosEncodingMode(pos_encoding_mode),
+                    /*use_fp16_qk_reduction=*/false, sm_scale, rope_scale, rope_theta,
+                    /*sm_scale=*/0);
+            if (status != cudaSuccess) {
+              LOG(FATAL) << "FlashInfer AttentionPrefillWithRaggedKVCache error "
+                         << cudaGetErrorString(status);
+            }
+          })})})
+}
+
+void _FlashInferAttentionPrefillWithRaggedKVCachePlan(DLTensor* float_workspace_buffer,
+                                                      DLTensor* int_workspace_buffer,
+                                                      DLTensor* qo_indptr, DLTensor* kv_indptr,
+                                                      int64_t batch_size, int64_t num_qo_heads,
+                                                      int64_t num_kv_heads, int64_t head_dim,
+                                                      TVMStreamHandle copy_stream) {
+  CHECK_EQ(float_workspace_buffer->ndim, 1) << "The workspace buffer must be a 1-D tensor";
+  size_t float_workspace_size_in_bytes =
+      float_workspace_buffer->shape[0] * float_workspace_buffer->dtype.bits / 8;
+  CHECK_EQ(int_workspace_buffer->ndim, 1) << "The workspace buffer must be a 1-D tensor";
+  size_t int_workspace_size_in_bytes =
+      int_workspace_buffer->shape[0] * int_workspace_buffer->dtype.bits / 8;
+  cudaStream_t original_stream = batch_prefill_ragged_kv_handler.GetCUDAStream();
+  batch_prefill_ragged_kv_handler.SetCUDAStream(static_cast<cudaStream_t>(copy_stream));
+
+  // NOTE(Zihao): here we presume the input data type is half, in the future we should
+  //  leave a parameter for the input data type.
+  using dtype_in = half;
+
+  DISPATCH_TVM_CUDA_IDTYPE(qo_indptr->dtype, dtype_idx, {
+    cudaError_t status = batch_prefill_ragged_kv_handler.Plan<dtype_in, dtype_idx>(
+        static_cast<void*>(float_workspace_buffer->data), float_workspace_size_in_bytes,
+        static_cast<void*>(int_workspace_buffer->data), int_workspace_size_in_bytes,
+        static_cast<dtype_idx*>(qo_indptr->data) + qo_indptr->byte_offset / sizeof(dtype_idx),
+        static_cast<dtype_idx*>(kv_indptr->data) + kv_indptr->byte_offset / sizeof(dtype_idx),
+        batch_size, num_qo_heads, num_kv_heads, head_dim,
+        /*page_size=*/1);
+    if (status != cudaSuccess) {
+      LOG(FATAL) << "FlashInfer PrefillWithRaggedKVCache Plan error " << cudaGetErrorString(status);
+    }
+  });
+  batch_prefill_ragged_kv_handler.SetCUDAStream(original_stream);
+}
+
+void _FlashInferMergeState(DLTensor* v_a, DLTensor* s_a, DLTensor* v_b, DLTensor* s_b,
+                           DLTensor* v_merged, DLTensor* s_merged) {
+  CHECK_EQ(v_a->device.device_type, kDLCUDA) << "The device of v_a must be CUDA.";
+  CHECK_EQ(s_a->device.device_type, kDLCUDA) << "The device of s_a must be CUDA.";
+  CHECK_EQ(v_b->device.device_type, kDLCUDA) << "The device of v_b must be CUDA.";
+  CHECK_EQ(s_b->device.device_type, kDLCUDA) << "The device of s_b must be CUDA.";
+  CHECK_EQ(v_merged->device.device_type, kDLCUDA) << "The device of v_merged must be CUDA.";
+  CHECK_EQ(s_merged->device.device_type, kDLCUDA) << "The device of s_merged must be CUDA.";
+  int32_t dev_id = v_a->device.device_id;
+  CHECK_EQ(s_a->device.device_id, dev_id);
+  CHECK_EQ(v_b->device.device_id, dev_id);
+  CHECK_EQ(s_b->device.device_id, dev_id);
+  CHECK_EQ(v_merged->device.device_id, dev_id);
+  CHECK_EQ(s_merged->device.device_id, dev_id);
+
+  CHECK(v_a->dtype.lanes == 1 && s_a->dtype.lanes == 1 && v_b->dtype.lanes == 1 &&
+        s_b->dtype.lanes == 1 && v_merged->dtype.lanes == 1 && s_merged->dtype.lanes == 1);
+  CHECK(v_a->dtype.bits == v_b->dtype.bits && v_a->dtype.code == v_b->dtype.code);
+  CHECK(s_a->dtype.bits == 32 && s_a->dtype.code == kDLFloat);
+  CHECK(s_b->dtype.bits == 32 && s_b->dtype.code == kDLFloat);
+  CHECK(s_merged->dtype.bits == 32 && s_merged->dtype.code == kDLFloat);
+
+  CHECK_EQ(v_a->ndim, 3);
+  int64_t batch_size = v_a->shape[0];
+  int64_t num_heads = v_a->shape[1];
+  int64_t head_dim = v_a->shape[2];
+  CHECK_EQ(s_a->shape[0], batch_size);
+  CHECK_EQ(s_a->shape[1], num_heads);
+  CHECK_EQ(v_b->shape[0], batch_size);
+  CHECK_EQ(v_b->shape[1], num_heads);
+  CHECK_EQ(v_b->shape[2], head_dim);
+  CHECK_EQ(s_b->shape[0], batch_size);
+  CHECK_EQ(s_b->shape[1], num_heads);
+  CHECK_EQ(v_merged->shape[0], batch_size);
+  CHECK_EQ(v_merged->shape[1], num_heads);
+  CHECK_EQ(v_merged->shape[2], head_dim);
+  CHECK_EQ(s_merged->shape[0], batch_size);
+  CHECK_EQ(s_merged->shape[1], num_heads);
+
+  DISPATCH_TVM_CUDA_DTYPE(
+      v_a->dtype, dtype_in, {DISPATCH_TVM_CUDA_DTYPE(v_merged->dtype, dtype_out, {
+        cudaError_t status =
+            MergeState(static_cast<dtype_in*>(v_a->data), static_cast<float*>(s_a->data),
+                       static_cast<dtype_in*>(v_b->data), static_cast<float*>(s_b->data),
+                       static_cast<dtype_out*>(v_merged->data), static_cast<float*>(s_merged->data),
+                       batch_size, num_heads, head_dim);
+        if (status != cudaSuccess) {
+          LOG(FATAL) << "FlashInfer CUDA MergeState error " << cudaGetErrorString(status);
+        }
+      })});
+}
+
+void _FlashInferMergeStateInPlace(DLTensor* v, DLTensor* s, DLTensor* v_other, DLTensor* s_other) {
+  CHECK_EQ(v->device.device_type, kDLCUDA) << "The device of v must be CUDA.";
+  CHECK_EQ(s->device.device_type, kDLCUDA) << "The device of s must be CUDA.";
+  CHECK_EQ(v_other->device.device_type, kDLCUDA) << "The device of v_other must be CUDA.";
+  CHECK_EQ(s_other->device.device_type, kDLCUDA) << "The device of s_other must be CUDA.";
+  int32_t dev_id = v->device.device_id;
+  CHECK_EQ(s->device.device_id, dev_id);
+  CHECK_EQ(v_other->device.device_id, dev_id);
+  CHECK_EQ(s_other->device.device_id, dev_id);
+
+  CHECK(v->dtype.lanes == 1 && s->dtype.lanes == 1 && v_other->dtype.lanes == 1 &&
+        s_other->dtype.lanes == 1);
+  CHECK(v->dtype.bits == v_other->dtype.bits && v->dtype.code == v_other->dtype.code);
+  CHECK(s->dtype.bits == 32 && s->dtype.code == kDLFloat);
+  CHECK(s_other->dtype.bits == 32 && s_other->dtype.code == kDLFloat);
+
+  CHECK_EQ(v->ndim, 3);
+  CHECK_EQ(v_other->ndim, 3);
+  CHECK_EQ(s->ndim, 2);        // qo_nnz, nhead_qo
+  CHECK_EQ(s_other->ndim, 2);  // qo_nnz, nhead_qo
+  int64_t batch_size = v->shape[0];
+  int64_t num_heads = v->shape[1];
+  int64_t head_dim = v->shape[2];
+  CHECK_EQ(s->shape[0], batch_size);
+  CHECK_EQ(s->shape[1], num_heads);
+  CHECK_EQ(v_other->shape[0], batch_size);
+  CHECK_EQ(v_other->shape[1], num_heads);
+  CHECK_EQ(v_other->shape[2], head_dim);
+  CHECK_EQ(s_other->shape[0], batch_size);
+  CHECK_EQ(s_other->shape[1], num_heads);
+
+  DISPATCH_TVM_CUDA_DTYPE(v->dtype, dtype, {
+    cudaError_t status =
+        MergeStateInPlace(static_cast<dtype*>(v->data), static_cast<float*>(s->data),
+                          static_cast<dtype*>(v_other->data), static_cast<float*>(s_other->data),
+                          batch_size, num_heads, head_dim);
+    if (status != cudaSuccess) {
+      LOG(FATAL) << "FlashInfer CUDA MergeStateInPlace error " << cudaGetErrorString(status);
+    }
+  });
+}
+
+void _FlashInferBatchQKApplyRotaryInPlace(DLTensor* q, DLTensor* k, DLTensor* indptr,
+                                          DLTensor* offsets, int64_t batch_size,
+                                          int64_t num_qo_heads, int64_t num_kv_heads,
+                                          int64_t head_dim, double rope_scale, double rope_theta) {
+  size_t q_stride_n = q->strides[0];
+  size_t q_stride_h = q->strides[1];
+  size_t k_stride_n = k->strides[0];
+  size_t k_stride_h = k->strides[1];
+  DISPATCH_TVM_CUDA_DTYPE(
+      q->dtype, dtype, {DISPATCH_TVM_CUDA_IDTYPE(indptr->dtype, idtype, {
+        cudaError_t status = BatchQKApplyRotaryInPlace(
+            static_cast<dtype*>(q->data), static_cast<dtype*>(k->data),
+            static_cast<idtype*>(indptr->data), static_cast<idtype*>(offsets->data), batch_size,
+            num_qo_heads, num_kv_heads, /*rotary_dim=*/head_dim, head_dim, q_stride_n, q_stride_h,
+            k_stride_n, k_stride_h,
+            /*interleave=*/false, rope_scale, rope_theta);
+        if (status != cudaSuccess) {
+          LOG(FATAL) << "FlashInfer CUDA kernel error " << cudaGetErrorString(status);
+        }
+      })});
+}
+
+void _FlashInferParallelSamplingFromProb(DLTensor* probs, DLTensor* uniform_samples,
+                                         DLTensor* row_indices, DLTensor* sampled_token_ids) {
+  CHECK_EQ(probs->device.device_type, kDLCUDA) << "The device of probs must be CUDA.";
+  CHECK_EQ(uniform_samples->device.device_type, kDLCUDA)
+      << "The device of uniform_samples must be CUDA.";
+  CHECK_EQ(row_indices->device.device_type, kDLCUDA) << "The device of row_indices must be CUDA.";
+  CHECK_EQ(sampled_token_ids->device.device_type, kDLCUDA)
+      << "The device of sampled_token_ids must be CUDA.";
+
+  int dev_id = probs->device.device_id;
+  CHECK_EQ(uniform_samples->device.device_id, dev_id);
+  CHECK_EQ(row_indices->device.device_id, dev_id);
+  CHECK_EQ(sampled_token_ids->device.device_id, dev_id);
+
+  CHECK(probs->dtype.lanes == 1 && uniform_samples->dtype.lanes == 1 &&
+        row_indices->dtype.lanes == 1 && sampled_token_ids->dtype.lanes == 1);
+  CHECK(probs->dtype.code == kDLFloat && probs->dtype.bits == 32);
+  CHECK(uniform_samples->dtype.code == kDLFloat && uniform_samples->dtype.bits == 32);
+  CHECK(row_indices->dtype.code == kDLInt && row_indices->dtype.bits == 32);
+  CHECK(sampled_token_ids->dtype.code == kDLInt && sampled_token_ids->dtype.bits == 32);
+
+  CHECK_EQ(probs->ndim, 2);              // num_probs, vocab_size
+  CHECK_EQ(uniform_samples->ndim, 1);    // batch_size,
+  CHECK_EQ(row_indices->ndim, 1);        // batch_size,
+  CHECK_EQ(sampled_token_ids->ndim, 1);  // batch_size,
+  int64_t num_probs = probs->shape[0];
+  int64_t vocab_size = probs->shape[1];
+  int64_t batch_size = row_indices->shape[0];
+  CHECK_EQ(uniform_samples->shape[0], batch_size);
+  CHECK_EQ(sampled_token_ids->shape[0], batch_size);
+
+  cudaError_t status = sampling::ParallelSamplingFromProb<float, int32_t>(
+      static_cast<float*>(probs->data), static_cast<float*>(uniform_samples->data),
+      static_cast<int32_t*>(sampled_token_ids->data), static_cast<int32_t*>(row_indices->data),
+      batch_size, vocab_size, /*deterministic=*/true);
+  if (status != cudaSuccess) {
+    LOG(FATAL) << "FlashInfer ParallelTopPSamplingFromProb error " << cudaGetErrorString(status);
+  }
+}
+
+void _FlashInferParallelTopPSamplingFromProb(DLTensor* probs, DLTensor* uniform_samples,
+                                             DLTensor* row_indices, DLTensor* top_p,
+                                             DLTensor* sampled_token_ids) {
+  CHECK_EQ(probs->device.device_type, kDLCUDA) << "The device of probs must be CUDA.";
+  CHECK_EQ(uniform_samples->device.device_type, kDLCUDA)
+      << "The device of uniform_samples must be CUDA.";
+  CHECK_EQ(row_indices->device.device_type, kDLCUDA) << "The device of row_indices must be CUDA.";
+  CHECK_EQ(top_p->device.device_type, kDLCUDA) << "The device of top_p must be CUDA.";
+  CHECK_EQ(sampled_token_ids->device.device_type, kDLCUDA)
+      << "The device of sampled_token_ids must be CUDA.";
+
+  int dev_id = probs->device.device_id;
+  CHECK_EQ(uniform_samples->device.device_id, dev_id);
+  CHECK_EQ(row_indices->device.device_id, dev_id);
+  CHECK_EQ(top_p->device.device_id, dev_id);
+  CHECK_EQ(sampled_token_ids->device.device_id, dev_id);
+
+  CHECK(probs->dtype.lanes == 1 && uniform_samples->dtype.lanes == 1 &&
+        row_indices->dtype.lanes == 1 && top_p->dtype.lanes == 1 &&
+        sampled_token_ids->dtype.lanes == 1);
+  CHECK(probs->dtype.code == kDLFloat && probs->dtype.bits == 32);
+  CHECK(uniform_samples->dtype.code == kDLFloat && uniform_samples->dtype.bits == 32);
+  CHECK(top_p->dtype.code == kDLFloat && top_p->dtype.bits == 32);
+  CHECK(row_indices->dtype.code == kDLInt && row_indices->dtype.bits == 32);
+  CHECK(sampled_token_ids->dtype.code == kDLInt && sampled_token_ids->dtype.bits == 32);
+
+  CHECK_EQ(probs->ndim, 2);              // num_probs, vocab_size
+  CHECK_EQ(uniform_samples->ndim, 2);    // num_rounds, batch_size
+  CHECK_EQ(row_indices->ndim, 1);        // batch_size,
+  CHECK_EQ(top_p->ndim, 1);              // num_probs,
+  CHECK_EQ(sampled_token_ids->ndim, 1);  // batch_size,
+  int64_t num_probs = probs->shape[0];
+  int64_t vocab_size = probs->shape[1];
+  int64_t batch_size = row_indices->shape[0];
+  int64_t num_rounds = uniform_samples->shape[0];
+  CHECK_EQ(uniform_samples->shape[1], batch_size);
+  CHECK_EQ(top_p->shape[0], num_probs);
+  CHECK_EQ(sampled_token_ids->shape[0], batch_size);
+
+  cudaError_t status = sampling::ParallelTopPSamplingFromProb<float, int32_t>(
+      static_cast<float*>(probs->data), static_cast<float*>(uniform_samples->data),
+      static_cast<int32_t*>(sampled_token_ids->data), /*success=*/nullptr,
+      static_cast<int32_t*>(row_indices->data), static_cast<float*>(top_p->data), batch_size,
+      vocab_size, num_rounds, /*deterministic=*/true);
+  if (status != cudaSuccess) {
+    LOG(FATAL) << "FlashInfer ParallelTopPSamplingFromProb error " << cudaGetErrorString(status);
+  }
+}
+
+TVM_REGISTER_GLOBAL("flashinfer.attention_kernel_prefill_with_paged_kv_cache")
+    .set_body_typed(_FlashInferAttentionPrefillWithPagedKVCache);
+
+TVM_REGISTER_GLOBAL("flashinfer.attention_kernel_prefill_with_paged_kv_cache_begin_forward")
+    .set_body_typed(_FlashInferAttentionPrefillWithPagedKVCachePlan);
+
+TVM_REGISTER_GLOBAL("flashinfer.attention_kernel_decode_with_paged_kv_cache")
+    .set_body_typed(_FlashInferAttentionDecodeWithPagedKVCache);
+
+TVM_REGISTER_GLOBAL("flashinfer.attention_kernel_decode_with_paged_kv_cache_begin_forward")
+    .set_body_typed(_FlashInferAttentionDecodeWithPagedKVCachePlan);
+
+TVM_REGISTER_GLOBAL("flashinfer.attention_kernel_prefill_with_ragged_kv_cache")
+    .set_body_typed(_FlashInferAttentionPrefillWithRaggedKVCache);
+
+TVM_REGISTER_GLOBAL("flashinfer.attention_kernel_prefill_with_ragged_kv_cache_begin_forward")
+    .set_body_typed(_FlashInferAttentionPrefillWithRaggedKVCachePlan);
+
+TVM_REGISTER_GLOBAL("flashinfer.merge_state").set_body_typed(_FlashInferMergeState);
+
+TVM_REGISTER_GLOBAL("flashinfer.merge_state_in_place").set_body_typed(_FlashInferMergeStateInPlace);
+
+TVM_REGISTER_GLOBAL("flashinfer.batch_qk_apply_rotary_in_place")
+    .set_body_typed(_FlashInferBatchQKApplyRotaryInPlace);
+
+TVM_REGISTER_GLOBAL("flashinfer.single_prefill")
+    .set_body_typed(_FlashInferSinglePrefillWithKVCache);
+
+TVM_REGISTER_GLOBAL("flashinfer.single_decode").set_body_typed(_FlashInferSingleDecodeWithKVCache);
+
+TVM_REGISTER_GLOBAL("flashinfer.sampling.parallel_sampling_from_prob")
+    .set_body_typed(_FlashInferParallelSamplingFromProb);
+
+TVM_REGISTER_GLOBAL("flashinfer.sampling.parallel_top_p_sampling_from_prob")
+    .set_body_typed(_FlashInferParallelTopPSamplingFromProb);

sglang_repo/sgl-kernel/3rdparty/flashinfer/src/utils.h

@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) 2023 by FlashInfer team.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <cuda_bf16.h>
+#include <cuda_fp16.h>
+#include <cuda_fp8.h>
+#include <cuda_runtime.h>
+#include <thrust/device_vector.h>
+#include <thrust/execution_policy.h>
+#include <thrust/host_vector.h>
+#include <thrust/iterator/counting_iterator.h>
+#include <thrust/random.h>
+#include <thrust/transform.h>
+
+#include <random>
+#include <sstream>
+
+#include "flashinfer/exception.h"
+#include "generated/dispatch.inc"
+
+#define _DISPATCH_SWITCH(var_name, cond, ...)                                         \
+  switch (cond) {                                                                     \
+    __VA_ARGS__                                                                       \
+    default:                                                                          \
+      std::ostringstream oss;                                                         \
+      oss << __PRETTY_FUNCTION__ << " failed to dispatch " var_name " " << int(cond); \
+      FLASHINFER_ERROR(oss.str());                                                    \
+  }
+
+#define _DISPATCH_CASE(case_expr, case_var, ...) \
+  case case_expr: {                              \
+    constexpr auto case_var = case_expr;         \
+    __VA_ARGS__                                  \
+    break;                                       \
+  }
+
+#define DISPATCH_group_size(expr, const_expr, ...) \
+  _DISPATCH_SWITCH("group_size", expr, _DISPATCH_CASES_group_size(const_expr, __VA_ARGS__))
+
+#define DISPATCH_head_dim(expr, const_expr, ...) \
+  _DISPATCH_SWITCH("head_dim", expr, _DISPATCH_CASES_head_dim(const_expr, __VA_ARGS__))
+
+#define DISPATCH_pos_encoding_mode(expr, const_expr, ...) \
+  _DISPATCH_SWITCH("positional encoding mode", expr,      \
+                   _DISPATCH_CASES_pos_encoding_mode(const_expr, __VA_ARGS__))
+
+#define DISPATCH_use_fp16_qk_reduction(expr, const_expr, ...) \
+  _DISPATCH_SWITCH("use_fp16_qk_reduction", expr,             \
+                   _DISPATCH_CASES_use_fp16_qk_reduction(const_expr, __VA_ARGS__))
+
+#define DISPATCH_mask_mode(expr, const_expr, ...) \
+  _DISPATCH_SWITCH("mask_mode", expr, _DISPATCH_CASES_mask_mode(const_expr, __VA_ARGS__))
+
+namespace utils {
+
+template <typename T>
+void vec_normal_(std::vector<T>& vec, float mean = 0.f, float std = 1.f) {
+  std::random_device rd{};
+  std::mt19937 gen{rd()};
+  std::normal_distribution d{mean, std};
+  for (size_t i = 0; i < vec.size(); ++i) {
+    vec[i] = T(d(gen));
+  }
+}
+
+template <typename T>
+void vec_uniform_(std::vector<T>& vec, float a = 0.f, float b = 1.f) {
+  std::random_device rd{};
+  std::mt19937 gen{rd()};
+  std::uniform_real_distribution d{a, b};
+  for (size_t i = 0; i < vec.size(); ++i) {
+    vec[i] = T(d(gen));
+  }
+}
+
+template <typename T>
+void vec_zero_(std::vector<T>& vec) {
+  std::fill(vec.begin(), vec.end(), T(0));
+}
+
+template <typename T>
+void vec_fill_(std::vector<T>& vec, T val) {
+  std::fill(vec.begin(), vec.end(), val);
+}
+
+template <typename T>
+void vec_randint_(std::vector<T>& vec, int low, int high) {
+  std::random_device rd{};
+  std::mt19937 gen{rd()};
+  std::uniform_int_distribution d{low, high};
+  for (size_t i = 0; i < vec.size(); ++i) {
+    vec[i] = T(d(gen));
+  }
+}
+
+template <typename T>
+size_t vec_bytes(const T& vec) {
+  return vec.size() * sizeof(typename T::value_type);
+}
+
+template <typename T>
+bool isclose(T a, T b, float rtol = 1e-5, float atol = 1e-8) {
+  return fabs(a - b) <= (atol + rtol * fabs(b));
+}
+
+template <typename T>
+std::tuple<std::vector<std::vector<T>>, std::vector<std::vector<int32_t>>>
+create_shared_prefix_testcase_data(size_t batch_size, size_t shared_prefix_length,
+                                   size_t unique_kv_length, size_t qo_append_length,
+                                   size_t num_qo_heads, size_t num_kv_heads, size_t head_dim,
+                                   size_t page_size) {
+  uint32_t num_pages = ((shared_prefix_length + unique_kv_length * batch_size) / page_size);
+  std::vector<T> shared_k_h(shared_prefix_length * num_kv_heads * head_dim);
+  std::vector<T> shared_v_h(shared_prefix_length * num_kv_heads * head_dim);
+  std::vector<T> q_h((batch_size * qo_append_length) * num_qo_heads * head_dim);
+
+  utils::vec_normal_(shared_k_h);
+  utils::vec_normal_(shared_v_h);
+  utils::vec_normal_(q_h);
+
+  std::vector<int32_t> qo_indptr{0};
+  std::vector<int32_t> kv_indptr_combined_h{0};
+  std::vector<int32_t> kv_indptr_unique_h{0};
+  std::vector<int32_t> kv_last_page_len_combined_h;
+  std::vector<int32_t> kv_last_page_len_unique_h;
+
+  for (uint32_t request_id = 0; request_id < batch_size; ++request_id) {
+    qo_indptr.push_back(qo_indptr.back() + qo_append_length);
+    kv_indptr_combined_h.push_back(kv_indptr_combined_h.back() +
+                                   (shared_prefix_length + unique_kv_length) / page_size);
+    kv_indptr_unique_h.push_back(kv_indptr_unique_h.back() + unique_kv_length / page_size);
+    kv_last_page_len_combined_h.push_back(page_size);
+    kv_last_page_len_unique_h.push_back(page_size);
+  }
+
+  std::vector<int32_t> kv_indices_combined_h(kv_indptr_combined_h.back());
+  std::vector<int32_t> kv_indices_unique_h(kv_indptr_unique_h.back());
+
+  std::vector<T> k_data_h(num_pages * num_kv_heads * page_size * head_dim);
+  std::vector<T> v_data_h(num_pages * num_kv_heads * page_size * head_dim);
+  uint32_t page_id = 0;
+
+  for (; page_id < (shared_prefix_length / page_size); page_id++) {
+    for (uint32_t entry_idx = 0; entry_idx < page_size; entry_idx++) {
+      for (uint32_t head_idx = 0; head_idx < num_kv_heads; head_idx++) {
+        std::copy(shared_k_h.begin() +
+                      ((page_id * page_size + entry_idx) * num_kv_heads + head_idx) * head_dim,
+                  shared_k_h.begin() +
+                      ((page_id * page_size + entry_idx) * num_kv_heads + head_idx + 1) * head_dim,
+                  k_data_h.begin() +
+                      ((page_id * num_kv_heads + head_idx) * page_size + entry_idx) * head_dim);
+        std::copy(shared_v_h.begin() +
+                      ((page_id * page_size + entry_idx) * num_kv_heads + head_idx) * head_dim,
+                  shared_v_h.begin() +
+                      ((page_id * page_size + entry_idx) * num_kv_heads + head_idx + 1) * head_dim,
+                  v_data_h.begin() +
+                      ((page_id * num_kv_heads + head_idx) * page_size + entry_idx) * head_dim);
+      }
+    }
+    for (uint32_t request_id = 0; request_id < batch_size; ++request_id) {
+      kv_indices_combined_h[request_id * ((shared_prefix_length + unique_kv_length) / page_size) +
+                            page_id] = page_id;
+    }
+  }
+
+  for (uint32_t request_id = 0; request_id < batch_size; ++request_id) {
+    for (uint32_t page_iter = 0; page_iter < (unique_kv_length / page_size);
+         ++page_iter, ++page_id) {
+      for (uint32_t entry_idx = 0; entry_idx < page_size; entry_idx++) {
+        for (uint32_t head_idx = 0; head_idx < num_kv_heads; head_idx++) {
+          std::vector<T> k(head_dim), v(head_dim);
+          utils::vec_normal_(k);
+          utils::vec_normal_(v);
+          std::copy(k.begin(), k.end(),
+                    k_data_h.begin() +
+                        ((page_id * num_kv_heads + head_idx) * page_size + entry_idx) * head_dim);
+          std::copy(v.begin(), v.end(),
+                    v_data_h.begin() +
+                        ((page_id * num_kv_heads + head_idx) * page_size + entry_idx) * head_dim);
+        }
+      }
+      kv_indices_combined_h[request_id * ((shared_prefix_length + unique_kv_length) / page_size) +
+                            (shared_prefix_length / page_size) + page_iter] = page_id;
+      kv_indices_unique_h[request_id * (unique_kv_length / page_size) + page_iter] = page_id;
+    }
+  }
+  return std::make_tuple<std::vector<std::vector<T>>, std::vector<std::vector<int32_t>>>(
+      {std::move(q_h), std::move(shared_k_h), std::move(shared_v_h), std::move(k_data_h),
+       std::move(v_data_h)},
+      {std::move(qo_indptr), std::move(kv_indices_combined_h), std::move(kv_indices_unique_h),
+       std::move(kv_indptr_combined_h), std::move(kv_indptr_unique_h),
+       std::move(kv_last_page_len_combined_h), std::move(kv_last_page_len_unique_h)});
+}
+
+}  // namespace utils

sglang_repo/sgl-kernel/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2023-2024 SGLang Team
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

sglang_repo/sgl-kernel/Makefile

@@ -0,0 +1,28 @@
+.PHONY: tree ln submodule install build clean rebuild test format
+
+tree:
+	@tree --prune -I "__pycache__|*.egg-info|*.so|build|3rdparty|dist"
+
+submodule:
+	@git submodule update --init --recursive
+
+ln: submodule
+	@rm -rf build && bear python3 setup.py build
+
+install: submodule
+	@pip install -e .
+
+build: submodule
+	@rm -rf dist/* || true && export MAX_JOBS=$(nproc) && python3 setup.py bdist_wheel && pip3 install dist/*whl --force-reinstall --no-deps
+
+clean:
+	@rm -rf build dist *.egg-info
+
+rebuild: clean submodule build
+	@echo "Succeed to rebuild"
+
+test:
+	@find tests -name "test_*.py" | xargs -n 1 python3
+
+format:
+	@find src tests -name '*.cc' -o -name '*.cu' -o -name '*.cuh' -o -name '*.h' -o -name '*.hpp' | xargs clang-format -i && find src tests -name '*.py' | xargs isort && find src tests -name '*.py' | xargs black