react-native-windows 0.85.0-preview.1 → 0.85.0

package/external/folly/folly/CancellationToken-inl.h

@@ -0,0 +1,449 @@
+/*
+ * 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 <algorithm>
+#include <cstdint>
+#include <limits>
+#include <tuple>
+#include <utility>
+
+#include <glog/logging.h>
+
+namespace folly {
+
+namespace detail {
+
+struct FixedMergingCancellationStateTag {};
+
+// Internal cancellation state object.
+class CancellationState {
+ public:
+  FOLLY_NODISCARD static CancellationStateSourcePtr create();
+
+ protected:
+  // Constructed initially with a CancellationSource reference count of 1.
+  CancellationState() noexcept;
+  // Constructed initially with a CancellationToken reference count of 1.
+  explicit CancellationState(FixedMergingCancellationStateTag) noexcept;
+
+  virtual ~CancellationState();
+
+  friend struct CancellationStateTokenDeleter;
+  friend struct CancellationStateSourceDeleter;
+
+  void removeTokenReference() noexcept;
+  void removeSourceReference() noexcept;
+
+ public:
+  FOLLY_NODISCARD CancellationStateTokenPtr addTokenReference() noexcept;
+
+  FOLLY_NODISCARD CancellationStateSourcePtr addSourceReference() noexcept;
+
+  bool tryAddCallback(
+      CancellationCallback* callback,
+      bool incrementRefCountIfSuccessful) noexcept;
+
+  void removeCallback(CancellationCallback* callback) noexcept;
+
+  bool isCancellationRequested() const noexcept;
+  bool canBeCancelled() const noexcept;
+
+  // Request cancellation.
+  // Return 'true' if cancellation had already been requested.
+  // Return 'false' if this was the first thread to request
+  // cancellation.
+  bool requestCancellation() noexcept;
+
+ private:
+  void lock() noexcept;
+  void unlock() noexcept;
+  void unlockAndIncrementTokenCount() noexcept;
+  void unlockAndDecrementTokenCount() noexcept;
+  bool tryLockAndCancelUnlessCancelled() noexcept;
+
+  template <typename Predicate>
+  bool tryLock(Predicate predicate) noexcept;
+
+  static bool canBeCancelled(std::uint64_t state) noexcept;
+  static bool isCancellationRequested(std::uint64_t state) noexcept;
+  static bool isLocked(std::uint64_t state) noexcept;
+
+  static constexpr std::uint64_t kCancellationRequestedFlag = 1;
+  static constexpr std::uint64_t kLockedFlag = 2;
+  static constexpr std::uint64_t kMergingFlag = 4;
+  static constexpr std::uint64_t kTokenReferenceCountIncrement = 8;
+  static constexpr std::uint64_t kSourceReferenceCountIncrement =
+      std::uint64_t(1) << 34u;
+  static constexpr std::uint64_t kTokenReferenceCountMask =
+      (kSourceReferenceCountIncrement - 1u) -
+      (kTokenReferenceCountIncrement - 1u);
+  static constexpr std::uint64_t kSourceReferenceCountMask =
+      std::numeric_limits<std::uint64_t>::max() -
+      (kSourceReferenceCountIncrement - 1u);
+
+  // Bit 0 - Cancellation Requested
+  // Bit 1 - Locked Flag
+  // Bit 2 - MergingCancellationState Flag
+  // Bits 3-33  - Token reference count (max ~2 billion)
+  // Bits 34-63 - Source reference count (max ~1 billion)
+  std::atomic<std::uint64_t> state_;
+  CancellationCallback* head_{nullptr};
+  std::thread::id signallingThreadId_;
+};
+
+template <size_t N>
+class FixedMergingCancellationState : public CancellationState {
+  template <typename... Ts>
+  FixedMergingCancellationState(Ts&&... tokens);
+
+ public:
+  template <typename... Ts>
+  FOLLY_NODISCARD static CancellationStateTokenPtr create(Ts&&... tokens);
+
+ private:
+  std::array<CancellationCallback, N> callbacks_;
+};
+
+template <typename... Data>
+class CancellationStateWithData : public CancellationState {
+  template <typename... Args>
+  CancellationStateWithData(Args&&... data);
+
+ public:
+  template <typename... Args>
+  FOLLY_NODISCARD static std::
+      pair<CancellationStateSourcePtr, std::tuple<Data...>*>
+      create(Args&&... data);
+
+ private:
+  std::tuple<Data...> data_;
+};
+
+inline void CancellationStateTokenDeleter::operator()(
+    CancellationState* state) noexcept {
+  state->removeTokenReference();
+}
+
+inline void CancellationStateSourceDeleter::operator()(
+    CancellationState* state) noexcept {
+  state->removeSourceReference();
+}
+
+} // namespace detail
+
+inline CancellationToken::CancellationToken(
+    const CancellationToken& other) noexcept
+    : state_() {
+  if (other.state_) {
+    state_ = other.state_->addTokenReference();
+  }
+}
+
+inline CancellationToken::CancellationToken(CancellationToken&& other) noexcept
+    : state_(std::move(other.state_)) {}
+
+inline CancellationToken& CancellationToken::operator=(
+    const CancellationToken& other) noexcept {
+  if (state_ != other.state_) {
+    CancellationToken temp{other};
+    swap(temp);
+  }
+  return *this;
+}
+
+inline CancellationToken& CancellationToken::operator=(
+    CancellationToken&& other) noexcept {
+  state_ = std::move(other.state_);
+  return *this;
+}
+
+inline bool CancellationToken::isCancellationRequested() const noexcept {
+  return state_ != nullptr && state_->isCancellationRequested();
+}
+
+inline bool CancellationToken::canBeCancelled() const noexcept {
+  return state_ != nullptr && state_->canBeCancelled();
+}
+
+inline void CancellationToken::swap(CancellationToken& other) noexcept {
+  std::swap(state_, other.state_);
+}
+
+inline CancellationToken::CancellationToken(
+    detail::CancellationStateTokenPtr state) noexcept
+    : state_(std::move(state)) {}
+
+inline bool operator==(
+    const CancellationToken& a, const CancellationToken& b) noexcept {
+  return a.state_ == b.state_;
+}
+
+inline bool operator!=(
+    const CancellationToken& a, const CancellationToken& b) noexcept {
+  return !(a == b);
+}
+
+inline CancellationSource::CancellationSource()
+    : state_(detail::CancellationState::create()) {}
+
+inline CancellationSource::CancellationSource(
+    const CancellationSource& other) noexcept
+    : state_() {
+  if (other.state_) {
+    state_ = other.state_->addSourceReference();
+  }
+}
+
+inline CancellationSource::CancellationSource(
+    CancellationSource&& other) noexcept
+    : state_(std::move(other.state_)) {}
+
+inline CancellationSource& CancellationSource::operator=(
+    const CancellationSource& other) noexcept {
+  if (state_ != other.state_) {
+    CancellationSource temp{other};
+    swap(temp);
+  }
+  return *this;
+}
+
+inline CancellationSource& CancellationSource::operator=(
+    CancellationSource&& other) noexcept {
+  state_ = std::move(other.state_);
+  return *this;
+}
+
+inline CancellationSource CancellationSource::invalid() noexcept {
+  return CancellationSource{detail::CancellationStateSourcePtr{}};
+}
+
+inline bool CancellationSource::isCancellationRequested() const noexcept {
+  return state_ != nullptr && state_->isCancellationRequested();
+}
+
+inline bool CancellationSource::canBeCancelled() const noexcept {
+  return state_ != nullptr;
+}
+
+inline CancellationToken CancellationSource::getToken() const noexcept {
+  if (state_ != nullptr) {
+    return CancellationToken{state_->addTokenReference()};
+  }
+  return CancellationToken{};
+}
+
+inline bool CancellationSource::requestCancellation() const noexcept {
+  if (state_ != nullptr) {
+    return state_->requestCancellation();
+  }
+  return false;
+}
+
+inline void CancellationSource::swap(CancellationSource& other) noexcept {
+  std::swap(state_, other.state_);
+}
+
+inline CancellationSource::CancellationSource(
+    detail::CancellationStateSourcePtr&& state) noexcept
+    : state_(std::move(state)) {}
+
+template <
+    typename Callable,
+    std::enable_if_t<
+        std::is_constructible<CancellationCallback::VoidFunction, Callable>::
+            value,
+        int>>
+inline CancellationCallback::CancellationCallback(
+    CancellationToken&& ct, Callable&& callable)
+    : next_(nullptr),
+      prevNext_(nullptr),
+      state_(nullptr),
+      callback_(static_cast<Callable&&>(callable)),
+      destructorHasRunInsideCallback_(nullptr),
+      callbackCompleted_(false) {
+  if (ct.state_ != nullptr && ct.state_->tryAddCallback(this, false)) {
+    state_ = ct.state_.release();
+  }
+}
+
+template <
+    typename Callable,
+    std::enable_if_t<
+        std::is_constructible<CancellationCallback::VoidFunction, Callable>::
+            value,
+        int>>
+inline CancellationCallback::CancellationCallback(
+    const CancellationToken& ct, Callable&& callable)
+    : next_(nullptr),
+      prevNext_(nullptr),
+      state_(nullptr),
+      callback_(static_cast<Callable&&>(callable)),
+      destructorHasRunInsideCallback_(nullptr),
+      callbackCompleted_(false) {
+  if (ct.state_ != nullptr && ct.state_->tryAddCallback(this, true)) {
+    state_ = ct.state_.get();
+  }
+}
+
+inline CancellationCallback::~CancellationCallback() {
+  if (state_ != nullptr) {
+    state_->removeCallback(this);
+  }
+}
+
+inline void CancellationCallback::invokeCallback() noexcept {
+  // Invoke within a noexcept context so that we std::terminate() if it throws.
+  callback_();
+}
+
+namespace detail {
+
+inline CancellationStateSourcePtr CancellationState::create() {
+  return CancellationStateSourcePtr{new CancellationState()};
+}
+
+inline CancellationState::CancellationState() noexcept
+    : state_(kSourceReferenceCountIncrement) {}
+inline CancellationState::CancellationState(
+    FixedMergingCancellationStateTag) noexcept
+    : state_(kTokenReferenceCountIncrement | kMergingFlag) {}
+
+inline CancellationStateTokenPtr
+CancellationState::addTokenReference() noexcept {
+  state_.fetch_add(kTokenReferenceCountIncrement, std::memory_order_relaxed);
+  return CancellationStateTokenPtr{this};
+}
+
+inline void CancellationState::removeTokenReference() noexcept {
+  const auto oldState = state_.fetch_sub(
+      kTokenReferenceCountIncrement, std::memory_order_acq_rel);
+  DCHECK(
+      (oldState & kTokenReferenceCountMask) >= kTokenReferenceCountIncrement);
+  if (oldState < (2 * kTokenReferenceCountIncrement)) {
+    delete this;
+  }
+}
+
+inline CancellationStateSourcePtr
+CancellationState::addSourceReference() noexcept {
+  state_.fetch_add(kSourceReferenceCountIncrement, std::memory_order_relaxed);
+  return CancellationStateSourcePtr{this};
+}
+
+inline void CancellationState::removeSourceReference() noexcept {
+  const auto oldState = state_.fetch_sub(
+      kSourceReferenceCountIncrement, std::memory_order_acq_rel);
+  DCHECK(
+      (oldState & kSourceReferenceCountMask) >= kSourceReferenceCountIncrement);
+  if (oldState <
+      (kSourceReferenceCountIncrement + kTokenReferenceCountIncrement)) {
+    delete this;
+  }
+}
+
+inline bool CancellationState::isCancellationRequested() const noexcept {
+  return isCancellationRequested(state_.load(std::memory_order_acquire));
+}
+
+inline bool CancellationState::canBeCancelled() const noexcept {
+  return canBeCancelled(state_.load(std::memory_order_acquire));
+}
+
+inline bool CancellationState::canBeCancelled(std::uint64_t state) noexcept {
+  // Can be cancelled if there is at least one CancellationSource ref-count
+  // or if cancellation has been requested.
+  return (state >= kSourceReferenceCountIncrement) ||
+      (state & kMergingFlag) != 0 || isCancellationRequested(state);
+}
+
+inline bool CancellationState::isCancellationRequested(
+    std::uint64_t state) noexcept {
+  return (state & kCancellationRequestedFlag) != 0;
+}
+
+inline bool CancellationState::isLocked(std::uint64_t state) noexcept {
+  return (state & kLockedFlag) != 0;
+}
+
+template <size_t N>
+template <typename... Ts>
+inline CancellationStateTokenPtr FixedMergingCancellationState<N>::create(
+    Ts&&... tokens) {
+  return CancellationStateTokenPtr{
+      new FixedMergingCancellationState<N>(std::forward<Ts>(tokens)...)};
+}
+
+template <typename... Data>
+struct WithDataTag {};
+
+template <size_t N>
+template <typename... Ts>
+inline FixedMergingCancellationState<N>::FixedMergingCancellationState(
+    Ts&&... tokens)
+    : CancellationState(FixedMergingCancellationStateTag{}),
+      callbacks_{
+          {{std::forward<Ts>(tokens), [this] { requestCancellation(); }}...}} {}
+
+template <typename... Data>
+template <typename... Args>
+CancellationStateWithData<Data...>::CancellationStateWithData(Args&&... data)
+    : data_(std::forward<Args>(data)...) {}
+
+template <typename... Data>
+template <typename... Args>
+std::pair<CancellationStateSourcePtr, std::tuple<Data...>*>
+CancellationStateWithData<Data...>::create(Args&&... data) {
+  auto* state =
+      new CancellationStateWithData<Data...>(std::forward<Args>(data)...);
+  return {CancellationStateSourcePtr{state}, &state->data_};
+}
+
+inline bool variadicDisjunction() {
+  return false;
+}
+
+inline bool variadicDisjunction(bool first) {
+  return first;
+}
+
+template <typename... Bools>
+bool variadicDisjunction(bool first, Bools... bools) {
+  return first || variadicDisjunction(bools...);
+}
+} // namespace detail
+
+template <typename... Data, typename... Args>
+std::pair<CancellationSource, std::tuple<Data...>*> CancellationSource::create(
+    detail::WithDataTag<Data...>, Args&&... data) {
+  auto cancellationStateWithData =
+      detail::CancellationStateWithData<Data...>::create(
+          std::forward<Args>(data)...);
+  return {
+      CancellationSource{std::move(cancellationStateWithData.first)},
+      cancellationStateWithData.second};
+}
+
+template <typename... Ts>
+inline CancellationToken CancellationToken::merge(Ts&&... tokens) {
+  bool canBeCancelled = detail::variadicDisjunction(tokens.canBeCancelled()...);
+  return canBeCancelled
+      ? CancellationToken(
+            detail::FixedMergingCancellationState<sizeof...(Ts)>::create(
+                std::forward<Ts>(tokens)...))
+      : CancellationToken();
+}
+
+} // namespace folly

package/external/folly/folly/CancellationToken.cpp

@@ -0,0 +1,250 @@
+/*
+ * 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/CancellationToken.h>
+#include <folly/Optional.h>
+#include <folly/synchronization/detail/Sleeper.h>
+
+#include <glog/logging.h>
+
+#include <algorithm>
+#include <new>
+#include <thread>
+#include <tuple>
+
+namespace folly {
+namespace detail {
+
+CancellationState::~CancellationState() {
+  DCHECK(head_ == nullptr);
+  DCHECK(!isLocked(state_.load(std::memory_order_relaxed)));
+  DCHECK(
+      state_.load(std::memory_order_relaxed) < kTokenReferenceCountIncrement);
+}
+
+bool CancellationState::tryAddCallback(
+    CancellationCallback* callback,
+    bool incrementRefCountIfSuccessful) noexcept {
+  // Try to acquire the lock, but abandon trying to acquire the lock if
+  // cancellation has already been requested (we can just immediately invoke
+  // the callback) or if cancellation can never be requested (we can just
+  // skip registration).
+  if (!tryLock([callback](std::uint64_t oldState) noexcept {
+        if (isCancellationRequested(oldState)) {
+          callback->invokeCallback();
+          return false;
+        }
+        return canBeCancelled(oldState);
+      })) {
+    return false;
+  }
+
+  // We've acquired the lock and cancellation has not yet been requested.
+  // Push this callback onto the head of the list.
+  if (head_ != nullptr) {
+    head_->prevNext_ = &callback->next_;
+  }
+  callback->next_ = head_;
+  callback->prevNext_ = &head_;
+  head_ = callback;
+
+  if (incrementRefCountIfSuccessful) {
+    // Combine multiple atomic operations into a single atomic operation.
+    unlockAndIncrementTokenCount();
+  } else {
+    unlock();
+  }
+
+  // Successfully added the callback.
+  return true;
+}
+
+void CancellationState::removeCallback(
+    CancellationCallback* callback) noexcept {
+  DCHECK(callback != nullptr);
+
+  lock();
+
+  if (callback->prevNext_ != nullptr) {
+    // Still registered in the list => not yet executed.
+    // Just remove it from the list.
+    *callback->prevNext_ = callback->next_;
+    if (callback->next_ != nullptr) {
+      callback->next_->prevNext_ = callback->prevNext_;
+    }
+
+    unlockAndDecrementTokenCount();
+    return;
+  }
+
+  unlock();
+
+  // Callback has either already executed or is executing concurrently on
+  // another thread.
+
+  if (signallingThreadId_ == std::this_thread::get_id()) {
+    // Callback executed on this thread or is still currently executing
+    // and is deregistering itself from within the callback.
+    if (callback->destructorHasRunInsideCallback_ != nullptr) {
+      // Currently inside the callback, let the requestCancellation() method
+      // know the object is about to be destructed and that it should
+      // not try to access the object when the callback returns.
+      *callback->destructorHasRunInsideCallback_ = true;
+    }
+  } else {
+    // Callback is currently executing on another thread, block until it
+    // finishes executing.
+    folly::detail::Sleeper sleeper;
+    while (!callback->callbackCompleted_.load(std::memory_order_acquire)) {
+      sleeper.wait();
+    }
+  }
+
+  removeTokenReference();
+}
+
+bool CancellationState::requestCancellation() noexcept {
+  if (!tryLockAndCancelUnlessCancelled()) {
+    // Was already marked as cancelled
+    return true;
+  }
+
+  // This thread marked as cancelled and acquired the lock
+
+  signallingThreadId_ = std::this_thread::get_id();
+
+  while (head_ != nullptr) {
+    // Dequeue the first item on the queue.
+    CancellationCallback* callback = head_;
+    head_ = callback->next_;
+    const bool anyMore = head_ != nullptr;
+    if (anyMore) {
+      head_->prevNext_ = &head_;
+    }
+    // Mark this item as removed from the list.
+    callback->prevNext_ = nullptr;
+
+    // Don't hold the lock while executing the callback
+    // as we don't want to block other threads from
+    // deregistering callbacks.
+    unlock();
+
+    // TRICKY: Need to store a flag on the stack here that the callback
+    // can use to signal that the destructor was executed inline
+    // during the call.
+    // If the destructor was executed inline then it's not safe to
+    // dereference 'callback' after 'invokeCallback()' returns.
+    // If the destructor runs on some other thread then the other
+    // thread will block waiting for this thread to signal that the
+    // callback has finished executing.
+    bool destructorHasRunInsideCallback = false;
+    callback->destructorHasRunInsideCallback_ = &destructorHasRunInsideCallback;
+
+    callback->invokeCallback();
+
+    if (!destructorHasRunInsideCallback) {
+      callback->destructorHasRunInsideCallback_ = nullptr;
+      callback->callbackCompleted_.store(true, std::memory_order_release);
+    }
+
+    if (!anyMore) {
+      // This was the last item in the queue when we dequeued it.
+      // No more items should be added to the queue after we have
+      // marked the state as cancelled, only removed from the queue.
+      // Avoid acquiring/releasing the lock in this case.
+      return false;
+    }
+
+    lock();
+  }
+
+  unlock();
+
+  return false;
+}
+
+void CancellationState::lock() noexcept {
+  folly::detail::Sleeper sleeper;
+  std::uint64_t oldState = state_.load(std::memory_order_relaxed);
+  do {
+    while (isLocked(oldState)) {
+      sleeper.wait();
+      oldState = state_.load(std::memory_order_relaxed);
+    }
+  } while (!state_.compare_exchange_weak(
+      oldState,
+      oldState | kLockedFlag,
+      std::memory_order_acquire,
+      std::memory_order_relaxed));
+}
+
+void CancellationState::unlock() noexcept {
+  state_.fetch_sub(kLockedFlag, std::memory_order_release);
+}
+
+void CancellationState::unlockAndIncrementTokenCount() noexcept {
+  state_.fetch_sub(
+      kLockedFlag - kTokenReferenceCountIncrement, std::memory_order_release);
+}
+
+void CancellationState::unlockAndDecrementTokenCount() noexcept {
+  auto oldState = state_.fetch_sub(
+      kLockedFlag + kTokenReferenceCountIncrement, std::memory_order_acq_rel);
+  if (oldState < (kLockedFlag + 2 * kTokenReferenceCountIncrement)) {
+    delete this;
+  }
+}
+
+bool CancellationState::tryLockAndCancelUnlessCancelled() noexcept {
+  folly::detail::Sleeper sleeper;
+  std::uint64_t oldState = state_.load(std::memory_order_acquire);
+  while (true) {
+    if (isCancellationRequested(oldState)) {
+      return false;
+    } else if (isLocked(oldState)) {
+      sleeper.wait();
+      oldState = state_.load(std::memory_order_acquire);
+    } else if (state_.compare_exchange_weak(
+                   oldState,
+                   oldState | kLockedFlag | kCancellationRequestedFlag,
+                   std::memory_order_acq_rel,
+                   std::memory_order_acquire)) {
+      return true;
+    }
+  }
+}
+
+template <typename Predicate>
+bool CancellationState::tryLock(Predicate predicate) noexcept {
+  folly::detail::Sleeper sleeper;
+  std::uint64_t oldState = state_.load(std::memory_order_acquire);
+  while (true) {
+    if (!predicate(oldState)) {
+      return false;
+    } else if (isLocked(oldState)) {
+      sleeper.wait();
+      oldState = state_.load(std::memory_order_acquire);
+    } else if (state_.compare_exchange_weak(
+                   oldState,
+                   oldState | kLockedFlag,
+                   std::memory_order_acquire)) {
+      return true;
+    }
+  }
+}
+
+} // namespace detail
+} // namespace folly