Multi-Threading wie in C++11

Transkript

1 Multi-Threading wie in C++11 Franco Chiappori Embedded Computing Conference 2013

2 Reiseroute Guards Lock-Free Data Structures Futures Promises Atomic Types Memory Barriers Compiler / Prozessor

3 Compiler / Hardware Code Prozessor Compiler

4 Out-of-Order Ausführung int data; bool isdatavalid = false; // Processor or thread #1 while (!isdatavalid) {; printf("%d", data); // Processor or thread #2 data = 42; isdatavalid = true; Wegen out-of-order Ausführung kann ein anderer Wert als 42 ausgegeben werden. Kann auch durch Cache Management verursacht sein.

5 Out-of-Order Ausführung int data; bool isdatavalid = false; // Processor or thread #1 while (!isdatavalid) {; printf("%d", data); // Processor or thread #2 data = 42; isdatavalid = true; Wegen out-of-order Ausführung kann ein anderer Wert als 42 ausgegeben werden. Kann auch durch Cache Management verursacht sein.

6 Out-of-Order Ausführung int data; bool isdatavalid = false; // Processor or thread #1 while (!isdatavalid) {; printf("%d", data); // Processor or thread #2 data = 42; isdatavalid = true; Wegen out-of-order Ausführung kann ein anderer Wert als 42 ausgegeben werden. Kann auch durch Cache Management verursacht sein.

7 Out-of-Order Ausführung int data; bool isdatavalid = false; // Processor or thread #1 while (!isdatavalid) {; printf("%d", data); // Processor or thread #2 data = 42; isdatavalid = true; Wegen out-of-order Ausführung kann ein anderer Wert als 42 ausgegeben werden. Kann auch durch Cache Management verursacht sein.

8 Out-of-Order Ausführung int data; bool isdatavalid = false; // Processor or thread #1 while (!isdatavalid) {; printf("%d", data); // Processor or thread #2 data = 42; isdatavalid = true; Wegen out-of-order Ausführung kann ein anderer Wert als 42 ausgegeben werden. Kann auch durch Cache Management verursacht sein.

9 Out-of-Order Ausführung int data; bool isdatavalid = false; // Processor or thread #1 while (!isdatavalid) {; printf("%d", data); // Processor or thread #2 data = 42; isdatavalid = true; Wegen out-of-order Ausführung kann ein anderer Wert als 42 ausgegeben werden. Kann auch durch Cache Management verursacht sein.

10 Memory Barriers

11 Re-Ordering mit Memory Barriers verhindern int data; std::atomic<bool> isdatavalid(false); // Thread #1 while (!isdatavalid.load(std::memory_order_relaxed)) {; std::atomic_thread_fence(std::memory_order_acquire); printf("%d", data); // Thread #2 data = 42; std::atomic_thread_fence(std::memory_order_release); isdatavalid.store(true, std::memory_order_relaxed);

12 Re-Ordering mit Memory Barriers verhindern int data; std::atomic<bool> isdatavalid(false); // Thread #1 while (!isdatavalid.load(std::memory_order_relaxed)) {; std::atomic_thread_fence(std::memory_order_acquire); printf("%d", data); // Thread #2 data = 42; std::atomic_thread_fence(std::memory_order_release); isdatavalid.store(true, std::memory_order_relaxed);

13 Re-Ordering mit Memory Barriers verhindern int data; std::atomic<bool> isdatavalid(false); // Thread #1 while (!isdatavalid.load(std::memory_order_relaxed)) {; std::atomic_thread_fence(std::memory_order_acquire); printf("%d", data); // Thread #2 data = 42; std::atomic_thread_fence(std::memory_order_release); isdatavalid.store(true, std::memory_order_relaxed); «Happens before»

14 Re-Ordering mit Memory Barriers verhindern int data; std::atomic<bool> isdatavalid(false); // Thread #1 while (!isdatavalid.load(std::memory_order_relaxed)) {; std::atomic_thread_fence(std::memory_order_acquire); printf("%d", data); // Thread #2 data = 42; std::atomic_thread_fence(std::memory_order_release); isdatavalid.store(true, std::memory_order_relaxed); «Happens before» «Synchronizes with»

15 Re-Ordering mit Memory Barriers verhindern int data; std::atomic<bool> isdatavalid(false); // Thread #1 while (!isdatavalid.load(std::memory_order_relaxed)) {; std::atomic_thread_fence(std::memory_order_acquire); printf("%d", data); // Thread #2 data = 42; std::atomic_thread_fence(std::memory_order_release); isdatavalid.store(true, std::memory_order_relaxed); «Happens before» «Synchronizes with»

16 Atomare Typen

17 Synchronisation mit atomaren Typen std::atomic<int> data(0); std::atomic<bool> isdatavalid(false); // Thread #1 while (!isdatavalid.load()) {; printf("%d", data.load()); // Thread #2 data.store(42); isdatavalid.store(true); Memory Barriers und Atomare Typen sind low-level Konstrukte Ihr Einsatz erfordert gute Kenntnisse und sorgfältiges Design Geeignet, um bewiesene Flaschenhälse zu optimieren

18 Futures

19 Synchroner Aufruf Client Server synchronous call return value

