proxygen: folly::fibers::FiberManager Class Reference

Single-threaded task execution engine. More...

#include <FiberManagerInternal.h>

Inheritance diagram for folly::fibers::FiberManager:

Classes
struct	AddTaskFinallyHelper

struct	AddTaskHelper

struct	FibersPoolResizer

struct	Options

struct	RemoteTask

Public Types
using	ExceptionCallback = folly::Function< void(std::exception_ptr, std::string)>

Public Member Functions
	FiberManager (const FiberManager &)=delete

FiberManager &	operator= (const FiberManager &)=delete

	FiberManager (std::unique_ptr< LoopController > loopController, Options options=Options())

template<typename LocalT >
	FiberManager (LocalType< LocalT >, std::unique_ptr< LoopController > loopController, Options options=Options())

	~FiberManager () override

LoopController &	loopController ()

const LoopController &	loopController () const

void	loopUntilNoReady ()

void	loopUntilNoReadyImpl ()

bool	shouldRunLoopRemote ()

bool	hasTasks () const

bool	hasReadyTasks () const

void	setExceptionCallback (ExceptionCallback ec)

template<typename F >
void	addTask (F &&func)

template<typename F >
auto	addTaskFuture (F &&func) -> folly::Future< typename folly::lift_unit< invoke_result_t< F >>::type >

template<typename F >
void	addTaskRemote (F &&func)

template<typename F >
auto	addTaskRemoteFuture (F &&func) -> folly::Future< typename folly::lift_unit< invoke_result_t< F >>::type >

void	add (folly::Func f) override

template<typename F , typename G >
void	addTaskFinally (F &&func, G &&finally)

template<typename F >
invoke_result_t< F >	runInMainContext (F &&func)

template<typename T >
T &	local ()

size_t	fibersAllocated () const

size_t	fibersPoolSize () const

bool	hasActiveFiber () const

Fiber *	currentFiber () const

size_t	stackHighWatermark () const

void	yield ()

void	setObserver (ExecutionObserver *observer)

ExecutionObserver *	getObserver ()

void	setPreemptRunner (InlineFunctionRunner *preemptRunner)

size_t	runQueueSize () const

template<typename T >
T &	localThread ()

Public Member Functions inherited from folly::Executor
virtual	~Executor ()

virtual void	addWithPriority (Func, int8_t priority)

virtual uint8_t	getNumPriorities () const

Static Public Member Functions
template<typename T >
static FOLLY_EXPORT T &	localThread ()

static FiberManager &	getFiberManager ()

static FiberManager *	getFiberManagerUnsafe ()

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)

Private Types
typedef folly::IntrusiveList< Fiber,&Fiber::listHook_ >	FiberTailQueue

typedef folly::IntrusiveList< Fiber,&Fiber::globalListHook_ >	GlobalFiberTailQueue

Private Member Functions
void	activateFiber (Fiber *fiber)

void	deactivateFiber (Fiber *fiber)

void	ensureLoopScheduled ()

Fiber *	getFiber ()

void	initLocalData (Fiber &fiber)

void	doFibersPoolResizing ()

void	runReadyFiber (Fiber *fiber)

void	remoteReadyInsert (Fiber *fiber)

void	registerAlternateSignalStack ()

Private Attributes
Fiber *	activeFiber_ {nullptr}

Fiber *	currentFiber_ {nullptr}

FiberTailQueue	readyFibers_

FiberTailQueue	yieldedFibers_

FiberTailQueue	fibersPool_

GlobalFiberTailQueue	allFibers_

size_t	fibersAllocated_ {0}

size_t	fibersPoolSize_ {0}

size_t	fibersActive_ {0}

size_t	fiberId_ {0}

size_t	maxFibersActiveLastPeriod_ {0}

std::unique_ptr< LoopController >	loopController_

bool	isLoopScheduled_ {false}

GuardPageAllocator	stackAllocator_

const Options	options_

size_t	stackHighWatermark_ {0}

folly::Function< void(Fiber &)>	awaitFunc_

folly::Function< void()>	immediateFunc_

InlineFunctionRunner *	preemptRunner_ {nullptr}

ExecutionObserver *	observer_ {nullptr}

ExceptionCallback	exceptionCallback_

folly::AtomicIntrusiveLinkedList< Fiber,&Fiber::nextRemoteReady_ >	remoteReadyQueue_

folly::AtomicIntrusiveLinkedList< RemoteTask,&RemoteTask::nextRemoteTask >	remoteTaskQueue_

ssize_t	remoteCount_ {0}

std::shared_ptr< TimeoutController >	timeoutManager_

FibersPoolResizer	fibersPoolResizer_

bool	fibersPoolResizerScheduled_ {false}

std::type_index	localType_

bool	alternateSignalStackRegistered_ {false}

Static Private Attributes
static FOLLY_TLS FiberManager *	currentFiberManager_ = nullptr

Friends
class	Baton

class	Fiber

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

