IMPROVING PROGRAMMABILITY AND PERFORMANCE PORTABILITY ON MANY-CORE PROCESSORS

Transkript

1 IMPROVING PROGRAMMABILITY AND PERFORMANCE PORTABILITY ON MANY-CORE PROCESSORS michel steuwer aus Duisburg

2 Die Manycore Ära 10,000,000 1,000, ,000 10,000 1,000 Transistors (in 1000s) Clock Frequency (in Mhz) Power (in Watt) Number of Cores Intel CPUs von 1970 bis Inspiriert von Herb Sutter The Free Lunch is Over: A Fundamental Turn Towards Concurrency in Software

3 Die Manycore Ära multicore CPUs GPUs Beschleuniger FPGAs

4 Agenda Meine Dissertation adressiert zwei zentrale Herausforderungen: I. Die Herausforderung der Programmierbarkeit II. Die Herausforderung der Performance-Portabilität

5 TEIL I Die Herausforderung der Programmierbarkeit

6 Programmierung mit OpenCL Beispiel: Parallele Summation eines Arrays in OpenCL kernel void reduce(global float* g_idata, global float* g_odata, unsigned int n, local float* l_data) { unsigned int tid = get_local_id(0); unsigned int i = get_global_id(0); l_data[tid] = (i < n)? g_idata[i] : 0; barrier(clk_local_mem_fence); // do reduction in local memory for (unsigned int s=1; s < get_local_size(0); s*= 2) { if ((tid % (2*s)) == 0) { l_data[tid] += l_data[tid + s]; barrier(clk_local_mem_fence); // write result for this work-group to global memory if (tid == 0) g_odata[get_group_id(0)] = l_data[0];

7 Programmierung mit OpenCL Beispiel: Parallele Summation eines Arrays in OpenCL Kernel Funktion wird parallel von vielen work-items ausgeführt kernel void reduce(global float* g_idata, global float* g_odata, unsigned int n, local float* l_data) { unsigned int tid = get_local_id(0); unsigned int i = get_global_id(0); l_data[tid] = (i < n)? g_idata[i] : 0; barrier(clk_local_mem_fence); // do reduction in local memory for (unsigned int s=1; s < get_local_size(0); s*= 2) { if ((tid % (2*s)) == 0) { l_data[tid] += l_data[tid + s]; barrier(clk_local_mem_fence); // write result for this work-group to global memory if (tid == 0) g_odata[get_group_id(0)] = l_data[0]; Work-items werden durch eine globale id identifizier

8 Programmierung mit OpenCL Beispiel: Parallele Summation eines Arrays in OpenCL Work-items werden zu work-groups zusammengefasst Lokale id innerhalb einer work-group kernel void reduce(global float* g_idata, global float* g_odata, unsigned int n, local float* l_data) { unsigned int tid = get_local_id(0); unsigned int i = get_global_id(0); l_data[tid] = (i < n)? g_idata[i] : 0; barrier(clk_local_mem_fence); // do reduction in local memory for (unsigned int s=1; s < get_local_size(0); s*= 2) { if ((tid % (2*s)) == 0) { l_data[tid] += l_data[tid + s]; barrier(clk_local_mem_fence); // write result for this work-group to global memory if (tid == 0) g_odata[get_group_id(0)] = l_data[0];

9 Programmierung mit OpenCL Beispiel: Parallele Summation eines Arrays in OpenCL Großer, aber langsamer globaler Speicher Kleiner, aber schneller lokaler Speicher kernel void reduce(global float* g_idata, global float* g_odata, unsigned int n, local float* l_data) { unsigned int tid = get_local_id(0); unsigned int i = get_global_id(0); l_data[tid] = (i < n)? g_idata[i] : 0; barrier(clk_local_mem_fence); // do reduction in local memory for (unsigned int s=1; s < get_local_size(0); s*= 2) { if ((tid % (2*s)) == 0) { l_data[tid] += l_data[tid + s]; barrier(clk_local_mem_fence); // write result for this work-group to global memory if (tid == 0) g_odata[get_group_id(0)] = l_data[0]; Barrieren für Speicherkonsistenz

10 Programmierung mit OpenCL Beispiel: Parallele Summation eines Arrays in OpenCL kernel void reduce(global float* g_idata, global float* g_odata, unsigned int n, local float* l_data) { unsigned int tid = get_local_id(0); unsigned int i = get_global_id(0); l_data[tid] = (i < n)? g_idata[i] : 0; barrier(clk_local_mem_fence); // do reduction in local memory for (unsigned int s=1; s < get_local_size(0); s*= 2) { if ((tid % (2*s)) == 0) { l_data[tid] += l_data[tid + s]; barrier(clk_local_mem_fence); // write result for this work-group to global memory if (tid == 0) g_odata[get_group_id(0)] = l_data[0]; Funktional korrekte Implementierungen in OpenCL sind schwierig!

11 DAS SKELCL PROGRAMMIERMODEL

12 Das SkelCL Programmiermodel Drei Abstraktionen zu OpenCL hinzugefügt: Parallele Datencontainer für eine einheitliche Speicherverwaltung zwischen CPU und (mehreren) GPUs implizite Speichertransfers zwischen CPU und GPU lazy copying minimiert den Datentransfer Wiederkehrende Muster paralleler Programmierung (Algorithmische Skelette) für eine vereinfachte Beschreibung paralleler Berechnungen zip ( ) [x1,, xn] [y1,, yn] = [x1 y1,, xn yn] reduce ( ) id [x1,, xn] = id x1 xn Daten Verteilungen für einen transparenten Datentransfer in Systemen mit mehreren GPUs. CPU CPU CPU 0 GPUs 1 0 GPUs 1 0 GPUs 1 single copy block

13 Die SkelCL Softwarebibliothek am Beispiel dotproduct A B = reduce (+) 0 (zip ( ) A B) #include <SkelCL/SkelCL.h> #include <SkelCL/Zip.h> #include <SkelCL/Reduce.h> #include <SkelCL/Vector.h> float dotproduct(const float* a, const float* b, int n) { using namespace skelcl; skelcl::init( 1_device.type(deviceType::ANY) ); auto mult = zip([](float x, float y) { return x*y; ); auto sum = reduce([](float x, float y) { return x+y;, 0); Vector<float> A(a, a+n); Vector<float> B(b, b+n); Vector<float> C = sum( mult(a, B) ); return C.front();

14 Neue Algorithmische Skelette Stencil Berechnungen Beispiel: Gaußscher Weichzeichner Allpairs Berechnungen Example: Matrix Multiplication 2 B T gauss M = stencil f 1 0M wo f die Funktion is welche den Gaußschen Weichzeichner beschreibt Unterstützung für mehre GPUs: CPU 1 3 A C (b) A B = allpairs dotproduct A B T Optimierung für zipreduce Muster: dotproduct a b = zipreduce (+) 0 ( ) a b 0 GPUs 1 overlap Verteilung Unterstützung für mehrere GPUs mit block und copy Verteilung

15 SkelCL Evaluation Geschwindigkeit mandelbrot linear algebra (dot product) matrix multiplication image processing (gaussian blur) medical imaging (LM OSEM) physics simulation (FDTD) 2.0 Relative Runtime OpenCL SkelCL OpenCL SkelCL OpenCL SkelCL OpenCL SkelCL OpenCL SkelCL OpenCL SkelCL SkelCL nahe an der Geschwindigkeit von OpenCL! (Ausnahme: dot product mehr dazu in Teil II)

16 SkelCL Evaluation Produktivität CPU code GPU code Relative Lines of Code mandelbrot linear algebra (dot product) matrix multiplication image processing (gaussian blur) medical imaging (LM OSEM) OpenCL SkelCL OpenCL SkelCL OpenCL SkelCL OpenCL SkelCL OpenCL SkelCL SkelCL Programme sind signifikant kürzer!

17 TEIL II Die Herausforderung der Performance-Portabilität

18 EIN NEUER ANSATZ ZUR PERFORMANCE PORTABLEN CODEGENERIERUNG

19 OpenCL und Performance-Portabilität Beispiel: Parallele Summation eines Arrays in OpenCL Vergleich von 7 OpenCL Implementierungen von Nvidia 200 Hardware Bandwidth Limit Bandwidth (GB/s) Impl. 1 Impl. 2 Impl. 3 Impl. 4 Impl. 5 Impl. 6 Impl. 7 cublas (a) Nvidia s GTX 480 GPU.

20 OpenCL und Performance-Portabilität 200 Hardware Bandwidth Limit Beispiel: Parallele Summation eines Arrays in OpenCL Vergleich von 7 OpenCL Implementierungen von Nvidia Bandwidth (GB/s) Impl. 1 Impl. 2 Impl. 3 Impl. 4 Impl. 5 Impl. 6 Impl. 7 cublas (a) Nvidia s GTX 480 GPU. 300 Hardware Bandwidth Limit 30 Hardware Bandwidth Limit Bandwidth (GB/s) Bandwidth (GB/s) Impl. 1 Impl. 2 Impl. 3 Impl. 4 Impl. 5 Impl. 6 Impl. 7 clblas 0 Impl. 1 Impl. 2 Impl. 3 Impl. 4 Failed Failed Failed Impl. 5 Impl. 6 Impl. 7 MKL (b) AMD s HD 7970 GPU. (c) Intel s E5530 dual-socket CPU. Performance in OpenCL ist nicht portabel!

21 Performance portable Codegenerierung mit Transformationsregeln BlackScholes Dot product Vector reduction... High-level programming High-level Expression Algorithmic Patterns iterate split map... reorder join reduce Algorithmic choices & Hardware optimizations Exploration with rewriting rules Low-level Expression OpenCL Patterns map-workgroup vectorize... tolocal map-local Code generation OpenCL Program Hardware Paradigms local memory workgroups... barriers vector units Figure 5.3: Overview of our code generation approach. Problems expressed

22 Beispiel: Parallele Summation vecsum = reduce (+) 0 rewrite rules code generation kernel void reduce6(global float* g_idata, global float* g_odata, unsigned int n, local volatile float* l_data) { unsigned int tid = get_local_id(0); unsigned int i = get_group_id(0) * (get_local_size(0)*2) + get_local_id(0); unsigned int gridsize = WG_SIZE * get_num_groups(0); l_data[tid] = 0; while (i < n) { l_data[tid] += g_idata[i]; if (i + WG_SIZE < n) l_data[tid] += g_idata[i+wg_size]; i += gridsize; barrier(clk_local_mem_fence); vecsum = reduce join map-workgroup join toglobal (map-local (map-seq id)) split 1 join map-warp join map-lane (reduce-seq (+) 0) split 2 reorder-stride 1 join map-lane (reduce-seq (+) 0) split 2 reorder-stride 2 join map-lane (reduce-seq (+) 0) split 2 reorder-stride 4 join map-lane (reduce-seq (+) 0) split 2 reorder-stride 8 join map-lane (reduce-seq (+) 0) split 2 reorder-stride 16 join map-lane (reduce-seq (+) 0) split 2 reorder-stride 32 split 64 join map-local (reduce-seq (+) 0) split 2 reorder-stride 64 join tolocal (map-local (reduce-seq (+) 0)) split (blocksize/128) reorder-stride 128 split blocksize Listing 5.13: Expression resembling the seventh implementation of parallel if (WG_SIZE >= 256) { if (tid < 128) { l_data[tid] += l_data[tid+128]; barrier(clk_local_mem_fence); if (WG_SIZE >= 128) { if (tid < 64) { l_data[tid] += l_data[tid+ 64]; barrier(clk_local_mem_fence); if (tid < 32) { if (WG_SIZE >= 64) { l_data[tid] += l_data[tid+32]; if (WG_SIZE >= 32) { l_data[tid] += l_data[tid+16]; if (WG_SIZE >= 16) { l_data[tid] += l_data[tid+ 8]; if (WG_SIZE >= 8) { l_data[tid] += l_data[tid+ 4]; if (WG_SIZE >= 4) { l_data[tid] += l_data[tid+ 2]; if (WG_SIZE >= 2) { l_data[tid] += l_data[tid+ 1]; if (tid == 0) g_odata[get_group_id(0)] = l_data[0];

24 Algorithmische Primitive map A,B,I :(A! B)! [A] I! [B] I zip A,B,I :[A] I! [B] I! [A B] I reduce A,I :((A A)! A)! A! [A] I! [A] 1 split A,I :(n :size)! [A] n I! [[A] n ] I join A,I,J :[[A] I ] J! [A] I J iterate A,I,J :(n :size)! ((m :size)! [A] I m! [A] m )! [A] I n J! [A] J

25 High-Level Programme scal = a.map ( a) asum = reduce (+) 0 map abs dot = xs ys.(reduce (+) 0 map ( )) (zip xs ys) gemv = mat xs ys.map (+) ( zip (map (scal dot xs) mat) (scal ys) )

28 Algorithmische Transformationsregeln Transformationsregeln sind semantikerhaltend Drücken Auswahl bei der algorithmische Implementierungen aus Split-Join Zerlegung: map f! join map (map f) split n Map Zusammenschluss: map f map g! map (f g) Reduktionsregeln: reduce fz! reduce fz reducepart fz reducepart fz! reducepart fz reorder reducepart fz! join map (reducepart fz) split n reducepart fz! iterate n (reducepart fz)

29 OpenCL Primitive Primitive mapglobal OpenCL Konzept Work-items mapworkgroup / maplocal Work-groups mapseq / reduceseq Sequentielle Implementierungen tolocal / toglobal Speicherbereiche mapvec / splitvec / joinvec Vektorisierung

30 OpenCL Transformationsregeln Drücken hardware-spezifische Optimierungen aus Map: map f! mapworkgroup f maplocal f mapglobal f mapseq f Lokaler/ Globaler Speicher: maplocal f! tolocal (maplocal f) maplocal f! toglobal (maplocal f) Vektorisierung: map f! joinvec map (mapvec f) splitvec n Map-Reduktion Zusammenschluss: reduceseq fz mapseq g! reduceseq ( (acc, x). f(acc, g x)) z

33 Muster basierte OpenCL Codegenerierung Generiere OpenCL Code für jedes OpenCL Primitiv mapglobal fxs for (int g_id = get_global_id(0); g_id < n; g_id += get_global_size(0)) { output[g_id] = f(xs[g_id]); reduceseq fzxs T acc = z; for (int i = 0; i < n; ++i) { acc = f(acc, xs[i]);..

34 Transformationsregeln definieren einen Suchraum gültiger Implementierungen reduce (+) 0 reduce (+) 0 reducepart (+) 0

35 Transformationsregeln definieren einen Suchraum gültiger Implementierungen reduce (+) 0 reduce (+) 0 reducepart (+) 0 reduce (+) 0 reducepart (+) 0 reorder reduce (+) 0 iterate n (reducepart (+) 0)

36 Transformationsregeln definieren einen Suchraum gültiger Implementierungen reduce (+) 0 reduce (+) 0 reducepart (+) 0 reduce (+) 0 reducepart (+) 0 reorder reduce (+) 0 iterate n (reducepart (+) 0)

37 Transformationsregeln definieren einen Suchraum gültiger Implementierungen reduce (+) 0 reduce (+) 0 reducepart (+) 0 reduce (+) 0 reducepart (+) 0 reorder reduce (+) 0 iterate n (reducepart (+) 0) reduce (+) 0 join map (reducepart (+) 0) split n

38 Transformationsregeln definieren einen Suchraum gültiger Implementierungen reduce (+) 0 reduce (+) 0 reducepart (+) 0 reduce (+) 0 reducepart (+) 0 reorder reduce (+) 0 iterate n (reducepart (+) 0) reduce (+) 0 join map (reducepart (+) 0) split n Vollautomatische Suche nach guten Implementierungen möglich! (Eine einfache Suchstrategie ist in der Dissertation beschrieben)

39 Evaluation Geschwindigkeit gegenüber einer funktional portablen Implementierung 4 Nvidia GPU AMD GPU Intel CPU Speedup small large small large small large small large scal asum dot gemv Black Scholes MD Bis zu 20x Speedup gegenüber der funktional portablen clblas Implementierung

40 Evaluation Geschwindigkeit gegenüber Hardware spezifischen Implementierungen Speedup over CUBLAS CUBLAS Generated small large small large small large small large scal asum dot gemv Speedup over clblas clblas Generated small large small large small large small large scal asum dot gemv Speedup over MKL MKL Generated small large small large small large small large scal asum dot gemv (a) Nvidia GPU (b) AMD GPU (c) Intel CPU Automatisch generierter Code vs. handoptimierten Code Konkurrenzfähige Ergebnisse vs. hochoptimierte Implementierungen Bis zu 4.5x Speedup für gemv auf der AMD GPU

41 Zusammenfassung Um die Herausforderung der Programmierbarkeit zu adressieren: Ein neuer Ansatz zur Programmierung von Systemen mit mehreren GPUs Zwei neue formell definierte und implementierte algorithmische Skelette Um die Herausforderung der Performance-Portabilität zu adressieren: Ein formelles System zur Transformation muster-basierter Programme Ein Codegenerator der Performance-Portabilität erreicht

42 Ergebnisse der Suche Automatisch Gefundene Ausdrücke asum = reduce (+) 0 map abs Nvidia GPU AMD GPU Intel CPU x.(reduceseq join join mapworkgroup ( toglobal maplocal (reduceseq ( (a, b). a+(abs b)) 0) reorderstride 2048 ) split 128 split 2048) x x.(reduceseq join joinvec join mapworkgroup ( maplocal (reduceseq (mapvec 2( (a, b). a+(abs b))) 0 reorderstride 2048 ) split 128 splitvec 2 split 4096) x x.(reduceseq join mapworkgroup (join joinvec maplocal ( reduceseq (mapvec 4( (a, b). a+(abs b))) 0 ) splitvec 4 split 32768) split 32768) x Gesucht für: Nvidia GTX 480 GPU, AMD Radeon HD 7970 GPU, Intel Xeon E5530 CPU

43 Ergebnisse der Suche Effizienz der Suche Absolute performance in GB/s Absolute performance in GB/s Absolute performance in GB/s Number of evaluated expressions Number of evaluated expressions Number of evaluated expressions (a) Nvidia GPU (b) AMD GPU (c) Intel CPU Die Suche hat auf jeder Platform weniger als 1 Stunde gedauert Durchschnittliche Zeit zur Ausführung eines Kandidaten weniger als 1/2 Sekunde

44 Fazit des Beispiels Optimieren in OpenCL ist kompliziert Verständnis für die Zielarchitektur benötigt Veränderungen im Program nicht offensichtlich kernel void reduce6(global float* g_idata, global float* g_odata, unsigned int n, local volatile float* l_data) { unsigned int tid = get_local_id(0); unsigned int i = get_group_id(0) * (get_local_size(0)*2) + get_local_id(0); unsigned int gridsize = WG_SIZE * get_num_groups(0); l_data[tid] = 0; while (i < n) { l_data[tid] += g_idata[i]; if (i + WG_SIZE < n) l_data[tid] += g_idata[i+wg_size]; i += gridsize; barrier(clk_local_mem_fence); kernel void reduce0(global float* g_idata, global float* g_odata, unsigned int n, local float* l_data) { unsigned int tid = get_local_id(0); unsigned int i = get_global_id(0); l_data[tid] = (i < n)? g_idata[i] : 0; barrier(clk_local_mem_fence); for (unsigned int s=1; s < get_local_size(0); s*= 2) { if ((tid % (2*s)) == 0) { l_data[tid] += l_data[tid + s]; barrier(clk_local_mem_fence); if (tid == 0) g_odata[get_group_id(0)] = l_data[0]; Nicht Optimierte Implementierung if (WG_SIZE >= 256) { if (tid < 128) { l_data[tid] += l_data[tid+128]; barrier(clk_local_mem_fence); if (WG_SIZE >= 128) { if (tid < 64) { l_data[tid] += l_data[tid+ 64]; barrier(clk_local_mem_fence); if (tid < 32) { if (WG_SIZE >= 64) { l_data[tid] += l_data[tid+32]; if (WG_SIZE >= 32) { l_data[tid] += l_data[tid+16]; if (WG_SIZE >= 16) { l_data[tid] += l_data[tid+ 8]; if (WG_SIZE >= 8) { l_data[tid] += l_data[tid+ 4]; if (WG_SIZE >= 4) { l_data[tid] += l_data[tid+ 2]; if (WG_SIZE >= 2) { l_data[tid] += l_data[tid+ 1]; if (tid == 0) g_odata[get_group_id(0)] = l_data[0]; Voll Optimierte Implementierung

45 Matrix Multiplikation C A B A x B = map(λ rowa map(λ colb dotproduct(rowa, colb), transpose(b)), A)

46 Suche für Matrix Multiplikation Phases: Algorithmic Exploration OpenCL speci c Exploration Parameter Exploration Code Generation......

47 Suchraum für Matrix Multiplikation 600 Fermi Kepler Tahiti 1500 Throughput (GFlop/s) Nur einige generierte OpenCL Programme mit sehr guter Performance

48 Performance Entwicklung für Matrix Multiplikation Selbst mit einer einfachen zufälligen Strategie kann man erwarten schnell ein Program mit guter Performance zu finden

49 Evaluation für Matrix Multiplikation Generated MAGMA cublas Nvidia GeForce GTX 480 (Fermi) Generated MAGMA cublas Nvidia GeForce GTX TITAN Black (Kepler) Throughput (Gflop/s) Generated clmagma clblas clblas Tuned Input Size 3000 AMD Radeon HD 7970 (Tahiti) Performance nahe oder sogar besser als handoptimierte MAGMA Bibliothek

50 Performance-Portabilität von Matrix Multiplikation 100 Executed on Fermi Kepler Tahiti Relative performance X X X X X X Executed with input size 0 X X 1K 2K 1K 2K 1K 2K Fermi Kepler Tahiti X X 1K 2K 1K 2K 1K 2K Fermi Kepler Tahiti The six specialized OpenCL kernels X X 1K 2K 1K 2K 1K 2K Fermi Kepler Tahiti Generierte Programmer sind spezialisiert für GPU und Eingabegröße