{

//typedef T result_type;

T operator()(Iterator first,Iterator last)

{

return std::accumulate(first,last,T());

}

{

unsigned long const length=std::distance(first,last);

if(!length)

return init;

unsigned long const block_size=25;

unsigned long const num_blocks=(length+block_size-1)/block_size;

boost::csbl::vector<boost::future<T> > futures(num_blocks-1);

boost::basic_thread_pool pool;

Iterator block_start=first;

for(unsigned long i=0;i<(num_blocks-1);++i)

{

Iterator block_end=block_start;

std::advance(block_end,block_size);

futures[i]=boost::async(pool, accumulate_block<Iterator,T>(), block_start, block_end);

block_start=block_end;

}

T last_result=accumulate_block<Iterator,T>()(block_start,last);

T result=init;

for(unsigned long i=0;i<(num_blocks-1);++i)

{

result+=futures[i].get();

}

result += last_result;

return result;

{

try

{

const int s = 1001;

std::vector<int> vec;

vec.reserve(s);

for (int i=0; i<s;++i)

vec.push_back(1);

int r = parallel_accumulate(vec.begin(), vec.end(),0);

std::cout << r << std::endl;

}

catch (std::exception& ex)

{

std::cout << "ERROR= " << ex.what() << "" << std::endl;

return 1;

}

catch (...)

{

std::cout << " ERROR= exception thrown" << std::endl;

return 2;

}

return 0;