Question

我的代码现在有一个循环调用蒙特卡洛函数来计算多个样本的简单积分（y = x，从0到1），并将总时间和积分值写入文本文件。然后循环增加线程数并继续向前。现在大约有8个线程，时间达到2.6秒左右。循环迭代64个线程，我看到没有减速超过.2秒，甚至有时加速。

对于循环调用蒙特卡罗方法，增加线程数：

//this loop will iterate the main loop for a number of threads from 1 to 16
    for (int j = 1; j <= 17; j++)
    {
        //tell user how many threads are running monte-carlo currently
        cout << "Program is running " << number_threads << " thread(s) currently." << endl;

        //reset values for new run
        num_of_samples = 1;
        integration_result = 0;

        //this for loop will run throughout number of circulations running through monte-carlo
        //and entering the data into the text folder
        for (int i = 1; i <= iteration_num; i++)
        {
            //call monte carlo function to perform integration and write values to text
            monteCarlo(num_of_samples, starting_x, end_x, number_threads);

            //increase num of samples for next test round
            num_of_samples = 2 * num_of_samples;
        } //end of second for loop

        //iterate num_threads
        if (number_threads == 1)
            number_threads = 2;
        else if (number_threads >= 32)
            number_threads += 8;
        else if (number_threads >= 16)
            number_threads += 4;
        else
            number_threads += 2;
    } //end of for loop

蒙特卡罗的平行部分：

int num_threads;
    double x, u, error_difference, fs = 0, integration_result = 0; //fs is a placeholder to hold added values of f(x)
    vector< vector<double>> dataHolder(number_threads, vector<double>(1)); //this vector will hold temp values of each thread

    //get start time for parallel block of code
    double start_time = omp_get_wtime();

    omp_set_dynamic(0);     // Explicitly disable dynamic teams
    omp_set_num_threads(number_threads); // Use 4 threads for all consecutive parallel regions

#pragma omp parallel default(none) private(x, u) shared(std::cout, end_x, starting_x, num_of_samples, fs, number_threads, num_threads, dataHolder)
    {
        int i, id, nthrds;
        double temp = fs;

        //define thread id and num of threads
        id = omp_get_thread_num();
        nthrds = omp_get_num_threads();

        //initilialize random seed
        srand(id * time(NULL) * 1000);

        //if there is only one thread
        if(id == 0)
            num_threads = nthrds;

        //this for loop will calculate a temp value for fs for each thread
        for (int i = id; i < num_of_samples; i = i + nthrds)
        {
            //assign random number under integration from 0 to 1
            u = fRand(0, 1); //random number between 0 and 1
            x = starting_x + (end_x - starting_x) * u;

            //this line of code is from Monte_Carlo Method by Alex Godunov (February 2007)
            //calculuate y for reciporical value of x and add it to thread's local fs
            temp += function(x);
        }

        //place temp inside vector dataHolder
        dataHolder[id][0] = temp;

        //no thread will go beyond this barrier until task is complete
#pragma omp barrier

        //one thread will do this task
#pragma omp single
        {
            //add summations to calc fs
            for(i = 0, fs = 0.0; i < num_threads; i ++)
                fs += dataHolder[i][0];
        } //implicit barrier here, wait for all tasks to be done
    }//end of parallel block of code

Answer 1

在使用光散射的简单Monte-Carlo步行实现相同类型的并行化之后，我能够获得相当少的回报。我认为由于集成计算如此简单，线程本身几乎没有单独进行，因此它们的开销相对较小，因此这里缺乏收益递减。如果其他人有任何其他信息对此问题有用，请随时发布。否则我会接受这个作为我的答案。

openMP缺少具有更高线程数的收益递减

1 个答案: