FibersTest.cpp File Reference

#include <atomic>
#include <thread>
#include <vector>
#include <folly/Memory.h>
#include <folly/Random.h>
#include <folly/futures/Future.h>
#include <folly/Conv.h>
#include <folly/fibers/AddTasks.h>
#include <folly/fibers/AtomicBatchDispatcher.h>
#include <folly/fibers/BatchDispatcher.h>
#include <folly/fibers/EventBaseLoopController.h>
#include <folly/fibers/FiberManager.h>
#include <folly/fibers/FiberManagerMap.h>
#include <folly/fibers/GenericBaton.h>
#include <folly/fibers/Semaphore.h>
#include <folly/fibers/SimpleLoopController.h>
#include <folly/fibers/TimedMutex.h>
#include <folly/fibers/WhenN.h>
#include <folly/io/async/ScopedEventBaseThread.h>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Classes
struct	AtomicBatchDispatcherTesting::DevNullPiper
struct	AtomicBatchDispatcherTesting::Job

Namespaces
	AtomicBatchDispatcherTesting

Macros
#define	ENABLE_TRACE_IN_TEST   0
#define	OUTPUT_TRACE   devNullPiper
#define	SET_UP_TEST_FUNC

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

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

Functions
	TEST (FiberManager, batonTimedWaitTimeout)
	TEST (FiberManager, batonTimedWaitPost)
	TEST (FiberManager, batonTimedWaitTimeoutEvb)
	TEST (FiberManager, batonTimedWaitPostEvb)
	TEST (FiberManager, batonTryWait)
	TEST (FiberManager, genericBatonFiberWait)
	TEST (FiberManager, genericBatonThreadWait)
	TEST (FiberManager, addTasksNoncopyable)
	TEST (FiberManager, awaitThrow)
	TEST (FiberManager, addTasksThrow)
	TEST (FiberManager, addTasksVoid)
	TEST (FiberManager, addTasksVoidThrow)
	TEST (FiberManager, addTasksReserve)
	TEST (FiberManager, addTaskDynamic)
	TEST (FiberManager, forEach)
	TEST (FiberManager, collectN)
	TEST (FiberManager, collectNThrow)
	TEST (FiberManager, collectNVoid)
	TEST (FiberManager, collectNVoidThrow)
	TEST (FiberManager, collectAll)
	TEST (FiberManager, collectAllVoid)
	TEST (FiberManager, collectAny)
	TEST (FiberManager, runInMainContext)
	TEST (FiberManager, addTaskFinally)
	TEST (FiberManager, fibersPoolWithinLimit)
	TEST (FiberManager, fibersPoolOverLimit)
	TEST (FiberManager, remoteFiberBasic)
	TEST (FiberManager, addTaskRemoteBasic)
	TEST (FiberManager, remoteHasTasks)
	TEST (FiberManager, remoteHasReadyTasks)
template<typename Data >
void	testFiberLocal ()
	TEST (FiberManager, fiberLocal)
	TEST (FiberManager, fiberLocalHeap)
	TEST (FiberManager, fiberLocalDestructor)
	TEST (FiberManager, yieldTest)
	TEST (FiberManager, RequestContext)
	TEST (FiberManager, resizePeriodically)
	TEST (FiberManager, batonWaitTimeoutHandler)
	TEST (FiberManager, batonWaitTimeoutMany)
	TEST (FiberManager, remoteFutureTest)
	TEST (FiberManager, remoteFutureVoidUnitTest)
	TEST (FiberManager, nestedFiberManagers)
	TEST (FiberManager, semaphore)
template<typename ExecutorT >
void	singleBatchDispatch (ExecutorT &executor, int batchSize, int index)
	TEST (FiberManager, batchDispatchTest)
template<typename ExecutorT >
folly::Future< std::vector< std::string > >	doubleBatchInnerDispatch (ExecutorT &executor, int totalNumberOfElements, std::vector< int > input)
template<typename ExecutorT >
void	doubleBatchOuterDispatch (ExecutorT &executor, int totalNumberOfElements, int index)
	TEST (FiberManager, doubleBatchDispatchTest)
template<typename ExecutorT >
void	batchDispatchExceptionHandling (ExecutorT &executor, int i)
	TEST (FiberManager, batchDispatchExceptionHandlingTest)
ResultT	AtomicBatchDispatcherTesting::processSingleInput (ValueT &&input)
std::vector< ResultT >	AtomicBatchDispatcherTesting::userDispatchFunc (std::vector< ValueT > &&inputs)
void	AtomicBatchDispatcherTesting::createJobs (AtomicBatchDispatcher< ValueT, ResultT > &atomicBatchDispatcher, std::vector< Job > &jobs, size_t count)
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))
void	AtomicBatchDispatcherTesting::validateResult (std::vector< folly::Optional< folly::Future< ResultT >>> &results, size_t i)
template<typename TException >
void	AtomicBatchDispatcherTesting::validateResults (std::vector< folly::Optional< folly::Future< ResultT >>> &results, size_t expectedNumResults)
	TEST (FiberManager, ABD_Test)
	TEST (FiberManager, ABD_DispatcherDestroyedBeforeCallingCommit)
	TEST (FiberManager, ABD_PreprocessingFailureTest)
	TEST (FiberManager, ABD_MultipleDispatchOnSameTokenErrorTest)
	TEST (FiberManager, ABD_GetTokenCalledAfterCommitTest)
	TEST (FiberManager, ABD_UserProvidedBatchDispatchThrowsTest)
	TEST (FiberManager, VirtualEventBase)
	TEST (TimedMutex, ThreadsAndFibersDontDeadlock)
	TEST (TimedMutex, ThreadFiberDeadlockOrder)
	TEST (TimedMutex, ThreadFiberDeadlockRace)
	TEST (FiberManager, highWaterMarkViaRecordStackEvery)
	TEST (FiberManager, highWaterMarkViaRecordCurrentPosition)

Variables
struct AtomicBatchDispatcherTesting::DevNullPiper	AtomicBatchDispatcherTesting::devNullPiper

Macro Definition Documentation

#define ENABLE_TRACE_IN_TEST   0

Definition at line 1773 of file FibersTest.cpp.

#define OUTPUT_TRACE   devNullPiper

Definition at line 1787 of file FibersTest.cpp.

Referenced by AtomicBatchDispatcherTesting::dispatchJobs(), and AtomicBatchDispatcherTesting::validateResult().

#define SET_UP_TEST_FUNC

Value:

using namespace AtomicBatchDispatcherTesting;                 \
  folly::EventBase evb;                                         \
  auto& executor = getFiberManager(evb);                        \
  const size_t COUNT = 11;                                      \
  std::vector<Job> jobs;                                        \
  jobs.reserve(COUNT);                                          \
  std::vector<folly::Optional<folly::Future<ResultT>>> results; \
  results.reserve(COUNT);                                       \
  DispatchFunctionT dispatchFunc

Definition at line 1930 of file FibersTest.cpp.

Referenced by TEST().

Function Documentation

template<typename ExecutorT >

void batchDispatchExceptionHandling	(	ExecutorT &	executor,
		int	i
	)

Definition at line 1742 of file FibersTest.cpp.

References EXPECT_THROW.

Referenced by TEST().

                                                                {
  thread_local BatchDispatcher<int, int, ExecutorT> batchDispatcher(
      executor, [](std::vector<int> &&) -> std::vector<int> {
        throw std::runtime_error("Surprise!!");
      });

  EXPECT_THROW(batchDispatcher.add(i).get(), std::runtime_error);
}

template<typename ExecutorT >

folly::Future<std::vector<std::string> > doubleBatchInnerDispatch	(	ExecutorT &	executor,
		int	totalNumberOfElements,
		std::vector< int >	input
	)

Definition at line 1651 of file FibersTest.cpp.

References folly::fibers::BatchDispatcher< ValueT, ResultT, ExecutorT >::add(), folly::gen::batch(), EXPECT_EQ, folly::gen::move, and folly::unit.

Referenced by doubleBatchOuterDispatch().

                          {
  thread_local BatchDispatcher<
      std::vector<int>,
      std::vector<std::string>,
      ExecutorT>
      batchDispatcher(executor, [=](std::vector<std::vector<int>>&& batch) {
        std::vector<std::vector<std::string>> results;
        int numberOfElements = 0;
        for (auto& unit : batch) {
          numberOfElements += unit.size();
          std::vector<std::string> result;
          for (auto& element : unit) {
            result.push_back(folly::to<std::string>(element));
          }
          results.push_back(std::move(result));
        }
        EXPECT_EQ(totalNumberOfElements, numberOfElements);
        return results;
      });

  return batchDispatcher.add(std::move(input));
}

template<typename ExecutorT >

void doubleBatchOuterDispatch	(	ExecutorT &	executor,
		int	totalNumberOfElements,
		int	index
	)

Batch values in groups of 5, and then call inner dispatch.

Definition at line 1681 of file FibersTest.cpp.

References folly::fibers::BatchDispatcher< ValueT, ResultT, ExecutorT >::add(), folly::gen::batch(), folly::collectAllSemiFuture(), doubleBatchInnerDispatch(), EXPECT_EQ, group, folly::gen::move, and folly::unit.

Referenced by TEST().

               {
  thread_local BatchDispatcher<int, std::string, ExecutorT> batchDispatcher(
      executor, [=, &executor](std::vector<int>&& batch) {
        EXPECT_EQ(totalNumberOfElements, batch.size());
        std::vector<std::string> results;
        std::vector<folly::Future<std::vector<std::string>>>
            innerDispatchResultFutures;

        std::vector<int> group;
        for (auto unit : batch) {
          group.push_back(unit);
          if (group.size() == 5) {
            auto localGroup = group;
            group.clear();

            innerDispatchResultFutures.push_back(doubleBatchInnerDispatch(
                executor, totalNumberOfElements, localGroup));
          }
        }

        folly::collectAllSemiFuture(
            innerDispatchResultFutures.begin(),
            innerDispatchResultFutures.end())
            .toUnsafeFuture()
            .then([&](std::vector<Try<std::vector<std::string>>>
                          innerDispatchResults) {
              for (auto& unit : innerDispatchResults) {
                for (auto& element : unit.value()) {
                  results.push_back(element);
                }
              }
            })
            .get();
        return results;
      });

  auto indexCopy = index;
  auto result = batchDispatcher.add(std::move(indexCopy));
  EXPECT_EQ(folly::to<std::string>(index), std::move(result).get());
}

template<typename ExecutorT >

void singleBatchDispatch	(	ExecutorT &	executor,
		int	batchSize,
		int	index
	)

Definition at line 1609 of file FibersTest.cpp.

