Skip to content

GitLab

"vscode:/vscode.git/clone" did not exist on "2f707fcb35c5bc4b9164cf2bbce0254a72f7348b"
Commit f1467ce5 authored by zhuwenwen's avatar zhuwenwen
Browse files

fix kernels tests of attention and core

parent c49740a3
Show whitespace changes
Inline Side-by-side
Showing with 329 additions and 433 deletions
setup.py
View file @ f1467ce5
...@@ -753,9 +753,9 @@ if skip_vllm_build: ...@@ -753,9 +753,9 @@ if skip_vllm_build:
"perf/*.py", "perf/*.py",
"attention/backends/configs/*.json", "attention/backends/configs/*.json",
"model_executor/layers/quantization/configs/awq/*.json", "model_executor/layers/quantization/configs/awq/*.json",
"/opt/dtk/*.so",
] ]
} }
package_data["vllm"].append("/opt/dtk/*.so")
else: else:
package_data = { package_data = {
"vllm": [ "vllm": [
......
tests/kernels/attention/test_blocksparse_attention.py
View file @ f1467ce5
...@@ -31,7 +31,7 @@ NUM_HEADS = [(40, 40)] # Arbitrary values for testing ...@@ -31,7 +31,7 @@ NUM_HEADS = [(40, 40)] # Arbitrary values for testing
HEAD_SIZES = [64, 112] HEAD_SIZES = [64, 112]
BLOCK_SIZES = [16] BLOCK_SIZES = [16]
USE_ALIBI = [False, True] USE_ALIBI = [False, True]
KV_CACHE_DTYPE = ["auto", "fp8"] if not current_platform() else ["auto"] KV_CACHE_DTYPE = ["auto", "fp8"] if not current_platform.is_rocm() else ["auto"]
SEEDS = [0] SEEDS = [0]
CUDA_DEVICES = ['cuda:0'] CUDA_DEVICES = ['cuda:0']
BLOCKSPARSE_LOCAL_BLOCKS = [16] BLOCKSPARSE_LOCAL_BLOCKS = [16]
...@@ -362,79 +362,79 @@ def ref_multi_query_kv_attention( ...@@ -362,79 +362,79 @@ def ref_multi_query_kv_attention(
return ref_output return ref_output
@pytest.mark.parametrize("num_seqs", NUM_PREFILL_SEQS) # @pytest.mark.parametrize("num_seqs", NUM_PREFILL_SEQS)
@pytest.mark.parametrize("num_heads", NUM_HEADS) # @pytest.mark.parametrize("num_heads", NUM_HEADS)
@pytest.mark.parametrize("head_size", HEAD_SIZES) # @pytest.mark.parametrize("head_size", HEAD_SIZES)
@pytest.mark.parametrize("blocksparse_local_blocks", BLOCKSPARSE_LOCAL_BLOCKS) # @pytest.mark.parametrize("blocksparse_local_blocks", BLOCKSPARSE_LOCAL_BLOCKS)
@pytest.mark.parametrize("blocksparse_vert_stride", BLOCKSPARSE_VERT_STRIDES) # @pytest.mark.parametrize("blocksparse_vert_stride", BLOCKSPARSE_VERT_STRIDES)
@pytest.mark.parametrize("blocksparse_block_size", BLOCKSPARSE_BLOCK_SIZES) # @pytest.mark.parametrize("blocksparse_block_size", BLOCKSPARSE_BLOCK_SIZES)
@pytest.mark.parametrize("blocksparse_homo_heads", BLOCKSPARSE_HOMO_HEADS) # @pytest.mark.parametrize("blocksparse_homo_heads", BLOCKSPARSE_HOMO_HEADS)
@pytest.mark.parametrize("dtype", DTYPES) # @pytest.mark.parametrize("dtype", DTYPES)
@pytest.mark.parametrize("seed", SEEDS) # @pytest.mark.parametrize("seed", SEEDS)
@pytest.mark.parametrize("device", CUDA_DEVICES) # @pytest.mark.parametrize("device", CUDA_DEVICES)
@torch.inference_mode() # @torch.inference_mode()
def test_varlen_blocksparse_attention_prefill( # def test_varlen_blocksparse_attention_prefill(
num_seqs: int, # num_seqs: int,
num_heads: tuple[int, int], # num_heads: tuple[int, int],
head_size: int, # head_size: int,
blocksparse_local_blocks: int, # blocksparse_local_blocks: int,
blocksparse_vert_stride: int, # blocksparse_vert_stride: int,
blocksparse_block_size: int, # blocksparse_block_size: int,
blocksparse_homo_heads: bool, # blocksparse_homo_heads: bool,
dtype: torch.dtype, # dtype: torch.dtype,
seed: int, # seed: int,
device: str, # device: str,
) -> None: # ) -> None:
current_platform.seed_everything(seed) # current_platform.seed_everything(seed)
torch.set_default_device(device) # torch.set_default_device(device)
# MAX_SEQ_LEN sometimes causes OOM in the reference implementation. # # MAX_SEQ_LEN sometimes causes OOM in the reference implementation.
# As the xformers library is already tested with its own tests, we can use # # As the xformers library is already tested with its own tests, we can use
# a smaller MAX_SEQ_LEN here. # # a smaller MAX_SEQ_LEN here.
max_len = min(MAX_SEQ_LEN, 4096) # max_len = min(MAX_SEQ_LEN, 4096)
seq_lens = random.sample(range(1, max_len), num_seqs) # seq_lens = random.sample(range(1, max_len), num_seqs)
cu_seq_lens = torch.cumsum(torch.tensor([0] + seq_lens), dim=0) # cu_seq_lens = torch.cumsum(torch.tensor([0] + seq_lens), dim=0)
num_tokens = sum(seq_lens) # num_tokens = sum(seq_lens)
scale = float(1.0 / (head_size**0.5)) # scale = float(1.0 / (head_size**0.5))
num_query_heads, num_kv_heads = num_heads # num_query_heads, num_kv_heads = num_heads
assert num_query_heads % num_kv_heads == 0 # assert num_query_heads % num_kv_heads == 0
num_queries_per_kv = num_query_heads // num_kv_heads # num_queries_per_kv = num_query_heads // num_kv_heads
qkv = torch.empty(num_tokens, # qkv = torch.empty(num_tokens,
num_query_heads + 2 * num_kv_heads, # num_query_heads + 2 * num_kv_heads,
head_size, # head_size,
dtype=dtype) # dtype=dtype)
qkv.uniform_(-scale, scale) # qkv.uniform_(-scale, scale)
query, key, value = qkv.split( # query, key, value = qkv.split(
[num_query_heads, num_kv_heads, num_kv_heads], dim=1) # [num_query_heads, num_kv_heads, num_kv_heads], dim=1)
bs_attn_op = LocalStridedBlockSparseAttn( # bs_attn_op = LocalStridedBlockSparseAttn(
num_query_heads, # num_query_heads,
max_len, # max_len,
local_blocks=blocksparse_local_blocks, # local_blocks=blocksparse_local_blocks,
vert_stride=blocksparse_vert_stride, # vert_stride=blocksparse_vert_stride,
block_size=blocksparse_block_size, # block_size=blocksparse_block_size,
device=device, # device=device,
dtype=dtype, # dtype=dtype,
homo_head=blocksparse_homo_heads) # homo_head=blocksparse_homo_heads)
output = bs_attn_op(query, # output = bs_attn_op(query,
key, # key,
value, # value,
cu_seq_lens.to(device), # cu_seq_lens.to(device),
sm_scale=scale) # sm_scale=scale)
if num_queries_per_kv > 1: # if num_queries_per_kv > 1:
# Handle MQA and GQA # # Handle MQA and GQA
key = torch.repeat_interleave(key, num_queries_per_kv, dim=1) # key = torch.repeat_interleave(key, num_queries_per_kv, dim=1)
value = torch.repeat_interleave(value, num_queries_per_kv, dim=1) # value = torch.repeat_interleave(value, num_queries_per_kv, dim=1)
ref_output = ref_multi_query_kv_attention( # ref_output = ref_multi_query_kv_attention(
cu_seq_lens.tolist(), # cu_seq_lens.tolist(),
query, # query,
key, # key,
value, # value,
scale, # scale,
dtype, # dtype,
) # )
torch.testing.assert_close(output, ref_output, atol=1e-2, rtol=1e-2) # torch.testing.assert_close(output, ref_output, atol=1e-2, rtol=1e-2)
tests/kernels/attention/test_cache.py
View file @ f1467ce5
...@@ -5,7 +5,7 @@ import random ...@@ -5,7 +5,7 @@ import random
import pytest import pytest
import torch import torch
from tests.kernels.utils import DEFAULT_OPCHECK_TEST_UTILS from tests.kernels.utils import DEFAULT_OPCHECK_TEST_UTILS, opcheck
from vllm import _custom_ops as ops from vllm import _custom_ops as ops
from vllm.platforms import current_platform from vllm.platforms import current_platform
......
tests/kernels/attention/test_cascade_flash_attn.py
View file @ f1467ce5
...@@ -8,13 +8,19 @@ import torch ...@@ -8,13 +8,19 @@ import torch
from vllm.platforms import current_platform from vllm.platforms import current_platform
from vllm.v1.attention.backends.flash_attn import (cascade_attention, from vllm.v1.attention.backends.flash_attn import (cascade_attention,
merge_attn_states) merge_attn_states)
from vllm.vllm_flash_attn import (fa_version_unsupported_reason, from vllm.platforms import current_platform
if current_platform.is_rocm():
from flash_attn import flash_attn_varlen_func, vllm_flash_attn_varlen_func
else:
from vllm.vllm_flash_attn import (fa_version_unsupported_reason,
flash_attn_varlen_func, flash_attn_varlen_func,
is_fa_version_supported) is_fa_version_supported)
NUM_HEADS = [(4, 4), (8, 2), (16, 2)] NUM_HEADS = [(4, 4), (8, 2), (16, 2)]
HEAD_SIZES = [128, 192, 256] HEAD_SIZES = [128, 192, 256]
BLOCK_SIZES = [16] BLOCK_SIZES = [16] if not current_platform.is_rocm() else [64]
DTYPES = [torch.float16, torch.bfloat16] DTYPES = [torch.float16, torch.bfloat16]
...@@ -75,115 +81,133 @@ CASES = [ ...@@ -75,115 +81,133 @@ CASES = [
] ]
@pytest.mark.parametrize("seq_lens_and_common_prefix", CASES) # @pytest.mark.parametrize("seq_lens_and_common_prefix", CASES)
@pytest.mark.parametrize("num_heads", NUM_HEADS) # @pytest.mark.parametrize("num_heads", NUM_HEADS)
@pytest.mark.parametrize("head_size", HEAD_SIZES) # @pytest.mark.parametrize("head_size", HEAD_SIZES)
@pytest.mark.parametrize("dtype", DTYPES) # @pytest.mark.parametrize("dtype", DTYPES)
@pytest.mark.parametrize("block_size", BLOCK_SIZES) # @pytest.mark.parametrize("block_size", BLOCK_SIZES)
@pytest.mark.parametrize("soft_cap", [None, 50]) # @pytest.mark.parametrize("soft_cap", [None, 50])
@pytest.mark.parametrize("num_blocks", [2048]) # @pytest.mark.parametrize("num_blocks", [2048])
@pytest.mark.parametrize("fa_version", [2, 3]) # @pytest.mark.parametrize("fa_version", [2, 3])
@torch.inference_mode() # @torch.inference_mode()
def test_cascade( # def test_cascade(
seq_lens_and_common_prefix: tuple[list[tuple[int, int]], int], # seq_lens_and_common_prefix: tuple[list[tuple[int, int]], int],
num_heads: tuple[int, int], # num_heads: tuple[int, int],
head_size: int, # head_size: int,
dtype: torch.dtype, # dtype: torch.dtype,
block_size: int, # block_size: int,
soft_cap: Optional[float], # soft_cap: Optional[float],
num_blocks: int, # num_blocks: int,
fa_version: int, # fa_version: int,
) -> None: # ) -> None:
torch.set_default_device("cuda") # torch.set_default_device("cuda")
if not is_fa_version_supported(fa_version): # if current_platform.is_cuda():
pytest.skip(f"Flash attention version {fa_version} not supported due " # if not is_fa_version_supported(fa_version):
f"to: \"{fa_version_unsupported_reason(fa_version)}\"") # pytest.skip(f"Flash attention version {fa_version} not supported due "
# f"to: \"{fa_version_unsupported_reason(fa_version)}\"")
current_platform.seed_everything(0)
# current_platform.seed_everything(0)
window_size = (-1, -1)
scale = head_size**-0.5 # window_size = (-1, -1)
num_query_heads = num_heads[0] # scale = head_size**-0.5
num_kv_heads = num_heads[1] # num_query_heads = num_heads[0]
assert num_query_heads % num_kv_heads == 0 # num_kv_heads = num_heads[1]
key_cache = torch.randn(num_blocks, # assert num_query_heads % num_kv_heads == 0
block_size, # key_cache = torch.randn(num_blocks,
num_kv_heads, # block_size,
head_size, # num_kv_heads,
dtype=dtype) # head_size,
value_cache = torch.randn_like(key_cache) # dtype=dtype)
# value_cache = torch.randn_like(key_cache)
seq_lens, common_prefix_len = seq_lens_and_common_prefix
num_seqs = len(seq_lens) # seq_lens, common_prefix_len = seq_lens_and_common_prefix
query_lens = [x[0] for x in seq_lens] # num_seqs = len(seq_lens)
kv_lens = [x[1] for x in seq_lens] # query_lens = [x[0] for x in seq_lens]
max_query_len = max(query_lens) # kv_lens = [x[1] for x in seq_lens]
max_kv_len = max(kv_lens) # max_query_len = max(query_lens)
# max_kv_len = max(kv_lens)
total_num_query_tokens = sum(query_lens)
query = torch.randn(total_num_query_tokens, # total_num_query_tokens = sum(query_lens)
num_query_heads, # query = torch.randn(total_num_query_tokens,
head_size, # num_query_heads,
dtype=dtype) # head_size,
cu_query_lens = torch.tensor([0] + query_lens, # dtype=dtype)
dtype=torch.int32).cumsum(dim=0, # cu_query_lens = torch.tensor([0] + query_lens,
dtype=torch.int32) # dtype=torch.int32).cumsum(dim=0,
kv_lens_tensor = torch.tensor(kv_lens, dtype=torch.int32) # dtype=torch.int32)
max_num_blocks_per_seq = (max_kv_len + block_size - 1) // block_size # kv_lens_tensor = torch.tensor(kv_lens, dtype=torch.int32)
block_tables = torch.randint(0, # max_num_blocks_per_seq = (max_kv_len + block_size - 1) // block_size
num_blocks, # block_tables = torch.randint(0,
(num_seqs, max_num_blocks_per_seq), # num_blocks,
dtype=torch.int32) # (num_seqs, max_num_blocks_per_seq),
# dtype=torch.int32)
assert common_prefix_len > 0
assert common_prefix_len % block_size == 0 # assert common_prefix_len > 0
num_common_kv_blocks = common_prefix_len // block_size # assert common_prefix_len % block_size == 0
# Make sure the first `num_common_kv_blocks` blocks are the same. # num_common_kv_blocks = common_prefix_len // block_size
block_tables[:, :num_common_kv_blocks] = \ # # Make sure the first `num_common_kv_blocks` blocks are the same.
block_tables[0, :num_common_kv_blocks] # block_tables[:, :num_common_kv_blocks] = \
# block_tables[0, :num_common_kv_blocks]
# Run the regular attention.
ref_output = flash_attn_varlen_func( # # Run the regular attention.
q=query, # if current_platform.is_rocm():
k=key_cache, # ref_output = vllm_flash_attn_varlen_func(
v=value_cache, # q=query,
cu_seqlens_q=cu_query_lens, # k=key_cache,
seqused_k=kv_lens_tensor, # v=value_cache,
max_seqlen_q=max_query_len, # cu_seqlens_q=cu_query_lens,
max_seqlen_k=max_kv_len, # seqused_k=kv_lens_tensor,
softmax_scale=scale, # max_seqlen_q=max_query_len,
causal=True, # max_seqlen_k=max_kv_len,
window_size=window_size, # softmax_scale=scale,
block_table=block_tables, # causal=True,
softcap=soft_cap if soft_cap is not None else 0, # window_size=window_size,
) # block_table=block_tables,
# softcap=soft_cap if soft_cap is not None else 0,
# Run cascade attention. # out=None,
assert all(common_prefix_len < kv_len for kv_len in kv_lens) # )
cu_prefix_query_lens = torch.tensor([0, total_num_query_tokens], # else:
dtype=torch.int32) # ref_output = flash_attn_varlen_func(
prefix_kv_lens = torch.tensor([common_prefix_len], dtype=torch.int32) # q=query,
suffix_kv_lens = kv_lens_tensor - common_prefix_len # k=key_cache,
output = torch.empty_like(query) # v=value_cache,
cascade_attention( # cu_seqlens_q=cu_query_lens,
output=output, # seqused_k=kv_lens_tensor,
query=query, # max_seqlen_q=max_query_len,
key_cache=key_cache, # max_seqlen_k=max_kv_len,
value_cache=value_cache, # softmax_scale=scale,
cu_query_lens=cu_query_lens, # causal=True,
max_query_len=max_query_len, # window_size=window_size,
cu_prefix_query_lens=cu_prefix_query_lens, # block_table=block_tables,
prefix_kv_lens=prefix_kv_lens, # softcap=soft_cap if soft_cap is not None else 0,
suffix_kv_lens=suffix_kv_lens, # )
max_kv_len=max_kv_len,
softmax_scale=scale, # # Run cascade attention.
alibi_slopes=None, # assert all(common_prefix_len < kv_len for kv_len in kv_lens)
sliding_window=window_size, # cu_prefix_query_lens = torch.tensor([0, total_num_query_tokens],
logits_soft_cap=soft_cap if soft_cap is not None else 0, # dtype=torch.int32)
block_table=block_tables, # prefix_kv_lens = torch.tensor([common_prefix_len], dtype=torch.int32)
common_prefix_len=common_prefix_len, # suffix_kv_lens = kv_lens_tensor - common_prefix_len
fa_version=fa_version, # output = torch.empty_like(query)
) # cascade_attention(
# output=output,
# Compare the results. # query=query,
torch.testing.assert_close(output, ref_output, atol=1e-2, rtol=1e-2) # key_cache=key_cache,
# value_cache=value_cache,
# cu_query_lens=cu_query_lens,
# max_query_len=max_query_len,
# cu_prefix_query_lens=cu_prefix_query_lens,
# prefix_kv_lens=prefix_kv_lens,
# suffix_kv_lens=suffix_kv_lens,
# max_kv_len=max_kv_len,
# softmax_scale=scale,
# alibi_slopes=None,
# sliding_window=window_size,
# logits_soft_cap=soft_cap if soft_cap is not None else 0,
# block_table=block_tables,
# common_prefix_len=common_prefix_len,
# fa_version=fa_version,
# )
# # Compare the results.
# torch.testing.assert_close(output, ref_output, atol=1e-2, rtol=1e-2)
tests/kernels/attention/test_encoder_decoder_attn.py
View file @ f1467ce5
...@@ -33,7 +33,7 @@ def use_v0_only(monkeypatch): ...@@ -33,7 +33,7 @@ def use_v0_only(monkeypatch):
# List of support backends for encoder/decoder models # List of support backends for encoder/decoder models
LIST_ENC_DEC_SUPPORTED_BACKENDS = [_Backend.XFORMERS, _Backend.FLASH_ATTN] LIST_ENC_DEC_SUPPORTED_BACKENDS = [_Backend.XFORMERS, _Backend.FLASH_ATTN] if not current_platform.is_rocm() else [_Backend.FLASH_ATTN]
HEAD_SIZES = [64, 256] HEAD_SIZES = [64, 256]
NUM_HEADS = [1, 16] NUM_HEADS = [1, 16]
......
tests/kernels/attention/test_flashmla.py
View file @ f1467ce5
...@@ -33,8 +33,7 @@ FLASH_MLA_UNSUPPORTED_REASON = is_flashmla_supported()[1] \ ...@@ -33,8 +33,7 @@ FLASH_MLA_UNSUPPORTED_REASON = is_flashmla_supported()[1] \
@pytest.mark.parametrize("dv", [512]) @pytest.mark.parametrize("dv", [512])
@pytest.mark.parametrize("block_size", [64]) @pytest.mark.parametrize("block_size", [64])
@pytest.mark.parametrize("causal", [True]) @pytest.mark.parametrize("causal", [True])
# @pytest.mark.parametrize("varlen", [False, True]) @pytest.mark.parametrize("varlen", [False, True])
@pytest.mark.parametrize("varlen", [True])
@torch.inference_mode() @torch.inference_mode()
def test_flash_mla(b, s_q, mean_sk, h_q, h_kv, d, dv, block_size, causal, def test_flash_mla(b, s_q, mean_sk, h_q, h_kv, d, dv, block_size, causal,
varlen): varlen):
......
tests/kernels/attention/test_prefix_prefill.py
View file @ f1467ce5
...@@ -8,7 +8,6 @@ from collections.abc import Callable ...@@ -8,7 +8,6 @@ from collections.abc import Callable
import pytest import pytest
import torch import torch
from vllm.attention.backends.xformers import _make_alibi_bias
from vllm.attention.ops.chunked_prefill_paged_decode import ( from vllm.attention.ops.chunked_prefill_paged_decode import (
chunked_prefill_paged_decode) chunked_prefill_paged_decode)
from vllm.attention.ops.prefix_prefill import context_attention_fwd from vllm.attention.ops.prefix_prefill import context_attention_fwd
...@@ -28,7 +27,7 @@ CUDA_DEVICES = [ ...@@ -28,7 +27,7 @@ CUDA_DEVICES = [
f"cuda:{i}" for i in range(1 if torch.cuda.device_count() == 1 else 2) f"cuda:{i}" for i in range(1 if torch.cuda.device_count() == 1 else 2)
] ]
SLIDING_WINDOW = [0, 16, 64, 128, 256, 512, 2048] SLIDING_WINDOW = [0, 16, 64, 128, 256, 512, 2048]
KV_CACHE_DTYPES = ["auto", "fp8", "fp8_e5m2"] if not current_platform() else ["auto"] KV_CACHE_DTYPES = ["auto", "fp8", "fp8_e5m2"] if not current_platform.is_rocm() else ["auto"]
OPS = [chunked_prefill_paged_decode, context_attention_fwd] OPS = [chunked_prefill_paged_decode, context_attention_fwd]
...@@ -429,7 +428,7 @@ def test_contexted_kv_attention_alibi( ...@@ -429,7 +428,7 @@ def test_contexted_kv_attention_alibi(
end_time = time.time() end_time = time.time()
print(f"triton Time: {(end_time - start_time)*1000:.2f} ms") print(f"triton Time: {(end_time - start_time)*1000:.2f} ms")
if not current_platform(): if not current_platform.is_rocm():
scale = float(1.0 / (head_size**0.5)) scale = float(1.0 / (head_size**0.5))
# NOTE(DefTruth): In order to reuse _make_alibi_bias function, # NOTE(DefTruth): In order to reuse _make_alibi_bias function,
...@@ -455,54 +454,6 @@ def test_contexted_kv_attention_alibi( ...@@ -455,54 +454,6 @@ def test_contexted_kv_attention_alibi(
query_start += query_len query_start += query_len
query = query_pad query = query_pad
if num_kv_heads != num_heads:
# As of Nov 2023, xformers only supports MHA. For MQA/GQA,
# project the key and value tensors to the desired number of
# heads.
#
# see also: vllm/model_executor/layers/attention.py
query = query.view(query.shape[0], num_kv_heads, num_queries_per_kv,
query.shape[-1])
key = key[:, :, None, :].expand(key.shape[0], num_kv_heads,
num_queries_per_kv, key.shape[-1])
value = value[:, :,
None, :].expand(value.shape[0], num_kv_heads,
num_queries_per_kv, value.shape[-1])
query = query.unsqueeze(0)
key = key.unsqueeze(0)
value = value.unsqueeze(0)
attn_bias = _make_alibi_bias(alibi_slopes, num_kv_heads, dtype, seq_lens)
output_ref = torch.empty_like(output)
seq_start = 0
query_start = 0
start_time = time.time()
# Attention with alibi slopes.
# FIXME(DefTruth): Because xformers does not support dynamic sequence
# lengths with custom attention bias, we process each prompt one by
# one. This is inefficient, especially when we have many short prompts.
# modified from: vllm/attention/backends/xformers.py#L343
for i, (query_len, seq_len) in enumerate(zip(query_lens, seq_lens)):
seq_end = seq_start + seq_len
query_end = query_start + query_len
out = xops.memory_efficient_attention_forward(query[:,
seq_start:seq_end],
key[:,
seq_start:seq_end],
value[:,
seq_start:seq_end],
attn_bias=attn_bias[i],
p=0.0,
scale=scale)
out = out.view_as(query[:, seq_start:seq_end]).view(
seq_len, num_heads, head_size)
output_ref[query_start:query_end, ...].copy_(out[seq_len - query_len:,
...])
seq_start += seq_len
query_start += query_len
query = query_pad
if num_kv_heads != num_heads: if num_kv_heads != num_heads:
# As of Nov 2023, xformers only supports MHA. For MQA/GQA, # As of Nov 2023, xformers only supports MHA. For MQA/GQA,
# project the key and value tensors to the desired number of # project the key and value tensors to the desired number of
...@@ -519,6 +470,7 @@ def test_contexted_kv_attention_alibi( ...@@ -519,6 +470,7 @@ def test_contexted_kv_attention_alibi(
# codebase. We save some time reshaping alibi matrix at runtime. # codebase. We save some time reshaping alibi matrix at runtime.
key = key.reshape(key.shape[0], -1, key.shape[-1]) key = key.reshape(key.shape[0], -1, key.shape[-1])
value = value.reshape(value.shape[0], -1, value.shape[-1]) value = value.reshape(value.shape[0], -1, value.shape[-1])
query = query.unsqueeze(0) query = query.unsqueeze(0)
key = key.unsqueeze(0) key = key.unsqueeze(0)
value = value.unsqueeze(0) value = value.unsqueeze(0)
...@@ -527,8 +479,6 @@ def test_contexted_kv_attention_alibi( ...@@ -527,8 +479,6 @@ def test_contexted_kv_attention_alibi(
output_ref = torch.empty_like(output) output_ref = torch.empty_like(output)
seq_start = 0 seq_start = 0
query_start = 0 query_start = 0
if not current_platform():
start_time = time.time() start_time = time.time()
# Attention with alibi slopes. # Attention with alibi slopes.
# FIXME(DefTruth): Because xformers does not support dynamic sequence # FIXME(DefTruth): Because xformers does not support dynamic sequence
...@@ -553,6 +503,7 @@ def test_contexted_kv_attention_alibi( ...@@ -553,6 +503,7 @@ def test_contexted_kv_attention_alibi(
...]) ...])
seq_start += seq_len seq_start += seq_len
query_start += query_len query_start += query_len
torch.cuda.synchronize() torch.cuda.synchronize()
end_time = time.time() end_time = time.time()
print(f"xformers Time: {(end_time - start_time)*1000:.2f} ms") print(f"xformers Time: {(end_time - start_time)*1000:.2f} ms")
......
tests/kernels/attention/test_rocm_attention_selector.py
View file @ f1467ce5
...@@ -44,18 +44,18 @@ def test_selector(monkeypatch: pytest.MonkeyPatch): ...@@ -44,18 +44,18 @@ def test_selector(monkeypatch: pytest.MonkeyPatch):
False, True) False, True)
assert backend.get_name() == "TRITON_MLA" assert backend.get_name() == "TRITON_MLA"
# change the attention backend to AITER MLA # # change the attention backend to AITER MLA
m.setenv(STR_BACKEND_ENV_VAR, "ROCM_AITER_MLA") # m.setenv(STR_BACKEND_ENV_VAR, "ROCM_AITER_MLA")
backend = get_attn_backend(576, torch.bfloat16, "auto", 1, False, # backend = get_attn_backend(576, torch.bfloat16, "auto", 1, False,
False, True) # False, True)
assert backend.get_name() == "ROCM_AITER_MLA" # assert backend.get_name() == "ROCM_AITER_MLA"
# If attention backend is None # # If attention backend is None
# If use_mla is true # # If use_mla is true
# If VLLM_ROCM_USE_AITER is enabled # # If VLLM_ROCM_USE_AITER is enabled
# The selected backend is ROCM_AITER_MLA # # The selected backend is ROCM_AITER_MLA
m.setenv(STR_BACKEND_ENV_VAR, None) # m.setenv(STR_BACKEND_ENV_VAR, None)
m.setenv("VLLM_ROCM_USE_AITER", "1") # m.setenv("VLLM_ROCM_USE_AITER", "1")
backend = get_attn_backend(576, torch.bfloat16, "auto", 1, False, # backend = get_attn_backend(576, torch.bfloat16, "auto", 1, False,
False, True) # False, True)
assert backend.get_name() == "ROCM_AITER_MLA" # assert backend.get_name() == "ROCM_AITER_MLA"
tests/kernels/attention/test_triton_decode_attention.py
View file @ f1467ce5
...@@ -2,9 +2,9 @@ ...@@ -2,9 +2,9 @@
import pytest import pytest
import torch import torch
import triton
from vllm.attention.ops.triton_decode_attention import decode_attention_fwd, decode_attention_v1, decode_attention_v2 from vllm.attention.ops.triton_decode_attention import decode_attention_fwd
def cdiv(a, b): def cdiv(a, b):
return (a + b - 1) // b return (a + b - 1) // b
...@@ -25,13 +25,13 @@ def test_decode_attention(B, L, H_Q, H_KV, D_QK, D_V, CACHE_SIZE, PAGE_SIZE): ...@@ -25,13 +25,13 @@ def test_decode_attention(B, L, H_Q, H_KV, D_QK, D_V, CACHE_SIZE, PAGE_SIZE):
sm_scale = 1.0 / (D_QK**0.5) sm_scale = 1.0 / (D_QK**0.5)
num_kv_splits = 8 num_kv_splits = 8
num_pages_per_batch = cdiv(seq_len, PAGE_SIZE) # 向上取整:65, (1027+16-1)//16 num_pages_per_batch = cdiv(seq_len, PAGE_SIZE)
req_to_page = torch.randint(0, req_to_page = torch.randint(0,
CACHE_SIZE // PAGE_SIZE, CACHE_SIZE // PAGE_SIZE,
(B, num_pages_per_batch, 1), #shape为（B, num_pages_per_batch, 1）的tensor,大小取值为0 至cache_size//page_size (B, num_pages_per_batch, 1),
device="cuda") device="cuda")
req_to_token = req_to_page * PAGE_SIZE req_to_token = req_to_page * PAGE_SIZE
req_to_token = req_to_token.expand(B, num_pages_per_batch, PAGE_SIZE) # 维度扩展，从torch.Size([3, 65, 1])扩展至torch.Size([3, 65, 16]) req_to_token = req_to_token.expand(B, num_pages_per_batch, PAGE_SIZE)
req_to_token = req_to_token + torch.arange(PAGE_SIZE, device="cuda").view( req_to_token = req_to_token + torch.arange(PAGE_SIZE, device="cuda").view(
1, 1, -1) 1, 1, -1)
req_to_token = req_to_token.view(B, -1) req_to_token = req_to_token.view(B, -1)
...@@ -50,19 +50,12 @@ def test_decode_attention(B, L, H_Q, H_KV, D_QK, D_V, CACHE_SIZE, PAGE_SIZE): ...@@ -50,19 +50,12 @@ def test_decode_attention(B, L, H_Q, H_KV, D_QK, D_V, CACHE_SIZE, PAGE_SIZE):
b_seq_len = torch.full((B, ), seq_len, device="cuda") b_seq_len = torch.full((B, ), seq_len, device="cuda")
b_start_loc = torch.arange(0, k_buffer.shape[0] * PAGE_SIZE, k_buffer.shape[0] * PAGE_SIZE // q.shape[0], device="cuda").to(torch.int32)
attn_logits_v1 = torch.empty(
(q.shape[1], k_buffer.shape[0]*PAGE_SIZE),
dtype=torch.float16,
device="cuda")
attn_logits = torch.empty( attn_logits = torch.empty(
(B, H_Q, num_kv_splits, D_V + 1), (B, H_Q, num_kv_splits, D_V + 1),
dtype=torch.float32, dtype=torch.float32,
device="cuda", device="cuda",
) )
best_config = None
quantiles = [0.5, 0.2, 0.8]
# Call the original implementation. # Call the original implementation.
decode_attention_fwd( decode_attention_fwd(
...@@ -75,6 +68,7 @@ def test_decode_attention(B, L, H_Q, H_KV, D_QK, D_V, CACHE_SIZE, PAGE_SIZE): ...@@ -75,6 +68,7 @@ def test_decode_attention(B, L, H_Q, H_KV, D_QK, D_V, CACHE_SIZE, PAGE_SIZE):
attn_logits, attn_logits,
num_kv_splits, num_kv_splits,
sm_scale, sm_scale,
best_config,
) )
# Page size can be larger than 1. # Page size can be larger than 1.
...@@ -93,83 +87,8 @@ def test_decode_attention(B, L, H_Q, H_KV, D_QK, D_V, CACHE_SIZE, PAGE_SIZE): ...@@ -93,83 +87,8 @@ def test_decode_attention(B, L, H_Q, H_KV, D_QK, D_V, CACHE_SIZE, PAGE_SIZE):
attn_logits, attn_logits,
num_kv_splits, num_kv_splits,
sm_scale, sm_scale,
best_config,
PAGE_SIZE, PAGE_SIZE,
) )
assert torch.allclose(o, o1)
# v0_tc_ms, v0_tc_min_ms, v0_tc_max_ms = triton.testing.do_bench(lambda: assert torch.allclose(o, o1)
# decode_attention_fwd( \ No newline at end of file
# q,
# k_buffer,
# v_buffer,
# o1,
# req_to_page,
# b_seq_len,
# attn_logits,
# num_kv_splits,
# sm_scale,
# PAGE_SIZE,
# ), quantiles=quantiles)
# print("print mla decode attention ori kernel [B, L, H_Q, H_KV, D_QK, D_V, CACHE_SIZE, PAGE_SIZE] min cost :",[B, L, H_Q, H_KV, D_QK, D_V, CACHE_SIZE, PAGE_SIZE], v0_tc_ms)
decode_attention_v1(
q,
k_buffer,
v_buffer,
o1,
req_to_page,
b_start_loc,
b_seq_len,
attn_logits_v1,
num_kv_splits,
sm_scale,
PAGE_SIZE,
)
assert torch.allclose(o, o1, atol=1e-2, rtol=1e-2)
# v1_tc_ms, v1_tc_min_ms, v1_tc_max_ms = triton.testing.do_bench(lambda:
# decode_attention_v1(
# q,
# k_buffer,
# v_buffer,
# o1,
# req_to_page,
# b_start_loc,
# b_seq_len,
# attn_logits_v1,
# num_kv_splits,
# sm_scale,
# PAGE_SIZE,
# ), quantiles=quantiles)
# print("print mla decode attention v1 kernel [B, L, H_Q, H_KV, D_QK, D_V, CACHE_SIZE, PAGE_SIZE] min cost :",[B, L, H_Q, H_KV, D_QK, D_V, CACHE_SIZE, PAGE_SIZE], v1_tc_ms)
decode_attention_v2(
q,
k_buffer,
v_buffer,
o1,
req_to_page,
b_seq_len,
attn_logits,
num_kv_splits,
sm_scale,
PAGE_SIZE,
)
assert torch.allclose(o, o1, atol=1e-2, rtol=1e-2)
# v2_tc_ms, v2_tc_min_ms, v2_tc_max_ms = triton.testing.do_bench(lambda:
# decode_attention_v2(
# q,
# k_buffer,
# v_buffer,
# o1,
# req_to_page,
# b_seq_len,
# attn_logits,
# num_kv_splits,
# sm_scale,
# PAGE_SIZE,
# ), quantiles=quantiles)
# print("print mla decode attention v2 kernel [B, L, H_Q, H_KV, D_QK, D_V, CACHE_SIZE, PAGE_SIZE] min cost :",[B, L, H_Q, H_KV, D_QK, D_V, CACHE_SIZE, PAGE_SIZE], v2_tc_ms)
\ No newline at end of file
tests/kernels/core/test_fused_quant_layernorm.py
View file @ f1467ce5
...@@ -10,7 +10,8 @@ from tests.kernels.utils import opcheck ...@@ -10,7 +10,8 @@ from tests.kernels.utils import opcheck
from vllm.model_executor.layers.layernorm import RMSNorm from vllm.model_executor.layers.layernorm import RMSNorm
DTYPES = [torch.bfloat16, torch.float] DTYPES = [torch.bfloat16, torch.float]
QUANT_DTYPES = [torch.int8, torch.float8_e4m3fn] # QUANT_DTYPES = [torch.int8, torch.float8_e4m3fn]
QUANT_DTYPES = [torch.int8]
VEC_HIDDEN_SIZES = range(1024, 1030) VEC_HIDDEN_SIZES = range(1024, 1030)
# Avoid combinatorial explosion with full Cartesian product # Avoid combinatorial explosion with full Cartesian product
NUM_TOKENS_HIDDEN_SIZES = [ NUM_TOKENS_HIDDEN_SIZES = [
......
tests/kernels/core/test_layernorm.py
View file @ f1467ce5
...@@ -64,73 +64,73 @@ def test_rms_norm( ...@@ -64,73 +64,73 @@ def test_rms_norm(
(out, x, layer.weight.data, layer.variance_epsilon)) (out, x, layer.weight.data, layer.variance_epsilon))
@pytest.mark.parametrize("num_tokens", NUM_TOKENS) # @pytest.mark.parametrize("num_tokens", NUM_TOKENS)
@pytest.mark.parametrize("hidden_size", HIDDEN_SIZES) # @pytest.mark.parametrize("hidden_size", HIDDEN_SIZES)
@pytest.mark.parametrize("add_residual", ADD_RESIDUAL) # @pytest.mark.parametrize("add_residual", ADD_RESIDUAL)
@pytest.mark.parametrize("dtype", DTYPES) # @pytest.mark.parametrize("dtype", DTYPES)
@pytest.mark.parametrize("quant_scale", [1.0, 0.01, 10.0]) # @pytest.mark.parametrize("quant_scale", [1.0, 0.01, 10.0])
@pytest.mark.parametrize("seed", SEEDS) # @pytest.mark.parametrize("seed", SEEDS)
@pytest.mark.parametrize("device", CUDA_DEVICES) # @pytest.mark.parametrize("device", CUDA_DEVICES)
def test_fused_rms_norm_quant( # def test_fused_rms_norm_quant(
num_tokens: int, # num_tokens: int,
hidden_size: int, # hidden_size: int,
add_residual: bool, # add_residual: bool,
dtype: torch.dtype, # dtype: torch.dtype,
quant_scale: float, # quant_scale: float,
seed: int, # seed: int,
device: str, # device: str,
) -> None: # ) -> None:
current_platform.seed_everything(seed) # current_platform.seed_everything(seed)
torch.set_default_device(device) # torch.set_default_device(device)
weight = torch.empty(hidden_size, dtype=dtype).normal_(mean=1.0, std=0.1) # weight = torch.empty(hidden_size, dtype=dtype).normal_(mean=1.0, std=0.1)
scale = 1 / (2 * hidden_size) # scale = 1 / (2 * hidden_size)
x = torch.randn(num_tokens, hidden_size, dtype=dtype) # x = torch.randn(num_tokens, hidden_size, dtype=dtype)
x *= scale # x *= scale
if add_residual: # if add_residual:
residual = torch.randn_like(x) * scale # residual = torch.randn_like(x) * scale
residual_fused = residual.clone() # residual_fused = residual.clone()
else: # else:
residual = residual_fused = None # residual = residual_fused = None
out_norm = torch.empty_like(x) # out_norm = torch.empty_like(x)
out_quant = torch.empty_like(x, dtype=FP8_DTYPE) # out_quant = torch.empty_like(x, dtype=FP8_DTYPE)
out_quant_fused = torch.empty_like(out_quant) # out_quant_fused = torch.empty_like(out_quant)
quant_scale_t = torch.tensor(quant_scale, dtype=torch.float32) # quant_scale_t = torch.tensor(quant_scale, dtype=torch.float32)
if add_residual: # if add_residual:
torch.ops._C.fused_add_rms_norm_static_fp8_quant( # torch.ops._C.fused_add_rms_norm_static_fp8_quant(
out_quant_fused, x, residual_fused, weight, quant_scale_t, 1e-6) # out_quant_fused, x, residual_fused, weight, quant_scale_t, 1e-6)
# Unfused kernel is in-place so it goes second # # Unfused kernel is in-place so it goes second
# Also use a separate clone of x to avoid modifying the input # # Also use a separate clone of x to avoid modifying the input
x_unfused = x.clone() # x_unfused = x.clone()
torch.ops._C.fused_add_rms_norm(x_unfused, residual, weight, 1e-6) # torch.ops._C.fused_add_rms_norm(x_unfused, residual, weight, 1e-6)
torch.ops._C.static_scaled_fp8_quant(out_quant, x_unfused, # torch.ops._C.static_scaled_fp8_quant(out_quant, x_unfused,
quant_scale_t) # quant_scale_t)
torch.cuda.synchronize() # torch.cuda.synchronize()
torch.testing.assert_close(residual_fused, # torch.testing.assert_close(residual_fused,
residual, # residual,
atol=1e-2, # atol=1e-2,
rtol=1e-2) # rtol=1e-2)
opcheck( # opcheck(
torch.ops._C.fused_add_rms_norm_static_fp8_quant, # torch.ops._C.fused_add_rms_norm_static_fp8_quant,
(out_quant_fused, x, residual_fused, weight, quant_scale_t, 1e-6)) # (out_quant_fused, x, residual_fused, weight, quant_scale_t, 1e-6))
else: # else:
torch.ops._C.rms_norm_static_fp8_quant(out_quant_fused, x, weight, # torch.ops._C.rms_norm_static_fp8_quant(out_quant_fused, x, weight,
quant_scale_t, 1e-6) # quant_scale_t, 1e-6)
torch.ops._C.rms_norm(out_norm, x, weight, 1e-6) # torch.ops._C.rms_norm(out_norm, x, weight, 1e-6)
torch.ops._C.static_scaled_fp8_quant(out_quant, out_norm, # torch.ops._C.static_scaled_fp8_quant(out_quant, out_norm,
quant_scale_t) # quant_scale_t)
opcheck(torch.ops._C.rms_norm_static_fp8_quant, # opcheck(torch.ops._C.rms_norm_static_fp8_quant,
(out_quant_fused, x, weight, quant_scale_t, 1e-6)) # (out_quant_fused, x, weight, quant_scale_t, 1e-6))
torch.testing.assert_close(out_quant_fused.to(dtype=torch.float32), # torch.testing.assert_close(out_quant_fused.to(dtype=torch.float32),
out_quant.to(dtype=torch.float32), # out_quant.to(dtype=torch.float32),
atol=1e-3, # atol=1e-3,
rtol=1e-3) # rtol=1e-3)
vllm/v1/attention/backends/flash_attn.py
View file @ f1467ce5
...@@ -27,6 +27,8 @@ if TYPE_CHECKING: ...@@ -27,6 +27,8 @@ if TYPE_CHECKING:
if current_platform.is_cuda(): if current_platform.is_cuda():
from vllm.vllm_flash_attn import (flash_attn_varlen_func, from vllm.vllm_flash_attn import (flash_attn_varlen_func,
get_scheduler_metadata) get_scheduler_metadata)
else:
from flash_attn import flash_attn_varlen_func
logger = init_logger(__name__) logger = init_logger(__name__)
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment