folly::EventBase Class Reference

#include <EventBase.h>

Inheritance diagram for folly::EventBase:

Classes
class	FunctionLoopCallback
class	FunctionRunner
class	LoopCallback
class	SmoothLoopTime
class	StackFunctionLoopCallback

Public Types
using	Func = folly::Function< void()>
Public Types inherited from folly::TimeoutManager
enum	InternalEnum { InternalEnum::INTERNAL, InternalEnum::NORMAL }
typedef std::chrono::milliseconds	timeout_type
using	Func = folly::Function< void()>
Public Types inherited from folly::ScheduledExecutor
typedef std::chrono::microseconds	Duration
typedef std::chrono::steady_clock::time_point	TimePoint

Public Member Functions
	EventBase ()
	EventBase (bool enableTimeMeasurement)
	EventBase (event_base *evb, bool enableTimeMeasurement=true)
	~EventBase () override
bool	loop ()
bool	loopIgnoreKeepAlive ()
bool	loopOnce (int flags=0)
void	loopForever ()
void	terminateLoopSoon ()
void	runInLoop (LoopCallback *callback, bool thisIteration=false)
void	runInLoop (Func c, bool thisIteration=false)
void	runOnDestruction (LoopCallback *callback)
void	runBeforeLoop (LoopCallback *callback)
template<typename T >
bool	runInEventBaseThread (void(*fn)(T *), T *arg)
bool	runInEventBaseThread (Func fn)
template<typename T >
bool	runInEventBaseThreadAndWait (void(*fn)(T *), T *arg)
bool	runInEventBaseThreadAndWait (Func fn)
template<typename T >
bool	runImmediatelyOrRunInEventBaseThreadAndWait (void(*fn)(T *), T *arg)
bool	runImmediatelyOrRunInEventBaseThreadAndWait (Func fn)
void	setMaxLatency (std::chrono::microseconds maxLatency, Func maxLatencyCob)
void	setLoadAvgMsec (std::chrono::milliseconds ms)
void	resetLoadAvg (double value=0.0)
double	getAvgLoopTime () const
bool	isRunning () const
void	waitUntilRunning ()
size_t	getNotificationQueueSize () const
void	setMaxReadAtOnce (uint32_t maxAtOnce)
bool	isInEventBaseThread () const
bool	inRunningEventBaseThread () const
void	checkIsInEventBaseThread () const
void	dcheckIsInEventBaseThread () const
HHWheelTimer &	timer ()
event_base *	getLibeventBase () const
void	bumpHandlingTime () final
void	setObserver (const std::shared_ptr< EventBaseObserver > &observer)
const std::shared_ptr< EventBaseObserver > &	getObserver ()
void	setExecutionObserver (ExecutionObserver *observer)
ExecutionObserver *	getExecutionObserver ()
void	setName (const std::string &name)
const std::string &	getName ()
void	add (Cob fn) override
	Implements the Executor interface. More...
void	drive () override
	Implements the DrivableExecutor interface. More...
void	scheduleAt (Func &&fn, TimePoint const &timeout) override
void	attachTimeoutManager (AsyncTimeout *obj, TimeoutManager::InternalEnum internal) final
void	detachTimeoutManager (AsyncTimeout *obj) final
bool	scheduleTimeout (AsyncTimeout *obj, TimeoutManager::timeout_type timeout) final
void	cancelTimeout (AsyncTimeout *obj) final
bool	isInTimeoutManagerThread () final
folly::VirtualEventBase &	getVirtualEventBase ()
EventBase *	getEventBase () override
	Implements the IOExecutor interface. More...
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)
Public Member Functions inherited from folly::DrivableExecutor
	~DrivableExecutor () override=default
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::IOExecutor
	~IOExecutor () override=default
Public Member Functions inherited from folly::ScheduledExecutor
	~ScheduledExecutor () override=default
void	schedule (Func &&a)
	Alias for add() (for Rx consistency) More...
void	schedule (Func &&a, Duration const &dur)
virtual TimePoint	now ()
	Get this executor's notion of time. Must be threadsafe. More...

Static Public Member Functions
static const char *	getLibeventVersion ()
static const char *	getLibeventMethod ()
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)

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

Private Types
typedef LoopCallback::List	LoopCallbackList

Private Member Functions
void	applyLoopKeepAlive ()
ssize_t	loopKeepAliveCount ()
bool	nothingHandledYet () const noexcept
bool	loopBody (int flags=0, bool ignoreKeepAlive=false)
bool	runLoopCallbacks ()
void	initNotificationQueue ()

Private Attributes
HHWheelTimer::UniquePtr	wheelTimer_
LoopCallbackList	loopCallbacks_
LoopCallbackList	runBeforeLoopCallbacks_
LoopCallbackList	onDestructionCallbacks_
LoopCallbackList *	runOnceCallbacks_
std::atomic< bool >	stop_
std::atomic< std::thread::id >	loopThread_
event_base *	evb_
std::unique_ptr< NotificationQueue< Func > >	queue_
std::unique_ptr< FunctionRunner >	fnRunner_
ssize_t	loopKeepAliveCount_ {0}
std::atomic< ssize_t >	loopKeepAliveCountAtomic_ {0}
bool	loopKeepAliveActive_ {false}
std::chrono::microseconds	maxLatency_
SmoothLoopTime	avgLoopTime_
SmoothLoopTime	maxLatencyLoopTime_
Func	maxLatencyCob_
const bool	enableTimeMeasurement_
std::size_t	nextLoopCnt_
std::size_t	latestLoopCnt_
std::chrono::steady_clock::time_point	startWork_
bool	invokingLoop_ {false}
std::shared_ptr< EventBaseObserver >	observer_
uint32_t	observerSampleCount_
ExecutionObserver *	executionObserver_
std::string	name_
std::mutex	onDestructionCallbacksMutex_
std::unordered_map< std::size_t, std::shared_ptr< void > >	localStorage_
std::unordered_set< detail::EventBaseLocalBaseBase * >	localStorageToDtor_
folly::once_flag	virtualEventBaseInitFlag_
std::unique_ptr< VirtualEventBase >	virtualEventBase_

Friends
class	detail::EventBaseLocalBase
template<typename T >
class	EventBaseLocal

Additional Inherited Members
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

This class is a wrapper for all asynchronous I/O processing functionality

EventBase provides a main loop that notifies EventHandler callback objects when I/O is ready on a file descriptor, and notifies AsyncTimeout objects when a specified timeout has expired. More complex, higher-level callback mechanisms can then be built on top of EventHandler and AsyncTimeout.

A EventBase object can only drive an event loop for a single thread. To take advantage of multiple CPU cores, most asynchronous I/O servers have one thread per CPU, and use a separate EventBase for each thread.

In general, most EventBase methods may only be called from the thread running the EventBase's loop. There are a few exceptions to this rule, for methods that are explicitly intended to allow communication with a EventBase from other threads. When it is safe to call a method from another thread it is explicitly listed in the method comments.

Definition at line 128 of file EventBase.h.

Member Typedef Documentation

using folly::EventBase::Func = folly::Function<void()>

Definition at line 135 of file EventBase.h.

typedef LoopCallback::List folly::EventBase::LoopCallbackList

private

Definition at line 698 of file EventBase.h.

Constructor & Destructor Documentation

folly::EventBase::EventBase ( )

inline

Create a new EventBase object.

Same as EventBase(true), which constructs an EventBase that measures time.

Definition at line 210 of file EventBase.h.

References c, loop(), and folly::T.

: EventBase(true) {}

folly::EventBase::EventBase ( bool  enableTimeMeasurement )

explicit

Create a new EventBase object.

Parameters

enableTimeMeasurement

Informs whether this event base should measure time. Disabling it would likely improve performance, but will disable some features that relies on time-measurement, including: observer, max latency and avg loop time.

Definition at line 76 of file EventBase.cpp.

