folly::fibers::TimedRWMutex< BatonType > Class Template Reference

#include <TimedMutex.h>

Classes
struct	MutexWaiter
class	ReadHolder
class	WriteHolder

Public Member Functions
	TimedRWMutex ()=default
	~TimedRWMutex ()=default
	TimedRWMutex (const TimedRWMutex &rhs)=delete
TimedRWMutex &	operator= (const TimedRWMutex &rhs)=delete
	TimedRWMutex (TimedRWMutex &&rhs)=delete
TimedRWMutex &	operator= (TimedRWMutex &&rhs)=delete
void	read_lock ()
template<typename Rep , typename Period >
bool	timed_read_lock (const std::chrono::duration< Rep, Period > &duration)
bool	try_read_lock ()
void	write_lock ()
template<typename Rep , typename Period >
bool	timed_write_lock (const std::chrono::duration< Rep, Period > &duration)
bool	try_write_lock ()
void	lock ()
void	unlock ()
void	downgrade ()

Private Types
enum	State { State::UNLOCKED, State::READ_LOCKED, State::WRITE_LOCKED }
typedef boost::intrusive::list_member_hook	MutexWaiterHookType
typedef boost::intrusive::member_hook< MutexWaiter, MutexWaiterHookType,&MutexWaiter::hook >	MutexWaiterHook
typedef boost::intrusive::list< MutexWaiter, MutexWaiterHook, boost::intrusive::constant_time_size< true > >	MutexWaiterList

Private Member Functions
void	verify_unlocked_properties ()

Private Attributes
folly::SpinLock	lock_
State	state_ = State::UNLOCKED
uint32_t	readers_ = 0
MutexWaiterList	write_waiters_
MutexWaiterList	read_waiters_

Detailed Description

template<typename BatonType>
class folly::fibers::TimedRWMutex< BatonType >

A readers-writer lock which allows multiple readers to hold the lock simultaneously or only one writer.

NOTE: This is a reader-preferred RWLock i.e. readers are give priority when there are both readers and writers waiting to get the lock.

Definition at line 92 of file TimedMutex.h.

Member Typedef Documentation

template<typename BatonType >

typedef boost::intrusive:: member_hook<MutexWaiter, MutexWaiterHookType, &MutexWaiter::hook> folly::fibers::TimedRWMutex< BatonType >::MutexWaiterHook

private

Definition at line 211 of file TimedMutex.h.

template<typename BatonType >

typedef boost::intrusive::list_member_hook folly::fibers::TimedRWMutex< BatonType >::MutexWaiterHookType

private

Definition at line 201 of file TimedMutex.h.

template<typename BatonType >

typedef boost::intrusive::list< MutexWaiter, MutexWaiterHook, boost::intrusive::constant_time_size<true> > folly::fibers::TimedRWMutex< BatonType >::MutexWaiterList

private

Definition at line 217 of file TimedMutex.h.

Member Enumeration Documentation

template<typename BatonType >

enum folly::fibers::TimedRWMutex::State

strongprivate

Enumerator
UNLOCKED
READ_LOCKED
WRITE_LOCKED

Definition at line 195 of file TimedMutex.h.

                   {
    UNLOCKED,
    READ_LOCKED,
    WRITE_LOCKED,
  };

Constructor & Destructor Documentation

template<typename BatonType >

folly::fibers::TimedRWMutex< BatonType >::TimedRWMutex ( )

default

template<typename BatonType >

folly::fibers::TimedRWMutex< BatonType >::~TimedRWMutex ( )

default

template<typename BatonType >

folly::fibers::TimedRWMutex< BatonType >::TimedRWMutex ( const TimedRWMutex< BatonType > &  rhs )

delete

template<typename BatonType >

folly::fibers::TimedRWMutex< BatonType >::TimedRWMutex ( TimedRWMutex< BatonType > &&  rhs )

delete

Member Function Documentation

template<typename BatonType >

void folly::fibers::TimedRWMutex< BatonType >::downgrade

(

)

Definition at line 320 of file TimedMutex-inl.h.

References folly::fibers::TimedRWMutex< BatonType >::MutexWaiter::baton, folly::gen::guard(), and folly::fibers::TimedMutex::lock_.

                                        {
  std::lock_guard<SpinLock> guard{lock_};
  assert(state_ == State::WRITE_LOCKED && readers_ == 0);
  state_ = State::READ_LOCKED;
  readers_ += 1;

  if (!read_waiters_.empty()) {
    readers_ += read_waiters_.size();

    while (!read_waiters_.empty()) {
      MutexWaiter& to_wake = read_waiters_.front();
      read_waiters_.pop_front();
      to_wake.baton.post();
    }
  }
}

