A demonstration of how to add parallelism using only standard C++ 17

cpp17-std-parallelism.cpp

#include <iostream>
#include <future>
#include <vector>
#include <array>
#include <numeric>  // needed for the std::iota part of the example

using VecIt = std::vector<int>::iterator;

int task(std::size_t task_id, VecIt begin, std::size_t count)
{
    int sum = 0;
    for (VecIt it = begin, end = begin + count; it != end; ++it)
        sum += *it;
    return sum;
}

int main()
{
    // create fake data: 0, 1, 2, ... 134
    std::vector<int> input_data(135);
    std::iota(input_data.begin(), input_data.end(), 0);
    
    // creating the workers
    constexpr std::size_t WorkerCount = 4;
    std::array<std::future<int>, WorkerCount> futures;
    std::size_t data_size = input_data.size();
    std::size_t block_size = data_size / WorkerCount;
    
    for (std::size_t i = 0; i < WorkerCount; ++i)
    {
        // the range of data on which we shall work
        std::size_t start = i * block_size,
                    count = (i + 1 != WorkerCount) ? (block_size) : (data_size - i * block_size);

        futures[i] = std::async(
            std::launch::async,
            [i, start, count, &input_data](){
                return task(i, input_data.begin() + start, count);    
            }
        );
    }
    
    // wait and harvest results
    int total = 0;
    for (std::size_t i = 0; i < WorkerCount; ++i)
        total += futures[i].get();
        
    std::cout << "harvested: " << total << ", expected: " << (data_size * (data_size - 1) / 2) << "\n";
    
    return 0;
}