References evb_, initNotificationQueue(), folly::lock(), folly::throwSystemError(), and UNLIKELY.

    : runOnceCallbacks_(nullptr),
      stop_(false),
      loopThread_(),
      queue_(nullptr),
      fnRunner_(nullptr),
      maxLatency_(0),
      avgLoopTime_(std::chrono::seconds(2)),
      maxLatencyLoopTime_(avgLoopTime_),
      enableTimeMeasurement_(enableTimeMeasurement),
      nextLoopCnt_(
          std::size_t(-40)) // Early wrap-around so bugs will manifest soon
      ,
      latestLoopCnt_(nextLoopCnt_),
      startWork_(),
      observer_(nullptr),
      observerSampleCount_(0),
      executionObserver_(nullptr) {
  struct event ev;
  {
    std::lock_guard<std::mutex> lock(libevent_mutex_);

    // The value 'current_base' (libevent 1) or
    // 'event_global_current_base_' (libevent 2) is filled in by event_set(),
    // allowing examination of its value without an explicit reference here.
    // If ev.ev_base is nullptr, then event_init() must be called, otherwise
    // call event_base_new().
    event_set(&ev, 0, 0, nullptr, nullptr);
    if (!ev.ev_base) {
      evb_ = event_init();
    }
  }

  if (ev.ev_base) {
    evb_ = event_base_new();
  }

  if (UNLIKELY(evb_ == nullptr)) {
    LOG(ERROR) << "EventBase(): Failed to init event base.";
    folly::throwSystemError("error in EventBase::EventBase()");
  }
  VLOG(5) << "EventBase(): Created.";
  initNotificationQueue();
}

folly::EventBase::EventBase ( event_base *  evb, bool  enableTimeMeasurement = true  )

explicit

Create a new EventBase object that will use the specified libevent event_base object to drive the event loop.

The EventBase will take ownership of this event_base, and will call event_base_free(evb) when the EventBase is destroyed.

Parameters

enableTimeMeasurement

Informs whether this event base should measure time. Disabling it would likely improve performance, but will disable some features that relies on time-measurement, including: observer, max latency and avg loop time.

Definition at line 122 of file EventBase.cpp.

References evb_, initNotificationQueue(), and UNLIKELY.

    : runOnceCallbacks_(nullptr),
      stop_(false),
      loopThread_(),
      evb_(evb),
      queue_(nullptr),
      fnRunner_(nullptr),
      maxLatency_(0),
      avgLoopTime_(std::chrono::seconds(2)),
      maxLatencyLoopTime_(avgLoopTime_),
      enableTimeMeasurement_(enableTimeMeasurement),
      nextLoopCnt_(
          std::size_t(-40)) // Early wrap-around so bugs will manifest soon
      ,
      latestLoopCnt_(nextLoopCnt_),
      startWork_(),
      observer_(nullptr),
      observerSampleCount_(0),
      executionObserver_(nullptr) {
  if (UNLIKELY(evb_ == nullptr)) {
    LOG(ERROR) << "EventBase(): Pass nullptr as event base.";
    throw std::invalid_argument("EventBase(): event base cannot be nullptr");
  }
  initNotificationQueue();
}

folly::EventBase::~EventBase ( )

override

Definition at line 148 of file EventBase.cpp.

References applyLoopKeepAlive(), folly::TimeoutManager::clearCobTimeouts(), evb_, fnRunner_, localStorageToDtor_, folly::lock(), loopKeepAliveCount(), loopOnce(), onDestructionCallbacks_, runBeforeLoopCallbacks_, folly::EventBase::LoopCallback::runLoopCallback(), runLoopCallbacks(), and virtualEventBase_.

Referenced by folly::run().

                      {
  std::future<void> virtualEventBaseDestroyFuture;
  if (virtualEventBase_) {
    virtualEventBaseDestroyFuture = virtualEventBase_->destroy();
  }

  // Keep looping until all keep-alive handles are released. Each keep-alive
  // handle signals that some external code will still schedule some work on
  // this EventBase (so it's not safe to destroy it).
  while (loopKeepAliveCount() > 0) {
    applyLoopKeepAlive();
    loopOnce();
  }

  if (virtualEventBaseDestroyFuture.valid()) {
    virtualEventBaseDestroyFuture.get();
  }

  // Call all destruction callbacks, before we start cleaning up our state.
  while (!onDestructionCallbacks_.empty()) {
    LoopCallback* callback = &onDestructionCallbacks_.front();
    onDestructionCallbacks_.pop_front();
    callback->runLoopCallback();
  }

  clearCobTimeouts();

  DCHECK_EQ(0u, runBeforeLoopCallbacks_.size());

  (void)runLoopCallbacks();

  if (!fnRunner_->consumeUntilDrained()) {
    LOG(ERROR) << "~EventBase(): Unable to drain notification queue";
  }

  // Stop consumer before deleting NotificationQueue
  fnRunner_->stopConsuming();
  {
    std::lock_guard<std::mutex> lock(libevent_mutex_);
    event_base_free(evb_);
  }

  for (auto storage : localStorageToDtor_) {
    storage->onEventBaseDestruction(*this);
  }

  VLOG(5) << "EventBase(): Destroyed.";
}

Member Function Documentation

void folly::EventBase::add ( Cob  fn )

inlineoverridevirtual

Implements the Executor interface.

Implements folly::ScheduledExecutor.

Definition at line 624 of file EventBase.h.

References folly::gen::move.

Referenced by folly::ScopedEventBaseThread::add().

                            {
    // runInEventBaseThread() takes a const&,
    // so no point in doing std::move here.
    runInEventBaseThread(std::move(fn));
  }

void folly::EventBase::applyLoopKeepAlive ( )

private

Definition at line 433 of file EventBase.cpp.

References fnRunner_, loopKeepAliveActive_, loopKeepAliveCount(), queue_, and virtualEventBase_.

Referenced by loopBody(), loopForever(), and ~EventBase().

                                   {
  auto keepAliveCount = loopKeepAliveCount();
  // Make sure default VirtualEventBase won't hold EventBase::loop() forever.
  if (virtualEventBase_ && virtualEventBase_->keepAliveCount() == 1) {
    --keepAliveCount;
  }

  if (loopKeepAliveActive_ && keepAliveCount == 0) {
    // Restore the notification queue internal flag
    fnRunner_->stopConsuming();
    fnRunner_->startConsumingInternal(this, queue_.get());
    loopKeepAliveActive_ = false;
  } else if (!loopKeepAliveActive_ && keepAliveCount > 0) {
    // Update the notification queue event to treat it as a normal
    // (non-internal) event.  The notification queue event always remains
    // installed, and the main loop won't exit with it installed.
    fnRunner_->stopConsuming();
    fnRunner_->startConsuming(this, queue_.get());
    loopKeepAliveActive_ = true;
  }
}

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

finalvirtual

Attaches/detaches TimeoutManager to AsyncTimeout

Implements folly::TimeoutManager.

Definition at line 694 of file EventBase.cpp.

References folly::event_ref_flags(), folly::AsyncTimeout::getEvent(), getLibeventBase(), and folly::TimeoutManager::INTERNAL.

                                                                             {
  struct event* ev = obj->getEvent();
  assert(ev->ev_base == nullptr);

  event_base_set(getLibeventBase(), ev);
  if (internal == AsyncTimeout::InternalEnum::INTERNAL) {
    // Set the EVLIST_INTERNAL flag
    event_ref_flags(ev) |= EVLIST_INTERNAL;
  }
}

void folly::EventBase::bumpHandlingTime ( )

finalvirtual

only EventHandler/AsyncTimeout subclasses and ourselves should ever call this.

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 476 of file EventBase.cpp.

References enableTimeMeasurement_, latestLoopCnt_, nextLoopCnt_, nothingHandledYet(), now(), and startWork_.

Referenced by folly::EventHandler::libeventCallback(), and runLoopCallbacks().

                                 {
  if (!enableTimeMeasurement_) {
    return;
  }

  VLOG(11) << "EventBase " << this << " " << __PRETTY_FUNCTION__
           << " (loop) latest " << latestLoopCnt_ << " next " << nextLoopCnt_;
  if (nothingHandledYet()) {
    latestLoopCnt_ = nextLoopCnt_;
    // set the time
    startWork_ = std::chrono::steady_clock::now();

    VLOG(11) << "EventBase " << this << " " << __PRETTY_FUNCTION__
             << " (loop) startWork_ " << startWork_.time_since_epoch().count();
  }
}

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

