react-native-windows 0.81.32 → 0.81.35

package/external/folly/folly/algorithm/simd/FindFixed.h

@@ -0,0 +1,301 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <algorithm>
+#include <array>
+#include <bit>
+#include <concepts>
+#include <cstdint>
+#include <cstring>
+#include <optional>
+#include <span>
+#include <type_traits>
+
+#include <folly/Portability.h>
+#include <folly/algorithm/simd/Movemask.h>
+#include <folly/algorithm/simd/detail/Traits.h>
+
+#if FOLLY_X64
+#include <immintrin.h>
+#endif
+
+#if FOLLY_AARCH64
+#include <arm_neon.h>
+#endif
+
+namespace folly {
+
+namespace detail {
+
+// Note: using std::same_as will just be slower to compile than is_same_v
+template <typename T>
+concept SimdFriendlyType =
+    (std::is_same_v<std::int8_t, T> || std::is_same_v<std::uint8_t, T> ||
+     std::is_same_v<std::int16_t, T> || std::is_same_v<std::uint16_t, T> ||
+     std::is_same_v<std::int32_t, T> || std::is_same_v<std::uint32_t, T> ||
+     std::is_same_v<std::int64_t, T> || std::is_same_v<std::uint64_t, T>);
+
+} // namespace detail
+
+template <typename T>
+concept FollyFindFixedSupportedType = detail::SimdFriendlyType<T> ||
+    (std::is_enum_v<T> && detail::SimdFriendlyType<std::underlying_type_t<T>>);
+
+/*
+ * # folly::findFixed
+ *
+ * A function to linear search in number of elements, known at compiled time.
+ *
+ * Example:
+ *   std::vector<int> v {1, 3, 1, 2};
+ *   std::span<const int, 4> vspan(v.data(), 4);
+ *   auto m0 = folly::findFixed(vspan, 3); // m0 == 1;
+ *   auto m1 = folly::findFixed(vspan, 5); // m0 == std::nullopt;
+ *
+ * Supported types:
+ *  any 8,16,32,64 bit integers
+ *  enums
+ *
+ * Max supported size of the range is 64 bytes.
+ */
+template <
+    FollyFindFixedSupportedType T,
+    std::convertible_to<T> U,
+    std::size_t N>
+constexpr std::optional<std::size_t> findFixed(std::span<const T, N> where, U x)
+  requires(sizeof(T) * N <= 64);
+
+// implementation ---------------------------------------------------------
+
+namespace find_fixed_detail {
+
+template <typename T>
+constexpr std::optional<std::size_t> findFixedConstexpr(
+    std::span<const T> where, T x) {
+  std::size_t res = 0;
+  for (T e : where) {
+    if (e == x) {
+      return res;
+    }
+    ++res;
+  }
+  return std::nullopt;
+}
+
+// clang just checks all elements one by one, without any vectorization.
+// even for not very friendly to SIMD cases we could do better but for
+// now only special powers of 2 were interesting.
+template <typename T, std::size_t N>
+std::optional<std::size_t> findFixedLetTheCompilerDoIt(
+    std::span<const T, N> where, T x) {
+  // this get's unrolled by both clang and gcc.
+  // Experimenting with more complex ways of writing this code
+  // didn't yield any results.
+  return findFixedConstexpr(std::span<const T>(where), x);
+}
+
+#if FOLLY_X64
+#if defined(__AVX2__)
+constexpr std::size_t kMaxSimdRegister = 32;
+#else
+constexpr std::size_t kMaxSimdRegister = 16;
+#endif
+#elif FOLLY_AARCH64
+constexpr std::size_t kMaxSimdRegister = 16;
+#else
+constexpr std::size_t kMaxSimdRegister = 1;
+#endif
+
+template <typename T>
+std::optional<std::size_t> find8bytes(const T* from, T x);
+template <typename T>
+std::optional<std::size_t> find16bytes(const T* from, T x);
+template <typename T>
+std::optional<std::size_t> find32bytes(const T* from, T x);
+
+template <typename T, std::size_t N>
+std::optional<std::size_t> find2Overlaping(std::span<const T, N> where, T x);
+
+template <typename T, std::size_t N>
+std::optional<std::size_t> findSplitFirstRegister(
+    std::span<const T, N> where, T x);
+
+template <typename T, std::size_t N>
+std::optional<std::size_t> findFixedDispatch(std::span<const T, N> where, T x) {
+  constexpr std::size_t kNumBytes = N * sizeof(T);
+
+  if constexpr (N == 0) {
+    return std::nullopt;
+  } else if constexpr (N <= 2 || kNumBytes < 8 || kMaxSimdRegister == 1) {
+    return findFixedLetTheCompilerDoIt(where, x);
+  } else if constexpr (kNumBytes == 8) {
+    return find8bytes(where.data(), x);
+  } else if constexpr (kNumBytes == 16) {
+    return find16bytes(where.data(), x);
+  } else if constexpr (kMaxSimdRegister >= 32 && kNumBytes == 32) {
+    return find32bytes(where.data(), x);
+  } else if constexpr (kMaxSimdRegister * 2 <= kNumBytes) {
+    return findSplitFirstRegister(where, x);
+  } else {
+    // we can maybe do one better here probably with either out of bounds
+    // loads or combined two register search but it's ok for now.
+    return find2Overlaping(where, x);
+  }
+}
+
+template <typename T, std::size_t N>
+std::optional<std::size_t> find2Overlaping(std::span<const T, N> where, T x) {
+  constexpr std::size_t kRegSize = std::bit_floor(N);
+
+  std::span<const T, kRegSize> firstOverlap(where.data(), kRegSize);
+  if (auto res = findFixed(firstOverlap, x)) {
+    return res;
+  }
+
+  std::span<const T, kRegSize> secondOverlap(
+      where.data() + (N - kRegSize), kRegSize);
+  if (auto res = findFixed(secondOverlap, x)) {
+    return *res + (N - kRegSize);
+  }
+  return std::nullopt;
+}
+
+template <typename T, std::size_t N>
+std::optional<std::size_t> findSplitFirstRegister(
+    std::span<const T, N> where, T x) {
+  constexpr std::size_t kRegSize = kMaxSimdRegister / sizeof(T);
+
+  std::span<const T, kRegSize> head(where.data(), kRegSize);
+  if (auto res = findFixed(head, x)) {
+    return res;
+  }
+
+  std::span<const T, N - kRegSize> tail(where.data() + kRegSize, N - kRegSize);
+  if (auto res = findFixed(tail, x)) {
+    return *res + kRegSize;
+  }
+  return std::nullopt;
+}
+
+template <typename Scalar, typename Reg>
+std::optional<std::size_t> firstTrue(Reg reg) {
+  auto [bits, bitsPerElement] = folly::simd::movemask<Scalar>(reg);
+  if (bits) {
+    return std::countr_zero(bits) / bitsPerElement();
+  }
+  return std::nullopt;
+}
+
+#if FOLLY_X64
+
+template <typename T>
+std::optional<std::size_t> find16ByteReg(__m128i reg, T x) {
+  if constexpr (sizeof(T) == 1) {
+    return firstTrue<T>(_mm_cmpeq_epi8(reg, _mm_set1_epi8(x)));
+  } else if constexpr (sizeof(T) == 2) {
+    return firstTrue<T>(_mm_cmpeq_epi16(reg, _mm_set1_epi16(x)));
+  } else if constexpr (sizeof(T) == 4) {
+    return firstTrue<T>(_mm_cmpeq_epi32(reg, _mm_set1_epi32(x)));
+  }
+}
+
+template <typename T>
+std::optional<std::size_t> find8bytes(const T* from, T x) {
+  std::uint64_t reg;
+  std::memcpy(&reg, from, 8);
+  return find16ByteReg(_mm_set1_epi64x(reg), x);
+}
+
+template <typename T>
+std::optional<std::size_t> find16bytes(const T* from, T x) {
+  __m128i reg = _mm_loadu_si128(reinterpret_cast<const __m128i*>(from));
+  return find16ByteReg(reg, x);
+}
+
+#if defined(__AVX2__)
+template <typename T>
+std::optional<std::size_t> find32ByteReg(__m256i reg, T x) {
+  if constexpr (sizeof(T) == 1) {
+    return firstTrue<T>(_mm256_cmpeq_epi8(reg, _mm256_set1_epi8(x)));
+  } else if constexpr (sizeof(T) == 2) {
+    return firstTrue<T>(_mm256_cmpeq_epi16(reg, _mm256_set1_epi16(x)));
+  } else if constexpr (sizeof(T) == 4) {
+    return firstTrue<T>(_mm256_cmpeq_epi32(reg, _mm256_set1_epi32(x)));
+  } else if constexpr (sizeof(T) == 8) {
+    return firstTrue<T>(_mm256_cmpeq_epi64(reg, _mm256_set1_epi64x(x)));
+  }
+}
+
+template <typename T>
+std::optional<std::size_t> find32bytes(const T* from, T x) {
+  __m256i reg = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(from));
+  return find32ByteReg(reg, x);
+}
+
+#endif
+#endif
+
+#if FOLLY_AARCH64
+
+template <typename T>
+std::optional<std::size_t> find8bytes(const T* from, T x) {
+  if constexpr (std::same_as<T, std::uint8_t>) {
+    return firstTrue<T>(vceq_u8(vld1_u8(from), vdup_n_u8(x)));
+  } else if constexpr (std::same_as<T, std::uint16_t>) {
+    return firstTrue<T>(vceq_u16(vld1_u16(from), vdup_n_u16(x)));
+  } else {
+    return firstTrue<T>(vceq_u32(vld1_u32(from), vdup_n_u32(x)));
+  }
+}
+
+template <typename T>
+std::optional<std::size_t> find16bytes(const T* from, T x) {
+  if constexpr (std::same_as<T, std::uint8_t>) {
+    return firstTrue<T>(vceqq_u8(vld1q_u8(from), vdupq_n_u8(x)));
+  } else if constexpr (std::same_as<T, std::uint16_t>) {
+    return firstTrue<T>(vceqq_u16(vld1q_u16(from), vdupq_n_u16(x)));
+  } else if constexpr (std::same_as<T, std::uint32_t>) {
+    return firstTrue<T>(vceqq_u32(vld1q_u32(from), vdupq_n_u32(x)));
+  } else {
+    return firstTrue<T>(vceqq_u64(vld1q_u64(from), vdupq_n_u64(x)));
+  }
+}
+
+#endif
+
+} // namespace find_fixed_detail
+
+template <
+    FollyFindFixedSupportedType T,
+    std::convertible_to<T> U,
+    std::size_t N>
+constexpr std::optional<std::size_t> findFixed(std::span<const T, N> where, U x)
+  requires(sizeof(T) * N <= 64)
+{
+  if constexpr (!std::is_same_v<T, U>) {
+    return findFixed(where, static_cast<T>(x));
+  } else if (std::is_constant_evaluated()) {
+    return find_fixed_detail::findFixedConstexpr(std::span<const T>(where), x);
+  } else {
+    return find_fixed_detail::findFixedDispatch(
+        simd::detail::asSimdFriendlyUint(where),
+        simd::detail::asSimdFriendlyUint(x));
+  }
+}
+
+} // namespace folly

package/external/folly/folly/algorithm/simd/Ignore.h

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <folly/lang/Bits.h>
+
+#include <type_traits>
+
+namespace folly::simd {
+
+/**
+ * ignore(_none/_extrema)
+ *
+ * tag types to be used in some simd operations.
+ *
+ * They are used to indicate to the function that
+ * some of the elements in are garbage.
+ *
+ * ignore_none indicates that the whole register is used.
+ * ignore_extrema.first, .last show how many elements are out of the data.
+ *
+ * Example:
+ * register: [true, true, false, false, false, false, false, true]
+ * indexes   [0,    1,    2,     3,     4,     5,     6,     7   ]
+ *
+ * ignore_extema{.first = 1, .last = 2}
+ * means that elements with indexes 0, 6, and 7 will be ignored
+ * (w/e that means for an operation)
+ */
+
+struct ignore_extrema {
+  int first = 0;
+  int last = 0;
+};
+
+struct ignore_none {};
+
+} // namespace folly::simd

package/external/folly/folly/algorithm/simd/Movemask.h

@@ -0,0 +1,207 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <folly/Portability.h>
+#include <folly/algorithm/simd/Ignore.h>
+#include <folly/lang/Bits.h>
+
+#include <cstdint>
+#include <type_traits>
+#include <utility>
+
+#if FOLLY_X64
+#include <immintrin.h>
+#endif
+
+#if FOLLY_AARCH64
+#include <arm_neon.h>
+#endif
+
+FOLLY_PUSH_WARNING
+FOLLY_GCC_DISABLE_WARNING("-Wignored-attributes")
+
+namespace folly::simd {
+
+/**
+ * movemask
+ * movemask_fn
+ *
+ * This is a low level utility used for simd search algorithms.
+ * At the moment used in folly::findFixed and folly::split.
+ *
+ * This is a logical extension of _mm_movemask_epi8 for different types
+ * for both x86 and arm.
+ *
+ * Main interface looks like this:
+ * folly::simd::movemask<scalar_type>(simdRegister)
+ *   -> std::pair<Bits, BitsPerElement>;
+ *
+ * scalar type - type of element in the simdRegister
+ *
+ *  Bits - unsigned integral, containing the bitmask (first is lowest bit).
+ *  BitsPerElement - std::integral_constant with number of bits per element.
+ *
+ * There are also overloads taking `ignore`
+ *
+ *   folly::simd::movemask<T>(nativeRegister, ignore_extrema)
+ *   folly::simd::movemask<T>(nativeRegister, ignore_none)
+ *
+ * These are there if not all the native register contains valid results,
+ * and some need to be ignored (zeroed out)
+ *
+ * Example: find in 8 shorts on arm.
+ *
+ *  std::optional<std::uint32_t> findUint16(
+ *       std::span<const std::uint16_t> haystack,
+ *       std::uint16_t needle) {
+ *    uint16x8_t loaded = vld1q_u16(arr.data());
+ *    uint16x8_t simdNeedle = vdupq_n_u16(needle);
+ *    uint16x8_t test = vceqq_u16(loaded, simdNeedle);
+ *
+ *    auto [bits, bitsPerElement] = folly::simd::movemask<std::uint16_t>(test);
+ *    if (!bits) {
+ *      return std::nullopt;
+ *    }
+ *    return std::countl_zero(bits) / bitsPerElement();
+ *  }
+ *
+ * Arm implementation is based on:
+ * https://github.com/jfalcou/eve/blob/a2e2cf539e36e9a3326800194ad5206a8ef3f5b7/include/eve/detail/function/simd/arm/neon/movemask.hpp#L48
+ *
+ **/
+
+template <typename Scalar>
+struct movemask_fn {
+  template <typename Reg>
+  auto operator()(Reg reg) const;
+
+  template <typename Reg, typename Ignore>
+  auto operator()(Reg reg, Ignore ignore) const;
+};
+
+template <typename Scalar>
+inline constexpr movemask_fn<Scalar> movemask;
+
+#if FOLLY_X64
+
+template <typename Scalar>
+template <typename Reg>
+FOLLY_ERASE auto movemask_fn<Scalar>::operator()(Reg reg) const {
+  std::integral_constant<std::uint32_t, sizeof(Scalar) == 2 ? 2 : 1>
+      bitsPerElement;
+
+  using uint_t = std::
+      conditional_t<std::is_same_v<Reg, __m128i>, std::uint16_t, std::uint32_t>;
+
+  auto mmask = static_cast<uint_t>([&] {
+    if constexpr (std::is_same_v<Reg, __m128i>) {
+      if constexpr (sizeof(Scalar) <= 2) {
+        return _mm_movemask_epi8(reg);
+      } else if constexpr (sizeof(Scalar) == 4) {
+        return _mm_movemask_ps(_mm_castsi128_ps(reg));
+      } else if constexpr (sizeof(Scalar) == 8) {
+        return _mm_movemask_pd(_mm_castsi128_pd(reg));
+      }
+    }
+#if defined(__AVX2__)
+    else if constexpr (std::is_same_v<Reg, __m256i>) {
+      if constexpr (sizeof(Scalar) <= 2) {
+        return _mm256_movemask_epi8(reg);
+      } else if constexpr (sizeof(Scalar) == 4) {
+        return _mm256_movemask_ps(_mm256_castsi256_ps(reg));
+      } else if constexpr (sizeof(Scalar) == 8) {
+        return _mm256_movemask_pd(_mm256_castsi256_pd(reg));
+      }
+    }
+#endif
+  }());
+  return std::pair{mmask, bitsPerElement};
+}
+
+#endif
+
+#if FOLLY_AARCH64
+
+namespace detail {
+
+FOLLY_ERASE auto movemaskChars16Aarch64(uint8x16_t reg) {
+  uint16x8_t u16s = vreinterpretq_u16_u8(reg);
+  u16s = vshrq_n_u16(u16s, 4);
+  uint8x8_t packed = vmovn_u16(u16s);
+  std::uint64_t bits = vget_lane_u64(vreinterpret_u64_u8(packed), 0);
+  return std::pair{bits, std::integral_constant<std::uint32_t, 4>{}};
+}
+
+template <typename Reg>
+FOLLY_ERASE uint64x1_t asUint64x1Aarch64(Reg reg) {
+  if constexpr (std::is_same_v<Reg, uint32x2_t>) {
+    return vreinterpret_u64_u32(reg);
+  } else if constexpr (std::is_same_v<Reg, uint16x4_t>) {
+    return vreinterpret_u64_u16(reg);
+  } else {
+    return vreinterpret_u64_u8(reg);
+  }
+}
+
+} // namespace detail
+
+template <typename Scalar>
+template <typename Reg>
+FOLLY_ERASE auto movemask_fn<Scalar>::operator()(Reg reg) const {
+  if constexpr (std::is_same_v<Reg, uint64x2_t>) {
+    return movemask<std::uint32_t>(vmovn_u64(reg));
+  } else if constexpr (std::is_same_v<Reg, uint32x4_t>) {
+    return movemask<std::uint16_t>(vmovn_u32(reg));
+  } else if constexpr (std::is_same_v<Reg, uint16x8_t>) {
+    return movemask<std::uint8_t>(vmovn_u16(reg));
+  } else if constexpr (std::is_same_v<Reg, uint8x16_t>) {
+    return detail::movemaskChars16Aarch64(reg);
+  } else {
+    std::uint64_t mmask = vget_lane_u64(detail::asUint64x1Aarch64(reg), 0);
+    return std::pair{
+        mmask, std::integral_constant<std::uint32_t, sizeof(Scalar) * 8>{}};
+  }
+}
+
+#endif
+
+#if FOLLY_X64 || FOLLY_AARCH64
+
+template <typename Scalar>
+template <typename Reg, typename Ignore>
+FOLLY_ERASE auto movemask_fn<Scalar>::operator()(Reg reg, Ignore ignore) const {
+  auto [bits, bitsPerElement] = operator()(reg);
+
+  if constexpr (std::is_same_v<Ignore, ignore_none>) {
+    return std::pair{bits, bitsPerElement};
+  } else {
+    static constexpr int kCardinal = sizeof(Reg) / sizeof(Scalar);
+
+    int bitsToKeep = (kCardinal - ignore.last) * bitsPerElement;
+
+    bits = clear_n_least_significant_bits(bits, ignore.first * bitsPerElement);
+    bits = clear_n_most_significant_bits(bits, sizeof(bits) * 8 - bitsToKeep);
+    return std::pair{bits, bitsPerElement};
+  }
+}
+
+#endif
+
+} // namespace folly::simd
+
+FOLLY_POP_WARNING

package/external/folly/folly/algorithm/simd/detail/BUCK

@@ -0,0 +1,70 @@
+######################################################################
+# Libraries
+
+load("@fbcode_macros//build_defs:cpp_library.bzl", "cpp_library")
+
+oncall("fbcode_entropy_wardens_folly")
+
+cpp_library(
+    name = "simd_any_of",
+    headers = ["SimdAnyOf.h"],
+    exported_deps = [
+        ":simd_for_each",
+        ":unroll_utils",
+        "//folly:c_portability",
+    ],
+)
+
+cpp_library(
+    name = "simd_platform",
+    headers = ["SimdPlatform.h"],
+    exported_deps = [
+        "//folly:portability",
+        "//folly/algorithm/simd:ignore",
+        "//folly/algorithm/simd:movemask",
+        "//folly/lang:bits",
+    ],
+)
+
+cpp_library(
+    name = "simd_contains_impl",
+    headers = ["ContainsImpl.h"],
+    exported_deps = [
+        ":simd_any_of",
+        ":simd_platform",
+        "//folly:c_portability",
+        "//folly/container:span",
+    ],
+)
+
+cpp_library(
+    name = "simd_for_each",
+    headers = ["SimdForEach.h"],
+    exported_deps = [
+        ":unroll_utils",
+        "//folly:c_portability",
+        "//folly:traits",
+        "//folly/algorithm/simd:ignore",
+        "//folly/lang:align",
+    ],
+)
+
+cpp_library(
+    name = "traits",
+    headers = ["Traits.h"],
+    exported_deps = [
+        "//folly:c_portability",
+        "//folly:memory",
+        "//folly:traits",
+        "//folly/container:span",
+    ],
+)
+
+cpp_library(
+    name = "unroll_utils",
+    headers = ["UnrollUtils.h"],
+    exported_deps = [
+        "//folly:portability",
+        "//folly:traits",
+    ],
+)