folly::FlatCombining< T, Mutex, Atom, Req > Class Template Reference

#include <FlatCombining.h>

Classes
class	Rec
	Combining request record. More...

Public Types
using	Pool = folly::IndexedMemPool< Rec, 32, 4, Atom, IndexedMemPoolTraitsLazyRecycle< Rec >>

Public Member Functions
	FlatCombining (const bool dedicated=true, const uint32_t numRecs=0, const uint32_t maxOps=0)
	~FlatCombining ()
void	drainAll ()
void	acquireExclusive ()
bool	tryExclusive ()
void	releaseExclusive ()
template<typename LockHolder >
void	holdLock (LockHolder &l)
template<typename LockHolder >
void	holdLock (LockHolder &l, std::defer_lock_t)
template<typename OpFunc >
void	requestNoFC (OpFunc &opFn)
template<typename OpFunc >
void	requestFC (OpFunc &&opFn, Rec *rec=nullptr, bool syncop=true)
template<typename OpFunc , typename FillFunc >
void	requestFC (OpFunc &&opFn, const FillFunc &fillFn, Rec *rec=nullptr, bool syncop=true)
template<typename OpFunc , typename FillFunc , typename ResFn >
void	requestFC (OpFunc &&opFn, const FillFunc &fillFn, const ResFn &resFn, Rec *rec=nullptr)
Rec *	allocRec ()
void	freeRec (Rec *rec)
uint64_t	getNumUncombined () const
uint64_t	getNumCombined () const
uint64_t	getNumPasses () const
uint64_t	getNumSessions () const

Protected Member Functions
template<typename OpFunc , typename FillFunc , typename ResFn >
void	requestOp (OpFunc &&opFn, const FillFunc &fillFn, const ResFn &resFn, Rec *rec, bool syncop, const bool custom)
void	pushRec (size_t idx)
size_t	getRecsHead ()
size_t	nextIndex (size_t idx)
void	clearPending ()
void	setPending ()
bool	isPending () const
void	awaitPending ()
uint64_t	combiningSession ()
void	tryCombining ()
void	dedicatedCombining ()
void	awaitDone (Rec &rec)
void	awaitDoneTryLock (Rec &rec)
void	shutdown ()
void	combinedOp (Req &)
	The following member functions may be overridden for customization. More...
void	processReq (Rec &rec)
uint64_t	combiningPass ()

Protected Attributes
const size_t	NULL_INDEX = 0
const uint32_t	kDefaultMaxOps = 100
const uint64_t	kDefaultNumRecs = 64
const uint64_t	kIdleThreshold = 10
Mutex	m_
folly::SaturatingSemaphore< true, Atom >	pending_
Atom< bool >	shutdown_ {false}
uint32_t	numRecs_
uint32_t	maxOps_
Atom< size_t >	recs_
bool	dedicated_
std::thread	combiner_
Pool	recsPool_
uint64_t	uncombined_ = 0
uint64_t	combined_ = 0
uint64_t	passes_ = 0
uint64_t	sessions_ = 0

Private Types
using	SavedFn = folly::Function< void()>

Detailed Description

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>
class folly::FlatCombining< T, Mutex, Atom, Req >

Flat combining (FC) was introduced in the SPAA 2010 paper Flat Combining and the Synchronization-Parallelism Tradeoff, by Danny Hendler, Itai Incze, Nir Shavit, and Moran Tzafrir. http://mcg.cs.tau.ac.il/projects/projects/flat-combining

FC is an alternative to coarse-grained locking for making sequential data structures thread-safe while minimizing the synchronization overheads and cache coherence traffic associated with locking.

Under FC, when a thread finds the lock contended, it can request (using a request record) that the lock holder execute its operation on the shared data structure. There can be a designated combiner thread or any thread can act as the combiner when it holds the lock.

Potential advantages of FC include:

• Reduced cache coherence traffic
• Reduced synchronization overheads, as the overheads of releasing and acquiring the lock are eliminated from the critical path of operating on the data structure.
• Opportunities for smart combining, where executing multiple operations together may take less time than executing the operations separately, e.g., K delete_min operations on a priority queue may be combined to take O(K + log N) time instead of O(K * log N).

