Update base for Update on "[ET][EZ] Enable operator<< for Half tensor data"

Useful for debugging `Half` i.e. `fp16` models, when we have `EValue`s that are `Half` dtype and we do the following:
```
std::cout << "===== INPUT =====" << std::endl;
for (EValue& v : inputs) {
  std::cout << v << std::endl;
}

std::cout << "===== OUTPUT =====" << std::endl;
for (EValue& v : outputs) {
  std::cout << v << std::endl;
}
```

## Before
```
===== INPUT =====
tensor(sizes=[1, 3, 96, 72], [<unhandled scalar type 5>])
===== OUTPUT =====
tensor(sizes=[1, 2, 96, 72], [<unhandled scalar type 5>])
```

## After
```
===== INPUT =====
tensor(sizes=[1, 3, 96, 72], [0.279785, 0.271484, 0.364746, ..., 0.150391, 0.836426, 0.019043])
===== OUTPUT =====
tensor(sizes=[1, 2, 96, 72], [18.2344, -10.0938, 1.35059, ..., -33.6875, 4.07422, -22.5312])
```

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

[ghstack-poisoned]

Author: jorgep31415

.ci/scripts/setup-vulkan-linux-deps.sh

@@ -0,0 +1,48 @@
+
+#!/bin/bash
+# Copyright (c) Meta Platforms, Inc. and 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.
+
+set -ex
+
+install_swiftshader() {
+  _https_amazon_aws=https://ossci-android.s3.amazonaws.com
+  _swiftshader_archive=swiftshader-abe07b943-prebuilt.tar.gz
+  _swiftshader_dir=/tmp/swiftshader
+  mkdir -p $_swiftshader_dir
+
+  _tmp_archive="/tmp/${_swiftshader_archive}"
+
+  curl --silent --show-error --location --fail --retry 3 \
+    --output "${_tmp_archive}" "$_https_amazon_aws/${_swiftshader_archive}"
+
+  tar -C "${_swiftshader_dir}" -xzf "${_tmp_archive}"
+
+  export VK_ICD_FILENAMES="${_swiftshader_dir}/swiftshader/build/Linux/vk_swiftshader_icd.json"
+  export LD_LIBRARY_PATH="${_swiftshader_dir}/swiftshader/build/Linux/"
+}
+
+install_vulkan_sdk() {
+  VULKAN_SDK_VERSION=$1
+  _vulkan_sdk_url="https://sdk.lunarg.com/sdk/download/${VULKAN_SDK_VERSION}/linux/vulkansdk-linux-x86_64-${VULKAN_SDK_VERSION}.tar.gz"
+
+  _vulkan_sdk_dir=/tmp/vulkansdk
+  mkdir -p $_vulkan_sdk_dir
+
+  _tmp_archive="/tmp/vulkansdk.tar.gz"
+
+  curl --silent --show-error --location --fail --retry 3 \
+    --output "${_tmp_archive}" "${_vulkan_sdk_url}"
+
+  tar -C "${_vulkan_sdk_dir}" -xzf "${_tmp_archive}"
+
+  export PATH="${PATH}:${_vulkan_sdk_dir}/${VULKAN_SDK_VERSION}/x86_64/bin/"
+}
+
+VULKAN_SDK_VERSION="1.2.198.1"
+
+install_swiftshader
+install_vulkan_sdk "${VULKAN_SDK_VERSION}"

.github/workflows/_unittest.yml

@@ -28,6 +28,9 @@ jobs:
         CONDA_ENV=$(conda env list --json | jq -r ".envs | .[-1]")
         conda activate "${CONDA_ENV}"
 
+        # Setup swiftshader and Vulkan SDK which are required to build the Vulkan delegate
+        source .ci/scripts/setup-vulkan-linux-deps.sh
+
         # Setup MacOS dependencies as there is no Docker support on MacOS atm
         PYTHON_EXECUTABLE=python \
         EXECUTORCH_BUILD_PYBIND=ON \
@@ -37,6 +40,7 @@ jobs:
         # Run pytest with coverage
         pytest -n auto --cov=./ --cov-report=xml
         # Run gtest
+        LLVM_PROFDATA=llvm-profdata-12 LLVM_COV=llvm-cov-12 \
         test/run_oss_cpp_tests.sh
 
   macos:
@@ -66,4 +70,5 @@ jobs:
         # Run pytest with coverage
         ${CONDA_RUN} pytest -n auto --cov=./ --cov-report=xml
         # Run gtest
+        LLVM_PROFDATA="xcrun llvm-profdata" LLVM_COV="xcrun llvm-cov" \
         ${CONDA_RUN} test/run_oss_cpp_tests.sh

.github/workflows/trunk.yml

