Zugriff auf thread-lokale aus einem anderen thread

Wie kann ich das Lesen/schreiben einer thread-lokalen variable von einem anderen thread aus? Das ist im Thread, möchte ich den Zugriff auf die variable in Thread B thread local storage-Bereich. Ich weiß die ID von dem anderen thread.

Die variable ist deklariert als __thread im GCC. Zielplattform ist Linux, aber die Unabhängigkeit wäre schön (GCC-spezifisch ist okay aber).

Fehlt ein thread-start-hook-es gibt keinen Weg, ich kann einfach die Spur dieser Wert am Anfang jedes Threads. Alle threads müssen verfolgt werden, auf diese Weise (nicht nur speziell gestartet sind).

Einer höheren Ebene wrapper wie boost thread_local_storage oder mit Hilfe der pthread-keys ist keine option. Ich verlange, dass die Leistung mit einem wahren __thread lokale variable.

ERSTE ANTWORT IST FALSCH: Man kann nicht Globale Variablen verwenden für das, was ich tun möchte. Jeder thread muss seine eigene Kopie der Variablen. Außerdem müssen diese Variablen werden __thread Variablen aus performance-Gründen (eine ebenso effiziente Lösung wäre auch okay, aber ich kenne keine). Ich habe auch keine Kontrolle über die thread-Eintrag Punkte, es gibt also keine Möglichkeit für solche threads zu registrieren jede Art von Struktur.

Thread-Lokalen ist nicht privat: ein Weiteres Missverständnis über thread-lokalen Variablen. Diese sind in keiner Weise irgendeine Art von private variable für den thread. Sie sind Global adressierbaren Speicher, mit der Einschränkung, dass Ihre Lebensdauer ist gebunden an den thread. Jede Funktion, aus jedem thread, wenn da ein Zeiger auf diese Variablen können Sie verändern. Die Frage oben ist im wesentlichen darüber, wie zu bekommen, dass die Zeiger-Adresse.

Natürlich, die Allgemeine Idee ist, dass Sie es nicht können. 🙂 Warum lassen Sie nicht jeden thread seinen privaten Wert mit einem nicht-lokalen Daten-Struktur?
vermutlich __thread sagt der compiler er verwenden kann, CPU-Register. wenn dem so ist, würde der direkte Zugriff nicht möglich wegen hardware-Einschränkungen.
die einheimischen sind letztendlich auch nur Standorte in den normalen Speicher. Sie können die Adresse und gib ihn auf einen anderen thread zugreifen.
das ist mein Kommentar über das fehlen eines start-thread Haken. Ich habe nicht die Möglichkeit abzufangen, alle thread erstellen und registrieren Sie die variable. Ebenso kann ich nicht den overhead eines Funktionsaufrufs für jeden lese-Zugriff auf die variable aus dem besitzenden thread.
Ich wollte auch Fragen eine sehr ähnliche Frage, aber für die Windows-Implementierung von thread local storage. Hast du durch Zufall finden die Antwort/Lösung auf deine Frage?
Es riecht wie etwas, das umgesetzt werden kann in eine Bibliothek. Die Art der thread_local ist ein wrapper um das, was Sie eigentlich wollen, damit Konstruktor und Destruktor können sich registrieren/de-registrieren der thread-Speicher-Adresse der Wert. I. e. anstatt das zu tun thread_local int Sie tun, etwas entlang der Linien von thread_local thread_registration<int>. Ich werde mich wohl mal an etwas zu schreiben wie diese bald.

InformationsquelleAutor edA-qa mort-ora-y | 2011-03-15

c++gcc linux multithreading thread-local-storage

15

Wenn Sie möchten, dass die thread-lokalen Variablen, die nicht-thread-lokaler, warum nicht Sie verwenden Sie Globale Variablen statt?

Wichtige Klarstellung!

Ich behaupte nicht, dass Sie verwenden einen einzigen globalen ersetzen Sie eine thread-lokale variable. Ich 'm darauf hindeutet, der mit einem einzigen globalen array oder andere geeignete Ansammlung von Werten ersetzen Sie eine thread-lokale variable.

Haben Sie, um eine Synchronisation natürlich, aber da Sie wollen, dass ein Wert geändert wurde in thread A zu thread B es gibt keinen Weg daran vorbei, dass.

Update:

Den GCC-Dokumentation auf __thread sagt:

Wenn der address-of-operator ist
angewendet, um eine thread-lokale variable, es
ist der zur Laufzeit ausgewertet wird und gibt
die Adresse des aktuellen Threads
Instanz der variable. Eine Adresse
so erhalten kann verwendet werden, von jedem thread.
Wenn ein thread beendet wird, werden alle Zeiger
thread-lokale Variablen, die
thread ungültig.

Daher, wenn Sie darauf bestehen, gehen auf diese Weise ich kann mir vorstellen es ist möglich, die Adresse einer thread-lokalen variable aus dem thread es gehört, gerade nach dem thread erzeugt. Sie könnten dann speichern einen Zeiger auf die Speicheradresse zu einer Karte (thread-id => Zeiger), und lassen Sie andere threads Zugriff auf die variable auf diese Weise. Dies setzt Voraus, dass Sie den code für die erzeugte thread.

