#include <iostream>
#include <thread>
#include <vector>
#include <numeric>
#include <functional>
#include <algorithm>
template <typename Iterator, typename T>
struct accumulate_block
{
void operator()(Iterator first, Iterator last, T &result)
{
result = std::accumulate(first, last, result);
}
};
template <typename Iterator, typename T>
T parallel_accumulate(Iterator first, Iterator last, T init)
{
unsigned long const lenght = std::distance(first, last);
if (!lenght)
return init;
unsigned long const min_per_thread = 25;
unsigned long const max_threads = (lenght + min_per_thread - 1) / min_per_thread;
unsigned long const num_threads = std::min(hardware_threads != 0 ? hardware_threads : 2, max_threads);
unsigned long const block_size = lenght / num_threads;
std::vector<T> results(num_threads);
std::vector<std::thread> threads(num_threads - 1);
Iterator block_start = first;
for (unsigned long i = 0; i < (num_threads - 1); ++i)
{
Iterator block_end = block_start;
std::advance(block_end, block_size);
threads[i] = std::thread(accumulate_block<Iterator, T>(),
block_start, block_end, std::ref(results[i]));
block_start = block_end;
}
accumulate_block<Iterator, T>()(block_start, last, results[num_threads - 1]);
std::for_each(threads.begin(), thread.end(), std::mem_fn(&std::thread::join));
return std::accumulate(results.begin(), results.end(), init);
}
int main()
{
std::vector<int> vec = {1, 2, 3, 4, 5, 0, 1};
std::cout << parallel_accumulate(vec.begin(), vec.end(), 0) << std::endl;
system("pause");
return 0;
}
Mam tu kod z pewnej książki, który robi wielowątkowo operację std::accumulate. Niestety nie działa, nie wiem dlaczego, a przez wielowątkowość, to wyskakują kompletnie nieintuicyjne, ciężkie do analizy błędy.