fix: refactor EpCtx OVIR parsing logic to use ep.context_file_path

Author: ankitm3k

onnxruntime/core/providers/openvino/backend_manager.cc

@@ -43,6 +43,8 @@ BackendManager::BackendManager(SessionContext& session_context,
                                                               session_context_(session_context),
                                                               shared_context_{shared_context} {
   subgraph_context_.is_ep_ctx_graph = ep_ctx_handle_.CheckForOVEPCtxNodeInGraph(subgraph);
+  // If the graph contains a OVIR wrapped node, we check if it has xml file attribute
+  subgraph_context_.is_ep_ctx_ovir_encapsulated = ep_ctx_handle_.CheckEPCacheContextAttribute(subgraph, "xml");
 
   bool cpu_or_gpu = session_context_.device_type.find("CPU") != std::string::npos ||
                     session_context_.device_type.find("GPU") != std::string::npos;

onnxruntime/core/providers/openvino/backends/basic_backend.cc

@@ -71,13 +71,23 @@ BasicBackend::BasicBackend(std::unique_ptr<ONNX_NAMESPACE::ModelProto>& model_pr
                                   !session_context_.so_disable_cpu_ep_fallback &&
                                   !subgraph_context_.is_ep_ctx_graph);
     if (subgraph_context_.is_ep_ctx_graph) {
-      // If the blob is held in an EPContext node, then skip FE+Compile
-      // and directly move on to creating a backend with the executable blob
-      exe_network_ = OVCore::Get()->ImportModel(*model_stream,
-                                                hw_target,
-                                                device_config,
-                                                enable_causallm,
-                                                session_context_.onnx_model_path_name.string());
+      if (subgraph_context_.is_ep_ctx_ovir_encapsulated) {
+        // If the EPContext node with OVIR Encapsulation, then create
+        // an executable network from EP_CACHE_CONTEXT using read_model() & compile_model()
+        exe_network_ = OVCore::Get()->ImportEPCtxOVIREncapsulation(*model_stream,
+                                                                    hw_target,
+                                                                    device_config,
+                                                                    enable_causallm,
+                                                                    session_context_.so_context_file_path,
+                                                                    subgraph_context_.subgraph_name);
+      } else {
+        // If the blob is held in an EPContext node, then skip FE+Compile
+        // and directly move on to creating a backend with the executable blob
+        exe_network_ = OVCore::Get()->ImportModel(*model_stream,
+                                                  hw_target,
+                                                  device_config,
+                                                  subgraph_context_.subgraph_name);
+      }
       model_stream.reset();  // Delete stream after it is no longer needed
     } else if (!session_context_.has_external_weights &&
                !subgraph_context_.has_dynamic_input_shape &&

onnxruntime/core/providers/openvino/contexts.h

@@ -137,6 +137,7 @@ struct SubGraphContext {
   string_index_map_t output_names;
   std::string model_precision;
   bool is_ep_ctx_graph = false;
+  bool is_ep_ctx_ovir_encapsulated = false;
 };
 
 }  // namespace openvino_ep

onnxruntime/core/providers/openvino/onnx_ctx_model_helper.cc

@@ -130,7 +130,7 @@ std::unique_ptr<std::istream> EPCtxHandler::GetModelBlobStream(const std::filesy
     // If the model stream is not an XML (i.e. precompiled blob), the OpenVINO SDK version that it was
     // exported with must match the version that is currently running.
     ORT_ENFORCE((attrs.count(EP_SDK_VER) == 1) && (attrs.at(EP_SDK_VER).s() == openvino_sdk_version_),
-                "EPCtx blob was exported / is compatible with with OpenVINO SDK version " + attrs.at(EP_SDK_VER).s() +
+                "EPCtx blob was exported / is compatible with OpenVINO SDK version " + attrs.at(EP_SDK_VER).s() +
                   ", but OpenVINO SDK version currently in use is " + openvino_sdk_version_);
   }
 
@@ -165,5 +165,32 @@ InlinedVector<const Node*> EPCtxHandler::GetEPCtxNodes() const {
   return InlinedVector<const Node*>(epctx_nodes.begin(), epctx_nodes.end());
 }
 
+// Check if graph's only node is EPContext & EP_CACHE_CONTEXT attribute has target extension.
+// @param graph_viewer: The graph to inspect.
+// @param target_attr_extn: The string to search for in the EP_CACHE_CONTEXT attribute.
+// @return true if the node exists, is of the correct type, and the attribute contains the extension; false otherwise.
+bool EPCtxHandler::CheckEPCacheContextAttribute(const GraphViewer& graph_viewer, const std::string& target_attr_extn) const {
+  // Only check if the graph has exactly one node
+  if (graph_viewer.NumberOfNodes() != 1) {
+    return false;
+  }
+  // Get the first node in topological order
+  auto first_index = *graph_viewer.GetNodesInTopologicalOrder().begin();
+  const Node* node = graph_viewer.GetNode(first_index);
+  if (!node) {
+    return false;
+  }
+  // Check OpType and required attributes
+  if (node->OpType() != EPCONTEXT_OP) {
+    return false;
+  }
+  const auto& attrs = node->GetAttributes();
+  auto it = attrs.find(EP_CACHE_CONTEXT);
+  if (it != attrs.end()) {
+    return it->second().s().find(target_attr_extn) != std::string::npos;
+  }
+  return false;
+}
+
 }  // namespace openvino_ep
 }  // namespace onnxruntime