References folly::fibers::BatchDispatcher< ValueT, ResultT, ExecutorT >::add(), folly::gen::batch(), EXPECT_EQ, and folly::gen::move.

Referenced by TEST().

                                                                        {
  thread_local BatchDispatcher<int, std::string, ExecutorT> batchDispatcher(
      executor, [=](std::vector<int>&& batch) {
        EXPECT_EQ(batchSize, batch.size());
        std::vector<std::string> results;
        for (auto& it : batch) {
          results.push_back(folly::to<std::string>(it));
        }
        return results;
      });

  auto indexCopy = index;
  auto result = batchDispatcher.add(std::move(indexCopy));
  EXPECT_EQ(folly::to<std::string>(index), std::move(result).get());
}

TEST	(	FiberManager	,
		batonTimedWaitTimeout
	)

Definition at line 43 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), EXPECT_EQ, EXPECT_FALSE, folly::fibers::FiberManager::loopController(), folly::gen::move, now(), and folly::fibers::Baton::try_wait_for().

                                          {
  bool taskAdded = false;
  size_t iterations = 0;

  FiberManager manager(std::make_unique<SimpleLoopController>());
  auto& loopController =
      dynamic_cast<SimpleLoopController&>(manager.loopController());

  auto now = SimpleLoopController::Clock::now();
  loopController.setTimeFunc([&] { return now; });

  auto loopFunc = [&]() {
    if (!taskAdded) {
      manager.addTask([&]() {
        Baton baton;

        auto res = baton.try_wait_for(std::chrono::milliseconds(230));

        EXPECT_FALSE(res);
        EXPECT_EQ(5, iterations);

        loopController.stop();
      });
      manager.addTask([&]() {
        Baton baton;

        auto res = baton.try_wait_for(std::chrono::milliseconds(130));

        EXPECT_FALSE(res);
        EXPECT_EQ(3, iterations);

        loopController.stop();
      });
      taskAdded = true;
    } else {
      now += std::chrono::milliseconds(50);
      iterations++;
    }
  };

  loopController.loop(std::move(loopFunc));
}

TEST	(	FiberManager	,
		batonTimedWaitPost
	)

Definition at line 86 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), EXPECT_EQ, EXPECT_TRUE, folly::fibers::FiberManager::loopController(), folly::gen::move, folly::fibers::Baton::post(), and folly::fibers::Baton::try_wait_for().

                                       {
  bool taskAdded = false;
  size_t iterations = 0;
  Baton* baton_ptr;

  FiberManager manager(std::make_unique<SimpleLoopController>());
  auto& loopController =
      dynamic_cast<SimpleLoopController&>(manager.loopController());

  auto loopFunc = [&]() {
    if (!taskAdded) {
      manager.addTask([&]() {
        Baton baton;
        baton_ptr = &baton;

        auto res = baton.try_wait_for(std::chrono::milliseconds(130));

        EXPECT_TRUE(res);
        EXPECT_EQ(2, iterations);

        loopController.stop();
      });
      taskAdded = true;
    } else {
      std::this_thread::sleep_for(std::chrono::milliseconds(50));
      iterations++;
      if (iterations == 2) {
        baton_ptr->post();
      }
    }
  };

  loopController.loop(std::move(loopFunc));
}

TEST	(	FiberManager	,
		batonTimedWaitTimeoutEvb
	)

Definition at line 121 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), EXPECT_EQ, EXPECT_FALSE, EXPECT_GT, EXPECT_LT, folly::fibers::FiberManager::loopController(), folly::EventBase::loopForever(), now(), folly::EventBase::runInEventBaseThread(), start, folly::EventBase::terminateLoopSoon(), and folly::fibers::Baton::try_wait_for().

                                             {
  size_t tasksComplete = 0;

  folly::EventBase evb;

  FiberManager manager(std::make_unique<EventBaseLoopController>());
  dynamic_cast<EventBaseLoopController&>(manager.loopController())
      .attachEventBase(evb);

  auto task = [&](size_t timeout_ms) {
    Baton baton;

    auto start = EventBaseLoopController::Clock::now();
    auto res = baton.try_wait_for(std::chrono::milliseconds(timeout_ms));
    auto finish = EventBaseLoopController::Clock::now();

    EXPECT_FALSE(res);

    auto duration_ms =
        std::chrono::duration_cast<std::chrono::milliseconds>(finish - start);

    EXPECT_GT(duration_ms.count(), timeout_ms - 50);
    EXPECT_LT(duration_ms.count(), timeout_ms + 50);

    if (++tasksComplete == 2) {
      evb.terminateLoopSoon();
    }
  };

  evb.runInEventBaseThread([&]() {
    manager.addTask([&]() { task(500); });
    manager.addTask([&]() { task(250); });
  });

  evb.loopForever();

  EXPECT_EQ(2, tasksComplete);
}

TEST	(	FiberManager	,
		batonTimedWaitPostEvb
	)

Definition at line 160 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), EXPECT_EQ, EXPECT_TRUE, folly::fibers::FiberManager::loopController(), folly::EventBase::loopForever(), now(), folly::fibers::Baton::post(), folly::EventBase::runInEventBaseThread(), start, folly::EventBase::terminateLoopSoon(), folly::fibers::Baton::try_wait_for(), and folly::TimeoutManager::tryRunAfterDelay().

                                          {
  size_t tasksComplete = 0;

  folly::EventBase evb;

  FiberManager manager(std::make_unique<EventBaseLoopController>());
  dynamic_cast<EventBaseLoopController&>(manager.loopController())
      .attachEventBase(evb);

  evb.runInEventBaseThread([&]() {
    manager.addTask([&]() {
      Baton baton;

      evb.tryRunAfterDelay([&]() { baton.post(); }, 100);

      auto start = EventBaseLoopController::Clock::now();
      auto res = baton.try_wait_for(std::chrono::milliseconds(130));
      auto finish = EventBaseLoopController::Clock::now();

      EXPECT_TRUE(res);

      auto duration_ms =
          std::chrono::duration_cast<std::chrono::milliseconds>(finish - start);

      EXPECT_TRUE(duration_ms.count() > 95 && duration_ms.count() < 110);

      if (++tasksComplete == 1) {
        evb.terminateLoopSoon();
      }
    });
  });

  evb.loopForever();

  EXPECT_EQ(1, tasksComplete);
}

TEST	(	FiberManager	,
		batonTryWait
	)

Definition at line 197 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), b, c, EXPECT_EQ, EXPECT_TRUE, folly::fibers::FiberManager::loopUntilNoReady(), folly::fibers::Baton::post(), and folly::fibers::Baton::try_wait().

                                 {
  FiberManager manager(std::make_unique<SimpleLoopController>());

  // Check if try_wait and post work as expected
  Baton b;

  manager.addTask([&]() {
    while (!b.try_wait()) {
    }
  });
  auto thr = std::thread([&]() {
    std::this_thread::sleep_for(std::chrono::milliseconds(300));
    b.post();
  });

  manager.loopUntilNoReady();
  thr.join();

  Baton c;

  // Check try_wait without post
  manager.addTask([&]() {
    int cnt = 100;
    while (cnt && !c.try_wait()) {
      cnt--;
    }
    EXPECT_TRUE(!c.try_wait()); // must still hold
    EXPECT_EQ(cnt, 0);
  });

  manager.loopUntilNoReady();
}

TEST	(	FiberManager	,
		genericBatonFiberWait
	)

Definition at line 230 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), b, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, folly::fibers::FiberManager::hasActiveFiber(), folly::fibers::FiberManager::loopUntilNoReady(), folly::fibers::Baton::post(), and folly::fibers::Baton::wait().

                                          {
  FiberManager manager(std::make_unique<SimpleLoopController>());

  GenericBaton b;
  bool fiberRunning = false;

  manager.addTask([&]() {
    EXPECT_EQ(manager.hasActiveFiber(), true);
    fiberRunning = true;
    b.wait();
    fiberRunning = false;
  });

  EXPECT_FALSE(fiberRunning);
  manager.loopUntilNoReady();
  EXPECT_TRUE(fiberRunning); // ensure fiber still active

  auto thr = std::thread([&]() {
    std::this_thread::sleep_for(std::chrono::milliseconds(300));
    b.post();
  });

  while (fiberRunning) {
    manager.loopUntilNoReady();
  }

  thr.join();
}

TEST	(	FiberManager	,
		genericBatonThreadWait
	)

Definition at line 259 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), b, EXPECT_EQ, EXPECT_TRUE, folly::fibers::FiberManager::hasActiveFiber(), folly::fibers::FiberManager::loopUntilNoReady(), folly::fibers::Baton::post(), and folly::fibers::Baton::wait().

                                           {
  FiberManager manager(std::make_unique<SimpleLoopController>());
  GenericBaton b;
  std::atomic<bool> threadWaiting(false);

  auto thr = std::thread([&]() {
    threadWaiting = true;
    b.wait();
    threadWaiting = false;
  });

  while (!threadWaiting) {
  }
  std::this_thread::sleep_for(std::chrono::milliseconds(300));

  manager.addTask([&]() {
    EXPECT_EQ(manager.hasActiveFiber(), true);
    EXPECT_TRUE(threadWaiting);
    b.post();
    while (threadWaiting) {
    }
  });

  manager.loopUntilNoReady();
  thr.join();
}

TEST	(	FiberManager	,
		addTasksNoncopyable
	)

Definition at line 286 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), folly::fibers::addTasks(), folly::fibers::await(), EXPECT_EQ, EXPECT_GE, i, folly::fibers::FiberManager::loopController(), and folly::gen::move.

                                        {
  std::vector<Promise<int>> pendingFibers;
  bool taskAdded = false;

  FiberManager manager(std::make_unique<SimpleLoopController>());
  auto& loopController =
      dynamic_cast<SimpleLoopController&>(manager.loopController());

  auto loopFunc = [&]() {
    if (!taskAdded) {
      manager.addTask([&]() {
        std::vector<std::function<std::unique_ptr<int>()>> funcs;
        for (int i = 0; i < 3; ++i) {
          funcs.push_back([i, &pendingFibers]() {
            await([&pendingFibers](Promise<int> promise) {
              pendingFibers.push_back(std::move(promise));
            });
            return std::make_unique<int>(i * 2 + 1);
          });
        }

        auto iter = addTasks(funcs.begin(), funcs.end());

        size_t n = 0;
        while (iter.hasNext()) {
          auto result = iter.awaitNext();
          EXPECT_EQ(2 * iter.getTaskID() + 1, *result);
          EXPECT_GE(2 - n, pendingFibers.size());
          ++n;
        }
        EXPECT_EQ(3, n);
      });
      taskAdded = true;
    } else if (pendingFibers.size()) {
      pendingFibers.back().setValue(0);
      pendingFibers.pop_back();
    } else {
      loopController.stop();
    }
  };

  loopController.loop(std::move(loopFunc));
}

TEST	(	FiberManager	,
		awaitThrow
	)

Definition at line 330 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTaskFuture(), folly::fibers::await(), EXPECT_THROW, folly::fibers::getFiberManager(), folly::gen::move, folly::EventBase::runInEventBaseThread(), and folly::fibers::Promise< T, BatonT >::setValue().

                               {
  folly::EventBase evb;
  struct ExpectedException {};
  getFiberManager(evb)
      .addTaskFuture([&] {
        EXPECT_THROW(
            await([](Promise<int> p) {
              p.setValue(42);
              throw ExpectedException();
            }),
            ExpectedException);

        EXPECT_THROW(
            await([&](Promise<int> p) {
              evb.runInEventBaseThread(
                  [p = std::move(p)]() mutable { p.setValue(42); });
              throw ExpectedException();
            }),
            ExpectedException);
      })
      .waitVia(&evb);
}

TEST	(	FiberManager	,
		addTasksThrow
	)

Definition at line 353 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), folly::fibers::addTasks(), folly::fibers::await(), EXPECT_EQ, EXPECT_GE, i, folly::fibers::FiberManager::loopController(), and folly::gen::move.

                                  {
  std::vector<Promise<int>> pendingFibers;
  bool taskAdded = false;

  FiberManager manager(std::make_unique<SimpleLoopController>());
  auto& loopController =
      dynamic_cast<SimpleLoopController&>(manager.loopController());

  auto loopFunc = [&]() {
    if (!taskAdded) {
      manager.addTask([&]() {
        std::vector<std::function<int()>> funcs;
        for (size_t i = 0; i < 3; ++i) {
          funcs.push_back([i, &pendingFibers]() {
            await([&pendingFibers](Promise<int> promise) {
              pendingFibers.push_back(std::move(promise));
            });
            if (i % 2 == 0) {
              throw std::runtime_error("Runtime");
            }
            return i * 2 + 1;
          });
        }

        auto iter = addTasks(funcs.begin(), funcs.end());

        size_t n = 0;
        while (iter.hasNext()) {
          try {
            int result = iter.awaitNext();
            EXPECT_EQ(1, iter.getTaskID() % 2);
            EXPECT_EQ(2 * iter.getTaskID() + 1, result);
          } catch (...) {
            EXPECT_EQ(0, iter.getTaskID() % 2);
          }
          EXPECT_GE(2 - n, pendingFibers.size());
          ++n;
        }
        EXPECT_EQ(3, n);
      });
      taskAdded = true;
    } else if (pendingFibers.size()) {
      pendingFibers.back().setValue(0);
      pendingFibers.pop_back();
    } else {
      loopController.stop();
    }
  };

  loopController.loop(std::move(loopFunc));
}

TEST	(	FiberManager	,
		addTasksVoid
	)

Definition at line 405 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), folly::fibers::addTasks(), folly::fibers::await(), EXPECT_EQ, EXPECT_GE, i, folly::fibers::FiberManager::loopController(), and folly::gen::move.

                                 {
  std::vector<Promise<int>> pendingFibers;
  bool taskAdded = false;

  FiberManager manager(std::make_unique<SimpleLoopController>());
  auto& loopController =
      dynamic_cast<SimpleLoopController&>(manager.loopController());

  auto loopFunc = [&]() {
    if (!taskAdded) {
      manager.addTask([&]() {
        std::vector<std::function<void()>> funcs;
        for (size_t i = 0; i < 3; ++i) {
          funcs.push_back([&pendingFibers]() {
            await([&pendingFibers](Promise<int> promise) {
              pendingFibers.push_back(std::move(promise));
            });
          });
        }

        auto iter = addTasks(funcs.begin(), funcs.end());

        size_t n = 0;
        while (iter.hasNext()) {
          iter.awaitNext();
          EXPECT_GE(2 - n, pendingFibers.size());
          ++n;
        }
        EXPECT_EQ(3, n);
      });
      taskAdded = true;
    } else if (pendingFibers.size()) {
      pendingFibers.back().setValue(0);
      pendingFibers.pop_back();
    } else {
      loopController.stop();
    }
  };

  loopController.loop(std::move(loopFunc));
}

TEST	(	FiberManager	,
		addTasksVoidThrow
	)

Definition at line 447 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), folly::fibers::addTasks(), folly::fibers::await(), EXPECT_EQ, EXPECT_GE, i, folly::fibers::FiberManager::loopController(), and folly::gen::move.

                                      {
  std::vector<Promise<int>> pendingFibers;
  bool taskAdded = false;

  FiberManager manager(std::make_unique<SimpleLoopController>());
  auto& loopController =
      dynamic_cast<SimpleLoopController&>(manager.loopController());

  auto loopFunc = [&]() {
    if (!taskAdded) {
      manager.addTask([&]() {
        std::vector<std::function<void()>> funcs;
        for (size_t i = 0; i < 3; ++i) {
          funcs.push_back([i, &pendingFibers]() {
            await([&pendingFibers](Promise<int> promise) {
              pendingFibers.push_back(std::move(promise));
            });
            if (i % 2 == 0) {
              throw std::runtime_error("");
            }
          });
        }

        auto iter = addTasks(funcs.begin(), funcs.end());

        size_t n = 0;
        while (iter.hasNext()) {
          try {
            iter.awaitNext();
            EXPECT_EQ(1, iter.getTaskID() % 2);
          } catch (...) {
            EXPECT_EQ(0, iter.getTaskID() % 2);
          }
          EXPECT_GE(2 - n, pendingFibers.size());
          ++n;
        }
        EXPECT_EQ(3, n);
      });
      taskAdded = true;
    } else if (pendingFibers.size()) {
      pendingFibers.back().setValue(0);
      pendingFibers.pop_back();
    } else {
      loopController.stop();
    }
  };

  loopController.loop(std::move(loopFunc));
}

TEST	(	FiberManager	,
		addTasksReserve
	)

Definition at line 497 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), folly::fibers::addTasks(), folly::fibers::await(), EXPECT_FALSE, EXPECT_TRUE, i, folly::fibers::FiberManager::loopController(), and folly::gen::move.

                                    {
  std::vector<Promise<int>> pendingFibers;
  bool taskAdded = false;

  FiberManager manager(std::make_unique<SimpleLoopController>());
  auto& loopController =
      dynamic_cast<SimpleLoopController&>(manager.loopController());

  auto loopFunc = [&]() {
    if (!taskAdded) {
      manager.addTask([&]() {
        std::vector<std::function<void()>> funcs;
        for (size_t i = 0; i < 3; ++i) {
          funcs.push_back([&pendingFibers]() {
            await([&pendingFibers](Promise<int> promise) {
              pendingFibers.push_back(std::move(promise));
            });
          });
        }

        auto iter = addTasks(funcs.begin(), funcs.end());

        iter.reserve(2);
        EXPECT_TRUE(iter.hasCompleted());
        EXPECT_TRUE(iter.hasPending());
        EXPECT_TRUE(iter.hasNext());

        iter.awaitNext();
        EXPECT_TRUE(iter.hasCompleted());
        EXPECT_TRUE(iter.hasPending());
        EXPECT_TRUE(iter.hasNext());

        iter.awaitNext();
        EXPECT_FALSE(iter.hasCompleted());
        EXPECT_TRUE(iter.hasPending());
        EXPECT_TRUE(iter.hasNext());

        iter.awaitNext();
        EXPECT_FALSE(iter.hasCompleted());
        EXPECT_FALSE(iter.hasPending());
        EXPECT_FALSE(iter.hasNext());
      });
      taskAdded = true;
    } else if (pendingFibers.size()) {
      pendingFibers.back().setValue(0);
      pendingFibers.pop_back();
    } else {
      loopController.stop();
    }
  };

  loopController.loop(std::move(loopFunc));
}

TEST	(	FiberManager	,
		addTaskDynamic
	)

Definition at line 551 of file FibersTest.cpp.

References folly::fibers::TaskIterator< T >::addTask(), folly::fibers::FiberManager::addTaskFuture(), folly::fibers::TaskIterator< T >::awaitNext(), EXPECT_EQ, folly::fibers::getFiberManager(), folly::fibers::Baton::post(), and folly::fibers::Baton::wait().

                                   {
  folly::EventBase evb;

  Baton batons[3];

  auto makeTask = [&](size_t taskId) {
    return [&, taskId]() -> size_t {
      batons[taskId].wait();
      return taskId;
    };
  };

  getFiberManager(evb)
      .addTaskFuture([&]() {
        TaskIterator<size_t> iterator;

        iterator.addTask(makeTask(0));
        iterator.addTask(makeTask(1));

        batons[1].post();

        EXPECT_EQ(1, iterator.awaitNext());

        iterator.addTask(makeTask(2));

        batons[2].post();

        EXPECT_EQ(2, iterator.awaitNext());

        batons[0].post();

        EXPECT_EQ(0, iterator.awaitNext());
      })
      .waitVia(&evb);
}

TEST	(	FiberManager	,
		forEach
	)

Definition at line 587 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), folly::fibers::await(), EXPECT_EQ, EXPECT_TRUE, folly::gen::first, folly::fibers::forEach(), i, folly::fibers::FiberManager::loopController(), and folly::gen::move.

                            {
  std::vector<Promise<int>> pendingFibers;
  bool taskAdded = false;

  FiberManager manager(std::make_unique<SimpleLoopController>());
  auto& loopController =
      dynamic_cast<SimpleLoopController&>(manager.loopController());

  auto loopFunc = [&]() {
    if (!taskAdded) {
      manager.addTask([&]() {
        std::vector<std::function<int()>> funcs;
        for (size_t i = 0; i < 3; ++i) {
          funcs.push_back([i, &pendingFibers]() {
            await([&pendingFibers](Promise<int> promise) {
              pendingFibers.push_back(std::move(promise));
            });
            return i * 2 + 1;
          });
        }

        std::vector<std::pair<size_t, int>> results;
        forEach(funcs.begin(), funcs.end(), [&results](size_t id, int result) {
          results.emplace_back(id, result);
        });
        EXPECT_EQ(3, results.size());
        EXPECT_TRUE(pendingFibers.empty());
        for (size_t i = 0; i < 3; ++i) {
          EXPECT_EQ(results[i].first * 2 + 1, results[i].second);
        }
      });
      taskAdded = true;
    } else if (pendingFibers.size()) {
      pendingFibers.back().setValue(0);
      pendingFibers.pop_back();
    } else {
      loopController.stop();
    }
  };

  loopController.loop(std::move(loopFunc));
}

TEST	(	FiberManager	,
		collectN
	)

