Merge branch 'main' into enable-per-channel-quantization-for-VgfPipeline

Author: YufengShi-dudu

backends/arm/_passes/decompose_meandim_pass.py

@@ -105,7 +105,7 @@ def call_operator(self, op, args, kwargs, meta):
 
         # Reshape back to 5D if necessary
         if len(input_shape) > 4:
-            original_dims = input_shape[0:-4]
+            original_dims = input_shape[0:-3]
             temp_shape = list(x.data.shape)[1:]
             temp_shape = original_dims + temp_shape
             dims_to_reduce = [dim + len(original_dims) - 1 for dim in dims_to_reduce]

backends/arm/operator_support/ethos_u55_support.py

@@ -6,15 +6,16 @@
 # pyre-unsafe
 
 import typing
+from typing import cast
 
 import torch
 import torch.fx as fx
+
 from executorch.backends.arm._passes.arm_pass_utils import get_first_fake_tensor
 from executorch.backends.arm._passes.insert_table_ops import TableOps
 from executorch.backends.arm.operators.op_permute import transform_permutation_vector
 from executorch.backends.arm.tosa_utils import tosa_shape
 from executorch.exir.backend.utils import WhyNoPartitionReporter
-
 from executorch.exir.dialects._ops import ops as exir_ops
 from torch.fx.passes.operator_support import OperatorSupportBase
 
