Warum ist std :: atomic & lt; bool & gt; viel langsamer als volatile bool?

Habe ich mit volatile bool seit Jahren für die Ausführung des Threads Kontrolle und es funktionierte gut

//in my class declaration
volatile bool stop_;

-----------------

//In the thread function
while (!stop_)
{
     do_things();
}

Nun, da c++11-Unterstützung für Atomare Operationen, die ich beschlossen, zu versuchen, statt

//in my class declaration
std::atomic<bool> stop_;

-----------------

//In the thread function
while (!stop_)
{
     do_things();
}

Aber es ist um mehrere Größenordnungen langsamer als die volatile bool!

Einfacher Testfall die ich geschrieben habe, dauert etwa 1 Sekunde, um mit volatile bool Ansatz. Mit std::atomic<bool> allerdings warte ich schon seit über 10 Minuten und gab auf!

Habe ich versucht zu verwenden memory_order_relaxed Flagge mit load und store den gleichen Effekt.

Meine Plattform:
Windows 7 64-bit
MinGW gcc 4.6.x

Was ich falsch mache?

UPD

Ja, ich weiß, dass die flüchtigen nicht stellen Sie eine thread-sichere variable. Meine Frage ist nicht zu flüchtig, es geht darum, warum atomic ist lächerlich langsam.

UPD2
@alle, vielen Dank für Ihre Kommentare - ich werde versuchen, all das schlug mich, wenn ich meine Maschine heute Abend.

Kommentar zu dem Problem
Sie sind Missverständnis, was volatile wirklich tut. volatile nicht die Dinge machen, thread-sicher, noch ist es eine Atomare operation. Kommentarautor: Mysticial
assert(your_atomic_variable.is_lock_free())? Kommentarautor: R. Martinho Fernandes
Der alte code ist falsch, es "geklappt" durch Zufall. Was ist besser: korrigieren oder zu schnell? Kommentarautor: Dietrich Epp
Bitte posten Sie Ihre einfachen Testfall (wenn Sie wollen sinnvolle Kommentare). Kommentarautor: CB Bailey
@Mysticial: Leider volatile durch Zufall geschieht, um speichern und laden von atomic auf x86. Kommentarautor: Jan Hudec

InformationsquelleAutor der Frage | 2012-10-30

  1. 29

    Code von "Olaf Dietsche"

     USE ATOMIC
 real   0m1.958s
 user   0m1.957s
 sys    0m0.000s

 USE VOLATILE
 real   0m1.966s
 user   0m1.953s
 sys    0m0.010s

    WENN SIE GCC VERWENDEN, KLEINERE 4.7

    http://gcc.gnu.org/gcc-4.7/changes.html

    Unterstützung für Atomare Operationen angeben, die C++11/C11 memory-Modell wurde Hinzugefügt. Diese neue __Atomare Routinen ersetzen die bestehenden __sync-built-in-Routinen.

    Atomic support ist ebenfalls verfügbar, für Speicherblöcke. Lock-freie Anweisungen werden benutzt, wenn ein Speicher-block der gleichen Größe und Ausrichtung, wie Sie einen unterstützten Datentyp "integer". Atomare Operationen, die keine lock-free-support-Links sind als Funktionsaufrufe. Eine Reihe von library-Funktionen steht auf der GCC-atomic-wiki in der "Externen Atomics Bibliothek" Abschnitt.

    Also ja .. einzige Lösung ist ein upgrade auf GCC 4.7

    InformationsquelleAutor der Antwort KoKuToru

  2. 12

    Da bin ich neugierig, das ich es selber getestet auf Ubuntu 12.04, AMD 2.3 GHz, gcc 4.6.3.

    #if 1
#include <atomic>
std::atomic<bool> stop_(false);
#else
volatile bool stop_ = false;
#endif

int main(int argc, char **argv)
{
    long n = 1000000000;
    while (!stop_) {
        if (--n < 0)
            stop_ = true;
    }

    return 0;
}

    Zusammengestellt g++ -g -std=c++0x -O3 a.cpp

    Obwohl, gleichen Schluss wie @aleguna:

    • nur bool:

      real 0m0.004s

      user 0m0.000s

      sys 0m0.004s

    • volatile bool:

      $ time ./ein.aus

      real 0m1.413s

      user 0m1.368s

      sys 0m0.008s

    • std::atomic<bool>:

      $ time ./ein.aus

      real 0m32.550s

      Benutzer 0m32.466s

      sys 0m0.008s

    • std::atomic<int>:

      $ time ./ein.aus

      real 0m32.091s

      Benutzer 0m31.958s

      sys 0m0.012s

    InformationsquelleAutor der Antwort Olaf Dietsche

  3. 2

    Meine Vermutung ist, dass dies eine hardware-Frage.
    Wenn Sie schreiben, der flüchtig Sie sagen, dass der compiler nicht davon ausgehen, etwas über die variable, aber wie ich es verstehe, wird die hardware immer noch behandeln Sie es wie eine normale variable. Dies bedeutet, dass die variable wird in den cache die ganze Zeit.
    Wenn Sie atomic, die Sie verwenden speziellen hardware-Anweisungen, die wahrscheinlich bedeutet, dass die variable fetch aus Hauptspeicher jedes mal, wenn es verwendet wird.
    Der Unterschied im timing ist im Einklang mit dieser Erklärung.

    InformationsquelleAutor der Antwort Olle Lindeberg

Schreibe einen Kommentar