finalvirtual

Cancels the AsyncTimeout, if scheduled

Implements folly::TimeoutManager.

Definition at line 732 of file EventBase.cpp.

References dcheckIsInEventBaseThread(), folly::AsyncTimeout::getEvent(), and folly::EventUtil::isEventRegistered().

Referenced by detachTimeoutManager().

                                               {
  dcheckIsInEventBaseThread();
  struct event* ev = obj->getEvent();
  if (EventUtil::isEventRegistered(ev)) {
    event_del(ev);
  }
}

void folly::EventBase::checkIsInEventBaseThread

(

)

const

Equivalent to CHECK(isInEventBaseThread()) (and assert/DCHECK for dcheckIsInEventBaseThread), but it prints more information on failure.

Definition at line 205 of file EventBase.cpp.

References folly::getThreadName(), loopThread_, and folly::Optional< Value >::value_or().

                                               {
  auto evbTid = loopThread_.load(std::memory_order_relaxed);
  if (evbTid == std::thread::id()) {
    return;
  }

  // Using getThreadName(evbTid) instead of name_ will work also if
  // the thread name is set outside of EventBase (and name_ is empty).
  auto curTid = std::this_thread::get_id();
  CHECK(evbTid == curTid)
      << "This logic must be executed in the event base thread. "
      << "Event base thread name: \""
      << folly::getThreadName(evbTid).value_or("")
      << "\", current thread name: \""
      << folly::getThreadName(curTid).value_or("") << "\"";
}

void folly::EventBase::dcheckIsInEventBaseThread ( ) const

inline

Definition at line 520 of file EventBase.h.

References folly::kIsDebug.

Referenced by folly::AsyncServerSocket::addAcceptCallback(), folly::AsyncUDPSocket::AsyncUDPSocket(), folly::EventHandler::attachEventBase(), folly::AsyncServerSocket::attachEventBase(), folly::AsyncSocket::attachEventBase(), folly::AsyncServerSocket::backoffTimeoutExpired(), folly::AsyncServerSocket::bind(), cancelTimeout(), folly::AsyncUDPSocket::close(), folly::AsyncSocket::close(), folly::AsyncSocket::closeNow(), folly::AsyncSocket::connect(), folly::AsyncServerSocket::detachEventBase(), folly::AsyncSocket::detachEventBase(), wangle::EvbHandshakeHelper::dropConnection(), folly::detail::EventBaseLocalBase::erase(), getName(), folly::AsyncServerSocket::getNumPendingMessagesInQueue(), folly::detail::EventBaseLocalBase::getVoid(), folly::NotificationQueue< MessageT >::Consumer::init(), folly::AsyncSocket::init(), folly::AsyncSocket::ioReady(), folly::AsyncSocket::isDetachable(), folly::AsyncSocket::isZeroCopyWriteInProgress(), folly::AsyncServerSocket::listen(), folly::detail::EventBaseLocalBase::onEventBaseDestruction(), folly::AsyncServerSocket::pauseAccepting(), folly::AsyncSocket::processZeroCopyWriteInProgress(), folly::AsyncServerSocket::removeAcceptCallback(), runBeforeLoop(), runInLoop(), scheduleTimeout(), folly::AsyncSocket::setErrMessageCB(), setName(), folly::AsyncSocket::setReadCB(), folly::AsyncSocket::setSendTimeout(), folly::detail::EventBaseLocalBase::setVoid(), folly::AsyncSocket::shutdownWrite(), folly::AsyncSocket::shutdownWriteNow(), folly::AsyncSSLSocket::sslAccept(), folly::AsyncSSLSocket::sslConn(), folly::AsyncServerSocket::startAccepting(), folly::AsyncServerSocket::stopAccepting(), folly::AsyncSocket::timeoutExpired(), folly::AsyncSocket::updateEventRegistration(), folly::AsyncServerSocket::useExistingSockets(), and folly::AsyncSocket::writeImpl().

                                         {
    if (kIsDebug) {
      checkIsInEventBaseThread();
    }
  }

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

finalvirtual

Implements folly::TimeoutManager.

Definition at line 705 of file EventBase.cpp.

References cancelTimeout(), and folly::AsyncTimeout::getEvent().

                                                      {
  cancelTimeout(obj);
  struct event* ev = obj->getEvent();
  ev->ev_base = nullptr;
}

void folly::EventBase::drive ( )

inlineoverridevirtual

Implements the DrivableExecutor interface.

Implements folly::DrivableExecutor.

Definition at line 631 of file EventBase.h.

References SCOPE_EXIT, and folly::detail::timeout.

Referenced by TEST().

                        {
    ++loopKeepAliveCount_;
    SCOPE_EXIT {
      --loopKeepAliveCount_;
    };
    loopOnce();
  }

double folly::EventBase::getAvgLoopTime ( ) const

inline

Get the average loop time in microseconds (an exponentially-smoothed ave)

Definition at line 479 of file EventBase.h.

Referenced by TEST().

                                {
    assert(enableTimeMeasurement_);
    return avgLoopTime_.get();
  }

EventBase * folly::EventBase::getEventBase ( )

overridevirtual

Implements the IOExecutor interface.

Implements folly::IOExecutor.

Definition at line 776 of file EventBase.cpp.

References folly::EventBase::SmoothLoopTime::buffer_interval_.

Referenced by AcceptRoutingHandlerTest::getEventBase(), proxygen::PassThroughTransportFilter::getEventBase(), and TEST().

                                   {
  return this;
}

ExecutionObserver* folly::EventBase::getExecutionObserver ( )

inline

Gets the execution observer associated with this EventBase.

Definition at line 609 of file EventBase.h.

References name, and string.

Referenced by folly::EventHandler::libeventCallback().

                                            {
    return executionObserver_;
  }

event_base* folly::EventBase::getLibeventBase ( ) const

inline

Definition at line 537 of file EventBase.h.

References evb_.

Referenced by attachTimeoutManager(), folly::AsyncSignalHandler::registerSignalHandler(), and folly::EventHandler::setEventBase().

                                      {
    return evb_;
  }

const char * folly::EventBase::getLibeventMethod ( )

static

Definition at line 764 of file EventBase.cpp.

                                         {
  return event_get_method();
}

const char * folly::EventBase::getLibeventVersion ( )

static

Definition at line 761 of file EventBase.cpp.

                                          {
  return event_get_version();
}

const std::string & folly::EventBase::getName

(

)

Returns the name of the thread that runs this event base.

Definition at line 749 of file EventBase.cpp.

References dcheckIsInEventBaseThread(), and name_.

                                    {
  dcheckIsInEventBaseThread();
  return name_;
}

size_t folly::EventBase::getNotificationQueueSize

(

)

const

Definition at line 197 of file EventBase.cpp.

References queue_.

Referenced by loopBody().

                                                 {
  return queue_->size();
}

const std::shared_ptr<EventBaseObserver>& folly::EventBase::getObserver ( )

inline

Definition at line 592 of file EventBase.h.

                                                        {
    return observer_;
  }

VirtualEventBase & folly::EventBase::getVirtualEventBase

(

)

Definition at line 768 of file EventBase.cpp.

References folly::call_once(), virtualEventBase_, and virtualEventBaseInitFlag_.

Referenced by folly::fibers::EventBaseLoopController::attachEventBase(), and TEST().

                                                 {
  folly::call_once(virtualEventBaseInitFlag_, [&] {
    virtualEventBase_ = std::make_unique<VirtualEventBase>(*this);
  });

  return *virtualEventBase_;
}

void folly::EventBase::initNotificationQueue ( )

private

Definition at line 640 of file EventBase.cpp.

References fnRunner_, and queue_.

