@nxtedition/rocksdb 5.2.21 → 5.2.28

package/deps/rocksdb/rocksdb/third-party/folly/folly/synchronization/ParkingLot.h

@@ -1,318 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#pragma once
-
-#include <atomic>
-#include <condition_variable>
-#include <mutex>
-
-#include <folly/hash/Hash.h>
-#include <folly/Indestructible.h>
-#include <folly/Unit.h>
-
-namespace folly {
-
-namespace parking_lot_detail {
-
-struct WaitNodeBase {
-  const uint64_t key_;
-  const uint64_t lotid_;
-  WaitNodeBase* next_{nullptr};
-  WaitNodeBase* prev_{nullptr};
-
-  // tricky: hold both bucket and node mutex to write, either to read
-  bool signaled_;
-  std::mutex mutex_;
-  std::condition_variable cond_;
-
-  WaitNodeBase(uint64_t key, uint64_t lotid)
-      : key_(key), lotid_(lotid), signaled_(false) {}
-
-  template <typename Clock, typename Duration>
-  std::cv_status wait(std::chrono::time_point<Clock, Duration> deadline) {
-    std::cv_status status = std::cv_status::no_timeout;
-    std::unique_lock<std::mutex> nodeLock(mutex_);
-    while (!signaled_ && status != std::cv_status::timeout) {
-      if (deadline != std::chrono::time_point<Clock, Duration>::max()) {
-        status = cond_.wait_until(nodeLock, deadline);
-      } else {
-        cond_.wait(nodeLock);
-      }
-    }
-    return status;
-  }
-
-  void wake() {
-    std::lock_guard<std::mutex> nodeLock(mutex_);
-    signaled_ = true;
-    cond_.notify_one();
-  }
-
-  bool signaled() {
-    return signaled_;
-  }
-};
-
-extern std::atomic<uint64_t> idallocator;
-
-// Our emulated futex uses 4096 lists of wait nodes.  There are two levels
-// of locking: a per-list mutex that controls access to the list and a
-// per-node mutex, condvar, and bool that are used for the actual wakeups.
-// The per-node mutex allows us to do precise wakeups without thundering
-// herds.
-struct Bucket {
-  std::mutex mutex_;
-  WaitNodeBase* head_;
-  WaitNodeBase* tail_;
-  std::atomic<uint64_t> count_;
-
-  static Bucket& bucketFor(uint64_t key);
-
-  void push_back(WaitNodeBase* node) {
-    if (tail_) {
-      assert(head_);
-      node->prev_ = tail_;
-      tail_->next_ = node;
-      tail_ = node;
-    } else {
-      tail_ = node;
-      head_ = node;
-    }
-  }
-
-  void erase(WaitNodeBase* node) {
-    assert(count_.load(std::memory_order_relaxed) >= 1);
-    if (head_ == node && tail_ == node) {
-      assert(node->prev_ == nullptr);
-      assert(node->next_ == nullptr);
-      head_ = nullptr;
-      tail_ = nullptr;
-    } else if (head_ == node) {
-      assert(node->prev_ == nullptr);
-      assert(node->next_);
-      head_ = node->next_;
-      head_->prev_ = nullptr;
-    } else if (tail_ == node) {
-      assert(node->next_ == nullptr);
-      assert(node->prev_);
-      tail_ = node->prev_;
-      tail_->next_ = nullptr;
-    } else {
-      assert(node->next_);
-      assert(node->prev_);
-      node->next_->prev_ = node->prev_;
-      node->prev_->next_ = node->next_;
-    }
-    count_.fetch_sub(1, std::memory_order_relaxed);
-  }
-};
-
-} // namespace parking_lot_detail
-
-enum class UnparkControl {
-  RetainContinue,
-  RemoveContinue,
-  RetainBreak,
-  RemoveBreak,
-};
-
-enum class ParkResult {
-  Skip,
-  Unpark,
-  Timeout,
-};
-
-/*
- * ParkingLot provides an interface that is similar to Linux's futex
- * system call, but with additional functionality.  It is implemented
- * in a portable way on top of std::mutex and std::condition_variable.
- *
- * Additional reading:
- * https://webkit.org/blog/6161/locking-in-webkit/
- * https://github.com/WebKit/webkit/blob/master/Source/WTF/wtf/ParkingLot.h
- * https://locklessinc.com/articles/futex_cheat_sheet/
- *
- * The main difference from futex is that park/unpark take lambdas,
- * such that nearly anything can be done while holding the bucket
- * lock.  Unpark() lambda can also be used to wake up any number of
- * waiters.
- *
- * ParkingLot is templated on the data type, however, all ParkingLot
- * implementations are backed by a single static array of buckets to
- * avoid large memory overhead.  Lambdas will only ever be called on
- * the specific ParkingLot's nodes.
- */
-template <typename Data = Unit>
-class ParkingLot {
-  const uint64_t lotid_;
-  ParkingLot(const ParkingLot&) = delete;
-
-  struct WaitNode : public parking_lot_detail::WaitNodeBase {
-    const Data data_;
-
-    template <typename D>
-    WaitNode(uint64_t key, uint64_t lotid, D&& data)
-        : WaitNodeBase(key, lotid), data_(std::forward<D>(data)) {}
-  };
-
- public:
-  ParkingLot() : lotid_(parking_lot_detail::idallocator++) {}
-
-  /* Park API
-   *
-   * Key is almost always the address of a variable.
-   *
-   * ToPark runs while holding the bucket lock: usually this
-   * is a check to see if we can sleep, by checking waiter bits.
-   *
-   * PreWait is usually used to implement condition variable like
-   * things, such that you can unlock the condition variable's lock at
-   * the appropriate time.
-   */
-  template <typename Key, typename D, typename ToPark, typename PreWait>
-  ParkResult park(const Key key, D&& data, ToPark&& toPark, PreWait&& preWait) {
-    return park_until(
-        key,
-        std::forward<D>(data),
-        std::forward<ToPark>(toPark),
-        std::forward<PreWait>(preWait),
-        std::chrono::steady_clock::time_point::max());
-  }
-
-  template <
-      typename Key,
-      typename D,
-      typename ToPark,
-      typename PreWait,
-      typename Clock,
-      typename Duration>
-  ParkResult park_until(
-      const Key key,
-      D&& data,
-      ToPark&& toPark,
-      PreWait&& preWait,
-      std::chrono::time_point<Clock, Duration> deadline);
-
-  template <
-      typename Key,
-      typename D,
-      typename ToPark,
-      typename PreWait,
-      typename Rep,
-      typename Period>
-  ParkResult park_for(
-      const Key key,
-      D&& data,
-      ToPark&& toPark,
-      PreWait&& preWait,
-      std::chrono::duration<Rep, Period>& timeout) {
-    return park_until(
-        key,
-        std::forward<D>(data),
-        std::forward<ToPark>(toPark),
-        std::forward<PreWait>(preWait),
-        timeout + std::chrono::steady_clock::now());
-  }
-
-  /*
-   * Unpark API
-   *
-   * Key is the same uniqueaddress used in park(), and is used as a
-   * hash key for lookup of waiters.
-   *
-   * Unparker is a function that is given the Data parameter, and
-   * returns an UnparkControl.  The Remove* results will remove and
-   * wake the waiter, the Ignore/Stop results will not, while stopping
-   * or continuing iteration of the waiter list.
-   */
-  template <typename Key, typename Unparker>
-  void unpark(const Key key, Unparker&& func);
-};
-
-template <typename Data>
-template <
-    typename Key,
-    typename D,
-    typename ToPark,
-    typename PreWait,
-    typename Clock,
-    typename Duration>
-ParkResult ParkingLot<Data>::park_until(
-    const Key bits,
-    D&& data,
-    ToPark&& toPark,
-    PreWait&& preWait,
-    std::chrono::time_point<Clock, Duration> deadline) {
-  auto key = hash::twang_mix64(uint64_t(bits));
-  auto& bucket = parking_lot_detail::Bucket::bucketFor(key);
-  WaitNode node(key, lotid_, std::forward<D>(data));
-
-  {
-    // A: Must be seq_cst.  Matches B.
-    bucket.count_.fetch_add(1, std::memory_order_seq_cst);
-
-    std::unique_lock<std::mutex> bucketLock(bucket.mutex_);
-
-    if (!std::forward<ToPark>(toPark)()) {
-      bucketLock.unlock();
-      bucket.count_.fetch_sub(1, std::memory_order_relaxed);
-      return ParkResult::Skip;
-    }
-
-    bucket.push_back(&node);
-  } // bucketLock scope
-
-  std::forward<PreWait>(preWait)();
-
-  auto status = node.wait(deadline);
-
-  if (status == std::cv_status::timeout) {
-    // it's not really a timeout until we unlink the unsignaled node
-    std::lock_guard<std::mutex> bucketLock(bucket.mutex_);
-    if (!node.signaled()) {
-      bucket.erase(&node);
-      return ParkResult::Timeout;
-    }
-  }
-
-  return ParkResult::Unpark;
-}
-
-template <typename Data>
-template <typename Key, typename Func>
-void ParkingLot<Data>::unpark(const Key bits, Func&& func) {
-  auto key = hash::twang_mix64(uint64_t(bits));
-  auto& bucket = parking_lot_detail::Bucket::bucketFor(key);
-  // B: Must be seq_cst.  Matches A.  If true, A *must* see in seq_cst
-  // order any atomic updates in toPark() (and matching updates that
-  // happen before unpark is called)
-  if (bucket.count_.load(std::memory_order_seq_cst) == 0) {
-    return;
-  }
-
-  std::lock_guard<std::mutex> bucketLock(bucket.mutex_);
-
-  for (auto iter = bucket.head_; iter != nullptr;) {
-    auto node = static_cast<WaitNode*>(iter);
-    iter = iter->next_;
-    if (node->key_ == key && node->lotid_ == lotid_) {
-      auto result = std::forward<Func>(func)(node->data_);
-      if (result == UnparkControl::RemoveBreak ||
-          result == UnparkControl::RemoveContinue) {
-        // we unlink, but waiter destroys the node
-        bucket.erase(node);
-
-        node->wake();
-      }
-      if (result == UnparkControl::RemoveBreak ||
-          result == UnparkControl::RetainBreak) {
-        return;
-      }
-    }
-  }
-}
-
-} // namespace folly

