Initial skeleton codes for Exynos Backend

Signed-off-by: jiseong.oh <[email protected]>

Author: Jiseong-oh

backends/samsung/enn_preprocess.py

@@ -0,0 +1,58 @@
+# Copyright (c) 2025 Samsung Electronics Co. LTD
+# All rights reserved
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+import logging
+from typing import Dict, final, List
+
+import torch
+from executorch.exir.backend.backend_details import (
+    BackendDetails,
+    CompileSpec,
+    PreprocessResult,
+)
+
+from executorch.exir.passes import PassManager
+
+from torch.export.exported_program import ExportedProgram
+
+
+@final
+class EnnBackend(BackendDetails):
+    @staticmethod
+    def preprocess(
+        edge_program: ExportedProgram,
+        compile_specs: List[CompileSpec],
+    ) -> PreprocessResult:
+        # 1 Converter Init
+        enn_preprocess_passes = PassManager(passes=[])
+
+        # 2 make enn graph
+        enn_preprocess_passes = PassManager(passes=[])
+        pass_result = enn_preprocess_passes(edge_program.graph_module)
+        # 3 node visitors
+        node_visitors = []
+
+        vals_to_ids: Dict[torch.fx.Node, int] = {}
+        for node in pass_result.graph_module.graph.nodes:
+            if node.op == "call_function":
+                logging.warning(f"Visiting: {node}, {node.target.__name__}")
+                if node.target.__name__ in node_visitors:
+                    pass
+                else:
+                    raise RuntimeError(
+                        f"{node.target.__name__}" " is not supported in ENN Delegate"
+                    )
+            elif node.op in [
+                "get_attr",
+                "placeholder",
+                "output",
+            ]:
+                continue
+            else:
+                raise RuntimeError(f"{node.op}" " is not supported in ENN Delegate")
+
+        # 4 Compile Graph
+        return PreprocessResult(processed_bytes=0, debug_handle_map={})

backends/samsung/partition/enn_partitioner.py

@@ -0,0 +1,91 @@
+# Copyright (c) 2025 Samsung Electronics Co. LTD
+# All rights reserved
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+import logging
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+import torch
+from executorch.backends.samsung.enn_preprocess import EnnBackend
+
+from executorch.backends.samsung.utils.utils import get_compile_spec
+from executorch.exir.backend.backend_details import CompileSpec
+from executorch.exir.backend.canonical_partitioners.pattern_op_partitioner import (
+    generate_partitions_from_list_of_nodes,
+)
+from executorch.exir.backend.partitioner import (
+    DelegationSpec,
+    Partitioner,
+    PartitionResult,
+)
+from executorch.exir.backend.utils import tag_constant_data
+from torch.fx.passes.infra.partitioner import Partition
+from torch.fx.passes.operator_support import OperatorSupportBase
+
+
+class EnnOperatorSupport(OperatorSupportBase):
+
+    def __init__(
+        self,
+        edge_program: torch.export.ExportedProgram,
+        compile_specs: List[CompileSpec],
+    ):
+        self.edge_program = edge_program
+        option_spec = get_compile_spec(compile_specs, "Exynos compile", required=True)
+
+    def is_node_supported(self, _, node: torch.fx.Node) -> bool:
+        if node.op != "call_function":
+            return False
+
+        if node.op in [
+            "get_attr",
+            "placeholder",
+            "output",
+        ]:
+            return False
+
+        return False
+
+    def __del__(self):
+        pass
+
+
+class EnnPartitioner(Partitioner):
+    def __init__(self, compile_specs: List[CompileSpec]):
+        # TODO(anyone): Add meaningful initialize
+        self.delegation_spec = DelegationSpec(EnnBackend.__name__, compile_specs)
+        self.partition_tags: Dict[str, DelegationSpec] = {}
+        self.compile_specs = compile_specs
+
+    def generate_partitions(
+        self, edge_program: torch.export.ExportedProgram
+    ) -> List[Any]:
+
+        return generate_partitions_from_list_of_nodes(
+            edge_program.graph_module,
+            op_support=self.op_support_checker,
+        )
+
+    def tag_nodes(self, partitions: List[Partition]) -> None:
+        partition_tags: Dict[str, DelegationSpec] = {}
+        for partition in partitions:
+            # Add delegation tags
+            for node in partition.nodes:
+                delegation_tag = f"enn_{partition.id}"
+                node.meta["delegation_tag"] = delegation_tag
+                partition_tags[delegation_tag] = self.delegation_spec
+        return partition_tags
+
+    # override
+    def partition(self, edge_program: torch.export.ExportedProgram) -> PartitionResult:
+        partitions = self.generate_partitions(edge_program)
+        logging.info(f"Find {len(partitions)} " "subgraphs to partition and lowering.")
+        if len(partitions) != 0:
+            self.partition_tags = self.tag_nodes(partitions)
+            tag_constant_data(edge_program)
+        del self.op_support_checker
+        return PartitionResult(
+            tagged_exported_program=edge_program, partition_tags=self.partition_tags
+        )

