Merge branch 'pytorch:main' into etdump-file-data-sink-test-coverage

Author: Megan0704-1

.lintrunner.toml

@@ -343,3 +343,29 @@ init_command = [
     '--dry-run={{DRYRUN}}',
     '--requirement=requirements-lintrunner.txt',
 ]
+
+[[linter]]
+code = 'LICENSELINT'
+include_patterns = [
+    '**/*',
+]
+exclude_patterns = [
+    '**/fb/**',
+    '.lintrunner.toml',
+]
+command = [
+    'python',
+    '-m',
+    'lintrunner_adapters',
+    'run',
+    'grep_linter',
+    '--pattern=Confidential and proprietary',
+    '--linter-name=LICENSELINT',
+    '--error-name=Wrong license',
+    """--error-description=\
+        Code contributed to ExecuTorch open source repo should have \
+        BSD-license header \
+    """,
+    '--',
+    '@{{PATHSFILE}}',
+]

backends/arm/_passes/arm_pass_manager.py

@@ -199,8 +199,8 @@ def transform_to_backend_pipeline(self, exported_program: ExportedProgram):
             )
 
     def transform_for_annotation_pipeline(self, graph_module: GraphModule):
-        self.add_pass(ScalarsToAttributePass())
         self.add_pass(ReplaceScalarWithTensorArgPass())
+        self.add_pass(ScalarsToAttributePass())
         self.add_pass(DecomposeLayerNormPass())
         self.add_pass(DecomposeVarPass())
         self.add_pass(DecomposeMeanDimPass())

backends/arm/_passes/arm_pass_utils.py

@@ -8,7 +8,7 @@
 # pyre-unsafe
 
 from inspect import isclass
-from typing import Optional
+from typing import Optional, Sequence
 
 import torch
 import torch.fx