Wenn Sie wirklich abenteuerlich, Sie könnten versuchen, zu Graben, bis die Informationen auf ___tls_get_addr (start von dieses PDF, die im Zusammenhang mit der oben genannten GCC-docs). Aber dieser Ansatz ist so hoch, compiler und Plattform spezifisch und so fehlt in der Dokumentation, die es werden sollten, wodurch Alarm ausgelöst werden, in jeden Kopf.
- Dies geht nicht auf meine Frage.
- mort-ora-y: Die Frage, wie ich ihn verstehe, liest sich wie "wie kann ich mit einem hammer ein Loch zu Graben?". Deshalb schlage ich vor, mit einem entsprechenden Werkzeug für den job.
- mort-ora-y: diese Antwort richtet sich Ihre Frage vollkommen, meiner Meinung nach. TLS per definition bedeutet "ich will nicht teilen Sie diese zwischen meine threads", und es nimmt der compiler zusätzliche Arbeit, um sicherzustellen, dass die Eigenschaft. Den Ratschlag, einfach eine normale, global, anstatt zu versuchen zu hacken um TLS Sinn macht. Ansonsten ist es, wie wenn man Salz in Ihren Kaffee und dann Gießen Sie es in den Ausguss, weil Sie nicht wie Salz in Ihren Kaffee.
- TLS können geteilt werden zwischen den threads: es ist adressierbaren Speicher, wie alle anderen. Ich bin auf der Suche nach einem Weg, um entdecken Sie die variable Adressen, ohne den Quell-thread kommunizieren.
- Ja, ich nehme an ich muss die Zeiger der Variablen, aber ich habe keinen thread starten Haken. Ich kann nicht eine Registrierungsfunktion. Ich muss Thread B nur in der Lage sein, um die lookup-Variablen in der Thread-A. kann Es nicht möglich sein; aber das ist, warum ich Frage.
- Ein globales array erfordert eine Registrierung-Funktion, aber ich nicht kontrollieren thread-Start. Es gibt keine Möglichkeit, erzwingen diese threads rufen Sie eine Funktion init (wenn es einen Weg gibt, dies zu tun, dann ja, das wäre fein).
- mort-ora-y: ich bin der Tatsache bewusst, dass thread-local bedeutet "mehrere Kopien der Variablen"), und auch die Tatsache, dass im Prinzip sollte es nichts verhindern, dass Sie aus der "Bekanntmachung" einer Variablen. Ich habe aktualisiert die Antwort explizit klarstellen; ich glaube immer noch, Sie versuchen gegen den Strom schwimmen.
- mort-ora-y: Dann habe ich 'm Angst, dass ___tls_get_addr ist Ihre einzige Hoffnung.
InformationsquelleAutor Jon
3

Ich bin auf der Suche für die gleiche Sache.
Wie ich sehe, hat niemand Ihre Frage beantwortet, nachdem er durchsucht das web in allen Arten kam ich zu der nachfolgenden Informationen: angenommen, dass zu kompilieren für den gcc unter linux (ubuntu) und mit -m64, die Segmentregister gs behält den Wert 0. Der verborgene Teil des Segments (halten Sie die lineare Adresse)
Punkte auf den thread-spezifischen lokalen Bereich.
Das Gebiet enthält, an die Adresse die Adresse die Adresse ( 64 bits ). Bei kleineren Adressen sind gespeichert, alle thread-lokalen Variablen.
Diese Adresse ist die native_handle().
So, um den Zugriff eines threads auf lokale Daten, sollten Sie es über diesen Zeiger.

In anderen Worten: (char*)&variable-(char*)myThread.native_handle()+(char*)theOtherThread.native_handle()

Den code, der veranschaulicht, die oben angenommen, dass g++,linux,pthreads ist:
```
#include <iostream>
#include <thread>
#include <sstream>

thread_local int B=0x11111111,A=0x22222222;

bool shouldContinue=false;

void code(){
    while(!shouldContinue);
    std::stringstream ss;
    ss<<" A:"<<A<<" B:"<<B<<std::endl;
    std::cout<<ss.str();
}

//#define ot(th,variable) 
//(*( (char*)&variable-(char*)(pthread_self())+(char*)(th.native_handle()) ))

int& ot(std::thread& th,int& v){
    auto p=pthread_self();
    intptr_t d=(intptr_t)&v-(intptr_t)p;
    return *(int*)((char*)th.native_handle()+d);
}

int main(int argc, char **argv)
{       

        std::thread th1(code),th2(code),th3(code),th4(code);

        ot(th1,A)=100;ot(th1,B)=110;
        ot(th2,A)=200;ot(th2,B)=210;
        ot(th3,A)=300;ot(th3,B)=310;
        ot(th4,A)=400;ot(th4,B)=410;

        shouldContinue=true;

        th1.join();
        th2.join();
        th3.join();
        th4.join();

    return 0;
}
```
- Ach ... tooo unportabel. [was ist, wenn der gcc-std::thread wird halt mit pthreads als native_handle? Oder Struktur ändert? Dies kann passieren, mit jedem nächsten gcc-update.]
InformationsquelleAutor George Kourtis
2

Ich war leider nie in der Lage, einen Weg zu finden, dies zu tun.

Ohne irgendeine Art von thread init-hook-es funktioniert einfach nicht scheinen, um einen Weg an, der Zeiger (kurz ASM hacks, wäre Plattform abhängig).

InformationsquelleAutor edA-qa mort-ora-y

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.