Merge branch 'main' into toupstream/dim_pass

Author: SaoirseARM

.ci/scripts/build-qnn-sdk.sh

@@ -40,6 +40,8 @@ set_up_aot() {
       -DEXECUTORCH_BUILD_EXTENSION_FLAT_TENSOR=ON \
       -DEXECUTORCH_BUILD_EXTENSION_NAMED_DATA_MAP=ON \
       -DEXECUTORCH_BUILD_EXTENSION_TENSOR=ON \
+      -DEXECUTORCH_BUILD_KERNELS_QUANTIZED=ON \
+      -DEXECUTORCH_BUILD_KERNELS_QUANTIZED_AOT=ON \
       -DEXECUTORCH_ENABLE_EVENT_TRACER=ON \
       -DPYTHON_EXECUTABLE=python3
   cmake --build $PWD --target "PyQnnManagerAdaptor" -j$(nproc)

.github/workflows/android-release-artifacts.yml

@@ -53,6 +53,9 @@ jobs:
         run: |
           VERSION="${{ inputs.version }}"
           FLAVOR="${{ inputs.flavor }}"
+          if [ -z "$FLAVOR" ]; then
+            FLAVOR="xnnpack"
+          fi
           if [ -z "$VERSION" ]; then
             echo "No version name specified. Will create a snapshot AAR"
             echo "should-skip=false" >> $GITHUB_OUTPUT
@@ -115,9 +118,10 @@ jobs:
         fi
 
         FLAVOR="${{ inputs.flavor }}"
-        if [ ! -z "$FLAVOR" ]; then
-          GRADLE_ARGS+=" -Dflavor=${FLAVOR}"
+        if [ -z "$FLAVOR" ]; then
+          FLAVOR="xnnpack"
         fi
+        GRADLE_ARGS+=" -Dflavor=${FLAVOR}"
 
         if [[ "$FLAVOR" == "vulkan" || "$FLAVOR" == "all" || -z "$FLAVOR" ]]; then
           curl -O https://sdk.lunarg.com/sdk/download/1.4.321.1/linux/vulkansdk-linux-x86_64-1.4.321.1.tar.xz

.gitignore

@@ -18,6 +18,7 @@ cmake-out*
 cmake-out-android/
 build-android/
 build-x86/
+build-hexagon/
 dist/
 arm-scratch/
 executorch.egg-info

CMakeLists.txt

@@ -50,6 +50,17 @@ project(executorch)
 
 set(EXECUTORCH_ROOT ${CMAKE_CURRENT_SOURCE_DIR})
 
+# Hexagon toolchain with release build complains about code in third party
+# libraries.
+if("${CMAKE_SYSTEM_PROCESSOR}" MATCHES "Hexagon" AND "${CMAKE_BUILD_TYPE}"
+                                                     STREQUAL "Release"
+)
+  add_compile_options(
+    -Wno-error=format -Wno-error=implicit-int-conversion
+    -Wno-error=unused-variable -Wno-error=unused-function
+  )
+endif()
+
 # --- ExecuTorch Version ---
 # Parse version from version.txt (single source of truth)
 file(READ "${EXECUTORCH_ROOT}/version.txt" ET_VERSION_STRING)

backends/arm/_passes/insert_table_ops.py

@@ -39,6 +39,7 @@ class TableOps:
         exir_ops.edge.aten.floor.default: torch.floor,
         exir_ops.edge.aten.log.default: torch.log,
         exir_ops.edge.aten.log1p.default: torch.log1p,
+        exir_ops.edge.aten.log10.default: torch.log10,
         exir_ops.edge.aten.reciprocal.default: torch.reciprocal,
         exir_ops.edge.aten.rsqrt.default: torch.rsqrt,
         exir_ops.edge.aten.sigmoid.default: torch.sigmoid,

backends/arm/_passes/rewrite_conv_pass.py

@@ -167,8 +167,8 @@ def _add_bias(
         weight_node: torch.fx.Node,
     ) -> torch.fx.Node:
         output_channels = get_first_fake_tensor(node).shape[1]
-        # add a node containging zeros if quantized, use int32, otherwise use float32
-        if "output_qparams" in node.meta and len(node.meta["output_qparams"]) > 0:
+        # add a node containing zeros if quantized, use int32, otherwise use float32
+        if self._is_quantized_conv(node):
             bias_data = torch.zeros(size=(output_channels,), dtype=torch.int32)
         else:
             output_dtype = node.meta["val"].dtype
@@ -188,9 +188,40 @@ def _add_bias(
         node.update_arg(2, bias_node)
         return bias_node
 
-    def insert_output_rescale(self, graph_module, node):
-        input_qparams = get_input_qparams(node)
-        output_qparams = get_output_qparams(node)[0]
+    def _is_quantized_conv(self, node: torch.fx.Node) -> bool:
+        return bool(node.meta.get("input_qparams", {}))
+
+    def _get_effective_output_qparams(self, node: torch.fx.Node):
+        """Return the quantized output domain for a conv node.
+
+        Quantization annotation may place output qparams on a following
+        activation instead of on the conv itself. If that activation is not
+        fuseable, it survives as a quantized ``clamp`` and still owns the
+        branch output qparams needed for the conv output rescale.
+
+        """
+        output_qparams = node.meta.get("output_qparams", {})
+        if output_qparams:
+            return output_qparams
+
+        users = list(node.users)
+        if len(users) != 1:
+            raise ValueError(
+                f"RewriteConvPass: No output quantization parameter found in node {node}\n"
+                f"original_aten={node.meta.get('original_aten', 'None')}"
+            )
+
+        activation = users[0]
+        if activation.target == exir_ops.edge.aten.clamp.default:
+            activation_output_qparams = activation.meta.get("output_qparams", {})
+            if activation_output_qparams:
+                return activation_output_qparams
+
+        return get_output_qparams(node)
+
+    def insert_output_rescale(self, graph_module, source_node, conv_node):
+        input_qparams = get_input_qparams(source_node)
+        output_qparams = self._get_effective_output_qparams(source_node)[0]
         weight_qparams = input_qparams[1]
         input_qparams = input_qparams[0]
         is_per_channel = weight_qparams.per_channel
@@ -207,18 +238,18 @@ def insert_output_rescale(self, graph_module, node):
                 itertools.cycle([output_qparams.get_scale_per_tensor()]),
             )
         ]
