Benchmark.cpp File Reference

#include <folly/Benchmark.h>
#include <folly/executors/InlineExecutor.h>
#include <folly/futures/Future.h>
#include <folly/futures/Promise.h>
#include <folly/portability/GFlags.h>
#include <folly/portability/Semaphore.h>
#include <folly/synchronization/Baton.h>
#include <vector>

Go to the source code of this file.

Classes
struct	Blob< S >

Functions
	BENCHMARK (constantFuture)
	BENCHMARK_RELATIVE (promiseAndFuture)
	BENCHMARK_RELATIVE (withThen)
	BENCHMARK_DRAW_LINE ()
	BENCHMARK (oneThen)
	BENCHMARK_RELATIVE (twoThens)
	BENCHMARK_RELATIVE (fourThens)
	BENCHMARK_RELATIVE (hundredThens)
	BENCHMARK (no_contention)
	BENCHMARK_RELATIVE (contention)
void	throwAndCatchImpl ()
void	throwAndCatchWrappedImpl ()
void	throwWrappedAndCatchImpl ()
void	throwWrappedAndCatchWrappedImpl ()
void	contend (void(*func)())
	BENCHMARK (throwAndCatch)
	BENCHMARK_RELATIVE (throwAndCatchWrapped)
	BENCHMARK_RELATIVE (throwWrappedAndCatch)
	BENCHMARK_RELATIVE (throwWrappedAndCatchWrapped)
	BENCHMARK (throwAndCatchContended)
	BENCHMARK_RELATIVE (throwAndCatchWrappedContended)
	BENCHMARK_RELATIVE (throwWrappedAndCatchContended)
	BENCHMARK_RELATIVE (throwWrappedAndCatchWrappedContended)
	BENCHMARK (lvalue_get)
	BENCHMARK_RELATIVE (rvalue_get)
template<class T >
Future< T >	fGen ()
template<class T >
std::vector< Future< T > >	fsGen ()
template<class T >
void	complexBenchmark ()
	BENCHMARK (complexUnit)
	BENCHMARK_RELATIVE (complexBlob4)
	BENCHMARK_RELATIVE (complexBlob8)
	BENCHMARK_RELATIVE (complexBlob64)
	BENCHMARK_RELATIVE (complexBlob128)
	BENCHMARK_RELATIVE (complexBlob256)
	BENCHMARK_RELATIVE (complexBlob512)
	BENCHMARK_RELATIVE (complexBlob1024)
	BENCHMARK_RELATIVE (complexBlob2048)
	BENCHMARK_RELATIVE (complexBlob4096)
int	main (int argc, char **argv)

Variables
InlineExecutor	exe

Function Documentation

BENCHMARK

(

constantFuture

)

Definition at line 45 of file Benchmark.cpp.

References folly::makeFuture().

                          {
  makeFuture(42);
}

BENCHMARK

(

oneThen

)

Definition at line 66 of file Benchmark.cpp.

                   {
  someThens(1);
}

BENCHMARK

(

no_contention

)

Definition at line 90 of file Benchmark.cpp.

References BENCHMARK_SUSPEND, f, folly::gen::move, folly::Baton< MayBlock, Atom >::post(), and folly::Baton< MayBlock, Atom >::wait().

                         {
  std::vector<Promise<int>> promises(10000);
  std::vector<Future<int>> futures;
  std::thread producer, consumer;

  BENCHMARK_SUSPEND {
    folly::Baton<> b1, b2;
    for (auto& p : promises) {
      futures.push_back(p.getFuture());
    }

    consumer = std::thread([&] {
      b1.post();
      for (auto& f : futures) {
        std::move(f).then(incr<int>);
      }
    });
    consumer.join();

    producer = std::thread([&] {
      b2.post();
      for (auto& p : promises) {
        p.setValue(42);
      }
    });

    b1.wait();
    b2.wait();
  }

  // The only thing we are measuring is how long fulfill + callbacks take
  producer.join();
}

BENCHMARK

(

throwAndCatch

)

Definition at line 265 of file Benchmark.cpp.

References throwAndCatchImpl().

                         {
  throwAndCatchImpl();
}

BENCHMARK

(

throwAndCatchContended

)

Definition at line 283 of file Benchmark.cpp.

References contend(), and throwAndCatchImpl().

                                  {
  contend(throwAndCatchImpl);
}