This implementation of flat combining supports: - A simple interface that requires minimal extra code by the user. To use this interface efficiently the user-provided functions must be copyable to folly::Function without dynamic allocation. If this is impossible or inconvenient, the user is encouraged to use the custom interface described below.

• A custom interface that supports custom combining and custom request structure, either for the sake of smart combining or for efficiently supporting operations that are not be copyable to folly::Function without dynamic allocation.
• Both synchronous and asynchronous operations.
• Request records with and without thread-caching.
• Combining with and without a dedicated combiner thread.

This implementation differs from the algorithm in the SPAA 2010 paper:

• It does not require thread caching of request records
• It supports a dedicated combiner
• It supports asynchronous operations

The generic FC class template supports generic data structures and utilities with arbitrary operations. The template supports static polymorphism for the combining function to enable custom smart combining.

A simple example of using the FC template: class ConcurrentFoo : public FlatCombining<ConcurrentFoo> { Foo foo_; // sequential data structure public: T bar(V& v) { // thread-safe execution of foo_.bar(v) T result; // Note: fn must be copyable to folly::Function without dynamic // allocation. Otherwise, it is recommended to use the custom // interface and manage the function arguments and results // explicitly in a custom request structure. auto fn = [&] { result = foo_.bar(v); }; this->requestFC(fn); return result; } };

See test/FlatCombiningExamples.h for more examples. See the comments for requestFC() below for a list of simple and custom variants of that function.

Definition at line 109 of file FlatCombining.h.

Member Typedef Documentation

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

using folly::FlatCombining< T, Mutex, Atom, Req >::Pool = folly:: IndexedMemPool<Rec, 32, 4, Atom, IndexedMemPoolTraitsLazyRecycle<Rec>>

Definition at line 230 of file FlatCombining.h.

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

using folly::FlatCombining< T, Mutex, Atom, Req >::SavedFn = folly::Function<void()>

private

Definition at line 110 of file FlatCombining.h.

Constructor & Destructor Documentation

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

folly::FlatCombining< T, Mutex, Atom, Req >::FlatCombining ( const bool  dedicated = true, const uint32_t  numRecs = 0, const uint32_t  maxOps = 0  )

inlineexplicit

The constructor takes three optional arguments:

• Optional dedicated combiner thread (default true)
• Number of records (if 0, then kDefaultNumRecs)
• A hint for the max. number of combined operations per combining session that is checked at the beginning of each pass on the request records (if 0, then kDefaultMaxops)

Definition at line 239 of file FlatCombining.h.

      : numRecs_(numRecs == 0 ? kDefaultNumRecs : numRecs),
        maxOps_(maxOps == 0 ? kDefaultMaxOps : maxOps),
        recs_(NULL_INDEX),
        dedicated_(dedicated),
        recsPool_(numRecs_) {
    if (dedicated_) {
      // dedicated combiner thread
      combiner_ = std::thread([this] { dedicatedCombining(); });
    }
  }

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

folly::FlatCombining< T, Mutex, Atom, Req >::~FlatCombining ( )

inline

Destructor: If there is a dedicated combiner, the destructor flags it to shutdown. Otherwise, the destructor waits for all pending asynchronous requests to be completed.

Definition at line 258 of file FlatCombining.h.

                   {
    if (dedicated_) {
      shutdown();
      combiner_.join();
    } else {
      drainAll();
    }
  }

Member Function Documentation

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

void folly::FlatCombining< T, Mutex, Atom, Req >::acquireExclusive ( )

inline

Definition at line 278 of file FlatCombining.h.

                          {
    m_.lock();
  }

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

Rec* folly::FlatCombining< T, Mutex, Atom, Req >::allocRec ( )

inline

Definition at line 379 of file FlatCombining.h.

Referenced by folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::requestOp().

                  {
    auto idx = recsPool_.allocIndex();
    if (idx == NULL_INDEX) {
      return nullptr;
    }
    Rec& rec = recsPool_[idx];
    rec.setIndex(idx);
    return &rec;
  }

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

void folly::FlatCombining< T, Mutex, Atom, Req >::awaitDone ( Rec &  rec )

inlineprotected

Definition at line 594 of file FlatCombining.h.

                           {
    if (dedicated_) {
      rec.awaitDone();
    } else {
      awaitDoneTryLock(rec);
    }
  }

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

void folly::FlatCombining< T, Mutex, Atom, Req >::awaitDoneTryLock ( Rec &  rec )

inlineprotected

Waits for the request to be done and occasionally tries to acquire the lock and to do combining. Used only in the absence of a dedicated combiner.

Definition at line 605 of file FlatCombining.h.

Referenced by folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::awaitDone().

                                  {
    assert(!dedicated_);
    int count = 0;
    while (!rec.isDone()) {
      if (count == 0) {
        std::unique_lock<Mutex> l(m_, std::defer_lock);
        if (l.try_lock()) {
          setPending();
          tryCombining();
        }
      } else {
        folly::asm_volatile_pause();
        if (++count == 1000) {
          count = 0;
        }
      }
    }
  }

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

void folly::FlatCombining< T, Mutex, Atom, Req >::awaitPending ( )

inlineprotected

Definition at line 545 of file FlatCombining.h.

Referenced by folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::dedicatedCombining().

                      {
    pending_.wait();
  }

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

void folly::FlatCombining< T, Mutex, Atom, Req >::clearPending ( )

inlineprotected

Definition at line 533 of file FlatCombining.h.

Referenced by folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::dedicatedCombining(), and folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::tryCombining().

                      {
    pending_.reset();
  }

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

void folly::FlatCombining< T, Mutex, Atom, Req >::combinedOp ( Req &  )

inlineprotected

The following member functions may be overridden for customization.

Definition at line 631 of file FlatCombining.h.

Referenced by folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::processReq().

                        {
    throw std::runtime_error(
        "FlatCombining::combinedOp(Req&) must be overridden in the derived"
        " class if called.");
  }

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

uint64_t folly::FlatCombining< T, Mutex, Atom, Req >::combiningPass ( )

inlineprotected

Definition at line 651 of file FlatCombining.h.

Referenced by folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::combiningSession().

                           {
    uint64_t count = 0;
    auto idx = getRecsHead();
    Rec* prev = nullptr;
    while (idx != NULL_INDEX) {
      Rec& rec = recsPool_[idx];
      auto next = rec.getNext();
      bool valid = rec.isValid();
      if (!valid && (passes_ - rec.getLast() > kIdleThreshold) &&
          (prev != nullptr)) {
        // Disconnect
        prev->setNext(next);
        rec.setDisconnected();
        // store-load order setDisconnected before isValid
        std::atomic_thread_fence(std::memory_order_seq_cst);
        valid = rec.isValid();
      } else {
        prev = &rec;
      }
      if (valid) {
        processReq(rec);
        ++count;
      }
      idx = next;
    }
    return count;
  }

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

uint64_t folly::FlatCombining< T, Mutex, Atom, Req >::combiningSession ( )

inlineprotected

Definition at line 549 of file FlatCombining.h.

Referenced by folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::dedicatedCombining(), and folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::tryCombining().

                              {
    uint64_t combined = 0;
    do {
      uint64_t count = static_cast<T*>(this)->combiningPass();
      if (count == 0) {
        break;
      }
      combined += count;
      ++this->passes_;
    } while (combined < this->maxOps_);
    return combined;
  }

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

void folly::FlatCombining< T, Mutex, Atom, Req >::dedicatedCombining ( )

inlineprotected

Definition at line 572 of file FlatCombining.h.

Referenced by folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::FlatCombining().

                            {
    while (true) {
      awaitPending();
      clearPending();
      if (shutdown_.load()) {
        break;
      }
      while (true) {
        uint64_t count;
        ++sessions_;
        {
          std::lock_guard<Mutex> guard(m_);
          count = combiningSession();
          combined_ += count;
        }
        if (count < maxOps_) {
          break;
        }
      }
    }
  }

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

void folly::FlatCombining< T, Mutex, Atom, Req >::drainAll ( )

inline

Definition at line 270 of file FlatCombining.h.

Referenced by folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::~FlatCombining().

                  {
    for (size_t i = getRecsHead(); i != NULL_INDEX; i = nextIndex(i)) {
      Rec& rec = recsPool_[i];
      awaitDone(rec);
    }
  }

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

void folly::FlatCombining< T, Mutex, Atom, Req >::freeRec ( Rec *  rec )

inline

Definition at line 390 of file FlatCombining.h.

Referenced by folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::requestOp().

                         {
    if (rec == nullptr) {
      return;
    }
    auto idx = rec->getIndex();
    recsPool_.recycleIndex(idx);
  }

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

uint64_t folly::FlatCombining< T, Mutex, Atom, Req >::getNumCombined ( ) const

inline

Definition at line 404 of file FlatCombining.h.

                                  {
    return combined_;
  }

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

uint64_t folly::FlatCombining< T, Mutex, Atom, Req >::getNumPasses ( ) const

inline

Definition at line 409 of file FlatCombining.h.

                                {
    return passes_;
  }

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

uint64_t folly::FlatCombining< T, Mutex, Atom, Req >::getNumSessions ( ) const

inline

Definition at line 414 of file FlatCombining.h.

                                  {
    return sessions_;
  }

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

uint64_t folly::FlatCombining< T, Mutex, Atom, Req >::getNumUncombined ( ) const

inline

Definition at line 399 of file FlatCombining.h.

                                    {
    return uncombined_;
  }

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

size_t folly::FlatCombining< T, Mutex, Atom, Req >::getRecsHead ( )

inlineprotected

Definition at line 525 of file FlatCombining.h.

Referenced by folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::combiningPass(), and folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::drainAll().

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

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

template<typename LockHolder >

void folly::FlatCombining< T, Mutex, Atom, Req >::holdLock ( LockHolder &  l )

inline

Definition at line 295 of file FlatCombining.h.

                               {
    l = LockHolder(m_);
  }

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

template<typename LockHolder >

void folly::FlatCombining< T, Mutex, Atom, Req >::holdLock ( LockHolder &  l, std::defer_lock_t    )

inline

Definition at line 303 of file FlatCombining.h.

                                                {
    l = LockHolder(m_, std::defer_lock);
  }

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

bool folly::FlatCombining< T, Mutex, Atom, Req >::isPending ( ) const

inlineprotected

Definition at line 541 of file FlatCombining.h.

Referenced by folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::tryCombining().

                         {
    return pending_.ready();
  }

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

size_t folly::FlatCombining< T, Mutex, Atom, Req >::nextIndex ( size_t  idx )

inlineprotected

Definition at line 529 of file FlatCombining.h.

Referenced by folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::drainAll().

                               {
    return recsPool_[idx].getNext();
  }

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

void folly::FlatCombining< T, Mutex, Atom, Req >::processReq ( Rec &  rec )

inlineprotected

Definition at line 637 of file FlatCombining.h.

Referenced by folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::combiningPass().

                            {
    SavedFn& opFn = rec.getFn();
    if (opFn) {
      // simple interface
      opFn();
    } else {
      // custom interface
      Req& req = rec.getReq();
      static_cast<T*>(this)->combinedOp(req); // defined in derived class
    }
    rec.setLast(passes_);
    rec.complete();
  }

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

void folly::FlatCombining< T, Mutex, Atom, Req >::pushRec ( size_t  idx )

inlineprotected

Definition at line 514 of file FlatCombining.h.

Referenced by folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::requestOp().

                           {
    Rec& rec = recsPool_[idx];
    while (true) {
      auto head = recs_.load(std::memory_order_acquire);
      rec.setNext(head); // there shouldn't be a data race here
      if (recs_.compare_exchange_weak(head, idx)) {
        return;
      }
    }
  }

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

void folly::FlatCombining< T, Mutex, Atom, Req >::releaseExclusive ( )

inline

Definition at line 288 of file FlatCombining.h.

                          {
    m_.unlock();
  }

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

template<typename OpFunc >

void folly::FlatCombining< T, Mutex, Atom, Req >::requestFC ( OpFunc &&  opFn, Rec *  rec = nullptr, bool  syncop = true  )

inline

Definition at line 337 of file FlatCombining.h.

                                                                        {
    auto dummy = [](Req&) {};
    requestOp(
        std::forward<OpFunc>(opFn),
        dummy /* fillFn */,
        dummy /* resFn */,
        rec,
        syncop,
        false /* simple */);
  }

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

template<typename OpFunc , typename FillFunc >

void folly::FlatCombining< T, Mutex, Atom, Req >::requestFC ( OpFunc &&  opFn, const FillFunc &  fillFn, Rec *  rec = nullptr, bool  syncop = true  )

inline

Definition at line 348 of file FlatCombining.h.

                          {
    auto dummy = [](Req&) {};
    requestOp(
        std::forward<OpFunc>(opFn),
        fillFn,
        dummy /* resFn */,
        rec,
        syncop,
        true /* custom */);
  }

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

template<typename OpFunc , typename FillFunc , typename ResFn >

void folly::FlatCombining< T, Mutex, Atom, Req >::requestFC ( OpFunc &&  opFn, const FillFunc &  fillFn, const ResFn &  resFn, Rec *  rec = nullptr  )

inline

Definition at line 363 of file FlatCombining.h.

                          {
    // must wait for result to execute resFn -- so it must be synchronous
    requestOp(
        std::forward<OpFunc>(opFn),
        fillFn,
        resFn,
        rec,
        true /* sync */,
        true /* custom*/);
  }

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

template<typename OpFunc >

void folly::FlatCombining< T, Mutex, Atom, Req >::requestNoFC ( OpFunc &  opFn )

inline

Definition at line 309 of file FlatCombining.h.

                                 {
    std::lock_guard<Mutex> guard(m_);
    opFn();
  }

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

template<typename OpFunc , typename FillFunc , typename ResFn >

void folly::FlatCombining< T, Mutex, Atom, Req >::requestOp ( OpFunc &&  opFn, const FillFunc &  fillFn, const ResFn &  resFn, Rec *  rec, bool  syncop, const bool  custom  )

inlineprotected

Definition at line 443 of file FlatCombining.h.

Referenced by folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::requestFC().

                         {
    std::unique_lock<Mutex> l(this->m_, std::defer_lock);
    if (l.try_lock()) {
      // No contention
      ++uncombined_;
      tryCombining();
      opFn();
      return;
    }

    // Try FC
    bool tc = (rec != nullptr);
    if (!tc) {
      // if an async op doesn't have a thread-cached record then turn
      // it into a synchronous op.
      syncop = true;
      rec = allocRec();
    }
    if (rec == nullptr) {
      // Can't use FC - Must acquire lock
      l.lock();
      ++uncombined_;
      tryCombining();
      opFn();
      return;
    }

    // Use FC
    // Wait if record is in use
    awaitDone(*rec);
    rec->clearDone();
    // Fill record
    if (custom) {
      // Fill the request (custom)
      Req& req = rec->getReq();
      fillFn(req);
      rec->clearFn();
    } else {
      rec->setFn(std::forward<OpFunc>(opFn));
    }
    // Indicate that record is valid
    assert(!rec->isValid());
    rec->setValid();
    // end of combining critical path
    setPending();
    // store-load order setValid before isDisconnected
    std::atomic_thread_fence(std::memory_order_seq_cst);
    if (rec->isDisconnected()) {
      rec->clearDisconnected();
      pushRec(rec->getIndex());
      setPending();
    }
    // If synchronous wait for the request to be completed
    if (syncop) {
      awaitDone(*rec);
      if (custom) {
        Req& req = rec->getReq();
        resFn(req); // Extract the result (custom)
      }
      if (!tc) {
        freeRec(rec); // Free the temporary record.
      }
    }
  }

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

void folly::FlatCombining< T, Mutex, Atom, Req >::setPending ( )

inlineprotected

Definition at line 537 of file FlatCombining.h.

Referenced by folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::awaitDoneTryLock(), folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::requestOp(), and folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::shutdown().

                    {
    pending_.post();
  }

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

void folly::FlatCombining< T, Mutex, Atom, Req >::shutdown ( )

inlineprotected

Definition at line 624 of file FlatCombining.h.

Referenced by folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::~FlatCombining().

                  {
    shutdown_.store(true);
    setPending();
  }

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

void folly::FlatCombining< T, Mutex, Atom, Req >::tryCombining ( )

inlineprotected

Definition at line 562 of file FlatCombining.h.

Referenced by folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::awaitDoneTryLock(), and folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::requestOp().

                      {
    if (!dedicated_) {
      while (isPending()) {
        clearPending();
        ++sessions_;
        combined_ += combiningSession();
      }
    }
  }

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

bool folly::FlatCombining< T, Mutex, Atom, Req >::tryExclusive ( )

inline

Definition at line 283 of file FlatCombining.h.

                      {
    return m_.try_lock();
  }

Member Data Documentation

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

uint64_t folly::FlatCombining< T, Mutex, Atom, Req >::combined_ = 0

protected

Definition at line 438 of file FlatCombining.h.

Referenced by folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::getNumCombined().

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

std::thread folly::FlatCombining< T, Mutex, Atom, Req >::combiner_

protected

Definition at line 434 of file FlatCombining.h.

Referenced by folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::FlatCombining(), and folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::~FlatCombining().

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

bool folly::FlatCombining< T, Mutex, Atom, Req >::dedicated_

protected

Definition at line 433 of file FlatCombining.h.

Referenced by folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::FlatCombining(), and folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::~FlatCombining().

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

const uint32_t folly::FlatCombining< T, Mutex, Atom, Req >::kDefaultMaxOps = 100

protected

Definition at line 420 of file FlatCombining.h.

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

const uint64_t folly::FlatCombining< T, Mutex, Atom, Req >::kDefaultNumRecs = 64

protected

Definition at line 421 of file FlatCombining.h.

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

const uint64_t folly::FlatCombining< T, Mutex, Atom, Req >::kIdleThreshold = 10

protected

Definition at line 422 of file FlatCombining.h.

Referenced by folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::combiningPass().

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

Mutex folly::FlatCombining< T, Mutex, Atom, Req >::m_

protected

Definition at line 424 of file FlatCombining.h.

Referenced by folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::acquireExclusive(), folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::awaitDoneTryLock(), folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::dedicatedCombining(), folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::holdLock(), folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::releaseExclusive(), folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::requestNoFC(), folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::requestOp(), and folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::tryExclusive().

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

uint32_t folly::FlatCombining< T, Mutex, Atom, Req >::maxOps_

protected

Definition at line 431 of file FlatCombining.h.

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

const size_t folly::FlatCombining< T, Mutex, Atom, Req >::NULL_INDEX = 0

protected

Definition at line 419 of file FlatCombining.h.

Referenced by folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::allocRec(), and folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::drainAll().

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

uint32_t folly::FlatCombining< T, Mutex, Atom, Req >::numRecs_

protected

Definition at line 430 of file FlatCombining.h.

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

uint64_t folly::FlatCombining< T, Mutex, Atom, Req >::passes_ = 0

protected

Definition at line 439 of file FlatCombining.h.

Referenced by folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::combiningSession(), and folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::getNumPasses().

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

folly::SaturatingSemaphore<true, Atom> folly::FlatCombining< T, Mutex, Atom, Req >::pending_

protected

Definition at line 427 of file FlatCombining.h.

Referenced by folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::awaitPending(), folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::clearPending(), folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::isPending(), and folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::setPending().

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

Atom<size_t> folly::FlatCombining< T, Mutex, Atom, Req >::recs_

protected

Definition at line 432 of file FlatCombining.h.

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

Pool folly::FlatCombining< T, Mutex, Atom, Req >::recsPool_

protected

Definition at line 435 of file FlatCombining.h.

Referenced by folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::allocRec(), folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::drainAll(), and folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::freeRec().

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

uint64_t folly::FlatCombining< T, Mutex, Atom, Req >::sessions_ = 0

protected

Definition at line 440 of file FlatCombining.h.

Referenced by folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::dedicatedCombining(), folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::getNumSessions(), and folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::tryCombining().

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

Atom<bool> folly::FlatCombining< T, Mutex, Atom, Req >::shutdown_ {false}

protected

Definition at line 428 of file FlatCombining.h.

Referenced by folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::dedicatedCombining(), and folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::shutdown().

template<typename T, typename Mutex = std::mutex, template< typename > class Atom = std::atomic, typename Req = bool>

uint64_t folly::FlatCombining< T, Mutex, Atom, Req >::uncombined_ = 0

protected

Definition at line 437 of file FlatCombining.h.

Referenced by folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::getNumUncombined(), and folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::requestOp().

---

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

• proxygen/folly/folly/experimental/flat_combining/FlatCombining.h