@nxtedition/rocksdb 15.2.2 → 15.2.4

package/deps/abseil-cpp/absl/base/internal/spinlock.cc

@@ -1,225 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// 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
-//
-//      https://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 "absl/base/internal/spinlock.h"
-
-#include <algorithm>
-#include <atomic>
-#include <cstdint>
-#include <limits>
-
-#include "absl/base/attributes.h"
-#include "absl/base/call_once.h"
-#include "absl/base/config.h"
-#include "absl/base/internal/atomic_hook.h"
-#include "absl/base/internal/cycleclock.h"
-#include "absl/base/internal/scheduling_mode.h"
-#include "absl/base/internal/spinlock_wait.h"
-#include "absl/base/internal/sysinfo.h" /* For NumCPUs() */
-#include "absl/base/internal/tsan_mutex_interface.h"
-
-// Description of lock-word:
-//  31..00: [............................3][2][1][0]
-//
-//     [0]: kSpinLockHeld
-//     [1]: kSpinLockCooperative
-//     [2]: kSpinLockDisabledScheduling
-// [31..3]: ONLY kSpinLockSleeper OR
-//          Wait time in cycles >> PROFILE_TIMESTAMP_SHIFT
-//
-// Detailed descriptions:
-//
-// Bit [0]: The lock is considered held iff kSpinLockHeld is set.
-//
-// Bit [1]: Eligible waiters (e.g. Fibers) may co-operatively reschedule when
-//          contended iff kSpinLockCooperative is set.
-//
-// Bit [2]: This bit is exclusive from bit [1].  It is used only by a
-//          non-cooperative lock.  When set, indicates that scheduling was
-//          successfully disabled when the lock was acquired.  May be unset,
-//          even if non-cooperative, if a ThreadIdentity did not yet exist at
-//          time of acquisition.
-//
-// Bit [3]: If this is the only upper bit ([31..3]) set then this lock was
-//          acquired without contention, however, at least one waiter exists.
-//
-//          Otherwise, bits [31..3] represent the time spent by the current lock
-//          holder to acquire the lock.  There may be outstanding waiter(s).
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES static AtomicHook<void (*)(
-    const void *lock, int64_t wait_cycles)>
-    submit_profile_data;
-
-void RegisterSpinLockProfiler(void (*fn)(const void *contendedlock,
-                                         int64_t wait_cycles)) {
-  submit_profile_data.Store(fn);
-}
-
-// Monitor the lock to see if its value changes within some time period
-// (adaptive_spin_count_ loop iterations). The last value read from the lock
-// is returned from the method.
-ABSL_CONST_INIT std::atomic<int> SpinLock::adaptive_spin_count_{0};
-uint32_t SpinLock::SpinLoop() {
-  // We are already in the slow path of SpinLock, initialize the
-  // adaptive_spin_count here.
-  if (adaptive_spin_count_.load(std::memory_order_relaxed) == 0) {
-    int current_spin_count = 0;
-    int new_spin_count = NumCPUs() > 1 ? 1000 : 1;
-    // If this fails, the value will remain unchanged. We may not spin for the
-    // intended duration, but that is still safe. We will try again on the next
-    // call to SpinLoop.
-    adaptive_spin_count_.compare_exchange_weak(
-        current_spin_count, new_spin_count, std::memory_order_relaxed,
-        std::memory_order_relaxed);
-  }
-  int c = adaptive_spin_count_.load(std::memory_order_relaxed);
-  uint32_t lock_value;
-  do {
-    lock_value = lockword_.load(std::memory_order_relaxed);
-  } while ((lock_value & kSpinLockHeld) != 0 && --c > 0);
-  return lock_value;
-}
-
-void SpinLock::SlowLock() {
-  uint32_t lock_value = SpinLoop();
-  lock_value = TryLockInternal(lock_value, 0);
-  if ((lock_value & kSpinLockHeld) == 0) {
-    return;
-  }
-
-  SchedulingMode scheduling_mode;
-  if ((lock_value & kSpinLockCooperative) != 0) {
-    scheduling_mode = SCHEDULE_COOPERATIVE_AND_KERNEL;
-  } else {
-    scheduling_mode = SCHEDULE_KERNEL_ONLY;
-  }
-
-  // The lock was not obtained initially, so this thread needs to wait for
-  // it.  Record the current timestamp in the local variable wait_start_time
-  // so the total wait time can be stored in the lockword once this thread
-  // obtains the lock.
-  int64_t wait_start_time = CycleClock::Now();
-  uint32_t wait_cycles = 0;
-  int lock_wait_call_count = 0;
-  while ((lock_value & kSpinLockHeld) != 0) {
-    // If the lock is currently held, but not marked as having a sleeper, mark
-    // it as having a sleeper.
-    if ((lock_value & kWaitTimeMask) == 0) {
-      // Here, just "mark" that the thread is going to sleep.  Don't store the
-      // lock wait time in the lock -- the lock word stores the amount of time
-      // that the current holder waited before acquiring the lock, not the wait
-      // time of any thread currently waiting to acquire it.
-      if (lockword_.compare_exchange_strong(
-              lock_value, lock_value | kSpinLockSleeper,
-              std::memory_order_relaxed, std::memory_order_relaxed)) {
-        // Successfully transitioned to kSpinLockSleeper.  Pass
-        // kSpinLockSleeper to the SpinLockWait routine to properly indicate
-        // the last lock_value observed.
-        lock_value |= kSpinLockSleeper;
-      } else if ((lock_value & kSpinLockHeld) == 0) {
-        // Lock is free again, so try and acquire it before sleeping.  The
-        // new lock state will be the number of cycles this thread waited if
-        // this thread obtains the lock.
-        lock_value = TryLockInternal(lock_value, wait_cycles);
-        continue;  // Skip the delay at the end of the loop.
-      } else if ((lock_value & kWaitTimeMask) == 0) {
-        // The lock is still held, without a waiter being marked, but something
-        // else about the lock word changed, causing our CAS to fail. For
-        // example, a new lock holder may have acquired the lock with
-        // kSpinLockDisabledScheduling set, whereas the previous holder had not
-        // set that flag. In this case, attempt again to mark ourselves as a
-        // waiter.
-        continue;
-      }
-    }
-
-    // SpinLockDelay() calls into fiber scheduler, we need to see
-    // synchronization there to avoid false positives.
-    ABSL_TSAN_MUTEX_PRE_DIVERT(this, 0);
-    // Wait for an OS specific delay.
-    SpinLockDelay(&lockword_, lock_value, ++lock_wait_call_count,
-                  scheduling_mode);
-    ABSL_TSAN_MUTEX_POST_DIVERT(this, 0);
-    // Spin again after returning from the wait routine to give this thread
-    // some chance of obtaining the lock.
-    lock_value = SpinLoop();
-    wait_cycles = EncodeWaitCycles(wait_start_time, CycleClock::Now());
-    lock_value = TryLockInternal(lock_value, wait_cycles);
-  }
-}
-
-void SpinLock::SlowUnlock(uint32_t lock_value) {
-  SpinLockWake(&lockword_,
-               false);  // wake waiter if necessary
-
-  // If our acquisition was contended, collect contentionz profile info.  We
-  // reserve a unitary wait time to represent that a waiter exists without our
-  // own acquisition having been contended.
-  if ((lock_value & kWaitTimeMask) != kSpinLockSleeper) {
-    const int64_t wait_cycles = DecodeWaitCycles(lock_value);
-    ABSL_TSAN_MUTEX_PRE_DIVERT(this, 0);
-    submit_profile_data(this, wait_cycles);
-    ABSL_TSAN_MUTEX_POST_DIVERT(this, 0);
-  }
-}
-
-// We use the upper 29 bits of the lock word to store the time spent waiting to
-// acquire this lock.  This is reported by contentionz profiling.  Since the
-// lower bits of the cycle counter wrap very quickly on high-frequency
-// processors we divide to reduce the granularity to 2^kProfileTimestampShift
-// sized units.  On a 4Ghz machine this will lose track of wait times greater
-// than (2^29/4 Ghz)*128 =~ 17.2 seconds.  Such waits should be extremely rare.
-static constexpr int kProfileTimestampShift = 7;
-
-// We currently reserve the lower 3 bits.
-static constexpr int kLockwordReservedShift = 3;
-
-uint32_t SpinLock::EncodeWaitCycles(int64_t wait_start_time,
-                                    int64_t wait_end_time) {
-  static const int64_t kMaxWaitTime =
-      std::numeric_limits<uint32_t>::max() >> kLockwordReservedShift;
-  int64_t scaled_wait_time =
-      (wait_end_time - wait_start_time) >> kProfileTimestampShift;
-
-  // Return a representation of the time spent waiting that can be stored in
-  // the lock word's upper bits.
-  uint32_t clamped = static_cast<uint32_t>(
-      std::min(scaled_wait_time, kMaxWaitTime) << kLockwordReservedShift);
-
-  if (clamped == 0) {
-    return kSpinLockSleeper;  // Just wake waiters, but don't record contention.
-  }
-  // Bump up value if necessary to avoid returning kSpinLockSleeper.
-  const uint32_t kMinWaitTime =
-      kSpinLockSleeper + (1 << kLockwordReservedShift);
-  if (clamped == kSpinLockSleeper) {
-    return kMinWaitTime;
-  }
-  return clamped;
-}
-
-int64_t SpinLock::DecodeWaitCycles(uint32_t lock_value) {
-  // Cast to uint32_t first to ensure bits [63:32] are cleared.
-  const int64_t scaled_wait_time =
-      static_cast<uint32_t>(lock_value & kWaitTimeMask);
-  return scaled_wait_time << (kProfileTimestampShift - kLockwordReservedShift);
-}
-
-}  // namespace base_internal
-ABSL_NAMESPACE_END
-}  // namespace absl