20 Asynchroner Aufruf Client Server asynchronous call return value?

21 Einsatz von Futures int calculate() { // Some lengthy calculations... return 42; int main() { std::future<int> result = std::asynch(calculate); // Do something else... printf("the result is: %d", result.get()); return 0;

22 Einsatz von Futures int calculate() { // Some lengthy calculations... return 42; int main() { std::future<int> result = std::asynch(calculate); // Do something else... printf("the result is: %d", result.get()); return 0;

23 Einsatz von Futures int calculate() { // Some lengthy calculations... return 42; int main() { std::future<int> result = std::asynch(calculate); // Do something else... printf("the result is: %d", result.get()); return 0;

24 Einsatz von Futures int calculate() { // Some lengthy calculations... return 42; int main() { std::future<int> result = std::asynch(calculate); // Do something else... printf("the result is: %d", result.get()); return 0;

25 Promises

26 Einsatz von Promises std::promise<int> resultpromise; // Thread #1 void calculate() { // Some lengthy calculations... resultpromise.set_value(42); // Thread #2 void printresult() { std::future<int> result = resultpromise.get_future(); // Do something else... printf("the result is: %d", result.get());

27 Einsatz von Promises std::promise<int> resultpromise; // Thread #1 void calculate() { // Some lengthy calculations... resultpromise.set_value(42); // Thread #2 void printresult() { std::future<int> result = resultpromise.get_future(); // Do something else... printf("the result is: %d", result.get());

28 Einsatz von Promises std::promise<int> resultpromise; // Thread #1 void calculate() { // Some lengthy calculations... resultpromise.set_value(42); // Thread #2 void printresult() { std::future<int> result = resultpromise.get_future(); // Do something else... printf("the result is: %d", result.get());

29 Einsatz von Promises std::promise<int> resultpromise; // Thread #1 void calculate() { // Some lengthy calculations... resultpromise.set_value(42); // Thread #2 void printresult() { std::future<int> result = resultpromise.get_future(); // Do something else... printf("the result is: %d", result.get());

30 Einsatzgebiet von Futures/Promises Arbeitslast auf mehrere Threads verteilen Arbeitslast flexibel aufteilen Auf Background Thread warten Beachten: future::get() kann blockieren Alternativen: Message Queue (Actor Model) Synchrone Aufrufe

31 Guards

32 Einsatz von Guards std::deque<int> somequeue; std::mutex queuemutex; bool queuepeek(int& value) { std::lock_guard<std::mutex> guard(queuemutex); if (somequeue.empty()) { return false; value = somequeue.front(); somequeue.pop_front(); return true;

33 Einsatz von Guards std::deque<int> somequeue; std::mutex queuemutex; bool queuepeek(int& value) { std::lock_guard<std::mutex> guard(queuemutex); if (somequeue.empty()) { return false; value = somequeue.front(); somequeue.pop_front(); return true;

34 Einsatz von Guards std::deque<int> somequeue; std::mutex queuemutex; bool queuepeek(int& value) { std::lock_guard<std::mutex> guard(queuemutex); if (somequeue.empty()) { return false; value = somequeue.front(); somequeue.pop_front(); return true;

35 Einsatz von Guards std::deque<int> somequeue; std::mutex queuemutex; bool queuepeek(int& value) { std::lock_guard<std::mutex> guard(queuemutex); if (somequeue.empty()) { return false; value = somequeue.front(); somequeue.pop_front(); return true;

36 Einsatz von Guards std::deque<int> somequeue; std::mutex queuemutex; bool queuepeek(int& value) { std::lock_guard<std::mutex> guard(queuemutex); if (somequeue.empty()) { return false; value = somequeue.front(); somequeue.pop_front(); return true;

37 Lock-Free Data Structures

38 Read-Copy-Update: Einfügen in einfach verkettete Liste 2) 1)

39 RCU: Entfernen aus einfach verketteter Liste 1) 2) Wann kann das Element gelöscht werden? Benutzte Techniken: rcu_read_lock / rcu_read_unlock std::shared_pointer garbage collection

40 Einsatzgebiet für Read-Copy-Update

41 Eisatzgebiet für Lock-Free Data Structures

42 Reiseroute Guards Lock-Free Data Structures Futures Promises Atomic Types Memory Barriers Compiler / Prozessor

43

44 Kernpunkte Synchronisation via Betriebssystem Threads gezielt einsetzen Performance messen

45 Referenz

46 Gute Heimreise!

47 Bildnachweis Hausabbruch: Wiki Media, Benutzer Rupp.de Atom: Wiki Media, Benutzer Halfdan / Indolences Ufo: Wiki Media, Benutzer Michael Salone Drei Eidgenossen: Parlamentsdienste, 3003 Bern Palastwachen: Wiki Media, Benutzer Ibagli Chain Gang: Wiki Media, Autor unbekannt Stoppuhr: Wiki Media, Benutzer Tasma3197 Gipfelbild Pilatus: Wiki Media, Benutzer Toby87 Kabine Pilatusbahn: Wiki Media, Benutzer The wub Pilatus, Barriere, Telefonbuch, C++ Concurrency Buch: Franco Chiappori, 6048 Horw