proxygen: folly::fibers::EventBaseLoopController Class Reference

#include <EventBaseLoopController.h>

Inheritance diagram for folly::fibers::EventBaseLoopController:

Classes
class	ControllerCallback

Public Member Functions
	EventBaseLoopController ()

	~EventBaseLoopController () override

void	attachEventBase (EventBase &eventBase)

void	attachEventBase (VirtualEventBase &eventBase)

VirtualEventBase *	getEventBase ()

void	setLoopRunner (InlineFunctionRunner *loopRunner)

Public Member Functions inherited from folly::fibers::LoopController
virtual	~LoopController ()

Private Member Functions
void	setFiberManager (FiberManager *fm) override

void	schedule () override

void	runLoop () override

void	scheduleThreadSafe () override

void	timedSchedule (std::function< void()> func, TimePoint time) override

Private Attributes
bool	awaitingScheduling_ {false}

VirtualEventBase *	eventBase_ {nullptr}

Executor::KeepAlive< VirtualEventBase >	eventBaseKeepAlive_

ControllerCallback	callback_

FiberManager *	fm_ {nullptr}

std::atomic< bool >	eventBaseAttached_ {false}

InlineFunctionRunner *	loopRunner_ {nullptr}

Friends
class	FiberManager

Additional Inherited Members
Public Types inherited from folly::fibers::LoopController
typedef std::chrono::steady_clock	Clock

typedef std::chrono::time_point< Clock >	TimePoint

Detailed Description

Definition at line 27 of file EventBaseLoopController.h.

Constructor & Destructor Documentation

folly::fibers::EventBaseLoopController::EventBaseLoopController ( )

inlineexplicit

Definition at line 22 of file EventBaseLoopController-inl.h.

22 : callback_(*this) {}

folly::fibers::EventBaseLoopController::callback_

ControllerCallback callback_

Definition: EventBaseLoopController.h:63

folly::fibers::EventBaseLoopController::~EventBaseLoopController ( )

inlineoverride

Definition at line 24 of file EventBaseLoopController-inl.h.

References callback_, folly::EventBase::LoopCallback::cancelLoopCallback(), and eventBaseKeepAlive_.

                                                          {
   callback_.cancelLoopCallback();
   eventBaseKeepAlive_.reset();
 }

Member Function Documentation

void folly::fibers::EventBaseLoopController::attachEventBase ( EventBase & eventBase )

inline

Attach EventBase after LoopController was created.

Definition at line 29 of file EventBaseLoopController-inl.h.

References folly::EventBase::getVirtualEventBase().

                                                                          {
   attachEventBase(eventBase.getVirtualEventBase());
 }

void folly::fibers::EventBaseLoopController::attachEventBase ( VirtualEventBase & eventBase )

inline

Definition at line 33 of file EventBaseLoopController-inl.h.

References awaitingScheduling_, eventBase_, eventBaseAttached_, and schedule().

                                  {
   if (eventBase_ != nullptr) {
     LOG(ERROR) << "Attempt to reattach EventBase to LoopController";
   }
 
   eventBase_ = &eventBase;
   eventBaseAttached_ = true;
 
   if (awaitingScheduling_) {
     schedule();
   }
 }

VirtualEventBase* folly::fibers::EventBaseLoopController::getEventBase ( )

inline

Definition at line 38 of file EventBaseLoopController.h.

References eventBase_.

Referenced by TEST_F().

                                    {
     return eventBase_;
   }

void folly::fibers::EventBaseLoopController::runLoop ( )

inlineoverrideprivatevirtual

Run FiberManager loopUntilNoReadyImpl(). May have additional logic specific to a LoopController.

Implements folly::fibers::LoopController.

Definition at line 66 of file EventBaseLoopController-inl.h.