template<typename BatonType >

void folly::fibers::TimedRWMutex< BatonType >::lock ( )

inline

Definition at line 131 of file TimedMutex.h.

References folly::fibers::TimedMutex::unlock().

              {
    write_lock();
  }

template<typename BatonType >

TimedRWMutex& folly::fibers::TimedRWMutex< BatonType >::operator= ( const TimedRWMutex< BatonType > &  rhs )

delete

template<typename BatonType >

TimedRWMutex& folly::fibers::TimedRWMutex< BatonType >::operator= ( TimedRWMutex< BatonType > &&  rhs )

delete

template<typename BatonType >

void folly::fibers::TimedRWMutex< BatonType >::read_lock

(

)

Definition at line 157 of file TimedMutex-inl.h.

References folly::fibers::TimedRWMutex< BatonType >::MutexWaiter::baton, folly::fibers::TimedMutex::lock_, and folly::ulock().

                                        {
  std::unique_lock<folly::SpinLock> ulock{lock_};
  if (state_ == State::WRITE_LOCKED) {
    MutexWaiter waiter;
    read_waiters_.push_back(waiter);
    ulock.unlock();
    waiter.baton.wait();
    assert(state_ == State::READ_LOCKED);
    return;
  }
  assert(
      (state_ == State::UNLOCKED && readers_ == 0) ||
      (state_ == State::READ_LOCKED && readers_ > 0));
  assert(read_waiters_.empty());
  state_ = State::READ_LOCKED;
  readers_ += 1;
}

template<typename BatonType >

template<typename Rep , typename Period >

bool folly::fibers::TimedRWMutex< BatonType >::timed_read_lock

(

const std::chrono::duration< Rep, Period > &

duration

)

Definition at line 177 of file TimedMutex-inl.h.

References folly::fibers::TimedRWMutex< BatonType >::MutexWaiter::baton, folly::gen::guard(), folly::fibers::TimedRWMutex< BatonType >::MutexWaiter::hook, folly::fibers::TimedMutex::lock_, and folly::ulock().

                                                    {
  std::unique_lock<folly::SpinLock> ulock{lock_};
  if (state_ == State::WRITE_LOCKED) {
    MutexWaiter waiter;
    read_waiters_.push_back(waiter);
    ulock.unlock();

    if (!waiter.baton.try_wait_for(duration)) {
      // We timed out. Two cases:
      // 1. We're still in the waiter list and we truly timed out
      // 2. We're not in the waiter list anymore. This could happen if the baton
      //    times out but the mutex is unlocked before we reach this code. In
      //    this case we'll pretend we got the lock on time.
      std::lock_guard<SpinLock> guard{lock_};
      if (waiter.hook.is_linked()) {
        read_waiters_.erase(read_waiters_.iterator_to(waiter));
        return false;
      }
    }
    return true;
  }
  assert(
      (state_ == State::UNLOCKED && readers_ == 0) ||
      (state_ == State::READ_LOCKED && readers_ > 0));
  assert(read_waiters_.empty());
  state_ = State::READ_LOCKED;
  readers_ += 1;
  return true;
}

template<typename BatonType >

template<typename Rep , typename Period >

bool folly::fibers::TimedRWMutex< BatonType >::timed_write_lock

(

const std::chrono::duration< Rep, Period > &

duration

)

Definition at line 239 of file TimedMutex-inl.h.

References folly::fibers::TimedRWMutex< BatonType >::MutexWaiter::baton, folly::gen::guard(), folly::fibers::TimedRWMutex< BatonType >::MutexWaiter::hook, folly::fibers::TimedMutex::lock_, and folly::ulock().

                                                    {
  std::unique_lock<folly::SpinLock> ulock{lock_};
  if (state_ == State::UNLOCKED) {
    verify_unlocked_properties();
    state_ = State::WRITE_LOCKED;
    return true;
  }
  MutexWaiter waiter;
  write_waiters_.push_back(waiter);
  ulock.unlock();

  if (!waiter.baton.try_wait_for(duration)) {
    // We timed out. Two cases:
    // 1. We're still in the waiter list and we truly timed out
    // 2. We're not in the waiter list anymore. This could happen if the baton
    //    times out but the mutex is unlocked before we reach this code. In
    //    this case we'll pretend we got the lock on time.
    std::lock_guard<SpinLock> guard{lock_};
    if (waiter.hook.is_linked()) {
      write_waiters_.erase(write_waiters_.iterator_to(waiter));
      return false;
    }
  }
  assert(state_ == State::WRITE_LOCKED);
  return true;
}

template<typename BatonType >

bool folly::fibers::TimedRWMutex< BatonType >::try_read_lock

