folly::fibers Namespace Reference

Namespaces
	detail

Classes
class	ABDCommitNotCalledException
class	ABDTokenNotDispatchedException
class	ABDUsageException
class	AtomicBatchDispatcher
class	BatchDispatcher
class	Baton
class	CacheManager
class	EventBaseLoopController
class	ExecutorLoopController
class	Fiber
	Fiber object used by FiberManager to execute tasks. More...
class	FiberImpl
class	FiberManager
	Single-threaded task execution engine. More...
struct	FirstArgOf
struct	FirstArgOf< F, typename std::enable_if< std::is_class< F >::value >::type >
struct	FirstArgOf< F, typename std::enable_if<!std::is_class< F >::value >::type >
class	GuardPageAllocator
class	InlineFunctionRunner
struct	IsRvalueRefTry
struct	IsRvalueRefTry< folly::Try< T > && >
class	LocalType
class	LoopController
class	Promise
class	Semaphore
class	SimpleLoopController
class	StackCache
class	StackCacheEntry
class	TaskIterator
class	TimedMutex
class	TimedRWMutex
class	TimeoutController

Typedefs
using	once_flag = basic_once_flag< TimedMutex >
typedef Baton	GenericBaton

Functions
template<class InputIterator >
TaskIterator< invoke_result_t< typename std::iterator_traits< InputIterator >::value_type > >	addTasks (InputIterator first, InputIterator last)
template<typename InputT , typename ResultT >
AtomicBatchDispatcher< InputT, ResultT >	createAtomicBatchDispatcher (folly::Function< std::vector< ResultT >(std::vector< InputT > &&)> dispatchFunc, size_t initialCapacity)
template<typename F >
FirstArgOf< F >::type::value_type	await (F &&func)
bool	onFiber ()
template<typename F >
void	addTask (F &&func)
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 ()
void	yield ()
FiberManager &	getFiberManager (EventBase &evb, const FiberManager::Options &opts)
FiberManager &	getFiberManager (VirtualEventBase &evb, const FiberManager::Options &opts)
template<class InputIterator , class F >
void	forEach (InputIterator first, InputIterator last, F &&f)
template<class InputIterator >
std::vector< typename std::enable_if< !std::is_same< invoke_result_t< typename std::iterator_traits< InputIterator >::value_type >, void >::value, typename std::pair< size_t, invoke_result_t< typename std::iterator_traits< InputIterator >::value_type > > >::type >	collectN (InputIterator first, InputIterator last, size_t n)
template<class InputIterator >
std::enable_if< std::is_same< invoke_result_t< typename std::iterator_traits< InputIterator >::value_type >, void >::value, std::vector< size_t > >::type	collectN (InputIterator first, InputIterator last, size_t n)
template<class InputIterator >
std::vector< typename std::enable_if< !std::is_same< invoke_result_t< typename std::iterator_traits< InputIterator >::value_type >, void >::value, invoke_result_t< typename std::iterator_traits< InputIterator >::value_type > >::type >	collectAll (InputIterator first, InputIterator last)
template<class InputIterator >
std::enable_if< std::is_same< invoke_result_t< typename std::iterator_traits< InputIterator >::value_type >, void >::value, void >::type	collectAll (InputIterator first, InputIterator last)
template<class InputIterator >
std::enable_if< !std::is_same< invoke_result_t< typename std::iterator_traits< InputIterator >::value_type >, void >::value, typename std::pair< size_t, invoke_result_t< typename std::iterator_traits< InputIterator >::value_type > > >::type	collectAny (InputIterator first, InputIterator last)
template<class InputIterator >
std::enable_if< std::is_same< invoke_result_t< typename std::iterator_traits< InputIterator >::value_type >, void >::value, size_t >::type	collectAny (InputIterator first, InputIterator last)

Variables
constexpr size_t	kNumGuarded = 100
constexpr size_t	kMaxInUse = 100

Typedef Documentation

typedef Baton folly::fibers::GenericBaton

Definition at line 25 of file GenericBaton.h.

using folly::fibers::once_flag = typedef basic_once_flag<TimedMutex>

Definition at line 23 of file CallOnce.h.

Function Documentation

template<typename F >

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

inline

Add a new task to be executed.

Parameters

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

Definition at line 529 of file FiberManagerInternal.h.

References folly::fibers::FiberManager::addTask(), and folly::fibers::FiberManager::getFiberManager().