Referenced by EventBase().

                                      {
  // Infinite size queue
  queue_ = std::make_unique<NotificationQueue<Func>>();

  // We allocate fnRunner_ separately, rather than declaring it directly
  // as a member of EventBase solely so that we don't need to include
  // NotificationQueue.h from EventBase.h
  fnRunner_ = std::make_unique<FunctionRunner>();

  // Mark this as an internal event, so event_base_loop() will return if
  // there are no other events besides this one installed.
  //
  // Most callers don't care about the internal notification queue used by
  // EventBase.  The queue is always installed, so if we did count the queue as
  // an active event, loop() would never exit with no more events to process.
  // Users can use loopForever() if they do care about the notification queue.
  // (This is useful for EventBase threads that do nothing but process
  // runInEventBaseThread() notifications.)
  fnRunner_->startConsumingInternal(this, queue_.get());
}

bool folly::EventBase::inRunningEventBaseThread ( ) const

inline

Definition at line 509 of file EventBase.h.

Referenced by runInEventBaseThread(), and runInEventBaseThreadAndWait().

                                        {
    return loopThread_.load(std::memory_order_relaxed) ==
        std::this_thread::get_id();
  }

bool folly::EventBase::isInEventBaseThread ( ) const

inline

Verify that current thread is the EventBase thread, if the EventBase is running.

Definition at line 504 of file EventBase.h.

Referenced by folly::AsyncUDPSocket::attachEventBase(), folly::AsyncUDPSocket::detachEventBase(), wangle::Acceptor::dropAllConnections(), folly::AttachDetachClient::readDataAvailable(), runImmediatelyOrRunInEventBaseThreadAndWait(), UDPServer::shutdown(), UDPClient::shutdown(), UDPServer::start(), and UDPClient::start().

                                   {
    auto tid = loopThread_.load(std::memory_order_relaxed);
    return tid == std::thread::id() || tid == std::this_thread::get_id();
  }

bool folly::EventBase::isInTimeoutManagerThread ( )

inlinefinalvirtual

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

Implements folly::TimeoutManager.

Definition at line 654 of file EventBase.h.

References folly::getEventBase().

                                        {
    return isInEventBaseThread();
  }

bool folly::EventBase::isRunning ( ) const

inline

check if the event base loop is running.

Definition at line 487 of file EventBase.h.

References uint32_t.

Referenced by setName(), and waitUntilRunning().

                         {
    return loopThread_.load(std::memory_order_relaxed) != std::thread::id();
  }

bool folly::EventBase::keepAliveAcquire ( )

inlineoverrideprotectedvirtual

Reimplemented from folly::Executor.

Definition at line 671 of file EventBase.h.

                                   {
    if (inRunningEventBaseThread()) {
      loopKeepAliveCount_++;
    } else {
      loopKeepAliveCountAtomic_.fetch_add(1, std::memory_order_relaxed);
    }
    return true;
  }

void folly::EventBase::keepAliveRelease ( )

inlineoverrideprotectedvirtual

Reimplemented from folly::Executor.

Definition at line 680 of file EventBase.h.

References add, and folly::pushmi::__adl::noexcept().

                                   {
    if (!inRunningEventBaseThread()) {
      return add([this] { loopKeepAliveCount_--; });
    }
    loopKeepAliveCount_--;
  }

bool folly::EventBase::loop

(

)

Runs the event loop.

loop() will loop waiting for I/O or timeouts and invoking EventHandler and AsyncTimeout callbacks as their events become ready. loop() will only return when there are no more events remaining to process, or after terminateLoopSoon() has been called.

loop() may be called again to restart event processing after a previous call to loop() or loopForever() has returned.

Returns true if the loop completed normally (if it processed all outstanding requests, or if terminateLoopSoon() was called). If an error occurs waiting for events, false will be returned.

Definition at line 256 of file EventBase.cpp.

References loopBody().

Referenced by BENCHMARK(), BENCHMARK_RELATIVE(), QueueTest::destroyCallback(), fizz::test::HandshakeTest::doClientHandshake(), fizz::test::HandshakeTest::doHandshake(), fizz::test::HandshakeTest::doServerHandshake(), fizz::tool::fizzClientCommand(), fizz::tool::fizzServerCommand(), folly::TestSSLServer::init(), loopForever(), main(), QueueTest::maxReadAtOnce(), QueueTest::multiConsumer(), BlockingSocket::open(), QueueTest::putMessages(), ClientRunner::run(), proxygen::WorkerThread::runLoop(), QueueTest::sendOne(), serverSocketSanityTest(), serverTest(), wangle::TEST(), fizz::server::test::TEST(), folly::TEST(), TEST(), TEST_F(), fizz::client::test::TEST_F(), TEST_P(), testConnectOptWrite(), and BlockingSocket::write().

                     {
  return loopBody();
}

bool folly::EventBase::loopBody ( int  flags = 0, bool  ignoreKeepAlive = false  )

private

Definition at line 275 of file EventBase.cpp.

References folly::EventBase::SmoothLoopTime::addSample(), applyLoopKeepAlive(), avgLoopTime_, folly::EventBase::SmoothLoopTime::dampen(), enableTimeMeasurement_, evb_, fnRunner_, folly::EventBase::SmoothLoopTime::get(), getNotificationQueueSize(), folly::getTimeDelta(), invokingLoop_, loopCallbacks_, loopThread_, maxLatency_, maxLatencyCob_, maxLatencyLoopTime_, name_, nextLoopCnt_, nothingHandledYet(), now(), folly::ScheduledExecutor::now(), observer_, observerSampleCount_, runBeforeLoopCallbacks_, runLoopCallbacks(), SCOPE_EXIT, folly::setThreadName(), startWork_, and stop_.

Referenced by loop(), loopIgnoreKeepAlive(), and loopOnce().

                                                        {
  VLOG(5) << "EventBase(): Starting loop.";

  DCHECK(!invokingLoop_)
      << "Your code just tried to loop over an event base from inside another "
      << "event base loop. Since libevent is not reentrant, this leads to "
      << "undefined behavior in opt builds. Please fix immediately. For the "
      << "common case of an inner function that needs to do some synchronous "
      << "computation on an event-base, replace getEventBase() by a new, "
      << "stack-allocated EvenBase.";
  invokingLoop_ = true;
  SCOPE_EXIT {
    invokingLoop_ = false;
  };

  int res = 0;
  bool ranLoopCallbacks;
  bool blocking = !(flags & EVLOOP_NONBLOCK);
  bool once = (flags & EVLOOP_ONCE);

  // time-measurement variables.
  std::chrono::steady_clock::time_point prev;
  std::chrono::steady_clock::time_point idleStart = {};
  std::chrono::microseconds busy;
  std::chrono::microseconds idle;

  loopThread_.store(std::this_thread::get_id(), std::memory_order_release);

  if (!name_.empty()) {
    setThreadName(name_);
  }

  if (enableTimeMeasurement_) {
    prev = std::chrono::steady_clock::now();
    idleStart = prev;
  }

  while (!stop_.load(std::memory_order_relaxed)) {
    if (!ignoreKeepAlive) {
      applyLoopKeepAlive();
    }
    ++nextLoopCnt_;

    // Run the before loop callbacks
    LoopCallbackList callbacks;
    callbacks.swap(runBeforeLoopCallbacks_);

    while (!callbacks.empty()) {
      auto* item = &callbacks.front();
      callbacks.pop_front();
      item->runLoopCallback();
    }

    // nobody can add loop callbacks from within this thread if
    // we don't have to handle anything to start with...
    if (blocking && loopCallbacks_.empty()) {
      res = event_base_loop(evb_, EVLOOP_ONCE);
    } else {
      res = event_base_loop(evb_, EVLOOP_ONCE | EVLOOP_NONBLOCK);
    }

    ranLoopCallbacks = runLoopCallbacks();

    if (enableTimeMeasurement_) {
      auto now = std::chrono::steady_clock::now();
      busy = std::chrono::duration_cast<std::chrono::microseconds>(
          now - startWork_);
      idle = std::chrono::duration_cast<std::chrono::microseconds>(
          startWork_ - idleStart);
      auto loop_time = busy + idle;

      avgLoopTime_.addSample(loop_time, busy);
      maxLatencyLoopTime_.addSample(loop_time, busy);

      if (observer_) {
        if (observerSampleCount_++ == observer_->getSampleRate()) {
          observerSampleCount_ = 0;
          observer_->loopSample(busy.count(), idle.count());
        }
      }

      VLOG(11) << "EventBase " << this << " did not timeout "
               << " loop time guess: " << loop_time.count()
               << " idle time: " << idle.count()
               << " busy time: " << busy.count()
               << " avgLoopTime: " << avgLoopTime_.get()
               << " maxLatencyLoopTime: " << maxLatencyLoopTime_.get()
               << " maxLatency_: " << maxLatency_.count() << "us"
               << " notificationQueueSize: " << getNotificationQueueSize()
               << " nothingHandledYet(): " << nothingHandledYet();

      // see if our average loop time has exceeded our limit
      if ((maxLatency_ > std::chrono::microseconds::zero()) &&
          (maxLatencyLoopTime_.get() > double(maxLatency_.count()))) {
        maxLatencyCob_();
        // back off temporarily -- don't keep spamming maxLatencyCob_
        // if we're only a bit over the limit
        maxLatencyLoopTime_.dampen(0.9);
      }

      // Our loop run did real work; reset the idle timer
      idleStart = now;
    } else {
      VLOG(11) << "EventBase " << this << " did not timeout";
    }

    // If the event loop indicate that there were no more events, and
    // we also didn't have any loop callbacks to run, there is nothing left to
    // do.
    if (res != 0 && !ranLoopCallbacks) {
      // Since Notification Queue is marked 'internal' some events may not have
      // run.  Run them manually if so, and continue looping.
      //
      if (getNotificationQueueSize() > 0) {
        fnRunner_->handlerReady(0);
      } else {
        break;
      }
    }

    if (enableTimeMeasurement_) {
      VLOG(11) << "EventBase " << this
               << " loop time: " << getTimeDelta(&prev).count();
    }

    if (once) {
      break;
    }
  }
  // Reset stop_ so loop() can be called again
  stop_.store(false, std::memory_order_relaxed);

  if (res < 0) {
    LOG(ERROR) << "EventBase: -- error in event loop, res = " << res;
    return false;
  } else if (res == 1) {
    VLOG(5) << "EventBase: ran out of events (exiting loop)!";
  } else if (res > 1) {
    LOG(ERROR) << "EventBase: unknown event loop result = " << res;
    return false;
  }

  loopThread_.store({}, std::memory_order_release);

  VLOG(5) << "EventBase(): Done with loop.";
  return true;
}

