folly::detail::distributed_mutex Namespace Reference

Classes
class	DistributedMutex
class	Waiter
class	WakerMetadata

Functions
std::chrono::nanoseconds	time ()
template<typename Type >
Type *	extractAddress (std::uintptr_t from)
std::uint64_t	strip (std::chrono::nanoseconds t)
std::uint64_t	recover (std::uint64_t from)
template<typename Waiter >
bool	spin (Waiter &waiter)
template<typename Waiter >
void	doFutexWake (Waiter *waiter)
template<typename Waiter >
bool	doFutexWait (Waiter *waiter, Waiter *&next)
template<typename Waiter >
bool	wait (Waiter *waiter, bool shouldSleep, Waiter *&next)
void	recordTimedWaiterAndClearTimedBit (bool &timedWaiter, std::uintptr_t &previous)
bool	preempted (std::uint64_t value)
bool	isSleeper (std::uintptr_t value)
template<typename Waiter >
std::uintptr_t	tryWake (bool publishing, Waiter *waiter, std::uintptr_t value, WakerMetadata metadata, Waiter *&sleepers)
template<typename Waiter >
bool	wake (bool publishing, Waiter &waiter, WakerMetadata metadata, Waiter *&sleepers)
template<typename Atomic >
void	wakeTimedWaiters (Atomic *state, bool timedWaiters)
template<typename Atomic , typename Proxy , typename Sleepers >
bool	tryUnlockClean (Atomic &state, Proxy &proxy, Sleepers sleepers)
template<typename Atomic , typename Deadline , typename MakeProxy >
auto	timedLock (Atomic &state, Deadline deadline, MakeProxy proxy)

Variables
constexpr auto	kUnlocked = std::uintptr_t{0b0}
constexpr auto	kLocked = std::uintptr_t{0b1}
constexpr auto	kTimedWaiter = std::uintptr_t{0b10}
constexpr auto	kUninitialized = std::uint32_t{0b0}
constexpr auto	kWaiting = std::uint32_t{0b1}
constexpr auto	kWake = std::uint32_t{0b10}
constexpr auto	kSkipped = std::uint32_t{0b11}
constexpr auto	kAboutToWait = std::uint32_t{0b100}
constexpr auto	kSleeping = std::uint32_t{0b101}
constexpr auto	kScheduledAwaySpinThreshold = std::chrono::nanoseconds{200}
constexpr auto	kMaxSpins = 4000

Function Documentation

template<typename Waiter >

bool folly::detail::distributed_mutex::doFutexWait	(	Waiter *	waiter,
		Waiter *&	next
	)

Definition at line 378 of file DistributedMutex-inl.h.

References doFutexWake(), folly::exchange(), folly::detail::futexWait(), and kAboutToWait.

Referenced by wait().

                                                {
  // first we get ready to sleep by calling exchange() on the futex with a
  // kSleeping value
  DCHECK((*waiter)->futex_.load(std::memory_order_relaxed) == kAboutToWait);

  // note the semantics of using a futex here, when we exchange the sleeper_
  // with kSleeping, we are getting ready to sleep, but before sleeping we get
  // ready to sleep, and we return from futexWait() when the value of
  // sleeper_ might have changed.  We can also wake up because of a spurious
  // wakeup, so we always check against the value in sleeper_ after returning
  // from futexWait(), if the value is not kWake, then we continue
  auto pre = (*waiter)->sleeper_.exchange(kSleeping, std::memory_order_acq_rel);

  // Seeing a kSleeping on a futex word before we set it ourselves means only
  // one thing - an unlocking thread caught us before we went to futex(), and
  // we now have the lock, so we abort
  //
  // if we were given an early delivery, we can return from this function with
  // a true, meaning that we now have the lock
  if (pre == kSleeping) {
    return true;
  }

  // if we reach here then were were not given an early delivery, and any
  // thread that goes to wake us up will see a consistent view of the rest of
  // the contention chain (since the next_ variable is set before the
  // kSleeping exchange above)
  while (pre != kWake) {
    // before enqueueing on the futex, we wake any waiters that we were
    // possibly responsible for
    doFutexWake(exchange(next, nullptr));

    // then we wait on the futex
    //
    // note that we have to protect ourselves against spurious wakeups here.
    // Because the corresponding futexWake() above does not synchronize
    // wakeups around the futex word.  Because doing so would become
    // inefficient
    futexWait(&(*waiter)->sleeper_, kSleeping);
    pre = (*waiter)->sleeper_.load(std::memory_order_acquire);
    DCHECK((pre == kSleeping) || (pre == kWake));
  }

  // when coming out of a futex, we might have some other sleeping threads
  // that we were supposed to wake up, assign that to the next pointer
  DCHECK(next == nullptr);
  next = extractAddress<Waiter>((*waiter)->next_);
  return false;
}

