react-native-windows 0.81.34 → 0.81.36

package/external/folly/folly/stop_watch.h

@@ -0,0 +1,317 @@
+/*
+ * 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 <chrono>
+#include <stdexcept>
+#include <utility>
+
+#include <folly/Chrono.h>
+#include <folly/Utility.h>
+#include <folly/portability/Time.h>
+
+namespace folly {
+
+using monotonic_clock = std::chrono::steady_clock;
+
+/**
+ * Calculates the duration of time intervals. Prefer this over directly using
+ * monotonic clocks. It is very lightweight and provides convenient facilities
+ * to avoid common pitfalls.
+ *
+ * There are two type aliases that should be preferred over instantiating this
+ * class directly: `coarse_stop_watch` and `stop_watch`.
+ *
+ * Arguments:
+ *  - Clock: the monotonic clock to use when calculating time intervals
+ *  - Duration: (optional) the duration to use when reporting elapsed time.
+ *              Defaults to the clock's duration.
+ *
+ * Example 1:
+ *
+ *  coarse_stop_watch<std::chrono::seconds> watch;
+ *  do_something();
+ *  std::cout << "time elapsed: " << watch.elapsed().count() << std::endl;
+ *
+ *  auto const ttl = 60_s;
+ *  if (watch.elapsed(ttl)) {
+ *    process_expiration();
+ *  }
+ *
+ * Example 2:
+ *
+ *  struct run_every_n_seconds {
+ *    using callback = std::function<void()>;
+ *    run_every_n_seconds(std::chrono::seconds period, callback action)
+ *      period_(period),
+ *      action_(std::move(action))
+ *    {
+ *      // watch_ is correctly initialized to the current time
+ *    }
+ *
+ *    void run() {
+ *      while (true) {
+ *        if (watch_.lap(period_)) {
+ *          action_();
+ *        }
+ *        std::this_thread::yield();
+ *      }
+ *    }
+ *
+ *  private:
+ *    stop_watch<> watch_;
+ *    std::chrono::seconds period_;
+ *    callback action_;
+ *  };
+ *
+ */
+template <typename Clock, typename Duration = typename Clock::duration>
+struct custom_stop_watch : private detail::inheritable<Clock> {
+ private:
+  using base = detail::inheritable<Clock>;
+
+ public:
+  using clock_type = Clock;
+  using duration = Duration;
+  using time_point = std::chrono::time_point<clock_type, duration>;
+
+  static_assert(
+      std::ratio_less_equal<
+          typename clock_type::duration::period,
+          typename duration::period>::value,
+      "clock must be at least as precise as the requested duration");
+
+  static_assert(
+      Clock::is_steady,
+      "only monotonic clocks should be used to track time intervals");
+
+  /**
+   * Initializes the stop watch with the current time as its checkpoint.
+   *
+   * Example:
+   *
+   *  stop_watch<> watch;
+   *  do_something();
+   *  std::cout << "time elapsed: " << watch.elapsed() << std::endl;
+   *
+   */
+  custom_stop_watch() : checkpoint_(now()) {}
+
+  /**
+   * Initializes the stop watch with the given time as its checkpoint.
+   *
+   * NOTE: this constructor should be seldomly used. It is only provided so
+   * that, in the rare occasions it is needed, one does not have to reimplement
+   * the `custom_stop_watch` class.
+   *
+   * Example:
+   *
+   *  custom_stop_watch<monotonic_clock> watch(monotonic_clock::now());
+   *  do_something();
+   *  std::cout << "time elapsed: " << watch.elapsed() << std::endl;
+   *
+   */
+  explicit custom_stop_watch(typename clock_type::time_point checkpoint)
+      : checkpoint_(std::move(checkpoint)) {}
+
+  /**
+   * Accepts a clock object, which can be useful in tests with a fake clock.
+   * Initializes the stop watch with the current time as its checkpoint.
+   */
+  explicit custom_stop_watch(clock_type clock)
+      : base(std::move(clock)), checkpoint_(now()) {}
+
+  /**
+   * Accepts a clock object, which can be useful in tests with a fake clock.
+   * Initializes the stop watch with the given time as its checkpoint.
+   */
+  custom_stop_watch(
+      clock_type clock, typename clock_type::time_point checkpoint)
+      : base(std::move(clock)), checkpoint_(std::move(checkpoint)) {}
+
+  /**
+   * Updates the stop watch checkpoint to the current time.
+   *
+   * Example:
+   *
+   *  struct some_resource {
+   *    // ...
+   *
+   *    void on_reloaded() {
+   *      time_alive.reset();
+   *    }
+   *
+   *    void report() {
+   *      std::cout << "resource has been alive for " << time_alive.elapsed();
+   *    }
+   *
+   *  private:
+   *    stop_watch<> time_alive;
+   *  };
+   *
+   */
+  void reset() { checkpoint_ = now(); }
+
+  /**
+   * Tells the elapsed time since the last update.
+   *
+   * The stop watch's checkpoint remains unchanged.
+   *
+   * Example:
+   *
+   *  stop_watch<> watch;
+   *  do_something();
+   *  std::cout << "time elapsed: " << watch.elapsed() << std::endl;
+   *
+   */
+  duration elapsed() const {
+    return std::chrono::duration_cast<duration>(now() - checkpoint_);
+  }
+
+  /**
+   * Tells whether the given duration has already elapsed since the last
+   * checkpoint.
+   *
+   * Example:
+   *
+   *  auto const ttl = 60_s;
+   *  stop_watch<> watch;
+   *
+   *  do_something();
+   *
+   *  std::cout << "ttl expired? " << std::boolalpha << watch.elapsed(ttl);
+   *
+   */
+  template <typename UDuration>
+  bool elapsed(UDuration&& amount) const {
+    return now() - checkpoint_ >= amount;
+  }
+
+  /**
+   * Tells the elapsed time since the last update, and updates the checkpoint
+   * to the current time.
+   *
+   * Example:
+   *
+   *  struct some_resource {
+   *    // ...
+   *
+   *    void on_reloaded() {
+   *      auto const alive = time_alive.lap();
+   *      std::cout << "resource reloaded after being alive for " << alive;
+   *    }
+   *
+   *  private:
+   *    stop_watch<> time_alive;
+   *  };
+   *
+   */
+  duration lap() {
+    auto lastCheckpoint = checkpoint_;
+
+    checkpoint_ = now();
+
+    return std::chrono::duration_cast<duration>(checkpoint_ - lastCheckpoint);
+  }
+
+  /**
+   * Tells whether the given duration has already elapsed since the last
+   * checkpoint. If so, update the checkpoint to the current time. If not,
+   * the checkpoint remains unchanged.
+   *
+   * Example:
+   *
+   *  void run_every_n_seconds(
+   *    std::chrono::seconds period,
+   *    std::function<void()> action
+   *  ) {
+   *    for (stop_watch<> watch;; ) {
+   *      if (watch.lap(period)) {
+   *        action();
+   *      }
+   *      std::this_thread::yield();
+   *    }
+   *  }
+   *
+   */
+  template <typename UDuration>
+  bool lap(UDuration&& amount) {
+    auto current = now();
+
+    if (current - checkpoint_ < amount) {
+      return false;
+    }
+
+    checkpoint_ = current;
+    return true;
+  }
+
+  /**
+   * Returns the current checkpoint
+   */
+  typename clock_type::time_point getCheckpoint() const noexcept {
+    return checkpoint_;
+  }
+
+ private:
+  typename clock_type::time_point checkpoint_;
+
+  typename clock_type::time_point now() const {
+    // We cannot just do base::now() if clock_type is marked as final.
+    return static_cast<clock_type const&>(*this).now();
+  }
+};
+
+/**
+ * A type alias for `custom_stop_watch` that uses a coarse monotonic clock as
+ * the time source.  Refer to the documentation of `custom_stop_watch` for full
+ * documentation.
+ *
+ * Arguments:
+ *  - Duration: (optional) the duration to use when reporting elapsed time.
+ *              Defaults to the clock's duration.
+ *
+ * Example:
+ *
+ *  coarse_stop_watch<std::chrono::seconds> watch;
+ *  do_something();
+ *  std::cout << "time elapsed: " << watch.elapsed().count() << std::endl;
+ *
+ */
+template <typename Duration = folly::chrono::coarse_steady_clock::duration>
+using coarse_stop_watch =
+    custom_stop_watch<folly::chrono::coarse_steady_clock, Duration>;
+
+/**
+ * A type alias for `custom_stop_watch` that uses a monotonic clock as the time
+ * source.  Refer to the documentation of `custom_stop_watch` for full
+ * documentation.
+ *
+ * Arguments:
+ *  - Duration: (optional) the duration to use when reporting elapsed time.
+ *              Defaults to the clock's duration.
+ *
+ * Example:
+ *
+ *  stop_watch<std::chrono::seconds> watch;
+ *  do_something();
+ *  std::cout << "time elapsed: " << watch.elapsed().count() << std::endl;
+ *
+ */
+template <typename Duration = std::chrono::steady_clock::duration>
+using stop_watch = custom_stop_watch<std::chrono::steady_clock, Duration>;
+} // namespace folly