Protected Member Functions inherited from folly::Executor
virtual bool	keepAliveAcquire ()

virtual void	keepAliveRelease ()

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

Single-threaded task execution engine.

FiberManager allows semi-parallel task execution on the same thread. Each task can notify FiberManager that it is blocked on something (via await()) call. This will pause execution of this task and it will be resumed only when it is unblocked (via setData()).

Definition at line 77 of file FiberManagerInternal.h.

Member Typedef Documentation

using folly::fibers::FiberManager::ExceptionCallback = folly::Function<void(std::exception_ptr, std::string)>

Definition at line 129 of file FiberManagerInternal.h.

typedef folly::IntrusiveList<Fiber, &Fiber::listHook_> folly::fibers::FiberManager::FiberTailQueue

private

Definition at line 370 of file FiberManagerInternal.h.

typedef folly::IntrusiveList<Fiber, &Fiber::globalListHook_> folly::fibers::FiberManager::GlobalFiberTailQueue

private

Definition at line 372 of file FiberManagerInternal.h.

Constructor & Destructor Documentation

folly::fibers::FiberManager::FiberManager ( const FiberManager & )

delete

folly::fibers::FiberManager::FiberManager	(	std::unique_ptr< LoopController >	loopController,
		Options	options = `Options()`
	)

explicit

Initializes, but doesn't start FiberManager loop

Parameters

loopController
options	FiberManager options

Definition at line 73 of file FiberManager.cpp.

     : FiberManager(
           LocalType<void>(),
           std::move(loopController),
           std::move(options)) {}

template<typename LocalT >

folly::fibers::FiberManager::FiberManager	(	LocalType< LocalT >	,
		std::unique_ptr< LoopController >	loopController,
		Options	options = `Options()`
	)

Initializes, but doesn't start FiberManager loop

Parameters

loopController
options	FiberManager options

Template Parameters

LocalT only local of this type may be stored on fibers. Locals of other types will be considered thread-locals.

Definition at line 531 of file FiberManagerInternal-inl.h.

References context, folly::DFATAL, fibersPoolResizer_, localType_, loopController_, name, and timeoutManager_.

     : loopController_(std::move(loopController__)),
       stackAllocator_(options.useGuardPages),
       options_(preprocessOptions(std::move(options))),
       exceptionCallback_([](std::exception_ptr eptr, std::string context) {
         try {
           std::rethrow_exception(eptr);
         } catch (const std::exception& e) {
           LOG(DFATAL) << "Exception " << typeid(e).name() << " with message '"
                       << e.what() << "' was thrown in "
                       << "FiberManager with context '" << context << "'";
         } catch (...) {
           LOG(DFATAL) << "Unknown exception was thrown in FiberManager with "
                       << "context '" << context << "'";
         }
       }),
       timeoutManager_(std::make_shared<TimeoutController>(*loopController_)),
       fibersPoolResizer_(*this),
       localType_(typeid(LocalT)) {
   loopController_->setFiberManager(this);
 }

folly::fibers::FiberManager::~FiberManager ( )

override

Definition at line 81 of file FiberManager.cpp.

References fibersActive_, fibersPool_, loopController_, and readyFibers_.

                             {
   loopController_.reset();
 
   while (!fibersPool_.empty()) {
     fibersPool_.pop_front_and_dispose([](Fiber* fiber) { delete fiber; });
   }
   assert(readyFibers_.empty());
   assert(fibersActive_ == 0);
 }

Member Function Documentation

void folly::fibers::FiberManager::activateFiber ( Fiber * fiber )

inlineprivate

Definition at line 59 of file FiberManagerInternal-inl.h.

References folly::fibers::FiberImpl::activate(), activeFiber_, folly::fibers::Fiber::fiberImpl_, folly::fibers::Fiber::getStack(), and SCOPE_EXIT.

Referenced by runReadyFiber().

                                                     {
   DCHECK_EQ(activeFiber_, (Fiber*)nullptr);
 
 #ifdef FOLLY_SANITIZE_ADDRESS
   DCHECK(!fiber->asanMainStackBase_);
   DCHECK(!fiber->asanMainStackSize_);
   auto stack = fiber->getStack();
   void* asanFakeStack;
   registerStartSwitchStackWithAsan(&asanFakeStack, stack.first, stack.second);
   SCOPE_EXIT {
     registerFinishSwitchStackWithAsan(asanFakeStack, nullptr, nullptr);
     fiber->asanMainStackBase_ = nullptr;
     fiber->asanMainStackSize_ = 0;
   };
 #endif
 
   activeFiber_ = fiber;
   fiber->fiberImpl_.activate();
 }

void folly::fibers::FiberManager::add ( folly::Func )

inlineoverridevirtual

Enqueue a function to executed by this executor. This and all variants must be threadsafe.

Implements folly::Executor.

Definition at line 239 of file FiberManagerInternal.h.

