ExceptionWrapperBenchmark.cpp File Reference

#include <folly/ExceptionWrapper.h>
#include <atomic>
#include <exception>
#include <stdexcept>
#include <thread>
#include <vector>
#include <folly/Benchmark.h>
#include <folly/portability/GFlags.h>

Go to the source code of this file.

Functions
	DEFINE_int32 (num_threads, 32,"Number of threads to run concurrency ""benchmarks")
	BENCHMARK (exception_ptr_create_and_test, iters)
	BENCHMARK_RELATIVE (exception_wrapper_create_and_test, iters)
	BENCHMARK_DRAW_LINE ()
	BENCHMARK (exception_ptr_create_and_test_concurrent, iters)
	BENCHMARK_RELATIVE (exception_wrapper_create_and_test_concurrent, iters)
	BENCHMARK (exception_ptr_create_and_throw, iters)
	BENCHMARK_RELATIVE (exception_wrapper_create_and_throw, iters)
	BENCHMARK_RELATIVE (exception_wrapper_create_and_cast, iters)
	BENCHMARK (exception_ptr_create_and_throw_concurrent, iters)
	BENCHMARK_RELATIVE (exception_wrapper_create_and_throw_concurrent, iters)
	BENCHMARK_RELATIVE (exception_wrapper_create_and_cast_concurrent, iters)
int	main (int argc, char *argv[])

Function Documentation

BENCHMARK	(	exception_ptr_create_and_test	,
		iters
	)

Definition at line 38 of file ExceptionWrapperBenchmark.cpp.

References b, folly::doNotOptimizeAway(), and i.

                                                {
  std::runtime_error e("payload");
  for (size_t i = 0; i < iters; ++i) {
    auto ep = std::make_exception_ptr(e);
    bool b = static_cast<bool>(ep);
    folly::doNotOptimizeAway(b);
  }
}

BENCHMARK	(	exception_ptr_create_and_test_concurrent	,
		iters
	)

Definition at line 58 of file ExceptionWrapperBenchmark.cpp.

References b, BENCHMARK_SUSPEND, folly::doNotOptimizeAway(), i, folly::pushmi::detail::t, and threads.

                                                           {
  std::atomic<bool> go(false);
  std::vector<std::thread> threads;
  BENCHMARK_SUSPEND {
    for (int t = 0; t < FLAGS_num_threads; ++t) {
      threads.emplace_back([&go, iters] {
        while (!go) {
        }
        std::runtime_error e("payload");
        for (size_t i = 0; i < iters; ++i) {
          auto ep = std::make_exception_ptr(e);
          bool b = static_cast<bool>(ep);
          folly::doNotOptimizeAway(b);
        }
      });
    }
  }
  go.store(true);
  for (auto& t : threads) {
    t.join();
  }
}

BENCHMARK	(	exception_ptr_create_and_throw	,
		iters
	)

Definition at line 111 of file ExceptionWrapperBenchmark.cpp.

References i.

                                                 {
  std::runtime_error e("payload");
  for (size_t i = 0; i < iters; ++i) {
    auto ep = std::make_exception_ptr(e);
    try {
      std::rethrow_exception(ep);
    } catch (std::runtime_error&) {
    }
  }
}

BENCHMARK	(	exception_ptr_create_and_throw_concurrent	,
		iters
	)

Definition at line 144 of file ExceptionWrapperBenchmark.cpp.

References BENCHMARK_SUSPEND, i, folly::pushmi::detail::t, and threads.

                                                            {
  std::atomic<bool> go(false);
  std::vector<std::thread> threads;
  BENCHMARK_SUSPEND {
    for (int t = 0; t < FLAGS_num_threads; ++t) {
      threads.emplace_back([&go, iters] {
        while (!go) {
        }
        std::runtime_error e("payload");
        for (size_t i = 0; i < iters; ++i) {
          auto ep = std::make_exception_ptr(e);
          try {
            std::rethrow_exception(ep);
          } catch (std::runtime_error&) {
          }
        }
      });
    }
  }
  go.store(true);
  for (auto& t : threads) {
    t.join();
  }
}

BENCHMARK_DRAW_LINE

(

)

Referenced by BENCHMARK_RELATIVE().

BENCHMARK_RELATIVE	(	exception_wrapper_create_and_test	,
		iters
	)

Definition at line 47 of file ExceptionWrapperBenchmark.cpp.

