Avoid empty temp external initializer file creation inside the call (#25188)

### Description
While EPContext model generation is enabled and some Nodes fallback on CPU. If the CPU nodes depend on external data. ORT force all external data to be embedded into new generated EPContext model by default. Ort
used to create a dummy externa initializer file with maximum size threshold to force all initializer data dump into generated Onnx model file. Internally, a "./model_ext_ini.bin" file is created and got removed at the end of the call. It causes problem if multiple session doing the same thing.
This fix is to avoid creating the temp empty external initializer file by adding a flag to force all external data to be embedded into new generated EPContext model.

Author: HectorSVC

include/onnxruntime/core/graph/model_saving_options.h

@@ -39,6 +39,9 @@ struct ModelSavingOptions {
 #else
   int64_t allocation_granularity = 4096;
 #endif
+  // Force embed all external initializer into the Onnx file
+  // Used for EPContext model generation while some nodes fallback on CPU which has external data dependency
+  bool force_embed_external_ini = false;
 };
 
 }  // namespace onnxruntime

onnxruntime/core/framework/graph_partitioner.cc

@@ -911,13 +911,16 @@ static Status CreateEpContextModel(const ExecutionProviders& execution_providers
 
   size_t ini_size_threshold = ep_context_gen_options.output_external_initializer_size_threshold;
   std::filesystem::path external_ini_path = ep_context_gen_options.output_external_initializers_file_path;
+  bool force_embed_external_ini = false;
   if (external_ini_path.empty()) {
-    // Set the threshold to the max so all initializers are forced into the Onnx file
+    // if no external ini file specified, set force_embed_external_ini to true to avoid intermedia file creation
+    // and force all initializers embed into the Onnx file
     ini_size_threshold = SIZE_MAX;
-    external_ini_path = "./model_ext_ini.bin";
+    force_embed_external_ini = true;
   }
 
   ModelSavingOptions model_saving_options{ini_size_threshold};
+  model_saving_options.force_embed_external_ini = force_embed_external_ini;
 
   if (saving_to_buffer) {
     ORT_RETURN_IF_ERROR(ep_context_model.MainGraph().Resolve());

onnxruntime/core/graph/graph.cc

@@ -4345,7 +4345,8 @@ Status Graph::AddExternalInitializersToGraphProtoImpl(
       std::vector<uint8_t> raw_data;
       ORT_RETURN_IF_ERROR(utils::UnpackInitializerData(initializer, model_path, raw_data));
       size_t tensor_bytes_size = raw_data.size();
-      if (tensor_bytes_size < model_saving_options.initializer_size_threshold) {
+      if (model_saving_options.force_embed_external_ini ||
+          tensor_bytes_size < model_saving_options.initializer_size_threshold) {
         *output_proto = initializer;
         // Data with size above the threshold is written into the new external initializer file
         // Data with size below the threshold should be kept inside the new model file
@@ -4441,25 +4442,31 @@ ONNX_NAMESPACE::GraphProto Graph::ToGraphProtoWithExternalInitializers(
   const std::filesystem::path modified_external_file_path = model_file_path.parent_path() / external_file_path;
   const auto& model_path = ModelPath();
 
-  // Create the external file.
-  std::ofstream external_stream(modified_external_file_path, std::ofstream::out | std::ofstream::binary);
-  auto const external_empty_pos = external_stream.tellp();
-  ORT_ENFORCE(external_stream.is_open(), "Failed to open for writing:", modified_external_file_path);
+  std::ofstream external_stream;
+  std::streampos external_empty_pos;
   int64_t external_offset = 0;
+  if (!model_saving_options.force_embed_external_ini) {
+    // Create the external file.
+    external_stream.open(modified_external_file_path, std::ofstream::out | std::ofstream::binary);
+    external_empty_pos = external_stream.tellp();
+    ORT_ENFORCE(external_stream.is_open(), "Failed to open for writing:", modified_external_file_path);
+  }
 
   ORT_THROW_IF_ERROR(AddExternalInitializersToGraphProtoImpl(model_path, external_file_path,
                                                              modified_external_file_path, model_saving_options,
                                                              result,
                                                              external_stream, external_offset));
 
-  if (!external_stream.flush()) {
-    ORT_THROW("Failed to flush file with external initializers: ", modified_external_file_path);
-  }
+  if (!model_saving_options.force_embed_external_ini) {
+    if (!external_stream.flush()) {
+      ORT_THROW("Failed to flush file with external initializers: ", modified_external_file_path);
+    }
 
-  // Delete if the external data file is empty
-  if (external_empty_pos == external_stream.tellp()) {
-    external_stream.close();
-    std::remove(modified_external_file_path.string().c_str());
+    // Delete if the external data file is empty
+    if (external_empty_pos == external_stream.tellp()) {
+      external_stream.close();
+      std::remove(modified_external_file_path.string().c_str());
+    }
   }
 
   return result;

onnxruntime/test/providers/qnn/qnn_ep_context_test.cc

@@ -748,7 +748,7 @@ TEST_F(QnnHTPBackendTests, QnnContextBinaryMultiPartitionSupport2) {
   QnnContextBinaryMultiPartitionTestBody(single_ep_node);
 }
 
-void EpCtxCpuNodeWithExternalIniFileTestBody(bool expect_external_ini_file) {
+void EpCtxCpuNodeWithExternalIniFileTestBody(bool expect_external_ini_file, bool load_model_from_buffer = false) {
   ProviderOptions provider_options;
   provider_options["backend_type"] = "htp";
 
@@ -787,7 +787,22 @@ void EpCtxCpuNodeWithExternalIniFileTestBody(bool expect_external_ini_file) {
     so.AddConfigEntry(kOrtSessionOptionsEpContextModelExternalInitializersFileName, external_ini_file.c_str());
   }  // otherwise all initializers are in Onnx file, no external data file generated
 
-  Ort::Session session(*ort_env, ToPathString(model_with_ext).c_str(), so);
+  if (load_model_from_buffer) {
+    std::vector<char> buffer;
+    {
+      std::ifstream file(model_with_ext, std::ios::binary | std::ios::ate);
+      if (!file)
+        ORT_THROW("Error reading model");
+      buffer.resize(narrow<size_t>(file.tellg()));
+      file.seekg(0, std::ios::beg);
+      if (!file.read(buffer.data(), buffer.size()))
+        ORT_THROW("Error reading model");
+    }
+    so.AddConfigEntry(kOrtSessionOptionsModelExternalInitializersFileFolderPath, "./testdata/");
+    Ort::Session session(*ort_env, buffer.data(), buffer.size(), so);
+  } else {
+    Ort::Session session(*ort_env, ToPathString(model_with_ext).c_str(), so);
+  }
 
   EXPECT_TRUE(std::filesystem::exists(ep_context_model_file.c_str()));
   if (expect_external_ini_file) {
@@ -803,18 +818,25 @@ void EpCtxCpuNodeWithExternalIniFileTestBody(bool expect_external_ini_file) {
   CleanUpCtxFile(ep_context_model_file);
 }
 
-// Set the external initializer size threshold to 1024 so FusedMatMul (which fallback on CPU)
+// Set the session option "ep.context_model_external_initializers_file_name" so FusedMatMul (which fallback on CPU)
 // will dump initializer data to external file
 TEST_F(QnnHTPBackendTests, QnnContextBinaryCpuNodeWithExternalWeights) {
   EpCtxCpuNodeWithExternalIniFileTestBody(true);
 }
 
-// Use the default external initializer size threshold (1024000) so FusedMatMul (which fallback on CPU)
-// will NOT dump initializer data to external file
+// Without setting the session option "ep.context_model_external_initializers_file_name"
+// so FusedMatMul (which fallback on CPU) will NOT dump initializer data to external file
 TEST_F(QnnHTPBackendTests, QnnContextBinaryCpuNodeWithoutExternalWeights) {
   EpCtxCpuNodeWithExternalIniFileTestBody(false);
 }
 
+// Load model from memory
+// Without setting the session option "ep.context_model_external_initializers_file_name"
+// so FusedMatMul (which fallback on CPU) will NOT dump initializer data to external file
+TEST_F(QnnHTPBackendTests, QnnContextBinaryCpuNodeWithoutExternalWeightsModelFromMemory) {
+  EpCtxCpuNodeWithExternalIniFileTestBody(false, true);
+}
+
 // Set ep.context_file_path to folder path which is not a valid option, check the error message
 TEST_F(QnnHTPBackendTests, QnnContextBinaryGenerationFolderPathNotExpected) {
   ProviderOptions provider_options;