package/deps/rocksdb/rocksdb/third-party/folly/folly/synchronization/WaitOptions.h

@@ -1,57 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#pragma once
-
-#include <chrono>
-
-namespace folly {
-
-/// WaitOptions
-///
-/// Various synchronization primitives as well as various concurrent data
-/// structures built using them have operations which might wait. This type
-/// represents a set of options for controlling such waiting.
-class WaitOptions {
- public:
-  struct Defaults {
-    /// spin_max
-    ///
-    /// If multiple threads are actively using a synchronization primitive,
-    /// whether indirectly via a higher-level concurrent data structure or
-    /// directly, where the synchronization primitive has an operation which
-    /// waits and another operation which wakes the waiter, it is common for
-    /// wait and wake events to happen almost at the same time. In this state,
-    /// we lose big 50% of the time if the wait blocks immediately.
-    ///
-    /// We can improve our chances of being waked immediately, before blocking,
-    /// by spinning for a short duration, although we have to balance this
-    /// against the extra cpu utilization, latency reduction, power consumption,
-    /// and priority inversion effect if we end up blocking anyway.
-    ///
-    /// We use a default maximum of 2 usec of spinning. As partial consolation,
-    /// since spinning as implemented in folly uses the pause instruction where
-    /// available, we give a small speed boost to the colocated hyperthread.
-    ///
-    /// On circa-2013 devbox hardware, it costs about 7 usec to FUTEX_WAIT and
-    /// then be awoken. Spins on this hw take about 7 nsec, where all but 0.5
-    /// nsec is the pause instruction.
-    static constexpr std::chrono::nanoseconds spin_max =
-        std::chrono::microseconds(2);
-  };
-
-  std::chrono::nanoseconds spin_max() const {
-    return spin_max_;
-  }
-  WaitOptions& spin_max(std::chrono::nanoseconds dur) {
-    spin_max_ = dur;
-    return *this;
-  }
-
- private:
-  std::chrono::nanoseconds spin_max_ = Defaults::spin_max;
-};
-
-} // namespace folly

