Gibt es irgendwelche Auswirkungen auf die Operationen mit den Variablen unabhängig von Atomlast verbrauchen?

Question

Wie bekannt ist, gibt es 6 std::memory_order's und 2 seine:

• acquire-semantische für Lasten - vermeidet Neuordnungs Last-Load und Lade-Speichere
• Release-semantische für den Speicher - vermeidet Neuordnungs Shop -Speichern und Lade-Speichere

Ie

static std::atomic<int> X; 
static int L, S; 
... 

void thread_func() 
{ 
    int local1 = L; // load(L)-load(X) - !!! can be reordered with X !!! 
    S = local1;  // store(S)-load(X) - !!! can be reordered with X !!! 

    int x_local = X.load(std::memory_order_acquire); // load(X) 

    int local2 = L; // load(X)-load(L) - can't be reordered with X 
    S = local2;  // load(X)-store(S) - can't be reordered with X 
} 

Aber welche von Nachbestellungen über load(X) kann konsumieren-semantische sein: für acquire-semantische, nur S = local1; kann nach X.load(std::memory_order_acquire); ausgeführt werden?

static std::atomic<int *> X; 
static int L1, L2, S1, S2; 
static int L, S; 
... 

void thread_func() 
{ 
    int *x_ptr_local = new int(1); 


    int local1 = L1; // load(L1)-load(X) - !!! can be reordered with X !!! 
    S1 = local1;  // store(S1)-load(X) - !!! can be reordered with X !!! 

    int dependent_x1 = *x_ptr_local; // load(x_ptr)-load(X) - !!! can be reordered with X !!! 
    S = dependent_x1;     // store(S)-load(X) - !!! can be reordered with X !!! 

    x_ptr_local = X.load(std::memory_order_consume); // load(X) 

    int dependent_x2 = *x_ptr_local; // load(X)-load(x_ptr) - can't be reordered with X 
    S = dependent_x2;     // load(X)-store(S) - can't be reordered with X 

    int local2 = L2; // load(X)-load(L2) - !!! can be reordered with X !!! 
    S2 = local2;  // load(X)-store(S2) - !!! can be reordered with X !!! 
} 

Ist es wahr, dass nur Operationen mit dependent_x2 nicht über X.load(std::memory_order_consume) neu geordnet werden können?

Und alle Operationen mit Variablen L1, L2, S1, S2 und dependent_x1 kann über X.load(std::memory_order_consume) erst nachbestellt werden - das heißt kann entweder vor oder nach X.load(std::memory_order_consume) durchgeführt werden, ist es nicht?

Answer 1

memory_order_consume wird verwendet, um die Reihenfolge der Datenabhängigkeiten vom atomaren Objekt selbst zu erhalten, ohne eine schwerere Synchronisation wie die von memory_order_acquire eingeführte zu verwenden. Mit memory_order_acquire, alle Speicheroperationen nach der acquire - abhängig von der atomaren Variablen oder sonst - sind verboten, vor ihm neu bestellt, während memory_order_consume nur die Neuordnung von abhängigen Anweisungen hemmt. Dies ist vorteilhaft für schwächer geordnete Architekturen wie ARM und PowerPC, die die Anordnung von datenabhängigen Anweisungen ohne explizite Barriere garantieren.

Seit memory_order_consume befasst sich mit Datenabhängigkeiten, die meisten Anwendungsfälle davon beinhalten eine std::atomic<T*>. Producer-Threads können eine vollständige Datenstruktur erstellen und die Adresse dieser Datenstruktur unter Verwendung von memory_order_release im Atomzeiger veröffentlichen. Consumer-Threads laden dann den Atomzeiger mit memory_order_consume und können eine Datenabhängigkeit mit den Speichern des Writerthreads herstellen, wenn sie den Zeiger datenabhängig verwenden, z. B. durch Dereferenzierung. Der Standard garantiert, dass alle abhängigen Lasten die Speicher des Writer-Threads widerspiegeln. Da die Ladung der atomaren Variablen über memory_order_consume erfolgt, können jedoch keine Garantien für den Status unabhängiger Variablen aus der Perspektive des Leserthreads abgegeben werden.

In Ihrem ersten Beispiel kann keine der Lasten nach memory_order_acquire vor ihm neu geordnet werden. In Ihrem zweiten Beispiel ist jedoch jede Neuordnung, die nicht von X oder dem geladenen Wert davon abhängig ist, faires Spiel. Nämlich, int dependent_x2 = *x_ptr_local; (und die entsprechende Last von dependent_x2) sind garantiert in Bezug auf X geordnet bleiben, aber das ist es. Alle anderen Nachbestellungen sind möglich.