/* Performance comparison of plain vs. segmented for_each loops
 * over double_ended::batch_deque.
 *
 * Copyright 2017 Joaquin M Lopez Munoz.
 * Distributed under the Boost Software License, Version 1.0.
 * (See accompanying file LICENSE_1_0.txt or copy at
 * http://www.boost.org/LICENSE_1_0.txt)
 */
  
#include <algorithm>
#include <array>
#include <chrono>
#include <cmath>
#include <numeric> 

std::chrono::high_resolution_clock::time_point measure_start,measure_pause;
    
template<typename F>
double measure(F f)
{
  using namespace std::chrono;
    
  static const int              num_trials=10;
  static const milliseconds     min_time_per_trial(200);
  std::array<double,num_trials> trials;
  volatile decltype(f())        res; /* to avoid optimizing f() away */
    
  for(int i=0;i<num_trials;++i){
    int                               runs=0;
    high_resolution_clock::time_point t2;
    
    measure_start=high_resolution_clock::now();
    do{
      res=f();
      ++runs;
      t2=high_resolution_clock::now();
    }while(t2-measure_start<min_time_per_trial);
    trials[i]=duration_cast<duration<double>>(t2-measure_start).count()/runs;
  }
  (void)res; /* var not used warn */
    
  std::sort(trials.begin(),trials.end());
  return std::accumulate(
    trials.begin()+2,trials.end()-2,0.0)/(trials.size()-4);
}

template<typename F>
double measure(unsigned int n,F f)
{
  double t=measure(f);
  return (t/n)*10E9;
}    

void pause_timing()
{
  measure_pause=std::chrono::high_resolution_clock::now();
}
    
void resume_timing()
{
  measure_start+=std::chrono::high_resolution_clock::now()-measure_pause;
}

#include <algorithm>
#include <boost/double_ended/batch_deque.hpp>
#include <boost/preprocessor/stringize.hpp>
#include <cmath>
#include <iostream>

template<std::size_t SegmentSize,typename F>
void measure_for_each(F f)
{
  std::cout<<"n\tplain\tsegmented\n";
  for(std::size_t n=1000;n<=10000000;n*=10){
    boost::double_ended::batch_deque<
      int,boost::double_ended::batch_deque_policy<SegmentSize>> d;
    for(auto i=n;i--;)d.push_back(i);

    unsigned long res=0;

    auto f1=[&](){
      res=0;
      std::for_each(d.begin(),d.end(),[&](int x){res+=f(x);});
      return res;
    };

    auto f2=[&](){
      res=0;
      for(auto it=d.segment_begin(),end=d.segment_end();it!=end;++it){
        std::for_each(
          it.data(),it.data()+it.data_size(),[&](int x){res+=f(x);});
      }
      return res;
    };

    std::cout<<"10E"<<int(std::log10(n))<<"\t"
             <<measure(n,f1)<<"\t"<<measure(n,f2)<<"\n";
  }
}

int main()
{
#define F1 [](int x){return x;}
#define F2 [](int x){return x%4?x:-x;}

  constexpr std::size_t S1=32;
  constexpr std::size_t S2=512;

  std::cout<<BOOST_PP_STRINGIZE(F1)<<"\n";
  std::cout<<"segment size: "<<S1<<"\n";
  measure_for_each<S1>(F1);
  std::cout<<"segment size: "<<S2<<"\n";
  measure_for_each<S2>(F1);

  std::cout<<"\n";

  std::cout<<BOOST_PP_STRINGIZE(F2)<<"\n";
  std::cout<<"segment size: "<<S1<<"\n";
  measure_for_each<S1>(F2);
  std::cout<<"segment size: "<<S2<<"\n";
  measure_for_each<S2>(F2);
}