Merge test

CMakeLists.txt

@@ -204,6 +204,8 @@ option(EXECUTORCH_BUILD_MPS "Build the MPS backend" OFF)
 
 option(EXECUTORCH_BUILD_NEURON "Build the backends/mediatek directory" OFF)
 
+option(EXECUTORCH_BUILD_OPENVINO "Build the Openvino backend" OFF)
+
 option(EXECUTORCH_BUILD_PYBIND "Build the Python Bindings" OFF)
 
 option(EXECUTORCH_BUILD_QNN "Build the Qualcomm backend" OFF)
@@ -715,6 +717,10 @@ if(EXECUTORCH_BUILD_NEURON)
   add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/backends/mediatek)
 endif()
 
+if(EXECUTORCH_BUILD_OPENVINO)
+  add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/backends/openvino)
+endif()
+
 if(EXECUTORCH_BUILD_QNN)
   add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/backends/qualcomm)
 endif()
@@ -817,6 +823,10 @@ if(EXECUTORCH_BUILD_PYBIND)
     list(APPEND _dep_libs mpsdelegate)
   endif()
 
+  if(EXECUTORCH_BUILD_OPENVINO)
+    list(APPEND _dep_libs openvino_backend)
+  endif()
+
   if(EXECUTORCH_BUILD_XNNPACK)
     # need to explicitly specify XNNPACK and microkernels-prod
     # here otherwise uses XNNPACK and microkernel-prod symbols from libtorch_cpu

README.md

@@ -29,6 +29,7 @@ Platform Support:
   - Arm
   - Cadence
   - MediaTek
+  - OpenVINO
   - Qualcomm
   - Vulkan
   - XNNPACK

backends/openvino/CMakeLists.txt

@@ -0,0 +1,75 @@
+# Copyright (c) Intel Corporation
+#
+# Licensed under the BSD License (the "License"); you may not use this file
+# except in compliance with the License. See the license file found in the
+# LICENSE file in the root directory of this source tree.
+
+# Set minimum required CMake version
+cmake_minimum_required(VERSION 3.19)
+
+# Set project name
+project(openvino_backend_project)
+
+# Set C++ standard
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Ensure compile_commands.json is generated
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+# Set up EXECUTORCH_ROOT if not already set
+if(NOT EXECUTORCH_ROOT)
+  set(EXECUTORCH_ROOT ${CMAKE_CURRENT_SOURCE_DIR}/../..)
+endif()
+
+# Define common include directories
+set(COMMON_INCLUDE_DIRS ${EXECUTORCH_ROOT}/..)
+
+# Include utility CMake scripts from ExecuteTorch
+include(${EXECUTORCH_ROOT}/build/Utils.cmake)
+
+# Find OpenVINO libraries
+find_package(OpenVINO REQUIRED)
+
+# Define OpenVINO backend as a static library
+add_library(openvino_backend STATIC .)
+
+# Enable exceptions and RTTI for OpenVINO backend
+target_compile_options(openvino_backend PRIVATE -frtti -fexceptions)
+
+# Include Executorch directories
+target_include_directories(openvino_backend PUBLIC ${COMMON_INCLUDE_DIRS})
+
+# Link OpenVINO and ExecuteTorch core libraries
+target_link_libraries(openvino_backend PRIVATE openvino::runtime executorch_core)
+
+# Add source files for OpenVINO backend
+target_sources(openvino_backend PRIVATE ${CMAKE_CURRENT_LIST_DIR}/runtime/OpenvinoBackend.cpp)
+
+target_link_options_shared_lib(openvino_backend)
+
+if(EXECUTORCH_BUILD_OPENVINO_EXECUTOR_RUNNER)
+    # Build executor runner binary for openvino backend
+    list(APPEND openvino_executor_runner_libs openvino_backend executorch)
+
+    set(_openvino_executor_runner__srcs
+        ${EXECUTORCH_ROOT}/examples/portable/executor_runner/executor_runner.cpp
+        ${EXECUTORCH_ROOT}/extension/data_loader/file_data_loader.cpp
+        ${EXECUTORCH_ROOT}/extension/evalue_util/print_evalue.cpp
+        ${EXECUTORCH_ROOT}/extension/runner_util/inputs.cpp
+        ${EXECUTORCH_ROOT}/extension/runner_util/inputs_portable.cpp
+        )
+    add_executable(openvino_executor_runner ${_openvino_executor_runner__srcs})
+
+    list(APPEND openvino_executor_runner_libs)
+
+    target_link_libraries(
+      openvino_executor_runner gflags portable_ops_lib ${openvino_executor_runner_libs}
+    )
+    target_compile_options(openvino_executor_runner PUBLIC ${_common_compile_options})
+endif()
+
+
+
+# Install OpenVINO backend library to the lib directory
+install(TARGETS openvino_backend DESTINATION lib)

