Pull generic dynamic loading utils into core api. This will need to be reused for loading plugin .so from driver.

PiperOrigin-RevId: 682739754

Author: LukeBoyer

tensorflow/lite/experimental/lrt/core/BUILD

@@ -122,6 +122,14 @@ cc_library(
     ],
 )
 
+cc_library(
+    name = "dynamic_loading",
+    srcs = ["dynamic_loading.cc"],
+    hdrs = ["dynamic_loading.h"],
+    linkopts = ["-ldl"],
+    deps = ["@com_google_absl//absl/strings:string_view"],
+)
+
 cc_library(
     name = "tensor_buffer",
     srcs = [

tensorflow/lite/experimental/lrt/qnn_sdk/load_sdk.cc renamed to tensorflow/lite/experimental/lrt/core/dynamic_loading.cc

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "tensorflow/lite/experimental/lrt/qnn_sdk/load_sdk.h"
+#include "tensorflow/lite/experimental/lrt/core/dynamic_loading.h"
 
 #include <dlfcn.h>
 #include <link.h>
@@ -22,29 +22,39 @@
 
 #include "absl/strings/string_view.h"
 
-namespace qnn::load {
+namespace lrt {
 
-void DumpDlInfo(void* handle) {
-  std::cerr << "--- Dyn Load Info ---\n";
+void* OpenLib(absl::string_view so_path) {
+  void* lib_handle =
+      ::dlopen(so_path.data(), RTLD_NOW | RTLD_LOCAL | RTLD_DEEPBIND);
+  if (lib_handle == nullptr) {
+    std::cerr << "Failed to load so at path: " << so_path
+              << " with err: " << ::dlerror() << "\n";
+  }
+  return lib_handle;
+}
+
+void DumpLibInfo(void* lib_handle) {
+  std::cerr << "--- Lib Info ---\n";
 
   Lmid_t dl_ns_idx;
-  if (0 != ::dlinfo(handle, RTLD_DI_LMID, &dl_ns_idx)) {
+  if (0 != ::dlinfo(lib_handle, RTLD_DI_LMID, &dl_ns_idx)) {
     return;
   }
 
   std::string dl_origin;
   dl_origin.resize(512);
-  if (0 != ::dlinfo(handle, RTLD_DI_ORIGIN, dl_origin.data())) {
+  if (0 != ::dlinfo(lib_handle, RTLD_DI_ORIGIN, dl_origin.data())) {
     return;
   }
 
   link_map* lm;
-  if (0 != ::dlinfo(handle, RTLD_DI_LINKMAP, &lm)) {
+  if (0 != ::dlinfo(lib_handle, RTLD_DI_LINKMAP, &lm)) {
     return;
   }
 
-  std::cerr << "DL namespace: " << dl_ns_idx << "\n";
-  std::cerr << "DL origin: " << dl_origin << "\n";
+  std::cerr << "Lib Namespace: " << dl_ns_idx << "\n";
+  std::cerr << "Lib Origin: " << dl_origin << "\n";
 
   std::cerr << "loaded objects:\n";
 
@@ -56,23 +66,12 @@ void DumpDlInfo(void* handle) {
     forward = forward->l_next;
   }
 
-  std::cerr << "*** " << lm->l_name << "\n";
+  std::cerr << "***" << lm->l_name << "\n";
 
   while (backward != nullptr) {
     std::cerr << "  " << backward->l_name << "\n";
     backward = backward->l_prev;
   }
 }
 
-void* LoadSO(absl::string_view so_path) {
-  // TODO: Figure out why deepbind is actually needed (sigsegv w/o).
-  void* lib_handle =
-      ::dlopen(so_path.data(), RTLD_NOW | RTLD_LOCAL | RTLD_DEEPBIND);
-  if (lib_handle == nullptr) {
-    std::cerr << "Failed to load so at path: " << so_path
-              << " with err: " << ::dlerror() << "\n";
-  }
-  return lib_handle;
-}
-
-}  // namespace qnn::load
+}  // namespace lrt

tensorflow/lite/experimental/lrt/core/dynamic_loading.h

@@ -0,0 +1,49 @@
+// Copyright 2024 Google LLC.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef TENSORFLOW_LITE_EXPERIMENTAL_LRT_CORE_DYNAMIC_LOADING_H_
+#define TENSORFLOW_LITE_EXPERIMENTAL_LRT_CORE_DYNAMIC_LOADING_H_
+
+#include <dlfcn.h>
+#include <stdlib.h>
+
+#include <iostream>
+
+#include "absl/strings/string_view.h"
+
+namespace lrt {
+
+// Loads shared library at given path, returning handle on success
+// and nullptr on failure.
+void* OpenLib(absl::string_view so_path);
+
+// Dumps loading details of given lib handle.
+void DumpLibInfo(void* lib_handle);
+
+// Resolves a named symbol from given lib handle of type Sym. Returns
+// nullptr on failure.
+template <class Sym>
+inline static Sym ResolveLibSymbol(void* lib_handle,
+                                   absl::string_view sym_name) {
+  Sym ptr = (Sym)::dlsym(lib_handle, sym_name.data());
+  if (ptr == nullptr) {
+    std::cerr << "Failed to resolve symbol: " << sym_name << " with err "
+              << ::dlerror() << "\n";
+  }
+  return ptr;
+}
+
+}  // namespace lrt
+
+#endif  // TENSORFLOW_LITE_EXPERIMENTAL_LRT_CORE_DYNAMIC_LOADING_H_

tensorflow/lite/experimental/lrt/qnn_sdk/BUILD

@@ -19,16 +19,6 @@ package(
     default_visibility = ["//tensorflow/lite/experimental/lrt:__subpackages__"],
 )
 
-ungrte_cc_library_with_qnn(
-    name = "load_sdk",
-    srcs = ["load_sdk.cc"],
-    hdrs = ["load_sdk.h"],
-    deps = [
-        "@com_google_absl//absl/strings:string_view",
-        # copybara:uncomment "//third_party/qairt:qnn_lib_headers",
-    ],
-)
-
 ungrte_cc_library_with_qnn(
     name = "log",
     srcs = ["log.cc"],
@@ -43,12 +33,12 @@ ungrte_cc_library_with_qnn(
     srcs = ["qnn_manager.cc"],
     hdrs = ["qnn_manager.h"],
     deps = [
-        ":load_sdk",
         ":log",
         "@com_google_absl//absl/strings:string_view",
         "@com_google_absl//absl/types:span",
         # copybara:uncomment "//third_party/qairt:qnn_lib_headers",
         "//tensorflow/lite/experimental/lrt/core:api_internal",
+        "//tensorflow/lite/experimental/lrt/core:dynamic_loading",
     ],
 )
 

tensorflow/lite/experimental/lrt/qnn_sdk/load_sdk.h

@@ -25,19 +25,25 @@
 #include "third_party/qairt/include/QNN/QnnTypes.h"
 #include "tensorflow/lite/experimental/lrt/c/lite_rt_common.h"
 #include "tensorflow/lite/experimental/lrt/cc/lite_rt_support.h"
-#include "tensorflow/lite/experimental/lrt/qnn_sdk/load_sdk.h"
+#include "tensorflow/lite/experimental/lrt/core/dynamic_loading.h"
 #include "tensorflow/lite/experimental/lrt/qnn_sdk/log.h"
 
-using ::qnn::load::QnnInterfaceGetProvidersFn_t;
-
 namespace qnn {
 
 namespace {
 
+// This is one of two qnns symbol that needs resolution. It is used to populate
+// pointers to related available qnn functions.
+constexpr char kLibQnnGetProvidersSymbol[] = "QnnInterface_getProviders";
+
+// Type definition for the QnnInterface_getProviders symbol.
+typedef Qnn_ErrorHandle_t (*QnnInterfaceGetProvidersFn_t)(
+    const QnnInterface_t*** provider_list, uint32_t* num_providers);
+
 absl::Span<const QnnInterface_t*> LoadProvidersFromLib(void* lib_so) {
-  load::QnnInterfaceGetProvidersFn_t get_providers = nullptr;
-  get_providers = load::ResolveQnnSymbol<QnnInterfaceGetProvidersFn_t>(
-      lib_so, load::kLibQnnGetProvidersSymbol);
+  QnnInterfaceGetProvidersFn_t get_providers = nullptr;
+  get_providers = lrt::ResolveLibSymbol<QnnInterfaceGetProvidersFn_t>(
+      lib_so, kLibQnnGetProvidersSymbol);
   if (get_providers == nullptr) {
     std::cerr << "Failed to resolve get providers symbol\n";
     return {};
@@ -56,7 +62,7 @@ absl::Span<const QnnInterface_t*> LoadProvidersFromLib(void* lib_so) {
 }  // namespace
 
 LrtStatus QnnManager::LoadLibSO(absl::string_view path) {
-  lib_so_ = load::LoadSO(path);
+  lib_so_ = lrt::OpenLib(path);
   if (lib_so_ == nullptr) {
     return kLrtStatusDynamicLoadErr;
   }
@@ -67,7 +73,7 @@ void QnnManager::DumpLibSODetails() const {
   if (lib_so_ == nullptr) {
     return;
   }
-  load::DumpDlInfo(lib_so_);
+  lrt::DumpLibInfo(lib_so_);
 }
 
 // TODO: Repace QnnManager::Funcs with indirection access operator.