folly::fibers::Semaphore Class Reference

#include <Semaphore.h>

Public Member Functions
	Semaphore (size_t tokenCount)
	Semaphore (const Semaphore &)=delete
	Semaphore (Semaphore &&)=delete
Semaphore &	operator= (const Semaphore &)=delete
Semaphore &	operator= (Semaphore &&)=delete
void	signal ()
void	wait ()
size_t	getCapacity () const

Private Member Functions
bool	waitSlow ()
bool	signalSlow ()

Private Attributes
size_t	capacity_
std::atomic< int64_t >	tokens_
folly::Synchronized< std::queue< folly::fibers::Baton * > >	waitList_

Detailed Description

Definition at line 28 of file Semaphore.h.

Constructor & Destructor Documentation

folly::fibers::Semaphore::Semaphore ( size_t  tokenCount )

inlineexplicit

Definition at line 30 of file Semaphore.h.

References getCapacity(), operator=(), signal(), signalSlow(), wait(), and waitSlow().

      : capacity_(tokenCount), tokens_(int64_t(capacity_)) {}

folly::fibers::Semaphore::Semaphore ( const Semaphore &  )

delete

folly::fibers::Semaphore::Semaphore ( Semaphore &&  )

delete

Member Function Documentation

size_t folly::fibers::Semaphore::getCapacity

(

)

const

Definition at line 97 of file Semaphore.cpp.

References capacity_.

Referenced by Semaphore().

                                    {
  return capacity_;
}

Semaphore& folly::fibers::Semaphore::operator= ( const Semaphore &  )

delete

Referenced by Semaphore().

Semaphore& folly::fibers::Semaphore::operator= ( Semaphore &&  )

delete

void folly::fibers::Semaphore::signal

(

)

Definition at line 44 of file Semaphore.cpp.

References signalSlow(), and tokens_.

Referenced by Semaphore(), and TEST().

                       {
  auto oldVal = tokens_.load(std::memory_order_acquire);
  do {
    if (oldVal == 0) {
      if (signalSlow()) {
        break;
      }
    }
  } while (!tokens_.compare_exchange_weak(
      oldVal,
      oldVal + 1,
      std::memory_order_release,
      std::memory_order_acquire));
}

bool folly::fibers::Semaphore::signalSlow ( )

private

Definition at line 21 of file Semaphore.cpp.

References tokens_, and waitList_.

Referenced by Semaphore(), and signal().

                           {
  // If we signalled a release, notify the waitlist
  auto waitListLock = waitList_.wlock();
  auto& waitList = *waitListLock;

  auto testVal = tokens_.load(std::memory_order_acquire);
  if (testVal != 0) {
    return false;
  }

  if (waitList.empty()) {
    // If the waitlist is now empty, ensure the token count increments
    // No need for CAS here as we will always be under the mutex
    CHECK(tokens_.compare_exchange_strong(
        testVal, testVal + 1, std::memory_order_relaxed));
  } else {
    // trigger waiter if there is one
    waitList.front()->post();
    waitList.pop();
  }
  return true;
}

void folly::fibers::Semaphore::wait

(

)

Definition at line 80 of file Semaphore.cpp.

References tokens_, and waitSlow().

Referenced by Semaphore(), and TEST().

                     {
  auto oldVal = tokens_.load(std::memory_order_acquire);
  do {
    if (oldVal == 0) {
      // If waitSlow fails it is because the token is non-zero by the time
      // the lock is taken, so we can just continue round the loop
      if (waitSlow()) {
        break;
      }
    }
  } while (!tokens_.compare_exchange_weak(
      oldVal,
      oldVal - 1,
      std::memory_order_release,
      std::memory_order_acquire));
}

bool folly::fibers::Semaphore::waitSlow ( )

private

Definition at line 59 of file Semaphore.cpp.

References tokens_, folly::fibers::Baton::wait(), and waitList_.

Referenced by Semaphore(), and wait().

                         {
  // Slow path, create a baton and acquire a mutex to update the wait list
  folly::fibers::Baton waitBaton;

  {
    auto waitListLock = waitList_.wlock();
    auto& waitList = *waitListLock;

    auto testVal = tokens_.load(std::memory_order_acquire);
    if (testVal != 0) {
      return false;
    }
    // prepare baton and add to queue
    waitList.push(&waitBaton);
  }
  // If we managed to create a baton, wait on it
  // This has to be done here so the mutex has been released
  waitBaton.wait();
  return true;
}

Member Data Documentation

size_t folly::fibers::Semaphore::capacity_

private

Definition at line 54 of file Semaphore.h.

Referenced by getCapacity().

std::atomic<int64_t> folly::fibers::Semaphore::tokens_

private

Definition at line 56 of file Semaphore.h.

Referenced by signal(), signalSlow(), wait(), and waitSlow().

folly::Synchronized<std::queue<folly::fibers::Baton*> > folly::fibers::Semaphore::waitList_

private

Definition at line 57 of file Semaphore.h.

Referenced by signalSlow(), and waitSlow().

---

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

• proxygen/folly/folly/fibers/Semaphore.h
• proxygen/folly/folly/fibers/Semaphore.cpp