Referenced by collectN(), forEach(), TEST(), and testFiberLocal().

                              {
  return FiberManager::getFiberManager().addTask(std::forward<F>(func));
}

template<typename F , typename G >

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

inline

Add a new task. When the task is complete, execute finally(Try<Result>&&) on the main context. Task functor is run and destroyed on the fiber context. Finally functor is run and destroyed 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 545 of file FiberManagerInternal.h.

References folly::fibers::FiberManager::addTaskFinally(), await(), and folly::fibers::FiberManager::getFiberManager().

Referenced by folly::fibers::FiberManager::add(), and folly::fibers::FiberManager::addTaskFuture().

                                                  {
  return FiberManager::getFiberManager().addTaskFinally(
      std::forward<F>(func), std::forward<G>(finally));
}

template<class InputIterator >

TaskIterator< invoke_result_t< typename std::iterator_traits< InputIterator >::value_type > > folly::fibers::addTasks ( InputIterator  first, InputIterator  last  )

inline

Schedules several tasks and immediately returns an iterator, that allow one to traverse tasks in the order of their completion. All results and exceptions thrown are stored alongside with the task id and are accessible via iterator.

Parameters

first	Range of tasks to be scheduled
last

Returns

movable, non-copyable iterator

Definition at line 114 of file AddTasks-inl.h.

References folly::fibers::TaskIterator< T >::addTask(), folly::gen::first, and folly::gen::move.

Referenced by TEST().

                                                  {
  typedef invoke_result_t<
      typename std::iterator_traits<InputIterator>::value_type>
      ResultType;
  typedef TaskIterator<ResultType> IteratorType;

  IteratorType iterator;

  for (; first != last; ++first) {
    iterator.addTask(std::move(*first));
  }

  iterator.context_->results.reserve(iterator.context_->totalTasks);

  return std::move(iterator);
}

template<typename F >

FirstArgOf< F >::type::value_type folly::fibers::await ( F &&  func )

inline

Blocks task execution until given promise is fulfilled.

Calls function passing in a Promise<T>, which has to be fulfilled.

Returns

data which was used to fulfill the promise.

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

References folly::fibers::Promise< T, BatonT >::await().

Referenced by addTaskFinally(), collectN(), Application::loop(), folly::fibers::TaskIterator< T >::reserve(), runBenchmark(), and TEST().

                                                            {
  typedef typename FirstArgOf<F>::type::value_type Result;
  typedef typename FirstArgOf<F>::type::baton_type BatonT;

  return Promise<Result, BatonT>::await(std::forward<F>(func));
}

template<class InputIterator >

std::vector< typename std::enable_if< !std::is_same< invoke_result_t< typename std::iterator_traits< InputIterator >::value_type >, void >::value, invoke_result_t< typename std::iterator_traits< InputIterator >::value_type > >::type > folly::fibers::collectAll ( InputIterator  first, InputIterator  last  )

inline

Schedules several tasks and blocks until all of these tasks are completed. If any of the tasks throws an exception, this exception will be re-thrown, but only when all the tasks are complete. If several tasks throw exceptions one of them will be re-thrown.

Parameters

first	Range of tasks to be scheduled
last

Returns

vector of values returned by tasks

Definition at line 147 of file WhenN-inl.h.

References forEach(), i, folly::gen::move, order, and folly::value().

Referenced by fizz::sm::getCertificateRequest(), and TEST().

                                                                         {
  typedef invoke_result_t<
      typename std::iterator_traits<InputIterator>::value_type>
      Result;
  size_t n = size_t(std::distance(first, last));
  std::vector<Result> results;
  std::vector<size_t> order(n);
  results.reserve(n);

  forEach(first, last, [&results, &order](size_t id, Result result) {
    order[id] = results.size();
    results.emplace_back(std::move(result));
  });
  assert(results.size() == n);

  std::vector<Result> orderedResults;
  orderedResults.reserve(n);

  for (size_t i = 0; i < n; ++i) {
    orderedResults.emplace_back(std::move(results[order[i]]));
  }

  return orderedResults;
}

template<class InputIterator >

std::enable_if< std::is_same< invoke_result_t< typename std::iterator_traits< InputIterator >::value_type >, void >::value, void >::type folly::fibers::collectAll ( InputIterator  first, InputIterator  last  )

inline

collectAll specialization for functions returning void

Parameters

first	Range of tasks to be scheduled
last

Definition at line 178 of file WhenN-inl.h.

References forEach(), type, and folly::value().

                                                                         {
  forEach(first, last, [](size_t /* id */) {});
}