void folly::EventBase::loopForever

(

)

Runs the event loop.

loopForever() behaves like loop(), except that it keeps running even if when there are no more user-supplied EventHandlers or AsyncTimeouts registered. It will only return after terminateLoopSoon() has been called.

This is useful for callers that want to wait for other threads to call runInEventBaseThread(), even when there are no other scheduled events.

loopForever() may be called again to restart event processing after a previous call to loop() or loopForever() has returned.

Throws a std::system_error if an error occurs.

Definition at line 455 of file EventBase.cpp.

References applyLoopKeepAlive(), loop(), loopKeepAliveCount_, SCOPE_EXIT, and folly::throwSystemError().

Referenced by folly::run(), folly::ZeroCopyTest::run(), proxygen::WorkerThread::runLoop(), runTest(), proxygen::HTTPServer::start(), wangle::TEST(), TEST(), folly::TEST(), TEST_F(), and folly::ThreadWheelTimekeeper::ThreadWheelTimekeeper().

                            {
  bool ret;
  {
    SCOPE_EXIT {
      applyLoopKeepAlive();
    };
    // Make sure notification queue events are treated as normal events.
    // We can't use loopKeepAlive() here since LoopKeepAlive token can only be
    // released inside a loop.
    ++loopKeepAliveCount_;
    SCOPE_EXIT {
      --loopKeepAliveCount_;
    };
    ret = loop();
  }

  if (!ret) {
    folly::throwSystemError("error in EventBase::loopForever()");
  }
}

bool folly::EventBase::loopIgnoreKeepAlive

(

)

Same as loop(), but doesn't wait for all keep-alive tokens to be released.

Definition at line 260 of file EventBase.cpp.

References fnRunner_, loopBody(), loopKeepAliveActive_, and queue_.

                                    {
  if (loopKeepAliveActive_) {
    // Make sure NotificationQueue is not counted as one of the readers
    // (otherwise loopBody won't return until terminateLoopSoon is called).
    fnRunner_->stopConsuming();
    fnRunner_->startConsumingInternal(this, queue_.get());
    loopKeepAliveActive_ = false;
  }
  return loopBody(0, true);
}

ssize_t folly::EventBase::loopKeepAliveCount ( )

private

Definition at line 423 of file EventBase.cpp.

References loopKeepAliveCount_, and loopKeepAliveCountAtomic_.

Referenced by applyLoopKeepAlive(), and ~EventBase().

                                      {
  if (loopKeepAliveCountAtomic_.load(std::memory_order_relaxed)) {
    loopKeepAliveCount_ +=
        loopKeepAliveCountAtomic_.exchange(0, std::memory_order_relaxed);
  }
  DCHECK_GE(loopKeepAliveCount_, 0);

  return loopKeepAliveCount_;
}

bool folly::EventBase::loopOnce

(

int

flags = 0

)

Wait for some events to become active, run them, then return.

When EVLOOP_NONBLOCK is set in flags, the loop won't block if there are not any events to process.

This is useful for callers that want to run the loop manually.

Returns the same result as loop().

Definition at line 271 of file EventBase.cpp.

References loopBody().

Referenced by BlockingSocket::readHelper(), folly::TEST(), TEST(), TEST_F(), and ~EventBase().

                                  {
  return loopBody(flags | EVLOOP_ONCE);
}

bool folly::EventBase::nothingHandledYet ( ) const

privatenoexcept

Definition at line 689 of file EventBase.cpp.

References latestLoopCnt_, and nextLoopCnt_.

Referenced by bumpHandlingTime(), and loopBody().

                                                 {
  VLOG(11) << "latest " << latestLoopCnt_ << " next " << nextLoopCnt_;
  return (nextLoopCnt_ != latestLoopCnt_);
}

void folly::EventBase::resetLoadAvg

(

double

value = 0.0

)

reset the load average to a desired value

Definition at line 235 of file EventBase.cpp.

References avgLoopTime_, enableTimeMeasurement_, maxLatencyLoopTime_, and folly::EventBase::SmoothLoopTime::reset().

Referenced by TEST().

                                         {
  assert(enableTimeMeasurement_);
  avgLoopTime_.reset(value);
  maxLatencyLoopTime_.reset(value);
}

void folly::EventBase::runBeforeLoop

(

LoopCallback *

callback

)

Adds a callback that will run immediately before the event loop. This is very similar to runInLoop(), but will not cause the loop to break: For example, this callback could be used to get loop times.

Definition at line 548 of file EventBase.cpp.

References folly::EventBase::LoopCallback::cancelLoopCallback(), dcheckIsInEventBaseThread(), and runBeforeLoopCallbacks_.

Referenced by folly::MemoryIdlerTimeout::runLoopCallback(), and TEST().

                                                    {
  dcheckIsInEventBaseThread();
  callback->cancelLoopCallback();
  runBeforeLoopCallbacks_.push_back(*callback);
}

template<typename T >

bool folly::EventBase::runImmediatelyOrRunInEventBaseThreadAndWait	(	void(*)(T *)	fn,
		T *	arg
	)

Definition at line 804 of file EventBase.h.

Referenced by wangle::AsyncServerSocketFactory::ThreadSafeDestructor::operator()(), wangle::AsyncUDPServerSocketFactory::ThreadSafeDestructor::operator()(), and TEST().

            {
  return runImmediatelyOrRunInEventBaseThreadAndWait([=] { fn(arg); });
}

bool folly::EventBase::runImmediatelyOrRunInEventBaseThreadAndWait

(

Func

fn

)

Definition at line 603 of file EventBase.cpp.

References isInEventBaseThread(), folly::gen::move, and runInEventBaseThreadAndWait().

                                                                   {
  if (isInEventBaseThread()) {
    fn();
    return true;
  } else {
    return runInEventBaseThreadAndWait(std::move(fn));
  }
}

template<typename T >

