folly::fibers::TimedMutex Class Reference

#include <TimedMutex.h>

Classes
struct	MutexWaiter

Public Member Functions
	TimedMutex () noexcept
	~TimedMutex ()
	TimedMutex (const TimedMutex &rhs)=delete
TimedMutex &	operator= (const TimedMutex &rhs)=delete
	TimedMutex (TimedMutex &&rhs)=delete
TimedMutex &	operator= (TimedMutex &&rhs)=delete
void	lock ()
template<typename Rep , typename Period >
bool	timed_lock (const std::chrono::duration< Rep, Period > &duration)
bool	try_lock ()
void	unlock ()

Private Types
enum	LockResult { LockResult::SUCCESS, LockResult::TIMEOUT, LockResult::STOLEN }
using	MutexWaiterList = folly::IntrusiveList< MutexWaiter,&MutexWaiter::hook >

Private Member Functions
template<typename WaitFunc >
LockResult	lockHelper (WaitFunc &&waitFunc)

Private Attributes
folly::SpinLock	lock_
bool	locked_ = false
MutexWaiterList	threadWaiters_
MutexWaiterList	fiberWaiters_
MutexWaiter *	notifiedFiber_ {nullptr}

Detailed Description

Like mutex but allows timed_lock in addition to lock and try_lock.

Definition at line 30 of file TimedMutex.h.

Member Typedef Documentation

using folly::fibers::TimedMutex::MutexWaiterList = folly::IntrusiveList<MutexWaiter, &MutexWaiter::hook>

private

Definition at line 73 of file TimedMutex.h.

Member Enumeration Documentation

enum folly::fibers::TimedMutex::LockResult

strongprivate

Enumerator
SUCCESS
TIMEOUT
STOLEN

Definition at line 61 of file TimedMutex.h.

{ SUCCESS, TIMEOUT, STOLEN };

Constructor & Destructor Documentation

folly::fibers::TimedMutex::TimedMutex ( )

inlinenoexcept

Definition at line 32 of file TimedMutex.h.

Referenced by ~TimedMutex().

{}

folly::fibers::TimedMutex::~TimedMutex ( )

inline

Definition at line 34 of file TimedMutex.h.

References fiberWaiters_, lock(), notifiedFiber_, operator=(), folly::detail::rhs, threadWaiters_, timed_lock(), TimedMutex(), try_lock(), and unlock().

                {
    DCHECK(threadWaiters_.empty());
    DCHECK(fiberWaiters_.empty());
    DCHECK(notifiedFiber_ == nullptr);
  }

folly::fibers::TimedMutex::TimedMutex ( const TimedMutex &  rhs )

delete

folly::fibers::TimedMutex::TimedMutex ( TimedMutex &&  rhs )

delete

Member Function Documentation

void folly::fibers::TimedMutex::lock ( )

inline

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

References folly::fibers::TimedMutex::MutexWaiter::baton, lockHelper(), SUCCESS, TIMEOUT, and folly::fibers::Baton::wait().

Referenced by TEST(), timed_lock(), and ~TimedMutex().

                             {
  auto result = lockHelper([](MutexWaiter& waiter) {
    waiter.baton.wait();
    return true;
  });

  DCHECK(result != LockResult::TIMEOUT);
  if (result == LockResult::SUCCESS) {
    return;
  }
  lock();
}

template<typename WaitFunc >

TimedMutex::LockResult folly::fibers::TimedMutex::lockHelper ( WaitFunc &&  waitFunc )

private

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

References fiberWaiters_, lock_, locked_, notifiedFiber_, folly::fibers::onFiber(), STOLEN, SUCCESS, threadWaiters_, TIMEOUT, and folly::ulock().

Referenced by lock(), and timed_lock().

                                                               {
  std::unique_lock<folly::SpinLock> ulock(lock_);
  if (!locked_) {
    locked_ = true;
    return LockResult::SUCCESS;
  }

  const auto isOnFiber = onFiber();

  if (!isOnFiber && notifiedFiber_ != nullptr) {
    // lock() was called on a thread and while some other fiber was already
    // notified, it hasn't be run yet. We steal the lock from that fiber then
    // to avoid potential deadlock.
    DCHECK(threadWaiters_.empty());
    notifiedFiber_ = nullptr;
    return LockResult::SUCCESS;
  }

  // Delay constructing the waiter until it is actually required.
  // This makes a huge difference, at least in the benchmarks,
  // when the mutex isn't locked.
  MutexWaiter waiter;
  if (isOnFiber) {
    fiberWaiters_.push_back(waiter);
  } else {
    threadWaiters_.push_back(waiter);
  }

  ulock.unlock();

  if (!waitFunc(waiter)) {
    return LockResult::TIMEOUT;
  }

  if (isOnFiber) {
    auto lockStolen = [&] {
      std::lock_guard<folly::SpinLock> lg(lock_);

      auto stolen = notifiedFiber_ != &waiter;
      if (!stolen) {
        notifiedFiber_ = nullptr;
      }
      return stolen;
    }();

    if (lockStolen) {
      return LockResult::STOLEN;
    }
  }

  return LockResult::SUCCESS;
}

