FlatCombiningBenchmark.cpp File Reference

#include <folly/Benchmark.h>
#include <folly/experimental/flat_combining/test/FlatCombiningTestHelpers.h>
#include <folly/portability/GTest.h>
#include <glog/logging.h>

Go to the source code of this file.

Functions
	DEFINE_bool (direct, false,"run direct measurement")
	DEFINE_int32 (reps, 10,"number of reps")
	DEFINE_int32 (ops, 100000,"number of operations per rep")
	DEFINE_int32 (lines, 5,"number of cache lines accessed per operation")
	DEFINE_int32 (numRecs, 8,"number of records")
	DEFINE_int32 (work, 1000,"amount of unrelated work per operation")
	BENCHMARK (no_combining_base, iters)
	BENCHMARK_RELATIVE (no_combining_dup, iters)
	BENCHMARK_DRAW_LINE ()
	BENCHMARK_RELATIVE (combining_dedicated_notc_sync, iters)
	BENCHMARK_RELATIVE (combining_dedicated_notc_sync_dup, iters)
	BENCHMARK_RELATIVE (combining_dedicated_notc_async, iters)
	BENCHMARK_RELATIVE (combining_dedicated_notc_async_dup, iters)
	BENCHMARK_RELATIVE (combining_dedicated_tc_sync, iters)
	BENCHMARK_RELATIVE (combining_dedicated_tc_sync_dup, iters)
	BENCHMARK_RELATIVE (combining_dedicated_tc_async, iters)
	BENCHMARK_RELATIVE (combining_dedicated_tc_async_dup, iters)
	BENCHMARK_RELATIVE (combining_no_dedicated_notc_sync, iters)
	BENCHMARK_RELATIVE (combining_no_dedicated_notc_sync_dup, iters)
	BENCHMARK_RELATIVE (combining_no_dedicated_notc_async, iters)
	BENCHMARK_RELATIVE (combining_no_dedicated_notc_async_dup, iters)
	BENCHMARK_RELATIVE (combining_no_dedicated_tc_sync, iters)
	BENCHMARK_RELATIVE (combining_no_dedicated_tc_sync_dup, iters)
	BENCHMARK_RELATIVE (combining_no_dedicated_tc_async, iters)
	BENCHMARK_RELATIVE (combining_no_dedicated_tc_async_dup, iters)
void	benchmarkSetup ()
	TEST (FlatCombining, folly_benchmark)
static uint64_t	test (std::string name, bool fc_, bool dedicated_, bool tc_, bool syncops_, uint64_t base)
	TEST (FlatCombining, direct_measurement)

Variables
static std::vector< int >	nthr = {1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64}
static int	nthreads
static bool	fc
static bool	simple
static bool	dedicated
static bool	tc
static bool	syncops

Function Documentation

BENCHMARK	(	no_combining_base	,
		iters
	)

Definition at line 43 of file FlatCombiningBenchmark.cpp.

References dedicated, fc, nthreads, folly::test::run_test(), simple, syncops, and tc.

                                    {
  fc = false;
  dedicated = false;
  tc = false;
  syncops = false;
  run_test(
      nthreads,
      FLAGS_lines,
      FLAGS_numRecs,
      FLAGS_work,
      iters,
      fc,
      simple,
      dedicated,
      tc,
      syncops);
}

BENCHMARK_DRAW_LINE

(

)

BENCHMARK_RELATIVE	(	no_combining_dup	,
		iters
	)

Definition at line 61 of file FlatCombiningBenchmark.cpp.

References folly::BENCHMARK_DRAW_LINE(), dedicated, fc, nthreads, folly::test::run_test(), simple, syncops, and tc.

                                            {
  run_test(
      nthreads,
      FLAGS_lines,
      FLAGS_numRecs,
      FLAGS_work,
      iters,
      fc,
      simple,
      dedicated,
      tc,
      syncops);
}

BENCHMARK_RELATIVE	(	combining_dedicated_notc_sync	,
		iters
	)

Definition at line 80 of file FlatCombiningBenchmark.cpp.

