Cleanup

* Make dyn loading wrapper return lrt status
* Use lrt logging instead of cerr
* Remove need for LogSeverity:: prefix
* Unify names in QnnManager

PiperOrigin-RevId: 682997204

Author: LukeBoyer

tensorflow/lite/experimental/lrt/core/BUILD

@@ -128,6 +128,7 @@ cc_library(
     hdrs = ["dynamic_loading.h"],
     linkopts = ["-ldl"],
     deps = [
+        ":logging",
         "//tensorflow/lite/experimental/lrt/c:lite_rt_c_api",
         "@com_google_absl//absl/strings:string_view",
     ],
@@ -220,8 +221,5 @@ cc_library(
     hdrs = [
         "logging.h",
     ],
-    deps = [
-        "//tensorflow/lite:minimal_logging",
-        "//tensorflow/lite/core:framework_stable",
-    ],
+    deps = ["//tensorflow/lite:minimal_logging"],
 )

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

@@ -18,24 +18,31 @@
 #include <link.h>
 
 #include <iostream>
+#include <sstream>
 #include <string>
 
 #include "absl/strings/string_view.h"
+#include "tensorflow/lite/experimental/lrt/c/lite_rt_common.h"
+#include "tensorflow/lite/experimental/lrt/core/logging.h"
 
 namespace lrt {
 
-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";
+// TODO make this return a status and have handle be output param.
+LrtStatus OpenLib(absl::string_view so_path, void** lib_handle) {
+  void* res = ::dlopen(so_path.data(), RTLD_NOW | RTLD_LOCAL | RTLD_DEEPBIND);
+  if (res == nullptr) {
+    LITE_RT_LOG(ERROR, "Failed to load .so at path: %s, with error: %s",
+                so_path, ::dlerror());
+
+    return kLrtStatusDynamicLoadErr;
   }
-  return lib_handle;
+  *lib_handle = res;
+  return kLrtStatusOk;
 }
 
 void DumpLibInfo(void* lib_handle) {
-  std::cerr << "--- Lib Info ---\n";
+  std::stringstream dump;
+  dump << "--- Lib Info ---\n";
 
   Lmid_t dl_ns_idx;
   if (0 != ::dlinfo(lib_handle, RTLD_DI_LMID, &dl_ns_idx)) {
@@ -53,25 +60,27 @@ void DumpLibInfo(void* lib_handle) {
     return;
   }
 
-  std::cerr << "Lib Namespace: " << dl_ns_idx << "\n";
-  std::cerr << "Lib Origin: " << dl_origin << "\n";
+  dump << "Lib Namespace: " << dl_ns_idx << "\n";
+  dump << "Lib Origin: " << dl_origin << "\n";
 
-  std::cerr << "loaded objects:\n";
+  dump << "loaded objects:\n";
 
   auto* forward = lm->l_next;
   auto* backward = lm->l_prev;
 
   while (forward != nullptr) {
-    std::cerr << "  " << forward->l_name << "\n";
+    dump << "  " << forward->l_name << "\n";
     forward = forward->l_next;
   }
 
-  std::cerr << "***" << lm->l_name << "\n";
+  dump << "***" << lm->l_name << "\n";
 
   while (backward != nullptr) {
-    std::cerr << "  " << backward->l_name << "\n";
+    dump << "  " << backward->l_name << "\n";
     backward = backward->l_prev;
   }
+
+  LITE_RT_LOG(INFO, "%s", dump.str().c_str());
 }
 
 }  // namespace lrt

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

@@ -18,30 +18,31 @@
 #include <dlfcn.h>
 #include <stdlib.h>
 
-#include <iostream>
-
 #include "absl/strings/string_view.h"
+#include "tensorflow/lite/experimental/lrt/c/lite_rt_common.h"
+#include "tensorflow/lite/experimental/lrt/core/logging.h"
 
 namespace lrt {
 
-// Loads shared library at given path, returning handle on success
-// and nullptr on failure.
-void* OpenLib(absl::string_view so_path);
+// Loads shared library at given path.
+LrtStatus OpenLib(absl::string_view so_path, void** lib_handle);
 
 // 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.
+// Resolves a named symbol from given lib handle of type Sym.
 template <class Sym>
-inline static Sym ResolveLibSymbol(void* lib_handle,
-                                   absl::string_view sym_name) {
+inline static LrtStatus ResolveLibSymbol(void* lib_handle,
+                                         absl::string_view sym_name,
+                                         Sym* sym_handle) {
   Sym ptr = (Sym)::dlsym(lib_handle, sym_name.data());
   if (ptr == nullptr) {
-    std::cerr << "Failed to resolve symbol: " << sym_name << " with err "
-              << ::dlerror() << "\n";
+    LITE_RT_LOG(ERROR, "Faild to resolve symbol: %s, with err: %s\n", sym_name,
+                ::dlerror());
+    return kLrtStatusDynamicLoadErr;
   }
-  return ptr;
+  *sym_handle = ptr;
+  return kLrtStatusOk;
 }
 
 }  // namespace lrt

tensorflow/lite/experimental/lrt/core/lite_rt_event.cc

@@ -26,8 +26,6 @@
 #include "tensorflow/lite/experimental/lrt/c/lite_rt_common.h"
 #include "tensorflow/lite/experimental/lrt/core/logging.h"
 
-using lrt::internal::LogSeverity;
-
 struct LrtEventT {
 #if LRT_HAS_SYNC_FENCE_SUPPORT
   int fd;
@@ -63,22 +61,20 @@ LrtStatus LrtEventWait(LrtEvent event, int64_t timeout_in_ms) {
     if (ret == 1) {
       break;
     } else if (ret == 0) {
-      LITE_RT_LOG(LogSeverity::WARNING, "Timeout expired: %d", timeout_in_ms);
+      LITE_RT_LOG(WARNING, "Timeout expired: %d", timeout_in_ms);
       return kLrtStatusErrorTimeoutExpired;
     }
   } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
 
   if (ret < 0) {
-    LITE_RT_LOG(LogSeverity::ERROR, "Error waiting for fence: %s",
-                ::strerror(errno));
+    LITE_RT_LOG(ERROR, "Error waiting for fence: %s", ::strerror(errno));
     return kLrtStatusErrorRuntimeFailure;
   }
 
   return kLrtStatusOk;
 
 #else
-  LITE_RT_LOG(LogSeverity::ERROR,
-              "LrtEventWait not implemented for this platform");
+  LITE_RT_LOG(ERROR, "LrtEventWait not implemented for this platform");
   return kLrtStatusErrorUnsupported;
 #endif
 }
@@ -97,8 +93,7 @@ LrtStatus LrtEventDestroy(LrtEvent event) {
   delete event;
   return kLrtStatusOk;
 #else
-  LITE_RT_LOG(LogSeverity::ERROR,
-              "LrtEventDestroy not implemented for this platform");
+  LITE_RT_LOG(ERROR, "LrtEventDestroy not implemented for this platform");
   return kLrtStatusErrorUnsupported;
 #endif
 }

tensorflow/lite/experimental/lrt/core/lite_rt_tensor_buffer.cc

@@ -26,8 +26,6 @@
 #include "tensorflow/lite/experimental/lrt/core/logging.h"
 #include "tensorflow/lite/experimental/lrt/core/tensor_buffer.h"
 
-using lrt::internal::LogSeverity;
-
 LrtStatus LrtCreateTensorBufferFromHostMemory(
     LrtRankedTensorType tensor_type, void* host_buffer_addr, size_t size,
     LrtHostMemoryDeallocator deallocator, LrtTensorBuffer* buffer) {
@@ -36,7 +34,7 @@ LrtStatus LrtCreateTensorBufferFromHostMemory(
       absl::MakeSpan(static_cast<uint8_t*>(host_buffer_addr), size),
       deallocator);
   if (!tensor_buffer.ok()) {
-    LITE_RT_LOG(LogSeverity::ERROR, "%s", tensor_buffer.status().message());
+    LITE_RT_LOG(ERROR, "%s", tensor_buffer.status().message());
     return kLrtStatusErrorRuntimeFailure;
   }
   *buffer = tensor_buffer->release();
@@ -55,7 +53,7 @@ LrtStatus LrtCreateTensorBufferFromAhwb(LrtRankedTensorType tensor_type,
   auto tensor_buffer = LrtTensorBufferT::CreateFromAhwb(
       tensor_type, ahwb, ahwb_offset, deallocator);
   if (!tensor_buffer.ok()) {
-    LITE_RT_LOG(LogSeverity::ERROR, "%s", tensor_buffer.status().message());
+    LITE_RT_LOG(ERROR, "%s", tensor_buffer.status().message());
     return kLrtStatusErrorRuntimeFailure;
   }
   *buffer = tensor_buffer->release();
@@ -70,7 +68,7 @@ LrtStatus LrtGetTensorBufferAhwb(LrtTensorBuffer buffer,
 
   auto ahwb_buffer = buffer->GetAhwbBuffer();
   if (!ahwb_buffer.ok()) {
-    LITE_RT_LOG(LogSeverity::ERROR, "%s", ahwb_buffer.status().message());
+    LITE_RT_LOG(ERROR, "%s", ahwb_buffer.status().message());
     return kLrtStatusErrorRuntimeFailure;
   }
 
@@ -91,7 +89,7 @@ LrtStatus LrtCreateTensorBufferFromIonBuffer(
       tensor_type, ion_buffer_addr, ion_buffer_fd, ion_buffer_size,
       ion_buffer_offset, deallocator);
   if (!tensor_buffer.ok()) {
-    LITE_RT_LOG(LogSeverity::ERROR, "%s", tensor_buffer.status().message());
+    LITE_RT_LOG(ERROR, "%s", tensor_buffer.status().message());
     return kLrtStatusErrorRuntimeFailure;
   }
   *buffer = tensor_buffer->release();
@@ -107,7 +105,7 @@ LrtStatus LrtGetTensorBufferIonBuffer(LrtTensorBuffer buffer,
 
   auto ion_buffer = buffer->GetIonBuffer();
   if (!ion_buffer.ok()) {
-    LITE_RT_LOG(LogSeverity::ERROR, "%s", ion_buffer.status().message());
+    LITE_RT_LOG(ERROR, "%s", ion_buffer.status().message());
     return kLrtStatusErrorRuntimeFailure;
   }
 
@@ -130,7 +128,7 @@ LrtStatus LrtCreateTensorBufferFromDmaBufBuffer(
       tensor_type, dmabuf_buffer_addr, dmabuf_buffer_fd, dmabuf_buffer_size,
       dmabuf_buffer_offset, deallocator);
   if (!tensor_buffer.ok()) {
-    LITE_RT_LOG(LogSeverity::ERROR, "%s", tensor_buffer.status().message());
+    LITE_RT_LOG(ERROR, "%s", tensor_buffer.status().message());
     return kLrtStatusErrorRuntimeFailure;
   }
   *buffer = tensor_buffer->release();
@@ -146,7 +144,7 @@ LrtStatus LrtGetTensorBufferDmaBufBuffer(LrtTensorBuffer buffer,
 
   auto dmabuf_buffer = buffer->GetDmaBufBuffer();
   if (!dmabuf_buffer.ok()) {
-    LITE_RT_LOG(LogSeverity::ERROR, "%s", dmabuf_buffer.status().message());
+    LITE_RT_LOG(ERROR, "%s", dmabuf_buffer.status().message());
     return kLrtStatusErrorRuntimeFailure;
   }
 
@@ -169,7 +167,7 @@ LrtStatus LrtCreateTensorBufferFromFastRpcBuffer(
       tensor_type, fastrpc_buffer_addr, fastrpc_buffer_fd, fastrpc_buffer_size,
       fastrpc_buffer_offset, deallocator);
   if (!tensor_buffer.ok()) {
-    LITE_RT_LOG(LogSeverity::ERROR, "%s", tensor_buffer.status().message());
+    LITE_RT_LOG(ERROR, "%s", tensor_buffer.status().message());
     return kLrtStatusErrorRuntimeFailure;
   }
   *buffer = tensor_buffer->release();
@@ -185,7 +183,7 @@ LrtStatus LrtGetTensorBufferFastRpcBuffer(LrtTensorBuffer buffer,
 
   auto fastrpc_buffer = buffer->GetFastRpcBuffer();
   if (!fastrpc_buffer.ok()) {
-    LITE_RT_LOG(LogSeverity::ERROR, "%s", fastrpc_buffer.status().message());
+    LITE_RT_LOG(ERROR, "%s", fastrpc_buffer.status().message());
     return kLrtStatusErrorRuntimeFailure;
   }
 
@@ -202,7 +200,7 @@ LrtStatus LrtCreateManagedTensorBuffer(LrtTensorBufferType buffer_type,
   auto tensor_buffer =
       LrtTensorBufferT::CreateManaged(buffer_type, tensor_type, buffer_size);
   if (!tensor_buffer.ok()) {
-    LITE_RT_LOG(LogSeverity::ERROR, "%s", tensor_buffer.status().message());
+    LITE_RT_LOG(ERROR, "%s", tensor_buffer.status().message());
     return kLrtStatusErrorRuntimeFailure;
   }
   *buffer = tensor_buffer->release();
@@ -252,7 +250,7 @@ LrtStatus LrtGetTensorBufferHostMemory(LrtTensorBuffer buffer,
 
   auto host_buffer = buffer->GetHostBuffer();
   if (!host_buffer.ok()) {
-    LITE_RT_LOG(LogSeverity::ERROR, "%s", host_buffer.status().message());
+    LITE_RT_LOG(ERROR, "%s", host_buffer.status().message());
     return kLrtStatusErrorRuntimeFailure;
   }
 
@@ -268,7 +266,7 @@ LrtStatus LrtLockTensorBuffer(LrtTensorBuffer buffer, void** host_mem_addr,
 
   auto mapped_addr = buffer->Lock(event);
   if (!mapped_addr.ok()) {
-    LITE_RT_LOG(LogSeverity::ERROR, "%s", mapped_addr.status().message());
+    LITE_RT_LOG(ERROR, "%s", mapped_addr.status().message());
     return kLrtStatusErrorRuntimeFailure;
   }
 
@@ -282,7 +280,7 @@ LrtStatus LrtUnlockTensorBuffer(LrtTensorBuffer buffer) {
   }
 
   if (auto status = buffer->Unlock(); !status.ok()) {
-    LITE_RT_LOG(LogSeverity::ERROR, "%s", status.message());
+    LITE_RT_LOG(ERROR, "%s", status.message());
     return kLrtStatusErrorRuntimeFailure;
   }
 

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

@@ -21,13 +21,19 @@ namespace lrt {
 namespace internal {
 
 enum class LogSeverity {
-  VERBOSE = 0,
-  INFO = 1,
-  WARNING = 2,
-  ERROR = 3,
-  SILENT = 4
+  kVerbose = 0,
+  kInfo = 1,
+  kWarning = 2,
+  kError = 3,
+  kSilent = 4
 };
 
+#define VERBOSE ::lrt::internal::LogSeverity::kVerbose
+#define INFO ::lrt::internal::LogSeverity::kInfo
+#define WARNING ::lrt::internal::LogSeverity::kWarning
+#define ERROR ::lrt::internal::LogSeverity::kError
+#define SILENT ::lrt::internal::LogSeverity::kSilent
+
 class Logger {
  public:
   static void Log(LogSeverity severity, const char* format, ...);

tensorflow/lite/experimental/lrt/qnn/qnn_compose_graph.cc

@@ -182,7 +182,7 @@ LrtStatus GraphMapper::LegalizeAndRegister(LrtTensor lrt_tensor,
   LRT_RETURN_STATUS_IF_NOT_OK(LegalizeTensor(lrt_tensor, qnn_tensor));
   LRT_RETURN_STATUS_IF_NOT_OK(AssignName(qnn_tensor));
   LRT_RETURN_STATUS_IF_QNN_NOT_OK(
-      Qnn().API()->tensorCreateGraphTensor(QnnGraph(), &qnn_tensor));
+      Qnn().Api()->tensorCreateGraphTensor(QnnGraph(), &qnn_tensor));
 
   return kLrtStatusOk;
 }
@@ -221,14 +221,14 @@ LrtStatus GraphMapper::IsLrtSubgraphSupported() {
 
 LrtStatus GraphMapper::InitQnnGraph(absl::string_view qnn_graph_name) {
   LRT_RETURN_STATUS_IF_QNN_NOT_OK(
-      Qnn().API()->graphCreate(Qnn().ContextHandle(), qnn_graph_name.data(),
+      Qnn().Api()->graphCreate(Qnn().ContextHandle(), qnn_graph_name.data(),
                                GetDefaultGraphConfigs().data(), &QnnGraph()));
   return kLrtStatusOk;
 }
 
 LrtStatus GraphMapper::Finalize() {
   LRT_RETURN_STATUS_IF_QNN_NOT_OK(
-      Qnn().API()->graphFinalize(QnnGraph(), nullptr, nullptr));
+      Qnn().Api()->graphFinalize(QnnGraph(), nullptr, nullptr));
   return kLrtStatusOk;
 }
 
@@ -300,7 +300,7 @@ LrtStatus GraphMapper::MapGraph(QnnManager& qnn, LrtSubgraph subgraph,
     qnn_op.v1.numOfOutputs = op_outs.size();
     qnn_op.v1.outputTensors = qnn_op_outs;
 
-    LRT_RETURN_STATUS_IF_QNN_NOT_OK(graph_mapper.Qnn().API()->graphAddNode(
+    LRT_RETURN_STATUS_IF_QNN_NOT_OK(graph_mapper.Qnn().Api()->graphAddNode(
         graph_mapper.QnnGraph(), qnn_op));
   }
 

tensorflow/lite/experimental/lrt/qnn_sdk/BUILD

@@ -39,6 +39,7 @@ ungrte_cc_library_with_qnn(
         # 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/core:logging",
     ],
 )