Enable onnxruntime_autoep_test on non-Windows platforms

cmake/CMakeLists.txt

@@ -1654,9 +1654,25 @@ if ("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
   endif()
 endif()
 
-#Now the 'onnxruntime_EXTERNAL_LIBRARIES' variable should be sealed. It will be used in onnxruntime.cmake which will be included in the next.
-#The order of the following targets matters. Right depends on left. If target A appears before target B. Then A.cmake can not use variables defined in B.cmake.
-set(ONNXRUNTIME_CMAKE_FILES onnxruntime_flatbuffers onnxruntime_common onnxruntime_mlas onnxruntime_graph onnxruntime_lora onnxruntime_framework onnxruntime_util onnxruntime_providers onnxruntime_optimizer onnxruntime_session ${ONNXRUNTIME_EAGER_CMAKE_FILE_NAME})
+# From this point on, onnxruntime_EXTERNAL_LIBRARIES should be no longer be modified. It will be used in
+# onnxruntime.cmake which will be included next.
+
+# The order of the CMake file names (which exclude the ".cmake" suffix) in ONNXRUNTIME_CMAKE_FILES matters. Later CMake
+# files may depend on earlier ones but earlier ones cannot depend on later ones. For example, if A appears before B,
+# then A.cmake cannot use variables defined in B.cmake.
+set(ONNXRUNTIME_CMAKE_FILES
+    onnxruntime_flatbuffers
+    onnxruntime_common
+    onnxruntime_mlas
+    onnxruntime_graph
+    onnxruntime_lora
+    onnxruntime_framework
+    onnxruntime_util
+    onnxruntime_providers
+    onnxruntime_optimizer
+    onnxruntime_session
+    ${ONNXRUNTIME_EAGER_CMAKE_FILE_NAME}
+    )
 
 if (onnxruntime_USE_WINML)
   # WINML uses and depends on the shared lib.  Note:  You can build WINML without DML and you will get a

cmake/onnxruntime_unittests.cmake

@@ -588,6 +588,7 @@ set (onnxruntime_shared_lib_test_SRC
           ${ONNXRUNTIME_SHARED_LIB_TEST_SRC_DIR}/test_nontensor_types.cc
           ${ONNXRUNTIME_SHARED_LIB_TEST_SRC_DIR}/test_ort_format_models.cc
           ${ONNXRUNTIME_SHARED_LIB_TEST_SRC_DIR}/test_run_options.cc
+          ${ONNXRUNTIME_SHARED_LIB_TEST_SRC_DIR}/test_runtime_path.cc
           ${ONNXRUNTIME_SHARED_LIB_TEST_SRC_DIR}/test_session_options.cc
           ${ONNXRUNTIME_SHARED_LIB_TEST_SRC_DIR}/utils.h
           ${ONNXRUNTIME_SHARED_LIB_TEST_SRC_DIR}/utils.cc
@@ -1518,9 +1519,48 @@ endif()
     target_link_libraries(onnxruntime_mocked_allocator PRIVATE ${GSL_TARGET})
     set_target_properties(onnxruntime_mocked_allocator PROPERTIES FOLDER "ONNXRuntimeTest")
 
+    # onnxruntime_runtime_path_test_shared_library
+    block()
+      set(onnxruntime_runtime_path_test_shared_library_src
+          "${TEST_SRC_DIR}/shared_lib/runtime_path_test_shared_library/runtime_path_test_shared_library.h"
+          "${TEST_SRC_DIR}/shared_lib/runtime_path_test_shared_library/runtime_path_test_shared_library.cc")
+
+      onnxruntime_add_shared_library(onnxruntime_runtime_path_test_shared_library
+                                     ${onnxruntime_runtime_path_test_shared_library_src})
+
+      target_link_libraries(onnxruntime_runtime_path_test_shared_library PRIVATE
+                            onnxruntime_common cpuinfo ${CMAKE_DL_LIBS})
+      target_include_directories(onnxruntime_runtime_path_test_shared_library PRIVATE ${ONNXRUNTIME_ROOT})
+
+      if(UNIX)
+        if (APPLE)
+          set(onnxruntime_runtime_path_test_shared_library_link_flags "-Xlinker -dead_strip")
+        elseif (NOT CMAKE_SYSTEM_NAME MATCHES "AIX")
+          string(CONCAT onnxruntime_runtime_path_test_shared_library_link_flags
+                 "-Xlinker --version-script=${TEST_SRC_DIR}/shared_lib/runtime_path_test_shared_library/runtime_path_test_shared_library.lds "
+                 "-Xlinker --no-undefined -Xlinker --gc-sections -z noexecstack")
+        endif()
+      else()
+        set(onnxruntime_runtime_path_test_shared_library_link_flags
+            "-DEF:${TEST_SRC_DIR}/shared_lib/runtime_path_test_shared_library/runtime_path_test_shared_library.def")
+      endif()
+
+      set_property(TARGET onnxruntime_runtime_path_test_shared_library APPEND_STRING PROPERTY LINK_FLAGS
+                   ${onnxruntime_runtime_path_test_shared_library_link_flags})
+
+      set_target_properties(onnxruntime_runtime_path_test_shared_library PROPERTIES FOLDER "ONNXRuntimeTest")
+      source_group(TREE ${TEST_SRC_DIR} FILES ${onnxruntime_runtime_path_test_shared_library_src})
+    endblock()
+
     #################################################################
     # test inference using shared lib
-    set(onnxruntime_shared_lib_test_LIBS onnxruntime_mocked_allocator onnxruntime_test_utils onnxruntime_common onnx_proto)
+    set(onnxruntime_shared_lib_test_LIBS
+        onnxruntime_mocked_allocator
+        onnxruntime_test_utils
+        onnxruntime_common
+        onnx_proto
+        onnxruntime_runtime_path_test_shared_library)
+
     if(NOT WIN32)
       if(onnxruntime_USE_SNPE)
         list(APPEND onnxruntime_shared_lib_test_LIBS onnxruntime_providers_snpe)
@@ -1978,8 +2018,7 @@ endif()
 
 # Build library that can be used with RegisterExecutionProviderLibrary and automatic EP selection
 # We need a shared lib build to use that as a dependency for the test library
-# Currently we only have device discovery on Windows so no point building the test app on other platforms.
-if (WIN32 AND onnxruntime_BUILD_SHARED_LIB AND
+if (onnxruntime_BUILD_SHARED_LIB AND
     NOT CMAKE_SYSTEM_NAME STREQUAL "Emscripten" AND
     NOT onnxruntime_MINIMAL_BUILD)
 
@@ -1991,7 +2030,7 @@ if (WIN32 AND onnxruntime_BUILD_SHARED_LIB AND
                                                 "${TEST_SRC_DIR}/autoep/library/plugin_ep_utils.h")
   onnxruntime_add_shared_library_module(example_plugin_ep ${onnxruntime_autoep_test_library_src})
   target_include_directories(example_plugin_ep PRIVATE ${REPO_ROOT}/include/onnxruntime/core/session)
-  target_link_libraries(example_plugin_ep PRIVATE onnxruntime)
+  target_link_libraries(example_plugin_ep PRIVATE onnxruntime ${GSL_TARGET})
 
   if(UNIX)
     if (APPLE)
@@ -2024,7 +2063,7 @@ if (WIN32 AND onnxruntime_BUILD_SHARED_LIB AND
           "${TEST_SRC_DIR}/autoep/library/example_plugin_ep_virt_gpu/ep.cc")
   onnxruntime_add_shared_library_module(example_plugin_ep_virt_gpu ${onnxruntime_autoep_test_example_plugin_ep_virt_gpu_src})
   target_include_directories(example_plugin_ep_virt_gpu PRIVATE ${REPO_ROOT}/include/onnxruntime/core/session)
-  target_link_libraries(example_plugin_ep_virt_gpu PRIVATE onnxruntime)
+  target_link_libraries(example_plugin_ep_virt_gpu PRIVATE onnxruntime ${GSL_TARGET})
 
   if(UNIX)
     if (APPLE)

onnxruntime/core/platform/env.h

@@ -245,9 +245,9 @@ class Env {
 
   // \brief Gets the file path of the onnx runtime code
   //
-  // Used to help load other shared libraries that live in the same folder as the core code, for example
-  // The DNNL provider shared library. Without this path, the module won't be found on windows in all cases.
-  virtual PathString GetRuntimePath() const { return PathString(); }
+  // Used to help load other shared libraries that live in the same folder as the core code.
+  // For example, the DNNL provider shared library.
+  virtual PathString GetRuntimePath() const = 0;
 
   // \brief Get a pointer to a symbol from a dynamic library.
   //

onnxruntime/core/platform/posix/env.cc

@@ -31,6 +31,7 @@
 #endif
 #include <unistd.h>
 
+#include <filesystem>
 #include <iostream>
 #include <optional>
 #include <thread>
@@ -554,6 +555,23 @@
     return common::Status::OK();
   }
 
+  PathString GetRuntimePath() const override {
+    // Use dladdr() to look up the file that contains an address from this binary.
+    const void* const address_from_this_binary = reinterpret_cast<const void*>(Env::Default);
+
+    if (Dl_info dl_info{};
+        dladdr(address_from_this_binary, &dl_info) != 0 && dl_info.dli_fname != nullptr) {
+      LOGS_DEFAULT(VERBOSE) << "Getting runtime path as parent directory of binary: " << dl_info.dli_fname;
+
+      auto runtime_path = std::filesystem::path{dl_info.dli_fname};
+      runtime_path = std::filesystem::absolute(runtime_path);
+      runtime_path.remove_filename();
+      return runtime_path;
+    }
+
+    return PathString{};
+  }
+
   common::Status GetSymbolFromLibrary(void* handle, const std::string& symbol_name, void** symbol) const override {
     dlerror();  // clear any old error str
 

onnxruntime/core/providers/cuda/version_script.lds

@@ -2,6 +2,8 @@
 VERS_1.0 {
   global:
     GetProvider;
+    CreateEpFactories;
+    ReleaseEpFactory;
     _binary_*;
 
   # Hide everything else.

onnxruntime/core/session/provider_bridge_ort.cc

@@ -1775,24 +1775,27 @@
 #if !defined(ORT_MINIMAL_BUILD) || defined(ORT_MINIMAL_BUILD_CUSTOM_OPS)
   Status LoadDynamicLibrary(onnxruntime::PathString library_name) override { return LoadDynamicLibraryFromProvider(library_name); };
 #endif
-} provider_host_;
+} g_provider_host;
 
 #if defined(_MSC_VER) && !defined(__clang__)
 #pragma warning(pop)
 #endif
 struct ProviderSharedLibrary {
-  void Ensure() {
-    if (handle_)
-      return;
+  Status Initialize() {
+    if (handle_) {
+      return Status::OK();
+    }
 
     auto full_path = Env::Default().GetRuntimePath() +
                      PathString(LIBRARY_PREFIX ORT_TSTR("onnxruntime_providers_shared") LIBRARY_EXTENSION);
-    ORT_THROW_IF_ERROR(Env::Default().LoadDynamicLibrary(full_path, true /*shared_globals on unix*/, &handle_));
+    ORT_RETURN_IF_ERROR(Env::Default().LoadDynamicLibrary(full_path, true /*shared_globals on unix*/, &handle_));
 
     void (*PProvider_SetHost)(void*);
-    ORT_THROW_IF_ERROR(Env::Default().GetSymbolFromLibrary(handle_, "Provider_SetHost", (void**)&PProvider_SetHost));
+    ORT_RETURN_IF_ERROR(Env::Default().GetSymbolFromLibrary(handle_, "Provider_SetHost", (void**)&PProvider_SetHost));
 
-    PProvider_SetHost(&provider_host_);
+    PProvider_SetHost(&g_provider_host);
+
+    return Status::OK();
   }
 
   void Unload() {
@@ -1819,7 +1822,7 @@
 static ProviderSharedLibrary s_library_shared;
 
 bool InitProvidersSharedLibrary() try {
-  s_library_shared.Ensure();
+  ORT_THROW_IF_ERROR(s_library_shared.Initialize());
   return true;
 } catch (const std::exception&) {
   return false;
@@ -1841,7 +1844,7 @@
   try {
     std::lock_guard<std::mutex> lock{mutex_};
     if (!provider_) {
-      s_library_shared.Ensure();
+      ORT_RETURN_IF_ERROR(s_library_shared.Initialize());
 
       if (absolute_) {
         // If filename_ is not absolute it should not be loaded.

onnxruntime/test/autoep/library/example_plugin_ep/ep.cc

@@ -381,7 +381,7 @@ void ORT_API_CALL ExampleEp::ReleaseNodeComputeInfosImpl(OrtEp* this_ptr,
                                                          size_t num_node_compute_infos) noexcept {
   (void)this_ptr;
   for (size_t i = 0; i < num_node_compute_infos; i++) {
-    delete node_compute_infos[i];
+    delete static_cast<ExampleNodeComputeInfo*>(node_compute_infos[i]);
   }
 }
 
@@ -399,7 +399,7 @@ OrtStatus* ExampleEp::CreateEpContextNodes(gsl::span<const OrtNode*> fused_nodes
       std::vector<std::string> value_names;
       value_names.reserve(value_infos.size());
 
-      for (const auto vi : value_infos) {
+      for (const auto& vi : value_infos) {
         value_names.push_back(vi.GetName());
       }
 

onnxruntime/test/autoep/library/example_plugin_ep/ep_allocator.h

@@ -5,6 +5,7 @@
 
 #include "../plugin_ep_utils.h"
 
+#include <memory>
 #include <sstream>
 
 // from onnxruntime/core/framework/allocator_stats.h
@@ -51,7 +52,16 @@ struct AllocatorStats {
   }
 };
 
-struct CustomAllocator : OrtAllocator {
+// `OrtAllocator` is a C API struct. `BaseAllocator` is a minimal C++ struct which inherits from `OrtAllocator`.
+// Notably, `BaseAllocator` has a virtual destructor to enable a derived class to be deleted through a `BaseAllocator`
+// pointer. Allocators which need to be deleted through a base class pointer should inherit from `BaseAllocator`.
+struct BaseAllocator : OrtAllocator {
+  virtual ~BaseAllocator() = default;
+};
+
+using AllocatorUniquePtr = std::unique_ptr<BaseAllocator>;
+
+struct CustomAllocator : BaseAllocator {
   CustomAllocator(const OrtMemoryInfo* mem_info, const ApiPtrs& api_ptrs_in)
       : memory_info{mem_info}, api_ptrs{api_ptrs_in} {
     version = ORT_API_VERSION;

onnxruntime/test/autoep/library/example_plugin_ep/ep_arena.h

@@ -551,7 +551,7 @@ class ArenaImpl {
   // un-assign chunks when StreamImpl::OnSessionRunEnd is called.
   std::unordered_map<const OrtSyncStreamImpl*, const OrtSyncStream*> impl_to_stream_;
 
-  AllocatorStats stats_;
+  AllocatorStats stats_{};
 
   const OrtApi& api_;
   const OrtEpApi& ep_api_;
@@ -563,7 +563,7 @@ class ArenaImpl {
   ArenaImpl& operator=(ArenaImpl&&) = delete;
 };
 
-struct ArenaAllocator : OrtAllocator {
+struct ArenaAllocator : BaseAllocator {
   static OrtStatus* CreateOrtArenaAllocator(AllocatorUniquePtr allocator,
                                             const OrtKeyValuePairs* options,
                                             const OrtApi& api,

onnxruntime/test/autoep/library/example_plugin_ep/ep_factory.cc

@@ -12,7 +12,12 @@
 #include "ep_stream_support.h"
 
 ExampleEpFactory::ExampleEpFactory(const char* ep_name, ApiPtrs apis, const OrtLogger& default_logger)
-    : OrtEpFactory{}, ApiPtrs(apis), default_logger_{default_logger}, ep_name_{ep_name} {
+    : OrtEpFactory{},
+      ApiPtrs(apis),
+      default_logger_{default_logger},
+      ep_name_{ep_name},
+      default_memory_info_{nullptr},
+      readonly_memory_info_{nullptr} {
   ort_version_supported = ORT_API_VERSION;  // set to the ORT version we were compiled with.
   GetName = GetNameImpl;
   GetVendor = GetVendorImpl;
@@ -34,43 +39,35 @@ ExampleEpFactory::ExampleEpFactory(const char* ep_name, ApiPtrs apis, const OrtL
 
   // setup the OrtMemoryInfo instances required by the EP.
   // We pretend the device the EP is running on is GPU.
-  OrtMemoryInfo* mem_info = nullptr;
-  auto* status = ort_api.CreateMemoryInfo_V2("ExampleEP GPU", OrtMemoryInfoDeviceType_GPU,
-                                             /*vendor*/ 0xBE57, /* device_id */ 0,
-                                             OrtDeviceMemoryType_DEFAULT,
-                                             /*alignment*/ 0,
-                                             // it is invalid to use OrtArenaAllocator as that is reserved for the
-                                             // internal ORT Arena implementation
-                                             OrtAllocatorType::OrtDeviceAllocator,
-                                             &mem_info);
-  assert(status == nullptr);  // should never fail.
-  default_memory_info_ = MemoryInfoUniquePtr(mem_info, ort_api.ReleaseMemoryInfo);
+  default_memory_info_ = Ort::MemoryInfo{"ExampleEP GPU",
+                                         OrtMemoryInfoDeviceType_GPU,
+                                         /*vendor*/ 0xBE57, /* device_id */ 0,
+                                         OrtDeviceMemoryType_DEFAULT,
+                                         /*alignment*/ 0,
+                                         // it is invalid to use OrtArenaAllocator as that is reserved for the internal
+                                         // ORT Arena implementation
+                                         OrtAllocatorType::OrtDeviceAllocator};
 
   // create data transfer for the device
-  const OrtMemoryDevice* device = ep_api.MemoryInfo_GetMemoryDevice(default_memory_info_.get());
+  const OrtMemoryDevice* device = ep_api.MemoryInfo_GetMemoryDevice(default_memory_info_);
   data_transfer_impl_ = std::make_unique<ExampleDataTransfer>(apis, device);
 
   // create read-only allocator for use with initializers. same info as DEFAULT memory apart from the allocator type.
-  status = ort_api.CreateMemoryInfo_V2("ExampleEP GPU readonly", OrtMemoryInfoDeviceType_GPU,
-                                       /*vendor*/ 0xBE57, /* device_id */ 0,
-                                       OrtDeviceMemoryType_DEFAULT,
-                                       /*alignment*/ 0,
-                                       OrtAllocatorType::OrtReadOnlyAllocator,
-                                       &mem_info);
-  assert(status == nullptr);  // should never fail.
-
-  readonly_memory_info_ = MemoryInfoUniquePtr(mem_info, ort_api.ReleaseMemoryInfo);
+  readonly_memory_info_ = Ort::MemoryInfo{"ExampleEP GPU readonly",
+                                          OrtMemoryInfoDeviceType_GPU,
+                                          /*vendor*/ 0xBE57, /* device_id */ 0,
+                                          OrtDeviceMemoryType_DEFAULT,
+                                          /*alignment*/ 0,
+                                          OrtAllocatorType::OrtReadOnlyAllocator};
 
   // HOST_ACCESSIBLE memory example. use the non-CPU device type so it's clear which device the memory is also
   // accessible from. we infer from the type of HOST_ACCESSIBLE that it's CPU accessible.
-  mem_info = nullptr;
-  status = ort_api.CreateMemoryInfo_V2("ExampleEP GPU pinned", OrtMemoryInfoDeviceType_GPU,
-                                       /*vendor*/ 0xBE57, /* device_id */ 0,
-                                       OrtDeviceMemoryType_HOST_ACCESSIBLE,
-                                       /*alignment*/ 0,
-                                       OrtAllocatorType::OrtDeviceAllocator,
-                                       &mem_info);
-  ort_api.ReleaseMemoryInfo(mem_info);
+  auto host_accessible_memory_info = Ort::MemoryInfo{"ExampleEP GPU pinned",
+                                                     OrtMemoryInfoDeviceType_GPU,
+                                                     /*vendor*/ 0xBE57, /* device_id */ 0,
+                                                     OrtDeviceMemoryType_HOST_ACCESSIBLE,
+                                                     /*alignment*/ 0,
+                                                     OrtAllocatorType::OrtDeviceAllocator};
 }
 
 /*static*/
@@ -136,8 +133,8 @@ OrtStatus* ORT_API_CALL ExampleEpFactory::GetSupportedDevicesImpl(OrtEpFactory*
       // register the allocator info required by the EP.
       // registering OrtMemoryInfo for host accessible memory would be done in an additional call.
       // OrtReadOnlyAllocator + OrtDeviceMemoryType_DEFAULT allocator for use with initializers is optional.
-      RETURN_IF_ERROR(factory->ep_api.EpDevice_AddAllocatorInfo(ep_device, factory->default_memory_info_.get()));
-      RETURN_IF_ERROR(factory->ep_api.EpDevice_AddAllocatorInfo(ep_device, factory->readonly_memory_info_.get()));
+      RETURN_IF_ERROR(factory->ep_api.EpDevice_AddAllocatorInfo(ep_device, factory->default_memory_info_));
+      RETURN_IF_ERROR(factory->ep_api.EpDevice_AddAllocatorInfo(ep_device, factory->readonly_memory_info_));
 
       ep_devices[num_ep_devices++] = ep_device;
     }
@@ -215,8 +212,8 @@ OrtStatus* ORT_API_CALL ExampleEpFactory::CreateAllocatorImpl(OrtEpFactory* this
   auto& factory = *static_cast<ExampleEpFactory*>(this_ptr);
   *allocator = nullptr;
 
-  bool is_default_allocator = memory_info == factory.default_memory_info_.get();
-  bool is_readonly_allocator = memory_info == factory.readonly_memory_info_.get();
+  bool is_default_allocator = memory_info == factory.default_memory_info_;
+  bool is_readonly_allocator = memory_info == factory.readonly_memory_info_;
 
   if (!is_default_allocator && !is_readonly_allocator) {
     return factory.ort_api.CreateStatus(ORT_INVALID_ARGUMENT,
@@ -244,7 +241,7 @@ OrtStatus* ORT_API_CALL ExampleEpFactory::CreateAllocatorImpl(OrtEpFactory* this
   std::lock_guard<std::mutex> lock{factory.mutex_};
 
   if (!factory.arena_allocator_) {
-    std::unique_ptr<OrtAllocator> ep_allocator = std::make_unique<CustomAllocator>(memory_info, factory);
+    AllocatorUniquePtr ep_allocator = std::make_unique<CustomAllocator>(memory_info, factory);
 
     // initial shared allocator in environment does not have allocator options.
     // if the user calls CreateSharedAllocator they can provide options to configure the arena differently.