References eventBase_, eventBaseKeepAlive_, fm_, folly::getKeepAliveToken(), folly::fibers::FiberManager::hasReadyTasks(), folly::fibers::FiberManager::hasTasks(), loopRunner_, folly::fibers::FiberManager::loopUntilNoReadyImpl(), and folly::fibers::InlineFunctionRunner::run().

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

                                              {
   if (!eventBaseKeepAlive_) {
     // runLoop can be called twice if both schedule() and scheduleThreadSafe()
     // were called.
     if (!fm_->hasTasks()) {
       return;
     }
     eventBaseKeepAlive_ = getKeepAliveToken(eventBase_);
   }
   if (loopRunner_) {
     if (fm_->hasReadyTasks()) {
       loopRunner_->run([&] { fm_->loopUntilNoReadyImpl(); });
     }
   } else {
     fm_->loopUntilNoReadyImpl();
   }
   if (!fm_->hasTasks()) {
     eventBaseKeepAlive_.reset();
   }
 }

void folly::fibers::EventBaseLoopController::schedule ( )

inlineoverrideprivatevirtual

Called by FiberManager to schedule the loop function run at some point in the futufre.

Implements folly::fibers::LoopController.

Definition at line 51 of file EventBaseLoopController-inl.h.

References awaitingScheduling_, callback_, eventBase_, eventBaseKeepAlive_, folly::VirtualEventBase::getEventBase(), folly::getKeepAliveToken(), and folly::EventBase::runInLoop().

Referenced by attachEventBase().

                                               {
   if (eventBase_ == nullptr) {
     // In this case we need to postpone scheduling.
     awaitingScheduling_ = true;
   } else {
     // Schedule it to run in current iteration.
 
     if (!eventBaseKeepAlive_) {
       eventBaseKeepAlive_ = getKeepAliveToken(eventBase_);
     }
     eventBase_->getEventBase().runInLoop(&callback_, true);
     awaitingScheduling_ = false;
   }
 }

void folly::fibers::EventBaseLoopController::scheduleThreadSafe ( )

inlineoverrideprivatevirtual

Same as schedule(), but safe to call from any thread.

Implements folly::fibers::LoopController.

Definition at line 87 of file EventBaseLoopController-inl.h.

References eventBase_, eventBaseAttached_, eventBaseKeepAlive_, fm_, folly::getKeepAliveToken(), folly::fibers::FiberManager::hasTasks(), folly::VirtualEventBase::runInEventBaseThread(), runLoop(), and folly::fibers::FiberManager::shouldRunLoopRemote().

                                                         {
   /* The only way we could end up here is if
      1) Fiber thread creates a fiber that awaits (which means we must
         have already attached, fiber thread wouldn't be running).
      2) We move the promise to another thread (this move is a memory fence)
      3) We fulfill the promise from the other thread. */
   assert(eventBaseAttached_);
 
   eventBase_->runInEventBaseThread(
       [this, eventBaseKeepAlive = getKeepAliveToken(eventBase_)]() {
         if (fm_->shouldRunLoopRemote()) {
           return runLoop();
         }
 
         if (!fm_->hasTasks()) {
           eventBaseKeepAlive_.reset();
         }
       });
 }

void folly::fibers::EventBaseLoopController::setFiberManager ( FiberManager * )

inlineoverrideprivatevirtual

Called by FiberManager to associate itself with the LoopController.

Implements folly::fibers::LoopController.

Definition at line 47 of file EventBaseLoopController-inl.h.

References fm_.

                                                                      {
   fm_ = fm;
 }

void folly::fibers::EventBaseLoopController::setLoopRunner ( InlineFunctionRunner * loopRunner )

inline

Definition at line 42 of file EventBaseLoopController.h.

References loopRunner_.

                                                        {
     loopRunner_ = loopRunner;
   }

void folly::fibers::EventBaseLoopController::timedSchedule	(	std::function< void()>	func,
		TimePoint	time
	)

inlineoverrideprivatevirtual

Called by FiberManager to schedule some function to be run at some time.

Implements folly::fibers::LoopController.

Definition at line 107 of file EventBaseLoopController-inl.h.

References count, eventBase_, eventBaseAttached_, now(), folly::TimeoutManager::tryRunAfterDelay(), and uint32_t.

                     {
   assert(eventBaseAttached_);
 
   // We want upper bound for the cast, thus we just add 1
   auto delay_ms =
       std::chrono::duration_cast<std::chrono::milliseconds>(time - Clock::now())
           .count() +
       1;
   // If clock is not monotonic
   delay_ms = std::max<decltype(delay_ms)>(delay_ms, 0);
   eventBase_->tryRunAfterDelay(func, uint32_t(delay_ms));
 }