//////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Vicente J. Botet Escriba 2008-2009.
// 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)
//
// See http://www.boost.org/libs/interthreads for documentation.
//
// Based on the shared.cpp example from the threadalert library of Roland Schwarz
//////////////////////////////////////////////////////////////////////////////

#include <iostream>
#include <algorithm>
#include <vector>

#include <boost/assert.hpp>

#include <boost/lambda/lambda.hpp>

#include <boost/timer.hpp>
#include <boost/thread/thread.hpp>
#include <boost/bind.hpp>

#include <tbb/task_scheduler_init.h>
#include <tbb/parallel_sort.h>
#include <tbb/parallel_for.h>
#include <tbb/blocked_range.h>

#include <tbb/concurrent_vector.h>

#include "parallel_tp.hpp"

static const int NN = 1000000;

typedef int element_type;
typedef tbb::concurrent_vector<element_type> col_type;
typedef col_type::iterator iterator_type;
typedef col_type::const_iterator const_iterator_type;

col_type sorted;
col_type filled;
col_type values1;
col_type values2;

using namespace std;
using namespace boost;

using boost::lambda::var;

template <typename T, typename F>
void evaluate_col(const T & c, const T & r, const char * const s, F f)
{
	T lc(c.begin(), c.end());
	cout << s << " 0.." << c.size();
	timer t;
	f(lc.begin(), lc.end());
	cout << " ok : " << std::equal(r.begin(), r.end(), lc.begin());
	cout << " elapsed: " << t.elapsed() << endl;
}



int main() 
{

	tbb::task_scheduler_init init;

	sorted.grow_by(NN);

	int i = 0;

	generate(sorted.begin(), sorted.end(), var(i)++);

	// will be in reversed order
	values1.grow_by(NN);
	generate(values1.begin(), values1.end(), --var(i));

	filled.grow_by(NN);
	std::fill(filled.begin(), filled.end(), 2);

	evaluate_col<col_type>(values1, filled, "            std::fill reverse", boost::bind(&std::fill<iterator_type, element_type>,
		::_1, ::_2, 2));

//	evaluate_col<col_type>(values1, filled, "       boost::tp:fill reverse", boost::bind(&parallel_fill<iterator_type, element_type>,
//		::_1, ::_2, 2));

	values2 = values1;

	struct TbbFiller
	{

		TbbFiller(col_type & v) : _v(v) {}

		mutable col_type & _v;

		void operator()(const tbb::blocked_range<int> & r) const
		{
			BOOST_ASSERT(_v.begin() + r.begin() <= _v.end());
			BOOST_ASSERT(_v.begin() + r.end() <= _v.end());

			std::fill(_v.begin() + r.begin(), _v.begin() + r.end(), 2);
		}
	};

	timer t;

	cout << "       tbb::parallel_for fill 0.." << values2.size();

	tbb::parallel_for(tbb::blocked_range<int>(0, values2.size(), 1000), TbbFiller(values2));

	cout << " ok : " << std::equal(filled.begin(), filled.end(), values2.begin());

	cout << " elapsed: " << t.elapsed() << endl;

	// std::sort evaluation
	evaluate_col<col_type>(values1, sorted, "            std::sort reverse", &std::sort<iterator_type>);

	// tbb::parallel_sort evaluation
	void (* s)(iterator_type, iterator_type) = &tbb::parallel_sort<iterator_type>;
	evaluate_col<col_type>(values1, sorted, "   tbb::parallel_sort reverse", s);

	// our sort evaluation
	evaluate_col<col_type>(values1, sorted, "      boost::tp::sort reverse", &parallel_tp<iterator_type>);


}