folly::MicroLockBase< MaxSpins, MaxYields > Class Template Reference

#include <MicroLock.h>

Inheritance diagram for folly::MicroLockBase< MaxSpins, MaxYields >:

Public Member Functions
void	lock (unsigned slot)
void	lock ()
bool	try_lock (unsigned slot)
bool	try_lock ()
Public Member Functions inherited from folly::MicroLockCore
void	unlock (unsigned slot)
void	unlock ()
void	init ()

Additional Inherited Members
Protected Member Functions inherited from folly::MicroLockCore
detail::Futex *	word () const
uint32_t	baseShift (unsigned slot) const
uint32_t	heldBit (unsigned slot) const
uint32_t	waitBit (unsigned slot) const
Static Protected Member Functions inherited from folly::MicroLockCore
static void	lockSlowPath (uint32_t oldWord, detail::Futex<> *wordPtr, uint32_t slotHeldBit, unsigned maxSpins, unsigned maxYields)
Protected Attributes inherited from folly::MicroLockCore
uint8_t	lock_

Detailed Description

template<unsigned MaxSpins = 1000, unsigned MaxYields = 0>
class folly::MicroLockBase< MaxSpins, MaxYields >

Definition at line 170 of file MicroLock.h.

Member Function Documentation

template<unsigned MaxSpins, unsigned MaxYields>

void folly::MicroLockBase< MaxSpins, MaxYields >::lock ( unsigned  slot )

inline

Definition at line 210 of file MicroLock.h.

References folly::MicroLockCore::heldBit(), folly::MicroLockCore::lockSlowPath(), uint32_t, folly::MicroLockCore::waitBit(), and folly::MicroLockCore::word().

                                                           {
  static_assert(MaxSpins + MaxYields < (unsigned)-1, "overflow");

  detail::Futex<>* wordPtr = word();
  uint32_t oldWord;
  oldWord = wordPtr->load(std::memory_order_relaxed);
  if ((oldWord & heldBit(slot)) == 0 &&
      wordPtr->compare_exchange_weak(
          oldWord,
          oldWord | heldBit(slot),
          std::memory_order_acquire,
          std::memory_order_relaxed)) {
    // Fast uncontended case: memory_order_acquire above is our barrier
  } else {
    // lockSlowPath doesn't have any slot-dependent computation; it
    // just shifts the input bit.  Make sure its shifting produces the
    // same result a call to waitBit for our slot would.
    assert(heldBit(slot) << 1 == waitBit(slot));
    // lockSlowPath emits its own memory barrier
    lockSlowPath(oldWord, wordPtr, heldBit(slot), MaxSpins, MaxYields);
  }
}

template<unsigned MaxSpins = 1000, unsigned MaxYields = 0>

void folly::MicroLockBase< MaxSpins, MaxYields >::lock ( )

inline

Definition at line 173 of file MicroLock.h.

References folly::lock(), and NO_SANITIZE_ADDRESS.

                     {
    lock(0);
  }

template<unsigned MaxSpins, unsigned MaxYields>

bool folly::MicroLockBase< MaxSpins, MaxYields >::try_lock ( unsigned  slot )

inline

Definition at line 183 of file MicroLock.h.

References folly::MicroLockCore::heldBit(), uint32_t, and folly::MicroLockCore::word().

                                                               {
  // N.B. You might think that try_lock is just the fast path of lock,
  // but you'd be wrong.  Keep in mind that other parts of our host
  // word might be changing while we take the lock!  We're not allowed
  // to fail spuriously if the lock is in fact not held, even if other
  // people are concurrently modifying other parts of the word.
  //
  // We need to loop until we either see firm evidence that somebody
  // else has the lock (by looking at heldBit) or see our CAS succeed.
  // A failed CAS by itself does not indicate lock-acquire failure.

  detail::Futex<>* wordPtr = word();
  uint32_t oldWord = wordPtr->load(std::memory_order_relaxed);
  do {
    if (oldWord & heldBit(slot)) {
      return false;
    }
  } while (!wordPtr->compare_exchange_weak(
      oldWord,
      oldWord | heldBit(slot),
      std::memory_order_acquire,
      std::memory_order_relaxed));

  return true;
}

template<unsigned MaxSpins = 1000, unsigned MaxYields = 0>

bool folly::MicroLockBase< MaxSpins, MaxYields >::try_lock ( )

inline

Definition at line 177 of file MicroLock.h.

                         {
    return try_lock(0);
  }

---

The documentation for this class was generated from the following file:

• proxygen/folly/folly/MicroLock.h