Warum ist lokaler Thread-Speicher so langsam?

Thread einheimischen in D sind wirklich schnell. Hier sind meine tests.

64-bit-Ubuntu, core i5, dmd v2.052
Compiler-Optionen: dmd -O -release -inline -m64

//this loop takes 0m0.630s
void main(){
    int a; //register allocated
    for( int i=1000*1000*1000; i>0; i-- ){
        a+=9;
    }
}

//this loop takes 0m1.875s
int a; //thread local in D, not static
void main(){
    for( int i=1000*1000*1000; i>0; i-- ){
        a+=9;
    }
}

So verlieren wir nur 1,2 Sekunden einer der CPU-Kerne pro 1000*1000*1000 thread-lokale Zugriffe.
Thread einheimischen sind aufgerufen mit %fs registrieren - es gibt also nur ein paar Prozessor-Befehle eingebunden:

Demontage mit objdump -d:

- this is local variable in %ecx register (loop counter in %eax):
   8:   31 c9                   xor    %ecx,%ecx
   a:   b8 00 ca 9a 3b          mov    $0x3b9aca00,%eax
   f:   83 c1 09                add    $0x9,%ecx
  12:   ff c8                   dec    %eax
  14:   85 c0                   test   %eax,%eax
  16:   75 f7                   jne    f <_Dmain+0xf>

- this is thread local, %fs register is used for indirection, %edx is loop counter:
   6:   ba 00 ca 9a 3b          mov    $0x3b9aca00,%edx
   b:   64 48 8b 04 25 00 00    mov    %fs:0x0,%rax
  12:   00 00 
  14:   48 8b 0d 00 00 00 00    mov    0x0(%rip),%rcx        # 1b <_Dmain+0x1b>
  1b:   83 04 08 09             addl   $0x9,(%rax,%rcx,1)
  1f:   ff ca                   dec    %edx
  21:   85 d2                   test   %edx,%edx
  23:   75 e6                   jne    b <_Dmain+0xb>

Vielleicht compiler könnte sogar noch schlauer und cache-thread-lokalen vor der Schleife ein register
und zurück zum thread-lokalen am Ende (es ist interessant zu vergleichen, mit gdc compiler),
aber auch jetzt noch Fragen sind sehr gut IMHO.

InformationsquelleAutor der Antwort Andriy

Wenn Sie nicht verwenden können compiler die Unterstützung für TLS, die Sie verwalten können, TLS selbst.
Ich baute eine wrapper-Vorlage für C++, so ist es leicht zu ersetzen Sie eine zugrunde liegende Implementierung.
In diesem Beispiel habe ich es umgesetzt für Win32.
Hinweis: Da Sie nicht erhalten, eine unbegrenzte Anzahl von TLS-Indizes je Prozess (zumindest unter Win32),
Sie sollten zeigen Sie auf heap-Blöcke groß genug sind, um alle thread-spezifischen Daten.
Auf diese Weise haben Sie eine minimale Anzahl von TLS Indizes und Verwandte Abfragen.
Im "besten Fall", Sie hätte nur 1 TLS-Zeiger zeigt auf eine private heap-block pro thread.

Kurz gesagt: zeigen Sie nicht auf einzelne Objekte, anstelle Punkt-zu-thread bestimmte, heap-Speicher/Behältnissen mit einem Inhalt von Objekt Zeiger auf eine bessere Leistung erzielen.

Nicht vergessen, Speicher freizugeben, wenn es nicht wieder verwendet.
Ich Tue dies, indem er einen thread in einer Klasse (wie Java funktioniert) und mit TLS von Konstruktor und Destruktor.
Desweiteren habe ich das speichern Häufig benutzter Daten wie der thread-handles und ID ' s als Schüler.

Verwendung:

für Typ*:
tl_ptr<Typ>

für const Typ*:
tl_ptr<const type>

für Typ* const:
const tl_ptr<Typ>

const Typ* const:
const tl_ptr<const type>

template<typename T>
class tl_ptr {
protected:
    DWORD index;
public:
    tl_ptr(void) : index(TlsAlloc()){
        assert(index != TLS_OUT_OF_INDEXES);
        set(NULL);
    }
    void set(T* ptr){
        TlsSetValue(index,(LPVOID) ptr);
    }
    T* get(void)const {
        return (T*) TlsGetValue(index);
    }
    tl_ptr& operator=(T* ptr){
        set(ptr);
        return *this;
    }
    tl_ptr& operator=(const tl_ptr& other){
        set(other.get());
        return *this;
    }
    T& operator*(void)const{
        return *get();
    }
    T* operator->(void)const{
        return get();
    }
    ~tl_ptr(){
        TlsFree(index);
    }
};

InformationsquelleAutor der Antwort sam

Haben wir gesehen, ähnliche performance-Probleme von TLS (auf Windows). Wir verlassen uns auf Sie für bestimmte kritische Vorgänge im inneren unseres Produkts "kernel'. Nach einiger Mühe habe ich beschlossen, zu versuchen und zu verbessern.

Ich bin froh sagen zu können, dass wir jetzt eine kleine API, Angebote > 50% Reduktion der CPU-Zeit für einen gleichwertigen Betrieb, wenn die callin-thread nicht "wissen", seine thread-id und > 65% zu reduzieren, wenn aufrufenden thread bereits erhalten hat, seine thread-id (vielleicht bei einigen anderen früheren Schritt der Verarbeitung).

Die neue Funktion ( get_thread_private_ptr() ) gibt immer einen Zeiger auf eine Struktur, die wir intern verwenden, um zu halten alle Arten, so brauchen wir nur eine pro thread.

Alles in allem denke ich, dass die Win32-TLS support ist wirklich schlecht gestaltete.

InformationsquelleAutor der Antwort Hugh