Exynos Backend for Executorch to bring up on Exynos SoC

CMakeLists.txt

@@ -576,6 +576,10 @@ if(EXECUTORCH_BUILD_QNN)
   list(APPEND _executorch_backends qnn_executorch_backend)
 endif()
 
+if(EXECUTORCH_BUILD_SAMSUNG)
+  add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/backends/samsung)
+endif()
+
 if(EXECUTORCH_BUILD_XNNPACK)
   add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/backends/xnnpack)
   list(APPEND _executorch_backends xnnpack_backend)

LICENSE

@@ -8,6 +8,7 @@ Copyright (c) Qualcomm Innovation Center, Inc.
 Copyright (c) 2023 Apple Inc.
 Copyright (c) 2024 MediaTek Inc.
 Copyright 2023 NXP
+Copyright (c) 2025 Samsung Electronics Co. LTD
 
 Redistribution and use in source and binary forms, with or without modification,
 are permitted provided that the following conditions are met:

backends/samsung/CMakeLists.txt

@@ -0,0 +1,141 @@
+# 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.
+
+
+cmake_minimum_required(VERSION 3.15)
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+get_filename_component(EXECUTORCH_SOURCE_DIR "${CMAKE_CURRENT_LIST_DIR}/../.." ABSOLUTE)
+
+if(NOT DEFINED EXYNOS_AI_LITECORE_PATH)
+	message(FATAL_ERROR "Please define EXYNOS_AI_LIRECORE_PATH by adding cmake parameter -DEXYNOS_AI_LITECORE_PATH=<...>")
+endif()
+if(CMAKE_TOOLCHAIN_FILE MATCHES ".*(iOS|ios\.toolchain)\.cmake$")
+	message(FATAL_ERROR "IOS is not supported on Exynos.")
+endif()
+
+if(NOT FLATC_EXECUTABLE)
+    set(FLATC_EXECUTABLE flatc)
+endif()
+
+add_compile_options(-Wall -Werror -fPIC)
+if(CMAKE_BUILD_TYPE STREQUAL "Release")
+    # strip symbols
+    add_link_options("-s")
+    # hide dynamic symbols
+    set(CMAKE_C_VISIBILITY_PRESET hidden)
+    set(CMAKE_CXX_VISIBILITY_PRESET hidden)
+    add_definitions(-DNDEBUG)
+endif()
+
+include_directories(${EXECUTORCH_SOURCE_DIR}/..)
+include_directories(${EXYNOS_AI_LITECORE_PATH})
+
+if(${ANDROID})
+    find_library(android_log log)
+endif()
+
+# add logging library
+add_library(enn_logging STATIC)
+
+
+if(${CMAKE_SYSTEM_PROCESSOR} MATCHES "x86_64")
+    add_subdirectory(
+        ${EXECUTORCH_SOURCE_DIR}/third-party/pybind11
+        ${CMAKE_CURRENT_BINARY_DIR}/pybind11
+    )
+    add_library(PyEnnWrapperAdaptor MODULE)
+
+    find_library(GG_API_LIB NAMES graphgen_api HINTS ${EXYNOS_AI_LITECORE_PATH}/lib64/)
+    add_library(graphgen_api SHARED IMPORTED GLOBAL)
+    set_target_properties(graphgen_api PROPERTIES
+        INTERFACE_INCLUDE_DIRECTORIES "${EXYNOS_AI_LITECORE_PATH}/include"
+        IMPORTED_LOCATION "${GG_API_LIB}"
+    )
+
+
+    set(_enn_compile_options_schema ${CMAKE_CURRENT_SOURCE_DIR}/serialization/compile_options_def.fbs)
+
+    set(_enn_schema_generate_dir "${CMAKE_BINARY_DIR}/schema/include/executorch/backends/samsung")
+    # Paths to headers generated from the .fbs files.
+    string(REGEX REPLACE "serialization/([^/]+)[.]fbs$" "\\1_generated.h" generated_header "${fbs_file}")
+    set(_enn_schema_output "${_enn_schema_generate_dir}/${generated_header}")
+
+    # Generate the headers from the .fbs files.
+    add_custom_command(
+        OUTPUT ${_enn_schema_output}
+        COMMAND
+        ${FLATC_EXECUTABLE} --cpp --cpp-std c++11 --scoped-enums -o
+        "${_enn_schema_generate_dir}"
+        ${_enn_compile_options_schema}
+        DEPENDS ${_enn_compile_options_schema}
+        WORKING_DIRECTORY ${EXECUTORCH_SOURCE_DIR}
+        COMMENT "Generating enn compile options headers"
+        VERBATIM
+    )
+    add_custom_target(enn_compile_options_output ALL DEPENDS ${_enn_schema_output})
+
+    set_target_properties(PyEnnWrapperAdaptor PROPERTIES CXX_VISIBILITY_PRESET hidden)
+    target_link_libraries(PyEnnWrapperAdaptor PRIVATE
+        pybind11::module
+        pybind11::lto
+        graphgen_api
+        enn_logging
+    )
+    target_include_directories(PyEnnWrapperAdaptor BEFORE PRIVATE
+        ${CMAKE_BINARY_DIR}/schema/include
+        ${EXECUTORCH_SOURCE_DIR}/third-party/flatbuffers/include
+    )
+    add_dependencies(PyEnnWrapperAdaptor enn_compile_options_output)
+    pybind11_extension(PyEnnWrapperAdaptor)
+
+    # PyGraphWrapperAdaptor
+    add_library(PyGraphWrapperAdaptor MODULE)
+    #
+    find_library(GRAPH_WRAPPER_LIB NAMES graph_wrapper HINTS ${EXYNOS_AI_LITECORE_PATH}/lib64/)
+    add_library(graph_wrapper SHARED IMPORTED GLOBAL)
+    set_target_properties(graph_wrapper PROPERTIES
+            INTERFACE_INCLUDE_DIRECTORIES "${EXYNOS_AI_LITECORE_PATH}/include"
+            IMPORTED_LOCATION "${GRAPH_WRAPPER_LIB}"
+    )
+    set_target_properties(PyGraphWrapperAdaptor PROPERTIES CXX_VISIBILITY_PRESET hidden)
+    target_link_libraries(PyGraphWrapperAdaptor PRIVATE
+            pybind11::module
+            pybind11::lto
+            graph_wrapper
+            enn_logging
+    )
+    pybind11_extension(PyGraphWrapperAdaptor)
+
+    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/aot)
+endif()
+
+
+if(${ANDROID})
+    target_link_libraries(enn_logging PRIVATE ${android_log})
+    add_library(enn_backend STATIC)
+    target_link_libraries(enn_backend PRIVATE enn_logging)
+    target_link_options_shared_lib(enn_backend)
+
+    set(__enn_executor_runner_srcs ${EXECUTORCH_SOURCE_DIR}/examples/samsung/executor_runner/enn_executor_runner.cpp)
+    add_executable(enn_executor_runner ${__enn_executor_runner_srcs})
+    target_link_libraries(enn_executor_runner PRIVATE
+            enn_logging
+            enn_backend
+            gflags
+            executorch
+            extension_data_loader
+            portable_ops_lib
+    )
+    set_target_properties(enn_executor_runner PROPERTIES CXX_VISIBILITY_PRESET hidden)
+    install(
+        TARGETS enn_backend enn_logging
+        DESTINATION lib
+    )
+endif()
+
+add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/runtime)

