/* 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 "stdafx.h"
#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/container/vector.hpp>
#include <boost/container/deque.hpp>
#include <boost/double_ended/devector.hpp>
#include <boost/double_ended/batch_deque.hpp>
#include <boost/preprocessor/stringize.hpp>
#include <boost/type_index.hpp>
#include <cmath>
#include <iostream>

bool condition( int i )
{
    return i % 3 == 0;
}

bool condition2( int i )
{
    return i / 2 > 0;
}

template<typename Container1, typename Container2>
void measure_for_each_contiguous()
{
  std::cout<<"n\t" << boost::typeindex::type_id<Container1>().pretty_name() << "\t" << boost::typeindex::type_id<Container2>().pretty_name() << "\t\n";
  for(std::size_t n=1000;n<=10000000;n*=10)
  {
    Container1 container1;
    container1.reserve( n );
    Container2 container2;
    container2.reserve( n );


    auto f1=[&]()
    {
        container1.clear();
        for( auto i = 0; i < n; ++i )    
            if( condition(i) || condition2(i) )
                container1.push_back( i );

        return container1.size();
    };

    auto f2 = [&]()
    {
        container2.clear();        
        for( auto i = 0; i < n; ++i )
            if( condition(i) || condition2(i) )
                container2.unsafe_push_back( i );

        return container2.size();
    };

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

template<typename Container1, typename Container2>
void measure_for_each_deque()
{
    std::cout << "n\t" << boost::typeindex::type_id<Container1>().pretty_name() << "\t" << boost::typeindex::type_id<Container2>().pretty_name() << "\t\n";
    for( std::size_t n = 1000; n <= 10000000; n *= 10 )
    {
        Container1 container1;
        Container2 container2;

        auto f1 = [&]()
        {
            container1.clear();
            for( auto i = 0; i < n; ++i )
                if( condition(i) || condition2(i) )
                    container1.push_back( i );

            return container1.size();
        };

        auto f2 = [&]()
        {
            container2.clear();       
            container2.reserve_back( n );
            for( auto i = 0; i < n; ++i )
                if( condition(i) || condition2(i) )
                    container2.unsafe_push_back( i );

            return container2.size();
        };


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

int main()
{

 
    measure_for_each_contiguous<boost::container::vector<int>, boost::double_ended::devector<int>>();
    measure_for_each_deque<boost::container::deque<int>, boost::double_ended::batch_deque<int,boost::double_ended::batch_deque_policy<128>>>();

    std::cout << "\n";
}