Update on "[ET-VK][ez] Allow logit linear layer to be lowered to Vulkan"

## Context

Due to poor performance of Vulkan's int4 linear operator, the final logit layer of the transformer model was not being delegated to vulkan, and was instead quantized and executed with the XNNPACK delegate.

However, with D72412950 / #9883 decent performance can now be achieved with Vulkan/s int4 linear op. Therefore, the final logit layer can be lowered to Vulkan.

## Changes

* Remove limit from `VkInt4WeightOnlyQuantizer` that was causing it to ignore the logit layer of the transformer
* Do not apply XNNPACK partitioner and quantizer when lowering with Vulkan

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

cc manuelcandales cbilgin

[ghstack-poisoned]

Author: SS-JIA

.ci/docker/ci_commit_pins/pytorch.txt

@@ -1 +1 @@
-7ae0ce6360b6e4f944906502d20da24c04debee5
+59d5cf083b4f860dea76fe8936076177f9367f10

backends/arm/test/models/test_conformer.py

@@ -31,7 +31,7 @@ class TestConformer(unittest.TestCase):
     # .to_executorch step, i.e. after Arm partitioner.
     ops_after_partitioner = {
         "executorch_exir_dialects_edge__ops_aten_max_default": 1,
-        "torch.ops.aten._assert_scalar.default": 10,
+        "torch.ops.aten._assert_scalar.default": 7,
         "torch.ops.aten._local_scalar_dense.default": 1,
     }
 

backends/arm/test/models/test_llama.py

@@ -11,6 +11,7 @@
 import sys
 import unittest
 
+import pytest
 import torch
 
 from executorch.backends.arm.test import common, conftest
@@ -102,7 +103,7 @@ def test_llama_tosa_MI(self):
         llama_model, llama_inputs, llama_meta = self.prepare_model()
 
         if llama_model is None and llama_inputs is None and llama_meta is None:
-            return
+            pytest.skip("Missing model and/or input files")
 
         with torch.no_grad():
             (

backends/vulkan/_passes/squeeze_unsqueeze_inputs.py

@@ -27,7 +27,7 @@ class SqueezeUnsqueezeInputs(ExportPass):
         exir_ops.edge.aten.gelu.default,
     }
 
-    def should_squeeze(self, op, shape: List[int]) -> bool:
+    def should_squeeze(self, op, shape: List[int]) -> bool:  # pyre-ignore
         if len(shape) == 3:
             return shape[1] == 1 and shape[0] > 1
         if len(shape) == 4:

backends/xnnpack/operators/op_slice_copy.py