template<typename Waiter >

void folly::detail::distributed_mutex::doFutexWake

(

Waiter *

waiter

)

Definition at line 342 of file DistributedMutex-inl.h.

References folly::detail::futexWake().

Referenced by doFutexWait(), tryUnlockClean(), and folly::detail::distributed_mutex::DistributedMutex< Atomic, TimePublishing >::unlock().

                                 {
  if (waiter) {
    // We can use a simple store operation here and not worry about checking
    // to see if the thread had actually started waiting on the futex, that is
    // already done in tryWake() when a sleeping thread is collected
    //
    // We now do not know whether the waiter had already enqueued on the futex
    // or whether it had just stored kSleeping in its futex and was about to
    // call futexWait().  We treat both these scenarios the same
    //
    // the below can theoretically cause a problem if we set the
    // wake signal and the waiter was in between setting kSleeping in its
    // futex and enqueueing on the futex.  In this case the waiter will just
    // return from futexWait() immediately.  This leaves the address that the
    // waiter was using for futexWait() possibly dangling, and the thread that
    // we woke in the exchange above might have used that address for some
    // other object
    //
    // however, even if the thread had indeed woken up simply becasue of the
    // above exchange(), the futexWake() below is not incorrect.  It is not
    // incorrect because futexWake() does not actually change the memory of
    // the futex word.  It just uses the address to do a lookup in the kernel
    // futex table.  And even if we call futexWake() on some other address,
    // and that address was being used to wait on futex() that thread will
    // protect itself from spurious wakeups, check the value in the futex word
    // and enqueue itself back on the futex
    //
    // this dangilng pointer possibility is why we use a pointer to the futex
    // word, and avoid dereferencing after the store() operation
    auto sleeper = &(*waiter)->sleeper_;
    sleeper->store(kWake, std::memory_order_release);
    futexWake(sleeper, 1);
  }
}

template<typename Type >

Type* folly::detail::distributed_mutex::extractAddress

(

std::uintptr_t

from

)

Zero out the other bits used by the implementation and return just an address from a uintptr_t

Definition at line 199 of file DistributedMutex-inl.h.

References max.

Referenced by folly::detail::distributed_mutex::DistributedMutex< Atomic, TimePublishing >::lock().

                                        {
  // shift one bit off the end, to get all 1s followed by a single 0
  auto mask = std::numeric_limits<std::uintptr_t>::max();
  mask >>= 1;
  mask <<= 1;
  CHECK(!(mask & 0b1));

  return reinterpret_cast<Type*>(from & mask);
}

bool folly::detail::distributed_mutex::isSleeper ( std::uintptr_t  value )

inline

Definition at line 552 of file DistributedMutex-inl.h.

Referenced by tryWake().

                                          {
  return (value == kAboutToWait);
}

bool folly::detail::distributed_mutex::preempted ( std::uint64_t  value )

inline

Definition at line 541 of file DistributedMutex-inl.h.

References kUninitialized, recover(), strip(), and time().

Referenced by tryWake().

                                         {
  auto currentTime = recover(strip(time()));
  auto nodeTime = recover(value);
  auto preempted = currentTime > nodeTime + kScheduledAwaySpinThreshold.count();

  // we say that the thread has been preempted if its timestamp says so, and
  // also if it is neither uninitialized nor skipped
  DCHECK(value != kSkipped);
  return (preempted) && (value != kUninitialized);
}

void folly::detail::distributed_mutex::recordTimedWaiterAndClearTimedBit ( bool &  timedWaiter, std::uintptr_t &  previous  )

inline

Definition at line 437 of file DistributedMutex-inl.h.

References UNLIKELY.

Referenced by folly::detail::distributed_mutex::DistributedMutex< Atomic, TimePublishing >::lock(), and folly::detail::distributed_mutex::DistributedMutex< Atomic, TimePublishing >::unlock().

                            {
  // the previous value in the mutex can never be kTimedWaiter, timed waiters
  // always set (kTimedWaiter | kLocked) in the mutex word when they try and
  // acquire the mutex
  DCHECK(previous != kTimedWaiter);

  if (UNLIKELY(previous & kTimedWaiter)) {
    // record whether there was a timed waiter in the previous mutex state, and
    // clear the timed bit from the previous state
    timedWaiter = true;
    previous = previous & (~kTimedWaiter);
  }
}