BENCHMARK

(

lvalue_get

)

Definition at line 317 of file Benchmark.cpp.

References folly::BenchmarkSuspender::dismissing(), folly::doNotOptimizeAway(), folly::makeFuture(), folly::gen::move, string, and folly::Optional< Value >::value().

                      {
  BenchmarkSuspender suspender;
  Optional<Future<Bulky>> future;
  future = makeFuture(Bulky("Hello"));
  suspender.dismissing([&] {
    std::string message = std::move(future.value()).get().message();
    doNotOptimizeAway(message);
  });
}

BENCHMARK

(

complexUnit

)

Definition at line 377 of file Benchmark.cpp.

                       {
  complexBenchmark<Unit>();
}

BENCHMARK_DRAW_LINE

(

)

BENCHMARK_RELATIVE

(

promiseAndFuture

)

Definition at line 49 of file Benchmark.cpp.

References f, folly::Promise< T >::getFuture(), folly::Promise< T >::setValue(), and folly::futures::detail::FutureBase< T >::value().

                                     {
  Promise<int> p;
  Future<int> f = p.getFuture();
  p.setValue(42);
  f.value();
}

BENCHMARK_RELATIVE

(

withThen

)

Definition at line 56 of file Benchmark.cpp.

References folly::BENCHMARK_DRAW_LINE(), f, folly::Promise< T >::getFuture(), folly::Promise< T >::setValue(), and folly::futures::detail::FutureBase< T >::value().

                             {
  Promise<int> p;
  Future<int> f = p.getFuture().then(incr<int>);
  p.setValue(42);
  f.value();
}

BENCHMARK_RELATIVE

(

twoThens

)

Definition at line 71 of file Benchmark.cpp.

                             {
  someThens(2);
}

BENCHMARK_RELATIVE

(

fourThens

)

Definition at line 76 of file Benchmark.cpp.

                              {
  someThens(4);
}

BENCHMARK_RELATIVE

(

hundredThens

)

Definition at line 81 of file Benchmark.cpp.

References folly::BENCHMARK_DRAW_LINE().

                                 {
  someThens(100);
}

BENCHMARK_RELATIVE

(

contention

)

Definition at line 124 of file Benchmark.cpp.

References folly::BENCHMARK_DRAW_LINE(), BENCHMARK_SUSPEND, f, folly::gen::move, folly::Baton< MayBlock, Atom >::post(), and folly::Baton< MayBlock, Atom >::wait().

                               {
  std::vector<Promise<int>> promises(10000);
  std::vector<Future<int>> futures;
  std::thread producer, consumer;
  sem_t sem;
  sem_init(&sem, 0, 0);

  BENCHMARK_SUSPEND {
    folly::Baton<> b1, b2;
    for (auto& p : promises) {
      futures.push_back(p.getFuture());
    }

    consumer = std::thread([&] {
      b1.post();
      for (auto& f : futures) {
        sem_wait(&sem);
        std::move(f).then(incr<int>);
      }
    });

    producer = std::thread([&] {
      b2.post();
      for (auto& p : promises) {
        sem_post(&sem);
        p.setValue(42);
      }
    });

    b1.wait();
    b2.wait();
  }

  // The astute reader will notice that we're not *precisely* comparing apples
  // to apples here. Well, maybe it's like comparing Granny Smith to
  // Braeburn or something. In the serial version, we waited for the futures
  // to be all set up, but here we are probably still doing that work
  // (although in parallel). But even though there is more work (on the order
  // of 2x), it is being done by two threads. Hopefully most of the difference
  // we see is due to lock contention and not false parallelism.
  //
  // Be warned that if the box is under heavy load, this will greatly skew
  // these results (scheduling overhead will begin to dwarf lock contention).
  // I'm not sure but I'd guess in Windtunnel this will mean large variance,
  // because I expect they load the boxes as much as they can?
  consumer.join();
  producer.join();
}

BENCHMARK_RELATIVE

(

throwAndCatchWrapped

)

Definition at line 269 of file Benchmark.cpp.

References throwAndCatchWrappedImpl().

                                         {
  throwAndCatchWrappedImpl();
}

BENCHMARK_RELATIVE

(

throwWrappedAndCatch

)

Definition at line 273 of file Benchmark.cpp.

References throwWrappedAndCatchImpl().

                                         {
  throwWrappedAndCatchImpl();
}

