распараллелить массив

///----------------------------------------------------------------------------|
/// C++11
/// Распараллеливование вычисления суммы массива.
/// Массив дробится на группы элементов,
///     кол-во групп равно кол-ву ядер на камне.
///----------------------------------------------------------------------------:
#include <iostream>
#include <thread>
#include <mutex>
#include <chrono>
#include <vector>
using namespace std;
 
///----------------------------------------------------------------------------|
/// Менеджер порядка вывода результа на дисплей.
/// (не обязательно: оставил для hoggy)
///----------------------------------------------------------------------------:
struct smyqueue
{   smyqueue() : q(1) {}
 
    int q;
    int max_id;
 
    void end(const int _c)
    {   if(_c == max_id) cout << "\n";
        else             cout << "\n";
 
        if(_c + 1 > max_id) q = 1;
        else                q = _c + 1;
    }
    bool get(const int _c)
    {   std::this_thread::sleep_for(std::chrono::milliseconds(1));
        if(_c == q)
        {   return true;
        }
        return false;
    }
} Q;
 
///----------------------------------------------------------------------------|
/// Многопоточка.
///----------------------------------------------------------------------------:
struct  smy_thread
{       smy_thread()
        {   count++;
            id = count;
        }
    int id;
    
    void operator()(int* m, int size, int* res)
    {   std::mutex mym;
        
        *res = 0;
        for(int i = 0; i < size; i++)
        {   *res += *(m + i);
        }
        
        while(true)
        if(Q.get(id))
        {   std::lock_guard<std::mutex> lock(mym);
            cout << "tread " << id << ", summa = " << *res;
            Q.end(id);
            break;
        }
    }
    
private:
    static int count;
};
int smy_thread::count = 0;
 
///----------------------------------------------------------------------------|
/// Запуск.
///----------------------------------------------------------------------------:
int main()
{   setlocale(0, "");
 
    ///-------------------------|
    /// Узнаем возмжности цпу.  |
    ///-------------------------:
    int n = std::thread::hardware_concurrency();
    if(0 == n)
    {   std::cout << "Warning: hardware_concurrency() is problem!\n\n";
        n = 1;
    }
    else std::cout << "std::thread::hardware_concurrency() = " << n << "\n\n";
    
    Q.max_id = n;
    
    ///-------------------------|
    /// Обрабатываемые данные.  |
    ///-------------------------:
    const int SIZE = 1000000001;
    int* m = new int[SIZE];
    for(int i = 0; i < SIZE; i++) m[i] = 1;
    
    ///-------------------------|
    /// Разбиваем массив.       |
    ///-------------------------:
    int ss  = SIZE/n;
    int sss = SIZE - ss * n + ss;
    
    ///-------------------------|
    /// Хранилище для потоков.  |
    ///-------------------------:
    vector<thread> threads;
                   threads.reserve(n);
    
    ///-------------------------|
    /// Сюда складируем суммы.  |
    ///-------------------------:
    int* sum = new int[n];
    
    ///-------------------------|
    /// Создаем потоки.         |
    ///-------------------------:
    int* mm = m;
    for(int i = 0; i < n - 1; i++)
    {   threads.emplace_back(smy_thread(), mm, ss,  sum + i);
        mm += ss;
    }   threads.emplace_back(smy_thread(), mm, sss, sum + n-1);
 
    ///-------------------------|
    /// Ждем погоду.            |
    ///-------------------------:
    int count = 1;
    for(auto& t: threads)
    {   t.join();
    }
    
    ///-------------------------|
    /// Аккумулируем результат. |
    ///-------------------------:
    int common_summa = 0;
    for(int i = 0; i < n; i++)
    {   common_summa += sum[i];
    }
    std::cout << "\nОбщая сумма = " << common_summa << "\n\n";
    
    std::cin.get();
    return 0;
}

        std::vector<int> arr(100, 1); 
 
        const size_t n = std::thread::hardware_concurrency();
        std::unique_ptr<int[]> sum{new int[n]{0}};
        std::vector<std::thread> threads;
        size_t sz = arr.size(); 
        auto *p = arr.data();
        auto *sum2 = sum.get();
        for (size_t i = n; i > 0;  --i)
        {
            const auto sz2 = sz / i;
            threads.emplace_back([p, sz2, sum = sum2++]() noexcept
            {
                for (auto it = p, end = p + sz2; it != end; ++it)
                    *sum += *it;
            });
 
            sz -= sz2;
            p += sz2;
        }
 
        size_t total = 0;
        for (size_t i = 0; i < n; ++i)
        {
            threads[i].join();
            total += sum[i];
            std::cout << "thread " << (i + 1) << ": " << sum[i] << std::endl;
        }
 
        std::cout << "total: " << total << std::endl;