AtomicBatchDispatcherTesting Namespace Reference

Classes
struct	DevNullPiper
struct	Job

Typedefs
using	ValueT = size_t
using	ResultT = std::string
using	DispatchFunctionT = folly::Function< std::vector< ResultT >(std::vector< ValueT > &&)>

Enumerations
enum	DispatchProblem { DispatchProblem::None, DispatchProblem::PreprocessThrows, DispatchProblem::DuplicateDispatch }

Functions
ResultT	processSingleInput (ValueT &&input)
std::vector< ResultT >	userDispatchFunc (std::vector< ValueT > &&inputs)
void	createJobs (AtomicBatchDispatcher< ValueT, ResultT > &atomicBatchDispatcher, std::vector< Job > &jobs, size_t count)
void	dispatchJobs (FiberManager &executor, std::vector< Job > &jobs, std::vector< folly::Optional< folly::Future< ResultT >>> &results, DispatchProblem dispatchProblem=DispatchProblem::None, size_t problemIndex=size_t(-1))
void	validateResult (std::vector< folly::Optional< folly::Future< ResultT >>> &results, size_t i)
template<typename TException >
void	validateResults (std::vector< folly::Optional< folly::Future< ResultT >>> &results, size_t expectedNumResults)

Variables
struct AtomicBatchDispatcherTesting::DevNullPiper	devNullPiper

Typedef Documentation

using AtomicBatchDispatcherTesting::DispatchFunctionT = typedef folly::Function<std::vector<ResultT>(std::vector<ValueT>&&)>

Definition at line 1771 of file FibersTest.cpp.

using AtomicBatchDispatcherTesting::ResultT = typedef std::string

Definition at line 1769 of file FibersTest.cpp.

using AtomicBatchDispatcherTesting::ValueT = typedef size_t

Definition at line 1768 of file FibersTest.cpp.

Enumeration Type Documentation

enum AtomicBatchDispatcherTesting::DispatchProblem

strong

Enumerator
None
PreprocessThrows
DuplicateDispatch

Definition at line 1838 of file FibersTest.cpp.

                           {
  None,
  PreprocessThrows,
  DuplicateDispatch,
};

Function Documentation

void AtomicBatchDispatcherTesting::createJobs	(	AtomicBatchDispatcher< ValueT, ResultT > &	atomicBatchDispatcher,
		std::vector< Job > &	jobs,
		size_t	count
	)

Definition at line 1828 of file FibersTest.cpp.

References count, folly::fibers::AtomicBatchDispatcher< InputT, ResultT >::getToken(), and i.

Referenced by TEST().

                  {
  jobs.clear();
  for (size_t i = 0; i < count; ++i) {
    jobs.emplace_back(Job(atomicBatchDispatcher.getToken(), i));
  }
}

void AtomicBatchDispatcherTesting::dispatchJobs	(	FiberManager &	executor,
		std::vector< Job > &	jobs,
		std::vector< folly::Optional< folly::Future< ResultT >>> &	results,
		DispatchProblem	dispatchProblem = DispatchProblem::None,
		size_t	problemIndex = size_t(-1)
	)

Definition at line 1844 of file FibersTest.cpp.

References folly::fibers::FiberManager::add(), EXPECT_THROW, EXPECT_TRUE, i, AtomicBatchDispatcherTesting::Job::input, folly::gen::move, OUTPUT_TRACE, AtomicBatchDispatcherTesting::Job::preprocess(), and AtomicBatchDispatcherTesting::Job::token.

Referenced by TEST().

                                      {
  EXPECT_TRUE(
      dispatchProblem == DispatchProblem::None || problemIndex < jobs.size());
  results.clear();
  results.resize(jobs.size());
  for (size_t i = 0; i < jobs.size(); ++i) {
    executor.add(
        [i, &executor, &jobs, &results, dispatchProblem, problemIndex]() {
          try {
            Job job(std::move(jobs[i]));

            if (dispatchProblem == DispatchProblem::PreprocessThrows) {
              if (i == problemIndex) {
                EXPECT_THROW(job.preprocess(executor, true), std::logic_error);
                return;
              }
            }

            job.preprocess(executor, false);
            OUTPUT_TRACE << "Dispatching job #" << i << std::endl;
            results[i] = job.token.dispatch(job.input);
            OUTPUT_TRACE << "Result future filled for job #" << i << std::endl;

            if (dispatchProblem == DispatchProblem::DuplicateDispatch) {
              if (i == problemIndex) {
                EXPECT_THROW(job.token.dispatch(job.input), ABDUsageException);
              }
            }
          } catch (...) {
            OUTPUT_TRACE << "Preprocessing failed for job #" << i << std::endl;
          }
        });
  }
}

ResultT AtomicBatchDispatcherTesting::processSingleInput

(

ValueT &&

input

)

Definition at line 1814 of file FibersTest.cpp.

References folly::gen::move.

Referenced by userDispatchFunc(), and validateResults().

                                           {
  return folly::to<ResultT>(std::move(input));
}

std::vector<ResultT> AtomicBatchDispatcherTesting::userDispatchFunc

(

std::vector< ValueT > &&

inputs

)

Definition at line 1818 of file FibersTest.cpp.

References i, folly::gen::move, and processSingleInput().

Referenced by TEST().

                                                                {
  size_t expectedCount = inputs.size();
  std::vector<ResultT> results;
  results.reserve(expectedCount);
  for (size_t i = 0; i < expectedCount; ++i) {
    results.emplace_back(processSingleInput(std::move(inputs[i])));
  }
  return results;
}

void AtomicBatchDispatcherTesting::validateResult	(	std::vector< folly::Optional< folly::Future< ResultT >>> &	results,
		size_t	i
	)

Definition at line 1884 of file FibersTest.cpp.

References i, and OUTPUT_TRACE.

Referenced by validateResults().

              {
  try {
    OUTPUT_TRACE << "results[" << i << "].value() : " << results[i]->value()
                 << std::endl;
  } catch (std::exception& e) {
    OUTPUT_TRACE << "Exception : " << e.what() << std::endl;
    throw;
  }
}

template<typename TException >

void AtomicBatchDispatcherTesting::validateResults	(	std::vector< folly::Optional< folly::Future< ResultT >>> &	results,
		size_t	expectedNumResults
	)

Definition at line 1897 of file FibersTest.cpp.

References EXPECT_EQ, EXPECT_NO_THROW, EXPECT_THROW, i, folly::gen::move, processSingleInput(), validateResult(), and folly::value().

Referenced by TEST().

                               {
  size_t numResultsFilled = 0;
  for (size_t i = 0; i < results.size(); ++i) {
    if (!results[i]) {
      continue;
    }
    ++numResultsFilled;
    EXPECT_THROW(validateResult(results, i), TException);
  }
  EXPECT_EQ(numResultsFilled, expectedNumResults);
}

Variable Documentation

struct AtomicBatchDispatcherTesting::DevNullPiper AtomicBatchDispatcherTesting::devNullPiper

Referenced by AtomicBatchDispatcherTesting::DevNullPiper::operator<<().