Многопоточность и вычисления: выбор оптимальной стратегии

float acc[SIZE]

    
#define SIZE 10000
    float calculate()
    {
        // Ресурсоемкие вычисления
    }
 
    void main()
    {
        float acc[SIZE];
        float temp = 0;
 
        srand(time(NULL));
        size_t index = 0;
    
        //Вот эту часть распараллелить по потокам
        for (size_t i = 0; i < 10000000; i++)
        {
            index = rand() % SIZE;        // Здесь на самом деле тоже долго высчитывать. 
            temp = calculate();
            acc[index] += temp;     // Вот здесь нужно синхронизировать
        }
    }

#include <iostream>
#include <vector>
#include <utility>
#include <thread>
#include <future>
#include <ctime>
#include <random>
#include <array>
 
using data_t = float;
using res_t = std::pair<data_t, size_t>;
constexpr std::size_t SIZE = 10;
std::array<data_t, SIZE> data;
std::mutex m;
 
res_t calculate()
{
   static std::mt19937 gen(static_cast<unsigned>(std::time(nullptr)));
   std::uniform_real_distribution<data_t> data_dis(-10, 10);
   std::uniform_int_distribution<std::size_t> index_dis(0, SIZE-1);
 
   std::this_thread::sleep_for(std::chrono::milliseconds(index_dis(gen)));
   return {data_dis(gen), index_dis(gen)};
}
 
template <typename Cont>
void modify(Cont &cont, const typename Cont::value_type& val, std::size_t idx)
{
   std::lock_guard<std::mutex> lock(m);
   cont[idx] += val;
}
 
int main()
{
   std::vector<std::future<res_t>> results;
   int count = 10000;
   while (count--)
      results.emplace_back(std::async(calculate));
 
   for (auto &f : results)
   {
      res_t res  = f.get();
      modify(data, res.first, res.second);
   }
 
   for (data_t i : data) std::cout << i << "\n";
}

#include <vector>
#include <random>
#include <time.h>
#include <math.h>
#include <omp.h>
 
#define SIZE 10000
double calculate(double x)
{
  return sin(x)*cos(x);
}
 
int main()
{
    // Итоговый вектор, данные храним на куче
    std::vector<double> acc(SIZE);
 
    // Начало параллельной секции
    #pragma omp parallel
    {
        // Промежуточный вектор
        std::vector<double> acc_private(SIZE);
        // Каждый поток использует свой генератор со своим зерном
        std::mt19937 gen(time(0)+1000*omp_get_thread_num());
        std::uniform_int_distribution<std::size_t> index_dis(0, SIZE-1);
 
        // Распределяем иттерации по потокам
        #pragma omp for
        for (size_t i=0; i<10000000; ++i) {
            size_t index = index_dis(gen);
            acc_private[index] += calculate((double)i/1000.0);
        }
        // Критическая секция со своей синхронизацией
        #pragma omp critical
        {
            for(size_t i=0; i<SIZE; ++i) {
                acc[i] = acc_private[i];
            }
        }
    }
    return 0;
}

        #pragma omp critical
        {
            for(size_t i=0; i<SIZE; ++i) {
                acc[i] = acc_private[i];
            }

 for (size_t i = 0; i < 10000000; i++)
        {
            index = rand() % SIZE;