Update base for Update on "[ET-VK] Using push constants for buffer to image prepack nodes."

This diff enables the use of push constants for buffer to image prepack nodes in the Vulkan runtime graph. Push constants are a more efficient way to pass small amounts of data to shaders, compared to using uniform buffers.
*   The `nchw_to_*.yaml` files have been updated to include the `USE_PUSH_CONST` flag which is `True` by default, and enables the use of push constants for all `nchw_to_*` operations.
*   New variants of the `nchw_to_*` operation have been added with suffix `_no_pc`, which do not use push constants. These variants are used for compatibility with testing and utility functions.
*   The `Convolution.cpp` and `Staging.cpp` files have been updated to pass empty parameter buffers and instead use push constants.

Differential Revision: [D70102398](https://our.internmc.facebook.com/intern/diff/D70102398/)

[ghstack-poisoned]

Author: trivedivivek

.github/scripts/label_utils.py

@@ -22,9 +22,7 @@
 
 LABEL_ERR_MSG_TITLE = "This PR needs a `release notes:` label"
 LABEL_ERR_MSG = f"""# {LABEL_ERR_MSG_TITLE}
-If your change should be included in the release notes (i.e. would users of this library care about this change?), please use a label starting with `release notes:`.
-
-If not, please add the `release notes: none` label.
+If your change should be included in the release notes (i.e. would users of this library care about this change?), please use a label starting with `release notes:`. This helps us keep track and include your important work in the next release notes.
 
 To add a label, you can comment to pytorchbot, for example
 `@pytorchbot label "release notes: none"`

.github/scripts/trymerge.py

@@ -59,12 +59,7 @@
     patterns_to_regex,
     retries_decorator,
 )
-from label_utils import (
-    gh_add_labels,
-    gh_remove_label,
-    has_required_labels,
-    LABEL_ERR_MSG,
-)
+from label_utils import gh_add_labels, gh_remove_label
 from trymerge_explainer import get_revert_message, TryMergeExplainer
 
 # labels
@@ -2116,9 +2111,6 @@ def merge(
     # Check for approvals
     find_matching_merge_rule(pr, repo, skip_mandatory_checks=True)
 
-    if not has_required_labels(pr):
-        raise RuntimeError(LABEL_ERR_MSG.lstrip(" #"))
-
     if ignore_current:
         checks = pr.get_checkrun_conclusions()
         _, failing, _ = categorize_checks(

.github/workflows/check-labels.yml

@@ -51,4 +51,4 @@ jobs:
           PR_NUM: ${{ github.event.number || github.event.inputs.pr_number }}
         run: |
           set -ex
-          python3 .github/scripts/check_labels.py --exit-non-zero "${PR_NUM}"
+          python3 .github/scripts/check_labels.py "${PR_NUM}"

.github/workflows/trunk.yml

@@ -305,7 +305,7 @@ jobs:
         # Install requirements
         ${CONDA_RUN} sh install_requirements.sh
         ${CONDA_RUN} sh backends/apple/coreml/scripts/install_requirements.sh
-        ${CONDA_RUN} python install_executorch.py --pybind coreml
+        ${CONDA_RUN} python install_executorch.py
         ${CONDA_RUN} sh examples/models/llama/install_requirements.sh
 
         # Test ANE llama

CMakePresets.json

@@ -15,7 +15,7 @@
         "CMAKE_TOOLCHAIN_FILE": "${sourceDir}/third-party/ios-cmake/ios.toolchain.cmake",
         "EXECUTORCH_BUILD_PRESET_FILE": "${sourceDir}/tools/cmake/preset/macos.cmake",
         "PLATFORM": "MAC_ARM64",
-        "DEPLOYMENT_TARGET": "10.15"
+        "DEPLOYMENT_TARGET": "12.0"
       },
       "condition": {
         "lhs": "${hostSystemName}",
@@ -77,7 +77,7 @@
       "inherits": ["common"],
       "cacheVariables": {
         "EXECUTORCH_BUILD_PRESET_FILE": "${sourceDir}/tools/cmake/preset/pybind.cmake",
-        "CMAKE_OSX_DEPLOYMENT_TARGET": "10.15"
+        "CMAKE_OSX_DEPLOYMENT_TARGET": "12.0"
       },
       "condition": {
         "type": "inList",
@@ -93,7 +93,7 @@
         ],
         "cacheVariables": {
             "EXECUTORCH_BUILD_PRESET_FILE": "${sourceDir}/tools/cmake/preset/llm.cmake",
-            "CMAKE_OSX_DEPLOYMENT_TARGET": "10.15"
+            "CMAKE_OSX_DEPLOYMENT_TARGET": "12.0"
         },
         "condition": {
             "type": "inList",

Package.swift

@@ -120,7 +120,7 @@ let package = Package(
   name: "executorch",
   platforms: [
     .iOS(.v17),
-    .macOS(.v10_15),
+    .macOS(.v12),
   ],
   products: packageProducts,
   targets: packageTargets + [

backends/apple/coreml/runtime/delegate/ETCoreMLDefaultModelExecutor.mm

@@ -27,7 +27,7 @@ - (instancetype)initWithModel:(ETCoreMLModel *)model {
                                                  eventLogger:(const executorchcoreml::ModelEventLogger* _Nullable __unused)eventLogger
                                                        error:(NSError * __autoreleasing *)error {
     if (self.ignoreOutputBackings) {
-        if (@available(macOS 11.0, iOS 16.0, tvOS 16.0, watchOS 9.0, *)) {
+        if (@available(iOS 16.0, tvOS 16.0, watchOS 9.0, *)) {
             predictionOptions.outputBackings = @{};
         }
     }

backends/apple/coreml/runtime/delegate/ETCoreMLModelManager.mm

@@ -92,7 +92,7 @@ BOOL is_backed_by_same_buffer(MLMultiArray *array1, MLMultiArray *array2) {
                                             NSOrderedSet<NSString *> *output_names,
                                             NSError * __autoreleasing *error) {
     MLPredictionOptions *options = [MLPredictionOptions new];
-    if (@available(macOS 11.0, iOS 16.0, tvOS 16.0, watchOS 9.0, *)) {
+    if (@available(iOS 16.0, tvOS 16.0, watchOS 9.0, *)) {
         NSMutableDictionary<NSString *, id> *output_backings = [NSMutableDictionary dictionary];
         NSEnumerator<NSString *> *enumerator = [output_names objectEnumerator];
         for (MLMultiArray *output in outputs) {
@@ -687,7 +687,7 @@ - (void)addPrewarmedAsset:(ETCoreMLAsset *)asset {
                                                                  eventLogger:eventLogger
                                                                        error:&localError];
     // Try without output backings.
-    if (@available(macOS 11.0, iOS 16.0, tvOS 16.0, watchOS 9.0, *)) {
+    if (@available(iOS 16.0, tvOS 16.0, watchOS 9.0, *)) {
         if (!modelOutputs && predictionOptions.outputBackings.count > 0) {
             executor.ignoreOutputBackings = YES;
             localError = nil;

backends/apple/mps/setup.md

@@ -91,7 +91,7 @@ I 00:00:00.122615 executorch:mps_executor_runner.mm:501] Model verified successf
 ### [Optional] Run the generated model directly using pybind
 1. Make sure `pybind` MPS support was installed:
 ```bash
-./install_executorch.sh --pybind mps
+CMAKE_ARGS="-DEXECUTORCH_BUILD_MPS=ON" ./install_executorch.sh
 ```
 2. Run the `mps_example` script to trace the model and run it directly from python:
 ```bash

backends/arm/_passes/__init__.py

@@ -23,6 +23,7 @@
 from .decompose_cosine_similarity_pass import DecomposeCosineSimilarityPass  # noqa
 from .decompose_div_pass import DecomposeDivPass  # noqa
 from .decompose_gelu_pass import DecomposeGeluPass  # noqa
+from .decompose_groupnorm_pass import DecomposeGroupNormPass  # noqa
 from .decompose_layernorm_pass import DecomposeLayerNormPass  # noqa
 from .decompose_leaky_relu_pass import DecomposeLeakyReLUPass  # noqa
 from .decompose_linalg_vector_norm_pass import DecomposeLinearVectorNormPass  # noqa

backends/arm/_passes/arm_pass_manager.py

@@ -27,6 +27,7 @@
     DecomposeCosineSimilarityPass,
     DecomposeDivPass,
     DecomposeGeluPass,
+    DecomposeGroupNormPass,
     DecomposeLayerNormPass,
     DecomposeLeakyReLUPass,
     DecomposeLinearPass,
@@ -141,6 +142,7 @@ def _tosa_080_MI_pipeline(self, exported_program: ExportedProgram) -> GraphModul
         self.add_pass(ConvertMmToBmmPass())
         self.add_pass(DecomposeLinearPass())
         self.add_pass(DecomposeLeakyReLUPass())
+        self.add_pass(DecomposeGroupNormPass())
         self.add_pass(DecomposeLayerNormPass())
         self.add_pass(DecomposeVarPass())
         self.add_pass(
@@ -208,6 +210,7 @@ def transform_for_annotation_pipeline(self, graph_module: GraphModule):
         self.add_pass(DecomposeScaledDotProductAttention())
         self.add_pass(ReplaceScalarWithTensorArgPassTOSABI())
         self.add_pass(ScalarsToAttributePass())
+        self.add_pass(DecomposeGroupNormPass())
         self.add_pass(DecomposeLayerNormPass())
         self.add_pass(DecomposeVarPass())
         self.add_pass(DecomposeMeanDimPass(graph_module, self.tosa_spec))

backends/arm/_passes/decompose_groupnorm_pass.py

@@ -0,0 +1,208 @@
+# Copyright 2025 Arm Limited and/or its affiliates.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe
+
+import operator
+
+import torch
+from executorch.backends.arm._passes import ArmPass
+from executorch.backends.arm._passes.arm_pass_utils import create_node
+from executorch.exir.dialects._ops import ops as exir_ops
+from executorch.exir.pass_base import PassResult
+
+
+def get_group_norm_decomposition(op) -> tuple:
+    if op == exir_ops.edge.aten.native_group_norm.default:
+        return (
+            exir_ops.edge.aten.mean.dim,
+            exir_ops.edge.aten.sub.Tensor,
+            exir_ops.edge.aten.var.correction,
+            exir_ops.edge.aten.full.default,
+            exir_ops.edge.aten.add.Tensor,
+            exir_ops.edge.aten.rsqrt.default,
+            exir_ops.edge.aten.mul.Tensor,
+            exir_ops.edge.aten.view_copy.default,
+        )
+    if op == torch.ops.aten.group_norm.default:
+        return (
+            torch.ops.aten.mean.dim,
+            torch.ops.aten.sub.Tensor,
+            torch.ops.aten.var.correction,
+            torch.ops.aten.full.default,
+            torch.ops.aten.add.Tensor,
+            torch.ops.aten.rsqrt.default,
+            torch.ops.aten.mul.Tensor,
+            torch.ops.aten.view_copy.default,
+        )
+    raise RuntimeError(f"Can't get group_norm composition for op {op}")
+
+
+class DecomposeGroupNormPass(ArmPass):
+    """
+    groupnorm is defined as: ((x - E[x]) / sqrt(Var[x] + eps)) * weights + bias
+    Decompose groupnorm(x, weight, bias, N, C, HxW, group, eps) to a sequence of:
+    mean        = op_mean(x, dims)           # E[x]
+    var         = op_var(x, dims)            # Var[x]
+    numerator   = op_sub(x, mean)            # (x - E[x])
+    add         = op_add(var, eps)           # Var[x] + eps
+    rsqrt       = op_rsqrt(add)              # 1 / sqrt(Var[x] + eps)
+    mul         = op_mul(numerator, rsqrt)   # ((x - E[x]) / sqrt(Var[x] + eps))
+    weigths     = op_mul(mul, weigths)       # ((x - E[x]) / sqrt(Var[x] + eps)) * weigths
+    bias        = op_add(weigths, bias)      # ((x - E[x]) / sqrt(Var[x] + eps)) * weigths + bias
+    where x can viewed with shape [N, group, C//group, HxW] dims=[C//group, HxW]
+
+    Source: https://pytorch.org/docs/stable/generated/torch.nn.GroupNorm.html
+    """
+
+    def call(self, graph_module: torch.fx.GraphModule):
+        modified = False
+        for node in graph_module.graph.nodes:
+            if node.op != "call_function" or node.target not in (
+                exir_ops.edge.aten.native_group_norm.default,
+                torch.ops.aten.group_norm.default,
+            ):
+                continue
+
+            # epsilon default value
+            eps = torch.finfo().eps
+            weights = None
+            bias = None
+            args = node.args
+            meta = node.meta
+            if isinstance(meta["val"], tuple):
+                shape = meta["val"][0].size()
+                dtype = meta["val"][0].dtype
+            else:
+                shape = meta["val"].size()
+                dtype = meta["val"].dtype
+            match len(args):
+                # MI profile always provides all the args: x, weight, bias, N, C, HxW, group, eps
+                case 8:
+                    x, weights, bias, N, C, HxW, group, eps = args
+                # BI profile: affine=[True|False], eps!=1e-5
+                case 5:
+                    x, group, weights, bias, eps = args
+                # BI profile: affine=True, eps=1e-5
+                case 4:
+                    x, group, weights, bias = args
+                # BI profile: affine=False, eps=1e=5
+                case 2:
+                    x, group = args
+                # Unsupported args
+                case _:
+                    raise ValueError(
+                        f"Unsupported group_norm argument pattern with {len(args)} args"
+                    )
+            N = shape[0]
+            C = shape[1]
+            HxW = 1
+            for dim in shape[2:]:
+                HxW *= dim
+            channels_per_group = C // group
+            grouped_shape = torch.Size([N, group, channels_per_group, HxW])
+            dims = [2, 3]
+            epsilon_reshaped_shape = torch.Size([1] * len(grouped_shape))
+            weights_reshaped_shape = torch.Size([1, group, channels_per_group, 1])
+            (
+                mean_op,
+                sub_op,
+                var_op,
+                full_op,
+                add_op,
+                rsqrt_op,
+                mul_op,
+                view_op,
+            ) = get_group_norm_decomposition(node.target)
+            with graph_module.graph.inserting_before(node):
+                keepdim = True
+                x_reshaped = create_node(
+                    graph_module.graph,
+                    view_op,
+                    args=(x, grouped_shape),
+                    from_node=node,
+                )
+                mean = create_node(
+                    graph_module.graph, mean_op, args=(x_reshaped, dims, keepdim)
+                )
+                sub = create_node(graph_module.graph, sub_op, args=(x_reshaped, mean))
+                var = create_node(
+                    graph_module.graph,
+                    var_op,
+                    args=(x_reshaped, dims),
+                    kwargs={"correction": 0, "keepdim": keepdim},
+                    from_node=node,
+                )
+                full = create_node(
+                    graph_module.graph,
+                    full_op,
+                    args=(epsilon_reshaped_shape, eps),
+                    kwargs={"dtype": dtype},
+                    from_node=node,
+                )
+                add0 = create_node(
+                    graph_module.graph, add_op, args=(var, full), from_node=node
+                )
+                rsqrt = create_node(
+                    graph_module.graph, rsqrt_op, args=(add0,), from_node=node
+                )
+                mul0 = create_node(
+                    graph_module.graph, mul_op, args=(sub, rsqrt), from_node=node
+                )
+                if weights is not None:
+                    weights_reshaped = create_node(
+                        graph_module.graph,
+                        view_op,
+                        args=(weights, weights_reshaped_shape),
+                        from_node=node,
+                    )
+                    mul1 = create_node(
+                        graph_module.graph,
+                        mul_op,
+                        args=(
+                            mul0,
+                            weights_reshaped,
+                        ),
+                        from_node=node,
+                    )
+                else:
+                    mul1 = mul0
+                if bias is not None:
+                    bias_reshaped_shape = weights_reshaped_shape
+                    bias_reshaped = create_node(
+                        graph_module.graph,
+                        view_op,
+                        args=(bias, bias_reshaped_shape),
+                        from_node=node,
+                    )
+                    output = create_node(
+                        graph_module.graph,
+                        add_op,
+                        args=(mul1, bias_reshaped),
+                        from_node=node,
+                    )
+                else:
+                    output = mul1
+
+                output_reshaped = create_node(
+                    graph_module.graph,
+                    view_op,
+                    args=(output, shape),
+                    from_node=node,
+                )
+
+                users = [user for user in node.users if node != user]
+                node.replace_all_uses_with(output_reshaped)
+                for user in users:
+                    if user.target == operator.getitem:
+                        user.replace_all_uses_with(output_reshaped)
+                graph_module.graph.erase_node(node)
+                graph_module.graph.eliminate_dead_code()
+                modified = True
+        if modified:
+            graph_module.recompile()
+            graph_module = super().call(graph_module).graph_module
+
+        return PassResult(graph_module, modified)

backends/arm/_passes/decompose_layernorm_pass.py

@@ -1,5 +1,4 @@
 # Copyright 2024-2025 Arm Limited and/or its affiliates.
-# All rights reserved.
 #
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
@@ -47,11 +46,12 @@ class DecomposeLayerNormPass(ArmPass):
     Decompose layernorm(x, normalized_shape, weights, bias, eps) to a sequence of:
     mean        = op_mean(x, dims)           # E[x]
     var         = op_var(x, dims)            # Var[x]
-    denominator = op_sub(x, mean)            # (x - E[x])
+    numerator   = op_sub(x, mean)            # (x - E[x])
     add         = op_add(var, eps)           # Var[x] + eps
     rsqrt       = op_rsqrt(add)              # 1 / sqrt(Var[x] + eps)
-    mul         = op_mul(denominator, rsqrt) # ((x - E[x]) / sqrt(Var[x] + eps)) * weigths
-    bias        = op_add(mul, bias)          # ((x - E[x]) / sqrt(Var[x] + eps)) * weigths + bias
+    mul         = op_mul(numerator, rsqrt)   # ((x - E[x]) / sqrt(Var[x] + eps))
+    weigths     = op_mul(mul, weigths)       # ((x - E[x]) / sqrt(Var[x] + eps)) * weigths
+    bias        = op_add(weigths, bias)      # ((x - E[x]) / sqrt(Var[x] + eps)) * weigths + bias
 
     Source: https://pytorch.org/docs/stable/generated/torch.nn.LayerNorm.html
     """