TimedMutex& folly::fibers::TimedMutex::operator= ( const TimedMutex &  rhs )

delete

Referenced by folly::fibers::TimedRWMutex< BatonType >::ReadHolder::~ReadHolder(), ~TimedMutex(), and folly::fibers::TimedRWMutex< BatonType >::WriteHolder::~WriteHolder().

TimedMutex& folly::fibers::TimedMutex::operator= ( TimedMutex &&  rhs )

delete

template<typename Rep , typename Period >

bool folly::fibers::TimedMutex::timed_lock

(

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

duration

)

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

References folly::assume_unreachable(), folly::fibers::TimedMutex::MutexWaiter::baton, folly::fibers::TimedMutex::MutexWaiter::hook, lock(), lock_, lockHelper(), STOLEN, SUCCESS, TIMEOUT, and folly::fibers::Baton::try_wait_for().

Referenced by TEST(), and ~TimedMutex().

                                                    {
  auto result = lockHelper([&](MutexWaiter& waiter) {
    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<folly::SpinLock> lg(lock_);
      if (waiter.hook.is_linked()) {
        waiter.hook.unlink();
        return false;
      }
    }
    return true;
  });

  switch (result) {
    case LockResult::SUCCESS:
      return true;
    case LockResult::TIMEOUT:
      return false;
    case LockResult::STOLEN:
      // We don't respect the duration if lock was stolen
      lock();
      return true;
  }
  assume_unreachable();
}

bool folly::fibers::TimedMutex::try_lock ( )

inline

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

References lock_, and locked_.

Referenced by ~TimedMutex().

                                 {
  std::lock_guard<folly::SpinLock> lg(lock_);
  if (locked_) {
    return false;
  }
  locked_ = true;
  return true;
}

void folly::fibers::TimedMutex::unlock ( )

inline

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

References folly::fibers::TimedMutex::MutexWaiter::baton, fiberWaiters_, lock_, locked_, notifiedFiber_, folly::fibers::Baton::post(), and threadWaiters_.

Referenced by folly::fibers::TimedRWMutex< BatonType >::lock(), TEST(), and ~TimedMutex().

                               {
  std::lock_guard<folly::SpinLock> lg(lock_);
  if (!threadWaiters_.empty()) {
    auto& to_wake = threadWaiters_.front();
    threadWaiters_.pop_front();
    to_wake.baton.post();
  } else if (!fiberWaiters_.empty()) {
    auto& to_wake = fiberWaiters_.front();
    fiberWaiters_.pop_front();
    notifiedFiber_ = &to_wake;
    to_wake.baton.post();
  } else {
    locked_ = false;
  }
}

Member Data Documentation

MutexWaiterList folly::fibers::TimedMutex::fiberWaiters_

private

Definition at line 78 of file TimedMutex.h.

Referenced by lockHelper(), unlock(), and ~TimedMutex().

folly::SpinLock folly::fibers::TimedMutex::lock_

private

Definition at line 75 of file TimedMutex.h.

Referenced by folly::fibers::TimedRWMutex< BatonType >::downgrade(), lockHelper(), folly::fibers::TimedRWMutex< BatonType >::read_lock(), folly::fibers::TimedRWMutex< BatonType >::ReadHolder::ReadHolder(), timed_lock(), folly::fibers::TimedRWMutex< BatonType >::timed_read_lock(), folly::fibers::TimedRWMutex< BatonType >::timed_write_lock(), try_lock(), folly::fibers::TimedRWMutex< BatonType >::try_read_lock(), folly::fibers::TimedRWMutex< BatonType >::try_write_lock(), unlock(), folly::fibers::TimedRWMutex< BatonType >::unlock(), folly::fibers::TimedRWMutex< BatonType >::write_lock(), folly::fibers::TimedRWMutex< BatonType >::WriteHolder::WriteHolder(), folly::fibers::TimedRWMutex< BatonType >::ReadHolder::~ReadHolder(), and folly::fibers::TimedRWMutex< BatonType >::WriteHolder::~WriteHolder().

bool folly::fibers::TimedMutex::locked_ = false

private

Definition at line 76 of file TimedMutex.h.

Referenced by lockHelper(), try_lock(), and unlock().

MutexWaiter* folly::fibers::TimedMutex::notifiedFiber_ {nullptr}

private

Definition at line 79 of file TimedMutex.h.

Referenced by lockHelper(), unlock(), and ~TimedMutex().

MutexWaiterList folly::fibers::TimedMutex::threadWaiters_

private

Definition at line 77 of file TimedMutex.h.

Referenced by lockHelper(), unlock(), and ~TimedMutex().

---

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

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