References dedicated, fc, nthreads, folly::test::run_test(), simple, syncops, and tc.

                                                         {
  fc = true;
  dedicated = true;
  tc = false;
  syncops = true;
  run_test(
      nthreads,
      FLAGS_lines,
      FLAGS_numRecs,
      FLAGS_work,
      iters,
      fc,
      simple,
      dedicated,
      tc,
      syncops);
}

BENCHMARK_RELATIVE	(	combining_dedicated_notc_sync_dup	,
		iters
	)

Definition at line 98 of file FlatCombiningBenchmark.cpp.

References folly::BENCHMARK_DRAW_LINE(), dedicated, fc, nthreads, folly::test::run_test(), simple, syncops, and tc.

                                                             {
  run_test(
      nthreads,
      FLAGS_lines,
      FLAGS_numRecs,
      FLAGS_work,
      iters,
      fc,
      simple,
      dedicated,
      tc,
      syncops);
}

BENCHMARK_RELATIVE	(	combining_dedicated_notc_async	,
		iters
	)

Definition at line 114 of file FlatCombiningBenchmark.cpp.

References dedicated, fc, nthreads, folly::test::run_test(), simple, syncops, and tc.

                                                          {
  syncops = false;
  run_test(
      nthreads,
      FLAGS_lines,
      FLAGS_numRecs,
      FLAGS_work,
      iters,
      fc,
      simple,
      dedicated,
      tc,
      syncops);
}

BENCHMARK_RELATIVE	(	combining_dedicated_notc_async_dup	,
		iters
	)

Definition at line 129 of file FlatCombiningBenchmark.cpp.

References folly::BENCHMARK_DRAW_LINE(), dedicated, fc, nthreads, folly::test::run_test(), simple, syncops, and tc.

                                                              {
  run_test(
      nthreads,
      FLAGS_lines,
      FLAGS_numRecs,
      FLAGS_work,
      iters,
      fc,
      simple,
      dedicated,
      tc,
      syncops);
}

BENCHMARK_RELATIVE	(	combining_dedicated_tc_sync	,
		iters
	)

Definition at line 145 of file FlatCombiningBenchmark.cpp.

References dedicated, fc, nthreads, folly::test::run_test(), simple, syncops, and tc.

                                                       {
  tc = true;
  syncops = true;
  run_test(
      nthreads,
      FLAGS_lines,
      FLAGS_numRecs,
      FLAGS_work,
      iters,
      fc,
      simple,
      dedicated,
      tc,
      syncops);
}

BENCHMARK_RELATIVE	(	combining_dedicated_tc_sync_dup	,
		iters
	)

Definition at line 161 of file FlatCombiningBenchmark.cpp.

References folly::BENCHMARK_DRAW_LINE(), dedicated, fc, nthreads, folly::test::run_test(), simple, syncops, and tc.

                                                           {
  run_test(
      nthreads,
      FLAGS_lines,
      FLAGS_numRecs,
      FLAGS_work,
      iters,
      fc,
      simple,
      dedicated,
      tc,
      syncops);
}

BENCHMARK_RELATIVE	(	combining_dedicated_tc_async	,
		iters
	)

Definition at line 177 of file FlatCombiningBenchmark.cpp.

References dedicated, fc, nthreads, folly::test::run_test(), simple, syncops, and tc.

                                                        {
  tc = true;
  syncops = false;
  run_test(
      nthreads,
      FLAGS_lines,
      FLAGS_numRecs,
      FLAGS_work,
      iters,
      fc,
      simple,
      dedicated,
      tc,
      syncops);
}

BENCHMARK_RELATIVE	(	combining_dedicated_tc_async_dup	,
		iters
	)

Definition at line 193 of file FlatCombiningBenchmark.cpp.

References folly::BENCHMARK_DRAW_LINE(), dedicated, fc, nthreads, folly::test::run_test(), simple, syncops, and tc.

                                                            {
  run_test(
      nthreads,
      FLAGS_lines,
      FLAGS_numRecs,
      FLAGS_work,
      iters,
      fc,
      simple,
      dedicated,
      tc,
      syncops);
}

