Ich benötige einen sehr schnellen (im Sinne von "Low Cost for Reader", nicht "Low Latency") Benachrichtigungsmechanismus zwischen Threads, um einen Lesecache zu aktualisieren:

Die Situatio

FadenW (Writer) aktualisiert eine Datenstruktur S) (in meinem Fall eine Einstellung in einer Karte) nur ab und zu.

FadenR (Reader) verwaltet einen Cache vonS und liest dies sehr häufig. Wenn ThreadW AktualisierungS FadenR muss in angemessener Zeit (10-100 ms) über das Update informiert werden.

Architecture ist ARM, x86 und x86_64. Ich muss @ unterstützC++03 mit gcc 4.6 und höher.

Cod

ist ungefähr so:

// variables shared between threads
bool updateAvailable;
SomeMutex dataMutex;
std::string myData;

// variables used only in Thread R
std::string myDataCache;

// Thread W
SomeMutex.Lock();
myData = "newData";
updateAvailable = true;
SomeMutex.Unlock();

// Thread R

if(updateAvailable)
{
    SomeMutex.Lock();
    myDataCache = myData;
    updateAvailable = false;
    SomeMutex.Unlock();
}

doSomethingWith(myDataCache);

Meine Frag

In ThreadR Auf dem "Fast Path" treten keine Sperren oder Barrieren auf (kein Update verfügbar). Ist das ein Fehler? Was sind die Konsequenzen dieses Designs?

Muss ich mich qualifizierenupdateAvailable wievolatile?

WilleR Hol dir das Updateschließlic?

Mein Verständnis so weit

Ist es sicher in Bezug auf Datenkonsistenz?

Dies sieht ein bisschen aus wie "Double Checked Locking". Gemäßhttp: //www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.htm Eine Speicherbarriere kann verwendet werden, um das Problem in C ++ zu beheben.

Der Hauptunterschied besteht jedoch darin, dass die gemeinsam genutzte Ressource auf dem schnellen Pfad des Readers niemals berührt / gelesen wird. Bei der Aktualisierung des Caches wird die Konsistenz durch den Mutex gewährleistet.

WilleR Hol dir das Update

Hier wird es knifflig. Wie ich es verstehe, läuft die CPU ThreadR könnte @ cachupdateAvailable auf unbestimmte Zeit, wobei der Leseweg effektiv vor dem eigentlichen @ verschoben wirif Erklärung

So kann das Update bis zum nächsten Cache-Leeren dauern, z. B. wenn ein anderer Thread oder Prozess geplant ist.