react-native-windows 0.84.0-preview.9 → 0.84.1

package/external/folly/folly/concurrency/memory/AtomicReadMostlyMainPtr.cpp

@@ -0,0 +1,43 @@
+/*
+ * 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/concurrency/memory/AtomicReadMostlyMainPtr.h>
+
+#include <folly/executors/InlineExecutor.h>
+
+namespace folly {
+namespace detail {
+
+namespace {
+struct FailingExecutor : folly::Executor {
+  // We shouldn't be invoking any callbacks.
+  void add(Func func) override {
+    LOG(DFATAL)
+        << "Added an RCU callback to the AtomicReadMostlyMainPtr executor.";
+    InlineExecutor::instance().add(std::move(func));
+  }
+};
+} // namespace
+
+// *All* modifications of *all* AtomicReadMostlyMainPtrs use the same mutex and
+// domain. The first of these just shrinks the size of the individual objects a
+// little, but the second is necessary for correctness; we want to support
+// arbitrarily many AtomicReadMostlyMainPtrs.
+Indestructible<std::mutex> atomicReadMostlyMu;
+Indestructible<folly::rcu_domain> atomicReadMostlyDomain(new FailingExecutor);
+
+} // namespace detail
+} // namespace folly

package/external/folly/folly/concurrency/memory/AtomicReadMostlyMainPtr.h

@@ -0,0 +1,190 @@
+/*
+ * 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 <cstdint>
+#include <memory>
+#include <mutex>
+
+#include <folly/Indestructible.h>
+#include <folly/concurrency/memory/ReadMostlySharedPtr.h>
+#include <folly/synchronization/Rcu.h>
+
+namespace folly {
+
+namespace detail {
+extern Indestructible<std::mutex> atomicReadMostlyMu;
+extern Indestructible<rcu_domain> atomicReadMostlyDomain;
+} // namespace detail
+
+/*
+ * What atomic_shared_ptr is to shared_ptr, AtomicReadMostlyMainPtr is to
+ * ReadMostlyMainPtr; it allows racy conflicting accesses to one. This gives
+ * true shared_ptr-like semantics, including reclamation at the point where the
+ * last pointer to an object goes away.
+ *
+ * It's about the same speed (slightly slower) as ReadMostlyMainPtr. The most
+ * significant feature they share is avoiding reader-reader contention and
+ * atomic RMWs in the absence of writes.
+ */
+template <typename T>
+class AtomicReadMostlyMainPtr {
+ public:
+  AtomicReadMostlyMainPtr() : curMainPtrIndex_(0) {}
+
+  explicit AtomicReadMostlyMainPtr(std::shared_ptr<T> ptr)
+      : curMainPtrIndex_(0) {
+    mainPtrs_[0] = ReadMostlyMainPtr<T>{std::move(ptr)};
+  }
+
+  void operator=(std::shared_ptr<T> desired) { store(std::move(desired)); }
+
+  bool is_lock_free() const { return false; }
+
+  ReadMostlySharedPtr<T> load(
+      std::memory_order order = std::memory_order_seq_cst) const {
+    detail::atomicReadMostlyDomain->lock();
+    // Synchronization point with the store in storeLocked().
+    auto index = curMainPtrIndex_.load(order);
+    auto result = mainPtrs_[index].getShared();
+    detail::atomicReadMostlyDomain->unlock();
+    return result;
+  }
+
+  void store(
+      std::shared_ptr<T> ptr,
+      std::memory_order order = std::memory_order_seq_cst) {
+    std::shared_ptr<T> old;
+    {
+      std::lock_guard<std::mutex> lg(*detail::atomicReadMostlyMu);
+      old = exchangeLocked(std::move(ptr), order);
+    }
+    // If ~T() runs (triggered by the shared_ptr refcount decrement), it's here,
+    // after dropping the lock. This avoids a possible (albeit esoteric)
+    // deadlock if ~T() modifies the AtomicReadMostlyMainPtr that used to point
+    // to it.
+  }
+
+  std::shared_ptr<T> exchange(
+      std::shared_ptr<T> ptr,
+      std::memory_order order = std::memory_order_seq_cst) {
+    std::lock_guard<std::mutex> lg(*detail::atomicReadMostlyMu);
+    return exchangeLocked(std::move(ptr), order);
+  }
+
+  bool compare_exchange_weak(
+      std::shared_ptr<T>& expected,
+      const std::shared_ptr<T>& desired,
+      std::memory_order successOrder = std::memory_order_seq_cst,
+      std::memory_order failureOrder = std::memory_order_seq_cst) {
+    return compare_exchange_strong(
+        expected, desired, successOrder, failureOrder);
+  }
+
+  bool compare_exchange_strong(
+      std::shared_ptr<T>& expected,
+      const std::shared_ptr<T>& desired,
+      std::memory_order successOrder = std::memory_order_seq_cst,
+      std::memory_order failureOrder = std::memory_order_seq_cst) {
+    // See the note at the end of store; we need to defer any destruction we
+    // might trigger until after the lock is released.
+    // This is not actually needed down the success path (the reference passed
+    // in as expected is another pointer to the same object, so we won't
+    // decrement the refcount to 0), but "never decrement a refcount while
+    // holding a lock" is an easier rule to keep in our heads, and costs us
+    // nothing.
+    std::shared_ptr<T> prev;
+    std::shared_ptr<T> expectedDup;
+    {
+      std::lock_guard<std::mutex> lg(*detail::atomicReadMostlyMu);
+      auto index = curMainPtrIndex_.load(failureOrder);
+      ReadMostlyMainPtr<T>& oldMain = mainPtrs_[index];
+      if (oldMain.get() != expected.get()) {
+        expectedDup = std::move(expected);
+        expected = oldMain.getStdShared();
+        return false;
+      }
+      prev = exchangeLocked(desired, successOrder);
+    }
+    return true;
+  }
+
+ private:
+  // Must hold the global mutex.
+  std::shared_ptr<T> exchangeLocked(
+      std::shared_ptr<T> ptr,
+      std::memory_order order = std::memory_order_seq_cst) {
+    // This is where the tricky bits happen; all modifications of the mainPtrs_
+    // and index happen here. We maintain the invariant that, on entry to this
+    // method, all read-side critical sections in progress are using the version
+    // indicated by curMainPtrIndex_, and the other version is nulled out.
+    // (Readers can still hold a ReadMostlySharedPtr to the thing the old
+    // version used to point to; they just can't access the old version to get
+    // that handle any more).
+    auto index = curMainPtrIndex_.load(std::memory_order_relaxed);
+    ReadMostlyMainPtr<T>& oldMain = mainPtrs_[index];
+    ReadMostlyMainPtr<T>& newMain = mainPtrs_[1 - index];
+    DCHECK(newMain.get() == nullptr)
+        << "Invariant should ensure that at most one version is non-null";
+    newMain.reset(std::move(ptr));
+    // If order is acq_rel, it should degrade to just release, and if acquire to
+    // relaxed, since this is a store rather than an RMW. (Of course, this is
+    // such a slow method that we don't really care, but precision is its own
+    // reward. If TSAN one day understands asymmetric barriers, this will also
+    // improve its error detection here). We get our "acquire-y-ness" from the
+    // mutex.
+    auto realOrder =
+        (order == std::memory_order_acq_rel       ? std::memory_order_release
+             : order == std::memory_order_acquire ? std::memory_order_relaxed
+                                                  : order);
+    // After this, read-side critical sections can access both versions, but
+    // new ones will use newMain.
+    // This is also synchronization point with loads.
+    curMainPtrIndex_.store(1 - index, realOrder);
+    // Wait for all read-side critical sections using oldMain to finish.
+    detail::atomicReadMostlyDomain->synchronize();
+    // We've reestablished the first half of the invariant (all readers are
+    // using newMain), now let's establish the other one (that the other pointer
+    // is null).
+    auto result = oldMain.getStdShared();
+    oldMain.reset();
+    return result;
+  }
+
+  // The right way to think of this implementation is as an
+  // std::atomic<ReadMostlyMainPtr<T>*>, protected by RCU. There's only two
+  // tricky parts:
+  // 1. We give ourselves our own RCU domain, and synchronize on modification,
+  //    so that we don't do any batching of deallocations. This gives
+  //    shared_ptr-like eager reclamation semantics.
+  // 2. Instead of putting the ReadMostlyMainPtrs on the heap, we keep them as
+  //    part of the same object to improve locality.
+
+  // Really, just a 0/1 index. This is also the synchronization point for memory
+  // orders.
+  std::atomic<uint8_t> curMainPtrIndex_;
+
+  // Both the ReadMostlyMainPtrs themselves and the domain have nontrivial
+  // indirections even on the read path, and asymmetric barriers on the write
+  // path. Some of these could be fused as a later optimization, at the cost of
+  // having to put more tricky threading primitives in this class that are
+  // currently abstracted out by those.
+  ReadMostlyMainPtr<T> mainPtrs_[2];
+};
+
+} // namespace folly

