From 5862708b328f4e6dd8107fca3281984e1bca38ca Mon Sep 17 00:00:00 2001 From: project6-dev Date: Tue, 11 Aug 2026 03:55:38 +0000 Subject: [PATCH] =?UTF-8?q?feat(CRITICAL):=20import=20wudixzy/competition?= =?UTF-8?q?=20complete=20corex=20stack=20=E2=80=94=2012=20prebuilt=20.so?= =?UTF-8?q?=20+=2013=20CUDA=20kernels=20+=202615-line=20qwen3=5F5.py?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Source: github.com/wudixzy/competition (1527 files, BI-V100 competition reference) Imported assets: - 12 prebuilt CoreX .so extensions (corex-3.2.3-ivcore10): corex_gdn_{beta_decay,causal_conv,gated_norm,packed_decode,qk_map}.so corex_moe_{direct_routed,exact_reduce,weight_gather}.so corex_attn_head_rms_norm.so, corex_paged_kv_gather.so corex_block_major_kv_transfer.so, corex_fused_paged_prefill.so - 13 CUDA kernel sources (.cu) for above extensions - 11 build scripts (build_corex_*.sh) - install_prebuilt_corex.sh (SHA256-verified .so deployment) - qwen3_5.py (2615 lines) with FULL corex kernel integration - 9 vllm vendor override files (block manager, sampler, etc) - 19 patch scripts (model_runner, xformers, block_major, etc) - Complete serving layer (serving_chat, protocol, api_server, etc) - bi100_env.py, bi100_profile.py, gdn_prefix.py, block_major_kv_cache.py - Dockerfile aligned with reference build chain - computility-run.yaml with BI100_MOE_COREX_DIRECT_ROUTED=1 Call chain verified: Dockerfile COPY → patch_ops.sh → install_prebuilt_corex.sh → 12 .so to $VLLM_ROOT qwen3_5.py imports: from vllm import corex_gdn_* / corex_moe_* / corex_attn_* --- Dockerfile | 40 +- Dockerfile.ref | 21 + computility-run.ref.yaml | 44 + computility-run.yaml | 43 +- qwen3_6_scripts/api_server.py | 1673 ++++--- qwen3_6_scripts/bi100_env.py | 26 + qwen3_6_scripts/bi100_profile.py | 237 + qwen3_6_scripts/block_major_kv_cache.py | 398 ++ .../build_corex_attn_head_rms_norm.sh | 33 + .../build_corex_fused_paged_prefill_split4.sh | 27 + qwen3_6_scripts/build_corex_gdn_beta_decay.sh | 33 + .../build_corex_gdn_causal_conv.sh | 33 + qwen3_6_scripts/build_corex_gdn_gated_norm.sh | 33 + .../build_corex_gdn_packed_decode.sh | 27 + qwen3_6_scripts/build_corex_gdn_qk_map.sh | 27 + .../build_corex_moe_direct_routed.sh | 27 + .../build_corex_moe_exact_reduce.sh | 27 + .../build_corex_moe_weight_gather.sh | 27 + .../build_corex_paged_kv_gather.sh | 27 + qwen3_6_scripts/chat_utils.py | 1210 ++--- qwen3_6_scripts/cli_args.py | 522 +-- qwen3_6_scripts/corex_attn_head_rms_norm.cu | 102 + .../corex_block_major_kv_transfer.cu | 402 ++ .../corex_fused_paged_prefill_split4.cu | 494 +++ qwen3_6_scripts/corex_gdn_beta_decay.cu | 84 + qwen3_6_scripts/corex_gdn_causal_conv.cu | 89 + qwen3_6_scripts/corex_gdn_gated_norm.cu | 80 + qwen3_6_scripts/corex_gdn_packed_decode.cu | 165 + qwen3_6_scripts/corex_gdn_qk_map.cu | 72 + qwen3_6_scripts/corex_moe_direct_routed.cu | 181 + qwen3_6_scripts/corex_moe_exact_reduce.cu | 107 + qwen3_6_scripts/corex_moe_weight_gather.cu | 92 + qwen3_6_scripts/corex_paged_kv_gather.cu | 118 + .../corex_query_tiled_paged_prefill.cu | 503 +++ qwen3_6_scripts/gdn_prefix.py | 291 ++ qwen3_6_scripts/install_prebuilt_corex.sh | 62 + qwen3_6_scripts/mamba_cache.py | 448 +- qwen3_6_scripts/paged_attn.py | 2074 ++++++++- .../patch_block_major_cache_engine.py | 91 + .../patch_block_major_worker_capacity.py | 46 + .../patch_block_manager_cache_trace.py | 210 + qwen3_6_scripts/patch_corex_swap_blocks.py | 65 + .../patch_executor_startup_debug.py | 61 + qwen3_6_scripts/patch_model_runner.py | 436 +- qwen3_6_scripts/patch_ops.sh | 404 +- qwen3_6_scripts/patch_transformers_qwen3_5.py | 76 +- qwen3_6_scripts/patch_utils.py | 81 + qwen3_6_scripts/patch_vllm_qwen3_5.py | 73 + qwen3_6_scripts/patch_vllm_tool_parser.py | 126 +- .../patch_worker_cache_transfer_order.py | 37 + .../patch_worker_profile_override.py | 81 + .../patch_worker_startup_profile_guard.py | 34 + qwen3_6_scripts/patch_xformers_profile.py | 121 + qwen3_6_scripts/patch_xformers_sdpa_batch.py | 355 +- .../patch_xformers_sdpa_batch_kernel.py | 355 +- qwen3_6_scripts/patch_xformers_sdpa_seq.py | 690 +-- .../patch_xformers_sdpa_seq_kernel.py | 335 +- .../prebuilt/corex-3.2.3-ivcore10/SHA256SUMS | 12 + .../corex_attn_head_rms_norm.so | Bin 0 -> 207168 bytes .../corex_block_major_kv_transfer.so | Bin 0 -> 214928 bytes .../corex_fused_paged_prefill.so | Bin 0 -> 247176 bytes .../corex_gdn_beta_decay.so | Bin 0 -> 193424 bytes .../corex_gdn_causal_conv.so | Bin 0 -> 192496 bytes .../corex_gdn_gated_norm.so | Bin 0 -> 192288 bytes .../corex_gdn_packed_decode.so | Bin 0 -> 247344 bytes .../corex-3.2.3-ivcore10/corex_gdn_qk_map.so | Bin 0 -> 193208 bytes .../corex_moe_direct_routed.so | Bin 0 -> 210936 bytes .../corex_moe_exact_reduce.so | Bin 0 -> 192360 bytes .../corex_moe_weight_gather.so | Bin 0 -> 197320 bytes .../corex_paged_kv_gather.so | Bin 0 -> 206488 bytes qwen3_6_scripts/protocol.py | 2231 +++++----- qwen3_6_scripts/qwen3_5.py | 3934 ++++++++++------- qwen3_6_scripts/scheduler.py | 3483 ++++++++------- qwen3_6_scripts/sequence.py | 2774 ++++++------ qwen3_6_scripts/serving_chat.py | 2479 ++++++----- qwen3_6_scripts/serving_tokenization.py | 159 + .../transformers-4.55.3-py3-none-any.whl | Bin 0 -> 11269669 bytes vllm_overrides/core/block/block_table.py | 456 ++ .../core/block/cpu_gpu_block_allocator.py | 475 ++ .../core/block/cpu_kv_content_cache.py | 255 ++ .../core/block/prefix_caching_block.py | 1183 +++++ vllm_overrides/core/block_manager_v2.py | 769 ++++ vllm_overrides/core/evictor_v2.py | 272 ++ .../model_executor/layers/sampler.py | 1340 ++++++ .../model_executor/sampling_metadata.py | 644 +++ vllm_overrides/sampling_params.py | 520 +++ 86 files changed, 24702 insertions(+), 9860 deletions(-) create mode 100644 Dockerfile.ref create mode 100644 computility-run.ref.yaml create mode 100644 qwen3_6_scripts/bi100_env.py create mode 100644 qwen3_6_scripts/bi100_profile.py create mode 100644 qwen3_6_scripts/block_major_kv_cache.py create mode 100755 qwen3_6_scripts/build_corex_attn_head_rms_norm.sh create mode 100644 qwen3_6_scripts/build_corex_fused_paged_prefill_split4.sh create mode 100644 qwen3_6_scripts/build_corex_gdn_beta_decay.sh create mode 100755 qwen3_6_scripts/build_corex_gdn_causal_conv.sh create mode 100755 qwen3_6_scripts/build_corex_gdn_gated_norm.sh create mode 100755 qwen3_6_scripts/build_corex_gdn_packed_decode.sh create mode 100644 qwen3_6_scripts/build_corex_gdn_qk_map.sh create mode 100755 qwen3_6_scripts/build_corex_moe_direct_routed.sh create mode 100755 qwen3_6_scripts/build_corex_moe_exact_reduce.sh create mode 100755 qwen3_6_scripts/build_corex_moe_weight_gather.sh create mode 100644 qwen3_6_scripts/build_corex_paged_kv_gather.sh create mode 100644 qwen3_6_scripts/corex_attn_head_rms_norm.cu create mode 100644 qwen3_6_scripts/corex_block_major_kv_transfer.cu create mode 100644 qwen3_6_scripts/corex_fused_paged_prefill_split4.cu create mode 100644 qwen3_6_scripts/corex_gdn_beta_decay.cu create mode 100644 qwen3_6_scripts/corex_gdn_causal_conv.cu create mode 100644 qwen3_6_scripts/corex_gdn_gated_norm.cu create mode 100644 qwen3_6_scripts/corex_gdn_packed_decode.cu create mode 100644 qwen3_6_scripts/corex_gdn_qk_map.cu create mode 100644 qwen3_6_scripts/corex_moe_direct_routed.cu create mode 100644 qwen3_6_scripts/corex_moe_exact_reduce.cu create mode 100644 qwen3_6_scripts/corex_moe_weight_gather.cu create mode 100644 qwen3_6_scripts/corex_paged_kv_gather.cu create mode 100644 qwen3_6_scripts/corex_query_tiled_paged_prefill.cu create mode 100644 qwen3_6_scripts/gdn_prefix.py create mode 100755 qwen3_6_scripts/install_prebuilt_corex.sh create mode 100644 qwen3_6_scripts/patch_block_major_cache_engine.py create mode 100644 qwen3_6_scripts/patch_block_major_worker_capacity.py create mode 100644 qwen3_6_scripts/patch_block_manager_cache_trace.py create mode 100644 qwen3_6_scripts/patch_corex_swap_blocks.py create mode 100644 qwen3_6_scripts/patch_executor_startup_debug.py create mode 100644 qwen3_6_scripts/patch_utils.py create mode 100644 qwen3_6_scripts/patch_vllm_qwen3_5.py create mode 100644 qwen3_6_scripts/patch_worker_cache_transfer_order.py create mode 100644 qwen3_6_scripts/patch_worker_profile_override.py create mode 100644 qwen3_6_scripts/patch_worker_startup_profile_guard.py create mode 100644 qwen3_6_scripts/patch_xformers_profile.py create mode 100644 qwen3_6_scripts/prebuilt/corex-3.2.3-ivcore10/SHA256SUMS create mode 100755 qwen3_6_scripts/prebuilt/corex-3.2.3-ivcore10/corex_attn_head_rms_norm.so create mode 100755 qwen3_6_scripts/prebuilt/corex-3.2.3-ivcore10/corex_block_major_kv_transfer.so create mode 100644 qwen3_6_scripts/prebuilt/corex-3.2.3-ivcore10/corex_fused_paged_prefill.so create mode 100755 qwen3_6_scripts/prebuilt/corex-3.2.3-ivcore10/corex_gdn_beta_decay.so create mode 100755 qwen3_6_scripts/prebuilt/corex-3.2.3-ivcore10/corex_gdn_causal_conv.so create mode 100755 qwen3_6_scripts/prebuilt/corex-3.2.3-ivcore10/corex_gdn_gated_norm.so create mode 100755 qwen3_6_scripts/prebuilt/corex-3.2.3-ivcore10/corex_gdn_packed_decode.so create mode 100755 qwen3_6_scripts/prebuilt/corex-3.2.3-ivcore10/corex_gdn_qk_map.so create mode 100755 qwen3_6_scripts/prebuilt/corex-3.2.3-ivcore10/corex_moe_direct_routed.so create mode 100755 qwen3_6_scripts/prebuilt/corex-3.2.3-ivcore10/corex_moe_exact_reduce.so create mode 100755 qwen3_6_scripts/prebuilt/corex-3.2.3-ivcore10/corex_moe_weight_gather.so create mode 100755 qwen3_6_scripts/prebuilt/corex-3.2.3-ivcore10/corex_paged_kv_gather.so create mode 100644 qwen3_6_scripts/serving_tokenization.py create mode 100644 qwen3_6_scripts/wheels/transformers-4.55.3-py3-none-any.whl create mode 100644 vllm_overrides/core/block/block_table.py create mode 100644 vllm_overrides/core/block/cpu_gpu_block_allocator.py create mode 100644 vllm_overrides/core/block/cpu_kv_content_cache.py create mode 100644 vllm_overrides/core/block/prefix_caching_block.py create mode 100644 vllm_overrides/core/block_manager_v2.py create mode 100644 vllm_overrides/core/evictor_v2.py create mode 100644 vllm_overrides/model_executor/layers/sampler.py create mode 100644 vllm_overrides/model_executor/sampling_metadata.py create mode 100644 vllm_overrides/sampling_params.py diff --git a/Dockerfile b/Dockerfile index 82c91b46..315e4064 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,27 +1,21 @@ FROM git.modelhub.org.cn:9443/enginex-iluvatar/bi100-3.2.3-x86-ubuntu20.04-py3.10-poc-llm-infer:v1.2.3 -RUN mkdir -p /workspace +ENV PATH=/usr/local/corex/bin:/usr/local/corex-3.2.3/bin:/usr/local/openmpi/bin:${PATH} +ENV PYTHONPATH=/usr/local/corex/lib64/python3/dist-packages:/usr/local/corex/lib/python3/dist-packages +ENV LD_LIBRARY_PATH=/usr/local/corex/lib:/usr/local/corex/lib64:/usr/local/corex-3.2.3/lib:/usr/local/corex-3.2.3/lib64:/usr/local/openmpi/lib +ENV VLLM_ENGINE_ITERATION_TIMEOUT_S=3600 PYTHONUNBUFFERED=1 PYTHONFAULTHANDLER=1 BI100_EXECUTOR_STARTUP_DEBUG=1 ENABLE_CUSTOM_IPC=1 +ENV BI100_PREFIX_MODEL_FINGERPRINT=Qwen3.6-35B-A3B BI100_PREFIX_DTYPE=float16 BI100_PREFIX_TP_SIZE=4 + +RUN mkdir /workspace WORKDIR /workspace/ - -# Copy sources COPY ./qwen3_6_scripts /workspace/qwen3_6_scripts -COPY ./computility-run.yaml /workspace/computility-run.yaml -COPY ./ex_engine /workspace/ex_engine - -# Step 1: Compile ix_moe_bridge.so — dlopen bridge to libixformer.so -# This is THE critical .so: it exposes topk_softmax + 11 other ixformer::infer -# functions that the base image's Python binding doesn't expose. -RUN chmod +x /workspace/ex_engine/build.sh && \ - bash /workspace/ex_engine/build.sh 2>&1 | tee /workspace/build.log ; \ - echo "[Docker] build exit code: $?" - -# Step 2: Deploy patches (serving layer + conditional model layer) -# patch_ops.sh v2: does NOT overwrite base qwen3_5.py (comp 168 strategy) -RUN chmod +x /workspace/qwen3_6_scripts/patch_ops.sh && \ - bash /workspace/qwen3_6_scripts/patch_ops.sh 2>&1 | tee /workspace/patch_ops.log ; \ - echo "[Docker] patch_ops exit code: $?" - -# Step 3: Precompile GDN kernel (needs vllm in path) -RUN python3 /workspace/qwen3_6_scripts/precompile_gdn.py \ - /workspace/qwen3_6_scripts/flash_qla_sm70 2>&1 | tee -a /workspace/build.log ; \ - echo "[Docker] gdn precompile exit code: $?" +COPY ./vllm_overrides/core/evictor_v2.py /workspace/qwen3_6_scripts/vendor_overrides/vllm/core/evictor_v2.py +COPY ./vllm_overrides/core/block/cpu_kv_content_cache.py /workspace/qwen3_6_scripts/vendor_overrides/vllm/core/block/cpu_kv_content_cache.py +COPY ./vllm_overrides/core/block/cpu_gpu_block_allocator.py /workspace/qwen3_6_scripts/vendor_overrides/vllm/core/block/cpu_gpu_block_allocator.py +COPY ./vllm_overrides/core/block/prefix_caching_block.py /workspace/qwen3_6_scripts/vendor_overrides/vllm/core/block/prefix_caching_block.py +COPY ./vllm_overrides/core/block/block_table.py /workspace/qwen3_6_scripts/vendor_overrides/vllm/core/block/block_table.py +COPY ./vllm_overrides/core/block_manager_v2.py /workspace/qwen3_6_scripts/vendor_overrides/vllm/core/block_manager_v2.py +COPY ./vllm_overrides/sampling_params.py /workspace/qwen3_6_scripts/vendor_overrides/vllm/sampling_params.py +COPY ./vllm_overrides/model_executor/sampling_metadata.py /workspace/qwen3_6_scripts/vendor_overrides/vllm/model_executor/sampling_metadata.py +COPY ./vllm_overrides/model_executor/layers/sampler.py /workspace/qwen3_6_scripts/vendor_overrides/vllm/model_executor/layers/sampler.py +RUN cd ./qwen3_6_scripts && bash ./patch_ops.sh diff --git a/Dockerfile.ref b/Dockerfile.ref new file mode 100644 index 00000000..6c9de2ff --- /dev/null +++ b/Dockerfile.ref @@ -0,0 +1,21 @@ +FROM harbor.4pd.io/modelhubxc/enginex-iluvatar/bi100-3.2.3-x86-ubuntu20.04-py3.10-poc-llm-infer:v1.2.3 + +ENV PATH=/usr/local/corex/bin:/usr/local/corex-3.2.3/bin:/usr/local/openmpi/bin:${PATH} +ENV PYTHONPATH=/usr/local/corex/lib64/python3/dist-packages:/usr/local/corex/lib/python3/dist-packages +ENV LD_LIBRARY_PATH=/usr/local/corex/lib:/usr/local/corex/lib64:/usr/local/corex-3.2.3/lib:/usr/local/corex-3.2.3/lib64:/usr/local/openmpi/lib +ENV VLLM_ENGINE_ITERATION_TIMEOUT_S=3600 PYTHONUNBUFFERED=1 PYTHONFAULTHANDLER=1 BI100_EXECUTOR_STARTUP_DEBUG=1 ENABLE_CUSTOM_IPC=1 +ENV BI100_PREFIX_MODEL_FINGERPRINT=Qwen3.6-35B-A3B BI100_PREFIX_DTYPE=float16 BI100_PREFIX_TP_SIZE=4 + +RUN mkdir /workspace +WORKDIR /workspace/ +COPY ./qwen3_6_scripts /workspace/qwen3_6_scripts +COPY ./vllm/core/evictor_v2.py /workspace/qwen3_6_scripts/vendor_overrides/vllm/core/evictor_v2.py +COPY ./vllm/core/block/cpu_kv_content_cache.py /workspace/qwen3_6_scripts/vendor_overrides/vllm/core/block/cpu_kv_content_cache.py +COPY ./vllm/core/block/cpu_gpu_block_allocator.py /workspace/qwen3_6_scripts/vendor_overrides/vllm/core/block/cpu_gpu_block_allocator.py +COPY ./vllm/core/block/prefix_caching_block.py /workspace/qwen3_6_scripts/vendor_overrides/vllm/core/block/prefix_caching_block.py +COPY ./vllm/core/block/block_table.py /workspace/qwen3_6_scripts/vendor_overrides/vllm/core/block/block_table.py +COPY ./vllm/core/block_manager_v2.py /workspace/qwen3_6_scripts/vendor_overrides/vllm/core/block_manager_v2.py +COPY ./vllm/sampling_params.py /workspace/qwen3_6_scripts/vendor_overrides/vllm/sampling_params.py +COPY ./vllm/model_executor/sampling_metadata.py /workspace/qwen3_6_scripts/vendor_overrides/vllm/model_executor/sampling_metadata.py +COPY ./vllm/model_executor/layers/sampler.py /workspace/qwen3_6_scripts/vendor_overrides/vllm/model_executor/layers/sampler.py +RUN cd ./qwen3_6_scripts && bash ./patch_ops.sh diff --git a/computility-run.ref.yaml b/computility-run.ref.yaml new file mode 100644 index 00000000..41351f46 --- /dev/null +++ b/computility-run.ref.yaml @@ -0,0 +1,44 @@ +concurrency: 1 +command: + - python3 + - -m + - vllm.entrypoints.openai.api_server + - --model + - /model + - --served-model-name + - llm + - --max-model-len + - '262144' + - --gpu-memory-utilization + - '0.9' + - --trust-remote-code + - -tp + - '4' + - --max-num-seqs + - '1' + - --disable-log-requests + - --disable-frontend-multiprocessing + - --max-num-batched-tokens + - '8192' + - --enable-chunked-prefill + - --max-seq-len-to-capture + - '32768' + - --enable-auto-tool-choice + - --tool-call-parser + - qwen3_coder + - --reasoning-parser + - qwen3 + - --enable-prefix-caching +env: + - name: VLLM_ENGINE_ITERATION_TIMEOUT_S + value: 3600 + - name: BI100_MOE_COREX_DIRECT_ROUTED + value: 1 + - name: BI100_GDN_COREX_PACKED_DECODE + value: 1 + - name: BI100_HYBRID_KV_ACCOUNTING + value: full_attention + - name: BI100_GDN_CACHE_POLICY + value: admission64 + - name: BI100_GDN_RESTORE_MODE + value: hybrid64 diff --git a/computility-run.yaml b/computility-run.yaml index 7af3118e..41351f46 100644 --- a/computility-run.yaml +++ b/computility-run.yaml @@ -8,42 +8,37 @@ command: - --served-model-name - llm - --max-model-len - - '256000' + - '262144' - --gpu-memory-utilization - - '0.95' + - '0.9' - --trust-remote-code - -tp - '4' - --max-num-seqs - - '2' - - --max-num-batched-tokens - - '4096' - - --enable-chunked-prefill + - '1' - --disable-log-requests - --disable-frontend-multiprocessing - - --enforce-eager + - --max-num-batched-tokens + - '8192' + - --enable-chunked-prefill + - --max-seq-len-to-capture + - '32768' - --enable-auto-tool-choice - --tool-call-parser - qwen3_coder - --reasoning-parser - qwen3 - --enable-prefix-caching - - --max-seq-len-to-capture - - '32768' - - --dtype - - half env: - name: VLLM_ENGINE_ITERATION_TIMEOUT_S - value: '3600' - - name: VLLM_ATTENTION_BACKEND - value: XFORMERS - - name: ENABLE_CUSTOM_IPC - value: '1' - - name: PYTHONPATH - value: /usr/local/corex/lib/python3/dist-packages:/usr/local/corex/lib64/python3/dist-packages - - name: LD_LIBRARY_PATH - value: /usr/local/corex/lib64:/usr/local/openmpi/lib:/usr/local/corex/lib64/python3/dist-packages/ixformer - - name: PYTORCH_CUDA_ALLOC_CONF - value: max_split_size_mb:512 - - name: OMP_NUM_THREADS - value: '1' + value: 3600 + - name: BI100_MOE_COREX_DIRECT_ROUTED + value: 1 + - name: BI100_GDN_COREX_PACKED_DECODE + value: 1 + - name: BI100_HYBRID_KV_ACCOUNTING + value: full_attention + - name: BI100_GDN_CACHE_POLICY + value: admission64 + - name: BI100_GDN_RESTORE_MODE + value: hybrid64 diff --git a/qwen3_6_scripts/api_server.py b/qwen3_6_scripts/api_server.py index 80a64248..fa5ef301 100644 --- a/qwen3_6_scripts/api_server.py +++ b/qwen3_6_scripts/api_server.py @@ -1,633 +1,1080 @@ -import asyncio -import importlib -import inspect -import multiprocessing -import os -import regex as re -import signal -import socket -import tempfile -from argparse import Namespace -from contextlib import asynccontextmanager -from functools import partial -from http import HTTPStatus +import asyncio +import importlib +import inspect +import multiprocessing +import os +import regex as re +import signal +import socket +import sys +import tempfile +import time +from argparse import Namespace +from contextlib import asynccontextmanager +from functools import partial +from http import HTTPStatus from typing import AsyncIterator, Set -import uvloop -from fastapi import APIRouter, FastAPI, Request -from fastapi.exceptions import RequestValidationError -from fastapi.middleware.cors import CORSMiddleware -from fastapi.responses import JSONResponse, Response, StreamingResponse -from starlette.datastructures import State -from starlette.routing import Mount -from typing_extensions import assert_never -import vllm.envs as envs -from vllm.config import ModelConfig -from vllm.engine.arg_utils import AsyncEngineArgs -from vllm.engine.async_llm_engine import AsyncLLMEngine -from vllm.engine.multiprocessing.client import MQLLMEngineClient -from vllm.engine.multiprocessing.engine import run_mp_engine -from vllm.engine.protocol import EngineClient -from vllm.entrypoints.launcher import serve_http -from vllm.entrypoints.logger import RequestLogger -from vllm.entrypoints.openai.cli_args import (make_arg_parser, - validate_parsed_serve_args) -# yapf conflicts with isort for this block -# yapf: disable -from vllm.entrypoints.openai.protocol import (ChatCompletionRequest, - ChatCompletionResponse, - CompletionRequest, - CompletionResponse, - DetokenizeRequest, - DetokenizeResponse, - EmbeddingRequest, - EmbeddingResponse, ErrorResponse, - LoadLoraAdapterRequest, - TokenizeRequest, - TokenizeResponse, - UnloadLoraAdapterRequest) -# yapf: enable -from vllm.entrypoints.openai.serving_chat import OpenAIServingChat -from vllm.entrypoints.openai.serving_completion import OpenAIServingCompletion -from vllm.entrypoints.openai.serving_embedding import OpenAIServingEmbedding -from vllm.entrypoints.openai.serving_engine import BaseModelPath -from vllm.entrypoints.openai.serving_tokenization import ( - OpenAIServingTokenization) -from vllm.entrypoints.openai.tool_parsers import ToolParserManager -from vllm.reasoning import ReasoningParserManager -from vllm.logger import init_logger -from vllm.usage.usage_lib import UsageContext -from vllm.utils import FlexibleArgumentParser, get_open_zmq_ipc_path -from vllm.version import __version__ as VLLM_VERSION +def _bi100_field(value, name): + if isinstance(value, dict): + return value.get(name) + return getattr(value, name, None) -TIMEOUT_KEEP_ALIVE = 5 # seconds -prometheus_multiproc_dir: tempfile.TemporaryDirectory +def _bi100_scalar(value): + return getattr(value, "value", value) -# Cannot use __name__ (https://github.com/vllm-project/vllm/pull/4765) + +def _bi100_tool_choice_kind(value): + value = _bi100_scalar(value) + if value is None: + return "unset" + if isinstance(value, str): + return value if value in ("none", "auto", "required") else "other" + function = _bi100_field(value, "function") + if function is not None and isinstance( + _bi100_field(function, "name"), str): + return "named" + return "other" + + +def _bi100_image_source_kind(value): + if not isinstance(value, str): + return "other" + prefix = value[:8].lower() + if prefix.startswith("data:"): + return "data" + if prefix.startswith(("http://", "https://")): + return "remote" + return "other" + + +def _bi100_chat_4xx_reason(message): + if message == "messages must contain at least one message": + return "empty_messages" + if (isinstance(message, str) + and message.startswith("top_p must be in (0, 1], got ")): + return "invalid_top_p" + if (isinstance(message, str) + and message.startswith("max_tokens must be at least 1, got ")): + return "invalid_max_tokens" + if (isinstance(message, str) + and message.startswith("This model's maximum context length is ") + and "tokens. However, you requested " in message): + return "context_length_exceeded" + if (isinstance(message, str) and message.startswith("n=") + and " exceeds max_num_seqs=" in message): + return "n_exceeds_max_num_seqs" + if message == 'tool_choice = "required" is not supported!': + return "unsupported_tool_choice_required" + if (isinstance(message, str) + and message.startswith('"auto" tool choice requires ')): + return "tool_parser_unavailable" + if message == "Tool call arguments are not valid JSON.": + return "invalid_tool_arguments_json" + if (isinstance(message, str) + and message.startswith("Tool call arguments must ")): + return "invalid_tool_arguments_type" + if (isinstance(message, str) + and ( + (message.startswith("At most ") + and " image(s) may be provided in one request." in message) + or (message.startswith("You set image=") + and "items in the same prompt." in message))): + return "image_count_limit" + if message == "Unknown model type: qwen3_5_moe": + return "image_model_type_unsupported" + return "unclassified_chat_error" + + +def _bi100_chat_request_shape(request): + messages = _bi100_field(request, "messages") + if not isinstance(messages, (list, tuple)): + messages = () + tools = _bi100_field(request, "tools") + if not isinstance(tools, (list, tuple)): + tools = () + + system_count = 0 + system_part_message_count = 0 + system_text_part_count = 0 + system_other_part_count = 0 + tool_message_count = 0 + assistant_tool_message_count = 0 + image_count = 0 + image_data_count = 0 + image_remote_count = 0 + image_other_count = 0 + for message in messages: + role = _bi100_scalar(_bi100_field(message, "role")) + if role == "system": + system_count += 1 + elif role == "tool": + tool_message_count += 1 + elif (role == "assistant" + and _bi100_field(message, "tool_calls")): + assistant_tool_message_count += 1 + content = _bi100_field(message, "content") + if not isinstance(content, (list, tuple)): + continue + if role == "system": + system_part_message_count += 1 + for part in content: + part_type = _bi100_scalar(_bi100_field(part, "type")) + if role == "system": + if part_type == "text": + system_text_part_count += 1 + else: + system_other_part_count += 1 + if part_type in ("image", "image_url"): + image_count += 1 + image_url = _bi100_field(part, "image_url") + source_kind = _bi100_image_source_kind( + _bi100_field(image_url, "url")) + if source_kind == "data": + image_data_count += 1 + elif source_kind == "remote": + image_remote_count += 1 + else: + image_other_count += 1 + + strict_false_count = 0 + strict_true_count = 0 + for tool in tools: + function = _bi100_field(tool, "function") + strict = _bi100_field(function, "strict") + if strict is False: + strict_false_count += 1 + elif strict is True: + strict_true_count += 1 + + n = _bi100_field(request, "n") + return { + "message_count": len(messages), + "system_count": system_count, + "system_part_message_count": system_part_message_count, + "system_text_part_count": system_text_part_count, + "system_other_part_count": system_other_part_count, + "tool_count": len(tools), + "tool_message_count": tool_message_count, + "assistant_tool_message_count": assistant_tool_message_count, + "strict_false_count": strict_false_count, + "strict_true_count": strict_true_count, + "tool_choice_kind": _bi100_tool_choice_kind( + _bi100_field(request, "tool_choice")), + "image_count": image_count, + "image_data_count": image_data_count, + "image_remote_count": image_remote_count, + "image_other_count": image_other_count, + "has_image": image_count > 0, + "stream": bool(_bi100_field(request, "stream")), + "n": n if isinstance(n, int) else None, + } + + +def _bi100_validation_message_reason(error, tool_choice_kind): + if not isinstance(error, dict): + return None + + messages = [] + context = error.get("ctx") + if isinstance(context, dict): + context_error = context.get("error") + if isinstance(context_error, ValueError): + messages.append(str(context_error)) + + message = error.get("msg") + if isinstance(message, str): + if message.startswith("Value error, "): + message = message.removeprefix("Value error, ") + messages.append(message) + + for message in messages: + if message == "Tool call arguments are not valid JSON.": + return "invalid_tool_arguments_json" + if message in ( + "Tool call arguments must decode to a JSON object.", + "Tool call arguments must be a JSON object or a " + "JSON-encoded object string."): + return "invalid_tool_arguments_type" + if message == ( + "`tool_choice` must be a named tool, \"auto\", or \"none\"."): + if tool_choice_kind == "required": + return "unsupported_tool_choice_required" + return "request_validation_tool_choice" + return None + + +def _bi100_validation_reason(errors, request_shape=None): + categories = set() + message_categories = set() + tool_choice_kind = ( + request_shape.get("tool_choice_kind") + if isinstance(request_shape, dict) else None + ) + validation_errors = errors if isinstance(errors, (list, tuple)) else () + for error in validation_errors: + if not isinstance(error, dict): + continue + message_category = _bi100_validation_message_reason( + error, tool_choice_kind) + if message_category is not None: + message_categories.add(message_category) + location = error.get("loc") + if not isinstance(location, (list, tuple)): + continue + fields = [ + value for value in location + if isinstance(value, str) + and value not in ("body", "query", "path") + ] + if not fields: + continue + field = fields[0] + descendants = set(fields[1:]) + if field == "messages": + if "tool_call_id" in descendants: + categories.add("request_validation_message_tool_call_id") + elif "tool_calls" in descendants: + categories.add("request_validation_message_tool_calls") + elif "content" in descendants: + categories.add("request_validation_message_content") + elif "role" in descendants: + categories.add("request_validation_message_role") + else: + categories.add("request_validation_messages") + elif field == "tools": + if "strict" in descendants: + categories.add("request_validation_tool_strict") + elif "parameters" in descendants: + categories.add("request_validation_tool_parameters") + else: + categories.add("request_validation_tools") + elif field in ("tool_choice", "parallel_tool_calls"): + categories.add("request_validation_tool_choice") + elif field == "response_format": + categories.add("request_validation_response_format") + elif field in ("stream", "stream_options"): + categories.add("request_validation_streaming") + elif field in ("n", "max_tokens", "min_tokens", "stop"): + categories.add("request_validation_generation") + elif field in ( + "temperature", "top_p", "top_k", "frequency_penalty", + "presence_penalty", "repetition_penalty", "seed"): + categories.add("request_validation_sampling") + elif field == "model": + categories.add("request_validation_model") + else: + categories.add("request_validation_other") + + priority = ( + "request_validation_tool_strict", + "request_validation_tool_parameters", + "request_validation_tool_choice", + "request_validation_message_tool_call_id", + "request_validation_message_tool_calls", + "request_validation_message_content", + "request_validation_message_role", + "request_validation_messages", + "request_validation_tools", + "request_validation_response_format", + "request_validation_streaming", + "request_validation_generation", + "request_validation_sampling", + "request_validation_model", + "request_validation_other", + ) + for category in priority: + if category in categories: + return category + message_priority = ( + "invalid_tool_arguments_json", + "invalid_tool_arguments_type", + "unsupported_tool_choice_required", + "request_validation_tool_choice", + ) + for category in message_priority: + if category in message_categories: + return category + return "request_validation_unknown" + + +def _bi100_validation_identifier(value): + if not isinstance(value, str) or not value or len(value) > 64: + return "unknown" + if not value.isascii(): + return "unknown" + if not all(character.isalnum() or character in "._-" + for character in value): + return "unknown" + return value + + +def _bi100_validation_diagnostics(errors): + if not isinstance(errors, (list, tuple)): + return "unknown", "unknown" + try: + error_count = len(errors) + except Exception: + return "unknown", "unknown" + if error_count > 1: + return "multiple", "multiple" + if error_count == 0: + return "unknown", "unknown" + + try: + error = errors[0] + if not isinstance(error, dict): + return "unknown", "unknown" + location = error.get("loc") + validation_type = _bi100_validation_identifier(error.get("type")) + if not isinstance(location, (list, tuple)): + return "unknown", validation_type + if not location: + return "root", validation_type + index = 0 + if location[0] in ("body", "query", "path", "header", "cookie"): + index = 1 + if index >= len(location): + return "root", validation_type + field = location[index] + if field in ("__root__", "root"): + return "root", validation_type + return _bi100_validation_identifier(field), validation_type + except Exception: + return "unknown", "unknown" + + +def _bi100_safe_validation_errors(exc): + try: + errors = exc.errors() + if not isinstance(errors, (list, tuple)): + return () + return tuple(errors) + except Exception: + return () + + +def _bi100_startup_trace(message: str) -> None: + if os.getenv("BI100_EXECUTOR_STARTUP_DEBUG") == "1": + stamp = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()) + print(f"[BI100 STARTUP] {stamp} pid={os.getpid()} {message}", + file=sys.stderr, flush=True) + + +_bi100_startup_trace("api_server stdlib imports complete; loading runtime dependencies") + +import uvloop +from fastapi import APIRouter, FastAPI, Request +from fastapi.exceptions import RequestValidationError +from fastapi.middleware.cors import CORSMiddleware +from fastapi.responses import JSONResponse, Response, StreamingResponse +from starlette.datastructures import State +from starlette.routing import Mount +from typing_extensions import assert_never + +import vllm.envs as envs +from vllm.config import ModelConfig +from vllm.engine.arg_utils import AsyncEngineArgs +from vllm.engine.async_llm_engine import AsyncLLMEngine +from vllm.engine.multiprocessing.client import MQLLMEngineClient +from vllm.engine.multiprocessing.engine import run_mp_engine +from vllm.engine.protocol import EngineClient +from vllm.entrypoints.launcher import serve_http +from vllm.entrypoints.logger import RequestLogger +from vllm.entrypoints.openai.cli_args import (make_arg_parser, + validate_parsed_serve_args) +# yapf conflicts with isort for this block +# yapf: disable +from vllm.entrypoints.openai.protocol import (ChatCompletionRequest, + ChatCompletionResponse, + CompletionRequest, + CompletionResponse, + DetokenizeRequest, + DetokenizeResponse, + EmbeddingRequest, + EmbeddingResponse, ErrorResponse, + LoadLoraAdapterRequest, + TokenizeRequest, + TokenizeResponse, + UnloadLoraAdapterRequest) +# yapf: enable +from vllm.entrypoints.openai.serving_chat import OpenAIServingChat +from vllm.entrypoints.openai.serving_completion import OpenAIServingCompletion +from vllm.entrypoints.openai.serving_embedding import OpenAIServingEmbedding +from vllm.entrypoints.openai.serving_engine import BaseModelPath +from vllm.entrypoints.openai.serving_tokenization import ( + OpenAIServingTokenization) +from vllm.entrypoints.openai.tool_parsers import ToolParserManager +from vllm.reasoning import ReasoningParserManager +from vllm.logger import init_logger +from vllm.usage.usage_lib import UsageContext +from vllm.utils import FlexibleArgumentParser, get_open_zmq_ipc_path +from vllm.version import __version__ as VLLM_VERSION + +TIMEOUT_KEEP_ALIVE = 5 # seconds + +prometheus_multiproc_dir: tempfile.TemporaryDirectory + +# Cannot use __name__ (https://github.com/vllm-project/vllm/pull/4765) logger = init_logger('vllm.entrypoints.openai.api_server') _running_tasks: Set[asyncio.Task] = set() +_bi100_startup_trace("api_server runtime imports complete") + + +def _bi100_log_chat_4xx(request, error) -> None: + code = getattr(error, "code", None) + if not isinstance(code, int) or not 400 <= code < 500: + return + shape = _bi100_chat_request_shape(request) + reason = _bi100_chat_4xx_reason(getattr(error, "message", None)) + logger.warning( + "[BI100 4XX] endpoint=chat code=%d reason=%s messages=%d " + "systems=%d system_part_msgs=%d system_text_parts=%d " + "system_other_parts=%d tools=%d tool_msgs=%d " + "assistant_tool_msgs=%d strict_false=%d strict_true=%d choice=%s " + "images=%d image_data=%d image_remote=%d image_other=%d " + "stream=%d n=%s", + code, + reason, + shape["message_count"], + shape["system_count"], + shape["system_part_message_count"], + shape["system_text_part_count"], + shape["system_other_part_count"], + shape["tool_count"], + shape["tool_message_count"], + shape["assistant_tool_message_count"], + shape["strict_false_count"], + shape["strict_true_count"], + shape["tool_choice_kind"], + shape["image_count"], + shape["image_data_count"], + shape["image_remote_count"], + shape["image_other_count"], + int(shape["stream"]), + shape["n"] if shape["n"] is not None else "unset", + ) + + +def _bi100_log_request_validation_4xx(raw_request, exc) -> None: + validation_errors = () + validation_field = "unknown" + validation_type = "unknown" + try: + validation_errors = _bi100_safe_validation_errors(exc) + validation_field, validation_type = ( + _bi100_validation_diagnostics(validation_errors) + ) + body = getattr(exc, "body", None) + url = getattr(raw_request, "url", None) + path = getattr(url, "path", "") + is_chat_request = ( + isinstance(path, str) + and path.endswith("/v1/chat/completions") + and isinstance(body, dict) + ) + shape = ( + _bi100_chat_request_shape(body) if is_chat_request else None + ) + reason = _bi100_validation_reason(validation_errors, shape) + if shape is not None: + if (reason == "request_validation_tools" + and shape["strict_true_count"]): + reason = "request_validation_tool_strict" + logger.warning( + "[BI100 4XX] endpoint=request_validation code=400 reason=%s " + "messages=%d systems=%d system_part_msgs=%d " + "system_text_parts=%d system_other_parts=%d tools=%d " + "tool_msgs=%d assistant_tool_msgs=%d strict_false=%d " + "strict_true=%d choice=%s images=%d image_data=%d " + "image_remote=%d image_other=%d stream=%d n=%s errors=%d " + "validation_field=%s validation_type=%s", + reason, + shape["message_count"], + shape["system_count"], + shape["system_part_message_count"], + shape["system_text_part_count"], + shape["system_other_part_count"], + shape["tool_count"], + shape["tool_message_count"], + shape["assistant_tool_message_count"], + shape["strict_false_count"], + shape["strict_true_count"], + shape["tool_choice_kind"], + shape["image_count"], + shape["image_data_count"], + shape["image_remote_count"], + shape["image_other_count"], + int(shape["stream"]), + shape["n"] if shape["n"] is not None else "unset", + len(validation_errors), + validation_field, + validation_type, + ) + else: + logger.warning( + "[BI100 4XX] endpoint=request_validation code=400 reason=%s " + "errors=%d validation_field=%s validation_type=%s", + reason, + len(validation_errors), + validation_field, + validation_type, + ) + return + except Exception: + pass + + try: + logger.warning( + "[BI100 4XX] endpoint=request_validation code=400 " + "reason=request_validation_unknown errors=%d " + "validation_field=%s validation_type=%s", + len(validation_errors), + validation_field, + validation_type, + ) + except Exception: + pass + @asynccontextmanager async def lifespan(app: FastAPI): - try: - if app.state.log_stats: - engine_client: EngineClient = app.state.engine_client - - async def _force_log(): - while True: - await asyncio.sleep(10.) - await engine_client.do_log_stats() - - task = asyncio.create_task(_force_log()) - _running_tasks.add(task) - task.add_done_callback(_running_tasks.remove) - else: - task = None - try: - yield - finally: - if task is not None: - task.cancel() - finally: - # Ensure app state including engine ref is gc'd - del app.state - - -@asynccontextmanager -async def build_async_engine_client( - args: Namespace) -> AsyncIterator[EngineClient]: - - # Context manager to handle engine_client lifecycle - # Ensures everything is shutdown and cleaned up on error/exit - engine_args = AsyncEngineArgs.from_cli_args(args) - - async with build_async_engine_client_from_engine_args( - engine_args, args.disable_frontend_multiprocessing) as engine: - yield engine - - -@asynccontextmanager -async def build_async_engine_client_from_engine_args( - engine_args: AsyncEngineArgs, - disable_frontend_multiprocessing: bool = False, -) -> AsyncIterator[EngineClient]: - """ - Create EngineClient, either: - - in-process using the AsyncLLMEngine Directly - - multiprocess using AsyncLLMEngine RPC - - Returns the Client or None if the creation failed. - """ - - # Fall back - # TODO: fill out feature matrix. - if (MQLLMEngineClient.is_unsupported_config(engine_args) - or disable_frontend_multiprocessing): - engine_config = engine_args.create_engine_config() - uses_ray = getattr(AsyncLLMEngine._get_executor_cls(engine_config), - "uses_ray", False) - - build_engine = partial(AsyncLLMEngine.from_engine_args, - engine_args=engine_args, - engine_config=engine_config, - usage_context=UsageContext.OPENAI_API_SERVER) - if uses_ray: - # Must run in main thread with ray for its signal handlers to work - engine_client = build_engine() - else: - engine_client = await asyncio.get_running_loop().run_in_executor( - None, build_engine) - - yield engine_client - return - - # Otherwise, use the multiprocessing AsyncLLMEngine. - else: - if "PROMETHEUS_MULTIPROC_DIR" not in os.environ: - # Make TemporaryDirectory for prometheus multiprocessing - # Note: global TemporaryDirectory will be automatically - # cleaned up upon exit. - global prometheus_multiproc_dir - prometheus_multiproc_dir = tempfile.TemporaryDirectory() - os.environ[ - "PROMETHEUS_MULTIPROC_DIR"] = prometheus_multiproc_dir.name - else: - logger.warning( - "Found PROMETHEUS_MULTIPROC_DIR was set by user. " - "This directory must be wiped between vLLM runs or " - "you will find inaccurate metrics. Unset the variable " - "and vLLM will properly handle cleanup.") - - # Select random path for IPC. - ipc_path = get_open_zmq_ipc_path() - logger.info("Multiprocessing frontend to use %s for IPC Path.", - ipc_path) - - # Start RPCServer in separate process (holds the LLMEngine). - # the current process might have CUDA context, - # so we need to spawn a new process - context = multiprocessing.get_context("spawn") - - engine_process = context.Process(target=run_mp_engine, - args=(engine_args, - UsageContext.OPENAI_API_SERVER, - ipc_path)) - engine_process.start() - logger.info("Started engine process with PID %d", engine_process.pid) - - # Build RPCClient, which conforms to EngineClient Protocol. - # NOTE: Actually, this is not true yet. We still need to support - # embedding models via RPC (see TODO above) - engine_config = engine_args.create_engine_config() - mp_engine_client = MQLLMEngineClient(ipc_path, engine_config) - - try: - while True: - try: - await mp_engine_client.setup() - break - except TimeoutError: - if not engine_process.is_alive(): - raise RuntimeError( - "Engine process failed to start") from None - - yield mp_engine_client # type: ignore[misc] - finally: - # Ensure rpc server process was terminated - engine_process.terminate() - - # Close all open connections to the backend - mp_engine_client.close() - - # Wait for engine process to join - engine_process.join(4) - if engine_process.exitcode is None: - # Kill if taking longer than 5 seconds to stop - engine_process.kill() - - # Lazy import for prometheus multiprocessing. - # We need to set PROMETHEUS_MULTIPROC_DIR environment variable - # before prometheus_client is imported. - # See https://prometheus.github.io/client_python/multiprocess/ - from prometheus_client import multiprocess - multiprocess.mark_process_dead(engine_process.pid) - - -router = APIRouter() - - -def mount_metrics(app: FastAPI): - # Lazy import for prometheus multiprocessing. - # We need to set PROMETHEUS_MULTIPROC_DIR environment variable - # before prometheus_client is imported. - # See https://prometheus.github.io/client_python/multiprocess/ - from prometheus_client import (CollectorRegistry, make_asgi_app, - multiprocess) - - prometheus_multiproc_dir_path = os.getenv("PROMETHEUS_MULTIPROC_DIR", None) - if prometheus_multiproc_dir_path is not None: - logger.info("vLLM to use %s as PROMETHEUS_MULTIPROC_DIR", - prometheus_multiproc_dir_path) - registry = CollectorRegistry() - multiprocess.MultiProcessCollector(registry) - - # Add prometheus asgi middleware to route /metrics requests - metrics_route = Mount("/metrics", make_asgi_app(registry=registry)) - else: - # Add prometheus asgi middleware to route /metrics requests - metrics_route = Mount("/metrics", make_asgi_app()) - - # Workaround for 307 Redirect for /metrics - metrics_route.path_regex = re.compile("^/metrics(?P.*)$") - app.routes.append(metrics_route) - - -def chat(request: Request) -> OpenAIServingChat: - return request.app.state.openai_serving_chat - - -def completion(request: Request) -> OpenAIServingCompletion: - return request.app.state.openai_serving_completion - - -def tokenization(request: Request) -> OpenAIServingTokenization: - return request.app.state.openai_serving_tokenization - - -def embedding(request: Request) -> OpenAIServingEmbedding: - return request.app.state.openai_serving_embedding - - -def engine_client(request: Request) -> EngineClient: - return request.app.state.engine_client - - -@router.get("/health") -async def health(raw_request: Request) -> Response: - """Health check.""" - await engine_client(raw_request).check_health() - return Response(status_code=200) - - -@router.post("/tokenize") -async def tokenize(request: TokenizeRequest, raw_request: Request): - generator = await tokenization(raw_request).create_tokenize(request) - if isinstance(generator, ErrorResponse): - return JSONResponse(content=generator.model_dump(), - status_code=generator.code) - elif isinstance(generator, TokenizeResponse): - return JSONResponse(content=generator.model_dump()) - - assert_never(generator) - - -@router.post("/detokenize") -async def detokenize(request: DetokenizeRequest, raw_request: Request): - generator = await tokenization(raw_request).create_detokenize(request) - if isinstance(generator, ErrorResponse): - return JSONResponse(content=generator.model_dump(), - status_code=generator.code) - elif isinstance(generator, DetokenizeResponse): - return JSONResponse(content=generator.model_dump()) - - assert_never(generator) - - -@router.get("/v1/models") -async def show_available_models(raw_request: Request): - models = await completion(raw_request).show_available_models() - return JSONResponse(content=models.model_dump()) - - -@router.get("/version") -async def show_version(): - ver = {"version": VLLM_VERSION} - return JSONResponse(content=ver) - - -def _select_error_policy(e: Exception): - """CCCL tuning_adjacent_difference policy_selector pattern: - Select error handling strategy based on exception characteristics, - like policy_selector chooses kernel config based on value_type_size - and may_alias. Returns (status_code, error_code, message).""" - err_msg = str(e) - err_type = type(e).__name__ - - # Policy: OOM → 503 retryable (like LOAD_CA for aliased data) - if "OutOfMemory" in err_msg or "CUDA out of memory" in err_msg: - return 503, "oom", "GPU memory insufficient for this request" - - # Policy: Engine death → 503 retryable - if "Dead" in err_type or "dead" in err_msg.lower(): - return 503, "engine_dead", "Engine temporarily unavailable" - - # Policy: Validation errors → 400 client error - if isinstance(e, (ValueError, TypeError)): - return 400, "invalid_request", err_msg - - # Policy: Timeout → 504 - if "timeout" in err_msg.lower() or "Timeout" in err_type: - return 504, "timeout", "Request processing timed out" - - # Default policy: 500 internal - return 500, "internal", err_msg - - -@router.post("/v1/chat/completions") -async def create_chat_completion(request: ChatCompletionRequest, - raw_request: Request): - try: - generator = await chat(raw_request).create_chat_completion( - request, raw_request) - except Exception as e: - status, code, msg = _select_error_policy(e) - if status >= 500: - logger.exception("Error in chat completion (policy=%s)", code) - else: - logger.warning("Client error in chat completion: %s", code) - return JSONResponse( - content={"error": {"message": msg, "type": "server_error", - "code": code}}, - status_code=status) - - if isinstance(generator, ErrorResponse): - return JSONResponse(content=generator.model_dump(), - status_code=generator.code) - - elif isinstance(generator, ChatCompletionResponse): - return JSONResponse(content=generator.model_dump()) - - return StreamingResponse(content=generator, media_type="text/event-stream") - - -@router.post("/v1/completions") -async def create_completion(request: CompletionRequest, raw_request: Request): - generator = await completion(raw_request).create_completion( + try: + if app.state.log_stats: + engine_client: EngineClient = app.state.engine_client + + async def _force_log(): + while True: + await asyncio.sleep(10.) + await engine_client.do_log_stats() + + task = asyncio.create_task(_force_log()) + _running_tasks.add(task) + task.add_done_callback(_running_tasks.remove) + else: + task = None + try: + yield + finally: + if task is not None: + task.cancel() + finally: + # Ensure app state including engine ref is gc'd + del app.state + + +@asynccontextmanager +async def build_async_engine_client( + args: Namespace) -> AsyncIterator[EngineClient]: + + _bi100_startup_trace("building AsyncEngineArgs") + # Context manager to handle engine_client lifecycle + # Ensures everything is shutdown and cleaned up on error/exit + engine_args = AsyncEngineArgs.from_cli_args(args) + + _bi100_startup_trace("entering engine client construction") + async with build_async_engine_client_from_engine_args( + engine_args, args.disable_frontend_multiprocessing) as engine: + _bi100_startup_trace("engine client construction completed") + yield engine + + +@asynccontextmanager +async def build_async_engine_client_from_engine_args( + engine_args: AsyncEngineArgs, + disable_frontend_multiprocessing: bool = False, +) -> AsyncIterator[EngineClient]: + """ + Create EngineClient, either: + - in-process using the AsyncLLMEngine Directly + - multiprocess using AsyncLLMEngine RPC + + Returns the Client or None if the creation failed. + """ + + # Fall back + # TODO: fill out feature matrix. + if (MQLLMEngineClient.is_unsupported_config(engine_args) + or disable_frontend_multiprocessing): + engine_config = engine_args.create_engine_config() + uses_ray = getattr(AsyncLLMEngine._get_executor_cls(engine_config), + "uses_ray", False) + + build_engine = partial(AsyncLLMEngine.from_engine_args, + engine_args=engine_args, + engine_config=engine_config, + usage_context=UsageContext.OPENAI_API_SERVER) + if uses_ray: + # Must run in main thread with ray for its signal handlers to work + engine_client = build_engine() + else: + engine_client = await asyncio.get_running_loop().run_in_executor( + None, build_engine) + + yield engine_client + return + + # Otherwise, use the multiprocessing AsyncLLMEngine. + else: + if "PROMETHEUS_MULTIPROC_DIR" not in os.environ: + # Make TemporaryDirectory for prometheus multiprocessing + # Note: global TemporaryDirectory will be automatically + # cleaned up upon exit. + global prometheus_multiproc_dir + prometheus_multiproc_dir = tempfile.TemporaryDirectory() + os.environ[ + "PROMETHEUS_MULTIPROC_DIR"] = prometheus_multiproc_dir.name + else: + logger.warning( + "Found PROMETHEUS_MULTIPROC_DIR was set by user. " + "This directory must be wiped between vLLM runs or " + "you will find inaccurate metrics. Unset the variable " + "and vLLM will properly handle cleanup.") + + # Select random path for IPC. + ipc_path = get_open_zmq_ipc_path() + logger.info("Multiprocessing frontend to use %s for IPC Path.", + ipc_path) + + # Start RPCServer in separate process (holds the LLMEngine). + # the current process might have CUDA context, + # so we need to spawn a new process + context = multiprocessing.get_context("spawn") + + engine_process = context.Process(target=run_mp_engine, + args=(engine_args, + UsageContext.OPENAI_API_SERVER, + ipc_path)) + engine_process.start() + logger.info("Started engine process with PID %d", engine_process.pid) + + # Build RPCClient, which conforms to EngineClient Protocol. + # NOTE: Actually, this is not true yet. We still need to support + # embedding models via RPC (see TODO above) + engine_config = engine_args.create_engine_config() + mp_engine_client = MQLLMEngineClient(ipc_path, engine_config) + + try: + while True: + try: + await mp_engine_client.setup() + break + except TimeoutError: + if not engine_process.is_alive(): + raise RuntimeError( + "Engine process failed to start") from None + + yield mp_engine_client # type: ignore[misc] + finally: + # Ensure rpc server process was terminated + engine_process.terminate() + + # Close all open connections to the backend + mp_engine_client.close() + + # Wait for engine process to join + engine_process.join(4) + if engine_process.exitcode is None: + # Kill if taking longer than 5 seconds to stop + engine_process.kill() + + # Lazy import for prometheus multiprocessing. + # We need to set PROMETHEUS_MULTIPROC_DIR environment variable + # before prometheus_client is imported. + # See https://prometheus.github.io/client_python/multiprocess/ + from prometheus_client import multiprocess + multiprocess.mark_process_dead(engine_process.pid) + + +router = APIRouter() + + +def mount_metrics(app: FastAPI): + # Lazy import for prometheus multiprocessing. + # We need to set PROMETHEUS_MULTIPROC_DIR environment variable + # before prometheus_client is imported. + # See https://prometheus.github.io/client_python/multiprocess/ + from prometheus_client import (CollectorRegistry, make_asgi_app, + multiprocess) + + prometheus_multiproc_dir_path = os.getenv("PROMETHEUS_MULTIPROC_DIR", None) + if prometheus_multiproc_dir_path is not None: + logger.info("vLLM to use %s as PROMETHEUS_MULTIPROC_DIR", + prometheus_multiproc_dir_path) + registry = CollectorRegistry() + multiprocess.MultiProcessCollector(registry) + + # Add prometheus asgi middleware to route /metrics requests + metrics_route = Mount("/metrics", make_asgi_app(registry=registry)) + else: + # Add prometheus asgi middleware to route /metrics requests + metrics_route = Mount("/metrics", make_asgi_app()) + + # Workaround for 307 Redirect for /metrics + metrics_route.path_regex = re.compile("^/metrics(?P.*)$") + app.routes.append(metrics_route) + + +def chat(request: Request) -> OpenAIServingChat: + return request.app.state.openai_serving_chat + + +def completion(request: Request) -> OpenAIServingCompletion: + return request.app.state.openai_serving_completion + + +def tokenization(request: Request) -> OpenAIServingTokenization: + return request.app.state.openai_serving_tokenization + + +def embedding(request: Request) -> OpenAIServingEmbedding: + return request.app.state.openai_serving_embedding + + +def engine_client(request: Request) -> EngineClient: + return request.app.state.engine_client + + +@router.get("/health") +async def health(raw_request: Request) -> Response: + """Health check.""" + await engine_client(raw_request).check_health() + return Response(status_code=200) + + +@router.post("/tokenize") +async def tokenize(request: TokenizeRequest, raw_request: Request): + generator = await tokenization(raw_request).create_tokenize(request) + if isinstance(generator, ErrorResponse): + return JSONResponse(content=generator.model_dump(), + status_code=generator.code) + elif isinstance(generator, TokenizeResponse): + return JSONResponse(content=generator.model_dump()) + + assert_never(generator) + + +@router.post("/detokenize") +async def detokenize(request: DetokenizeRequest, raw_request: Request): + generator = await tokenization(raw_request).create_detokenize(request) + if isinstance(generator, ErrorResponse): + return JSONResponse(content=generator.model_dump(), + status_code=generator.code) + elif isinstance(generator, DetokenizeResponse): + return JSONResponse(content=generator.model_dump()) + + assert_never(generator) + + +@router.get("/v1/models") +async def show_available_models(raw_request: Request): + models = await completion(raw_request).show_available_models() + return JSONResponse(content=models.model_dump()) + + +@router.get("/version") +async def show_version(): + ver = {"version": VLLM_VERSION} + return JSONResponse(content=ver) + + +@router.post("/v1/chat/completions") +async def create_chat_completion(request: ChatCompletionRequest, + raw_request: Request): + + generator = await chat(raw_request).create_chat_completion( request, raw_request) + if isinstance(generator, ErrorResponse): + _bi100_log_chat_4xx(request, generator) return JSONResponse(content=generator.model_dump(), status_code=generator.code) - elif isinstance(generator, CompletionResponse): - return JSONResponse(content=generator.model_dump()) - - return StreamingResponse(content=generator, media_type="text/event-stream") - - -@router.post("/v1/embeddings") -async def create_embedding(request: EmbeddingRequest, raw_request: Request): - generator = await embedding(raw_request).create_embedding( - request, raw_request) - if isinstance(generator, ErrorResponse): - return JSONResponse(content=generator.model_dump(), - status_code=generator.code) - elif isinstance(generator, EmbeddingResponse): - return JSONResponse(content=generator.model_dump()) - - assert_never(generator) - - -if envs.VLLM_TORCH_PROFILER_DIR: - logger.warning( - "Torch Profiler is enabled in the API server. This should ONLY be " - "used for local development!") - - @router.post("/start_profile") - async def start_profile(raw_request: Request): - logger.info("Starting profiler...") - await engine_client(raw_request).start_profile() - logger.info("Profiler started.") - return Response(status_code=200) - - @router.post("/stop_profile") - async def stop_profile(raw_request: Request): - logger.info("Stopping profiler...") - await engine_client(raw_request).stop_profile() - logger.info("Profiler stopped.") - return Response(status_code=200) - - -if envs.VLLM_ALLOW_RUNTIME_LORA_UPDATING: - logger.warning( - "Lora dynamic loading & unloading is enabled in the API server. " - "This should ONLY be used for local development!") - - @router.post("/v1/load_lora_adapter") - async def load_lora_adapter(request: LoadLoraAdapterRequest, - raw_request: Request): - response = await chat(raw_request).load_lora_adapter(request) - if isinstance(response, ErrorResponse): - return JSONResponse(content=response.model_dump(), - status_code=response.code) - - response = await completion(raw_request).load_lora_adapter(request) - if isinstance(response, ErrorResponse): - return JSONResponse(content=response.model_dump(), - status_code=response.code) - - return Response(status_code=200, content=response) - - @router.post("/v1/unload_lora_adapter") - async def unload_lora_adapter(request: UnloadLoraAdapterRequest, - raw_request: Request): - response = await chat(raw_request).unload_lora_adapter(request) - if isinstance(response, ErrorResponse): - return JSONResponse(content=response.model_dump(), - status_code=response.code) - - response = await completion(raw_request).unload_lora_adapter(request) - if isinstance(response, ErrorResponse): - return JSONResponse(content=response.model_dump(), - status_code=response.code) - - return Response(status_code=200, content=response) - - -def build_app(args: Namespace) -> FastAPI: - if args.disable_fastapi_docs: - app = FastAPI(openapi_url=None, - docs_url=None, - redoc_url=None, - lifespan=lifespan) - else: - app = FastAPI(lifespan=lifespan) - app.include_router(router) - app.root_path = args.root_path - - mount_metrics(app) - - app.add_middleware( - CORSMiddleware, - allow_origins=args.allowed_origins, - allow_credentials=args.allow_credentials, - allow_methods=args.allowed_methods, - allow_headers=args.allowed_headers, - ) - + + elif isinstance(generator, ChatCompletionResponse): + return JSONResponse(content=generator.model_dump()) + + return StreamingResponse(content=generator, media_type="text/event-stream") + + +@router.post("/v1/completions") +async def create_completion(request: CompletionRequest, raw_request: Request): + generator = await completion(raw_request).create_completion( + request, raw_request) + if isinstance(generator, ErrorResponse): + return JSONResponse(content=generator.model_dump(), + status_code=generator.code) + elif isinstance(generator, CompletionResponse): + return JSONResponse(content=generator.model_dump()) + + return StreamingResponse(content=generator, media_type="text/event-stream") + + +@router.post("/v1/embeddings") +async def create_embedding(request: EmbeddingRequest, raw_request: Request): + generator = await embedding(raw_request).create_embedding( + request, raw_request) + if isinstance(generator, ErrorResponse): + return JSONResponse(content=generator.model_dump(), + status_code=generator.code) + elif isinstance(generator, EmbeddingResponse): + return JSONResponse(content=generator.model_dump()) + + assert_never(generator) + + +if envs.VLLM_TORCH_PROFILER_DIR: + logger.warning( + "Torch Profiler is enabled in the API server. This should ONLY be " + "used for local development!") + + @router.post("/start_profile") + async def start_profile(raw_request: Request): + logger.info("Starting profiler...") + await engine_client(raw_request).start_profile() + logger.info("Profiler started.") + return Response(status_code=200) + + @router.post("/stop_profile") + async def stop_profile(raw_request: Request): + logger.info("Stopping profiler...") + await engine_client(raw_request).stop_profile() + logger.info("Profiler stopped.") + return Response(status_code=200) + + +if envs.VLLM_ALLOW_RUNTIME_LORA_UPDATING: + logger.warning( + "Lora dynamic loading & unloading is enabled in the API server. " + "This should ONLY be used for local development!") + + @router.post("/v1/load_lora_adapter") + async def load_lora_adapter(request: LoadLoraAdapterRequest, + raw_request: Request): + response = await chat(raw_request).load_lora_adapter(request) + if isinstance(response, ErrorResponse): + return JSONResponse(content=response.model_dump(), + status_code=response.code) + + response = await completion(raw_request).load_lora_adapter(request) + if isinstance(response, ErrorResponse): + return JSONResponse(content=response.model_dump(), + status_code=response.code) + + return Response(status_code=200, content=response) + + @router.post("/v1/unload_lora_adapter") + async def unload_lora_adapter(request: UnloadLoraAdapterRequest, + raw_request: Request): + response = await chat(raw_request).unload_lora_adapter(request) + if isinstance(response, ErrorResponse): + return JSONResponse(content=response.model_dump(), + status_code=response.code) + + response = await completion(raw_request).unload_lora_adapter(request) + if isinstance(response, ErrorResponse): + return JSONResponse(content=response.model_dump(), + status_code=response.code) + + return Response(status_code=200, content=response) + + +def build_app(args: Namespace) -> FastAPI: + if args.disable_fastapi_docs: + app = FastAPI(openapi_url=None, + docs_url=None, + redoc_url=None, + lifespan=lifespan) + else: + app = FastAPI(lifespan=lifespan) + app.include_router(router) + app.root_path = args.root_path + + mount_metrics(app) + + app.add_middleware( + CORSMiddleware, + allow_origins=args.allowed_origins, + allow_credentials=args.allow_credentials, + allow_methods=args.allowed_methods, + allow_headers=args.allowed_headers, + ) + @app.exception_handler(RequestValidationError) - async def validation_exception_handler(_, exc): + async def validation_exception_handler(raw_request, exc): + _bi100_log_request_validation_4xx(raw_request, exc) chat = app.state.openai_serving_chat err = chat.create_error_response(message=str(exc)) - return JSONResponse(err.model_dump(), - status_code=HTTPStatus.BAD_REQUEST) - - if token := envs.VLLM_API_KEY or args.api_key: - - @app.middleware("http") - async def authentication(request: Request, call_next): - root_path = "" if args.root_path is None else args.root_path - if request.method == "OPTIONS": - return await call_next(request) - if not request.url.path.startswith(f"{root_path}/v1"): - return await call_next(request) - if request.headers.get("Authorization") != "Bearer " + token: - return JSONResponse(content={"error": "Unauthorized"}, - status_code=401) - return await call_next(request) - - for middleware in args.middleware: - module_path, object_name = middleware.rsplit(".", 1) - imported = getattr(importlib.import_module(module_path), object_name) - if inspect.isclass(imported): - app.add_middleware(imported) - elif inspect.iscoroutinefunction(imported): - app.middleware("http")(imported) - else: - raise ValueError(f"Invalid middleware {middleware}. " - f"Must be a function or a class.") - - return app - - -def init_app_state( - engine_client: EngineClient, - model_config: ModelConfig, - state: State, - args: Namespace, -) -> None: - if args.served_model_name is not None: - served_model_names = args.served_model_name - else: - served_model_names = [args.model] - - if args.disable_log_requests: - request_logger = None - else: - request_logger = RequestLogger(max_log_len=args.max_log_len) - - base_model_paths = [ - BaseModelPath(name=name, model_path=args.model) - for name in served_model_names - ] - - state.engine_client = engine_client - state.log_stats = not args.disable_log_stats - - state.openai_serving_chat = OpenAIServingChat( - engine_client, - model_config, - base_model_paths, - args.response_role, - lora_modules=args.lora_modules, - prompt_adapters=args.prompt_adapters, - request_logger=request_logger, - chat_template=args.chat_template, - return_tokens_as_token_ids=args.return_tokens_as_token_ids, - enable_auto_tools=args.enable_auto_tool_choice, - tool_parser=args.tool_call_parser, - reasoning_parser=getattr(args, 'reasoning_parser', None)) - state.openai_serving_completion = OpenAIServingCompletion( - engine_client, - model_config, - base_model_paths, - lora_modules=args.lora_modules, - prompt_adapters=args.prompt_adapters, - request_logger=request_logger, - return_tokens_as_token_ids=args.return_tokens_as_token_ids, - ) - state.openai_serving_embedding = OpenAIServingEmbedding( - engine_client, - model_config, - base_model_paths, - request_logger=request_logger, - ) - state.openai_serving_tokenization = OpenAIServingTokenization( - engine_client, - model_config, - base_model_paths, - lora_modules=args.lora_modules, - request_logger=request_logger, - chat_template=args.chat_template, - ) - - -async def run_server(args, **uvicorn_kwargs) -> None: - logger.info("vLLM API server version %s", VLLM_VERSION) - logger.info("args: %s", args) - - if args.tool_parser_plugin and len(args.tool_parser_plugin) > 3: - ToolParserManager.import_tool_parser(args.tool_parser_plugin) - - valide_tool_parses = ToolParserManager.tool_parsers.keys() - if args.enable_auto_tool_choice \ - and args.tool_call_parser not in valide_tool_parses: - raise KeyError(f"invalid tool call parser: {args.tool_call_parser} " - f"(chose from {{ {','.join(valide_tool_parses)} }})") - - reasoning_parser = getattr(args, 'reasoning_parser', None) - if reasoning_parser: - valid_reasoning = ReasoningParserManager.list_registered() - if reasoning_parser not in valid_reasoning: - raise KeyError( - f"invalid reasoning parser: {reasoning_parser} " - f"(chose from {{ {','.join(valid_reasoning)} }})") - - # workaround to make sure that we bind the port before the engine is set up. - # This avoids race conditions with ray. - # see https://github.com/vllm-project/vllm/issues/8204 - sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) - sock.bind(("", args.port)) - - def signal_handler(*_) -> None: - # Interrupt server on sigterm while initializing - raise KeyboardInterrupt("terminated") - - signal.signal(signal.SIGTERM, signal_handler) - - async with build_async_engine_client(args) as engine_client: - app = build_app(args) - - model_config = await engine_client.get_model_config() - init_app_state(engine_client, model_config, app.state, args) - - shutdown_task = await serve_http( - app, - host=args.host, - port=args.port, - log_level=args.uvicorn_log_level, - timeout_keep_alive=TIMEOUT_KEEP_ALIVE, - ssl_keyfile=args.ssl_keyfile, - ssl_certfile=args.ssl_certfile, - ssl_ca_certs=args.ssl_ca_certs, - ssl_cert_reqs=args.ssl_cert_reqs, - fd=sock.fileno(), - **uvicorn_kwargs, - ) - - # NB: Await server shutdown only after the backend context is exited - await shutdown_task - - -if __name__ == "__main__": - # NOTE(simon): - # This section should be in sync with vllm/scripts.py for CLI entrypoints. - parser = FlexibleArgumentParser( - description="vLLM OpenAI-Compatible RESTful API server.") - parser = make_arg_parser(parser) - args = parser.parse_args() - validate_parsed_serve_args(args) - - uvloop.run(run_server(args)) + return JSONResponse(err.model_dump(), + status_code=HTTPStatus.BAD_REQUEST) + + if token := envs.VLLM_API_KEY or args.api_key: + + @app.middleware("http") + async def authentication(request: Request, call_next): + root_path = "" if args.root_path is None else args.root_path + if request.method == "OPTIONS": + return await call_next(request) + if not request.url.path.startswith(f"{root_path}/v1"): + return await call_next(request) + if request.headers.get("Authorization") != "Bearer " + token: + return JSONResponse(content={"error": "Unauthorized"}, + status_code=401) + return await call_next(request) + + for middleware in args.middleware: + module_path, object_name = middleware.rsplit(".", 1) + imported = getattr(importlib.import_module(module_path), object_name) + if inspect.isclass(imported): + app.add_middleware(imported) + elif inspect.iscoroutinefunction(imported): + app.middleware("http")(imported) + else: + raise ValueError(f"Invalid middleware {middleware}. " + f"Must be a function or a class.") + + return app + + +def init_app_state( + engine_client: EngineClient, + model_config: ModelConfig, + state: State, + args: Namespace, +) -> None: + if args.served_model_name is not None: + served_model_names = args.served_model_name + else: + served_model_names = [args.model] + + if args.disable_log_requests: + request_logger = None + else: + request_logger = RequestLogger(max_log_len=args.max_log_len) + + base_model_paths = [ + BaseModelPath(name=name, model_path=args.model) + for name in served_model_names + ] + + state.engine_client = engine_client + state.log_stats = not args.disable_log_stats + + state.openai_serving_chat = OpenAIServingChat( + engine_client, + model_config, + base_model_paths, + args.response_role, + lora_modules=args.lora_modules, + prompt_adapters=args.prompt_adapters, + request_logger=request_logger, + chat_template=args.chat_template, + return_tokens_as_token_ids=args.return_tokens_as_token_ids, + enable_auto_tools=args.enable_auto_tool_choice, + tool_parser=args.tool_call_parser, + reasoning_parser=getattr(args, 'reasoning_parser', None)) + state.openai_serving_completion = OpenAIServingCompletion( + engine_client, + model_config, + base_model_paths, + lora_modules=args.lora_modules, + prompt_adapters=args.prompt_adapters, + request_logger=request_logger, + return_tokens_as_token_ids=args.return_tokens_as_token_ids, + ) + state.openai_serving_embedding = OpenAIServingEmbedding( + engine_client, + model_config, + base_model_paths, + request_logger=request_logger, + ) + state.openai_serving_tokenization = OpenAIServingTokenization( + engine_client, + model_config, + base_model_paths, + lora_modules=args.lora_modules, + request_logger=request_logger, + chat_template=args.chat_template, + ) + + +async def run_server(args, **uvicorn_kwargs) -> None: + _bi100_startup_trace("run_server entered") + logger.info("vLLM API server version %s", VLLM_VERSION) + logger.info("args: %s", args) + + if args.tool_parser_plugin and len(args.tool_parser_plugin) > 3: + ToolParserManager.import_tool_parser(args.tool_parser_plugin) + + valide_tool_parses = ToolParserManager.tool_parsers.keys() + if args.enable_auto_tool_choice \ + and args.tool_call_parser not in valide_tool_parses: + raise KeyError(f"invalid tool call parser: {args.tool_call_parser} " + f"(chose from {{ {','.join(valide_tool_parses)} }})") + + reasoning_parser = getattr(args, 'reasoning_parser', None) + if reasoning_parser: + valid_reasoning = ReasoningParserManager.list_registered() + if reasoning_parser not in valid_reasoning: + raise KeyError( + f"invalid reasoning parser: {reasoning_parser} " + f"(chose from {{ {','.join(valid_reasoning)} }})") + + # workaround to make sure that we bind the port before the engine is set up. + # This avoids race conditions with ray. + # see https://github.com/vllm-project/vllm/issues/8204 + sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + sock.bind(("", args.port)) + + def signal_handler(*_) -> None: + # Interrupt server on sigterm while initializing + raise KeyboardInterrupt("terminated") + + signal.signal(signal.SIGTERM, signal_handler) + + _bi100_startup_trace("starting engine client context") + async with build_async_engine_client(args) as engine_client: + _bi100_startup_trace("building FastAPI application") + app = build_app(args) + + _bi100_startup_trace("requesting model config from engine") + model_config = await engine_client.get_model_config() + _bi100_startup_trace("model config received; initializing app state") + init_app_state(engine_client, model_config, app.state, args) + + _bi100_startup_trace("starting HTTP server") + shutdown_task = await serve_http( + app, + host=args.host, + port=args.port, + log_level=args.uvicorn_log_level, + timeout_keep_alive=TIMEOUT_KEEP_ALIVE, + ssl_keyfile=args.ssl_keyfile, + ssl_certfile=args.ssl_certfile, + ssl_ca_certs=args.ssl_ca_certs, + ssl_cert_reqs=args.ssl_cert_reqs, + fd=sock.fileno(), + **uvicorn_kwargs, + ) + + # NB: Await server shutdown only after the backend context is exited + await shutdown_task + + +if __name__ == "__main__": + _bi100_startup_trace("api_server __main__ entered") + # NOTE(simon): + # This section should be in sync with vllm/scripts.py for CLI entrypoints. + parser = FlexibleArgumentParser( + description="vLLM OpenAI-Compatible RESTful API server.") + parser = make_arg_parser(parser) + args = parser.parse_args() + validate_parsed_serve_args(args) + _bi100_startup_trace( + f"arguments parsed model={args.model} tp={args.tensor_parallel_size} " + f"max_model_len={args.max_model_len}") + + uvloop.run(run_server(args)) diff --git a/qwen3_6_scripts/bi100_env.py b/qwen3_6_scripts/bi100_env.py new file mode 100644 index 00000000..468eb499 --- /dev/null +++ b/qwen3_6_scripts/bi100_env.py @@ -0,0 +1,26 @@ +import os + + +def env_bool(name: str, default: bool = False) -> bool: + raw = os.getenv(name) + if raw is None: + return default + if raw in ("1", "true", "True", "yes", "YES", "on", "ON"): + return True + if raw in ("0", "false", "False", "no", "NO", "off", "OFF"): + return False + raise RuntimeError(f"{name} must be boolean, got {raw!r}") + + +def env_int(name: str, default: int, min_value: int, max_value: int) -> int: + raw = os.getenv(name) + if raw is None: + return default + try: + value = int(raw) + except ValueError as exc: + raise RuntimeError(f"{name} must be int, got {raw!r}") from exc + if not (min_value <= value <= max_value): + raise RuntimeError( + f"{name}={value} outside [{min_value}, {max_value}]") + return value diff --git a/qwen3_6_scripts/bi100_profile.py b/qwen3_6_scripts/bi100_profile.py new file mode 100644 index 00000000..98697029 --- /dev/null +++ b/qwen3_6_scripts/bi100_profile.py @@ -0,0 +1,237 @@ +import contextlib +import fnmatch +import functools +import json +import os +import re +import threading +import time + +from vllm.logger import init_logger + +logger = init_logger(__name__) +_EVENT_SCHEMA = "bi100-profile-event-v1" +_EVENT_VERSION = 1 +_NAME_RE = re.compile(r"^[A-Za-z][A-Za-z0-9_.-]{0,63}$") +_FILTER_RE = re.compile(r"^[A-Za-z][A-Za-z0-9_.*?-]{0,63}$") + + +def _strict_bool(name: str, default: str = "0") -> bool: + value = os.getenv(name, default).strip() + if value not in {"0", "1"}: + raise RuntimeError(f"{name} must be exactly 0 or 1, got {value!r}") + return value == "1" + + +_ENABLED = _strict_bool("BI100_PROFILE") +_INCLUDE_STARTUP = _strict_bool("BI100_PROFILE_INCLUDE_STARTUP") +_MODE = os.getenv("BI100_PROFILE_MODE", "sync").strip().lower() +_FILTERS = tuple( + item.strip() + for item in os.getenv("BI100_PROFILE_FILTER", "").split(",") + if item.strip() +) +if _ENABLED and _MODE not in {"sync", "event"}: + raise RuntimeError(f"unsupported BI100_PROFILE_MODE={_MODE!r}") +if _ENABLED and any(_FILTER_RE.fullmatch(pattern) is None + for pattern in _FILTERS): + raise RuntimeError("BI100_PROFILE_FILTER contains an invalid pattern") + +_EVENT_RECORDS = [] +_COUNTERS = {} +_LOCK = threading.Lock() +_FORWARD_INDEX = 0 +_LAST_FLUSH_NS = None +_ACTIVE_FORWARD_TOKEN = None +_NEXT_FORWARD_TOKEN = 0 + + +def _enabled_for(name: str) -> bool: + return (_ENABLED + and (not _FILTERS + or any(fnmatch.fnmatchcase(name, pattern) + for pattern in _FILTERS))) + + +def _skip_startup() -> bool: + return (not _INCLUDE_STARTUP + and os.getenv("BI100_IN_STARTUP_PROFILE") == "1") + + +def bi100_profile_event_enabled() -> bool: + return _ENABLED and _MODE == "event" and not _skip_startup() + + +def _begin_profile_forward(): + global _ACTIVE_FORWARD_TOKEN, _NEXT_FORWARD_TOKEN + if not bi100_profile_event_enabled(): + return None + with _LOCK: + _EVENT_RECORDS.clear() + _COUNTERS.clear() + token = _NEXT_FORWARD_TOKEN + _NEXT_FORWARD_TOKEN += 1 + _ACTIVE_FORWARD_TOKEN = token + return token + + +def _abort_profile_forward(token) -> None: + global _ACTIVE_FORWARD_TOKEN + if token is None: + return + with _LOCK: + if _ACTIVE_FORWARD_TOKEN != token: + return + _EVENT_RECORDS.clear() + _COUNTERS.clear() + _ACTIVE_FORWARD_TOKEN = None + + +def bi100_profile_transaction(function): + """Keep one top-level model forward isolated from failed forwards.""" + @functools.wraps(function) + def wrapped(*args, **kwargs): + token = _begin_profile_forward() + if token is None: + return function(*args, **kwargs) + try: + result = function(*args, **kwargs) + except BaseException: + _abort_profile_forward(token) + raise + with _LOCK: + was_flushed = _ACTIVE_FORWARD_TOKEN != token + if not was_flushed: + _abort_profile_forward(token) + raise RuntimeError( + "BI100 profile transaction completed without a flush") + return result + + return wrapped + + +def _normalize_metadata(metadata): + normalized = {} + for key, value in metadata.items(): + if not isinstance(key, str) or _NAME_RE.fullmatch(key) is None: + raise TypeError("profile metadata keys must be bounded names") + if isinstance(value, bool): + normalized[key] = value + elif isinstance(value, int) and not isinstance(value, bool): + normalized[key] = value + elif isinstance(value, str) and len(value) <= 64: + normalized[key] = value + else: + raise TypeError( + "profile metadata values must be bool, int, or short strings") + return normalized + + +def bi100_profile_count(name: str, **metadata) -> None: + """Record privacy-safe path metadata for the current model forward.""" + if not bi100_profile_event_enabled() or not _enabled_for(name): + return + if not isinstance(name, str) or _NAME_RE.fullmatch(name) is None: + raise TypeError("profile counter name must be a bounded name") + normalized = _normalize_metadata(metadata) + encoded = json.dumps( + {"name": name, **normalized}, sort_keys=True, separators=(",", ":")) + with _LOCK: + _COUNTERS[encoded] = _COUNTERS.get(encoded, 0) + 1 + + +@contextlib.contextmanager +def bi100_timer(name: str): + if not _enabled_for(name) or _skip_startup(): + yield + return + import torch + + if _MODE == "event": + started = torch.cuda.Event(enable_timing=True) + finished = torch.cuda.Event(enable_timing=True) + host_started_ns = time.monotonic_ns() + started.record() + try: + yield + finally: + finished.record() + with _LOCK: + _EVENT_RECORDS.append( + (name, started, finished, host_started_ns)) + return + + torch.cuda.synchronize() + t0 = time.perf_counter() + try: + yield + finally: + torch.cuda.synchronize() + logger.info("[BI100_PROFILE] %s %.3f ms", name, + (time.perf_counter() - t0) * 1000) + + +def bi100_profile_flush(*, tp_rank, **metadata): + """Synchronize once and emit one aggregate event record per model forward.""" + global _ACTIVE_FORWARD_TOKEN, _FORWARD_INDEX, _LAST_FLUSH_NS + if not bi100_profile_event_enabled(): + return None + if (not isinstance(tp_rank, int) or isinstance(tp_rank, bool) + or not 0 <= tp_rank < 256): + raise TypeError("profile TP rank must be an integer in [0, 255]") + normalized_metadata = _normalize_metadata(metadata) + + with _LOCK: + records = list(_EVENT_RECORDS) + counters = dict(_COUNTERS) + _EVENT_RECORDS.clear() + _COUNTERS.clear() + _ACTIVE_FORWARD_TOKEN = None + if not records: + return None + + import torch + + torch.cuda.synchronize() + flushed_ns = time.monotonic_ns() + regions = {} + model_started_ns = [] + for name, started, finished, host_started_ns in records: + stats = regions.setdefault(name, {"count": 0, "total_ms": 0.0}) + stats["count"] += 1 + stats["total_ms"] += float(started.elapsed_time(finished)) + if name == "model.forward": + model_started_ns.append(host_started_ns) + + counter_rows = [] + for encoded, count in sorted(counters.items()): + row = json.loads(encoded) + row["count"] = count + counter_rows.append(row) + + first_model_started_ns = ( + min(model_started_ns) if model_started_ns else None) + payload = { + "schema": _EVENT_SCHEMA, + "version": _EVENT_VERSION, + "tp_rank": tp_rank, + "forward_index": _FORWARD_INDEX, + "metadata": normalized_metadata, + "event_count": len(records), + "model_forward_event_count": len(model_started_ns), + "regions": regions, + "counters": counter_rows, + "host_model_start_to_flush_ms": ( + (flushed_ns - first_model_started_ns) / 1_000_000 + if first_model_started_ns is not None else None), + "host_gap_since_previous_flush_ms": ( + (first_model_started_ns - _LAST_FLUSH_NS) / 1_000_000 + if first_model_started_ns is not None + and _LAST_FLUSH_NS is not None + else None), + } + _FORWARD_INDEX += 1 + _LAST_FLUSH_NS = flushed_ns + logger.info("[BI100_PROFILE_EVENT] %s", + json.dumps(payload, sort_keys=True, separators=(",", ":"))) + return payload diff --git a/qwen3_6_scripts/block_major_kv_cache.py b/qwen3_6_scripts/block_major_kv_cache.py new file mode 100644 index 00000000..80eb4d22 --- /dev/null +++ b/qwen3_6_scripts/block_major_kv_cache.py @@ -0,0 +1,398 @@ +from __future__ import annotations + +import os +import time +from collections.abc import Mapping + +import torch + +from vllm.logger import init_logger + + +logger = init_logger(__name__) + +ENABLE_ENV = "BI100_BLOCK_MAJOR_CPU_KV" +TRACE_ENV = "BI100_BLOCK_MAJOR_CPU_KV_TRACE" +CPU_OFFLOAD_ENV = "BI100_CPU_KV_OFFLOAD" +HYBRID_ACCOUNTING_ENV = "BI100_HYBRID_KV_ACCOUNTING" +NUM_ATTENTION_LAYERS = 10 +KV_PLANES = 2 +ELEMENTS_PER_PLANE_BLOCK = 4096 +STAGING_BLOCKS = 512 +STAGING_BUFFER_COUNT = 2 +BYTES_PER_BLOCK = ( + NUM_ATTENTION_LAYERS * KV_PLANES * ELEMENTS_PER_PLANE_BLOCK * 2 +) +GPU_STAGING_BYTES = STAGING_BLOCKS * STAGING_BUFFER_COUNT * BYTES_PER_BLOCK + + +def _strict_binary_selector( + name: str, + environ: Mapping[str, str] | None = None, +) -> bool: + source = os.environ if environ is None else environ + raw = source.get(name, "0") + if raw == "0": + return False + if raw == "1": + return True + raise RuntimeError(f"{name} must be exactly '0' or '1', got {raw!r}") + + +def block_major_cpu_kv_enabled( + environ: Mapping[str, str] | None = None, +) -> bool: + return _strict_binary_selector(ENABLE_ENV, environ) + + +def block_major_cpu_kv_trace_enabled( + environ: Mapping[str, str] | None = None, +) -> bool: + return _strict_binary_selector(TRACE_ENV, environ) + + +def _require_block_major_runtime( + environ: Mapping[str, str] | None = None, +) -> None: + source = os.environ if environ is None else environ + if source.get(CPU_OFFLOAD_ENV, "0") != "1": + raise RuntimeError( + f"{ENABLE_ENV}=1 requires {CPU_OFFLOAD_ENV}=1") + if source.get(HYBRID_ACCOUNTING_ENV, "legacy40") != "full_attention": + raise RuntimeError( + f"{ENABLE_ENV}=1 requires " + f"{HYBRID_ACCOUNTING_ENV}=full_attention") + + +def reserve_block_major_gpu_blocks( + num_gpu_blocks: int, + cache_block_size: int, + environ: Mapping[str, str] | None = None, +) -> int: + if (not isinstance(num_gpu_blocks, int) + or isinstance(num_gpu_blocks, bool) + or num_gpu_blocks < 0): + raise ValueError("num_gpu_blocks must be a non-negative integer") + if not block_major_cpu_kv_enabled(environ): + return num_gpu_blocks + + _require_block_major_runtime(environ) + if cache_block_size != BYTES_PER_BLOCK: + raise RuntimeError( + f"{ENABLE_ENV}=1 requires cache block size " + f"{BYTES_PER_BLOCK}, got {cache_block_size}") + reserved_blocks = ( + GPU_STAGING_BYTES + cache_block_size - 1 + ) // cache_block_size + remaining_blocks = num_gpu_blocks - reserved_blocks + if remaining_blocks <= 0: + raise RuntimeError( + "block-major GPU staging leaves no usable GPU KV blocks") + logger.info( + "[BI100 BLOCK KV] capacity reserve blocks=%d bytes=%d " + "profiled_blocks=%d usable_blocks=%d", + reserved_blocks, + GPU_STAGING_BYTES, + num_gpu_blocks, + remaining_blocks, + ) + return remaining_blocks + + +def validate_block_mapping( + mapping: torch.Tensor, + source_limit: int, + destination_limit: int, +) -> tuple[torch.Tensor, torch.Tensor]: + if not isinstance(mapping, torch.Tensor): + raise TypeError("block mapping must be a torch.Tensor") + if mapping.device.type != "cpu": + raise ValueError("block mapping must be on CPU") + if mapping.dtype != torch.int64: + raise ValueError("block mapping must use torch.int64") + if not mapping.is_contiguous(): + raise ValueError("block mapping must be contiguous") + if mapping.dim() != 2 or mapping.shape[1] != 2: + raise ValueError("block mapping must have shape [N, 2]") + if source_limit <= 0 or destination_limit <= 0: + raise ValueError("block mapping limits must be positive") + + sources: set[int] = set() + destinations: set[int] = set() + for row, pair in enumerate(mapping.tolist()): + source, destination = pair + if not 0 <= source < source_limit: + raise ValueError( + f"source block out of range at row {row}: {source}") + if not 0 <= destination < destination_limit: + raise ValueError( + f"destination block out of range at row {row}: " + f"{destination}") + if source in sources: + raise ValueError(f"duplicate source block: {source}") + if destination in destinations: + raise ValueError(f"duplicate destination block: {destination}") + sources.add(source) + destinations.add(destination) + + return mapping[:, 0].contiguous(), mapping[:, 1].contiguous() + + +class BlockMajorCpuKVCache: + + def __init__( + self, + gpu_cache: list[torch.Tensor], + num_cpu_blocks: int, + pin_memory: bool, + ) -> None: + self._validate_gpu_cache(gpu_cache) + if block_major_cpu_kv_enabled(): + _require_block_major_runtime() + if num_cpu_blocks <= 0: + raise RuntimeError( + f"{ENABLE_ENV}=1 requires a positive CPU block count") + if not pin_memory: + raise RuntimeError( + f"{ENABLE_ENV}=1 requires pinned CPU memory") + + try: + from vllm import corex_block_major_kv_transfer as extension + except ImportError as exc: + raise RuntimeError( + "block-major CoreX extension is unavailable") from exc + + self.extension = extension + self.gpu_cache = gpu_cache + self.device = gpu_cache[0].device + self.dtype = gpu_cache[0].dtype + self.num_gpu_blocks = gpu_cache[0].shape[1] + self.num_cpu_blocks = num_cpu_blocks + self.trace_enabled = block_major_cpu_kv_trace_enabled() + + self.cpu_pool = torch.zeros( + ( + num_cpu_blocks, + NUM_ATTENTION_LAYERS, + KV_PLANES, + ELEMENTS_PER_PLANE_BLOCK, + ), + dtype=self.dtype, + device="cpu", + pin_memory=True, + ) + if not self.cpu_pool.is_pinned(): + raise RuntimeError("block-major CPU pool is not pinned") + + # Preserve the public CacheEngine shape without allocating a second + # layer-major CPU cache. Transfer methods use cpu_pool directly. + self.layer_views = [ + self.cpu_pool[:, layer, :, :].permute(1, 0, 2) + for layer in range(NUM_ATTENTION_LAYERS) + ] + self.cpu_staging = [ + torch.empty( + ( + STAGING_BLOCKS, + NUM_ATTENTION_LAYERS, + KV_PLANES, + ELEMENTS_PER_PLANE_BLOCK, + ), + dtype=self.dtype, + device="cpu", + pin_memory=True, + ) + for _ in range(STAGING_BUFFER_COUNT) + ] + if not all(staging.is_pinned() for staging in self.cpu_staging): + raise RuntimeError("block-major CPU staging is not pinned") + + with torch.cuda.device(self.device): + self.gpu_staging = [ + torch.empty_like(staging, device=self.device) + for staging in self.cpu_staging + ] + self.events = [ + torch.cuda.Event(enable_timing=False) + for _ in range(STAGING_BUFFER_COUNT) + ] + self.error_flag = torch.zeros( + 1, dtype=torch.int32, device=self.device) + + logger.info( + "[BI100 BLOCK KV] enabled device=%s gpu_blocks=%d cpu_blocks=%d " + "layers=%d block_bytes=%d staging_blocks=%d staging_buffers=%d", + self.device, + self.num_gpu_blocks, + self.num_cpu_blocks, + NUM_ATTENTION_LAYERS, + BYTES_PER_BLOCK, + STAGING_BLOCKS, + STAGING_BUFFER_COUNT, + ) + + @staticmethod + def _validate_gpu_cache(gpu_cache: list[torch.Tensor]) -> None: + if len(gpu_cache) != NUM_ATTENTION_LAYERS: + raise RuntimeError( + f"{ENABLE_ENV}=1 requires exactly " + f"{NUM_ATTENTION_LAYERS} GPU attention caches, got " + f"{len(gpu_cache)}") + first = gpu_cache[0] + if first.device.type != "cuda": + raise RuntimeError("block-major GPU cache must be on CUDA") + if first.dtype != torch.float16: + raise RuntimeError("block-major GPU cache must use float16") + if (first.dim() != 3 or first.shape[0] != KV_PLANES + or first.shape[2] != ELEMENTS_PER_PLANE_BLOCK): + raise RuntimeError( + "block-major GPU cache must have shape [2, blocks, 4096]") + if not first.is_contiguous(): + raise RuntimeError("block-major GPU cache must be contiguous") + + for layer, tensor in enumerate(gpu_cache): + if tensor.device != first.device: + raise RuntimeError( + f"GPU cache layer {layer} is on a different device") + if tensor.dtype != first.dtype or tensor.shape != first.shape: + raise RuntimeError( + f"GPU cache layer {layer} has inconsistent geometry") + if not tensor.is_contiguous(): + raise RuntimeError( + f"GPU cache layer {layer} is not contiguous") + + def _to_gpu_ids(self, block_ids: torch.Tensor) -> torch.Tensor: + return block_ids.to( + device=self.device, + dtype=torch.int32, + non_blocking=False, + ) + + @staticmethod + def _chunks( + source: torch.Tensor, + destination: torch.Tensor, + gpu_ids: torch.Tensor, + ): + for start in range(0, source.numel(), STAGING_BLOCKS): + end = min(start + STAGING_BLOCKS, source.numel()) + yield ( + source[start:end], + destination[start:end], + gpu_ids[start:end], + end - start, + ) + + def _begin(self) -> None: + self.error_flag.zero_() + + def _finish( + self, + direction: str, + block_count: int, + started: float | None, + ) -> None: + # check_error performs the final stream synchronization. This also + # makes every staging slot safe to reuse in the next CacheEngine call. + self.extension.check_error(self.error_flag) + if started is not None: + elapsed_ms = (time.perf_counter() - started) * 1000.0 + logger.info( + "[BI100 BLOCK KV TRACE] direction=%s blocks=%d bytes=%d " + "elapsed_ms=%.3f", + direction, + block_count, + block_count * BYTES_PER_BLOCK, + elapsed_ms, + ) + + def swap_out(self, mapping: torch.Tensor) -> None: + started = time.perf_counter() if self.trace_enabled else None + source_gpu, destination_cpu = validate_block_mapping( + mapping, + source_limit=self.num_gpu_blocks, + destination_limit=self.num_cpu_blocks, + ) + block_count = source_gpu.numel() + if block_count == 0: + return + source_gpu_ids = self._to_gpu_ids(source_gpu) + + self._begin() + pending: tuple[int, torch.Tensor, int] | None = None + for index, (_, destination, gpu_ids, count) in enumerate( + self._chunks( + source_gpu, destination_cpu, source_gpu_ids)): + slot = index % STAGING_BUFFER_COUNT + self.extension.pack( + self.gpu_cache, + gpu_ids, + self.gpu_staging[slot], + self.error_flag, + count, + ) + self.cpu_staging[slot][:count].copy_( + self.gpu_staging[slot][:count], + non_blocking=True, + ) + self.events[slot].record() + if pending is not None: + pending_slot, pending_destination, pending_count = pending + self.events[pending_slot].synchronize() + self.extension.cpu_scatter( + self.cpu_staging[pending_slot], + self.cpu_pool, + pending_destination, + pending_count, + ) + pending = (slot, destination, count) + + if pending is not None: + pending_slot, pending_destination, pending_count = pending + self.events[pending_slot].synchronize() + self.extension.cpu_scatter( + self.cpu_staging[pending_slot], + self.cpu_pool, + pending_destination, + pending_count, + ) + self._finish("d2h", block_count, started) + + def swap_in(self, mapping: torch.Tensor) -> None: + started = time.perf_counter() if self.trace_enabled else None + source_cpu, destination_gpu = validate_block_mapping( + mapping, + source_limit=self.num_cpu_blocks, + destination_limit=self.num_gpu_blocks, + ) + block_count = source_cpu.numel() + if block_count == 0: + return + destination_gpu_ids = self._to_gpu_ids(destination_gpu) + + self._begin() + for index, (source, _, gpu_ids, count) in enumerate( + self._chunks( + source_cpu, destination_gpu, destination_gpu_ids)): + slot = index % STAGING_BUFFER_COUNT + if index >= STAGING_BUFFER_COUNT: + self.events[slot].synchronize() + self.extension.cpu_gather( + self.cpu_pool, + source, + self.cpu_staging[slot], + count, + ) + self.gpu_staging[slot][:count].copy_( + self.cpu_staging[slot][:count], + non_blocking=True, + ) + self.extension.scatter( + self.gpu_staging[slot], + gpu_ids, + self.gpu_cache, + self.error_flag, + count, + ) + self.events[slot].record() + self._finish("h2d", block_count, started) diff --git a/qwen3_6_scripts/build_corex_attn_head_rms_norm.sh b/qwen3_6_scripts/build_corex_attn_head_rms_norm.sh new file mode 100755 index 00000000..9802a2a0 --- /dev/null +++ b/qwen3_6_scripts/build_corex_attn_head_rms_norm.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash +set -euo pipefail + +VLLM_ROOT=${1:?usage: build_corex_attn_head_rms_norm.sh VLLM_ROOT} +COREX_ROOT=${COREX_ROOT:-/usr/local/corex-3.2.3} +TORCH_ROOT=${TORCH_ROOT:-${COREX_ROOT}/lib64/python3/dist-packages/torch} +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +OUTPUT=${VLLM_ROOT}/corex_attn_head_rms_norm.so + +"${COREX_ROOT}/bin/clang++" \ + -std=c++17 -O3 -shared -fPIC \ + --cuda-path="${COREX_ROOT}" \ + --cuda-gpu-arch=ivcore10 \ + --no-cuda-version-check \ + -D_GLIBCXX_USE_CXX11_ABI=0 \ + -DTORCH_EXTENSION_NAME=corex_attn_head_rms_norm \ + -DTORCH_API_INCLUDE_EXTENSION_H \ + -I"${TORCH_ROOT}/include" \ + -I"${TORCH_ROOT}/include/torch/csrc/api/include" \ + -I"${TORCH_ROOT}/include/TH" \ + -I"${TORCH_ROOT}/include/THC" \ + -I/usr/local/include/python3.10 \ + "${SCRIPT_DIR}/corex_attn_head_rms_norm.cu" \ + -L"${TORCH_ROOT}/lib" \ + -L"${COREX_ROOT}/lib64" \ + -Wl,-rpath,"${TORCH_ROOT}/lib" \ + -Wl,-rpath,"${COREX_ROOT}/lib64" \ + -ltorch_python -ltorch_cuda -ltorch_cpu -ltorch \ + -lc10_cuda -lc10 -lcudart \ + -o "${OUTPUT}" + +test -s "${OUTPUT}" +printf '[ok] CoreX attention head RMSNorm extension %s\n' "${OUTPUT}" diff --git a/qwen3_6_scripts/build_corex_fused_paged_prefill_split4.sh b/qwen3_6_scripts/build_corex_fused_paged_prefill_split4.sh new file mode 100644 index 00000000..0ed3a637 --- /dev/null +++ b/qwen3_6_scripts/build_corex_fused_paged_prefill_split4.sh @@ -0,0 +1,27 @@ +#!/usr/bin/env bash +set -euo pipefail + +VLLM_ROOT=${1:?usage: build_corex_fused_paged_prefill_split4.sh VLLM_ROOT} +COREX_ROOT=${COREX_ROOT:-/usr/local/corex-3.2.3} +TORCH_ROOT=${TORCH_ROOT:-${COREX_ROOT}/lib64/python3/dist-packages/torch} +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +OUTPUT=${VLLM_ROOT}/corex_fused_paged_prefill_split4.so + +"${COREX_ROOT}/bin/clang++" \ + -std=c++17 -O3 -shared -fPIC \ + --cuda-path="${COREX_ROOT}" --cuda-gpu-arch=ivcore10 \ + --no-cuda-version-check -D_GLIBCXX_USE_CXX11_ABI=0 \ + -DTORCH_EXTENSION_NAME=corex_fused_paged_prefill \ + -DTORCH_API_INCLUDE_EXTENSION_H \ + -I"${TORCH_ROOT}/include" \ + -I"${TORCH_ROOT}/include/torch/csrc/api/include" \ + -I"${TORCH_ROOT}/include/TH" -I"${TORCH_ROOT}/include/THC" \ + -I/usr/local/include/python3.10 \ + "${SCRIPT_DIR}/corex_fused_paged_prefill_split4.cu" \ + -L"${TORCH_ROOT}/lib" -L"${COREX_ROOT}/lib64" \ + -Wl,-rpath,"${TORCH_ROOT}/lib" -Wl,-rpath,"${COREX_ROOT}/lib64" \ + -ltorch_python -ltorch_cuda -ltorch_cpu -ltorch \ + -lc10_cuda -lc10 -lcublas -lcudart -o "${OUTPUT}" + +test -s "${OUTPUT}" +printf '[ok] CoreX split4 fused paged-prefill extension %s\n' "${OUTPUT}" diff --git a/qwen3_6_scripts/build_corex_gdn_beta_decay.sh b/qwen3_6_scripts/build_corex_gdn_beta_decay.sh new file mode 100644 index 00000000..fc92dac9 --- /dev/null +++ b/qwen3_6_scripts/build_corex_gdn_beta_decay.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash +set -euo pipefail + +VLLM_ROOT=${1:?usage: build_corex_gdn_beta_decay.sh VLLM_ROOT} +COREX_ROOT=${COREX_ROOT:-/usr/local/corex-3.2.3} +TORCH_ROOT=${TORCH_ROOT:-${COREX_ROOT}/lib64/python3/dist-packages/torch} +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +OUTPUT=${VLLM_ROOT}/corex_gdn_beta_decay.so + +"${COREX_ROOT}/bin/clang++" \ + -std=c++17 -O3 -shared -fPIC \ + --cuda-path="${COREX_ROOT}" \ + --cuda-gpu-arch=ivcore10 \ + --no-cuda-version-check \ + -D_GLIBCXX_USE_CXX11_ABI=0 \ + -DTORCH_EXTENSION_NAME=corex_gdn_beta_decay \ + -DTORCH_API_INCLUDE_EXTENSION_H \ + -I"${TORCH_ROOT}/include" \ + -I"${TORCH_ROOT}/include/torch/csrc/api/include" \ + -I"${TORCH_ROOT}/include/TH" \ + -I"${TORCH_ROOT}/include/THC" \ + -I/usr/local/include/python3.10 \ + "${SCRIPT_DIR}/corex_gdn_beta_decay.cu" \ + -L"${TORCH_ROOT}/lib" \ + -L"${COREX_ROOT}/lib64" \ + -Wl,-rpath,"${TORCH_ROOT}/lib" \ + -Wl,-rpath,"${COREX_ROOT}/lib64" \ + -ltorch_python -ltorch_cuda -ltorch_cpu -ltorch \ + -lc10_cuda -lc10 -lcudart \ + -o "${OUTPUT}" + +test -s "${OUTPUT}" +printf '[ok] CoreX GDN beta/decay extension %s\n' "${OUTPUT}" diff --git a/qwen3_6_scripts/build_corex_gdn_causal_conv.sh b/qwen3_6_scripts/build_corex_gdn_causal_conv.sh new file mode 100755 index 00000000..4a6eded0 --- /dev/null +++ b/qwen3_6_scripts/build_corex_gdn_causal_conv.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash +set -euo pipefail + +VLLM_ROOT=${1:?usage: build_corex_gdn_causal_conv.sh VLLM_ROOT} +COREX_ROOT=${COREX_ROOT:-/usr/local/corex-3.2.3} +TORCH_ROOT=${TORCH_ROOT:-${COREX_ROOT}/lib64/python3/dist-packages/torch} +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +OUTPUT=${VLLM_ROOT}/corex_gdn_causal_conv.so + +"${COREX_ROOT}/bin/clang++" \ + -std=c++17 -O3 -shared -fPIC \ + --cuda-path="${COREX_ROOT}" \ + --cuda-gpu-arch=ivcore10 \ + --no-cuda-version-check \ + -D_GLIBCXX_USE_CXX11_ABI=0 \ + -DTORCH_EXTENSION_NAME=corex_gdn_causal_conv \ + -DTORCH_API_INCLUDE_EXTENSION_H \ + -I"${TORCH_ROOT}/include" \ + -I"${TORCH_ROOT}/include/torch/csrc/api/include" \ + -I"${TORCH_ROOT}/include/TH" \ + -I"${TORCH_ROOT}/include/THC" \ + -I/usr/local/include/python3.10 \ + "${SCRIPT_DIR}/corex_gdn_causal_conv.cu" \ + -L"${TORCH_ROOT}/lib" \ + -L"${COREX_ROOT}/lib64" \ + -Wl,-rpath,"${TORCH_ROOT}/lib" \ + -Wl,-rpath,"${COREX_ROOT}/lib64" \ + -ltorch_python -ltorch_cuda -ltorch_cpu -ltorch \ + -lc10_cuda -lc10 -lcudart \ + -o "${OUTPUT}" + +test -s "${OUTPUT}" +printf '[ok] CoreX GDN causal conv extension %s\n' "${OUTPUT}" diff --git a/qwen3_6_scripts/build_corex_gdn_gated_norm.sh b/qwen3_6_scripts/build_corex_gdn_gated_norm.sh new file mode 100755 index 00000000..aca1c2b4 --- /dev/null +++ b/qwen3_6_scripts/build_corex_gdn_gated_norm.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash +set -euo pipefail + +VLLM_ROOT=${1:?usage: build_corex_gdn_gated_norm.sh VLLM_ROOT} +COREX_ROOT=${COREX_ROOT:-/usr/local/corex-3.2.3} +TORCH_ROOT=${TORCH_ROOT:-${COREX_ROOT}/lib64/python3/dist-packages/torch} +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +OUTPUT=${VLLM_ROOT}/corex_gdn_gated_norm.so + +"${COREX_ROOT}/bin/clang++" \ + -std=c++17 -O3 -shared -fPIC \ + --cuda-path="${COREX_ROOT}" \ + --cuda-gpu-arch=ivcore10 \ + --no-cuda-version-check \ + -D_GLIBCXX_USE_CXX11_ABI=0 \ + -DTORCH_EXTENSION_NAME=corex_gdn_gated_norm \ + -DTORCH_API_INCLUDE_EXTENSION_H \ + -I"${TORCH_ROOT}/include" \ + -I"${TORCH_ROOT}/include/torch/csrc/api/include" \ + -I"${TORCH_ROOT}/include/TH" \ + -I"${TORCH_ROOT}/include/THC" \ + -I/usr/local/include/python3.10 \ + "${SCRIPT_DIR}/corex_gdn_gated_norm.cu" \ + -L"${TORCH_ROOT}/lib" \ + -L"${COREX_ROOT}/lib64" \ + -Wl,-rpath,"${TORCH_ROOT}/lib" \ + -Wl,-rpath,"${COREX_ROOT}/lib64" \ + -ltorch_python -ltorch_cuda -ltorch_cpu -ltorch \ + -lc10_cuda -lc10 -lcudart \ + -o "${OUTPUT}" + +test -s "${OUTPUT}" +printf '[ok] CoreX GDN gated norm extension %s\n' "${OUTPUT}" diff --git a/qwen3_6_scripts/build_corex_gdn_packed_decode.sh b/qwen3_6_scripts/build_corex_gdn_packed_decode.sh new file mode 100755 index 00000000..f3f34dd4 --- /dev/null +++ b/qwen3_6_scripts/build_corex_gdn_packed_decode.sh @@ -0,0 +1,27 @@ +#!/usr/bin/env bash +set -euo pipefail + +VLLM_ROOT=${1:?usage: build_corex_gdn_packed_decode.sh VLLM_ROOT} +COREX_ROOT=${COREX_ROOT:-/usr/local/corex-3.2.3} +TORCH_ROOT=${TORCH_ROOT:-${COREX_ROOT}/lib64/python3/dist-packages/torch} +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +OUTPUT=${VLLM_ROOT}/corex_gdn_packed_decode.so + +"${COREX_ROOT}/bin/clang++" \ + -std=c++17 -O3 -shared -fPIC \ + --cuda-path="${COREX_ROOT}" --cuda-gpu-arch=ivcore10 \ + --no-cuda-version-check -D_GLIBCXX_USE_CXX11_ABI=0 \ + -DTORCH_EXTENSION_NAME=corex_gdn_packed_decode \ + -DTORCH_API_INCLUDE_EXTENSION_H \ + -I"${TORCH_ROOT}/include" \ + -I"${TORCH_ROOT}/include/torch/csrc/api/include" \ + -I"${TORCH_ROOT}/include/TH" -I"${TORCH_ROOT}/include/THC" \ + -I/usr/local/include/python3.10 \ + "${SCRIPT_DIR}/corex_gdn_packed_decode.cu" \ + -L"${TORCH_ROOT}/lib" -L"${COREX_ROOT}/lib64" \ + -Wl,-rpath,"${TORCH_ROOT}/lib" -Wl,-rpath,"${COREX_ROOT}/lib64" \ + -ltorch_python -ltorch_cuda -ltorch_cpu -ltorch \ + -lc10_cuda -lc10 -lcudart -o "${OUTPUT}" + +test -s "${OUTPUT}" +printf '[ok] CoreX GDN packed decode extension %s\n' "${OUTPUT}" diff --git a/qwen3_6_scripts/build_corex_gdn_qk_map.sh b/qwen3_6_scripts/build_corex_gdn_qk_map.sh new file mode 100644 index 00000000..8a971ecb --- /dev/null +++ b/qwen3_6_scripts/build_corex_gdn_qk_map.sh @@ -0,0 +1,27 @@ +#!/usr/bin/env bash +set -euo pipefail + +VLLM_ROOT=${1:?usage: build_corex_gdn_qk_map.sh VLLM_ROOT} +COREX_ROOT=${COREX_ROOT:-/usr/local/corex-3.2.3} +TORCH_ROOT=${TORCH_ROOT:-${COREX_ROOT}/lib64/python3/dist-packages/torch} +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +OUTPUT=${VLLM_ROOT}/corex_gdn_qk_map.so + +"${COREX_ROOT}/bin/clang++" \ + -std=c++17 -O3 -shared -fPIC \ + --cuda-path="${COREX_ROOT}" --cuda-gpu-arch=ivcore10 \ + --no-cuda-version-check -D_GLIBCXX_USE_CXX11_ABI=0 \ + -DTORCH_EXTENSION_NAME=corex_gdn_qk_map \ + -DTORCH_API_INCLUDE_EXTENSION_H \ + -I"${TORCH_ROOT}/include" \ + -I"${TORCH_ROOT}/include/torch/csrc/api/include" \ + -I"${TORCH_ROOT}/include/TH" -I"${TORCH_ROOT}/include/THC" \ + -I/usr/local/include/python3.10 \ + "${SCRIPT_DIR}/corex_gdn_qk_map.cu" \ + -L"${TORCH_ROOT}/lib" -L"${COREX_ROOT}/lib64" \ + -Wl,-rpath,"${TORCH_ROOT}/lib" -Wl,-rpath,"${COREX_ROOT}/lib64" \ + -ltorch_python -ltorch_cuda -ltorch_cpu -ltorch \ + -lc10_cuda -lc10 -lcudart -o "${OUTPUT}" + +test -s "${OUTPUT}" +printf '[ok] CoreX GDN q/k map extension %s\n' "${OUTPUT}" diff --git a/qwen3_6_scripts/build_corex_moe_direct_routed.sh b/qwen3_6_scripts/build_corex_moe_direct_routed.sh new file mode 100755 index 00000000..c487c0b3 --- /dev/null +++ b/qwen3_6_scripts/build_corex_moe_direct_routed.sh @@ -0,0 +1,27 @@ +#!/usr/bin/env bash +set -euo pipefail + +VLLM_ROOT=${1:?usage: build_corex_moe_direct_routed.sh VLLM_ROOT} +COREX_ROOT=${COREX_ROOT:-/usr/local/corex-3.2.3} +TORCH_ROOT=${TORCH_ROOT:-${COREX_ROOT}/lib64/python3/dist-packages/torch} +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +OUTPUT=${VLLM_ROOT}/corex_moe_direct_routed.so + +"${COREX_ROOT}/bin/clang++" \ + -std=c++17 -O3 -shared -fPIC \ + --cuda-path="${COREX_ROOT}" --cuda-gpu-arch=ivcore10 \ + --no-cuda-version-check -D_GLIBCXX_USE_CXX11_ABI=0 \ + -DTORCH_EXTENSION_NAME=corex_moe_direct_routed \ + -DTORCH_API_INCLUDE_EXTENSION_H \ + -I"${TORCH_ROOT}/include" \ + -I"${TORCH_ROOT}/include/torch/csrc/api/include" \ + -I"${TORCH_ROOT}/include/TH" -I"${TORCH_ROOT}/include/THC" \ + -I/usr/local/include/python3.10 \ + "${SCRIPT_DIR}/corex_moe_direct_routed.cu" \ + -L"${TORCH_ROOT}/lib" -L"${COREX_ROOT}/lib64" \ + -Wl,-rpath,"${TORCH_ROOT}/lib" -Wl,-rpath,"${COREX_ROOT}/lib64" \ + -ltorch_python -ltorch_cuda -ltorch_cpu -ltorch \ + -lc10_cuda -lc10 -lcudart -o "${OUTPUT}" + +test -s "${OUTPUT}" +printf '[ok] CoreX direct routed-expert extension %s\n' "${OUTPUT}" diff --git a/qwen3_6_scripts/build_corex_moe_exact_reduce.sh b/qwen3_6_scripts/build_corex_moe_exact_reduce.sh new file mode 100755 index 00000000..55e4edfe --- /dev/null +++ b/qwen3_6_scripts/build_corex_moe_exact_reduce.sh @@ -0,0 +1,27 @@ +#!/usr/bin/env bash +set -euo pipefail + +VLLM_ROOT=${1:?usage: build_corex_moe_exact_reduce.sh VLLM_ROOT} +COREX_ROOT=${COREX_ROOT:-/usr/local/corex-3.2.3} +TORCH_ROOT=${TORCH_ROOT:-${COREX_ROOT}/lib64/python3/dist-packages/torch} +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +OUTPUT=${VLLM_ROOT}/corex_moe_exact_reduce.so + +"${COREX_ROOT}/bin/clang++" \ + -std=c++17 -O3 -shared -fPIC \ + --cuda-path="${COREX_ROOT}" --cuda-gpu-arch=ivcore10 \ + --no-cuda-version-check -D_GLIBCXX_USE_CXX11_ABI=0 \ + -DTORCH_EXTENSION_NAME=corex_moe_exact_reduce \ + -DTORCH_API_INCLUDE_EXTENSION_H \ + -I"${TORCH_ROOT}/include" \ + -I"${TORCH_ROOT}/include/torch/csrc/api/include" \ + -I"${TORCH_ROOT}/include/TH" -I"${TORCH_ROOT}/include/THC" \ + -I/usr/local/include/python3.10 \ + "${SCRIPT_DIR}/corex_moe_exact_reduce.cu" \ + -L"${TORCH_ROOT}/lib" -L"${COREX_ROOT}/lib64" \ + -Wl,-rpath,"${TORCH_ROOT}/lib" -Wl,-rpath,"${COREX_ROOT}/lib64" \ + -ltorch_python -ltorch_cuda -ltorch_cpu -ltorch \ + -lc10_cuda -lc10 -lcudart -o "${OUTPUT}" + +test -s "${OUTPUT}" +printf '[ok] CoreX MoE exact reduce extension %s\n' "${OUTPUT}" diff --git a/qwen3_6_scripts/build_corex_moe_weight_gather.sh b/qwen3_6_scripts/build_corex_moe_weight_gather.sh new file mode 100755 index 00000000..f01b7859 --- /dev/null +++ b/qwen3_6_scripts/build_corex_moe_weight_gather.sh @@ -0,0 +1,27 @@ +#!/usr/bin/env bash +set -euo pipefail + +VLLM_ROOT=${1:?usage: build_corex_moe_weight_gather.sh VLLM_ROOT} +COREX_ROOT=${COREX_ROOT:-/usr/local/corex-3.2.3} +TORCH_ROOT=${TORCH_ROOT:-${COREX_ROOT}/lib64/python3/dist-packages/torch} +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +OUTPUT=${VLLM_ROOT}/corex_moe_weight_gather.so + +"${COREX_ROOT}/bin/clang++" \ + -std=c++17 -O3 -shared -fPIC \ + --cuda-path="${COREX_ROOT}" --cuda-gpu-arch=ivcore10 \ + --no-cuda-version-check -D_GLIBCXX_USE_CXX11_ABI=0 \ + -DTORCH_EXTENSION_NAME=corex_moe_weight_gather \ + -DTORCH_API_INCLUDE_EXTENSION_H \ + -I"${TORCH_ROOT}/include" \ + -I"${TORCH_ROOT}/include/torch/csrc/api/include" \ + -I"${TORCH_ROOT}/include/TH" -I"${TORCH_ROOT}/include/THC" \ + -I/usr/local/include/python3.10 \ + "${SCRIPT_DIR}/corex_moe_weight_gather.cu" \ + -L"${TORCH_ROOT}/lib" -L"${COREX_ROOT}/lib64" \ + -Wl,-rpath,"${TORCH_ROOT}/lib" -Wl,-rpath,"${COREX_ROOT}/lib64" \ + -ltorch_python -ltorch_cuda -ltorch_cpu -ltorch \ + -lc10_cuda -lc10 -lcudart -o "${OUTPUT}" + +test -s "${OUTPUT}" +printf '[ok] CoreX MoE selected-weight gather extension %s\n' "${OUTPUT}" diff --git a/qwen3_6_scripts/build_corex_paged_kv_gather.sh b/qwen3_6_scripts/build_corex_paged_kv_gather.sh new file mode 100644 index 00000000..09c8c885 --- /dev/null +++ b/qwen3_6_scripts/build_corex_paged_kv_gather.sh @@ -0,0 +1,27 @@ +#!/usr/bin/env bash +set -euo pipefail + +VLLM_ROOT=${1:?usage: build_corex_paged_kv_gather.sh VLLM_ROOT} +COREX_ROOT=${COREX_ROOT:-/usr/local/corex-3.2.3} +TORCH_ROOT=${TORCH_ROOT:-${COREX_ROOT}/lib64/python3/dist-packages/torch} +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +OUTPUT=${VLLM_ROOT}/corex_paged_kv_gather.so + +"${COREX_ROOT}/bin/clang++" \ + -std=c++17 -O3 -shared -fPIC \ + --cuda-path="${COREX_ROOT}" --cuda-gpu-arch=ivcore10 \ + --no-cuda-version-check -D_GLIBCXX_USE_CXX11_ABI=0 \ + -DTORCH_EXTENSION_NAME=corex_paged_kv_gather \ + -DTORCH_API_INCLUDE_EXTENSION_H \ + -I"${TORCH_ROOT}/include" \ + -I"${TORCH_ROOT}/include/torch/csrc/api/include" \ + -I"${TORCH_ROOT}/include/TH" -I"${TORCH_ROOT}/include/THC" \ + -I/usr/local/include/python3.10 \ + "${SCRIPT_DIR}/corex_paged_kv_gather.cu" \ + -L"${TORCH_ROOT}/lib" -L"${COREX_ROOT}/lib64" \ + -Wl,-rpath,"${TORCH_ROOT}/lib" -Wl,-rpath,"${COREX_ROOT}/lib64" \ + -ltorch_python -ltorch_cuda -ltorch_cpu -ltorch \ + -lc10_cuda -lc10 -lcudart -o "${OUTPUT}" + +test -s "${OUTPUT}" +printf '[ok] CoreX paged K/V gather extension %s\n' "${OUTPUT}" diff --git a/qwen3_6_scripts/chat_utils.py b/qwen3_6_scripts/chat_utils.py index 9be41e0b..007c1e83 100644 --- a/qwen3_6_scripts/chat_utils.py +++ b/qwen3_6_scripts/chat_utils.py @@ -1,603 +1,617 @@ -import asyncio -import codecs -import json -from abc import ABC, abstractmethod -from collections import defaultdict -from functools import lru_cache, partial -from pathlib import Path -from typing import (Any, Awaitable, Dict, Generic, Iterable, List, Literal, - Mapping, Optional, Tuple, TypeVar, Union, cast) - -# yapf conflicts with isort for this block -# yapf: disable -from openai.types.chat import (ChatCompletionAssistantMessageParam, - ChatCompletionContentPartImageParam) -from openai.types.chat import ( - ChatCompletionContentPartParam as OpenAIChatCompletionContentPartParam) -from openai.types.chat import (ChatCompletionContentPartRefusalParam, - ChatCompletionContentPartTextParam) -from openai.types.chat import ( - ChatCompletionMessageParam as OpenAIChatCompletionMessageParam) -from openai.types.chat import (ChatCompletionMessageToolCallParam, - ChatCompletionToolMessageParam) -# yapf: enable -# pydantic needs the TypedDict from typing_extensions -from pydantic import ConfigDict -from transformers import PreTrainedTokenizer, PreTrainedTokenizerFast -from typing_extensions import Required, TypeAlias, TypedDict - -from vllm.config import ModelConfig -from vllm.logger import init_logger -from vllm.multimodal import MultiModalDataDict -from vllm.multimodal.utils import (async_get_and_parse_audio, - async_get_and_parse_image, - get_and_parse_audio, get_and_parse_image) -from vllm.transformers_utils.tokenizer import AnyTokenizer, MistralTokenizer - -logger = init_logger(__name__) - - -class AudioURL(TypedDict, total=False): - url: Required[str] - """ - Either a URL of the audio or a data URL with base64 encoded audio data. - """ - - -class ChatCompletionContentPartAudioParam(TypedDict, total=False): - audio_url: Required[AudioURL] - - type: Required[Literal["audio_url"]] - """The type of the content part.""" - - -class CustomChatCompletionContentPartParam(TypedDict, total=False): - __pydantic_config__ = ConfigDict(extra="allow") # type: ignore - - type: Required[str] - """The type of the content part.""" - - -ChatCompletionContentPartParam: TypeAlias = Union[ - OpenAIChatCompletionContentPartParam, ChatCompletionContentPartAudioParam, - ChatCompletionContentPartRefusalParam, - CustomChatCompletionContentPartParam] - - -class CustomChatCompletionMessageParam(TypedDict, total=False): - """Enables custom roles in the Chat Completion API.""" - role: Required[str] - """The role of the message's author.""" - - content: Union[str, List[ChatCompletionContentPartParam]] - """The contents of the message.""" - - name: str - """An optional name for the participant. - - Provides the model information to differentiate between participants of the - same role. - """ - - tool_call_id: Optional[str] - """Tool call that this message is responding to.""" - - tool_calls: Optional[Iterable[ChatCompletionMessageToolCallParam]] - """The tool calls generated by the model, such as function calls.""" - - reasoning_content: Optional[str] - """Reasoning / thinking content for assistant messages (vLLM extension). - When present in a previous assistant turn, it is rendered as - ... before the main content so the model sees its own - chain-of-thought in subsequent turns.""" - - -ChatCompletionMessageParam = Union[OpenAIChatCompletionMessageParam, - CustomChatCompletionMessageParam] - - -# TODO: Make fields ReadOnly once mypy supports it -class ConversationMessage(TypedDict, total=False): - role: Required[str] - """The role of the message's author.""" - - content: Optional[str] - """The contents of the message""" - - tool_call_id: Optional[str] - """Tool call that this message is responding to.""" - - name: Optional[str] - """The name of the function to call""" - - tool_calls: Optional[Iterable[ChatCompletionMessageToolCallParam]] - """The tool calls generated by the model, such as function calls.""" - - reasoning_content: Optional[str] - """Reasoning / thinking content for assistant messages. - Passed directly to the chat template (Qwen3 reads message.reasoning_content - natively) instead of being manually wrapped in ....""" - - -ModalityStr = Literal["image", "audio", "video"] -_T = TypeVar("_T") - - -class BaseMultiModalItemTracker(ABC, Generic[_T]): - """ - Tracks multi-modal items in a given request and ensures that the number - of multi-modal items in a given request does not exceed the configured - maximum per prompt. - """ - - def __init__(self, model_config: ModelConfig, tokenizer: AnyTokenizer): - super().__init__() - - self._model_config = model_config - self._tokenizer = tokenizer - self._allowed_items = (model_config.multimodal_config.limit_per_prompt - if model_config.multimodal_config else {}) - self._consumed_items = {k: 0 for k in self._allowed_items} - - self._items: List[_T] = [] - - @staticmethod - @lru_cache(maxsize=None) - def _cached_token_str(tokenizer: AnyTokenizer, token_index: int) -> str: - return tokenizer.decode(token_index) - - def _placeholder_str(self, modality: ModalityStr, - current_count: int) -> Optional[str]: - # TODO: Let user specify how to insert image tokens into prompt - # (similar to chat template) - hf_config = self._model_config.hf_config - model_type = hf_config.model_type - - if modality == "image": - if model_type == "phi3_v": - # Workaround since this token is not defined in the tokenizer - return f"<|image_{current_count}|>" - if model_type == "minicpmv": - return "(./)" - if model_type in ("blip-2", "chatglm", "fuyu", "paligemma", - "pixtral"): - # These models do not use image tokens in the prompt - return None - if model_type == "qwen": - return f"Picture {current_count}: " - if model_type.startswith("llava"): - return self._cached_token_str(self._tokenizer, - hf_config.image_token_index) - if model_type in ("chameleon", "internvl_chat", "NVLM_D"): - return "" - if model_type == "mllama": - return "<|image|>" - if model_type in ("qwen2_vl", "qwen2_5_vl", - "qwen3_5", "qwen3_5_moe"): +import asyncio +import codecs +import json +from abc import ABC, abstractmethod +from collections import defaultdict +from functools import lru_cache, partial +from pathlib import Path +from typing import (Any, Awaitable, Dict, Generic, Iterable, List, Literal, + Mapping, Optional, Tuple, TypeVar, Union, cast) + +# yapf conflicts with isort for this block +# yapf: disable +from openai.types.chat import (ChatCompletionAssistantMessageParam, + ChatCompletionContentPartImageParam) +from openai.types.chat import ( + ChatCompletionContentPartParam as OpenAIChatCompletionContentPartParam) +from openai.types.chat import (ChatCompletionContentPartRefusalParam, + ChatCompletionContentPartTextParam) +from openai.types.chat import ( + ChatCompletionMessageParam as OpenAIChatCompletionMessageParam) +from openai.types.chat import (ChatCompletionMessageToolCallParam, + ChatCompletionToolMessageParam) +# yapf: enable +# pydantic needs the TypedDict from typing_extensions +from pydantic import ConfigDict +from transformers import PreTrainedTokenizer, PreTrainedTokenizerFast +from typing_extensions import Required, TypeAlias, TypedDict + +from vllm.config import ModelConfig +from vllm.logger import init_logger +from vllm.multimodal import MultiModalDataDict +from vllm.multimodal.utils import (async_get_and_parse_audio, + async_get_and_parse_image, + get_and_parse_audio, get_and_parse_image) +from vllm.transformers_utils.tokenizer import AnyTokenizer, MistralTokenizer + +logger = init_logger(__name__) + + +class AudioURL(TypedDict, total=False): + url: Required[str] + """ + Either a URL of the audio or a data URL with base64 encoded audio data. + """ + + +class ChatCompletionContentPartAudioParam(TypedDict, total=False): + audio_url: Required[AudioURL] + + type: Required[Literal["audio_url"]] + """The type of the content part.""" + + +class CustomChatCompletionContentPartParam(TypedDict, total=False): + __pydantic_config__ = ConfigDict(extra="allow") # type: ignore + + type: Required[str] + """The type of the content part.""" + + +ChatCompletionContentPartParam: TypeAlias = Union[ + OpenAIChatCompletionContentPartParam, ChatCompletionContentPartAudioParam, + ChatCompletionContentPartRefusalParam, + CustomChatCompletionContentPartParam] + + +class CustomChatCompletionMessageParam(TypedDict, total=False): + """Enables custom roles in the Chat Completion API.""" + role: Required[str] + """The role of the message's author.""" + + content: Union[str, List[ChatCompletionContentPartParam]] + """The contents of the message.""" + + name: str + """An optional name for the participant. + + Provides the model information to differentiate between participants of the + same role. + """ + + tool_call_id: Optional[str] + """Tool call that this message is responding to.""" + + tool_calls: Optional[Iterable[ChatCompletionMessageToolCallParam]] + """The tool calls generated by the model, such as function calls.""" + + reasoning_content: Optional[str] + """Reasoning / thinking content for assistant messages (vLLM extension). + When present in a previous assistant turn, it is rendered as + ... before the main content so the model sees its own + chain-of-thought in subsequent turns.""" + + +ChatCompletionMessageParam = Union[OpenAIChatCompletionMessageParam, + CustomChatCompletionMessageParam] + + +# TODO: Make fields ReadOnly once mypy supports it +class ConversationMessage(TypedDict, total=False): + role: Required[str] + """The role of the message's author.""" + + content: Optional[str] + """The contents of the message""" + + tool_call_id: Optional[str] + """Tool call that this message is responding to.""" + + name: Optional[str] + """The name of the function to call""" + + tool_calls: Optional[Iterable[ChatCompletionMessageToolCallParam]] + """The tool calls generated by the model, such as function calls.""" + + reasoning_content: Optional[str] + """Reasoning / thinking content for assistant messages. + Passed directly to the chat template (Qwen3 reads message.reasoning_content + natively) instead of being manually wrapped in ....""" + + +ModalityStr = Literal["image", "audio", "video"] +_T = TypeVar("_T") + + +class BaseMultiModalItemTracker(ABC, Generic[_T]): + """ + Tracks multi-modal items in a given request and ensures that the number + of multi-modal items in a given request does not exceed the configured + maximum per prompt. + """ + + def __init__(self, model_config: ModelConfig, tokenizer: AnyTokenizer): + super().__init__() + + self._model_config = model_config + self._tokenizer = tokenizer + self._allowed_items = (model_config.multimodal_config.limit_per_prompt + if model_config.multimodal_config else {}) + self._consumed_items = {k: 0 for k in self._allowed_items} + + self._items: List[_T] = [] + + @staticmethod + @lru_cache(maxsize=None) + def _cached_token_str(tokenizer: AnyTokenizer, token_index: int) -> str: + return tokenizer.decode(token_index) + + def _placeholder_str(self, modality: ModalityStr, + current_count: int) -> Optional[str]: + # TODO: Let user specify how to insert image tokens into prompt + # (similar to chat template) + hf_config = self._model_config.hf_config + model_type = hf_config.model_type + + if modality == "image": + if model_type == "phi3_v": + # Workaround since this token is not defined in the tokenizer + return f"<|image_{current_count}|>" + if model_type == "minicpmv": + return "(./)" + if model_type in ("blip-2", "chatglm", "fuyu", "paligemma", + "pixtral"): + # These models do not use image tokens in the prompt + return None + if model_type == "qwen": + return f"Picture {current_count}: " + if model_type.startswith("llava"): + return self._cached_token_str(self._tokenizer, + hf_config.image_token_index) + if model_type in ("chameleon", "internvl_chat", "NVLM_D"): + return "" + if model_type == "mllama": + return "<|image|>" + if model_type in ("qwen2_vl", "qwen2_5_vl", "qwen3_5", + "qwen3_5_moe"): return "<|vision_start|><|image_pad|><|vision_end|>" - if model_type == "molmo": - return "" - - raise TypeError(f"Unknown model type: {model_type}") - elif modality == "audio": - if model_type == "ultravox": - return "<|reserved_special_token_0|>" - raise TypeError(f"Unknown model type: {model_type}") - elif modality == "video": - if model_type in ("qwen2_vl", "qwen2_5_vl", - "qwen3_5", "qwen3_5_moe"): - return "<|vision_start|><|video_pad|><|vision_end|>" - raise TypeError(f"Unknown model type: {model_type}") - else: - raise TypeError(f"Unknown modality: {modality}") - - @staticmethod - def _combine(items: List[MultiModalDataDict]) -> MultiModalDataDict: - mm_lists: Mapping[str, List[object]] = defaultdict(list) - - # Merge all the multi-modal items - for single_mm_data in items: - for mm_key, mm_item in single_mm_data.items(): - if isinstance(mm_item, list): - mm_lists[mm_key].extend(mm_item) - else: - mm_lists[mm_key].append(mm_item) - - # Unpack any single item lists for models that don't expect multiple. - return { - mm_key: mm_list[0] if len(mm_list) == 1 else mm_list - for mm_key, mm_list in mm_lists.items() - } - - def add(self, modality: ModalityStr, item: _T) -> Optional[str]: - """ - Add a multi-modal item to the current prompt and returns the - placeholder string to use, if any. - """ - allowed_count = self._allowed_items.get(modality, 1) - current_count = self._consumed_items.get(modality, 0) + 1 - if current_count > allowed_count: - raise ValueError( - f"At most {allowed_count} {modality}(s) may be provided in " - "one request.") - - self._consumed_items[modality] = current_count - self._items.append(item) - - return self._placeholder_str(modality, current_count) - - @abstractmethod - def create_parser(self) -> "BaseMultiModalContentParser": - raise NotImplementedError - - -class MultiModalItemTracker(BaseMultiModalItemTracker[MultiModalDataDict]): - - def all_mm_data(self) -> Optional[MultiModalDataDict]: - return self._combine(self._items) if self._items else None - - def create_parser(self) -> "BaseMultiModalContentParser": - return MultiModalContentParser(self) - - -class AsyncMultiModalItemTracker( - BaseMultiModalItemTracker[Awaitable[MultiModalDataDict]]): - - async def all_mm_data(self) -> Optional[MultiModalDataDict]: - if self._items: - items = await asyncio.gather(*self._items) - return self._combine(items) - - return None - - def create_parser(self) -> "BaseMultiModalContentParser": - return AsyncMultiModalContentParser(self) - - -class BaseMultiModalContentParser(ABC): - - def __init__(self) -> None: - super().__init__() - - # multimodal placeholder_string : count - self._placeholder_counts: Dict[str, int] = defaultdict(lambda: 0) - - def _add_placeholder(self, placeholder: Optional[str]): - if placeholder: - self._placeholder_counts[placeholder] += 1 - - def mm_placeholder_counts(self) -> Dict[str, int]: - return dict(self._placeholder_counts) - - @abstractmethod - def parse_image(self, image_url: str) -> None: - raise NotImplementedError - - @abstractmethod - def parse_audio(self, audio_url: str) -> None: - raise NotImplementedError - - -class MultiModalContentParser(BaseMultiModalContentParser): - - def __init__(self, tracker: MultiModalItemTracker) -> None: - super().__init__() - - self._tracker = tracker - - def parse_image(self, image_url: str) -> None: - image = get_and_parse_image(image_url) - - placeholder = self._tracker.add("image", image) - self._add_placeholder(placeholder) - - def parse_audio(self, audio_url: str) -> None: - audio = get_and_parse_audio(audio_url) - - placeholder = self._tracker.add("audio", audio) - self._add_placeholder(placeholder) - - -class AsyncMultiModalContentParser(BaseMultiModalContentParser): - - def __init__(self, tracker: AsyncMultiModalItemTracker) -> None: - super().__init__() - - self._tracker = tracker - - def parse_image(self, image_url: str) -> None: - image_coro = async_get_and_parse_image(image_url) - - placeholder = self._tracker.add("image", image_coro) - self._add_placeholder(placeholder) - - def parse_audio(self, audio_url: str) -> None: - audio_coro = async_get_and_parse_audio(audio_url) - - placeholder = self._tracker.add("audio", audio_coro) - self._add_placeholder(placeholder) - - -def validate_chat_template(chat_template: Optional[Union[Path, str]]): - """Raises if the provided chat template appears invalid.""" - if chat_template is None: - return - - elif isinstance(chat_template, Path) and not chat_template.exists(): - raise FileNotFoundError( - "the supplied chat template path doesn't exist") - - elif isinstance(chat_template, str): - JINJA_CHARS = "{}\n" - if not any(c in chat_template - for c in JINJA_CHARS) and not Path(chat_template).exists(): - raise ValueError( - f"The supplied chat template string ({chat_template}) " - f"appears path-like, but doesn't exist!") - - else: - raise TypeError( - f"{type(chat_template)} is not a valid chat template type") - - -def load_chat_template( - chat_template: Optional[Union[Path, str]]) -> Optional[str]: - if chat_template is None: - return None - try: - with open(chat_template, "r") as f: - resolved_chat_template = f.read() - except OSError as e: - if isinstance(chat_template, Path): - raise - - JINJA_CHARS = "{}\n" - if not any(c in chat_template for c in JINJA_CHARS): - msg = (f"The supplied chat template ({chat_template}) " - f"looks like a file path, but it failed to be " - f"opened. Reason: {e}") - raise ValueError(msg) from e - - # If opening a file fails, set chat template to be args to - # ensure we decode so our escape are interpreted correctly - resolved_chat_template = codecs.decode(chat_template, "unicode_escape") - - logger.info("Using supplied chat template:\n%s", resolved_chat_template) - return resolved_chat_template - - -# TODO: Let user specify how to insert multimodal tokens into prompt -# (similar to chat template) -def _get_full_multimodal_text_prompt(placeholder_counts: Dict[str, int], - text_prompt: str) -> str: - """Combine multimodal prompts for a multimodal language model.""" - - # Look through the text prompt to check for missing placeholders - missing_placeholders: List[str] = [] - for placeholder in placeholder_counts: - - # For any existing placeholder in the text prompt, we leave it as is - placeholder_counts[placeholder] -= text_prompt.count(placeholder) - - if placeholder_counts[placeholder] < 0: - raise ValueError( - f"Found more '{placeholder}' placeholders in input prompt than " - "actual multimodal data items.") - - missing_placeholders.extend([placeholder] * - placeholder_counts[placeholder]) - - # NOTE: For now we always add missing placeholders at the front of - # the prompt. This may change to be customizable in the future. - return "\n".join(missing_placeholders + [text_prompt]) - - -# No need to validate using Pydantic again -_TextParser = partial(cast, ChatCompletionContentPartTextParam) -_ImageParser = partial(cast, ChatCompletionContentPartImageParam) -_AudioParser = partial(cast, ChatCompletionContentPartAudioParam) -_RefusalParser = partial(cast, ChatCompletionContentPartRefusalParam) -MODEL_KEEP_MULTI_MODAL_CONTENT = {'mllama'} - - -def _parse_chat_message_content_parts( - role: str, - parts: Iterable[ChatCompletionContentPartParam], - mm_tracker: BaseMultiModalItemTracker, -) -> List[ConversationMessage]: - texts: List[str] = [] - - mm_parser = mm_tracker.create_parser() - keep_multimodal_content = \ - mm_tracker._model_config.hf_config.model_type in \ - MODEL_KEEP_MULTI_MODAL_CONTENT - - has_image = False - for part in parts: - part_type = part["type"] - if part_type == "text": - text = _TextParser(part)["text"] - texts.append(text) - elif part_type == "image_url": - image_url = _ImageParser(part)["image_url"] - - if image_url.get("detail", "auto") != "auto": - logger.warning( - "'image_url.detail' is currently not supported and " - "will be ignored.") - - mm_parser.parse_image(image_url["url"]) - has_image = True - elif part_type == "audio_url": - audio_url = _AudioParser(part)["audio_url"] - - mm_parser.parse_audio(audio_url["url"]) - elif part_type == "refusal": - text = _RefusalParser(part)["refusal"] - texts.append(text) - else: - raise NotImplementedError(f"Unknown part type: {part_type}") - - text_prompt = "\n".join(texts) - if keep_multimodal_content: - text_prompt = "\n".join(texts) - role_content = [{'type': 'text', 'text': text_prompt}] - - if has_image: - role_content = [{'type': 'image'}] + role_content - return [ConversationMessage(role=role, - content=role_content)] # type: ignore - else: - mm_placeholder_counts = mm_parser.mm_placeholder_counts() - if mm_placeholder_counts: - text_prompt = _get_full_multimodal_text_prompt( - mm_placeholder_counts, text_prompt) - return [ConversationMessage(role=role, content=text_prompt)] - - -# No need to validate using Pydantic again -_AssistantParser = partial(cast, ChatCompletionAssistantMessageParam) -_ToolParser = partial(cast, ChatCompletionToolMessageParam) - - -def _parse_chat_message_content( - message: ChatCompletionMessageParam, - mm_tracker: BaseMultiModalItemTracker, -) -> List[ConversationMessage]: - role = message["role"] - content = message.get("content") - - if content is None: - content = [] - elif isinstance(content, str): - content = [ - ChatCompletionContentPartTextParam(type="text", text=content) - ] - - result = _parse_chat_message_content_parts( - role, - content, # type: ignore - mm_tracker, - ) - - for result_msg in result: - if role == 'assistant': - parsed_msg = _AssistantParser(message) - - if "tool_calls" in parsed_msg: - result_msg["tool_calls"] = list(parsed_msg["tool_calls"]) - - # Pass reasoning content as a dedicated field so the chat template - # can render it natively (Qwen3: message.reasoning_content branch). - # Accept both "reasoning" (new vllm) and "reasoning_content" (ours). - reasoning = (message.get("reasoning") # type: ignore[arg-type] - or message.get("reasoning_content")) # type: ignore[arg-type] - if reasoning and isinstance(reasoning, str): - result_msg["reasoning_content"] = reasoning - - elif role == "tool": - parsed_msg = _ToolParser(message) - if "tool_call_id" in parsed_msg: - result_msg["tool_call_id"] = parsed_msg["tool_call_id"] - - if "name" in message and isinstance(message["name"], str): - result_msg["name"] = message["name"] - - return result - - -def _postprocess_messages(messages: List[ConversationMessage]) -> None: - # per the Transformers docs & maintainers, tool call arguments in - # assistant-role messages with tool_calls need to be dicts not JSON str - - # this is how tool-use chat templates will expect them moving forwards - # so, for messages that have tool_calls, parse the string (which we get - # from openAI format) to dict + if model_type == "molmo": + return "" + + raise TypeError(f"Unknown model type: {model_type}") + elif modality == "audio": + if model_type == "ultravox": + return "<|reserved_special_token_0|>" + raise TypeError(f"Unknown model type: {model_type}") + elif modality == "video": + if model_type in ("qwen2_vl","qwen2_5_vl"): + return "<|vision_start|><|video_pad|><|vision_end|>" + raise TypeError(f"Unknown model type: {model_type}") + else: + raise TypeError(f"Unknown modality: {modality}") + + @staticmethod + def _combine(items: List[MultiModalDataDict]) -> MultiModalDataDict: + mm_lists: Mapping[str, List[object]] = defaultdict(list) + + # Merge all the multi-modal items + for single_mm_data in items: + for mm_key, mm_item in single_mm_data.items(): + if isinstance(mm_item, list): + mm_lists[mm_key].extend(mm_item) + else: + mm_lists[mm_key].append(mm_item) + + # Unpack any single item lists for models that don't expect multiple. + return { + mm_key: mm_list[0] if len(mm_list) == 1 else mm_list + for mm_key, mm_list in mm_lists.items() + } + + def add(self, modality: ModalityStr, item: _T) -> Optional[str]: + """ + Add a multi-modal item to the current prompt and returns the + placeholder string to use, if any. + """ + allowed_count = self._allowed_items.get(modality, 1) + current_count = self._consumed_items.get(modality, 0) + 1 + if current_count > allowed_count: + raise ValueError( + f"At most {allowed_count} {modality}(s) may be provided in " + "one request.") + + self._consumed_items[modality] = current_count + self._items.append(item) + + return self._placeholder_str(modality, current_count) + + @abstractmethod + def create_parser(self) -> "BaseMultiModalContentParser": + raise NotImplementedError + + +class MultiModalItemTracker(BaseMultiModalItemTracker[MultiModalDataDict]): + + def all_mm_data(self) -> Optional[MultiModalDataDict]: + return self._combine(self._items) if self._items else None + + def create_parser(self) -> "BaseMultiModalContentParser": + return MultiModalContentParser(self) + + +class AsyncMultiModalItemTracker( + BaseMultiModalItemTracker[Awaitable[MultiModalDataDict]]): + + async def all_mm_data(self) -> Optional[MultiModalDataDict]: + if self._items: + items = await asyncio.gather(*self._items) + return self._combine(items) + + return None + + def create_parser(self) -> "BaseMultiModalContentParser": + return AsyncMultiModalContentParser(self) + + +class BaseMultiModalContentParser(ABC): + + def __init__(self) -> None: + super().__init__() + + # multimodal placeholder_string : count + self._placeholder_counts: Dict[str, int] = defaultdict(lambda: 0) + + def _add_placeholder(self, placeholder: Optional[str]): + if placeholder: + self._placeholder_counts[placeholder] += 1 + + def mm_placeholder_counts(self) -> Dict[str, int]: + return dict(self._placeholder_counts) + + @abstractmethod + def parse_image(self, image_url: str) -> None: + raise NotImplementedError + + @abstractmethod + def parse_audio(self, audio_url: str) -> None: + raise NotImplementedError + + +class MultiModalContentParser(BaseMultiModalContentParser): + + def __init__(self, tracker: MultiModalItemTracker) -> None: + super().__init__() + + self._tracker = tracker + + def parse_image(self, image_url: str) -> None: + image = get_and_parse_image(image_url) + + placeholder = self._tracker.add("image", image) + self._add_placeholder(placeholder) + + def parse_audio(self, audio_url: str) -> None: + audio = get_and_parse_audio(audio_url) + + placeholder = self._tracker.add("audio", audio) + self._add_placeholder(placeholder) + + +class AsyncMultiModalContentParser(BaseMultiModalContentParser): + + def __init__(self, tracker: AsyncMultiModalItemTracker) -> None: + super().__init__() + + self._tracker = tracker + + def parse_image(self, image_url: str) -> None: + image_coro = async_get_and_parse_image(image_url) + + placeholder = self._tracker.add("image", image_coro) + self._add_placeholder(placeholder) + + def parse_audio(self, audio_url: str) -> None: + audio_coro = async_get_and_parse_audio(audio_url) + + placeholder = self._tracker.add("audio", audio_coro) + self._add_placeholder(placeholder) + + +def validate_chat_template(chat_template: Optional[Union[Path, str]]): + """Raises if the provided chat template appears invalid.""" + if chat_template is None: + return + + elif isinstance(chat_template, Path) and not chat_template.exists(): + raise FileNotFoundError( + "the supplied chat template path doesn't exist") + + elif isinstance(chat_template, str): + JINJA_CHARS = "{}\n" + if not any(c in chat_template + for c in JINJA_CHARS) and not Path(chat_template).exists(): + raise ValueError( + f"The supplied chat template string ({chat_template}) " + f"appears path-like, but doesn't exist!") + + else: + raise TypeError( + f"{type(chat_template)} is not a valid chat template type") + + +def load_chat_template( + chat_template: Optional[Union[Path, str]]) -> Optional[str]: + if chat_template is None: + return None + try: + with open(chat_template, "r") as f: + resolved_chat_template = f.read() + except OSError as e: + if isinstance(chat_template, Path): + raise + + JINJA_CHARS = "{}\n" + if not any(c in chat_template for c in JINJA_CHARS): + msg = (f"The supplied chat template ({chat_template}) " + f"looks like a file path, but it failed to be " + f"opened. Reason: {e}") + raise ValueError(msg) from e + + # If opening a file fails, set chat template to be args to + # ensure we decode so our escape are interpreted correctly + resolved_chat_template = codecs.decode(chat_template, "unicode_escape") + + logger.info("Using supplied chat template:\n%s", resolved_chat_template) + return resolved_chat_template + + +# TODO: Let user specify how to insert multimodal tokens into prompt +# (similar to chat template) +def _get_full_multimodal_text_prompt(placeholder_counts: Dict[str, int], + text_prompt: str) -> str: + """Combine multimodal prompts for a multimodal language model.""" + + # Look through the text prompt to check for missing placeholders + missing_placeholders: List[str] = [] + for placeholder in placeholder_counts: + + # For any existing placeholder in the text prompt, we leave it as is + placeholder_counts[placeholder] -= text_prompt.count(placeholder) + + if placeholder_counts[placeholder] < 0: + raise ValueError( + f"Found more '{placeholder}' placeholders in input prompt than " + "actual multimodal data items.") + + missing_placeholders.extend([placeholder] * + placeholder_counts[placeholder]) + + # NOTE: For now we always add missing placeholders at the front of + # the prompt. This may change to be customizable in the future. + return "\n".join(missing_placeholders + [text_prompt]) + + +# No need to validate using Pydantic again +_TextParser = partial(cast, ChatCompletionContentPartTextParam) +_ImageParser = partial(cast, ChatCompletionContentPartImageParam) +_AudioParser = partial(cast, ChatCompletionContentPartAudioParam) +_RefusalParser = partial(cast, ChatCompletionContentPartRefusalParam) +MODEL_KEEP_MULTI_MODAL_CONTENT = {'mllama'} + + +def _parse_chat_message_content_parts( + role: str, + parts: Iterable[ChatCompletionContentPartParam], + mm_tracker: BaseMultiModalItemTracker, +) -> List[ConversationMessage]: + texts: List[str] = [] + + mm_parser = mm_tracker.create_parser() + keep_multimodal_content = \ + mm_tracker._model_config.hf_config.model_type in \ + MODEL_KEEP_MULTI_MODAL_CONTENT + + has_image = False + for part in parts: + part_type = part["type"] + if part_type == "text": + text = _TextParser(part)["text"] + texts.append(text) + elif part_type == "image_url": + image_url = _ImageParser(part)["image_url"] + + if image_url.get("detail", "auto") != "auto": + logger.warning( + "'image_url.detail' is currently not supported and " + "will be ignored.") + + mm_parser.parse_image(image_url["url"]) + has_image = True + elif part_type == "audio_url": + audio_url = _AudioParser(part)["audio_url"] + + mm_parser.parse_audio(audio_url["url"]) + elif part_type == "refusal": + text = _RefusalParser(part)["refusal"] + texts.append(text) + else: + raise NotImplementedError(f"Unknown part type: {part_type}") + + text_prompt = "\n".join(texts) + if keep_multimodal_content: + text_prompt = "\n".join(texts) + role_content = [{'type': 'text', 'text': text_prompt}] + + if has_image: + role_content = [{'type': 'image'}] + role_content + return [ConversationMessage(role=role, + content=role_content)] # type: ignore + else: + mm_placeholder_counts = mm_parser.mm_placeholder_counts() + if mm_placeholder_counts: + text_prompt = _get_full_multimodal_text_prompt( + mm_placeholder_counts, text_prompt) + return [ConversationMessage(role=role, content=text_prompt)] + + +# No need to validate using Pydantic again +_AssistantParser = partial(cast, ChatCompletionAssistantMessageParam) +_ToolParser = partial(cast, ChatCompletionToolMessageParam) + + +def _parse_chat_message_content( + message: ChatCompletionMessageParam, + mm_tracker: BaseMultiModalItemTracker, +) -> List[ConversationMessage]: + role = message["role"] + content = message.get("content") + + if content is None: + content = [] + elif isinstance(content, str): + content = [ + ChatCompletionContentPartTextParam(type="text", text=content) + ] + + result = _parse_chat_message_content_parts( + role, + content, # type: ignore + mm_tracker, + ) + + for result_msg in result: + if role == 'assistant': + parsed_msg = _AssistantParser(message) + + if "tool_calls" in parsed_msg: + result_msg["tool_calls"] = list(parsed_msg["tool_calls"]) + + # Pass reasoning content as a dedicated field so the chat template + # can render it natively (Qwen3: message.reasoning_content branch). + # Accept both "reasoning" (new vllm) and "reasoning_content" (ours). + reasoning = (message.get("reasoning") # type: ignore[arg-type] + or message.get("reasoning_content")) # type: ignore[arg-type] + if reasoning and isinstance(reasoning, str): + result_msg["reasoning_content"] = reasoning + + elif role == "tool": + parsed_msg = _ToolParser(message) + if "tool_call_id" in parsed_msg: + result_msg["tool_call_id"] = parsed_msg["tool_call_id"] + + if "name" in message and isinstance(message["name"], str): + result_msg["name"] = message["name"] + + return result + + +def _postprocess_messages(messages: List[ConversationMessage]) -> None: + # per the Transformers docs & maintainers, tool call arguments in + # assistant-role messages with tool_calls need to be dicts not JSON str - + # this is how tool-use chat templates will expect them moving forwards + # so, for messages that have tool_calls, parse the string (which we get + # from openAI format) to dict for message in messages: if (message["role"] == "assistant" and "tool_calls" in message - and isinstance(message["tool_calls"], list)): + and message["tool_calls"] is not None): + if not isinstance(message["tool_calls"], list): + message["tool_calls"] = list(message["tool_calls"]) for item in message["tool_calls"]: - item["function"]["arguments"] = json.loads( - item["function"]["arguments"]) - - -def parse_chat_messages( - messages: List[ChatCompletionMessageParam], - model_config: ModelConfig, - tokenizer: AnyTokenizer, -) -> Tuple[List[ConversationMessage], Optional[MultiModalDataDict]]: - conversation: List[ConversationMessage] = [] - mm_tracker = MultiModalItemTracker(model_config, tokenizer) - - for msg in messages: - sub_messages = _parse_chat_message_content(msg, mm_tracker) - - conversation.extend(sub_messages) - - _postprocess_messages(conversation) - - return conversation, mm_tracker.all_mm_data() - - -def parse_chat_messages_futures( - messages: List[ChatCompletionMessageParam], - model_config: ModelConfig, - tokenizer: AnyTokenizer, -) -> Tuple[List[ConversationMessage], Awaitable[Optional[MultiModalDataDict]]]: - conversation: List[ConversationMessage] = [] - mm_tracker = AsyncMultiModalItemTracker(model_config, tokenizer) - - for msg in messages: - sub_messages = _parse_chat_message_content(msg, mm_tracker) - - conversation.extend(sub_messages) - - _postprocess_messages(conversation) - - return conversation, mm_tracker.all_mm_data() - - -def apply_hf_chat_template( - tokenizer: Union[PreTrainedTokenizer, PreTrainedTokenizerFast], - conversation: List[ConversationMessage], - chat_template: Optional[str], - *, - tokenize: bool = False, # Different from HF's default - **kwargs: Any, -) -> str: - if chat_template is None and tokenizer.chat_template is None: - raise ValueError( - "As of transformers v4.44, default chat template is no longer " - "allowed, so you must provide a chat template if the tokenizer " - "does not define one.") - - return tokenizer.apply_chat_template( - conversation=conversation, # type: ignore[arg-type] - chat_template=chat_template, - tokenize=tokenize, - **kwargs, - ) - - -def apply_mistral_chat_template( - tokenizer: MistralTokenizer, - messages: List[ChatCompletionMessageParam], - chat_template: Optional[str] = None, - **kwargs: Any, -) -> List[int]: - if chat_template is not None: - logger.warning( - "'chat_template' cannot be overridden for mistral tokenizer.") - if "add_generation_prompt" in kwargs: - logger.warning( - "'add_generation_prompt' is not supported for mistral tokenizer, " - "so it will be ignored.") - if "continue_final_message" in kwargs: - logger.warning( - "'continue_final_message' is not supported for mistral tokenizer, " - "so it will be ignored.") - - return tokenizer.apply_chat_template( - messages=messages, - **kwargs, - ) + arguments = item["function"]["arguments"] + if isinstance(arguments, str): + try: + arguments = json.loads(arguments) + except json.JSONDecodeError as exc: + raise ValueError( + "Tool call arguments are not valid JSON.") from exc + elif not isinstance(arguments, dict): + raise TypeError( + "Tool call arguments must be a JSON object or a " + "JSON-encoded object string.") + if not isinstance(arguments, dict): + raise TypeError( + "Tool call arguments must decode to a JSON object.") + item["function"]["arguments"] = arguments + + +def parse_chat_messages( + messages: List[ChatCompletionMessageParam], + model_config: ModelConfig, + tokenizer: AnyTokenizer, +) -> Tuple[List[ConversationMessage], Optional[MultiModalDataDict]]: + conversation: List[ConversationMessage] = [] + mm_tracker = MultiModalItemTracker(model_config, tokenizer) + + for msg in messages: + sub_messages = _parse_chat_message_content(msg, mm_tracker) + + conversation.extend(sub_messages) + + _postprocess_messages(conversation) + + return conversation, mm_tracker.all_mm_data() + + +def parse_chat_messages_futures( + messages: List[ChatCompletionMessageParam], + model_config: ModelConfig, + tokenizer: AnyTokenizer, +) -> Tuple[List[ConversationMessage], Awaitable[Optional[MultiModalDataDict]]]: + conversation: List[ConversationMessage] = [] + mm_tracker = AsyncMultiModalItemTracker(model_config, tokenizer) + + for msg in messages: + sub_messages = _parse_chat_message_content(msg, mm_tracker) + + conversation.extend(sub_messages) + + _postprocess_messages(conversation) + + return conversation, mm_tracker.all_mm_data() + + +def apply_hf_chat_template( + tokenizer: Union[PreTrainedTokenizer, PreTrainedTokenizerFast], + conversation: List[ConversationMessage], + chat_template: Optional[str], + *, + tokenize: bool = False, # Different from HF's default + **kwargs: Any, +) -> str: + if chat_template is None and tokenizer.chat_template is None: + raise ValueError( + "As of transformers v4.44, default chat template is no longer " + "allowed, so you must provide a chat template if the tokenizer " + "does not define one.") + + return tokenizer.apply_chat_template( + conversation=conversation, # type: ignore[arg-type] + chat_template=chat_template, + tokenize=tokenize, + **kwargs, + ) + + +def apply_mistral_chat_template( + tokenizer: MistralTokenizer, + messages: List[ChatCompletionMessageParam], + chat_template: Optional[str] = None, + **kwargs: Any, +) -> List[int]: + if chat_template is not None: + logger.warning( + "'chat_template' cannot be overridden for mistral tokenizer.") + if "add_generation_prompt" in kwargs: + logger.warning( + "'add_generation_prompt' is not supported for mistral tokenizer, " + "so it will be ignored.") + if "continue_final_message" in kwargs: + logger.warning( + "'continue_final_message' is not supported for mistral tokenizer, " + "so it will be ignored.") + + return tokenizer.apply_chat_template( + messages=messages, + **kwargs, + ) diff --git a/qwen3_6_scripts/cli_args.py b/qwen3_6_scripts/cli_args.py index ad0698d2..292b6da5 100644 --- a/qwen3_6_scripts/cli_args.py +++ b/qwen3_6_scripts/cli_args.py @@ -1,261 +1,261 @@ -""" -This file contains the command line arguments for the vLLM's -OpenAI-compatible server. It is kept in a separate file for documentation -purposes. -""" - -import argparse -import json -import ssl -from typing import List, Optional, Sequence, Union - -from vllm.engine.arg_utils import AsyncEngineArgs, nullable_str -from vllm.entrypoints.chat_utils import validate_chat_template -from vllm.entrypoints.openai.serving_engine import (LoRAModulePath, - PromptAdapterPath) -from vllm.entrypoints.openai.tool_parsers import ToolParserManager -from vllm.utils import FlexibleArgumentParser - - -class LoRAParserAction(argparse.Action): - - def __call__( - self, - parser: argparse.ArgumentParser, - namespace: argparse.Namespace, - values: Optional[Union[str, Sequence[str]]], - option_string: Optional[str] = None, - ): - if values is None: - values = [] - if isinstance(values, str): - raise TypeError("Expected values to be a list") - - lora_list: List[LoRAModulePath] = [] - for item in values: - if item in [None, '']: # Skip if item is None or empty string - continue - if '=' in item and ',' not in item: # Old format: name=path - name, path = item.split('=') - lora_list.append(LoRAModulePath(name, path)) - else: # Assume JSON format - try: - lora_dict = json.loads(item) - lora = LoRAModulePath(**lora_dict) - lora_list.append(lora) - except json.JSONDecodeError: - parser.error( - f"Invalid JSON format for --lora-modules: {item}") - except TypeError as e: - parser.error( - f"Invalid fields for --lora-modules: {item} - {str(e)}" - ) - setattr(namespace, self.dest, lora_list) - - -class PromptAdapterParserAction(argparse.Action): - - def __call__( - self, - parser: argparse.ArgumentParser, - namespace: argparse.Namespace, - values: Optional[Union[str, Sequence[str]]], - option_string: Optional[str] = None, - ): - if values is None: - values = [] - if isinstance(values, str): - raise TypeError("Expected values to be a list") - - adapter_list: List[PromptAdapterPath] = [] - for item in values: - name, path = item.split('=') - adapter_list.append(PromptAdapterPath(name, path)) - setattr(namespace, self.dest, adapter_list) - - -def make_arg_parser(parser: FlexibleArgumentParser) -> FlexibleArgumentParser: - parser.add_argument("--host", - type=nullable_str, - default=None, - help="host name") - parser.add_argument("--port", type=int, default=8000, help="port number") - parser.add_argument( - "--uvicorn-log-level", - type=str, - default="info", - choices=['debug', 'info', 'warning', 'error', 'critical', 'trace'], - help="log level for uvicorn") - parser.add_argument("--allow-credentials", - action="store_true", - help="allow credentials") - parser.add_argument("--allowed-origins", - type=json.loads, - default=["*"], - help="allowed origins") - parser.add_argument("--allowed-methods", - type=json.loads, - default=["*"], - help="allowed methods") - parser.add_argument("--allowed-headers", - type=json.loads, - default=["*"], - help="allowed headers") - parser.add_argument("--api-key", - type=nullable_str, - default=None, - help="If provided, the server will require this key " - "to be presented in the header.") - parser.add_argument( - "--lora-modules", - type=nullable_str, - default=None, - nargs='+', - action=LoRAParserAction, - help="LoRA module configurations in either 'name=path' format" - "or JSON format. " - "Example (old format): 'name=path' " - "Example (new format): " - "'{\"name\": \"name\", \"local_path\": \"path\", " - "\"base_model_name\": \"id\"}'") - parser.add_argument( - "--prompt-adapters", - type=nullable_str, - default=None, - nargs='+', - action=PromptAdapterParserAction, - help="Prompt adapter configurations in the format name=path. " - "Multiple adapters can be specified.") - parser.add_argument("--chat-template", - type=nullable_str, - default=None, - help="The file path to the chat template, " - "or the template in single-line form " - "for the specified model") - parser.add_argument("--response-role", - type=nullable_str, - default="assistant", - help="The role name to return if " - "`request.add_generation_prompt=true`.") - parser.add_argument("--ssl-keyfile", - type=nullable_str, - default=None, - help="The file path to the SSL key file") - parser.add_argument("--ssl-certfile", - type=nullable_str, - default=None, - help="The file path to the SSL cert file") - parser.add_argument("--ssl-ca-certs", - type=nullable_str, - default=None, - help="The CA certificates file") - parser.add_argument( - "--ssl-cert-reqs", - type=int, - default=int(ssl.CERT_NONE), - help="Whether client certificate is required (see stdlib ssl module's)" - ) - parser.add_argument( - "--root-path", - type=nullable_str, - default=None, - help="FastAPI root_path when app is behind a path based routing proxy") - parser.add_argument( - "--middleware", - type=nullable_str, - action="append", - default=[], - help="Additional ASGI middleware to apply to the app. " - "We accept multiple --middleware arguments. " - "The value should be an import path. " - "If a function is provided, vLLM will add it to the server " - "using @app.middleware('http'). " - "If a class is provided, vLLM will add it to the server " - "using app.add_middleware(). ") - parser.add_argument( - "--return-tokens-as-token-ids", - action="store_true", - help="When --max-logprobs is specified, represents single tokens as " - "strings of the form 'token_id:{token_id}' so that tokens that " - "are not JSON-encodable can be identified.") - parser.add_argument( - "--disable-frontend-multiprocessing", - action="store_true", - help="If specified, will run the OpenAI frontend server in the same " - "process as the model serving engine.") - - parser.add_argument( - "--enable-auto-tool-choice", - action="store_true", - default=False, - help= - "Enable auto tool choice for supported models. Use --tool-call-parser" - "to specify which parser to use") - - valid_tool_parsers = ToolParserManager.tool_parsers.keys() - parser.add_argument( - "--tool-call-parser", - type=str, - metavar="{" + ",".join(valid_tool_parsers) + "} or name registered in " - "--tool-parser-plugin", - default=None, - help= - "Select the tool call parser depending on the model that you're using." - " This is used to parse the model-generated tool call into OpenAI API " - "format. Required for --enable-auto-tool-choice.") - - parser.add_argument( - "--tool-parser-plugin", - type=str, - default="", - help= - "Special the tool parser plugin write to parse the model-generated tool" - " into OpenAI API format, the name register in this plugin can be used " - "in --tool-call-parser.") - - parser.add_argument( - "--reasoning-parser", - type=str, - default=None, - help= - "Select the reasoning parser to split ... content into " - "reasoning_content vs content in the response. " - "Supported: qwen3") - - parser = AsyncEngineArgs.add_cli_args(parser) - - parser.add_argument('--max-log-len', - type=int, - default=None, - help='Max number of prompt characters or prompt ' - 'ID numbers being printed in log.' - '\n\nDefault: Unlimited') - - parser.add_argument( - "--disable-fastapi-docs", - action='store_true', - default=False, - help="Disable FastAPI's OpenAPI schema, Swagger UI, and ReDoc endpoint" - ) - - return parser - - -def validate_parsed_serve_args(args: argparse.Namespace): - """Quick checks for model serve args that raise prior to loading.""" - if hasattr(args, "subparser") and args.subparser != "serve": - return - - # Ensure that the chat template is valid; raises if it likely isn't - validate_chat_template(args.chat_template) - - # Enable auto tool needs a tool call parser to be valid - if args.enable_auto_tool_choice and not args.tool_call_parser: - raise TypeError("Error: --enable-auto-tool-choice requires " - "--tool-call-parser") - - -def create_parser_for_docs() -> FlexibleArgumentParser: - parser_for_docs = FlexibleArgumentParser( - prog="-m vllm.entrypoints.openai.api_server") - return make_arg_parser(parser_for_docs) +""" +This file contains the command line arguments for the vLLM's +OpenAI-compatible server. It is kept in a separate file for documentation +purposes. +""" + +import argparse +import json +import ssl +from typing import List, Optional, Sequence, Union + +from vllm.engine.arg_utils import AsyncEngineArgs, nullable_str +from vllm.entrypoints.chat_utils import validate_chat_template +from vllm.entrypoints.openai.serving_engine import (LoRAModulePath, + PromptAdapterPath) +from vllm.entrypoints.openai.tool_parsers import ToolParserManager +from vllm.utils import FlexibleArgumentParser + + +class LoRAParserAction(argparse.Action): + + def __call__( + self, + parser: argparse.ArgumentParser, + namespace: argparse.Namespace, + values: Optional[Union[str, Sequence[str]]], + option_string: Optional[str] = None, + ): + if values is None: + values = [] + if isinstance(values, str): + raise TypeError("Expected values to be a list") + + lora_list: List[LoRAModulePath] = [] + for item in values: + if item in [None, '']: # Skip if item is None or empty string + continue + if '=' in item and ',' not in item: # Old format: name=path + name, path = item.split('=') + lora_list.append(LoRAModulePath(name, path)) + else: # Assume JSON format + try: + lora_dict = json.loads(item) + lora = LoRAModulePath(**lora_dict) + lora_list.append(lora) + except json.JSONDecodeError: + parser.error( + f"Invalid JSON format for --lora-modules: {item}") + except TypeError as e: + parser.error( + f"Invalid fields for --lora-modules: {item} - {str(e)}" + ) + setattr(namespace, self.dest, lora_list) + + +class PromptAdapterParserAction(argparse.Action): + + def __call__( + self, + parser: argparse.ArgumentParser, + namespace: argparse.Namespace, + values: Optional[Union[str, Sequence[str]]], + option_string: Optional[str] = None, + ): + if values is None: + values = [] + if isinstance(values, str): + raise TypeError("Expected values to be a list") + + adapter_list: List[PromptAdapterPath] = [] + for item in values: + name, path = item.split('=') + adapter_list.append(PromptAdapterPath(name, path)) + setattr(namespace, self.dest, adapter_list) + + +def make_arg_parser(parser: FlexibleArgumentParser) -> FlexibleArgumentParser: + parser.add_argument("--host", + type=nullable_str, + default=None, + help="host name") + parser.add_argument("--port", type=int, default=8000, help="port number") + parser.add_argument( + "--uvicorn-log-level", + type=str, + default="info", + choices=['debug', 'info', 'warning', 'error', 'critical', 'trace'], + help="log level for uvicorn") + parser.add_argument("--allow-credentials", + action="store_true", + help="allow credentials") + parser.add_argument("--allowed-origins", + type=json.loads, + default=["*"], + help="allowed origins") + parser.add_argument("--allowed-methods", + type=json.loads, + default=["*"], + help="allowed methods") + parser.add_argument("--allowed-headers", + type=json.loads, + default=["*"], + help="allowed headers") + parser.add_argument("--api-key", + type=nullable_str, + default=None, + help="If provided, the server will require this key " + "to be presented in the header.") + parser.add_argument( + "--lora-modules", + type=nullable_str, + default=None, + nargs='+', + action=LoRAParserAction, + help="LoRA module configurations in either 'name=path' format" + "or JSON format. " + "Example (old format): 'name=path' " + "Example (new format): " + "'{\"name\": \"name\", \"local_path\": \"path\", " + "\"base_model_name\": \"id\"}'") + parser.add_argument( + "--prompt-adapters", + type=nullable_str, + default=None, + nargs='+', + action=PromptAdapterParserAction, + help="Prompt adapter configurations in the format name=path. " + "Multiple adapters can be specified.") + parser.add_argument("--chat-template", + type=nullable_str, + default=None, + help="The file path to the chat template, " + "or the template in single-line form " + "for the specified model") + parser.add_argument("--response-role", + type=nullable_str, + default="assistant", + help="The role name to return if " + "`request.add_generation_prompt=true`.") + parser.add_argument("--ssl-keyfile", + type=nullable_str, + default=None, + help="The file path to the SSL key file") + parser.add_argument("--ssl-certfile", + type=nullable_str, + default=None, + help="The file path to the SSL cert file") + parser.add_argument("--ssl-ca-certs", + type=nullable_str, + default=None, + help="The CA certificates file") + parser.add_argument( + "--ssl-cert-reqs", + type=int, + default=int(ssl.CERT_NONE), + help="Whether client certificate is required (see stdlib ssl module's)" + ) + parser.add_argument( + "--root-path", + type=nullable_str, + default=None, + help="FastAPI root_path when app is behind a path based routing proxy") + parser.add_argument( + "--middleware", + type=nullable_str, + action="append", + default=[], + help="Additional ASGI middleware to apply to the app. " + "We accept multiple --middleware arguments. " + "The value should be an import path. " + "If a function is provided, vLLM will add it to the server " + "using @app.middleware('http'). " + "If a class is provided, vLLM will add it to the server " + "using app.add_middleware(). ") + parser.add_argument( + "--return-tokens-as-token-ids", + action="store_true", + help="When --max-logprobs is specified, represents single tokens as " + "strings of the form 'token_id:{token_id}' so that tokens that " + "are not JSON-encodable can be identified.") + parser.add_argument( + "--disable-frontend-multiprocessing", + action="store_true", + help="If specified, will run the OpenAI frontend server in the same " + "process as the model serving engine.") + + parser.add_argument( + "--enable-auto-tool-choice", + action="store_true", + default=False, + help= + "Enable auto tool choice for supported models. Use --tool-call-parser" + "to specify which parser to use") + + valid_tool_parsers = ToolParserManager.tool_parsers.keys() + parser.add_argument( + "--tool-call-parser", + type=str, + metavar="{" + ",".join(valid_tool_parsers) + "} or name registered in " + "--tool-parser-plugin", + default=None, + help= + "Select the tool call parser depending on the model that you're using." + " This is used to parse the model-generated tool call into OpenAI API " + "format. Required for --enable-auto-tool-choice.") + + parser.add_argument( + "--tool-parser-plugin", + type=str, + default="", + help= + "Special the tool parser plugin write to parse the model-generated tool" + " into OpenAI API format, the name register in this plugin can be used " + "in --tool-call-parser.") + + parser.add_argument( + "--reasoning-parser", + type=str, + default=None, + help= + "Select the reasoning parser to split ... content into " + "reasoning_content vs content in the response. " + "Supported: qwen3") + + parser = AsyncEngineArgs.add_cli_args(parser) + + parser.add_argument('--max-log-len', + type=int, + default=None, + help='Max number of prompt characters or prompt ' + 'ID numbers being printed in log.' + '\n\nDefault: Unlimited') + + parser.add_argument( + "--disable-fastapi-docs", + action='store_true', + default=False, + help="Disable FastAPI's OpenAPI schema, Swagger UI, and ReDoc endpoint" + ) + + return parser + + +def validate_parsed_serve_args(args: argparse.Namespace): + """Quick checks for model serve args that raise prior to loading.""" + if hasattr(args, "subparser") and args.subparser != "serve": + return + + # Ensure that the chat template is valid; raises if it likely isn't + validate_chat_template(args.chat_template) + + # Enable auto tool needs a tool call parser to be valid + if args.enable_auto_tool_choice and not args.tool_call_parser: + raise TypeError("Error: --enable-auto-tool-choice requires " + "--tool-call-parser") + + +def create_parser_for_docs() -> FlexibleArgumentParser: + parser_for_docs = FlexibleArgumentParser( + prog="-m vllm.entrypoints.openai.api_server") + return make_arg_parser(parser_for_docs) diff --git a/qwen3_6_scripts/corex_attn_head_rms_norm.cu b/qwen3_6_scripts/corex_attn_head_rms_norm.cu new file mode 100644 index 00000000..6021d1da --- /dev/null +++ b/qwen3_6_scripts/corex_attn_head_rms_norm.cu @@ -0,0 +1,102 @@ +#include +#include +#include +#include + +#include + +namespace { + +constexpr int kHeadDim = 256; +constexpr int kThreads = 256; + +void check_half_matrix(const torch::Tensor& input, const char* name) { + TORCH_CHECK(input.is_cuda(), name, " must be a CUDA tensor"); + TORCH_CHECK(input.scalar_type() == torch::kFloat16, + name, " must have dtype float16"); + TORCH_CHECK(input.is_contiguous(), name, " must be contiguous"); + TORCH_CHECK(input.dim() == 2 && input.size(1) == kHeadDim, + name, " must have shape (rows, 256)"); +} + +__global__ void prepare_kernel(const __half* input, float* converted, + float* squares, int rows) { + const int row = blockIdx.x; + const int column = threadIdx.x; + if (row >= rows || column >= kHeadDim) { + return; + } + const int offset = row * kHeadDim + column; + const float value = __half2float(input[offset]); + converted[offset] = value; + squares[offset] = __fmul_rn(value, value); +} + +__global__ void apply_inverse_kernel( + const float* input, const __half* weight, const float* inverse, + __half* output, int rows) { + const int row = blockIdx.x; + const int column = threadIdx.x; + if (row >= rows || column >= kHeadDim) { + return; + } + const int offset = row * kHeadDim + column; + const float scaled = __fmul_rn(input[offset], inverse[row]); + const float factor = __fadd_rn(1.0f, __half2float(weight[column])); + output[offset] = __float2half_rn(__fmul_rn(scaled, factor)); +} + +} // namespace + +std::vector prepare(const torch::Tensor& input) { + check_half_matrix(input, "input"); + auto float_options = input.options().dtype(torch::kFloat32); + auto converted = torch::empty(input.sizes(), float_options); + auto squares = torch::empty(input.sizes(), float_options); + const int rows = static_cast(input.size(0)); + prepare_kernel<<>>( + reinterpret_cast(input.data_ptr()), + converted.data_ptr(), squares.data_ptr(), rows); + C10_CUDA_KERNEL_LAUNCH_CHECK(); + return {converted, squares}; +} + +torch::Tensor apply_inverse(const torch::Tensor& input, + const torch::Tensor& weight, + const torch::Tensor& inverse) { + TORCH_CHECK(input.is_cuda() && weight.is_cuda() && inverse.is_cuda(), + "all tensors must be CUDA tensors"); + TORCH_CHECK(input.scalar_type() == torch::kFloat32, + "input must have dtype float32"); + TORCH_CHECK(weight.scalar_type() == torch::kFloat16, + "weight must have dtype float16"); + TORCH_CHECK(inverse.scalar_type() == torch::kFloat32, + "inverse must have dtype float32"); + TORCH_CHECK(input.is_contiguous() && weight.is_contiguous() + && inverse.is_contiguous(), + "all tensors must be contiguous"); + TORCH_CHECK(input.dim() == 2 && input.size(1) == kHeadDim, + "input must have shape (rows, 256)"); + TORCH_CHECK(weight.dim() == 1 && weight.size(0) == kHeadDim, + "weight must have shape (256,)"); + TORCH_CHECK(inverse.numel() == input.size(0), + "inverse must contain one value per row"); + auto output = torch::empty( + input.sizes(), input.options().dtype(torch::kFloat16)); + const int rows = static_cast(input.size(0)); + apply_inverse_kernel<<>>( + input.data_ptr(), + reinterpret_cast(weight.data_ptr()), + inverse.data_ptr(), + reinterpret_cast<__half*>(output.data_ptr()), rows); + C10_CUDA_KERNEL_LAUNCH_CHECK(); + return output; +} + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, module) { + module.def("prepare", &prepare, + "Convert FP16 attention heads and compute exact squares"); + module.def("apply_inverse", &apply_inverse, + "Apply PyTorch-computed attention head RMSNorm inverse"); +} diff --git a/qwen3_6_scripts/corex_block_major_kv_transfer.cu b/qwen3_6_scripts/corex_block_major_kv_transfer.cu new file mode 100644 index 00000000..cac1f1c1 --- /dev/null +++ b/qwen3_6_scripts/corex_block_major_kv_transfer.cu @@ -0,0 +1,402 @@ +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +namespace { + +constexpr int kAttentionLayers = 10; +constexpr int kKvPlanes = 2; +constexpr int kElementsPerPlaneBlock = 4096; +constexpr int kElementsPerVector = 8; +constexpr int kVectorsPerPlaneBlock = + kElementsPerPlaneBlock / kElementsPerVector; +constexpr int kVectorsPerBlockMajorRow = + kAttentionLayers * kKvPlanes * kVectorsPerPlaneBlock; +constexpr int kThreads = 256; +constexpr int kMaxGridBlocks = 65535; + +using PackedVector = uint4; + +__device__ __forceinline__ const PackedVector* select_const_layer( + int layer, const PackedVector* layer0, const PackedVector* layer1, + const PackedVector* layer2, const PackedVector* layer3, + const PackedVector* layer4, const PackedVector* layer5, + const PackedVector* layer6, const PackedVector* layer7, + const PackedVector* layer8, const PackedVector* layer9) { + switch (layer) { + case 0: + return layer0; + case 1: + return layer1; + case 2: + return layer2; + case 3: + return layer3; + case 4: + return layer4; + case 5: + return layer5; + case 6: + return layer6; + case 7: + return layer7; + case 8: + return layer8; + default: + return layer9; + } +} + +__device__ __forceinline__ PackedVector* select_mutable_layer( + int layer, PackedVector* layer0, PackedVector* layer1, + PackedVector* layer2, PackedVector* layer3, PackedVector* layer4, + PackedVector* layer5, PackedVector* layer6, PackedVector* layer7, + PackedVector* layer8, PackedVector* layer9) { + switch (layer) { + case 0: + return layer0; + case 1: + return layer1; + case 2: + return layer2; + case 3: + return layer3; + case 4: + return layer4; + case 5: + return layer5; + case 6: + return layer6; + case 7: + return layer7; + case 8: + return layer8; + default: + return layer9; + } +} + +__global__ void pack_block_major_kernel( + const PackedVector* layer0, const PackedVector* layer1, + const PackedVector* layer2, const PackedVector* layer3, + const PackedVector* layer4, const PackedVector* layer5, + const PackedVector* layer6, const PackedVector* layer7, + const PackedVector* layer8, const PackedVector* layer9, + const int* source_blocks, PackedVector* staging, int* error_flag, + int count, int gpu_blocks) { + const int64_t total = + static_cast(count) * kVectorsPerBlockMajorRow; + for (int64_t linear = + static_cast(blockIdx.x) * blockDim.x + threadIdx.x; + linear < total; + linear += static_cast(blockDim.x) * gridDim.x) { + int64_t cursor = linear; + const int feature_vector = cursor % kVectorsPerPlaneBlock; + cursor /= kVectorsPerPlaneBlock; + const int kv_plane = cursor % kKvPlanes; + cursor /= kKvPlanes; + const int layer = cursor % kAttentionLayers; + const int row = cursor / kAttentionLayers; + const int source_block = source_blocks[row]; + if (static_cast(source_block) >= + static_cast(gpu_blocks)) { + atomicExch(error_flag, 1); + continue; + } + const PackedVector* source = select_const_layer( + layer, layer0, layer1, layer2, layer3, layer4, layer5, layer6, + layer7, layer8, layer9); + const int64_t source_index = + ((static_cast(kv_plane) * gpu_blocks + source_block) + * kVectorsPerPlaneBlock) + + feature_vector; + staging[linear] = source[source_index]; + } +} + +__global__ void scatter_block_major_kernel( + const PackedVector* staging, const int* destination_blocks, + PackedVector* layer0, PackedVector* layer1, PackedVector* layer2, + PackedVector* layer3, PackedVector* layer4, PackedVector* layer5, + PackedVector* layer6, PackedVector* layer7, PackedVector* layer8, + PackedVector* layer9, int* error_flag, int count, int gpu_blocks) { + const int64_t total = + static_cast(count) * kVectorsPerBlockMajorRow; + for (int64_t linear = + static_cast(blockIdx.x) * blockDim.x + threadIdx.x; + linear < total; + linear += static_cast(blockDim.x) * gridDim.x) { + int64_t cursor = linear; + const int feature_vector = cursor % kVectorsPerPlaneBlock; + cursor /= kVectorsPerPlaneBlock; + const int kv_plane = cursor % kKvPlanes; + cursor /= kKvPlanes; + const int layer = cursor % kAttentionLayers; + const int row = cursor / kAttentionLayers; + const int destination_block = destination_blocks[row]; + if (static_cast(destination_block) >= + static_cast(gpu_blocks)) { + atomicExch(error_flag, 1); + continue; + } + PackedVector* destination = select_mutable_layer( + layer, layer0, layer1, layer2, layer3, layer4, layer5, layer6, + layer7, layer8, layer9); + const int64_t destination_index = + ((static_cast(kv_plane) * gpu_blocks + destination_block) + * kVectorsPerPlaneBlock) + + feature_vector; + destination[destination_index] = staging[linear]; + } +} + +void check_gpu_layers(const std::vector& layers) { + TORCH_CHECK(layers.size() == kAttentionLayers, "expected exactly ", + kAttentionLayers, " GPU attention-layer tensors"); + const auto device = layers.front().device(); + const int64_t blocks = layers.front().size(1); + for (int layer = 0; layer < kAttentionLayers; ++layer) { + const auto& tensor = layers[layer]; + TORCH_CHECK(tensor.is_cuda(), "GPU layer ", layer, + " must be a CUDA tensor"); + TORCH_CHECK(tensor.device() == device, "GPU layer ", layer, + " is on a different device"); + TORCH_CHECK(tensor.scalar_type() == torch::kFloat16, "GPU layer ", + layer, " must use float16"); + TORCH_CHECK(tensor.is_contiguous(), "GPU layer ", layer, + " must be contiguous"); + TORCH_CHECK(tensor.dim() == 3 && tensor.size(0) == kKvPlanes && + tensor.size(1) == blocks && + tensor.size(2) == kElementsPerPlaneBlock, + "GPU layer ", layer, " must have shape [2, blocks, 4096]"); + TORCH_CHECK( + reinterpret_cast(tensor.data_ptr()) % + alignof(PackedVector) == + 0, + "GPU layer ", layer, " is not 16-byte aligned"); + } +} + +void check_gpu_transfer_args(const std::vector& layers, + const torch::Tensor& block_ids, + const torch::Tensor& staging, + const torch::Tensor& error_flag, + int64_t count) { + check_gpu_layers(layers); + TORCH_CHECK(block_ids.is_cuda(), "block_ids must be a CUDA tensor"); + TORCH_CHECK(block_ids.device() == layers.front().device(), + "block_ids must be on the cache device"); + TORCH_CHECK(block_ids.scalar_type() == torch::kInt32, + "block_ids must use int32"); + TORCH_CHECK(block_ids.dim() == 1 && block_ids.is_contiguous(), + "block_ids must be a contiguous one-dimensional tensor"); + TORCH_CHECK(count > 0 && count <= block_ids.numel(), + "count must be in [1, block_ids.numel()]"); + TORCH_CHECK(staging.is_cuda(), "staging must be a CUDA tensor"); + TORCH_CHECK(staging.device() == layers.front().device(), + "staging must be on the cache device"); + TORCH_CHECK(staging.scalar_type() == torch::kFloat16, + "staging must use float16"); + TORCH_CHECK(staging.is_contiguous(), "staging must be contiguous"); + TORCH_CHECK( + staging.dim() == 4 && staging.size(0) >= count && + staging.size(1) == kAttentionLayers && + staging.size(2) == kKvPlanes && + staging.size(3) == kElementsPerPlaneBlock, + "staging must have shape [capacity>=count, 10, 2, 4096]"); + TORCH_CHECK( + reinterpret_cast(staging.data_ptr()) % + alignof(PackedVector) == + 0, + "staging is not 16-byte aligned"); + TORCH_CHECK(error_flag.is_cuda(), + "error_flag must be a CUDA tensor"); + TORCH_CHECK(error_flag.device() == layers.front().device(), + "error_flag must be on the cache device"); + TORCH_CHECK(error_flag.scalar_type() == torch::kInt32, + "error_flag must use int32"); + TORCH_CHECK(error_flag.is_contiguous() && error_flag.numel() == 1, + "error_flag must be one contiguous int32 value"); +} + +int launch_blocks(int64_t count) { + const int64_t total = count * kVectorsPerBlockMajorRow; + return static_cast(std::min( + (total + kThreads - 1) / kThreads, kMaxGridBlocks)); +} + +void pack_block_major(const std::vector& layers, + const torch::Tensor& source_blocks, + torch::Tensor staging, torch::Tensor error_flag, + int64_t count) { + check_gpu_transfer_args( + layers, source_blocks, staging, error_flag, count); + const int blocks = static_cast(layers.front().size(1)); + pack_block_major_kernel<<>>( + reinterpret_cast( + layers[0].data_ptr()), + reinterpret_cast( + layers[1].data_ptr()), + reinterpret_cast( + layers[2].data_ptr()), + reinterpret_cast( + layers[3].data_ptr()), + reinterpret_cast( + layers[4].data_ptr()), + reinterpret_cast( + layers[5].data_ptr()), + reinterpret_cast( + layers[6].data_ptr()), + reinterpret_cast( + layers[7].data_ptr()), + reinterpret_cast( + layers[8].data_ptr()), + reinterpret_cast( + layers[9].data_ptr()), + source_blocks.data_ptr(), + reinterpret_cast(staging.data_ptr()), + error_flag.data_ptr(), static_cast(count), blocks); + C10_CUDA_KERNEL_LAUNCH_CHECK(); +} + +void scatter_block_major(const torch::Tensor& staging, + const torch::Tensor& destination_blocks, + const std::vector& layers, + torch::Tensor error_flag, + int64_t count) { + check_gpu_transfer_args( + layers, destination_blocks, staging, error_flag, count); + const int blocks = static_cast(layers.front().size(1)); + scatter_block_major_kernel<<>>( + reinterpret_cast( + staging.data_ptr()), + destination_blocks.data_ptr(), + reinterpret_cast(layers[0].data_ptr()), + reinterpret_cast(layers[1].data_ptr()), + reinterpret_cast(layers[2].data_ptr()), + reinterpret_cast(layers[3].data_ptr()), + reinterpret_cast(layers[4].data_ptr()), + reinterpret_cast(layers[5].data_ptr()), + reinterpret_cast(layers[6].data_ptr()), + reinterpret_cast(layers[7].data_ptr()), + reinterpret_cast(layers[8].data_ptr()), + reinterpret_cast(layers[9].data_ptr()), + error_flag.data_ptr(), static_cast(count), blocks); + C10_CUDA_KERNEL_LAUNCH_CHECK(); +} + +void check_transfer_error(const torch::Tensor& error_flag) { + TORCH_CHECK(error_flag.is_cuda(), + "error_flag must be a CUDA tensor"); + TORCH_CHECK(error_flag.scalar_type() == torch::kInt32, + "error_flag must use int32"); + TORCH_CHECK(error_flag.is_contiguous() && error_flag.numel() == 1, + "error_flag must be one contiguous int32 value"); + TORCH_CHECK(error_flag.item() == 0, + "GPU block mapping contains an out-of-range id"); +} + +void check_cpu_transfer_args(const torch::Tensor& pool, + const torch::Tensor& block_ids, + const torch::Tensor& staging, int64_t count) { + TORCH_CHECK(!pool.is_cuda() && !staging.is_cuda() && + !block_ids.is_cuda(), + "CPU gather/scatter tensors must be on CPU"); + TORCH_CHECK(pool.scalar_type() == torch::kFloat16 && + staging.scalar_type() == torch::kFloat16, + "CPU pool and staging must use float16"); + TORCH_CHECK(pool.is_contiguous() && staging.is_contiguous(), + "CPU pool and staging must be contiguous"); + TORCH_CHECK( + pool.dim() == 4 && pool.size(1) == kAttentionLayers && + pool.size(2) == kKvPlanes && + pool.size(3) == kElementsPerPlaneBlock, + "CPU pool must have shape [slots, 10, 2, 4096]"); + TORCH_CHECK( + staging.dim() == 4 && staging.size(0) >= count && + staging.size(1) == kAttentionLayers && + staging.size(2) == kKvPlanes && + staging.size(3) == kElementsPerPlaneBlock, + "CPU staging must have shape [capacity>=count, 10, 2, 4096]"); + TORCH_CHECK(block_ids.scalar_type() == torch::kInt64, + "CPU block_ids must use int64"); + TORCH_CHECK(block_ids.dim() == 1 && block_ids.is_contiguous(), + "CPU block_ids must be contiguous and one-dimensional"); + TORCH_CHECK(count > 0 && count <= block_ids.numel(), + "count must be in [1, block_ids.numel()]"); + + const int64_t* ids = block_ids.data_ptr(); + for (int64_t row = 0; row < count; ++row) { + TORCH_CHECK(ids[row] >= 0 && ids[row] < pool.size(0), + "CPU block id out of range at row ", row, ": ", ids[row]); + } +} + +void cpu_gather_rows(const torch::Tensor& pool, + const torch::Tensor& source_blocks, + torch::Tensor staging, int64_t count) { + check_cpu_transfer_args(pool, source_blocks, staging, count); + const int64_t row_elements = + kAttentionLayers * kKvPlanes * kElementsPerPlaneBlock; + const size_t row_bytes = + static_cast(row_elements) * sizeof(at::Half); + const char* source = reinterpret_cast( + pool.data_ptr()); + char* destination = + reinterpret_cast(staging.data_ptr()); + const int64_t* ids = source_blocks.data_ptr(); + at::parallel_for(0, count, 8, [&](int64_t begin, int64_t end) { + for (int64_t row = begin; row < end; ++row) { + std::memcpy(destination + row * row_bytes, + source + ids[row] * row_bytes, row_bytes); + } + }); +} + +void cpu_scatter_rows(const torch::Tensor& staging, + torch::Tensor pool, + const torch::Tensor& destination_blocks, + int64_t count) { + check_cpu_transfer_args(pool, destination_blocks, staging, count); + const int64_t row_elements = + kAttentionLayers * kKvPlanes * kElementsPerPlaneBlock; + const size_t row_bytes = + static_cast(row_elements) * sizeof(at::Half); + const char* source = reinterpret_cast( + staging.data_ptr()); + char* destination = + reinterpret_cast(pool.data_ptr()); + const int64_t* ids = destination_blocks.data_ptr(); + at::parallel_for(0, count, 8, [&](int64_t begin, int64_t end) { + for (int64_t row = begin; row < end; ++row) { + std::memcpy(destination + ids[row] * row_bytes, + source + row * row_bytes, row_bytes); + } + }); +} + +} // namespace + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, module) { + module.def("pack", &pack_block_major, + "Pack ten layer-major FP16 KV caches into block-major staging"); + module.def("scatter", &scatter_block_major, + "Scatter block-major FP16 staging into ten layer-major caches"); + module.def("check_error", &check_transfer_error, + "Fail fast after a bounds-safe asynchronous transfer"); + module.def("cpu_gather", &cpu_gather_rows, + "Gather block-major CPU pool rows into bounded staging"); + module.def("cpu_scatter", &cpu_scatter_rows, + "Scatter bounded staging rows into the block-major CPU pool"); +} diff --git a/qwen3_6_scripts/corex_fused_paged_prefill_split4.cu b/qwen3_6_scripts/corex_fused_paged_prefill_split4.cu new file mode 100644 index 00000000..bbd12508 --- /dev/null +++ b/qwen3_6_scripts/corex_fused_paged_prefill_split4.cu @@ -0,0 +1,494 @@ +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +namespace { + +constexpr int kBlockSize = 16; +constexpr int kHeadDim = 256; +constexpr int kKeyPack = 8; +constexpr int kNumQueryHeads = 4; +constexpr int kNumKvHeads = 1; +constexpr int kTileTokens = 512; +constexpr int kSplitCount = 4; +constexpr int kGroupTokens = kSplitCount * kTileTokens; +constexpr int kThreads = 256; +constexpr int kMaxQueryTokens = 8192; +constexpr int kMaxSequenceTokens = 262144; + +void check_half_cuda_contiguous(const torch::Tensor& tensor, + const char* name) { + TORCH_CHECK(tensor.is_cuda(), name, " must be a CUDA tensor"); + TORCH_CHECK(tensor.scalar_type() == torch::kFloat16, + name, " must have dtype float16"); + TORCH_CHECK(tensor.is_contiguous(), name, " must be contiguous"); +} + +__global__ void convert_query_kernel(const __half* query, float* converted, + int query_len, float scale) { + const int64_t total = static_cast(query_len) + * kNumQueryHeads * kHeadDim; + for (int64_t index = + static_cast(blockIdx.x) * blockDim.x + threadIdx.x; + index < total; + index += static_cast(blockDim.x) * gridDim.x) { + const int dim = index % kHeadDim; + const int query_index = + (index / kHeadDim) % query_len; + const int head = + index / (static_cast(kHeadDim) * query_len); + const int64_t source = + (static_cast(query_index) * kNumQueryHeads + head) + * kHeadDim + dim; + converted[index] = __half2float(query[source]) * scale; + } +} + +__global__ void gather_kv_group_kernel( + const __half* key_new, const __half* value_new, + const __half* key_cache, const __half* value_cache, + const int* block_table, float* key_tiles, float* value_tiles, + int context_len, int query_len, int group_start, int group_tokens, + int active_splits) { + constexpr int kElements = kTileTokens * kHeadDim; + const int64_t total = static_cast(active_splits) * kElements; + for (int64_t index = + static_cast(blockIdx.x) * blockDim.x + threadIdx.x; + index < total; + index += static_cast(blockDim.x) * gridDim.x) { + const int split = index / kElements; + const int element = index - static_cast(split) * kElements; + const int token_offset = element / kHeadDim; + const int dim = element - token_offset * kHeadDim; + const int remaining_tokens = group_tokens - split * kTileTokens; + const int split_tokens = + remaining_tokens < kTileTokens ? remaining_tokens : kTileTokens; + const int logical_token = + group_start + split * kTileTokens + token_offset; + float key_value = 0.0f; + float value_value = 0.0f; + if (token_offset >= split_tokens) { + // The fixed 512-column GEMMs require zero-filled tail columns. + } else if (logical_token < context_len) { + const int logical_block = logical_token / kBlockSize; + const int block_offset = logical_token % kBlockSize; + const int physical_block = block_table[logical_block]; + const int64_t key_index = + (((static_cast(physical_block) * kNumKvHeads) + * (kHeadDim / kKeyPack) + dim / kKeyPack) + * kBlockSize + block_offset) * kKeyPack + dim % kKeyPack; + const int64_t value_index = + ((static_cast(physical_block) * kNumKvHeads) + * kHeadDim + dim) * kBlockSize + block_offset; + key_value = __half2float(key_cache[key_index]); + value_value = __half2float(value_cache[value_index]); + } else if (logical_token < context_len + query_len) { + const int query_index = logical_token - context_len; + const int64_t source = + static_cast(query_index) * kHeadDim + dim; + key_value = __half2float(key_new[source]); + value_value = __half2float(value_new[source]); + } + key_tiles[index] = key_value; + value_tiles[index] = value_value; + } +} + +__global__ void mask_group_scores_kernel( + float* scores, int query_len, int context_len, + int group_start, int group_tokens, int active_splits, + int rows, bool causal) { + const int64_t split_elements = + static_cast(rows) * kTileTokens; + const int64_t elements = active_splits * split_elements; + for (int64_t index = + static_cast(blockIdx.x) * blockDim.x + threadIdx.x; + index < elements; + index += static_cast(blockDim.x) * gridDim.x) { + const int split = index / split_elements; + const int split_index = index - split * split_elements; + const int column = split_index % kTileTokens; + const int row = split_index / kTileTokens; + const int query_index = row % query_len; + const int remaining_tokens = group_tokens - split * kTileTokens; + const int split_tokens = + remaining_tokens < kTileTokens ? remaining_tokens : kTileTokens; + const int logical_token = + group_start + split * kTileTokens + column; + if (column >= split_tokens + || (causal && logical_token > context_len + query_index)) { + scores[index] = -std::numeric_limits::infinity(); + } + } +} + +__global__ void normalize_split_scores_kernel( + float* scores, float* corrections, float* running_max, + float* running_sum, int active_splits, int rows) { + const int row = blockIdx.x; + if (row >= rows) { + return; + } + + __shared__ float reduction[kThreads]; + __shared__ float state_max; + __shared__ float state_sum; + __shared__ float next_max; + __shared__ float correction; + + if (threadIdx.x == 0) { + state_max = running_max[row]; + state_sum = running_sum[row]; + } + __syncthreads(); + + for (int split = 0; split < active_splits; ++split) { + float* row_scores = + scores + (static_cast(split) * rows + row) * kTileTokens; + float local_max = -std::numeric_limits::infinity(); + for (int column = threadIdx.x; column < kTileTokens; + column += blockDim.x) { + local_max = fmaxf(local_max, row_scores[column]); + } + reduction[threadIdx.x] = local_max; + __syncthreads(); + for (int stride = kThreads / 2; stride > 0; stride /= 2) { + if (threadIdx.x < stride) { + reduction[threadIdx.x] = fmaxf( + reduction[threadIdx.x], reduction[threadIdx.x + stride]); + } + __syncthreads(); + } + if (threadIdx.x == 0) { + next_max = fmaxf(state_max, reduction[0]); + correction = + (state_max == -std::numeric_limits::infinity() + && next_max == -std::numeric_limits::infinity()) + ? 1.0f + : expf(state_max - next_max); + corrections[static_cast(split) * rows + row] = correction; + } + __syncthreads(); + + float local_sum = 0.0f; + for (int column = threadIdx.x; column < kTileTokens; + column += blockDim.x) { + const float score = row_scores[column]; + const float probability = + (score == -std::numeric_limits::infinity() + && next_max == -std::numeric_limits::infinity()) + ? 0.0f + : expf(score - next_max); + row_scores[column] = probability; + local_sum = __fadd_rn(local_sum, probability); + } + reduction[threadIdx.x] = local_sum; + __syncthreads(); + for (int stride = kThreads / 2; stride > 0; stride /= 2) { + if (threadIdx.x < stride) { + reduction[threadIdx.x] = __fadd_rn( + reduction[threadIdx.x], reduction[threadIdx.x + stride]); + } + __syncthreads(); + } + if (threadIdx.x == 0) { + state_sum = __fadd_rn( + __fmul_rn(state_sum, correction), reduction[0]); + state_max = next_max; + } + __syncthreads(); + } + + if (threadIdx.x == 0) { + running_max[row] = state_max; + running_sum[row] = state_sum; + } +} + +__global__ void merge_split_output_kernel( + float* running_output, const float* split_output, + const float* corrections, int active_splits, + int rows, int64_t output_elements) { + for (int64_t index = + static_cast(blockIdx.x) * blockDim.x + threadIdx.x; + index < output_elements; + index += static_cast(blockDim.x) * gridDim.x) { + const int row = index / kHeadDim; + float value = running_output[index]; + for (int split = 0; split < active_splits; ++split) { + const int64_t row_index = + static_cast(split) * rows + row; + const int64_t output_index = + static_cast(split) * output_elements + index; + value = __fadd_rn( + __fmul_rn(value, corrections[row_index]), + split_output[output_index]); + } + running_output[index] = value; + } +} + +__global__ void accumulate_output_kernel( + float* running_output, const float* tile_output, + const float* correction, int64_t elements) { + for (int64_t index = + static_cast(blockIdx.x) * blockDim.x + threadIdx.x; + index < elements; + index += static_cast(blockDim.x) * gridDim.x) { + const int row = index / kHeadDim; + const float scaled = + __fmul_rn(running_output[index], correction[row]); + running_output[index] = __fadd_rn(scaled, tile_output[index]); + } +} + +int launch_blocks(int64_t elements) { + const int64_t needed = (elements + kThreads - 1) / kThreads; + return static_cast(std::min(needed, 65535)); +} + +void check_cublas(cublasStatus_t status, const char* operation) { + TORCH_CHECK(status == CUBLAS_STATUS_SUCCESS, operation, + " failed with cuBLAS status ", static_cast(status)); +} + +cublasStatus_t qk_batched( + cublasHandle_t handle, const float* key_tile, const float* query, + float* scores, int query_len) { + const float alpha = 1.0f; + const float beta = 0.0f; + return cublasSgemmStridedBatched( + handle, CUBLAS_OP_T, CUBLAS_OP_N, + kTileTokens, query_len, kHeadDim, + &alpha, key_tile, kHeadDim, 0, + query, kHeadDim, static_cast(query_len) * kHeadDim, + &beta, scores, kTileTokens, + static_cast(query_len) * kTileTokens, + kNumQueryHeads); +} + +cublasStatus_t pv_batched( + cublasHandle_t handle, const float* value_tile, const float* scores, + float* output, int query_len) { + const float alpha = 1.0f; + const float beta = 0.0f; + return cublasSgemmStridedBatched( + handle, CUBLAS_OP_N, CUBLAS_OP_N, + kHeadDim, query_len, kTileTokens, + &alpha, value_tile, kHeadDim, 0, + scores, kTileTokens, + static_cast(query_len) * kTileTokens, + &beta, output, kHeadDim, + static_cast(query_len) * kHeadDim, + kNumQueryHeads); +} + +} // namespace + +std::vector fused_paged_prefill_forward( + const torch::Tensor& query, const torch::Tensor& key_new, + const torch::Tensor& value_new, const torch::Tensor& key_cache, + const torch::Tensor& value_cache, const torch::Tensor& block_table, + int64_t context_len_arg, double scale_arg) { + check_half_cuda_contiguous(query, "query"); + check_half_cuda_contiguous(key_new, "key_new"); + check_half_cuda_contiguous(value_new, "value_new"); + check_half_cuda_contiguous(key_cache, "key_cache"); + check_half_cuda_contiguous(value_cache, "value_cache"); + TORCH_CHECK(block_table.is_cuda(), + "block_table must be a CUDA tensor"); + TORCH_CHECK(block_table.scalar_type() == torch::kInt32, + "block_table must have dtype int32"); + TORCH_CHECK(block_table.is_contiguous(), + "block_table must be contiguous"); + TORCH_CHECK(block_table.dim() == 1, + "block_table must be one-dimensional"); + TORCH_CHECK(query.dim() == 3 && query.size(1) == kNumQueryHeads + && query.size(2) == kHeadDim, + "query must have shape (Q, 4, 256)"); + TORCH_CHECK(key_new.dim() == 3 && key_new.size(1) == kNumKvHeads + && key_new.size(2) == kHeadDim, + "key_new must have shape (Q, 1, 256)"); + TORCH_CHECK(value_new.sizes() == key_new.sizes(), + "value_new must match key_new"); + TORCH_CHECK(key_new.size(0) == query.size(0), + "query, key_new, and value_new lengths must match"); + TORCH_CHECK(key_cache.dim() == 5 + && key_cache.size(1) == kNumKvHeads + && key_cache.size(2) == kHeadDim / kKeyPack + && key_cache.size(3) == kBlockSize + && key_cache.size(4) == kKeyPack, + "key_cache must have shape (N, 1, 32, 16, 8)"); + TORCH_CHECK(value_cache.dim() == 4 + && value_cache.size(1) == kNumKvHeads + && value_cache.size(2) == kHeadDim + && value_cache.size(3) == kBlockSize, + "value_cache must have shape (N, 1, 256, 16)"); + TORCH_CHECK(key_cache.size(0) == value_cache.size(0), + "key/value cache block counts must match"); + TORCH_CHECK(query.device() == key_new.device() + && query.device() == value_new.device() + && query.device() == key_cache.device() + && query.device() == value_cache.device() + && query.device() == block_table.device(), + "all tensors must use the same device"); + TORCH_CHECK(context_len_arg >= 0 + && context_len_arg <= kMaxSequenceTokens, + "context_len is out of range"); + TORCH_CHECK(context_len_arg % kBlockSize == 0, + "context_len must be block aligned"); + const int query_len = static_cast(query.size(0)); + const int context_len = static_cast(context_len_arg); + TORCH_CHECK(query_len > 0 && query_len <= kMaxQueryTokens, + "query length must be in [1, 8192]"); + TORCH_CHECK(context_len + query_len <= kMaxSequenceTokens, + "context_len + query_len exceeds 262144"); + const int required_blocks = + (context_len + kBlockSize - 1) / kBlockSize; + TORCH_CHECK(block_table.numel() >= required_blocks, + "block_table is too short for context_len"); + if (required_blocks > 0) { + auto active_blocks = block_table.narrow(0, 0, required_blocks); + const int minimum_block = active_blocks.min().item(); + const int maximum_block = active_blocks.max().item(); + TORCH_CHECK(minimum_block >= 0 + && maximum_block < key_cache.size(0), + "block_table contains an out-of-range physical block ID"); + } + TORCH_CHECK(std::isfinite(scale_arg) && scale_arg > 0.0, + "scale must be finite and positive"); + TORCH_CHECK(query_len <= std::numeric_limits::max() / kNumQueryHeads, + "query length overflows row count"); + + const int rows = kNumQueryHeads * query_len; + const int64_t output_elements = + static_cast(rows) * kHeadDim; + auto float_options = query.options().dtype(torch::kFloat32); + auto converted_query = torch::empty( + {kNumQueryHeads, query_len, kHeadDim}, float_options); + auto key_tiles = torch::empty( + {kSplitCount, kTileTokens, kHeadDim}, float_options); + auto value_tiles = torch::empty( + {kSplitCount, kTileTokens, kHeadDim}, float_options); + auto scores = torch::empty( + {kSplitCount, kNumQueryHeads, query_len, kTileTokens}, + float_options); + auto split_output = torch::empty( + {kSplitCount, kNumQueryHeads, query_len, kHeadDim}, + float_options); + auto running_max = torch::full( + {kNumQueryHeads, query_len}, + -std::numeric_limits::infinity(), float_options); + auto running_sum = torch::zeros( + {kNumQueryHeads, query_len}, float_options); + auto running_output = torch::zeros( + {kNumQueryHeads, query_len, kHeadDim}, float_options); + auto corrections = torch::empty( + {kSplitCount, kNumQueryHeads, query_len}, float_options); + + auto stream = at::cuda::getCurrentCUDAStream(); + convert_query_kernel<<>>( + reinterpret_cast(query.data_ptr()), + converted_query.data_ptr(), query_len, + static_cast(scale_arg)); + C10_CUDA_KERNEL_LAUNCH_CHECK(); + + cublasHandle_t handle = at::cuda::getCurrentCUDABlasHandle(); + check_cublas(cublasSetStream(handle, stream), "cublasSetStream"); + const int64_t key_split_stride = + static_cast(kTileTokens) * kHeadDim; + const int64_t score_split_stride = + static_cast(rows) * kTileTokens; + const int64_t output_split_stride = output_elements; + const auto run_group = [&](int group_start, int group_tokens, + bool causal) { + const int active_splits = + (group_tokens + kTileTokens - 1) / kTileTokens; + TORCH_CHECK(active_splits > 0 && active_splits <= kSplitCount, + "invalid split count for paged-prefill group"); + constexpr int kGatherBlocks = 512; + gather_kv_group_kernel<<>>( + reinterpret_cast(key_new.data_ptr()), + reinterpret_cast(value_new.data_ptr()), + reinterpret_cast(key_cache.data_ptr()), + reinterpret_cast(value_cache.data_ptr()), + block_table.data_ptr(), key_tiles.data_ptr(), + value_tiles.data_ptr(), context_len, query_len, group_start, + group_tokens, active_splits); + C10_CUDA_KERNEL_LAUNCH_CHECK(); + + for (int split = 0; split < active_splits; ++split) { + check_cublas(qk_batched( + handle, + key_tiles.data_ptr() + split * key_split_stride, + converted_query.data_ptr(), + scores.data_ptr() + split * score_split_stride, + query_len), "split4 paged prefill QK"); + } + + const bool needs_mask = + causal || group_tokens != active_splits * kTileTokens; + if (needs_mask) { + const int64_t score_elements = + static_cast(active_splits) * score_split_stride; + mask_group_scores_kernel<<< + launch_blocks(score_elements), kThreads, 0, stream>>>( + scores.data_ptr(), query_len, context_len, group_start, + group_tokens, active_splits, rows, causal); + C10_CUDA_KERNEL_LAUNCH_CHECK(); + } + + normalize_split_scores_kernel<<>>( + scores.data_ptr(), corrections.data_ptr(), + running_max.data_ptr(), running_sum.data_ptr(), + active_splits, rows); + C10_CUDA_KERNEL_LAUNCH_CHECK(); + + for (int split = 0; split < active_splits; ++split) { + check_cublas(pv_batched( + handle, + value_tiles.data_ptr() + split * key_split_stride, + scores.data_ptr() + split * score_split_stride, + split_output.data_ptr() + split * output_split_stride, + query_len), "split4 paged prefill PV"); + } + + merge_split_output_kernel<<< + launch_blocks(output_elements), kThreads, 0, stream>>>( + running_output.data_ptr(), split_output.data_ptr(), + corrections.data_ptr(), active_splits, rows, + output_elements); + C10_CUDA_KERNEL_LAUNCH_CHECK(); + }; + for (int group_start = 0; group_start < context_len; + group_start += kGroupTokens) { + run_group(group_start, + std::min(kGroupTokens, context_len - group_start), false); + } + for (int key_start = 0; key_start < query_len; + key_start += kGroupTokens) { + run_group(context_len + key_start, + std::min(kGroupTokens, query_len - key_start), true); + } + + running_output.div_(running_sum.unsqueeze(-1)); + auto output = running_output.permute({1, 0, 2}) + .to(query.scalar_type()).contiguous(); + auto lse = (running_max + at::log(running_sum)) + .transpose(0, 1).contiguous(); + return {output, lse}; +} + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, module) { + module.def("forward", &fused_paged_prefill_forward, + "Fixed-shape FP32 paged-prefill pipeline for cache-only context"); +} diff --git a/qwen3_6_scripts/corex_gdn_beta_decay.cu b/qwen3_6_scripts/corex_gdn_beta_decay.cu new file mode 100644 index 00000000..48e50dc6 --- /dev/null +++ b/qwen3_6_scripts/corex_gdn_beta_decay.cu @@ -0,0 +1,84 @@ +#include +#include +#include +#include + +namespace { + +__global__ void beta_decay_kernel(const half* beta_input, + const half* decay_input, + const half* a_log, + const half* dt_bias, + float* output, int elements, + int heads) { + const int index = blockIdx.x * blockDim.x + threadIdx.x; + if (index >= elements) { + return; + } + const int head = index % heads; + + const float beta_value = __half2float(beta_input[index]); + const float beta_fp32 = 1.0f / (1.0f + expf(-beta_value)); + output[index] = __half2float(__float2half(beta_fp32)); + + const float x = (__half2float(decay_input[index]) + + __half2float(dt_bias[head])); + const float softplus = x > 20.0f ? x : log1pf(expf(x)); + output[elements + index] = expf( + -expf(__half2float(a_log[head])) * softplus); +} + +void check_half(const torch::Tensor& tensor, const char* name) { + TORCH_CHECK(tensor.is_cuda(), name, " must be a CUDA tensor"); + TORCH_CHECK(tensor.scalar_type() == torch::kFloat16, + name, " must have dtype float16"); + TORCH_CHECK(tensor.is_contiguous(), name, " must be contiguous"); + TORCH_CHECK(tensor.dim() == 2, name, " must have shape (batch, heads)"); +} + +void check_half_vector(const torch::Tensor& tensor, const char* name) { + TORCH_CHECK(tensor.is_cuda(), name, " must be a CUDA tensor"); + TORCH_CHECK(tensor.scalar_type() == torch::kFloat16, + name, " must have dtype float16"); + TORCH_CHECK(tensor.is_contiguous(), name, " must be contiguous"); + TORCH_CHECK(tensor.dim() == 1, name, " must have shape (heads)"); +} + +} // namespace + +torch::Tensor beta_decay(const torch::Tensor& beta_input, + const torch::Tensor& decay_input, + const torch::Tensor& a_log, + const torch::Tensor& dt_bias) { + check_half(beta_input, "beta_input"); + check_half(decay_input, "decay_input"); + check_half_vector(a_log, "a_log"); + check_half_vector(dt_bias, "dt_bias"); + TORCH_CHECK(beta_input.sizes() == decay_input.sizes(), + "beta_input and decay_input shapes must match"); + TORCH_CHECK(beta_input.size(1) == a_log.size(0) && + a_log.sizes() == dt_bias.sizes(), + "parameter heads must match input heads"); + + const int elements = static_cast(beta_input.numel()); + const int heads = static_cast(beta_input.size(1)); + torch::Tensor output = torch::empty( + {2, beta_input.size(0), beta_input.size(1)}, + beta_input.options().dtype(torch::kFloat32)); + constexpr int threads = 128; + const int blocks = (elements + threads - 1) / threads; + beta_decay_kernel<<>>( + reinterpret_cast(beta_input.data_ptr()), + reinterpret_cast(decay_input.data_ptr()), + reinterpret_cast(a_log.data_ptr()), + reinterpret_cast(dt_bias.data_ptr()), + output.data_ptr(), elements, heads); + C10_CUDA_KERNEL_LAUNCH_CHECK(); + return output; +} + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, module) { + module.def("beta_decay", &beta_decay, + "Fused GDN beta sigmoid and decay factor"); +} diff --git a/qwen3_6_scripts/corex_gdn_causal_conv.cu b/qwen3_6_scripts/corex_gdn_causal_conv.cu new file mode 100644 index 00000000..6101d5ce --- /dev/null +++ b/qwen3_6_scripts/corex_gdn_causal_conv.cu @@ -0,0 +1,89 @@ +#include +#include +#include +#include + +namespace { + +constexpr int kStateLen = 3; +constexpr int kKernelSize = kStateLen + 1; +constexpr int kThreads = 256; + +__global__ void causal_conv_update_kernel( + float* state, const __half* hidden, const __half* weight, + __half* output, int channels) { + const int channel = blockIdx.x * blockDim.x + threadIdx.x; + const int batch = blockIdx.y; + if (channel >= channels) { + return; + } + + const int state_offset = (batch * channels + channel) * kStateLen; + const int vector_offset = batch * channels + channel; + const int weight_offset = channel * kKernelSize; + const __half current = hidden[vector_offset]; + const __half state0 = __float2half_rn(state[state_offset]); + const __half state1 = __float2half_rn(state[state_offset + 1]); + const __half state2 = __float2half_rn(state[state_offset + 2]); + + float value = __half2float(state0) * __half2float(weight[weight_offset]); + value += __half2float(state1) * __half2float(weight[weight_offset + 1]); + value += __half2float(state2) * __half2float(weight[weight_offset + 2]); + value += __half2float(current) * __half2float(weight[weight_offset + 3]); + + state[state_offset] = __half2float(state1); + state[state_offset + 1] = __half2float(state2); + state[state_offset + 2] = __half2float(current); + const __half convolved = __float2half_rn(value); + const float activation_input = __half2float(convolved); + output[vector_offset] = __float2half_rn( + activation_input / (1.0f + expf(-activation_input))); +} + +void check_half_cuda_contiguous(const torch::Tensor& tensor, + const char* name) { + TORCH_CHECK(tensor.is_cuda(), name, " must be a CUDA tensor"); + TORCH_CHECK(tensor.scalar_type() == torch::kFloat16, + name, " must have dtype float16"); + TORCH_CHECK(tensor.is_contiguous(), name, " must be contiguous"); +} + +} // namespace + +torch::Tensor causal_conv_update(torch::Tensor state, + const torch::Tensor& hidden, + const torch::Tensor& weight) { + TORCH_CHECK(state.is_cuda(), "state must be a CUDA tensor"); + TORCH_CHECK(state.scalar_type() == torch::kFloat32, + "state must have dtype float32"); + TORCH_CHECK(state.is_contiguous(), "state must be contiguous"); + check_half_cuda_contiguous(hidden, "hidden"); + check_half_cuda_contiguous(weight, "weight"); + TORCH_CHECK(state.dim() == 3 && state.size(2) == kStateLen, + "state must have shape (batch, channels, 3)"); + TORCH_CHECK(hidden.dim() == 3 && hidden.size(2) == 1 && + hidden.size(0) == state.size(0) && + hidden.size(1) == state.size(1), + "hidden must have shape (batch, channels, 1)"); + TORCH_CHECK(weight.dim() == 2 && weight.size(0) == state.size(1) && + weight.size(1) == kKernelSize, + "weight must have shape (channels, 4)"); + + auto output = torch::empty_like(hidden); + const int channels = static_cast(state.size(1)); + const dim3 blocks((channels + kThreads - 1) / kThreads, + static_cast(state.size(0))); + causal_conv_update_kernel<<>>( + state.data_ptr(), + reinterpret_cast(hidden.data_ptr()), + reinterpret_cast(weight.data_ptr()), + reinterpret_cast<__half*>(output.data_ptr()), channels); + C10_CUDA_KERNEL_LAUNCH_CHECK(); + return output; +} + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, module) { + module.def("causal_conv_update", &causal_conv_update, + "Fused CoreX Gated DeltaNet causal convolution update"); +} diff --git a/qwen3_6_scripts/corex_gdn_gated_norm.cu b/qwen3_6_scripts/corex_gdn_gated_norm.cu new file mode 100644 index 00000000..aa8a0352 --- /dev/null +++ b/qwen3_6_scripts/corex_gdn_gated_norm.cu @@ -0,0 +1,80 @@ +#include +#include +#include +#include + +namespace { + +constexpr int kHeadDim = 128; + +__device__ __forceinline__ float silu(float value) { + return value / (1.0f + expf(-value)); +} + +__global__ void gated_rms_norm_inverse_kernel( + const float* input, const __half* gate, const __half* weight, + const float* inverse, __half* output, int rows) { + const int row = blockIdx.x; + const int column = threadIdx.x; + if (row >= rows || column >= kHeadDim) { + return; + } + const int offset = row * kHeadDim + column; + const float scaled = __fmul_rn(input[offset], inverse[row]); + const float normalized = __fmul_rn( + __half2float(weight[column]), scaled); + const float activated = silu(__half2float(gate[offset])); + output[offset] = __float2half_rn(__fmul_rn(normalized, activated)); +} + +void check_input(const torch::Tensor& input, const torch::Tensor& gate, + const torch::Tensor& weight, + const torch::Tensor& inverse) { + TORCH_CHECK(input.is_cuda() && gate.is_cuda() && weight.is_cuda() + && inverse.is_cuda(), + "all tensors must be CUDA tensors"); + TORCH_CHECK(input.scalar_type() == torch::kFloat32, + "input must have dtype float32"); + TORCH_CHECK(gate.scalar_type() == torch::kFloat16, + "gate must have dtype float16"); + TORCH_CHECK(weight.scalar_type() == torch::kFloat16, + "weight must have dtype float16"); + TORCH_CHECK(inverse.scalar_type() == torch::kFloat32, + "inverse must have dtype float32"); + TORCH_CHECK(input.is_contiguous() && gate.is_contiguous() + && weight.is_contiguous() && inverse.is_contiguous(), + "all tensors must be contiguous"); + TORCH_CHECK(input.dim() == 2 && input.size(1) == kHeadDim, + "input must have shape (rows, 128)"); + TORCH_CHECK(gate.sizes() == input.sizes(), + "gate must match input shape"); + TORCH_CHECK(weight.dim() == 1 && weight.size(0) == kHeadDim, + "weight must have shape (128,)"); + TORCH_CHECK(inverse.numel() == input.size(0), + "inverse must contain one value per row"); +} + +} // namespace + +torch::Tensor apply_inverse(const torch::Tensor& input, + const torch::Tensor& gate, + const torch::Tensor& weight, + const torch::Tensor& inverse) { + check_input(input, gate, weight, inverse); + auto output = torch::empty_like(gate); + const int rows = static_cast(input.size(0)); + gated_rms_norm_inverse_kernel<<< + rows, kHeadDim, 0, at::cuda::getCurrentCUDAStream()>>>( + input.data_ptr(), + reinterpret_cast(gate.data_ptr()), + reinterpret_cast(weight.data_ptr()), + inverse.data_ptr(), + reinterpret_cast<__half*>(output.data_ptr()), rows); + C10_CUDA_KERNEL_LAUNCH_CHECK(); + return output; +} + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, module) { + module.def("apply_inverse", &apply_inverse, + "CoreX gated RMSNorm using a PyTorch-computed inverse"); +} diff --git a/qwen3_6_scripts/corex_gdn_packed_decode.cu b/qwen3_6_scripts/corex_gdn_packed_decode.cu new file mode 100644 index 00000000..140017da --- /dev/null +++ b/qwen3_6_scripts/corex_gdn_packed_decode.cu @@ -0,0 +1,165 @@ +#include +#include +#include +#include + +namespace { + +constexpr int kKeyHeads = 4; +constexpr int kValueHeads = 8; +constexpr int kHeadDim = 128; +constexpr int kMixedDim = + (2 * kKeyHeads + kValueHeads) * kHeadDim; +constexpr float kQueryScale = 0.08838834764831845f; + +__global__ void gdn_packed_decode_kernel( + float* state, const half* mixed_qkv, const half* beta_input, + const half* decay_input, const half* a_log, const half* dt_bias, + float* output) { + const int batch_head = blockIdx.x; + const int column = threadIdx.x; + const int batch = batch_head / kValueHeads; + const int value_head = batch_head % kValueHeads; + const int key_head = value_head / (kValueHeads / kKeyHeads); + const int mixed_offset = batch * kMixedDim; + const int query_offset = mixed_offset + key_head * kHeadDim; + const int key_offset = + mixed_offset + kKeyHeads * kHeadDim + key_head * kHeadDim; + const int value_offset = mixed_offset + 2 * kKeyHeads * kHeadDim + + value_head * kHeadDim; + const int vector_offset = batch_head * kHeadDim; + const int state_offset = batch_head * kHeadDim * kHeadDim; + + __shared__ half norm_squares[kHeadDim * 2]; + __shared__ float normalized_query[kHeadDim]; + __shared__ float normalized_key[kHeadDim]; + const half raw_query = mixed_qkv[query_offset + column]; + const half raw_key = mixed_qkv[key_offset + column]; + norm_squares[column] = __hmul(raw_query, raw_query); + norm_squares[kHeadDim + column] = __hmul(raw_key, raw_key); + __syncthreads(); + + for (int stride = kHeadDim / 2; stride > 0; stride >>= 1) { + if (column < stride) { + norm_squares[column] = __hadd( + norm_squares[column], norm_squares[column + stride]); + norm_squares[kHeadDim + column] = __hadd( + norm_squares[kHeadDim + column], + norm_squares[kHeadDim + column + stride]); + } + __syncthreads(); + } + + const half epsilon = __float2half(1e-6f); + const half query_inverse = __float2half(rsqrtf(__half2float( + __hadd(norm_squares[0], epsilon)))); + const half key_inverse = __float2half(rsqrtf(__half2float( + __hadd(norm_squares[kHeadDim], epsilon)))); + normalized_query[column] = __half2float( + __hmul(raw_query, query_inverse)) * kQueryScale; + normalized_key[column] = __half2float(__hmul(raw_key, key_inverse)); + __syncthreads(); + + const int coefficient_offset = batch * kValueHeads + value_head; + const float beta_value = __half2float(beta_input[coefficient_offset]); + const float beta = __half2float(__float2half( + 1.0f / (1.0f + expf(-beta_value)))); + const float decay_x = __half2float(decay_input[coefficient_offset]) + + __half2float(dt_bias[value_head]); + const float softplus = + decay_x > 20.0f ? decay_x : log1pf(expf(decay_x)); + const float decay = expf( + -expf(__half2float(a_log[value_head])) * softplus); + + float memory = 0.0f; +#pragma unroll + for (int row = 0; row < kHeadDim; ++row) { + const int index = state_offset + row * kHeadDim + column; + const float decayed = state[index] * decay; + memory += normalized_key[row] * decayed; + } + + const float value = __half2float(mixed_qkv[value_offset + column]); + const float delta = (value - memory) * beta; + float result = 0.0f; +#pragma unroll + for (int row = 0; row < kHeadDim; ++row) { + const int index = state_offset + row * kHeadDim + column; + const float decayed = state[index] * decay; + const float updated = decayed + normalized_key[row] * delta; + state[index] = updated; + result += normalized_query[row] * updated; + } + output[vector_offset + column] = result; +} + +void check_half_matrix(const torch::Tensor& tensor, const char* name, + int64_t width) { + TORCH_CHECK(tensor.is_cuda(), name, " must be a CUDA tensor"); + TORCH_CHECK(tensor.scalar_type() == torch::kFloat16, + name, " must have dtype float16"); + TORCH_CHECK(tensor.is_contiguous(), name, " must be contiguous"); + TORCH_CHECK(tensor.dim() == 2 && tensor.size(1) == width, + name, " must have shape (batch, ", width, ")"); +} + +void check_half_vector(const torch::Tensor& tensor, const char* name) { + TORCH_CHECK(tensor.is_cuda(), name, " must be a CUDA tensor"); + TORCH_CHECK(tensor.scalar_type() == torch::kFloat16, + name, " must have dtype float16"); + TORCH_CHECK(tensor.is_contiguous(), name, " must be contiguous"); + TORCH_CHECK(tensor.dim() == 1 && tensor.size(0) == kValueHeads, + name, " must have shape (", kValueHeads, ")"); +} + +} // namespace + +torch::Tensor packed_decode(torch::Tensor state, + const torch::Tensor& mixed_qkv, + const torch::Tensor& beta_input, + const torch::Tensor& decay_input, + const torch::Tensor& a_log, + const torch::Tensor& dt_bias) { + TORCH_CHECK(state.is_cuda(), "state must be a CUDA tensor"); + TORCH_CHECK(state.scalar_type() == torch::kFloat32, + "state must have dtype float32"); + TORCH_CHECK(state.is_contiguous(), "state must be contiguous"); + TORCH_CHECK(state.dim() == 4 && state.size(0) == 1 + && state.size(1) == kValueHeads + && state.size(2) == kHeadDim + && state.size(3) == kHeadDim, + "state must have shape (1, 8, 128, 128)"); + check_half_matrix(mixed_qkv, "mixed_qkv", kMixedDim); + check_half_matrix(beta_input, "beta_input", kValueHeads); + check_half_matrix(decay_input, "decay_input", kValueHeads); + check_half_vector(a_log, "a_log"); + check_half_vector(dt_bias, "dt_bias"); + TORCH_CHECK(mixed_qkv.size(0) == 1 && beta_input.size(0) == 1 + && decay_input.size(0) == 1, + "packed decode only supports one sequence"); + TORCH_CHECK(state.device() == mixed_qkv.device() + && state.device() == beta_input.device() + && state.device() == decay_input.device() + && state.device() == a_log.device() + && state.device() == dt_bias.device(), + "all inputs must be on the same device"); + + torch::Tensor output = torch::empty( + {1, kValueHeads, kHeadDim}, state.options()); + gdn_packed_decode_kernel<<>>( + state.data_ptr(), + reinterpret_cast(mixed_qkv.data_ptr()), + reinterpret_cast(beta_input.data_ptr()), + reinterpret_cast(decay_input.data_ptr()), + reinterpret_cast(a_log.data_ptr()), + reinterpret_cast(dt_bias.data_ptr()), + output.data_ptr()); + C10_CUDA_KERNEL_LAUNCH_CHECK(); + return output; +} + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, module) { + module.def("packed_decode", &packed_decode, + "Packed Qwen3.6 GDN single-token decode"); +} diff --git a/qwen3_6_scripts/corex_gdn_qk_map.cu b/qwen3_6_scripts/corex_gdn_qk_map.cu new file mode 100644 index 00000000..7d4d74f2 --- /dev/null +++ b/qwen3_6_scripts/corex_gdn_qk_map.cu @@ -0,0 +1,72 @@ +#include +#include +#include +#include + +namespace { + +constexpr int kHeadDim = 128; +constexpr float kQueryScale = 0.08838834764831845f; + +__global__ void qk_map_kernel(const half* query, const half* key, + float* output, int batch, int key_heads, + int value_heads, int expand_ratio) { + const int elements = batch * value_heads * kHeadDim; + const int index = blockIdx.x * blockDim.x + threadIdx.x; + if (index >= elements) { + return; + } + const int dim = index % kHeadDim; + const int value_head_index = index / kHeadDim; + const int value_head = value_head_index % value_heads; + const int batch_index = value_head_index / value_heads; + const int key_head = value_head / expand_ratio; + const int source = ((batch_index * key_heads + key_head) * kHeadDim + dim); + output[index] = __half2float(query[source]) * kQueryScale; + output[elements + index] = __half2float(key[source]); +} + +void check_input(const torch::Tensor& tensor, const char* name) { + TORCH_CHECK(tensor.is_cuda(), name, " must be a CUDA tensor"); + TORCH_CHECK(tensor.scalar_type() == torch::kFloat16, + name, " must have dtype float16"); + TORCH_CHECK(tensor.is_contiguous(), name, " must be contiguous"); + TORCH_CHECK(tensor.dim() == 3 && tensor.size(2) == kHeadDim, + name, " must have shape (batch, key_heads, 128)"); +} + +} // namespace + +torch::Tensor qk_map(const torch::Tensor& query, + const torch::Tensor& key, + int64_t value_heads_arg) { + check_input(query, "query"); + check_input(key, "key"); + TORCH_CHECK(query.sizes() == key.sizes(), + "query and key shapes must match"); + const int batch = static_cast(query.size(0)); + const int key_heads = static_cast(query.size(1)); + const int value_heads = static_cast(value_heads_arg); + TORCH_CHECK(value_heads > 0 && value_heads % key_heads == 0, + "value_heads must be divisible by key_heads"); + + torch::Tensor output = torch::empty( + {2, batch, value_heads, kHeadDim}, + query.options().dtype(torch::kFloat32)); + const int elements = batch * value_heads * kHeadDim; + constexpr int threads = 256; + const int blocks = (elements + threads - 1) / threads; + qk_map_kernel<<>>( + reinterpret_cast(query.data_ptr()), + reinterpret_cast(key.data_ptr()), + output.data_ptr(), batch, key_heads, value_heads, + value_heads / key_heads); + C10_CUDA_KERNEL_LAUNCH_CHECK(); + return output; +} + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, module) { + module.def("qk_map", &qk_map, + "Map normalized FP16 key heads to FP32 value heads"); +} diff --git a/qwen3_6_scripts/corex_moe_direct_routed.cu b/qwen3_6_scripts/corex_moe_direct_routed.cu new file mode 100644 index 00000000..37699d4b --- /dev/null +++ b/qwen3_6_scripts/corex_moe_direct_routed.cu @@ -0,0 +1,181 @@ +#include +#include +#include +#include + +namespace { + +constexpr int kExperts = 256; +constexpr int kTopK = 8; +constexpr int kHidden = 2048; +constexpr int kIntermediate = 128; +constexpr int kW13Rows = 2 * kIntermediate; +constexpr int kThreads = 256; +constexpr int kWarpSize = 32; + +__device__ inline float warp_sum(float value) { +#pragma unroll + for (int offset = kWarpSize / 2; offset > 0; offset /= 2) { + value += __shfl_down_sync(0xffffffff, value, offset); + } + return value; +} + +__global__ void direct_w13_kernel( + const __half* input, const __half* w13, const int64_t* expert_ids, + __half* gate_up) { + const int warp = + (static_cast(blockIdx.x) * blockDim.x + threadIdx.x) / kWarpSize; + const int lane = threadIdx.x & (kWarpSize - 1); + if (warp >= kTopK * kW13Rows) { + return; + } + + const int slot = warp / kW13Rows; + const int local_row = warp - slot * kW13Rows; + const int64_t expert = expert_ids[slot]; + const int64_t weight_row = + (expert * kW13Rows + local_row) * static_cast(kHidden); + const __half2* input2 = reinterpret_cast(input); + const __half2* weight2 = + reinterpret_cast(w13 + weight_row); + float sum = 0.0f; + for (int index = lane; index < kHidden / 2; index += kWarpSize) { + const __half2 x = input2[index]; + const __half2 weight = weight2[index]; + sum = fmaf(__half2float(weight.x), __half2float(x.x), sum); + sum = fmaf(__half2float(weight.y), __half2float(x.y), sum); + } + sum = warp_sum(sum); + if (lane == 0) { + gate_up[warp] = __float2half_rn(sum); + } +} + +__global__ void direct_w2_reduce_kernel( + const __half* activated, const __half* w2, const int64_t* expert_ids, + const __half* weights, __half* output) { + const int warp = + (static_cast(blockIdx.x) * blockDim.x + threadIdx.x) / kWarpSize; + const int lane = threadIdx.x & (kWarpSize - 1); + if (warp >= kHidden) { + return; + } + + float weighted_sum = 0.0f; +#pragma unroll + for (int slot = 0; slot < kTopK; ++slot) { + const int64_t expert = expert_ids[slot]; + const int64_t weight_row = + (expert * kHidden + warp) * static_cast(kIntermediate); + const __half2* activation2 = reinterpret_cast( + activated + slot * kIntermediate); + const __half2* weight2 = + reinterpret_cast(w2 + weight_row); + float expert_sum = 0.0f; + for (int index = lane; index < kIntermediate / 2; + index += kWarpSize) { + const __half2 x = activation2[index]; + const __half2 weight = weight2[index]; + expert_sum = fmaf( + __half2float(weight.x), __half2float(x.x), expert_sum); + expert_sum = fmaf( + __half2float(weight.y), __half2float(x.y), expert_sum); + } + expert_sum = warp_sum(expert_sum); + if (lane == 0) { + const __half expert_half = __float2half_rn(expert_sum); + const __half product = __hmul(expert_half, weights[slot]); + weighted_sum += __half2float(product); + } + } + if (lane == 0) { + output[warp] = __float2half_rn(weighted_sum); + } +} + +void check_half_cuda(const torch::Tensor& tensor, const char* name) { + TORCH_CHECK(tensor.is_cuda(), name, " must be a CUDA tensor"); + TORCH_CHECK(tensor.scalar_type() == torch::kFloat16, + name, " must have dtype float16"); + TORCH_CHECK(tensor.is_contiguous(), name, " must be contiguous"); +} + +void check_ids(const torch::Tensor& expert_ids) { + TORCH_CHECK(expert_ids.is_cuda() && expert_ids.is_contiguous(), + "expert_ids must be a contiguous CUDA tensor"); + TORCH_CHECK(expert_ids.scalar_type() == torch::kInt64, + "expert_ids must have dtype int64"); + TORCH_CHECK(expert_ids.dim() == 1 && expert_ids.numel() == kTopK, + "expert_ids must have shape (8,)"); +} + +} // namespace + +torch::Tensor direct_w13(const torch::Tensor& input, + const torch::Tensor& w13, + const torch::Tensor& expert_ids) { + check_half_cuda(input, "input"); + check_half_cuda(w13, "w13"); + check_ids(expert_ids); + TORCH_CHECK(input.dim() == 2 && input.size(0) == 1 + && input.size(1) == kHidden, + "input must have shape (1, 2048)"); + TORCH_CHECK(w13.dim() == 3 && w13.size(0) == kExperts + && w13.size(1) == kW13Rows + && w13.size(2) == kHidden, + "w13 must have shape (256, 256, 2048)"); + + auto output = torch::empty({kTopK, kW13Rows}, input.options()); + constexpr int kWarpsPerBlock = kThreads / kWarpSize; + constexpr int kBlocks = + (kTopK * kW13Rows + kWarpsPerBlock - 1) / kWarpsPerBlock; + direct_w13_kernel<<>>( + reinterpret_cast(input.data_ptr()), + reinterpret_cast(w13.data_ptr()), + expert_ids.data_ptr(), + reinterpret_cast<__half*>(output.data_ptr())); + C10_CUDA_KERNEL_LAUNCH_CHECK(); + return output; +} + +torch::Tensor direct_w2_reduce(const torch::Tensor& activated, + const torch::Tensor& w2, + const torch::Tensor& expert_ids, + const torch::Tensor& weights) { + check_half_cuda(activated, "activated"); + check_half_cuda(w2, "w2"); + check_half_cuda(weights, "weights"); + check_ids(expert_ids); + TORCH_CHECK(activated.dim() == 2 && activated.size(0) == kTopK + && activated.size(1) == kIntermediate, + "activated must have shape (8, 128)"); + TORCH_CHECK(w2.dim() == 3 && w2.size(0) == kExperts + && w2.size(1) == kHidden + && w2.size(2) == kIntermediate, + "w2 must have shape (256, 2048, 128)"); + TORCH_CHECK(weights.dim() == 1 && weights.numel() == kTopK, + "weights must have shape (8,)"); + + auto output = torch::empty({1, kHidden}, activated.options()); + constexpr int kWarpsPerBlock = kThreads / kWarpSize; + constexpr int kBlocks = + (kHidden + kWarpsPerBlock - 1) / kWarpsPerBlock; + direct_w2_reduce_kernel<<>>( + reinterpret_cast(activated.data_ptr()), + reinterpret_cast(w2.data_ptr()), + expert_ids.data_ptr(), + reinterpret_cast(weights.data_ptr()), + reinterpret_cast<__half*>(output.data_ptr())); + C10_CUDA_KERNEL_LAUNCH_CHECK(); + return output; +} + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, module) { + module.def("w13", &direct_w13, + "Direct selected-expert FP16 W13 matvec"); + module.def("w2_reduce", &direct_w2_reduce, + "Direct selected-expert W2 matvec and routed reduction"); +} diff --git a/qwen3_6_scripts/corex_moe_exact_reduce.cu b/qwen3_6_scripts/corex_moe_exact_reduce.cu new file mode 100644 index 00000000..05c3b7f2 --- /dev/null +++ b/qwen3_6_scripts/corex_moe_exact_reduce.cu @@ -0,0 +1,107 @@ +#include +#include +#include +#include + +namespace { + +constexpr int kTopK = 8; +constexpr int kThreads = 256; + +enum class Mode { kSerialFloat, kTreeFloat, kSerialHalf }; + +__global__ void exact_reduce_kernel(const __half* expert_output, + const __half* weights, + __half* output, int hidden, + Mode mode) { + const int column = blockIdx.x * blockDim.x + threadIdx.x; + if (column >= hidden) { + return; + } + __half products[kTopK]; +#pragma unroll + for (int expert = 0; expert < kTopK; ++expert) { + products[expert] = __hmul( + expert_output[expert * hidden + column], weights[expert]); + } + if (mode == Mode::kSerialHalf) { + __half sum = products[0]; +#pragma unroll + for (int expert = 1; expert < kTopK; ++expert) { + sum = __hadd(sum, products[expert]); + } + output[column] = sum; + return; + } + + float sum; + if (mode == Mode::kSerialFloat) { + sum = __half2float(products[0]); +#pragma unroll + for (int expert = 1; expert < kTopK; ++expert) { + sum += __half2float(products[expert]); + } + } else { + const float sum01 = __half2float(products[0]) + __half2float(products[1]); + const float sum23 = __half2float(products[2]) + __half2float(products[3]); + const float sum45 = __half2float(products[4]) + __half2float(products[5]); + const float sum67 = __half2float(products[6]) + __half2float(products[7]); + sum = (sum01 + sum23) + (sum45 + sum67); + } + output[column] = __float2half_rn(sum); +} + +void check_input(const torch::Tensor& expert_output, + const torch::Tensor& weights) { + TORCH_CHECK(expert_output.is_cuda() && weights.is_cuda(), + "inputs must be CUDA tensors"); + TORCH_CHECK(expert_output.scalar_type() == torch::kFloat16 + && weights.scalar_type() == torch::kFloat16, + "inputs must have dtype float16"); + TORCH_CHECK(expert_output.is_contiguous() && weights.is_contiguous(), + "inputs must be contiguous"); + TORCH_CHECK(expert_output.dim() == 2 + && expert_output.size(0) == kTopK, + "expert_output must have shape (8, hidden)"); + TORCH_CHECK(weights.dim() == 1 && weights.size(0) == kTopK, + "weights must have shape (8,)"); +} + +torch::Tensor launch(const torch::Tensor& expert_output, + const torch::Tensor& weights, Mode mode) { + check_input(expert_output, weights); + auto output = torch::empty( + {1, expert_output.size(1)}, expert_output.options()); + const int hidden = static_cast(expert_output.size(1)); + const int blocks = (hidden + kThreads - 1) / kThreads; + exact_reduce_kernel<<>>( + reinterpret_cast(expert_output.data_ptr()), + reinterpret_cast(weights.data_ptr()), + reinterpret_cast<__half*>(output.data_ptr()), hidden, mode); + C10_CUDA_KERNEL_LAUNCH_CHECK(); + return output; +} + +} // namespace + +torch::Tensor serial_float(const torch::Tensor& expert_output, + const torch::Tensor& weights) { + return launch(expert_output, weights, Mode::kSerialFloat); +} + +torch::Tensor tree_float(const torch::Tensor& expert_output, + const torch::Tensor& weights) { + return launch(expert_output, weights, Mode::kTreeFloat); +} + +torch::Tensor serial_half(const torch::Tensor& expert_output, + const torch::Tensor& weights) { + return launch(expert_output, weights, Mode::kSerialHalf); +} + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, module) { + module.def("serial_float", &serial_float); + module.def("tree_float", &tree_float); + module.def("serial_half", &serial_half); +} diff --git a/qwen3_6_scripts/corex_moe_weight_gather.cu b/qwen3_6_scripts/corex_moe_weight_gather.cu new file mode 100644 index 00000000..60ebc702 --- /dev/null +++ b/qwen3_6_scripts/corex_moe_weight_gather.cu @@ -0,0 +1,92 @@ +#include +#include +#include +#include + +#include +#include + +namespace { + +constexpr int kTopK = 8; +constexpr int kThreads = 256; +constexpr int kGridX = 8; + +__global__ void selected_weight_gather_vec16_kernel( + const uint4* w13, const uint4* w2, const int64_t* expert_ids, + uint4* selected_w13, uint4* selected_w2, + int64_t w13_vecs_per_expert, int64_t w2_vecs_per_expert) { + const int segment = blockIdx.y; + const int slot = segment & (kTopK - 1); + const bool copy_w2 = segment >= kTopK; + const int64_t count = + copy_w2 ? w2_vecs_per_expert : w13_vecs_per_expert; + const uint4* source = copy_w2 ? w2 : w13; + uint4* output = copy_w2 ? selected_w2 : selected_w13; + const int64_t source_offset = expert_ids[slot] * count; + const int64_t output_offset = static_cast(slot) * count; + for (int64_t index = + static_cast(blockIdx.x) * blockDim.x + threadIdx.x; + index < count; + index += static_cast(blockDim.x) * gridDim.x) { + output[output_offset + index] = source[source_offset + index]; + } +} + +void check_weight(const torch::Tensor& tensor, const char* name) { + TORCH_CHECK(tensor.is_cuda(), name, " must be a CUDA tensor"); + TORCH_CHECK(tensor.scalar_type() == torch::kFloat16, + name, " must have dtype float16"); + TORCH_CHECK(tensor.is_contiguous(), name, " must be contiguous"); + TORCH_CHECK(tensor.dim() == 3, name, " must be rank three"); + TORCH_CHECK(tensor.size(1) * tensor.size(2) % 8 == 0, + name, " expert slices must be divisible by 16 bytes"); +} + +} // namespace + +std::vector gather_selected_weights( + const torch::Tensor& w13, const torch::Tensor& w2, + const torch::Tensor& expert_ids) { + check_weight(w13, "w13"); + check_weight(w2, "w2"); + TORCH_CHECK(w13.device() == w2.device(), + "W13/W2 must be on the same device"); + TORCH_CHECK(w13.size(0) == w2.size(0), + "W13/W2 expert counts differ"); + TORCH_CHECK(w13.size(2) == w2.size(1), + "W13/W2 hidden dimensions differ"); + TORCH_CHECK(w13.size(1) == 2 * w2.size(2), + "W13/W2 intermediate dimensions differ"); + TORCH_CHECK(expert_ids.is_cuda() && expert_ids.is_contiguous(), + "expert_ids must be a contiguous CUDA tensor"); + TORCH_CHECK(expert_ids.device() == w13.device(), + "weights and expert_ids must be on the same device"); + TORCH_CHECK(expert_ids.scalar_type() == torch::kInt64, + "expert_ids must have dtype int64"); + TORCH_CHECK(expert_ids.dim() == 1 && expert_ids.numel() == kTopK, + "expert_ids must have shape (8,)"); + + auto selected_w13 = torch::empty( + {kTopK, w13.size(1), w13.size(2)}, w13.options()); + auto selected_w2 = torch::empty( + {kTopK, w2.size(1), w2.size(2)}, w2.options()); + const int64_t w13_vecs_per_expert = w13.size(1) * w13.size(2) / 8; + const int64_t w2_vecs_per_expert = w2.size(1) * w2.size(2) / 8; + const dim3 grid(kGridX, 2 * kTopK); + selected_weight_gather_vec16_kernel<<< + grid, kThreads, 0, at::cuda::getCurrentCUDAStream()>>>( + reinterpret_cast(w13.data_ptr()), + reinterpret_cast(w2.data_ptr()), + expert_ids.data_ptr(), + reinterpret_cast(selected_w13.data_ptr()), + reinterpret_cast(selected_w2.data_ptr()), + w13_vecs_per_expert, w2_vecs_per_expert); + C10_CUDA_KERNEL_LAUNCH_CHECK(); + return {selected_w13, selected_w2}; +} + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, module) { + module.def("gather", &gather_selected_weights, + "Gather selected FP16 top-8 MoE weights with 16-byte loads"); +} diff --git a/qwen3_6_scripts/corex_paged_kv_gather.cu b/qwen3_6_scripts/corex_paged_kv_gather.cu new file mode 100644 index 00000000..e2087277 --- /dev/null +++ b/qwen3_6_scripts/corex_paged_kv_gather.cu @@ -0,0 +1,118 @@ +#include +#include +#include +#include + +#include +#include +#include + +namespace { + +constexpr int kThreads = 256; +constexpr int kSmallGridBlocks = 256; +constexpr int kSmallGridMaxSeqLen = 96 * 1024; + +__global__ void paged_kv_gather_kernel( + const __half* key_cache, const __half* value_cache, + const int* block_table, float* key_output, float* value_output, + int seq_len, int num_kv_heads, int head_size, int block_size, + int key_pack) { + const int64_t total = + static_cast(seq_len) * num_kv_heads * head_size; + for (int64_t index = + static_cast(blockIdx.x) * blockDim.x + threadIdx.x; + index < total; + index += static_cast(blockDim.x) * gridDim.x) { + const int dim = index % head_size; + const int token = (index / head_size) % seq_len; + const int kv_head = index / (static_cast(head_size) * seq_len); + const int logical_block = token / block_size; + const int block_offset = token % block_size; + const int physical_block = block_table[logical_block]; + + const int64_t key_index = + (((static_cast(physical_block) * num_kv_heads + kv_head) + * (head_size / key_pack) + dim / key_pack) + * block_size + block_offset) * key_pack + dim % key_pack; + const int64_t value_index = + ((static_cast(physical_block) * num_kv_heads + kv_head) + * head_size + dim) * block_size + block_offset; + const int64_t key_output_index = + (static_cast(kv_head) * head_size + dim) * seq_len + token; + const int64_t value_output_index = + (static_cast(kv_head) * seq_len + token) * head_size + dim; + + key_output[key_output_index] = __half2float(key_cache[key_index]); + value_output[value_output_index] = __half2float(value_cache[value_index]); + } +} + +void check_half_cuda_contiguous(const torch::Tensor& tensor, + const char* name) { + TORCH_CHECK(tensor.is_cuda(), name, " must be a CUDA tensor"); + TORCH_CHECK(tensor.scalar_type() == torch::kFloat16, + name, " must have dtype float16"); + TORCH_CHECK(tensor.is_contiguous(), name, " must be contiguous"); +} + +} // namespace + +std::vector gather_paged_kv( + const torch::Tensor& key_cache, const torch::Tensor& value_cache, + const torch::Tensor& block_table, int64_t seq_len) { + check_half_cuda_contiguous(key_cache, "key_cache"); + check_half_cuda_contiguous(value_cache, "value_cache"); + TORCH_CHECK(block_table.is_cuda(), "block_table must be a CUDA tensor"); + TORCH_CHECK(block_table.scalar_type() == torch::kInt32, + "block_table must have dtype int32"); + TORCH_CHECK(block_table.is_contiguous(), "block_table must be contiguous"); + TORCH_CHECK(key_cache.dim() == 5, + "key_cache must have shape (blocks, kv_heads, d/x, block, x)"); + TORCH_CHECK(value_cache.dim() == 4, + "value_cache must have shape (blocks, kv_heads, d, block)"); + TORCH_CHECK(block_table.dim() == 1, + "block_table must be a one-dimensional row"); + TORCH_CHECK(key_cache.size(0) == value_cache.size(0), + "key/value block counts differ"); + TORCH_CHECK(key_cache.size(1) == value_cache.size(1), + "key/value KV-head counts differ"); + TORCH_CHECK(key_cache.size(3) == value_cache.size(3), + "key/value block sizes differ"); + TORCH_CHECK(key_cache.size(2) * key_cache.size(4) == value_cache.size(2), + "key/value head sizes differ"); + TORCH_CHECK(seq_len > 0, "seq_len must be positive"); + + const int block_size = static_cast(value_cache.size(3)); + const int64_t required_blocks = (seq_len + block_size - 1) / block_size; + TORCH_CHECK(required_blocks <= block_table.numel(), + "block_table is too short for seq_len"); + const int num_kv_heads = static_cast(value_cache.size(1)); + const int head_size = static_cast(value_cache.size(2)); + const int key_pack = static_cast(key_cache.size(4)); + + auto output_options = key_cache.options().dtype(torch::kFloat32); + auto key_output = torch::empty( + {num_kv_heads, head_size, seq_len}, output_options); + auto value_output = torch::empty( + {num_kv_heads, seq_len, head_size}, output_options); + const int64_t total = seq_len * num_kv_heads * head_size; + const int grid_cap = + seq_len <= kSmallGridMaxSeqLen ? kSmallGridBlocks : 65535; + const int blocks = static_cast(std::min( + (total + kThreads - 1) / kThreads, grid_cap)); + paged_kv_gather_kernel<<>>( + reinterpret_cast(key_cache.data_ptr()), + reinterpret_cast(value_cache.data_ptr()), + block_table.data_ptr(), key_output.data_ptr(), + value_output.data_ptr(), static_cast(seq_len), + num_kv_heads, head_size, block_size, key_pack); + C10_CUDA_KERNEL_LAUNCH_CHECK(); + return {key_output, value_output}; +} + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, module) { + module.def("gather", &gather_paged_kv, + "Gather paged FP16 K/V directly into FP32 attention layouts"); +} diff --git a/qwen3_6_scripts/corex_query_tiled_paged_prefill.cu b/qwen3_6_scripts/corex_query_tiled_paged_prefill.cu new file mode 100644 index 00000000..e94624b9 --- /dev/null +++ b/qwen3_6_scripts/corex_query_tiled_paged_prefill.cu @@ -0,0 +1,503 @@ +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +namespace { + +constexpr int kBlockSize = 16; +constexpr int kHeadDim = 256; +constexpr int kKeyPack = 8; +constexpr int kNumQueryHeads = 4; +constexpr int kNumKvHeads = 1; +constexpr int kQueryTile = 16; +constexpr int kKeyTile = 16; +constexpr int kReductionTokens = 512; +constexpr int kKeyTilesPerReduction = kReductionTokens / kKeyTile; +constexpr int kPvReductionSplits = 4; +constexpr int kKeyTilesPerPvSplit = + kKeyTilesPerReduction / kPvReductionSplits; +constexpr int kMmaK = 16; +constexpr int kDimTiles = kHeadDim / kMmaK; +constexpr int kWarpSize = 64; +constexpr int kMaxQueryTokens = 8192; +constexpr int kMaxSequenceTokens = 262144; + +using namespace nvcuda; + +struct __align__(128) SharedStorage { + float matrix_tile[kQueryTile * kKeyTile]; + float scores[ + kKeyTilesPerReduction * kQueryTile * kKeyTile]; + float running_output[kQueryTile * kHeadDim]; + float partial_output[ + kPvReductionSplits * kQueryTile * kMmaK]; + float running_max[kQueryTile]; + float running_sum[kQueryTile]; + float correction[kQueryTile]; +}; + +void check_half_cuda_contiguous(const torch::Tensor& tensor, + const char* name) { + TORCH_CHECK(tensor.is_cuda(), name, " must be a CUDA tensor"); + TORCH_CHECK(tensor.scalar_type() == torch::kFloat16, + name, " must have dtype float16"); + TORCH_CHECK(tensor.is_contiguous(), name, " must be contiguous"); +} + +__device__ __forceinline__ float load_key( + const __half* key_new, const __half* key_cache, + const int* block_table, int logical_token, int context_len, int dim) { + if (logical_token < context_len) { + const int logical_block = logical_token / kBlockSize; + const int block_offset = logical_token % kBlockSize; + const int physical_block = block_table[logical_block]; + const int64_t index = + ((((static_cast(physical_block) * kNumKvHeads) + * (kHeadDim / kKeyPack) + dim / kKeyPack) + * kBlockSize + block_offset) * kKeyPack + dim % kKeyPack); + return __half2float(key_cache[index]); + } + const int query_index = logical_token - context_len; + return __half2float( + key_new[static_cast(query_index) * kHeadDim + dim]); +} + +__device__ __forceinline__ float load_value( + const __half* value_new, const __half* value_cache, + const int* block_table, int logical_token, int context_len, int dim) { + if (logical_token < context_len) { + const int logical_block = logical_token / kBlockSize; + const int block_offset = logical_token % kBlockSize; + const int physical_block = block_table[logical_block]; + const int64_t index = + ((static_cast(physical_block) * kNumKvHeads) + * kHeadDim + dim) * kBlockSize + block_offset; + return __half2float(value_cache[index]); + } + const int query_index = logical_token - context_len; + return __half2float( + value_new[static_cast(query_index) * kHeadDim + dim]); +} + +__global__ void query_tiled_paged_prefill_kernel( + const __half* query, const __half* key_new, const __half* value_new, + const __half* key_cache, const __half* value_cache, + const int* block_table, __half* output, float* lse, + int context_len, int query_len, float scale) { + __shared__ SharedStorage shared; + + const int lane = threadIdx.x; + const int query_tile_index = blockIdx.x / kNumQueryHeads; + const int query_head = blockIdx.x % kNumQueryHeads; + const int query_start = query_tile_index * kQueryTile; + const int active_rows = min(kQueryTile, query_len - query_start); + if (active_rows <= 0) { + return; + } + + wmma::fragment query_fragments[kDimTiles]; + +#pragma unroll + for (int dim_tile = 0; dim_tile < kDimTiles; ++dim_tile) { +#pragma unroll + for (int quarter = 0; quarter < 4; ++quarter) { + const int row = lane / 16 + quarter * 4; + const int column = lane % 16; + float value = 0.0f; + if (row < active_rows) { + const int query_index = query_start + row; + const int dim = dim_tile * kMmaK + column; + const int64_t source = + (static_cast(query_index) * kNumQueryHeads + + query_head) * kHeadDim + dim; + value = __half2float(query[source]) * scale; + } + const int offset = + wmma::CoordToOffset<32, wmma::layout_t::mem_row_major>( + row, column); + shared.matrix_tile[offset] = value; + } + __syncthreads(); + wmma::load_matrix_sync( + query_fragments[dim_tile], shared.matrix_tile, 0); + __syncthreads(); + } + + for (int index = lane; index < kQueryTile * kHeadDim; + index += kWarpSize) { + shared.running_output[index] = 0.0f; + } + if (lane < kQueryTile) { + shared.running_max[lane] = -std::numeric_limits::infinity(); + shared.running_sum[lane] = 0.0f; + shared.correction[lane] = 1.0f; + } + __syncthreads(); + + const int last_query = min(query_start + kQueryTile, query_len); + + // Preserve the installed reference's 512-token reduction boundaries: + // paged context and current causal K/V are separate phases. + for (int phase = 0; phase < 2; ++phase) { + const int phase_base = phase == 0 ? 0 : context_len; + const int phase_tokens = phase == 0 ? context_len : last_query; + for (int group_start = 0; group_start < phase_tokens; + group_start += kReductionTokens) { + const int group_tokens = + min(kReductionTokens, phase_tokens - group_start); + const int group_key_tiles = + (group_tokens + kKeyTile - 1) / kKeyTile; + + for (int key_tile_in_group = 0; + key_tile_in_group < group_key_tiles; + ++key_tile_in_group) { + const int local_key_start = + group_start + key_tile_in_group * kKeyTile; + const int logical_key_start = phase_base + local_key_start; + wmma::fragment + score_fragment; + wmma::fill_fragment(score_fragment, 0.0f); + +#pragma unroll + for (int dim_tile = 0; dim_tile < kDimTiles; ++dim_tile) { +#pragma unroll + for (int quarter = 0; quarter < 4; ++quarter) { + const int row = lane / 16 + quarter * 4; + const int column = lane % 16; + const int logical_token = logical_key_start + column; + const int dim = dim_tile * kMmaK + row; + const float value = + local_key_start + column < phase_tokens + ? load_key(key_new, key_cache, block_table, + logical_token, context_len, dim) + : 0.0f; + const int offset = + wmma::CoordToOffset< + 32, wmma::layout_t::mem_col_major>( + row, column); + shared.matrix_tile[offset] = value; + } + __syncthreads(); + wmma::fragment key_fragment; + wmma::load_matrix_sync( + key_fragment, shared.matrix_tile, 0); + wmma::mma_sync( + score_fragment, + query_fragments[dim_tile], + key_fragment, + score_fragment); + __syncthreads(); + } + + float* score_tile = + shared.scores + + key_tile_in_group * kQueryTile * kKeyTile; + wmma::store_matrix_sync( + score_tile, score_fragment, 0, wmma::mem_row_major); + __syncthreads(); + } + + if (lane < kQueryTile) { + const int row = lane; + if (row >= active_rows) { + shared.correction[row] = 1.0f; + for (int key_offset = 0; key_offset < group_tokens; + ++key_offset) { + const int key_tile = key_offset / kKeyTile; + const int column = key_offset % kKeyTile; + shared.scores[ + key_tile * kQueryTile * kKeyTile + + row * kKeyTile + column] = 0.0f; + } + } else { + const int absolute_query = + context_len + query_start + row; + float block_max = + -std::numeric_limits::infinity(); + for (int key_offset = 0; key_offset < group_tokens; + ++key_offset) { + const int key_tile = key_offset / kKeyTile; + const int column = key_offset % kKeyTile; + const int score_index = + key_tile * kQueryTile * kKeyTile + + row * kKeyTile + column; + const int logical_key = + phase_base + group_start + key_offset; + if (logical_key <= absolute_query) { + block_max = fmaxf( + block_max, shared.scores[score_index]); + } else { + shared.scores[score_index] = + -std::numeric_limits::infinity(); + } + } + const float old_max = shared.running_max[row]; + const float new_max = fmaxf(old_max, block_max); + const float correction = + old_max == -std::numeric_limits::infinity() + ? 0.0f + : expf(old_max - new_max); + float group_sum = 0.0f; + for (int key_offset = 0; key_offset < group_tokens; + ++key_offset) { + const int key_tile = key_offset / kKeyTile; + const int column = key_offset % kKeyTile; + const int score_index = + key_tile * kQueryTile * kKeyTile + + row * kKeyTile + column; + const float score = shared.scores[score_index]; + const float probability = + score == -std::numeric_limits::infinity() + ? 0.0f + : expf(score - new_max); + shared.scores[score_index] = probability; + group_sum += probability; + } + shared.running_sum[row] = + shared.running_sum[row] * correction + group_sum; + shared.running_max[row] = new_max; + shared.correction[row] = correction; + } + for (int key_offset = group_tokens; + key_offset < group_key_tiles * kKeyTile; + ++key_offset) { + const int key_tile = key_offset / kKeyTile; + const int column = key_offset % kKeyTile; + shared.scores[ + key_tile * kQueryTile * kKeyTile + + row * kKeyTile + column] = 0.0f; + } + } + __syncthreads(); + + for (int index = lane; + index < active_rows * kHeadDim; + index += kWarpSize) { + const int row = index / kHeadDim; + shared.running_output[index] *= shared.correction[row]; + } + __syncthreads(); + +#pragma unroll + for (int dim_tile = 0; dim_tile < kDimTiles; ++dim_tile) { + // CoreX's reference matmul reduces a 512-token K dimension + // hierarchically. Preserve that numerical shape with four fixed, + // contiguous 128-token partials and a deterministic binary merge. +#pragma unroll + for (int split = 0; split < kPvReductionSplits; ++split) { + wmma::fragment + output_fragment; + wmma::fill_fragment(output_fragment, 0.0f); + const int split_start = split * kKeyTilesPerPvSplit; + const int split_end = + min(group_key_tiles, split_start + kKeyTilesPerPvSplit); + for (int key_tile_in_group = split_start; + key_tile_in_group < split_end; + ++key_tile_in_group) { + const int local_key_start = + group_start + key_tile_in_group * kKeyTile; + const int logical_key_start = phase_base + local_key_start; + const float* score_tile = + shared.scores + + key_tile_in_group * kQueryTile * kKeyTile; + wmma::fragment probability_fragment; + wmma::load_matrix_sync( + probability_fragment, score_tile, 0); + +#pragma unroll + for (int quarter = 0; quarter < 4; ++quarter) { + const int row = lane / 16 + quarter * 4; + const int column = lane % 16; + const int logical_token = logical_key_start + row; + const int dim = dim_tile * kMmaK + column; + const float value = + local_key_start + row < phase_tokens + ? load_value(value_new, value_cache, block_table, + logical_token, context_len, dim) + : 0.0f; + const int offset = + wmma::CoordToOffset< + 32, wmma::layout_t::mem_row_major>( + row, column); + shared.matrix_tile[offset] = value; + } + __syncthreads(); + + wmma::fragment value_fragment; + wmma::load_matrix_sync( + value_fragment, shared.matrix_tile, 0); + wmma::mma_sync( + output_fragment, + probability_fragment, + value_fragment, + output_fragment); + __syncthreads(); + } + + wmma::store_matrix_sync( + shared.partial_output + + split * kQueryTile * kMmaK, + output_fragment, + 0, + wmma::mem_row_major); + __syncthreads(); + } + +#pragma unroll + for (int quarter = 0; quarter < 4; ++quarter) { + const int row = lane / 16 + quarter * 4; + const int column = lane % 16; + if (row < active_rows) { + const int output_index = + row * kHeadDim + dim_tile * kMmaK + column; + const int tile_index = row * kMmaK + column; + const int partial_stride = kQueryTile * kMmaK; + const float left = __fadd_rn( + shared.partial_output[tile_index], + shared.partial_output[partial_stride + tile_index]); + const float right = __fadd_rn( + shared.partial_output[2 * partial_stride + tile_index], + shared.partial_output[3 * partial_stride + tile_index]); + shared.running_output[output_index] = __fadd_rn( + shared.running_output[output_index], + __fadd_rn(left, right)); + } + } + __syncthreads(); + } + } + } + + for (int index = lane; index < active_rows * kHeadDim; + index += kWarpSize) { + const int row = index / kHeadDim; + const int dim = index % kHeadDim; + const int query_index = query_start + row; + const int64_t destination = + (static_cast(query_index) * kNumQueryHeads + + query_head) * kHeadDim + dim; + output[destination] = __float2half_rn( + shared.running_output[index] / shared.running_sum[row]); + } + if (lane < active_rows) { + const int query_index = query_start + lane; + lse[static_cast(query_index) * kNumQueryHeads + + query_head] = + shared.running_max[lane] + logf(shared.running_sum[lane]); + } +} + +} // namespace + +std::vector query_tiled_paged_prefill_forward( + const torch::Tensor& query, const torch::Tensor& key_new, + const torch::Tensor& value_new, const torch::Tensor& key_cache, + const torch::Tensor& value_cache, const torch::Tensor& block_table, + int64_t context_len_arg, double scale_arg) { + check_half_cuda_contiguous(query, "query"); + check_half_cuda_contiguous(key_new, "key_new"); + check_half_cuda_contiguous(value_new, "value_new"); + check_half_cuda_contiguous(key_cache, "key_cache"); + check_half_cuda_contiguous(value_cache, "value_cache"); + TORCH_CHECK(block_table.is_cuda(), + "block_table must be a CUDA tensor"); + TORCH_CHECK(block_table.scalar_type() == torch::kInt32, + "block_table must have dtype int32"); + TORCH_CHECK(block_table.is_contiguous(), + "block_table must be contiguous"); + TORCH_CHECK(block_table.dim() == 1, + "block_table must be one-dimensional"); + TORCH_CHECK(query.dim() == 3 && query.size(1) == kNumQueryHeads + && query.size(2) == kHeadDim, + "query must have shape (Q, 4, 256)"); + TORCH_CHECK(key_new.dim() == 3 && key_new.size(1) == kNumKvHeads + && key_new.size(2) == kHeadDim, + "key_new must have shape (Q, 1, 256)"); + TORCH_CHECK(value_new.sizes() == key_new.sizes(), + "value_new must match key_new"); + TORCH_CHECK(key_new.size(0) == query.size(0), + "query, key_new, and value_new lengths must match"); + TORCH_CHECK(key_cache.dim() == 5 + && key_cache.size(1) == kNumKvHeads + && key_cache.size(2) == kHeadDim / kKeyPack + && key_cache.size(3) == kBlockSize + && key_cache.size(4) == kKeyPack, + "key_cache must have shape (N, 1, 32, 16, 8)"); + TORCH_CHECK(value_cache.dim() == 4 + && value_cache.size(1) == kNumKvHeads + && value_cache.size(2) == kHeadDim + && value_cache.size(3) == kBlockSize, + "value_cache must have shape (N, 1, 256, 16)"); + TORCH_CHECK(key_cache.size(0) == value_cache.size(0), + "key/value cache block counts must match"); + TORCH_CHECK(query.device() == key_new.device() + && query.device() == value_new.device() + && query.device() == key_cache.device() + && query.device() == value_cache.device() + && query.device() == block_table.device(), + "all tensors must use the same device"); + TORCH_CHECK(context_len_arg >= 0 + && context_len_arg <= kMaxSequenceTokens, + "context_len is out of range"); + TORCH_CHECK(context_len_arg % kBlockSize == 0, + "context_len must be block aligned"); + const int query_len = static_cast(query.size(0)); + const int context_len = static_cast(context_len_arg); + TORCH_CHECK(query_len > 0 && query_len <= kMaxQueryTokens, + "query length must be in [1, 8192]"); + TORCH_CHECK(context_len + query_len <= kMaxSequenceTokens, + "context_len + query_len exceeds 262144"); + const int required_blocks = context_len / kBlockSize; + TORCH_CHECK(block_table.numel() >= required_blocks, + "block_table is too short for context_len"); + if (required_blocks > 0) { + auto active_blocks = block_table.narrow(0, 0, required_blocks); + const int minimum_block = active_blocks.min().item(); + const int maximum_block = active_blocks.max().item(); + TORCH_CHECK(minimum_block >= 0 + && maximum_block < key_cache.size(0), + "block_table contains an out-of-range physical block ID"); + } + TORCH_CHECK(std::isfinite(scale_arg) && scale_arg > 0.0, + "scale must be finite and positive"); + + auto output = torch::empty_like(query); + auto lse = torch::empty( + {query_len, kNumQueryHeads}, + query.options().dtype(torch::kFloat32)); + const int query_tiles = + (query_len + kQueryTile - 1) / kQueryTile; + const int blocks = query_tiles * kNumQueryHeads; + auto stream = at::cuda::getCurrentCUDAStream(); + query_tiled_paged_prefill_kernel<<< + blocks, kWarpSize, 0, stream>>>( + reinterpret_cast(query.data_ptr()), + reinterpret_cast(key_new.data_ptr()), + reinterpret_cast(value_new.data_ptr()), + reinterpret_cast(key_cache.data_ptr()), + reinterpret_cast(value_cache.data_ptr()), + block_table.data_ptr(), + reinterpret_cast<__half*>(output.data_ptr()), + lse.data_ptr(), context_len, query_len, + static_cast(scale_arg)); + C10_CUDA_KERNEL_LAUNCH_CHECK(); + return {output, lse}; +} + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, module) { + module.def("forward", &query_tiled_paged_prefill_forward, + "Fixed BI100 query-tiled paged-prefill forward"); +} diff --git a/qwen3_6_scripts/gdn_prefix.py b/qwen3_6_scripts/gdn_prefix.py new file mode 100644 index 00000000..3eccfe1f --- /dev/null +++ b/qwen3_6_scripts/gdn_prefix.py @@ -0,0 +1,291 @@ +"""Shared GDN prefix-state cache contracts for the BI100 runtime.""" + +from __future__ import annotations + +import os +from collections import OrderedDict +from dataclasses import dataclass +from typing import Iterable, List, Optional, Sequence, Tuple + + +GdnPrefixKey = Tuple[int, bytes] +GdnCapturePoint = Tuple[int, GdnPrefixKey] + +_VALID_POLICIES = {"fine32", "admission64", "off"} +GDN_KERNEL_CHUNK_TOKENS = 64 +GDN_DIRECT_MIN_REPLAY_TOKENS = 2 + +_VALID_RESTORE_MODES = {"direct", "hybrid64", "chunk64", "aligned"} + + +def _env_choice(name: str, default: str, choices: set[str]) -> str: + value = os.getenv(name, default).strip().lower() + if value not in choices: + allowed = ", ".join(sorted(choices)) + raise RuntimeError(f"invalid {name}={value!r}; expected one of: {allowed}") + return value + + +def gdn_cache_policy_from_env() -> str: + return _env_choice("BI100_GDN_CACHE_POLICY", "fine32", _VALID_POLICIES) + + +def gdn_restore_mode_from_env() -> str: + return _env_choice( + "BI100_GDN_RESTORE_MODE", "direct", _VALID_RESTORE_MODES) + + +def gdn_restore_alignment(restore_mode: str, block_size: int, + scheduler_chunk_tokens: int) -> int: + """Return the content boundary required by a restore mode.""" + if block_size <= 0: + raise ValueError("block_size must be positive") + if restore_mode == "direct": + return block_size + if restore_mode in {"hybrid64", "chunk64"}: + alignment = GDN_KERNEL_CHUNK_TOKENS + elif restore_mode == "aligned": + alignment = scheduler_chunk_tokens + else: + raise ValueError(f"unknown GDN restore mode: {restore_mode}") + if alignment <= 0 or alignment % block_size != 0: + raise ValueError( + f"{restore_mode} GDN restore requires a positive alignment " + f"divisible by block_size={block_size}; got {alignment}") + return alignment + + +def make_prefix_key(block_count: int, digest: bytes) -> GdnPrefixKey: + if block_count <= 0: + raise ValueError("GDN prefix key requires at least one complete block") + if not isinstance(digest, bytes) or len(digest) != 32: + raise ValueError("GDN prefix digest must be exactly 32 bytes") + return block_count, digest + + +def keys_from_block_hashes(block_hashes: Sequence[bytes]) -> List[GdnPrefixKey]: + return [make_prefix_key(i + 1, digest) + for i, digest in enumerate(block_hashes)] + + +def strict_prefix_block_count(token_count: int, block_size: int) -> int: + if block_size <= 0: + raise ValueError("block_size must be positive") + if token_count <= 1: + return 0 + return (token_count - 1) // block_size + + +def key_at_strict_boundary(block_hashes: Sequence[bytes], token_count: int, + block_size: int) -> Optional[GdnPrefixKey]: + block_count = min( + len(block_hashes), strict_prefix_block_count(token_count, block_size)) + if block_count <= 0: + return None + return make_prefix_key(block_count, block_hashes[block_count - 1]) + + +def final_capture_key( + block_hashes: Sequence[bytes], prompt_tokens: int, block_size: int, + restore_mode: str, replay_alignment: int) -> Optional[GdnPrefixKey]: + if restore_mode in {"direct", "hybrid64"}: + block_count = min( + len(block_hashes), strict_prefix_block_count( + prompt_tokens, block_size)) + if (block_count > 0 + and prompt_tokens - block_count * block_size + < GDN_DIRECT_MIN_REPLAY_TOKENS): + block_count -= 1 + if block_count <= 0: + return None + return make_prefix_key(block_count, block_hashes[block_count - 1]) + if restore_mode not in {"chunk64", "aligned"}: + raise ValueError(f"unknown GDN restore mode: {restore_mode}") + if (replay_alignment <= 0 or replay_alignment % block_size != 0 + or prompt_tokens <= 1): + return None + boundary_tokens = ((prompt_tokens - 1) // replay_alignment + * replay_alignment) + block_count = min(len(block_hashes), boundary_tokens // block_size) + if block_count <= 0: + return None + return make_prefix_key(block_count, block_hashes[block_count - 1]) + + +def restore_key_is_eligible( + key: GdnPrefixKey, prompt_tokens: int, block_size: int, + restore_mode: str, replay_alignment: int, + direct_final_key: Optional[GdnPrefixKey] = None) -> bool: + """Return whether restoring ``key`` preserves the execution contract.""" + make_prefix_key(*key) + if block_size <= 0: + raise ValueError("block_size must be positive") + boundary_tokens = key[0] * block_size + remaining_tokens = prompt_tokens - boundary_tokens + if remaining_tokens <= 0: + return False + if restore_mode == "direct": + return remaining_tokens >= GDN_DIRECT_MIN_REPLAY_TOKENS + if restore_mode == "hybrid64": + if direct_final_key is not None: + make_prefix_key(*direct_final_key) + return (remaining_tokens >= GDN_DIRECT_MIN_REPLAY_TOKENS + and replay_alignment > 0 + and (boundary_tokens % replay_alignment == 0 + or key == direct_final_key)) + if restore_mode not in {"chunk64", "aligned"}: + raise ValueError(f"unknown GDN restore mode: {restore_mode}") + return (replay_alignment > 0 + and boundary_tokens % replay_alignment == 0) + + +def capture_points_for_step( + targets: Iterable[GdnPrefixKey], physical_context_tokens: int, + logical_end_tokens: int, block_size: int) -> Tuple[GdnCapturePoint, ...]: + if physical_context_tokens < 0 or logical_end_tokens < 0: + raise ValueError("token positions must be non-negative") + if logical_end_tokens <= physical_context_tokens: + return () + selected = {} + for key in targets: + make_prefix_key(*key) + boundary_tokens = key[0] * block_size + if physical_context_tokens < boundary_tokens <= logical_end_tokens: + selected[boundary_tokens - physical_context_tokens] = key + points = tuple(sorted(selected.items())) + if len(points) > 2: + raise ValueError("at most two GDN capture points are allowed per step") + return points + + +def cap_prefill_end_at_capture_boundary( + logical_start_tokens: int, logical_end_tokens: int, + targets: Iterable[GdnPrefixKey], block_size: int) -> int: + """Stop a physical prefill step at its earliest pending capture boundary.""" + if logical_start_tokens < 0 or logical_end_tokens < 0: + raise ValueError("token positions must be non-negative") + if logical_end_tokens < logical_start_tokens: + raise ValueError("logical end must not precede logical start") + if block_size <= 0: + raise ValueError("block_size must be positive") + + capped_end = logical_end_tokens + for key in targets: + make_prefix_key(*key) + boundary_tokens = key[0] * block_size + if logical_start_tokens < boundary_tokens < capped_end: + capped_end = boundary_tokens + return capped_end + + +def canonical_direct_segment_offsets( + block_hashes: Sequence[bytes], physical_context_tokens: int, + logical_end_tokens: int, block_size: int, + scheduler_chunk_tokens: int) -> Tuple[int, ...]: + """Reproduce cold fine32/direct segment boundaries after fast-forward.""" + if physical_context_tokens < 0 or logical_end_tokens < 0: + raise ValueError("token positions must be non-negative") + if block_size <= 0 or scheduler_chunk_tokens <= 0: + raise ValueError("block and scheduler chunk sizes must be positive") + if scheduler_chunk_tokens % block_size != 0: + raise ValueError("scheduler chunk size must be divisible by block size") + if logical_end_tokens <= physical_context_tokens: + return () + + boundaries = set() + step_ends = list(range(scheduler_chunk_tokens, logical_end_tokens, + scheduler_chunk_tokens)) + for step_end in (*step_ends, logical_end_tokens): + key = final_capture_key(block_hashes, step_end, block_size, + "direct", block_size) + if key is not None: + boundaries.add(key[0] * block_size) + boundaries.update(step_ends) + return tuple( + boundary - physical_context_tokens + for boundary in sorted(boundaries) + if physical_context_tokens < boundary < logical_end_tokens) + + +@dataclass(frozen=True) +class GdnCachePlan: + restore_key: Optional[GdnPrefixKey] = None + capture_points: Tuple[GdnCapturePoint, ...] = () + evict_keys: Tuple[GdnPrefixKey, ...] = () + + +class GdnPrefixStatePolicy: + """Scheduler-owned state index with deterministic worker actions.""" + + def __init__(self, policy: str) -> None: + if policy not in _VALID_POLICIES: + raise ValueError(f"unknown GDN cache policy: {policy}") + self.policy = policy + self.capacity = {"fine32": 32, "admission64": 64, "off": 0}[policy] + self._resident: OrderedDict[GdnPrefixKey, None] = OrderedDict() + + def __len__(self) -> int: + return len(self._resident) + + def resident_keys(self) -> Tuple[GdnPrefixKey, ...]: + return tuple(self._resident) + + def contains(self, key: GdnPrefixKey) -> bool: + return key in self._resident + + def should_capture_final(self, key: GdnPrefixKey) -> bool: + """Return whether a final state must be materialized on this request.""" + make_prefix_key(*key) + if self.policy == "off": + return False + if self.policy == "admission64": + return key not in self._resident + return True + + def select_restore( + self, live_prefix_keys: Sequence[GdnPrefixKey], + max_blocks: int) -> Optional[GdnPrefixKey]: + if self.capacity == 0 or max_blocks <= 0: + return None + best = None + for key in live_prefix_keys[:max_blocks]: + if key in self._resident: + best = key + if best is not None: + self._resident.move_to_end(best) + return best + + def repeated_branch_candidate( + self, live_prefix_keys: Sequence[GdnPrefixKey], + max_blocks: int) -> Optional[GdnPrefixKey]: + """Return a repeated raw-KV branch that lacks recurrent state. + + A live KV hit proves that the content occurred in an earlier request; + the current request is therefore the second or later occurrence. + """ + if (self.policy != "admission64" or max_blocks <= 0 + or not live_prefix_keys): + return None + candidate = live_prefix_keys[min(len(live_prefix_keys), max_blocks) - 1] + if candidate in self._resident: + return None + return candidate + + def admit(self, keys: Iterable[GdnPrefixKey]) -> Tuple[GdnPrefixKey, ...]: + evicted: List[GdnPrefixKey] = [] + if self.capacity == 0: + return () + for key in keys: + make_prefix_key(*key) + if key in self._resident: + self._resident.move_to_end(key) + else: + self._resident[key] = None + while len(self._resident) > self.capacity: + evicted_key, _ = self._resident.popitem(last=False) + evicted.append(evicted_key) + return tuple(evicted) + + def forget(self, keys: Iterable[GdnPrefixKey]) -> None: + for key in keys: + self._resident.pop(key, None) diff --git a/qwen3_6_scripts/install_prebuilt_corex.sh b/qwen3_6_scripts/install_prebuilt_corex.sh new file mode 100755 index 00000000..aca8052c --- /dev/null +++ b/qwen3_6_scripts/install_prebuilt_corex.sh @@ -0,0 +1,62 @@ +#!/usr/bin/env bash +set -euo pipefail + +VLLM_ROOT=${1:?usage: install_prebuilt_corex.sh VLLM_ROOT} +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +BUNDLE_DIR=${SCRIPT_DIR}/prebuilt/corex-3.2.3-ivcore10 +MANIFEST=${BUNDLE_DIR}/SHA256SUMS + +[[ -d "$VLLM_ROOT" ]] || { + printf 'vLLM root does not exist: %s\n' "$VLLM_ROOT" >&2 + exit 2 +} +[[ -f "$MANIFEST" ]] || { + printf 'prebuilt CoreX manifest is missing: %s\n' "$MANIFEST" >&2 + exit 2 +} + +mapfile -t artifacts < <(awk '{print $2}' "$MANIFEST") +[[ "${#artifacts[@]}" -eq 12 ]] || { + printf 'expected 12 prebuilt CoreX artifacts, found %s\n' \ + "${#artifacts[@]}" >&2 + exit 2 +} + +for artifact in "${artifacts[@]}"; do + [[ "$artifact" == corex_*.so && "$artifact" != */* ]] || { + printf 'invalid prebuilt artifact name: %s\n' "$artifact" >&2 + exit 2 + } +done + +( + cd "$BUNDLE_DIR" + sha256sum --strict --check SHA256SUMS +) + +for artifact in "${artifacts[@]}"; do + install -m 0755 "$BUNDLE_DIR/$artifact" "$VLLM_ROOT/$artifact" +done + +python3 - "$VLLM_ROOT" "${artifacts[@]}" <<'PY' +import pathlib +import struct +import sys + +root = pathlib.Path(sys.argv[1]) +for name in sys.argv[2:]: + path = root / name + if not path.is_file() or path.stat().st_size == 0: + raise SystemExit(f"installed CoreX extension is empty: {path}") + header = path.read_bytes()[:20] + if len(header) < 20 or header[:4] != b"\x7fELF": + raise SystemExit(f"installed CoreX extension is not ELF: {path}") + if header[4:6] != b"\x02\x01": + raise SystemExit( + f"installed CoreX extension is not 64-bit little-endian ELF: {path}") + machine = struct.unpack_from(" 0 - for cache_t in self.mamba_cache: - cache_t[:, [to_index,from_index]] = \ - cache_t[:, [from_index,to_index]] - - def _copy_mamba_cache(self, from_index: int, to_index: int): - assert len(self.mamba_cache) > 0 - for cache_t in self.mamba_cache: - cache_t[:, to_index].copy_(cache_t[:, from_index], - non_blocking=True) - - def _move_out_if_already_occupied(self, index: int, - all_occupied_indices: List[int]): - if index in all_occupied_indices: - first_free_index = self._first_free_index_in_mamba_cache() - # In case occupied, move the occupied to a new empty block - self._move_cache_index_and_mappings(from_index=index, - to_index=first_free_index) - - def _assign_seq_id_to_mamba_cache_in_specific_dest(self, cur_rid: str, - seq_id: int, - destination_index: int): - """ - Assign (req_id,seq_id) pair to a `destination_index` index, if - already occupied, move the occupying index to a free index. - """ - all_occupied_indices = self._get_all_occupied_indices() - if cur_rid not in self.mamba_cache_indices_mapping: - self._move_out_if_already_occupied( - index=destination_index, - all_occupied_indices=all_occupied_indices) - for cache_t in self.mamba_cache: - cache_t[:, destination_index].zero_() - self.mamba_cache_indices_mapping[cur_rid] = { - seq_id: destination_index - } - elif seq_id not in (seq_ids2indices := - self.mamba_cache_indices_mapping[cur_rid]): - # parallel sampling , where n > 1, assume prefill have - # already happened now we only need to copy the already - # existing cache into the siblings seq_ids caches - self._move_out_if_already_occupied( - index=destination_index, - all_occupied_indices=all_occupied_indices) - index_exists = list(seq_ids2indices.values())[0] - # case of decoding n>1, copy prefill cache to decoding indices - self._copy_mamba_cache(from_index=index_exists, - to_index=destination_index) - self.mamba_cache_indices_mapping[cur_rid][ - seq_id] = destination_index - else: - # already exists - cache_index_already_exists = self.mamba_cache_indices_mapping[ - cur_rid][seq_id] - if cache_index_already_exists != destination_index: - # In case the seq id already exists but not in - # the right destination, swap it with what's occupying it - self._swap_pair_indices_and_mappings( - from_index=cache_index_already_exists, - to_index=destination_index) - - def _prepare_current_run_mamba_cache( - self, request_ids_to_seq_ids: Dict[str, list[int]], - finished_requests_ids: List[str]): - running_indices = [] - request_ids_to_seq_ids_flatten = [ - (req_id, seq_id) - for req_id, seq_ids in request_ids_to_seq_ids.items() - for seq_id in seq_ids - ] - batch_size = len(request_ids_to_seq_ids_flatten) - for dest_index, (request_id, - seq_id) in enumerate(request_ids_to_seq_ids_flatten): - if request_id in finished_requests_ids: - # Do not allocate cache index for requests that run - # and finish right after - continue - self._assign_seq_id_to_mamba_cache_in_specific_dest( - request_id, seq_id, dest_index) - running_indices.append(dest_index) - - self._clean_up_first_bs_blocks(batch_size, running_indices) - conv_state = self.mamba_cache[0][:, :batch_size] - temporal_state = self.mamba_cache[1][:, :batch_size] - - return (conv_state, temporal_state) - - def _get_all_occupied_indices(self): - return [ - cache_idx - for seq_ids2indices in self.mamba_cache_indices_mapping.values() - for cache_idx in seq_ids2indices.values() - ] - - def _clean_up_first_bs_blocks(self, batch_size: int, - indices_for_current_run: List[int]): - # move out all of the occupied but currently not running blocks - # outside of the first n blocks - destination_indices = range(batch_size) - max_possible_batch_size = self.mamba_cache[0].shape[1] - for destination_index in destination_indices: - if destination_index in self._get_all_occupied_indices() and \ - destination_index not in indices_for_current_run: - # move not running indices outside of the batch - all_other_indices = list( - range(batch_size, max_possible_batch_size)) - first_avail_index = self._first_free_index_in_mamba_cache( - all_other_indices) - self._swap_indices(from_index=destination_index, - to_index=first_avail_index) - - def _move_cache_index_and_mappings(self, from_index: int, to_index: int): - self._copy_mamba_cache(from_index=from_index, to_index=to_index) - self._update_mapping_index(from_index=from_index, to_index=to_index) - - def _swap_pair_indices_and_mappings(self, from_index: int, to_index: int): - self._swap_mamba_cache(from_index=from_index, to_index=to_index) - self._swap_mapping_index(from_index=from_index, to_index=to_index) - - def _swap_mapping_index(self, from_index: int, to_index: int): - for seq_ids2index in self.mamba_cache_indices_mapping.values(): - for seq_id, index in seq_ids2index.items(): - if from_index == index: - seq_ids2index.update({seq_id: to_index}) - elif to_index == index: - seq_ids2index.update({seq_id: from_index}) - - def _update_mapping_index(self, from_index: int, to_index: int): - for seq_ids2index in self.mamba_cache_indices_mapping.values(): - for seq_id, index in seq_ids2index.items(): - if from_index == index: - seq_ids2index.update({seq_id: to_index}) - return - - def _release_finished_requests(self, - finished_seq_groups_req_ids: List[str]): - for req_id in finished_seq_groups_req_ids: - if req_id in self.mamba_cache_indices_mapping: - self.mamba_cache_indices_mapping.pop(req_id) - - def _first_free_index_in_mamba_cache( - self, indices_range: Optional[List[int]] = None) -> int: - assert self.mamba_cache is not None - if indices_range is None: - max_possible_batch_size = self.mamba_cache[0].shape[1] - indices_range = list(range(max_possible_batch_size)) - all_occupied_indices = self._get_all_occupied_indices() - for i in indices_range: - if i not in all_occupied_indices: - return i - raise Exception("Couldn't find a free spot in the mamba cache! This" - "should never happen") +from typing import Dict, List, Optional + +import torch + +from vllm.attention.backends.abstract import AttentionMetadata + + +class MambaCacheManager: + + def __init__(self, dtype, num_mamba_layers, max_batch_size, + conv_state_shape, temporal_state_shape): + + conv_state = torch.empty(size=(num_mamba_layers, max_batch_size) + + conv_state_shape, + dtype=dtype, + device="cuda") + temporal_state = torch.zeros(size=(num_mamba_layers, max_batch_size) + + temporal_state_shape, + dtype=dtype, + device="cuda") + + self.mamba_cache = (conv_state, temporal_state) + + # Maps between the request id and a dict that maps between the seq_id + # and its index inside the self.mamba_cache + self.mamba_cache_indices_mapping: Dict[str, Dict[int, int]] = {} + + def current_run_tensors(self, input_ids: torch.Tensor, + attn_metadata: AttentionMetadata, **kwargs): + """ + Return the tensors for the current run's conv and ssm state. + """ + if "seqlen_agnostic_capture_inputs" not in kwargs: + # We get here only on Prefill/Eager mode runs + request_ids_to_seq_ids = kwargs["request_ids_to_seq_ids"] + finished_requests_ids = kwargs["finished_requests_ids"] + + self._release_finished_requests(finished_requests_ids) + mamba_cache_tensors = self._prepare_current_run_mamba_cache( + request_ids_to_seq_ids, finished_requests_ids) + + else: + # CUDA graph capturing runs + mamba_cache_tensors = kwargs["seqlen_agnostic_capture_inputs"] + + return mamba_cache_tensors + + def copy_inputs_before_cuda_graphs(self, input_buffers, **kwargs): + """ + Copy the relevant Mamba cache into the CUDA graph input buffer + that was provided during the capture runs + (JambaForCausalLM.mamba_gc_cache_buffer). + """ + assert all( + key in kwargs + for key in ["request_ids_to_seq_ids", "finished_requests_ids"]) + finished_requests_ids = kwargs["finished_requests_ids"] + request_ids_to_seq_ids = kwargs["request_ids_to_seq_ids"] + + self._release_finished_requests(finished_requests_ids) + self._prepare_current_run_mamba_cache(request_ids_to_seq_ids, + finished_requests_ids) + + def get_seqlen_agnostic_capture_inputs(self, batch_size: int): + """ + Provide the CUDA graph capture runs with a buffer in adjusted size. + The buffer is used to maintain the Mamba Cache during the CUDA graph + replay runs. + """ + return tuple(buffer[:, :batch_size] for buffer in self.mamba_cache) + + def _swap_mamba_cache(self, from_index: int, to_index: int): + assert len(self.mamba_cache) > 0 + for cache_t in self.mamba_cache: + cache_t[:, [to_index,from_index]] = \ + cache_t[:, [from_index,to_index]] + + def _copy_mamba_cache(self, from_index: int, to_index: int): + assert len(self.mamba_cache) > 0 + for cache_t in self.mamba_cache: + cache_t[:, to_index].copy_(cache_t[:, from_index], + non_blocking=True) + + def _move_out_if_already_occupied(self, index: int, + all_occupied_indices: List[int]): + if index in all_occupied_indices: + first_free_index = self._first_free_index_in_mamba_cache() + # In case occupied, move the occupied to a new empty block + self._move_cache_index_and_mappings(from_index=index, + to_index=first_free_index) + + def _assign_seq_id_to_mamba_cache_in_specific_dest(self, cur_rid: str, + seq_id: int, + destination_index: int): + """ + Assign (req_id,seq_id) pair to a `destination_index` index, if + already occupied, move the occupying index to a free index. + """ + all_occupied_indices = self._get_all_occupied_indices() + if cur_rid not in self.mamba_cache_indices_mapping: + self._move_out_if_already_occupied( + index=destination_index, + all_occupied_indices=all_occupied_indices) + for cache_t in self.mamba_cache: + cache_t[:, destination_index].zero_() + self.mamba_cache_indices_mapping[cur_rid] = { + seq_id: destination_index + } + elif seq_id not in (seq_ids2indices := + self.mamba_cache_indices_mapping[cur_rid]): + # parallel sampling , where n > 1, assume prefill have + # already happened now we only need to copy the already + # existing cache into the siblings seq_ids caches + self._move_out_if_already_occupied( + index=destination_index, + all_occupied_indices=all_occupied_indices) + index_exists = list(seq_ids2indices.values())[0] + # case of decoding n>1, copy prefill cache to decoding indices + self._copy_mamba_cache(from_index=index_exists, + to_index=destination_index) + self.mamba_cache_indices_mapping[cur_rid][ + seq_id] = destination_index + else: + # already exists + cache_index_already_exists = self.mamba_cache_indices_mapping[ + cur_rid][seq_id] + if cache_index_already_exists != destination_index: + # In case the seq id already exists but not in + # the right destination, swap it with what's occupying it + self._swap_pair_indices_and_mappings( + from_index=cache_index_already_exists, + to_index=destination_index) + + def _prepare_current_run_mamba_cache( + self, request_ids_to_seq_ids: Dict[str, list[int]], + finished_requests_ids: List[str]): + running_indices = [] + request_ids_to_seq_ids_flatten = [ + (req_id, seq_id) + for req_id, seq_ids in request_ids_to_seq_ids.items() + for seq_id in seq_ids + ] + batch_size = len(request_ids_to_seq_ids_flatten) + for dest_index, (request_id, + seq_id) in enumerate(request_ids_to_seq_ids_flatten): + if request_id in finished_requests_ids: + # Do not allocate cache index for requests that run + # and finish right after + continue + self._assign_seq_id_to_mamba_cache_in_specific_dest( + request_id, seq_id, dest_index) + running_indices.append(dest_index) + + self._clean_up_first_bs_blocks(batch_size, running_indices) + conv_state = self.mamba_cache[0][:, :batch_size] + temporal_state = self.mamba_cache[1][:, :batch_size] + + return (conv_state, temporal_state) + + def _get_all_occupied_indices(self): + return [ + cache_idx + for seq_ids2indices in self.mamba_cache_indices_mapping.values() + for cache_idx in seq_ids2indices.values() + ] + + def _clean_up_first_bs_blocks(self, batch_size: int, + indices_for_current_run: List[int]): + # move out all of the occupied but currently not running blocks + # outside of the first n blocks + destination_indices = range(batch_size) + max_possible_batch_size = self.mamba_cache[0].shape[1] + for destination_index in destination_indices: + if destination_index in self._get_all_occupied_indices() and \ + destination_index not in indices_for_current_run: + # move not running indices outside of the batch + all_other_indices = list( + range(batch_size, max_possible_batch_size)) + first_avail_index = self._first_free_index_in_mamba_cache( + all_other_indices) + self._swap_indices(from_index=destination_index, + to_index=first_avail_index) + + def _move_cache_index_and_mappings(self, from_index: int, to_index: int): + self._copy_mamba_cache(from_index=from_index, to_index=to_index) + self._update_mapping_index(from_index=from_index, to_index=to_index) + + def _swap_pair_indices_and_mappings(self, from_index: int, to_index: int): + self._swap_mamba_cache(from_index=from_index, to_index=to_index) + self._swap_mapping_index(from_index=from_index, to_index=to_index) + + def _swap_mapping_index(self, from_index: int, to_index: int): + for seq_ids2index in self.mamba_cache_indices_mapping.values(): + for seq_id, index in seq_ids2index.items(): + if from_index == index: + seq_ids2index.update({seq_id: to_index}) + elif to_index == index: + seq_ids2index.update({seq_id: from_index}) + + def _update_mapping_index(self, from_index: int, to_index: int): + for seq_ids2index in self.mamba_cache_indices_mapping.values(): + for seq_id, index in seq_ids2index.items(): + if from_index == index: + seq_ids2index.update({seq_id: to_index}) + return + + def _release_finished_requests(self, + finished_seq_groups_req_ids: List[str]): + for req_id in finished_seq_groups_req_ids: + if req_id in self.mamba_cache_indices_mapping: + self.mamba_cache_indices_mapping.pop(req_id) + + def _first_free_index_in_mamba_cache( + self, indices_range: Optional[List[int]] = None) -> int: + assert self.mamba_cache is not None + if indices_range is None: + max_possible_batch_size = self.mamba_cache[0].shape[1] + indices_range = list(range(max_possible_batch_size)) + all_occupied_indices = self._get_all_occupied_indices() + for i in indices_range: + if i not in all_occupied_indices: + return i + raise Exception("Couldn't find a free spot in the mamba cache! This" + "should never happen") diff --git a/qwen3_6_scripts/paged_attn.py b/qwen3_6_scripts/paged_attn.py index 85904895..e7daa2fe 100644 --- a/qwen3_6_scripts/paged_attn.py +++ b/qwen3_6_scripts/paged_attn.py @@ -1,9 +1,27 @@ from dataclasses import dataclass from typing import List, Optional, Tuple +import hashlib +import json +import os +from pathlib import Path +import re import sys +import tempfile import torch import traceback from vllm import _custom_ops as ops +from vllm.bi100_env import env_bool, env_int +from vllm.bi100_profile import bi100_profile_count, bi100_timer + +try: + from vllm import corex_paged_kv_gather as _corex_paged_kv_gather +except ImportError: + _corex_paged_kv_gather = None + +try: + from vllm import corex_fused_paged_prefill as _corex_fused_paged_prefill +except ImportError: + _corex_fused_paged_prefill = None # from vllm.attention.ops.prefix_prefill import context_attention_fwd # NOTE: context_attention_fwd (Triton kernel from prefix_prefill.py) is NOT @@ -13,6 +31,1219 @@ from vllm import _custom_ops as ops # Should be the same as PARTITION_SIZE in `paged_attention_v2_launcher`. _PARTITION_SIZE = 512 +_PYTORCH_DECODE_THRESHOLD = env_int( + "BI100_PYTORCH_DECODE_THRESHOLD", 32768, 1, 262144) +_PREFIX_BLOCKS_PER_TILE = env_int( + "BI100_PREFIX_BLOCKS_PER_TILE", 32, 1, 1024) +_FORCE_PAGED_ATTN_V2 = env_bool("BI100_FORCE_PAGED_ATTN_V2", False) +_PAGED_ATTN_DIAGNOSTICS = env_bool( + "BI100_PAGED_ATTN_DIAGNOSTICS", False) +_USE_COREX_PAGED_KV_GATHER = ( + _corex_paged_kv_gather is not None + and env_bool("BI100_ATTN_COREX_PAGED_GATHER", True)) +_ENABLE_COREX_FUSED_PAGED_PREFILL = env_bool( + "BI100_ATTN_COREX_FUSED_PREFILL", False) +_FUSED_PREFILL_DIAGNOSTICS = env_bool( + "BI100_ATTN_COREX_FUSED_PREFILL_DIAGNOSTICS", False) + + +def _env_choice(name: str, default: str, choices: Tuple[str, ...]) -> str: + value = os.environ.get(name, default) + if value not in choices: + raise RuntimeError( + f"{name} must be one of {', '.join(choices)}, got {value!r}") + return value + + +_FUSED_PREFILL_SHADOW = env_bool( + "BI100_ATTN_COREX_FUSED_PREFILL_SHADOW", False) +_FUSED_PREFILL_SHADOW_MAX_CALLS_PER_CONTEXT = env_int( + "BI100_ATTN_COREX_FUSED_PREFILL_SHADOW_MAX_CALLS_PER_CONTEXT", + 2, 1, 8) +_FUSED_PREFILL_SHADOW_NUMERIC_MODE = _env_choice( + "BI100_ATTN_COREX_FUSED_PREFILL_SHADOW_NUMERIC_MODE", + "legacy", + ("legacy", "calibrated"), +) +_FUSED_PREFILL_SHADOW_FAILURE_ACTION = _env_choice( + "BI100_ATTN_COREX_FUSED_PREFILL_SHADOW_FAILURE_ACTION", + "raise", + ("raise", "record"), +) +_USE_COREX_FUSED_PAGED_PREFILL = ( + _corex_fused_paged_prefill is not None + and _ENABLE_COREX_FUSED_PAGED_PREFILL) +_DECODE_LOG_INTERVAL = 8192 if _PAGED_ATTN_DIAGNOSTICS else 0 +_DECODE_DISPATCH_LOGGED = set() +_PREFIX_DISPATCH_LOGGED = set() +_FUSED_PREFILL_DIAGNOSTICS_LOGGED = set() +_CACHE_WRITE_LOGGED = False +_FUSED_PREFILL_SHADOW_RELATIVE_L2_LIMIT = 1.0e-5 +_FUSED_PREFILL_SHADOW_MAX_ABS_LIMIT = 1.0e-3 +_FUSED_PREFILL_SHADOW_ERROR_MULTIPLIER = 2.0 +_FUSED_PREFILL_SHADOW_RATIO_FLOOR = 1.0e-12 +_FUSED_PREFILL_SHADOW_STATE = { + "pid": None, + "records": [], +} +_ACTIVATION_CAPTURE_ENABLED = env_bool( + "BI100_ATTN_CAPTURE_REPLAY", False) +_ACTIVATION_CAPTURE_ATTESTATION = ( + "synthetic-exact-prompt-v1") +_ACTIVATION_CAPTURE_STATE = { + "pid": None, + "seen_by_bucket": {}, + "records": [], +} + + +def _parse_fused_prefill_shadow_contexts(raw: str) -> Tuple[int, ...]: + """Parse fixed lower-bound buckets used by the diagnostic shadow.""" + values = [] + for field in raw.split(","): + field = field.strip() + if not field: + raise RuntimeError( + "BI100_ATTN_COREX_FUSED_PREFILL_SHADOW_CONTEXTS " + "contains an empty field") + try: + value = int(field) + except ValueError as exc: + raise RuntimeError( + "BI100_ATTN_COREX_FUSED_PREFILL_SHADOW_CONTEXTS must " + "contain integers") from exc + if value < 0 or value > 262144: + raise RuntimeError( + "BI100_ATTN_COREX_FUSED_PREFILL_SHADOW_CONTEXTS value " + "is outside [0, 262144]") + values.append(value) + if not values or values != sorted(set(values)): + raise RuntimeError( + "BI100_ATTN_COREX_FUSED_PREFILL_SHADOW_CONTEXTS must be " + "strictly increasing and unique") + return tuple(values) + + +_FUSED_PREFILL_SHADOW_CONTEXTS = _parse_fused_prefill_shadow_contexts( + os.environ.get( + "BI100_ATTN_COREX_FUSED_PREFILL_SHADOW_CONTEXTS", + "49152,114688")) + + +def _validate_fused_prefill_shadow_configuration( + enabled: bool, + fused_enabled: bool, + report_dir: Optional[str], + run_id: Optional[str], +) -> Optional[Path]: + """Validate that the diagnostic cannot silently write ambiguous data.""" + if not enabled: + return None + if not fused_enabled: + raise RuntimeError( + "fused-prefill shadow requires the fused-prefill path") + if ( + _FUSED_PREFILL_SHADOW_FAILURE_ACTION == "record" + and _FUSED_PREFILL_SHADOW_NUMERIC_MODE != "calibrated" + ): + raise RuntimeError( + "record-only shadow failures require calibrated numeric mode") + if not report_dir: + raise RuntimeError( + "BI100_ATTN_COREX_FUSED_PREFILL_SHADOW_REPORT_DIR is required") + path = Path(report_dir).expanduser() + tmp_root = Path("/tmp").resolve() + try: + path = path.resolve(strict=False) + except OSError as exc: + raise RuntimeError( + "fused-prefill shadow report directory cannot be resolved") \ + from exc + if ( + not path.is_absolute() + or path == tmp_root + or not path.is_relative_to(tmp_root) + ): + raise RuntimeError( + "fused-prefill shadow report directory must be under /tmp") + if ( + not run_id + or len(run_id) > 96 + or re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_.-]*", run_id) is None + ): + raise RuntimeError( + "BI100_ATTN_COREX_FUSED_PREFILL_SHADOW_RUN_ID is invalid") + path.mkdir(mode=0o700, parents=True, exist_ok=True) + if not path.resolve(strict=True).is_relative_to(tmp_root): + raise RuntimeError( + "fused-prefill shadow report directory escaped /tmp") + try: + path.chmod(0o700) + except OSError: + pass + return path + + +_FUSED_PREFILL_SHADOW_RUN_ID = os.environ.get( + "BI100_ATTN_COREX_FUSED_PREFILL_SHADOW_RUN_ID") +_FUSED_PREFILL_SHADOW_REPORT_DIR = ( + _validate_fused_prefill_shadow_configuration( + _FUSED_PREFILL_SHADOW, + _USE_COREX_FUSED_PAGED_PREFILL, + os.environ.get( + "BI100_ATTN_COREX_FUSED_PREFILL_SHADOW_REPORT_DIR"), + _FUSED_PREFILL_SHADOW_RUN_ID, + )) + + +def _parse_strict_int_tuple( + raw: str, + *, + name: str, + minimum: int, + maximum: int, +) -> Tuple[int, ...]: + values = [] + for field in raw.split(","): + field = field.strip() + if not field: + raise RuntimeError(f"{name} contains an empty field") + try: + value = int(field) + except ValueError as exc: + raise RuntimeError(f"{name} must contain integers") from exc + if value < minimum or value > maximum: + raise RuntimeError( + f"{name} value is outside [{minimum}, {maximum}]") + values.append(value) + if not values or values != sorted(set(values)): + raise RuntimeError(f"{name} must be strictly increasing and unique") + return tuple(values) + + +_ACTIVATION_CAPTURE_CONTEXTS = _parse_strict_int_tuple( + os.environ.get( + "BI100_ATTN_CAPTURE_REPLAY_CONTEXTS", + "24576,57344,122880", + ), + name="BI100_ATTN_CAPTURE_REPLAY_CONTEXTS", + minimum=0, + maximum=262144, +) +_ACTIVATION_CAPTURE_CALL_ORDINALS = _parse_strict_int_tuple( + os.environ.get( + "BI100_ATTN_CAPTURE_REPLAY_CALL_ORDINALS", + "0,4,9", + ), + name="BI100_ATTN_CAPTURE_REPLAY_CALL_ORDINALS", + minimum=0, + maximum=63, +) + + +def _validate_activation_capture_configuration( + enabled: bool, + fused_enabled: bool, + report_dir: Optional[str], + run_id: Optional[str], + source_revision: Optional[str], + runtime_identity: Optional[str], + attestation: Optional[str], +) -> Optional[Path]: + if not enabled: + return None + if fused_enabled: + raise RuntimeError( + "activation capture requires the baseline PyTorch fallback") + if attestation != _ACTIVATION_CAPTURE_ATTESTATION: + raise RuntimeError( + "activation capture requires the synthetic prompt attestation") + if ( + not source_revision + or re.fullmatch(r"[0-9a-f]{40,64}", source_revision) is None + ): + raise RuntimeError( + "BI100_ATTN_CAPTURE_REPLAY_SOURCE_REVISION is invalid") + if ( + not runtime_identity + or len(runtime_identity) > 160 + or re.fullmatch( + r"[A-Za-z0-9][A-Za-z0-9_.:/-]*", runtime_identity) is None + ): + raise RuntimeError( + "BI100_ATTN_CAPTURE_REPLAY_RUNTIME_IDENTITY is invalid") + if ( + not run_id + or len(run_id) > 96 + or re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_.-]*", run_id) is None + ): + raise RuntimeError( + "BI100_ATTN_CAPTURE_REPLAY_RUN_ID is invalid") + if not report_dir: + raise RuntimeError( + "BI100_ATTN_CAPTURE_REPLAY_DIR is required") + path = Path(report_dir).expanduser() + tmp_root = Path("/tmp").resolve() + try: + path = path.resolve(strict=False) + except OSError as exc: + raise RuntimeError( + "activation capture directory cannot be resolved") from exc + if ( + not path.is_absolute() + or path == tmp_root + or not path.is_relative_to(tmp_root) + ): + raise RuntimeError( + "activation capture directory must be under /tmp") + path.mkdir(mode=0o700, parents=True, exist_ok=True) + if not path.resolve(strict=True).is_relative_to(tmp_root): + raise RuntimeError( + "activation capture directory escaped /tmp") + try: + path.chmod(0o700) + except OSError: + pass + return path + + +_ACTIVATION_CAPTURE_RUN_ID = os.environ.get( + "BI100_ATTN_CAPTURE_REPLAY_RUN_ID") +_ACTIVATION_CAPTURE_SOURCE_REVISION = os.environ.get( + "BI100_ATTN_CAPTURE_REPLAY_SOURCE_REVISION") +_ACTIVATION_CAPTURE_RUNTIME_IDENTITY = os.environ.get( + "BI100_ATTN_CAPTURE_REPLAY_RUNTIME_IDENTITY") +_ACTIVATION_CAPTURE_DIR = _validate_activation_capture_configuration( + _ACTIVATION_CAPTURE_ENABLED, + _ENABLE_COREX_FUSED_PAGED_PREFILL, + os.environ.get("BI100_ATTN_CAPTURE_REPLAY_DIR"), + _ACTIVATION_CAPTURE_RUN_ID, + _ACTIVATION_CAPTURE_SOURCE_REVISION, + _ACTIVATION_CAPTURE_RUNTIME_IDENTITY, + os.environ.get("BI100_ATTN_CAPTURE_REPLAY_SYNTHETIC_ATTESTATION"), +) + + +def _log_corex_fused_prefill_diagnostic(stage: str, **fields) -> None: + """Emit one privacy-safe guard snapshot per stage and worker.""" + if not _FUSED_PREFILL_DIAGNOSTICS: + return + key = (os.getpid(), stage) + if key in _FUSED_PREFILL_DIAGNOSTICS_LOGGED: + return + details = " ".join(f"{name}={value}" for name, value in fields.items()) + print( + "[BI100 PAGED_ATTN] fused_prefill_guard " + f"pid={os.getpid()} rank={os.environ.get('RANK', '?')} " + f"local_rank={os.environ.get('LOCAL_RANK', '?')} stage={stage} " + f"{details}", + file=sys.stderr, + flush=True, + ) + _FUSED_PREFILL_DIAGNOSTICS_LOGGED.add(key) + + +def _fused_prefill_shadow_rank() -> int: + distributed = getattr(torch, "distributed", None) + if distributed is not None: + try: + if ( + distributed.is_available() + and distributed.is_initialized() + ): + rank = int(distributed.get_rank()) + if rank >= 0: + return rank + except (AttributeError, RuntimeError, TypeError, ValueError): + pass + for name in ("RANK", "LOCAL_RANK"): + raw = os.environ.get(name) + if raw is None: + continue + try: + value = int(raw) + except ValueError: + continue + if value >= 0: + return value + cuda = getattr(torch, "cuda", None) + if cuda is not None: + try: + if cuda.is_available(): + device = int(cuda.current_device()) + if device >= 0: + return device + except (AttributeError, RuntimeError, TypeError, ValueError): + pass + return -1 + + +def _activation_capture_process_state() -> dict: + pid = os.getpid() + if _ACTIVATION_CAPTURE_STATE["pid"] != pid: + _ACTIVATION_CAPTURE_STATE["pid"] = pid + _ACTIVATION_CAPTURE_STATE["seen_by_bucket"] = {} + _ACTIVATION_CAPTURE_STATE["records"] = [] + return _ACTIVATION_CAPTURE_STATE + + +def _activation_capture_bucket(context_tokens: int) -> Optional[int]: + for index, lower_bound in enumerate(_ACTIVATION_CAPTURE_CONTEXTS): + upper_bound = ( + _ACTIVATION_CAPTURE_CONTEXTS[index + 1] + if index + 1 < len(_ACTIVATION_CAPTURE_CONTEXTS) + else 262145 + ) + if lower_bound <= context_tokens < upper_bound: + return lower_bound + return None + + +def _atomic_write_activation_manifest(records: list) -> None: + if _ACTIVATION_CAPTURE_DIR is None: + raise RuntimeError("activation capture directory is unset") + rank = _fused_prefill_shadow_rank() + if rank < 0: + raise RuntimeError("activation capture cannot determine TP rank") + value = { + "schema": "bi100-fused-prefill-activation-bank-v1", + "version": 1, + "run_id": _ACTIVATION_CAPTURE_RUN_ID, + "rank": rank, + "source_revision": _ACTIVATION_CAPTURE_SOURCE_REVISION, + "runtime_identity": _ACTIVATION_CAPTURE_RUNTIME_IDENTITY, + "producer": "baseline-pytorch-fallback", + "synthetic_prompt_attestation": ( + _ACTIVATION_CAPTURE_ATTESTATION), + "selection": { + "context_buckets": list(_ACTIVATION_CAPTURE_CONTEXTS), + "full_attention_call_ordinals": list( + _ACTIVATION_CAPTURE_CALL_ORDINALS), + }, + "record_count": len(records), + "records": records, + "privacy": { + "raw_activation_files_private": True, + "raw_activation_files_may_be_committed": False, + "contains_prompts": False, + "contains_model_outputs": False, + "contains_token_ids": False, + "contains_credentials": False, + }, + } + destination = _ACTIVATION_CAPTURE_DIR / f"rank-{rank}.manifest.json" + descriptor, temporary = tempfile.mkstemp( + prefix=f".{destination.name}.", + suffix=".tmp", + dir=destination.parent, + ) + try: + with os.fdopen(descriptor, "w", encoding="ascii") as stream: + json.dump(value, stream, ensure_ascii=True, indent=2, + sort_keys=True) + stream.write("\n") + stream.flush() + os.fsync(stream.fileno()) + os.replace(temporary, destination) + finally: + try: + os.unlink(temporary) + except FileNotFoundError: + pass + + +def _reserve_activation_capture( + context_tokens: int, +) -> Optional[Tuple[int, int]]: + if not _ACTIVATION_CAPTURE_ENABLED: + return None + bucket = _activation_capture_bucket(context_tokens) + if bucket is None: + return None + state = _activation_capture_process_state() + ordinal = int(state["seen_by_bucket"].get(bucket, 0)) + state["seen_by_bucket"][bucket] = ordinal + 1 + if ordinal not in _ACTIVATION_CAPTURE_CALL_ORDINALS: + return None + return bucket, ordinal + + +def _tensor_shape_dtype(tensor: torch.Tensor) -> dict: + return { + "shape": list(tensor.shape), + "dtype": str(tensor.dtype), + } + + +def _sha256_file(path: Path) -> str: + digest = hashlib.sha256() + with path.open("rb") as stream: + for chunk in iter(lambda: stream.read(1024 * 1024), b""): + digest.update(chunk) + return digest.hexdigest() + + +def _capture_fused_prefill_activation( + reservation: Tuple[int, int], + query: torch.Tensor, + key: torch.Tensor, + value: torch.Tensor, + key_cache: torch.Tensor, + value_cache: torch.Tensor, + active_block_table: torch.Tensor, + context_tokens: int, + scale: float, +) -> None: + if _ACTIVATION_CAPTURE_DIR is None: + raise RuntimeError("activation capture directory is unset") + bucket, ordinal = reservation + rank = _fused_prefill_shadow_rank() + if rank < 0: + raise RuntimeError("activation capture cannot determine TP rank") + + active_ids = [ + int(value) for value in active_block_table.detach().cpu().tolist() + ] + identity_to_compact = {} + unique_ids = [] + compact_table = [] + for physical_id in active_ids: + if physical_id < 0 or physical_id >= key_cache.shape[0]: + raise RuntimeError( + "activation capture block table is outside the KV cache") + compact_id = identity_to_compact.get(physical_id) + if compact_id is None: + compact_id = len(unique_ids) + identity_to_compact[physical_id] = compact_id + unique_ids.append(physical_id) + compact_table.append(compact_id) + + if unique_ids: + physical = torch.tensor( + unique_ids, + dtype=torch.long, + device=key_cache.device, + ) + compact_key_cache = ( + key_cache.index_select(0, physical).detach().cpu().contiguous()) + compact_value_cache = ( + value_cache.index_select(0, physical).detach().cpu().contiguous()) + else: + compact_key_cache = key_cache[:0].detach().cpu().contiguous() + compact_value_cache = value_cache[:0].detach().cpu().contiguous() + compact_block_table = torch.tensor( + compact_table, + dtype=torch.int32, + ) + tensors = { + "query": query.detach().cpu().contiguous(), + "key": key.detach().cpu().contiguous(), + "value": value.detach().cpu().contiguous(), + "key_cache": compact_key_cache, + "value_cache": compact_value_cache, + "block_table": compact_block_table, + } + filename = ( + f"rank-{rank}.bucket-{bucket}.ordinal-{ordinal}." + f"ctx-{context_tokens}.q-{query.shape[0]}.pt" + ) + destination = _ACTIVATION_CAPTURE_DIR / filename + descriptor, temporary = tempfile.mkstemp( + prefix=f".{filename}.", suffix=".tmp", + dir=destination.parent) + os.close(descriptor) + try: + torch.save({ + "schema": "bi100-fused-prefill-activation-case-v1", + "version": 1, + "context_tokens": context_tokens, + "scale": float(scale), + "rank": rank, + "bucket": bucket, + "call_ordinal": ordinal, + "tensors": tensors, + }, temporary) + os.chmod(temporary, 0o600) + with open(temporary, "rb") as stream: + os.fsync(stream.fileno()) + os.replace(temporary, destination) + finally: + try: + os.unlink(temporary) + except FileNotFoundError: + pass + + state = _activation_capture_process_state() + state["records"].append({ + "bucket_min_context_tokens": bucket, + "call_ordinal": ordinal, + "context_tokens": context_tokens, + "query_length": int(query.shape[0]), + "file": filename, + "sha256": _sha256_file(destination), + "size_bytes": destination.stat().st_size, + "compact_physical_blocks": len(unique_ids), + "logical_blocks": len(compact_table), + "tensors": { + name: _tensor_shape_dtype(tensor) + for name, tensor in tensors.items() + }, + }) + _atomic_write_activation_manifest(state["records"]) + + +def _fused_prefill_shadow_process_state() -> dict: + pid = os.getpid() + if _FUSED_PREFILL_SHADOW_STATE["pid"] != pid: + _FUSED_PREFILL_SHADOW_STATE["pid"] = pid + _FUSED_PREFILL_SHADOW_STATE["records"] = [] + return _FUSED_PREFILL_SHADOW_STATE + + +def _fused_prefill_shadow_report_path() -> Path: + if _FUSED_PREFILL_SHADOW_REPORT_DIR is None: + raise RuntimeError("fused-prefill shadow report directory is unset") + rank = _fused_prefill_shadow_rank() + rank_label = str(rank) if rank >= 0 else "unknown" + return _FUSED_PREFILL_SHADOW_REPORT_DIR / ( + f"rank-{rank_label}-pid-{os.getpid()}.json") + + +def _atomic_write_fused_prefill_shadow_report(value: dict) -> None: + path = _fused_prefill_shadow_report_path() + descriptor, temporary = tempfile.mkstemp( + prefix=f".{path.name}.", suffix=".tmp", dir=path.parent) + try: + os.fchmod(descriptor, 0o600) + with os.fdopen(descriptor, "w", encoding="utf-8") as stream: + json.dump(value, stream, ensure_ascii=True, indent=2, + sort_keys=True) + stream.write("\n") + stream.flush() + os.fsync(stream.fileno()) + os.replace(temporary, path) + finally: + try: + os.unlink(temporary) + except FileNotFoundError: + pass + + +def _build_fused_prefill_shadow_report(records: list) -> dict: + expected = ( + len(_FUSED_PREFILL_SHADOW_CONTEXTS) + * _FUSED_PREFILL_SHADOW_MAX_CALLS_PER_CONTEXT) + completed = [ + record for record in records + if record["status"] in {"pass", "fail", "invalid"} + ] + failures = [record for record in completed if record["status"] == "fail"] + invalid = [record for record in completed if record["status"] == "invalid"] + pending = [record for record in records if record["status"] == "pending"] + relative_l2_values = [ + record["relative_l2"] for record in completed + if isinstance(record.get("relative_l2"), float) + ] + max_abs_values = [ + record["max_abs"] for record in completed + if isinstance(record.get("max_abs"), float) + ] + if invalid: + status = "invalid" + elif failures: + status = "fail" + elif len(completed) == expected and not pending: + status = "pass" + else: + status = "collecting" + report = { + "schema": "bi100-fused-prefill-real-activation-shadow-v1", + "version": 1, + "run_id": _FUSED_PREFILL_SHADOW_RUN_ID, + "pid": os.getpid(), + "rank": _fused_prefill_shadow_rank(), + "status": status, + "selection": { + "minimum_context_tokens": list( + _FUSED_PREFILL_SHADOW_CONTEXTS), + "max_calls_per_context": ( + _FUSED_PREFILL_SHADOW_MAX_CALLS_PER_CONTEXT), + }, + "thresholds": { + "require_finite_candidate": True, + "require_finite_reference": True, + "maximum_relative_l2": ( + _FUSED_PREFILL_SHADOW_RELATIVE_L2_LIMIT), + "maximum_absolute_error": ( + _FUSED_PREFILL_SHADOW_MAX_ABS_LIMIT), + }, + "observations": { + "expected": expected, + "reserved": len(records), + "completed": len(completed), + "passed": sum(record["status"] == "pass" for record in records), + "failed": len(failures), + "invalid": len(invalid), + "pending": len(pending), + "maximum_relative_l2": ( + max(relative_l2_values) if relative_l2_values else None), + "maximum_absolute_error": ( + max(max_abs_values) if max_abs_values else None), + }, + "records": records, + "privacy": { + "contains_prompts": False, + "contains_model_outputs": False, + "contains_tensor_values": False, + "contains_token_ids": False, + "contains_credentials": False, + }, + } + if _FUSED_PREFILL_SHADOW_NUMERIC_MODE == "calibrated": + report["schema"] = ( + "bi100-fused-prefill-real-activation-calibrated-shadow-v1") + report["thresholds"] = { + "require_finite_candidate": True, + "require_finite_reference": True, + "maximum_candidate_vs_rounded_relative_l2": ( + _FUSED_PREFILL_SHADOW_RELATIVE_L2_LIMIT), + "maximum_error_multiple_over_fp16_rounding": ( + _FUSED_PREFILL_SHADOW_ERROR_MULTIPLIER), + "ratio_denominator_floor": ( + _FUSED_PREFILL_SHADOW_RATIO_FLOOR), + "fixed_max_abs_role": "diagnostic_only", + "finite_failure_action": ( + _FUSED_PREFILL_SHADOW_FAILURE_ACTION), + } + calibrated_metrics = ( + "candidate_to_fp32_relative_l2", + "candidate_to_fp32_max_abs", + "rounded_to_fp32_relative_l2", + "rounded_to_fp32_max_abs", + "relative_l2_baseline_ratio", + "max_abs_baseline_ratio", + ) + for name in calibrated_metrics: + values = [ + record[name] for record in completed + if isinstance(record.get(name), float) + ] + report["observations"][f"maximum_{name}"] = ( + max(values) if values else None) + return report + + +def _reserve_fused_prefill_shadow( + query: torch.Tensor, + block_context_len: int, + num_q_heads: int, + num_kv_heads: int, + head_dim: int, + block_size: int, +) -> Optional[int]: + if not _FUSED_PREFILL_SHADOW: + return None + state = _fused_prefill_shadow_process_state() + records = state["records"] + selected_bucket = None + for bucket_index, bucket in enumerate(_FUSED_PREFILL_SHADOW_CONTEXTS): + upper_bound = ( + _FUSED_PREFILL_SHADOW_CONTEXTS[bucket_index + 1] + if bucket_index + 1 < len(_FUSED_PREFILL_SHADOW_CONTEXTS) + else None) + used = sum( + record["bucket_min_context_tokens"] == bucket + for record in records) + if ( + block_context_len >= bucket + and (upper_bound is None or block_context_len < upper_bound) + and used < _FUSED_PREFILL_SHADOW_MAX_CALLS_PER_CONTEXT + ): + selected_bucket = bucket + break + if selected_bucket is None: + return None + record = { + "index": len(records), + "status": "pending", + "bucket_min_context_tokens": selected_bucket, + "context_tokens": block_context_len, + "query_shape": list(query.shape), + "query_heads": num_q_heads, + "kv_heads": num_kv_heads, + "head_dim": head_dim, + "block_size": block_size, + "candidate_finite": None, + "reference_finite": None, + "relative_l2": None, + "max_abs": None, + "error_stage": None, + "error_type": None, + } + if _FUSED_PREFILL_SHADOW_NUMERIC_MODE == "calibrated": + record.update({ + "candidate_to_fp32_relative_l2": None, + "candidate_to_fp32_max_abs": None, + "rounded_to_fp32_relative_l2": None, + "rounded_to_fp32_max_abs": None, + "relative_l2_baseline_ratio": None, + "max_abs_baseline_ratio": None, + }) + records.append(record) + _atomic_write_fused_prefill_shadow_report( + _build_fused_prefill_shadow_report(records)) + return record["index"] + + +def _finish_fused_prefill_shadow( + index: int, + *, + status: str, + candidate_finite: Optional[bool] = None, + reference_finite: Optional[bool] = None, + relative_l2: Optional[float] = None, + max_abs: Optional[float] = None, + candidate_to_fp32_relative_l2: Optional[float] = None, + candidate_to_fp32_max_abs: Optional[float] = None, + rounded_to_fp32_relative_l2: Optional[float] = None, + rounded_to_fp32_max_abs: Optional[float] = None, + relative_l2_baseline_ratio: Optional[float] = None, + max_abs_baseline_ratio: Optional[float] = None, + error_stage: Optional[str] = None, + error_type: Optional[str] = None, +) -> None: + state = _fused_prefill_shadow_process_state() + records = state["records"] + if index < 0 or index >= len(records): + raise RuntimeError("fused-prefill shadow record index is invalid") + if status not in {"pass", "fail", "invalid"}: + raise RuntimeError("fused-prefill shadow status is invalid") + record = records[index] + updates = { + "status": status, + "candidate_finite": candidate_finite, + "reference_finite": reference_finite, + "relative_l2": relative_l2, + "max_abs": max_abs, + "error_stage": error_stage, + "error_type": error_type, + } + if _FUSED_PREFILL_SHADOW_NUMERIC_MODE == "calibrated": + updates.update({ + "candidate_to_fp32_relative_l2": ( + candidate_to_fp32_relative_l2), + "candidate_to_fp32_max_abs": candidate_to_fp32_max_abs, + "rounded_to_fp32_relative_l2": ( + rounded_to_fp32_relative_l2), + "rounded_to_fp32_max_abs": rounded_to_fp32_max_abs, + "relative_l2_baseline_ratio": relative_l2_baseline_ratio, + "max_abs_baseline_ratio": max_abs_baseline_ratio, + }) + record.update(updates) + _atomic_write_fused_prefill_shadow_report( + _build_fused_prefill_shadow_report(records)) + + +def _calibrated_shadow_metrics_qualified(metrics: dict) -> bool: + return ( + metrics["relative_l2"] + <= _FUSED_PREFILL_SHADOW_RELATIVE_L2_LIMIT + and metrics["candidate_to_fp32_relative_l2"] + <= ( + _FUSED_PREFILL_SHADOW_ERROR_MULTIPLIER + * metrics["rounded_to_fp32_relative_l2"] + + _FUSED_PREFILL_SHADOW_RATIO_FLOOR + ) + and metrics["candidate_to_fp32_max_abs"] + <= ( + _FUSED_PREFILL_SHADOW_ERROR_MULTIPLIER + * metrics["rounded_to_fp32_max_abs"] + + _FUSED_PREFILL_SHADOW_RATIO_FLOOR + ) + ) + + +def _error_metrics( + actual: torch.Tensor, + reference: torch.Tensor, + denominator: float, +) -> Tuple[float, float]: + difference = actual - reference + relative_l2 = float(torch.norm(difference).item()) / denominator + max_abs = float(difference.abs().max().item()) + return relative_l2, max_abs + + +def _compare_fused_prefill_shadow_outputs( + candidate: torch.Tensor, + reference: torch.Tensor, + reference_fp32: Optional[torch.Tensor] = None, +) -> dict: + candidate_float = candidate.float() + reference_float = reference.float() + candidate_finite = bool(torch.isfinite(candidate_float).all().item()) + reference_finite = bool(torch.isfinite(reference_float).all().item()) + if _FUSED_PREFILL_SHADOW_NUMERIC_MODE == "calibrated": + if reference_fp32 is None: + raise RuntimeError( + "calibrated fused-prefill shadow requires FP32 reference") + reference_fp32 = reference_fp32.float() + reference_finite = ( + reference_finite + and bool(torch.isfinite(reference_fp32).all().item()) + ) + if not candidate_finite or not reference_finite: + result = { + "status": "fail" if not candidate_finite else "invalid", + "candidate_finite": candidate_finite, + "reference_finite": reference_finite, + "relative_l2": None, + "max_abs": None, + } + if _FUSED_PREFILL_SHADOW_NUMERIC_MODE == "calibrated": + result.update({ + "candidate_to_fp32_relative_l2": None, + "candidate_to_fp32_max_abs": None, + "rounded_to_fp32_relative_l2": None, + "rounded_to_fp32_max_abs": None, + "relative_l2_baseline_ratio": None, + "max_abs_baseline_ratio": None, + }) + return result + denominator = max(float(torch.norm(reference_float).item()), 1.0e-12) + relative_l2, max_abs = _error_metrics( + candidate_float, reference_float, denominator) + if _FUSED_PREFILL_SHADOW_NUMERIC_MODE == "calibrated": + if reference_fp32 is None: + raise RuntimeError( + "calibrated fused-prefill shadow lost its FP32 reference") + fp32_denominator = max( + float(torch.norm(reference_fp32).item()), + _FUSED_PREFILL_SHADOW_RATIO_FLOOR, + ) + candidate_fp32_relative_l2, candidate_fp32_max_abs = ( + _error_metrics( + candidate_float, reference_fp32, fp32_denominator)) + rounded_fp32_relative_l2, rounded_fp32_max_abs = ( + _error_metrics( + reference_float, reference_fp32, fp32_denominator)) + metrics = { + "relative_l2": relative_l2, + "max_abs": max_abs, + "candidate_to_fp32_relative_l2": ( + candidate_fp32_relative_l2), + "candidate_to_fp32_max_abs": candidate_fp32_max_abs, + "rounded_to_fp32_relative_l2": rounded_fp32_relative_l2, + "rounded_to_fp32_max_abs": rounded_fp32_max_abs, + "relative_l2_baseline_ratio": ( + candidate_fp32_relative_l2 + / max( + rounded_fp32_relative_l2, + _FUSED_PREFILL_SHADOW_RATIO_FLOOR, + ) + ), + "max_abs_baseline_ratio": ( + candidate_fp32_max_abs + / max( + rounded_fp32_max_abs, + _FUSED_PREFILL_SHADOW_RATIO_FLOOR, + ) + ), + } + return { + "status": ( + "pass" + if _calibrated_shadow_metrics_qualified(metrics) + else "fail" + ), + "candidate_finite": True, + "reference_finite": True, + **metrics, + } + qualified = ( + relative_l2 <= _FUSED_PREFILL_SHADOW_RELATIVE_L2_LIMIT + and max_abs <= _FUSED_PREFILL_SHADOW_MAX_ABS_LIMIT) + return { + "status": "pass" if qualified else "fail", + "candidate_finite": True, + "reference_finite": True, + "relative_l2": relative_l2, + "max_abs": max_abs, + } + + +def _validate_decode_layout( + num_seqs: int, + seq_lens_count: int, + block_table_rows: int, + block_table_width: int, + actual_max: int, + block_size: int, + physical_key_blocks: int, + physical_value_blocks: int, + num_heads: int, + num_kv_heads: int, +) -> int: + """Validate host-visible decode metadata before a native kernel launch.""" + if num_seqs <= 0: + raise RuntimeError(f"decode requires num_seqs > 0, got {num_seqs}") + if seq_lens_count != num_seqs: + raise RuntimeError( + f"seq_lens has {seq_lens_count} entries for {num_seqs} sequences") + if block_table_rows < num_seqs: + raise RuntimeError( + f"block table has {block_table_rows} rows for {num_seqs} sequences") + if actual_max <= 0: + raise RuntimeError(f"decode sequence length must be > 0, got {actual_max}") + if block_size <= 0: + raise RuntimeError(f"KV block_size must be > 0, got {block_size}") + if physical_key_blocks != physical_value_blocks: + raise RuntimeError( + "key/value cache block counts differ: " + f"{physical_key_blocks} != {physical_value_blocks}") + if num_kv_heads <= 0 or num_heads % num_kv_heads != 0: + raise RuntimeError( + f"invalid GQA layout: num_heads={num_heads}, " + f"num_kv_heads={num_kv_heads}") + + required_blocks = (actual_max + block_size - 1) // block_size + if required_blocks > block_table_width: + raise RuntimeError( + f"decode needs {required_blocks} blocks for seq_len={actual_max}, " + f"but block table width is {block_table_width}") + return required_blocks + + +def _strict_prefix_query_segments( + context_len: int, + query_len: int, + block_size: int, +) -> List[Tuple[int, int, int]]: + """Split a query at the strict prefix-cache checkpoint, if it crosses it.""" + if query_len <= 0: + return [] + total_len = context_len + query_len + strict_prefix_len = ((total_len - 1) // block_size) * block_size + split = strict_prefix_len - context_len + if 0 < split < query_len: + return [(0, split, context_len), + (split, query_len, strict_prefix_len)] + return [(0, query_len, context_len)] + + +def _is_supported_corex_fused_paged_prefill_request( + kv_cache_dtype: str, + max_query_len: int, + total_query_len: int, + alibi_slopes: Optional[torch.Tensor], + sliding_window: Optional[int], + k_scale: float, + v_scale: float, + is_causal_decoder: bool, +) -> bool: + """Check request-wide properties that are outside the native ABI.""" + return bool( + is_causal_decoder + and _PREFIX_BLOCKS_PER_TILE == 32 + and kv_cache_dtype == "auto" + and max_query_len == total_query_len + and alibi_slopes is None + and sliding_window is None + and k_scale == 1.0 + and v_scale == 1.0 + ) + + +def _can_enable_corex_fused_paged_prefill_request( + kv_cache_dtype: str, + max_query_len: int, + total_query_len: int, + alibi_slopes: Optional[torch.Tensor], + sliding_window: Optional[int], + k_scale: float, + v_scale: float, + is_causal_decoder: bool, +) -> bool: + return bool( + _USE_COREX_FUSED_PAGED_PREFILL + and _is_supported_corex_fused_paged_prefill_request( + kv_cache_dtype, + max_query_len, + total_query_len, + alibi_slopes, + sliding_window, + k_scale, + v_scale, + is_causal_decoder, + ) + ) + + +def _is_single_sequence_fused_prefill_metadata( + batch_size: int, + block_table_rows: int, + query_start_count: int, + query_start_first: int, + query_start_last: int, + seq_lens_count: int, + seq_len: int, + context_lens_count: int, + context_len: int, + total_query_len: int, +) -> bool: + """Validate the exact single-sequence metadata used by qualification.""" + return bool( + batch_size == 1 + and block_table_rows == 1 + and query_start_count == 2 + and query_start_first == 0 + and query_start_last == total_query_len + and seq_lens_count == 1 + and context_lens_count == 1 + and context_len >= 0 + and seq_len == context_len + total_query_len + and seq_len <= 262144 + ) + + +def _is_supported_corex_fused_paged_prefill_segment( + query: torch.Tensor, + key: torch.Tensor, + value: torch.Tensor, + prefix_key: torch.Tensor, + prefix_value: torch.Tensor, + key_cache: torch.Tensor, + value_cache: torch.Tensor, + block_tables: torch.Tensor, + seq_index: int, + block_context_len: int, + num_q_heads: int, + num_kv_heads: int, + head_dim: int, + gqa_ratio: int, + block_size: int, +) -> bool: + """Accept only the fixed M1-47 production shape.""" + query_len = query.shape[0] + if ( + query_len <= 16 + or query_len > 8192 + or block_context_len < 0 + or block_context_len % 16 != 0 + or block_context_len + query_len > 262144 + ): + return False + if (num_q_heads, num_kv_heads, head_dim, gqa_ratio, block_size) != ( + 4, + 1, + 256, + 4, + 16, + ): + return False + if prefix_key.shape[0] != 0 or prefix_value.shape[0] != 0: + return False + if ( + tuple(query.shape) != (query_len, 4, 256) + or tuple(key.shape) != (query_len, 1, 256) + or tuple(value.shape) != (query_len, 1, 256) + ): + return False + if ( + len(key_cache.shape) != 5 + or tuple(key_cache.shape[1:]) != (1, 32, 16, 8) + or len(value_cache.shape) != 4 + or tuple(value_cache.shape[1:]) != (1, 256, 16) + or key_cache.shape[0] != value_cache.shape[0] + ): + return False + if ( + len(block_tables.shape) != 2 + or block_tables.shape[0] != 1 + or seq_index < 0 + or seq_index >= block_tables.shape[0] + or block_tables.shape[1] < block_context_len // block_size + ): + return False + + half_tensors = (query, key, value, key_cache, value_cache) + if any(tensor.dtype != torch.float16 for tensor in half_tensors): + return False + if block_tables.dtype != torch.int32: + return False + tensors = half_tensors + (block_tables,) + if any(not tensor.is_cuda for tensor in tensors): + return False + if any(tensor.device != query.device for tensor in tensors): + return False + if any(not tensor.is_contiguous() for tensor in tensors): + return False + return True + + +def _can_use_corex_fused_paged_prefill( + query: torch.Tensor, + key: torch.Tensor, + value: torch.Tensor, + prefix_key: torch.Tensor, + prefix_value: torch.Tensor, + key_cache: torch.Tensor, + value_cache: torch.Tensor, + block_tables: torch.Tensor, + seq_index: int, + block_context_len: int, + num_q_heads: int, + num_kv_heads: int, + head_dim: int, + gqa_ratio: int, + block_size: int, +) -> bool: + return bool( + _USE_COREX_FUSED_PAGED_PREFILL + and _is_supported_corex_fused_paged_prefill_segment( + query, + key, + value, + prefix_key, + prefix_value, + key_cache, + value_cache, + block_tables, + seq_index, + block_context_len, + num_q_heads, + num_kv_heads, + head_dim, + gqa_ratio, + block_size, + ) + ) + + +def _prefix_context_tile_spans( + block_context_len: int, + prefix_query_len: int, + tile_size: int, +) -> List[Tuple[int, int, int, int]]: + """Map context tiles to block-cache and preceding-query token ranges. + + Each tuple is ``(block_start, block_end, prefix_start, prefix_end)``. + Concatenating both ranges reconstructs one tile in the logical context. + Keeping tiles aligned to absolute token positions makes cold segmented + prefill use the same online-softmax partitions as a warm cached request. + """ + if block_context_len < 0 or prefix_query_len < 0 or tile_size <= 0: + raise ValueError("context lengths must be non-negative and tile_size > 0") + spans = [] + total_context_len = block_context_len + prefix_query_len + for tile_start in range(0, total_context_len, tile_size): + tile_end = min(tile_start + tile_size, total_context_len) + block_start = min(tile_start, block_context_len) + block_end = min(tile_end, block_context_len) + prefix_start = max(0, tile_start - block_context_len) + prefix_end = max(0, tile_end - block_context_len) + spans.append((block_start, block_end, prefix_start, prefix_end)) + return spans @dataclass @@ -74,16 +1305,65 @@ class PagedAttention: k_scale: float, v_scale: float, ) -> None: + global _CACHE_WRITE_LOGGED + flat_slots = slot_mapping.flatten() + if key.shape[0] != value.shape[0]: + raise RuntimeError( + f"key/value token counts differ: {key.shape[0]} != " + f"{value.shape[0]}") + if flat_slots.numel() != key.shape[0]: + raise RuntimeError( + f"slot_mapping has {flat_slots.numel()} entries for " + f"{key.shape[0]} KV tokens") + if key_cache.shape[0] != value_cache.shape[0]: + raise RuntimeError( + "key/value cache block counts differ before cache write: " + f"{key_cache.shape[0]} != {value_cache.shape[0]}") + + if _PAGED_ATTN_DIAGNOSTICS and flat_slots.numel() > 0: + min_slot = int(flat_slots.min().item()) + max_slot = int(flat_slots.max().item()) + max_valid_slot = key_cache.shape[0] * value_cache.shape[3] - 1 + if min_slot < -1 or max_slot > max_valid_slot: + raise RuntimeError( + f"slot_mapping range [{min_slot}, {max_slot}] outside " + f"[-1, {max_valid_slot}]") + + if _PAGED_ATTN_DIAGNOSTICS and not _CACHE_WRITE_LOGGED: + print( + "[BI100 PAGED_ATTN] cache_write " + f"pid={os.getpid()} rank={os.environ.get('RANK', '?')} " + f"local_rank={os.environ.get('LOCAL_RANK', '?')} " + f"key={tuple(key.shape)} value={tuple(value.shape)} " + f"slots={tuple(flat_slots.shape)} " + f"key_cache={tuple(key_cache.shape)} " + f"value_cache={tuple(value_cache.shape)}", + file=sys.stderr, + flush=True, + ) + _CACHE_WRITE_LOGGED = True + ops.reshape_and_cache( key, value, key_cache, value_cache, - slot_mapping.flatten(), + flat_slots, kv_cache_dtype, k_scale, v_scale, ) + if _PAGED_ATTN_DIAGNOSTICS: + try: + torch.cuda.synchronize() + except Exception as exc: + print( + "[BI100 PAGED_ATTN] cache_write_sync_failed " + f"pid={os.getpid()} error={type(exc).__name__}: {exc}", + file=sys.stderr, + flush=True, + ) + raise @staticmethod def _forward_decode_pytorch( @@ -123,20 +1403,32 @@ class PagedAttention: num_blocks = (seq_len + block_size - 1) // block_size blk_ids = block_tables[i, :num_blocks] - # Gather K: [kv_h, head_dim, seq_len] fp32 — no GQA expansion. - # With kv_h=1 and seq_len=100K this is 98 MB vs 586 MB if expanded. - k_t = (key_cache[blk_ids] - .permute(0, 3, 1, 2, 4) - .contiguous() - .view(-1, num_kv_heads, head_dim))[:seq_len] \ - .permute(1, 2, 0).contiguous().float() # [kv_h, d, seq_len] - - # Gather V: [kv_h, seq_len, head_dim] fp32 - v_t = (value_cache[blk_ids] - .permute(0, 3, 1, 2) - .contiguous() - .view(-1, num_kv_heads, head_dim))[:seq_len] \ - .permute(1, 0, 2).contiguous().float() # [kv_h, seq_len, d] + use_corex_gather = ( + _USE_COREX_PAGED_KV_GATHER + and query.dtype == torch.float16 + and key_cache.dtype == torch.float16 + and value_cache.dtype == torch.float16 + and block_tables.dtype == torch.int32 + and key_cache.is_contiguous() + and value_cache.is_contiguous() + and blk_ids.is_contiguous()) + if use_corex_gather: + k_t, v_t = _corex_paged_kv_gather.gather( + key_cache, value_cache, blk_ids, seq_len) + else: + # Gather K: [kv_h, head_dim, seq_len] fp32 without GQA + # expansion. The CoreX path above fuses these layout copies + # and FP16-to-FP32 conversions into one kernel. + k_t = (key_cache[blk_ids] + .permute(0, 3, 1, 2, 4) + .contiguous() + .view(-1, num_kv_heads, head_dim))[:seq_len] \ + .permute(1, 2, 0).contiguous().float() + v_t = (value_cache[blk_ids] + .permute(0, 3, 1, 2) + .contiguous() + .view(-1, num_kv_heads, head_dim))[:seq_len] \ + .permute(1, 0, 2).contiguous().float() # Reshape Q for lazy GQA: [kv_h, gqa_ratio, 1, d] q_grouped = (query[i].float() @@ -164,7 +1456,44 @@ class PagedAttention: # paged_attention_v1 on BI-V100 fails for long contexts. # Route on actual sequence length (seq_lens.max()), not the max_seq_len # parameter which is inflated to max_model_len in CUDA graph mode. - _PYTORCH_DECODE_THRESHOLD = 32768 + _PYTORCH_DECODE_THRESHOLD = _PYTORCH_DECODE_THRESHOLD + _FORCE_PAGED_ATTN_V2 = _FORCE_PAGED_ATTN_V2 + + @staticmethod + def _should_use_paged_attention_v1( + max_seq_len: int, + max_num_partitions: int, + num_seqs: int, + num_heads: int, + ) -> bool: + if PagedAttention._FORCE_PAGED_ATTN_V2: + return False + # Keep the stable BI100 default: V1 is used unless long-context decode + # has already routed to the PyTorch fallback above. + return True + + @staticmethod + def _validate_prefix_block_table( + seq_index: int, + num_ctx_blocks: int, + block_table_width: int, + ctx_len: int, + ) -> int: + if num_ctx_blocks <= block_table_width: + return num_ctx_blocks + msg = ( + f"seq {seq_index}: num_ctx_blocks={num_ctx_blocks} " + f"> block_tables.shape[1]={block_table_width}, " + f"ctx_len={ctx_len}. Block table is undersized; " + "refusing to truncate context because attention would be incorrect.") + if env_bool("BI100_ALLOW_PREFIX_GUARD_CAP", False): + print( + "[paged_attn RISK] BI100_ALLOW_PREFIX_GUARD_CAP=1; " + f"{msg} Debug cap is enabled and may corrupt output.", + file=sys.stderr, + flush=True) + return block_table_width + raise RuntimeError(msg) @staticmethod def forward_decode( @@ -175,7 +1504,7 @@ class PagedAttention: seq_lens: torch.Tensor, max_seq_len: int, kv_cache_dtype: str, - num_kv_heads: int, + head_mapping: torch.Tensor, scale: float, alibi_slopes: Optional[torch.Tensor], k_scale: float, @@ -187,9 +1516,80 @@ class PagedAttention: blocksparse_head_sliding_step: int = 0, ) -> torch.Tensor: actual_max = int(seq_lens.max().item()) if seq_lens.numel() > 0 else max_seq_len + block_size = value_cache.shape[3] + num_seqs, num_heads, head_size = query.shape + if key_cache.shape[1] != value_cache.shape[1]: + raise RuntimeError( + "key/value cache KV-head counts differ: " + f"{key_cache.shape[1]} != {value_cache.shape[1]}") + if head_mapping.numel() != num_heads: + raise RuntimeError( + f"head_mapping has {head_mapping.numel()} entries for " + f"{num_heads} query heads") + required_blocks = _validate_decode_layout( + num_seqs=num_seqs, + seq_lens_count=seq_lens.numel(), + block_table_rows=block_tables.shape[0], + block_table_width=block_tables.shape[1], + actual_max=actual_max, + block_size=block_size, + physical_key_blocks=key_cache.shape[0], + physical_value_blocks=value_cache.shape[0], + num_heads=num_heads, + num_kv_heads=key_cache.shape[1], + ) + if actual_max > max_seq_len: + raise RuntimeError( + f"actual decode length {actual_max} exceeds max_seq_len " + f"{max_seq_len}") + if actual_max > PagedAttention._PYTORCH_DECODE_THRESHOLD: - return PagedAttention._forward_decode_pytorch( - query, key_cache, value_cache, block_tables, seq_lens, scale) + path = ("pytorch_corex_gather" if _USE_COREX_PAGED_KV_GATHER + else "pytorch") + else: + path = "native_v1" + log_key = (path, None) + if (_DECODE_LOG_INTERVAL > 0 and + actual_max % _DECODE_LOG_INTERVAL == 0): + log_key = (path, actual_max) + if log_key not in _DECODE_DISPATCH_LOGGED: + print( + "[BI100 PAGED_ATTN] decode_dispatch " + f"pid={os.getpid()} rank={os.environ.get('RANK', '?')} " + f"local_rank={os.environ.get('LOCAL_RANK', '?')} " + f"path={path} actual_max={actual_max} " + f"max_seq_len={max_seq_len} query={tuple(query.shape)} " + f"key_cache={tuple(key_cache.shape)} " + f"value_cache={tuple(value_cache.shape)} " + f"block_tables={tuple(block_tables.shape)} " + f"required_blocks={required_blocks} " + f"threshold={PagedAttention._PYTORCH_DECODE_THRESHOLD}", + file=sys.stderr, + flush=True, + ) + _DECODE_DISPATCH_LOGGED.add(log_key) + + if _PAGED_ATTN_DIAGNOSTICS: + for seq_index in range(num_seqs): + seq_len = int(seq_lens[seq_index].item()) + if seq_len <= 0: + raise RuntimeError( + f"seq {seq_index}: decode length must be > 0, got {seq_len}") + seq_blocks = (seq_len + block_size - 1) // block_size + block_ids = block_tables[seq_index, :seq_blocks] + min_block = int(block_ids.min().item()) + max_block = int(block_ids.max().item()) + if min_block < 0 or max_block >= key_cache.shape[0]: + raise RuntimeError( + f"seq {seq_index}: physical block range " + f"[{min_block}, {max_block}] outside " + f"[0, {key_cache.shape[0] - 1}]") + + if actual_max > PagedAttention._PYTORCH_DECODE_THRESHOLD: + with bi100_timer("paged_attn.decode_pytorch"): + return PagedAttention._forward_decode_pytorch( + query, key_cache, value_cache, block_tables, seq_lens, + scale) if blocksparse_vert_stride is not None and blocksparse_vert_stride > 1: # use blocksparse paged attention @@ -200,8 +1600,6 @@ class PagedAttention: f"{block_size=} used in block_tables.") output = torch.empty_like(query) - block_size = value_cache.shape[3] - num_seqs, num_heads, head_size = query.shape max_num_partitions = ((max_seq_len + _PARTITION_SIZE - 1) // _PARTITION_SIZE) # NOTE(woosuk): We use a simple heuristic to decide whether to use @@ -211,9 +1609,8 @@ class PagedAttention: # to parallelize. # TODO(woosuk): Tune this heuristic. # For context len > 8192, use V2 kernel to avoid shared memory shortage. - use_v1 = (max_seq_len <= 8192 - and (max_num_partitions == 1 or num_seqs * num_heads > 512)) - use_v1 = True + use_v1 = PagedAttention._should_use_paged_attention_v1( + max_seq_len, max_num_partitions, num_seqs, num_heads) if use_v1: # Run PagedAttention V1. ops.paged_attention_v1( @@ -221,7 +1618,7 @@ class PagedAttention: query, key_cache, value_cache, - num_kv_heads, + head_mapping, scale, block_tables, seq_lens, @@ -251,7 +1648,7 @@ class PagedAttention: query, key_cache, value_cache, - num_kv_heads, + head_mapping, scale, block_tables, seq_lens, @@ -286,15 +1683,49 @@ class PagedAttention: sliding_window: Optional[int], k_scale: float, v_scale: float, + is_causal_decoder: bool = False, ) -> torch.Tensor: # NOTE: The Triton context_attention_fwd kernel hangs on Iluvatar # BI-V100 hardware (same class of issue as cudnnFlashAttnForward). # Use a pure-PyTorch fallback that reads the paged KV cache directly. + supported_request = bool( + (_USE_COREX_FUSED_PAGED_PREFILL + or _ACTIVATION_CAPTURE_ENABLED) + and _is_supported_corex_fused_paged_prefill_request( + kv_cache_dtype, + max_query_len, + query.shape[0], + alibi_slopes, + sliding_window, + k_scale, + v_scale, + is_causal_decoder, + )) + fused_request_eligible = bool( + _USE_COREX_FUSED_PAGED_PREFILL and supported_request) + capture_request_eligible = bool( + _ACTIVATION_CAPTURE_ENABLED and supported_request) + _log_corex_fused_prefill_diagnostic( + "request", + eligible=fused_request_eligible, + use_native=_USE_COREX_FUSED_PAGED_PREFILL, + causal=is_causal_decoder, + kv_cache_dtype=kv_cache_dtype, + max_query_len=max_query_len, + total_query_len=query.shape[0], + tile_blocks=_PREFIX_BLOCKS_PER_TILE, + alibi_none=alibi_slopes is None, + sliding_window=sliding_window, + k_scale=k_scale, + v_scale=v_scale, + ) return PagedAttention._forward_prefix_pytorch( query, key, value, key_cache, value_cache, block_tables, query_start_loc, seq_lens_tensor, context_lens, + fused_request_eligible=fused_request_eligible, + capture_request_eligible=capture_request_eligible, ) @staticmethod @@ -308,12 +1739,15 @@ class PagedAttention: query_start_loc: torch.Tensor, seq_lens_tensor: torch.Tensor, context_lens: torch.Tensor, + fused_request_eligible: bool = False, + capture_request_eligible: bool = False, ) -> torch.Tensor: """Pure-PyTorch prefix-attention with K-tiling (Flash-Attention online softmax). Memory complexity: O(q_len), independent of kv_len. - With chunked prefill (q_len ≤ max_num_batched_tokens = 4096) peak - per layer ≈ 96 MB regardless of context length. + Query segments end at the same strict block boundary used by prefix + caching. This keeps online-softmax reduction partitions identical when + an otherwise equivalent request reuses that prefix. Algorithm: Flash Attention online softmax. Q is reshaped once to [kv_h, gqa, q_len, d] (24 MB) and held for all @@ -340,11 +1774,12 @@ class PagedAttention: context_lens : [batch_size] tokens already in KV cache """ try: + profile_name = "paged_attn.prefix_pytorch" # Paged-block tiles for context phase. # tile_sz = _BLOCKS_PER_TILE × block_size (e.g. 16×16 = 256 tokens). # Score tensor [kv_h, gqa, q_len, tile_sz] fp32 = 24 MB per tile. # Same tile size reused for the current-chunk phase. - _BLOCKS_PER_TILE = 32 + _BLOCKS_PER_TILE = _PREFIX_BLOCKS_PER_TILE batch_size = seq_lens_tensor.shape[0] num_q_heads = query.shape[1] @@ -356,7 +1791,54 @@ class PagedAttention: scale = head_dim ** -0.5 orig_dtype = query.dtype output = torch.empty_like(query) - dev = query.device + + if fused_request_eligible or capture_request_eligible: + query_start_count = query_start_loc.numel() + seq_lens_count = seq_lens_tensor.numel() + context_lens_count = context_lens.numel() + query_start_first = ( + int(query_start_loc[0].item()) + if query_start_count == 2 else -1) + query_start_last = ( + int(query_start_loc[1].item()) + if query_start_count == 2 else -1) + seq_len = ( + int(seq_lens_tensor[0].item()) + if seq_lens_count == 1 else -1) + context_len = ( + int(context_lens[0].item()) + if context_lens_count == 1 else -1) + metadata_eligible = ( + _is_single_sequence_fused_prefill_metadata( + batch_size=batch_size, + block_table_rows=block_tables.shape[0], + query_start_count=query_start_count, + query_start_first=query_start_first, + query_start_last=query_start_last, + seq_lens_count=seq_lens_count, + seq_len=seq_len, + context_lens_count=context_lens_count, + context_len=context_len, + total_query_len=query.shape[0], + )) + _log_corex_fused_prefill_diagnostic( + "metadata", + eligible=metadata_eligible, + batch_size=batch_size, + block_table_rows=block_tables.shape[0], + query_start_count=query_start_count, + query_start_first=query_start_first, + query_start_last=query_start_last, + seq_lens_count=seq_lens_count, + seq_len=seq_len, + context_lens_count=context_lens_count, + context_len=context_len, + total_query_len=query.shape[0], + ) + fused_request_eligible = bool( + fused_request_eligible and metadata_eligible) + capture_request_eligible = bool( + capture_request_eligible and metadata_eligible) for i in range(batch_size): ctx_len = int(context_lens[i].item()) @@ -364,157 +1846,48 @@ class PagedAttention: q_end = int(query_start_loc[i + 1].item()) q_len = q_end - q_start - q_i = query[q_start:q_end] # [q_len, q_h, d] - k_i = key [q_start:q_end] # [q_len, kv_h, d] - v_i = value[q_start:q_end] - - # Q reshaped and scaled once; held for all K-tiles. - # [kv_h, gqa, q_len, d] fp32 — 24 MB for q_len=4096, d=256 - q_seq = (q_i.permute(1, 0, 2) - .float() - .view(num_kv_heads, gqa_ratio, q_len, head_dim) - .mul_(scale)) - - # Flash-Attention online-softmax accumulators. - # m, l : [kv_h, gqa, q_len] fp32 — <0.1 MB - # o : [kv_h, gqa, q_len, d] fp32 — 24 MB - m = torch.full((num_kv_heads, gqa_ratio, q_len), - float('-inf'), dtype=torch.float32, device=dev) - l = torch.zeros_like(m) - o = torch.zeros((num_kv_heads, gqa_ratio, q_len, head_dim), - dtype=torch.float32, device=dev) - - # -------------------------------------------------------------- - # Phase 1 — context tokens (positions 0 … ctx_len-1). - # - # Every context key has absolute position < ctx_len; every - # query has position ≥ ctx_len. k_pos < q_pos is always True - # → no causal mask needed for pure context tiles. - # -------------------------------------------------------------- - if ctx_len > 0: - num_ctx_blocks = (ctx_len + block_size - 1) // block_size - # Safety: if block_tables is too narrow this indicates a - # prefix_cache_hit + chunked-prefill bug in model_runner.py - # (Case 1 leaves prefix_cache_hit=True but block_table is - # only computed_block_nums, not the full context blocks). - # patch_model_runner.py fixes the root cause; this guard - # prevents a zero-dim amax() crash if it still slips through. - if num_ctx_blocks > block_tables.shape[1]: - print( - f"[paged_attn WARNING] seq {i}: num_ctx_blocks={num_ctx_blocks} " - f"> block_tables.shape[1]={block_tables.shape[1]}, ctx_len={ctx_len}. " - "Block table is undersized (prefix_cache_hit bug). " - "Capping context to available blocks — attention may be incorrect.", - file=sys.stderr, flush=True) - num_ctx_blocks = block_tables.shape[1] - for tile_blk in range(0, num_ctx_blocks, _BLOCKS_PER_TILE): - blk_end = min(tile_blk + _BLOCKS_PER_TILE, num_ctx_blocks) - blk_ids = block_tables[i, tile_blk:blk_end] - - # Gather K/V for this tile. - # key_cache [blk_ids]: [n, kv_h, d//x, blk_sz, x] - # value_cache[blk_ids]: [n, kv_h, d, blk_sz] - k_tile = (key_cache[blk_ids] - .permute(0, 3, 1, 2, 4) - .contiguous() - .view(-1, num_kv_heads, head_dim)) - v_tile = (value_cache[blk_ids] - .permute(0, 3, 1, 2) - .contiguous() - .view(-1, num_kv_heads, head_dim)) - - # Trim padding in the last block of the tile. - valid = (min(blk_end * block_size, ctx_len) - - tile_blk * block_size) - k_tile = k_tile[:valid] # [valid, kv_h, d] - v_tile = v_tile[:valid] - - # k_t: [kv_h, 1, d, valid] (broadcast over gqa_ratio) - # v_t: [kv_h, 1, valid, d] - k_t = (k_tile.permute(1, 0, 2) - .unsqueeze(1) - .transpose(-1, -2) - .float()) - v_t = (v_tile.permute(1, 0, 2) - .unsqueeze(1) - .float()) - del k_tile, v_tile - - # Scores: [kv_h, gqa, q_len, valid] - s = torch.matmul(q_seq, k_t) - del k_t - # No causal mask: all context keys precede all queries. - - # Online softmax update — Flash-Attention Algorithm 1. - # exp_s = s - new_max (in-place exp after del s) - m_blk = s.amax(dim=-1) - m_new = torch.maximum(m, m_blk) - exp_s = s - m_new.unsqueeze(-1) - del s - exp_s.exp_() - corr = torch.exp(m - m_new) - m.copy_(m_new) - del m_blk, m_new - l.mul_(corr).add_(exp_s.sum(dim=-1)) - o.mul_(corr.unsqueeze(-1)).add_( - torch.matmul(exp_s, v_t)) - del exp_s, v_t, corr - - # -------------------------------------------------------------- - # Phase 2 — current-chunk tokens (positions ctx_len … ctx_len+q_len-1). - # - # Causal mask: query at relative position j sees key at relative - # position k only when k ≤ j. Tiles of tile_sz tokens each. - # -------------------------------------------------------------- - for kc_start in range(0, q_len, tile_sz): - kc_end = min(kc_start + tile_sz, q_len) - kc_len = kc_end - kc_start - - k_blk = k_i[kc_start:kc_end] # [kc_len, kv_h, d] - v_blk = v_i[kc_start:kc_end] - - k_t = (k_blk.permute(1, 0, 2) - .unsqueeze(1) - .transpose(-1, -2) - .float()) # [kv_h, 1, d, kc_len] - v_t = (v_blk.permute(1, 0, 2) - .unsqueeze(1) - .float()) # [kv_h, 1, kc_len, d] - - s = torch.matmul(q_seq, k_t) # [kv_h, gqa, q_len, kc_len] - del k_t - - # Causal mask: key at (kc_start+k) must not exceed query j. - k_rel = torch.arange(kc_start, kc_end, device=dev) - q_rel = torch.arange(q_len, device=dev) - mask = k_rel.unsqueeze(0) > q_rel.unsqueeze(1) # [q_len, kc_len] - s.masked_fill_(mask.unsqueeze(0).unsqueeze(0), float('-inf')) - del mask, k_rel, q_rel - - # Online softmax update (identical to context phase). - m_blk = s.amax(dim=-1) - m_new = torch.maximum(m, m_blk) - exp_s = s - m_new.unsqueeze(-1) - del s - exp_s.exp_() - corr = torch.exp(m - m_new) - m.copy_(m_new) - del m_blk, m_new - l.mul_(corr).add_(exp_s.sum(dim=-1)) - o.mul_(corr.unsqueeze(-1)).add_( - torch.matmul(exp_s, v_t)) - del exp_s, v_t, corr - - # -------------------------------------------------------------- - # Finalize: normalize running output by normalization factor. - # o: [kv_h, gqa, q_len, d] → [q_len, q_h, d] - # -------------------------------------------------------------- - o.div_(l.unsqueeze(-1)) - output[q_start:q_end] = ( - o.view(num_q_heads, q_len, head_dim) - .permute(1, 0, 2) - .to(orig_dtype) - ) + for seg_start, seg_end, seg_ctx_len in ( + _strict_prefix_query_segments( + ctx_len, q_len, block_size)): + absolute_start = q_start + seg_start + absolute_end = q_start + seg_end + bi100_profile_count( + "paged_attn.prefix_dispatch", + path="pytorch", + query_len=seg_end - seg_start, + request_query_len=q_len, + context_len=seg_ctx_len, + block_size=block_size, + query_heads=num_q_heads, + kv_heads=num_kv_heads, + head_dim=head_dim, + ) + with bi100_timer(profile_name): + output[absolute_start:absolute_end] = ( + PagedAttention._forward_prefix_segment_pytorch( + query[absolute_start:absolute_end], + key[absolute_start:absolute_end], + value[absolute_start:absolute_end], + key[q_start:absolute_start], + value[q_start:absolute_start], + key_cache, + value_cache, + block_tables, + i, + ctx_len, + num_q_heads, + num_kv_heads, + head_dim, + gqa_ratio, + block_size, + tile_sz, + scale, + orig_dtype, + fused_request_eligible=( + fused_request_eligible), + capture_request_eligible=( + capture_request_eligible), + )) except Exception as e: print(f"[paged_attn ERROR] {type(e).__name__}: {e}", @@ -523,6 +1896,345 @@ class PagedAttention: raise return output + @staticmethod + def _forward_prefix_segment_pytorch( + query: torch.Tensor, + key: torch.Tensor, + value: torch.Tensor, + prefix_key: torch.Tensor, + prefix_value: torch.Tensor, + key_cache: torch.Tensor, + value_cache: torch.Tensor, + block_tables: torch.Tensor, + seq_index: int, + block_context_len: int, + num_q_heads: int, + num_kv_heads: int, + head_dim: int, + gqa_ratio: int, + block_size: int, + tile_sz: int, + scale: float, + orig_dtype, + fused_request_eligible: bool = False, + return_fp32: bool = False, + capture_request_eligible: bool = False, + ) -> torch.Tensor: + """Run online-softmax attention for one strict-prefix query segment.""" + q_len = query.shape[0] + supported_segment = ( + _is_supported_corex_fused_paged_prefill_segment( + query, + key, + value, + prefix_key, + prefix_value, + key_cache, + value_cache, + block_tables, + seq_index, + block_context_len, + num_q_heads, + num_kv_heads, + head_dim, + gqa_ratio, + block_size, + )) + segment_eligible = bool( + fused_request_eligible + and _USE_COREX_FUSED_PAGED_PREFILL + and supported_segment) + capture_segment_eligible = bool( + capture_request_eligible + and _ACTIVATION_CAPTURE_ENABLED + and supported_segment) + _log_corex_fused_prefill_diagnostic( + "segment", + eligible=segment_eligible, + request_eligible=fused_request_eligible, + query_shape=tuple(query.shape), + key_shape=tuple(key.shape), + value_shape=tuple(value.shape), + prefix_key_shape=tuple(prefix_key.shape), + prefix_value_shape=tuple(prefix_value.shape), + key_cache_shape=tuple(key_cache.shape), + value_cache_shape=tuple(value_cache.shape), + block_table_shape=tuple(block_tables.shape), + context_len=block_context_len, + seq_index=seq_index, + q_dtype=query.dtype, + block_table_dtype=block_tables.dtype, + query_cuda=query.is_cuda, + query_contiguous=query.is_contiguous(), + key_contiguous=key.is_contiguous(), + value_contiguous=value.is_contiguous(), + block_table_contiguous=block_tables.is_contiguous(), + heads=f"{num_q_heads}/{num_kv_heads}/{head_dim}", + gqa_ratio=gqa_ratio, + block_size=block_size, + ) + if segment_eligible or capture_segment_eligible: + required_blocks = block_context_len // block_size + active_block_table = block_tables[ + seq_index, :required_blocks].contiguous() + if capture_segment_eligible: + reservation = _reserve_activation_capture(block_context_len) + if reservation is not None: + _capture_fused_prefill_activation( + reservation, + query, + key, + value, + key_cache, + value_cache, + active_block_table, + block_context_len, + scale, + ) + if segment_eligible: + shadow_index = _reserve_fused_prefill_shadow( + query, + block_context_len, + num_q_heads, + num_kv_heads, + head_dim, + block_size, + ) + try: + fused_result = _corex_fused_paged_prefill.forward( + query, + key, + value, + key_cache, + value_cache, + active_block_table, + block_context_len, + scale, + ) + except Exception as exc: + if shadow_index is not None: + _finish_fused_prefill_shadow( + shadow_index, + status="invalid", + error_stage="candidate-execution", + error_type=type(exc).__name__, + ) + raise + if ( + not isinstance(fused_result, (list, tuple)) + or len(fused_result) != 2 + ): + if shadow_index is not None: + _finish_fused_prefill_shadow( + shadow_index, + status="invalid", + error_stage="candidate-contract", + error_type="InvalidResult", + ) + raise RuntimeError( + "corex fused paged-prefill returned an invalid result") + fused_output = fused_result[0] + if ( + tuple(fused_output.shape) != tuple(query.shape) + or fused_output.dtype != query.dtype + or fused_output.device != query.device + ): + if shadow_index is not None: + _finish_fused_prefill_shadow( + shadow_index, + status="invalid", + error_stage="candidate-contract", + error_type="InvalidOutput", + ) + raise RuntimeError( + "corex fused paged-prefill returned an invalid output") + if shadow_index is not None: + try: + reference_result = ( + PagedAttention._forward_prefix_segment_pytorch( + query, + key, + value, + prefix_key, + prefix_value, + key_cache, + value_cache, + block_tables, + seq_index, + block_context_len, + num_q_heads, + num_kv_heads, + head_dim, + gqa_ratio, + block_size, + tile_sz, + scale, + orig_dtype, + fused_request_eligible=False, + capture_request_eligible=False, + return_fp32=( + _FUSED_PREFILL_SHADOW_NUMERIC_MODE + == "calibrated"), + )) + reference_fp32 = ( + reference_result + if _FUSED_PREFILL_SHADOW_NUMERIC_MODE + == "calibrated" + else None + ) + reference_output = ( + reference_result.to(orig_dtype) + if reference_fp32 is not None + else reference_result + ) + shadow_metrics = _compare_fused_prefill_shadow_outputs( + fused_output, + reference_output, + reference_fp32, + ) + except Exception as exc: + _finish_fused_prefill_shadow( + shadow_index, + status="invalid", + error_stage="reference-execution", + error_type=type(exc).__name__, + ) + raise + _finish_fused_prefill_shadow( + shadow_index, + **shadow_metrics, + ) + if ( + shadow_metrics["status"] != "pass" + and ( + _FUSED_PREFILL_SHADOW_FAILURE_ACTION == "raise" + or shadow_metrics["status"] == "invalid" + or shadow_metrics.get("candidate_finite") is not True + or shadow_metrics.get("reference_finite") is not True + ) + ): + raise RuntimeError( + "corex fused paged-prefill failed the real-activation " + "shadow-reference numerical gate") + log_key = "corex_split4" + if log_key not in _PREFIX_DISPATCH_LOGGED: + print( + "[BI100 PAGED_ATTN] prefix_dispatch " + f"pid={os.getpid()} rank={os.environ.get('RANK', '?')} " + f"local_rank={os.environ.get('LOCAL_RANK', '?')} " + f"path={log_key} context_len={block_context_len} " + f"query_len={q_len} required_blocks={required_blocks}", + file=sys.stderr, + flush=True, + ) + _PREFIX_DISPATCH_LOGGED.add(log_key) + return fused_output + + dev = query.device + q_seq = (query.permute(1, 0, 2) + .float() + .view(num_kv_heads, gqa_ratio, q_len, head_dim) + .mul(scale)) + m = torch.full((num_kv_heads, gqa_ratio, q_len), + float('-inf'), dtype=torch.float32, device=dev) + l = torch.zeros_like(m) + o = torch.zeros((num_kv_heads, gqa_ratio, q_len, head_dim), + dtype=torch.float32, device=dev) + + if block_context_len > 0: + num_ctx_blocks = (block_context_len + block_size - 1) // block_size + num_ctx_blocks = PagedAttention._validate_prefix_block_table( + seq_index, num_ctx_blocks, block_tables.shape[1], + block_context_len) + + for block_start, block_end, prefix_start, prefix_end in ( + _prefix_context_tile_spans( + block_context_len, prefix_key.shape[0], tile_sz)): + k_parts = [] + v_parts = [] + if block_end > block_start: + first_block = block_start // block_size + last_block = (block_end + block_size - 1) // block_size + blk_ids = block_tables[seq_index, first_block:last_block] + k_blocks = (key_cache[blk_ids] + .permute(0, 3, 1, 2, 4) + .contiguous() + .view(-1, num_kv_heads, head_dim)) + v_blocks = (value_cache[blk_ids] + .permute(0, 3, 1, 2) + .contiguous() + .view(-1, num_kv_heads, head_dim)) + offset = block_start - first_block * block_size + length = block_end - block_start + k_parts.append(k_blocks[offset:offset + length]) + v_parts.append(v_blocks[offset:offset + length]) + if prefix_end > prefix_start: + k_parts.append(prefix_key[prefix_start:prefix_end]) + v_parts.append(prefix_value[prefix_start:prefix_end]) + k_context = (k_parts[0] if len(k_parts) == 1 + else torch.cat(k_parts, dim=0)) + v_context = (v_parts[0] if len(v_parts) == 1 + else torch.cat(v_parts, dim=0)) + k_t = (k_context.permute(1, 0, 2) + .unsqueeze(1).transpose(-1, -2).float()) + v_t = v_context.permute(1, 0, 2).unsqueeze(1).float() + PagedAttention._update_online_softmax(q_seq, k_t, v_t, m, l, o) + + for key_start in range(0, q_len, tile_sz): + key_end = min(key_start + tile_sz, q_len) + k_t = (key[key_start:key_end].permute(1, 0, 2) + .unsqueeze(1).transpose(-1, -2).float()) + v_t = (value[key_start:key_end].permute(1, 0, 2) + .unsqueeze(1).float()) + scores = torch.matmul(q_seq, k_t) + del k_t + key_positions = torch.arange(key_start, key_end, device=dev) + query_positions = torch.arange(q_len, device=dev) + mask = key_positions.unsqueeze(0) > query_positions.unsqueeze(1) + scores.masked_fill_(mask.unsqueeze(0).unsqueeze(0), float('-inf')) + del mask, key_positions, query_positions + PagedAttention._update_online_softmax_from_scores( + scores, v_t, m, l, o) + + o.div_(l.unsqueeze(-1)) + output = ( + o.view(num_q_heads, q_len, head_dim) + .permute(1, 0, 2) + ) + return output if return_fp32 else output.to(orig_dtype) + + @staticmethod + def _update_online_softmax( + query: torch.Tensor, + key: torch.Tensor, + value: torch.Tensor, + running_max: torch.Tensor, + running_sum: torch.Tensor, + running_output: torch.Tensor, + ) -> None: + scores = torch.matmul(query, key) + PagedAttention._update_online_softmax_from_scores( + scores, value, running_max, running_sum, running_output) + + @staticmethod + def _update_online_softmax_from_scores( + scores: torch.Tensor, + value: torch.Tensor, + running_max: torch.Tensor, + running_sum: torch.Tensor, + running_output: torch.Tensor, + ) -> None: + block_max = scores.amax(dim=-1) + new_max = torch.maximum(running_max, block_max) + exp_scores = scores - new_max.unsqueeze(-1) + del scores + exp_scores.exp_() + correction = torch.exp(running_max - new_max) + running_max.copy_(new_max) + running_sum.mul_(correction).add_(exp_scores.sum(dim=-1)) + running_output.mul_(correction.unsqueeze(-1)).add_( + torch.matmul(exp_scores, value)) + @staticmethod def swap_blocks( src_kv_cache: torch.Tensor, diff --git a/qwen3_6_scripts/patch_block_major_cache_engine.py b/qwen3_6_scripts/patch_block_major_cache_engine.py new file mode 100644 index 00000000..74b8a7c1 --- /dev/null +++ b/qwen3_6_scripts/patch_block_major_cache_engine.py @@ -0,0 +1,91 @@ +from patch_utils import package_root, replace_once + + +CACHE_ENGINE = package_root("vllm") / "worker" / "cache_engine.py" + +IMPORT_ANCHOR = """\ +from vllm.logger import init_logger +""" + +IMPORT_REPLACEMENT = """\ +from vllm.block_major_kv_cache import ( + BlockMajorCpuKVCache, + block_major_cpu_kv_enabled, +) +from vllm.logger import init_logger +""" + +ALLOCATION_ANCHOR = """\ + self.gpu_cache = self._allocate_kv_cache( + self.num_gpu_blocks, self.device_config.device_type) + self.cpu_cache = self._allocate_kv_cache(self.num_cpu_blocks, "cpu") +""" + +ALLOCATION_REPLACEMENT = """\ + self.gpu_cache = self._allocate_kv_cache( + self.num_gpu_blocks, self.device_config.device_type) + self._bi100_block_major_cpu_kv = None + if block_major_cpu_kv_enabled(): + self._bi100_block_major_cpu_kv = BlockMajorCpuKVCache( + self.gpu_cache, + self.num_cpu_blocks, + pin_memory=is_pin_memory_available(), + ) + self.cpu_cache = self._bi100_block_major_cpu_kv.layer_views + else: + self.cpu_cache = self._allocate_kv_cache( + self.num_cpu_blocks, "cpu") +""" + +SWAP_ANCHOR = """\ + def swap_in(self, src_to_dst: torch.Tensor) -> None: + for i in range(self.num_attention_layers): + self.attn_backend.swap_blocks(self.cpu_cache[i], self.gpu_cache[i], + src_to_dst) + + def swap_out(self, src_to_dst: torch.Tensor) -> None: + for i in range(self.num_attention_layers): + self.attn_backend.swap_blocks(self.gpu_cache[i], self.cpu_cache[i], + src_to_dst) +""" + +SWAP_REPLACEMENT = """\ + def swap_in(self, src_to_dst: torch.Tensor) -> None: + if self._bi100_block_major_cpu_kv is not None: + self._bi100_block_major_cpu_kv.swap_in(src_to_dst) + return + for i in range(self.num_attention_layers): + self.attn_backend.swap_blocks(self.cpu_cache[i], self.gpu_cache[i], + src_to_dst) + + def swap_out(self, src_to_dst: torch.Tensor) -> None: + if self._bi100_block_major_cpu_kv is not None: + self._bi100_block_major_cpu_kv.swap_out(src_to_dst) + return + for i in range(self.num_attention_layers): + self.attn_backend.swap_blocks(self.gpu_cache[i], self.cpu_cache[i], + src_to_dst) +""" + + +replace_once( + CACHE_ENGINE, + IMPORT_ANCHOR, + IMPORT_REPLACEMENT, + required=True, + already_contains="from vllm.block_major_kv_cache import", +) +replace_once( + CACHE_ENGINE, + ALLOCATION_ANCHOR, + ALLOCATION_REPLACEMENT, + required=True, + already_contains="self._bi100_block_major_cpu_kv = None", +) +replace_once( + CACHE_ENGINE, + SWAP_ANCHOR, + SWAP_REPLACEMENT, + required=True, + already_contains="self._bi100_block_major_cpu_kv.swap_in", +) diff --git a/qwen3_6_scripts/patch_block_major_worker_capacity.py b/qwen3_6_scripts/patch_block_major_worker_capacity.py new file mode 100644 index 00000000..599e194e --- /dev/null +++ b/qwen3_6_scripts/patch_block_major_worker_capacity.py @@ -0,0 +1,46 @@ +from patch_utils import package_root, replace_once + + +WORKER = package_root("vllm") / "worker" / "worker.py" + +IMPORT_ANCHOR = """\ +from vllm.logger import init_logger +""" + +IMPORT_REPLACEMENT = """\ +from vllm.block_major_kv_cache import reserve_block_major_gpu_blocks +from vllm.logger import init_logger +""" + +CAPACITY_ANCHOR = """\ + num_gpu_blocks = max(num_gpu_blocks, 0) + num_cpu_blocks = max(num_cpu_blocks, 0) +""" + +CAPACITY_REPLACEMENT = """\ + num_gpu_blocks = reserve_block_major_gpu_blocks( + num_gpu_blocks, cache_block_size) + num_gpu_blocks = max(num_gpu_blocks, 0) + num_cpu_blocks = max(num_cpu_blocks, 0) +""" + + +replace_once( + WORKER, + IMPORT_ANCHOR, + IMPORT_REPLACEMENT, + required=True, + already_contains=( + "from vllm.block_major_kv_cache import " + "reserve_block_major_gpu_blocks" + ), +) +replace_once( + WORKER, + CAPACITY_ANCHOR, + CAPACITY_REPLACEMENT, + required=True, + already_contains=( + "num_gpu_blocks = reserve_block_major_gpu_blocks(" + ), +) diff --git a/qwen3_6_scripts/patch_block_manager_cache_trace.py b/qwen3_6_scripts/patch_block_manager_cache_trace.py new file mode 100644 index 00000000..cc1937d7 --- /dev/null +++ b/qwen3_6_scripts/patch_block_manager_cache_trace.py @@ -0,0 +1,210 @@ +"""Install the optional BI100 prefix-cache diagnostic trace.""" +from patch_utils import package_root, replace_once, replace_one_of + +VLLM_ROOT = package_root("vllm") +TARGET = VLLM_ROOT / "core" / "block_manager_v2.py" +OUTPUTS_TARGET = VLLM_ROOT / "outputs.py" + +HELPER = ''' + def _bi100_capture_cache_trace(self, seq_group, seq, block_table) -> None: + if os.getenv("BI100_CACHE_TRACE", "0") != "1": + return + + session = getattr(self, "_bi100_trace_session", None) + if session is None: + session = hashlib.sha256(os.urandom(16)).hexdigest()[:16] + self._bi100_trace_session = session + + self._bi100_trace_ordinal = getattr(self, "_bi100_trace_ordinal", 0) + 1 + request_id_sha256 = hashlib.sha256( + str(seq_group.request_id).encode("utf-8")).hexdigest()[:16] + + prompt_tokens = len(seq.get_token_ids()) + requests = getattr(self, "_bi100_trace_requests", None) + if requests is None: + requests = {} + self._bi100_trace_requests = requests + + requests[seq.seq_id] = { + "version": 4, + "trace_session_sha256": session, + "ordinal": self._bi100_trace_ordinal, + "request_id_sha256": request_id_sha256, + "prompt_tokens": prompt_tokens, + "prompt_allocated_blocks": ( + (prompt_tokens + self.block_size - 1) // self.block_size + ), + "block_size": self.block_size, + "capacity_blocks": self.num_total_gpu_blocks, + } + setattr(seq_group, "_bi100_cache_trace_seq_id", seq.seq_id) + setattr(seq_group, "_bi100_cache_trace_emit", + self._bi100_emit_cache_trace) + + def _bi100_update_cache_trace( + self, seq, raw_kv_hit_blocks, restore_key, capture_actions, + evict_keys, policy) -> None: + if os.getenv("BI100_CACHE_TRACE", "0") != "1": + return + requests = getattr(self, "_bi100_trace_requests", None) + if not requests or seq.seq_id not in requests: + return + record = requests[seq.seq_id] + record["gdn_policy"] = policy + if "initial_raw_kv_contiguous_hit_blocks" not in record: + record["initial_raw_kv_contiguous_hit_blocks"] = max( + 0, int(raw_kv_hit_blocks)) + record["gdn_restore_digest_base64"] = ( + base64.b64encode(restore_key[1]).decode("ascii") + if restore_key is not None else None) + record["raw_kv_contiguous_hit_blocks"] = max( + int(raw_kv_hit_blocks), + int(record.get("raw_kv_contiguous_hit_blocks", 0))) + effective_blocks = int(restore_key[0]) if restore_key is not None else 0 + record["effective_gdn_hit_blocks"] = max( + effective_blocks, int(record.get("effective_gdn_hit_blocks", 0))) + + admissions = record.setdefault("gdn_admissions", []) + for key, reason in capture_actions: + admissions.append({ + "block_count": int(key[0]), + "digest_base64": base64.b64encode(key[1]).decode("ascii"), + "reason": str(reason), + }) + evictions = record.setdefault("gdn_evictions", []) + for key in evict_keys: + evictions.append({ + "block_count": int(key[0]), + "digest_base64": base64.b64encode(key[1]).decode("ascii"), + "reason": "capacity_lru", + }) + + def _bi100_finalize_cache_trace(self, seq, block_table) -> None: + if os.getenv("BI100_CACHE_TRACE", "0") != "1": + return + + requests = getattr(self, "_bi100_trace_requests", None) + if not requests: + return + + record = requests.get(seq.seq_id) + if record is None: + return + + total_tokens = len(seq.get_token_ids()) + block_hashes = block_table.get_content_hashes() + for block_hash in block_hashes: + if not isinstance(block_hash, bytes) or len(block_hash) != 32: + raise RuntimeError( + "BI100 cache trace requires 32-byte content hashes") + full_blocks = len(block_hashes) + record.update({ + "total_tokens": total_tokens, + "allocated_blocks": ( + (total_tokens + self.block_size - 1) // self.block_size + ), + "full_blocks": full_blocks, + "hash_encoding": "sha256_base64", + "block_hashes": base64.b64encode(b"".join(block_hashes)).decode("ascii"), + "_finalized": True, + }) + generated_tokens = max(0, total_tokens - record["prompt_tokens"]) + record["generated_tokens"] = generated_tokens + + def _bi100_emit_cache_trace(self, seq_group) -> None: + if os.getenv("BI100_CACHE_TRACE", "0") != "1": + return + seq_id = getattr(seq_group, "_bi100_cache_trace_seq_id", None) + requests = getattr(self, "_bi100_trace_requests", None) + if seq_id is None or not requests: + return + record = requests.pop(seq_id, None) + if record is None: + return + if record.pop("_finalized", False) is not True: + raise RuntimeError( + "BI100 cache trace emitted before block finalization") + + metrics = getattr(seq_group, "metrics", None) + arrival = getattr(metrics, "arrival_time", None) + first_token = getattr(metrics, "first_token_time", None) + finished = getattr(metrics, "finished_time", None) + queue = getattr(metrics, "time_in_queue", None) + cached = getattr(metrics, "num_cached_tokens", None) + if any(value is None for value in ( + arrival, first_token, finished, queue)): + raise RuntimeError( + "BI100 cache trace requires finalized request metrics") + record["ttft_s"] = max(0.0, float(first_token - arrival)) + record["request_latency_s"] = max( + 0.0, float(finished - arrival)) + record["time_in_queue_s"] = max(0.0, float(queue)) + record["observed_effective_cached_tokens"] = max( + 0, int(cached or 0)) + ttft_s = record["ttft_s"] + if ttft_s > 0: + record["observed_input_tps"] = record["prompt_tokens"] / ttft_s + generated_tokens = record["generated_tokens"] + if generated_tokens > 1: + decode_s = finished - first_token + if decode_s > 0: + record["observed_output_tps"] = ( + (generated_tokens - 1) / decode_s) + print("[BI100_CACHE_TRACE] " + json.dumps(record, separators=(",", ":"), + sort_keys=True), flush=True) +''' + + +def main(): + replace_once(TARGET, "from collections.abc import Mapping\n", + "from collections.abc import Mapping\nimport base64\nimport json\nimport os\n", + required=True, already_contains="import base64\n") + replace_once(TARGET, "class BlockSpaceManagerV2(BlockSpaceManager):\n", + "class BlockSpaceManagerV2(BlockSpaceManager):\n" + HELPER, + required=True, already_contains="def _bi100_capture_cache_trace(") + replace_once(TARGET, + " self.block_tables[seq.seq_id] = block_table\n\n # Track seq", + " self.block_tables[seq.seq_id] = block_table\n self._bi100_capture_cache_trace(\n seq_group, seq, block_table)\n\n # Track seq", + required=True, + already_contains="self.block_tables[seq.seq_id] = block_table\n" + " self._bi100_capture_cache_trace(") + replacements = [] + for table_key in ("seq_id", "seq.seq_id"): + prefix = ( + " self._last_access_blocks_tracker." + "update_seq_blocks_last_access(\n" + f" seq_id, self.block_tables[{table_key}]." + "physical_block_ids)\n") + replacements.append(( + prefix + "\n # Untrack seq", + prefix + " self._bi100_finalize_cache_trace(\n" + f" seq, self.block_tables[{table_key}])\n\n" + " # Untrack seq", + )) + replace_one_of( + TARGET, + replacements, + required=True, + already_contains=" self._bi100_finalize_cache_trace(\n" + " seq, self.block_tables[") + replace_once( + OUTPUTS_TARGET, + " seq_group.set_finished_time(finished_time)\n\n" + " init_args = (seq_group.request_id, prompt, prompt_token_ids,\n", + " seq_group.set_finished_time(finished_time)\n" + " if finished_time is not None:\n" + " cache_trace_emit = getattr(\n" + " seq_group, \"_bi100_cache_trace_emit\", None)\n" + " if callable(cache_trace_emit):\n" + " cache_trace_emit(seq_group)\n" + " delattr(seq_group, \"_bi100_cache_trace_emit\")\n" + " delattr(seq_group, \"_bi100_cache_trace_seq_id\")\n\n" + " init_args = (seq_group.request_id, prompt, prompt_token_ids,\n", + required=True, + already_contains="if finished_time is not None:\n" + " cache_trace_emit = getattr(\n", + ) + + +if __name__ == "__main__": + main() diff --git a/qwen3_6_scripts/patch_corex_swap_blocks.py b/qwen3_6_scripts/patch_corex_swap_blocks.py new file mode 100644 index 00000000..0988bffd --- /dev/null +++ b/qwen3_6_scripts/patch_corex_swap_blocks.py @@ -0,0 +1,65 @@ +from patch_utils import package_root, replace_once + + +CUSTOM_OPS = package_root("vllm") / "_custom_ops.py" + +CLEAN_BLOCK = """\ +def swap_blocks(src: torch.Tensor, dst: torch.Tensor, + block_mapping: torch.Tensor) -> None: + ixf_F.swap_blocks(src, dst, block_mapping) +""" + +COMPATIBLE_BLOCK = """\ +def swap_blocks(src: torch.Tensor, dst: torch.Tensor, + block_mapping: torch.Tensor) -> None: + # BI100 CoreX 3.2.3 exposes vllm_swap_blocks, while this vLLM build calls + # the newer swap_blocks name. Normalize the worker's CPU int64 [N, 2] + # tensor only for the legacy public API and fail fast on malformed maps. + native_swap_blocks = getattr(ixf_F, "swap_blocks", None) + if native_swap_blocks is not None: + native_swap_blocks(src, dst, block_mapping) + return + + vendor_swap_blocks = getattr(ixf_F, "vllm_swap_blocks", None) + if vendor_swap_blocks is None: + raise RuntimeError( + "ixformer exposes neither swap_blocks nor vllm_swap_blocks") + + if isinstance(block_mapping, torch.Tensor): + if block_mapping.device.type != "cpu": + raise ValueError("swap block mapping must be a CPU tensor") + if block_mapping.dtype != torch.int64: + raise ValueError("swap block mapping must use torch.int64") + if block_mapping.dim() != 2 or block_mapping.shape[1] != 2: + raise ValueError("swap block mapping must have shape [N, 2]") + pairs = block_mapping.tolist() + elif isinstance(block_mapping, dict): + pairs = list(block_mapping.items()) + else: + raise TypeError("swap block mapping must be a tensor or dict") + + normalized_mapping = {} + destinations = set() + for source, destination in pairs: + source = int(source) + destination = int(destination) + if source < 0 or destination < 0: + raise ValueError("swap block indices must be non-negative") + if source in normalized_mapping: + raise ValueError(f"duplicate swap source block: {source}") + if destination in destinations: + raise ValueError( + f"duplicate swap destination block: {destination}") + normalized_mapping[source] = destination + destinations.add(destination) + vendor_swap_blocks(src, dst, normalized_mapping) +""" + + +replace_once( + CUSTOM_OPS, + CLEAN_BLOCK, + COMPATIBLE_BLOCK, + required=True, + already_contains="BI100 CoreX 3.2.3 exposes vllm_swap_blocks", +) diff --git a/qwen3_6_scripts/patch_executor_startup_debug.py b/qwen3_6_scripts/patch_executor_startup_debug.py new file mode 100644 index 00000000..c554e954 --- /dev/null +++ b/qwen3_6_scripts/patch_executor_startup_debug.py @@ -0,0 +1,61 @@ +from patch_utils import package_root, replace_once + +VLLM_ROOT = package_root("vllm") + +MULTIPROC_GPU_EXECUTOR = VLLM_ROOT / "executor" / "multiproc_gpu_executor.py" +MULTIPROC_WORKER_UTILS = VLLM_ROOT / "executor" / "multiproc_worker_utils.py" + + +def ensure_import_os(path): + text = path.read_text() + if "import os\n" in text: + print(f"[skip] import os already present: {path}") + return + for anchor in ("import time\n", "import signal\n", "import sys\n"): + if anchor in text: + replace_once( + path, + anchor, + anchor + "import os\n", + required=True, + already_contains="import os\n", + ) + return + raise RuntimeError(f"no import anchor found for os in {path}") + + +ensure_import_os(MULTIPROC_GPU_EXECUTOR) +ensure_import_os(MULTIPROC_WORKER_UTILS) + + +replace_once( + MULTIPROC_GPU_EXECUTOR, + """logger = init_logger(__name__)\n""", + """logger = init_logger(__name__)\n\n\ndef _bi100_startup_debug(message: str, *args) -> None:\n if os.getenv(\"BI100_EXECUTOR_STARTUP_DEBUG\") == \"1\":\n logger.info(\"[BI100 startup] \" + message, *args)\n""", + required=True, + already_contains="def _bi100_startup_debug(", +) + +replace_once( + MULTIPROC_GPU_EXECUTOR, + """ self.driver_worker = self._create_worker(\n distributed_init_method=distributed_init_method)\n self._run_workers(\"init_device\")\n self._run_workers(\"load_model\",\n max_concurrent_workers=self.parallel_config.\n max_parallel_loading_workers)\n""", + """ _bi100_startup_debug(\"creating driver worker\")\n self.driver_worker = self._create_worker(\n distributed_init_method=distributed_init_method)\n _bi100_startup_debug(\"created driver worker\")\n _bi100_startup_debug(\"starting init_device\")\n self._run_workers(\"init_device\")\n _bi100_startup_debug(\"finished init_device\")\n _bi100_startup_debug(\"starting load_model\")\n self._run_workers(\"load_model\",\n max_concurrent_workers=self.parallel_config.\n max_parallel_loading_workers)\n _bi100_startup_debug(\"finished load_model\")\n""", + required=True, + already_contains='_bi100_startup_debug("starting init_device")', +) + +replace_once( + MULTIPROC_GPU_EXECUTOR, + """ # Start all remote workers first.\n worker_outputs = [\n worker.execute_method(method, *args, **kwargs)\n for worker in self.workers\n ]\n\n driver_worker_method = getattr(self.driver_worker, method)\n driver_worker_output = driver_worker_method(*args, **kwargs)\n\n # Get the results of the workers.\n return [driver_worker_output\n ] + [output.get() for output in worker_outputs]\n""", + """ _bi100_startup_debug(\"enqueue remote method=%s workers=%d\", method,\n len(self.workers))\n # Start all remote workers first.\n worker_outputs = [\n worker.execute_method(method, *args, **kwargs)\n for worker in self.workers\n ]\n _bi100_startup_debug(\"remote enqueued method=%s\", method)\n\n driver_worker_method = getattr(self.driver_worker, method)\n _bi100_startup_debug(\"driver start method=%s\", method)\n driver_worker_output = driver_worker_method(*args, **kwargs)\n _bi100_startup_debug(\"driver done method=%s\", method)\n\n # Get the results of the workers.\n _bi100_startup_debug(\"waiting remote results method=%s\", method)\n remote_outputs = [output.get() for output in worker_outputs]\n _bi100_startup_debug(\"remote done method=%s\", method)\n return [driver_worker_output] + remote_outputs\n""", + required=True, + already_contains='_bi100_startup_debug("enqueue remote method=%s workers=%d"', +) + +replace_once( + MULTIPROC_WORKER_UTILS, + """ task_id, method, args, kwargs = items\n try:\n executor = getattr(worker, method)\n output = executor(*args, **kwargs)\n except SystemExit:\n""", + """ task_id, method, args, kwargs = items\n if os.getenv(\"BI100_EXECUTOR_STARTUP_DEBUG\") == \"1\":\n logger.info(\"[BI100 worker] start method=%s\", method)\n try:\n executor = getattr(worker, method)\n output = executor(*args, **kwargs)\n if os.getenv(\"BI100_EXECUTOR_STARTUP_DEBUG\") == \"1\":\n logger.info(\"[BI100 worker] done method=%s\", method)\n except SystemExit:\n""", + required=True, + already_contains='logger.info("[BI100 worker] start method=%s", method)', +) diff --git a/qwen3_6_scripts/patch_model_runner.py b/qwen3_6_scripts/patch_model_runner.py index e10ad271..a74f94e1 100644 --- a/qwen3_6_scripts/patch_model_runner.py +++ b/qwen3_6_scripts/patch_model_runner.py @@ -1,46 +1,43 @@ -""" -Fix: prefix_cache_hit stays True for chunked-prefill chunk 2+ even when past cache. +"""Patch vLLM 0.6.3 prefix-cache and MRoPE chunk alignment bugs.""" -Root cause: - model_runner.py _compute_for_prefix_cache_hit has three cases: - Case 1: prefix_cache_len <= context_len → "already past cache, do normal" - Case 2: context_len < prefix_cache_len < seq_len → partial hit, correct - Case 3: seq_len <= prefix_cache_len → full hit, reduce to 1 token +from __future__ import annotations - Case 1 does nothing (leaves prefix_cache_hit = True). Then in utils.py: - if inter_data.prefix_cache_hit: - block_table = computed_block_nums ← ONLY the original prefix blocks! +import pathlib - But context_len > prefix_cache_len means chunk 1 tokens (between prefix_cache_len - and context_len) are ALSO in KV cache and need to be in block_table. - block_table = computed_block_nums misses all chunk-1 blocks. +from patch_utils import package_root, replace_once - In _forward_prefix_pytorch: - num_ctx_blocks = ceil(context_len / block_size) # e.g. 268 - block_tables.shape[1] = len(computed_block_nums) # e.g. 12 <-- too small! - At tile_blk >= 12: blk_ids is empty → k_t shape [..., 0] → amax crash. -Fix: - Set prefix_cache_hit = False for Case 1, so utils.py falls through to: - elif chunked_prefill_enabled: - block_table = block_tables[seq_id] ← full block table (prefix + chunk1) -""" +HELPER_ANCHOR = """\ +logger = init_logger(__name__) -import re -import sys +LORA_WARMUP_RANK = 8""" -CANDIDATE_PATHS = [ - "/usr/local/corex/lib64/python3/dist-packages/vllm/worker/model_runner.py", - "/usr/local/corex/lib/python3/dist-packages/vllm/worker/model_runner.py", -] +HELPER_REPLACEMENT = """\ +logger = init_logger(__name__) -OLD_BLOCK = """\ + +def _slice_mrope_positions(positions, start, stop, expected_len): + if positions is None or len(positions) != 3: + raise RuntimeError("MRoPE positions must contain three axes") + sliced = [axis[start:stop] for axis in positions] + lengths = [len(axis) for axis in sliced] + if lengths != [expected_len] * 3: + raise RuntimeError( + "MRoPE/input token length mismatch after chunk alignment: " + f"positions={lengths}, input_tokens={expected_len}, " + f"slice=({start}, {stop})") + return sliced + + +LORA_WARMUP_RANK = 8""" + +PREFIX_PAST_ANCHOR = """\ if prefix_cache_len <= context_len: # We already passed the cache hit region, # so do normal computation. pass""" -NEW_BLOCK = """\ +PREFIX_PAST_REPLACEMENT = """\ if prefix_cache_len <= context_len: # We already passed the cache hit region, # so do normal computation. @@ -51,28 +48,361 @@ NEW_BLOCK = """\ # causing an empty blk_ids slice and a zero-dim amax() crash. inter_data.prefix_cache_hit = False""" -import os +PARTIAL_HIT_ANCHOR = """\ + inter_data.input_positions[seq_idx] = inter_data.input_positions[ + seq_idx][uncomputed_start:] + context_len = prefix_cache_len -patched = False -for path in CANDIDATE_PATHS: - if not os.path.exists(path): - continue - with open(path, "r") as f: - src = f.read() - if OLD_BLOCK not in src: - if NEW_BLOCK in src: - print(f"[patch_model_runner] already patched: {path}") - patched = True - break - print(f"[patch_model_runner] WARNING: expected block not found in {path}, skipping") - continue - patched_src = src.replace(OLD_BLOCK, NEW_BLOCK, 1) - with open(path, "w") as f: - f.write(patched_src) - print(f"[patch_model_runner] patched Case-1 prefix_cache_hit fix in: {path}") - patched = True - break + inter_data.context_lens[seq_idx] = context_len + inter_data.query_lens[ + seq_idx] = inter_data.seq_lens[seq_idx] - context_len""" -if not patched: - print("[patch_model_runner] ERROR: could not find model_runner.py at any known path", file=sys.stderr) - sys.exit(1) +PARTIAL_HIT_REPLACEMENT = """\ + inter_data.input_positions[seq_idx] = inter_data.input_positions[ + seq_idx][uncomputed_start:] + context_len = prefix_cache_len + + inter_data.context_lens[seq_idx] = context_len + inter_data.query_lens[ + seq_idx] = inter_data.seq_lens[seq_idx] - context_len + if inter_data.mrope_input_positions is not None: + positions = inter_data.mrope_input_positions[seq_idx] + if positions is not None: + inter_data.mrope_input_positions[seq_idx] = \\ + _slice_mrope_positions( + positions, uncomputed_start, None, + inter_data.query_lens[seq_idx])""" + +FULL_HIT_ANCHOR = """\ + inter_data.input_positions[seq_idx] = inter_data.input_positions[ + seq_idx][-1:] + inter_data.query_lens[seq_idx] = 1 + inter_data.context_lens[seq_idx] = inter_data.seq_lens[seq_idx] - 1""" + +FULL_HIT_REPLACEMENT = """\ + inter_data.input_positions[seq_idx] = inter_data.input_positions[ + seq_idx][-1:] + inter_data.query_lens[seq_idx] = 1 + inter_data.context_lens[seq_idx] = inter_data.seq_lens[seq_idx] - 1 + if inter_data.mrope_input_positions is not None: + positions = inter_data.mrope_input_positions[seq_idx] + if positions is not None: + inter_data.mrope_input_positions[seq_idx] = \\ + _slice_mrope_positions(positions, -1, None, 1)""" + +MULTIMODAL_MROPE_ANCHOR = """\ + mrope_input_positions, mrope_position_delta = \\ + MRotaryEmbedding.get_input_positions( + token_ids, + image_grid_thw=image_grid_thw, + video_grid_thw=video_grid_thw, + image_token_id=hf_config.image_token_id, + video_token_id=hf_config.video_token_id, + vision_start_token_id=hf_config.vision_start_token_id, + vision_end_token_id=hf_config.vision_end_token_id, + spatial_merge_size=hf_config.vision_config. + spatial_merge_size, + context_len=inter_data.context_lens[seq_idx], + ) + + seq_data.mrope_position_delta = mrope_position_delta + inter_data.mrope_input_positions[ + seq_idx] = mrope_input_positions""" + +MULTIMODAL_MROPE_REPLACEMENT = """\ + # vLLM 0.6.3 returns positions through the end of token_ids, + # while chunked prefill sends only [context_len:seq_len]. + # Compute the full MRoPE map once so the delta remains tied to + # the complete request, then select exactly the physical query. + mrope_input_positions, mrope_position_delta = \\ + MRotaryEmbedding.get_input_positions( + token_ids, + image_grid_thw=image_grid_thw, + video_grid_thw=video_grid_thw, + image_token_id=hf_config.image_token_id, + video_token_id=hf_config.video_token_id, + vision_start_token_id=hf_config.vision_start_token_id, + vision_end_token_id=hf_config.vision_end_token_id, + spatial_merge_size=hf_config.vision_config. + spatial_merge_size, + context_len=0, + ) + mrope_input_positions = _slice_mrope_positions( + mrope_input_positions, + inter_data.context_lens[seq_idx], + inter_data.seq_lens[seq_idx], + len(inter_data.input_tokens[seq_idx])) + + seq_data.mrope_position_delta = mrope_position_delta + inter_data.mrope_input_positions[ + seq_idx] = mrope_input_positions""" + +MODEL_INPUT_FIELDS_ANCHOR = """\ + multi_modal_kwargs: Optional[BatchedTensorInputs] = None + request_ids_to_seq_ids: Optional[Dict[str, List[int]]] = None""" + +MODEL_INPUT_FIELDS_REPLACEMENT = """\ + multi_modal_kwargs: Optional[BatchedTensorInputs] = None + # BI100 scheduler-owned GDN prefix-cache actions. These plain Python + # objects are included in the multiprocess model-input broadcast. + gdn_restore_key: Optional[Tuple[int, bytes]] = None + gdn_capture_points: Optional[List[Tuple[int, Tuple[int, bytes]]]] = None + gdn_evict_keys: Optional[List[Tuple[int, bytes]]] = None + gdn_segment_offsets: Optional[List[int]] = None + request_ids_to_seq_ids: Optional[Dict[str, List[int]]] = None""" + +BASE_BROADCAST_ANCHOR = """\ + \"multi_modal_kwargs\": self.multi_modal_kwargs, + \"prompt_adapter_mapping\": self.prompt_adapter_mapping, + \"prompt_adapter_requests\": self.prompt_adapter_requests, + \"virtual_engine\": self.virtual_engine, + \"request_ids_to_seq_ids\": self.request_ids_to_seq_ids, + \"finished_requests_ids\": self.finished_requests_ids, + } + _add_attn_metadata_broadcastable_dict(tensor_dict, self.attn_metadata) + return tensor_dict + + @classmethod""" + +BASE_BROADCAST_REPLACEMENT = """\ + \"multi_modal_kwargs\": self.multi_modal_kwargs, + \"gdn_restore_key\": self.gdn_restore_key, + \"gdn_capture_points\": self.gdn_capture_points, + \"gdn_evict_keys\": self.gdn_evict_keys, + \"gdn_segment_offsets\": self.gdn_segment_offsets, + \"prompt_adapter_mapping\": self.prompt_adapter_mapping, + \"prompt_adapter_requests\": self.prompt_adapter_requests, + \"virtual_engine\": self.virtual_engine, + \"request_ids_to_seq_ids\": self.request_ids_to_seq_ids, + \"finished_requests_ids\": self.finished_requests_ids, + } + _add_attn_metadata_broadcastable_dict(tensor_dict, self.attn_metadata) + return tensor_dict + + @classmethod""" + +SAMPLING_BROADCAST_ANCHOR = """\ + \"multi_modal_kwargs\": self.multi_modal_kwargs, + \"prompt_adapter_mapping\": self.prompt_adapter_mapping, + \"prompt_adapter_requests\": self.prompt_adapter_requests, + \"virtual_engine\": self.virtual_engine, + \"request_ids_to_seq_ids\": self.request_ids_to_seq_ids, + \"finished_requests_ids\": self.finished_requests_ids, + } + _add_attn_metadata_broadcastable_dict(tensor_dict, self.attn_metadata) + _add_sampling_metadata_broadcastable_dict(tensor_dict, + self.sampling_metadata)""" + +SAMPLING_BROADCAST_REPLACEMENT = """\ + \"multi_modal_kwargs\": self.multi_modal_kwargs, + \"gdn_restore_key\": self.gdn_restore_key, + \"gdn_capture_points\": self.gdn_capture_points, + \"gdn_evict_keys\": self.gdn_evict_keys, + \"gdn_segment_offsets\": self.gdn_segment_offsets, + \"prompt_adapter_mapping\": self.prompt_adapter_mapping, + \"prompt_adapter_requests\": self.prompt_adapter_requests, + \"virtual_engine\": self.virtual_engine, + \"request_ids_to_seq_ids\": self.request_ids_to_seq_ids, + \"finished_requests_ids\": self.finished_requests_ids, + } + _add_attn_metadata_broadcastable_dict(tensor_dict, self.attn_metadata) + _add_sampling_metadata_broadcastable_dict(tensor_dict, + self.sampling_metadata)""" + +BUILDER_INIT_ANCHOR = """\ + self.finished_requests_ids = finished_requests_ids + self.decode_only = True + + # Intermediate data""" + +BUILDER_INIT_REPLACEMENT = """\ + self.finished_requests_ids = finished_requests_ids + self.decode_only = True + self.gdn_restore_key = None + self.gdn_capture_points = None + self.gdn_evict_keys = None + self.gdn_segment_offsets = None + + # Intermediate data""" + +ADD_SEQ_GROUP_ANCHOR = """\ + def add_seq_group(self, seq_group_metadata: SequenceGroupMetadata): + \"\"\"Add a sequence group to the builder.\"\"\" + seq_ids = seq_group_metadata.seq_data.keys()""" + +ADD_SEQ_GROUP_REPLACEMENT = """\ + def add_seq_group(self, seq_group_metadata: SequenceGroupMetadata): + \"\"\"Add a sequence group to the builder.\"\"\" + gdn_actions = ( + seq_group_metadata.gdn_restore_key, + seq_group_metadata.gdn_capture_points, + seq_group_metadata.gdn_evict_keys, + seq_group_metadata.gdn_segment_offsets, + ) + if any(value is not None for value in gdn_actions): + if not seq_group_metadata.is_prompt: + raise RuntimeError(\"GDN prefix-cache actions require prefill\") + if any(value is not None for value in ( + self.gdn_restore_key, self.gdn_capture_points, + self.gdn_evict_keys, self.gdn_segment_offsets)): + raise RuntimeError( + \"only one GDN prefix-cache action group is supported\") + (self.gdn_restore_key, self.gdn_capture_points, + self.gdn_evict_keys, self.gdn_segment_offsets) = gdn_actions + seq_ids = seq_group_metadata.seq_data.keys()""" + +BUILD_RESULT_ANCHOR = """\ + lora_mapping=lora_mapping, + lora_requests=lora_requests, + multi_modal_kwargs=multi_modal_kwargs, + request_ids_to_seq_ids=request_ids_to_seq_ids,""" + +BUILD_RESULT_REPLACEMENT = """\ + lora_mapping=lora_mapping, + lora_requests=lora_requests, + multi_modal_kwargs=multi_modal_kwargs, + gdn_restore_key=self.gdn_restore_key, + gdn_capture_points=self.gdn_capture_points, + gdn_evict_keys=self.gdn_evict_keys, + gdn_segment_offsets=self.gdn_segment_offsets, + request_ids_to_seq_ids=request_ids_to_seq_ids,""" + +EXECUTE_KWARGS_ANCHOR = """\ + seqlen_agnostic_kwargs = { + \"finished_requests_ids\": model_input.finished_requests_ids, + \"request_ids_to_seq_ids\": model_input.request_ids_to_seq_ids, + } if self.has_inner_state else {} + if (self.observability_config is not None""" + +EXECUTE_KWARGS_REPLACEMENT = """\ + seqlen_agnostic_kwargs = { + \"finished_requests_ids\": model_input.finished_requests_ids, + \"request_ids_to_seq_ids\": model_input.request_ids_to_seq_ids, + } if self.has_inner_state else {} + gdn_prefix_kwargs = {} + if model_input.gdn_restore_key is not None: + gdn_prefix_kwargs[\"gdn_restore_key\"] = model_input.gdn_restore_key + if model_input.gdn_capture_points is not None: + gdn_prefix_kwargs[\"gdn_capture_points\"] = ( + model_input.gdn_capture_points) + if model_input.gdn_evict_keys is not None: + gdn_prefix_kwargs[\"gdn_evict_keys\"] = model_input.gdn_evict_keys + if model_input.gdn_segment_offsets is not None: + gdn_prefix_kwargs[\"gdn_segment_offsets\"] = ( + model_input.gdn_segment_offsets) + if (self.observability_config is not None""" + +MODEL_CALL_ANCHOR = """\ + **MultiModalInputs.as_kwargs(multi_modal_kwargs, + device=self.device), + **seqlen_agnostic_kwargs)""" + +MODEL_CALL_REPLACEMENT = """\ + **MultiModalInputs.as_kwargs(multi_modal_kwargs, + device=self.device), + **seqlen_agnostic_kwargs, + **gdn_prefix_kwargs)""" + +PROFILE_KV_LAYERS_ANCHOR = """\ + num_layers = self.model_config.get_num_layers(self.parallel_config)""" + +PROFILE_KV_LAYERS_REPLACEMENT = """\ + num_layers = self.model_config.get_num_attention_layers( + self.parallel_config)""" + + +def patch_model_runner(model_runner: pathlib.Path) -> None: + replace_once( + model_runner, + HELPER_ANCHOR, + HELPER_REPLACEMENT, + required=True, + already_contains="def _slice_mrope_positions(", + ) + replace_once( + model_runner, + PREFIX_PAST_ANCHOR, + PREFIX_PAST_REPLACEMENT, + required=True, + already_contains="Must clear prefix_cache_hit so _add_seq_group", + ) + replace_once( + model_runner, + PARTIAL_HIT_ANCHOR, + PARTIAL_HIT_REPLACEMENT, + required=True, + already_contains="positions, uncomputed_start, None,", + ) + replace_once( + model_runner, + FULL_HIT_ANCHOR, + FULL_HIT_REPLACEMENT, + required=True, + already_contains="_slice_mrope_positions(positions, -1, None, 1)", + ) + replace_once( + model_runner, + MULTIMODAL_MROPE_ANCHOR, + MULTIMODAL_MROPE_REPLACEMENT, + required=True, + already_contains="Compute the full MRoPE map once", + ) + replace_once( + model_runner, + MODEL_INPUT_FIELDS_ANCHOR, + MODEL_INPUT_FIELDS_REPLACEMENT, + already_contains="gdn_restore_key: Optional[Tuple[int, bytes]]", + ) + replace_once( + model_runner, + BASE_BROADCAST_ANCHOR, + BASE_BROADCAST_REPLACEMENT, + already_contains=BASE_BROADCAST_REPLACEMENT, + ) + replace_once( + model_runner, + SAMPLING_BROADCAST_ANCHOR, + SAMPLING_BROADCAST_REPLACEMENT, + already_contains=SAMPLING_BROADCAST_REPLACEMENT, + ) + replace_once( + model_runner, + BUILDER_INIT_ANCHOR, + BUILDER_INIT_REPLACEMENT, + already_contains="self.gdn_restore_key = None", + ) + replace_once( + model_runner, + ADD_SEQ_GROUP_ANCHOR, + ADD_SEQ_GROUP_REPLACEMENT, + already_contains="gdn_actions = (", + ) + replace_once( + model_runner, + BUILD_RESULT_ANCHOR, + BUILD_RESULT_REPLACEMENT, + already_contains="gdn_restore_key=self.gdn_restore_key", + ) + replace_once( + model_runner, + EXECUTE_KWARGS_ANCHOR, + EXECUTE_KWARGS_REPLACEMENT, + already_contains="gdn_prefix_kwargs = {}", + ) + replace_once( + model_runner, + MODEL_CALL_ANCHOR, + MODEL_CALL_REPLACEMENT, + already_contains="**gdn_prefix_kwargs)", + ) + replace_once( + model_runner, + PROFILE_KV_LAYERS_ANCHOR, + PROFILE_KV_LAYERS_REPLACEMENT, + required=True, + already_contains=PROFILE_KV_LAYERS_REPLACEMENT, + ) + + +if __name__ == "__main__": + patch_model_runner(package_root("vllm") / "worker" / "model_runner.py") diff --git a/qwen3_6_scripts/patch_ops.sh b/qwen3_6_scripts/patch_ops.sh index a7fc5714..587d663c 100755 --- a/qwen3_6_scripts/patch_ops.sh +++ b/qwen3_6_scripts/patch_ops.sh @@ -1,191 +1,247 @@ -#!/bin/bash -# ========================================================================== -# PATCH_OPS.SH v2 — Align with comp 168 strategy +#!/usr/bin/env bash +# BI-V100 patch script for Qwen3.6-35B-A3B (Qwen3_5 MoE architecture) # -# COMP 168 PROOF (dockerrizhi.txt 07-23 lines 310-397): -# corex_gdn.py:56 → dlopen libcorex_gdn.so ✅ -# corex_gdn.py:228 → GDN prefill fused ✅ -# corex_gdn.py:138 → GDN decode fused ✅ -# corex_moe.py:339 → MoE prefill: expert-grouped-wmma ✅ -# corex_moe.py:249 → MoE decode fused ✅ -# corex_fa2.py:333 → FA2 packed prefill ✅ -# corex_fa2.py:507 → FA2 paged chunked prefill ✅ -# corex_fa2.py:225 → FA2 paged decode ✅ +# Triton situation on BI-V100: +# - Standard Triton 2.3.1 is already present in the image. +# - HAS_TRITON = False (hardcoded in vendor vllm), but Triton is still used +# for TP-mode cache management (custom_cache_manager / libentry). +# - The vendor's triton_utils/__init__.py, custom_cache_manager.py, libentry.py +# are already correct for standard Triton 2.3.1 — do NOT overwrite them. +# - DO NOT install BI-V150 corex Triton 2.1.0 (pkgs/triton): that causes +# GPU hang on BI-V100 because the Triton CUDA PTX kernels are incompatible. + +# Recommended server start command for TP=4 support 256K, needs chunked prefill +# CUDA_VISIBLE_DEVICES="4,5,6,7" VLLM_ENGINE_ITERATION_TIMEOUT_S=3600 python3 -m vllm.entrypoints.openai.api_server \ +# --model /workspace/models/Qwen3.6-35B-A3B --port 1111 --served-model-name llm \ +# --max-model-len 262144 --trust-remote-code -tp 4 --gpu-memory-utilization 0.90 \ +# --max-num-seqs 1 --disable-log-requests --disable-frontend-multiprocessing \ +# --max-num-batched-tokens 8192 --enable-chunked-prefill --enable-prefix-caching \ +# --max-seq-len-to-capture 32768 --enable-auto-tool-choice \ +# --tool-call-parser qwen3_coder --reasoning-parser qwen3 # -# ALL 3 corex modules are IN THE BASE IMAGE and work correctly. -# Our Sub508 failed because we OVERWROTE qwen3_5.py, breaking the call chain. -# -# STRATEGY: DO NOT TOUCH model layer. Only deploy: -# 1. transformers config (Qwen3_5Config) -# 2. serving layer (protocol/serving_chat/api_server/chat_utils/tool_parser/reasoning) -# 3. ix_bridge.so (fills ixf_F.vllm_moe_topk_softmax gap if base _custom_ops hits it) -# 4. _custom_ops.py patch (make topk_softmax use ix_bridge instead of crashing) -# ========================================================================== +# With prefix caching (GDN align-mode, requires chunked prefill): +# CUDA_VISIBLE_DEVICES="4,5,6,7" VLLM_ENGINE_ITERATION_TIMEOUT_S=3600 python3 -m vllm.entrypoints.openai.api_server \ +# --model /workspace/models/Qwen3.6-35B-A3B --port 1111 --served-model-name llm \ +# --max-model-len 262144 --trust-remote-code -tp 4 --gpu-memory-utilization 0.90 \ +# --max-num-seqs 1 --disable-log-requests --disable-frontend-multiprocessing \ +# --max-num-batched-tokens 8192 --enable-chunked-prefill --enable-prefix-caching \ +# --max-seq-len-to-capture 32768 --enable-auto-tool-choice \ +# --tool-call-parser qwen3_coder --reasoning-parser qwen3 -cd "$(dirname "$0")" -echo "[patch_ops.v2] START — comp 168 aligned strategy" +set -euo pipefail -VLLM="" -for P in /usr/local/corex/lib/python3/dist-packages/vllm \ - /usr/local/corex/lib64/python3/dist-packages/vllm; do - [ -d "$P" ] && VLLM="$P" && echo "[patch_ops] Found vllm at: $VLLM" && break -done -[ -z "$VLLM" ] && echo "[patch_ops] ERROR: vllm not found" && exit 1 +build_stage() { printf '[BI100 BUILD] %s\n' "$1" >&2; } +require_file() { + local path=$1 + [[ -f "$path" ]] || { + printf 'required patch source is missing: %s\n' "$path" >&2 + exit 2 + } +} +install_patch_file() { + local source=$1 + local target=$2 -# ---- PROBE ---- -echo "[probe] === Base image state ===" -_QW="$VLLM/model_executor/models/qwen3_5.py" -[ -f "$_QW" ] && echo "[probe] qwen3_5.py: $(wc -c < "$_QW") bytes, $(wc -l < "$_QW") lines" || echo "[probe] qwen3_5.py: MISSING" -for m in corex_gdn.py corex_moe.py corex_fa2.py; do - _F="$VLLM/model_executor/models/$m" - [ -f "$_F" ] && echo "[probe] $m: $(wc -c < "$_F") bytes" || echo "[probe] $m: MISSING" -done -ls -la /usr/local/corex/lib64/libcorex_*.so 2>/dev/null || echo "[probe] no libcorex_*.so" -echo "[probe] ===========================" - -# Find secondary vllm path for mirroring -VLLM2="" -for P in /usr/local/corex/lib/python3/dist-packages/vllm \ - /usr/local/corex/lib64/python3/dist-packages/vllm; do - [ -d "$P" ] && [ "$P" != "$VLLM" ] && VLLM2="$P" && break -done - -# Helper: deploy to both vllm paths -deploy_both() { - local src="$1" dst="$2" - cp "$src" "$VLLM/$dst" 2>/dev/null || true - [ -n "$VLLM2" ] && cp "$src" "$VLLM2/$dst" 2>/dev/null || true + require_file "$source" + mkdir -p "$(dirname "$target")" + install -m 0644 "$source" "$target" } -# =========================================================== -# 1. Transformers config (Qwen3_5Config support) -# =========================================================== -TMODELS="" -for P in /usr/local/lib/python3.10/site-packages/transformers/models \ - /usr/local/corex/lib/python3/dist-packages/transformers/models; do - [ -d "$P" ] && TMODELS="$P" && break -done -if [ -n "$TMODELS" ]; then - pip install transformers==4.55.3 -i https://pypi.tuna.tsinghua.edu.cn/simple --timeout 30 2>&1 || true - apt-get update -qq && apt-get install -y -qq ninja-build 2>&1 || true - cp -r ./qwen3_5 "$TMODELS/" 2>/dev/null || true - cp -r ./qwen3_5_moe "$TMODELS/" 2>/dev/null || true - python3 ./patch_transformers_qwen3_5.py 2>&1 || true - echo "[patch_ops] transformers config deployed" +build_stage "patch script entered" + +build_stage "checking offline transformers dependency" +# --- transformers: Qwen3_5 tokenizer / model files -------------------------- +TRANSFORMERS_REQUIRED_VERSION="4.55.3" +if ! python3 - "$TRANSFORMERS_REQUIRED_VERSION" <<'PY' +import importlib.metadata +import sys + +required = sys.argv[1] +try: + installed = importlib.metadata.version("transformers") +except importlib.metadata.PackageNotFoundError: + raise SystemExit(1) +raise SystemExit(0 if installed == required else 1) +PY +then + WHEEL_DIR="./wheels" + if ! ls "${WHEEL_DIR}/transformers-${TRANSFORMERS_REQUIRED_VERSION}"*.whl >/dev/null 2>&1; then + echo "transformers ${TRANSFORMERS_REQUIRED_VERSION} is required, but no offline wheel was found in ${WHEEL_DIR}" >&2 + exit 2 + fi + python3 -m pip install --no-index --no-deps --find-links="${WHEEL_DIR}" \ + "transformers==${TRANSFORMERS_REQUIRED_VERSION}" fi -# =========================================================== -# 2. MODEL LAYER — CONDITIONAL deployment -# If base has qwen3_5.py > 1000 bytes → DO NOT OVERWRITE -# This is the comp 168 strategy. -# =========================================================== -_QW_SIZE=0 -[ -f "$_QW" ] && _QW_SIZE=$(wc -c < "$_QW") +python3 - "$TRANSFORMERS_REQUIRED_VERSION" <<'PY' +import importlib.metadata +import sys -if [ "$_QW_SIZE" -gt 1000 ]; then - echo "[patch_ops] *** BASE IMAGE HAS qwen3_5.py (${_QW_SIZE} bytes) — KEEPING IT ***" - echo "[patch_ops] *** This is the comp 168 strategy: don't break corex_* call chain ***" - - # Only add registry entry if missing - if ! grep -q "Qwen3_5ForCausalLM" "$VLLM/model_executor/models/registry.py" 2>/dev/null; then - cp ./registry.py "$VLLM/model_executor/models/registry.py" 2>/dev/null && \ - echo "[patch_ops] registry.py deployed (was missing Qwen3_5)" - [ -n "$VLLM2" ] && cp ./registry.py "$VLLM2/model_executor/models/registry.py" 2>/dev/null || true - fi -else - echo "[patch_ops] *** BASE IMAGE MISSING qwen3_5.py — deploying ours ***" - deploy_both ./qwen3_5.py "model_executor/models/qwen3_5.py" - deploy_both ./registry.py "model_executor/models/registry.py" - deploy_both ./mamba_cache.py "model_executor/models/mamba_cache.py" - - # Only deploy corex modules if base doesn't have them - for m in corex_gdn.py corex_moe.py corex_fa2.py; do - if [ ! -f "$VLLM/model_executor/models/$m" ]; then - deploy_both "/workspace/ex_engine/python/$m" "model_executor/models/$m" - echo "[patch_ops] deployed $m (was MISSING)" - fi - done - - # flash_qla_sm70 (only if we deployed our qwen3_5.py) - _FLASH_SRC="/workspace/qwen3_6_scripts/flash_qla_sm70" - if [ -d "$_FLASH_SRC" ]; then - for _VPATH in "$VLLM" "$VLLM2"; do - [ -z "$_VPATH" ] && continue - cp -r "$_FLASH_SRC" "$_VPATH/model_executor/models/flash_qla_sm70" 2>/dev/null || true - done - echo "[patch_ops] flash_qla_sm70 deployed" - fi -fi +required = sys.argv[1] +installed = importlib.metadata.version("transformers") +if installed != required: + raise SystemExit( + f"transformers version mismatch: expected {required}, got {installed}") +print(f"[ok] transformers {installed}") +PY -# =========================================================== -# 3. SERVING LAYER — always deploy (comp 168 also used custom serving) -# =========================================================== -mkdir -p "$VLLM/entrypoints/openai/tool_parsers" 2>/dev/null || true -[ -n "$VLLM2" ] && mkdir -p "$VLLM2/entrypoints/openai/tool_parsers" 2>/dev/null || true +build_stage "discovering Python package roots" +python3 - <<'PY' > /tmp/qwen36_patch_paths.env +from patch_utils import package_root, shell_env_line -deploy_both ./protocol.py "entrypoints/openai/protocol.py" -deploy_both ./cli_args.py "entrypoints/openai/cli_args.py" -deploy_both ./serving_chat.py "entrypoints/openai/serving_chat.py" -deploy_both ./api_server.py "entrypoints/openai/api_server.py" -deploy_both ./chat_utils.py "entrypoints/chat_utils.py" -deploy_both ./qwen3coder_tool_parser.py "entrypoints/openai/tool_parsers/qwen3coder_tool_parser.py" -deploy_both ./tool_parsers_init.py "entrypoints/openai/tool_parsers/__init__.py" -python3 ./patch_vllm_tool_parser.py 2>&1 || true -cp -r ./reasoning "$VLLM/" 2>/dev/null || true -[ -n "$VLLM2" ] && cp -r ./reasoning "$VLLM2/" 2>/dev/null || true -echo "[patch_ops] serving layer deployed" +print(shell_env_line("VLLM_ROOT", package_root("vllm"))) +print(shell_env_line("TRANSFORMERS_ROOT", package_root("transformers"))) +PY +source /tmp/qwen36_patch_paths.env -# =========================================================== -# 4. ix_bridge.so — ONLY PURPOSE: fill ixf_F.vllm_moe_topk_softmax gap -# Even comp 168 had this issue — the base _custom_ops.py tries to call -# ixf_F.vllm_moe_topk_softmax which doesn't exist. -# BUT comp 168's corex_moe.py bypasses _custom_ops entirely. -# So ix_bridge is only needed if base qwen3_5.py path hits _custom_ops. -# =========================================================== -_SITE="/usr/local/corex/lib/python3/dist-packages" -if [ -d "$_SITE" ]; then - _EX_DST="$_SITE/ex_engine" - mkdir -p "$_EX_DST/python" "$_EX_DST/build" "$_EX_DST/csrc" - cp /workspace/ex_engine/python/*.py "$_EX_DST/python/" 2>/dev/null || true - touch "$_EX_DST/__init__.py" "$_EX_DST/python/__init__.py" - - # Deploy pre-built .so - if [ -d "/workspace/ex_engine/build" ]; then - cp /workspace/ex_engine/build/*.so "$_EX_DST/build/" 2>/dev/null || true - cp /workspace/ex_engine/build/*.so "$_EX_DST/" 2>/dev/null || true - echo "[patch_ops] ex_engine .so deployed: $(ls /workspace/ex_engine/build/*.so 2>/dev/null | wc -l) files" - fi - - # C++ sources for JIT - cp /workspace/ex_engine/csrc/ix_full_bridge.cpp "$_EX_DST/csrc/" 2>/dev/null || true - cp /workspace/ex_engine/csrc/ix_moe_bridge.cpp "$_EX_DST/csrc/" 2>/dev/null || true - - echo "[patch_ops] ex_engine package deployed to $_SITE" -fi +echo "VLLM_ROOT=${VLLM_ROOT}" +echo "TRANSFORMERS_ROOT=${TRANSFORMERS_ROOT}" +[[ -d "$VLLM_ROOT" ]] || { + printf 'vLLM root does not exist: %s\n' "$VLLM_ROOT" >&2 + exit 2 +} -# =========================================================== -# 5. XFormers patches — head_dim=256 bypass for BI-V100 -# Comp 168 also had xformers patches (base uses xformers for attention) -# =========================================================== -python3 ./patch_xformers_sdpa_seq.py 2>&1 || true -python3 ./patch_xformers_sdpa_batch.py 2>&1 || true -echo "[patch_ops] xformers patches applied" +VLLM_OVERRIDE_ROOT="./vendor_overrides/vllm" +[[ -d "$VLLM_OVERRIDE_ROOT" ]] || { + printf 'vLLM override directory missing: %s\n' "$VLLM_OVERRIDE_ROOT" >&2 + exit 2 +} -# =========================================================== -# 6. model_runner patch (prefix_cache_hit fix) -# =========================================================== -python3 ./patch_model_runner.py 2>&1 || true -echo "[patch_ops] model_runner patched" +build_stage "installing authoritative vLLM core block overrides" +install_patch_file \ + "${VLLM_OVERRIDE_ROOT}/core/evictor_v2.py" \ + "${VLLM_ROOT}/core/evictor_v2.py" +install_patch_file \ + "${VLLM_OVERRIDE_ROOT}/core/block/cpu_kv_content_cache.py" \ + "${VLLM_ROOT}/core/block/cpu_kv_content_cache.py" +install_patch_file \ + "${VLLM_OVERRIDE_ROOT}/core/block/cpu_gpu_block_allocator.py" \ + "${VLLM_ROOT}/core/block/cpu_gpu_block_allocator.py" +install_patch_file \ + "${VLLM_OVERRIDE_ROOT}/core/block/prefix_caching_block.py" \ + "${VLLM_ROOT}/core/block/prefix_caching_block.py" +install_patch_file \ + "${VLLM_OVERRIDE_ROOT}/core/block/block_table.py" \ + "${VLLM_ROOT}/core/block/block_table.py" +install_patch_file \ + "${VLLM_OVERRIDE_ROOT}/core/block_manager_v2.py" \ + "${VLLM_ROOT}/core/block_manager_v2.py" +install_patch_file \ + "${VLLM_OVERRIDE_ROOT}/sampling_params.py" \ + "${VLLM_ROOT}/sampling_params.py" +install_patch_file \ + "${VLLM_OVERRIDE_ROOT}/model_executor/sampling_metadata.py" \ + "${VLLM_ROOT}/model_executor/sampling_metadata.py" +install_patch_file \ + "${VLLM_OVERRIDE_ROOT}/model_executor/layers/sampler.py" \ + "${VLLM_ROOT}/model_executor/layers/sampler.py" -# =========================================================== -# 7. Deploy precompiled .so files -# =========================================================== -for _SO in /workspace/ex_engine/moe_topk_softmax_v3*.so /tmp/torch_extensions/*/moe_topk_softmax_v3*.so; do - [ -f "$_SO" ] && cp "$_SO" "$_SITE/" 2>/dev/null && echo "[patch_ops] MoE topk .so: $(basename $_SO)" && break -done -for _SO in /workspace/ex_engine/moe_ops_v055*.so /tmp/torch_extensions/*/moe_ops_v055*.so; do - [ -f "$_SO" ] && cp "$_SO" "$_SITE/" 2>/dev/null && echo "[patch_ops] MoE v055 .so: $(basename $_SO)" && break -done +build_stage "installing hash-pinned CoreX 3.2.3 extensions" +bash ./install_prebuilt_corex.sh "${VLLM_ROOT}" -echo "[patch_ops.v2] DONE — comp 168 aligned" -echo "[patch_ops.v2] KEY: base qwen3_5.py $([ "$_QW_SIZE" -gt 1000 ] && echo "KEPT" || echo "REPLACED"), serving layer deployed" +build_stage "installing BI100 runtime modules" +cp ./bi100_env.py "${VLLM_ROOT}/bi100_env.py" +cp ./bi100_profile.py "${VLLM_ROOT}/bi100_profile.py" +cp ./block_major_kv_cache.py "${VLLM_ROOT}/block_major_kv_cache.py" +cp ./gdn_prefix.py "${VLLM_ROOT}/gdn_prefix.py" + +build_stage "installing CoreX paged-KV swap compatibility" +python3 ./patch_corex_swap_blocks.py +python3 ./patch_block_major_cache_engine.py +python3 ./patch_worker_cache_transfer_order.py + +# --- paged_attn.py: replace forward_prefix with pure-PyTorch fallback ------- +# The Triton context_attention_fwd kernel hangs BI-V100 GPUs permanently +# (standard Triton 2.3.1 PTX is not supported by the corex runtime either). +# Our paged_attn.py bypasses it entirely via _forward_prefix_pytorch, which +# utilizes K-tiling techniques, and also have _forward_decode_pytorch to bypass kernel +# when context length is high +cp ./paged_attn.py "${VLLM_ROOT}/attention/ops/paged_attn.py" + +# --- model_runner.py: fix prefix_cache_hit stays True in chunked-prefill chunk 2+ --- +# Bug: _compute_for_prefix_cache_hit Case 1 (prefix_cache_len <= context_len) +# leaves prefix_cache_hit=True. Then _add_seq_group uses block_table=computed_block_nums +# (only the original prefix blocks), ignoring chunk-1 KV cache blocks. +# _forward_prefix_pytorch then gets an undersized block_tables and crashes with +# "amax(): Expected reduction dim -1 to have non-zero size" on the 2nd tile. +# Fix: set prefix_cache_hit=False for Case 1 so the full block_tables is used. +python3 ./patch_model_runner.py + +build_stage "installing executor startup diagnostics" +python3 ./patch_executor_startup_debug.py +python3 ./patch_worker_startup_profile_guard.py +python3 ./patch_block_major_worker_capacity.py + +build_stage "installing transformers Qwen3.5 model support" +cp -r ./qwen3_5 "${TRANSFORMERS_ROOT}/models/" +cp -r ./qwen3_5_moe "${TRANSFORMERS_ROOT}/models/" +python3 ./patch_transformers_qwen3_5.py + +build_stage "installing vLLM Qwen3.6 model implementation" +# --- vllm model: Qwen3.6-35B-A3B (Qwen3_5 MoE arch) ------------------------- +cp ./mamba_cache.py "${VLLM_ROOT}/model_executor/models/" +cp ./qwen3_5.py "${VLLM_ROOT}/model_executor/models/qwen3_5.py" +python3 ./patch_vllm_qwen3_5.py + +# --- sequence.py: fix completion_tokens inflation under chunked prefill ------ +# Bug: get_output_token_ids_to_return(delta=True) with num_new_tokens=0 +# returns _cached_all_token_ids[-0:] == [0:] (the ENTIRE prompt+output list). +# Each prefill chunk step adds prompt_len to previous_num_tokens, so a 10K +# prompt processed in 3 chunks inflates completion_tokens by ~30K. +# Also adds num_cached_tokens field to RequestMetrics for prefix-cache stats. +cp ./sequence.py "${VLLM_ROOT}/sequence.py" + +# --- scheduler.py: record num_cached_tokens in RequestMetrics ---------------- +# Reports only the longest prefix backed by both live KV blocks and an exact +# GDN restore state. Raw KV-only hits must not inflate cached_tokens. +# serving_chat.py exposes the value in the OpenAI-compatible usage details. +cp ./scheduler.py "${VLLM_ROOT}/core/scheduler.py" + +build_stage "installing diagnostic initial allocation trace" +python3 ./patch_block_manager_cache_trace.py + +build_stage "installing scheduler and attention patches" +# --- xformers: bypass cudnnFlashAttnForward (head_dim=256 > 128 limit) ------ +# Injects _run_sdpa_fallback (pure matmul+softmax) into xformers.py. +# Required because head_dim=256 > 128 and ixformer flash attention either +# crashes (is_causal=True) or produces wrong output (attn_mask path). +# The fallback uses query_start_loc to derive actual query lengths, so it +# works correctly during profiling runs with chunked-prefill-style batches. +# also bypasses auto chunked prefill on +python3 ./patch_xformers_sdpa_seq.py +python3 ./patch_xformers_profile.py + +build_stage "installing API parsers and serving modules" +# --- tool parser: Qwen3 XML tool call format --------------------------------- +# Registers "qwen3_coder" parser for Qwen3.6 XML-style tool calls: +# \nvalue\n +# Use at server start: --tool-call-parser qwen3_coder --enable-auto-tool-choice +cp ./qwen3coder_tool_parser.py "${VLLM_ROOT}/entrypoints/openai/tool_parsers/" +python3 ./patch_vllm_tool_parser.py + +# --- reasoning parser: Qwen3 ... split ------------------------ +# Adds --reasoning-parser qwen3 support. +# Routes thinking tokens to reasoning_content, rest to content in the delta. +# Works together with --tool-call-parser qwen3_coder (think → tool call flow). +cp -r ./reasoning "${VLLM_ROOT}/" +cp ./protocol.py "${VLLM_ROOT}/entrypoints/openai/protocol.py" +cp ./cli_args.py "${VLLM_ROOT}/entrypoints/openai/cli_args.py" +cp ./serving_chat.py "${VLLM_ROOT}/entrypoints/openai/serving_chat.py" +cp ./serving_tokenization.py \ + "${VLLM_ROOT}/entrypoints/openai/serving_tokenization.py" +cp ./api_server.py "${VLLM_ROOT}/entrypoints/openai/api_server.py" +cp ./chat_utils.py "${VLLM_ROOT}/entrypoints/chat_utils.py" +python3 - ./api_server.py \ + "${VLLM_ROOT}/entrypoints/openai/api_server.py" <<'PY' +from pathlib import Path +import sys + +source = Path(sys.argv[1]).read_bytes() +installed = Path(sys.argv[2]).read_bytes() +if source != installed: + raise SystemExit("runtime api_server overlay identity mismatch") +PY + +build_stage "compiling submission Python sources" +find . -path './wheels' -prune -o -name '*.py' -print0 | xargs -0 python3 -m py_compile +build_stage "patch script completed" diff --git a/qwen3_6_scripts/patch_transformers_qwen3_5.py b/qwen3_6_scripts/patch_transformers_qwen3_5.py index 0ca6bcc2..f0619a98 100644 --- a/qwen3_6_scripts/patch_transformers_qwen3_5.py +++ b/qwen3_6_scripts/patch_transformers_qwen3_5.py @@ -2,54 +2,23 @@ Patches transformers 4.55.3 to register qwen3_5 and qwen3_5_moe model types. Deploy steps on the remote machine: - 1. cp -r modified_scripts/qwen3_5 /usr/local/lib/python3.10/site-packages/transformers/models/qwen3_5 - 2. cp -r modified_scripts/qwen3_5_moe /usr/local/lib/python3.10/site-packages/transformers/models/qwen3_5_moe + 1. patch_ops.sh locates transformers with importlib.util.find_spec. + 2. cp -r modified_scripts/qwen3_5* into the detected transformers/models. 3. python3 modified_scripts/patch_transformers_qwen3_5.py - -Target: pip-installed transformers at /usr/local/lib/python3.10/site-packages/transformers/ -(Not the corex pre-installed path at /usr/local/corex/lib64/python3/dist-packages/) """ import sys -TRANSFORMERS_ROOT = None -for _p in ["/usr/local/lib/python3.10/site-packages/transformers", - "/usr/local/corex/lib/python3/dist-packages/transformers", - "/usr/local/corex/lib64/python3/dist-packages/transformers"]: - import os - if os.path.isdir(_p): - TRANSFORMERS_ROOT = _p - break -if TRANSFORMERS_ROOT is None: - TRANSFORMERS_ROOT = "/usr/local/lib/python3.10/site-packages/transformers" -AUTO_CONFIG = f"{TRANSFORMERS_ROOT}/models/auto/configuration_auto.py" -MODELS_INIT = f"{TRANSFORMERS_ROOT}/models/__init__.py" +from patch_utils import package_root, replace_once, replace_one_of - -def patch_file(path, replacements): - with open(path, "r") as f: - content = f.read() - - patched = False - for old, new in replacements: - if new in content: - print(f" [skip] already patched: {repr(new[:60])}") - continue - if old not in content: - print(f" [warn] anchor not found: {repr(old[:60])}") - continue - content = content.replace(old, new, 1) - patched = True - print(f" [ok] inserted after: {repr(old[:60])}") - - if patched: - with open(path, "w") as f: - f.write(content) +TRANSFORMERS_ROOT = package_root("transformers") +AUTO_CONFIG = TRANSFORMERS_ROOT / "models" / "auto" / "configuration_auto.py" +MODELS_INIT = TRANSFORMERS_ROOT / "models" / "__init__.py" def main(): print(f"=== Patching {AUTO_CONFIG} ===") - patch_file(AUTO_CONFIG, [ + replace_one_of(AUTO_CONFIG, [ # CONFIG_MAPPING_NAMES: insert qwen3_5 + qwen3_5_moe right after qwen3 ( '("qwen3", "Qwen3Config"),', @@ -59,6 +28,8 @@ def main(): '("qwen3", "Qwen3Config")\n', '("qwen3", "Qwen3Config"),\n ("qwen3_5", "Qwen3_5Config"),\n ("qwen3_5_moe", "Qwen3_5MoeConfig"),\n', ), + ], required=True, already_contains='("qwen3_5_moe", "Qwen3_5MoeConfig")') + replace_one_of(AUTO_CONFIG, [ # MODEL_NAMES_MAPPING (model_type -> human readable name) ( '("qwen3", "Qwen3"),', @@ -68,15 +39,15 @@ def main(): '("qwen3", "Qwen3")\n', '("qwen3", "Qwen3"),\n ("qwen3_5", "Qwen3_5"),\n ("qwen3_5_moe", "Qwen3_5_MoE"),\n', ), - ]) + ], required=True, already_contains='("qwen3_5_moe", "Qwen3_5_MoE")') print(f"\n=== Patching {MODELS_INIT} ===") - patch_file(MODELS_INIT, [ - ( - "from .qwen3 import *\n", - "from .qwen3 import *\n from .qwen3_5 import *\n from .qwen3_5_moe import *\n", - ), - ]) + replace_once( + MODELS_INIT, + "from .qwen3 import *\n", + "from .qwen3 import *\n from .qwen3_5 import *\n from .qwen3_5_moe import *\n", + required=True, + already_contains="from .qwen3_5_moe import *") # Verification print("\n=== Verification ===") @@ -88,28 +59,31 @@ def main(): mod = importlib.util.module_from_spec(spec) mod.__package__ = ".".join(module_name.split(".")[:-1]) pkg = sys.modules.setdefault("transformers", types.ModuleType("transformers")) - pkg.__path__ = [TRANSFORMERS_ROOT] + pkg.__path__ = [str(TRANSFORMERS_ROOT)] cu = sys.modules.setdefault( "transformers.configuration_utils", types.ModuleType("transformers.configuration_utils")) class _PC: - def __init__(self, **kwargs): pass + def __init__(self, **kwargs): + return None cu.PretrainedConfig = _PC for sub in ("transformers.models", f"transformers.models.{module_name.split('.')[-2]}"): m = sys.modules.setdefault(sub, types.ModuleType(sub)) - m.__path__ = [TRANSFORMERS_ROOT] + m.__path__ = [str(TRANSFORMERS_ROOT)] spec.loader.exec_module(mod) return mod mod27 = _load_config_mod( "transformers.models.qwen3_5.configuration_qwen3_5", - f"{TRANSFORMERS_ROOT}/models/qwen3_5/configuration_qwen3_5.py", + str(TRANSFORMERS_ROOT / "models" / "qwen3_5" / + "configuration_qwen3_5.py"), ) cfg = mod27.Qwen3_5Config() print(f" Qwen3_5Config() smoke-test OK (model_type={cfg.model_type})") mod35 = _load_config_mod( "transformers.models.qwen3_5_moe.configuration_qwen3_5_moe", - f"{TRANSFORMERS_ROOT}/models/qwen3_5_moe/configuration_qwen3_5_moe.py", + str(TRANSFORMERS_ROOT / "models" / "qwen3_5_moe" / + "configuration_qwen3_5_moe.py"), ) moe_cfg = mod35.Qwen3_5MoeConfig() print(f" Qwen3_5MoeConfig() smoke-test OK (model_type={moe_cfg.model_type})") @@ -117,7 +91,7 @@ def main(): print(f" num_experts={t.num_experts}, top_k={t.num_experts_per_tok}, " f"shared={t.shared_expert_intermediate_size}, layers={t.num_hidden_layers}") except Exception as e: - print(f" [warn] smoke-test failed (may be fine at runtime): {e}") + print(f" [optional] smoke-test failed (may be fine at runtime): {e}") print("\nDone.") diff --git a/qwen3_6_scripts/patch_utils.py b/qwen3_6_scripts/patch_utils.py new file mode 100644 index 00000000..104adc43 --- /dev/null +++ b/qwen3_6_scripts/patch_utils.py @@ -0,0 +1,81 @@ +from __future__ import annotations + +import importlib.util +import pathlib +import shlex +from typing import Iterable, Optional, Sequence, Tuple + + +def package_root(pkg: str) -> pathlib.Path: + spec = importlib.util.find_spec(pkg) + if spec is None: + raise RuntimeError(f"package not found: {pkg}") + if not spec.submodule_search_locations: + raise RuntimeError(f"package has no package root: {pkg}") + return pathlib.Path(next(iter(spec.submodule_search_locations))).resolve() + + +def ensure_file(path: pathlib.Path) -> pathlib.Path: + if not path.is_file(): + raise FileNotFoundError(str(path)) + return path + + +def ensure_dir(path: pathlib.Path) -> pathlib.Path: + if not path.is_dir(): + raise FileNotFoundError(str(path)) + return path + + +def replace_once(path: pathlib.Path, + old: str, + new: str, + *, + required: bool = True, + already_contains: Optional[str] = None) -> bool: + path = ensure_file(path) + text = path.read_text() + marker = already_contains if already_contains is not None else new + if marker in text: + print(f"[skip] already patched: {path}") + return False + if old not in text: + msg = f"anchor not found in {path}: {old[:120]!r}" + if required: + raise RuntimeError(msg) + print(f"[warn] {msg}") + return False + path.write_text(text.replace(old, new, 1)) + print(f"[ok] patched: {path}") + return True + + +def replace_one_of(path: pathlib.Path, + replacements: Sequence[Tuple[str, str]], + *, + required: bool = True, + already_contains: Optional[str] = None) -> bool: + path = ensure_file(path) + text = path.read_text() + if already_contains is not None and already_contains in text: + print(f"[skip] already patched: {path}") + return False + for _, new in replacements: + if new in text: + print(f"[skip] already patched: {path}") + return False + for old, new in replacements: + if old in text: + path.write_text(text.replace(old, new, 1)) + print(f"[ok] patched: {path}") + return True + anchors = ", ".join(repr(old[:80]) for old, _ in replacements) + msg = f"anchor not found in {path}; tried: {anchors}" + if required: + raise RuntimeError(msg) + print(f"[warn] {msg}") + return False + + +def shell_env_line(name: str, value: pathlib.Path) -> str: + return f"{name}={shlex.quote(str(value))}" diff --git a/qwen3_6_scripts/patch_vllm_qwen3_5.py b/qwen3_6_scripts/patch_vllm_qwen3_5.py new file mode 100644 index 00000000..55313fc9 --- /dev/null +++ b/qwen3_6_scripts/patch_vllm_qwen3_5.py @@ -0,0 +1,73 @@ +""" +Patches the vLLM model registry and deploys the Qwen3_5 model file. + +Deploy steps on the remote machine: + 1. patch_ops.sh locates vLLM with importlib.util.find_spec. + 2. cp modified_scripts/qwen3_5.py into the detected vllm model directory. + 2. python3 modified_scripts/patch_vllm_qwen3_5.py + +The registry patch installs Qwen3.6 aliases so /model/config.json does not +need to be edited by hand. +""" + +import ast + +from patch_utils import package_root, replace_once + +VLLM_ROOT = package_root("vllm") +REGISTRY = VLLM_ROOT / "model_executor" / "models" / "registry.py" +MODEL = VLLM_ROOT / "model_executor" / "models" / "qwen3_5.py" + +EXPECTED_REGISTRY_ENTRIES = ( + '"Qwen3ForCausalLM": ("qwen3_5", "Qwen3_5ForCausalLM")', + '"Qwen3MoeForCausalLM": ("qwen3_5", "Qwen3_5MoeForCausalLM")', + '"Qwen3_5ForCausalLM": ("qwen3_5", "Qwen3_5ForCausalLM")', + '"Qwen3_5MoeForCausalLM": ("qwen3_5", "Qwen3_5MoeForCausalLM")', + '"Qwen3_6ForCausalLM": ("qwen3_5", "Qwen3_5ForCausalLM")', + '"Qwen3_6MoeForCausalLM": ("qwen3_5", "Qwen3_5MoeForCausalLM")', +) + + +def main(): + print(f"=== Patching {REGISTRY} ===") + replace_once( + REGISTRY, + ' "Qwen3ForCausalLM": ("qwen3", "Qwen3ForCausalLM"),\n' + ' "Qwen3MoeForCausalLM": ("qwen3_moe", "Qwen3MoeForCausalLM"),', + ' "Qwen3ForCausalLM": ("qwen3_5", "Qwen3_5ForCausalLM"),\n' + ' "Qwen3MoeForCausalLM": ("qwen3_5", "Qwen3_5MoeForCausalLM"),\n' + ' "Qwen3_5ForCausalLM": ("qwen3_5", "Qwen3_5ForCausalLM"),\n' + ' "Qwen3_5MoeForCausalLM": ("qwen3_5", "Qwen3_5MoeForCausalLM"),\n' + ' "Qwen3_6ForCausalLM": ("qwen3_5", "Qwen3_5ForCausalLM"),\n' + ' "Qwen3_6MoeForCausalLM": ("qwen3_5", "Qwen3_5MoeForCausalLM"),', + required=True, + already_contains='"Qwen3_6MoeForCausalLM"') + + print("\n=== Static verification ===") + model_source = MODEL.read_text(encoding="utf-8") + tree = ast.parse(model_source, filename=str(MODEL)) + class_names = { + node.name for node in tree.body if isinstance(node, ast.ClassDef) + } + required_classes = {"Qwen3_5ForCausalLM", "Qwen3_5MoeForCausalLM"} + missing_classes = required_classes - class_names + if missing_classes: + raise RuntimeError( + f"Qwen3.5 model classes missing: {sorted(missing_classes)}") + + registry_source = REGISTRY.read_text(encoding="utf-8") + missing_entries = [ + entry for entry in EXPECTED_REGISTRY_ENTRIES + if entry not in registry_source + ] + if missing_entries: + raise RuntimeError( + f"Qwen3.5 registry entries missing: {missing_entries}") + print(" model syntax and class declarations verified without import") + print(f" registry aliases verified: {len(EXPECTED_REGISTRY_ENTRIES)}") + + print("\nDone. Registry aliases installed; do not edit /model/config.json.") + + +if __name__ == "__main__": + main() diff --git a/qwen3_6_scripts/patch_vllm_tool_parser.py b/qwen3_6_scripts/patch_vllm_tool_parser.py index f2575ba9..18463a53 100644 --- a/qwen3_6_scripts/patch_vllm_tool_parser.py +++ b/qwen3_6_scripts/patch_vllm_tool_parser.py @@ -1,79 +1,57 @@ -""" -Patches vLLM 0.6.3 to register Qwen3CoderToolParser under the name "qwen3_coder". - +""" +Patches vLLM 0.6.3 to register Qwen3CoderToolParser under the name "qwen3_coder". + Deploy steps on the remote machine (already called by patch_ops.sh): - 1. cp qwen3coder_tool_parser.py \ - /usr/local/corex/lib/python3/dist-packages/vllm/entrypoints/openai/tool_parsers/ + 1. patch_ops.sh locates vLLM with importlib.util.find_spec. + 2. cp qwen3coder_tool_parser.py into the detected vllm tool_parsers. 2. python3 patch_vllm_tool_parser.py + +Usage after patching: + --tool-call-parser qwen3_coder --enable-auto-tool-choice +""" + +from patch_utils import ensure_dir, package_root, replace_once -Usage after patching: - --tool-call-parser qwen3_coder --enable-auto-tool-choice -""" - -import os - -VLLM_ROOT = "/usr/local/corex/lib/python3/dist-packages/vllm" -TOOL_PARSERS_DIR = f"{VLLM_ROOT}/entrypoints/openai/tool_parsers" -INIT_FILE = f"{TOOL_PARSERS_DIR}/__init__.py" - - -def patch_file(path, replacements): - with open(path, "r") as f: - content = f.read() - - patched = False - for old, new in replacements: - if new in content: - print(f" [skip] already patched: {repr(new[:70])}") - continue - if old not in content: - print(f" [warn] anchor not found: {repr(old[:70])}") - continue - content = content.replace(old, new, 1) - patched = True - print(f" [ok] patched: {repr(old[:50])} -> {repr(new[:50])}") - - if patched: - with open(path, "w") as f: - f.write(content) - - -def main(): - if not os.path.isdir(TOOL_PARSERS_DIR): - raise FileNotFoundError( - f"Tool parsers directory not found: {TOOL_PARSERS_DIR}\n" - "Verify the vLLM installation path.") +VLLM_ROOT = package_root("vllm") +TOOL_PARSERS_DIR = VLLM_ROOT / "entrypoints" / "openai" / "tool_parsers" +INIT_FILE = TOOL_PARSERS_DIR / "__init__.py" + + +def main(): + ensure_dir(TOOL_PARSERS_DIR) print(f"=== Patching {INIT_FILE} ===") - patch_file(INIT_FILE, [ - ( - "from .mistral_tool_parser import MistralToolParser", - "from .mistral_tool_parser import MistralToolParser\n" - "from .qwen3coder_tool_parser import Qwen3CoderToolParser", - ), - ( - '"MistralToolParser", "Internlm2ToolParser", "Llama3JsonToolParser"\n]', - '"MistralToolParser", "Internlm2ToolParser", "Llama3JsonToolParser",\n' - ' "Qwen3CoderToolParser"\n]', - ), - ]) - - print("\n=== Verification ===") - try: - import importlib.util - spec = importlib.util.spec_from_file_location( - "qwen3coder_tool_parser", - f"{TOOL_PARSERS_DIR}/qwen3coder_tool_parser.py", - ) - mod = importlib.util.module_from_spec(spec) - print(f" Module spec loaded: {spec.name}") - print(" (full import requires torch/vllm runtime — skipping exec)") - except Exception as e: - print(f" [warn] spec check failed: {e}") - - print("\nDone. Start vLLM server with:") - print(" --tool-call-parser qwen3_coder --enable-auto-tool-choice") - - -if __name__ == "__main__": - main() + replace_once( + INIT_FILE, + "from .mistral_tool_parser import MistralToolParser", + "from .mistral_tool_parser import MistralToolParser\n" + "from .qwen3coder_tool_parser import Qwen3CoderToolParser", + required=True, + already_contains="from .qwen3coder_tool_parser import Qwen3CoderToolParser") + replace_once( + INIT_FILE, + '"MistralToolParser", "Internlm2ToolParser", "Llama3JsonToolParser"\n]', + '"MistralToolParser", "Internlm2ToolParser", "Llama3JsonToolParser",\n' + ' "Qwen3CoderToolParser"\n]', + required=True, + already_contains='"Qwen3CoderToolParser"') + + print("\n=== Verification ===") + try: + import importlib.util + spec = importlib.util.spec_from_file_location( + "qwen3coder_tool_parser", + str(TOOL_PARSERS_DIR / "qwen3coder_tool_parser.py"), + ) + mod = importlib.util.module_from_spec(spec) + print(f" Module spec loaded: {spec.name}") + print(" (full import requires torch/vllm runtime — skipping exec)") + except Exception as e: + print(f" [optional] spec check failed: {e}") + + print("\nDone. Start vLLM server with:") + print(" --tool-call-parser qwen3_coder --enable-auto-tool-choice") + + +if __name__ == "__main__": + main() diff --git a/qwen3_6_scripts/patch_worker_cache_transfer_order.py b/qwen3_6_scripts/patch_worker_cache_transfer_order.py new file mode 100644 index 00000000..af7df40f --- /dev/null +++ b/qwen3_6_scripts/patch_worker_cache_transfer_order.py @@ -0,0 +1,37 @@ +from patch_utils import package_root, replace_once + + +WORKER = package_root("vllm") / "worker" / "worker.py" + +CLEAN_BLOCK = """\ + if (worker_input.blocks_to_swap_in is not None + and worker_input.blocks_to_swap_in.numel() > 0): + self.cache_engine[virtual_engine].swap_in( + worker_input.blocks_to_swap_in) + if (worker_input.blocks_to_swap_out is not None + and worker_input.blocks_to_swap_out.numel() > 0): + self.cache_engine[virtual_engine].swap_out( + worker_input.blocks_to_swap_out) +""" + +ORDERED_BLOCK = """\ + # BI100 content-addressed CPU KV tier may preserve a victim and reuse + # that same GPU slot in one step. Complete every D2H before any H2D. + if (worker_input.blocks_to_swap_out is not None + and worker_input.blocks_to_swap_out.numel() > 0): + self.cache_engine[virtual_engine].swap_out( + worker_input.blocks_to_swap_out) + if (worker_input.blocks_to_swap_in is not None + and worker_input.blocks_to_swap_in.numel() > 0): + self.cache_engine[virtual_engine].swap_in( + worker_input.blocks_to_swap_in) +""" + + +replace_once( + WORKER, + CLEAN_BLOCK, + ORDERED_BLOCK, + required=True, + already_contains="Complete every D2H before any H2D", +) diff --git a/qwen3_6_scripts/patch_worker_profile_override.py b/qwen3_6_scripts/patch_worker_profile_override.py new file mode 100644 index 00000000..a62a2ce2 --- /dev/null +++ b/qwen3_6_scripts/patch_worker_profile_override.py @@ -0,0 +1,81 @@ +from patch_utils import package_root, replace_one_of + +WORKER = package_root("vllm") / "worker" / "worker.py" + +CLEAN_BLOCK = """\ + # Profile the memory usage of the model and get the maximum number of + # cache blocks that can be allocated with the remaining free memory. + torch.cuda.empty_cache() + + # Execute a forward pass with dummy inputs to profile the memory usage + # of the model. + self.model_runner.profile_run() +""" + +GUARDED_BLOCK = """\ + # Profile the memory usage of the model and get the maximum number of + # cache blocks that can be allocated with the remaining free memory. + torch.cuda.empty_cache() + + # Execute a forward pass with dummy inputs to profile the memory usage + # of the model. Mark this synthetic pass so BI100_PROFILE can skip + # timing it by default; profiling real requests is the useful signal. + _bi100_prev_startup_profile = os.environ.get("BI100_IN_STARTUP_PROFILE") + os.environ["BI100_IN_STARTUP_PROFILE"] = "1" + try: + self.model_runner.profile_run() + finally: + if _bi100_prev_startup_profile is None: + os.environ.pop("BI100_IN_STARTUP_PROFILE", None) + else: + os.environ["BI100_IN_STARTUP_PROFILE"] = _bi100_prev_startup_profile +""" + +NEW_BLOCK = """\ + # Profile the memory usage of the model and get the maximum number of + # cache blocks that can be allocated with the remaining free memory. + torch.cuda.empty_cache() + + # BI100: Qwen3.6 batched dummy profile_run can trip GDN non-finite + # checks before the server starts. If the operator explicitly provides + # --num-gpu-blocks-override, trust that conservative capacity value and + # skip only the synthetic profile pass. Real inference still uses the + # normal GDN fail-fast path. + if self.cache_config.num_gpu_blocks_override is not None: + cache_block_size = self.get_cache_block_size_bytes() + if cache_block_size == 0: + num_cpu_blocks = 0 + else: + num_cpu_blocks = int(self.cache_config.swap_space_bytes // + cache_block_size) + logger.warning( + "[BI100] skipping worker.profile_run because " + "num_gpu_blocks_override=%d was explicitly set", + self.cache_config.num_gpu_blocks_override) + gc.collect() + torch.cuda.empty_cache() + return self.cache_config.num_gpu_blocks_override, max(num_cpu_blocks, 0) + + # Execute a forward pass with dummy inputs to profile the memory usage + # of the model. Mark this synthetic pass so BI100_PROFILE can skip + # timing it by default; profiling real requests is the useful signal. + _bi100_prev_startup_profile = os.environ.get("BI100_IN_STARTUP_PROFILE") + os.environ["BI100_IN_STARTUP_PROFILE"] = "1" + try: + self.model_runner.profile_run() + finally: + if _bi100_prev_startup_profile is None: + os.environ.pop("BI100_IN_STARTUP_PROFILE", None) + else: + os.environ["BI100_IN_STARTUP_PROFILE"] = _bi100_prev_startup_profile +""" + +replace_one_of( + WORKER, + [ + (GUARDED_BLOCK, NEW_BLOCK), + (CLEAN_BLOCK, NEW_BLOCK), + ], + required=True, + already_contains="[BI100] skipping worker.profile_run", +) diff --git a/qwen3_6_scripts/patch_worker_startup_profile_guard.py b/qwen3_6_scripts/patch_worker_startup_profile_guard.py new file mode 100644 index 00000000..6110aa68 --- /dev/null +++ b/qwen3_6_scripts/patch_worker_startup_profile_guard.py @@ -0,0 +1,34 @@ +from patch_utils import package_root, replace_one_of + + +WORKER = package_root("vllm") / "worker" / "worker.py" + +CLEAN_BLOCK = """\ + # Execute a forward pass with dummy inputs to profile the memory usage + # of the model. + self.model_runner.profile_run() +""" + +GUARDED_BLOCK = """\ + # Execute a forward pass with dummy inputs to profile the memory usage + # of the model. Mark this synthetic pass so BI100_PROFILE can exclude + # it without changing vLLM's normal capacity calculation. + _bi100_prev_startup_profile = os.environ.get("BI100_IN_STARTUP_PROFILE") + os.environ["BI100_IN_STARTUP_PROFILE"] = "1" + try: + self.model_runner.profile_run() + finally: + if _bi100_prev_startup_profile is None: + os.environ.pop("BI100_IN_STARTUP_PROFILE", None) + else: + os.environ["BI100_IN_STARTUP_PROFILE"] = _bi100_prev_startup_profile +""" + + +replace_one_of( + WORKER, + [(CLEAN_BLOCK, GUARDED_BLOCK)], + required=True, + already_contains=( + "Mark this synthetic pass so BI100_PROFILE can exclude"), +) diff --git a/qwen3_6_scripts/patch_xformers_profile.py b/qwen3_6_scripts/patch_xformers_profile.py new file mode 100644 index 00000000..51d24650 --- /dev/null +++ b/qwen3_6_scripts/patch_xformers_profile.py @@ -0,0 +1,121 @@ +"""Install disabled-by-default M1-48 XFormers timing boundaries.""" + +from __future__ import annotations + +from pathlib import Path + +try: + from patch_utils import package_root, replace_once +except ModuleNotFoundError: + from .patch_utils import package_root, replace_once + + +IMPORT_OLD = "from vllm.logger import init_logger" +IMPORT_NEW = """\ +from vllm.bi100_profile import bi100_timer +from vllm.logger import init_logger""" + +KV_WRITE_OLD = """\ + PagedAttention.write_to_paged_cache(key, value, key_cache, + value_cache, + updated_slot_mapping, + self.kv_cache_dtype, + k_scale, v_scale)""" +KV_WRITE_NEW = """\ + with bi100_timer("xformers.kv_write"): + PagedAttention.write_to_paged_cache( + key, value, key_cache, value_cache, + updated_slot_mapping, self.kv_cache_dtype, + k_scale, v_scale)""" + +DENSE_OLD = """\ + out = self._run_memory_efficient_xformers_forward( + query, key, value, prefill_meta, attn_type=attn_type)""" +DENSE_NEW = """\ + with bi100_timer("xformers.dense_prefill"): + out = self._run_memory_efficient_xformers_forward( + query, key, value, prefill_meta, attn_type=attn_type)""" + +PAGED_OLD = """\ + out = PagedAttention.forward_prefix( + query, + key, + value, + self.kv_cache_dtype, + key_cache, + value_cache, + prefill_meta.block_tables, + prefill_meta.query_start_loc, + prefill_meta.seq_lens_tensor, + prefill_meta.context_lens_tensor, + prefill_meta.max_query_len, + self.alibi_slopes, + self.sliding_window, + k_scale, + v_scale, + is_causal_decoder=(attn_type == AttentionType.DECODER), + )""" +PAGED_NEW = """\ + with bi100_timer("xformers.paged_prefill"): + out = PagedAttention.forward_prefix( + query, + key, + value, + self.kv_cache_dtype, + key_cache, + value_cache, + prefill_meta.block_tables, + prefill_meta.query_start_loc, + prefill_meta.seq_lens_tensor, + prefill_meta.context_lens_tensor, + prefill_meta.max_query_len, + self.alibi_slopes, + self.sliding_window, + k_scale, + v_scale, + is_causal_decoder=(attn_type == AttentionType.DECODER), + )""" + + +def patch_file(path: Path) -> None: + replace_once( + path, + IMPORT_OLD, + IMPORT_NEW, + already_contains="from vllm.bi100_profile import bi100_timer", + ) + replace_once( + path, + KV_WRITE_OLD, + KV_WRITE_NEW, + already_contains='bi100_timer("xformers.kv_write")', + ) + replace_once( + path, + DENSE_OLD, + DENSE_NEW, + already_contains='bi100_timer("xformers.dense_prefill")', + ) + replace_once( + path, + PAGED_OLD, + PAGED_NEW, + already_contains='bi100_timer("xformers.paged_prefill")', + ) + text = path.read_text(encoding="utf-8") + canonical = "\n".join(line.rstrip(" \t") for line in text.split("\n")) + if not canonical.endswith("\n"): + canonical += "\n" + if canonical != text: + path.write_text(canonical, encoding="utf-8") + + +def main() -> None: + path = package_root("vllm") / "attention" / "backends" / "xformers.py" + print("=== patch_xformers_profile (M1-48 diagnostic timers) ===") + print(f"Target: {path}") + patch_file(path) + + +if __name__ == "__main__": + main() diff --git a/qwen3_6_scripts/patch_xformers_sdpa_batch.py b/qwen3_6_scripts/patch_xformers_sdpa_batch.py index a585b4d0..72315b58 100644 --- a/qwen3_6_scripts/patch_xformers_sdpa_batch.py +++ b/qwen3_6_scripts/patch_xformers_sdpa_batch.py @@ -1,192 +1,177 @@ """ -策略：批量（block-diagonal）fallback — 纯 PyTorch 数学实现 -============================================================= -构建块对角 causal mask，对整批序列一次 matmul + softmax， -完全绕开所有硬件 flash attention kernel。 - -背景： - ixformer flshattF: head_dim > 128 报错拒绝 - cudnnFlashAttnForward: 接受 head_dim=256，但数值结果错误（输出全"!"） - 两者大概率是同一硬件单元，ixformer 提前拦截了硬件不支持的配置。 - 纯 matmul 路径完全绕开硬件 flash attention，数值正确。 - -优点： - 数值正确。 - 并发请求 prefill attention 在 GPU 上真正并行（一次大 matmul）。 - -缺点： - 峰值显存 = total_tokens² × H × dtype_size - total_tokens 受 --max-num-batched-tokens 控制，max-model-len 控制不住。 - -内存参考（fp16，H_local=6，--max-num-batched-tokens=T）： - T=2048 → 峰值 ~50 MB - T=4096 → 峰值 ~200 MB - T=8192 → 峰值 ~800 MB - T=16384 → 峰值 ~3.2 GB - +策略：批量（block-diagonal）fallback — 纯 PyTorch 数学实现 +============================================================= +构建块对角 causal mask，对整批序列一次 matmul + softmax， +完全绕开所有硬件 flash attention kernel。 + +背景： + ixformer flshattF: head_dim > 128 报错拒绝 + cudnnFlashAttnForward: 接受 head_dim=256，但数值结果错误（输出全"!"） + 两者大概率是同一硬件单元，ixformer 提前拦截了硬件不支持的配置。 + 纯 matmul 路径完全绕开硬件 flash attention，数值正确。 + +优点： + 数值正确。 + 并发请求 prefill attention 在 GPU 上真正并行（一次大 matmul）。 + +缺点： + 峰值显存 = total_tokens² × H × dtype_size + total_tokens 受 --max-num-batched-tokens 控制，max-model-len 控制不住。 + +内存参考（fp16，H_local=6，--max-num-batched-tokens=T）： + T=2048 → 峰值 ~50 MB + T=4096 → 峰值 ~200 MB + T=8192 → 峰值 ~800 MB + T=16384 → 峰值 ~3.2 GB + Deploy: python3 modified_scripts/patch_xformers_sdpa_batch.py """ -XFORMERS_PATH = ( - "/usr/local/corex/lib64/python3/dist-packages/" - "vllm/attention/backends/xformers.py" -) - -FALLBACK_METHOD = ''' - def _run_sdpa_fallback( - self, - query: torch.Tensor, - key: torch.Tensor, - value: torch.Tensor, - attn_metadata: "XFormersMetadata", - ) -> torch.Tensor: - """批量纯数学 attention fallback。 - - 构建块对角 causal mask（等价于 ixformer BlockDiagonalCausalMask）， - 对整批序列一次 matmul + softmax，GPU 并行处理所有序列。 - - 块对角 mask 结构（seq1 len=3，seq2 len=2）： - s1,0 s1,1 s1,2 s2,0 s2,1 - s1,0 [ 0 -inf -inf -inf -inf ] - s1,1 [ 0 0 -inf -inf -inf ] - s1,2 [ 0 0 0 -inf -inf ] - s2,0 [-inf -inf -inf 0 -inf ] - s2,1 [-inf -inf -inf 0 0 ] - - softmax 在 float32 下计算防止 float16 溢出，结果转回原始 dtype。 - - Args: - query : [1, total_prefill_tokens, num_heads, head_dim] - key : [1, total_prefill_tokens, num_kv_heads, head_dim] - value : [1, total_prefill_tokens, num_kv_heads, head_dim] - Returns: - [1, total_prefill_tokens, num_heads, head_dim] - """ - assert attn_metadata.seq_lens is not None - orig_dtype = query.dtype - total_tokens = query.shape[1] - - # ── 构建块对角 causal mask [T, T] ──────────────────────────────── - # 全部初始化为 -inf，再对每条序列的对角块填入下三角 0 - mask = torch.full( - (total_tokens, total_tokens), - float("-inf"), - dtype=torch.float32, - device=query.device, - ) - start = 0 - for seq_len in attn_metadata.seq_lens: - end = start + seq_len - mask[start:end, start:end] = torch.tril( - torch.zeros(seq_len, seq_len, - dtype=torch.float32, device=query.device) - ) - start = end - - # ── [1, H, T, D]，.contiguous() ────────────────────────────────── - q_all = query.squeeze(0).permute(1, 0, 2).contiguous().unsqueeze(0) - k_all = key.squeeze(0).permute(1, 0, 2).contiguous().unsqueeze(0) - v_all = value.squeeze(0).permute(1, 0, 2).contiguous().unsqueeze(0) - - # ── GQA：展开 KV heads ──────────────────────────────────────────── - if k_all.shape[1] != q_all.shape[1]: - n = q_all.shape[1] // k_all.shape[1] - k_all = k_all.repeat_interleave(n, dim=1).contiguous() - v_all = v_all.repeat_interleave(n, dim=1).contiguous() - - # ── 纯数学 attention（float32 防溢出）──────────────────────────── - # [1, H, T, T] - attn_w = torch.matmul(q_all.float(), k_all.float().transpose(-2, -1)) - attn_w = attn_w * self.scale - attn_w = attn_w + mask # 加法广播：mask [T,T] → [1, H, T, T] - attn_w = torch.softmax(attn_w, dim=-1) - - out = torch.matmul(attn_w, v_all.float()).to(orig_dtype) - # [1, H, T, D] → [1, T, H, D] - return out.squeeze(0).permute(1, 0, 2).contiguous().unsqueeze(0) - -''' - -OLD_XFORMER_BLOCK = """\ - self.attn_op = xops.fmha.flash.FwOp() - if self.alibi_slopes is None: - # Add the batch dimension. - query = query.unsqueeze(0) - key = key.unsqueeze(0) - value = value.unsqueeze(0) - out = xops.memory_efficient_attention_forward( - query, - key, - value, - attn_bias=attn_bias[0], - p=0.0, - scale=self.scale, - op = self.attn_op - ) - return out.view_as(original_query)\ -""" - -NEW_XFORMER_BLOCK = """\ - self.attn_op = xops.fmha.flash.FwOp() - if self.alibi_slopes is None: - # Add the batch dimension. - query = query.unsqueeze(0) - key = key.unsqueeze(0) - value = value.unsqueeze(0) - if self.head_size > 128: - out = self._run_sdpa_fallback(query, key, value, attn_metadata) - else: - out = xops.memory_efficient_attention_forward( - query, - key, - value, - attn_bias=attn_bias[0], - p=0.0, - scale=self.scale, - op=self.attn_op, - ) - return out.view_as(original_query)\ -""" - -INJECT_ANCHOR = " def _run_memory_efficient_xformers_forward(" - +from patch_utils import package_root, replace_once +XFORMERS_PATH = package_root("vllm") / "attention" / "backends" / "xformers.py" + +FALLBACK_METHOD = ''' + def _run_sdpa_fallback( + self, + query: torch.Tensor, + key: torch.Tensor, + value: torch.Tensor, + attn_metadata: "XFormersMetadata", + ) -> torch.Tensor: + """批量纯数学 attention fallback。 + + 构建块对角 causal mask（等价于 ixformer BlockDiagonalCausalMask）， + 对整批序列一次 matmul + softmax，GPU 并行处理所有序列。 + + 块对角 mask 结构（seq1 len=3，seq2 len=2）： + s1,0 s1,1 s1,2 s2,0 s2,1 + s1,0 [ 0 -inf -inf -inf -inf ] + s1,1 [ 0 0 -inf -inf -inf ] + s1,2 [ 0 0 0 -inf -inf ] + s2,0 [-inf -inf -inf 0 -inf ] + s2,1 [-inf -inf -inf 0 0 ] + + softmax 在 float32 下计算防止 float16 溢出，结果转回原始 dtype。 + + Args: + query : [1, total_prefill_tokens, num_heads, head_dim] + key : [1, total_prefill_tokens, num_kv_heads, head_dim] + value : [1, total_prefill_tokens, num_kv_heads, head_dim] + Returns: + [1, total_prefill_tokens, num_heads, head_dim] + """ + assert attn_metadata.seq_lens is not None + orig_dtype = query.dtype + total_tokens = query.shape[1] + + # ── 构建块对角 causal mask [T, T] ──────────────────────────────── + # 全部初始化为 -inf，再对每条序列的对角块填入下三角 0 + mask = torch.full( + (total_tokens, total_tokens), + float("-inf"), + dtype=torch.float32, + device=query.device, + ) + start = 0 + for seq_len in attn_metadata.seq_lens: + end = start + seq_len + mask[start:end, start:end] = torch.tril( + torch.zeros(seq_len, seq_len, + dtype=torch.float32, device=query.device) + ) + start = end + + # ── [1, H, T, D]，.contiguous() ────────────────────────────────── + q_all = query.squeeze(0).permute(1, 0, 2).contiguous().unsqueeze(0) + k_all = key.squeeze(0).permute(1, 0, 2).contiguous().unsqueeze(0) + v_all = value.squeeze(0).permute(1, 0, 2).contiguous().unsqueeze(0) + + # ── GQA：展开 KV heads ──────────────────────────────────────────── + if k_all.shape[1] != q_all.shape[1]: + n = q_all.shape[1] // k_all.shape[1] + k_all = k_all.repeat_interleave(n, dim=1).contiguous() + v_all = v_all.repeat_interleave(n, dim=1).contiguous() + + # ── 纯数学 attention（float32 防溢出）──────────────────────────── + # [1, H, T, T] + attn_w = torch.matmul(q_all.float(), k_all.float().transpose(-2, -1)) + attn_w = attn_w * self.scale + attn_w = attn_w + mask # 加法广播：mask [T,T] → [1, H, T, T] + attn_w = torch.softmax(attn_w, dim=-1) + + out = torch.matmul(attn_w, v_all.float()).to(orig_dtype) + # [1, H, T, D] → [1, T, H, D] + return out.squeeze(0).permute(1, 0, 2).contiguous().unsqueeze(0) + +''' + +OLD_XFORMER_BLOCK = """\ + self.attn_op = xops.fmha.flash.FwOp() + if self.alibi_slopes is None: + # Add the batch dimension. + query = query.unsqueeze(0) + key = key.unsqueeze(0) + value = value.unsqueeze(0) + out = xops.memory_efficient_attention_forward( + query, + key, + value, + attn_bias=attn_bias[0], + p=0.0, + scale=self.scale, + op = self.attn_op + ) + return out.view_as(original_query)\ +""" + +NEW_XFORMER_BLOCK = """\ + self.attn_op = xops.fmha.flash.FwOp() + if self.alibi_slopes is None: + # Add the batch dimension. + query = query.unsqueeze(0) + key = key.unsqueeze(0) + value = value.unsqueeze(0) + if self.head_size > 128: + out = self._run_sdpa_fallback(query, key, value, attn_metadata) + else: + out = xops.memory_efficient_attention_forward( + query, + key, + value, + attn_bias=attn_bias[0], + p=0.0, + scale=self.scale, + op=self.attn_op, + ) + return out.view_as(original_query)\ +""" + +INJECT_ANCHOR = " def _run_memory_efficient_xformers_forward(" + + def patch_file(path): - with open(path, "r") as f: - content = f.read() - changed = False - - if "_run_sdpa_fallback" in content: - print(" [skip] _run_sdpa_fallback already present") - elif INJECT_ANCHOR not in content: - print(" [warn] inject anchor not found") - else: - content = content.replace(INJECT_ANCHOR, FALLBACK_METHOD + INJECT_ANCHOR, 1) - print(" [ok] injected _run_sdpa_fallback (batch, pure-math)") - changed = True - - if NEW_XFORMER_BLOCK in content: - print(" [skip] dispatch block already patched") - elif OLD_XFORMER_BLOCK in content: - content = content.replace(OLD_XFORMER_BLOCK, NEW_XFORMER_BLOCK, 1) - print(" [ok] patched dispatch block") - changed = True - else: - print(" [warn] dispatch block anchor not found") - - if changed: - with open(path, "w") as f: - f.write(content) - print(f" Written: {path}") - - -def main(): - print("=== patch_xformers_sdpa_batch (batch, pure-math) ===") - print(f"Target: {XFORMERS_PATH}") - patch_file(XFORMERS_PATH) - print("\nDone.") - - -if __name__ == "__main__": - main() + replace_once( + path, + INJECT_ANCHOR, + FALLBACK_METHOD + INJECT_ANCHOR, + required=True, + already_contains="def _run_sdpa_fallback(") + replace_once( + path, + OLD_XFORMER_BLOCK, + NEW_XFORMER_BLOCK, + required=True, + already_contains="out = self._run_sdpa_fallback(query, key, value, attn_metadata)") + + +def main(): + print("=== patch_xformers_sdpa_batch (batch, pure-math) ===") + print(f"Target: {XFORMERS_PATH}") + patch_file(XFORMERS_PATH) + print("\nDone.") + + +if __name__ == "__main__": + main() diff --git a/qwen3_6_scripts/patch_xformers_sdpa_batch_kernel.py b/qwen3_6_scripts/patch_xformers_sdpa_batch_kernel.py index e7f647ff..f5212087 100644 --- a/qwen3_6_scripts/patch_xformers_sdpa_batch_kernel.py +++ b/qwen3_6_scripts/patch_xformers_sdpa_batch_kernel.py @@ -1,191 +1,176 @@ -""" -策略：批量（block-diagonal）— F.scaled_dot_product_attention，可走硬件 kernel -============================================================================= -构建块对角 causal mask，对整批序列一次 F.scaled_dot_product_attention。 -与 patch_xformers_sdpa_batch.py（纯 matmul）的区别： - SDPA 会根据 PyTorch/驱动能力分发到最优 kernel（Flash Attention / - mem-efficient attention / math fallback），而不是固定走 cublas matmul。 - -历史说明： - 该方案最早因输出全"!"而被弃用，后续排查确认"!"由 mamba_cache.py bug - 引起，与 attention 实现无关。当前恢复此方案用于性能对比测试。 - -已知硬件限制（BI-V100）： - cudnnFlashAttnForward 不支持 is_causal=True（报错）。 - 本实现使用 is_causal=False + 显式块对角 additive mask 规避此限制。 - 若 SDPA 仍分发到有问题的 kernel，回退到 patch_xformers_sdpa_batch.py。 - -优点（vs 纯 matmul）： - SDPA 可分发到 Flash Attention kernel → O(L) 显存、更快的 CUDA kernel。 - -缺点： - 依赖硬件 kernel 行为，若 kernel 有 bug 则数值错误（需与 matmul 版对比验证）。 - +""" +策略：批量（block-diagonal）— F.scaled_dot_product_attention，可走硬件 kernel +============================================================================= +构建块对角 causal mask，对整批序列一次 F.scaled_dot_product_attention。 +与 patch_xformers_sdpa_batch.py（纯 matmul）的区别： + SDPA 会根据 PyTorch/驱动能力分发到最优 kernel（Flash Attention / + mem-efficient attention / math fallback），而不是固定走 cublas matmul。 + +历史说明： + 该方案最早因输出全"!"而被弃用，后续排查确认"!"由 mamba_cache.py bug + 引起，与 attention 实现无关。当前恢复此方案用于性能对比测试。 + +已知硬件限制（BI-V100）： + cudnnFlashAttnForward 不支持 is_causal=True（报错）。 + 本实现使用 is_causal=False + 显式块对角 additive mask 规避此限制。 + 若 SDPA 仍分发到有问题的 kernel，回退到 patch_xformers_sdpa_batch.py。 + +优点（vs 纯 matmul）： + SDPA 可分发到 Flash Attention kernel → O(L) 显存、更快的 CUDA kernel。 + +缺点： + 依赖硬件 kernel 行为，若 kernel 有 bug 则数值错误（需与 matmul 版对比验证）。 + Deploy: python3 modified_scripts/patch_xformers_sdpa_batch_kernel.py """ -XFORMERS_PATH = ( - "/usr/local/corex/lib64/python3/dist-packages/" - "vllm/attention/backends/xformers.py" -) - -FALLBACK_METHOD = ''' - def _run_sdpa_fallback( - self, - query: torch.Tensor, - key: torch.Tensor, - value: torch.Tensor, - attn_metadata: "XFormersMetadata", - ) -> torch.Tensor: - """批量 F.scaled_dot_product_attention fallback（可走硬件 kernel）。 - - 构建块对角 causal mask，对整批序列一次 SDPA 调用。 - SDPA 可分发到 Flash Attention / mem-efficient attention kernel。 - is_causal=False + 显式 additive mask，规避 cudnnFlashAttnForward - 不支持 is_causal=True 的限制。 - - 块对角 mask（seq1 len=3，seq2 len=2）： - s1,0 s1,1 s1,2 s2,0 s2,1 - s1,0 [ 0 -inf -inf -inf -inf ] - s1,1 [ 0 0 -inf -inf -inf ] - s1,2 [ 0 0 0 -inf -inf ] - s2,0 [-inf -inf -inf 0 -inf ] - s2,1 [-inf -inf -inf 0 0 ] - - Args: - query : [1, total_prefill_tokens, num_heads, head_dim] - key : [1, total_prefill_tokens, num_kv_heads, head_dim] - value : [1, total_prefill_tokens, num_kv_heads, head_dim] - Returns: - [1, total_prefill_tokens, num_heads, head_dim] - """ - import torch.nn.functional as F - - assert attn_metadata.seq_lens is not None - orig_dtype = query.dtype - total_tokens = query.shape[1] - - # ── 块对角 causal mask [T, T] ───────────────────────────────────── - mask = torch.full( - (total_tokens, total_tokens), - float("-inf"), - dtype=orig_dtype, - device=query.device, - ) - start = 0 - for seq_len in attn_metadata.seq_lens: - end = start + seq_len - mask[start:end, start:end] = torch.tril( - torch.zeros(seq_len, seq_len, dtype=orig_dtype, device=query.device) - ) - start = end - - # ── [1, H, T, D] ────────────────────────────────────────────────── - q_all = query.squeeze(0).permute(1, 0, 2).contiguous().unsqueeze(0) - k_all = key.squeeze(0).permute(1, 0, 2).contiguous().unsqueeze(0) - v_all = value.squeeze(0).permute(1, 0, 2).contiguous().unsqueeze(0) - - # ── GQA：展开 KV heads ──────────────────────────────────────────── - if k_all.shape[1] != q_all.shape[1]: - n = q_all.shape[1] // k_all.shape[1] - k_all = k_all.repeat_interleave(n, dim=1).contiguous() - v_all = v_all.repeat_interleave(n, dim=1).contiguous() - - # ── F.scaled_dot_product_attention（可走硬件 kernel）───────────── - # is_causal=False：避免 cudnnFlashAttnForward "not support causal mode" - # attn_mask 传 additive float mask（非 bool），SDPA 选择 math/kernel 路径 - out = F.scaled_dot_product_attention( - q_all, k_all, v_all, - attn_mask=mask, - dropout_p=0.0, - is_causal=False, - scale=self.scale, - ) - # [1, H, T, D] → [1, T, H, D] - return out.squeeze(0).permute(1, 0, 2).contiguous().unsqueeze(0) - -''' - -OLD_XFORMER_BLOCK = """\ - self.attn_op = xops.fmha.flash.FwOp() - if self.alibi_slopes is None: - # Add the batch dimension. - query = query.unsqueeze(0) - key = key.unsqueeze(0) - value = value.unsqueeze(0) - out = xops.memory_efficient_attention_forward( - query, - key, - value, - attn_bias=attn_bias[0], - p=0.0, - scale=self.scale, - op = self.attn_op - ) - return out.view_as(original_query)\ -""" - -NEW_XFORMER_BLOCK = """\ - self.attn_op = xops.fmha.flash.FwOp() - if self.alibi_slopes is None: - # Add the batch dimension. - query = query.unsqueeze(0) - key = key.unsqueeze(0) - value = value.unsqueeze(0) - if self.head_size > 128: - out = self._run_sdpa_fallback(query, key, value, attn_metadata) - else: - out = xops.memory_efficient_attention_forward( - query, - key, - value, - attn_bias=attn_bias[0], - p=0.0, - scale=self.scale, - op=self.attn_op, - ) - return out.view_as(original_query)\ -""" - -INJECT_ANCHOR = " def _run_memory_efficient_xformers_forward(" - +from patch_utils import package_root, replace_once +XFORMERS_PATH = package_root("vllm") / "attention" / "backends" / "xformers.py" + +FALLBACK_METHOD = ''' + def _run_sdpa_fallback( + self, + query: torch.Tensor, + key: torch.Tensor, + value: torch.Tensor, + attn_metadata: "XFormersMetadata", + ) -> torch.Tensor: + """批量 F.scaled_dot_product_attention fallback（可走硬件 kernel）。 + + 构建块对角 causal mask，对整批序列一次 SDPA 调用。 + SDPA 可分发到 Flash Attention / mem-efficient attention kernel。 + is_causal=False + 显式 additive mask，规避 cudnnFlashAttnForward + 不支持 is_causal=True 的限制。 + + 块对角 mask（seq1 len=3，seq2 len=2）： + s1,0 s1,1 s1,2 s2,0 s2,1 + s1,0 [ 0 -inf -inf -inf -inf ] + s1,1 [ 0 0 -inf -inf -inf ] + s1,2 [ 0 0 0 -inf -inf ] + s2,0 [-inf -inf -inf 0 -inf ] + s2,1 [-inf -inf -inf 0 0 ] + + Args: + query : [1, total_prefill_tokens, num_heads, head_dim] + key : [1, total_prefill_tokens, num_kv_heads, head_dim] + value : [1, total_prefill_tokens, num_kv_heads, head_dim] + Returns: + [1, total_prefill_tokens, num_heads, head_dim] + """ + import torch.nn.functional as F + + assert attn_metadata.seq_lens is not None + orig_dtype = query.dtype + total_tokens = query.shape[1] + + # ── 块对角 causal mask [T, T] ───────────────────────────────────── + mask = torch.full( + (total_tokens, total_tokens), + float("-inf"), + dtype=orig_dtype, + device=query.device, + ) + start = 0 + for seq_len in attn_metadata.seq_lens: + end = start + seq_len + mask[start:end, start:end] = torch.tril( + torch.zeros(seq_len, seq_len, dtype=orig_dtype, device=query.device) + ) + start = end + + # ── [1, H, T, D] ────────────────────────────────────────────────── + q_all = query.squeeze(0).permute(1, 0, 2).contiguous().unsqueeze(0) + k_all = key.squeeze(0).permute(1, 0, 2).contiguous().unsqueeze(0) + v_all = value.squeeze(0).permute(1, 0, 2).contiguous().unsqueeze(0) + + # ── GQA：展开 KV heads ──────────────────────────────────────────── + if k_all.shape[1] != q_all.shape[1]: + n = q_all.shape[1] // k_all.shape[1] + k_all = k_all.repeat_interleave(n, dim=1).contiguous() + v_all = v_all.repeat_interleave(n, dim=1).contiguous() + + # ── F.scaled_dot_product_attention（可走硬件 kernel）───────────── + # is_causal=False：避免 cudnnFlashAttnForward "not support causal mode" + # attn_mask 传 additive float mask（非 bool），SDPA 选择 math/kernel 路径 + out = F.scaled_dot_product_attention( + q_all, k_all, v_all, + attn_mask=mask, + dropout_p=0.0, + is_causal=False, + scale=self.scale, + ) + # [1, H, T, D] → [1, T, H, D] + return out.squeeze(0).permute(1, 0, 2).contiguous().unsqueeze(0) + +''' + +OLD_XFORMER_BLOCK = """\ + self.attn_op = xops.fmha.flash.FwOp() + if self.alibi_slopes is None: + # Add the batch dimension. + query = query.unsqueeze(0) + key = key.unsqueeze(0) + value = value.unsqueeze(0) + out = xops.memory_efficient_attention_forward( + query, + key, + value, + attn_bias=attn_bias[0], + p=0.0, + scale=self.scale, + op = self.attn_op + ) + return out.view_as(original_query)\ +""" + +NEW_XFORMER_BLOCK = """\ + self.attn_op = xops.fmha.flash.FwOp() + if self.alibi_slopes is None: + # Add the batch dimension. + query = query.unsqueeze(0) + key = key.unsqueeze(0) + value = value.unsqueeze(0) + if self.head_size > 128: + out = self._run_sdpa_fallback(query, key, value, attn_metadata) + else: + out = xops.memory_efficient_attention_forward( + query, + key, + value, + attn_bias=attn_bias[0], + p=0.0, + scale=self.scale, + op=self.attn_op, + ) + return out.view_as(original_query)\ +""" + +INJECT_ANCHOR = " def _run_memory_efficient_xformers_forward(" + + def patch_file(path): - with open(path, "r") as f: - content = f.read() - changed = False - - if "_run_sdpa_fallback" in content: - print(" [skip] _run_sdpa_fallback already present") - elif INJECT_ANCHOR not in content: - print(" [warn] inject anchor not found") - else: - content = content.replace(INJECT_ANCHOR, FALLBACK_METHOD + INJECT_ANCHOR, 1) - print(" [ok] injected _run_sdpa_fallback (batch, F.sdpa kernel)") - changed = True - - if NEW_XFORMER_BLOCK in content: - print(" [skip] dispatch block already patched") - elif OLD_XFORMER_BLOCK in content: - content = content.replace(OLD_XFORMER_BLOCK, NEW_XFORMER_BLOCK, 1) - print(" [ok] patched dispatch block") - changed = True - else: - print(" [warn] dispatch block anchor not found") - - if changed: - with open(path, "w") as f: - f.write(content) - print(f" Written: {path}") - - -def main(): - print("=== patch_xformers_sdpa_batch_kernel (batch, F.sdpa + kernel dispatch) ===") - print(f"Target: {XFORMERS_PATH}") - patch_file(XFORMERS_PATH) - print("\nDone.") - - -if __name__ == "__main__": - main() + replace_once( + path, + INJECT_ANCHOR, + FALLBACK_METHOD + INJECT_ANCHOR, + required=True, + already_contains="def _run_sdpa_fallback(") + replace_once( + path, + OLD_XFORMER_BLOCK, + NEW_XFORMER_BLOCK, + required=True, + already_contains="out = self._run_sdpa_fallback(query, key, value, attn_metadata)") + + +def main(): + print("=== patch_xformers_sdpa_batch_kernel (batch, F.sdpa + kernel dispatch) ===") + print(f"Target: {XFORMERS_PATH}") + patch_file(XFORMERS_PATH) + print("\nDone.") + + +if __name__ == "__main__": + main() diff --git a/qwen3_6_scripts/patch_xformers_sdpa_seq.py b/qwen3_6_scripts/patch_xformers_sdpa_seq.py index 496abc1f..05d97338 100644 --- a/qwen3_6_scripts/patch_xformers_sdpa_seq.py +++ b/qwen3_6_scripts/patch_xformers_sdpa_seq.py @@ -1,321 +1,427 @@ -""" -策略：顺序（per-sequence）fallback — 纯 PyTorch 数学实现 -========================================================== -逐条序列用 matmul + softmax 手写 attention，完全绕开所有硬件 -flash attention kernel（ixformer / cudnnFlashAttnForward）。 - -背景： - Iluvatar cudnnFlashAttnForward 存在两个已知问题： - 1. 不支持 is_causal=True（报错） - 2. 使用 attn_mask 路径时数值结果不正确（静默错误，输出全为"!"） - 与华为昇腾 910B4 上 llama.cpp --flash-attn off 修复同类问题的原理相同。 - 纯数学路径（matmul + softmax）在任何 PyTorch 后端上结果都正确。 - -优点： - 数值正确，不依赖任何硬件特定 attention kernel。 - 峰值显存 = max(seq_len)² × H × dtype_size，由 --max-model-len 控制。 - -缺点： - 并发请求的 prefill attention 串行执行。 - O(L²) 显存（无 flash attention 的 O(L) 优化）。 - -内存参考（fp16，H_local=6）： - max-model-len=4096 → 峰值 ~200 MB - max-model-len=8192 → 峰值 ~800 MB - max-model-len=16384 → 峰值 ~3.2 GB - -额外 patch（arg_utils.py）： - vllm 0.6.3 在 max_model_len > 32K 时会自动开启 chunked prefill（无命令行 - 关闭选项），原意是防止 profiling OOM。但 _run_sdpa_fallback 已通过 Q-tiling - 解决了该问题，chunked prefill 反而会把推理路径从 _run_sdpa_fallback 切换到 - _forward_prefix_pytorch，属于不必要的行为变更，因此一并禁用该自动逻辑。 - -Deploy: - python3 modified_scripts/patch_xformers_sdpa_seq.py -""" - -XFORMERS_PATH = ( - "/usr/local/corex/lib64/python3/dist-packages/" - "vllm/attention/backends/xformers.py" -) - -ARG_UTILS_PATH = ( - "/usr/local/corex/lib64/python3/dist-packages/" - "vllm/engine/arg_utils.py" -) +""" +策略：顺序（per-sequence）fallback — 纯 PyTorch 数学实现 +========================================================== +逐条序列用 matmul + softmax 手写 attention，完全绕开所有硬件 +flash attention kernel（ixformer / cudnnFlashAttnForward）。 + +背景： + Iluvatar cudnnFlashAttnForward 存在两个已知问题： + 1. 不支持 is_causal=True（报错） + 2. 使用 attn_mask 路径时数值结果不正确（静默错误，输出全为"!"） + 与华为昇腾 910B4 上 llama.cpp --flash-attn off 修复同类问题的原理相同。 + 纯数学路径（matmul + softmax）在任何 PyTorch 后端上结果都正确。 + +优点： + 数值正确，不依赖任何硬件特定 attention kernel。 + 峰值显存 = max(seq_len)² × H × dtype_size，由 --max-model-len 控制。 + +缺点： + 并发请求的 prefill attention 串行执行。 + O(L²) 显存（无 flash attention 的 O(L) 优化）。 + +内存参考（fp16，H_local=6）： + max-model-len=4096 → 峰值 ~200 MB + max-model-len=8192 → 峰值 ~800 MB + max-model-len=16384 → 峰值 ~3.2 GB + +额外 patch（arg_utils.py）： + vllm 0.6.3 在 max_model_len > 32K 时会自动开启 chunked prefill（无命令行 + 关闭选项），原意是防止 profiling OOM。但 _run_sdpa_fallback 已通过 Q-tiling + 解决了该问题，chunked prefill 反而会把推理路径从 _run_sdpa_fallback 切换到 + _forward_prefix_pytorch，属于不必要的行为变更，因此一并禁用该自动逻辑。 + +Deploy: + python3 modified_scripts/patch_xformers_sdpa_seq.py +""" + +from patch_utils import package_root, replace_one_of, replace_once +VLLM_ROOT = package_root("vllm") +XFORMERS_PATH = VLLM_ROOT / "attention" / "backends" / "xformers.py" +ARG_UTILS_PATH = VLLM_ROOT / "engine" / "arg_utils.py" LOGITS_PROC_PATH = ( - "/usr/local/corex/lib64/python3/dist-packages/" - "vllm/model_executor/layers/logits_processor.py" -) - -# _apply_logits_processors crashes when seq_groups is None (intermediate -# chunked-prefill chunks on the driver rank). Add an early-return guard. -_LP_OLD_BLOCK = """\ -def _apply_logits_processors( - logits: torch.Tensor, - sampling_metadata: SamplingMetadata, -) -> torch.Tensor: - found_logits_processors = False\ -""" - + VLLM_ROOT / "model_executor" / "layers" / "logits_processor.py") +OUTLINES_DECODING_PATH = ( + VLLM_ROOT / "model_executor" / "guided_decoding" / + "outlines_decoding.py") + +# _apply_logits_processors crashes when seq_groups is None (intermediate +# chunked-prefill chunks on the driver rank). Add an early-return guard. +_LP_OLD_BLOCK = """\ +def _apply_logits_processors( + logits: torch.Tensor, + sampling_metadata: SamplingMetadata, +) -> torch.Tensor: + found_logits_processors = False\ +""" + _LP_NEW_BLOCK = """\ -def _apply_logits_processors( - logits: torch.Tensor, - sampling_metadata: SamplingMetadata, -) -> torch.Tensor: - if sampling_metadata.seq_groups is None: # intermediate chunked-prefill chunk - return logits +def _apply_logits_processors( + logits: torch.Tensor, + sampling_metadata: SamplingMetadata, +) -> torch.Tensor: + if sampling_metadata.seq_groups is None: # intermediate chunked-prefill chunk + return logits found_logits_processors = False\ """ -# vllm 0.6.3 自动开启 chunked prefill 的原始块 -_ARG_OLD_BLOCK = """\ - if (is_gpu and not use_sliding_window and not use_spec_decode - and not self.enable_lora - and not self.enable_prompt_adapter): - self.enable_chunked_prefill = True - logger.warning( - "Chunked prefill is enabled by default for models with " - "max_model_len > 32K. Currently, chunked prefill might " - "not work with some features or models. If you " - "encounter any issues, please disable chunked prefill " - "by setting --enable-chunked-prefill=False.")\ +# Outlines' UNESCAPED_STRING accepts raw JSON control characters, including +# newlines and tabs. The generated text can therefore satisfy the CFG while +# still failing json.loads(). Use the RFC 8259 string character constraints. +_JSON_STRING_OLD_BLOCK = """\ +| UNESCAPED_STRING +| SIGNED_NUMBER -> number +| "true" -> true +| "false" -> false +| "null" -> null + +array : "[" [value ("," value)*] "]" +object : "{" [pair ("," pair)*] "}" +pair : UNESCAPED_STRING ":" value + +%import common.UNESCAPED_STRING +%import common.SIGNED_NUMBER +%import common.WS + +%ignore WS\ """ +_JSON_STRING_V1_BLOCK = r'''| JSON_STRING +| SIGNED_NUMBER -> number +| "true" -> true +| "false" -> false +| "null" -> null + +array : "[" [value ("," value)*] "]" +object : "{" [pair ("," pair)*] "}" +pair : JSON_STRING ":" value + +JSON_STRING: /"(\\["\\\/bfnrt]|\\u[0-9a-fA-F]{4}|[^"\\\x00-\x1f])*"/ +%import common.SIGNED_NUMBER +%import common.WS + +%ignore WS''' + +_JSON_STRING_NEW_BLOCK = r'''| JSON_STRING +| SIGNED_NUMBER -> number +| "true" -> true +| "false" -> false +| "null" -> null + +array : "[" _ws [value (_ws "," _ws value)*] _ws "]" +object : "{" _ws [pair (_ws "," _ws pair)*] _ws "}" +pair : JSON_STRING _ws ":" _ws value +_ws : JSON_WS? + +JSON_STRING: /"(\\["\\\/bfnrt]|\\u[0-9a-fA-F]{4}|[^"\\\x00-\x1f])*"/ +JSON_WS: /[ \t\r\n]{1,4}/ +%import common.SIGNED_NUMBER''' + +# vllm 0.6.3 自动开启 chunked prefill 的原始块 +_ARG_OLD_BLOCK = """\ + if (is_gpu and not use_sliding_window and not use_spec_decode + and not self.enable_lora + and not self.enable_prompt_adapter): + self.enable_chunked_prefill = True + logger.warning( + "Chunked prefill is enabled by default for models with " + "max_model_len > 32K. Currently, chunked prefill might " + "not work with some features or models. If you " + "encounter any issues, please disable chunked prefill " + "by setting --enable-chunked-prefill=False.")\ +""" + _ARG_NEW_BLOCK = """\ - if (is_gpu and not use_sliding_window and not use_spec_decode - and not self.enable_lora - and not self.enable_prompt_adapter): - pass # skip auto-enable: Q-tiling in _run_sdpa_fallback + if (is_gpu and not use_sliding_window and not use_spec_decode + and not self.enable_lora + and not self.enable_prompt_adapter): + pass # skip auto-enable: Q-tiling in _run_sdpa_fallback # handles long-context memory without chunked prefill\ """ -FALLBACK_METHOD = ''' - def _run_sdpa_fallback( - self, - query: torch.Tensor, - key: torch.Tensor, - value: torch.Tensor, - attn_metadata: "XFormersMetadata", - ) -> torch.Tensor: - """纯数学 causal attention fallback，带 Q-tiling 内存优化。 - - 调用时机：kv_cache.numel()==0（profiling 阶段）。 - 此路径无 KV 缓存前缀，KV 长度 == query 长度。 - - 内存优化（Q-tiling，与 Flash Attention 同思路）： - 将 Q 分成 _Q_CHUNK 大小的子块逐块计算，每块峰值内存 - O(_Q_CHUNK × q_len) 而非 O(q_len²)。 - profiling 阶段序列可能达到 max_model_len（如 20K tokens）， - 不加 Q-tiling 会产生 9.6 GB 矩阵直接 OOM。 - - softmax 在 float32 下计算以防止 float16 溢出，结果转回原始 dtype。 - - Args: - query : [1, total_query_tokens, num_heads, head_dim] - key : [1, total_query_tokens, num_kv_heads, head_dim] - value : [1, total_query_tokens, num_kv_heads, head_dim] - Returns: - [1, total_query_tokens, num_heads, head_dim] - """ - _Q_CHUNK = 256 # 与 _forward_prefix_pytorch 的 _ATTN_Q_CHUNK 保持一致 - - assert attn_metadata.seq_lens is not None - orig_dtype = query.dtype - num_seqs = len(attn_metadata.seq_lens) - - # 推导每条序列的实际 query 长度。 - # 正常 prefill 时 q_len == seq_len；如果将来遇到 chunked 场景， - # query_start_loc 记录的是真实 query token 数（非全序列长度）。 - if (attn_metadata.query_start_loc is not None - and len(attn_metadata.query_start_loc) == num_seqs + 1): - q_lens = [ - int(attn_metadata.query_start_loc[i + 1].item()) - - int(attn_metadata.query_start_loc[i].item()) - for i in range(num_seqs) - ] - else: - q_lens = list(attn_metadata.seq_lens) - - q_flat = query.squeeze(0) # [T, H, D] - k_flat = key.squeeze(0) # [T, Hkv, D] - v_flat = value.squeeze(0) - - output = torch.empty_like(q_flat) - seq_start = 0 - for q_len in q_lens: - seq_end = seq_start + q_len - - # 当前序列的完整 K/V（此路径无前缀，KV == Q） - k_s = k_flat[seq_start:seq_end].permute(1, 0, 2).float() # [Hkv, q_len, D] - v_s = v_flat[seq_start:seq_end].permute(1, 0, 2).float() # [Hkv, q_len, D] - - # GQA：展开 KV heads 至与 query heads 一致 - if k_s.shape[0] != self.num_heads: - n = self.num_heads // k_s.shape[0] - k_s = k_s.repeat_interleave(n, dim=0).contiguous() - v_s = v_s.repeat_interleave(n, dim=0).contiguous() - - # k_pos 用于因果掩码 - k_pos = torch.arange(q_len, device=query.device) - - # Q-tiling：分块处理 query，峰值内存 O(_Q_CHUNK × q_len) - for qc_start in range(0, q_len, _Q_CHUNK): - qc_end = min(qc_start + _Q_CHUNK, q_len) - - # [H, qc, D] - q_c = q_flat[seq_start + qc_start:seq_start + qc_end] \ - .permute(1, 0, 2).float() - - # [H, qc, q_len] - attn_w = torch.matmul(q_c, k_s.transpose(-2, -1)) * self.scale - - # 因果掩码：q_c 里位置 j 只能看 k_pos <= j（相对位置） - qc_q_pos = torch.arange(qc_start, qc_end, device=query.device) - mask = k_pos.unsqueeze(0) > qc_q_pos.unsqueeze(1) - attn_w = attn_w.masked_fill(mask.unsqueeze(0), float("-inf")) - - attn_w = torch.softmax(attn_w, dim=-1) - out_c = torch.matmul(attn_w, v_s).to(orig_dtype) # [H, qc, D] - - output[seq_start + qc_start:seq_start + qc_end] = ( - out_c.permute(1, 0, 2)) - - seq_start = seq_end - - return output.unsqueeze(0) # [1, T, H, D] - -''' - -OLD_XFORMER_BLOCK = """\ - self.attn_op = xops.fmha.flash.FwOp() - if self.alibi_slopes is None: - # Add the batch dimension. - query = query.unsqueeze(0) - key = key.unsqueeze(0) - value = value.unsqueeze(0) - out = xops.memory_efficient_attention_forward( - query, - key, - value, - attn_bias=attn_bias[0], - p=0.0, - scale=self.scale, - op = self.attn_op - ) - return out.view_as(original_query)\ +_MM_PREFIX_OLD_BLOCK = """\ + if model_config.is_multimodal_model: + if self.enable_prefix_caching: + logger.warning( + "--enable-prefix-caching is currently not " + "supported for multimodal models and has been disabled.") + self.enable_prefix_caching = False\ """ -NEW_XFORMER_BLOCK = """\ - self.attn_op = xops.fmha.flash.FwOp() - if self.alibi_slopes is None: - # Add the batch dimension. - query = query.unsqueeze(0) - key = key.unsqueeze(0) - value = value.unsqueeze(0) - if self.head_size > 128: - out = self._run_sdpa_fallback(query, key, value, attn_metadata) - else: - out = xops.memory_efficient_attention_forward( +_MM_PREFIX_NEW_BLOCK = """\ + if model_config.is_multimodal_model: + architectures = getattr(model_config.hf_config, + "architectures", []) or [] + qwen36_native_vision = "Qwen3_5MoeForCausalLM" in architectures + if self.enable_prefix_caching and qwen36_native_vision: + logger.info( + "Keeping prefix caching enabled for the Qwen3.6 native " + "vision path.") + elif self.enable_prefix_caching: + logger.warning( + "--enable-prefix-caching is currently not " + "supported for multimodal models and has been disabled.") + self.enable_prefix_caching = False\ +""" + +FALLBACK_METHOD = ''' + def _run_sdpa_fallback( + self, + query: torch.Tensor, + key: torch.Tensor, + value: torch.Tensor, + attn_metadata: "XFormersMetadata", + ) -> torch.Tensor: + """纯数学 causal attention fallback，带 Q-tiling 内存优化。 + + 调用时机：kv_cache.numel()==0（profiling 阶段）。 + 此路径无 KV 缓存前缀，KV 长度 == query 长度。 + + 内存优化（Q-tiling，与 Flash Attention 同思路）： + 将 Q 分成 _Q_CHUNK 大小的子块逐块计算，每块峰值内存 + O(_Q_CHUNK × q_len) 而非 O(q_len²)。 + profiling 阶段序列可能达到 max_model_len（如 20K tokens）， + 不加 Q-tiling 会产生 9.6 GB 矩阵直接 OOM。 + + softmax 在 float32 下计算以防止 float16 溢出，结果转回原始 dtype。 + + Args: + query : [1, total_query_tokens, num_heads, head_dim] + key : [1, total_query_tokens, num_kv_heads, head_dim] + value : [1, total_query_tokens, num_kv_heads, head_dim] + Returns: + [1, total_query_tokens, num_heads, head_dim] + """ + _Q_CHUNK = 256 # 与 _forward_prefix_pytorch 的 _ATTN_Q_CHUNK 保持一致 + + assert attn_metadata.seq_lens is not None + orig_dtype = query.dtype + num_seqs = len(attn_metadata.seq_lens) + + # 推导每条序列的实际 query 长度。 + # 正常 prefill 时 q_len == seq_len；如果将来遇到 chunked 场景， + # query_start_loc 记录的是真实 query token 数（非全序列长度）。 + if (attn_metadata.query_start_loc is not None + and len(attn_metadata.query_start_loc) == num_seqs + 1): + q_lens = [ + int(attn_metadata.query_start_loc[i + 1].item()) - + int(attn_metadata.query_start_loc[i].item()) + for i in range(num_seqs) + ] + else: + q_lens = list(attn_metadata.seq_lens) + + q_flat = query.squeeze(0) # [T, H, D] + k_flat = key.squeeze(0) # [T, Hkv, D] + v_flat = value.squeeze(0) + + output = torch.empty_like(q_flat) + seq_start = 0 + for q_len in q_lens: + seq_end = seq_start + q_len + + # 当前序列的完整 K/V（此路径无前缀，KV == Q） + k_s = k_flat[seq_start:seq_end].permute(1, 0, 2).float() # [Hkv, q_len, D] + v_s = v_flat[seq_start:seq_end].permute(1, 0, 2).float() # [Hkv, q_len, D] + + # GQA：展开 KV heads 至与 query heads 一致 + if k_s.shape[0] != self.num_heads: + n = self.num_heads // k_s.shape[0] + k_s = k_s.repeat_interleave(n, dim=0).contiguous() + v_s = v_s.repeat_interleave(n, dim=0).contiguous() + + # k_pos 用于因果掩码 + k_pos = torch.arange(q_len, device=query.device) + + # Q-tiling：分块处理 query，峰值内存 O(_Q_CHUNK × q_len) + for qc_start in range(0, q_len, _Q_CHUNK): + qc_end = min(qc_start + _Q_CHUNK, q_len) + + # [H, qc, D] + q_c = q_flat[seq_start + qc_start:seq_start + qc_end] \ + .permute(1, 0, 2).float() + + # [H, qc, q_len] + attn_w = torch.matmul(q_c, k_s.transpose(-2, -1)) * self.scale + + # 因果掩码：q_c 里位置 j 只能看 k_pos <= j（相对位置） + qc_q_pos = torch.arange(qc_start, qc_end, device=query.device) + mask = k_pos.unsqueeze(0) > qc_q_pos.unsqueeze(1) + attn_w = attn_w.masked_fill(mask.unsqueeze(0), float("-inf")) + + attn_w = torch.softmax(attn_w, dim=-1) + out_c = torch.matmul(attn_w, v_s).to(orig_dtype) # [H, qc, D] + + output[seq_start + qc_start:seq_start + qc_end] = ( + out_c.permute(1, 0, 2)) + + seq_start = seq_end + + return output.unsqueeze(0) # [1, T, H, D] + +''' + +OLD_XFORMER_BLOCK = """\ + self.attn_op = xops.fmha.flash.FwOp() + if self.alibi_slopes is None: + # Add the batch dimension. + query = query.unsqueeze(0) + key = key.unsqueeze(0) + value = value.unsqueeze(0) + out = xops.memory_efficient_attention_forward( + query, + key, + value, + attn_bias=attn_bias[0], + p=0.0, + scale=self.scale, + op = self.attn_op + ) + return out.view_as(original_query)\ +""" + +NEW_XFORMER_BLOCK = """\ + self.attn_op = xops.fmha.flash.FwOp() + if self.alibi_slopes is None: + # Add the batch dimension. + query = query.unsqueeze(0) + key = key.unsqueeze(0) + value = value.unsqueeze(0) + if self.head_size > 128: + out = self._run_sdpa_fallback(query, key, value, attn_metadata) + else: + out = xops.memory_efficient_attention_forward( + query, + key, + value, + attn_bias=attn_bias[0], + p=0.0, + scale=self.scale, + op=self.attn_op, + ) + return out.view_as(original_query)\ +""" + +INJECT_ANCHOR = " def _run_memory_efficient_xformers_forward(" + +_PREFIX_CALL_OLD_BLOCK = """\ + out = PagedAttention.forward_prefix( query, key, value, - attn_bias=attn_bias[0], - p=0.0, - scale=self.scale, - op=self.attn_op, - ) - return out.view_as(original_query)\ + self.kv_cache_dtype, + key_cache, + value_cache, + prefill_meta.block_tables, + prefill_meta.query_start_loc, + prefill_meta.seq_lens_tensor, + prefill_meta.context_lens_tensor, + prefill_meta.max_query_len, + self.alibi_slopes, + self.sliding_window, + k_scale, + v_scale, + )\ """ -INJECT_ANCHOR = " def _run_memory_efficient_xformers_forward(" +_PREFIX_CALL_NEW_BLOCK = """\ + out = PagedAttention.forward_prefix( + query, + key, + value, + self.kv_cache_dtype, + key_cache, + value_cache, + prefill_meta.block_tables, + prefill_meta.query_start_loc, + prefill_meta.seq_lens_tensor, + prefill_meta.context_lens_tensor, + prefill_meta.max_query_len, + self.alibi_slopes, + self.sliding_window, + k_scale, + v_scale, + is_causal_decoder=(attn_type == AttentionType.DECODER), + )\ +""" def patch_file(path): - with open(path, "r") as f: - content = f.read() - changed = False - - if "_run_sdpa_fallback" in content: - print(" [skip] _run_sdpa_fallback already present") - elif INJECT_ANCHOR not in content: - print(" [warn] inject anchor not found") - else: - content = content.replace(INJECT_ANCHOR, FALLBACK_METHOD + INJECT_ANCHOR, 1) - print(" [ok] injected _run_sdpa_fallback (sequential, pure-math)") - changed = True - - if NEW_XFORMER_BLOCK in content: - print(" [skip] dispatch block already patched") - elif OLD_XFORMER_BLOCK in content: - content = content.replace(OLD_XFORMER_BLOCK, NEW_XFORMER_BLOCK, 1) - print(" [ok] patched dispatch block") - changed = True - else: - print(" [warn] dispatch block anchor not found") - - if changed: - with open(path, "w") as f: - f.write(content) - print(f" Written: {path}") - - + replace_once( + path, + INJECT_ANCHOR, + FALLBACK_METHOD + INJECT_ANCHOR, + required=True, + already_contains="def _run_sdpa_fallback(") + replace_once( + path, + OLD_XFORMER_BLOCK, + NEW_XFORMER_BLOCK, + required=True, + already_contains="out = self._run_sdpa_fallback(query, key, value, attn_metadata)") + replace_once( + path, + _PREFIX_CALL_OLD_BLOCK, + _PREFIX_CALL_NEW_BLOCK, + required=True, + already_contains=( + "is_causal_decoder=(attn_type == AttentionType.DECODER)")) + + def patch_arg_utils(path): - with open(path, "r") as f: - content = f.read() - changed = False - - if "skip auto-enable: Q-tiling" in content: - print(" [skip] chunked-prefill auto-enable already disabled") - elif _ARG_OLD_BLOCK in content: - content = content.replace(_ARG_OLD_BLOCK, _ARG_NEW_BLOCK, 1) - print(" [ok] disabled chunked-prefill auto-enable for 32K+") - changed = True - else: - print(" [warn] target block not found — check arg_utils.py version") - - if changed: - with open(path, "w") as f: - f.write(content) - print(f" Written: {path}") - - + replace_once( + path, + _ARG_OLD_BLOCK, + _ARG_NEW_BLOCK, + required=True, + already_contains="skip auto-enable: Q-tiling") + replace_once( + path, + _MM_PREFIX_OLD_BLOCK, + _MM_PREFIX_NEW_BLOCK, + required=True, + already_contains="Keeping prefix caching enabled for the Qwen3.6") + + def patch_logits_processor(path): - with open(path, "r") as f: - content = f.read() - changed = False - - if "intermediate chunked-prefill chunk" in content: - print(" [skip] seq_groups=None guard already present") - elif _LP_OLD_BLOCK in content: - content = content.replace(_LP_OLD_BLOCK, _LP_NEW_BLOCK, 1) - print(" [ok] added seq_groups=None guard in _apply_logits_processors") - changed = True - else: - print(" [warn] target block not found — check logits_processor.py version") - - if changed: - with open(path, "w") as f: - f.write(content) - print(f" Written: {path}") + replace_once( + path, + _LP_OLD_BLOCK, + _LP_NEW_BLOCK, + required=True, + already_contains="intermediate chunked-prefill chunk") -def main(): - print("=== patch_xformers_sdpa_seq (sequential, pure-math) ===") - print(f"Target: {XFORMERS_PATH}") - patch_file(XFORMERS_PATH) - - print("\n=== patch_arg_utils (disable chunked-prefill auto-enable) ===") - print(f"Target: {ARG_UTILS_PATH}") - patch_arg_utils(ARG_UTILS_PATH) - - print("\n=== patch_logits_processor (seq_groups=None guard for chunked prefill) ===") +def patch_outlines_json_grammar(path): + replace_one_of( + path, + [ + (_JSON_STRING_V1_BLOCK, _JSON_STRING_NEW_BLOCK), + (_JSON_STRING_OLD_BLOCK, _JSON_STRING_NEW_BLOCK), + ], + required=True, + already_contains="JSON_WS:") + + +def main(): + print("=== patch_xformers_sdpa_seq (sequential, pure-math) ===") + print(f"Target: {XFORMERS_PATH}") + patch_file(XFORMERS_PATH) + + print("\n=== patch_arg_utils (disable chunked-prefill auto-enable) ===") + print(f"Target: {ARG_UTILS_PATH}") + patch_arg_utils(ARG_UTILS_PATH) + + print("\n=== patch_logits_processor (seq_groups=None guard for chunked prefill) ===") print(f"Target: {LOGITS_PROC_PATH}") patch_logits_processor(LOGITS_PROC_PATH) - print("\nDone.") - - -if __name__ == "__main__": - main() + print("\n=== patch_outlines_json_grammar (reject raw control chars) ===") + print(f"Target: {OUTLINES_DECODING_PATH}") + patch_outlines_json_grammar(OUTLINES_DECODING_PATH) + + print("\nDone.") + + +if __name__ == "__main__": + main() diff --git a/qwen3_6_scripts/patch_xformers_sdpa_seq_kernel.py b/qwen3_6_scripts/patch_xformers_sdpa_seq_kernel.py index 82df8d09..39633d6d 100644 --- a/qwen3_6_scripts/patch_xformers_sdpa_seq_kernel.py +++ b/qwen3_6_scripts/patch_xformers_sdpa_seq_kernel.py @@ -1,181 +1,166 @@ -""" -策略：顺序（per-sequence）— F.scaled_dot_product_attention，可走硬件 kernel -============================================================================= -逐条序列调用 F.scaled_dot_product_attention，is_causal=False + 显式因果 mask。 -与 patch_xformers_sdpa_seq.py（纯 matmul）的区别： - SDPA 可分发到 Flash Attention / mem-efficient attention kernel， - 而纯 matmul 固定走 cublas。 - -硬件限制（BI-V100）： - cudnnFlashAttnForward 不支持 is_causal=True（直接报错）。 - 必须使用 is_causal=False + 显式 additive causal mask。 - 每条序列单独构造上三角 -inf mask，peak 显存 = max(seq_len)² × dtype， - 比 batch 版的 total_tokens² 小得多。 - -与 batch_kernel 的对比： - seq_kernel: 显存小，peak = max_single_seq²；并发 prefill 串行排队 - batch_kernel: 显存大，peak = total_tokens²；并发 prefill 一次并行处理， - 通过 --max-num-batched-tokens 控制 total_tokens 上限 - +""" +策略：顺序（per-sequence）— F.scaled_dot_product_attention，可走硬件 kernel +============================================================================= +逐条序列调用 F.scaled_dot_product_attention，is_causal=False + 显式因果 mask。 +与 patch_xformers_sdpa_seq.py（纯 matmul）的区别： + SDPA 可分发到 Flash Attention / mem-efficient attention kernel， + 而纯 matmul 固定走 cublas。 + +硬件限制（BI-V100）： + cudnnFlashAttnForward 不支持 is_causal=True（直接报错）。 + 必须使用 is_causal=False + 显式 additive causal mask。 + 每条序列单独构造上三角 -inf mask，peak 显存 = max(seq_len)² × dtype， + 比 batch 版的 total_tokens² 小得多。 + +与 batch_kernel 的对比： + seq_kernel: 显存小，peak = max_single_seq²；并发 prefill 串行排队 + batch_kernel: 显存大，peak = total_tokens²；并发 prefill 一次并行处理， + 通过 --max-num-batched-tokens 控制 total_tokens 上限 + Deploy: python3 modified_scripts/patch_xformers_sdpa_seq_kernel.py """ -XFORMERS_PATH = ( - "/usr/local/corex/lib64/python3/dist-packages/" - "vllm/attention/backends/xformers.py" -) - -FALLBACK_METHOD = ''' - def _run_sdpa_fallback( - self, - query: torch.Tensor, - key: torch.Tensor, - value: torch.Tensor, - attn_metadata: "XFormersMetadata", - ) -> torch.Tensor: - """顺序 F.scaled_dot_product_attention fallback（可走硬件 kernel）。 - - 逐条序列调用 SDPA，is_causal=False + 显式上三角 additive mask。 - cudnnFlashAttnForward 不支持 is_causal=True，必须用显式 mask。 - 逐序列构造 mask，peak 显存 = max(seq_len)² × dtype（远小于 batch 版）。 - - Args: - query : [1, total_prefill_tokens, num_heads, head_dim] - key : [1, total_prefill_tokens, num_kv_heads, head_dim] - value : [1, total_prefill_tokens, num_kv_heads, head_dim] - Returns: - [1, total_prefill_tokens, num_heads, head_dim] - """ - import torch.nn.functional as F - - assert attn_metadata.seq_lens is not None - orig_dtype = query.dtype - - q_flat = query.squeeze(0) # [T, H, D] - k_flat = key.squeeze(0) # [T, Hkv, D] - v_flat = value.squeeze(0) - - output = torch.empty_like(q_flat) - start = 0 - for seq_len in attn_metadata.seq_lens: - end = start + seq_len - # [1, H, L, D] - q_s = q_flat[start:end].permute(1, 0, 2).contiguous().unsqueeze(0) - k_s = k_flat[start:end].permute(1, 0, 2).contiguous().unsqueeze(0) - v_s = v_flat[start:end].permute(1, 0, 2).contiguous().unsqueeze(0) - - # GQA：展开 KV heads - if k_s.shape[1] != q_s.shape[1]: - n = q_s.shape[1] // k_s.shape[1] - k_s = k_s.repeat_interleave(n, dim=1).contiguous() - v_s = v_s.repeat_interleave(n, dim=1).contiguous() - - # 逐序列因果 mask [L, L]，上三角 -inf - causal_mask = torch.tril( - torch.zeros(seq_len, seq_len, dtype=orig_dtype, device=q_s.device) - ) - causal_mask = causal_mask.masked_fill( - torch.triu(torch.ones(seq_len, seq_len, dtype=torch.bool, - device=q_s.device), diagonal=1), - float("-inf"), - ) - - # is_causal=False + 显式 mask，规避 cudnnFlashAttnForward 不支持 is_causal=True - out_s = F.scaled_dot_product_attention( - q_s, k_s, v_s, - attn_mask=causal_mask, - dropout_p=0.0, - is_causal=False, - scale=self.scale, - ) - # [1, H, L, D] → [L, H, D] - output[start:end] = out_s.squeeze(0).permute(1, 0, 2).to(orig_dtype) - start = end - - return output.unsqueeze(0) # [1, T, H, D] - -''' - -OLD_XFORMER_BLOCK = """\ - self.attn_op = xops.fmha.flash.FwOp() - if self.alibi_slopes is None: - # Add the batch dimension. - query = query.unsqueeze(0) - key = key.unsqueeze(0) - value = value.unsqueeze(0) - out = xops.memory_efficient_attention_forward( - query, - key, - value, - attn_bias=attn_bias[0], - p=0.0, - scale=self.scale, - op = self.attn_op - ) - return out.view_as(original_query)\ -""" - -NEW_XFORMER_BLOCK = """\ - self.attn_op = xops.fmha.flash.FwOp() - if self.alibi_slopes is None: - # Add the batch dimension. - query = query.unsqueeze(0) - key = key.unsqueeze(0) - value = value.unsqueeze(0) - if self.head_size > 128: - out = self._run_sdpa_fallback(query, key, value, attn_metadata) - else: - out = xops.memory_efficient_attention_forward( - query, - key, - value, - attn_bias=attn_bias[0], - p=0.0, - scale=self.scale, - op=self.attn_op, - ) - return out.view_as(original_query)\ -""" - -INJECT_ANCHOR = " def _run_memory_efficient_xformers_forward(" - +from patch_utils import package_root, replace_once +XFORMERS_PATH = package_root("vllm") / "attention" / "backends" / "xformers.py" + +FALLBACK_METHOD = ''' + def _run_sdpa_fallback( + self, + query: torch.Tensor, + key: torch.Tensor, + value: torch.Tensor, + attn_metadata: "XFormersMetadata", + ) -> torch.Tensor: + """顺序 F.scaled_dot_product_attention fallback（可走硬件 kernel）。 + + 逐条序列调用 SDPA，is_causal=False + 显式上三角 additive mask。 + cudnnFlashAttnForward 不支持 is_causal=True，必须用显式 mask。 + 逐序列构造 mask，peak 显存 = max(seq_len)² × dtype（远小于 batch 版）。 + + Args: + query : [1, total_prefill_tokens, num_heads, head_dim] + key : [1, total_prefill_tokens, num_kv_heads, head_dim] + value : [1, total_prefill_tokens, num_kv_heads, head_dim] + Returns: + [1, total_prefill_tokens, num_heads, head_dim] + """ + import torch.nn.functional as F + + assert attn_metadata.seq_lens is not None + orig_dtype = query.dtype + + q_flat = query.squeeze(0) # [T, H, D] + k_flat = key.squeeze(0) # [T, Hkv, D] + v_flat = value.squeeze(0) + + output = torch.empty_like(q_flat) + start = 0 + for seq_len in attn_metadata.seq_lens: + end = start + seq_len + # [1, H, L, D] + q_s = q_flat[start:end].permute(1, 0, 2).contiguous().unsqueeze(0) + k_s = k_flat[start:end].permute(1, 0, 2).contiguous().unsqueeze(0) + v_s = v_flat[start:end].permute(1, 0, 2).contiguous().unsqueeze(0) + + # GQA：展开 KV heads + if k_s.shape[1] != q_s.shape[1]: + n = q_s.shape[1] // k_s.shape[1] + k_s = k_s.repeat_interleave(n, dim=1).contiguous() + v_s = v_s.repeat_interleave(n, dim=1).contiguous() + + # 逐序列因果 mask [L, L]，上三角 -inf + causal_mask = torch.tril( + torch.zeros(seq_len, seq_len, dtype=orig_dtype, device=q_s.device) + ) + causal_mask = causal_mask.masked_fill( + torch.triu(torch.ones(seq_len, seq_len, dtype=torch.bool, + device=q_s.device), diagonal=1), + float("-inf"), + ) + + # is_causal=False + 显式 mask，规避 cudnnFlashAttnForward 不支持 is_causal=True + out_s = F.scaled_dot_product_attention( + q_s, k_s, v_s, + attn_mask=causal_mask, + dropout_p=0.0, + is_causal=False, + scale=self.scale, + ) + # [1, H, L, D] → [L, H, D] + output[start:end] = out_s.squeeze(0).permute(1, 0, 2).to(orig_dtype) + start = end + + return output.unsqueeze(0) # [1, T, H, D] + +''' + +OLD_XFORMER_BLOCK = """\ + self.attn_op = xops.fmha.flash.FwOp() + if self.alibi_slopes is None: + # Add the batch dimension. + query = query.unsqueeze(0) + key = key.unsqueeze(0) + value = value.unsqueeze(0) + out = xops.memory_efficient_attention_forward( + query, + key, + value, + attn_bias=attn_bias[0], + p=0.0, + scale=self.scale, + op = self.attn_op + ) + return out.view_as(original_query)\ +""" + +NEW_XFORMER_BLOCK = """\ + self.attn_op = xops.fmha.flash.FwOp() + if self.alibi_slopes is None: + # Add the batch dimension. + query = query.unsqueeze(0) + key = key.unsqueeze(0) + value = value.unsqueeze(0) + if self.head_size > 128: + out = self._run_sdpa_fallback(query, key, value, attn_metadata) + else: + out = xops.memory_efficient_attention_forward( + query, + key, + value, + attn_bias=attn_bias[0], + p=0.0, + scale=self.scale, + op=self.attn_op, + ) + return out.view_as(original_query)\ +""" + +INJECT_ANCHOR = " def _run_memory_efficient_xformers_forward(" + + def patch_file(path): - with open(path, "r") as f: - content = f.read() - changed = False - - if "_run_sdpa_fallback" in content: - print(" [skip] _run_sdpa_fallback already present") - elif INJECT_ANCHOR not in content: - print(" [warn] inject anchor not found") - else: - content = content.replace(INJECT_ANCHOR, FALLBACK_METHOD + INJECT_ANCHOR, 1) - print(" [ok] injected _run_sdpa_fallback (seq, F.sdpa kernel)") - changed = True - - if NEW_XFORMER_BLOCK in content: - print(" [skip] dispatch block already patched") - elif OLD_XFORMER_BLOCK in content: - content = content.replace(OLD_XFORMER_BLOCK, NEW_XFORMER_BLOCK, 1) - print(" [ok] patched dispatch block") - changed = True - else: - print(" [warn] dispatch block anchor not found") - - if changed: - with open(path, "w") as f: - f.write(content) - print(f" Written: {path}") - - -def main(): - print("=== patch_xformers_sdpa_seq_kernel (seq, F.sdpa + kernel dispatch) ===") - print(f"Target: {XFORMERS_PATH}") - patch_file(XFORMERS_PATH) - print("\nDone.") - - -if __name__ == "__main__": - main() + replace_once( + path, + INJECT_ANCHOR, + FALLBACK_METHOD + INJECT_ANCHOR, + required=True, + already_contains="def _run_sdpa_fallback(") + replace_once( + path, + OLD_XFORMER_BLOCK, + NEW_XFORMER_BLOCK, + required=True, + already_contains="out = self._run_sdpa_fallback(query, key, value, attn_metadata)") + + +def main(): + print("=== patch_xformers_sdpa_seq_kernel (seq, F.sdpa + kernel dispatch) ===") + print(f"Target: {XFORMERS_PATH}") + patch_file(XFORMERS_PATH) + print("\nDone.") + + +if __name__ == "__main__": + main() diff --git a/qwen3_6_scripts/prebuilt/corex-3.2.3-ivcore10/SHA256SUMS b/qwen3_6_scripts/prebuilt/corex-3.2.3-ivcore10/SHA256SUMS new file mode 100644 index 00000000..f2915aa5 --- /dev/null +++ b/qwen3_6_scripts/prebuilt/corex-3.2.3-ivcore10/SHA256SUMS @@ -0,0 +1,12 @@ +534019b3c2ad2d2c65492b01a975874ee440026eda2e8666bc3c1dc8a0a0a6f6 corex_attn_head_rms_norm.so +7e2aafd8dc755b0ee16c3b9bb812b95548fc042bbaa840dd9db7d2c51a10474c corex_block_major_kv_transfer.so +ad4ea7707bb2f2bfe04e07a7ad5fd58a647232be70a3056937a0d738c8254bff corex_fused_paged_prefill.so +1856c86e3100415061aa698a48bdeff3fe785994b45b4e72a42cd9158552a7d8 corex_gdn_beta_decay.so +957c7518f5831299fc73f19a4ca2aa3c8231afe9ea7c979127b4f426cd9d6906 corex_gdn_causal_conv.so +ec2d11fa82d9d0816a6da53e62605e962786fa20ecd5f62e50f9d43087fc4d67 corex_gdn_gated_norm.so +27b7ae2ce4fe173336355d72a2678d043df4bd1ed85e9231a99bfb81885a6ce3 corex_gdn_packed_decode.so +015b61046ad73d8f12d754f7a87d4f6cba33070af1c079879e15b71a94571670 corex_gdn_qk_map.so +0eb120e89608bb5b64ca4356a5d3d362121806d081ccc1ccf346dac472a819ec corex_moe_direct_routed.so +d26f2fa39c3921a95793786601e90cf6ebadd06f1d752af541bf82c21acbc1c9 corex_moe_exact_reduce.so +50b0b44c1da779bb2c03419ed549aee9bb922d1f9bab8b7f11a3d91cca0d21c3 corex_moe_weight_gather.so +e944ec0528ed9b6cb74518de3c57e3730543a7bdebc872f993bfdc8424f13e6b corex_paged_kv_gather.so diff --git a/qwen3_6_scripts/prebuilt/corex-3.2.3-ivcore10/corex_attn_head_rms_norm.so b/qwen3_6_scripts/prebuilt/corex-3.2.3-ivcore10/corex_attn_head_rms_norm.so new file mode 100755 index 0000000000000000000000000000000000000000..27a560df86fa5f47e0201577062ba52e4b0eb4f3 GIT binary patch literal 207168 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