@@ -149,7 +149,7 @@ def get_first_fake_tensor(node: torch.fx.Node) -> FakeTensor:
     If the node contains many fake tensors, return the first one.
     """
     if isinstance(
-        node.meta["val"], (tuple, torch.fx.immutable_collections.immutable_list)
+        node.meta["val"], (Sequence, torch.fx.immutable_collections.immutable_list)
     ):
         fake_tensor = node.meta["val"][0]
     else:

backends/arm/ethosu_backend.py

@@ -23,7 +23,6 @@
 
 # debug functionality
 logger = logging.getLogger(__name__)
-logger.setLevel(logging.WARNING)
 
 
 @final

backends/arm/operator_support/tosa_supported_operators.py

@@ -18,7 +18,9 @@
     FuseQuantizedActivationPass,
 )
 from executorch.backends.arm.tosa_specification import Tosa_0_80, TosaSpecification
+from executorch.exir import ExportedProgram
 from executorch.exir.dialects._ops import ops as exir_ops
+from torch.export.graph_signature import InputKind
 from torch.fx.passes.operator_support import any_chain, chain, OperatorSupportBase
 from torch.fx.passes.utils.source_matcher_utils import get_source_partitions
 
@@ -84,9 +86,10 @@ def get_registered_tosa_support_checks(
 
 def tosa_support_factory(
     tosa_spec: TosaSpecification,
+    exported_program: ExportedProgram,
     additional_checks: Optional[Sequence[OperatorSupportBase]] = None,
 ) -> OperatorSupportBase:
-    negative_checks: list[OperatorSupportBase] = []
+    negative_checks: list[OperatorSupportBase] = [CheckInt64Inputs(exported_program)]
     if not tosa_spec.support_float():
         negative_checks.append(NeedsDecompositionCheck())
         negative_checks.append(CheckProperQuantization())
@@ -247,6 +250,10 @@ def is_node_supported(
             exir_ops.edge.aten._log_softmax.default,
             exir_ops.edge.aten.var.correction,
             exir_ops.edge.aten.var.dim,
+            exir_ops.edge.aten.add.Scalar,
+            exir_ops.edge.aten.sub.Scalar,
+            exir_ops.edge.aten.mul.Scalar,
+            exir_ops.edge.aten.div.Scalar,
         ]
         return not needs_decomp
 
@@ -312,6 +319,8 @@ def is_node_supported(
             exir_ops.edge.aten.bmm.default,
             exir_ops.edge.aten.convolution.default,
             exir_ops.edge.aten.exp.default,
+            exir_ops.edge.aten.full.default,
+            exir_ops.edge.aten.full_like.default,
             exir_ops.edge.aten.hardtanh.default,
             exir_ops.edge.aten.linear.default,
             exir_ops.edge.aten.log.default,
@@ -371,3 +380,29 @@ def is_node_supported(
         if not output_quantized:
             return False
         return True
+
+
+class CheckInt64Inputs(OperatorSupportBase):
+
+    def __init__(self, exported_program: ExportedProgram):
+        self.input_names = [
+            spec.arg.name
+            for spec in exported_program.graph_signature.input_specs
+            if spec.kind == InputKind.USER_INPUT
+        ]
+        super().__init__()
+
+    def is_node_supported(
+        self, submodules: typing.Mapping[str, torch.nn.Module], node: fx.Node
+    ) -> bool:
+
+        for input_node in node.all_input_nodes:
+            # We can cast constant placeholders AOT, not call_functions.
+            if (
+                input_node.name in self.input_names
+                or not input_node.op == "placeholder"
+            ):
+                tensor = get_first_fake_tensor(input_node)
+                if tensor.dtype == torch.int64:
+                    return False
+        return True

backends/arm/process_node.py

@@ -14,11 +14,7 @@
 from executorch.backends.arm.operators.node_visitor import NodeVisitor
 from executorch.backends.arm.tosa_mapping import TosaArg
 from executorch.backends.arm.tosa_specification import TosaSpecification
-from executorch.backends.arm.tosa_utils import (
-    get_node_debug_info,
-    getNodeArgs,
-    tosa_shape,
-)
+from executorch.backends.arm.tosa_utils import getNodeArgs, tosa_shape
 from torch.export.exported_program import ExportedProgram
 
 
@@ -36,7 +32,7 @@ def process_call_function(
         output = TosaArg(node)
     except ValueError as e:
         raise ValueError(
-            f"Failed processing call_function:\n{get_node_debug_info(node)}"
+            f"Failed processing call_function: {node.name}. "
             "Is the original torch function supported?"
         ) from e
     tosa_graph.currRegion.currBasicBlock.addTensor(
@@ -74,7 +70,7 @@ def process_inputs(
         tosa_arg = TosaArg(node)
     except ValueError as e:
         raise ValueError(
-            f"Failed processing input placeholder:\n{get_node_debug_info(node)}"
+            f"Failed processing input placeholder: {node.name}. "
             "Is the original torch function supported?"
         ) from e
     input_shape = tosa_arg.shape
@@ -100,7 +96,7 @@ def process_inputs_to_parameters(
         tosa_arg = TosaArg(node)
     except ValueError as e:
         raise ValueError(
-            f"Failed processing parameter placeholder:\n{get_node_debug_info(node)}"
+            f"Failed processing parameter placeholder: {node.name}. "
             "Is the original torch function supported?"
         ) from e
     parameter_name = edge_program.graph_signature.inputs_to_parameters[tosa_arg.name]
@@ -129,7 +125,7 @@ def process_inputs_to_buffers(
         tosa_arg = TosaArg(node)
     except ValueError as e:
         raise ValueError(
-            f"Failed processing buffer placeholder:\n{get_node_debug_info(node)}"
+            f"Failed processing buffer placeholder: {node.name}. "
             "Is the original torch function supported?"
         ) from e
     buffer_name = edge_program.graph_signature.inputs_to_buffers[node.name]
@@ -157,7 +153,7 @@ def process_inputs_to_lifted_tensor_constants(
         tosa_arg = TosaArg(node)
     except ValueError as e:
         raise ValueError(
-            f"Failed processing lifted tensor constant placeholder:\n{get_node_debug_info(node)}"
+            f"Failed processing lifted tensor constant placeholder: {node.name}. "
             "Is the original torch function supported?"
         ) from e
     tensor_name = edge_program.graph_signature.inputs_to_lifted_tensor_constants[

backends/arm/scripts/build_executorch_runner.sh

@@ -78,6 +78,7 @@ source ${setup_path_script}
 pte_file=$(realpath ${pte_file})
 ethosu_tools_dir=$(realpath ${ethosu_tools_dir})
 ethos_u_root_dir="$ethosu_tools_dir/ethos-u"
+mkdir -p "${ethos_u_root_dir}"
 ethosu_tools_dir=$(realpath ${ethos_u_root_dir})
 
 et_build_dir=${et_build_root}/cmake-out
@@ -106,6 +107,7 @@ then
     fi
 fi
 
+mkdir -p "${output_folder}"
 output_folder=$(realpath ${output_folder})
 
 if [[ ${target} == *"ethos-u55"*  ]]; then
@@ -128,7 +130,6 @@ if [ "$build_with_etdump" = true ] ; then
 fi
 
 echo "Building with BundleIO/etdump/extra flags: ${build_bundleio_flags} ${build_with_etdump_flags} ${extra_build_flags}"
-mkdir -p "${output_folder}"
 
 cmake \
     -DCMAKE_BUILD_TYPE=${build_type}            \

backends/arm/test/misc/test_debug_feats.py

@@ -9,6 +9,7 @@
 import shutil
 import tempfile
 import unittest
+from importlib.metadata import version
 
 import torch
 from executorch.backends.arm.test import common
@@ -192,15 +193,16 @@ def test_collate_tosa_BI_tests(self):
             .to_edge_transform_and_lower()
             .to_executorch()
         )
+        et_version = version("executorch")
         # test that the output directory is created and contains the expected files
         assert os.path.exists(
             "test_collate_tosa_tests/tosa-bi/TestCollateTosaTests/test_collate_tosa_BI_tests"
         )
         assert os.path.exists(
-            "test_collate_tosa_tests/tosa-bi/TestCollateTosaTests/test_collate_tosa_BI_tests/output_tag6.tosa"
+            f"test_collate_tosa_tests/tosa-bi/TestCollateTosaTests/test_collate_tosa_BI_tests/output_tag6_TOSA-0.80+BI_{et_version}.tosa"
         )
         assert os.path.exists(
-            "test_collate_tosa_tests/tosa-bi/TestCollateTosaTests/test_collate_tosa_BI_tests/desc_tag6.json"
+            f"test_collate_tosa_tests/tosa-bi/TestCollateTosaTests/test_collate_tosa_BI_tests/desc_tag6_TOSA-0.80+BI_{et_version}.json"
         )
 
         os.environ.pop("TOSA_TESTCASES_BASE_PATH")

backends/arm/test/models/test_conformer.py

@@ -93,7 +93,7 @@ def test_conformer_tosa_BI(self):
             )
         )
 
-    @unittest.expectedFailure  # TODO(MLETORCH-635)
+    @conftest.expectedFailureOnFVP  # TODO(MLETORCH-635)
     def test_conformer_u55_BI(self):
         tester = (
             ArmTester(
@@ -115,7 +115,7 @@ def test_conformer_u55_BI(self):
                 inputs=get_test_inputs(self.dim, self.lengths, self.num_examples),
             )
 
-    @unittest.expectedFailure  # TODO(MLETORCH-635)
+    @conftest.expectedFailureOnFVP  # TODO(MLETORCH-635)
     def test_conformer_u85_BI(self):
         tester = (
             ArmTester(

backends/arm/test/models/test_nn_functional.py

@@ -0,0 +1,118 @@
+# 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.
+
+"""
+Tests 10 popular torch.nn.functional not tested in other ways or training related
+- normalize
+- grid_sample
+- one_hot
+- softplus
+- cosine_similarity
+- unfold
+- elu
+- fold
+- affine_grid
+- max_pool1d
+- threshold
+"""
+from typing import Callable
+
+import torch
+from executorch.backends.arm.test.common import parametrize
+from executorch.backends.arm.test.tester.test_pipeline import (
+    TosaPipelineBI,
+    TosaPipelineMI,
+)
+
+
+def module_factory(function: Callable) -> torch.nn.Module:
+    class ModuleWrapper(torch.nn.Module):
+        def forward(self, *args):
+            return function(*args)
+
+    return ModuleWrapper()
+
+
+example_input = torch.rand(1, 6, 16, 16)
+
+module_tests = {
+    "normalize": (module_factory(torch.nn.functional.normalize), (example_input,)),
+    "grid_sample": (
+        module_factory(torch.nn.functional.grid_sample),
+        (torch.rand(1, 1, 4, 4), torch.rand(1, 5, 5, 2)),
+    ),
+    "one_hot": (
+        module_factory(torch.nn.functional.one_hot),
+        (torch.randint(0, 5, (2, 2, 5, 5)), 5),
+    ),
+    "softplus": (module_factory(torch.nn.functional.softplus), (example_input,)),
+    "cosine_similarity": (
+        module_factory(torch.nn.functional.cosine_similarity),
+        (example_input, example_input),
+    ),
+    "unfold": (
+        module_factory(torch.nn.functional.unfold),
+        (torch.randn(1, 3, 10, 12), (4, 5)),
+    ),
+    "elu": (module_factory(torch.nn.functional.elu), (example_input,)),
+    "fold": (
+        module_factory(torch.nn.functional.fold),
+        (torch.randn(1, 12, 12), (4, 5), (2, 2)),
+    ),
+    "affine_grid": (
+        module_factory(torch.nn.functional.affine_grid),
+        (torch.rand(1, 2, 3), (1, 2, 10, 10)),
+    ),
+    "max_pool1d": (
+        module_factory(torch.nn.functional.max_pool1d),
+        (torch.randn(20, 16, 50), 4),
+    ),
+    "threshold": (
+        module_factory(torch.nn.functional.threshold),
+        (example_input, 0.5, 0.1),
+    ),
+}
+
+input_t = tuple[torch.Tensor]
+
+
+@parametrize(
+    "test_data", module_tests, xfails={"max_pool1d": "ValueError: Invalid TOSA graph"}
+)
+def test_nn_functional_MI(test_data):
+    module, inputs = test_data
+    pipeline = TosaPipelineMI[input_t](
+        module, inputs, "", use_to_edge_transform_and_lower=True
+    )
+    pipeline.pop_stage("check.aten")
+    pipeline.pop_stage("check_count.exir")
+    try:
+        pipeline.run()
+    except RuntimeError as e:
+        if (
+            "Ran model with TosaReferenceModelDispatch but never ran TOSABackend delegate."
+            not in str(e)
+        ):
+            raise e
+
+
+@parametrize("test_data", module_tests)
+def test_nn_functional_BI(test_data):
+    module, inputs = test_data
+    pipeline = TosaPipelineBI[input_t](
+        module, inputs, "", use_to_edge_transform_and_lower=True
+    )
+    pipeline.pop_stage("check.aten")
+    pipeline.pop_stage("check_count.exir")
+    pipeline.pop_stage("check.quant_nodes")
+    pipeline.pop_stage("check_not.quant_nodes")
+    try:
+        pipeline.run()
+    except RuntimeError as e:
+        if (
+            "Ran model with TosaReferenceModelDispatch but never ran TOSABackend delegate."
+            not in str(e)
+        ):
+            raise e