package/external/folly/folly/concurrency/memory/BUCK

@@ -0,0 +1,53 @@
+load("@fbcode_macros//build_defs:cpp_library.bzl", "cpp_library")
+
+oncall("fbcode_entropy_wardens_folly")
+
+cpp_library(
+    name = "atomic_read_mostly_main_ptr",
+    srcs = [
+        "AtomicReadMostlyMainPtr.cpp",
+    ],
+    headers = [
+        "AtomicReadMostlyMainPtr.h",
+    ],
+    deps = [
+        "//folly/executors:inline_executor",
+    ],
+    exported_deps = [
+        "//folly:indestructible",
+        "//folly/concurrency/memory:read_mostly_shared_ptr",
+        "//folly/synchronization:rcu",
+    ],
+)
+
+cpp_library(
+    name = "read_mostly_shared_ptr",
+    headers = ["ReadMostlySharedPtr.h"],
+    exported_deps = [
+        "//folly:function",
+        "//folly/concurrency/memory:tl_ref_count",
+    ],
+)
+
+cpp_library(
+    name = "primary_ptr",
+    headers = ["PrimaryPtr.h"],
+    exported_deps = [
+        "//folly:function",
+        "//folly/futures:cleanup",
+        "//folly/futures:core",
+    ],
+    exported_external_deps = [
+        "glog",
+    ],
+)
+
+cpp_library(
+    name = "tl_ref_count",
+    headers = ["TLRefCount.h"],
+    exported_deps = [
+        "//folly:thread_local",
+        "//folly/synchronization:asymmetric_thread_fence",
+        "//folly/synchronization/detail:sleeper",
+    ],
+)

