Move QNN SDK into backends/qualcomm/CMakeLists.txt

larryliu0820 · larryliu0820 · commit 1bbc5c01d394 · 2025-11-03T23:09:14.000-08:00
diff --git a/backends/qualcomm/CMakeLists.txt b/backends/qualcomm/CMakeLists.txt
@@ -23,15 +23,53 @@ get_filename_component(
   _common_include_directories "${EXECUTORCH_SOURCE_DIR}/.." ABSOLUTE
 )
 
-if(NOT DEFINED QNN_SDK_ROOT)
-  message(
-    FATAL_ERROR
-      "Please define QNN_SDK_ROOT, e.g. cmake <..> -DQNN_SDK_ROOT=<...>"
-  )
-elseif(CMAKE_TOOLCHAIN_FILE MATCHES ".*(iOS|ios\.toolchain)\.cmake$")
+if(CMAKE_TOOLCHAIN_FILE MATCHES ".*(iOS|ios\.toolchain)\.cmake$")
   message(FATAL_ERROR "ios is not supported by Qualcomm AI Engine Direct")
 endif()
 
+set(_qnn_host_is_linux_x86 FALSE)
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux"
+   AND CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|amd64|i.86)$")
+  set(_qnn_host_is_linux_x86 TRUE)
+endif()
+
+if(NOT DEFINED QNN_SDK_ROOT)
+  if(_qnn_host_is_linux_x86)
+    find_package(Python3 COMPONENTS Interpreter REQUIRED)
+    message(STATUS "QNN_SDK_ROOT not provided, downloading Qualcomm SDK")
+    execute_process(
+      COMMAND
+        ${Python3_EXECUTABLE}
+        ${EXECUTORCH_SOURCE_DIR}/backends/qualcomm/scripts/download_qnn_sdk.py
+        --print-sdk-path
+      WORKING_DIRECTORY ${EXECUTORCH_SOURCE_DIR}
+      RESULT_VARIABLE _qnn_sdk_download_result
+      OUTPUT_VARIABLE _qnn_sdk_download_output
+      ERROR_VARIABLE _qnn_sdk_download_error
+      OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    if(NOT _qnn_sdk_download_result EQUAL 0
+       OR _qnn_sdk_download_output STREQUAL "")
+      message(
+        FATAL_ERROR
+          "Failed to download Qualcomm SDK. stdout: ${_qnn_sdk_download_output}\n"
+          "stderr: ${_qnn_sdk_download_error}"
+      )
+    endif()
+    set(
+      QNN_SDK_ROOT
+      ${_qnn_sdk_download_output}
+      CACHE PATH "Qualcomm SDK root directory" FORCE
+    )
+  else()
+    message(
+      FATAL_ERROR
+        "Please define QNN_SDK_ROOT, e.g. cmake <..> -DQNN_SDK_ROOT=<...>"
+    )
+  endif()
+endif()
+
+set(ENV{QNN_SDK_ROOT} ${QNN_SDK_ROOT})
 message(STATUS "Using qnn sdk root ${QNN_SDK_ROOT}")
 message(STATUS "Using EXECUTORCH_SOURCE_DIR ${EXECUTORCH_SOURCE_DIR}")
 
@@ -214,7 +252,9 @@ add_subdirectory(
 install(
   TARGETS qnn_executorch_backend
   EXPORT ExecuTorchTargets
-  DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}/executorch/backends/qualcomm
+  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}/executorch/backends/qualcomm
+  RUNTIME DESTINATION ${CMAKE_INSTALL_LIBDIR}/executorch/backends/qualcomm
 )
 
 # QNN pybind
@@ -275,4 +315,10 @@ if(${CMAKE_SYSTEM_PROCESSOR} MATCHES "x86_64")
     ${QNN_EXECUTORCH_ROOT_DIR}/aot/python
     ${CMAKE_CURRENT_BINARY_DIR}/qnn_executorch/python
   )
+
+  install(
+    TARGETS PyQnnManagerAdaptor PyQnnWrapperAdaptor
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}/executorch/backends/qualcomm/python
+    RUNTIME DESTINATION ${CMAKE_INSTALL_LIBDIR}/executorch/backends/qualcomm/python
+  )
 endif()
diff --git a/backends/qualcomm/scripts/download_qnn_sdk.py b/backends/qualcomm/scripts/download_qnn_sdk.py
@@ -1,4 +1,4 @@
-# Add these imports for additional logging
+import argparse
 import ctypes
 import logging
 import os
@@ -592,3 +592,46 @@ def install_qnn_sdk() -> bool:
 
     # libc++ and QNN SDK setup
     return _ensure_libcxx_stack() and _ensure_qnn_sdk_lib()
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    parser = argparse.ArgumentParser(
+        description="Helper utility for Qualcomm SDK staging."
+    )
+    parser.add_argument(
+        "--dst-folder",
+        type=pathlib.Path,
+        default=SDK_DIR,
+        help="Destination directory for the Qualcomm SDK.",
+    )
+    parser.add_argument(
+        "--print-sdk-path",
+        action="store_true",
+        help="Print the resolved Qualcomm SDK path to stdout.",
+    )
+    parser.add_argument(
+        "--install-sdk",
+        action="store_true",
+        help="Ensure the SDK and runtime libraries are staged and loaded.",
+    )
+    args = parser.parse_args(argv)
+
+    logging.basicConfig(level=logging.INFO)
+
+    sdk_path: Optional[pathlib.Path]
+    if args.install_sdk:
+        if not install_qnn_sdk():
+            return 1
+        sdk_path = pathlib.Path(os.environ.get("QNN_SDK_ROOT", args.dst_folder))
+    else:
+        sdk_path = _download_qnn_sdk(dst_folder=args.dst_folder)
+        if sdk_path is None:
+            return 1
+
+    if args.print_sdk_path and sdk_path is not None:
+        print(sdk_path)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/setup.py b/setup.py
@@ -57,8 +57,6 @@
 import site
 import subprocess
 import sys