onnxruntime/core/providers/openvino/onnx_ctx_model_helper.h

@@ -33,6 +33,7 @@ class EPCtxHandler {
                                std::string&& model_blob_str) const;
   std::unique_ptr<std::istream> GetModelBlobStream(const std::filesystem::path& so_context_file_path, const GraphViewer& graph_viewer) const;
   InlinedVector<const Node*> GetEPCtxNodes() const;
+  bool CheckEPCacheContextAttribute(const GraphViewer& graph_viewer, const std::string& target_attr_extn) const;
 
  private:
   const std::string openvino_sdk_version_;

onnxruntime/core/providers/openvino/ov_interface.cc

@@ -191,30 +191,66 @@ OVExeNetwork OVCore::CompileModel(const std::string& onnx_model,
 }
 
 OVExeNetwork OVCore::ImportModel(std::istream& model_stream,
+                                 std::string hw_target,
+                                 const ov::AnyMap& device_config,
+                                 std::string name) {
+  try {
+    ov::CompiledModel obj;
+    obj = core.import_model(model_stream, hw_target, device_config);
+#ifndef NDEBUG
+    printDebugInfo(exe.Get());
+#endif
+    OVExeNetwork exe(obj, hw_target);
+    return exe;
+  } catch (const Exception& e) {
+    ORT_THROW(log_tag + " Exception while Loading Network for graph: " + name + e.what());
+  } catch (...) {
+    ORT_THROW(log_tag + " Exception while Loading Network for graph " + name);
+  }
+}
+
+OVExeNetwork OVCore::ImportEPCtxOVIREncapsulation(std::istream& model_stream,
                                  std::string hw_target,
                                  const ov::AnyMap& device_config,
                                  bool enable_causallm,
+                                 std::filesystem::path context_file_path,
                                  std::string name) {
   try {
     OVExeNetwork exe;
 
     bool isXML = backend_utils::IsModelStreamXML(model_stream);
 
-    if (!isXML) {
-      auto obj = core.import_model(model_stream, hw_target, device_config);
-      exe = OVExeNetwork(obj, hw_target);
-    } else {
+    ORT_ENFORCE(!context_file_path.string().empty(),
+                "The session option ep.context_file_path is not set for EPContext node with OVIR Encapsulation. "
+                "Current value: '" + context_file_path.string() + "'");
+
+    // Helper function to check if file exists and is readable
+    const auto check_file_access = [&context_file_path](const std::filesystem::path& path) {
+      try {
+        const auto status = std::filesystem::status(path);
+        if (!std::filesystem::exists(status)) {
+          ORT_THROW(log_tag + "Required file missing: " + path.string());
+        }
+        std::ifstream file(path);
+        if (!file.is_open()) {
+          ORT_THROW(log_tag + "Required file not readable: " + path.string());
+        }
+      } catch (const std::exception& e) {
+        ORT_THROW(log_tag + "Exception while checking file access for: " + path.string() + " - " + e.what());
+      }
+    };
+
+    if (isXML) {
       // If the model is XML, we need to load it with the XML content in read_model()
       // where weights from bin file is directly consumed
-      std::string xml_file_name = name;
-      if (name.size() >= 5 && name.substr(name.size() - 5) == ".onnx") {
-        xml_file_name.replace(name.size() - 5, 5, ".xml");
-      } else {
-        throw std::runtime_error("Invalid model name. Make sure *.onnx, *.xml, and *.bin carry the same name.");
-      }
+      auto xml_file_path = context_file_path.parent_path() / (context_file_path.stem().string() + ".xml");
+
+      check_file_access(xml_file_path);
+
+      LOGS_DEFAULT(INFO) << log_tag << "Reading OVIR from XML file path: " << xml_file_path.string();
 
       // Load the model explicitly with XML contents
-      std::shared_ptr<ov::Model> model = core.read_model(xml_file_name);
+      std::shared_ptr<ov::Model> model = core.read_model(xml_file_path.string());
 
       if (enable_causallm) {
         exe = OVCore::Get()->StatefulCompileModel(model, hw_target, device_config);

onnxruntime/core/providers/openvino/ov_interface.h

@@ -80,10 +80,16 @@ struct OVCore : WeakSingleton<OVCore> {
                             const std::string& name);
   // OV Interface for Import model Stream
   OVExeNetwork ImportModel(std::istream& model_stream,
+                           std::string hw_target,
+                           const ov::AnyMap& device_config,
+                           std::string name);
+  OVExeNetwork ImportEPCtxOVIREncapsulation(std::istream& model_stream,
                            std::string hw_target,
                            const ov::AnyMap& device_config,
                            bool enable_causallm,
+                           std::filesystem::path context_file_path,
                            std::string name);
+
   std::vector<std::string> GetAvailableDevices() const;
   std::vector<std::string> GetAvailableDevices(const std::string& device_type) const;
   void SetCache(const std::string& cache_dir_path);