Question

In my code, I have a function that operates with static random engine generators and I would like to be able to throw an error if the user tries to call this function from threads different from the main one.

As an example, if you consider the following function :

void f()
{
    if (/* SOMETHING */) {
        throw std::future_error("ERROR = f() : cannot be executed in parallel");
    }
}

what would be /* SOMETHING */ ?

Answer 1

A much, much, much better solution would be to make your retrieval of random numbers thread-safe.

This can be done one of two ways:

1. Acquire a mutex on retrieval of random numbers.
2. Give any threads that need to generate random numbers their own random object.

Lets talk about #1. Since you propose wrapping your calls to get random numbers, it isn’t too farfetched to wrap those calls with a mutex. Rather than simply presenting the problem to the user at runtime (which is generally a really poor development choice), we’ve just solved the problem instead. The only downside is that we’ve slowed down calls to our random number generator — which is probably acceptable, but if it isn’t…onto option #2.

And, for #2… You say that this is a static random number generator. Perhaps that means that you cannot make another copy of it, but this is worth mentioning anyway. rand and srand are like this. But, if you are using something like C++11’s std::uniform_int_distribution, you should have no problem creating a copy for each thread. (Perhaps consider std::thread_local if you cannot find a good place to put each thread’s copy.)