Распараллеливание

#include <iostream>
#include <cmath>
#include <ostream>
#include <cstdlib>
#include <Windows.h>
#include <conio.h>
#include <stdlib.h>
#include "omp.h"
#include <ctime>
#include <random>
using namespace std;
int main(){
    setlocale(0, "");
    srand(time(NULL));
    random_device rd;
    default_random_engine gener(rd());
    uniform_real_distribution<double> distr(-2, 2);
    int P;
    cout << "Количество потоков: P=  "; cin >> P;
    double x, y, z, V=0, V1=0;
    int n = 1000000;
    int num, i;
    int ch = n / (10 * P);
    float fTimeStart1 = clock() / (float)CLOCKS_PER_SEC;
#pragma omp parallel num_threads(P) private(i) reduction(+:V1){
        num = omp_get_thread_num();
 
#pragma omp for schedule(dynamic,ch)
        for (i = 0; i <= n; i++){
            x = distr(gener);
            y = distr(gener);
            z = distr(gener);
            if (x * x + y * y + z * z <= 4.0 && (x <= 0.0 || x >= 0.1) && (y <= 0.0 || y >= 0.1))
                V++;
            V1 = V / n;
        }
    }
    float fTimeStop = clock() / (float)CLOCKS_PER_SEC;
    printf("Время решения %f с.\n", fTimeStop - fTimeStart1);
    cout << "Result = " << V1;
    system("pause");
    return 0;
}

#pragma omp parallel ...
{
    random_device rd;
    default_random_engine gener(rd());
    uniform_real_distribution<double> distr(-2, 2);
 
    // ...
    #pragma omp for
    for(....) {
        // ... distr(gener)
    }
}

#pragma omp parallel num_threads(P) private(x,y,z,i) reduction(+: V)
    {
        random_device rd;
        default_random_engine gener(rd());
        uniform_real_distribution<double> distr(-2, 2);
        num = omp_get_thread_num();
#pragma omp for schedule(dynamic,ch)
        for (i = 0; i <= n; i++)
        {
            x = distr(gener);
            y = distr(gener);
            z = distr(gener);
            if (x * x + y * y + z * z <= 4.0 && (x <= 0.0 || x >= 0.1) && (y <= 0.0 || y >= 0.1))
            V++;    
        }
        V = V / n;
    }

#include <iostream>
#include <random>
 
#include <omp.h>
 
double calculate_figure_volume(uint64_t n_points, int n_threads)
{
    uint64_t k_points = 0;
    #pragma omp parallel num_threads(n_threads) reduction(+ : k_points)
    {
        std::random_device                     rd;
        std::default_random_engine             gener(rd());
        std::uniform_real_distribution<double> distr(-2.0, 2.0);
 
        #pragma omp for
        for (uint64_t i = 0; i < n_points; i++) {
            double x = distr(gener);
            double y = distr(gener);
            double z = distr(gener);
            if ((x * x + y * y + z * z <= 4.0) &&
                (x <= 0.0 || x >= 0.1) &&
                (y <= 0.0 || y >= 0.1))
                k_points++;
        }
    }
    return (4.0 * 4.0 * 4.0) * (double)k_points / (double)n_points;
}
 
int main()
{
    std::cout << "threads\tv\ttime\n";
    uint64_t n_points = 100'000'000ull;
    for (int n_threads = 1; n_threads <= 8; n_threads++) {
        double t_start = omp_get_wtime();
        double v       = calculate_figure_volume(n_points, n_threads);
        double t_end   = omp_get_wtime();
 
    std::cout << n_threads << "\t"
          << v << "\t"
          << (t_end - t_start) << "\n";
    }
    return 0;
}