-        with graph_module.graph.inserting_after(node):
+        with graph_module.graph.inserting_after(conv_node):
             rescale_node = create_node(
                 graph=graph_module.graph,
                 op_target=exir_ops.backend.tosa.RESCALE.default,
                 args=(
-                    node,
+                    conv_node,
                     output_qparams.dtype,
                     post_conv2d_scale,
                     0,
                     output_qparams.get_zp_per_tensor(),
                 ),
-                from_node=node,
+                from_node=source_node,
             )
         return rescale_node
 
@@ -347,15 +378,17 @@ def call(self, graph_module: torch.fx.GraphModule) -> PassResult:  # noqa: C901
                 tosa_node_fake_tensor.dtype == torch.int32
                 and input_fake_tensor.dtype == torch.int8
             ):
-                output_rescale = self.insert_output_rescale(graph_module, tosa_op)
+                output_rescale = self.insert_output_rescale(graph_module, node, tosa_op)
                 node.replace_all_uses_with(output_rescale)
             elif (
                 tosa_node_fake_tensor.dtype == torch.int32
                 and input_fake_tensor.dtype == torch.int16
             ):
                 has_bias = len(node.meta["input_qparams"]) > 2
                 if not has_bias:
-                    output_rescale = self.insert_output_rescale(graph_module, tosa_op)
+                    output_rescale = self.insert_output_rescale(
+                        graph_module, node, tosa_op
+                    )
                     node.replace_all_uses_with(output_rescale)
                 else:
                     node.replace_all_uses_with(tosa_op)

backends/arm/operator_support/tosa_profile_supported_op_lists.py

@@ -56,6 +56,7 @@
     exir_ops.edge.aten.expm1.default,
     exir_ops.edge.aten.log.default,
     exir_ops.edge.aten.log1p.default,
+    exir_ops.edge.aten.log10.default,
     exir_ops.edge.aten.linear.default,
     exir_ops.edge.aten.split_with_sizes_copy.default,
     exir_ops.edge.aten.split_copy.Tensor,

backends/arm/quantizer/quantization_annotator.py

