Merge branch 'main' into gasoonjia/drop-cuda-12.6

Author: digantdesai

.github/workflows/lint.yml

@@ -58,7 +58,7 @@ jobs:
           pip install -r requirements-lintrunner.txt
           USE_CPP=0 pip install --no-build-isolation third-party/ao
           # Match requirements-examples.txt for the model APIs checked by mypy.
-          pip install pytest numpy parameterized huggingface_hub "transformers==5.0.0rc1" timm expecttest types-requests tosa-tools
+          pip install pytest numpy parameterized huggingface_hub "transformers==5.11.0" timm expecttest types-requests tosa-tools
 
       - name: Generate mypy stubs for C++ bindings
         run: |

backends/arm/BUCK

@@ -136,6 +136,7 @@ fbcode_target(
         ":arm_compile_spec",
         "//caffe2:torch",
         "//executorch/backends/arm/_passes:passes",
+        "//executorch/backends/arm/operator_support:operator_support",
         "//executorch/backends/arm/tosa/dialect:lib",
         "//executorch/backends/arm/tosa:specification",
         "//executorch/backends/arm/tosa:partitioner",

backends/arm/operator_support/tosa_supported_operators.py

@@ -1021,22 +1021,54 @@ def is_node_supported(
 class CheckResolvedTensorShapes(OperatorSupportBase):
     """Reject nodes with unresolved tensor input or output shapes."""
 
-    def __init__(self, reporter: WhyNoPartitionReporter):
+    def __init__(
+        self,
+        reporter: WhyNoPartitionReporter,
+        *,
+        targets: Optional[Sequence[object]] = None,
+        reject_symbolic_scalars: bool = False,
+    ):
         """Initialize the check with a reporter.
 
         Args:
             reporter (WhyNoPartitionReporter): Reporter for rejection reasons.
+            targets (Optional[Sequence[object]]): Operators requiring resolved
+                tensor shapes. None checks all operators.
+            reject_symbolic_scalars (bool): Reject symbolic scalar inputs and
+                outputs on all call_function nodes, regardless of targets.
 
         """
         self.reporter = reporter
+        self.targets = targets
+        self.reject_symbolic_scalars = reject_symbolic_scalars
 
     def is_node_supported(
         self, submodules: typing.Mapping[str, torch.nn.Module], node: fx.Node
     ) -> bool:
-        """Return False when the node depends on unresolved tensor shapes."""
+        """Return False for unresolved shapes or disallowed symbolic scalars."""
         del submodules
         if node.op in ("placeholder", "output"):
             return True
+
+        if (
+            self.reject_symbolic_scalars
+            and node.op == "call_function"
+            and any(
+                isinstance(
+                    value.meta.get("val"), (torch.SymInt, torch.SymFloat, torch.SymBool)
+                )
+                for value in (node, *node.all_input_nodes)
+            )
+        ):
+            self.reporter.report_reject(
+                node, "Target does not support scalar symbolic inputs or outputs."
+            )
+            return False
+
+        # Require resolved tensor shapes only for the selected operators.
+        # Symbolic scalar restrictions above apply to all operators.
+        if self.targets is not None and node.target not in self.targets:
+            return True
         if node.op == "call_function" and node.target in (*Q_OPS, *DQ_OPS):
             return True
 

backends/arm/runtime/EthosUExecutionStats.cpp

@@ -63,14 +63,17 @@ void copy_pmu_events(
 }
 } // namespace
 
+// cppcheck-suppress unusedFunction
 EthosUStatsBuffer* set_ethosu_stats_buffer(EthosUStatsBuffer* buffer) noexcept {
   return capture_buffer.exchange(buffer, std::memory_order_acq_rel);
 }
 
+// cppcheck-suppress unusedFunction
 bool ethosu_execution_metrics_enabled() noexcept {
   return true;
 }
 
+// cppcheck-suppress unusedFunction
 executorch::runtime::Error set_ethosu55_65_pmu_events(
     executorch::runtime::ArrayRef<ethosu_pmu_event_type> events) noexcept {
   using executorch::runtime::Error;
@@ -81,6 +84,7 @@ executorch::runtime::Error set_ethosu55_65_pmu_events(
   return Error::Ok;
 }
 
+// cppcheck-suppress unusedFunction
 executorch::runtime::Error set_ethosu85_pmu_events(
     executorch::runtime::ArrayRef<ethosu_pmu_event_type> events) noexcept {
   using executorch::runtime::Error;
@@ -173,6 +177,7 @@ void ethosu_inference_end(struct ethosu_driver* drv, void* user_arg) {
     record.success = drv->job.result == ETHOSU_JOB_RESULT_OK;
     record.stats.device_identifier = reinterpret_cast<uintptr_t>(drv->dev.reg);
     record.stats.product = drv->dev.caps.product;
+    record.stats.macs_per_cycle = 1u << drv->dev.caps.log2_macs;
     record.stats.cycle_count = ETHOSU_PMU_Get_CCNTR(drv);
     record.stats.cycle_count_valid = true;
     const uint32_t overflow_status = ETHOSU_PMU_Get_CNTR_OVS(drv);
@@ -195,7 +200,7 @@ void ethosu_inference_end(struct ethosu_driver* drv, void* user_arg) {
       uint8_t metadata[executorch::backends::arm::kEthosUCycleMetadataMaxSize]{
           'E', 'U', 'C', '1'};
       write_le32(metadata + 4, record.stats.product);
-      write_le32(metadata + 8, 1u << drv->dev.caps.log2_macs);
+      write_le32(metadata + 8, record.stats.macs_per_cycle);
       write_le32(metadata + 12, static_cast<uint32_t>(record.stats.platform));
       const uint32_t flags =
           (record.stats.cycle_overflow ? 1u : 0u) | (record.success ? 2u : 0u);

backends/arm/runtime/EthosUExecutionStats.h

@@ -80,6 +80,8 @@ struct EthosUExecutionStats {
   uintptr_t device_identifier = 0;
   // Ethos-U product identifier for the NPU that produced this record.
   uint32_t product = 0;
+  // Number of MACs per cycle supported by the NPU.
+  uint32_t macs_per_cycle = 0;
   // Platform that produced this record.
   EthosUPlatform platform = EthosUPlatform::CoreDriver;
   // NPU PMU cycle count for this execution, when available.

backends/arm/scripts/setup-mlsdk-from-source.sh

@@ -15,7 +15,7 @@ root_dir="${et_dir}/examples/arm/arm-scratch"
 setup_path_script=""
 mlsdk_manifest_dir="ml-sdk-for-vulkan-manifest"
 mlsdk_manifest_url="${MLSDK_MANIFEST_URL:-https://github.com/arm/ai-ml-sdk-manifest.git}"
-mlsdk_manifest_tag="${MLSDK_MANIFEST_TAG:-refs/tags/v2026.12.0.dev20261027}" # Keep this in sync with backends/arm/requirements-arm-vgf.txt and backends/arm/requirements-arm-vgf-runtime.txt
+mlsdk_manifest_tag="${MLSDK_MANIFEST_TAG:-refs/tags/v2026.09.0}" # Keep this in sync with backends/arm/requirements-arm-vgf.txt and backends/arm/requirements-arm-vgf-runtime.txt
 
 enable_model_converter=0
 enable_vgf_lib=0

backends/arm/test/misc/test_compile_spec.py

@@ -108,6 +108,27 @@ def test_compile_spec_vgf_no_quant():
         EthosUCompileSpec._from_list(spec_list)
 
 
+def test_compile_spec_vgf_default_enables_bf16():
+    """The default VGF spec advertises BF16 without dropping other
+    extensions.
+    """
+    spec = VgfCompileSpec()
+    assert spec.tosa_spec.support_float()
+    assert spec.tosa_spec.support_integer()
+    assert spec.tosa_spec.support_extension("int4")
+    assert spec.tosa_spec.support_extension("int16")
+    assert spec.tosa_spec.support_extension("bf16")
+
+    roundtripped = VgfCompileSpec._from_list(spec._to_list())
+    assert roundtripped.tosa_spec.support_extension("bf16")
+
+
+def test_compile_spec_vgf_explicit_tosa_spec_does_not_enable_bf16():
+    """Opting into a narrower TOSA spec must still remain possible."""
+    spec = VgfCompileSpec("TOSA-1.0+FP+INT+int4+int16")
+    assert not spec.tosa_spec.support_extension("bf16")
+
+
 def test_compile_spec_vgf_defaults_leaky_relu_to_decompose():
     compile_spec = VgfCompileSpec()
     pipeline_config = compile_spec._get_pass_pipeline_config()

backends/arm/test/misc/test_tosa_operator_support.py

@@ -19,10 +19,14 @@
 )
 from executorch.backends.arm.operator_support.where_support import WhereSupported
 from executorch.backends.arm.tosa import TosaSpecification
+from executorch.backends.arm.tosa.compile_spec import TosaCompileSpec
+from executorch.backends.arm.tosa.partitioner import TOSAPartitioner
+from executorch.exir import to_edge
 from executorch.exir.backend.utils import WhyNoPartitionReporter
 from executorch.exir.dialects._ops import ops as exir_ops
 from torch._subclasses.fake_tensor import FakeTensorMode
 from torch.fx.experimental.symbolic_shapes import ShapeEnv
+from torch.fx.passes.operator_support import OpSupports
 
 
 def _fake_tensor(shape: tuple[int, ...], dtype: torch.dtype = torch.float32):
@@ -347,3 +351,36 @@ def test_int64_operand_check_widths(dtype, agree) -> None:
     node = graph.call_function(exir_ops.edge.aten.bitwise_or.Tensor, (x, y))
 
     assert _int64_operands_agree(node) == agree
+
+
+@pytest.mark.parametrize("boundary", ["input", "output", "internal"])
+def test_tosa_symbolic_scalar_boundaries(boundary, caplog) -> None:
+    class Reshape(torch.nn.Module):
+        def forward(self, x):
+            result = x.reshape(x.shape[0], -1).relu()
+            return (result, x.shape[0]) if boundary == "output" else result
+
+    program = to_edge(
+        torch.export.export(
+            Reshape(),
+            (torch.randn(2, 2, 3),),
+            dynamic_shapes=({0: torch.export.Dim("batch", min=1, max=4)},),
+        )
+    ).exported_program()
+    sym_size = program.graph.find_nodes(
+        op="call_function", target=torch.ops.aten.sym_size.int
+    )[0]
+    checks = (
+        [OpSupports.decline_if_node_in_names({sym_size.name})]
+        if boundary == "input"
+        else []
+    )
+    partitioner = TOSAPartitioner(
+        TosaCompileSpec("TOSA-1.1+FP+shape"), additional_checks=checks
+    )
+    with caplog.at_level("INFO"):
+        result = partitioner.partition(program)
+
+    assert bool(result.partition_tags) is (boundary == "internal")
+    if boundary != "internal":
+        assert "Partition has unsupported scalar" in caplog.text

backends/arm/test/misc/test_vgf_backend.py

@@ -10,6 +10,7 @@
 from unittest import mock
 
 import pytest
+import torch
 
 from executorch.backends.arm._passes import EnsureUniqueOutputNodesPass, RewriteConvPass
 from executorch.backends.arm._passes.arm_pass_manager import (
@@ -18,6 +19,9 @@
     PassInsertions,
 )
 
+from executorch.backends.arm.operator_support.tosa_supported_operators import (
+    CheckResolvedTensorShapes,
+)
 from executorch.backends.arm.vgf import backend, backend as vgf_backend, VgfCompileSpec
 from executorch.backends.arm.vgf._passes import GroupIndependentCustomShadersPass
 from executorch.backends.arm.vgf.backend import (
@@ -29,9 +33,13 @@
     vgf_compile,
 )
 from executorch.exir.backend.backend_details import PreprocessResult
+from executorch.exir.backend.utils import WhyNoPartitionReporter
+from executorch.exir.dialects._ops import ops as exir_ops
 from executorch.exir.pass_base import ExportPass
+from torch._subclasses.fake_tensor import FakeTensorMode
 from torch.export.exported_program import ExportedProgram
 from torch.fx import GraphModule
+from torch.fx.experimental.symbolic_shapes import ShapeEnv
 from torch.fx.passes.infra.pass_base import PassResult
 
 
@@ -540,3 +548,38 @@ def fake_converter_run(command, **kwargs):
     assert not (artifact_path / "output.tosa.vgf").exists()
 
     assert mock_run.call_count == 2
+
+
+@pytest.mark.parametrize("dynamic", [False, True])
+@pytest.mark.parametrize(
+    "target,args",
+    [
+        (exir_ops.edge.aten.view_copy.default, ([-1],)),
+        (exir_ops.edge.aten.permute_copy.default, ([1, 0],)),
+        (torch.ops.aten.sym_size.int, (0,)),
+        (exir_ops.edge.aten.relu.default, ()),
+    ],
+)
+def test_vgf_dynamic_shape_support(target, args, dynamic) -> None:
+    shape_env = ShapeEnv()
+    inputs = torch.empty((2, 3))
+    graph = torch.fx.Graph()
+    x = graph.placeholder("x")
+    with FakeTensorMode(shape_env=shape_env) as mode:
+        x.meta["val"] = mode.from_tensor(inputs, static_shapes=not dynamic)
+        node = graph.call_function(target, (x, *args))
+        node.meta["val"] = target(x.meta["val"], *args)
+
+    checker = CheckResolvedTensorShapes(
+        WhyNoPartitionReporter(),
+        targets=(
+            exir_ops.edge.aten.view_copy.default,
+            exir_ops.edge.aten.permute_copy.default,
+        ),
+        reject_symbolic_scalars=True,
+    )
+    expected_support = not dynamic or target == exir_ops.edge.aten.relu.default
+    assert checker.is_node_supported({}, node) is expected_support
+
+    default_checker = CheckResolvedTensorShapes(WhyNoPartitionReporter())
+    assert default_checker.is_node_supported({}, node) is (not dynamic)

backends/arm/test/misc/tosa_dialect/test_tosa_shape_support.py

@@ -128,13 +128,14 @@ def forward(self, x: torch.Tensor) -> torch.Tensor:
         return x.reshape(x.shape[0], 6)
 
 
-class ReturnSymSizeArithmetic(torch.nn.Module):
+class FullWithSymSizeArithmetic(torch.nn.Module):
     def __init__(self, operation) -> None:
         super().__init__()
         self.operation = operation
 
-    def forward(self, x: torch.Tensor) -> tuple[torch.Tensor, int]:
-        return x, self.operation(x.shape[0], 2)
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        size = self.operation(x.shape[0], 2) + 3
+        return torch.full((size,), 1.0)
 
 
 class Index(torch.nn.Module):
@@ -583,10 +584,10 @@ def test_shape_extension_rejects_sym_size_from_int64_without_int64_extension():
 
 
 def test_shape_extension_partitions_sym_size_int():
-    inputs = (torch.randn(2, 3),)
+    inputs = (torch.randn(2, 2, 3),)
     batch = Dim("batch", min=1, max=4)
     exported_program = _exported_program(
-        ReturnSymSize(),
+        ReshapeWithSymSize(),
         inputs,
         dynamic_shapes=({0: batch},),
     )
@@ -609,7 +610,7 @@ def test_shape_extension_partitions_symint_arithmetic(operation):
     inputs = (torch.randn(2, 3),)
     batch = Dim("batch", min=1, max=4)
     exported_program = _exported_program(
-        ReturnSymSizeArithmetic(operation),
+        FullWithSymSizeArithmetic(operation),
         inputs,
         dynamic_shapes=({0: batch},),
     )