References folly::fibers::addTaskFinally(), FOLLY_EXPORT, folly::fibers::local(), folly::gen::move, folly::fibers::runInMainContext(), and folly::T.

Referenced by folly::FiberIOExecutor::add(), and AtomicBatchDispatcherTesting::dispatchJobs().

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

template<typename F >

void folly::fibers::FiberManager::addTask ( F && func )

Add a new task to be executed. Must be called from FiberManager's thread.

Parameters

func	Task functor; must have a signature of `void func()`. The object will be destroyed once task execution is complete.

Definition at line 306 of file FiberManagerInternal-inl.h.

References ensureLoopScheduled(), getFiber(), initLocalData(), observer_, readyFibers_, and folly::ExecutionObserver::runnable().

Referenced by folly::fibers::addTask(), BENCHMARK(), main(), runBenchmark(), TEST(), and testFiberLocal().

                                    {
   typedef AddTaskHelper<F> Helper;
 
   auto fiber = getFiber();
   initLocalData(*fiber);
 
   if (Helper::allocateInBuffer) {
     auto funcLoc = static_cast<typename Helper::Func*>(fiber->getUserBuffer());
     new (funcLoc) typename Helper::Func(std::forward<F>(func), *this);
 
     fiber->setFunction(std::ref(*funcLoc));
   } else {
     auto funcLoc = new typename Helper::Func(std::forward<F>(func), *this);
 
     fiber->setFunction(std::ref(*funcLoc));
   }
 
   readyFibers_.push_back(*fiber);
   if (observer_) {
     observer_->runnable(reinterpret_cast<uintptr_t>(fiber));
   }
 
   ensureLoopScheduled();
 }

template<typename F , typename G >

void folly::fibers::FiberManager::addTaskFinally	(	F &&	func,
		G &&	finally
	)

Add a new task. When the task is complete, execute finally(Try<Result>&&) on the main context.

Parameters

func	Task functor; must have a signature of `T func()` for some T.
finally	Finally functor; must have a signature of `void finally(Try<T>&&)` and will be passed the result of func() (including the exception if occurred).

Definition at line 417 of file FiberManagerInternal-inl.h.

References ensureLoopScheduled(), getFiber(), initLocalData(), observer_, readyFibers_, folly::ExecutionObserver::runnable(), type, and folly::value().

Referenced by folly::fibers::addTaskFinally(), and TEST().

                                                        {
   typedef invoke_result_t<F> Result;
 
   static_assert(
       IsRvalueRefTry<typename FirstArgOf<G>::type>::value,
       "finally(arg): arg must be Try<T>&&");
   static_assert(
       std::is_convertible<
           Result,
           typename std::remove_reference<
               typename FirstArgOf<G>::type>::type::element_type>::value,
       "finally(Try<T>&&): T must be convertible from func()'s return type");
 
   auto fiber = getFiber();
   initLocalData(*fiber);
 
   typedef AddTaskFinallyHelper<
       typename std::decay<F>::type,
       typename std::decay<G>::type>
       Helper;
 
   if (Helper::allocateInBuffer) {
     auto funcLoc = static_cast<typename Helper::Func*>(fiber->getUserBuffer());
     auto finallyLoc =
         static_cast<typename Helper::Finally*>(static_cast<void*>(funcLoc + 1));
 
     new (finallyLoc) typename Helper::Finally(std::forward<G>(finally), *this);
     new (funcLoc) typename Helper::Func(std::forward<F>(func), *finallyLoc);
 
     fiber->setFunctionFinally(std::ref(*funcLoc), std::ref(*finallyLoc));
   } else {
     auto finallyLoc =
         new typename Helper::Finally(std::forward<G>(finally), *this);
     auto funcLoc =
         new typename Helper::Func(std::forward<F>(func), *finallyLoc);
 
     fiber->setFunctionFinally(std::ref(*funcLoc), std::ref(*finallyLoc));
   }
 
   readyFibers_.push_back(*fiber);
   if (observer_) {
     observer_->runnable(reinterpret_cast<uintptr_t>(fiber));
   }
 
   ensureLoopScheduled();
 }

template<typename F >

auto folly::fibers::FiberManager::addTaskFuture ( F && func ) -> folly::Future<typename folly::lift_unit<invoke_result_t<F>>::type>

Add a new task to be executed and return a future that will be set on return from func. Must be called from FiberManager's thread.

Parameters

func	Task functor; must have a signature of `void func()`. The object will be destroyed once task execution is complete.

Definition at line 25 of file FiberManager-inl.h.

References folly::fibers::addTaskFinally(), f, folly::Promise< T >::getFuture(), folly::gen::move, folly::Promise< T >::setTry(), folly::pushmi::detail::t, and folly::T.

Referenced by TEST().

                                                                     {
   using T = invoke_result_t<F>;
   using FutureT = typename folly::lift_unit<T>::type;
 
   folly::Promise<FutureT> p;
   auto f = p.getFuture();
   addTaskFinally(
       [func = std::forward<F>(func)]() mutable { return func(); },
       [p = std::move(p)](folly::Try<T>&& t) mutable {
         p.setTry(std::move(t));
       });
   return f;
 }