(

)

Definition at line 209 of file TimedMutex-inl.h.

References folly::gen::guard(), and folly::fibers::TimedMutex::lock_.

                                            {
  std::lock_guard<SpinLock> guard{lock_};
  if (state_ != State::WRITE_LOCKED) {
    assert(
        (state_ == State::UNLOCKED && readers_ == 0) ||
        (state_ == State::READ_LOCKED && readers_ > 0));
    assert(read_waiters_.empty());
    state_ = State::READ_LOCKED;
    readers_ += 1;
    return true;
  }
  return false;
}

template<typename BatonType >

bool folly::fibers::TimedRWMutex< BatonType >::try_write_lock

(

)

Definition at line 268 of file TimedMutex-inl.h.

References folly::gen::guard(), and folly::fibers::TimedMutex::lock_.

                                             {
  std::lock_guard<SpinLock> guard{lock_};
  if (state_ == State::UNLOCKED) {
    verify_unlocked_properties();
    state_ = State::WRITE_LOCKED;
    return true;
  }
  return false;
}

template<typename BatonType >

void folly::fibers::TimedRWMutex< BatonType >::unlock

(

)

Definition at line 279 of file TimedMutex-inl.h.

References folly::fibers::TimedRWMutex< BatonType >::MutexWaiter::baton, folly::gen::guard(), and folly::fibers::TimedMutex::lock_.

                                     {
  std::lock_guard<SpinLock> guard{lock_};
  assert(state_ != State::UNLOCKED);
  assert(
      (state_ == State::READ_LOCKED && readers_ > 0) ||
      (state_ == State::WRITE_LOCKED && readers_ == 0));
  if (state_ == State::READ_LOCKED) {
    readers_ -= 1;
  }

  if (!read_waiters_.empty()) {
    assert(
        state_ == State::WRITE_LOCKED && readers_ == 0 &&
        "read waiters can only accumulate while write locked");
    state_ = State::READ_LOCKED;
    readers_ = read_waiters_.size();

    while (!read_waiters_.empty()) {
      MutexWaiter& to_wake = read_waiters_.front();
      read_waiters_.pop_front();
      to_wake.baton.post();
    }
  } else if (readers_ == 0) {
    if (!write_waiters_.empty()) {
      assert(read_waiters_.empty());
      state_ = State::WRITE_LOCKED;

      // Wake a single writer (after releasing the spin lock)
      MutexWaiter& to_wake = write_waiters_.front();
      write_waiters_.pop_front();
      to_wake.baton.post();
    } else {
      verify_unlocked_properties();
      state_ = State::UNLOCKED;
    }
  } else {
    assert(state_ == State::READ_LOCKED);
  }
}

template<typename BatonType >

void folly::fibers::TimedRWMutex< BatonType >::verify_unlocked_properties ( )

inlineprivate

Definition at line 188 of file TimedMutex.h.

                                    {
    assert(readers_ == 0);
    assert(read_waiters_.empty());
    assert(write_waiters_.empty());
  }

template<typename BatonType >

void folly::fibers::TimedRWMutex< BatonType >::write_lock

(

)

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

References folly::fibers::TimedRWMutex< BatonType >::MutexWaiter::baton, folly::fibers::TimedMutex::lock_, and folly::ulock().

                                         {
  std::unique_lock<folly::SpinLock> ulock{lock_};
  if (state_ == State::UNLOCKED) {
    verify_unlocked_properties();
    state_ = State::WRITE_LOCKED;
    return;
  }
  MutexWaiter waiter;
  write_waiters_.push_back(waiter);
  ulock.unlock();
  waiter.baton.wait();
}

Member Data Documentation

template<typename BatonType >

folly::SpinLock folly::fibers::TimedRWMutex< BatonType >::lock_

private

Definition at line 219 of file TimedMutex.h.

template<typename BatonType >

MutexWaiterList folly::fibers::TimedRWMutex< BatonType >::read_waiters_

private

Definition at line 228 of file TimedMutex.h.

template<typename BatonType >

uint32_t folly::fibers::TimedRWMutex< BatonType >::readers_ = 0

private

Definition at line 223 of file TimedMutex.h.

template<typename BatonType >

State folly::fibers::TimedRWMutex< BatonType >::state_ = State::UNLOCKED

private

Definition at line 221 of file TimedMutex.h.

template<typename BatonType >

MutexWaiterList folly::fibers::TimedRWMutex< BatonType >::write_waiters_

private

Definition at line 225 of file TimedMutex.h.

---

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

• proxygen/folly/folly/fibers/TimedMutex.h
• proxygen/folly/folly/fibers/TimedMutex-inl.h