std::uint64_t folly::detail::distributed_mutex::recover ( std::uint64_t  from )

inline

Recover the timestamp value from an integer that has the timestamp encoded in it

Definition at line 224 of file DistributedMutex-inl.h.

Referenced by preempted().

                                             {
  return from >> 8;
}

template<typename Waiter >

bool folly::detail::distributed_mutex::spin

(

Waiter &

waiter

)

Definition at line 309 of file DistributedMutex-inl.h.

References folly::asm_volatile_pause(), folly::data(), folly::detail::distributed_mutex::Waiter< Atomic >::futex_, kMaxSpins, kSkipped, kWaiting, max, now(), folly::detail::Sleeper::sleep(), strip(), and time().

Referenced by main(), and wait().

                          {
  auto spins = 0;
  while (true) {
    // publish our current time in the futex as a part of the spin waiting
    // process
    //
    // if we are under the maximum number of spins allowed before sleeping, we
    // publish the exact timestamp, otherwise we publish the minimum possible
    // timestamp to force the waking thread to skip us
    ++spins;
    auto now = (spins < kMaxSpins) ? time() : decltype(time())::zero();
    auto data = strip(now) | kWaiting;
    auto signal = waiter.futex_.exchange(data, std::memory_order_acq_rel);
    signal &= std::numeric_limits<std::uint8_t>::max();

    // if we got skipped, make a note of it and return if we got a skipped
    // signal or a signal to wake up
    auto skipped = signal == kSkipped;
    if (skipped || (signal == kWake)) {
      return !skipped;
    }

    // if we are under the spin threshold, pause to allow the other
    // hyperthread to run.  If not, then sleep
    if (spins < kMaxSpins) {
      asm_volatile_pause();
    } else {
      Sleeper::sleep();
    }
  }
}

std::uint64_t folly::detail::distributed_mutex::strip ( std::chrono::nanoseconds  t )

inline

Strips the given nanoseconds into only the least significant 56 bits by moving the least significant 56 bits over by 8 zeroing out the bottom 8 bits to be used as a medium of information transfer for the thread wait nodes

Definition at line 215 of file DistributedMutex-inl.h.

References time().

Referenced by upload.MercurialVCS::__init__(), cpp.gmock_class::_GenerateMethods(), cpp.ast.AstBuilder::_GenerateOne(), pump.Output::Append(), upload.VersionControlSystem::CheckForUnknownFiles(), upload.MercurialVCS::GetBaseFile(), upload::GetEmail(), gmock_doctor::main(), preempted(), upload::RealMain(), spin(), fuse_gtest_files::VerifyOutputFile(), pump::WrapCode(), and pump::WrapComment().

                                                 {
  auto time = t.count();
  return time << 8;
}

std::chrono::nanoseconds folly::detail::distributed_mutex::time ( )

inline

Get the time since epoch in nanoseconds

This is faster than std::chrono::steady_clock because it avoids a VDSO access to get the timestamp counter

Note that the hardware timestamp counter on x86, like std::steady_clock is guaranteed to be monotonically increasing - https://c9x.me/x86/html/file_module_x86_id_278.html

Definition at line 190 of file DistributedMutex-inl.h.

References folly::asm_rdtsc().

Referenced by BENCHMARK(), benchmarkGet(), testing::internal::CheckedDowncastToActualType(), cmake_minimum_required(), folly::BucketedTimeSeries< VT, CT >::countRate(), wangle::FilePoller::fileTouchedWithinCondInternal(), TestAsyncTransport::WriteEvent::getCount(), folly::ssl::OpenSSLCertUtils::getDateTimeStr(), proxygen::getDateTimeStr(), folly::BlockingQueue< folly::CPUThreadPoolExecutor::CPUTask >::getNumPriorities(), folly::fibers::SimpleLoopController::loop(), main(), preempted(), folly::rcu_domain< Tag >::retire(), runFairness(), folly::fibers::TimeoutController::runTimeouts(), folly::fibers::TimeoutController::scheduleRun(), QuickTest::SetUp(), spin(), strip(), QuickTest::TearDown(), TEST(), TEST_F(), testing::gmock_matchers_test::TEST_P(), folly::hazptr_domain< DeterministicAtomic >::try_timed_cleanup(), and folly::fibers::LoopController::~LoopController().

                                   {
  return std::chrono::nanoseconds{asm_rdtsc()};
}

