folly::futures Namespace Reference

Namespaces
	detail
	test

Classes
class	Barrier

Functions
template<class It , class F , class ItT , class Result >
std::vector< Future< Result > >	map (It first, It last, F func)
template<class It , class F , class ItT , class Result >
std::vector< Future< Result > >	map (Executor &exec, It first, It last, F func)
Future< Unit >	sleep (Duration dur, Timekeeper *tk)
template<class Collection , class F >
auto	map (Collection &&c, F &&func) -> decltype(map(c.begin(), c.end(), func))
template<class Collection , class F >
auto	map (Executor &exec, Collection &&c, F &&func) -> decltype(map(exec, c.begin(), c.end(), func))
template<class Policy , class FF >
invoke_result_t< FF, size_t >	retrying (Policy &&p, FF &&ff)
std::function< bool(size_t, const exception_wrapper &)>	retryingPolicyBasic (size_t max_tries)
template<class Policy , class URNG >
std::function< Future< bool >size_t, const exception_wrapper &)>	retryingPolicyCappedJitteredExponentialBackoff (size_t max_tries, Duration backoff_min, Duration backoff_max, double jitter_param, URNG &&rng, Policy &&p)
std::function< Future< bool >size_t, const exception_wrapper &)>	retryingPolicyCappedJitteredExponentialBackoff (size_t max_tries, Duration backoff_min, Duration backoff_max, double jitter_param)

Detailed Description

This namespace is for utility functions that would usually be static members of Future, except they don't make sense there because they don't depend on the template type (rather, on the type of their arguments in some cases). This is the least-bad naming scheme we could think of. Some of the functions herein have really-likely-to-collide names, like "map" and "sleep".

Function Documentation

template<class Collection , class F >

auto folly::futures::map	(	Collection &&	c,
		F &&	func
	)		-> decltype(map(c.begin(), c.end(), func))

Definition at line 78 of file helpers.h.

References c, and map().

                                                                              {
  return map(c.begin(), c.end(), std::forward<F>(func));
}

template<class Collection , class F >

auto folly::futures::map	(	Executor &	exec,
		Collection &&	c,
		F &&	func
	)		-> decltype(map(exec, c.begin(), c.end(), func))

Definition at line 84 of file helpers.h.

References c, folly::collectAllSemiFuture(), folly::pushmi::executor, folly::gen::first, int8_t, folly::makeFuture(), folly::makeFutureWith(), folly::makeSemiFuture(), folly::makeSemiFutureWith(), map(), folly::Executor::MID_PRI, folly::pushmi::detail::t, folly::T, type, value, folly::value(), and folly::via().

                                                     {
  return map(exec, c.begin(), c.end(), std::forward<F>(func));
}

template<class It , class F , class ItT , class Result >

std::vector< Future< Result > > folly::futures::map	(	It	first,
		It	last,
		F	func
	)

Set func as the callback for each input Future and return a vector of Futures containing the results in the input order.

Definition at line 2358 of file Future-inl.h.

References FOLLY_GNU_DISABLE_WARNING, FOLLY_POP_WARNING, FOLLY_PUSH_WARNING, and folly::gen::move.

Referenced by complexBenchmark(), map(), and TEST().

                                                         {
  std::vector<Future<Result>> results;
  results.reserve(std::distance(first, last));
  for (auto it = first; it != last; it++) {
    FOLLY_PUSH_WARNING
    FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations")
    results.push_back(std::move(*it).then(func));
    FOLLY_POP_WARNING
  }
  return results;
}

template<class It , class F , class ItT , class Result >

std::vector< Future< Result > > folly::futures::map	(	Executor &	exec,
		It	first,
		It	last,
		F	func
	)

Set func as the callback for each input Future and return a vector of Futures containing the results in the input order and completing on exec.

Definition at line 2371 of file Future-inl.h.

References FOLLY_GNU_DISABLE_WARNING, FOLLY_POP_WARNING, FOLLY_PUSH_WARNING, and folly::gen::move.

                                                                         {
  std::vector<Future<Result>> results;
  results.reserve(std::distance(first, last));
  for (auto it = first; it != last; it++) {
    FOLLY_PUSH_WARNING
    FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations")
    results.push_back(std::move(*it).via(&exec).then(func));
    FOLLY_POP_WARNING
  }
  return results;
}

template<class Policy , class FF >

invoke_result_t< FF, size_t > folly::futures::retrying	(	Policy &&	p,
		FF &&	ff
	)

retrying

Given a policy and a future-factory, creates futures according to the policy.

The policy must be moveable - retrying will move it a lot - and callable of either of the two forms:

