cachebenchmark.cpp

#include <chrono>
#include <iostream>
#include <type_traits>


template <class F, class... Args>
std::chrono::duration<double>
benchmark(F&& f, Args&&... args)
{
  using clock = std::conditional<std::chrono::high_resolution_clock::is_steady,
                                 std::chrono::high_resolution_clock,
                                 std::chrono::steady_clock>::type;
  const auto t0 = clock::now();
  std::forward<F>(f)(std::forward<Args>(args)...);
  return std::chrono::duration<double>(clock::now() - t0);
}

struct FarApart
{
  char a;
  char c[128];
  char b;
};

struct CloseTogether
{
  char c[128];
  char a;
  char b;
};

template<typename T>
void benchmarkCache(T* t, int s)
{
  int j = 0;
  for (int i = 0; i != s; ++i) {
    if(t[i].a == t[i].b)
      j++;
  }
}

int main() {
  constexpr auto LENGTH = 10000000;
  CloseTogether* ct = new CloseTogether[LENGTH];
  FarApart* fa = new FarApart[LENGTH];
  std::cout << "Struct with members close together takes: "<< benchmark(benchmarkCache<CloseTogether>, ct, LENGTH).count() << std::endl;
  std::cout << "Struct with members far apart takes: " << benchmark(benchmarkCache<FarApart>, fa, LENGTH).count() << std::endl;
  delete[] ct;
  delete[] fa;
}