Enable free dimension override for graph optimization level 0

onnxruntime/core/optimizer/graph_transformer_utils.cc

@@ -220,6 +220,10 @@ InlinedVector<std::unique_ptr<GraphTransformer>> GenerateTransformers(
   AllocatorPtr cpu_allocator = CPUAllocator::DefaultInstance();
 
   switch (level) {
+    case TransformerLevel::Default: {
+      transformers.emplace_back(std::make_unique<FreeDimensionOverrideTransformer>(
+          session_options.free_dimension_overrides));
+    } break;
     case TransformerLevel::Level1: {
       // RewriteRule optimizations are the simplest (they generally remove unnecessary nodes and are cheap to run)
       // so run them first so there is potentially less for the more intensive optimizations like ConstantFolding,

onnxruntime/core/session/inference_session.cc

@@ -3645,11 +3645,21 @@ common::Status InferenceSession::AddPredefinedTransformers(
     RecordRuntimeOptimizationProducedNodeOpSchemaFn record_runtime_optimization_produced_op_schema_fn,
     const logging::Logger& logger) const {
   const auto& cpu_ep = *execution_providers_.Get(onnxruntime::kCpuExecutionProvider);
-  for (int i = static_cast<int>(TransformerLevel::Level1); i <= static_cast<int>(TransformerLevel::MaxLevel); i++) {
+  for (int i = static_cast<int>(TransformerLevel::Default); i <= static_cast<int>(TransformerLevel::MaxLevel); i++) {
     TransformerLevel level = static_cast<TransformerLevel>(i);
-    if (graph_optimization_level >= level) {
+    std::function<onnxruntime::InlinedVector<std::unique_ptr<GraphTransformer>>()> transformers_to_register;
+
+    // Enable free dimension override even when the graph optimization level is 0.
+    // If the optimization level is above 0, the override will be applied during level 1 optimization.
+    if ((graph_optimization_level == TransformerLevel::Default) && (level == TransformerLevel::Default)) {
+      transformers_to_register = [&]() {
+        return optimizer_utils::GenerateTransformers(level, session_options_, cpu_ep, logger,
+                                                     optimizers_to_disable_,
+                                                     GetIntraOpThreadPoolToUse());
+      };
+    } else if (graph_optimization_level >= level) {
       // Generate and register transformers for level
-      auto transformers_to_register = [&]() {
+      transformers_to_register = [&]() {
         const bool use_full_build_optimizations =
             level == TransformerLevel::Level1 ||
             minimal_build_optimization_handling == MinimalBuildOptimizationHandling::ApplyFullBuildOptimizations;
@@ -3670,11 +3680,11 @@ common::Status InferenceSession::AddPredefinedTransformers(
                                                                       optimizers_to_disable_,
                                                                       GetIntraOpThreadPoolToUse());
         }
-      }();
+      };
+    }
 
-      for (auto& entry : transformers_to_register) {
-        ORT_RETURN_IF_ERROR(transformer_manager.Register(std::move(entry), level));
-      }
+    for (auto& entry : transformers_to_register()) {
+      ORT_RETURN_IF_ERROR(transformer_manager.Register(std::move(entry), level));
     }
   }
   return Status::OK();