template<typename F >

void folly::fibers::FiberManager::addTaskRemote ( F && func )

Add a new task to be executed. Safe to call from other threads.

Parameters

func	Task function; must have a signature of `void func()`. The object will be destroyed once task execution is complete.

Definition at line 332 of file FiberManagerInternal-inl.h.

References getFiberManagerUnsafe(), localType_, loopController_, and remoteTaskQueue_.

Referenced by TEST(), and testFiberLocal().

                                          {
   auto task = [&]() {
     auto currentFm = getFiberManagerUnsafe();
     if (currentFm && currentFm->currentFiber_ &&
         currentFm->localType_ == localType_) {
       return std::make_unique<RemoteTask>(
           std::forward<F>(func), currentFm->currentFiber_->localData_);
     }
     return std::make_unique<RemoteTask>(std::forward<F>(func));
   }();
   if (remoteTaskQueue_.insertHead(task.release())) {
     loopController_->scheduleThreadSafe();
   }
 }

template<typename F >

auto folly::fibers::FiberManager::addTaskRemoteFuture ( F && func ) -> folly::Future<typename folly::lift_unit<invoke_result_t<F>>::type>

Add a new task to be executed and return a future that will be set on return from func. Safe to call from other threads.

Parameters

func	Task function; must have a signature of `void func()`. The object will be destroyed once task execution is complete.

Definition at line 41 of file FiberManager-inl.h.

References f, folly::Promise< T >::getFuture(), folly::makeTryWith(), folly::gen::move, folly::fibers::runInMainContext(), folly::Promise< T >::setTry(), folly::pushmi::detail::t, and type.

Referenced by TEST().

                                                                     {
   folly::Promise<typename folly::lift_unit<invoke_result_t<F>>::type> p;
   auto f = p.getFuture();
   addTaskRemote(
       [p = std::move(p), func = std::forward<F>(func), this]() mutable {
         auto t = folly::makeTryWith(std::forward<F>(func));
         runInMainContext([&]() { p.setTry(std::move(t)); });
       });
   return f;
 }

Fiber* folly::fibers::FiberManager::currentFiber ( ) const

inline

Returns: The currently running fiber or null if no fiber is executing.

Definition at line 297 of file FiberManagerInternal.h.

References folly::fibers::yield().

                               {
     return currentFiber_;
   }

void folly::fibers::FiberManager::deactivateFiber ( Fiber * fiber )

inlineprivate

Definition at line 79 of file FiberManagerInternal-inl.h.

References activeFiber_, folly::fibers::FiberImpl::deactivate(), folly::fibers::Fiber::fiberImpl_, and SCOPE_EXIT.

Referenced by folly::fibers::Fiber::fiberFunc(), and folly::fibers::Fiber::preempt().

                                                       {
   DCHECK_EQ(activeFiber_, fiber);
 
 #ifdef FOLLY_SANITIZE_ADDRESS
   DCHECK(fiber->asanMainStackBase_);
   DCHECK(fiber->asanMainStackSize_);
 
   registerStartSwitchStackWithAsan(
       &fiber->asanFakeStack_,
       fiber->asanMainStackBase_,
       fiber->asanMainStackSize_);
   SCOPE_EXIT {
     registerFinishSwitchStackWithAsan(
         fiber->asanFakeStack_,
         &fiber->asanMainStackBase_,
         &fiber->asanMainStackSize_);
     fiber->asanFakeStack_ = nullptr;
   };
 #endif
 
   activeFiber_ = nullptr;
   fiber->fiberImpl_.deactivate();
 }

void folly::fibers::FiberManager::doFibersPoolResizing ( )

private

Definition at line 170 of file FiberManager.cpp.

References fibersActive_, fibersAllocated_, fibersPool_, fibersPoolSize_, maxFibersActiveLastPeriod_, folly::fibers::FiberManager::Options::maxFibersPoolSize, and options_.

                                         {
   while (fibersAllocated_ > maxFibersActiveLastPeriod_ &&
          fibersPoolSize_ > options_.maxFibersPoolSize) {
     auto fiber = &fibersPool_.front();
     assert(fiber != nullptr);
     fibersPool_.pop_front();
     delete fiber;
     --fibersPoolSize_;
     --fibersAllocated_;
   }
 
   maxFibersActiveLastPeriod_ = fibersActive_;
 }

void folly::fibers::FiberManager::ensureLoopScheduled ( )

inlineprivate

Schedules a loop with loopController (unless already scheduled before).

Definition at line 50 of file FiberManagerInternal-inl.h.

References isLoopScheduled_, and loopController_.

Referenced by addTask(), addTaskFinally(), loopUntilNoReadyImpl(), and folly::fibers::Fiber::resume().

                                               {
   if (isLoopScheduled_) {
     return;
   }
 
   isLoopScheduled_ = true;
   loopController_->schedule();
 }