BENCHMARK_RELATIVE

(

throwWrappedAndCatchWrapped

)

Definition at line 277 of file Benchmark.cpp.

References folly::BENCHMARK_DRAW_LINE(), and throwWrappedAndCatchWrappedImpl().

                                                {
  throwWrappedAndCatchWrappedImpl();
}

BENCHMARK_RELATIVE

(

throwAndCatchWrappedContended

)

Definition at line 287 of file Benchmark.cpp.

References contend(), and throwAndCatchWrappedImpl().

                                                  {
  contend(throwAndCatchWrappedImpl);
}

BENCHMARK_RELATIVE

(

throwWrappedAndCatchContended

)

Definition at line 291 of file Benchmark.cpp.

References contend(), and throwWrappedAndCatchImpl().

                                                  {
  contend(throwWrappedAndCatchImpl);
}

BENCHMARK_RELATIVE

(

throwWrappedAndCatchWrappedContended

)

Definition at line 295 of file Benchmark.cpp.

References folly::BENCHMARK_DRAW_LINE(), contend(), message, folly::gen::move, string, and throwWrappedAndCatchWrappedImpl().

                                                         {
  contend(throwWrappedAndCatchWrappedImpl);
}

BENCHMARK_RELATIVE

(

rvalue_get

)

Definition at line 327 of file Benchmark.cpp.

References folly::BenchmarkSuspender::dismissing(), folly::doNotOptimizeAway(), folly::makeFuture(), folly::gen::move, string, and folly::Optional< Value >::value().

                               {
  BenchmarkSuspender suspender;
  Optional<Future<Bulky>> future;
  future = makeFuture(Bulky("Hello"));
  suspender.dismissing([&] {
    std::string message = std::move(future.value()).get().message();
    doNotOptimizeAway(message);
  });
}

BENCHMARK_RELATIVE

(

complexBlob4

)

Definition at line 381 of file Benchmark.cpp.

                                 {
  complexBenchmark<Blob<4>>();
}

BENCHMARK_RELATIVE

(

complexBlob8

)

Definition at line 385 of file Benchmark.cpp.

                                 {
  complexBenchmark<Blob<8>>();
}

BENCHMARK_RELATIVE

(

complexBlob64

)

Definition at line 389 of file Benchmark.cpp.

                                  {
  complexBenchmark<Blob<64>>();
}

BENCHMARK_RELATIVE

(

complexBlob128

)

Definition at line 393 of file Benchmark.cpp.

                                   {
  complexBenchmark<Blob<128>>();
}

BENCHMARK_RELATIVE

(

complexBlob256

)

Definition at line 397 of file Benchmark.cpp.

                                   {
  complexBenchmark<Blob<256>>();
}

BENCHMARK_RELATIVE

(

complexBlob512

)

Definition at line 401 of file Benchmark.cpp.

                                   {
  complexBenchmark<Blob<512>>();
}

BENCHMARK_RELATIVE

(

complexBlob1024

)

Definition at line 405 of file Benchmark.cpp.

                                    {
  complexBenchmark<Blob<1024>>();
}

BENCHMARK_RELATIVE

(

complexBlob2048

)

Definition at line 409 of file Benchmark.cpp.

                                    {
  complexBenchmark<Blob<2048>>();
}

BENCHMARK_RELATIVE

(

complexBlob4096

)

Definition at line 413 of file Benchmark.cpp.

                                    {
  complexBenchmark<Blob<4096>>();
}

template<class T >

void complexBenchmark

(

)

Definition at line 362 of file Benchmark.cpp.

References folly::BENCHMARK_DRAW_LINE(), folly::collect(), folly::collectAll(), folly::collectAny(), folly::makeFuture(), folly::futures::map(), folly::pushmi::detail::t, and folly::T.

                        {
  collect(fsGen<T>());
  collectAll(fsGen<T>());
  collectAny(fsGen<T>());
  futures::map(fsGen<T>(), [](const T& t) { return t; });
  futures::map(fsGen<T>(), [](const T& t) { return makeFuture(T(t)); });
}

void contend

(

void(*)()

func

)

Definition at line 241 of file Benchmark.cpp.

References folly::BenchmarkSuspender::dismiss(), i, folly::BenchmarkSuspender::rehire(), s, folly::pushmi::detail::t, and threads.

