folly::RWSpinLock Class Reference

#include <RWSpinLock.h>

Classes
class	ReadHolder
class	UpgradedHolder
class	WriteHolder

Public Member Functions
constexpr	RWSpinLock ()
	RWSpinLock (RWSpinLock const &)=delete
RWSpinLock &	operator= (RWSpinLock const &)=delete
void	lock ()
void	unlock ()
void	lock_shared ()
void	unlock_shared ()
void	unlock_and_lock_shared ()
void	lock_upgrade ()
void	unlock_upgrade ()
void	unlock_upgrade_and_lock ()
void	unlock_upgrade_and_lock_shared ()
void	unlock_and_lock_upgrade ()
bool	try_lock ()
bool	try_lock_shared ()
bool	try_unlock_upgrade_and_lock ()
bool	try_lock_upgrade ()
int32_t	bits () const

Private Types
enum	: int32_t { READER = 4, UPGRADED = 2, WRITER = 1 }

Private Attributes
std::atomic< int32_t >	bits_

Detailed Description

Definition at line 181 of file RWSpinLock.h.

Member Enumeration Documentation

anonymous enum : int32_t

private

Enumerator
READER
UPGRADED
WRITER

Definition at line 182 of file RWSpinLock.h.

: int32_t { READER = 4, UPGRADED = 2, WRITER = 1 };

Constructor & Destructor Documentation

constexpr folly::RWSpinLock::RWSpinLock ( )

inline

Definition at line 185 of file RWSpinLock.h.

References operator=().

: bits_(0) {}

folly::RWSpinLock::RWSpinLock ( RWSpinLock const &  )

delete

Member Function Documentation

int32_t folly::RWSpinLock::bits ( ) const

inline

Definition at line 306 of file RWSpinLock.h.

References bits_.

                       {
    return bits_.load(std::memory_order_acquire);
  }

void folly::RWSpinLock::lock ( )

inline

Definition at line 191 of file RWSpinLock.h.

References count, LIKELY, try_lock(), and folly::fibers::yield().

Referenced by folly::RWSpinLock::ReadHolder::reset(), folly::RWSpinLock::UpgradedHolder::reset(), folly::RWSpinLock::WriteHolder::reset(), and folly::RWSpinLock::WriteHolder::WriteHolder().

              {
    uint_fast32_t count = 0;
    while (!LIKELY(try_lock())) {
      if (++count > 1000) {
        std::this_thread::yield();
      }
    }
  }

void folly::RWSpinLock::lock_shared ( )

inline

Definition at line 207 of file RWSpinLock.h.

References count, LIKELY, try_lock_shared(), and folly::fibers::yield().

Referenced by folly::RWSpinLock::ReadHolder::ReadHolder(), and folly::RWSpinLock::ReadHolder::reset().

                     {
    uint_fast32_t count = 0;
    while (!LIKELY(try_lock_shared())) {
      if (++count > 1000) {
        std::this_thread::yield();
      }
    }
  }

void folly::RWSpinLock::lock_upgrade ( )

inline

Definition at line 227 of file RWSpinLock.h.

References count, try_lock_upgrade(), and folly::fibers::yield().

Referenced by folly::RWSpinLock::UpgradedHolder::reset(), and folly::RWSpinLock::UpgradedHolder::UpgradedHolder().

                      {
    uint_fast32_t count = 0;
    while (!try_lock_upgrade()) {
      if (++count > 1000) {
        std::this_thread::yield();
      }
    }
  }

RWSpinLock& folly::RWSpinLock::operator= ( RWSpinLock const &  )

delete

Referenced by RWSpinLock().

bool folly::RWSpinLock::try_lock ( )

inline

Definition at line 264 of file RWSpinLock.h.

References bits_, folly::symbolizer::test::expect(), int32_t, and WRITER.

Referenced by lock().

                  {
    int32_t expect = 0;
    return bits_.compare_exchange_strong(
        expect, WRITER, std::memory_order_acq_rel);
  }

bool folly::RWSpinLock::try_lock_shared ( )

inline

Definition at line 276 of file RWSpinLock.h.

References bits_, int32_t, READER, UNLIKELY, UPGRADED, folly::value(), and WRITER.

Referenced by lock_shared().

                         {
    // fetch_add is considerably (100%) faster than compare_exchange,
    // so here we are optimizing for the common (lock success) case.
    int32_t value = bits_.fetch_add(READER, std::memory_order_acquire);
    if (UNLIKELY(value & (WRITER | UPGRADED))) {
      bits_.fetch_add(-READER, std::memory_order_release);
      return false;
    }
    return true;
  }

