Add files using upload-large-folder tool

ckpts/universal/global_step120/zero/13.mlp.dense_4h_to_h.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4b76ba44617583c711f86f1de7e4a659c37648ded1f657f897dba30513ef8656
+size 33555612

ckpts/universal/global_step120/zero/17.mlp.dense_h_to_4h.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:34a40fb1e962c52cede791fa69ed0d037966235db1a663f491aadda732b091ed
+size 33555612

ckpts/universal/global_step120/zero/17.mlp.dense_h_to_4h.weight/fp32.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1b604db8453bd1484546feaeba94c1ea31052848a6de2234e191cf3dfd534717
+size 33555533

ckpts/universal/global_step120/zero/26.attention.query_key_value.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:04f24ac126b0f57c4a53ee91ea64fd799da90b0b6d07ab50b38ab25eb682b804
+size 50332843

ckpts/universal/global_step120/zero/26.attention.query_key_value.weight/fp32.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f2eaa8e4a45847d44158859761ec77111585296ae41b4e64dac17284d4bcd62d
+size 50332749

ckpts/universal/global_step120/zero/29.vocab_parallel_projection.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f7ea30c1e8b0a2b4cb29ab44c993294f6c852a73425f9be0a57a01d9f6478834
+size 415237291

venv/lib/python3.10/site-packages/torch/_prims/rng_prims.py

@@ -0,0 +1,268 @@
+from typing import Optional, Tuple
+
+import torch
+import torch.utils._pytree as pytree
+from torch import _prims
+from torch._C import DispatchKey
+from torch._higher_order_ops.utils import autograd_not_implemented
+from torch._ops import HigherOrderOperator
+
+from torch._prims_common import CUDARngStateHelper, make_contiguous_strides_for
+from torch._prims_common.wrappers import backwards_not_supported
+from torch._subclasses.fake_tensor import FakeTensorMode
+from torch.fx.experimental.proxy_tensor import (
+    disable_proxy_modes_tracing,
+    ProxyTorchDispatchMode,
+    track_tensor_tree,
+)
+from torch.types import _device, _dtype
+
+
+rngprim_namespace = "rngprims"
+rngprim = torch.library.Library(rngprim_namespace, "DEF")
+rngprim_impl = torch.library.Library(
+    rngprim_namespace, "IMPL", "CompositeExplicitAutograd"
+)
+rngprim_autograd_impl = torch.library.Library(rngprim_namespace, "IMPL", "Autograd")
+rngprim_meta_impl = torch.library.Library(rngprim_namespace, "IMPL", "Meta")
+
+
+def throw_on_non_cuda(device):
+    raise RuntimeError(
+        f"You are trying to functionalize a {device.type} RNG operator but {device.type} does not "
+        f"use Philox/counter-based RNG. Therefore, functionalizing a {device.type} RNG operator is "
+        "not supported. We are discussing the possibility of a Philox-based RNG implementation for CPU."
+    )
+
+
+def register_rng_prim(name, schema, impl_aten, impl_meta, doc, tags=None):
+    rngprim.define(schema)
+    rngprim_impl.impl(name, impl_aten)
+    rngprim_meta_impl.impl(name, impl_meta)
+
+    prim_packet = getattr(torch._ops.ops.rngprims, name)
+    prim = prim_packet.default
+    if tags:
+        prim._tags = tags
+
+    rngprim_autograd_impl.impl(name, backwards_not_supported(prim))
+
+    for p in (prim_packet, prim):
+        p.__doc__ = doc
+        p.return_type = torch._prims_common.RETURN_TYPE.NEW  # type: ignore[attr-defined]
+
+        p.schema = schema
+        p.impl_aten = impl_aten
+        p.prim_meta_impl = impl_meta
+
+
+# Philox rand offsets could be shared in future with other philox ops, so
+# keeping these functions in global scope.
+def philox_rand_offset_meta(
+    shape: torch.Size,
+):
+    return _prims.TensorLike(torch.tensor(0, dtype=torch.int64))
+
+
+def philox_rand_offset(
+    shape: torch.Size,
+):
+    # For impl, look at the function calc_execution_policy in the file
+    # aten/src/ATen/native/cuda/DistributionTemplates.h. The impl was copied at
+    # commit hash 72aa0667bd16707d50eb8fa337092a1f5d11dfb6
+    numel_scalar = 1
+    for dim_size in shape:
+        numel_scalar *= dim_size
+    numel = torch.scalar_tensor(numel_scalar, dtype=torch.int64)
+
+    block_size = 256
+    unroll = 4
+    curand4_engine_calls = 4
+    device_property = torch.cuda.get_device_properties(torch.cuda.current_device())
+    blocks_per_sm = device_property.max_threads_per_multi_processor // block_size
+    grid_size = (numel + block_size - 1) // block_size
+    grid_size = min(grid_size, device_property.multi_processor_count * blocks_per_sm)
+    offset = (
+        (numel - 1) // (block_size * grid_size * unroll) + 1
+    ) * curand4_engine_calls
+    return offset
+
+
+def register_philox_rand():
+    name = "philox_rand"
+    schema = "philox_rand(SymInt[] size, Tensor seed, Tensor offset, int[]? stride, Device? device=None, ScalarType? dtype=None) -> (Tensor, Tensor)"  # noqa: B950
+
+    def _philox_rand_meta(
+        shape: torch.Size,
+        seed: torch.Tensor,
+        offset: torch.Tensor,
+        stride: Optional[Tuple[int, ...]],
+        device: _device,
+        dtype: _dtype,
+    ):
+        # stride arg will be useful for distributed usecase. Currently, its unused.
+        assert stride is None
+        stride = make_contiguous_strides_for(shape)
+        random_values = _prims.TensorMeta(
+            shape=shape, strides=stride, dtype=dtype, device=device
+        )
+        offset = philox_rand_offset_meta(shape)
+        return (random_values, offset)
+
+    def _philox_rand(
+        shape: torch.Size,
+        seed: torch.Tensor,
+        offset: torch.Tensor,
+        stride: Optional[Tuple[int, ...]],
+        device: _device,
+        dtype: _dtype,
+    ):
+        # stride arg will be useful for distributed usecase. Currently, its unused.
+        assert stride is None
+        if device.type == "cpu":
+            devices = []
+        else:
+            devices = [device]
+
+        if device.type != "cuda":
+            raise throw_on_non_cuda(device)
+
+        with torch.random.fork_rng(devices):
+            CUDARngStateHelper.set_torch_state_tensor(seed, offset)
+            random_values = torch.rand(shape, device=device, dtype=dtype)
+
+        return random_values, philox_rand_offset(shape)
+
+    register_rng_prim(
+        name=name,
+        schema=schema,
+        impl_aten=_philox_rand,
+        impl_meta=_philox_rand_meta,
+        doc="Philox based stateless rand operator",
+        tags=(torch.Tag.nondeterministic_seeded,),
+    )
+
+
+def get_device(args, kwargs):
+    if kwargs.get("device"):
+        device = kwargs.get("device")
+        if isinstance(device, str):
+            device = torch.device(device)
+        return device.type
+
+    devices = {arg.device.type for arg in args if isinstance(arg, torch.Tensor)}
+    if any(dev == "cuda" for dev in devices):
+        return "cuda"
+    elif any(dev == "cpu" for dev in devices):
+        return "cpu"
+    return None
+
+
+def register_run_and_save_rng_state_op():
+    run_and_save_rng_state = HigherOrderOperator("run_and_save_rng_state")
+
+    run_and_save_rng_state.py_impl(DispatchKey.Autograd)(
+        autograd_not_implemented(run_and_save_rng_state, deferred_error=True)
+    )
+
+    @run_and_save_rng_state.py_impl(DispatchKey.CUDA)
+    def impl_cuda(op, *args, **kwargs):
+        return torch.cuda.get_rng_state(), op(*args, **kwargs)
+
+    @run_and_save_rng_state.py_impl(DispatchKey.CPU)
+    def impl_cpu(op, *args, **kwargs):
+        return torch.get_rng_state(), op(*args, **kwargs)
+
+    @run_and_save_rng_state.py_impl(DispatchKey.BackendSelect)
+    def impl_backend_select(op, *args, **kwargs):
+        impl_map = {"cuda": impl_cuda, "cpu": impl_cpu}
+        device = get_device(args, kwargs)
+        assert device in impl_map, f"Backend not supported for {device}"
+        impl = impl_map[device]
+        return impl(op, *args, **kwargs)
+
+    @run_and_save_rng_state.py_impl(FakeTensorMode)
+    def impl_fake_tensor_mode(mode, op, *args, **kwargs):
+        # Check device to call the right impl
+        with mode:
+            return impl_backend_select(op, *args, **kwargs)
+
+    @run_and_save_rng_state.py_impl(ProxyTorchDispatchMode)
+    def impl_proxy_dispatch_mode(mode, op, *args, **kwargs):
+        if mode.enable_tracing:
+            out = impl_backend_select(op, *args, **kwargs)
+            proxy_args = pytree.tree_map(mode.tracer.unwrap_proxy, (op, *args))
+            proxy_kwargs = pytree.tree_map(mode.tracer.unwrap_proxy, kwargs)
+            out_proxy = mode.tracer.create_proxy(
+                "call_function", run_and_save_rng_state, proxy_args, proxy_kwargs
+            )
+            return track_tensor_tree(out, out_proxy, constant=None, tracer=mode.tracer)
+        else:
+            return run_and_save_rng_state(op, *args, **kwargs)
+
+    return run_and_save_rng_state
+
+
+def register_run_with_rng_state_op():
+    run_with_rng_state = HigherOrderOperator("run_with_rng_state")
+
+    run_with_rng_state.py_impl(DispatchKey.Autograd)(
+        autograd_not_implemented(run_with_rng_state, deferred_error=True)
+    )
+
+    @run_with_rng_state.py_impl(DispatchKey.CUDA)
+    def impl_cuda(rng_state, op, *args, **kwargs):
+        current_state = torch.cuda.get_rng_state()
+        torch.cuda.set_rng_state(rng_state.cpu())
+        out = op(*args, **kwargs)
+        torch.cuda.set_rng_state(current_state)
+        return out
+
+    @run_with_rng_state.py_impl(DispatchKey.CPU)
+    def impl_cpu(rng_state, op, *args, **kwargs):
+        current_state = torch.get_rng_state()
+        torch.set_rng_state(rng_state)
+        out = op(*args, **kwargs)
+        torch.set_rng_state(current_state)
+        return out
+
+    @run_with_rng_state.py_impl(ProxyTorchDispatchMode)
+    def impl_proxy_dispatch_mode(mode, rng_state, op, *args, **kwargs):
+        if mode.enable_tracing:
+            with disable_proxy_modes_tracing():
+                out = run_with_rng_state(rng_state, op, *args, **kwargs)
+            proxy_args = pytree.tree_map(
+                mode.tracer.unwrap_proxy, (rng_state, op, *args)
+            )
+            proxy_kwargs = pytree.tree_map(mode.tracer.unwrap_proxy, kwargs)
+            out_proxy = mode.tracer.create_proxy(
+                "call_function", run_with_rng_state, proxy_args, proxy_kwargs
+            )
+            return track_tensor_tree(out, out_proxy, constant=None, tracer=mode.tracer)
+        else:
+            return run_with_rng_state(rng_state, op, *args, **kwargs)
+
+    @run_with_rng_state.py_impl(DispatchKey.BackendSelect)
+    def impl_backend_select(rng_state, op, *args, **kwargs):
+        impl_map = {"cuda": impl_cuda, "cpu": impl_cpu}
+        device = get_device(args, kwargs)
+        assert device in impl_map, f"Backend not supported for {device}"
+        impl = impl_map[device]
+        return impl(rng_state, op, *args, **kwargs)
+
+    @run_with_rng_state.py_impl(FakeTensorMode)
+    def impl_fake_tensor_mode(mode, rng_state, op, *args, **kwargs):
+        # Skip setting the set_rng_state as it does not work well with fake tensors.
+        # And it does not matter for the fake tensor mode.
+        with mode:
+            return op(*args, **kwargs)
+
+    return run_with_rng_state
+
+
+run_and_save_rng_state = register_run_and_save_rng_state_op()
+run_with_rng_state = register_run_with_rng_state_op()
+
+
+def register_rng_prims():
+    register_philox_rand()

venv/lib/python3.10/site-packages/torch/distributed/__init__.py

@@ -0,0 +1,132 @@
+import os
+import sys
+from enum import Enum
+import pdb
+import io
+
+import torch
+
+def is_available() -> bool:
+    """
+    Return ``True`` if the distributed package is available.
+
+    Otherwise,
+    ``torch.distributed`` does not expose any other APIs. Currently,
+    ``torch.distributed`` is available on Linux, MacOS and Windows. Set
+    ``USE_DISTRIBUTED=1`` to enable it when building PyTorch from source.
+    Currently, the default value is ``USE_DISTRIBUTED=1`` for Linux and Windows,
+    ``USE_DISTRIBUTED=0`` for MacOS.
+    """
+    return hasattr(torch._C, "_c10d_init")
+
+
+if is_available() and not torch._C._c10d_init():
+    raise RuntimeError("Failed to initialize torch.distributed")
+
+# Custom Runtime Errors thrown from the distributed package
+DistError = torch._C._DistError
+DistBackendError = torch._C._DistBackendError
+DistNetworkError = torch._C._DistNetworkError
+DistStoreError = torch._C._DistStoreError
+
+if is_available():
+    from torch._C._distributed_c10d import (
+        Store,
+        FileStore,
+        TCPStore,
+        ProcessGroup as ProcessGroup,
+        Backend as _Backend,
+        PrefixStore,
+        Reducer,
+        Logger,
+        BuiltinCommHookType,
+        GradBucket,
+        Work as _Work,
+        _DEFAULT_FIRST_BUCKET_BYTES,
+        _register_comm_hook,
+        _register_builtin_comm_hook,
+        _broadcast_coalesced,
+        _compute_bucket_assignment_by_size,
+        _verify_params_across_processes,
+        _test_python_store,
+        DebugLevel,
+        get_debug_level,
+        set_debug_level,
+        set_debug_level_from_env,
+        _make_nccl_premul_sum,
+    )
+
+    class _DistributedPdb(pdb.Pdb):
+        """
+        Supports using PDB from inside a multiprocessing child process.
+
+        Usage:
+        _DistributedPdb().set_trace()
+        """
+        def interaction(self, *args, **kwargs):
+            _stdin = sys.stdin
+            try:
+                sys.stdin = open('/dev/stdin')
+                pdb.Pdb.interaction(self, *args, **kwargs)
+            finally:
+                sys.stdin = _stdin
+
+    def breakpoint(rank: int = 0):
+        """
+        Set a breakpoint, but only on a single rank.  All other ranks will wait for you to be
+        done with the breakpoint before continuing.
+
+        Args:
+            rank (int): Which rank to break on.  Default: ``0``
+        """
+        if get_rank() == rank:
+            pdb = _DistributedPdb()
+            pdb.message(
+                "\n!!! ATTENTION !!!\n\n"
+                f"Type 'up' to get to the frame that called dist.breakpoint(rank={rank})\n"
+            )
+            pdb.set_trace()
+        barrier()
+
+    if sys.platform != "win32":
+        from torch._C._distributed_c10d import (
+            HashStore,
+            _round_robin_process_groups,
+        )
+
+    from .distributed_c10d import *  # noqa: F403
+
+    # Variables prefixed with underscore are not auto imported
+    # See the comment in `distributed_c10d.py` above `_backend` on why we expose
+    # this.
+
+    from .distributed_c10d import (
+        _all_gather_base,
+        _reduce_scatter_base,
+        _create_process_group_wrapper,
+        _rank_not_in_group,
+        _coalescing_manager,
+        _CoalescingManager,
+        _get_process_group_name,
+    )
+
+    from .rendezvous import (
+        rendezvous,
+        _create_store_from_options,
+        register_rendezvous_handler,
+    )
+
+    from .remote_device import _remote_device
+
+    set_debug_level_from_env()
+
+else:
+    # This stub is sufficient to get
+    #   python test/test_public_bindings.py -k test_correct_module_names
+    # working even when USE_DISTRIBUTED=0.  Feel free to add more
+    # stubs as necessary.
+    # We cannot define stubs directly because they confuse pyre
+
+    class _ProcessGroupStub:
+        pass
+    sys.modules["torch.distributed"].ProcessGroup = _ProcessGroupStub  # type: ignore[attr-defined]

venv/lib/python3.10/site-packages/torch/distributed/_composable_state.py

@@ -0,0 +1,37 @@
+from typing import cast, Dict, Optional
+
+import torch.nn as nn
+
+
+class _State:
+    pass
+
+
+_module_state_mapping: Dict[nn.Module, _State] = {}
+
+
+def _insert_module_state(module: nn.Module, state: _State) -> None:
+    global _module_state_mapping
+    assert module not in _module_state_mapping, f"Inserting {module} more than once."
+    _module_state_mapping[module] = state
+
+
+def _get_module_state(module: nn.Module) -> Optional[_State]:
+    """
+    Return the ``_State`` in ``model``.
+
+    Given a ``module``, this API finds out if the module is also a ``_State``
+    instance or if the module is managed by a composable API. If the module
+    is also a ``_State``, ``module`` will be casted to ``_State` and returned.
+    If it is managed by a composable API, the corresponding ``_State`` will
+    be returned.
+    """
+    global _module_state_mapping
+    if isinstance(module, _State):
+        return cast(_State, module)
+    else:
+        # https://github.com/pytorch/pytorch/issues/107054
+        if module in _module_state_mapping:
+            return _module_state_mapping[module]
+        else:
+            return None

venv/lib/python3.10/site-packages/torch/distributed/_functional_collectives.py

