fix: logging messages in metal (#1671)

Author: AlpinDale

aphrodite/metal/compat.py

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-"""Compatibility patches for vLLM + transformers version mismatches.
+"""Compatibility patches for Aphrodite + transformers version mismatches.
 
 Applied once at platform registration time. Optional missing dependencies are
 logged; unexpected runtime errors are allowed to surface so regressions remain
@@ -146,8 +146,7 @@ def _stack_qwen36_moe_per_expert_weights(
     and ``...mlp.experts.down_proj``, both stacked along axis 0 over experts.
 
     Mirrors the (scan -> validate -> walk) structure of upstream
-    ml-explore/mlx-lm#1224. Removable once vllm-metal's mlx-lm pin bumps
-    past that merge.
+    ml-explore/mlx-lm#1224.
 
     No-op when no per-expert keys are present (dense Qwen3.5/3.6 or already-
     stacked MoE checkpoints).

aphrodite/metal/config.py

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-"""Configuration for vLLM Metal plugin via environment variables."""
+"""Configuration for Aphrodite Metal plugin via environment variables."""
 
 import os
 from dataclasses import dataclass
@@ -37,7 +37,7 @@
 
 @dataclass
 class MetalConfig:
-    """Configuration for vLLM Metal plugin."""
+    """Configuration for Aphrodite Metal plugin."""
 
     memory_fraction: float  # -1.0 means "auto" (calculate minimal needed)
     use_mlx: bool

aphrodite/metal/envs.py

@@ -1,16 +1,16 @@
 # SPDX-License-Identifier: Apache-2.0
-"""Environment variable definitions for the vLLM Metal plugin.
+"""Environment variable definitions for the Aphrodite Metal plugin.
 
 This module is the single source of truth for all ``APHRODITE_METAL_*`` (and
 ``APHRODITE_MLX_*``) environment variables.  It mirrors the lazy-evaluation
-pattern used by ``vllm/envs.py``: each variable is read from
+pattern used by ``aphrodite/envs.py``: each variable is read from
 ``os.environ`` on access via ``__getattr__``, so values are never stale
 and ``monkeypatch.setenv`` works in tests without extra resets.
 
 During plugin registration (``aphrodite.metal._register``), the
 ``environment_variables`` dict is merged into
 ``aphrodite.envs.environment_variables`` so that ``validate_environ()``
-recognises our variables and does not emit spurious "Unknown vLLM
+recognises our variables and does not emit spurious "Unknown Aphrodite
 environment variable" warnings.
 """
 
@@ -84,5 +84,5 @@ def __getattr__(name: str) -> Any:
 
 
 def __dir__() -> list[str]:
-    # Mirrors vllm/envs.py; enables tab-completion and introspection.
+    # Mirrors aphrodite/envs.py; enables tab-completion and introspection.
     return list(environment_variables.keys())

aphrodite/metal/metal_backend.py

@@ -18,7 +18,7 @@ class MetalBackend(AttentionBackend):
     block_size, and the hybrid-block-size math via
     Platform._align_hybrid_block_size) can read Metal's MultipleOf(16)
     alignment constraint. The Metal paged-attention kernels are tuned for
-    block_size=16; advertising MultipleOf(16) makes vLLM's selector default
+    block_size=16; advertising MultipleOf(16) makes Aphrodite's selector default
     to 16 and lets hybrid models align to multiples of 16. It is never
     dispatched to as a real attention backend — the actual Metal paged
     attention lives in metal_kernel_backend/paged_attention.py. The

aphrodite/metal/metal_kernel_backend/attention_sdpa.py

@@ -110,7 +110,7 @@ def _build_block_tables(
     """Build kernel-compatible block tables, translating if necessary.
 
     When ``cache_block_size`` exceeds the kernel's compiled block sizes,
-    each vLLM block ``b`` is expanded into ``ratio`` kernel blocks
+    each Aphrodite block ``b`` is expanded into ``ratio`` kernel blocks
     ``[b*ratio, b*ratio+ratio)``.  The cache is reshaped later to
     match (zero-copy).
 
@@ -136,7 +136,7 @@ def _build_block_tables(
         return result
 
     # Hybrid path — translate large block_size to a kernel-compatible one.
-    # Vectorized: each vLLM block b → [b*ratio, b*ratio+1, …, b*ratio+ratio-1].
+    # Vectorized: each Aphrodite block b → [b*ratio, b*ratio+1, …, b*ratio+ratio-1].
     kernel_bs = _pick_kernel_block_size(cache_block_size)
     ratio = cache_block_size // kernel_bs
 
@@ -447,10 +447,10 @@ def sdpa_forward(
     max_seq_len = ctx.max_context_len or max(ctx.context_lens)
 
     # --- Block tables (with hybrid block-size translation) ---
-    # vLLM may inflate block_size (e.g. 544) to align attention pages with
+    # Aphrodite may inflate block_size (e.g. 544) to align attention pages with
     # mamba pages in hybrid models.  The Metal kernel only supports small
     # block sizes (8, 16, 32).  _build_block_tables handles the translation:
-    # it expands each vLLM block into multiple kernel blocks and returns the
+    # it expands each Aphrodite block into multiple kernel blocks and returns the
     # kernel-compatible block_size.  The cache is reshaped to match (zero-copy).
     block_tables, kernel_block_size = _build_block_tables(ctx, kv_cache.block_size)
 

aphrodite/metal/multimodal/__init__.py

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-"""Generic multimodal helpers for vLLM Metal."""
+"""Generic multimodal helpers for Aphrodite Metal."""
 
 from __future__ import annotations
 

aphrodite/metal/multimodal/embeddings.py

@@ -16,7 +16,7 @@ def merge_multimodal_embeddings(
 ) -> mx.array:
     """Splice multimodal embeddings into placeholder positions.
 
-    Mirrors ``vllm/model_executor/models/utils.py``
+    Mirrors ``aphrodite/model_executor/models/utils.py``
     ``_merge_multimodal_embeddings`` for MLX arrays.  Returns a new array;
     ``inputs_embeds`` is not mutated.
     """

aphrodite/metal/multimodal/qwen3_vl/adapter.py

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-"""Qwen3-VL multimodal adapter for vLLM Metal."""
+"""Qwen3-VL multimodal adapter for Aphrodite Metal."""
 
 from __future__ import annotations
 
@@ -30,10 +30,10 @@ def get_mrope_input_positions(
     ) -> tuple[mx.array, int]:
         """Return ``((3, seq_len) int32 positions, mrope_position_delta)``.
 
-        Calls upstream vLLM's mm_features-driven Qwen3-VL M-RoPE helper with a
+        Calls upstream Aphrodite's mm_features-driven Qwen3-VL M-RoPE helper with a
         minimal image-only config shim, then converts the returned torch tensor
         to an MLX array.  This keeps the position-building policy upstream-owned
-        while the vllm-metal runner can consume MLX arrays.
+        while the aphrodite metal runner can consume MLX arrays.
         """
         if not input_tokens:
             return mx.zeros((3, 0), dtype=mx.int32), 0

aphrodite/metal/platform.py

@@ -220,24 +220,21 @@ def get_torch_device(cls, device_id: int = 0) -> torch.device:
 
     @classmethod
     def check_and_update_config(cls, aphrodite_config: "AphroditeConfig") -> None:
-        """Check and update vLLM configuration for Metal compatibility.
+        """Check and update Aphrodite configuration for Metal compatibility.
 
         Args:
-            aphrodite_config: vLLM configuration object
+            aphrodite_config: Aphrodite configuration object
         """
         config = get_config()
         parallel_config = aphrodite_config.parallel_config
         model_config = aphrodite_config.model_config
         compilation_config = aphrodite_config.compilation_config
 
         # Metal execution is MLX-backed. Torch Inductor/CUDAGraph settings do
-        # not apply to the actual model path, so normalize them here rather
-        # than requiring users to pass --enforce-eager.
+        # not apply to the actual model path, so disable those compilation
+        # surfaces without overriding the user's eager-mode flag here.
         from aphrodite.config.compilation import CompilationMode, CUDAGraphMode
 
-        if model_config is not None and not model_config.enforce_eager:
-            logger.info("Metal: forcing eager mode; torch.compile/CUDAGraphs are not used on MLX.")
-            model_config.enforce_eager = True
         compilation_config.mode = CompilationMode.NONE
         compilation_config.cudagraph_mode = CUDAGraphMode.NONE
         compilation_config.max_cudagraph_capture_size = 0
@@ -385,7 +382,7 @@ def _find_non_ssm_backend(
     def update_block_size_for_backend(cls, aphrodite_config: "AphroditeConfig") -> None:
         """Update block_size for Metal platform.
 
-        Delegates to vLLM's base implementation, which reads the Metal kernel
+        Delegates to Aphrodite's base implementation, which reads the Metal kernel
         alignment (MultipleOf(16)) from our :meth:`_find_non_ssm_backend`
         override. Adds a one-time warning when paged attention is enabled for
         a hybrid model, explaining the cache-block-size translation mechanism
@@ -403,16 +400,16 @@ def update_block_size_for_backend(cls, aphrodite_config: "AphroditeConfig") -> N
         # block-size translation mechanism.
         #
         # Background:
-        # - vLLM requires block_size=160 (or larger) for hybrid models to satisfy
+        # - Aphrodite requires block_size=160 (or larger) for hybrid models to satisfy
         #   page size divisibility validation between SDPA and Mamba layers.
         #
-        # Solution (PR #235):
-        # - vLLM sees a large block_size (e.g., 144 = 16 * 9) for its scheduler
+        # Solution:
+        # - Aphrodite sees a large block_size (e.g., 144 = 16 * 9) for its scheduler
         #   validation.
         # - The Metal kernel uses a translated block_size (16, the kernel sweet
         #   spot) that it supports.
-        # - Each vLLM block is split into ratio = cache_block_size / kernel_block_size
-        #   kernel blocks. For example, one vLLM block of 144 tokens becomes 9 kernel
+        # - Each Aphrodite block is split into ratio = cache_block_size / kernel_block_size
+        #   kernel blocks. For example, one Aphrodite block of 144 tokens becomes 9 kernel
         #   blocks of 16 tokens each.
         # - The KV cache is reshaped (zero-copy) to match: [num_blocks, 144, ...] →
         #   [num_blocks*9, 16, ...]. The physical memory layout is unchanged.
@@ -423,17 +420,17 @@ def update_block_size_for_backend(cls, aphrodite_config: "AphroditeConfig") -> N
         if model_config.is_hybrid and metal_config.use_paged_attention:
             logger.warning(
                 "Hybrid model (e.g., Qwen3.5) with paged attention enabled. "
-                "Using block-size translation (PR #235) to convert vLLM's large "
+                "Using block-size translation (PR #235) to convert Aphrodite's large "
                 "block_size to a Metal kernel-compatible size.\n"
-                "  Mechanism: Each vLLM block is split into multiple kernel blocks.\n"
-                "  Example: vLLM block_size=144 → kernel block_size=16 (ratio=9).\n"
+                "  Mechanism: Each Aphrodite block is split into multiple kernel blocks.\n"
+                "  Example: Aphrodite block_size=144 → kernel block_size=16 (ratio=9).\n"
                 "  The KV cache is reshaped (zero-copy) and block tables are expanded.\n"
                 "  This is a logical transformation — physical memory is unchanged."
             )
 
         # Delegate the rest to upstream. With our ``_find_non_ssm_backend``
         # returning :class:`MetalBackend` (which advertises ``MultipleOf(16)``),
-        # vLLM's Phase 1 picks a kernel-aligned default of 16 for non-hybrid
+        # Aphrodite's Phase 1 picks a kernel-aligned default of 16 for non-hybrid
         # models (matching the kernel sweet spot), and Phase 2
         # (``_align_hybrid_block_size``) handles hybrid alignment. The kernel
         # layer (``_pick_kernel_block_size``) validates the final
@@ -453,10 +450,10 @@ def get_attn_backend_cls(
         if selected_backend and selected_backend != AttentionBackendEnum.CPU_ATTN:
             logger.info(f"Cannot use {selected_backend} backend on Metal/MLX.")
         if attn_selector_config.use_mla:
-            # MLA attention is handled by the vllm-metal model runner (MLAPagedAttentionWrapper),
-            # not by vLLM's attention backend selector. Continue to return CPU_ATTN below.
+            # MLA attention is handled by the aphrodite metal model runner (MLAPagedAttentionWrapper),
+            # not by Aphrodite's attention backend selector. Continue to return CPU_ATTN below.
             logger.info(
-                "MLA model detected; attention handled by vllm-metal model runner"
+                "MLA model detected; attention handled by aphrodite metal model runner"
             )
         if attn_selector_config.use_sparse:
             raise NotImplementedError("Sparse Attention is not supported on Metal/MLX.")

aphrodite/metal/profiler/__init__.py

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
-"""Metal frame-capture profiler for vLLM Metal."""
+"""Metal frame-capture profiler for Aphrodite Metal."""
 
 from aphrodite.metal.profiler.wrapper import MetalProfilerWrapper