folly::VirtualEventBase Class Reference

#include <VirtualEventBase.h>

Inheritance diagram for folly::VirtualEventBase:

Public Member Functions
	VirtualEventBase (EventBase &evb)
	VirtualEventBase (const VirtualEventBase &)=delete
VirtualEventBase &	operator= (const VirtualEventBase &)=delete
	~VirtualEventBase () override
EventBase &	getEventBase ()
void	runOnDestruction (EventBase::LoopCallback *callback)
template<typename F >
void	runInEventBaseThread (F &&f)
HHWheelTimer &	timer ()
void	attachTimeoutManager (AsyncTimeout *obj, TimeoutManager::InternalEnum internal) override
void	detachTimeoutManager (AsyncTimeout *obj) override
bool	scheduleTimeout (AsyncTimeout *obj, TimeoutManager::timeout_type timeout) override
void	cancelTimeout (AsyncTimeout *obj) override
void	bumpHandlingTime () override
bool	isInTimeoutManagerThread () override
void	add (folly::Func f) override
bool	inRunningEventBaseThread () const
Public Member Functions inherited from folly::Executor
virtual	~Executor ()
virtual void	addWithPriority (Func, int8_t priority)
virtual uint8_t	getNumPriorities () const
Public Member Functions inherited from folly::TimeoutManager
	TimeoutManager ()
virtual	~TimeoutManager ()
void	runAfterDelay (Func cob, uint32_t milliseconds, InternalEnum internal=InternalEnum::NORMAL)
bool	tryRunAfterDelay (Func cob, uint32_t milliseconds, InternalEnum internal=InternalEnum::NORMAL)

Protected Member Functions
bool	keepAliveAcquire () override
void	keepAliveRelease () override
Protected Member Functions inherited from folly::TimeoutManager
void	clearCobTimeouts ()

Private Types
using	LoopCallbackList = EventBase::LoopCallback::List

Private Member Functions
ssize_t	keepAliveCount ()
std::future< void >	destroy ()
void	destroyImpl ()

Private Attributes
KeepAlive< EventBase >	evb_
ssize_t	loopKeepAliveCount_ {1}
std::atomic< ssize_t >	loopKeepAliveCountAtomic_ {0}
std::promise< void >	destroyPromise_
std::future< void >	destroyFuture_ {destroyPromise_.get_future()}
KeepAlive< VirtualEventBase >	loopKeepAlive_
folly::Synchronized< LoopCallbackList >	onDestructionCallbacks_

Friends
class	EventBase

Additional Inherited Members
Public Types inherited from folly::TimeoutManager
enum	InternalEnum { InternalEnum::INTERNAL, InternalEnum::NORMAL }
typedef std::chrono::milliseconds	timeout_type
using	Func = folly::Function< void()>
Static Public Member Functions inherited from folly::Executor
template<typename ExecutorT >
static KeepAlive< ExecutorT >	getKeepAliveToken (ExecutorT *executor)
template<typename ExecutorT >
static KeepAlive< ExecutorT >	getKeepAliveToken (ExecutorT &executor)
Static Public Attributes inherited from folly::Executor
static const int8_t	LO_PRI = SCHAR_MIN
static const int8_t	MID_PRI = 0
static const int8_t	HI_PRI = SCHAR_MAX
Static Protected Member Functions inherited from folly::Executor
template<typename ExecutorT >
static bool	isKeepAliveDummy (const KeepAlive< ExecutorT > &keepAlive)
template<typename ExecutorT >
static KeepAlive< ExecutorT >	makeKeepAlive (ExecutorT *executor)

Detailed Description

VirtualEventBase implements a light-weight view onto existing EventBase.

Multiple VirtualEventBases can be backed by a single EventBase. Similarly to EventBase, VirtualEventBase implements loopKeepAlive() functionality, which allows callbacks holding KeepAlive token to keep EventBase looping until they are complete.

VirtualEventBase destructor blocks until all its KeepAliveTokens are released and all tasks scheduled through it are complete. EventBase destructor also blocks until all VirtualEventBases backed by it are released.

Definition at line 40 of file VirtualEventBase.h.

Member Typedef Documentation

using folly::VirtualEventBase::LoopCallbackList = EventBase::LoopCallback::List

private

Definition at line 161 of file VirtualEventBase.h.

Constructor & Destructor Documentation

folly::VirtualEventBase::VirtualEventBase ( EventBase &  evb )

explicit

Definition at line 20 of file VirtualEventBase.cpp.

    : evb_(getKeepAliveToken(evb)) {}

folly::VirtualEventBase::VirtualEventBase ( const VirtualEventBase &  )

delete

folly::VirtualEventBase::~VirtualEventBase ( )

override

Definition at line 57 of file VirtualEventBase.cpp.

References destroy(), destroyFuture_, and evb_.

                                    {
  if (!destroyFuture_.valid()) {
    return;
  }
  CHECK(!evb_->inRunningEventBaseThread());
  destroy().get();
}

Member Function Documentation

void folly::VirtualEventBase::add ( folly::Func  f )

inlineoverridevirtual

See also

runInEventBaseThread