Definition at line 630 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), folly::fibers::await(), folly::fibers::collectN(), EXPECT_EQ, folly::gen::first, i, folly::fibers::FiberManager::loopController(), and folly::gen::move.

                             {
  std::vector<Promise<int>> pendingFibers;
  bool taskAdded = false;

  FiberManager manager(std::make_unique<SimpleLoopController>());
  auto& loopController =
      dynamic_cast<SimpleLoopController&>(manager.loopController());

  auto loopFunc = [&]() {
    if (!taskAdded) {
      manager.addTask([&]() {
        std::vector<std::function<int()>> funcs;
        for (size_t i = 0; i < 3; ++i) {
          funcs.push_back([i, &pendingFibers]() {
            await([&pendingFibers](Promise<int> promise) {
              pendingFibers.push_back(std::move(promise));
            });
            return i * 2 + 1;
          });
        }

        auto results = collectN(funcs.begin(), funcs.end(), 2);
        EXPECT_EQ(2, results.size());
        EXPECT_EQ(1, pendingFibers.size());
        for (size_t i = 0; i < 2; ++i) {
          EXPECT_EQ(results[i].first * 2 + 1, results[i].second);
        }
      });
      taskAdded = true;
    } else if (pendingFibers.size()) {
      pendingFibers.back().setValue(0);
      pendingFibers.pop_back();
    } else {
      loopController.stop();
    }
  };

  loopController.loop(std::move(loopFunc));
}

TEST	(	FiberManager	,
		collectNThrow
	)

Definition at line 670 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), folly::fibers::await(), folly::fibers::collectN(), EXPECT_EQ, i, folly::fibers::FiberManager::loopController(), and folly::gen::move.

                                  {
  std::vector<Promise<int>> pendingFibers;
  bool taskAdded = false;

  FiberManager manager(std::make_unique<SimpleLoopController>());
  auto& loopController =
      dynamic_cast<SimpleLoopController&>(manager.loopController());

  auto loopFunc = [&]() {
    if (!taskAdded) {
      manager.addTask([&]() {
        std::vector<std::function<int()>> funcs;
        for (size_t i = 0; i < 3; ++i) {
          funcs.push_back([&pendingFibers]() -> size_t {
            await([&pendingFibers](Promise<int> promise) {
              pendingFibers.push_back(std::move(promise));
            });
            throw std::runtime_error("Runtime");
          });
        }

        try {
          collectN(funcs.begin(), funcs.end(), 2);
        } catch (...) {
          EXPECT_EQ(1, pendingFibers.size());
        }
      });
      taskAdded = true;
    } else if (pendingFibers.size()) {
      pendingFibers.back().setValue(0);
      pendingFibers.pop_back();
    } else {
      loopController.stop();
    }
  };

  loopController.loop(std::move(loopFunc));
}

TEST	(	FiberManager	,
		collectNVoid
	)

Definition at line 709 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), folly::fibers::await(), folly::fibers::collectN(), EXPECT_EQ, i, folly::fibers::FiberManager::loopController(), and folly::gen::move.

                                 {
  std::vector<Promise<int>> pendingFibers;
  bool taskAdded = false;

  FiberManager manager(std::make_unique<SimpleLoopController>());
  auto& loopController =
      dynamic_cast<SimpleLoopController&>(manager.loopController());

  auto loopFunc = [&]() {
    if (!taskAdded) {
      manager.addTask([&]() {
        std::vector<std::function<void()>> funcs;
        for (size_t i = 0; i < 3; ++i) {
          funcs.push_back([&pendingFibers]() {
            await([&pendingFibers](Promise<int> promise) {
              pendingFibers.push_back(std::move(promise));
            });
          });
        }

        auto results = collectN(funcs.begin(), funcs.end(), 2);
        EXPECT_EQ(2, results.size());
        EXPECT_EQ(1, pendingFibers.size());
      });
      taskAdded = true;
    } else if (pendingFibers.size()) {
      pendingFibers.back().setValue(0);
      pendingFibers.pop_back();
    } else {
      loopController.stop();
    }
  };

  loopController.loop(std::move(loopFunc));
}

TEST	(	FiberManager	,
		collectNVoidThrow
	)

Definition at line 745 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), folly::fibers::await(), folly::fibers::collectN(), EXPECT_EQ, i, folly::fibers::FiberManager::loopController(), and folly::gen::move.

                                      {
  std::vector<Promise<int>> pendingFibers;
  bool taskAdded = false;

  FiberManager manager(std::make_unique<SimpleLoopController>());
  auto& loopController =
      dynamic_cast<SimpleLoopController&>(manager.loopController());

  auto loopFunc = [&]() {
    if (!taskAdded) {
      manager.addTask([&]() {
        std::vector<std::function<void()>> funcs;
        for (size_t i = 0; i < 3; ++i) {
          funcs.push_back([&pendingFibers]() {
            await([&pendingFibers](Promise<int> promise) {
              pendingFibers.push_back(std::move(promise));
            });
            throw std::runtime_error("Runtime");
          });
        }

        try {
          collectN(funcs.begin(), funcs.end(), 2);
        } catch (...) {
          EXPECT_EQ(1, pendingFibers.size());
        }
      });
      taskAdded = true;
    } else if (pendingFibers.size()) {
      pendingFibers.back().setValue(0);
      pendingFibers.pop_back();
    } else {
      loopController.stop();
    }
  };

  loopController.loop(std::move(loopFunc));
}

TEST	(	FiberManager	,
		collectAll
	)

Definition at line 784 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), folly::fibers::await(), folly::fibers::collectAll(), EXPECT_EQ, EXPECT_TRUE, i, folly::fibers::FiberManager::loopController(), and folly::gen::move.

                               {
  std::vector<Promise<int>> pendingFibers;
  bool taskAdded = false;

  FiberManager manager(std::make_unique<SimpleLoopController>());
  auto& loopController =
      dynamic_cast<SimpleLoopController&>(manager.loopController());

  auto loopFunc = [&]() {
    if (!taskAdded) {
      manager.addTask([&]() {
        std::vector<std::function<int()>> funcs;
        for (size_t i = 0; i < 3; ++i) {
          funcs.push_back([i, &pendingFibers]() {
            await([&pendingFibers](Promise<int> promise) {
              pendingFibers.push_back(std::move(promise));
            });
            return i * 2 + 1;
          });
        }

        auto results = collectAll(funcs.begin(), funcs.end());
        EXPECT_TRUE(pendingFibers.empty());
        for (size_t i = 0; i < 3; ++i) {
          EXPECT_EQ(i * 2 + 1, results[i]);
        }
      });
      taskAdded = true;
    } else if (pendingFibers.size()) {
      pendingFibers.back().setValue(0);
      pendingFibers.pop_back();
    } else {
      loopController.stop();
    }
  };

  loopController.loop(std::move(loopFunc));
}

TEST	(	FiberManager	,
		collectAllVoid
	)

Definition at line 823 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), folly::fibers::await(), folly::fibers::collectAll(), EXPECT_TRUE, i, folly::fibers::FiberManager::loopController(), and folly::gen::move.

                                   {
  std::vector<Promise<int>> pendingFibers;
  bool taskAdded = false;

  FiberManager manager(std::make_unique<SimpleLoopController>());
  auto& loopController =
      dynamic_cast<SimpleLoopController&>(manager.loopController());

  auto loopFunc = [&]() {
    if (!taskAdded) {
      manager.addTask([&]() {
        std::vector<std::function<void()>> funcs;
        for (size_t i = 0; i < 3; ++i) {
          funcs.push_back([&pendingFibers]() {
            await([&pendingFibers](Promise<int> promise) {
              pendingFibers.push_back(std::move(promise));
            });
          });
        }

        collectAll(funcs.begin(), funcs.end());
        EXPECT_TRUE(pendingFibers.empty());
      });
      taskAdded = true;
    } else if (pendingFibers.size()) {
      pendingFibers.back().setValue(0);
      pendingFibers.pop_back();
    } else {
      loopController.stop();
    }
  };

  loopController.loop(std::move(loopFunc));
}

TEST	(	FiberManager	,
		collectAny
	)

Definition at line 858 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), folly::fibers::await(), folly::fibers::collectAny(), EXPECT_EQ, EXPECT_FALSE, EXPECT_GT, EXPECT_LT, i, folly::kIsSanitizeAddress, folly::fibers::FiberManager::loopController(), and folly::gen::move.

                               {
  std::vector<Promise<int>> pendingFibers;
  bool taskAdded = false;

  FiberManager manager(std::make_unique<SimpleLoopController>());
  auto& loopController =
      dynamic_cast<SimpleLoopController&>(manager.loopController());

  auto loopFunc = [&]() {
    if (!taskAdded) {
      manager.addTask([&]() {
        std::vector<std::function<int()>> funcs;
        for (size_t i = 0; i < 3; ++i) {
          funcs.push_back([i, &pendingFibers]() {
            await([&pendingFibers](Promise<int> promise) {
              pendingFibers.push_back(std::move(promise));
            });
            if (i == 1) {
              throw std::runtime_error("This exception will be ignored");
            }
            return i * 2 + 1;
          });
        }

        auto result = collectAny(funcs.begin(), funcs.end());
        EXPECT_EQ(2, pendingFibers.size());
        EXPECT_EQ(2, result.first);
        EXPECT_EQ(2 * 2 + 1, result.second);
      });
      taskAdded = true;
    } else if (pendingFibers.size()) {
      pendingFibers.back().setValue(0);
      pendingFibers.pop_back();
    } else {
      loopController.stop();
    }
  };

  loopController.loop(std::move(loopFunc));
}

TEST	(	FiberManager	,
		runInMainContext
	)

Definition at line 927 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), EXPECT_EQ, EXPECT_TRUE, folly::fibers::FiberManager::loopController(), folly::fibers::FiberManager::runInMainContext(), folly::fibers::runInMainContext(), and folly::value().

                                     {
  FiberManager manager(std::make_unique<SimpleLoopController>());
  auto& loopController =
      dynamic_cast<SimpleLoopController&>(manager.loopController());

  bool checkRan = false;

  int mainLocation;
  manager.runInMainContext(
      [&]() { expectMainContext(checkRan, &mainLocation, nullptr); });
  EXPECT_TRUE(checkRan);

  checkRan = false;

  manager.addTask([&]() {
    struct A {
      explicit A(int value_) : value(value_) {}
      A(const A&) = delete;
      A(A&&) = default;

      int value;
    };
    int stackLocation;
    auto ret = runInMainContext([&]() {
      expectMainContext(checkRan, &mainLocation, &stackLocation);
      return A(42);
    });
    EXPECT_TRUE(checkRan);
    EXPECT_EQ(42, ret.value);
  });

  loopController.loop([&]() { loopController.stop(); });

  EXPECT_TRUE(checkRan);
}