package/deps/rocksdb/rocksdb/third-party/folly/folly/synchronization/detail/InlineFunctionRef.h

@@ -1,219 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#pragma once
-
-#include <cstdint>
-#include <type_traits>
-
-#include <folly/Traits.h>
-#include <folly/Utility.h>
-#include <folly/functional/Invoke.h>
-#include <folly/lang/Launder.h>
-
-namespace folly {
-namespace detail {
-
-/**
- * InlineFunctionRef is similar to folly::FunctionRef but has the additional
- * benefit of being able to store the function it was instantiated with inline
- * in a buffer of the given capacity.  Inline storage is only used if the
- * function object and a pointer (for type-erasure) are small enough to fit in
- * the templated size.  If there is not enough in-situ capacity for the
- * callable, this just stores a reference to the function object like
- * FunctionRef.
- *
- * This helps give a perf boost in the case where the data gets separated from
- * the point of invocation.  If, for example, at the point of invocation, the
- * InlineFunctionRef object is not cached, a remote memory/cache read might be
- * required to invoke the original callable.  Customizable inline storage
- * helps tune storage so we can store a type-erased callable with better
- * performance and locality.  A real-life example of this might be a
- * folly::FunctionRef with a function pointer.  The folly::FunctionRef would
- * point to the function pointer object in a remote location.  This causes a
- * double-indirection at the point of invocation, and if that memory is dirty,
- * or not cached, it would cause additional cache misses.  On the other hand
- * with InlineFunctionRef, inline storage would store the value of the
- * function pointer, avoiding the need to do a remote lookup to fetch the
- * value of the function pointer.
- *
- * To prevent misuse, InlineFunctionRef disallows construction from an lvalue
- * callable.  This is to prevent usage where a user relies on the callable's
- * state after invocation through InlineFunctionRef.  This has the potential
- * to copy the callable into inline storage when the callable is small, so we
- * might not use the same function when invoking, but rather a copy of it.
- *
- * Also note that InlineFunctionRef will always invoke the const qualified
- * version of the call operator for any callable that is passed.  Regardless
- * of whether it has a non-const version.  This is done to enforce the logical
- * constraint of function state being immutable.
- *
- * This class is always trivially-copyable (and therefore
- * trivially-destructible), making it suitable for use in a union without
- * requiring manual destruction.
- */
-template <typename FunctionType, std::size_t Size>
-class InlineFunctionRef;
-
-template <typename ReturnType, typename... Args, std::size_t Size>
-class InlineFunctionRef<ReturnType(Args...), Size> {
-  using Storage =
-      _t<std::aligned_storage<Size - sizeof(uintptr_t), sizeof(uintptr_t)>>;
-  using Call = ReturnType (*)(const Storage&, Args&&...);
-
-  struct InSituTag {};
-  struct RefTag {};
-
-  static_assert(
-      (Size % sizeof(uintptr_t)) == 0,
-      "Size has to be a multiple of sizeof(uintptr_t)");
-  static_assert(Size >= 2 * sizeof(uintptr_t), "This doesn't work");
-  static_assert(alignof(Call) == alignof(Storage), "Mismatching alignments");
-
-  // This defines a mode tag that is used in the construction of
-  // InlineFunctionRef to determine the storage and indirection method for the
-  // passed callable.
-  //
-  // This requires that the we pass in a type that is not ref-qualified.
-  template <typename Func>
-  using ConstructMode = _t<std::conditional<
-      folly::is_trivially_copyable<Func>{} &&
-          (sizeof(Func) <= sizeof(Storage)) &&
-          (alignof(Func) <= alignof(Storage)),
-      InSituTag,
-      RefTag>>;
-
- public:
-  /**
-   * InlineFunctionRef can be constructed from a nullptr, callable or another
-   * InlineFunctionRef with the same size.  These are the constructors that
-   * don't take a callable.
-   *
-   * InlineFunctionRef is meant to be trivially copyable so we default the
-   * constructors and assignment operators.
-   */
-  InlineFunctionRef(std::nullptr_t) : call_{nullptr} {}
-  InlineFunctionRef() : call_{nullptr} {}
-  InlineFunctionRef(const InlineFunctionRef& other) = default;
-  InlineFunctionRef(InlineFunctionRef&&) = default;
-  InlineFunctionRef& operator=(const InlineFunctionRef&) = default;
-  InlineFunctionRef& operator=(InlineFunctionRef&&) = default;
-
-  /**
-   * Constructors from callables.
-   *
-   * If all of the following conditions are satisfied, then we store the
-   * callable in the inline storage:
-   *
-   *  1) The function has been passed as an rvalue, meaning that there is no
-   *     use of the original in the user's code after it has been passed to
-   *     us.
-   *  2) Size of the callable is less than the size of the inline storage
-   *     buffer.
-   *  3) The callable is trivially constructible and destructible.
-   *
-   * If any one of the above conditions is not satisfied, we fall back to
-   * reference semantics and store the function as a pointer, and add a level
-   * of indirection through type erasure.
-   */
-  template <
-      typename Func,
-      _t<std::enable_if<
-          !std::is_same<_t<std::decay<Func>>, InlineFunctionRef>{} &&
-          !std::is_reference<Func>{} &&
-          std::is_convertible<
-              decltype(std::declval<Func&&>()(std::declval<Args&&>()...)),
-              ReturnType>{}>>* = nullptr>
-  InlineFunctionRef(Func&& func) {
-    // We disallow construction from lvalues, so assert that this is not a
-    // reference type.  When invoked with an lvalue, Func is a lvalue
-    // reference type, when invoked with an rvalue, Func is not ref-qualified.
-    static_assert(
-        !std::is_reference<Func>{},
-        "InlineFunctionRef cannot be used with lvalues");
-    static_assert(std::is_rvalue_reference<Func&&>{}, "");
-    construct(ConstructMode<Func>{}, folly::as_const(func));
-  }
-
-  /**
-   * The call operator uses the function pointer and a reference to the
-   * storage to do the dispatch.  The function pointer takes care of the
-   * appropriate casting.
-   */
-  ReturnType operator()(Args... args) const {
-    return call_(storage_, static_cast<Args&&>(args)...);
-  }
-
-  /**
-   * We have a function engaged if the call function points to anything other
-   * than null.
-   */
-  operator bool() const noexcept {
-    return call_;
-  }
-
- private:
-  friend class InlineFunctionRefTest;
-
-  /**
-   * Inline storage constructor implementation.
-   */
-  template <typename Func>
-  void construct(InSituTag, Func& func) {
-    using Value = _t<std::remove_reference<Func>>;
-
-    // Assert that the following two assumptions are valid
-    //    1) fit in the storage space we have and match alignments, and
-    //    2) be invocable in a const context, it does not make sense to copy a
-    //       callable into inline storage if it makes state local
-    //       modifications.
-    static_assert(alignof(Value) <= alignof(Storage), "");
-    static_assert(is_invocable<const _t<std::decay<Func>>, Args&&...>{}, "");
-    static_assert(folly::is_trivially_copyable<Value>{}, "");
-
-    new (&storage_) Value{func};
-    call_ = &callInline<Value>;
-  }
-
-  /**
-   * Ref storage constructor implementation.  This is identical to
-   * folly::FunctionRef.
-   */
-  template <typename Func>
-  void construct(RefTag, Func& func) {
-    // store a pointer to the function
-    using Pointer = _t<std::add_pointer<_t<std::remove_reference<Func>>>>;
-    new (&storage_) Pointer{&func};
-    call_ = &callPointer<Pointer>;
-  }
-
-  template <typename Func>
-  static ReturnType callInline(const Storage& object, Args&&... args) {
-    // The only type of pointer allowed is a function pointer, no other
-    // pointer types are invocable.
-    static_assert(
-        !std::is_pointer<Func>::value ||
-            std::is_function<_t<std::remove_pointer<Func>>>::value,
-        "");
-    return (*folly::launder(reinterpret_cast<const Func*>(&object)))(
-        static_cast<Args&&>(args)...);
-  }
-
-  template <typename Func>
-  static ReturnType callPointer(const Storage& object, Args&&... args) {
-    // When the function we were instantiated with was not trivial, the given
-    // pointer points to a pointer, which pointers to the callable.  So we
-    // cast to a pointer and then to the pointee.
-    static_assert(std::is_pointer<Func>::value, "");
-    return (**folly::launder(reinterpret_cast<const Func*>(&object)))(
-        static_cast<Args&&>(args)...);
-  }
-
-  Call call_;
-  Storage storage_;
-};
-
-} // namespace detail
-} // namespace folly