package/external/folly/folly/concurrency/memory/PrimaryPtr.h

@@ -0,0 +1,338 @@
+/*
+ * 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 <memory>
+#include <mutex>
+
+#include <folly/Function.h>
+#include <folly/futures/Cleanup.h>
+#include <folly/futures/Future.h>
+
+#include <glog/logging.h>
+
+namespace folly {
+
+template <typename T>
+class EnablePrimaryFromThis;
+
+template <typename T>
+class PrimaryPtr;
+
+template <typename T>
+class PrimaryPtrRef;
+
+namespace detail {
+struct publicallyDerivedFromEnablePrimaryFromThis_fn {
+  template <class T>
+  void operator()(const EnablePrimaryFromThis<T>&) const {}
+};
+} // namespace detail
+
+template <class T>
+constexpr bool is_enable_master_from_this_v = folly::
+    is_invocable_v<detail::publicallyDerivedFromEnablePrimaryFromThis_fn, T>;
+
+template <typename T>
+using is_enable_master_from_this =
+    std::bool_constant<is_enable_master_from_this_v<T>>;
+
+/**
+ * EnablePrimaryFromThis provides an object with appropriate access to the
+ * functionality of the PrimaryPtr holding this.
+ */
+template <typename T>
+class EnablePrimaryFromThis {
+  // initializes members when the PrimaryPtr for this is constructed
+  //
+  // used by the PrimaryPtr for this, to invoke the EnablePrimaryFromThis base
+  // of T, if it exists.
+  template <
+      class O,
+      class Master,
+      std::enable_if_t<is_enable_master_from_this_v<O>, int> = 0>
+  static void set(EnablePrimaryFromThis<O>* that, Master& m) {
+    that->outerPtrWeak_ = m.outerPtrWeak_;
+  }
+
+  template <
+      class O,
+      class Master,
+      std::enable_if_t<!is_enable_master_from_this_v<O>, int> = 0>
+  static void set(O*, Master&) {}
+
+ public:
+  // Gets a non-owning reference to the pointer. PrimaryPtr::join() and the
+  // PrimaryPtr::cleanup() work do *NOT* wait for outstanding PrimaryPtrRef
+  // objects to be released.
+  PrimaryPtrRef<T> masterRefFromThis() {
+    return PrimaryPtrRef<T>(outerPtrWeak_);
+  }
+
+  // Gets a non-owning const reference to the pointer. PrimaryPtr::join() and
+  // the PrimaryPtr::cleanup() work do *NOT* wait for outstanding PrimaryPtrRef
+  // objects to be released.
+  PrimaryPtrRef<const T> masterRefFromThis() const {
+    return PrimaryPtrRef<const T>(outerPtrWeak_);
+  }
+
+  // Attempts to lock a pointer. Returns null if pointer is not set or if
+  // PrimaryPtr::join() was called or the PrimaryPtr::cleanup() task was started
+  // (even if the call to PrimaryPtr::join() hasn't returned yet and the
+  // PrimaryPtr::cleanup() task has not completed yet).
+  std::shared_ptr<T> masterLockFromThis() {
+    if (auto outerPtr = outerPtrWeak_.lock()) {
+      return *outerPtr;
+    }
+    return nullptr;
+  }
+
+  // Attempts to lock a pointer. Returns null if pointer is not set or if
+  // PrimaryPtr::join() was called or the PrimaryPtr::cleanup() task was started
+  // (even if the call to PrimaryPtr::join() hasn't returned yet and the
+  // PrimaryPtr::cleanup() task has not completed yet).
+  std::shared_ptr<T const> masterLockFromThis() const {
+    if (!*this) {
+      return nullptr;
+    }
+    if (auto outerPtr = outerPtrWeak_.lock()) {
+      return *outerPtr;
+    }
+    return nullptr;
+  }
+
+ private:
+  template <class>
+  friend class PrimaryPtr;
+
+  std::weak_ptr<std::shared_ptr<T>> outerPtrWeak_;
+};
+
+/**
+ * PrimaryPtr should be used to achieve deterministic destruction of objects
+ * with shared ownership. Once an object is managed by a PrimaryPtr, shared_ptrs
+ * can be obtained pointing to that object. However destroying those shared_ptrs
+ * will never call the object destructor inline. To destroy the object, join()
+ * method must be called on PrimaryPtr or the task returned from cleanup() must
+ * be completed, which will wait for all shared_ptrs to be released and then
+ * call the object destructor on the caller supplied execution context.
+ */
+template <typename T>
+class PrimaryPtr {
+  // retrieves nested cleanup() work from innerPtr_. Called when the PrimaryPtr
+  // cleanup() task has finished waiting for outstanding references
+  //
+  template <class Cleanup, std::enable_if_t<is_cleanup_v<Cleanup>, int> = 0>
+  static folly::SemiFuture<folly::Unit> getCleanup(Cleanup* cleanup) {
+    return std::move(*cleanup).cleanup();
+  }
+
+  template <class O, std::enable_if_t<!is_cleanup_v<O>, int> = 0>
+  static folly::SemiFuture<folly::Unit> getCleanup(O*) {
+    return folly::makeSemiFuture();
+  }
+
+ public:
+  PrimaryPtr() = delete;
+  template <class T2, class Deleter>
+  PrimaryPtr(std::unique_ptr<T2, Deleter> ptr) {
+    set(std::move(ptr));
+  }
+
+  explicit PrimaryPtr(std::nullptr_t) {}
+
+  ~PrimaryPtr() {
+    if (*this) {
+      LOG(FATAL) << "PrimaryPtr has to be joined explicitly.";
+    }
+  }
+
+  PrimaryPtr(PrimaryPtr<T>&&) = default;
+
+  void swap(PrimaryPtr<T>& other) noexcept {
+    PrimaryPtr<T> temp = std::move(other);
+    other = std::move(*this);
+    *this = std::move(temp);
+  }
+
+  PrimaryPtr<T> exchange(PrimaryPtr<T>&& newVal) noexcept {
+    PrimaryPtr<T> oldVal = std::move(*this);
+    *this = std::move(newVal);
+    return oldVal;
+  }
+
+  explicit operator bool() const { return !!innerPtr_; }
+
+  // Attempts to lock a pointer. Returns null if pointer is not set or if join()
+  // was called or the cleanup() task was started (even if the call to join()
+  // hasn't returned yet and the cleanup() task has not completed yet).
+  std::shared_ptr<T> lock() const {
+    if (auto outerPtr = outerPtrWeak_.lock()) {
+      return *outerPtr;
+    }
+    return nullptr;
+  }
+
+  // Waits until all the refereces obtained via lock() are released. Then
+  // destroys the object in the current thread.
+  // Can not be called concurrently with set().
+  void join() {
+    if (!*this) {
+      return;
+    }
+    this->cleanup().get();
+  }
+
+  // Returns: a SemiFuture that waits until all the refereces obtained via
+  // lock() are released. Then destroys the object on the Executor provided to
+  // the SemiFuture.
+  //
+  // The returned SemiFuture must run to completion before calling set()
+  //
+  folly::SemiFuture<folly::Unit> cleanup() {
+    return folly::makeSemiFuture()
+        // clear outerPtrShared_ after cleanup is started
+        // to disable further calls to lock().
+        // then wait for outstanding references.
+        .deferValue([this](folly::Unit) {
+          if (!this->outerPtrShared_) {
+            LOG(FATAL)
+                << "Cleanup already run - lock() was previouly disabled.";
+          }
+          this->outerPtrShared_.reset();
+          return std::move(this->unreferenced_);
+        })
+        // start cleanup tasks
+        .deferValue([this](folly::Unit) { return getCleanup(innerPtr_.get()); })
+        .defer([this](folly::Try<folly::Unit> r) {
+          if (r.hasException()) {
+            LOG(FATAL) << "Cleanup actions must be noexcept.";
+          }
+          this->innerPtr_.reset();
+        });
+  }
+
+  // Sets the pointer. Can not be called concurrently with lock() or join() or
+  // ref() or while the SemiFuture returned from cleanup() is running.
+  template <class T2, class Deleter>
+  void set(std::unique_ptr<T2, Deleter> ptr) {
+    if (*this) {
+      LOG(FATAL) << "PrimaryPtr has to be joined before being set.";
+    }
+
+    if (!ptr) {
+      return;
+    }
+
+    auto rawPtr = ptr.get();
+    innerPtr_ = std::unique_ptr<T, folly::Function<void(T*)>>{
+        ptr.release(),
+        [d = ptr.get_deleter(), rawPtr](T*) mutable { d(rawPtr); }};
+
+    auto [referencesPromise, referencesFuture] =
+        folly::makePromiseContract<folly::Unit>();
+    unreferenced_ = std::move(referencesFuture);
+
+    // The deleter object needs to be copyable in std::shared_ptr on some
+    // platform. To work around this limitation we can slightly tweak the
+    // semantics of deleter copy constructor and check we always use this
+    // object at most once.
+    class LastReference {
+     public:
+      LastReference(Promise<Unit>&& p) : p_(std::move(p)) {}
+      LastReference(LastReference&&) = default;
+      LastReference(LastReference& other) : LastReference(std::move(other)) {}
+      void operator()(T*) {
+        DCHECK(!p_.isFulfilled());
+        p_.setValue();
+      }
+
+     private:
+      Promise<Unit> p_;
+    };
+    auto innerPtrShared = std::shared_ptr<T>(
+        innerPtr_.get(), LastReference{std::move(referencesPromise)});
+
+    outerPtrWeak_ = outerPtrShared_ =
+        std::make_shared<std::shared_ptr<T>>(innerPtrShared);
+
+    // attaches optional EnablePrimaryFromThis base of innerPtr_ to this
+    // PrimaryPtr
+    EnablePrimaryFromThis<T>::set(innerPtr_.get(), *this);
+  }
+
+  // Gets a non-owning reference to the pointer. join() and the cleanup() work
+  // do *NOT* wait for outstanding PrimaryPtrRef objects to be released.
+  PrimaryPtrRef<T> ref() const { return PrimaryPtrRef<T>(outerPtrWeak_); }
+
+ private:
+  // Making this private for now since non-null PrimaryPtr's must be explicitly
+  // joined before destruction.
+  PrimaryPtr<T>& operator=(PrimaryPtr<T>&& other) = default;
+
+  template <class>
+  friend class EnablePrimaryFromThis;
+  friend class PrimaryPtrRef<T>;
+
+  folly::SemiFuture<folly::Unit> unreferenced_;
+  std::shared_ptr<std::shared_ptr<T>> outerPtrShared_;
+  std::weak_ptr<std::shared_ptr<T>> outerPtrWeak_;
+  std::unique_ptr<T, folly::Function<void(T*)>> innerPtr_;
+};
+
+template <typename T>
+void swap(PrimaryPtr<T>& x, PrimaryPtr<T>& y) noexcept {
+  x.swap(y);
+}
+
+template <typename T>
+PrimaryPtr<T> exchange(PrimaryPtr<T>& x, PrimaryPtr<T>&& newVal) noexcept {
+  return x.exchange(std::move(newVal));
+}
+
+/**
+ * PrimaryPtrRef is a non-owning reference to the pointer. PrimaryPtr::join()
+ * and the PrimaryPtr::cleanup() work do *NOT* wait for outstanding
+ * PrimaryPtrRef objects to be released.
+ */
+template <typename T>
+class PrimaryPtrRef {
+ public:
+  PrimaryPtrRef() = default;
+
+  // Attempts to lock a pointer. Returns null if pointer is not set or if
+  // join() was called or cleanup() work was started (even if the call to join()
+  // hasn't returned yet or the cleanup() work has not completed yet).
+  std::shared_ptr<T> lock() const {
+    if (auto outerPtr = outerPtrWeak_.lock()) {
+      return *outerPtr;
+    }
+    return nullptr;
+  }
+
+ private:
+  template <class>
+  friend class EnablePrimaryFromThis;
+  template <class>
+  friend class PrimaryPtr;
+  /* implicit */ PrimaryPtrRef(std::weak_ptr<std::shared_ptr<T>> outerPtrWeak)
+      : outerPtrWeak_(std::move(outerPtrWeak)) {}
+
+  std::weak_ptr<std::shared_ptr<T>> outerPtrWeak_;
+};
+
+} // namespace folly