backends/samsung/README.md

@@ -0,0 +1,71 @@
+# ExecuTorch Samsung Exynos Delegate
+
+The subtree contains Exynos delegation implementation for ExecuTorch. The target of delegation
+is deploying torch model run with exynos NPU/DSP.
+
+This backend is implemented on the top of [EXYNOS_LITECORE](https://soc-developer.semiconductor.samsung.com/global/development/light-core)
+Please prepare the SDK before you start, it is important to code compilation and runtime.
+
+## Delegate Options
+
+### Supported Chipset
+- Exynos 2500 (E9955)
+
+### Supported Inference Type
+- Quantized (i8/u8/i16/u16)
+- FP16
+
+## Directory Structure
+
+```
+backends/samsung
+├── aot        # Codes for generating binary buffer for ENN runtime.
+├── builders   # Codes for lowering each operators.
+├── partition  # ENN Partitioner.
+├── passes     # Various passes helping lower models to ENN backend.
+├── python     # Places to put pybind artifacts for accessing samsung libraries.
+├── runtime    # ENN runtime for executing lowered models.
+├── scripts    # Misc supporting scripts, not related to core functionality.
+└── serialization # Codes for building Graph IR for Exynos and serializing.
+
+examples
+└── samsung # Examples to run ENN backends.
+```
+
+## How to build
+Please download Exynos AI LiteCore, and set the root path of SDK directory to `EXYNOS_AI_LITECORE_PATH`.</br>
+Please navigate to [Android NDK](https://developer.android.com/ndk) and download a version of NDK.
+`ANDROID_NDK` refers the root path of NDK directory.</br>
+
+### Set up environment variables
+```bash
+export LD_LIBRARY_PATH=${EXYNOS_AI_LITECORE_PATH}/lib64
+```
+
+### Build AOT Targets
+Generated python artifacts allow user call `Compile` interface to lower a model to ENN backend in python script.
+```bash
+./backends/samsung/build.sh -b x86_64
+```
+
+### Build ENN Runtime
+```bash
+./backends/samsung/build.sh -b android --ndk ${ANDROID_NDK}
+```
+ANDROID_ABI=arm64-v8a is default, necessary runtime executable generate in `build_exynos_android` directory.
+
+### Build Anroid Extension
+This is later exposed Java app. Please turn on CMake option `EXECUTORCH_BUILD_ENN`, and ENN runtime will be added.
+```bash
+cmake extension/android \
+  -DCMAKE_TOOLCHAIN_FILE="${ANDROID_NDK}/build/cmake/android.toolchain.cmake" \
+  -DANDROID_ABI="${ANDROID_ABI}" \
+  -DCMAKE_INSTALL_PREFIX=cmake-android-out \
+  -Bcmake-android-out/extension/android
+
+cmake --build cmake-android-out/extension/android -j8
+```
+
+## Examples
+
+Please see this [README.md](../../examples/samsung/README.md).

backends/samsung/aot/CMakeLists.txt

@@ -0,0 +1,15 @@
+# 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
+)
+target_sources(
+        PyGraphWrapperAdaptor PUBLIC PyGraphWrapperAdaptor.cpp
+        PyGraphWrapperAdaptor.h wrappers/op_param_wrapper.h
+        wrappers/op_wrapper.h wrappers/tensor_wrapper.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