ForeachBenchmark.cpp File Reference

#include <algorithm>
#include <map>
#include <folly/Benchmark.h>
#include <folly/Random.h>
#include <folly/container/Enumerate.h>
#include <folly/container/Foreach.h>
#include <folly/init/Init.h>

Go to the source code of this file.

Functions
void	setupBenchmark (size_t iters)
void	setupCharVecBenchmark (size_t iters)
	BENCHMARK (ForEachFunctionNoAssign, iters)
	BENCHMARK (StdForEachFunctionNoAssign, iters)
	BENCHMARK (RangeBasedForLoopNoAssign, iters)
	BENCHMARK (ManualLoopNoAssign, iters)
	BENCHMARK (ForEachFunctionAssign, iters)
	BENCHMARK (StdForEachFunctionAssign, iters)
	BENCHMARK (RangeBasedForLoopAssign, iters)
	BENCHMARK (ManualLoopAssign, iters)
	BENCHMARK (ForEachFunctionNoAssignWithIndexManipulation, iters)
	BENCHMARK (StdForEachFunctionNoAssignWithIndexManipulation, iters)
	BENCHMARK (RangeBasedForLoopNoAssignWithIndexManipulation, iters)
	BENCHMARK (ForEachFunctionFetch, iters)
	BENCHMARK (StdForEachFunctionFetch, iters)
	BENCHMARK (ForLoopFetch, iters)
	BENCHMARK (ForEachKVNoMacroAssign, iters)
	BENCHMARK (ForEachKVNoMacroNoAssign, iters)
	BENCHMARK (ForEachKVMacro, iters)
	BENCHMARK (ForEachManual, iters)
	BENCHMARK (ForEachRange, iters)
	BENCHMARK (ForEachDescendingManual, iters)
	BENCHMARK (ForEachRangeR, iters)
	BENCHMARK (CharVecForRange, iters)
	BENCHMARK (CharVecForRangeExplicitIndex, iters)
	BENCHMARK (CharVecForEach, iters)
	BENCHMARK (CharVecForEachIndex, iters)
	BENCHMARK (CharVecForRangeEnumerate, iters)
int	main (int argc, char **argv)

Variables
std::map< int, std::string >	bmMap
std::vector< int >	vec_one
std::vector< int >	vec_two
std::vector< char >	vec_char

Function Documentation

BENCHMARK	(	ForEachFunctionNoAssign	,
		iters
	)

Definition at line 62 of file ForeachBenchmark.cpp.

References folly::BenchmarkSuspender::dismissing(), folly::doNotOptimizeAway(), folly::for_each(), setupBenchmark(), and string.

                                          {
  BenchmarkSuspender suspender;

  int sumKeys = 0;
  std::string sumValues;
  setupBenchmark(iters);

  suspender.dismissing([&]() {
    folly::for_each(bmMap, [&](auto& key_val_pair) {
      sumKeys += key_val_pair.first;
      sumValues += key_val_pair.second;
    });
    doNotOptimizeAway(sumKeys);
  });
}

BENCHMARK	(	StdForEachFunctionNoAssign	,
		iters
	)

Definition at line 78 of file ForeachBenchmark.cpp.

References folly::BenchmarkSuspender::dismissing(), folly::doNotOptimizeAway(), for_each(), setupBenchmark(), and string.

                                             {
  BenchmarkSuspender suspender;

  int sumKeys = 0;
  std::string sumValues;
  setupBenchmark(iters);

  suspender.dismissing([&]() {
    std::for_each(bmMap.begin(), bmMap.end(), [&](auto& key_val_pair) {
      sumKeys += key_val_pair.first;
      sumValues += key_val_pair.second;
    });
    doNotOptimizeAway(sumKeys);
  });
}

BENCHMARK	(	RangeBasedForLoopNoAssign	,
		iters
	)

Definition at line 94 of file ForeachBenchmark.cpp.

References folly::BenchmarkSuspender::dismissing(), folly::doNotOptimizeAway(), setupBenchmark(), and string.

                                            {
  BenchmarkSuspender suspender;
  int sumKeys = 0;
  std::string sumValues;
  setupBenchmark(iters);

  suspender.dismissing([&]() {
    for (auto& key_val_pair : bmMap) {
      sumKeys += key_val_pair.first;
      sumValues += key_val_pair.second;
    }
    doNotOptimizeAway(sumKeys);
  });
}

BENCHMARK	(	ManualLoopNoAssign	,
		iters
	)

Definition at line 109 of file ForeachBenchmark.cpp.

