Upload folder using huggingface_hub (part 21)

.gitattributes

@@ -545,3 +545,11 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.12/site-packages/torch/_inductor/codegen/__pycache__/simd.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.12/site-packages/torch/_inductor/codegen/__pycache__/triton.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.12/site-packages/torch/_inductor/codegen/__pycache__/wrapper.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_inductor/fx_passes/__pycache__/post_grad.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_inductor/fx_passes/__pycache__/split_cat.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_inductor/heuristics/template/__pycache__/triton.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_inductor/runtime/__pycache__/triton_heuristics.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_refs/__pycache__/__init__.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_subclasses/__pycache__/fake_impls.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_subclasses/__pycache__/fake_tensor.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_vendor/quack/__pycache__/gemm_sm100.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text

.venv/lib/python3.12/site-packages/torch/_inductor/codegen/rocm/rocm_benchmark_request.py

@@ -0,0 +1,143 @@
+# mypy: allow-untyped-defs
+from __future__ import annotations
+
+import functools
+import logging
+from ctypes import byref, c_int, c_size_t, c_void_p
+from typing import Any, TYPE_CHECKING
+
+import torch
+from torch._inductor import config
+from torch._inductor.autotune_process import (
+    BenchmarkRequest,
+    GPUDeviceBenchmarkMixin,
+    TensorMeta,
+)
+from torch._inductor.codecache import DLLWrapper, ROCmCodeCache
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterable
+
+
+log = logging.getLogger(__name__)
+
+
+class ROCmBenchmarkRequest(GPUDeviceBenchmarkMixin, BenchmarkRequest):
+    # Important: Instances of this class have to be serializable
+    # across process boundaries. Do not put CUDA Tensors in here!
+
+    def __init__(
+        self,
+        kernel_name: str,
+        input_tensor_meta: TensorMeta | list[TensorMeta],
+        output_tensor_meta: TensorMeta | list[TensorMeta],
+        extra_args: Iterable[Any],
+        source_code: str,
+    ) -> None:
+        super().__init__(kernel_name, input_tensor_meta, output_tensor_meta, extra_args)
+        self.source_code = source_code
+        self.workspace_size: int = 0
+        self.workspace: torch.Tensor | None = None
+        self.DLL: DLLWrapper | None = None
+        self._workspace_size_updated = False
+        self.hash_key: str = ""
+        self.source_file: str = ""
+        self.hash_key, self.source_file = ROCmCodeCache.write(self.source_code, "so")
+
+    def precompile(self):
+        # Prepopulate code cache
+        # may happen in separate Threadpool
+        log.debug("Precompiling %s", self)
+        ROCmCodeCache.compile(self.source_code, "so")
+        if config.rocm.generate_test_runner:
+            ROCmCodeCache.compile(self.source_code, "exe")
+        log.debug("Done precompiling %s", self)
+
+    def make_run_fn(
+        self, *input_tensors: torch.Tensor, out: torch.Tensor
+    ) -> Callable[[], None]:
+        self.ensure_dll_loaded()
+        self.update_workspace_size()
+        args = [c_void_p(tensor.data_ptr()) for tensor in list(input_tensors) + [out]]
+        size_args = [c_int(arg) for arg in self.extra_args]
+        log.debug(
+            "make_run_fn: self.kernel_name=%s, self.source_file=%s, self.hash_key=%s, self.DLL=%s, args=%s, self.extra_args=%s",
+            self.kernel_name,
+            self.source_file,
+            self.hash_key,
+            self.DLL,
+            args,
+            self.extra_args,
+        )
+        stream_ptr = c_void_p(torch.cuda.current_stream().cuda_stream)
+        run_method = getattr(self.DLL, self.kernel_name)
+        workspace_ptr = c_void_p(0)
+        if self.workspace_size > 0:
+            self.workspace = torch.zeros(
+                (self.workspace_size + 7) // 8,
+                dtype=torch.float64,
+                device=out.device,
+            )
+            workspace_ptr = c_void_p(self.workspace.data_ptr())
+
+        # Generate partial function.
+        return functools.partial(
+            run_method,
+            *args,
+            *size_args,
+            None,  # null workspace size ptr
+            workspace_ptr,  # set workspace ptr,
+            stream_ptr,
+        )
+
+    def update_workspace_size(self) -> None:
+        if self._workspace_size_updated:
+            return
+        self.ensure_dll_loaded()
+        unique_input_count = len(
+            dict.fromkeys(meta.name for meta in self.input_tensor_meta)
+        )
+        args = [c_void_p(None) for _ in range(unique_input_count + 1)]
+        stream_ptr = c_void_p(torch.cuda.current_stream().cuda_stream)
+
+        run_method = getattr(self.DLL, self.kernel_name)
+        # Retrieve workspace_size and initialize workspace.
+        c_workspace_size = c_size_t()
+        size_args = [c_int(arg) for arg in self.extra_args]
+        run_method(
+            *args,  # input ptrs and output ptrs
+            *size_args,
+            byref(
+                c_workspace_size
+            ),  # set workspace size ptr to retrieve workspace size
+            None,  # null workspace ptr
+            stream_ptr,
+        )
+        torch.cuda.synchronize()  # shake out any CUDA errors
+        self.workspace_size = c_workspace_size.value
+        log.debug(
+            "update_workspace_size called: new workspace size=%d, self.kernel_name=%s, self.source_file=%s, self.hash_key=%s, self.DLL=%s, args=%s, self.extra_args=%s",
+            self.workspace_size,
+            self.kernel_name,
+            self.source_file,
+            self.hash_key,
+            self.DLL,
+            args,
+            self.extra_args,
+        )
+        self._workspace_size_updated = True
+
+    def ensure_dll_loaded(self):
+        if self.DLL is None:
+            self.DLL, self.hash_key, self.source_file = ROCmCodeCache.load(
+                self.source_code, "so"
+            )
+
+    def cleanup_run_fn(self) -> None:
+        if self.DLL is not None:
+            self.DLL.close()
+        self.workspace = None
+
+    def __str__(self) -> str:
+        return f"{self.kernel_name=}, {self.source_file=}, {self.hash_key=}"

.venv/lib/python3.12/site-packages/torch/_inductor/codegen/rocm/rocm_cpp_scheduling.py

@@ -0,0 +1,114 @@
+# mypy: allow-untyped-defs
+import logging
+from collections.abc import Sequence
+from typing import cast, TypeGuard
+
+from ... import config
+from ...codecache import code_hash, get_path
+from ...scheduler import BaseSchedulerNode, BaseScheduling, SchedulerNode
+from ...utils import get_fused_kernel_name, get_kernel_metadata, sympy_product
+from ...virtualized import V
+from ..common import IndentedBuffer
+from .rocm_template_buffer import ROCmTemplateBuffer
+
+
+log = logging.getLogger(__name__)
+
+
+class ROCmCPPScheduling(BaseScheduling):
+    """
+    Partial Scheduling implementation for ROCm C++ Kernels.
+    This class is intended to be used in combination with TritonScheduling,
+    and delegated to by CUDACombinedScheduling.
+
+    It handles fusion decisions and ROCm C++ specific template code generation.
+    """
+
+    def group_fn(self, sizes):
+        return tuple(V.graph.sizevars.simplify(sympy_product(s)) for s in sizes)
+
+    @staticmethod
+    def is_rocm_cpp_template(node: BaseSchedulerNode) -> TypeGuard[SchedulerNode]:
+        return isinstance(node, SchedulerNode) and isinstance(
+            node.node, ROCmTemplateBuffer
+        )
+
+    def can_fuse_vertical(
+        self, node1: BaseSchedulerNode, node2: BaseSchedulerNode
+    ) -> bool:
+        return False
+
+    def define_kernel(self, src_code: str, node_schedule) -> str:
+        wrapper = V.graph.wrapper_code
+        if src_code in wrapper.src_to_kernel:
+            kernel_name = wrapper.src_to_kernel[src_code]
+        else:
+            fused_name = (
+                get_fused_kernel_name(node_schedule, config.triton.descriptive_names)
+                if config.triton.descriptive_names
+                else ""
+            )
+            kernel_name = "_".join(["rocm", fused_name, wrapper.next_kernel_suffix()])
+            # use the original src_code as the key
+            wrapper.src_to_kernel[src_code] = kernel_name
+            src_code = src_code.replace("KERNEL_NAME", kernel_name)
+
+            _, _, kernel_path = get_path(code_hash(src_code), "py")
+
+            compile_wrapper = IndentedBuffer()
+            compile_wrapper.writeline("async_compile.rocm(r'''")
+            compile_wrapper.splice(src_code, strip=True)
+            compile_wrapper.writeline(
+                f"''', 'so', aot_compile={str(V.graph.aot_mode)})"
+            )
+
+            metadata_comment = f"# kernel path: {kernel_path}"
+            origins, detailed_origins = get_kernel_metadata(node_schedule, wrapper)
+            metadata_comment += "\n" + origins + "\n" + detailed_origins
+            wrapper.define_kernel(
+                kernel_name, compile_wrapper.getvalue(), metadata_comment
+            )
+
+            # For JIT cpp_wrapper, the kernel call site emits a bare
+            # `extern "C"` symbol reference; compile the .so now so the
+            # wrapper compile can link against it via extra_flags.
+            # Autotune compiled a .so for the unfused kernel name
+            # (e.g. rocm_<hash>), but at codegen time the kernel name
+            # gains a descriptive prefix (rocm_fused_mm_<hash>), so the
+            # exported symbol differs and we need a fresh compile.
+            if V.graph.cpp_wrapper and not V.graph.aot_mode:
+                from ...codecache import ROCmCodeCache
+
+                so_path, _, _ = ROCmCodeCache.compile(src_code, "so")
+                wrapper.external_kernel_libs.add(so_path)
+        return kernel_name
+
+    def codegen_template(
+        self,
+        template_node: BaseSchedulerNode,
+        epilogue_nodes: Sequence[BaseSchedulerNode],
+        prologue_nodes: Sequence[BaseSchedulerNode],
+    ):
+        """
+        Codegen a ROCm template, possibly with fused epilogues
+        """
+        if not self.is_rocm_cpp_template(template_node):
+            raise AssertionError(
+                "Template node passed to ROCmScheduler.codegen_template must be a SchedulerNode that wraps a ROCmTemplateBuffer"
+            )
+        _, (_numel, rnumel) = template_node.group
+        if rnumel != 1:
+            raise AssertionError(f"expected rnumel == 1, got {rnumel}")
+        ctb: ROCmTemplateBuffer = cast(ROCmTemplateBuffer, template_node.node)
+        kernel, render = ctb.make_kernel_render(ctb)  # type: ignore[misc]
+        with kernel:
+            template_node.mark_run()
+            src_code = render()
+
+        with V.set_kernel_handler(kernel):
+            node_schedule = [template_node]
+            kernel_name = self.define_kernel(src_code, node_schedule)
+        self.codegen_comment(node_schedule, kernel_name)
+        kernel.call_kernel(kernel_name, ctb)
+        V.graph.removed_buffers |= kernel.removed_buffers
+        self.free_buffers_in_scheduler()

.venv/lib/python3.12/site-packages/torch/_inductor/codegen/rocm/rocm_kernel.py

@@ -0,0 +1,298 @@
+# mypy: allow-untyped-defs
+import logging
+from collections.abc import Callable, Sequence
+from typing import Any, TYPE_CHECKING
+
+import torch._inductor.config as config
+from torch._inductor.codegen.cpp_wrapper_cpu import CppWrapperCpu
+from torch._inductor.utils import do_bench_using_profiling
+
+from ...ir import Buffer, ChoiceCaller, IRNode, Layout, PrimitiveInfoType, TensorBox
+from ...virtualized import V
+from ..common import Kernel, OpOverrides, WorkspaceArg, WorkspaceZeroMode
+from ..cpp_utils import CppPrinter
+from .rocm_benchmark_request import ROCmBenchmarkRequest
+from .rocm_template_buffer import ROCmTemplateBuffer
+from .rocm_utils import DTYPE_TO_ROCM_TYPE
+
+
+if TYPE_CHECKING:
+    from torch._inductor.codegen.rocm.rocm_template import ArgInfo, ROCmTemplate
+
+log = logging.getLogger(__name__)
+
+cexpr = CppPrinter().doprint
+
+
+def _normalize_idx(index: int, total_length: int) -> int:
+    return index if index >= 0 else index + total_length
+
+
+class ROCmKernel(Kernel):
+    """
+    Baseclass for ROCm based Kernels
+    """
+
+    overrides = OpOverrides  # type: ignore[assignment]
+
+
+class ROCmTemplateKernel(ROCmKernel):
+    """
+    Template kernels defined by ROCm in C++.
+    """
+
+    _EXTRA_CPP_ARGS = "size_t* workspace_size, uint8_t* workspace, hipStream_t stream"
+
+    def __init__(
+        self,
+        kernel_name: str,
+        runtime_arg_info: list["ArgInfo"],
+        runtime_arg_values: list[Any],
+    ) -> None:
+        """
+        Initializes a new instance of the ROCmTemplateKernel class.
+
+        Args:
+            kernel_name (str): The name of the kernel.
+        """
+        super().__init__()
+        self.kernel_name = kernel_name
+        # Mapping from arg name to IRNode.
+        self.named_nodes: dict[str, IRNode] = {}
+        self.runtime_arg_info = runtime_arg_info
+        self.runtime_arg_values = runtime_arg_values
+
+    def get_signature(self):
+        return self.signature
+
+    def def_kernel(
+        self,
+        inputs: list[IRNode],
+        outputs: list[IRNode],
+        size_args: list[str],
+        names_str: str = "",
+        input_reorder: list[int] | None = None,
+    ) -> str:
+        """
+        Hook called from template code to generate function definition and
+        needed args.
+
+        Args:
+            inputs: List of input IRNodes
+            outputs: List of output IRNodes
+            names_str: Comma separated list of input + output argument names.
+            input_reorder: The actual order of input nodes.
+                           e.g. The template might have input argument defined as [X, W, Bias],
+                           and the actual input passed into this template could be [Bias, X, W].
+                           In this case, the `input_reorder` would be [2, 0, 1].
+        """
+        names = [x.strip() for x in names_str.strip().split(",")]
+        if len(inputs) + len(outputs) != len(names):
+            raise RuntimeError(
+                f"{len(inputs) + len(outputs)=} != {len(names)=}, {inputs=}, {outputs=}, {names=}"
+            )
+
+        if input_reorder == [2, 0, 1]:
+            input_reorder = [4, 0, 1, 2, 3]
+
+        if input_reorder is not None:
+            if len(inputs) != len(input_reorder):
+                raise AssertionError(
+                    f"expected len(inputs) == len(input_reorder), "
+                    f"got {len(inputs)} and {len(input_reorder)}"
+                )
+        else:
+            input_reorder = list(range(len(inputs)))
+
+        for idx in input_reorder:
+            name = names[idx]
+            node = inputs[idx]
+            if node is not None:
+                self.named_nodes[name] = node
+                self.args.input_buffers[node.get_name()] = name
+
+        for name, node in zip(names[len(inputs) : len(inputs) + len(outputs)], outputs):
+            if node is not None:
+                self.named_nodes[name] = node
+                self.args.output_buffers[node.get_name()] = name
+
+        arg_defs, *_ = self.args.cpp_argdefs(DTYPE_TO_ROCM_TYPE)
+
+        runtime_arg_defs = [f"{arg.ty} {arg.name}" for arg in self.runtime_arg_info]
+
+        signature = f"int {self.kernel_name}({', '.join(arg_defs + size_args + runtime_arg_defs)},{self._EXTRA_CPP_ARGS})"
+        self.signature = signature
+        return signature
+
+    def call_kernel(
+        self,
+        name: str,
+        node: "ROCmTemplateBuffer",  # type: ignore[name-defined]
+    ) -> None:
+        """
+        Generates code to call the kernel through V.graph.wrapper_code.
+        used from within torch._inductor.wrapper.PythonWrapperCodegen
+
+        name: Name of kernel function.
+        node: The ROCmTemplateBuffer node which contains information about the kernel, it's fused epilogue nodes
+        as well as all required inputs and outputs.
+        """
+        wrapper = V.graph.wrapper_code
+
+        arg_types: list[Any]
+        if V.graph.cpp_wrapper:
+            # Make sure we initialize these kernels since they're exported as
+            # C-style symbol names.
+            if not isinstance(wrapper, CppWrapperCpu):
+                raise AssertionError(
+                    f"expected wrapper to be CppWrapperCpu, got {type(wrapper)}"
+                )
+            wrapper.initialized_kernels[name] = self
+            # Kinda hacky because we always originally initialize name with "KERNEL_NAME"
+            # So, we replace with the real kernel name passed as an arg to this function.
+            self.signature = self.signature.replace("KERNEL_NAME", name)
+            _, call_args, arg_types = self.args.cpp_argdefs(DTYPE_TO_ROCM_TYPE)
+        else:
+            _, call_args, _, arg_types = self.args.python_argdefs()
+
+        kernel_args = []
+        for arg in call_args:
+            # dynamo wraps unspec variable as 0d CPU tensor, need convert to scalar
+            if V.graph.is_unspec_arg(arg):
+                arg = arg + ".item()"
+            else:
+                if not V.graph.cpp_wrapper:
+                    arg = f"c_void_p({arg}.data_ptr())"
+            kernel_args.append(arg)
+
+        # add size args
+        size_args = [
+            f"{V.graph.sizevars.simplify(sarg)}" for sarg in node.template.size_args()
+        ]
+
+        if V.graph.cpp_wrapper:
+            kernel_args.extend(size_args)
+        else:
+            kernel_args.extend(f"c_int({sarg})" for sarg in size_args)
+
+        if V.graph.cpp_wrapper:
+            arg_types.extend(["int"] * len(node.template.size_args()))
+
+        # the runtime args come right after the size args
+        kernel_args.extend(self.runtime_arg_values)
+        for arg in self.runtime_arg_info:
+            arg_types.append(arg.ty)
+
+        # workspace_size ptr is NULL to mark this call is not intended for retrieving workspace_size.
+        # workspace_size should have already been retrieved prior to this call.
+        kernel_args.append("nullptr" if V.graph.cpp_wrapper else "None")
+        if V.graph.cpp_wrapper:
+            arg_types.append("size_t*")
+
+        if node.get_workspace_size() > 0:
+            ws = WorkspaceArg(
+                count=node.get_workspace_size(),
+                device=V.graph.get_current_device_or_throw(),
+                zero_mode=WorkspaceZeroMode.UNINITIALIZED,
+                outer_name=WorkspaceArg.unique_name(),
+            )
+            wrapper.generate_workspace_allocation(ws)
+            data_ptr = f"{ws.outer_name}.data_ptr()"
+            kernel_args.append(
+                data_ptr if V.graph.cpp_wrapper else f"c_void_p({data_ptr})"
+            )
+        else:
+            ws = None
+            kernel_args.append("nullptr" if V.graph.cpp_wrapper else "None")
+        if V.graph.cpp_wrapper:
+            arg_types.append("uint8_t*")
+        wrapper.generate_kernel_call(
+            name,
+            kernel_args,
+            triton=False,
+            arg_types=arg_types,
+        )
+        if ws:
+            wrapper.generate_workspace_deallocation(ws)
+
+
+class ROCmTemplateCaller(ChoiceCaller):
+    """
+    ROCmTemplateCaller
+
+    This class represents a caller for ROCm template kernels. It is a subclass of ChoiceCaller.
+    Attributes:
+        name (str): The name of the caller.
+        category (str): The category of the caller.
+        bmreq (ROCmBenchmarkRequest): The benchmark request for the caller.
+        template_buffer (ROCmTemplateBuffer): The template buffer for the caller.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        category: str,
+        input_nodes: list[Buffer],
+        layout: Layout,
+        make_kernel_render: Callable[
+            [ROCmTemplateBuffer, Sequence[IRNode] | None], str
+        ],
+        bmreq: ROCmBenchmarkRequest,
+        template: "ROCmTemplate",  # type: ignore[name-defined]
+        info_kwargs: dict[str, PrimitiveInfoType | list[PrimitiveInfoType]] | None,  # type: ignore[type-arg]
+    ) -> None:
+        super().__init__(name, input_nodes, layout, description="")
+        self.category = category
+        self.make_kernel_render = make_kernel_render
+        self.bmreq = bmreq
+        self.template = template
+        self.info_kwargs = info_kwargs
+
+    def precompile(self) -> None:
+        if self.bmreq is None:
+            raise AssertionError("expected self.bmreq to be set")
+        self.bmreq.precompile()
+
+    def benchmark(self, *args, out) -> float:
+        if self.bmreq is None:
+            raise AssertionError("expected self.bmreq to be set")
+        if config.profile_bandwidth_with_do_bench_using_profiling:
+            algo = self.bmreq.make_run_fn(*args, out=out)
+            return do_bench_using_profiling(algo)
+        return self.bmreq.benchmark(*args, out=out)
+
+    def __str__(self) -> str:
+        return f"ROCmTemplateCaller(source_file={self.bmreq.source_file}, {self.info_dict()})"
+
+    def call_name(self) -> str:
+        return f"rocm_template_kernels.{self.name}"
+
+    def hash_key(self) -> str:
+        return "-".join(
+            [
+                self.category,
+                self.bmreq.hash_key,
+            ]
+        )
+
+    def info_dict(self) -> dict[str, PrimitiveInfoType | list[PrimitiveInfoType]]:
+        """Information returned here is logged to the autotune log file when that is enabled."""
+        return {
+            "backend": "ROCm",
+            "name": self.name,
+            **dict(self.info_kwargs["op"].dict_items()),  # type: ignore[union-attr, index]
+        }
+
+    def output_node(self) -> TensorBox:
+        self.bmreq.update_workspace_size()
+        buffer = ROCmTemplateBuffer(
+            layout=self.layout,
+            inputs=self.input_nodes,
+            make_kernel_render=self.make_kernel_render,
+            workspace_size=self.bmreq.workspace_size,
+            template=self.template,
+        )
+        # Pass KTC annotation to the buffer for encoding
+        if "ktc" in self.annotations:
+            buffer.annotations["ktc"] = self.annotations["ktc"]
+        return TensorBox.create(buffer)

.venv/lib/python3.12/site-packages/torch/_inductor/codegen/rocm/rocm_template.py

@@ -0,0 +1,194 @@
+# mypy: allow-untyped-defs
+import functools
+import itertools
+import logging
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import Any
+from unittest.mock import patch
+
+from ...autotune_process import TensorMeta
+from ...ir import Buffer, IRNode, Layout
+from ...utils import IndentedBuffer, unique
+from ...virtualized import V
+from ..common import KernelTemplate
+from .rocm_benchmark_request import ROCmBenchmarkRequest
+from .rocm_kernel import ROCmTemplateCaller, ROCmTemplateKernel
+from .rocm_template_buffer import ROCmTemplateBuffer
+from .rocm_utils import DTYPE_TO_ROCM_TYPE
+
+
+log = logging.getLogger(__name__)
+
+
+# FIXME: unify with the CUDA version
+@dataclass(frozen=True)
+class ArgInfo:
+    name: str
+    ty: str
+
+
+class ROCmTemplate(KernelTemplate):
+    index_counter = itertools.count()
+    gfx9_threads_per_warp = 64
+
+    def __init__(
+        self,
+        name: str,
+        input_nodes: list[Buffer],
+        layout: Layout,
+        input_reorder: list[int] | None = None,
+    ) -> None:
+        """
+
+        Baseclass for ROCm C++ Templates, derived from KernelTemplate. Not to be instantiated directly.
+
+        Args:
+            name (str): The name of the ROCmTemplate object.
+            input_nodes (List[IRNode]): A list of input IRNodes.
+            layout (Layout): The layout of the output buffer / tensor.
+            input_reorder (Optional[List[int]]): An optional list that specifies the order of the input nodes.
+
+        """
+        super().__init__(name)
+        self.input_nodes = input_nodes
+        self.output_node: Buffer = Buffer(name="buf_out", layout=layout)
+        self.input_reorder = input_reorder
+        self.layout = layout
+
+    def generate(  # type: ignore[override]
+        self,
+        **kwargs,
+    ) -> ROCmTemplateCaller:
+        """
+        Generates the ROCm template caller object for the given GEMM template and operation. This ROCmTemplateCaller
+        may be used to call and benchmark the generated ROCm kernel in a standalone manner to enable Autotuning.
+
+        Args:
+            kwargs: Additional keyword arguments.
+
+        Returns:
+            A ROCmTemplateCaller object representing the generated ROCm template caller.
+        """
+        kernel_name = f"rocm_{self.name}"
+        kernel_hash_name = f"rocm_{self.name}_{next(self.index_counter)}"
+        with (
+            patch.object(V.graph, "get_dtype", self._fake_get_dtype(self.output_node)),
+            ROCmTemplateKernel(
+                kernel_name=kernel_name,
+                runtime_arg_info=self.get_runtime_arg_info(),
+                runtime_arg_values=self.get_runtime_arg_values(**kwargs),
+            ) as kernel,
+        ):
+            code = self.render(kernel=kernel, **kwargs)
+            _, call_args, _, _ = kernel.args.python_argdefs()
+            log.debug("Autotune key: %s, Generated Code:\n%s", kernel_hash_name, code)
+            log.debug(
+                "Args: cpp_argdefs: %s, python_argdefs: %s",
+                kernel.args.cpp_argdefs(DTYPE_TO_ROCM_TYPE),
+                kernel.args.python_argdefs(),
+            )
+
+        input_reorder = (
+            self.input_reorder
+            if self.input_reorder is not None
+            else list(range(len(self.input_nodes)))
+        )
+        expected_args = list(
+            unique(self.input_nodes[idx].get_name() for idx in input_reorder)
+        )
+        expected_args.extend([self.output_node.get_name()])
+        if list(call_args)[: len(expected_args)] != expected_args:
+            raise AssertionError(
+                (
+                    call_args,
+                    expected_args,
+                )
+            )
+
+        size_args = (
+            self.size_args() if hasattr(self, "size_args") else ()
+        )  # subclass should define def size_args()
+        # Resolve symbolic sizes to concrete ints for benchmarking only.
+        size_args_ints = list(V.graph.sizevars.optimization_hints(size_args))
+        # The runtime args come right after the size args
+        runtime_args = self.get_runtime_arg_values(**kwargs)
+        extra_args = size_args_ints + runtime_args
+        bmreq = ROCmBenchmarkRequest(
+            kernel_name=kernel_name,
+            input_tensor_meta=TensorMeta.from_irnodes(self.input_nodes),
+            output_tensor_meta=TensorMeta.from_irnodes(self.output_node),
+            extra_args=extra_args,
+            source_code=code,
+        )
+
+        def make_kernel_render(
+            template_node: ROCmTemplateBuffer,
+            epilogue_nodes: Sequence[IRNode] | None = None,
+        ):
+            kernel = ROCmTemplateKernel(
+                kernel_name="KERNEL_NAME",
+                runtime_arg_info=self.get_runtime_arg_info(),
+                runtime_arg_values=self.get_runtime_arg_values(**kwargs),
+            )
+            render = functools.partial(
+                self.render,
+                kernel=kernel,
+                template_buffer_node=template_node,
+                epilogue_nodes=epilogue_nodes,
+                **kwargs,  # includes "op" argument in case of CUTLASSGemmTemplate
+            )
+            return kernel, render
+
+        return ROCmTemplateCaller(
+            kernel_hash_name,
+            self.name,
+            self.input_nodes,
+            self.output_node.get_layout(),
+            make_kernel_render,
+            bmreq,
+            self,
+            kwargs,
+        )
+
+    def header(self) -> IndentedBuffer:
+        res = IndentedBuffer()
+        res.splice(
+            """
+                #include <exception>
+                #include <iostream>
+                #include <memory>
+                #include <random>
+                #include <vector>
+            """
+        )
+        return res
+
+    def globals(self) -> IndentedBuffer:
+        res = IndentedBuffer()
+        res.splice(
+            """
+                // We compile all models with -fvisibility=hidden. Any symbols that need to be
+                // exposed in the final shared library must be declared with PT_EXPORT to make
+                // them visible.
+                #ifdef __GNUC__ // Applies to any compiler with GNU extensions (clang and g++)
+                #define PT_EXPORT __attribute__((__visibility__("default")))
+                #else
+                #ifdef _WIN32
+                #define PT_EXPORT __declspec(dllexport)
+                #else
+                #define PT_EXPORT
+                #endif
+                #endif
+            """
+        )
+        return res
+
+    def render(self, **kwargs) -> str:
+        raise NotImplementedError
+
+    def get_runtime_arg_info(self) -> list[ArgInfo]:
+        return []
+
+    def get_runtime_arg_values(self, **kwargs) -> list[Any]:
+        return []

.venv/lib/python3.12/site-packages/torch/_inductor/codegen/rocm/rocm_template_buffer.py

@@ -0,0 +1,27 @@
+from collections.abc import Callable, Sequence
+from typing import TypeVar
+from typing_extensions import ParamSpec
+
+from ...ir import Buffer, Layout, TemplateBuffer
+
+
+_P = ParamSpec("_P")
+_T = TypeVar("_T")
+
+
+class ROCmTemplateBuffer(TemplateBuffer):
+    def __init__(
+        self,
+        layout: Layout,
+        inputs: Sequence[Buffer],
+        make_kernel_render: Callable[_P, _T],
+        workspace_size: int,
+        template: "ROCmTemplate",  # type: ignore[name-defined]  # noqa: F821
+    ) -> None:
+        super().__init__(layout, inputs, make_kernel_render)
+        # Global memory (in bytes) needed for this template.
+        self.workspace_size = workspace_size
+        self.template = template
+
+    def get_workspace_size(self) -> int:
+        return self.workspace_size if self.workspace_size is not None else 0

.venv/lib/python3.12/site-packages/torch/_inductor/codegen/rocm/rocm_utils.py

@@ -0,0 +1,17 @@
+# mypy: allow-untyped-defs
+
+
+import torch
+
+from ..cpp_utils import DTYPE_TO_CPP
+
+
+DTYPE_TO_ROCM_TYPE = {
+    **DTYPE_TO_CPP,
+    torch.float16: "uint16_t",
+    torch.float8_e4m3fnuz: "uint8_t",
+    torch.float8_e5m2fnuz: "uint8_t",
+    torch.float8_e4m3fn: "uint8_t",
+    torch.float8_e5m2: "uint8_t",
+    torch.bfloat16: "uint16_t",
+}

.venv/lib/python3.12/site-packages/torch/_inductor/codegen/segmented_tree.py

@@ -0,0 +1,242 @@
+from collections.abc import Callable
+from typing import Generic, TypeVar
+
+
+T = TypeVar("T")
+
+
+def _value_or(opt: T | None, default: T) -> T:
+    return opt if opt is not None else default
+
+
+class SegmentedTree(Generic[T]):
+    def __init__(
+        self,
+        values: list[T],
+        update_op: Callable[[T, T], T],
+        summary_op: Callable[[T, T], T],
+        identity_element: T,
+    ):
+        """
+        Initialize a segment tree with the given values and operations.
+
+        Args:
+            values: list of initial values
+            update_op: Function to apply when updating a value (e.g., addition)
+            summary_op: Function to summarize two values (e.g., min, max, sum)
+            identity_element: Identity element for the summary_op (e.g., 0 for sum, float('inf') for min)
+
+        Raises:
+            ValueError: If the input values list is empty
+        """
+        if not values:
+            raise ValueError("Cannot create a segment tree with empty values list")
+
+        self.n = len(values)
+        self.update_op = update_op
+        self.summary_op = summary_op
+        self.identity = identity_element
+
+        # Size of segment tree array (next power of 2 * 2)
+        # The tree follows a standard heap layout where
+        # node `n`'s children are at `2*n` and `2*n+1`.
+        # Index 0 is unused.
+        self.size = 1
+        while self.size < self.n:
+            self.size *= 2
+        self.size *= 2
+
+        # Initialize tree and lazy arrays
+        self.tree = [identity_element] * self.size
+        # The lazy array contains updates to the given node
+        # Upon update, we only push updates to the top-most
+        # nodes that fully receive the update. We then
+        # propagate the update down as required (i.e., when
+        # we receive an interval query that neither fully
+        # contains the node nor fully doesn't contain the
+        # node
+        self.lazy: list[T | None] = [None] * self.size
+
+        # Build the tree
+        self._build(values, 1, 0, self.n - 1)
+
+    def _build(self, values: list[T], node: int, start: int, end: int) -> None:
+        """
+        Build the segment tree recursively.
+
+        Args:
+            values: Original array of values
+            node: Current node index in the segment tree
+            start: Start index of the segment
+            end: End index of the segment
+        """
+        if start == end:
+            # Leaf node
+            if start < len(values):
+                self.tree[node] = values[start]
+            return
+
+        mid = (start + end) // 2
+        left_child = 2 * node
+        right_child = 2 * node + 1
+
+        # Recursively build left and right subtrees
+        self._build(values, left_child, start, mid)
+        self._build(values, right_child, mid + 1, end)
+
+        # Update current node with summary of children
+        self.tree[node] = self.summary_op(self.tree[left_child], self.tree[right_child])
+
+    def _children(self, node: int) -> list[int]:
+        return [2 * node, 2 * node + 1]
+
+    def _push_lazy(self, node: int, start: int, end: int) -> None:
+        """
+        Push lazy updates down to children.
+
+        Args:
+            node: Current node index
+            start: Start index of the segment
+            end: End index of the segment
+        """
+        lazy_node = self.lazy[node]
+        if lazy_node is None:
+            return
+
+        # Apply lazy update to current node
+        self.tree[node] = self.update_op(self.tree[node], lazy_node)
+
+        if start != end:  # Not a leaf node
+            # Propagate to children
+            for child in self._children(node):
+                self.lazy[child] = self.update_op(
+                    _value_or(self.lazy[child], self.identity), lazy_node
+                )
+
+        # Clear the lazy value
+        self.lazy[node] = None
+
+    def _update_range_helper(
+        self, node: int, start: int, end: int, left: int, right: int, value: T
+    ) -> None:
+        """
+        Helper method to update a range of values in the segment tree.
+
+        Args:
+            node: Current node index
+            start: Start index of the current segment
+            end: End index of the current segment
+            left: Start index of the range to update
+            right: End index of the range to update
+            value: Value to apply to the range
+        """
+        # Push lazy updates before processing this node
+        self._push_lazy(node, start, end)
+
+        # No overlap
+        if start > right or end < left:
+            return
+
+        # Complete overlap
+        if start >= left and end <= right:
+            # Apply update to current node
+            self.lazy[node] = value
+            self._push_lazy(node, start, end)
+            return
+
+        # Partial overlap, recurse to children
+        mid = (start + end) // 2
+        left_child = 2 * node
+        right_child = 2 * node + 1
+
+        self._update_range_helper(left_child, start, mid, left, right, value)
+        self._update_range_helper(right_child, mid + 1, end, left, right, value)
+
+        # Update current node based on children
+        self.tree[node] = self.summary_op(self.tree[left_child], self.tree[right_child])
+
+    def _query_range_helper(
+        self, node: int, start: int, end: int, left: int, right: int
+    ) -> T:
+        """
+        Helper method to query a range of values in the segment tree.
+
+        Args:
+            node: Current node index
+            start: Start index of the current segment
+            end: End index of the current segment
+            left: Start index of the range to query
+            right: End index of the range to query
+
+        Returns:
+            Summary value for the range
+        """
+        # No overlap
+        if start > right or end < left:
+            return self.identity
+
+        # Push lazy updates before processing this node
+        self._push_lazy(node, start, end)
+
+        # Complete overlap
+        if start >= left and end <= right:
+            return self.tree[node]
+
+        # Partial overlap, recurse to children
+        mid = (start + end) // 2
+        left_child = 2 * node
+        right_child = 2 * node + 1
+
+        left_result = self._query_range_helper(left_child, start, mid, left, right)
+        right_result = self._query_range_helper(right_child, mid + 1, end, left, right)
+
+        # Combine results from children
+        return self.summary_op(left_result, right_result)
+
+    def update_range(self, start: int, end: int, value: T) -> None:
+        """
+        Update a range of values in the segment tree.
+
+        Args:
+            start: Start index of the range to update (inclusive)
+            end: End index of the range to update (inclusive)
+            value: Value to apply to the range
+
+        Raises:
+            ValueError: If start > end or indices are out of bounds
+        """
+        if start > end:
+            raise ValueError("Start index must be less than or equal to end index")
+
+        if start < 0 or start >= self.n:
+            raise ValueError(f"Start index {start} out of bounds [0, {self.n - 1}]")
+
+        if end < 0 or end >= self.n:
+            raise ValueError(f"End index {end} out of bounds [0, {self.n - 1}]")
+
+        self._update_range_helper(1, 0, self.n - 1, start, end, value)
+
+    def summarize_range(self, start: int, end: int) -> T:
+        """
+        Query a range of values in the segment tree.
+
+        Args:
+            start: Start index of the range to query (inclusive)
+            end: End index of the range to query (inclusive)
+
+        Returns:
+            Summary value for the range according to the summary operation
+
+        Raises:
+            ValueError: If start > end or indices are out of bounds
+        """
+        if start > end:
+            raise ValueError("Start index must be less than or equal to end index")
+
+        if start < 0 or start >= self.n:
+            raise ValueError(f"Start index {start} out of bounds [0, {self.n - 1}]")
+
+        if end < 0 or end >= self.n:
+            raise ValueError(f"End index {end} out of bounds [0, {self.n - 1}]")
+
+        return self._query_range_helper(1, 0, self.n - 1, start, end)

.venv/lib/python3.12/site-packages/torch/_inductor/codegen/simd_kernel_features.py

@@ -0,0 +1,790 @@
+from __future__ import annotations
+
+import collections
+import dataclasses
+import functools
+import itertools
+import typing
+from typing import Any
+
+import sympy
+
+import torch
+
+from ...utils._ordered_set import OrderedSet
+from ...utils._sympy.functions import FloorDiv, Min, ModularIndexing
+from ...utils._sympy.symbol import make_symbol, SymT
+from .. import ir
+from ..dependencies import Dep, extract_loop_body_with_args, MemoryDep
+from ..runtime.hints import ReductionHint
+from ..runtime.runtime_utils import next_power_of_2
+from ..scheduler import SchedulerNode
+from ..utils import cache_on_self
+from ..virtualized import V
+
+
+if typing.TYPE_CHECKING:
+    from collections.abc import Iterable, Sequence
+
+    from torch._inductor.tiling_utils import CoalesceVarAnalysis
+
+
+_INNER_REDUCTION_RATIO = 32
+_SMALL_INNER_REDUCTION_RATIO = 16
+_SMALL_INNER_REDUCTION_MAX_RBLOCK = 512
+
+
+def tiling_scores_suggest_inner_reduction(
+    tiling_scores: dict[str, sympy.Expr], reduction_numel: sympy.Expr
+) -> bool:
+    """Return whether tiling scores justify treating a reduction as inner."""
+    sizevars = V.graph.sizevars
+    non_reduction_score = sum(
+        sizevars.optimization_hint(tiling_scores.get(dim, 0), fallback=0)
+        for dim in ("x", "y", "z")
+    )
+    non_reduction_score = max(non_reduction_score, 1)
+    r_score = sizevars.optimization_hint(tiling_scores["r0_"], fallback=0)
+    if r_score >= _INNER_REDUCTION_RATIO * non_reduction_score:
+        return True
+    if r_score < _SMALL_INNER_REDUCTION_RATIO * non_reduction_score:
+        return False
+
+    # Moderate score ratios are useful while persistent configs can keep XBLOCK=8.
+    rblock_hint = next_power_of_2(
+        max(sizevars.optimization_hint(reduction_numel, fallback=1), 1)
+    )
+    return rblock_hint <= _SMALL_INNER_REDUCTION_MAX_RBLOCK
+
+
+class NodeScheduleMarker:
+    @staticmethod
+    def only_nodes(it: Iterable[NodeScheduleEntry]) -> Iterable[SchedulerNode]:
+        for item in it:
+            if not (item is DisableReduction or item is EnableReduction):
+                yield item  # type: ignore[misc]
+
+    @staticmethod
+    def is_reduction() -> bool:
+        return False
+
+
+NodeScheduleEntry = SchedulerNode | type[NodeScheduleMarker]
+
+
+class DisableReduction(NodeScheduleMarker):
+    """
+    Marker to invoke `kernel.disable_reduction()`.  This closes a
+    reduction loop and allows for pointwise ops to occur on the output
+    of a reduction.
+    """
+
+
+class EnableReduction(NodeScheduleMarker):
+    """
+    Marker to end a DisableReduction block.
+    """
+
+    @staticmethod
+    def filter(node_schedule: list[NodeScheduleEntry]) -> Iterable[SchedulerNode]:
+        """
+        Get the nodes from node_schedule skipping those in a
+        DisableReduction block.
+        """
+        disabled = False
+        for node in node_schedule:
+            if node in (EnableReduction, DisableReduction):
+                # Don't tile stuff outside the main reduction loop
+                disabled = node is DisableReduction
+            elif disabled:
+                pass
+            else:
+                yield node  # type: ignore[misc]
+
+
+class SIMDKernelFeatures:
+    """
+    An ordered schedule of nodes that will become a single kernel.
+    """
+
+    def __init__(
+        self,
+        node_schedule: list[NodeScheduleEntry],
+        numel: sympy.Expr,
+        reduction_numel: sympy.Expr = sympy.S.One,
+        coalesce_analysis: CoalesceVarAnalysis | None = None,
+        tiling_scores: dict[str, sympy.Expr] | None = None,
+    ):
+        self.node_schedule = node_schedule
+        # numel excludes reduction_numel
+        self.numel: sympy.Expr = V.graph.sizevars.simplify(numel)
+        self.reduction_numel: sympy.Expr = V.graph.sizevars.simplify(reduction_numel)
+        self._stats_cache: dict[tuple[sympy.Expr, ...], MemoryStats] = {}
+        self.coalesce_analysis = coalesce_analysis
+        self.tiling_scores = tiling_scores
+
+    def with_tiling_scores(
+        self, tiling_scores: dict[str, sympy.Expr] | None
+    ) -> SIMDKernelFeatures:
+        return SIMDKernelFeatures(
+            self.node_schedule,
+            self.numel,
+            self.reduction_numel,
+            self.coalesce_analysis,
+            tiling_scores,
+        )
+
+    @cache_on_self
+    def is_reduction(self) -> bool:
+        return self.reduction_numel != 1
+
+    @cache_on_self
+    def scheduler_nodes(self) -> Iterable[SchedulerNode]:
+        return tuple(NodeScheduleMarker.only_nodes(self.node_schedule))
+
+    def reduction_nodes(self) -> list[SchedulerNode]:
+        return [n for n in self.scheduler_nodes() if n.is_reduction()]
+
+    @cache_on_self
+    def strict_sum_reductions(self) -> tuple[ir.Reduction, ...]:
+        return tuple(
+            node.node.data
+            for node in self.reduction_nodes()
+            if isinstance(node.node, ir.ComputedBuffer)
+            and isinstance(node.node.data, ir.Reduction)
+            and node.node.data.strict_sum_rblock is not None
+        )
+
+    def has_strict_sum_multirow_reduction(self) -> bool:
+        return any(r.strict_sum_multirow for r in self.strict_sum_reductions())
+
+    @cache_on_self
+    def strict_sum_rblock(self) -> int | None:
+        rblocks = OrderedSet(
+            reduction.strict_sum_rblock for reduction in self.strict_sum_reductions()
+        )
+        if not rblocks:
+            return None
+        if len(rblocks) != 1:
+            raise AssertionError(
+                f"strict sums require one reduction block size, got {rblocks}"
+            )
+        return next(iter(rblocks))
+
+    @cache_on_self
+    def buf_accesses(self) -> dict[str, list[Dep]]:
+        """only needed for config.benchmark_kernel"""
+        buf_accesses = collections.defaultdict(list)
+        for node in self.scheduler_nodes():
+            for access in node.read_writes.reads | node.read_writes.writes:
+                buf_accesses[access.name].append(access)
+        return buf_accesses
+
+    @cache_on_self
+    def op_counts(self) -> collections.Counter[str]:
+        counts: collections.Counter[str] = collections.Counter()
+        for node in self.scheduler_nodes():
+            counts.update(node._body.op_counts)
+        return counts
+
+    def contains_op(self, op_name: str) -> bool:
+        """True if V.ops.{op_name} is used in node_schedule"""
+        return bool(self.op_counts().get(op_name))
+
+    def get_mutations(self) -> OrderedSet[str]:
+        mutations: OrderedSet[str] = OrderedSet()
+        for node in self.scheduler_nodes():
+            for buf in node.get_outputs():
+                mutations.update(buf.get_mutations())
+        return mutations
+
+    @cache_on_self
+    def select_index_dtype(self) -> torch.dtype:
+        # Gather all used buffer names
+        buffer_names: OrderedSet[str] = OrderedSet()
+        for node in self.scheduler_nodes():
+            buffer_names.update(node.get_buffer_names())
+            buffer_names.update(node.used_buffer_names())
+        buffers = [V.graph.get_buffer(name) for name in buffer_names]
+
+        # In theory we can separately check xnumel and rnumel are <= int_max
+        # but some indexers do use the full linear index so we need to be
+        # conservative here.
+        total_numel = self.numel * self.reduction_numel
+
+        from .simd import SIMDScheduling
+
+        if SIMDScheduling.can_use_32bit_indexing(total_numel, buffers):
+            # Fused address expressions can overflow int32 even when
+            # numel/storage_size are within range, so check them directly.
+            if self.any_index_expr_overflows_int32():
+                return torch.int64
+            return torch.int32
+        return torch.int64
+
+    @cache_on_self
+    def any_index_expr_overflows_int32(self) -> bool:
+        """Return True if any MemoryDep addressing expression can overflow int32.
+
+        Two complementary checks are applied to each index:
+
+        - Constant offset: the index evaluated at the origin (every loop
+          variable set to 0) must lie within [-2**31, 2**31 - 1]. This is cheap
+          and independent of loop-var ranges, so it also covers deps whose sizes
+          are symbolic.
+        - Variable-scaled bound: the index bounded over the actual iteration
+          range of every loop variable must not exceed 2**31 - 1. This catches
+          overflow such as the `V * x0` synthesized when unrolled chunked-loop
+          slices are stitched into one pointwise kernel (`V` a per-chunk stride,
+          `x0` spanning the fused numel); unlike a `numel * max_stride` proxy it
+          is exact, since a stride on a size-1 dim multiplies an empty range and
+          drops out. Deps with a symbolic loop-var size, or whose bound is
+          unknown/indirect (infinite), are skipped here and left to the
+          constant-offset and per-buffer storage-size checks.
+        """
+        from torch.utils._sympy.numbers import int_oo
+        from torch.utils._sympy.value_ranges import bound_sympy, ValueRanges
+
+        int32_max = sympy.Integer(2**31 - 1)
+        int32_min = sympy.Integer(-(2**31))
+        for node in self.scheduler_nodes():
+            for dep in itertools.chain(node.read_writes.reads, node.read_writes.writes):
+                if not isinstance(dep, MemoryDep):
+                    continue
+                index = dep.index
+                if not isinstance(index, sympy.Expr):
+                    continue
+
+                # Constant offset (index at the origin).
+                try:
+                    const_part = index.subs(
+                        {s: sympy.Integer(0) for s in index.free_symbols}
+                    )
+                    if isinstance(const_part, sympy.Expr) and (
+                        const_part > int32_max or const_part < int32_min
+                    ):
+                        return True
+                except (ZeroDivisionError, TypeError, ValueError):
+                    pass
+
+                # Variable-scaled bound over concrete loop-var ranges. A
+                # ValueRanges bound must be concrete, so skip a dep with any
+                # symbolic loop-var size.
+                sizes = dep.size
+                if any(getattr(s, "free_symbols", None) for s in sizes):
+                    continue
+                try:
+                    var_ranges = {
+                        var: ValueRanges(0, max(int(size) - 1, 0))
+                        for var, size in zip(dep.var_names, sizes)
+                    }
+                    upper = bound_sympy(index, var_ranges).upper
+                    if (
+                        isinstance(upper, sympy.Expr)
+                        and not upper.has(int_oo, sympy.oo)
+                        and upper > int32_max
+                    ):
+                        return True
+                except (ZeroDivisionError, TypeError, ValueError):
+                    continue
+        return False
+
+    def get_reduction_hint(
+        self, tiling_scores: dict[str, sympy.Expr] | None = None
+    ) -> ReductionHint:
+        if tiling_scores is None:
+            tiling_scores = self.tiling_scores
+        reductions = self.reduction_nodes()
+        if len(reductions) > 0:
+            hints = [self.reduction_hint(n) for n in reductions]
+            if hints.count(hints[0]) == len(hints):
+                reduction_hint_val = hints[0]
+            else:
+                reduction_hint_val = ReductionHint.DEFAULT
+
+            if (
+                reduction_hint_val == ReductionHint.INNER
+                and self.has_non_contiguous_pw_in_reduction_kernel()
+            ):
+                reduction_hint_val = ReductionHint.DEFAULT
+
+            # Upgrade DEFAULT to INNER for inner reductions based on tiling scores
+            if (
+                reduction_hint_val == ReductionHint.DEFAULT
+                and tiling_scores is not None
+                and "x" in tiling_scores
+                and "r0_" in tiling_scores
+            ):
+                if tiling_scores_suggest_inner_reduction(
+                    tiling_scores, self.reduction_numel
+                ):
+                    reduction_hint_val = ReductionHint.INNER
+        else:
+            reduction_hint_val = ReductionHint.DEFAULT
+        return reduction_hint_val
+
+    @cache_on_self
+    def buffer_read_counts(self) -> dict[str, int]:
+        """Counts how many times each buffer is read within the kernel"""
+        read_counts: dict[str, int] = collections.defaultdict(int)
+
+        for node in self.scheduler_nodes():
+            # node.read_writes.reads contains MemoryDep objects for each read
+            for read_dep in node.read_writes.reads:
+                read_counts[read_dep.name] += 1
+
+        return dict(read_counts)  # Convert defaultdict to regular dict
+
+    def has_non_contiguous_pw_in_reduction_kernel(self) -> bool:
+        pointwise_nodes = [
+            n
+            for n in self.scheduler_nodes()
+            if not n.is_reduction()
+            and n.group[1][0] == self.numel * self.reduction_numel
+        ]
+        for node in pointwise_nodes:
+            # An index can be an integer when loading a random seed.
+            if not all(
+                not isinstance(dep, MemoryDep)
+                or dep.is_contiguous()
+                or isinstance(dep.index, (sympy.Integer, int))
+                or dep.stride1_for_last_dim()
+                for dep in itertools.chain(
+                    node.read_writes.reads, node.read_writes.writes
+                )
+            ):
+                return True
+        return False
+
+    @staticmethod
+    def reduction_hint(node: Any) -> ReductionHint:
+        if not node.is_reduction():
+            raise AssertionError("expected node to be a reduction")
+        if node.node.data.reduction_hint != ReductionHint.INNER and all(
+            dep.is_contiguous()
+            for dep in itertools.chain(node.read_writes.reads, node.read_writes.writes)
+        ):
+            return ReductionHint.INNER
+        else:
+            return node.node.data.reduction_hint
+
+    def memory_stats(
+        self, groups_dict: dict[str, sympy.Expr] | None = None
+    ) -> MemoryStats:
+        """Analysis to generate features that can be used in heuristics"""
+        if groups_dict is None:
+            groups = (self.numel, self.reduction_numel)
+        elif groups_dict.keys() == OrderedSet(["x", "r0_"]):
+            groups = (groups_dict["x"], groups_dict["r0_"])
+        else:
+            raise NotImplementedError(f"groups_dict={groups_dict!r}")
+        result = self._stats_cache.get(groups)
+        if result is None:
+            self._stats_cache[groups] = result = MemoryStats.compute(
+                MemoryEstimator(self, groups)
+            )
+        return result
+
+
+class MemoryEstimator:
+    """
+    Estimate various properties of the kernel for use in heuristics.
+    We simulate the memory effects of CSE/buffer elimination in codegen.
+    """
+
+    kernel_sizes: tuple[sympy.Expr, ...]
+    outside_loop: MemoryEstimate
+    loops: list[MemoryEstimate]
+    persistent: MemoryEstimate
+    symbols: list[sympy.Symbol]
+
+    def __init__(self, features: SIMDKernelFeatures, groups: Sequence[sympy.Expr]):
+        self.features = features
+        self.inside_reduction = features.is_reduction()
+        self.store_buffer_names: OrderedSet[str] = OrderedSet()
+        self.must_keep_buffers: OrderedSet[str] = OrderedSet()
+        self.num_reductions_dims = 1
+        self.groups = groups
+        self.symbols = [make_symbol(SymT.INDEX, i) for i in range(len(groups))]
+        # We are doing two estimates simultaneously:
+        # 1) the first is a for a non-persistent (aka looped) reduction, using self.outside_loop/self.loops
+        # we add an item to loops each corresponding to each reduction loop in the kernel
+        # outside_loop is only used for broadcasting or point-wise ops that don't use the reduction dimension
+        # 2) the second is for a persistent kernel, using self.persistent
+        # persistent kernels don't have loops, so we only have one MemoryEstimate()
+        # for point-wise ops the two estimates will be the same, they matter for reductions only
+        self.outside_loop = MemoryEstimate()
+        self.loops = [MemoryEstimate()]
+        self.persistent = MemoryEstimate()
+        self.simulate_codegen()
+        self.remove_kernel_local()
+
+    def simulate_codegen(self) -> None:
+        from .simd import SIMDKernel
+
+        kernel_size_outside_loop = (*self.groups[:-1], sympy.S.One)
+        kernel_size_inside_loop = tuple(self.groups)
+        self.kernel_sizes = kernel_size_inside_loop
+
+        for node in self.features.node_schedule:
+            if node is DisableReduction:
+                self.inside_reduction = False
+                self.kernel_sizes = kernel_size_outside_loop
+                continue
+            elif node is EnableReduction:
+                self.inside_reduction = True
+                self.kernel_sizes = kernel_size_inside_loop
+                self.loops.append(MemoryEstimate())
+                continue
+            if not isinstance(node, SchedulerNode):
+                raise AssertionError(f"expected SchedulerNode, got {type(node)}")
+            rw = extract_loop_body_with_args(
+                node._body,
+                SIMDKernel.map_kernel_groups_to_node_sizes(
+                    self.kernel_sizes, node.get_ranges(), self.set_ranges
+                ),
+                dict(zip(self.symbols, self.kernel_sizes)),
+            )
+
+            for dep in rw._reads:
+                if not isinstance(dep, MemoryDep):
+                    continue
+                dep = dep.simplify_with_ranges()
+                if not self.persistent.writes.get(dep.name):  # cache miss?
+                    self.persistent.reads[dep.name].add(dep)
+                # the cache behavior of looped kernels is more complex than the persistent case above
+                # some operations are lifted outside the loop (if they don't use the reduction dimension)
+                # other operations are inside the loop, and can only be reused within the same loop
+                if not (
+                    self.outside_loop.writes.get(dep.name)
+                    or self.loops[-1].writes.get(dep.name)
+                ):
+                    self.scope(dep).reads[dep.name].add(dep)
+                    if dep.name in self.store_buffer_names and self.loops[-1].reads.get(
+                        dep.name
+                    ):
+                        self.must_keep_buffers.add(dep.name)
+
+            for dep in rw._writes:
+                if not isinstance(dep, MemoryDep):
+                    continue
+                dep = dep.simplify_with_ranges()
+                self.store_buffer_names.add(dep.name)
+                self.persistent.writes[dep.name].add(dep)
+                self.scope(dep).writes[dep.name].add(dep)
+
+    def remove_kernel_local(self) -> None:
+        # Remove any kernel-local buffers
+        fused_node_names = OrderedSet(
+            [n.get_name() for n in self.features.scheduler_nodes()]
+        )
+        for name in self.store_buffer_names:
+            if not self.persistent.reads.get(
+                name
+            ) and V.graph.scheduler.can_buffer_be_removed_through_fusion(
+                name, fused_node_names
+            ):
+                self.persistent.remove(name)
+                if name not in self.must_keep_buffers:
+                    # we can also remove this from the looped kernel
+                    self.outside_loop.remove(name)
+                    for loop in self.loops:
+                        loop.remove(name)
+
+        if not self.loops[-1]:
+            self.loops.pop()  # for pointwise ops
+
+    def scope(self, dep: MemoryDep) -> MemoryEstimate:
+        """Determine how a read/write should be categorized"""
+        if self.inside_reduction and (
+            self.has_reduction_var(dep.index) or dep.is_indirect()
+        ):
+            return self.loops[-1]
+        return self.outside_loop
+
+    def has_reduction_var(self, index: sympy.Expr) -> bool:
+        for sym in self.symbols[-self.num_reductions_dims :]:
+            if isinstance(sym, sympy.Symbol) and sym in index.free_symbols:
+                return True
+        return False
+
+    def set_ranges(self, *lengths: list[list[sympy.Expr]]) -> list[list[sympy.Expr]]:
+        if len(self.kernel_sizes) != len(lengths):
+            raise AssertionError(
+                f"expected len(kernel_sizes) == len(lengths), got "
+                f"{len(self.kernel_sizes)} != {len(lengths)}"
+            )
+        return [
+            self.make_flat_range(sym, numel, length)
+            for sym, numel, length in zip(self.symbols, self.kernel_sizes, lengths)
+        ]
+
+    @staticmethod
+    def make_flat_range(
+        sym: sympy.Symbol, numel: sympy.Expr, lengths: list[sympy.Expr]
+    ) -> list[sympy.Expr]:
+        if len(lengths) == 1 and numel == lengths[0]:
+            return [sym]
+        divisor = sympy.S.One
+        itervars = []
+        for length in reversed(lengths):
+            if V.graph.sizevars.statically_known_equals(divisor * length, numel):
+                expr = FloorDiv(sym, divisor)
+            else:
+                expr = ModularIndexing(sym, divisor, length)
+            itervars.append(expr)
+            divisor = divisor * length
+        return [*reversed(itervars)]
+
+
+@dataclasses.dataclass
+class MemoryEstimate:
+    """Tracks the memory usage of a single loop in the generated kernel"""
+
+    reads: dict[str, OrderedSet[MemoryDep]] = dataclasses.field(
+        default_factory=functools.partial(collections.defaultdict, OrderedSet)
+    )
+    writes: dict[str, OrderedSet[MemoryDep]] = dataclasses.field(
+        default_factory=functools.partial(collections.defaultdict, OrderedSet)
+    )
+
+    def remove(self, name: str) -> None:
+        self.reads.pop(name, None)
+        self.writes.pop(name, None)
+
+    def __bool__(self) -> bool:
+        return bool(self.reads or self.writes)
+
+    def __repr__(self) -> str:
+        return f"""MemoryEstimate(
+            reads={[*itertools.chain.from_iterable(self.reads.values())]!r},
+            writes={[*itertools.chain.from_iterable(self.writes.values())]!r}
+        )"""
+
+
+@dataclasses.dataclass
+class StatsForDim:
+    """Memory usage stats for a block dimension in the generated kernel (different from user dimensions)"""
+
+    # the number of load/store ops
+    count_per_thread_contiguous: int = 0
+    count_per_thread_broadcast: int = 0
+    count_per_thread_non_contiguous: int = 0  # excludes broadcast
+
+    # total bytes in each load/store op for a single element
+    bytes_per_thread_contiguous: int = 0
+    bytes_per_thread_broadcast: int = 0
+    bytes_per_thread_non_contiguous: int = 0  # excludes broadcast
+
+    # total bytes read by entire kernel
+    bytes_contiguous_or_broadcast: sympy.Expr = sympy.S.Zero
+    bytes_non_contiguous: sympy.Expr = sympy.S.Zero
+
+    def __add__(self, other: typing.Self) -> StatsForDim:
+        return StatsForDim(
+            count_per_thread_contiguous=self.count_per_thread_contiguous
+            + other.count_per_thread_contiguous,
+            count_per_thread_broadcast=self.count_per_thread_broadcast
+            + other.count_per_thread_broadcast,
+            count_per_thread_non_contiguous=self.count_per_thread_non_contiguous
+            + other.count_per_thread_non_contiguous,
+            bytes_per_thread_contiguous=self.bytes_per_thread_contiguous
+            + other.bytes_per_thread_contiguous,
+            bytes_per_thread_broadcast=self.bytes_per_thread_broadcast
+            + other.bytes_per_thread_broadcast,
+            bytes_per_thread_non_contiguous=self.bytes_per_thread_non_contiguous
+            + other.bytes_per_thread_non_contiguous,
+            bytes_contiguous_or_broadcast=self.bytes_contiguous_or_broadcast
+            + other.bytes_contiguous_or_broadcast,
+            bytes_non_contiguous=self.bytes_non_contiguous + other.bytes_non_contiguous,
+        )
+
+    @property
+    def count_per_thread(self) -> int:
+        return (
+            self.count_per_thread_contiguous
+            + self.count_per_thread_broadcast
+            + self.count_per_thread_non_contiguous
+        )
+
+    @property
+    def bytes_per_thread(self) -> int:
+        return (
+            self.bytes_per_thread_contiguous
+            + self.bytes_per_thread_broadcast
+            + self.bytes_per_thread_non_contiguous
+        )
+
+    @property
+    def bytes(self) -> sympy.Expr:
+        return self.bytes_contiguous_or_broadcast + self.bytes_non_contiguous
+
+    @property
+    def contiguous_score(self) -> float:
+        return 1.0 - self.count_per_thread_non_contiguous / max(
+            self.count_per_thread, 1
+        )
+
+
+@dataclasses.dataclass
+class StatsForLoop:
+    """Memory usage stats for single loop in the generated kernel"""
+
+    # load/store ops
+    count_per_thread: int = 0
+    bytes_per_thread: int = 0
+
+    def __add__(self, other: typing.Self) -> StatsForLoop:
+        return StatsForLoop(
+            count_per_thread=self.count_per_thread + other.count_per_thread,
+            bytes_per_thread=self.bytes_per_thread + other.bytes_per_thread,
+        )
+
+
+@dataclasses.dataclass
+class StatsForReadsOrWrites:
+    """Memory usage stats that are collected for reads/writes/both"""
+
+    dim: list[StatsForDim]
+    loop: list[StatsForLoop]
+    # total bytes contiguous in any dimension
+    bytes_contiguous_or_broadcast: sympy.Expr = sympy.S.Zero
+    bytes_non_contiguous: sympy.Expr = sympy.S.Zero
+
+    def __add__(self, other: typing.Self) -> StatsForReadsOrWrites:
+        if len(self.dim) != len(other.dim):
+            raise AssertionError(
+                f"expected len(self.dim) == len(other.dim), got "
+                f"{len(self.dim)} != {len(other.dim)}"
+            )
+        if len(self.loop) != len(other.loop):
+            raise AssertionError(
+                f"expected len(self.loop) == len(other.loop), got "
+                f"{len(self.loop)} != {len(other.loop)}"
+            )
+        return StatsForReadsOrWrites(
+            dim=[a + b for a, b in zip(self.dim, other.dim)],
+            loop=[a + b for a, b in zip(self.loop, other.loop)],
+            bytes_contiguous_or_broadcast=self.bytes_contiguous_or_broadcast
+            + self.bytes_contiguous_or_broadcast,
+            bytes_non_contiguous=self.bytes_non_contiguous + other.bytes_non_contiguous,
+        )
+
+    @property
+    def count_per_thread(self) -> int:
+        return self.dim[0].count_per_thread
+
+    @property
+    def bytes_per_thread(self) -> int:
+        return self.dim[0].bytes_per_thread
+
+    @property
+    def bytes(self) -> sympy.Expr:
+        return self.bytes_contiguous_or_broadcast + self.bytes_non_contiguous
+
+    @classmethod
+    def compute(
+        cls,
+        loop_deps: list[dict[str, OrderedSet[MemoryDep]]],
+        index_symbols: list[sympy.Symbol],
+    ) -> typing.Self:
+        ndim = len(index_symbols)
+        result = cls(dim := [StatsForDim() for _ in range(ndim)], [])
+        for dep_group in loop_deps:
+            result.loop.append(loop_stats := StatsForLoop())
+            for name, deps in dep_group.items():
+                if not deps:
+                    raise AssertionError(f"expected non-empty deps for {name}")
+                contiguous_or_broadcast = [True] * ndim
+                numel = sympy.S.Zero
+                itemsize = V.graph.get_dtype(name).itemsize
+                loop_stats.count_per_thread += len(deps)
+                loop_stats.bytes_per_thread += itemsize * len(deps)
+                for dep in deps:
+                    strides: list[sympy.Expr] = V.graph.sizevars.stride_vars(
+                        dep.index, index_symbols
+                    )
+                    for i in range(ndim):
+                        if V.graph.sizevars.statically_known_equals(strides[i], 1):
+                            dim[i].count_per_thread_contiguous += 1
+                            dim[i].bytes_per_thread_contiguous += itemsize
+                        elif (
+                            V.graph.sizevars.statically_known_equals(strides[i], 0)
+                            and not dep.is_indirect()
+                        ):
+                            dim[i].count_per_thread_broadcast += 1
+                            dim[i].bytes_per_thread_broadcast += itemsize
+                        else:
+                            dim[i].count_per_thread_non_contiguous += 1
+                            dim[i].bytes_per_thread_non_contiguous += itemsize
+                            contiguous_or_broadcast[i] = False
+                    numel += dep.get_numel()
+                if len(deps) > 1:
+                    # can't read more elements than exist in the buffer
+                    numel = Min(numel, V.graph.get_numel(name))
+                nbytes = numel * itemsize
+                for i in range(ndim):
+                    if contiguous_or_broadcast[i]:
+                        dim[i].bytes_contiguous_or_broadcast += nbytes
+                    else:
+                        dim[i].bytes_non_contiguous += nbytes
+                if any(contiguous_or_broadcast):
+                    result.bytes_contiguous_or_broadcast += nbytes
+                else:
+                    result.bytes_non_contiguous += nbytes
+        if len(result.loop) > 1:
+            # the first loop represent the "outside of the loop" compute which could be long lived
+            result.loop = [result.loop[0] + x for x in result.loop[1:]]
+        return result
+
+
+@dataclasses.dataclass
+class StatsForKernelType:
+    """Memory usage stats that are collected for both persistent and looped kernels"""
+
+    reads: StatsForReadsOrWrites
+    writes: StatsForReadsOrWrites
+    memory: StatsForReadsOrWrites
+
+    @classmethod
+    def compute(
+        cls, loops: list[MemoryEstimate], estimator: MemoryEstimator
+    ) -> typing.Self:
+        reads = StatsForReadsOrWrites.compute(
+            [loop.reads for loop in loops], estimator.symbols
+        )
+        writes = StatsForReadsOrWrites.compute(
+            [loop.writes for loop in loops], estimator.symbols
+        )
+        return cls(
+            reads=reads,
+            writes=writes,
+            memory=reads + writes,
+        )
+
+
+@dataclasses.dataclass
+class MemoryStats:
+    """Memory usage stats collected for each generated kernel"""
+
+    persistent: StatsForKernelType
+    looped: StatsForKernelType
+
+    def get(self, persistent: bool) -> StatsForKernelType:
+        return self.persistent if persistent else self.looped
+
+    @classmethod
+    def compute(cls, estimator: MemoryEstimator) -> typing.Self:
+        persistent = StatsForKernelType.compute([estimator.persistent], estimator)
+        if len(estimator.loops) == 1 and not (
+            estimator.outside_loop and estimator.loops[0]
+        ):
+            looped = persistent  # loops/persistent is the same in this common case
+        else:
+            looped = StatsForKernelType.compute(
+                [estimator.outside_loop, *estimator.loops], estimator
+            )
+        return cls(
+            persistent=persistent,
+            looped=looped,
+        )

.venv/lib/python3.12/site-packages/torch/_inductor/codegen/subgraph.py

@@ -0,0 +1,615 @@
+import contextlib
+import functools
+import itertools
+import logging
+from collections.abc import Callable
+from typing import Any
+
+import sympy
+
+import torch
+import torch._inductor.config as config
+from torch._dynamo.utils import counters
+from torch._inductor import ir
+from torch._inductor.autotune_process import (
+    SubgraphCPUBenchmarkRequest,
+    SubgraphGPUBenchmarkRequest,
+    TensorMeta,
+)
+from torch._inductor.codegen.common import KernelTemplate
+from torch._inductor.ir import (
+    Buffer,
+    FixedLayout,
+    get_free_symbols,
+    get_symbolic_inputs,
+    gm_original_output_strides,
+    ir_node_to_tensor,
+    Layout,
+)
+from torch._inductor.runtime.benchmarking import benchmarker
+from torch._inductor.utils import do_bench_using_profiling
+from torch._inductor.virtualized import V
+from torch.utils._ordered_set import OrderedSet
+
+
+log = logging.getLogger(__name__)
+
+
+def inline_subgraph_to_ir_nodes(
+    gm: torch.fx.GraphModule, inputs: list[Any], name: str
+) -> Any:
+    """Inline a subgraph by converting its FX operations to individual IR nodes.
+
+    This converts a subgraph to multiple ComputedBuffer nodes (fusable),
+    enabling epilogue fusion with subsequent operations.
+
+    Returns:
+        TensorBox containing the final operation result as individual IR nodes
+    """
+    from torch._inductor.lowering import process_subgraph_nodes
+
+    # Temporarily switch V.graph.module to subgraph during processing; restore to prevent IR nodes added to wrong graph
+    original_module = V.graph.module
+    try:
+        V.graph.module = gm
+        return process_subgraph_nodes(gm, inputs)
+    finally:
+        V.graph.module = original_module
+
+
+class SubgraphChoiceCaller(ir.ChoiceCaller):
+    """
+    Represents a Subgraph Autotuning choice, and the subgraph can be any arbitrary
+    GraphModule. Compiles the Subgraph down to a module for benchmarking.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        input_nodes: list[Buffer],
+        layout: Layout,
+        description: str,
+        make_fx_graph: Callable[..., Any],
+        input_gen_fns: dict[int, Callable[[Any], torch.Tensor]] | None = None,
+    ) -> None:
+        super().__init__(name, input_nodes, layout, description)
+
+        # Create inputs for tracing and benchmarking:
+        # - trace_inputs: Always use symbolic inputs for tracing so the graph works
+        #   for any size at runtime. This correctly captures shape-dependent operations
+        #   like x * x.shape[0].
+        # - benchmark_inputs: Use input_gen_fns if provided (for range-specific benchmarks)
+        #   or concrete inputs from ir_node_to_tensor with guard_shape=False.
+        trace_inputs = []
+        self.benchmark_inputs = []
+        with V.fake_mode:
+            for i, inp in enumerate(self.input_nodes):
+                # Here there will be no unbacked symbols, as SubgraphBuffer does not support them
+                if len(get_free_symbols(inp.get_size(), unbacked_only=True)) != 0:
+                    raise AssertionError("expected no unbacked symbols in input size")
+                if len(get_free_symbols(inp.get_stride(), unbacked_only=True)) != 0:
+                    raise AssertionError("expected no unbacked symbols in input stride")
+
+                inp.data.freeze_layout()  # type: ignore[attr-defined]
+
+                # Always use symbolic inputs for tracing
+                trace_inputs.append(ir_node_to_tensor(inp))
+
+                # Use input_gen_fn for benchmarking if provided, otherwise concrete sizes
+                if input_gen_fns is not None and i in input_gen_fns:
+                    self.benchmark_inputs.append(input_gen_fns[i](inp))
+                else:
+                    self.benchmark_inputs.append(
+                        ir_node_to_tensor(inp, replace_symbols_with_hints=True)
+                    )
+
+        # Trace with symbolic inputs for guard detection
+        self.gm = make_fx_graph(*trace_inputs)
+        gm_original_output_strides(self.gm)
+        # Store symbolic inputs for sym_input computation
+        self.example_inputs = trace_inputs
+
+        self.sym_inputs = get_symbolic_inputs(self.input_nodes)
+        self.sym_input_values = self._compute_sym_input_values()
+
+        # Cached decomposition info for range-based dispatch (set via cache_decomposition)
+        self.decomposition: Callable[..., Any] | None = None
+        self.decomposition_kwargs: dict[str, Any] = {}
+        # Config patches to apply during kernel codegen (e.g., coordinate_descent_tuning)
+        self.config_patches: dict[str, Any] = {}
+        # Cache compiled module to avoid recompiling on every benchmark call
+        self._compiled_module: Any = None
+        # Cache benchmark request for async autotuning
+        self._bmreq: (
+            SubgraphGPUBenchmarkRequest | SubgraphCPUBenchmarkRequest | None
+        ) = None
+
+        # Pre-compile only if using async pipelined autotuning
+        # Must happen in __init__ because compilation requires virtualized context (V.graph, V.debug)
+        if config.pipeline_max_autotune_gemm:
+            with V.fake_mode:
+                self._compiled_module = self._compile_for_benchmarking()
+                self._bmreq = self._create_benchmark_request()
+
+    def _compute_sym_input_values(self) -> list[int]:
+        """Extract concrete dimension values for sym_inputs from benchmark_inputs.
+
+        The compiled module expects symbolic dimension values as runtime arguments.
+        This maps each symbolic variable to its concrete value from the benchmark tensors.
+        Used for range based autotuning.
+        """
+        sym_input_names = OrderedSet(
+            [s.name for s in self.sym_inputs if hasattr(s, "name")]
+        )
+
+        # Build mapping: symbolic dimension name -> concrete value
+        sym_name_to_value: dict[str, int] = {}
+        for inp_node, benchmark_inp in zip(self.input_nodes, self.benchmark_inputs):
+            if isinstance(benchmark_inp, torch.Tensor):
+                for sym_dim, actual_dim in zip(
+                    inp_node.get_size(), benchmark_inp.shape
+                ):
+                    if isinstance(sym_dim, sympy.Symbol):
+                        sym_name_to_value[sym_dim.name] = int(actual_dim)
+                    elif str(sym_dim) in sym_input_names:
+                        sym_name_to_value[str(sym_dim)] = int(actual_dim)
+
+        result = []
+        for sym_var in self.sym_inputs:
+            if isinstance(sym_var, sympy.Symbol) and sym_var.name in sym_name_to_value:
+                result.append(sym_name_to_value[sym_var.name])
+            else:
+                hint = V.graph.sizevars.shape_env.optimization_hint(sym_var, fallback=1)
+                result.append(int(hint))
+        return result
+
+    def cache_decomposition(
+        self, decomposition: Callable[..., Any], kwargs: dict[str, Any]
+    ) -> None:
+        """Cache decomposition function and kwargs for range-based dispatch lookup."""
+        self.decomposition = decomposition
+        self.decomposition_kwargs = kwargs
+
+    def __str__(self) -> str:
+        return f"SubgraphCaller({self.name})"
+
+    def _compile_for_benchmarking(self) -> Any:
+        """Compile the subgraph for benchmarking, returns the compiled module."""
+        from torch._inductor.graph import GraphLowering
+
+        safe_name = self.name.replace("::", "_").replace(".", "_")
+
+        # Symbolic inputs produce code with symbolic sizes resolved at runtime
+        # via sym_input_values. Without symbols (static shapes), compile with
+        # benchmark_inputs whose sizes match the actual benchmark tensors.
+        compile_inputs = (
+            self.example_inputs if self.sym_inputs else self.benchmark_inputs
+        )
+        log.debug("Benchmark compile %s: sym_inputs=%s", self.name, self.sym_inputs)
+
+        if self.gm is None:
+            raise AssertionError("expected self.gm to be set")
+        bm_graph_lowering = GraphLowering(
+            gm=self.gm,
+            example_inputs=compile_inputs,
+            shape_env=V.graph._shape_env,
+            cpp_wrapper=V.graph.cpp_wrapper,
+            aot_mode=V.graph.aot_mode,
+            extern_node_serializer=V.graph.extern_node_serializer,
+            is_inference=V.graph.is_inference,
+            is_backward=V.graph.is_backward,
+            name=f"benchmark_{safe_name}",
+        )
+
+        for sym_inp in self.sym_inputs:
+            bm_graph_lowering.graph_inputs[sym_inp.name] = sym_inp
+            bm_graph_lowering.graph_input_names.append(sym_inp.name)
+
+        with V.set_graph_handler(bm_graph_lowering):
+            # Apply config_patches during benchmarking (e.g., coordinate_descent_tuning)
+            # Also disable max_autotune to avoid nested autotuning
+            benchmark_config: dict[str, Any] = {
+                "max_autotune": False,
+                "max_autotune_gemm": False,
+                "max_autotune_gemm_backends": "ATEN",
+                "benchmark_fusion": False,
+                "pipeline_max_autotune_gemm": False,
+                **self.config_patches,
+            }
+            with config.patch(benchmark_config):
+                bm_graph_lowering.run(*compile_inputs)
+                return bm_graph_lowering.compile_to_module()
+
+    def _create_benchmark_request(
+        self,
+    ) -> SubgraphGPUBenchmarkRequest | SubgraphCPUBenchmarkRequest:
+        """Create a benchmark request for async autotuning."""
+        if self._compiled_module is None:
+            raise AssertionError(
+                "Module must be compiled before creating benchmark request"
+            )
+        input_tensor_meta = TensorMeta.from_irnodes(self.input_nodes)
+        output_tensor_meta = TensorMeta.from_irnodes(self.layout)
+
+        if self.layout.device.type == "cpu":
+            bmreq_cls = SubgraphCPUBenchmarkRequest
+        else:
+            bmreq_cls = SubgraphGPUBenchmarkRequest
+
+        return bmreq_cls(
+            kernel_name=self.name,
+            input_tensor_meta=input_tensor_meta,
+            output_tensor_meta=output_tensor_meta,
+            extra_args=tuple(),
+            module_path=self._compiled_module.__file__,
+            module_cache_key=self._compiled_module.key,
+            sym_input_values=self.sym_input_values,
+        )
+
+    @property
+    def bmreq(
+        self,
+    ) -> SubgraphGPUBenchmarkRequest | SubgraphCPUBenchmarkRequest:
+        """Benchmark request for async autotuning. Pre-compiled when pipeline_max_autotune_gemm is enabled."""
+        if self._bmreq is None:
+            raise AssertionError(
+                "bmreq accessed but pipeline_max_autotune_gemm was not enabled during __init__"
+            )
+        return self._bmreq
+
+    def _ensure_compiled(self) -> None:
+        """Ensure the module is compiled. Used for lazy compilation in non-async path."""
+        if self._compiled_module is None:
+            self._compiled_module = self._compile_for_benchmarking()
+
+    def benchmark(self, *args: list[Any], out: torch.Tensor) -> float:
+        """Regular benchmarking: compile if needed, then use benchmarker."""
+        self._ensure_compiled()
+        bm_func = self._compiled_module.call
+        sym_inputs = self.sym_input_values
+
+        def fn() -> Any:
+            return bm_func([*sym_inputs, *args])
+
+        if self._benchmark_with_cudagraphs:
+            return benchmarker.benchmark_gpu_with_cuda_graph(fn)
+
+        if config.profile_bandwidth_with_do_bench_using_profiling:
+            return do_bench_using_profiling(fn)
+        return benchmarker.benchmark(
+            fn,
+            device=benchmarker.infer_device(*sym_inputs, *args),
+        )
+
+    def benchmark_collective(self, *args: list[Any], out: torch.Tensor) -> None:
+        """Run once for collective benchmarking (barrier sync handled by caller)."""
+        self._ensure_compiled()
+        self._compiled_module.call([*self.sym_input_values, *args])
+
+    def hash_key(self) -> str:
+        if self.gm is None:
+            raise AssertionError("expected self.gm to be set")
+        return "-".join(
+            [
+                self.name.rsplit("_", 1)[0],
+                *[str(inp.get_size()) for inp in self.input_nodes],
+                *[str(inp.get_stride()) for inp in self.input_nodes],
+                str(self.gm.graph),
+            ]
+        )
+
+    def output_node(self) -> ir.TensorBox:
+        if self.gm is None:
+            raise AssertionError("expected self.gm to be set")
+        return ir.TensorBox.create(
+            ir.SubgraphBuffer(
+                layout=self.layout,
+                input_nodes=self.input_nodes,
+                gm=self.gm,
+                example_inputs=self.example_inputs,
+                subgraph_name=self.name,
+                config_patches=self.config_patches if self.config_patches else None,
+            )
+        )
+
+    def info_dict(self) -> dict[str, Any]:
+        """Information returned here is logged to the autotune log file when that is enabled."""
+        return {
+            "backend": "subgraph",
+            "kernel_name": self.name,
+        }
+
+    def autoheuristic_id(self) -> str:
+        return f"subgraph_{self.name}"
+
+
+class SubgraphTemplate(KernelTemplate):
+    """
+    A template for subgraph evaluation to be used in autotuning.
+
+    This class allows creating customized subgraphs that can be appended
+    as choices during the autotuning process, enabling the selection of
+    optimal implementations for complex operations.
+    """
+
+    index_counter = itertools.count()
+
+    def __init__(
+        self,
+        name: str,
+    ):
+        """
+        Initialize a subgraph template.
+
+        Args:
+            name: The name of this template
+            graph: The FX graph
+        """
+        super().__init__(name=name)
+
+    def generate(  # type: ignore[override]
+        self,
+        name: str,
+        input_nodes: list[Buffer],
+        layout: Layout,
+        make_fx_graph: Callable[..., Any],
+        description: str = "",
+        input_gen_fns: dict[int, Callable[[Any], torch.Tensor]] | None = None,
+        **kwargs: Any,
+    ) -> SubgraphChoiceCaller:
+        """
+        Generate a SubgraphChoiceCaller instance for autotuning.
+
+        Args:
+            name: The name for this subgraph choice
+            input_nodes: List of input nodes to the subgraph
+            layout: Memory layout information for the output
+            make_fx_graph: Callable that creates the FX graph for this subgraph
+            description: Optional description of this choice
+            input_gen_fns: Optional dict mapping input indices to tensor generators
+            **kwargs: Additional keyword arguments
+
+        Returns:
+            SubgraphChoiceCaller: A callable object that can be used for autotuning
+        """
+
+        return SubgraphChoiceCaller(
+            name=f"{name}_{next(SubgraphTemplate.index_counter)}",
+            input_nodes=input_nodes,
+            layout=layout,
+            description=description,
+            make_fx_graph=make_fx_graph,
+            input_gen_fns=input_gen_fns,
+        )
+
+    def generate_custom_op_choices(
+        self,
+        name: str,
+        decompositions: list[Callable[..., Any]],
+        input_nodes: list[Buffer],
+        non_tensor_args: list[dict[str, Any]],
+        default_impl: Callable[..., Any] | None = None,
+        input_gen_fns: dict[int, Callable[[Any], torch.Tensor]] | None = None,
+        config_patches_list: list[dict[str, Any]] | None = None,
+    ) -> list[SubgraphChoiceCaller]:
+        """
+        Generate multiple SubgraphChoiceCaller instances for custom op autotuning.
+
+        This method extends SubgraphTemplate to support custom op decompositions,
+        allowing multiple implementations to compete in autotuning.
+
+        Args:
+            name: Base name for the choices
+            decompositions: List of decomposition functions to compete in autotuning
+            input_nodes: List of tensor inputs. All tensor arguments must be passed here.
+            non_tensor_args: List of non-tensor kwargs only, one dict per corresponding decomposition.
+            default_impl: Default implementation for layout inference
+            input_gen_fns: Optional dict mapping input indices to tensor generators
+            config_patches_list: Optional list of config patches per decomposition
+
+        Returns:
+            List of SubgraphChoiceCaller instances for autotuning
+        """
+        if not decompositions:
+            return []
+
+        if len(decompositions) != len(non_tensor_args):
+            raise AssertionError(
+                f"decompositions and non_tensor_args must have same length, "
+                f"got {len(decompositions)} decompositions and {len(non_tensor_args)} kwargs"
+            )
+
+        # Default to empty config_patches if not provided
+        if config_patches_list is None:
+            config_patches_list = [{} for _ in decompositions]
+
+        # Infer layouts and ensure layout consistency for fair autotuning comparison
+        layouts = [
+            self._infer_custom_op_layout(
+                input_nodes, decomp, kwargs, default_impl, input_gen_fns
+            )
+            for decomp, kwargs in zip(decompositions, non_tensor_args)
+        ]
+
+        # Validate all decompositions produce equivalent layouts for fair comparison
+        self._validate_layout_equivalence(name, decompositions, layouts)
+        layout = layouts[0]  # All layouts are now validated to be equivalent
+
+        choices: list[SubgraphChoiceCaller] = []
+        for decomp, decomp_kwargs, config_patches in zip(
+            decompositions, non_tensor_args, config_patches_list
+        ):
+            # Create make_fx_graph function for this decomposition
+            # Uses error_on_new_guards to detect impls that add guards
+            from torch.fx.experimental.symbolic_shapes import _ShapeEnvGuardError
+
+            def make_fx_graph(
+                *args: Any,
+                decomp: Callable[..., Any] = decomp,
+                decomp_kwargs: dict[str, Any] = decomp_kwargs,
+            ) -> Any:
+                # decomp_kwargs contains all merged parameters: CustomOpConfig params + runtime kwargs
+
+                from torch.fx.experimental.proxy_tensor import make_fx
+
+                from ..decomposition import select_decomp_table
+
+                decomposition_table = select_decomp_table()
+                shape_env = V.fake_mode.shape_env
+
+                # Use error_on_new_guards to detect impls that add guards during tracing
+                guard_ctx = (
+                    shape_env.error_on_new_guards()
+                    if shape_env is not None
+                    else contextlib.nullcontext()
+                )
+                with guard_ctx:
+                    return make_fx(
+                        functools.partial(decomp, **decomp_kwargs),
+                        decomposition_table=decomposition_table,
+                        tracing_mode="symbolic",
+                    )(*args)
+
+            # Generate descriptive name for this variant
+            variant_name = self._generate_variant_name(decomp, decomp_kwargs)
+
+            # Try to create choice; skip if it adds guards
+            try:
+                choice = self.generate(
+                    name=f"{name}_{variant_name}",
+                    input_nodes=input_nodes,
+                    layout=layout,
+                    make_fx_graph=make_fx_graph,
+                    description=f"CustomOp {decomp.__name__}",
+                    input_gen_fns=input_gen_fns,
+                )
+            except _ShapeEnvGuardError:
+                log.info(
+                    "Skipping decomposition %s: adds guards during tracing",
+                    decomp.__name__,
+                )
+                counters["inductor"]["custom_op_decomp_guard_skips"] += 1
+                continue
+
+            # Cache decomposition info for range-based dispatch
+            choice.cache_decomposition(decomp, decomp_kwargs)
+            # Store config_patches for this choice
+            choice.config_patches = config_patches
+            choices.append(choice)
+
+        return choices
+
+    def _generate_variant_name(
+        self, decomp: Callable[..., Any], kwargs: dict[str, Any]
+    ) -> str:
+        """Generate a descriptive name for a decomposition variant with its parameters."""
+        import re
+
+        base_name = decomp.__name__
+        if not kwargs:
+            return base_name
+
+        def sanitize_value(v: Any) -> str:
+            """Convert a value to a valid Python identifier component."""
+            s = str(v)
+            # Replace invalid characters with underscores
+            s = re.sub(r"[^a-zA-Z0-9_]", "_", s)
+            # Ensure it doesn't start with a digit
+            if s and s[0].isdigit():
+                s = "_" + s
+            return s
+
+        param_suffix = "_".join(
+            f"{k}_{sanitize_value(v)}" for k, v in sorted(kwargs.items())
+        )
+        return f"{base_name}_{param_suffix}"
+
+    def _validate_non_tensor_kwargs(self, kwargs: dict[str, Any]) -> None:
+        """Validate that kwargs contains only non-tensor arguments."""
+        for key, value in kwargs.items():
+            if isinstance(value, (torch.Tensor, Buffer)):
+                raise AssertionError(
+                    f"kwargs['{key}'] contains tensor {type(value)}. "
+                    f"Tensor arguments should be in input_nodes, not kwargs. "
+                    f"Only scalar/non-tensor parameters should be in kwargs."
+                )
+
+    def _validate_layout_equivalence(
+        self,
+        op_name: str,
+        decompositions: list[Callable[..., Any]],
+        layouts: list[Layout],
+    ) -> None:
+        """Ensure all layouts have consistent stride, device, dtype, and sizes for fair autotuning."""
+        if not layouts:
+            return
+
+        reference = layouts[0]
+        for i, layout in enumerate(layouts[1:], start=1):
+            if (layout.device, layout.dtype, layout.size, layout.stride) != (
+                reference.device,
+                reference.dtype,
+                reference.size,
+                reference.stride,
+            ):
+                raise AssertionError(
+                    f"Layout mismatch in custom op '{op_name}': "
+                    f"decomposition '{decompositions[i].__name__}' produces "
+                    f"({layout.device}, {layout.dtype}, {layout.size}, {layout.stride}) "
+                    f"but '{decompositions[0].__name__}' produces "
+                    f"({reference.device}, {reference.dtype}, {reference.size}, {reference.stride})"
+                )
+
+    def _infer_custom_op_layout(
+        self,
+        input_nodes: list[Buffer],
+        function_decomposition: Callable[..., Any],
+        kwargs: dict[str, Any],
+        default_impl: Callable[..., Any] | None = None,
+        input_gen_fns: dict[int, Callable[[Any], torch.Tensor]] | None = None,
+    ) -> Layout:
+        """Infer output layout for custom ops using the default implementation when available.
+        Note that the Subgraph assumes custom ops return exactly one tensor output.
+        TODO: Add support for multiple output custom ops.
+        """
+        import functools
+
+        from torch._inductor.virtualized import V
+
+        # Assert kwargs contain only non-tensor arguments
+        self._validate_non_tensor_kwargs(kwargs)
+
+        with V.fake_mode:
+            example_inputs = []
+            for i, inp in enumerate(input_nodes):
+                if input_gen_fns and i in input_gen_fns:
+                    fake_tensor = input_gen_fns[i](inp)
+                else:
+                    raw_shape = inp.get_size()
+                    concrete_shape = V.graph.sizevars.optimization_hints(raw_shape)
+                    raw_stride = inp.get_stride()
+                    concrete_stride = V.graph.sizevars.optimization_hints(raw_stride)
+                    fake_tensor = torch.empty_strided(
+                        concrete_shape,
+                        concrete_stride,
+                        dtype=inp.get_dtype(),
+                        device=inp.get_device(),
+                    )
+                example_inputs.append(fake_tensor)
+
+            fn = functools.partial(function_decomposition, **kwargs)
+            output = fn(*example_inputs)
+
+            # Assert single output
+            if not isinstance(output, torch.Tensor):
+                raise AssertionError(
+                    f"Expected single tensor output, got {type(output)}. "
+                    f"Multi-output custom ops not yet supported in autotuning."
+                )
+
+            return FixedLayout(
+                device=output.device,
+                dtype=output.dtype,
+                size=output.shape,
+                stride=output.stride(),
+            )

.venv/lib/python3.12/site-packages/torch/_inductor/codegen/triton_combo_kernel.py

@@ -0,0 +1,2036 @@
+import io
+import itertools
+import logging
+import textwrap
+import tokenize
+from collections import defaultdict
+from collections.abc import Callable
+from dataclasses import dataclass
+from functools import cache
+from typing import Any, cast, TYPE_CHECKING
+
+import sympy
+from sympy import Integer, Symbol
+
+import torch
+from torch.utils._ordered_set import OrderedSet
+
+
+if TYPE_CHECKING:
+    import triton
+
+from .. import config, metrics
+from ..runtime.hints import DeviceProperties, TritonMeta
+from ..runtime.runtime_utils import next_power_of_2
+from ..runtime.triton_heuristics import (
+    RoundRobinComboKernelGrid,
+    SequentialComboKernelGrid,
+    SequentialFlattenComboKernelGrid,
+)
+from ..scheduler import BaseSchedulerNode
+from ..stream_utils import (
+    coor_benchmark_device_idx,
+    coor_device_str,
+    get_raw_stream_name,
+)
+from ..utils import (
+    clear_on_fresh_cache,
+    DeferredLineBase,
+    Placeholder,
+    triton_version_uses_attrs_dict,
+)
+from ..virtualized import V
+from .common import (
+    ArgName,
+    ConstexprArg,
+    IndentedBuffer,
+    InplacedBuffer,
+    Kernel,
+    PythonPrinter,
+    RemovedArg,
+    SizeArg,
+    TensorArg,
+    WorkspaceArg,
+)
+from .simd import NodeInfo, prefix_is_reduction, SIMDScheduling
+from .simd_kernel_features import SIMDKernelFeatures
+from .triton import TritonKernel
+from .triton_utils import (
+    config_of,
+    equal_1_arg_indices,
+    is_unaligned_buffer,
+    signature_to_meta,
+)
+
+
+# Default block sizes used when combo kernel autotuning is disabled.
+DEFAULT_COMBO_BLOCK_SIZE_1D = 1024
+DEFAULT_COMBO_BLOCK_SIZE_2D = 32
+
+
+log = logging.getLogger(__name__)
+pexpr = PythonPrinter().doprint
+LARGE_NUMELS = 51_200_000
+BLOCK_UTILIZATION = 0.8
+
+
+def _size_hint(expr: Any) -> int:
+    return V.graph.sizevars.optimization_hint(expr, fallback=1)
+
+
+def _node_partition_log_context(
+    node: BaseSchedulerNode, node_info_map: dict[BaseSchedulerNode, NodeInfo]
+) -> tuple[Any, ...]:
+    node_info = node_info_map[node]
+    tiling_hints = tuple(
+        (str(dim), _size_hint(numel))
+        for dim, numel in sorted(
+            node_info.tiling.items(), key=lambda item: str(item[0])
+        )
+    )
+    return (
+        bool(node_info.features.is_reduction()),
+        node_info.is_persistent_reduction,
+        tiling_hints,
+        _size_hint(node_info.numel),
+        _size_hint(node_info.rnumel),
+    )
+
+
+def _partition_separation_log_context(
+    separated_nodes: list[BaseSchedulerNode],
+    companion_nodes: list[BaseSchedulerNode],
+    node_info_map: dict[BaseSchedulerNode, NodeInfo],
+) -> tuple[tuple[Any, ...], tuple[Any, ...]]:
+    return (
+        tuple(_node_partition_log_context(n, node_info_map) for n in separated_nodes),
+        tuple(_node_partition_log_context(n, node_info_map) for n in companion_nodes),
+    )
+
+
+def _log_partition_separation(
+    log_message: str,
+    separated_nodes: list[BaseSchedulerNode],
+    companion_nodes: list[BaseSchedulerNode],
+    node_info_map: dict[BaseSchedulerNode, NodeInfo],
+) -> None:
+    if log.isEnabledFor(logging.DEBUG):
+        _log_partition_separation_once(
+            log_message,
+            len(separated_nodes),
+            _partition_separation_log_context(
+                separated_nodes, companion_nodes, node_info_map
+            ),
+        )
+
+
+# This diagnostic is otherwise repeated once per equivalent recompile.
+@clear_on_fresh_cache
+@cache
+def _log_partition_separation_once(
+    log_message: str,
+    num_nodes: int,
+    partition_context: tuple[tuple[Any, ...], tuple[Any, ...]],
+) -> None:
+    log.debug(
+        log_message,
+        num_nodes,
+    )
+
+
+def _default_custom_combo_kernel_horizontal_partition(
+    nodes: list[BaseSchedulerNode],
+    triton_scheduling: SIMDScheduling,
+    node_info_map: dict[BaseSchedulerNode, NodeInfo],
+) -> list[list[BaseSchedulerNode]]:
+    """Horizontally partition the given list of nodes into a list of list of nodes where each sublist
+    represents a partition. Nodes in different partitions are implemented in different combo kernels.
+    Nodes in the same partition are likely to be implemented
+    in the same combo kernel, but subject to subsequent restrictions like CUDA limits for number of args.
+
+    Input arguments:
+        nodes: a list of fused scheduler nodes to partition.
+        triton_scheduling: TritonScheduling instance.
+        node_info_map: a map from node to NodeInfo NamedTuple
+    Output:
+        a list of list of nodes with each sublist representing a partition.
+
+    The default algorithm is to partition nodes based on the following rules:
+        1) nodes with the same number of block dimensions are grouped together.
+        2) large pointwise nodes (numels greater than LARGE_NUMELS) are separated from other nodes.
+        3) large reduce nodes are separated from other nodes.
+    """
+
+    if len(nodes) < 1:
+        raise AssertionError(f"expected at least 1 node, got {len(nodes)}")
+
+    # first partition nodes based on number of block dimensions
+    tilings = [node_info_map[n].tiling for n in nodes]
+
+    max_dims = max(len(t) for t in tilings)
+    nodes_per_ndim: list[list[BaseSchedulerNode]] = []
+    for i in range(2, max_dims + 1):
+        group_per_dim = [n for n, t in zip(nodes, tilings) if len(t) == i]
+        reduction = [
+            n for n in group_per_dim if node_info_map[n].features.is_reduction()
+        ]
+        not_reduction = [n for n in group_per_dim if n not in reduction]
+        # rnumel > 2048 usually has long execution time
+        # BaseSchedulerNode.group[-1][-1] is rnumel for reduction nodes
+        # Scheduling heuristic: separate long reductions (rnumel > 2048).
+        # Uses optimization_hint with fallback=1 so unbacked defaults to short reduction.
+        long_reduction = [
+            n
+            for n in reduction
+            if V.graph.sizevars.optimization_hint(n.group[-1][-1], fallback=1) > 2048  # type: ignore[arg-type]
+        ]
+        short_reduction = [n for n in reduction if n not in long_reduction]
+        very_large_reduction = [
+            n
+            for n in long_reduction
+            if (
+                V.graph.sizevars.optimization_hint(node_info_map[n].numel, fallback=1)
+                * V.graph.sizevars.optimization_hint(
+                    node_info_map[n].rnumel, fallback=1
+                )
+            )
+            > LARGE_NUMELS
+        ]
+        long_reduction = [n for n in long_reduction if n not in very_large_reduction]
+        if long_reduction:
+            _log_partition_separation(
+                "ComboKernels: %d long reduction nodes are separated",
+                long_reduction,
+                not_reduction + short_reduction,
+                node_info_map,
+            )
+        if very_large_reduction:
+            log.debug(
+                "ComboKernels: %d very large reduction nodes are separated",
+                len(very_large_reduction),
+            )
+            nodes_per_ndim.extend([node] for node in very_large_reduction)
+        large_pointwise = [
+            n
+            for n in not_reduction
+            if not node_info_map[n].features.is_reduction()
+            and len(node_info_map[n].tiling) == 2
+            and V.graph.sizevars.optimization_hint(
+                node_info_map[n].tiling["x"], fallback=1
+            )
+            > LARGE_NUMELS
+        ]
+        if large_pointwise:
+            companion_nodes = [n for n in not_reduction if n not in large_pointwise]
+            # TODO benchmark the performance when large pointwise nodes combining with others
+            # Include the non-large pointwise companions because the diagnostic
+            # describes a partition decision for the current candidate group.
+            _log_partition_separation(
+                "ComboKernels: %d large pointwise nodes are separated",
+                large_pointwise,
+                companion_nodes,
+                node_info_map,
+            )
+            not_reduction = companion_nodes
+            nodes_per_ndim.extend([node] for node in large_pointwise)
+
+        nodes_per_ndim.extend(
+            g for g in (not_reduction, short_reduction, long_reduction) if g
+        )
+
+    if sum(len(p) for p in nodes_per_ndim) != len(nodes):
+        raise AssertionError("partitioned node count must equal input node count")
+    return nodes_per_ndim
+
+
+_custom_combo_kernel_horizontal_partition_algorithm: Callable[
+    [
+        list[BaseSchedulerNode],
+        SIMDScheduling,
+        dict[BaseSchedulerNode, NodeInfo],
+    ],
+    list[list[BaseSchedulerNode]],
+] = _default_custom_combo_kernel_horizontal_partition
+
+
+def set_custom_combo_kernel_horizontal_partition(
+    algorithm: Callable[
+        [
+            list[BaseSchedulerNode],
+            SIMDScheduling,
+            dict[BaseSchedulerNode, NodeInfo],
+        ],
+        list[list[BaseSchedulerNode]],
+    ],
+) -> None:
+    """Sets the algorithm used to partition nodes into horizontal partitions. Nodes in different partitions
+    are implemented in different combo kernels. Nodes in the same partition are likely to be implemented
+    in the same combo kernel, but subject to subsequent restrictions like CUDA limits for number of args.
+
+    The algorithm should take a list of nodes and return a list of list of nodes.
+
+    The default algorithm is to partition nodes based on number of block dimensions.
+    """
+    global _custom_combo_kernel_horizontal_partition_algorithm
+    _custom_combo_kernel_horizontal_partition_algorithm = algorithm
+
+
+@dataclass
+class PartitionState:
+    partitions: list[list[BaseSchedulerNode]]
+    cur_partition: list[BaseSchedulerNode]
+    cur_count: int
+
+    def finalize(self) -> None:
+        if self.cur_partition:
+            self.partitions.append(self.cur_partition)
+
+
+@dataclass
+class SubKernelSetup:
+    uniquify_block_sizes: list[str]
+    lhs_names: list[str]
+
+
+@dataclass
+class SubKernelCode:
+    setup: IndentedBuffer
+    body: IndentedBuffer
+    setup_lhs_names: list[str]
+
+
+@dataclass
+class NoinlineSubKernelCall:
+    params: list[ArgName]
+    call_args: list[str]
+    signature_key: tuple[Any, ...]
+
+
+@dataclass
+class SharedBody:
+    body: IndentedBuffer
+    placeholder_names: list[str]
+    args_by_subkernel: list[list[str]]
+    setup_lhs_names: list[str]
+
+
+@dataclass
+class ComboLaunchConfig:
+    kwargs: dict[str, int]
+    num_warps: int
+    num_stages: int
+
+
+class ComboKernel(Kernel):
+    """
+    A kernel that combines multiple sub-kernels into a single fused kernel.
+    """
+
+    @staticmethod
+    def _update_partition(
+        partition_state: PartitionState,
+        node_rw_count: int,
+        node_info: BaseSchedulerNode,
+    ) -> None:
+        if partition_state.cur_count + node_rw_count > config.combo_kernel_max_num_args:
+            partition_state.partitions.append(partition_state.cur_partition)
+            partition_state.cur_partition = [node_info]
+            partition_state.cur_count = node_rw_count
+        else:
+            partition_state.cur_count += node_rw_count
+            partition_state.cur_partition.append(node_info)
+
+    @staticmethod
+    def _base_horizontal_partition(
+        subkernel_nodes: list[BaseSchedulerNode],
+        triton_scheduling: SIMDScheduling,
+        node_info_map: dict[BaseSchedulerNode, NodeInfo],
+        custom_algorithm: bool,
+    ) -> list[list[BaseSchedulerNode]]:
+        """Generates a list of lists of node info tuples which consist of (fused_nodes, tiling, numel, rnumel)
+        for each subkernel node where each sublist is guaranteed to not exceed CUDA limits for number of args
+        (read/writes) and to have the same 2D or 1D blocking strategy."""
+        # TODO support combination of kernels with different block dimensions
+        if len(subkernel_nodes) < 1:
+            raise AssertionError(
+                f"expected at least 1 subkernel node, got {len(subkernel_nodes)}"
+            )
+        mixed_sizes = config.combo_kernel_allow_mixed_sizes > 1 or (
+            config.combo_kernel_allow_mixed_sizes == 1 and custom_algorithm
+        )
+
+        ndim_to_partition_state: dict[int, PartitionState] = defaultdict(
+            lambda: PartitionState([], [], 0)
+        )
+        yelem_to_partition_state: dict[int, PartitionState] = defaultdict(
+            lambda: PartitionState([], [], 0)
+        )
+        all_partitions = []
+
+        for node in subkernel_nodes:
+            tiled_groups = node_info_map[node].tiling
+            node_info = node
+
+            read_writes = node.read_writes
+            read_write_count = len(read_writes.reads) + len(read_writes.writes)
+
+            ndim = len(tiled_groups)
+            if ndim < 2:
+                raise AssertionError(f"Combokernel not support tile {tiled_groups}")
+
+            # Skip 2d reductions (r0_,r1_) and 3D pointwise (x,y,z) from combo
+            keys = tiled_groups.keys()
+            if ("r0_" in keys and "r1_" in keys) or "z" in keys:
+                all_partitions.append([node_info])
+                continue
+
+            if not mixed_sizes and ndim == 3:
+                y_elem = tiled_groups["y"]
+                partition_state = yelem_to_partition_state[y_elem]
+                ComboKernel._update_partition(
+                    partition_state, read_write_count, node_info
+                )
+            else:
+                if not (mixed_sizes or ndim <= 3):
+                    raise AssertionError(f"No mixed sizes: tile {tiled_groups}")
+                partition_state = ndim_to_partition_state[ndim]
+                ComboKernel._update_partition(
+                    partition_state, read_write_count, node_info
+                )
+
+        for partition_state in ndim_to_partition_state.values():
+            partition_state.finalize()
+            all_partitions.extend(partition_state.partitions)
+        for partition_state in yelem_to_partition_state.values():
+            partition_state.finalize()
+            all_partitions.extend(partition_state.partitions)
+        return all_partitions
+
+    @staticmethod
+    def horizontal_partition(
+        nodes: list[BaseSchedulerNode],
+        triton_scheduling: SIMDScheduling,
+        node_info_map: dict[BaseSchedulerNode, NodeInfo],
+        custom_algorithm: bool = False,
+    ) -> list[list[BaseSchedulerNode]]:
+        """Generates a list of lists of node info tuples which consist of (fused_nodes, tiling, numel, rnum)
+        for each subkernel node where each sublist forms a ComboKernel. It horizontally partitions nodes into
+        sublists in the following way:
+            1) call _custom_combo_kernel_horizontal_partition_algorithm() if custom_algorithm is True
+            2) then, call _base_horizontal_partition() to partition nodes into sublists, each sublist is
+               guaranteed to not exceed CUDA limits for number of args (read/writes) and to have the same
+               2D or 1D blocking strategy.
+        """
+        if custom_algorithm:
+            raw_partitions = _custom_combo_kernel_horizontal_partition_algorithm(
+                nodes, triton_scheduling, node_info_map
+            )
+        else:
+            raw_partitions = [nodes]
+
+        """Generates a list of lists of node info tuples which consist of (fused_nodes, tiling, numel, rnumel)
+        for each subkernel node where each sublist is guaranteed to not exceed CUDA limits for number of args
+        (read/writes) and to have the same 2D or 1D blocking strategy."""
+        all_partitions = []
+        for raw_partition in raw_partitions:
+            all_partitions.extend(
+                ComboKernel._base_horizontal_partition(
+                    raw_partition, triton_scheduling, node_info_map, custom_algorithm
+                )
+            )
+        return all_partitions
+
+    class SequentialDispatch:
+        """
+        The dispatcher which dispatches the subkernels in a sequential manner:
+        the blocks are first dispatched to the 1st subkernel (until it is filled),
+        then to the 2nd subkernel, and so on.
+        The class defines the methods specific to the dispatch algorithm.
+        Methods:
+            codegen_pid_range(...): codegen the pid range for each subkernel.
+            grid(...): codegen the grid size for launching the combo kernel.
+        """
+
+        grid_expr = SequentialComboKernelGrid
+
+        @classmethod
+        def codegen_pid_range(
+            cls, kernel: "ComboKernel", num: int, code: IndentedBuffer
+        ) -> None:
+            if num == 0:
+                cls._calculate_xblocks(kernel, code)
+                code.splice(f"if pid < num_xblocks_{num}:")
+                with code.indent():
+                    code.splice("pid_offset = pid")
+            else:
+                code.splice(f"elif pid < num_xblocks_{num}:")
+                with code.indent():
+                    code.splice(f"pid_offset = pid - num_xblocks_{num - 1}")
+
+        @classmethod
+        def _calculate_xblocks(
+            cls, kernel: "ComboKernel", code: IndentedBuffer
+        ) -> None:
+            x_numels_list = kernel.x_numels_list
+            for i in range(len(x_numels_list)):
+                xnumels, no_x_dim = (
+                    (x_numels_list[i], False)
+                    if isinstance(x_numels_list[i], str)
+                    and cast(str, x_numels_list[i])[0] != "-"
+                    or (
+                        isinstance(x_numels_list[i], int)
+                        and cast(int, x_numels_list[i]) > 0
+                    )
+                    else (kernel.min_x_blocks_list[i], True)
+                )
+                xblock_str = (
+                    f"tl.cdiv({xnumels}, XBLOCK)" if not no_x_dim else f"{xnumels}"
+                )
+                if i == 0:
+                    code.splice(f"num_xblocks_{i} = {xblock_str}")
+                else:
+                    code.splice(f"num_xblocks_{i} = num_xblocks_{i - 1} + {xblock_str}")
+
+    class SequentialFlattenGridDispatch:
+        """
+        Flattened grid dispatch for per-subkernel blocks.
+        Uses flattened grid (sum of x*y blocks, 1, 1) and computes
+        x_pid_offset, y_pid_offset from the flattened pid.
+        """
+
+        grid_expr = SequentialFlattenComboKernelGrid
+
+        @classmethod
+        def codegen_pid_range(
+            cls, kernel: "ComboKernel", num: int, code: IndentedBuffer
+        ) -> None:
+            if num == 0:
+                cls._calculate_total_blocks(kernel, code)
+                code.splice(f"if pid < num_blocks_{num}:")
+            else:
+                code.splice(f"elif pid < num_blocks_{num}:")
+
+            with code.indent():
+                # Compute local pid within this subkernel's block range
+                if num == 0:
+                    code.splice("local_pid = pid")
+                else:
+                    code.splice(f"local_pid = pid - num_blocks_{num - 1}")
+
+                # Compute x/y indices from flattened local_pid
+                if kernel.y_tree_list[num]:
+                    code.splice(f"x_pid_offset = local_pid % x_blocks_{num}")
+                    code.splice(f"y_pid_offset = local_pid // x_blocks_{num}")
+                else:
+                    code.splice("x_pid_offset = local_pid")
+
+        @classmethod
+        def _calculate_total_blocks(
+            cls, kernel: "ComboKernel", code: IndentedBuffer
+        ) -> None:
+            """
+            Calculate total blocks for each subkernel (x_blocks * y_blocks)
+            and cumulative block counts for dispatch boundaries.
+            """
+            for i, sub_kernel in enumerate(kernel.sub_kernels):
+                no_x_dim = sub_kernel.no_x_dim
+                xnumel = (
+                    kernel.min_x_blocks_list[i] if no_x_dim else kernel.x_numels_list[i]
+                )
+                x_blocks_str = (
+                    f"tl.cdiv({xnumel}, XBLOCK_{i})" if not no_x_dim else f"{xnumel}"
+                )
+                code.splice(f"x_blocks_{i} = {x_blocks_str}")
+
+                if kernel.y_tree_list[i]:
+                    numel = V.graph.sizevars.simplify(kernel.y_tree_list[i].numel)
+                    ynumel = (
+                        int(numel)
+                        if isinstance(numel, (Integer, int))
+                        else f"ynumel_{i}"
+                    )
+                    code.splice(f"y_blocks_{i} = tl.cdiv({ynumel}, YBLOCK_{i})")
+
+                blocks_expr = (
+                    f"x_blocks_{i} * y_blocks_{i}"
+                    if kernel.y_tree_list[i]
+                    else f"x_blocks_{i}"
+                )
+                code.splice(
+                    f"num_blocks_{i} = {blocks_expr}"
+                    if i == 0
+                    else f"num_blocks_{i} = num_blocks_{i - 1} + {blocks_expr}"
+                )
+
+    class RoundRobinDispatch:
+        """
+        The dispatcher which dispatches the subkernels in a round robin manner:
+        the blocks are interleavedly dispatched to each subkernel to execute them
+        in parallel.
+        The class defines the methods specific to the dispatch algorithm.
+        Methods:
+            codegen_pid_range(...): codegen the pid range for each subkernel.
+            grid(...): codegen the grid size for launching the combo kernel.
+        """
+
+        grid_expr = RoundRobinComboKernelGrid
+
+        @classmethod
+        def codegen_pid_range(
+            cls, kernel: "ComboKernel", num: int, code: IndentedBuffer
+        ) -> None:
+            num_kernels = len(kernel.sub_kernels)
+            if num == 0:
+                cond = "if"
+            else:
+                cond = "elif"
+            code.splice(f"{cond} pid % {num_kernels} == {num}:")
+            with code.indent():
+                code.splice(f"pid_offset = pid // {num_kernels}")
+
+    def __init__(
+        self,
+        triton_kernel_cls: type[TritonKernel],
+        enable_autotune: bool = False,
+        mixed_sizes: bool = False,
+        per_subkernel_blocks: bool = False,
+    ) -> None:
+        super().__init__()
+        self.triton_kernel_cls = triton_kernel_cls
+        self.sub_kernels: list[TritonKernel] = []
+        self.iter_vars_count = itertools.count()
+        self.grids: list[list[int]] = []
+        self.min_x_blocks_list: list[int | str] = []
+        self.x_numels_list: list[int | str] = []
+        self.y_tree_list: list = []
+        self.enable_autotune = enable_autotune
+        self.mixed_sizes = mixed_sizes
+        self.per_subkernel_blocks = per_subkernel_blocks
+        self.dispatch_class: (
+            type[
+                ComboKernel.SequentialDispatch
+                | ComboKernel.SequentialFlattenGridDispatch
+                | ComboKernel.RoundRobinDispatch
+            ]
+            | None
+        ) = None
+        self.block_args: list[str] = []
+        # the following are used when autotuning is disabled
+        self.block_size_1d = DEFAULT_COMBO_BLOCK_SIZE_1D
+        self.block_size_2d = DEFAULT_COMBO_BLOCK_SIZE_2D
+        self.num_warps = 8
+        self.block_size_reduce = 256
+        self.dynamic_shape_args: list[str] = []
+        self.no_bench_stitched_config: triton.Config | None = None
+        self.combo_compile_time_autotune = False
+        # Compile-time autotune: per-subkernel winning block sizes (XBLOCK_0, ...), passed as args.
+        self.stitched_block_config: dict[str, int] | None = None
+        # Distinct winner launch configs across the subkernels; seeds the combo's kernel-level autotune.
+        self.combo_launch_candidates: list[ComboLaunchConfig] = []
+        self.noinline_sub_kernel_calls: list[NoinlineSubKernelCall] = []
+        self.noinline_arg_name_maps: list[dict[str, str]] = []
+
+    @property
+    def bake_blocks(self) -> bool:
+        """Whether autotuning is disabled and default block values are required.
+
+        Legacy combo kernels bake these values into the kernel body. Per-subkernel
+        block combos pass them as constexpr arguments through default_config.
+        """
+        return not self.enable_autotune
+
+    def create_sub_kernel(self, triton_kernel: TritonKernel) -> TritonKernel:
+        sub_kernel = triton_kernel
+        # pyrefly: ignore [bad-assignment]
+        metrics.generated_kernel_count -= 1
+        if not self.per_subkernel_blocks:
+            sub_kernel.args = self.args
+            sub_kernel.iter_vars_count = self.iter_vars_count
+            sub_kernel.cse.iter_buffer_ids = self.cse.iter_buffer_ids
+        self.sub_kernels.append(sub_kernel)
+        return sub_kernel
+
+    @staticmethod
+    def create_triton_kernel(
+        tiling: dict[str, sympy.Expr],
+        features: SIMDKernelFeatures,
+        optimize_mask: bool,
+        triton_kernel_cls: type[TritonKernel],
+        tiling_scores: dict[str, sympy.Expr] | None = None,
+        per_subkernel_blocks: bool = False,
+    ) -> TritonKernel:
+        """
+        Only allow optimize_mask=True when 1) sequential dispatch is used,
+        2) numels except x dimension are the same for each sub kernel.
+        """
+        # Flattened dispatch: all dimensions derived from single pid
+        if per_subkernel_blocks:
+            pid_cache = {
+                "tl.program_id(0)": "x_pid_offset",
+                "tl.program_id(1)": "y_pid_offset",
+            }
+        else:
+            pid_cache = {"tl.program_id(0)": "pid_offset"}
+
+        kwargs: dict[str, Any] = dict(
+            pid_cache=pid_cache,
+            optimize_mask=optimize_mask,
+            is_combo_kernel=True,
+            per_subkernel_blocks=per_subkernel_blocks,
+            # foreach kernels don't work with cooperative reductions
+            override_cooperative_reduction=False,
+            tiling_scores=tiling_scores,
+        )
+        triton_kernel_cls.apply_feature_required_overrides(features, kwargs)
+
+        return triton_kernel_cls(tiling, features=features, **kwargs)
+
+    def codegen_static_numels_sub_kernel(
+        self, code: IndentedBuffer, sub_kernel: TritonKernel, num: int
+    ) -> SubKernelSetup:
+        """
+        We get a small speedup from hard coding numels if they are static.
+
+        This code stomps on the passed-in values by writing an constant to the top of the kernel.
+
+        In a kernel like:
+        def KERNEL_NAME(in_ptr0, in_ptr1, out_ptr2, xnumel, rnumel, XBLOCK : tl.constexpr, R0_BLOCK : tl.constexpr):
+
+        We would add
+        xnumel = 4096
+        rnumel = 768
+
+        After the signature, before the kernel code, if we decided to make these static. As its hardcoded, it becomes
+        a better signal to triton on how to unroll and do some static indexing. So, it's not so much that downstream
+        knows that its a static numel, as that you just plop a constant into the kernel.
+        """
+        grid = []
+        lhs_names: list[str] = []
+        uniquify_block_sizes = []
+        for tree in sub_kernel.range_trees:
+            simplified_tree_numel = V.graph.sizevars.simplify(tree.numel)
+            if isinstance(simplified_tree_numel, (Integer, int)):
+                lhs_name = f"{tree.prefix}numel"
+                code.writeline(f"{lhs_name} = {int(simplified_tree_numel)}")
+                lhs_names.append(lhs_name)
+            else:
+                if f"{tree.prefix}numel_{num}" not in self.dynamic_shape_args:
+                    raise AssertionError(
+                        f"{tree.prefix}numel_{num} not in dynamic_shape_args"
+                    )
+                uniquify_block_sizes.append(f"{tree.prefix}numel")
+
+            if not tree.is_reduction:
+                if isinstance(simplified_tree_numel, (Integer, int)):
+                    grid.append(int(simplified_tree_numel))
+                else:
+                    # pyrefly: ignore [bad-argument-type]
+                    grid.append(f"{tree.prefix}numel_{num}")
+
+            if tree.is_reduction and sub_kernel.persistent_reduction:
+                val = TritonKernel._get_persistent_RBLOCK(tree.numel)
+                suffix = "" if self.per_subkernel_blocks else f"_{num}"
+                lhs_names.append(f"{tree.prefix.upper()}BLOCK{suffix}")
+                code.writeline(
+                    f"{tree.prefix.upper()}BLOCK{suffix}: tl.constexpr = {val}"
+                )
+
+            if tree.prefix == "x" and sub_kernel.no_x_dim:
+                suffix = "" if self.per_subkernel_blocks else f"_{num}"
+                lhs_names.append(f"XBLOCK{suffix}")
+                code.writeline(f"XBLOCK{suffix}: tl.constexpr = 1")
+                uniquify_block_sizes.append("XBLOCK")
+            elif tree.prefix in ("x", "y") and self.per_subkernel_blocks:
+                uniquify_block_sizes.append(f"{tree.prefix.upper()}BLOCK")
+            elif tree.is_reduction:
+                if self.per_subkernel_blocks or sub_kernel.persistent_reduction:
+                    uniquify_block_sizes.append(f"{tree.prefix.upper()}BLOCK")
+        self.grids.append(grid)
+        return SubKernelSetup(
+            uniquify_block_sizes=uniquify_block_sizes,
+            lhs_names=lhs_names,
+        )
+
+    def min_x_blocks_sub_kernel(self, sub_kernel: TritonKernel, num: int) -> None:
+        """
+        Kernels with no_x_dim being true has no tunable XBLOCK. They have a fixed number of X blocks.
+        Grid calculation needs to make sure that they are assigned with enough number of blocks.
+        """
+        min_x_blocks: int | str = 0
+        x_numels: int | str = 0
+        for tree in sub_kernel.range_trees:
+            simplified_tree_numel = V.graph.sizevars.simplify(tree.numel)
+            if tree.prefix == "x":
+                if isinstance(simplified_tree_numel, (Integer, int)):
+                    x_numels = int(simplified_tree_numel)
+                else:
+                    x_numels = f"{tree.prefix}numel_{num}"
+                if sub_kernel.no_x_dim:
+                    min_x_blocks = x_numels
+                    x_numels = (
+                        # pyrefly: ignore [unsupported-operation]
+                        -min_x_blocks
+                        if isinstance(x_numels, int)
+                        # pyrefly: ignore [redundant-cast]
+                        else "-" + cast(str, x_numels)
+                    )
+                else:
+                    if isinstance(simplified_tree_numel, (Integer, int)):
+                        x_numels = int(simplified_tree_numel)
+                    else:
+                        x_numels = f"{tree.prefix}numel_{num}"
+        self.min_x_blocks_list.append(min_x_blocks)
+        self.x_numels_list.append(x_numels)
+
+    def select_heuristics(self, sub_kernel: TritonKernel) -> tuple[str, dict[str, int]]:
+        size_hints = {
+            prefix: next_power_of_2(V.graph.sizevars.optimization_hint(numel))
+            for prefix, numel in sub_kernel.numels.items()
+            if not prefix_is_reduction(prefix) or sub_kernel.inside_reduction
+        }
+        if sub_kernel.persistent_reduction:
+            if not sub_kernel.inside_reduction:
+                raise AssertionError(
+                    "persistent_reduction sub_kernel must be inside_reduction"
+                )
+            heuristics = "persistent_reduction"
+        elif sub_kernel.inside_reduction:
+            heuristics = "reduction"
+        else:
+            heuristics = "pointwise"
+        return heuristics, size_hints
+
+    def select_combo_heuristics(
+        self, heuristics_list: list[str], size_hints_list: list[dict[str, int]]
+    ) -> tuple[str, dict[str, int], TritonKernel]:
+        if not self.enable_autotune and self.no_bench_stitched_config is None:
+            return "foreach", size_hints_list[0], self.sub_kernels[0]
+        if "reduction" in heuristics_list:
+            i, _ = max(
+                enumerate(size_hints_list),
+                key=lambda x: x[1]["x"] if heuristics_list[x[0]] == "reduction" else 0,
+            )
+            return heuristics_list[i], size_hints_list[i], self.sub_kernels[i]
+        elif "pointwise" in heuristics_list:
+            i, _ = max(
+                enumerate(size_hints_list),
+                key=lambda x: x[1]["x"] if heuristics_list[x[0]] == "pointwise" else 0,
+            )
+            # modify size_hint to avoid oom check fail (may be a false alarm)
+            num_pointwise = len([e for e in heuristics_list if e == "pointwise"])
+            num_reduction = len([e for e in heuristics_list if e == "reduction"])
+            num_persistent_reduction = len(
+                [e for e in heuristics_list if e == "persistent_reduction"]
+            )
+            if num_reduction != 0:
+                raise AssertionError(
+                    "combining pointwise and reduction are not supported yet."
+                )
+            heuristics = (
+                "pointwise_with_reduction"
+                if num_persistent_reduction > 0
+                else "pointwise"
+            )
+            if len(heuristics_list) - num_pointwise >= 4:
+                size_hints = size_hints_list[i]
+                size_hints["x"] = min(128, size_hints["x"])
+            return heuristics, size_hints_list[i], self.sub_kernels[i]
+        else:
+            # find persistent_reduction with maximum rnumel
+            i, _ = max(
+                enumerate(size_hints_list),
+                key=lambda x: max(
+                    (v for k, v in x[1].items() if prefix_is_reduction(k))
+                ),
+            )
+            return heuristics_list[i], size_hints_list[i], self.sub_kernels[i]
+
+    def get_mutated_args_sub_kernels(self) -> list[str]:
+        mutated_args: OrderedSet[str] = OrderedSet()
+        for num, sub_kernel in enumerate(self.sub_kernels):
+            arg_name_map = (
+                self.noinline_arg_name_maps[num] if self.per_subkernel_blocks else {}
+            )
+            for mutation in sub_kernel.mutations:
+                if mutation in sub_kernel.args.input_buffers:
+                    name = sub_kernel.args.input_buffers[mutation]
+                    mutated_args.add(arg_name_map.get(name, name))
+                if (
+                    mutation in sub_kernel.args.inplace_buffers
+                    and mutation not in V.graph.removed_buffers
+                    and mutation not in sub_kernel.removed_buffers
+                ):
+                    name = cast(
+                        InplacedBuffer, sub_kernel.args.inplace_buffers[mutation]
+                    ).inner_name
+                    mutated_args.add(arg_name_map.get(name, name))
+                if mutation in sub_kernel.args.output_buffers:
+                    arg = sub_kernel.args.output_buffers[mutation]
+                    if isinstance(arg, RemovedArg):
+                        raise AssertionError("mutated output buffer arg was removed")
+                    mutated_args.add(arg_name_map.get(arg, arg))
+        return sorted(mutated_args)
+
+    def select_dispatch_strategy(self) -> None:
+        if self.dispatch_class is not None:
+            return
+        if self.per_subkernel_blocks:
+            self.dispatch_class = ComboKernel.SequentialFlattenGridDispatch
+            return
+        # mixed_sizes is used for optimize_mask, so it only allows sequential dispatch
+        # Not mixed sizes on y dim technically is ok to use round robin as wells.
+        if not self.mixed_sizes or any(isinstance(e, str) for e in self.x_numels_list):
+            # str in x_numels_list means a dynamic shape
+            self.dispatch_class = ComboKernel.SequentialDispatch
+            return
+        # A negative x_blocks_list element means the kernel is not tunable,
+        # i.e., no_x_dim = True
+        x_numels_list = [abs(cast(int, e)) for e in self.x_numels_list]
+        total = max(x_numels_list) * len(x_numels_list)
+        needed = sum(x_numels_list)
+        if needed / total > BLOCK_UTILIZATION:
+            # Introduced overhead (masked blocks) is less than 20%
+            self.dispatch_class = ComboKernel.RoundRobinDispatch
+        else:
+            self.dispatch_class = ComboKernel.SequentialDispatch
+
+    def jit_line(
+        self,
+        heuristics: str,
+        size_hints: dict[str, int],
+        selected_kernel: TritonKernel,
+        signature: list[Any],
+        argdefs: list[ArgName],
+        size_hints_list: list[dict[str, int]],
+        pointwise_with_reduce: bool = False,
+    ) -> str:
+        """Write the @triton_heuristics.<heuristics> decorator line for the combo kernel."""
+
+        can_use_32bit = all(k.index_dtype == "tl.int32" for k in self.sub_kernels)
+        size_dtype = "tl.int32" if can_use_32bit else "tl.int64"
+        for i, sub in enumerate(self.sub_kernels):
+            self.min_x_blocks_sub_kernel(sub, i)
+        self.select_dispatch_strategy()
+        triton_meta: TritonMeta = cast(
+            TritonMeta,
+            {
+                "signature": signature_to_meta(
+                    signature, size_dtype=size_dtype, argdefs=argdefs
+                ),
+                "device": DeviceProperties.create(
+                    V.graph.get_current_device_or_throw()
+                ),
+                "constants": {},
+                # Inherit enable_fp_fusion, launch_pdl, disable_ftz so combo kernels
+                # compile with the same Triton options as standalone kernels.
+                **TritonKernel.triton_meta_common(),
+            },
+        )
+
+        for arg_num in equal_1_arg_indices(signature):
+            triton_meta["constants"][signature[arg_num].name] = 1  # type: ignore[index,union-attr]
+
+        triton_meta["configs"] = [
+            config_of(signature, skip_cpp_wrapper_input_tensor_alignment=True)
+        ]
+
+        mutated_args = self.get_mutated_args_sub_kernels()
+        dispatch = self.dispatch_class
+        if dispatch is None:
+            raise AssertionError("dispatch_class must not be None")
+
+        # Compute the max persistent R0_BLOCK across sub-kernels.
+        # This is used by _reduction_configs() to avoid generating configs
+        # where XBLOCK * max_persistent_rblock creates pathologically large
+        # tiles that cause extreme ROCm compilation times.
+        # The max_persistent_rblock mirrors how R0_BLOCK is computed in
+        # codegen_static_numels_sub_kernel() for persistent reductions.
+        max_persistent_rblock = 0
+        if not self.per_subkernel_blocks:
+            max_persistent_rblock = max(
+                (
+                    TritonKernel._get_persistent_RBLOCK(tree.numel)
+                    for sub in self.sub_kernels
+                    if sub.persistent_reduction
+                    for tree in sub.range_trees
+                    if tree.is_reduction
+                ),
+                default=0,
+            )
+
+        inductor_meta = {
+            "grid_type": dispatch.grid_expr.__name__,
+            "combo_grid_meta": self.combo_grid_meta(size_hints_list),
+            "kernel_name": str(Placeholder.DESCRIPTIVE_NAME),
+            "mutated_arg_names": mutated_args,
+            # Matches triton.py:codegen_kernel(): inference/backward graphs skip
+            # CPU-copy of mutated args during autotune retries; training-forward
+            # graphs must keep it to preserve benchmark inputs across retries.
+            "optimize_mem": V.graph.is_inference or V.graph.is_backward,
+            **self.triton_kernel_cls.inductor_meta_common(),
+        }
+        if max_persistent_rblock > 0:
+            inductor_meta["max_persistent_rblock"] = max_persistent_rblock
+
+        # Sum per-sub-kernel bandwidth / FLOP estimates for the combo launch.
+        sub_metas = [sub.inductor_meta_per_kernel() for sub in self.sub_kernels]
+        self._kernel_num_gb = sum(m.get("kernel_num_gb") or 0 for m in sub_metas)
+        if config.benchmark_kernel or config.profile_bandwidth:
+            inductor_meta["kernel_num_gb"] = self._kernel_num_gb
+        if config.benchmark_kernel:
+            inductor_meta["kernel_flop"] = sum(
+                m.get("kernel_flop") or 0 for m in sub_metas
+            )
+
+        sub_kernel = selected_kernel
+        if heuristics == "foreach":
+            heuristics_line = f"""
+                @triton_heuristics.foreach(
+                    filename=__file__,
+                    triton_meta={triton_meta!r},
+                    inductor_meta={inductor_meta!r},
+                )
+                @triton.jit
+            """
+        elif sub_kernel.inside_reduction:
+            reduction_hint = sub_kernel.features.get_reduction_hint(
+                sub_kernel.tiling_scores
+            )
+            heuristics_line = f"""
+                @triton_heuristics.{heuristics}(
+                    size_hints={size_hints!r},
+                    reduction_hint={reduction_hint},
+                    filename=__file__,
+                    triton_meta={triton_meta!r},
+                    inductor_meta={inductor_meta!r}
+                )
+                @triton.jit
+            """
+        else:
+            tile_hint = ""
+            if len(size_hints) == 2:
+                tile_hint = "tile_hint=TileHint.SQUARE,"
+            else:
+                tile_hint = "tile_hint=TileHint.DEFAULT,"
+            heuristics_line = f"""
+                @triton_heuristics.{heuristics}(
+                    size_hints={size_hints!r}, {tile_hint}
+                    filename=__file__,
+                    triton_meta={triton_meta!r},
+                    inductor_meta={inductor_meta!r}
+                )
+                @triton.jit
+            """
+
+        self.triton_meta = triton_meta
+        self.inductor_meta = inductor_meta
+
+        return heuristics_line
+
+    def codegen_blocks(self, code: IndentedBuffer) -> None:
+        has_yblock = any(self.y_tree_list)
+        stitched_kwargs = (
+            self.no_bench_stitched_config.kwargs
+            if self.no_bench_stitched_config is not None
+            else None
+        )
+
+        for block in self.block_args:
+            if stitched_kwargs is not None and block in stitched_kwargs:
+                size = stitched_kwargs[block]
+            elif "YBLOCK" in block:
+                size = self.block_size_2d
+            elif "XBLOCK" in block:
+                size = self.block_size_2d if has_yblock else self.block_size_1d
+            elif "R0_BLOCK" in block:
+                size = self.block_size_reduce
+            else:
+                raise AssertionError(f"{block} is not supported without autotuning")
+            code.splice(f"{block}: tl.constexpr = {size}")
+
+    def get_block_args(self) -> list[ConstexprArg]:
+        """
+        Calculate blocks from sub_kernels and range_trees.
+        Update self.block_args, self.y_tree_list
+        Return the block args
+        """
+        block_names = {}
+        for i, sub_kernel in enumerate(self.sub_kernels):
+            y_tree = None
+            for tree in sub_kernel.range_trees:
+                if tree.is_reduction and (
+                    not sub_kernel.inside_reduction or sub_kernel.persistent_reduction
+                ):
+                    continue
+                if tree.prefix == "x" and sub_kernel.no_x_dim:
+                    continue
+                if tree.prefix == "y":
+                    y_tree = tree
+                if self.per_subkernel_blocks:
+                    block_names[f"{tree.prefix.upper()}BLOCK_{i}"] = tree.prefix
+                else:
+                    block_names[f"{tree.prefix.upper()}BLOCK"] = tree.prefix
+            self.y_tree_list.append(y_tree)
+        self.block_args = list(block_names.keys())
+
+        return [ConstexprArg(x) for x in block_names]
+
+    def add_numel_to_args(
+        self, argdefs: list[ArgName], signature: list[Any]
+    ) -> list[ArgName]:
+        for num, sub_kernel in enumerate(self.sub_kernels):
+            for tree in sub_kernel.active_range_trees():
+                if not isinstance(tree.numel, (Integer, int)):
+                    # only if it is a dynamic shape
+                    sizearg = SizeArg(f"{tree.prefix}numel_{num}", tree.numel)
+                    signature.append(sizearg)
+                    argdefs.append(ArgName(f"{tree.prefix}numel_{num}"))
+                    self.dynamic_shape_args.append(f"{tree.prefix}numel_{num}")
+        return argdefs
+
+    def add_numel_to_call_args(
+        self, name: str, call_args: list[Any], arg_types: list[Any]
+    ) -> None:
+        for num, sub_kernel in enumerate(self.sub_kernels):
+            for tree in sub_kernel.range_trees:
+                numel_name = f"{tree.prefix}numel_{num}"
+                if numel_name not in self.dynamic_shape_args:
+                    continue
+                if isinstance(tree.numel, (Integer, Symbol)):
+                    expr = tree.numel
+                else:
+                    expr = V.graph.wrapper_code.generate_numel_expr(
+                        name, tree, suffix=str(num)
+                    )
+
+                if not tree.is_reduction or sub_kernel.inside_reduction:
+                    call_args.append(expr)
+                    arg_types.append(type(expr))
+
+    def kernel_benchmark_extra_args(self) -> list[str]:
+        extra_args = []
+        for num, sub_kernel in enumerate(self.sub_kernels):
+            for tree in sub_kernel.range_trees:
+                numel_name = f"{tree.prefix}numel_{num}"
+                if numel_name not in self.dynamic_shape_args:
+                    continue
+
+                if not tree.is_reduction or sub_kernel.inside_reduction:
+                    extra_args.append(
+                        str(V.graph.sizevars.optimization_hint(tree.numel))
+                    )
+        return extra_args
+
+    def _merge_noinline_kernel_args(self) -> None:
+        for sub_kernel in self.sub_kernels:
+            self._merge_noinline_kernel_arg(sub_kernel)
+
+        self.noinline_arg_name_maps = [
+            self._resolve_noinline_kernel_arg_names(sub_kernel)
+            for sub_kernel in self.sub_kernels
+        ]
+
+    def _merge_noinline_kernel_arg(self, sub_kernel: TritonKernel) -> None:
+        # Each noinline body codegens in a local namespace, so different members
+        # can all have local names like in_ptr0/out_ptr0. First replay every
+        # local arg into the combo-main namespace; names are resolved only after
+        # all members have registered their in-place relationships.
+        local_args = sub_kernel.args
+        local_argdefs, _, local_signature, _ = local_args.python_argdefs()
+
+        for argdef, signature in zip(local_argdefs, local_signature, strict=True):
+            if isinstance(signature, TensorArg):
+                buffer = signature.buffer
+                inplaced = local_args.inplace_buffers.get(buffer)
+                if (
+                    inplaced is not None
+                    and not isinstance(inplaced, RemovedArg)
+                    and inplaced.inner_name == argdef.name
+                ):
+                    input_name, *output_names = inplaced.other_names
+                    for output_name in output_names:
+                        if output_name not in self.args.inplace_buffers:
+                            self.args.make_inplace(input_name, output_name)
+                elif local_args.output_buffers.get(buffer) == argdef.name:
+                    self.args.output(buffer)
+                else:
+                    self.args.input(buffer)
+            elif isinstance(signature, SizeArg):
+                expr = signature.expr
+                if isinstance(expr, Symbol):
+                    self.args.size(expr)
+                else:
+                    self.args.seed_offset(argdef.name, int(expr))
+
+    def _resolve_noinline_kernel_arg_names(
+        self, sub_kernel: TritonKernel
+    ) -> dict[str, str]:
+        local_args = sub_kernel.args
+        local_to_main: dict[str, str] = {}
+        local_argdefs, _, local_signature, _ = local_args.python_argdefs()
+
+        for argdef, signature in zip(local_argdefs, local_signature, strict=True):
+            if isinstance(signature, TensorArg):
+                buffer = signature.buffer
+                if (
+                    buffer in local_args.inplace_buffers
+                    or local_args.output_buffers.get(buffer) == argdef.name
+                ):
+                    main_name = self.args.output(buffer)
+                else:
+                    main_name = self.args.input(buffer)
+            elif isinstance(signature, SizeArg):
+                main_name = self.args.sizevars[signature.expr]
+            else:
+                raise AssertionError(
+                    f"unsupported combo noinline argument "
+                    f"{argdef.name}: {type(signature).__name__}"
+                )
+
+            local_to_main[argdef.name] = main_name
+
+        return local_to_main
+
+    def _noinline_block_args_for_sub_kernel(
+        self, sub_kernel: TritonKernel, num: int
+    ) -> list[tuple[ArgName, str]]:
+        block_args: list[tuple[ArgName, str]] = []
+        for tree in sub_kernel.range_trees:
+            if tree.prefix == "x" and sub_kernel.no_x_dim:
+                continue
+            if tree.prefix in ("x", "y") or (
+                tree.is_reduction
+                and sub_kernel.inside_reduction
+                and not sub_kernel.persistent_reduction
+            ):
+                name = f"{tree.prefix.upper()}BLOCK"
+                block_args.append((ArgName(name, is_constexpr=True), f"{name}_{num}"))
+        return block_args
+
+    def _signature_key_part(self, arg: Any) -> tuple[Any, ...]:
+        if isinstance(arg, TensorArg):
+            return ("tensor", arg.dtype, is_unaligned_buffer(arg))
+        if isinstance(arg, SizeArg):
+            return ("size", type(arg.expr).__name__)
+        if isinstance(arg, ConstexprArg):
+            return ("constexpr", arg.name)
+        return (type(arg).__name__, getattr(arg, "name", None))
+
+    def _prepare_noinline_sub_kernel_calls(self) -> None:
+        calls: list[NoinlineSubKernelCall] = []
+        for num, sub_kernel in enumerate(self.sub_kernels):
+            local_to_main = self.noinline_arg_name_maps[num]
+            local_argdefs, _, local_signature, _ = sub_kernel.args.python_argdefs()
+            params = list(local_argdefs)
+            call_args = [local_to_main[arg.name] for arg in local_argdefs]
+            signature_key: list[Any] = [
+                self._signature_key_part(arg) for arg in local_signature
+            ]
+
+            for tree in sub_kernel.active_range_trees():
+                if isinstance(tree.numel, (Integer, int)):
+                    continue
+                if tree.is_reduction and not sub_kernel.inside_reduction:
+                    continue
+                params.append(ArgName(f"{tree.prefix}numel"))
+                call_args.append(f"{tree.prefix}numel_{num}")
+                signature_key.append(("range_numel", tree.prefix))
+
+            params.append(ArgName("x_pid_offset"))
+            call_args.append("x_pid_offset")
+            signature_key.append(("dispatch", "x_pid_offset"))
+            if any(tree.prefix == "y" for tree in sub_kernel.range_trees):
+                params.append(ArgName("y_pid_offset"))
+                call_args.append("y_pid_offset")
+                signature_key.append(("dispatch", "y_pid_offset"))
+
+            for param, call_arg in self._noinline_block_args_for_sub_kernel(
+                sub_kernel, num
+            ):
+                params.append(param)
+                call_args.append(call_arg)
+                signature_key.append(("block", param.full_name()))
+
+            calls.append(
+                NoinlineSubKernelCall(
+                    params=params,
+                    call_args=call_args,
+                    signature_key=tuple(signature_key),
+                )
+            )
+
+        self.noinline_sub_kernel_calls = calls
+
+    def _can_share_body(
+        self,
+        heuristics_list: list[str],
+    ) -> bool:
+        if len(self.sub_kernels) < 2:
+            return False
+        if self.enable_autotune or self.per_subkernel_blocks:
+            return False
+        if torch.version.hip is not None:
+            # The shared-body form joins live pointer placeholders after a
+            # many-way dispatch branch. HIP/Triton currently has pathological
+            # compile times for that IR shape on large foreach lists, so keep
+            # ROCm on the existing per-branch body emission path.
+            return False
+        if self.dispatch_class not in (
+            ComboKernel.SequentialDispatch,
+            ComboKernel.RoundRobinDispatch,
+        ):
+            return False
+        if self.dynamic_shape_args or any(self.y_tree_list):
+            return False
+        if any(
+            sub_kernel.no_x_dim
+            or sub_kernel.inside_reduction
+            or sub_kernel.persistent_reduction
+            for sub_kernel in self.sub_kernels
+        ):
+            return False
+        return all(heuristic == "pointwise" for heuristic in heuristics_list)
+
+    @staticmethod
+    def _plain_lines(code: IndentedBuffer) -> list[str] | None:
+        lines: list[str] = []
+        for line in code._lines:
+            if isinstance(line, str):
+                lines.append(line)
+            elif isinstance(line, DeferredLineBase):
+                evaluated = line()
+                if evaluated is not None:
+                    lines.append(evaluated)
+            else:
+                return None
+        return lines
+
+    @staticmethod
+    def _replace_names_in_line(line: str, replacements: dict[str, str]) -> str | None:
+        if not replacements:
+            return line
+        try:
+            pieces: list[str] = []
+            cursor = 0
+            for token in tokenize.generate_tokens(io.StringIO(line).readline):
+                if token.type == tokenize.NAME and token.string in replacements:
+                    start, end = token.start[1], token.end[1]
+                    pieces.append(line[cursor:start])
+                    pieces.append(replacements[token.string])
+                    cursor = end
+            pieces.append(line[cursor:])
+            return "".join(pieces)
+        except tokenize.TokenError:
+            return None
+
+    @classmethod
+    def _replace_names(
+        cls, lines: list[str], replacements: dict[str, str]
+    ) -> list[str] | None:
+        replaced: list[str] = []
+        for line in lines:
+            new_line = cls._replace_names_in_line(line, replacements)
+            if new_line is None:
+                return None
+            replaced.append(new_line)
+        return replaced
+
+    @staticmethod
+    def _names_in_lines(lines: list[str]) -> OrderedSet[str] | None:
+        names: OrderedSet[str] = OrderedSet()
+        try:
+            for line in lines:
+                for token in tokenize.generate_tokens(io.StringIO(line).readline):
+                    if token.type == tokenize.NAME:
+                        names.add(token.string)
+        except tokenize.TokenError:
+            return None
+        return names
+
+    @staticmethod
+    def _range_tree_names(sub_kernel: TritonKernel) -> list[str]:
+        names: list[str] = []
+        for tree in sub_kernel.range_trees:
+            names.append(tree.name)
+            names.extend(entry.name for entry in tree.nodes.values())
+        return names
+
+    @classmethod
+    def _range_tree_name_replacements(
+        cls, first: TritonKernel, sub_kernel: TritonKernel
+    ) -> dict[str, str] | None:
+        if len(first.range_trees) != len(sub_kernel.range_trees):
+            return None
+
+        for first_tree, tree in zip(
+            first.range_trees, sub_kernel.range_trees, strict=True
+        ):
+            if (
+                first_tree.prefix != tree.prefix
+                or first_tree.tensor_dim != tree.tensor_dim
+                or first_tree.is_reduction != tree.is_reduction
+            ):
+                return None
+
+        first_names = cls._range_tree_names(first)
+        names = cls._range_tree_names(sub_kernel)
+        if len(first_names) != len(names):
+            return None
+        return {
+            name: first_name
+            for first_name, name in zip(first_names, names, strict=True)
+            if name != first_name
+        }
+
+    @classmethod
+    def _body_name_replacements(
+        cls,
+        first: TritonKernel,
+        sub_kernel: TritonKernel,
+        args: list[str],
+    ) -> dict[str, str] | None:
+        first_cse_names = {
+            canonical: name for name, canonical in first._op_trace_cse_names.items()
+        }
+        replacements: dict[str, str] = {}
+        for name, canonical in sub_kernel._op_trace_cse_names.items():
+            first_name = first_cse_names.get(canonical)
+            if first_name is None:
+                return None
+            if name != first_name:
+                replacements[name] = first_name
+
+        range_replacements = cls._range_tree_name_replacements(first, sub_kernel)
+        if range_replacements is None:
+            return None
+        replacements.update(range_replacements)
+
+        for i, arg in enumerate(args):
+            replacements[arg] = f"foreach_arg{i}"
+        return replacements
+
+    @staticmethod
+    def _compatible_shared_arg_properties(
+        args_by_subkernel: list[list[str]],
+        tensor_args: dict[str, TensorArg],
+    ) -> bool:
+        if not args_by_subkernel:
+            return False
+        num_args = len(args_by_subkernel[0])
+        if num_args == 0:
+            return False
+        if any(len(args) != num_args for args in args_by_subkernel):
+            return False
+        if any(arg not in tensor_args for args in args_by_subkernel for arg in args):
+            return False
+
+        for arg_index in range(num_args):
+            properties = OrderedSet(
+                [
+                    (
+                        tensor_args[args[arg_index]].dtype,
+                        is_unaligned_buffer(tensor_args[args[arg_index]]),
+                    )
+                    for args in args_by_subkernel
+                ]
+            )
+            if len(properties) != 1:
+                return False
+
+        return True
+
+    @classmethod
+    def _setup_lhs_names(cls, sub_kernel_codes: list[SubKernelCode]) -> list[str]:
+        names: list[str] = []
+        seen: OrderedSet[str] = OrderedSet()
+        for sub_kernel_code in sub_kernel_codes:
+            for name in sub_kernel_code.setup_lhs_names:
+                if name not in seen:
+                    seen.add(name)
+                    names.append(name)
+        return names
+
+    def _try_get_shared_body(
+        self,
+        sub_kernel_codes: list[SubKernelCode],
+        signature: list[Any],
+        heuristics_list: list[str],
+    ) -> SharedBody | None:
+        if not self._can_share_body(heuristics_list):
+            return None
+
+        tensor_args = {arg.name: arg for arg in signature if isinstance(arg, TensorArg)}
+        if not tensor_args:
+            return None
+        first_sub_kernel = self.sub_kernels[0]
+        first_trace = first_sub_kernel.op_trace
+        if not first_trace:
+            return None
+        if any(
+            sub_kernel.op_trace != first_trace for sub_kernel in self.sub_kernels[1:]
+        ):
+            return None
+
+        transformed_bodies: list[list[str]] = []
+        args_by_subkernel: list[list[str]] = []
+
+        for sub_kernel, sub_kernel_code in zip(
+            self.sub_kernels, sub_kernel_codes, strict=True
+        ):
+            lines = self._plain_lines(sub_kernel_code.body)
+            if lines is None:
+                return None
+            body_names = self._names_in_lines(lines)
+            if body_names is None:
+                return None
+            if any(
+                arg in body_names and arg not in tensor_args
+                for arg in sub_kernel.op_trace_buffer_arg_names
+            ):
+                return None
+            args = [
+                arg
+                for arg in sub_kernel.op_trace_buffer_arg_names
+                if arg in tensor_args and arg in body_names
+            ]
+            # Every live tensor pointer in the emitted body must come from the
+            # structured trace so placeholder substitution cannot miss it.
+            if any(arg in body_names and arg not in args for arg in tensor_args):
+                return None
+            args_by_subkernel.append(args)
+
+            replacements = self._body_name_replacements(
+                first_sub_kernel, sub_kernel, args
+            )
+            if replacements is None:
+                return None
+            transformed = self._replace_names(lines, replacements)
+            if transformed is None:
+                return None
+
+            transformed_bodies.append(transformed)
+
+        if any(body != transformed_bodies[0] for body in transformed_bodies[1:]):
+            return None
+        if not self._compatible_shared_arg_properties(args_by_subkernel, tensor_args):
+            return None
+
+        setup_lhs_names = self._setup_lhs_names(sub_kernel_codes)
+
+        body = IndentedBuffer()
+        body.writelines(transformed_bodies[0])
+        return SharedBody(
+            body=body,
+            placeholder_names=[
+                f"foreach_arg{i}" for i in range(len(args_by_subkernel[0]))
+            ],
+            args_by_subkernel=args_by_subkernel,
+            setup_lhs_names=setup_lhs_names,
+        )
+
+    def _codegen_sub_kernel_bodies(
+        self,
+    ) -> list[SubKernelCode]:
+        sub_kernel_codes: list[SubKernelCode] = []
+        for num, sub_kernel in enumerate(self.sub_kernels):
+            setup = IndentedBuffer()
+            sub_kernel_setup = self.codegen_static_numels_sub_kernel(
+                setup, sub_kernel, num
+            )
+            sub_kernel.codegen_prologue(sub_kernel.body)
+            sub_kernel.codegen_body()
+            sub_kernel._filter_pdl(sub_kernel.body)
+            uniquify = (
+                []
+                if self.per_subkernel_blocks
+                else sub_kernel_setup.uniquify_block_sizes
+            )
+            body = self.uniquify_block_sizes(sub_kernel.body, num, uniquify)
+            sub_kernel_codes.append(
+                SubKernelCode(
+                    setup=setup,
+                    body=body,
+                    setup_lhs_names=sub_kernel_setup.lhs_names,
+                )
+            )
+        return sub_kernel_codes
+
+    def _codegen_branch(
+        self,
+        code: IndentedBuffer,
+        num: int,
+        sub_kernel_code: SubKernelCode,
+    ) -> None:
+        if self.dispatch_class is None:
+            raise AssertionError("dispatch_class must not be None")
+        self.dispatch_class.codegen_pid_range(self, num, code)
+        with code.indent():
+            code.splice(sub_kernel_code.setup)
+            code.splice(sub_kernel_code.body)
+
+    def _codegen_noinline_sub_kernels(
+        self,
+        code: IndentedBuffer,
+        kernel_name: str,
+        sub_kernel_codes: list[SubKernelCode],
+    ) -> list[str]:
+        """Emit each sub-kernel body as a @triton.jit(noinline=True) device
+        function and return the per-branch call lines."""
+        call_lines: list[str] = []
+        defs = IndentedBuffer()
+        emitted: dict[tuple[Any, ...], str] = {}
+        for num, sub_kernel_code in enumerate(sub_kernel_codes):
+            noinline_call = self.noinline_sub_kernel_calls[num]
+            params = noinline_call.params
+            call_args = noinline_call.call_args
+            key = (
+                sub_kernel_code.setup.getvalue(),
+                sub_kernel_code.body.getvalue(),
+                noinline_call.signature_key,
+            )
+
+            sub_name = emitted.get(key)
+            if sub_name is None:
+                sub_name = f"{kernel_name}_body_{len(emitted)}"
+                emitted[key] = sub_name
+                defs.writeline("")
+                defs.writeline("@triton.jit(noinline=True)")
+                defs.writeline(
+                    f"def {sub_name}({', '.join(p.full_name() for p in params)}):"
+                )
+                with defs.indent():
+                    defs.splice(sub_kernel_code.setup)
+                    defs.splice(sub_kernel_code.body)
+            call_lines.append(f"{sub_name}({', '.join(call_args)})")
+        defs.writeline("")
+        code.splice(defs)
+        return call_lines
+
+    def _codegen_shared_branches(
+        self,
+        code: IndentedBuffer,
+        sub_kernel_codes: list[SubKernelCode],
+        shared_body: SharedBody,
+    ) -> None:
+        if self.dispatch_class is None:
+            raise AssertionError("dispatch_class must not be None")
+        for num, sub_kernel_code in enumerate(sub_kernel_codes):
+            self.dispatch_class.codegen_pid_range(self, num, code)
+            with code.indent():
+                code.splice(sub_kernel_code.setup)
+                for placeholder, arg in zip(
+                    shared_body.placeholder_names,
+                    shared_body.args_by_subkernel[num],
+                    strict=True,
+                ):
+                    code.writeline(f"{placeholder} = {arg}")
+
+        code.splice("else:")
+        with code.indent():
+            code.splice("pid_offset = 0")
+            for name in shared_body.setup_lhs_names:
+                code.writeline(f"{name} = 0")
+            for placeholder, arg in zip(
+                shared_body.placeholder_names,
+                shared_body.args_by_subkernel[0],
+                strict=True,
+            ):
+                code.writeline(f"{placeholder} = {arg}")
+
+        code.splice(shared_body.body)
+
+    def codegen_kernel(self, name: str | None = None) -> str:
+        """Generate the triton code for a combo kernel that fuses multiple sub-kernels."""
+        # TODO: is it correct to use the first sub kernel's heuristics?
+        heuristics_list, size_hints_list = [], []
+        for subkernel in self.sub_kernels:
+            h, s = self.select_heuristics(subkernel)
+            heuristics_list.append(h)
+            size_hints_list.append(s)
+        heuristics, size_hints, selected_kernel = self.select_combo_heuristics(
+            heuristics_list, size_hints_list
+        )
+        pointwise_with_reduction, heuristics = (
+            (True, "pointwise")
+            if heuristics == "pointwise_with_reduction"
+            else (False, heuristics)
+        )
+        code = IndentedBuffer()
+
+        code.splice(self.triton_kernel_cls.gen_common_triton_imports())
+        if config.benchmark_combo_kernel:
+            code.splice(self.imports_for_benchmark_kernel())
+
+        seen_helpers: OrderedSet[str] = OrderedSet()
+        for sub_kernel in self.sub_kernels:
+            for helper in sub_kernel.helper_functions:
+                if helper not in seen_helpers:
+                    code.writeline("")
+                    code.splice(helper)
+                    seen_helpers.add(helper)
+
+        if self.per_subkernel_blocks:
+            self._merge_noinline_kernel_args()
+
+        argdefs, _, signature, _ = self.args.python_argdefs()
+        argdefs = self.add_numel_to_args(argdefs, signature)
+        if self.per_subkernel_blocks:
+            main_arg_names = OrderedSet(arg.name for arg in argdefs)
+            mapped_arg_names = OrderedSet(
+                name
+                for name_map in self.noinline_arg_name_maps
+                for name in name_map.values()
+            )
+            missing_arg_names = mapped_arg_names - main_arg_names
+            if missing_arg_names:
+                raise AssertionError(
+                    "combo noinline call arguments missing from main signature: "
+                    f"{sorted(missing_arg_names)}"
+                )
+        block_args = self.get_block_args()
+        if not self.bake_blocks or self.per_subkernel_blocks:
+            argdefs.extend([ArgName(x.name, is_constexpr=True) for x in block_args])
+            if triton_version_uses_attrs_dict():
+                signature.extend(block_args)
+        if self.per_subkernel_blocks:
+            self._prepare_noinline_sub_kernel_calls()
+
+        kernel_name = name or str(Placeholder.KERNEL_NAME)
+
+        sub_kernel_codes = self._codegen_sub_kernel_bodies()
+        # Sub-functions must be emitted before the main kernel's heuristics
+        # decorator line (triton reads the decorated function's source by
+        # inspection). PDL intrinsics move with each body and proton scopes
+        # wrap the main kernel around the calls, so neither needs the inline
+        # form.
+        noinline_calls: list[str] | None = None
+        if self.per_subkernel_blocks:
+            noinline_calls = self._codegen_noinline_sub_kernels(
+                code, kernel_name, sub_kernel_codes
+            )
+
+        code.splice(
+            self.jit_line(
+                heuristics,
+                size_hints,
+                selected_kernel,
+                pointwise_with_reduce=pointwise_with_reduction,
+                signature=signature,
+                argdefs=argdefs,
+                size_hints_list=size_hints_list,
+            )
+        )
+        code.writeline(
+            f"def {kernel_name}({', '.join(x.full_name() for x in argdefs)}):"
+        )
+
+        with code.indent():
+            if config.triton.proton_profiling:
+                code.writeline(f'pl.enter_scope("{kernel_name}")')
+            code.splice("pid = tl.program_id(0)")
+            if self.bake_blocks and not self.per_subkernel_blocks:
+                self.codegen_blocks(code)
+
+            shared_body = self._try_get_shared_body(
+                sub_kernel_codes, signature, heuristics_list
+            )
+            if shared_body is not None:
+                self._codegen_shared_branches(code, sub_kernel_codes, shared_body)
+            elif noinline_calls is not None:
+                if self.dispatch_class is None:
+                    raise AssertionError("dispatch_class must not be None")
+                for num, call_line in enumerate(noinline_calls):
+                    self.dispatch_class.codegen_pid_range(self, num, code)
+                    with code.indent():
+                        code.writeline(call_line)
+                code.splice("else:")
+                with code.indent():
+                    code.splice("pass")
+            else:
+                for num, sub_kernel_code in enumerate(sub_kernel_codes):
+                    self._codegen_branch(code, num, sub_kernel_code)
+
+                code.splice("else:")
+                with code.indent():
+                    code.splice("pass")
+            if config.triton.proton_profiling:
+                code.writeline(f'pl.exit_scope("{kernel_name}")')
+
+        if config.benchmark_combo_kernel:
+            code.splice(self.codegen_kernel_benchmark(num_gb=self._kernel_num_gb))
+
+        return code.getvalue()
+
+    def codegen_kernel_benchmark(self, num_gb: float) -> IndentedBuffer:
+        """
+        Generates Python code for benchmarking this combo kernel.
+        - Creates example inputs (random tensors, constants, sizes).
+        - Runs the kernel on the current GPU/stream.
+        - Prints runtime (ms) and throughput (GB/s) using `num_gb`.
+        Args:
+            num_gb (float): The number of gigabytes to use for throughput calculation.
+        Returns:
+            IndentedBuffer: A buffer containing the generated Python benchmark code.
+        """
+        result = IndentedBuffer()
+        _argdefs, call_args, signature, _ = self.args.python_argdefs()
+        result.writelines(["", "", "def get_args():"])
+        with result.indent():
+            name_cnt = itertools.count()
+            var_names = []
+            for arg_name, arg_sig in zip(call_args, signature):
+                var_name = f"arg_{next(name_cnt)}"
+                buf = V.graph.try_get_buffer(arg_name)
+                if buf:
+                    size = V.graph.sizevars.optimization_hints(buf.get_size())
+                    stride = V.graph.sizevars.optimization_hints(buf.get_stride())
+                    result.writeline(
+                        f"{var_name} = rand_strided({size}, {stride}, device='{coor_device_str(buf.get_device())}', dtype={buf.get_dtype()})"
+                    )
+                elif arg_name in V.graph.constants:
+                    # note that random seed is put in V.graph.constants
+                    const_tensor = V.graph.constants[arg_name]
+                    size = V.graph.sizevars.optimization_hints(const_tensor.size())
+                    stride = V.graph.sizevars.optimization_hints(const_tensor.stride())
+                    result.writeline(
+                        f"{var_name} = rand_strided({size}, {stride}, device='{coor_device_str(const_tensor.device)}', dtype={const_tensor.dtype})"  # type: ignore[arg-type]
+                    )
+                elif isinstance(arg_sig, SizeArg):
+                    symval_hint = V.graph.sizevars.optimization_hint(arg_sig.expr)
+
+                    # Force the seed_offset to be 0 so calls to the same kernel
+                    # using different seed offset will have the same benchmark harness.
+                    # We can dedup kernel definitions in this case.
+                    if "seed_offset" in arg_sig.name:
+                        symval_hint = 0
+                    result.writeline(f"{var_name} = {symval_hint}")
+                elif isinstance(arg_sig, WorkspaceArg):
+                    device = V.graph.get_current_device_or_throw()
+                    count = V.graph.sizevars.optimization_hint(arg_sig.count)
+                    # for benchmark harness, we ignore arg_sig.zero_mode and always zero it
+                    result.writeline(
+                        f"{var_name} = torch.zeros({count}, device='{coor_device_str(device)}', dtype={arg_sig.dtype})"
+                    )
+                else:
+                    raise KeyError(
+                        f"Don't find the buffer or const tensor for {arg_name}"
+                    )
+                var_names.append(var_name)
+            if self.dynamic_shape_args:
+                var_names.extend(self.kernel_benchmark_extra_args())
+            result.writeline(f"return {', '.join(var_names)},")
+
+        result.writelines(["\n", "\n", "def call(args):"])
+        device = V.graph.get_current_device_or_throw()
+        coor_preamble, index = coor_benchmark_device_idx(device.index)
+        with result.indent():
+            if coor_preamble:
+                result.writeline(coor_preamble)
+            result.writeline(f"with {V.graph.device_ops.device_guard(index)}:")
+            with result.indent():
+                result.writeline(
+                    V.graph.device_ops.set_device(index)
+                )  # no-op to ensure context
+                stream_name = get_raw_stream_name(device.index)
+                result.writeline(f"{stream_name} = get_raw_stream({index})")
+                result.writeline(
+                    f"{str(Placeholder.KERNEL_NAME)}.run(*args, stream={stream_name})"
+                )
+
+        # benchmark all configs
+        result.writelines(["\n", "\n", "def benchmark_all_configs(args):"])
+        with result.indent():
+            if coor_preamble:
+                result.writeline(coor_preamble)
+            result.writeline(f"with {V.graph.device_ops.device_guard(index)}:")
+            with result.indent():
+                result.writeline(
+                    V.graph.device_ops.set_device(index)
+                )  # no-op to ensure context
+                result.writeline(
+                    f"return {str(Placeholder.KERNEL_NAME)}.benchmark_all_configs(*args)"
+                )
+
+        result.writelines(["\n", "\n", "if __name__ == '__main__':"])
+        with result.indent():
+            result.writeline(
+                "from torch._inductor.runtime.benchmarking import benchmarker"
+            )
+            result.writeline("")
+
+            result.writeline("args = get_args()")
+            result.writeline(
+                f"ms = benchmarker.benchmark(call, fn_args=(args,), device='{device.type}',rep=40)"
+            )
+            result.writeline(f"num_gb = {num_gb}")
+            result.writeline("gb_per_s = num_gb / (ms / 1e3)")
+            result.writeline(
+                'print(f"{ms:.3f}ms    {num_gb:.3f}GB    {gb_per_s:.2f}GB/s")'
+            )
+
+        return result
+
+    def imports_for_benchmark_kernel(self) -> str:
+        # Dedent BEFORE substituting get_raw_stream: a multi-line override would
+        # otherwise collapse dedent's common prefix and misindent the imports.
+        return textwrap.dedent(
+            """
+            from torch._dynamo.testing import rand_strided
+            {}
+            import torch
+            """
+        ).format(V.graph.device_ops.import_get_raw_stream_as("get_raw_stream"))
+
+    def uniquify_block_sizes(
+        self, code: IndentedBuffer, num_kernel: int, uniquify: list[str]
+    ) -> IndentedBuffer:
+        if not uniquify:
+            return code
+        modified = IndentedBuffer(initial_indent=code._indent)
+        for line in code._lines:
+            if isinstance(line, str) and (blocks := [e for e in uniquify if e in line]):
+                modified_line = line
+                for block in blocks:
+                    modified_line = modified_line.replace(
+                        block, f"{block}_{num_kernel}"
+                    )
+                modified.writeline(modified_line)
+            elif isinstance(line, DeferredLineBase) and (
+                blocks := [e for e in uniquify if e in line.line]
+            ):
+                modified_line = line.line
+                for block in blocks:
+                    modified_line = modified_line.replace(
+                        block, f"{block}_{num_kernel}"
+                    )
+                new_line = line._new_line(modified_line)
+                modified.writeline(new_line)
+            else:
+                modified.writeline(line)
+        return modified
+
+    def call_kernel(self, name: str) -> None:
+        _, call_args, _, arg_types = self.args.python_argdefs()
+
+        wrapper = V.graph.wrapper_code
+        if self.dispatch_class is None:
+            raise AssertionError("dispatch_class must not be None")
+        if self.dynamic_shape_args:
+            self.add_numel_to_call_args(name, call_args, arg_types)
+
+        wrapper.generate_kernel_call(
+            name,
+            call_args,
+            triton=True,
+            arg_types=arg_types,
+            triton_meta=self.triton_meta,
+            inductor_meta=self.inductor_meta,
+        )
+
+    def combo_grid_meta(self, size_hints_list: list[dict[str, int]]) -> dict[str, Any]:
+        """
+        Build metadata used by combo-kernel grid/dispatch/autotune helpers.
+        """
+        dynamic_shape = bool(self.dynamic_shape_args)
+        num_kernels = len(self.sub_kernels)
+        min_blocks = (
+            max(self.min_x_blocks_list) * num_kernels if not dynamic_shape else None
+        )
+
+        meta: dict[str, Any] = {
+            "num_kernels": num_kernels,
+            "min_blocks": min_blocks,
+            # Captured at codegen time so runtime sees the same value the
+            # source was generated with, regardless of later config changes.
+            "autotune_grouping": config.combo_kernel_autotune_grouping,
+            "block_arg_names": tuple(self.block_args),
+        }
+
+        if self.bake_blocks or self.combo_compile_time_autotune:
+            default_config: dict[str, int] = {}
+            if self.combo_compile_time_autotune:
+                # Compile-time autotune: per-subkernel winning block sizes are passed as args;
+                # num_warps / num_stages / backend kwargs are autotuned over the distinct winner
+                # launch candidates (flattened to tuples so the meta stays repr-serializable).
+                if not self.combo_launch_candidates:
+                    raise AssertionError(
+                        "compile-time autotune requires at least one launch candidate"
+                    )
+                if self.stitched_block_config is not None:
+                    default_config = dict(self.stitched_block_config)
+                meta["stitched_launch_candidates"] = [
+                    (c.kwargs, c.num_warps, c.num_stages)
+                    for c in self.combo_launch_candidates
+                ]
+            elif self.no_bench_stitched_config is not None:
+                stitched = self.no_bench_stitched_config
+                default_config = {
+                    k: int(v) for k, v in stitched.kwargs.items() if "BLOCK" in k
+                }
+                meta["stitched_backend_kwargs"] = {
+                    k: v for k, v in stitched.kwargs.items() if "BLOCK" not in k
+                }
+                meta["stitched_num_warps"] = stitched.num_warps
+                meta["stitched_num_stages"] = stitched.num_stages
+            elif self.per_subkernel_blocks:
+                # Per-subkernel block sizes: XBLOCK_0, XBLOCK_1, etc.
+                for num, sub_kernel in enumerate(self.sub_kernels):
+                    if sub_kernel.no_x_dim:
+                        default_config[f"XBLOCK_{num}"] = 1
+                    else:
+                        block_size = (
+                            self.block_size_2d
+                            if any(self.y_tree_list)
+                            else self.block_size_1d
+                        )
+                        default_config[f"XBLOCK_{num}"] = block_size
+
+                    if self.y_tree_list[num]:
+                        default_config[f"YBLOCK_{num}"] = self.block_size_2d
+            else:
+                if "YBLOCK" in self.block_args:
+                    default_config = {
+                        "XBLOCK": self.block_size_2d,
+                        "YBLOCK": self.block_size_2d,
+                    }
+                else:
+                    default_config = {"XBLOCK": self.block_size_1d}
+            meta["default_config"] = default_config
+        else:
+            meta["default_config"] = None
+
+        for num, sub_kernel in enumerate(self.sub_kernels):
+            meta[f"no_x_dim_{num}"] = sub_kernel.no_x_dim
+
+            if self.per_subkernel_blocks:
+                meta[f"heuristic_{num}"] = (
+                    "persistent_reduction"
+                    if sub_kernel.persistent_reduction
+                    else "reduction"
+                    if sub_kernel.inside_reduction
+                    else "pointwise"
+                )
+
+                meta[f"size_hints_{num}"] = size_hints_list[num]
+                meta[f"inductor_meta_{num}"] = sub_kernel.inductor_meta_per_kernel()
+                if meta[f"heuristic_{num}"] == "pointwise":
+                    if len(size_hints_list[num]) == 2:
+                        meta[f"tile_hint_{num}"] = "TileHint.SQUARE"
+                    else:
+                        meta[f"tile_hint_{num}"] = "TileHint.DEFAULT"
+                else:
+                    meta[f"reduction_hint_{num}"] = (
+                        sub_kernel.features.get_reduction_hint(
+                            sub_kernel.tiling_scores
+                        ).name
+                    )
+
+            for tree in sub_kernel.range_trees:
+                if not tree.is_reduction:
+                    numel_name = f"{tree.prefix}numel_{num}"
+                    if numel_name in self.dynamic_shape_args:
+                        meta[numel_name] = None
+                    else:
+                        meta[numel_name] = int(V.graph.sizevars.simplify(tree.numel))
+
+        return meta

.venv/lib/python3.12/site-packages/torch/_inductor/codegen/triton_split_scan.py

@@ -0,0 +1,228 @@
+# mypy: allow-untyped-defs
+import functools
+
+import sympy
+
+from torch._inductor import config
+from torch._inductor.codegen.simd import IterationRangesRoot, prefix_is_reduction
+from torch._inductor.codegen.triton import (
+    triton_compute_type,
+    TritonCSEVariable,
+    TritonKernel,
+)
+from torch._inductor.runtime.triton_heuristics import SplitScanGrid
+from torch.utils._ordered_set import OrderedSet
+from torch.utils._sympy.functions import CeilDiv
+
+from ..utils import sympy_product, upcast_compute_type
+
+
+class TritonSplitScanKernel(TritonKernel):
+    """Generates a triton kernel that supports ops.scan calls while also splitting
+    the reduction dimension over multiple triton programs.
+
+    For this kernel, loop numels will always take the form ``(xdim, rdim)``
+    and the grid has the shape ``(CeilDiv(rdim, RBLOCK), xdim)``. Communication
+    between blocks occurs within a global memory workspace buffer, which
+    must be zero-filled before launching the kernel.
+
+    Note that generation for ``ops.reduction`` is not supported.
+
+    For details of the communication strategy, see
+    https://research.nvidia.com/publication/2016-03_single-pass-parallel-prefix-scan-decoupled-look-back
+
+    """
+
+    def __init__(
+        self,
+        tiling: dict[str, sympy.Expr],
+        pid_cache=None,
+        fixed_config=None,
+        **kwargs,
+    ) -> None:
+        if pid_cache is not None:
+            raise AssertionError("not supported")
+        if fixed_config is not None:
+            raise AssertionError("not supported")
+        super().__init__(
+            tiling,
+            **kwargs,
+        )
+        self.no_x_dim = True
+
+    def should_use_persistent_reduction(self) -> bool:
+        return False
+
+    def should_use_cooperative_reduction(self) -> bool:
+        return False
+
+    def initialize_range_tree(self, pid_cache):
+        prefixes = ["y", "x", "r0_"]
+        if len(self.numels) > len(prefixes):
+            raise AssertionError("z dimension not supported for split scan")
+        active_prefixes = prefixes[len(prefixes) - len(self.numels) :]
+
+        grid_dims = {"r0_": 0, "x": 1, "y": 2}
+        for prefix in active_prefixes:
+            numel = self.numels[prefix]
+            tensor_dim = 0 if prefix_is_reduction(prefix) else None
+            grid_dim = grid_dims[prefix]
+            self.range_trees.append(
+                IterationRangesRoot(
+                    f"{prefix}index",
+                    numel,
+                    prefix,
+                    grid_dim,
+                    self,  # type: ignore[arg-type]
+                    pid_cache=pid_cache,
+                    is_loop=False,
+                    tensor_dim=tensor_dim,
+                    grid_dim=grid_dim,
+                    has_zdim=False,
+                )
+            )
+
+    def reduction(self, dtype, src_dtype, reduction_type, value):
+        raise NotImplementedError("NYI TritonSplitDimKernel reductions")
+
+    def scan(self, dtypes, combine_fn, values):
+        """
+        Perform an associative scan on 'values'.
+        """
+        import triton.language as tl
+
+        (dtype,) = dtypes
+        (value,) = values
+
+        dtype = upcast_compute_type(dtype)
+        compute_type = triton_compute_type(dtype)
+        compute_type_triton = getattr(tl, compute_type[3:])
+
+        element_nbits = compute_type_triton.primitive_bitwidth
+
+        scratch_type = "tl.uint32" if element_nbits <= 16 else "tl.uint64"
+        scratch_type_triton = getattr(tl, scratch_type[3:])
+        scratch_elems_per_block = 3 if element_nbits == 64 else 1
+        scratch_nbytes_per_block = scratch_elems_per_block * (
+            scratch_type_triton.primitive_bitwidth // 8
+        )
+
+        cse_compute = functools.partial(self.cse.generate, self.compute)
+
+        if len(self.numels) != 2:
+            raise AssertionError("Unexpected tiling")
+        min_rblock = config.triton.min_split_scan_rblock
+        reduction_numel = sympy_product(
+            numel
+            for prefix, numel in self.numels.items()
+            if prefix_is_reduction(prefix)
+        )
+        pointwise_numel = sympy_product(
+            numel
+            for prefix, numel in self.numels.items()
+            if not prefix_is_reduction(prefix)
+        )
+        max_blocks = pointwise_numel * CeilDiv(reduction_numel, min_rblock)
+        nbytes = scratch_nbytes_per_block * max_blocks
+        scratch_base: str | TritonCSEVariable
+        scratch_base, _, offset = self.args.workspace(nelem=nbytes, zero_fill=True)
+        if offset != 0:
+            scratch_base = f"({scratch_base} + {self.index_to_str(offset)})"
+        runtime_rblocks = f"tl.num_programs({self.range_trees[-1].index})"
+        scratch_base = (
+            f"{scratch_base}.to(tl.pointer_type({scratch_type})) + xoffset * "
+            f"{scratch_elems_per_block} * {runtime_rblocks}"
+        )
+
+        masks = OrderedSet(f"{tree.prefix}mask" for tree in self.range_trees)
+        self.filter_masks(masks)
+        if self._load_mask:
+            raise AssertionError("ops.scan not supported inside ops.masked")
+
+        value = cse_compute(
+            f"{value}.to({compute_type})",
+            dtype=dtype,
+            shape=value.shape,
+        )
+        value = cse_compute(
+            f"tl.broadcast_to({value}, {self.dense_size_str()})",
+            dtype=dtype,
+            shape=self.dense_size_list(),
+        )
+
+        combine_helper_fn = self._lift_helper(combine_fn, (value,), (dtype,))
+        dim = self.triton_tensor_ndim() - 1
+        if dim != 0:
+            raise AssertionError(f"expected scan dim == 0, got {dim}")
+        scan_shape = value.shape
+        if scan_shape is None:
+            raise AssertionError("expected value.shape to be set")
+        reduced_shape = list(scan_shape)
+        del reduced_shape[dim]
+
+        block_sum = cse_compute(
+            f"tl.reduce({value}, {dim}, {combine_helper_fn})",
+            dtype=dtype,
+            shape=reduced_shape,
+        )
+        exclusive_prefix = self.cse.newvar(
+            dtype=dtype,
+            shape=reduced_shape,
+        )
+        if element_nbits == 64:
+            self.compute.splice(
+                f"""
+                {exclusive_prefix} = triton_helpers.exclusive_scan_decoupled_lookback_64(
+                    {scratch_base},
+                    {block_sum},
+                    {self.iteration_ranges_get_pid(self.range_trees[-1])},
+                    {combine_helper_fn},
+                )
+                """,
+                strip=True,
+            )
+
+        else:
+            if element_nbits > 32:
+                raise AssertionError(
+                    f"expected element_nbits <= 32, got {element_nbits}"
+                )
+            value_as_uint_dtype = f"tl.uint{element_nbits}"
+
+            self.compute.splice(
+                f"""
+                {exclusive_prefix} = triton_helpers.exclusive_scan_decoupled_lookback(
+                    {scratch_base},
+                    {block_sum},
+                    {self.iteration_ranges_get_pid(self.range_trees[-1])},
+                    {combine_helper_fn},
+                    DTYPE_VALUE_AS_UINT={value_as_uint_dtype},
+                    DTYPE_PACK={scratch_type},
+                )
+                """,
+                strip=True,
+            )
+        # Compute final cumsum
+        block_scan = cse_compute(
+            f"tl.associative_scan({value}, {dim}, {combine_helper_fn})",
+            dtype=dtype,
+            shape=scan_shape,
+        )
+        combined_result = cse_compute(
+            f"{combine_helper_fn}({exclusive_prefix}, {block_scan})",
+            dtype=dtype,
+            shape=scan_shape,
+        )
+        return (
+            cse_compute(
+                f"tl.where(roffset == 0, {block_scan}, {combined_result})",
+                dtype=dtype,
+                shape=scan_shape,
+            ),
+        )
+
+    def _get_heuristic(self):
+        return "split_scan"
+
+    def _get_grid_type(self) -> type[SplitScanGrid]:
+        return SplitScanGrid

.venv/lib/python3.12/site-packages/torch/_inductor/codegen/triton_utils.py

@@ -0,0 +1,387 @@
+# mypy: allow-untyped-defs
+from typing import Any
+
+import sympy
+
+import torch
+from torch.utils._sympy.symbol import symbol_is_type, SymT
+
+from .. import config
+from ..runtime.hints import AttrsDescriptorWrapper, DeviceProperties
+from ..utils import (
+    _type_of,
+    device_supports_fp64,
+    expr_fits_within_32bit,
+    triton_version_uses_attrs_dict,
+)
+from ..virtualized import V
+from .common import (
+    ArgName,
+    ConstexprArg,
+    KernelArgType,
+    SizeArg,
+    TensorArg,
+    TMADescriptorArg,
+    WorkspaceArg,
+)
+
+
+def should_unwrap_unspec_arg(name: str):
+    if V.graph.is_unspec_arg(name):
+        # Unwrap on all devices except CPU
+        if V.graph.get_current_device_or_throw().type != "cpu":
+            return True
+        # Only unwrap on CPU if the input is not used as an output
+        if name not in V.graph.mutated_buffers:
+            return True
+    return False
+
+
+def use_uint8_triton_storage_for_cuda_float8_e4m3fn(
+    dtype: torch.dtype,
+    arg_name: str | None = None,
+    *,
+    device: torch.device | None = None,
+) -> bool:
+    # Triton rejects fp8e4nv pointer types before sm89, but eager CUDA can
+    # still dequantize float8_e4m3fn values by treating storage as raw bytes.
+    if dtype != torch.float8_e4m3fn or torch.version.hip is not None:
+        return False
+    if arg_name is not None and not arg_name.startswith("in_ptr"):
+        return False
+
+    if device is None:
+        try:
+            device = V.graph.get_current_device_or_throw()
+        except AttributeError:
+            return False
+
+    if device.type != "cuda":
+        return False
+
+    return DeviceProperties.create(device).cc < 89
+
+
+def signature_of(arg: KernelArgType, *, size_dtype: str | None) -> str:
+    if isinstance(arg, TensorArg):
+        typ = _type_of(arg.dtype)
+        if should_unwrap_unspec_arg(arg.buffer):
+            # had unwrapped 0d tensor as scalar
+            new_typ = typ.lstrip("*")
+            if new_typ in ["fp16", "bf16"]:
+                return "fp32"
+            else:
+                return new_typ
+        elif use_uint8_triton_storage_for_cuda_float8_e4m3fn(arg.dtype, arg.name):
+            return "*u8"
+        else:
+            return typ
+    if isinstance(arg, SizeArg):
+        if arg.expr is None:
+            if triton_version_uses_attrs_dict():
+                # In newer versions of Triton, the signature includes "None" args
+                # and their type is marked as "constexpr"
+                return "constexpr"
+            else:
+                # In older versions of Triton...
+                # From triton/runtime/jit.py
+                # `None` is nullptr.  Implicitly convert to *i8.
+                return "*i8"
+        elif _arg_equals_1(arg) and triton_version_uses_attrs_dict():
+            # In new versions of Triton, if we have an equal-to-1 arg that's marked as a constant,
+            # it should be marked as "constexpr" in the signature.
+            return "constexpr"
+        elif isinstance(arg.expr, (float, sympy.Float)):
+            # Python floats are natively fp64, so use fp64 to preserve precision
+            if config._use_fp64_for_unbacked_floats and device_supports_fp64(
+                V.graph.current_device
+            ):
+                return "fp64"
+            return "fp32"
+        elif isinstance(arg.expr, sympy.Symbol) and symbol_is_type(
+            arg.expr, (SymT.UNBACKED_FLOAT)
+        ):
+            # Unbacked floats from .item() should preserve fp64 precision
+            if config._use_fp64_for_unbacked_floats and device_supports_fp64(
+                V.graph.current_device
+            ):
+                return "fp64"
+            return "fp32"
+        elif isinstance(arg.expr, bool):
+            return "i1"
+
+        # if this is an integer
+        if size_dtype == "tl.int32":
+            return "i32"
+        elif size_dtype == "tl.int64":
+            return "i64"
+        elif size_dtype is None:
+            # no hint: we'll see if we know that this is a 32-bit int, and guard if possible.
+            int_max = torch.iinfo(torch.int32).max
+            if expr_fits_within_32bit(arg.expr):
+                V.graph.sizevars.check_leq(arg.expr, int_max)
+                return "i32"
+            else:
+                return "i64"
+        else:
+            raise NotImplementedError(f"unhandled size_dtype {size_dtype}")
+    if isinstance(arg, WorkspaceArg):
+        return _type_of(arg.dtype)
+    if isinstance(arg, TMADescriptorArg):
+        if arg.api_type == "experimental":
+            return "nvTmaDesc"
+        else:
+            # https://github.com/triton-lang/triton/blob/9695baed9b46cf957e08b157bb4133f4a4b331c5/python/triton/runtime/jit.py#L360-L363
+            if arg.api_type != "stable":
+                raise AssertionError(
+                    f"expected api_type == 'stable', got {arg.api_type}"
+                )
+            if arg.block_shape is None:
+                raise AssertionError("expected block_shape to not be None")
+            if arg.dtype is None:
+                raise AssertionError("expected dtype to not be None")
+            inner = _type_of(arg.dtype)[1:]  # strip the `*`: *fp32 -> fp32
+            return f"tensordesc<{inner}{list(arg.block_shape)}>"
+    if isinstance(arg, ConstexprArg):
+        return "constexpr"
+    raise NotImplementedError(f"unhandled {type(arg)}: {arg}")
+
+
+def non_constexpr_signature(signature):
+    new_signature = []
+    for arg in signature:
+        if not isinstance(arg, ConstexprArg):
+            new_signature.append(arg)
+
+    return new_signature
+
+
+def select_tile_hint(size_hints, signature):
+    """Pick TileHint.SQUARE vs TileHint.DEFAULT for 2D pointwise; None for 1D.
+
+    SQUARE applies when the kernel has exactly 2 size hints and 4 non-constexpr
+    signature args (input, output, and 2 numel args -> a square 2D tile).
+    """
+    from torch._inductor.runtime.hints import TileHint
+
+    if len(size_hints) != 2:
+        return None
+    if len(non_constexpr_signature(signature)) == 4:
+        return TileHint.SQUARE
+    return TileHint.DEFAULT
+
+
+def signature_to_meta(
+    signature: list[KernelArgType],
+    *,
+    size_dtype: str | None,
+    argdefs: list[ArgName],
+    indices: list[int] | None = None,
+    is_template: bool = False,
+) -> dict[str, str]:
+    if indices is None:
+        indices = list(range(len(signature)))
+
+    def _decide_tl_dtype(arg):
+        # Even if the ks0 symbol itself is within tl.int32 range, it's
+        # risky to use tl.int32 dtype since we may have ks0*ks1 later
+        # for kernels like torch.mean when dynamic shape is enabled.
+        #
+        # Check config.triton.use_block_ptr, since Triton block pointer
+        # does not support 64bit indexing:
+        # https://gist.github.com/shunting314/6a41c776171720ce4561f202dcde0ad6
+        #
+        # If the triton metadata is for a template, don't use tl.int64 index.
+        # Templates like flex attention/decoding uses block pointers which
+        # does not support 64 bit indexing.
+        if (
+            not config.triton.use_block_ptr
+            and not is_template
+            and isinstance(arg, SizeArg)
+            and arg.name.startswith("ks")
+        ):
+            return "tl.int64"
+        return size_dtype
+
+    return {
+        argdefs[i].name: signature_of(arg, size_dtype=_decide_tl_dtype(arg))
+        for i, arg in zip(indices, signature)
+    }
+
+
+def _get_buffer_layout(buf_name: str) -> "torch._inductor.ir.Layout":
+    """Get the layout for a buffer, handling both scheduler buffers and graph inputs."""
+    if V.graph.scheduler:
+        layout = V.graph.scheduler.get_buffer_layout(buf_name)
+    else:
+        buffer = V.graph.try_get_buffer(buf_name)
+        # output arg
+        if not buffer:
+            if buf_name != V.kernel.output_node.name:
+                raise AssertionError(
+                    f"expected buf_name == output_node.name, got {buf_name}"
+                )
+            layout = V.kernel.output_node.layout
+        else:
+            layout = buffer.get_layout()
+    return layout
+
+
+def is_unaligned_buffer_name(buf_name: str) -> bool:
+    if buf_name in V.graph.unaligned_buffers:
+        return True
+
+    if buf_name in V.graph.graph_inputs:
+        # See Note: [Input Alignment handling in Inductor]
+        # For graph inputs that is not recorded in V.graph.unaligned_buffers,
+        # we know for sure the tensor is aligned.
+        return False
+
+    if buf_name in V.graph.constants:
+        # all constants are assumed to be aligned
+        return False
+
+    layout = _get_buffer_layout(buf_name)
+    if isinstance(layout, torch._inductor.ir.NonOwningLayout):
+        return not layout.maybe_guard_aligned()
+    else:
+        return False
+
+
+def is_unaligned_buffer(arg: TensorArg):
+    return is_unaligned_buffer_name(arg.buffer)
+
+
+def _arg_equals_1(arg: KernelArgType) -> bool:
+    return (
+        isinstance(arg, SizeArg)
+        and isinstance(arg.expr, (int, sympy.Integer))
+        and V.graph.sizevars.statically_known_equals(arg.expr, 1)  # type: ignore[arg-type]
+    )
+
+
+def equal_1_arg_indices(
+    args: list[KernelArgType],
+    *,
+    indices: list[int] | None = None,
+) -> tuple[int, ...]:
+    if indices is None:
+        indices = list(range(len(args)))
+
+    equal_to_1 = tuple(i for i, arg in zip(indices, args) if _arg_equals_1(arg))
+
+    return equal_to_1
+
+
+def _is_tensor_within_2gb(arg: TensorArg) -> bool:
+    """Check if a tensor argument's storage is provably within 2GB.
+
+    Mirrors HIPBackend.is_within_2gb() but uses compile-time symbolic analysis
+    instead of runtime tensor inspection. This enables canonicalize_pointers to
+    decompose pointer arithmetic into (splat(base), offset) form for buffer ops.
+    """
+    MAX_BYTES = 2**31 - 1
+    try:
+        # Graph inputs aren't tracked by the scheduler; get their layout
+        # from the graph_inputs dict to avoid KeyError in get_buffer_layout.
+        if arg.buffer in V.graph.graph_inputs:
+            inp = V.graph.graph_inputs[arg.buffer]
+            if hasattr(inp, "get_layout"):
+                layout = inp.get_layout()
+            else:
+                return False
+        else:
+            layout = _get_buffer_layout(arg.buffer)
+        storage_bytes = layout.storage_size() * arg.dtype.itemsize
+        return V.graph.sizevars.statically_known_true(storage_bytes <= MAX_BYTES)
+    except Exception:
+        return False
+
+
+def config_of(
+    args: list[KernelArgType],
+    *,
+    indices: list[int] | None = None,
+    pointer_range_override: tuple[int, ...] | None = None,
+    skip_cpp_wrapper_input_tensor_alignment: bool = False,
+) -> Any:
+    if indices is None:
+        indices = list(range(len(args)))
+
+    def is_aligned(x: KernelArgType, alignment: int, include_tensor: bool) -> bool:
+        """
+        Roughly follow triton code here:
+        https://github.com/triton-lang/triton/blob/5282ed890d453e10b9ee30076ef89115dd197761/python/triton/runtime/jit.py#L208-L222
+        """
+        if isinstance(x, TensorArg):
+            if include_tensor:
+                offset_aligned = V.graph.sizevars.statically_known_multiple_of(
+                    x.offset * x.dtype.itemsize,
+                    alignment,  # type: ignore[arg-type]
+                )
+                return offset_aligned and not is_unaligned_buffer(x)
+            else:
+                return False
+        if isinstance(x, SizeArg):
+            # TODO(voz): These are kinda redundant, if we can solve out statically_known_multiple_of with
+            # _maybe_evaluate_static...
+            if x.name.startswith("load_seed_offset"):
+                return False
+            if x.expr is None:
+                return False
+            if isinstance(x.expr, (float, bool)):
+                return False
+            return V.graph.sizevars.statically_known_multiple_of(x.expr, alignment)  # type: ignore[arg-type]
+        if isinstance(x, WorkspaceArg):
+            # We allocate the workspace ourselves, so it is always aligned
+            return True
+        if isinstance(x, (TMADescriptorArg, ConstexprArg)):
+            return False
+        raise NotImplementedError(f"unhandled {type(x)}: {x}")
+
+    def include_tensor_alignment(arg: KernelArgType) -> bool:
+        if (
+            not skip_cpp_wrapper_input_tensor_alignment
+            or not V.graph.cpp_wrapper
+            or V.graph.aot_mode
+            or not isinstance(arg, TensorArg)
+            or arg.buffer not in V.graph.graph_inputs
+        ):
+            return True
+
+        try:
+            input_idx = V.graph.graph_input_names.index(arg.buffer)
+        except ValueError:
+            return True
+        return input_idx not in (V.graph.inputs_to_check or ())
+
+    if config.triton.divisible_by_16:
+        divisible_by_16 = tuple(
+            i
+            for i, arg in zip(indices, args)
+            if is_aligned(
+                arg,
+                alignment=16,
+                include_tensor=include_tensor_alignment(arg),
+            )
+        )
+    else:
+        divisible_by_16 = ()
+
+    equal_to_1 = equal_1_arg_indices(args, indices=indices)
+
+    # On AMD/HIP, tag tensor args whose storage fits in 2GB so Triton
+    # can use 32-bit pointer offsets and emit buffer load/store ops.
+    if pointer_range_override is not None:
+        pointer_range_32 = pointer_range_override
+    elif torch.version.hip is not None:
+        pointer_range_32 = tuple(
+            i
+            for i, arg in zip(indices, args)
+            if isinstance(arg, TensorArg) and _is_tensor_within_2gb(arg)
+        )
+    else:
+        pointer_range_32 = ()
+
+    # pyrefly: ignore [bad-argument-count, bad-argument-type]
+    return AttrsDescriptorWrapper(divisible_by_16, equal_to_1, pointer_range_32)

.venv/lib/python3.12/site-packages/torch/_inductor/codegen/wrapper_fxir.py

@@ -0,0 +1,1412 @@
+import dataclasses
+import functools
+import logging
+import operator
+import textwrap
+from collections import Counter
+from collections.abc import Callable, Iterable, Sequence
+from typing import Any
+
+import sympy
+
+import torch
+from torch._export.passes._node_metadata_hook import (
+    _node_metadata_hook,
+    _set_node_metadata_hook,
+)
+from torch._higher_order_ops.triton_kernel_wrap import (
+    TraceableTritonKernelWrapper,
+    tracing_triton_hopifier_singleton,
+    triton_kernel_wrapper_mutation,
+)
+from torch._inductor.codecache import LambdaFuture, PyCodeCache
+from torch._inductor.runtime.triton_heuristics import CachingAutotuner
+from torch._inductor.select_algorithm import extern_kernels  # noqa: F401
+from torch._inductor.utils import convert_to_symint
+from torch._inductor.virtualized import V
+from torch._library.triton import wrap_triton
+from torch.fx import GraphModule
+from torch.fx.experimental.symbolic_shapes import (
+    CallMethodKey,
+    ConvertIntKey,
+    DivideByKey,
+)
+from torch.utils import _pytree as pytree
+from torch.utils._ordered_set import OrderedSet
+from torch.utils._sympy.functions import FloorDiv
+from torch.utils._sympy.interp import _run_sympy_handler, sympy_interp
+from torch.utils._sympy.reference import OptimizedPythonReferenceAnalysis
+from torch.utils._sympy.solve import try_solve
+
+from .. import config, ir
+from ..runtime.triton_compat import Config
+from ..utils import cache_property_on_self, LineContext, ValueWithLineMap
+from .common import (
+    CodegenSymbol,
+    FileBackedGraphModule,
+    WorkspaceArg,
+    WorkspaceZeroMode,
+)
+from .wrapper import (
+    AllocateLine,
+    BufferLike,
+    CommentLine,
+    DynamicScalarLine,
+    EnterDeviceContextManagerLine,
+    EnterSubgraphLine,
+    ExitDeviceContextManagerLine,
+    ExitSubgraphLine,
+    ExternKernelAllocLine,
+    ExternKernelOutLine,
+    FreeIfNotReusedLine,
+    FreeLine,
+    IndexPutFallbackLine,
+    KernelCallLine,
+    KernelDefinitionLine,
+    Line,
+    MultiOutputLine,
+    NullLine,
+    PythonWrapperCodegen,
+    ReinterpretLine,
+    ReuseLine,
+    ScatterFallbackLine,
+    SubgraphPythonWrapperCodegen,
+    SwitchLine,
+    SymbolicCallArg,
+    SymbolicCallArgLine,
+    UnbackedSymbolDefsLine,
+    WrapperLine,
+)
+
+
+aten = torch.ops.aten
+log = logging.getLogger(__name__)
+
+
+@dataclasses.dataclass
+class SymbolBuffer(CodegenSymbol):
+    """
+    Represents a symbolic graph input. Expressions more complex than a single
+    sympy.Symbol require a name.
+    """
+
+    expr: sympy.Expr
+    name: str | None = None
+
+    def get_name(self) -> str:
+        if self.name is not None:
+            return self.name
+        if not isinstance(self.expr, sympy.Symbol):
+            raise AssertionError(f"expression requires a name: {self.expr}")
+        return str(self.expr)
+
+    def get_example(self) -> torch.Tensor | torch.SymInt:
+        sym_int = convert_to_symint(self.expr)
+        if not isinstance(sym_int, torch.SymInt):
+            raise AssertionError(f"expected torch.SymInt, got {type(sym_int)}")
+        return sym_int
+
+
+CodegenBuffer = BufferLike | SymbolBuffer
+
+
+@dataclasses.dataclass
+class TritonKernel:
+    """
+    Stores metadata about Triton kernels for use in FX.
+    """
+
+    tuner: CachingAutotuner
+    wrapped: TraceableTritonKernelWrapper
+
+
+def replace_floor_div(expr: sympy.Expr) -> sympy.Expr:
+    """
+    Replace sympy.floor with FloorDiv.
+    """
+
+    def replace(expr: sympy.Expr) -> sympy.Expr:
+        expr = sympy.together(expr)
+
+        # Division is represented as a Mul with a Rational factor or a Pow with negative
+        # exponent. We convert floor(Mul(...)) to FloorDiv(numerator, denominator) by
+        # partitioning factors into the numerator and denominator.
+        (numerator, denominator) = (sympy.S.One,) * 2
+        for arg in sympy.Mul.make_args(expr):
+            if isinstance(arg, sympy.Rational):
+                numerator *= arg.numerator
+                denominator *= arg.denominator
+            elif isinstance(arg, sympy.Pow) and arg.exp.is_negative:
+                denominator *= arg.base**-arg.exp
+            else:
+                numerator *= arg
+
+        return FloorDiv(numerator, denominator)
+
+    return expr.replace(sympy.floor, replace)
+
+
+class WrapperFxCodegen(PythonWrapperCodegen):
+    """
+    Backend to generate wrapper code as an FX IR graph.
+    """
+
+    supports_caching = False
+
+    def __init__(self, *args: Any, **kwargs: Any):
+        super().__init__(*args, **kwargs)
+        self.subgms: dict[str, torch.fx.GraphModule] = {}
+
+    def codegen_inputs(self) -> None:
+        """
+        This would generate code for symbolic input shapes, strides, etc.
+        Since the FX converter handles this, do nothing here.
+        """
+
+    def codegen_switch(self, node: ir.Switch) -> None:
+        """
+        Switch/cond codegen normally emits a number of different wrapper lines.
+        Instead, FX conversion uses a dedicated line for the whole node.
+        """
+        self.writeline(SwitchLine(self, node))
+        for subgraph in node.branches:  # pyrefly: ignore [not-iterable]
+            self.codegen_subgraph_common(subgraph)
+
+    def define_subgraph_launcher_fn(
+        self, name: str, subgraph_code: ValueWithLineMap | FileBackedGraphModule
+    ) -> None:
+        """
+        Record subgms as they're generated.
+        """
+        if not isinstance(subgraph_code, FileBackedGraphModule):
+            raise AssertionError(
+                f"expected FileBackedGraphModule, got {type(subgraph_code)}"
+            )
+        self.subgms[name] = subgraph_code.gm
+
+    @property
+    @cache_property_on_self
+    def is_subgraph(self) -> bool:
+        return isinstance(self, SubgraphPythonWrapperCodegen)
+
+    def get_fx_graph_inputs(
+        self,
+    ) -> dict[str, ir.TensorBox | ir.TorchBindObject | sympy.Expr | None]:
+        """
+        Get the input nodes corresponding to FX graph placeholders.
+        """
+
+        if V.aot_compilation and not self.is_subgraph:
+            # AOT graphs must match the signature of the input module.
+            return {
+                node.name: V.graph.graph_inputs.get(node.name)
+                for node in V.graph.module.graph.find_nodes(op="placeholder")  # type: ignore[operator, union-attr]
+            }
+
+        return self.get_graph_inputs()
+
+    def _generate(self, is_inference: bool) -> tuple[FileBackedGraphModule, None]:
+        self.run_wrapper_ir_passes(is_inference)
+
+        prologue = "\n".join(
+            [
+                self.imports.getvalue(),
+                self.header.getvalue(),
+            ]
+        )
+        gm = FxConverter(
+            lines=self.lines,
+            prologue=prologue,
+            graph_inputs=self.get_fx_graph_inputs(),
+            graph_outputs=self.get_graph_outputs(),
+            subgms=self.subgms,
+            is_subgraph=self.is_subgraph,
+        ).generate()
+
+        compiled_fn = self.compile_graph(gm)
+
+        return FileBackedGraphModule(gm, compiled_fn), None
+
+    def compile_graph(self, gm: GraphModule) -> Callable[..., Any]:
+        """
+        Converts the graph module into a runnable function. The default implementation
+        is simply an interpreter calling kernels in eager mode. Derived backends can
+        override this to do further compilation.
+        """
+        return gm.forward
+
+    def write_header(self) -> None:
+        """
+        Python subgraphs normally lack headers.
+        Override this behavior to generate prologues for FX subgraphs.
+        """
+        PythonWrapperCodegen.write_header(self)
+
+    def register_alignment_check_inputs(self) -> None:
+        """FXIR does not emit deferred alignment copies.
+        Alignment is handled by the runtime wrapper."""
+
+    def codegen_deferred_alignment_copies(
+        self, input_names: Iterable[str], stream: int = 0
+    ) -> None:
+        """FXIR does not emit deferred alignment copies."""
+
+    @classmethod
+    def create(
+        cls: type["WrapperFxCodegen"],
+        is_subgraph: bool,
+        subgraph_name: str | None,
+        parent_wrapper: PythonWrapperCodegen | None,
+        partition_signatures: ir.GraphPartitionSignature | None = None,
+    ) -> "WrapperFxCodegen":
+        if is_subgraph:
+            if subgraph_name is None:
+                raise AssertionError("subgraph_name must not be None for subgraphs")
+            if parent_wrapper is None:
+                raise AssertionError("parent_wrapper must not be None for subgraphs")
+
+            # Subgraphs override some methods of PythonWrapperCodegen.
+            # Apply these overrides to the user-provided class, with priority given to
+            # user-provided methods.
+            class SubgraphFxWrapperCodegen(cls, SubgraphPythonWrapperCodegen):  # type: ignore[misc,valid-type]
+                def compile_graph(self, gm: GraphModule) -> Callable[..., Any]:
+                    """
+                    Skip graph compilation for subgraphs.
+                    """
+
+                    def crash_if_run(*args: Any) -> None:
+                        raise NotImplementedError("Cannot run a subgraph in isolation!")
+
+                    return crash_if_run
+
+            return SubgraphFxWrapperCodegen(
+                subgraph_name, parent_wrapper, partition_signatures
+            )
+
+        return cls()
+
+
+@dataclasses.dataclass
+class FxConverter:
+    """
+    Generates FX IR from Wrapper IR. As each instance is only meant to be used once, the
+    input and output code are stored as attributes.
+    """
+
+    lines: list[Line]
+    prologue: str
+    graph_inputs: dict[str, ir.TensorBox | ir.TorchBindObject | sympy.Expr | None]
+    graph_outputs: list[ir.IRNode]
+    subgms: dict[str, torch.fx.GraphModule]
+    is_subgraph: bool
+
+    def __post_init__(self) -> None:
+        graph = torch.fx.Graph()
+        self.gm = GraphModule({}, graph)  # Wrapper FX IR.
+        self.buffer_to_node: dict[
+            str | None, torch.fx.Node
+        ] = {}  # Symbol table for codegen.
+        self.kernels: dict[str, TritonKernel] = {}  # Table to store Triton kernels.
+        self._unique_symbol_ids: Counter[str] = Counter()
+        self.tracer = torch.fx.proxy.GraphAppendingTracer(graph)
+        self.expr_to_proxy: dict[sympy.Expr, torch.fx.Proxy] = {}
+
+    def _import_kernel(self, code: str, kernel_name: str) -> CachingAutotuner:
+        """
+        Imports a kernel from source, possibly autotuning block parameters.
+        """
+        module_code = "\n".join([self.prologue, code])
+        mod = PyCodeCache.load(module_code)
+        kernel = getattr(mod, kernel_name)
+
+        if isinstance(kernel, LambdaFuture):
+            kernel = kernel.result()
+
+        if not isinstance(kernel, CachingAutotuner):
+            raise NotImplementedError(
+                textwrap.dedent(f"""
+                Unsupported type for kernel {kernel_name}: {type(kernel)}.
+                FX conversion only supports Triton kernels.
+            """)
+            )
+
+        # Parallel compile workers strip the Python function from the pickled
+        # JITFunction. FXIR stores the JITFunction in the Triton HOP side table,
+        # so reload it in the parent before runtime execution can need it.
+        kernel._ensure_kernel_loaded()
+
+        return kernel
+
+    def _create_as_strided(
+        self,
+        input_node: torch.fx.Node,
+        size: tuple[Any, ...],
+        stride: tuple[Any, ...],
+        offset: int | sympy.Expr,
+    ) -> torch.fx.Node:
+        if isinstance(offset, sympy.Expr):
+            offset = replace_floor_div(offset)
+        return self.gm.graph.call_function(
+            torch.as_strided,
+            args=(
+                input_node,
+                self._generate_sym_nodes(size),
+                self._generate_sym_nodes(stride),
+                self._generate_sym_node(offset),
+            ),
+        )
+
+    def _record_allocation(self, buffer: CodegenBuffer, node: torch.fx.Node) -> None:
+        """
+        Updates the symbol table to record that an Inductor buffer maps to the result of
+        an FX node.
+        """
+        if node in self.buffer_to_node:
+            raise AssertionError(f"node already recorded in buffer_to_node: {node}")
+        self.buffer_to_node[buffer.get_name()] = node
+
+    def _free(self, buffer: CodegenBuffer | ir.TorchBindObject) -> None:
+        """
+        Removes the buffer from the symbol table.
+        """
+        name = buffer.get_name()
+        del self.buffer_to_node[name]
+
+    def _lookup_args(self, args: tuple[Any, ...]) -> tuple[Any, ...]:
+        """
+        Maps call args back to FX nodes.
+        """
+        return tuple(
+            self.buffer_to_node[arg]
+            if isinstance(arg, str)
+            else arg.inner_expr
+            if isinstance(arg, SymbolicCallArg)
+            else arg
+            for arg in args
+        )
+
+    def _get_buffer(self, node: ir.IRNode) -> CodegenBuffer:
+        """
+        Extract buffer data from an IR node.
+        """
+        if isinstance(node, (ir.Buffer, WorkspaceArg)):
+            return node
+        elif isinstance(node, (ir.BaseView, ir.MutableBox)):
+            return self._get_buffer(node.data)
+        elif isinstance(node, sympy.Symbol):
+            return SymbolBuffer(node)
+        else:
+            raise NotImplementedError(f"Unable to extract buffer from node: {node}")
+
+    def _generate_size_proxy(
+        self, node: torch.fx.Node, expr: sympy.Expr
+    ) -> torch.fx.Proxy:
+        proxy = torch.fx.Proxy(node, tracer=self.tracer)
+        self.expr_to_proxy[expr] = proxy
+        return proxy
+
+    def _generate_graph_inputs(self) -> None:
+        """
+        Converts graph inputs to FX placeholders.
+        """
+
+        for name, ir_node in self.graph_inputs.items():
+            if ir_node is None:
+                # Create dummy input nodes to match the input signature
+                self.gm.graph.placeholder(name)
+                continue
+
+            # Introduce a new symbol for constant inputs.
+            is_constant = isinstance(ir_node, (int, float, sympy.Integer, sympy.Float))
+
+            # Special handling for dynamic shapes which are not simple symbols.
+            is_expr = isinstance(ir_node, sympy.Expr) and not isinstance(
+                ir_node, (sympy.Symbol, sympy.Integer, sympy.Float)
+            )
+            if is_expr and ir_node.is_integer is not True:
+                raise NotImplementedError(
+                    f"Unsupported non-integer symbolic graph input: {ir_node}"
+                )
+
+            if is_constant:
+                buffer = SymbolBuffer(sympy.Symbol(name, is_integer=True))
+            elif is_expr:
+                buffer = SymbolBuffer(ir_node, name=name)
+            else:
+                buffer = self._get_buffer(ir_node)
+            placeholder_node = self.gm.graph.placeholder(buffer.get_name())
+            placeholder_node.meta["val"] = (
+                ir_node if is_constant else buffer.get_example()
+            )
+            self._record_allocation(buffer, placeholder_node)
+
+            # Record symbol definitions for dynamic shapes.
+            if isinstance(ir_node, sympy.Expr) and not is_constant:
+                self._generate_size_proxy(placeholder_node, ir_node)
+
+    def _generate_graph_input_shapes(self) -> None:
+        """
+        Generate nodes creating symints that are part of graph input
+        shape/strides.
+        """
+
+        def _codegen_symbol(
+            sym_or_exp: sympy.Symbol | sympy.Expr,
+            base_node: torch.fx.Node,
+            target: torch._ops.OpOverload,
+            dim: int,
+        ) -> None:
+            def codegen_proxy() -> torch.fx.Proxy:
+                size_node = self.gm.graph.call_function(target, (base_node, dim))
+                size_proxy = self._generate_size_proxy(size_node, sym_or_exp)
+                return size_proxy
+
+            if isinstance(sym_or_exp, sympy.Symbol):
+                if sym_or_exp in self.expr_to_proxy:
+                    return
+                codegen_proxy()
+
+            elif isinstance(sym_or_exp, sympy.Integer):
+                return
+
+            elif isinstance(sym_or_exp, sympy.Expr):
+                # Check if we need to solve for an undefined symbol.
+                undefined_symbols = [
+                    sym
+                    for sym in sym_or_exp.free_symbols
+                    if sym not in self.expr_to_proxy
+                ]
+                if len(undefined_symbols) == 0:
+                    self._sympy_interp(sym_or_exp)
+                    return
+                elif len(undefined_symbols) > 1:
+                    raise NotImplementedError(
+                        f"Underdetermined input expression: {sym_or_exp}"
+                    )
+
+                # Define a new symbol for the input size.
+                size_proxy = codegen_proxy()
+                size_symbol = sympy.Symbol(
+                    size_proxy.node.name, integer=True, nonnegative=True
+                )
+                self.expr_to_proxy[size_symbol] = size_proxy
+
+                self._define_symbol_by_solving(
+                    sym_or_exp, size_symbol, undefined_symbols[0]
+                )
+
+        for ir_node in self.graph_inputs.values():
+            if isinstance(ir_node, ir.TensorBox):
+                buffer = self._get_buffer(ir_node)
+                placeholder_node = self.buffer_to_node[buffer.get_name()]
+
+                for dim, size in enumerate(ir_node.get_size()):
+                    _codegen_symbol(
+                        size, placeholder_node, torch.ops.aten.sym_size.int, dim
+                    )
+                for dim, stride in enumerate(ir_node.get_stride()):
+                    _codegen_symbol(
+                        stride, placeholder_node, torch.ops.aten.sym_stride.int, dim
+                    )
+
+        # A compound input binds its whole expression to one placeholder, so a
+        # symbol appearing only inside it has no node of its own. Recover it
+        # from that placeholder, after the loop above has defined every symbol
+        # the tensor shapes determine.
+        for ir_node in self.graph_inputs.values():
+            if not isinstance(ir_node, sympy.Expr) or isinstance(ir_node, sympy.Symbol):
+                continue
+            proxy = self.expr_to_proxy.get(ir_node)
+            if proxy is None:
+                continue
+            undefined = [
+                sym for sym in ir_node.free_symbols if sym not in self.expr_to_proxy
+            ]
+            if len(undefined) == 0:
+                continue
+            elif len(undefined) > 1:
+                # One bound value cannot determine several symbols. This is a
+                # branch closing over an expression whose symbols come from
+                # tensors it does not take, such as y.shape[0] + z.shape[0].
+                raise NotImplementedError(
+                    f"Compound input {ir_node} leaves these symbols undefined: "
+                    f"{sorted(undefined, key=str)}"
+                )
+
+            # A tensor-derived FX node does not reserve its symbol's name, so a
+            # Dummy is what keeps the anchor from colliding with one.
+            anchor = sympy.Dummy(proxy.node.name, integer=True)
+            self.expr_to_proxy[anchor] = proxy
+            self._define_symbol_by_solving(ir_node, anchor, undefined[0])
+
+    def _generate_graph_constants(self) -> None:
+        for name, value in V.graph.constants.items():
+            node = self.gm.graph.get_attr(name)
+            node.meta["val"] = value
+            setattr(self.gm, name, value)
+            self.buffer_to_node[name] = node
+
+    def _generate_buffer(self, node: ir.IRNode) -> torch.fx.Node | None:
+        """
+        Generates FX IR for transformations on a buffer, such as ReinterpretView.
+        Does nothing if no such transformations are present.
+        """
+
+        if isinstance(node, ir.ShapeAsConstantBuffer):
+            # Generate FX nodes to compute the shape expression.
+            return self._sympy_interp(node.expr).node
+
+        def generate_to_buffer(node: ir.IRNode) -> BufferLike | None:
+            if isinstance(node, (ir.Buffer, WorkspaceArg)):
+                return node
+            elif isinstance(node, ir.NoneAsConstantBuffer):
+                return None
+            elif isinstance(node, ir.MutableBox):
+                return generate_to_buffer(node.data)
+            elif isinstance(node, ir.ReinterpretView):
+                # We need to introduce a new symbol if the output is a ReinterpretView.
+                # Use a WorkspaceArg for this.
+                buffer = self._get_buffer(node.data)
+                if not isinstance(buffer, (ir.Buffer, WorkspaceArg)):
+                    raise AssertionError(
+                        f"expected ir.Buffer or WorkspaceArg, got {type(buffer)}"
+                    )
+                unique_name = self.gm.graph._graph_namespace.create_name(
+                    f"{buffer.get_name()}_view", None
+                )
+                device = buffer.get_device()
+                if not device:
+                    raise AssertionError(f"buffer has no device: {buffer}")
+                reused_as = WorkspaceArg(
+                    count=buffer.get_size(),
+                    zero_mode=WorkspaceZeroMode.UNINITIALIZED,
+                    device=device,
+                    outer_name=unique_name,
+                    dtype=buffer.get_dtype(),
+                )
+
+                # Generate FX IR for the view.
+                self._generate_reinterpret_helper(buffer, reused_as, node.layout)
+
+                return reused_as
+            else:
+                raise NotImplementedError(f"Unrecognized buffer/view node: {node}")
+
+        buffer = generate_to_buffer(node)
+        return self.buffer_to_node[buffer.get_name()] if buffer is not None else None
+
+    def _generate_outputs(
+        self,
+    ) -> torch.fx.Node | None | list[torch.fx.Node | None]:
+        """
+        Generate FX IR for graph outputs.
+        """
+        output_nodes = [
+            self._generate_buffer(node) for idx, node in enumerate(self.graph_outputs)
+        ]
+
+        # Parent graphs with single return elements don't use a tuple.
+        output_value = (
+            output_nodes[0]
+            if len(output_nodes) == 1 and not self.is_subgraph
+            else output_nodes
+        )
+
+        return output_value
+
+    def _generate_subgm_getattrs(self) -> None:
+        """
+        Generate getattr nodes for subgms.
+        """
+
+        def generate_getattr(name: str, subgm: torch.fx.GraphModule) -> torch.fx.Node:
+            self.gm.add_submodule(name, subgm)
+            node = self.gm.graph.get_attr(name)
+            node.meta["val"] = subgm
+            return node
+
+        self.subgm_getattrs = {
+            name: generate_getattr(name, subgm) for name, subgm in self.subgms.items()
+        }
+
+    def _get_subgm_attr(self, subgraph: ir.Subgraph) -> torch.fx.Node:
+        """
+        Look up the getattr node for a subgraph.
+        """
+        graph = subgraph.graph
+        if graph is None:
+            raise AssertionError("subgraph.graph must not be None")
+        return self.subgm_getattrs[graph.name]
+
+    def generate(self) -> torch.fx.GraphModule:
+        """
+        Main entrypoint for FX codegen.
+        """
+        self._generate_graph_inputs()
+        self._generate_graph_constants()
+        self._generate_subgm_getattrs()
+
+        with _set_node_metadata_hook(
+            self.gm,
+            functools.partial(_node_metadata_hook, fake_mode=V.fake_mode),
+        ):
+            self._generate_graph_input_shapes()
+
+            # Generate FX IR from Wrapper IR lines.
+            for line in self.lines:
+                if isinstance(line, WrapperLine):
+                    line.codegen_fx(self)(line)
+                elif isinstance(line, LineContext):
+                    # Ignore line context in FX IR.
+                    pass
+                else:
+                    raise NotImplementedError(
+                        textwrap.dedent(
+                            f"""
+                        Found line of unrecognized type '{type(line)}':
+                            '{line}'
+
+                        FX conversion only supports Wrapper IR lines.
+                        """
+                        )
+                    )
+
+            output = self._generate_outputs()
+
+        self.gm.graph.output(output)
+        self.gm.recompile()
+        return self.gm
+
+    def _sympy_interp(self, expr: sympy.Expr) -> torch.fx.Proxy:
+        # hash cons
+        if expr in self.expr_to_proxy:
+            return self.expr_to_proxy[expr]
+        # base cases, don't cache
+        if isinstance(
+            expr,
+            (
+                sympy.Integer,
+                sympy.Number,
+                sympy.Symbol,
+                sympy.logic.boolalg.BooleanAtom,
+            ),
+        ):
+            return sympy_interp(
+                OptimizedPythonReferenceAnalysis, self.expr_to_proxy, expr
+            )
+
+        # hash cons on arguments, run expr handler
+        self.expr_to_proxy[expr] = _run_sympy_handler(
+            OptimizedPythonReferenceAnalysis,
+            [self._sympy_interp(arg) for arg in expr.args],
+            expr,
+        )
+        return self.expr_to_proxy[expr]
+
+    def _define_symbol_by_solving(
+        self, expr: sympy.Expr, anchor: sympy.Symbol, symbol: sympy.Symbol
+    ) -> None:
+        """
+        Define symbol by solving expr == anchor, which already maps to a proxy.
+        """
+        # A returned solution directly defines the symbol in terms of the anchor.
+        solution = try_solve(sympy.Eq(expr, anchor), symbol)
+        if solution is None:
+            raise NotImplementedError(
+                f"Cannot solve input expression {expr} for {symbol}"
+            )
+
+        symbol_expr = solution[1]
+        # If the symbol is an integer, division becomes FloorDiv.
+        if symbol.is_integer:
+            symbol_expr = replace_floor_div(sympy.floor(symbol_expr))
+
+        # Generate FX for the symbol.
+        self._sympy_interp(symbol_expr)
+        self.expr_to_proxy[symbol] = self.expr_to_proxy[symbol_expr]
+
+    def _generate_sym_node(self, s: int | sympy.Expr) -> int | torch.fx.Node:
+        if isinstance(s, (int, sympy.Integer)):
+            return int(s)
+        elif isinstance(s, sympy.Symbol):
+            if s not in self.expr_to_proxy:
+                raise AssertionError(
+                    f"Could not find a node corresponding to the symbol {s}"
+                )
+            return self.expr_to_proxy[s].node
+        elif isinstance(s, sympy.Expr):
+            return self._sympy_interp(s).node
+
+        elif isinstance(s, torch.fx.Node):
+            return s
+
+        else:
+            raise ValueError(f"{s} of type {type(s)} is not a valid input")
+
+    def _generate_sym_nodes(
+        self, shape: Sequence[sympy.Expr]
+    ) -> list[int | torch.fx.Node]:
+        return [self._generate_sym_node(s) for s in shape]
+
+    def _generate_allocate(self, line: WrapperLine) -> None:
+        if not isinstance(line, AllocateLine):
+            raise AssertionError(f"expected AllocateLine, got {type(line)}")
+        buffer = line.node
+        name = buffer.get_name()
+        if name in V.graph.removed_buffers:
+            raise AssertionError(f"buffer {name} is in removed_buffers")
+
+        device = buffer.get_device()
+        if not device:
+            raise AssertionError(f"buffer has no device: {buffer}")
+        dtype = buffer.get_dtype()
+        shape = self._generate_sym_nodes(buffer.get_size())
+        stride = self._generate_sym_nodes(buffer.get_stride())
+
+        node = self.gm.graph.call_function(
+            torch.empty_strided,
+            args=(shape, stride),
+            kwargs={"dtype": dtype, "device": device.type},
+        )
+        if not name:
+            raise AssertionError(f"buffer has an empty name: {buffer}")
+        node.name = name
+        self._record_allocation(buffer, node)
+
+    def _generate_switch(self, line: WrapperLine) -> None:
+        if not isinstance(line, SwitchLine):
+            raise AssertionError(f"expected SwitchLine, got {type(line)}")
+
+        ir_node = line.node
+        if ir_node.branches is None:
+            raise AssertionError("ir_node.branches must not be None")
+        if ir_node.operands is None:
+            raise AssertionError("ir_node.operands must not be None")
+
+        def generate_buffer(node: ir.IRNode | None) -> torch.fx.Node | None:
+            if node is None:
+                raise AssertionError("node must not be None")
+            return self._generate_buffer(node)
+
+        selector = generate_buffer(ir_node.selector)
+        operands = tuple(generate_buffer(arg) for arg in ir_node.operands)
+        branch_subgms = [self._get_subgm_attr(branch) for branch in ir_node.branches]
+
+        if ir_node.is_cond:
+            # cond expects (selector, true_fn, false_fn, operands) -- branches unpacked positionally.
+            if len(branch_subgms) != 2:
+                raise AssertionError(
+                    f"cond requires exactly 2 branches, got {len(branch_subgms)}"
+                )
+            # branches are stored as [false_fn, true_fn] in ir.Switch
+            false_subgm, true_subgm = branch_subgms
+            fx_node = self.gm.graph.call_function(
+                torch.ops.higher_order.cond,
+                args=(selector, true_subgm, false_subgm, operands),
+            )
+        else:
+            # switch expects (selector, [branch_fn, ...], operands) -- branches passed as a list.
+            fx_node = self.gm.graph.call_function(
+                torch.ops.higher_order.switch,
+                args=(selector, branch_subgms, operands),
+            )
+        self._record_allocation(ir_node, fx_node)
+
+    def _generate_assert_size_stride(self, line: WrapperLine) -> None:
+        pass
+
+    def _generate_comment(self, line: WrapperLine) -> None:
+        if not isinstance(line, CommentLine):
+            raise AssertionError(f"expected CommentLine, got {type(line)}")
+        # We ignore comments in FX IR.
+
+    def _generate_dynamic_scalar(self, line: WrapperLine) -> None:
+        if not isinstance(line, DynamicScalarLine):
+            raise AssertionError(f"expected DynamicScalarLine, got {type(line)}")
+
+        ir_node = line.node
+        (input_ir_node,) = ir_node.inputs
+        if not isinstance(input_ir_node, ir.IRNode):
+            raise AssertionError(f"expected ir.IRNode, got {type(input_ir_node)}")
+        input_fx_node = self._generate_buffer(input_ir_node)
+        keypath = ir_node.keypath
+        graph = self.gm.graph
+
+        def generate_item(x: torch.fx.Node | None) -> torch.fx.Node:
+            if x is None:
+                raise AssertionError("x must not be None")
+            return graph.call_function(
+                aten.item.default,
+                args=(x,),
+            )
+
+        if len(keypath) == 0:
+            result_fx_node = generate_item(input_fx_node)
+        elif len(keypath) == 1 and isinstance(keypath[0], ConvertIntKey):
+            where_fx_node = graph.call_function(
+                aten.where.Scalar,
+                args=(input_fx_node, 1, 0),
+            )
+            result_fx_node = generate_item(where_fx_node)
+        else:
+            raise NotImplementedError(f"Unsupported keypath: {keypath}")
+
+        result_symbol = ir_node.sym
+        result_buffer = SymbolBuffer(result_symbol)
+        self._record_allocation(result_buffer, result_fx_node)
+        self._generate_size_proxy(result_fx_node, result_symbol)
+
+    def _generate_enter_device_context_manager(self, line: WrapperLine) -> None:
+        if not isinstance(line, EnterDeviceContextManagerLine):
+            raise AssertionError(
+                f"expected EnterDeviceContextManagerLine, got {type(line)}"
+            )
+        # We ignore the device context in FX IR.
+
+    def _generate_exit_device_context_manager(self, line: WrapperLine) -> None:
+        if not isinstance(line, ExitDeviceContextManagerLine):
+            raise AssertionError(
+                f"expected ExitDeviceContextManagerLine, got {type(line)}"
+            )
+        # We ignore the device context in FX IR.
+
+    def _generate_enter_subgraph(self, line: WrapperLine) -> None:
+        if not isinstance(line, EnterSubgraphLine):
+            raise AssertionError(f"expected EnterSubgraphLine, got {type(line)}")
+        # We ignore memory planning lines in FX IR.
+
+    def _generate_exit_subgraph(self, line: WrapperLine) -> None:
+        if not isinstance(line, ExitSubgraphLine):
+            raise AssertionError(f"expected ExitSubgraphLine, got {type(line)}")
+        # We ignore memory planning lines in FX IR.
+
+    def _generate_free(self, line: WrapperLine) -> None:
+        if not isinstance(line, FreeLine):
+            raise AssertionError(f"expected FreeLine, got {type(line)}")
+
+        buf = line.node
+
+        # No need to free placeholders.
+        if self.buffer_to_node[buf.get_name()].op == "placeholder":
+            return
+
+        self._free(buf)
+
+    def _generate_free_if_not_reused(self, line: WrapperLine) -> None:
+        if not isinstance(line, FreeIfNotReusedLine):
+            raise AssertionError(f"expected FreeIfNotReusedLine, got {type(line)}")
+        buf = line.node
+        if buf.get_name() in V.graph.removed_buffers:
+            raise AssertionError(f"buffer {buf.get_name()} is in removed_buffers")
+        if not line.is_reused:
+            self._free(buf)
+
+    def _generate_line_context(self, line: WrapperLine) -> None:
+        if not isinstance(line, LineContext):
+            raise AssertionError(f"expected LineContext, got {type(line)}")
+        # We ignore line context in FX IR.
+
+    def _generate_reinterpret(self, line: WrapperLine) -> None:
+        if not isinstance(line, ReinterpretLine):
+            raise AssertionError(f"expected ReinterpretLine, got {type(line)}")
+        self._generate_reinterpret_helper(line.node, line.reused_as, line.layout)
+
+    def _generate_reinterpret_helper(
+        self, input_buffer: BufferLike, result_buffer: BufferLike, layout: ir.Layout
+    ) -> None:
+        input_node = self.buffer_to_node[input_buffer.get_name()]
+
+        # Look up output metadata.
+        name = result_buffer.get_name()
+        if not name:
+            raise AssertionError(f"result_buffer has an empty name: {result_buffer}")
+        size = tuple(layout.size)
+        stride = tuple(layout.stride)
+        if isinstance(layout, ir.NonOwningLayout):
+            # Look up the view's layout.
+            view = layout.view
+            if not isinstance(view, ir.ReinterpretView):
+                raise AssertionError(f"unexpected type: {type(view)}")
+            layout = view.layout
+        offset = input_buffer.get_offset() + layout.offset
+
+        # Map ReinterpretView to as_strided.
+        result_node = self._create_as_strided(input_node, size, stride, offset)
+        result_node.name = name
+        self._record_allocation(result_buffer, result_node)
+
+    def _generate_reuse(self, line: WrapperLine) -> None:
+        if not isinstance(line, ReuseLine):
+            raise AssertionError(f"expected ReuseLine, got {type(line)}")
+        old = line.node
+        new = line.reused_as
+        if any(buf.get_name() in V.graph.removed_buffers for buf in (old, new)):
+            raise AssertionError("old or new buffer is in removed_buffers")
+        if old.get_dtype() != new.get_dtype():
+            raise AssertionError(
+                f"dtype mismatch: {old.get_dtype()} != {new.get_dtype()}"
+            )
+
+        old_node = self.buffer_to_node[old.get_name()]
+        result_node = old_node
+
+        # Change shape and stride.
+        size = tuple(new.get_size())
+        stride = tuple(new.get_stride())
+        offset = new.get_offset()
+        if (
+            tuple(old.get_size()) != size
+            or tuple(old.get_stride()) != stride
+            or old.get_offset() != offset
+        ):
+            result_node = self._create_as_strided(old_node, size, stride, offset)
+
+        self._record_allocation(new, result_node)
+
+        # Free the old buffer, if we allocated a new tensor.
+        if (
+            old.get_name() not in V.graph.get_output_names()
+            and line.delete_old
+            and result_node is not old_node
+        ):
+            self._free(old)
+
+    def _generate_multi_output(self, line: WrapperLine) -> None:
+        if not isinstance(line, MultiOutputLine):
+            raise AssertionError(f"expected MultiOutputLine, got {type(line)}")
+
+        arg_node = self.buffer_to_node[line.arg_name]
+
+        # For non-tuple / non-list outputs, map the
+        # output to the same node as the input.
+        if len(line.indices) == 0:
+            self.buffer_to_node[line.result_name] = arg_node
+            return
+
+        # Extract the index for tuple access.
+        inds = line.indices[0][1:]
+        if len(inds) != 1:
+            raise AssertionError(f"Cannot convert {inds} to an index.")
+        idx = inds[0]
+
+        node = self.gm.graph.call_function(operator.getitem, args=(arg_node, idx))
+        node.name = line.result_name
+        self.buffer_to_node[line.result_name] = node
+
+    def _generate_fallback_call(
+        self,
+        ir_node: ir.ExternKernel,
+        args: tuple[Any, ...] | None = None,
+        kwargs: dict[str, Any] | None = None,
+    ) -> None:
+        fx_node = self.gm.graph.call_function(
+            ir_node.op_overload,  # type: ignore[arg-type]
+            args=args,
+            kwargs=kwargs,
+        )
+        result_buffer = ir_node.codegen_reference()
+        self.buffer_to_node[result_buffer] = fx_node
+        # For in-place mutation ops (e.g., scatter_reduce_, index_put_),
+        # update the buffer mapping for mutated inputs so downstream
+        # references to the mutated buffer see the post-mutation node.
+        for mutated_name in ir_node.get_mutation_names():
+            self.buffer_to_node[mutated_name] = fx_node
+
+    def _generate_index_put_fallback(self, line: WrapperLine) -> None:
+        if not isinstance(line, IndexPutFallbackLine):
+            raise AssertionError(f"expected IndexPutFallbackLine, got {type(line)}")
+        ir_node = line.node
+
+        def generate_buffer_or_none(
+            x: ir.IRNode | Sequence[ir.IRNode] | None,
+        ) -> torch.fx.Node | None:
+            """
+            Handles None before calling _generate_buffer.
+            """
+            if x is None:
+                return None
+
+            if not isinstance(x, ir.IRNode):
+                raise AssertionError(f"expected ir.IRNode, got {type(x)}")
+            return self._generate_buffer(x)
+
+        (x, values) = [generate_buffer_or_none(t) for t in ir_node.inputs[:2]]
+        indices = tuple(generate_buffer_or_none(t) for t in line.indices)
+        accumulate = ir_node.constant_args[0]
+        args = (x, indices, values, accumulate)
+        self._generate_fallback_call(ir_node, args)
+
+    def _generate_scatter_fallback(self, line: WrapperLine) -> None:
+        if not isinstance(line, ScatterFallbackLine):
+            raise AssertionError(f"expected ScatterFallbackLine, got {type(line)}")
+        ir_node = line.node
+        if not ir.is_node_sequence(ir_node.inputs):
+            raise AssertionError("ir_node.inputs is not a node sequence")
+        (x, index, src) = [self._generate_buffer(t) for t in ir_node.inputs] + (
+            [] if ir_node.src_is_tensor else [ir_node.constant_args[1]]
+        )
+        args = (x, ir_node.constant_args[0], index, src)
+        kwargs = {}
+        if reduce := ir_node.kwargs.get("reduce"):
+            kwargs["reduce"] = reduce
+        # Only pass kwargs that the op's schema actually accepts, since
+        # ScatterFallback stores both reduce and include_self for all
+        # scatter variants, but not all ops support them (e.g.,
+        # scatter_.value has no kwargs, scatter_reduce_.two has both).
+        if not isinstance(ir_node.op_overload, torch._ops.OpOverload):
+            raise AssertionError(
+                f"expected torch._ops.OpOverload, got {type(ir_node.op_overload)}"
+            )
+        schema_arg_names = OrderedSet(
+            [a.name for a in ir_node.op_overload._schema.arguments]
+        )
+        kwargs = {k: v for k, v in ir_node.kwargs.items() if k in schema_arg_names}
+
+        self._generate_fallback_call(ir_node, args, kwargs)
+
+    def _generate_null(self, line: WrapperLine) -> None:
+        if not isinstance(line, NullLine):
+            raise AssertionError(f"expected NullLine, got {type(line)}")
+        # Does nothing.
+
+    def _generate_comm_buffer_allocate(self, line: WrapperLine) -> None:
+        if not (isinstance(line, AllocateLine) and line.comm_buffer):
+            raise AssertionError("expected AllocateLine with comm_buffer set")
+        raise NotImplementedError("Comm buffer allocation is not yet supported")
+
+    def _generate_comm_buffer_free(self, line: WrapperLine) -> None:
+        if not (isinstance(line, FreeIfNotReusedLine) and line.comm_buffer):
+            raise AssertionError("expected FreeIfNotReusedLine with comm_buffer set")
+        self._free(line.node)
+
+    def _generate_triton_call(self, line: WrapperLine) -> None:
+        if not isinstance(line, KernelCallLine):
+            raise AssertionError(f"expected KernelCallLine, got {type(line)}")
+
+        # Collect all kwargs, including autotuned block sizes.
+        call_args = self._lookup_args(line.call_args)
+        kernel = self.kernels[line.kernel_name]
+        tuner = kernel.tuner
+
+        def tune_kernel(tuner: CachingAutotuner, call_args: Sequence[Any]) -> None:
+            from triton.runtime import driver
+
+            log.info("Autotuning Triton kernel %s at compile time.", kernel_name)
+
+            device = driver.active.get_current_device()
+
+            stream = driver.active.get_current_stream(device)
+
+            def node_to_tuning_arg(arg: Any) -> Any:
+                """
+                Create real tensors for autotuning arguments, substituting size hints
+                for dynamic shapes.
+                """
+
+                def to_size_hint_sympy_int(arg: sympy.Expr | int) -> int:
+                    return V.graph.sizevars.optimization_hint(arg)
+
+                def to_size_hint_list(arg: list[torch.SymInt | int]) -> list[int]:
+                    args_sympy = [
+                        x.node.expr if isinstance(x, torch.SymInt) else x for x in arg
+                    ]
+                    return pytree.tree_map(to_size_hint_sympy_int, args_sympy)
+
+                if not isinstance(arg, torch.fx.Node):
+                    return to_size_hint_sympy_int(arg)
+
+                fake = arg.meta["val"]
+                return torch.empty_strided(
+                    to_size_hint_list(fake.shape),
+                    to_size_hint_list(fake.stride()),
+                    dtype=fake.dtype,
+                    device=device,
+                ).zero_()
+
+            # call args can be fx nodes or sympy expressions or integers!
+            arg_values = [node_to_tuning_arg(arg) for arg in call_args]
+            tuner.run(*arg_values, stream=stream)
+
+        # Optionally autotune the kernels.
+        # The FX backend currently only supports compile-time tuning.
+        kernel_name = tuner.fn.__name__
+        if config.triton.autotune_at_compile_time:
+            # Skip compile-time autotuning if any unbacked symbol lacks a user-provided
+            # optimization hint — autotuning with the generic fallback would
+            # produce meaningless results.
+            hinted = V.graph.sizevars.all_unbacked_explicitly_hinted
+            can_tune = True
+            for arg in call_args:
+                if isinstance(arg, torch.fx.Node):
+                    fake = arg.meta["val"]
+                    if not hinted(list(fake.shape) + list(fake.stride())):
+                        can_tune = False
+                        break
+                elif not hinted(arg):
+                    can_tune = False
+                    break
+            if can_tune:
+                tune_kernel(tuner, call_args)
+            else:
+                log.info(
+                    "Detected unhinted unbacked symints. Skipping compile-time autotuning for kernel %s.",
+                    kernel_name,
+                )
+        else:
+            log.info(
+                "Skipping autotuning for kernel %s. Set config.triton.autotune_at_compile_time = True to enable.",
+                kernel_name,
+            )
+
+        triton_meta = tuner.triton_meta
+        signature = triton_meta["signature"]
+
+        def add_constants_to_call_args(
+            call_args: Sequence[Any], cfg: Config
+        ) -> tuple[Any, ...]:
+            """
+            Add constant kwargs to the arg list.
+            """
+            # Add args from the proper Triton signature.
+            # Exclude constants and config kwargs, as those are tracked separately.
+            new_call_args = []
+            constants = triton_meta["constants"]
+            call_kwargs = {
+                key: val
+                for key, val in zip(signature, call_args)
+                # pyrefly: ignore [missing-attribute]
+                if key not in constants and key not in cfg.kwargs
+            }
+
+            # Add constants stored as Triton metadata, in signature order.
+            call_kwargs |= constants
+            new_call_args = [
+                call_kwargs[key]
+                for key in signature
+                # pyrefly: ignore [missing-attribute]
+                if key not in cfg.kwargs
+            ]
+
+            # Add Inductor's extra launcher args to the end.
+            if extra_launcher_args := tuner.inductor_meta.get("extra_launcher_args"):
+                new_call_args.extend(
+                    call_args[len(call_args) - len(extra_launcher_args) :]
+                )
+
+            return tuple(new_call_args)
+
+        kernel_config = tuner.compile_results[0].config
+        extra_options = getattr(kernel_config, "extra_options", None)
+        call_args = add_constants_to_call_args(call_args, kernel_config)
+        call_args, grid = tuner._interpret_args_grid(call_args, kernel_config)
+        call_kwargs = dict(zip(signature, call_args))
+        # pyrefly: ignore [missing-attribute]
+        if any(kwarg in kernel_config.kwargs for kwarg in call_kwargs):
+            raise AssertionError(f"kwargs overlap config: {call_kwargs}")
+        # pyrefly: ignore [missing-attribute]
+        call_kwargs.update(kernel_config.kwargs)
+
+        # Replace sympy.floor with FloorDiv, to make the expression traceable.
+        grid = [replace_floor_div(x) if isinstance(x, sympy.Expr) else x for x in grid]
+        wrapper_grid = [tuple(self._generate_sym_nodes(grid))]
+        call_kwargs = {
+            name: self._generate_sym_node(val) for name, val in call_kwargs.items()
+        }
+        backend_options = triton_meta.get("backend_options", {})
+        if backend_options:
+            # FXIR executes Triton kernels through the HOP, not the already
+            # materialized CachingAutotuner launcher. Preserve backend option
+            # values in the HOP payload so a direct FXIR run or later Inductor
+            # re-lowering re-enters Triton JIT with the same compiler options
+            # that were used during FXIR precompile/autotune.
+            for name, value in backend_options.items():
+                # If the backend option is also a kernel parameter, call_kwargs
+                # already contains the launch value reconstructed from the Triton
+                # signature/config. Keep that value and only add backend options
+                # that are not otherwise represented in the HOP payload.
+                call_kwargs.setdefault(name, value)
+
+        # Store non-graphable kwargs in the side table.
+        (
+            call_kwargs,
+            constant_args_idx,
+        ) = tracing_triton_hopifier_singleton.store_non_graphable_args(call_kwargs)
+
+        hop_kwargs: dict[str, Any] = {
+            "kernel_idx": kernel.wrapped.kernel_idx,
+            "constant_args_idx": constant_args_idx,
+            "grid": wrapper_grid,
+            "tma_descriptor_metadata": {},
+            "kwargs": call_kwargs,
+        }
+        if backend_options:
+            # Keep the FXIR HOP call shape unchanged for normal Inductor
+            # kernels. Some downstream HOP py_impls have fixed keyword-only
+            # signatures and only need launch_kwargs when there are real
+            # Triton backend options to preserve.
+            hop_kwargs["launch_kwargs"] = tuple(backend_options)
+
+        triton_node = self.gm.graph.call_function(
+            triton_kernel_wrapper_mutation,
+            kwargs=hop_kwargs,
+        )
+        if extra_options:
+            triton_node.meta["extra_options"] = extra_options
+
+    def _generate_extern_kernel_alloc(self, line: WrapperLine) -> None:
+        if not isinstance(line, ExternKernelAllocLine):
+            raise AssertionError(f"expected ExternKernelAllocLine, got {type(line)}")
+        node = line.node
+        self._generate_extern_kernel_common(node, node)
+
+    def _generate_extern_kernel_out(
+        self,
+        line: WrapperLine,
+    ) -> None:
+        if not isinstance(line, ExternKernelOutLine):
+            raise AssertionError(f"expected ExternKernelOutLine, got {type(line)}")
+        node = line.node
+        out_node = node.output_view if node.output_view else node
+        self._generate_extern_kernel_common(node, out_node)
+
+    def _generate_extern_kernel_common(
+        self, kernel: ir.ExternKernel, out_ir_node: ir.IRNode
+    ) -> None:
+        """
+        Generates FX IR from either ExternKernelAlloc or ExternKernelOut.
+        """
+
+        # Get FX nodes corresponding to the call args.
+        if not ir.is_node_sequence(kernel.inputs):
+            raise AssertionError("kernel.inputs is not a node sequence")
+        tensor_nodes = tuple(self._generate_buffer(arg) for arg in kernel.inputs)
+        if hasattr(kernel, "unflatten_args"):
+            args, _ = kernel.unflatten_args(tensor_nodes, kernel.constant_args)
+        else:
+            args = tensor_nodes + tuple(kernel.constant_args)
+
+        # Get the result buffer.
+        # Some kernels write to a pre-existing output tensor via the "out" kwarg.
+        # Materialize any IR nodes in kwargs to FX nodes (e.g., TensorBox -> Tensor).
+        kwargs = {
+            k: self._generate_buffer(v) if isinstance(v, ir.IRNode) else v
+            for k, v in kernel.kwargs.items()
+        }
+
+        result_buffer: str | None = None
+        if isinstance(kernel, ir.ExternKernelOut):
+            kwargs["out"] = self.buffer_to_node[out_ir_node.codegen_reference()]
+        elif isinstance(kernel.layout, (ir.Layout, ir.MultiOutputLayout)):
+            result_buffer = kernel.get_name()
+        elif isinstance(kernel.layout, ir.NoneLayout):
+            pass
+        else:
+            raise NotImplementedError(f"Unrecognized output layout: {kernel.layout}")
+
+        fx_node = self.gm.graph.call_function(
+            kernel.op_overload,  # type: ignore[arg-type]
+            args=args,
+            kwargs=kwargs,
+        )
+
+        # Assign the result to the given name.
+        if result_buffer:
+            if "out" in kwargs:
+                raise AssertionError(
+                    f"Extern kernel '{kernel}' has both result and out kwarg. Expected only one."
+                )
+            fx_node.name = result_buffer
+            self.buffer_to_node[result_buffer] = fx_node
+
+    def _generate_kernel_call(self, line: WrapperLine) -> None:
+        if not isinstance(line, KernelCallLine):
+            raise AssertionError(f"expected KernelCallLine, got {type(line)}")
+        if not line.triton:
+            raise NotImplementedError("FX conversion only supports Triton kernels.")
+
+        self._generate_triton_call(line)
+
+    def _generate_kernel_definition(self, line: WrapperLine) -> None:
+        if not isinstance(line, KernelDefinitionLine):
+            raise AssertionError(f"expected KernelDefinitionLine, got {type(line)}")
+
+        # Generate code for the kernel.
+        kernel_code = PythonWrapperCodegen._format_kernel_definition(
+            line.kernel_name, line.kernel_body, metadata=line.metadata
+        )
+
+        # Import the module and store the JIT kernel.
+        tuner = self._import_kernel(kernel_code, line.kernel_name)
+        wrapped = wrap_triton(tuner.fn)
+        self.kernels[line.kernel_name] = TritonKernel(tuner, wrapped)
+
+    def _generate_symbolic_call_arg(self, line: WrapperLine) -> None:
+        if not isinstance(line, SymbolicCallArgLine):
+            raise AssertionError(f"expected SymbolicCallArgLine, got {type(line)}")
+        # Store the arg: expr mapping for later use.
+        arg = line.arg
+
+        inner_expr_proxy = self._sympy_interp(arg.inner_expr)
+        self.expr_to_proxy[arg.inner] = inner_expr_proxy
+
+    def _generate_unbacked_symbol_defs(self, line: WrapperLine) -> None:
+        if not isinstance(line, UnbackedSymbolDefsLine):
+            raise AssertionError(f"expected UnbackedSymbolDefsLine, got {type(line)}")
+        graph = self.gm.graph
+
+        def convert_key(node: torch.fx.Node, path: pytree.KeyPath) -> torch.fx.Node:
+            """
+            Generate FX IR for each key entry.
+            """
+            # Base case.
+            if len(path) == 0:
+                return node
+
+            # Process the first entry and recurse.
+            entry = path[0]
+            if isinstance(entry, CallMethodKey):
+                target = {
+                    "size": aten.sym_size.int,
+                    "stride": aten.sym_stride.int,
+                    "storage_offset": aten.sym_storage_offset,
+                }[entry.name]
+                if not callable(target):
+                    raise AssertionError(f"target is not callable: {target}")
+                node = graph.call_function(
+                    target,
+                    args=(
+                        (node, path[1].idx)
+                        if len(path) > 1 and isinstance(path[1], pytree.SequenceKey)
+                        else (node,)
+                    ),
+                )
+                return convert_key(node, path[1 + len(node.args) :])
+            elif isinstance(entry, pytree.SequenceKey):
+                node = graph.call_function(operator.getitem, args=(node, entry.idx))
+                return convert_key(node, path[1:])
+            elif isinstance(entry, DivideByKey):
+                node = graph.call_function(
+                    operator.floordiv, args=(node, entry.divisor)
+                )
+                return convert_key(node, path[1:])
+            else:
+                raise NotImplementedError(f"Unrecognized entry type: {type(entry)}")
+
+        unbacked_bindings = line.unbacked_bindings
+        if unbacked_bindings is None:
+            raise AssertionError("line.unbacked_bindings must not be None")
+        # Kernels with no unbacked symbols aren't recorded in buffer_to_node, so
+        # return before the output-buffer lookup to avoid a KeyError. Mirrors
+        # the non-FX wrapper's early return.
+        if not unbacked_bindings:
+            return
+        root_node = self.buffer_to_node[line.output_name]
+        for s, keypath in unbacked_bindings.items():
+            # Check if we already generated this symbol.
+            if s.name in self.buffer_to_node:
+                continue
+
+            node = convert_key(root_node, keypath)
+            out_buffer = SymbolBuffer(s)
+            self._record_allocation(out_buffer, node)
+            self._generate_size_proxy(node, s)

.venv/lib/python3.12/site-packages/torch/_inductor/codegen/xpu/compile_utils.py

@@ -0,0 +1,145 @@
+# mypy: allow-untyped-defs
+import functools
+import logging
+import os
+import shutil
+import subprocess
+
+from torch._inductor import config
+from torch._inductor.codegen.xpu.xpu_env import get_xpu_arch
+from torch._inductor.utils import is_linux
+
+from ..cuda.compile_utils import _cutlass_include_paths
+
+
+log = logging.getLogger(__name__)
+
+
+@functools.cache
+def icpx_exist(icpx_path: str | None = "icpx") -> bool:
+    return icpx_path is not None and shutil.which(icpx_path) is not None
+
+
+def _sycl_compiler() -> str:
+    # Search order:
+    # 0) which icpx
+    # 1) config.xpu.oneapi_root
+    # 2) ONEAPI_ROOT environment variable
+    # 3) default system search PATH.
+    if icpx_exist("icpx"):
+        return "icpx"
+
+    if os.path.exists(config.xpu.oneapi_root or ""):
+        oneapi_root = config.xpu.oneapi_root
+    elif os.path.exists(os.getenv("ONEAPI_ROOT") or ""):
+        oneapi_root = os.getenv("ONEAPI_ROOT")
+    else:
+        oneapi_root = None
+
+    if oneapi_root:
+        oneapi_inclue = os.path.join(oneapi_root, "include")
+        if "CPLUS_INCLUDE_PATH" in os.environ:
+            os.environ["CPLUS_INCLUDE_PATH"] += ":" + oneapi_inclue
+        else:
+            os.environ["CPLUS_INCLUDE_PATH"] = oneapi_inclue
+        return os.path.realpath(os.path.join(oneapi_root, "bin/icpx"))
+
+    # Mirrors _cuda_compiler(): return the bare name and let the compile
+    # subprocess produce the error, so callers can probe with icpx_exist().
+    return "icpx"
+
+
+def _sycl_lib_options() -> list[str]:
+    """
+    Util function for CUTLASS backend to find the correct XPU libraries.
+    """
+    # _set_gpu_runtime_env()  # cpp_extension consults the env
+    from torch.utils import cpp_extension
+
+    lpaths = cpp_extension.library_paths(device_type="xpu")
+    extra_ldflags: list[str] = []
+    if is_linux():
+        for path in lpaths:
+            if "torch/lib" in path:
+                # don't want to depend on pytorch
+                continue
+            # -rpath ensures the DLL can find its dependencies when loaded, even
+            # if the library path is non-standard.
+            extra_ldflags.extend([f"-L{path}", "-Xlinker", f"-rpath={path}"])
+
+        extra_ldflags.append("-lsycl")
+    else:
+        raise NotImplementedError(
+            "Unsupported env, failed to find xpu libs! Currently only Linux is supported."
+        )
+    return extra_ldflags
+
+
+def _sycl_arch_as_compile_option() -> str:
+    arc_option_map = {"Xe12": "pvc", "Xe20": "bmg-g21,bmg-g31"}
+    arch = get_xpu_arch()
+    return arc_option_map.get(arch, "pvc")
+
+
+def _sycl_compiler_options() -> list[str]:
+    options = [
+        "-DCUTLASS_ENABLE_SYCL",
+        "-DSYCL_INTEL_TARGET",
+        "-DCUTLASS_VERSIONS_GENERATED",
+        "-O3",
+        "-DNDEBUG",
+        "-std=c++20",
+        "-fPIC",
+        "-fsycl",
+        "-fsycl-targets=spir64_gen",
+        "-Xspirv-translator",
+        "-spirv-ext=+SPV_INTEL_split_barrier,+SPV_INTEL_2d_block_io,+SPV_INTEL_subgroup_matrix_multiply_accumulate",
+        "-fno-sycl-instrument-device-code",
+        "-DMKL_ILP64",
+        "-MD",
+        "-Xs",
+        (
+            f"-device {_sycl_arch_as_compile_option()} "
+            "-options \"-igc_opts 'VISAOptions=-perfmodel,VectorAliasBBThreshold=100000000000,"
+            "ExtraOCLOptions=-cl-intel-256-GRF-per-thread'\" "
+            "-options -ze-opt-large-register-file"
+        ),
+    ]
+    if config.cutlass.enable_debug_info:
+        options.extend(["-lineinfo", "-g", "-DCUTLASS_DEBUG_TRACE_LEVEL=1"])
+    return options
+
+
+def xpu_compile_command(
+    src_files: list[str],
+    dst_file: str,
+    dst_file_ext: str,
+    extra_args: list[str] | None = None,
+) -> str:
+    if extra_args is None:
+        extra_args = []
+    include_paths = _cutlass_include_paths()
+    sycl_lib_options = _sycl_lib_options()
+    sycl_compiler_options = _sycl_compiler_options()
+
+    # Build command as a list to preserve arguments with spaces
+    cmd_parts = (
+        [_sycl_compiler()]
+        + extra_args
+        + ["-I" + path for path in include_paths]
+        + ["-isystem", "/include"]
+        + sycl_compiler_options
+        + sycl_lib_options
+    )
+    if dst_file_ext == "o":
+        cmd_parts.extend(["-c", "-o", dst_file] + src_files)
+    elif dst_file_ext == "so":
+        cmd_parts.extend(["-shared", "-o", dst_file] + src_files)
+    elif dst_file_ext == "exe":
+        cmd_parts.extend(["-o", dst_file] + src_files)
+    else:
+        raise NotImplementedError(f"Unsupported output file suffix {dst_file_ext}!")
+
+    res = subprocess.list2cmdline(cmd_parts)
+    log.debug("XPU command: %s", res)
+    return res

.venv/lib/python3.12/site-packages/torch/_inductor/codegen/xpu/device_op_overrides.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from ..common import (
+    DeviceIdx,
+    DeviceOpOverrides,
+    register_device_op_overrides,
+    TritonScratchWorkspace,
+)
+
+
+class XPUDeviceOpOverrides(DeviceOpOverrides):
+    def import_get_raw_stream_as(self, name: str) -> str:
+        return f"from torch._C import _xpu_getCurrentRawStream as {name}"
+
+    def set_device(self, device_idx: DeviceIdx) -> str:
+        return f"torch.xpu.set_device({device_idx})"
+
+    def synchronize(self) -> str:
+        return "torch.xpu.synchronize()"
+
+    def device_guard(self, device_idx: DeviceIdx) -> str:
+        return f"torch.xpu._DeviceGuard({device_idx})"
+
+    def current_device_idx_expr(self) -> str:
+        return "torch.xpu.current_device()"
+
+    def current_stream(self) -> str:
+        return "torch.xpu.current_stream()"
+
+    def cpp_device_guard(self) -> str:
+        return "at::DeviceGuard"
+
+    def cpp_aoti_device_guard(self) -> str:
+        return "AOTIXpuGuard"
+
+    def cpp_stream_guard(self) -> str:
+        return "at::xpu::XPUStreamGuard"
+
+    def cpp_aoti_stream_guard(self) -> str:
+        return "AOTIXpuStreamGuard"
+
+    def cpp_getStreamFromExternal(self) -> str:
+        return "at::xpu::getStreamFromExternal"
+
+    def kernel_header(self) -> str:
+        source_codes = """
+        #include <torch/csrc/inductor/aoti_runtime/sycl_runtime_wrappers.h>
+        """
+        return source_codes
+
+    def kernel_driver(self) -> str:
+        return ""
+
+    def cpp_stream_type(self) -> str:
+        return "sycl::queue*"
+
+    def aoti_get_stream(self) -> str:
+        return "aoti_torch_get_current_xpu_stream"
+
+    def cpp_kernel_type(self) -> str:
+        return "std::unique_ptr<sycl::kernel>"
+
+    def cpp_device_ptr(self) -> str:
+        return "void *"
+
+    def cpp_scratch(
+        self, idx: int, workspace: TritonScratchWorkspace, prefix: str | None = None
+    ) -> tuple[list[str], str] | None:
+        return [f"void *global_scratch_{idx} = 0;"], f"global_scratch_{idx}"
+
+
+register_device_op_overrides("xpu", XPUDeviceOpOverrides())

.venv/lib/python3.12/site-packages/torch/_inductor/codegen/xpu/xpu_combined_scheduling.py

@@ -0,0 +1,139 @@
+# mypy: allow-untyped-defs
+from __future__ import annotations
+
+from typing import Any, TYPE_CHECKING
+
+from torch._inductor.scheduler import (
+    BaseSchedulerNode,
+    BaseScheduling,
+    FusedSchedulerNode,
+    Scheduler,
+    SchedulerNode,
+)
+
+from ..cutlass.scheduling import CUTLASSScheduling
+from ..triton import TritonScheduling
+
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+    from typing import TypeAlias
+
+    from sympy import Expr
+
+    import torch
+    from torch.utils._ordered_set import OrderedSet
+
+    from ..common import BackendFeature
+
+    _IntLike: TypeAlias = int | Expr
+
+
+class XPUCombinedScheduling(BaseScheduling):
+    """
+    Scheduler for XPU Kernels, which delegates calls as appropriate
+    to the SYCL-C++ and Triton Schedulers, which both work for XPU devices
+    and use a unified-wrapper for codegen.
+
+    If Scheduling code needs to be specialized for the case of mixed Triton / SYCL C++ code,
+    this would also be the place to do it.
+    """
+
+    def __init__(self, scheduler: Scheduler | None) -> None:
+        super().__init__(scheduler)
+        self._triton_scheduling = TritonScheduling(scheduler)
+        self._cutlass_scheduling = CUTLASSScheduling(scheduler)
+
+    def get_backend_features(self, device: torch.device) -> OrderedSet[BackendFeature]:
+        return self._triton_scheduling.get_backend_features(device)
+
+    def choose_node_backend(self, node: BaseSchedulerNode) -> BaseScheduling:
+        if self._cutlass_scheduling.is_cutlass_template(node):
+            return self._cutlass_scheduling
+        return self._triton_scheduling
+
+    def can_fuse_vertical(
+        self, node1: BaseSchedulerNode, node2: BaseSchedulerNode
+    ) -> bool:
+        if self._cutlass_scheduling.can_fuse_vertical(node1, node2):
+            return True
+        elif self._cutlass_scheduling.is_cutlass_template(
+            node1
+        ) or self._cutlass_scheduling.is_cutlass_template(node2):
+            return False
+        return self._triton_scheduling.can_fuse_vertical(node1, node2)
+
+    def can_fuse_horizontal(
+        self, node1: BaseSchedulerNode, node2: BaseSchedulerNode
+    ) -> bool:
+        for node in (node1, node2):
+            if self._cutlass_scheduling.is_cutlass_template(node):
+                return self._cutlass_scheduling.can_fuse_horizontal(
+                    node1, node2
+                )  # always False at the moment
+        return self._triton_scheduling.can_fuse_horizontal(node1, node2)
+
+    def group_fn(
+        self, sizes: Sequence[Sequence[_IntLike]]
+    ) -> tuple[tuple[_IntLike, ...], ...]:
+        return self._triton_scheduling.group_fn(sizes)
+
+    def codegen_template(
+        self,
+        template_node: BaseSchedulerNode,
+        epilogue_nodes: Sequence[BaseSchedulerNode],
+        prologue_nodes: Sequence[BaseSchedulerNode],
+    ) -> str | None:
+        if self._cutlass_scheduling.is_cutlass_template(template_node):
+            if prologue_nodes:
+                raise AssertionError("cutlass template does not support prologue_nodes")
+            return self._cutlass_scheduling.codegen_template(
+                template_node, epilogue_nodes, prologue_nodes
+            )
+        else:
+            return self._triton_scheduling.codegen_template(
+                template_node, epilogue_nodes, prologue_nodes
+            )
+
+    def codegen_mix_order_reduction(self, node):
+        return self._triton_scheduling.codegen_mix_order_reduction(node)
+
+    def codegen_nested_reduction(self, node):
+        return self._triton_scheduling.codegen_nested_reduction(node)
+
+    def codegen_node(self, node: FusedSchedulerNode | SchedulerNode) -> None:
+        return self._triton_scheduling.codegen_node(node)
+
+    def codegen_sync(self) -> None:
+        return self._triton_scheduling.codegen_sync()
+
+    def flush(self) -> None:
+        return self._triton_scheduling.flush()
+
+    def codegen_combo_kernel(self, *args: Any, **kwargs: Any) -> None:
+        return self._triton_scheduling.codegen_combo_kernel(*args, **kwargs)
+
+    def benchmark_fused_nodes(
+        self, nodes: Sequence[BaseSchedulerNode]
+    ) -> tuple[float, str]:
+        return self._triton_scheduling.benchmark_fused_nodes(nodes)
+
+    def benchmark_codegened_module(self, module):
+        return self._triton_scheduling.benchmark_codegened_module(module)
+
+    def generate_kernel_code_from_nodes(
+        self,
+        nodes: Sequence[Any],
+        benchmark_kernel: bool = False,
+        hint_override: int | None = None,
+    ) -> str:
+        return self._triton_scheduling.generate_kernel_code_from_nodes(
+            nodes, benchmark_kernel, hint_override=hint_override
+        )
+
+    def benchmark_combo_kernel(
+        self, node_list: Sequence[BaseSchedulerNode], node_benchmark_results
+    ) -> tuple[float, float, list[str | None]]:
+        return self._triton_scheduling.benchmark_combo_kernel(
+            node_list, node_benchmark_results
+        )

.venv/lib/python3.12/site-packages/torch/_inductor/codegen/xpu/xpu_env.py

@@ -0,0 +1,38 @@
+import functools
+import logging
+
+import torch
+from torch._inductor.utils import clear_on_fresh_cache
+
+
+log = logging.getLogger(__name__)
+
+
+@clear_on_fresh_cache
+@functools.lru_cache(1)
+def get_xpu_arch() -> str | None:
+    from torch.testing._internal.common_xpu import get_xpu_codename, XPUCodename
+
+    name2arch = {
+        XPUCodename.PVC: "Xe12",
+        XPUCodename.BMG: "Xe20",
+    }
+
+    codename = get_xpu_codename()
+    if not codename or codename not in name2arch:
+        log.warning("Unknown XPU codename, cannot determine architecture")
+        return None
+
+    return name2arch[codename]
+
+
+@clear_on_fresh_cache
+@functools.lru_cache(1)
+def get_xpu_version() -> str | None:
+    # string of version, like 20250101
+    try:
+        xpu_version = torch.version.xpu or ""
+        return xpu_version
+    except Exception:
+        log.exception("Error getting xpu version")
+        return None

.venv/lib/python3.12/site-packages/torch/_inductor/comm_analysis.py

@@ -0,0 +1,922 @@
+import functools
+import logging
+import math
+import operator
+from dataclasses import dataclass
+from enum import IntEnum
+from typing import Any
+
+import sympy
+
+import torch
+import torch.utils._pytree as pytree
+from torch.fx.experimental.symbolic_shapes import optimization_hint
+from torch.fx.operator_schemas import normalize_function
+
+from . import ir
+from .utils import get_dtype_size, snode_args_kwargs, sympy_product
+from .virtualized import V
+
+
+log = logging.getLogger(__name__)
+
+
+class NCCL_COLL(IntEnum):
+    ALL_REDUCE = 0
+    ALL_GATHER = 1
+    REDUCE_SCATTER = 2
+    ALL_TO_ALL = 3
+    UNSUPPORTED = 4
+    P2P = 5
+
+
+class NVIDIA_GPU_TYPE(IntEnum):
+    VOLTA = 0
+    AMPERE = 1
+    HOPPER = 2
+    BLACKWELL = 3
+
+
+class InterconnectType(IntEnum):
+    NVLINK_V100 = 0
+    NVLINK_A100 = 1
+    NVLINK_H100 = 2
+    NVLINK_B200 = 3
+    IB_HDR = 4  # 200 Gbps InfiniBand
+    IB_NDR = 5  # 400 Gbps InfiniBand / RoCE
+    PCIE = 6  # PCIe (no NVLink)
+
+
+@dataclass(frozen=True)
+class InterconnectProfile:
+    """Empirically calibrated interconnect parameters for saturation estimation."""
+
+    bus_bw_GBps: float  # effective bus bandwidth at large messages (GB/s)
+    latency_per_hop_us: float  # per-ring-step latency (us)
+    base_latency_us: float  # fixed startup latency (us)
+    min_saturation_bytes: int = 0  # floor for small group sizes
+
+
+_MB = 1024 * 1024
+
+# Empirically calibrated per-interconnect profiles for saturation estimation.
+# NVLink bus_bw from https://github.com/NVIDIA/nccl/blob/master/src/graph/topo.h
+# IB hop_lat/base_lat from MAST sweep profiles on H100 GrandTeton RoCE
+# (see agent_space/nccl_model_validation.md for calibration data).
+# IB min_saturation_bytes floors the estimate for small group sizes where the
+# ring-step formula underestimates.
+INTERCONNECT_PROFILES: dict[InterconnectType, InterconnectProfile] = {
+    InterconnectType.NVLINK_H100: InterconnectProfile(36.0, 40.0, 10.0),
+    InterconnectType.NVLINK_A100: InterconnectProfile(22.0, 45.0, 10.0),
+    InterconnectType.NVLINK_B200: InterconnectProfile(60.0, 30.0, 10.0),
+    InterconnectType.NVLINK_V100: InterconnectProfile(14.0, 50.0, 10.0),
+    InterconnectType.IB_NDR: InterconnectProfile(
+        22.0, 12.0, 30.0, min_saturation_bytes=100 * _MB
+    ),
+    InterconnectType.IB_HDR: InterconnectProfile(
+        11.0, 14.0, 30.0, min_saturation_bytes=75 * _MB
+    ),
+    # PCIe: ~10 GB/s effective NCCL bus BW (GPU->CPU->GPU ring steps)
+    InterconnectType.PCIE: InterconnectProfile(10.0, 60.0, 15.0),
+}
+
+_GPU_TO_INTRA: dict[NVIDIA_GPU_TYPE, InterconnectType] = {
+    NVIDIA_GPU_TYPE.VOLTA: InterconnectType.NVLINK_V100,
+    NVIDIA_GPU_TYPE.AMPERE: InterconnectType.NVLINK_A100,
+    NVIDIA_GPU_TYPE.HOPPER: InterconnectType.NVLINK_H100,
+    NVIDIA_GPU_TYPE.BLACKWELL: InterconnectType.NVLINK_B200,
+}
+_GPU_TO_INTER: dict[NVIDIA_GPU_TYPE, InterconnectType] = {
+    NVIDIA_GPU_TYPE.VOLTA: InterconnectType.IB_HDR,
+    NVIDIA_GPU_TYPE.AMPERE: InterconnectType.IB_HDR,
+    NVIDIA_GPU_TYPE.HOPPER: InterconnectType.IB_NDR,
+    NVIDIA_GPU_TYPE.BLACKWELL: InterconnectType.IB_NDR,
+}
+
+
+@functools.lru_cache
+def _has_nvlink() -> bool:
+    """Detect NVLink via nvidia-smi topology, falling back to peer access check."""
+    import subprocess
+
+    if not torch.cuda.is_available() or torch.cuda.device_count() < 2:
+        return True  # Single GPU: interconnect irrelevant
+    try:
+        result = subprocess.run(
+            ["nvidia-smi", "topo", "-m"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode == 0:
+            # Check GPU-GPU section (before Legend) for "NV" links
+            topo = result.stdout.split("Legend")[0]
+            return "NV" in topo
+    except (subprocess.TimeoutExpired, OSError):
+        pass
+    # Fallback: peer access generally implies NVLink on datacenter GPUs
+    try:
+        return torch.cuda.can_device_access_peer(0, 1)
+    except (AssertionError, RuntimeError):
+        return True
+
+
+@functools.lru_cache
+def get_gpu_type() -> NVIDIA_GPU_TYPE:
+    # Prefer compute capability (works for all NVIDIA GPUs, including H200, L40, etc.)
+    if torch.cuda.is_available() and torch.cuda.device_count() > 0:
+        major = torch.cuda.get_device_properties(0).major
+        if major >= 10:
+            return NVIDIA_GPU_TYPE.BLACKWELL
+        if major >= 9:
+            return NVIDIA_GPU_TYPE.HOPPER
+        if major >= 8:
+            return NVIDIA_GPU_TYPE.AMPERE
+        if major >= 7:
+            return NVIDIA_GPU_TYPE.VOLTA
+    # Fallback: nvidia-smi string matching
+    gpu_info = torch.utils.collect_env.get_gpu_info(torch.utils.collect_env.run) or ""
+    if "V100" in gpu_info:
+        return NVIDIA_GPU_TYPE.VOLTA
+    elif "A100" in gpu_info:
+        return NVIDIA_GPU_TYPE.AMPERE
+    elif "H100" in gpu_info:
+        return NVIDIA_GPU_TYPE.HOPPER
+    elif any(gpu in gpu_info for gpu in ("B100", "B200", "B300")):
+        return NVIDIA_GPU_TYPE.BLACKWELL
+    else:
+        return NVIDIA_GPU_TYPE.AMPERE
+
+
+def detect_interconnect(group_size: int) -> InterconnectType:
+    """Auto-detect interconnect type from GPU generation and group topology."""
+    gpus_per_node = torch.cuda.device_count() if torch.cuda.is_available() else 8
+    gpu_gen = get_gpu_type()
+    if math.ceil(group_size / gpus_per_node) == 1:
+        if not _has_nvlink():
+            return InterconnectType.PCIE
+        return _GPU_TO_INTRA.get(gpu_gen, InterconnectType.NVLINK_A100)
+    return _GPU_TO_INTER.get(gpu_gen, InterconnectType.IB_HDR)
+
+
+def get_collective_type_from_kernel_name(kernel_name: str) -> NCCL_COLL:
+    if kernel_name is None:
+        raise AssertionError("kernel_name must not be None")
+    if "all_reduce" in kernel_name:
+        return NCCL_COLL.ALL_REDUCE
+    elif "all_gather" in kernel_name:
+        return NCCL_COLL.ALL_GATHER
+    elif "reduce_scatter" in kernel_name:
+        return NCCL_COLL.REDUCE_SCATTER
+    elif any(comm in kernel_name for comm in ("all_to_all", "alltoall")):
+        return NCCL_COLL.ALL_TO_ALL
+    elif any(comm in kernel_name for comm in ("isend", "irecv", "batch_p2p")):
+        return NCCL_COLL.P2P
+    else:
+        return NCCL_COLL.UNSUPPORTED
+
+
+def get_collective_type(node: ir.IRNode) -> NCCL_COLL:
+    if not isinstance(node, ir._CollectiveKernel):
+        raise ValueError(f"node is not a collective kernel: {node}")
+
+    name = node.python_kernel_name
+    if name is None:
+        raise AssertionError("node.python_kernel_name must not be None")
+    return get_collective_type_from_kernel_name(name)
+
+
+def get_ir_node_size_numel(size: torch.Size, fallback: int = 4096 * 4096) -> int:
+    numel = sympy_product(size)
+    if isinstance(numel, sympy.Integer):
+        return int(numel)
+    return V.graph.sizevars.optimization_hint(numel, fallback=fallback)
+
+
+def get_fx_node_size_numel(size: torch.Size, fallback: int = 4096 * 4096) -> int:
+    numel = functools.reduce(operator.mul, size, 1)
+    result = optimization_hint(numel, fallback=fallback)
+    return result
+
+
+def get_collective_input_size_bytes(node: ir.IRNode) -> int:
+    sz_bytes = 0
+    for inp in node.inputs:  # type: ignore[attr-defined]
+        numel = get_ir_node_size_numel(inp.layout.size)
+        sz_bytes += numel * get_dtype_size(inp.layout.dtype)
+    return sz_bytes
+
+
+def get_collective_group_size(node: ir.IRNode) -> int:
+    if isinstance(node, ir._CollectiveKernel) and not isinstance(node, ir._WaitKernel):
+        from torch.distributed.distributed_c10d import _get_group_size_by_name
+
+        return _get_group_size_by_name(node.constant_args[-1])
+    else:
+        raise TypeError(f"Unsupported collective type: {node}")
+
+
+####################################################################################################################
+# The following code and constants are adapted from https://github.com/NVIDIA/nccl/blob/master/src/graph/tuning.cc #
+####################################################################################################################
+
+
+class NCCL_HW(IntEnum):
+    NVLINK = 0
+    PCI = 1
+    NET = 2
+
+
+class NCCL_ALGO(IntEnum):
+    TREE = 0
+    RING = 1
+
+
+class NCCL_PROTO(IntEnum):
+    # Matches NCCL devcomm.h protocol enum
+    LL = 0  # Low-latency
+    LL128 = 1  # Low-latency 128-byte
+    SIMPLE = 2
+
+
+_NUM_ALGOS = 2  # TREE, RING
+_NUM_PROTOS = 3  # LL, LL128, SIMPLE
+
+# Base latencies in us — [algo][proto]
+# https://github.com/NVIDIA/nccl/blob/master/src/graph/tuning.cc (ncclTunerConstantsDefaults)
+baseLat = [
+    # Tree
+    [6.8, 14.0, 8.4],
+    # Ring
+    [6.6, 14.0, 8.4],
+]
+
+# Hardware latencies in us — [hw][algo][proto]
+# https://github.com/NVIDIA/nccl/blob/master/src/graph/tuning.cc (ncclTunerConstantsDefaults)
+hwLat = [
+    # NVLINK
+    [
+        [0.6, 1.25, 4.0],  # Tree
+        [0.6, 1.9, 3.4],  # Ring
+    ],
+    # PCI
+    [
+        [1.0, 1.9, 4.0],  # Tree
+        [1.0, 2.5, 5.7],  # Ring
+    ],
+    # NET
+    [
+        [5.0, 8.5, 14.0],  # Tree
+        [2.7, 4.0, 14.0],  # Ring
+    ],
+]
+
+
+# LL max bus BW — [compCapIndex][scaleIndex(N1/N2/N4+)]
+# https://github.com/NVIDIA/nccl/blob/master/src/graph/tuning.cc (ncclTunerConstantsDefaults)
+llMaxBws = [
+    [39.0, 39.0, 20.4],  # Volta
+    [87.7, 22.5, 19.0],  # Ampere
+    [141.0, 45.0, 35.0],  # Hopper
+    [282.0, 90.0, 70.0],  # Blackwell
+]
+
+# Per-channel max BW caps — [compCapIndex][scaleIndex]
+# https://github.com/NVIDIA/nccl/blob/master/src/graph/tuning.cc (ncclTunerConstantsDefaults)
+perChMaxRingLL128Bws = [
+    [20.0, 20.0, 20.0],  # Volta
+    [20.0, 20.0, 20.0],  # Ampere
+    [36.7, 36.7, 36.7],  # Hopper
+    [40.0, 40.0, 40.0],  # Blackwell
+]
+
+# https://github.com/NVIDIA/nccl/blob/master/src/graph/tuning.cc (ncclTunerConstantsDefaults)
+perChMaxTreeLL128Bws = [
+    [20.0, 20.0, 20.0],  # Volta
+    [20.0, 20.0, 20.0],  # Ampere
+    [36.7, 36.7, 29.0],  # Hopper
+    [55.6, 31.67, 20.0],  # Blackwell
+]
+
+# https://github.com/NVIDIA/nccl/blob/master/src/graph/tuning.cc (ncclTunerConstantsDefaults)
+perChMaxTreeBws = [
+    [26.5, 18.5, 10.0],  # Volta
+    [24.0, 23.6, 17.8],  # Ampere
+    [38.7, 41.4, 36.0],  # Hopper
+    [70.0, 42.8, 24.0],  # Blackwell
+]
+
+# Tree correction factor for medium message sizes — [proto][logSize]
+# logSize = log2(nBytes >> 6), indices 0..23 map to 64B..256MB
+# https://github.com/NVIDIA/nccl/blob/master/src/graph/tuning.cc (ncclTunerConstantsDefaults)
+treeCorrectionFactor = [
+    # LL
+    [
+        1.0,
+        1.0,
+        1.0,
+        1.0,
+        0.9,
+        0.8,
+        0.7,
+        0.7,
+        0.7,
+        0.7,
+        0.6,
+        0.5,
+        0.4,
+        0.4,
+        0.5,
+        0.6,
+        0.7,
+        0.8,
+        0.9,
+        1.0,
+        1.0,
+        1.0,
+        1.0,
+        1.0,
+    ],
+    # LL128
+    [
+        1.0,
+        1.0,
+        1.0,
+        1.0,
+        1.0,
+        0.9,
+        0.8,
+        0.8,
+        0.8,
+        0.7,
+        0.6,
+        0.6,
+        0.6,
+        0.6,
+        0.6,
+        0.6,
+        0.8,
+        0.9,
+        0.9,
+        0.9,
+        0.9,
+        1.0,
+        1.0,
+        1.0,
+    ],
+    # SIMPLE
+    [
+        0.9,
+        0.9,
+        0.9,
+        0.9,
+        0.9,
+        0.9,
+        0.9,
+        0.8,
+        0.7,
+        0.6,
+        0.6,
+        0.5,
+        0.5,
+        0.5,
+        0.5,
+        0.6,
+        0.7,
+        0.8,
+        0.7,
+        0.7,
+        0.8,
+        0.9,
+        0.9,
+        0.9,
+    ],
+]
+
+# Heuristic nChannels per GPU generation.
+# NCCL selects dynamically via topology search (up to MAXCHANNELS/2=32 for ring).
+# These approximate standard DGX/HGX topologies; see nccl/src/graph/search.cc.
+_GPU_NCHANNELS = {
+    NVIDIA_GPU_TYPE.VOLTA: 2,
+    NVIDIA_GPU_TYPE.AMPERE: 8,
+    NVIDIA_GPU_TYPE.HOPPER: 16,
+    NVIDIA_GPU_TYPE.BLACKWELL: 32,
+}
+
+# NVLink bus bandwidth per GPU (GB/s).
+# https://github.com/NVIDIA/nccl/blob/master/src/graph/topo.h (link speed constants)
+_GPU_NVLINK_BW: dict[NVIDIA_GPU_TYPE, float] = {
+    NVIDIA_GPU_TYPE.VOLTA: 120.0,
+    NVIDIA_GPU_TYPE.AMPERE: 240.0,
+    NVIDIA_GPU_TYPE.HOPPER: 370.0,
+    NVIDIA_GPU_TYPE.BLACKWELL: 720.0,
+}
+
+# PCIe effective intra-node bandwidth (GB/s) for NCCL ring.
+# Conservative: GPU->CPU->GPU ring steps limit effective BW well below link rate.
+_PCIE_INTRA_NODE_BW = 24.0
+
+# Per-GPU inter-node bandwidth (GB/s), assuming 1:1 GPU:NIC ratio.
+# HDR: 200Gbps=25GB/s, NDR: 400Gbps=50GB/s per NIC.
+_GPU_INTER_NODE_BW: dict[NVIDIA_GPU_TYPE, float] = {
+    NVIDIA_GPU_TYPE.VOLTA: 12.0,
+    NVIDIA_GPU_TYPE.AMPERE: 25.0,
+    NVIDIA_GPU_TYPE.HOPPER: 50.0,
+    NVIDIA_GPU_TYPE.BLACKWELL: 50.0,
+}
+
+
+def get_intra_node_bw() -> float:
+    """Return intra-node bandwidth in GB/s. Config overrides auto-detection."""
+    override = torch._inductor.config.intra_node_bw
+    if override is not None:
+        return float(override)
+    if not _has_nvlink():
+        return _PCIE_INTRA_NODE_BW
+    return _GPU_NVLINK_BW.get(get_gpu_type(), 240.0)
+
+
+def get_inter_node_bw() -> float:
+    """Return inter-node (IB/RoCE) bandwidth in GB/s. Config overrides auto-detection."""
+    override = torch._inductor.config.inter_node_bw
+    if override is not None:
+        return float(override)
+    return _GPU_INTER_NODE_BW.get(get_gpu_type(), 25.0)
+
+
+def _log2i(n: int) -> int:
+    """Integer log2, matching NCCL's log2i (floor of log2)."""
+    if n <= 0:
+        return 0
+    r = 0
+    while n > 1:
+        n >>= 1
+        r += 1
+    return r
+
+
+def estimate_nccl_collective_runtime_nccl_estimator(snode) -> float | None:  # type: ignore[no-untyped-def]
+    kernel = snode.node
+    if kernel is None:
+        raise AssertionError("snode.node must not be None")
+    py_kernel_name = getattr(kernel, "python_kernel_name", "")
+    pg_name = kernel.constant_args[-1]  # type: ignore[attr-defined]
+    from torch.distributed.distributed_c10d import _resolve_process_group
+
+    pg = _resolve_process_group(pg_name)
+    rank: int = torch.distributed.get_rank(pg)
+    # TODO(ivankobzarev): Figure out how we can use time estimations,
+    # without cuda allocations.
+    device = torch.device(f"cuda:{rank}")
+
+    fn = eval(py_kernel_name)
+    args, kwargs = snode_args_kwargs(snode)
+
+    # TODO(ivankobzarev): fix out variants snode_args_kwargs
+    if "all_gather_into_tensor_out" in py_kernel_name:
+        args = args[1:] + args[0]
+
+    with torch.distributed._time_estimator(group=pg, device=device) as time_estimator:
+        w = fn(*args, **kwargs)
+        torch.ops._c10d_functional.wait_tensor.default(w)
+
+    est_time_us = time_estimator.estimated_time
+    if est_time_us is None:
+        raise AssertionError("NCCL time estimator did not produce a result")
+    # -1000 constant is NCCL return in case of error during estimations.
+    # Observed it for all_to_all estimations.
+    if est_time_us < 0:
+        return None
+    est_time_ms = est_time_us / 1e3
+    return est_time_ms
+
+
+def _nccl_algo_time(
+    nBytes: int,
+    group_size: int,
+    coll: NCCL_COLL,
+    algo: int,
+    proto: int,
+) -> float:
+    """Compute NCCL estimated time in us for a given (algo, proto) pair.
+
+    Mirrors ncclTopoTuneModel bandwidth/latency computation and
+    ncclTopoGetAlgoTime from NCCL tuning.cc. Returns -1 if the
+    (algo, proto) combination is disabled for this configuration.
+    """
+    gpus_per_node = torch.cuda.device_count() if torch.cuda.is_available() else 8
+    nNodes = math.ceil(group_size / gpus_per_node)
+    nRanks = group_size
+    compCapIndex = get_gpu_type()
+    index2 = nNodes - 1 if nNodes <= 2 else 2
+
+    # Total bus bandwidth (not per-channel). Auto-detected from GPU
+    # generation, or overridden by config. nChannels is only used for
+    # per-channel BW cap table lookups.
+    bwIntra = get_intra_node_bw()
+    bwInter = get_inter_node_bw()
+    nChannels = _GPU_NCHANNELS.get(compCapIndex, 8)
+
+    # Detect interconnect for IB-specific corrections
+    interconnect = detect_interconnect(group_size)
+    is_ib = interconnect in (InterconnectType.IB_NDR, InterconnectType.IB_HDR)
+
+    # LL128: disable for inter-node IB (BW tables calibrated for NVLink only)
+    # and for large-scale multi-node (>2 nodes)
+    if proto == NCCL_PROTO.LL128:
+        if nNodes > 2:
+            return -1.0
+        if nNodes > 1 and is_ib:
+            return -1.0
+
+    # --- Bandwidth computation (mirrors ncclTopoTuneModel) ---
+    # For IB interconnect, always use inter-node BW (bwIntra only for NVLink).
+    # Original NCCL tuning.cc uses bwIntra for nNodes<=2, designed for NVSwitch;
+    # doesn't apply to IB.
+    if nNodes == 1:
+        bw = bwIntra
+    elif is_ib:
+        bw = bwInter
+    else:
+        bw = bwIntra if nNodes <= 2 else bwInter
+
+    # IB corrections calibrated against H100 GrandTeton RoCE profiles
+    # (see agent_space/nccl_model_validation.md for calibration data):
+    if is_ib and nNodes > 1:
+        # NIC efficiency: fewer nodes → fewer NICs utilized → lower effective BW.
+        # 2-node (single inter-hop): ~0.80×; 8+ nodes: ~1.0×
+        nic_efficiency = 0.77 + 0.23 * min(1.0, (nNodes - 1) / 7)
+        bw *= nic_efficiency
+        # Multi-rail: larger messages utilize more NICs (8 NICs per H100 node).
+        # Power-law fit (exponent 0.17) to non-coalesced profile BW vs size.
+        if nNodes > 2:
+            multi_rail = (max(nBytes, 50_000_000) / 50_000_000) ** 0.17
+            bw *= multi_rail
+
+    busBw = bw
+
+    index1 = compCapIndex if nNodes == 1 else 0
+    llMaxBw = llMaxBws[index1][index2]
+
+    if algo == NCCL_ALGO.RING and proto == NCCL_PROTO.LL:
+        busBw = min(llMaxBw, busBw * 0.5)
+    elif algo == NCCL_ALGO.RING and proto == NCCL_PROTO.LL128:
+        busBw = min(
+            busBw * (120.0 / 128.0),
+            nChannels * perChMaxRingLL128Bws[compCapIndex][index2],
+        )
+    elif algo == NCCL_ALGO.TREE and proto == NCCL_PROTO.LL:
+        busBw = min(busBw * (1.0 / 3.8), llMaxBw)
+    elif algo == NCCL_ALGO.TREE and proto == NCCL_PROTO.LL128:
+        factor = 7.0 / 9.0 if nNodes == 1 else 120.0 / 128.0
+        busBw = min(
+            busBw * factor,
+            nChannels * perChMaxTreeLL128Bws[compCapIndex][index2],
+        )
+    elif algo == NCCL_ALGO.TREE and proto == NCCL_PROTO.SIMPLE:
+        if coll == NCCL_COLL.ALL_REDUCE:
+            busBw = min(busBw * 0.92, nChannels * perChMaxTreeBws[compCapIndex][index2])
+    # Ring+SIMPLE: no extra cap beyond busBw
+
+    if busBw <= 0:
+        return -1.0
+
+    # nsteps for the collective
+    if coll == NCCL_COLL.ALL_REDUCE:
+        nsteps = 2 * (nRanks - 1)
+    elif coll in (NCCL_COLL.REDUCE_SCATTER, NCCL_COLL.ALL_GATHER):
+        nsteps = nRanks - 1
+    elif coll == NCCL_COLL.ALL_TO_ALL:
+        nsteps = 2 * (nRanks - 1)
+    elif coll == NCCL_COLL.P2P:
+        nsteps = 1
+    else:
+        return -1.0
+
+    # Bus BW to algorithm BW conversion
+    # Tree allreduce uses 0.5 ratio; Ring uses nRanks/nsteps
+    if algo == NCCL_ALGO.TREE and coll == NCCL_COLL.ALL_REDUCE:
+        bandwidth = busBw * 0.5
+    elif algo == NCCL_ALGO.RING:
+        bandwidth = busBw * (1.0 * nRanks / nsteps)
+    else:
+        bandwidth = busBw * 0.5
+
+    if bandwidth <= 0:
+        return -1.0
+
+    # --- Latency computation (mirrors ncclTopoTuneModel) ---
+    intraHw = NCCL_HW.PCI if interconnect == InterconnectType.PCIE else NCCL_HW.NVLINK
+    lat = baseLat[algo][proto]
+    intraLat = hwLat[intraHw][algo][proto]
+    interLat = hwLat[NCCL_HW.NET][algo][proto]
+
+    netOverhead = 1.0 if nNodes > 1 else 0.0
+    if proto == NCCL_PROTO.SIMPLE and nNodes > 1:
+        netOverhead *= 3.0
+    intraLat = max(intraLat, netOverhead)
+
+    if algo == NCCL_ALGO.RING:
+        nInterSteps = (
+            0
+            if nNodes == 1
+            else (2 * (nNodes - 1) if coll == NCCL_COLL.ALL_REDUCE else nNodes - 1)
+        )
+        lat += (nsteps - nInterSteps) * intraLat + nInterSteps * interLat
+    elif algo == NCCL_ALGO.TREE:
+        if coll == NCCL_COLL.ALL_REDUCE:
+            lat += 2 * (
+                (nRanks // max(nNodes, 1) - 1) * intraLat + _log2i(nNodes) * interLat
+            )
+
+    # --- ncclTopoGetAlgoTime: time = lat + nBytes / (1000 * bandwidth) ---
+    # Tree correction factor for medium messages
+    if algo == NCCL_ALGO.TREE and coll == NCCL_COLL.ALL_REDUCE:
+        logSize = _log2i(nBytes >> 6) if nBytes >= 64 else 0
+        if 0 <= logSize < 24:
+            bandwidth *= treeCorrectionFactor[proto][logSize]
+
+    time_us = lat + nBytes / (1000.0 * bandwidth)
+    return time_us
+
+
+def _nccl_best_algo_time(
+    nBytes: int,
+    group_size: int,
+    coll: NCCL_COLL,
+) -> tuple[float, int, int]:
+    """Find the best (algo, proto) for a given collective and return (time_us, algo, proto).
+
+    Iterates all supported (algo, proto) combinations and picks the one with
+    minimum estimated time, mirroring NCCL's algorithm selection.
+    """
+    best_time = float("inf")
+    best_algo = NCCL_ALGO.RING
+    best_proto = NCCL_PROTO.LL
+
+    for algo in (NCCL_ALGO.TREE, NCCL_ALGO.RING):
+        # Tree only supports allreduce in our model
+        if algo == NCCL_ALGO.TREE and coll != NCCL_COLL.ALL_REDUCE:
+            continue
+        for proto in (NCCL_PROTO.LL, NCCL_PROTO.LL128, NCCL_PROTO.SIMPLE):
+            t = _nccl_algo_time(nBytes, group_size, coll, algo, proto)
+            if 0 <= t < best_time:
+                best_time = t
+                best_algo = algo
+                best_proto = proto
+
+    return best_time, best_algo, best_proto
+
+
+def estimate_nccl_collective_runtime_impl(
+    tensor_storage_size_bytes: int, group_size: int, coll: NCCL_COLL
+) -> float:
+    """Returns estimated NCCL collective runtime in milliseconds (ms).
+
+    Uses a multi-algorithm, multi-protocol model aligned with NCCL's
+    ncclTopoTuneModel and ncclTopoGetAlgoTime (tuning.cc). Evaluates
+    Ring and Tree algorithms across LL, LL128, and SIMPLE protocols,
+    selecting the (algo, proto) pair that minimizes estimated time.
+    """
+    if group_size <= 1:
+        return 0
+
+    if coll == NCCL_COLL.UNSUPPORTED:
+        return 0
+
+    time_us, _, _ = _nccl_best_algo_time(tensor_storage_size_bytes, group_size, coll)
+    if time_us < 0 or time_us == float("inf"):
+        return 0
+    return time_us / 1000.0
+
+
+def compute_min_saturation_bytes(
+    group_size: int,
+    coll: NCCL_COLL,
+    target_efficiency: float = 0.9,
+) -> int:
+    """Compute min message size for target BW efficiency using empirical profiles.
+
+    Uses per-interconnect profiles calibrated to real NCCL behavior (algorithm,
+    protocol, channel selection) rather than the analytical model.
+    """
+    _SUPPORTED = (NCCL_COLL.ALL_GATHER, NCCL_COLL.REDUCE_SCATTER, NCCL_COLL.ALL_REDUCE)
+    if coll not in _SUPPORTED:
+        raise AssertionError(
+            f"Unsupported collective {coll}, expected one of {_SUPPORTED}"
+        )
+
+    if group_size <= 1:
+        return 0
+
+    profile = INTERCONNECT_PROFILES[detect_interconnect(group_size)]
+
+    if coll in (NCCL_COLL.ALL_GATHER, NCCL_COLL.REDUCE_SCATTER):
+        nsteps = group_size - 1
+    elif coll == NCCL_COLL.ALL_REDUCE:
+        nsteps = 2 * (group_size - 1)
+    else:
+        return 0
+
+    total_latency_us = profile.base_latency_us + nsteps * profile.latency_per_hop_us
+    latency_s = total_latency_us * 1e-6
+    bw_bytes_per_s = profile.bus_bw_GBps * 1e9
+    eff_ratio = target_efficiency / (1.0 - target_efficiency)
+    min_bytes = int(eff_ratio * latency_s * bw_bytes_per_s)
+    return max(min_bytes, profile.min_saturation_bytes)
+
+
+################################################################################################################
+# The above code and constants are adapted from https://github.com/NVIDIA/nccl/blob/master/src/graph/tuning.cc #
+################################################################################################################
+
+
+def estimate_nccl_collective_runtime(node: ir.IRNode) -> float:
+    """Returns estimated NCCL collective runtime in milliseconds (ms).
+
+    Uses the multi-algorithm, multi-protocol analytical model aligned with
+    NCCL's tuning.cc to select the best (algo, proto) pair for the given
+    collective size and topology.
+    """
+    tensor_storage_size_bytes = get_collective_input_size_bytes(node)
+    group_size = get_collective_group_size(node)
+    coll = get_collective_type(node)
+    return estimate_nccl_collective_runtime_impl(
+        tensor_storage_size_bytes, group_size, coll
+    )
+
+
+def estimate_fx_collective_size(fx_node: torch.fx.Node) -> int:
+    """Estimate the size of a collective operation in bytes, including inputs and outputs."""
+    input_bytes = None
+
+    args, kwargs = fx_node.args, fx_node.kwargs
+    kwargs = dict(kwargs)
+
+    # don't double count pre-allocated buffer passed in
+    kwargs.pop("out", None)
+
+    def tensor_bytes(t: torch.Tensor) -> int:
+        return get_fx_node_size_numel(t.size()) * get_dtype_size(t.dtype)
+
+    def add_inp_bytes(inp: torch.fx.Node):
+        inp_val = inp.meta.get("val", None)
+        if not isinstance(inp_val, torch.Tensor):
+            return
+
+        nonlocal input_bytes
+        if input_bytes is None:
+            input_bytes = 0
+        input_bytes += tensor_bytes(inp_val)
+
+    pytree.tree_map_only(
+        torch.fx.Node,
+        add_inp_bytes,
+        (args, kwargs),
+    )
+
+    output_val = fx_node.meta.get("val", None)
+
+    if input_bytes is None or output_val is None:
+        return 0
+
+    # Coalesced collectives return a list of tensors
+    if isinstance(output_val, (list, tuple)):
+        output_bytes = sum(
+            tensor_bytes(t) for t in output_val if isinstance(t, torch.Tensor)
+        )
+    elif isinstance(output_val, torch.Tensor):
+        output_bytes = tensor_bytes(output_val)
+    else:
+        return 0
+
+    return input_bytes + output_bytes
+
+
+def estimate_fx_collective_memory_footprint(fx_node: torch.fx.Node) -> int:
+    """Estimate the memory footprint of a collective operation in bytes.
+
+    This returns the total bytes that need to be live concurrently in memory.
+    For all_reduce, we divide by 2 since it can be done in-place.
+    """
+    from torch._inductor.fx_passes.bucketing import (
+        is_all_reduce_tensor as is_all_reduce,
+    )
+
+    size = estimate_fx_collective_size(fx_node)
+    return size if not is_all_reduce(fx_node) else size // 2
+
+
+def estimate_nccl_collective_runtime_from_fx_node(
+    fx_node: torch.fx.Node,
+    override_size: int | None = None,
+    use_nccl_estimator: bool = True,
+) -> float:
+    """Returns estimated NCCL collective runtime in milliseconds (ms).
+
+    Tries the NCCL simulator first (if available and enabled), falls back
+    to the multi-algo/proto analytical model from tuning.cc.
+    """
+    from torch.distributed.distributed_c10d import _get_group_size_by_name
+
+    if fx_node.target is torch.ops._c10d_functional.all_to_all_single.default:
+        # TODO(ivankobzarev): Temporarily disabled - NCCL estimator returns internal error.
+        # for all_to_all during inductor compilation. Falls back to heuristic estimation.
+        use_nccl_estimator = False
+
+    if override_size is None:
+        tensor_storage_size_bytes = estimate_fx_collective_size(fx_node)
+    else:
+        tensor_storage_size_bytes = override_size
+
+    if isinstance(fx_node.target, str):
+        raise AssertionError(f"fx_node.target must not be a str, got {fx_node.target}")
+    opt_args_kwargs = normalize_function(
+        fx_node.target,
+        args=fx_node.args,
+        kwargs=fx_node.kwargs,
+        normalize_to_only_use_kwargs=True,
+    )
+    if opt_args_kwargs is None:
+        raise AssertionError("normalize_function returned None")
+    args, kwargs = opt_args_kwargs
+
+    from torch._inductor.fx_passes.bucketing import _resolve_group_name
+
+    group_name = _resolve_group_name(kwargs["group_name"])
+    group_size = _get_group_size_by_name(group_name)
+    if not isinstance(fx_node.target, torch._ops.OpOverload):
+        raise AssertionError(
+            f"expected fx_node.target to be an OpOverload, got {type(fx_node.target)}"
+        )
+    coll = get_collective_type_from_kernel_name(fx_node.target.name())
+
+    def _nccl_estimate() -> float | None:
+        # TODO: Refactor with estimate_nccl_collective_runtime_nccl_estimator
+        from torch.distributed.distributed_c10d import _resolve_process_group, Backend
+
+        pg = _resolve_process_group(group_name)
+        if torch.distributed.distributed_c10d.get_backend(pg) == Backend.FAKE:
+            # nccl estimator requires real process group
+            return None
+
+        device = torch.device("cuda")
+        try:
+            backend = pg._get_backend(device)
+        except RuntimeError:
+            return None
+        if not backend.supports_time_estimate:
+            return None
+
+        flat_args, flat_args_pytree_spec = pytree.tree_flatten((args, kwargs))
+
+        def _tensor(size, dtype, device) -> torch.Tensor:  # type: ignore[no-untyped-def]
+            return torch.empty(
+                size if override_size is None else [override_size],
+                dtype=dtype,
+                device=device,
+            )
+
+        def to_real_tensor(e: Any) -> Any:
+            if isinstance(e, torch.fx.Node):
+                return to_real_tensor(e.meta["val"])
+            if isinstance(e, torch.Tensor):
+                return _tensor([get_fx_node_size_numel(e.size())], e.dtype, e.device)
+            return e
+
+        flat_args = [to_real_tensor(a) for a in flat_args]
+        real_args, real_kwargs = pytree.tree_unflatten(flat_args, flat_args_pytree_spec)
+
+        fn = fx_node.target
+        if not isinstance(fn, torch._ops.OpOverload):
+            raise AssertionError(
+                f"expected fx_node.target to be an OpOverload, got {type(fn)}"
+            )
+        with torch.distributed._time_estimator(
+            group=pg, device=device
+        ) as time_estimator:
+            w = fn(*real_args, **real_kwargs)
+            # Coalesced collectives return a list of tensors
+            if isinstance(w, (list, tuple)):
+                for t in w:
+                    torch.ops._c10d_functional.wait_tensor.default(t)
+            else:
+                torch.ops._c10d_functional.wait_tensor.default(w)
+        est_time_us = time_estimator.estimated_time
+        if est_time_us is None:
+            raise AssertionError("NCCL time estimator did not produce a result")
+        # -1000 constant is NCCL return in case of error during estimations.
+        # Observed it for all_to_all estimations.
+        if est_time_us < 0:
+            return None
+        est_time_ms = est_time_us / 1e3
+        return est_time_ms
+
+    if use_nccl_estimator:
+        est_time_ms = _nccl_estimate()
+        if est_time_ms is not None:
+            return est_time_ms
+
+    return estimate_nccl_collective_runtime_impl(
+        tensor_storage_size_bytes, group_size, coll
+    )

.venv/lib/python3.12/site-packages/torch/_inductor/comm_lowering.py

@@ -0,0 +1,967 @@
+# mypy: allow-untyped-defs
+import logging
+
+import torch
+import torch.utils._pytree as pytree
+from torch._inductor.utils import is_symbolic
+from torch.utils._ordered_set import OrderedSet
+
+from . import config, ir
+from .virtualized import V
+
+
+log = logging.getLogger(__name__)
+
+
+# NOTE [lowering-time collective optimization]
+#
+# In collective communication libraries such as NCCL, every rank maintains
+# communication buffers that are remotely accessible by some peers. Depending
+# on the underlying transport, remote accessibility may be established via
+# mechanisms such as ib_reg_mr, CUDA P2P, or CUDA multicast. Typically, these
+# buffers are private to the communication library by default, and
+# communication ops copy user data in and out of these buffers.
+#
+# To prevent these copies, an optimization commonly known as "user buffer
+# registration" can be employed. This allows direct establishment of remote
+# accessibility on user buffers, eliminating the need for copying. However,
+# this optimization introduces stringent usage requirements, which are
+# typically hard to satisfy without being intrusive to the user code:
+#
+# - Establishing remote accessibility is expensive and often done ahead of
+# time. In such implementations, all ranks must agree on the set of allocations
+# used for every collective op. Failing to meet this requirement can
+# lead to runtime errors or even silent correctness issues.
+# - Even if the collective communication library supports gracefully falling
+# back to "unregistered" implementations, the fallback mechanism would nullify
+# the optimization.
+# - Some communication mechanisms impose stricter requirements than others. For
+# example, CUDA's multicast + multi-mem instructions require all ranks to agree
+# not only on the allocations used for every collective but also on the offsets
+# within these allocations.
+#
+# To support all different mechanisms with optimal results, we aim to satisfy
+# the strictest requirement for this family of optimizations - we ensure that
+# every collective op invocation is guaranteed to operate on the same
+# allocation, at the same offset, in every iteration.
+#
+# For eligible collective ops, we identify communication buffers at lowering
+# time and optionally choose to lower the op to a different kernel
+# (communication libraries like NCCL handle both registered and non-registered
+# buffers transparently within the same op, though some may require different
+# ops for different cases). Later, the codegen will perform "persistent
+# allocation" to satisfy the aforementioned constraints, and optionally,
+# perform buffer planning to optimize overall memory usage.
+def can_realize_as_comm_buffer(
+    x: ir.TensorBox, comm_buffer_type: ir.CommBufferType
+) -> bool:
+    """
+    Check if an input can be realized as a comm buffer of the specified
+    `comm_buffer_type`.
+    """
+    data = _get_data(x)
+
+    if isinstance(data, ir.Loops):
+        return True
+
+    # We cannot realize buffers as comm buffers if we don't control their
+    # allocation.
+    if isinstance(data, ir.Buffer) and not data.should_allocate():
+        return False
+
+    layout = data.get_output_spec()
+    if isinstance(layout, ir.CommBufferLayout):
+        return True
+
+    if isinstance(layout, ir.FixedLayout):
+        return True
+
+    if isinstance(layout, ir.FlexibleLayout) and not is_symbolic(data.get_numel()):
+        return True
+
+    return False
+
+
+def realize_as_comm_buffer(
+    x: ir.TensorBox,
+    comm_buffer_type: ir.CommBufferType,
+    group_name: "torch.distributed.distributed_c10d.GroupName",
+) -> None:
+    """
+    Realize an input as a comm buffer of the specified `comm_buffer_type`.
+
+    Specifically, this realizes the underlying buffer if it's still unrealized
+    and changes the layout of the buffer to `ir.CommBufferLayout`.
+    """
+    x.realize()
+    buffer = _get_data(x)
+    if not isinstance(buffer, ir.Buffer):
+        raise AssertionError(f"expected an `ir.Buffer`, got {type(buffer)}")
+
+    layout = buffer.get_output_spec()
+    if isinstance(layout, ir.CommBufferLayout):
+        return
+
+    # The buffer may have already been frozen to FixedLayout if it was used
+    # by another operation before the comm operation.
+    if not isinstance(layout, (ir.FlexibleLayout, ir.FixedLayout)):
+        raise AssertionError(
+            "A buffer can only be realized as a comm buffer if it "
+            f"has `FlexibleLayout` or `FixedLayout` (got {layout})."
+        )
+
+    if is_symbolic(buffer.get_numel()):
+        raise AssertionError(
+            "A buffer with symbolic shape cannot be converted to "
+            f"a comm buffer (got {layout})."
+        )
+
+    buffer.layout = ir.CommBufferLayout(
+        layout=layout,
+        comm_buffer_type=comm_buffer_type,
+        group_name=group_name,
+    )
+
+
+def _get_data(x: ir.TensorBox) -> ir.IRNode:
+    if isinstance(x.data, ir.BaseView):
+        # TensorBox -> *View -> StorageBox -> IRNode
+        node = x.data.unwrap_view()
+        if not isinstance(node, (ir.BaseView, ir.MutableBox)):
+            raise AssertionError(
+                f"expected an `ir.BaseView` or `ir.MutableBox`, got {type(node)}"
+            )
+        return node.data
+    elif isinstance(x.data, ir.StorageBox):
+        # TensorBox -> StorageBox -> IRNode
+        return x.data.data
+    else:
+        raise AssertionError(
+            "Expect the data attr of a `TensorBox` to be either "
+            f"an `ir.BaseView` or `ir.StorageBox` (got {x.data})."
+        )
+
+
+_bufs_to_skip_wait = OrderedSet[tuple[int, str]]()
+
+
+def mark_as_skip_wait(x: ir.IRNode) -> None:
+    """
+    If a non-blocking collective is lowered as a blocking collective, the wait
+    node in the original graph becomes useless and we can skip the lowering it.
+    """
+    _bufs_to_skip_wait.add((id(V.graph), x.get_name()))
+
+
+def should_skip_wait(x: ir.IRNode) -> bool:
+    return (id(V.graph), x.get_name()) in _bufs_to_skip_wait
+
+
+def _should_lower_as_one_shot_all_reduce(
+    inp: ir.TensorBox,
+    reduce_op: str,
+    group_name: "torch.distributed.distributed_c10d.GroupName",
+):
+    from torch.distributed._symmetric_memory import is_symm_mem_enabled_for_group
+
+    inp_size = inp.get_numel() * inp.get_dtype().itemsize
+    return (
+        config._collective.auto_select
+        and is_symm_mem_enabled_for_group(group_name)
+        and can_realize_as_comm_buffer(inp, ir.CommBufferType.SYMM_MEM)
+        and reduce_op == "sum"
+        and inp_size <= config._collective.one_shot_all_reduce_threshold_bytes
+    )
+
+
+def _one_shot_all_reduce(inp: ir.TensorBox, reduce_op, group_name):
+    realize_as_comm_buffer(inp, ir.CommBufferType.SYMM_MEM, group_name)
+    return pytree.tree_map(
+        ir.TensorBox.create,
+        ir.FallbackKernel.create(
+            torch.ops.symm_mem.one_shot_all_reduce.default,
+            inp,
+            reduce_op,
+            group_name,
+        ),
+    )
+
+
+def _create_out_of_place(kernel, inputs, *args) -> ir.IRNode:
+    node = ir._CollectiveKernel.create_out_of_place(kernel, inputs, *args)
+    if not isinstance(node, ir.IRNode):
+        raise AssertionError(f"expected an `ir.IRNode`, got {type(node)}")
+    return ir.TensorBox.create(node)
+
+
+def register_comm_lowerings():
+    """
+    Register lowerings for the comm subsystem.
+    """
+    try:
+        _ = torch.ops._c10d_functional.all_reduce
+    except AttributeError:
+        log.info(
+            "Inductor support for distributed collectives depends on building "
+            "torch.distributed"
+        )
+        return
+
+    from .lowering import (
+        add_layout_constraint,
+        clone,
+        constrain_to_fx_strides,
+        copy_,
+        register_lowering,
+    )
+
+    def register_comm_lowering(fn):
+        add_layout_constraint(fn, constrain_to_fx_strides)
+        return register_lowering(fn)
+
+    c10d = torch.ops._c10d_functional
+
+    @register_comm_lowering(c10d.all_reduce)  # type: ignore[misc]
+    def _all_reduce(
+        inp: ir.TensorBox,
+        reduce_op: str,
+        group_name: "torch.distributed.distributed_c10d.GroupName",
+    ) -> ir.TensorBox:
+        if _should_lower_as_one_shot_all_reduce(inp, reduce_op, group_name):
+            return _one_shot_all_reduce(inp, reduce_op, group_name)
+
+        # Lower as c10d.all_reduce_
+        inp = clone(inp)
+        if config.reorder_for_compute_comm_overlap:
+            # The horizontal fusion of this clone often severely delays the
+            # scheduling of the all_reduce_ node. Horizontally fusing this
+            # clone can almost never out-perform scheduling the all_reduce_
+            # earlier. Also in most cases, this clone is eliminated via
+            # in-place reuse. Therefore, we tell the scheduler to not fuse it.
+            inp.realize()
+            V.graph.no_fuse_buffer_names.add(inp.get_name())
+        # pyrefly: ignore [bad-assignment]
+        inp = ir.ExternKernel.require_contiguous(inp)
+        # Because we are lowering as inplace c10d.all_reduce_, we should generate
+        # _AllReduce_Kernel instead of _AllReduceKernel.
+        ir._AllReduce_Kernel.create_inplace(
+            c10d.all_reduce_.default,
+            inp,  # type: ignore[arg-type]
+            reduce_op,
+            group_name,  # type: ignore[arg-type]
+        )
+        return inp  # type: ignore[return-value]
+
+    @register_comm_lowering(c10d.all_reduce_)  # type: ignore[misc]
+    def _all_reduce_(
+        inp: ir.TensorBox,
+        reduce_op: str,
+        group_name: "torch.distributed.distributed_c10d.GroupName",
+    ) -> ir.TensorBox:
+        if _should_lower_as_one_shot_all_reduce(inp, reduce_op, group_name):
+            ret = copy_(
+                inp,
+                _one_shot_all_reduce(inp, reduce_op, group_name),
+            )
+            mark_as_skip_wait(ret)
+            return inp
+
+        # Lower as c10d.all_reduce_
+        # pyrefly: ignore [bad-assignment]
+        inp = ir.ExternKernel.require_contiguous(inp)
+        ir._AllReduce_Kernel.create_inplace(
+            c10d.all_reduce_.default,
+            inp,  # type: ignore[arg-type]
+            reduce_op,
+            group_name,  # type: ignore[arg-type]
+        )
+        return inp  # type: ignore[return-value]
+
+    @register_comm_lowering(c10d.all_reduce_coalesced)
+    def _all_reduce_coalesced(inputs, reduce_op, group_name):
+        inputs = [clone(inp) for inp in inputs]
+        ir._CollectiveKernel.create_inplace(
+            c10d.all_reduce_coalesced_.default,
+            inputs,
+            reduce_op,
+            group_name,
+        )
+        return inputs
+
+    @register_comm_lowering(c10d.all_reduce_coalesced_)
+    def _all_reduce_coalesced_(inputs, reduce_op, group_name):
+        ir._CollectiveKernel.create_inplace(
+            c10d.all_reduce_coalesced_.default,
+            inputs,
+            reduce_op,
+            group_name,
+        )
+        return inputs
+
+    @register_comm_lowering(c10d.all_gather_into_tensor)
+    def _all_gather_into_tensor(inp, group_size, group_name):
+        return _create_out_of_place(
+            c10d.all_gather_into_tensor.default,
+            inp,
+            group_size,
+            group_name,
+        )
+
+    @register_comm_lowering(c10d.all_gather_into_tensor_coalesced)
+    def _all_gather_into_tensor_coalesced(inputs, group_size, group_name):
+        return pytree.tree_map(
+            ir.TensorBox.create,
+            ir._CollectiveKernel.create_out_of_place(
+                c10d.all_gather_into_tensor_coalesced.default,
+                inputs,
+                group_size,
+                group_name,
+            ),
+        )
+
+    @register_comm_lowering(c10d.all_gather_into_tensor_out)
+    def _all_gather_into_tensor_out(inp, group_size, group_name, *, out):
+        ir._CollectiveKernel.create_inplace(
+            c10d.all_gather_into_tensor_out.default,
+            inp,
+            group_size,
+            group_name,
+            out=out,
+        )
+        return out
+
+    @register_comm_lowering(c10d.reduce_scatter_tensor)
+    def _reduce_scatter_tensor(inp, reduce_op, group_size, group_name):
+        return _create_out_of_place(
+            c10d.reduce_scatter_tensor.default,
+            inp,
+            reduce_op,
+            group_size,
+            group_name,
+        )
+
+    @register_comm_lowering(c10d.reduce_scatter_tensor_out)
+    def _reduce_scatter_tensor_out(inp, reduce_op, group_size, group_name, *, out):
+        ir._CollectiveKernel.create_inplace(
+            c10d.reduce_scatter_tensor_out.default,
+            inp,
+            reduce_op,
+            group_size,
+            group_name,
+            out=out,
+        )
+        return out
+
+    @register_comm_lowering(c10d.reduce_scatter_tensor_coalesced)
+    def _reduce_scatter_tensor_coalesced(inputs, reduce_op, group_size, group_name):
+        return pytree.tree_map(
+            ir.TensorBox.create,
+            ir._CollectiveKernel.create_out_of_place(
+                c10d.reduce_scatter_tensor_coalesced.default,
+                inputs,
+                reduce_op,
+                group_size,
+                group_name,
+            ),
+        )
+
+    @register_comm_lowering(c10d.all_to_all_single)
+    def _all_to_all_single(inp, output_split_sizes, input_split_sizes, group_name):
+        return _create_out_of_place(
+            c10d.all_to_all_single.default,
+            inp,
+            output_split_sizes,
+            input_split_sizes,
+            group_name,
+        )
+
+    @register_comm_lowering(c10d.broadcast)
+    def _broadcast(inp, src, group_name):
+        inp = clone(inp)
+        ir._CollectiveKernel.create_inplace(
+            c10d.broadcast_.default, inp, src, group_name
+        )
+        return inp
+
+    @register_comm_lowering(c10d.broadcast_)
+    def _broadcast_(inp, src, group_name):
+        ir._CollectiveKernel.create_inplace(
+            c10d.broadcast_.default, inp, src, group_name
+        )
+        return inp
+
+    @register_comm_lowering(torch.ops._dtensor.shard_dim_alltoall)
+    def _shard_dim_alltoall(inp, gather_dim, shard_dim, group_name):
+        return _create_out_of_place(
+            torch.ops._dtensor.shard_dim_alltoall.default,
+            inp,
+            gather_dim,
+            shard_dim,
+            group_name,
+        )
+
+    @register_comm_lowering(c10d.wait_tensor)
+    def _wait_tensor(inp):
+        if should_skip_wait(inp):
+            return inp
+
+        ir._WaitKernel.create_wait(c10d.wait_tensor.default, inp)
+        return inp
+
+    @register_comm_lowering(c10d.isend)  # type: ignore[misc]
+    def _isend(inp, dst, tag, group_name):
+        inp = ir.ExternKernel.require_contiguous(inp)
+        return _create_out_of_place(c10d.isend.default, inp, dst, tag, group_name)
+
+    @register_comm_lowering(c10d.irecv)  # type: ignore[misc]
+    def _irecv(inp, src, tag, group_name):
+        inp = ir.ExternKernel.require_contiguous(inp)
+        ir._CollectiveKernel.create_inplace(
+            c10d.irecv.default, inp, src, tag, group_name
+        )
+        return inp
+
+    @register_comm_lowering(c10d.batch_p2p_ops)  # type: ignore[misc]
+    def _batch_p2p_ops(op_list, peer_list, tag_list, tensors, group_name):
+        tensors = [ir.ExternKernel.require_contiguous(t) for t in tensors]
+        kernel = c10d.batch_p2p_ops.default
+        with V.graph.fake_mode:
+            result = ir._CollectiveKernel.process_kernel(
+                kernel,
+                op_list,
+                peer_list,
+                tag_list,
+                tensors,
+                group_name,
+            )
+        example_output = result.example_output
+        tensor_args = result.tensor_args
+        non_tensor_args = result.non_tensor_args
+        unflatten_args = result.unflatten_args
+        if result.unbacked_bindings:
+            raise AssertionError(f"{kernel} {result.unbacked_bindings}")
+        for op, tensor_arg in zip(op_list, tensor_args):
+            tensor_arg.realize()
+            if op == "irecv":
+                V.graph.mark_buffer_mutated(tensor_arg.get_name())
+
+        device = tensor_args[0].get_device_or_error()
+        packed = ir._CollectiveKernel(
+            ir.MultiOutputLayout(device=device),
+            kernel,
+            tensor_args,
+            non_tensor_args,
+            unflatten_args,
+        )
+
+        results = []
+        for i, (op, t, ex_out) in enumerate(zip(op_list, tensors, example_output)):
+            if op == "irecv":
+                packed.mutation_outputs.append(
+                    ir.MutationOutput(ir.NoneLayout(device=device), t, packed)
+                )
+                packed.alias_names.append(t.get_name())
+                results.append(t)
+            else:
+                # isend: 0-element placeholder output connected to the collective
+                placeholder = ir.MultiOutput(
+                    ir._CollectiveKernel.tensor_to_layout(ex_out),
+                    packed,
+                    [(list, i)],
+                )
+                results.append(ir.TensorBox.create(placeholder))
+        return results
+
+
+def register_symm_mem_lowerings():
+    """
+    Register lowerings for symmetric memory (symm_mem) operations.
+    """
+    try:
+        symm_mem = torch.ops.symm_mem
+        # Check for an actual operation, not just the namespace.
+        # torch.ops.symm_mem is a lazy namespace that always exists,
+        # but the operations may not exist on non-CUDA platforms or
+        # when USE_DISTRIBUTED is disabled.
+        _ = symm_mem.one_shot_all_reduce
+    except AttributeError:
+        log.info("symm_mem ops not available, skipping symm_mem lowerings")
+        return
+
+    from torch._library._out_variant import register_out_variant
+
+    # Register manual out variant mappings for symm_mem ops.
+    register_out_variant(
+        symm_mem.one_shot_all_reduce.default,
+        symm_mem.one_shot_all_reduce_out.default,
+    )
+    register_out_variant(
+        symm_mem.one_shot_all_reduce_copy.default,
+        symm_mem.one_shot_all_reduce_copy_out.default,
+    )
+
+    from .lowering import register_lowering
+
+    def _copy_input_to_comm_buffer(
+        inp: ir.TensorBox,
+        comm_buffer_type: ir.CommBufferType,
+        group_name: "torch.distributed.distributed_c10d.GroupName",
+    ) -> ir.TensorBox:
+        """
+        Fallback: insert a Pointwise identity copy allocated in P2P via
+        CommBufferLayout.  Used when we don't control the input's allocation.
+        """
+        inp.realize()
+        copy = ir.Pointwise.create(
+            device=inp.get_device(),
+            dtype=inp.get_dtype(),
+            inner_fn=inp.make_loader(),
+            ranges=inp.get_size(),
+        )
+        realize_as_comm_buffer(copy, comm_buffer_type, group_name)
+        return copy
+
+    def _maybe_realize_symm_mem(
+        inp: ir.TensorBox,
+        group_name: str,  # type: ignore[arg-type]
+    ) -> ir.TensorBox:
+        """
+        Ensure inp is in P2P memory for a symm_mem collective.
+
+        If inductor controls the buffer's allocation (ComputedBuffer,
+        or any buffer with FlexibleLayout/FixedLayout), switch its
+        layout to CommBufferLayout in-place, zero-copy.
+
+        If inductor does not control allocation (e.g. InputBuffer),
+        insert a Pointwise identity copy into a new CommBufferLayout buffer.
+        This adds an extra Triton kernel. Returns the possibly new TensorBox.
+
+        TODO(tianrengao): eliminate the extra kernel for static-shape
+        InputBuffers by pre-allocating P2P memory in the wrapper and DMA .copy_()
+        """
+        if can_realize_as_comm_buffer(inp, ir.CommBufferType.SYMM_MEM):
+            realize_as_comm_buffer(inp, ir.CommBufferType.SYMM_MEM, group_name)  # type: ignore[arg-type]
+            return inp
+        else:
+            return _copy_input_to_comm_buffer(
+                inp,
+                ir.CommBufferType.SYMM_MEM,
+                group_name,  # type: ignore[arg-type]
+            )
+
+    def _create_low_contention_ag_out(
+        kernel: torch._ops.OpOverload,
+        inp: ir.TensorBox,
+        group_name: "torch.distributed.distributed_c10d.GroupName",
+    ) -> ir.TensorBox:
+        from torch.distributed import distributed_c10d as c10d
+
+        inp.realize()
+        group_size = c10d._get_group_size_by_name(group_name)
+        out_size = [inp.get_size()[0] * group_size, *inp.get_size()[1:]]
+        layout = ir.CommBufferLayout(
+            ir.FixedLayout(
+                device=inp.get_device_or_error(),
+                dtype=inp.get_dtype(),
+                size=out_size,
+            ),
+            ir.CommBufferType.SYMM_MEM,
+            group_name,
+        )
+        return ir.TensorBox.create(
+            ir.ExternKernelOut(
+                layout=layout,
+                inputs=[inp],
+                constant_args=(group_name,),
+                op_overload=kernel,
+            )
+        )
+
+    @register_lowering(symm_mem.one_shot_all_reduce)
+    def _symm_mem_one_shot_all_reduce(
+        inp: ir.TensorBox,
+        reduce_op: str,
+        group_name: str,
+    ):
+        inp = _maybe_realize_symm_mem(inp, group_name)
+        return pytree.tree_map(
+            ir.TensorBox.create,
+            ir.FallbackKernel.create(
+                symm_mem.one_shot_all_reduce.default,
+                inp,
+                reduce_op,
+                group_name,
+            ),
+        )
+
+    @register_lowering(symm_mem.one_shot_all_reduce_out)
+    def _symm_mem_one_shot_all_reduce_out(
+        inp: ir.TensorBox,
+        reduce_op: str,
+        group_name: str,
+        out: ir.TensorBox,
+    ):
+        inp = _maybe_realize_symm_mem(inp, group_name)
+        return pytree.tree_map(
+            ir.TensorBox.create,
+            ir.FallbackKernel.create(
+                symm_mem.one_shot_all_reduce_out.default,
+                inp,
+                reduce_op,
+                group_name,
+                out,
+            ),
+        )
+
+    @register_lowering(symm_mem.one_shot_all_reduce_copy)
+    def _symm_mem_one_shot_all_reduce_copy(
+        symm_buffer: ir.TensorBox,
+        local_input: ir.TensorBox,
+        reduce_op: str,
+        group_name: str,
+    ):
+        symm_buffer = _maybe_realize_symm_mem(symm_buffer, group_name)
+        return pytree.tree_map(
+            ir.TensorBox.create,
+            ir.FallbackKernel.create(
+                symm_mem.one_shot_all_reduce_copy.default,
+                symm_buffer,
+                local_input,
+                reduce_op,
+                group_name,
+            ),
+        )
+
+    @register_lowering(symm_mem.one_shot_all_reduce_copy_out)
+    def _symm_mem_one_shot_all_reduce_copy_out(
+        symm_buffer: ir.TensorBox,
+        local_input: ir.TensorBox,
+        reduce_op: str,
+        group_name: str,
+        out: ir.TensorBox,
+    ):
+        symm_buffer = _maybe_realize_symm_mem(symm_buffer, group_name)
+        return pytree.tree_map(
+            ir.TensorBox.create,
+            ir.FallbackKernel.create(
+                symm_mem.one_shot_all_reduce_copy_out.default,
+                symm_buffer,
+                local_input,
+                reduce_op,
+                group_name,
+                out,
+            ),
+        )
+
+    @register_lowering(symm_mem.two_shot_all_reduce_)
+    def _symm_mem_two_shot_all_reduce_(
+        inp: ir.TensorBox,
+        reduce_op: str,
+        group_name: str,
+    ):
+        inp = _maybe_realize_symm_mem(inp, group_name)
+        ir.FallbackKernel.create(
+            symm_mem.two_shot_all_reduce_.default,
+            inp,
+            reduce_op,
+            group_name,
+        )
+        return inp
+
+    @register_lowering(symm_mem.two_shot_all_reduce_out)
+    def _symm_mem_two_shot_all_reduce_out(
+        inp: ir.TensorBox,
+        reduce_op: str,
+        group_name: str,
+        output: ir.TensorBox,
+    ):
+        inp = _maybe_realize_symm_mem(inp, group_name)
+        return pytree.tree_map(
+            ir.TensorBox.create,
+            ir.FallbackKernel.create(
+                symm_mem.two_shot_all_reduce_out.default,
+                inp,
+                reduce_op,
+                group_name,
+                output,
+            ),
+        )
+
+    @register_lowering(symm_mem.multimem_all_reduce_)
+    def _symm_mem_multimem_all_reduce_(
+        inp: ir.TensorBox,
+        reduce_op: str,
+        group_name: str,
+    ):
+        inp = _maybe_realize_symm_mem(inp, group_name)
+        ir.FallbackKernel.create(
+            symm_mem.multimem_all_reduce_.default,
+            inp,
+            reduce_op,
+            group_name,
+        )
+        return inp
+
+    @register_lowering(symm_mem.multimem_one_shot_all_reduce)
+    def _symm_mem_multimem_one_shot_all_reduce(
+        inp: ir.TensorBox,
+        reduce_op: str,
+        group_name: str,
+    ):
+        inp = _maybe_realize_symm_mem(inp, group_name)
+        return pytree.tree_map(
+            ir.TensorBox.create,
+            ir.FallbackKernel.create(
+                symm_mem.multimem_one_shot_all_reduce.default,
+                inp,
+                reduce_op,
+                group_name,
+            ),
+        )
+
+    @register_lowering(symm_mem.multimem_one_shot_all_reduce_out)
+    def _symm_mem_multimem_one_shot_all_reduce_out(
+        inp: ir.TensorBox,
+        reduce_op: str,
+        group_name: str,
+        out: ir.TensorBox,
+    ):
+        inp = _maybe_realize_symm_mem(inp, group_name)
+        return pytree.tree_map(
+            ir.TensorBox.create,
+            ir.FallbackKernel.create(
+                symm_mem.multimem_one_shot_all_reduce_out.default,
+                inp,
+                reduce_op,
+                group_name,
+                out,
+            ),
+        )
+
+    @register_lowering(symm_mem.multimem_one_shot_reduce_out)
+    def _symm_mem_multimem_one_shot_reduce_out(
+        inp: ir.TensorBox,
+        reduce_op: str,
+        root: int,
+        group_name: str,
+        out: ir.TensorBox,
+    ):
+        inp = _maybe_realize_symm_mem(inp, group_name)
+        return pytree.tree_map(
+            ir.TensorBox.create,
+            ir.FallbackKernel.create(
+                symm_mem.multimem_one_shot_reduce_out.default,
+                inp,
+                reduce_op,
+                root,
+                group_name,
+                out,
+            ),
+        )
+
+    @register_lowering(symm_mem.multimem_all_gather_out)
+    def _symm_mem_multimem_all_gather_out(
+        inp: ir.TensorBox,
+        group_name: str,
+        out: ir.TensorBox,
+    ):
+        inp = _maybe_realize_symm_mem(inp, group_name)
+        return pytree.tree_map(
+            ir.TensorBox.create,
+            ir.FallbackKernel.create(
+                symm_mem.multimem_all_gather_out.default,
+                inp,
+                group_name,
+                out,
+            ),
+        )
+
+    @register_lowering(symm_mem.reduce_scatter_out)
+    def _symm_mem_reduce_scatter_out(
+        inp: ir.TensorBox,
+        group_name: str,
+        split_last_dim: bool,
+        output: ir.TensorBox,
+    ):
+        inp = _maybe_realize_symm_mem(inp, group_name)
+        return pytree.tree_map(
+            ir.TensorBox.create,
+            ir.FallbackKernel.create(
+                symm_mem.reduce_scatter_out.default,
+                inp,
+                group_name,
+                split_last_dim,
+                output,
+            ),
+        )
+
+    @register_lowering(symm_mem.all_to_all_vdev)
+    def _symm_mem_all_to_all_vdev(
+        inp: ir.TensorBox,
+        out: ir.TensorBox,
+        in_splits: ir.TensorBox,
+        out_splits_offsets: ir.TensorBox,
+        group_name: str,
+    ):
+        inp = _maybe_realize_symm_mem(inp, group_name)
+        out = _maybe_realize_symm_mem(out, group_name)
+        ir.FallbackKernel.create(
+            symm_mem.all_to_all_vdev.default,
+            inp,
+            out,
+            in_splits,
+            out_splits_offsets,
+            group_name,
+        )
+        return None
+
+    @register_lowering(symm_mem.all_to_all_vdev_2d)
+    def _symm_mem_all_to_all_vdev_2d(
+        inp: ir.TensorBox,
+        out: ir.TensorBox,
+        in_splits: ir.TensorBox,
+        out_splits_offsets: ir.TensorBox,
+        group_name: str,
+        major_align=None,
+    ):
+        inp = _maybe_realize_symm_mem(inp, group_name)
+        out = _maybe_realize_symm_mem(out, group_name)
+        ir.FallbackKernel.create(
+            symm_mem.all_to_all_vdev_2d.default,
+            inp,
+            out,
+            in_splits,
+            out_splits_offsets,
+            group_name,
+            major_align,
+        )
+        return None
+
+    @register_lowering(symm_mem.all_to_all_vdev_2d_offset)
+    def _symm_mem_all_to_all_vdev_2d_offset(
+        inp: ir.TensorBox,
+        out: ir.TensorBox,
+        in_splits_offsets: ir.TensorBox,
+        out_splits_offsets: ir.TensorBox,
+        group_name: str,
+    ):
+        inp = _maybe_realize_symm_mem(inp, group_name)
+        out = _maybe_realize_symm_mem(out, group_name)
+        ir.FallbackKernel.create(
+            symm_mem.all_to_all_vdev_2d_offset.default,
+            inp,
+            out,
+            in_splits_offsets,
+            out_splits_offsets,
+            group_name,
+        )
+        return None
+
+    @register_lowering(symm_mem.tile_reduce)
+    def _symm_mem_tile_reduce(
+        in_tile: ir.TensorBox,
+        out_tile: ir.TensorBox,
+        root: int,
+        group_name: str,
+        reduce_op: str = "sum",
+    ):
+        in_tile = _maybe_realize_symm_mem(in_tile, group_name)
+        out_tile = _maybe_realize_symm_mem(out_tile, group_name)
+        ir.FallbackKernel.create(
+            symm_mem.tile_reduce.default,
+            in_tile,
+            out_tile,
+            root,
+            group_name,
+            reduce_op,
+        )
+        return None
+
+    @register_lowering(symm_mem.multi_root_tile_reduce)
+    def _symm_mem_multi_root_tile_reduce(
+        in_tiles,  # list of TensorBox
+        out_tile: ir.TensorBox,
+        roots,  # list of int
+        group_name: str,
+        reduce_op: str = "sum",
+    ):
+        for i, in_tile in enumerate(in_tiles):
+            in_tiles[i] = _maybe_realize_symm_mem(in_tile, group_name)
+        out_tile = _maybe_realize_symm_mem(out_tile, group_name)
+        ir.FallbackKernel.create(
+            symm_mem.multi_root_tile_reduce.default,
+            in_tiles,
+            out_tile,
+            roots,
+            group_name,
+            reduce_op,
+        )
+        return None
+
+    @register_lowering(symm_mem._low_contention_all_gather)
+    def _symm_mem_low_contention_all_gather(
+        inp: ir.TensorBox,
+        group_name: str,
+    ):
+        # Use _CollectiveKernel so that _WaitKernel.get_volatile_reads()
+        # can track the input's lifetime through wait_tensor, preventing
+        # the memory planner from reusing the input buffer while the
+        # backend stream is still reading it.
+        return _create_out_of_place(
+            symm_mem._low_contention_all_gather.default,
+            inp,
+            group_name,
+        )
+
+    @register_lowering(symm_mem._low_contention_all_gather_ce_multicast)
+    def _symm_mem_low_contention_all_gather_ce_multicast(
+        inp: ir.TensorBox,
+        group_name: "torch.distributed.distributed_c10d.GroupName",
+    ):
+        return _create_low_contention_ag_out(
+            symm_mem._low_contention_all_gather_ce_multicast_out.default,
+            inp,
+            group_name,
+        )
+
+    @register_lowering(symm_mem._low_contention_all_gather_ce_multicast_out)
+    def _symm_mem_low_contention_all_gather_ce_multicast_out(
+        inp: ir.TensorBox,
+        group_name: "torch.distributed.distributed_c10d.GroupName",
+        out: ir.TensorBox,
+    ):
+        inp.realize()
+        if can_realize_as_comm_buffer(out, ir.CommBufferType.SYMM_MEM):
+            realize_as_comm_buffer(out, ir.CommBufferType.SYMM_MEM, group_name)
+        else:
+            raise RuntimeError(
+                "_low_contention_all_gather_ce_multicast_out requires an "
+                "Inductor-owned output buffer that can be realized as symmetric "
+                "memory; this indicates an invalid lowering."
+            )
+        return pytree.tree_map(
+            ir.TensorBox.create,
+            ir.FallbackKernel.create(
+                symm_mem._low_contention_all_gather_ce_multicast_out.default,
+                inp,
+                group_name,
+                out,
+            ),
+        )
+
+    @register_lowering(symm_mem._low_contention_reduce_scatter)
+    def _symm_mem_low_contention_reduce_scatter(
+        inp: ir.TensorBox,
+        reduce_op: str,
+        group_name: str,
+    ):
+        # Use _CollectiveKernel so that _WaitKernel.get_volatile_reads()
+        # can track the input's lifetime through wait_tensor, preventing
+        # the memory planner from reusing the input buffer while the
+        # backend stream is still reading it.
+        return _create_out_of_place(
+            symm_mem._low_contention_reduce_scatter.default,
+            inp,
+            reduce_op,
+            group_name,
+        )

.venv/lib/python3.12/site-packages/torch/_inductor/comms.py

@@ -0,0 +1,2402 @@
+# mypy: allow-untyped-defs
+# pyre-strict
+from __future__ import annotations
+
+import heapq
+import importlib
+import itertools
+import logging
+import sys
+from collections import defaultdict
+from dataclasses import dataclass
+from typing import Any, TYPE_CHECKING
+
+import torch
+from torch._logging import trace_structured
+from torch.utils._ordered_set import OrderedSet
+
+from . import config, config_comms, ir
+from .dependencies import WeakDep
+
+
+if TYPE_CHECKING:
+    from .ir import IRNode, Operation
+
+from .memory import (
+    estimate_peak_memory_allocfree,
+    FreeableInputBuffer,
+    get_freeable_input_buf,
+    SNodeMemory,
+)
+from .utils import contains_collective, contains_wait, is_fallback_op, is_wait
+from .virtualized import V
+
+
+log = logging.getLogger(__name__)
+overlap_log = torch._logging.getArtifactLogger(__name__, "overlap")
+
+if TYPE_CHECKING:
+    from torch._inductor.scheduler import BaseSchedulerNode
+
+
+def align_runtime_estimations_across_all_distributed_ranks(
+    snodes: list[BaseSchedulerNode],
+):
+    runtime_estimations = [snode.get_estimated_runtime() for snode in snodes]
+
+    import torch.distributed as dist
+    from torch.distributed.distributed_c10d import _get_default_group
+
+    world_size = dist.get_world_size()
+    pg = _get_default_group()
+    gathered_runtime_estimations: list[list[float]] = [[] for _ in range(world_size)]
+    dist.all_gather_object(
+        gathered_runtime_estimations,
+        runtime_estimations,
+        pg,
+    )
+
+    lengths = OrderedSet([len(e) for e in gathered_runtime_estimations])
+    if len(lengths) != 1:
+        log.warning(
+            "Different ranks have different numbers of scheduler nodes (%s), "
+            "skipping runtime estimation alignment",
+            [len(e) for e in gathered_runtime_estimations],
+        )
+        for idx, snode in enumerate(snodes):
+            snode.override_estimated_runtime = runtime_estimations[idx]
+        return
+
+    median_runtime_estimations = torch.median(
+        torch.tensor(gathered_runtime_estimations), dim=0
+    ).values.tolist()
+
+    for idx, snode in enumerate(snodes):
+        snode.override_estimated_runtime = median_runtime_estimations[idx]
+
+
+def sink_waits(snodes: list[BaseSchedulerNode]) -> list[BaseSchedulerNode]:
+    """
+    Greedily schedules waits as late as possible.
+    """
+    return _schedule_for_comm(
+        snodes, raise_comms=False, sink_waits=True, reorder_for_overlap=False
+    )
+
+
+def raise_comms(snodes: list[BaseSchedulerNode]) -> list[BaseSchedulerNode]:
+    """
+    Greedily schedules comms as early as possible.
+    """
+    return _schedule_for_comm(
+        snodes, raise_comms=True, sink_waits=False, reorder_for_overlap=False
+    )
+
+
+def reorder_compute_for_overlap(
+    snodes: list[BaseSchedulerNode],
+) -> list[BaseSchedulerNode]:
+    """
+    This achieves the following overall scheduling procedure:
+        Step 1: Given that we've currently scheduled comm N, we now schedule all compute nodes
+            that are required for comm N + 1 but do not depend on comm N, to run at the same time with comm N.
+        Step 2: If all those compute nodes are sufficient to overlap comm N, we're done.
+            Otherwise, we now need to look elsewhere to find compute that overlaps with comm N.
+            We prioritize compute nodes that are needed sooner.
+        Step 3: We schedule the compute nodes dependent on comm N and required for comm N + 1.
+        Step 4: We schedule comm N + 1.
+        Repeat this for subsequent comm nodes.
+    """
+    return _schedule_for_comm(
+        snodes, raise_comms=True, sink_waits=True, reorder_for_overlap=True
+    )
+
+
+def reorder_communication_preserving_peak_memory(
+    snodes: list[BaseSchedulerNode],
+) -> list[BaseSchedulerNode]:
+    """
+    Reorders communication ops relative to computation ops to improve communication-compute overlapping and hide comm
+    latency.  Stops moving a particular op if it reaches a point that would have increased the peak memory footprint.
+
+    Currently, follows these heuristics (subject to change or tune):
+    - never reorders collectives relative to one another, for SPMD safety
+    - has an option for per-collective prefetch limit, but does not enable it by default
+    - limits the total number of reorder steps to some factor of the graph size to prevent worst-case quadratic
+      performance
+
+    Prerequisite: sink_comms_and_waits - ensure comm and wait nodes are scheduled as late as possible, respecting data
+    dependencies.  That allows reorder_communication_preserving_peak_memory to take a best case peak-memory snapshot,
+    and then monotonically improve latency by moving collectives backward in time.
+
+    Peak memory impact is computed in an iterative fashion.  First, memory use at each timestep is computed, and global
+    peak memory is computed as a max over timesteps.  Then, when swapping any two adjacent nodes, only the curr-memory
+    for the earlier of the nodes after the swap is affected.  This enables checking step by step whether a swap is
+    peak-memory-safe, and bailing out if not.  Example:
+
+    0   n0      C0
+    1   n1      C0 + Allocs(n1) - Frees(n1)
+    2   n2      C0 + Allocs(n1) - Frees(n1) + Allocs(n2) - Frees(n2)
+
+    0   n0      C0
+    1   n2      C0 + Allocs(n2) - Frees(n2)    <-- After moving n2 to Time 1, only time1 memory changes
+    2   n1      C0 + Allocs(n2) - Frees(n2) + Allocs(n1) - Frees(n1)
+
+    """
+    reordered_snodes, node_stats = (
+        _reorder_communication_preserving_peak_memory_internal(snodes)
+    )
+
+    return reordered_snodes
+
+
+@dataclass
+class ReorderInfo:
+    """
+    Debug info describing how an individual snode was reordered
+    """
+
+    limiting_factor: str = "None"
+    moves: int = 0
+    grouped: int = 0
+    grouped_info: str = ""
+    comm_time: float = -1.0
+    comp_time: float = -1.0
+    initial_exposed: float = -1.0
+    final_exposed: float = -1.0
+    overlap_info: str = "None"
+
+    @property
+    def improvement(self):
+        return self.initial_exposed - self.final_exposed
+
+
+def is_gemm_like(node: IRNode | Operation | None) -> bool:
+    if node is None:
+        return False
+
+    if is_fallback_op(
+        node,  # type: ignore[arg-type]
+        torch.ops.aten._scaled_dot_product_flash_attention.default,
+    ):
+        return True
+
+    if (
+        python_kernel_name := getattr(node, "python_kernel_name", None)
+    ) and "extern_kernels" in python_kernel_name:
+        return True
+    return False
+
+
+def contains_gemm_like(snode: BaseSchedulerNode) -> bool:
+    from torch._inductor.scheduler import GroupedSchedulerNode
+
+    if isinstance(snode, GroupedSchedulerNode):
+        return any(contains_gemm_like(x) for x in snode.snodes)
+    else:
+        return is_gemm_like(snode.node)
+
+
+def _temp_group_visit_leaves(snode: BaseSchedulerNode, fn):
+    from torch._inductor.scheduler import GroupedSchedulerNode
+
+    if isinstance(snode, GroupedSchedulerNode) and snode.temp_grouping:
+        for _snode in snode.snodes:
+            fn(_snode)
+    else:
+        fn(snode)
+
+
+def _group_name(snode, with_bufs=False) -> str:
+    ret = ""
+    for n in snode.snodes:
+        if ret:
+            ret += "_"
+        ret += n.get_name()
+        if with_bufs:
+            ret += f"{list(snode.get_buffer_names())}"
+    return ret
+
+
+def _is_fake_dep(d):
+    return isinstance(d, WeakDep) and d.is_fake
+
+
+def _group_names(gns: list[BaseSchedulerNode]) -> str:
+    return "~".join([gn.get_name() for gn in gns])
+
+
+def _initialize_memory_tracking(snodes, graph_inputs=None, graph_outputs=None):
+    """Initialize memory tracking data structures"""
+    if graph_inputs is None:
+        graph_inputs = OrderedSet(V.graph.graph_inputs.keys())
+    if graph_outputs is None:
+        graph_outputs = OrderedSet(V.graph.get_output_names())
+
+    name_to_freeable_input_buf = get_freeable_input_buf(snodes, graph_inputs)
+    peak_memory, snodes_curr_memory, snodes_allocfree, buf_to_snode_last_use = (
+        estimate_peak_memory_allocfree(
+            snodes, name_to_freeable_input_buf, graph_outputs
+        )
+    )
+    _curr_memory = dict(zip(snodes, snodes_curr_memory))
+    # pyrefly: ignore [unsupported-operation]
+    _curr_memory[None] = (0, 0)
+
+    # Build candidate buffer map for optimization
+    candidate_buffer_map = _build_candidate_buffer_map(buf_to_snode_last_use)
+
+    return (
+        peak_memory,
+        _curr_memory,
+        snodes_allocfree,
+        buf_to_snode_last_use,
+        name_to_freeable_input_buf,
+        candidate_buffer_map,
+    )
+
+
+def _initialize_double_linked_list(
+    snodes: list[BaseSchedulerNode],
+) -> tuple[
+    dict[BaseSchedulerNode, BaseSchedulerNode | None],
+    dict[BaseSchedulerNode, BaseSchedulerNode | None],
+    BaseSchedulerNode,
+]:
+    """Create double-linked list structure from snodes"""
+    _prev = {}
+    _next = {}
+    for i, snode in enumerate(snodes):
+        _prev[snode] = snodes[i - 1] if i > 0 else None
+        _next[snode] = snodes[i + 1] if i < len(snodes) - 1 else None
+    _head = snodes[0]
+    return _prev, _next, _head
+
+
+def _build_candidate_buffer_map(
+    buf_to_snode_last_use: dict,
+) -> dict[BaseSchedulerNode, OrderedSet]:
+    """
+    Build inverted index: node -> set of buffers where node appears in successors.
+
+    This optimization reduces buffer iteration from O(total_buffers) to O(buffers_per_node).
+    Since buffer successors are immutable during reordering, this map doesn't need updates.
+
+    Returns:
+        dict mapping each node to the set of buffers that have this node in their successors
+    """
+    node_to_candidate_bufs: dict[BaseSchedulerNode, OrderedSet] = defaultdict(
+        OrderedSet
+    )
+
+    for buf in buf_to_snode_last_use:
+        # Add to every successor node's buffer set
+        for succ_node in buf.mpi_buffer.succ_nodes:
+            node_to_candidate_bufs[succ_node].add(buf)
+
+    return dict(node_to_candidate_bufs)
+
+
+def _precompute_node_output_sets(
+    snodes: list[BaseSchedulerNode],
+) -> dict[BaseSchedulerNode, OrderedSet[str]]:
+    """
+    Pre-compute output name sets for all nodes.
+
+    This optimization avoids creating OrderedSet objects repeatedly during
+    exposed time calculations.
+
+    Returns:
+        dict mapping each node to a set of its output names
+    """
+    return {
+        snode: OrderedSet(o.get_name() for o in snode.get_outputs()) for snode in snodes
+    }
+
+
+def _op_runtime_estimate_mult(snode):
+    # Apply multipliers for faster experimentation.
+    # TODO(ivankobzarev): Remove after confirmation that runtime estimations are correct.
+    if contains_collective(snode):
+        return config_comms.reorder_sink_runtime_estimations_comm_mult
+
+    return config_comms.reorder_sink_runtime_estimations_non_comm_mult
+
+
+def is_async_collective(snode):
+    """
+    Filtering out ops that contain Collective and Wait inside and considered as Collectives.
+    See contains_collective function.
+    If the op contains Wait inside - consider as Synchronous compute.
+    """
+    if python_kernel_name := getattr(snode.node, "python_kernel_name", None):
+        if "torch.ops._dtensor.shard_dim_alltoall.default" in python_kernel_name:
+            return False
+
+    return True
+
+
+def contains_async_collective(snode):
+    return contains_collective(snode, is_async_collective)
+
+
+def _group_nodes_from_linked_list(
+    head: BaseSchedulerNode | None,
+    tail: BaseSchedulerNode | None,
+    next_dict: dict[BaseSchedulerNode, BaseSchedulerNode | None],
+) -> list[BaseSchedulerNode]:
+    """
+    Traverse doubly-linked list from head to tail and return nodes as a list.
+
+    Args:
+        head: Starting node of the segment
+        tail: Ending node of the segment (inclusive)
+        next_dict: Dictionary mapping each node to its next node
+
+    Returns:
+        List of nodes from head to tail (inclusive)
+    """
+    ret = []
+    n = head
+    while True:
+        if n is not None:
+            ret.append(n)
+        if n == tail:
+            break
+        n = next_dict[n]  # type: ignore[index]
+    return ret
+
+
+def _is_corresponding_collective_wait(
+    collective_snode: BaseSchedulerNode,
+    wait_snode: BaseSchedulerNode,
+    node_output_sets: dict[BaseSchedulerNode, frozenset[str]],
+    node_dep_sets: dict[BaseSchedulerNode, frozenset[str]],
+) -> bool:
+    """
+    Check if a wait node corresponds to a given collective node.
+    Uses pre-computed sets for O(1) lookup.
+    """
+    collective_outs = node_output_sets[collective_snode]
+    unmet_deps = node_dep_sets[wait_snode]
+    return bool(unmet_deps & collective_outs)
+
+
+def _coll_exposed_communication_time(
+    collective_snode: BaseSchedulerNode,
+    next_dict: dict[BaseSchedulerNode, BaseSchedulerNode | None],
+    runtimes: dict[BaseSchedulerNode, float],
+    node_output_sets: dict[BaseSchedulerNode, frozenset[str]],
+    node_dep_sets: dict[BaseSchedulerNode, frozenset[str]],
+) -> tuple[float, float, str]:
+    """
+    Calculate exposed communication time by iterating directly over linked list.
+    Avoids O(N) list construction for each call.
+
+    The collective_snode is the starting point, iteration continues via next_dict.
+    """
+    comm_time = runtimes[collective_snode]
+    comp_time = 0.0
+    collective_outs = node_output_sets[collective_snode]
+    overlap_info = ""
+    collectives_found: list[BaseSchedulerNode] = []
+
+    snode = next_dict[collective_snode]
+    while snode is not None:
+        unmet_deps = node_dep_sets[snode]
+
+        if unmet_deps & collective_outs:
+            overlap_info += f"->W[{snode.get_name()}]"
+            break
+
+        if contains_collective(snode):
+            if not contains_async_collective(snode):
+                break
+            else:
+                collectives_found.append(snode)
+                snode = next_dict[snode]
+                continue
+        if contains_wait(snode):
+            has_wait_for_collectives_found = False
+            for _coll in collectives_found:
+                if _is_corresponding_collective_wait(
+                    collective_snode, snode, node_output_sets, node_dep_sets
+                ):
+                    has_wait_for_collectives_found = True
+                    break
+            if has_wait_for_collectives_found:
+                break
+
+        comp_time_before = comp_time
+
+        def accumulate_time(_snode: BaseSchedulerNode) -> None:
+            nonlocal comp_time
+            comp_time += runtimes[_snode]
+
+        _temp_group_visit_leaves(snode, accumulate_time)
+        comp_time_after = comp_time
+        overlap_info += f"+{snode.get_name()}[{comp_time_after - comp_time_before}]"
+
+        snode = next_dict[snode]
+
+    return comm_time, comp_time, overlap_info
+
+
+def _wait_exposed_communication_time(
+    wait_snode: BaseSchedulerNode,
+    head: BaseSchedulerNode,
+    prev_dict: dict[BaseSchedulerNode, BaseSchedulerNode | None],
+    runtimes: dict[BaseSchedulerNode, float],
+    node_output_sets: dict[BaseSchedulerNode, frozenset[str]],
+    node_dep_sets: dict[BaseSchedulerNode, frozenset[str]],
+) -> tuple[float, float, str]:
+    """
+    Calculate exposed communication time for a wait operation by iterating
+    directly over linked list backwards. Avoids O(N) list construction.
+
+    Iterates from wait_snode backwards using prev_dict to find corresponding collective.
+    """
+    comm_time = 0.0
+    comp_time = 0.0
+    overlap_info = ""
+    waits_found: list[BaseSchedulerNode] = []
+
+    snode = prev_dict[wait_snode]
+    while snode is not None:
+        if contains_wait(snode):
+            waits_found.append(snode)
+        if contains_collective(snode):
+            if _is_corresponding_collective_wait(
+                snode, wait_snode, node_output_sets, node_dep_sets
+            ):
+                comm_time = runtimes[snode]
+                overlap_info += f"->C[{snode.get_name()}]"
+                break
+
+            if not contains_async_collective(snode):
+                comp_time = 0.0
+                snode = prev_dict[snode]
+                continue
+            else:
+                for w in waits_found:
+                    if _is_corresponding_collective_wait(
+                        snode, w, node_output_sets, node_dep_sets
+                    ):
+                        comp_time = 0.0
+                        break  # inner loop break
+                snode = prev_dict[snode]
+                continue
+
+        comp_time_before = comp_time
+
+        def accumulate_time(_snode: BaseSchedulerNode) -> None:
+            nonlocal comp_time
+            comp_time += runtimes[_snode]
+
+        _temp_group_visit_leaves(snode, accumulate_time)
+        comp_time_after = comp_time
+        overlap_info += f"+{snode.get_name()}[{comp_time_after - comp_time_before}]"
+
+        snode = prev_dict[snode]
+
+    return comm_time, comp_time, overlap_info
+
+
+def _perform_double_linked_list_swap(
+    candidate: BaseSchedulerNode,
+    group_head: BaseSchedulerNode,
+    group_tail: BaseSchedulerNode,
+    prev_dict: dict[BaseSchedulerNode, BaseSchedulerNode | None],
+    next_dict: dict[BaseSchedulerNode, BaseSchedulerNode | None],
+    head: BaseSchedulerNode,
+) -> BaseSchedulerNode:
+    """
+    Swap positions of candidate and group in doubly-linked list.
+
+    Transforms:
+    candidate_prev -> candidate -> group_head...group_tail -> group_tail_next
+    Into:
+    candidate_prev -> group_head...group_tail -> candidate -> group_tail_next
+
+    Args:
+        candidate: Node to swap with group
+        group_head: First node of group
+        group_tail: Last node of group
+        prev_dict: Dictionary mapping nodes to their previous nodes
+        next_dict: Dictionary mapping nodes to their next nodes
+        head: Current head of the linked list
+
+    Returns:
+        New head of the linked list (may change if candidate was the head)
+    """
+    # 0: Update candidate's previous node
+    candidate_prev = prev_dict[candidate]
+    if candidate_prev:
+        next_dict[candidate_prev] = group_head
+    prev_dict[group_head] = candidate_prev
+
+    # 2: Update group_tail's next node
+    group_tail_next = next_dict[group_tail]
+    if group_tail_next:
+        prev_dict[group_tail_next] = candidate
+    next_dict[candidate] = group_tail_next
+
+    # 1: Link group_tail to candidate
+    prev_dict[candidate] = group_tail
+    next_dict[group_tail] = candidate
+
+    # Update head if candidate was the head
+    if head == candidate:
+        return group_head
+    return head
+
+
+def _calculate_potential_peak_memory_reorder(
+    candidate: BaseSchedulerNode,
+    gns: list[BaseSchedulerNode],
+    group_tail: BaseSchedulerNode,
+    group_peak_memory: int,
+    candidate_delta_mem: int,
+    candidate_allocfree: SNodeMemory,
+    group_n_to_bufs_after_swap_dealloc_by_candidate: dict,
+    curr_memory: dict,
+) -> tuple[int, dict[BaseSchedulerNode, int]]:
+    """
+    Calculate potential peak memory after swapping candidate with group (reorder version).
+
+    Computes new memory levels for all affected nodes and returns the potential
+    peak memory along with cached post-allocation memory values for each node.
+
+    Args:
+        candidate: Node being moved
+        gns: Group nodes
+        group_tail: Last node of group
+        group_peak_memory: Current peak memory within the group
+        candidate_delta_mem: Net memory change from candidate (alloc - free)
+        candidate_allocfree: Candidate's allocation/free info
+        group_n_to_bufs_after_swap_dealloc_by_candidate: Buffers whose deallocation moves to candidate
+        curr_memory: Current memory state dict
+
+    Returns:
+        Tuple of (potential_peak_memory, post_alloc_update_dict)
+    """
+    # Caching calculations of memory for group nodes and candidate,
+    # to apply without recalculation after swap.
+    _post_alloc_update: dict[BaseSchedulerNode, int] = {}
+    potential_peak: int = 0
+    if not group_n_to_bufs_after_swap_dealloc_by_candidate:
+        # Not accounting for buffers last use change
+        potential_peak = max(
+            group_peak_memory - candidate_delta_mem,
+            curr_memory[group_tail][1]
+            - candidate_delta_mem
+            + candidate_allocfree.size_alloc,
+        )
+        return potential_peak, _post_alloc_update
+
+    # If candidate will be after group, the starting memory level of group nodes
+    # changes to the -(candidate.size_alloc - candidate.size_free)
+    mem_after_reorder_delta: int = -candidate_delta_mem
+    for gn in gns:
+        gn_post_alloc_mem = curr_memory[gn][0] + mem_after_reorder_delta
+        _post_alloc_update[gn] = gn_post_alloc_mem
+        potential_peak = max(potential_peak, gn_post_alloc_mem)
+
+        bufs = group_n_to_bufs_after_swap_dealloc_by_candidate.get(gn)
+        if bufs is not None:
+            for buf in bufs:
+                # Candidate will deallocate those buffers
+                mem_after_reorder_delta += buf.mpi_buffer.size_free
+
+    candidate_mem_post_alloc = (
+        curr_memory[group_tail][1]
+        + mem_after_reorder_delta
+        + candidate_allocfree.size_alloc
+    )
+    _post_alloc_update[candidate] = candidate_mem_post_alloc
+    potential_peak = max(potential_peak, candidate_mem_post_alloc)
+    return potential_peak, _post_alloc_update
+
+
+def _update_memory_tracking_after_swap_reorder(
+    candidate: BaseSchedulerNode,
+    gns: list[BaseSchedulerNode],
+    group_tail: BaseSchedulerNode,
+    candidate_delta_mem: int,
+    candidate_allocfree: SNodeMemory,
+    group_n_to_bufs_after_swap_dealloc_by_candidate: dict,
+    post_alloc_update: dict[BaseSchedulerNode, int],
+    curr_memory: dict,
+    buf_to_snode_last_use: dict,
+    snodes_allocfree: dict,
+) -> None:
+    """
+    Update memory tracking structures after swap (reorder version).
+
+    Updates curr_memory, buf_to_snode_last_use, and snodes_allocfree dictionaries
+    to reflect the new memory state after swapping candidate with group.
+
+    Args:
+        candidate: Node that was moved
+        gns: Group nodes
+        group_tail: Last node of group
+        candidate_delta_mem: Net memory change from candidate (alloc - free)
+        candidate_allocfree: Candidate's allocation/free info
+        group_n_to_bufs_after_swap_dealloc_by_candidate: Buffers whose deallocation moves to candidate
+        post_alloc_update: Cached post-allocation memory values
+        curr_memory: Current memory state dict (mutated)
+        buf_to_snode_last_use: Buffer to last-use node mapping (mutated)
+        snodes_allocfree: Node allocation/free info dict (mutated)
+    """
+    if not group_n_to_bufs_after_swap_dealloc_by_candidate:
+        for gn in gns:
+            cm = curr_memory[gn]
+            curr_memory[gn] = (
+                cm[0] - candidate_delta_mem,
+                cm[1] - candidate_delta_mem,
+            )
+        _candidate_post_alloc_mem = (
+            curr_memory[group_tail][1] + candidate_allocfree.size_alloc
+        )
+        _candidate_post_free_mem = (
+            _candidate_post_alloc_mem - candidate_allocfree.size_free
+        )
+        curr_memory[candidate] = (
+            _candidate_post_alloc_mem,
+            _candidate_post_free_mem,
+        )
+        return
+
+    # Candidate becomes last use of some bufs
+    for bufs in group_n_to_bufs_after_swap_dealloc_by_candidate.values():
+        for buf in bufs:
+            buf_to_snode_last_use[buf] = candidate
+
+    size_free_to_move_to_candidate_sum: int = 0
+    for n in gns:
+        _gn_post_alloc_mem: int = post_alloc_update[n]
+        size_free_to_move_to_candidate: int = sum(
+            buf.mpi_buffer.size_free
+            for buf in group_n_to_bufs_after_swap_dealloc_by_candidate[n]
+        )
+        size_free_to_move_to_candidate_sum += size_free_to_move_to_candidate
+        # group node does not deallocate this after swap
+        snodes_allocfree[n].size_free -= size_free_to_move_to_candidate
+        gn_post_free_mem: int = _gn_post_alloc_mem - snodes_allocfree[n].size_free
+        curr_memory[n] = (_gn_post_alloc_mem, gn_post_free_mem)
+    _candidate_post_alloc_mem = post_alloc_update[candidate]
+    snodes_allocfree[candidate].size_free += size_free_to_move_to_candidate_sum
+    candidate_post_free_mem = (
+        _candidate_post_alloc_mem - snodes_allocfree[candidate].size_free
+    )
+    curr_memory[candidate] = (
+        _candidate_post_alloc_mem,
+        candidate_post_free_mem,
+    )
+
+
+def _find_buffers_with_changed_last_use(
+    candidate: BaseSchedulerNode,
+    gns: list[BaseSchedulerNode],
+    buf_to_snode_last_use: dict,
+    candidate_buffer_map: dict[BaseSchedulerNode, OrderedSet],
+) -> dict[BaseSchedulerNode, list[FreeableInputBuffer | Any]]:
+    """
+    Find buffers whose last use will change after swapping candidate with group.
+
+    When we swap [candidate [group]] to [[group] candidate], some buffers that
+    were last used by a group node will now be last used by candidate instead.
+    This affects memory deallocation timing.
+
+    Args:
+        candidate: The node being moved
+        gns: Group nodes being swapped with candidate
+        buf_to_snode_last_use: Mapping of buffers to their current last-use nodes
+        candidate_buffer_map: Pre-computed map of node -> buffers using that node
+
+    Returns:
+        Dict mapping group nodes to buffers that will change their last-use node
+    """
+    group_n_to_bufs_after_swap_dealloc_by_candidate: dict[
+        BaseSchedulerNode, list[FreeableInputBuffer | Any]
+    ] = defaultdict(list)
+
+    # Optimization: only check buffers where candidate is a successor
+    # Reduces from O(all_buffers) to O(buffers_per_candidate)
+    candidate_bufs = candidate_buffer_map.get(candidate, OrderedSet())
+    gns_set = OrderedSet(gns)  # O(1) membership testing
+
+    for buf in candidate_bufs:
+        snode_last_use = buf_to_snode_last_use[buf]
+        if snode_last_use in gns_set:
+            group_n_to_bufs_after_swap_dealloc_by_candidate[snode_last_use].append(buf)
+
+    return group_n_to_bufs_after_swap_dealloc_by_candidate
+
+
+def _is_node_groupable_for_reorder(
+    candidate: BaseSchedulerNode,
+) -> tuple[bool, str | None]:
+    """
+    Check if a candidate node can be grouped with collective during reordering.
+
+    This pass processes collectives left to right, so we avoid grouping with
+    already-processed collectives based on configuration.
+
+    Args:
+        candidate: Node to check for groupability
+
+    Returns:
+        Tuple of (is_groupable, reason_if_not_groupable)
+    """
+    # This pass processes collectives left to right,
+    # Do not group with processed collectives.
+    # Leaving config for experimentation in 2D
+    if not config_comms.reorder_iterative_group_with_collectives:
+        if contains_async_collective(candidate):
+            return (
+                False,
+                f"candidate contains_collective {candidate.get_name()}",
+            )
+    if not config_comms.reorder_iterative_use_runtime_estimations:
+        if contains_gemm_like(candidate):
+            return False, "contains_gemm_like"
+    return True, None
+
+
+def _format_and_log_reordering_stats(
+    stats: dict[BaseSchedulerNode, ReorderInfo],
+    head: BaseSchedulerNode,
+    next_dict: dict[BaseSchedulerNode, BaseSchedulerNode | None],
+    original_snodes_num: int,
+    peak_memory: int,
+    name_to_freeable_input_buf: dict,
+    graph_outputs: OrderedSet[str],
+) -> list[BaseSchedulerNode]:
+    """
+    Format reordering statistics, log them, and return final node list.
+
+    Computes improvement metrics, creates a formatted table (using tabulate if
+    available), validates the reordered node count, recalculates peak memory,
+    and logs all information.
+
+    Args:
+        stats: Per-node reordering statistics
+        head: Head of the reordered linked list
+        next_dict: Linked list next pointers
+        original_snodes_num: Original number of nodes (for validation)
+        peak_memory: Initial peak memory before reordering
+        name_to_freeable_input_buf: Buffer memory tracking info
+        graph_outputs: Graph output names
+
+    Returns:
+        Final reordered list of scheduler nodes
+    """
+    node_stats = stats
+    improvement = {snode: node_stats[snode].improvement for snode in node_stats}
+    total_improvement = sum([improvement[snode] for snode in improvement])
+    total_moves = sum([node_stats[snode].moves for snode in node_stats])
+
+    reorder_log_str = (
+        f"reorder_communication_preserving_peak_memory improved overlap by {total_improvement} ns"
+        f" after {total_moves} reorders.\n"
+    )
+    headers = [
+        "Collective node",
+        "comm_time(us)",
+        "comp_time(us)",
+        "initial exposed(us)",
+        "final exposed(us)",
+        "improvement(us)",
+        "limiting factor",
+        "moves",
+        "grouped",
+        "grouped_info",
+        "overlap_info",
+    ]
+    rows = [
+        [
+            node_summary(snode),
+            node_info.comm_time / 1e3,
+            node_info.comp_time / 1e3,
+            node_info.initial_exposed / 1e3,
+            node_info.final_exposed / 1e3,
+            node_info.improvement / 1e3,
+            node_info.limiting_factor,
+            node_info.moves,
+            node_info.grouped,
+            node_info.grouped_info,
+            node_info.overlap_info,
+        ]
+        for snode, node_info in node_stats.items()
+    ]
+    if importlib.util.find_spec("tabulate"):
+        from tabulate import tabulate
+
+        reorder_log_str += tabulate(
+            rows,
+            headers=headers,
+        )
+    else:
+        reorder_log_str += (
+            "Please `pip install tabulate` to nicely render overlap stats.\n"
+        )
+        reorder_log_str += str(headers) + "\n"
+        reorder_log_str += "\n".join(map(str, rows))
+
+    new_snodes = _group_nodes_from_linked_list(head, None, next_dict)
+    if len(new_snodes) != original_snodes_num:
+        raise AssertionError(
+            f"expected {original_snodes_num} nodes, got {len(new_snodes)}"
+        )
+    new_peak_memory, _, _, _ = estimate_peak_memory_allocfree(
+        new_snodes, name_to_freeable_input_buf, graph_outputs
+    )
+    reorder_log_str += f"\n peak_memory_before:{peak_memory}"
+    reorder_log_str += f"\n peak_memory_after:{new_peak_memory}"
+
+    overlap_log.info(reorder_log_str)
+    trace_structured(
+        "artifact",
+        metadata_fn=lambda: {
+            "name": "reorder_communication_preserving_peak_memory",
+            "encoding": "string",
+        },
+        payload_fn=lambda: reorder_log_str,
+    )
+
+    return new_snodes
+
+
+def _reorder_communication_preserving_peak_memory_internal(
+    snodes: list[BaseSchedulerNode],
+) -> tuple[list[BaseSchedulerNode], dict[BaseSchedulerNode, ReorderInfo]]:
+    """
+    Internal testing helper that also returns debug info.
+    Returns:
+        - reordered snodes list
+        - dict {snode: ReorderInfo}
+    """
+    has_collectives = False
+    for snode in snodes:
+        if contains_collective(snode):
+            has_collectives = True
+            break
+    if not has_collectives:
+        return snodes, {}
+
+    original_snodes_num = len(snodes)
+    # heuristic to avoid degenerating to quadratic time
+    graph_inputs: OrderedSet[str] = OrderedSet(V.graph.graph_inputs.keys())
+    graph_outputs: OrderedSet[str] = OrderedSet(V.graph.get_output_names())
+    (
+        peak_memory,
+        _curr_memory,
+        snodes_allocfree,
+        buf_to_snode_last_use,
+        name_to_freeable_input_buf,
+        candidate_buffer_map,
+    ) = _initialize_memory_tracking(snodes, graph_inputs, graph_outputs)
+
+    runtimes: dict[BaseSchedulerNode, float] = {
+        snode: estimate_op_runtime(snode) * _op_runtime_estimate_mult(snode)
+        for snode in snodes
+    }
+
+    # Pre-compute output and dependency sets for O(1) lookup instead of O(N) creation per iteration
+    node_output_sets: dict[BaseSchedulerNode, frozenset[str]] = {
+        snode: frozenset(o.get_name() for o in snode.get_outputs()) for snode in snodes
+    }
+    node_dep_sets: dict[BaseSchedulerNode, frozenset[str]] = {
+        snode: frozenset(
+            d.name for d in snode.unmet_dependencies if not _is_fake_dep(d)
+        )
+        for snode in snodes
+    }
+
+    # debug stats
+    stats: dict[BaseSchedulerNode, ReorderInfo] = {}
+
+    total_moves = 0
+
+    _prev, _next, _head = _initialize_double_linked_list(snodes)
+
+    debug_num_collectives_to_reorder: int | None = (
+        config_comms.reorder_iterative_debug_limit_to_reorder
+    )
+
+    num_processed_collectives: int = 0
+    curr: BaseSchedulerNode | None = _head
+    debug_iterative_memory_recompute = (
+        config_comms.reorder_iterative_debug_memory_recompute
+    )
+    iterative_recompute_error = False
+
+    while curr is not None and _next[curr] is not None:
+        _next_curr = _next[curr]
+        if iterative_recompute_error:
+            break
+
+        if not contains_async_collective(curr):
+            curr = _next_curr
+            continue
+
+        if debug_num_collectives_to_reorder is not None and (
+            num_processed_collectives >= debug_num_collectives_to_reorder
+        ):
+            break
+        num_processed_collectives += 1
+
+        info = stats[curr] = ReorderInfo()
+        comm_time, comp_time, overlap_info = _coll_exposed_communication_time(
+            curr, _next, runtimes, node_output_sets, node_dep_sets
+        )
+        info.comm_time = comm_time
+        info.comp_time = comp_time
+        info.initial_exposed = info.final_exposed = comm_time - comp_time
+        info.overlap_info = overlap_info
+
+        candidate = _prev[curr]
+        group_head = curr
+        group_tail = curr
+        group_waits = {}
+        group_runtime = 0.0
+        group_peak_memory = _curr_memory[curr][0]  # post_alloc memory
+
+        # Track group dependencies incrementally - initialize from pre-computed sets
+        group_unmet_deps_names = OrderedSet(node_dep_sets[curr])
+        group_output_names = OrderedSet(node_output_sets[curr])
+
+        while candidate is not None:
+            if config_comms.reorder_iterative_use_runtime_estimations and (
+                info.final_exposed
+                < -config_comms.reorder_iterative_extra_comm_comp_overlap
+                * info.comm_time
+            ):
+                info.limiting_factor = "unexposed by runtime estimations"
+                break
+
+            if (
+                not config_comms.reorder_iterative_unsafe_collectives_reorder
+                and contains_collective(candidate)
+            ):
+                info.limiting_factor = "collective ordering"
+                break
+
+            # Early exit: if group has no unmet dependencies, candidate can't have data dependency
+            data_deps_names = group_unmet_deps_names - group_output_names
+            if not data_deps_names:
+                data_dep = False
+            else:
+                # Calculate effective dependencies (not satisfied within group)
+                # Use pre-computed set for O(1) lookup
+                candidate_out_names = node_output_sets[candidate]
+                data_dep = bool(candidate_out_names & data_deps_names)
+
+            if data_dep:
+                is_groupable_result, grouping_reason = _is_node_groupable_for_reorder(
+                    candidate
+                )
+                if is_groupable_result:
+                    group_head = candidate
+
+                    # Update incremental dependency tracking using pre-computed sets
+                    group_unmet_deps_names.update(node_dep_sets[candidate])
+                    group_output_names.update(node_output_sets[candidate])
+
+                    if config_comms.reorder_iterative_use_runtime_estimations:
+                        if contains_wait(candidate):
+                            comm_time, comp_time, _ = _wait_exposed_communication_time(
+                                candidate,
+                                _head,
+                                _prev,
+                                runtimes,
+                                node_output_sets,
+                                node_dep_sets,
+                            )
+                            group_waits[candidate] = comm_time, comp_time
+                        if not contains_async_collective(candidate):
+                            group_runtime += runtimes[candidate]
+
+                    group_peak_memory = max(
+                        group_peak_memory, _curr_memory[candidate][0]
+                    )
+                    info.grouped += 1
+                    candidate = _prev[candidate]
+                    continue
+                else:
+                    msg = (
+                        f"data dependency detected"
+                        f"\n candidate:{candidate.get_name()}(outs:{[o.get_name() for o in candidate.get_outputs()]})"
+                        f"\n non_group_reason:{grouping_reason}"
+                    )
+                    info.limiting_factor = msg
+                    break
+
+            if config_comms.reorder_iterative_use_runtime_estimations:
+                # Check if candidate has sync runtime
+                if not contains_async_collective(candidate):
+                    c_runtime = runtimes[candidate]
+
+                    if c_runtime > 0 and len(group_waits) > 0:
+                        # pyrefly: ignore[no-matching-overload]
+                        exposed_before = max(0, info.comm_time - info.comp_time)
+                        # pyrefly: ignore[no-matching-overload]
+                        exposed_after = max(
+                            0, info.comm_time - info.comp_time - c_runtime
+                        )
+                        exposed_delta = exposed_after - exposed_before
+                        for gw_comm_time, gw_comp_time in group_waits.values():
+                            # pyrefly: ignore [no-matching-overload]
+                            gw_exposed_before = max(0, gw_comm_time - gw_comp_time)
+                            # pyrefly: ignore [no-matching-overload]
+                            gw_exposed_after = max(
+                                0, gw_comm_time - gw_comp_time + c_runtime
+                            )
+
+                            exposed_delta += gw_exposed_after - gw_exposed_before
+
+                        if exposed_delta > 0:
+                            info.limiting_factor = (
+                                f"candidate has compute {c_runtime},"
+                                f" group contains waits, total_exposed_delta {exposed_delta}"
+                            )
+                            break
+                        else:
+                            # Update all group_colls comm_time, comp_time
+                            for gw, (
+                                gw_comm_time,
+                                gw_comp_time,
+                            ) in group_waits.items():
+                                group_waits[gw] = (
+                                    gw_comm_time,
+                                    gw_comp_time - c_runtime,
+                                )
+                else:
+                    # Candidate is async_collective
+
+                    # Unsafe collectives reordering
+                    # Cj -> [...group_runtime..., Ci] -> Wj
+                    # Checking that we are not increasing exposed time of Cj
+                    if group_runtime > 0:
+                        comm_time, comp_time, _ = _coll_exposed_communication_time(
+                            candidate, _next, runtimes, node_output_sets, node_dep_sets
+                        )
+                        # pyrefly: ignore[no-matching-overload]
+                        exposed_before = max(0, comm_time - comp_time)
+                        # pyrefly: ignore[no-matching-overload]
+                        exposed_after = max(0, comm_time - comp_time + group_runtime)
+                        exposed_delta = exposed_after - exposed_before
+                        if exposed_delta > 0:
+                            info.limiting_factor = (
+                                f"candidate {candidate.get_name()} is collective,"
+                                f" group_runtime:{group_runtime},"
+                                f" exposed_delta:{exposed_delta} c_comm_time:{comm_time} c_comp_time:{comp_time}"
+                            )
+                            break
+
+            # Create group nodes list once for swap operations
+            gns: list[BaseSchedulerNode] = _group_nodes_from_linked_list(
+                group_head, group_tail, _next
+            )
+
+            candidate_allocfree: SNodeMemory = snodes_allocfree[candidate]
+            candidate_delta_mem: int = (
+                candidate_allocfree.size_alloc - candidate_allocfree.size_free
+            )
+            # candidate and one of group nodes are successors of the same buffer
+            # and last use of the buffer happen in group nodes.
+            # This last use deallocates it.
+            # If we swap [candidate [group]] to [[group] candidate],
+            # candidate becomes the last use
+            # and deallocated this buffer instead of group node.
+            # we need to update size_free accordingly to group_node and candidate,
+            # and recalculate post_alloc, post_free for them.
+            #
+            # Buf that changes its last use snode,
+            # after swap will be deallocated only by candidate,
+            # while before it was deallocated by group node.
+            group_n_to_bufs_after_swap_dealloc_by_candidate = (
+                _find_buffers_with_changed_last_use(
+                    candidate, gns, buf_to_snode_last_use, candidate_buffer_map
+                )
+            )
+
+            potential_peak, _post_alloc_update = (
+                _calculate_potential_peak_memory_reorder(
+                    candidate,
+                    gns,
+                    group_tail,
+                    group_peak_memory,
+                    candidate_delta_mem,
+                    candidate_allocfree,
+                    group_n_to_bufs_after_swap_dealloc_by_candidate,
+                    _curr_memory,
+                )
+            )
+
+            if (
+                potential_peak - peak_memory
+                > peak_memory * config_comms.reorder_iterative_peak_memory_budget
+            ):
+                info.limiting_factor = (
+                    f"peak memory new:{potential_peak} vs base:{peak_memory}"
+                )
+                break
+            info.moves += 1
+            total_moves += 1
+
+            _head = _perform_double_linked_list_swap(
+                candidate, group_head, group_tail, _prev, _next, _head
+            )
+
+            comm_time, comp_time, overlap_info = _coll_exposed_communication_time(
+                curr, _next, runtimes, node_output_sets, node_dep_sets
+            )
+            info.comm_time = comm_time
+            info.comp_time = comp_time
+            info.overlap_info = overlap_info
+            info.final_exposed = comm_time - comp_time
+
+            _update_memory_tracking_after_swap_reorder(
+                candidate,
+                gns,
+                group_tail,
+                candidate_delta_mem,
+                candidate_allocfree,
+                group_n_to_bufs_after_swap_dealloc_by_candidate,
+                _post_alloc_update,
+                _curr_memory,
+                buf_to_snode_last_use,
+                snodes_allocfree,
+            )
+
+            if debug_iterative_memory_recompute:
+                # Compare iteratively recomputed memory data
+                # with full run of estimate_peak_memory
+
+                from .comms_debug import _debug_iterative_memory_recompute
+
+                iterative_recompute_error = _debug_iterative_memory_recompute(
+                    candidate,
+                    gns,
+                    _group_names(gns),
+                    _group_nodes_from_linked_list(_head, None, _next),
+                    name_to_freeable_input_buf,
+                    graph_outputs,
+                    peak_memory,
+                    _curr_memory,
+                    snodes_allocfree,
+                    "reorder_communication_preserving_peak_memory",
+                    group_n_to_bufs_after_swap_dealloc_by_candidate,
+                )
+                if iterative_recompute_error:
+                    break
+            candidate = _prev[group_head]
+        curr = _next_curr
+
+    if not config_comms.reorder_sink_verbose_logging:
+        new_snodes = _group_nodes_from_linked_list(_head, None, _next)
+        return new_snodes, stats
+
+    new_snodes = _format_and_log_reordering_stats(
+        stats,
+        _head,
+        _next,
+        original_snodes_num,
+        peak_memory,
+        name_to_freeable_input_buf,
+        graph_outputs,
+    )
+
+    return new_snodes, stats
+
+
+def _schedule_for_comm(
+    snodes: list[BaseSchedulerNode],
+    raise_comms: bool,
+    sink_waits: bool,
+    reorder_for_overlap: bool,
+) -> list[BaseSchedulerNode]:
+    """
+    Schedule `snodes` for various comm optimization objectives.
+
+    Args:
+        snodes: the nodes to be scheduled.
+        raise_comms: whether to greedily schedule collectives as early as possible
+        sink_wait: whether to greedily schedule waits as late as possible
+        reorder_compute_for_overlap: whether to reorder compute nodes to
+            optimize for compute/communication overlapping.
+
+    Returns:
+        The new schedule order.
+
+    Some notes on the synergy between different options:
+        - `raise_comms` provides more overlapping opportunities for `reorder_compute_for_overlap`.
+        - When both `raise_comms` and `sink_waits` is `True`, `raise_comms` is prioritized.
+    """
+    # We assign each node a tuple of scores (score_0, score_1, score_2),
+    # decreasing in importance, with a lower value indicating a higher ranking:
+    #
+    # - score_0: the lowest comm_idx among the comm nodes that the node blocks.
+    # If a node doesn't block any comm nodes, its score_0 is set to
+    # sys.maxsize. This score ensures that comm nodes get scheduled as early as
+    # possible.
+    # - score_1: 1 if the node is a wait node, 0 otherwise. This score ensures
+    # that wait nodes are deferred as late as possible.
+    # - score_2: the index of the node in the original topological order. This
+    # score provides stability in case of ties.
+    #
+    # When only raise_comms is True, only score_0 and score_2 are considered.
+    # When only sink_waits is True, only score_1 and score_2 are considered.
+    # When neither is True, the original order is yielded.
+    buf_name_to_snode = {}
+    name_to_fused_node = {}
+    scores_0, scores_1, scores_2 = {}, {}, {}
+    for idx, snode in enumerate(snodes):
+        for buf_name in snode.get_buffer_names():
+            buf_name_to_snode[buf_name] = snode
+
+        for op_name in snode.get_operation_names():
+            name_to_fused_node[op_name] = snode
+        name_to_fused_node[snode.get_name()] = snode
+
+        node_name = snode.get_name()
+        scores_0[node_name] = sys.maxsize
+        scores_1[node_name] = 0
+        scores_2[node_name] = idx
+
+    comm_idx = 0
+    for snode in snodes:
+        if raise_comms and contains_collective(snode):
+            scores_0[snode.get_name()] = comm_idx
+            for ancestor in snode.ancestors:
+                anc_fused_name = name_to_fused_node[ancestor].get_name()
+                scores_0[anc_fused_name] = min(scores_0[anc_fused_name], comm_idx)
+            comm_idx += 1
+        elif sink_waits and contains_wait(snode):
+            scores_1[snode.get_name()] = 1
+
+    class Runnable:
+        def __init__(self, snode) -> None:
+            self.snode = snode
+            name = next(iter(snode.get_operation_names()))
+            fused_name = name_to_fused_node[name].get_name()
+            self.score = (
+                scores_0[fused_name],
+                scores_1[fused_name],
+                scores_2[fused_name],
+            )
+
+        def __lt__(self, other):
+            return self.score < other.score
+
+    unmet_deps: dict[BaseSchedulerNode, OrderedSet[str]] = {
+        snode: OrderedSet(dep.name for dep in snode.unmet_dependencies)
+        for snode in snodes
+    }
+
+    ready: list[Runnable] = []
+    buffer_users: dict[str, OrderedSet[BaseSchedulerNode]] = defaultdict(OrderedSet)
+    snode_to_cost = {snode: estimate_op_runtime(snode) for snode in snodes}
+
+    for snode, deps in unmet_deps.items():
+        if len(deps) == 0:
+            heapq.heappush(ready, Runnable(snode))
+        for dep in deps:
+            buffer_users[dep].add(snode)
+
+    scheduled = []
+
+    def schedule(snode):
+        """
+        Schedules `snode` and put all unblocked nodes onto the ready queue.
+        """
+        scheduled.append(snode)
+        for buf_name in snode.get_buffer_names():
+            for snode in buffer_users[buf_name]:
+                unmet_deps[snode].remove(buf_name)
+                if len(unmet_deps[snode]) == 0:
+                    heapq.heappush(ready, Runnable(snode))
+
+    def get_overlapping_candidate():
+        """
+        Return the next node in the ready queue that's neither a collective or
+        a wait.
+        """
+        candidates = [
+            x
+            for x in ready
+            if not contains_collective(x.snode) and not contains_wait(x.snode)
+        ]
+        if len(candidates) == 0:
+            return None
+        return min(candidates, key=lambda x: x.score)
+
+    def schedule_collective_for_overlap(snode):
+        """
+        Schedules collective node `snode`, along with one or more compute nodes
+        to overlap with it. The strategy is described in the comment of
+        `reorder_compute_for_overlap`.
+        """
+        if not contains_collective(snode):
+            raise AssertionError("expected snode to contain a collective")
+        schedule(snode)
+
+        collective_cost = snode_to_cost[snode]
+        while (
+            collective_cost > 0
+            and (candidate := get_overlapping_candidate()) is not None
+        ):
+            ready.remove(candidate)
+
+            schedule(candidate.snode)
+
+            collective_cost -= snode_to_cost[candidate.snode]
+        heapq.heapify(ready)
+
+    while ready:
+        snode = heapq.heappop(ready).snode
+        if reorder_for_overlap and contains_collective(snode):
+            schedule_collective_for_overlap(snode)
+        else:
+            schedule(snode)
+
+    for deps in unmet_deps.values():
+        if len(deps) != 0:
+            raise AssertionError(
+                f"Detected unscheduled nodes. Nodes with unmet dependencies: {unmet_deps}"
+            )
+    return scheduled
+
+
+def decide_global_ordering_of_comms(
+    nodes: list[BaseSchedulerNode], name_to_buf, name_to_fused_node
+) -> list[BaseSchedulerNode]:
+    """
+    Decide global ordering of comms, by just enforcing the ordering that's in the input graph
+    (might not be the same ordering as the eager mode program).
+    TODO: Come up with a better approach
+    """
+    if not torch.distributed.is_available():
+        return nodes
+
+    comm_nodes = [n for n in nodes if contains_collective(n)]
+
+    for i in range(1, len(comm_nodes)):
+        # Enforce ordering by making previous comm a `WeakDep` dependency of the next comm
+        mutating_buf = next(iter(comm_nodes[i].get_buffer_names()))
+        for buf in comm_nodes[i - 1].get_buffer_names():
+            comm_nodes[i].add_fake_dep(
+                WeakDep(buf, mutating_buf=mutating_buf, is_fake=True)
+            )
+
+    return nodes
+
+
+@dataclass
+class SinkWaitInfo:
+    grouped: int = 0
+    grouped_info: str = ""
+    moves: int = 0
+    moves_info: str = ""
+    limiting_factor: str = "None"
+    comm_time: float = -1.0
+    comp_time: float = -1.0
+    initial_exposed: float = -1.0
+    final_exposed: float = -1.0
+    overlap_info: str = "None"
+
+    @property
+    def improvement(self):
+        return self.initial_exposed - self.final_exposed
+
+
+def _is_node_groupable_for_sink_waits(
+    candidate: BaseSchedulerNode,
+) -> tuple[bool, str | None]:
+    """
+    Check if a candidate node can be grouped during sink_waits pass.
+
+    Sink Waits traverses waits right to left, so we don't group with
+    processed waits on the right or with async collectives.
+
+    Args:
+        candidate: Node to check for groupability
+
+    Returns:
+        Tuple of (is_groupable, reason_if_not_groupable)
+    """
+    # Sink Waits traverse Waits right to left,
+    # => we do not group with processed Waits on the right.
+    if contains_wait(candidate):
+        return False, f"candidate contains wait {candidate.get_name()}"
+    if contains_async_collective(candidate):
+        return (
+            False,
+            f"candidate contains_async_collective {candidate.get_name()}",
+        )
+
+    if not config_comms.sink_iterative_use_runtime_estimations:
+        # Heuristics pre-use_runtime_estimations:
+        # TODO(ivankobzarev): Remove them after confirming,
+        # that using runtime estimations always give better results.
+        # We do not want to group with collectives to not reorder them forward.
+        if contains_collective(candidate):
+            return (
+                False,
+                f"candidate contains collective {candidate.get_name()}",
+            )
+        if contains_gemm_like(candidate):
+            return (
+                False,
+                f"candidate contains gemm_like {candidate.get_name()}",
+            )
+    return True, None
+
+
+def _update_memory_tracking_after_swap_sink_waits(
+    candidate: BaseSchedulerNode,
+    gns: list[BaseSchedulerNode],
+    candidate_delta_mem: int,
+    candidate_allocfree: SNodeMemory,
+    group_n_to_bufs_after_swap_dealloc_instead_of_candidate: dict,
+    post_alloc_update: dict[BaseSchedulerNode, int],
+    size_free_delta_update: dict[BaseSchedulerNode, int],
+    curr_memory: dict,
+    snodes_allocfree: dict,
+) -> None:
+    """
+    Update memory tracking structures after swap (sink_waits version).
+
+    Updates curr_memory and snodes_allocfree dictionaries to reflect the new
+    memory state after swapping candidate with group.
+
+    Args:
+        candidate: Node that was moved
+        gns: Group nodes
+        candidate_delta_mem: Net memory change from candidate (alloc - free)
+        candidate_allocfree: Candidate's allocation/free info
+        group_n_to_bufs_after_swap_dealloc_instead_of_candidate: Buffers whose deallocation moves from candidate to group
+        post_alloc_update: Cached post-allocation memory values
+        size_free_delta_update: Cached size-free delta values
+        curr_memory: Current memory state dict (mutated)
+        snodes_allocfree: Node allocation/free info dict (mutated)
+    """
+    group_head = gns[0]
+    pre_group_mem = curr_memory[group_head][0] - snodes_allocfree[group_head].size_alloc
+    if not group_n_to_bufs_after_swap_dealloc_instead_of_candidate:
+        candidate_post_alloc = pre_group_mem + candidate_allocfree.size_alloc
+        curr_memory[candidate] = (
+            candidate_post_alloc,
+            candidate_post_alloc - candidate_allocfree.size_free,
+        )
+        for gn in gns:
+            cm = curr_memory[gn]
+            curr_memory[gn] = (
+                cm[0] + candidate_delta_mem,
+                cm[1] + candidate_delta_mem,
+            )
+        return
+
+    for n in [candidate, *gns]:
+        post_alloc = post_alloc_update[n]
+        snodes_allocfree[n].size_free += size_free_delta_update.get(n, 0)
+        curr_memory[n] = (
+            post_alloc,
+            post_alloc - snodes_allocfree[n].size_free,
+        )
+
+
+def _calculate_potential_peak_memory_sink_waits(
+    candidate: BaseSchedulerNode,
+    gns: list[BaseSchedulerNode],
+    group_head: BaseSchedulerNode,
+    group_peak_memory: int,
+    candidate_delta_mem: int,
+    candidate_allocfree: SNodeMemory,
+    group_n_to_bufs_after_swap_dealloc_instead_of_candidate: dict,
+    curr_memory: dict,
+    snodes_allocfree: dict,
+) -> tuple[int, dict[BaseSchedulerNode, int], dict[BaseSchedulerNode, int]]:
+    """
+    Calculate potential peak memory after swapping candidate with group (sink_waits version).
+
+    Computes new memory levels for all affected nodes and returns the potential
+    peak memory along with cached post-allocation and size-free delta values.
+
+    Args:
+        candidate: Node being moved
+        gns: Group nodes
+        group_head: First node of group
+        group_peak_memory: Current peak memory within the group
+        candidate_delta_mem: Net memory change from candidate (alloc - free)
+        candidate_allocfree: Candidate's allocation/free info
+        group_n_to_bufs_after_swap_dealloc_instead_of_candidate: Buffers whose deallocation moves from candidate to group
+        curr_memory: Current memory state dict
+        snodes_allocfree: Allocation/free info for all nodes
+
+    Returns:
+        Tuple of (potential_peak_memory, post_alloc_update_dict, size_free_delta_update_dict)
+    """
+    pre_group_mem = curr_memory[group_head][0] - snodes_allocfree[group_head].size_alloc
+    # Stash memory tracing updates to not recompute them after swap
+    _post_alloc_update: dict[BaseSchedulerNode, int] = {}
+    _size_free_delta_update: dict[BaseSchedulerNode, int] = {}
+
+    potential_peak = 0
+    if not group_n_to_bufs_after_swap_dealloc_instead_of_candidate:
+        # Not accounting for buffers liveliness change
+        potential_peak = max(
+            group_peak_memory + candidate_delta_mem,
+            pre_group_mem + candidate_allocfree.size_alloc,
+        )
+        return potential_peak, _post_alloc_update, _size_free_delta_update
+
+    candidate_post_alloc = pre_group_mem + candidate_allocfree.size_alloc
+    _post_alloc_update[candidate] = candidate_post_alloc
+    potential_peak = candidate_post_alloc
+    candidate_size_free_to_move = sum(
+        buf.mpi_buffer.size_free  # type: ignore[attr-defined]
+        for buf in itertools.chain.from_iterable(
+            group_n_to_bufs_after_swap_dealloc_instead_of_candidate.values()
+        )
+    )
+    _size_free_delta_update[candidate] = -candidate_size_free_to_move
+    delta_mem = candidate_delta_mem + candidate_size_free_to_move
+    for gn in gns:
+        gn_post_alloc = curr_memory[gn][0] + delta_mem
+        _post_alloc_update[gn] = gn_post_alloc
+        potential_peak = max(potential_peak, gn_post_alloc)
+        gn_size_free_to_add = 0
+        if gn in group_n_to_bufs_after_swap_dealloc_instead_of_candidate:
+            bufs = group_n_to_bufs_after_swap_dealloc_instead_of_candidate[gn]
+            for buf in bufs:
+                gn_size_free_to_add += buf.mpi_buffer.size_free
+            _size_free_delta_update[gn] = gn_size_free_to_add
+        delta_mem -= gn_size_free_to_add
+    return potential_peak, _post_alloc_update, _size_free_delta_update
+
+
+def _perform_double_linked_list_swap_sink_waits(
+    candidate: BaseSchedulerNode,
+    group_head: BaseSchedulerNode,
+    group_tail: BaseSchedulerNode,
+    prev_dict: dict[BaseSchedulerNode, BaseSchedulerNode | None],
+    next_dict: dict[BaseSchedulerNode, BaseSchedulerNode | None],
+    head: BaseSchedulerNode,
+) -> BaseSchedulerNode:
+    """
+    Swap positions of candidate and group in doubly-linked list (sink_waits version).
+
+    Transforms (moves candidate to the left):
+    group_head_prev -> group_head...group_tail -> candidate -> candidate_next
+    Into:
+    group_head_prev -> candidate -> group_head...group_tail -> candidate_next
+
+    Args:
+        candidate: Node to swap with group
+        group_head: First node of group
+        group_tail: Last node of group
+        prev_dict: Dictionary mapping nodes to their previous nodes
+        next_dict: Dictionary mapping nodes to their next nodes
+        head: Current head of the linked list
+
+    Returns:
+        New head of the linked list (may change if group_head was the head)
+    """
+    # 0: Update group_head's previous node
+    group_head_prev = prev_dict[group_head]
+    if group_head_prev:
+        next_dict[group_head_prev] = candidate
+    prev_dict[candidate] = group_head_prev
+
+    # 2: Update candidate's next node
+    candidate_next = next_dict[candidate]
+    if candidate_next:
+        prev_dict[candidate_next] = group_tail
+    next_dict[group_tail] = candidate_next
+
+    # 1: Link candidate to group_head
+    prev_dict[group_head] = candidate
+    next_dict[candidate] = group_head
+
+    # Update head if group_head was the head
+    if group_head == head:
+        return candidate
+    return head
+
+
+def _format_and_log_sink_waits_stats(
+    stats: dict[BaseSchedulerNode, SinkWaitInfo],
+    head: BaseSchedulerNode,
+    next_dict: dict[BaseSchedulerNode, BaseSchedulerNode | None],
+    original_snodes_num: int,
+    peak_memory: int,
+    name_to_freeable_input_buf: dict,
+    graph_outputs: OrderedSet[str],
+) -> list[BaseSchedulerNode]:
+    """
+    Format sink_waits statistics, log them, and return final node list.
+
+    Computes improvement metrics, creates a formatted table (using tabulate if
+    available), validates the reordered node count, recalculates peak memory,
+    and logs all information.
+
+    Args:
+        stats: Per-node sink_waits statistics
+        head: Head of the reordered linked list
+        next_dict: Linked list next pointers
+        original_snodes_num: Original number of nodes (for validation)
+        peak_memory: Initial peak memory before reordering
+        name_to_freeable_input_buf: Buffer memory tracking info
+        graph_outputs: Graph output names
+
+    Returns:
+        Final reordered list of scheduler nodes
+    """
+    headers = [
+        "Wait node",
+        "comm_time(us)",
+        "comp_time(us)",
+        "initial exposed(us)",
+        "final exposed(us)",
+        "improvement(us)",
+        "limiting factor",
+        "grouped",
+        "grouped_info",
+        "moves",
+        "moves_info",
+        "overlap_info",
+    ]
+    rows = [
+        [
+            node_summary(snode),
+            info.comm_time / 1e3,
+            info.comp_time / 1e3,
+            info.initial_exposed / 1e3,
+            info.final_exposed / 1e3,
+            info.improvement / 1e3,
+            info.limiting_factor,
+            info.grouped,
+            info.grouped_info,
+            info.moves,
+            info.moves_info,
+            info.overlap_info,
+        ]
+        for snode, info in stats.items()
+    ]
+    log_str = ""
+    if importlib.util.find_spec("tabulate"):
+        from tabulate import tabulate
+
+        log_str += tabulate(
+            rows,
+            headers=headers,
+        )
+    else:
+        log_str += "Please `pip install tabulate` to nicely render overlap stats.\n"
+        log_str += str(headers) + "\n"
+        log_str += "\n".join(map(str, rows))
+    overlap_log.info(log_str)
+    new_snodes = _group_nodes_from_linked_list(head, None, next_dict)
+    if len(new_snodes) != original_snodes_num:
+        raise AssertionError(
+            f"expected {original_snodes_num} nodes, got {len(new_snodes)}"
+        )
+    new_peak_memory, _, _, _ = estimate_peak_memory_allocfree(
+        new_snodes, name_to_freeable_input_buf, graph_outputs
+    )
+    log_str += f"\n sink_waits_iterative peak_memory_before:{peak_memory}"
+    log_str += f"\n sink_waits_iterative peak_memory_after:{new_peak_memory}"
+    trace_structured(
+        "artifact",
+        metadata_fn=lambda: {
+            "name": "sink_waits_iterative_info",
+            "encoding": "string",
+        },
+        payload_fn=lambda: log_str,
+    )
+    return new_snodes
+
+
+def _find_buffers_with_changed_last_use_sink_waits(
+    candidate: BaseSchedulerNode,
+    gns: list[BaseSchedulerNode],
+    buf_to_snode_last_use: dict,
+    candidate_buffer_map: dict[BaseSchedulerNode, OrderedSet],
+) -> dict[BaseSchedulerNode, list[FreeableInputBuffer | Any]]:
+    """
+    Find buffers whose last use will change after swapping in sink_waits pass.
+
+    When we swap [group] candidate to candidate [group], some buffers that
+    were last used by candidate will now be last used by a group node instead.
+    This is the opposite direction from the reorder version.
+
+    Args:
+        candidate: The node being moved (currently last use)
+        gns: Group nodes being swapped with candidate
+        buf_to_snode_last_use: Mapping of buffers to their current last-use nodes
+        candidate_buffer_map: Pre-computed map of node -> buffers using that node
+
+    Returns:
+        Dict mapping group nodes to buffers that will change their last-use node
+    """
+    group_n_to_bufs_after_swap_dealloc_instead_of_candidate: dict[
+        BaseSchedulerNode, list[FreeableInputBuffer | Any]
+    ] = defaultdict(list)
+
+    # Optimization: only check buffers where candidate is a successor
+    # Reduces from O(all_buffers) to O(buffers_per_candidate)
+    candidate_bufs = candidate_buffer_map.get(candidate, OrderedSet())
+
+    for buf in candidate_bufs:
+        snode_last_use = buf_to_snode_last_use[buf]
+        if snode_last_use != candidate:
+            continue
+
+        # candidate is last use of buf
+        # Find last group node in successors (maintains order)
+        succ_nodes = buf.mpi_buffer.succ_nodes
+        last_succ_gn = None
+        for gn in gns:
+            if gn in succ_nodes:
+                last_succ_gn = gn
+
+        if last_succ_gn is None:
+            continue
+
+        # gn has successors of buf that after potential swap will become
+        # last use of buf and start deallocating buf instead of candidate
+        group_n_to_bufs_after_swap_dealloc_instead_of_candidate[last_succ_gn].append(
+            buf
+        )
+
+    return group_n_to_bufs_after_swap_dealloc_instead_of_candidate
+
+
+def _sink_waits_iterative_internal(
+    snodes: list[BaseSchedulerNode],
+) -> tuple[list[BaseSchedulerNode], dict[BaseSchedulerNode, SinkWaitInfo]]:
+    original_snodes_num = len(snodes)
+    if original_snodes_num == 0:
+        return snodes, {}
+    graph_inputs: OrderedSet[str] = OrderedSet(V.graph.graph_inputs.keys())
+    graph_outputs: OrderedSet[str] = OrderedSet(V.graph.get_output_names())
+    (
+        peak_memory,
+        _curr_memory,
+        snodes_allocfree,
+        buf_to_snode_last_use,
+        name_to_freeable_input_buf,
+        candidate_buffer_map,
+    ) = _initialize_memory_tracking(snodes, graph_inputs, graph_outputs)
+
+    _prev, _next, _head = _initialize_double_linked_list(snodes)
+
+    stats: dict[BaseSchedulerNode, SinkWaitInfo] = {}
+
+    runtimes: dict[BaseSchedulerNode, float] = {
+        snode: estimate_op_runtime(snode) * _op_runtime_estimate_mult(snode)
+        for snode in snodes
+    }
+
+    # Pre-compute output and dependency sets for O(1) lookup instead of O(N) creation per iteration
+    node_output_sets: dict[BaseSchedulerNode, frozenset[str]] = {
+        snode: frozenset(o.get_name() for o in snode.get_outputs()) for snode in snodes
+    }
+    node_dep_sets: dict[BaseSchedulerNode, frozenset[str]] = {
+        snode: frozenset(
+            d.name for d in snode.unmet_dependencies if not _is_fake_dep(d)
+        )
+        for snode in snodes
+    }
+
+    curr: BaseSchedulerNode | None = snodes[-1]
+
+    processed_waits = OrderedSet()  # type: ignore[var-annotated]
+    debug_iterative_memory_recompute = (
+        config_comms.reorder_iterative_debug_memory_recompute
+    )
+    debug_num_sink_waits_to_reorder: int | None = (
+        config_comms.sink_waits_iterative_debug_limit_to_sink
+    )
+
+    iterative_recompute_error = False
+    while curr is not None and _prev[curr] is not None:
+        _prev_curr = _prev[curr]
+        if iterative_recompute_error:
+            break
+        if (
+            debug_num_sink_waits_to_reorder is not None
+            and len(processed_waits) >= debug_num_sink_waits_to_reorder
+        ):
+            break
+
+        if not (contains_wait(curr) and curr not in processed_waits):
+            curr = _prev_curr
+            continue
+
+        processed_waits.add(curr)
+        info = stats[curr] = SinkWaitInfo()
+        comm_time, comp_time, overlap_info = _wait_exposed_communication_time(
+            curr, _head, _prev, runtimes, node_output_sets, node_dep_sets
+        )
+        info.initial_exposed = info.final_exposed = comm_time - comp_time
+        info.comm_time = comm_time
+        info.comp_time = comp_time
+        info.overlap_info = overlap_info
+
+        candidate = _next[curr]
+        group_head = curr
+        group_tail = curr
+        group_colls = {}
+        group_runtime = 0.0
+        group_peak_memory = _curr_memory[curr][0]
+
+        # Track group outputs and check collective status incrementally - initialize from pre-computed set
+        group_output_names = OrderedSet(node_output_sets[curr])
+        group_contains_collective = contains_collective(curr)
+
+        while candidate is not None:
+            if config_comms.sink_iterative_use_runtime_estimations and (
+                info.final_exposed
+                < -config_comms.sink_iterative_extra_comm_comp_overlap * info.comm_time
+            ):
+                info.limiting_factor = "unexposed by runtime estimations"
+                break
+
+            # Early exit: if group has no outputs, candidate can't depend on it
+            if not group_output_names:
+                data_dep = False
+            else:
+                # Calculate candidate dependencies using pre-computed set
+                candidate_dep_names = node_dep_sets[candidate]
+                data_dep = bool(candidate_dep_names & group_output_names)
+
+            # Conservative sink wait, limiting by space before next collective.
+            # The global strategy is that bucketing should create space.
+            # For 2D we can experiment with allowing to sink Wait beyond non current group collective.
+
+            if not config_comms.sink_waits_iterative_swap_with_collectives:
+                if contains_async_collective(candidate):
+                    info.limiting_factor = (
+                        f"candidate contains_async_collective {candidate.get_name()}"
+                    )
+                    break
+
+            # 1. If we have data_dep - we can not swap => trying to group
+            # 2. If swap candidate and current node both contain collectives => trying to group
+            both_contain_comms = group_contains_collective and contains_collective(
+                candidate
+            )
+            if data_dep or both_contain_comms:
+                _is_groupable, groupable_reason = _is_node_groupable_for_sink_waits(
+                    candidate
+                )
+                if _is_groupable:
+                    group_tail = candidate
+
+                    # Update incremental tracking using pre-computed set
+                    group_output_names.update(node_output_sets[candidate])
+                    group_contains_collective = (
+                        group_contains_collective or contains_collective(candidate)
+                    )
+
+                    if (
+                        config_comms.sink_iterative_use_runtime_estimations
+                        and contains_collective(candidate)
+                    ):
+                        comm_time, comp_time, _ = _coll_exposed_communication_time(
+                            candidate, _next, runtimes, node_output_sets, node_dep_sets
+                        )
+                        group_colls[candidate] = (comm_time, comp_time)
+                        if not contains_async_collective(candidate):
+                            group_runtime += runtimes[candidate]
+
+                    group_peak_memory = max(
+                        group_peak_memory, _curr_memory[candidate][0]
+                    )
+                    info.grouped += 1
+                    candidate = _next[candidate]
+                    continue
+                elif not data_dep:
+                    if (
+                        not config_comms.sink_waits_iterative_unsafe_collectives_reorder
+                        and both_contain_comms
+                    ):
+                        info.limiting_factor = (
+                            f"collective ordering"
+                            f"\n with candidate:{candidate.get_name()}"
+                        )
+                        break
+                else:
+                    info.limiting_factor = (
+                        f"data dependency detected"
+                        f"\n candidate:{candidate.get_name()}"
+                        f"\n non_group_reason:{groupable_reason}"
+                    )
+                    break
+
+            if config_comms.sink_iterative_use_runtime_estimations:
+                if is_wait(candidate.node):
+                    # Corresponding collective is before the group,
+                    # Swap can increase exposed time of corresponding collective
+                    comm_time, comp_time, _ = _wait_exposed_communication_time(
+                        candidate,
+                        _head,
+                        _prev,
+                        runtimes,
+                        node_output_sets,
+                        node_dep_sets,
+                    )
+                    # pyrefly: ignore[no-matching-overload]
+                    exposed_before = max(0, comm_time - comp_time)
+                    # pyrefly: ignore[no-matching-overload]
+                    exposed_after = max(0, comm_time - comp_time + group_runtime)
+                    # We do not know how much we can sink more after this swap,
+                    # Just comparing advantage at the moment for now.
+                    if exposed_after > exposed_before:
+                        info.limiting_factor = (
+                            "candidate is wait,"
+                            f" exposed_before:{exposed_before} vs exposed_after:{exposed_after}"
+                        )
+                        break
+
+                # Check if candidate has sync runtime
+                if not contains_async_collective(candidate):
+                    # If candidate has sync runtime,
+                    # Waits of gorup_colls are on the right from group.
+                    # Swap can increase their exposed time.
+                    c_runtime = runtimes[candidate]
+
+                    if c_runtime > 0 and len(group_colls) > 0:
+                        # pyrefly: ignore[no-matching-overload]
+                        exposed_before = max(0, info.comm_time - info.comp_time)
+                        # pyrefly: ignore[no-matching-overload]
+                        exposed_after = max(
+                            0, info.comm_time - info.comp_time - c_runtime
+                        )
+                        exposed_delta = exposed_after - exposed_before
+                        for gc_comm_time, gc_comp_time in group_colls.values():
+                            # pyrefly: ignore [no-matching-overload]
+                            gc_exposed_before = max(0, gc_comm_time - gc_comp_time)
+                            # pyrefly: ignore [no-matching-overload]
+                            gc_exposed_after = max(
+                                0, gc_comm_time - gc_comp_time + c_runtime
+                            )
+                            exposed_delta += gc_exposed_after - gc_exposed_before
+                        if exposed_delta > 0:
+                            info.limiting_factor = (
+                                f"candidate has compute {c_runtime}, group contains collectives,"
+                                f" total_exposed_delta {exposed_delta}"
+                            )
+                            break
+                        else:
+                            # Update all group_colls comm_time, comp_time
+                            for gc, (
+                                gc_comm_time,
+                                gc_comp_time,
+                            ) in group_colls.items():
+                                group_colls[gc] = (
+                                    gc_comm_time,
+                                    gc_comp_time - c_runtime,
+                                )
+
+            # Create group nodes list once for swap operations
+            gns: list[BaseSchedulerNode] = _group_nodes_from_linked_list(
+                group_head, group_tail, _next
+            )
+
+            candidate_allocfree: SNodeMemory = snodes_allocfree[candidate]
+            candidate_delta_mem = (
+                candidate_allocfree.size_alloc - candidate_allocfree.size_free
+            )
+            # [group] candidate -> candidate [group]
+            # Check for buffers with successors in group and candidate last successor
+            #
+            # Buf that  changes its last use snode,
+            # It was deallocated by candidate,
+            # but after swap it will be deallocated by group node.
+            group_n_to_bufs_after_swap_dealloc_instead_of_candidate = (
+                _find_buffers_with_changed_last_use_sink_waits(
+                    candidate, gns, buf_to_snode_last_use, candidate_buffer_map
+                )
+            )
+
+            potential_peak, _post_alloc_update, _size_free_delta_update = (
+                _calculate_potential_peak_memory_sink_waits(
+                    candidate,
+                    gns,
+                    group_head,
+                    group_peak_memory,
+                    candidate_delta_mem,
+                    candidate_allocfree,
+                    group_n_to_bufs_after_swap_dealloc_instead_of_candidate,
+                    _curr_memory,
+                    snodes_allocfree,
+                )
+            )
+            if (
+                potential_peak - peak_memory
+                > peak_memory * config_comms.sink_iterative_peak_memory_budget
+            ):
+                info.limiting_factor = (
+                    f"peak memory new:{potential_peak} vs base:{peak_memory}"
+                )
+                break
+
+            info.moves += 1
+            info.moves_info += f"+{candidate.get_name()}"
+
+            _head = _perform_double_linked_list_swap_sink_waits(
+                candidate, group_head, group_tail, _prev, _next, _head
+            )
+
+            comm_time, comp_time, overlap_info = _wait_exposed_communication_time(
+                curr, _head, _prev, runtimes, node_output_sets, node_dep_sets
+            )
+            info.comm_time = comm_time
+            info.comp_time = comp_time
+            info.final_exposed = comm_time - comp_time
+            info.overlap_info = overlap_info
+
+            _update_memory_tracking_after_swap_sink_waits(
+                candidate,
+                gns,
+                candidate_delta_mem,
+                candidate_allocfree,
+                group_n_to_bufs_after_swap_dealloc_instead_of_candidate,
+                _post_alloc_update,
+                _size_free_delta_update,
+                _curr_memory,
+                snodes_allocfree,
+            )
+
+            if debug_iterative_memory_recompute:
+                from .comms_debug import _debug_iterative_memory_recompute
+
+                iterative_recompute_error = _debug_iterative_memory_recompute(
+                    candidate,
+                    gns,
+                    _group_names(gns),
+                    _group_nodes_from_linked_list(_head, None, _next),
+                    name_to_freeable_input_buf,
+                    graph_outputs,
+                    peak_memory,
+                    _curr_memory,
+                    snodes_allocfree,
+                    "sink_waits_iterative",
+                    group_n_to_bufs_after_swap_dealloc_instead_of_candidate,
+                )
+                if iterative_recompute_error:
+                    break
+
+            candidate = _next[group_tail]
+        curr = _prev_curr
+
+    if not config_comms.reorder_sink_verbose_logging:
+        new_snodes = _group_nodes_from_linked_list(_head, None, _next)
+        return new_snodes, stats
+
+    new_snodes = _format_and_log_sink_waits_stats(
+        stats,
+        _head,
+        _next,
+        original_snodes_num,
+        peak_memory,
+        name_to_freeable_input_buf,
+        graph_outputs,
+    )
+
+    return new_snodes, stats
+
+
+def sink_waits_iterative(snodes: list[BaseSchedulerNode]) -> list[BaseSchedulerNode]:
+    """
+    Similarly to reorder_communication_preserving_peak_memory this pass will try to iteratively
+    push Wait nodes later, recomputing estimated peak memory before each swap,
+    and preventing peak memory regressions.
+
+    Pass will be applied to every Wait node. If there are immediate dependencies with next node,
+    pass will try to group them together and on the next step to swap the group with next candidate.
+
+    If _inductor.config_comms.sink_iterative_use_runtime_estimations is set True,
+    pass will stop reordering of Wait once corresponding Collective is unexposed,
+    based on runtime estimations.
+
+    inductor.config_comms.sink_iterative_peak_memory_budget allows to tune how much pass
+    can regress initial peak memory.
+    E.g.:
+    sink_iterative_peak_memory_budget == 0.0 - No regression of initial peak memory is allowed
+    sink_iterative_peak_memory_budget == 0.2 - Pass can improve comm-compute overlap, sacrificing
+    20% of initial peak memory value.
+
+    inductor.config_comms.sink_iterative_extra_comm_comp_overlap config allows to more aggressively
+    sink waits, stopping only when overlap_compute >= (1 + extra_comm_comp_overlap) * comm_time
+    """
+    return _sink_waits_iterative_internal(snodes)[0]
+
+
+def estimate_op_runtime(snode: BaseSchedulerNode) -> float:
+    """
+    Returns estimated op runtime in milliseconds (ms)
+    """
+    if config.estimate_op_runtime == "default":
+        runtime = snode.get_estimated_runtime()
+    else:
+        if not callable(config.estimate_op_runtime):
+            raise AssertionError("expected config.estimate_op_runtime to be callable")
+        runtime = config.estimate_op_runtime(snode)
+    return runtime
+
+
+def node_summary(snode):
+    snodes = snode.get_nodes()
+    if len(snodes) == 1:
+        detail = ""
+        if isinstance(snode.node, (ir.ExternKernelOut, ir._CollectiveKernel)):
+            outs_str = f"outs:{[o.get_name() for o in snode.get_outputs()]}"
+            ins_str = f"ins:{[d.name for d in snode.unmet_dependencies]}"
+            detail = f" {snode.get_name()} ({snode.node.python_kernel_name})\n {outs_str}({ins_str})"
+        layouts = [child.node.get_output_spec() for child in snode.get_nodes()]
+        out_tensor_info = ",".join(
+            [
+                f" (size={layout.size}, stride={layout.stride})"
+                if isinstance(layout, ir.Layout)
+                else ""
+                for layout in layouts
+            ]
+        )
+        try:
+            node_name = snode.node.maybe_get_name()
+        except AttributeError:
+            # TODO: node_summary was written without FusedSchedulerNode in mind, generally needs to be hardened
+            node_name = ""
+        return f"{snode.node.__class__.__name__}{detail}{out_tensor_info} ({node_name} ({snode.get_estimated_runtime():.0f} ns)"
+
+    # Flatten the summaries for Fused/Foreach/Grouped nodes
+    summaries = []
+    for child_snode in snodes:
+        summaries.append(node_summary(child_snode))
+    return f"{snode.__class__.__name__}: {', '.join(summaries)}"
+
+
+def visualize_overlap(order):
+    # TODO - this function probably doesn't do a very good job estimating the runtime because it doesn't carefully model
+    # streams and overlap. For now its mostly useful as a debug visualization.
+
+    total_est_runtime: float = 0.0
+    cur_comm_node = None
+
+    def step_log(step, msg):
+        overlap_log.debug(f"{step:>6}: {msg}")
+
+    for step, snode in enumerate(order):
+        if cur_comm_node is None:
+            if contains_collective(snode):
+                total_est_runtime += estimate_op_runtime(snode)
+                cur_comm_node = snode.node
+            elif is_wait(snode.node):
+                # raise AssertionError(
+                #     "Wait is not expected when there is no collective running"
+                # )
+                pass
+            else:  # exposed compute op
+                total_est_runtime += estimate_op_runtime(snode)
+            step_log(step, f"{node_summary(snode)}")
+        else:  # cur_comm_node is not None
+            if contains_collective(snode):
+                total_est_runtime += estimate_op_runtime(snode)
+                cur_comm_node = snode.node
+                step_log(step, f"{node_summary(snode)}")
+            elif is_wait(snode.node):  # end of this comm op
+                step_log(step, f"{node_summary(snode)}")
+                cur_comm_node = None
+            else:  # overlapped compute op
+                step_log(step, f"| {node_summary(snode)}")
+    overlap_log.debug(f"Est. runtime (ms): {total_est_runtime / 1000 / 1000}")
+
+
+def simple_overlap(snodes: list[BaseSchedulerNode]) -> list[BaseSchedulerNode]:
+    """Move collectives earlier and waits later via adjacent swaps.
+    Each swap is safe: no collective reordering, no memory regression."""
+    if len(snodes) < 2:
+        return snodes
+
+    collectives = [s for s in snodes if contains_async_collective(s)]
+    waits = [s for s in snodes if contains_wait(s)]
+    if not collectives and not waits:
+        return snodes
+
+    outputs_of: dict[BaseSchedulerNode, frozenset[str]] = {
+        s: frozenset(o.get_name() for o in s.get_outputs()) for s in snodes
+    }
+    # Fake WeakDeps encode ordering-only constraints, such as collective order.
+    deps_of: dict[BaseSchedulerNode, frozenset[str]] = {
+        s: frozenset(d.name for d in s.unmet_dependencies) for s in snodes
+    }
+
+    _prev, _next, _head = _initialize_double_linked_list(snodes)
+    (
+        peak_memory,
+        _curr_memory,
+        snodes_allocfree,
+        _buf_last_use,
+        _freeable,
+        _cand_buf_map,
+    ) = _initialize_memory_tracking(snodes)
+
+    n_moved_colls = 0
+    n_moved_waits = 0
+
+    def peak_memory_safe_swap(
+        candidate: BaseSchedulerNode,
+        group_node: BaseSchedulerNode,
+        *,
+        sink_wait: bool,
+    ) -> bool:
+        nonlocal _head
+
+        group_nodes = [group_node]
+        candidate_af = snodes_allocfree[candidate]
+        candidate_delta = candidate_af.size_alloc - candidate_af.size_free
+        size_free_cache: dict[BaseSchedulerNode, int] = {}
+
+        if sink_wait:
+            changed_bufs = _find_buffers_with_changed_last_use_sink_waits(
+                candidate, group_nodes, _buf_last_use, _cand_buf_map
+            )
+            potential_peak, post_alloc_cache, size_free_cache = (
+                _calculate_potential_peak_memory_sink_waits(
+                    candidate,
+                    group_nodes,
+                    group_node,
+                    _curr_memory[group_node][0],
+                    candidate_delta,
+                    candidate_af,
+                    changed_bufs,
+                    _curr_memory,
+                    snodes_allocfree,
+                )
+            )
+        else:
+            changed_bufs = _find_buffers_with_changed_last_use(
+                candidate, group_nodes, _buf_last_use, _cand_buf_map
+            )
+            potential_peak, post_alloc_cache = _calculate_potential_peak_memory_reorder(
+                candidate,
+                group_nodes,
+                group_node,
+                _curr_memory[group_node][0],
+                candidate_delta,
+                candidate_af,
+                changed_bufs,
+                _curr_memory,
+            )
+
+        if potential_peak > peak_memory:
+            return False
+
+        if sink_wait:
+            _head = _perform_double_linked_list_swap_sink_waits(
+                candidate, group_node, group_node, _prev, _next, _head
+            )
+            _update_memory_tracking_after_swap_sink_waits(
+                candidate,
+                group_nodes,
+                candidate_delta,
+                candidate_af,
+                changed_bufs,
+                post_alloc_cache,
+                size_free_cache,
+                _curr_memory,
+                snodes_allocfree,
+            )
+        else:
+            _head = _perform_double_linked_list_swap(
+                candidate, group_node, group_node, _prev, _next, _head
+            )
+            _update_memory_tracking_after_swap_reorder(
+                candidate,
+                group_nodes,
+                group_node,
+                candidate_delta,
+                candidate_af,
+                changed_bufs,
+                post_alloc_cache,
+                _curr_memory,
+                _buf_last_use,
+                snodes_allocfree,
+            )
+
+        return True
+
+    # Phase 1: move each collective earlier via adjacent swaps
+    # Swap [pred, coll] -> [coll, pred]: pred is the "candidate" (moves later)
+    for coll in collectives:
+        coll_deps = deps_of[coll]
+        moved = False
+
+        pred = _prev[coll]
+        while pred is not None:
+            if outputs_of[pred] & coll_deps:
+                break
+            if contains_async_collective(pred):
+                break
+            if not peak_memory_safe_swap(pred, coll, sink_wait=False):
+                break
+
+            moved = True
+            pred = _prev[coll]
+
+        if moved:
+            n_moved_colls += 1
+
+    # Phase 2: move each wait later via adjacent swaps
+    # Swap [wait, succ] -> [succ, wait]: succ is the "candidate" (moves earlier)
+    for wait in reversed(waits):
+        wait_outs = outputs_of[wait]
+        moved = False
+
+        succ = _next[wait]
+        while succ is not None:
+            if deps_of[succ] & wait_outs:
+                break
+            if contains_wait(succ):
+                break
+            if not peak_memory_safe_swap(succ, wait, sink_wait=True):
+                break
+
+            moved = True
+            succ = _next[wait]
+
+        if moved:
+            n_moved_waits += 1
+
+    if n_moved_colls or n_moved_waits:
+        log.info(
+            "simple_overlap: moved %d collectives, %d waits (peak %d MB)",
+            n_moved_colls,
+            n_moved_waits,
+            peak_memory // (1024 * 1024),
+        )
+
+    return _group_nodes_from_linked_list(_head, None, _next)
+
+
+def reorder_compute_and_comm_for_overlap(
+    snodes: list[BaseSchedulerNode],
+) -> list[BaseSchedulerNode]:
+    order = snodes
+    # pyrefly: ignore [bad-assignment]
+    for p in config.reorder_for_compute_comm_overlap_passes:
+        if isinstance(p, str) and p in globals():
+            p = globals()[p]  # it is a builtin pass
+        if not callable(p):
+            raise AssertionError(
+                f"Invalid reorder_compute_and_comm_for_overlap pass: {p} is not callable"
+            )
+        order = p(order)  # type: ignore[operator]
+    # pyrefly: ignore [bad-return]
+    return order

.venv/lib/python3.12/site-packages/torch/_inductor/comms_debug.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from torch._logging import trace_structured
+
+from .memory import estimate_peak_memory_allocfree
+
+
+if TYPE_CHECKING:
+    from torch.utils._ordered_set import OrderedSet
+
+    from .memory import FreeableInputBuffer, SNodeMemory
+    from .scheduler import BaseSchedulerNode, SchedulerBuffer
+
+
+def _debug_iterative_memory_recompute(
+    candidate: BaseSchedulerNode,
+    gns: list[BaseSchedulerNode],
+    group_names: str,
+    snodes: list[BaseSchedulerNode],
+    name_to_freeable_input_buf: dict[str, FreeableInputBuffer],
+    graph_outputs: OrderedSet[str],
+    peak_memory: int,
+    iter_curr_memory: dict[BaseSchedulerNode, tuple[int, int]],
+    snodes_allocfree: dict[BaseSchedulerNode, SNodeMemory],
+    tlparse_name: str,
+    gn_to_bufs_last_use: dict[
+        BaseSchedulerNode, list[FreeableInputBuffer | SchedulerBuffer]
+    ],
+) -> bool:
+    iterative_recompute_error = False
+    candidate_allocfree = snodes_allocfree[candidate]
+    est_peak_memory, snodes_curr_memory, snodes_allocfree, _ = (
+        estimate_peak_memory_allocfree(
+            snodes, name_to_freeable_input_buf, graph_outputs
+        )
+    )
+    est_curr_memory = dict(zip(snodes, snodes_curr_memory))
+    iter_cm = iter_curr_memory[candidate]
+    new_cm = est_curr_memory[candidate]
+    log = ""
+    if est_peak_memory > peak_memory:
+        log = "ITERATIVE PEAK DOES NOT MATCH"
+        iterative_recompute_error = True
+    if iter_cm != new_cm:
+        log = "ITERATIVE CURR MEMORY CANDIDATE DOES NOT MATCH"
+        iterative_recompute_error = True
+    for gn in gns:
+        iter_gnm = iter_curr_memory[gn]
+        new_gnm = est_curr_memory[gn]
+        if iter_gnm != new_gnm:
+            log = f"ITERATIVE GN CURR MEMORY DOES NOT MATCH:{gn.get_name()}"
+            iterative_recompute_error = True
+    if iterative_recompute_error:
+        log += (
+            f"\nCANDIDATE:{candidate.get_name()}"
+            f"\nGROUP:{group_names}"
+            f"\nPEAK_MEMORY_BEFORE:{peak_memory}"
+            f"\nPEAK_MEMORY_AFTER_SWAP:{est_peak_memory}"
+            f"\nCANDIDATE:{candidate.debug_str()}"
+            f"\nCANDIDATE_ITER_CURR_MEMORY:{iter_cm}"
+            f"\nCANDIDATE_NEW__CURR_MEMORY:{new_cm}"
+            f"\nCANDIDATE_ITER_ALLOCFREE:{candidate_allocfree}"
+            f"\nCANDIDATE_NEW_ALLOCFREE:{snodes_allocfree[candidate]}"
+        )
+        peak_log = ""
+        for i, (pre, _post) in enumerate(snodes_curr_memory):
+            if est_peak_memory == pre:
+                n = snodes[i]
+                peak_log = (
+                    f"\nNEW_PEAK:{est_peak_memory}(BASE:{peak_memory})"
+                    f" @ SNODE[{i}/{len(snodes)}]:{n.get_name()} {n.debug_str()}"
+                )
+                break
+        group_log = ""
+        for i, gn in enumerate(gns):
+            iter_gnm = iter_curr_memory[gn]
+            new_gnm = est_curr_memory[gn]
+            group_log += (
+                f"\nGROUP_NODE[{i}]:{gn.debug_str()}"
+                f"\nGROUP_NODE[{i}] ITER_GNM[{gn.get_name()}]:{iter_gnm}"
+                f"\nGROUP_NODE[{i}] ESTM_GNM[{gn.get_name()}]:{new_gnm}"
+                f"\nGROUP_NODE[{i}] ITER_allocfree:{snodes_allocfree[gn]}"
+                f"\nGROUP_NODE[{i}] ESTM_allocfree:{snodes_allocfree[gn]}"
+            )
+        log += peak_log
+        log += group_log
+        log += f"\nGN_TO_BUFS_LAST_USE:{gn_to_bufs_last_use}"
+        log += "\n\n".join(
+            [
+                (
+                    f"\nSNODE[{i}]\n{n.debug_str()}"
+                    f"\nITER_cur_mem:{iter_curr_memory[n]}"
+                    f"\nESTM_cur_mem:{est_curr_memory[n]}"
+                    f"\nITER_allocfree:{snodes_allocfree[n]}"
+                    f"\nESTM_allocfree:{snodes_allocfree[n]}"
+                )
+                for i, n in enumerate(snodes)
+            ]
+        )
+        tname = f"{tlparse_name}_ITERATIVE_RECOMPUTE_ERROR"
+        print(f"{tname}:\n{log}")
+        trace_structured(
+            "artifact",
+            metadata_fn=lambda: {
+                "name": tname,
+                "encoding": "string",
+            },
+            payload_fn=lambda: log,
+        )
+    return iterative_recompute_error

.venv/lib/python3.12/site-packages/torch/_inductor/compile_fx_async.py

@@ -0,0 +1,415 @@
+from __future__ import annotations
+
+from collections import deque
+from dataclasses import dataclass
+from typing import Any, TYPE_CHECKING
+from typing_extensions import final, override
+
+import torch._inductor.async_compile  # noqa: F401 required to warm up AsyncCompile pools
+from torch._inductor.output_code import (
+    CompiledFxGraph,
+    CompiledFxGraphConstants,
+    OutputCode,
+)
+
+from .compile_fx import _CompileFxKwargs, _InProcessFxCompile, FxCompile
+
+
+# When async compile works with cache, remove the disabling below
+BUG_CACHES_DONT_WORK_WITH_ASYNC = True
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Sequence
+    from concurrent.futures import Future
+
+    from torch._inductor.utils import InputType
+    from torch.fx import GraphModule
+
+    from .compile_fx_ext import _OutOfProcessFxCompile, _WireProtocolPickledOutput
+
+
+@dataclass
+class _PostCompileData:
+    example_inputs: Sequence[InputType]
+    constants: CompiledFxGraphConstants
+    graph_kwargs: _CompileFxKwargs
+
+
+@dataclass
+class ProgressiveCompilationState:
+    progression_futures: deque[Future[_WireProtocolPickledOutput]]
+    callback: Callable[[_WireProtocolPickledOutput], OutputCode]
+    post_compile_data: _PostCompileData | None
+
+    def check_and_get_ready_stage(self) -> int:
+        """Check if any progression stage is ready and return its index, or -1 if none are ready."""
+        if not self.progression_futures:
+            return -1
+
+        stage_index = -1
+        if self.post_compile_data:
+            for i, future in enumerate(self.progression_futures):
+                if future.done():
+                    stage_index = i
+
+        return stage_index
+
+    def switch_to_progression_stage(self, stage_index: int) -> tuple[OutputCode, bool]:
+        """
+        Switch to the specified progression stage and return the optimized output code.
+        Returns a tuple of (optimized_output_code, should_clear_compilation_state).
+        """
+        future = self.progression_futures[stage_index]
+        if future is None:
+            raise AssertionError("expected future to be not None")
+        optimized_output_code = self.callback(future.result())
+
+        if pcd := self.post_compile_data:
+            optimized_output_code.post_compile(
+                pcd.example_inputs, pcd.constants, pcd.graph_kwargs
+            )
+
+        # Clear earlier progression futures to free memory
+        for _ in range(stage_index + 1):
+            self.progression_futures.popleft()
+
+        # Return whether all compilation state should be cleared
+        should_clear_state = not self.progression_futures
+        return optimized_output_code, should_clear_state
+
+
+# _AsyncOutputCode handles the actual management of waiting for an
+# out-of-process compile to finish and then switching over to it.
+@final
+class _AsyncOutputCode(OutputCode):
+    _eager_fn: Callable[..., Any] | None
+    _output_code: OutputCode | None
+    _future: Future[_WireProtocolPickledOutput] | None
+    _callback: Callable[[_WireProtocolPickledOutput], OutputCode]
+    _post_compile_data: _PostCompileData | None = None
+    _boxed_call: bool  # Copied from the forward/output_code
+
+    def __init__(
+        self,
+        # eager_fn is run until the future is finished.
+        eager_fn: Callable[..., Any],
+        # this responds with the result of the out-of-process compile when it's
+        # ready.
+        future: Future[_WireProtocolPickledOutput],
+        # this callback gets called to turn the _WireProtocolPickledOutput into an OutputCode
+        callback: Callable[[_WireProtocolPickledOutput], OutputCode],
+    ) -> None:
+        self._eager_fn = eager_fn
+        self._boxed_call = getattr(eager_fn, "_boxed_call", False)
+        self._output_code = None
+
+        self._future = future
+        self._callback = callback
+
+    @override
+    def __call__(self, *args: Any) -> Any:
+        if self._future is not None and self._future.done():
+            args = self._switch_to_compiled_fn(args)
+
+        if eager_fn := self._eager_fn:
+            _AsyncFxCompile._stat_eager_runs += 1
+            return eager_fn(*args)
+
+        else:
+            _AsyncFxCompile._stat_compiled_runs += 1
+            if self._output_code is None:
+                raise AssertionError("expected self._output_code to be not None")
+            return self._output_code.__call__(*args)
+
+    # Takes and returns the args (converted to the "right" boxed mode)
+    def _switch_to_compiled_fn(self, args: tuple[Any, ...]) -> tuple[Any, ...]:
+        if self._future is None:
+            raise AssertionError("expected self._future to be not None")
+
+        # TODO: If the future ended in an exception do we want to continue
+        # running eager or hit the exception now?
+        f, self._future = self._future, None
+        output_code = self._callback(f.result())
+
+        if pcd := self._post_compile_data:
+            self._post_compile_data = None
+
+            output_code.post_compile(
+                pcd.example_inputs, pcd.constants, pcd.graph_kwargs
+            )
+
+        self._output_code = output_code
+        self._eager_fn = None
+        boxed_call = getattr(output_code, "_boxed_call", False)
+
+        if self._boxed_call != boxed_call:
+            if self._boxed_call:
+                # Was boxed, now unboxed
+                args = args[0] if len(args) > 0 else ()
+            else:
+                # Was unboxed, now boxed
+                args = (args,)
+
+        self._boxed_call = boxed_call
+        return args
+
+    @override
+    def post_compile(
+        self,
+        example_inputs: Sequence[InputType],
+        constants: CompiledFxGraphConstants,
+        graph_kwargs: _CompileFxKwargs,
+    ) -> None:
+        if self._eager_fn is not None:
+            self._post_compile_data = _PostCompileData(
+                example_inputs, constants, graph_kwargs
+            )
+        else:
+            if self._output_code is None:
+                raise AssertionError("expected self._output_code to be not None")
+            self._output_code.post_compile(example_inputs, constants, graph_kwargs)
+
+
+# Given an FxCompile for an out-of-process compile _AsyncFxCompile will run
+# eager until the compiled artifact is ready then it will automatically switch
+# over to using the compiled version.
+@final
+class _AsyncFxCompile(FxCompile):
+    _compile: _OutOfProcessFxCompile
+
+    # Some debugging stats:
+    # Number of times we started a background compile.
+    _stat_bg_started: int = 0
+    # Number of times we finished a background compile.
+    _stat_bg_finished: int = 0
+    # Number of times we ran "eager"
+    _stat_eager_runs: int = 0
+    # Number of times we ran our compiled (out-of-process) artifact
+    _stat_compiled_runs: int = 0
+
+    def __init__(self, compile: _OutOfProcessFxCompile) -> None:
+        self._compile = compile
+
+    @classmethod
+    def _reset_stats(cls) -> None:
+        cls._stat_bg_started = 0
+        cls._stat_bg_finished = 0
+        cls._stat_eager_runs = 0
+        cls._stat_compiled_runs = 0
+
+    @override
+    def codegen_and_compile(
+        self,
+        gm: GraphModule,
+        example_inputs: Sequence[InputType],
+        inputs_to_check: Sequence[int],
+        graph_kwargs: _CompileFxKwargs,
+    ) -> OutputCode:
+        eager_compile = _InProcessFxCompile()
+        eager_compile.compile_region_name = self.compile_region_name
+        eager_output_code = eager_compile.codegen_and_compile(
+            gm, example_inputs, inputs_to_check, graph_kwargs
+        )
+
+        # This is similar to _SerializedFxCompile.codegen_and_compile() but
+        # handles the async routing.
+
+        serialized = self._compile.serialize_compile(
+            gm, example_inputs, inputs_to_check, graph_kwargs
+        )
+        if not serialized:
+            # We can't serialize - just return the eager OutputCode
+            return eager_output_code
+
+        inputs, constants = serialized
+
+        _AsyncFxCompile._stat_bg_started += 1
+        f = self._compile._send_to_child_async(inputs)
+
+        # This is called by _switch_to_compiled_fn() when f has a result...
+        def callback(pickled_output: _WireProtocolPickledOutput) -> OutputCode:
+            _AsyncFxCompile._stat_bg_finished += 1
+            output = pickled_output.deserialize(constants)
+            if isinstance(output.graph, CompiledFxGraph):
+                output.graph.compile_region_name = self.compile_region_name
+            self._compile._postprocess(output)
+            return output.graph
+
+        return _AsyncOutputCode(eager_output_code, f, callback)
+
+
+# _ProgressiveOutputCode handles running a fast compile first, then hot-swapping
+# to a more optimized version when the expensive compile finishes.
+@final
+class _ProgressiveOutputCode(OutputCode):
+    _fast_output_code: OutputCode | None
+    _optimized_output_code: OutputCode | None
+    _compilation_state: ProgressiveCompilationState | None
+    # _boxed_call state is effectively cached (we sometimes wrap unboxed w/
+    # lambdas to box them) so we can't change it mid-way. Since _boxed_call=True
+    # is more common let's default to that and we'll convert if necessary.
+    _boxed_call: bool = True
+
+    def __init__(
+        self,
+        # Fast compile that runs faster than the progressive compiles
+        fast_output_code: OutputCode,
+        # Futures for the progressive optimized compiles
+        progression_futures: Sequence[Future[_WireProtocolPickledOutput]],
+        # Callback to convert the optimized result to OutputCode
+        callback: Callable[[_WireProtocolPickledOutput], OutputCode],
+    ) -> None:
+        self._fast_output_code = fast_output_code
+        self._optimized_output_code = None
+        self._compilation_state = ProgressiveCompilationState(
+            progression_futures=deque(progression_futures),
+            callback=callback,
+            post_compile_data=None,
+        )
+
+    @override
+    def __call__(self, args: Sequence[Any]) -> Any:
+        # Check if any newer progression stage is ready and switch to it
+        self._check_and_switch_progression()
+
+        if self._optimized_output_code is not None:
+            _ProgressiveFxCompile._stat_optimized_runs += 1
+            output_code = self._optimized_output_code
+        else:
+            _ProgressiveFxCompile._stat_fast_runs += 1
+            if self._fast_output_code is None:
+                raise AssertionError("expected self._fast_output_code to be not None")
+            output_code = self._fast_output_code
+
+        boxed_call = getattr(output_code, "_boxed_call", False)
+        if boxed_call:
+            res = output_code.__call__(args)
+        else:
+            res = output_code.__call__(*args)
+        return res
+
+    def _check_and_switch_progression(self) -> None:
+        if not self._compilation_state:
+            return
+
+        stage_index = self._compilation_state.check_and_get_ready_stage()
+        if stage_index == -1:
+            # no futures are ready
+            return
+
+        self._switch_to_progression_stage(stage_index)
+
+    def _switch_to_progression_stage(self, stage_index: int) -> None:
+        if self._compilation_state is None:
+            raise AssertionError("expected self._compilation_state to be not None")
+        optimized_output_code, should_clear_state = (
+            self._compilation_state.switch_to_progression_stage(stage_index)
+        )
+
+        self._optimized_output_code = optimized_output_code
+        self._fast_output_code = None
+
+        # Clear all compilation state if no more progression futures are left
+        if should_clear_state:
+            self._compilation_state = None
+
+    @override
+    def post_compile(
+        self,
+        example_inputs: Sequence[InputType],
+        constants: CompiledFxGraphConstants,
+        graph_kwargs: _CompileFxKwargs,
+    ) -> None:
+        if self._fast_output_code is None:
+            raise AssertionError("expected self._fast_output_code to be not None")
+        self._fast_output_code.post_compile(example_inputs, constants, graph_kwargs)
+
+        if self._compilation_state is None:
+            raise AssertionError("expected self._compilation_state to be not None")
+        # Store for later when optimized version is ready
+        self._compilation_state.post_compile_data = _PostCompileData(
+            example_inputs, constants, graph_kwargs
+        )
+
+
+# _ProgressiveFxCompile runs a fast compile immediately, then kicks off
+# progressive compiles in the background and hot-swaps when they're ready.
+@final
+class _ProgressiveFxCompile(FxCompile):
+    _fast_compile: FxCompile
+    _optimized_compile: _OutOfProcessFxCompile
+    _progression_configs: list[dict[str, Any]]
+
+    # Debugging stats
+    _stat_bg_started: int = 0
+    _stat_bg_finished: int = 0
+    _stat_fast_runs: int = 0
+    _stat_optimized_runs: int = 0
+
+    def __init__(
+        self,
+        fast_compile: FxCompile,
+        optimized_compile: _OutOfProcessFxCompile,
+        progression_configs: list[dict[str, Any]],
+    ) -> None:
+        self._fast_compile = fast_compile
+        self._optimized_compile = optimized_compile
+        self._progression_configs = progression_configs
+
+    @classmethod
+    def _reset_stats(cls) -> None:
+        cls._stat_bg_started = 0
+        cls._stat_bg_finished = 0
+        cls._stat_fast_runs = 0
+        cls._stat_optimized_runs = 0
+
+    @override
+    def codegen_and_compile(
+        self,
+        gm: GraphModule,
+        example_inputs: Sequence[InputType],
+        inputs_to_check: Sequence[int],
+        graph_kwargs: _CompileFxKwargs,
+    ) -> OutputCode:
+        import torch._inductor.config as inductor_config
+
+        progression_futures: list[Future[_WireProtocolPickledOutput]] = []
+
+        for config in self._progression_configs:
+            with inductor_config.patch(config):
+                _ProgressiveFxCompile._stat_bg_started += 1
+
+                # Start the progressive compiles in the background
+                serialized = self._optimized_compile.serialize_compile(
+                    gm, example_inputs, inputs_to_check, graph_kwargs
+                )
+
+                if not serialized:
+                    continue
+
+                inputs, constants = serialized
+                future = self._optimized_compile._send_to_child_async(inputs)
+                progression_futures.append(future)
+
+        fast_output_code = self._fast_compile.codegen_and_compile(
+            gm, example_inputs, inputs_to_check, graph_kwargs
+        )
+
+        if not progression_futures:
+            # All async compile attempts failed - just return the fast version
+            return fast_output_code
+
+        # Callback to handle the optimized result.
+        # This callback may be called multiple times, once for each progressive level completed,
+        # but may be skipped if a level either never completes or if a more optimal level
+        # completes before a less optimal one is switched to.
+        def callback(pickled_output: _WireProtocolPickledOutput) -> OutputCode:
+            _ProgressiveFxCompile._stat_bg_finished += 1
+            output = pickled_output.deserialize(constants)
+            if isinstance(output.graph, CompiledFxGraph):
+                output.graph.compile_region_name = self.compile_region_name
+            self._optimized_compile._postprocess(output)
+            return output.graph
+
+        return _ProgressiveOutputCode(fast_output_code, progression_futures, callback)

.venv/lib/python3.12/site-packages/torch/_inductor/compile_fx_ext.py

@@ -0,0 +1,729 @@
+from __future__ import annotations
+
+import contextlib
+import dataclasses
+import functools
+import logging
+import os
+import queue
+import sys
+import tempfile
+import warnings
+from abc import abstractmethod
+from dataclasses import dataclass
+from typing import Any, TYPE_CHECKING, TypeGuard
+from typing_extensions import final, override, Self
+
+import torch._inductor.async_compile
+import torch.fx
+from torch._inductor.codecache import BypassFxGraphCache, FxGraphCache
+from torch._inductor.metrics import CachedMetricsDeltas, CachedMetricsHelper
+from torch._inductor.output_code import (
+    CompiledFxGraph,
+    CompiledFxGraphConstants,
+    CompiledFxGraphConstantsWithGm,
+    OutputCode,
+)
+from torch._inductor.utils import patch_subprocess_env
+from torch._subclasses import FakeTensorMode
+from torch.utils._ordered_set import OrderedSet
+
+from . import config
+from .compile_fx import _CompileFxKwargs, _InProcessFxCompile, FxCompile, log
+from .debug import DebugContext
+from .graph import GraphLowering
+from .virtualized import V
+
+
+if TYPE_CHECKING:
+    import types
+    from collections.abc import Generator, Mapping, Sequence
+    from concurrent.futures import Future
+
+    from torch._inductor.utils import InputType
+    from torch.fx import GraphModule
+
+
+def _graph_contains_triton_kernel_wrappers(gm: GraphModule) -> bool:
+    """
+    Check if the graph contains triton kernel wrapper nodes. These nodes contain
+    references to the kernel_side_table which is process-local and can't be
+    serialized across processes.
+    """
+    from torch._higher_order_ops.triton_kernel_wrap import (
+        triton_kernel_wrapper_functional,
+        triton_kernel_wrapper_mutation,
+    )
+
+    for module in gm.modules():
+        if not isinstance(module, torch.fx.GraphModule):
+            continue
+        for node in module.graph.nodes:
+            if node.target in (
+                triton_kernel_wrapper_functional,
+                triton_kernel_wrapper_mutation,
+            ):
+                return True
+    return False
+
+
+@dataclass
+class _VirtualizedSerializer:
+    """
+    This handles the data for serializing Virtualized.
+    """
+
+    # The values here get serialized. We don't grab everything because some of
+    # the fields can't be serialized.
+    aot_compilation: Any = None
+    choices: Any = None
+    local_buffer_context: Any = None
+    ops: Any = None
+    kernel: Any = None
+    current_node: Any = None
+
+    @classmethod
+    def serialize(cls) -> _VirtualizedSerializer:
+        """
+        Turn the current state of torch._inductor.virtualized.V into a
+        serializable structure.
+        """
+        kwargs = {}
+        for f in dataclasses.fields(cls):
+            kwargs[f.name] = getattr(V, f.name)
+        return _VirtualizedSerializer(**kwargs)
+
+    def patch(self) -> _VirtualizedSerializerContextManager:
+        """
+        Returns a context manager which patches the saved values into the
+        current environment. While patched, any value not listed above will be
+        poisoned so that reads will raise an error.
+        """
+        return _VirtualizedSerializerContextManager(self)
+
+
+class _VirtualizedSerializerContextManager(contextlib.ExitStack):
+    """
+    Helper for _VirtualizedSerializer.patch()
+    """
+
+    def __init__(self, virtualized: _VirtualizedSerializer) -> None:
+        super().__init__()
+        self.virtualized = virtualized
+
+    @override
+    def __enter__(self) -> Self:
+        super().__enter__()
+
+        for set_name in dir(V):
+            if not set_name.startswith("set_"):
+                continue
+            name = set_name[4:]
+            name = name.removesuffix("_handler")
+            set_handler = getattr(V, set_name)
+            if hasattr(self.virtualized, name):
+                value = getattr(self.virtualized, name)
+            else:
+                # poison any values that we don't serialize so that any
+                # unset accesses are caught.
+                value = torch._inductor.virtualized._PoisonedVirtual
+            self.enter_context(set_handler(value))
+
+        return self
+
+
+def _is_fallback_handler(op: object) -> bool:
+    try:
+        return op._is_fallback_handler  # type: ignore[attr-defined]
+    except AttributeError:
+        return False
+
+
+class _LoweringSerializer:
+    """
+    This handles the data for serializing lowering.lowering
+    """
+
+    # A full implementation would make sure that all lowerings are copied over
+    # (or at least detected and raise a bypass when a non-standard lowering is
+    # used). For now we just handle tests by looking for lowerings that were
+    # overridden with a forced fallback.
+    fallbacks: OrderedSet[str]
+
+    def __init__(self) -> None:
+        from . import lowering
+
+        self.fallbacks = OrderedSet(
+            str(k) for k, v in lowering.lowerings.items() if _is_fallback_handler(v)
+        )
+
+    def patch(self) -> _LoweringSerializerContextManager:
+        return _LoweringSerializerContextManager(self)
+
+
+class _LoweringSerializerContextManager(contextlib.ExitStack):
+    """
+    Helper for _LoweringSerializer.patch()
+    """
+
+    def __init__(self, lowering: _LoweringSerializer) -> None:
+        super().__init__()
+        self.lowering = lowering
+
+    @override
+    def __enter__(self) -> Self:
+        super().__enter__()
+
+        from . import lowering
+
+        for k, v in lowering.lowerings.items():
+            name = str(k)
+            if name in self.lowering.fallbacks:
+                if not _is_fallback_handler(v):
+                    self.enter_context(lowering.force_fallback(k))  # type: ignore[arg-type]
+
+        return self
+
+
+@dataclass
+class _FakeTensorModeSerializer:
+    allow_non_fake_inputs: bool
+
+    def __init__(self, fake_mode: FakeTensorMode) -> None:
+        self.allow_non_fake_inputs = fake_mode.allow_non_fake_inputs
+        self.shape_env = fake_mode.shape_env
+
+    @contextlib.contextmanager
+    def patch(self, fake_mode: FakeTensorMode) -> Generator[None, None, None]:
+        saved_allow_non_fake_inputs = fake_mode.allow_non_fake_inputs
+        fake_mode.allow_non_fake_inputs = self.allow_non_fake_inputs
+
+        yield
+
+        fake_mode.allow_non_fake_inputs = saved_allow_non_fake_inputs
+
+
+@dataclass
+class _WireProtocolInput:
+    """
+    For _SerializedFxCompile - encapsulates all the data being transferred
+    (sent) from the parent to the child.
+    """
+
+    gm: torch.fx.GraphModule
+    example_inputs: Sequence[InputType]
+    inputs_to_check: Sequence[int]
+    graph_kwargs: _CompileFxKwargs
+    tracing_context: torch._guards.TracingContext | None
+    config: dict[str, object]
+    virtualized: _VirtualizedSerializer
+    deterministic_guard_for_testing: (  # type: ignore[name-defined]  # mypy bug
+        torch.testing._internal.common_utils.DeterministicGuard | None
+    )
+    logger_state: _LoggerState
+    lowering: _LoweringSerializer
+    fake_tensor_mode: _FakeTensorModeSerializer
+
+    def serialize(self) -> _WireProtocolPickledInput:
+        """
+        Turns this object into a _WireProtocolPickledInput which can be
+        directly transferred across a stream.
+        """
+        from torch.fx._graph_pickler import GraphPickler
+
+        return _WireProtocolPickledInput(GraphPickler.dumps(self))
+
+
+def _current_fake_mode() -> FakeTensorMode:
+    fake_mode = None
+    if context := torch._guards.TracingContext.try_get():
+        fake_mode = context.fake_mode
+    if fake_mode is not None:
+        return fake_mode
+
+    shape_env = torch.fx.experimental.symbolic_shapes.ShapeEnv()
+    return FakeTensorMode(shape_env=shape_env)
+
+
+@dataclass
+class _WireProtocolPickledInput:
+    value: bytes
+
+    def deserialize(self) -> _WireProtocolInput:
+        """
+        Turn this streamable object back into a _WireProtocolInput.
+        """
+        from torch.fx._graph_pickler import GraphPickler
+
+        fake_mode = _current_fake_mode()
+        result = GraphPickler.loads(self.value, fake_mode)
+        if not isinstance(result, _WireProtocolInput):
+            raise AssertionError(f"expected _WireProtocolInput, got {type(result)}")
+        return result
+
+
+@dataclass
+class _WireProtocolOutput:
+    """
+    For _SerializedFxCompile - encapsulates all the data being transferred
+    (returned) back from the child to the parent.
+    """
+
+    graph: OutputCode
+    metrics: CachedMetricsDeltas
+    logs: list[logging.LogRecord]
+    warning_replay: list[warnings.WarningMessage] | None
+    shape_env: torch.fx.experimental.symbolic_shapes.ShapeEnv | None
+
+    def serialize(self) -> _WireProtocolPickledOutput:
+        """
+        Turns this object into a _WireProtocolPickledOutput which can be
+        directly transferred across a stream.
+        """
+        from torch.fx._graph_pickler import GraphPickler
+
+        if isinstance(self.graph, CompiledFxGraph):
+            self.graph.prepare_for_serialization()
+        return _WireProtocolPickledOutput(GraphPickler.dumps(self))
+
+
+@dataclass
+class _WireProtocolPickledOutput:
+    value: bytes
+
+    def deserialize(self, constants: CompiledFxGraphConstants) -> _WireProtocolOutput:
+        """
+        Turn this streamable object back into a _WireProtocolOutput.
+        """
+        from torch.fx._graph_pickler import GraphPickler
+
+        fake_mode = _current_fake_mode()
+        result = GraphPickler.loads(self.value, fake_mode)
+        if not isinstance(result, _WireProtocolOutput):
+            raise AssertionError(f"expected _WireProtocolOutput, got {type(result)}")
+        if isinstance(result.graph, CompiledFxGraph):
+            result.graph.after_deserialization(constants)
+        return result
+
+
+class _LoggerState:
+    """
+    This class is for tracking logging that happens during an out-of-process
+    compile so we can "replay" those messages when the compile is done. Used as
+    a context manager which returns the captured logs (object).
+    """
+
+    loggers: dict[str, int]
+    # The actual log capturing mechanism - this should be None when we're not
+    # actively capturing logs.
+    captured_logs: _CapturedLogs | None = None
+
+    def __init__(self) -> None:
+        # Mapping from logger name to level.
+        self.loggers = {}
+
+        def filter(
+            logger: logging.Logger | logging.PlaceHolder,
+        ) -> TypeGuard[logging.Logger]:
+            if not isinstance(logger, logging.Logger):
+                # Assume that Placeholders propagate
+                return False
+            # We only want to track torch._inductor logging
+            if not logger.name.startswith("torch._inductor"):
+                return False
+            # If this logger propagates then assume we'll track its parent
+            if logger.propagate:
+                return False
+            return True
+
+        root = logging.getLogger("torch._inductor")
+        if sys.version_info < (3, 12):
+            # logging.getChildren() doesn't exist until 3.12
+            logging._acquireLock()  # type: ignore[attr-defined]
+            try:
+                for logger in root.manager.loggerDict.values():
+                    if filter(logger):
+                        self.loggers[logger.name] = logger.level
+            finally:
+                logging._releaseLock()  # type: ignore[attr-defined]
+        else:
+            q = [root]
+            while q:
+                logger = q.pop()
+                if filter(logger):
+                    self.loggers[logger.name] = logger.level
+                q.extend(logger.getChildren())
+
+    def __enter__(self) -> _CapturedLogs:
+        if self.captured_logs is not None:
+            raise AssertionError("captured_logs already set on __enter__")
+        self.captured_logs = _CapturedLogs(self)
+        self.captured_logs.apply()
+        return self.captured_logs
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: types.TracebackType | None,
+    ) -> None:
+        if self.captured_logs is None:
+            raise AssertionError("captured_logs not set on __exit__")
+        self.captured_logs.remove()
+
+
+class _CapturedLogs:
+    """
+    Helper for _LoggerState - this class actually attaches to the logger in
+    the child process and grabs the log messages themselves.
+    """
+
+    state: _LoggerState
+    queue: queue.Queue[logging.LogRecord]
+    handlers: dict[str, logging.Handler] | None
+
+    def __init__(self, state: _LoggerState) -> None:
+        self.state = state
+        # A queue of the log entries
+        # TODO: For memory purposes should we log to a file and then respond with that?
+        self.queue = queue.Queue(-1)
+        # Mapping from name to handler (only valid when applied)
+        self.handlers = None
+
+    def finish(self) -> list[logging.LogRecord]:
+        if self.handlers is not None:
+            raise AssertionError("expected handlers to be None in finish")
+        logs = []
+        try:
+            while True:
+                logs.append(self.queue.get_nowait())
+        except queue.Empty:
+            pass
+        return logs
+
+    def remove(self) -> None:
+        if self.handlers is None:
+            raise AssertionError("expected handlers to be set in remove")
+        handlers, self.handlers = self.handlers, None
+        for name, handler in handlers.items():
+            logger = logging.getLogger(name)
+            logger.removeHandler(handler)
+
+    def apply(self) -> None:
+        from logging.handlers import QueueHandler
+
+        if self.handlers is not None:
+            raise AssertionError("expected handlers to be None in apply")
+        self.handlers = {}
+        for name, level in self.state.loggers.items():
+            logger = logging.getLogger(name)
+            handler = QueueHandler(self.queue)
+            self.handlers[name] = handler
+            logger.addHandler(handler)
+            if level != logging.NOTSET:
+                logger.setLevel(level)
+
+
+class _SerializedFxCompile(FxCompile):
+    """
+    This is used to represent an FxCompile which occurs across a serialized
+    boundary.
+    """
+
+    @override
+    def codegen_and_compile(
+        self,
+        gm: GraphModule,
+        example_inputs: Sequence[InputType],
+        inputs_to_check: Sequence[int],
+        graph_kwargs: _CompileFxKwargs,
+    ) -> OutputCode:
+        # If this code changes it's likely _AsyncFxCompile.codegen_and_compile()
+        # will also need to match.
+
+        serialized = self.serialize_compile(
+            gm, example_inputs, inputs_to_check, graph_kwargs
+        )
+        if not serialized:
+            eager_compile = _InProcessFxCompile()
+            eager_compile.compile_region_name = self.compile_region_name
+            return eager_compile.codegen_and_compile(
+                gm, example_inputs, inputs_to_check, graph_kwargs
+            )
+
+        inputs, constants = serialized
+        output = self._send_to_child(inputs).deserialize(constants)
+        if isinstance(output.graph, CompiledFxGraph):
+            output.graph.compile_region_name = self.compile_region_name
+
+        self._postprocess(output)
+        self._compile_stats[type(self)].codegen_and_compile += 1
+
+        # TODO: Do we need to figure out what changed in TracingContext in the
+        # child and plumb that back up to the parent?
+
+        return output.graph
+
+    def serialize_compile(
+        self,
+        gm: GraphModule,
+        example_inputs: Sequence[InputType],
+        inputs_to_check: Sequence[int],
+        graph_kwargs: _CompileFxKwargs,
+    ) -> tuple[_WireProtocolPickledInput, CompiledFxGraphConstantsWithGm] | None:
+        """
+        Prepare a _WireProtocolInput to compile. If None is returned then it
+        wasn't possible to serialize and we should fallback to in-process.
+        """
+        try:
+            # _check_for_hop raises BypassFxGraphCache when it detects something
+            # we can't cache (or serialize)
+            FxGraphCache._check_for_hop(gm)
+        except BypassFxGraphCache as e:
+            log.debug("Skipping %s compile: %s", type(self), e)
+            return None
+
+        # Triton kernel wrapper nodes contain references to the kernel_side_table
+        # which is process-local and can't be serialized across processes.
+        if _graph_contains_triton_kernel_wrappers(gm):
+            log.debug(
+                "Skipping %s compile: graph contains triton kernel wrappers", type(self)
+            )
+            return None
+
+        context = torch._guards.TracingContext.try_get()
+        constants = CompiledFxGraphConstantsWithGm(gm)
+        logger_state = _LoggerState()
+        lowering = _LoweringSerializer()
+
+        # If we're running tests then grab the DeterministicGuard (don't want to
+        # import this if it isn't already imported because it has side-effects)
+        deterministic_guard_for_testing: (  # type: ignore[name-defined]  # mypy bug
+            torch.testing._internal.common_utils.DeterministicGuard | None
+        ) = None
+        try:
+            deterministic_guard_for_testing = (
+                torch.testing._internal.common_utils.DeterministicGuard._current_state()  # type: ignore[attr-defined]  # mypy bug
+            )
+        except AttributeError:
+            pass
+
+        fake_mode = _current_fake_mode()
+        fake_tensor_mode = _FakeTensorModeSerializer(fake_mode)
+
+        from pickle import PicklingError
+
+        try:
+            input = _WireProtocolInput(
+                gm,
+                example_inputs,
+                inputs_to_check,
+                graph_kwargs,
+                context,
+                config.save_config_portable(),
+                _VirtualizedSerializer.serialize(),
+                deterministic_guard_for_testing,
+                logger_state,
+                lowering,
+                fake_tensor_mode,
+            ).serialize()
+            return (input, constants)
+        except (AttributeError, BypassFxGraphCache, PicklingError):
+            # For example: AttributeError: Can't pickle local object
+            # 'make_opaque_unary_fn.<locals>.OpaqueUnaryFn'
+
+            # TODO: scuba record about not being able to do this?
+            log.warning("Unable to pickle input graph or example inputs", exc_info=True)
+
+            return None
+
+    @abstractmethod
+    def _send_to_child(
+        self, pickled_input: _WireProtocolPickledInput
+    ) -> _WireProtocolPickledOutput:
+        # The implementation of this should transfer `input` to the child, call
+        # `_run_in_child(input)` and transfer the result back.
+        ...
+
+    def _postprocess(self, output: _WireProtocolOutput) -> None:
+        pass
+
+    @classmethod
+    def _run_in_child(
+        cls,
+        pickled_input: _WireProtocolPickledInput,
+        extra_env: Mapping[str, str | None] | None = None,
+    ) -> _WireProtocolPickledOutput:
+        metrics = CachedMetricsHelper()
+
+        with contextlib.ExitStack() as stack:
+            stack.enter_context(patch_subprocess_env(extra_env))
+
+            # Save warnings to "replay" in the parent
+            warning_replay = stack.enter_context(warnings.catch_warnings(record=True))
+
+            # TODO: Should we split the input into multiple sections where each
+            # section sets up state for the previous section? (i.e. a Config section
+            # which we decode and apply, followed by a FakeTensorMode section which
+            # we decode and apply, etc)
+            input = pickled_input.deserialize()
+
+            stack.enter_context(input.virtualized.patch())
+            stack.enter_context(input.lowering.patch())
+            stack.enter_context(config.patch(input.config))
+            captured_logs = stack.enter_context(input.logger_state)
+            if input.deterministic_guard_for_testing:
+                stack.enter_context(input.deterministic_guard_for_testing)
+            stack.enter_context(torch._guards.tracing(input.tracing_context))
+            stack.enter_context(DebugContext())
+
+            fake_mode = _current_fake_mode()
+            stack.enter_context(input.fake_tensor_mode.patch(fake_mode))
+
+            output_graph = _InProcessFxCompile().codegen_and_compile(
+                input.gm,
+                input.example_inputs,
+                input.inputs_to_check,
+                input.graph_kwargs,
+            )
+
+        logs = captured_logs.finish()
+
+        return _WireProtocolOutput(
+            output_graph,
+            metrics.get_deltas(),
+            logs,
+            warning_replay,
+            fake_mode.shape_env,
+        ).serialize()
+
+
+# This is a debugging/testing implementation of FxCompile which serializes the
+# input and output but still runs the FxCompile in-process.
+@final
+class _DebugSerdeFxCompile(_SerializedFxCompile):
+    @override
+    def _send_to_child(
+        self, pickled_input: _WireProtocolPickledInput
+    ) -> _WireProtocolPickledOutput:
+        # For debugging just serde the input and output but don't run in a
+        # subprocess.
+        return self._run_in_child(pickled_input)
+
+
+class _OutOfProcessFxCompile(_SerializedFxCompile):
+    """
+    Represents an FxCompile which is run outside the current process (in
+    either a subprocess or possibly even a separate machine).
+    """
+
+    @override
+    @final
+    def _send_to_child(
+        self, pickled_input: _WireProtocolPickledInput
+    ) -> _WireProtocolPickledOutput:
+        f = self._send_to_child_async(pickled_input)
+
+        # For debugging: If we want to print status updates...
+        # last = time.time()
+        # while not f.done():
+        #     print("tick...")
+        #     time.sleep(0.125)
+        #     now = time.time()
+        #     if now - last > 1:
+        #         last = now
+
+        return f.result()
+
+    @abstractmethod
+    def _send_to_child_async(
+        self, pickled_input: _WireProtocolPickledInput
+    ) -> Future[_WireProtocolPickledOutput]: ...
+
+    def _postprocess(self, output: _WireProtocolOutput) -> None:
+        # Since our metrics were gathered in a subprocess make sure to add them
+        # here.
+        CachedMetricsHelper.apply_deltas(output.metrics)
+
+        # This is used by tests to check the output for specific details.  For
+        # remote things (subproc and RE) we need to do the `save_output_code`
+        # here since it didn't happen earlier in-process. In the future if this
+        # doesn't have "source_code" (it's a CompiledAOTI, for example) and we
+        # need it we'll have to grab it and serialize it separately from the
+        # child.
+        if GraphLowering.save_output_code is not None:
+            GraphLowering.save_output_code(output.graph.source_code)  # type: ignore[attr-defined]
+
+        # And forward our collected logs. The cache is cleared when the outer
+        # function exits.
+        @functools.cache
+        def getLogger(name: str) -> logging.Logger:
+            return logging.getLogger(name)
+
+        if output.warning_replay:
+            for w in output.warning_replay:
+                warnings.warn_explicit(
+                    message=w.message,
+                    category=w.category,
+                    filename=w.filename,
+                    lineno=w.lineno,
+                    source=w.source,
+                )
+
+        for record in output.logs:
+            logger = getLogger(record.name)
+            logger.handle(record)
+
+
+# For debugging - create a _FxCompile which writes the serialized data to a file
+# and then exits.
+#
+# TODO: make this a FxCompileMode value?
+#
+# The "child runner" should look something like this:
+#
+#     import torch
+#     from torch._inductor import compile_fx
+#     idx = 0
+#     with open(f"/tmp/pytorch_compile_fx_tmp_input_{idx}.bin", "rb") as f:
+#         input = compile_fx._WireProtocolPickledInput(f.read())
+#     result = compile_fx._SubprocessFxCompile._run_in_child(input)
+#     with open(f"/tmp/pytorch_compile_fx_tmp_output_{idx}.bin", "wb") as f:
+#         f.write(result.value)
+#
+@final
+class _DebugFileFxCompile(_SerializedFxCompile):
+    file_index = 0
+
+    @override
+    def _send_to_child(
+        self, pickled_input: _WireProtocolPickledInput
+    ) -> _WireProtocolPickledOutput:
+        idx = _DebugFileFxCompile.file_index
+        _DebugFileFxCompile.file_index += 1
+
+        name = os.path.join(
+            tempfile.gettempdir(), f"pytorch_compile_fx_tmp_input_{idx}.bin"
+        )
+        with open(name, "wb") as f:
+            f.write(pickled_input.value)
+        print(f"Wrote to {name}")
+
+        if False:
+            name = os.path.join(
+                tempfile.gettempdir(), f"pytorch_compile_fx_tmp_actual_{idx}.bin"
+            )
+            actual = self._run_in_child(pickled_input)
+            with open(name, "wb") as f:
+                f.write(actual.value)
+            return actual
+        elif False:
+            name = os.path.join(
+                tempfile.gettempdir(), f"pytorch_compile_fx_tmp_output_{idx}.bin"
+            )
+            with open(name, "rb") as f:
+                result = _WireProtocolPickledOutput(f.read())
+                print(f"Read from {name}")
+            return result
+        else:
+            os._exit(-1)

.venv/lib/python3.12/site-packages/torch/_inductor/compile_fx_subproc.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import atexit
+import functools
+import os
+from typing import TYPE_CHECKING
+from typing_extensions import final, override
+
+import torch._inductor.async_compile
+import torch.fx
+from torch._inductor.compile_worker.subproc_pool import (
+    AnyPool,
+    SubprocKind,
+    SubprocPool,
+)
+from torch._inductor.utils import clear_caches
+
+from .compile_fx_ext import (
+    _OutOfProcessFxCompile,
+    _WireProtocolPickledInput,
+    _WireProtocolPickledOutput,
+)
+
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+    from concurrent.futures import Future
+
+
+@final
+class _SubprocessFxCompile(_OutOfProcessFxCompile):
+    @override
+    def _send_to_child_async(
+        self, input: _WireProtocolPickledInput
+    ) -> Future[_WireProtocolPickledOutput]:
+        # TODO: Do we need to copy across some kind of logging IDs? (ChromiumEventLogger)
+
+        pool = self.process_pool()
+
+        # TODO: This is probably the wrong thing to do long-term - but for now
+        # let's share the cache so we can identify tests broken by this later.
+        env_vars = ["TORCHINDUCTOR_CACHE_DIR", "TRITON_CACHE_DIR"]
+        extra_env = {v: os.environ.get(v) for v in env_vars}
+
+        return pool.submit(
+            _SubprocessFxCompile._run_in_child_subprocess, input, extra_env
+        )
+
+    @staticmethod
+    @functools.cache
+    def process_pool() -> AnyPool:
+        pool = SubprocPool(
+            # TODO: Consider raising this limit if we start using async w/
+            # subprocess and want to compile multiple graphs in parallel.
+            1,
+            kind=SubprocKind.SPAWN,
+        )
+
+        atexit.register(pool.shutdown)
+
+        return pool
+
+    @classmethod
+    def _run_in_child_subprocess(
+        cls,
+        pickled_input: _WireProtocolPickledInput,
+        extra_env: Mapping[str, str | None] | None,
+    ) -> _WireProtocolPickledOutput:
+        # TODO: In subprocess mode we need to clear the inductor caches.
+        # The problem:
+        #   1. We compile in worker A which fills stuff in tmpdir
+        #   2. parent clears inductor caches which deletes tmpdirs and tells
+        #      cpp_prefix_path() to clear its LRU cache
+        #   3. We compile a second time in subproc A - but since we never told
+        #      cpp_prefix_path() in worker A to clear its LRU it thinks the
+        #      tmpdir still exists and fails to compile.
+        #
+        # TODO: We probably should be using a separate tmpdir in the worker
+        # anyway... but we should probably still respect clear_caches()
+        # in the parent... maybe?
+        #
+        # TODO: We could be less aggressive by keeping a clock which gets
+        # incremented when we clear the cache, send the clock to the worker and
+        # only clear caches if the clock changed since last time.
+        #
+        clear_caches()
+        torch._inductor.metrics.reset()
+
+        # TODO: turn off config.fx_graph_async_compile
+
+        result = cls._run_in_child(pickled_input, extra_env)
+        return result

.venv/lib/python3.12/site-packages/torch/_inductor/compile_worker/__main__.py

@@ -0,0 +1,81 @@
+# mypy: allow-untyped-defs
+import argparse
+import base64
+import functools
+import importlib
+import logging
+import os
+import sys
+from typing import TypeVar
+
+from torch._inductor.async_compile import pre_fork_setup
+from torch._inductor.codecache import torch_key
+from torch._inductor.compile_worker.subproc_pool import (
+    SubprocKind,
+    SubprocMain,
+    SubprocPickler,
+)
+from torch._inductor.compile_worker.utils import _async_compile_initializer
+from torch._inductor.runtime.compile_tasks import _set_triton_ptxas_path
+
+
+_T = TypeVar("_T")
+
+
+log = logging.getLogger(__name__)
+
+_set_triton_ptxas_path()
+
+try:
+    import triton
+
+    if triton is None:
+        raise AssertionError("triton failed to preload in parent")
+except ImportError:
+    pass
+
+
+def _lookup_and_create_type(base: type[_T], qname: str) -> _T:
+    """
+    Given a base type and qualified name: import & lookup that name, check
+    that it's of the given type and then instantiate it.
+    """
+    pkg, name = qname.rsplit(".", 1)
+    mod = importlib.import_module(pkg)
+    ty = getattr(mod, name)
+    if not issubclass(ty, base):
+        raise TypeError(f"Type {ty} is not a subtype of {base}")
+    return ty()
+
+
+def main():
+    try:
+        parser = argparse.ArgumentParser()
+        parser.add_argument(
+            "--pickler", type=functools.partial(_lookup_and_create_type, SubprocPickler)
+        )
+        parser.add_argument("--kind", type=SubprocKind)
+        parser.add_argument("--workers", type=int)
+        parser.add_argument("--parent", type=int)
+        parser.add_argument("--read-fd", type=int)
+        parser.add_argument("--write-fd", type=int)
+        parser.add_argument("--torch-key", type=str)
+        args = parser.parse_args()
+        if os.getppid() != args.parent:
+            sys.exit(0)
+        read_fd = os.fdopen(args.read_fd, "rb")
+        write_fd = os.fdopen(args.write_fd, "wb")
+
+        pre_fork_setup()
+
+        torch_key.set(base64.b64decode(args.torch_key.encode("utf-8")))  # type: ignore[attr-defined]
+
+        _async_compile_initializer(args.parent)
+
+        SubprocMain(args.pickler, args.kind, args.workers, read_fd, write_fd).main()
+    except Exception:
+        log.exception("Uncaught exception in compile_worker subprocess")
+
+
+if __name__ == "__main__":
+    main()

.venv/lib/python3.12/site-packages/torch/_inductor/compile_worker/subproc_pool.py

@@ -0,0 +1,867 @@
+import base64
+import functools
+import itertools
+import json
+import logging
+import multiprocessing
+import os
+import pickle
+import struct
+import subprocess
+import sys
+import threading
+import time
+import traceback
+import typing
+from collections.abc import Callable
+from concurrent.futures import Future, ProcessPoolExecutor
+from concurrent.futures.process import BrokenProcessPool
+from enum import Enum, IntEnum
+from pathlib import Path
+from typing import Any, IO, TypeVar
+from typing_extensions import Never, ParamSpec
+
+# _thread_safe_fork is needed because the subprocesses in the pool can read
+# justknobs, e.g., in the Triton compiler. For internal, the import installs
+# functionality to destroy singletons before forking and re-enable them after.
+import torch._thread_safe_fork  # noqa: F401
+from torch._inductor import config
+from torch._inductor.codecache import torch_key
+from torch._inductor.compile_worker import watchdog
+from torch._inductor.compile_worker.timer import Timer
+from torch._inductor.compile_worker.tracked_process_pool import (
+    TrackedProcessPoolExecutor,
+)
+from torch._inductor.compile_worker.utils import _async_compile_initializer
+from torch._inductor.utils import get_ld_library_path, python_subprocess_env
+from torch._logging import trace_structured
+from torch._utils_internal import find_compile_subproc_binary
+from torch.monitor import _WaitCounter, _WaitCounterTracker
+
+
+log = logging.getLogger(__name__)
+
+_P = ParamSpec("_P")
+_T = TypeVar("_T")
+
+
+class MsgHeader(IntEnum):
+    ERROR = 0
+    SHUTDOWN = 1
+    QUIESCE = 2
+    WAKEUP = 3
+    JOB = 4
+    # Sidecar -> parent watchdog report about a still-running job (out-of-band,
+    # low volume). Payload is a pickled status dict; does not affect the future.
+    STATUS = 5
+
+
+def _current_compile_id() -> Any:
+    # Snapshotted at submit so a later watchdog STATUS report (handled on the
+    # read thread, which has no ambient compile context) can be attributed to the
+    # right compile in tlparse.
+    try:
+        from torch._guards import CompileContext
+
+        return CompileContext.current_compile_id()
+    except Exception:
+        return None
+
+
+def _pack_msg(msg_header: MsgHeader, job_id: int, length: int) -> bytes:
+    return struct.pack("nnn", int(msg_header), job_id, length)
+
+
+def _unpack_msg(data: bytes) -> tuple[MsgHeader, int, int]:
+    if not data:
+        return MsgHeader.ERROR, -1, -1
+    msg_header, job_id, length = struct.unpack("nnn", data)
+    return MsgHeader(msg_header), job_id, length
+
+
+msg_bytes = len(_pack_msg(MsgHeader.JOB, 0, 0))
+
+# How often the parent polls the sidecar process for liveness. The sidecar
+# dying is the only signal this catches, so a coarse interval is fine.
+_SIDECAR_HEALTH_POLL_SECONDS = 2.0
+
+# How long, in total, to let compile workers exit on SIGTERM during pool
+# teardown before escalating to SIGKILL. A worker wedged holding a lock or in a
+# C/GIL section won't honor SIGTERM, and an unbounded wait for it would stall the
+# whole shutdown.
+_WORKER_TERMINATE_GRACE_SECONDS = 10.0
+
+
+def _send_msg(
+    write_pipe: IO[bytes], msg_header: MsgHeader, job_id: int = -1, data: bytes = b""
+) -> None:
+    length = len(data)
+    write_pipe.write(_pack_msg(msg_header, job_id, length))
+    if length > 0:
+        write_pipe.write(data)
+    write_pipe.flush()
+
+
+def _recv_msg(read_pipe: IO[bytes]) -> tuple[MsgHeader, int, bytes]:
+    msg_header, job_id, length = _unpack_msg(read_pipe.read(msg_bytes))
+    data = read_pipe.read(length) if length > 0 else b""
+    return msg_header, job_id, data
+
+
+class _SubprocExceptionInfo:
+    """
+    Carries exception info from subprocesses across the wire. traceback
+    objects are not pickleable, so we store the trace as a string and
+    use it for the message in the exception thrown in the main process.
+    """
+
+    def __init__(self, details: str) -> None:
+        self.details = details
+
+
+class SubprocException(Exception):
+    """
+    Thrown when a job in a subprocess raises an Exception.
+    """
+
+    def __init__(self, details: str, name: str = "<unknown>") -> None:
+        self.details = details
+        super().__init__(
+            f"An exception occurred in a subprocess:\n\nName={name}\n{details}"
+        )
+
+    def with_name(self, name: str) -> "SubprocException":
+        return SubprocException(self.details, name)
+
+
+class SubprocPickler:
+    """
+    Allows a caller to provide a custom pickler for passing data with the
+    subprocess.
+    """
+
+    def dumps(self, obj: object) -> bytes:
+        return pickle.dumps(obj, pickle.HIGHEST_PROTOCOL)
+
+    def loads(self, data: bytes) -> object:
+        return pickle.loads(data)
+
+
+class SubprocKind(Enum):
+    FORK = "fork"
+    SPAWN = "spawn"
+
+
+class SubprocPool:
+    """
+    Mimic a concurrent.futures.ProcessPoolExecutor, but wrap it in
+    a subprocess.Popen() to try to avoid issues with forking/spawning
+    """
+
+    def __init__(
+        self,
+        nprocs: int,
+        pickler: SubprocPickler | None = None,
+        kind: SubprocKind = SubprocKind.FORK,
+        quiesce: bool = False,
+    ) -> None:
+        entry = os.path.join(os.path.dirname(__file__), "__main__.py")
+        self.pickler = pickler or SubprocPickler()
+        self.kind = kind
+
+        subproc_read_fd, write_fd = os.pipe()
+        read_fd, subproc_write_fd = os.pipe()
+        self.write_pipe = os.fdopen(write_fd, "wb")
+        self.read_pipe = os.fdopen(read_fd, "rb")
+        torch_key_str = base64.b64encode(torch_key()).decode("utf-8")
+
+        cmd = [
+            sys.executable,
+            entry,
+        ]
+        if (binary := find_compile_subproc_binary()) is not None:
+            cmd = [binary]
+
+        args = [
+            f"--pickler={self.pickler.__class__.__module__}.{self.pickler.__class__.__name__}",
+            f"--kind={self.kind.value}",
+            f"--workers={nprocs}",
+            f"--parent={os.getpid()}",
+            f"--read-fd={str(subproc_read_fd)}",
+            f"--write-fd={str(subproc_write_fd)}",
+            f"--torch-key={torch_key_str}",
+        ]
+        cmd.extend(args)
+        log_path = None
+        self.log_file = None
+
+        if config.worker_suppress_logging:
+            log_path = os.devnull
+            log.info("Suppressing compile worker output due to config")
+        else:
+            log_path = config.torchinductor_worker_logpath
+            if not log_path:
+                log_path = config.get_worker_log_path()
+
+        if log_path:
+            # pyrefly: ignore [bad-assignment]
+            self.log_file = open(log_path, "w")  # noqa:SIM115
+        # Kept so the liveness watchdog can tail worker output if the sidecar dies.
+        self.log_path = log_path
+
+        self.process = subprocess.Popen(
+            cmd,
+            env={
+                **python_subprocess_env(),
+                # Safeguard against creating a SubprocPool in the subprocess.
+                "TORCH_WARM_POOL": "0",
+                # Some internal usages need a modified LD_LIBRARY_PATH.
+                "LD_LIBRARY_PATH": get_ld_library_path(),
+            },
+            pass_fds=(subproc_read_fd, subproc_write_fd),
+            stdout=self.log_file,
+            stderr=self.log_file,
+        )
+        # The sidecar inherited these via pass_fds; the parent uses its own ends
+        # (write_pipe/read_pipe) and must drop its copies. Otherwise the parent
+        # itself keeps the result pipe's write end open, so read_pipe would never
+        # EOF even after the sidecar and all workers are gone.
+        os.close(subproc_read_fd)
+        os.close(subproc_write_fd)
+
+        self.write_lock = threading.Lock()
+        self.read_thread = threading.Thread(
+            target=self._read_thread, name="InductorSubproc", daemon=True
+        )
+        # Backstop for the sidecar dying. Closing the inherited pipe fds (in the
+        # parent above and in each worker's initializer) means a dead sidecar
+        # normally yields a clean EOF that _read_thread handles. This watchdog
+        # covers the cases where EOF does not arrive -- e.g. a stray fd copy still
+        # holding the write end open -- by detecting the dead process directly.
+        self.health_thread = threading.Thread(
+            target=self._health_monitor, name="InductorSubprocHealth", daemon=True
+        )
+
+        self.futures_lock = threading.Lock()
+        self.pending_futures: dict[int, Future[Any]] = {}
+        # Compile id captured at submit so watchdog STATUS reports (handled on the
+        # read thread) attribute to the right compile in tlparse. Keyed by job_id.
+        self._job_compile_id: dict[int, Any] = {}
+        # The pending waitcounter, is used to indicate the time when we have any specific job running.
+        self.pending_waitcounters: dict[int, Any] = {}
+        self.job_id_count = itertools.count()
+
+        # The running waitcounter indicates the time when the SubProcPool object exists.
+        self.running = True
+        self.running_waitcounter = _WaitCounter(
+            "pytorch.wait_counter.subproc_pool.running"
+        ).guard()
+        self.running_waitcounter.__enter__()
+
+        # The quiesce waitcounter indicates when the job is in a quiesced state.
+        self.quiesce_waitcounter: _WaitCounterTracker | None = None
+
+        # Firstjob is used to capture the time from when the firstjob is queued, to when the first job is done.
+        self.firstjob = True
+        self.firstjob_id: int | None = None
+        self.firstjob_waitcounter = _WaitCounter(
+            "pytorch.wait_counter.subproc_pool.first_job"
+        ).guard()
+
+        if quiesce:
+            self.timer: Timer | None = Timer(
+                config.quiesce_async_compile_time, self.quiesce
+            )
+        else:
+            self.timer = None
+
+        # Start threads last to ensure all member variables are initialized
+        # before any access.
+        self.read_thread.start()
+        self.health_thread.start()
+
+    def submit(
+        self, job_fn: Callable[_P, _T], *args: _P.args, **kwargs: _P.kwargs
+    ) -> Future[_T]:
+        if args or kwargs:
+            # pyrefly: ignore [bad-assignment]
+            job_fn = functools.partial(job_fn, *args, **kwargs)
+        job_data = self.pickler.dumps(job_fn)
+        future: Future[_T]
+        with self.futures_lock:
+            job_id = next(self.job_id_count)
+            self.pending_futures[job_id] = future = Future()
+            self._job_compile_id[job_id] = _current_compile_id()
+            self.pending_waitcounters[job_id] = _WaitCounter(
+                "pytorch.wait_counter.subproc_pool.job"
+            ).guard()
+            self.pending_waitcounters[job_id].__enter__()
+            if self.quiesce_waitcounter:
+                self.firstjob = True
+                self.quiesce_waitcounter.__exit__()
+                self.quiesce_waitcounter = None
+            # This can be entered from either quiesce wakeup, or from startup.
+            if self.firstjob:
+                self.firstjob_id = job_id
+                self.firstjob_waitcounter.__enter__()
+                self.firstjob = False
+        future.set_running_or_notify_cancel()
+        self._send(MsgHeader.JOB, job_id, job_data)
+        return future
+
+    def _send(self, msg_header: MsgHeader, job_id: int = -1, data: bytes = b"") -> None:
+        with self.write_lock:
+            if not self.running:
+                raise RuntimeError("Attempting to use a closed pool")
+            _send_msg(self.write_pipe, msg_header, job_id, data)
+
+    def _read_thread(self) -> None:
+        while True:
+            data = b""
+            job_id = -1
+            try:
+                msg_header, job_id, data = _recv_msg(self.read_pipe)
+            except Exception:
+                # Something went wrong during the read. There's no way we have a
+                # valid msg.
+                log.exception("failure in subproc_pool._recv_msg")
+                msg_header = MsgHeader.ERROR
+
+            if msg_header == MsgHeader.STATUS:
+                # Out-of-band watchdog report; does not touch futures.
+                self._handle_worker_status(job_id, data)
+                continue
+
+            if msg_header != MsgHeader.JOB:
+                # read_pipe returned None or got exception
+                if self.running:
+                    log.warning("SubprocPool unclean exit")
+                    self.running = False
+                    self.running_waitcounter.__exit__()
+                self.read_pipe.close()
+                # Cancel all the pending futures.
+                self.shutdown()
+                return
+
+            try:
+                result = self.pickler.loads(data)
+            except Exception as e:
+                # Something went wrong unpickling. We have a job_id so just
+                # notify that particular future and continue on.
+                log.exception("unpickle failure in SubprocPool._read_thread")
+                result = e
+
+            with self.futures_lock:
+                if not self.running:
+                    return
+                if self.timer:
+                    self.timer.record_call()
+                if isinstance(result, _SubprocExceptionInfo):
+                    # An exception occurred in the submitted job
+                    self.pending_futures[job_id].set_exception(
+                        SubprocException(result.details)
+                    )
+                elif isinstance(result, Exception):
+                    # An exception occurred in some of our subprocess machinery.
+                    self.pending_futures[job_id].set_exception(result)
+                else:
+                    self.pending_futures[job_id].set_result(result)
+
+                self.pending_waitcounters[job_id].__exit__()
+                del self.pending_waitcounters[job_id]
+                if self.firstjob_id == job_id:
+                    self.firstjob_waitcounter.__exit__()
+
+                del self.pending_futures[job_id]
+                self._job_compile_id.pop(job_id, None)
+
+    def _health_monitor(self) -> None:
+        # Poll the sidecar for liveness. If it dies while we still think we are
+        # running, fail the pending compiles rather than let waiters block
+        # forever (see health_thread comment in __init__).
+        while self.running:
+            returncode = self.process.poll()
+            if returncode is not None:
+                self._on_sidecar_death(returncode)
+                return
+            time.sleep(_SIDECAR_HEALTH_POLL_SECONDS)
+
+    def _on_sidecar_death(self, returncode: int) -> None:
+        with self.futures_lock:
+            if not self.running:
+                # Expected exit (shutdown) or already handled.
+                return
+            self.running = False
+        # `running` is set under different locks across shutdown()/_read_thread/
+        # here, so this exit can race another for the same transition. That's
+        # safe: _WaitCounterTracker.__exit__ is idempotent (optional::reset()).
+        self.running_waitcounter.__exit__()
+
+        pid = self.process.pid
+        log.error(
+            "Inductor compile worker sidecar (pid %s) exited unexpectedly with "
+            "code %s during compilation; failing pending compile jobs. Re-run "
+            "with TORCHINDUCTOR_COMPILE_THREADS=1 to compile in the main process.",
+            pid,
+            returncode,
+        )
+        self._log_sidecar_death_diagnostics(returncode)
+
+        exc = RuntimeError(
+            f"Inductor compile worker sidecar (pid {pid}) exited unexpectedly "
+            f"with code {returncode} during compilation. Re-run with "
+            "TORCHINDUCTOR_COMPILE_THREADS=1 to compile in the main process."
+        )
+        with self.futures_lock:
+            for job_id, future in self.pending_futures.items():
+                if not future.cancel():
+                    future.set_exception(exc)
+                waitcounter = self.pending_waitcounters.pop(job_id, None)
+                if waitcounter is not None:
+                    waitcounter.__exit__()
+            self.pending_futures.clear()
+            self._job_compile_id.clear()
+        # We intentionally do not close read_pipe here. _read_thread owns it and
+        # may be mid-read; closing a buffered pipe out from under a concurrent
+        # read can deadlock on the buffer lock. It is a daemon thread, so leaving
+        # it is harmless now that the futures are resolved -- and if the sidecar's
+        # death already produced an EOF, _read_thread will close the pipe itself.
+
+    def _log_sidecar_death_diagnostics(self, returncode: int) -> None:
+        tail = ""
+        if self.log_path and self.log_path != os.devnull:
+            try:
+                with open(self.log_path, errors="replace") as f:
+                    tail = "".join(f.readlines()[-50:])
+            except OSError:
+                pass
+        if tail:
+            log.error(
+                "Last output from compile worker sidecar (pid %s):\n%s",
+                self.process.pid,
+                tail,
+            )
+        # Surface the same info to structured tracing so production jobs (which
+        # only have tlparse access) can diagnose the crash.
+        try:
+            trace_structured(
+                "artifact",
+                metadata_fn=lambda: {
+                    "name": "compile_worker_sidecar_death",
+                    "encoding": "string",
+                },
+                payload_fn=lambda: (
+                    f"sidecar pid={self.process.pid} returncode={returncode}\n\n{tail}"
+                ),
+            )
+        except Exception:
+            log.warning("Failed to emit sidecar-death trace artifact", exc_info=True)
+
+    def _handle_worker_status(self, job_id: int, data: bytes) -> None:
+        # Best-effort, and runs on the read thread: a bad status report (corrupt
+        # payload or a logging failure) must not escape and kill result
+        # processing, so guard the whole thing.
+        try:
+            status = self.pickler.loads(data)
+            if not isinstance(status, dict):
+                return
+            compile_id = self._job_compile_id.get(job_id)
+            record = {**status, "compile_id": str(compile_id) if compile_id else None}
+            trace_structured(
+                "artifact",
+                metadata_fn=lambda: {
+                    "name": "compile_worker_status",
+                    "encoding": "json",
+                },
+                payload_fn=lambda: json.dumps(record),
+                compile_id=compile_id,
+                expect_trace_id=False,
+                suppress_context=True,
+                record_logging_overhead=False,
+            )
+        except Exception:
+            log.warning("failed to report compile worker status", exc_info=True)
+
+    def quiesce(self) -> None:
+        self._send(MsgHeader.QUIESCE)
+        if self.quiesce_waitcounter is None:
+            self.quiesce_waitcounter = _WaitCounter(
+                "pytorch.wait_counter.subproc_pool.quiesced"
+            ).guard()
+            self.quiesce_waitcounter.__enter__()
+
+    def wakeup(self) -> None:
+        self._send(MsgHeader.WAKEUP)
+
+    def shutdown(self) -> None:
+        try:
+            with self.write_lock:
+                if not self.running:
+                    return
+                if self.timer:
+                    self.timer.quit()
+                self.running = False
+                self.running_waitcounter.__exit__()
+                _send_msg(self.write_pipe, MsgHeader.SHUTDOWN)
+                self.write_pipe.close()
+            try:
+                self.process.wait(300)
+            except subprocess.TimeoutExpired:
+                # The sidecar did not exit in time (e.g. wedged tearing down its
+                # own worker pool). Don't stall the whole process; kill it and
+                # move on. TimeoutExpired is not an OSError, so it would
+                # otherwise propagate uncaught out of shutdown().
+                log.warning(
+                    "Compile worker sidecar (pid %s) did not exit within 300s; "
+                    "killing it.",
+                    self.process.pid,
+                )
+                self.process.kill()
+                self.process.wait()
+            if self.log_file:
+                self.log_file.close()
+        except OSError:
+            log.warning("Ignored OSError in pool shutdown", exc_info=True)
+        finally:
+            with self.futures_lock:
+                for future in self.pending_futures.values():
+                    if not future.cancel():
+                        future.set_exception(RuntimeError("SubprocPool closed"))
+                self.pending_futures.clear()
+                self._job_compile_id.clear()
+
+
+class SubprocMain:
+    """Communicates with a SubprocPool in the parent process, called by __main__.py"""
+
+    def __init__(
+        self,
+        pickler: SubprocPickler,
+        kind: SubprocKind,
+        nprocs: int,
+        read_pipe: IO[bytes],
+        write_pipe: IO[bytes],
+    ) -> None:
+        self.pickler = pickler
+        self.kind = kind
+        self.read_pipe = read_pipe
+        self.write_pipe = write_pipe
+        self.write_lock = threading.Lock()
+        self.nprocs = nprocs
+        self.pool: ProcessPoolExecutor | None = None
+        self.pool_finalizer: Any | None = None
+        self.running = True
+        # job_id -> monotonic submit time; scanned by the watchdog thread.
+        self._inflight: dict[int, float] = {}
+        self._inflight_lock = threading.Lock()
+        self._watchdog_stop = threading.Event()
+
+    def main(self) -> None:
+        # Phase heartbeats rely on fork inheritance of the shared buffer; spawn
+        # workers get no buffer and degrade to duration-only reporting.
+        if self.kind == SubprocKind.FORK:
+            watchdog.create(self.nprocs)
+        self._start_watchdog()
+        while True:
+            msg_header, job_id, data = _recv_msg(self.read_pipe)
+            if msg_header == MsgHeader.JOB:
+                self.submit(job_id, data)
+            elif msg_header == MsgHeader.WAKEUP:
+                self._start_pool()
+            elif msg_header == MsgHeader.QUIESCE:
+                self._quiesce()
+            else:
+                return self._shutdown()
+
+    def _quiesce(self) -> None:
+        self._shutdown_pool(terminate_workers=False)
+
+    def _shutdown(self) -> None:
+        self._watchdog_stop.set()
+        with self.write_lock:
+            self.running = False
+            try:
+                _send_msg(self.write_pipe, MsgHeader.SHUTDOWN)
+                self.write_pipe.close()
+            except BrokenPipeError:
+                pass  # parent process already shutdown
+            self.read_pipe.close()
+        self._shutdown_pool(terminate_workers=True)
+
+    def _shutdown_pool(self, *, terminate_workers: bool) -> None:
+        if self.pool is None:
+            return
+
+        pool = self.pool
+        self.pool = None
+
+        if self.pool_finalizer is not None:
+            if terminate_workers:
+                self.pool_finalizer.cancel()
+            self.pool_finalizer = None
+
+        if terminate_workers:
+            # The sidecar is exiting, so do not let ProcessPoolExecutor's
+            # interpreter finalization wait for running compiler workers.
+            _terminate_process_pool(pool)
+        else:
+            pool.shutdown(wait=False)
+
+    def submit(self, job_id: int, data: bytes) -> None:
+        # Clock starts before _start_pool/_warm_process_pool, so the first job's
+        # reported elapsed intentionally includes cold pool creation and the fork
+        # of the workers -- that wait is real and worth surfacing.
+        with self._inflight_lock:
+            self._inflight[job_id] = time.monotonic()
+        while self.running:
+            try:
+                self._submit_inner(job_id, data)
+                return
+            except BrokenProcessPool:
+                # If any subprocess in the pool crashes, we get a BrokenProcessPool
+                # exception and the whole pool becomes unusable. Handle crashes by
+                # recreating the pool and resubmitting. Log it -- this was
+                # previously silent, hiding repeated worker crashes that can stall
+                # a job in this retry loop.
+                log.warning(
+                    "Compile worker pool broke while submitting job %s; "
+                    "recreating the pool and retrying.",
+                    job_id,
+                    exc_info=True,
+                )
+                self.pool = None
+
+    def _submit_inner(self, job_id: int, data: bytes) -> None:
+        def callback(fut: Future[Any]) -> None:
+            with self._inflight_lock:
+                self._inflight.pop(job_id, None)
+            if not self.running:
+                return
+            try:
+                result = fut.result()
+            except Exception as e:
+                log.exception("Error in subprocess")
+                result = self.pickler.dumps(e)
+            if not isinstance(result, bytes):
+                raise AssertionError(f"Expected bytes result, got {type(result)}")
+            with self.write_lock:
+                if self.running:
+                    _send_msg(self.write_pipe, MsgHeader.JOB, job_id, result)
+            return
+
+        self._start_pool()
+        if self.pool is None:
+            raise AssertionError("pool must be initialized before submitting jobs")
+
+        future = self.pool.submit(
+            functools.partial(SubprocMain.do_job, self.pickler, job_id, data)
+        )
+        future.add_done_callback(callback)
+
+    def _start_pool(self) -> None:
+        if self.pool is not None:
+            return
+
+        # Recycle heartbeat slots before the new worker generation forks.
+        watchdog.reset()
+
+        # Only fork workers inherit the sidecar<->parent pipe fds and must close
+        # them (see _async_compile_initializer). Under spawn the workers do not
+        # inherit them (close_fds=True + O_CLOEXEC), and these integers would
+        # refer to unrelated fds the fresh interpreter reused -- closing them
+        # would be silent corruption, not a no-op.
+        close_fds = (
+            (self.read_pipe.fileno(), self.write_pipe.fileno())
+            if self.kind == SubprocKind.FORK
+            else ()
+        )
+        self.pool = TrackedProcessPoolExecutor(
+            self.nprocs,
+            mp_context=multiprocessing.get_context(self.kind.value),
+            initializer=functools.partial(
+                _async_compile_initializer, os.getpid(), close_fds
+            ),
+        )
+        self.pool_finalizer = multiprocessing.util.Finalize(
+            None, self.pool.shutdown, exitpriority=sys.maxsize
+        )
+        _warm_process_pool(self.pool, self.nprocs)
+
+    def _start_watchdog(self) -> None:
+        interval = config.compile_worker_watchdog_interval_seconds
+        if interval <= 0:
+            return
+        threading.Thread(
+            target=self._watchdog_loop,
+            args=(interval,),
+            name="InductorSubprocWatchdog",
+            daemon=True,
+        ).start()
+
+    def _watchdog_loop(self, interval: float) -> None:
+        # Every `interval` seconds, report any job still running past `interval`
+        # so a stuck/slow worker leaves a breadcrumb (the parent turns these into
+        # tlparse artifacts). Re-reports each tick with a growing elapsed time.
+        while not self._watchdog_stop.wait(interval):
+            now = time.monotonic()
+            now_ns = time.monotonic_ns()
+            heartbeats = watchdog.read_heartbeats()
+            with self._inflight_lock:
+                slow = [
+                    (job_id, elapsed)
+                    for job_id, start in self._inflight.items()
+                    if (elapsed := now - start) >= interval
+                ]
+            for job_id, elapsed in slow:
+                self._report_status(job_id, elapsed, heartbeats.get(job_id), now_ns)
+
+    def _report_status(
+        self,
+        job_id: int,
+        elapsed: float,
+        heartbeat: tuple[int, int, int] | None,
+        now_ns: int,
+    ) -> None:
+        status: dict[str, Any] = {"job_id": job_id, "elapsed_s": round(elapsed, 1)}
+        if heartbeat is not None:
+            phase, phase_start_ns, worker_pid = heartbeat
+            status["phase"] = watchdog.Phase(phase).name.lower()
+            status["phase_elapsed_s"] = round((now_ns - phase_start_ns) / 1e9, 1)
+            status["worker_pid"] = worker_pid
+        elif watchdog.enabled():
+            # Heartbeats are active but this job isn't in any worker's slot. Almost
+            # always that means it's still queued in the pool -- a running (fork)
+            # worker stamps its slot before doing anything. It can also briefly
+            # mean the opposite: a job that just finished (clear_current_job ran in
+            # do_job's finally) but hasn't yet been popped from _inflight by the
+            # sidecar callback. That window is negligibly short, so we don't
+            # distinguish it.
+            status["phase"] = "queued"
+        # Otherwise phase tracking is unavailable (e.g. a spawn pool) and the
+        # report carries duration only -- we can't tell queued from running.
+        payload = self.pickler.dumps(status)
+        try:
+            with self.write_lock:
+                if self.running:
+                    _send_msg(self.write_pipe, MsgHeader.STATUS, job_id, payload)
+        except (OSError, ValueError):
+            # Parent gone / pipe closed; the watchdog is best-effort.
+            pass
+
+    @staticmethod
+    def do_job(pickler: SubprocPickler, job_id: int, data: bytes) -> bytes:
+        # do the pickle/unpickle in the sub-subproc
+        watchdog.set_current_job(job_id)
+        try:
+            job = typing.cast(Callable[[], object], pickler.loads(data))
+            try:
+                result = job()
+            except Exception:
+                result = _SubprocExceptionInfo(traceback.format_exc())
+            return pickler.dumps(result)
+        finally:
+            watchdog.clear_current_job()
+
+
+AnyPool = ProcessPoolExecutor | SubprocPool
+
+
+def _get_process_pool_processes(pool: ProcessPoolExecutor) -> list[Any]:
+    processes = getattr(pool, "_processes", None)
+    if processes is not None:
+        return list(processes.values())
+
+    manager_thread = getattr(pool, "_executor_manager_thread", None)
+    manager_processes = getattr(manager_thread, "processes", None)
+    if manager_processes is not None:
+        return list(manager_processes.values())
+
+    return []
+
+
+def _terminate_process_pool(pool: ProcessPoolExecutor) -> None:
+    processes = _get_process_pool_processes(pool)
+    for process in processes:
+        try:
+            if process.is_alive():
+                process.terminate()
+        except (OSError, ValueError):
+            log.warning("Ignored error terminating compile worker", exc_info=True)
+
+    # Give workers a bounded, shared grace period to exit on the SIGTERM above,
+    # then SIGKILL any that are wedged. Without this the pool.shutdown(wait=True)
+    # below can block on an unreaped worker until the parent's shutdown wait
+    # gives up (a ~300s stall).
+    deadline = time.time() + _WORKER_TERMINATE_GRACE_SECONDS
+    for process in processes:
+        try:
+            remaining = deadline - time.time()
+            if remaining > 0:
+                process.join(remaining)
+            if process.is_alive():
+                process.kill()
+        except (OSError, ValueError, AssertionError):
+            log.warning("Ignored error killing compile worker", exc_info=True)
+
+    try:
+        pool.shutdown(wait=True, cancel_futures=True)
+    except Exception:
+        log.warning("Ignored error shutting down compile worker pool", exc_info=True)
+
+
+def _warm_process_pool(pool: ProcessPoolExecutor, n: int) -> None:
+    # We have to fork processes for compiler workers, but the more memory and other resources that are loaded, the
+    # slower the os.fork time is, quite drastically. It also holds the GIL so we can't put it on another thread.
+
+    # Examples:
+    # A simple x + x + x script: 10ms seconds in the middle of the program, 2ms at startup
+    # tf_efficientnet_b0 benchmark: 50ms! in the middle of the program , 3ms at startup
+
+    # So we want to start the workers early when it is still cheap, and also to allow the workers to get
+    # ready before we have work for them.
+
+    # ProcessPoolExecutor also does not launch the workers until it finds a point when all the workers are idle.
+    # But if we waited until then fork time will be long and we will be waiting for the processes to initialize.
+
+    # We force them to start here with some YOLOing of the internal methods.
+
+    if hasattr(pool, "_start_queue_management_thread"):
+        pool._start_queue_management_thread()
+    else:
+        for _ in range(n):
+            pool._adjust_process_count()
+        if hasattr(pool, "_start_executor_manager_thread"):
+            pool._start_executor_manager_thread()
+
+
+class TestException(RuntimeError):
+    pass
+
+
+def raise_testexc() -> Never:
+    raise TestException
+
+
+def _test_signal_then_sleep(signal_path: str, seconds: float) -> None:
+    # Test helper: announce that this worker has begun executing by creating
+    # signal_path, then block. Lets a test wait until a job is actually running
+    # in a worker before acting on the pool (e.g. shutting it down).
+    Path(signal_path).touch()
+    time.sleep(seconds)
+
+
+def _ignore_sigterm_and_sleep_for_test() -> None:
+    # Test helper: a compile worker that ignores SIGTERM and blocks, forcing pool
+    # teardown to escalate to SIGKILL instead of stalling on a graceful shutdown.
+    import signal
+
+    signal.signal(signal.SIGTERM, signal.SIG_IGN)
+    while True:
+        time.sleep(3600)
+
+
+def _report_phase_and_sleep_for_test(phase: int, seconds: float) -> None:
+    # Test helper: report a heartbeat phase from a worker, then block, so the
+    # sidecar watchdog observes and reports that phase.
+    watchdog.report_phase(watchdog.Phase(phase))
+    time.sleep(seconds)

.venv/lib/python3.12/site-packages/torch/_inductor/compile_worker/timer.py

@@ -0,0 +1,55 @@
+from collections.abc import Callable
+from threading import Lock, Thread
+from time import monotonic, sleep
+
+
+class Timer:
+    """
+    This measures how long we have gone since last receiving an event and if it is greater than a set interval, calls a function.
+    """
+
+    def __init__(
+        self,
+        duration: int | float,  # Duration in seconds
+        call: Callable[[], None],  # Function to call when we expire
+    ) -> None:
+        # We don't start the background thread until we actually get an event.
+        self.background_thread: Thread | None = None
+        self.last_called: float | None = None
+        self.duration = duration
+        self.sleep_time = duration / 2
+        self.call = call
+        self.exit = False
+
+        self.lock = Lock()
+
+    def record_call(self) -> None:
+        with self.lock:
+            if self.background_thread is None:
+                self.background_thread = Thread(
+                    target=self.check, daemon=True, name="subproc_worker_timer"
+                )
+                self.background_thread.start()
+            self.last_called = monotonic()
+
+    def quit(self) -> None:
+        with self.lock:
+            self.exit = True
+
+    def check(self) -> None:
+        while True:
+            # We have to be sensitive on checking here, to avoid too much impact on cpu
+            sleep(self.sleep_time)
+            with self.lock:
+                if self.exit:
+                    return
+                if self.last_called is None:
+                    raise AssertionError("last_called must be set before timer check")
+                if self.last_called + self.duration >= monotonic():
+                    continue
+                self.last_called = None
+                self.background_thread = None
+
+            # Releasing lock in case self.call() takes a very long time or is reentrant
+            self.call()
+            return

.venv/lib/python3.12/site-packages/torch/_inductor/compile_worker/tracked_process_pool.py

@@ -0,0 +1,113 @@
+import atexit
+import concurrent
+import dataclasses
+import logging
+import threading
+from collections.abc import Callable
+from concurrent.futures import Future, ProcessPoolExecutor
+from dataclasses import dataclass
+from multiprocessing.context import BaseContext
+from time import time
+from typing import Any, TypeVar
+from typing_extensions import ParamSpec
+
+# _thread_safe_fork is needed because the subprocesses in the pool can read
+# justknobs, e.g., in the Triton compiler. For internal, the import installs
+# functionality to destroy singletons before forking and re-enable them after.
+import torch._thread_safe_fork  # noqa: F401
+
+
+_P = ParamSpec("_P")
+_R = TypeVar("_R")
+
+
+log = logging.getLogger(__name__)
+
+
+@dataclass
+class _QueueStats:
+    # Mapping from id(future) -> start time
+    pending: dict[int, float] = dataclasses.field(default_factory=dict)
+    timing: list[float] = dataclasses.field(default_factory=list)
+    enqueue_count: int = 0
+    dequeue_count: int = 0
+    max_queue_depth: int = 0
+    pool_count: int = 0
+
+
+# The queue statistics tracked by TrackedProcessPoolExecutor. Always grab
+# _queue_stats_lock before touching.
+_queue_stats = _QueueStats()
+_queue_stats_lock = threading.Lock()
+
+
+class TrackedProcessPoolExecutor(ProcessPoolExecutor):
+    def __init__(
+        self,
+        max_workers: int | None = None,
+        mp_context: BaseContext | None = None,
+        initializer: Callable[[], object] | None = None,
+    ) -> None:
+        with _queue_stats_lock:
+            _queue_stats.pool_count += 1
+        super().__init__(max_workers, mp_context, initializer)
+
+    def _record_dequeue(self, f: Future[Any]) -> None:
+        now = time()
+        with _queue_stats_lock:
+            stats = _queue_stats
+            if (start_time := stats.pending.pop(id(f), None)) is None:
+                return
+            stats.dequeue_count += 1
+            duration = now - start_time
+            stats.timing.append(duration)
+
+    def _record_enqueue(self, f: Future[Any]) -> None:
+        # Monkeypatch the set_running_or_notify_cancel so we can track when the Future moves out of PENDING.
+        saved_running_or_notify_cancel = f.set_running_or_notify_cancel
+
+        def set_running_or_notify_cancel() -> Any:
+            self._record_dequeue(f)
+            return saved_running_or_notify_cancel()
+
+        now = time()
+        with _queue_stats_lock:
+            stats = _queue_stats
+            stats.pending[id(f)] = now
+            stats.enqueue_count += 1
+            stats.max_queue_depth = max(stats.max_queue_depth, len(stats.pending))
+            f.set_running_or_notify_cancel = set_running_or_notify_cancel  # type: ignore[method-assign]
+
+        if f._state != concurrent.futures._base.PENDING:
+            self._record_dequeue(f)
+
+    def submit(
+        self, fn: Callable[_P, _R], /, *args: _P.args, **kwargs: _P.kwargs
+    ) -> Future[_R]:
+        # pyrefly: ignore [bad-argument-type]
+        f = super().submit(fn, *args, **kwargs)
+        self._record_enqueue(f)
+        return f
+
+
+@atexit.register
+def _queue_stats_report() -> None:
+    stats = _queue_stats
+    if stats.pool_count == 0:
+        return
+
+    timing = stats.timing
+    timing.sort()
+
+    log.info("AsyncCompile Metrics:")
+    log.info("  Pools %s", stats.pool_count)
+    log.info(
+        "  Items %d enqueued / %d dequeued", stats.enqueue_count, stats.dequeue_count
+    )
+    log.info("  Max Queue Depth: %d", stats.max_queue_depth)
+    n = len(timing)
+    if n > 0:
+        log.info("  Longest queue time: %0.2fs", timing[-1])
+        log.info("  P50: %0.2fs", timing[n // 2])
+        if n >= 20:
+            log.info("  P95: %0.2fs", timing[n * 95 // 100])

.venv/lib/python3.12/site-packages/torch/_inductor/compile_worker/utils.py

@@ -0,0 +1,72 @@
+import os
+import signal
+from threading import Thread
+from time import sleep
+
+from torch._inductor.compile_worker import watchdog
+
+
+_IN_TOPLEVEL_PROCESS = True
+
+
+def in_toplevel_process() -> bool:
+    global _IN_TOPLEVEL_PROCESS
+    return _IN_TOPLEVEL_PROCESS
+
+
+# If this process dies abnormally (e.g. segfault)
+# it will not shut down the workers. Instead,
+# the workers will have their parent reassigned to the
+# init process. This launches a separate thread to
+# watch for the worker getting reassigned,
+# and cleans it up in this case.
+#
+# This function cannot be an inner function since otherwise mp_context="spawn" would
+# not work for ProcessPoolExecutor since inner functions cannot be pickled.
+def _async_compile_initializer(orig_ppid: int, close_fds: tuple[int, ...] = ()) -> None:
+    # In fork mode a worker inherits the sidecar's entire fd table, including the
+    # sidecar<->parent pipes. The worker must not keep those open: holding the
+    # result pipe's write end would stop the parent from ever seeing EOF when the
+    # sidecar dies. The caller only passes these fds under fork; under spawn the
+    # worker doesn't inherit them and the same integers would name unrelated fds
+    # the fresh interpreter reused, so closing them there would be silent
+    # corruption (the OSError guard wouldn't catch it) rather than a no-op.
+    for fd in close_fds:
+        try:
+            os.close(fd)
+        except OSError:
+            pass
+
+    import torch._C
+
+    def run() -> None:
+        while True:
+            sleep(60)
+            if orig_ppid != os.getppid():
+                os.kill(os.getpid(), signal.SIGKILL)
+
+    global _watchdog_thread, _original_parent
+    _original_parent = orig_ppid
+    _watchdog_thread = Thread(target=run, daemon=True)
+    _watchdog_thread.start()
+    # Ignore Ctrl-C (i.e. SIGINT) sent to pool workers to avoid meaningless log spam.
+    signal.signal(signal.SIGINT, signal.SIG_IGN)
+
+    # Install a crash handler to print out the stacktrace for SEGV
+    torch._C._initCrashHandler()
+
+    # Set a bit to distinguish async_compile subprocesses from the toplevel process.
+    global _IN_TOPLEVEL_PROCESS
+    _IN_TOPLEVEL_PROCESS = False
+
+    # Claim a heartbeat slot so the sidecar watchdog can report this worker's
+    # compile phase (no-op unless the sidecar allocated the shared buffer).
+    watchdog.init_worker_slot()
+
+
+_watchdog_thread: Thread | None = None
+_original_parent: int | None = None
+
+
+def has_parent_changed() -> bool:
+    return _original_parent != os.getppid()

.venv/lib/python3.12/site-packages/torch/_inductor/compile_worker/watchdog.py

@@ -0,0 +1,149 @@
+"""Shared-memory heartbeat so the compile-worker sidecar's watchdog can report
+which phase a slow/stuck worker is in (see SubprocMain._watchdog_loop).
+
+A single multiprocessing.Array is allocated in the sidecar (create()) before it
+forks its worker pool; every forked worker inherits the same buffer and writes
+only its own slot -- single writer per slot, so no lock is needed there and a
+rare torn read is harmless for a coarse once-a-minute diagnostic. The sidecar's
+watchdog thread reads all slots.
+
+Slots are recycled off the pool's lifecycle rather than by polling worker
+liveness: the sidecar calls reset() every time it (re)builds the worker pool,
+and workers then claim slots 0..nprocs-1 with a per-generation counter. A worker
+death tears down and rebuilds the whole pool (ProcessPoolExecutor's behavior), so
+reset() runs before the replacement generation forks and there is never more than
+one live worker per slot. (If the pool were ever configured to replace workers
+individually -- e.g. max_tasks_per_child -- a replacement would simply run out of
+counter and report nothing, rather than collide with a live worker's slot.)
+
+Everything is a no-op unless the sidecar allocated the buffer and the worker
+claimed a slot, so the report_phase() calls sprinkled through the compile path
+are free in the main process and in non-forking pools (spawn workers do not
+inherit the buffer and simply degrade to duration-only reporting).
+"""
+
+from __future__ import annotations
+
+import multiprocessing
+import os
+import time
+from enum import IntEnum
+from typing import Any
+
+
+class Phase(IntEnum):
+    # Persisted as ints in the shared buffer; append new phases, don't renumber.
+    RUNNING = 0
+    QUERYING_CACHE = 1
+    COMPILING = 2
+
+
+# Per-slot layout: _FIELDS longs.
+_FIELDS = 4
+_F_JOB_ID = 0
+_F_PHASE = 1
+_F_PHASE_START_NS = 2
+_F_PID = 3
+_EMPTY = -1  # job_id sentinel for an idle slot
+
+# Allocated in the sidecar (create) before forking; inherited by fork workers.
+# _counter's lock also serializes slot claims and reset().
+_heartbeat: Any | None = None
+_counter: Any | None = None
+_nprocs: int = 0
+# Claimed post-fork by each worker (init_worker_slot).
+_slot: int | None = None
+
+
+def create(nprocs: int) -> None:
+    """Sidecar: allocate the shared buffer before forking the worker pool."""
+    global _heartbeat, _counter, _nprocs
+    ctx = multiprocessing.get_context("fork")
+    _nprocs = nprocs
+    _counter = ctx.Value("i", 0)
+    buf = ctx.Array("q", nprocs * _FIELDS, lock=False)
+    for s in range(nprocs):
+        buf[s * _FIELDS + _F_JOB_ID] = _EMPTY
+    _heartbeat = buf
+
+
+def reset() -> None:
+    """Sidecar: recycle all slots for a fresh worker generation. Call before
+    (re)building the worker pool so the new workers claim clean slots 0..n-1."""
+    if _heartbeat is None or _counter is None:
+        return
+    with _counter.get_lock():
+        _counter.value = 0
+        for s in range(_nprocs):
+            base = s * _FIELDS
+            _heartbeat[base + _F_JOB_ID] = _EMPTY
+            _heartbeat[base + _F_PID] = 0
+
+
+def init_worker_slot() -> None:
+    """Worker: claim this generation's next slot. No-op if the sidecar didn't
+    allocate a buffer (main process / spawn pools)."""
+    global _slot
+    if _heartbeat is None or _counter is None or _nprocs <= 0:
+        return
+    with _counter.get_lock():
+        slot = _counter.value
+        _counter.value = slot + 1
+    # Only the first nprocs workers of a generation get a slot; any beyond that
+    # (which shouldn't happen without per-worker replacement) report nothing.
+    if slot < _nprocs:
+        _slot = slot
+        _heartbeat[slot * _FIELDS + _F_PID] = os.getpid()
+
+
+def set_current_job(job_id: int) -> None:
+    """Worker: mark the start of a job in this worker's slot."""
+    if _heartbeat is None or _slot is None:
+        return
+    base = _slot * _FIELDS
+    _heartbeat[base + _F_PHASE] = int(Phase.RUNNING)
+    _heartbeat[base + _F_PHASE_START_NS] = time.monotonic_ns()
+    # Written last so a concurrent reader sees a fully-populated slot or none.
+    _heartbeat[base + _F_JOB_ID] = job_id
+
+
+def report_phase(phase: Phase) -> None:
+    """Worker: record the phase this worker just entered."""
+    if _heartbeat is None or _slot is None:
+        return
+    base = _slot * _FIELDS
+    _heartbeat[base + _F_PHASE_START_NS] = time.monotonic_ns()
+    _heartbeat[base + _F_PHASE] = int(phase)
+
+
+def clear_current_job() -> None:
+    """Worker: mark this slot idle when its job finishes."""
+    if _heartbeat is None or _slot is None:
+        return
+    _heartbeat[_slot * _FIELDS + _F_JOB_ID] = _EMPTY
+
+
+def enabled() -> bool:
+    """Sidecar: whether phase heartbeats are active (fork pools only)."""
+    return _heartbeat is not None
+
+
+def read_heartbeats() -> dict[int, tuple[int, int, int]]:
+    """Sidecar: job_id -> (phase, phase_start_ns, pid) for currently-busy slots.
+
+    phase_start_ns is worker monotonic_ns; on Linux CLOCK_MONOTONIC is
+    system-wide so the sidecar can diff it against its own monotonic_ns.
+    """
+    if _heartbeat is None:
+        return {}
+    out: dict[int, tuple[int, int, int]] = {}
+    for s in range(_nprocs):
+        base = s * _FIELDS
+        job_id = _heartbeat[base + _F_JOB_ID]
+        if job_id != _EMPTY:
+            out[job_id] = (
+                _heartbeat[base + _F_PHASE],
+                _heartbeat[base + _F_PHASE_START_NS],
+                _heartbeat[base + _F_PID],
+            )
+    return out

.venv/lib/python3.12/site-packages/torch/_inductor/compiler_bisector.py

@@ -0,0 +1,833 @@
+import atexit
+import collections
+import dataclasses
+import functools
+import os
+import shutil
+import sys
+import tempfile
+from collections.abc import Callable
+from dataclasses import dataclass, field
+
+from torch._inductor.runtime.cache_dir_utils import cache_dir
+
+
+# Set the subdirectory name
+SUBDIR_NAME = "bisect"
+
+
+@dataclass
+class Subsystem:
+    name: str
+
+
+@dataclass
+class BisectSubsystem(Subsystem):
+    pass
+
+
+@dataclass
+class BinarySubsystem(Subsystem):
+    pass
+
+
+@dataclass
+class ConfigChange(BinarySubsystem):
+    name: str = field(init=False)
+    config_name: str
+    config_field: str
+    config_value: object
+
+    def __post_init__(self) -> None:
+        self.name = f"{self.config_name}_{self.config_field}"
+
+
+# Dictionary of backend -> subsystems
+BACKENDS: dict[str, list[Subsystem]] = {
+    # run dynamo without aot_autograd
+    "eager": [],
+    # run dynamo with aot_autograd, but no partitioner or decomps
+    "aot_eager": [],
+    # run dynamo with aot autograd, decompositions and partitioner
+    "aot_eager_decomp_partition": [
+        ConfigChange("aot_eager_decomp_partition", "cse", False),
+        BisectSubsystem(
+            "decomposition"
+        ),  # number of decompositions we apply in tracing
+    ],  # TODO - add cse ?
+    # applies CrossRefFakeMode on invocation
+    "aot_eager_decomp_partition_crossref": [],
+    "inductor": [
+        BisectSubsystem("pre_grad_passes"),  # passes applied on pre-grad IR
+        BisectSubsystem("joint_graph_passes"),  # passes applied on joint graph
+        BisectSubsystem(
+            "post_grad_passes"
+        ),  # passes applied individually on forward, and backward in inductor
+        ConfigChange("inductor", "fallback_random", True),
+        ConfigChange("inductor", "emulate_precision_casts", True),
+        ConfigChange("inductor", "layout_optimization", False),
+        ConfigChange("inductor", "comprehensive_padding", False),
+        BisectSubsystem("cudagraphs"),  # cudagraph wrapping of compiled graphs
+        BisectSubsystem("lowerings"),  # lowering aten operators to inductor
+    ],  # TODO - add more - fusions ?
+}
+
+subsystem_call_counter: dict[str, int] = collections.Counter()
+
+
+@functools.cache
+def get_env_val(env_str: str) -> str | None:
+    return os.environ.get(env_str, None)
+
+
+@dataclasses.dataclass
+class BisectionResult:
+    """
+    backend: torch.compile backend responsible for failure
+    subsystem: optional, registered component identified for failure
+    bisect_number: optional, number of times the subsystem needed to be applied to trigger failure
+    debug_info: associated info of the triggering bisect application of subsystem
+    """
+
+    backend: str
+    subsystem: str | None = None
+    bisect_number: int | None = None
+    debug_info: str | None = None
+
+
+class CompilerBisector:
+    """
+    This class iteratively runs torch.compile backends (eager, aot_eager, inductor) to find the
+    first backend that can repro an issue.
+
+    Once it discovers the offending backend it will iteratively disable subsystems within the backend.
+    For subsystems which are applied repeatedly, such as the number of post grad passes or number
+    of lowering of nodes to inductor ir, it will bisect to find the offending application.
+
+    The idiomatic way to run it is with `do_bisect`. You can also use it by setting the env flags
+    `TORCH_BISECT_BACKEND`, `TORCH_BISECT_SUBSYSTEM` and `TORCH_BISECT_MAX`.
+
+    It also supports a CLI interface:
+
+        python -m torch._inductor.compiler_bisector start
+        python -m torch._inductor.compiler_bisector good
+        python -m torch._inductor.compiler_bisector bad
+        python -m torch._inductor.compiler_bisector end
+
+    Or use `run` to automatically bisect by running a command repeatedly:
+
+        python -m torch._inductor.compiler_bisector run <command>
+
+    The command's exit code determines the result: 0 = good, non-zero = bad.
+    The TORCH_COMPILE_BACKEND env var is set to the backend being tested.
+    """
+
+    bisection_enabled: bool = False
+
+    in_process_cache: str | None = None
+
+    @classmethod
+    def clear_call_counter_debug_info(
+        cls, backend_name: str, subsystem_name: str
+    ) -> None:
+        file_path = os.path.join(
+            cls.get_dir(),
+            backend_name,
+            f"{subsystem_name}_call_counter_debug_info.txt",
+        )
+        cls.write_lines_to_file(file_path, [])
+
+    @classmethod
+    def reset_counters(cls) -> None:
+        subsystem_call_counter.clear()
+        for backend, subsystem_list in BACKENDS.items():
+            for subsystem in subsystem_list:
+                if isinstance(subsystem, BisectSubsystem):
+                    cls.clear_call_counter_debug_info(backend, subsystem.name)
+
+    @classmethod
+    def get_dir(cls) -> str:
+        return f"{cache_dir() if not cls.in_process_cache else cls.in_process_cache}/{SUBDIR_NAME}"
+
+    @classmethod
+    def write_lines_to_file(
+        cls, file_path: str, lines: list[str], *, append: bool = False
+    ) -> None:
+        os.makedirs(os.path.dirname(file_path), exist_ok=True)
+        with open(file_path, "a" if append else "w") as file:
+            file.writelines(lines)
+
+    @classmethod
+    def read_lines_from_file(cls, file_path: str) -> list[str]:
+        if os.path.exists(file_path):
+            with open(file_path) as file:
+                return file.readlines()
+        return []
+
+    @classmethod
+    def update_run_state(
+        cls, backend_name: str, subsystem: Subsystem, run_state: str
+    ) -> None:
+        file_path = os.path.join(
+            cls.get_dir(), backend_name, f"{subsystem.name}_run_state.txt"
+        )
+        if isinstance(subsystem, ConfigChange):
+            if run_state != "test_disable":
+                raise AssertionError(
+                    f"expected run_state == 'test_disable', got {run_state}"
+                )
+            cls.set_config_values(
+                backend_name,
+                subsystem.name,
+                {subsystem.config_field: subsystem.config_value},
+            )
+
+        cls.write_lines_to_file(file_path, [run_state])
+
+    @classmethod
+    def set_config_values(
+        cls, backend: str, subsystem: str, config_data: dict[str, object]
+    ) -> None:
+        file_path = os.path.join(cls.get_dir(), backend, f"{subsystem}_config.txt")
+        lines = [f"{k}={v}\n" for k, v in config_data.items()]
+        cls.write_lines_to_file(file_path, lines)
+
+    @classmethod
+    def update_bisect_status(cls, backend_name: str, subsystem_name: str) -> None:
+        if not isinstance(subsystem_name, str):
+            raise AssertionError(
+                f"expected subsystem_name to be str, got {type(subsystem_name)}"
+            )
+        file_path = os.path.join(cls.get_dir(), "bisect_status.txt")
+        lines = [f"backend={backend_name}\n", f"subsystem={subsystem_name}\n"]
+        cls.write_lines_to_file(file_path, lines)
+
+    @classmethod
+    def update_bisect_range(
+        cls, backend_name: str, subsystem_name: str, low: int, high: int
+    ) -> None:
+        if not isinstance(subsystem_name, str):
+            raise AssertionError(
+                f"expected subsystem_name to be str, got {type(subsystem_name)}"
+            )
+        file_path = os.path.join(
+            cls.get_dir(), backend_name, f"{subsystem_name}_bisect_range.txt"
+        )
+        lines = [f"low={low}\n", f"high={high}\n"]
+        cls.write_lines_to_file(file_path, lines)
+
+    @classmethod
+    def add_call_counter_debug_info(
+        cls, backend_name: str, subsystem_name: str, call_counter: int, debug_info: str
+    ) -> None:
+        file_path = os.path.join(
+            cls.get_dir(), backend_name, f"{subsystem_name}_call_counter_debug_info.txt"
+        )
+        # This is only called for the last ~2 items in a bisect, so writing duplicate
+        # lines does not have performance implications later.
+        lines = [f"{call_counter}={debug_info}\n"]
+        cls.write_lines_to_file(file_path, lines, append=True)
+
+    @classmethod
+    def get_call_counter_debug_info(
+        cls, backend_name: str, subsystem_name: str, call_counter: int
+    ) -> str | None:
+        file_path = os.path.join(
+            cls.get_dir(), backend_name, f"{subsystem_name}_call_counter_debug_info.txt"
+        )
+        call_counter_str = str(call_counter)
+        for line in reversed(cls.read_lines_from_file(file_path)):
+            counter, _, debug_info = line.strip().partition("=")
+            if counter == call_counter_str:
+                return debug_info
+        return None
+
+    @classmethod
+    def get_backend(cls) -> str | None:
+        """
+        Returns the active backend, if any
+        """
+        if val := get_env_val("TORCH_BISECT_BACKEND"):
+            return val
+
+        file_path = os.path.join(cls.get_dir(), "bisect_status.txt")
+        lines = cls.read_lines_from_file(file_path)
+        for line in lines:
+            if line.startswith("backend="):
+                return line.strip().split("=")[1]
+        return None
+
+    @classmethod
+    def get_subsystem(cls) -> str | None:
+        """
+        Returns the active subsystem, if any
+        """
+
+        if val := get_env_val("TORCH_BISECT_SUBSYSTEM"):
+            return val
+
+        file_path = os.path.join(cls.get_dir(), "bisect_status.txt")
+        lines = cls.read_lines_from_file(file_path)
+        for line in lines:
+            if line.startswith("subsystem="):
+                out = line.strip().split("=")[1]
+                return out or None
+        return None
+
+    @classmethod
+    def get_subsystem_object(cls, backend_name: str, subsystem_name: str) -> Subsystem:
+        return next(obj for obj in BACKENDS[backend_name] if obj.name == subsystem_name)
+
+    @classmethod
+    def get_run_state(cls, backend_name: str, subsystem_name: str) -> str | None:
+        """
+        Returns the current stage of bisecting, if Any
+        """
+
+        file_path = os.path.join(
+            cls.get_dir(), backend_name, f"{subsystem_name}_run_state.txt"
+        )
+        lines = cls.read_lines_from_file(file_path)
+        if lines:
+            out = lines[0].strip()
+            if out not in ("test_disable", "find_max_bounds", "bisect"):
+                raise AssertionError(
+                    f"unexpected run_state {out!r}, expected one of "
+                    "'test_disable', 'find_max_bounds', 'bisect'"
+                )
+            return out
+        return None
+
+    @classmethod
+    def get_bisect_range(
+        cls, backend_name: str, subsystem_name: str
+    ) -> tuple[int, int]:
+        file_path = os.path.join(
+            cls.get_dir(), backend_name, f"{subsystem_name}_bisect_range.txt"
+        )
+        lines = cls.read_lines_from_file(file_path)
+        low = None
+        high = None
+        # pyrefly: ignore [bad-assignment]
+        for line in reversed(lines):
+            if line.startswith("low="):
+                low = int(line.strip().split("=")[1])
+            elif line.startswith("high="):
+                high = int(line.strip().split("=")[1])
+
+            if low is not None and high is not None:
+                break
+
+        if low is None or high is None:
+            raise RuntimeError(
+                f"Trying to get bisect range when it is not set: subsystem {subsystem_name}"
+            )
+
+        return low, high
+
+    @classmethod
+    def update_config_change(cls, backend: str, subsystem: ConfigChange) -> None:
+        file_path = os.path.join(cls.get_dir(), backend, f"{subsystem.name}_config.txt")
+        lines = [
+            f"config_name={subsystem.config_name}\n",
+            f"config_field={subsystem.config_field}\n",
+            f"config_value={subsystem.config_value}\n",
+        ]
+        cls.write_lines_to_file(file_path, lines)
+
+    @classmethod
+    def get_config_change(cls, config_name: str) -> dict[str, object] | None:
+        backend = cls.get_backend()
+        subsystem = cls.get_subsystem()
+
+        if not backend or not subsystem:
+            return None
+
+        file_path = os.path.join(cls.get_dir(), backend, f"{subsystem}_config.txt")
+
+        if not os.path.exists(file_path):
+            return None
+
+        lines = cls.read_lines_from_file(file_path)
+        config_data = {}
+        for line in lines:
+            key, value = line.strip().split("=", 1)
+            config_data[key] = eval(value)
+
+        return config_data
+
+    @classmethod
+    def delete_bisect_status(cls) -> None:
+        # in process_cache we have created if it exists, just the subdirectory of non created dir
+        dir_name = cls.in_process_cache or cls.get_dir()
+        if os.path.exists(dir_name):
+            shutil.rmtree(dir_name)
+            print("Bisection status deleted.")
+        else:
+            print("No bisection status found.")
+
+    @classmethod
+    def get_system_counter(cls, name: str, increment: bool = True) -> int:
+        global subsystem_call_counter
+        curr = subsystem_call_counter[name]
+        if increment:
+            subsystem_call_counter[name] += 1
+        return curr
+
+    @classmethod
+    def disable_subsystem(
+        cls,
+        backend: str,
+        subsystem: str,
+        debug_info: Callable[[], str] | None = None,
+    ) -> bool:
+        if not cls.bisection_enabled:
+            return False
+
+        if cls.get_backend() != backend:
+            return False
+
+        if cls.get_subsystem() != subsystem:
+            return False
+
+        if val := get_env_val("TORCH_BISECT_MAX"):
+            counter = cls.get_system_counter(subsystem, increment=True)
+            return counter > int(val)
+
+        run_state = cls.get_run_state(backend, subsystem)
+        if run_state == "test_disable":
+            # First run, disable completely
+            return True
+        elif run_state == "find_max_bounds":
+            # Second run, update bisection range and return True to enable the subsystem
+            cls.update_bisect_range(
+                backend,
+                subsystem,
+                0,
+                cls.get_system_counter(subsystem, increment=True),
+            )
+            return False
+        else:
+            if run_state != "bisect":
+                raise AssertionError(f"expected run_state == 'bisect', got {run_state}")
+            # If the environment variable is not set, use the bisection range midpoint
+            low, high = cls.get_bisect_range(backend, subsystem)
+            # if high - low <= 2:
+            midpoint = (low + high) // 2
+            call_counter = cls.get_system_counter(subsystem)
+
+            if (
+                call_counter >= low
+                and call_counter <= high
+                and (high - low) <= 2
+                and debug_info is not None
+            ):
+                cls.add_call_counter_debug_info(
+                    backend, subsystem, call_counter, debug_info()
+                )
+
+            return call_counter > midpoint
+
+    @classmethod
+    def advance_subsystem(
+        cls, curr_backend: str, curr_subsystem: Subsystem
+    ) -> Subsystem | None:
+        """
+        Tries to move to the next subsystem within the current system.
+        """
+        print(f"Disabling {curr_subsystem.name} did not fix the issue.")
+
+        current_subsystems = BACKENDS[curr_backend]
+        current_subsystem_index = next(
+            i
+            for i, subsystem in enumerate(current_subsystems)
+            if subsystem.name == curr_subsystem.name
+        )
+
+        if current_subsystem_index < len(current_subsystems) - 1:
+            next_subsystem = current_subsystems[current_subsystem_index + 1]
+            cls.update_bisect_status(curr_backend, next_subsystem.name)
+            cls.update_run_state(curr_backend, next_subsystem, "test_disable")
+            print(
+                f"Moving to the next subsystem: {curr_backend} - {next_subsystem.name}"
+            )
+            return next_subsystem
+        else:
+            print(
+                f"All subsystems in {curr_backend} have been checked. The issue is not in this system."
+            )
+            return None
+
+    @classmethod
+    def advance_backend(cls, curr_backend: str) -> str | None:
+        """
+        Tries Move to the next backend.
+        """
+        current_system_index = list(BACKENDS.keys()).index(curr_backend)
+
+        if current_system_index < len(BACKENDS) - 1:
+            curr_backend = list(BACKENDS.keys())[current_system_index + 1]
+            cls.update_bisect_status(curr_backend, "")
+            print(f"Moving to the next system: {curr_backend}")
+            return curr_backend
+        else:
+            return None
+
+    @classmethod
+    def process_subsystem(
+        cls,
+        curr_backend: str,
+        curr_subsystem: Subsystem,
+        fn: Callable[[], bool],
+        cli_interface: bool = True,
+    ) -> bool:
+        """
+        Process the current subsystem. Returns True if the issue is found, False otherwise.
+        """
+        if not isinstance(curr_subsystem, Subsystem):
+            raise AssertionError(
+                f"expected curr_subsystem to be Subsystem, got {type(curr_subsystem)}"
+            )
+        while True:
+            run_state = cls.get_run_state(curr_backend, curr_subsystem.name)
+            cls.reset_counters()
+            if run_state == "test_disable":
+                if not fn():
+                    next_subsystem = cls.advance_subsystem(curr_backend, curr_subsystem)
+                    if not next_subsystem:
+                        return False
+                    curr_subsystem = next_subsystem
+                else:
+                    if isinstance(curr_subsystem, ConfigChange):
+                        print(
+                            f"Setting config {curr_subsystem.config_name} field {curr_subsystem.config_field} "
+                            f"to {curr_subsystem.config_value} fixed the issue"
+                        )
+                    else:
+                        print(f"Disabling {curr_subsystem.name} fixed the issue.")
+                    if isinstance(curr_subsystem, BinarySubsystem):
+                        return True
+                    print("Starting bisect by getting upper bound.")
+                    cls.update_run_state(
+                        curr_backend, curr_subsystem, "find_max_bounds"
+                    )
+            elif run_state == "find_max_bounds":
+                if fn():
+                    raise RuntimeError(
+                        f"Function succeeded with 'find_max_bounds' status for {curr_backend} - {curr_subsystem.name}."
+                    )
+                else:
+                    _, high = cls.get_bisect_range(curr_backend, curr_subsystem.name)
+                    print(f"Upper bound of {high} found for {curr_backend}.")
+                    cls.update_run_state(curr_backend, curr_subsystem, "bisect")
+            elif run_state == "bisect":
+                low, high = cls.get_bisect_range(curr_backend, curr_subsystem.name)
+                midpoint = (low + high) // 2
+                print(
+                    f"Bisecting {curr_backend} - {curr_subsystem.name} (Range: [{low}, {high}], Midpoint: {midpoint})"
+                )
+                if fn():
+                    cls.update_bisect_range(
+                        curr_backend, curr_subsystem.name, midpoint + 1, high
+                    )
+                else:
+                    cls.update_bisect_range(
+                        curr_backend, curr_subsystem.name, low, midpoint
+                    )
+                low, high = cls.get_bisect_range(curr_backend, curr_subsystem.name)
+                if low == high:
+                    print(
+                        f"Binary search completed for {curr_backend} - {curr_subsystem.name}. The bisect number is {low}. "
+                        f"Debug info: {cls.get_call_counter_debug_info(curr_backend, curr_subsystem.name, low) or 'not found'}"
+                    )
+                    return True
+            else:
+                raise RuntimeError(f"Unexpected run_state {run_state}")
+
+            if cli_interface:
+                sys.exit(0)
+
+    @classmethod
+    def initialize_system(cls) -> None:
+        curr_backend = next(iter(BACKENDS.keys()))
+        curr_subsystem = ""
+        cls.update_bisect_status(curr_backend, curr_subsystem)
+        print(f"Starting bisection process with system: {curr_backend}")
+
+    @classmethod
+    def do_bisect(
+        cls, fn: Callable[[], bool], cli_interface: bool = False
+    ) -> BisectionResult | None:
+        """
+        Run fn repeatedly attempting to bisect torch.compile. fn should return True on success and False on failure.
+        """
+
+        # TODO graph bisecting is not well composed with lowering
+        # bisector so far. Use a config to opt-in
+        import torch._inductor.config as inductor_config
+
+        if inductor_config.test_configs.bisect_pre_grad_graph:
+            BACKENDS["inductor"].insert(0, BisectSubsystem("pre_grad_graph"))
+
+        if not cli_interface:
+            bisection_enabled_orig = cls.bisection_enabled
+            cls.delete_bisect_status()
+            cls.bisection_enabled = True
+            # Only create temp dir if not already set (CLI run mode pre-sets it)
+            if not cls.in_process_cache:
+                cls.in_process_cache = tempfile.mkdtemp()
+
+            def cleanup() -> None:
+                cls.bisection_enabled = bisection_enabled_orig
+                cls.delete_bisect_status()
+                cls.in_process_cache = None
+
+                if BACKENDS["inductor"][0].name == "pre_grad_graph":
+                    del BACKENDS["inductor"][0]
+
+            cleanup_handler = atexit.register(cleanup)
+
+            class DisableBisect:
+                def __del__(self) -> None:
+                    cleanup()
+                    atexit.unregister(cleanup_handler)
+
+            _cleanup = DisableBisect()
+
+        curr_backend = cls.get_backend()
+        curr_subsystem_name = cls.get_subsystem()
+
+        if not curr_backend:
+            cls.initialize_system()
+            curr_backend = cls.get_backend()
+            if curr_backend is None:
+                raise AssertionError(
+                    "expected curr_backend to be set after initialize_system"
+                )
+            curr_subsystem_name = cls.get_subsystem()
+
+        curr_subsystem = (
+            cls.get_subsystem_object(curr_backend, curr_subsystem_name)
+            if curr_subsystem_name is not None
+            else None
+        )
+        while True:
+            if curr_backend is None:
+                raise AssertionError("expected curr_backend to be set")
+            cls.reset_counters()
+            if curr_subsystem:
+                result = cls.process_subsystem(
+                    curr_backend, curr_subsystem, fn, cli_interface=cli_interface
+                )
+                if result:
+                    curr_subsystem = cls.get_subsystem_object(
+                        curr_backend,
+                        cls.get_subsystem(),  # type: ignore[arg-type]
+                    )
+
+                    if isinstance(curr_subsystem, BinarySubsystem):
+                        return BisectionResult(
+                            curr_backend,
+                            curr_subsystem.name,
+                            0,
+                            curr_subsystem.name,
+                        )
+
+                    low, _ = cls.get_bisect_range(curr_backend, curr_subsystem.name)
+                    return BisectionResult(
+                        curr_backend,
+                        curr_subsystem.name,
+                        low,
+                        cls.get_call_counter_debug_info(
+                            curr_backend, curr_subsystem.name, low
+                        ),
+                    )
+
+                next_subsystem = cls.advance_subsystem(curr_backend, curr_subsystem)
+                if not next_subsystem:
+                    print(
+                        f"The issue is in the {curr_backend} system, but could not identify subsystem."
+                    )
+                    if curr_backend is None:
+                        raise AssertionError("expected curr_backend to be set")
+                    return BisectionResult(curr_backend)
+
+                curr_subsystem = next_subsystem
+            else:
+                if fn():
+                    next_backend = cls.advance_backend(curr_backend)
+                    if not next_backend:
+                        print("All systems have been checked.")
+                        return None
+
+                    curr_backend = next_backend
+                else:
+                    current_subsystems = BACKENDS[curr_backend]
+                    if current_subsystems:
+                        curr_subsystem = current_subsystems[0]
+                        cls.update_bisect_status(curr_backend, curr_subsystem.name)
+                        cls.update_run_state(
+                            curr_backend, curr_subsystem, "test_disable"
+                        )
+                        print(
+                            f"The issue is in the {curr_backend} system. Moving to the first subsystem: {curr_subsystem}"
+                        )
+                    else:
+                        print(f"The issue is in the {curr_backend} system.")
+                        return BisectionResult(curr_backend)
+
+            if cli_interface:
+                sys.exit(0)
+
+
+HELP_TEXT = """\
+Usage: python -m torch._inductor.compiler_bisector <command>
+
+Commands:
+  start       Start a new bisection session (manual mode)
+  good        Mark the current state as good (no issue)
+  bad         Mark the current state as bad (issue present)
+  end         End the bisection session and clean up
+  run <cmd>   Automatically bisect by running a command repeatedly
+              Exit code 0 = good, non-zero = bad
+
+Example - using 'run' for automatic bisection:
+
+  1. Create a test script (e.g., test_bug.py):
+
+      import os, sys, torch
+
+      def main():
+          torch._dynamo.reset()
+          # Use the backend the bisector is testing
+          backend = os.environ.get("TORCH_COMPILE_BACKEND", "inductor")
+
+          @torch.compile(backend=backend)
+          def fn(x):
+              return x.sin()  # or your failing operation
+
+          x = torch.randn(10)
+          compiled = fn(x)
+          expected = x.sin()  # eager reference
+
+          if torch.allclose(compiled, expected, rtol=1e-4, atol=1e-4):
+              return 0  # PASS
+          else:
+              print(f"FAIL: got {compiled}, expected {expected}")
+              return 1  # FAIL
+
+      if __name__ == "__main__":
+          sys.exit(main())
+
+  2. Run the bisector:
+
+      python -m torch._inductor.compiler_bisector run python test_bug.py
+
+  3. The bisector will:
+      - Test backends (eager, aot_eager, inductor) to find which fails
+      - Test subsystems within that backend (passes, lowerings, etc.)
+      - Binary search to find the exact operation causing the issue
+
+  Output:
+      Disabling lowerings fixed the issue.
+      Binary search completed for inductor - lowerings. The bisect number is 42.
+      Bisection complete: BisectionResult(backend='inductor', subsystem='lowerings', ...)
+
+Environment variables set for your test script:
+  TORCH_COMPILE_BACKEND  - The backend being tested (use this in torch.compile)
+"""
+
+
+def command_line_usage() -> None:
+    """Entry point for the compiler bisector command-line interface."""
+    if len(sys.argv) < 2:
+        print(HELP_TEXT)
+        sys.exit(1)
+
+    bisection_manager = CompilerBisector()
+    command = sys.argv[1]
+
+    if command == "end":
+        bisection_manager.delete_bisect_status()
+        sys.exit(0)
+
+    if command == "start":
+        bisection_manager.delete_bisect_status()
+        bisection_manager.initialize_system()
+        sys.exit(0)
+
+    if command == "run":
+        if len(sys.argv) < 3:
+            print(
+                "Usage: python -m torch._inductor.compiler_bisector run <command> [args...]"
+            )
+            sys.exit(1)
+
+        import subprocess
+
+        run_cmd = sys.argv[2:]
+
+        def test_function() -> bool:
+            # Pass bisection state to subprocess via environment variables
+            env = os.environ.copy()
+            backend = bisection_manager.get_backend()
+            subsystem = bisection_manager.get_subsystem()
+
+            if backend:
+                # For test script to select the right backend
+                env["TORCH_COMPILE_BACKEND"] = backend
+                # For bisector in subprocess to know which backend we're testing
+                env["TORCH_BISECT_BACKEND"] = backend
+
+            if subsystem:
+                if backend is None:  # subsystem requires a backend
+                    raise AssertionError("subsystem requires a backend")
+                env["TORCH_BISECT_SUBSYSTEM"] = subsystem
+                # Get run_state to determine TORCH_BISECT_MAX
+                run_state = bisection_manager.get_run_state(backend, subsystem)
+                if run_state == "test_disable":
+                    # -1 means always disable (counter > -1 is always True)
+                    env["TORCH_BISECT_MAX"] = "-1"
+                # For find_max_bounds and bisect, let the subprocess use file-based
+                # mechanisms. The subprocess reads run_state and bisect_range from
+                # files, and writes the actual count during find_max_bounds.
+
+            result = subprocess.run(run_cmd, env=env)
+            return result.returncode == 0
+
+        bisection_manager.delete_bisect_status()
+        bisection_manager.bisection_enabled = True
+        # Use shared cache_dir instead of temp dir so subprocesses can access files
+        CompilerBisector.in_process_cache = cache_dir()
+        result = bisection_manager.do_bisect(test_function, cli_interface=False)
+        if result:
+            print(f"\nBisection complete: {result}")
+        else:
+            print("\nBisection complete: no issue found")
+        sys.exit(0)
+
+    if command not in ["good", "bad"]:
+        print(f"Invalid command: {command}")
+        print("Must be 'good', 'bad', 'start', 'end', or 'run'.")
+        sys.exit(1)
+
+    def test_function() -> bool:
+        return command == "good"
+
+    if not bisection_manager.get_backend():
+        raise ValueError("Must call start prior to good or bad")
+
+    bisection_manager.do_bisect(test_function, cli_interface=True)
+
+
+def get_is_bisection_enabled() -> bool:
+    return (
+        CompilerBisector.get_subsystem() is not None
+        or CompilerBisector.get_backend() is not None
+    )
+
+
+CompilerBisector.bisection_enabled = get_is_bisection_enabled()
+
+if __name__ == "__main__":
+    command_line_usage()