backends/samsung/utils/export_utils.py

@@ -0,0 +1,29 @@
+# Copyright (c) 2025 Samsung Electronics Co. LTD
+# All rights reserved
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+from typing import List, Optional, Tuple
+
+import executorch.exir as exir
+import torch
+from executorch.exir import EdgeCompileConfig, ExportedProgram
+from executorch.exir.backend.backend_details import CompileSpec
+from executorch.exir.program._program import (
+    to_edge_transform_and_lower,
+)
+
+
+def to_edge_transform_and_lower_to_enn(
+    module: torch.nn.Module,
+    inputs: Tuple[torch.Tensor],
+    custom_pass_config: List[PassType] = None,
+    compile_specs: Optional[CompileSpec] = None,
+) -> exir.ExecutorchProgramManager:
+    assert compile_specs is not None, "For now, we must deliver complile specs"
+    prog = torch.export.export(module, inputs)
+    return to_edge_transform_and_lower(
+        prog,
+        compile_config=[],
+    )

examples/samsung/aot_compiler.py

@@ -0,0 +1,84 @@
+# Copyright (c) 2025 Samsung Electronics Co. LTD
+# All rights reserved
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+import argparse
+import logging
+
+from executorch.backends.samsung.serialization.compile_options import (
+    gen_samsung_backend_compile_spec,
+)
+from executorch.backends.samsung.utils.export_utils import (
+    to_edge_transform_and_lower_to_enn,
+)
+from executorch.exir import ExecutorchBackendConfig
+from executorch.extension.export_util.utils import save_pte_program
+
+from ..models import MODEL_NAME_TO_MODEL
+from ..models.model_factory import EagerModelFactory
+
+FORMAT = "[%(levelname)s %(asctime)s %(filename)s:%(lineno)s] %(message)s"
+logging.basicConfig(level=logging.INFO, format=FORMAT)
+
+SUPPORT_MODEL_NAMES = []
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument(
+        "-c",
+        "--chipset",
+        required=True,
+        help="Samsung chipset, i.e. E9955, etc",
+        type=str,
+    )
+    parser.add_argument(
+        "-m",
+        "--model_name",
+        required=True,
+        help=f"Model name. Valid ones: {SUPPORT_MODEL_NAMES}",
+    )
+    parser.add_argument("-o", "--output_dir", default=".", help="output directory")
+
+    args = parser.parse_args()
+
+    if args.model_name not in SUPPORT_MODEL_NAMES and args.quantize:
+        raise RuntimeError(
+            f"Model {args.model_name} is not a valid name. or not quantizable right now, "
+            "please contact executorch team if you want to learn why or how to support "
+            "quantization for the requested model"
+            f"Available models are {SUPPORT_MODEL_NAMES}."
+        )
+
+    model, example_inputs, dynamic_shapes, _ = EagerModelFactory.create_model(
+        *MODEL_NAME_TO_MODEL[args.model_name]
+    )
+    assert (
+        dynamic_shapes is None
+    ), "enn backend doesn't support dynamic shapes currently."
+
+    model = model.eval()
+
+    if args.quantize:
+        raise NotImplementedError("Quantizer is under developing...")
+    else:
+        # TODO(anyone) Remove the judgement after quantizer work fine or judge it in other ways
+        # raise AssertionError("Only support s8/fp16/s16")
+        pass
+
+    # logging.info(f"Exported graph:\n{edge.exported_program().graph}")
+    compile_specs = [gen_samsung_backend_compile_spec(args.chipset)]
+    edge = to_edge_transform_and_lower_to_enn(
+        model, example_inputs, compile_specs=compile_specs
+    )
+
+    # Save
+    exec_prog = edge.to_executorch(
+        config=ExecutorchBackendConfig(extract_delegate_segments=True)
+    )
+
+    quant_tag = "q8" if args.quantize else "fp32"
+    model_name = f"{args.model_name}_exynos_{quant_tag}"
+    save_pte_program(exec_prog, model_name, args.output_dir)