Where to initialize random seed for use through multiple random modules?

Question

So, every time I am developing something big, with multiple modules coming together to build a final functionality, I've been wondering the same question: Where to initialize the random seed if more than 1 module needs to use the random function?

If I have a certain class that needs random (e.g. class that initializes itself by sorting an input array with self-implemented quicksort, so I would need a random for the pivot choice), I usually have a private static bool isRandOn; variable, so before I start the random pivot choice, I check that variable and do srand(time(NULL)); if the random is not on yet.

If I have a ton of utility functions in a namespace, I do a very similar thing: I put such a variable in an anonymous namespace inside my utils library, and do the more-or-less same thing as with a class.

The problem I have is when combining those modules. All by it self, I know each module will not set the seed more than once. But, I want to be able to use a various amount of my modules together, I want other people to be able to use one or more of my modules independent of the others...

So, what is the best way to handle multiple random-seed-needing modules? Set the seed in each module? Do not set the seed at all but instead document the usage of random and make the user initialize the seed if he wants to use the module? Something third?

Answer 1

I would suggest using Boost.Random rather than relying on some global state shared at the program level.

Boost.Random has two concepts:

• Engine: which generates random numbers
• Distributions: which adapt the result from the engines to provide results fitted to a certain distribution (normal, poisson, gaussian, ...)

Each module may then have its own Engine, or indeed several of them: there is no specific reason for a given Engine to be shared between several different functions within the same module.

As a final word: whatever you do make sure you have a way to set the seed(s) deterministically for bug repro purposes. Bug repro may benefit from having multiple engines (isolation of the parts helps).

Answer 2

You can make a special "module" for random number generation, and use that from the other parts of your application. Then you only seed once when the random-number module is initialized.

Answer 3

@penelope gave a correct answer. There is some complex algorithm for generating pseudo-random number sequence behind rand(). This is like some function rand_func(prev_rand), which generates next pseudo-random number from previous. For the first time you call srand(time(NULL)), which sets prev_rand to in these terms supposing time(NULL) to be quite undetermined. So you can safely call srand() (which sets ) multiple times.

The special issue is if you neet predictable pseudo-random sequences: for example, srand(0) etc. But it seems to be not your case.

Answer 4

The best way I came with to avoid repeating always the same initial random sequence is to do the following in each module where you call the random() function:

/* Global variable to remember if we already initialized the PRNG */
static bool seed_initialized = false;

/* Helper function to avoid having always the same sequence again and again */
static void
prng_init (unsigned int seed)
{
  if (!seed_initialized)
    {
      srandom (seed);
      seed_initialized = true;
    }
}

And, each time you use random() in a function you start the function with something like:

 /* Initializing PRNG with a 'reasonably strong' random seed for our purpose */
 prng_init (time (NULL) - getpid());

This way, you ensure that:

1. You will initialize your PRNG at least the first time you go through;

2. You will never reinitialize the random sequence more than once within the module.

Hope this help!