References folly::BenchmarkSuspender::dismissing(), folly::doNotOptimizeAway(), setupBenchmark(), and string.

                                     {
  BenchmarkSuspender suspender;

  int sumKeys = 0;
  std::string sumValues;
  setupBenchmark(iters);

  suspender.dismissing([&]() {
    for (auto iter = bmMap.begin(); iter != bmMap.end(); ++iter) {
      sumKeys += iter->first;
      sumValues += iter->second;
    }
    doNotOptimizeAway(sumKeys);
  });
}

BENCHMARK	(	ForEachFunctionAssign	,
		iters
	)

Definition at line 125 of file ForeachBenchmark.cpp.

References folly::BenchmarkSuspender::dismissing(), folly::for_each(), k, setupBenchmark(), string, and v.

                                        {
  BenchmarkSuspender suspender;

  int sumKeys = 0;
  std::string sumValues;
  setupBenchmark(iters);

  suspender.dismissing([&]() {
    folly::for_each(bmMap, [&](auto& key_val_pair) {
      const int k = key_val_pair.first;
      const std::string v = key_val_pair.second;
      sumKeys += k;
      sumValues += v;
    });
  });
}

BENCHMARK	(	StdForEachFunctionAssign	,
		iters
	)

Definition at line 142 of file ForeachBenchmark.cpp.

References folly::BenchmarkSuspender::dismissing(), for_each(), k, setupBenchmark(), string, and v.

                                           {
  BenchmarkSuspender suspender;

  int sumKeys = 0;
  std::string sumValues;
  setupBenchmark(iters);

  suspender.dismissing([&]() {
    std::for_each(bmMap.begin(), bmMap.end(), [&](auto& key_val_pair) {
      const int k = key_val_pair.first;
      const std::string v = key_val_pair.second;
      sumKeys += k;
      sumValues += v;
    });
  });
}

BENCHMARK	(	RangeBasedForLoopAssign	,
		iters
	)

Definition at line 159 of file ForeachBenchmark.cpp.

References folly::BenchmarkSuspender::dismissing(), k, setupBenchmark(), string, and v.

                                          {
  BenchmarkSuspender suspender;

  int sumKeys = 0;
  std::string sumValues;
  setupBenchmark(iters);

  suspender.dismissing([&]() {
    for (auto& key_val_pair : bmMap) {
      const int k = key_val_pair.first;
      const std::string v = key_val_pair.second;
      sumKeys += k;
      sumValues += v;
    }
  });
}

BENCHMARK	(	ManualLoopAssign	,
		iters
	)

Definition at line 176 of file ForeachBenchmark.cpp.

References folly::BenchmarkSuspender::dismissing(), k, setupBenchmark(), string, and v.

                                   {
  BenchmarkSuspender suspender;

  int sumKeys = 0;
  std::string sumValues;
  setupBenchmark(iters);

  suspender.dismissing([&]() {
    for (auto iter = bmMap.begin(); iter != bmMap.end(); ++iter) {
      const int k = iter->first;
      const std::string v = iter->second;
      sumKeys += k;
      sumValues += v;
    }
  });
}

BENCHMARK	(	ForEachFunctionNoAssignWithIndexManipulation	,
		iters
	)

Definition at line 193 of file ForeachBenchmark.cpp.

References folly::BenchmarkSuspender::dismissing(), folly::for_each(), setupBenchmark(), and string.

                                                               {
  BenchmarkSuspender suspender;

  int sumKeys = 0;
  std::string sumValues;
  setupBenchmark(iters);

  suspender.dismissing([&]() {
    folly::for_each(bmMap, [&](auto& key_val_pair, auto index) {
      sumKeys += key_val_pair.first;
      sumValues += key_val_pair.second;
      sumValues += index;
    });
  });
}

BENCHMARK	(	StdForEachFunctionNoAssignWithIndexManipulation	,
		iters
	)

Definition at line 209 of file ForeachBenchmark.cpp.

References folly::BenchmarkSuspender::dismissing(), for_each(), setupBenchmark(), and string.

                                                                  {
  BenchmarkSuspender suspender;

  int sumKeys = 0;
  std::string sumValues;
  setupBenchmark(iters);

  suspender.dismissing([&]() {
    auto index = std::size_t{0};
    std::for_each(bmMap.begin(), bmMap.end(), [&](auto& key_val_pair) {
      sumKeys += key_val_pair.first;
      sumValues += key_val_pair.second;
      sumValues += index;
      ++index;
    });
  });
}

BENCHMARK	(	RangeBasedForLoopNoAssignWithIndexManipulation	,
		iters
	)

Definition at line 227 of file ForeachBenchmark.cpp.

