C++11 Thread-Sicherheit von Zufallsgeneratoren

In C++11 gibt es eine Reihe neuer Random number generator-Motoren und-Verteilung Funktionen. Sie sind thread-sicher? Wenn Sie teilen sich eine einzige zufällige Verteilung und Motor zwischen mehreren threads, ist es sicher und wird Sie noch erhalten Zufallszahlen? Das Szenario, das ich Suche ist so etwas wie,

void foo() {
    std::mt19937_64 engine(static_cast<uint64_t> (system_clock::to_time_t(system_clock::now())));
    std::uniform_real_distribution<double> zeroToOne(0.0, 1.0);
#pragma omp parallel for
    for (int i = 0; i < 1000; i++) {
        double a = zeroToOne(engine);
    }
}

Verwendung von OpenMP oder

void foo() {
    std::mt19937_64 engine(static_cast<uint64_t> (system_clock::to_time_t(system_clock::now())));
    std::uniform_real_distribution<double> zeroToOne(0.0, 1.0);
    dispatch_apply(1000, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^(size_t i) {
        double a = zeroToOne(engine);
    });
}

mit libdispatch.

InformationsquelleAutor user1139069 | 2012-01-11

c++c++11 grand-central-dispatch openmp thread-safety

26

Den C++11 standard-Bibliothek ist weitgehend thread-sicher. Die thread-Sicherheit garantiert auf PRNG-Objekte das gleiche wie für Container. Genauer gesagt, da der PRNG Klassen sind alle pseudo-random, d.h. Sie erzeugen eine deterministische Sequenz basierend auf einem bestimmten ist-Zustand, es gibt wirklich keinen Raum zu spähen oder Stossen auf alles, was außerhalb der enthaltenen Zustand (das ist auch sichtbar für den user).

Nur als Container sperren müssen, um Sie sicher zu teilen, müsstest du den PRNG-Objekt. Dies würde, machen Sie es langsam und nicht deterministisch. Ein Objekt pro thread wäre besser.

§17.6.5.9 [res.auf.Daten.Rennen]:

1 Dieser Abschnitt spezifiziert Anforderungen, Implementierungen erfüllen
um zu verhindern, dass Daten Rennen (1.10). Jeder standard-Bibliothek-Funktion ist
erfüllen jede Anforderung, sofern nicht anders angegeben. Implementierungen können
verhindern, dass Daten-Rennen in Fällen, andere als die unten angegebenen.

2 Eine C++ - standard-library-Funktion darf nicht direkt oder indirekt
access-Objekte (1.10) zugänglich, die von anderen threads als dem aktuellen
thread, es sei denn, die Objekte sind direkt oder indirekt über die
Funktion, die die Argumente, einschließlich dieser.

3 Eine C++ - standard-library-Funktion darf nicht direkt oder indirekt
Objekte ändern (1.10) zugänglich, die von anderen threads als dem aktuellen
thread, es sei denn, die Objekte sind direkt oder indirekt über die
Funktion ist non - const-Argumenten, einschließlich dieser.

4 [ Hinweis: Dies bedeutet, dass zum Beispiel-Implementierungen, die Sie nicht verwenden
statisches Objekt für interne Zwecke ohne Synchronisation, da es
könnte eine Daten-Rennen, auch in Programmen, die nicht explizit freigeben
Objekte betweenthreads. —endnote]

5 Eine C++ - standard-Bibliothek-Funktion ist nicht auf Objekte indirekt
erreichbar über Argumente oder über Elemente des Containers
Argumente, außer durch aufrufen der Funktionen erforderlich, die von seiner Spezifikation
auf diesen container-Elementen.

6 Operationen auf Iteratoren erhalten durch den Aufruf einer standard-Bibliothek
container-oder string-member-Funktion kann den Zugriff auf die zugrunde liegenden
container, sondern wird sich nicht ändern. [Hinweis: In bestimmten, container
Operationen, Iteratoren ungültig Konflikt mit Operationen auf
Iteratoren im Zusammenhang mit diesem container. — Ende Hinweis ]

7-Implementierungen können teilen Ihre eigenen internen Objekte zwischen threads
wenn die Objekte für die Nutzer nicht sichtbar und geschützt sind gegen Daten
Rennen.

