Update parallel compilation to handle optimization correctly.

allevato · luispadron · commit 2eaa35b20baa · 2025-09-24T21:14:59.000-04:00
Explicitly disable cross-module optimization in `exec` configs so that Swift tools can be built in parallel to speed up critical build paths. Cherry-pic: d1ecc8a
diff --git a/swift/internal/compiling.bzl b/swift/internal/compiling.bzl
@@ -48,12 +48,14 @@ load(
     "SWIFT_FEATURE_EMIT_SWIFTDOC",
     "SWIFT_FEATURE_EMIT_SWIFTINTERFACE",
     "SWIFT_FEATURE_FULL_LTO",
+    "SWIFT_FEATURE_ENABLE_LIBRARY_EVOLUTION",
     "SWIFT_FEATURE_HEADERS_ALWAYS_ACTION_INPUTS",
     "SWIFT_FEATURE_INDEX_WHILE_BUILDING",
     "SWIFT_FEATURE_MODULAR_INDEXING",
     "SWIFT_FEATURE_MODULE_MAP_HOME_IS_CWD",
     "SWIFT_FEATURE_NO_GENERATED_MODULE_MAP",
     "SWIFT_FEATURE_OPT",
+    "SWIFT_FEATURE_OPT_USES_CMO",
     "SWIFT_FEATURE_OPT_USES_WMO",
     "SWIFT_FEATURE_PROPAGATE_GENERATED_MODULE_MAP",
     "SWIFT_FEATURE_SPLIT_DERIVED_FILES_GENERATION",
@@ -765,25 +767,64 @@ def _should_plan_parallel_compilation(
         feature_configuration,
         user_compile_flags):
     """Returns `True` if the compilation should be done in parallel."""
-    parallel_requested = is_feature_enabled(
+    if not is_feature_enabled(
         feature_configuration = feature_configuration,
         feature_name = SWIFT_FEATURE_COMPILE_IN_PARALLEL,
-    )
+    ):
+        return False
 
     # TODO: are we able to support split derived file generation in parallel, this feature is not in upstream.
     # For now, force non-parallel compilation when split derived file generation is enabled.
-    split_derived_file_generation = is_feature_enabled(
+    if is_feature_enabled(
         feature_configuration = feature_configuration,
         feature_name = SWIFT_FEATURE_SPLIT_DERIVED_FILES_GENERATION,
-    )
-
-    # The Swift driver will not emit separate jobs to compile the module and to
-    # perform codegen if optimization is requested. See
+    ):
+        return False
+
+    # When the Swift driver plans a compilation, the default behavior is to emit
+    # separate frontend jobs to emit the module and to perform codegen. However,
+    # this will *not* happen if cross-module optimization is possible; in that
+    # case, the driver emits a single frontend job to compile everything. If any
+    # of the following conditions is true, then cross-module optimization is not
+    # possible and we can plan parallel compilation:
+    #
+    # -   Whole-module optimization is not enabled.
+    # -   Library evolution is enabled.
+    # -   Cross-module optimization has been explicitly disabled.
+    # -   Optimization (via the `-O` flag group) has not been requested.
+    #
+    # This logic mirrors that defined in
     # https://github.com/swiftlang/swift-driver/blob/c647e91574122f2b104d294ab1ec5baadaa1aa95/Sources/SwiftDriver/Jobs/EmitModuleJob.swift#L156-L181.
-    opt_requested = is_optimization_manually_requested(
-        user_compile_flags = user_compile_flags,
+    if not (
+        is_wmo_manually_requested(
+            user_compile_flags = user_compile_flags,
+        ) or are_all_features_enabled(
+            feature_configuration = feature_configuration,
+            feature_names = [SWIFT_FEATURE_OPT, SWIFT_FEATURE_OPT_USES_WMO],
+        )
+    ):
+        return True
+
+    if is_feature_enabled(
+        feature_configuration = feature_configuration,
+        feature_name = SWIFT_FEATURE_ENABLE_LIBRARY_EVOLUTION,
+    ):
+        return True
+
+    if not is_feature_enabled(
+        feature_configuration = feature_configuration,
+        feature_name = SWIFT_FEATURE_OPT_USES_CMO,
+    ):
+        return True
+
+    return (
+        not is_optimization_manually_requested(
+            user_compile_flags = user_compile_flags,
+        ) and not is_feature_enabled(
+            feature_configuration = feature_configuration,
+            feature_name = SWIFT_FEATURE_OPT,
+        )
     )
-    return parallel_requested and not opt_requested and not split_derived_file_generation
 
 def _execute_compile_plan(
         actions,
diff --git a/swift/internal/feature_names.bzl b/swift/internal/feature_names.bzl
@@ -173,6 +173,15 @@ SWIFT_FEATURE_OPT_USES_WMO = "swift.opt_uses_wmo"
 # the `-Osize` flag instead of `-O`.
 SWIFT_FEATURE_OPT_USES_OSIZE = "swift.opt_uses_osize"
 
+# If enabled, compilations that are using whole-module optimization and also
+# request optimizations via the `-O` flag group will have cross-module
+# optimization performed. This is the default behavior for the Swift compiler
+# and for these build rules, with one exception: because CMO prevents
+# parallelized compilation, we unconditionally disable CMO for targets built in
+# an `exec` configuration under the presumption that build speed is more
+# important than runtime performance for build tools.
+SWIFT_FEATURE_OPT_USES_CMO = "swift.opt_uses_cmo"
+
 # If enabled, and if the toolchain specifies a generated header rewriting tool,
 # that tool will be invoked after compilation to rewrite the generated header in
 # place.
diff --git a/swift/internal/features.bzl b/swift/internal/features.bzl
@@ -20,7 +20,6 @@ load(
     ":feature_names.bzl",
     "SWIFT_FEATURE_CACHEABLE_SWIFTMODULES",
     "SWIFT_FEATURE_CHECKED_EXCLUSIVITY",
-    "SWIFT_FEATURE_COMPILE_IN_PARALLEL",
     "SWIFT_FEATURE_COVERAGE",
     "SWIFT_FEATURE_COVERAGE_PREFIX_MAP",
     "SWIFT_FEATURE_DEBUG_PREFIX_MAP",
@@ -40,6 +39,7 @@ load(
     "SWIFT_FEATURE_OPT_USES_WMO",
     "SWIFT_FEATURE_REMAP_XCODE_PATH",
     "SWIFT_FEATURE_USE_GLOBAL_MODULE_CACHE",
+    "SWIFT_FEATURE_OPT_USES_CMO",
     "SWIFT_FEATURE__SUPPORTS_V6",
 )
 load(":package_specs.bzl", "label_matches_package_specs")
@@ -137,6 +137,19 @@ def configure_features(
             unsupported_features = unsupported_features,
         )
 
+    # Disable CMO for builds in `exec` configurations so that we can use
+    # parallelized compilation for build tools written in Swift. The speedup
+    # from parallelized compilation is significantly higher than the performance
+    # loss from disabling CMO.
+    #
+    # HACK: There is no supported API yet to detect whether a build is in an
+    # `exec` configuration. https://github.com/bazelbuild/bazel/issues/14444.
+    if "-exec" in ctx.bin_dir.path or "/host/" in ctx.bin_dir.path:
+        unsupported_features.append(SWIFT_FEATURE_OPT_USES_CMO)
+    else:
+        requested_features = list(requested_features)
+        requested_features.append(SWIFT_FEATURE_OPT_USES_CMO)
+
     all_requestable_features, all_unsupported_features = _compute_features(
         label = ctx.label,
         requested_features = requested_features,
@@ -150,6 +163,7 @@ def configure_features(
         requested_features = all_requestable_features,
         unsupported_features = all_unsupported_features,
     )
+
     return struct(
         _cc_feature_configuration = cc_feature_configuration,
         _enabled_features = all_requestable_features,
@@ -193,12 +207,6 @@ def features_for_build_modes(ctx, cpp_fragment = None):
     requested_features.append("swift.{}".format(compilation_mode))
     if compilation_mode in ("dbg", "fastbuild"):
         requested_features.append(SWIFT_FEATURE_ENABLE_TESTING)
-    elif compilation_mode == "opt":
-        # Disable parallel compilation early if we know we're going to be doing
-        # an optimized compile, because the driver will not emit separate jobs
-        # unless we also explicitly disable cross-module optimization. See
-        # https://github.com/swiftlang/swift-driver/blob/c647e91574122f2b104d294ab1ec5baadaa1aa95/Sources/SwiftDriver/Jobs/EmitModuleJob.swift#L156-L181.
-        unsupported_features.append(SWIFT_FEATURE_COMPILE_IN_PARALLEL)
 
     if ctx.configuration.coverage_enabled:
         requested_features.append(SWIFT_FEATURE_COVERAGE)
diff --git a/swift/internal/optimization.bzl b/swift/internal/optimization.bzl
@@ -16,7 +16,6 @@
 
 load(
     ":feature_names.bzl",
-    "SWIFT_FEATURE_COMPILE_IN_PARALLEL",
     "SWIFT_FEATURE__NUM_THREADS_0_IN_SWIFTCOPTS",
     "SWIFT_FEATURE__WMO_IN_SWIFTCOPTS",
 )
@@ -113,13 +112,6 @@ def optimization_features_from_swiftcopts(swiftcopts):
     requested_features = []
     unsupported_features = []
 
-    if is_optimization_manually_requested(user_compile_flags = swiftcopts):
-        # Disable parallel compilation early if we know we're going to be doing
-        # an optimized compile, because the driver will not emit separate jobs
-        # unless we also explicitly disable cross-module optimization. See
-        # https://github.com/swiftlang/swift-driver/blob/c647e91574122f2b104d294ab1ec5baadaa1aa95/Sources/SwiftDriver/Jobs/EmitModuleJob.swift#L156-L181.
-        unsupported_features.append(SWIFT_FEATURE_COMPILE_IN_PARALLEL)
-
     if is_wmo_manually_requested(user_compile_flags = swiftcopts):
         requested_features.append(SWIFT_FEATURE__WMO_IN_SWIFTCOPTS)
     if find_num_threads_flag_value(user_compile_flags = swiftcopts) == 1:
diff --git a/swift/toolchains/config/compile_config.bzl b/swift/toolchains/config/compile_config.bzl
@@ -72,6 +72,7 @@ load(
     "SWIFT_FEATURE_MODULE_MAP_HOME_IS_CWD",
     "SWIFT_FEATURE_NO_ASAN_VERSION_CHECK",
     "SWIFT_FEATURE_OPT",
+    "SWIFT_FEATURE_OPT_USES_CMO",
     "SWIFT_FEATURE_OPT_USES_OSIZE",
     "SWIFT_FEATURE_OPT_USES_WMO",
     "SWIFT_FEATURE_REWRITE_GENERATED_HEADER",
@@ -366,6 +367,11 @@ def compile_action_configs(
             configurators = [add_arg("-Osize")],
             features = [SWIFT_FEATURE_OPT, SWIFT_FEATURE_OPT_USES_OSIZE],
         ),
+        ActionConfigInfo(
+            actions = all_compile_action_names(),
+            configurators = [add_arg("-disable-cmo")],
+            not_features = [SWIFT_FEATURE_OPT_USES_CMO],
+        ),
 
         # If the `swift.opt_uses_wmo` feature is enabled, opt builds should also
         # automatically imply whole-module optimization.
diff --git a/test/debug_settings_tests.bzl b/test/debug_settings_tests.bzl
@@ -238,8 +238,6 @@ def debug_settings_test_suite(name, tags = []):
             "-g",
             "-gline-tables-only",
         ],
-        # In optimized mode, the driver still uses a single invocation for both
-        # the module and for codegen.
         mnemonic = "SwiftCompile",
         tags = all_tags,
         target_under_test = "//test/fixtures/debug_settings:simple",
diff --git a/test/features_tests.bzl b/test/features_tests.bzl
@@ -213,9 +213,7 @@ def features_test_suite(name, tags = []):
         tags = all_tags,
         expected_argv = ["-emit-object", "-O"],
         not_expected_argv = ["-whole-module-optimization"],
-        # In optimized mode, the driver still uses a single invocation for both
-        # the module and for codegen.
-        mnemonic = "SwiftCompile",
+        mnemonic = "SwiftCompileModule",
         target_under_test = "//test/fixtures/debug_settings:simple",
     )
 
diff --git a/test/fixtures/parallel_compilation/BUILD b/test/fixtures/parallel_compilation/BUILD
@@ -34,12 +34,34 @@ swift_library(
 )
 
 swift_library(
-    name = "with_opt_with_wmo",
+    name = "with_opt_with_wmo_no_cmo",
     srcs = ["Empty.swift"],
     copts = [
         "-O",
         "-wmo",
     ],
+    features = ["-swift.opt_uses_cmo"],
+    tags = FIXTURE_TAGS,
+)
+
+swift_library(
+    name = "with_opt_with_wmo_with_cmo",
+    srcs = ["Empty.swift"],
+    copts = [
+        "-O",
+        "-wmo",
+    ],
+    tags = FIXTURE_TAGS,
+)
+
+swift_library(
+    name = "with_opt_with_wmo_with_library_evolution",
+    srcs = ["Empty.swift"],
+    copts = [
+        "-O",
+        "-wmo",
+    ],
+    library_evolution = True,
     tags = FIXTURE_TAGS,
 )
 
diff --git a/test/parallel_compilation_tests.bzl b/test/parallel_compilation_tests.bzl
@@ -18,10 +18,17 @@ load("@bazel_skylib//rules:build_test.bzl", "build_test")
 load(
     "@build_bazel_rules_swift//test/rules:actions_created_test.bzl",
     "actions_created_test",
+    "make_actions_created_test_rule",
 )
 
 visibility("private")
 
+opt_actions_create_test = make_actions_created_test_rule(
+    config_settings = {
+        "//command_line_option:compilation_mode": "opt",
+    },
+)
+
 def parallel_compilation_test_suite(name, tags = []):
     """Test suite for parallel compilation.
 
@@ -47,25 +54,46 @@ def parallel_compilation_test_suite(name, tags = []):
         target_under_test = "@build_bazel_rules_swift//test/fixtures/parallel_compilation:no_opt_with_wmo",
     )
 
-    # Optimized, non-WMO cannot be compiled in parallel.
-    # TODO: b/351801556 - This is actually incorrect based on further driver
-    # testing; update the rules to allow compiling these in parallel.
+    # Optimized, non-WMO can be compiled in parallel.
     actions_created_test(
         name = "{}_with_opt_no_wmo".format(name),
-        mnemonics = ["-SwiftCompileModule", "-SwiftCompileCodegen", "SwiftCompile"],
+        mnemonics = ["SwiftCompileModule", "SwiftCompileCodegen", "-SwiftCompile"],
         tags = all_tags,
         target_under_test = "@build_bazel_rules_swift//test/fixtures/parallel_compilation:with_opt_no_wmo",
     )
 
-    # Optimized, with-WMO cannot be compiled in parallel.
-    # TODO: b/351801556 - This should be allowed if cross-module-optimization is
-    # disabled. Update the rules to allow this and add a new version of this
-    # target that disables CMO so we can test both situtations.
+    # Optimized, with-WMO can be compiled in parallel if CMO is also disabled.
+    actions_created_test(
+        name = "{}_with_opt_with_wmo_no_cmo".format(name),
+        mnemonics = ["SwiftCompileModule", "SwiftCompileCodegen", "-SwiftCompile"],
+        tags = all_tags,
+        target_under_test = "@build_bazel_rules_swift//test/fixtures/parallel_compilation:with_opt_with_wmo_no_cmo",
+    )
+
+    # Optimized, with-WMO cannot be compiled in parallel if CMO is enabled.
     actions_created_test(
-        name = "{}_with_opt_with_wmo".format(name),
+        name = "{}_with_opt_with_wmo_with_cmo".format(name),
         mnemonics = ["-SwiftCompileModule", "-SwiftCompileCodegen", "SwiftCompile"],
         tags = all_tags,
-        target_under_test = "@build_bazel_rules_swift//test/fixtures/parallel_compilation:with_opt_with_wmo",
+        target_under_test = "@build_bazel_rules_swift//test/fixtures/parallel_compilation:with_opt_with_wmo_with_cmo",
+    )
+
+    # Force `-c opt` on a non-optimized, with-WMO target and make sure we don't
+    # plan parallel compilation there.
+    opt_actions_create_test(
+        name = "{}_no_opt_with_wmo_but_compilation_mode_opt".format(name),
+        mnemonics = ["-SwiftCompileModule", "-SwiftCompileCodegen", "SwiftCompile"],
+        tags = all_tags,
+        target_under_test = "@build_bazel_rules_swift//test/fixtures/parallel_compilation:no_opt_with_wmo",
+    )
+
+    # Optimized, with-WMO can be compiled in parallel if library evolution is
+    # enabled (which implicitly disables CMO).
+    actions_created_test(
+        name = "{}_with_opt_with_wmo_with_library_evolution".format(name),
+        mnemonics = ["SwiftCompileModule", "SwiftCompileCodegen", "-SwiftCompile"],
+        tags = all_tags,
+        target_under_test = "@build_bazel_rules_swift//test/fixtures/parallel_compilation:with_opt_with_wmo_with_library_evolution",
     )
 
     # Make sure that when we look for optimizer flags, we don't treat `-Onone`
@@ -85,7 +113,9 @@ def parallel_compilation_test_suite(name, tags = []):
             "@build_bazel_rules_swift//test/fixtures/parallel_compilation:no_opt_no_wmo",
             "@build_bazel_rules_swift//test/fixtures/parallel_compilation:no_opt_with_wmo",
             "@build_bazel_rules_swift//test/fixtures/parallel_compilation:with_opt_no_wmo",
-            "@build_bazel_rules_swift//test/fixtures/parallel_compilation:with_opt_with_wmo",
+            "@build_bazel_rules_swift//test/fixtures/parallel_compilation:with_opt_with_wmo_no_cmo",
+            "@build_bazel_rules_swift//test/fixtures/parallel_compilation:with_opt_with_wmo_with_cmo",
+            "@build_bazel_rules_swift//test/fixtures/parallel_compilation:with_opt_with_wmo_with_library_evolution",
             "@build_bazel_rules_swift//test/fixtures/parallel_compilation:onone_with_wmo",
         ],
         tags = all_tags,
