Add test that reuses external initializers from original model

onnxruntime/core/session/onnxruntime_c_api.cc

@@ -2541,9 +2541,17 @@ ORT_API(void, OrtApis::ReleaseExternalInitializerInfo, _Frees_ptr_opt_ OrtExtern
 ORT_API_STATUS_IMPL(OrtApis::CreateExternalInitializerInfo, _In_ const ORTCHAR_T* filepath,
                     _In_ int64_t file_offset, _In_ size_t byte_size, _Outptr_ OrtExternalInitializerInfo** out) {
   API_IMPL_BEGIN
+#if !defined(ORT_MINIMAL_BUILD)
   auto ext_data_info = std::make_unique<onnxruntime::ExternalDataInfo>(filepath, file_offset, byte_size);
   *out = static_cast<OrtExternalInitializerInfo*>(ext_data_info.release());
   return nullptr;
+#else
+  *out = nullptr;
+  ORT_UNUSED_PARAMETER(filepath);
+  ORT_UNUSED_PARAMETER(file_offset);
+  ORT_UNUSED_PARAMETER(byte_size);
+  return OrtApis::CreateStatus(ORT_NOT_IMPLEMENTED, "CreateExternalInitializerInfo() is not supported in this build.");
+#endif
   API_IMPL_END
 }
 

onnxruntime/test/providers/qnn/qnn_ep_context_test.cc

@@ -688,7 +688,7 @@ struct CustomInitializerHandlerState {
 static OrtStatus* ORT_API_CALL TestHandleInitializerDataFunc(void* state,
                                                              const char* initializer_name,
                                                              const OrtValue* initializer_value,
-                                                             const OrtExternalInitializerInfo* external_info,
+                                                             const OrtExternalInitializerInfo* /*external_info*/,
                                                              OrtExternalInitializerInfo** new_external_info) {
   const OrtApi& ort_api = Ort::GetApi();
   CustomInitializerHandlerState* custom_state = reinterpret_cast<CustomInitializerHandlerState*>(state);
@@ -704,20 +704,6 @@ static OrtStatus* ORT_API_CALL TestHandleInitializerDataFunc(void* state,
   // Store other initializers in an external file.
   //
 
-  // If the original initializer was stored in an external file, keep it there (just for testing).
-  if (external_info != nullptr) {
-    const ORTCHAR_T* location = ort_api.ExternalInitializerInfo_GetFilePath(external_info);
-    int64_t offset = ort_api.ExternalInitializerInfo_GetFileOffset(external_info);
-    size_t byte_size = ort_api.ExternalInitializerInfo_GetByteSize(external_info);
-
-    if (OrtStatus* status = ort_api.CreateExternalInitializerInfo(location, offset, byte_size, new_external_info);
-        status != nullptr) {
-      return status;
-    }
-
-    return nullptr;
-  }
-
   // Get initializer's byte size
   size_t byte_size = 0;
   if (OrtStatus* status = ort_api.GetTensorSizeInBytes(initializer_value, &byte_size); status != nullptr) {
@@ -794,6 +780,68 @@ TEST_F(QnnHTPBackendTests, CompileApi_InputFile_OutputFile_InitializerHandler) {
   CheckEpContextNodeCounts(output_model_file, 2, 2);
 }
 
+static OrtStatus* ORT_API_CALL ReuseExternalInitializers(void* state,
+                                                         const char* initializer_name,
+                                                         const OrtValue* initializer_value,
+                                                         const OrtExternalInitializerInfo* external_info,
+                                                         OrtExternalInitializerInfo** new_external_info) {
+  const OrtApi& ort_api = Ort::GetApi();
+
+  // If the original initializer was stored in an external file, keep it there (just for testing).
+  if (external_info != nullptr) {
+    const ORTCHAR_T* location = ort_api.ExternalInitializerInfo_GetFilePath(external_info);
+    int64_t offset = ort_api.ExternalInitializerInfo_GetFileOffset(external_info);
+    size_t byte_size = ort_api.ExternalInitializerInfo_GetByteSize(external_info);
+
+    if (OrtStatus* status = ort_api.CreateExternalInitializerInfo(location, offset, byte_size, new_external_info);
+        status != nullptr) {
+      return status;
+    }
+
+    // Keep track of number of reused external initializers so that we can assert
+    // that we reused the expected number of initializers.
+    // THIS IS TEST CODE. An application would not do this.
+    size_t* num_reused_ext_initializers = reinterpret_cast<size_t*>(state);
+    *num_reused_ext_initializers += 1;
+
+    return nullptr;
+  }
+
+  // If not originally external, save it within the generated compiled model
+  *new_external_info = nullptr;
+  return nullptr;
+}
+
+// Test using the CompileModel() API with settings:
+//   - input model comes from a file
+//   - write output model to a file
+//   - Use callback to specify where each initializer is stored. We'll reuse external initializers
+//     from original model!
+TEST_F(QnnHTPBackendTests, CompileApi_InitializerHandler_ReuseExternalInitializers) {
+  const ORTCHAR_T* input_model_file = ORT_TSTR("testdata/conv_qdq_external_ini.onnx");
+  const ORTCHAR_T* output_model_file = ORT_TSTR("testdata/conv_qdq_external_ini_reuse_ctx.onnx");
+  std::filesystem::remove(output_model_file);
+
+  size_t num_reused_ext_initializers = 0;
+
+  // Create model compilation options from the session options.
+  Ort::SessionOptions so;
+  Ort::ModelCompilationOptions compile_options(*ort_env, so);
+  compile_options.SetInputModelPath(input_model_file);
+  compile_options.SetOutputModelPath(output_model_file);
+  compile_options.SetOutputModelHandleInitializerFunc(ReuseExternalInitializers,
+                                                      reinterpret_cast<void*>(&num_reused_ext_initializers));
+  compile_options.SetEpContextEmbedMode(true);
+
+  // Compile the model.
+  Ort::Status status = Ort::CompileModel(*ort_env, compile_options);
+  ASSERT_TRUE(status.IsOK()) << status.GetErrorMessage();
+  ASSERT_TRUE(std::filesystem::exists(output_model_file));
+  std::filesystem::remove(output_model_file);
+
+  ASSERT_EQ(num_reused_ext_initializers, 2);  // Reused external conv weight and bias.
+}
+
 // Test that the explicit compile API can be configured to return an error if the output model does not
 // have EPContext nodes.
 TEST_F(QnnHTPBackendTests, CompileApi_SetFlags_ErrorIfNoCompiledNodes) {