size_t folly::fibers::FiberManager::fibersAllocated ( ) const

Returns: How many fiber objects (and stacks) has this manager allocated.

Definition at line 137 of file FiberManager.cpp.

References fibersAllocated_.

Referenced by TEST().

                                            {
   return fibersAllocated_;
 }

size_t folly::fibers::FiberManager::fibersPoolSize ( ) const

Returns: How many of the allocated fiber objects are currently in the free pool.

Definition at line 141 of file FiberManager.cpp.

References fibersPoolSize_.

Referenced by BENCHMARK(), and TEST().

                                           {
   return fibersPoolSize_;
 }

Fiber * folly::fibers::FiberManager::getFiber ( )

private

Returns: An initialized Fiber object from the pool

Definition at line 104 of file FiberManager.cpp.

References Fiber, fiberId_, fibersActive_, fibersAllocated_, fibersPool_, folly::fibers::FiberManager::Options::fibersPoolResizePeriodMs, fibersPoolResizer_, fibersPoolResizerScheduled_, fibersPoolSize_, folly::fibers::Fiber::init(), maxFibersActiveLastPeriod_, options_, and folly::fibers::FiberManager::Options::recordStackEvery.

Referenced by addTask(), addTaskFinally(), and loopUntilNoReadyImpl().

                               {
   Fiber* fiber = nullptr;
 
   if (options_.fibersPoolResizePeriodMs > 0 && !fibersPoolResizerScheduled_) {
     fibersPoolResizer_();
     fibersPoolResizerScheduled_ = true;
   }
 
   if (fibersPool_.empty()) {
     fiber = new Fiber(*this);
     ++fibersAllocated_;
   } else {
     fiber = &fibersPool_.front();
     fibersPool_.pop_front();
     assert(fibersPoolSize_ > 0);
     --fibersPoolSize_;
   }
   assert(fiber);
   if (++fibersActive_ > maxFibersActiveLastPeriod_) {
     maxFibersActiveLastPeriod_ = fibersActive_;
   }
   ++fiberId_;
   bool recordStack = (options_.recordStackEvery != 0) &&
       (fiberId_ % options_.recordStackEvery == 0);
   fiber->init(recordStack);
   return fiber;
 }

FiberManager & folly::fibers::FiberManager::getFiberManager ( )

inlinestatic

Definition at line 483 of file FiberManagerInternal-inl.h.

References currentFiberManager_.

Referenced by folly::fibers::addTask(), and folly::fibers::addTaskFinally().

                                                    {
   assert(currentFiberManager_ != nullptr);
   return *currentFiberManager_;
 }

FiberManager * folly::fibers::FiberManager::getFiberManagerUnsafe ( )

inlinestatic

Definition at line 488 of file FiberManagerInternal-inl.h.

References currentFiberManager_.

Referenced by addTaskRemote(), initLocalData(), folly::fibers::local(), folly::fibers::onFiber(), folly::fibers::runInMainContext(), TEST(), folly::fibers::Baton::try_wait_for(), folly::fibers::Baton::wait(), and folly::fibers::yield().

                                                          {
   return currentFiberManager_;
 }

ExecutionObserver * folly::fibers::FiberManager::getObserver ( )

Returns: Current observer for this FiberManager. Returns nullptr if no observer has been set.

Definition at line 162 of file FiberManager.cpp.

References observer_.

                                              {
   return observer_;
 }

bool folly::fibers::FiberManager::hasActiveFiber ( ) const

inline

return true if running activeFiber_ is not nullptr.

Definition at line 492 of file FiberManagerInternal-inl.h.

References activeFiber_.

Referenced by TEST().

                                                {
   return activeFiber_ != nullptr;
 }

bool folly::fibers::FiberManager::hasReadyTasks ( ) const

inline

Returns: true if there are tasks ready to run.

Definition at line 267 of file FiberManagerInternal-inl.h.

References readyFibers_, remoteReadyQueue_, and remoteTaskQueue_.

Referenced by folly::fibers::EventBaseLoopController::runLoop().

                                               {
   return !readyFibers_.empty() || !remoteReadyQueue_.empty() ||
       !remoteTaskQueue_.empty();
 }

bool folly::fibers::FiberManager::hasTasks ( ) const

Returns: true if there are outstanding tasks.

Definition at line 99 of file FiberManager.cpp.

References fibersActive_, remoteCount_, remoteReadyQueue_, and remoteTaskQueue_.

Referenced by folly::fibers::SimpleLoopController::loop(), folly::fibers::ExecutorLoopController::runLoop(), folly::fibers::EventBaseLoopController::runLoop(), folly::fibers::EventBaseLoopController::scheduleThreadSafe(), TEST(), and testFiberLocal().

                                   {
   return fibersActive_ > 0 || !remoteReadyQueue_.empty() ||
       !remoteTaskQueue_.empty() || remoteCount_ > 0;
 }

