False sharing und stack Variablen

Question

Ich habe kleine, aber häufig verwendete Funktionsobjekte. Jeder Thread erhält eine eigene Kopie. Alles ist statisch zugeordnet. Kopien teilen keine globalen oder statischen Daten. Muss ich diese Objekte vor falscher Freigabe schützen?

Vielen Dank. EDIT: Hier ist ein Spielzeug-Programm, das Boost.Threads verwendet. Kann eine falsche Freigabe für das Feld Daten auftreten?

#include <boost/thread/thread.hpp> 

struct Work { 
    void operator()() { 
     ++data; 
    } 

    int data; 
}; 

int main() { 
    boost::thread_group threads; 
    for (int i = 0; i < 10; ++i) 
     threads.create_thread(Work()); 
    threads.join_all(); 
} 

Answer 1

False Freigabe zwischen Threads ist, wenn 2 oder mehr Threads die gleiche Cache-Zeile verwenden.

z. :

struct Work { 
    Work(int& d) : data(d) {} 
    void operator()() { 
     ++data; 
    } 

    int& data; 
}; 

int main() { 
    int false_sharing[10] = { 0 }; 
    boost::thread_group threads; 
    for (int i = 0; i < 10; ++i) 
     threads.create_thread(Work(false_sharing[i])); 
    threads.join_all(); 

    int no_false_sharing[10 * CACHELINE_SIZE_INTS] = { 0 }; 
    for (int i = 0; i < 10; ++i) 
     threads.create_thread(Work(no_false_sharing[i * CACHELINE_SIZE_INTS])); 
    threads.join_all(); 
} 

Die Threads in dem ersten Block leiden falsches Teilen. Die Threads im zweiten Block nicht (Danke an CACHELINE_SIZE).

Daten auf dem Stapel sind immer "weit" von anderen Threads entfernt. (Z. B. unter Windows, mindestens ein paar Seiten).

Mit Ihrer Definition eines Funktionsobjekts kann eine falsche Freigabe angezeigt werden, da die Instanzen Work auf dem Heap erstellt werden und dieser Heapspeicher innerhalb des Threads verwendet wird.

Dies kann dazu führen, dass mehrere Work Instanzen nebeneinander liegen und somit die gemeinsame Nutzung von Cache-Zeilen verursachen können.

Aber ... Ihre Stichprobe macht keinen Sinn, weil Daten nie außerhalb berührt werden und so falsches Teilen unnötig herbeigeführt wird.

Der einfachste Weg, um solche Probleme zu vermeiden, besteht darin, Ihre 'gemeinsamen' Daten lokal auf dem Stapel zu kopieren und dann an der Stapelkopie zu arbeiten. Wenn Ihre Arbeit abgeschlossen ist, kopieren Sie sie zurück in die Ausgabe var.

Z. B:

struct Work { 
    Work(int& d) : data(d) {} 
    void operator()() 
    { 
     int tmp = data; 
     for(int i = 0; i < lengthy_op; ++i) 
      ++tmp; 
     data = tmp; 
    } 

    int& data; 
}; 

Dies verhindert, dass alle Probleme mit Teilen.

Answer 2

Ich fühle mich nicht ganz sicher mit den Details, aber hier ist mein nehmen:

(1) Ihr vereinfachtes Beispiel gebrochen wird, da boost create_thread eine Referenz erwartet, übergeben Sie eine temporäre.

(2) Wenn Sie vector<Work> mit einem Element für jeden Thread verwenden oder sie nacheinander im Speicher haben, wird die falsche Freigabe auftreten.

Answer 3

Ich habe ein gutes Stück Forschung gemacht und es scheint, dass es keine Silberkugellösung zu falschem Teilen gibt. Hier ist, was ich (dank Christopher) habe: 1) Pad Ihre Daten von beiden Seiten mit unbenutzten oder weniger häufig verwendeten Sachen. 2) Kopieren Sie Ihre Daten in den Stapel und kopieren Sie sie zurück, nachdem alle harte Arbeit erledigt ist. 3) Verwenden Sie die Cache-Aligned-Speicherzuweisung.