TEST	(	FiberManager	,
		addTaskFinally
	)

Definition at line 963 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTaskFinally(), EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, and folly::fibers::FiberManager::loopController().

                                   {
  FiberManager manager(std::make_unique<SimpleLoopController>());
  auto& loopController =
      dynamic_cast<SimpleLoopController&>(manager.loopController());

  bool checkRan = false;

  int mainLocation;

  manager.addTaskFinally(
      [&]() { return 1234; },
      [&](Try<int>&& result) {
        EXPECT_EQ(result.value(), 1234);

        expectMainContext(checkRan, &mainLocation, nullptr);
      });

  EXPECT_FALSE(checkRan);

  loopController.loop([&]() { loopController.stop(); });

  EXPECT_TRUE(checkRan);
}

TEST	(	FiberManager	,
		fibersPoolWithinLimit
	)

Definition at line 987 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), EXPECT_EQ, folly::fibers::FiberManager::fibersAllocated(), folly::fibers::FiberManager::fibersPoolSize(), i, folly::fibers::FiberManager::loopController(), and folly::fibers::FiberManager::Options::maxFibersPoolSize.

                                          {
  FiberManager::Options opts;
  opts.maxFibersPoolSize = 5;

  FiberManager manager(std::make_unique<SimpleLoopController>(), opts);
  auto& loopController =
      dynamic_cast<SimpleLoopController&>(manager.loopController());

  size_t fibersRun = 0;

  for (size_t i = 0; i < 5; ++i) {
    manager.addTask([&]() { ++fibersRun; });
  }
  loopController.loop([&]() { loopController.stop(); });

  EXPECT_EQ(5, fibersRun);
  EXPECT_EQ(5, manager.fibersAllocated());
  EXPECT_EQ(5, manager.fibersPoolSize());

  for (size_t i = 0; i < 5; ++i) {
    manager.addTask([&]() { ++fibersRun; });
  }
  loopController.loop([&]() { loopController.stop(); });

  EXPECT_EQ(10, fibersRun);
  EXPECT_EQ(5, manager.fibersAllocated());
  EXPECT_EQ(5, manager.fibersPoolSize());
}

TEST	(	FiberManager	,
		fibersPoolOverLimit
	)

Definition at line 1016 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), EXPECT_EQ, folly::fibers::FiberManager::fibersAllocated(), folly::fibers::FiberManager::fibersPoolSize(), i, folly::fibers::FiberManager::loopController(), and folly::fibers::FiberManager::Options::maxFibersPoolSize.

                                        {
  FiberManager::Options opts;
  opts.maxFibersPoolSize = 5;

  FiberManager manager(std::make_unique<SimpleLoopController>(), opts);
  auto& loopController =
      dynamic_cast<SimpleLoopController&>(manager.loopController());

  size_t fibersRun = 0;

  for (size_t i = 0; i < 10; ++i) {
    manager.addTask([&]() { ++fibersRun; });
  }

  EXPECT_EQ(0, fibersRun);
  EXPECT_EQ(10, manager.fibersAllocated());
  EXPECT_EQ(0, manager.fibersPoolSize());

  loopController.loop([&]() { loopController.stop(); });

  EXPECT_EQ(10, fibersRun);
  EXPECT_EQ(5, manager.fibersAllocated());
  EXPECT_EQ(5, manager.fibersPoolSize());
}

TEST	(	FiberManager	,
		remoteFiberBasic
	)

Definition at line 1041 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), folly::fibers::await(), EXPECT_EQ, EXPECT_TRUE, folly::fibers::FiberManager::loopController(), folly::fibers::FiberManager::loopUntilNoReady(), and folly::gen::move.

                                     {
  FiberManager manager(std::make_unique<SimpleLoopController>());
  auto& loopController =
      dynamic_cast<SimpleLoopController&>(manager.loopController());

  int result[2];
  result[0] = result[1] = 0;
  folly::Optional<Promise<int>> savedPromise[2];
  manager.addTask([&]() {
    result[0] = await(
        [&](Promise<int> promise) { savedPromise[0] = std::move(promise); });
  });
  manager.addTask([&]() {
    result[1] = await(
        [&](Promise<int> promise) { savedPromise[1] = std::move(promise); });
  });

  manager.loopUntilNoReady();

  EXPECT_TRUE(savedPromise[0].hasValue());
  EXPECT_TRUE(savedPromise[1].hasValue());
  EXPECT_EQ(0, result[0]);
  EXPECT_EQ(0, result[1]);

  std::thread remoteThread0{[&]() { savedPromise[0]->setValue(42); }};
  std::thread remoteThread1{[&]() { savedPromise[1]->setValue(43); }};
  remoteThread0.join();
  remoteThread1.join();
  EXPECT_EQ(0, result[0]);
  EXPECT_EQ(0, result[1]);
  /* Should only have scheduled once */
  EXPECT_EQ(1, loopController.remoteScheduleCalled());

  manager.loopUntilNoReady();
  EXPECT_EQ(42, result[0]);
  EXPECT_EQ(43, result[1]);
}

TEST	(	FiberManager	,
		addTaskRemoteBasic
	)

Definition at line 1079 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTaskRemote(), folly::fibers::await(), EXPECT_EQ, EXPECT_TRUE, folly::fibers::FiberManager::loopUntilNoReady(), and folly::gen::move.

                                       {
  FiberManager manager(std::make_unique<SimpleLoopController>());

  int result[2];
  result[0] = result[1] = 0;
  folly::Optional<Promise<int>> savedPromise[2];

  std::thread remoteThread0{[&]() {
    manager.addTaskRemote([&]() {
      result[0] = await(
          [&](Promise<int> promise) { savedPromise[0] = std::move(promise); });
    });
  }};
  std::thread remoteThread1{[&]() {
    manager.addTaskRemote([&]() {
      result[1] = await(
          [&](Promise<int> promise) { savedPromise[1] = std::move(promise); });
    });
  }};
  remoteThread0.join();
  remoteThread1.join();

  manager.loopUntilNoReady();

  EXPECT_TRUE(savedPromise[0].hasValue());
  EXPECT_TRUE(savedPromise[1].hasValue());
  EXPECT_EQ(0, result[0]);
  EXPECT_EQ(0, result[1]);

  savedPromise[0]->setValue(42);
  savedPromise[1]->setValue(43);

  EXPECT_EQ(0, result[0]);
  EXPECT_EQ(0, result[1]);

  manager.loopUntilNoReady();
  EXPECT_EQ(42, result[0]);
  EXPECT_EQ(43, result[1]);
}

TEST	(	FiberManager	,
		remoteHasTasks
	)

Definition at line 1119 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTaskRemote(), counter, EXPECT_EQ, EXPECT_FALSE, folly::fibers::FiberManager::hasTasks(), and folly::fibers::FiberManager::loopUntilNoReady().

                                   {
  size_t counter = 0;
  FiberManager fm(std::make_unique<SimpleLoopController>());
  std::thread remote([&]() { fm.addTaskRemote([&]() { ++counter; }); });

  remote.join();

  while (fm.hasTasks()) {
    fm.loopUntilNoReady();
  }

  EXPECT_FALSE(fm.hasTasks());
  EXPECT_EQ(counter, 1);
}

TEST	(	FiberManager	,
		remoteHasReadyTasks
	)

Definition at line 1134 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTaskRemote(), folly::fibers::await(), EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, folly::fibers::FiberManager::hasTasks(), folly::fibers::FiberManager::loopUntilNoReady(), and folly::gen::move.

                                        {
  int result = 0;
  folly::Optional<Promise<int>> savedPromise;
  FiberManager fm(std::make_unique<SimpleLoopController>());
  std::thread remote([&]() {
    fm.addTaskRemote([&]() {
      result = await(
          [&](Promise<int> promise) { savedPromise = std::move(promise); });
      EXPECT_TRUE(fm.hasTasks());
    });
  });

  remote.join();
  EXPECT_TRUE(fm.hasTasks());

  fm.loopUntilNoReady();
  EXPECT_TRUE(fm.hasTasks());

  std::thread remote2([&]() { savedPromise->setValue(47); });
  remote2.join();
  EXPECT_TRUE(fm.hasTasks());

  fm.loopUntilNoReady();
  EXPECT_FALSE(fm.hasTasks());

  EXPECT_EQ(result, 47);
}

TEST	(	FiberManager	,
		fiberLocal
	)

Definition at line 1206 of file FibersTest.cpp.

References folly::value().

                               {
  struct SimpleData {
    int value{42};
  };

  testFiberLocal<SimpleData>();
}

TEST	(	FiberManager	,
		fiberLocalHeap
	)

Definition at line 1214 of file FibersTest.cpp.

References testing::_, and folly::value().

                                   {
  struct LargeData {
    char _[1024 * 1024];
    int value{42};
  };

  testFiberLocal<LargeData>();
}

TEST	(	FiberManager	,
		fiberLocalDestructor
	)

Definition at line 1223 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), folly::fibers::addTask(), folly::data(), EXPECT_EQ, EXPECT_FALSE, folly::fibers::FiberManager::hasTasks(), and folly::fibers::FiberManager::loopUntilNoReady().

                                         {
  struct CrazyData {
    size_t data{42};

    ~CrazyData() {
      if (data == 41) {
        addTask([]() {
          EXPECT_EQ(42, local<CrazyData>().data);
          // Make sure we don't have infinite loop
          local<CrazyData>().data = 0;
        });
      }
    }
  };

  FiberManager fm(
      LocalType<CrazyData>(), std::make_unique<SimpleLoopController>());

  fm.addTask([]() { local<CrazyData>().data = 41; });

  fm.loopUntilNoReady();
  EXPECT_FALSE(fm.hasTasks());
}

TEST	(	FiberManager	,
		yieldTest
	)

Definition at line 1247 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), EXPECT_TRUE, folly::fibers::FiberManager::loopController(), and folly::fibers::FiberManager::yield().

                              {
  FiberManager manager(std::make_unique<SimpleLoopController>());
  auto& loopController =
      dynamic_cast<SimpleLoopController&>(manager.loopController());

  bool checkRan = false;

  manager.addTask([&]() {
    manager.yield();
    checkRan = true;
  });

  loopController.loop([&]() {
    if (checkRan) {
      loopController.stop();
    }
  });

  EXPECT_TRUE(checkRan);
}

TEST	(	FiberManager	,
		RequestContext
	)