void folly::fibers::FiberManager::initLocalData ( Fiber & fiber )

inlineprivate

Sets local data for given fiber if all conditions are met.

Definition at line 522 of file FiberManagerInternal-inl.h.

References getFiberManagerUnsafe(), folly::fibers::Fiber::localData_, localType_, folly::fibers::Fiber::rcontext_, and folly::RequestContext::saveContext().

Referenced by addTask(), and addTaskFinally().

                                                     {
   auto fm = getFiberManagerUnsafe();
   if (fm && fm->currentFiber_ && fm->localType_ == localType_) {
     fiber.localData_ = fm->currentFiber_->localData_;
   }
   fiber.rcontext_ = RequestContext::saveContext();
 }

template<typename T >

T & folly::fibers::FiberManager::local ( )

Returns a refference to a fiber-local context for given Fiber. Should be always called with the same T for each fiber. Fiber-local context is lazily default-constructed on first request. When new task is scheduled via addTask / addTaskRemote from a fiber its fiber-local context is copied into the new fiber.

Definition at line 504 of file FiberManagerInternal-inl.h.

References currentFiber_, folly::fibers::Fiber::LocalData::get(), folly::fibers::Fiber::localData_, localType_, and folly::T.

                        {
   if (std::type_index(typeid(T)) == localType_ && currentFiber_) {
     return currentFiber_->localData_.get<T>();
   }
   return localThread<T>();
 }

template<typename T >

static FOLLY_EXPORT T& folly::fibers::FiberManager::localThread ( )

static

template<typename T >

T& folly::fibers::FiberManager::localThread ( )

Definition at line 512 of file FiberManagerInternal-inl.h.

References folly::pushmi::detail::t, and folly::T.

                              {
 #ifndef __APPLE__
   static thread_local T t;
   return t;
 #else // osx doesn't support thread_local
   static ThreadLocal<T> t;
   return *t;
 #endif
 }

LoopController & folly::fibers::FiberManager::loopController ( )

Controller access.

Definition at line 91 of file FiberManager.cpp.

References loopController_.

Referenced by main(), runBenchmark(), and TEST().

                                              {
   return *loopController_;
 }

const LoopController & folly::fibers::FiberManager::loopController ( ) const

Definition at line 95 of file FiberManager.cpp.

References loopController_.

                                                          {
   return *loopController_;
 }

void folly::fibers::FiberManager::loopUntilNoReady ( )

inline

Keeps running ready tasks until the list of ready tasks is empty.

Definition at line 186 of file FiberManagerInternal-inl.h.

References loopController_.

Referenced by BENCHMARK(), TEST(), and testFiberLocal().

                                            {
   return loopController_->runLoop();
 }

void folly::fibers::FiberManager::loopUntilNoReadyImpl ( )

inline

This should only be called by a LoopController.

Definition at line 190 of file FiberManagerInternal-inl.h.

References alternateSignalStackRegistered_, currentFiberManager_, ensureLoopScheduled(), folly::fibers::FiberManager::RemoteTask::func, getFiber(), isLoopScheduled_, folly::fibers::FiberManager::RemoteTask::localData, folly::fibers::Fiber::localData_, folly::gen::move, observer_, folly::fibers::FiberManager::RemoteTask::rcontext, folly::fibers::Fiber::rcontext_, readyFibers_, registerAlternateSignalStack(), remoteCount_, remoteReadyQueue_, remoteTaskQueue_, folly::ExecutionObserver::runnable(), runReadyFiber(), folly::RequestContext::saveContext(), SCOPE_EXIT, folly::RequestContext::setContext(), folly::fibers::Fiber::setFunction(), folly::f14::swap(), UNLIKELY, and yieldedFibers_.