backends/openvino/README.md

@@ -0,0 +1,87 @@
+# OpenVINO Backend for ExecuTorch
+The OpenVINO backend enables optimized execution of deep learning models on Intel hardware, leveraging Intel's [OpenVINO toolkit](https://www.intel.com/content/www/us/en/developer/tools/openvino-toolkit/overview.html) for inference acceleration.
+
+## Supported Hardware
+
+OpenVINO backend supports the following hardware:
+
+- Intel CPUs
+- Intel integrated GPUs
+- Intel discrete GPUs
+- Intel NPUs
+
+For more information on the supported hardware, please refer to [OpenVINO System Requirements](https://docs.openvino.ai/2025/about-openvino/release-notes-openvino/system-requirements.html) page.
+
+## Directory Structure
+
+```
+executorch
+├── backends
+│   └── openvino
+│       ├── runtime
+│           ├── OpenvinoBackend.cpp
+│           └── OpenvinoBackend.h
+│       ├── scripts
+│           └── openvino_build.sh
+│       ├── tests
+│       ├── CMakeLists.txt
+│       ├── README.md
+│       ├── __init__.py
+│       ├── partitioner.py
+│       ├── preprocess.py
+│       └── requirements.txt
+└── examples
+    └── openvino
+        ├── aot_optimize_and_infer.py
+        └── README.md
+```
+
+## Build Instructions
+
+### Prerequisites
+
+Before you begin, ensure you have openvino installed and configured on your system:
+
+```bash
+git clone https://github.com/openvinotoolkit/openvino.git
+cd openvino && git checkout releases/2025/1
+git submodule update --init --recursive
+mkdir build && cd build
+cmake .. -DCMAKE_BUILD_TYPE=Release -DENABLE_PYTHON=ON
+make -j$(nproc)
+
+cd ..
+cmake --install build --prefix <your_preferred_install_location>
+cd <your_preferred_install_location>
+source setupvars.sh
+```
+Note: The OpenVINO backend is not yet supported with the current OpenVINO release packages. It is recommended to build from source. The instructions for using OpenVINO release packages will be added soon.
+
+### Setup
+
+Follow the steps below to setup your build environment:
+
+1. **Setup ExecuTorch Environment**: Refer to the [Environment Setup](https://pytorch.org/executorch/stable/getting-started-setup#environment-setup) guide for detailed instructions on setting up the ExecuTorch environment.
+
+2. **Setup OpenVINO Backend Environment**
+- Install the dependent libs. Ensure that you are inside `executorch/backends/openvino/` directory
+   ```bash
+   pip install -r requirements.txt
+   ```
+  Note: To achieve optimal performance with NNCF quantization, you should install the latest development version of NNCF (version 2.16.0.dev0+191b53d9 or higher).
+3. Navigate to `scripts/` directory.
+
+4. **Build OpenVINO Backend C++ Libraries and Executor Runner**: Once the prerequisites are in place, run the `openvino_build.sh` script to start the build process. By default, OpenVINO backend will be built under `cmake-out/backends/openvino/` as `libopenvino_backend.a`
+
+   ```bash
+   ./openvino_build.sh
+   ```
+   **Build OpenVINO Backend Python Package with Pybindings**: To build and install the OpenVINO backend Python package with Python bindings, run the `openvino_build.sh` script with the `--enable_python` argument. This will compile and install the ExecuTorch Python package with the OpenVINO backend into your Python environment. This option will also enable python bindings required to execute OpenVINO backend tests and `export_and_infer_openvino.py` script inside `executorch/examples/openvino` folder.
+
+   ```bash
+   ./openvino_build.sh --enable_python
+   ```
+
+### Run
+
+Please refer to [README.md](../../examples/openvino/README.md) for instructions on running examples of various of models with openvino backend.

backends/openvino/__init__.py

@@ -0,0 +1,5 @@
+from .partitioner import OpenvinoPartitioner
+from .preprocess import OpenvinoBackend
+from .quantizer.quantizer import OpenVINOQuantizer
+
+__all__ = [OpenvinoBackend, OpenvinoPartitioner, OpenVINOQuantizer]

backends/openvino/partitioner.py

@@ -0,0 +1,141 @@
+# Copyright (c) Intel Corporation
+#
+# Licensed under the BSD License (the "License"); you may not use this file
+# except in compliance with the License. See the license file found in the
+# LICENSE file in the root directory of this source tree.
+
+from typing import Callable, final, List, Optional, Tuple
+
+import torch
+from executorch.backends.openvino.preprocess import OpenvinoBackend
+from executorch.exir.backend.backend_details import CompileSpec
+from executorch.exir.backend.partitioner import (
+    DelegationSpec,
+    Partitioner,
+    PartitionResult,
+)
+from executorch.exir.backend.utils import tag_constant_data
+from openvino.frontend.pytorch.torchdynamo.op_support import OperatorSupport
+
+from torch.export.exported_program import ExportedProgram
+from torch.fx.passes.infra.partitioner import CapabilityBasedPartitioner
+from torch.fx.passes.operator_support import OperatorSupportBase
+
+
+class OpenvinoOperatorsSupport(OperatorSupportBase):
+
+    def __init__(
+        self,
+        op_types_to_skip: Optional[set] = None,
+        op_names_to_skip: Optional[set] = None,
+    ) -> None:
+        """
+        Initializes the OpenvinoOperatorsSupport class.
+
+        :param op_types_to_skip: A set of operator types to skip during support checking.
+        :param op_names_to_skip: A set of operator names to skip during support checking.
+        """
+        if op_types_to_skip is None:
+            op_types_to_skip = set()
+        if op_names_to_skip is None:
+            op_names_to_skip = set()
+
+        self._op_types_to_skip = op_types_to_skip
+        self._op_names_to_skip = op_names_to_skip
+
+    def is_node_supported(self, _, node: torch.fx.Node) -> bool:
+        """
+        Checks if a given node is supported by OpenVINO.
+
+        :param node: The FX graph node representing an operation.
+        :return: True if the node is supported, otherwise False.
+        """
+        if node.op != "call_function":
+            return False
+
+        options = []
+        op_type = node.target.__name__
+        supported_ops = OperatorSupport(options)._support_dict
+        if op_type == "getitem":
+            return True
+
+        if "torch.ops." + str(op_type) in supported_ops:
+            return True
+        else:
+            print("Op not supported: ", "torch.ops." + str(op_type))
+
+        if op_type in self._op_types_to_skip or node.name in self._op_names_to_skip:
+            print(
+                f"[OpenVINO Backend] The {op_type} operator with name '{node.name}' is skipped."
+            )
+            return False
+
+        return False
+
+
+@final
+class OpenvinoPartitioner(Partitioner):
+
+    def __init__(
+        self,
+        compile_spec: List[CompileSpec],
+        op_types_to_skip: Optional[set] = None,
+        op_names_to_skip: Optional[set] = None,
+    ) -> None:
+        """
+        Initializes the OpenvinoPartitioner class.
+
+        :param compile_spec: A list of compile specifications for OpenVINO.
+        :param op_types_to_skip: A set of operator types to skip during partitioning.
+        :param op_names_to_skip: A set of operator names to skip during partitioning.
+        """
+        self.delegation_spec = DelegationSpec(OpenvinoBackend.__name__, compile_spec)
+        self._op_types_to_skip = op_types_to_skip
+        self._op_names_to_skip = op_names_to_skip
+
+    def ops_to_not_decompose(
+        self,
+        ep: ExportedProgram,
+    ) -> Tuple[List[torch._ops.OpOverload], Optional[Callable[[torch.fx.Node], bool]]]:
+        """
+        Returns a tuple containing a list of operations that should not be decomposed
+        and an optional function to filter nodes.
+
+        :param ep: The exported program.
+        :return: A tuple consisting of a list of ops to keep and an optional filtering function.
+        """
+        ops_not_decompose = [
+            torch.ops.aten.pixel_shuffle.default,
+            torch.ops.aten.upsample_bilinear2d.default,
+            torch.ops.aten.upsample_bilinear2d.vec,
+            torch.ops.aten.upsample_nearest2d.default,
+            torch.ops.aten.upsample_nearest2d.vec,
+        ]
+        return (ops_not_decompose, None)
+
+    def partition(self, exported_program: ExportedProgram) -> PartitionResult:
+        """
+        Partitions an exported program into supported and unsupported segments.
+
+        :param exported_program: The exported program.
+        :return: A PartitionResult containing the partitioned graph and delegation tags.
+        """
+        partitioner = CapabilityBasedPartitioner(
+            exported_program.graph_module,
+            OpenvinoOperatorsSupport(self._op_types_to_skip, self._op_names_to_skip),
+            allows_single_node_partition=True,
+        )
+        partition_list = partitioner.propose_partitions()
+
+        partition_tags = {}
+        for partition in partition_list:
+            for node in partition.nodes:
+                tag = f"tag{partition.id}"
+                node.meta["delegation_tag"] = tag
+                partition_tags[tag] = self.delegation_spec
+
+        tag_constant_data(exported_program)
+
+        return PartitionResult(
+            tagged_exported_program=exported_program, partition_tags=partition_tags
+        )