react-native-windows 0.81.34 → 0.81.35

package/external/folly/folly/synchronization/AtomicNotification.h

@@ -0,0 +1,117 @@
+/*
+ * 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 <atomic>
+#include <condition_variable>
+
+#include <folly/Portability.h>
+
+namespace folly {
+
+/**
+ * The behavior of the atomic_wait() family of functions is semantically
+ * identical to futex().  Correspondingly, calling atomic_notify_one(),
+ * atomic_notify_all() is identical to futexWake() with 1 and
+ * std::numeric_limits<int>::max() respectively
+ *
+ * The difference here compared to the futex API above is that it works with
+ * all types of atomic widths.  When a 32 bit atomic integer is used, the
+ * implementation falls back to using futex() if possible, and the
+ * compatibility implementation for non-linux systems otherwise.  For all
+ * other integer widths, the compatibility implementation is used
+ *
+ * The templating of this API is changed from the standard in the following
+ * ways
+ *
+ * - At the time of writing, libstdc++'s implementation of std::atomic<> does
+ *   not include the value_type alias.  So we rely on the atomic type being a
+ *   template class such that the first type is the underlying value type
+ * - The Atom parameter allows this API to be compatible with
+ *   DeterministicSchedule testing.
+ * - atomic_wait_until() does not exist in the linked paper, the version here
+ *   is identical to futexWaitUntil() and returns std::cv_status
+ */
+//  mimic: std::atomic_wait, p1135r0
+namespace detail {
+namespace atomic_notification {
+struct atomic_wait_fn {
+ public:
+  template <typename Atomic, typename Integer>
+  constexpr void operator()(const Atomic* atomic, Integer integer) const {
+    tag_invoke(*this, atomic, integer);
+  }
+};
+} // namespace atomic_notification
+} // namespace detail
+inline constexpr auto atomic_wait =
+    detail::atomic_notification::atomic_wait_fn{};
+
+//  mimic: std::atomic_wait_until, p1135r0
+namespace detail {
+namespace atomic_notification {
+struct atomic_wait_until_fn {
+ public:
+  template <typename Atomic, typename Integer, typename Clock, typename Dur>
+  constexpr std::cv_status operator()(
+      const Atomic* atomic,
+      Integer old,
+      const std::chrono::time_point<Clock, Dur>& deadline) const {
+    return tag_invoke(*this, atomic, old, deadline);
+  }
+};
+} // namespace atomic_notification
+} // namespace detail
+inline constexpr auto atomic_wait_until =
+    detail::atomic_notification::atomic_wait_until_fn{};
+
+//  mimic: std::atomic_notify_one, p1135r0
+namespace detail {
+namespace atomic_notification {
+struct atomic_notify_one_fn {
+ public:
+  template <typename Atomic>
+  constexpr void operator()(const Atomic* atomic) const {
+    tag_invoke(*this, atomic);
+  }
+};
+} // namespace atomic_notification
+} // namespace detail
+inline constexpr auto atomic_notify_one =
+    detail::atomic_notification::atomic_notify_one_fn{};
+
+//  mimic: std::atomic_notify_all, p1135r0
+namespace detail {
+namespace atomic_notification {
+struct atomic_notify_all_fn {
+ public:
+  template <typename Atomic>
+  constexpr void operator()(Atomic* atomic) const {
+    tag_invoke(*this, atomic);
+  }
+};
+} // namespace atomic_notification
+} // namespace detail
+inline constexpr auto atomic_notify_all =
+    detail::atomic_notification::atomic_notify_all_fn{};
+
+//  mimic: std::atomic_uint_fast_wait_t, p1135r0
+using atomic_uint_fast_wait_t = std::atomic<std::uint32_t>;
+
+} // namespace folly
+
+#include <folly/synchronization/AtomicNotification-inl.h>

package/external/folly/folly/synchronization/AtomicRef.h

