Atomare Datentypen

Barrieren und atomare Smart Pointer in C++20

In meinem letzten Artikel habe ich Latches zur Thread-Koordination in C++20 vorgestellt. Latch besitzt einen großen Bruder: Barrier. Diese können mehrmals verwendet werden. In diesem Artikel beschäftige ich mit Barrieren und atomaren Smart Pointers.

Hier geht's direkt zum Artikel auf Heise Developer: https://heise.de/-5041229https://heise.de/-5041229.

Gelesen: 2356

Performanzvergleich von Bedingungsvariablen und Atomics in C++20

Nach Einführen des std::atomic_flag in meinem letzten Artikel "Synchronisation mit atomaren Variablen in C++20" möchte ich nun tiefer eintauchen. Heute implementiere ich ein Ping-Pong-Spiel mit Bedingungsvariablen: std::atomic_flag und std::atomic<bool>. Los geht das Spiel!

Hier geht's direkt zum Artikel auf Heise Developer:

Gelesen: 2394

Synchronisation mit atomaren Variablen

Sender/Empfänger Arbeitsabläufe sind typisch für Threads. In solch einem Arbeitsablauf wartet der Empfänger auf die Benachrichtigung des Senders bevor er seine Arbeit fortsetzt. Es gibt einige Möglichkeiten diesen Arbeitsablauf umzusetzen. Mit C++11 bieten sich Bedingungsvariablen oder Promise/Future-Paare an, mit C++20 atomare Variablen.

Hier geht es direkt zum Artikel auf Heise Developer:

Gelesen: 2383

Atomare Referenzen mit C++20

Atomare Variablen erhalten wichtige Erweiterungen in C++20. Im heutigen Artikel stelle ich den neuen Datentyp std::atomic_ref genauer vor.

Hier geht es direkt zum Artikel auf Heise Developer: https://heise.de/-4987217.

Gelesen: 2413

Atomare Smart Pointer

C++20 wird atomare Smart Pointer erhalten. Ganz genau wird es ein std::atomic_shared_ptr und ein std::atomic_weak_ptr sein. Warum eigentlich, std::shared_ptr und std::weak_ptr sind doch schon thread-sicher. Jein. Da muss ich ein wenig ausholen.

Weiterlesen...
Gelesen: 14180

Multithreaded: Addition mit minimaler Synchronisation

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.

Weiterlesen...
Gelesen: 9435

Multithreaded: Addition mit einer geteilten Variable

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.

Weiterlesen...
Gelesen: 11029

Single-Threaded: Summe der Elemente eines Vektors

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.

Weiterlesen...
Gelesen: 11930

Threadsicheres Initialisieren eines Singletons

Singletons lassen sich in vielen Variationen in C++11 threadsicher initialisieren. Dabei können vereinfachend gesprochen Zusicherung der C++-Laufzeit, Locks oder auch atomare Operationen verwendet werden. Mich interessiert vor allem in diesem Artikel die Antwort auf die Frage: Welche Performanzunterschiede bestehen zwischen den Variationen?

Weiterlesen...
Gelesen: 23078

Abonniere den Newsletter (+ pdf Päckchen)

Beiträge-Archiv

Sourcecode

Neuste Kommentare