bool folly::RWSpinLock::try_lock_upgrade ( )

inline

Definition at line 295 of file RWSpinLock.h.

References bits_, int32_t, UPGRADED, folly::value(), and WRITER.

Referenced by lock_upgrade().

                          {
    int32_t value = bits_.fetch_or(UPGRADED, std::memory_order_acquire);

    // Note: when failed, we cannot flip the UPGRADED bit back,
    // as in this case there is either another upgrade lock or a write lock.
    // If it's a write lock, the bit will get cleared up when that lock's done
    // with unlock().
    return ((value & (UPGRADED | WRITER)) == 0);
  }

bool folly::RWSpinLock::try_unlock_upgrade_and_lock ( )

inline

Definition at line 288 of file RWSpinLock.h.

References bits_, folly::symbolizer::test::expect(), int32_t, UPGRADED, and WRITER.

Referenced by unlock_upgrade_and_lock().

                                     {
    int32_t expect = UPGRADED;
    return bits_.compare_exchange_strong(
        expect, WRITER, std::memory_order_acq_rel);
  }

void folly::RWSpinLock::unlock ( )

inline

Definition at line 201 of file RWSpinLock.h.

References bits_, READER, UPGRADED, and WRITER.

Referenced by folly::RWSpinLock::WriteHolder::reset(), unlock_and_lock_shared(), and folly::RWSpinLock::WriteHolder::~WriteHolder().

                {
    static_assert(READER > WRITER + UPGRADED, "wrong bits!");
    bits_.fetch_and(~(WRITER | UPGRADED), std::memory_order_release);
  }

void folly::RWSpinLock::unlock_and_lock_shared ( )

inline

Definition at line 221 of file RWSpinLock.h.

References bits_, READER, and unlock().

Referenced by folly::RWSpinLock::ReadHolder::ReadHolder().

                                {
    bits_.fetch_add(READER, std::memory_order_acquire);
    unlock();
  }

void folly::RWSpinLock::unlock_and_lock_upgrade ( )

inline

Definition at line 256 of file RWSpinLock.h.

References bits_, UPGRADED, and WRITER.

Referenced by folly::RWSpinLock::UpgradedHolder::UpgradedHolder().

                                 {
    // need to do it in two steps here -- as the UPGRADED bit might be OR-ed at
    // the same time when other threads are trying do try_lock_upgrade().
    bits_.fetch_or(UPGRADED, std::memory_order_acquire);
    bits_.fetch_add(-WRITER, std::memory_order_release);
  }

void folly::RWSpinLock::unlock_shared ( )

inline

Definition at line 216 of file RWSpinLock.h.

References bits_, and READER.

Referenced by folly::RWSpinLock::ReadHolder::reset(), and folly::RWSpinLock::ReadHolder::~ReadHolder().

                       {
    bits_.fetch_add(-READER, std::memory_order_release);
  }

void folly::RWSpinLock::unlock_upgrade ( )

inline

Definition at line 236 of file RWSpinLock.h.

References bits_, and UPGRADED.

Referenced by folly::RWSpinLock::UpgradedHolder::reset(), and folly::RWSpinLock::UpgradedHolder::~UpgradedHolder().

                        {
    bits_.fetch_add(-UPGRADED, std::memory_order_acq_rel);
  }

void folly::RWSpinLock::unlock_upgrade_and_lock ( )

inline

Definition at line 241 of file RWSpinLock.h.

References count, int64_t, try_unlock_upgrade_and_lock(), and folly::fibers::yield().

Referenced by folly::RWSpinLock::WriteHolder::WriteHolder().

                                 {
    int64_t count = 0;
    while (!try_unlock_upgrade_and_lock()) {
      if (++count > 1000) {
        std::this_thread::yield();
      }
    }
  }

void folly::RWSpinLock::unlock_upgrade_and_lock_shared ( )

inline

Definition at line 251 of file RWSpinLock.h.

References bits_, READER, and UPGRADED.

Referenced by folly::RWSpinLock::ReadHolder::ReadHolder().

                                        {
    bits_.fetch_add(READER - UPGRADED, std::memory_order_acq_rel);
  }

Member Data Documentation

std::atomic<int32_t> folly::RWSpinLock::bits_

private

Definition at line 511 of file RWSpinLock.h.

Referenced by bits(), try_lock(), try_lock_shared(), try_lock_upgrade(), try_unlock_upgrade_and_lock(), unlock(), unlock_and_lock_shared(), unlock_and_lock_upgrade(), unlock_shared(), unlock_upgrade(), and unlock_upgrade_and_lock_shared().

---

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

• proxygen/folly/folly/synchronization/RWSpinLock.h