Wie man threadsichere Referenzzählung in C++ implementiert

Question

Wie implementieren Sie ein effizientes und threadsicheres Referenzzählsystem auf X86-CPUs in der Programmiersprache C++?

Ich laufe immer auf das Problem, dass die kritischen Operationen nicht atomaren, und die verfügbaren X86 Interlock-Operationen sind nicht ausreichend für die Implementierung der Ref-Zählsystem.

Der folgende Artikel behandelt das Thema, sondern erfordert eine spezielle CPU-Anweisungen:

http://www.ddj.com/architect/184401888

Answer 1

Heutzutage kann man die Anhebung/TR1 Shared_ptr <> Smart-Pointer zu halten Ihre Referenz gezählt Referenzen verwenden.

Funktioniert gut; kein Aufhebens, kein Muss. Die Klasse shared_ptr <> kümmert sich um alle Sperren, die auf dem Refcount benötigt werden.

Answer 2

Genau genommen müssen Sie warten, bis C++ 0x thread-sicheren Code in reinem C++ schreiben kann.

Jetzt können Sie Posix verwenden oder Ihre eigenen plattformunabhängigen Wrapper zum Vergleichen und Austauschen und/oder verriegelten Inkrementieren/Dekrementieren erstellen.

Answer 3

In VC++ können Sie _InterlockedCompareExchange verwenden.

do 
    read the count 
    perform mathematical operation 
    interlockedcompareexchange(destination, updated count, old count) 
until the interlockedcompareexchange returns the success code. 

Auf anderen Plattformen/Compiler mit dem entsprechenden intrinsischen für die LOCK cmpxchg Anweisung, dass die MS der _InterlockedCompareExchange aussetzt.

Answer 4

Wenn die Anweisung selbst nicht atomar ist, müssen Sie den Abschnitt des Codes, der die entsprechende Variable aktualisiert, zu einem kritischen Abschnitt machen.

d. H. Sie müssen verhindern, dass andere Threads diesen Codeabschnitt mithilfe eines Sperrschemas eingeben. Natürlich müssen die Sperren atomar sein, aber Sie können einen atomaren Sperrmechanismus innerhalb der pthread_mutex-Klasse finden.

Die Frage nach effizienten: Die Pthread-Bibliothek ist so effizient wie es sein kann und immer noch garantieren, dass Mutex-Sperre atomare für Ihr Betriebssystem ist.

Ist es teuer: Wahrscheinlich. Aber für alles, was eine Garantie erfordert, entstehen Kosten.

Answer 5

Dieser spezielle Code, der in diesem ddj-Artikel gepostet wird, fügt zusätzliche Komplexität hinzu, um Bugs bei der Verwendung von Smartpointern Rechnung zu tragen.

Insbesondere, wenn Sie nicht garantieren können, dass sich der Smart Pointer bei einer Zuweisung zu einem anderen Smart Pointer nicht ändert, tun Sie es falsch oder machen etwas sehr unzuverlässiges, um damit zu beginnen. Wenn sich der intelligente Zeiger ändern kann, während er einem anderen intelligenten Zeiger zugewiesen wird, bedeutet dies, dass der Code, der die Zuweisung ausführt, nicht den intelligenten Zeiger besitzt, der zunächst verdächtig ist.

Answer 6

Win32 InterlockedIncrementAcquire und InterlockedDecrementRelease (wenn Sie sicher und vorsichtig sein wollen über Plattformen mit möglicher Neuordnung, daher müssen Sie Speicherbarrieren zur gleichen Zeit ausgeben) oder InterlockedIncrement und InterlockedDecrement (wenn Sie sicher sind, dass x86 bleiben), sind atomar und werden den Job machen.

Das heißt, Boost/TR1 shared_ptr <> wird all dies für Sie behandeln, daher, wenn Sie es nicht auf eigene Faust implementieren müssen, werden Sie wahrscheinlich das Beste tun, um dabei zu bleiben.

Answer 7

Bedenken Sie, dass das Sperren sehr teuer ist, und jedes Mal, wenn Sie Objekte zwischen intelligenten Zeigern übergeben - auch wenn das Objekt derzeit einem Thread gehört (die intelligente Zeigerbibliothek weiß das nicht).

dies gegeben, kann es eine Faustregel gilt: anwendbar hier (ich bin glücklich korrigiert werden!)

Wenn die Folge Dinge auf Sie zutreffen:

• Sie komplexe Datenstrukturen haben, die wäre schwer Destruktoren für schreiben (oder wo STL-Stil Wert Semantik wäre unpassend, von Entwurf), so dass Sie Smart-Zeigern, es für Sie zu tun, und
• Sie verwenden mehrere Threads, die diese Objekte teilen, und
• Sie interessieren sich für per Formance sowie Korrektheit

... dann kann die tatsächliche Garbage Collection eine bessere Wahl sein. Obwohl GC einen schlechten Ruf für die Leistung hat, ist alles relativ. Ich glaube, dass es sehr gut mit dem Sperren von Smartpointern verglichen wird. Es war ein wichtiger Teil, warum das CLR-Team sich für echte GC entschieden hat und nicht für eine Referenzzählung. Siehe this article, insbesondere diese krassen Vergleich dessen, was Referenzzuordnung bedeutet, wenn Sie zählen los:

keine ref Zählung:

a = b; 

ref Zählung:

if (a != null) 
    if (InterlockedDecrement(ref a.m_ref) == 0) 
      a.FinalRelease(); 

if (b != null) 
    InterlockedIncrement(ref b.m_ref); 

a = b;