@@ -212,19 +213,51 @@ def is_node_supported(
         Returns:
             False if the operator is not support and True if it is supported.
         """
-        if not node.target == exir_ops.edge.aten.view_copy.default:
+        # Select decomposes into squeeze, which in turn becomes a view. Therefore,
+        # perform the same check on select operators as view operators.
+        if node.target not in (
+            exir_ops.edge.aten.view_copy.default,
+            exir_ops.edge.aten.select.int,
+            exir_ops.edge.aten.select_copy.int,
+        ):
             return True
 
-        shape = list(get_first_fake_tensor(node).shape)
+        if node.target in (
+            exir_ops.edge.aten.select.int,
+            exir_ops.edge.aten.select_copy.int,
+        ):
+            input_node, dim, index = cast(tuple[fx.Node, int, int], node.args)
+
+            shape = input_node.meta["val"].shape
+            rank = len(shape)
+            if not -rank <= dim < rank:
+                raise IndexError(
+                    f"Dim {dim} is outside of the range for tensor '{node.target}' of "
+                    f"rank {rank}"
+                )
+            dim = dim % rank
+
+            size = shape[dim]
+            if not -size <= index < size:
+                raise IndexError(
+                    f"Index {index} is outside of the range for dim {dim} with size "
+                    f"{size} for tensor {node.target}"
+                )
+            index = index % size
+
+            # Shape after squeeze. This may get converted into a view which may become
+            # a transpose. This is why we're checking select.
+            squeezed_shape = shape[:dim] + shape[dim + 1 :]
+            shape = squeezed_shape
+        else:
+            shape = list(get_first_fake_tensor(node).shape)
+
         dtype = _try_determine_dtype(node)
-        permutation = list(typing.cast(list[int], node.args[1]))
 
         rank = len(shape)
         if rank > 4:
             if dtype == torch.int32:
-                self.reporter.report_reject(
-                    node, f"No support for {permutation=} in int32."
-                )
+                self.reporter.report_reject(node, "No support for rank > 4 in int32.")
                 return False
 
         if dtype in (torch.int8, torch.int16):

backends/arm/test/ops/test_ceil.py

@@ -0,0 +1,96 @@
+# 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.
+
+from typing import Tuple
+
+import torch
+from executorch.backends.arm.test import common
+from executorch.backends.arm.test.tester.test_pipeline import (
+    EthosU55PipelineBI,
+    EthosU85PipelineBI,
+    TosaPipelineBI,
+    TosaPipelineMI,
+)
+
+input_t1 = Tuple[torch.Tensor]
+
+
+class Ceil(torch.nn.Module):
+    def forward(self, x: torch.Tensor):
+        return torch.ceil(x)
+
+    aten_op = "torch.ops.aten.ceil.default"
+    exir_op = "executorch_exir_dialects_edge__ops_aten_ceil_default"
+
+
+zeros = torch.zeros(1, 10, 10, 10)
+ones = torch.ones(10, 10, 10)
+rand = torch.rand(10, 10) - 0.5
+randn_pos = torch.randn(1, 4, 4, 4) + 10
+randn_neg = torch.randn(1, 4, 4, 4) - 10
+ramp = torch.arange(-16, 16, 0.2)
+
+test_data = {
+    "ceil_zeros": lambda: (Ceil(), zeros),
+    "ceil_ones": lambda: (Ceil(), ones),
+    "ceil_rand": lambda: (Ceil(), rand),
+    "ceil_randn_pos": lambda: (Ceil(), randn_pos),
+    "ceil_randn_neg": lambda: (Ceil(), randn_neg),
+    "ceil_ramp": lambda: (Ceil(), ramp),
+}
+
+
+@common.parametrize("test_data", test_data)
+def test_ceil_tosa_MI(test_data: input_t1):
+    module, data = test_data()
+    pipeline = TosaPipelineMI[input_t1](
+        module,
+        (data,),
+        module.aten_op,
+        module.exir_op,
+    )
+    pipeline.run()
+
+
+@common.parametrize("test_data", test_data)
+def test_ceil_tosa_BI(test_data: input_t1):
+    module, data = test_data()
+    pipeline = TosaPipelineBI[input_t1](
+        module,
+        (data,),
+        module.aten_op,
+        module.exir_op,
+        atol=0.06,
+        rtol=0.01,
+    )
+    pipeline.run()
+
+
+@common.parametrize("test_data", test_data)
+@common.XfailIfNoCorstone300
+def test_ceil_u55_BI(test_data: input_t1):
+    module, data = test_data()
+    pipeline = EthosU55PipelineBI[input_t1](
+        module,
+        (data,),
+        module.aten_op,
+        module.exir_op,
+        run_on_fvp=True,
+    )
+    pipeline.run()
+
+
+@common.parametrize("test_data", test_data)
+@common.XfailIfNoCorstone320
+def test_ceil_u85_BI(test_data: input_t1):
+    module, data = test_data()
+    pipeline = EthosU85PipelineBI[input_t1](
+        module,
+        (data,),
+        module.aten_op,
+        module.exir_op,
+        run_on_fvp=True,
+    )
+    pipeline.run()

backends/arm/test/ops/test_unary.py renamed to backends/arm/test/ops/test_floor.py

@@ -14,24 +14,13 @@
     TosaPipelineMI,
 )
 
-
-input_t1 = Tuple[torch.Tensor]  # Input x
-
-
-class Ceil(torch.nn.Module):
-    def forward(self, x: torch.Tensor):
-        return torch.ceil(x)
-
-    op_name = "ceil"
-    aten_op = "torch.ops.aten.ceil.default"
-    exir_op = "executorch_exir_dialects_edge__ops_aten_ceil_default"
+input_t1 = Tuple[torch.Tensor]
 
 
 class Floor(torch.nn.Module):
     def forward(self, x: torch.Tensor):
         return torch.floor(x)
 
-    op_name = "floor"
     aten_op = "torch.ops.aten.floor.default"
     exir_op = "executorch_exir_dialects_edge__ops_aten_floor_default"
 
@@ -43,77 +32,34 @@ def forward(self, x: torch.Tensor):
 randn_neg = torch.randn(1, 4, 4, 4) - 10
 ramp = torch.arange(-16, 16, 0.2)
 
-
 test_data = {
-    "ceil_zeros": lambda: (
-        Ceil(),
-        zeros,
-    ),
-    "floor_zeros": lambda: (
-        Floor(),
-        zeros,
-    ),
-    "ceil_ones": lambda: (
-        Ceil(),
-        ones,
-    ),
-    "floor_ones": lambda: (
-        Floor(),
-        ones,
-    ),
-    "ceil_rand": lambda: (
-        Ceil(),
-        rand,
-    ),
-    "floor_rand": lambda: (
-        Floor(),
-        rand,
-    ),
-    "ceil_randn_pos": lambda: (
-        Ceil(),
-        randn_pos,
-    ),
-    "floor_randn_pos": lambda: (
-        Floor(),
-        randn_pos,
-    ),
-    "ceil_randn_neg": lambda: (
-        Ceil(),
-        randn_neg,
-    ),
-    "floor_randn_neg": lambda: (
-        Floor(),
-        randn_neg,
-    ),
-    "ceil_ramp": lambda: (
-        Ceil(),
-        ramp,
-    ),
-    "floor_ramp": lambda: (
-        Floor(),
-        ramp,
-    ),
+    "floor_zeros": lambda: (Floor(), zeros),
+    "floor_ones": lambda: (Floor(), ones),
+    "floor_rand": lambda: (Floor(), rand),
+    "floor_randn_pos": lambda: (Floor(), randn_pos),
+    "floor_randn_neg": lambda: (Floor(), randn_neg),
+    "floor_ramp": lambda: (Floor(), ramp),
 }
 
 
 @common.parametrize("test_data", test_data)
-def test_unary_tosa_MI(test_data: input_t1):
-    module, test_data = test_data()
+def test_floor_tosa_MI(test_data: input_t1):
+    module, data = test_data()
     pipeline = TosaPipelineMI[input_t1](
         module,
-        (test_data,),
+        (data,),
         module.aten_op,
         module.exir_op,
     )
     pipeline.run()
 
 
 @common.parametrize("test_data", test_data)
-def test_unary_tosa_BI(test_data: input_t1):
-    module, test_data = test_data()
+def test_floor_tosa_BI(test_data: input_t1):
+    module, data = test_data()
     pipeline = TosaPipelineBI[input_t1](
         module,
-        (test_data,),
+        (data,),
         module.aten_op,
         module.exir_op,
         atol=0.06,
@@ -124,11 +70,11 @@ def test_unary_tosa_BI(test_data: input_t1):
 
 @common.parametrize("test_data", test_data)
 @common.XfailIfNoCorstone300
-def test_unary_u55_BI(test_data: input_t1):
-    module, test_data = test_data()
+def test_floor_u55_BI(test_data: input_t1):
+    module, data = test_data()
     pipeline = EthosU55PipelineBI[input_t1](
         module,
-        (test_data,),
+        (data,),
         module.aten_op,
         module.exir_op,
         run_on_fvp=True,
@@ -138,11 +84,11 @@ def test_unary_u55_BI(test_data: input_t1):
 
 @common.parametrize("test_data", test_data)
 @common.XfailIfNoCorstone320
-def test_unary_u85_BI(test_data: input_t1):
-    module, test_data = test_data()
+def test_floor_u85_BI(test_data: input_t1):
+    module, data = test_data()
     pipeline = EthosU85PipelineBI[input_t1](
         module,
-        (test_data,),
+        (data,),
         module.aten_op,
         module.exir_op,
         run_on_fvp=True,

backends/arm/test/ops/test_mean_dim.py

@@ -210,6 +210,11 @@ class MeanDim(torch.nn.Module):
             (1, 2),
             False,
         ),
+        "rank5_2": lambda: (
+            torch.rand(1, 4, 7, 3, 2),
+            (2),
+            False,
+        ),
         "u55_avg_pool_not_supported": lambda: (
             torch.rand(1, 1, 1, 257),
             (0, 1, 2, 3),
@@ -255,6 +260,7 @@ def test_mean_dim_tosa_BI(test_data):
     "rank5_01234": "Rank 5 graph input currently not supported in EthosUBackend (passes since CHW are all averaged over so data order does not matter in this case)",
     "rank5_234": "Rank 5 graph input currently not supported in EthosUBackend (passes since CHW are all averaged over so data order does not matter in this case)",
     "rank5_12": "Rank 5 graph input currently not supported in EthosUBackend",
+    "rank5_2": "Rank 5 graph input currently not supported in EthosUBackend",
 }
 
 

backends/arm/test/ops/test_select.py

@@ -13,6 +13,7 @@
 from executorch.backends.arm.test.tester.test_pipeline import (
     EthosU55PipelineBI,
     EthosU85PipelineBI,
+    OpNotSupportedPipeline,
     TosaPipelineBI,
     TosaPipelineMI,
 )
@@ -32,6 +33,10 @@
     "select3d_0_dim_1_index": lambda: (torch.arange(-16, 16, 0.2), 0, 1),
 }
 
+test_data_not_delegated = {
+    "select3d_large_after_squeeze": lambda: (torch.rand(3, 64, 3, 49, 32), 0, 0),
+}
+
 aten_op_copy = "torch.ops.aten.select_copy.int"
 aten_op_int = "torch.ops.aten.select.int"
 
@@ -129,6 +134,19 @@ def test_select_int_u55_BI(test_data: Tuple):
     pipeline.run()
 
 
+@common.parametrize("test_data", test_data_not_delegated)
+def test_select_int_u55_BI_not_delegated(test_data: Tuple):
+    pipeline = OpNotSupportedPipeline[input_t1](
+        SelectInt(),
+        test_data(),
+        {aten_op_copy: 0},
+        n_expected_delegates=0,
+        quantize=True,
+        u55_subset=True,
+    )
+    pipeline.run()
+
+
 @common.parametrize("test_data", test_data_suite, x_fails)
 @common.XfailIfNoCorstone320
 def test_select_int_u85_BI_copy(test_data: Tuple):