fix: refactor plugin code

ankitm3k · ankitm3k · commit b0f08cd79995 · 2025-07-19T21:00:21.000+05:30
diff --git a/onnxruntime/core/providers/openvino/openvino_provider_factory.cc b/onnxruntime/core/providers/openvino/openvino_provider_factory.cc
@@ -5,7 +5,6 @@
 #include <cctype>
 #include <map>
 #include <set>
-#include <sstream>
 
 #include <utility>
 #include "core/providers/shared_library/provider_api.h"
@@ -20,7 +19,6 @@
 
 namespace onnxruntime {
 namespace openvino_ep {
-
 void ParseConfigOptions(ProviderInfo& pi) {
   if (pi.config_options == nullptr)
     return;
@@ -380,7 +378,7 @@ struct OpenVINOProviderFactory : IExecutionProviderFactory {
     // The implementation of the SessionOptionsAppendExecutionProvider C API function automatically adds EP options to
     // the session option configurations with the key prefix "ep.<lowercase_ep_name>.".
     // Extract those EP options into a new "provider_options" map.
-    std::string lowercase_ep_name = "OpenVINOExecutionProvider";
+    std::string lowercase_ep_name = kOpenVINOExecutionProvider;
     std::transform(lowercase_ep_name.begin(), lowercase_ep_name.end(), lowercase_ep_name.begin(), [](unsigned char c) {
       return static_cast<char>(std::tolower(c));
     });
@@ -436,7 +434,7 @@ struct OpenVINO_Provider : Provider {
   }
 
   Status CreateIExecutionProvider(const OrtHardwareDevice* const* /*devices*/,
-                                  const OrtKeyValuePairs* const* /*ep_metadata*/,
+                                  const OrtKeyValuePairs* const* ep_metadata,
                                   size_t num_devices,
                                   ProviderOptions& provider_options,
                                   const OrtSessionOptions& session_options,
@@ -445,12 +443,27 @@ struct OpenVINO_Provider : Provider {
     if (num_devices != 1) {
       return Status(common::ONNXRUNTIME, ORT_EP_FAIL, "OpenVINO EP only supports one device.");
     }
-    std::array<const void*, 2> params{
-        &provider_options,
-        &session_options.GetConfigOptions(),
-    };
-    auto ep_factory = CreateExecutionProviderFactory(&params);
-    ep = ep_factory->CreateProvider(session_options, logger);
+
+    ProviderInfo pi;
+    const auto& config_options = session_options.GetConfigOptions();
+    ParseProviderInfo(provider_options, &config_options, pi);
+
+    const auto& device_meta_data = ep_metadata[0];
+    auto it = device_meta_data->Entries().find("ov_device");
+    if (it == device_meta_data->Entries().end()) {
+      return Status(common::ONNXRUNTIME, ORT_INVALID_ARGUMENT, "OpenVINO EP device metadata not found.");
+    }
+    pi.device_type = it->second;
+
+    /*
+    TODO: This is where we need to perform some checking / manupulation of the session_options before
+    they are passed into CreateProviders() below.
+    Note: pi.device_type is getting set above, but I *think* it will just get overridden by the
+          ParseConfigOptions() that will be done inside of CreateProvider();
+    */
+
+    auto factory = std::make_unique<OpenVINOProviderFactory>(pi, SharedContext::Get());
+    ep = factory->CreateProvider(session_options, logger);
     return Status::OK();
   }
 
@@ -464,106 +477,6 @@ struct OpenVINO_Provider : Provider {
   ProviderInfo_OpenVINO_Impl info_;
 };  // OpenVINO_Provider
 
-// OrtEpApi infrastructure to be able to use the OpenVINO EP as an OrtEpFactory for auto EP selection.
-struct OpenVINOEpFactory : OrtEpFactory {
-  OpenVINOEpFactory(const OrtApi& ort_api_in)
-      : ort_api{ort_api_in} {
-    GetName = GetNameImpl;
-    GetVendor = GetVendorImpl;
-    GetSupportedDevices = GetSupportedDevicesImpl;
-    CreateEp = CreateEpImpl;
-    ReleaseEp = ReleaseEpImpl;
-  }
-
-  static const char* GetNameImpl(const OrtEpFactory*) noexcept {
-    return ep_name;
-  }
-
-  static const char* GetVendorImpl(const OrtEpFactory*) noexcept {
-    return vendor;
-  }
-
-  static OrtStatus* GetSupportedDevicesImpl(OrtEpFactory* ep_factory,
-                                            const OrtHardwareDevice* const* devices,
-                                            size_t num_devices,
-                                            OrtEpDevice** ep_devices,
-                                            size_t max_ep_devices,
-                                            size_t* num_ep_devices) noexcept {
-    if (!ep_factory || !devices || !ep_devices || !num_ep_devices) {
-        return nullptr;
-    }
-
-    *num_ep_devices = 0;
-    const OpenVINOEpFactory* factory = static_cast<const OpenVINOEpFactory*>(ep_factory);
-
-    // Simple device discovery and EP device creation
-    for (size_t i = 0; i < num_devices && *num_ep_devices < max_ep_devices; ++i) {
-        const std::uint32_t vendorId = factory->ort_api.HardwareDevice_VendorId(devices[i]);
-        const char* vendorName = factory->ort_api.HardwareDevice_Vendor(devices[i]);
-
-        // Check if this is an Intel device
-        if ((vendorId == intel_vendor_id) ||
-            (vendorName && std::string(vendorName).find("Intel") != std::string::npos)) {
-
-            const auto device_type = factory->ort_api.HardwareDevice_Type(devices[i]);
-
-            // Map device type to OpenVINO string
-            const char* device_type_str = nullptr;
-            switch (device_type) {
-                case OrtHardwareDeviceType_CPU: device_type_str = "CPU"; break;
-                case OrtHardwareDeviceType_GPU: device_type_str = "GPU"; break;
-                case OrtHardwareDeviceType_NPU: device_type_str = "NPU"; break;
-                default: continue; // Skip unknown device types
-            }
-
-            // Create EP options
-            OrtKeyValuePairs* ep_options = nullptr;
-            factory->ort_api.CreateKeyValuePairs(&ep_options);
-            factory->ort_api.AddKeyValuePair(ep_options, "device_type", device_type_str);
-
-            // Create EP device
-            OrtEpDevice* ep_device = nullptr;
-            OrtStatus* status = factory->ort_api.GetEpApi()->CreateEpDevice(
-                ep_factory, devices[i], nullptr, ep_options, &ep_device);
-
-            factory->ort_api.ReleaseKeyValuePairs(ep_options);
-
-            if (status == nullptr) {
-                ep_devices[(*num_ep_devices)++] = ep_device;
-            } else {
-                return status;
-            }
-        }
-    }
-
-    return nullptr;
-  }
-
-  static OrtStatus* CreateEpImpl(OrtEpFactory* ep_factory,
-                                 const OrtHardwareDevice* const* devices,
-                                 const OrtKeyValuePairs* const* ep_metadata_pairs,
-                                 size_t num_devices,
-                                 const OrtSessionOptions* session_options,
-                                 const OrtLogger* logger,
-                                 OrtEp** ep) noexcept {
-    if (!ep_factory || !ep) {
-        return nullptr;
-    }
-    const OpenVINOEpFactory* factory = static_cast<const OpenVINOEpFactory*>(ep_factory);
-    return factory->ort_api.CreateStatus(ORT_INVALID_ARGUMENT, "OpenVINO EP factory does not support this method.");
-  }
-
-  static void ReleaseEpImpl(OrtEpFactory*, OrtEp*) noexcept {
-    // no-op as we never create an EP here.
-  }
-
-  const OrtApi& ort_api;
-  // Intel vendor ID. Refer to the ACPI ID registry (search Intel): https://uefi.org/ACPI_ID_List
-  static constexpr std::uint32_t intel_vendor_id{0x8086};
-  static constexpr const char* const ep_name{kOpenVINOExecutionProvider};
-  static constexpr const char* const vendor{"Intel Corporation"};
-};
-
 }  // namespace openvino_ep
 }  // namespace onnxruntime
 
@@ -573,37 +486,4 @@ ORT_API(onnxruntime::Provider*, GetProvider) {
   static onnxruntime::openvino_ep::OpenVINO_Provider g_provider;
   return &g_provider;
 }
-
-OrtStatus* CreateEpFactories(const char* /*registration_name*/, const OrtApiBase* ort_api_base,
-                             OrtEpFactory** factories, size_t max_factories, size_t* num_factories) {
-  if (!ort_api_base || !factories || !num_factories) {
-    return nullptr;
-  }
-
-  const OrtApi* ort_api = ort_api_base->GetApi(ORT_API_VERSION);
-  if (!ort_api) {
-    return nullptr;
-  }
-
-  if (max_factories < 1) {
-    return ort_api->CreateStatus(ORT_INVALID_ARGUMENT,
-                                 "Not enough space to return EP factory. Need at least one.");
-  }
-
-  try {
-    factories[0] = new onnxruntime::openvino_ep::OpenVINOEpFactory(*ort_api);
-    *num_factories = 1;
-    return nullptr;
-  } catch (...) {
-    return ort_api->CreateStatus(ORT_FAIL, "Failed to create OpenVINO EP factory.");
-  }
-}
-
-OrtStatus* ReleaseEpFactory(OrtEpFactory* factory) {
-  if (factory) {
-    delete static_cast<onnxruntime::openvino_ep::OpenVINOEpFactory*>(factory);
-  }
-  return nullptr;
-}
-
 }
diff --git a/onnxruntime/core/providers/openvino/ov_factory.cc b/onnxruntime/core/providers/openvino/ov_factory.cc
@@ -0,0 +1,176 @@
+// Copyright (C) Intel Corporation
+// Licensed under the MIT License
+
+#include <memory>
+#include <map>
+#include <string>
+#include <algorithm>
+#include <vector>
+#include <ranges>
+#include <format>
+
+#define ORT_API_MANUAL_INIT
+#include "onnxruntime_cxx_api.h"
+#undef ORT_API_MANUAL_INIT
+
+#include "onnxruntime_c_api.h"
+#include "ov_factory.h"
+#include "openvino/openvino.hpp"
+#include "ov_interface.h"
+
+using namespace onnxruntime::openvino_ep;
+using ov_core_singleton = onnxruntime::openvino_ep::WeakSingleton<ov::Core>;
+
+static void InitCxxApi(const OrtApiBase& ort_api_base) {
+  static std::once_flag init_api;
+  std::call_once(init_api, [&]() {
+    const OrtApi* ort_api = ort_api_base.GetApi(ORT_API_VERSION);
+    Ort::InitApi(ort_api);
+  });
+}
+
+OpenVINOEpPluginFactory::OpenVINOEpPluginFactory(ApiPtrs apis, const std::string& ov_metadevice_name, std::shared_ptr<ov::Core> core)
+    : ApiPtrs{apis},
+      ep_name_(ov_metadevice_name.empty() ? provider_name_ : std::string(provider_name_) + "." + ov_metadevice_name),
+      device_type_(ov_metadevice_name),
+      ov_core_(std::move(core)) {
+  OrtEpFactory::GetName = GetNameImpl;
+  OrtEpFactory::GetVendor = GetVendorImpl;
+  OrtEpFactory::GetVendorId = GetVendorIdImpl;
+  OrtEpFactory::GetSupportedDevices = GetSupportedDevicesImpl;
+  OrtEpFactory::GetVersion = GetVersionImpl;
+  ort_version_supported = ORT_API_VERSION;  // Set to the ORT version we were compiled with.
+}
+
+const std::vector<std::string>& OpenVINOEpPluginFactory::GetOvDevices() {
+  static std::vector<std::string> devices = ov_core_singleton::Get()->get_available_devices();
+  return devices;
+}
+
+const std::vector<std::string>& OpenVINOEpPluginFactory::GetOvMetaDevices() {
+  static std::vector<std::string> virtual_devices = [ov_core = ov_core_singleton::Get()] {
+    std::vector<std::string> supported_virtual_devices{};
+    for (const auto& meta_device : known_meta_devices_) {
+      try {
+        ov_core->get_property(meta_device, ov::supported_properties);
+        supported_virtual_devices.push_back(meta_device);
+      } catch (ov::Exception&) {
+        // meta device isn't supported.
+      }
+    }
+    return supported_virtual_devices;
+  }();
+
+  return virtual_devices;
+}
+
+OrtStatus* OpenVINOEpPluginFactory::GetSupportedDevices(const OrtHardwareDevice* const* devices,
+                                                        size_t num_devices,
+                                                        OrtEpDevice** ep_devices,
+                                                        size_t max_ep_devices,
+                                                        size_t* p_num_ep_devices) {
+  size_t& num_ep_devices = *p_num_ep_devices;
+
+  // Create a map for device type mapping
+  static const std::map<OrtHardwareDeviceType, std::string> ort_to_ov_device_name = {
+      {OrtHardwareDeviceType::OrtHardwareDeviceType_CPU, "CPU"},
+      {OrtHardwareDeviceType::OrtHardwareDeviceType_GPU, "GPU"},
+      {OrtHardwareDeviceType::OrtHardwareDeviceType_NPU, "NPU"},
+  };
+
+  for (size_t i = 0; i < num_devices && num_ep_devices < max_ep_devices; ++i) {
+    const OrtHardwareDevice& device = *devices[i];
+    if (ort_api.HardwareDevice_VendorId(&device) != vendor_id_) {
+      // Not an Intel Device.
+      continue;
+    }
+
+    auto device_type = ort_api.HardwareDevice_Type(&device);
+    auto device_it = ort_to_ov_device_name.find(device_type);
+    if (device_it == ort_to_ov_device_name.end()) {
+      // We don't know about this device type
+      continue;
+    }
+
+    const auto& ov_device_type = device_it->second;
+    std::string ov_device_name;
+    auto get_pci_device_id = [&](const std::string& ov_device) {
+      try {
+        ov::device::PCIInfo pci_info = ov_core_->get_property(ov_device, ov::device::pci_info);
+        return pci_info.device;
+      } catch (ov::Exception&) {
+        return 0u;  // If we can't get the PCI info, we won't have a device ID.
+      }
+    };
+
+    auto filtered_devices = GetOvDevices(ov_device_type);
+    auto matched_device = filtered_devices.begin();
+    if (filtered_devices.size() > 1 && device_type == OrtHardwareDeviceType::OrtHardwareDeviceType_GPU) {
+      // If there are multiple devices of the same type, we need to match by device ID.
+      matched_device = std::find_if(filtered_devices.begin(), filtered_devices.end(), [&](const std::string& ov_device) {
+        uint32_t ort_device_id = ort_api.HardwareDevice_DeviceId(&device);
+        return ort_device_id == get_pci_device_id(ov_device);
+      });
+    }
+
+    if (matched_device == filtered_devices.end()) {
+      // We didn't find a matching OpenVINO device for the OrtHardwareDevice.
+      continue;
+    }
+
+    // these can be returned as nullptr if you have nothing to add.
+    OrtKeyValuePairs* ep_metadata = nullptr;
+    OrtKeyValuePairs* ep_options = nullptr;
+    ort_api.CreateKeyValuePairs(&ep_metadata);
+    ort_api.AddKeyValuePair(ep_metadata, ov_device_key_, matched_device->c_str());
+
+    // Create EP device
+    auto* status = ort_api.GetEpApi()->CreateEpDevice(this, &device, ep_metadata, ep_options,
+                                                      &ep_devices[num_ep_devices++]);
+
+    ort_api.ReleaseKeyValuePairs(ep_metadata);
+    ort_api.ReleaseKeyValuePairs(ep_options);
+
+    if (status != nullptr) {
+      return status;
+    }
+  }
+
+  return nullptr;
+}
+
+extern "C" {
+//
+// Public symbols
+//
+OrtStatus* CreateEpFactories(const char* /*registration_name*/, const OrtApiBase* ort_api_base,
+                             OrtEpFactory** factories, size_t max_factories, size_t* num_factories) {
+  InitCxxApi(*ort_api_base);
+  const ApiPtrs api_ptrs{Ort::GetApi(), Ort::GetEpApi(), Ort::GetModelEditorApi()};
+
+  // Get available devices from OpenVINO
+  auto ov_core = ov_core_singleton::Get();
+  std::vector<std::string> supported_factories = {""};
+  const auto& meta_devices = OpenVINOEpPluginFactory::GetOvMetaDevices();
+  supported_factories.insert(supported_factories.end(), meta_devices.begin(), meta_devices.end());
+
+  const size_t required_factories = supported_factories.size();
+  if (max_factories < required_factories) {
+    return Ort::Status(std::format("Not enough space to return EP factories. Need at least {} factories.", required_factories).c_str(), ORT_INVALID_ARGUMENT);
+  }
+
+  size_t factory_index = 0;
+  for (const auto& device_name : supported_factories) {
+    // Create a factory for this specific device
+    factories[factory_index++] = new OpenVINOEpPluginFactory(api_ptrs, device_name, ov_core);
+  }
+
+  *num_factories = factory_index;
+  return nullptr;
+}
+
+OrtStatus* ReleaseEpFactory(OrtEpFactory* factory) {
+  delete static_cast<OpenVINOEpPluginFactory*>(factory);
+  return nullptr;
+}
+}
diff --git a/onnxruntime/core/providers/openvino/ov_factory.h b/onnxruntime/core/providers/openvino/ov_factory.h
