Add model compilation in ORT perf test (#25797)

This PR adds model compilation support in ort perf test
* Add `--compile_ep_context` flag in onnxruntime_perf_test. This
generates EP context model and prints out compilation time and perf
statistics for the compiled model
* Prints `Compile time cost` for EP context compilation

Sample usage:
```sh
$ ./onnxruntime_perf_test -e trt-rtx -I -r 1 "/path/to/model.onnx" --compile_ep_context --compile_model_path "/path/to/model_ctx.onnx"
```

Output:
```sh
Compile time cost: 17.8012 s
Session creation time cost: 0.966619 s
First inference time cost: 8151 ms
Total inference time cost: 8.08084 s
Total inference requests: 1
Average inference time cost: 8080.84 ms
Total inference run time: 8.08085 s
Number of inferences per second: 0.123749
Avg CPU usage: 6 %
Peak working set size: 7861874688 bytes
Avg CPU usage:6
Peak working set size:7861874688
Runs:1
Min Latency: 8.08084 s
Max Latency: 8.08084 s
P50 Latency: 8.08084 s
P90 Latency: 8.08084 s
P95 Latency: 8.08084 s
P99 Latency: 8.08084 s
P999 Latency: 8.08084 s
```

Author: thevishalagarwal

onnxruntime/test/perftest/command_args_parser.cc

@@ -171,6 +171,9 @@ ABSL_FLAG(std::string, plugin_ep_options, "",
           "--plugin_ep_options \"ep_1_option_1_key|ep_1_option_1_value ...;;ep_3_option_1_key|ep_3_option_1_value ...;... \"");
 ABSL_FLAG(bool, list_ep_devices, false, "Prints all available device indices and their properties (including metadata). This option makes the program exit early without performing inference.\n");
 ABSL_FLAG(std::string, select_ep_devices, "", "Specifies a semicolon-separated list of device indices to add to the session and run with.");
+ABSL_FLAG(bool, compile_ep_context, DefaultPerformanceTestConfig().run_config.compile_ep_context, "Generate an EP context model");
+ABSL_FLAG(std::string, compile_model_path, "model_ctx.onnx", "The compiled model path for saving EP context model. Overwrites if already exists");
+ABSL_FLAG(bool, compile_binary_embed, DefaultPerformanceTestConfig().run_config.compile_binary_embed, "Embed binary blob within EP context node");
 ABSL_FLAG(bool, h, false, "Print program usage.");
 
 namespace onnxruntime {
@@ -487,6 +490,16 @@ bool CommandLineParser::ParseArguments(PerformanceTestConfig& test_config, int a
     if (!select_ep_devices.empty()) test_config.selected_ep_device_indices = select_ep_devices;
   }
 
+  // --compile_ep_context
+  test_config.run_config.compile_ep_context = absl::GetFlag(FLAGS_compile_ep_context);
+
+  // --compile_model_path
+  const auto& compile_model_path = absl::GetFlag(FLAGS_compile_model_path);
+  test_config.run_config.compile_model_path = ToPathString(compile_model_path);
+
+  // --compile_binary_embed
+  test_config.run_config.compile_binary_embed = absl::GetFlag(FLAGS_compile_binary_embed);
+
   if (positional.size() == 2) {
     test_config.model_info.model_file_path = ToPathString(positional[1]);
     test_config.run_config.f_dump_statistics = true;

onnxruntime/test/perftest/main.cc

@@ -13,6 +13,9 @@
 using namespace onnxruntime;
 const OrtApi* g_ort = NULL;
 
+int RunPerfTest(Ort::Env& env, const perftest::PerformanceTestConfig& test_config);
+Ort::Status CompileEpContextModel(const Ort::Env& env, const perftest::PerformanceTestConfig& test_config);
+
 #ifdef _WIN32
 int real_main(int argc, wchar_t* argv[]) {
 #else
@@ -67,24 +70,27 @@ int real_main(int argc, char* argv[]) {
     return 0;
   }
 
-  std::random_device rd;
-  perftest::PerformanceRunner perf_runner(env, test_config, rd);
+  int status = 0;
 
-  // Exit if user enabled -n option so that user can measure session creation time
-  if (test_config.run_config.exit_after_session_creation) {
-    perf_runner.LogSessionCreationTime();
-    return 0;
-  }
+  // EP context perf test
+  if (test_config.run_config.compile_ep_context) {
+    {
+      std::cout << "\n> Compiling model...\n";
+      auto compile_status = CompileEpContextModel(env, test_config);
 
-  auto status = perf_runner.Run();
-  if (!status.IsOK()) {
-    printf("Run failed:%s\n", status.ErrorMessage().c_str());
-    return -1;
-  }
-
-  perf_runner.SerializeResult();
+      if (!compile_status.IsOK())
+        return -1;
+    }
 
-  return 0;
+    {
+      test_config.model_info.model_file_path = test_config.run_config.compile_model_path;
+      status = RunPerfTest(env, test_config);
+    }
+  } else {
+    // regular perf test
+    status = RunPerfTest(env, test_config);
+  }
+  return status;
 }
 
 #ifdef _WIN32
@@ -107,3 +113,54 @@ int main(int argc, char* argv[]) {
 
   return retval;
 }
+
+int RunPerfTest(Ort::Env& env, const perftest::PerformanceTestConfig& test_config) {
+  std::random_device rd;
+  perftest::PerformanceRunner perf_runner(env, test_config, rd);
+
+  // Exit if user enabled -n option so that user can measure session creation time
+  if (test_config.run_config.exit_after_session_creation) {
+    perf_runner.LogSessionCreationTime();
+    return 0;
+  }
+
+  auto status = perf_runner.Run();
+  if (!status.IsOK()) {
+    printf("Run failed:%s\n", status.ErrorMessage().c_str());
+    return -1;
+  }
+
+  perf_runner.SerializeResult();
+  return 0;
+}
+
+Ort::Status CompileEpContextModel(const Ort::Env& env, const perftest::PerformanceTestConfig& test_config) {
+  auto output_ctx_model_path = test_config.run_config.compile_model_path;
+  const auto provider_name = test_config.machine_config.provider_type_name;
+
+  Ort::SessionOptions session_options;
+
+  std::unordered_map<std::string, std::string> provider_options;
+  session_options.AppendExecutionProvider(provider_name, provider_options);
+
+  Ort::ModelCompilationOptions model_compile_options(env, session_options);
+  model_compile_options.SetEpContextEmbedMode(test_config.run_config.compile_binary_embed);
+  model_compile_options.SetInputModelPath(test_config.model_info.model_file_path.c_str());
+  model_compile_options.SetOutputModelPath(output_ctx_model_path.c_str());
+
+  Ort::Status status;
+  std::chrono::duration<double> compile_duration;
+  {
+    auto compile_time_start = std::chrono::high_resolution_clock::now();
+    status = Ort::CompileModel(env, model_compile_options);
+    auto compile_time_end = std::chrono::high_resolution_clock::now();
+    compile_duration = compile_time_end - compile_time_start;
+  }
+
+  if (!status.IsOK()) {
+    std::cout << "Failed to compile model: " << status.GetErrorMessage() << std::endl;
+  } else {
+    std::cout << "Compile time cost: " << compile_duration.count() << " s\n";
+  }
+  return status;
+}

onnxruntime/test/perftest/test_configuration.h

@@ -69,6 +69,9 @@ struct RunConfig {
   std::basic_string<ORTCHAR_T> register_custom_op_path;
   bool enable_cuda_io_binding{false};
   bool use_extensions = false;
+  bool compile_ep_context{false};
+  std::basic_string<ORTCHAR_T> compile_model_path;
+  bool compile_binary_embed{false};
 };
 
 struct PerformanceTestConfig {