Provide a python interface for compliation

- Provides a Python interface for compiling NN models via LiteCore in ahead-of-time compilation.

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

Author: Jiseong-oh

backends/samsung/aot/CMakeLists.txt

@@ -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.
+
+target_sources(
+    PyEnnWrapperAdaptor PUBLIC PyEnnWrapperAdaptor.cpp
+        PyEnnWrapperAdaptor.h
+)
+

backends/samsung/aot/PyEnnWrapperAdaptor.cpp

@@ -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.
+ *
+ */
+
+#include <executorch/backends/samsung/aot/PyEnnWrapperAdaptor.h>
+#include <pybind11/pybind11.h>
+
+namespace torch {
+namespace executor {
+namespace enn {
+PYBIND11_MODULE(PyEnnWrapperAdaptor, m) {
+  pybind11::class_<PyEnnWrapper, std::shared_ptr<PyEnnWrapper>>(m, "EnnWrapper")
+      .def(pybind11::init())
+      .def("Init", &PyEnnWrapper::Init)
+      .def("IsNodeSupportedByBackend", &PyEnnWrapper::IsNodeSupportedByBackend)
+      .def(
+          "Compile",
+          &PyEnnWrapper::Compile,
+          "Ahead of time compilation for serialized graph.")
+      .def("Destroy", &PyEnnWrapper::Destroy, "Release resources.");
+}
+} // namespace enn
+} // namespace executor
+} // namespace torch

backends/samsung/aot/PyEnnWrapperAdaptor.h

@@ -0,0 +1,79 @@
+/*
+ *  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.
+ *
+ */
+#pragma once
+
+#include <include/graphgen_c.h>
+#include <include/graphgen_common.h>
+#include <pybind11/numpy.h>
+#include <pybind11/pybind11.h>
+
+#include <iostream>
+#include <memory>
+#include <vector>
+
+namespace py = pybind11;
+
+namespace torch {
+namespace executor {
+namespace enn {
+
+class PyEnnWrapper {
+ public:
+  PyEnnWrapper() {}
+
+  void Init(const py::bytes& compile_opts) {
+    graphgen_instance_ = graphgen_create();
+  }
+
+  bool IsNodeSupportedByBackend() {
+    return False;
+  }
+
+  py::array_t<char> Compile(const py::array_t<char>& model_buffer) {
+    if (graphgen_instance_ == nullptr) {
+      ENN_LOG_ERROR("Please call `Init()` first before compile.");
+      return py::array_t<char>();
+    }
+
+
+    auto m_buf_info = model_buffer.request();
+    auto* model_buf_ptr = reinterpret_cast<uint8_t*>(m_buf_info.ptr);
+    NNCBuffer* nnc_buffer = nullptr;
+    if (graphgen_generate(
+            graphgen_instance_, model_buf_ptr, m_buf_info.size, &nnc_buffer) !=
+        GraphGenResult::SUCCESS) {
+      ENN_LOG_ERROR("Compile model failed.");
+      return py::array_t<char>();
+    }
+
+   auto result = py::array_t<char>({nnc_buffer->size}, {sizeof(char)});
+    auto result_buf = result.request();
+    memcpy(result_buf.ptr, nnc_buffer->addr, nnc_buffer->size);
+
+    graphgen_release_buffer(graphgen_instance_, nnc_buffer);
+
+    return result;
+  }
+
+  void Destroy() {
+    graphgen_release(graphgen_instance_);
+    graphgen_instance_ = nullptr;
+  }
+
+  ~PyEnnWrapper() {
+    Destroy();
+  }
+
+ private:
+  // pointer to enn software entry
+  void* graphgen_instance_ = nullptr;
+};
+} // namespace enn
+} // namespace executor
+} // namespace torch

backends/samsung/enn_preprocess.py

@@ -7,6 +7,7 @@
 import logging
 from typing import Dict, final, List
 
+import executorch.backends.samsung.python.PyEnnWrapperAdaptor as PyEnnWrapper
 import torch
 from executorch.exir.backend.backend_details import (
     BackendDetails,
@@ -26,7 +27,12 @@ def preprocess(
         edge_program: ExportedProgram,
         compile_specs: List[CompileSpec],
     ) -> PreprocessResult:
-        # 1 Converter Init
+        enn_wrapper = PyEnnWrapper.EnnWrapper()
+        option_spec = get_compile_spec(
+            compile_specs, ENN_COMPILE_OPTION_TITLE, required=True
+        )
+        enn_wrapper.Init(option_spec.value)
+
         enn_preprocess_passes = PassManager(passes=[])
 
         # 2 make enn graph
@@ -55,4 +61,5 @@ def preprocess(
                 raise RuntimeError(f"{node.op}" " is not supported in ENN Delegate")
 
         # 4 Compile Graph
+        enn_wrapper.Destroy()
         return PreprocessResult(processed_bytes=0, debug_handle_map={})

backends/samsung/partition/enn_partitioner.py

@@ -7,6 +7,8 @@
 import logging
 from typing import Any, Callable, Dict, List, Optional, Tuple
 
+import executorch.backends.samsung.python.PyEnnWrapperAdaptor as PyEnnWrapper
+
 import torch
 from executorch.backends.samsung.enn_preprocess import EnnBackend
 
@@ -33,7 +35,9 @@ def __init__(
         compile_specs: List[CompileSpec],
     ):
         self.edge_program = edge_program
+        self.enn_wrapper = PyEnnWrapper.EnnWrapper()
         option_spec = get_compile_spec(compile_specs, "Exynos compile", required=True)
+        self.enn_wrapper.Init(option_spec.value)
 
     def is_node_supported(self, _, node: torch.fx.Node) -> bool:
         if node.op != "call_function":
@@ -46,10 +50,11 @@ def is_node_supported(self, _, node: torch.fx.Node) -> bool:
         ]:
             return False
 
-        return False
+        supported = self.enn_wrapper.IsNodeSupportedByBackend()
+        return supported
 
     def __del__(self):
-        pass
+        self.enn_wrapper.Destroy()
 
 
 class EnnPartitioner(Partitioner):