template<class InputIterator >

std::enable_if< !std::is_same< invoke_result_t< typename std::iterator_traits< InputIterator >::value_type >, void >::value, typename std::pair< size_t, invoke_result_t< typename std::iterator_traits< InputIterator >::value_type > > >::type folly::fibers::collectAny ( InputIterator  first, InputIterator  last  )

inline

Schedules several tasks and blocks until one of them is completed. If this task throws an exception, this exception will be re-thrown. Exceptions thrown by all other tasks will be ignored.

Parameters

first	Range of tasks to be scheduled
last

Returns

pair of index of the first completed task and its return value

Definition at line 192 of file WhenN-inl.h.

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

Referenced by TEST(), and testFiberLocal().

                                                                    {
  auto result = collectN(first, last, 1);
  assert(result.size() == 1);
  return std::move(result[0]);
}

template<class InputIterator >

std::enable_if< std::is_same< invoke_result_t< typename std::iterator_traits< InputIterator >::value_type >, void >::value, size_t >::type folly::fibers::collectAny ( InputIterator  first, InputIterator  last  )

inline

WhenAny specialization for functions returning void.

Parameters

first	Range of tasks to be scheduled
last

Returns

index of the first completed task

Definition at line 204 of file WhenN-inl.h.

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

                                                                           {
  auto result = collectN(first, last, 1);
  assert(result.size() == 1);
  return std::move(result[0]);
}

template<class InputIterator >

std::vector< typename std::enable_if< !std::is_same< invoke_result_t< typename std::iterator_traits< InputIterator >::value_type >, void >::value, typename std::pair< size_t, invoke_result_t< typename std::iterator_traits< InputIterator >::value_type > > >::type > folly::fibers::collectN ( InputIterator  first, InputIterator  last, size_t  n  )

inline

Schedules several tasks and blocks until n of these tasks are completed. If any of these n tasks throws an exception, this exception will be re-thrown, but only when n tasks are complete. If several tasks throw exceptions one of them will be re-thrown.

Parameters

first	Range of tasks to be scheduled
last
n	Number of tasks to wait for

Returns

vector of pairs (task index, return value of task)

Definition at line 34 of file WhenN-inl.h.

References addTask(), await(), context, f, folly::gen::first, i, folly::gen::move, type, and folly::value().

Referenced by collectAny(), and TEST().

                                                            {
  typedef invoke_result_t<
      typename std::iterator_traits<InputIterator>::value_type>
      Result;
  assert(n > 0);
  assert(std::distance(first, last) >= 0);
  assert(n <= static_cast<size_t>(std::distance(first, last)));

  struct Context {
    std::vector<std::pair<size_t, Result>> results;
    size_t tasksTodo;
    std::exception_ptr e;
    folly::Optional<Promise<void>> promise;

    Context(size_t tasksTodo_) : tasksTodo(tasksTodo_) {
      this->results.reserve(tasksTodo_);
    }
  };
  auto context = std::make_shared<Context>(n);

  await([first, last, context](Promise<void> promise) mutable {
    context->promise = std::move(promise);
    for (size_t i = 0; first != last; ++i, ++first) {
      addTask([i, context, f = std::move(*first)]() {
        try {
          auto result = f();
          if (context->tasksTodo == 0) {
            return;
          }
          context->results.emplace_back(i, std::move(result));
        } catch (...) {
          if (context->tasksTodo == 0) {
            return;
          }
          context->e = std::current_exception();
        }
        if (--context->tasksTodo == 0) {
          context->promise->setValue();
        }
      });
    }
  });

  if (context->e != std::exception_ptr()) {
    std::rethrow_exception(context->e);
  }

  return std::move(context->results);
}

template<class InputIterator >

std::enable_if< std::is_same< invoke_result_t< typename std::iterator_traits< InputIterator >::value_type >, void >::value, std::vector< size_t > >::type folly::fibers::collectN ( InputIterator  first, InputIterator  last, size_t  n  )

inline

collectN specialization for functions returning void

Parameters

first	Range of tasks to be scheduled
last
n	Number of tasks to wait for

Returns

vector of completed task indices

Definition at line 91 of file WhenN-inl.h.