@@ -502,6 +502,7 @@ def _match_pattern(
     torch.ops.aten.sinh.default,
     torch.ops.aten.atan.default,
     torch.ops.aten.log1p.default,
+    torch.ops.aten.log10.default,
     torch.ops.aten.acosh.default,
     torch.ops.aten.sign.default,
     torch.ops.aten.asinh.default,

backends/arm/runtime/VGFSetup.cpp

@@ -173,7 +173,12 @@ VkResult allocate_tensor(
       .memoryTypeIndex = memory_index,
   };
 
-  vkAllocateMemory(device, &allocate_info, nullptr, memory);
+  result = vkAllocateMemory(device, &allocate_info, nullptr, memory);
+  if (result != VK_SUCCESS) {
+    ET_LOG(Error, "Failed to allocate tensor memory, error %d", result);
+    vkDestroyTensorARM(device, *tensor, nullptr);
+    return result;
+  }
 
   // Bind tensor to memory
   const VkBindTensorMemoryInfoARM bind_info = {
@@ -183,7 +188,13 @@ VkResult allocate_tensor(
       .memory = *memory,
       .memoryOffset = 0,
   };
-  vkBindTensorMemoryARM(device, 1, &bind_info);
+  result = vkBindTensorMemoryARM(device, 1, &bind_info);
+  if (result != VK_SUCCESS) {
+    ET_LOG(Error, "Failed to bind tensor memory, error %d", result);
+    vkDestroyTensorARM(device, *tensor, nullptr);
+    vkFreeMemory(device, *memory, nullptr);
+    return result;
+  }
 
   VkTensorViewCreateInfoARM tensor_view_info = {
       .sType = VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM,
@@ -799,7 +810,10 @@ bool VgfRepr::process_vgf(const char* vgf_data, ArrayRef<CompileSpec> specs) {
         .bindPoint = bind_point_requirement.bindPoint,
         .objectIndex = 0, // NOTE: tied to numObjects assert above
     };
-    VkMemoryRequirements2 memory_requirements;
+    VkMemoryRequirements2 memory_requirements = {
+        .sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
+        .pNext = nullptr,
+    };
     vkGetDataGraphPipelineSessionMemoryRequirementsARM(
         vk_device, &memory_requirements_info, &memory_requirements);
 

backends/arm/test/ops/test_log10.py

@@ -0,0 +1,87 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+# Copyright 2024-2026 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 (
+    EthosU55PipelineINT,
+    EthosU85PipelineINT,
+    TosaPipelineINT,
+    VgfPipeline,
+)
+
+aten_op = "torch.ops.aten.log10.default"
+exir_op = "executorch_exir_dialects_edge__ops_aten_log10_default"
+
+input_t1 = Tuple[torch.Tensor]
+
+
+def _tensor(values):
+    return torch.tensor(values, dtype=torch.float32)
+
+
+test_data_suite = {
+    # (test_name, test_data)
+    "tiny_positive": lambda: (_tensor([5e-4, 8e-4, 9e-4, 1e-3, 1.2e-3])),
+    "mixed_range": lambda: (_tensor([1e-4, 5e-4, 2e-3, 1e-2, 5e-2])),
+    "ones_rank4": lambda: (torch.ones(1, 10, 10, 10)),
+    "ones_rank3": lambda: (torch.ones(10, 10, 10)),
+    "rand": lambda: (torch.rand(10, 10) + 0.001),
+    "randn_pos": lambda: (torch.randn(10) + 10),
+    "randn_spread": lambda: (torch.max(torch.Tensor([0.1]), torch.randn(10) * 100)),
+    "ramp": lambda: (torch.arange(0.01, 20, 0.2)),
+}
+
+
+class Log10(torch.nn.Module):
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return torch.log10(x)
+
+
+@common.parametrize("test_data", test_data_suite)
+def test_log10_tosa_INT(test_data: input_t1):
+    pipeline = TosaPipelineINT[input_t1](Log10(), (test_data(),), aten_op, exir_op)
+    pipeline.run()
+
+
+@common.parametrize("test_data", test_data_suite)
+@common.XfailIfNoCorstone300
+def test_log10_u55_INT(test_data: input_t1):
+    EthosU55PipelineINT[input_t1](
+        Log10(),
+        (test_data(),),
+        aten_op,
+        exir_op,
+    ).run()
+
+
+@common.parametrize("test_data", test_data_suite)
+@common.XfailIfNoCorstone320
+def test_log10_u85_INT(test_data: input_t1):
+    EthosU85PipelineINT[input_t1](
+        Log10(),
+        (test_data(),),
+        aten_op,
+        exir_op,
+    ).run()
+
+
+@common.parametrize("test_data", test_data_suite)
+@common.SkipIfNoModelConverter
+def test_log10_vgf_quant(test_data: input_t1):
+    pipeline = VgfPipeline[input_t1](
+        Log10(),
+        (test_data(),),
+        aten_op,
+        exir_op,
+        quantize=True,
+    )
+    pipeline.run()