SerialExecutorTest.cpp File Reference

#include <chrono>
#include <folly/executors/CPUThreadPoolExecutor.h>
#include <folly/executors/InlineExecutor.h>
#include <folly/executors/SerialExecutor.h>
#include <folly/portability/GTest.h>
#include <folly/synchronization/Baton.h>

Go to the source code of this file.

Functions
void	SimpleTest (std::shared_ptr< folly::Executor > const &parent)
	TEST (SerialExecutor, Simple)
	TEST (SerialExecutor, SimpleInline)
	TEST (SerialExecutor, Afterlife)
void	RecursiveAddTest (std::shared_ptr< folly::Executor > const &parent)
	TEST (SerialExecutor, RecursiveAdd)
	TEST (SerialExecutor, RecursiveAddInline)
	TEST (SerialExecutor, ExecutionThrows)

Function Documentation

void RecursiveAddTest

(

std::shared_ptr< folly::Executor > const &

parent

)

Definition at line 106 of file SerialExecutorTest.cpp.

References burnMs(), folly::pushmi::executor, EXPECT_EQ, folly::getKeepAliveToken(), i, folly::Baton< MayBlock, Atom >::post(), values(), and folly::Baton< MayBlock, Atom >::wait().

Referenced by TEST().

                                                                  {
  auto executor =
      SerialExecutor::create(folly::getKeepAliveToken(parent.get()));

  folly::Baton<> finished_baton;

  std::vector<int> values;
  std::vector<int> expected = {{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}};

  int i = 0;
  std::function<void()> lambda = [&] {
    if (i < 10) {
      // make this extra vulnerable to concurrent execution
      values.push_back(0);
      burnMs(10);
      values.back() = i;
      executor->add(lambda);
    } else if (i < 12) {
      // Below we will post this lambda three times to the executor. When
      // executed, the lambda will re-post itself during the first ten
      // executions. Afterwards we do nothing twice (this else-branch), and
      // then on the 13th execution signal that we are finished.
    } else {
      finished_baton.post();
    }
    ++i;
  };

  executor->add(lambda);
  executor->add(lambda);
  executor->add(lambda);

  // wait until last task has executed
  finished_baton.wait();

  EXPECT_EQ(expected, values);
}

void SimpleTest

(

std::shared_ptr< folly::Executor > const &

parent

)

Definition at line 34 of file SerialExecutorTest.cpp.

References burnMs(), folly::pushmi::executor, EXPECT_EQ, folly::getKeepAliveToken(), i, folly::Baton< MayBlock, Atom >::post(), values(), and folly::Baton< MayBlock, Atom >::wait().

Referenced by TEST().

                                                            {
  auto executor =
      SerialExecutor::create(folly::getKeepAliveToken(parent.get()));

  std::vector<int> values;
  std::vector<int> expected;

  for (int i = 0; i < 20; ++i) {
    executor->add([i, &values] {
      // make this extra vulnerable to concurrent execution
      values.push_back(0);
      burnMs(10);
      values.back() = i;
    });
    expected.push_back(i);
  }

  // wait until last task has executed
  folly::Baton<> finished_baton;
  executor->add([&finished_baton] { finished_baton.post(); });
  finished_baton.wait();

  EXPECT_EQ(expected, values);
}

TEST	(	SerialExecutor	,
		Simple
	)

Definition at line 59 of file SerialExecutorTest.cpp.

References SimpleTest().

                             {
  SimpleTest(std::make_shared<folly::CPUThreadPoolExecutor>(4));
}

TEST	(	SerialExecutor	,
		SimpleInline
	)

Definition at line 62 of file SerialExecutorTest.cpp.

References SimpleTest().

                                   {
  SimpleTest(std::make_shared<folly::InlineExecutor>());
}

TEST	(	SerialExecutor	,
		Afterlife
	)

Definition at line 69 of file SerialExecutorTest.cpp.

References burnMs(), folly::pushmi::executor, EXPECT_EQ, folly::getKeepAliveToken(), i, folly::Baton< MayBlock, Atom >::post(), folly::Baton< MayBlock, Atom >::reset(), values(), and folly::Baton< MayBlock, Atom >::wait().

                                {
  auto cpu_executor = std::make_shared<folly::CPUThreadPoolExecutor>(4);
  auto executor =
      SerialExecutor::create(folly::getKeepAliveToken(cpu_executor.get()));

  // block executor until we call start_baton.post()
  folly::Baton<> start_baton;
  executor->add([&start_baton] { start_baton.wait(); });

  std::vector<int> values;
  std::vector<int> expected;

  for (int i = 0; i < 20; ++i) {
    executor->add([i, &values] {
      // make this extra vulnerable to concurrent execution
      values.push_back(0);
      burnMs(10);
      values.back() = i;
    });
    expected.push_back(i);
  }

  folly::Baton<> finished_baton;
  executor->add([&finished_baton] { finished_baton.post(); });

  // destroy SerialExecutor
  executor.reset();

  // now kick off the tasks
  start_baton.post();

  // wait until last task has executed
  finished_baton.wait();

  EXPECT_EQ(expected, values);
}

TEST	(	SerialExecutor	,
		RecursiveAdd
	)

Definition at line 144 of file SerialExecutorTest.cpp.

References RecursiveAddTest().

                                   {
  RecursiveAddTest(std::make_shared<folly::CPUThreadPoolExecutor>(4));
}

TEST	(	SerialExecutor	,
		RecursiveAddInline
	)

Definition at line 147 of file SerialExecutorTest.cpp.

References RecursiveAddTest().

                                         {
  RecursiveAddTest(std::make_shared<folly::InlineExecutor>());
}

TEST	(	SerialExecutor	,
		ExecutionThrows
	)

Definition at line 151 of file SerialExecutorTest.cpp.

References folly::pushmi::executor.

                                      {
  auto executor = SerialExecutor::create();

  // an empty Func will throw std::bad_function_call when invoked,
  // but SerialExecutor should catch that exception
  executor->add(folly::Func{});
}