template<typename Atomic , typename Deadline , typename MakeProxy >

auto folly::detail::distributed_mutex::timedLock	(	Atomic &	state,
		Deadline	deadline,
		MakeProxy	proxy
	)

Definition at line 784 of file DistributedMutex-inl.h.

References folly::atomic_wait_until(), folly::data(), and kLocked.

Referenced by folly::detail::distributed_mutex::DistributedMutex< Atomic, TimePublishing >::try_lock_for(), and folly::detail::distributed_mutex::DistributedMutex< Atomic, TimePublishing >::try_lock_until().

                                                                  {
  while (true) {
    // we put a bit on the central state to show that there is a timed waiter
    // and go to sleep on the central state
    //
    // when this thread goes to unlock the mutex, it will expect a 0b1 in the
    // mutex state (0b1, not 0b11), but then it will see that the value in the
    // mutex state is 0b11 and not 0b1, meaning that there might have been
    // another timed waiter.  Even though there might not have been another
    // timed waiter in the time being.  This sort of missed wakeup is
    // desirable for timed waiters; it helps avoid thundering herds of timed
    // waiters.  Because the mutex is packed in 8 bytes, and we need an
    // address to be stored in those 8 bytes, we don't have much room to play
    // with.  The only other solution is to issue a futexWake(INT_MAX) to wake
    // up all waiters when a clean unlock is committed, when a thread saw a
    // timed waiter in the mutex previously.
    //
    // putting a 0b11 here works for a set of reasons that is a superset of
    // the set of reasons that make it okay to put a kLocked (0b1) in the
    // mutex state.  Now that the thread has put (kTimedWaiter | kLocked)
    // (0b11) in the mutex state and it expects a kLocked (0b1), there are two
    // scenarios possible.  The first being when there is no contention chain
    // formation in the mutex from the time a timed waiter got a lock to
    // unlock.  In this case, the unlocker sees a 0b11 in the mutex state,
    // adjusts to the presence of a timed waiter and cleanly unlocks with a
    // kUnlocked (0b0).  The second is when there is a contention chain.
    // When a thread puts its address in the mutex and sees the timed bit, it
    // records the presence of a timed waiter, and then pretends as if it
    // hadn't seen the timed bit.  So future contention chain releases, will
    // terminate with a kLocked (0b1) and not a (kLocked | kTimedWaiter)
    // (0b11).  This just works naturally with the rest of the algorithm
    // without incurring a perf hit for the regular non-timed case
    //
    // this strategy does however mean, that when threads try to acquire the
    // mutex and all time out, there will be a wasteful syscall to issue wakeups
    // to waiting threads.  We don't do anything to try and minimize this
    //
    // we need to use a fetch_or() here because we need to convey two bits of
    // information - 1, whether the mutex is locked or not, and 2, whether
    // there is a timed waiter.  The alternative here is to use the second bit
    // to convey information only, we can use a fetch_set() on the second bit
    // to make this faster, but that comes at the expense of requiring regular
    // fast path lock attempts.  Which use a single bit read-modify-write for
    // better performance
    auto data = kTimedWaiter | kLocked;
    auto previous = state.fetch_or(data, std::memory_order_acquire);
    if (!(previous & 0b1)) {
      DCHECK(!previous);
      return proxy(nullptr, kLocked, true);
    }

    // wait on the futex until signalled, if we get a timeout, the try_lock
    // fails
    auto result = atomic_wait_until(&state, previous | data, deadline);
    if (result == std::cv_status::timeout) {
      return proxy(nullptr, std::uintptr_t{0}, false);
    }
  }
}

template<typename Atomic , typename Proxy , typename Sleepers >

bool folly::detail::distributed_mutex::tryUnlockClean	(	Atomic &	state,
		Proxy &	proxy,
		Sleepers	sleepers
	)

Definition at line 677 of file DistributedMutex-inl.h.

References doFutexWake(), and UNLIKELY.

Referenced by folly::detail::distributed_mutex::DistributedMutex< Atomic, TimePublishing >::unlock().

                                                                    {
  auto expected = proxy.expected_;
  while (true) {
    if (state.compare_exchange_strong(
            expected,
            kUnlocked,
            std::memory_order_release,
            std::memory_order_relaxed)) {
      // if we were able to commit an unlocked, we need to wake up the futex
      // waiters, if any
      doFutexWake(sleepers);
      return true;
    }

    // if we failed the compare_exchange_strong() above, we check to see if
    // the failure was because of the presence of a timed waiter.  If that
    // was the case then we try one more time with the kTimedWaiter bit set
    if (UNLIKELY(expected == (proxy.expected_ | kTimedWaiter))) {
      proxy.timedWaiters_ = true;
      continue;
    }

    // otherwise break, we have a contention chain
    return false;
  }
}

