Find Example - Benchmark (Nonius) Code

set_benchmark.cpp

/* Running:
BNSIZE=10000; BNQUERIES=1000

./find --param=size:$BNSIZE --param=queries:$BNQUERIES >
  results.size=$BNSIZE.queries=$BNQUERIES.txt

./find --param=size:$BNSIZE --param=queries:$BNQUERIES --reporter=html
  --output=results.size=$BNSIZE.queries=$BNQUERIES.html
*/

#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <iterator>
#include <random>
#include <set>
#include <vector>
#include <boost/container/flat_set.hpp>
#include <EASTL/vector_set.h>

#include <nonius/nonius.h++>
#include <nonius/main.h++>

NONIUS_PARAM(size, std::size_t{100u})
NONIUS_PARAM(queries, std::size_t{10u})


// EASTL
// https://wuyingren.github.io/howto/2016/02/11/Using-EASTL-in-your-projects/
void* operator new[](size_t size, const char* pName, int flags, unsigned debugFlags, const char* file, int line) {
  return malloc(size);
}

void* operator new[](size_t size, size_t alignment, size_t alignmentOffset, const char* pName, int flags, unsigned debugFlags, const char* file, int line) {
  return malloc(size);
}

using T = std::uint32_t;

std::vector<T> odd_numbers(std::size_t count) {
  std::vector<T> result;
  result.reserve(count);
  for (std::size_t i = 0; i != count; i++)
    result.push_back(2 * i + 1);
  return result;
}

template <typename container_type>
T ctor_and_find(const char * type_name, const std::vector<T> & v,
                std::size_t q) {
  std::mt19937 prng(1);
  const std::size_t n = v.size();
  std::uniform_int_distribution<T> uniform(0, 2 * n + 2);
  
  const container_type s(begin(v), end(v));
  
  T sum = 0;
  for (std::size_t i = 0; i != q; ++i) {
    const auto it = s.find(uniform(prng));
    sum += (it != end(s)) ? *it : 0;
  }
  return sum;
}



T ctor_and_find(const char * type_name, const std::vector<T> & v_src,
                std::size_t q) {
  std::mt19937 prng(1);
  const std::size_t n = v_src.size();
  std::uniform_int_distribution<T> uniform(0, 2*n + 2);
  
  auto v = v_src;
  std::sort(begin(v), end(v));
  
  T sum = 0;
  for (std::size_t i = 0; i != q; ++i) {
    const auto k = uniform(prng);
    const auto it = std::lower_bound(begin(v), end(v), k);
    sum += (it != end(v)) ? (*it == k ? k : 0) : 0;
  }
  return sum;
}

NONIUS_BENCHMARK("std::set", [](nonius::chronometer meter) {
  const auto n = meter.param<size>();
  const auto q = meter.param<queries>();
  const auto v = odd_numbers(n);
  meter.measure([q, &v] {
    ctor_and_find<std::set<T>>("std::set", v, q);
  });
});

NONIUS_BENCHMARK("std::vector: copy & sort", [](nonius::chronometer meter) {
  const auto n = meter.param<size>();
  const auto q = meter.param<queries>();
  const auto v = odd_numbers(n);
  meter.measure([q, &v] {
    ctor_and_find("std::vector: copy & sort", v, q);
  });
});


NONIUS_BENCHMARK("boost::container::flat_set", [](nonius::chronometer meter) {
  const auto n = meter.param<size>();
  const auto q = meter.param<queries>();
  const auto v = odd_numbers(n);
  meter.measure([q, &v] {
    ctor_and_find<boost::container::flat_set<T>>("boost::container::flat_set", v, q);
  });
});

NONIUS_BENCHMARK("eastl::vector_set", [](nonius::chronometer meter) {
  const auto n = meter.param<size>();
  const auto q = meter.param<queries>();
  const auto v = odd_numbers(n);
  meter.measure([q, &v] {
    ctor_and_find<eastl::vector_set<T>>("eastl::vector_set", v, q);
  });
});

int main(int argc, char * argv[]) { nonius::main(argc, argv); }