@@ -69,7 +69,9 @@ def define_node(
             output_shape = [output_shape[i] for i in PERM_NCHW_TO_NHWC]
             dim_of_slice = PERM_NHWC_TO_NCHW[dim_of_slice]
 
-        slice_begin_index = cast(int, node.args[2])
+        slice_begin_index = 0
+        if len(node.args) > 2 and node.args[2]:
+            slice_begin_index = cast(int, node.args[2])
         if slice_begin_index < 0:
             slice_begin_index = input_shape[dim_of_slice] + slice_begin_index
 

backends/xnnpack/test/ops/test_slice_copy.py

@@ -69,6 +69,18 @@ def forward(self, x):
         # Note that two of the slices are optimized away as they are identity.
         self._test_slice_copy(ConvSlice(), inputs, 4, 2)
 
+    def test_fp32_slice_copy_default_start(self):
+        """
+        XNNPACK supports default start in slice op.
+        """
+
+        class Slice(torch.nn.Module):
+            def forward(self, x):
+                return torch.ops.aten.slice.Tensor(x, 0, None, 2)
+
+        inputs = (torch.randn(5, 5),)
+        self._test_slice_copy(Slice(), inputs, 1, 1)
+
     def test_fp32_slice_copy_stride_non_1(self):
         """
         XNNPACK does not support strided slicing.

devtools/etdump/etdump_filter.cpp

@@ -0,0 +1,95 @@
+/*
+ * 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.
+ */
+
+#include <executorch/devtools/etdump/etdump_filter.h>
+
+#include <executorch/runtime/core/error.h>
+
+using ::executorch::runtime::DelegateDebugIntId;
+using ::executorch::runtime::Error;
+using ::executorch::runtime::kUnsetDelegateDebugIntId;
+
+namespace executorch {
+namespace etdump {
+
+ETDumpFilter::ETDumpFilter() = default;
+
+Result<bool> ETDumpFilter::add_regex(string_view pattern) {
+  auto regex = std::make_unique<re2::RE2>(pattern.data());
+  if (!regex->ok()) {
+    return Error::InvalidArgument; // Error during regex compilation
+  }
+  regex_patterns_.emplace_back(std::move(regex));
+  return true;
+}
+
+Result<bool> ETDumpFilter::set_debug_handle_range(size_t start, size_t end) {
+  if (start >= end) {
+    return Error::InvalidArgument; // Start is greater than end
+  }
+  if (start < 0 || end < 0) {
+    return Error::InvalidArgument; // Start or end is negative
+  }
+  range_start_ = start;
+  range_end_ = end;
+  return true;
+}
+
+Result<bool> ETDumpFilter::filter_name_(const char* name) {
+  if (name == nullptr) {
+    return Error::InvalidArgument;
+  }
+  if (regex_patterns_.empty()) {
+    return true;
+  }
+  for (const auto& regex : regex_patterns_) {
+    if (RE2::FullMatch(name, *regex)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+Result<bool> ETDumpFilter::filter_delegate_debug_index_(
+    DelegateDebugIntId debug_handle) {
+  if (debug_handle == kUnsetDelegateDebugIntId) {
+    return Error::InvalidArgument; // Delegate debug index is unset
+  }
+
+  if (range_start_ == 0 && range_end_ == 0) {
+    return true;
+  }
+
+  if (debug_handle < range_start_ || debug_handle >= range_end_) {
+    return false;
+  }
+
+  return true;
+}
+
+Result<bool> ETDumpFilter::filter(
+    const char* name,
+    DelegateDebugIntId delegate_debug_index) {
+  if ((name == nullptr) == (delegate_debug_index == kUnsetDelegateDebugIntId)) {
+    return Error::InvalidArgument; // Name and delegate debug index should be
+                                   // both set or unset
+  }
+
+  if (name) {
+    return filter_name_(name);
+  } else {
+    return filter_delegate_debug_index_(delegate_debug_index);
+  }
+}
+
+size_t ETDumpFilter::get_n_regex() const {
+  return regex_patterns_.size();
+}
+
+} // namespace etdump
+} // namespace executorch

devtools/etdump/etdump_filter.h

@@ -0,0 +1,102 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <re2/re2.h>
+#include <memory>
+
+#include <executorch/runtime/core/event_tracer.h>
+#include <executorch/runtime/core/result.h>
+#include <executorch/runtime/platform/platform.h>
+
+namespace executorch::etdump {
+
+using ::executorch::aten::string_view;
+using ::executorch::runtime::Result;
+
+/**
+ * ETDumpFilter is a class that filters intermediate output based on output's
+ * name by full regex filtering, or delegate debug indices by range-based
+ * filtering.
+ *
+ * Note that this filter supports up to MAX_REGEX_PATTERNS regex patterns with a
+ * maximum length of MAX_PATTERN_LENGTH characters each.
+ */
+
+class ETDumpFilter : public ::executorch::runtime::EventTracerFilterBase {
+ public:
+  ETDumpFilter();
+  ~ETDumpFilter() override = default;
+  /**
+   * Adds a regex pattern to the filter.
+   *
+   * @param[in] pattern A c string representing the regex pattern to be added.
+   *
+   * @return A Result<bool> indicating the success or failure of adding the
+   * regex pattern.
+   *         - True if the pattern is successfully added.
+   *         - False if the pattern could not be added or if the maximum number
+   * of patterns is exceeded.
+   *         - An error code if number of pattern has reached to cap, or any
+   * error occurs during regex compilation.
+   */
+  Result<bool> add_regex(string_view pattern);
+  /**
+   * Sets the range for the delegate debug index filtering as [start, end).
+   * Note that this function will flush the existing range.
+   *
+   * @param[in] start The start of the range for filtering.
+   * @param[in] end The end of the range for filtering.
+   *
+   * @return A Result<bool> indicating the success or failure of setting the
+   * range.
+   *         - True if the range is successfully set.
+   *         - An error code if an error occurs.
+   */
+  Result<bool> set_debug_handle_range(size_t start, size_t end);
+
+  /**
+   * Filters events based on the given name or delegate debug index.
+   *
+   * Note that everytime only one of either the name or delegate_debug_index
+   * should be passed in.
+   *
+   * @param[in] name A pointer to a string representing the `name` of the
+   * event. If `delegate_debug_index` is not set to kUnsetDebugHandle, `name`
+   * should be set to nullptr.
+   *
+   * @param[in] delegate_debug_index A DebugHandle representing the debug index
+   * of the delegate. If `name` is not nullptr, this should be set to
+   * kUnsetDebugHandle.
+   *
+   * @return A Result<bool> indicating whether the event matches the filter
+   * criteria.
+   *         - True if the event matches the filter, or filter is unset.
+   *         - False if the event does not match or is unknown.
+   *         - An error code if an error occurs during filtering.
+   */
+  Result<bool> filter(
+      const char* name,
+      ::executorch::runtime::DelegateDebugIntId delegate_debug_index) override;
+
+  /**
+   * Returns the number of regex patterns in the filter.
+   */
+  size_t get_n_regex() const;
+
+ private:
+  std::vector<std::unique_ptr<re2::RE2>> regex_patterns_;
+  size_t range_start_ = 0;
+  size_t range_end_ = 0;
+  Result<bool> filter_name_(const char* name);
+  Result<bool> filter_delegate_debug_index_(
+      ::executorch::runtime::DelegateDebugIntId delegate_debug_index);
+};
+
+} // namespace executorch::etdump

devtools/etdump/etdump_flatcc.cpp

@@ -15,6 +15,7 @@
 #include <executorch/devtools/etdump/etdump_schema_flatcc_builder.h>
 #include <executorch/devtools/etdump/etdump_schema_flatcc_reader.h>
 #include <executorch/devtools/etdump/utils.h>
+#include <executorch/runtime/core/error.h>
 #include <executorch/runtime/core/exec_aten/exec_aten.h>
 #include <executorch/runtime/core/exec_aten/util/scalar_type_util.h>
 #include <executorch/runtime/platform/assert.h>
@@ -28,6 +29,7 @@ using ::executorch::runtime::ChainID;
 using ::executorch::runtime::DebugHandle;
 using ::executorch::runtime::DelegateDebugIdType;
 using ::executorch::runtime::DelegateDebugIntId;
+using ::executorch::runtime::Error;
 using ::executorch::runtime::EValue;
 using ::executorch::runtime::EventTracerEntry;
 using ::executorch::runtime::kUnsetDelegateDebugIntId;

devtools/etdump/etdump_flatcc.h

@@ -9,7 +9,6 @@
 #pragma once
 
 #include <cstdint>
-#include <memory>
 
 #include <executorch/devtools/etdump/data_sinks/buffer_data_sink.h>
 #include <executorch/devtools/etdump/data_sinks/data_sink_base.h>