template<typename Waiter >

std::uintptr_t folly::detail::distributed_mutex::tryWake	(	bool	publishing,
		Waiter *	waiter,
		std::uintptr_t	value,
		WakerMetadata	metadata,
		Waiter *&	sleepers
	)

Definition at line 557 of file DistributedMutex-inl.h.

References isSleeper(), cpp.ast::next(), and preempted().

Referenced by wake().

                       {
  // first we see if we can wake the current thread that is spinning
  if ((!publishing || !preempted(value)) && !isSleeper(value)) {
    // we need release here because of the write to wakerMetadata_
    (*waiter)->wakerMetadata_ = metadata;
    (*waiter)->waiters_ = reinterpret_cast<std::uintptr_t>(sleepers);
    (*waiter)->futex_.store(kWake, std::memory_order_release);
    return 0;
  }

  // if the thread is not a sleeper, and we were not able to catch it before
  // preemption, we can just return a false, it is safe to read next_ because
  // the thread was preempted.  Preemption signals can only come after the
  // thread has set the next_ pointer, since the timestamp writes only start
  // occurring after that point
  //
  // if a thread was preempted it must have stored next_ in the waiter struct,
  // as the store to futex_ that resets the value from kUninitialized happens
  // after the write to next
  CHECK(publishing);
  if (!isSleeper(value)) {
    // go on to the next one
    //
    // Also, we need a memory_order_release here to prevent missed wakeups.  A
    // missed wakeup here can happen when we see that a thread had been
    // preempted and skip it.  Then go on to release the lock, and then when
    // the thread which got skipped does an exchange on the central storage,
    // still sees the locked bit, and never gets woken up
    //
    // Can we relax this?
    DCHECK(preempted(value));
    auto next = (*waiter)->next_;
    (*waiter)->futex_.store(kSkipped, std::memory_order_release);
    return next;
  }

  // if we are here the thread is a sleeper
  //
  // we attempt to catch the thread before it goes to futex().  If we are able
  // to catch the thread before it sleeps on a futex, we are done, and don't
  // need to go any further
  //
  // if we are not able to catch the thread before it goes to futex, we
  // collect the current thread in the list of sleeping threads represented by
  // sleepers, and return the next thread in the list and return false along
  // with the previous next value
  //
  // it is safe to read the next_ pointer in the waiter struct if we were
  // unable to catch the thread before it went to futex() because we use
  // acquire-release ordering for the exchange operation below.  And if we see
  // that the thread was already sleeping, we have synchronized with the write
  // to next_ in the context of the sleeping thread
  //
  // Also we need to set the value of waiters_ and wakerMetadata_ in the
  // thread before doing the exchange because we need to pass on the list of
  // sleepers in the event that we were able to catch the thread before it
  // went to futex().  If we were unable to catch the thread before it slept,
  // these fields will be ignored when the thread wakes up anyway
  DCHECK(isSleeper(value));
  (*waiter)->wakerMetadata_ = metadata;
  (*waiter)->waiters_ = reinterpret_cast<std::uintptr_t>(sleepers);
  auto pre = (*waiter)->sleeper_.exchange(kSleeping, std::memory_order_acq_rel);

  // we were able to catch the thread before it went to sleep, return true
  if (pre != kSleeping) {
    return 0;
  }

  // otherwise return false, with the value of next_, it is safe to read next
  // because of the same logic as when a thread was preempted
  //
  // we also need to collect this sleeper in the list of sleepers being built
  // up
  auto next = (*waiter)->next_;
  (*waiter)->next_ = reinterpret_cast<std::uintptr_t>(sleepers);
  sleepers = waiter;
  return next;
}

template<typename Waiter >

bool folly::detail::distributed_mutex::wait	(	Waiter *	waiter,
		bool	shouldSleep,
		Waiter *&	next
	)

Definition at line 429 of file DistributedMutex-inl.h.

References doFutexWait(), and spin().