References folly::BenchmarkSuspender::dismissing(), setupBenchmark(), and string.

                                                                 {
  BenchmarkSuspender suspender;

  int sumKeys = 0;
  std::string sumValues;
  setupBenchmark(iters);

  suspender.dismissing([&]() {
    auto index = std::size_t{0};
    for (auto& key_val_pair : bmMap) {
      sumKeys += key_val_pair.first;
      sumValues += key_val_pair.second;
      sumValues += index;
    }
  });
}

BENCHMARK	(	ForEachFunctionFetch	,
		iters
	)

Definition at line 244 of file ForeachBenchmark.cpp.

References folly::BenchmarkSuspender::dismissing(), folly::fetch(), folly::for_each(), and setupBenchmark().

                                       {
  BenchmarkSuspender suspender;
  setupBenchmark(iters);

  suspender.dismissing([&]() {
    folly::for_each(bmMap, [&](auto& key_val_pair, auto index) {
      folly::fetch(vec_one, index) = key_val_pair.first;
    });
  });
}

BENCHMARK	(	StdForEachFunctionFetch	,
		iters
	)

Definition at line 255 of file ForeachBenchmark.cpp.

References folly::BenchmarkSuspender::dismissing(), for_each(), and setupBenchmark().

                                          {
  BenchmarkSuspender suspender;
  setupBenchmark(iters);

  suspender.dismissing([&]() {
    auto index = std::size_t{0};
    std::for_each(bmMap.begin(), bmMap.end(), [&](auto& key_val_pair) {
      *(vec_one.begin() + index++) = key_val_pair.first;
    });
  });
}

BENCHMARK	(	ForLoopFetch	,
		iters
	)

Definition at line 267 of file ForeachBenchmark.cpp.

References folly::BenchmarkSuspender::dismissing(), and setupBenchmark().

                               {
  BenchmarkSuspender suspender;
  setupBenchmark(iters);

  suspender.dismissing([&]() {
    auto index = std::size_t{0};
    for (auto& key_val_pair : bmMap) {
      *(vec_one.begin() + index++) = key_val_pair.first;
    }
  });
}

BENCHMARK	(	ForEachKVNoMacroAssign	,
		iters
	)

Definition at line 279 of file ForeachBenchmark.cpp.

References BENCHMARK_SUSPEND, FOR_EACH, k, setupBenchmark(), string, and v.

                                         {
  int sumKeys = 0;
  std::string sumValues;

  BENCHMARK_SUSPEND {
    setupBenchmark(iters);
  }

  FOR_EACH (iter, bmMap) {
    const int k = iter->first;
    const std::string v = iter->second;
    sumKeys += k;
    sumValues += v;
  }
}

BENCHMARK	(	ForEachKVNoMacroNoAssign	,
		iters
	)

Definition at line 295 of file ForeachBenchmark.cpp.

References BENCHMARK_SUSPEND, FOR_EACH, setupBenchmark(), and string.

                                           {
  int sumKeys = 0;
  std::string sumValues;

  BENCHMARK_SUSPEND {
    setupBenchmark(iters);
  }

  FOR_EACH (iter, bmMap) {
    sumKeys += iter->first;
    sumValues += iter->second;
  }
}

BENCHMARK	(	ForEachKVMacro	,
		iters
	)

Definition at line 309 of file ForeachBenchmark.cpp.

References BENCHMARK_SUSPEND, FOR_EACH_KV, k, setupBenchmark(), string, and v.

                                 {
  int sumKeys = 0;
  std::string sumValues;

  BENCHMARK_SUSPEND {
    setupBenchmark(iters);
  }

  FOR_EACH_KV (k, v, bmMap) {
    sumKeys += k;
    sumValues += v;
  }
}

BENCHMARK	(	ForEachManual	,
		iters
	)

Definition at line 323 of file ForeachBenchmark.cpp.

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

                                {
  int sum = 1;
  for (size_t i = 1; i < iters; ++i) {
    sum *= i;
  }
  doNotOptimizeAway(sum);
}

BENCHMARK	(	ForEachRange	,
		iters
	)

Definition at line 331 of file ForeachBenchmark.cpp.

References folly::doNotOptimizeAway(), FOR_EACH_RANGE, i, and sum().

                               {
  int sum = 1;
  FOR_EACH_RANGE (i, 1, iters) { sum *= i; }
  doNotOptimizeAway(sum);
}

BENCHMARK	(	ForEachDescendingManual	,
		iters
	)

Definition at line 337 of file ForeachBenchmark.cpp.

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

                                          {
  int sum = 1;
  for (size_t i = iters; i-- > 1;) {
    sum *= i;
  }
  doNotOptimizeAway(sum);
}

