folly::fibers::BatchDispatcher< ValueT, ResultT, ExecutorT > Class Template Reference

#include <BatchDispatcher.h>

Classes
struct	DispatchState

Public Types
using	ValueBatchT = std::vector< ValueT >
using	ResultBatchT = std::vector< ResultT >
using	PromiseBatchT = std::vector< folly::Promise< ResultT >>
using	DispatchFunctionT = folly::Function< ResultBatchT(ValueBatchT &&)>

Public Member Functions
	BatchDispatcher (ExecutorT &executor, DispatchFunctionT dispatchFunc)
Future< ResultT >	add (ValueT value)

Static Private Member Functions
static void	dispatchFunctionWrapper (DispatchState &state)

Private Attributes
ExecutorT &	executor_
std::shared_ptr< DispatchState >	state_

Detailed Description

template<typename ValueT, typename ResultT, typename ExecutorT>
class folly::fibers::BatchDispatcher< ValueT, ResultT, ExecutorT >

BatchDispatcher is useful for batching values while doing I/O. For example, if you are launching multiple tasks which take a single id and each task fetches from database, you can use BatchDispatcher to batch those ids and do a single query requesting all those ids.

To use this, create a BatchDispatcher with a dispatch function which consumes a vector of values and returns a vector of results in the same order. Add values to BatchDispatcher using add function, which returns a future to the result set in your dispatch function.

Implementation Logic:

• using FiberManager as executor example, user creates a thread_local BatchDispatcher, on which user calls add(value).
• add(value) adds the value in a vector and also schedules a new task(BatchDispatchFunction) which will read the vector of values and call user's DispatchFunction() on it.
• assuming the executor queues all the task and runs them in order of their creation time, then BatchDispatcher will run later than all the tasks already created. Depending on this, all the values were added in these tasks would be picked up by BatchDispatchFunction()

Example:

• User schedules Task1, Task2, Task3 each of them calls BatchDispatch.add() with id1, id2, id3 respectively.
• Executor's state {Task1, Task2, Task3}, BatchDispatchers state {}
• After Task1 calls BatchDispatcher.add(): Executor's state {Task2, Task3, BatchDispatchFunction}, BatchDispatcher's state {id1}
• After Task2 calls BatchDispatcher.add(): Executor's state {Task3, BatchDispatchFunction}, BatchDispatcher's state {id1, id2}
• After Task3 calls BatchDispatcher.add(): Executor's state {BatchDispatchFunction}, BatchDispatcher's state {id1, id2, id3}
• Now BatchDispatcher calls user's Dispatch function with {id1, id2, id3}

Note:

• This only works with executors which runs the tasks in order of their schedule time.
• BatchDispatcher is not thread safe.

Definition at line 72 of file BatchDispatcher.h.

Member Typedef Documentation

template<typename ValueT , typename ResultT , typename ExecutorT >

using folly::fibers::BatchDispatcher< ValueT, ResultT, ExecutorT >::DispatchFunctionT = folly::Function<ResultBatchT(ValueBatchT&&)>

Definition at line 77 of file BatchDispatcher.h.

template<typename ValueT , typename ResultT , typename ExecutorT >

using folly::fibers::BatchDispatcher< ValueT, ResultT, ExecutorT >::PromiseBatchT = std::vector<folly::Promise<ResultT>>

Definition at line 76 of file BatchDispatcher.h.

template<typename ValueT , typename ResultT , typename ExecutorT >

using folly::fibers::BatchDispatcher< ValueT, ResultT, ExecutorT >::ResultBatchT = std::vector<ResultT>

Definition at line 75 of file BatchDispatcher.h.

template<typename ValueT , typename ResultT , typename ExecutorT >

using folly::fibers::BatchDispatcher< ValueT, ResultT, ExecutorT >::ValueBatchT = std::vector<ValueT>

Definition at line 74 of file BatchDispatcher.h.

Constructor & Destructor Documentation

