Serialization from EXIR

- For Exynos AI LiteCore, EXIR will be serialized and converted.

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

Author: Jiseong-oh

backends/samsung/enn_preprocess.py

@@ -9,6 +9,11 @@
 
 import executorch.backends.samsung.python.PyEnnWrapperAdaptor as PyEnnWrapper
 import torch
+from executorch.backends.samsung.serialization.compile_options import (
+    ENN_COMPILE_OPTION_TITLE,
+)
+from executorch.backends.samsung.serialization.enn_graph_schema import EnnGraph
+
 from executorch.exir.backend.backend_details import (
     BackendDetails,
     CompileSpec,

backends/samsung/serialization/compile_options.py

@@ -0,0 +1,87 @@
+# 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 json
+import os
+import tempfile
+
+from dataclasses import dataclass
+from enum import IntEnum, unique
+from typing import Dict, List, Optional
+
+import pkg_resources
+from executorch.exir._serialize._dataclass import _DataclassEncoder
+from executorch.exir._serialize._flatbuffer import _flatc_compile
+from executorch.exir.backend.backend_details import CompileSpec
+
+
+@unique
+class SamsungChipset(IntEnum):
+    UNDEFINED_CHIP_V = 0
+    E9955 = 9955
+
+
+@dataclass
+class DebugOption:
+    name: str  # option name as a key
+    value: str
+
+
+@dataclass
+class EnnExecuTorchOptions:
+    chipset: SamsungChipset = SamsungChipset.UNDEFINED_CHIP_V
+    debug_options: Optional[List[DebugOption]] = None
+
+
+ENN_COMPILE_OPTION_TITLE = "enn_compile_options"
+COMPILE_OPTION_SCHEMA_NAME = "compile_options_def"
+
+
+def gen_samsung_backend_compile_spec_core(options: EnnExecuTorchOptions) -> CompileSpec:
+    with tempfile.TemporaryDirectory() as d:
+        # schema
+        schema_path = os.path.join(d, "{}.fbs".format(COMPILE_OPTION_SCHEMA_NAME))
+        with open(schema_path, "wb") as schema_file:
+            schema_file.write(
+                pkg_resources.resource_string(
+                    __name__, "{}.fbs".format(COMPILE_OPTION_SCHEMA_NAME)
+                )
+            )
+        # dump json
+        json_path = os.path.join(d, "{}.json".format(COMPILE_OPTION_SCHEMA_NAME))
+        enn_options_json = json.dumps(options, cls=_DataclassEncoder, indent=4)
+        with open(json_path, "wb") as json_file:
+            json_file.write(enn_options_json.encode("ascii"))
+
+        _flatc_compile(d, schema_path, json_path)
+        output_path = os.path.join(d, "{}.eeto".format(COMPILE_OPTION_SCHEMA_NAME))
+        with open(output_path, "rb") as output_file:
+            return CompileSpec(ENN_COMPILE_OPTION_TITLE, output_file.read())
+
+
+def gen_samsung_backend_compile_spec(
+    chipset: str, debug_options: Optional[Dict[str, str]] = None
+):
+    """
+    A function to generate an ExecuTorch binary for Samsung Backend.
+
+    Attributes:
+        chipset (str): chipset name in SamsungChipset. For example, E9955 or e9955 both work.
+
+    Returns:
+        CompileSpec: key is COMPILE_OPTION_SCHEMA_NAME, value is serialization binary of fb schema
+    """
+    pass_debug_options = []
+    if debug_options is not None:
+        for key, value in debug_options.items():
+            pass_debug_options.append(DebugOption(key, value))
+
+    option = EnnExecuTorchOptions(
+        getattr(SamsungChipset, chipset.upper()),
+        pass_debug_options,
+    )
+
+    return gen_samsung_backend_compile_spec_core(option)

backends/samsung/serialization/compile_options_def.fbs

@@ -0,0 +1,30 @@
+//============================================================================
+//
+// Copyright (c) 2025 Samsung Electronics. 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.
+//
+//============================================================================
+
+namespace enn_option;
+
+// Identifier of a valid executor schema.
+file_identifier "EETO";
+// Extension of written files.
+file_extension "eeto";
+
+table DebugOption {
+  name: string;
+  value: string;
+}
+
+table EnnExecuTorchOptions {
+  // The version of chipset. Specify the soc to compile and execute model.
+  chipset: int;
+
+  // Debug options controlling behavior of compilation.
+  debug_options: [DebugOption];
+}
+
+root_type EnnExecuTorchOptions;

backends/samsung/serialization/enn_graph_schema.py

@@ -0,0 +1,107 @@
+# 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, Dict, List, Optional, Union
+
+import executorch.backends.samsung.python.PyGraphWrapperAdaptor as PyGraphWrapper
+
+import numpy as np
+
+import torch
+
+class EnnGraph:
+    def __init__(self):
+        # default
+        self.version = "0.6.0"
+
+    def init(self, name: str, soc_name):
+        self.name = name
+        self.soc_name = soc_name
+        self.graph = PyGraphWrapper.PyEnnGraphWrapper()
+        self.graph.Init()
+
+        self.inputs = []
+        self.outputs = []
+
+    def define_op(
+        self,
+        name,
+        type,
+        input_ids: List[int],
+        output_ids: List[int],
+        params: Optional[Dict] = None,
+    ):
+        op = PyGraphWrapper.PyEnnOpWrapper(name, type, input_ids, output_ids)
+
+        if params is not None:
+            assert isinstance(params, dict), "Please pass op params as dict type."
+            for key in params:
+                py_param_wrapper = PyGraphWrapper.OpParamWrapper(key)
+                if isinstance(params[key], (list, tuple)):
+                    py_param_wrapper.SetVectorValue(params[key])
+                elif isinstance(params[key], str):
+                    py_param_wrapper.SetStringValue(params[key])
+                elif isinstance(params[key], (int, float, bool)):
+                    py_param_wrapper.SetScalarValue(params[key])
+                else:
+                    logging.error("Unsupported param type.")
+                # Set
+                op.AddOpParam(py_param_wrapper)
+
+        self.graph.DefineOpNode(op)
+
+    def define_tensor(  # noqa: C901
+        self,
+        name: str,
+        shape: List,
+        data_type: str,
+        tensor_type: str,
+        data: Optional[Union[np.ndarray, torch.Tensor]] = None,
+        quant_param: Optional[Dict[str, Any]] = None,
+    ) -> int:
+        layout = "NCHW" if len(shape) == 4 else "UNDEFINED"
+
+        tensor = PyGraphWrapper.PyEnnTensorWrapper(name, shape, data_type, layout)
+
+        if data is not None:
+            if isinstance(data, torch.Tensor):
+                data = data.detach().numpy()
+            tensor.AddData(data)
+
+        id = self.graph.DefineTensor(tensor)
+
+        if tensor_type == "INPUT":
+            self.inputs.append(id)
+        elif tensor_type == "OUTPUT":
+            self.outputs.append(id)
+
+        return id
+
+    def finish(self):
+        self.graph.SetGraphInputTensors(self.inputs)
+        self.graph.SetGraphOutputTensors(self.outputs)
+        self.graph.FinishBuild()
+
+    def serialize(self):
+        return self.graph.Serialize()
+
+    @staticmethod
+    def _affine_meta_param(param: Any) -> str:
+        type_str_affine_table = {
+            torch.int32: "FLOAT32",  # INT32 just used for HW quant.
+        }
+        if isinstance(param, str):
+            return param
+        if isinstance(param, (float, int)):
+            return [param]
+        if hasattr(param, "tolist"):
+            return param.tolist()
+        if isinstance(param, torch.dtype):
+            # Convenient for debugging
+            param = type_str_affine_table.get(param, "")
+
+        return param