References b, BENCHMARK_DRAW_LINE(), folly::doNotOptimizeAway(), and i.

                                                             {
  std::runtime_error e("payload");
  for (size_t i = 0; i < iters; ++i) {
    auto ew = folly::make_exception_wrapper<std::runtime_error>(e);
    bool b = static_cast<bool>(ew);
    folly::doNotOptimizeAway(b);
  }
}

BENCHMARK_RELATIVE	(	exception_wrapper_create_and_test_concurrent	,
		iters
	)

Definition at line 81 of file ExceptionWrapperBenchmark.cpp.

References b, BENCHMARK_DRAW_LINE(), BENCHMARK_SUSPEND, folly::doNotOptimizeAway(), i, folly::pushmi::detail::t, and threads.

                                                                        {
  std::atomic<bool> go(false);
  std::vector<std::thread> threads;
  BENCHMARK_SUSPEND {
    for (int t = 0; t < FLAGS_num_threads; ++t) {
      threads.emplace_back([&go, iters] {
        while (!go) {
        }
        std::runtime_error e("payload");
        for (size_t i = 0; i < iters; ++i) {
          auto ew = folly::make_exception_wrapper<std::runtime_error>(e);
          bool b = static_cast<bool>(ew);
          folly::doNotOptimizeAway(b);
        }
      });
    }
  }
  go.store(true);
  for (auto& t : threads) {
    t.join();
  }
}

BENCHMARK_RELATIVE	(	exception_wrapper_create_and_throw	,
		iters
	)

Definition at line 122 of file ExceptionWrapperBenchmark.cpp.

References i.

                                                              {
  std::runtime_error e("payload");
  for (size_t i = 0; i < iters; ++i) {
    auto ew = folly::make_exception_wrapper<std::runtime_error>(e);
    try {
      ew.throw_exception();
    } catch (std::runtime_error&) {
    }
  }
}

BENCHMARK_RELATIVE	(	exception_wrapper_create_and_cast	,
		iters
	)

Definition at line 133 of file ExceptionWrapperBenchmark.cpp.

References b, BENCHMARK_DRAW_LINE(), folly::doNotOptimizeAway(), and i.

                                                             {
  std::runtime_error e("payload");
  for (size_t i = 0; i < iters; ++i) {
    auto ew = folly::make_exception_wrapper<std::runtime_error>(e);
    bool b = ew.is_compatible_with<std::runtime_error>();
    folly::doNotOptimizeAway(b);
  }
}

BENCHMARK_RELATIVE	(	exception_wrapper_create_and_throw_concurrent	,
		iters
	)

Definition at line 169 of file ExceptionWrapperBenchmark.cpp.

References BENCHMARK_SUSPEND, i, folly::pushmi::detail::t, and threads.

                                                                         {
  std::atomic<bool> go(false);
  std::vector<std::thread> threads;
  BENCHMARK_SUSPEND {
    for (int t = 0; t < FLAGS_num_threads; ++t) {
      threads.emplace_back([&go, iters] {
        while (!go) {
        }
        std::runtime_error e("payload");
        for (size_t i = 0; i < iters; ++i) {
          auto ew = folly::make_exception_wrapper<std::runtime_error>(e);
          try {
            ew.throw_exception();
          } catch (std::runtime_error&) {
          }
        }
      });
    }
  }
  go.store(true);
  for (auto& t : threads) {
    t.join();
  }
}

BENCHMARK_RELATIVE	(	exception_wrapper_create_and_cast_concurrent	,
		iters
	)

Definition at line 194 of file ExceptionWrapperBenchmark.cpp.

References b, BENCHMARK_SUSPEND, folly::doNotOptimizeAway(), i, folly::pushmi::detail::t, and threads.

                                                                        {
  std::atomic<bool> go(false);
  std::vector<std::thread> threads;
  BENCHMARK_SUSPEND {
    for (int t = 0; t < FLAGS_num_threads; ++t) {
      threads.emplace_back([&go, iters] {
        while (!go) {
        }
        std::runtime_error e("payload");
        for (size_t i = 0; i < iters; ++i) {
          auto ew = folly::make_exception_wrapper<std::runtime_error>(e);
          bool b = ew.is_compatible_with<std::runtime_error>();
          folly::doNotOptimizeAway(b);
        }
      });
    }
  }
  go.store(true);
  for (auto& t : threads) {
    t.join();
  }
}

DEFINE_int32	(	num_threads	,
		32	,
		"Number of threads to run concurrency ""benchmarks"
	)

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 217 of file ExceptionWrapperBenchmark.cpp.

References folly::runBenchmarks().

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