Réentrance de boost RNG

Question

je une boucle qui devrait être parallélisé bien par insering un OpenMP pragma:

boost::normal_distribution<double> ddist(0, pow(retention, i - 1)); 
    boost::variate_generator<gen &, BOOST_TYPEOF(ddist)> dgen(rng, ddist); 
    // Diamond                 
    const std::uint_fast32_t dno = 1 << i - 1; 
// #pragma omp parallel for 
    for (std::uint_fast32_t x = 0; x < dno; x++) 
    for (std::uint_fast32_t y = 0; y < dno; y++) 
     { 
     const std::uint_fast32_t diff = size/dno; 
     const std::uint_fast32_t x1 = x*diff, x2 = (x + 1)*diff; 
     const std::uint_fast32_t y1 = y*diff, y2 = (y + 1)*diff; 
     double avg = 
      (arr[x1][y1] + arr[x1][y2] + arr[x2][y1] + arr[x2][y2])/4; 
     arr[(x1 + x2)/2][(y1 + y2)/2] = avg + dgen(); 
     } 

(sauf si je fais une erreur chaque exécution ne dépend pas d'autres du tout désolé pas. tout le code est inséré).

Cependant, ma question est - sont boost RNG thread-safe? Ils semblent se référer au code gcc pour gcc donc même si le code gcc est thread-safe, il peut ne pas être le cas pour d'autres plateformes.

Answer 1

En parcourant les archives de la liste de diffusion Boost donne:

Boost.Random ne maintient pas l'état global qui aurait besoin de protection multi-threading.

Boost.Random est thread-safe tant que vous n'accédez pas un objet donné de deux threads simultanément. (Accès deux objets différents est ok, aussi longtemps car ils ne partagent pas un moteur). Si vous avez besoin de ce type de sécurité, c'est trivial pour rouler cela par vous-même avec un emballage de mutex approprié.

Answer 2

Si vous êtes préoccupé par la sécurité des filetages, n'utilisez pas de boost, utilisez TRNG. C'est une bibliothèque parallèle de génération de nombres aléatoires conçue pour fonctionner sur le cluster TINA en Allemagne. Cela vous permet de créer plusieurs flux de nombres aléatoires. Il y a un tutoriel sur comment utiliser TRNG avec OpenMP ici http://www.lindonslog.com/programming/parallel-random-number-generation-trng/ comme vous essayez de le faire. Vous créez un nombre indépendant de flux en fonction du nombre de threads que vous utilisez, puis vous en tirez en utilisant le rang du thread. Tout est dans le tutoriel ci-dessus.