@@ -0,0 +1,181 @@
+/*
+ * 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 <atomic>
+#include <cassert>
+#include <cstddef>
+#include <type_traits>
+
+#include <folly/Traits.h>
+#include <folly/lang/SafeAssert.h>
+
+namespace folly {
+
+namespace detail {
+
+template <typename T>
+struct atomic_ref_base {
+  static_assert(sizeof(T) == sizeof(std::atomic<T>), "size mismatch");
+  static_assert(
+      std::is_trivially_copyable_v<T>, "value not trivially-copyable");
+
+  using value_type = T;
+
+  static inline constexpr std::size_t required_alignment =
+      alignof(std::atomic<T>);
+
+  explicit atomic_ref_base(T& ref) : ref_(ref) { check_alignment_(); }
+  atomic_ref_base(atomic_ref_base const&) = default;
+
+  void store(T desired, std::memory_order order = std::memory_order_seq_cst)
+      const noexcept {
+    return atomic().store(desired, order);
+  }
+
+  T load(std::memory_order order = std::memory_order_seq_cst) const noexcept {
+    return atomic().load(order);
+  }
+
+  T exchange(T desired, std::memory_order order = std::memory_order_seq_cst)
+      const noexcept {
+    return atomic().exchange(desired, order);
+  }
+
+  bool compare_exchange_weak(
+      T& expected,
+      T desired,
+      std::memory_order success,
+      std::memory_order failure) const noexcept {
+    return atomic().compare_exchange_weak(expected, desired, success, failure);
+  }
+
+  bool compare_exchange_weak(
+      T& expected,
+      T desired,
+      std::memory_order order = std::memory_order_seq_cst) const noexcept {
+    return atomic().compare_exchange_weak(expected, desired, order);
+  }
+
+  bool compare_exchange_strong(
+      T& expected,
+      T desired,
+      std::memory_order success,
+      std::memory_order failure) const noexcept {
+    return atomic().compare_exchange_strong(
+        expected, desired, success, failure);
+  }
+
+  bool compare_exchange_strong(
+      T& expected,
+      T desired,
+      std::memory_order order = std::memory_order_seq_cst) const noexcept {
+    return atomic().compare_exchange_strong(expected, desired, order);
+  }
+
+  std::atomic<T>& atomic() const noexcept {
+    return reinterpret_cast<std::atomic<T>&>(ref_); // ub dragons be here
+  }
+
+ private:
+  void check_alignment_() const noexcept {
+    auto ptr = reinterpret_cast<uintptr_t>(
+        &reinterpret_cast<unsigned char const&>(ref_));
+    FOLLY_SAFE_DCHECK(ptr % required_alignment == 0);
+  }
+
+  T& ref_;
+};
+
+template <typename T>
+struct atomic_ref_integral_base : atomic_ref_base<T> {
+  using atomic_ref_base<T>::atomic_ref_base;
+  using atomic_ref_base<T>::atomic;
+
+  T fetch_add(T arg, std::memory_order order = std::memory_order_seq_cst)
+      const noexcept {
+    return atomic().fetch_add(arg, order);
+  }
+
+  T fetch_sub(T arg, std::memory_order order = std::memory_order_seq_cst)
+      const noexcept {
+    return atomic().fetch_sub(arg, order);
+  }
+
+  T fetch_and(T arg, std::memory_order order = std::memory_order_seq_cst)
+      const noexcept {
+    return atomic().fetch_and(arg, order);
+  }
+
+  T fetch_or(T arg, std::memory_order order = std::memory_order_seq_cst)
+      const noexcept {
+    return atomic().fetch_or(arg, order);
+  }
+
+  T fetch_xor(T arg, std::memory_order order = std::memory_order_seq_cst)
+      const noexcept {
+    return atomic().fetch_xor(arg, order);
+  }
+};
+
+template <typename T>
+using atomic_ref_select = conditional_t<
+    std::is_integral<T>::value && !std::is_same<T, bool>::value,
+    atomic_ref_integral_base<T>,
+    atomic_ref_base<T>>;
+
+} // namespace detail
+
+//  atomic_ref
+//
+//  A very partial backport of std::atomic_ref from C++20, limited for now to
+//  the common operations on counters for now. May become a complete backport
+//  in the future.
+//
+//  Relies on the assumption that `T&` is reinterpretable as `std::atomic<T>&`.
+//  And that the required alignment for that reinterpretation is `alignof(T)`.
+//  When that is not the case, *kaboom*.
+//
+//  mimic: std::atomic_ref, C++20
+template <typename T>
+class atomic_ref : public detail::atomic_ref_select<T> {
+ private:
+  using base = detail::atomic_ref_select<T>;
+
+ public:
+  using base::base;
+};
+
+template <typename T>
+atomic_ref(T&) -> atomic_ref<T>;
+
+struct make_atomic_ref_t {
+  template <
+      typename T,
+      std::enable_if_t<
+          std::is_trivially_copyable_v<T> &&
+              sizeof(T) == sizeof(std::atomic<T>) &&
+              alignof(T) == alignof(std::atomic<T>),
+          int> = 0>
+  atomic_ref<T> operator()(T& ref) const {
+    return atomic_ref<T>{ref};
+  }
+};
+
+inline constexpr make_atomic_ref_t make_atomic_ref;
+
+} // namespace folly

package/external/folly/folly/synchronization/AtomicStruct.h

@@ -0,0 +1,150 @@
+/*
+ * 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 <atomic>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <type_traits>
+
+#include <folly/ConstexprMath.h>
+#include <folly/Traits.h>
+#include <folly/synchronization/detail/AtomicUtils.h>
+
+namespace folly {
+
+namespace detail {
+template <size_t>
+struct AtomicStructRaw;
+template <>
+struct AtomicStructRaw<0> {
+  using type = uint8_t;
+};
+template <>
+struct AtomicStructRaw<1> {
+  using type = uint16_t;
+};
+template <>
+struct AtomicStructRaw<2> {
+  using type = uint32_t;
+};
+template <>
+struct AtomicStructRaw<3> {
+  using type = uint64_t;
+};
+} // namespace detail
+
+/// AtomicStruct<T> work like C++ atomics, but can be used on any POD
+/// type <= 8 bytes.
+template <typename T, template <typename> class Atom = std::atomic>
+class AtomicStruct {
+ private:
+  using Raw = _t<detail::AtomicStructRaw<constexpr_log2_ceil(sizeof(T))>>;
+
+  static_assert(alignof(T) <= alignof(Raw), "underlying type is under-aligned");
+  static_assert(sizeof(T) <= sizeof(Raw), "underlying type is under-sized");
+  static_assert(
+      std::is_trivial<T>::value || std::is_trivially_copyable<T>::value,
+      "target type must be trivially copyable");
+
+  Atom<Raw> data;
+
+  static Raw encode(T v) noexcept {
+    // we expect the compiler to optimize away the memcpy, but without
+    // it we would violate strict aliasing rules
+    Raw d = 0;
+    memcpy(&d, static_cast<void*>(&v), sizeof(T));
+    return d;
+  }
+
+  static T decode(Raw d) noexcept {
+    T v;
+    memcpy(static_cast<void*>(&v), &d, sizeof(T));
+    return v;
+  }
+
+ public:
+  AtomicStruct() = default;
+  ~AtomicStruct() = default;
+  AtomicStruct(AtomicStruct<T> const&) = delete;
+  AtomicStruct<T>& operator=(AtomicStruct<T> const&) = delete;
+
+  constexpr /* implicit */ AtomicStruct(T v) noexcept : data(encode(v)) {}
+
+  bool is_lock_free() const noexcept { return data.is_lock_free(); }
+
+  bool compare_exchange_strong(
+      T& v0, T v1, std::memory_order mo = std::memory_order_seq_cst) noexcept {
+    return compare_exchange_strong(
+        v0, v1, mo, detail::default_failure_memory_order(mo));
+  }
+  bool compare_exchange_strong(
+      T& v0,
+      T v1,
+      std::memory_order success,
+      std::memory_order failure) noexcept {
+    Raw d0 = encode(v0);
+    bool rv = data.compare_exchange_strong(d0, encode(v1), success, failure);
+    if (!rv) {
+      v0 = decode(d0);
+    }
+    return rv;
+  }
+
+  bool compare_exchange_weak(
+      T& v0, T v1, std::memory_order mo = std::memory_order_seq_cst) noexcept {
+    return compare_exchange_weak(
+        v0, v1, mo, detail::default_failure_memory_order(mo));
+  }
+  bool compare_exchange_weak(
+      T& v0,
+      T v1,
+      std::memory_order success,
+      std::memory_order failure) noexcept {
+    Raw d0 = encode(v0);
+    bool rv = data.compare_exchange_weak(d0, encode(v1), success, failure);
+    if (!rv) {
+      v0 = decode(d0);
+    }
+    return rv;
+  }
+
+  T exchange(T v, std::memory_order mo = std::memory_order_seq_cst) noexcept {
+    return decode(data.exchange(encode(v), mo));
+  }
+
+  /* implicit */ operator T() const noexcept { return decode(data); }
+
+  T load(std::memory_order mo = std::memory_order_seq_cst) const noexcept {
+    return decode(data.load(mo));
+  }
+
+  T operator=(T v) noexcept { return decode(data = encode(v)); }
+
+  void store(T v, std::memory_order mo = std::memory_order_seq_cst) noexcept {
+    data.store(encode(v), mo);
+  }
+
+  // std::atomic also provides volatile versions of all of the access
+  // methods.  These are callable on volatile objects, and also can
+  // theoretically have different implementations than their non-volatile
+  // counterpart.  If someone wants them here they can easily be added
+  // by duplicating the above code and the corresponding unit tests.
+};
+
+} // namespace folly