BENCHMARK_RELATIVE	(	combining_no_dedicated_notc_sync	,
		iters
	)

Definition at line 213 of file FlatCombiningBenchmark.cpp.

References dedicated, fc, nthreads, folly::test::run_test(), simple, syncops, and tc.

                                                            {
  dedicated = false;
  tc = false;
  syncops = true;
  run_test(
      nthreads,
      FLAGS_lines,
      FLAGS_numRecs,
      FLAGS_work,
      iters,
      fc,
      simple,
      dedicated,
      tc,
      syncops);
}

BENCHMARK_RELATIVE	(	combining_no_dedicated_notc_sync_dup	,
		iters
	)

Definition at line 230 of file FlatCombiningBenchmark.cpp.

References folly::BENCHMARK_DRAW_LINE(), dedicated, fc, nthreads, folly::test::run_test(), simple, syncops, and tc.

                                                                {
  run_test(
      nthreads,
      FLAGS_lines,
      FLAGS_numRecs,
      FLAGS_work,
      iters,
      fc,
      simple,
      dedicated,
      tc,
      syncops);
}

BENCHMARK_RELATIVE	(	combining_no_dedicated_notc_async	,
		iters
	)

Definition at line 246 of file FlatCombiningBenchmark.cpp.

References dedicated, fc, nthreads, folly::test::run_test(), simple, syncops, and tc.

                                                             {
  syncops = false;
  run_test(
      nthreads,
      FLAGS_lines,
      FLAGS_numRecs,
      FLAGS_work,
      iters,
      fc,
      simple,
      dedicated,
      tc,
      syncops);
}

BENCHMARK_RELATIVE	(	combining_no_dedicated_notc_async_dup	,
		iters
	)

Definition at line 261 of file FlatCombiningBenchmark.cpp.

References folly::BENCHMARK_DRAW_LINE(), dedicated, fc, nthreads, folly::test::run_test(), simple, syncops, and tc.

                                                                 {
  run_test(
      nthreads,
      FLAGS_lines,
      FLAGS_numRecs,
      FLAGS_work,
      iters,
      fc,
      simple,
      dedicated,
      tc,
      syncops);
}

BENCHMARK_RELATIVE	(	combining_no_dedicated_tc_sync	,
		iters
	)

Definition at line 277 of file FlatCombiningBenchmark.cpp.

References dedicated, fc, nthreads, folly::test::run_test(), simple, syncops, and tc.

                                                          {
  tc = true;
  syncops = true;
  run_test(
      nthreads,
      FLAGS_lines,
      FLAGS_numRecs,
      FLAGS_work,
      iters,
      fc,
      simple,
      dedicated,
      tc,
      syncops);
}

BENCHMARK_RELATIVE	(	combining_no_dedicated_tc_sync_dup	,
		iters
	)

Definition at line 293 of file FlatCombiningBenchmark.cpp.

References folly::BENCHMARK_DRAW_LINE(), dedicated, fc, nthreads, folly::test::run_test(), simple, syncops, and tc.

                                                              {
  run_test(
      nthreads,
      FLAGS_lines,
      FLAGS_numRecs,
      FLAGS_work,
      iters,
      fc,
      simple,
      dedicated,
      tc,
      syncops);
}

BENCHMARK_RELATIVE	(	combining_no_dedicated_tc_async	,
		iters
	)

Definition at line 309 of file FlatCombiningBenchmark.cpp.

References dedicated, fc, nthreads, folly::test::run_test(), simple, syncops, and tc.

                                                           {
  tc = true;
  syncops = false;
  run_test(
      nthreads,
      FLAGS_lines,
      FLAGS_numRecs,
      FLAGS_work,
      iters,
      fc,
      simple,
      dedicated,
      tc,
      syncops);
}

BENCHMARK_RELATIVE	(	combining_no_dedicated_tc_async_dup	,
		iters
	)

Definition at line 325 of file FlatCombiningBenchmark.cpp.