@@ -0,0 +1,1084 @@
+import sys
+import warnings
+from typing import cast, List, Optional, Tuple, TYPE_CHECKING, Union
+
+import torch
+import torch.distributed as dist
+import torch.distributed.distributed_c10d as c10d
+from torch._custom_ops import impl_abstract
+from torch.distributed.device_mesh import DeviceMesh
+from torch.fx.experimental.proxy_tensor import get_innermost_proxy_mode
+
+from . import _functional_collectives_impl as fun_col_impl
+from ._functional_collectives_impl import (  # noqa: F401
+    _register_tensor_wrapper,
+    native_funcol_enabled,
+)
+
+try:
+    from torch.utils._cxx_pytree import tree_map_only
+except ImportError:
+    from torch.utils._pytree import tree_map_only  # type: ignore[no-redef]
+
+
+if torch._running_with_deploy():
+
+    def is_torchdynamo_compiling():
+        """Can't import torchdynamo in torchdeploy builds currently."""
+        return False
+
+else:
+    try:
+        from torch.compiler import is_dynamo_compiling as is_torchdynamo_compiling
+    except Exception:
+        warnings.warn(
+            "Unable to import torchdynamo util `is_torchdynamo_compiling`, so won't support torchdynamo correctly"
+        )
+
+        def is_torchdynamo_compiling():
+            return False
+
+
+"""
+New traceable, functional collectives.
+RFC: https://github.com/pytorch/pytorch/issues/93173
+
+  compiler: trace these ops with plain-old-data schemas, then choose how to lower them.
+  eager: execute these 'functional' ops which in eager return AsyncCollectiveTensor subclasses,
+         automatically calling .wait() on underlying/hidden async 'work' obj only when fed to
+         a downstream op.
+
+Issues:
+* Where should these ops live? Couldn't `import torch` if putting these ops in existing torch.distributed files
+* Proper support for eager requires inplace ops. We should explore having it as an option for the API.
+"""
+
+"""
+Functional collectives are asynchronous only and we perform implicit stream synchronization
+on behalf of the user.
+
+We use AsyncCollectiveTensor to wrap the result tensor of a collective and it lets us witness
+first usage of the tensor and insert cross stream sync at the right place.
+
+The above are the easy bits, the hard one is how we match the Work object returned by
+c10d and the tensor AsyncCollectiveTensor wraps. We alloc the tensor inside the collective
+op implementation (see ``clone()`` call in ``_all_reduce``) and then it's handled by the
+dispatcher which might call other implementations that are allowed to change the returned
+tensor - even return a tensor with a different shape (see ``torch.vmap``).
+
+This means the caller of our ops receives a Tensor that is not guaranteed to be the same
+allocated by our implementations and that makes pairing The AsyncTensor to the original
+tensor a lot harder. This pairing is needed so we can lookup the Work object to use.
+
+Originally, we tried WeakKeyDictionary to map from Tensor to Work, but because Tensor's
+identity is not stable across dispatch, the op caller would end up with a different Tensor
+instance that would not match any in the dictionary.
+
+With Tensor identity out of the question, we decided use the tensor data pointer, which
+should be stable across all the Tensor changes done during dispatch.
+
+We have a dictionary of tensor::data_ptr -> Work that we insert right after we call into c10d.
+
+We use this dictionary when AsyncCollectiveTensor is used to invoke Work::wait()
+
+Finally, we setup a finalizer against the tensor wrapper to observe it getting collected so we
+can clean up stale entries in the dictionary.
+
+To eliminate the possibility of races we have a global version counter that is used by the finalizer.
+
+As a wise man said once: Don't cross the streams (https://www.youtube.com/watch?v=wyKQe_i9yyo)
+
+"""
+
+"""
+Functional collectives can accept any of these types to describe the ranks participating in collectives.
+
+The different types will be desugared to a canonical format
+"""
+RANK_TYPES = Union[
+    List[int],
+    List[List[int]],
+    dist.ProcessGroup,
+    DeviceMesh,
+    Tuple["dist._tensor.DeviceMesh", int],
+    str,
+]
+
+
+"""
+User facing APIs for functional collectives
+-------------------------------------------
+
+These apis are called by user code and expected to work both in eager execution and compilation,
+but there are significant differences to how the two modes are implemented underneath.
+
+Eager execution is 'optimized' using a tensor subclass that schedules the synchronization (via wait_tensor() op)
+just before the tensor is first used.  Compiled tracing currently relies on the compiler to perform this optimization,
+and cannot yet correctly trace the AsyncTensor wrapper class.  In the future, these paths may be unified
+if sufficient subclass support is added in dynamo.
+
+Example: all_reduce is an entrypoint API, and other collectives follow a similar pattern.
+
+Here's how it works under torch.compile/dynamo:
+all_reduce(...)
+  |--> _expand_group(...)               - desugars processgroup into canonical/traceable format
+  |--> c10d_functional.all_reduce(...)  - dynamo captures this op call, doesn't trace deeper
+  |--> _maybe_wrap_tensor(...)          - wait_tensor() op is immediately called, no AsyncTensor subclass needed
+
+And under eager execution:
+all_reduce(...)
+  |--> _expand_group(...)               - same as above, but less critical for eager
+  |--> c10d_functional.all_reduce(...)  - dispatches to real kernel OR records op in trace
+  |--> _maybe_wrap_tensor(...)          - AsyncTensor wrapper applied to returned tensor,
+                                          which issues wait_tensor() at the time of first use
+"""
+
+
+def wait_tensor(tensor):
+    """
+    Wait on a tensor returned by the collectives ops.
+
+    Waiting follows device semantics, which means blocking on CPU and synchronizing streams on CUDA.
+    """
+    if native_funcol_enabled():
+        return torch.ops._c10d_functional.wait_tensor(tensor)  # type: ignore[attr-defined]
+    else:
+        return torch.ops.c10d_functional.wait_tensor(tensor)  # type: ignore[attr-defined]
+
+
+def broadcast(self: torch.Tensor, src: int, group: RANK_TYPES, tag: str = ""):
+    """
+    Broadcasts the tensor to all processes in the given process group.
+
+    Args:
+        src (int): Source rank
+        group (ProcessGroup or List[int]): The process group to work on.
+        tag (str, optional): A unique identifier for the collective. Default: empty string
+    """
+    if native_funcol_enabled():
+        group_name = _resolve_group_name(group, tag)
+        tensor = torch.ops._c10d_functional.broadcast(self, src, group_name)
+    else:
+        tag, rankset, group_size = _expand_group(group, tag)
+        tensor = torch.ops.c10d_functional.broadcast(
+            self, src, tag, rankset, group_size
+        )
+    return _maybe_wrap_tensor(tensor)
+
+
+def all_reduce(self: torch.Tensor, reduceOp: str, group: RANK_TYPES, tag: str = ""):
+    """
+    Reduces the tensor data across all machines in such a way that all get
+    the final result.
+
+    The input tensor is left unmodified.
+
+    Group can be one of:
+        List[int]: ranks participating in the collective.
+        List[List[int]]: 2D mesh of ranks taking part of this collective in MPMD.
+        ProcessGroup: Will perform a collective using the ranks and tag of the PG.
+        DeviceMesh: Do a SPMD collective over all ranks of the mesh
+        (DeviceMesh, int): Do a MPMD collective over one dimension of the DeviceMesh
+
+    :: N.B. If you pass a PG or a 1D list to perform a MPMD collective, the compiler won't be able to recover
+    that information and perform collective algebraic optimization. Use other forms of input for that.
+    """
+    if native_funcol_enabled():
+        group_name = _resolve_group_name(group, tag)
+        tensor = torch.ops._c10d_functional.all_reduce(
+            self, reduceOp.lower(), group_name
+        )
+    else:
+        tag, rankset, group_size = _expand_group(group, tag)
+        tensor = torch.ops.c10d_functional.all_reduce(  # type: ignore[attr-defined]
+            self,
+            reduceOp,
+            tag,
+            rankset,
+            group_size,
+        )
+    return _maybe_wrap_tensor(tensor)
+
+
+def all_gather_tensor(
+    self: torch.Tensor,
+    gather_dim: int,
+    group: RANK_TYPES,
+    tag: str = "",
+):
+    """
+    Gather tensor data across from all machines and concatenate over ``gather_dim``.
+
+    Note that it currently only supports gather_dim = 0.
+
+    The input tensor is left unmodified.
+    Group can be one of:
+        List[int]: ranks participating in the collective.
+        List[List[int]]: 2D mesh of ranks taking part of this collective in MPMD.
+        ProcessGroup: Will perform a collective using the ranks and tag of the PG.
+        DeviceMesh: Do a SPMD collective over all ranks of the mesh
+        (DeviceMesh, int): Do a MPMD collective over one dimension of the DeviceMesh
+
+    :: N.B. If you pass a PG or a 1D list to perform a MPMD collective, the compiler won't be able to recover
+    that information and perform collective algebraic optimization. Use other forms of input for that.
+    """
+    assert self.is_contiguous()
+    if native_funcol_enabled():
+        group_name = _resolve_group_name(group, tag)
+        group_size = c10d._get_group_size_by_name(group_name)
+        tensor = torch.ops._c10d_functional.all_gather_into_tensor(
+            self, group_size, group_name
+        )
+    else:
+        tag, rankset, group_size = _expand_group(group, tag)
+        tensor = torch.ops.c10d_functional.all_gather_into_tensor(  # type: ignore[attr-defined]
+            self,
+            tag,
+            rankset,
+            group_size,
+        )
+    res = _maybe_wrap_tensor(tensor)
+    # TODO this should be done inside AsyncCollectiveTensor to delay the wait() call
+    if gather_dim != 0:
+        # torch.cat access the data so we already need to wait here, first do wait
+        # and then chunk + cat avoid us going through ACT dispatching logic again
+        if isinstance(res, AsyncCollectiveTensor):
+            res = res.wait()  # type: ignore[attr-defined]
+        res = torch.cat(torch.chunk(res, group_size, dim=0), dim=gather_dim)
+    return res
+
+
+def reduce_scatter_tensor(
+    self: torch.Tensor,
+    reduceOp: str,
+    scatter_dim: int,
+    group: RANK_TYPES,
+    tag: str = "",
+):
+    """
+    Reduces the tensor data across all machines in such a way that all get
+    the final result, then scatter the results to corresponding ranks.
+
+
+    The input tensor is left unmodified.
+    Group can be one of:
+        List[int]: ranks participating in the collective.
+        List[List[int]]: 2D mesh of ranks taking part of this collective in MPMD.
+        ProcessGroup: Will perform a collective using the ranks and tag of the PG.
+        DeviceMesh: Do a SPMD collective over all ranks of the mesh
+        (DeviceMesh, int): Do a MPMD collective over one dimension of the DeviceMesh
+    :: N.B. If you pass a PG or a 1D list to perform a MPMD collective, the compiler won't be able to recover
+    that information and perform collective algebraic optimization. Use other forms of input for that.
+    """
+    if native_funcol_enabled():
+        group_name = _resolve_group_name(group, tag)
+        group_size = c10d._get_group_size_by_name(group_name)
+    else:
+        tag, rankset, group_size = _expand_group(group, tag)
+
+    assert (
+        self.size(scatter_dim) % group_size == 0
+    ), f"input dimension 0 ({self.size(0)} must be a multiple of group_size {group_size}"
+    if scatter_dim != 0:
+        tensor_list = torch.chunk(self, group_size, dim=scatter_dim)
+        self = torch.cat(tensor_list)
+
+    if native_funcol_enabled():
+        tensor = torch.ops._c10d_functional.reduce_scatter_tensor(
+            self,
+            reduceOp.lower(),
+            group_size,
+            group_name,  # type: ignore[possibly-undefined]
+        )
+    else:
+        tensor = torch.ops.c10d_functional.reduce_scatter_tensor(  # type: ignore[attr-defined]
+            self,
+            reduceOp,
+            tag,
+            rankset,  # type: ignore[possibly-undefined]
+            group_size,
+        )
+    res = _maybe_wrap_tensor(tensor)
+    return res
+
+
+def all_reduce_coalesced(
+    self: List[torch.Tensor], reduceOp: str, group: RANK_TYPES, tag: str = ""
+) -> List[torch.Tensor]:
+    """
+    Reduces a list of tensors across all machines in such a way that all get
+    the final result.
+
+    The all tensors in the input list are left unmodified.
+
+    Group can be one of:
+        List[int]: ranks participating in the collective.
+        List[List[int]]: 2D mesh of ranks taking part of this collective in MPMD.
+        ProcessGroup: Will perform a collective using the ranks and tag of the PG.
+        DeviceMesh: Do a SPMD collective over all ranks of the mesh
+        (DeviceMesh, int): Do a MPMD collective over one dimension of the DeviceMesh
+
+    :: N.B. If you pass a PG or a 1D list to perform a MPMD collective, the compiler won't be able to recover
+    that information and perform collective algebraic optimization. Use other forms of input for that.
+    """
+    if native_funcol_enabled():
+        group_name = _resolve_group_name(group, tag)
+        tensor_list = torch.ops._c10d_functional.all_reduce_coalesced(  # type: ignore[attr-defined]
+            self,
+            reduceOp.lower(),
+            group_name,
+        )
+    else:
+        tag, rankset, group_size = _expand_group(group, tag)
+        tensor_list = torch.ops.c10d_functional.all_reduce_coalesced(  # type: ignore[attr-defined]
+            self,
+            reduceOp,
+            tag,
+            rankset,
+            group_size,
+        )
+    return list(map(_maybe_wrap_tensor, tensor_list))
+
+
+def all_gather_into_tensor_coalesced(
+    self: List[torch.Tensor], group: RANK_TYPES, tag: str = ""
+) -> List[torch.Tensor]:
+    """
+    Gather a list of tensors across from all machines.
+
+    Note that it currently only supports gather_dim = 0.
+
+    The input tensor is left unmodified.
+    Group can be one of:
+        List[int]: ranks participating in the collective.
+        List[List[int]]: 2D mesh of ranks taking part of this collective in MPMD.
+        ProcessGroup: Will perform a collective using the ranks and tag of the PG.
+        DeviceMesh: Do a SPMD collective over all ranks of the mesh
+        (DeviceMesh, int): Do a MPMD collective over one dimension of the DeviceMesh
+
+    :: N.B. If you pass a PG or a 1D list to perform a MPMD collective, the compiler won't be able to recover
+    that information and perform collective algebraic optimization. Use other forms of input for that.
+    """
+    if native_funcol_enabled():
+        group_name = _resolve_group_name(group, tag)
+        group_size = c10d._get_group_size_by_name(group_name)
+        tensor_list = torch.ops._c10d_functional.all_gather_into_tensor_coalesced(  # type: ignore[attr-defined]
+            self,
+            group_size,
+            group_name,
+        )
+    else:
+        tag, rankset, group_size = _expand_group(group, tag)
+        tensor_list = torch.ops.c10d_functional.all_gather_into_tensor_coalesced(  # type: ignore[attr-defined]
+            self,
+            tag,
+            rankset,
+            group_size,
+        )
+    return list(map(_maybe_wrap_tensor, tensor_list))
+
+
+def reduce_scatter_tensor_coalesced(
+    inputs: List[torch.Tensor],
+    reduceOp: str,
+    scatter_dim: List[int],
+    group: RANK_TYPES,
+    tag: str = "",
+) -> List[torch.Tensor]:
+    """
+    Reduces a list of tensors across all machines in such a way that all get
+    the final result, then scatter the results to corresponding ranks.
+
+    The input tensors are left unmodified.
+    Group can be one of:
+        List[int]: ranks participating in the collective.
+        List[List[int]]: 2D mesh of ranks taking part of this collective in MPMD.
+        ProcessGroup: Will perform a collective using the ranks and tag of the PG.
+        DeviceMesh: Do a SPMD collective over all ranks of the mesh
+        (DeviceMesh, int): Do a MPMD collective over one dimension of the DeviceMesh
+
+    :: N.B. If you pass a PG or a 1D list to perform a MPMD collective, the compiler won't be able to recover
+    that information and perform collective algebraic optimization. Use other forms of input for that.
+    """
+    if native_funcol_enabled():
+        group_name = _resolve_group_name(group, tag)
+        group_size = c10d._get_group_size_by_name(group_name)
+    else:
+        tag, rankset, group_size = _expand_group(group, tag)
+
+    assert len(scatter_dim) == len(inputs)
+    for idx, (dim, tensor) in enumerate(zip(scatter_dim, inputs)):
+        assert (
+            tensor.size(dim) % group_size == 0
+        ), f"input dimension {dim} ({tensor.size(dim)} must be a multiple of group_size {group_size} for tensor at index {idx}"
+        if dim != 0:
+            tensor_list = torch.chunk(tensor, group_size, dim=dim)
+            inputs[idx] = torch.cat(tensor_list)
+
+    if native_funcol_enabled():
+        tensor_list = torch.ops._c10d_functional.reduce_scatter_tensor_coalesced(  # type: ignore[attr-defined]
+            inputs,
+            reduceOp.lower(),
+            group_size,
+            group_name,  # type: ignore[possibly-undefined]
+        )
+    else:
+        tensor_list = torch.ops.c10d_functional.reduce_scatter_tensor_coalesced(  # type: ignore[attr-defined]
+            inputs,
+            reduceOp,
+            tag,
+            rankset,  # type: ignore[possibly-undefined]
+            group_size,
+        )
+
+    return list(map(_maybe_wrap_tensor, tensor_list))
+
+
+# This is a bit unsafe: it checks if the first argument in the schema reports as a non-mutable alias.
+# Today, this maps 1:1 with "aten ops that are views".
+def _is_view_op(tgt):
+    assert isinstance(tgt, torch._ops.OpOverload)
+    schema = tgt._schema
+    if len(schema.arguments) > 0:
+        first_arg = schema.arguments[0]
+        # check if op is a view
+        return first_arg.alias_info is not None and not first_arg.alias_info.is_write
+
+
+def all_to_all_single(
+    self: torch.Tensor,
+    output_split_sizes: Optional[List[int]],
+    input_split_sizes: Optional[List[int]],
+    group: RANK_TYPES,
+    tag: str = "",
+) -> torch.Tensor:
+    """
+    Each process splits input tensor and then scatters the split list
+    to all processes in a group. Then concatenate the received tensors from all
+    the processes in the group and return single output tensor.
+
+    Group can be one of:
+        List[int]: ranks participating in the collective.
+        List[List[int]]: 2D mesh of ranks taking part of this collective in MPMD.
+        ProcessGroup: Will perform a collective using the ranks and tag of the PG.
+        DeviceMesh: Do a SPMD collective over all ranks of the mesh
+        (DeviceMesh, int): Do a MPMD collective over one dimension of the DeviceMesh
+
+    :: N.B. If you pass a PG or a 1D list to perform a MPMD collective, the compiler won't be able to recover
+    that information and perform collective algebraic optimization. Use other forms of input for that.
+    """
+    if output_split_sizes is not None:
+        assert all(
+            isinstance(size, (int, torch.SymInt)) for size in output_split_sizes
+        ), output_split_sizes
+    if input_split_sizes is not None:
+        assert all(
+            isinstance(size, (int, torch.SymInt)) for size in input_split_sizes
+        ), input_split_sizes
+    if native_funcol_enabled():
+        group_name = _resolve_group_name(group, tag)
+        group_size = c10d._get_group_size_by_name(group_name)
+        if output_split_sizes is None or input_split_sizes is None:
+            assert output_split_sizes is None and input_split_sizes is None, (
+                "output_split_sizes and input_split_sizes must either be "
+                "specified together or both set to None"
+            )
+            output_split_sizes = [self.shape[0] // group_size] * group_size
+            input_split_sizes = output_split_sizes
+        tensor = torch.ops._c10d_functional.all_to_all_single(  # type: ignore[attr-defined]
+            self,
+            output_split_sizes,
+            input_split_sizes,
+            group_name,
+        )
+    else:
+        tag, rankset, group_size = _expand_group(group, tag)
+        tensor = torch.ops.c10d_functional.all_to_all_single(  # type: ignore[attr-defined]
+            self,
+            output_split_sizes,
+            input_split_sizes,
+            tag,
+            rankset,
+            group_size,
+        )
+    return _maybe_wrap_tensor(tensor)
+
+
+def permute_tensor(
+    self: torch.Tensor,
+    src_dst: List[int],
+    group: RANK_TYPES,
+    tag: str = "",
+) -> torch.Tensor:
+    """
+    Permutes the elements of the tensor according to the given source/destination pairs. `src_dst` should
+    be defined such that src_dst[m] == n means m sends to n.
+
+    Group can be one of:
+        List[int]: ranks participating in the collective.
+        List[List[int]]: 2D mesh of ranks taking part of this collective in MPMD.
+        ProcessGroup: Will perform a collective using the ranks and tag of the PG.
+        DeviceMesh: Do a SPMD collective over all ranks of the mesh
+        (DeviceMesh, int): Do a MPMD collective over one
+    """
+    t, rankset, group_size = _expand_group(group, tag)
+    local_pg = c10d._find_or_create_pg_by_ranks_and_tag(t, rankset, group_size)
+
+    output_split_sizes = [0] * group_size
+    input_split_sizes = [0] * group_size
+    for src, dst in enumerate(src_dst):
+        if src == dist.get_rank(local_pg):
+            input_split_sizes[dst] = self.numel()
+        if dst == dist.get_rank(local_pg):
+            output_split_sizes[src] = self.numel()
+
+    return all_to_all_single(self, output_split_sizes, input_split_sizes, group, tag)
+
+
+class AsyncCollectiveTensor(torch.Tensor):
+    r"""
+    A Tensor wrapper subclass that is used to trigger a call to wait
+    prior to first use of the underlying tensor.
+    Use it inside functional collective pytorch wrappers like the following:
+    def functional_collective(self, group, tag):
+        tag, rankset, group_size = _expand_group(group, tag)
+        tensor = torch.ops.c10d_functional.{collective}(self, tag, rankset, group_size)
+        return _maybe_wrap_tensor(tensor)
+    """
+    elem: torch.Tensor
+    completed: bool
+
+    __slots__ = ["elem", "completed"]
+
+    @staticmethod
+    def __new__(cls, elem: torch.Tensor):
+        r = torch.Tensor._make_wrapper_subclass(  # type: ignore[attr-defined]
+            cls,
+            elem.size(),
+            strides=elem.stride(),
+            storage_offset=elem.storage_offset(),
+            dtype=elem.dtype,
+            layout=elem.layout,
+            device=elem.device,
+            requires_grad=False,
+        )
+        r.elem = elem
+        r.completed = False
+        return r
+
+    def __tensor_flatten__(self):
+        return ["elem"], None
+
+    def tolist(self):
+        self.trigger_wait()
+        return self.elem.tolist()
+
+    @staticmethod
+    def __tensor_unflatten__(inner_tensors, meta, outer_size, outer_stride):
+        assert meta is None
+        elem = inner_tensors["elem"]
+        return AsyncCollectiveTensor(elem)
+
+    def __repr__(self):
+        self.trigger_wait()
+        return f"AsyncCollectiveTensor({self.elem})"
+
+    def trigger_wait(self):
+        if not self.completed:
+            wait_tensor(self.elem)
+            self.completed = True
+        return self.elem
+
+    def wait(self) -> torch.Tensor:
+        wait_tensor(self.elem)
+        return self.elem
+
+    def _get_acs_underlying_tensor(self):
+        """This method enables  _functional_collectives_impl to test if a tensor is an ACS"""
+        return self.elem
+
+    @classmethod
+    def __torch_dispatch__(cls, func, types, args=(), kwargs=None):
+        if func == torch.ops.aten.view.default:
+            # Fast handle aten.view as a lot of view related op goes to aten.view
+            # eventually, this avoids pytree slowdown
+            res = func(args[0].elem, args[1])
+            wrapper_res = AsyncCollectiveTensor(res)
+            _register_tensor_wrapper(wrapper_res)
+            return wrapper_res
+
+        is_view_op = _is_view_op(func)
+
+        def unwrap(e: AsyncCollectiveTensor):
+            # wait_tensor is idepotent and will do stream sync only once
+            if not is_view_op:
+                e.trigger_wait()
+            return e.elem
+
+        def wrap(e: torch.Tensor):
+            # wait_tensor is idepotent and will do stream sync only once
+            assert not isinstance(e, AsyncCollectiveTensor)
+            res = AsyncCollectiveTensor(e)
+            _register_tensor_wrapper(res)
+            return res
+
+        unwrapped_args = tree_map_only(AsyncCollectiveTensor, unwrap, args)
+        unwrapped_kwargs = tree_map_only(AsyncCollectiveTensor, unwrap, kwargs)
+
+        # we don't wrap the result as it doesn't need to be waited on.
+        out = func(*unwrapped_args, **unwrapped_kwargs)
+
+        # View ops dont require a sync, so we should re-wrap the outputs.
+        if is_view_op:
+            out = tree_map_only(torch.Tensor, wrap, out)
+
+        return out
+
+    def numpy(self):
+        return self.wait().numpy()
+
+
+"""
+Utils and infrastructure for tracing support
+"""
+
+
+def _expand_group(group: RANK_TYPES, tag: str = "") -> Tuple[str, List[int], int]:
+    """
+    _expand_group desugars the different RANK_TYPES types into a canonical format that is traceable.
+
+    By having this be part of the explicit eager codepath, we avoid having to specialize behavior inside
+    torchdynamo and can still interoperate with processgroup objects or other untraceable forms.
+    """
+    # had to define this hack _inside_ expand_group to avoid
+    # graph_break [('torch.* op returned non-Tensor int
+    # caused by 'cast_*` functions being treated as 'torch.*' ops (iiuc)
+    if TYPE_CHECKING:
+
+        def cast_listlistint(x):
+            return cast(List[List[int]], x)
+
+        def cast_listint(x):
+            return cast(List[int], x)
+
+    else:
+        # fake cast op for use at runtime since dynamo doesn't support real cast
+        # also, dynamo didn't like encountering 'typing' objects ()
+        # NotImplementedError: argument of type: <class 'typing._GenericAlias'>
+        def cast_listlistint(x):
+            return x
+
+        def cast_listint(x):
+            return x
+
+    rankset: List[int]
+    if isinstance(group, list):
+        if isinstance(group[0], list):
+            nested_list = cast_listlistint(group)
+            rankset = []
+            group_size = -1
+            for rs in nested_list:
+                rankset.extend(rs)
+                if group_size != -1 and group_size != len(rs):
+                    raise ValueError(
+                        f"group sizes must be identical found {group_size} and {len(rs)}"
+                    )
+                group_size = len(rs)
+        else:
+            rankset = cast_listint(group)
+            group_size = len(rankset)
+    elif isinstance(group, dist.ProcessGroup):
+        rankset = dist.get_process_group_ranks(group)
+        group_size = len(rankset)
+        tag = tag or c10d._get_group_tag(group)
+    elif isinstance(group, DeviceMesh):
+        assert (
+            group.ndim == 1
+        ), "Only 1D mesh is supported, pass in (DeviceMesh, int) together if mesh > 1D"
+        # TODO: it should run collective in the whole mesh instead of dim 0
+        tag, rankset, _ = group._dim_group_infos[0]
+        group_size = len(rankset)
+    elif isinstance(group, tuple):
+        if (
+            len(group) == 2
+            and isinstance(group[0], DeviceMesh)
+            and isinstance(group[1], int)
+        ):
+            dmesh = group[0]
+            dim = group[1]
+            tag, rankset, _ = dmesh._dim_group_infos[dim]
+            group_size = len(rankset)
+        else:
+            raise ValueError("Invalid tuple for group must be (DeviceMesh, int)")
+    else:
+        raise ValueError(
+            "Invalid type for group, must be one of List, Processgroup, DeviceMesh or (DeviceMesh, int)."
+        )
+
+    return (tag, rankset, group_size)
+
+
+def _resolve_group_name(group: RANK_TYPES, tag: str = "") -> str:
+    """
+    Given group in RANK_TYPES, return the group name.
+    """
+    # `tag` will be deprecated. See details in:
+    # https://github.com/pytorch/pytorch/issues/93173#issuecomment-1907095208
+    if isinstance(group, dist.ProcessGroup):
+        return group.group_name
+    elif isinstance(group, str):
+        return group
+    elif isinstance(group, DeviceMesh):
+        assert (
+            group.ndim == 1
+        ), "Only 1D mesh is supported, pass in (DeviceMesh, int) together if mesh > 1D"
+        return group._dim_group_infos[0][2]
+    elif isinstance(group, tuple):
+        if (
+            len(group) == 2
+            and isinstance(group[0], DeviceMesh)
+            and isinstance(group[1], int)
+        ):
+            dmesh = group[0]
+            dim = group[1]
+            return dmesh._dim_group_infos[dim][2]
+        else:
+            raise ValueError("Invalid tuple for group must be (DeviceMesh, int)")
+    elif isinstance(group, list):
+        if not is_torchdynamo_compiling():
+            warnings.warn(
+                "The combination of ranks + tag as process group "
+                "identifier has been deprecated. Please switch to "
+                "using ProcessGroup, DeviceMesh, or group name instead."
+            )
+        return c10d._resolve_group_name_by_ranks_and_tag(cast(List[int], group), tag)
+    else:
+        raise ValueError(f"Unsupported group type: {type(group)}, {group}")
+
+
+def _are_we_tracing() -> bool:
+    if is_torchdynamo_compiling():
+        return True
+    # If functionalization is turned on, we are almost definitely compiling/tracing.
+    # (In particular, AOTAutograd traces a model once with functionalization on
+    #  but proxy tracing turned of, so this is how we detect it).
+    if (
+        torch._C._get_dispatch_mode(torch._C._TorchDispatchModeKey.FUNCTIONAL)
+        is not None
+    ):
+        return True
+    mode = get_innermost_proxy_mode()
+    if mode is None:
+        return False
+    return mode.tracer is not None
+
+
+def _maybe_wrap_tensor(self) -> torch.Tensor:
+    if _are_we_tracing():
+        return wait_tensor(self)
+    res = AsyncCollectiveTensor(self)
+    _register_tensor_wrapper(res)
+    return cast(torch.Tensor, res)
+
+
+def _all_gather_into_tensor_coalesced_meta(self, tag, rankset, group_size):
+    def mk_out_tensor(shard):
+        out_size = list(shard.size())
+        out_size[0] *= group_size
+        out_tensor = shard.new_empty(out_size)
+        return out_tensor
+
+    return [mk_out_tensor(t) for t in self]
+
+
+# We now register meta kernels to deal with tracing
+def _broadcast_meta(self, *args):
+    return torch.empty_like(self)
+
+
+def _all_reduce_meta(self, *args):
+    return torch.empty_like(self)
+
+
+def _wait_tensor_meta(self, *args):
+    return torch.empty_like(self)
+
+
+def _all_gather_into_tensor_meta(shard, tag, rankset, group_size):
+    out_size = list(shard.size())
+    out_size[0] *= group_size
+    return shard.new_empty(out_size)
+
+
+def _reduce_scatter_tensor_meta(input, reduce_op, tag, rankset, group_size):
+    out_size = list(input.size())
+    out_size[0] //= group_size
+    return input.new_empty(out_size)
+
+
+def _all_reduce_coalesced_meta(self, *args):
+    return [torch.empty_like(t) for t in self]
+
+
+def _all_reduce__meta(inp, *args):
+    return inp
+
+
+def _broadcast__meta(inp, *args):
+    return inp
+
+
+def _all_reduce_coalesced__meta(inputs, *args):
+    return inputs
+
+
+def _reduce_scatter_tensor_coalesced_meta(inputs, reduceOp, tag, rankset, group_size):
+    def mk_out_tensor(input):
+        out_size = list(input.size())
+        out_size[0] //= group_size
+        out_tensor = input.new_empty(out_size)
+        return out_tensor
+
+    return [mk_out_tensor(t) for t in inputs]
+
+
+# NB: We often say all_to_all has dynamic output size, but this is not
+# technically true: instead, what typically happens is you manually
+# communicate the output_split_sizes ahead of time (which is dynamic),
+# but then you pass those sizes explicitly, and the all to all itself
+# isn't dynamic, it just follows the specified output splits
+def _all_to_all_single_meta(
+    input, output_split_sizes, input_split_sizes, *args, **kwargs
+):
+    if output_split_sizes is None:
+        return input.new_empty(input.size())
+    else:
+        for s in output_split_sizes:
+            torch._check_is_size(s)
+        out_size = list(input.size())
+        out_size[0] = sum(output_split_sizes)
+        return input.new_empty(out_size)
+
+
+def _all_gather_into_tensor_native_meta(input, group_size, group_name):
+    shape = list(input.size())
+    shape[0] *= group_size
+    return input.new_empty(shape)
+
+
+def _all_gather_into_tensor_coalesced_native_meta(inputs, group_size, group_name):
+    return [
+        _all_gather_into_tensor_native_meta(input, group_size, group_name)
+        for input in inputs
+    ]
+
+
+def _reduce_scatter_tensor_native_meta(inp, reduce_op, group_size, group_name):
+    shape = list(inp.size())
+    shape[0] //= group_size
+    return inp.new_empty(shape)
+
+
+def _reduce_scatter_tensor_coalesced_native_meta(
+    inputs, reduce_op, group_size, group_name
+):
+    return [
+        _reduce_scatter_tensor_native_meta(inp, reduce_op, group_size, group_name)
+        for inp in inputs
+    ]
+
+
+def _register_ops():
+    ops_defs = [
+        "broadcast(Tensor self, int src, str tag, int[] ranks, int group_size) -> Tensor",
+        "all_reduce(Tensor self, str reduceOp, str tag, int[] ranks, int group_size) -> Tensor",
+        "all_reduce_coalesced(Tensor[] self, str reduceOp, str tag, int[] ranks, int group_size) -> Tensor[]",
+        "wait_tensor(Tensor self) -> Tensor",
+        "all_gather_into_tensor(Tensor shard, str tag, int[] ranks, int group_size) -> Tensor",
+        "all_gather_into_tensor_coalesced(Tensor[] input, str tag, int[] ranks, int group_size) -> Tensor[]",
+        "reduce_scatter_tensor(Tensor input, str reduceOp, str tag, int[] ranks, int group_size) -> Tensor",
+        "reduce_scatter_tensor_coalesced(Tensor[] inputs, str reduceOp, str tag, int[] ranks, int group_size) -> Tensor[]",
+        "all_to_all_single(Tensor input, SymInt[]? output_split_sizes, SymInt[]? input_split_sizes, str tag, int[] ranks, int group_size) -> Tensor",  # noqa: B950
+    ]
+
+    my_module = sys.modules[__name__]
+    for op_def in ops_defs:
+        op_name = op_def[0 : op_def.index("(")]
+        backend_impl = getattr(fun_col_impl, f"_{op_name}")
+        meta_impl = getattr(my_module, f"_{op_name}_meta")
+        c10_lib.define(op_def, tags=torch.Tag.pt2_compliant_tag)
+        c10_lib_impl.impl(op_name, backend_impl, "CompositeExplicitAutograd")
+        impl_abstract(f"c10d_functional::{op_name}")(meta_impl)
+
+
+if not torch._running_with_deploy():
+    # Library MUST be defined at module scope or it doesn't work
+    # Creating a "DEF" Library always crashes torch::deploy so we create our Library instances here
+    #   guarded against running inside it
+    c10_lib = torch.library.Library("c10d_functional", "DEF")
+    c10_lib_impl = torch.library.Library("c10d_functional", "IMPL")
+    _register_ops()
+
+    _c10_lib_impl = torch.library.Library("_c10d_functional", "IMPL")
+    _c10_lib_impl.impl("all_reduce", _all_reduce_meta, "Meta")
+    _c10_lib_impl.impl("all_reduce_", _all_reduce__meta, "Meta")
+    _c10_lib_impl.impl("all_reduce_coalesced", _all_reduce_coalesced_meta, "Meta")
+    _c10_lib_impl.impl("all_reduce_coalesced_", _all_reduce_coalesced__meta, "Meta")
+    _c10_lib_impl.impl("wait_tensor", _wait_tensor_meta, "Meta")
+    _c10_lib_impl.impl(
+        "all_gather_into_tensor", _all_gather_into_tensor_native_meta, "Meta"
+    )
+    _c10_lib_impl.impl(
+        "all_gather_into_tensor_coalesced",
+        _all_gather_into_tensor_coalesced_native_meta,
+        "Meta",
+    )
+    _c10_lib_impl.impl(
+        "reduce_scatter_tensor", _reduce_scatter_tensor_native_meta, "Meta"
+    )
+    _c10_lib_impl.impl(
+        "reduce_scatter_tensor_coalesced",
+        _reduce_scatter_tensor_coalesced_native_meta,
+        "Meta",
+    )
+    _c10_lib_impl.impl("all_to_all_single", _all_to_all_single_meta, "Meta")
+    _c10_lib_impl.impl("broadcast", _broadcast_meta, "Meta")
+    _c10_lib_impl.impl("broadcast_", _broadcast__meta, "Meta")
+else:
+    warnings.warn(
+        "PyTorch Distributed functional collectives do not work with torch::deploy."
+    )
+
+
+"""
+Dynamo Remappings allow seamless translation from non-functional collectives of supportable form into
+functional collective calls followed by inplace copy ops, allowing them to be traced into a functional graph.
+
+We implement this by writing a decomposition and teaching dynamo how to associate it to a corresponding op via
+the mapping dict below.
+
+These schemas intentionally match torch.distributed.distributed_c10d.* ops that we are trying to remap from
+"""
+
+
+def all_gather_tensor_inplace(
+    output_tensor: torch.Tensor,
+    input_tensor: torch.Tensor,
+    group,  # TODO add a type,
+    async_op: bool = False,
+    tag: str = "",
+    gather_dim: int = 0,
+):
+    assert (
+        not async_op
+    ), "Can't remap async version of inplace op to functional collective"
+    return output_tensor.copy_(all_gather_tensor(input_tensor, gather_dim, group, tag))
+
+
+def reduce_scatter_tensor_inplace(
+    output: torch.Tensor,
+    input: torch.Tensor,
+    op: str = "sum",  # TODO type is actually c10d ReduceOp. is this ok?
+    group=None,  # TODO add a type
+    async_op: bool = False,
+    scatter_dim: int = 0,
+    tag: str = "",
+):
+    assert (
+        not async_op
+    ), "Can't remap async version of inplace op to functional collective"
+    return output.copy_(reduce_scatter_tensor(input, op, scatter_dim, group, tag))
+
+
+REDUCE_OP_TO_STR = {
+    dist.ReduceOp.SUM: "sum",
+    dist.ReduceOp.AVG: "avg",
+    dist.ReduceOp.PRODUCT: "product",
+    dist.ReduceOp.MIN: "min",
+    dist.ReduceOp.MAX: "max",
+    dist.ReduceOp.BAND: "band",
+    dist.ReduceOp.BOR: "bor",
+    dist.ReduceOp.BXOR: "bxor",
+}
+
+
+def all_reduce_inplace(
+    tensor: torch.Tensor,
+    op: str = "sum",
+    group=None,
+    async_op: bool = False,
+    tag: str = "",
+):
+    assert (
+        not async_op
+    ), "Can't remap async version of inplace op to functional collective"
+
+    return tensor.copy_(all_reduce(tensor, op, group, tag))
+
+
+def all_to_all_inplace(
+    output: torch.Tensor,
+    input: torch.Tensor,
+    output_split_sizes=None,
+    input_split_sizes=None,
+    group=None,
+    async_op=False,
+    tag: str = "",
+):
+    assert (
+        not async_op
+    ), "Can't remap async version of inplace op to functional collective"
+    return output.copy_(
+        all_to_all_single(input, output_split_sizes, input_split_sizes, group, tag)
+    )
+
+
+def all_gather_inplace(
+    tensor_list: List[torch.Tensor],
+    tensor: torch.Tensor,
+    group=None,
+    async_op=False,
+    tag: str = "",
+):
+    assert (
+        not async_op
+    ), "Can't remap async version of inplace op to functional collective"
+    assert all(
+        t.size(0) == tensor.size(0) for t in tensor_list
+    ), "Remapping variable size all_gather is not yet supported"
+
+    output = all_gather_tensor(tensor, 0, group, tag)
+
+    # Use aten.slice instead of aten.split because the latter causes
+    # tensor.shape(0) to be unnecessarily baked in when it's a SymInt.
+    output_splits = []
+    offset = 0
+    for t in tensor_list:
+        output_splits.append(output[offset : offset + t.size(0)])
+        offset += t.size(0)
+    for dst, src in zip(tensor_list, output_splits):
+        dst.copy_(src)
+    return tensor_list
+
+
+from torch.distributed.distributed_c10d import (
+    _all_gather_base as legacy_all_gather_base,
+    _reduce_scatter_base as legacy_reduce_scatter_base,
+    all_gather as legacy_all_gather,
+    all_gather_into_tensor as legacy_allgather,
+    all_reduce as legacy_allreduce,
+    all_to_all_single as legacy_all_to_all_single,
+    reduce_scatter_tensor as legacy_reducescatter,
+)
+
+# This dict should contain sets of functions that dynamo is allowed to remap.
+# Functions in this set should accept the same args/kwargs 1:1 as their mapping.
+traceable_collective_remaps = {
+    legacy_allgather: all_gather_tensor_inplace,
+    legacy_reducescatter: reduce_scatter_tensor_inplace,
+    legacy_allreduce: all_reduce_inplace,
+    legacy_all_to_all_single: all_to_all_inplace,
+    legacy_all_gather: all_gather_inplace,
+    legacy_reduce_scatter_base: reduce_scatter_tensor_inplace,
+    legacy_all_gather_base: all_gather_tensor_inplace,
+}

venv/lib/python3.10/site-packages/torch/distributed/_functional_collectives_impl.py

@@ -0,0 +1,409 @@
+import logging
+import os
+import warnings
+import weakref
+from typing import cast, Dict, List, Optional
+
+import torch
+import torch.distributed as dist
+import torch.distributed.distributed_c10d as c10d
+
+"""
+Moved eager kernel implementations to a separate file partly for readability and partly as it is currently
+easier in dynamo to set tracing policy on a file-by-file level.
+
+Do not put code in this file that Dynamo is expected to trace into, as dynamo may disallow this whole file.
+
+DEBUG/TESTING HELPERS:
+
+This module includes some helpers that are quite useful when debugging or testing functional collectives:
+
+_tensor_needs_wait
+_outstanding_wait_count
+_wait_all
+
+"""
+
+_use_native_funcol: Optional[bool] = None
+
+
+if torch._running_with_deploy():
+
+    def native_funcol_enabled():
+        return False
+
+else:
+    from torch._dynamo import assume_constant_result
+
+    @assume_constant_result
+    def native_funcol_enabled():
+        global _use_native_funcol
+        if _use_native_funcol is None:
+            try:
+                # Disable native funcol when torch_xla is installed. This check
+                # will be removed once torch_xla adopts the native_funcol IR.
+                import torch_xla  # noqa: F401
+
+                _use_native_funcol = False
+            except Exception:
+                # When TORCH_DISABLE_NATIVE_FUNCOL is set, fallback to py funcol
+                _use_native_funcol = (
+                    os.environ.get("TORCH_DISABLE_NATIVE_FUNCOL") != "1"
+                )
+
+        return _use_native_funcol
+
+
+logger = logging.getLogger(__name__)
+
+data_ptr_to_work: Dict[int, "_WaitRegistration"] = dict()
+work_version = 0
+
+
+class _WaitRegistration:
+    def __init__(self, work):
+        global work_version
+        self.work = work
+        self.version = work_version
+        self.ptrs = set()
+        self.ptr_alias_count = {}
+        self.cleanup_count = 0
+        work_version += 1
+
+    def _register_tensor_ptr(self, data_ptr):
+        global data_ptr_to_work
+        data_ptr_to_work[data_ptr] = self
+        self.ptrs.add(data_ptr)
+
+    def _record_wrapper(self, ptr):
+        self._register_tensor_ptr(ptr)
+        self.ptr_alias_count.setdefault(ptr, 0)
+        self.ptr_alias_count[ptr] += 1
+        self.cleanup_count += 1
+
+    def wait(self):
+        if self.work is not None:
+            self.work.wait()
+            self.work = None
+        self.cleanup()
+
+    def decrement_live_tensor(self, ptr):
+        self.cleanup_count -= 1
+        if self.cleanup_count == 0:
+            self.wait()
+        else:
+            self.ptr_alias_count[ptr] -= 1
+            if (
+                self.ptr_alias_count[ptr] < 1
+                and data_ptr_to_work.get(ptr, None) == self
+            ):
+                del data_ptr_to_work[ptr]
+
+    def cleanup(self):
+        for ptr in self.ptrs:
+            if data_ptr_to_work.get(ptr, None) == self:
+                del data_ptr_to_work[ptr]
+
+
+def _register_tensor_work(tensor_or_list, work_or_list):
+    if not isinstance(tensor_or_list, list):
+        tensor_or_list = [tensor_or_list]
+    if not isinstance(work_or_list, list):
+        reg = _WaitRegistration(work_or_list)
+        for tensor in tensor_or_list:
+            reg._register_tensor_ptr(tensor.data_ptr())
+    else:
+        for tensor, work in zip(tensor_or_list, work_or_list):
+            reg = _WaitRegistration(work)
+            reg._register_tensor_ptr(tensor.data_ptr())
+
+
+def _wait_reg_dec(ptr, wait_reg):
+    wait_reg.decrement_live_tensor(ptr)
+
+
+def _register_tensor_wrapper(tensor) -> None:
+    if native_funcol_enabled():
+        # Tensor storage -> work mapping is maintained in C++
+        return
+    global data_ptr_to_work
+    data_ptr = tensor.elem.data_ptr()
+    # Note: we should NEVER try to trace this, bc it registers runtime stuff during trace.
+    # Instead, backends must call this themselves when implementing traced collectives.
+    wait_reg = data_ptr_to_work.get(data_ptr, None)
+    if wait_reg is None:
+        warnings.warn(
+            "Trying to register finalizer to AsyncCollectiveTensor but the inner tensor is already gone"
+        )
+    else:
+        # We force the collective to be waited in the case this tensor goes away to reduce the change of deadlocks.
+        # NOTE: we register the callback to the ACT wrapper class, for the following reasons:
+        # 1. The inner tensor is referenced by the associated Work object, so it's uncollective until we release the
+        #  associated work object
+        # 2. There's a n-to-1 relationship between wrappers and inner tensor due to non-waitable ops like view()
+        wait_reg._record_wrapper(data_ptr)
+        weakref.finalize(tensor, _wait_reg_dec, data_ptr, wait_reg)
+
+
+def _wait_tensor(tensor: torch.Tensor) -> torch.Tensor:
+    global data_ptr_to_work
+    data_ptr = tensor.data_ptr()
+    wait_reg = data_ptr_to_work.get(data_ptr)
+    if wait_reg is not None:
+        wait_reg.wait()
+    return tensor
+
+
+def _tensor_needs_wait(tensor: torch.Tensor) -> bool:
+    """Returns true if ```tensor``` needs to be waited. Works with ACS and inner tensors."""
+    if hasattr(tensor, "_get_acs_underlying_tensor"):
+        tensor = tensor._get_acs_underlying_tensor()
+    data_ptr = tensor.data_ptr()
+    wait_reg = data_ptr_to_work.get(data_ptr)
+    return wait_reg is not None and wait_reg.work is not None
+
+
+def _outstanding_wait_count() -> int:
+    """Returns the number of outstanding work objects waiting to be waited (sic)."""
+    return len(data_ptr_to_work)
+
+
+def _wait_all() -> None:
+    """Wait for all outstanding collectives."""
+    for work_reg in list(data_ptr_to_work.values()):
+        work_reg.wait()
+
+
+def _str_to_reduce_op(reduceOp: str) -> dist.ReduceOp:
+    reduceOp = reduceOp.upper()
+    op = dist.ReduceOp.RedOpType.__members__.get(reduceOp)
+    if op is None:
+        raise ValueError(f"Invalid reduce operation {reduceOp}")
+    return cast(dist.ReduceOp, op)
+
+
+"""
+Kernel implementations (for eager runtime only) - should never be traced by torch.compile
+
+These functions should all be bound to dispatcher ops.  During tracing, the op itself should be
+captured in the graph and the backend should implement the op however it prefers.
+"""
+
+
+def _broadcast(self, src, tag, ranks, group_size):
+    group = c10d._find_or_create_pg_by_ranks_and_tag(tag, ranks, group_size)
+    assert group is not None
+
+    inplace_tensor = self.clone(memory_format=torch.contiguous_format)
+    work = dist.broadcast(inplace_tensor, src, group=group, async_op=True)
+    _register_tensor_work(inplace_tensor, work)
+
+    return inplace_tensor
+
+
+# TODO assert if ranks has duplicated entries
+def _all_reduce(self, reduceOp, tag, ranks, group_size):
+    op = _str_to_reduce_op(reduceOp)
+    group = c10d._find_or_create_pg_by_ranks_and_tag(tag, ranks, group_size)
+    assert group is not None
+
+    inplace_tensor = self.clone(memory_format=torch.contiguous_format)
+    work = dist.all_reduce(inplace_tensor, op=op, group=group, async_op=True)
+    _register_tensor_work(inplace_tensor, work)
+
+    return inplace_tensor
+
+
+def _all_reduce_coalesced(self, reduceOp, tag, ranks, group_size):
+    op = _str_to_reduce_op(reduceOp)
+    group = c10d._find_or_create_pg_by_ranks_and_tag(tag, ranks, group_size)
+    assert group is not None
+
+    inplace_tensor_list = [t.clone(memory_format=torch.contiguous_format) for t in self]
+    work = dist.all_reduce_coalesced(
+        inplace_tensor_list, op=op, group=group, async_op=True
+    )
+    _register_tensor_work(inplace_tensor_list, work)
+
+    return inplace_tensor_list
+
+
+def _all_gather_into_tensor(shard, tag, ranks, group_size):
+    # TODO add dim support?
+    group = c10d._find_or_create_pg_by_ranks_and_tag(tag, ranks, group_size)
+    assert group is not None
+    out_size = list(shard.size())
+    out_size[0] *= group_size
+    out_tensor = shard.new_empty(out_size)
+    assert out_tensor.is_contiguous()
+    # FIXME gloo doesn't support _allgather_base
+    if dist.get_backend(group) == dist.Backend.GLOO or shard.is_cpu:
+        tensor_list = list(torch.chunk(out_tensor, group_size))
+        work = dist.all_gather(tensor_list, shard, group=group, async_op=True)
+    else:
+        work = dist.all_gather_into_tensor(
+            out_tensor, shard, group=group, async_op=True
+        )
+    _register_tensor_work(out_tensor, work)
+
+    return out_tensor
+
+
+def _all_gather_into_tensor_coalesced(self, tag, rankset, group_size):
+    group = c10d._find_or_create_pg_by_ranks_and_tag(tag, rankset, group_size)
+    assert group is not None
+
+    def mk_out_tensor(shard):
+        out_size = list(shard.size())
+        out_size[0] *= group_size
+        out_tensor = shard.new_empty(out_size)
+        assert out_tensor.is_contiguous()
+        return out_tensor
+
+    out_tensors = [mk_out_tensor(t) for t in self]
+
+    work_list = _all_gather_into_tensor_coalesced_fallback(
+        output_tensors=out_tensors, input_tensors=self, group=group, async_op=True
+    )
+
+    _register_tensor_work(out_tensors, work_list)
+    return out_tensors
+
+
+def _reduce_scatter_tensor(
+    input: torch.Tensor,
+    reduceOp: str,
+    tag: str,
+    ranks: List[int],
+    group_size: int,
+):
+    # TODO add dim support?
+    group = c10d._find_or_create_pg_by_ranks_and_tag(tag, ranks, group_size)
+    assert group is not None
+    op = _str_to_reduce_op(reduceOp)
+
+    if dist.get_backend(group) == dist.Backend.GLOO or input.is_cpu:
+        # cpu::gloo backend does not have reduce_scatter we fallback to do all_reduce
+        # + local chunk
+        logger.warning(
+            "ProcessGroupGloo does not support reduce_scatter, falling back with all reduce!"
+        )
+        reduction_input = input.clone()
+        group_rank = dist.get_rank(group)
+        work = dist.all_reduce(reduction_input, op=op, group=group, async_op=True)
+        out_tensor = reduction_input.chunk(group_size, dim=0)[group_rank]
+        _register_tensor_work(out_tensor, work)
+    else:
+        out_size = list(input.size())
+        out_size[0] //= group_size
+        out_tensor = input.new_empty(out_size)
+        work = dist.reduce_scatter_tensor(
+            out_tensor, input, op=op, group=group, async_op=True
+        )
+        _register_tensor_work(out_tensor, work)
+
+    return out_tensor
+
+
+def _reduce_scatter_tensor_coalesced(
+    inputs: List[torch.Tensor],
+    reduce_op: str,
+    tag: str,
+    ranks: List[int],
+    group_size: int,
+):
+    group = c10d._find_or_create_pg_by_ranks_and_tag(tag, ranks, group_size)
+    assert group is not None
+    op = _str_to_reduce_op(reduce_op)
+
+    def mk_out_tensor(shard):
+        out_size = list(shard.size())
+        out_size[0] //= group_size
+        out_tensor = shard.new_empty(out_size)
+        assert out_tensor.is_contiguous()
+        return out_tensor
+
+    out_tensors = [mk_out_tensor(t) for t in inputs]
+
+    work_list = _reduce_scatter_tensor_coalesced_fallback(
+        output_tensors=out_tensors,
+        input_tensors=inputs,
+        op=op,
+        group=group,
+        async_op=False,
+    )
+
+    _register_tensor_work(out_tensors, work_list)
+    return out_tensors
+
+
+def _all_gather_into_tensor_coalesced_fallback(
+    output_tensors, input_tensors, group, async_op=False
+):
+    # all_gather_coalesced is useless, it doesn't work under NCCL and does lots of copies under Gloo
+    # all_gather is useless too because it's single tensor
+    # NCCL's PG::all_gather with multiple tensors is broken, it only works for the multi-device setting
+    #  and fails if you mix same-size with different-size tensor lists.
+    # _coalescing_manager crashed NCCL when used with all_gather_into_tensor.
+    if input_tensors[0].is_cpu or not async_op:
+        work_list = []
+        out_tensors_sliced = [
+            list(torch.chunk(out_tensor, dist.get_world_size(group)))
+            for out_tensor in output_tensors
+        ]
+        for shard, out_tensor in zip(input_tensors, out_tensors_sliced):
+            work = c10d.all_gather(out_tensor, shard, group=group, async_op=async_op)
+            work_list.append(work)
+        return work_list
+    else:
+        with c10d._coalescing_manager(group=group, async_ops=True) as cm:
+            for in_t, out_t in zip(input_tensors, output_tensors):
+                dist.all_gather_into_tensor(out_t, in_t, group=group, async_op=True)
+        return cm
+
+
+def _reduce_scatter_tensor_coalesced_fallback(
+    output_tensors, input_tensors, op, group, async_op=False
+):
+    # All the same reasons as the all_gather fallback
+    work_list = []
+    for shard, out_tensor in zip(input_tensors, output_tensors):
+        work = c10d.reduce_scatter_tensor(
+            out_tensor, shard, op=op, group=group, async_op=async_op
+        )
+        work_list.append(work)
+    return work_list
+
+
+def _all_to_all_single(
+    input: torch.Tensor,
+    output_split_sizes: Optional[List[int]],
+    input_split_sizes: Optional[List[int]],
+    tag: str,
+    ranks: List[int],
+    group_size: int,
+):
+    group = c10d._find_or_create_pg_by_ranks_and_tag(tag, ranks, group_size)
+
+    if output_split_sizes is not None:
+        torch._check(
+            input.dim() >= 1,
+            lambda: f"Expected input to have at least 1 dim but got {input.dim()} dim",
+        )
+        out_size = list(input.size())
+        out_size[0] = sum(output_split_sizes)
+        out_tensor = input.new_empty(out_size)
+    else:
+        out_tensor = input.new_empty(input.size())
+
+    work = c10d.all_to_all_single(
+        out_tensor,
+        input,
+        output_split_sizes=output_split_sizes,
+        input_split_sizes=input_split_sizes,
+        group=group,
+        async_op=True,
+    )
+    _register_tensor_work(out_tensor, work)
+
+    return out_tensor

venv/lib/python3.10/site-packages/torch/distributed/_sharded_tensor/__init__.py

@@ -0,0 +1,12 @@
+# Keep old package for BC purposes, this file should be removed once
+# everything moves to the `torch.distributed._shard` package.
+import sys
+import torch
+import warnings
+
+from torch.distributed._shard.sharded_tensor import *  # noqa: F403
+warnings.warn(
+    "torch.distributed._sharded_tensor will be deprecated, use torch.distributed._shard.sharded_tensor instead",
+    DeprecationWarning
+)
+sys.modules['torch.distributed._sharded_tensor'] = torch.distributed._shard.sharded_tensor

venv/lib/python3.10/site-packages/torch/distributed/_sharding_spec/__init__.py

@@ -0,0 +1,14 @@
+# Keep old package for BC purposes, this file should be removed once
+# everything moves to the `torch.distributed._shard` package.
+import sys
+import torch
+import warnings
+
+from torch.distributed._shard.sharding_spec import *  # noqa: F403
+warnings.warn(
+    "torch.distributed._sharding_spec will be deprecated, use torch.distributed._shard.sharding_spec instead",
+    DeprecationWarning
+)
+
+import torch.distributed._shard.sharding_spec as _sharding_spec
+sys.modules['torch.distributed._sharding_spec'] = _sharding_spec

venv/lib/python3.10/site-packages/torch/distributed/_spmd/api.py

@@ -0,0 +1,575 @@
+from abc import ABC, abstractmethod
+from contextlib import contextmanager, nullcontext
+from copy import copy
+from dataclasses import dataclass
+from functools import partial, wraps
+from typing import Any, Callable, cast, Dict, List, Optional, Set, Tuple, Union
+
+from functorch import make_fx
+
+import torch
+import torch.distributed as dist
+
+# We need to import _functional_collectives to trigger op registration
+import torch.distributed._functional_collectives
+import torch.nn as nn
+import torch.utils._pytree as pytree
+
+from torch import fx
+from torch._decomp.decompositions import native_layer_norm_backward
+
+from torch._subclasses.fake_tensor import FakeTensorMode
+from torch.distributed._spmd.data_parallel import gradients_tagging
+from torch.distributed._spmd.parallel_mode import (
+    DataParallel,
+    DTensorExpandMode,
+    ParallelMode,
+)
+from torch.distributed._tensor import Placement
+from torch.fx.graph import _PyTreeCodeGen, _PyTreeInfo, CodeGen
+from torch.nn.utils import stateless
+from torch.nn.utils._named_member_accessor import NamedMemberAccessor
+
+
+class Override(ABC):
+    r"""Override the tracing and transformation behavior of :meth:`~torch.distributed._spmd.compile`.
+
+    This is useful when any part of the model is not traceable or if you prefer
+    to not trace it due to any reason. More specifically, users can implement
+    :meth:`torch.distributed._spmd.Override.replacement` to replace an original
+    submodule with the return new submodule. The new submodule contains
+    operations that users preferred to be traced, which simply be a dummy
+    placeholder operator. After tracing, users can implement
+    :meth:`torch.distributed._spmd.Override.transform` to transform the traced
+    graph, where the dummy placeholder operator serves as an anchor to insert
+    new sub-graphs.
+    """
+
+    @abstractmethod
+    def replacement(self, fqn: str, orig_submodule: torch.nn.Module) -> torch.nn.Module:
+        r"""Implement this method to return a new :class:`nn.Module` instance to replace the ``orig_submodule``
+        argument in the model.
+
+        This helps if ``orig_submodule`` is not traceable or should not be traced.
+
+        Args:
+            fqn (str): fully quantified name of the submodule.
+            orig_submodule (class:`nn.Module`): original submodule instance to replace.
+
+        Returns:
+            A new :class:`nn.Module` instance to replace the original one.
+
+        """
+        pass
+
+    @abstractmethod
+    def transform(
+        self,
+        gm: fx.GraphModule,
+        flat_state: List[torch.Tensor],
+    ) -> fx.GraphModule:
+        r"""
+        Given a DTensor-expanded graph and sharding schema for every node,
+        conduct additional transformation for the sub-graph from the :class:`nn.Module`
+        returned by :meth:`torch.distributed._spmd.Override.replacement` if
+        necessary.
+
+        Args:
+            gm (:class:`fx.Graph`): a DTensor-expanded graph.
+            flat_state (List[str, :class:`Tensor`]): a reference to the list of
+                flattened state. The elements in ``flat_state`` map to the first
+                ``len(flat_state)`` placeholders in the graph. The transformation
+                can add state to or remove state from ``flat_state`` as long as
+                it keeps ``flat_state`` and the placeholders consistent.
+
+        Returns:
+            The :class:`fx.Graph` after transformation.
+
+        """
+        pass
+
+
+class _PyTreeCodeGenOutputsOnly(_PyTreeCodeGen):
+    # pyre-ignore[3]
+    def process_inputs(self, *args: Any) -> Any:
+        return args
+
+    # pyre-ignore[2, 3]
+    def gen_fn_def(self, free_vars, maybe_return_annotation):
+        return CodeGen.gen_fn_def(self, free_vars, maybe_return_annotation)
+
+
+def _to_caller_flattened_graph_module(gm: torch.fx.GraphModule) -> torch.fx.GraphModule:
+    """Move the responsibility of flattening the input arguments from the graph module to the caller.
+
+    Example:
+
+        output = gm(my_struct)
+
+        gm = gm(to_caller_flattened_graph_module)
+
+        output = gm(*pytree.flatten(my_struct)[0])
+
+    """
+    # pyre-ignore[16]
+    gm._graph._codegen = _PyTreeCodeGenOutputsOnly(
+        pytree_info=_PyTreeInfo(
+            # pyre-ignore[6]
+            orig_args=None,  # type: ignore[arg-type]
+            # pyre-ignore[6]
+            in_spec=None,  # type: ignore[arg-type]
+            # pyre-ignore[16]
+            out_spec=gm._graph._codegen.pytree_info.out_spec,
+        )
+    )
+    gm.recompile()
+    return gm
+
+
+# Use a dtensor expand mode for now to preserve the old behavior
+# and avoid breaking existing code
+dtensor_expand_mode = DTensorExpandMode()
+
+
+def _override_placements(t: torch.Tensor, placements: List[Placement]):
+    global dtensor_expand_mode
+    dtensor_expand_mode._placements_override[id(t)] = placements
+
+
+@contextmanager
+def _rematerialize_optimizer(
+    opt: torch.optim.Optimizer,
+    named_states: Dict[str, Any],
+    params: Dict[str, nn.Parameter],
+):
+    assert opt is not None
+
+    # update opt.state with proxy tensors
+    orig_states = copy(opt.state)
+    for n in named_states:
+        # opt.state's key type is string, but optimizer uses Parameter as keys
+        opt.state[params[n]] = named_states[n]  # type: ignore[index]
+
+    # FIXME: support multiple parameter groups
+    param_group = opt.param_groups[0]
+    orig_params = param_group["params"]
+    param_group["params"] = params.values()
+
+    try:
+        yield
+    finally:
+        param_group["params"] = orig_params
+        opt.state = orig_states
+
+
+aten = torch.ops.aten  # pyre-ignore
+
+
+@contextmanager
+def _enable_compile():
+    # The return value of torch._utils.is_compiling changes optimizer behavior.
+    # We need that function to return True to include optimizer in the graph.
+    # See: https://github.com/pytorch/pytorch/blob/a524123c91ab399c9dd6882c1189596dd77e7734/torch/optim/optimizer.py#L41
+    def f_true():
+        return True
+
+    orig_is_compiling_code = torch._utils.is_compiling.__code__
+    torch._utils.is_compiling.__code__ = f_true.__code__
+    try:
+        yield
+    finally:
+        torch._utils.is_compiling.__code__ = orig_is_compiling_code
+
+
+def _foreach_add_decomp(self, other, alpha=1):
+    self_updated = aten._foreach_add.List(self, other, alpha=alpha)
+    for s, s_u in zip(self, self_updated):
+        s.copy_(s_u)
+
+
+def _foreach_unaop_decomp(op, self):
+    self_updated = op(self)
+    for s, s_u in zip(self, self_updated):
+        s.copy_(s_u)
+
+
+def _foreach_binop_list_decomp(op, self, other):
+    self_updated = op(self, other)
+    for s, s_u in zip(self, self_updated):
+        s.copy_(s_u)
+
+
+def _foreach_binop_scalar_decomp(op, self, scalar=1):
+    self_updated = op(self, scalar)
+    for s, s_u in zip(self, self_updated):
+        s.copy_(s_u)
+
+
+def _foreach_addcop_scalar_decomp(op, self, tensor1, tensor2, scalar=1):
+    self_updated = op(self, tensor1, tensor2, scalar)
+    for s, s_u in zip(self, self_updated):
+        s.copy_(s_u)
+
+
+def _fused_adam_decomp(
+    self,
+    grads,
+    exp_avgs,
+    exp_avg_sqs,
+    max_exp_avg_sqs,
+    state_steps,
+    *,
+    lr=1,
+    beta1=1,
+    beta2=1,
+    weight_decay=1,
+    eps=1,
+    amsgrad=True,
+    maximize=True,
+    grad_scale=None,
+    found_inf=None,
+):
+    orig_tuple = (self, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs)
+    updated_tuple = aten._fused_adam.default(
+        self,
+        grads,
+        exp_avgs,
+        exp_avg_sqs,
+        max_exp_avg_sqs,
+        state_steps,
+        lr=lr,
+        beta1=beta1,
+        beta2=beta2,
+        weight_decay=weight_decay,
+        eps=eps,
+        amsgrad=amsgrad,
+        maximize=maximize,
+        grad_scale=grad_scale,
+        found_inf=found_inf,
+    )
+
+    for idx, (orig, updated) in enumerate(zip(orig_tuple, updated_tuple)):
+        if idx == 1:
+            # skip gradient copying as we don't need to copy gradients back
+            continue
+        for o, u in zip(orig, updated):
+            o.copy_(u)
+
+
+SPMD_DECOMP_TABLE = {
+    aten._foreach_add_.List: _foreach_add_decomp,
+    aten._foreach_add_.Scalar: partial(
+        _foreach_binop_scalar_decomp, aten._foreach_add.Scalar
+    ),
+    aten._foreach_addcdiv_.Scalar: partial(
+        _foreach_addcop_scalar_decomp, aten._foreach_addcdiv.Scalar
+    ),
+    aten._foreach_addcmul_.Scalar: partial(
+        _foreach_addcop_scalar_decomp, aten._foreach_addcmul.Scalar
+    ),
+    aten._foreach_div_.List: partial(
+        _foreach_binop_list_decomp, aten._foreach_div.List
+    ),
+    aten._foreach_mul_.Scalar: partial(
+        _foreach_binop_scalar_decomp, aten._foreach_mul.Scalar
+    ),
+    aten._foreach_div_.Scalar: partial(
+        _foreach_binop_scalar_decomp, aten._foreach_div.Scalar
+    ),
+    aten._foreach_neg_.default: partial(
+        _foreach_unaop_decomp, aten._foreach_neg.default
+    ),
+    aten._foreach_reciprocal_.default: partial(
+        _foreach_unaop_decomp, aten._foreach_reciprocal.default
+    ),
+    aten._foreach_sqrt_.default: partial(
+        _foreach_unaop_decomp, aten._foreach_sqrt.default
+    ),
+    aten._foreach_sub_.Scalar: partial(
+        _foreach_binop_scalar_decomp, aten._foreach_sub.Scalar
+    ),
+    aten._fused_adam_.default: _fused_adam_decomp,
+    aten.native_layer_norm_backward.default: native_layer_norm_backward,
+}
+
+
+DEDUP_TARGETS: Set[torch._ops.OpOverload] = {
+    torch.ops.c10d_functional.all_reduce.default,
+    torch.ops.c10d_functional.wait_tensor.default,
+}
+
+
+def _dedup_collectives(gm: fx.GraphModule) -> fx.GraphModule:
+    args_to_node: Dict[Tuple[Any, ...], fx.Node] = {}
+
+    for node in gm.graph.nodes:
+        # replace all args with the results from the first unique comm op
+        args = pytree.arg_tree_leaves(*node.args)
+
+        if node.target in DEDUP_TARGETS:
+            args_key = (node.target, *args)
+            unique_node = args_to_node.get(args_key, None)
+            if unique_node is None:
+                # first time seeing this combination, remember it
+                args_to_node[args_key] = node
+            else:
+                # the current node is a duplicate, replace it
+                node.replace_all_uses_with(unique_node)
+                gm.graph.erase_node(node)
+
+    gm.recompile()
+
+    return gm
+
+
+@dataclass
+class _CompiledResult:
+    gm: fx.GraphModule
+    mod: nn.Module
+    opt: Optional[torch.optim.Optimizer]
+    flat_state: List[torch.Tensor]
+
+
+def _compile(
+    func: Callable,
+    module_override: Optional[List[Override]],
+    parallel_mode: ParallelMode,
+    *args: Any,
+    **kwargs: Any,
+) -> _CompiledResult:
+    # 1. Extract nn.Module and Optimizer from args and kwargs
+    # FIXME(@mrshenli): support multiple nn.Module instances
+    # FIXME(@mrshenli): support multiple Optiimzer instances
+    # FIXME(@mrshenli): need to broadcast model to sync parameters
+    mod, opt = None, None
+    for arg in pytree.arg_tree_leaves(*args, **kwargs):
+        if isinstance(arg, nn.Module):
+            assert mod is None, "Only support single nn.Module for now"
+            mod = arg
+        if isinstance(arg, torch.optim.Optimizer):
+            assert opt is None, "Only support single Optimizer for now"
+            opt = arg
+
+    assert mod is not None, "Couldn't find nn.Module instances from the arguments."
+
+    # 2. Override target submodules (e.g., MoE) with dummy replacements
+    if module_override:
+        accessor = NamedMemberAccessor(mod)
+
+        def swap(fqn_prefix: str, module: torch.nn.Module) -> None:
+            for override in module_override:  # type: ignore[union-attr]
+                for name, child in module.named_children():
+                    if len(name) == 0:
+                        continue
+                    fqn = fqn_prefix + "." + name if fqn_prefix != "" else name
+                    new_child = override.replacement(fqn, child)
+                    if id(new_child) == id(child):
+                        swap(fqn, new_child)
+                    else:
+                        accessor.swap_submodule(fqn, new_child)
+
+        swap("", mod)
+
+    # 3. Trace statelss version of the train_step
+    params = dict(mod.named_parameters(remove_duplicate=False))
+    buffers = dict(mod.named_buffers(remove_duplicate=False))
+
+    named_states = {}
+    if opt is not None:
+        # Pass named_states instead of opt.state to stateless_func, because
+        # the later uses nn.Parameter as key. During tracing, we need to
+        # make sure optimizers can find the states using proxy tensors.
+        for n, p in params.items():
+            if p in opt.state:
+                # opt.state's key type is string, but optimizer uses
+                # Parameter as keys
+                named_states[n] = opt.state[p]  # type: ignore[index]
+
+    is_data_parallel_mode = isinstance(parallel_mode, DataParallel)
+
+    # Lift states and parameters as function arguments so that make_fx
+    # can trace operations applied to them.
+    def stateless_func(func, params, buffers, named_states, args, kwargs):
+        with stateless._reparametrize_module(
+            mod, {**params, **buffers}
+        ), _rematerialize_optimizer(
+            opt, named_states, params
+        ) if opt else nullcontext():
+            # For DataParallel mode, install hooks first to tag the gradients
+            with gradients_tagging(params) if is_data_parallel_mode else nullcontext():
+                ret = func(*args, **kwargs)
+
+            # make sure updated parameters are returned
+            return ret, list(mod.parameters()), list(named_states.values())  # type: ignore[union-attr]
+
+    # FIXME: Using symbolic tracing to work around in DTensor expand mode.
+    # Otherwise it hits shape mismatch error, as we use local inputs to
+    # trace local graph and use DTensor to expand operators, where
+    # DTensor's shape is the global shape.
+    tracing_mode = "fake" if is_data_parallel_mode else "symbolic"
+
+    if is_data_parallel_mode:
+        fake_mode = FakeTensorMode()
+        data_parallel_mode = cast(DataParallel, parallel_mode)
+
+        def _get_full_batch_arg(arg: torch.Tensor) -> torch.Tensor:
+            # since compilation happens in the first iteration and we
+            # receives mini-batch input, convert them to full batch
+            # fake tensor input first for data parallel sharding
+            # propagations
+            fake_arg = fake_mode.from_tensor(arg)
+            arg_dims = [1] * arg.ndim
+            # expand the tensor to full batch size on its batch dim
+            arg_dims[data_parallel_mode.input_batch_dim] *= dist.get_world_size()
+            return fake_arg.repeat(arg_dims)
+
+        args = pytree.tree_map_only(
+            torch.Tensor,
+            _get_full_batch_arg,
+            args,
+        )
+        kwargs = pytree.tree_map_only(
+            torch.Tensor,
+            _get_full_batch_arg,
+            kwargs,
+        )
+
+    with _enable_compile(), torch.autograd.detect_anomaly(check_nan=False):
+        # FIXME(@mrshenli): functionalization does not work for our use
+        # case yet. Use explicit decompositions for foreach ops.
+        # Remove this when the following issue is addressed.
+        # Issue: https://github.com/pytorch/pytorch/issues/97852
+        gm = make_fx(
+            partial(stateless_func, func),
+            tracing_mode=tracing_mode,
+            decomposition_table=SPMD_DECOMP_TABLE,
+            _allow_non_fake_inputs=False,
+        )(params, buffers, named_states, args, kwargs)
+
+    params_and_buffers: Dict[str, Union[torch.Tensor, nn.Parameter]] = {
+        **params,
+        **buffers,
+    }
+
+    # 4. parallel mode to expand a single device graph to a distributed graph
+    gm = parallel_mode.partition(
+        gm,
+        mod,
+        opt,
+        params_and_buffers,
+        named_states,
+        args,
+        kwargs,
+    )
+
+    # 5. Move the responsibility of flattening the input arguments from the
+    # graph module to the caller. This serves two purposes:
+    #   - Transformations that add/remove state need to manipulate a state
+    #   container that maintains the state tensors in the same order as they
+    #   appear in graph placeholders.
+    #   - Reduced runtime cost. The state container is only flattened once upfront.
+    flat_state = pytree.tree_leaves([params_and_buffers, named_states])
+    gm = _to_caller_flattened_graph_module(gm)
+
+    # 6. dedup comm operators.
+    # The duplication could come from DTensor args and kwargs redistribution.
+    # Suppose one operator produces a Partial gradient tensor and model
+    # parameters are replicated. In this case, every optimizer operation using
+    # that Partial gradient tensor would trigger an allreduce. This is becuase
+    # DTensor only has local information on individual tensor/operator, which is
+    # not sufficient to detect duplications in the graph. This situation can
+    # also happen when inserting FSDP allgather if a parameter is used multiple
+    # times in the forward method.
+    # TODO(@mrshenli): @yifuwang has a suggestion of conducting expansion and
+    # dedup at tracer-level to avoid multiple graph passes.
+    gm = _dedup_collectives(gm)
+
+    # 7. Replace previously inserted dummy ones with real graphs.
+    if module_override:
+        for override in module_override:
+            gm = override.transform(gm, flat_state)
+
+    return _CompiledResult(gm, mod, opt, flat_state)
+
+
+# Note that the Python convention of __dict__ requires the key to be str.
+# TODO: ensure the key is unique.
+COMPILED_OBJECT_KEY = "_compiled_obj"
+
+
+def compile(
+    module_override: Optional[List[Override]] = None,
+    gm_transformation: Optional[Callable[[fx.GraphModule], fx.GraphModule]] = None,
+    parallel_mode: Optional[ParallelMode] = None,
+):
+    r"""Compile and optimize a callable, which can be a train step within a training loop.
+
+    This method will extract :class:`nn.Module` and :class:`torch.optim.Optimizer`
+    instances from the input arguments and trace operations applied to their
+    parameters and states.
+
+    Args:
+        module_override (Optional[List[Override]]): a list of Override instances
+            that will be applied to the module in order. The :class:`Override`
+            objects provide :class:`nn.Module` replacements during tracing and a
+            graph transformation function after tracing. (Default: ``None``)
+        gm_transformation (Optional[Callable[fx.GraphModule, fx.GraphModule]]):
+            a callback that will be called after the original callable is
+            compiled and distributed (usually after the first iteration) to
+            transform the compiled GraphModule into a new optimized one.
+        parallel_mode (Optional[ParallelMode]): a :class:`ParallelMode` object
+            that specifies how to parallelize the callable. Each ParallelMode
+            would have its own strategy to partition the model and the captured
+            graph (Default: ``None``)
+
+    """
+
+    def inner(func: Callable):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            last_train_step = kwargs.pop("last_train_step", False) if kwargs else False
+            first_iter = False
+            # Put the COMPILED_OBJECT_KEY in ``wrapper`` instead of ``func`` as
+            # ``wrapper`` is the one that users will get.
+            compiled_obj = wrapper.__dict__.get(COMPILED_OBJECT_KEY, None)
+            if compiled_obj is None:
+                first_iter = True
+                global dtensor_expand_mode
+                mode: ParallelMode = (
+                    dtensor_expand_mode if parallel_mode is None else parallel_mode
+                )
+
+                compiled_obj = _compile(func, module_override, mode, *args, **kwargs)
+                wrapper.__dict__[COMPILED_OBJECT_KEY] = compiled_obj
+
+            flat_inps = compiled_obj.flat_state + pytree.arg_tree_leaves(
+                *args, **kwargs
+            )
+
+            with torch.no_grad():
+                # N.B.: we don't need autograd as backward has already been
+                # captured in the graph.
+                if first_iter and gm_transformation:
+                    # TODO: SPMD should provid a default and configurable
+                    # transformation.
+                    compiled_obj.gm = gm_transformation(compiled_obj.gm)
+                if not last_train_step:
+                    output = compiled_obj.gm(*flat_inps)[0]
+                else:
+                    # This is the last train step. Call IterGraphModule.forward()
+                    # with the `last_iter` argument and catch the exception in
+                    # case the compiled_obj is not wrapped with IterGraphModule.
+                    try:
+                        output = compiled_obj.gm(*flat_inps, last_iter=last_train_step)[
+                            0
+                        ]
+                    except TypeError as e:
+                        if "last_iter" not in str(e):
+                            raise e
+                        output = compiled_obj.gm(*flat_inps)[0]
+
+                return output
+
+        return wrapper
+
+    return inner

venv/lib/python3.10/site-packages/torch/distributed/_spmd/batch_dim_utils.py

@@ -0,0 +1,179 @@
+from typing import Callable, Dict, List, Set
+
+import torch
+
+import torch.fx as fx
+
+import torch.utils._pytree as pytree
+
+from torch import Tensor
+
+from torch.distributed._tensor import DeviceMesh, Replicate, Shard
+from torch.distributed._tensor.ops.view_ops import (
+    DimSpec,
+    InputDim,
+    ops as view_op_rules,
+)
+from torch.distributed._tensor.placement_types import _Partial, DTensorSpec
+
+aten = torch.ops.aten
+
+
+class BatchDimAnalyzer:
+    """This class is used to analyze the batch dimension of each tensor/node in the graph.
+
+    We need to know the batch dimension of each tensor/node so that we know
+    exactly the sharding layout of intermediate tensors.
+
+    We possibly should evaluate using symbolic shapes to track the batch dimension.
+    We can experiment it later with dynamo integration (as dynamo have mark_dynamic
+    API which allows marking batch dimension only) or try to use FakeTensorMode to
+    mark the batch dimension. For now, let's just use the batch dimension of the first
+    input tensor as the hint to track the batch dimension of all tensors/nodes in
+    the graph.
+    """
+
+    def __init__(self, batch_dim: int = 0) -> None:
+        self.batch_dim = batch_dim
+
+        self.batch_dim_map: Dict[fx.Node, int] = {}
+        # batch dim size is used to track the batch dim size of the input tensor
+        self.batch_dim_size = -1
+
+        self.dim_rule_map: Dict[torch._ops.OpOverload, Callable[..., torch.Tensor]] = {
+            aten.squeeze.default: torch.squeeze,
+            aten.squeeze.dim: torch.squeeze,
+            aten.view.default: Tensor.view,
+            aten.reshape.default: torch.reshape,
+            aten._unsafe_view.default: Tensor.view,
+            aten.unsqueeze.default: torch.unsqueeze,
+            aten.expand.default: Tensor.expand,
+            aten.permute.default: torch.permute,
+            aten.repeat.default: Tensor.repeat,
+            aten.transpose.int: torch.transpose,
+        }
+
+    def init_batch_dim_size(self, batch_dim_size: int) -> None:
+        """Initialize batch dim size base on the first input batch size."""
+        if self.batch_dim_size != -1 and self.batch_dim_size != batch_dim_size:
+            raise RuntimeError(
+                f"batch dim size is already initialized! "
+                f"Found new batch size: {batch_dim_size} not "
+                f"matching existing batch dim size: {self.batch_dim_size}!"
+            )
+        self.batch_dim_size = batch_dim_size
+
+    def set_batch_dim(self, node: fx.Node, batch_dim: int) -> None:
+        self.batch_dim_map[node] = batch_dim
+
+    def get_batch_dim(self, node: fx.Node) -> int:
+        if node not in self.batch_dim_map:
+            raise RuntimeError(f"batch dim analysis failed on node: {node}!")
+        return self.batch_dim_map[node]
+
+    def compute_batch_dim(self, node: fx.Node, full_reduction=False) -> int:
+        """Compute the batch dimension for the `node`."""
+        assert self.batch_dim_size != -1, "batch dim size is not initialized!"
+
+        if node in self.batch_dim_map:
+            # if batch dim already computed, simply return it
+            return self.batch_dim_map[node]
+
+        if node.target in self.dim_rule_map:
+            view_op_rule = view_op_rules[self.dim_rule_map[node.target]]  # type: ignore[index]
+            args_val = pytree.tree_map_only(fx.Node, lambda n: n.meta["val"], node.args)
+            kwargs_val = pytree.tree_map_only(
+                fx.Node, lambda n: n.meta["val"], node.kwargs
+            )
+            output_dim_rules = view_op_rule.dim_map(*args_val, **kwargs_val)
+
+            def collect_input_dim(cmd: DimSpec, input_dims: Set[int]):
+                if isinstance(cmd, InputDim):
+                    input_dims.add(cmd.input_dim)
+                for inp in cmd.inputs():
+                    collect_input_dim(inp, input_dims)
+
+            output_dim_to_input_dims: List[Set[int]] = []
+            for inp in output_dim_rules:
+                input_dims: Set[int] = set()
+                collect_input_dim(inp, input_dims=input_dims)
+                output_dim_to_input_dims.append(input_dims)
+
+            operand = node.all_input_nodes[0]
+            operand_batch_dim = self.get_batch_dim(operand)
+            for output_dim, input_dims in enumerate(output_dim_to_input_dims):
+                if operand_batch_dim in input_dims:
+                    self.set_batch_dim(node, output_dim)
+                    # update batch dim size before return
+                    # this is because batch dim size might change during the middle
+                    self.batch_dim_size = node.meta["val"].shape[output_dim]
+                    return output_dim
+
+        # if there's no hints from the output_dim_rules, we infer from output
+        # shape to see if there's batch dim, and shard correspondingly
+        node_val = node.meta["val"]
+        if isinstance(node_val, (list, tuple)):
+            shapes = [val.shape for val in node_val]
+        else:
+            shapes = [node_val.shape]
+
+        # for reduction op that reduces over the sharded batch dim
+        # we don't generate partial, but rather, we generate shard
+        # This is because the intention of data parallel is to never
+        # do full reduction across batch dimension, it would still
+        # keep the reduction activation as sharded.
+        full_reduction = False
+        # loop through the dim size to find the output batch dim
+        for shape in shapes:
+            if len(shape) == 0:
+                full_reduction = True
+
+            for i, dim_size in enumerate(shape):
+                if dim_size == self.batch_dim_size:
+                    self.set_batch_dim(node, i)
+                    return i
+
+        operands = node.all_input_nodes
+        if not operands:
+            # if there's no operands, it must be factory ops and it's a tensor
+            # generated for computation and should be marked as replicated
+            self.set_batch_dim(node, -1)
+            # -1 means replicated
+            return -1
+        else:
+            # if there's operand we see the operand have batch dim, if operand
+            # have batch dim but output does not, it's either a full reduction,
+            # where we should stay sharded, or it's a reduction on batch dim only
+            # where we should produce partial
+            operand_batch_dim = -1
+            for operand in operands:
+                if operand in self.batch_dim_map:
+                    operand_batch_dim = self.get_batch_dim(operand)
+            # self.get_batch_dim(operands[0])
+            if operand_batch_dim < 0:
+                # if operand does not have batch dim, we also don't have batch dim
+                self.set_batch_dim(node, operand_batch_dim)
+                return operand_batch_dim
+            elif full_reduction:
+                self.set_batch_dim(node, operand_batch_dim)
+                return operand_batch_dim
+            else:
+                # if operand have batch dim but output does not, it should
+                # produce partial, we use -2 to indicate partial
+                self.set_batch_dim(node, -2)
+                return -2
+
+    def compute_act_spec(self, node: fx.Node, mesh: DeviceMesh) -> DTensorSpec:
+        """Compute the batch dimension for the current node, then generate the sharding spec that shards on the batch dimension."""
+        node_batch_dim = self.compute_batch_dim(node)
+        if node_batch_dim == -1:
+            # indicate this activation is replicated
+            act_spec = DTensorSpec(mesh=mesh, placements=(Replicate(),))
+        elif node_batch_dim == -2:
+            # indicate this activation is partial
+            act_spec = DTensorSpec(mesh=mesh, placements=(_Partial(),))
+        else:
+            # indicate this activation is Shard
+            act_spec = DTensorSpec(mesh=mesh, placements=(Shard(node_batch_dim),))
+
+        return act_spec

venv/lib/python3.10/site-packages/torch/distributed/_spmd/comm_tensor.py

@@ -0,0 +1,247 @@
+from dataclasses import dataclass
+from functools import partial
+from typing import Any, List, Optional, Tuple
+
+import torch
+from torch._C import _disabled_torch_function_impl
+from torch.fx.experimental.proxy_tensor import (
+    _ProxyTensor,
+    fetch_object_proxy,
+    get_innermost_proxy_mode,
+    get_proxy_slot,
+    set_proxy_slot,
+    track_tensor_tree,
+)
+from torch.utils import _pytree as pytree
+from torch.utils._mode_utils import no_dispatch
+from torch.utils._pytree import tree_flatten, tree_map, tree_map_only
+
+
+@dataclass
+class _CommResult:
+    # a custom type wrapping both inplace output tensor and work handle
+    _tensor: torch.Tensor
+    _work: torch.distributed._Work
+
+
+def _wait_comm(comm_result: _CommResult):
+    # This function is only used by tracing mode as a call_function node right
+    # before consuming a collective result tensor.
+    comm_result._work.wait()
+    return comm_result._tensor
+
+
+def _wrap_comm_result(result: Tuple[Any, Any]) -> Tuple[Any, Any]:
+    def wrap(work, e):
+        assert isinstance(e, torch.Tensor), (
+            "Excepting collection of tensors as the first element in the "
+            "return value of communication operations."
+        )
+
+        return _CommResult(e, work)
+
+    # E.g.,
+    # allreduce_ returns ([tensor], work)
+    # allgather_ returns ([[tensor1, tensor2]], work)
+    work = result[1]
+    return (tree_map(partial(wrap, work), result[0]), work)
+
+
+def _get_tracer() -> Optional[torch.fx.Tracer]:
+    mode = get_innermost_proxy_mode()
+    if mode is None:
+        return None
+    return mode.tracer
+
+
+class CommTensor(torch.Tensor):
+    r"""
+    A Tensor subclass to wrap input tensors for collective communications.
+
+    This Tensor subclass works for both eager and tracing mode.
+    In eager mode, it will record whether the inplace collective communication
+    has been launched using this Tensor and remember the corresponding work
+    handle. If yes, it will explicitly call wait() in the ``__torch_dispatch__``
+    function before subsequent operations consuming the value of the Tensor.
+
+    In tracing mode, ``CommTensor`` inserts two node into the graph using the
+    ``__torch_dispatch__`` function.
+    1. The first node is inserted right after the
+    communication, wrapping both the inplace output tensor and the returned
+    work handle into a custom ``_CommResult`` type. We have to do this because
+    ``ProxyTorchDispatchMode`` only handles ``torch.Tensor``, ``_ProxyTensor``,
+    and ``torch.nn.Parameter`` objects and will treat the work handle
+    as a constant and embed that into the graph. As a result, during execution,
+    it will use the work handle created during tracing and will lead to wrong
+    result. The solution in this test is to manually create a proxy on the
+    return value of ``allreduce_`` which is ``([tensor], work)``, and wrap that
+    to ``[(_CommResult(tensor, work)), work]``. In this way, subsequent nodes can
+    directly consume ``_CommResult``.
+    2. The second node is inserted right before any subsequent node reads from
+    ``_CommResult``. It will call ``wait()`` on the stashed work handle to ensure
+    that computation waits for communication.
+    """
+
+    _supported_comms: List[str] = [
+        "_allgather_base_",
+        "_reduce_scatter_base_",
+        "allreduce_",
+        "allgather_",
+        "alltoall_",
+        "broadcast_",
+        "reduce_scatter_",
+        "scatter_",
+    ]
+
+    _tensor: torch.Tensor
+    _work: Optional[torch.distributed._Work]
+
+    @staticmethod
+    def __new__(cls, tensor: torch.Tensor):
+        t = tensor._tensor if isinstance(tensor, CommTensor) else tensor
+        if get_innermost_proxy_mode() is None:
+            # noop for eager mode
+            return tensor
+
+        # Use non-CommTensor to avoid nested CommTensor Wrapping
+        r = torch.Tensor._make_subclass(cls, t, require_grad=t.requires_grad)
+        # The tensor object wrapped by this CommTensor
+        # NB: THIS CAN BE A CommTensor; see test_nested_comm_tensor_wrapping
+        r._tensor = tensor  # type: ignore[attr-defined]
+        # Record the LAST `work` object returned by collective communication
+        # operations. If this is None, it means no collectives have called
+        # since last time a tensor is wrapped by CommTensor
+        r._work = None  # type: ignore[attr-defined]
+        return r
+
+    def __repr__(self):
+        return f"CommTensor({self._tensor}, work={self._work})"
+
+    # disable __torch_function__ so that CommTensor can recursively dispatch
+    # with ProxyTorchDispatchMode in make_fx
+    __torch_function__ = _disabled_torch_function_impl
+
+    @classmethod
+    def _is_supported(cls, op_name):
+        return any(comm in op_name for comm in cls._supported_comms)
+
+    @classmethod
+    def __torch_dispatch__(cls, func, types, args=(), kwargs=None):
+        # shared states when unwrapping args
+        tracer: Optional[torch.fx.Tracer] = None
+        work: Optional[torch.distributed._Work] = None
+
+        # wrapped ._tensor if this is a CommTensor, and insert/call wait()
+        # if communication has been launched on this tensor.
+        def unwrap(e: Any):
+            if isinstance(e, CommTensor):
+                nonlocal tracer, work
+
+                work = e._work
+                # TODO(ezyang): I don't really understand what's going on
+                # here, but it seems that tracer doesn't reflect whether or
+                # not there is ambient tracing going on, but rather, whether
+                # or not we will trace THIS particular invocation.  If we
+                # have a nested CommTensor, the outer layer doesn't actually
+                # trace and we only trace the inner layer
+                if not isinstance(e._tensor, CommTensor):
+                    tracer = _get_tracer()
+
+                if work is not None:
+                    if tracer is not None:
+                        # insert a node to the traced graph.
+                        proxy_res = tracer.create_proxy(  # type: ignore[union-attr]
+                            "call_function",
+                            _wait_comm,
+                            (get_proxy_slot(e._tensor, tracer).proxy,),
+                            {},
+                            name="wait_comm",
+                        )
+                        # HACK: update the proxy for the inplace output
+                        set_proxy_slot(e._tensor, tracer, proxy_res)
+                    # For eager mode, simply wait.
+                    # During tracing, still need to wait here, to make sure the
+                    # execution during tracing is correct.
+                    work.wait()
+
+                # communication has been waited, stop propagating CommTensor
+                return e._tensor
+            else:
+                return e
+
+        def wrap(e: Any):
+            return CommTensor(e) if isinstance(e, torch.Tensor) else e
+
+        def set_work(work: torch.distributed._Work, e: Any):
+            if isinstance(e, CommTensor):
+                e._work = work  # type: ignore[attr-defined]
+            elif isinstance(e, torch.Tensor):
+                raise RuntimeError(
+                    "Type of output tensors from collective communication during "
+                    "tracing should always be CommTensor instead of torch.Tensor"
+                )
+            return e
+
+        unwrapped_args = tree_map(unwrap, args)
+        unwrapped_kwargs = tree_map(unwrap, kwargs)
+
+        if cls._is_supported(func.__name__):
+            if tracer is not None:
+                # in tracing mode, get proxies for args
+                proxy_args, proxy_kwargs = tree_map_only(
+                    _ProxyTensor,
+                    lambda e: e.proxy,
+                    tree_map_only(
+                        torch.Tensor,
+                        fetch_object_proxy(tracer),
+                        (unwrapped_args, unwrapped_kwargs),
+                    ),
+                )
+
+                # get proxy for output tuple
+                proxy_res = func(*proxy_args, **proxy_kwargs)
+                assert isinstance(proxy_res, torch.fx.Proxy)
+                # insert a node that wraps the output tuple into
+                # _CommResult(tensor, work)
+                comm_result_proxy = tracer.create_proxy(  # type: ignore[union-attr]
+                    "call_function",
+                    _wrap_comm_result,
+                    (proxy_res,),
+                    {},
+                    name="comm_result",
+                )
+
+                with no_dispatch():
+                    # disable dispatch to avoid trigger ProxyTorchDispatchMode logic
+                    out = func(*unwrapped_args, **unwrapped_kwargs)
+
+                # wrap output with the proxy of _CommResult, so that subsequent
+                # ops and link to it.
+                track_tensor_tree(out, comm_result_proxy, constant=None, tracer=tracer)
+
+                # N.B.: we still need to remember the work handle here, and wait
+                # for it later to make sure the execution during tracing is
+                # correct. Also, remember comm is already launched
+                # args[0] is always the collection of output tensors
+                pytree.tree_map_(partial(set_work, out[1]), args[0])
+
+                # HACK: update the proxy on the input argument as this is an
+                # inplace collective communication.
+                flat_args, args_spec = tree_flatten(unwrapped_args[0])
+                flat_out, out_spec = tree_flatten(out[0])
+                for a, o in zip(flat_args, flat_out):
+                    set_proxy_slot(a, tracer, get_proxy_slot(o, tracer))
+
+                return out
+            else:
+                # in eager mode, simply remember work handle as an attribute
+                out = func(*unwrapped_args, **unwrapped_kwargs)
+                pytree.tree_map_(partial(set_work, out[1]), args[0])
+                return out
+        else:
+            if work is not None:
+                return func(*unwrapped_args, **unwrapped_kwargs)
+            else:
+                # we need to propagate CommTensor wrapping until the first
+                # subsequent operation has waited for it.
+                return tree_map(wrap, func(*unwrapped_args, **unwrapped_kwargs))

venv/lib/python3.10/site-packages/torch/distributed/_spmd/config.py

@@ -0,0 +1,27 @@
+import logging
+import sys
+from types import ModuleType
+from typing import Set
+
+# log level (levels print what it says + all levels listed below it)
+# DEBUG print full traces <-- lowest level + print tracing of every instruction
+# INFO print compiler functions + distributed graphs
+# WARN print warnings
+# ERROR print exceptions
+log_level: int = logging.DEBUG
+# Verbose will print full stack traces on warnings and errors
+verbose = False
+
+# the name of a file to write the logs to
+log_file_name: None = None
+
+
+class _AccessLimitingConfig(ModuleType):
+    def __setattr__(self, name, value) -> None:
+        if name not in _allowed_config_names:
+            raise AttributeError(f"{__name__}.{name} does not exist")
+        return object.__setattr__(self, name, value)
+
+
+_allowed_config_names: Set[str] = {*globals().keys()}
+sys.modules[__name__].__class__ = _AccessLimitingConfig

venv/lib/python3.10/site-packages/torch/distributed/_spmd/data_parallel.py

@@ -0,0 +1,824 @@
+import operator
+from contextlib import contextmanager
+from enum import Enum
+
+from typing import Any, cast, Dict, List, Optional, Tuple
+
+import torch
+
+import torch.distributed.distributed_c10d as c10d
+import torch.fx as fx
+import torch.library
+import torch.nn as nn
+
+import torch.utils._pytree as pytree
+
+from torch.distributed._spmd.batch_dim_utils import BatchDimAnalyzer
+from torch.distributed._tensor import DeviceMesh, distribute_tensor, Replicate, Shard
+
+from torch.distributed._tensor._utils import compute_local_shape
+from torch.distributed._tensor.op_schema import (
+    OpStrategy,
+    PlacementStrategy,
+    StrategyType,
+    TupleStrategy,
+)
+from torch.distributed._tensor.placement_types import _Partial, DTensorSpec, Placement
+from torch.distributed._tensor.redistribute import redistribute_local_tensor
+from torch.fx import GraphModule
+from torch.fx.experimental.proxy_tensor import make_fx
+from torch.fx.passes.shape_prop import _extract_tensor_metadata
+from torch.nn.utils._named_member_accessor import NamedMemberAccessor
+
+aten = torch.ops.aten
+
+# Dummy op used by data parallel to tag gradients.
+_spmd_lib_def = torch.library.Library("_spmd", "DEF")
+_spmd_lib_def.define("tag_grad(Tensor self) -> Tensor")
+
+_spmd_lib_impl = torch.library.Library("_spmd", "IMPL")
+_spmd_lib_impl.impl("tag_grad", lambda x: x, "CompositeExplicitAutograd")
+
+
+class DataParallelStyle(Enum):
+    """This enum represents the style of the data-parallel operation.
+
+    We have three types of Data Parallel style:
+    1. DEFAULT: the default data parallel style, which is to represent a mixed
+                replicate and fully shard behavior. For each parameter that is able
+                to be sharded evenly, we shard it, otherwise we would replicate the
+                parameter. This style avoids potential padding if the parameters
+                cannot be sharded evenly, but it would generate a mixed of all_reduce
+                and reduce_scatter.
+    2. REPLICATE: the data parallel style that replicates all model parameters.
+                  This is similar to the behavior of DistributedDataParallel.
+    3. FULLY_SHARD: the data parallel style that shards all model parameters. This
+                    is similar to the behavior of FullyShardedDataParallel, the
+                    difference is that FullyShardedDataParallel (ZERO-3), which
+                    shards the model using FlatParameter based sharding,
+                    while this style shards each parameter into DTensor.
+    """
+
+    DEFAULT = 0
+    REPLICATE = 1
+    FULLY_SHARD = 2
+
+
+class NodeType(Enum):
+    """NodeType is an enum that records the type of the tensors in the graph.
+
+    This is used to determine the data parallel strategy.
+    """
+
+    PARAM = 0
+    ACT = 1
+    GRAD = 2
+    STATE = 3
+    NON_TENSOR = 4  # NON_TENSOR is to tag non tensor node (i.e. graph output)
+
+
+class DataParallelStrategy(OpStrategy):
+    """DataParallelStrategy is a special case of OpStrategy that only records the "data parallel style" placement
+    strategy for each fx Node.
+
+    It takes a list of PlacementStrategy, where each PlacementStrategy describes
+    one way to distribute the tensor and computation. In the DataParallel case,
+    there're two possible ways to distribute the parameters:
+        1. replicate the parameter over a set of devices (DDP like behavior)
+        2. shard the parameter on its tensor dimension 0 over a set of devices
+           (FSDP like behavior).
+
+    In addition to the strategy list, we also need to:
+    1. `node_type`: record the type of each node in the graph, so that we can
+        determine how to propagate in a data parallel fashion.
+    2. `reduce_over_batch` is specifically tied to data parallel as the loss
+        calculation usually results in scalar tensor where it comes from a
+        reduction over the batch dimension. We need to know this information
+        so that we could keep the output as sharded.
+    """
+
+    def __init__(
+        self,
+        node_type: NodeType,
+        strategy_list: List[PlacementStrategy],
+        reduction_over_batch: bool = False,
+    ):
+        super().__init__(strategy_list)
+        self.node_type = node_type
+        self.reduction_over_batch = reduction_over_batch
+
+    def __str__(self) -> str:
+        return f"type: {self.node_type}, {super().__str__()}"
+
+
+@contextmanager
+def gradients_tagging(params: Dict[str, torch.Tensor]):
+    """Tag the gradient of the parameters with a special tag, so that we can identify them during SPMD expansion.
+
+    It's safe to trace those hooks and we would remove those nodes later.
+    """
+    tagging_hooks = []
+    try:
+        for p in params.values():
+            h = p.register_hook(torch.ops._spmd.tag_grad)
+            tagging_hooks.append(h)
+        yield
+    finally:
+        # remove those hooks after tracing
+        for h in tagging_hooks:
+            h.remove()
+
+
+def _gen_shard_strategy(
+    mesh: DeviceMesh, shard_dim: int, input_specs: Optional[List[DTensorSpec]] = None
+) -> PlacementStrategy:
+    """Util function to generate a shard strategy on shard_dim."""
+    return PlacementStrategy(
+        output_specs=DTensorSpec(mesh=mesh, placements=(Shard(shard_dim),)),
+        input_specs=input_specs,
+    )
+
+
+def _gen_replicate_strategy(
+    mesh: DeviceMesh, input_specs: Optional[List[DTensorSpec]] = None
+) -> PlacementStrategy:
+    """Util function to generate a replicate strategy."""
+    return PlacementStrategy(
+        output_specs=DTensorSpec(mesh=mesh, placements=(Replicate(),)),
+        input_specs=input_specs,
+    )
+
+
+def _gen_partial_strategy(mesh: DeviceMesh) -> PlacementStrategy:
+    """Util function to generate a partial strategy."""
+    # NOTE: we use AVG by default, avg reduction is needed depending on
+    # the loss function, for most loss function it should do
+    # gradient averaging. There might be certain cases it should
+    # not do gradient averaging (i.e. sum) but it's pretty rare.
+    # TODO: Only NCCL supports AVG so using backend like Gloo would
+    # crash, we should figure out a way to support avg reduction
+    # for non-NCCL backend
+    reduce_op = c10d.ReduceOp.AVG  # type: ignore[attr-defined]
+    return PlacementStrategy(
+        output_specs=DTensorSpec(mesh=mesh, placements=(_Partial(reduce_op),)),
+    )
+
+
+def build_data_parallel_strategies(
+    train_step_graph: GraphModule,
+    num_params: int,
+    num_states: int,
+    mesh: DeviceMesh,
+    batch_dim: int = 0,
+) -> Dict[fx.Node, StrategyType]:
+    """Loop through the train step graph and build the data parallel strategy for each fx Node."""
+    activation_idx = num_params + num_states
+    non_compute_ops = [
+        aten.clone.default,
+        aten.detach.default,
+        aten.ones_like.default,
+        aten.reshape.default,
+        aten.t.default,
+        aten.view.default,
+        torch.ops._spmd.tag_grad.default,
+        operator.getitem,
+    ]
+
+    tuple_strategy_ops = [aten._fused_adam.default]
+
+    dp_strategy_map: Dict[fx.Node, StrategyType] = {}
+    batch_dim_analyzer = BatchDimAnalyzer(batch_dim)
+    placeholder_idx = 0
+    num_param_grad = 0
+
+    # first we backward propagate to mark the param gradients sharding
+    # with tag_grad node helps and then delete the tag_grad nodes
+    for node in reversed(list(train_step_graph.graph.nodes)):
+        # find a param_grad node via the tagging
+        if node.target == torch.ops._spmd.tag_grad.default:
+            cur_node = node
+            while cur_node.target in non_compute_ops:
+                cur_node = cur_node.args[0]
+                partial_strategy = _gen_partial_strategy(mesh)
+                dp_strategy_map[cur_node] = DataParallelStrategy(
+                    NodeType.GRAD, [partial_strategy]
+                )
+            num_param_grad += 1
+            # remove the tag_grad node from graph
+            node.replace_all_uses_with(node.args[0])
+            train_step_graph.graph.erase_node(node)
+
+            if num_param_grad == num_params:
+                # early break if we have already processed all param_grads
+                break
+
+    # next we forward propagate to mark all the sharding
+    for node in train_step_graph.graph.nodes:
+        if node.op == "placeholder":
+            if "val" not in node.meta:
+                # NOTE: There're certain cases where the placeholder nodes do
+                # not have real tensor values:
+                # 1. optimizer states can be None sometimes, i.e. SGD with
+                #    no momentum, optimizer states populate `momentum` state
+                #    as None, the full graph we get from `compile` would have
+                #    None as the placeholder value
+                # 2. function args might not only contain params or activations,
+                #    but also contain other non-tensor inputs, i.e. the model
+                #    and optimizer instances baked in as a placeholder, there might
+                #    also be some scalar argument which is not a tensor
+                #
+                # For the above cases, we create a NON_TENSOR stratgy so that we
+                # know it's not a tensor and we don't need to shard it
+                dp_strategy_map[node] = DataParallelStrategy(NodeType.NON_TENSOR, [])
+
+            elif placeholder_idx < num_params:
+                # during compilation there's an assumption that the first num_params
+                # placeholders should be parameters
+                shard_strategy = _gen_shard_strategy(mesh, 0)
+                replica_strategy = _gen_replicate_strategy(mesh)
+                dp_strategy_map[node] = DataParallelStrategy(
+                    NodeType.PARAM, [replica_strategy, shard_strategy]
+                )
+
+            elif placeholder_idx < activation_idx:
+                # optimizer states follow the same strategy as
+                # the corresponding parameters
+                replica_strategy = _gen_replicate_strategy(mesh)
+                shard_strategy = _gen_shard_strategy(mesh, 0)
+
+                dp_strategy_map[node] = DataParallelStrategy(
+                    NodeType.STATE, [replica_strategy, shard_strategy]
+                )
+            else:
+                activation_batch_dim_size = node.meta["val"].shape[batch_dim]
+                # find the first activation node and use its batch dim size
+                if batch_dim_analyzer.batch_dim_size == -1:
+                    batch_dim_analyzer.init_batch_dim_size(activation_batch_dim_size)
+
+                batch_dim_analyzer.set_batch_dim(node, batch_dim)
+                shard_strategy = _gen_shard_strategy(mesh, batch_dim)
+                dp_strategy_map[node] = DataParallelStrategy(
+                    NodeType.ACT, [shard_strategy]
+                )
+            placeholder_idx += 1
+        elif node.op == "call_function":
+            # Annotate node types for the computation graph
+            # Data Parallel node propagation logic:
+            # param (non-compute) -> out: param
+            # grad (non-compute before/after) -> out: grad
+            # state -> output: state
+            #
+            # param + activation (param must be replicate, act be sharded) -> out: activation
+            # param/state + grad (param/state/grad be the same spec) -> out: param/state
+            # param + state -> out: param
+
+            if node.target in non_compute_ops:
+                # At this point, we should have removed all the `tag_grad` nodes in the graph
+                assert node.target != torch.ops._spmd.tag_grad.default
+
+                input_nodes = node.all_input_nodes
+                assert (
+                    len(input_nodes) == 1
+                ), f"non-compute op only support one input now, found node: {node} with length of inputs: {len(node.args)}"
+                arg_strategy = dp_strategy_map[input_nodes[0]]
+
+                if node.target == operator.getitem:
+                    # for getitem call, just forward the strategy from the input
+                    getitem_idx = node.args[1]
+                    if isinstance(arg_strategy, TupleStrategy):
+                        # for tuple strategy, we need to get the child strategy from the tuple
+                        dp_strategy_map[node] = arg_strategy.childs[getitem_idx]
+                    else:
+                        # if it's not a tuple strategy, we just forward the arg strategy
+                        dp_strategy_map[node] = arg_strategy
+                else:
+                    assert isinstance(arg_strategy, DataParallelStrategy)
+                    arg_node_type = arg_strategy.node_type
+                    if arg_node_type == NodeType.PARAM:
+                        replica_strategy = _gen_replicate_strategy(mesh)
+                        dp_strategy_map[node] = DataParallelStrategy(
+                            NodeType.PARAM, [replica_strategy]
+                        )
+                    elif arg_node_type == NodeType.GRAD:
+                        partial_sig = _gen_partial_strategy(mesh)
+                        dp_strategy_map[node] = DataParallelStrategy(
+                            NodeType.GRAD, [partial_sig]
+                        )
+                    elif arg_node_type == NodeType.ACT:
+                        arg_node_spec = batch_dim_analyzer.compute_act_spec(
+                            input_nodes[0], mesh
+                        )
+
+                        output_spec = batch_dim_analyzer.compute_act_spec(node, mesh)
+
+                        shard_strategy = PlacementStrategy(
+                            output_specs=output_spec, input_specs=[arg_node_spec]
+                        )
+                        dp_strategy_map[node] = DataParallelStrategy(
+                            NodeType.ACT, [shard_strategy]
+                        )
+                    else:
+                        raise RuntimeError(
+                            f"non compute op not supporting {arg_node_type}! "
+                        )
+
+                # finished processing this non-compute node
+                continue
+
+            # for computatation nodes, we need to check all the inputs
+            input_args = node.all_input_nodes
+            input_specs = []
+            if node in dp_strategy_map:
+                # found a param_grad node that already have output pre-filled spec
+                # fill in the expected input specs for the pre-filled strategy
+                node_strategy = dp_strategy_map[node]
+                assert isinstance(node_strategy, DataParallelStrategy)
+                node_type = node_strategy.node_type
+                assert node_type == NodeType.GRAD
+                produce_param_grad_strat = node_strategy.strategies
+                has_activation = False
+                for arg in input_args:
+                    arg_strategy = dp_strategy_map[arg]
+                    assert isinstance(arg_strategy, DataParallelStrategy)
+                    arg_node_type = arg_strategy.node_type
+                    if arg_node_type == NodeType.ACT:
+                        # activation sharded
+                        has_activation = True
+                        act_spec = batch_dim_analyzer.compute_act_spec(arg, mesh)
+
+                        input_specs.append(act_spec)
+
+                if has_activation:
+                    assert len(produce_param_grad_strat) == 1
+                    produce_param_grad_strat[0].input_specs = input_specs
+            elif node.target in tuple_strategy_ops:
+                # ops that need to build tuple strategy instead of normal strategy
+                # This should happen rarely and only needed when we need to generate
+                # different node strategy for multiple outputs (i.e. fused_adam op)
+                # TODO: Currently this specializes to fused optimizer ops, but we need
+                # to see how to generalize this strategy building logic
+                output_strategy_len = len(node.args) - 1
+                tuple_strategies = []
+                for i in range(output_strategy_len):
+                    if not isinstance(node.args[i], list):
+                        raise RuntimeError(
+                            f"Expecting list as arg to build Tuple Strategy, but found type {type(node.args[i])}!"
+                        )
+                    # for list/tuple arg, use the first one to find out the node type
+                    if len(node.args[i]) > 0:
+                        arg_strategy = dp_strategy_map[node.args[i][0]]
+                        assert isinstance(arg_strategy, DataParallelStrategy)
+                        assert arg_strategy.node_type in [
+                            NodeType.PARAM,
+                            NodeType.GRAD,
+                            NodeType.STATE,
+                        ], "Expecting param/grad/state as arg to build Tuple Strategy!"
+                        replica_strategy = _gen_replicate_strategy(mesh)
+                        shard_strategy = _gen_shard_strategy(mesh, shard_dim=0)
+                        out_node_strategy: StrategyType = DataParallelStrategy(
+                            arg_strategy.node_type, [replica_strategy, shard_strategy]
+                        )
+
+                        tuple_strategies.append(out_node_strategy)
+
+                output_tuple_strategy = TupleStrategy(tuple(tuple_strategies))
+                dp_strategy_map[node] = output_tuple_strategy
+            else:
+                # NOTE: This is the common region for all regular computation ops
+
+                input_node_types = [
+                    cast(DataParallelStrategy, dp_strategy_map[arg]).node_type
+                    for arg in input_args
+                    if isinstance(dp_strategy_map[arg], DataParallelStrategy)
+                ]
+                if NodeType.GRAD in input_node_types:
+                    # param/state + grad, build up acceptable strategy
+                    # the strategy should be the same for all the inputs/outputs
+                    # TODO: optimizer parts should follow the dtensor prop logic
+                    # to support more general cases that allows optimizer states
+                    # to have different shardings compare to the params
+                    replica_strategy = _gen_replicate_strategy(mesh)
+                    shard_strategy = _gen_shard_strategy(mesh, shard_dim=0)
+                    output_node_type = NodeType.PARAM
+
+                    non_grad_types = [t for t in input_node_types if t != NodeType.GRAD]
+
+                    output_node_type = non_grad_types[0]
+                    for non_grad_type in non_grad_types:
+                        assert (
+                            non_grad_type == output_node_type
+                        ), f"Found more than one non grad types! Expect {output_node_type} but found {non_grad_type}!"
+                    assert output_node_type in [
+                        NodeType.PARAM,
+                        NodeType.STATE,
+                    ], f"Expecting output node type to be either state or param, but found {output_node_type}!"
+
+                    dp_strategy_map[node] = DataParallelStrategy(
+                        output_node_type, [replica_strategy, shard_strategy]
+                    )
+                elif NodeType.STATE in input_node_types:
+                    # either param + state or state + state
+                    replica_strategy = _gen_replicate_strategy(mesh)
+                    shard_strategy = _gen_shard_strategy(mesh, shard_dim=0)
+                    output_node_type = (
+                        NodeType.PARAM
+                        if NodeType.PARAM in input_node_types
+                        else NodeType.STATE
+                    )
+
+                    dp_strategy_map[node] = DataParallelStrategy(
+                        output_node_type, [replica_strategy, shard_strategy]
+                    )
+                elif NodeType.PARAM in input_node_types:
+                    if NodeType.ACT in input_node_types:
+                        # param + activation, build up acceptable strategy
+                        # param must be replicated, activation must be sharded
+                        for arg in input_args:
+                            arg_strategy = dp_strategy_map[arg]
+                            assert isinstance(arg_strategy, DataParallelStrategy)
+                            node_type = arg_strategy.node_type
+                            if node_type == NodeType.ACT:
+                                # compute activation spec
+                                act_spec = batch_dim_analyzer.compute_act_spec(
+                                    arg, mesh
+                                )
+
+                                input_specs.append(act_spec)
+                            elif node_type == NodeType.PARAM:
+                                # param must be replicated
+                                input_specs.append(
+                                    DTensorSpec(mesh=mesh, placements=(Replicate(),))
+                                )
+                            else:
+                                raise RuntimeError(
+                                    f"Expecting node with parameter and activation, but found {input_node_types}! "
+                                )
+                        # produce activation type sharding for output
+                        output_spec = batch_dim_analyzer.compute_act_spec(node, mesh)
+
+                        act_strategy = PlacementStrategy(
+                            output_specs=output_spec, input_specs=input_specs
+                        )
+
+                        dp_strategy_map[node] = DataParallelStrategy(
+                            NodeType.ACT, [act_strategy]
+                        )
+                    else:
+                        # If inputs only have parameters, the
+                        # strategy of this node should follow input
+                        dp_strategy_map[node] = dp_strategy_map[input_args[0]]
+                else:
+                    # If input nodes does not have PARAM/GRAD/STATE, then
+                    # it should be a pure activation computation, it should
+                    # produce activation output.
+                    # Activations are usually sharded unless model creates
+                    # new tensors during computation, which depend on whether
+                    # the new tensor associate with a batch dim or not, it could
+                    # be shard/replicate/partial, batch dim analyzer should tell
+                    # us the correct sharding.
+                    for arg in input_args:
+                        arg_strategy = dp_strategy_map[arg]
+                        assert isinstance(arg_strategy, DataParallelStrategy)
+                        input_spec = batch_dim_analyzer.compute_act_spec(arg, mesh)
+
+                        input_specs.append(input_spec)
+
+                    act_spec = batch_dim_analyzer.compute_act_spec(node, mesh)
+                    op_strategy = PlacementStrategy(
+                        output_specs=act_spec, input_specs=input_specs
+                    )
+                    dp_strategy_map[node] = DataParallelStrategy(
+                        NodeType.ACT, [op_strategy]
+                    )
+
+        elif node.op == "output":
+            dp_strategy_map[node] = DataParallelStrategy(NodeType.NON_TENSOR, [])
+        else:
+            raise RuntimeError(f"op code {node.op} not supported")
+
+    return dp_strategy_map  # type: ignore[return-value]
+
+
+def mark_data_parallel_shardings(
+    train_step_graph: GraphModule,
+    num_parameters: int,
+    num_states: int,
+    dp_strategy_map: Dict[fx.Node, StrategyType],
+    parallel_mode: DataParallelStyle = DataParallelStyle.FULLY_SHARD,
+) -> None:
+    """Mark the sharding for the nodes in the train_step_graph."""
+    activation_idx = num_parameters + num_states
+    placeholder_idx = 0
+    for node in train_step_graph.graph.nodes:
+        node_strategy = dp_strategy_map[node]
+        if node.op == "placeholder":
+            assert isinstance(node_strategy, DataParallelStrategy)
+            node_type = node_strategy.node_type
+            node_strategies = node_strategy.strategies
+            if node_type == NodeType.NON_TENSOR:
+                # set node sharding to None
+                node_sharding = None
+            elif placeholder_idx < activation_idx:
+                assert len(node_strategies) > 0, "node_strategies should not be empty"
+                if parallel_mode == DataParallelStyle.REPLICATE:
+                    # set to replicate for replicate style
+                    node_sharding = node_strategies[0]
+                elif parallel_mode == DataParallelStyle.FULLY_SHARD:
+                    # set to shard for fully shard style
+                    if len(node_strategies) == 1:
+                        # only one strategy, use that instead
+                        # i.e. optimizer state steps can only be replicate
+                        node_sharding = node_strategies[0]
+                    else:
+                        # use the full sharding strategy
+                        node_sharding = node_strategies[1]
+                elif parallel_mode == DataParallelStyle.DEFAULT:
+                    # TODO: add support for default mode
+                    # default mode would generate either replicate or shard
+                    raise NotImplementedError("default mode not implemented")
+            else:
+                assert len(node_strategies) > 0, "node_strategies should not be empty"
+                # mark activation as sharded on batch dim
+                node_sharding = node_strategies[0]
+
+            node.meta["sharding"] = node_sharding  # type: ignore[possibly-undefined]
+
+            placeholder_idx += 1
+        elif node.op == "call_function":
+            if isinstance(node_strategy, TupleStrategy):
+                # For tuple strategy in the data parallel mode, it should have the same strategy
+                # for all tuple elements, assert that then use the first element's strategy as sharding
+                first_strategy = cast(DataParallelStrategy, node_strategy.childs[0])
+                for child_strategy in node_strategy.childs:
+                    assert isinstance(child_strategy, DataParallelStrategy)
+                    assert child_strategy.strategies == first_strategy.strategies
+
+                node_strategies = first_strategy.strategies
+            else:
+                assert isinstance(node_strategy, DataParallelStrategy)
+                node_strategies = node_strategy.strategies
+
+            assert (
+                len(node_strategies) <= 2
+            ), "data parallel should have at most 2 strategies"
+            if len(node_strategies) == 1:
+                node.meta["sharding"] = node_strategies[0]
+            elif len(node_strategies) == 2:
+                if parallel_mode == DataParallelStyle.REPLICATE:
+                    # set to replicate for replicate style
+                    node.meta["sharding"] = node_strategies[0]
+                elif parallel_mode == DataParallelStyle.FULLY_SHARD:
+                    # set to shard for fully shard style
+                    node.meta["sharding"] = node_strategies[1]
+                else:
+                    raise RuntimeError("default mode not supported yet!")
+            else:
+                raise RuntimeError(
+                    f"node {node} strategy length {len(node_strategies)} is not expected!"
+                )
+        elif node.op == "output":
+            assert (
+                isinstance(node_strategy, DataParallelStrategy)
+                and node_strategy.node_type == NodeType.NON_TENSOR
+            ), "output node should not be tensor"
+            node.meta["sharding"] = None
+        else:
+            raise RuntimeError(f"op code {node.op} not supported")
+
+
+def _partition_val(val: Any, spec: DTensorSpec) -> Any:
+    """Util function to convert a full tensor val to its local component."""
+    if isinstance(val, torch.Tensor):
+        local_shard = val
+        if val.ndim == 0:
+            # If it's already a scalar tensor, it is already local, we don't
+            # need to do anything
+            return local_shard
+
+        for idx, placement in enumerate(spec.placements):
+            if placement.is_shard():
+                placement = cast(Shard, placement)
+                num_chunks = spec.mesh.size(mesh_dim=idx)
+                my_coord = spec.mesh.get_coordinate()
+                assert my_coord is not None, "current rank not in mesh!"
+                my_coord_on_mesh_dim = my_coord[idx]
+                local_shard = placement._split_tensor(
+                    local_shard, num_chunks, with_padding=False, contiguous=False
+                )[0][my_coord_on_mesh_dim]
+        return local_shard
+    elif isinstance(val, (tuple, list)):
+        return val.__class__(_partition_val(v, spec) for v in val)
+    else:
+        raise RuntimeError(f"val type {type(val)} not supported")
+
+
+def partitioner(graph: GraphModule) -> GraphModule:
+    """Graph partitioner that partitions the single device graph to distributed graph."""
+    shape_adjustment_ops = {
+        aten._unsafe_view.default: 1,
+        aten.expand.default: 1,
+        aten.new_zeros.default: 1,
+        aten.ones.default: 0,
+        aten.reshape.default: 1,
+        aten.view.default: 1,
+        aten.zeros.default: 0,
+    }
+    # partition the graph to distributed
+    for node in graph.graph.nodes:
+        node_sharding = node.meta["sharding"]
+        # None sharding means this node don't need sharding
+        if node_sharding is None:
+            continue
+
+        if node.op == "placeholder":
+            out_spec = node_sharding.output_spec
+            if not hasattr(out_spec, "from_local"):
+                local_val = _partition_val(node.meta["val"], out_spec)
+                # update node value
+                node.meta["val"] = local_val
+        elif node.op == "call_function":
+            out_spec = node_sharding.output_spec
+
+            # check if there's misaligned sharding, insert reshard if there is
+            expected_input_specs = node_sharding.input_specs
+            for idx, input_arg in enumerate(node.all_input_nodes):
+                input_arg_sharding = input_arg.meta["sharding"]
+
+                input_arg_spec = input_arg_sharding.output_spec
+                desired_spec = (
+                    out_spec
+                    if expected_input_specs is None
+                    else expected_input_specs[idx]
+                )
+                if input_arg_spec != desired_spec:
+                    input_arg_spec.tensor_meta = input_arg.meta["tensor_meta"]
+                    desired_spec.tensor_meta = input_arg.meta["tensor_meta"]
+                    input_arg_tensor = input_arg.meta["val"]
+
+                    # insert reshard operation
+                    def reshard_fn(local_tensor: torch.Tensor) -> torch.Tensor:
+                        return redistribute_local_tensor(
+                            local_tensor,
+                            input_arg_spec,
+                            desired_spec,
+                        )
+
+                    reshard_gm = make_fx(reshard_fn)(input_arg_tensor)
+                    reshard_gm_nodes = list(reshard_gm.graph.nodes)
+                    input_node = reshard_gm_nodes[0]
+                    with graph.graph.inserting_before(node):
+                        output_node = graph.graph.graph_copy(
+                            reshard_gm.graph,
+                            val_map={
+                                input_node: input_arg,
+                            },
+                        )
+                    node.replace_input_with(input_arg, output_node)
+
+            output_val = node.meta["val"]
+
+            if node.target == torch.ops.aten.repeat.default:
+                # for repeat op, we need to infer the repeat sizes
+                assert isinstance(output_val, torch.Tensor)
+                local_shape = compute_local_shape(
+                    output_val.shape, out_spec.mesh, out_spec.placements
+                )
+                input_shape = node.args[0].meta["val"].shape
+
+                def infer_repeat_sizes(repeated_shape, input_shape):
+                    repeated_size = [1] * len(repeated_shape)
+                    padded_length = len(repeated_shape) - len(input_shape)
+                    for i in range(len(repeated_shape)):
+                        if i < padded_length:
+                            repeated_size[i] = repeated_shape[i]
+                        else:
+                            repeated_size[i] = (
+                                repeated_shape[i] // input_shape[i - padded_length]
+                            )
+
+                    return repeated_size
+
+                node.update_arg(1, infer_repeat_sizes(local_shape, input_shape))
+
+            elif node.target in shape_adjustment_ops:
+                # for view related op that needs shape, adjust shape to local shape if needed
+                assert isinstance(output_val, torch.Tensor)
+                local_shape = compute_local_shape(
+                    output_val.shape, out_spec.mesh, out_spec.placements
+                )
+                shape_arg_num = shape_adjustment_ops[node.target]
+                node.update_arg(shape_arg_num, local_shape)
+
+            # convert output val to its local component
+            node.meta["val"] = _partition_val(output_val, out_spec)
+
+        elif node.op == "output":
+            break
+        else:
+            raise RuntimeError(f"op code {node} not supported")
+
+    # clean up the graph by removing sharding and partitioning related metadata
+    for node in graph.graph.nodes:
+        if "sharding" in node.meta:
+            del node.meta["sharding"]
+        if "val" in node.meta and isinstance(node.meta["val"], torch.Tensor):
+            local_tensor_meta = _extract_tensor_metadata(node.meta["val"])
+            node.meta["tensor_meta"] = local_tensor_meta
+
+    graph.graph.lint()
+    graph.recompile()
+    return graph
+
+
+def partition_data_parallel(
+    graph: GraphModule,
+    model: nn.Module,
+    optimizer: Optional[torch.optim.Optimizer],
+    params_buffers: Dict[str, torch.Tensor],
+    named_states: Dict[str, Any],
+    args: Tuple[Any, ...],
+    kwargs: Dict[str, Any],
+    mesh: DeviceMesh,
+    parallel_style: DataParallelStyle,
+    input_batch_dim: int,
+) -> GraphModule:
+    """Partition the graph to into a data parallel graph.
+
+    This function also shards/replicates the model parameters and optimizer states to DTensors.
+    """
+    num_params_buffers = len(params_buffers)
+    flattened_states = pytree.tree_leaves(named_states)
+    num_states = len(flattened_states)
+
+    changed = graph.graph.eliminate_dead_code()
+    if changed:
+        graph.recompile()
+
+    # 1. First build up data parallel strategies for the whole graph
+    strategy_map = build_data_parallel_strategies(
+        graph, num_params_buffers, num_states, mesh=mesh, batch_dim=input_batch_dim
+    )
+
+    # 2. Next we mark the data parallel strategy for each node base on
+    #    the parallel_style
+    mark_data_parallel_shardings(
+        graph,
+        num_parameters=num_params_buffers,
+        num_states=num_states,
+        dp_strategy_map=strategy_map,
+        parallel_mode=parallel_style,
+    )
+
+    # 3. Partition the single machine graph to the distribute graph
+    partitioned_graph = partitioner(graph)
+
+    # preserve node types for the expanded graph
+    for node in partitioned_graph.graph.nodes:
+        if node in strategy_map:
+            node_strategy = strategy_map[node]
+            if isinstance(node_strategy, DataParallelStrategy):
+                node.meta["node_type"] = node_strategy.node_type
+            elif isinstance(node_strategy, TupleStrategy):
+                node.meta["node_type"] = NodeType.NON_TENSOR
+            else:
+                raise RuntimeError(f"Unknown node strategy {node_strategy}")
+        else:
+            # if the nodes are expanded nodes (collectives), we mark them
+            # the same type as the input node.
+            input_node = node.all_input_nodes[0]
+            node.meta["node_type"] = input_node.meta["node_type"]
+
+    # 4. Last, inplace partition the weights and optim states to
+    #    DTensors base on the parallel style
+    accessor = NamedMemberAccessor(model)
+    for param_key, param in params_buffers.items():
+        placement: Placement = Replicate()
+        if parallel_style == DataParallelStyle.FULLY_SHARD:
+            placement = Shard(0)
+        elif parallel_style != DataParallelStyle.REPLICATE:
+            raise RuntimeError(f"parallel style {parallel_style} not supported yet")
+
+        dtensor_param = distribute_tensor(param, mesh, [placement])
+        # update re-parameterized module param dict and optim states dict to DTensor
+        params_buffers[param_key] = dtensor_param.to_local()
+        # update module parameters to DTensor
+        accessor.set_tensor(param_key, dtensor_param)
+
+        # update the optimizer state key and values to DTensor
+        if optimizer is not None and param in optimizer.state:
+            param_states = named_states[param_key]
+            param_dtensor_states = {}
+            for state_key, state_val in param_states.items():
+                if isinstance(state_val, torch.Tensor) and state_val.ndim > 0:
+                    # shard/replicate non-scalar tensors, for scalar tensor, we
+                    # don't do anything
+                    dtensor_state = distribute_tensor(state_val, mesh, [placement])
+                    param_dtensor_states[state_key] = dtensor_state
+                    param_states[state_key] = dtensor_state.to_local()
+                else:
+                    param_dtensor_states[state_key] = state_val
+
+            optimizer.state.pop(param)  # type: ignore[call-overload]
+            optimizer.state[dtensor_param] = param_dtensor_states  # type: ignore[index]
+
+    return partitioned_graph

venv/lib/python3.10/site-packages/torch/distributed/_spmd/distribute.py

@@ -0,0 +1,783 @@
+import logging
+import operator
+from dataclasses import dataclass
+from enum import auto, Enum
+from functools import partial
+from typing import Any, Callable, cast, Dict, List, Optional, Sequence, Tuple, Union
+
+import torch
+import torch.distributed._spmd.experimental_ops
+import torch.fx as fx
+
+from torch.distributed._spmd.comm_tensor import _get_tracer
+from torch.distributed._spmd.graph_utils import OP
+from torch.distributed._spmd.log_utils import get_logger
+
+from torch.distributed._tensor import DeviceMesh, DTensor
+from torch.distributed._tensor.op_schema import OpSchema
+from torch.distributed._tensor.placement_types import (
+    _Partial,
+    DTensorSpec,
+    Placement,
+    Replicate,
+    Shard,
+    TensorMeta,
+)
+from torch.distributed._tensor.redistribute import redistribute_local_tensor
+from torch.fx.experimental.proxy_tensor import make_fx, proxy_slot
+from torch.utils import _pytree as pytree
+from torch.utils._pytree import tree_flatten, tree_map, tree_map_only, tree_unflatten
+
+
+logger: Optional[logging.Logger] = None
+
+aten = torch.ops.aten
+
+
+class TrainingPhase(Enum):
+    FORWARD = auto()
+    BACKWARD = auto()
+
+
+@dataclass
+class Schema:
+    mesh: DeviceMesh
+    placements: List[Placement]
+
+
+@dataclass
+class DSymInt:
+    """DSymInt represents a value retrieved by a SymInt op from a DTensor.
+
+    DSymInt helps View and Factory ops to determine the placement and shape of the
+    output tensor, as those operators either do not have an input DTensor or
+    the input DTensor is insufficient to determine the output tensor's placement.
+    """
+
+    global_value: int  # value that the SymInt evaluates to
+    local_value: int  # vaue that this SymInt evaluates to on the local shard
+    mesh: DeviceMesh  # device mesh of the DTensor where this SymInt is retrieved from
+
+    def is_shard(self) -> bool:
+        return self.local_value != self.global_value
+
+    @classmethod
+    def from_node(cls, node: fx.Node, dtensor: DTensor) -> "DSymInt":
+        dim: int = 0
+        if node.target == aten.sym_size:
+            dim = cast(int, node.args[1])
+            return cls(
+                global_value=dtensor.size(dim),
+                local_value=dtensor.to_local().size(dim),
+                mesh=dtensor.device_mesh,
+            )
+        elif node.target == aten.sym_numel:
+            return cls(
+                global_value=dtensor.numel(),
+                local_value=dtensor.to_local().numel(),
+                mesh=dtensor.device_mesh,
+            )
+        elif node.target == aten.sym_stride:
+            dim = cast(int, node.args[1])
+            return cls(
+                global_value=dtensor.stride(dim),
+                local_value=dtensor.to_local().stride(dim),
+                mesh=dtensor.device_mesh,
+            )
+        else:
+            raise NotImplementedError(f"DSymInt does not support {node.target}")
+
+
+def _is_partial_dtensor(obj: Any) -> bool:
+    """Check if object is 1) DTensor and  2) with any placement of _Partial."""
+    if not isinstance(obj, DTensor):
+        return False
+
+    is_partial = False
+    for placement in obj.placements:
+        if isinstance(placement, _Partial):
+            is_partial = True
+            break
+
+    return is_partial
+
+
+def _dispatch_with_local_tensors(
+    op: torch._ops.OpOverload,
+    local_args: Tuple[Any, ...],
+    kwargs: Optional[Dict[str, Any]] = None,
+    specs: Optional[
+        Dict[
+            torch.Tensor,
+            Tuple[torch.Size, DeviceMesh, Sequence[Placement], Sequence[Placement]],
+        ]
+    ] = None,
+) -> Any:
+    if kwargs is None:
+        kwargs = {}
+    if specs is None:
+        specs = {}
+
+    def redistribute(arg: Any) -> Any:
+        tensor_shape, mesh, current_placement, target_placement = specs[arg]
+        tensor_meta = TensorMeta(
+            tensor_shape,
+            stride=arg.stride(),
+            dtype=arg.dtype,
+        )
+        current_spec = DTensorSpec(
+            mesh, tuple(current_placement), tensor_meta=tensor_meta
+        )
+        target_spec = DTensorSpec(
+            mesh, tuple(target_placement), tensor_meta=tensor_meta
+        )
+
+        return (
+            redistribute_local_tensor(arg, current_spec, target_spec)  # type: ignore[index]
+            if isinstance(arg, torch.Tensor) and arg in specs  # type: ignore[operator]
+            else arg
+        )
+
+    # TODO: this is broken because it won't redistributed potential tensors on the kwargs
+    return op(*tree_map(redistribute, local_args), **kwargs)
+
+
+# Figure out how to specify a type spec for the return specs value
+# without the entire structure.
+# pyre-fixme
+def _update_specs_for_redistribute(args, target_schema, redistribute):
+    # Code adapted from pack_args_kwargs_with_local_tensor
+    flatten_args, args_tree_spec = tree_flatten(args)
+    flatten_args_schema = pytree.tree_leaves(target_schema.args_schema)
+
+    specs: Dict[
+        torch.Tensor,
+        Tuple[
+            torch.Size,
+            DeviceMesh,
+            Sequence[Placement],
+            Sequence[Placement],
+        ],
+    ] = {}
+    for i, arg in enumerate(flatten_args):
+        if isinstance(arg, DTensor):
+            if redistribute:
+                specs[arg._local_tensor] = (
+                    arg.size(),
+                    flatten_args_schema[i].mesh,
+                    arg.placements,
+                    flatten_args_schema[i].placements,
+                )
+            flatten_args_schema[i] = arg._local_tensor
+
+    unflattened_args = tree_unflatten(flatten_args_schema, args_tree_spec)
+    return specs, unflattened_args
+
+
+# When no tensor redistribution is required, we only need to update non-tensor args
+# of the node according to op_schema and avoid building a GraphModule just for the
+# node.
+def _update_node_from_op_schema(node: torch.fx.Node, op_schema: OpSchema) -> None:
+    flat_args, args_tree_spec = tree_flatten(node.args)
+    flat_args_schema = pytree.tree_leaves(op_schema.args_schema)
+
+    def is_sym_int_or_int(arg: Union[int, torch.fx.Node]) -> bool:
+        if isinstance(arg, torch.fx.Node):
+            return arg.target in [
+                aten.sym_size,
+                aten.sym_numel,
+                aten.sym_stride,
+            ]
+        return isinstance(arg, int)
+
+    assert len(flat_args) == len(flat_args_schema)
+    for i, (arg, arg_schema) in enumerate(zip(flat_args, flat_args_schema)):
+        if is_sym_int_or_int(arg) and isinstance(arg_schema, int):
+            flat_args[i] = arg_schema
+
+    args = tree_unflatten(flat_args, args_tree_spec)
+    for idx, arg in enumerate(args):
+        node.update_arg(idx, arg)
+    return None
+
+
+def _remap_arg(node_to_obj: Dict[fx.Node, Any], arg: Any) -> Any:
+    if isinstance(arg, torch.fx.Node):
+        obj = node_to_obj[arg]
+        if _get_tracer():
+            # This is a shared arg, already has a tracer from previous
+            # tracing. Delete the tracer.
+            del cast(Dict[Any, Any], obj.__dict__)[proxy_slot]
+        return obj
+    else:
+        return arg
+
+
+def unpack_sizes_and_dims(
+    sizes: List[Union[DSymInt, int]], mesh: DeviceMesh
+) -> Tuple[List[int], List[Placement]]:
+    local_sizes: List[int] = [
+        s.local_value if isinstance(s, DSymInt) else s for s in sizes
+    ]
+    placements: List[Placement] = [
+        Shard(i)
+        for i, a in enumerate(sizes)
+        if (isinstance(a, DSymInt) and a.is_shard())
+    ] or [Replicate()]
+
+    assert len(placements) == mesh.ndim, (
+        f"The number of sharded dimensions ({len(placements)}) must "
+        f"match number of dimensions in device mesh ({mesh.ndim})."
+    )
+
+    return local_sizes, placements
+
+
+def binop_sym_int_consumer_rule(node: fx.Node, args: Tuple[Any, ...]) -> DTensor:
+    assert len(args) == 2, f"Expect two args but got op {node.target} with args {args}"
+    assert isinstance(
+        args[0], DTensor
+    ), f"Expect 1st argument to be DTensor but got {args[0]}"
+    assert isinstance(args[1], list), f"Expect 2nd argument as list but got {args[1]}"
+
+    # extract sharded dimensions in the size list, the output DTensor should
+    # follow these placements.
+    local_sizes, placements = unpack_sizes_and_dims(args[1], args[0].device_mesh)
+
+    # set node args to real int sizes.
+    node.args = (node.args[0], local_sizes)
+    op = cast(torch._ops.OpOverload, node.target)
+    return DTensor.from_local(
+        local_tensor=op(args[0]._local_tensor, local_sizes),
+        device_mesh=args[0].device_mesh,
+        placements=placements,
+        run_check=False,
+    )
+
+
+def slice_backwad_sym_int_consumer_rule(
+    node: fx.Node, args: Tuple[Any, ...]
+) -> DTensor:
+    grad_output, input_sizes, dim, start, end, step = args
+
+    local_sizes: List[int] = [
+        s.local_value if isinstance(s, DSymInt) else s for s in input_sizes
+    ]
+
+    input_tensor = torch.zeros(
+        local_sizes, device=grad_output.device, dtype=grad_output.dtype
+    )
+    return DTensor.from_local(
+        local_tensor=torch.slice_scatter(
+            input_tensor, grad_output.to_local(), dim, start, end, step
+        ),
+        device_mesh=grad_output.device_mesh,
+        placements=grad_output.placements,
+        run_check=False,
+    )
+
+
+def factory_with_sizes_rule(
+    node: fx.Node,
+    args: Tuple[Any, ...],
+    kwargs: Dict[str, Any],
+    default_mesh: DeviceMesh,
+) -> DTensor:
+    flat_args = pytree.arg_tree_leaves(*args)
+    assert not any(isinstance(a, DTensor) for a in flat_args), (
+        f"Not expect DTensor argument for factory op, but got {node.target} "
+        f"with arguments {args}."
+    )
+    assert isinstance(args[0], list), f"Expect 2nd argument as list but got {args[1]}"
+
+    local_sizes, placements = unpack_sizes_and_dims(args[0], default_mesh)
+    node.args = (local_sizes, *args[1:])
+    op = cast(torch._ops.OpOverload, node.target)
+    return DTensor.from_local(
+        local_tensor=op(*node.args, **kwargs),
+        device_mesh=default_mesh,
+        placements=placements,
+        run_check=False,
+    )
+
+
+def factory_arange_rule(
+    node: fx.Node,
+    args: Tuple[Any, ...],
+    kwargs: Dict[str, Any],
+    default_mesh: DeviceMesh,
+) -> DTensor:
+    node.args = tree_map(lambda a: a.local_value if isinstance(a, DSymInt) else a, args)
+    op = cast(torch._ops.OpOverload, node.target)
+    return DTensor.from_local(
+        local_tensor=op(*node.args, **kwargs),
+        device_mesh=default_mesh,
+        placements=[Replicate()],
+        run_check=False,
+    )
+
+
+def default_factory_op_rule(
+    node: fx.Node,
+    args: Tuple[Any, ...],
+    kwargs: Dict[str, Any],
+    default_mesh: DeviceMesh,
+) -> DTensor:
+    node.args, node.kwargs = args, kwargs
+    op = cast(torch._ops.OpOverload, node.target)
+    return DTensor.from_local(
+        local_tensor=op(*node.args, **node.kwargs),
+        device_mesh=default_mesh,
+        placements=[Replicate()],
+        run_check=False,
+    )
+
+
+# Dispatch override for view and factory ops that consume SymInt arguments,
+# where the output spec should follow dimension placement where the SymInt comes
+# from.
+VIEW_SYM_INT_CONSUMERS: Dict[torch._ops.OpOverload, Callable] = {
+    aten._unsafe_view.default: binop_sym_int_consumer_rule,
+    aten.expand.default: binop_sym_int_consumer_rule,
+    aten.slice_backward.default: slice_backwad_sym_int_consumer_rule,
+    aten.view.default: binop_sym_int_consumer_rule,
+}
+
+FACTORY_SYM_INT_CONSUMERS: Dict[torch._ops.OpOverload, Callable] = {
+    aten.full.default: factory_with_sizes_rule,
+    aten.arange.default: factory_arange_rule,
+    aten.arange.start: factory_arange_rule,
+}
+
+
+# Dispatch override for factory ops, as DTensor cannot propogate sharding spec
+# without DTensor inputs.
+FACTORY_OPS: Dict[torch._ops.OpOverload, Callable] = {
+    aten.scalar_tensor.default: default_factory_op_rule,
+    aten.arange.start: default_factory_op_rule,
+    aten.zeros.default: default_factory_op_rule,
+}
+
+
+def _get_dtensor_dispatch_graph(
+    node: fx.Node,
+    node_to_obj: Dict[fx.Node, Any],
+    *,
+    force_make_fx: bool = False,
+    default_mesh: Optional[DeviceMesh] = None,
+) -> Optional[fx.GraphModule]:
+    with torch.no_grad():
+        # Args should be a list of objects post remapping.
+        args = tree_map(partial(_remap_arg, node_to_obj), node.args)
+        kwargs = tree_map(partial(_remap_arg, node_to_obj), node.kwargs)
+
+        op_overload = cast(torch._ops.OpOverload, node.target)
+
+        if any(
+            a.is_shard()
+            for a in pytree.arg_tree_leaves(*args)
+            if isinstance(a, DSymInt)
+        ):
+            if op_overload in VIEW_SYM_INT_CONSUMERS:
+                assert len(kwargs) == 0, f"Expect empty kwargs, but got {kwargs}"
+                node_to_obj[node] = VIEW_SYM_INT_CONSUMERS[op_overload](node, args)
+                return None
+            elif op_overload in FACTORY_SYM_INT_CONSUMERS:
+                assert default_mesh is not None, "Requires default mesh for factory ops"
+                node_to_obj[node] = FACTORY_SYM_INT_CONSUMERS[op_overload](
+                    node, args, kwargs, default_mesh
+                )
+                return None
+            else:
+                assert isinstance(logger, logging.Logger)
+                logger.warning(
+                    "Assuming using local_value from SymInt for %s"
+                    "is mathematically correct. Full args are %s.",
+                    op_overload,
+                    args,
+                )
+
+        if node.target == aten.view.default:
+            # HACK: this is a hack to get around with the fact that some
+            # view operations on a "global" tensor is invalid usage
+            # but somehow the view operation on the batch input might hit it
+            # so we convert the view op to reshape before calling DTensor
+            op_overload = aten.reshape.default
+
+        # DSymInt args are not sharded on any dimension, local value and global
+        # value should be the same
+        args = tree_map(lambda a: a.local_value if isinstance(a, DSymInt) else a, args)
+        kwargs = tree_map(
+            lambda a: a.local_value if isinstance(a, DSymInt) else a, kwargs
+        )
+
+        if op_overload in FACTORY_OPS:
+            # Don't pass factory ops to DTensor dispatch, as DTensor cannot
+            # propagate sharding spec without DTensor inputs.
+            node_to_obj[node] = FACTORY_OPS[op_overload](
+                node, args, kwargs, default_mesh
+            )
+            return None
+
+        dispatch = partial(
+            _dispatch_with_local_tensors,
+            op_overload,
+            kwargs=kwargs,
+            specs=args,
+        )
+
+        gm = make_fx(dispatch, _allow_non_fake_inputs=False)(args)
+        # FIXME(@wanchaol, @mrshenli): the above seems to accidentally captured
+        # DeviceMesh tensor ops when handling inplace operators? The ``_to_copy`` is
+        # not connected to graph output. So, using DCE to get rid of it, but this
+        # doesn't look correct.
+        #
+        # The following operators appear in the captured graph, where the dtype is
+        # torch.int64.
+        #
+        # get_attr       _tensor_constant0  _tensor_constant0         ()
+        # call_function  transpose          aten.transpose.int        (_tensor_constant0, -1, 0)
+        # call_function  view               aten.view.default         (transpose, [-1, 2])
+        # call_function  view_1             aten.view.default         (view, [2])
+        # call_function  _to_copy           aten._to_copy.default     (view_1,)
+        gm.graph.eliminate_dead_code()
+
+        return gm
+
+
+def _build_dummy_add_graph(
+    dt: DTensor, node_to_obj: Dict[fx.Node, Any]
+) -> Tuple[fx.GraphModule, Any]:
+    """Create a graph for a dummy add function from a partial DTensor.
+
+    This dummy add is used for triggering all_reduce on a Partial DTensor
+    during the DTensor expansion of the traced graph.
+    Also returns the actual DTensor after resharding.
+    """
+
+    def dummy_add(grad: torch.Tensor, zero: torch.Tensor) -> torch.Tensor:
+        return grad + zero
+
+    grad: torch.Tensor = dt._local_tensor
+    zero: torch.Tensor = torch.zeros_like(dt._local_tensor)
+
+    traced_add = make_fx(dummy_add)(grad, zero)
+
+    placeholders = [n for n in traced_add.graph.nodes if n.op == OP.PLACEHOLDER]
+    call_functions = [n for n in traced_add.graph.nodes if n.op == OP.CALL_FUNCTION]
+    assert len(placeholders) == 2
+    assert len(call_functions) == 1
+    node_to_obj[placeholders[0]] = dt
+    node_to_obj[placeholders[1]] = DTensor.from_local(
+        zero, dt.device_mesh, [Replicate()], run_check=False
+    )
+
+    traced_dispatch = _get_dtensor_dispatch_graph(
+        call_functions[0], node_to_obj, force_make_fx=True
+    )
+    assert traced_dispatch is not None
+
+    # TODO(anj): This depends on the call function node -> actual DTensor output
+    # mapping that we want to avoid for SPMD expansion
+    return traced_dispatch, node_to_obj[call_functions[0]]
+
+
+def _convert_output(
+    gm: fx.GraphModule,
+    node: fx.Node,
+    node_to_obj: Dict[fx.Node, Any],
+) -> fx.Node:
+    new_args = []
+    has_partial = False
+    for argument in node.args[0]:  # type: ignore[union-attr]
+        if not isinstance(argument, fx.Node):
+            new_args.append(argument)
+            continue
+
+        obj = node_to_obj[argument]
+
+        if not _is_partial_dtensor(obj):
+            new_args.append(argument)
+            continue
+
+        has_partial = True
+
+        # we know it's a dtensor from is partial DT check...
+        dt = cast(DTensor, obj)
+
+        traced_dispatch, result_obj = _build_dummy_add_graph(dt, node_to_obj)
+
+        wait = [
+            n
+            for n in traced_dispatch.graph.nodes
+            if n.name == "wait_comm" or n.name == "wait_tensor"
+        ]
+        add = [n for n in traced_dispatch.graph.nodes if n.name == "add"]
+        assert len(wait) == 1 and len(add) == 1
+
+        # remove add node and replace it with wait node
+        add[0].replace_all_uses_with(wait[0])
+        traced_dispatch.graph.eliminate_dead_code()
+        # also update the actual DTensor corresponding to the node
+        # TODO(anj): We require mapping of the final DTensor output to the wait
+        # comm node.
+        node_to_obj[wait[0]] = result_obj
+
+        value_remap: Dict[fx.Node, fx.Node] = {}
+        for dtn in traced_dispatch.graph.nodes:
+            if dtn.op == OP.PLACEHOLDER:
+                # do nothing, ignore placeholders, as it has
+                # already been prepared in value_remap
+                value_remap[dtn] = argument
+            elif dtn.op == OP.OUTPUT:
+                assert (
+                    len(dtn.args) == 1 and len(dtn.args[0]) == 1
+                ), f"Expecting single output, but got {dtn.args} {len(dtn.args)}"
+                new_args.append(value_remap[dtn.args[0][0]])
+                # the concrete DTensor value of output was added when creating the
+                # inner graph (in _build_dummy_add_graph). Just add it to the final
+                # output node so that we can report the final output specs correctly.
+                # TODO(anj): We are depending on the concrete DTensor output of the dummy add.
+                node_to_obj[value_remap[dtn.args[0][0]]] = node_to_obj[dtn.args[0][0]]
+
+            else:
+                if dtn.op == OP.GET_ATTR:
+                    setattr(
+                        gm,
+                        dtn.target,
+                        getattr(traced_dispatch, dtn.target),
+                    )
+                with gm.graph.inserting_before(node):
+                    value_remap[dtn] = gm.graph.node_copy(dtn, lambda n: value_remap[n])
+    if has_partial:
+        gm.graph.erase_node(node)
+        return gm.graph.output(new_args)
+    else:
+        return node
+
+
+def _rebuild_graph(
+    gm: fx.GraphModule,
+    node_replacements: Dict[torch.fx.Node, torch.fx.GraphModule],
+) -> None:
+    # replace nodes in local traced graph with DTensor's dispatch graph
+    for node in gm.graph.nodes:
+        if node not in node_replacements:
+            continue
+
+        traced_dispatch = node_replacements[node]
+        # Map DT's dispatch graph input placeholder nodes to the ones in
+        # local traced graph. It uses index-based accessing, which is
+        # brittle, just for testing purpose.
+        flatten_args = pytree.arg_tree_leaves(*node.args)
+        i, value_remap = 0, {}
+        for dtn in traced_dispatch.graph.nodes:
+            if dtn.op == OP.PLACEHOLDER:
+                value_remap[dtn] = flatten_args[i]
+                i += 1
+
+        # insert DT's dispatch graph to traced local graph.
+        with gm.graph.inserting_before(node):
+            for dtn in traced_dispatch.graph.nodes:
+                if dtn.op == OP.PLACEHOLDER:
+                    # do nothing, ignore placeholders, as it has already
+                    # been prepared in value_remap
+                    pass
+                elif dtn.op == OP.OUTPUT:
+                    assert (
+                        len(dtn.args) == 1
+                    ), f"Expecting single output, but got {dtn.args} {len(dtn.args[0])}"
+                    outputs = dtn.args[0]
+                    # we currently support two very specific types of output
+                    # 1. single output
+                    # 2. multiple outputs resulting from getitem of all elements of tuple
+                    if len(outputs) == 1:
+                        # for single output, we replace the node with the single node
+                        output = outputs[0]
+                    else:
+                        # for multiple outputs, we check that these outputs correspond
+                        # to all elements of a tuple. In that case, we replace
+                        # uses of the output directly with the original tuple
+                        source = None
+                        for i, out in enumerate(outputs):
+                            # we allow None outputs for certain items in the tuple
+                            if out is None:
+                                continue
+                            assert out.op == "call_function"
+                            assert out.target.__module__ == "_operator"
+                            assert out.target.__name__ == "getitem"
+                            assert source is None or source == out.args[0]
+                            source = out.args[0]
+                            assert out.args[1] == i
+                        assert source is not None
+                        output = source
+
+                    new_node = value_remap[output]
+                    node.replace_all_uses_with(new_node)
+                else:
+                    value_remap[dtn] = gm.graph.node_copy(dtn, lambda n: value_remap[n])
+                    if all(
+                        isinstance(n.target, torch._ops.OpOverload)
+                        and n.target._schema.name.startswith(
+                            ("aten::_foreach", "aten::_fused_adam")
+                        )
+                        for n in [dtn, node]
+                    ):
+                        # FIXME(@mrshenli): This is a temporary solution enable
+                        # foreach ops. The problem is that foreach ops returns
+                        # List[Tensor], but make_fx will flatten that before
+                        # passing those tensors to output node, which will
+                        # introduce additional getitem nodes. These redundant
+                        # getitem nodes breaks graph correctness as we cannot do
+                        # getitem(getitem(foreach_out, 0), 0). This temporary
+                        # solution skips getitem nodes in DTensor expanded
+                        # subgraphs.
+                        node.replace_all_uses_with(value_remap[dtn])
+                        break
+            # explicitly erase node instead of relying on DCE, as DCE does not
+            # remove inplace copy_ correctly.
+            gm.graph.erase_node(node)
+
+    gm.graph.eliminate_dead_code()
+    gm.recompile()
+
+
+def _get_last_consumer_to_nodes(
+    graph: fx.Graph,
+) -> Dict[fx.Node, List[fx.Node]]:
+    # Run through reverse nodes and record the first instance of a use
+    # of a given node. This represents the *last* use of the node in the
+    # execution order of the program, which we will use to free unused
+    # values
+    node_to_last_consumer: Dict[fx.Node, fx.Node] = {}
+    last_consumer_to_nodes: Dict[fx.Node, List[fx.Node]] = {}
+
+    def _register_final_consumer(arg_node: fx.Node, consumer: fx.Node) -> None:
+        if arg_node not in node_to_last_consumer:
+            node_to_last_consumer[arg_node] = consumer
+            last_consumer_to_nodes.setdefault(consumer, []).append(arg_node)
+
+    for node in reversed(graph.nodes):
+        fx.node.map_arg(
+            node.args, lambda arg_node: _register_final_consumer(arg_node, node)
+        )
+        fx.node.map_arg(
+            node.kwargs,
+            lambda kwarg_node: _register_final_consumer(kwarg_node, node),
+        )
+
+    return last_consumer_to_nodes
+
+
+def _convert_to_distributed(
+    gm: fx.GraphModule,
+    inps: List[torch.Tensor],
+    schemas: List[Schema],
+    default_mesh: Optional[DeviceMesh] = None,
+    _allow_partial: bool = False,
+) -> Tuple[fx.GraphModule, Dict[str, Schema]]:
+    """Transform a graph module to a distributed graph module.
+
+    Returns:
+        - transformed graph module
+        - map from output name to DTensorSpec
+
+    """
+    global logger
+    logger = get_logger("spmd_exp")
+    operators = {getattr(operator, name) for name in operator.__all__}
+    node_to_obj: Dict[fx.Node, Any] = {}
+    # map local op node in traced_f to its corresponding subgraph of
+    # DTensor ops.
+    node_replacements: Dict[torch.fx.Node, torch.fx.GraphModule] = {}
+
+    last_consumer_to_nodes = _get_last_consumer_to_nodes(gm.graph)
+
+    output_schemas: Dict[str, Schema] = {}
+    for i, node in enumerate(gm.graph.nodes):
+        assert logger is not None
+        logger.info("node%s: op=%s target=%s", i, node.op, node.target)
+        if node.op == OP.PLACEHOLDER:
+            assert i < len(
+                inps
+            ), f"got more placeholder nodes ({i + 1}) than inputs ({len(inps)})"
+
+            # our example inputs are local shards. Create DTensors from them.
+            node_to_obj[node] = DTensor.from_local(
+                inps[i].clone(),  # use clone to avoid modifications from inplace ops
+                schemas[i].mesh,
+                schemas[i].placements,
+                # prevent running this collective in backwards pass
+                run_check=False,
+            )
+        elif isinstance(node.target, torch._ops.OpOverloadPacket):
+            dtensor = cast(DTensor, node_to_obj[node.args[0]])
+            node_to_obj[node] = DSymInt.from_node(node, dtensor)
+        elif isinstance(node.target, torch._ops.OpOverload):
+            replacement = _get_dtensor_dispatch_graph(
+                node, node_to_obj, default_mesh=default_mesh
+            )
+            if replacement is not None:
+                node_replacements[node] = replacement
+        elif node.op == OP.OUTPUT:
+            if not _allow_partial:
+                # Returns an expanded dummy add node that ensures
+                # that the partial output tensor has been converted
+                # to a replicated tensor.
+                node = _convert_output(gm, node, node_to_obj)
+
+            # Save output sharding for the inputs to backward pass.
+            # TODO(anj): Pipe the output schema for the BW pass
+            # instead of requiring the full output DTensor to be
+            # materialized.
+            for inp_arg in node.args[0]:
+                if isinstance(inp_arg, fx.Node):
+                    obj = node_to_obj[inp_arg]
+                    if isinstance(obj, DTensor):
+                        output_schemas[inp_arg.name] = Schema(
+                            obj.device_mesh, obj.placements  # type: ignore[arg-type]
+                        )
+        elif node.op == OP.CALL_FUNCTION:
+            args = tree_map(partial(_remap_arg, node_to_obj), node.args)
+            kwargs = tree_map(partial(_remap_arg, node_to_obj), node.kwargs)
+
+            dsymints = list(
+                filter(lambda a: isinstance(a, DSymInt), args + tuple(kwargs.values()))
+            )
+
+            if node.target in operators and len(dsymints) > 0:
+                assert all(
+                    dsymints[0].mesh == d.mesh for d in dsymints
+                ), "all DSymInts must have the same mesh. "
+
+                local_args = tree_map_only(DSymInt, lambda a: a.local_value, args)
+                local_kwargs = tree_map_only(DSymInt, lambda a: a.local_value, kwargs)
+
+                global_args = tree_map_only(DSymInt, lambda a: a.global_value, args)
+                global_kwargs = tree_map_only(DSymInt, lambda a: a.global_value, kwargs)
+
+                node.args = local_args
+                node.kwargs = local_kwargs
+
+                node_to_obj[node] = DSymInt(
+                    local_value=node.target(*local_args, **local_kwargs),
+                    global_value=node.target(*global_args, **global_kwargs),
+                    mesh=dsymints[0].mesh,
+                )
+            else:
+                assert len(dsymints) == 0, (
+                    "SPMD expansion does not support SymInt in non-operator "
+                    f"nodes, got {node.target}."
+                )
+                node_to_obj[node] = node.target(*args, **kwargs)
+        else:
+            raise ValueError(f"Unrecognized node.op type {node.op}")
+
+        if node in last_consumer_to_nodes:
+            # Save memory by deleting objs that wont be used anymore.
+            for arg_node in last_consumer_to_nodes[node]:
+                del node_to_obj[arg_node]
+
+    _rebuild_graph(gm, node_replacements)
+
+    return gm, output_schemas

venv/lib/python3.10/site-packages/torch/distributed/_spmd/experimental_ops.py

@@ -0,0 +1,455 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates
+from typing import cast, List, Optional, Sequence, Tuple
+
+import torch
+from torch.distributed._tensor.op_schema import OpSchema, OutputSharding
+from torch.distributed._tensor.ops.common_rules import pointwise_rule
+from torch.distributed._tensor.ops.utils import register_prop_rule
+
+from torch.distributed._tensor.placement_types import (
+    _Partial,
+    DTensorSpec,
+    Placement,
+    Replicate,
+    Shard,
+    TensorMeta,
+)
+
+aten = torch.ops.aten  # pyre-ignore
+
+
+@register_prop_rule(  # pyre-ignore
+    [
+        aten._foreach_neg.default,
+        aten._foreach_reciprocal.default,
+        aten._foreach_sqrt.default,
+    ]
+)
+def _prop__foreach_unaop(op_schema: OpSchema) -> OutputSharding:
+    self = op_schema.args_schema[0]
+    assert isinstance(self, list) and all(isinstance(s, DTensorSpec) for s in self)
+    # FIXME(@mrshenli): for sqrt, this is only mathematically correct for
+    # Replicate and Shard tensor.
+    return OutputSharding(output_spec=self)
+
+
+@register_prop_rule(  # pyre-ignore
+    [
+        aten._foreach_add.List,
+        aten._foreach_div.List,
+        aten._foreach_mul.List,
+    ]
+)
+def _prop__foreach_binop_list(op_schema: OpSchema) -> OutputSharding:
+    self, other = op_schema.args_schema[:2]
+    scalar = None if len(op_schema.args_schema) < 3 else op_schema.args_schema[2]
+    assert isinstance(self, list) and all(
+        isinstance(s, DTensorSpec) for s in self
+    ), f"Expect a List[DTensorSpec] but got {self}"
+    assert isinstance(other, list) and all(
+        isinstance(o, DTensorSpec) for o in other
+    ), f"Expect a List[DTensorSpec] but got {other}"
+    assert len(self) == len(other), (
+        "Two tensor lists must match in length, "
+        f"but got {len(self)} and {len(other)}"
+    )
+
+    if any(s != o for s, o in zip(self, other)):
+        # If DTensorSpec for the two operand do not match, suggest using
+        # self's DTensorSpec. This will trigger allreduce if other is partial
+        # and self is replicated.
+        return OutputSharding(
+            output_spec=None,
+            schema_suggestions=[
+                OpSchema(
+                    op=op_schema.op,
+                    args_schema=(self, self, scalar) if scalar else (self, self),
+                    kwargs_schema=op_schema.kwargs_schema,
+                )
+            ],
+        )
+    else:
+        return OutputSharding(output_spec=self)
+
+
+@register_prop_rule(  # pyre-ignore
+    [
+        aten._foreach_add.Scalar,
+        aten._foreach_div.Scalar,
+        aten._foreach_mul.Scalar,
+        aten._foreach_sub.Scalar,
+    ]
+)
+def _prop__foreach_binop_scalar(op_schema: OpSchema) -> OutputSharding:
+    self, scalar = op_schema.args_schema
+    assert isinstance(self, list) and all(isinstance(s, DTensorSpec) for s in self)
+    assert not isinstance(scalar, list)
+    return OutputSharding(output_spec=self)
+
+
+@register_prop_rule(  # pyre-ignore
+    [
+        aten._foreach_addcdiv.Scalar,
+        aten._foreach_addcmul.Scalar,
+    ]
+)
+def _prop__foreach_addcop_scalar(op_schema: OpSchema):
+    self, tensor1, tensor2 = op_schema.args_schema[:3]
+    scalar = None if len(op_schema.args_schema) < 4 else op_schema.args_schema[3]
+    assert isinstance(self, list) and all(isinstance(s, DTensorSpec) for s in self)
+    assert isinstance(tensor1, list) and all(isinstance(s, DTensorSpec) for s in self)
+    assert isinstance(tensor2, list) and all(isinstance(s, DTensorSpec) for s in self)
+    if any(s != t1 or s != t2 for s, t1, t2 in zip(self, tensor1, tensor2)):
+        # If DTensorSpec for the two operand do not match, suggest using
+        # self's DTensorSpec. This will trigger allreduce if other is partial
+        # and self is replicated.
+        return OutputSharding(
+            output_spec=None,
+            schema_suggestions=[
+                OpSchema(
+                    op=op_schema.op,
+                    args_schema=(self, self, self, scalar)
+                    if scalar
+                    else (self, self, self),
+                    kwargs_schema=op_schema.kwargs_schema,
+                )
+            ],
+        )
+    else:
+        return OutputSharding(output_spec=self)
+
+
+@register_prop_rule([aten._foreach_pow.ScalarAndTensor])  # pyre-ignore
+def _prop__foreach_pow_scalar_and_tensor(op_schema: OpSchema):
+    scala, exponent = op_schema.args_schema
+    assert isinstance(exponent, list) and all(
+        isinstance(s, DTensorSpec) for s in exponent
+    )
+    return OutputSharding(output_spec=exponent)
+
+
+@register_prop_rule([aten._fused_adam.default])  # pyre-ignore
+def _prop__fused_adam(op_schema: OpSchema):
+    NT = 5
+    tesnor_list_args: Tuple[List[DTensorSpec]] = op_schema.args_schema[:NT]  # type: ignore[assignment]
+
+    assert all(isinstance(schema, list) for schema in tesnor_list_args)
+    assert all(
+        isinstance(s, DTensorSpec) for schema in tesnor_list_args for s in schema
+    )
+
+    tensor_schemas: Tuple[List[DTensorSpec]] = [  # type: ignore[assignment]
+        schema for schema in tesnor_list_args if len(schema)
+    ]
+
+    assert all(len(s) == len(tensor_schemas[0]) for s in tensor_schemas), (
+        "expect the same number of gradients and states, but got "
+        f"{[len(s) for s in tensor_schemas]}."
+    )
+
+    if any(any(t != ts[0] for t in ts) for ts in zip(*tensor_schemas)):
+        new_schemas: Tuple[List[DTensorSpec]] = tuple(  # type: ignore[assignment]
+            op_schema.args_schema[0] if len(s) else s for s in tesnor_list_args
+        )
+        return OutputSharding(
+            output_spec=None,
+            schema_suggestions=[
+                OpSchema(
+                    op=op_schema.op,
+                    args_schema=new_schemas + op_schema.args_schema[NT:],
+                    kwargs_schema=op_schema.kwargs_schema,
+                )
+            ],
+        )
+    else:
+        return OutputSharding(output_spec=(op_schema.args_schema[0],) * NT)  # type: ignore[arg-type]
+
+
+@register_prop_rule(aten.nll_loss_forward.default)  # pyre-ignore
+def _prop_nll_loss_forward(op_schema: OpSchema) -> OutputSharding:
+    self, target = op_schema.args_schema[:2]
+    assert isinstance(self, DTensorSpec)
+    assert isinstance(target, DTensorSpec)
+    if self.placements != target.placements:
+        # Self and target must match in placements, which should be shard along
+        # batch dimension in data parallell use cases. Force redistribute.
+
+        # need to create a new self instead return (target, target) as target
+        # and self might not match in shape.
+        new_self = DTensorSpec(
+            mesh=self.mesh,
+            placements=target.placements,
+            tensor_meta=self.tensor_meta,
+        )
+        return OutputSharding(
+            output_spec=None,
+            schema_suggestions=[
+                OpSchema(
+                    op=op_schema.op,
+                    args_schema=(new_self, target) + op_schema.args_schema[2:],
+                    kwargs_schema=op_schema.kwargs_schema,
+                )
+            ],
+        )
+    else:
+        return OutputSharding(
+            output_spec=(
+                # by default, nll_loss_forward conducts a reduction and returns
+                # a scalar tensor, and hence the _Partial placements.
+                DTensorSpec(mesh=self.mesh, placements=(_Partial(),)),
+                # the 2nd output total_weight is always a scalar tensor
+                DTensorSpec(mesh=self.mesh, placements=(Replicate(),)),
+            )
+        )
+
+
+@register_prop_rule(aten.nll_loss_backward.default)  # pyre-ignore
+def _prop_nll_loss_backward(op_schema: OpSchema) -> OutputSharding:
+    grad_output, self = op_schema.args_schema[:2]
+    assert isinstance(grad_output, DTensorSpec)
+    assert isinstance(self, DTensorSpec)
+    return OutputSharding(output_spec=self)
+
+
+@register_prop_rule(aten.stack.default)
+def _prop_stack(op_schema: OpSchema) -> OutputSharding:
+    tensors = op_schema.args_schema[0]
+    dim = 0 if len(op_schema.args_schema) == 1 else cast(int, op_schema.args_schema[1])
+    assert (
+        isinstance(tensors, list) and len(tensors) > 0
+    ), "expect at least one tensor to stack"
+    assert all(
+        isinstance(t, DTensorSpec) for t in tensors
+    ), f"expect a list of DTensorSpecs, but got {tensors}"
+    assert all(
+        t.shape == tensors[0].shape for t in tensors
+    ), f"expect all tensors to have the same shape, but got {tensors}."
+    # TODO: provide schema_suggestions when placements do not match
+    assert all(
+        t.placements == tensors[0].placements for t in tensors
+    ), f"expect all tensors to have the same placements, but got {tensors}."
+    assert all(
+        not p.is_shard(dim) for p in tensors[0].placements
+    ), "DTensor does not support stack on sharded dimension."
+
+    return OutputSharding(
+        output_spec=DTensorSpec(mesh=tensors[0].mesh, placements=tensors[0].placements)
+    )
+
+
+@register_prop_rule(aten.select.int)
+def _prop_select(op_schema: OpSchema) -> OutputSharding:
+    tensor, dim = op_schema.args_schema[:2]
+    assert isinstance(tensor, DTensorSpec)
+    assert isinstance(dim, int)
+    placements: Sequence[Placement] = tensor.placements
+    assert all(
+        not p.is_shard(dim) for p in placements
+    ), "DTensor does not support select on sharded dimension."
+
+    # select will remove one dimension, decrement dim of Shard placements by 1
+    # if they are larger than dim.
+    new_placements: List[Placement] = []
+    for p in placements:
+        # Using isinstance instead of is_shard so that mypy won't complain
+        # about accessing dim attribute.
+        if isinstance(p, Shard) and p.dim > dim:
+            new_placements.append(Shard(p.dim - 1))
+        else:
+            new_placements.append(p)
+
+    return OutputSharding(
+        output_spec=DTensorSpec(mesh=tensor.mesh, placements=tuple(new_placements))
+    )
+
+
+@register_prop_rule(aten.native_layer_norm.default)  # pyre-ignore
+def _prop_native_layer_norm(op_schema: OpSchema) -> OutputSharding:
+    input, normalized_shape, weight, bias, eps = op_schema.args_schema
+    assert isinstance(input, DTensorSpec)
+    assert isinstance(normalized_shape, (tuple, list))
+    if weight is not None:
+        assert isinstance(weight, DTensorSpec)
+        assert all(isinstance(p, Replicate) for p in weight.placements)
+    if bias is not None:
+        assert isinstance(bias, DTensorSpec)
+        assert all(isinstance(p, Replicate) for p in bias.placements)
+    # only the left-most (non-normalized) dimensions of the input can be sharded
+    batch_ndim = len(input.shape) - len(normalized_shape)
+    assert all(
+        isinstance(p, Replicate) or (isinstance(p, Shard) and p.dim < batch_ndim,)
+        for p in input.placements
+    )
+    stats_spec = DTensorSpec(
+        mesh=input.mesh,
+        placements=input.placements,
+    )
+    return OutputSharding(output_spec=(input, stats_spec, stats_spec))
+
+
+@register_prop_rule(aten.native_layer_norm_backward.default)  # pyre-ignore
+def _prop_native_layer_norm_backward(op_schema: OpSchema) -> OutputSharding:
+    (
+        grad,
+        input,
+        normalized_shape,
+        result1,
+        result2,
+        weight,
+        bias,
+        grad_input_mask,
+    ) = op_schema.args_schema
+    assert isinstance(grad, DTensorSpec)
+    assert isinstance(grad_input_mask, (list, tuple))
+    if weight is not None:
+        assert isinstance(weight, DTensorSpec)
+        assert all(isinstance(s, Replicate) for s in weight.placements)
+    if bias is not None:
+        assert isinstance(bias, DTensorSpec)
+        assert all(isinstance(s, Replicate) for s in bias.placements)
+    # ensure sharding on dim 0, which will trigger the "Partial" output on
+    # weight and bias grads
+    assert any(
+        isinstance(s, Shard) and s.dim == 0 for s in grad.placements
+    ), f"Got {grad.placements}"
+    weight_grad = (
+        DTensorSpec(
+            mesh=weight.mesh,
+            placements=tuple([_Partial()] * weight.mesh.ndim),
+        )
+        if weight
+        else None
+    )
+    bias_grad = (
+        DTensorSpec(
+            mesh=bias.mesh,
+            placements=tuple([_Partial()] * bias.mesh.ndim),
+        )
+        if bias
+        else None
+    )
+    return OutputSharding(
+        # NOTE: type errors below are legit. This is because DTensor currently
+        # doesn't support Optional return values. Need to be fixed in DTensor repo.
+        output_spec=(
+            grad if grad_input_mask[0] else None,
+            weight_grad if grad_input_mask[1] else None,
+            bias_grad if grad_input_mask[2] else None,
+        ),
+    )
+
+
+def _refine_sharding(
+    op_schema: OpSchema, active_dim: Optional[int]
+) -> Sequence[Placement]:
+    """Considers 2 first inputs of op_schema as having same shape, and returns suggested placement for a pointwise operation."""
+    # consider the operating dimension as a singleton to prevent sharding on it
+    # however, if active_dim is None, this means the input and output shapes are equal and
+    # we'll apply exactly the pointwise rule.
+
+    args_schema = []
+    for s in op_schema.args_schema[:2]:
+        assert isinstance(s, DTensorSpec) and s.tensor_meta is not None
+        args_schema.append(
+            DTensorSpec(
+                mesh=s.mesh,  # type: ignore[attr-defined]
+                placements=s.placements,  # type: ignore[attr-defined]
+                tensor_meta=TensorMeta(
+                    shape=torch.Size(
+                        s.shape[0:active_dim] + (1,) + s.shape[active_dim + 1 :]
+                    )
+                    if active_dim is not None
+                    else s.shape,
+                    stride=s.tensor_meta.stride,
+                    dtype=s.tensor_meta.dtype,
+                ),
+            )
+        )
+
+    op_schema = OpSchema(
+        op=op_schema.op,
+        args_schema=args_schema,  # type: ignore[arg-type]
+        kwargs_schema={},
+    )
+    output_sharding = pointwise_rule(op_schema, linearity=False)
+    if output_sharding.output_spec:
+        assert isinstance(output_sharding.output_spec, DTensorSpec)
+        return output_sharding.output_spec.placements
+    else:
+        assert output_sharding.schema_suggestions is not None
+        out_schema = output_sharding.schema_suggestions[0].args_schema[0]
+        assert isinstance(out_schema, DTensorSpec)
+        return tuple(out_schema.placements)
+
+
+@register_prop_rule(aten.slice_scatter.default)  # pyre-ignore
+def prop_slice_scatter(op_schema: OpSchema) -> OutputSharding:
+    # 1. number of dimensions in input and src need to match.
+    # 2. number of elements on all non-dim need to match between input and src.
+    # 3. numer of elements in src in dim need to match the slice size.
+    # Given the above:
+    # - We suggest for src to follow the sharding of input, except on the scatter dimension,
+    #   where our best bet for now is to make them replicated as a fall-back.
+    #   TODO: Ideally we'd like to make sure the output is re-sharded afterwards to keep input sharding.
+
+    defaults = (None, None, 0, None, None, 1)
+    input, src, dim, start, end, step = (
+        op_schema.args_schema + defaults[len(op_schema.args_schema) :]
+    )
+    assert isinstance(input, DTensorSpec)
+    assert isinstance(src, DTensorSpec)
+    assert isinstance(dim, int)
+
+    if dim < 0:
+        dim += input.ndim
+
+    # if the input shape and the output shape are the same on the operating dimension,
+    # this is effectively a no-op, so we just propagate sharding as we would do for
+    # pointwise, no exceptions.
+    if input.shape[dim] == src.shape[dim]:
+        assert start == 0
+        assert end >= src.shape[dim]  # type: ignore[operator]
+        dim = None
+
+    # apply sharding refinement as implemented in pointwise_rule
+    input_suggestion = list(_refine_sharding(op_schema, dim))
+    # apply the exception -- disallow sharding on the operating dimension.
+    for i, p in enumerate(input_suggestion):
+        if isinstance(p, Shard) and p.dim == dim:
+            input_suggestion[i] = Replicate()
+    input_suggestion = tuple(input_suggestion)  # type: ignore[assignment]
+
+    if input_suggestion == tuple(input.placements) and src.placements == tuple(
+        input.placements
+    ):
+        # if our sharding is correct, the output sharding will be the same as the input.
+        return OutputSharding(
+            output_spec=DTensorSpec(
+                mesh=input.mesh,
+                placements=input.placements,
+            )
+        )
+    else:
+        # otherwise, return the suggestion.
+        return OutputSharding(
+            output_spec=None,
+            schema_suggestions=[
+                OpSchema(
+                    op=op_schema.op,
+                    args_schema=(
+                        DTensorSpec(
+                            mesh=input.mesh,
+                            placements=input_suggestion,
+                            tensor_meta=input.tensor_meta,
+                        ),
+                        DTensorSpec(
+                            mesh=src.mesh,
+                            placements=input_suggestion,
+                            tensor_meta=src.tensor_meta,
+                        ),
+                    )
+                    + op_schema.args_schema[2:],
+                    kwargs_schema=op_schema.kwargs_schema,
+                )
+            ],
+        )

venv/lib/python3.10/site-packages/torch/distributed/_spmd/gm_transformation.py

@@ -0,0 +1,51 @@
+from typing import Callable
+
+from torch import fx
+from torch.distributed._spmd.graph_optimization import (
+    comm_fusion_with_concat,
+    enable_graph_optimization_dump,
+    remove_copy_from_optimizer,
+    schedule_comm_wait,
+)
+from torch.distributed._spmd.graph_utils import dump_graphs_to_files
+from torch.distributed._spmd.iter_graph_module import IterGraphModule
+
+
+class GraphModuleTransformation:
+    def __init__(
+        self,
+        *,
+        enable_graph_optimization: bool = False,
+        enable_inductor: bool = False,
+        dump_graphs: bool = False,
+    ) -> None:
+        self.enable_graph_optimization = enable_graph_optimization
+        self.enable_inductor = enable_inductor
+        self.dump_graphs = dump_graphs
+
+    def __call__(self, gm: fx.GraphModule) -> Callable:
+        if self.dump_graphs:
+            graph_folder = dump_graphs_to_files(
+                {"before_transformation_gm": gm.print_readable(False)}
+            )
+            enable_graph_optimization_dump(graph_folder)
+
+        iter_gm = IterGraphModule(gm, enable_inductor=self.enable_inductor)
+        if self.enable_graph_optimization:
+            comm_fusion_with_concat(iter_gm, 100)
+            schedule_comm_wait(iter_gm)
+            remove_copy_from_optimizer(iter_gm)
+        # Must be called after we are not going to move the graphs
+        iter_gm.finalize_setup()
+
+        if self.dump_graphs:
+            dump_graphs_to_files(
+                {
+                    "iter_graph_setup_gm": iter_gm.setup_gm.print_readable(False),
+                    "iter_graph_main_gm": iter_gm.main_gm.print_readable(False),
+                    "iter_graph_cleanup_gm": iter_gm.cleanup_gm.print_readable(False),
+                },
+                graph_folder,  # type: ignore[possibly-undefined]
+            )
+
+        return iter_gm

venv/lib/python3.10/site-packages/torch/distributed/_spmd/graph_optimization.py

@@ -0,0 +1,986 @@
+# Owner(s): ["oncall: distributed"]
+import collections
+import itertools
+import logging
+import operator
+import tempfile
+import time
+from dataclasses import dataclass, field
+from functools import wraps
+from typing import (
+    Any,
+    Callable,
+    cast,
+    DefaultDict,
+    Dict,
+    Iterable,
+    List,
+    Optional,
+    Set,
+    Tuple,
+    Union,
+)
+
+import torch
+import torch.fx as fx
+from torch._subclasses.fake_tensor import FakeTensor, FakeTensorMode
+from torch.distributed._spmd.graph_utils import (
+    CommType,
+    dump_graphs_to_files,
+    find_node,
+    get_output,
+    OP,
+)
+from torch.distributed._spmd.iter_graph_module import IterGraphModule
+from torch.fx.passes.shape_prop import TensorMetadata
+from torch.utils import _pytree as pytree
+from torch.utils._pytree import tree_flatten, tree_unflatten
+
+logger: logging.Logger = logging.getLogger("graph_optimization")
+aten = torch.ops.aten
+fake_tensor_mode = FakeTensorMode()
+
+_optimized_func: Set[str] = set()
+# The key is the target pass and the value is the prerequisites of the pass.
+_prerequisite_sets: DefaultDict[str, Set[str]] = collections.defaultdict(set)
+# The key is the target pass and the value is the passes that must applied before
+# the key.
+_apply_before_sets: DefaultDict[str, Set[str]] = collections.defaultdict(set)
+_dump_graph_folder: str = ""
+
+
+def enable_graph_optimization_dump(folder: str = ""):
+    global _dump_graph_folder
+    if not folder:
+        folder = tempfile.mkdtemp()
+    _dump_graph_folder = folder
+
+
+# TODO(@fegin): Support multiple runs of graph optimization
+# TODO(@fegin): With this design, circular imports will happen when a pass
+# developer accidentally create a pass dependency cycle. As a result, we need to
+# break this file into a finer granularity to avoid incorrect circular import.
+def graph_optimization_pass(
+    prerequisites: Iterable[Callable],
+    apply_after: Iterable[Callable],
+) -> Callable:
+    """Define the contract of a graph optimization pass.
+
+    All the passes should be wrapped with this decorator.
+    `prerequisites` is used to annotate the prerequisite passes of the this pass.
+    `apply_after` means that this wrapped pass must be applied after the passes
+    in `apply_after`. The difference between `prerequisites` and `apply_after`
+    is that all the passes in `prerequisites` must be applied to the graph and
+    must be applifed before the wrapped pass while the passes `apply_after` are
+    optional. But if a pass in `apply_after` is applied to the graph, it has to
+    be done before the wrapped pass.
+    Optimizer pass developers are required to add these fields accordingly and
+    users need to follow the restrictions to avoid the assert.
+
+    Current design has one limitation: users can only apply the optimizations
+    once.  In some cases, we may need to run multiple the same optimization
+    multiple time, e.g., optimization passes -> profiling the result -> apply
+    optimization passes with the profiling result again. This limitation will be
+    addressed limitation in the future.
+
+    Args:
+        prerequisites (Iterable[Callable]): the list of string to the names of
+            passes which are the prerequisites of this pass.
+        apply_after (Iterable[Callable]): the list of string to the names of
+            passes that can not be applied after the wrapped pass.
+    """
+
+    def inner(func: Callable) -> Callable:
+        def make_key(func: Callable) -> str:
+            return f"{func.__module__}.{func.__name__}"
+
+        func_key = make_key(func)
+        _prerequisite_sets[func_key] = {make_key(f) for f in prerequisites}
+        for apply_after_pass in apply_after:
+            _apply_before_sets[make_key(apply_after_pass)].add(func_key)
+
+        @wraps(func)
+        def pass_wrapper(
+            gm: Union[fx.GraphModule, IterGraphModule], *args: Any, **kwargs: Any
+        ) -> None:
+            begin = time.time()
+            assert isinstance(gm, (fx.GraphModule, IterGraphModule)), (
+                "The first argument of the pass must be either "
+                "fx.GraphModule or IterGraphModule."
+            )
+            assert func_key not in _optimized_func, f"Cannot apply {func_key} twice."
+            invalid_passes = _apply_before_sets[func_key].intersection(_optimized_func)
+            assert (
+                not invalid_passes
+            ), f"{invalid_passes} must be applied after {func_key}."
+            assert _prerequisite_sets[func_key].issubset(_optimized_func), (
+                f"{_prerequisite_sets[func_key] - _optimized_func} are the "
+                f"prerequisites of {func_key} but are not applified. "
+                f"Applied passes are {_optimized_func}."
+            )
+
+            func(gm, *args, **kwargs)
+            gm.graph.lint()
+            gm.graph.eliminate_dead_code()
+            gm.recompile()
+            _optimized_func.add(func_key)
+
+            prefix = f"after_{func.__name__}"
+            if _dump_graph_folder:
+                if isinstance(gm, IterGraphModule):
+                    dump_graphs_to_files(
+                        {
+                            f"{prefix}_setup_gm": gm.setup_gm,
+                            f"{prefix}_main_gm": gm.main_gm,
+                            f"{prefix}_cleanup_gm": gm.cleanup_gm,
+                        },
+                        _dump_graph_folder,
+                    )
+                else:
+                    dump_graphs_to_files({prefix: gm}, _dump_graph_folder)
+
+            logger.info("Spent %f seconds applying %s", time.time() - begin, func_key)
+
+        return pass_wrapper
+
+    return inner
+
+
+@dataclass(unsafe_hash=True)
+class CommBlock:
+    shape: Optional[torch.Size]
+    node_list: List[fx.Node]
+    inputs: List[fx.Node]
+    wait_nodes: List[fx.Node]
+    comm_node: fx.Node
+    outputs: Set[fx.Node]
+
+
+def get_comm_block(comm_node: fx.Node) -> CommBlock:
+    """Find out all the nodes belong to this communcation given a collective node (e.g., allreduce).
+
+    Args:
+        comm_node(fx.Node): The target communication/collective node.
+
+    Returns:
+        The CommBlock that encapsulates the related nodes (e.g., wait_node) of
+        the given comm_node.
+    """
+    # We choose 5 to prevent some accidents that cause infinite loop. But
+    # with functional collective, the distance is 1.
+    MAX_WAIT_DISTANCE = 5
+    node_list = []
+    wait_nodes = []
+    inputs = pytree.arg_tree_leaves(*comm_node.args, **comm_node.kwargs)
+    input_nodes = [inp for inp in inputs if isinstance(inp, fx.Node)]
+    distance = 0
+    wait_prefixes = ("wait_comm", "wait_tensor")
+    non_end_users_nodes = ("split", "reshape", "getitem", "detach", "alias")
+
+    nodes = collections.deque([comm_node, None])
+    while nodes and distance < 5:
+        node = nodes.popleft()
+        if node is None:
+            distance += 1
+            if nodes:
+                nodes.append(None)
+            continue
+        node_list.append(node)
+        if node.name.startswith(wait_prefixes):
+            wait_nodes.append(node)
+        else:
+            for child in node.users:
+                if isinstance(child, fx.Node):
+                    nodes.append(child)
+
+    if not wait_nodes:
+        raise RuntimeError(
+            "The wait nodes are too far away from the comm node {comm_node}."
+        )
+
+    # Identify all the outputs of this collective block.
+    outputs: Set[fx.Node] = set()
+    nodes = collections.deque(wait_nodes)
+    while nodes:
+        node = nodes.popleft()
+        assert node is not None
+        for user in node.users:
+            if isinstance(user, fx.Node) and user.name.startswith(non_end_users_nodes):
+                nodes.append(user)
+                node_list.append(user)
+            else:
+                outputs.add(node)
+                break
+
+    # TODO: populate all the tensor metadata and remove the default.
+    tensor_meta = input_nodes[0].meta.get("tensor_meta", None)
+    return CommBlock(
+        # TODO: support symbolic shapes
+        shape=torch.Size(int(s) for s in tensor_meta.shape) if tensor_meta else None,
+        node_list=node_list,
+        wait_nodes=wait_nodes,
+        comm_node=comm_node,
+        inputs=input_nodes,
+        outputs=outputs,
+    )
+
+
+def get_all_comm_blocks(
+    gm: IterGraphModule, comm_ops: Union[Tuple[str, ...], str]
+) -> List[CommBlock]:
+    return [
+        get_comm_block(node)
+        for node in gm.graph.nodes
+        if node.name.startswith(comm_ops)
+    ]
+
+
+def _create_meta_val(
+    fake_tensor_mode: FakeTensorMode,
+    val: FakeTensor,
+) -> FakeTensor:
+    # TODO: fix the memory_format
+    return FakeTensor(
+        fake_tensor_mode,
+        torch.empty(
+            val.shape,
+            dtype=val.dtype,
+            device="meta",
+            requires_grad=val.requires_grad,
+        ),
+        val.device,
+    )
+
+
+def _create_meta_tensor_meta(
+    fake_tensor_mode: FakeTensorMode,
+    val: FakeTensor,
+) -> TensorMetadata:
+    return TensorMetadata(
+        shape=val.shape,
+        dtype=val.dtype,
+        requires_grad=val.requires_grad,
+        stride=val.stride,  # type: ignore[arg-type]
+        # TODO: fix these value
+        memory_format=None,
+        is_quantized=False,
+        qparams={},
+    )
+
+
+def _call_function(
+    gm: IterGraphModule,
+    fake_tensor_mode: FakeTensorMode,
+    meta_val: Optional[FakeTensor],
+    function: Any,
+    *args: Any,
+    **kwargs: Any,
+) -> fx.Node:
+    node = gm.graph.call_function(function, args, kwargs)
+
+    if meta_val is None:
+        flat_args, spec = tree_flatten((args, kwargs))
+        new_flat_args = []
+        memory_format = None
+        for arg in flat_args:
+            if not isinstance(arg, fx.Node):
+                new_flat_args.append(arg)
+                continue
+            val = arg.meta["val"]
+            new_flat_args.append(_create_meta_val(fake_tensor_mode, val))
+
+        fake_args, fake_kwargs = tree_unflatten(new_flat_args, spec)
+        new_meta_val = function(*fake_args, **fake_kwargs)
+    else:
+        new_meta_val = meta_val
+    node.meta["val"] = new_meta_val
+    node.meta["tensor_meta"] = _create_meta_tensor_meta(fake_tensor_mode, new_meta_val)
+    return node
+
+
+def _scatter_wait_result(
+    gm: IterGraphModule,
+    fused_comm_block: CommBlock,
+    comm_blocks: List[CommBlock],
+    node_indices: Dict[fx.Node, int],
+) -> None:
+    """Scatter the result of the fused communication node to the original users -- splitting the output and reshape each subitem."""
+    last_wait_node_idx = 0
+    for node in gm.graph.nodes:
+        if node == fused_comm_block.comm_node:
+            break
+        last_wait_node_idx = max(
+            node_indices.get(node, last_wait_node_idx), last_wait_node_idx
+        )
+
+    fused_comm_node = fused_comm_block.comm_node
+    fused_wait_node = fused_comm_block.wait_nodes[0]
+
+    with gm.graph.inserting_after(fused_wait_node):
+        split_node = gm.graph.call_function(
+            aten.split,
+            (
+                fused_wait_node,
+                # TODO(@fegin): support symbolic shapes
+                [int(cast(torch.Size, cb.shape).numel()) for cb in comm_blocks],
+            ),
+        )
+
+    # Scatter the split result.
+    need_sort_nodes = []
+    last_split_reshape_node = split_node
+    with gm.graph.inserting_after(split_node):
+        for idx, comm_block in enumerate(comm_blocks):
+            # Some users of the original allreduce and wait are scheduled
+            # before the fused allreduce. We must move these users to a
+            # correct topological sort order -- right after the last fused
+            # allreduce result, the `last_split_reshape_node` variable.
+            orig_wait = comm_block.wait_nodes[0]
+            nodes = collections.deque(list(orig_wait.users))
+            while nodes:
+                user_node = nodes.popleft()
+                if not isinstance(user_node, fx.Node):
+                    continue
+                if node_indices[user_node] < last_wait_node_idx:
+                    need_sort_nodes.append(user_node)
+                    nodes.extend(list(user_node.users))
+
+            split_idx_node = gm.graph.call_function(operator.getitem, (split_node, idx))
+            with gm.graph.inserting_after(split_idx_node):
+                wait_output_node = gm.graph.call_function(
+                    aten.reshape, (split_idx_node, comm_block.shape)
+                )
+            gm.graph.node_replace_all_uses_with(orig_wait, wait_output_node)
+
+        if last_split_reshape_node == split_node:
+            last_split_reshape_node = wait_output_node  # type: ignore[possibly-undefined]
+
+    need_sort_nodes = sorted(need_sort_nodes, key=lambda node: node_indices[node])
+    gm.graph.move_after(need_sort_nodes, last_split_reshape_node)
+
+    gm.graph.eliminate_dead_code()
+
+
+def _fuse_with_cat(
+    gm: IterGraphModule,
+    comm_blocks: List[CommBlock],
+    node_indices: Dict[fx.Node, int],
+) -> CommBlock:
+    """Fuse the CommBlocks using concat given a list of CommBlock (only allreduce)."""
+    # Find the last input node.
+    last_input_node = comm_blocks[0].inputs[0]
+    last_input_index = -1
+    all_input_nodes = []
+    for comm_block in comm_blocks:
+        input_node = comm_block.inputs[0]
+        # If the input node is a clone, this is CommTensor based implementation.
+        if input_node.name.startswith("clone"):
+            input_node = cast(fx.Node, input_node.args[0])
+        all_input_nodes.append(input_node)
+        index = node_indices[input_node]
+        if index >= last_input_index:
+            assert index != last_input_index
+            last_input_node = input_node
+            last_input_index = index
+
+    # Flatten all the inputs right after the last input is ready.
+    with gm.graph.inserting_after(last_input_node):
+        cat_inputs = []
+        for input_node in all_input_nodes:
+            cat_inputs.append(
+                _call_function(
+                    gm, fake_tensor_mode, None, aten.flatten.using_ints, input_node
+                )
+            )
+
+    with gm.graph.inserting_after(cat_inputs[0]):
+        cat_node = _call_function(gm, fake_tensor_mode, None, aten.cat, cat_inputs)
+
+    # Create a new Comm node.
+    last_comm = comm_blocks[-1]
+    last_comm_node = last_comm.comm_node
+    last_wait_node = last_comm.wait_nodes[0]
+    with gm.graph.inserting_after(cat_node):
+        flatten_args, spec = tree_flatten((last_comm_node.args, last_comm_node.kwargs))
+        flatten_args[0] = cat_node
+        args, kwargs = tree_unflatten(flatten_args, spec)
+        fused_comm_node = _call_function(
+            gm,
+            fake_tensor_mode,
+            cat_node.meta["val"],
+            last_comm_node.target,
+            *args,
+            **kwargs,
+        )
+
+    # Create a new Wait node.
+    with gm.graph.inserting_after(fused_comm_node):
+        flatten_args, spec = tree_flatten((last_wait_node.args, last_wait_node.kwargs))
+        flatten_args[0] = fused_comm_node
+        args, kwargs = tree_unflatten(flatten_args, spec)
+        fused_wait_node = _call_function(
+            gm,
+            fake_tensor_mode,
+            cat_node.meta["val"],
+            last_wait_node.target,
+            *args,
+            **kwargs,
+        )
+
+    # Move the fused_comm_node and its args to right after the source node
+    nodes_to_move = cat_inputs + [cat_node, fused_comm_node, fused_wait_node]
+    gm.graph.move_after(nodes_to_move, last_input_node)
+
+    tensor_meta = cat_node.meta.get("tensor_meta")
+    fused_comm_block = CommBlock(
+        shape=tensor_meta.shape,  # type: ignore[union-attr]
+        node_list=[fused_comm_node, fused_wait_node],
+        wait_nodes=[fused_wait_node],
+        comm_node=fused_comm_node,
+        inputs=[cat_node],
+        outputs={fused_wait_node},
+    )
+
+    _scatter_wait_result(gm, fused_comm_block, comm_blocks, node_indices)
+
+    return fused_comm_block
+
+
+def _expedite_comm_ops(gm: IterGraphModule, comm_blocks: List[CommBlock]) -> None:
+    node_indices = {node: i for i, node in enumerate(gm.graph.nodes)}
+    for comm_block in comm_blocks:
+        last_input = comm_block.comm_node
+        last_input_idx = -1
+        for input in comm_block.inputs:
+            input_idx = node_indices[input]
+            if input_idx > last_input_idx:
+                last_input = input
+                last_input_idx = input_idx
+        gm.graph.node_append(last_input, comm_block.comm_node)
+
+
+@graph_optimization_pass(
+    prerequisites=[],
+    apply_after=[],
+)
+def comm_fusion_with_concat(
+    gm: IterGraphModule,
+    bucket_size_mb: int,
+) -> None:
+    """Run fuse communication with concat.
+
+    This implementation uses concat to concat the bucketed gradients.
+    """
+    comm_blocks = get_all_comm_blocks(gm, (CommType.ALLREDUCE, "all_reduce"))
+    # First ensure the allreduce are scheduled immediately right after the gradients.
+    _expedite_comm_ops(gm, comm_blocks)
+    # Get the comm_blocks based on the new order.
+    comm_blocks = get_all_comm_blocks(gm, (CommType.ALLREDUCE, "all_reduce"))
+    node_indices = {node: i for i, node in enumerate(gm.graph.nodes)}
+
+    bucket_size = 1 * 1024**2
+    bucket_cap_size = bucket_size_mb * 1024**2
+    begin = end = curr_size = 0
+    while end < len(comm_blocks):
+        # TODO: determine the dtype
+        curr_size += cast(torch.Size, comm_blocks[end].shape).numel() * 4
+        end += 1
+        if curr_size < bucket_size:
+            continue
+        _fuse_with_cat(gm, comm_blocks[begin:end], node_indices)
+        bucket_size = bucket_cap_size
+        begin = end
+        curr_size = 0
+    else:
+        if begin < len(comm_blocks):
+            _fuse_with_cat(gm, comm_blocks[begin:end], node_indices)
+
+
+@graph_optimization_pass(
+    prerequisites=[comm_fusion_with_concat],
+    apply_after=[],
+)
+def schedule_comm_wait(gm: IterGraphModule) -> None:
+    """Delay the execution of wait tensors of allreduce until its first user."""
+    comm_blocks = get_all_comm_blocks(gm, (CommType.ALLREDUCE, "all_reduce"))
+
+    # Find all the end users.
+    allreduce_users: Set[fx.Node] = set()
+    for allreduce in comm_blocks:
+        for output in allreduce.outputs:
+            allreduce_users.update(output.users)
+
+    node_indices = {node: i for i, node in enumerate(gm.graph.nodes)}
+    for allreduce in comm_blocks:
+        # Find the earliest users.
+        assert (
+            len(allreduce.outputs) >= 1
+        ), f"Found a allreduce that has zero outputs/users -- {allreduce}."
+        # Initialize the target_node to be the first user of the first output.
+        target_node = next(iter(next(iter(allreduce.outputs)).users))
+        target_node_index = 2**31
+        for user in (user for output in allreduce.outputs for user in output.users):
+            index = node_indices[user]
+            if index < target_node_index:
+                target_node = user
+                target_node_index = index
+
+        # Move wait nodes and all the subsequent output nodes before the
+        # earliest user.
+        wait_idx = -1
+        for wait_idx, node in enumerate(allreduce.node_list):
+            if node == allreduce.wait_nodes[0]:
+                break
+        assert wait_idx >= 0
+        gm.graph.move_before(allreduce.node_list[wait_idx:], target_node)
+
+
+@graph_optimization_pass(
+    prerequisites=[],
+    apply_after=[],
+)
+def remove_copy_from_optimizer(gm: IterGraphModule) -> None:
+    """Erase the orphant copy_ that generated when tracing optimizer.
+
+    Two reasons why we could not simply use the DCE of fx.Graph.
+    1. fx.Graph treats copy_ as a side-effect node and does not erase it.
+    2. Users may want to preserve some orphan `copy_` that is not from the
+       optimizer.
+    If the second reason does not hold, this pass can be rewritten as using
+    DCE from fx.Graph (with the overwrite to the side-effect node list).
+    """
+    MAX_COPY_DISTANCE = 5
+    remove_candidates: Set[fx.Node] = set()
+    for node in reversed(gm.graph.nodes):
+        if node.users:
+            continue
+        if node.op != OP.CALL_FUNCTION or node.target != aten.copy_.default:
+            continue
+
+        copy_ancestors: Set[fx.Node] = set()
+        nodes = collections.deque([node, None])
+        distance = 0
+        should_remove = False
+        while nodes and distance < MAX_COPY_DISTANCE:
+            visiting = nodes.popleft()
+            if visiting is None:
+                distance += 1
+                if nodes:
+                    nodes.append(None)
+                continue
+            copy_ancestors.add(visiting)
+            if visiting.op == OP.CALL_FUNCTION and str(visiting.target).startswith(
+                ("aten._foreach_", "aten._fused_")
+            ):
+                should_remove = True
+            parents = pytree.arg_tree_leaves(*visiting.args, **visiting.kwargs)
+            for parent in parents:
+                if isinstance(parent, fx.Node):
+                    nodes.append(parent)
+        if should_remove:
+            # We add all ancestors to the list and it is okay as not all of
+            # them will be erased -- only those nodes with zero users will be
+            # erased.
+            remove_candidates.update(copy_ancestors)
+
+    for node in reversed(gm.graph.nodes):
+        if node.users:
+            continue
+        if node not in remove_candidates:
+            continue
+        gm.graph.erase_node(node)
+
+
+# The args list of fused_adam function. We don't care about kwargs.
+AdamArgs = collections.namedtuple(
+    "AdamArgs",
+    ["params", "grads", "exp_avgs", "exp_avg_sqs", "max_exp_avg_sqs", "state_steps"],
+)
+
+
+# TODO(fegin): Have a template class for all Block class.
+@dataclass(unsafe_hash=True)
+class FusedAdamBlock:
+    optim_node: fx.Node
+    generate_output: bool
+    # The output list of the copy nodes. The order follows the argument order.
+    param_outputs: List[fx.Node] = field(default_factory=list)
+    grad_outputs: List[fx.Node] = field(default_factory=list)
+    exp_avgs_outputs: List[fx.Node] = field(default_factory=list)
+    exp_avg_sqs_outputs: List[fx.Node] = field(default_factory=list)
+    # TODO(fegin): populate/generate the max_exp_avg_sqs if exists
+    max_exp_avg_sqs: List[fx.Node] = field(default_factory=list)
+
+    def generate_outputs(self):
+        # Iterate all the args and generate the corresponding output lists.
+        # Assuming the corrsesponding output nodes are not created yet.
+        def _generate_outputs(arg_idx, output_list):
+            graph = self.optim_node.graph
+            with graph.inserting_after(self.optim_node):
+                optim_getitem = graph.call_function(
+                    operator.getitem, (self.optim_node, arg_idx)
+                )
+            for i, arg in enumerate(self.optim_node.args[arg_idx]):
+                with graph.inserting_after(optim_getitem):
+                    updated_arg = graph.call_function(
+                        operator.getitem, (optim_getitem, i)
+                    )
+                with graph.inserting_after(updated_arg):
+                    output_copy = graph.call_function(aten.copy_, (arg, updated_arg))
+                output_list.append(output_copy)
+
+        _generate_outputs(0, self.param_outputs)
+        # Do not generate gradient out list as it is not used.
+        _generate_outputs(2, self.exp_avgs_outputs)
+        _generate_outputs(3, self.exp_avg_sqs_outputs)
+
+    def populate_outputs(self):
+        # Populate the existing output lists from the graph.
+        def _populate_outputs(args_idx, output_list):
+            optim_getitem = self.optim_node
+            for user in self.optim_node.users:
+                assert (
+                    user.target == operator.getitem
+                ), f"The user of {self.optim_node} is not getitem."
+                if user.args[1] == args_idx:
+                    optim_getitem = user
+                    break
+            assert (
+                optim_getitem != self.optim_node
+            ), f"Cannot find the getitem node for {self.optim_node}"
+            output_list.extend(
+                [self.optim_node] * len(cast(List[fx.Node], self.optim_node.args[0]))
+            )
+            for updated_arg in optim_getitem.users:
+                assert (
+                    updated_arg.target == operator.getitem
+                ), f"Unexpected node target {updated_arg.target}."
+                idx = updated_arg.args[1]
+                output_copy = next(iter(updated_arg.users))
+                assert str(output_copy.target).startswith(
+                    "aten.copy_"
+                ), f"Unexpected node target {output_copy.target}."
+                output_list[idx] = output_copy
+            for i, output in enumerate(output_list):
+                assert output != self.optim_node, f"{i}th output is not replaced."
+
+            assert output_list, f"The output for {self.optim_node} is empty."
+
+        _populate_outputs(0, self.param_outputs)
+        _populate_outputs(2, self.exp_avgs_outputs)
+        _populate_outputs(3, self.exp_avg_sqs_outputs)
+
+    def __post_init__(self):
+        if self.param_outputs:
+            return
+        if self.generate_output:
+            self.generate_outputs()
+        else:
+            self.populate_outputs()
+
+
+@dataclass(unsafe_hash=True)
+class ForeachAddBlock:
+    add_node: fx.Node
+    generate_output: bool
+    # The output list of the copy nodes. The order follows the argument order.
+    outputs: List[fx.Node] = field(default_factory=list)
+
+    def generate_outputs(self):
+        # Iterate all the args and generate the corresponding output lists
+        # Assuming the corrsesponding output nodes are not created yet.
+        graph = self.add_node.graph
+        for i, arg in enumerate(cast(Tuple[Any, ...], self.add_node.args[0])):
+            with graph.inserting_after(self.add_node):
+                updated_arg = graph.call_function(operator.getitem, (self.add_node, i))
+            with graph.inserting_after(updated_arg):
+                output_copy = graph.call_function(aten.copy_, (arg, updated_arg))
+            self.outputs.append(output_copy)
+        assert self.outputs, f"The output for {self.add_node} is empty."
+
+    def populate_outputs(self):
+        # Populate the existing output lists from the graph.
+        self.outputs = [
+            self.add_node for _ in cast(Tuple[Any, ...], self.add_node.args[0])
+        ]
+        for updated_arg in self.add_node.users:
+            assert (
+                updated_arg.target == operator.getitem
+            ), f"Unexpected node target {updated_arg.target}"
+            idx = cast(int, updated_arg.args[1])
+            output_copy = next(iter(updated_arg.users))
+            assert str(output_copy.target).startswith(
+                "aten.copy_"
+            ), f"The execpted output node is different, {str(output_copy.target)}"
+            self.outputs[idx] = output_copy
+        for i, output in enumerate(self.outputs):
+            assert output != self.add_node, f"{i}th output is not replaced."
+
+    def __post_init__(self):
+        if self.outputs:
+            return
+
+        if self.generate_output:
+            self.generate_outputs()
+        else:
+            self.populate_outputs()
+
+
+@dataclass(unsafe_hash=True)
+class FusedOptimizerBlock:
+    step: ForeachAddBlock
+    optim: FusedAdamBlock
+
+
+def get_fused_optimizer_block(optim_node: fx.Node) -> FusedOptimizerBlock:
+    """Given a fused optimizer node and return the FusedOptimizerBlock."""
+    MAX_STEP_DISTANCE = 5
+    # Find the step (foreach_add)
+    nodes = collections.deque([optim_node, None])
+    step_node = optim_node
+    distance = 0
+    while nodes and distance < MAX_STEP_DISTANCE:
+        node = nodes.popleft()
+        if node is None:
+            distance += 1
+            if nodes:
+                nodes.append(None)
+            continue
+        elif node.op == OP.CALL_FUNCTION and str(node.target).startswith(
+            "aten._foreach_add"
+        ):
+            step_node = node
+            break
+        else:
+            nodes.extend(
+                a
+                for a in pytree.arg_tree_leaves(*node.args, **node.kwargs)
+                if isinstance(a, fx.Node)
+            )
+    if step_node == optim_node:
+        raise RuntimeError(
+            "Cannot find step node (foreach_add) for the optimizer node "
+            f"{optim_node} with {MAX_STEP_DISTANCE} BFS distance. "
+            "The API design does not match the tracing graph."
+        )
+
+    step = ForeachAddBlock(step_node, generate_output=False)
+    optim = FusedAdamBlock(optim_node, generate_output=False)
+    return FusedOptimizerBlock(step, optim)
+
+
+def get_all_fused_optimizer_blocks(
+    gm: IterGraphModule, optim_ops: Union[Tuple[str, ...], str]
+) -> List[FusedOptimizerBlock]:
+    """Find all the FusedOptimizerBlock that the optimizer operators are in `optim_ops`."""
+    return [
+        get_fused_optimizer_block(node)
+        for node in gm.graph.nodes
+        if node.name.startswith(optim_ops)
+    ]
+
+
+def _split_fused_adam(
+    gm: IterGraphModule,
+    orig_optim_block: FusedOptimizerBlock,
+    split_gradients: Set[fx.Node],
+) -> Tuple[FusedOptimizerBlock, FusedOptimizerBlock]:
+    """Split the `orig_optim_block` into two FusedOptimizerBlock.
+
+    The first one will be the optimizer that optimize `split_gradients`. The second one is
+    used to optimize the remaining gradients.
+    An assert will be raised if one of the optimizer optimize zero gradients.
+    """
+    orig_optim_args = AdamArgs(*orig_optim_block.optim.optim_node.args)
+    optim_args = (AdamArgs([], [], [], [], [], []), AdamArgs([], [], [], [], [], []))
+    # The only hint we can use to split the optimizer is the order/indices.
+    orig_optim_indices: Tuple[List[int], List[int]] = ([], [])
+    orig_step_indices: Tuple[List[int], List[int]] = ([], [])
+
+    for idx, gradient in enumerate(orig_optim_args.grads):
+        group_idx = 0 if gradient in split_gradients else 1
+        orig_optim_indices[group_idx].append(idx)
+        # Get the argument for idx-th gradient from orig_optim_args
+        for orig_arg, optim_arg in zip(orig_optim_args, optim_args[group_idx]):
+            # Only add the argument to the list if the original argument list
+            # is not empty. If the original argument list is empty, the new
+            # one must be an empty list as well.
+            if orig_arg:
+                optim_arg.append(orig_arg[idx])
+
+        # If argument order of step is the same as optimizer, nothing has to be
+        # done. However, it is risky to rely on this assumption so we populate
+        # the orig_step_indices.
+        orig_step_output = optim_args[group_idx].state_steps[-1]
+        assert str(orig_step_output.target).startswith(
+            "aten.copy_"
+        ), f"The copy output is {orig_step_output.target}, expect aten.copy_"
+        orig_step_getitem = orig_step_output.args[1]
+        assert "getitem" in str(
+            orig_step_getitem.target
+        ), f"The copy getitem is {orig_step_getitem.target}, expect operator.getitem"
+        orig_step_idx = orig_step_getitem.args[1]
+        orig_step_indices[group_idx].append(orig_step_idx)
+
+    if not all(l for l in (orig_step_indices + orig_optim_indices)):
+        raise ValueError("At least one split optimizer does not have input.")
+
+    output = get_output(gm.graph)
+    results: List[FusedOptimizerBlock] = []
+    flatten_output_args, spec = tree_flatten((output.args, output.kwargs))
+    flatten_output_args_indices: DefaultDict[
+        fx.Node, Set[int]
+    ] = collections.defaultdict(set)
+    for idx, output_arg in enumerate(flatten_output_args):
+        if isinstance(output_arg, fx.Node):
+            flatten_output_args_indices[output_arg].add(idx)
+
+    def replace_flatten_output_args(orig_node: fx.Node, new_node: fx.Node):
+        for idx in flatten_output_args_indices[orig_node]:
+            flatten_output_args[idx] = new_node
+
+    # Create the new step and optim nodes and blocks.
+    for group_idx in range(2):
+        step_args: List[fx.Node] = []
+        orig_step_outputs: List[fx.Node] = []
+        # We have to create the new step node and block first because it is used
+        # for the new optim node as the input.
+        with gm.graph.inserting_after(orig_optim_block.optim.optim_node):
+            for idx in orig_step_indices[group_idx]:
+                step_args.append(
+                    cast(Tuple[fx.Node, ...], orig_optim_block.step.add_node.args[0])[
+                        idx
+                    ]
+                )
+                orig_step_outputs.append(orig_optim_block.step.outputs[idx])
+            step = gm.graph.call_function(
+                aten._foreach_add.Scalar,
+                (step_args, 1),
+            )
+        step_block = ForeachAddBlock(step, generate_output=True)
+        for i, step_output in enumerate(step_block.outputs):
+            # Replace the original step output in the graph output node with
+            # the new one.
+            orig_step_output = orig_step_outputs[i]
+            replace_flatten_output_args(orig_step_output, step_output)
+            # Also need to replace the step output used for the new optimizer.
+            assert optim_args[group_idx].state_steps[i] == orig_step_output, (
+                f"The expected step output node mismatched, {orig_step_output} "
+                f"{optim_args[group_idx].state_steps[i]}"
+            )
+            optim_args[group_idx].state_steps[i] = step_output
+
+        # Insert the optimizer node after the first step output because its
+        # topo sort order is the last.
+        with gm.graph.inserting_after(step_block.outputs[0]):
+            optim = gm.graph.call_function(
+                aten._fused_adam.default,
+                optim_args[group_idx],
+                orig_optim_block.optim.optim_node.kwargs,
+            )
+        optim_block = FusedAdamBlock(optim, generate_output=True)
+        for curr_idx, orig_idx in enumerate(orig_optim_indices[group_idx]):
+            list_names = ("param_outputs", "exp_avgs_outputs", "exp_avg_sqs_outputs")
+            for name in list_names:
+                orig_list = getattr(orig_optim_block.optim, name)
+                curr_list = getattr(optim_block, name)
+                replace_flatten_output_args(orig_list[orig_idx], curr_list[curr_idx])
+
+        results.append(FusedOptimizerBlock(step_block, optim_block))
+
+    # Optimizer is used as the output of the train_step. Therefore, we have to
+    # update the output node of the graph.
+    output_args, output_kwargs = tree_unflatten(flatten_output_args, spec)
+    gm.graph.node_set_args(output, output_args)
+    gm.graph.node_set_kwargs(output, output_kwargs)
+    # Remove the original copy_ nodes as they won't be DCE.
+    for copy_output in itertools.chain(
+        orig_optim_block.optim.param_outputs,
+        orig_optim_block.optim.exp_avgs_outputs,
+        orig_optim_block.optim.exp_avg_sqs_outputs,
+    ):
+        gm.graph.erase_node(copy_output)
+    # Call DCE once to get rid of the old optimizer. By doing so, we will be
+    # able to erase the copy_ nodes of step later.
+    gm.graph.eliminate_dead_code()
+    for copy_output in orig_optim_block.step.outputs:
+        gm.graph.erase_node(copy_output)
+    # This is not required but calling this for consistency.
+    gm.graph.eliminate_dead_code()
+
+    return results[0], results[1]
+
+
+def split_fused_optimizer(
+    gm: IterGraphModule,
+    optim_block: FusedOptimizerBlock,
+    split_gradients: Set[fx.Node],
+) -> Tuple[FusedOptimizerBlock, FusedOptimizerBlock]:
+    if not split_gradients:
+        raise ValueError("The given split_gradients is empty.")
+    if str(optim_block.optim.optim_node.target).startswith("aten._fused_adam"):
+        return _split_fused_adam(gm, optim_block, split_gradients)
+    else:
+        raise NotImplementedError("Only fused_adam is supported now")
+
+
+# TODO(fegin): The API only support fused adam now. Should extend it to support
+# foreach as well.
+@graph_optimization_pass(
+    prerequisites=[remove_copy_from_optimizer],
+    apply_after=[schedule_comm_wait],
+)
+def iter_move_grads_and_optimizers(
+    gm: IterGraphModule,
+    target_comm_node: str,
+    target_dest_node: str,
+) -> None:
+    """Extract a comm block and split out a new optimizer and step for it.
+
+    This subgraph is then moved to the forward graph.
+    """
+    for comm_block in get_all_comm_blocks(gm, "all_reduce"):
+        if comm_block.comm_node.name == target_comm_node:
+            break
+    else:
+        raise ValueError(f"Cannot find {target_comm_node}")
+
+    optim_blocks = get_all_fused_optimizer_blocks(gm, "_fused_adam")
+    for optim_block in optim_blocks:
+        optim_args = AdamArgs(*optim_block.optim.optim_node.args)
+        one_output = next(iter(comm_block.outputs))
+        if one_output in optim_args.grads:
+            break
+    else:
+        raise ValueError(f"{target_comm_node} is not used by any fused optimizer.")
+
+    move_optim, _ = split_fused_optimizer(gm, optim_block, comm_block.outputs)
+
+    move_nodes = find_all_descendants(
+        gm, [comm_block.comm_node, move_optim.step.add_node]
+    )
+
+    stop_node = find_node(gm.graph, lambda n: n.name == target_dest_node)[0]
+
+    gm.graph.move_to_next_iter_before(move_nodes, stop_node)
+
+
+def find_all_descendants(
+    gm: IterGraphModule,
+    parent_nodes: List[fx.Node],
+) -> List[fx.Node]:
+    """Identify the list of nodes to move during FX graph transformation."""
+    assert len(parent_nodes) > 0, "No parent nodes are given."
+
+    output = get_output(gm.graph)
+    dq_parent_nodes = collections.deque(parent_nodes)
+    move_node_set = set()
+    while dq_parent_nodes:
+        node = dq_parent_nodes.popleft()
+        move_node_set.add(node)
+        dq_parent_nodes += [
+            u for u in node.users if isinstance(u, fx.Node) and u != output
+        ]
+    move_nodes = [node for node in gm.graph.nodes if node in move_node_set]
+
+    return move_nodes

venv/lib/python3.10/site-packages/torch/distributed/_spmd/graph_utils.py

@@ -0,0 +1,145 @@
+import logging
+import os
+import tempfile
+from enum import Enum
+from typing import Callable, cast, Dict, Iterable, List, Set
+
+import torch.fx as fx
+from torch.fx.passes.shape_prop import TensorMetadata
+from torch.utils import _pytree as pytree
+from torch.utils._pytree import tree_flatten, tree_unflatten
+
+
+logger: logging.Logger = logging.getLogger("graph_utils")
+
+
+class OP(str, Enum):
+    CALL_FUNCTION = "call_function"
+    CALL_MODULE = "call_module"
+    CALL_METHOD = "call_method"
+    GET_ATTR = "get_attr"
+    OUTPUT = "output"
+    PLACEHOLDER = "placeholder"
+
+
+class CommType(str, Enum):
+    ALLREDUCE = "allreduce_"
+    ALLGATHER = "allgather_"
+    BROADCAST = "broadcast_"
+    REDUCESCATTER = "reduce_scatter_"
+    SCATTER = "scatter_"
+
+
+def get_node_tensor_metadata(node: fx.Node, is_required: bool = True) -> TensorMetadata:
+    metadata = node.meta.get("tensor_meta", None)
+    if is_required and metadata is None:
+        raise RuntimeError(
+            f"Callsite expects that ``tensor_meta`` exists in ``{node.name}``, "
+            f"but got None instead. Node: {node.op} {node.name} {node.target}"
+        )
+    return metadata
+
+
+def get_output(graph: fx.Graph) -> fx.Node:
+    """Take a graphmodule and return the graph output node.
+
+    We traverse in reverse to expedite it, with the idea that last node should be output
+    """
+    for node in reversed(graph.nodes):
+        if node.op == OP.OUTPUT:
+            return node
+    raise RuntimeError(f"Cannot find the output node in {graph}")
+
+
+def find_node(
+    graph: fx.Graph, predicate: Callable, reverse_order: bool = False
+) -> List[fx.Node]:
+    """Take a predicate and return all the nodes in the `graph` where the predicate holds."""
+    nodes = cast(Iterable[fx.Node], graph.nodes)
+    if reverse_order:
+        nodes = cast(Iterable[fx.Node], iter(reversed(nodes)))  # type: ignore[call-overload]
+    return [node for node in nodes if predicate(node)]
+
+
+def is_leaf_subgraph(graph: fx.Graph, subgraph: List[fx.Node]) -> bool:
+    """Ensure nodes in ``subgraph`` satisfy one of the following rules.
+
+    1. The user of the node is in ``subgraph``.
+    2. The user of the node is output.
+    3. There are no users -- the node is a side-effect node.
+    """
+    all_nodes: Set[fx.Node] = set(subgraph)
+    output = get_output(graph)
+    for node in subgraph:
+        for user in node.users:
+            if not isinstance(user, fx.Node):
+                continue
+            if user not in all_nodes and user != output:
+                return False
+    return True
+
+
+def clone_subgraph(
+    graph: fx.Graph, subgraph: List[fx.Node], target: fx.Node
+) -> List[fx.Node]:
+    """Clone the given subgraph and insert it before ``target``.
+
+    This API currently does not support inserting after ``target``.
+    """
+    all_nodes = set(subgraph)
+    mapping: Dict[fx.Node, fx.Node] = dict()
+    cloned_subgraph = []
+    with graph.inserting_before(target):
+        for node in subgraph:
+            cloned_node = graph.call_function(
+                node.target, node.args, node.kwargs, node.type
+            )
+            # TODO: there are many flatten/unflatten in IterGraph that
+            # can be simplified with tree_map. Will simplify this in
+            # a follow-up PR.
+            original_input = pytree.arg_tree_leaves(*node.args, **node.kwargs)
+            cloned_input, spec = tree_flatten((cloned_node.args, cloned_node.kwargs))
+            mapped_cloned_input = []
+            for original_input_node, cloned_input_node in zip(
+                original_input, cloned_input
+            ):
+                if (
+                    isinstance(original_input_node, fx.Node)
+                    and original_input_node in all_nodes
+                ):
+                    assert original_input_node in mapping
+                    mapped_cloned_input.append(mapping[original_input_node])
+                else:
+                    mapped_cloned_input.append(cloned_input_node)
+            cloned_node.args, cloned_node.kwargs = tree_unflatten(
+                mapped_cloned_input, spec
+            )
+            mapping[node] = cloned_node
+            cloned_subgraph.append(cloned_node)
+
+    return cloned_subgraph
+
+
+def rebuild_graph(gm: fx.GraphModule, remove_dead_code: bool = True) -> None:
+    """Run the required steps to ensure production-ready graph.
+
+    Note - per the fx docs, elimination of dead code is not very precise.
+    Hence, the flag to make this step optional.
+    """
+    gm.graph.lint()
+    if remove_dead_code:
+        gm.graph.eliminate_dead_code()
+    gm.recompile()
+
+
+def dump_graphs_to_files(graphs: Dict[str, fx.GraphModule], folder: str = "") -> str:
+    if not folder:
+        folder = tempfile.mkdtemp()
+
+    for prefix, gm in graphs.items():
+        with open(os.path.join(folder, f"{prefix}.graph"), "w") as fp:
+            fp.write(str(gm))
+
+    logger.warning("Dump graphs to %s", folder)
+
+    return folder

venv/lib/python3.10/site-packages/torch/distributed/_spmd/iter_graph_module.py

@@ -0,0 +1,762 @@
+import copy
+import inspect
+import logging
+from typing import Any, Callable, cast, Dict, List, Optional, Set, Tuple, Type
+
+import torch.nn as nn
+from torch import fx
+from torch.distributed._spmd.graph_utils import (
+    clone_subgraph,
+    get_output,
+    is_leaf_subgraph,
+)
+from torch.distributed._spmd.partial_lower import partial_lower
+from torch.fx.graph import _PyTreeCodeGen, PythonCode
+from torch.fx.node import Argument
+from torch.profiler import record_function
+from torch.utils import _pytree as pytree
+from torch.utils._pytree import tree_flatten, tree_map, tree_map_only, tree_unflatten
+
+
+logger: logging.Logger = logging.getLogger("IterGraphModule")
+
+
+class IterGraph(fx.Graph):
+    """``IterGraph`` is used to perform cross-iteration optimization.
+
+    ``IterGraph`` keeps track of the 3 graphs, self (the original graph), setup graph, and
+    cleanup graph. The 3 graphs should be identical copies of a ``fx.Graph``.
+
+    IterGraph subclass fx.Graph to override the necessary APIs that will be used
+    when constructing a optimization, e.g., communication fusion. IterGraph also
+    provides APIs that originally belong to fx.Node and all these APIs will have
+    ``node_`` prefix. For example, ``IterGraph.node_prepend`` is the equivalence
+    of ``fx.Node.prepend``. Note that all the optimizations must be constructed
+    using these APIs.
+    """
+
+    def __init__(
+        self,
+        orig_graph: fx.Graph,
+        setup_graph: fx.Graph,
+        cleanup_graph: fx.Graph,
+        owning_module: Optional[fx.GraphModule] = None,
+        tracer_cls: Optional[Type["fx.Tracer"]] = None,
+        tracer_extras: Optional[Dict[str, Any]] = None,
+    ):
+        super().__init__(owning_module, tracer_cls, tracer_extras)
+
+        output_vals = self.graph_copy(orig_graph, {}, return_output_node=True)
+        # TODO: if we do ``deepcopy(_codegen)`` and the input argument contains
+        # a dictionary with the form of Dict[torch.Tensor, Any], the
+        # torch.fx._pytree.treen_flatten_spec will not be able to flatten the
+        # dict -- the torch.Tensor will be duplicated because the _input_spec
+        # will save the ``keys`` of a dictionary (the values are not saved).
+        self._codegen = copy.deepcopy(orig_graph._codegen)
+        assert isinstance(output_vals, tuple)
+        output_val, old_output_val = output_vals
+        super().output(output_val, type_expr=getattr(old_output_val, "type", None))
+
+        self.setup_graph = setup_graph
+        self.cleanup_graph = cleanup_graph
+        self._all_graphs: Tuple[fx.Graph, ...] = (
+            self.setup_graph,
+            self.cleanup_graph,
+            cast(fx.Graph, super()),
+        )
+
+        self._setup_mapping: Dict[fx.Node, fx.Node] = {}
+        self._cleanup_mapping: Dict[fx.Node, fx.Node] = {}
+        self._freeze_cross_iter_movement = False
+        self._cross_iter_block_count = 0
+
+        for node, setup_node, cleanup_node in zip(
+            self.nodes, self.setup_graph.nodes, self.cleanup_graph.nodes
+        ):
+            self._setup_mapping[node] = setup_node
+            self._cleanup_mapping[node] = cleanup_node
+
+        self.num_extra_output = 0
+
+    def _lookup_node(self, node: fx.Node, graph: fx.Graph) -> Optional[fx.Node]:
+        if graph == self.setup_graph:
+            return self._setup_mapping.get(node, None)
+        elif graph == self.cleanup_graph:
+            return self._cleanup_mapping.get(node, None)
+        return node
+
+    def _fx_graph_call(
+        self, graph: fx.Graph, func: str, *args: Any, **kwargs: Any
+    ) -> Any:
+        fx_graph: fx.Graph = graph if graph != self else cast(fx.Graph, super())
+        return getattr(fx_graph, func)(*args, **kwargs)
+
+    def _insert_context(self, func: str, node: fx.Node):
+        class _InsertPoint:
+            def __init__(self, insert_points: List[Any]):
+                self.insert_points = insert_points
+
+            def __enter__(self):
+                pass
+
+            def __exit__(self, type, value, tb):
+                for insert_point in self.insert_points:
+                    insert_point.__exit__(type, value, tb)
+
+        insert_points = []
+        for graph in self._all_graphs:
+            if node:
+                actual_node = self._lookup_node(node, graph)
+                assert actual_node is not None, "Cannot handle None case now."
+            else:
+                actual_node = node
+            insert_points.append(getattr(graph, func)(actual_node))
+
+        return _InsertPoint(insert_points)
+
+    def inserting_after(self, node):
+        if self._freeze_cross_iter_movement:
+            return super().inserting_after(node)
+        return self._insert_context("inserting_after", node)
+
+    def inserting_before(self, node):
+        if self._freeze_cross_iter_movement:
+            return super().inserting_before(node)
+        return self._insert_context("inserting_before", node)
+
+    def _forward_subgraph_inputs(
+        self, subgraph: List[fx.Node], graph: fx.Graph, erase_node: bool
+    ) -> int:
+        """Turn the inputs of a subgraph into the extra output of the entire graph.
+
+        If ``erase_node`` is True, the subgraph will be erased from the graph -- essentially forward the inputs
+        of the subgraph to the output of the graph.
+        """
+        output = get_output(graph)
+        inputs = []
+        all_nodes: Set[fx.Node] = set(subgraph)
+
+        for node in subgraph:
+            node_inputs = pytree.arg_tree_leaves(*node.args, **node.kwargs)
+            for _input in node_inputs:
+                if not isinstance(_input, fx.Node):
+                    continue
+                if _input in all_nodes:
+                    continue
+                inputs.append(_input)
+
+        if erase_node:
+            # We have to remove the node in the reversed order to ensure the
+            # node has zero users.
+            erased = set()
+            for node in reversed(subgraph):
+                if len(node.users) == 1:
+                    key = next(iter(node.users.keys()))
+                    if key == output:
+                        flatten_args, spec = tree_flatten((output.args, output.kwargs))
+                        if node not in flatten_args:
+                            # This optimizer node from the legacy _SPMD tracing.
+                            node.users.clear()
+                        elif str(node.target).startswith("aten.copy_"):
+                            # This is the case where the optimizer is
+                            # functionalized with copy_.
+                            for i in range(len(flatten_args)):
+                                if flatten_args[i] == node:
+                                    flatten_args[i] = node.args[0]
+                        else:
+                            # We have not figured out semantics of forwarding
+                            # all diff ops.
+                            raise RuntimeError(
+                                f"IterGraph does not how to forward the output of {node}"
+                            )
+                        output.args, output.kwargs = tree_unflatten(flatten_args, spec)
+
+                # This is the step case where there is a virtual data dependency
+                # (in-place update) between step and optimizer. And
+                # functionalize_optim add this dependency
+                for user in list(node.users.keys()):
+                    if user in erased:
+                        node.users.pop(user)
+                if node.users:
+                    raise RuntimeError(
+                        "IterGraph has not supported moving the nodes that "
+                        "produce users output result. "
+                        f"Error node: {node}."
+                    )
+                self._fx_graph_call(graph, "erase_node", node)
+                erased.add(node)
+
+        # Add all the extra output nodes into a list and append the list to
+        # the original output.args[0].
+        if self.num_extra_output:
+            # If the extra-output list already exist, just use it.
+            cast(List[fx.Node], output.args[0][-1]).extend(inputs)  # type: ignore[index]
+            new_output = output.args[0]
+        else:
+            # When adding the extra-output list, out_spec of _PyTreeCodeGen
+            # must be updated accordingly.
+            if isinstance(graph._codegen, _PyTreeCodeGen):
+                codegen = graph._codegen
+                new_output = list(output.args[0])  # type: ignore[arg-type]
+                new_output.append(inputs)
+                assert codegen.pytree_info.out_spec is not None
+                original_tree_out = tree_unflatten(
+                    cast(List[Any], output.args[0]), codegen.pytree_info.out_spec
+                )
+                # Use None as a placeholder. If we use the extra-output list
+                # the list will be flatten as well and put into out_spec.
+                _, out_spec = tree_flatten((original_tree_out, None))
+                codegen.pytree_info = codegen.pytree_info._replace(out_spec=out_spec)
+            else:
+                new_output = (output.args[0], inputs)
+        self._fx_graph_call(graph, "erase_node", output)
+        self._fx_graph_call(graph, "output", new_output)
+
+        logger.info("Extended outputs from the subgraph inputs: %s", str(inputs))
+        return len(inputs)
+
+    def _forward_inputs_to_subgraph(
+        self, subgraph: List[fx.Node], graph: fx.Graph, extra_input: int
+    ) -> None:
+        """Create extra input nodes and forward the input nodes to the ``subgraph``.
+
+        The external input nodes of ``subgraph`` (nodes that are not in ``subgraph``) will replaced by the newly
+        created input nodes.
+        """
+        placeholders = [node for node in graph.nodes if str(node.op) == "placeholder"]
+        assert placeholders, "No placeholders are found"
+        # Append the extra input nodes to the current input nodes.
+        with self._fx_graph_call(graph, "inserting_after", placeholders[-1]):
+            new_input_nodes = list(
+                reversed(
+                    [
+                        self._fx_graph_call(
+                            graph,
+                            "placeholder",
+                            f"cross_iter_input_{self._cross_iter_block_count}_{i}",
+                        )
+                        for i in reversed(range(extra_input))
+                    ]
+                )
+            )
+
+        # Update the inputs of subgraph to use the newly created input nodes.
+        all_nodes = set(subgraph)
+        new_input_index = 0
+        for node in subgraph:
+            node_inputs, spec = tree_flatten((node.args, node.kwargs))
+            new_node_inputs = []
+            for input_node in node_inputs:
+                if not isinstance(input_node, fx.Node) or input_node in all_nodes:
+                    new_node_inputs.append(input_node)
+                else:
+                    new_node_inputs.append(new_input_nodes[new_input_index])
+                    new_input_index += 1
+            node.args, node.kwargs = tree_unflatten(new_node_inputs, spec)
+        assert new_input_index == len(
+            new_input_nodes
+        ), f"More inputs than needed {len(new_input_nodes)} > {new_input_index}"
+
+        # Update the in_spec of _PyTreeCodeGen if in_spec is not None (the new
+        # SPMD makes in_spec as None).
+        if (
+            isinstance(graph._codegen, _PyTreeCodeGen)
+            and graph._codegen.pytree_info.in_spec is not None
+        ):
+            codegen = graph._codegen
+            original_tree_in = tree_unflatten(placeholders, codegen.pytree_info.in_spec)
+            _, in_spec = tree_flatten(tuple(list(original_tree_in) + new_input_nodes))
+            codegen.pytree_info = codegen.pytree_info._replace(in_spec=in_spec)
+            for new_input in new_input_nodes:
+                codegen.pytree_info.orig_args.append(new_input.name)
+            codegen.pytree_info = codegen.pytree_info._replace(in_spec=in_spec)
+
+    def move_to_next_iter_before(
+        self, subgraph: List[fx.Node], target_node: fx.Node
+    ) -> None:
+        """Move the ``subgraph`` to the next iteration before ``target_node``.
+
+        The ``subgraph`` is a list of fx.Node and must satisfy the following
+        restrictions:
+            1. The order of the nodes in ``subgraph`` must obey the topological
+               sort order.
+            2. The users of the node in ``subgraph`` must be one of the following:
+                a.) the user is also a node in ``subgraph``.
+                b.) the user is the output of the full graph.
+                c.) the node has users (side effect node).
+        """
+        if self._freeze_cross_iter_movement:
+            raise RuntimeError(
+                "The cross-iteration movement has been frozen for the given "
+                "IterGraph."
+            )
+
+        if not is_leaf_subgraph(self, subgraph):
+            raise ValueError(
+                "The target nodes for ``move_to_next_iter_before`` must "
+                "satisfy one of the following conditions: 1) the user of the "
+                "node is in the target nodes, 2) the user is the output of the "
+                "graph, 3) there are no users -- the node is a side-effect node. "
+            )
+
+        self._cross_iter_block_count += 1
+        # The main graph must be the last one to be modified. Otherwise, the
+        # mapping may change and hence introduce incorrect mapping for setup
+        # and cleanup graphs.
+
+        # For the setup graph, no additional input is needed but additional
+        # outputs will be created. The additional output represents the input of
+        # the action to be moved to the next iteration -- main graph.
+        setup_subgraph: List[fx.Node] = []
+        for node in subgraph:
+            mapped_node = self._lookup_node(node, self.setup_graph)
+            assert mapped_node is not None
+            setup_subgraph.append(mapped_node)
+        setup_extra_input = self._forward_subgraph_inputs(
+            subgraph=setup_subgraph,
+            graph=self.setup_graph,
+            erase_node=True,
+        )
+
+        # For the cleanup graph, additional input is required to get the output
+        # from the last iteration -- main graph. Additional nodes are also
+        # needed to perform the action moved from the last iteration.
+        target_cleanup_node = self._lookup_node(target_node, self.cleanup_graph)
+        assert target_cleanup_node is not None, "The target_cleanup_node is None."
+        cleanup_subgraph: List[fx.Node] = []
+        for node in subgraph:
+            mapped_node = self._lookup_node(node, self.cleanup_graph)
+            assert mapped_node is not None
+            cleanup_subgraph.append(mapped_node)
+        cloned_subgraph = clone_subgraph(
+            self.cleanup_graph,
+            cleanup_subgraph,
+            target=target_cleanup_node,
+        )
+        self._forward_inputs_to_subgraph(
+            cloned_subgraph, self.cleanup_graph, setup_extra_input
+        )
+
+        # For the main graph, additional input will be created to represent
+        # the output from the last iteration -- main graph or setup graph.
+        # Additional output will also be generated to represent the input for
+        # the next iteration -- the main graph or the cleanup graph.
+        main_extra_input = self._forward_subgraph_inputs(
+            subgraph=subgraph, graph=self, erase_node=False
+        )
+        assert main_extra_input == setup_extra_input
+        for node in subgraph:
+            target_node.prepend(node)
+        self._forward_inputs_to_subgraph(subgraph, self, main_extra_input)
+
+        # TODO: This is a temporary solution. We are going to remove DCE usage
+        # or have something to replace fx DCE.
+        for node in self.cleanup_graph.nodes:
+            if len(node.users) == 0:
+                node.users["__hold__"] = None  # type: ignore[index]
+        for node in self.nodes:
+            if len(node.users) == 0:
+                node.users["__hold__"] = None  # type: ignore[index]
+        self.num_extra_output += main_extra_input
+
+    def move_before(self, nodes: List[fx.Node], target_node: fx.Node) -> None:
+        for graph in self._all_graphs:
+            actual_nodes = [self._lookup_node(node, graph) for node in nodes]
+            actual_target_node = self._lookup_node(target_node, graph)
+            assert actual_target_node is not None
+            for actual_node in actual_nodes:
+                actual_target_node.prepend(actual_node)
+
+    def move_after(self, nodes: List[fx.Node], target_node: fx.Node) -> None:
+        for graph in self._all_graphs:
+            actual_nodes = [self._lookup_node(node, graph) for node in nodes]
+            actual_target_node = self._lookup_node(target_node, graph)
+            for actual_node in actual_nodes:
+                assert actual_target_node is not None
+                actual_target_node.append(actual_node)
+                actual_target_node = actual_node
+
+    def call_function(
+        self,
+        the_function: Callable[..., Any],
+        args: Optional[Tuple[Argument, ...]] = None,
+        kwargs: Optional[Dict[str, Argument]] = None,
+        type_expr: Optional[Any] = None,
+    ) -> fx.Node:
+        if self._freeze_cross_iter_movement:
+            return super().call_function(the_function, args, kwargs, type_expr)
+
+        setup_args = tree_map(
+            lambda arg: self._lookup_node(arg, self.setup_graph)
+            if isinstance(arg, fx.Node)
+            else arg,
+            args,
+        )
+        setup_kwargs = tree_map(
+            lambda arg: self._lookup_node(arg, self.setup_graph)
+            if isinstance(arg, fx.Node)
+            else arg,
+            kwargs,
+        )
+        cleanup_args = tree_map(
+            lambda arg: self._lookup_node(arg, self.cleanup_graph)
+            if isinstance(arg, fx.Node)
+            else arg,
+            args,
+        )
+        cleanup_kwargs = tree_map(
+            lambda arg: self._lookup_node(arg, self.cleanup_graph)
+            if isinstance(arg, fx.Node)
+            else arg,
+            kwargs,
+        )
+
+        setup_node = self.setup_graph.call_function(
+            the_function, setup_args, setup_kwargs, type_expr
+        )
+        main_node = super().call_function(the_function, args, kwargs, type_expr)
+        cleanup_node = self.cleanup_graph.call_function(
+            the_function, cleanup_args, cleanup_kwargs, type_expr
+        )
+        self._setup_mapping[main_node] = setup_node
+        self._cleanup_mapping[main_node] = cleanup_node
+        return main_node
+
+    def erase_node(self, to_erase: fx.Node) -> None:
+        if self._freeze_cross_iter_movement:
+            return super().erase_node(to_erase)
+
+        setup_node = self._lookup_node(to_erase, self.setup_graph)
+        assert setup_node is not None, "setup_node is None"
+        self.setup_graph.erase_node(setup_node)
+        super().erase_node(to_erase)
+        cleanup_node = self._lookup_node(to_erase, self.cleanup_graph)
+        self.cleanup_graph.erase_node(cleanup_node)
+
+    def placeholder(
+        self,
+        name: str,
+        type_expr: Optional[Any] = None,
+        default_value: Any = inspect.Signature.empty,
+    ) -> fx.Node:
+        if self._freeze_cross_iter_movement:
+            return super().placeholder(name, type_expr, default_value)
+
+        main_placeholder = super().placeholder(name, type_expr, default_value)
+        setup_placeholder = self.setup_graph.placeholder(name, type_expr, default_value)
+        cleanup_placeholder = self.cleanup_graph.placeholder(
+            name, type_expr, default_value
+        )
+        self._setup_mapping[main_placeholder] = setup_placeholder
+        self._cleanup_mapping[main_placeholder] = cleanup_placeholder
+        return main_placeholder
+
+    def output(self, result: Argument, type_expr: Optional[Any] = None) -> fx.Node:
+        if self._freeze_cross_iter_movement:
+            return super().output(result, type_expr)
+
+        main_output = super().output(result, type_expr)
+        setup_result = tree_map(
+            lambda _result: self._lookup_node(_result, self.setup_graph)
+            if isinstance(_result, fx.Node)
+            else _result,
+            result,
+        )
+        cleanup_result = tree_map(
+            lambda _result: self._lookup_node(_result, self.cleanup_graph)
+            if isinstance(_result, fx.Node)
+            else _result,
+            result,
+        )
+        self.setup_graph.output(setup_result, type_expr)
+        self.cleanup_graph.output(cleanup_result, type_expr)
+
+        return main_output
+
+    def lint(self) -> None:
+        self.setup_graph.lint()
+        super().lint()
+        self.cleanup_graph.lint()
+
+    def node_prepend(self, target_node: fx.Node, node: fx.Node) -> None:
+        """Prepend node to target_node."""
+        if self._freeze_cross_iter_movement:
+            target_node.prepend(node)
+            return
+
+        for graph in self._all_graphs:
+            actual_node = self._lookup_node(node, graph)
+            assert actual_node is not None, "The node is None"
+            actual_target_node = self._lookup_node(target_node, graph)
+            assert actual_target_node is not None, "The target node is None"
+            actual_target_node.prepend(actual_node)
+
+    def node_append(self, target_node: fx.Node, node: fx.Node) -> None:
+        """Append node to target_node."""
+        if self._freeze_cross_iter_movement:
+            target_node.append(node)
+            return
+
+        for graph in self._all_graphs:
+            actual_node = self._lookup_node(node, graph)
+            assert actual_node is not None, f"The actual node is None, {node}."
+            actual_target_node = self._lookup_node(target_node, graph)
+            assert (
+                actual_target_node is not None
+            ), f"The actual target node is None, {target_node}."
+            actual_target_node.append(actual_node)
+
+    def node_set_args(self, node: fx.Node, args: Tuple[Argument, ...]) -> None:
+        if self._freeze_cross_iter_movement:
+            node.args = args
+            return
+
+        setup_args = tree_map_only(
+            fx.Node, lambda _arg: self._lookup_node(_arg, self.setup_graph), args
+        )
+        setup_node = self._lookup_node(node, self.setup_graph)
+        assert setup_node is not None
+        setup_node.args = setup_args
+        cleanup_args = tree_map_only(
+            fx.Node, lambda _arg: self._lookup_node(_arg, self.cleanup_graph), args
+        )
+        cleanup_node = self._lookup_node(node, self.cleanup_graph)
+        assert cleanup_node is not None
+        cleanup_node.args = cleanup_args
+        node.args = args
+
+    def node_set_kwargs(self, node: fx.Node, kwargs: Dict[str, Argument]) -> None:
+        if self._freeze_cross_iter_movement:
+            node.kwargs = kwargs
+            return
+
+        setup_kwargs = tree_map_only(
+            fx.Node, lambda _arg: self._lookup_node(_arg, self.setup_graph), kwargs
+        )
+        setup_node = self._lookup_node(node, self.setup_graph)
+        assert setup_node is not None
+        setup_node.kwargs = setup_kwargs
+        cleanup_kwargs = tree_map_only(
+            fx.Node, lambda _arg: self._lookup_node(_arg, self.cleanup_graph), kwargs
+        )
+        cleanup_node = self._lookup_node(node, self.cleanup_graph)
+        assert cleanup_node is not None
+        cleanup_node.kwargs = cleanup_kwargs
+        node.kwargs = kwargs
+
+    def node_replace_all_uses_with(
+        self,
+        node: fx.Node,
+        replace_with: fx.Node,
+        delete_user_cb: Callable[[fx.Node], bool] = lambda user: True,
+        *,
+        propagate_meta=False,
+    ) -> List[fx.Node]:
+        for graph in self._all_graphs:
+            actual_node = self._lookup_node(node, graph)
+            actual_replace_with = self._lookup_node(replace_with, graph)
+            assert actual_node is not None
+            ret = actual_node.replace_all_uses_with(
+                actual_replace_with,
+                delete_user_cb,
+                propagate_meta=propagate_meta,
+            )
+        return ret  # type: ignore[possibly-undefined]
+
+    def node_add_user(self, node: fx.Node, user: Any) -> None:
+        for graph in self._all_graphs:
+            actual_node = self._lookup_node(node, graph)
+            if isinstance(user, fx.Node):
+                actual_user_node = self._lookup_node(user, graph)
+            else:
+                actual_user_node = user
+            assert actual_node is not None
+            actual_node.users[actual_user_node] = None  # type: ignore[index]
+
+    def node_remove_user(self, node: fx.Node, user: Any) -> None:
+        for graph in self._all_graphs:
+            actual_node = self._lookup_node(node, graph)
+            if isinstance(user, fx.Node):
+                actual_user_node = self._lookup_node(user, graph)
+            else:
+                actual_user_node = user
+            assert actual_node is not None
+            del actual_node.users[actual_user_node]  # type: ignore[arg-type]
+
+    def keep_unused_nodes(self) -> None:
+        for node in self.nodes:
+            if len(node.users) == 0 and str(node.op) != "output":
+                self.node_add_user(node, "__hold__")
+
+    def functionalize_optim(self) -> None:
+        # IterGraph can only support full graph (fwd+bwd+optim). As optimizer
+        # is not a functional call (it is inplace op), this method adds the of
+        # the optimizer call. This method has strong assumption of the optimizer
+        # and may not always be working. This method is intended be a temporary
+        # solution only.
+
+        # TODO: remove this API after DCE is removed
+        for node in reversed(self.nodes):
+            if node.name.startswith("output"):
+                output_node = node
+            elif node.name.startswith(
+                "_fused_adam_",
+            ):
+                optim_node = node
+            elif node.name.startswith(
+                "_foreach_add_",
+            ):
+                step_node = node
+                self.node_add_user(optim_node, output_node)  # type: ignore[possibly-undefined]
+                self.node_add_user(step_node, optim_node)  # type: ignore[possibly-undefined]
+
+    def defunctionalize_optim(self) -> None:
+        # TODO: remove this API after DCE is not used with IterGraph
+        for graph in self._all_graphs:
+            for node in reversed(graph.nodes):
+                if node.name.startswith("output"):
+                    output_node = node
+                elif node.name.startswith(
+                    "_fused_adam_",
+                ):
+                    optim_node = node
+                elif node.name.startswith(
+                    "_foreach_add_",
+                ):
+                    step_node = node
+                    optim_node.users.pop(output_node, None)  # type: ignore[possibly-undefined]
+                    step_node.users.pop(optim_node, None)  # type: ignore[possibly-undefined]
+
+    def freeze_cross_iter_movement(self) -> None:
+        self._freeze_cross_iter_movement = True
+
+
+class IterGraphModule(nn.Module):
+    """``IterGraphModule`` provides the ability to do cross-iteration optimization.
+
+    Given a ``fx.GraphModule``, main_gm, ``IterGraphModule`` internally
+    duplicate it to 3 copies and redirect the ``forward`` request to a different
+    ``fx.GraphModule`` based on the iteration count. This allows users to do
+    graph optimizations that across iterations (e.g., moving collective wait in
+    the backward to the forward of the next iteration).
+
+    Note that users must call the APIs provided by ``IterGraphModule`` or
+    ``IterGraph`` to rewrite the graph so that ``IterGraphModule`` can keep the
+    data dependency for all 3 graphs.
+    """
+
+    def __init__(
+        self,
+        main_gm: fx.GraphModule,
+        max_iters: int = -1,
+        enable_inductor: bool = False,
+    ) -> None:
+        super().__init__()
+
+        def _copy_gm(src: fx.GraphModule, graph: fx.Graph) -> fx.GraphModule:
+            gm = fx.GraphModule(src, graph)
+            gm.meta = getattr(graph, "meta", {})
+            return gm
+
+        self.setup_gm = _copy_gm(main_gm, copy.deepcopy(main_gm.graph))
+        self.cleanup_gm = _copy_gm(main_gm, copy.deepcopy(main_gm.graph))
+        self.main_gm = _copy_gm(
+            main_gm,
+            IterGraph(main_gm.graph, self.setup_gm.graph, self.cleanup_gm.graph),
+        )
+
+        self._iter = 0
+        self._max_iters = max_iters
+        self._previous_output: Tuple[Any, ...] = tuple()
+        self._num_extra_output = 0
+        self._is_frozen = False
+        self._enable_inductor = enable_inductor
+
+    def finalize_setup(self) -> None:
+        """Set up the internal states and also get the signal from users that what is the maximum iteration count.
+
+        This method must be called before the forward() is called.
+        """
+        if not self._is_frozen:
+            self.graph.freeze_cross_iter_movement()
+            self._num_extra_output = self.graph.num_extra_output
+            if self._enable_inductor:
+                self.main_gm = partial_lower(self.main_gm)
+            self._is_frozen = True
+
+        self._iter = 0
+
+    def _run(self, gm: fx.GraphModule, last_iter: bool, *args, **kwargs) -> Any:
+        if self._num_extra_output > 0:
+            new_args = args + (self._previous_output)
+            output = gm(*new_args, **kwargs)
+            if not last_iter:
+                assert len(output) == 2
+                self._previous_output = tuple(output[-1])
+                assert (
+                    len(self._previous_output) > 0
+                ), "There should be at least one extra output."
+                output = output[0]
+        else:
+            # No cross-iteration optimization is done. Simply call the
+            # GraphModule.
+            output = gm(*args, **kwargs)
+        return output
+
+    def forward(self, *args: Any, last_iter: bool = False, **kwargs: Any) -> Any:
+        self._iter += 1
+        last_iter = last_iter or self._iter == self._max_iters
+        if last_iter:
+            logger.info("Using the cleanup graph")
+            gm = self.cleanup_gm
+            profiler_string = "## IterGraphModule: Cleanup Graph ##"
+            self._iter = 0
+        elif self._iter == 1:
+            logger.info("Using the setup graph")
+            gm = self.setup_gm
+            profiler_string = "## IterGraphModule: Setup Graph ##"
+        else:
+            gm = self.main_gm
+            if self._iter == 2:
+                logger.info("Using the main graph")
+                profiler_string = "## IterGraphModule -- Maybe Compiling ##"
+            else:
+                profiler_string = "## IterGraphModule ##"
+
+        with record_function(profiler_string):
+            return self._run(gm, last_iter, *args, **kwargs)
+
+    @property
+    def graph(self) -> IterGraph:
+        return cast(IterGraph, self.main_gm.graph)
+
+    def recompile(self) -> PythonCode:
+        self.setup_gm.recompile()
+        self.cleanup_gm.recompile()
+        return self.main_gm.recompile()
+
+    def freeze_cross_iter_movement(self) -> None:
+        # TODO: remove this API once it is not used.
+        self.graph.freeze_cross_iter_movement()
+        self._num_extra_output = self.graph.num_extra_output
+
+    def print_readable(self, print_output: bool = True) -> str:
+        return self.main_gm.print_readable(print_output)
+
+    def print_all_graphs(self) -> None:
+        logger.info("Printing the three fx.Graph:")
+        logger.info("1. Setup fx.Graph:")
+        logger.info("%s", self.setup_gm.graph)
+        logger.info("2. Main fx.Graph:")
+        logger.info("%s", self.main_gm.graph)
+        logger.info("3. Cleanup fx.Graph:")
+        logger.info("%s", self.cleanup_gm.graph)
+
+    def print_all_graph_modules(self) -> None:
+        logger.info("Printing the three fx gm:")
+        logger.info("1. Setup fx.GraphModule:")
+        logger.info("%s", self.setup_gm.print_readable(False))
+        logger.info("2. Main fx.GraphModule:")
+        logger.info("%s", self.main_gm.print_readable(False))
+        logger.info("3. Cleanup fx.GraphModule:")
+        logger.info("%s", self.cleanup_gm.print_readable(False))

venv/lib/python3.10/site-packages/torch/distributed/_spmd/log_utils.py

@@ -0,0 +1,78 @@
+import logging
+import logging.config
+import os
+from typing import Optional
+
+import torch.distributed as dist
+
+
+LOGGING_CONFIG = {
+    "version": 1,
+    "formatters": {
+        "spmd_format": {"format": "%(name)s: [%(levelname)s] %(message)s"},
+        "graph_opt_format": {"format": "%(name)s: [%(levelname)s] %(message)s"},
+    },
+    "handlers": {
+        "spmd_console": {
+            "class": "logging.StreamHandler",
+            "level": "DEBUG",
+            "formatter": "spmd_format",
+            "stream": "ext://sys.stdout",
+        },
+        "graph_opt_console": {
+            "class": "logging.StreamHandler",
+            "level": "DEBUG",
+            "formatter": "graph_opt_format",
+            "stream": "ext://sys.stdout",
+        },
+        "null_console": {
+            "class": "logging.NullHandler",
+        },
+    },
+    "loggers": {
+        "spmd_exp": {
+            "level": "DEBUG",
+            "handlers": ["spmd_console"],
+            "propagate": False,
+        },
+        "graph_opt": {
+            "level": "DEBUG",
+            "handlers": ["graph_opt_console"],
+            "propagate": False,
+        },
+        "null_logger": {
+            "handlers": ["null_console"],
+            "propagate": False,
+        },
+        # TODO(anj): Add loggers for MPMD
+    },
+    "disable_existing_loggers": False,
+}
+
+
+def get_logger(log_type: str) -> Optional[logging.Logger]:
+    from torch.distributed._spmd import config
+
+    if "PYTEST_CURRENT_TEST" not in os.environ:
+        logging.config.dictConfig(LOGGING_CONFIG)
+        avail_loggers = list(LOGGING_CONFIG["loggers"].keys())  # type: ignore[attr-defined]
+        assert (
+            log_type in avail_loggers
+        ), f"Unable to find {log_type} in the available list of loggers {avail_loggers}"
+
+        if not dist.is_initialized():
+            return logging.getLogger(log_type)
+
+        if dist.get_rank() == 0:
+            logger = logging.getLogger(log_type)
+            logger.setLevel(config.log_level)
+            if config.log_file_name is not None:
+                log_file = logging.FileHandler(config.log_file_name)
+                log_file.setLevel(config.log_level)
+                logger.addHandler(log_file)
+        else:
+            logger = logging.getLogger("null_logger")
+
+        return logger
+
+    return logging.getLogger("null_logger")

venv/lib/python3.10/site-packages/torch/distributed/_spmd/parallel_mode.py

@@ -0,0 +1,216 @@
+from abc import ABC, abstractmethod
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+import torch
+import torch.distributed as dist
+import torch.utils._pytree as pytree
+from torch._subclasses import FakeTensorMode
+from torch.distributed._spmd.data_parallel import (
+    DataParallelStyle,
+    partition_data_parallel,
+)
+from torch.distributed._spmd.distribute import _convert_to_distributed, Schema
+from torch.distributed._tensor import DeviceMesh, Placement, Replicate, Shard
+
+from torch.fx import GraphModule
+
+
+class ParallelMode(ABC):
+    """
+    Basic Parallel Mode interface. Each parallelism pattern should implement
+    this interface to describe how to partition and compile the graph in the
+    spmd compiler.
+    """
+
+    @abstractmethod
+    def partition(
+        self,
+        gm: GraphModule,
+        model: torch.nn.Module,
+        optimizer: Optional[torch.optim.Optimizer],
+        params_and_buffers: Dict[str, Any],
+        named_states: Dict[str, Any],
+        args: Tuple[Any, ...],
+        kwargs: Dict[str, Any],
+    ) -> GraphModule:
+        """
+        Partition a single device graph to a distributed graph.
+
+        TODO(@wanchaol): some of these arguments are not necessary for
+        partitioning, remove the unnecessary ones later.
+        """
+        raise NotImplementedError()
+
+    @abstractmethod
+    def transform_and_compile(self, gm: GraphModule) -> GraphModule:
+        """
+        Transform and compile a distributed graph with a set of graph
+        transformation and optimization passes for each parallel mode.
+
+        The returned result should be a compiled executable graph in
+        the distributed environment.
+        """
+        # TODO: add more necessary arguments to this interface.
+        raise NotImplementedError()
+
+
+class DataParallel(ParallelMode):
+    """Data Parallelism mode."""
+
+    def __init__(
+        self,
+        parallel_style: str = "replicate",
+        *,
+        input_batch_dim: int = 0,
+        custom_passes: Optional[Callable[[GraphModule], GraphModule]] = None,
+    ):
+        """
+        DataParallel Mode that partition the model and graph to data parallel style
+        parallelism (i.e. DDP/FSDP/ZERO-3). It currently supports three different
+        parallel styles: "replicate", "fully_shard", and "default". See
+        :class:`DataParallelStyle` for more details.
+
+        Args:
+            parallel_style (str): parallel style to use. Currently supports
+                "replicate", "fully_shard", and "default".
+
+        Keyword args:
+            input_batch_dim (int): the batch dimension of the input tensor.
+                 default: 0
+            custom_passes (Callable[[GraphModule], GraphModule], optional):
+                A custom callable that overrides the default graph transformation
+                and optimization passes.
+        """
+        if parallel_style == "replicate":
+            self.parallel_style = DataParallelStyle.REPLICATE
+        elif parallel_style == "fully_shard":
+            self.parallel_style = DataParallelStyle.FULLY_SHARD
+        elif parallel_style == "default":
+            self.parallel_style = DataParallelStyle.DEFAULT
+        else:
+            raise RuntimeError(f"Unknown parallel style: {parallel_style}")
+
+        # TODO: what if user passes in a incorrect `input_batch_dim`, how should we
+        # detect that and do proper error handling?
+        self.input_batch_dim = input_batch_dim
+
+        if custom_passes is not None:
+            self._gm_passes: Callable[[GraphModule], GraphModule] = custom_passes
+        else:
+            # TODO: add a few default passes here.
+            self._gm_passes = lambda gm: gm
+
+    def partition(
+        self,
+        gm: GraphModule,
+        model: torch.nn.Module,
+        optimizer: Optional[torch.optim.Optimizer],
+        params_and_buffers: Dict[str, Any],
+        named_states: Dict[str, Any],
+        args: Tuple[Any, ...],
+        kwargs: Dict[str, Any],
+    ) -> GraphModule:
+        # TODO: figure out a way to avoid explicit "cuda" mesh.
+        mesh = DeviceMesh("cuda", torch.arange(dist.get_world_size()))
+
+        gm = partition_data_parallel(
+            gm,
+            model,
+            optimizer,
+            params_and_buffers,
+            named_states,
+            args,
+            kwargs,
+            mesh,
+            self.parallel_style,
+            self.input_batch_dim,
+        )
+        return gm
+
+    def transform_and_compile(self, gm: GraphModule) -> GraphModule:
+        """optimize a distributed graph with a set of optimization passes"""
+        # TODO: add more necessary arguments to this interface.
+        return self._gm_passes(gm)
+
+
+class DTensorExpandMode(ParallelMode):
+    """
+    The DTensor Expand mode. It's replicating the parameters and
+    shard the inputs to represent DDP like behavior, it's currently
+    a transitent mode before we move to the new data parallel expansion.
+    """
+
+    def __init__(
+        self, custom_passes: Optional[Callable[[GraphModule], GraphModule]] = None
+    ):
+        self._placements_override: Dict[int, List[Placement]] = {}
+        if custom_passes is not None:
+            self._gm_passes: Callable[[GraphModule], GraphModule] = custom_passes
+        else:
+            # TODO: add a few default passes here.
+            self._gm_passes = lambda gm: gm
+
+    def partition(
+        self,
+        gm: GraphModule,
+        model: torch.nn.Module,
+        optimizer: Optional[torch.optim.Optimizer],
+        params_and_buffers: Dict[str, Any],
+        named_states: Dict[str, Any],
+        args: Tuple[Any, ...],
+        kwargs: Dict[str, Any],
+    ) -> GraphModule:
+        flat_args = pytree.arg_tree_leaves(*args, **kwargs)
+
+        mesh = DeviceMesh("cuda", torch.arange(dist.get_world_size()).cuda())
+        shard_schema: Schema = Schema(mesh=mesh, placements=[Shard(0)])
+        # FIXME: allow other sharding schemas
+        replicate_schema: Schema = Schema(mesh=mesh, placements=[Replicate()])
+
+        inps, schemas = [], []
+
+        for p in pytree.tree_leaves(params_and_buffers):
+            assert isinstance(p, torch.Tensor), f"expecting Tensor but got {type(p)}"
+            inps.append(p)
+            schemas.append(replicate_schema)
+
+        for o in pytree.tree_leaves(named_states):
+            if isinstance(o, torch.Tensor):
+                inps.append(o)
+                schemas.append(replicate_schema)
+            else:
+                inps.append(torch.empty(0))
+                schemas.append(replicate_schema)
+
+        for a in flat_args:
+            if isinstance(a, torch.Tensor):
+                inps.append(a)
+                if id(a) in self._placements_override:
+                    schemas.append(
+                        Schema(mesh=mesh, placements=self._placements_override[id(a)])
+                    )
+                else:
+                    schemas.append(shard_schema)
+            else:
+                # Create dummy tensor and schema for non-tensor inputs for
+                # the purpose of dtensor expansion. Non-tensor inputs are
+                # guaranteed unused in dispatcher graphs produced by make_fx.
+                # However, we still need to respect them so that tensor inputs
+                # match wtih their placeholders.
+                inps.append(torch.empty(0))
+                schemas.append(shard_schema)
+
+        with FakeTensorMode(allow_non_fake_inputs=True):
+            fake_inps = [torch.empty_like(inp) for inp in inps]
+
+        return _convert_to_distributed(
+            gm, fake_inps, schemas, default_mesh=mesh, _allow_partial=False
+        )[0]
+
+    def transform_and_compile(self, gm: GraphModule) -> GraphModule:
+        """
+        Transform and compile a distributed graph with a set of graph transformation
+        and optimization passes for the dtensor fallback parallel mode.
+        """
+        # TODO: move the trasnformation passed to this function
+        return self._gm_passes(gm)

venv/lib/python3.10/site-packages/torch/distributed/_spmd/partial_lower.py

@@ -0,0 +1,268 @@
+# This file is copied from Meta internal repo and is not synced with the
+# internal version. Once the internal version is fully mature, we should
+# upstream again and retire the internal version. @yifuwang
+
+import logging
+import operator
+from typing import Callable, List, Optional, Set, Tuple
+
+from functorch import make_fx
+
+import torch
+
+from torch._inductor.compile_fx import compile_fx_inner
+from torch._inductor.decomposition import select_decomp_table
+
+MIN_ATEN_OPS_TO_LOWER = 10
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+def _create_subgraph_module(
+    inputs: List[torch.fx.Node], body: List[torch.fx.Node], outputs: List[torch.fx.Node]
+) -> torch.fx.GraphModule:
+    subgraph: torch.fx.Graph = torch.fx.Graph()
+    node_to_subgraph_node = {}
+    for idx, inp in enumerate(inputs):
+        subgraph_inp = subgraph.placeholder(name=f"arg_{idx}")
+        subgraph_inp.meta = inp.meta
+        node_to_subgraph_node[inp] = subgraph_inp
+
+    for node in body:
+        subgraph_node = subgraph.node_copy(
+            node, arg_transform=lambda x: node_to_subgraph_node[x]
+        )
+        node_to_subgraph_node[node] = subgraph_node
+
+    subgraph.output(result=tuple(node_to_subgraph_node[x] for x in outputs))
+    subgraph.eliminate_dead_code()
+    subgraph.lint()
+    return torch.fx.GraphModule(root={}, graph=subgraph)
+
+
+def _is_container_node(node: torch.fx.Node) -> bool:
+    if any(user.target == operator.getitem for user in node.users):
+        assert all(user.target == operator.getitem for user in node.users), (
+            "Malformed graph: a container node is used as input for non-getitem nodes."
+            "\nNode: {fmt_node}\nUsers: {fmt_users}".format(
+                fmt_node=node.format_node(),
+                fmt_users="\n".join(u.format_node() for u in node.users),
+            )
+        )
+        return True
+    return False
+
+
+def _lower_subgraph_nodes(
+    gm: torch.fx.GraphModule,
+    subgraph_name: str,
+    subgraph_nodes: List[torch.fx.Node],
+    dumper: Callable[[str], str],
+) -> None:
+    prologue: List[torch.fx.Node] = []
+    inputs: List[torch.fx.Node] = []
+    body: List[torch.fx.Node] = []
+    visible: Set[torch.fx.Node] = set()
+
+    # Inductor requires all graph input to be tensors. When adding a container
+    # node as subgraph input, add its descendant getitem nodes to the subgraph
+    # prologue and add its leaf getitem nodes to the subgraph input.
+    def add_input(arg: torch.fx.Node) -> None:
+        stack = [arg]
+        while len(stack) != 0:
+            node = stack.pop()
+            if _is_container_node(node):
+                # We should only prepone nodes within subgraph_nodes
+                prologue.extend(user for user in node.users if user in subgraph_nodes)
+                stack.extend(node.users)
+            else:
+                if node not in visible:
+                    inputs.append(node)
+                    visible.add(node)
+
+    for node in subgraph_nodes:
+        if node.op == "get_attr":
+            # Prepone get_attr to avoid having to copy
+            # the attribute to the subgraph module.
+            inputs.append(node)
+            visible.add(node)
+            continue
+
+        for arg in node.all_input_nodes:
+            if arg not in visible:
+                add_input(arg)
+
+        if node not in prologue:
+            body.append(node)
+            visible.add(node)
+
+    outputs: List[torch.fx.Node] = []
+
+    # Inductor requires all graph output to be tensors. When adding a container
+    # node as subgraph output, add its descendant getitem nodes to the subgraph
+    # body and add its leaf getitem nodes to the subgraph output.
+    def add_output(output: torch.fx.Node) -> None:
+        stack = [output]
+        while len(stack) != 0:
+            node = stack.pop()
+            if _is_container_node(node):
+                body.extend(node.users)
+                stack.extend(node.users)
+            elif not all(user in visible for user in node.users):
+                if node not in outputs:
+                    outputs.append(node)
+
+    for node in body:
+        if not all(user in visible for user in node.users):
+            add_output(node)
+
+    assert len(inputs) == len(set(inputs))
+    assert len(outputs) == len(set(outputs))
+
+    subgraph_module = _create_subgraph_module(inputs, body, outputs)
+    readable_tag = dumper(str(subgraph_module.graph))
+    setattr(gm, subgraph_name, _InductorModule(subgraph_module))
+
+    insertion_point = subgraph_nodes[-1].next
+    for node in prologue:
+        insertion_point.prepend(node)
+
+    with gm.graph.inserting_before(insertion_point):
+        # Insert subgraph call
+        subgraph_call = gm.graph.create_node(
+            op="call_module",
+            target=subgraph_name,
+            args=tuple(inputs),
+            kwargs={"tag": readable_tag},
+        )
+        # Replace parent graph nodes with their corresponding subgraph outputs
+        for idx, output in enumerate(outputs):
+            new_output = gm.graph.create_node(
+                op="call_function",
+                target=operator.getitem,
+                args=(subgraph_call, idx),
+            )
+            new_output.meta = output.meta
+            output.replace_all_uses_with(new_output)
+
+    # Erase lowered nodes from the parent graph
+    for node in reversed(body + outputs):
+        if len(node.users) == 0:
+            gm.graph.erase_node(node)
+
+
+class _InductorModule(torch.nn.Module):
+    def __init__(self, gm: torch.fx.GraphModule) -> None:
+        super().__init__()
+        self.gm = gm
+        self.compiled: Optional[
+            Callable[[List[torch.Tensor]], List[torch.Tensor]]
+        ] = None
+
+    def forward(self, *args: torch.Tensor, tag: str) -> List[torch.Tensor]:
+        if self.compiled is None:
+            inductor_decompositions = select_decomp_table()
+            # TODO: figure out why turning on cudagraphs cause exceptions.
+            decomp_gm = make_fx(self.gm, decomposition_table=inductor_decompositions)(
+                *args
+            )
+            logger.info("Lowering subgraph (%s) to Inductor...", tag)
+            self.compiled = compile_fx_inner(
+                decomp_gm,
+                list(args),
+                cudagraphs=False,
+            )
+            logger.info("Completed lowering subgraph (%s) to Inductor", tag)
+        with torch.profiler.record_function(tag):
+            assert self.compiled is not None
+            return self.compiled(list(args))
+
+
+def _is_inductor_compatible(node: torch.fx.Node) -> Tuple[bool, str]:
+    # `has_tag` is not supported yet
+    # if has_tag(node, "non_lowerable"):
+
+    if node.target in (
+        torch.ops.aten._fused_adam_.default,
+        torch.ops.aten._fused_adam.default,
+        torch.ops.aten._foreach_add_.Scalar,
+        torch.ops.aten._foreach_add.Scalar,
+    ):
+        return False, "fused adam is not supported yet"
+
+    # TODO(yifu): apparently having a meta kernel is not a necessary
+    # condition for Inductor compatiblity. We should refine the check.
+    # Sneaking this one in for now to support comm_fusion_with_cat.
+    if node.target == torch.ops.aten.flatten.using_ints:
+        return True, ""
+
+    if isinstance(node.target, torch._ops.OpOverload):
+        if not node.target.has_kernel_for_dispatch_key(torch._C.DispatchKey.Meta):
+            return False, f"{node.target} doesn't have a meta kernel registered"
+    return True, ""
+
+
+def _subgraph_predicate(nodes: List[torch.fx.Node]) -> bool:
+    num_aten_ops = len([n for n in nodes if str(n.target).startswith("aten.")])
+    return num_aten_ops >= MIN_ATEN_OPS_TO_LOWER
+
+
+def partial_lower(
+    gm: torch.fx.GraphModule,
+    node_predicate: Callable[[torch.fx.Node], bool] = lambda x: True,
+    subgraph_predicate: Callable[[List[torch.fx.Node]], bool] = lambda x: True,
+    dumper: Callable[[str], str] = lambda x: "subgraph",
+) -> torch.fx.GraphModule:
+    """
+    Lower Inductor compatible portions of the graph module to Inductor.
+
+    Args:
+        node_predicate: user predicate for determining whether to consider a node for
+            lowering.
+        subgraph_predicate: user predicate for determining whether to consider a list of
+            candidate nodes for lowering.
+        dumper: a callback for dumping subgraphs for human digestion. For exmaple, it
+            can be a function that writes to disk/blob storage and returns the
+            path/handle. The returned path/handle for each subgraph will be made
+            available in the subgraph call node in the parent graph, as well as the
+            label of the profiler block for the subgraph.
+    """
+    nodes_per_subgraph: List[List[torch.fx.Node]] = [[]]
+    ptr = next(iter(gm.graph.nodes))
+
+    def _node_predicate(node: torch.fx.Node) -> Tuple[bool, str]:
+        should_lower, reason = _is_inductor_compatible(node)
+        if not should_lower:
+            return should_lower, reason
+        if not node_predicate(node):
+            return False, "user predicate"
+        return True, ""
+
+    while ptr.op != "output":
+        if ptr.op == "placeholder":
+            ptr = ptr.next
+            continue
+        should_lower, reason = _node_predicate(ptr)
+        if should_lower:
+            nodes_per_subgraph[-1].append(ptr)
+        else:
+            if len(nodes_per_subgraph[-1]) > 0:
+                logger.warning(
+                    "partial_lower: graph break at %s. Reason: %s", str(ptr), reason
+                )
+            nodes_per_subgraph.append([])
+        ptr = ptr.next
+
+    nodes_per_subgraph = [
+        nodes
+        for nodes in nodes_per_subgraph
+        if subgraph_predicate(nodes) and _subgraph_predicate(nodes)
+    ]
+
+    for idx, subgraph_nodes in enumerate(nodes_per_subgraph):
+        subgraph_name = f"subgraph_{idx}"
+        _lower_subgraph_nodes(gm, subgraph_name, subgraph_nodes, dumper)
+
+    gm.graph.lint()
+    gm.recompile()
+    return gm