Definition at line 1268 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), folly::fibers::FiberManager::addTaskFinally(), folly::fibers::FiberManager::addTaskRemote(), EXPECT_EQ, EXPECT_TRUE, folly::RequestContext::get(), folly::fibers::FiberManager::loopUntilNoReady(), folly::fibers::Baton::post(), folly::fibers::runInMainContext(), folly::RequestContext::setContext(), and folly::fibers::Baton::wait().

                                   {
  FiberManager fm(std::make_unique<SimpleLoopController>());

  bool checkRun1 = false;
  bool checkRun2 = false;
  bool checkRun3 = false;
  bool checkRun4 = false;
  folly::fibers::Baton baton1;
  folly::fibers::Baton baton2;
  folly::fibers::Baton baton3;
  folly::fibers::Baton baton4;

  {
    folly::RequestContextScopeGuard rctx;
    auto rcontext1 = folly::RequestContext::get();
    fm.addTask([&, rcontext1]() {
      EXPECT_EQ(rcontext1, folly::RequestContext::get());
      baton1.wait(
          [&]() { EXPECT_EQ(rcontext1, folly::RequestContext::get()); });
      EXPECT_EQ(rcontext1, folly::RequestContext::get());
      runInMainContext(
          [&]() { EXPECT_EQ(rcontext1, folly::RequestContext::get()); });
      checkRun1 = true;
    });
  }
  {
    folly::RequestContextScopeGuard rctx;
    auto rcontext2 = folly::RequestContext::get();
    fm.addTaskRemote([&, rcontext2]() {
      EXPECT_EQ(rcontext2, folly::RequestContext::get());
      baton2.wait();
      EXPECT_EQ(rcontext2, folly::RequestContext::get());
      checkRun2 = true;
    });
  }
  {
    folly::RequestContextScopeGuard rctx;
    auto rcontext3 = folly::RequestContext::get();
    fm.addTaskFinally(
        [&, rcontext3]() {
          EXPECT_EQ(rcontext3, folly::RequestContext::get());
          baton3.wait();
          EXPECT_EQ(rcontext3, folly::RequestContext::get());

          return folly::Unit();
        },
        [&, rcontext3](Try<folly::Unit>&& /* t */) {
          EXPECT_EQ(rcontext3, folly::RequestContext::get());
          checkRun3 = true;
        });
  }
  {
    folly::RequestContext::setContext(nullptr);
    fm.addTask([&]() {
      folly::RequestContextScopeGuard rctx;
      auto rcontext4 = folly::RequestContext::get();
      baton4.wait();
      EXPECT_EQ(rcontext4, folly::RequestContext::get());
      checkRun4 = true;
    });
  }
  {
    folly::RequestContextScopeGuard rctx;
    auto rcontext = folly::RequestContext::get();

    fm.loopUntilNoReady();
    EXPECT_EQ(rcontext, folly::RequestContext::get());

    baton1.post();
    EXPECT_EQ(rcontext, folly::RequestContext::get());
    fm.loopUntilNoReady();
    EXPECT_TRUE(checkRun1);
    EXPECT_EQ(rcontext, folly::RequestContext::get());

    baton2.post();
    EXPECT_EQ(rcontext, folly::RequestContext::get());
    fm.loopUntilNoReady();
    EXPECT_TRUE(checkRun2);
    EXPECT_EQ(rcontext, folly::RequestContext::get());

    baton3.post();
    EXPECT_EQ(rcontext, folly::RequestContext::get());
    fm.loopUntilNoReady();
    EXPECT_TRUE(checkRun3);
    EXPECT_EQ(rcontext, folly::RequestContext::get());

    baton4.post();
    EXPECT_EQ(rcontext, folly::RequestContext::get());
    fm.loopUntilNoReady();
    EXPECT_TRUE(checkRun4);
    EXPECT_EQ(rcontext, folly::RequestContext::get());
  }
}

TEST	(	FiberManager	,
		resizePeriodically
	)

Definition at line 1362 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), EXPECT_EQ, folly::fibers::FiberManager::fibersAllocated(), folly::fibers::FiberManager::Options::fibersPoolResizePeriodMs, folly::fibers::FiberManager::fibersPoolSize(), i, folly::fibers::FiberManager::loopController(), folly::EventBase::loopOnce(), and folly::fibers::FiberManager::Options::maxFibersPoolSize.

                                       {
  FiberManager::Options opts;
  opts.fibersPoolResizePeriodMs = 300;
  opts.maxFibersPoolSize = 5;

  FiberManager manager(std::make_unique<EventBaseLoopController>(), opts);

  folly::EventBase evb;
  dynamic_cast<EventBaseLoopController&>(manager.loopController())
      .attachEventBase(evb);

  std::vector<Baton> batons(10);

  size_t tasksRun = 0;
  for (size_t i = 0; i < 30; ++i) {
    manager.addTask([i, &batons, &tasksRun]() {
      ++tasksRun;
      // Keep some fibers active indefinitely
      if (i < batons.size()) {
        batons[i].wait();
      }
    });
  }

  EXPECT_EQ(0, tasksRun);
  EXPECT_EQ(30, manager.fibersAllocated());
  EXPECT_EQ(0, manager.fibersPoolSize());

  evb.loopOnce();
  EXPECT_EQ(30, tasksRun);
  EXPECT_EQ(30, manager.fibersAllocated());
  // Can go over maxFibersPoolSize, 10 of 30 fibers still active
  EXPECT_EQ(20, manager.fibersPoolSize());

  std::this_thread::sleep_for(std::chrono::milliseconds(400));
  evb.loopOnce(); // no fibers active in this period
  EXPECT_EQ(30, manager.fibersAllocated());
  EXPECT_EQ(20, manager.fibersPoolSize());

  std::this_thread::sleep_for(std::chrono::milliseconds(400));
  evb.loopOnce(); // should shrink fibers pool to maxFibersPoolSize
  EXPECT_EQ(15, manager.fibersAllocated());
  EXPECT_EQ(5, manager.fibersPoolSize());

  for (size_t i = 0; i < batons.size(); ++i) {
    batons[i].post();
  }
  evb.loopOnce();
  EXPECT_EQ(15, manager.fibersAllocated());
  EXPECT_EQ(15, manager.fibersPoolSize());

  std::this_thread::sleep_for(std::chrono::milliseconds(400));
  evb.loopOnce(); // 10 fibers active in last period
  EXPECT_EQ(10, manager.fibersAllocated());
  EXPECT_EQ(10, manager.fibersPoolSize());

  std::this_thread::sleep_for(std::chrono::milliseconds(400));
  evb.loopOnce();
  EXPECT_EQ(5, manager.fibersAllocated());
  EXPECT_EQ(5, manager.fibersPoolSize());
}

TEST	(	FiberManager	,
		batonWaitTimeoutHandler
	)

Definition at line 1424 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), EXPECT_EQ, EXPECT_FALSE, folly::fibers::FiberManager::loopController(), folly::EventBase::loopOnce(), folly::fibers::FiberManager::loopUntilNoReady(), folly::fibers::Baton::TimeoutHandler::scheduleTimeout(), folly::fibers::Baton::try_wait(), and folly::fibers::Baton::wait().

                                            {
  FiberManager manager(std::make_unique<EventBaseLoopController>());

  folly::EventBase evb;
  dynamic_cast<EventBaseLoopController&>(manager.loopController())
      .attachEventBase(evb);

  size_t fibersRun = 0;
  Baton baton;
  Baton::TimeoutHandler timeoutHandler;

  manager.addTask([&]() {
    baton.wait(timeoutHandler);
    ++fibersRun;
  });
  manager.loopUntilNoReady();

  EXPECT_FALSE(baton.try_wait());
  EXPECT_EQ(0, fibersRun);

  timeoutHandler.scheduleTimeout(std::chrono::milliseconds(250));
  std::this_thread::sleep_for(std::chrono::milliseconds(500));

  EXPECT_FALSE(baton.try_wait());
  EXPECT_EQ(0, fibersRun);

  evb.loopOnce();
  manager.loopUntilNoReady();

  EXPECT_EQ(1, fibersRun);
}

TEST	(	FiberManager	,
		batonWaitTimeoutMany
	)

Definition at line 1456 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), folly::fibers::addTask(), i, folly::fibers::FiberManager::loopController(), folly::EventBase::loopForever(), folly::fibers::Baton::TimeoutHandler::scheduleTimeout(), folly::EventBase::terminateLoopSoon(), and folly::fibers::Baton::wait().

                                         {
  FiberManager manager(std::make_unique<EventBaseLoopController>());

  folly::EventBase evb;
  dynamic_cast<EventBaseLoopController&>(manager.loopController())
      .attachEventBase(evb);

  constexpr size_t kNumTimeoutTasks = 10000;
  size_t tasksCount = kNumTimeoutTasks;

  // We add many tasks to hit timeout queue deallocation logic.
  for (size_t i = 0; i < kNumTimeoutTasks; ++i) {
    manager.addTask([&]() {
      Baton baton;
      Baton::TimeoutHandler timeoutHandler;

      folly::fibers::addTask([&] {
        timeoutHandler.scheduleTimeout(std::chrono::milliseconds(1000));
      });

      baton.wait(timeoutHandler);
      if (--tasksCount == 0) {
        evb.terminateLoopSoon();
      }
    });
  }

  evb.loopForever();
}

TEST	(	FiberManager	,
		remoteFutureTest
	)

Definition at line 1486 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTaskFuture(), folly::fibers::FiberManager::addTaskRemoteFuture(), EXPECT_EQ, folly::fibers::FiberManager::loopController(), and folly::gen::move.

                                     {
  FiberManager fiberManager(std::make_unique<SimpleLoopController>());
  auto& loopController =
      dynamic_cast<SimpleLoopController&>(fiberManager.loopController());

  int testValue1 = 5;
  int testValue2 = 7;
  auto f1 = fiberManager.addTaskFuture([&]() { return testValue1; });
  auto f2 = fiberManager.addTaskRemoteFuture([&]() { return testValue2; });
  loopController.loop([&]() { loopController.stop(); });
  auto v1 = std::move(f1).get();
  auto v2 = std::move(f2).get();

  EXPECT_EQ(v1, testValue1);
  EXPECT_EQ(v2, testValue2);
}

TEST	(	FiberManager	,
		remoteFutureVoidUnitTest
	)

Definition at line 1504 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTaskFuture(), folly::fibers::FiberManager::addTaskRemoteFuture(), ASSERT_TRUE, folly::fibers::FiberManager::loopController(), and folly::Future< T >::wait().

                                             {
  FiberManager fiberManager(std::make_unique<SimpleLoopController>());
  auto& loopController =
      dynamic_cast<SimpleLoopController&>(fiberManager.loopController());

  bool ranLocal = false;
  folly::Future<folly::Unit> futureLocal =
      fiberManager.addTaskFuture([&]() { ranLocal = true; });

  bool ranRemote = false;
  folly::Future<folly::Unit> futureRemote =
      fiberManager.addTaskRemoteFuture([&]() { ranRemote = true; });

  loopController.loop([&]() { loopController.stop(); });

  futureLocal.wait();
  ASSERT_TRUE(ranLocal);

  futureRemote.wait();
  ASSERT_TRUE(ranRemote);
}

