benchmarkSetContainer.cpp

Go to the documentation of this file.

#include <iostream>
#include <benchmark/benchmark.h>
#include <unordered_set>

#include "DGtal/base/Common.h"
#include "DGtal/kernel/domains/CDomainArchetype.h"
#include "DGtal/kernel/sets/DigitalSetBySTLVector.h"
#include "DGtal/kernel/sets/DigitalSetBySTLSet.h"
#include "DGtal/kernel/sets/DigitalSetByAssociativeContainer.h"
#include "DGtal/kernel/sets/DigitalSetFromMap.h"

#include "DGtal/kernel/PointHashFunctions.h"

#include "DGtal/helpers/StdDefs.h"
#include <map>
#include <string>


using namespace std;
using namespace DGtal;


typedef DGtal::DigitalSetBySTLSet< Z2i::Domain> FromSet;
typedef DGtal::DigitalSetBySTLVector< Z2i::Domain> FromVector;
typedef DGtal::DigitalSetByAssociativeContainer< Z2i::Domain, std::unordered_set<Z2i::Point> > FromUnordered;

typedef DGtal::DigitalSetBySTLSet< Z3i::Domain> FromSet3;
typedef DGtal::DigitalSetBySTLVector< Z3i::Domain> FromVector3;
typedef DGtal::DigitalSetByAssociativeContainer< Z3i::Domain, std::unordered_set<Z3i::Point> > FromUnordered3;

template<typename Q>
static void BM_Constructor(benchmark::State& state)
{
  while (state.KeepRunning())
    {
      state.PauseTiming();
      typename Q::Domain dom(typename Q::Point().diagonal(0),
                             typename Q::Point().diagonal(state.range_x()));
      state.ResumeTiming();
      Q image( dom );
    }
}
BENCHMARK_TEMPLATE(BM_Constructor, FromVector)->Range(1<<3 , 1 << 8);
BENCHMARK_TEMPLATE(BM_Constructor, FromSet)->Range(1<<3 , 1 << 8);
BENCHMARK_TEMPLATE(BM_Constructor, FromUnordered)->Range(1<<3 , 1 << 8);
BENCHMARK_TEMPLATE(BM_Constructor, FromVector3)->Range(1<<3 , 1 << 8);
BENCHMARK_TEMPLATE(BM_Constructor, FromSet3)->Range(1<<3 , 1 << 8);
BENCHMARK_TEMPLATE(BM_Constructor, FromUnordered3)->Range(1<<3 , 1 << 8);


template<typename Q>
static void BM_insert(benchmark::State& state)
{
  Q myset(typename Q::Domain( Q::Point::diagonal(0), Q::Point::diagonal(2048) ));
  while (state.KeepRunning())
    {
      state.PauseTiming();
      typename Q::Point p;
      for(unsigned int j=0; j < Q::Point::dimension; j++)
        p[j] = rand() % 2048;
      state.ResumeTiming();

      myset.insert( p );
   }
}
BENCHMARK_TEMPLATE(BM_insert, FromVector);
BENCHMARK_TEMPLATE(BM_insert, FromSet);
BENCHMARK_TEMPLATE(BM_insert, FromUnordered);
BENCHMARK_TEMPLATE(BM_insert, FromVector3);
BENCHMARK_TEMPLATE(BM_insert, FromSet3);
BENCHMARK_TEMPLATE(BM_insert, FromUnordered3);



template<typename Q>
static void BM_iterate(benchmark::State& state)
{
  Q myset(typename Q::Domain( Q::Point::diagonal(0), Q::Point::diagonal(2048) ));
  for(unsigned int i= 0; i < state.range_x(); ++i)
    {
      typename Q::Point p;
      for(unsigned int j=0; j < Q::Point::dimension; j++)
        p[j] = rand() % 2048;
      myset.insert( p );
    }
  while (state.KeepRunning())
    {
      for(typename Q::ConstIterator it= myset.begin(), itend=myset.end(); it != itend;
          ++it)
        benchmark::DoNotOptimize(it);
    }
}
BENCHMARK_TEMPLATE(BM_iterate, FromVector)->Range(1<<3 , 1 << 10);;
BENCHMARK_TEMPLATE(BM_iterate, FromSet)->Range(1<<3 , 1 << 10);;
BENCHMARK_TEMPLATE(BM_iterate, FromUnordered)->Range(1<<3 , 1 << 10);;
BENCHMARK_TEMPLATE(BM_iterate, FromVector3)->Range(1<<3 , 1 << 10);;
BENCHMARK_TEMPLATE(BM_iterate, FromSet3)->Range(1<<3 , 1 << 10);;
BENCHMARK_TEMPLATE(BM_iterate, FromUnordered3)->Range(1<<3 , 1 << 10);;


// Standard services - public :

int main( int argc,  const char*argv[] )
{
  benchmark::Initialize(&argc, argv);

  benchmark::RunSpecifiedBenchmarks();
  return 0;
}
//                                                                           //