react-native-windows 0.84.0 → 0.84.1

package/external/folly/folly/concurrency/PriorityUnboundedQueueSet.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 <atomic>
+#include <vector>
+
+#include <folly/Memory.h>
+#include <folly/concurrency/UnboundedQueue.h>
+#include <folly/lang/Align.h>
+
+namespace folly {
+
+/// PriorityUnboundedQueueSet
+///
+/// A set of per-priority queues, and an interface for accessing them.
+///
+/// Functions:
+///   Consumer operations:
+///     bool try_dequeue(T&);
+///     Optional<T> try_dequeue();
+///       Tries to extract an element from the front of the least-priority
+///       backing queue which has an element, if any.
+///     T const* try_peek();
+///       Returns a pointer to the element at the front of the least-priority
+///       backing queue which has an element, if any. Only allowed when
+///       SingleConsumer is true.
+///     Note:
+///       Queues at lower priority are tried before queues at higher priority.
+///
+///   Secondary functions:
+///     queue& at_priority(size_t);
+///     queue const& at_priority(size_t) const;
+///       Returns a reference to the owned queue at the given priority.
+///     size_t size() const;
+///       Returns an estimate of the total size of the owned queues.
+///     bool empty() const;
+///       Returns true only if all of the owned queues were empty during the
+///       call.
+///     Note: size() and empty() are guaranteed to be accurate only if the
+///       owned queues are not changed concurrently.
+template <
+    typename T,
+    bool SingleProducer,
+    bool SingleConsumer,
+    bool MayBlock,
+    size_t LgSegmentSize = 8,
+    size_t LgAlign = constexpr_log2(hardware_destructive_interference_size),
+    template <typename> class Atom = std::atomic>
+class PriorityUnboundedQueueSet {
+ public:
+  using queue = UnboundedQueue<
+      T,
+      SingleProducer,
+      SingleConsumer,
+      MayBlock,
+      LgSegmentSize,
+      LgAlign,
+      Atom>;
+
+  explicit PriorityUnboundedQueueSet(size_t priorities) : queues_(priorities) {}
+
+  PriorityUnboundedQueueSet(PriorityUnboundedQueueSet const&) = delete;
+  PriorityUnboundedQueueSet(PriorityUnboundedQueueSet&&) = delete;
+  PriorityUnboundedQueueSet& operator=(PriorityUnboundedQueueSet const&) =
+      delete;
+  PriorityUnboundedQueueSet& operator=(PriorityUnboundedQueueSet&&) = delete;
+
+  queue& at_priority(size_t priority) { return queues_.at(priority); }
+
+  queue const& at_priority(size_t priority) const {
+    return queues_.at(priority);
+  }
+
+  bool try_dequeue(T& item) noexcept {
+    for (auto& q : queues_) {
+      if (q.try_dequeue(item)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  Optional<T> try_dequeue() noexcept {
+    for (auto& q : queues_) {
+      if (auto item = q.try_dequeue()) {
+        return item;
+      }
+    }
+    return none;
+  }
+
+  T const* try_peek() noexcept {
+    DCHECK(SingleConsumer);
+    for (auto& q : queues_) {
+      if (auto ptr = q.try_peek()) {
+        return ptr;
+      }
+    }
+    return nullptr;
+  }
+
+  size_t size() const noexcept {
+    size_t size = 0;
+    for (auto& q : queues_) {
+      size += q.size();
+    }
+    return size;
+  }
+
+  bool empty() const noexcept {
+    for (auto& q : queues_) {
+      if (!q.empty()) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  size_t priorities() const noexcept { return queues_.size(); }
+
+ private:
+  //  queue_alloc custom allocator is necessary until C++17
+  //    http://open-std.org/JTC1/SC22/WG21/docs/papers/2012/n3396.htm
+  //    https://gcc.gnu.org/bugzilla/show_bug.cgi?id=65122
+  //    https://bugs.llvm.org/show_bug.cgi?id=22634
+  using queue_alloc = AlignedSysAllocator<queue, FixedAlign<alignof(queue)>>;
+  std::vector<queue, queue_alloc> queues_;
+}; // PriorityUnboundedQueueSet
+
+/* Aliases */
+
+template <
+    typename T,
+    bool MayBlock,
+    size_t LgSegmentSize = 8,
+    size_t LgAlign = constexpr_log2(hardware_destructive_interference_size),
+    template <typename> class Atom = std::atomic>
+using PriorityUSPSCQueueSet = PriorityUnboundedQueueSet<
+    T,
+    true,
+    true,
+    MayBlock,
+    LgSegmentSize,
+    LgAlign,
+    Atom>;
+
+template <
+    typename T,
+    bool MayBlock,
+    size_t LgSegmentSize = 8,
+    size_t LgAlign = constexpr_log2(hardware_destructive_interference_size),
+    template <typename> class Atom = std::atomic>
+using PriorityUMPSCQueueSet = PriorityUnboundedQueueSet<
+    T,
+    false,
+    true,
+    MayBlock,
+    LgSegmentSize,
+    LgAlign,
+    Atom>;
+
+template <
+    typename T,
+    bool MayBlock,
+    size_t LgSegmentSize = 8,
+    size_t LgAlign = constexpr_log2(hardware_destructive_interference_size),
+    template <typename> class Atom = std::atomic>
+using PriorityUSPMCQueueSet = PriorityUnboundedQueueSet<
+    T,
+    true,
+    false,
+    MayBlock,
+    LgSegmentSize,
+    LgAlign,
+    Atom>;
+
+template <
+    typename T,
+    bool MayBlock,
+    size_t LgSegmentSize = 8,
+    size_t LgAlign = constexpr_log2(hardware_destructive_interference_size),
+    template <typename> class Atom = std::atomic>
+using PriorityUMPMCQueueSet = PriorityUnboundedQueueSet<
+    T,
+    false,
+    false,
+    MayBlock,
+    LgSegmentSize,
+    LgAlign,
+    Atom>;
+
+} // namespace folly

package/external/folly/folly/concurrency/ProcessLocalUniqueId.cpp

@@ -0,0 +1,46 @@
+/*
+ * 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/Likely.h>
+#include <folly/concurrency/ProcessLocalUniqueId.h>
+#include <folly/synchronization/RelaxedAtomic.h>
+
+#include <atomic>
+
+namespace folly {
+
+uint64_t processLocalUniqueId() {
+  FOLLY_CONSTINIT static relaxed_atomic<uint64_t> nextEpoch{0};
+  // Id format is <epoch: 48 bits> <counter: 16 bits>.
+  // Ephemeral threads, if any, can waste a whole epoch, so we keep epochs
+  // relatively small, but large enough to amortize the atomic epoch increment.
+  constexpr int kCounterBits = 16;
+  constexpr uint64_t kCounterMask = (uint64_t(1) << kCounterBits) - 1;
+  thread_local uint64_t next{0};
+
+  // If first call in thread, or counter wrapped around, start new epoch.
+  if (FOLLY_UNLIKELY((next & kCounterMask) == 0)) {
+    next = nextEpoch++ << kCounterBits;
+    // Skip 0 as per contract.
+    if (FOLLY_UNLIKELY(next == 0)) {
+      ++next;
+    }
+  }
+
+  return next++;
+}
+
+} // namespace folly

package/external/folly/folly/concurrency/ProcessLocalUniqueId.h

@@ -0,0 +1,38 @@
+/*
+ * 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 <cstdint>
+
+namespace folly {
+
+/**
+ * Generates a 64-bit id that is unique within the process. The returned ids
+ * should not be persisted or passed to other processes, and there are no
+ * ordering guarantees.
+ *
+ * It is guaranteed that 0 is never returned, hence 0 can be used as a sentinel
+ * value, similarly to nullptr.
+ *
+ * The function is thread-safe.
+ *
+ * The uniqueness guarantee can be broken if enough ids are generated, but even
+ * in the most pessimistic scenario it would take a few hundred years.
+ */
+uint64_t processLocalUniqueId();
+
+} // namespace folly

package/external/folly/folly/concurrency/SingletonRelaxedCounter.h

@@ -0,0 +1,325 @@
+/*
+ * 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 <array>
+#include <atomic>
+#include <type_traits>
+#include <unordered_set>
+
+#include <folly/Likely.h>
+#include <folly/Portability.h>
+#include <folly/Synchronized.h>
+#include <folly/Utility.h>
+#include <folly/detail/StaticSingletonManager.h>
+#include <folly/detail/thread_local_globals.h>
+#include <folly/lang/SafeAssert.h>
+#include <folly/synchronization/AtomicRef.h>
+
+namespace folly {
+
+namespace detail {
+
+//  SingletonRelaxedCounterBase
+//
+//  Extracts tag-independent functionality from SingletonRelaxedCounter below
+//  to avoid the monomorphization the compiler would otherwise perform.
+//
+//  Tricks:
+//  * Use constexpr vtables as the polymorphization mechanism.
+//  * Use double-noinline outer-only-noexcept definitions to shrink code size in
+//    inline or monomorphized slow paths.
+template <typename Int>
+class SingletonRelaxedCounterBase {
+ protected:
+  using Signed = std::make_signed_t<Int>;
+  using Counter = Signed; // should be atomic but clang generates worse code
+
+  struct CounterAndCache {
+    Counter counter; // valid during LocalLifetime object lifetime
+    Counter* cache; // points to counter when counter is valid
+  };
+  static_assert(std::is_trivial_v<CounterAndCache>);
+
+  struct CounterRefAndLocal {
+    Counter* counter; // refers either to local counter or to global counter
+    bool local; // if true, definitely local; if false, could be global
+  };
+
+  struct LocalLifetime;
+
+  //  Global
+  //
+  //  Tracks all of the per-thread/per-dso counters and lifetimes and maintains
+  //  a global fallback counter.
+  struct Global {
+    struct Tracking {
+      std::unordered_map<LocalLifetime*, CounterAndCache*> lifetimes;
+    };
+
+    Counter fallback; // used instead of local during thread destruction
+    folly::Synchronized<Tracking> tracking;
+  };
+
+  using GetGlobal = Global&();
+  using GetLocal = CounterAndCache&();
+  using GetLifetime = LocalLifetime&();
+
+  struct Arg {
+    GetGlobal& global;
+    GetLocal& local;
+    GetLifetime& lifetime;
+  };
+
+  //  LocalLifetime
+  //
+  //  Manages local().cache, global().tracking, and moving outstanding counts
+  //  from local().counter to global().counter during thread destruction and dso
+  //  unload.
+  //
+  //  The index map is within Global to reduce per-thread overhead for threads
+  //  which do not participate in counter mutations, rather than being a member
+  //  field of LocalLifetime. This comes at the cost of the slow path always
+  //  acquiring a unique lock on the global mutex.
+  struct LocalLifetime {
+    FOLLY_NOINLINE void destroy(GetGlobal& get_global) noexcept {
+      destroy_(get_global);
+    }
+    FOLLY_NOINLINE void destroy_(GetGlobal& get_global) {
+      auto& global = get_global();
+      auto const tracking = global.tracking.wlock();
+      auto& entry = tracking->lifetimes[this];
+      FOLLY_SAFE_CHECK(entry);
+      auto entry_counter = atomic_ref(entry->counter);
+      auto const current = entry_counter.load(std::memory_order_relaxed);
+      atomic_ref(global.fallback).fetch_add(current, std::memory_order_relaxed);
+      entry_counter.store(Signed(0), std::memory_order_relaxed);
+      entry->cache = nullptr;
+      tracking->lifetimes.erase(this);
+    }
+
+    FOLLY_NOINLINE void track(Global& global, CounterAndCache& state) noexcept {
+      track_(global, state);
+    }
+    FOLLY_NOINLINE void track_(Global& global, CounterAndCache& state) {
+      state.cache = &state.counter;
+      auto const tracking = global.tracking.wlock();
+      auto& entry = tracking->lifetimes[this];
+      FOLLY_SAFE_CHECK(!entry || &state == entry);
+      entry = &state;
+    }
+  };
+
+  FOLLY_NOINLINE static Int aggregate(GetGlobal& get_global) noexcept {
+    return aggregate_(get_global);
+  }
+  FOLLY_NOINLINE static Int aggregate_(GetGlobal& get_global) {
+    auto& global = get_global();
+    auto count = atomic_ref(global.fallback).load(std::memory_order_relaxed);
+    auto const tracking = global.tracking.rlock();
+    for (auto const& [_, entry] : tracking->lifetimes) {
+      FOLLY_SAFE_CHECK(entry);
+      count += atomic_ref(entry->counter).load(std::memory_order_relaxed);
+    }
+    return std::is_unsigned<Int>::value
+        ? to_unsigned(std::max(Signed(0), count))
+        : count;
+  }
+
+  FOLLY_ERASE static void mutate(Signed v, CounterRefAndLocal cl) {
+    auto c = atomic_ref(*cl.counter);
+    if (cl.local) {
+      //  splitting load/store on the local counter is faster than fetch-and-add
+      c.store(c.load(std::memory_order_relaxed) + v, std::memory_order_relaxed);
+    } else {
+      //  but is not allowed on the global counter because mutations may be lost
+      c.fetch_add(v, std::memory_order_relaxed);
+    }
+  }
+
+  FOLLY_NOINLINE static void mutate_slow(Signed v, Arg const& arg) noexcept {
+    mutate(v, counter(arg));
+  }
+
+  FOLLY_NOINLINE static Counter& counter_slow(Arg const& arg) noexcept {
+    auto& global = arg.global();
+    if (thread_is_dying()) {
+      return global.fallback;
+    }
+    auto& state = arg.local();
+    arg.lifetime().track(global, state); // idempotent
+    auto const cache = state.cache;
+    return FOLLY_LIKELY(!!cache) ? *cache : global.fallback;
+  }
+
+  FOLLY_ERASE static CounterRefAndLocal counter(Arg const& arg) {
+    auto& state = arg.local();
+    auto const cache = state.cache; // a copy! null before/after LocalLifetime
+    auto const counter = FOLLY_LIKELY(!!cache) ? cache : &counter_slow(arg);
+    //  cache is a stale nullptr after the first call to counter_slow; this is
+    //  intentional for the side-effect of shrinking the inline fast path
+    return CounterRefAndLocal{counter, !!cache};
+  }
+};
+
+} // namespace detail
+
+//  SingletonRelaxedCounter
+//
+//  A singleton-per-tag relaxed counter. Optimized for increment/decrement
+//  runtime performance under contention and inlined fast path code size.
+//
+//  The cost of computing the value of the counter is linear in the number of
+//  threads which perform increments/decrements, and computing the value of the
+//  counter is exclusive with thread exit and dlclose. The result of this
+//  computation is not a point-in-time snapshot of increments and decrements
+//  summed, but is an approximation which may exclude any subset of increments
+//  and decrements that do not happen before the start of the computation.
+//
+//  Templated over the integral types. When templated over an unsigned integral
+//  type, it is assumed that decrements do not exceed increments, and if within
+//  computation of the value of the counter more decrements are observed to
+//  exceed increments then the excess decrements are ignored. This avoids the
+//  scenario of incrementing and decrementing once each in different threads,
+//  and concurrently observing a computed value of the counter of 2^64 - 1.
+//
+//  Templated over the tag types. Each unique pair of integral type and tag type
+//  is a different counter.
+//
+//  Implementation:
+//  Uses a thread-local counter when possible to avoid contention, and a global
+//  counter as a fallback. The total count at any given time is computed by
+//  summing over the global counter plus all of the thread-local counters; since
+//  the total sum is not a snapshot of the value at any given point in time, it
+//  is a relaxed sum; when the system quiesces (i.e., when no concurrent
+//  increments or decrements are happening and no threads are going through
+//  thread exit phase), the sum is exact.
+//
+//  Most of the implementation is in SingletonRelaxedCounterBase to avoid excess
+//  monomorphization.
+template <typename Int, typename Tag>
+class SingletonRelaxedCounter
+    : private detail::SingletonRelaxedCounterBase<Int> {
+ public:
+  static void add(Int value) { mutate(+to_signed(value)); }
+  static void sub(Int value) { mutate(-to_signed(value)); }
+  static Int count() { return aggregate(global); }
+
+ private:
+  using Base = detail::SingletonRelaxedCounterBase<Int>;
+  using Base::aggregate;
+  using Base::mutate;
+  using Base::mutate_slow;
+  using typename Base::Arg;
+  using typename Base::CounterAndCache;
+  using typename Base::GetGlobal;
+  using typename Base::Global;
+  using typename Base::LocalLifetime;
+  using typename Base::Signed;
+
+  struct MonoLocalLifetime : LocalLifetime {
+    ~MonoLocalLifetime() noexcept(false) { LocalLifetime::destroy(global); }
+  };
+
+  //  It is an invariant that in a single call to mutate which calls mutate_slow
+  //  the thread_local local and the thread_local lifetime that are used are in
+  //  the same DSO as each other.
+  //
+  //  The following functions are all [[gnu::visibility("hidden")]] in order to
+  //  ensure this invariant.
+
+  FOLLY_ERASE_NOINLINE static void mutate_slow(Signed v) noexcept {
+    static constexpr Arg arg{global, local, lifetime};
+    mutate_slow(v, arg);
+  }
+
+  FOLLY_ERASE static void mutate(Signed v, void (&slow)(Signed) = mutate_slow) {
+    auto const cache = local().cache; // a copy! null before/after LocalLifetime
+    //  fun-ref to trick compiler into emitting a tail call
+    FOLLY_LIKELY(!!cache) ? mutate(v, {cache, true}) : slow(v);
+  }
+
+  static constexpr GetGlobal& global = folly::detail::createGlobal<Global, Tag>;
+
+  FOLLY_ERASE static CounterAndCache& local() {
+    //  this is a member function local instead of a class member because of
+    //  https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66944
+    static thread_local CounterAndCache instance;
+    return instance;
+  }
+
+  FOLLY_ERASE static LocalLifetime& lifetime() {
+    static thread_local MonoLocalLifetime lifetime;
+    return lifetime;
+  }
+};
+
+template <typename Counted>
+class SingletonRelaxedCountableAccess;
+
+//  SingletonRelaxedCountable
+//
+//  A CRTP base class for making the instances of a type within a process be
+//  globally counted. The running counter is a relaxed counter.
+//
+//  To avoid adding any new names from the base class to the counted type, the
+//  count is exposed via a separate type SingletonRelaxedCountableAccess.
+//
+//  This type is a convenience interface around SingletonRelaxedCounter.
+template <typename Counted>
+class SingletonRelaxedCountable {
+ public:
+  SingletonRelaxedCountable() noexcept {
+    static_assert(
+        std::is_base_of<SingletonRelaxedCountable, Counted>::value, "non-crtp");
+    Counter::add(1);
+  }
+  ~SingletonRelaxedCountable() noexcept {
+    static_assert(
+        std::is_base_of<SingletonRelaxedCountable, Counted>::value, "non-crtp");
+    Counter::sub(1);
+  }
+
+  SingletonRelaxedCountable(const SingletonRelaxedCountable&) noexcept
+      : SingletonRelaxedCountable() {}
+  SingletonRelaxedCountable(SingletonRelaxedCountable&&) noexcept
+      : SingletonRelaxedCountable() {}
+
+  SingletonRelaxedCountable& operator=(const SingletonRelaxedCountable&) =
+      default;
+  SingletonRelaxedCountable& operator=(SingletonRelaxedCountable&&) = default;
+
+ private:
+  friend class SingletonRelaxedCountableAccess<Counted>;
+
+  struct Tag;
+  using Counter = SingletonRelaxedCounter<size_t, Tag>;
+};
+
+//  SingletonRelaxedCountableAccess
+//
+//  Provides access to the running count of instances of a type using the CRTP
+//  base class SingletonRelaxedCountable.
+template <typename Counted>
+class SingletonRelaxedCountableAccess {
+ public:
+  static size_t count() {
+    return SingletonRelaxedCountable<Counted>::Counter::count();
+  }
+};
+
+} // namespace folly