[VitisAI] Add External EP Loader (#26627)

## [VitisAI] Add External EP Loader

### Description

This PR introduces a dynamic external execution provider loading
mechanism for the VitisAI execution provider, enabling runtime loading
of alternative execution providers through a plugin-style architecture.

### Key Changes

#### 1. **New External EP Library Infrastructure** (`global_api.cc`)
- Added `ExternalEpLibaray` class to dynamically load external execution
provider libraries at runtime
- Implemented complete library lifecycle management (loading, unloading,
symbol resolution)
- Added global registry (`g_external_ep_libaries`) with caching to avoid
redundant library loading
- Created `CreateExecutionProviderFromAnotherEp()` function to
instantiate execution providers from external libraries

**Implementation Details:**
- **Simplified symbol resolution**: Only resolves the essential
`GetProvider` symbol (required)
- **Removed optional symbols**: No longer attempts to resolve
`CreateEpFactories` or `RyzenAI_SetSessionOptions`
- Lazy initialization pattern with `Ensure()` method
- Safe cleanup with `Clear()` method and proper error handling
- Platform-agnostic library loading using `LIBRARY_PREFIX` and
`LIBRARY_EXTENSION` macros

#### 2. **API Extension** (`global_api.h`)
- Declared new public function: `CreateExecutionProviderFromAnotherEp()`
- Added required includes:
- `core/framework/execution_provider.h` for `IExecutionProvider`
interface
  - `<memory>` for smart pointer support

#### 3. **Factory Integration** (`vitisai_provider_factory.cc`)
- Integrated external EP loading into the VitisAI provider factory
workflow
- Added provider option check for `external_ep_libray` key
- **Logic Flow**:
  1. Check if `external_ep_libray` option is specified
  2. If yes, load and return the external execution provider
  3. If no, create and return standard VitisAI execution provider

Co-authored-by: Yueqing Zhang <[email protected]>

Author: BoarQing

onnxruntime/core/providers/vitisai/imp/global_api.cc

@@ -611,3 +611,53 @@ vaip_core::OrtApiForVaip* create_org_api_hook() {
     return &the_global_api;
   }
 }
+
+struct ExternalEpLibaray {
+  ExternalEpLibaray(const std::string& libray_name) : libray_name_{libray_name} {
+    Ensure();
+  }
+  onnxruntime::Provider* (*get_provider_api)();
+  void (*create_ep_factories)(void*, const OrtApiBase*, void*, OrtEpFactory**, size_t, size_t*);
+  void (*set_session_option)(OrtSessionOptions*);
+
+  void Ensure() {
+    if (handle_)
+      return;
+    auto& env = Provider_GetHost()->Env__Default();
+    auto library_filename = PathString(LIBRARY_PREFIX) + PathString(libray_name_.begin(), libray_name_.end()) + LIBRARY_EXTENSION;
+    auto full_path = env.GetRuntimePath() + library_filename;
+    ORT_THROW_IF_ERROR(env.LoadDynamicLibrary(full_path, true, &handle_));
+    ORT_THROW_IF_ERROR(env.GetSymbolFromLibrary(handle_, "GetProvider", (void**)&get_provider_api));
+  }
+
+  void Clear() {
+    if (handle_) {
+      auto& env = Provider_GetHost()->Env__Default();
+      auto status = env.UnloadDynamicLibrary(handle_);
+      vai_assert(status.IsOK(), status.ErrorMessage());
+      handle_ = nullptr;
+    }
+  }
+
+ private:
+  std::string libray_name_;
+  void* handle_{};
+};
+static std::unordered_map<std::string, std::unique_ptr<ExternalEpLibaray>> g_external_ep_libaries;
+
+std::unique_ptr<onnxruntime::IExecutionProvider>
+CreateExecutionProviderFromAnotherEp(const std::string& lib, const OrtSessionOptions& session_options,
+                                     std::unordered_map<std::string, std::string>& provider_options) {
+  auto it = g_external_ep_libaries.find(lib);
+  if (it == g_external_ep_libaries.end()) {
+    it = g_external_ep_libaries.emplace(lib, std::make_unique<ExternalEpLibaray>(lib)).first;
+  }
+  auto ep_lib = it->second.get();
+  auto get_provider_func = ep_lib->get_provider_api;
+  auto provider = get_provider_func();
+  std::unique_ptr<onnxruntime::IExecutionProvider> ret;
+  provider->Initialize();
+  std::ignore = provider->CreateIExecutionProvider(nullptr, nullptr, 0, const_cast<onnxruntime::ProviderOptions&>(provider_options), session_options, *((OrtLogger*)nullptr), ret);
+
+  return ret;
+}

onnxruntime/core/providers/vitisai/include/vaip/global_api.h

@@ -6,10 +6,12 @@
 #define ORT_API_MANUAL_INIT
 #include "core/session/onnxruntime_cxx_api.h"
 #include "core/framework/provider_options.h"
+#include "core/framework/execution_provider.h"
 #include "vaip/my_ort.h"
 #include "vaip/dll_safe.h"
 #include "vaip/custom_op.h"
 #include <optional>
+#include <memory>
 void initialize_vitisai_ep();
 void deinitialize_vitisai_ep();
 vaip_core::DllSafe<std::vector<std::unique_ptr<vaip_core::ExecutionProvider>>> compile_onnx_model(const onnxruntime::GraphViewer& graph_viewer, const onnxruntime::logging::Logger& logger, const onnxruntime::ProviderOptions& options);
@@ -40,3 +42,6 @@ using EventInfo = std::tuple<
 void profiler_collect(
     std::vector<EventInfo>& api_events,
     std::vector<EventInfo>& kernel_events);
+std::unique_ptr<onnxruntime::IExecutionProvider>
+CreateExecutionProviderFromAnotherEp(const std::string& lib, const OrtSessionOptions& session_options,
+                                     std::unordered_map<std::string, std::string>& provider_options);

onnxruntime/core/providers/vitisai/vitisai_provider_factory.cc

@@ -7,7 +7,6 @@
 #include <cctype>
 #include <unordered_map>
 #include <string>
-
 #include "vaip/global_api.h"
 #include "./vitisai_execution_provider.h"
 #include "core/framework/execution_provider.h"
@@ -57,6 +56,10 @@ std::unique_ptr<IExecutionProvider> VitisAIProviderFactory::CreateProvider(const
     }
   }
 
+  auto it = provider_options.find("external_ep_libray");
+  if (it != provider_options.end()) {
+    return CreateExecutionProviderFromAnotherEp(it->second, session_options, provider_options);
+  }
   auto ep_instance = std::make_unique<VitisAIExecutionProvider>(provider_options);
   ep_instance->SetLogger(reinterpret_cast<const logging::Logger*>(&session_logger));
   return ep_instance;