Implements folly::Executor.

Definition at line 115 of file VirtualEventBase.h.

References folly::gen::move, and runInEventBaseThread().

                                 {
    runInEventBaseThread(std::move(f));
  }

void folly::VirtualEventBase::attachTimeoutManager ( AsyncTimeout *  obj, TimeoutManager::InternalEnum  internal  )

inlineoverridevirtual

Attaches/detaches TimeoutManager to AsyncTimeout

Implements folly::TimeoutManager.

Definition at line 85 of file VirtualEventBase.h.

References evb_.

                                                    {
    evb_->attachTimeoutManager(obj, internal);
  }

void folly::VirtualEventBase::bumpHandlingTime ( )

inlineoverridevirtual

This is used to mark the beginning of a new loop cycle by the first handler fired within that cycle.

Implements folly::TimeoutManager.

Definition at line 104 of file VirtualEventBase.h.

References evb_.

                                   {
    evb_->bumpHandlingTime();
  }

void folly::VirtualEventBase::cancelTimeout ( AsyncTimeout *  obj )

inlineoverridevirtual

Cancels the AsyncTimeout, if scheduled

Implements folly::TimeoutManager.

Definition at line 100 of file VirtualEventBase.h.

References evb_.

                                                 {
    evb_->cancelTimeout(obj);
  }

std::future< void > folly::VirtualEventBase::destroy ( )

private

Definition at line 23 of file VirtualEventBase.cpp.

References destroyFuture_, evb_, and folly::gen::move.

Referenced by keepAliveCount(), and ~VirtualEventBase().

                                          {
  CHECK(evb_->runInEventBaseThread([this] { loopKeepAlive_.reset(); }));

  return std::move(destroyFuture_);
}

void folly::VirtualEventBase::destroyImpl ( )

private

Definition at line 29 of file VirtualEventBase.cpp.

References folly::TimeoutManager::clearCobTimeouts(), destroyPromise_, evb_, onDestructionCallbacks_, SCOPE_EXIT, and folly::Synchronized< T, Mutex >::swap().

Referenced by keepAliveCount(), and keepAliveRelease().

                                   {
  try {
    {
      // After destroyPromise_ is posted this object may be destroyed, so make
      // sure we release EventBase's keep-alive token before that.
      SCOPE_EXIT {
        evb_.reset();
      };

      clearCobTimeouts();

      // To avoid potential deadlock, do not hold the mutex while invoking
      // user-supplied callbacks.
      LoopCallbackList callbacks;
      onDestructionCallbacks_.swap(callbacks);
      while (!callbacks.empty()) {
        auto& callback = callbacks.front();
        callbacks.pop_front();
        callback.runLoopCallback();
      }
    }

    destroyPromise_.set_value();
  } catch (...) {
    destroyPromise_.set_exception(std::current_exception());
  }
}

void folly::VirtualEventBase::detachTimeoutManager ( AsyncTimeout *  obj )

inlineoverridevirtual

Implements folly::TimeoutManager.

Definition at line 91 of file VirtualEventBase.h.

References evb_.

                                                        {
    evb_->detachTimeoutManager(obj);
  }

EventBase& folly::VirtualEventBase::getEventBase ( )

inline

Definition at line 49 of file VirtualEventBase.h.

References evb_, and runOnDestruction().

Referenced by folly::fibers::EventBaseLoopController::schedule(), and TEST_F().

                            {
    return *evb_;
  }

bool folly::VirtualEventBase::inRunningEventBaseThread ( ) const

inline

Definition at line 119 of file VirtualEventBase.h.

References evb_.

                                        {
    return evb_->inRunningEventBaseThread();
  }

bool folly::VirtualEventBase::isInTimeoutManagerThread ( )

inlineoverridevirtual

Helper method to know whether we are running in the timeout manager thread

Implements folly::TimeoutManager.

Definition at line 108 of file VirtualEventBase.h.

References evb_.

                                           {
    return evb_->isInTimeoutManagerThread();
  }

bool folly::VirtualEventBase::keepAliveAcquire ( )

inlineoverrideprotectedvirtual

Reimplemented from folly::Executor.

Definition at line 124 of file VirtualEventBase.h.

References evb_, loopKeepAliveCount_, and loopKeepAliveCountAtomic_.

                                   {
    if (evb_->inRunningEventBaseThread()) {
      DCHECK(loopKeepAliveCount_ + loopKeepAliveCountAtomic_.load() > 0);

      ++loopKeepAliveCount_;
    } else {
      ++loopKeepAliveCountAtomic_;
    }
    return true;
  }

ssize_t folly::VirtualEventBase::keepAliveCount ( )

inlineprivate

Definition at line 151 of file VirtualEventBase.h.

References destroy(), destroyImpl(), loopKeepAliveCount_, and loopKeepAliveCountAtomic_.

                           {
    if (loopKeepAliveCountAtomic_.load()) {
      loopKeepAliveCount_ += loopKeepAliveCountAtomic_.exchange(0);
    }
    return loopKeepAliveCount_;
  }

void folly::VirtualEventBase::keepAliveRelease ( )