Referenced by folly::fibers::ExecutorLoopController::runLoop(), folly::fibers::EventBaseLoopController::runLoop(), and folly::fibers::SimpleLoopController::runLoop().

                                                {
 #ifndef _WIN32
   if (UNLIKELY(!alternateSignalStackRegistered_)) {
     registerAlternateSignalStack();
   }
 #endif
 
   // Support nested FiberManagers
   auto originalFiberManager = this;
   std::swap(currentFiberManager_, originalFiberManager);
 
   // Save current context, and reset it after executing all fibers.
   // This can avoid a lot of context swapping,
   // if the Fibers share the same context
   auto curCtx = RequestContext::saveContext();
 
   SCOPE_EXIT {
     RequestContext::setContext(std::move(curCtx));
     isLoopScheduled_ = false;
     if (!readyFibers_.empty()) {
       ensureLoopScheduled();
     }
     std::swap(currentFiberManager_, originalFiberManager);
     CHECK_EQ(this, originalFiberManager);
   };
 
   bool hadRemote = true;
   while (hadRemote) {
     while (!readyFibers_.empty()) {
       auto& fiber = readyFibers_.front();
       readyFibers_.pop_front();
       runReadyFiber(&fiber);
     }
 
     auto hadRemoteFiber = remoteReadyQueue_.sweepOnce(
         [this](Fiber* fiber) { runReadyFiber(fiber); });
 
     if (hadRemoteFiber) {
       ++remoteCount_;
     }
 
     auto hadRemoteTask =
         remoteTaskQueue_.sweepOnce([this](RemoteTask* taskPtr) {
           std::unique_ptr<RemoteTask> task(taskPtr);
           auto fiber = getFiber();
           if (task->localData) {
             fiber->localData_ = *task->localData;
           }
           fiber->rcontext_ = std::move(task->rcontext);
 
           fiber->setFunction(std::move(task->func));
           if (observer_) {
             observer_->runnable(reinterpret_cast<uintptr_t>(fiber));
           }
           runReadyFiber(fiber);
         });
 
     if (hadRemoteTask) {
       ++remoteCount_;
     }
 
     hadRemote = hadRemoteTask || hadRemoteFiber;
   }
 
   if (observer_) {
     for (auto& yielded : yieldedFibers_) {
       observer_->runnable(reinterpret_cast<uintptr_t>(&yielded));
     }
   }
   readyFibers_.splice(readyFibers_.end(), yieldedFibers_);
 }

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

delete

Referenced by folly::fibers::FiberManager::FibersPoolResizer::operator()().

void folly::fibers::FiberManager::registerAlternateSignalStack ( )

private

Definition at line 361 of file FiberManager.cpp.

References alternateSignalStackRegistered_, and folly::SingletonThreadLocal< T, Tag, Make, TLTag >::get().

Referenced by loopUntilNoReadyImpl().

                                                 {
   SingletonThreadLocal<ScopedAlternateSignalStack>::get();
 
   alternateSignalStackRegistered_ = true;
 }

void folly::fibers::FiberManager::remoteReadyInsert ( Fiber * fiber )

private

Definition at line 149 of file FiberManager.cpp.

References loopController_, observer_, remoteReadyQueue_, and folly::ExecutionObserver::runnable().

Referenced by folly::fibers::Fiber::resume().

                                                  {
   if (observer_) {
     observer_->runnable(reinterpret_cast<uintptr_t>(fiber));
   }
   if (remoteReadyQueue_.insertHead(fiber)) {
     loopController_->scheduleThreadSafe();
   }
 }

template<typename F >

invoke_result_t< F > folly::fibers::FiberManager::runInMainContext ( F && func )

If called from a fiber, immediately switches to the FiberManager's context and runs func(), going back to the Fiber's context after completion. Outside a fiber, just calls func() directly.

Returns: value returned by func().

Definition at line 465 of file FiberManagerInternal-inl.h.

References activeFiber_, folly::fibers::Fiber::AWAITING_IMMEDIATE, f, immediateFunc_, folly::gen::move, folly::fibers::Fiber::preempt(), folly::tryEmplaceWith(), and UNLIKELY.

Referenced by TEST().

                                                           {
   if (UNLIKELY(activeFiber_ == nullptr)) {
     return func();
   }
 
   typedef invoke_result_t<F> Result;
 
   folly::Try<Result> result;
   auto f = [&func, &result]() mutable {
     folly::tryEmplaceWith(result, std::forward<F>(func));
   };
 
   immediateFunc_ = std::ref(f);
   activeFiber_->preempt(Fiber::AWAITING_IMMEDIATE);
 
   return std::move(result).value();
 }

size_t folly::fibers::FiberManager::runQueueSize ( ) const

inline

Returns an estimate of the number of fibers which are waiting to run (does not include fibers or tasks scheduled remotely).

Definition at line 337 of file FiberManagerInternal.h.

References folly::fibers::getFiberManager().

                               {
     return readyFibers_.size() + yieldedFibers_.size();
   }

void folly::fibers::FiberManager::runReadyFiber ( Fiber * fiber )

inlineprivate

Definition at line 103 of file FiberManagerInternal-inl.h.