• Future<bool>(size_t, exception_wrapper)
• bool(size_t, exception_wrapper) Internally, the latter is transformed into the former in the obvious way. The first parameter is the attempt number of the next prospective attempt; the second parameter is the most recent exception. The policy returns a Future<bool> which, when completed with true, indicates that a retry is desired.

We provide a few generic policies:

• Basic
• CappedJitteredexponentialBackoff

Custom policies may use the most recent try number and exception to decide whether to retry and optionally to do something interesting like delay before the retry. Users may pass inline lambda expressions as policies, or may define their own data types meeting the above requirements. Users are responsible for managing the lifetimes of anything pointed to or referred to from inside the policy.

For example, one custom policy may try up to k times, but only if the most recent exception is one of a few types or has one of a few error codes indicating that the failure was transitory.

Cancellation is not supported.

If both FF and Policy inline executes, then it is possible to hit a stack overflow due to the recursive nature of the retry implementation

Definition at line 234 of file Retrying.h.

References folly::futures::detail::retrying().

Referenced by TEST().

                                                          {
  using tag = typename detail::retrying_policy_traits<Policy>::tag;
  return detail::retrying(std::forward<Policy>(p), std::forward<FF>(ff), tag());
}

std::function<bool(size_t, const exception_wrapper&)> folly::futures::retryingPolicyBasic ( size_t  max_tries )

inline

Definition at line 240 of file Retrying.h.

Referenced by TEST().

                                      {
  return [=](size_t n, const exception_wrapper&) { return n < max_tries; };
}

template<class Policy , class URNG >

std::function<Future<bool>size_t, const exception_wrapper&)> folly::futures::retryingPolicyCappedJitteredExponentialBackoff	(	size_t	max_tries,
		Duration	backoff_min,
		Duration	backoff_max,
		double	jitter_param,
		URNG &&	rng,
		Policy &&	p
	)

Definition at line 246 of file Retrying.h.

References folly::futures::detail::retryingPolicyCappedJitteredExponentialBackoff(), and rng.

                {
  using tag = typename detail::retrying_policy_traits<Policy>::tag;
  return detail::retryingPolicyCappedJitteredExponentialBackoff(
      max_tries,
      backoff_min,
      backoff_max,
      jitter_param,
      std::forward<URNG>(rng),
      std::forward<Policy>(p),
      tag());
}

std::function<Future<bool>size_t, const exception_wrapper&)> folly::futures::retryingPolicyCappedJitteredExponentialBackoff ( size_t  max_tries, Duration  backoff_min, Duration  backoff_max, double  jitter_param  )

inline

Definition at line 265 of file Retrying.h.

References folly::gen::move, and folly::futures::detail::retryingPolicyCappedJitteredExponentialBackoff().

                         {
  auto p = [](size_t, const exception_wrapper&) { return true; };
  return retryingPolicyCappedJitteredExponentialBackoff(
      max_tries,
      backoff_min,
      backoff_max,
      jitter_param,
      ThreadLocalPRNG(),
      std::move(p));
}

Future< Unit > folly::futures::sleep	(	Duration	,
		Timekeeper *	= nullptr
	)

Returns a Future that will complete after the specified duration. The Duration typedef of a std::chrono duration type indicates the resolution you can expect to be meaningful (milliseconds at the time of writing). Normally you wouldn't need to specify a Timekeeper, we will use the global futures timekeeper (we run a thread whose job it is to keep time for futures timeouts) but we provide the option for power users.

The Timekeeper thread will be lazily created the first time it is needed. If your program never uses any timeouts or other time-based Futures you will pay no Timekeeper thread overhead.

Definition at line 42 of file Future.cpp.

References folly::Timekeeper::after(), folly::detail::getTimekeeperSingleton(), LIKELY, and UNLIKELY.

Referenced by folly::coro::TimedWaitAwaitable< Awaitable >::await_suspend(), BENCHMARK(), folly::SemiFuture< T >::delayed(), folly::Future< T >::delayed(), wangle::ExpiringFilter< Req, Resp >::ExpiringFilter(), keepAliveTest(), RpcService::operator()(), folly::futures::detail::retryingPolicyCappedJitteredExponentialBackoff(), wangle::ExpiringFilter< Req, Resp >::startIdleTimer(), TEST(), and virtualExecutorTest().

                                                 {
  std::shared_ptr<Timekeeper> tks;
  if (LIKELY(!tk)) {
    tks = folly::detail::getTimekeeperSingleton();
    tk = tks.get();
  }

  if (UNLIKELY(!tk)) {
    return makeFuture<Unit>(FutureNoTimekeeper());
  }

  return tk->after(dur);
}