Support to converter Exynos's own IR from EXIR

- It can be converted op or graph

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

Author: Jiseong-oh

backends/samsung/builders/__init__.py

@@ -0,0 +1,11 @@
+# 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 . import node_visitor
+
+__all__ = [
+    node_visitor,
+]

backends/samsung/builders/node_visitor.py

@@ -0,0 +1,100 @@
+# 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 Dict, Optional
+
+import torch
+from executorch.backends.samsung.builders.utils import (
+    get_map_dtype,
+    get_tensor,
+    get_tensor_type,
+)
+from executorch.backends.samsung.serialization.enn_graph_schema import EnnGraph
+from torch.export import ExportedProgram
+
+
+class NodeVisitor:
+    """
+    Node visitor pattern for visiting nodes in an edge IR graph
+    """
+
+    def __init__(self, exported_program: ExportedProgram) -> None:
+        self._exported_program = exported_program or None
+
+    @property
+    def exported_program(self) -> ExportedProgram:
+        return self._exported_program
+
+    def define_node(self, node: torch.fx.Node, enn_graph: EnnGraph):
+        raise NotImplementedError("NodeVisitor must be extended!")
+
+    def define_tensor(
+        self,
+        node: torch.fx.Node,
+        enn_graph: EnnGraph,
+        vals_to_ids: Dict[torch.fx.Node, int],
+        swap_nc_for_weights: bool = False,
+        output_idx: Optional[int] = None,
+    ) -> int:
+        if node in vals_to_ids and (output_idx is None or output_idx == 0):
+            return vals_to_ids[node]
+
+        # Get tensor basic information
+        tensor = get_tensor(self.exported_program, node)
+
+        if output_idx is not None:
+            tensor = tensor[output_idx]
+
+        tensor_type = get_tensor_type(self.exported_program, node)
+        data_type = get_map_dtype(tensor.dtype)
+
+        const_data = None
+
+        dims = [1] if len(tensor.size()) == 0 else list(tensor.size())
+
+        enn_tensor_id = enn_graph.define_tensor(
+            node.name,
+            dims,
+            data_type,
+            tensor_type.name,
+            const_data,
+        )
+        assert enn_tensor_id is not None
+        vals_to_ids[node] = enn_tensor_id
+
+        return enn_tensor_id
+
+
+_node_visitor_dict = {}
+
+
+def register_node_visitor(visitor):
+    assert (
+        isinstance(visitor, type)
+        and issubclass(visitor, NodeVisitor)
+        and hasattr(visitor, "target")
+    ), f"Illformed NodeVisitor subclass, can't register!, got: {visitor}"
+    if isinstance(visitor.target, str):
+        _node_visitor_dict[visitor.target] = visitor
+    elif isinstance(visitor.target, (list, tuple)):
+        for target in visitor.target:
+            _node_visitor_dict[target] = visitor
+    else:
+        raise TypeError(
+            f"target of vistor should be str|Tuple[str]|List[str], not{type(visitor.target)}"
+        )
+
+
+def get_node_visitors(*args) -> Dict[str, NodeVisitor]:
+    node_visitors = {}
+    """
+    Create a new class instance at runtime, and put them in a dict
+    """
+    for target, visitor in _node_visitor_dict.items():
+        assert callable(visitor), "Expecting a callable class, "
+        f"but got {visitor} of type {type(visitor)}"
+        node_visitors[target] = visitor(*args)
+    return node_visitors

backends/samsung/builders/utils.py