TEST	(	FiberManager	,
		nestedFiberManagers
	)

Definition at line 1526 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), EXPECT_EQ, folly::fibers::getFiberManager(), folly::fibers::FiberManager::getFiberManagerUnsafe(), folly::EventBase::loopForever(), folly::fibers::runInMainContext(), and folly::EventBase::terminateLoopSoon().

                                        {
  folly::EventBase outerEvb;
  folly::EventBase innerEvb;

  getFiberManager(outerEvb).addTask([&]() {
    EXPECT_EQ(
        &getFiberManager(outerEvb), FiberManager::getFiberManagerUnsafe());

    runInMainContext([&]() {
      getFiberManager(innerEvb).addTask([&]() {
        EXPECT_EQ(
            &getFiberManager(innerEvb), FiberManager::getFiberManagerUnsafe());

        innerEvb.terminateLoopSoon();
      });

      innerEvb.loopForever();
    });

    EXPECT_EQ(
        &getFiberManager(outerEvb), FiberManager::getFiberManagerUnsafe());

    outerEvb.terminateLoopSoon();
  });

  outerEvb.loopForever();
}

TEST	(	FiberManager	,
		semaphore
	)

Definition at line 1554 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), counter, evb_, EXPECT_GE, EXPECT_LT, i, folly::fibers::FiberManager::loopController(), folly::EventBase::loopForever(), folly::fibers::Baton::post(), folly::fibers::Semaphore::signal(), folly::EventBase::terminateLoopSoon(), and folly::fibers::Semaphore::wait().

                              {
  static constexpr size_t kTasks = 10;
  static constexpr size_t kIterations = 10000;
  static constexpr size_t kNumTokens = 10;

  Semaphore sem(kNumTokens);
  int counterA = 0;
  int counterB = 0;

  auto task = [&sem](int& counter, folly::fibers::Baton& baton) {
    FiberManager manager(std::make_unique<EventBaseLoopController>());
    folly::EventBase evb;
    dynamic_cast<EventBaseLoopController&>(manager.loopController())
        .attachEventBase(evb);

    {
      std::shared_ptr<folly::EventBase> completionCounter(
          &evb, [](folly::EventBase* evb_) { evb_->terminateLoopSoon(); });

      for (size_t i = 0; i < kTasks; ++i) {
        manager.addTask([&, completionCounter]() {
          for (size_t j = 0; j < kIterations; ++j) {
            sem.wait();
            ++counter;
            sem.signal();
            --counter;

            EXPECT_LT(counter, kNumTokens);
            EXPECT_GE(counter, 0);
          }
        });
      }

      baton.wait();
    }
    evb.loopForever();
  };

  folly::fibers::Baton batonA;
  folly::fibers::Baton batonB;
  std::thread threadA([&] { task(counterA, batonA); });
  std::thread threadB([&] { task(counterB, batonB); });

  batonA.post();
  batonB.post();
  threadA.join();
  threadB.join();

  EXPECT_LT(counterA, kNumTokens);
  EXPECT_LT(counterB, kNumTokens);
  EXPECT_GE(counterA, 0);
  EXPECT_GE(counterB, 0);
}

TEST	(	FiberManager	,
		batchDispatchTest
	)

Definition at line 1625 of file FibersTest.cpp.

References folly::pushmi::executor, folly::fibers::getFiberManager(), i, folly::EventBase::loop(), and singleBatchDispatch().

                                      {
  folly::EventBase evb;
  auto& executor = getFiberManager(evb);

  // Launch multiple fibers with a single id.
  executor.add([&]() {
    int batchSize = 10;
    for (int i = 0; i < batchSize; i++) {
      executor.add(
          [=, &executor]() { singleBatchDispatch(executor, batchSize, i); });
    }
  });
  evb.loop();

  // Reuse the same BatchDispatcher to batch once again.
  executor.add([&]() {
    int batchSize = 10;
    for (int i = 0; i < batchSize; i++) {
      executor.add(
          [=, &executor]() { singleBatchDispatch(executor, batchSize, i); });
    }
  });
  evb.loop();
}

TEST	(	FiberManager	,
		doubleBatchDispatchTest
	)

Definition at line 1725 of file FibersTest.cpp.

References doubleBatchOuterDispatch(), folly::pushmi::executor, folly::fibers::getFiberManager(), i, and folly::EventBase::loop().

                                            {
  folly::EventBase evb;
  auto& executor = getFiberManager(evb);

  // Launch multiple fibers with a single id.
  executor.add([&]() {
    int totalNumberOfElements = 20;
    for (int i = 0; i < totalNumberOfElements; i++) {
      executor.add([=, &executor]() {
        doubleBatchOuterDispatch(executor, totalNumberOfElements, i);
      });
    }
  });
  evb.loop();
}

TEST	(	FiberManager	,
		batchDispatchExceptionHandlingTest
	)

Definition at line 1751 of file FibersTest.cpp.

References batchDispatchExceptionHandling(), folly::pushmi::executor, folly::fibers::getFiberManager(), i, and folly::EventBase::loop().

                                                       {
  folly::EventBase evb;
  auto& executor = getFiberManager(evb);

  // Launch multiple fibers with a single id.
  executor.add([&]() {
    int totalNumberOfElements = 5;
    for (int i = 0; i < totalNumberOfElements; i++) {
      executor.add(
          [=, &executor]() { batchDispatchExceptionHandling(executor, i); });
    }
  });
  evb.loop();
}

TEST	(	FiberManager	,
		ABD_Test
	)

Definition at line 1941 of file FibersTest.cpp.

References folly::fibers::createAtomicBatchDispatcher(), AtomicBatchDispatcherTesting::createJobs(), AtomicBatchDispatcherTesting::dispatchJobs(), folly::pushmi::executor, folly::gen::move, SET_UP_TEST_FUNC, AtomicBatchDispatcherTesting::userDispatchFunc(), and AtomicBatchDispatcherTesting::validateResults().

                             {
  SET_UP_TEST_FUNC;

  //
  // Testing AtomicBatchDispatcher with explicit call to commit()
  //
  dispatchFunc = userDispatchFunc;
  auto atomicBatchDispatcher =
      createAtomicBatchDispatcher(std::move(dispatchFunc));
  createJobs(atomicBatchDispatcher, jobs, COUNT);
  dispatchJobs(executor, jobs, results);
  atomicBatchDispatcher.commit();
  evb.loop();
  validateResults(results, COUNT);
}

TEST	(	FiberManager	,
		ABD_DispatcherDestroyedBeforeCallingCommit
	)

Definition at line 1957 of file FibersTest.cpp.

References folly::fibers::createAtomicBatchDispatcher(), AtomicBatchDispatcherTesting::createJobs(), AtomicBatchDispatcherTesting::dispatchJobs(), folly::pushmi::executor, folly::gen::move, SET_UP_TEST_FUNC, and AtomicBatchDispatcherTesting::userDispatchFunc().

                                                               {
  SET_UP_TEST_FUNC;

  //
  // Testing AtomicBatchDispatcher destroyed before calling commit.
  // Handles error cases for:
  // - User might have forgotten to add the call to commit() in the code
  // - An unexpected exception got thrown in user code before commit() is called
  //
  try {
    dispatchFunc = userDispatchFunc;
    auto atomicBatchDispatcher =
        createAtomicBatchDispatcher(std::move(dispatchFunc));
    createJobs(atomicBatchDispatcher, jobs, COUNT);
    dispatchJobs(executor, jobs, results);
    throw std::runtime_error(
        "Unexpected exception in user code before commit called");
    // atomicBatchDispatcher.commit();
  } catch (...) {
    /* User code handles the exception and does not exit process */
  }
  evb.loop();
  validateResults<ABDCommitNotCalledException>(results, COUNT);
}

TEST	(	FiberManager	,
		ABD_PreprocessingFailureTest
	)

Definition at line 1982 of file FibersTest.cpp.

References folly::fibers::createAtomicBatchDispatcher(), AtomicBatchDispatcherTesting::createJobs(), AtomicBatchDispatcherTesting::dispatchJobs(), folly::pushmi::executor, folly::gen::move, SET_UP_TEST_FUNC, and AtomicBatchDispatcherTesting::userDispatchFunc().

                                                 {
  SET_UP_TEST_FUNC;

  //
  // Testing preprocessing failure on a job throws
  //
  dispatchFunc = userDispatchFunc;
  auto atomicBatchDispatcher =
      createAtomicBatchDispatcher(std::move(dispatchFunc));
  createJobs(atomicBatchDispatcher, jobs, COUNT);
  dispatchJobs(executor, jobs, results, DispatchProblem::PreprocessThrows, 8);
  atomicBatchDispatcher.commit();
  evb.loop();
  validateResults<ABDTokenNotDispatchedException>(results, COUNT - 1);
}

TEST	(	FiberManager	,
		ABD_MultipleDispatchOnSameTokenErrorTest
	)

Definition at line 1998 of file FibersTest.cpp.

References folly::fibers::createAtomicBatchDispatcher(), AtomicBatchDispatcherTesting::createJobs(), AtomicBatchDispatcherTesting::dispatchJobs(), folly::pushmi::executor, folly::gen::move, SET_UP_TEST_FUNC, and AtomicBatchDispatcherTesting::userDispatchFunc().

                                                             {
  SET_UP_TEST_FUNC;

  //
  // Testing that calling dispatch more than once on the same token throws
  //
  dispatchFunc = userDispatchFunc;
  auto atomicBatchDispatcher =
      createAtomicBatchDispatcher(std::move(dispatchFunc));
  createJobs(atomicBatchDispatcher, jobs, COUNT);
  dispatchJobs(executor, jobs, results, DispatchProblem::DuplicateDispatch, 4);
  atomicBatchDispatcher.commit();
  evb.loop();
}

TEST	(	FiberManager	,
		ABD_GetTokenCalledAfterCommitTest
	)

Definition at line 2013 of file FibersTest.cpp.

