Merge tag 'v0.7.2' into v0.7.2-dev

vllm/core/block/utils.py

+# SPDX-License-Identifier: Apache-2.0
 """Block manager utils."""
 from vllm.sequence import SequenceGroup
 from vllm.utils import (STR_NOT_IMPL_ENC_DEC_PREFIX_CACHE,

vllm/core/block_manager.py

+# SPDX-License-Identifier: Apache-2.0
 """A block manager that manages token blocks."""
 from typing import Dict, List, Optional
 from typing import Sequence as GenericSequence

vllm/core/evictor.py

+# SPDX-License-Identifier: Apache-2.0
+
 import enum
 import heapq
 from abc import ABC, abstractmethod

vllm/core/interfaces.py

+# SPDX-License-Identifier: Apache-2.0
+
 import enum
 from abc import ABC, abstractmethod
 from typing import List

vllm/core/placeholder_block_space_manager.py

+# SPDX-License-Identifier: Apache-2.0
+
 from typing import List, Tuple
 
 from vllm.core.interfaces import AllocStatus, BlockSpaceManager

vllm/core/scheduler.py

+# SPDX-License-Identifier: Apache-2.0
+
 import enum
 import os
 import random

vllm/device_allocator/cumem.py

+# SPDX-License-Identifier: Apache-2.0
+
 # cumem-based pytorch pluggable allocator to implement sleep mode.
 # other approaches tried but failed:
 # - cuda-python package binding

vllm/distributed/__init__.py

+# SPDX-License-Identifier: Apache-2.0
+
 from .communication_op import *
 from .parallel_state import *
 from .utils import *

vllm/distributed/communication_op.py

+# SPDX-License-Identifier: Apache-2.0
+
 from typing import Any, Dict, Optional, Union
 
 import torch

vllm/distributed/device_communicators/cuda_wrapper.py

+# SPDX-License-Identifier: Apache-2.0
 """This file is a pure Python wrapper for the cudart library.
 It avoids the need to compile a separate shared library, and is
 convenient for use when we just need to call a few functions.

vllm/distributed/device_communicators/custom_all_reduce.py

+# SPDX-License-Identifier: Apache-2.0
+
 import ctypes
 from contextlib import contextmanager
 from typing import List, Optional, Union

vllm/distributed/device_communicators/custom_all_reduce_utils.py

+# SPDX-License-Identifier: Apache-2.0
+
 import ctypes
 import json
 import os

vllm/distributed/device_communicators/hpu_communicator.py

+# SPDX-License-Identifier: Apache-2.0
+
 import torch
 import torch.distributed as dist
 from torch.distributed import ProcessGroup

vllm/distributed/device_communicators/pynccl.py

+# SPDX-License-Identifier: Apache-2.0
+
 from typing import Optional, Union
 
 # ===================== import region =====================

vllm/distributed/device_communicators/pynccl_wrapper.py

+# SPDX-License-Identifier: Apache-2.0
+
 # This file is a pure Python wrapper for the NCCL library.
 # The main purpose is to use NCCL combined with CUDA graph.
 # Before writing this script, we tried the following approach:

vllm/distributed/device_communicators/shm_broadcast.py

+# SPDX-License-Identifier: Apache-2.0
+
 import os
 import pickle
 import sys

vllm/distributed/device_communicators/tpu_communicator.py

+# SPDX-License-Identifier: Apache-2.0
+
 import os
 
 import torch

vllm/distributed/device_communicators/xpu_communicator.py

+# SPDX-License-Identifier: Apache-2.0
+
 import torch
 import torch.distributed as dist
 from torch.distributed import ProcessGroup

vllm/distributed/kv_transfer/kv_connector/base.py

+# SPDX-License-Identifier: Apache-2.0
 """
 KVConnectorBase Class for Distributed KV Cache & Hidden State communication
 

vllm/distributed/kv_transfer/kv_connector/factory.py

+# SPDX-License-Identifier: Apache-2.0
+
 import importlib
 from typing import TYPE_CHECKING, Callable, Dict, Type