Referenced by burn(), MultiFilePollerTest::delayedWrite(), folly::detail::distributed_mutex::DistributedMutex< Atomic, TimePublishing >::lock(), folly::Future< folly::folly::Unit >::onError(), folly::Subprocess::readChildErrorPipe(), folly::Subprocess::returnCode(), folly::SemiFuture< T >::SemiFuture(), folly::Subprocess::spawn(), TEST(), TEST_F(), testTryReadUntil(), testTryWriteUntil(), and folly::Subprocess::waitChecked().

                                                           {
  if (shouldSleep) {
    return doFutexWait(waiter, next);
  }

  return spin(**waiter);
}

template<typename Waiter >

bool folly::detail::distributed_mutex::wake	(	bool	publishing,
		Waiter &	waiter,
		WakerMetadata	metadata,
		Waiter *&	sleepers
	)

Definition at line 642 of file DistributedMutex-inl.h.

References current, cpp.ast::next(), tryWake(), folly::value(), and folly::detail::distributed_mutex::WakerMetadata::waker_.

Referenced by folly::detail::distributed_mutex::DistributedMutex< Atomic, TimePublishing >::unlock().

                       {
  // loop till we find a node that is either at the end of the list (as
  // specified by metadata) or we find a node that is active (as specified by
  // the last published timestamp of the node)
  auto current = &waiter;
  while (current) {
    auto value = (*current)->futex_.load(std::memory_order_acquire);
    auto next = tryWake(publishing, current, value, metadata, sleepers);
    if (!next) {
      return true;
    }

    // we need to read the value of the next node in the list before skipping
    // it, this is because after we skip it the node might wake up and enqueue
    // itself, and thereby gain a new next node
    CHECK(publishing);
    current =
        (next == metadata.waker_) ? nullptr : extractAddress<Waiter>(next);
  }

  return false;
}

template<typename Atomic >

void folly::detail::distributed_mutex::wakeTimedWaiters	(	Atomic *	state,
		bool	timedWaiters
	)

Definition at line 670 of file DistributedMutex-inl.h.

References folly::atomic_notify_one(), and UNLIKELY.

Referenced by folly::detail::distributed_mutex::DistributedMutex< Atomic, TimePublishing >::unlock().

                                                        {
  if (UNLIKELY(timedWaiters)) {
    atomic_notify_one(state);
  }
}

Variable Documentation

constexpr auto folly::detail::distributed_mutex::kAboutToWait = std::uint32_t{0b100}

Definition at line 88 of file DistributedMutex-inl.h.

Referenced by doFutexWait(), and folly::detail::distributed_mutex::DistributedMutex< Atomic, TimePublishing >::lock().

constexpr auto folly::detail::distributed_mutex::kLocked = std::uintptr_t{0b1}

Definition at line 54 of file DistributedMutex-inl.h.

Referenced by folly::detail::distributed_mutex::DistributedMutex< Atomic, TimePublishing >::lock(), timedLock(), and folly::detail::distributed_mutex::DistributedMutex< Atomic, TimePublishing >::unlock().

constexpr auto folly::detail::distributed_mutex::kMaxSpins = 4000

Definition at line 116 of file DistributedMutex-inl.h.

Referenced by spin().

constexpr auto folly::detail::distributed_mutex::kScheduledAwaySpinThreshold = std::chrono::nanoseconds{200}

Definition at line 113 of file DistributedMutex-inl.h.

constexpr auto folly::detail::distributed_mutex::kSkipped = std::uint32_t{0b11}

Definition at line 85 of file DistributedMutex-inl.h.

Referenced by spin().

constexpr auto folly::detail::distributed_mutex::kSleeping = std::uint32_t{0b101}

Definition at line 107 of file DistributedMutex-inl.h.

constexpr auto folly::detail::distributed_mutex::kTimedWaiter = std::uintptr_t{0b10}

Definition at line 68 of file DistributedMutex-inl.h.

constexpr auto folly::detail::distributed_mutex::kUninitialized = std::uint32_t{0b0}

Definition at line 76 of file DistributedMutex-inl.h.

Referenced by folly::detail::distributed_mutex::DistributedMutex< Atomic, TimePublishing >::lock(), and preempted().

constexpr auto folly::detail::distributed_mutex::kUnlocked = std::uintptr_t{0b0}

Definition at line 47 of file DistributedMutex-inl.h.

constexpr auto folly::detail::distributed_mutex::kWaiting = std::uint32_t{0b1}

Definition at line 79 of file DistributedMutex-inl.h.

Referenced by spin().

constexpr auto folly::detail::distributed_mutex::kWake = std::uint32_t{0b10}

Definition at line 81 of file DistributedMutex-inl.h.