bool folly::EventBase::runInEventBaseThread	(	void(*)(T *)	fn,
		T *	arg
	)

Run the specified function in the EventBase's thread.

This method is thread-safe, and may be called from another thread.

If runInEventBaseThread() is called when the EventBase loop is not running, the function call will be delayed until the next time the loop is started.

If runInEventBaseThread() returns true the function has successfully been scheduled to run in the loop thread. However, if the loop is terminated (and never later restarted) before it has a chance to run the requested function, the function will be run upon the EventBase's destruction.

If two calls to runInEventBaseThread() are made from the same thread, the functions will always be run in the order that they were scheduled. Ordering between functions scheduled from separate threads is not guaranteed.

Parameters

fn	The function to run. The function must not throw any exceptions.
arg	An argument to pass to the function.

Returns

Returns true if the function was successfully scheduled, or false if there was an error scheduling the function.

Definition at line 794 of file EventBase.h.

Referenced by folly::ThreadWheelTimekeeper::after(), AcceptRoutingHandlerTest::clientConnectAndCleanClose(), AcceptRoutingHandlerTest::clientConnectAndWrite(), folly::AttachDetachClient::connect(), wangle::EvbHandshakeHelper::connectionError(), wangle::EvbHandshakeHelper::connectionReady(), folly::AttachDetachClient::connectSuccess(), wangle::EvbHandshakeHelper::dropConnection(), wangle::Acceptor::dropConnections(), proxygen::WorkerThread::forceStop(), wangle::Acceptor::forceStop(), AcceptRoutingHandlerTest::justClientConnect(), QueueTest::multiConsumer(), StaticService::StaticHandler::readFile(), folly::ZeroCopyTest::run(), runInEventBaseThreadAndWait(), runTest(), AcceptRoutingHandlerTest::sendClientException(), QueueTest::sendOne(), folly::AsyncServerSocket::RemoteAcceptor::start(), folly::AsyncServerSocket::RemoteAcceptor::stop(), proxygen::WorkerThread::stopWhenIdle(), TEST(), folly::TEST(), TEST_F(), proxygen::HandlerCallbacks::threadStopped(), folly::ThreadWheelTimekeeper::ThreadWheelTimekeeper(), proxygen::HTTPServer::updateTicketSeeds(), proxygen::HTTPServer::updateTLSCredentials(), and folly::TestSSLServer::~TestSSLServer().

                                                           {
  return runInEventBaseThread([=] { fn(arg); });
}

bool folly::EventBase::runInEventBaseThread

(

Func

fn

)

Run the specified function in the EventBase's thread

This version of runInEventBaseThread() takes a folly::Function object. Note that this may be less efficient than the version that takes a plain function pointer and void* argument, if moving the function is expensive (e.g., if it wraps a lambda which captures some values with expensive move constructors).

If the loop is terminated (and never later restarted) before it has a chance to run the requested function, the function will be run upon the EventBase's destruction.

The function must not throw any exceptions.

Definition at line 554 of file EventBase.cpp.

References inRunningEventBaseThread(), folly::gen::move, queue_, and runInLoop().

                                            {
  // Send the message.
  // It will be received by the FunctionRunner in the EventBase's thread.

  // We try not to schedule nullptr callbacks
  if (!fn) {
    LOG(ERROR) << "EventBase " << this
               << ": Scheduling nullptr callbacks is not allowed";
    return false;
  }

  // Short-circuit if we are already in our event base
  if (inRunningEventBaseThread()) {
    runInLoop(std::move(fn));
    return true;
  }

  try {
    queue_->putMessage(std::move(fn));
  } catch (const std::exception& ex) {
    LOG(ERROR) << "EventBase " << this << ": failed to schedule function "
               << "for EventBase thread: " << ex.what();
    return false;
  }

  return true;
}

template<typename T >

bool folly::EventBase::runInEventBaseThreadAndWait	(	void(*)(T *)	fn,
		T *	arg
	)

Definition at line 799 of file EventBase.h.

Referenced by runImmediatelyOrRunInEventBaseThreadAndWait(), TEST(), TEST_F(), and folly::ThreadWheelTimekeeper::~ThreadWheelTimekeeper().

                                                                  {
  return runInEventBaseThreadAndWait([=] { fn(arg); });
}

bool folly::EventBase::runInEventBaseThreadAndWait

(

Func

fn

)

Definition at line 582 of file EventBase.cpp.

References folly::copy(), inRunningEventBaseThread(), folly::gen::move, folly::Baton< MayBlock, Atom >::post(), runInEventBaseThread(), SCOPE_EXIT, and folly::Baton< MayBlock, Atom >::wait().

                                                   {
  if (inRunningEventBaseThread()) {
    LOG(ERROR) << "EventBase " << this << ": Waiting in the event loop is not "
               << "allowed";
    return false;
  }

  Baton<> ready;
  runInEventBaseThread([&ready, fn = std::move(fn)]() mutable {
    SCOPE_EXIT {
      ready.post();
    };
    // A trick to force the stored functor to be executed and then destructed
    // before posting the baton and waking the waiting thread.
    copy(std::move(fn))();
  });
  ready.wait();

  return true;
}

void folly::EventBase::runInLoop	(	LoopCallback *	callback,
		bool	thisIteration = false
	)

Adds the given callback to a queue of things run after the current pass through the event loop completes. Note that if this callback calls runInLoop() the new callback won't be called until the main event loop has gone through a cycle.

This method may only be called from the EventBase's thread. This essentially allows an event handler to schedule an additional callback to be invoked after it returns.

Use runInEventBaseThread() to schedule functions from another thread.

The thisIteration parameter makes this callback run in this loop iteration, instead of the next one, even if called from a runInLoop callback (normal io callbacks that call runInLoop will always run in this iteration). This was originally added to support detachEventBase, as a user callback may have called terminateLoopSoon(), but we want to make sure we detach. Also, detachEventBase almost always must be called from the base event loop to ensure the stack is unwound, since most users of EventBase are not thread safe.

Ideally we would not need thisIteration, and instead just use runInLoop with loop() (instead of terminateLoopSoon).

Definition at line 520 of file EventBase.cpp.

References folly::EventBase::LoopCallback::cancelLoopCallback(), folly::EventBase::LoopCallback::context_, dcheckIsInEventBaseThread(), loopCallbacks_, runOnceCallbacks_, and folly::RequestContext::saveContext().

Referenced by BENCHMARK(), BENCHMARK_RELATIVE(), TestAsyncTransport::fireNextReadEvent(), fizz::tool::TerminalInputHandler::hitEOF(), QueueTest::maxReadAtOnce(), folly::ZeroCopyTestAsyncSocket::onDataReady(), runInEventBaseThread(), folly::fibers::EventBaseLoopController::schedule(), folly::AsyncSocket::scheduleImmediateRead(), folly::AsyncSocket::scheduleInitialReadWrite(), proxygen::HTTPServer::start(), TEST(), and tmpDisableReads().

                                                                    {
  dcheckIsInEventBaseThread();
  callback->cancelLoopCallback();
  callback->context_ = RequestContext::saveContext();
  if (runOnceCallbacks_ != nullptr && thisIteration) {
    runOnceCallbacks_->push_back(*callback);
  } else {
    loopCallbacks_.push_back(*callback);
  }
}

void folly::EventBase::runInLoop	(	Func	c,
		bool	thisIteration = false
	)

Convenience function to call runInLoop() with a folly::Function.

This creates a LoopCallback object to wrap the folly::Function, and invoke the folly::Function when the loop callback fires. This is slightly more expensive than defining your own LoopCallback, but more convenient in areas that aren't too performance sensitive.

This method may only be called from the EventBase's thread. This essentially allows an event handler to schedule an additional callback to be invoked after it returns.

Use runInEventBaseThread() to schedule functions from another thread.

Definition at line 531 of file EventBase.cpp.

References dcheckIsInEventBaseThread(), loopCallbacks_, folly::gen::move, runOnceCallbacks_, and folly::RequestContext::saveContext().

                                                      {
  dcheckIsInEventBaseThread();
  auto wrapper = new FunctionLoopCallback(std::move(cob));
  wrapper->context_ = RequestContext::saveContext();
  if (runOnceCallbacks_ != nullptr && thisIteration) {
    runOnceCallbacks_->push_back(*wrapper);
  } else {
    loopCallbacks_.push_back(*wrapper);
  }
}

