temp for sdk and fix libcxx

Author: cccclai

backends/qualcomm/__init__.py

@@ -6,7 +6,9 @@
 # If users have preinstalled QNN_SDK_ROOT, we will use it.
 qnn_sdk_root_flag = os.getenv("QNN_SDK_ROOT", None)
 
+print("evn_flag: ", env_flag, "qnn_sdk_root_flag: ", qnn_sdk_root_flag, "qnn_sdk_root")
 if not env_flag in ("1", "true", "yes") and not qnn_sdk_root_flag:
+    print("############ Installing QNN SDK ############")
     ok = install_qnn_sdk()
     if not ok:
         raise RuntimeError("Failed to install QNN SDK. Please check the logs above.")

backends/qualcomm/scripts/download_qnn_sdk.py

@@ -38,9 +38,9 @@ def get_qnn_version() -> str:
     return QNN_VERSION
 
 
-def _download_qnn_sdk() -> Optional[pathlib.Path]:
+def _download_qnn_sdk(dst_folder=SDK_DIR) -> Optional[pathlib.Path]:
     """
-    Download and extract the Qualcomm SDK into SDK_DIR.
+    Download and extract the Qualcomm SDK into dst_folder.
 
     Notes:
         - Only runs on Linux x86 platforms. Skips otherwise.
@@ -53,8 +53,8 @@ def _download_qnn_sdk() -> Optional[pathlib.Path]:
         print("Skipping Qualcomm SDK (only supported on Linux x86).")
         return None
 
-    SDK_DIR.mkdir(parents=True, exist_ok=True)
-    print(f"SDK_DIR is {SDK_DIR}, exists: {SDK_DIR.exists()}")
+    dst_folder.mkdir(parents=True, exist_ok=True)
+    print(f"dst_folder is {dst_folder}, exists: {dst_folder.exists()}")
     print(f"Current working directory: {os.getcwd()}")
 
     with tempfile.TemporaryDirectory() as tmpdir:
@@ -95,24 +95,24 @@ def report_progress(block_num, block_size, total_size):
 
         if QAIRT_URL.endswith(".zip"):
             print("Extracting ZIP archive...")
-            _extract_zip(archive_path, QAIRT_CONTENT_DIR, SDK_DIR)
+            _extract_zip(archive_path, QAIRT_CONTENT_DIR, dst_folder)
         elif QAIRT_URL.endswith((".tar.gz", ".tgz")):
             print("Extracting TAR archive...")
-            _extract_tar(archive_path, QAIRT_CONTENT_DIR, SDK_DIR)
+            _extract_tar(archive_path, QAIRT_CONTENT_DIR, dst_folder)
         else:
             raise ValueError(f"Unsupported archive format: {QAIRT_URL}")
 
-        print(f"Verifying extraction to {SDK_DIR}")
-        if SDK_DIR.exists():
+        print(f"Verifying extraction to {dst_folder}")
+        if dst_folder.exists():
             print(f"SDK directory exists. Contents:")
-            for item in SDK_DIR.iterdir():
+            for item in dst_folder.iterdir():
                 print(f"  {item.name}")
         else:
             print("ERROR: SDK directory was not created!")
 
-        print(f"Qualcomm SDK extracted to {SDK_DIR}")
+        print(f"Qualcomm SDK extracted to {dst_folder}")
 
-    return SDK_DIR
+    return dst_folder
 
 
 def _extract_zip(archive_path, content_dir, target_dir):
@@ -166,8 +166,8 @@ def _extract_tar(archive_path: pathlib.Path, prefix: str, target_dir: pathlib.Pa
     "libc++.so.1.0",
     "libc++abi.so.1.0",
     "libunwind.so.1",
-    "libm.so.6",
-    "libpython3.10.so.1.0",
+    # "libm.so.6",
+    # "libpython3.10.so.1.0",
 ]
 
 
@@ -189,23 +189,16 @@ def _stage_libcxx(target_dir: pathlib.Path):
     with tarfile.open(temp_tar, "r:xz") as tar:
         tar.extractall(temp_extract.parent)
 
-    lib_src = temp_extract / "lib"
+    lib_src = temp_extract / "lib" / "x86_64-unknown-linux-gnu"
     for fname in REQUIRED_LIBCXX_LIBS:
         src_path = lib_src / fname
         if not src_path.exists():
-            print(f"[libcxx] Warning: {fname} not found in extracted LLVM")
+            print(
+                f"[libcxx] Warning: {fname} not found in extracted LLVM src_path {src_path}"
+            )
             continue
         shutil.copy(src_path, target_dir / fname)
 
-    libcxx = target_dir / "libc++.so.1.0"
-    libcxx_abi = target_dir / "libc++abi.so.1.0"
-    if libcxx.exists():
-        os.symlink("libc++.so.1.0", target_dir / "libc++.so.1")
-        os.symlink("libc++.so.1", target_dir / "libc++.so")
-    if libcxx_abi.exists():
-        os.symlink("libc++abi.so.1.0", target_dir / "libc++abi.so.1")
-        os.symlink("libc++abi.so.1", target_dir / "libc++abi.so")
-
     print(f"[libcxx] Staged libc++ to {target_dir}")
 
 
@@ -294,13 +287,14 @@ def _ensure_qnn_sdk_lib() -> bool:
 
 
 def _load_libcxx_libs(lib_path):
+    print("running _load_libcxx_libs")
     candidates = list(lib_path.glob("*.so*"))
     priority = ["libc++abi", "libc++"]
     sorted_candidates = [
         f for name in priority for f in candidates if f.name.startswith(name)
     ]
     sorted_candidates += [f for f in candidates if f not in sorted_candidates]
-
+    print("sorted_candidates: ", sorted_candidates)
     for sofile in sorted_candidates:
         try:
             ctypes.CDLL(str(sofile), mode=ctypes.RTLD_GLOBAL)
@@ -357,6 +351,6 @@ def install_qnn_sdk() -> bool:
     Returns:
         True if both steps succeeded (or were already satisfied), else False.
     """
