allow EP to be selected

Author: edgchen1

mobile/examples/model_tester/common/include/model_runner.h

@@ -5,24 +5,42 @@
 #include <chrono>
 #include <optional>
 #include <string>
+#include <unordered_map>
 #include <vector>
 
 namespace model_runner {
 
+using Clock = std::chrono::steady_clock;
+using Duration = Clock::duration;
+
 struct RunConfig {
+  // Path to the model to run.
   std::string model_path{};
 
-  size_t num_warmup_iterations{};
-  size_t num_iterations{};
+  // Whether to run a warmup iteration before running the measured (timed) iterations.
+  bool run_warmup_iteration{true};
+
+  // Number of iterations to run.
+  size_t num_iterations{10};
+
+  // Configuration for an Execution Provider (EP).
+  struct EpConfig {
+    std::string provider_name{};
+    std::unordered_map<std::string, std::string> provider_options{};
+  };
 
+  // Specifies the EP to use in the session.
+  std::optional<EpConfig> ep{};
+
+  // Specifies the onnxruntime log level.
   std::optional<int> log_level{};
 };
 
-using Clock = std::chrono::steady_clock;
-using Duration = Clock::duration;
-
 struct RunResult {
+  // Time taken to load the model.
   Duration load_duration;
+
+  // Times taken to run the model.
   std::vector<Duration> run_durations;
 };
 

mobile/examples/model_tester/common/model_runner.cpp

@@ -177,6 +177,10 @@ RunResult Run(const RunConfig& run_config) {
 
   auto session_options = Ort::SessionOptions{};
 
+  if (const auto& ep_config = run_config.ep; ep_config.has_value()) {
+    session_options.AppendExecutionProvider(ep_config->provider_name, ep_config->provider_options);
+  }
+
   Timer timer{};
   auto session = Ort::Session{env, run_config.model_path.c_str(), session_options};
   run_result.load_duration = timer.Elapsed();
@@ -191,15 +195,16 @@ RunResult Run(const RunConfig& run_config) {
 
   auto run_options = Ort::RunOptions{};
 
+  run_result.run_durations.reserve(run_config.num_iterations);
+
   // warmup
-  for (size_t i = 0; i < run_config.num_warmup_iterations; ++i) {
+  if (run_config.run_warmup_iteration) {
     auto outputs = session.Run(run_options,
                                input_name_cstrs.data(), input_values.data(), input_values.size(),
                                output_name_cstrs.data(), output_name_cstrs.size());
   }
 
   // measure runs
-  run_result.run_durations.reserve(run_config.num_iterations);
   for (size_t i = 0; i < run_config.num_iterations; ++i) {
     timer.Reset();
     auto outputs = session.Run(run_options,

mobile/examples/model_tester/ios/ModelTester/ModelRunner/model_runner_objc_wrapper.h

@@ -1,16 +1,28 @@
 #import <Foundation/Foundation.h>
-#include <stdint.h>
 
 NS_ASSUME_NONNULL_BEGIN
 
 /**
- * This class is an Objective-C wrapper around the C++ model runner functionality.
+ * This class is an Objective-C wrapper around the C++ `model_runner::RunConfig` structure.
+ */
+@interface ModelRunnerRunConfig : NSObject
+
+- (void)setModelPath:(NSString*)modelPath;
+
+- (void)setNumIterations:(NSUInteger)numIterations;
+
+- (void)setExecutionProvider:(NSString*)providerName
+                     options:(nullable NSDictionary<NSString*, NSString*>*)providerOptions;
+
+@end
+
+/**
+ * This class is an Objective-C wrapper around the C++ model runner functions.
  */
 @interface ModelRunner : NSObject
 
-+ (nullable NSString*)runWithModelPath:(NSString*)modelPath
-                         numIterations:(uint32_t)numIterations
-                                 error:(NSError**)error;
++ (nullable NSString*)runWithConfig:(ModelRunnerRunConfig*)config
+                              error:(NSError**)error NS_SWIFT_NAME(run(config:));
 
 @end
 

mobile/examples/model_tester/ios/ModelTester/ModelRunner/model_runner_objc_wrapper.mm

@@ -2,16 +2,52 @@
 
 #include "model_runner.h"
 
+NS_ASSUME_NONNULL_BEGIN
+
+@interface ModelRunnerRunConfig ()
+
+- (const model_runner::RunConfig&)cppRunConfig;
+
+@end
+
+@implementation ModelRunnerRunConfig {
+  model_runner::RunConfig _runConfig;
+}
+
+- (void)setModelPath:(nonnull NSString*)modelPath {
+  _runConfig.model_path = modelPath.UTF8String;
+}
+
+- (void)setNumIterations:(NSUInteger)numIterations {
+  _runConfig.num_iterations = static_cast<size_t>(numIterations);
+}
+
+- (void)setExecutionProvider:(NSString*)providerName
+                     options:(nullable NSDictionary<NSString*, NSString*>*)providerOptions {
+  model_runner::RunConfig::EpConfig ep_config{};
+  ep_config.provider_name = providerName.UTF8String;
+  if (providerOptions != nil) {
+    for (NSString* optionName in providerOptions) {
+      NSString* optionValue = providerOptions[optionName];
+      ep_config.provider_options.emplace(optionName.UTF8String,
+                                         optionValue.UTF8String);
+    }
+  }
+  _runConfig.ep = std::move(ep_config);
+}
+
+- (const model_runner::RunConfig&)cppRunConfig {
+  return _runConfig;
+}
+
+@end
+
 @implementation ModelRunner
 
-+ (nullable NSString*)runWithModelPath:(NSString*)modelPath
-                         numIterations:(uint32_t)numIterations
-                                 error:(NSError**)error {
++ (nullable NSString*)runWithConfig:(ModelRunnerRunConfig*)objcConfig
+                              error:(NSError**)error {
   try {
-    model_runner::RunConfig config{};
-    config.model_path = modelPath.UTF8String;
-    config.num_iterations = numIterations;
-    config.num_warmup_iterations = 1;
+    const auto& config = [objcConfig cppRunConfig];
 
     auto result = model_runner::Run(config);
 
@@ -32,3 +68,5 @@ + (nullable NSString*)runWithModelPath:(NSString*)modelPath
 }
 
 @end
+
+NS_ASSUME_NONNULL_END

mobile/examples/model_tester/ios/ModelTester/ModelTester/ContentView.swift

@@ -4,10 +4,18 @@ enum ModelTesterError: Error {
   case runtimeError(msg: String)
 }
 
+enum ExecutionProviderType: String, CaseIterable, Identifiable {
+  case cpu = "CPU"
+  case coreml = "CoreML"
+
+  var id: Self { self }
+}
+
 struct ContentView: View {
   @State private var runResultMessage: String = ""
   @State private var isRunning: Bool = false
-  @State private var numIterations: UInt32 = 10
+  @State private var numIterations: UInt = 10
+  @State private var executionProviderType: ExecutionProviderType = .cpu
 
   private func Run() {
     isRunning = true
@@ -19,9 +27,15 @@ struct ContentView: View {
           throw ModelTesterError.runtimeError(msg: "Failed to find model file path.")
         }
 
-        output = try ModelRunner.run(
-          withModelPath: modelPath,
-          numIterations: numIterations)
+        let config = ModelRunnerRunConfig()
+        config.setModelPath(modelPath)
+        config.setNumIterations(numIterations)
+
+        if executionProviderType != .cpu {
+          config.setExecutionProvider(executionProviderType.rawValue)
+        }
+
+        output = try ModelRunner.run(config: config)
       } catch {
         output = "Error: \(error)"
       }
@@ -33,14 +47,17 @@ struct ContentView: View {
   }
 
   var body: some View {
-    VStack {
-      HStack {
-        Text("Iterations:")
-        TextField(
-          "", value: $numIterations,
-          format: IntegerFormatStyle<UInt32>.number
-        )
-        .keyboardType(.numberPad)
+    Form {
+      Text("Iterations:")
+      TextField(
+        "", value: $numIterations,
+        format: IntegerFormatStyle<UInt>.number
+      ).keyboardType(.numberPad)
+
+      Picker("Execution provider type", selection: $executionProviderType) {
+        ForEach(ExecutionProviderType.allCases) { epType in
+          Text(epType.rawValue).tag(epType)
+        }
       }
 
       Button(action: Run) { Text("Run") }
@@ -49,7 +66,6 @@ struct ContentView: View {
       Text(runResultMessage)
         .font(.body.monospaced())
     }
-    .padding()
   }
 }