References folly::fibers::createAtomicBatchDispatcher(), AtomicBatchDispatcherTesting::createJobs(), AtomicBatchDispatcherTesting::dispatchJobs(), folly::pushmi::executor, EXPECT_THROW, folly::gen::move, SET_UP_TEST_FUNC, AtomicBatchDispatcherTesting::userDispatchFunc(), and AtomicBatchDispatcherTesting::validateResults().

                                                      {
  SET_UP_TEST_FUNC;

  //
  // Testing that exception set on attempt to call getToken after commit called
  //
  dispatchFunc = userDispatchFunc;
  auto atomicBatchDispatcher =
      createAtomicBatchDispatcher(std::move(dispatchFunc));
  createJobs(atomicBatchDispatcher, jobs, COUNT);
  atomicBatchDispatcher.commit();
  EXPECT_THROW(atomicBatchDispatcher.getToken(), ABDUsageException);
  dispatchJobs(executor, jobs, results);
  EXPECT_THROW(atomicBatchDispatcher.getToken(), ABDUsageException);
  evb.loop();
  validateResults(results, COUNT);
  EXPECT_THROW(atomicBatchDispatcher.getToken(), ABDUsageException);
}

TEST	(	FiberManager	,
		ABD_UserProvidedBatchDispatchThrowsTest
	)

Definition at line 2032 of file FibersTest.cpp.

References folly::fibers::createAtomicBatchDispatcher(), AtomicBatchDispatcherTesting::createJobs(), AtomicBatchDispatcherTesting::dispatchJobs(), folly::pushmi::executor, folly::gen::move, SET_UP_TEST_FUNC, and AtomicBatchDispatcherTesting::userDispatchFunc().

                                                            {
  SET_UP_TEST_FUNC;

  //
  // Testing that exception is set if user provided batch dispatch throws
  //
  dispatchFunc = [](std::vector<ValueT>&& inputs) -> std::vector<ResultT> {
    (void)userDispatchFunc(std::move(inputs));
    throw std::runtime_error("Unexpected exception in user dispatch function");
  };
  auto atomicBatchDispatcher =
      createAtomicBatchDispatcher(std::move(dispatchFunc));
  createJobs(atomicBatchDispatcher, jobs, COUNT);
  dispatchJobs(executor, jobs, results);
  atomicBatchDispatcher.commit();
  evb.loop();
  validateResults<std::runtime_error>(results, COUNT);
}

TEST	(	FiberManager	,
		VirtualEventBase
	)

Definition at line 2051 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTaskRemote(), EXPECT_FALSE, EXPECT_TRUE, folly::ScopedEventBaseThread::getEventBase(), folly::fibers::getFiberManager(), folly::EventBase::getVirtualEventBase(), and folly::fibers::Baton::try_wait_for().

                                     {
  bool done1{false};
  bool done2{false};
  {
    folly::ScopedEventBaseThread thread;

    auto evb1 =
        std::make_unique<folly::VirtualEventBase>(*thread.getEventBase());
    auto& evb2 = thread.getEventBase()->getVirtualEventBase();

    getFiberManager(*evb1).addTaskRemote([&] {
      Baton baton;
      baton.try_wait_for(std::chrono::milliseconds{100});

      done1 = true;
    });

    getFiberManager(evb2).addTaskRemote([&] {
      Baton baton;
      baton.try_wait_for(std::chrono::milliseconds{200});

      done2 = true;
    });

    EXPECT_FALSE(done1);
    EXPECT_FALSE(done2);

    evb1.reset();
    EXPECT_TRUE(done1);
    EXPECT_FALSE(done2);
  }
  EXPECT_TRUE(done2);
}

TEST	(	TimedMutex	,
		ThreadsAndFibersDontDeadlock
	)

Definition at line 2085 of file FibersTest.cpp.

References b, EXPECT_EQ, folly::fibers::getFiberManager(), i, folly::fibers::TimedMutex::lock(), folly::EventBase::loop(), mutex, folly::fibers::Baton::try_wait_for(), and folly::fibers::TimedMutex::unlock().

                                               {
  folly::EventBase evb;
  auto& fm = getFiberManager(evb);
  TimedMutex mutex;
  std::thread testThread([&] {
    for (int i = 0; i < 100; i++) {
      mutex.lock();
      mutex.unlock();
      {
        Baton b;
        b.try_wait_for(std::chrono::milliseconds(1));
      }
    }
  });

  for (int numFibers = 0; numFibers < 100; numFibers++) {
    fm.addTask([&] {
      for (int i = 0; i < 20; i++) {
        mutex.lock();
        {
          Baton b;
          b.try_wait_for(std::chrono::milliseconds(1));
        }
        mutex.unlock();
        {
          Baton b;
          b.try_wait_for(std::chrono::milliseconds(1));
        }
      }
    });
  }

  evb.loop();
  EXPECT_EQ(0, fm.hasTasks());
  testThread.join();
}

TEST	(	TimedMutex	,
		ThreadFiberDeadlockOrder
	)

Definition at line 2122 of file FibersTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, folly::fibers::getFiberManager(), folly::fibers::TimedMutex::lock(), folly::EventBase::loopOnce(), mutex, folly::fibers::runInMainContext(), folly::fibers::TimedMutex::timed_lock(), and folly::fibers::TimedMutex::unlock().

                                           {
  folly::EventBase evb;
  auto& fm = getFiberManager(evb);
  TimedMutex mutex;

  mutex.lock();
  std::thread unlockThread([&] {
    /* sleep override */ std::this_thread::sleep_for(
        std::chrono::milliseconds{100});
    mutex.unlock();
  });

  fm.addTask([&] { std::lock_guard<TimedMutex> lg(mutex); });
  fm.addTask([&] {
    runInMainContext([&] {
      auto locked = mutex.timed_lock(std::chrono::seconds{1});
      EXPECT_TRUE(locked);
      if (locked) {
        mutex.unlock();
      }
    });
  });

  evb.loopOnce();
  EXPECT_EQ(0, fm.hasTasks());

  unlockThread.join();
}

TEST	(	TimedMutex	,
		ThreadFiberDeadlockRace
	)

Definition at line 2151 of file FibersTest.cpp.

References EXPECT_EQ, EXPECT_LT, EXPECT_NE, EXPECT_TRUE, folly::fibers::getFiberManager(), folly::fibers::TimedMutex::lock(), folly::EventBase::loopOnce(), mutex, folly::fibers::runInMainContext(), folly::fibers::TimedMutex::timed_lock(), and folly::fibers::TimedMutex::unlock().

                                          {
  folly::EventBase evb;
  auto& fm = getFiberManager(evb);
  TimedMutex mutex;

  mutex.lock();

  fm.addTask([&] {
    auto locked = mutex.timed_lock(std::chrono::seconds{1});
    EXPECT_TRUE(locked);
    if (locked) {
      mutex.unlock();
    }
  });
  fm.addTask([&] {
    mutex.unlock();
    runInMainContext([&] {
      auto locked = mutex.timed_lock(std::chrono::seconds{1});
      EXPECT_TRUE(locked);
      if (locked) {
        mutex.unlock();
      }
    });
  });

  evb.loopOnce();
  EXPECT_EQ(0, fm.hasTasks());
}

TEST	(	FiberManager	,
		highWaterMarkViaRecordStackEvery
	)

Test that we can properly track fiber stack usage, via recordStackEvery For ASAN builds, it is not recorded.

Definition at line 2202 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), b, f, i, folly::fibers::FiberManager::loopController(), folly::fibers::FiberManager::Options::recordStackEvery, s, and folly::fibers::FiberManager::stackHighWatermark().

                                                     {
  auto f = [] {
    folly::fibers::FiberManager::Options opts;
    opts.recordStackEvery = 1;

    FiberManager fm(std::make_unique<SimpleLoopController>(), opts);
    auto& loopController =
        dynamic_cast<SimpleLoopController&>(fm.loopController());

    static constexpr size_t n = 1000;
    int s = 0;
    fm.addTask([&]() {
      int b[n] = {0};
      for (size_t i = 0; i < n; ++i) {
        b[i] = i;
      }
      for (size_t i = 0; i + 1 < n; ++i) {
        s += b[i] * b[i + 1];
      }
    });

    (void)s;

    loopController.loop([&]() { loopController.stop(); });
    expectStackHighWatermark(n * sizeof(int), fm.stackHighWatermark());
  };
  std::thread(f).join();
}

TEST	(	FiberManager	,
		highWaterMarkViaRecordCurrentPosition
	)

Test that we can properly track fiber stack usage, via current position estimate. For ASAN builds, it is not recorded.

Definition at line 2235 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), b, f, i, folly::fibers::FiberManager::loopController(), folly::fibers::FiberManager::runInMainContext(), s, and folly::fibers::FiberManager::stackHighWatermark().

                                                          {
  auto f = [] {
    FiberManager fm(std::make_unique<SimpleLoopController>());
    auto& loopController =
        dynamic_cast<SimpleLoopController&>(fm.loopController());

    static constexpr size_t n = 1000;
    int s = 0;
    fm.addTask([&]() {
      int b[n] = {0};
      for (size_t i = 0; i < n; ++i) {
        b[i] = i;
      }
      for (size_t i = 0; i + 1 < n; ++i) {
        s += b[i] * b[i + 1];
      }
      // Calls preempt, which calls recordStackPosition.
      fm.runInMainContext([]() {});
    });

    (void)s;

    loopController.loop([&]() { loopController.stop(); });
    expectStackHighWatermark(n * sizeof(int), fm.stackHighWatermark());
  };
  std::thread(f).join();
}

template<typename Data >

void testFiberLocal

(

)

Definition at line 1163 of file FibersTest.cpp.

References folly::fibers::FiberManager::addTask(), folly::fibers::addTask(), folly::fibers::FiberManager::addTaskRemote(), folly::fibers::collectAny(), EXPECT_EQ, EXPECT_FALSE, folly::fibers::FiberManager::hasTasks(), folly::fibers::FiberManager::loopUntilNoReady(), tasks, and folly::value().

                      {
  FiberManager fm(LocalType<Data>(), std::make_unique<SimpleLoopController>());

  fm.addTask([]() {
    EXPECT_EQ(42, local<Data>().value);

    local<Data>().value = 43;

    addTask([]() {
      EXPECT_EQ(43, local<Data>().value);

      local<Data>().value = 44;

      addTask([]() { EXPECT_EQ(44, local<Data>().value); });
    });
  });

  fm.addTask([&]() {
    EXPECT_EQ(42, local<Data>().value);

    local<Data>().value = 43;

    fm.addTaskRemote([]() { EXPECT_EQ(43, local<Data>().value); });
  });

  fm.addTask([]() {
    EXPECT_EQ(42, local<Data>().value);
    local<Data>().value = 43;

    auto task = []() {
      EXPECT_EQ(43, local<Data>().value);
      local<Data>().value = 44;
    };
    std::vector<std::function<void()>> tasks{task};
    collectAny(tasks.begin(), tasks.end());

    EXPECT_EQ(43, local<Data>().value);
  });

  fm.loopUntilNoReady();
  EXPECT_FALSE(fm.hasTasks());
}