Referenced by loopUntilNoReadyImpl().

                                                     {
   SCOPE_EXIT {
     assert(currentFiber_ == nullptr);
     assert(activeFiber_ == nullptr);
   };
 
   assert(
       fiber->state_ == Fiber::NOT_STARTED ||
       fiber->state_ == Fiber::READY_TO_RUN);
   currentFiber_ = fiber;
   // Note: resetting the context is handled by the loop
   RequestContext::setContext(std::move(fiber->rcontext_));
   if (observer_) {
     observer_->starting(reinterpret_cast<uintptr_t>(fiber));
   }
 
   while (fiber->state_ == Fiber::NOT_STARTED ||
          fiber->state_ == Fiber::READY_TO_RUN) {
     activateFiber(fiber);
     if (fiber->state_ == Fiber::AWAITING_IMMEDIATE) {
       try {
         immediateFunc_();
       } catch (...) {
         exceptionCallback_(std::current_exception(), "running immediateFunc_");
       }
       immediateFunc_ = nullptr;
       fiber->state_ = Fiber::READY_TO_RUN;
     }
   }
 
   if (fiber->state_ == Fiber::AWAITING) {
     awaitFunc_(*fiber);
     awaitFunc_ = nullptr;
     if (observer_) {
       observer_->stopped(reinterpret_cast<uintptr_t>(fiber));
     }
     currentFiber_ = nullptr;
     fiber->rcontext_ = RequestContext::saveContext();
   } else if (fiber->state_ == Fiber::INVALID) {
     assert(fibersActive_ > 0);
     --fibersActive_;
     // Making sure that task functor is deleted once task is complete.
     // NOTE: we must do it on main context, as the fiber is not
     // running at this point.
     fiber->func_ = nullptr;
     fiber->resultFunc_ = nullptr;
     if (fiber->finallyFunc_) {
       try {
         fiber->finallyFunc_();
       } catch (...) {
         exceptionCallback_(std::current_exception(), "running finallyFunc_");
       }
       fiber->finallyFunc_ = nullptr;
     }
     // Make sure LocalData is not accessible from its destructor
     if (observer_) {
       observer_->stopped(reinterpret_cast<uintptr_t>(fiber));
     }
     currentFiber_ = nullptr;
     fiber->rcontext_ = RequestContext::saveContext();
     fiber->localData_.reset();
     fiber->rcontext_.reset();
 
     if (fibersPoolSize_ < options_.maxFibersPoolSize ||
         options_.fibersPoolResizePeriodMs > 0) {
       fibersPool_.push_front(*fiber);
       ++fibersPoolSize_;
     } else {
       delete fiber;
       assert(fibersAllocated_ > 0);
       --fibersAllocated_;
     }
   } else if (fiber->state_ == Fiber::YIELDED) {
     if (observer_) {
       observer_->stopped(reinterpret_cast<uintptr_t>(fiber));
     }
     currentFiber_ = nullptr;
     fiber->rcontext_ = RequestContext::saveContext();
     fiber->state_ = Fiber::READY_TO_RUN;
     yieldedFibers_.push_back(*fiber);
   }
 }

void folly::fibers::FiberManager::setExceptionCallback ( FiberManager::ExceptionCallback ec )

Sets exception callback which will be called if any of the tasks throws an exception.

Parameters

Definition at line 132 of file FiberManager.cpp.

References exceptionCallback_, and folly::gen::move.

                                                                         {
   assert(ec);
   exceptionCallback_ = std::move(ec);
 }

void folly::fibers::FiberManager::setObserver ( ExecutionObserver * observer )

Setup fibers execution observation/instrumentation. Fiber locals are available to observer.

Parameters

observer Fiber's execution observer.

Definition at line 158 of file FiberManager.cpp.

References observer_.

                                                           {
   observer_ = observer;
 }

void folly::fibers::FiberManager::setPreemptRunner ( InlineFunctionRunner * preemptRunner )

Setup fibers preempt runner.

Definition at line 166 of file FiberManager.cpp.

References preemptRunner_.

                                                                        {
   preemptRunner_ = preemptRunner;
 }

bool folly::fibers::FiberManager::shouldRunLoopRemote ( )

inline

This should only be called by a LoopController.

Definition at line 262 of file FiberManagerInternal-inl.h.

References remoteCount_, remoteReadyQueue_, and remoteTaskQueue_.

Referenced by folly::fibers::SimpleLoopController::runLoop(), folly::fibers::ExecutorLoopController::scheduleThreadSafe(), and folly::fibers::EventBaseLoopController::scheduleThreadSafe().

                                               {
   --remoteCount_;
   return !remoteReadyQueue_.empty() || !remoteTaskQueue_.empty();
 }

size_t folly::fibers::FiberManager::stackHighWatermark ( ) const

Returns: What was the most observed fiber stack usage (in bytes).

Definition at line 145 of file FiberManager.cpp.

References stackHighWatermark_.

Referenced by TEST().

                                               {
   return stackHighWatermark_;
 }

void folly::fibers::FiberManager::yield ( )

inline

Yield execution of the currently running fiber. Must only be called from a fiber executing on this FiberManager. The calling fiber will be scheduled when all other fibers have had a chance to run and the event loop is serviced.

Definition at line 496 of file FiberManagerInternal-inl.h.

References activeFiber_, currentFiberManager_, folly::fibers::Fiber::preempt(), folly::fibers::Fiber::RUNNING, folly::fibers::Fiber::state_, and folly::fibers::Fiber::YIELDED.

Referenced by AtomicBatchDispatcherTesting::Job::preprocess(), and TEST().

                                 {
   assert(currentFiberManager_ == this);
   assert(activeFiber_ != nullptr);
   assert(activeFiber_->state_ == Fiber::RUNNING);
   activeFiber_->preempt(Fiber::YIELDED);
 }