Move the sdpa_bitwise_mask_gen test onto the OSS-exported path (#23157)

Summary:

`generic/operators/op_sdpa_bitwise_mask_gen.cpp` exports to GitHub, but
`generic/operators/tests/fb/` does not, so the test that pins the kernel's
contract was invisible to every OSS consumer of it. The diff above this one
changes the exported kernel's float comparison; without this move it would
export with nothing guarding it.

`generic/operators/tests/` (non-`fb`) is the exported sibling, and
`backends/cadence/CMakeLists.txt` already reaches for
`${TARGET_DIR}/operators/tests/CMakeLists.txt` for whichever backend is
selected, guarded by `EXISTS`, so adding that file is the supported way to
opt a backend in. `TARGET_DIR` defaults to `generic`. The new
`CMakeLists.txt` mirrors `hifi/operators/tests/CMakeLists.txt`, naming its
target `cadence_generic_op_tests` to match the
`cadence_${TARGET_DIR}_op_tests` pattern `test-cadence-xtensa.sh` derives.

This is a relocation plus one formatting change. The test file moves
unmodified except for a single clang-format line break at the
`float_expected` initialisation: `tests/fb/` does not export, so the file had
never been seen by OSS `lintrunner`, and putting it on the exported path
subjects it to the CLANGFORMAT check for the first time. The BUCK target is
the same rule verbatim, just in `tests/BUCK` instead of `tests/fb/BUCK`. The
ISS benchmark stays in `tests/fb/` -- it calls `xthal_get_ccount()` and pins
`DLA_V130_1p0v2`, so it cannot build outside Meta.

Caveat for a follow-up, deliberately not done here: OSS CI does not yet reach
this target. `build-cadence-runner.yml` runs `_xtensa_test.yml` with
`backend: hifi4` only, and `test-cadence-xtensa.sh` maps `CADENCE_OPT_FLAG`
to `hifi`/`vision`/`fusion_g3` and errors on anything else, so there is no
path that selects `generic`. Wiring that up means changing CI behaviour and
picking an Xtensa core for the generic build, which does not belong in a
relocation.

Differential Revision: D121265174

Pull Request resolved: #23157

Author: mvartani-meta

backends/cadence/generic/operators/tests/BUCK

@@ -0,0 +1,24 @@
+load("@fbsource//tools/build_defs:platform_defs.bzl", "CXX")
+load("@fbsource//tools/target_determinator/macros:ci.bzl", "ci")
+load("@fbsource//xplat/on_device_ai/Assistant/Jarvis/build:cxx_wrapper.bzl", "jarvis_wrapper")
+
+oncall("executorch")
+
+jarvis_wrapper.cxx_test(
+    name = "test_op_sdpa_bitwise_mask_gen",
+    srcs = [
+        "test_op_sdpa_bitwise_mask_gen.cpp",
+    ],
+    compatible_backends = ["generic"],
+    labels = [ci.linux(ci.mode("fbsource//arvr/mode/platform010/dev"))],
+    platforms = CXX,
+    visibility = [
+        "fbsource//xplat/executorch/backends/cadence/...",
+        "fbcode//executorch/backends/cadence/...",
+    ],
+    deps = [
+        "fbsource//xplat/executorch/backends/cadence/generic/operators:op_sdpa_bitwise_mask_gen",
+        "fbsource//xplat/executorch/kernels/test:gtest_utils",
+        "fbsource//xplat/executorch/runtime/core/exec_aten/testing_util:tensor_util",
+    ],
+)

backends/cadence/generic/operators/tests/CMakeLists.txt

@@ -0,0 +1,74 @@
+# 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.
+#
+# gtest op-level tests for the Cadence generic (reference) backend,
+# cross-compiled for Xtensa and run on the Instruction Set Simulator (xt-run).
+# Each test calls the kernel directly (impl::generic::native::<op>) and checks
+# with EXPECT_TENSOR_EQ, mirroring the BUCK tests. Built only when
+# EXECUTORCH_BUILD_CADENCE_OP_TESTS is ON; see .ci/scripts/test-cadence-xtensa.sh.
+
+cmake_minimum_required(VERSION 3.19)
+
+# Tame the vendored googletest build on the Xtensa clang toolchain. It hardcodes
+# -Werror -Wconversion on its own sources, which clang-10 trips (e.g. an int ->
+# signed char narrowing in gtest-port.h); -Wno-error keeps those non-fatal. A
+# ccache launcher also preprocesses then recompiles the .i, where the -I dirs
+# are unused and clang warns; -Qunused-arguments silences that. These land after
+# googletest's own flags, so they win, and apply to this whole subtree.
+add_compile_options(-Qunused-arguments -Wno-error)
+
+# Let files say "include <executorch/path/to/header.h>".
+set(_common_include_directories
+    ${EXECUTORCH_ROOT}/.. ${EXECUTORCH_ROOT}/runtime/core/portable_type/c10
+)
+
+# Build googletest FOR the Xtensa target. find_package(GTest) would resolve the
+# HOST gtest, which cannot link Xtensa objects, so add the source tree instead.
+# The cadence toolchain uses -stdlib=libc++ (exceptions/RTTI/iostream
+# available); the ISS is single-threaded, so disable pthreads.
+if(NOT TARGET gtest)
+  set(gtest_disable_pthreads
+      ON
+      CACHE BOOL "" FORCE
+  )
+  set(INSTALL_GTEST
+      OFF
+      CACHE BOOL "" FORCE
+  )
+  add_subdirectory(
+    ${EXECUTORCH_ROOT}/third-party/googletest
+    ${CMAKE_CURRENT_BINARY_DIR}/googletest
+  )
+endif()
+
+# Op-level gtests, one source per operator. Each calls its kernel directly and
+# checks with EXPECT_TENSOR_EQ, mirroring the BUCK tests.
+add_executable(
+  cadence_generic_op_tests
+  test_op_sdpa_bitwise_mask_gen.cpp
+  ${EXECUTORCH_ROOT}/runtime/core/exec_aten/testing_util/tensor_util.cpp
+)
+target_compile_definitions(cadence_generic_op_tests PRIVATE GTEST_HAS_PTHREAD=0)
+target_include_directories(
+  cadence_generic_op_tests PRIVATE ${_common_include_directories}
+                                   ${CMAKE_BINARY_DIR}
+)
+
+# Direct-call: link the libs that define the kernels under test. custom_ops has
+# the cadence-specific ops; aten_ops_cadence has the aten-compliant ones;
+# cadence_kernels is the shared kernel layer; executorch provides the platform
+# layer the tests' runtime_init() needs. No cadence_ops_lib registry is needed
+# for direct-call tests.
+target_link_libraries(
+  cadence_generic_op_tests
+  PRIVATE gtest
+          gtest_main
+          gmock
+          executorch
+          custom_ops
+          aten_ops_cadence
+          cadence_kernels
+)

backends/cadence/generic/operators/tests/test_op_sdpa_bitwise_mask_gen.cpp

@@ -0,0 +1,219 @@
+/*
+ * 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/backends/cadence/generic/operators/op_sdpa_bitwise_mask_gen.h>
+
+#include <executorch/kernels/test/TestUtil.h>
+#include <executorch/runtime/core/exec_aten/exec_aten.h>
+#include <executorch/runtime/core/exec_aten/testing_util/tensor_factory.h>
+#include <executorch/runtime/core/exec_aten/testing_util/tensor_util.h>
+#include <gtest/gtest.h>
+
+#include <cstdint>
+#include <vector>
+
+namespace impl {
+namespace generic {
+namespace native {
+namespace {
+
+using ::executorch::aten::ScalarType;
+using ::executorch::aten::Tensor;
+using ::executorch::runtime::testing::TensorFactory;
+
+// Transcription of the packing loop as it was written before the data pointers
+// were hoisted out of it. Tests compare the kernel against this so that any
+// rewrite of the loop body has to stay byte-identical.
+template <typename T, typename MaskedPred>
+std::vector<uint8_t> reference_pack(
+    const std::vector<T>& in,
+    MaskedPred is_masked) {
+  std::vector<uint8_t> packed(in.size() / 8);
+  for (size_t i = 0, out_index = 0; i < in.size(); i += 8, out_index++) {
+    uint8_t packed_mask = 0;
+    for (size_t j = 0; j < 8; j++) {
+      packed_mask |= static_cast<uint8_t>(is_masked(in[i + j])) << j;
+    }
+    packed[out_index] = packed_mask;
+  }
+  return packed;
+}
+
+// A bool mask uses True = keep, so the kernel inverts it.
+std::vector<uint8_t> reference_pack_bool(const std::vector<uint8_t>& in) {
+  return reference_pack(in, [](uint8_t v) { return !v; });
+}
+
+std::vector<uint8_t> reference_pack_float(
+    const std::vector<float>& in,
+    double threshold) {
+  return reference_pack(in, [threshold](float v) { return v < threshold; });
+}
+
+class GenericSdpaBitwiseMaskGenTest : public OperatorTest {
+ protected:
+  Tensor&
+  sdpa_bitwise_mask_gen_out(const Tensor& mask, double threshold, Tensor& out) {
+    return impl::generic::native::sdpa_bitwise_mask_gen_out(
+        context_, mask, threshold, out);
+  }
+};
+
+// Pins the bit order and polarity with hand-computed bytes: element j of each
+// group of 8 lands in bit j, and a False (blocked) input sets that bit.
+TEST_F(GenericSdpaBitwiseMaskGenTest, BoolMaskPacksBlockedAsSetBitLsbFirst) {
+  TensorFactory<ScalarType::Bool> tf_bool;
+  TensorFactory<ScalarType::Byte> tf_uint8;
+
+  // clang-format off
+  Tensor mask = tf_bool.make(
+      {4, 8},
+      {
+          // All kept -> no bits set.
+          1, 1, 1, 1, 1, 1, 1, 1,
+          // All blocked -> every bit set.
+          0, 0, 0, 0, 0, 0, 0, 0,
+          // Only element 0 blocked -> bit 0.
+          0, 1, 1, 1, 1, 1, 1, 1,
+          // Only element 3 blocked -> bit 3.
+          1, 1, 1, 0, 1, 1, 1, 1,
+      });
+  // clang-format on
+
+  Tensor out = tf_uint8.zeros({4, 1});
+  Tensor expected = tf_uint8.make({4, 1}, {0x00, 0xFF, 0x01, 0x08});
+
+  sdpa_bitwise_mask_gen_out(mask, 0.0, out);
+
+  EXPECT_TENSOR_EQ(out, expected);
+}
+
+// Values equal to the threshold are kept; only strictly smaller ones are
+// masked.
+TEST_F(GenericSdpaBitwiseMaskGenTest, FloatMaskThresholdIsStrictlyLess) {
+  TensorFactory<ScalarType::Float> tf_float;
+  TensorFactory<ScalarType::Byte> tf_uint8;
+
+  const double threshold = -1.5;
+
+  // clang-format off
+  Tensor mask = tf_float.make(
+      {3, 8},
+      {
+          // Exactly at the threshold, and above it -> kept.
+          -1.5, -1.5, -1.5, -1.5, 0.0, 1.0, 100.0, -1.4999,
+          // Below the threshold -> masked.
+          -1.6, -2.0, -100.0, -1.50001, -3.0, -4.0, -5.0, -6.0,
+          // Alternating, starting with a masked element.
+          -2.0, 0.0, -2.0, 0.0, -2.0, 0.0, -2.0, 0.0,
+      });
+  // clang-format on
+
+  Tensor out = tf_uint8.zeros({3, 1});
+  Tensor expected = tf_uint8.make({3, 1}, {0x00, 0xFF, 0x55});
+
+  sdpa_bitwise_mask_gen_out(mask, threshold, out);
+
+  EXPECT_TENSOR_EQ(out, expected);
+}
+
+TEST_F(GenericSdpaBitwiseMaskGenTest, BoolMaskMatchesReferencePacking) {
+  TensorFactory<ScalarType::Bool> tf_bool;
+  TensorFactory<ScalarType::Byte> tf_uint8;
+
+  constexpr int kRows = 7;
+  constexpr int kCols = 64;
+
+  // Causal-style mask: row r keeps the first 8*(r+1) columns.
+  std::vector<uint8_t> in(kRows * kCols);
+  for (int r = 0; r < kRows; r++) {
+    for (int c = 0; c < kCols; c++) {
+      in[r * kCols + c] = static_cast<uint8_t>(c < 8 * (r + 1));
+    }
+  }
+
+  Tensor mask = tf_bool.make({kRows, kCols}, in);
+  Tensor out = tf_uint8.zeros({kRows, kCols / 8});
+  Tensor expected = tf_uint8.make({kRows, kCols / 8}, reference_pack_bool(in));
+
+  sdpa_bitwise_mask_gen_out(mask, 0.0, out);
+
+  EXPECT_TENSOR_EQ(out, expected);
+}
+
+TEST_F(GenericSdpaBitwiseMaskGenTest, FloatMaskMatchesReferencePacking) {
+  TensorFactory<ScalarType::Float> tf_float;
+  TensorFactory<ScalarType::Byte> tf_uint8;
+
+  constexpr int kRows = 7;
+  constexpr int kCols = 64;
+  const double threshold = 0.0;
+
+  // Irregular sign pattern so every bit position gets exercised both ways.
+  std::vector<float> in(kRows * kCols);
+  for (size_t i = 0; i < in.size(); i++) {
+    in[i] = static_cast<float>((i * 37) % 71) * 0.25f - 8.0f;
+  }
+
+  Tensor mask = tf_float.make({kRows, kCols}, in);
+  Tensor out = tf_uint8.zeros({kRows, kCols / 8});
+  Tensor expected =
+      tf_uint8.make({kRows, kCols / 8}, reference_pack_float(in, threshold));
+
+  sdpa_bitwise_mask_gen_out(mask, threshold, out);
+
+  EXPECT_TENSOR_EQ(out, expected);
+}
+
+// A mask the size of a real attention mask, so the packing loop runs over many
+// output bytes rather than a handful.
+TEST_F(GenericSdpaBitwiseMaskGenTest, LargeMaskMatchesReferencePacking) {
+  TensorFactory<ScalarType::Bool> tf_bool;
+  TensorFactory<ScalarType::Float> tf_float;
+  TensorFactory<ScalarType::Byte> tf_uint8;
+
+  constexpr int kSeq = 256;
+  constexpr int kKv = 256;
+  const double threshold = 0.0;
+
+  std::vector<uint8_t> bool_in(kSeq * kKv);
+  std::vector<float> float_in(kSeq * kKv);
+  for (int r = 0; r < kSeq; r++) {
+    for (int c = 0; c < kKv; c++) {
+      const bool keep = c <= r;
+      bool_in[r * kKv + c] = static_cast<uint8_t>(keep);
+      float_in[r * kKv + c] = keep ? 0.0f : -1e30f;
+    }
+  }
+
+  Tensor bool_mask = tf_bool.make({kSeq, kKv}, bool_in);
+  Tensor bool_out = tf_uint8.zeros({kSeq, kKv / 8});
+  Tensor bool_expected =
+      tf_uint8.make({kSeq, kKv / 8}, reference_pack_bool(bool_in));
+
+  sdpa_bitwise_mask_gen_out(bool_mask, threshold, bool_out);
+
+  EXPECT_TENSOR_EQ(bool_out, bool_expected);
+
+  Tensor float_mask = tf_float.make({kSeq, kKv}, float_in);
+  Tensor float_out = tf_uint8.zeros({kSeq, kKv / 8});
+  Tensor float_expected =
+      tf_uint8.make({kSeq, kKv / 8}, reference_pack_float(float_in, threshold));
+
+  sdpa_bitwise_mask_gen_out(float_mask, threshold, float_out);
+
+  EXPECT_TENSOR_EQ(float_out, float_expected);
+
+  // Both dtypes describe the same mask, so they must pack to the same bytes.
+  EXPECT_TENSOR_EQ(bool_out, float_out);
+}
+
+} // namespace
+} // namespace native
+} // namespace generic
+} // namespace impl