lato 2014,, Wydział Elektroniki i Technik Informacyjnych
SSE, SSE2, SSE3, SSE4, AVX, C++11 threads OpenMP, OpenACC CUDA, OpenCL, C++ AMP 2
Prawo Amdahla Prawo Gustafsona Czy warto zajmować się obliczeniami równoległymi, a zwłaszcza masywnie równoległymi? Memory bandwidth GFlops Intensywność arytmetyczna algorytmów Jakie podstawowe czynniki wpływają na wydajność/szybkość działania współczesnych komputerów? Machine balance Roofline 3
T s = S + P T p = S + P/N S up =T s /T p E f =S up /N Gdy N -> S up -> 1+P/S E f -> 0 Ts 11 1 2 4 8 S P / N S P / N S S Tp 4
5
T s = S + N*P T p = S + P S up =T s /T p E f =S up /N Gdy N -> S up -> N E f -> 1 Tp 1 2 4 S S S P P P P P P P Maciej Sypniewski 6
7
Liczba bajtów przesyłanych między procesorem i pamięcią półprzewodnikową w jednostce czasu (typowy przykład dla CPU) Źródło http://zsmith.co/ Memory bandwidth versus memory size 8
Przykład: MBand teoretyczny dla CPU MBand = effective_mem_freq * interface_width / 8 Dla CPU : Intel Xeon E5-2697 v2 effective_mem_freq = 2 * 1.866 [GHz] = 3.732 [GHz] double data rate interface_width = 4 *32 = 128 [B] cztery kanały pamięci MBand = 59.7 [GB/s] 9
Przykład: MBand teoretyczny dla GPU MBand = effective_mem_freq * interface_width / 8 Dla GPU : Nvidia GTX Titan effective_mem_freq = 4 * 1.5 [GHz] = 6 [GHz] quad data rate interface_width = 384 [B] MBand = 288 [GB/s] aktualnie MBand gpu /MBand cpu 5 10
Liczba miliardów operacji zmiennoprzecinkowych wykonywanych przez system komputerowy w ciągu sekundy Giga 10^9 miliard (2^30) ang. Bilion (short scale) Tera 10^12 bilion (2^40) ang. Trilion (short scale) Peta 10^15 biliard (2^50) TOP 500 (54.9) Eksa 10^18 trylion (2^60) Zetta 10^21 tryliard (2^70) 1000^3, 1024^3 GB Decimal/Binary GiB (IEC) 11
Przykład: GFlops teoretyczne dla CPU GFlops = (CPU speed in GHz) x (number of CPU cores) x (CPU instruction per cycle) x (number of CPUs per node). Dla CPU : Intel Xeon E5-2697 v2 GFlops =2.7*12*8*1=259.2 Ginsts = 32.4 = Gflops / 8 Instruction throughput 12
Przykład: GFlops teoretyczne dla GPU GFlops = (GPU speed in GHz) x (number of GPU cores) x (GPU instruction per cycle) x (number of GPUs per node). Dla GPU : Nvidia GTX Titan GFlops =0.872*2688*2*1=4687.9 Ginsts = 2343.9 = Gflops / 2 GFlops gpu / Gflops cpu =18.1 Ginsts gpu / Ginsts cpu =72.3 Instruction throughput 13
Dla algorytmów liczba operacji obliczeniowych podzielona przez liczbę bajtów danych wymaganych do wykonania tych operacji Przykłady Saxpy single z=a*x+y -> y[i]=a*x[i]+y[i] Liczba operacji obliczeniowych 2 Liczba operacji pamięciowych w bajtach 3*4 Ai=2/(3*4 [B])=1/6 14
Przykłady praktyczne Obliczanie długości wektora ~ 1/8 Stensils method ~ ¼ (symulacje, obraz) Macierze gęste N/16 (przy założeniu wykorzystania cache) Arithmetic intensity O(1) O(log(N)) O(N) większość alg. FFT dense matrix 15
Dla komputerów : stosunek mocy obliczeniowej (np. wyrażonej w GFlops) do przepustowości pamięci (np. wyrażonej w GB/s) Przykłady: CPU : Intel Xeon E5-2697 v2 Mbal = 259.2 / 59.7 = 4.3 GPU : Nvidia GTX Titan Mbal = 4687.9 / 288 = 16.3 288 16
Problem Najczęściej Intensywność arytmetyczna < 1 (np. 0.2) Najczęściej machine balance > 1 (np. 10) Zwykle mamy do czynienia z przypadkami obliczeniowymi gdzie mamy za dużą moc obliczeniową w stosunku do wymaganego pasma pamięci często dużo za dużą (np. 20 razy) 17
Wydajność obliczeniowa Mperf [GFlops] = min { GFlops, Ai*Mband } http://lorenabarba.com/news/fast-multipole-method-in-the-exascale-era/ 18
SSE Streaming SIMD Extention (128 bit) 1999 Pentium III AVX Advanced Vector Extention (256 bit) 2011 Sandy Bridge AVX2 AVX512 (Haswell, Broadwell) VC++ 2013 Update2 FMA Fused Multiple Add - a*b+c w jednym cyklu 19
SSE Streaming SIMD Extention (128 bit) 1999 Pentium III AVX Advanced Vector Extention (256 bit) 2011 Sandy Bridge AVX2 AVX512 (Haswell, Broadwell) VC++ 2013 Update2 FMA Fused Multiple Add - a*b+c w jednym cyklu 20
Programowanie niskopoziomowe SIMD Intrinsic functions 21
Wykorzystanie automatic vectorization 22
Nowy nowoczesny standard (sematyka przesuniecia, wyrażenia lamda itp..) Przenośność standard (Windows, Linux, itd.) Skalowalność 23
C++11 threads zawiera narzędzia programowania wielowątkowego znane z poprzednich standardów i implementacji (SUN threads, POSIX pthreads, Windows threads itp.) opakowane w nowe elementy C++11 Zarządzanie wątkami klasa thread, join, detach Synchronizacja mutex, lock_guard, unique_lock Zarządzanie zadaniami async, promise future, packaged task 24
Przykład 1 : saxpy Przykład 2 : Monte Carlo Pi Przykład 3 : Producer Consumer 25
Jeden z najbardziej produktywnych standardów obliczeń równoległych Minimalne zmiany w kodzie szeregowym mogą potencjalnie dać zasadnicze zmiany w wydajności oprogramowania Kod szeregowy nadal działa be zmian OpenMP zwykle jest realizowany na wątkach 26
Źródło - Wikipedia 27
Saxpy Iloczyn skalarny 28
chrono nowa C++11 biblioteka standardowa do zarządzania czasem Biblioteka nie ogranicza precyzji pomiaru czasu Podstawowe elementy to: clock - zegary system_clock zegar systemowy steady_clock zegar o stałym upływie czasu high_resolution zegar o największej możliwej rozdzielczości Clock period wyrażony jako ratio duration czas trwania () time_point Typowe użycie w celu precyzyjnego pomiaru czasu auto st = std::chrono::high_resolution_clock::now(); Czasochłonny kod auto ed = std::chrono::high_resolution_clock::now(); auto dur = std::chrono::duration_cast<std::chrono::microseconds>(ed - st); 29
using yocto = ratio<1,1000000000000000000000000>; // conditionally supported using zepto = ratio<1,1000000000000000000000>; // conditionally supported using atto = ratio<1,1000000000000000000>; using femto = ratio<1,1000000000000000>; using pico = ratio<1,1000000000000>; using nano = ratio<1,1000000000>; using micro = ratio<1,1000000>; using milli = ratio<1,1000>; using centi = ratio<1,100>; using deci = ratio<1,10>; using deca = ratio<10,1>; using hecto = ratio<100,1>; using kilo = ratio<1000,1>; using mega = ratio<1000000,1>; using giga = ratio<1000000000,1>; using tera = ratio<1000000000000,1>; using peta = ratio<1000000000000000,1>; using exa = ratio<1000000000000000000,1>; using zetta = ratio<1000000000000000000000,1>; // conditionally supported using yotta = ratio<1000000000000000000000000,1>; // conditionally supported duration<double,pico> d2 {3.33}; // 3.33 picoseconds Żródło The C++Programming language Bjarne Stroustrup 30
ciekawe strony w internecie związane z przedmiotem Np. HPC http://biuletyn.icm.edu.pl/index.php/o_biuletynie C++11 threads Youtube Bo Qian C++11 Concurrency, Bartosz Milewski Blog Programming Cafe Kolejny wykład GPU podstawy OpenACC, CUDA, OpenCL, C++AMP 31