References folly::BENCHMARK_DRAW_LINE(), dedicated, fc, nthreads, folly::test::run_test(), simple, syncops, and tc.

                                                               {
  run_test(
      nthreads,
      FLAGS_lines,
      FLAGS_numRecs,
      FLAGS_work,
      iters,
      fc,
      simple,
      dedicated,
      tc,
      syncops);
}

void benchmarkSetup

(

)

Definition at line 341 of file FlatCombiningBenchmark.cpp.

Referenced by TEST().

                      {
  int numCores = std::thread::hardware_concurrency();
  std::cout << "\nRunning benchmarks on machine with " << numCores
            << " logical cores" << std::endl;
}

DEFINE_bool	(	direct	,
		false	,
		"run direct measurement"
	)

DEFINE_int32	(	reps	,
		10	,
		"number of reps"
	)

DEFINE_int32	(	ops	,
		100000	,
		"number of operations per rep"
	)

DEFINE_int32	(	lines	,
		5	,
		"number of cache lines accessed per operation"
	)

DEFINE_int32	(	numRecs	,
		8	,
		"number of records"
	)

DEFINE_int32	(	work	,
		1000	,
		"amount of unrelated work per operation"
	)

TEST	(	FlatCombining	,
		folly_benchmark
	)

Definition at line 347 of file FlatCombiningBenchmark.cpp.

References b, benchmarkSetup(), i, nthreads, folly::runBenchmarks(), simple, and string.

                                     {
  if (FLAGS_benchmark) {
    benchmarkSetup();
    for (bool b : {true, false}) {
      simple = b;
      std::string str = simple ? "simple" : "custom";
      std::cout << "\n------------------------------------ " << str
                << " interface" << std::endl;
      for (int i : nthr) {
        std::cout << "\n---------------------------------- Number of threads = "
                  << i << std::endl;
        nthreads = i;
        folly::runBenchmarks();
      }
    }
  }
}

static uint64_t test ( std::string  name, bool  fc_, bool  dedicated_, bool  tc_, bool  syncops_, uint64_t  base  )

static

Definition at line 367 of file FlatCombiningBenchmark.cpp.

References i, max, min, name, nthreads, folly::test::run_test(), simple, sum(), and uint64_t.

Referenced by folly::Bits< T, Traits >::blockCount(), clause11_21_4_2_a(), clause11_21_4_4(), clause11_21_4_6_1(), clause11_21_4_7_2_a2(), clause11_21_4_7_2_b2(), clause11_21_4_7_2_c2(), clause11_21_4_8_9_a(), TEST(), folly::io::test::TEST(), test_message(), test_message_pause(), test_multiple3(), test_parse_url(), test_scan(), zeroCopyOff(), zeroCopyOn(), and Foo::~Foo().

                   {
  uint64_t min = UINTMAX_MAX;
  uint64_t max = 0;
  uint64_t sum = 0;

  for (int i = 0; i < FLAGS_reps; ++i) {
    uint64_t dur = run_test(
        nthreads,
        FLAGS_lines,
        FLAGS_numRecs,
        FLAGS_work,
        FLAGS_ops,
        fc_,
        simple,
        dedicated_,
        tc_,
        syncops_);
    sum += dur;
    min = std::min(min, dur);
    max = std::max(max, dur);
  }
  uint64_t avg = sum / FLAGS_reps;

  uint64_t res = min;
  std::cout << name;
  std::cout << "   " << std::setw(4) << max / FLAGS_ops << " ns";
  std::cout << "   " << std::setw(4) << avg / FLAGS_ops << " ns";
  std::cout << "   " << std::setw(4) << res / FLAGS_ops << " ns";
  if (base) {
    std::cout << " " << std::setw(3) << 100 * base / res << "%";
  }
  std::cout << std::endl;
  return res;
}

TEST	(	FlatCombining	,
		direct_measurement
	)

Definition at line 408 of file FlatCombiningBenchmark.cpp.

