Fix crash at process exit on macOS

fix destructor order by using different way to deal with OrtEnv

Author: fs-eire

js/node/src/inference_session_wrap.cc

@@ -6,6 +6,7 @@
 #include "common.h"
 #include "inference_session_wrap.h"
 #include "ort_instance_data.h"
+#include "ort_singleton_data.h"
 #include "run_options_helper.h"
 #include "session_options_helper.h"
 #include "tensor_helper.h"
@@ -76,7 +77,7 @@ Napi::Value InferenceSessionWrap::LoadModel(const Napi::CallbackInfo& info) {
       Napi::String value = info[0].As<Napi::String>();
 
       ParseSessionOptions(info[1].As<Napi::Object>(), sessionOptions);
-      this->session_.reset(new Ort::Session(*OrtInstanceData::OrtEnv(),
+      this->session_.reset(new Ort::Session(*OrtSingletonData::Env(),
 #ifdef _WIN32
                                             reinterpret_cast<const wchar_t*>(value.Utf16Value().c_str()),
 #else
@@ -91,7 +92,7 @@ Napi::Value InferenceSessionWrap::LoadModel(const Napi::CallbackInfo& info) {
       int64_t bytesLength = info[2].As<Napi::Number>().Int64Value();
 
       ParseSessionOptions(info[3].As<Napi::Object>(), sessionOptions);
-      this->session_.reset(new Ort::Session(*OrtInstanceData::OrtEnv(),
+      this->session_.reset(new Ort::Session(*OrtSingletonData::Env(),
                                             reinterpret_cast<char*>(buffer) + bytesOffset, bytesLength,
                                             sessionOptions));
     } else {
@@ -211,7 +212,7 @@ Napi::Value InferenceSessionWrap::Run(const Napi::CallbackInfo& info) {
       ParseRunOptions(info[2].As<Napi::Object>(), runOptions);
     }
     if (preferredOutputLocations_.size() == 0) {
-      session_->Run(runOptions == nullptr ? *OrtInstanceData::OrtDefaultRunOptions() : runOptions,
+      session_->Run(runOptions == nullptr ? *OrtSingletonData::DefaultRunOptions() : runOptions,
                     inputIndex == 0 ? nullptr : &inputNames_cstr[0], inputIndex == 0 ? nullptr : &inputValues[0],
                     inputIndex, outputIndex == 0 ? nullptr : &outputNames_cstr[0],
                     outputIndex == 0 ? nullptr : &outputValues[0], outputIndex);
@@ -240,7 +241,7 @@ Napi::Value InferenceSessionWrap::Run(const Napi::CallbackInfo& info) {
         }
       }
 
-      session_->Run(runOptions == nullptr ? *OrtInstanceData::OrtDefaultRunOptions() : runOptions, *ioBinding_);
+      session_->Run(runOptions == nullptr ? *OrtSingletonData::DefaultRunOptions() : runOptions, *ioBinding_);
 
       auto outputs = ioBinding_->GetOutputValues();
       ORT_NAPI_THROW_ERROR_IF(outputs.size() != outputIndex, env, "Output count mismatch.");

js/node/src/ort_instance_data.cc

@@ -6,27 +6,10 @@
 
 #include "common.h"
 #include "ort_instance_data.h"
+#include "ort_singleton_data.h"
 #include "onnxruntime_cxx_api.h"
 
-std::unique_ptr<Ort::Env> OrtInstanceData::ortEnv;
-std::unique_ptr<Ort::RunOptions> OrtInstanceData::ortDefaultRunOptions;
-std::mutex OrtInstanceData::ortEnvMutex;
-std::atomic<uint64_t> OrtInstanceData::ortEnvRefCount;
-std::atomic<bool> OrtInstanceData::ortEnvDestroyed;
-
 OrtInstanceData::OrtInstanceData() {
-  ++ortEnvRefCount;
-}
-
-OrtInstanceData::~OrtInstanceData() {
-  if (--ortEnvRefCount == 0) {
-    std::lock_guard<std::mutex> lock(ortEnvMutex);
-    if (ortEnv) {
-      ortDefaultRunOptions.reset(nullptr);
-      ortEnv.reset();
-      ortEnvDestroyed = true;
-    }
-  }
 }
 
 void OrtInstanceData::Create(Napi::Env env, Napi::Function inferenceSessionWrapperFunction) {
@@ -42,14 +25,8 @@ void OrtInstanceData::InitOrt(Napi::Env env, int log_level, Napi::Function tenso
 
   data->ortTensorConstructor = Napi::Persistent(tensorConstructor);
 
-  if (!ortEnv) {
-    std::lock_guard<std::mutex> lock(ortEnvMutex);
-    if (!ortEnv) {
-      ORT_NAPI_THROW_ERROR_IF(ortEnvDestroyed, env, "OrtEnv already destroyed.");
-      ortEnv.reset(new Ort::Env{OrtLoggingLevel(log_level), "onnxruntime-node"});
-      ortDefaultRunOptions.reset(new Ort::RunOptions{});
-    }
-  }
+  // Only the first time call to OrtSingletonData::GetOrCreateOrtObjects() will create the Ort::Env
+  OrtSingletonData::GetOrCreateOrtObjects(log_level);
 }
 
 const Napi::FunctionReference& OrtInstanceData::TensorConstructor(Napi::Env env) {

js/node/src/ort_instance_data.h

@@ -8,11 +8,6 @@
 
 /**
  * The OrtInstanceData class is designed to manage the lifecycle of necessary instance data, including:
- * - The Ort::Env singleton instance.
- *   This is a global singleton that is shared across all InferenceSessionWrap instances. It is created when the first
- *   time `InferenceSession.initOrtOnce()` is called. It is destroyed when the last active NAPI Env is destroyed.
- *   Once destroyed, it cannot be created again.
- *
  * - The Object reference of the InferenceSessionWrap class and the Tensor constructor.
  *   This is a per-env data that has the same lifecycle as the Napi::Env. If there are worker threads, each thread will
  *   have its own handle to the InferenceSessionWrap class and the Tensor constructor.
@@ -27,24 +22,11 @@ struct OrtInstanceData {
   static void InitOrt(Napi::Env env, int log_level, Napi::Function tensorConstructor);
   // Get the Tensor constructor reference for the Napi::Env
   static const Napi::FunctionReference& TensorConstructor(Napi::Env env);
-  // Get the global Ort::Env
-  static const Ort::Env* OrtEnv() { return ortEnv.get(); }
-  // Get the default Ort::RunOptions
-  static Ort::RunOptions* OrtDefaultRunOptions() { return ortDefaultRunOptions.get(); }
-
-  ~OrtInstanceData();
 
  private:
   OrtInstanceData();
 
   // per env persistent constructors
   Napi::FunctionReference wrappedSessionConstructor;
   Napi::FunctionReference ortTensorConstructor;
-
-  // ORT env (global singleton)
-  static std::unique_ptr<Ort::Env> ortEnv;
-  static std::unique_ptr<Ort::RunOptions> ortDefaultRunOptions;
-  static std::mutex ortEnvMutex;
-  static std::atomic<uint64_t> ortEnvRefCount;
-  static std::atomic<bool> ortEnvDestroyed;
 };

js/node/src/ort_singleton_data.cc

@@ -0,0 +1,22 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "ort_singleton_data.h"
+
+OrtSingletonData::OrtObjects::OrtObjects(int log_level)
+    : env(new Ort::Env{OrtLoggingLevel(log_level), "onnxruntime-node"}),
+      default_run_options(new Ort::RunOptions{}) {
+}
+
+OrtSingletonData::OrtObjects& OrtSingletonData::GetOrCreateOrtObjects(int log_level) {
+  static OrtObjects ort_objects(log_level);
+  return ort_objects;
+}
+
+const Ort::Env* OrtSingletonData::Env() {
+  return GetOrCreateOrtObjects().env.get();
+}
+
+const Ort::RunOptions* OrtSingletonData::DefaultRunOptions() {
+  return GetOrCreateOrtObjects().default_run_options.get();
+}

js/node/src/ort_singleton_data.h

@@ -0,0 +1,40 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <napi.h>
+#include "onnxruntime_cxx_api.h"
+
+/**
+ * The OrtSingletonData class is designed to manage the lifecycle of necessary singleton instance data, including:
+ *
+ * - The Ort::Env singleton instance.
+ *   This is a global singleton that is shared across all InferenceSessionWrap instances. It is created when the first
+ *   time `InferenceSession.initOrtOnce()` is called.
+ *
+ * - The Ort::RunOptions singleton instance.
+ *   This is an empty default RunOptions instance. It is created once to allow reuse across all session inference run.
+ *
+ * The OrtSingletonData class uses the "Meyers Singleton" pattern to ensure thread-safe lazy initialization, as well as
+ * proper destruction order at program exit.
+ */
+struct OrtSingletonData {
+  struct OrtObjects {
+    std::unique_ptr<Ort::Env> env;
+    std::unique_ptr<Ort::RunOptions> default_run_options;
+
+   private:
+    // The following pattern ensures that OrtObjects can only be created by OrtSingletonData
+    OrtObjects(int log_level);
+    friend struct OrtSingletonData;
+  };
+
+  static OrtObjects& GetOrCreateOrtObjects(int log_level = ORT_LOGGING_LEVEL_WARNING);
+
+  // Get the global Ort::Env
+  static const Ort::Env* Env();
+
+  // Get the default Ort::RunOptions
+  static const Ort::RunOptions* DefaultRunOptions();
+};