język c++ i przetwarzanie współbieżne w akcji pełna wersja, ebooki(1)
[ Pobierz całość w formacie PDF ]
Spis treci
Sowo wstpne .......................................................................................................................................... 11
Podzikowania .......................................................................................................................................... 13
O tej ksice .............................................................................................................................................. 15
Rozdzia 1. Witaj, wiecie wspóbienoci w C++!
19
1.1.
Czym jest wspóbieno? ........................................................................................................... 20
1.1.1. Wspóbieno w systemach komputerowych ................................................................. 20
1.1.2. Modele wspóbienoci ..................................................................................................... 22
1.2.
Dlaczego warto stosowa wspóbieno? ................................................................................. 25
1.2.1. Stosowanie wspóbienoci do podziau zagadnie ......................................................... 25
1.2.2. Stosowanie wspóbienoci do podniesienia wydajnoci ................................................. 26
1.2.3. Kiedy nie naley stosowa wspóbienoci ....................................................................... 27
1.3.
Wspóbieno i wielowtkowo w jzyku C++ .................................................................... 28
1.3.1. Historia przetwarzania wielowtkowego w jzyku C++ ................................................ 29
1.3.2. Obsuga wspóbienoci w nowym standardzie ............................................................... 30
1.3.3. Efektywno biblioteki wtków jzyka C++ .................................................................. 30
1.3.4. Mechanizmy zwizane z poszczególnymi platformami ................................................... 32
1.4.
Do dziea! ...................................................................................................................................... 32
1.4.1. „Witaj wiecie wspóbienoci” ......................................................................................... 32
1.5.
Podsumowanie .............................................................................................................................. 34
Rozdzia 2. Zarzdzanie wtkami
35
2.1.
Podstawowe zarzdzanie wtkami ............................................................................................. 36
2.1.1 Uruchamianie wtku .......................................................................................................... 36
2.1.2. Oczekiwanie na zakoczenie wtku .................................................................................. 39
2.1.3. Oczekiwanie w razie wystpienia wyjtku ....................................................................... 39
2.1.4. Uruchamianie wtków w tle .............................................................................................. 42
2.2.
Przekazywanie argumentów do funkcji wtku ......................................................................... 43
2.3.
Przenoszenie wasnoci wtku .................................................................................................... 46
2.4.
Wybór liczby wtków w czasie wykonywania ........................................................................... 49
2.5.
Identyfikowanie wtków ............................................................................................................. 52
2.6.
Podsumowanie .............................................................................................................................. 54
Rozdzia 3. Wspódzielenie danych przez wtki
55
3.1.
Problemy zwizane ze wspódzieleniem danych przez wtki ................................................. 56
3.1.1. Sytuacja wycigu ................................................................................................................ 58
3.1.2. Unikanie problematycznych sytuacji wycigu .................................................................. 59
3.2.
Ochrona wspódzielonych danych za pomoc muteksów ........................................................ 60
3.2.1. Stosowanie muteksów w jzyku C++ ............................................................................. 60
3.2.2. Projektowanie struktury kodu z myl o ochronie wspódzielonych danych ................. 62
6
Spis treci
3.2.3. Wykrywanie sytuacji wycigu zwizanych z interfejsami ................................................ 63
3.2.4. Zakleszczenie: problem i rozwizanie .............................................................................. 71
3.2.5. Dodatkowe wskazówki dotyczce unikania zakleszcze ................................................. 73
3.2.6. Elastyczne blokowanie muteksów za pomoc szablonu std::unique_lock ...................... 79
3.2.7. Przenoszenie wasnoci muteksu pomidzy zasigami .................................................... 80
3.2.8. Dobór waciwej szczegóowoci blokad .......................................................................... 82
3.3.
Alternatywne mechanizmy ochrony wspódzielonych danych ................................................ 84
3.3.1. Ochrona wspódzielonych danych podczas inicjalizacji .................................................. 84
3.3.2. Ochrona rzadko aktualizowanych struktur danych .......................................................... 88
3.3.3. Blokowanie rekurencyjne .................................................................................................. 90
3.4.
Podsumowanie .............................................................................................................................. 91
Rozdzia 4. Synchronizacja wspóbienych operacji
93
4.1.
Oczekiwanie na zdarzenie lub inny warunek ........................................................................... 94
4.1.1. Oczekiwanie na spenienie warunku za pomoc zmiennych warunkowych .................. 95
4.1.2. Budowa kolejki gwarantujcej bezpieczne przetwarzanie wielowtkowe
przy uyciu zmiennych warunkowych .............................................................................. 97
4.2.
Oczekiwanie na jednorazowe zdarzenia za pomoc przyszoci ........................................... 102
4.2.1. Zwracanie wartoci przez zadania wykonywane w tle ................................................... 103
4.2.2. Wizanie zadania z przyszoci ...................................................................................... 106
4.2.3. Obietnice (szablon std::promise) ..................................................................................... 109
4.2.4. Zapisywanie wyjtku na potrzeby przyszoci ................................................................ 111
4.2.5. Oczekiwanie na wiele wtków ........................................................................................ 112
4.3.
Oczekiwanie z limitem czasowym ............................................................................................ 115
4.3.1. Zegary ............................................................................................................................... 115
4.3.2. Okresy ............................................................................................................................... 117
4.3.3. Punkty w czasie ................................................................................................................ 118
4.3.4. Funkcje otrzymujce limity czasowe .............................................................................. 120
4.4.
Upraszczanie kodu za pomoc technik synchronizowania operacji ..................................... 121
4.4.1. Programowanie funkcyjne przy uyciu przyszoci ....................................................... 122
4.4.2. Synchronizacja operacji za pomoc przesyania komunikatów ..................................... 127
4.5.
Podsumowanie ............................................................................................................................ 131
Rozdzia 5. Model pamici jzyka C++ i operacje na typach atomowych
133
5.1.
Podstawowe elementy modelu pamici ................................................................................... 134
5.1.1. Obiekty i miejsca w pamici ............................................................................................ 134
5.1.2. Obiekty, miejsca w pamici i przetwarzanie wspóbiene ............................................ 135
5.1.3. Kolejno modyfikacji ...................................................................................................... 136
5.2.
Operacje i typy atomowe jzyka C++ .................................................................................... 137
5.2.1. Standardowe typy atomowe ............................................................................................ 138
5.2.2. Operacje na typie std::atomic_flag .................................................................................. 141
5.2.3. Operacje na typie std::atomic<bool> ............................................................................ 143
5.2.4. Operacje na typie std::atomic<T*> — arytmetyka wskaników ................................. 146
5.2.5. Operacje na standardowych atomowych typach cakowitoliczbowych ........................ 147
5.2.6. Gówny szablon klasy std::atomic<> ............................................................................. 147
5.2.7. Wolne funkcje dla operacji atomowych .......................................................................... 150
5.3.
Synchronizacja operacji i wymuszanie ich porzdku ............................................................ 151
5.3.1. Relacja synchronizacji ...................................................................................................... 152
5.3.2. Relacja poprzedzania ....................................................................................................... 154
5.3.3. Porzdkowanie pamici na potrzeby operacji atomowych ............................................ 155
5.3.4. Sekwencje zwalniania i relacja synchronizacji ............................................................... 175
Spis treci
7
5.3.5. Ogrodzenia ....................................................................................................................... 178
5.3.6. Porzdkowanie operacji nieatomowych za pomoc operacji atomowych ..................... 180
5.4.
Podsumowanie ............................................................................................................................ 182
Rozdzia 6. Projektowanie wspóbienych struktur danych przy uyciu blokad
183
6.1.
Co oznacza projektowanie struktur danych pod ktem wspóbienoci? ............................ 184
6.1.1. Wskazówki dotyczce projektowania wspóbienych struktur danych ........................ 185
6.2.
Projektowanie wspóbienych struktur danych przy uyciu blokad .................................... 186
6.2.1. Stos gwarantujcy bezpieczestwo przetwarzania wielowtkowego
przy uyciu blokad ........................................................................................................... 187
6.2.2. Kolejka gwarantujca bezpieczestwo przetwarzania wielowtkowego
przy uyciu blokad i zmiennych warunkowych ............................................................. 190
6.2.3. Kolejka gwarantujca bezpieczestwo przetwarzania wielowtkowego
przy uyciu szczegóowych blokad i zmiennych warunkowych .................................... 194
6.3.
Projektowanie zoonych struktur danych przy uyciu blokad ............................................. 207
6.3.1. Implementacja tablicy wyszukiwania gwarantujcej bezpieczestwo
przetwarzania wielowtkowego przy uyciu blokad ...................................................... 207
6.3.2. Implementacja listy gwarantujcej bezpieczestwo przetwarzania
wielowtkowego przy uyciu blokad .............................................................................. 213
6.4.
Podsumowanie ............................................................................................................................ 218
Rozdzia 7. Projektowanie wspóbienych struktur danych bez blokad
219
7.1.
Definicje i ich praktyczne znaczenie ....................................................................................... 220
7.1.1. Rodzaje nieblokujcych struktur danych ........................................................................ 220
7.1.2. Struktury danych bez blokad ........................................................................................... 221
7.1.3. Struktury danych bez oczekiwania ................................................................................. 222
7.1.4. Zalety i wady struktur danych bez blokad ...................................................................... 222
7.2.
Przykady struktur danych bez blokad .................................................................................... 223
7.2.1. Implementacja stosu gwarantujcego bezpieczestwo przetwarzania
wielowtkowego bez blokad ............................................................................................ 224
7.2.2. Eliminowanie niebezpiecznych wycieków — zarzdzanie pamici
w strukturach danych bez blokad .................................................................................... 228
7.2.3. Wykrywanie wzów, których nie mona odzyska, za pomoc wskaników ryzyka ........ 233
7.2.4. Wykrywanie uywanych wzów metod zliczania referencji .......................................... 242
7.2.5. Zmiana modelu pamici uywanego przez operacje na stosie bez blokad ................... 247
7.2.6. Implementacja kolejki gwarantujcej bezpieczestwo przetwarzania
wielowtkowego bez blokad ............................................................................................ 252
7.3.
Wskazówki dotyczce pisania struktur danych bez blokad ................................................... 264
7.3.1. Wskazówka: na etapie tworzenia prototypu naley stosowa tryb
std::memory_order_seq_cst ............................................................................................ 265
7.3.2. Wskazówka: naley uywa schematu odzyskiwania pamici bez blokad .................... 265
7.3.3 Wskazówka: naley unika problemu ABA .................................................................... 266
7.3.4. Wskazówka: naley identyfikowa ptle aktywnego oczekiwania i wykorzystywa
czas bezczynnoci na wspieranie innego wtku ............................................................. 267
7.4.
Podsumowanie ............................................................................................................................ 267
Rozdzia 8. Projektowanie wspóbienego kodu
269
8.1.
Techniki dzielenia pracy pomidzy wtki ............................................................................... 270
8.1.1. Dzielenie danych pomidzy wtki przed rozpoczciem przetwarzania ....................... 271
8.1.2. Rekurencyjne dzielenie danych ...................................................................................... 272
8.1.3. Dzielenie pracy wedug typu zadania ............................................................................. 276
8
Spis treci
8.2.
Czynniki wpywajce na wydajno wspóbienego kodu ..................................................... 279
8.2.1. Liczba procesorów ........................................................................................................... 280
8.2.2. Wspózawodnictwo o dane i ping-pong bufora .............................................................. 281
8.2.3. Faszywe wspódzielenie ................................................................................................. 284
8.2.4. Jak blisko naley rozmieci dane? ................................................................................. 285
8.2.5. Nadsubskrypcja i zbyt intensywne przeczanie zada ................................................. 285
8.3.
Projektowanie struktur danych pod ktem wydajnoci przetwarzania wielowtkowego ..... 286
8.3.1. Podzia elementów tablicy na potrzeby zoonych operacji .......................................... 287
8.3.2. Wzorce dostpu do danych w pozostaych strukturach ................................................. 289
8.4.
Dodatkowe aspekty projektowania wspóbienych struktur danych ................................... 291
8.4.1. Bezpieczestwo wyjtków w algorytmach równolegych .............................................. 291
8.4.2. Skalowalno i prawo Amdahla ....................................................................................... 298
8.4.3. Ukrywanie opónie za pomoc wielu wtków .............................................................. 300
8.4.4. Skracanie czasu reakcji za pomoc technik przetwarzania równolegego .................... 301
8.5.
Projektowanie wspóbienego kodu w praktyce ..................................................................... 303
8.5.1. Równolega implementacja funkcji std::for_each ........................................................... 304
8.5.2. Równolega implementacja funkcji std::find .................................................................. 306
8.5.3. Równolega implementacja funkcji std::partial_sum ..................................................... 312
8.6.
Podsumowanie ............................................................................................................................ 322
Rozdzia 9. Zaawansowane zarzdzanie wtkami
323
9.1.
Pule wtków ................................................................................................................................ 324
9.1.1. Najprostsza moliwa pula wtków .................................................................................. 324
9.1.2. Oczekiwanie na zadania wysyane do puli wtków ........................................................ 327
9.1.3. Zadania oczekujce na inne zadania ............................................................................... 330
9.1.4. Unikanie wspózawodnictwa w dostpie do kolejki zada ............................................ 333
9.1.5. Wykradanie zada ............................................................................................................ 335
9.2.
Przerywanie wykonywania wtków .......................................................................................... 340
9.2.1. Uruchamianie i przerywanie innego wtku .................................................................... 340
9.2.2. Wykrywanie przerwania wtku ....................................................................................... 342
9.2.3. Przerywanie oczekiwania na zmienn warunkow ........................................................ 343
9.2.4. Przerywanie oczekiwania na zmienn typu std::condition_variable_any ..................... 346
9.2.5. Przerywanie pozostaych wywoa blokujcych ............................................................ 348
9.2.6. Obsuga przerwa ............................................................................................................ 349
9.2.7. Przerywanie zada wykonywanych w tle podczas zamykania aplikacji ........................ 350
9.3.
Podsumowanie ............................................................................................................................ 352
Rozdzia 10. Testowanie i debugowanie aplikacji wielowtkowych 353
10.1. Rodzaje bdów zwizanych z przetwarzaniem wspóbienym ............................................ 354
10.1.1. Niechciane blokowanie ............................................................................................... 354
10.1.2. Sytuacje wycigu ......................................................................................................... 355
10.2. Techniki lokalizacji bdów zwizanych z przetwarzaniem wspóbienym ........................ 357
10.2.1. Przegldanie kodu w celu znalezienia ewentualnych bdów .................................. 357
10.2.2. Znajdowanie bdów zwizanych z przetwarzaniem wspóbienym
poprzez testowanie kodu ................................................................................................. 359
10.2.3. Projektowanie kodu pod ktem atwoci testowania ................................................. 361
10.2.4. Techniki testowania wielowtkowego kodu .............................................................. 363
10.2.5. Projektowanie struktury wielowtkowego kodu testowego ...................................... 366
10.2.6. Testowanie wydajnoci wielowtkowego kodu ......................................................... 369
10.3. Podsumowanie ............................................................................................................................ 370
[ Pobierz całość w formacie PDF ]