@tduncan / Nvidia-Optimization-Stack-VLLM Mirror · read-only / commits / 3468f17ebe
Fork 0

A high-throughput and memory-efficient inference and serving engine for LLMs

Mirrored from https://github.com/tduncan-lum/Nvidia-Optimization-Stack---VLLM.git

Synced Nov 14, 05:30 UTC

[V0 deprecation] Remove _VLLM_V1 suffixes from attention backend names (#25489)

Signed-off-by: Matthew Bonanni <mbonanni@redhat.com> Signed-off-by: Matthew Bonanni <mbonanni001@gmail.com>

Matthew Bonanni committed Sep 25, 2025 at 13:37 UTC 3468f17ebe4daf19ff120d95eebde48f59d7cac2
42 files changed +131 -174
.buildkite/scripts/hardware_ci/run-xpu-test.sh
+1 -1
@@ -35,7 +35,7 @@ docker run \
35 python3 examples/offline_inference/basic/generate.py --model facebook/opt-125m --block-size 64 -O3 -O.cudagraph_mode=NONE
36 python3 examples/offline_inference/basic/generate.py --model facebook/opt-125m --block-size 64 --enforce-eager -tp 2 --distributed-executor-backend ray
37 python3 examples/offline_inference/basic/generate.py --model facebook/opt-125m --block-size 64 --enforce-eager -tp 2 --distributed-executor-backend mp
38 - VLLM_ATTENTION_BACKEND=TRITON_ATTN_VLLM_V1 python3 examples/offline_inference/basic/generate.py --model facebook/opt-125m --block-size 64 --enforce-eager
38 + VLLM_ATTENTION_BACKEND=TRITON_ATTN python3 examples/offline_inference/basic/generate.py --model facebook/opt-125m --block-size 64 --enforce-eager
39 cd tests
40 pytest -v -s v1/core
41 pytest -v -s v1/engine
tests/compile/piecewise/test_full_cudagraph.py
+1 -1
@@ -103,7 +103,7 @@ backend_configs = {
103 # Triton Attention
104 "TritonAttn":
105 BackendConfig(name="TritonAttn",
106 - env_vars={"VLLM_ATTENTION_BACKEND": "TRITON_ATTN_VLLM_V1"},
106 + env_vars={"VLLM_ATTENTION_BACKEND": "TRITON_ATTN"},
107 comp_config={
108 "cudagraph_mode": "FULL",
109 }),
tests/compile/test_fusion_attn.py
+1 -1
@@ -338,7 +338,7 @@ else:
338 @pytest.mark.parametrize("model_name, model_class", MODELS)
339 @pytest.mark.parametrize("backend",
340 [_Backend.FLASHINFER] if current_platform.is_cuda()
341 - else [_Backend.TRITON_ATTN_VLLM_V1])
341 + else [_Backend.TRITON_ATTN])
342 @pytest.mark.parametrize(
343 "split_attention",
344 [False, True] if current_platform.is_rocm() else [False])
tests/entrypoints/openai/test_serving_chat.py
+1 -1
@@ -68,7 +68,7 @@ def default_server_args(with_tool_parser: bool):
68 def gptoss_server(monkeypatch_module: pytest.MonkeyPatch,
69 default_server_args: list[str]):
70 with monkeypatch_module.context() as m:
71 - m.setenv("VLLM_ATTENTION_BACKEND", "TRITON_ATTN_VLLM_V1")
71 + m.setenv("VLLM_ATTENTION_BACKEND", "TRITON_ATTN")
72 with RemoteOpenAIServer(GPT_OSS_MODEL_NAME,
73 default_server_args) as remote_server:
74 yield remote_server
tests/kernels/attention/test_attention_selector.py
+18 -16
@@ -31,7 +31,7 @@ DEVICE_MLA_BACKENDS = {
31 }
32
33 DEVICE_REGULAR_ATTN_BACKENDS = {
34 - "cuda": ["XFORMERS", "FLASHINFER"],
34 + "cuda": ["XFORMERS", "FLASHINFER", "FLASH_ATTN"],
35 "hip": ["ROCM_FLASH"],
36 "cpu": ["TORCH_SDPA"],
37 }
@@ -86,7 +86,7 @@ def test_env(
86 with patch("vllm.attention.selector.current_platform",
87 CpuPlatform()):
88 backend = get_attn_backend(16, torch.float16, None, block_size)
89 - assert backend.get_name() == "TORCH_SDPA_VLLM_V1"
89 + assert backend.get_name() == "TORCH_SDPA"
90
91 elif device == "hip":
92 with patch("vllm.attention.selector.current_platform",
@@ -125,7 +125,7 @@ def test_env(
125 None,
126 block_size,
127 use_mla=use_mla)
128 - expected = f"{name}_VLLM_V1"
128 + expected = name
129 assert backend.get_name() == expected
130 else:
131 backend = get_attn_backend(16,
@@ -133,7 +133,7 @@ def test_env(
133 None,
134 block_size,
135 use_mla=use_mla)
136 - expected = "TRITON_ATTN_VLLM_V1"
136 + expected = "TRITON_ATTN"
137 assert backend.get_name() == expected
138
139 elif device == "cuda":
@@ -160,7 +160,7 @@ def test_env(
160 None,
161 block_size,
162 use_mla=use_mla)
163 - expected = "CUTLASS_MLA_VLLM_V1"
163 + expected = "CUTLASS_MLA"
164 assert backend.get_name() == expected
165 elif name == "FLASHINFER_MLA":
166 if block_size not in [32, 64]:
@@ -193,7 +193,7 @@ def test_env(
193 None,
194 block_size,
195 use_mla=use_mla)
196 - expected = f"{name}_VLLM_V1"
196 + expected = name
197 assert backend.get_name() == expected
198 elif name == "FLASH_ATTN_MLA":
199 backend = get_attn_backend(16,
@@ -210,7 +210,7 @@ def test_env(
210 None,
211 block_size,
212 use_mla=use_mla)
213 - expected = "TRITON_MLA_VLLM_V1"
213 + expected = "TRITON_MLA"
214 assert backend.get_name() == expected
215 elif name == "FLASHINFER":
216 backend = get_attn_backend(16,
@@ -218,25 +218,24 @@ def test_env(
218 None,
219 block_size,
220 use_mla=use_mla)
221 - expected = "FLASHINFER_VLLM_V1"
221 + expected = "FLASHINFER"
222 assert backend.get_name() == expected
223 - else:
223 + elif name == "XFORMERS":
224 backend = get_attn_backend(32,
225 torch.float16,
226 None,
227 block_size,
228 use_mla=use_mla)
229 - expected = "FLASH_ATTN_VLLM_V1"
229 + expected = "XFORMERS"
230 assert backend.get_name() == expected
231 -
232 - backend = get_attn_backend(16,
231 + elif name == "FLASH_ATTN":
232 + backend = get_attn_backend(32,
233 torch.float16,
234 None,
235 block_size,
236 use_mla=use_mla)
237 - assert backend.get_name() == "FLEX_ATTENTION", (
238 - "Should fallback to FlexAttention if head size is "
239 - "not supported by FlashAttention")
237 + expected = "FLASH_ATTN"
238 + assert backend.get_name() == expected
239
240
241 @pytest.mark.parametrize("device", ["cpu", "cuda"])
@@ -252,7 +251,7 @@ def test_fp32_fallback(
251 with patch("vllm.attention.selector.current_platform",
252 CpuPlatform()):
253 backend = get_attn_backend(16, torch.float32, None, 16)
255 - assert backend.get_name() == "TORCH_SDPA_VLLM_V1"
254 + assert backend.get_name() == "TORCH_SDPA"
255
256 elif device == "cuda":
257 with patch("vllm.attention.selector.current_platform",
@@ -266,6 +265,9 @@ def test_flash_attn(monkeypatch: pytest.MonkeyPatch):
265 # TODO: When testing for v1, pipe in `use_v1` as an argument to
266 # get_attn_backend
267
268 + pytest.skip("Skipping as current backend selector does not " \
269 + "handle fallbacks when a backend is set via env var.")
270 +
271 with monkeypatch.context() as m:
272 m.setenv(STR_BACKEND_ENV_VAR, STR_FLASH_ATTN_VAL)
273
tests/kernels/attention/test_rocm_attention_selector.py
+5 -9
@@ -28,7 +28,7 @@ def test_selector(monkeypatch: pytest.MonkeyPatch):
28 # Test standard ROCm attention
29 backend = get_attn_backend(16, torch.float16, torch.float16, 16, False)
30 assert (backend.get_name() == "ROCM_FLASH"
31 - or backend.get_name() == "TRITON_ATTN_VLLM_V1")
31 + or backend.get_name() == "TRITON_ATTN")
32
33 # MLA test for deepseek related
34
@@ -40,8 +40,7 @@ def test_selector(monkeypatch: pytest.MonkeyPatch):
40 16,
41 False,
42 use_mla=True)
43 - assert (backend.get_name() == "TRITON_MLA"
44 - or backend.get_name() == "TRITON_MLA_VLLM_V1")
43 + assert backend.get_name() == "TRITON_MLA"
44
45 # If attention backend is None
46 # If use_mla is true
@@ -53,8 +52,7 @@ def test_selector(monkeypatch: pytest.MonkeyPatch):
52 16,
53 False,
54 use_mla=True)
56 - assert (backend.get_name() == "TRITON_MLA"
57 - or backend.get_name() == "TRITON_MLA_VLLM_V1")
55 + assert backend.get_name() == "TRITON_MLA"
56
57 # change the attention backend to AITER MLA
58 m.setenv(STR_BACKEND_ENV_VAR, "ROCM_AITER_MLA")
@@ -64,8 +62,7 @@ def test_selector(monkeypatch: pytest.MonkeyPatch):
62 1,
63 False,
64 use_mla=True)
67 - assert (backend.get_name() == "ROCM_AITER_MLA"
68 - or backend.get_name() == "ROCM_AITER_MLA_VLLM_V1")
65 + assert backend.get_name() == "ROCM_AITER_MLA"
66
67 # If attention backend is None
68 # If use_mla is true
@@ -79,5 +76,4 @@ def test_selector(monkeypatch: pytest.MonkeyPatch):
76 1,
77 False,
78 use_mla=True)
82 - assert (backend.get_name() == "ROCM_AITER_MLA"
83 - or backend.get_name() == "ROCM_AITER_MLA_VLLM_V1")
79 + assert backend.get_name() == "ROCM_AITER_MLA"
tests/kernels/utils.py
+4 -4
@@ -524,14 +524,14 @@ def make_backend(backend_name: str) -> AttentionBackend:
524
525 * Backend instance
526 '''
527 - if backend_name in (STR_XFORMERS_ATTN_VAL, "XFORMERS_VLLM_V1"):
527 + if backend_name == STR_XFORMERS_ATTN_VAL:
528 from vllm.v1.attention.backends.xformers import (
529 XFormersAttentionBackend)
530 return XFormersAttentionBackend()
531 - if backend_name in (STR_FLASH_ATTN_VAL, "FLASH_ATTN_VLLM_V1"):
531 + if backend_name == STR_FLASH_ATTN_VAL:
532 from vllm.v1.attention.backends.flash_attn import FlashAttentionBackend
533 return FlashAttentionBackend()
534 - if backend_name == "TRITON_ATTN_VLLM_V1":
534 + if backend_name == "TRITON_ATTN":
535 from vllm.v1.attention.backends.triton_attn import (
536 TritonAttentionBackend)
537 return TritonAttentionBackend()
@@ -539,7 +539,7 @@ def make_backend(backend_name: str) -> AttentionBackend:
539 from vllm.v1.attention.backends.flex_attention import (
540 FlexAttentionBackend)
541 return FlexAttentionBackend()
542 - if backend_name in ("TORCH_SDPA", "TORCH_SDPA_VLLM_V1"):
542 + if backend_name == "TORCH_SDPA":
543 from vllm.v1.attention.backends.cpu_attn import TorchSDPABackend
544 return TorchSDPABackend()
545 if backend_name == "FLASHINFER":
tests/models/test_initialization.py
+1 -1
@@ -84,7 +84,7 @@ def can_initialize(model_arch: str, monkeypatch: pytest.MonkeyPatch,
84 # FIXME: A hack to bypass FA3 assertion because our CI's L4 GPU
85 # has cc==8.9 which hasn't supported FA3 yet. Remove this hack when
86 # L4 supports FA3.
87 - m.setenv("VLLM_ATTENTION_BACKEND", "TRITON_ATTN_VLLM_V1")
87 + m.setenv("VLLM_ATTENTION_BACKEND", "TRITON_ATTN")
88 if model_arch == "WhisperForConditionalGeneration":
89 m.setenv("VLLM_WORKER_MULTIPROC_METHOD", "spawn")
90 LLM(
tests/utils.py
+4 -4
@@ -1131,14 +1131,14 @@ def has_module_attribute(module_name, attribute_name):
1131
1132 def get_attn_backend_list_based_on_platform() -> list[str]:
1133 if current_platform.is_cuda():
1134 - return ["FLASH_ATTN_VLLM_V1", "TRITON_ATTN_VLLM_V1", "TREE_ATTN"]
1134 + return ["FLASH_ATTN", "TRITON_ATTN", "TREE_ATTN"]
1135 elif current_platform.is_rocm():
1136 - attn_backend_list = ["TRITON_ATTN_VLLM_V1"]
1136 + attn_backend_list = ["TRITON_ATTN"]
1137 try:
1138 import aiter # noqa: F401
1139 - attn_backend_list.append("FLASH_ATTN_VLLM_V1")
1139 + attn_backend_list.append("FLASH_ATTN")
1140 except Exception:
1141 - print("Skip FLASH_ATTN_VLLM_V1 on ROCm as aiter is not installed")
1141 + print("Skip FLASH_ATTN on ROCm as aiter is not installed")
1142
1143 return attn_backend_list
1144 else:
tests/v1/attention/test_attention_backends.py
+7 -8
@@ -21,16 +21,15 @@ from vllm.v1.attention.backends.utils import (CommonAttentionMetadata,
21 from vllm.v1.kv_cache_interface import FullAttentionSpec
22
23 BACKENDS_TO_TEST = [
24 - _Backend.FLASH_ATTN_VLLM_V1, _Backend.FLASHINFER_VLLM_V1,
25 - _Backend.FLEX_ATTENTION, _Backend.TRITON_ATTN_VLLM_V1, _Backend.TREE_ATTN,
26 - "FLEX_ATTENTION_SLOW"
24 + _Backend.FLASH_ATTN, _Backend.FLASHINFER, _Backend.FLEX_ATTENTION,
25 + _Backend.TRITON_ATTN, _Backend.TREE_ATTN, "FLEX_ATTENTION_SLOW"
26 ]
27
28 # Remove flashinfer from the list if it's not available
29 try:
30 import flashinfer # noqa: F401
31 except ImportError:
33 - BACKENDS_TO_TEST.remove(_Backend.FLASHINFER_VLLM_V1)
32 + BACKENDS_TO_TEST.remove(_Backend.FLASHINFER)
33
34
35 def _convert_dtype_to_torch(dtype):
@@ -214,7 +213,7 @@ def run_attention_backend(
213 builder_cls, impl_cls = get_attention_backend(actual_backend)
214
215 # Mock flashinfer's get_per_layer_parameters if needed
217 - if actual_backend == _Backend.FLASHINFER_VLLM_V1:
216 + if actual_backend == _Backend.FLASHINFER:
217 import unittest.mock
218
219 from vllm.v1.attention.backends.utils import PerLayerParameters
@@ -434,7 +433,7 @@ def _test_backend_correctness(
433 # [num_blocks, 2, block_size, num_kv_heads, head_size]
434 # Select the appropriate KV cache format for each backend
435 kv_cache_for_backend = kv_cache
437 - if backend_name == _Backend.FLASHINFER_VLLM_V1:
436 + if backend_name == _Backend.FLASHINFER:
437 kv_cache_for_backend = kv_cache.transpose(0, 1)
438
439 # For FlashInfer default to HND layout and
@@ -518,8 +517,8 @@ def test_causal_backend_correctness(batch_spec_name: str, model: str):
517
518
519 SLIDING_WINDOW_BACKENDS_TO_TEST = [
521 - _Backend.FLASH_ATTN_VLLM_V1, _Backend.FLEX_ATTENTION,
522 - _Backend.TRITON_ATTN_VLLM_V1, "FLEX_ATTENTION_SLOW"
520 + _Backend.FLASH_ATTN, _Backend.FLEX_ATTENTION, _Backend.TRITON_ATTN,
521 + "FLEX_ATTENTION_SLOW"
522 ]
523
524
tests/v1/attention/test_mla_backends.py
+2 -2
@@ -15,8 +15,8 @@ from vllm.v1.attention.backends.utils import CommonAttentionMetadata
15 from vllm.v1.kv_cache_interface import FullAttentionSpec
16
17 BACKENDS_TO_TEST = [
18 - _Backend.CUTLASS_MLA, _Backend.FLASHMLA_VLLM_V1, _Backend.FLASH_ATTN_MLA,
19 - _Backend.TRITON_MLA_VLLM_V1
18 + _Backend.CUTLASS_MLA, _Backend.FLASHMLA, _Backend.FLASH_ATTN_MLA,
19 + _Backend.TRITON_MLA
20 ]
21
22 # Remove CUTLASS_MLA from the list if not using sm100
tests/v1/attention/utils.py
+6 -6
@@ -120,30 +120,30 @@ def get_attention_backend(backend_name: _Backend):
120 Tuple of (backend_builder_class, backend_impl_class)
121 """
122 backend_map = {
123 - _Backend.FLASH_ATTN_VLLM_V1:
123 + _Backend.FLASH_ATTN:
124 ("vllm.v1.attention.backends.flash_attn.FlashAttentionBackend"
125 if current_platform.is_cuda() else
126 "vllm.v1.attention.backends.rocm_aiter_fa.AiterFlashAttentionBackend"
127 ),
128 - _Backend.FLASHINFER_VLLM_V1:
128 + _Backend.FLASHINFER:
129 "vllm.v1.attention.backends.flashinfer.FlashInferBackend",
130 _Backend.FLEX_ATTENTION:
131 "vllm.v1.attention.backends.flex_attention.FlexAttentionBackend",
132 - _Backend.TRITON_ATTN_VLLM_V1:
132 + _Backend.TRITON_ATTN:
133 "vllm.v1.attention.backends.triton_attn.TritonAttentionBackend",
134 _Backend.TREE_ATTN:
135 "vllm.v1.attention.backends.tree_attn.TreeAttentionBackend",
136 - _Backend.XFORMERS_VLLM_V1:
136 + _Backend.XFORMERS:
137 "vllm.v1.attention.backends.xformers.XFormersAttentionBackend",
138 _Backend.CUTLASS_MLA:
139 "vllm.v1.attention.backends.mla.cutlass_mla.CutlassMLABackend",
140 - _Backend.FLASHMLA_VLLM_V1:
140 + _Backend.FLASHMLA:
141 "vllm.v1.attention.backends.mla.flashmla.FlashMLABackend",
142 _Backend.FLASH_ATTN_MLA:
143 "vllm.v1.attention.backends.mla.flashattn_mla.FlashAttnMLABackend",
144 _Backend.FLASHINFER_MLA:
145 "vllm.v1.attention.backends.mla.flashinfer_mla.FlashInferMLABackend",
146 - _Backend.TRITON_MLA_VLLM_V1:
146 + _Backend.TRITON_MLA:
147 "vllm.v1.attention.backends.mla.triton_mla.TritonMLABackend",
148 }
149
tests/v1/cudagraph/test_cudagraph_mode.py
+1 -1
@@ -89,7 +89,7 @@ backend_configs = {
89 # Triton Attention
90 "TritonAttn":
91 BackendConfig(name="TritonAttn",
92 - env_vars={"VLLM_ATTENTION_BACKEND": "TRITON_ATTN_VLLM_V1"},
92 + env_vars={"VLLM_ATTENTION_BACKEND": "TRITON_ATTN"},
93 comp_config={
94 "cudagraph_mode": "FULL_AND_PIECEWISE",
95 }),
tests/v1/e2e/test_cascade_attention.py
+5 -2
@@ -9,11 +9,14 @@ from ...utils import create_new_process_for_each_test
9
10
11 @create_new_process_for_each_test()
12 -@pytest.mark.parametrize("attn_backend",
13 - ["FLASH_ATTN_VLLM_V1", "FLASHINFER_VLLM_V1"])
12 +@pytest.mark.parametrize("attn_backend", ["FLASH_ATTN", "FLASHINFER"])
13 def test_cascade_attention(example_system_message, monkeypatch, attn_backend):
14 prompt = "\n<User>: Implement fibonacci sequence in Python.\n<Claude>:"
15
16 + if attn_backend == "FLASHINFER":
17 + pytest.skip("This test is failing with FlashInfer backend and "
18 + "needs investigation. See issue #25679.")
19 +
20 with monkeypatch.context() as m:
21 m.setenv("VLLM_USE_V1", "1")
22 m.setenv("VLLM_ATTENTION_BACKEND", attn_backend)
tests/v1/e2e/test_spec_decode.py
+3 -4
@@ -176,12 +176,11 @@ def test_eagle_correctness(
176 m.setenv("VLLM_MLA_DISABLE", "1")
177 m.setenv("VLLM_ATTENTION_BACKEND", attn_backend)
178
179 - if (attn_backend == "TRITON_ATTN_VLLM_V1"
180 - and not current_platform.is_rocm()):
181 - pytest.skip("TRITON_ATTN_VLLM_V1 does not support "
179 + if (attn_backend == "TRITON_ATTN" and not current_platform.is_rocm()):
180 + pytest.skip("TRITON_ATTN does not support "
181 "multi-token eagle spec decode on current platform")
182
184 - if attn_backend == "FLASH_ATTN_VLLM_V1" and current_platform.is_rocm():
183 + if attn_backend == "FLASH_ATTN" and current_platform.is_rocm():
184 m.setenv("VLLM_ROCM_USE_AITER", "1")
185
186 method, model_name, spec_model_name, tp_size = model_setup
tests/v1/spec_decode/test_eagle.py
+10 -12
@@ -314,12 +314,11 @@ def test_load_model(mock_get_model, mock_get_layers, mock_get_pp_group, method,
314
315 monkeypatch.setenv("VLLM_ATTENTION_BACKEND", attn_backend)
316
317 - if (attn_backend == "TRITON_ATTN_VLLM_V1"
318 - and not current_platform.is_rocm()):
319 - pytest.skip("TRITON_ATTN_VLLM_V1 does not support "
317 + if (attn_backend == "TRITON_ATTN" and not current_platform.is_rocm()):
318 + pytest.skip("TRITON_ATTN does not support "
319 "multi-token eagle spec decode on current platform")
320
322 - if attn_backend == "FLASH_ATTN_VLLM_V1" and current_platform.is_rocm():
321 + if attn_backend == "FLASH_ATTN" and current_platform.is_rocm():
322 monkeypatch.setenv("VLLM_ROCM_USE_AITER", "1")
323
324 # Setup draft model mock
@@ -400,16 +399,15 @@ def test_propose(method, attn_backend, num_speculative_tokens, monkeypatch):
399
400 monkeypatch.setenv("VLLM_ATTENTION_BACKEND", attn_backend)
401
403 - if (attn_backend == "TRITON_ATTN_VLLM_V1"
404 - and not current_platform.is_rocm()):
405 - pytest.skip("TRITON_ATTN_VLLM_V1 does not support "
402 + if (attn_backend == "TRITON_ATTN" and not current_platform.is_rocm()):
403 + pytest.skip("TRITON_ATTN does not support "
404 "multi-token eagle spec decode on current platform")
405
406 if (attn_backend == "TREE_ATTN"):
407 pytest.skip("TREE_ATTN is tested separately in test_propose_tree"
408 "because it requires special input mocking.")
409
412 - if attn_backend == "FLASH_ATTN_VLLM_V1" and current_platform.is_rocm():
410 + if attn_backend == "FLASH_ATTN" and current_platform.is_rocm():
411 monkeypatch.setenv("VLLM_ROCM_USE_AITER", "1")
412
413 # Use GPU device
@@ -510,12 +508,12 @@ def test_propose(method, attn_backend, num_speculative_tokens, monkeypatch):
508 device=device)
509 sampling_metadata = mock.MagicMock()
510
513 - if attn_backend == "FLASH_ATTN_VLLM_V1":
511 + if attn_backend == "FLASH_ATTN":
512 attn_metadata_builder_cls, _ = get_attention_backend(
515 - _Backend.FLASH_ATTN_VLLM_V1)
516 - elif attn_backend == "TRITON_ATTN_VLLM_V1":
513 + _Backend.FLASH_ATTN)
514 + elif attn_backend == "TRITON_ATTN":
515 attn_metadata_builder_cls, _ = get_attention_backend(
518 - _Backend.TRITON_ATTN_VLLM_V1)
516 + _Backend.TRITON_ATTN)
517 elif attn_backend == "TREE_ATTN":
518 attn_metadata_builder_cls, _ = get_attention_backend(
519 _Backend.TREE_ATTN)
tests/v1/spec_decode/test_max_len.py
+3 -4
@@ -41,12 +41,11 @@ def test_eagle_max_len(monkeypatch: pytest.MonkeyPatch,
41 m.setenv("VLLM_USE_V1", "1")
42 m.setenv("VLLM_ATTENTION_BACKEND", attn_backend)
43
44 - if (attn_backend == "TRITON_ATTN_VLLM_V1"
45 - and not current_platform.is_rocm()):
46 - pytest.skip("TRITON_ATTN_VLLM_V1 does not support "
44 + if (attn_backend == "TRITON_ATTN" and not current_platform.is_rocm()):
45 + pytest.skip("TRITON_ATTN does not support "
46 "multi-token eagle spec decode on current platform")
47
49 - if attn_backend == "FLASH_ATTN_VLLM_V1" and current_platform.is_rocm():
48 + if attn_backend == "FLASH_ATTN" and current_platform.is_rocm():
49 m.setenv("VLLM_ROCM_USE_AITER", "1")
50
51 llm = LLM(
tests/v1/spec_decode/test_tree_attention.py
+1 -1
@@ -278,7 +278,7 @@ def test_tree_attn_correctness() -> None:
278 block_table=block_table,
279 slot_mapping=branch_slot_mapping,
280 seqlen_k=sequence_position + q_len,
281 - backend=_Backend.FLASH_ATTN_VLLM_V1,
281 + backend=_Backend.FLASH_ATTN,
282 ).view(batch_size, -1, num_heads, dim_per_head)
283
284 # Compare the outputs.
tests/v1/test_oracle.py
-23
@@ -54,26 +54,3 @@ def test_v1_llm_by_default(monkeypatch):
54 print(llm.generate("Hello my name is"))
55 assert hasattr(llm.llm_engine, "engine_core")
56 m.delenv("VLLM_USE_V1")
57 -
58 -
59 -def test_v1_attn_backend(monkeypatch):
60 - with monkeypatch.context() as m:
61 - if os.getenv("VLLM_USE_V1", None):
62 - m.delenv("VLLM_USE_V1")
63 - m.setenv("VLLM_ATTENTION_BACKEND", "XFORMERS")
64 -
65 - # Fall back to V0.
66 - _ = AsyncEngineArgs(model=MODEL).create_engine_config()
67 - assert not envs.VLLM_USE_V1
68 - m.delenv("VLLM_USE_V1")
69 -
70 - # Reject if V1.
71 - m.setenv("VLLM_USE_V1", "1")
72 - with pytest.raises(NotImplementedError):
73 - AsyncEngineArgs(model=MODEL).create_engine_config()
74 - m.delenv("VLLM_USE_V1")
75 -
76 - m.setenv("VLLM_ATTENTION_BACKEND", "FLASHMLA")
77 - _ = AsyncEngineArgs(model=MODEL).create_engine_config()
78 - assert envs.VLLM_USE_V1
79 - m.delenv("VLLM_USE_V1")
vllm/attention/layer.py
+6 -15
@@ -364,7 +364,7 @@ class Attention(nn.Module, AttentionLayerBase):
364 self.impl.process_weights_after_loading(act_dtype)
365
366 # FlashInfer requires attention sinks to be float32
367 - if (self.backend == _Backend.FLASHINFER_VLLM_V1
367 + if (self.backend == _Backend.FLASHINFER
368 and hasattr(self.impl, 'sinks')):
369 from vllm.v1.attention.backends.flashinfer import FlashInferImpl
370 assert isinstance(self.impl, FlashInferImpl)
@@ -420,21 +420,17 @@ class MultiHeadAttention(nn.Module):
420
421 self.attn_backend = backend if backend in {
422 _Backend.TORCH_SDPA,
423 - _Backend.TORCH_SDPA_VLLM_V1,
423 _Backend.XFORMERS,
425 - _Backend.PALLAS_VLLM_V1,
424 + _Backend.PALLAS,
425 _Backend.ROCM_AITER_FA,
426 _Backend.FLASH_ATTN,
428 - _Backend.FLASH_ATTN_VLLM_V1,
427 } else _Backend.TORCH_SDPA
428
429 if (self.attn_backend == _Backend.XFORMERS
430 and not check_xformers_availability()):
431 self.attn_backend = _Backend.TORCH_SDPA
432
435 - if self.attn_backend in {
436 - _Backend.FLASH_ATTN, _Backend.FLASH_ATTN_VLLM_V1
437 - }:
433 + if self.attn_backend == _Backend.FLASH_ATTN:
434 if use_upstream_fa:
435 from flash_attn import flash_attn_varlen_func
436 self._flash_attn_varlen_func = flash_attn_varlen_func
@@ -468,11 +464,7 @@ class MultiHeadAttention(nn.Module):
464 key = torch.repeat_interleave(key, num_repeat, dim=2)
465 value = torch.repeat_interleave(value, num_repeat, dim=2)
466
471 - if self.attn_backend in {
472 - _Backend.FLASH_ATTN,
473 - _Backend.FLASH_ATTN_VLLM_V1,
474 - }:
475 -
467 + if self.attn_backend == _Backend.FLASH_ATTN:
468 cu_seqlens_q = torch.arange(0, (bsz + 1) * q_len,
469 step=q_len,
470 dtype=torch.int32,
@@ -499,8 +491,7 @@ class MultiHeadAttention(nn.Module):
491 key,
492 value,
493 scale=self.scale)
502 - elif (self.attn_backend == _Backend.TORCH_SDPA
503 - or self.attn_backend == _Backend.TORCH_SDPA_VLLM_V1):
494 + elif self.attn_backend == _Backend.TORCH_SDPA:
495 query, key, value = (x.transpose(1, 2)
496 for x in (query, key, value))
497 out = F.scaled_dot_product_attention(query,
@@ -508,7 +499,7 @@ class MultiHeadAttention(nn.Module):
499 value,
500 scale=self.scale)
501 out = out.transpose(1, 2)
511 - elif self.attn_backend == _Backend.PALLAS_VLLM_V1:
502 + elif self.attn_backend == _Backend.PALLAS:
503 query, key, value = (x.transpose(1, 2)
504 for x in (query, key, value))
505 from torch_xla.experimental.custom_kernel import flash_attention
vllm/attention/selector.py
+8
@@ -186,6 +186,14 @@ def _cached_get_attn_backend(
186 # Check the environment variable and override if specified
187 backend_by_env_var: Optional[str] = envs.VLLM_ATTENTION_BACKEND
188 if backend_by_env_var is not None:
189 + if backend_by_env_var.endswith("_VLLM_V1"):
190 + logger.warning(
191 + "The suffix '_VLLM_V1' in the environment variable "
192 + "%s is no longer necessary as V0 backends have been "
193 + "deprecated. Please remove this suffix from your "
194 + "environment variable setting.", STR_BACKEND_ENV_VAR)
195 + backend_by_env_var = backend_by_env_var.removesuffix(
196 + "_VLLM_V1")
197 selected_backend = backend_name_to_enum(backend_by_env_var)
198 if selected_backend is None:
199 raise ValueError(
vllm/distributed/kv_transfer/kv_connector/v1/nixl_connector.py
+4 -4
@@ -577,8 +577,8 @@ class NixlConnectorWorker:
577 use_mla=self.use_mla)
578 self.backend_name = backend.get_name()
579 attn_backend = backend_name_to_enum(self.backend_name)
580 - self._use_flashinfer = attn_backend == _Backend.FLASHINFER_VLLM_V1
581 - self._use_pallas_v1 = attn_backend == _Backend.PALLAS_VLLM_V1
580 + self._use_flashinfer = attn_backend == _Backend.FLASHINFER
581 + self._use_pallas = attn_backend == _Backend.PALLAS
582 self.kv_cache_layout = get_kv_cache_layout()
583 logger.debug("Detected attention backend %s", self.backend_name)
584 logger.debug("Detected kv cache layout %s", self.kv_cache_layout)
@@ -749,7 +749,7 @@ class NixlConnectorWorker:
749 # (roughly 8KB vs 5KB).
750 # Conversely for FlashInfer, K and V are registered in the same region
751 # to better exploit the memory layout (ie num_blocks is the first dim).
752 - split_k_and_v = not (self.use_mla or self._use_pallas_v1
752 + split_k_and_v = not (self.use_mla or self._use_pallas
753 or self._use_flashinfer)
754 tensor_size_bytes = None
755 for layer_name, cache_or_caches in xfer_buffers.items():
@@ -938,7 +938,7 @@ class NixlConnectorWorker:
938 tp_ratio = divide(self._tp_size[self.engine_id],
939 self._tp_size[engine_id])
940 assert tp_ratio > 0, "Decode TP cannot be smaller than prefill TP"
941 - assert not self._use_pallas_v1 or tp_ratio == 1, \
941 + assert not self._use_pallas or tp_ratio == 1, \
942 "TPU (pallas_v1) DOES NOT support heterogeneous TP yet."
943
944 # Handle tp_size>num_kv_heads: replicate KV cache.
vllm/engine/arg_utils.py
+4 -8
@@ -1479,25 +1479,21 @@ class EngineArgs:
1479 "such as ngram, medusa, eagle, or deepseek_mtp.")
1480
1481 V1_BACKENDS = [
1482 - "FLASH_ATTN_VLLM_V1",
1482 "FLASH_ATTN",
1483 "PALLAS",
1485 - "PALLAS_VLLM_V1",
1486 - "TRITON_ATTN_VLLM_V1",
1484 + "TRITON_ATTN",
1485 "TRITON_MLA",
1486 "CUTLASS_MLA",
1487 "FLASHMLA",
1490 - "FLASHMLA_VLLM_V1",
1488 "FLASH_ATTN_MLA",
1489 "FLASHINFER",
1493 - "FLASHINFER_VLLM_V1",
1490 "FLASHINFER_MLA",
1491 "ROCM_AITER_MLA",
1496 - "TORCH_SDPA_VLLM_V1",
1492 + "TORCH_SDPA",
1493 "FLEX_ATTENTION",
1494 "TREE_ATTN",
1499 - "XFORMERS_VLLM_V1",
1500 - "ROCM_ATTN_VLLM_V1",
1495 + "XFORMERS",
1496 + "ROCM_ATTN",
1497 ]
1498 if (envs.is_set("VLLM_ATTENTION_BACKEND")
1499 and envs.VLLM_ATTENTION_BACKEND not in V1_BACKENDS):
vllm/model_executor/warmup/kernel_warmup.py
+1 -1
@@ -42,7 +42,7 @@ def kernel_warmup(worker: "Worker"):
42 # and is not a pooling model
43 def _is_flashinfer_backend(backend):
44 try:
45 - return backend.get_name() == "FLASHINFER_VLLM_V1"
45 + return backend.get_name() == "FLASHINFER"
46 except NotImplementedError:
47 return False
48
vllm/platforms/cuda.py
+10 -11
@@ -241,9 +241,8 @@ class CudaPlatformBase(Platform):
241 use_flashinfermla = selected_backend == _Backend.FLASHINFER_MLA or (
242 selected_backend is None and cls.is_device_capability(100)
243 and block_size in [32, 64])
244 - use_flashmla = selected_backend in [
245 - _Backend.FLASHMLA, _Backend.FLASHMLA_VLLM_V1
246 - ] or (selected_backend is None and is_flashmla_supported()[0])
244 + use_flashmla = selected_backend == _Backend.FLASHMLA or (
245 + selected_backend is None and is_flashmla_supported()[0])
246 use_flashattn = selected_backend == _Backend.FLASH_ATTN_MLA or (
247 selected_backend is None and flash_attn_supports_mla())
248 use_triton = selected_backend == _Backend.TRITON_MLA or (
@@ -282,7 +281,7 @@ class CudaPlatformBase(Platform):
281 if use_v1:
282 FLASHINFER_V1 = "vllm.v1.attention.backends.flashinfer.FlashInferBackend" # noqa: E501
283 FLEX_ATTENTION_V1 = "vllm.v1.attention.backends.flex_attention.FlexAttentionBackend" # noqa: E501
285 - TRITON_ATTN_VLLM_V1 = "vllm.v1.attention.backends.triton_attn.TritonAttentionBackend" # noqa: E501
284 + TRITON_ATTN = "vllm.v1.attention.backends.triton_attn.TritonAttentionBackend" # noqa: E501
285 FLASH_ATTN_V1 = "vllm.v1.attention.backends.flash_attn.FlashAttentionBackend" # noqa: E501
286 TREE_ATTN_V1 = "vllm.v1.attention.backends.tree_attn.TreeAttentionBackend" # noqa: E501
287 XFORMERS_V1 = "vllm.v1.attention.backends.xformers.XFormersAttentionBackend" # noqa: E501
@@ -300,16 +299,16 @@ class CudaPlatformBase(Platform):
299 elif selected_backend == _Backend.FLEX_ATTENTION:
300 logger.info_once("Using FlexAttention backend on V1 engine.")
301 return FLEX_ATTENTION_V1
303 - elif selected_backend == _Backend.TRITON_ATTN_VLLM_V1:
302 + elif selected_backend == _Backend.TRITON_ATTN:
303 logger.info_once("Using Triton backend on V1 engine.")
305 - return TRITON_ATTN_VLLM_V1
304 + return TRITON_ATTN
305 elif selected_backend == _Backend.FLASH_ATTN:
306 logger.info_once("Using Flash Attention backend on V1 engine.")
307 return FLASH_ATTN_V1
308 elif selected_backend == _Backend.TREE_ATTN:
309 logger.info_once("Using Tree Attention backend on V1 engine.")
310 return TREE_ATTN_V1
312 - elif selected_backend == _Backend.XFORMERS_VLLM_V1:
311 + elif selected_backend == _Backend.XFORMERS:
312 logger.info_once("Using XFormers backend on V1 engine.")
313 return XFORMERS_V1
314
@@ -341,7 +340,7 @@ class CudaPlatformBase(Platform):
340 if (has_sink or
341 use_fp8_kv_cache) and not cls.is_device_capability(90):
342 logger.info_once("Using Triton backend on V1 engine.")
344 - return TRITON_ATTN_VLLM_V1
343 + return TRITON_ATTN
344 elif is_default_backend_supported := is_attn_backend_supported(
345 FLASH_ATTN_V1, head_size, dtype,
346 allow_import_error=False):
@@ -457,12 +456,12 @@ class CudaPlatformBase(Platform):
456 else:
457 # Default to FlashAttention
458 if attention_backend is None:
460 - attention_backend = "FLASH_ATTN_VLLM_V1"
459 + attention_backend = "FLASH_ATTN"
460
461 # All Blackwell backends support fp8
462 if cls.is_device_capability(100):
463 supported = True
465 - elif attention_backend == "FLASH_ATTN_VLLM_V1":
464 + elif attention_backend == "FLASH_ATTN":
465 if fp8_attention:
466 from vllm.attention.utils.fa_utils import (
467 flash_attn_supports_fp8)
@@ -471,7 +470,7 @@ class CudaPlatformBase(Platform):
470 supported = True
471 elif attention_backend == "FLASHINFER":
472 supported = True
474 - elif attention_backend == "TRITON_ATTN_VLLM_V1":
473 + elif attention_backend == "TRITON_ATTN":
474 supported = cls.supports_fp8()
475 return supported
476
vllm/platforms/interface.py
+2 -10
@@ -40,34 +40,26 @@ def in_wsl() -> bool:
40
41 class _Backend(enum.Enum):
42 FLASH_ATTN = enum.auto()
43 - FLASH_ATTN_VLLM_V1 = enum.auto()
44 - TRITON_ATTN_VLLM_V1 = enum.auto()
43 + TRITON_ATTN = enum.auto()
44 XFORMERS = enum.auto()
45 ROCM_FLASH = enum.auto()
46 ROCM_AITER_MLA = enum.auto() # Supported by V1
48 - ROCM_AITER_MLA_VLLM_V1 = enum.auto()
47 ROCM_AITER_FA = enum.auto() # used for ViT attn backend
48 TORCH_SDPA = enum.auto()
51 - TORCH_SDPA_VLLM_V1 = enum.auto()
49 FLASHINFER = enum.auto()
53 - FLASHINFER_VLLM_V1 = enum.auto()
50 FLASHINFER_MLA = enum.auto()
51 TRITON_MLA = enum.auto() # Supported by V1
56 - TRITON_MLA_VLLM_V1 = enum.auto()
52 CUTLASS_MLA = enum.auto()
53 FLASHMLA = enum.auto() # Supported by V1
59 - FLASHMLA_VLLM_V1 = enum.auto()
54 FLASH_ATTN_MLA = enum.auto() # Supported by V1
55 PALLAS = enum.auto()
62 - PALLAS_VLLM_V1 = enum.auto()
56 IPEX = enum.auto()
57 DUAL_CHUNK_FLASH_ATTN = enum.auto()
58 DIFFERENTIAL_FLASH_ATTN = enum.auto()
59 NO_ATTENTION = enum.auto()
60 FLEX_ATTENTION = enum.auto()
61 TREE_ATTN = enum.auto()
69 - XFORMERS_VLLM_V1 = enum.auto()
70 - ROCM_ATTN_VLLM_V1 = enum.auto()
62 + ROCM_ATTN = enum.auto()
63
64
65 class PlatformEnum(enum.Enum):
vllm/platforms/rocm.py
+2 -3
@@ -218,8 +218,7 @@ class RocmPlatform(Platform):
218 raise ValueError(
219 f" The selected backend, {selected_backend.name},"
220 f"does not support block size {block_size}.")
221 - if selected_backend in (_Backend.ROCM_AITER_MLA,
222 - _Backend.ROCM_AITER_MLA_VLLM_V1):
221 + if selected_backend == _Backend.ROCM_AITER_MLA:
222 if block_size == 1:
223 logger.info("Using AITER MLA backend on V1 engine.")
224 return "vllm.v1.attention.backends.mla.rocm_aiter_mla.AiterMLABackend" # noqa: E501
@@ -240,7 +239,7 @@ class RocmPlatform(Platform):
239 elif (envs.VLLM_ROCM_USE_AITER and
240 envs.VLLM_USE_AITER_UNIFIED_ATTENTION) or \
241 envs.VLLM_V1_USE_PREFILL_DECODE_ATTENTION or \
243 - selected_backend == _Backend.ROCM_ATTN_VLLM_V1:
242 + selected_backend == _Backend.ROCM_ATTN:
243 # rocm specific backend, with aiter and/or
244 # triton prefix-prefill
245 logger.info("Using Rocm/Aiter Attention backend on V1 engine.")
vllm/platforms/tpu.py
+1 -2
@@ -50,8 +50,7 @@ class TpuPlatform(Platform):
50 dtype: torch.dtype, kv_cache_dtype: Optional[str],
51 block_size: int, use_v1: bool, use_mla: bool,
52 has_sink) -> str:
53 - if (selected_backend != _Backend.PALLAS
54 - and selected_backend != _Backend.PALLAS_VLLM_V1):
53 + if selected_backend != _Backend.PALLAS:
54 logger.info("Cannot use %s backend on TPU.", selected_backend)
55
56 if not use_v1:
vllm/platforms/xpu.py
+6 -6
@@ -40,14 +40,14 @@ class XPUPlatform(Platform):
40 use_v1 = envs.VLLM_USE_V1
41 if not use_v1:
42 raise ValueError("XPU backend only supports V1.")
43 - TRITON_ATTN_VLLM_V1 = "vllm.v1.attention.backends.triton_attn.TritonAttentionBackend" # noqa: E501
44 - FLASH_ATTN_V1 = "vllm.v1.attention.backends.flash_attn.FlashAttentionBackend" # noqa: E501
45 - if selected_backend == _Backend.TRITON_ATTN_VLLM_V1:
43 + TRITON_ATTN = "vllm.v1.attention.backends.triton_attn.TritonAttentionBackend" # noqa: E501
44 + FLASH_ATTN = "vllm.v1.attention.backends.flash_attn.FlashAttentionBackend" # noqa: E501
45 + if selected_backend == _Backend.TRITON_ATTN:
46 logger.info_once("Using Triton backend on V1 engine.")
47 - return TRITON_ATTN_VLLM_V1
47 + return TRITON_ATTN
48 elif selected_backend == _Backend.FLASH_ATTN:
49 logger.info_once("Using Flash Attention backend on V1 engine.")
50 - return FLASH_ATTN_V1
50 + return FLASH_ATTN
51 elif selected_backend:
52 raise ValueError(
53 f"Invalid attention backend for {cls.device_name}, "
@@ -64,7 +64,7 @@ class XPUPlatform(Platform):
64 XPU only support fp8 kv cache with triton backend.
65 """
66 if envs.is_set("VLLM_ATTENTION_BACKEND") and \
67 - envs.VLLM_ATTENTION_BACKEND == "TRITON_ATTN_VLLM_V1":
67 + envs.VLLM_ATTENTION_BACKEND == "TRITON_ATTN":
68 return kv_cache_dtype in ["fp8_e4m3", "fp8_e5m2", "fp8"]
69
70 return False
vllm/v1/attention/backends/cpu_attn.py
+1 -1
@@ -54,7 +54,7 @@ class TorchSDPABackend(AttentionBackend):
54
55 @staticmethod
56 def get_name() -> str:
57 - return "TORCH_SDPA_VLLM_V1"
57 + return "TORCH_SDPA"
58
59 @staticmethod
60 def get_impl_cls() -> type["TorchSDPABackendImpl"]:
vllm/v1/attention/backends/flash_attn.py
+1 -1
@@ -60,7 +60,7 @@ class FlashAttentionBackend(AttentionBackend):
60
61 @staticmethod
62 def get_name() -> str:
63 - return "FLASH_ATTN_VLLM_V1"
63 + return "FLASH_ATTN"
64
65 @staticmethod
66 def get_impl_cls() -> type["FlashAttentionImpl"]:
vllm/v1/attention/backends/flashinfer.py
+1 -1
@@ -167,7 +167,7 @@ class FlashInferBackend(AttentionBackend):
167
168 @staticmethod
169 def get_name() -> str:
170 - return "FLASHINFER_VLLM_V1"
170 + return "FLASHINFER"
171
172 @staticmethod
173 def get_impl_cls() -> type[FlashInferImpl]:
vllm/v1/attention/backends/mla/common.py
+1 -1
@@ -270,7 +270,7 @@ class MLACommonBackend(AttentionBackend):
270
271 @staticmethod
272 def get_name() -> str:
273 - return "TRITON_MLA_VLLM_V1"
273 + return "TRITON_MLA"
274
275 @staticmethod
276 def get_metadata_cls() -> type["AttentionMetadata"]:
vllm/v1/attention/backends/mla/flashmla.py
+1 -1
@@ -27,7 +27,7 @@ class FlashMLABackend(MLACommonBackend):
27
28 @staticmethod
29 def get_name() -> str:
30 - return "FLASHMLA_VLLM_V1"
30 + return "FLASHMLA"
31
32 @staticmethod
33 def get_metadata_cls() -> type["FlashMLAMetadata"]:
vllm/v1/attention/backends/mla/rocm_aiter_mla.py
+1 -1
@@ -33,7 +33,7 @@ class AiterMLABackend(MLACommonBackend):
33
34 @staticmethod
35 def get_name() -> str:
36 - return "ROCM_AITER_MLA_VLLM_V1"
36 + return "ROCM_AITER_MLA"
37
38 @staticmethod
39 def get_impl_cls() -> type["AiterMLAImpl"]:
vllm/v1/attention/backends/mla/triton_mla.py
+1 -1
@@ -24,7 +24,7 @@ class TritonMLABackend(MLACommonBackend):
24
25 @staticmethod
26 def get_name() -> str:
27 - return "TRITON_MLA_VLLM_V1"
27 + return "TRITON_MLA"
28
29 @staticmethod
30 def get_impl_cls() -> type["TritonMLAImpl"]:
vllm/v1/attention/backends/pallas.py
+1 -1
@@ -86,7 +86,7 @@ class PallasAttentionBackend(AttentionBackend):
86
87 @staticmethod
88 def get_name() -> str:
89 - return "PALLAS_VLLM_V1"
89 + return "PALLAS"
90
91 @staticmethod
92 def get_impl_cls() -> type["PallasAttentionBackendImpl"]:
vllm/v1/attention/backends/rocm_aiter_fa.py
+1 -1
@@ -340,7 +340,7 @@ class AiterFlashAttentionBackend(AttentionBackend):
340
341 @staticmethod
342 def get_name() -> str:
343 - return "FLASH_ATTN_VLLM_V1"
343 + return "FLASH_ATTN"
344
345 @staticmethod
346 def get_impl_cls() -> type["AiterFlashAttentionImpl"]:
vllm/v1/attention/backends/rocm_attn.py
+1 -1
@@ -159,7 +159,7 @@ class RocmAttentionBackend(AttentionBackend):
159
160 @staticmethod
161 def get_name() -> str:
162 - return "ROCM_ATTN_VLLM_V1"
162 + return "ROCM_ATTN"
163
164 @staticmethod
165 def get_impl_cls() -> type["RocmAttentionImpl"]:
vllm/v1/attention/backends/tree_attn.py
+1 -1
@@ -52,7 +52,7 @@ class TreeAttentionBackend(AttentionBackend):
52
53 @staticmethod
54 def get_name() -> str:
55 - return "TREE_ATTN_VLLM_V1"
55 + return "TREE_ATTN"
56
57 @staticmethod
58 def get_impl_cls() -> type["TreeAttentionImpl"]:
vllm/v1/attention/backends/triton_attn.py
+1 -1
@@ -155,7 +155,7 @@ class TritonAttentionBackend(AttentionBackend):
155
156 @staticmethod
157 def get_name() -> str:
158 - return "TRITON_ATTN_VLLM_V1"
158 + return "TRITON_ATTN"
159
160 @staticmethod
161 def get_impl_cls() -> type["TritonAttentionImpl"]:
vllm/v1/attention/backends/xformers.py
+1 -1
@@ -90,7 +90,7 @@ class XFormersAttentionBackend(AttentionBackend):
90
91 @staticmethod
92 def get_name() -> str:
93 - return "XFORMERS_VLLM_V1"
93 + return "XFORMERS"
94
95 @staticmethod
96 def get_impl_cls() -> type["XFormersAttentionImpl"]: