react-native-windows 0.83.2 → 0.83.3

package/external/folly/folly/algorithm/simd/detail/SimdPlatform.h

@@ -0,0 +1,445 @@
+/*
+ * 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/algorithm/simd/Movemask.h>
+#include <folly/algorithm/simd/detail/SimdPlatform.h>
+#include <folly/lang/Bits.h>
+
+#include <array>
+
+#if FOLLY_X64 && FOLLY_SSE_PREREQ(4, 2)
+#include <immintrin.h>
+#endif
+
+#if FOLLY_AARCH64
+#include <arm_neon.h>
+#endif
+
+namespace folly {
+namespace simd::detail {
+
+/**
+ * SimdPlatform<T>
+ *
+ * Common interface for some SIMD operations between: sse4.2, avx2,
+ * arm-neon.
+ *
+ * Supported types for T at the moment are uint8_16/uint16_t/uint32_t/uint64_t
+ *
+ * If it's not one of the supported platforms:
+ *  std::same_as<SimdPlatform<T>, void>
+ *  There is also a macro: FOLLY_DETAIL_HAS_SIMD_PLATFORM set to 1 or 0
+ *
+ **/
+
+#if FOLLY_X64 && FOLLY_SSE_PREREQ(4, 2) || FOLLY_AARCH64
+
+template <typename Platform>
+struct SimdPlatformCommon {
+  /**
+   * sclar_t - type of scalar we operate on (uint8_t, uint16_t etc)
+   * reg_t - type of a simd register (__m128i)
+   * logical_t - type of a simd logical register (matches reg_t so far)
+   **/
+  using scalar_t = typename Platform::scalar_t;
+  using reg_t = typename Platform::reg_t;
+  using logical_t = typename Platform::logical_t;
+
+  static constexpr int kCardinal = sizeof(reg_t) / sizeof(scalar_t);
+
+  /**
+   * loads:
+   * precondition: at least one element should be not ignored.
+   *
+   * loada - load from an aligned (to sizeof(reg_t)) address
+   * loadu - load from an unaligned address
+   * unsafeLoadu - load from an unaligned address that disables sanitizers.
+   *               This is for reading a register within a page
+   *               but maybe outside of the array's boundary.
+   *
+   * Ignored values can be garbage.
+   **/
+  template <typename Ignore>
+  static reg_t loada(const scalar_t* ptr, Ignore);
+  static reg_t loadu(const scalar_t* ptr, ignore_none);
+  static reg_t unsafeLoadu(const scalar_t* ptr, ignore_none);
+
+  /**
+   * Comparing reg_t against the scalar.
+   *
+   * NOTE: less_equal only implemented for uint8_t
+   *       for now.
+   **/
+  static logical_t equal(reg_t reg, scalar_t x);
+  static logical_t less_equal(reg_t reg, scalar_t x);
+
+  /**
+   * logical reduction
+   **/
+  template <typename Ignore>
+  static bool any(logical_t logical, Ignore ignore);
+
+  /**
+   * logical operations
+   **/
+  static logical_t logical_or(logical_t x, logical_t y);
+
+  /**
+   * Converting register to an array for debugging
+   **/
+  static auto toArray(reg_t x);
+};
+
+template <typename Platform>
+template <typename Ignore>
+FOLLY_ERASE auto SimdPlatformCommon<Platform>::loada(
+    const scalar_t* ptr, Ignore) -> reg_t {
+  if constexpr (std::is_same_v<ignore_none, Ignore>) {
+    // There is not point to aligned load instructions
+    // on modern cpus. Arm doesn't even have any.
+    return loadu(ptr, ignore_none{});
+  } else {
+    // We have a precondition: at least one element is loaded.
+    // From this we can prove that we can unsafely load from
+    // and aligned address.
+    //
+    // Here is an explanation from Stephen Canon:
+    // https://stackoverflow.com/questions/25566302/vectorized-strlen-getting-away-with-reading-unallocated-memory
+    return unsafeLoadu(ptr, ignore_none{});
+  }
+}
+
+template <typename Platform>
+FOLLY_ERASE auto SimdPlatformCommon<Platform>::loadu(
+    const scalar_t* ptr, ignore_none) -> reg_t {
+  return Platform::loadu(ptr);
+}
+
+template <typename Platform>
+FOLLY_ERASE auto SimdPlatformCommon<Platform>::unsafeLoadu(
+    const scalar_t* ptr, ignore_none) -> reg_t {
+  return Platform::unsafeLoadu(ptr);
+}
+
+template <typename Platform>
+FOLLY_ERASE auto SimdPlatformCommon<Platform>::equal(reg_t reg, scalar_t x)
+    -> logical_t {
+  return Platform::equal(reg, Platform::broadcast(x));
+}
+
+template <typename Platform>
+FOLLY_ERASE auto SimdPlatformCommon<Platform>::less_equal(reg_t reg, scalar_t x)
+    -> logical_t {
+  static_assert(std::is_same_v<scalar_t, std::uint8_t>, "not implemented");
+  return Platform::less_equal(reg, Platform::broadcast(x));
+}
+
+template <typename Platform>
+template <typename Ignore>
+FOLLY_ERASE bool SimdPlatformCommon<Platform>::any(
+    logical_t logical, Ignore ignore) {
+  if constexpr (std::is_same_v<Ignore, ignore_none>) {
+    return Platform::any(logical);
+  } else {
+    return movemask<scalar_t>(logical, ignore).first;
+  }
+}
+
+template <typename Platform>
+FOLLY_ERASE auto SimdPlatformCommon<Platform>::logical_or(
+    logical_t x, logical_t y) -> logical_t {
+  return Platform::logical_or(x, y);
+}
+
+template <typename Platform>
+FOLLY_ERASE auto SimdPlatformCommon<Platform>::toArray(reg_t x) {
+  std::array<scalar_t, kCardinal> res;
+  std::memcpy(&res, &x, sizeof(x));
+  return res;
+}
+
+#endif
+
+#if FOLLY_X64 && FOLLY_SSE_PREREQ(4, 2)
+
+template <typename T>
+struct SimdSse42PlatformSpecific {
+  using scalar_t = T;
+  using reg_t = __m128i;
+  using logical_t = reg_t;
+
+  FOLLY_ERASE
+  static reg_t loadu(const scalar_t* p) {
+    return _mm_loadu_si128(reinterpret_cast<const reg_t*>(p));
+  }
+
+  FOLLY_DISABLE_SANITIZERS
+  FOLLY_ERASE
+  static reg_t unsafeLoadu(const scalar_t* p) {
+    return _mm_loadu_si128(reinterpret_cast<const reg_t*>(p));
+  }
+
+  FOLLY_ERASE
+  static reg_t broadcast(scalar_t x) {
+    if constexpr (std::is_same_v<scalar_t, std::uint8_t>) {
+      return _mm_set1_epi8(x);
+    } else if constexpr (std::is_same_v<scalar_t, std::uint16_t>) {
+      return _mm_set1_epi16(x);
+    } else if constexpr (std::is_same_v<scalar_t, std::uint32_t>) {
+      return _mm_set1_epi32(x);
+    } else if constexpr (std::is_same_v<scalar_t, std::uint64_t>) {
+      return _mm_set1_epi64x(x);
+    }
+  }
+
+  FOLLY_ERASE
+  static logical_t equal(reg_t x, reg_t y) {
+    if constexpr (std::is_same_v<scalar_t, std::uint8_t>) {
+      return _mm_cmpeq_epi8(x, y);
+    } else if constexpr (std::is_same_v<scalar_t, std::uint16_t>) {
+      return _mm_cmpeq_epi16(x, y);
+    } else if constexpr (std::is_same_v<scalar_t, std::uint32_t>) {
+      return _mm_cmpeq_epi32(x, y);
+    } else if constexpr (std::is_same_v<scalar_t, std::uint64_t>) {
+      return _mm_cmpeq_epi64(x, y);
+    }
+  }
+
+  FOLLY_ERASE
+  static logical_t less_equal(reg_t x, reg_t y) {
+    static_assert(
+        std::is_same_v<std::uint8_t, scalar_t>, "other types not implemented");
+    // No unsigned comparisons on x86
+    // less equal <=> equal (min)
+    reg_t min = _mm_min_epu8(x, y);
+    return equal(x, min);
+  }
+
+  FOLLY_ERASE
+  static logical_t logical_or(logical_t x, logical_t y) {
+    return _mm_or_si128(x, y);
+  }
+
+  FOLLY_ERASE
+  static bool any(logical_t log) { return movemask<std::uint8_t>(log).first; }
+};
+
+#define FOLLY_DETAIL_HAS_SIMD_PLATFORM 1
+
+template <typename T>
+using SimdSse42Platform = SimdPlatformCommon<SimdSse42PlatformSpecific<T>>;
+
+#if defined(__AVX2__)
+
+template <typename T>
+struct SimdAvx2PlatformSpecific {
+  using scalar_t = T;
+  using reg_t = __m256i;
+  using logical_t = reg_t;
+
+  FOLLY_ERASE
+  static reg_t loadu(const scalar_t* p) {
+    return _mm256_loadu_si256(reinterpret_cast<const reg_t*>(p));
+  }
+
+  FOLLY_DISABLE_SANITIZERS
+  FOLLY_ERASE
+  static reg_t unsafeLoadu(const scalar_t* p) {
+    return _mm256_loadu_si256(reinterpret_cast<const reg_t*>(p));
+  }
+
+  FOLLY_ERASE
+  static reg_t broadcast(scalar_t x) {
+    if constexpr (std::is_same_v<scalar_t, std::uint8_t>) {
+      return _mm256_set1_epi8(x);
+    } else if constexpr (std::is_same_v<scalar_t, std::uint16_t>) {
+      return _mm256_set1_epi16(x);
+    } else if constexpr (std::is_same_v<scalar_t, std::uint32_t>) {
+      return _mm256_set1_epi32(x);
+    } else if constexpr (std::is_same_v<scalar_t, std::uint64_t>) {
+      return _mm256_set1_epi64x(x);
+    }
+  }
+
+  FOLLY_ERASE
+  static logical_t equal(reg_t x, reg_t y) {
+    if constexpr (std::is_same_v<scalar_t, std::uint8_t>) {
+      return _mm256_cmpeq_epi8(x, y);
+    } else if constexpr (std::is_same_v<scalar_t, std::uint16_t>) {
+      return _mm256_cmpeq_epi16(x, y);
+    } else if constexpr (std::is_same_v<scalar_t, std::uint32_t>) {
+      return _mm256_cmpeq_epi32(x, y);
+    } else if constexpr (std::is_same_v<scalar_t, std::uint64_t>) {
+      return _mm256_cmpeq_epi64(x, y);
+    }
+  }
+
+  FOLLY_ERASE
+  static logical_t less_equal(reg_t x, reg_t y) {
+    static_assert(
+        std::is_same_v<std::uint8_t, scalar_t>, "other types not implemented");
+    // See SSE comment
+    reg_t min = _mm256_min_epu8(x, y);
+    return _mm256_cmpeq_epi8(x, min);
+  }
+
+  FOLLY_ERASE
+  static logical_t logical_or(logical_t x, logical_t y) {
+    return _mm256_or_si256(x, y);
+  }
+
+  FOLLY_ERASE
+  static bool any(logical_t log) {
+    return simd::movemask<std::uint8_t>(log).first;
+  }
+};
+
+template <typename T>
+using SimdAvx2Platform = SimdPlatformCommon<SimdAvx2PlatformSpecific<T>>;
+
+template <typename T>
+using SimdPlatform = SimdAvx2Platform<T>;
+
+#else
+
+template <typename T>
+using SimdPlatform = SimdPlatformCommon<SimdSse42PlatformSpecific<T>>;
+
+#endif
+
+#elif FOLLY_AARCH64
+
+template <typename T>
+struct SimdAarch64PlatformSpecific {
+  using scalar_t = T;
+
+  FOLLY_ERASE
+  static auto loadu(const scalar_t* p) {
+    if constexpr (std::is_same_v<scalar_t, std::uint8_t>) {
+      return vld1q_u8(p);
+    } else if constexpr (std::is_same_v<scalar_t, std::uint16_t>) {
+      return vld1q_u16(p);
+    } else if constexpr (std::is_same_v<scalar_t, std::uint32_t>) {
+      return vld1q_u32(p);
+    } else if constexpr (std::is_same_v<scalar_t, std::uint64_t>) {
+      return vld1q_u64(p);
+    }
+  }
+
+  using reg_t = decltype(loadu(nullptr));
+  using logical_t = reg_t;
+
+  FOLLY_DISABLE_SANITIZERS
+  FOLLY_ERASE
+  static reg_t unsafeLoadu(const scalar_t* p) {
+    if constexpr (std::is_same_v<scalar_t, std::uint8_t>) {
+      return vld1q_u8(p);
+    } else if constexpr (std::is_same_v<scalar_t, std::uint16_t>) {
+      return vld1q_u16(p);
+    } else if constexpr (std::is_same_v<scalar_t, std::uint32_t>) {
+      return vld1q_u32(p);
+    } else if constexpr (std::is_same_v<scalar_t, std::uint64_t>) {
+      return vld1q_u64(p);
+    }
+  }
+
+  FOLLY_ERASE
+  static reg_t broadcast(scalar_t x) {
+    if constexpr (std::is_same_v<scalar_t, std::uint8_t>) {
+      return vdupq_n_u8(x);
+    } else if constexpr (std::is_same_v<scalar_t, std::uint16_t>) {
+      return vdupq_n_u16(x);
+    } else if constexpr (std::is_same_v<scalar_t, std::uint32_t>) {
+      return vdupq_n_u32(x);
+    } else if constexpr (std::is_same_v<scalar_t, std::uint64_t>) {
+      return vdupq_n_u64(x);
+    }
+  }
+
+  FOLLY_ERASE
+  static logical_t equal(reg_t x, reg_t y) {
+    if constexpr (std::is_same_v<scalar_t, std::uint8_t>) {
+      return vceqq_u8(x, y);
+    } else if constexpr (std::is_same_v<scalar_t, std::uint16_t>) {
+      return vceqq_u16(x, y);
+    } else if constexpr (std::is_same_v<scalar_t, std::uint32_t>) {
+      return vceqq_u32(x, y);
+    } else if constexpr (std::is_same_v<scalar_t, std::uint64_t>) {
+      return vceqq_u64(x, y);
+    }
+  }
+
+  FOLLY_ERASE
+  static logical_t less_equal(reg_t x, reg_t y) {
+    if constexpr (std::is_same_v<scalar_t, std::uint8_t>) {
+      return vcleq_u8(x, y);
+    } else if constexpr (std::is_same_v<scalar_t, std::uint16_t>) {
+      return vcleq_u16(x, y);
+    } else if constexpr (std::is_same_v<scalar_t, std::uint32_t>) {
+      return vcleq_u32(x, y);
+    } else if constexpr (std::is_same_v<scalar_t, std::uint64_t>) {
+      return vcleq_u64(x, y);
+    }
+  }
+
+  FOLLY_ALWAYS_INLINE
+  static logical_t logical_or(logical_t x, logical_t y) {
+    if constexpr (std::is_same_v<scalar_t, std::uint8_t>) {
+      return vorrq_u8(x, y);
+    } else if constexpr (std::is_same_v<scalar_t, std::uint16_t>) {
+      return vorrq_u16(x, y);
+    } else if constexpr (std::is_same_v<scalar_t, std::uint32_t>) {
+      return vorrq_u32(x, y);
+    } else if constexpr (std::is_same_v<scalar_t, std::uint64_t>) {
+      return vorrq_u64(x, y);
+    }
+  }
+
+  FOLLY_ALWAYS_INLINE
+  static bool any(logical_t log) {
+    // https://github.com/dotnet/runtime/pull/75864
+    auto u32 = bit_cast<uint32x4_t>(log);
+    u32 = vpmaxq_u32(u32, u32);
+    auto u64 = bit_cast<uint64x2_t>(u32);
+    return vgetq_lane_u64(u64, 0);
+  }
+};
+
+#define FOLLY_DETAIL_HAS_SIMD_PLATFORM 1
+
+template <typename T>
+using SimdAarch64Platform = SimdPlatformCommon<SimdAarch64PlatformSpecific<T>>;
+
+template <typename T>
+using SimdPlatform = SimdAarch64Platform<T>;
+
+#define FOLLY_DETAIL_HAS_SIMD_PLATFORM 1
+
+#else
+
+#define FOLLY_DETAIL_HAS_SIMD_PLATFORM 0
+
+template <typename T>
+using SimdPlatform = void;
+
+#endif
+
+} // namespace simd::detail
+} // namespace folly

package/external/folly/folly/algorithm/simd/detail/Traits.h

@@ -0,0 +1,125 @@
+/*
+ * 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/CPortability.h>
+#include <folly/Memory.h>
+#include <folly/Traits.h>
+#include <folly/container/span.h>
+
+#include <concepts>
+#include <type_traits>
+
+namespace folly::simd::detail {
+
+template <typename T>
+auto findSimdFriendlyEquivalent() {
+  if constexpr (std::is_enum_v<T>) {
+    return findSimdFriendlyEquivalent<std::underlying_type_t<T>>();
+  } else if constexpr (std::is_pointer_v<T>) {
+    // We use signed numbers for pointers because x86 support for signed
+    // numbers is better and we can get away with it, in terms of correctness.
+    return int_bits_t<sizeof(T) * 8>{};
+  } else if constexpr (std::is_floating_point_v<T>) {
+    if constexpr (sizeof(T) == 4) {
+      return float{};
+    } else {
+      return double{};
+    }
+  } else if constexpr (std::is_signed_v<T>) {
+    return int_bits_t<sizeof(T) * 8>{};
+  } else if constexpr (std::is_unsigned_v<T>) {
+    return uint_bits_t<sizeof(T) * 8>{};
+  }
+}
+
+template <typename T>
+constexpr bool has_simd_friendly_equivalent_scalar =
+    !std::is_same_v<void, decltype(findSimdFriendlyEquivalent<T>())>;
+
+template <typename T>
+using simd_friendly_equivalent_scalar_t = std::enable_if_t<
+    has_simd_friendly_equivalent_scalar<T>,
+    like_t<T, decltype(findSimdFriendlyEquivalent<std::remove_const_t<T>>())>>;
+
+template <typename T>
+constexpr bool has_integral_simd_friendly_equivalent_scalar_v =
+    std::is_integral_v< // void will return false
+        decltype(findSimdFriendlyEquivalent<std::remove_const_t<T>>())>;
+
+template <typename T>
+using unsigned_simd_friendly_equivalent_scalar_t = std::enable_if_t<
+    has_integral_simd_friendly_equivalent_scalar_v<T>,
+    like_t<T, uint_bits_t<sizeof(T) * 8>>>;
+
+template <typename R>
+using span_for = decltype(folly::span(std::declval<const R&>()));
+
+struct AsSimdFriendlyFn {
+  template <typename T, std::size_t extent>
+  FOLLY_ERASE auto operator()(folly::span<T, extent> s) const
+      -> folly::span<simd_friendly_equivalent_scalar_t<T>, extent> {
+    return reinterpret_span_cast<simd_friendly_equivalent_scalar_t<T>>(s);
+  }
+
+  template <typename R>
+  FOLLY_ERASE auto operator()(R&& r) const
+      -> decltype(operator()(span_for<R>(r))) {
+    return operator()(folly::span(r));
+  }
+
+  template <typename T>
+  FOLLY_ERASE constexpr auto operator()(T x) const
+      -> simd_friendly_equivalent_scalar_t<T> {
+    using res_t = simd_friendly_equivalent_scalar_t<T>;
+    if constexpr (!std::is_pointer_v<T>) {
+      return static_cast<res_t>(x);
+    } else {
+      return reinterpret_cast<res_t>(x);
+    }
+  }
+};
+inline constexpr AsSimdFriendlyFn asSimdFriendly;
+
+struct AsSimdFriendlyUintFn {
+  template <typename T, std::size_t extent>
+  FOLLY_ERASE auto operator()(folly::span<T, extent> s) const
+      -> folly::span<unsigned_simd_friendly_equivalent_scalar_t<T>, extent> {
+    return reinterpret_span_cast<unsigned_simd_friendly_equivalent_scalar_t<T>>(
+        s);
+  }
+
+  template <typename R>
+  FOLLY_ERASE auto operator()(R&& r) const
+      -> decltype(operator()(span_for<R>(r))) {
+    return operator()(folly::span(r));
+  }
+
+  template <typename T>
+  FOLLY_ERASE constexpr auto operator()(T x) const
+      -> unsigned_simd_friendly_equivalent_scalar_t<T> {
+    using res_t = unsigned_simd_friendly_equivalent_scalar_t<T>;
+    if constexpr (!std::is_pointer_v<T>) {
+      return static_cast<res_t>(x);
+    } else {
+      return reinterpret_cast<res_t>(x);
+    }
+  }
+};
+inline constexpr AsSimdFriendlyUintFn asSimdFriendlyUint;
+
+} // namespace folly::simd::detail

package/external/folly/folly/algorithm/simd/detail/UnrollUtils.h

@@ -0,0 +1,126 @@
+/*
+ * 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/Traits.h>
+
+#include <array>
+#include <type_traits>
+
+namespace folly::simd::detail {
+
+/**
+ * UnrollUtils
+ *
+ * Unfortunately compilers often don't unroll the loops with small
+ * fixed number of iterations and/or not unroll them properly.
+ *
+ * This is a collection of helpers that use templates to do some
+ * common unrolled loops.
+ */
+struct UnrollUtils {
+ public:
+  /**
+   * arrayMap(x, op)
+   *
+   * Typical "map" from functional languages: apply op for each element,
+   * return an array of results.
+   */
+  template <typename T, std::size_t N, typename Op>
+  FOLLY_NODISCARD FOLLY_ALWAYS_INLINE static constexpr auto arrayMap(
+      const std::array<T, N>& x, Op op) {
+    return arrayMapImpl(x, op, std::make_index_sequence<N>());
+  }
+
+  /**
+   * arrayReduce(x, op)
+   *
+   * std::reduce(x.begin(), x.end(), op) but unrolled and orders operations
+   * to minimize dependencies.
+   *
+   * (a + b) + (c + d)
+   */
+  template <typename T, std::size_t N, typename Op>
+  FOLLY_NODISCARD FOLLY_ALWAYS_INLINE static constexpr T arrayReduce(
+      const std::array<T, N>& x, Op op) {
+    return arrayReduceImpl<0, N>(x, op);
+  }
+
+  /**
+   * unrollUntil<N>(op)
+   *
+   *  Do operation N times or until it returns true to break.
+   *  Op accepts integral_constant<i> so it can keep track of a step begin
+   * executed.
+   *
+   *  Returns wether true if it was interrupted (you can know if the op breaked)
+   */
+  template <std::size_t N, typename Op>
+  FOLLY_ALWAYS_INLINE static constexpr bool unrollUntil(Op op) {
+    return unrollUntilImpl(op, std::make_index_sequence<N>{});
+  }
+
+ private:
+  template <typename T, std::size_t N, typename Op, std::size_t... i>
+  FOLLY_ALWAYS_INLINE static constexpr auto arrayMapImpl(
+      const std::array<T, N>& x, Op op, std::index_sequence<i...>) {
+    using U = decltype(op(std::declval<const T&>()));
+
+    FOLLY_PUSH_WARNING
+    // This is a very common gcc issue,
+    // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97222 apparently discarding
+    // it here is fine and done through out.
+    FOLLY_GCC_DISABLE_WARNING("-Wignored-attributes")
+    std::array<U, N> res{{op(x[i])...}};
+    FOLLY_POP_WARNING
+    return res;
+  }
+
+  template <
+      std::size_t f,
+      std::size_t l,
+      typename T,
+      std::size_t N,
+      typename Op>
+  FOLLY_ALWAYS_INLINE static constexpr std::enable_if_t<l - f == 1, T>
+  arrayReduceImpl(std::array<T, N> const& x, Op) {
+    return x[f];
+  }
+
+  template <
+      std::size_t f,
+      std::size_t l,
+      typename T,
+      std::size_t N,
+      typename Op>
+  FOLLY_ALWAYS_INLINE static constexpr std::enable_if_t<l - f != 1, T>
+  arrayReduceImpl(std::array<T, N> const& x, Op op) {
+    constexpr std::size_t n = l - f;
+    T leftSum = arrayReduceImpl<f, f + n / 2>(x, op);
+    T rightSum = arrayReduceImpl<f + n / 2, l>(x, op);
+    return op(leftSum, rightSum);
+  }
+
+  template <typename Op, std::size_t... i>
+  FOLLY_ALWAYS_INLINE static constexpr bool unrollUntilImpl(
+      Op op, std::index_sequence<i...>) {
+    return (... || op(index_constant<i>{}));
+  }
+};
+
+} // namespace folly::simd::detail