package/deps/abseil-cpp/absl/base/internal/spinlock.h

@@ -1,310 +0,0 @@
-//
-// Copyright 2017 The Abseil Authors.
-//
-// 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
-//
-//      https://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.
-//
-
-//  Most users requiring mutual exclusion should use Mutex.
-//  SpinLock is provided for use in two situations:
-//   - for use by Abseil internal code that Mutex itself depends on
-//   - for async signal safety (see below)
-
-// SpinLock with a SchedulingMode::SCHEDULE_KERNEL_ONLY is async
-// signal safe. If a spinlock is used within a signal handler, all code that
-// acquires the lock must ensure that the signal cannot arrive while they are
-// holding the lock. Typically, this is done by blocking the signal.
-//
-// Threads waiting on a SpinLock may be woken in an arbitrary order.
-
-#ifndef ABSL_BASE_INTERNAL_SPINLOCK_H_
-#define ABSL_BASE_INTERNAL_SPINLOCK_H_
-
-#include <atomic>
-#include <cstdint>
-#include <mutex>
-#include <type_traits>
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-#include "absl/base/const_init.h"
-#include "absl/base/internal/low_level_scheduling.h"
-#include "absl/base/internal/raw_logging.h"
-#include "absl/base/internal/scheduling_mode.h"
-#include "absl/base/internal/tsan_mutex_interface.h"
-#include "absl/base/macros.h"
-#include "absl/base/thread_annotations.h"
-
-namespace tcmalloc {
-namespace tcmalloc_internal {
-
-class AllocationGuardSpinLockHolder;
-class Static;
-
-}  // namespace tcmalloc_internal
-}  // namespace tcmalloc
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-class ABSL_LOCKABLE ABSL_ATTRIBUTE_WARN_UNUSED SpinLock {
- public:
-  constexpr SpinLock() : lockword_(kSpinLockCooperative) { RegisterWithTsan(); }
-
-  // Constructors that allow non-cooperative spinlocks to be created for use
-  // inside thread schedulers.  Normal clients should not use these.
-  constexpr explicit SpinLock(SchedulingMode mode)
-      : lockword_(IsCooperative(mode) ? kSpinLockCooperative : 0) {
-    RegisterWithTsan();
-  }
-
-#if ABSL_HAVE_ATTRIBUTE(enable_if) && !defined(_WIN32)
-  // Constructor to inline users of the default scheduling mode.
-  //
-  // This only needs to exists for inliner runs, but doesn't work correctly in
-  // clang+windows builds, likely due to mangling differences.
-  ABSL_DEPRECATE_AND_INLINE()
-  constexpr explicit SpinLock(SchedulingMode mode)
-      __attribute__((enable_if(mode == SCHEDULE_COOPERATIVE_AND_KERNEL,
-                               "Cooperative use default constructor")))
-      : SpinLock() {}
-#endif
-
-  // Constructor for global SpinLock instances.  See absl/base/const_init.h.
-  ABSL_DEPRECATE_AND_INLINE()
-  constexpr SpinLock(absl::ConstInitType, SchedulingMode mode)
-      : SpinLock(mode) {}
-
-  // For global SpinLock instances prefer trivial destructor when possible.
-  // Default but non-trivial destructor in some build configurations causes an
-  // extra static initializer.
-#ifdef ABSL_INTERNAL_HAVE_TSAN_INTERFACE
-  ~SpinLock() { ABSL_TSAN_MUTEX_DESTROY(this, __tsan_mutex_not_static); }
-#else
-  ~SpinLock() = default;
-#endif
-
-  // Acquire this SpinLock.
-  inline void lock() ABSL_EXCLUSIVE_LOCK_FUNCTION() {
-    ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
-    if (!TryLockImpl()) {
-      SlowLock();
-    }
-    ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0);
-  }
-
-  ABSL_DEPRECATE_AND_INLINE()
-  inline void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION() { return lock(); }
-
-  // Try to acquire this SpinLock without blocking and return true if the
-  // acquisition was successful.  If the lock was not acquired, false is
-  // returned.  If this SpinLock is free at the time of the call, try_lock will
-  // return true with high probability.
-  [[nodiscard]] inline bool try_lock() ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(true) {
-    ABSL_TSAN_MUTEX_PRE_LOCK(this, __tsan_mutex_try_lock);
-    bool res = TryLockImpl();
-    ABSL_TSAN_MUTEX_POST_LOCK(
-        this, __tsan_mutex_try_lock | (res ? 0 : __tsan_mutex_try_lock_failed),
-        0);
-    return res;
-  }
-
-  ABSL_DEPRECATE_AND_INLINE()
-  [[nodiscard]] inline bool TryLock() ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(true) {
-    return try_lock();
-  }
-
-  // Release this SpinLock, which must be held by the calling thread.
-  inline void unlock() ABSL_UNLOCK_FUNCTION() {
-    ABSL_TSAN_MUTEX_PRE_UNLOCK(this, 0);
-    uint32_t lock_value = lockword_.load(std::memory_order_relaxed);
-    lock_value = lockword_.exchange(lock_value & kSpinLockCooperative,
-                                    std::memory_order_release);
-
-    if ((lock_value & kSpinLockDisabledScheduling) != 0) {
-      SchedulingGuard::EnableRescheduling(true);
-    }
-    if ((lock_value & kWaitTimeMask) != 0) {
-      // Collect contentionz profile info, and speed the wakeup of any waiter.
-      // The wait_cycles value indicates how long this thread spent waiting
-      // for the lock.
-      SlowUnlock(lock_value);
-    }
-    ABSL_TSAN_MUTEX_POST_UNLOCK(this, 0);
-  }
-
-  ABSL_DEPRECATE_AND_INLINE()
-  inline void Unlock() ABSL_UNLOCK_FUNCTION() { unlock(); }
-
-  // Determine if the lock is held.  When the lock is held by the invoking
-  // thread, true will always be returned. Intended to be used as
-  // CHECK(lock.IsHeld()).
-  [[nodiscard]] inline bool IsHeld() const {
-    return (lockword_.load(std::memory_order_relaxed) & kSpinLockHeld) != 0;
-  }
-
-  // Return immediately if this thread holds the SpinLock exclusively.
-  // Otherwise, report an error by crashing with a diagnostic.
-  inline void AssertHeld() const ABSL_ASSERT_EXCLUSIVE_LOCK() {
-    if (!IsHeld()) {
-      ABSL_RAW_LOG(FATAL, "thread should hold the lock on SpinLock");
-    }
-  }
-
- protected:
-  // These should not be exported except for testing.
-
-  // Store number of cycles between wait_start_time and wait_end_time in a
-  // lock value.
-  static uint32_t EncodeWaitCycles(int64_t wait_start_time,
-                                   int64_t wait_end_time);
-
-  // Extract number of wait cycles in a lock value.
-  static int64_t DecodeWaitCycles(uint32_t lock_value);
-
-  // Provide access to protected method above.  Use for testing only.
-  friend struct SpinLockTest;
-  friend class tcmalloc::tcmalloc_internal::AllocationGuardSpinLockHolder;
-  friend class tcmalloc::tcmalloc_internal::Static;
-
-  static int GetAdaptiveSpinCount() {
-    return adaptive_spin_count_.load(std::memory_order_relaxed);
-  }
-  static void SetAdaptiveSpinCount(int count) {
-    adaptive_spin_count_.store(count, std::memory_order_relaxed);
-  }
-
-  static std::atomic<int> adaptive_spin_count_;
-
- private:
-  // lockword_ is used to store the following:
-  //
-  // bit[0] encodes whether a lock is being held.
-  // bit[1] encodes whether a lock uses cooperative scheduling.
-  // bit[2] encodes whether the current lock holder disabled scheduling when
-  //        acquiring the lock. Only set when kSpinLockHeld is also set.
-  // bit[3:31] encodes time a lock spent on waiting as a 29-bit unsigned int.
-  //        This is set by the lock holder to indicate how long it waited on
-  //        the lock before eventually acquiring it. The number of cycles is
-  //        encoded as a 29-bit unsigned int, or in the case that the current
-  //        holder did not wait but another waiter is queued, the LSB
-  //        (kSpinLockSleeper) is set. The implementation does not explicitly
-  //        track the number of queued waiters beyond this. It must always be
-  //        assumed that waiters may exist if the current holder was required to
-  //        queue.
-  //
-  // Invariant: if the lock is not held, the value is either 0 or
-  // kSpinLockCooperative.
-  static constexpr uint32_t kSpinLockHeld = 1;
-  static constexpr uint32_t kSpinLockCooperative = 2;
-  static constexpr uint32_t kSpinLockDisabledScheduling = 4;
-  static constexpr uint32_t kSpinLockSleeper = 8;
-  // Includes kSpinLockSleeper.
-  static constexpr uint32_t kWaitTimeMask =
-      ~(kSpinLockHeld | kSpinLockCooperative | kSpinLockDisabledScheduling);
-
-  // Returns true if the provided scheduling mode is cooperative.
-  static constexpr bool IsCooperative(SchedulingMode scheduling_mode) {
-    return scheduling_mode == SCHEDULE_COOPERATIVE_AND_KERNEL;
-  }
-
-  constexpr void RegisterWithTsan() {
-#if ABSL_HAVE_BUILTIN(__builtin_is_constant_evaluated)
-    if (!__builtin_is_constant_evaluated()) {
-      ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static);
-    }
-#endif
-  }
-
-  bool IsCooperative() const {
-    return lockword_.load(std::memory_order_relaxed) & kSpinLockCooperative;
-  }
-
-  uint32_t TryLockInternal(uint32_t lock_value, uint32_t wait_cycles);
-  void SlowLock() ABSL_ATTRIBUTE_COLD;
-  void SlowUnlock(uint32_t lock_value) ABSL_ATTRIBUTE_COLD;
-  uint32_t SpinLoop();
-
-  inline bool TryLockImpl() {
-    uint32_t lock_value = lockword_.load(std::memory_order_relaxed);
-    return (TryLockInternal(lock_value, 0) & kSpinLockHeld) == 0;
-  }
-
-  std::atomic<uint32_t> lockword_;
-
-  SpinLock(const SpinLock&) = delete;
-  SpinLock& operator=(const SpinLock&) = delete;
-};
-
-// Corresponding locker object that arranges to acquire a spinlock for
-// the duration of a C++ scope.
-class ABSL_SCOPED_LOCKABLE [[nodiscard]] SpinLockHolder
-    : public std::lock_guard<SpinLock> {
- public:
-  inline explicit SpinLockHolder(
-      SpinLock& l ABSL_INTERNAL_ATTRIBUTE_CAPTURED_BY(this))
-      ABSL_EXCLUSIVE_LOCK_FUNCTION(l)
-      : std::lock_guard<SpinLock>(l) {}
-  ABSL_DEPRECATE_AND_INLINE()
-  inline explicit SpinLockHolder(SpinLock* l) ABSL_EXCLUSIVE_LOCK_FUNCTION(l)
-      : SpinLockHolder(*l) {}
-
-  inline ~SpinLockHolder() ABSL_UNLOCK_FUNCTION() = default;
-};
-
-// Register a hook for profiling support.
-//
-// The function pointer registered here will be called whenever a spinlock is
-// contended.  The callback is given an opaque handle to the contended spinlock
-// and the number of wait cycles.  This is thread-safe, but only a single
-// profiler can be registered.  It is an error to call this function multiple
-// times with different arguments.
-void RegisterSpinLockProfiler(void (*fn)(const void* lock,
-                                         int64_t wait_cycles));
-
-//------------------------------------------------------------------------------
-// Public interface ends here.
-//------------------------------------------------------------------------------
-
-// If (result & kSpinLockHeld) == 0, then *this was successfully locked.
-// Otherwise, returns last observed value for lockword_.
-inline uint32_t SpinLock::TryLockInternal(uint32_t lock_value,
-                                          uint32_t wait_cycles) {
-  if ((lock_value & kSpinLockHeld) != 0) {
-    return lock_value;
-  }
-
-  uint32_t sched_disabled_bit = 0;
-  if ((lock_value & kSpinLockCooperative) == 0) {
-    // For non-cooperative locks we must make sure we mark ourselves as
-    // non-reschedulable before we attempt to CompareAndSwap.
-    if (SchedulingGuard::DisableRescheduling()) {
-      sched_disabled_bit = kSpinLockDisabledScheduling;
-    }
-  }
-
-  if (!lockword_.compare_exchange_strong(
-          lock_value,
-          kSpinLockHeld | lock_value | wait_cycles | sched_disabled_bit,
-          std::memory_order_acquire, std::memory_order_relaxed)) {
-    SchedulingGuard::EnableRescheduling(sched_disabled_bit != 0);
-  }
-
-  return lock_value;
-}
-
-}  // namespace base_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_BASE_INTERNAL_SPINLOCK_H_