bool folly::EventBase::runLoopCallbacks ( )

private

Definition at line 612 of file EventBase.cpp.

References bumpHandlingTime(), folly::EventBase::LoopCallback::context_, loopCallbacks_, folly::gen::move, folly::EventBase::LoopCallback::runLoopCallback(), and runOnceCallbacks_.

Referenced by loopBody(), and ~EventBase().

                                 {
  bumpHandlingTime();
  if (!loopCallbacks_.empty()) {
    // Swap the loopCallbacks_ list with a temporary list on our stack.
    // This way we will only run callbacks scheduled at the time
    // runLoopCallbacks() was invoked.
    //
    // If any of these callbacks in turn call runInLoop() to schedule more
    // callbacks, those new callbacks won't be run until the next iteration
    // around the event loop.  This prevents runInLoop() callbacks from being
    // able to start file descriptor and timeout based events.
    LoopCallbackList currentCallbacks;
    currentCallbacks.swap(loopCallbacks_);
    runOnceCallbacks_ = &currentCallbacks;

    while (!currentCallbacks.empty()) {
      LoopCallback* callback = &currentCallbacks.front();
      currentCallbacks.pop_front();
      folly::RequestContextScopeGuard rctx(std::move(callback->context_));
      callback->runLoopCallback();
    }

    runOnceCallbacks_ = nullptr;
    return true;
  }
  return false;
}

void folly::EventBase::runOnDestruction

(

LoopCallback *

callback

)

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

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

Note: will be called from the thread that invoked EventBase destructor, before the final run of loop callbacks.

Definition at line 542 of file EventBase.cpp.

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

Referenced by folly::run(), and TEST_F().

                                                       {
  std::lock_guard<std::mutex> lg(onDestructionCallbacksMutex_);
  callback->cancelLoopCallback();
  onDestructionCallbacks_.push_back(*callback);
}

void folly::EventBase::scheduleAt ( Func &&  , TimePoint const &    )

overridevirtual

Schedule a Func to be executed at time t, or as soon afterward as possible. Expect millisecond resolution at best. Must be threadsafe.

Reimplemented from folly::ScheduledExecutor.

Definition at line 754 of file EventBase.cpp.

References folly::gen::move, folly::ScheduledExecutor::now(), folly::HHWheelTimer::scheduleTimeoutFn(), and timer().

Referenced by fizz::server::test::TEST(), and TEST().

                                                              {
  auto duration = timeout - now();
  timer().scheduleTimeoutFn(
      std::move(fn),
      std::chrono::duration_cast<std::chrono::milliseconds>(duration));
}

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

finalvirtual

Schedules AsyncTimeout to fire after timeout milliseconds

Implements folly::TimeoutManager.

Definition at line 711 of file EventBase.cpp.

References dcheckIsInEventBaseThread(), folly::errnoStr(), and folly::AsyncTimeout::getEvent().

                                        {
  dcheckIsInEventBaseThread();
  // Set up the timeval and add the event
  struct timeval tv;
  tv.tv_sec = long(timeout.count() / 1000LL);
  tv.tv_usec = long((timeout.count() % 1000LL) * 1000LL);

  struct event* ev = obj->getEvent();

  DCHECK(ev->ev_base);

  if (event_add(ev, &tv) < 0) {
    LOG(ERROR) << "EventBase: failed to schedule timeout: " << errnoStr(errno);
    return false;
  }

  return true;
}

void folly::EventBase::setExecutionObserver ( ExecutionObserver *  observer )

inline

Setup execution observation/instrumentation for every EventHandler executed in this EventBase.

Parameters

executionObserver

EventHandle's execution observer.

Definition at line 602 of file EventBase.h.

                                                         {
    executionObserver_ = observer;
  }

void folly::EventBase::setLoadAvgMsec

(

std::chrono::milliseconds

ms

)

Set smoothing coefficient for loop load average; # of milliseconds for exp(-1) (1/2.71828...) decay.

Definition at line 224 of file EventBase.cpp.

References avgLoopTime_, enableTimeMeasurement_, maxLatencyLoopTime_, folly::EventBase::SmoothLoopTime::setTimeInterval(), and us.

Referenced by TEST().

                                                       {
  assert(enableTimeMeasurement_);
  std::chrono::microseconds us = std::chrono::milliseconds(ms);
  if (ms > std::chrono::milliseconds::zero()) {
    maxLatencyLoopTime_.setTimeInterval(us);
    avgLoopTime_.setTimeInterval(us);
  } else {
    LOG(ERROR) << "non-positive arg to setLoadAvgMsec()";
  }
}

void folly::EventBase::setMaxLatency ( std::chrono::microseconds  maxLatency, Func  maxLatencyCob  )

inline

Set the maximum desired latency in us and provide a callback which will be called when that latency is exceeded. OBS: This functionality depends on time-measurement.

Definition at line 459 of file EventBase.h.

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

Referenced by TEST().

                                                                           {
    assert(enableTimeMeasurement_);
    maxLatency_ = maxLatency;
    maxLatencyCob_ = std::move(maxLatencyCob);
  }

void folly::EventBase::setMaxReadAtOnce

(

uint32_t

maxAtOnce

)

Definition at line 201 of file EventBase.cpp.

References fnRunner_.

Referenced by runTest().

                                                   {
  fnRunner_->setMaxReadAtOnce(maxAtOnce);
}

void folly::EventBase::setName

(

const std::string &

name

)

Set the name of the thread that runs this event base.

Definition at line 740 of file EventBase.cpp.

References dcheckIsInEventBaseThread(), isRunning(), loopThread_, name, name_, and folly::setThreadName().

Referenced by TEST(), folly::ThreadWheelTimekeeper::ThreadWheelTimekeeper(), and proxygen::WorkerThread::WorkerThread().

                                             {
  dcheckIsInEventBaseThread();
  name_ = name;

  if (isRunning()) {
    setThreadName(loopThread_.load(std::memory_order_relaxed), name_);
  }
}

void folly::EventBase::setObserver ( const std::shared_ptr< EventBaseObserver > &  observer )

inline

Definition at line 587 of file EventBase.h.

                                                                     {
    assert(enableTimeMeasurement_);
    observer_ = observer;
  }

void folly::EventBase::terminateLoopSoon

(

)

Causes the event loop to exit soon.

This will cause an existing call to loop() or loopForever() to stop event processing and return, even if there are still events remaining to be processed.

It is safe to call terminateLoopSoon() from another thread to cause loop() to wake up and return in the EventBase loop thread. terminateLoopSoon() may also be called from the loop thread itself (for example, a EventHandler or AsyncTimeout callback may call terminateLoopSoon() to cause the loop to exit after the callback returns.) If the loop is not running, this will cause the next call to loop to terminate soon after starting. If a loop runs out of work (and so terminates on its own) concurrently with a call to terminateLoopSoon(), this may cause a race condition.

Note that the caller is responsible for ensuring that cleanup of all event callbacks occurs properly. Since terminateLoopSoon() causes the loop to exit even when there are pending events present, there may be remaining callbacks present waiting to be invoked. If the loop is later restarted pending events will continue to be processed normally, however if the EventBase is destroyed after calling terminateLoopSoon() it is the caller's responsibility to ensure that cleanup happens properly even if some outstanding events are never processed.

Definition at line 493 of file EventBase.cpp.

References evb_, queue_, and stop_.