-import sysconfig
-import tempfile
 
 from distutils import log  # type: ignore[import-not-found]
 from distutils.sysconfig import get_python_lib  # type: ignore[import-not-found]
@@ -463,84 +461,6 @@ def run(self):
         if self._ran_build:
             return
 
-        try:
-            # Following code is for building the Qualcomm backend.
-            from backends.qualcomm.scripts.download_qnn_sdk import (
-                _download_qnn_sdk,
-                is_linux_x86,
-            )
-
-            if is_linux_x86():
-                os.environ["EXECUTORCH_BUILDING_WHEEL"] = "1"
-
-                with tempfile.TemporaryDirectory() as tmpdir:
-                    tmp_path = Path(tmpdir)
-                    sdk_path = _download_qnn_sdk(dst_folder=tmp_path)
-
-                    if not sdk_path:
-                        raise RuntimeError(
-                            "Qualcomm SDK not found, cannot build backend"
-                        )
-
-                    # Determine paths
-                    prj_root = Path(__file__).parent.resolve()
-                    build_sh = prj_root / "backends/qualcomm/scripts/build.sh"
-                    build_root = prj_root / "build-x86"
-
-                    if not build_sh.exists():
-                        raise FileNotFoundError(f"{build_sh} not found")
-
-                    # Run build.sh with SDK path exported
-                    env = dict(**os.environ)
-                    env["QNN_SDK_ROOT"] = str(sdk_path)
-                    subprocess.check_call(
-                        [
-                            str(build_sh),
-                            "--skip_linux_android",
-                            "--skip_linux_embedded",
-                        ],
-                        env=env,
-                    )
-
-                    # Copy the main .so into the wheel package
-                    so_src = (
-                        build_root / "backends/qualcomm/libqnn_executorch_backend.so"
-                    )
-                    so_dst = Path(
-                        self.get_ext_fullpath(
-                            "executorch.backends.qualcomm.qnn_backend"
-                        )
-                    )
-                    self.mkpath(str(so_dst.parent))  # ensure destination exists
-                    self.copy_file(str(so_src), str(so_dst))
-                    logging.info(f"Copied Qualcomm backend: {so_src} -> {so_dst}")
-
-                    # Copy Python adaptor .so files
-                    ext_suffix = sysconfig.get_config_var("EXT_SUFFIX")
-
-                    so_files = [
-                        (
-                            "executorch.backends.qualcomm.python.PyQnnManagerAdaptor",
-                            prj_root
-                            / f"backends/qualcomm/python/PyQnnManagerAdaptor{ext_suffix}",
-                        ),
-                        (
-                            "executorch.backends.qualcomm.python.PyQnnWrapperAdaptor",
-                            prj_root
-                            / f"backends/qualcomm/python/PyQnnWrapperAdaptor{ext_suffix}",
-                        ),
-                    ]
-
-                    for module_name, so_src in so_files:
-                        so_dst = Path(self.get_ext_fullpath(module_name))
-                        self.mkpath(str(so_dst.parent))
-                        self.copy_file(str(so_src), str(so_dst))
-                        logging.info(f"Copied Qualcomm backend: {so_src} -> {so_dst}")
-
-        except ImportError:
-            logging.error("Fail to build Qualcomm backend")
-            logging.exception("Import error")
-
         if self.editable_mode:
             self._ran_build = True
             self.run_command("build")
@@ -918,5 +838,24 @@ def run(self):  # noqa C901
             is_dynamic_lib=True,
             dependent_cmake_flags=["EXECUTORCH_BUILD_KERNELS_LLM_AOT"],
         ),
+        BuiltFile(
+            src_dir="%CMAKE_CACHE_DIR%/backends/qualcomm/%BUILD_TYPE%/",
+            src_name="qnn_executorch_backend",
+            dst="executorch/backends/qualcomm/",
+            is_dynamic_lib=True,
+            dependent_cmake_flags=["EXECUTORCH_BUILD_QNN"],
+        ),
+        BuiltExtension(
+            src_dir="%CMAKE_CACHE_DIR%/backends/qualcomm/python/%BUILD_TYPE%/",
+            src="PyQnnManagerAdaptor.*",
+            modpath="executorch.backends.qualcomm.python.PyQnnManagerAdaptor",
+            dependent_cmake_flags=["EXECUTORCH_BUILD_QNN"],
+        ),
+        BuiltExtension(
+            src_dir="%CMAKE_CACHE_DIR%/backends/qualcomm/python/%BUILD_TYPE%/",
+            src="PyQnnWrapperAdaptor.*",
+            modpath="executorch.backends.qualcomm.python.PyQnnWrapperAdaptor",
+            dependent_cmake_flags=["EXECUTORCH_BUILD_QNN"],
+        ),
     ],
 )
diff --git a/tools/cmake/preset/pybind.cmake b/tools/cmake/preset/pybind.cmake
@@ -35,6 +35,9 @@ elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
   set_overridable_option(EXECUTORCH_BUILD_EXTENSION_TRAINING ON)
   set_overridable_option(EXECUTORCH_BUILD_EXTENSION_LLM_RUNNER ON)
   set_overridable_option(EXECUTORCH_BUILD_EXTENSION_LLM ON)
+  if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|amd64|i.86)$")
+    set_overridable_option(EXECUTORCH_BUILD_QNN ON)
+  endif()
 elseif(CMAKE_SYSTEM_NAME STREQUAL "Windows" OR CMAKE_SYSTEM_NAME STREQUAL
                                                "WIN32"
 )