References addTask(), await(), context, f, folly::gen::first, i, folly::gen::move, type, and folly::value().

                                                            {
  assert(n > 0);
  assert(std::distance(first, last) >= 0);
  assert(n <= static_cast<size_t>(std::distance(first, last)));

  struct Context {
    std::vector<size_t> taskIndices;
    std::exception_ptr e;
    size_t tasksTodo;
    folly::Optional<Promise<void>> promise;

    Context(size_t tasksTodo_) : tasksTodo(tasksTodo_) {
      this->taskIndices.reserve(tasksTodo_);
    }
  };
  auto context = std::make_shared<Context>(n);

  await([first, last, context](Promise<void> promise) mutable {
    context->promise = std::move(promise);
    for (size_t i = 0; first != last; ++i, ++first) {
      addTask([i, context, f = std::move(*first)]() {
        try {
          f();
          if (context->tasksTodo == 0) {
            return;
          }
          context->taskIndices.push_back(i);
        } catch (...) {
          if (context->tasksTodo == 0) {
            return;
          }
          context->e = std::current_exception();
        }
        if (--context->tasksTodo == 0) {
          context->promise->setValue();
        }
      });
    }
  });

  if (context->e != std::exception_ptr()) {
    std::rethrow_exception(context->e);
  }

  return context->taskIndices;
}

template<typename InputT , typename ResultT >

AtomicBatchDispatcher< InputT, ResultT > folly::fibers::createAtomicBatchDispatcher	(	folly::Function< std::vector< ResultT >(std::vector< InputT > &&)>	dispatchFunc,
		size_t	initialCapacity
	)

Definition at line 214 of file AtomicBatchDispatcher-inl.h.

References folly::gen::move, and folly::fibers::AtomicBatchDispatcher< InputT, ResultT >::reserve().

Referenced by TEST().

                            {
  auto abd = AtomicBatchDispatcher<InputT, ResultT>(std::move(dispatchFunc));
  if (initialCapacity) {
    abd.reserve(initialCapacity);
  }
  return abd;
}

template<class InputIterator , class F >

void folly::fibers::forEach ( InputIterator  first, InputIterator  last, F &&  f  )

inline

Schedules several tasks and blocks until all of them are completed. In the process of their successfull completion given callback would be called for each of them with the index of the task and the result it returned (if not void). If any of these n tasks throws an exception, this exception will be re-thrown, but only when all tasks are complete. If several tasks throw exceptions one of them will be re-thrown. Callback won't be called for tasks that throw exception.

Parameters

first	Range of tasks to be scheduled
last
F	callback to call for each result. In case of each task returning void it should be callable F(size_t id) otherwise should be callable F(size_t id, Result)

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

References addTask(), f, folly::gen::first, i, folly::gen::move, and folly::fibers::Baton::wait().

Referenced by collectAll(), and TEST().

                                                                    {
  if (first == last) {
    return;
  }

  typedef typename std::iterator_traits<InputIterator>::value_type FuncType;

  size_t tasksTodo = 1;
  std::exception_ptr e;
  Baton baton;

  auto taskFunc = [&tasksTodo, &e, &f, &baton](size_t id, FuncType&& func) {
    return [id,
            &tasksTodo,
            &e,
            &f,
            &baton,
            func_ = std::forward<FuncType>(func)]() mutable {
      try {
        callFuncs(std::forward<FuncType>(func_), f, id);
      } catch (...) {
        e = std::current_exception();
      }
      if (--tasksTodo == 0) {
        baton.post();
      }
    };
  };

  auto firstTask = first;
  ++first;

  for (size_t i = 1; first != last; ++i, ++first, ++tasksTodo) {
    addTask(taskFunc(i, std::move(*first)));
  }

  taskFunc(0, std::move(*firstTask))();
  baton.wait();

  if (e != std::exception_ptr()) {
    std::rethrow_exception(e);
  }
}

FiberManager & folly::fibers::getFiberManager	(	EventBase &	evb,
		const FiberManager::Options &	opts
	)

Definition at line 183 of file FiberManagerMap.cpp.

References folly::pushmi::operators::get.

Referenced by folly::FiberIOExecutor::add(), BENCHMARK(), main(), folly::fibers::FiberManager::runQueueSize(), TEST(), and TEST_F().

                                     {
  return ThreadLocalCache<EventBase>::get(evb, opts);
}

FiberManager & folly::fibers::getFiberManager	(	VirtualEventBase &	evb,
		const FiberManager::Options &	opts
	)

Definition at line 189 of file FiberManagerMap.cpp.

References folly::pushmi::operators::get.

                                     {
  return ThreadLocalCache<VirtualEventBase>::get(evb, opts);
}