template<typename ValueT , typename ResultT , typename ExecutorT >

folly::fibers::BatchDispatcher< ValueT, ResultT, ExecutorT >::BatchDispatcher ( ExecutorT &  executor, DispatchFunctionT  dispatchFunc  )

inline

Definition at line 79 of file BatchDispatcher.h.

      : executor_(executor),
        state_(new DispatchState(std::move(dispatchFunc))) {}

Member Function Documentation

template<typename ValueT , typename ResultT , typename ExecutorT >

Future<ResultT> folly::fibers::BatchDispatcher< ValueT, ResultT, ExecutorT >::add ( ValueT  value )

inline

Definition at line 83 of file BatchDispatcher.h.

References folly::fibers::BatchDispatcher< ValueT, ResultT, ExecutorT >::dispatchFunctionWrapper(), folly::fibers::BatchDispatcher< ValueT, ResultT, ExecutorT >::executor_, folly::Promise< T >::getFuture(), folly::gen::move, and folly::fibers::BatchDispatcher< ValueT, ResultT, ExecutorT >::state_.

Referenced by doubleBatchInnerDispatch(), doubleBatchOuterDispatch(), and singleBatchDispatch().

                                    {
    if (state_->values.empty()) {
      executor_.add([state = state_]() { dispatchFunctionWrapper(*state); });
    }

    folly::Promise<ResultT> resultPromise;
    auto resultFuture = resultPromise.getFuture();

    state_->values.emplace_back(std::move(value));
    state_->promises.emplace_back(std::move(resultPromise));

    return resultFuture;
  }

template<typename ValueT , typename ResultT , typename ExecutorT >

static void folly::fibers::BatchDispatcher< ValueT, ResultT, ExecutorT >::dispatchFunctionWrapper ( DispatchState &  state )

inlinestaticprivate

Definition at line 107 of file BatchDispatcher.h.

References folly::fibers::BatchDispatcher< ValueT, ResultT, ExecutorT >::DispatchState::dispatchFunc, i, folly::gen::move, folly::fibers::BatchDispatcher< ValueT, ResultT, ExecutorT >::DispatchState::promises, and folly::fibers::BatchDispatcher< ValueT, ResultT, ExecutorT >::DispatchState::values.

Referenced by folly::fibers::BatchDispatcher< ValueT, ResultT, ExecutorT >::add().

                                                            {
    ValueBatchT values;
    PromiseBatchT promises;
    state.values.swap(values);
    state.promises.swap(promises);

    try {
      auto results = state.dispatchFunc(std::move(values));
      if (results.size() != promises.size()) {
        throw std::logic_error(
            "Unexpected number of results returned from dispatch function");
      }

      for (size_t i = 0; i < promises.size(); i++) {
        promises[i].setValue(std::move(results[i]));
      }
    } catch (const std::exception& ex) {
      for (size_t i = 0; i < promises.size(); i++) {
        promises[i].setException(
            exception_wrapper(std::current_exception(), ex));
      }
    } catch (...) {
      for (size_t i = 0; i < promises.size(); i++) {
        promises[i].setException(exception_wrapper(std::current_exception()));
      }
    }
  }

Member Data Documentation

template<typename ValueT , typename ResultT , typename ExecutorT >

ExecutorT& folly::fibers::BatchDispatcher< ValueT, ResultT, ExecutorT >::executor_

private

Definition at line 135 of file BatchDispatcher.h.

Referenced by folly::fibers::BatchDispatcher< ValueT, ResultT, ExecutorT >::add().

template<typename ValueT , typename ResultT , typename ExecutorT >

std::shared_ptr<DispatchState> folly::fibers::BatchDispatcher< ValueT, ResultT, ExecutorT >::state_

private

Definition at line 136 of file BatchDispatcher.h.

Referenced by folly::fibers::BatchDispatcher< ValueT, ResultT, ExecutorT >::add().

---

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

• proxygen/folly/folly/fibers/BatchDispatcher.h