Add EPContext helper fallback coverage

Author: Gopalakrishnan Nallasamy

onnxruntime/test/autoep/library/ep_context_data_utils.h

@@ -203,7 +203,8 @@ inline OrtStatus* ReadEpContextDataWithFileFallback(const OrtApi& api, const Ort
 
 inline OrtStatus* WriteEpContextDataWithFileFallback(const OrtApi& api, const OrtEpApi& ep_api,
                                                      const OrtEpContextConfig* ep_context_config,
-                                                     const char* file_name, const OrtGraph* graph,
+                                                     const char* file_name, const char* fallback_file_name,
+                                                     const OrtGraph* graph,
                                                      const void* buffer, size_t buffer_size) {
   if (file_name == nullptr || file_name[0] == '\0') {
     return api.CreateStatus(ORT_INVALID_ARGUMENT, "EPContext data file name must not be empty");
@@ -223,7 +224,19 @@ inline OrtStatus* WriteEpContextDataWithFileFallback(const OrtApi& api, const Or
     return write_func(write_state, file_name, buffer, buffer_size);
   }
 
-  return WriteEpContextDataToFile(api, file_name, graph, buffer, buffer_size);
+  if (fallback_file_name == nullptr || fallback_file_name[0] == '\0') {
+    return api.CreateStatus(ORT_INVALID_ARGUMENT, "EPContext data fallback file name must not be empty");
+  }
+
+  return WriteEpContextDataToFile(api, fallback_file_name, graph, buffer, buffer_size);
+}
+
+inline OrtStatus* WriteEpContextDataWithFileFallback(const OrtApi& api, const OrtEpApi& ep_api,
+                                                     const OrtEpContextConfig* ep_context_config,
+                                                     const char* file_name, const OrtGraph* graph,
+                                                     const void* buffer, size_t buffer_size) {
+  return WriteEpContextDataWithFileFallback(api, ep_api, ep_context_config, file_name, file_name, graph, buffer,
+                                            buffer_size);
 }
 
 }  // namespace ep_context_data_utils

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

@@ -7,6 +7,7 @@
 #include <atomic>
 #include <cassert>
 #include <cstring>
+#include <filesystem>
 #include <memory>
 #include <string>
 #include <unordered_map>
@@ -538,9 +539,21 @@ OrtStatus* ExampleEp::CreateEpContextNodes(const OrtGraph* graph,
       std::string ep_ctx = config_.embed_ep_context_in_model ? "binary_data" : fused_node_name + ".ctx";
       if (!config_.embed_ep_context_in_model) {
         const std::string ep_context_data = "binary_data";
+        std::string fallback_ep_ctx = ep_ctx;
+        const OrtGraph* fallback_graph = graph;
+        if (!config_.ep_context_output_model_path.empty()) {
+          const std::filesystem::path output_model_path =
+              ep_context_data_utils::Utf8Path(config_.ep_context_output_model_path.c_str());
+          const std::filesystem::path output_model_dir = output_model_path.parent_path();
+          if (!output_model_dir.empty()) {
+            fallback_ep_ctx = ep_context_data_utils::PathToUtf8String(
+                output_model_dir / ep_context_data_utils::Utf8Path(ep_ctx.c_str()));
+          }
+          fallback_graph = nullptr;
+        }
         RETURN_IF_ERROR(ep_context_data_utils::WriteEpContextDataWithFileFallback(
-            ort_api, ep_api, ep_context_config_, ep_ctx.c_str(), graph, ep_context_data.data(),
-            ep_context_data.size()));
+            ort_api, ep_api, ep_context_config_, ep_ctx.c_str(), fallback_ep_ctx.c_str(), fallback_graph,
+            ep_context_data.data(), ep_context_data.size()));
       }
       attributes[0] = Ort::OpAttr("ep_cache_context", ep_ctx.data(), static_cast<int>(ep_ctx.size()),
                                   ORT_OP_ATTR_STRING);

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

@@ -63,6 +63,7 @@ class ExampleEp : public OrtEp, public ApiPtrs {
     bool enable_ep_context = false;
     bool embed_ep_context_in_model = true;
     bool enable_weightless_ep_context_nodes = false;
+    std::string ep_context_output_model_path;
     // Other EP configs (typically extracted from OrtSessionOptions or OrtHardwareDevice(s))
   };
 

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

@@ -218,17 +218,21 @@ OrtStatus* ORT_API_CALL ExampleEpFactory::CreateEpImpl(OrtEpFactory* this_ptr,
   // Note: should not store a direct reference to the session options object as its lifespan is not guaranteed.
   std::string ep_context_enable;
   std::string ep_context_embed_mode;
+  std::string ep_context_output_model_path;
   std::string weightless_ep_context_nodes_enable;
   RETURN_IF_ERROR(GetSessionConfigEntryOrDefault(*session_options, kOrtSessionOptionEpContextEnable, "0",
                                                  ep_context_enable));
   RETURN_IF_ERROR(GetSessionConfigEntryOrDefault(*session_options, kOrtSessionOptionEpContextEmbedMode, "1",
                                                  ep_context_embed_mode));
+  RETURN_IF_ERROR(GetSessionConfigEntryOrDefault(*session_options, kOrtSessionOptionEpContextFilePath, "",
+                                                 ep_context_output_model_path));
   RETURN_IF_ERROR(GetSessionConfigEntryOrDefault(*session_options, kOrtSessionOptionEpEnableWeightlessEpContextNodes,
                                                  "0", weightless_ep_context_nodes_enable));
 
   ExampleEp::Config config = {};
   config.enable_ep_context = ep_context_enable == "1";
   config.embed_ep_context_in_model = ep_context_embed_mode != "0";
+  config.ep_context_output_model_path = std::move(ep_context_output_model_path);
   config.enable_weightless_ep_context_nodes = weightless_ep_context_nodes_enable == "1";
 
   OrtEpContextConfig* ep_context_config_raw = nullptr;