[bugfix]: pin the CPU platform in the FP8 tests and stop writing MASTER_PORT

Fixes three problems in the tests added by the previous commit.

The block-wiring fixture swapped in a hand-written platform stub that defined
only is_mps and get_attn_backend_cls. Constructing the block reaches
set_weight_attrs, which calls current_platform.is_tpu on every linear, so the
test raised AttributeError inside the attention to_q before the feed-forward
was built and before either FP8 assertion ran. It now pins the real
CpuPlatform, which answers the whole current Platform interface rather than
the two methods that happened to be needed.

The two-rank test wrote MASTER_ADDR and MASTER_PORT into the environment.
test_gpu_tests_preserve_a_launcher_assigned_rendezvous_port scans every file
under fastvideo/tests and fails on a written MASTER_PORT, because that
clobbers the port the CI runner leased to the lane. The rendezvous now goes
through init_method, and the os import is gone with it.

The loader guard test passed device=cpu, which does not change the global
platform. maybe_load_fsdp_model turns FSDP off on MPS, so on a Mac the guard
sat inside a branch that never ran and the test failed later for an unrelated
reason. It pins CpuPlatform too, so every host takes the same path.

Author: KyleNeverGivesUp

fastvideo/tests/ops/quantization/test_fp8_ffn_suffix_wiring.py

@@ -11,8 +11,8 @@
 
 These are CPU-only contracts. Attaching ``quant_method`` needs neither a GPU
 nor real weights. The one test that builds a real H3 block takes
-``cpu_attention_platform``, because constructing the block resolves an
-attention backend and that is the only GPU-shaped dependency in this file.
+``cpu_attention_platform``, which pins the CPU platform so the block resolves
+the same attention backend on every host.
 """
 from __future__ import annotations
 
@@ -62,33 +62,21 @@ def test_minimax_h3_feed_forward_linears_get_fp8_method() -> None:
 
 @pytest.fixture
 def cpu_attention_platform(monkeypatch):
-    """Resolve attention to SDPA so an H3 block can be built without a GPU.
-
-    ``MiniMaxH3Attention.__init__`` and ``DistributedAttention.__init__`` both
-    call ``get_attn_backend``, which asks the platform for a backend qualname
-    and raises ``Invalid attention backend for ...`` on an empty string
-    (``selector.py``). A CPU-only host has no platform that answers, so the
-    block raises during construction and the FP8 assertions below never run.
-
-    Only the name is resolved here. ``SDPAImpl.__init__`` stores scalars and
-    touches no device, and nothing in this test runs attention.
+    """Build the H3 block against the real CPU platform, on any host.
+
+    Constructing the block reaches ``set_weight_attrs``, which calls
+    ``current_platform.is_tpu()``, and then ``get_attn_backend``, which asks the
+    platform for a backend qualname. Pinning ``CpuPlatform`` rather than a stub
+    means no future platform call can be missed, and the test takes the same
+    path on a CUDA host, a Mac and a CPU-only runner. ``CpuPlatform`` answers
+    ``TORCH_SDPA``; ``SDPAImpl.__init__`` stores scalars and touches no device,
+    and nothing here runs attention.
     """
     from fastvideo import platforms
     from fastvideo.attention import selector
+    from fastvideo.platforms.cpu import CpuPlatform
 
-    class _SDPAOnlyPlatform:
-        device_name = "cpu-test"
-
-        @classmethod
-        def is_mps(cls) -> bool:
-            return False
-
-        @classmethod
-        def get_attn_backend_cls(cls, selected_backend, head_size, dtype) -> str:
-            del selected_backend, head_size, dtype
-            return "fastvideo.attention.backends.sdpa.SDPABackend"
-
-    monkeypatch.setattr(platforms, "_current_platform", _SDPAOnlyPlatform())
+    monkeypatch.setattr(platforms, "_current_platform", CpuPlatform())
     # The resolution is memoized on inputs that do not include the platform,
     # so a real entry from another test would survive the swap.
     selector._cached_get_attn_backend.cache_clear()

fastvideo/tests/ops/quantization/test_fp8_fsdp_shard_guard.py

@@ -15,7 +15,6 @@
 from __future__ import annotations
 
 import contextlib
-import os
 import socket
 
 import pytest
@@ -75,14 +74,23 @@ def test_helper_reports_only_layers_the_converter_would_touch() -> None:
     assert _has_fp8_convertible_layers(plain) is False
 
 
-def test_loader_refuses_fp8_when_the_shard_dim_is_greater_than_one() -> None:
+def test_loader_refuses_fp8_when_the_shard_dim_is_greater_than_one(monkeypatch) -> None:
     """The guard must fire before the loader builds a device mesh.
 
     ``maybe_load_fsdp_model`` hard-codes a CUDA mesh for every non-NPU
     platform, so a guard placed after mesh creation could not be reached on a
     CPU host at all, and on a GPU host would fire only after sharding had
     already started.
+
+    The platform is pinned because the loader turns FSDP off entirely on MPS.
+    Left alone, this would skip the guard on a Mac and fail later for an
+    unrelated reason, so the test would only really run on Linux.
     """
+    from fastvideo import platforms
+    from fastvideo.platforms.cpu import CpuPlatform
+
+    monkeypatch.setattr(platforms, "_current_platform", CpuPlatform())
+
     with pytest.raises(NotImplementedError) as excinfo:
         maybe_load_fsdp_model(
             model_cls=_FP8Linear,
@@ -105,9 +113,11 @@ def test_loader_refuses_fp8_when_the_shard_dim_is_greater_than_one() -> None:
 def _sharded_conversion_worker(rank: int, world_size: int, port: int) -> None:
     from torch.distributed.tensor import Shard, distribute_tensor, init_device_mesh
 
-    os.environ["MASTER_ADDR"] = "127.0.0.1"
-    os.environ["MASTER_PORT"] = str(port)
-    dist.init_process_group("gloo", rank=rank, world_size=world_size)
+    # The rendezvous goes through init_method, not the environment.
+    # ``test_gpu_tests_preserve_a_launcher_assigned_rendezvous_port`` scans
+    # every file under fastvideo/tests and fails on a written MASTER_PORT,
+    # because that would clobber the port the CI runner leased to the lane.
+    dist.init_process_group("gloo", init_method=f"tcp://127.0.0.1:{port}", rank=rank, world_size=world_size)
     try:
         mesh = init_device_mesh("cpu", (world_size, ))
         model = _FP8Linear()