@@ -7,6 +7,9 @@ on:
       - release/*
     tags:
       - ciflow/trunk/*
+  pull_request:
+    paths:
+      - .ci/scripts/**
   workflow_dispatch:
 
 concurrency:

CMakeLists.txt

@@ -343,6 +343,23 @@ else()
   set(CMAKE_TOOLCHAIN_ANDROID OFF)
 endif()
 
+# Add code coverage flags to supported compilers
+if(EXECUTORCH_USE_CPP_CODE_COVERAGE)
+  if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+    string(APPEND CMAKE_C_FLAGS " --coverage -fprofile-abs-path")
+    string(APPEND CMAKE_CXX_FLAGS " --coverage -fprofile-abs-path")
+  elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
+    string(APPEND CMAKE_C_FLAGS " -fprofile-instr-generate -fcoverage-mapping")
+    string(APPEND CMAKE_CXX_FLAGS
+           " -fprofile-instr-generate -fcoverage-mapping"
+    )
+  else()
+    message(ERROR
+            "Code coverage for compiler ${CMAKE_CXX_COMPILER_ID} is unsupported"
+    )
+  endif()
+endif()
+
 # EXECUTORCH_BUILD_HOST_TARGETS: Option to control the building of host-only
 # tools like `flatc`, along with example executables like `executor_runner` and
 # libraries that it uses, like `gflags`. Disabling this can be helpful when

backends/qualcomm/builders/__init__.py

@@ -33,6 +33,7 @@
     op_mul,
     op_pad,
     op_pow,
+    op_prelu,
     op_quantize,
     op_relu,
     op_reshape,
@@ -42,6 +43,7 @@
     op_skip_ops,
     op_slice_copy,
     op_softmax,
+    op_space_to_depth,
     op_sqrt,
     op_squeeze,
     op_sub,
@@ -50,6 +52,7 @@
     op_transpose,
     op_unsqueeze,
     op_upsample_bilinear2d,
+    op_upsample_nearest2d,
 )
 
 __all__ = [
@@ -75,11 +78,13 @@
     op_layer_norm,
     op_linear,
     op_log_softmax,
+    op_matmul,
     op_max_pool2d,
     op_mean_dim,
     op_mul,
     op_pad,
     op_pow,
+    op_prelu,
     op_quantize,
     op_relu,
     op_reshape,
@@ -89,6 +94,7 @@
     op_skip_ops,
     op_slice_copy,
     op_softmax,
+    op_space_to_depth,
     op_squeeze,
     op_sqrt,
     op_sub,
@@ -97,5 +103,5 @@
     op_transpose,
     op_unsqueeze,
     op_upsample_bilinear2d,
-    op_matmul,
+    op_upsample_nearest2d,
 ]

backends/qualcomm/builders/op_prelu.py

@@ -0,0 +1,105 @@
+# Copyright (c) Qualcomm Innovation Center, Inc.
+# 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.
+from typing import Dict
+
+import executorch.backends.qualcomm.python.PyQnnWrapperAdaptor as PyQnnWrapper
+
+import torch
+from executorch.exir.dialects._ops import ops as exir_ops
+
+from .node_visitor import get_parameter, NodeVisitor, register_node_visitor
+from .qnn_constants import OpPRelu, QNN_OP_PACKAGE_NAME_QTI_AISW
+
+
+@register_node_visitor
+class PReLU(NodeVisitor):
+    target = ["aten.leaky_relu.default", "aten.prelu.default"]
+
+    def __init__(self, *args) -> None:
+        super().__init__(*args)
+
+    def define_node(
+        self,
+        node: torch.fx.Node,
+        nodes_to_wrappers: Dict[torch.fx.Node, PyQnnWrapper.TensorWrapper],
+    ) -> PyQnnWrapper.PyQnnOpWrapper:
+        input_node = node.args[0]
+        input_tensor = self.get_tensor(input_node, node)
+        prelu_inp_tensor_wrapper = self.define_tensor(
+            input_node,
+            input_tensor,
+            PyQnnWrapper.Qnn_TensorType_t.QNN_TENSOR_TYPE_NATIVE,
+            nodes_to_wrappers,
+            is_input_tensor=True,
+        )
+
+        if node.target.__name__ == "aten.leaky_relu.default":
+            coeff = 1e-2 if len(node.args) < 2 else node.args[1]
+            coeff_tensor = torch.full(input_tensor.shape, coeff).to(torch.float32)
+        else:
+            coeff_node = node.args[1]
+            coeff_tensor = torch.zeros(input_node.meta["val"].shape)
+            coeff = get_parameter(coeff_node, self.edge_program)
+            # per-channel activation
+            if coeff_node.meta["val"].shape[0] > 1:
+                for i in range(input_node.meta["val"].shape[1]):
+                    coeff_tensor = coeff_tensor.index_fill(
+                        1, torch.tensor([i]), coeff[i]
+                    )
+                if "axis_order" in input_node.meta:
+                    axis_order = input_node.meta["axis_order"]
+                    coeff_tensor = coeff_tensor.permute(dims=axis_order).contiguous()
+                # simple min-max quantization
+                coeff = torch.max(coeff).item()
+            else:
+                coeff = coeff.item()
+                coeff_tensor = torch.full(input_tensor.shape, coeff).to(torch.float32)
+
+        # 'graph', 'name', 'op', 'target', 'args', and 'kwargs'
+        scalar_node = torch.fx.Node(
+            node.graph,
+            node.name + "_runtime_scalar",
+            "call_function",
+            exir_ops.edge.aten.full.default,
+            (),  # args
+            {},  # kwargs
+        )
+        if pow_quant_attrs := node.meta.get("quant_attrs"):
+            quant_attrs = pow_quant_attrs.copy()
+            quant_range = quant_attrs["quant_max"] - quant_attrs["quant_min"]
+            # coeff is guaranteed to be positive
+            quant_attrs["zero_point"] = 0
+            quant_attrs["scale"] = coeff / quant_range
+            scalar_node.meta["quant_attrs"] = quant_attrs
+
+        scalar_tensor_wrapper = self.define_tensor(
+            scalar_node,
+            coeff_tensor,
+            PyQnnWrapper.Qnn_TensorType_t.QNN_TENSOR_TYPE_STATIC,
+            nodes_to_wrappers,
+            is_input_tensor=True,
+        )
+        prelu_input_tensors = [prelu_inp_tensor_wrapper, scalar_tensor_wrapper]
+
+        output_tensor = self.get_tensor(node, node)
+        output_tensor_wrapper = self.define_tensor(
+            node,
+            output_tensor,
+            PyQnnWrapper.Qnn_TensorType_t.QNN_TENSOR_TYPE_NATIVE,
+            nodes_to_wrappers,
+            is_input_tensor=False,
+        )
+        prelu_output_tensors = [output_tensor_wrapper]
+
+        prelu_op = PyQnnWrapper.PyQnnOpWrapper(
+            node.name,
+            QNN_OP_PACKAGE_NAME_QTI_AISW,
+            OpPRelu.op_name,
+        )
+        prelu_op.AddInputTensors(prelu_input_tensors)
+        prelu_op.AddOutputTensors(prelu_output_tensors)
+
+        return prelu_op

backends/qualcomm/builders/op_space_to_depth.py

@@ -0,0 +1,76 @@
+# Copyright (c) Qualcomm Innovation Center, Inc.
+# 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.
+
+from typing import Dict
+
+import executorch.backends.qualcomm.python.PyQnnWrapperAdaptor as PyQnnWrapper
+
+import numpy as np
+import torch
+
+from .node_visitor import NodeVisitor, register_node_visitor
+from .qnn_constants import OpSpaceToDepth, QNN_OP_PACKAGE_NAME_QTI_AISW
+
+
+@register_node_visitor
+class SpaceToDepthVisitor(NodeVisitor):
+    target = ["aten.pixel_unshuffle.default"]
+
+    def __init__(self, *args) -> None:
+        super().__init__(*args)
+
+    def define_node(
+        self,
+        node: torch.fx.Node,
+        nodes_to_wrappers: Dict[torch.fx.Node, PyQnnWrapper.TensorWrapper],
+    ) -> PyQnnWrapper.PyQnnOpWrapper:
+        input_node = node.args[0]
+        input_tensor = self.get_tensor(input_node, node)
+        input_tensor_wrapper = self.define_tensor(
+            input_node,
+            input_tensor,
+            PyQnnWrapper.Qnn_TensorType_t.QNN_TENSOR_TYPE_NATIVE,
+            nodes_to_wrappers,
+            is_input_tensor=True,
+        )
+
+        output_tensor = self.get_tensor(node, node)
+        output_tensor_wrapper = self.define_tensor(
+            node,
+            output_tensor,
+            PyQnnWrapper.Qnn_TensorType_t.QNN_TENSOR_TYPE_NATIVE,
+            nodes_to_wrappers,
+            is_input_tensor=False,
+        )
+
+        block_size = []
+        for index in range(1, 3):
+            block_size.append(input_tensor.shape[index] / output_tensor.shape[index])
+        block_size = np.array(block_size, dtype=np.uint32)
+        block_size_shape = [2]
+
+        space_to_depth_op = PyQnnWrapper.PyQnnOpWrapper(
+            node.name,
+            QNN_OP_PACKAGE_NAME_QTI_AISW,
+            OpSpaceToDepth.op_name,
+        )
+        space_to_depth_op.AddInputTensors([input_tensor_wrapper])
+        space_to_depth_op.AddOutputTensors([output_tensor_wrapper])
+        space_to_depth_op.AddTensorParam(
+            OpSpaceToDepth.param_block_size,
+            PyQnnWrapper.Qnn_DataType_t.QNN_DATATYPE_UINT_32,
+            len(block_size.shape),
+            block_size_shape,
+            block_size,
+            True,
+        )
+        space_to_depth_op.AddScalarParam(
+            OpSpaceToDepth.param_mode,
+            PyQnnWrapper.Qnn_DataType_t.QNN_DATATYPE_UINT_32,
+            {"data": np.uint32(OpSpaceToDepth.Mode.CRD)},
+        )
+
+        return space_to_depth_op

backends/qualcomm/builders/op_upsample_bilinear2d.py

@@ -60,7 +60,7 @@ def define_node(
         reisze_bilinear_op.AddScalarParam(
             OpResizeBilinear.param_half_pixel_centers,
             PyQnnWrapper.Qnn_DataType_t.QNN_DATATYPE_BOOL_8,
-            {"data": True},
+            {"data": not node.args[2]},
         )
 
         return reisze_bilinear_op