folly::ParkingLot< Data > Class Template Reference

#include <ParkingLot.h>

Classes
struct	WaitNode

Public Member Functions
	ParkingLot ()
template<typename Key , typename D , typename ToPark , typename PreWait >
ParkResult	park (const Key key, D &&data, ToPark &&toPark, PreWait &&preWait)
template<typename Key , typename D , typename ToPark , typename PreWait , typename Clock , typename Duration >
ParkResult	park_until (const Key key, D &&data, ToPark &&toPark, PreWait &&preWait, std::chrono::time_point< Clock, Duration > deadline)
template<typename Key , typename D , typename ToPark , typename PreWait , typename Rep , typename Period >
ParkResult	park_for (const Key key, D &&data, ToPark &&toPark, PreWait &&preWait, std::chrono::duration< Rep, Period > &timeout)
template<typename Key , typename Unparker >
void	unpark (const Key key, Unparker &&func)
template<typename Key , typename Func >
void	unpark (const Key bits, Func &&func)

Private Member Functions
	ParkingLot (const ParkingLot &)=delete

Private Attributes
const uint64_t	lotid_

Detailed Description

template<typename Data = Unit>
class folly::ParkingLot< Data >

Definition at line 162 of file ParkingLot.h.

Constructor & Destructor Documentation

template<typename Data = Unit>

folly::ParkingLot< Data >::ParkingLot ( const ParkingLot< Data > &  )

privatedelete

template<typename Data = Unit>

folly::ParkingLot< Data >::ParkingLot ( )

inline

Definition at line 175 of file ParkingLot.h.

: lotid_(parking_lot_detail::idallocator++) {}

Member Function Documentation

template<typename Data = Unit>

template<typename Key , typename D , typename ToPark , typename PreWait >

ParkResult folly::ParkingLot< Data >::park ( const Key  key, D &&  data, ToPark &&  toPark, PreWait &&  preWait  )

inline

Definition at line 189 of file ParkingLot.h.

References D, folly::data(), testing::Key(), and max.

Referenced by folly::detail::atomic_notification::atomic_wait_impl(), BENCHMARK_RELATIVE(), TEST(), and WaitableMutex::wait().

                                                                               {
    return park_until(
        key,
        std::forward<D>(data),
        std::forward<ToPark>(toPark),
        std::forward<PreWait>(preWait),
        std::chrono::steady_clock::time_point::max());
  }

template<typename Data = Unit>

template<typename Key , typename D , typename ToPark , typename PreWait , typename Rep , typename Period >

ParkResult folly::ParkingLot< Data >::park_for ( const Key  key, D &&  data, ToPark &&  toPark, PreWait &&  preWait, std::chrono::duration< Rep, Period > &  timeout  )

inline

Definition at line 219 of file ParkingLot.h.

References D, folly::data(), testing::Key(), and now().

                                               {
    return park_until(
        key,
        std::forward<D>(data),
        std::forward<ToPark>(toPark),
        std::forward<PreWait>(preWait),
        timeout + std::chrono::steady_clock::now());
  }

template<typename Data >

template<typename Key , typename D , typename ToPark , typename PreWait , typename Clock , typename Duration >

ParkResult folly::ParkingLot< Data >::park_until	(	const Key	key,
		D &&	data,
		ToPark &&	toPark,
		PreWait &&	preWait,
		std::chrono::time_point< Clock, Duration >	deadline
	)

Definition at line 256 of file ParkingLot.h.

References folly::parking_lot_detail::Bucket::bucketFor(), folly::data(), folly::parking_lot_detail::WaitNodeBase::lotid_, folly::parking_lot_detail::WaitNodeBase::signaled(), folly::Skip, folly::Timeout, folly::hash::twang_mix64(), uint64_t, folly::Unpark, and folly::parking_lot_detail::WaitNodeBase::wait().

Referenced by folly::detail::atomic_notification::atomic_wait_until_impl().

                                                   {
  auto key = hash::twang_mix64(uint64_t(bits));
  auto& bucket = parking_lot_detail::Bucket::bucketFor(key);
  WaitNode node(key, lotid_, std::forward<D>(data));

  {
    // A: Must be seq_cst.  Matches B.
    bucket.count_.fetch_add(1, std::memory_order_seq_cst);

    std::unique_lock<std::mutex> bucketLock(bucket.mutex_);

    if (!std::forward<ToPark>(toPark)()) {
      bucketLock.unlock();
      bucket.count_.fetch_sub(1, std::memory_order_relaxed);
      return ParkResult::Skip;
    }

    bucket.push_back(&node);
  } // bucketLock scope

  std::forward<PreWait>(preWait)();

  auto status = node.wait(deadline);

  if (status == std::cv_status::timeout) {
    // it's not really a timeout until we unlink the unsignaled node
    std::lock_guard<std::mutex> bucketLock(bucket.mutex_);
    if (!node.signaled()) {
      bucket.erase(&node);
      return ParkResult::Timeout;
    }
  }

  return ParkResult::Unpark;
}

template<typename Data = Unit>

template<typename Key , typename Unparker >

void folly::ParkingLot< Data >::unpark	(	const Key	key,
		Unparker &&	func
	)

Referenced by folly::detail::atomic_notification::atomic_notify_all_impl(), folly::detail::atomic_notification::atomic_notify_one_impl(), BENCHMARK_RELATIVE(), and WaitableMutex::unlock().

template<typename Data = Unit>

template<typename Key , typename Func >

void folly::ParkingLot< Data >::unpark	(	const Key	bits,
		Func &&	func
	)

Definition at line 299 of file ParkingLot.h.

References folly::parking_lot_detail::Bucket::bucketFor(), folly::parking_lot_detail::WaitNodeBase::lotid_, folly::parking_lot_detail::WaitNodeBase::next_, folly::RemoveBreak, folly::RemoveContinue, folly::RetainBreak, folly::hash::twang_mix64(), and uint64_t.

                                                         {
  auto key = hash::twang_mix64(uint64_t(bits));
  auto& bucket = parking_lot_detail::Bucket::bucketFor(key);
  // B: Must be seq_cst.  Matches A.  If true, A *must* see in seq_cst
  // order any atomic updates in toPark() (and matching updates that
  // happen before unpark is called)
  if (bucket.count_.load(std::memory_order_seq_cst) == 0) {
    return;
  }

  std::lock_guard<std::mutex> bucketLock(bucket.mutex_);

  for (auto iter = bucket.head_; iter != nullptr;) {
    auto node = static_cast<WaitNode*>(iter);
    iter = iter->next_;
    if (node->key_ == key && node->lotid_ == lotid_) {
      auto result = std::forward<Func>(func)(node->data_);
      if (result == UnparkControl::RemoveBreak ||
          result == UnparkControl::RemoveContinue) {
        // we unlink, but waiter destroys the node
        bucket.erase(node);

        node->wake();
      }
      if (result == UnparkControl::RemoveBreak ||
          result == UnparkControl::RetainBreak) {
        return;
      }
    }
  }
}

Member Data Documentation

template<typename Data = Unit>

const uint64_t folly::ParkingLot< Data >::lotid_

private

Definition at line 163 of file ParkingLot.h.

---

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

• proxygen/folly/folly/synchronization/ParkingLot.h