BENCHMARK	(	ForEachRangeR	,
		iters
	)

Definition at line 345 of file ForeachBenchmark.cpp.

References folly::doNotOptimizeAway(), FOR_EACH_RANGE_R, i, and sum().

                                {
  int sum = 1;
  FOR_EACH_RANGE_R (i, 1U, iters) { sum *= i; }
  doNotOptimizeAway(sum);
}

BENCHMARK	(	CharVecForRange	,
		iters
	)

Definition at line 351 of file ForeachBenchmark.cpp.

References BENCHMARK_SUSPEND, c, folly::doNotOptimizeAway(), setupCharVecBenchmark(), and sum().

                                  {
  BENCHMARK_SUSPEND {
    setupCharVecBenchmark(iters);
  }
  size_t sum = 0;
  for (auto& c : vec_char) {
    sum += c;
  }
  doNotOptimizeAway(sum);
}

BENCHMARK	(	CharVecForRangeExplicitIndex	,
		iters
	)

Definition at line 362 of file ForeachBenchmark.cpp.

References BENCHMARK_SUSPEND, c, folly::doNotOptimizeAway(), setupCharVecBenchmark(), and sum().

                                               {
  BENCHMARK_SUSPEND {
    setupCharVecBenchmark(iters);
  }
  size_t sum = 0;
  size_t index = 0;
  for (auto& c : vec_char) {
    sum += c * index;
    ++index;
  }
  doNotOptimizeAway(sum);
}

BENCHMARK	(	CharVecForEach	,
		iters
	)

Definition at line 375 of file ForeachBenchmark.cpp.

References BENCHMARK_SUSPEND, c, folly::doNotOptimizeAway(), folly::for_each(), setupCharVecBenchmark(), and sum().

                                 {
  BENCHMARK_SUSPEND {
    setupCharVecBenchmark(iters);
  }
  size_t sum = 0;
  folly::for_each(vec_char, [&](auto& c) { sum += c; });
  doNotOptimizeAway(sum);
}

BENCHMARK	(	CharVecForEachIndex	,
		iters
	)

Definition at line 384 of file ForeachBenchmark.cpp.

References BENCHMARK_SUSPEND, c, folly::doNotOptimizeAway(), folly::for_each(), setupCharVecBenchmark(), and sum().

                                      {
  BENCHMARK_SUSPEND {
    setupCharVecBenchmark(iters);
  }
  size_t sum = 0;
  folly::for_each(vec_char, [&](auto& c, auto index) { sum += c * index; });
  doNotOptimizeAway(sum);
}

BENCHMARK	(	CharVecForRangeEnumerate	,
		iters
	)

Definition at line 393 of file ForeachBenchmark.cpp.

References BENCHMARK_SUSPEND, folly::doNotOptimizeAway(), folly::enumerate(), setupCharVecBenchmark(), and sum().

                                           {
  BENCHMARK_SUSPEND {
    setupCharVecBenchmark(iters);
  }
  size_t sum = 0;
  for (auto&& it : enumerate(vec_char)) {
    sum += *it * it.index;
  }
  doNotOptimizeAway(sum);
}

int main	(	int	argc,
		char **	argv
	)

Definition at line 404 of file ForeachBenchmark.cpp.

References folly::init(), and folly::runBenchmarks().

                                {
  folly::init(&argc, &argv);
  runBenchmarks();
  return 0;
}

void setupBenchmark

(

size_t

iters

)

Definition at line 44 of file ForeachBenchmark.cpp.

References i.

Referenced by BENCHMARK().

                                  {
  bmMap.clear();
  for (size_t i = 0; i < iters; ++i) {
    bmMap[i] = "teststring";
  }

  vec_one.clear();
  vec_two.clear();
  vec_one.resize(iters);
  vec_two.resize(iters);
}

void setupCharVecBenchmark

(

size_t

iters

)

Definition at line 56 of file ForeachBenchmark.cpp.

References folly::Random::rand32().

Referenced by BENCHMARK().

                                         {
  vec_char.resize(iters);
  std::generate(
      vec_char.begin(), vec_char.end(), [] { return Random::rand32(128); });
}

Variable Documentation

std::map<int, std::string> bmMap

Definition at line 37 of file ForeachBenchmark.cpp.

std::vector<char> vec_char

Definition at line 42 of file ForeachBenchmark.cpp.

std::vector<int> vec_one

Definition at line 38 of file ForeachBenchmark.cpp.

std::vector<int> vec_two

Definition at line 39 of file ForeachBenchmark.cpp.