executorch 1.6.0__cp315-cp315-win_amd64.whl

executorch/exir/program/_program.py

@@ -0,0 +1,2056 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+# Copyright 2025-2026 Arm Limited and/or its affiliates.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# pyre-strict
+import copy
+import io
+import logging
+import os
+from collections import defaultdict
+from typing import Any, Dict, List, Optional, Sequence, Set, TextIO, Type, Union
+
+import torch
+import torch._export
+from executorch.exir._serialize._cord import Cord
+from executorch.exir._serialize._named_data_store import (
+    NamedDataStore,
+    NamedDataStoreOutput,
+)
+from executorch.exir._serialize._serialize import serialize_for_executorch
+from executorch.exir._serialize.data_serializer import DataSerializer
+from executorch.exir._warnings import experimental
+from executorch.exir.backend.backend_api import (
+    MethodProgramsPartitionerSpec,
+    to_backend,
+)
+from executorch.exir.backend.partitioner import Partitioner
+from executorch.exir.capture._config import EdgeCompileConfig, ExecutorchBackendConfig
+from executorch.exir.delegate import executorch_call_delegate, is_lowered_module
+from executorch.exir.emit import emit_program, EmitterOutput
+from executorch.exir.emit._emitter import _DelegateDebugIdentifierMap
+from executorch.exir.error import ExportError
+from executorch.exir.graph_module import (
+    contains_any_call_fn_target_op,
+    get_control_flow_submodules,
+)
+from executorch.exir.operator.convert import _pybind_schema_to_native_schema
+from executorch.exir.operator.util import _QUANT_PRIMITIVES
+from executorch.exir.pass_base import PassBase
+from executorch.exir.pass_manager import ExportedProgramPassManager, PassType
+
+from executorch.exir.passes import (
+    base_post_op_replace_passes,
+    base_pre_op_replace_passes,
+    convert_constant_dim_order_pass,
+    dead_code_elimination_pass,
+    EdgeToBackendOpsPass,
+    LegalizePortableDimOrderPass,
+    MemoryFormatOpsPass,
+    OpReplacePass,
+    remove_unused_parameters_pass,
+    ReplaceEmptyLikePass,
+)
+from executorch.exir.passes.delegate_scratch_pass import DelegateScratchSpecPass
+from executorch.exir.passes.external_constants_pass import (
+    external_constants_pass,
+    external_mutable_weights_pass,
+)
+from executorch.exir.passes.insert_write_back_for_buffers_pass import (
+    insert_write_back_for_buffers_pass,
+)
+from executorch.exir.passes.normalize_view_copy_base_pass import (
+    NormalizeViewCopyBasePass,
+)
+from executorch.exir.passes.propagate_device_config import PropagateDeviceConfig
+from executorch.exir.passes.propagate_device_pass import PropagateDevicePass
+from executorch.exir.passes.quant_fusion_pass import quant_fusion_and_const_prop_pass
+from executorch.exir.passes.reinplace import DEFAULT_INPLACEABLE_OPS, reinplace_pass
+from executorch.exir.passes.remove_graph_asserts_pass import (
+    RemoveGraphAssertsPass,
+    RemoveNonCoreAtenOpGraphAssertsPass,
+)
+from executorch.exir.passes.remove_mixed_type_operators import RemoveMixedTypeOperators
+from executorch.exir.passes.replace_aten_with_edge_pass import aten_to_edge
+from executorch.exir.passes.replace_view_copy_with_view_pass import (
+    ReplaceViewCopyWithViewPass,
+)
+from executorch.exir.passes.spec_prop_pass import SpecPropPass
+from executorch.exir.passes.weights_to_outputs_pass import weights_to_outputs_pass
+from executorch.exir.print_program import pretty_print, print_program
+from executorch.exir.schema import Program
+from executorch.exir.tracer import _default_decomposition_table
+from executorch.exir.verification.verifier import (
+    EXIRATenDialectVerifier,
+    EXIREdgeDialectVerifier,
+    get_aten_verifier,
+)
+from torch._export.passes import ReplaceViewOpsWithViewCopyOpsPass
+from torch._export.utils import _detect_fake_mode_from_gm
+from torch._export.verifier import Verifier
+from torch.export import ExportedProgram
+from torch.export._remove_auto_functionalized_pass import (
+    unsafe_remove_auto_functionalized_pass,
+)
+from torch.export.exported_program import InputKind, InputSpec, TensorArgument
+from torch.fx import _pytree as fx_pytree
+from torch.fx._compatibility import compatibility
+from torch.fx.passes.infra.pass_manager import PassManager as GraphModulePassManager
+
+from torch.utils import _pytree as pytree
+
+Val = Any
+
+from typing import Any, Callable
+
+from torch.library import Library
+
+try:
+    from executorch.exir.program.fb.logger import et_logger
+except ImportError:
+    # Define a stub decorator that does nothing
+    def et_logger(api_name: str) -> Callable[[Any], Any]:
+        def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+            def wrapper(*args: Any, **kwargs: Any) -> Any:
+                return func(*args, **kwargs)
+
+            return wrapper
+
+        return decorator
+
+
+# This is the reserved namespace that is used to register ops to that will
+# be prevented from being decomposed during to_edge_transform_and_lower.
+edge_no_decomp_namespace = "EDGE_DO_NOT_DECOMP"
+lib = Library(edge_no_decomp_namespace, "DEF")
+# Map from aten ops to the transformed ops registered in the edge_no_decomp_namespace.
+aten_op_to_transform_op = {}
+# Map from the transformed ops registered in the edge_no_decomp_namespace to aten ops.
+transform_op_to_aten_op = {}
+
+
+from executorch.exir._program_utils import (  # noqa: E402
+    _get_updated_graph_signature,
+    _get_updated_range_constraints,
+)
+
+
+def _transform(
+    self,
+    *passes: PassType,
+    override_verifiers: None | list[Type[Verifier]] = None,
+) -> "ExportedProgram":
+    """
+    Transforms the program according to the provided passes.
+
+    Args:
+        self: The ExportedProgram instance to transform
+        *passes: A sequence of passes to apply to the program
+        override_verifiers: Optional list of verifier classes to use instead of the default verifiers.
+            This is needed if the transforms yields illegal graph that the default verifier cannot handle.
+
+    Returns:
+        ExportedProgram: A new ExportedProgram with the transformations applied, or self if no changes were made
+    """
+    # A user friendly check to avoid vararg surprises, PEP 3102
+    assert not any(
+        isinstance(p, (list, Verifier)) for p in passes
+    ), f"Expected all passes to be of PassType, not list or Verifier. Use override_verifiers kwarg instead. Got: {list(passes)}"
+
+    return _transform_with_pass_manager(
+        self, ExportedProgramPassManager(list(passes)), override_verifiers
+    )
+
+
+def _transform_with_pass_manager(
+    self: ExportedProgram,
+    pass_manager: Union[ExportedProgramPassManager, GraphModulePassManager],
+    override_verifiers: None | list[Type[Verifier]] = None,
+) -> "ExportedProgram":
+    """
+    Transforms the program using the provided pass_manager.
+
+    Args:
+        self: The ExportedProgram instance to transform
+        pass_manager: An instance of PassManager to apply transformations.
+            - ExportedProgramPassManager: operates on the full ExportedProgram
+            - GraphModulePassManager: operates on the GraphModule only
+        override_verifiers: Optional list of verifier classes to use instead of the default verifiers.
+            This is needed if the transforms yields illegal graph that the default verifier cannot handle.
+
+    Returns:
+        ExportedProgram: A new ExportedProgram with the transformations applied, or self if no changes were made
+    """
+    if isinstance(pass_manager, ExportedProgramPassManager):
+        res = pass_manager(self, override_verifiers)
+        if not res.modified:
+            return self
+        return res.exported_program
+    else:
+        res = pass_manager(self.graph_module)
+        if not res.modified:
+            return self
+        return _update_exported_program_graph_module(
+            self, res.graph_module, override_verifiers
+        )
+
+
+def _update_exported_program_graph_module(
+    exported_program: ExportedProgram,
+    gm: torch.fx.GraphModule,
+    override_verifiers: None | list[Type[Verifier]] = None,
+) -> "ExportedProgram":
+    transformed_ep = ExportedProgram(
+        root=gm,
+        graph=gm.graph,
+        graph_signature=_get_updated_graph_signature(
+            exported_program.graph_signature, gm
+        ),
+        state_dict=exported_program.state_dict,
+        range_constraints=_get_updated_range_constraints(
+            gm, exported_program.range_constraints
+        ),
+        module_call_graph=copy.deepcopy(exported_program._module_call_graph),
+        example_inputs=exported_program.example_inputs,
+        constants=exported_program.constants,
+        verifiers=override_verifiers or [exported_program.verifier],
+    )
+    transformed_ep.graph_module.meta.update(exported_program.graph_module.meta)
+    transformed_ep.graph_module.meta.update(gm.meta)
+    return transformed_ep
+
+
+def _copy_module(new_prog, new_gm):
+    new_prog.meta.update(new_gm.meta)
+    new_prog.graph = new_gm.graph
+    submodules = [name for name, _ in new_prog.named_children()]
+    for name in submodules:
+        delattr(new_prog, name)
+    for name, mod in new_gm.named_children():
+        setattr(new_prog, name, mod)
+    for node in new_gm.graph.nodes:
+        if node.op == "get_attr":
+            t = getattr(new_gm, node.target, None)
+            if isinstance(t, torch.Tensor):
+                setattr(new_prog, node.target, t)
+
+
+def _create_empty_etrecord():
+    # Import etrecord at runtime to resolve cyclic dependencies (program -> etrecord -> program).
+    # This also ensures that etrecord-related packages do not affect the export flow.
+    # @manual
+    from executorch.devtools.etrecord import ETRecord
+
+    return ETRecord()
+
+
+def lift_constant_tensor_pass(ep):
+    """
+    Takes an ExportedProgram and returns the ExportedProgram modified in-place,
+    with the constant tensors as buffers.
+    """
+    if len([node for node in ep.graph.nodes if node.op == "placeholder"]) == 0:
+        return ep
+
+    graph_signature = ep.graph_signature
+    buffers = list(graph_signature.buffers)
+
+    fake_mode = _detect_fake_mode_from_gm(ep.graph_module)
+
+    first_user_input = None
+    lifted_constants = []
+    for node in ep.graph.nodes:
+        if node.op == "placeholder" and node.name in graph_signature.user_inputs:
+            first_user_input = node
+            break
+
+    for node in ep.graph.nodes:
+        if node.op == "get_attr":
+            constant_tensor = getattr(ep.graph_module, node.target)
+            if not isinstance(constant_tensor, torch.Tensor):
+                continue
+
+            constant_tensor_fqn = f"_lifted_tensor_constant{len(buffers)}"
+
+            with ep.graph.inserting_before(first_user_input):
+                # Insert the constant node before the first user input
+                const_placeholder_node = ep.graph.placeholder(constant_tensor_fqn)
+                for k, v in node.meta.items():
+                    const_placeholder_node.meta[k] = v
+                if fake_mode is not None:
+                    const_placeholder_node.meta["val"] = fake_mode.from_tensor(
+                        constant_tensor, static_shapes=True
+                    )
+                else:
+                    const_placeholder_node.meta["val"] = constant_tensor
+                const_placeholder_node.meta["val"].constant = constant_tensor
+                node.replace_all_uses_with(const_placeholder_node)
+                ep.graph.erase_node(node)
+
+                # Add the constant as a buffer to the graph signature
+                lifted_constants.append(
+                    InputSpec(
+                        kind=InputKind.BUFFER,
+                        arg=TensorArgument(name=const_placeholder_node.name),
+                        target=constant_tensor_fqn,
+                        persistent=True,
+                    )
+                )
+                buffers.append(constant_tensor_fqn)
+                ep.state_dict[constant_tensor_fqn] = constant_tensor
+
+    new_input_specs = []
+    for s in graph_signature.input_specs:
+        if s.kind == InputKind.USER_INPUT and len(lifted_constants) > 0:
+            new_input_specs.extend(lifted_constants)
+            lifted_constants.clear()
+        new_input_specs.append(s)
+    if len(lifted_constants) > 0:
+        new_input_specs = lifted_constants + new_input_specs
+    ep.graph_signature.input_specs = new_input_specs
+    ep.graph_module.recompile()
+    return ep
+
+
+# Stub to ease migration from `transform` to private `_transform`
+def transform_exported_program(ep, *passes: PassType) -> ExportedProgram:
+    if hasattr(ep, "_transform"):
+        return ep._transform(*passes)
+    else:
+        return ep.transform(*passes)
+
+
+class HackedUpExportedProgramDONOTUSE(ExportedProgram):
+    def __init__(
+        self,
+        root,
+        graph,
+        graph_signature,
+        call_spec,
+        state_dict,
+        range_constraints,
+        module_call_graph,
+        example_inputs,
+        verifier,
+    ):
+        super().__init__(
+            root=root,
+            graph=graph,
+            graph_signature=graph_signature,
+            state_dict=state_dict,
+            range_constraints=range_constraints,
+            module_call_graph=module_call_graph,
+            example_inputs=example_inputs,
+            verifier=verifier,
+        )
+
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        import torch._export.error as error
+
+        if self.call_spec.in_spec is not None:
+            user_args = args
+            try:
+                args = fx_pytree.tree_flatten_spec(user_args, self.call_spec.in_spec)  # type: ignore[assignment]
+            except Exception:
+                _, received_spec = pytree.tree_flatten(user_args)
+                raise error.InternalError(
+                    "Trying to flatten user inputs with exported input tree spec: \n"
+                    f"{self.call_spec.in_spec}\n"
+                    "but actually got inputs with tree spec of: \n"
+                    f"{received_spec}"
+                )
+
+        ordered_params = tuple(
+            self.state_dict[name] for name in self.graph_signature.parameters
+        )
+        ordered_buffers = tuple(
+            self.state_dict[name] for name in self.graph_signature.buffers
+        )
+
+        with torch.no_grad():
+            # NOTE: calling convention is first params, then buffers, then args as user supplied them.
+            # See: torch/_functorch/aot_autograd.py#L1034
+            res = torch.fx.Interpreter(self.graph_module).run(
+                *ordered_params, *ordered_buffers, *args, enable_io_processing=False
+            )
+
+        if self.call_spec.out_spec is not None:
+            mutation = self.graph_signature.buffers_to_mutate
+            num_mutated = len(mutation)
+            mutated_buffers = res[:num_mutated]
+
+            # Exclude dependency token from final result.
+            assertion_dep_token = self.graph_signature.assertion_dep_token
+            if assertion_dep_token is not None:
+                assertion_dep_token_index = list(assertion_dep_token.keys())[0]
+                res = res[:assertion_dep_token_index]
+
+            res = res[num_mutated:]
+            try:
+                res = pytree.tree_unflatten(res, self.call_spec.out_spec)
+            except Exception:
+                _, received_spec = pytree.tree_flatten(res)
+                raise error.InternalError(
+                    "Trying to flatten user outputs with exported output tree spec: \n"
+                    f"{self.call_spec.out_spec}\n"
+                    "but actually got outputs with tree spec of: \n"
+                    f"{received_spec}"
+                )
+            finally:
+                ix = 0
+                for buffer in self.graph_signature.buffers_to_mutate.values():
+                    self.state_dict[buffer] = mutated_buffers[ix]
+                    ix += 1
+        return res
+
+
+@compatibility(is_backward_compatible=False)
+class ExirExportedProgram:
+    def __init__(
+        self,
+        exported_program: ExportedProgram,
+        after_to_edge_passes: bool,
+        compile_config: Optional[EdgeCompileConfig] = None,
+    ):
+        self.exported_program = exported_program
+
+        # Add a flag to denote whehter to_edge is called on this program
+        # to detect misusage of directly calling to_executorch without to_edge
+        self.after_to_edge_passes = after_to_edge_passes
+        self.compile_config = compile_config or EdgeCompileConfig()
+
+    def transform(self, *passes: PassType) -> "ExirExportedProgram":
+        self.exported_program = _transform(self.exported_program, *passes)
+        return self
+
+    def __call__(self, *args: Any) -> Any:
+        return self.exported_program.module()(*args)
+
+    # TODO(ycao): Change this to a composable function.
+    def to_edge(
+        self, config: Optional[EdgeCompileConfig] = None
+    ) -> "ExirExportedProgram":
+        config = config or EdgeCompileConfig()
+        assert isinstance(
+            self.exported_program.graph_module, torch.fx.GraphModule
+        ), f"type is instead: {type(self.exported_program.graph_module).__name__}"
+
+        return _to_edge(self, config)
+
+    def dump(self) -> None:
+        print(self.exported_program.graph_module.graph)
+
+    def to_executorch(
+        self,
+        config: Optional[ExecutorchBackendConfig] = None,
+    ) -> "ExecutorchProgram":
+        if not self.after_to_edge_passes:
+            raise RuntimeError("Must run to_edge before to_executorch.")
+        config = config or ExecutorchBackendConfig()
+        new_gm = self.exported_program.graph_module
+        for p in edge_to_executorch_passes(
+            config, edge_compile_config=self.compile_config
+        ):
+            new_gm_res = p(new_gm)
+            assert new_gm_res is not None
+            new_gm = new_gm_res.graph_module
+
+        # This is tech debt on tech debt. memory planning pass inherits from some pass infra for GMs.
+        # This isnt enough info now so i cant use call I have to use some new function 'run'.
+        # Existing user passes dont use run so Im just cheating here because they dont need to work on mutable buffers yet.
+        # After exir.capture is gone I will clean up the memory planning infra to be consistent.
+        # Frankly all of exir has big code quality issues because of the migrations that need to be addressed.
+        new_gm_res = config.memory_planning_pass(new_gm)  # pyre-ignore[29]
+        assert new_gm_res is not None
+        new_gm = new_gm_res.graph_module
+        new_prog = ExirExportedProgram(
+            copy.deepcopy(self.exported_program), self.after_to_edge_passes
+        )
+        _copy_module(new_prog.exported_program.graph_module, new_gm)
+        executorch_prog = ExecutorchProgram(
+            new_prog,
+            emit_stacktrace=config.emit_stacktrace,
+            extract_delegate_segments=config.extract_delegate_segments,
+            segment_alignment=config.segment_alignment,
+            constant_tensor_alignment=config.constant_tensor_alignment,
+            delegate_alignment=config.delegate_alignment,
+        )
+        executorch_prog.graph_module.meta.update(new_gm.meta)
+        executorch_prog.graph_module.meta.update(
+            self.exported_program.graph_module.meta
+        )
+        return executorch_prog
+
+    def __deepcopy__(
+        self, memo: Optional[Dict[int, Any]] = None
+    ) -> "ExirExportedProgram":
+        new_eep = ExirExportedProgram(
+            copy.deepcopy(self.exported_program, memo),
+            self.after_to_edge_passes,
+            copy.deepcopy(self.compile_config, memo),
+        )
+        return new_eep
+
+
+@compatibility(is_backward_compatible=False)
+class ExecutorchProgram:
+    def __init__(
+        self,
+        exir_exported_program: ExirExportedProgram,
+        emit_stacktrace: bool,
+        extract_delegate_segments: bool,
+        segment_alignment: int,
+        constant_tensor_alignment: Optional[int] = None,
+        delegate_alignment: Optional[int] = None,
+    ) -> None:
+        if not exir_exported_program.after_to_edge_passes:
+            raise RuntimeError(
+                "Need to call prog.to_edge prior to constructing ExecutorchProgram."
+            )
+        self.exported_program = exir_exported_program.exported_program
+        self._pte_data: Optional[Cord] = None
+        self._tensor_data: Optional[Dict[str, Cord]] = None
+        self._buffer: Optional[bytes] = None
+        self._emitter_output: Optional[EmitterOutput] = None
+        self._emit_stacktrace: bool = emit_stacktrace
+        self._extract_delegate_segments: bool = extract_delegate_segments
+        self._segment_alignment: int = segment_alignment
+        self._constant_tensor_alignment: Optional[int] = constant_tensor_alignment
+        self._delegate_alignment: Optional[int] = delegate_alignment
+        from executorch.extension.flat_tensor.serialize.serialize import (
+            FlatTensorConfig,
+            FlatTensorSerializer,
+        )
+
+        self._data_serializer: DataSerializer = FlatTensorSerializer(
+            FlatTensorConfig(self._segment_alignment)
+        )
+
+    def _get_emitter_output(self) -> EmitterOutput:
+        if self._emitter_output is None:
+            self._emitter_output = emit_program(
+                self.exported_program, self._emit_stacktrace
+            )
+        return self._emitter_output
+
+    def _get_pte_data(self) -> Cord:
+        if self._pte_data is None:
+            self._pte_data, self._tensor_data = serialize_for_executorch(
+                self._get_emitter_output(),
+                ExecutorchBackendConfig(
+                    extract_delegate_segments=self._extract_delegate_segments,
+                    segment_alignment=self._segment_alignment,
+                    constant_tensor_alignment=self._constant_tensor_alignment,
+                    delegate_alignment=self._delegate_alignment,
+                ),
+                self._data_serializer,
+            )
+        assert self._pte_data is not None
+        return self._pte_data
+
+    @property
+    def buffer(self) -> bytes:
+        """Returns the serialized ExecuTorch binary as a byte string.
+
+        Note that the call to `buffer` may allocate a very large amount of
+        contiguous memory, depending on the model size. If writing to a file,
+        use `write_to_file` which won't incur additional copies.
+        """
+        # TODO(T181494963): update pybinding to remove buffer cache, which can consume large
+        # amounts of memory longer than necessary.
+        if self._buffer is None:
+            self._buffer = bytes(self._get_pte_data())
+        return self._buffer
+
+    @property
+    @experimental("This API is experimental and subject to change without notice.")
+    def data_files(self) -> Dict[str, bytes]:
+        """Returns the data files as a dictionary of filename to byte data.
+
+        Returns:
+            Dict[str, bytes]: Dictionary mapping data filenames (e.g., .ptd files) to
+                their serialized byte content.
+            Returns empty dict if no data files are available.
+        """
+        if self._pte_data is None:
+            self._get_pte_data()  # This populates _tensor_data
+
+        if self._tensor_data is None:
+            return {}
+
+        return {filename: bytes(cord) for filename, cord in self._tensor_data.items()}
+
+    @property
+    def program(self) -> Program:
+        return self._get_emitter_output().program
+
+    @property
+    def debug_handle_map(self) -> Dict[int, Union[int, List[int]]]:
+        if self._emitter_output:
+            return self._emitter_output.debug_handle_map
+        return self._get_emitter_output().debug_handle_map
+
+    @property
+    def delegate_map(
+        self,
+    ) -> Dict[str, Dict[int, Dict[str, Union[str, _DelegateDebugIdentifierMap]]]]:
+        if self._emitter_output:
+            return self._emitter_output.method_to_delegate_debug_id_map
+        return self._get_emitter_output().method_to_delegate_debug_id_map
+
+    @property
+    def instruction_id_to_num_outs_map(
+        self,
+    ) -> Dict[str, Dict[int, Union[int, List[int]]]]:
+        if self._emitter_output:
+            return self._emitter_output.instruction_id_to_num_outs_map
+        return self._get_emitter_output().instruction_id_to_num_outs_map
+
+    @property
+    def graph_module(self) -> torch.fx.GraphModule:
+        return self.exported_program.graph_module
+
+    # TODO (zhxchen17) Change this to property.
+    def dump_graph_module(self) -> torch.fx.GraphModule:
+        return self.exported_program.graph_module
+
+    def dump_exported_program(self) -> ExportedProgram:
+        return self.exported_program
+
+    def write_to_file(self, open_file: io.BufferedIOBase) -> None:
+        """
+        Writes the serialized ExecuTorch binary to the file at `open_file`. Prefer to use this over
+        `buffer`, as it writes to file without copying into a contiguous block of memory first,
+        reducing the peak memory usage.
+        """
+        self._get_pte_data().write_to_file(open_file)
+
+    def write_tensor_data_to_file(self, outdir) -> None:
+        """
+        Writes the serialized ExecuTorch data files to the directory at `outdir`.
+        """
+        assert self._tensor_data is not None
+        # pyre-ignore[16]: `Optional` has no attribute `items`.
+        for filename, cord in self._tensor_data.items():
+            with open(os.path.join(outdir, f"{filename}.ptd"), "wb") as f:
+                logging.info(f"Writing data file to {filename}.ptd")
+                cord.write_to_file(f)
+
+
+def _get_aten_to_edge_passes(config: EdgeCompileConfig):
+    # TODO: the last two passes for aten_to_edge need to be eliminated_dead_code -> debug_handle_generator. After enable
+    # use_edge_op it can be moved to aten_to_edge_passes before eliminated_dead_code pass. Also ExportPass doesn't play
+    # well with node.meta, meaning after some passes permuting operators, we may lose some information in node.meta.
+    # It might be regenerated in SpecPropPass so it may not be visiable. However debug handle will be lost.
+
+    pre_op_replace_passes = base_pre_op_replace_passes + [RemoveMixedTypeOperators()]
+
+    post_op_replace_passes = base_post_op_replace_passes
+
+    return pre_op_replace_passes, post_op_replace_passes
+
+
+def _to_edge(ep, config: EdgeCompileConfig) -> "ExirExportedProgram":
+    if config._check_ir_validity:
+        try:
+            EXIRATenDialectVerifier()(ep.exported_program.graph_module)
+        except ExportError:
+            logging.info(
+                "If a particular operator failed core ATen IR check, please consider adding it to the exception list. "
+                "Add the operator to _core_aten_ops_exception_list in EdgeCompileConfig. This is the recommended way "
+                "to resolve this type of failure, so that the rest of the IR validation check can still be performed.\n"
+                "If you'd like to disable IR validation checking, please set _check_ir_validity in EdgeCompileConfig, "
+                "like *.to_edge(exir.EdgeCompileConfig(_check_ir_validity=False))."
+            )
+            raise
+
+    dialect = ep.exported_program.dialect
+    if dialect == "ATEN":
+        ep = ExirExportedProgram(
+            ExportedProgram(
+                root=ep.exported_program.graph_module,
+                graph=ep.exported_program.graph_module.graph,
+                graph_signature=ep.exported_program.graph_signature,
+                state_dict=ep.exported_program.state_dict,
+                range_constraints=ep.exported_program.range_constraints,
+                module_call_graph=ep.exported_program.module_call_graph,
+                example_inputs=ep.exported_program.example_inputs,
+                constants=ep.exported_program.constants,
+                verifiers=[
+                    get_aten_verifier(
+                        config=config,
+                    )
+                ],
+            ),
+            False,
+            config,
+        )
+    pre_op_replace_passes, post_op_replace_passes = _get_aten_to_edge_passes(config)
+
+    new_ep = copy.deepcopy(ep).transform(*pre_op_replace_passes)
+    if dialect == "ATEN":
+        new_ep.exported_program = lift_constant_tensor_pass(new_ep.exported_program)
+
+    new_gm = new_ep.exported_program.graph_module
+    new_gm_res = OpReplacePass()(new_gm)
+    assert new_gm_res is not None
+    new_gm = new_gm_res.graph_module
+    if not config._skip_dim_order:
+        new_gm_res = MemoryFormatOpsPass()(new_gm)
+        assert new_gm_res is not None
+        new_gm = new_gm_res.graph_module
+
+    for p in post_op_replace_passes:
+        new_gm_res = p(new_gm)
+        assert new_gm_res is not None
+        new_gm = new_gm_res.graph_module
+
+    new_ep.exported_program = ExportedProgram(
+        root=new_gm,
+        graph=new_gm.graph,
+        graph_signature=_get_updated_graph_signature(
+            new_ep.exported_program.graph_signature, new_gm
+        ),
+        state_dict=new_ep.exported_program.state_dict,
+        range_constraints=new_ep.exported_program.range_constraints,
+        module_call_graph=new_ep.exported_program.module_call_graph,
+        example_inputs=new_ep.exported_program.example_inputs,
+        constants=new_ep.exported_program.constants,
+        verifiers=[
+            EXIREdgeDialectVerifier(
+                edge_compile_config=config,
+                class_only=True,
+            )
+        ],
+    )
+    new_ep.after_to_edge_passes = True
+    return new_ep
+
+
+def pre_memory_planning_passes(
+    config: ExecutorchBackendConfig, name: Optional[str] = None
+) -> List[PassType]:
+    """
+    Returns a list of passes to run before memory planning.
+    Get the sym shape eval pass based on the method name, if the pass is not in the dict, use the default pass.
+    """
+    # Handle symbolic shape eval pass
+    if isinstance(config.sym_shape_eval_pass, dict):
+        default_pass = ExecutorchBackendConfig().sym_shape_eval_pass
+        if not name:
+            sym_shape_eval_pass = default_pass
+        # pyre-ignore: Undefined attribute [16]
+        sym_shape_eval_pass = config.sym_shape_eval_pass.get(name, default_pass)
+    elif isinstance(config.sym_shape_eval_pass, PassBase):
+        sym_shape_eval_pass = config.sym_shape_eval_pass
+    else:
+        raise RuntimeError(
+            f"sym_shape_eval_pass must be a dict or a PassBase, got {config.sym_shape_eval_pass}"
+        )
+    if config.remove_view_copy:
+        return [
+            NormalizeViewCopyBasePass(),
+            dead_code_elimination_pass,
+            ReplaceViewCopyWithViewPass(),
+            sym_shape_eval_pass,
+            config.to_out_var_pass,
+            DelegateScratchSpecPass(),
+        ]
+    else:
+        return [
+            sym_shape_eval_pass,
+            config.to_out_var_pass,
+            DelegateScratchSpecPass(),
+        ]
+
+
+def edge_to_executorch_passes(
+    config: ExecutorchBackendConfig,
+    name: Optional[str] = None,
+    edge_compile_config: Optional[EdgeCompileConfig] = None,
+) -> List[PassType]:
+    """
+    Returns a list of passes to lower from edge to executorch.
+    Get the pre memory planning passes based on the method name, if the pass is not in the dict, use the default pass.
+    """
+    # Handle propagate device config
+    propagate_device_config = config.propagate_device_config
+    if isinstance(propagate_device_config, dict):
+        device_cfg = propagate_device_config.get(name, PropagateDeviceConfig())
+    else:
+        device_cfg = propagate_device_config
+
+    edge_compile_config = edge_compile_config or EdgeCompileConfig()
+    passes: List[PassType] = [
+        # ExecuTorch backend ops are unable to handle unbacked symints. So after
+        # this pass, passes cannot be Interpreter-based, because it will fail if
+        # there exists an unbacked symint operation.
+        *config.passes,
+        SpecPropPass(),
+        PropagateDevicePass(
+            skip_h2d_for_method_inputs=device_cfg.skip_h2d_for_method_inputs,
+            skip_d2h_for_method_outputs=device_cfg.skip_d2h_for_method_outputs,
+            enable_non_cpu_memory_planning=config.enable_non_cpu_memory_planning,
+            error_on_per_call_copies=device_cfg.error_on_per_call_copies,
+            skip_h2d_for_constants=device_cfg.skip_h2d_for_constants,
+        ),
+        EdgeToBackendOpsPass(),
+        RemoveGraphAssertsPass(),
+    ] + pre_memory_planning_passes(config, name)
+
+    if not edge_compile_config._skip_dim_order:
+        passes.insert(len(config.passes), LegalizePortableDimOrderPass())
+
+    return passes
+
+
+def _generate_edge_program(
+    config: EdgeCompileConfig,
+    program: ExportedProgram,
+    core_aten_ops_exception_list: Optional[List[torch._ops.OpOverload]] = None,
+    preserve_ops: Optional[List[torch._ops.OpOverload]] = None,
+) -> ExportedProgram:
+    """
+    Args:
+        config: The configuration for the edge program.
+        program: The exported program to be converted to an edge program.
+        core_aten_ops_exception_list: A list of aten ops that are missing decompositions to core aten.
+        preserve_ops: A list of aten ops that should not be decomposed.
+    Returns:
+        An ExportedProgram in edge dialect.
+    """
+    # Remove unused parameters
+    program = remove_unused_parameters_pass(program)
+
+    if not config._skip_dim_order:
+        # Normalize constants, buffers, parameters and inputs before
+        # partitioning, so a delegate sees the layout the program stores, and before
+        # MemoryFormatOpsPass rewrites preserve-format copies, which cannot
+        # represent arbitrary dim orders.
+        program = convert_constant_dim_order_pass.convert_constant_dim_order_pass(
+            program
+        )
+
+    pre_op_replace_passes, post_op_replace_passes = _get_aten_to_edge_passes(config)
+
+    passes = [
+        # Remove invalid assert ops, such as _assert_tensor_metadata
+        RemoveNonCoreAtenOpGraphAssertsPass(),
+        # TODO move inside aten_to_edge passes after all users are migrated off v1 capture
+        ReplaceViewOpsWithViewCopyOpsPass(),
+    ]
+    passes.extend(pre_op_replace_passes)
+    empty_like = torch.ops.aten.empty_like.default
+    if (
+        empty_like not in (preserve_ops or [])
+        and empty_like not in config.preserve_ops
+        and contains_any_call_fn_target_op(program.graph_module, [empty_like])
+    ):
+        passes.append(ReplaceEmptyLikePass())
+    passes.append(OpReplacePass())
+    if not config._skip_dim_order:
+        passes.append(MemoryFormatOpsPass())
+
+    gm = program.graph_module
+    for p in passes:
+        gm_res = p(gm)
+        assert gm_res is not None
+        gm = gm_res.graph_module
+
+    edge_program = ExportedProgram(
+        root=gm,
+        graph=gm.graph,
+        graph_signature=_get_updated_graph_signature(program.graph_signature, gm),
+        state_dict=program.state_dict,
+        range_constraints=program.range_constraints,
+        module_call_graph=program.module_call_graph,
+        example_inputs=program.example_inputs,
+        constants=program.constants,
+        verifiers=[
+            EXIREdgeDialectVerifier(
+                edge_compile_config=config,
+                class_only=True,
+                core_aten_ops_exception_list=core_aten_ops_exception_list,
+                preserve_ops=preserve_ops,
+            )
+        ],
+    )
+
+    # Lift the tensor constants created in ScalarToTensorPass
+    edge_program = lift_constant_tensor_pass(edge_program)
+
+    # Normalize tensor constants introduced by the preceding passes. With
+    # _skip_dim_order this is the only call, so it fixes the layout of
+    # parameters, buffers, constants and inputs, but ops computed from them
+    # keep the old strides.
+    edge_program = convert_constant_dim_order_pass.convert_constant_dim_order_pass(
+        edge_program
+    )
+
+    edge_program = _transform(edge_program, *post_op_replace_passes)
+
+    return edge_program
+
+
+def _replace_aten_ops_with_transformed_ops(
+    name: str,
+    program: ExportedProgram,
+    partitioner,
+):
+    preserve_ops = set()
+    partitioners = partitioner.get(name)
+    if partitioners is None:
+        return
+
+    # Iterate through the graph and replace the aten ops with the corresponding
+    # transformed ops.
+    for partitioner in partitioners:
+        ops_set_to_not_decompose, check_op_support = partitioner.ops_to_not_decompose(
+            program
+        )
+        ops_set_to_not_decompose = _remove_invalid_ops_for_not_decompose(
+            ops_set_to_not_decompose
+        )
+
+        for op_aten in ops_set_to_not_decompose:
+            _register_no_decomp_op(op_aten)
+
+        for node in program.graph.nodes:
+            is_op_supported = check_op_support(node) if check_op_support else True
+            if (
+                node.op == "call_function"
+                and node.target in ops_set_to_not_decompose
+                and is_op_supported
+            ):
+                preserve_ops.add(node.target)
+                node.target = aten_op_to_transform_op[node.target]
+
+        for _, submod, _ in get_control_flow_submodules(program.graph_module):
+            for node in submod.graph.nodes:
+                is_op_supported = check_op_support(node) if check_op_support else True
+                if (
+                    node.op == "call_function"
+                    and node.target in ops_set_to_not_decompose
+                    and is_op_supported
+                ):
+                    preserve_ops.add(node.target)
+                    node.target = aten_op_to_transform_op[node.target]
+
+    return preserve_ops
+
+
+def _restore_transformed_ops_to_aten_ops(program: ExportedProgram):
+    # Iterate through the graph and replace back the transformed ops with their
+    # corresponding aten ops.
+    for node in program.graph.nodes:
+        if node.op == "call_function" and str(node.target) in transform_op_to_aten_op:
+            node.target = transform_op_to_aten_op[str(node.target)]
+    for _, submod, _ in get_control_flow_submodules(program.graph_module):
+        for node in submod.graph.nodes:
+            if (
+                node.op == "call_function"
+                and str(node.target) in transform_op_to_aten_op
+            ):
+                node.target = transform_op_to_aten_op[str(node.target)]
+
+
+# Returns the op in edge_no_decomp_namespace namespace for the aten
+# op that is passed in.
+def _get_transformed_op(op_aten):
+    op_name = op_aten._schema.name.split("::")[1]
+    overload_name = op_aten._schema.overload_name
+    assert hasattr(
+        torch.ops, edge_no_decomp_namespace
+    ), f"Couldn't find {edge_no_decomp_namespace} in torch.ops. Please make sure the Library has been registered."
+    op_namespace = getattr(torch.ops, edge_no_decomp_namespace)
+    op = getattr(op_namespace, op_name)
+    return getattr(op, overload_name)
+
+
+# Registers the op in edge_no_decomp_namespace namespace for the aten
+# op that is passed in if it is not already cached in the table.
+def _register_no_decomp_op(op_aten):
+    # Check if the op is already cached in the table. If not, then we need to
+    # create a new op in the edge_no_decomp_namespace namespace.
+    if aten_op_to_transform_op.get(op_aten) is None and isinstance(
+        op_aten, torch._ops.OpOverload
+    ):
+        # Extract the schema from the aten op.
+        op_schema = str(op_aten._schema).split("::")[1]
+        op_name = op_aten._schema.name.split("::")[1]
+        # Define an op in the edge_no_decomp_namespace namespace with the aten schema.
+        lib.define(op_schema)
+        # Define the implementation of the op in the edge_no_decomp_namespace namespace.
+        # Important to note that the implementation of the op is the same as the aten op.
+
+        overload_name = op_aten._schema.overload_name
+        if overload_name != "":
+            op_name += "." + overload_name
+        lib.impl(op_name, op_aten, "CompositeExplicitAutograd")
+
+        # Cache the aten op and transformed op in their corresponding tables for future use.
+        aten_op_to_transform_op[op_aten] = _get_transformed_op(op_aten)
+        transform_op_to_aten_op[str(aten_op_to_transform_op[op_aten])] = op_aten
+
+
+def _sanity_check_graph_for_non_decomp_ops(
+    name: str,
+    program: ExportedProgram,
+    ops_set_to_not_decompose,
+    check_op_support,
+    generate_error=False,
+    partitioner_name=None,
+):
+    warning_str_end = ""
+    if partitioner_name is not None:
+        warning_str_end += f"This op was registered by the partitioner {partitioner_name} to not be decomposed.\n"
+    warning_str_end += f"The following ops: {ops_set_to_not_decompose} were specified to not be decomposed in {name}."
+
+    # Check that the ops that were registered to not be decomposed are not present in the
+    # graph anymore as the transform passes and backends should have consumed them by now.
+    ops_set_to_not_decompose = {
+        aten_to_edge(op) for op in ops_set_to_not_decompose
+    }.union(ops_set_to_not_decompose)
+
+    quant_primitives = {aten_to_edge(op) for op in _QUANT_PRIMITIVES}
+    for node in program.graph_module.graph.nodes:
+        is_op_supported = check_op_support(node) if check_op_support else True
+        if (
+            node.op == "call_function"
+            and node.target in ops_set_to_not_decompose
+            and node.target not in quant_primitives
+        ) and is_op_supported:
+            warning_str = (
+                f"Node {node} with op {node.target} was not decomposed or delegated.\n"
+                + warning_str_end
+            )
+            if generate_error:
+                raise RuntimeError(warning_str)
+            else:
+                logging.warning(warning_str)
+    for _, submod, _ in get_control_flow_submodules(program.graph_module):
+        for node in submod.graph.nodes:
+            is_op_supported = check_op_support(node) if check_op_support else True
+            if (
+                node.op == "call_function"
+                and node.target in ops_set_to_not_decompose
+                and node.target not in quant_primitives
+            ) and is_op_supported:
+                warning_str = (
+                    f"Node {node} with op {node.target} was not decomposed or delegated.\n"
+                    + warning_str_end
+                )
+                if generate_error:
+                    raise RuntimeError(warning_str)
+                else:
+                    logging.warning(warning_str)
+
+
+def _remove_invalid_ops_for_not_decompose(  # noqa: C901
+    preserve_ops: List[torch._ops.OpOverload],
+) -> List[torch._ops.OpOverload]:
+    _logged_warnings = set()
+
+    def log_warning(warn_str):
+        if warn_str not in _logged_warnings:
+            logging.warn(warn_str)
+            _logged_warnings.add(warn_str)
+
+    # To address https://github.com/pytorch/executorch/issues/8781
+    def keep(op):
+        # Explicit allow list
+        allow_list = []
+        try:
+            # Ops in torch.ops.quant are not always loaded, so we use try/except
+            # Aliases output, but we need to allow it for XNNPACK
+            allow_list.append(torch.ops.torchao.choose_qparams_affine.default)
+        except:
+            pass
+
+        if op in allow_list:
+            return True
+
+        schema = op._schema
+        native_schema = _pybind_schema_to_native_schema(schema)
+        if native_schema is None:
+            log_warning(
+                f"Torchgen is not able to parse the schema of {op._schema}.  This is not fatal."
+            )
+        else:
+            if native_schema.is_mutable:
+                log_warning(
+                    f"Op {op} was requested for preservation by partitioner.  This request is ignored because it is mutable."
+                )
+                return False
+
+            if native_schema.aliased_return_names() != [None]:
+                log_warning(
+                    f"Op {op} was requested for preservation by partitioner.  This request is ignored because it aliases output."
+                )
+                return False
+
+        # Fallback: torchgen does not detect alias annotations on ops
+        # returning lists of aliased tensors (e.g. split.Tensor returns
+        # Tensor(a)[]). Check op._schema.returns directly.
+        for ret in schema.returns:
+            if ret.alias_info is not None:
+                log_warning(
+                    f"Op {op} was requested for preservation by partitioner.  This request is ignored because it aliases output."
+                )
+                return False
+
+        # Explicit block list of ops that don't work if asked for
+        # preservation
+        if op in [
+            # Hits infinte recursion error when op is in
+            # EDGE_DO_NOT_DECOMP namespace
+            torch.ops.aten._to_copy.default,
+            # scalar to tensor type promotion does not work on ops
+            # in EDGE_DO_NOT_DECOMP namespace
+            torch.ops.aten.mul.Tensor,
+            torch.ops.aten.add.Tensor,
+            torch.ops.aten.sub.Tensor,
+            torch.ops.aten.div.Tensor,
+            torch.ops.aten.item.default,
+            torch.ops.aten._local_scalar_dense.default,
+            torch.ops.aten.unbind.int,
+            torch.ops.aten.split_with_sizes.default,
+        ]:
+            log_warning(
+                f"Op {op} was requested for preservation by partitioner.  This request is ignored because it is in a blocklist."
+            )
+            return False
+        return True
+
+    return list(filter(keep, preserve_ops))
+
+
+def _can_skip_using_EDGE_DO_NOT_DECOMP(
+    partitioner: Partitioner, program: ExportedProgram
+) -> bool:
+    # THe current design of using EDGE_DO_NOT_DECOMP to prevent decomposition
+    # has long standing issues.  _remove_invalid_ops_for_not_decompose was a band-aid to
+    # fix some of the issues, but more issues are coming up over time, including a new issue with SDPA
+    # and contiguous views: https://fb.workplace.com/groups/pytorch.edge.users/permalink/1796069037930048/
+    # EDGE_DO_NOT_DECOMP is only needed by partitioners that specify check_op_support
+    # As a temp fix, we give a more reliable path for backends that do not specify check_op_support
+    _, check_op_support = partitioner.ops_to_not_decompose(program)
+    return check_op_support is None
+
+
+def _apply_pre_decomposition_transforms(
+    program: ExportedProgram, partitioners: List[Partitioner]
+) -> ExportedProgram:
+    for partitioner in partitioners:
+        program = partitioner.transform_for_pre_decomposition(program)
+    return program
+
+
+def _gen_edge_manager_for_partitioners(
+    partitioner: Dict[str, List[Partitioner]],
+    aten_programs: Dict[str, ExportedProgram],
+    config: EdgeCompileConfig,
+    constant_methods: Optional[Dict[str, Any]],
+    generate_etrecord: Optional[bool] = False,
+) -> "EdgeProgramManager":
+    """
+    Generates EdgeProgramManager for subsequent lowering to the
+    partitioners specified by partitioner. The EdgeProgramManager is generated from
+    aten_programs.
+
+    Partitioners specify what nodes should not be decomposed from the original aten programs.
+    This is done through two passes of run_decompositions.
+        - First pass preserves all aten_targets specified by partitioners to preserve
+          them from nested decompositions
+        - Second pass uses check_op fn provided by partitioners to perform additional checks
+          on nodes with preserved aten targets. They are then replaces with transformed ops to
+          keep them through the second pass of decompositions
+    """
+    ops_set_to_not_decompose_by_program = defaultdict(list)
+    edge_programs: Dict[str, ExportedProgram] = {}
+    for name, program in aten_programs.items():
+        partitioners_for_program = partitioner.get(name, [])
+        program = _apply_pre_decomposition_transforms(program, partitioners_for_program)
+
+        # Functionalize program before asking partitioners to preserve ops
+        program = program.run_decompositions({})
+
+        if partitioner is not None:
+            final_ops_to_preserve = set()
+
+            # Decompose by default if there are no partitioners for the method
+            if not partitioners_for_program:
+                table = _default_decomposition_table()
+                for op in config.preserve_ops:
+                    table.pop(op, None)
+                program = program.run_decompositions(table)
+
+            # Process each partitioner individually using their specific requirements
+            for curr_partitioner in partitioners_for_program:
+                curr_ops_no_decomp, _ = curr_partitioner.ops_to_not_decompose(program)
+
+                # Check if this partitioner can skip using EDGE_DO_NOT_DECOMP
+                can_skip_using_edge_do_not_decomp = _can_skip_using_EDGE_DO_NOT_DECOMP(
+                    curr_partitioner, program
+                )
+
+                if can_skip_using_edge_do_not_decomp:
+                    # Preserve all ops in curr_ops_no_decomp from decomposition
+                    table = _default_decomposition_table()
+                    ops_needing_preservation = []
+
+                    for op in curr_ops_no_decomp:
+                        if table.pop(op, None) is not None:
+                            ops_needing_preservation.append(op)
+
+                    # The initial ``run_decompositions({})`` above has already
+                    # functionalized the graph. This second call only applies
+                    # operator decompositions from the remaining table, so it is
+                    # safe to skip when none of those targets occur in the graph.
+                    # Unless the config preserves it, empty_like does not
+                    # count: ReplaceEmptyLikePass lowers any that is left.
+                    not_counted = (
+                        set()
+                        if torch.ops.aten.empty_like.default in config.preserve_ops
+                        else {torch.ops.aten.empty_like.default}
+                    )
+                    if contains_any_call_fn_target_op(
+                        program.graph_module, table.keys() - not_counted
+                    ):
+                        program = program.run_decompositions(table)
+                    final_ops_to_preserve.update(ops_needing_preservation)
+                else:
+                    # EDGE_DO_NOT_DECOMP path for the partitioner
+                    curr_ops_no_decomp = _remove_invalid_ops_for_not_decompose(
+                        curr_ops_no_decomp
+                    )
+
+                    # Apply decompositions with this partitioner's preserved ops
+                    table = _default_decomposition_table()
+                    for op in curr_ops_no_decomp:
+                        table.pop(op, None)
+
+                    # First pass of decompositions with this partitioner's preserved ops
+                    program = program.run_decompositions(table)
+
+                    # Filter ops using EDGE_DO_NOT_DECOMP
+                    temp_partitioner_dict = {name: [curr_partitioner]}
+                    preserved_ops = (
+                        _replace_aten_ops_with_transformed_ops(
+                            name, program, temp_partitioner_dict
+                        )
+                        or []
+                    )
+                    final_ops_to_preserve.update(preserved_ops)
+
+                    # Second pass of decompositions with this partitioner's preserved ops after filtering
+                    program = program.run_decompositions(_default_decomposition_table())
+
+                    # Restore ops from edge_no_decomp_namespace to aten ops
+                    _restore_transformed_ops_to_aten_ops(program)
+            ops_set_to_not_decompose_by_program[name].extend(final_ops_to_preserve)
+
+        edge_programs[name] = _generate_edge_program(
+            config,
+            program,
+            preserve_ops=ops_set_to_not_decompose_by_program.get(name, []),
+        )
+
+    # Merge ops_to_not_decompose into config so that downstream calls (e.g.
+    # EdgeProgramManager.transform()) carry the exception list through their
+    # verifiers automatically.
+    all_ops_not_to_decompose = list(
+        set().union(*ops_set_to_not_decompose_by_program.values())
+    )
+    config._core_aten_ops_exception_list = list(
+        set(config._core_aten_ops_exception_list) | set(all_ops_not_to_decompose)
+    )
+
+    edge_manager = EdgeProgramManager(
+        edge_programs,
+        constant_methods,
+        config,
+        all_ops_not_to_decompose,
+    )
+
+    if generate_etrecord:
+        etrecord = _create_empty_etrecord()
+        etrecord.add_exported_program(aten_programs)
+        etrecord.add_edge_dialect_program(copy.deepcopy(edge_manager))
+        edge_manager._etrecord = etrecord
+
+    return edge_manager
+
+
+def collect_named_data_store_from_exported_program(
+    exported_program: ExportedProgram,
+    named_data_store: NamedDataStore,
+) -> None:
+    """
+    Collects all the named data store outputs found within the exported program
+    and adds them to named_data_store.
+    """
+
+    # collected all the named data into the named data store for deduplication
+    def collect_named_data_store_outputs(
+        graph_module: torch.fx.GraphModule,
+    ) -> None:
+        for node in graph_module.graph.nodes:
+            if node.target == executorch_call_delegate:
+                lbm = getattr(graph_module, node.args[0].target)
+                assert is_lowered_module(lbm)
+                data_store_output = lbm.named_data_store_output
+                if data_store_output is not None:
+                    named_data_store.merge_named_data_store(data_store_output)
+
+        for _, submod, _ in get_control_flow_submodules(graph_module):
+            collect_named_data_store_outputs(submod)
+
+    collect_named_data_store_outputs(exported_program.graph_module)
+
+
+@et_logger("to_edge_transform_and_lower")
+def to_edge_transform_and_lower(  # noqa: C901
+    programs: Union[ExportedProgram, Dict[str, ExportedProgram]],
+    transform_passes: Optional[
+        Union[
+            Sequence[PassType],
+            Dict[str, Sequence[PassType]],
+            GraphModulePassManager,
+            ExportedProgramPassManager,
+        ]
+    ] = None,
+    partitioner: Optional[
+        Union[List[Partitioner], Dict[str, List[Partitioner]]]
+    ] = None,
+    constant_methods: Optional[Dict[str, Any]] = None,
+    compile_config: Optional[EdgeCompileConfig] = None,
+    generate_etrecord: bool = False,
+) -> "EdgeProgramManager":
+    """
+    :func:`to_edge_transform_and_lower` constructs an EdgeProgramManager from a set of
+    exported programs in ATen dialect. It differs fundamentally from to_edge in that it
+    combines the conversion of the ATen dialect to the edge dialect program, then running
+    the transformation passes and then subsequently lowering the programs to their
+    corresponding backends all into a single API.
+
+    This is fundamentally useful for lowering to backends that have ops registered that they
+    do not want to be decomposed and thus rely on matching with these non-decomposed ops. For
+    these sorts of backends this is the *only* API that should be used to lower to the edge
+    dialect. Using a combination of to_edge(...) and to_backend(...) will result in inconsistent
+    or wrong behavior.
+
+    This API is the primary recommended way to lower to the CPU based XNNPack backend.
+
+    Args:
+        programs: Can be a single ExportedProgram or a dictionary mapping function names
+            to their corresponding ExportedPrograms. If only a single ExportedProgram is
+            provided it will be assigned the name "forward".
+
+        transform_passes: The transform_passes can be one of:
+            1) a list of passes -
+                all methods in the given EdgeProgramManager will be transformed with the provided passes.
+            2) a dictionary -
+                only method names specified in the dictionary will be transformed
+                with their corresponding passes
+            3) an instance of a PassManager (either a GraphModulePassManager or an ExportedProgramPassManager) -
+                all methods in the given EdgeProgramManager will be
+                transformed with the given PassManager instance.
+
+        partitioner: The partitioner can either be a Partitioner subclass instance, or a
+            dictionary mapping method names to Partitioner subclass instance. If it is a
+            Partitioner subclass, all programs in the given EdgeProgramManager will be lowered
+            using the given partitioner. If it is a dictionary, only method names specified in
+            the dictionary will be lowered with the given partitioner.
+
+        constant_methods: An optional dictionary of method name to the constant value
+            returned by that method in eager mode. Often used to store config information on
+            Edge models.
+
+        compile_config: An optional argument used to provide greater control over the
+            transformation to edge dialect process.
+
+        generate_etrecord: An optional argument used to generate an etrecord for debugging purposes.
+
+    Returns:
+        EdgeProgramManager
+    """
+    assert not isinstance(constant_methods, EdgeCompileConfig)
+    config = compile_config or EdgeCompileConfig()
+    if not isinstance(programs, dict):
+        aten_programs = {"forward": programs}
+    else:
+        aten_programs = programs
+
+    if not isinstance(partitioner, dict) and partitioner is not None:
+        partitioner = {name: partitioner for name in aten_programs.keys()}
+    elif partitioner is None:
+        partitioner = {name: [] for name in aten_programs.keys()}
+
+    edge_manager = _gen_edge_manager_for_partitioners(
+        partitioner, aten_programs, config, constant_methods, generate_etrecord
+    )
+
+    if transform_passes is not None:
+        edge_manager = edge_manager.transform(transform_passes)
+        for method in edge_manager.methods:
+            lift_constant_tensor_pass(edge_manager.exported_program(method))
+
+        if generate_etrecord:
+            edge_manager._etrecord.add_extra_export_modules(
+                {"edge_after_transform": copy.deepcopy(edge_manager)}
+            )
+
+    max_num_partitioners = 0
+    for partitioner_list in partitioner.values():
+        max_num_partitioners = max(max_num_partitioners, len(partitioner_list))
+
+    for i in range(max_num_partitioners):
+        method_to_partitioner = {}
+        for name, partitioner_list in partitioner.items():
+            if i < len(partitioner_list):
+                method_to_partitioner[name] = partitioner_list[i]
+        edge_manager = edge_manager.to_backend(method_to_partitioner)
+
+    for name, program in edge_manager._edge_programs.items():
+        ops_set_to_not_decompose: Set[torch._ops.OpOverload] = set()
+        partitioners = partitioner.get(name, [])
+        for curr_partitioner in partitioners:
+            curr_op_set, check_op_support = curr_partitioner.ops_to_not_decompose(
+                program
+            )
+
+            if not _can_skip_using_EDGE_DO_NOT_DECOMP(curr_partitioner, program):
+                curr_op_set = _remove_invalid_ops_for_not_decompose(curr_op_set)
+            ops_set_to_not_decompose = ops_set_to_not_decompose.union(curr_op_set)
+            _sanity_check_graph_for_non_decomp_ops(
+                name,
+                program,
+                ops_set_to_not_decompose,
+                check_op_support,
+                partitioner_name=curr_partitioner.__class__.__name__,
+                generate_error=True,
+            )
+
+        preserve_ops = config.preserve_ops + list(ops_set_to_not_decompose)
+        if config._check_ir_validity:
+            EXIREdgeDialectVerifier(
+                edge_compile_config=config,
+                class_only=True,
+                preserve_ops=preserve_ops,
+            )()(program.graph_module)
+
+    return edge_manager
+
+
+@et_logger("to_edge")
+def to_edge(
+    programs: Union[ExportedProgram, Dict[str, ExportedProgram]],
+    constant_methods: Optional[Dict[str, Any]] = None,
+    compile_config: Optional[EdgeCompileConfig] = None,
+    generate_etrecord: bool = False,
+) -> "EdgeProgramManager":
+    """
+    :func:`to_edge` constructs an EdgeProgramManager from a set of exported programs in
+    ATen dialect. Upon construction those programs are transformed into edge dialect.
+
+    Args:
+        programs: Can be a single ExportedProgram or a dictionary mapping function names to their corresponding ExportedPrograms. If only a single ExportedProgram is provided it will be assigned the name "forward".
+
+        constant_methods: An optional dictionary of method name to the constant value returned by that method in eager mode. Often used to store config information on Edge models.
+
+        compile_config: An optional argument used to provide greater control over the transformation to edge dialect process.
+
+        generate_etrecord: An optional argument used to generate an etrecord for debugging purposes. Default is False.
+
+    Returns:
+        EdgeProgramManager
+    """
+    assert not isinstance(constant_methods, EdgeCompileConfig)
+    config = compile_config or EdgeCompileConfig()
+    if not isinstance(programs, dict):
+        aten_programs = {"forward": programs}
+    else:
+        aten_programs = programs
+
+    edge_programs: Dict[str, ExportedProgram] = {}
+
+    for name, program in aten_programs.items():
+        # Decompose to Core ATen
+        table = _default_decomposition_table()
+        preserve_ops = []
+        if compile_config:
+            preserve_ops = compile_config.preserve_ops
+            for op in compile_config.preserve_ops:
+                table.pop(op, None)
+        program = program.run_decompositions(table)
+
+        if config._check_ir_validity:
+            # Remove invalid assert ops, such as _assert_tensor_metadata.
+            # This pass is run in _generate_edge_program; it is required here to
+            # ensure the graph is in ATen dialect before verification.
+            gm = program.graph_module
+            gm_res = RemoveNonCoreAtenOpGraphAssertsPass()(gm)
+            assert gm_res is not None
+            gm = gm_res.graph_module
+            try:
+                EXIRATenDialectVerifier(
+                    edge_compile_config=config,
+                    class_only=False,
+                    # ReplaceEmptyLikePass lowers it in _generate_edge_program.
+                    core_aten_ops_exception_list=[torch.ops.aten.empty_like.default],
+                )(gm)
+            except ExportError as e:
+                logging.info(f"Input program {name} is not in ATen dialect.")
+                raise e
+
+        edge_programs[name] = _generate_edge_program(
+            config, program, preserve_ops=preserve_ops
+        )
+        if config._check_ir_validity:
+            try:
+                EXIREdgeDialectVerifier(
+                    edge_compile_config=config,
+                    class_only=True,
+                    preserve_ops=preserve_ops,
+                )()(edge_programs[name].graph_module)
+            except ExportError as e:
+                logging.info(f"Input program {name} is not in Edge dialect.")
+                raise e
+
+    epm = EdgeProgramManager(edge_programs, constant_methods, config)
+    if generate_etrecord:
+        etrecord = _create_empty_etrecord()
+        etrecord.add_exported_program(aten_programs)
+        etrecord.add_edge_dialect_program(copy.deepcopy(epm))
+        epm._etrecord = etrecord
+
+    return epm
+
+
+class EdgeProgramManager:
+    """
+    Package of one or more `ExportedPrograms` in Edge dialect. Designed to simplify
+    lowering to ExecuTorch. See: https://pytorch.org/executorch/main/ir-exir
+
+    Allows easy applications of transforms across a collection of exported programs
+    including the delegation of subgraphs.
+
+    Manages the second link in the lowering chain of ATen -> Edge -> ExecuTorch.
+    """
+
+    def __init__(
+        self,
+        edge_programs: Union[ExportedProgram, Dict[str, ExportedProgram]],
+        constant_methods: Optional[Dict[str, Any]] = None,
+        compile_config: Optional[EdgeCompileConfig] = None,
+        core_aten_ops_exception_list: Optional[List[torch._ops.OpOverload]] = None,
+        preserve_ops: Optional[List[torch._ops.OpOverload]] = None,
+    ):
+        """
+        Should not be called directly by users. User should use :func:'to_edge' instead.
+
+        Constructs an EdgeProgramManager from an existing set of exported programs in edge dialect.
+        """
+        self.compile_config = compile_config or EdgeCompileConfig()
+        if not isinstance(edge_programs, dict):
+            edge_programs = {"forward": edge_programs}
+
+        for name, program in edge_programs.items():
+            try:
+                EXIREdgeDialectVerifier(
+                    edge_compile_config=self.compile_config,
+                    core_aten_ops_exception_list=core_aten_ops_exception_list,
+                    preserve_ops=preserve_ops,
+                )(program.graph_module)
+            except ExportError as e:
+                logging.info(f"Input program {name} is not in aten dialect.")
+                raise e
+
+        self._edge_programs: Dict[str, ExportedProgram] = edge_programs
+        self._config_methods = constant_methods
+
+        self._named_data_store = NamedDataStore()
+        for _, program in self._edge_programs.items():
+            collect_named_data_store_from_exported_program(
+                program, self._named_data_store
+            )
+
+        self._etrecord = None
+
+    @property
+    def methods(self) -> Set[str]:
+        """
+        Returns the set of methods in this EdgeProgramManager.
+        """
+        return set(self._edge_programs.keys())
+
+    @property
+    def config_methods(self) -> Set[str]:
+        """
+        Returns the set of config methods in this EdgeProgramManager.
+        """
+        return set(self._config_methods.keys()) if self._config_methods else set()
+
+    def exported_program(self, method_name: str = "forward") -> ExportedProgram:
+        """
+        Returns the ExportedProgram specified by 'method_name'.
+        """
+
+        return self._edge_programs[method_name]
+
+    @et_logger("transform")
+    def transform(
+        self,
+        passes: Union[
+            Sequence[PassType],
+            Dict[str, Sequence[PassType]],
+            ExportedProgramPassManager,
+            GraphModulePassManager,
+        ],
+        compile_config: Optional[EdgeCompileConfig] = None,
+    ) -> "EdgeProgramManager":
+        """
+        Transforms the program according to the provided passes.
+
+        Args:
+            passes: This param can be one of:
+                1) a list of passes -
+                    all methods in the given EdgeProgramManager
+                    will be transformed with the provided passes.
+                2) a dictionary mapping method names to lists of passes -
+                    only method names specified in the dictionary will be
+                    transformed with their corresponding passes.
+                3) a PassManager (either ExportedProgramPassManager or GraphModulePassManager) instance -
+                    all methods in the given EdgeProgramManager will be
+                    transformed with the given PassManager instance.
+            compile_config: Compile config to use for veriy the correctness of model
+                graph after each pass. If not specified, the compile config of the
+                calling EdgeProgramManager will be used. It will be used in as compile
+                config of returned EdgeProgramManager.
+
+        Returns:
+            EdgeProgramManager: A copy of the calling EdgeProgramManager with the
+            transformations applied.
+        """
+
+        compile_config = compile_config or self.compile_config
+        new_programs: Dict[str, ExportedProgram] = {}
+
+        # Cast passes parameter upfront.
+        passes_seq: Optional[Sequence[PassType]] = None
+        passes_dict: Optional[Dict[str, Sequence[PassType]]] = None
+        pass_manager: Optional[
+            Union[ExportedProgramPassManager, GraphModulePassManager]
+        ] = None
+
+        if isinstance(passes, Sequence):
+            passes_seq = passes
+        if isinstance(passes, dict):
+            passes_dict = passes
+        if isinstance(passes, (ExportedProgramPassManager, GraphModulePassManager)):
+            pass_manager = passes
+
+        for name, program in self._edge_programs.items():
+            # If the method name is enforced, but not matched, we skip transformation.
+            if (
+                isinstance(passes, dict)
+                and passes_dict
+                and name not in passes_dict.keys()
+            ):
+                new_programs[name] = copy.deepcopy(program)
+                continue
+
+            # Depending on the passes parameter, call the corresponding transform function.
+            if passes_seq is not None:
+                new_programs[name] = _transform(program, *passes_seq)
+            elif passes_dict is not None:
+                new_programs[name] = _transform(program, *passes_dict[name])
+            elif pass_manager is not None:
+                new_programs[name] = _transform_with_pass_manager(program, pass_manager)
+
+            # Verify the correctness of model graph after each transformation.
+            EXIREdgeDialectVerifier(edge_compile_config=compile_config)(
+                new_programs[name].graph_module
+            )
+
+        epm = EdgeProgramManager(
+            new_programs, copy.deepcopy(self._config_methods), compile_config
+        )
+
+        epm._etrecord = self._etrecord
+        return epm
+
+    @et_logger("to_backend")
+    def to_backend(
+        self,
+        partitioner: Union[Partitioner, Dict[str, Partitioner]],
+    ) -> "EdgeProgramManager":
+        """
+        Returns a semantically-equivalent program to the one given as input,
+        but with portions of each program in the EdgeProgramManager targeted
+        for delegation as determined by the partitioner.
+
+        Args:
+            partitioner: The partitioner can either be a Partitioner subclass instance, or a
+                dictionary mapping method names to Partitioner subclass instance. If it is a
+                Partitioner subclass, all programs in the given EdgeProgramManager
+                will be lowered using the given partitioner. If it is a
+                dictionary, only method names specified in the dictionary will be
+                lowered with the given partitioner.
+
+                The Partitioner subclass instance is in charge with tagging portions of the
+                input program for delegation. A valid partitioner must return PartitionerResult including valid
+                partition_tags: Dict[str, DelegationSpec], where each key is a tag
+                name and the nodes with same tag will be fused a one subgraph and
+                delegated to backend specififed in delegation spec.
+
+        Returns:
+            EdgeProgramManager: A copy of the calling EdgeProgramManager with the
+            specified subgraphs lowered.
+        """
+        new_edge_programs: Dict[str, ExportedProgram] = {}
+        method_to_partitioner: Dict[str, Partitioner] = {}
+        if not isinstance(partitioner, dict):
+            method_to_partitioner = {name: partitioner for name in self._edge_programs}
+        else:
+            method_to_partitioner = partitioner
+
+        method_to_programs_and_partitioners = MethodProgramsPartitionerSpec(
+            self._edge_programs,
+            method_to_partitioner,
+        )
+
+        new_edge_programs = to_backend(method_to_programs_and_partitioners)
+        config = EdgeCompileConfig(_check_ir_validity=False)
+        epm = EdgeProgramManager(
+            new_edge_programs,
+            copy.deepcopy(self._config_methods),
+            config,
+        )
+
+        epm._etrecord = self._etrecord
+        return epm
+
+    @et_logger("to_executorch")
+    def to_executorch(  # noqa (FLAKE8) C901
+        self,
+        config: Optional[ExecutorchBackendConfig] = None,
+    ) -> "ExecutorchProgramManager":
+        """
+        Transforms the program to the ExecuTorch backend.
+
+        Args:
+            config: An optional argument used to provide greater control over
+                the transformation to the ExecuTorch backend.
+
+        Returns:
+            ExecutorchProgramManager: A manager representing the state of the EdgeProgramManager
+            after it has been transformed to the ExecuTorch backend.
+        """
+        config = config if config else ExecutorchBackendConfig()
+        execution_programs: Dict[str, ExportedProgram] = {}
+        for name, program in self._edge_programs.items():
+            if config.do_quant_fusion_and_const_prop:
+                if program.graph_signature.backward_signature is not None:
+                    raise Exception(
+                        "Cannot run do_quant_fusion_and_const_prop on a graph with a backward signature intended for on-device training."
+                        " Please set do_quant_fusion_and_const_prop to False in the ExecutorchBackendConfig."
+                    )
+                program = quant_fusion_and_const_prop_pass(program)
+            if config.run_reinplace_pass or config.reinplace_extra_ops:
+                extra = config.reinplace_extra_ops or frozenset()
+                program = reinplace_pass(
+                    program,
+                    ops_to_inplace=DEFAULT_INPLACEABLE_OPS | extra,
+                )
+            program = weights_to_outputs_pass(program)
+            program = unsafe_remove_auto_functionalized_pass(program)
+            gm, new_signature = insert_write_back_for_buffers_pass(program)
+            new_gm = program.graph_module
+            for p in edge_to_executorch_passes(
+                config, name, edge_compile_config=self.compile_config
+            ):
+                new_gm_res = p(new_gm)
+                assert new_gm_res is not None
+                new_gm = new_gm_res.graph_module
+                if isinstance(p, SpecPropPass):
+                    # Note that this is a hacky way to get around the fact that
+                    # placeholder nodes corresponding to the parameters of the graph module
+                    # shall not participate in memory planning. It increases runtime memory
+                    # footprint.
+                    # Proper way would be to have ExportPass work with ExportedProgram
+                    # instead of GraphModule. This is because ExportPass should work
+                    # on top of the export artifact of torch.export whichi s ExportedProgram.
+                    # Working with GraphModule does not provide all the information contained
+                    # in the ExportedProgram
+                    # TODO(who?)
+                    p.update_placeholder_tensor_specs(program, new_gm)
+
+            # Tag constant weights.
+            if (
+                isinstance(config.external_constants, bool)
+                and config.external_constants
+            ):
+                new_gm_res = external_constants_pass(new_gm)
+                new_gm = new_gm_res.graph_module
+            elif callable(config.external_constants):
+                new_gm_res = external_constants_pass(new_gm, config.external_constants)
+                new_gm = new_gm_res.graph_module
+
+            # Tag mutable weights.
+            if config.external_mutable_weights:
+                new_gm_res = external_mutable_weights_pass(new_gm, program)
+                new_gm = new_gm_res.graph_module
+
+            if isinstance(config.memory_planning_pass, dict):
+                memory_planning_pass = config.memory_planning_pass.get(
+                    name, ExecutorchBackendConfig().memory_planning_pass
+                )
+            else:
+                memory_planning_pass = config.memory_planning_pass
+            # Propagate enable_non_cpu_memory_planning from the top-level config
+            # to the pass instance so that device-aware partitioning is applied.
+            if hasattr(memory_planning_pass, "enable_non_cpu_memory_planning"):
+                memory_planning_pass.enable_non_cpu_memory_planning = (
+                    config.enable_non_cpu_memory_planning
+                )
+            # TODO(jakeszwe): Follow up with compiler on if the deepcopy is necessary and if so how to make it work
+            if hasattr(memory_planning_pass, "run"):
+                new_gm_res = memory_planning_pass.run(new_gm, new_signature)
+            else:
+                new_gm_res = memory_planning_pass(new_gm)
+
+            # WARNING: DO NOT ADD ANY MORE PASSES AFTER MEMORY PLANNING PASS.
+            # THERE ARE A LOT OF ASSUMPTIONS IN THE STACK THAT MEMORY PLANNING IS THE LAST PASS BEFORE THE EMITTER.
+            assert new_gm_res is not None
+            new_gm = new_gm_res.graph_module
+
+            _copy_module(program.graph_module, new_gm)
+            execution_programs[name] = program
+        # After running memory planning on all entry points we can run the cross entry point memory planning
+        if isinstance(config.memory_planning_pass, dict):
+            for memory_planning_pass in config.memory_planning_pass.values():
+                if hasattr(memory_planning_pass, "run_multimethod"):
+                    memory_planning_pass.run_multimethod()
+        else:
+            memory_planning_pass = config.memory_planning_pass
+            if hasattr(memory_planning_pass, "run_multimethod"):
+                memory_planning_pass.run_multimethod()
+
+        et_pm = ExecutorchProgramManager(
+            execution_programs,
+            self._config_methods,
+            config,
+            self._named_data_store.get_named_data_store_output(),
+        )
+
+        if self._etrecord is not None:
+            # Create a clean copy of the ETRecord for the executorch manager
+            # This preserves edge-stage data while allowing executorch data to be added
+            et_etrecord = self._etrecord.copy()
+            et_etrecord.add_executorch_program(et_pm)
+            et_pm._etrecord = et_etrecord
+
+        return et_pm
+
+
+class ExecutorchProgramManager:
+    """
+    Package of one or more `ExportedPrograms` in Execution dialect. Designed to simplify
+    lowering to ExecuTorch. See: https://pytorch.org/executorch/main/ir-exir
+
+    When the ExecutorchProgramManager is constructed the ExportedPrograms in execution dialect
+    are used to form the executorch binary (in a process called emission) and then serialized
+    to a buffer.
+
+    Manages the final link in the lowering chain of ATen -> Edge -> ExecuTorch.
+    """
+
+    def __init__(
+        self,
+        execution_programs: Dict[str, ExportedProgram],
+        config_methods: Optional[Dict[str, Any]] = None,
+        backend_config: Optional[ExecutorchBackendConfig] = None,
+        named_data: Optional[NamedDataStoreOutput] = None,
+    ):
+        """
+        End users should not call this constructor directly. Instead, they should use
+        :func:'to_executorch' to construct an ExecutorchProgramManager.
+
+        Constructs an ExecutorchProgramManager from a set of exported programs in
+        execution dialect.
+
+        Args:
+            execution_programs: A dictionary of method name to the corresponding
+            ExportedProgram.
+
+            config_methods: A dictionary of method name to the config value returned
+            by that method in eager mode.
+
+            backend_config: An optional argument used to provide greater control over
+            the emission and serialization.
+        """
+        # Set up methods
+        self._execution_programs: Dict[str, ExportedProgram] = execution_programs
+        self._config_methods: Optional[Dict[str, Any]] = config_methods
+
+        # Named data from EdgeProgramManager
+        self._named_data: Optional[NamedDataStoreOutput] = named_data
+
+        backend_config = backend_config or ExecutorchBackendConfig()
+
+        # Emit methods
+        self._emitter_output: EmitterOutput = emit_program(
+            self._execution_programs,
+            backend_config.emit_stacktrace,
+            self._config_methods,
+            backend_config.emit_mutable_buffer_names,
+        )
+
+        # Serialize emitter output, ready to be written to a file.
+        from executorch.extension.flat_tensor.serialize.serialize import (
+            FlatTensorConfig,
+            FlatTensorSerializer,
+        )
+
+        self._data_serializer = FlatTensorSerializer(
+            FlatTensorConfig(segment_alignment=backend_config.segment_alignment)
+        )
+        self._pte_data, self._tensor_data = serialize_for_executorch(
+            self._emitter_output,
+            backend_config,
+            self._data_serializer,
+            self._named_data,
+        )
+        self._buffer: Optional[bytes] = None
+        self._etrecord = None
+
+    @property
+    def methods(self) -> Set[str]:
+        """
+        Returns the set of methods in this ExecutorchProgramManager.
+        """
+        return set(self._execution_programs.keys())
+
+    @property
+    def config_methods(self) -> Set[str]:
+        """
+        Returns the set of config methods in this ExecutorchProgramManager.
+        """
+        return set(self._config_methods.keys()) if self._config_methods else set()
+
+    def exported_program(self, method_name: str = "forward") -> ExportedProgram:
+        """
+        Returns the ExportedProgram specified by 'method_name'.
+        """
+        return self._execution_programs[method_name]
+
+    def dump_executorch_program(
+        self, verbose: bool = False, out: Optional[TextIO] = None
+    ) -> None:
+        """
+        Prints the ExecuTorch binary in a human readable format.
+
+        Args:
+            verbose (bool):
+                If False prints the binary in a condensed format.
+                If True prints the binary 1-1 with the specification in the schema.
+            out:
+                If None, prints to stdout.
+                If non-None, writes the string to that stream object. It can be
+                    a file object, a StringIO object, or any other TextIO subclass.
+        """
+        if verbose:
+            pretty_print(self._emitter_output.program, out=out)
+        else:
+            print_program(self._emitter_output.program, out=out)
+
+    @property
+    def debug_handle_map(self) -> Dict[int, Union[int, List[int]]]:
+        return self._emitter_output.debug_handle_map
+
+    @property
+    def delegate_map(
+        self,
+    ) -> Dict[str, Dict[int, Dict[str, Union[str, _DelegateDebugIdentifierMap]]]]:
+        return self._emitter_output.method_to_delegate_debug_id_map
+
+    @property
+    def instruction_id_to_num_outs_map(
+        self,
+    ) -> Dict[str, Dict[int, Union[int, List[int]]]]:
+        return self._emitter_output.instruction_id_to_num_outs_map
+
+    @property
+    def executorch_program(self) -> Program:
+        """
+        Returns the object that represents the ExecuTorch binary before serialization.
+        """
+        return self._emitter_output.program
+
+    @property
+    def buffer(self) -> bytes:
+        """Returns the serialized ExecuTorch binary as a byte string.
+
+        Note that the call to `buffer` may allocate a very large amount of
+        contiguous memory, depending on the model size. If writing to a file,
+        use `write_to_file` which won't incur additional copies.
+        """
+        # TODO(T181494963): update pybinding to remove buffer cache, which can consume large
+        # amounts of memory longer than necessary.
+        if self._buffer is None:
+            self._buffer = bytes(self._pte_data)
+        return self._buffer
+
+    def get_etrecord(self):
+        """
+        Get the generated ETRecord if etrecord generation was enabled.
+
+        Returns:
+            ETRecord object if generation was enabled, None otherwise
+
+        Raises:
+            RuntimeError: if ETRecord object was not generated.
+        """
+
+        if self._etrecord is None:
+            raise RuntimeError("ETRecord was not generated")
+        return self._etrecord
+
+    def write_to_file(self, open_file: io.BufferedIOBase) -> None:
+        """
+        Writes the serialized ExecuTorch binary to the file at `open_file`. Prefer to use this over
+        `buffer`, as it writes to file without copying into a contiguous block of memory first,
+        reducing the peak memory usage.
+        """
+        self._pte_data.write_to_file(open_file)
+
+    def write_tensor_data_to_file(self, outdir) -> None:
+        """
+        Writes the serialized ExecuTorch data files to the directory at `outdir`.
+        """
+        assert self._tensor_data is not None
+        for filename, cord in self._tensor_data.items():
+            if not filename.endswith(".ptd"):
+                filename += ".ptd"
+            with open(os.path.join(outdir, f"{filename}"), "wb") as f:
+                logging.info(f"Writing data file to {filename}")
+                cord.write_to_file(f)
+
+    def save(self, path: str) -> None:
+        """
+        Saves the serialized ExecuTorch binary to the file at `path`.
+        """
+        if path[-4:] != ".pte":
+            logging.error(f"Path {path} does not end with .pte")
+            raise ValueError(f"Path {path} does not end with .pte")
+        try:
+            with open(path, "wb") as file:
+                self.write_to_file(file)
+                logging.info(f"Saved exported program to {path}")
+        except Exception as e:
+            logging.error(f"Error while saving to {path}: {e}")