Referenced by proxygen::WorkerThread::forceStop(), QueueTest::maxReadAtOnce(), folly::ZeroCopyTestAsyncSocket::onDataFinish(), folly::ZeroCopyTestAsyncSocket::onDataReady(), TestAcceptor::onNewConnection(), runInThreadTestFunc(), runTest(), UDPClient::shutdown(), proxygen::HTTPServer::stop(), proxygen::WorkerThread::stopWhenIdle(), fizz::server::test::TEST(), wangle::TEST(), TEST(), folly::TEST(), TEST_F(), folly::ScopedEventBaseThread::~ScopedEventBaseThread(), and folly::ThreadWheelTimekeeper::~ThreadWheelTimekeeper().

                                  {
  VLOG(5) << "EventBase(): Received terminateLoopSoon() command.";

  // Set stop to true, so the event loop will know to exit.
  stop_.store(true, std::memory_order_relaxed);

  // Call event_base_loopbreak() so that libevent will exit the next time
  // around the loop.
  event_base_loopbreak(evb_);

  // If terminateLoopSoon() is called from another thread,
  // the EventBase thread might be stuck waiting for events.
  // In this case, it won't wake up and notice that stop_ is set until it
  // receives another event.  Send an empty frame to the notification queue
  // so that the event loop will wake up even if there are no other events.
  //
  // We don't care about the return value of trySendFrame().  If it fails
  // this likely means the EventBase already has lots of events waiting
  // anyway.
  try {
    queue_->putMessage(nullptr);
  } catch (...) {
    // We don't care if putMessage() fails.  This likely means
    // the EventBase already has lots of events waiting anyway.
  }
}

HHWheelTimer& folly::EventBase::timer ( )

inline

Definition at line 526 of file EventBase.h.

References folly::HHWheelTimer::newTimer().

Referenced by scheduleAt(), TEST_F(), and proxygen::WheelTimerInstance::WheelTimerInstance().

                        {
    if (!wheelTimer_) {
      wheelTimer_ = HHWheelTimer::newTimer(this);
    }
    return *wheelTimer_.get();
  }

void folly::EventBase::waitUntilRunning

(

)

wait until the event loop starts (after starting the event loop thread).

Definition at line 249 of file EventBase.cpp.

References isRunning(), and folly::fibers::yield().

Referenced by folly::ScopedEventBaseThread::ScopedEventBaseThread(), proxygen::WorkerThread::start(), TEST(), and folly::ThreadWheelTimekeeper::ThreadWheelTimekeeper().

                                 {
  while (!isRunning()) {
    std::this_thread::yield();
  }
}

Friends And Related Function Documentation

friend class detail::EventBaseLocalBase

friend

Definition at line 783 of file EventBase.h.

template<typename T >

friend class EventBaseLocal

friend

Definition at line 785 of file EventBase.h.

Member Data Documentation

SmoothLoopTime folly::EventBase::avgLoopTime_

private

Definition at line 744 of file EventBase.h.

Referenced by loopBody(), resetLoadAvg(), and setLoadAvgMsec().

const bool folly::EventBase::enableTimeMeasurement_

private

Definition at line 757 of file EventBase.h.

Referenced by bumpHandlingTime(), loopBody(), resetLoadAvg(), and setLoadAvgMsec().

event_base* folly::EventBase::evb_

private

Definition at line 730 of file EventBase.h.

Referenced by EventBase(), loopBody(), folly::EventBase::FunctionRunner::messageAvailable(), terminateLoopSoon(), and ~EventBase().

ExecutionObserver* folly::EventBase::executionObserver_

private

Definition at line 774 of file EventBase.h.

std::unique_ptr<FunctionRunner> folly::EventBase::fnRunner_

private

Definition at line 735 of file EventBase.h.

Referenced by applyLoopKeepAlive(), initNotificationQueue(), loopBody(), loopIgnoreKeepAlive(), setMaxReadAtOnce(), and ~EventBase().

bool folly::EventBase::invokingLoop_ {false}

private

Definition at line 767 of file EventBase.h.

Referenced by loopBody().

std::size_t folly::EventBase::latestLoopCnt_

private

Definition at line 761 of file EventBase.h.

Referenced by bumpHandlingTime(), and nothingHandledYet().

std::unordered_map<std::size_t, std::shared_ptr<void> > folly::EventBase::localStorage_

private

Definition at line 786 of file EventBase.h.

Referenced by folly::detail::EventBaseLocalBase::erase(), folly::detail::EventBaseLocalBase::getVoid(), and folly::detail::EventBaseLocalBase::setVoid().

std::unordered_set<detail::EventBaseLocalBaseBase*> folly::EventBase::localStorageToDtor_

private

Definition at line 787 of file EventBase.h.

Referenced by folly::detail::EventBaseLocalBase::erase(), folly::detail::EventBaseLocalBase::setVoid(), and ~EventBase().

LoopCallbackList folly::EventBase::loopCallbacks_

private

Definition at line 711 of file EventBase.h.

Referenced by loopBody(), runInLoop(), and runLoopCallbacks().

bool folly::EventBase::loopKeepAliveActive_ {false}

private

Definition at line 738 of file EventBase.h.

Referenced by applyLoopKeepAlive(), and loopIgnoreKeepAlive().

ssize_t folly::EventBase::loopKeepAliveCount_ {0}

private

Definition at line 736 of file EventBase.h.

Referenced by loopForever(), and loopKeepAliveCount().

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

private

Definition at line 737 of file EventBase.h.

Referenced by loopKeepAliveCount().

std::atomic<std::thread::id> folly::EventBase::loopThread_

private

Definition at line 727 of file EventBase.h.

Referenced by checkIsInEventBaseThread(), loopBody(), and setName().

std::chrono::microseconds folly::EventBase::maxLatency_

private

Definition at line 741 of file EventBase.h.

Referenced by loopBody().

Func folly::EventBase::maxLatencyCob_

private

Definition at line 752 of file EventBase.h.

Referenced by loopBody().

SmoothLoopTime folly::EventBase::maxLatencyLoopTime_

private

Definition at line 749 of file EventBase.h.

Referenced by loopBody(), resetLoadAvg(), and setLoadAvgMsec().

std::string folly::EventBase::name_

private

Definition at line 777 of file EventBase.h.

Referenced by getName(), loopBody(), and setName().

std::size_t folly::EventBase::nextLoopCnt_

private

Definition at line 760 of file EventBase.h.

Referenced by bumpHandlingTime(), loopBody(), and nothingHandledYet().

std::shared_ptr<EventBaseObserver> folly::EventBase::observer_

private

Definition at line 770 of file EventBase.h.

Referenced by loopBody().

uint32_t folly::EventBase::observerSampleCount_

private

Definition at line 771 of file EventBase.h.

Referenced by loopBody().

LoopCallbackList folly::EventBase::onDestructionCallbacks_

private

Definition at line 713 of file EventBase.h.

Referenced by runOnDestruction(), and ~EventBase().

std::mutex folly::EventBase::onDestructionCallbacksMutex_

private

Definition at line 780 of file EventBase.h.

Referenced by runOnDestruction().

std::unique_ptr<NotificationQueue<Func> > folly::EventBase::queue_

private

Definition at line 734 of file EventBase.h.

Referenced by applyLoopKeepAlive(), getNotificationQueueSize(), initNotificationQueue(), loopIgnoreKeepAlive(), runInEventBaseThread(), and terminateLoopSoon().

LoopCallbackList folly::EventBase::runBeforeLoopCallbacks_

private

Definition at line 712 of file EventBase.h.

Referenced by loopBody(), runBeforeLoop(), and ~EventBase().

LoopCallbackList* folly::EventBase::runOnceCallbacks_

private

Definition at line 719 of file EventBase.h.

Referenced by runInLoop(), and runLoopCallbacks().

std::chrono::steady_clock::time_point folly::EventBase::startWork_

private

Definition at line 762 of file EventBase.h.

Referenced by bumpHandlingTime(), and loopBody().

std::atomic<bool> folly::EventBase::stop_

private

Definition at line 723 of file EventBase.h.

Referenced by loopBody(), and terminateLoopSoon().

std::unique_ptr<VirtualEventBase> folly::EventBase::virtualEventBase_

private

Definition at line 790 of file EventBase.h.

Referenced by applyLoopKeepAlive(), getVirtualEventBase(), and ~EventBase().

folly::once_flag folly::EventBase::virtualEventBaseInitFlag_

private

Definition at line 789 of file EventBase.h.

Referenced by getVirtualEventBase().

HHWheelTimer::UniquePtr folly::EventBase::wheelTimer_

private

Definition at line 709 of file EventBase.h.

---

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

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