@@ -0,0 +1,65 @@
+# 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 enum import Enum
+
+import torch
+from executorch.backends.samsung.utils.utils import is_graph_input, is_graph_output
+from executorch.backends.transforms.utils import get_param_tensor, is_param_node
+
+from torch.export import ExportedProgram
+
+DATA_TYPE_STR_MAPPING = {
+    torch.int8: "INT8",
+    torch.uint8: "UINT8",
+    torch.int16: "INT16",
+    torch.uint16: "UINT16",
+    torch.int32: "INT32",
+    torch.int64: "INT64",
+    torch.float16: "FLOAT16",
+    torch.float32: "FLOAT32",
+}
+
+TORCH_TYPE_QTYPE_MAPPING = {
+    torch.int8: torch.qint8,
+    torch.uint8: torch.quint8,
+    torch.int32: torch.qint32,
+}
+
+
+class TensorType(Enum):
+    INPUT = 0
+    OUTPUT = 1
+    CONSTANT = 2
+    FEATUREMAP = 3
+
+
+def get_tensor_type(exported_program: ExportedProgram, tensor: torch.fx.Node) -> str:
+    if is_graph_input(exported_program, tensor):
+        return TensorType.INPUT
+    elif is_graph_output(tensor):
+        return TensorType.OUTPUT
+    elif is_param_node(exported_program, tensor):
+        return TensorType.CONSTANT
+    else:
+        return TensorType.FEATUREMAP
+
+
+def get_map_dtype(dtype):
+    if dtype not in DATA_TYPE_STR_MAPPING:
+        raise RuntimeError("Data type cannot be decided: ", dtype)
+    return DATA_TYPE_STR_MAPPING[dtype]
+
+
+def get_tensor(exported_program: ExportedProgram, node: torch.fx.Node):
+    if not is_param_node(exported_program, node):
+        return node.meta["val"]
+    tensor = get_param_tensor(exported_program, node)
+    return tensor.contiguous()
+
+
+def affine_type_to_str(ttype: TensorType):
+    return str(ttype).removeprefix("TensorType.")

backends/samsung/enn_preprocess.py

@@ -9,10 +9,12 @@
 
 import executorch.backends.samsung.python.PyEnnWrapperAdaptor as PyEnnWrapper
 import torch
+from executorch.backends.samsung.builders.node_visitor import get_node_visitors
 from executorch.backends.samsung.serialization.compile_options import (
     ENN_COMPILE_OPTION_TITLE,
 )
 from executorch.backends.samsung.serialization.enn_graph_schema import EnnGraph
+from executorch.backends.samsung.utils.utils import get_compile_spec
 
 from executorch.exir.backend.backend_details import (
     BackendDetails,
@@ -38,23 +40,23 @@ def preprocess(
         )
         enn_wrapper.Init(option_spec.value)
 
-        enn_preprocess_passes = PassManager(passes=[])
-
-        # 2 make enn graph
         enn_preprocess_passes = PassManager(passes=[])
         pass_result = enn_preprocess_passes(edge_program.graph_module)
+        assert pass_result is not None
 
         enn_graph = EnnGraph()
         enn_graph.init("UnknownName", "")
-        # 3 node visitors
-        node_visitors = []
+        # node visitors
+        node_visitors = get_node_visitors(edge_program)
 
         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
+                    node_visitors[node.target.__name__].define_node(
+                        node, enn_graph, vals_to_ids
+                    )
                 else:
                     raise RuntimeError(
                         f"{node.target.__name__}" " is not supported in ENN Delegate"
@@ -68,11 +70,13 @@ def preprocess(
             else:
                 raise RuntimeError(f"{node.op}" " is not supported in ENN Delegate")
 
-        # 4 Compile Graph
+        # Compile Graph
         enn_wrapper.Destroy()
         enn_graph.finish()
         ser_buf = enn_graph.serialize()
         enn_context_binary = enn_wrapper.Compile(ser_buf)
         assert enn_context_binary is not None and len(enn_context_binary) > 0
         enn_wrapper.Destroy()
-        return PreprocessResult(processed_bytes=bytes(enn_context_binary), debug_handle_map={})
+        return PreprocessResult(
+            processed_bytes=bytes(enn_context_binary), debug_handle_map={}
+        )

backends/samsung/utils/utils.py

@@ -0,0 +1,37 @@
+# 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
+
+import torch
+
+from executorch.backends.transforms.utils import is_param_node
+from executorch.exir.backend.backend_details import CompileSpec
+
+from torch.export.exported_program import ExportedProgram
+
+
+def get_compile_spec(
+    compile_specs: List[CompileSpec], spec_name: str, required=False
+) -> CompileSpec:
+    for spec in compile_specs:
+        if spec_name == spec.key:
+            return spec
+    assert not required, f"Require {spec_name} but it doesn't exist."
+
+
+def is_graph_input(exported_program: ExportedProgram, node: torch.fx.Node) -> bool:
+    return node.op == "placeholder" and not is_param_node(exported_program, node)
+
+
+def is_graph_output(node: torch.fx.Node) -> bool:
+    # skip getitem node
+    for user in node.users.keys():
+        if user.op == "output" or (
+            user.target.__name__ == "getitem" and is_graph_output(user)
+        ):
+            return True
+    return False