template<typename T >

T& folly::fibers::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 584 of file FiberManagerInternal.h.

References folly::fibers::FiberManager::getFiberManagerUnsafe(), and folly::T.

Referenced by folly::fibers::FiberManager::add(), lifo_test(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::load(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::putOwnedBase(), folly::detail::ThreadCachedLists< Tag >::ListHead::splice(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::takeOwnedBase(), and folly::AsyncSocket::withAddr().

           {
  auto fm = FiberManager::getFiberManagerUnsafe();
  if (fm) {
    return fm->local<T>();
  }
  return FiberManager::localThread<T>();
}

bool folly::fibers::onFiber ( )

inline

Returns

true iff we are running in a fiber's context

Definition at line 517 of file FiberManagerInternal.h.

References folly::fibers::FiberManager::getFiberManagerUnsafe().

Referenced by wangle::SSLSessionCacheManager::getSession(), folly::fibers::TimedMutex::lockHelper(), and TEST_F().

                      {
  auto fm = FiberManager::getFiberManagerUnsafe();
  return fm ? fm->hasActiveFiber() : false;
}

template<typename F >

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

inline

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 568 of file FiberManagerInternal.h.

References folly::fibers::FiberManager::getFiberManagerUnsafe(), and UNLIKELY.

Referenced by folly::fibers::FiberManager::add(), folly::fibers::FiberManager::addTaskRemoteFuture(), folly::python::getFiberManager(), and TEST().

                                                     {
  auto fm = FiberManager::getFiberManagerUnsafe();
  if (UNLIKELY(fm == nullptr)) {
    return func();
  }
  return fm->runInMainContext(std::forward<F>(func));
}

void folly::fibers::yield ( )

inline

Definition at line 592 of file FiberManagerInternal.h.

References folly::fibers::FiberManager::getFiberManagerUnsafe().

Referenced by folly::SharedMutexImpl< true >::applyDeferredReaders(), folly::detail::atomic_hash_spin_wait(), atomicIncrBaseline(), BENCHMARK_RELATIVE(), ConcurrentFlowManySender::cancellation_test(), ConcurrentFlowSingleSender::cancellation_test(), contendedRW(), contendedUse(), contentionAtWidth(), folly::fibers::FiberManager::currentFiber(), folly::detail::LifoSemBase< BatonType, Atom >::decrOrPush(), folly::RelaxedConcurrentPriorityQueue< T, MayBlock, SupportsSize, PopBatch, ListTargetSize, Mutex, Atom >::grow(), folly::detail::LifoSemBase< BatonType, Atom >::incrOrPop(), folly::isSequencedExecutor(), liveClockWaitUntilTests(), folly::RWSpinLock::lock(), folly::detail::lock(), folly::RWSpinLock::lock_shared(), folly::RWSpinLock::lock_upgrade(), folly::MicroLockCore::lockSlowPath(), main(), FibYielder::operator()(), run_basic_tests(), runAllAndValidate(), runContendedReaders(), runMixed(), runPingPong(), runRemoteUnlock(), folly::detail::LifoSemBase< BatonType, Atom >::shutdown(), folly::detail::spin_yield_until(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::takeOwnedBase(), TEST(), TEST_F(), folly::sync_tests::testConcurrency(), folly::detail::LifoSemBase< BatonType, Atom >::tryRemoveNode(), folly::RWSpinLock::unlock_upgrade_and_lock(), folly::hazptr_domain< DeterministicAtomic >::wait_for_zero_bulk_reclaims(), folly::EventBase::waitUntilRunning(), and folly::SharedMutexImpl< true >::yieldWaitForZeroBits().

                    {
  auto fm = FiberManager::getFiberManagerUnsafe();
  if (fm) {
    fm->yield();
  } else {
    std::this_thread::yield();
  }
}

Variable Documentation

constexpr size_t folly::fibers::kMaxInUse = 100

Maximum number of allocator instances with guarded stacks enabled

Definition at line 53 of file GuardPageAllocator.cpp.

constexpr size_t folly::fibers::kNumGuarded = 100

Each stack with a guard page creates two memory mappings. Since this is a limited resource, we don't want to create too many of these.

The upper bound on total number of mappings created is kNumGuarded * kMaxInUse. Number of guarded stacks per allocator instance

Definition at line 48 of file GuardPageAllocator.cpp.

Referenced by folly::fibers::StackCache::giveBack(), and folly::fibers::StackCache::StackCache().