bb4337b34c · tduncan/Nvidia-Optimization-Stack-VLLM

docs/design/plugin_system.md

+1

@@ -154,3 +154,4 @@ The interface for the model/module may change during vLLM's development. If you

154 !!! warning "Deprecations"

155 - `use_v1` parameter in `Platform.get_attn_backend_cls` is deprecated. It has been removed in v0.13.0.

156 - `_Backend` in `vllm.attention` is deprecated. It has been removed in v0.13.0. Please use `vllm.attention.backends.registry.register_backend` to add new attention backend to `AttentionBackendEnum` instead.

157 + - `seed_everything` platform interface is deprecated. It will be removed in v0.14.0 or later. Please use `vllm.utils.torch_utils.set_random_seed` instead.

tests/compile/distributed/test_async_tp.py

+2 -1

@@ -26,6 +26,7 @@ from vllm.distributed.parallel_state import (

26 )

27 from vllm.platforms import current_platform

28 from vllm.utils.system_utils import update_environment_variables

29 +from vllm.utils.torch_utils import set_random_seed

30

31 from ...models.registry import HF_EXAMPLE_MODELS

32 from ...utils import (

@@ -301,7 +302,7 @@ def async_tp_pass_on_test_model(

302 dtype: torch.dtype,

303 dynamic: bool,

304 ):

304 - current_platform.seed_everything(0)

305 + set_random_seed(0)

306

307 device = torch.device(f"cuda:{local_rank}")

308 torch.cuda.set_device(device)

tests/compile/distributed/test_fusion_all_reduce.py

+2 -1

@@ -32,6 +32,7 @@ from vllm.model_executor.layers.quantization.utils.w8a8_utils import (

32 )

33 from vllm.platforms import current_platform

34 from vllm.utils.system_utils import update_environment_variables

35 +from vllm.utils.torch_utils import set_random_seed

36

37 from ...utils import has_module_attribute, multi_gpu_test

38 from ..backend import TestBackend

@@ -263,7 +264,7 @@ def all_reduce_fusion_pass_on_test_model(

264 enable_rms_norm_custom_op,

265 enable_quant_fp8_custom_op,

266 ):

266 - current_platform.seed_everything(0)

267 + set_random_seed(0)

268

269 device = torch.device(f"cuda:{local_rank}")

270 torch.cuda.set_device(device)

tests/compile/distributed/test_sequence_parallelism.py

+2 -1

@@ -31,6 +31,7 @@ from vllm.model_executor.layers.quantization.utils.quant_utils import GroupShape

31 from vllm.model_executor.layers.quantization.utils.w8a8_utils import Fp8LinearOp

32 from vllm.platforms import current_platform

33 from vllm.utils.system_utils import update_environment_variables

34 +from vllm.utils.torch_utils import set_random_seed

35

36 from ...utils import multi_gpu_test

37 from ..backend import TestBackend

@@ -232,7 +233,7 @@ def sequence_parallelism_pass_on_test_model(

233 fuse_norm_quant: bool,

234 dynamic: bool,

235 ):

235 - current_platform.seed_everything(0)

236 + set_random_seed(0)

237

238 device = torch.device(f"cuda:{local_rank}")

239 torch.cuda.set_device(device)

tests/kernels/attention/test_aiter_flash_attn.py

+2 -1

@@ -8,6 +8,7 @@ import torch

8 import vllm.v1.attention.backends.rocm_aiter_fa # noqa: F401

9 from vllm.attention.utils.fa_utils import is_flash_attn_varlen_func_available

10 from vllm.platforms import current_platform

11 +from vllm.utils.torch_utils import set_random_seed

12

13 NUM_HEADS = [(4, 4), (8, 2)]

14 HEAD_SIZES = [128, 256]

@@ -104,7 +105,7 @@ def test_varlen_with_paged_kv(

105 if not is_flash_attn_varlen_func_available():

106 pytest.skip("flash_attn_varlen_func required to run this test.")

107 torch.set_default_device("cuda")

107 - current_platform.seed_everything(0)

108 + set_random_seed(0)

109 num_seqs = len(seq_lens)

110 query_lens = [x[0] for x in seq_lens]

111 kv_lens = [x[1] for x in seq_lens]

tests/kernels/attention/test_attention.py

+2 -1

@@ -13,6 +13,7 @@ from vllm.attention.layer import Attention

13 from vllm.attention.layers.mm_encoder_attention import MMEncoderAttention

14 from vllm.platforms import current_platform

15 from vllm.utils.mem_utils import get_max_shared_memory_bytes

16 +from vllm.utils.torch_utils import set_random_seed

17

18 FLOAT32_BYTES = torch.finfo(torch.float).bits // 8

19 # This will change depending on the compute capability.

@@ -150,7 +151,7 @@ def test_paged_attention(

151

152 global PARTITION_SIZE

153

153 - current_platform.seed_everything(seed)

154 + set_random_seed(seed)

155 torch.set_default_device(device)

156 scale = float(1.0 / (head_size**0.5))

157 num_query_heads, num_kv_heads = num_heads

tests/kernels/attention/test_cache.py

+9 -8

@@ -9,6 +9,7 @@ import torch

9 from tests.kernels.utils import DEFAULT_OPCHECK_TEST_UTILS, opcheck

10 from vllm import _custom_ops as ops

11 from vllm.platforms import current_platform

12 +from vllm.utils.torch_utils import set_random_seed

13

14 COPYING_DIRECTION = [("cuda", "cpu"), ("cuda", "cuda"), ("cpu", "cuda")]

15 DTYPES = [torch.bfloat16, torch.float]

@@ -64,7 +65,7 @@ def test_reshape_and_cache(

65 ) -> None:

66 if kv_cache_dtype == "fp8" and head_size % 16:

67 pytest.skip()

67 - current_platform.seed_everything(seed)

68 + set_random_seed(seed)

69 torch.set_default_device(device)

70 torch.cuda.set_device(device)

71 # Create a random slot mapping.

@@ -185,7 +186,7 @@ def test_reshape_and_cache_flash(

186 kv_cache_layout: str,

187 implementation: str,

188 ) -> None:

188 - current_platform.seed_everything(seed)

189 + set_random_seed(seed)

190 torch.set_default_device(device)

191 torch.cuda.set_device(device)

192 assert implementation in ["cuda", "triton"]

@@ -355,7 +356,7 @@ def test_swap_blocks(

356 if kv_cache_dtype == "fp8" and head_size % 16:

357 pytest.skip()

358

358 - current_platform.seed_everything(seed)

359 + set_random_seed(seed)

360

361 src_device = device if direction[0] == "cuda" else "cpu"

362 dst_device = device if direction[1] == "cuda" else "cpu"

@@ -444,7 +445,7 @@ def test_fp8_e4m3_conversion(

445 seed: int,

446 device: str,

447 ) -> None:

447 - current_platform.seed_everything(seed)

448 + set_random_seed(seed)

449

450 low = -224.0

451 high = 224.0

@@ -507,7 +508,7 @@ def test_concat_and_cache_mla(

508 device: str,

509 kv_cache_dtype: str,

510 ) -> None:

510 - current_platform.seed_everything(seed)

511 + set_random_seed(seed)

512 torch.set_default_device(device)

513 torch.cuda.set_device(device)

514

@@ -584,7 +585,7 @@ def test_concat_and_cache_ds_mla(

585 if dtype.itemsize != 2:

586 pytest.skip("ds_mla only supports 16-bit input")

587 kv_cache_dtype = "fp8_ds_mla"

587 - current_platform.seed_everything(seed)

588 + set_random_seed(seed)

589 torch.set_default_device(device)

590 torch.cuda.set_device(device)

591

@@ -695,7 +696,7 @@ def test_swap_blocks_mla(

696 device: str,

697 kv_cache_dtype: str,

698 ) -> None:

698 - current_platform.seed_everything(seed)

699 + set_random_seed(seed)

700 torch.set_default_device(device)

701 torch.cuda.set_device(device)

702

@@ -947,7 +948,7 @@ def test_concat_and_cache_mla_cpu(

948 ) -> None:

949 device = "cpu"

950 kv_cache_dtype = "auto"

950 - current_platform.seed_everything(seed)

951 + set_random_seed(seed)

952 torch.set_default_device(device)

953

954 total_slots = num_blocks * block_size

tests/kernels/attention/test_cascade_flash_attn.py

+3 -2

@@ -6,6 +6,7 @@ import pytest

6 import torch

7

8 from vllm.platforms import current_platform

9 +from vllm.utils.torch_utils import set_random_seed

10 from vllm.v1.attention.backends.flash_attn import cascade_attention, merge_attn_states

11

12 try:

@@ -39,7 +40,7 @@ def test_merge_kernel(

40 dtype: torch.dtype,

41 ):

42 torch.set_default_device("cuda")

42 - current_platform.seed_everything(0)

43 + set_random_seed(0)

44 num_query_heads = num_heads[0]

45 num_kv_heads = num_heads[1]

46 assert num_query_heads % num_kv_heads == 0

@@ -103,7 +104,7 @@ def test_cascade(

104 f'to: "{fa_version_unsupported_reason(fa_version)}"'

105 )

106

106 - current_platform.seed_everything(0)

107 + set_random_seed(0)

108

109 window_size = (-1, -1)

110 scale = head_size**-0.5

tests/kernels/attention/test_cpu_attn.py

+2 -1

@@ -8,6 +8,7 @@ import pytest

8 import torch

9

10 from vllm.platforms import CpuArchEnum, current_platform

11 +from vllm.utils.torch_utils import set_random_seed

12 from vllm.v1.attention.backends.cpu_attn import _get_attn_isa

13

14 if not current_platform.is_cpu():

@@ -190,7 +191,7 @@ def varlen_with_paged_kv(

191 use_sink: bool,

192 isa: str,

193 ) -> None:

193 - current_platform.seed_everything(0)

194 + set_random_seed(0)

195 num_seqs = len(seq_lens)

196 query_lens = [x[0] for x in seq_lens]

197 kv_lens = [x[1] for x in seq_lens]

tests/kernels/attention/test_flash_attn.py

+2 -1

@@ -6,6 +6,7 @@ import pytest

6 import torch

7

8 from vllm.platforms import current_platform

9 +from vllm.utils.torch_utils import set_random_seed

10

11 try:

12 from vllm.vllm_flash_attn import (

@@ -129,7 +130,7 @@ def test_varlen_with_paged_kv(

130 "Flash attention with quantized inputs is only "

131 "supported on version 3 with bfloat16 base type"

132 )

132 - current_platform.seed_everything(0)

133 + set_random_seed(0)

134 num_seqs = len(seq_lens)

135 query_lens = [x[0] for x in seq_lens]

136 kv_lens = [x[1] for x in seq_lens]

tests/kernels/attention/test_flashinfer.py

+5 -4

@@ -5,6 +5,7 @@

5 import pytest

6

7 from vllm.platforms import current_platform

8 +from vllm.utils.torch_utils import set_random_seed

9

10 try:

11 import flashinfer

@@ -101,7 +102,7 @@ def test_flashinfer_decode_with_paged_kv(

102 sliding_window: int | None,

103 ) -> None:

104 torch.set_default_device("cuda")

104 - current_platform.seed_everything(0)

105 + set_random_seed(0)

106 num_seqs = len(kv_lens)

107 num_query_heads = num_heads[0]

108 num_kv_heads = num_heads[1]

@@ -196,7 +197,7 @@ def test_flashinfer_prefill_with_paged_kv(

197 sliding_window: int | None,

198 ) -> None:

199 torch.set_default_device("cuda")

199 - current_platform.seed_everything(0)

200 + set_random_seed(0)

201 num_seqs = len(seq_lens)

202 query_lens = [x[0] for x in seq_lens]

203 kv_lens = [x[1] for x in seq_lens]

@@ -299,7 +300,7 @@ def test_flashinfer_prefill_with_paged_fp8_kv(

300 ) -> None:

301 pytest.skip("TODO: fix the accuracy issue")

302 torch.set_default_device("cuda")

302 - current_platform.seed_everything(0)

303 + set_random_seed(0)

304 num_seqs = len(seq_lens)

305 query_lens = [x[0] for x in seq_lens]

306 kv_lens = [x[1] for x in seq_lens]

@@ -409,7 +410,7 @@ def test_flashinfer_decode_with_paged_fp8_kv(

410 ) -> None:

411 # test doesn't work for num_heads = (16,16)

412 torch.set_default_device("cuda")

412 - current_platform.seed_everything(0)

413 + set_random_seed(0)

414 num_seqs = len(kv_lens)

415 num_query_heads = num_heads[0]

416 num_kv_heads = num_heads[1]

tests/kernels/attention/test_flashinfer_trtllm_attention.py

+3 -2

@@ -10,6 +10,7 @@ from tests.kernels.quantization.nvfp4_utils import (

10 )

11 from vllm.platforms import current_platform

12 from vllm.utils.math_utils import round_up

13 +from vllm.utils.torch_utils import set_random_seed

14

15 if not current_platform.is_device_capability_family(100):

16 pytest.skip(

@@ -80,7 +81,7 @@ def test_flashinfer_trtllm_decode_with_baseline(

81 has_sinks: bool,

82 ) -> None:

83 torch.set_default_device("cuda")

83 - current_platform.seed_everything(42)

84 + set_random_seed(42)

85

86 q_quant_dtype, kv_quant_dtype, o_quant_dtype = quant_dtypes

87 q_quant_dtype = q_quant_dtype or dtype

@@ -279,7 +280,7 @@ def test_flashinfer_trtllm_prefill_with_baseline(

280 has_sinks: bool,

281 ) -> None:

282 torch.set_default_device("cuda")

282 - current_platform.seed_everything(42)

283 + set_random_seed(42)

284

285 q_quant_dtype, kv_quant_dtype, o_quant_dtype = quant_dtypes

286 q_quant_dtype = q_quant_dtype or dtype

tests/kernels/attention/test_lightning_attn.py

+4 -4

@@ -5,7 +5,7 @@ import pytest

5 import torch

6

7 from vllm.model_executor.layers.lightning_attn import linear_decode_forward_triton

8 -from vllm.platforms import current_platform

8 +from vllm.utils.torch_utils import set_random_seed

9

10 NUM_HEADS = [4, 8]

11 HEAD_SIZES = [64]

@@ -124,7 +124,7 @@ def test_linear_decode_forward_triton(

124 torch.set_default_device("cuda")

125 torch.manual_seed(42)

126 torch.cuda.manual_seed_all(42)

127 - current_platform.seed_everything(42)

127 + set_random_seed(42)

128 base = 0.01

129 q = base * torch.randn(batch_size, num_heads, 1, head_size, dtype=dtype)

130 k = base * torch.randn(batch_size, num_heads, 1, head_size, dtype=dtype)

@@ -167,7 +167,7 @@ def test_linear_decode_forward_triton_with_padding(

167 torch.set_default_device("cuda")

168 torch.manual_seed(42)

169 torch.cuda.manual_seed_all(42)

170 - current_platform.seed_everything(42)

170 + set_random_seed(42)

171

172 batch_size = 4

173 base = 0.01

@@ -231,7 +231,7 @@ def test_lightning_attention_reference(

231 torch.set_default_device("cuda")

232 torch.manual_seed(42)

233 torch.cuda.manual_seed_all(42)

234 - current_platform.seed_everything(42)

234 + set_random_seed(42)

235

236 base = 0.01

237 q = base * torch.randn(batch_size, num_heads, seq_len, head_size, dtype=dtype)

tests/kernels/attention/test_mha_attn.py

+3 -2

@@ -19,6 +19,7 @@ from vllm.platforms import current_platform

19 from vllm.platforms.cpu import CpuPlatform

20 from vllm.platforms.cuda import CudaPlatform

21 from vllm.platforms.rocm import RocmPlatform

22 +from vllm.utils.torch_utils import set_random_seed

23

24

25 @pytest.fixture(autouse=True)

@@ -123,7 +124,7 @@ def test_mha_attn_forward(

124 dtype: torch.dtype,

125 device: str,

126 ):

126 - current_platform.seed_everything(0)

127 + set_random_seed(0)

128 torch.set_default_device(device)

129 torch.set_default_dtype(dtype)

130

@@ -168,7 +169,7 @@ def test_mha_attn_varlen_forward(

169 dtype: torch.dtype,

170 device: str,

171 ):

171 - current_platform.seed_everything(0)

172 + set_random_seed(0)

173 torch.set_default_device(device)

174 torch.set_default_dtype(dtype)

175

tests/kernels/attention/test_prefix_prefill.py

+3 -3

@@ -13,7 +13,7 @@ import torch.nn.functional as F

13 from vllm.attention.ops.chunked_prefill_paged_decode import chunked_prefill_paged_decode

14 from vllm.attention.ops.prefix_prefill import context_attention_fwd

15 from vllm.platforms import current_platform

16 -from vllm.utils.torch_utils import STR_DTYPE_TO_TORCH_DTYPE

16 +from vllm.utils.torch_utils import STR_DTYPE_TO_TORCH_DTYPE, set_random_seed

17

18 NUM_HEADS = [64]

19 NUM_QUERIES_PER_KV = [1, 64]

@@ -125,7 +125,7 @@ def test_contexted_kv_attention(

125 ):

126 pytest.skip("ROCm custom paged attention does not support fp8_e5m2 KV cache")

127

128 - current_platform.seed_everything(0)

128 + set_random_seed(0)

129 torch.set_default_device(device)

130

131 # Need this, otherwise when we capture the graph the process

@@ -346,7 +346,7 @@ def test_contexted_kv_attention_alibi(

346 ):

347 pytest.skip("ROCm custom paged attention does not support fp8_e5m2 KV cache")

348

349 - current_platform.seed_everything(0)

349 + set_random_seed(0)

350 torch.set_default_device(device)

351

352 # Need this, otherwise when we capture the graph the process

tests/kernels/attention/test_triton_unified_attention.py

+2 -1

@@ -8,6 +8,7 @@ import torch

8 from vllm.attention.ops.triton_unified_attention import unified_attention

9 from vllm.platforms import current_platform

10 from vllm.utils.math_utils import next_power_of_2

11 +from vllm.utils.torch_utils import set_random_seed

12

13 NUM_HEADS = [(4, 4), (8, 2)]

14 HEAD_SIZES = [128, 256]

@@ -113,7 +114,7 @@ def test_triton_unified_attn(

114 ) -> None:

115 torch.set_default_device("cuda")

116

116 - current_platform.seed_everything(0)

117 + set_random_seed(0)

118 num_seqs = len(seq_lens)

119 query_lens = [x[0] for x in seq_lens]

120 kv_lens = [x[1] for x in seq_lens]

tests/kernels/core/test_activation.py

+3 -3

@@ -18,7 +18,7 @@ from vllm.model_executor.layers.activation import (

18 SiluAndMul,

19 SwigluOAIAndMul,

20 )

21 -from vllm.platforms import current_platform

21 +from vllm.utils.torch_utils import set_random_seed

22

23 DTYPES = [torch.half, torch.bfloat16, torch.float]

24 NUM_TOKENS = [7, 83, 2048] # Arbitrary values for testing

@@ -52,7 +52,7 @@ def test_act_and_mul(

52 seed: int,

53 device: str,

54 ) -> None:

55 - current_platform.seed_everything(seed)

55 + set_random_seed(seed)

56 torch.set_default_device(device)

57 x = torch.randn(num_tokens, 2 * d, dtype=dtype)

58 if activation == "silu_and_mul":

@@ -129,7 +129,7 @@ def test_activation(

129 seed: int,

130 device: str,

131 ) -> None:

132 - current_platform.seed_everything(seed)

132 + set_random_seed(seed)

133 torch.set_default_device(device)

134 x = torch.randn(num_tokens, d, dtype=dtype)

135 layer = activation[0]()

tests/kernels/core/test_fused_qk_norm_rope.py

+2 -1

@@ -8,6 +8,7 @@ from tests.kernels.utils import opcheck

8 from vllm.model_executor.layers.layernorm import RMSNorm

9 from vllm.model_executor.layers.rotary_embedding import RotaryEmbedding

10 from vllm.platforms import current_platform

11 +from vllm.utils.torch_utils import set_random_seed

12

13 DTYPES = [torch.bfloat16, torch.float16]

14 IS_NEOX = [True, False]

@@ -64,7 +65,7 @@ def test_fused_qk_norm_rope_matches_reference(

65 rotary_ratio: float,

66 ):

67 torch.set_default_device(device)

67 - current_platform.seed_everything(seed)

68 + set_random_seed(seed)

69 num_heads, num_kv_heads, head_dim = 16, 4, 128

70 num_tokens = 4

71

tests/kernels/core/test_layernorm.py

+3 -3

@@ -7,7 +7,7 @@ import torch

7 from tests.kernels.quant_utils import FP8_DTYPE

8 from tests.kernels.utils import opcheck

9 from vllm.model_executor.layers.layernorm import RMSNorm

10 -from vllm.platforms import current_platform

10 +from vllm.utils.torch_utils import set_random_seed

11

12 DTYPES = [torch.half, torch.bfloat16, torch.float]

13 NUM_TOKENS = [7, 83, 4096] # Arbitrary values for testing

@@ -34,7 +34,7 @@ def test_rms_norm(

34 device: str,

35 strided_input: bool,

36 ) -> None:

37 - current_platform.seed_everything(seed)

37 + set_random_seed(seed)

38 torch.set_default_device(device)

39 layer = RMSNorm(hidden_size).to(dtype=dtype)

40 layer.weight.data.normal_(mean=1.0, std=0.1)

@@ -88,7 +88,7 @@ def test_fused_rms_norm_quant(

88 device: str,

89 strided_input: bool,

90 ) -> None:

91 - current_platform.seed_everything(seed)

91 + set_random_seed(seed)

92 torch.set_default_device(device)

93

94 weight = torch.empty(hidden_size, dtype=dtype).normal_(mean=1.0, std=0.1)

tests/kernels/core/test_mrope.py

+2 -1

@@ -10,6 +10,7 @@ from transformers import __version__ as TRANSFORMERS_VERSION

10 from vllm.model_executor.layers.rotary_embedding import get_rope

11 from vllm.platforms import current_platform

12 from vllm.transformers_utils.config import get_config

13 +from vllm.utils.torch_utils import set_random_seed

14

15 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

16

@@ -24,7 +25,7 @@ def generate_test_data(

25 device: torch.device,

26 ):

27 """Generate test data for given configuration."""

27 - current_platform.seed_everything(42)

28 + set_random_seed(42)

29 # Create 2D positions (3, num_tokens) for multimodal case

30 positions = torch.randint(

31 0, max_position_embeddings // 4, (3, num_tokens), device=device

tests/kernels/core/test_pos_encoding.py

+2 -2

@@ -9,7 +9,7 @@ import torch

9

10 from tests.kernels.allclose_default import get_default_atol, get_default_rtol

11 from vllm.model_executor.layers.rotary_embedding import get_rope

12 -from vllm.platforms import current_platform

12 +from vllm.utils.torch_utils import set_random_seed

13

14 IS_NEOX_STYLE = [True, False]

15 DTYPES = [torch.bfloat16, torch.float]

@@ -79,7 +79,7 @@ def test_rotary_embedding(

79 if rotary_dim is None:

80 rotary_dim = head_size

81

82 - current_platform.seed_everything(seed)

82 + set_random_seed(seed)

83 torch.set_default_device(device)

84 if rotary_dim is None:

85 rotary_dim = head_size

tests/kernels/mamba/test_causal_conv1d.py

+4 -4

@@ -12,7 +12,7 @@ from vllm.model_executor.layers.mamba.ops.causal_conv1d import (

12 causal_conv1d_fn,

13 causal_conv1d_update,

14 )

15 -from vllm.platforms import current_platform

15 +from vllm.utils.torch_utils import set_random_seed

16

17

18 def causal_conv1d_ref(

@@ -154,7 +154,7 @@ def test_causal_conv1d_update(dim, width, seqlen, has_bias, silu_activation, ity

154 if itype == torch.bfloat16:

155 rtol, atol = 1e-2, 5e-2

156 # set seed

157 - current_platform.seed_everything(0)

157 + set_random_seed(0)

158 batch = 2

159 x = torch.randn(batch, dim, seqlen, device=device, dtype=itype)

160 x_ref = x.clone()

@@ -201,7 +201,7 @@ def test_causal_conv1d_update_with_batch_gather(

201 rtol, atol = 1e-2, 5e-2

202

203 # set seed

204 - current_platform.seed_everything(0)

204 + set_random_seed(0)

205

206 padding = 5 if with_padding else 0

207 padded_batch_size = batch_size + padding

@@ -278,7 +278,7 @@ def test_causal_conv1d_varlen(

278 if itype == torch.bfloat16:

279 rtol, atol = 1e-2, 5e-2

280 # set seed

281 - current_platform.seed_everything(0)

281 + set_random_seed(0)

282 seqlens = []

283 batch_size = batch

284 padding = 3 if with_padding else 0

tests/kernels/mamba/test_mamba_mixer2.py

+2 -2

@@ -12,8 +12,8 @@ from vllm.distributed.parallel_state import (

12 initialize_model_parallel,

13 )

14 from vllm.model_executor.layers.mamba.mamba_mixer2 import Mixer2RMSNormGated

15 -from vllm.platforms import current_platform

15 from vllm.utils.system_utils import update_environment_variables

16 +from vllm.utils.torch_utils import set_random_seed

17

18

19 @multi_gpu_test(num_gpus=2)

@@ -68,7 +68,7 @@ def mixer2_gated_norm_tensor_parallel(

68 dtype: torch.dtype,

69 device: str,

70 ):

71 - current_platform.seed_everything(0)

71 + set_random_seed(0)

72

73 device = torch.device(f"cuda:{local_rank}")

74 torch.cuda.set_device(device)

tests/kernels/mamba/test_mamba_ssm.py

+6 -6

@@ -13,7 +13,7 @@ from vllm.model_executor.layers.mamba.ops.mamba_ssm import (

13 selective_scan_fn,

14 selective_state_update,

15 )

16 -from vllm.platforms import current_platform

16 +from vllm.utils.torch_utils import set_random_seed

17

18

19 def selective_state_update_ref(

@@ -271,7 +271,7 @@ def test_selective_scan(

271 rtolw = max(rtolw, rtol)

272 atolw = max(atolw, atol)

273 # set seed

274 - current_platform.seed_everything(0)

274 + set_random_seed(0)

275 batch_size = 1

276 dim = 4

277 dstate = 8

@@ -401,7 +401,7 @@ def test_selective_state_update(dim, dstate, has_z, itype):

401 if torch.version.hip:

402 atol *= 2

403 # set seed

404 - current_platform.seed_everything(0)

404 + set_random_seed(0)

405 batch_size = 1

406 state = torch.randn(batch_size, dim, dstate, dtype=itype, device=device)

407 x = torch.randn(batch_size, dim, device=device, dtype=itype)

@@ -438,7 +438,7 @@ def test_selective_state_update_varlen(dim, dstate, has_z, itype, max_seq_len):

438 if torch.version.hip:

439 atol *= 2

440 # set seed

441 - current_platform.seed_everything(0)

441 + set_random_seed(0)

442 batch_size = 4

443 token_counts = torch.randint(1, max_seq_len + 1, (batch_size,), device=device)

444 total_tokens = int(token_counts.sum().item())

@@ -857,7 +857,7 @@ def test_selective_state_update_with_num_accepted_tokens(

857 if torch.version.hip:

858 atol *= 2

859

860 - current_platform.seed_everything(0)

860 + set_random_seed(0)

861 batch_size = 4

862

863 tokens_per_seq = torch.randint(1, max_seq_len + 1, (batch_size,), device=device)

@@ -983,7 +983,7 @@ def test_selective_state_update_varlen_with_num_accepted(

983 if torch.version.hip:

984 atol *= 2

985

986 - current_platform.seed_everything(0)

986 + set_random_seed(0)

987 batch_size = 4

988

989 tokens_per_seq = torch.randint(1, max_seq_len + 1, (batch_size,), device=device)

tests/kernels/mamba/test_mamba_ssm_ssd.py

+2 -2

@@ -9,7 +9,7 @@ from einops import rearrange, repeat

9 from vllm.model_executor.layers.mamba.ops.ssd_combined import (

10 mamba_chunk_scan_combined_varlen,

11 )

12 -from vllm.platforms import current_platform

12 +from vllm.utils.torch_utils import set_random_seed

13 from vllm.v1.attention.backends.mamba2_attn import compute_varlen_chunk_metadata

14

15 # Added by the IBM Team, 2024

@@ -82,7 +82,7 @@ def ssd_minimal_discrete(X, A, B, C, block_len, initial_states=None):

82

83

84 def generate_random_inputs(batch_size, seqlen, n_heads, d_head, itype, device="cuda"):

85 - current_platform.seed_everything(0)

85 + set_random_seed(0)

86 A = -torch.exp(torch.rand(n_heads, dtype=itype, device=device))

87 dt = F.softplus(

88 torch.randn(batch_size, seqlen, n_heads, dtype=itype, device=device) - 4

tests/kernels/moe/modular_kernel_tools/make_feature_matrix.py

+2 -2

@@ -10,7 +10,7 @@ from tqdm import tqdm

10

11 from vllm.config import VllmConfig, set_current_vllm_config

12 from vllm.model_executor.layers.fused_moe.config import FUSED_MOE_UNQUANTIZED_CONFIG

13 -from vllm.platforms import current_platform

13 +from vllm.utils.torch_utils import set_random_seed

14

15 from .common import (

16 Config,

@@ -40,7 +40,7 @@ def rank_worker(

40 config: Config,

41 weights: WeightTensors,

42 ):

43 - current_platform.seed_everything(pgi.rank)

43 + set_random_seed(pgi.rank)

44

45 # sanity check

46 from vllm import envs

tests/kernels/moe/modular_kernel_tools/profile_modular_kernel.py

+2 -2

@@ -9,7 +9,7 @@ from typing import Any

9 import torch

10

11 from vllm.config import VllmConfig

12 -from vllm.platforms import current_platform

12 +from vllm.utils.torch_utils import set_random_seed

13

14 from .common import Config, RankTensors, WeightTensors, make_modular_kernel

15 from .parallel_utils import ProcessGroupInfo, parallel_launch_with_config

@@ -82,7 +82,7 @@ def rank_worker(

82 config: Config,

83 weights: WeightTensors,

84 ):

85 - current_platform.seed_everything(pgi.rank)

85 + set_random_seed(pgi.rank)

86

87 # sanity check

88 from vllm import envs

tests/kernels/moe/test_batched_moe.py

+3 -2

@@ -21,6 +21,7 @@ from vllm.model_executor.layers.fused_moe.fused_batched_moe import (

21 from vllm.model_executor.layers.fused_moe.fused_moe import fused_topk

22 from vllm.platforms import current_platform

23 from vllm.triton_utils import tl

24 +from vllm.utils.torch_utils import set_random_seed

25

26 MNK_FACTORS = [

27 (1, 128, 128),

@@ -115,7 +116,7 @@ def test_batched_mm(

116 ):

117 """Note: float8_e4m3fn is not supported on CUDA architecture < 89,

118 and those tests will be skipped on unsupported hardware."""

118 - current_platform.seed_everything(7)

119 + set_random_seed(7)

120

121 use_fp8_w8a8 = dtype == torch.float8_e4m3fn

122

@@ -252,7 +253,7 @@ def test_fused_moe_batched_experts(

253 ):

254 """Note: float8_e4m3fn is not supported on CUDA architecture < 89,

255 and those tests will be skipped on unsupported hardware."""

255 - current_platform.seed_everything(7)

256 + set_random_seed(7)

257

258 use_fp8_w8a8 = dtype == torch.float8_e4m3fn

259

tests/kernels/moe/test_cpu_fused_moe.py

+2 -1

@@ -8,6 +8,7 @@ from tests.kernels.allclose_default import get_default_atol, get_default_rtol

8 from vllm._custom_ops import cpu_fused_moe, cpu_prepack_moe_weight

9 from vllm.model_executor.layers.activation import SiluAndMul, SwigluOAIAndMul

10 from vllm.platforms import current_platform

11 +from vllm.utils.torch_utils import set_random_seed

12

13 if not current_platform.is_cpu():

14 pytest.skip("skipping CPU-only tests", allow_module_level=True)

@@ -114,7 +115,7 @@ def test_cpu_fused_moe(

115 act: str,

116 isa: str,

117 ):

117 - current_platform.seed_everything(0)

118 + set_random_seed(0)

119

120 topk_num = max(expert_num // 2, 1)

121 up_dim = 2 * intermediate_size

tests/kernels/moe/test_cutlass_moe.py

+4 -3

@@ -20,6 +20,7 @@ from vllm.model_executor.layers.fused_moe.cutlass_moe import (

20 from vllm.model_executor.layers.fused_moe.fused_moe import fused_experts, fused_topk

21 from vllm.model_executor.layers.fused_moe.utils import moe_kernel_quantize_input

22 from vllm.platforms import current_platform

23 +from vllm.utils.torch_utils import set_random_seed

24

25 NUM_EXPERTS = [40, 64]

26 TOP_KS = [6, 8]

@@ -277,7 +278,7 @@ def test_cutlass_moe_8_bit_no_graph(

278 workspace_init,

279 ep_size: int | None = None,

280 ):

280 - current_platform.seed_everything(7)

281 + set_random_seed(7)

282 monkeypatch.setenv("VLLM_FUSED_MOE_CHUNK_SIZE", "8192")

283 with set_current_vllm_config(vllm_config):

284 mt = MOETensors8Bit.make_moe_tensors_8bit(m, k, n, e, per_act_token, per_out_ch)

@@ -332,7 +333,7 @@ def test_cutlass_moe_8_bit_cuda_graph(

333 monkeypatch,

334 workspace_init,

335 ):

335 - current_platform.seed_everything(7)

336 + set_random_seed(7)

337 monkeypatch.setenv("VLLM_FUSED_MOE_CHUNK_SIZE", "8192")

338 with set_current_vllm_config(vllm_config):

339 dtype = torch.half

@@ -469,7 +470,7 @@ def test_run_cutlass_moe_fp8(

470 ep_size: int,

471 workspace_init,

472 ):

472 - current_platform.seed_everything(7)

473 + set_random_seed(7)

474 with set_current_vllm_config(vllm_config):

475 mt = MOETensors8Bit.make_moe_tensors_8bit(

476 m, k, n, e, per_act_token, per_out_channel

tests/kernels/moe/test_deepep_deepgemm_moe.py

+4 -4

@@ -22,13 +22,13 @@ from vllm.model_executor.layers.fused_moe.config import (

22 )

23 from vllm.model_executor.layers.fused_moe.fused_moe import fused_experts

24 from vllm.model_executor.layers.fused_moe.modular_kernel import FusedMoEModularKernel

25 -from vllm.platforms import current_platform

25 from vllm.utils.deep_gemm import (

26 get_mk_alignment_for_contiguous_layout,

27 is_deep_gemm_e8m0_used,

28 is_deep_gemm_supported,

29 )

30 from vllm.utils.import_utils import has_deep_ep, has_deep_gemm

31 +from vllm.utils.torch_utils import set_random_seed

32 from vllm.v1.worker.workspace import init_workspace_manager

33

34 from ...utils import multi_gpu_test

@@ -367,7 +367,7 @@ def _test_deepep_deepgemm_moe(

367 device = torch.device(f"cuda:{pgi.local_rank}")

368 init_workspace_manager(device)

369

370 - current_platform.seed_everything(pgi.rank)

370 + set_random_seed(pgi.rank)

371

372 w1 = w1.to(device=torch.cuda.current_device())

373 w2 = w2.to(device=torch.cuda.current_device())

@@ -456,7 +456,7 @@ def test_ht_deepep_deepgemm_moe(

456 """

457

458 m, n, k = mnk

459 - current_platform.seed_everything(7)

459 + set_random_seed(7)

460

461 if topk > num_experts:

462 pytest.skip(f"Skipping test: topk={topk} > E={num_experts}")

@@ -531,7 +531,7 @@ def test_ll_deepep_deepgemm_moe(

531 assert not is_deep_gemm_e8m0_used()

532

533 m, n, k = mnk

534 - current_platform.seed_everything(7)

534 + set_random_seed(7)

535

536 if topk > num_experts:

537 pytest.skip(f"Skipping test: topk={topk} > E={num_experts}")

tests/kernels/moe/test_deepep_moe.py

+3 -3

@@ -20,8 +20,8 @@ from vllm.model_executor.layers.fused_moe.modular_kernel import FusedMoEModularK

20 from vllm.model_executor.layers.quantization.utils.fp8_utils import (

21 per_token_group_quant_fp8,

22 )

23 -from vllm.platforms import current_platform

23 from vllm.utils.import_utils import has_deep_ep

24 +from vllm.utils.torch_utils import set_random_seed

25 from vllm.v1.worker.workspace import init_workspace_manager

26

27 from ...utils import multi_gpu_test

@@ -446,7 +446,7 @@ def test_deep_ep_moe(

446 low_latency_mode = False

447 use_fp8_dispatch = False

448

449 - current_platform.seed_everything(7)

449 + set_random_seed(7)

450 world_size, dp_size = world_dp_size

451 config = TestConfig(dtype=dtype, topk=topk, m=m, k=k, n=n, num_experts=num_experts)

452

@@ -507,7 +507,7 @@ def test_low_latency_deep_ep_moe(

507 f"hidden sizes {DeepEPLLPrepareAndFinalize.SUPPORTED_HIDDEN_SIZES}"

508 )

509

510 - current_platform.seed_everything(7)

510 + set_random_seed(7)

511 world_size, dp_size = world_dp_size

512 config = TestConfig(dtype=dtype, topk=topk, m=m, k=k, n=n, num_experts=num_experts)

513

tests/kernels/moe/test_flashinfer.py

+3 -2

@@ -22,6 +22,7 @@ from vllm.model_executor.layers.quantization.utils.flashinfer_utils import (

22 from vllm.model_executor.layers.quantization.utils.fp8_utils import input_to_float8

23 from vllm.model_executor.models.llama4 import Llama4MoE

24 from vllm.platforms import current_platform

25 +from vllm.utils.torch_utils import set_random_seed

26

27 try:

28 from vllm.utils.flashinfer import has_flashinfer_cutlass_fused_moe

@@ -158,7 +159,7 @@ def test_flashinfer_per_tensor_moe_fp8_no_graph(

159 ):

160 if not current_platform.has_device_capability(100):

161 pytest.skip("Test is only supported for sm >= 100")

161 - current_platform.seed_everything(7)

162 + set_random_seed(7)

163 monkeypatch.setenv("VLLM_FUSED_MOE_CHUNK_SIZE", "8192")

164 with set_current_vllm_config(vllm_config):

165 td = TestData.make_moe_tensors_8bit(m, k, n, e, reorder=True)

@@ -222,7 +223,7 @@ def test_flashinfer_cutlass_moe_fp8_no_graph(

223 monkeypatch,

224 workspace_init,

225 ):

225 - current_platform.seed_everything(7)

226 + set_random_seed(7)

227 monkeypatch.setenv("VLLM_FUSED_MOE_CHUNK_SIZE", "8192")

228 with set_current_vllm_config(vllm_config):

229 td = TestData.make_moe_tensors_8bit(

tests/kernels/moe/test_flashinfer_moe.py

+2 -1

@@ -23,6 +23,7 @@ from vllm.model_executor.layers.fused_moe.fused_moe import fused_topk

23 from vllm.model_executor.layers.fused_moe.modular_kernel import FusedMoEModularKernel

24 from vllm.platforms import current_platform

25 from vllm.utils.flashinfer import has_flashinfer_cutlass_fused_moe

26 +from vllm.utils.torch_utils import set_random_seed

27

28 if not has_flashinfer_cutlass_fused_moe() or not current_platform.has_device_capability(

29 100

@@ -60,7 +61,7 @@ def test_flashinfer_fp4_moe_no_graph(

61 activation: str,

62 workspace_init,

63 ):

63 - current_platform.seed_everything(7)

64 + set_random_seed(7)

65 with set_current_vllm_config(

66 VllmConfig(parallel_config=ParallelConfig(pipeline_parallel_size=1))

67 ):

tests/kernels/moe/test_grouped_topk.py

+2 -1

@@ -19,6 +19,7 @@ from vllm.model_executor.layers.fused_moe.fused_moe import (

19 fused_grouped_topk,

20 )

21 from vllm.platforms import current_platform

22 +from vllm.utils.torch_utils import set_random_seed

23

24

25 @pytest.mark.skipif(

@@ -52,7 +53,7 @@ def test_grouped_topk(

53 )

54 get_cached_compilation_config.cache_clear()

55

55 - current_platform.seed_everything(0)

56 + set_random_seed(0)

57 hidden_states = torch.randn((n_token, n_hidden), dtype=dtype, device="cuda")

58 gating_output = torch.randn((n_token, n_expert), dtype=dtype, device="cuda")

59 e_score_correction_bias = torch.randn(

tests/kernels/moe/test_modular_kernel_combinations.py

+2 -2

@@ -15,7 +15,7 @@ from vllm.config import VllmConfig, set_current_vllm_config

15 from vllm.platforms import current_platform

16 from vllm.utils.flashinfer import has_flashinfer_cutlass_fused_moe

17 from vllm.utils.import_utils import has_deep_ep, has_deep_gemm, has_pplx

18 -from vllm.utils.torch_utils import cuda_device_count_stateless

18 +from vllm.utils.torch_utils import cuda_device_count_stateless, set_random_seed

19 from vllm.v1.worker.workspace import init_workspace_manager

20

21 from .modular_kernel_tools.common import (

@@ -82,7 +82,7 @@ def rank_worker(

82 device = torch.device(f"cuda:{pgi.local_rank}")

83 init_workspace_manager(device)

84

85 - current_platform.seed_everything(pgi.rank)

85 + set_random_seed(pgi.rank)

86

87 # sanity check

88 from vllm import envs

tests/kernels/moe/test_modular_oai_triton_moe.py

+2 -1

@@ -34,6 +34,7 @@ from vllm.model_executor.layers.fused_moe.prepare_finalize import (

34 )

35 from vllm.model_executor.layers.utils import shuffle_weight

36 from vllm.platforms import current_platform

37 +from vllm.utils.torch_utils import set_random_seed

38

39 MNK = [

40 (1, 512, 384),

@@ -211,7 +212,7 @@ def test_oai_triton_moe(

212 unfused: bool,

213 workspace_init,

214 ):

214 - current_platform.seed_everything(0)

215 + set_random_seed(0)

216 (

217 w1,

218 w2,

tests/kernels/moe/test_moe.py

+2 -1

@@ -60,6 +60,7 @@ from vllm.model_executor.layers.quantization.utils.quant_utils import quantize_w

60 from vllm.model_executor.models.mixtral import MixtralMoE

61 from vllm.platforms import current_platform

62 from vllm.scalar_type import ScalarType, scalar_types

63 +from vllm.utils.torch_utils import set_random_seed

64 from vllm.v1.worker.workspace import init_workspace_manager

65

66 NUM_EXPERTS = [8, 64, 192]

@@ -234,7 +235,7 @@ def test_fused_moe(

235 monkeypatch,

236 workspace_init,

237 ):

237 - current_platform.seed_everything(7)

238 + set_random_seed(7)

239

240 monkeypatch.setenv("VLLM_FUSED_MOE_CHUNK_SIZE", str(chunk_size))

241

tests/kernels/moe/test_moe_align_block_size.py

+2 -1

@@ -14,12 +14,13 @@ from vllm.model_executor.layers.fused_moe.moe_align_block_size import (

14 )

15 from vllm.platforms import current_platform

16 from vllm.utils.math_utils import round_up

17 +from vllm.utils.torch_utils import set_random_seed

18

19 NUM_TOKENS = [1, 3, 256, 2256, 4096]

20 NUM_EXPERTS = [32, 160, 256, 257]

21 TOP_KS = [1, 2, 16, 32]

22 BLOCK_SIZES = [32, 128]

22 -current_platform.seed_everything(0)

23 +set_random_seed(0)

24

25

26 def _group_tokens_by_expert(

tests/kernels/moe/test_moe_permute_unpermute.py

+3 -2

@@ -17,11 +17,12 @@ from vllm.model_executor.layers.fused_moe.moe_permute_unpermute import (

17 moe_unpermute,

18 )

19 from vllm.platforms import current_platform

20 +from vllm.utils.torch_utils import set_random_seed

21

22 NUM_EXPERTS = [16, 64, 256]

23 TOP_KS = [2, 6, 8]

24 EP_SIZE = [1, 4, 16]

24 -current_platform.seed_everything(0)

25 +set_random_seed(0)

26

27 if current_platform.is_rocm():

28 pytest.skip(

@@ -226,7 +227,7 @@ def test_moe_permute_unpermute(

227 n_local_expert, expert_map, _ = determine_expert_map(ep_size, ep_rank, n_expert)

228 expert_map = expert_map.cuda()

229 start_expert = n_local_expert * ep_rank

229 - current_platform.seed_everything(0)

230 + set_random_seed(0)

231 hidden_states = torch.randn((n_token, n_hidden), device="cuda").to(dtype)

232 gating_output = torch.randn((n_token, n_expert), device="cuda").to(dtype)

233 topk_weights, topk_ids, token_expert_indices = fused_topk(

tests/kernels/moe/test_nvfp4_moe.py

+2 -1

@@ -16,6 +16,7 @@ from vllm.model_executor.layers.fused_moe.config import nvfp4_moe_quant_config

16 from vllm.model_executor.layers.fused_moe.cutlass_moe import cutlass_moe_fp4

17 from vllm.model_executor.layers.fused_moe.fused_moe import fused_topk

18 from vllm.platforms import current_platform

19 +from vllm.utils.torch_utils import set_random_seed

20

21 if not current_platform.has_device_capability(100):

22 pytest.skip(

@@ -42,7 +43,7 @@ MNK_FACTORS = [

43 def test_cutlass_fp4_moe_no_graph(

44 m: int, n: int, k: int, e: int, topk: int, dtype: torch.dtype, workspace_init

45 ):

45 - current_platform.seed_everything(7)

46 + set_random_seed(7)

47 with set_current_vllm_config(

48 VllmConfig(parallel_config=ParallelConfig(pipeline_parallel_size=1))

49 ):

tests/kernels/moe/test_pplx_cutlass_moe.py

+2 -1

@@ -14,6 +14,7 @@ from vllm.model_executor.layers.fused_moe.fused_moe import fused_topk

14 from vllm.model_executor.layers.fused_moe.modular_kernel import FusedMoEModularKernel

15 from vllm.platforms import current_platform

16 from vllm.utils.math_utils import cdiv

17 +from vllm.utils.torch_utils import set_random_seed

18

19 from ...utils import multi_gpu_test

20 from .parallel_utils import ProcessGroupInfo, parallel_launch

@@ -290,7 +291,7 @@ def test_cutlass_moe_pplx(

291 world_dp_size: tuple[int, int],

292 use_internode: bool,

293 ):

293 - current_platform.seed_everything(7)

294 + set_random_seed(7)

295

296 with set_current_vllm_config(vllm_config):

297 dtype = torch.half

tests/kernels/moe/test_pplx_moe.py

+7 -7

@@ -44,8 +44,8 @@ from vllm.model_executor.layers.fused_moe.modular_kernel import FusedMoEModularK

44 from vllm.model_executor.layers.fused_moe.topk_weight_and_reduce import (

45 TopKWeightAndReduceDelegate,

46 )

47 -from vllm.platforms import current_platform

47 from vllm.utils.math_utils import round_up

48 +from vllm.utils.torch_utils import set_random_seed

49 from vllm.v1.worker.workspace import init_workspace_manager

50

51 from ...utils import multi_gpu_test

@@ -184,7 +184,7 @@ def test_fused_moe_batched_experts(

184 dtype: torch.dtype,

185 workspace_init,

186 ):

187 - current_platform.seed_everything(7)

187 + set_random_seed(7)

188

189 a = torch.randn((m, k), device="cuda", dtype=dtype) / 10

190 w1 = torch.randn((e, 2 * n, k), device="cuda", dtype=dtype) / 10

@@ -491,7 +491,7 @@ def test_pplx_prepare_finalize_slow(

491 if per_act_token_quant and block_shape is not None:

492 pytest.skip("Skip illegal quantization combination")

493

494 - current_platform.seed_everything(7)

494 + set_random_seed(7)

495 m, n, k = mnk

496 world_size, dp_size = world_dp_size

497 device = "cuda"

@@ -809,7 +809,7 @@ def test_pplx_moe_slow(

809 block_shape: list[int] | None,

810 use_internode: bool,

811 ):

812 - current_platform.seed_everything(7)

812 + set_random_seed(7)

813 m, n, k = mnk

814 world_size, dp_size = world_dp_size

815

@@ -888,7 +888,7 @@ def _pplx_test_loop(

888 new_vllm_config.parallel_config.enable_expert_parallel = True

889 _set_vllm_config(new_vllm_config, pgi.world_size, pgi.rank, pgi.local_rank)

890

891 - current_platform.seed_everything(7)

891 + set_random_seed(7)

892 combos = itertools.product(

893 PPLX_COMBOS, NUM_EXPERTS, TOP_KS, DTYPES, [False, True], [None, [128, 128]]

894 )

@@ -982,7 +982,7 @@ def test_pplx_prepare_finalize(

982 world_dp_size: tuple[int, int],

983 use_internode: bool,

984 ):

985 - current_platform.seed_everything(7)

985 + set_random_seed(7)

986 world_size, dp_size = world_dp_size

987 parallel_launch(

988 world_size * dp_size,

@@ -1005,7 +1005,7 @@ def test_pplx_moe(

1005 use_internode: bool,

1006 use_shared_experts: bool,

1007 ):

1008 - current_platform.seed_everything(7)

1008 + set_random_seed(7)

1009 world_size, dp_size = world_dp_size

1010 parallel_launch(

1011 world_size,

tests/kernels/moe/test_silu_mul_fp8_quant_deep_gemm.py

+2 -1

@@ -13,6 +13,7 @@ from vllm.model_executor.layers.fused_moe.batched_deep_gemm_moe import (

13 from vllm.platforms import current_platform

14 from vllm.utils.deep_gemm import DeepGemmQuantScaleFMT, has_deep_gemm

15 from vllm.utils.math_utils import cdiv, round_up

16 +from vllm.utils.torch_utils import set_random_seed

17

18 if current_platform.is_fp8_fnuz():

19 pytest.skip(

@@ -201,7 +202,7 @@ def token_random(E, T, H2, tokens_per_expert):

202 @torch.inference_mode()

203 def test_silu_mul_fp8_quant_deep_gemm(E: int, T: int, H: int, fp8_type: torch.dtype):

204 group_size = 128

204 - current_platform.seed_everything(42)

205 + set_random_seed(42)

206

207 tokens_per_expert = torch.randint(

208 low=0,

tests/kernels/moe/test_silu_mul_per_token_group_quant_fp8_colmajor.py

+2 -1

@@ -11,6 +11,7 @@ from vllm.model_executor.layers.quantization.utils.fp8_utils import (

11 from vllm.platforms import current_platform

12 from vllm.triton_utils import triton

13 from vllm.utils.deep_gemm import is_deep_gemm_e8m0_used

14 +from vllm.utils.torch_utils import set_random_seed

15

16 FLOAT8_DTYPE = torch.float8_e4m3fn

17 GROUP_SIZE = 128

@@ -72,7 +73,7 @@ def reference(x: torch.Tensor, use_ue8m0: bool) -> tuple[torch.Tensor, torch.Ten

73 reason="ROCm does not support DeepGemm.",

74 )

75 def test_silu_mul_fp8_quant_deep_gemm(T: int, N: int):

75 - current_platform.seed_everything(42)

76 + set_random_seed(42)

77

78 input = torch.rand((T, N), dtype=torch.bfloat16, device="cuda")

79

tests/kernels/quantization/test_awq_triton.py

+3 -3

@@ -13,7 +13,7 @@ from vllm.model_executor.layers.quantization.awq_triton import (

13 awq_dequantize_triton,

14 awq_gemm_triton,

15 )

16 -from vllm.platforms import current_platform

16 +from vllm.utils.torch_utils import set_random_seed

17

18 device = "cuda"

19

@@ -86,7 +86,7 @@ def test_dequantize(qweight_rows, qweight_cols, group_size):

86 zeros_cols = qweight_cols

87 zeros_dtype = torch.int32

88

89 - current_platform.seed_everything(0)

89 + set_random_seed(0)

90

91 qweight = torch.randint(

92 0,

@@ -141,7 +141,7 @@ def test_gemm(N, K, M, splitK, group_size):

141 qzeros_rows = scales_rows

142 qzeros_cols = qweight_cols

143

144 - current_platform.seed_everything(0)

144 + set_random_seed(0)

145

146 input = torch.rand((input_rows, input_cols), dtype=input_dtype, device=device)

147 qweight = torch.randint(

tests/kernels/quantization/test_cutlass_w4a8_moe.py

+3 -2

@@ -17,6 +17,7 @@ from vllm.model_executor.layers.quantization.utils.quant_utils import (

17 )

18 from vllm.platforms import current_platform

19 from vllm.scalar_type import ScalarType, scalar_types

20 +from vllm.utils.torch_utils import set_random_seed

21

22 IS_SUPPORTED_BY_GPU = (

23 current_platform.is_cuda() and current_platform.get_device_capability()[0] >= 9

@@ -248,7 +249,7 @@ def compute_moe_reference_output(setup: MoETestSetup) -> torch.Tensor:

249 @pytest.mark.parametrize("random_zero", [True, False])

250 def test_cutlass_w4a8_moe_mm_end_to_end(shape, random_zero):

251 num_experts, N, K = shape

251 - current_platform.seed_everything(42)

252 + set_random_seed(42)

253 setup = make_moe_test_setup(

254 num_experts=num_experts, K=K, N=N, max_blocks=64, random_zero=random_zero

255 )

@@ -308,7 +309,7 @@ class W4A8MoELayer(torch.nn.Module):

309 reason="W4A8 Grouped GEMM is not supported on this GPU type.",

310 )

311 def test_cutlass_w4a8_moe_mm_cuda_graph():

311 - current_platform.seed_everything(42)

312 + set_random_seed(42)

313 # Fixed config for CUDA graph test (single parameter point).

314 num_experts = 8

315 K = 512

tests/kernels/quantization/test_flashinfer_nvfp4_scaled_mm.py

+2 -1

@@ -12,6 +12,7 @@ from nvfp4_utils import (

12 from vllm import _custom_ops as ops

13 from vllm.platforms import current_platform

14 from vllm.utils.flashinfer import flashinfer_scaled_fp4_mm

15 +from vllm.utils.torch_utils import set_random_seed

16

17 if not current_platform.has_device_capability(100):

18 pytest.skip(

@@ -72,7 +73,7 @@ def test_flashinfer_nvfp4_gemm(

73 if backend == "trtllm" and dtype == torch.float16:

74 pytest.skip("Only torch.bfloat16 is supported for TRTLLM FP4 GEMM operations")

75

75 - current_platform.seed_everything(seed)

76 + set_random_seed(seed)

77 m, n, packed_k = shape

78 k = packed_k * 2

79 block_size = 16

tests/kernels/quantization/test_flashinfer_scaled_mm.py

+2 -1

@@ -6,6 +6,7 @@ import torch

6 from vllm import _custom_ops as ops

7 from vllm.platforms import current_platform

8 from vllm.utils.flashinfer import flashinfer_scaled_fp8_mm

9 +from vllm.utils.torch_utils import set_random_seed

10

11 if not current_platform.has_device_capability(100):

12 pytest.skip(

@@ -38,7 +39,7 @@ def test_flashinfer_fp8_gemm(

39 device: str,

40 autotune: bool,

41 ) -> None:

41 - current_platform.seed_everything(seed)

42 + set_random_seed(seed)

43 m, n, k = shape

44 a = torch.randn((m, k), dtype=dtype, device=device)

45 b = torch.randn((n, k), dtype=dtype, device=device) / k

tests/kernels/quantization/test_fp8_quant.py

+4 -4

@@ -11,7 +11,7 @@ from tests.kernels.quant_utils import (

11 ref_dynamic_per_token_quant,

12 )

13 from tests.kernels.utils import opcheck

14 -from vllm.platforms import current_platform

14 +from vllm.utils.torch_utils import set_random_seed

15

16 DTYPES = [torch.bfloat16, torch.float]

17 HIDDEN_SIZES = [17, 1024, 1025, 1026, 5137, 8193]

@@ -51,7 +51,7 @@ def opcheck_fp8_quant(

51 def test_dynamic_per_token_fp8_quant(

52 num_tokens: int, hidden_size: int, dtype: torch.dtype, scale_ub: bool, seed: int

53 ) -> None:

54 - current_platform.seed_everything(seed)

54 + set_random_seed(seed)

55

56 x = (

57 torch.rand(num_tokens, hidden_size, dtype=dtype, device="cuda") + 1e-6

@@ -81,7 +81,7 @@ def test_dynamic_per_token_fp8_quant(

81 def test_dynamic_per_tensor_fp8_quant(

82 num_tokens: int, hidden_size: int, dtype: torch.dtype, seed: int

83 ) -> None:

84 - current_platform.seed_everything(seed)

84 + set_random_seed(seed)

85

86 x = torch.rand(num_tokens, hidden_size, dtype=dtype, device="cuda")

87

@@ -101,7 +101,7 @@ def test_dynamic_per_tensor_fp8_quant(

101 @torch.inference_mode()

102 @pytest.mark.parametrize("seed", SEEDS)

103 def test_fp8_quant_large(seed: int) -> None:

104 - current_platform.seed_everything(seed)

104 + set_random_seed(seed)

105

106 num_tokens = 1024000 # Mistral-Nemo's max_position_embeddings

107 hidden_size = 1152 # Smallest hidden_size to reproduce the error

tests/kernels/quantization/test_fp8_quant_group.py

+4 -4

@@ -7,7 +7,7 @@ import torch

7

8 from vllm.model_executor.layers.quantization.input_quant_fp8 import QuantFP8

9 from vllm.model_executor.layers.quantization.utils.quant_utils import GroupShape

10 -from vllm.platforms import current_platform

10 +from vllm.utils.torch_utils import set_random_seed

11

12

13 @pytest.mark.parametrize(

@@ -30,7 +30,7 @@ def test_quantfp8_group_functionality(

30 Tests both CUDA and native implementations, column-major scales,

31 and verifies consistency between implementations.

32 """

33 - current_platform.seed_everything(seed)

33 + set_random_seed(seed)

34

35 x = torch.randn((batch_size, hidden_dim), dtype=torch.bfloat16, device="cuda") * 8

36 expected_num_groups = (hidden_dim + group_size - 1) // group_size

@@ -83,7 +83,7 @@ def test_quantfp8_group_functionality(

83 @pytest.mark.parametrize("use_ue8m0", [True, False])

84 @torch.inference_mode()

85 def test_quantfp8_group_multidimensional(seed: int, use_ue8m0: bool) -> None:

86 - current_platform.seed_everything(seed)

86 + set_random_seed(seed)

87

88 group_size = 64

89

@@ -136,7 +136,7 @@ def test_quantfp8_group_multidimensional(seed: int, use_ue8m0: bool) -> None:

136 @pytest.mark.parametrize("seed", [42])

137 @torch.inference_mode()

138 def test_quantfp8_group_edge_cases(seed: int) -> None:

139 - current_platform.seed_everything(seed)

139 + set_random_seed(seed)

140

141 batch_size = 16

142 group_size = 64

tests/kernels/quantization/test_gguf.py

+4 -4

@@ -11,7 +11,7 @@ from huggingface_hub import snapshot_download

11 import vllm._custom_ops as ops

12 from vllm.model_executor.layers.fused_moe import fused_experts

13 from vllm.model_executor.layers.quantization.gguf import _fused_moe_gguf

14 -from vllm.platforms import current_platform

14 +from vllm.utils.torch_utils import set_random_seed

15

16 GGUF_SAMPLE = snapshot_download("Isotr0py/test-gguf-sample")

17 GGUF_SAMPLE_MOE = snapshot_download("SzymonOzog/test-gguf-moe-sample")

@@ -91,7 +91,7 @@ def test_dequantize(

91 @pytest.mark.parametrize("quant_type", QUANT_TYPES)

92 @torch.inference_mode()

93 def test_mmvq(hidden_size: int, dtype: torch.dtype, quant_type: GGMLQuantizationType):

94 - current_platform.seed_everything(0)

94 + set_random_seed(0)

95

96 tensors = get_gguf_sample_tensors(hidden_size, quant_type)

97 x = torch.rand((1, hidden_size), dtype=dtype, device="cuda")

@@ -134,7 +134,7 @@ def test_mmq(

134 dtype: torch.dtype,

135 quant_type: GGMLQuantizationType,

136 ):

137 - current_platform.seed_everything(0)

137 + set_random_seed(0)

138

139 tensors = get_gguf_sample_tensors(hidden_size, quant_type)

140 x = torch.rand((num_tokens, hidden_size), dtype=dtype, device="cuda")

@@ -169,7 +169,7 @@ def test_moe(

169 quant_type: GGMLQuantizationType,

170 top_k: int,

171 ):

172 - current_platform.seed_everything(0)

172 + set_random_seed(0)

173 H, E = 1024, 256

174

175 x = torch.rand((num_tokens, H), dtype=dtype, device="cuda")

tests/kernels/quantization/test_int8_quant.py

+5 -5

@@ -7,7 +7,7 @@ import torch

7 from tests.kernels.quant_utils import ref_dynamic_per_token_quant

8 from tests.kernels.utils import opcheck

9 from vllm._custom_ops import scaled_int8_quant

10 -from vllm.platforms import current_platform

10 +from vllm.utils.torch_utils import set_random_seed

11

12 DTYPES = [torch.bfloat16, torch.float]

13 HIDDEN_SIZES = [17, 1024, 1025, 1026, 5137, 8193]

@@ -46,7 +46,7 @@ def opcheck_int8_quant_dynamic(output, input, symmetric=True):

46 def test_dynamic_scaled_int8_quant(

47 num_tokens: int, hidden_size: int, dtype: torch.dtype, seed: int

48 ) -> None:

49 - current_platform.seed_everything(seed)

49 + set_random_seed(seed)

50

51 x = torch.rand(num_tokens, hidden_size, dtype=dtype, device="cuda") * 1000

52

@@ -70,7 +70,7 @@ def test_dynamic_scaled_int8_quant(

70 def test_dynamic_scaled_int8_azp_quant(

71 num_tokens: int, hidden_size: int, dtype: torch.dtype, seed: int

72 ) -> None:

73 - current_platform.seed_everything(seed)

73 + set_random_seed(seed)

74 int8_traits = torch.iinfo(torch.int8)

75

76 x = torch.rand(num_tokens, hidden_size, dtype=dtype, device="cuda") * 1000 - 300

@@ -111,7 +111,7 @@ def test_dynamic_scaled_int8_azp_quant(

111 def test_static_scaled_int8_quant(

112 num_tokens: int, hidden_size: int, dtype: torch.dtype, seed: int, scale: float

113 ) -> None:

114 - current_platform.seed_everything(seed)

114 + set_random_seed(seed)

115 int8_traits = torch.iinfo(torch.int8)

116

117 x = torch.rand(num_tokens, hidden_size, dtype=dtype, device="cuda") * 1000

@@ -144,7 +144,7 @@ def test_static_scaled_int8_azp_quant(

144 scale: float,

145 azp: int,

146 ) -> None:

147 - current_platform.seed_everything(seed)

147 + set_random_seed(seed)

148 int8_traits = torch.iinfo(torch.int8)

149

150 x = torch.rand(num_tokens, hidden_size, dtype=dtype, device="cuda") * 1000 - 300

tests/kernels/quantization/test_mxfp4_qutlass.py

+2 -1

@@ -24,6 +24,7 @@ from compressed_tensors.transform.utils.hadamard import deterministic_hadamard_m

24 from vllm._custom_ops import fusedQuantizeMx, matmul_mxf4_bf16_tn

25 from vllm.model_executor.layers.quantization.qutlass_utils import to_blocked

26 from vllm.platforms import current_platform

27 +from vllm.utils.torch_utils import set_random_seed

28

29 if not torch.cuda.is_available():

30 pytest.skip("CUDA required for these tests.", allow_module_level=True)

@@ -205,7 +206,7 @@ LLAMA_MODELS = {

206

207 @pytest.fixture(autouse=True)

208 def _seed_each_test():

208 - current_platform.seed_everything(0)

209 + set_random_seed(0)

210 np.random.seed(0)

211 torch.random.manual_seed(0)

212

tests/kernels/quantization/test_nvfp4_quant.py

+3 -2

@@ -6,6 +6,7 @@ import torch

6 from vllm import _custom_ops as ops

7 from vllm.platforms import current_platform

8 from vllm.scalar_type import scalar_types

9 +from vllm.utils.torch_utils import set_random_seed

10

11 if not current_platform.has_device_capability(100):

12 pytest.skip(

@@ -134,7 +135,7 @@ def test_quantize_to_fp4(

135 seed: int,

136 device: str,

137 ) -> None:

137 - current_platform.seed_everything(seed)

138 + set_random_seed(seed)

139 torch.set_default_device(device)

140

141 m, n = shape

@@ -156,7 +157,7 @@ def test_quantize_to_fp4(

157 @torch.inference_mode()

158 def test_quantize_to_fp4_padded(pad_shape: tuple[int, int]) -> None:

159 dtype = torch.float16

159 - current_platform.seed_everything(42)

160 + set_random_seed(42)

161 torch.set_default_device("cuda:0")

162

163 m, n = pad_shape

tests/kernels/quantization/test_nvfp4_qutlass.py

+2 -1

@@ -25,6 +25,7 @@ from vllm import _custom_ops as ops # use existing nvfp4 gemm in vllm

25 from vllm._custom_ops import fusedQuantizeNv

26 from vllm.model_executor.layers.quantization.qutlass_utils import to_blocked

27 from vllm.platforms import current_platform

28 +from vllm.utils.torch_utils import set_random_seed

29

30 if not torch.cuda.is_available():

31 pytest.skip("CUDA required for these tests.", allow_module_level=True)

@@ -193,7 +194,7 @@ LLAMA_MODELS = {

194

195 @pytest.fixture(autouse=True)

196 def _seed_each_test():

196 - current_platform.seed_everything(0)

197 + set_random_seed(0)

198 np.random.seed(0)

199 torch.random.manual_seed(0)

200

tests/kernels/quantization/test_nvfp4_scaled_mm.py

+2 -1

@@ -6,6 +6,7 @@ from nvfp4_utils import FLOAT4_E2M1_MAX, FLOAT8_E4M3_MAX, dequantize_nvfp4_to_dt

6

7 from vllm import _custom_ops as ops

8 from vllm.platforms import current_platform

9 +from vllm.utils.torch_utils import set_random_seed

10

11 if not current_platform.has_device_capability(100):

12 pytest.skip(

@@ -59,7 +60,7 @@ def test_nvfp4_gemm(

60 seed: int,

61 device: str,

62 ) -> None:

62 - current_platform.seed_everything(seed)

63 + set_random_seed(seed)

64 m, n, packed_k = shape

65 k = packed_k * 2

66 block_size = 16

tests/kernels/quantization/test_silu_mul_nvfp4_quant.py

+2 -1

@@ -11,6 +11,7 @@ from tests.kernels.quantization.nvfp4_utils import (

11 from vllm._custom_ops import scaled_fp4_quant

12 from vllm.model_executor.layers.activation import SiluAndMul

13 from vllm.platforms import current_platform

14 +from vllm.utils.torch_utils import set_random_seed

15

16 if not current_platform.has_device_capability(100):

17 pytest.skip(

@@ -33,7 +34,7 @@ def test_silu_mul_nvfp4_quant(

34 dtype: torch.dtype,

35 shape: tuple[int, int],

36 ) -> None:

36 - current_platform.seed_everything(42)

37 + set_random_seed(42)

38 device = "cuda:0"

39 torch.set_default_device(device)

40

tests/kernels/quantization/test_triton_scaled_mm.py

+2 -1

@@ -11,6 +11,7 @@ import pytest

11 import torch

12

13 from vllm.platforms import current_platform

14 +from vllm.utils.torch_utils import set_random_seed

15

16 device = "cuda"

17

@@ -85,7 +86,7 @@ def test_scaled_mm(

86 ):

87 is_floating_point_type = lambda t: torch.tensor([1, 1], dtype=t).is_floating_point()

88

88 - current_platform.seed_everything(0)

89 + set_random_seed(0)

90

91 # NOTE: There are cases, where if the matrix is large enough, an output

92 # like 65504.4 can be produced, and can easily turn into inf when

tests/kernels/test_apply_repetition_penalties.py

+3 -2

@@ -9,6 +9,7 @@ from vllm._custom_ops import (

9 apply_repetition_penalties_torch,

10 )

11 from vllm.platforms import current_platform

12 +from vllm.utils.torch_utils import set_random_seed

13

14 NUM_SEQS = [1, 2, 3, 4, 8, 13, 17, 32, 37, 256, 1023, 1024, 1025]

15 # [stress, stress, stress, Qwen, llama 4]

@@ -38,7 +39,7 @@ def test_apply_repetition_penalties(

39 Test the apply_repetition_penalties custom op

40 against a reference implementation.

41 """

41 - current_platform.seed_everything(seed)

42 + set_random_seed(seed)

43 torch.set_default_device("cuda:0")

44

45 # Create test data

@@ -95,7 +96,7 @@ def test_apply_repetition_penalties_zero_seqs() -> None:

96 dtype = torch.float32

97 seed = 0

98

98 - current_platform.seed_everything(seed)

99 + set_random_seed(seed)

100 torch.set_default_device("cuda:0")

101

102 # Create test data

tests/kernels/test_fla_layernorm_guard.py

+8 -8

@@ -10,7 +10,7 @@ from vllm.model_executor.layers.fla.ops.layernorm_guard import (

10 layernorm_fn,

11 rms_norm_ref,

12 )

13 -from vllm.platforms import current_platform

13 +from vllm.utils.torch_utils import set_random_seed

14

15

16 def layer_norm_ref(

@@ -114,7 +114,7 @@ def test_layer_norm_fwd_basic(

114 is_rms_norm: bool,

115 ) -> None:

116 """Test basic layer norm forward pass without z (gate) tensor."""

117 - current_platform.seed_everything(seed)

117 + set_random_seed(seed)

118 device = torch.device("cuda:0")

119

120 # Create inputs

@@ -156,7 +156,7 @@ def test_layer_norm_fwd_with_gate(

156 is_rms_norm: bool,

157 ) -> None:

158 """Test layer norm forward pass with z (gate) tensor."""

159 - current_platform.seed_everything(42)

159 + set_random_seed(42)

160 device = torch.device("cuda:0")

161

162 # Create inputs

@@ -213,7 +213,7 @@ def test_layer_norm_fwd_with_groups(

213 f"hidden_size {hidden_size} not divisible by group_size {group_size}"

214 )

215

216 - current_platform.seed_everything(42)

216 + set_random_seed(42)

217 device = torch.device("cuda:0")

218

219 # Create inputs

@@ -253,7 +253,7 @@ def test_layer_norm_rows_per_block(

253 dtype: torch.dtype,

254 ) -> None:

255 """Test that rows_per_block logic works correctly for various M sizes."""

256 - current_platform.seed_everything(42)

256 + set_random_seed(42)

257 device = torch.device("cuda:0")

258 hidden_size = 1024

259

@@ -278,7 +278,7 @@ def test_layer_norm_rows_per_block(

278 def test_strided_input(dtype: torch.dtype) -> None:

279 """Test that the kernel handles non-contiguous (strided)

280 inputs correctly."""

281 - current_platform.seed_everything(42)

281 + set_random_seed(42)

282 device = torch.device("cuda:0")

283 num_tokens = 128

284 hidden_size = 1024

@@ -318,7 +318,7 @@ def test_output_buffer_provided(

318 dtype: torch.dtype,

319 ) -> None:

320 """Test that the kernel works when an output buffer is provided."""

321 - current_platform.seed_everything(42)

321 + set_random_seed(42)

322 device = torch.device("cuda:0")

323

324 # Create inputs

@@ -359,7 +359,7 @@ def test_multidimensional_input(

359 dtype: torch.dtype,

360 ) -> None:

361 """Test that the autograd function handles multidimensional inputs."""

362 - current_platform.seed_everything(42)

362 + set_random_seed(42)

363 device = torch.device("cuda:0")

364 hidden_size = shape[-1]

365

tests/lora/test_fused_moe_lora_kernel.py

+4 -4

@@ -18,8 +18,8 @@ from vllm.distributed.parallel_state import (

18 get_tensor_model_parallel_world_size,

19 )

20 from vllm.lora.ops.triton_ops import fused_moe_lora

21 -from vllm.platforms import current_platform

21 from vllm.utils.network_utils import get_open_port

22 +from vllm.utils.torch_utils import set_random_seed

23

24

25 @pytest.fixture(autouse=True)

@@ -265,7 +265,7 @@ def test_fused_moe_lora_kernel(

265 seed,

266 ):

267 torch.set_default_device(device)

268 - current_platform.seed_everything(seed)

268 + set_random_seed(seed)

269 # the number of randomly generated sentences.

270 num_sequences = 10

271 # generate data

@@ -358,7 +358,7 @@ def test_fused_moe_lora_kernel_fully_sharded(

358 seed,

359 column_parallel,

360 ):

361 - current_platform.seed_everything(seed)

361 + set_random_seed(seed)

362 # the number of randomly generated sentences.

363 num_sequences = 10

364 # generate data

@@ -415,7 +415,7 @@ def use_fused_moe_lora_kernel_tensor_parallel(

415 def _get_shard_slice(shard_size):

416 return slice(local_rank * shard_size, (local_rank + 1) * shard_size)

417

418 - current_platform.seed_everything(seed)

418 + set_random_seed(seed)

419

420 device = torch.device(f"cuda:{local_rank}")

421 torch.cuda.set_device(device)

tests/lora/test_layers.py

+1 -1

@@ -43,8 +43,8 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

43 VocabParallelEmbedding,

44 get_masked_input_and_mask,

45 )

46 -from vllm.model_executor.utils import set_random_seed

46 from vllm.platforms import current_platform

47 +from vllm.utils.torch_utils import set_random_seed

48

49 from .utils import DummyLoRAManager

50

tests/lora/test_punica_ops.py

+3 -3

@@ -9,7 +9,7 @@ import vllm.lora.ops.torch_ops as torch_ops

9 import vllm.lora.ops.triton_ops as triton_ops

10 from vllm.lora.ops.triton_ops import LoRAKernelMeta

11 from vllm.lora.ops.triton_ops.utils import _LORA_A_PTR_DICT, _LORA_B_PTR_DICT

12 -from vllm.platforms import current_platform

12 +from vllm.utils.torch_utils import set_random_seed

13

14 from .utils import PunicaTensors, assert_close, generate_data_for_nslices

15

@@ -395,7 +395,7 @@ def test_kernels(

395 Tests LoRA kernels.

396 """

397 torch.set_default_device(device)

398 - current_platform.seed_everything(seed)

398 + set_random_seed(seed)

399

400 if op_type == "shrink":

401 check_lora_shrink_kernel(

@@ -447,7 +447,7 @@ def test_kernels_hidden_size(

447 Tests SGMV and LoRA kernels.

448 """

449 torch.set_default_device(device)

450 - current_platform.seed_everything(seed)

450 + set_random_seed(seed)

451

452 if op_type == "shrink":

453 check_lora_shrink_kernel(

tests/models/test_vision.py

+4 -3

@@ -21,6 +21,7 @@ from vllm.model_executor.models.vision import (

21 from vllm.platforms import current_platform

22 from vllm.utils.network_utils import get_open_port

23 from vllm.utils.system_utils import update_environment_variables

24 +from vllm.utils.torch_utils import set_random_seed

25

26 pytestmark = pytest.mark.cpu_test

27

@@ -98,7 +99,7 @@ def run_dp_sharded_vision_model_vs_direct(

99 """

100

101 # Set random seed for reproducibility

101 - current_platform.seed_everything(0)

102 + set_random_seed(0)

103

104 device = f"{current_platform.device_name}:{local_rank}"

105 current_platform.set_device(device)

@@ -284,7 +285,7 @@ def run_dp_sharded_mrope_vision_model_vs_direct(

285 calling the model directly.

286 """

287 # Set random seed for reproducibility

287 - current_platform.seed_everything(0)

288 + set_random_seed(0)

289 device = f"{current_platform.device_name}:{local_rank}"

290 current_platform.set_device(device)

291 torch.set_default_device(device)

@@ -408,7 +409,7 @@ def run_dp_sharded_mrope_vision_model_uneven_load_worker(

409 ):

410 """Test run_dp_sharded_mrope_vision_model with uneven load distribution."""

411 # Set up distributed environment

411 - current_platform.seed_everything(123)

412 + set_random_seed(123)

413 device = f"{current_platform.device_name}:{local_rank}"

414 current_platform.set_device(device)

415 torch.set_default_device(device)

tests/v1/attention/test_attention_backends.py

+6 -2

@@ -19,7 +19,11 @@ from vllm.attention.backends.registry import AttentionBackendEnum

19 from vllm.config import ModelConfig

20 from vllm.platforms import current_platform

21 from vllm.utils.math_utils import cdiv

22 -from vllm.utils.torch_utils import STR_DTYPE_TO_TORCH_DTYPE, is_torch_equal_or_newer

22 +from vllm.utils.torch_utils import (

23 + STR_DTYPE_TO_TORCH_DTYPE,

24 + is_torch_equal_or_newer,

25 + set_random_seed,

26 +)

27 from vllm.v1.attention.backends.utils import (

28 CommonAttentionMetadata,

29 set_kv_cache_layout,

@@ -320,7 +324,7 @@ def _test_backend_correctness(

324 multiple GPUs. This tests that backends work correctly with different

325 head counts.

326 """

323 - current_platform.seed_everything(42)

327 + set_random_seed(42)

328

329 hf_config_override = None

330 if tensor_parallel_size > 1:

tests/v1/kv_offload/test_cpu_gpu.py

+2 -1

@@ -7,6 +7,7 @@ import pytest

7 import torch

8

9 from vllm.platforms import current_platform

10 +from vllm.utils.torch_utils import set_random_seed

11 from vllm.v1.attention.backends.flash_attn import FlashAttentionBackend

12 from vllm.v1.kv_offload.mediums import CPULoadStoreSpec, GPULoadStoreSpec

13 from vllm.v1.kv_offload.worker.cpu_gpu import CpuGpuOffloadingHandlers

@@ -62,7 +63,7 @@ def test_transfer(

63 seed: int,

64 device: str,

65 ) -> None:

65 - current_platform.seed_everything(seed)

66 + set_random_seed(seed)

67

68 # create per-layer GPU KV caches based on available attn_backends

69 attn_backends_list = BACKENDS_TO_TEST

tests/v1/tpu/test_mha_attn.py

+2 -1

@@ -15,6 +15,7 @@ import torch_xla.core.xla_model

15 from vllm.attention.layers.mm_encoder_attention import MMEncoderAttention

16 from vllm.attention.selector import _cached_get_attn_backend

17 from vllm.platforms import current_platform

18 +from vllm.utils.torch_utils import set_random_seed

19

20

21 @pytest.fixture(autouse=True)

@@ -63,7 +64,7 @@ def test_mha_attn_forward(

64 head_size: int,

65 device: str,

66 ):

66 - current_platform.seed_everything(0)

67 + set_random_seed(0)

68 # These are expected to be f32

69 q = torch.randn(batch_size, seq_len, num_heads * head_size, device=device)

70 k = torch.randn(batch_size, seq_len, num_kv_heads * head_size, device=device)

tests/v1/worker/test_gpu_model_runner.py

+2 -1

@@ -26,6 +26,7 @@ from vllm.platforms import current_platform

26 from vllm.sampling_params import SamplingParams

27 from vllm.utils.mem_constants import GiB_bytes

28 from vllm.utils.system_utils import update_environment_variables

29 +from vllm.utils.torch_utils import set_random_seed

30 from vllm.v1.core.kv_cache_utils import estimate_max_model_len, get_kv_cache_configs

31 from vllm.v1.core.sched.output import CachedRequestData, NewRequestData, SchedulerOutput

32 from vllm.v1.kv_cache_interface import (

@@ -776,7 +777,7 @@ def test_hybrid_attention_mamba_tensor_shapes():

777 will not corrupt an attention block and vice versa

778 """

779

779 - current_platform.seed_everything(42)

780 + set_random_seed(42)

781

782 update_environment_variables(

783 {

vllm/model_executor/__init__.py

-2

@@ -2,10 +2,8 @@

2 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project

3

4 from vllm.model_executor.parameter import BasevLLMParameter, PackedvLLMParameter

5 -from vllm.model_executor.utils import set_random_seed

5

6 __all__ = [

8 - "set_random_seed",

7 "BasevLLMParameter",

8 "PackedvLLMParameter",

9 ]

vllm/model_executor/utils.py

-6

@@ -10,12 +10,6 @@ import torch

10 from vllm.utils.torch_utils import is_torch_equal_or_newer

11

12

13 -def set_random_seed(seed: int | None) -> None:

14 - from vllm.platforms import current_platform

15 -

16 - current_platform.seed_everything(seed)

17 -

18 -

13 def set_weight_attrs(

14 weight: torch.Tensor,

15 weight_attrs: dict[str, Any] | None,

vllm/platforms/interface.py

+4

@@ -372,6 +372,10 @@ class Platform:

372

373 Loosely based on: https://github.com/Lightning-AI/pytorch-lightning/blob/2.4.0/src/lightning/fabric/utilities/seed.py#L20

374 """

375 + logger.info_once(

376 + "`seed_everything` is deprecated. It will be removed in v0.14.0 or later. "

377 + "Please use `vllm.utils.torch_utils.set_random_seed` instead."

378 + )

379 if seed is not None:

380 random.seed(seed)

381 np.random.seed(seed)

vllm/utils/torch_utils.py

+10 -5

@@ -3,6 +3,7 @@

3 import contextlib

4 import importlib.metadata

5 import os

6 +import random

7 import threading

8 from collections.abc import Callable, Collection

9 from functools import lru_cache

@@ -278,6 +279,13 @@ def kv_cache_dtype_str_to_dtype(

279 return STR_DTYPE_TO_TORCH_DTYPE[kv_cache_dtype]

280

281

282 +def set_random_seed(seed: int | None) -> None:

283 + if seed is not None:

284 + random.seed(seed)

285 + np.random.seed(seed)

286 + torch.manual_seed(seed)

287 +

288 +

289 def create_kv_caches_with_random_flash(

290 num_blocks: int,

291 block_size: int,

@@ -290,9 +298,7 @@ def create_kv_caches_with_random_flash(

298 device: str | None = "cuda",

299 cache_layout: str | None = "NHD",

300 ) -> tuple[list[torch.Tensor], list[torch.Tensor]]:

293 - from vllm.platforms import current_platform

294 -

295 - current_platform.seed_everything(seed)

301 + set_random_seed(seed)

302

303 dtype = get_kv_cache_torch_dtype(cache_dtype, model_dtype)

304 generic_kv_cache_shape = (num_blocks, 2, block_size, num_heads, head_size)

@@ -335,9 +341,8 @@ def create_kv_caches_with_random(

341 raise ValueError(

342 f"Does not support key cache of type fp8 with head_size {head_size}"

343 )

338 - from vllm.platforms import current_platform

344

340 - current_platform.seed_everything(seed)

345 + set_random_seed(seed)

346

347 dtype = get_kv_cache_torch_dtype(cache_dtype, model_dtype)

348

vllm/v1/worker/cpu_worker.py

+1 -1

@@ -10,10 +10,10 @@ import torch

10 from vllm import envs

11 from vllm.config import VllmConfig

12 from vllm.logger import init_logger

13 -from vllm.model_executor.utils import set_random_seed

13 from vllm.platforms import CpuArchEnum, current_platform

14 from vllm.platforms.cpu import CpuPlatform, LogicalCPUInfo

15 from vllm.profiler.wrapper import TorchProfilerWrapper

16 +from vllm.utils.torch_utils import set_random_seed

17 from vllm.v1.worker.cpu_model_runner import CPUModelRunner

18 from vllm.v1.worker.gpu_worker import Worker, init_worker_distributed_environment

19

vllm/v1/worker/gpu_worker.py

+1 -1

@@ -34,7 +34,6 @@ from vllm.distributed.parallel_state import (

34 )

35 from vllm.logger import init_logger

36 from vllm.lora.request import LoRARequest

37 -from vllm.model_executor import set_random_seed

37 from vllm.model_executor.models.interfaces import is_mixture_of_experts

38 from vllm.model_executor.warmup.kernel_warmup import kernel_warmup

39 from vllm.platforms import current_platform

@@ -43,6 +42,7 @@ from vllm.sequence import IntermediateTensors

42 from vllm.tasks import SupportedTask

43 from vllm.utils.mem_constants import GiB_bytes

44 from vllm.utils.mem_utils import MemorySnapshot, memory_profiling

45 +from vllm.utils.torch_utils import set_random_seed

46 from vllm.v1.core.sched.output import GrammarOutput, SchedulerOutput

47 from vllm.v1.engine import ReconfigureDistributedRequest, ReconfigureRankType

48 from vllm.v1.kv_cache_interface import KVCacheConfig, KVCacheSpec

vllm/v1/worker/tpu_worker.py

+1 -2

@@ -20,12 +20,11 @@ from vllm.distributed.kv_transfer import (

20 )

21 from vllm.logger import init_logger

22 from vllm.lora.request import LoRARequest

23 -from vllm.model_executor import set_random_seed

23 from vllm.platforms import current_platform

24 from vllm.platforms.tpu import USE_TPU_INFERENCE

25 from vllm.tasks import SupportedTask

26 from vllm.utils.math_utils import cdiv

28 -from vllm.utils.torch_utils import STR_DTYPE_TO_TORCH_DTYPE

27 +from vllm.utils.torch_utils import STR_DTYPE_TO_TORCH_DTYPE, set_random_seed

28 from vllm.v1.core.sched.output import GrammarOutput, SchedulerOutput

29 from vllm.v1.kv_cache_interface import AttentionSpec, KVCacheConfig, KVCacheSpec

30 from vllm.v1.outputs import ModelRunnerOutput

vllm/v1/worker/xpu_worker.py

+1 -1

@@ -9,9 +9,9 @@ import torch.distributed

9 from vllm.config import VllmConfig

10 from vllm.distributed import get_world_group

11 from vllm.logger import init_logger

12 -from vllm.model_executor import set_random_seed

12 from vllm.platforms import current_platform

13 from vllm.profiler.wrapper import TorchProfilerWrapper

14 +from vllm.utils.torch_utils import set_random_seed

15 from vllm.v1.worker.gpu_worker import Worker, init_worker_distributed_environment

16 from vllm.v1.worker.xpu_model_runner import XPUModelRunner

17

[Platform] Deprecate seed_everything (#31659)