Convert onnxruntime::Status to OrtStatus

chilo-ms · chilo-ms · commit 75240a410974 · 2025-07-10T15:02:26.000-07:00
diff --git a/plugin_execution_providers/tensorrt/tensorrt_execution_provider_info.cc b/plugin_execution_providers/tensorrt/tensorrt_execution_provider_info.cc
@@ -59,29 +59,29 @@ TensorrtExecutionProviderInfo TensorrtExecutionProviderInfo::FromProviderOptions
   TensorrtExecutionProviderInfo info{};
 
   void* user_compute_stream = nullptr;
-  ORT_THROW_IF_ERROR(
+  THROW_IF_ERROR(
       ProviderOptionsParser{}
           .AddValueParser(
               tensorrt::provider_option_names::kDeviceId,
-              [&info](const std::string& value_str) -> Status {
-                ORT_RETURN_IF_ERROR(ParseStringWithClassicLocale(value_str, info.device_id));
+              [&info](const std::string& value_str) -> OrtStatus* {
+                RETURN_IF_ERROR(ParseStringWithClassicLocale(value_str, info.device_id));
                 int num_devices{};
                 CUDA_RETURN_IF_ERROR(cudaGetDeviceCount(&num_devices));
-                ORT_RETURN_IF_NOT(
+                RETURN_IF_NOT(
                     0 <= info.device_id && info.device_id < num_devices,
                     "Invalid device ID: ", info.device_id,
                     ", must be between 0 (inclusive) and ", num_devices, " (exclusive).");
-                return Status::OK();
+                return nullptr;
               })
           .AddAssignmentToReference(tensorrt::provider_option_names::kMaxPartitionIterations, info.max_partition_iterations)
           .AddAssignmentToReference(tensorrt::provider_option_names::kHasUserComputeStream, info.has_user_compute_stream)
           .AddValueParser(
               tensorrt::provider_option_names::kUserComputeStream,
-              [&user_compute_stream](const std::string& value_str) -> Status {
+              [&user_compute_stream](const std::string& value_str) -> OrtStatus* {
                 size_t address;
-                ORT_RETURN_IF_ERROR(ParseStringWithClassicLocale(value_str, address));
+                RETURN_IF_ERROR(ParseStringWithClassicLocale(value_str, address));
                 user_compute_stream = reinterpret_cast<void*>(address);
-                return Status::OK();
+                return nullptr;
               })
           .AddAssignmentToReference(tensorrt::provider_option_names::kMinSubgraphSize, info.min_subgraph_size)
           .AddAssignmentToReference(tensorrt::provider_option_names::kMaxWorkspaceSize, info.max_workspace_size)
diff --git a/plugin_execution_providers/tensorrt/tensorrt_execution_provider_info.h b/plugin_execution_providers/tensorrt/tensorrt_execution_provider_info.h
@@ -3,9 +3,10 @@
 
 #pragma once
 
-#include <string>
+#include "tensorrt_execution_provider_utils.h"
 #include "provider_options.h"
-#include "common.h"
+
+#include <string>
 
 #define TRT_DEFAULT_OPTIMIZER_LEVEL 3
 
@@ -54,7 +55,7 @@ struct TensorrtExecutionProviderInfo {
   std::string engine_cache_prefix{""};
   bool engine_hw_compatible{false};
 
-  static TensorrtExecutionProviderInfo FromProviderOptions(const onnxruntime::ProviderOptions& options);
+  static TensorrtExecutionProviderInfo FromProviderOptions(const ProviderOptions& options);
 //  static ProviderOptions ToProviderOptions(const TensorrtExecutionProviderInfo& info);
 //  static ProviderOptions ToProviderOptions(const OrtTensorRTProviderOptionsV2& info);
 //  static void UpdateProviderOptions(void* provider_options, const ProviderOptions& options, bool string_copy);
diff --git a/plugin_execution_providers/tensorrt/tensorrt_execution_provider_utils.h b/plugin_execution_providers/tensorrt/tensorrt_execution_provider_utils.h
@@ -6,6 +6,7 @@
 
 #include "flatbuffers/idl.h"
 #include "ort_trt_int8_cal_table.fbs.h"
+#include "make_string.h"
 // #include "core/providers/cuda/cuda_pch.h"
 // #include "core/common/path_string.h"
 // #include "core/framework/murmurhash3.h"
@@ -21,6 +22,26 @@
 #include <iostream>
 #include <filesystem>
 
+struct ApiPtrs {
+  const OrtApi& ort_api;
+  const OrtEpApi& ep_api;
+  const OrtModelEditorApi& model_editor_api;
+};
+
+const OrtApi* g_ort_api = nullptr;
+const OrtEpApi* g_ep_api = nullptr;
+const OrtModelEditorApi* g_model_editor_api = nullptr;
+
+#define ENFORCE(condition, ...)                            \
+  do {                                                      \
+    if (!(condition)) {                                      \
+      throw std::runtime_error(MakeString(__VA_ARGS__));    \
+    }                                                       \
+  } while (false)
+
+#define THROW(...) \
+  throw std::runtime_error(MakeString(__VA_ARGS__));
+
 #define RETURN_IF_ERROR(fn)    \
   do {                         \
     OrtStatus* _status = (fn); \
@@ -29,17 +50,60 @@
     }                          \
   } while (0)
 
-#define RETURN_IF(cond, ort_api, msg)                    \
-  do {                                                   \
-    if ((cond)) {                                        \
-      return (ort_api).CreateStatus(ORT_EP_FAIL, (msg)); \
-    }                                                    \
+/*
+template <typename... Args>
+std::string ComposeString(Args&&... args) {
+  std::ostringstream oss;
+  (oss << ... << args);
+  return oss.str();
+};
+*/
+
+#define RETURN_IF(cond, ...)                                                               \
+  do {                                                                                     \
+    if ((cond)) {                                                                          \
+      return Ort::GetApi().CreateStatus(ORT_EP_FAIL, MakeString(__VA_ARGS__).c_str()); \
+    }                                                                                      \
+  } while (0)
+
+#define RETURN_IF_NOT(condition, ...) RETURN_IF(!(condition), __VA_ARGS__)
+
+#define MAKE_STATUS(error_code, msg) \
+  Ort::GetApi().CreateStatus(error_code, (msg));
+
+#define THROW_IF_ERROR(expr)                         \
+  do {                                               \
+    auto _status = (expr);                           \
+    if (_status != nullptr) {                        \
+      std::ostringstream oss;                        \
+      oss << Ort::GetApi().GetErrorMessage(_status); \
+      Ort::GetApi().ReleaseStatus(_status);          \
+      throw std::runtime_error(oss.str());           \
+    }                                                \
   } while (0)
 
-struct ApiPtrs {
-  const OrtApi& ort_api;
-  const OrtEpApi& ep_api;
-  const OrtModelEditorApi& model_editor_api;
+// Helper to release Ort one or more objects obtained from the public C API at the end of their scope.
+template <typename T>
+struct DeferOrtRelease {
+  DeferOrtRelease(T** object_ptr, std::function<void(T*)> release_func)
+      : objects_(object_ptr), count_(1), release_func_(release_func) {}
+
+  DeferOrtRelease(T** objects, size_t count, std::function<void(T*)> release_func)
+      : objects_(objects), count_(count), release_func_(release_func) {}
+
+  ~DeferOrtRelease() {
+    if (objects_ != nullptr && count_ > 0) {
+      for (size_t i = 0; i < count_; ++i) {
+        if (objects_[i] != nullptr) {
+          release_func_(objects_[i]);
+          objects_[i] = nullptr;
+        }
+      }
+    }
+  }
+  T** objects_ = nullptr;
+  size_t count_ = 0;
+  std::function<void(T*)> release_func_ = nullptr;
 };
 
 namespace fs = std::filesystem;
diff --git a/plugin_execution_providers/tensorrt/utils/cuda/cuda_call.h b/plugin_execution_providers/tensorrt/utils/cuda/cuda_call.h
@@ -2,21 +2,18 @@
 // Licensed under the MIT License.
 
 #pragma once
-#include "../common.h"
-
-namespace onnxruntime {
 
 // -----------------------------------------------------------------------
 // Error handling
 // -----------------------------------------------------------------------
 //
 template <typename ERRTYPE>
 const char* CudaErrString(ERRTYPE) {
-  ORT_NOT_IMPLEMENTED();
+  THROW();
 }
 
 template <typename ERRTYPE, bool THRW>
-std::conditional_t<THRW, void, Status> CudaCall(
+std::conditional_t<THRW, void, OrtStatus*> CudaCall(
     ERRTYPE retCode, const char* exprString, const char* libName, ERRTYPE successCode, const char* msg, const char* file, const int line) {
   if (retCode != successCode) {
     try {
@@ -41,22 +38,20 @@ std::conditional_t<THRW, void, Status> CudaCall(
                file, line, exprString, msg);
       if constexpr (THRW) {
         // throw an exception with the error info
-        ORT_THROW(str);
+        THROW(str);
       } else {
-        //LOGS_DEFAULT(ERROR) << str;
-        return ORT_MAKE_STATUS(ONNXRUNTIME, FAIL, str);
+        return MAKE_STATUS(ORT_EP_FAIL, str);
       }
     } catch (const std::exception& e) {  // catch, log, and rethrow since CUDA code sometimes hangs in destruction, so we'd never get to see the error
       if constexpr (THRW) {
-        ORT_THROW(e.what());
+        THROW(e.what());
       } else {
-        //LOGS_DEFAULT(ERROR) << e.what();
-        return ORT_MAKE_STATUS(ONNXRUNTIME, FAIL, e.what());
+        return MAKE_STATUS(ORT_EP_FAIL, e.what());
       }
     }
   }
   if constexpr (!THRW) {
-    return Status::OK();
+    return nullptr;
   }
 }
 
@@ -65,5 +60,3 @@ std::conditional_t<THRW, void, Status> CudaCall(
     //ERRTYPE retCode, const char* exprString, const char* libName, ERRTYPE successCode, const char* msg, const char* file, const int line);
 
 #define CUDA_CALL(expr) (CudaCall<cudaError, false>((expr), #expr, "CUDA", cudaSuccess, "", __FILE__, __LINE__))
-
-}  // namespace onnxruntime
diff --git a/plugin_execution_providers/tensorrt/utils/cuda/cuda_common.h b/plugin_execution_providers/tensorrt/utils/cuda/cuda_common.h
@@ -5,10 +5,8 @@
 
 #include "cuda_call.h"
 
-namespace onnxruntime {
 namespace cuda {
 
-#define CUDA_RETURN_IF_ERROR(expr) ORT_RETURN_IF_ERROR(CUDA_CALL(expr))
+#define CUDA_RETURN_IF_ERROR(expr) RETURN_IF_ERROR(CUDA_CALL(expr))
 
-}  // namespace cuda
-}  // namespace onnxruntime
+}  // namespace cuda
diff --git a/plugin_execution_providers/tensorrt/utils/make_string.h b/plugin_execution_providers/tensorrt/utils/make_string.h
@@ -21,8 +21,6 @@
 #include <sstream>
 #include <type_traits>
 
-namespace onnxruntime {
-
 namespace detail {
 
 inline void MakeStringImpl(std::ostringstream& /*ss*/) noexcept {
@@ -122,5 +120,3 @@ inline std::string MakeStringWithClassicLocale(const std::string& str) {
 inline std::string MakeStringWithClassicLocale(const char* cstr) {
   return cstr;
 }
-
-}  // namespace onnxruntime
diff --git a/plugin_execution_providers/tensorrt/utils/parse_string.h b/plugin_execution_providers/tensorrt/utils/parse_string.h
@@ -8,10 +8,6 @@
 #include <string_view>
 #include <type_traits>
 
-#include "common.h"
-
-namespace onnxruntime {
-
 /**
  * Tries to parse a value from an entire string.
  */
@@ -67,9 +63,9 @@ inline bool TryParseStringWithClassicLocale(std::string_view str, bool& value) {
  * Parses a value from an entire string.
  */
 template <typename T>
-Status ParseStringWithClassicLocale(std::string_view s, T& value) {
-  ORT_RETURN_IF_NOT(TryParseStringWithClassicLocale(s, value), "Failed to parse value: \"", value, "\"");
-  return Status::OK();
+OrtStatus* ParseStringWithClassicLocale(std::string_view s, T& value) {
+  RETURN_IF_NOT(TryParseStringWithClassicLocale(s, value), "Failed to parse value: \"", value, "\"");
+  return nullptr;
 }
 
 /**
@@ -81,5 +77,3 @@ T ParseStringWithClassicLocale(std::string_view s) {
   ORT_THROW_IF_ERROR(ParseStringWithClassicLocale(s, value));
   return value;
 }
-
-}  // namespace onnxruntime
diff --git a/plugin_execution_providers/tensorrt/utils/provider_options_utils.h b/plugin_execution_providers/tensorrt/utils/provider_options_utils.h