8 Sofern nicht anders angegeben, C++ - standard-library-Funktionen sind
alle Operationen nur innerhalb des aktuellen Threads, wenn diese
Operationen haben Auswirkungen, die sichtbar sind (1.10) für die Nutzer.

9 [ Hinweis: Dies ermöglicht die Implementierungen der Operationen parallelisieren, wenn
es gibt keine sichtbaren Nebenwirkungen. — Ende Hinweis ]
- Das ist im Grunde, was ich dachte, es war nicht thread-sicher. Ist es ok das zu teilen, die distribution Objekt std::uniform_real_distribution<double> zeroToOne(0.0, 1.0) Menge threads und verwenden Sie einen Motor pro-thread?
- Nein, sicher nicht. Obwohl auf den ersten Blick eine Verteilung Objekts kann seinen job tun, indem Sie einfach delegieren jedem Aufruf der engine-Objekt, ohne zur Wahrung der inneren Zustand, wenn Sie darüber nachdenken ein Motor, der nicht genügend zufällige bits müssen möglicherweise zweimal aufgerufen werden. Aber zweimal (oder einmal) zuviel, so könnte es besser sein, erlauben Zwischenspeicherung von überschüssigem zufällige bits. §26.5.1.6 "Random number distribution requirements" dies erlaubt, die Verteilung von Objekten, die speziell haben Zustand ändert sich mit jedem Aufruf. Deshalb sollte Sie behandelt werden, als Teil der Motor für die Verriegelung Zwecke.
InformationsquelleAutor Potatoswatter
3

Standard (gut N3242) scheint machen keine Erwähnung von random number generation, Rennen kostenlos (außer, dass rand ist das nicht), so ist es nicht(es sei denn ich habe etwas übersehen). Außer es gibt wirklich keinen Sinn, mit Ihnen threadsave, denn es bestünde eine relativ kräftige overhead (im Vergleich zu der generation der zahlen selbst zumindest), ohne wirklich etwas gewinnen.

Außerdem sehe ich nicht wirklich einen Vorteil og mit einem gemeinsam genutzten Zufallszahlengenerator auf, anstatt ein pro-thread, die jeweils geringfügig anders initialisiert (z.B. aus den Ergebnissen von einem anderen generator oder die aktuelle thread-id). Afterall, die Sie vermutlich gar nicht darauf verlassen, dass der generator die Erzeugung einer bestimmten Sequenz mit jedem Lauf sowieso. Also ich würde ändern Sie Ihren code so etwas wie dieses (für openmp keine Ahnung libdispatch):
```
void foo() {
    #pragma omp parallel
    {
    //just an example, not sure if that is a good way too seed the generation
    //but the principle should be clear
    std::mt19937_64 engine((omp_get_thread_num() + 1) * static_cast<uint64_t>(system_clock::to_time_t(system_clock::now())));
    std::uniform_real_distribution<double> zeroToOne(0.0, 1.0);
    #pragma omp for
        for (int i = 0; i < 1000; i++) {
            double a = zeroToOne(engine);
        }
    }
}
```
- Eigentlich, wenn Sie den gleichen RNG ist das Lesen von verschiedenen threads, die Sie nicht verlassen Sie sich auf immer die selbe Reihe von Zufallszahlen, die auch für einen festen seed weil Planung kann dazu führen, ein anderes, um den Zugang zu der RNG aus den verschiedenen threads auf getrennte Läufe. Also besonders wenn Sie brauchen, reproduzierbare Zufallszahl-Sequenzen, Sie sollten nicht teilen RNGs zwischen threads.
- Das hängt davon ab, wie definiert man immer die gleiche Reihenfolge. Ich würde sagen, man wird die gleiche Sequenz (globaly), seine nur, dass die threads werden sehen, verschiedene Teile es mit jedem Lauf.
- Dies gab mir einen guten Start! Ein obs, kann es eine gute Idee, um einen Ausgangswert angeben, anstatt die Systemzeit+Datum (wenn Sie die Pflege über die Reproduzierbarkeit).
InformationsquelleAutor Grizzly
1

Den Dokumentation macht keine Erwähnung von thread-Sicherheit, so würde ich annehmen, dass Sie Sie nicht thread-sicher.
- Nicht erwähnt wird auf cppreference.com heißt nicht, dass es nicht so ist.
InformationsquelleAutor Mitch Wheat

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.