-    ok_qnn = _ensure_qnn_sdk_lib()
     ok_libcxx = _ensure_libcxx_stack()
+    ok_qnn = _ensure_qnn_sdk_lib()
     return bool(ok_qnn and ok_libcxx)

setup.py

@@ -466,82 +466,62 @@ def run(self):
 
         try:
             # Following code is for building the Qualcomm backend.
-            from backends.qualcomm.scripts.download_qnn_sdk import (
-                _download_qnn_sdk,
-                SDK_DIR,
-            )
+            from backends.qualcomm.scripts.download_qnn_sdk import _download_qnn_sdk
 
             os.environ["EXECUTORCH_BUILDING_WHEEL"] = "1"
 
-            # qnn sdk setup
-            _download_qnn_sdk()
-
-            sdk_path = Path(SDK_DIR).resolve()  # full absolute path
-            print("sdk_path: ", sdk_path)
-            if not sdk_path:
-                raise RuntimeError("Qualcomm SDK not found, cannot build backend")
-
-            # Determine paths
-            prj_root = Path(__file__).parent.resolve()
-            print("prj_root: ", prj_root)
-            # TODO: stop using script but add cmake configuration properly
-            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)
-            print("str(sdk_path): ", str(sdk_path))
-            env["QNN_SDK_ROOT"] = str(sdk_path)
-            subprocess.check_call([str(build_sh), "--skip_aarch64"], 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(so_dst.parent)  # ensure destination exists
-            self.copy_file(str(so_src), str(so_dst))
-            print(f"Copied Qualcomm backend: {so_src} -> {so_dst}")
-
-            # --- CLEANUP SECTION ---
-            # 1. Remove Qualcomm SDK staging folder so it doesn’t get packaged
-            if os.path.exists(SDK_DIR):
-                try:
-                    shutil.rmtree(SDK_DIR)
-                    print(f"Removed Qualcomm SDK folder: {SDK_DIR}")
-                except Exception as e:
-                    print(f"Failed to remove SDK_DIR {SDK_DIR}: {e}")
-
-            # 2. Also remove the entire packaged SDK tree
-            pkg_sdk_dir = prj_root / "backends/qualcomm/sdk"
-            if pkg_sdk_dir.exists():
-                try:
-                    shutil.rmtree(pkg_sdk_dir)
-                    print(f"Removed packaged Qualcomm SDK: {pkg_sdk_dir}")
-                except Exception as e:
-                    print(f"Failed to remove packaged SDK dir {pkg_sdk_dir}: {e}")
-
-            so_files = [
-                (
-                    "executorch.backends.qualcomm.python.PyQnnManagerAdaptor",
-                    prj_root
-                    / "backends/qualcomm/python/PyQnnManagerAdaptor.cpython-310-x86_64-linux-gnu.so",
-                ),
-                (
-                    "executorch.backends.qualcomm.python.PyQnnWrapperAdaptor",
-                    prj_root
-                    / "backends/qualcomm/python/PyQnnWrapperAdaptor.cpython-310-x86_64-linux-gnu.so",
-                ),
-            ]
-
-            for module_name, so_src in so_files:
-                so_dst = Path(self.get_ext_fullpath(module_name))
-                self.mkpath(str(so_dst.parent))
+            with tempfile.TemporaryDirectory() as tmpdir:
+                tmp_path = Path(tmpdir)
+                sdk_path = _download_qnn_sdk(dst_folder=tmp_path)
+
+                print("sdk_path: ", sdk_path)
+                if not sdk_path:
+                    raise RuntimeError("Qualcomm SDK not found, cannot build backend")
+
+                # Determine paths
+                prj_root = Path(__file__).parent.resolve()
+                print("prj_root: ", prj_root)
+                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)
+                print("str(sdk_path): ", str(sdk_path))
+                env["QNN_SDK_ROOT"] = str(sdk_path)
+                subprocess.check_call([str(build_sh), "--skip_aarch64"], 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(so_dst.parent)  # ensure destination exists
                 self.copy_file(str(so_src), str(so_dst))
                 print(f"Copied Qualcomm backend: {so_src} -> {so_dst}")
+
+                # Copy Python adaptor .so files
+                so_files = [
+                    (
+                        "executorch.backends.qualcomm.python.PyQnnManagerAdaptor",
+                        prj_root
+                        / "backends/qualcomm/python/PyQnnManagerAdaptor.cpython-310-x86_64-linux-gnu.so",
+                    ),
+                    (
+                        "executorch.backends.qualcomm.python.PyQnnWrapperAdaptor",
+                        prj_root
+                        / "backends/qualcomm/python/PyQnnWrapperAdaptor.cpython-310-x86_64-linux-gnu.so",
+                    ),
+                ]
+
+                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))
+                    print(f"Copied Qualcomm backend: {so_src} -> {so_dst}")
+
         except ImportError:
             print("Fail to build Qualcomm backend")
             print("Import error: ", sys.exc_info()[0])