fix: Fix logic for parsing model_file_path

Author: ankitm3k

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

@@ -72,14 +72,29 @@ BasicBackend::BasicBackend(std::unique_ptr<ONNX_NAMESPACE::ModelProto>& model_pr
                                   !subgraph_context_.is_ep_ctx_graph);
     if (subgraph_context_.is_ep_ctx_graph) {
       if (subgraph_context_.is_ep_ctx_ovir_encapsulated) {
+        // model_file_path will use so_context_file_path if the onnx_model_path_name is not available,
+        // especially in case of CreateSessionFormArray() where user must explicitly
+        // specify absolute path for so_context_file_path.
+        auto model_file_path = [this]() {
+          if (!session_context_.onnx_model_path_name.empty() &&
+          std::filesystem::exists(session_context_.onnx_model_path_name)) return session_context_.onnx_model_path_name;
+
+          ORT_ENFORCE(!session_context_.so_context_file_path.empty() &&
+          std::filesystem::path(session_context_.so_context_file_path).is_absolute() &&
+          std::filesystem::exists(session_context_.so_context_file_path),
+          log_tag + "Context file path must be non-empty & absolute, when using CreateSessionFormArray() API explicitly."
+          "Please set a valid absolute path for ep.context_file_path in session options.");
+          // Return absolute context file path as input to ImportEPCtxOVIREncapsulation() function.
+          return session_context_.so_context_file_path;
+
+        };
         // 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);
+                                                                    model_file_path());
       } 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

onnxruntime/core/providers/openvino/ov_interface.cc

@@ -38,7 +38,6 @@ void printDebugInfo(const ov::CompiledModel& obj) {
               continue;
             OPENVINO_SUPPRESS_DEPRECATED_END
             std::cout << "    " << item2.first << ": " << item2.second.as<std::string>() << std::endl;
-          }
         }
       } else {
         std::cout << "  " << cfg << ": " << prop.as<std::string>() << std::endl;
@@ -210,29 +209,23 @@ OVExeNetwork OVCore::ImportModel(std::istream& model_stream,
 }
 
 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) {
+                                                  std::string& hw_target,
+                                                  const ov::AnyMap& device_config,
+                                                  bool enable_causallm,
+                                                  std::filesystem::path model_file_path) {
   try {
     OVExeNetwork exe;
 
     bool isXML = backend_utils::IsModelStreamXML(model_stream);
 
-    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) {
+    const auto check_file_access = [&model_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());
+        if (!std::filesystem::exists(path) || std::filesystem::is_empty(path)) {
+          ORT_THROW(log_tag + "Required file missing or empty: " + path.string());
         }
         std::ifstream file(path);
-        if (!file.is_open()) {
+        if (!file) {
           ORT_THROW(log_tag + "Required file not readable: " + path.string());
         }
       } catch (const std::exception& e) {
@@ -243,7 +236,7 @@ OVExeNetwork OVCore::ImportEPCtxOVIREncapsulation(std::istream& model_stream,
     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
-      auto xml_file_path = context_file_path.parent_path() / (context_file_path.stem().string() + ".xml");
+      auto xml_file_path = model_file_path.parent_path() / (model_file_path.stem().string() + ".xml");
 
       check_file_access(xml_file_path);
 
@@ -265,9 +258,9 @@ OVExeNetwork OVCore::ImportEPCtxOVIREncapsulation(std::istream& model_stream,
 #endif
     return exe;
   } catch (const Exception& e) {
-    ORT_THROW(log_tag + " Exception while Loading Network for graph: " + name + e.what());
+    ORT_THROW(log_tag + " Exception while Loading Network from OVIR model file: " + model_file_path.string() + e.what());
   } catch (...) {
-    ORT_THROW(log_tag + " Exception while Loading Network for graph " + name);
+    ORT_THROW(log_tag + " Exception while Loading Network from OVIR model file: " + model_file_path.string());
   }
 }
 

onnxruntime/core/providers/openvino/ov_interface.h

@@ -84,11 +84,10 @@ struct OVCore : WeakSingleton<OVCore> {
                            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::string& hw_target,
+                                            const ov::AnyMap& device_config,
+                                            bool enable_causallm,
+                                            std::filesystem::path model_file_path);
 
   std::vector<std::string> GetAvailableDevices() const;
   std::vector<std::string> GetAvailableDevices(const std::string& device_type) const;