Referenced by BENCHMARK(), and BENCHMARK_RELATIVE().

                             {
  folly::BenchmarkSuspender s;
  const int N = 100;
  const int iters = 1000;
  pthread_barrier_t barrier;
  pthread_barrier_init(&barrier, nullptr, N + 1);
  std::vector<std::thread> threads;
  for (int i = 0; i < N; i++) {
    threads.push_back(std::thread([&]() {
      pthread_barrier_wait(&barrier);
      for (int j = 0; j < iters; j++) {
        func();
      }
    }));
  }
  pthread_barrier_wait(&barrier);
  s.dismiss();
  for (auto& t : threads) {
    t.join();
  }
  s.rehire();
  pthread_barrier_destroy(&barrier);
}

template<class T >

Future<T> fGen

(

)

Definition at line 340 of file Benchmark.cpp.

References f, folly::Promise< T >::getFuture(), folly::makeFuture(), folly::gen::move, folly::Promise< T >::setValue(), folly::pushmi::detail::t, folly::T, and folly::via().

                 {
  Promise<T> p;
  auto f = p.getFuture()
               .then([](T&& t) { return std::move(t); })
               .then([](T&& t) { return makeFuture(std::move(t)); })
               .via(&exe)
               .then([](T&& t) { return std::move(t); })
               .then([](T&& t) { return makeFuture(std::move(t)); });
  p.setValue(T());
  return f;
}

template<class T >

std::vector<Future<T> > fsGen

(

)

Definition at line 353 of file Benchmark.cpp.

References i.

                             {
  std::vector<Future<T>> fs;
  for (auto i = 0; i < 10; i++) {
    fs.push_back(fGen<T>());
  }
  return fs;
}

int main	(	int	argc,
		char **	argv
	)

Definition at line 417 of file Benchmark.cpp.

References folly::runBenchmarks().

                                {
  gflags::ParseCommandLineFlags(&argc, &argv, true);
  folly::runBenchmarks();
  return 0;
}

void throwAndCatchImpl

(

)

Definition at line 176 of file Benchmark.cpp.

References folly::makeFuture(), and folly::pushmi::detail::t.

Referenced by BENCHMARK().

                         {
  makeFuture()
      .then([](Try<Unit>&&) { throw std::runtime_error("oh no"); })
      .then([](Try<Unit>&& t) {
        try {
          t.value();
        } catch (const std::runtime_error& e) {
          // ...
          return;
        }
        CHECK(false);
      });
}

void throwAndCatchWrappedImpl

(

)

Definition at line 196 of file Benchmark.cpp.

References folly::makeFuture(), and folly::pushmi::detail::t.

Referenced by BENCHMARK_RELATIVE().

                                {
  makeFuture()
      .then([](Try<Unit>&&) { throw std::runtime_error("oh no"); })
      .then([](Try<Unit>&& t) {
        auto caught = t.withException<std::runtime_error>(
            [](const std::runtime_error& /* e */) {
              // ...
            });
        CHECK(caught);
      });
}

void throwWrappedAndCatchImpl

(

)

Definition at line 209 of file Benchmark.cpp.

References folly::makeFuture(), and folly::pushmi::detail::t.

Referenced by BENCHMARK_RELATIVE().

                                {
  makeFuture()
      .then([](Try<Unit>&&) {
        return makeFuture<Unit>(std::runtime_error("oh no"));
      })
      .then([](Try<Unit>&& t) {
        try {
          t.value();
        } catch (const std::runtime_error& e) {
          // ...
          return;
        }
        CHECK(false);
      });
}

void throwWrappedAndCatchWrappedImpl

(

)

Definition at line 226 of file Benchmark.cpp.

References folly::makeFuture(), and folly::pushmi::detail::t.

Referenced by BENCHMARK_RELATIVE().

                                       {
  makeFuture()
      .then([](Try<Unit>&&) {
        return makeFuture<Unit>(std::runtime_error("oh no"));
      })
      .then([](Try<Unit>&& t) {
        auto caught = t.withException<std::runtime_error>(
            [](const std::runtime_error& /* e */) {
              // ...
            });
        CHECK(caught);
      });
}

Variable Documentation

InlineExecutor exe

Definition at line 337 of file Benchmark.cpp.

Referenced by folly::futures::detail::convertFuture(), getTracepointArguments(), proxygen::HTTPServer::start(), TEST(), and folly::Future< T >::within().