References benchmarkSetup(), i, nthreads, simple, string, test(), and uint64_t.

                                        {
  if (!FLAGS_direct) {
    return;
  }
  benchmarkSetup();
  simple = false;
  std::string str = simple ? "simple" : "custom";
  std::cout << "\n------------------------------------ " << str << " interface"
            << std::endl;
  for (int i : nthr) {
    nthreads = i;
    std::cout << "\n------------------------------------ Number of threads = "
              << i << "\n"
              << std::endl;
    std::cout << "Test_name, Max time, Avg time, Min time, % base min / min\n"
              << std::endl;

    uint64_t base =
        test("no_combining - base         ", false, false, false, false, 0);
    test("no_combining - dup          ", false, false, false, false, base);
    std::cout << "---------------------------------------" << std::endl;

    std::cout << "---- dedicated-------------------------" << std::endl;
    test("combining_notc_sync         ", true, true, false, true, base);
    test("combining_notc_sync - dup   ", true, true, false, true, base);
    std::cout << "---------------------------------------" << std::endl;
    test("combining_notc_async        ", true, true, false, false, base);
    test("combining_notc_async - dup  ", true, true, false, false, base);
    std::cout << "---------------------------------------" << std::endl;
    test("combining_tc_sync           ", true, true, true, true, base);
    test("combining_tc_sync - dup     ", true, true, true, true, base);
    std::cout << "---------------------------------------" << std::endl;
    test("combining_tc_async          ", true, true, true, false, base);
    test("combining_tc_async - dup    ", true, true, true, false, base);
    std::cout << "---------------------------------------" << std::endl;

    std::cout << "---- no dedicated----------------------" << std::endl;
    test("combining_notc_sync         ", true, false, false, true, base);
    test("combining_notc_sync - dup   ", true, false, false, true, base);
    std::cout << "---------------------------------------" << std::endl;
    test("combining_notc_async        ", true, false, false, false, base);
    test("combining_notc_async - dup  ", true, false, false, false, base);
    std::cout << "---------------------------------------" << std::endl;
    test("combining_tc_sync           ", true, false, true, true, base);
    test("combining_tc_sync - dup     ", true, false, true, true, base);
    std::cout << "---------------------------------------" << std::endl;
    test("combining_tc_async          ", true, false, true, false, base);
    test("combining_tc_async - dup    ", true, false, true, false, base);
    std::cout << "---------------------------------------" << std::endl;
  }
}

Variable Documentation

bool dedicated

static

Definition at line 38 of file FlatCombiningBenchmark.cpp.

Referenced by BENCHMARK(), BENCHMARK_RELATIVE(), and folly::test::run_test().

bool fc

static

Definition at line 36 of file FlatCombiningBenchmark.cpp.

Referenced by BENCHMARK(), and BENCHMARK_RELATIVE().

std::vector<int> nthr = {1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64}

static

Definition at line 34 of file FlatCombiningBenchmark.cpp.

int nthreads

static

Definition at line 35 of file FlatCombiningBenchmark.cpp.

Referenced by array_bench(), BENCHMARK(), BENCHMARK_RELATIVE(), folly::test::fc_test(), holder_bench(), list_hoh_bench(), list_protect_all_bench(), local_bench(), obj_bench(), run_once(), folly::test::run_test(), runInThreadsAndWait(), TEST(), and test().

bool simple

static

Definition at line 37 of file FlatCombiningBenchmark.cpp.

Referenced by BENCHMARK(), BENCHMARK_RELATIVE(), main(), TEST(), test(), testing::internal::TEST(), and testing::internal::To::To().

bool syncops

static

Definition at line 40 of file FlatCombiningBenchmark.cpp.

Referenced by BENCHMARK(), BENCHMARK_RELATIVE(), and folly::test::run_test().

bool tc

static

Definition at line 39 of file FlatCombiningBenchmark.cpp.

Referenced by BENCHMARK(), BENCHMARK_RELATIVE(), folly::test::fc_test(), folly::hazptr_array< 3, Atom >::hazptr_array(), folly::hazptr_local< M, Atom >::hazptr_local(), folly::FlatCombining< FcSimpleExample< Mutex, Atom >, Mutex, Atom >::requestOp(), folly::test::run_test(), TEST(), folly::hazptr_array< 3, Atom >::~hazptr_array(), and folly::hazptr_local< M, Atom >::~hazptr_local().