Der Zeitpunkt wird durch seinen Startpunkt, die sogenannte Epoche und die darauf bezogenen Zeitdauer festgelegt. Dabei enthält ein Zeitpunkt einen Zeitgeber(Clock) und eine Zeitdauer (Duration).

Ein Blog, der sich mit den Multithreadingfähigkeiten von modernem C++ beschäftigt und nicht auf die Zeitbibliothek eingeht, ist nicht vollständig. Insbesondere, wenn ich in den letzten Artikeln öfters mit Hilfe der Zeitbibliothek die Performanz von kleinen Codeabschnitten gemessen habe. Daher gebe ich in diesem Artikel einen Überblick über die Zeitkomponenten Zeitpunkt, Zeitdauer und Zeitgeber. Jeder der drei Komponenten werde ich mir dann in weiteren Artikeln noch genauer anschauen.

std::memory_order_consume ist das legendärste der sechs Speichermodelle. Dieser besondere Ruf ist zwei Tatsachen geschuldet. Zum einen ist die std::memory_order_consume Ordnung sehr verständnisresistent. Zum andern hat es meines Wissens noch kein Compiler umgesetzt.

Eine release-Operation synchronisiert sich mit einer acquire-Operation auf der gleichen atomaren Variable und erzeugt dazu noch eine Ordnungsbedingung. Damit lassen sich Threads auf performante Weise synchronisieren, wenn sie auf einer gemeinsamen atomaren Variablen agieren. Doch wie lassen sich zwei Threads mit der Acquire-Release-Semantik synchronisieren, wenn sie auf keiner gemeinsamen atomaren Variablen agieren? Eine globale Ordnung der Threads mit Hilfe der Sequenziellen Konsistenz ist oft zu schwergewichtig.

Nachdem ich in den letzten drei Artikel die Summe eines Vektors in drei verschiedenen Strategien berechnet habe, möchte ich mit diesem Artikel mein Fazit ziehen.

Zwei Strategien bin ich bisher bei meiner Addition aller Elemente eines std::vector gefolgt. Zum einen habe ich die ganze Summation in einem Thread ausgeführt (Single-Threaded: Summe der Elemente eines Vektors), zum anderen alle Threads auf einer gemeinsamen Summations-Variable (Multithreaded: Addition mit einer geteilten Variable) agieren lassen. Gerade die zweite Strategie war sehr naiv. In diesem Artikel werde ich meine Erkenntnisse aus beiden Artikeln anwenden. Mein Ziel wird es daher sein, die Threads möglichst unabhängig ihre Arbeit ausführen zu lassen und die Synchronisation der Threads auf der Summations-Variable zu minimieren.

Ziel dieses Artikels ist es, die Summe aller Elemente eines Vektors zu bilden. Habe ich es im letzten Artikel mit einem Thread versucht, nütze ich dieses mal die volle Power meiner PCs. Ich verwende eine gemeinsame Summen-Variable, die von allen Threads gleichzeitig benutzt wird. Was bei ersten Hinsehen wie eine gute Idee klingt, ist bei genauerem Blick eine sehr naive Strategie. Überwiegt der Aufwand für die Synchronisation der Summen-Variable deutlich den Performanzvorteil der vier bzw. zwei CPUs.

Wie lassen sich die Werte eines std::vector am schnellsten zusammenaddieren? Diese Frage will ich in mehreren Artikeln nachgehen. Als Referenzwert soll dabei die Addition in einem Thread dienen. In weiteren Artikel gehe ich auf atomare Variablen, Locks, Tasks und threadlokale Daten ein.

Ich hätte nie gedacht, dass ich mit meinem letzten Artikel zum Threadsicheres Initialisieren eines Singleton soviel Emotion wecken würde. Daher will ich diesen Artikel nützen, die Emotionen zusammenzufassen.