inlineoverrideprotectedvirtual

Reimplemented from folly::Executor.

Definition at line 135 of file VirtualEventBase.h.

References destroyImpl(), evb_, loopKeepAliveCount_, and loopKeepAliveCountAtomic_.

                                   {
    if (!evb_->inRunningEventBaseThread()) {
      return evb_->add([=] { keepAliveRelease(); });
    }
    if (loopKeepAliveCountAtomic_.load()) {
      loopKeepAliveCount_ += loopKeepAliveCountAtomic_.exchange(0);
    }
    DCHECK(loopKeepAliveCount_ > 0);
    if (--loopKeepAliveCount_ == 0) {
      destroyImpl();
    }
  }

VirtualEventBase& folly::VirtualEventBase::operator= ( const VirtualEventBase &  )

delete

template<typename F >

void folly::VirtualEventBase::runInEventBaseThread ( F &&  f )

inline

VirtualEventBase destructor blocks until all tasks scheduled through its runInEventBaseThread are complete.

See also

EventBase::runInEventBaseThread

Definition at line 72 of file VirtualEventBase.h.

References evb_, f, and folly::Executor::getKeepAliveToken().

Referenced by add(), and folly::fibers::EventBaseLoopController::scheduleThreadSafe().

                                   {
    // KeepAlive token has to be released in the EventBase thread. If
    // runInEventBaseThread() fails, we can't extract the KeepAlive token
    // from the callback to properly release it.
    CHECK(evb_->runInEventBaseThread(
        [keepAliveToken = getKeepAliveToken(this),
         f = std::forward<F>(f)]() mutable { f(); }));
  }

void folly::VirtualEventBase::runOnDestruction

(

EventBase::LoopCallback *

callback

)

Adds the given callback to a queue of things run before destruction of current VirtualEventBase.

This allows users of VirtualEventBase that run in it, but don't control it, to be notified before VirtualEventBase gets destructed.

Note: this will be called from the loop of the EventBase, backing this VirtualEventBase

Definition at line 65 of file VirtualEventBase.cpp.

References folly::EventBase::LoopCallback::cancelLoopCallback(), and onDestructionCallbacks_.

Referenced by getEventBase().

                                                                       {
  onDestructionCallbacks_.withWLock([&](LoopCallbackList& callbacks) {
    callback->cancelLoopCallback();
    callbacks.push_back(*callback);
  });
}

bool folly::VirtualEventBase::scheduleTimeout ( AsyncTimeout *  obj, TimeoutManager::timeout_type  timeout  )

inlineoverridevirtual

Schedules AsyncTimeout to fire after timeout milliseconds

Implements folly::TimeoutManager.

Definition at line 95 of file VirtualEventBase.h.

References evb_.

               {
    return evb_->scheduleTimeout(obj, timeout);
  }

HHWheelTimer& folly::VirtualEventBase::timer ( )

inline

Definition at line 81 of file VirtualEventBase.h.

References evb_.

                        {
    return evb_->timer();
  }

Friends And Related Function Documentation

friend class EventBase

friend

Definition at line 149 of file VirtualEventBase.h.

Member Data Documentation

std::future<void> folly::VirtualEventBase::destroyFuture_ {destroyPromise_.get_future()}

private

Definition at line 168 of file VirtualEventBase.h.

Referenced by destroy(), and ~VirtualEventBase().

std::promise<void> folly::VirtualEventBase::destroyPromise_

private

Definition at line 167 of file VirtualEventBase.h.

Referenced by destroyImpl().

KeepAlive<EventBase> folly::VirtualEventBase::evb_

private

Definition at line 163 of file VirtualEventBase.h.

Referenced by attachTimeoutManager(), bumpHandlingTime(), cancelTimeout(), destroy(), destroyImpl(), detachTimeoutManager(), getEventBase(), inRunningEventBaseThread(), isInTimeoutManagerThread(), keepAliveAcquire(), keepAliveRelease(), runInEventBaseThread(), scheduleTimeout(), timer(), and ~VirtualEventBase().

KeepAlive<VirtualEventBase> folly::VirtualEventBase::loopKeepAlive_

private

Initial value:

{
      makeKeepAlive<VirtualEventBase>(this)}

Definition at line 169 of file VirtualEventBase.h.

ssize_t folly::VirtualEventBase::loopKeepAliveCount_ {1}

private

Definition at line 165 of file VirtualEventBase.h.

Referenced by keepAliveAcquire(), keepAliveCount(), and keepAliveRelease().

std::atomic<ssize_t> folly::VirtualEventBase::loopKeepAliveCountAtomic_ {0}

private

Definition at line 166 of file VirtualEventBase.h.

Referenced by keepAliveAcquire(), keepAliveCount(), and keepAliveRelease().

folly::Synchronized<LoopCallbackList> folly::VirtualEventBase::onDestructionCallbacks_

private

Definition at line 172 of file VirtualEventBase.h.

Referenced by destroyImpl(), and runOnDestruction().

---

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

• proxygen/folly/folly/io/async/VirtualEventBase.h
• proxygen/folly/folly/io/async/VirtualEventBase.cpp