Qualcomm AI Engine Direct - Support Platform Abstraction Layer (PAL) (pytorch#20050)

### Summary

This PR introduces **Platform Abstraction Layer (PAL)** support to
enable consistent, platform-independent behavior, including Linux and
Windows.

### Scope

The goal of this change is to encapsulate platform-specific logic behind
a unified interface, improving portability, maintainability, and
extensibility of the codebase.

### Supported Platforms

- Linux
- Windows

### Currently Supported Functionality

The initial PAL implementation focuses on the following capabilities:
- **Dynamic loading**
Provides a unified interface for loading shared libraries at runtime
across supported platforms.

- **Shared library name construction**
Abstracts platform-specific shared library naming conventions (e.g.,
.so, .dll) to ensure correct library resolution on each platform.

### Future Work

- Additional PAL features if required.

---------

Co-authored-by: chenweng <chenweng@qti.qualcomm.com>

Author: zhaoxul-qti

backends/qualcomm/CMakeLists.txt

@@ -119,6 +119,7 @@ endif()
 include_directories(
   BEFORE ${_common_include_directories} ${QNN_SDK_ROOT}/include/QNN
   ${EXECUTORCH_SOURCE_DIR}/runtime/core/portable_type/c10
+  ${QNN_EXECUTORCH_ROOT_DIR}/runtime/pal/include
 )
 
 set(_qnn_schema__srcs backends/qualcomm/serialization/qc_compiler_spec.fbs)
@@ -175,6 +176,7 @@ add_library(qnn_logger STATIC)
 add_library(qnn_manager STATIC)
 add_library(qnn_mem_manager STATIC)
 add_library(qnn_op_package_manager STATIC)
+add_library(qnn_pal STATIC)
 add_library(qnn_profiler STATIC)
 add_library(qnn_schema INTERFACE ${_qnn_schema__outputs})
 add_library(qnn_sys_function_interface INTERFACE)
@@ -188,11 +190,12 @@ add_library(wrappers STATIC)
 target_link_libraries(wrappers PRIVATE qnn_executorch_logging)
 target_link_libraries(
   qnn_implementation PRIVATE qnn_function_interface qnn_executorch_logging
-                             ${CMAKE_DL_LIBS}
+                             qnn_pal ${CMAKE_DL_LIBS}
 )
 target_link_libraries(
-  qnn_sys_implementation PRIVATE qnn_sys_function_interface
-                                 qnn_executorch_logging ${CMAKE_DL_LIBS}
+  qnn_sys_implementation
+  PRIVATE qnn_sys_function_interface qnn_executorch_logging qnn_pal
+          ${CMAKE_DL_LIBS}
 )
 target_link_libraries(qnn_executorch_logging PRIVATE qnn_schema)
 target_link_libraries(qnn_profiler PRIVATE qnn_executorch_logging)
@@ -243,6 +246,7 @@ target_link_libraries(
           qnn_context
           qnn_graph
           qnn_mem_manager
+          qnn_pal
 )
 
 target_link_libraries(
@@ -297,7 +301,7 @@ else()
   )
 endif()
 target_link_libraries(
-  shared_buffer PRIVATE qnn_executorch_logging ${CMAKE_DL_LIBS}
+  shared_buffer PRIVATE qnn_executorch_logging qnn_pal ${CMAKE_DL_LIBS}
 )
 #
 # add linker option

backends/qualcomm/runtime/CMakeLists.txt

@@ -47,3 +47,16 @@ target_sources(
   shared_buffer PRIVATE ${CMAKE_CURRENT_LIST_DIR}/SharedBuffer.h
                         ${CMAKE_CURRENT_LIST_DIR}/SharedBuffer.cpp
 )
+
+# qnn_pal
+if(WIN32)
+  target_sources(
+    qnn_pal PRIVATE ${CMAKE_CURRENT_LIST_DIR}/pal/src/windows/DynamicLoading.cpp
+                    ${CMAKE_CURRENT_LIST_DIR}/pal/src/windows/Path.cpp
+  )
+else()
+  target_sources(
+    qnn_pal PRIVATE ${CMAKE_CURRENT_LIST_DIR}/pal/src/linux/DynamicLoading.cpp
+                    ${CMAKE_CURRENT_LIST_DIR}/pal/src/linux/Path.cpp
+  )
+endif()

backends/qualcomm/runtime/SharedBuffer.cpp

@@ -5,10 +5,11 @@
  * This source code is licensed under the BSD-style license found in the
  * LICENSE file in the root directory of this source tree.
  */
-#include <dlfcn.h>
 #include <executorch/backends/qualcomm/runtime/Logging.h>
 #include <executorch/backends/qualcomm/runtime/SharedBuffer.h>
 
+#include <pal/DynamicLoading.h>
+
 // Refer to the QNN HTP Shared Buffer Tutorial
 // in Qualcomm® AI Engine Direct document
 constexpr uint8_t RPCMEM_HEAP_ID_SYSTEM = 25;
@@ -81,10 +82,10 @@ SharedBuffer& SharedBuffer::GetSharedBufferManager() {
   std::lock_guard<std::mutex> lk(init_mutex_);
   static SharedBuffer shared_buffer_manager;
   if (!shared_buffer_manager.GetInitialize()) {
-#if defined(__aarch64__)
+#if defined(__ANDROID__)
     Error status = shared_buffer_manager.Load();
 #else
-    // For x86_64 platform
+    // libcdsprpc.so is an Android vendor library; skip on all other platforms.
     Error status = Error::Ok;
 #endif
     if (status == Error::Ok) {
@@ -95,7 +96,7 @@ SharedBuffer& SharedBuffer::GetSharedBufferManager() {
 }
 
 SharedBuffer::~SharedBuffer() {
-#if defined(__aarch64__)
+#if defined(__ANDROID__)
   if (initialize_) {
     SharedBuffer::GetSharedBufferManager().UnLoad();
   }
@@ -163,23 +164,27 @@ bool SharedBuffer::IsAllocated(void* buf) {
 Error SharedBuffer::Load() {
   // On Android, 32-bit and 64-bit libcdsprpc.so can be found at /vendor/lib/
   // and /vendor/lib64/ respectively.
-  lib_cdsp_rpc_ = dlopen("libcdsprpc.so", RTLD_NOW | RTLD_LOCAL);
+  lib_cdsp_rpc_ = pal::dynamic_loading::DlOpen(
+      "libcdsprpc.so",
+      pal::dynamic_loading::DL_NOW | pal::dynamic_loading::DL_LOCAL);
   if (lib_cdsp_rpc_ == nullptr) {
     QNN_EXECUTORCH_LOG_ERROR(
-        "Unable to load shared buffer. dlerror(): %s", dlerror());
+        "Unable to load shared buffer. dlerror(): %s",
+        pal::dynamic_loading::DlError());
     return Error::Internal;
   }
   rpc_mem_alloc_ = reinterpret_cast<RpcMemAllocFn_t>( // NOLINT
-      dlsym(lib_cdsp_rpc_, "rpcmem_alloc"));
+      pal::dynamic_loading::DlSym(lib_cdsp_rpc_, "rpcmem_alloc"));
   rpc_mem_free_ = reinterpret_cast<RpcMemFreeFn_t>( // NOLINT
-      dlsym(lib_cdsp_rpc_, "rpcmem_free"));
+      pal::dynamic_loading::DlSym(lib_cdsp_rpc_, "rpcmem_free"));
   rpc_mem_to_fd_ = reinterpret_cast<RpcMemToFdFn_t>( // NOLINT
-      dlsym(lib_cdsp_rpc_, "rpcmem_to_fd"));
+      pal::dynamic_loading::DlSym(lib_cdsp_rpc_, "rpcmem_to_fd"));
   if (nullptr == rpc_mem_alloc_ || nullptr == rpc_mem_free_ ||
       nullptr == rpc_mem_to_fd_) {
     QNN_EXECUTORCH_LOG_ERROR(
-        "Unable to access symbols in shared buffer. dlerror(): %s", dlerror());
-    dlclose(lib_cdsp_rpc_);
+        "Unable to access symbols in shared buffer. dlerror(): %s",
+        pal::dynamic_loading::DlError());
+    pal::dynamic_loading::DlClose(lib_cdsp_rpc_);
     return Error::Internal;
   }
   return Error::Ok;
@@ -199,9 +204,10 @@ void SharedBuffer::AddCusomMemTensorAddr(void* tensor_addr, void* custom_mem) {
 };
 
 Error SharedBuffer::UnLoad() {
-  if (dlclose(lib_cdsp_rpc_) != 0) {
+  if (pal::dynamic_loading::DlClose(lib_cdsp_rpc_) != 0) {
     QNN_EXECUTORCH_LOG_ERROR(
-        "Unable to close shared buffer. dlerror(): %s", dlerror());
+        "Unable to close shared buffer. dlerror(): %s",
+        pal::dynamic_loading::DlError());
     return Error::Internal;
   };
   return Error::Ok;

backends/qualcomm/runtime/backends/QnnBackendUnifiedRegistry.h

@@ -15,6 +15,8 @@
 #include <executorch/backends/qualcomm/runtime/backends/QnnSysImplementation.h>
 #include <executorch/runtime/core/error.h>
 
+#include <pal/Path.h>
+
 #include <memory>
 #include <mutex>
 #include <string>
@@ -79,12 +81,16 @@ class QnnBackendUnifiedRegistry {
   // For macro, refer to executorch/backends/qualcomm/CMakeLists.txt
   static constexpr const char* htp_library_name_ = HEXAGON_LIB;
 #else
-  static constexpr const char* htp_library_name_ = "libQnnHtp.so";
+  static inline const std::string htp_library_name_ =
+      pal::path::GetLibraryName("QnnHtp");
 #endif
-  static constexpr const char* gpu_library_name_ = "libQnnGpu.so";
-  static constexpr const char* dsp_library_name_ = "libQnnDsp.so";
+  static inline const std::string gpu_library_name_ =
+      pal::path::GetLibraryName("QnnGpu");
+  static inline const std::string dsp_library_name_ =
+      pal::path::GetLibraryName("QnnDsp");
   // Lpai library name is same for both traditional build and hexagon build.
-  static constexpr const char* lpai_library_name_ = "libQnnLpai.so";
+  static inline const std::string lpai_library_name_ =
+      pal::path::GetLibraryName("QnnLpai");
 
   std::unique_ptr<const QnnSaver_Config_t*[]> GetImplementationConfig(
       const QnnExecuTorchOptions* options) {

backends/qualcomm/runtime/backends/QnnDlcManager.h

@@ -14,6 +14,8 @@
 #include <executorch/backends/qualcomm/runtime/backends/QnnBackendUnifiedRegistry.h>
 #include <executorch/backends/qualcomm/runtime/backends/ir/IrContext.h>
 
+#include <pal/Path.h>
+
 namespace executorch {
 namespace backends {
 namespace qnn {
@@ -105,7 +107,8 @@ class QnnDlcManager {
   }
 
  private:
-  static constexpr const char* library_name_ = "libQnnIr.so";
+  static inline const std::string library_name_ =
+      pal::path::GetLibraryName("QnnIr");
 
   const QnnExecuTorchContextBinary& qnn_context_blob_;
   const QnnExecuTorchOptions* options_;

backends/qualcomm/runtime/backends/QnnImplementation.cpp

@@ -22,7 +22,7 @@ struct DlCloser {
   int operator()(void* handle) {
     if (handle == nullptr)
       return 0;
-    return dlclose(handle);
+    return pal::dynamic_loading::DlClose(handle);
   }
 };
 
@@ -59,22 +59,26 @@ const QnnInterface_t* QnnImplementation::StartBackend(
 
 #ifdef __hexagon__
   FARF(RUNTIME_HIGH, "Opening lib_path %s", lib_path.c_str());
-  std::unique_ptr<void, DlCloser> lib_handle(
-      dlopen(lib_path.c_str(), RTLD_NOW | RTLD_GLOBAL));
+  std::unique_ptr<void, DlCloser> lib_handle(pal::dynamic_loading::DlOpen(
+      lib_path.c_str(),
+      pal::dynamic_loading::DL_NOW | pal::dynamic_loading::DL_GLOBAL));
   FARF(RUNTIME_HIGH, "Done loading lib_path %s", lib_path.c_str());
 #else
   // If the library is already loaded, return the handle.
-  std::unique_ptr<void, DlCloser> lib_handle(
-      dlopen(lib_path.c_str(), RTLD_NOW | RTLD_NOLOAD | RTLD_GLOBAL));
+  std::unique_ptr<void, DlCloser> lib_handle(pal::dynamic_loading::DlOpen(
+      lib_path.c_str(),
+      pal::dynamic_loading::DL_NOW | pal::dynamic_loading::DL_NOLOAD |
+          pal::dynamic_loading::DL_GLOBAL));
   if (!lib_handle) {
-    lib_handle = std::unique_ptr<void, DlCloser>(
-        dlopen(lib_path.c_str(), RTLD_NOW | RTLD_GLOBAL));
+    lib_handle = std::unique_ptr<void, DlCloser>(pal::dynamic_loading::DlOpen(
+        lib_path.c_str(),
+        pal::dynamic_loading::DL_NOW | pal::dynamic_loading::DL_GLOBAL));
   }
   if (lib_handle == nullptr) {
     QNN_EXECUTORCH_LOG_ERROR(
         "Cannot Open QNN library %s, with error: %s",
         lib_path.c_str(),
-        dlerror());
+        pal::dynamic_loading::DlError());
     return nullptr;
   }
 #endif
@@ -87,7 +91,7 @@ const QnnInterface_t* QnnImplementation::StartBackend(
     QNN_EXECUTORCH_LOG_ERROR(
         "QnnImplementation::Load Cannot load symbol "
         "QnnInterface_getProviders : %s",
-        dlerror());
+        pal::dynamic_loading::DlError());
     return nullptr;
   }
 
@@ -131,12 +135,12 @@ Error QnnImplementation::Unload() {
     return Error::Ok;
   }
 
-  int dlclose_error = dlclose(lib_handle_);
+  int dlclose_error = pal::dynamic_loading::DlClose(lib_handle_);
   if (dlclose_error != 0) {
     QNN_EXECUTORCH_LOG_ERROR(
         "Fail to close QNN backend %s with error %s",
         lib_path_.c_str(),
-        dlerror());
+        pal::dynamic_loading::DlError());
     return Error::Internal;
   }
   lib_handle_ = nullptr;

backends/qualcomm/runtime/backends/QnnImplementation.h

@@ -10,15 +10,17 @@
 #include <executorch/backends/qualcomm/runtime/Logging.h>
 #include <executorch/backends/qualcomm/runtime/backends/QnnFunctionInterface.h>
 
-#include <dlfcn.h>
+#include <pal/DynamicLoading.h>
+
 #include <string>
 namespace executorch {
 namespace backends {
 namespace qnn {
 
 template <typename Fn>
 Fn loadQnnFunction(void* handle, const char* function_name) {
-  return reinterpret_cast<Fn>(dlsym(handle, function_name)); // NOLINT
+  return reinterpret_cast<Fn>( // NOLINT
+      pal::dynamic_loading::DlSym(handle, function_name));
 }
 
 class QnnImplementation {

backends/qualcomm/runtime/backends/QnnSysImplementation.cpp

@@ -6,8 +6,8 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#include <dlfcn.h>
 #include <executorch/backends/qualcomm/runtime/backends/QnnSysImplementation.h>
+#include <pal/DynamicLoading.h>
 namespace executorch {
 namespace backends {
 namespace qnn {
@@ -16,24 +16,27 @@ using executorch::runtime::Error;
 
 Error QnnSystemImplementation::Load() {
   Qnn_ErrorHandle_t error = QNN_SUCCESS;
-  void* lib_handle_ = dlopen(lib_path_.c_str(), RTLD_NOW | RTLD_LOCAL);
+  lib_handle_ = pal::dynamic_loading::DlOpen(
+      lib_path_.c_str(),
+      pal::dynamic_loading::DL_NOW | pal::dynamic_loading::DL_LOCAL);
   if (lib_handle_ == nullptr) {
     QNN_EXECUTORCH_LOG_ERROR(
         "Cannot Open QNN library %s, with error: %s",
         lib_path_.c_str(),
-        dlerror());
+        pal::dynamic_loading::DlError());
     return Error::Internal;
   }
 
   auto* get_providers =
       // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
       reinterpret_cast<QnnSystemInterfaceGetProvidersFn*>(
-          dlsym(lib_handle_, "QnnSystemInterface_getProviders"));
+          pal::dynamic_loading::DlSym(
+              lib_handle_, "QnnSystemInterface_getProviders"));
   if (get_providers == nullptr) {
     QNN_EXECUTORCH_LOG_ERROR(
         "QnnSystemImplementation::Load Cannot load symbol "
         "QnnSystemInterface_getProviders : %s",
-        dlerror());
+        pal::dynamic_loading::DlError());
     return Error::Internal;
   }
 
@@ -65,10 +68,11 @@ Error QnnSystemImplementation::Unload() {
   if (lib_handle_ == nullptr)
     return Error::Ok;
 
-  int dlclose_error = dlclose(lib_handle_);
+  int dlclose_error = pal::dynamic_loading::DlClose(lib_handle_);
   if (dlclose_error != 0) {
     QNN_EXECUTORCH_LOG_WARN(
-        "Failed to close QnnSystem library with error %s", dlerror());
+        "Failed to close QnnSystem library with error %s",
+        pal::dynamic_loading::DlError());
     return Error::Internal;
   }
 

backends/qualcomm/runtime/backends/ir/target/QnnDlcManager.cpp

@@ -6,10 +6,12 @@
  * LICENSE file in the root directory of this source tree.
  */
 #include <executorch/backends/qualcomm/runtime/backends/QnnDlcManager.h>
+#ifndef _WIN32
 #include <fcntl.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <unistd.h>
+#endif
 #include <fstream>
 
 namespace executorch {