package/deps/abseil-cpp/absl/base/internal/spinlock_akaros.inc

@@ -1,35 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// 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
-//
-//      https://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.
-//
-// This file is an Akaros-specific part of spinlock_wait.cc
-
-#include <atomic>
-
-#include "absl/base/internal/scheduling_mode.h"
-
-extern "C" {
-
-ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)(
-    std::atomic<uint32_t>* /* lock_word */, uint32_t /* value */,
-    int /* loop */, absl::base_internal::SchedulingMode /* mode */) {
-  // In Akaros, one must take care not to call anything that could cause a
-  // malloc(), a blocking system call, or a uthread_yield() while holding a
-  // spinlock. Our callers assume will not call into libraries or other
-  // arbitrary code.
-}
-
-ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)(
-    std::atomic<uint32_t>* /* lock_word */, bool /* all */) {}
-
-}  // extern "C"

package/deps/abseil-cpp/absl/base/internal/spinlock_benchmark.cc

@@ -1,80 +0,0 @@
-// Copyright 2018 The Abseil Authors.
-//
-// 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
-//
-//      https://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.
-
-// See also //absl/synchronization:mutex_benchmark for a comparison of SpinLock
-// and Mutex performance under varying levels of contention.
-
-#include "absl/base/internal/raw_logging.h"
-#include "absl/base/internal/scheduling_mode.h"
-#include "absl/base/internal/spinlock.h"
-#include "absl/base/no_destructor.h"
-#include "absl/synchronization/internal/create_thread_identity.h"
-#include "benchmark/benchmark.h"
-
-namespace {
-
-template <absl::base_internal::SchedulingMode scheduling_mode>
-static void BM_TryLock(benchmark::State& state) {
-  // Ensure a ThreadIdentity is installed so that KERNEL_ONLY has an effect.
-  ABSL_INTERNAL_CHECK(
-      absl::synchronization_internal::GetOrCreateCurrentThreadIdentity() !=
-          nullptr,
-      "GetOrCreateCurrentThreadIdentity() failed");
-
-  static absl::NoDestructor<absl::base_internal::SpinLock> spinlock(
-      scheduling_mode);
-  for (auto _ : state) {
-    if (spinlock->try_lock()) spinlock->unlock();
-  }
-}
-
-template <absl::base_internal::SchedulingMode scheduling_mode>
-static void BM_SpinLock(benchmark::State& state) {
-  // Ensure a ThreadIdentity is installed so that KERNEL_ONLY has an effect.
-  ABSL_INTERNAL_CHECK(
-      absl::synchronization_internal::GetOrCreateCurrentThreadIdentity() !=
-          nullptr,
-      "GetOrCreateCurrentThreadIdentity() failed");
-
-  static absl::NoDestructor<absl::base_internal::SpinLock> spinlock(
-      scheduling_mode);
-  for (auto _ : state) {
-    absl::base_internal::SpinLockHolder holder(*spinlock.get());
-  }
-}
-
-BENCHMARK_TEMPLATE(BM_SpinLock,
-                   absl::base_internal::SCHEDULE_KERNEL_ONLY)
-    ->UseRealTime()
-    ->Threads(1)
-    ->ThreadPerCpu();
-
-BENCHMARK_TEMPLATE(BM_SpinLock,
-                   absl::base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL)
-    ->UseRealTime()
-    ->Threads(1)
-    ->ThreadPerCpu();
-
-BENCHMARK_TEMPLATE(BM_TryLock, absl::base_internal::SCHEDULE_KERNEL_ONLY)
-    ->UseRealTime()
-    ->Threads(1)
-    ->ThreadPerCpu();
-
-BENCHMARK_TEMPLATE(BM_TryLock,
-                   absl::base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL)
-    ->UseRealTime()
-    ->Threads(1)
-    ->ThreadPerCpu();
-
-}  // namespace