package/external/folly/folly/synchronization/AsymmetricThreadFence.cpp

@@ -0,0 +1,91 @@
+/*
+ * 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.
+ */
+
+#include <folly/synchronization/AsymmetricThreadFence.h>
+
+#include <mutex>
+
+#include <folly/Exception.h>
+#include <folly/Indestructible.h>
+#include <folly/portability/SysMembarrier.h>
+#include <folly/portability/SysMman.h>
+#include <folly/synchronization/RelaxedAtomic.h>
+
+namespace folly {
+
+namespace {
+
+// The intention is to force a memory barrier in every core running any of the
+// process's threads. There is not a wide selection of options, but we do have
+// one trick: force a TLB shootdown. There are multiple scenarios in which a TLB
+// shootdown occurs, two of which are relevant: (1) when a resident page is
+// swapped out, and (2) when the protection on a resident page is downgraded.
+// We cannot force (1) and we cannot force (2). But we can force at least one of
+// the outcomes (1) or (2) to happen!
+void mprotectMembarrier() {
+  // This function is required to be safe to call on shutdown,
+  // so we must leak the mutex.
+  static Indestructible<std::mutex> mprotectMutex;
+  std::lock_guard<std::mutex> lg(*mprotectMutex);
+
+  // Ensure that we have a dummy page. The page is not used to store data;
+  // rather, it is used only for the side-effects of page operations.
+  static void* dummyPage = nullptr;
+  if (dummyPage == nullptr) {
+    dummyPage = mmap(nullptr, 1, PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+    FOLLY_SAFE_PCHECK(MAP_FAILED != dummyPage);
+  }
+
+  // We want to downgrade the page while it is resident. To do that, it must
+  // first be upgraded and forced to be resident.
+  FOLLY_SAFE_PCHECK(-1 != mprotect(dummyPage, 1, PROT_READ | PROT_WRITE));
+
+  // Force the page to be resident. If it is already resident, almost no-op.
+  *static_cast<char volatile*>(dummyPage) = 0;
+
+  // Downgrade the page. Forces a memory barrier in every core running any
+  // of the process's threads, if the page is resident. On a sane platform.
+  // If the page has been swapped out and is no longer resident, then the
+  // memory barrier has already occurred.
+  FOLLY_SAFE_PCHECK(-1 != mprotect(dummyPage, 1, PROT_READ));
+}
+
+bool sysMembarrierAvailableCached() {
+  // Optimistic concurrency variation on static local variable
+  static relaxed_atomic<char> cache{0};
+  char value = cache;
+  if (value == 0) {
+    value = detail::sysMembarrierPrivateExpeditedAvailable() ? 1 : -1;
+    cache = value;
+  }
+  return value == 1;
+}
+
+} // namespace
+
+void asymmetric_thread_fence_heavy_fn::impl_(std::memory_order order) noexcept {
+  if (kIsLinux) {
+    if (sysMembarrierAvailableCached()) {
+      FOLLY_SAFE_PCHECK(-1 != detail::sysMembarrierPrivateExpedited());
+    } else {
+      mprotectMembarrier();
+    }
+  } else {
+    std::atomic_thread_fence(order);
+  }
+}
+
+} // namespace folly

package/external/folly/folly/synchronization/AsymmetricThreadFence.h

@@ -0,0 +1,60 @@
+/*
+ * 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 <folly/portability/Asm.h>
+
+namespace folly {
+
+//  asymmetric_thread_fence_light
+//
+//  mimic: std::experimental::asymmetric_thread_fence_light, p1202r4
+//  http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p1202r4.pdf
+struct asymmetric_thread_fence_light_fn {
+  FOLLY_ALWAYS_INLINE void operator()(std::memory_order order) const noexcept {
+    if (kIsLinux) {
+      asm_volatile_memory();
+    } else {
+      std::atomic_thread_fence(order);
+    }
+  }
+};
+inline constexpr asymmetric_thread_fence_light_fn
+    asymmetric_thread_fence_light{};
+
+//  asymmetric_thread_fence_heavy
+//
+//  mimic: std::experimental::asymmetric_thread_fence_heavy, p1202r4
+//  http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p1202r4.pdf
+struct asymmetric_thread_fence_heavy_fn {
+  FOLLY_ALWAYS_INLINE void operator()(std::memory_order order) const noexcept {
+    if (kIsLinux) {
+      impl_(order);
+    } else {
+      std::atomic_thread_fence(order);
+    }
+  }
+
+ private:
+  static void impl_(std::memory_order) noexcept;
+};
+inline constexpr asymmetric_thread_fence_heavy_fn
+    asymmetric_thread_fence_heavy{};
+
+} // namespace folly

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

@@ -0,0 +1,146 @@
+/*
+ * 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/detail/Futex.h>
+#include <folly/synchronization/ParkingLot.h>
+
+namespace folly {
+namespace detail {
+namespace atomic_notification {
+/**
+ * We use Futex<std::atomic> as the alias that has the lowest performance
+ * overhead with respect to atomic notifications.  Assert that
+ * atomic_uint_fast_wait_t is the same as Futex<std::atomic>
+ */
+static_assert(std::is_same<atomic_uint_fast_wait_t, Futex<std::atomic>>{}, "");
+
+/**
+ * Implementation and specializations for the atomic_wait() family of
+ * functions
+ */
+inline std::cv_status toCvStatus(FutexResult result) {
+  return (result == FutexResult::TIMEDOUT) ? std::cv_status::timeout
+                                           : std::cv_status::no_timeout;
+}
+inline std::cv_status toCvStatus(ParkResult result) {
+  return (result == ParkResult::Timeout) ? std::cv_status::timeout
+                                         : std::cv_status::no_timeout;
+}
+
+// ParkingLot instantiation for futex management
+extern ParkingLot<std::uint32_t> parkingLot;
+
+template <template <typename...> class Atom, typename... Args>
+void atomic_wait_impl(
+    const Atom<std::uint32_t, Args...>* atomic, std::uint32_t old) {
+  futexWait(atomic, old);
+  return;
+}
+
+template <template <typename...> class Atom, typename Integer, typename... Args>
+void atomic_wait_impl(const Atom<Integer, Args...>* atomic, Integer old) {
+  static_assert(!std::is_same<Integer, std::uint32_t>{}, "");
+  parkingLot.park(atomic, -1, [&] { return atomic->load() == old; }, [] {});
+}
+
+template <
+    template <typename...>
+    class Atom,
+    typename... Args,
+    typename Clock,
+    typename Duration>
+std::cv_status atomic_wait_until_impl(
+    const Atom<std::uint32_t, Args...>* atomic,
+    std::uint32_t expected,
+    const std::chrono::time_point<Clock, Duration>& deadline) {
+  return toCvStatus(futexWaitUntil(atomic, expected, deadline));
+}
+
+template <
+    template <typename...>
+    class Atom,
+    typename Integer,
+    typename... Args,
+    typename Clock,
+    typename Duration>
+std::cv_status atomic_wait_until_impl(
+    const Atom<Integer, Args...>* atomic,
+    Integer expected,
+    const std::chrono::time_point<Clock, Duration>& deadline) {
+  static_assert(!std::is_same<Integer, std::uint32_t>{}, "");
+  return toCvStatus(parkingLot.park_until(
+      atomic, -1, [&] { return atomic->load() == expected; }, [] {}, deadline));
+}
+
+template <template <typename...> class Atom, typename... Args>
+void atomic_notify_one_impl(const Atom<std::uint32_t, Args...>* atomic) {
+  futexWake(atomic, 1);
+  return;
+}
+
+template <template <typename...> class Atom, typename Integer, typename... Args>
+void atomic_notify_one_impl(const Atom<Integer, Args...>* atomic) {
+  static_assert(!std::is_same<Integer, std::uint32_t>{}, "");
+  parkingLot.unpark(atomic, [&](const auto& data) {
+    FOLLY_SAFE_DCHECK(data == std::numeric_limits<std::uint32_t>::max(), "");
+    return UnparkControl::RemoveBreak;
+  });
+}
+
+template <template <typename...> class Atom, typename... Args>
+void atomic_notify_all_impl(const Atom<std::uint32_t, Args...>* atomic) {
+  futexWake(atomic);
+  return;
+}
+
+template <template <typename...> class Atom, typename Integer, typename... Args>
+void atomic_notify_all_impl(const Atom<Integer, Args...>* atomic) {
+  static_assert(!std::is_same<Integer, std::uint32_t>{}, "");
+  parkingLot.unpark(atomic, [&](const auto& data) {
+    FOLLY_SAFE_DCHECK(data == std::numeric_limits<std::uint32_t>::max(), "");
+    return UnparkControl::RemoveContinue;
+  });
+}
+
+template <typename Integer>
+void tag_invoke(
+    atomic_wait_fn, const std::atomic<Integer>* atomic, Integer expected) {
+  atomic_wait_impl(atomic, expected);
+}
+
+template <typename Integer, typename Clock, typename Duration>
+std::cv_status tag_invoke(
+    atomic_wait_until_fn,
+    const std::atomic<Integer>* atomic,
+    Integer expected,
+    const std::chrono::time_point<Clock, Duration>& deadline) {
+  return atomic_wait_until_impl(atomic, expected, deadline);
+}
+
+template <typename Integer>
+void tag_invoke(atomic_notify_one_fn, const std::atomic<Integer>* atomic) {
+  atomic_notify_one_impl(atomic);
+}
+
+template <typename Integer>
+void tag_invoke(atomic_notify_all_fn, const std::atomic<Integer>* atomic) {
+  atomic_notify_all_impl(atomic);
+}
+} // namespace atomic_notification
+} // namespace detail
+} // namespace folly

package/external/folly/folly/synchronization/AtomicNotification.cpp

@@ -0,0 +1,34 @@
+/*
+ * 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.
+ */
+
+#include <folly/synchronization/AtomicNotification.h>
+
+#include <cstdint>
+
+namespace folly {
+namespace detail {
+namespace atomic_notification {
+
+// ParkingLot instance used for the atomic_wait() family of functions
+//
+// This has been defined as a static object (as opposed to allocated to avoid
+// destruction order problems) because of possible uses coming from
+// allocation-sensitive contexts.
+ParkingLot<std::uint32_t> parkingLot;
+
+} // namespace atomic_notification
+} // namespace detail
+} // namespace folly