Thread: Generating random numbers in parallel

Hi

I generate a series of random numbers in parallel (using OpenMP), but depending on what number of threads I invoke, I get a different result. From that I conclude that I have made an error somewhere!

Here is the MWE, which generates a number between 0..1 and increments a variable if the generated variable is larger than 0.5:

Code:

#include <random>
typedef std::uniform_real_distribution<double> distr_uni;

#define max_threads 1

using namespace std;

int main(int argc, char* argv[])
{
    int reservoir_counter, accepted_tube=0;
    double r;

    omp_set_num_threads(max_threads);
    #pragma omp parallel
    {
        mt19937 eng(0);
        distr_uni uniform(0, 1);


        #pragma omp for private(r, reservoir_counter) reduction(+:accepted_tube)
        for(reservoir_counter=0; reservoir_counter<100000; reservoir_counter++)
        {
            r = uniform(eng);
            if(r>0.5)
            {
                accepted_tube++;
            }
        }
    }
    cout << accepted_tube << endl;
    return 0;
}

When I set max_threads=1 I get 50027, but when max_threads=60 (on a machine that supports it....) I get 50440.

The sensitive RNG and its engine I have declared within the parallelized area, so it's not really clear to me where the error can possibly be.

Can someone spot my error that is apparently there?

Originally Posted by Niels_M

Do you agree with my overall structure of the program? I.e., that each thread gets its own engine in order to avoid "scrambling" them together?

Well, no. Pseudorandom number generators tend to be sequential (i.e. the (N-1)th value needs to be produced before the Nth) which means they can't be broken into parallel pieces.

You'll somehow need to anticipate the required starting condition (e.g. the first random value to be produced) for every thread.

Originally Posted by Niels_M

I meant that if I seed every engine uniquely, then my approach seems correct (?)

You're the one expecting the same output, regardless of number of threads. Seeding each "engine" separately (where, by engine, I assume you mean each thread) will not achieve that.

Originally Posted by rcgldr

You need to create a separate program cycle the RNG through the number of cycles expected for each thread to determine the starting seed for each thread if you want the multiple threads to use the same set of pseudo random numbers as a single thread.

Which is my point. That's the way to ensure the same output, I agree. Having to do a substantial portion of calculations sequentially and in advance negates a lot of the benefits of using threads.

Such is the nature of trying to make a sequential process (in the sense that later results depend on earlier ones) into a multithreaded process.