College 13: Patterns (2)

Transcriptie

1 Concurrency Gerard Tel / Jacco Bikker - november 2016 februari 2017 College 13: Patterns (2) Welkom!

2 genda: Collective Operations Reduce Scan Stencil Recurrence

3 Concurrency college 13 Patterns (2) 3 Collectives sequence Wat vooraf ging map nesting (dynamisch) nesting fork dependency divide & conquer

4 Concurrency college 13 Patterns (2) 4 Collectives Wat vooraf ging SIMD: Vector parallellisme (aka parallellisme op instructie-niveau) Regular parallelism Data parallellisme Map pattern OpenCL / GPGPU: Single Instruction Multiple Thread / Lockstep Streaming algorithms Regular parallelism Data parallellisme Map pattern

5 Concurrency college 13 Patterns (2) 5 Collectives Wat vooraf ging

6 Concurrency college 13 Patterns (2) 6 Collectives Collective Operations Verzameling van patterns voor het verwerken van verzamelingen als geheel in plaats van als individuele elementen. Voorbeelden: Reduce Scan Stencil Recurrence Collective operations zijn de patronen die we toepassen op embarrassing parallelism.

7 genda: Collective Operations Reduce Scan Stencil Recurrence

8 Concurrency college 13 Patterns (2) 8 Reduce Reduction Combineren van data tot een enkel gegeven. Combineer n input elementen met combiner functie : +, * -, / matrix vermenigvuldiging min, max addition with saturation complexe functie specificeerbare functie

9 Concurrency college 13 Patterns (2) 9 Reduce Reduction Combineer n input elementen met combiner functie x 0 x 1 x 2 x 3 x 4 x 5 y = n 1 x i i=0 + + Wat als n = 0? + y = n 1 i=0 x i, voor n > 0 0, voor n = y

10 Concurrency college 13 Patterns (2) 10 Reduce Reduction Combineer n input elementen met combiner functie Wat als n = 0? y = n 1 i=0 x i assert( n > 0 ); y = x[0]; for( int i = 1; i < n; i++ ) y += x[i]; y = n 1 i=0 x i, voor n > 0 0, voor n = 0 y = identity; for( int i = 0; i < n; i++ ) y += x[i];

11 Concurrency college 13 Patterns (2) 11 Reduce Reduction Toepassingen: Gemiddelde waarde berekenen (Bijvoorbeeld voor exposure control) Bepalen hoeveel elementen voldoen aan een bepaalde voorwaarde Dieptebereik van een beeld bepalen (min, max z)

12 Concurrency college 13 Patterns (2) 12 Reduce Reduction Combineer n input elementen met combiner functie De reductie kan in parallel worden uitgevoerd: N/2 threads combineren steeds twee elementen. De parallelle reductie vergt log 2 N stappen, maar alleen wanneer we altijd N/2 threads kunnen gebruiken. Let op: optional parallelism neemt snel af (dit is het omgekeerde van wat er bij divide and conquer gebeurde).

13 Concurrency college 13 Patterns (2) 13 Reduce Reduction Combineer n input elementen met combiner functie Voorbeeld: dot product (NED: inproduct). c = B c = x B x + y B y + z B z c = N 1 i=0 i B i

14 Concurrency college 13 Patterns (2) 14 Reduce Reduction Combineer n input elementen met combiner functie Parallelle executie verandert de volgorde waarin we operaties uitvoeren. is een binaire operatie, i.e.: f: S S S. Om bij herordenen hetzelfde resultaat te krijgen moet associatief zijn.

15 Concurrency college 13 Patterns (2) 15 Reduce Reduction Om bij herordenen hetzelfde resultaat te krijgen moet associatief zijn. ssociatief: X Y Z = X (Y Z) Commutatief: X Y = Y X ssociatief Commutatief +, * -, / matrix * matrix min, max signed addition w/ saturation complexe functie specificeerbare functie????

16 Concurrency college 13 Patterns (2) 16 Reduce Reduction Signed addition with saturation associativiteit: Om bij herordenen hetzelfde resultaat te krijgen moet associatief zijn. Byte / unsigned char: = 100 B = 100 C = -50 +(B+C) = (100-50) = = 127 (+B)+C = ( ) - 50 = = 77

17 Concurrency college 13 Patterns (2) 17 Reduce Reduction Combineer n input elementen met combiner functie Om bij herordenen hetzelfde resultaat te krijgen moet associatief zijn. c = x B x + y B y + z B z c = x B x + ( y B y + z B z )

18 Concurrency college 13 Patterns (2) 18 Reduce Reduction ssociatief: X Y Z = X (Y Z) Commutatief: X Y = Y X ssociatief Commutatief +, * -, / matrix * matrix min, max signed addition w/ saturation complexe functie specificeerbare functie floating point +, *??????

19 Concurrency college 13 Patterns (2) 19 Reduce Reduction Floating point add / mul associativiteit: Stel: = B = C = En: floating point waarden worden met 7 posities opgeslagen. Dan: = = = = = =

20 Concurrency college 13 Patterns (2) 20 Reduce Reduction ssociatief: X Y Z = X (Y Z) Commutatief: X Y = Y X ssociatief Commutatief +, * -, / matrix * matrix min, max signed addition w/ saturation complexe functie specificeerbare functie floating point +, *????

21 Concurrency college 13 Patterns (2) 21 Reduce Reduction Voor reduction is alleen associativiteit vereist. y = x 0 x 1 x 2 x 3 x 4 x 5 x 0 x 1 x 2 x 3 x 4 x 5 = ((((x 0 x 1 ) x 2 ) x 3 ) x 4 ) x 5 = x 0 x 1 x 2 x 3 x 4 x 5 y

22 Concurrency college 13 Patterns (2) 22 Reduce Reduction Voor reduction is alleen associativiteit vereist. x 0 x 1 x 2 x 3 x 4 x 5 y = x 0 x 1 x 2 x 3 x 4 x 5 = ((((x 0 x 1 ) x 2 ) x 3 ) x 4 ) x 5 = x 0 x 1 x 2 x 3 x 4 x 5 y

23 Concurrency college 13 Patterns (2) 23 Reduce Reduction x 0 x 1 x 2 x 3 x 4 x 5 x 6 x 7 Vector operatie Scalar operaties y

24 Concurrency college 13 Patterns (2) 24 Reduce x 0 x 1 x 2 x 3 x 4 x 5 x 6 x 7 x 8 x 9 x 10 x 11 x 12 x 13 x 14 x 15 Reductie met vector operaties: convergeert naar optimale benutting van vector hardware. Let op: dit vereist naast associativiteit ook commutativiteit. y

25 Concurrency college 13 Patterns (2) 25 Reduce Reduction Dit vereist commutativiteit : Dit is goed te zien wanneer we 2-wide SIMD gebruiken. x 0 + x 1 + x 2 + x 3 (x 0 + x 2 ) + (x 1 + x 3 ) x 1 en x 2 zijn van plaats verwisseld.

26 Concurrency college 13 Patterns (2) 26 Reduce Reduction ssociatief: X Y Z = X (Y Z) Commutatief: X Y = Y X ssociatief Commutatief +, * -, / matrix * matrix min, max signed addition w/ saturation complexe functie specificeerbare functie floating point +, *???? Parallelle reductie: Vereist associativiteit en (voor efficiënt gebruik van vector instructies) commutativiteit. Onder deze voorwaarden is optimaal gebruik van vector hardware mogelijk (SIMD / GPU).

27 Concurrency college 13 Patterns (2) 27 Reduce Parallel Reduction Samenvatting: Uit te voeren in log 2 N stappen, met N/2 threads voor de eerste stap. Uit te voeren met SIMD; hierbij wordt de vector hardware vrijwel volledig benut. Valkuil: Floating point addition & multiplication is niet (volledig) associatief. Parallel reduction is in dat geval dus niet deterministisch.

28 genda: Collective Operations Reduce Scan Stencil Recurrence

29 Concurrency college 13 Patterns (2) 29 Scan lle reducties van een input set, met als resultaat een output set met dezelfde omvang. Twee varianten: Inclusive: Exclusive: y n = y n = n i=0 n 1 i=0 x i x i

30 Concurrency college 13 Patterns (2) 30 Scan Voorbeeld: Summed rea Table I Σ x, y = x x y y i(x, y )

31 Concurrency college 13 Patterns (2) 31 Scan Voorbeeld: Summed rea Table I Σ x, y = x x y y i(x, y ) Met een ST kunnen we een box filter van willekeurige grootte bepalen in O(1) tijd: V = I C I D I B + I w h D B C

32 Concurrency college 13 Patterns (2) 32 Scan Summed rea Table - Separation Scan 0 Scan 0 Scan Scan 0 0

33 Concurrency college 13 Patterns (2) 33 Scan Summed rea Table - Separation Scan Scan Scan Scan Scan 0 0 Scan 0 0 Scan 0 0 Scan 0 0

34 Concurrency college 13 Patterns (2) 34 Scan Voorbeeld: Caveman Hoe weet thread 1 dat de eerste output op positie 4 in de array moet komen? thread 0 thread 1 1. Dat weet thread 1 helemaal niet; beide threads doen atomic incs om te voorkomen dat ze dezelfde array positie beschrijven.

35 Concurrency college 13 Patterns (2) 35 Scan Voorbeeld: Caveman Hoe weet thread 1 dat de eerste output op positie 4 in de array moet komen? thread 0 thread 1 1. Dat weet thread 1 helemaal niet; beide threads doen atomic incs om te voorkomen dat ze dezelfde array positie beschrijven. (de data van thread 1 en 2 staat nu door elkaar in de output array; is dat een probleem?)

36 Concurrency college 13 Patterns (2) 36 Scan Voorbeeld: Caveman Hoe weet thread 1 dat de eerste output op positie 4 in de array moet komen? thread 0 thread 1 1. Dat weet thread 1 helemaal niet; beide threads doen atomic incs om te voorkomen dat ze dezelfde array positie beschrijven. 2. Met een scan.

37 Concurrency college 13 Patterns (2) 37 Scan Voorbeeld: Caveman Hoe weet thread 1 dat de eerste output op positie 4 in de array moet komen? thread 0 thread 1 thread 2 thread 3 thread 4 thread 5 thread 6 thread 7 1. Dat weet thread 1 helemaal niet; beide threads doen atomic incs om te voorkomen dat ze dezelfde array positie beschrijven. 2. Met een scan. exclusive scan:

38 Concurrency college 13 Patterns (2) 38 Scan Identity waarde lle reducties van een input set, met als resultaat een output set met dezelfde omvang. // inclusive total = 0; for( int i = 0; i < n; i++ ) { total += x[i]; y[i] = total; // loop-carried dependency } // exclusive total = 0; for( int i = 0; i < n; i++ ) { y[i] = total; // loop-carried dependency total += x[i]; }

39 Concurrency college 13 Patterns (2) 39 Scan

40 Concurrency college 13 Patterns (2) 40 Scan Identity waarde Nuttig voor tiled parallel scan. Tiled: meerdere seriële scans in parallel. Seriële scans: O(1) opslag, versus O(n) voor de parallelle versie.

41 Concurrency college 13 Patterns (2) 41 Scan Parallel Scan for( d = 0; d < log 2 n; d++ ) for all k in parallel do if k >= 2 d x[k] += x[k 2 d ] d=0, 2 d = 1 d=1, 2 d = 2 d=2, 2 d =

42 Concurrency college 13 Patterns (2) 42 Scan Parallel Scan Span: log n Work: ~ n log n d=1, 2 d 1 = S P = T 1 T n log n log n = n d=2, 2 d 1 = T 1 met het seriële algoritme: n S P = T 1 T = n log n d=3, 2 d 1 =

43 Concurrency college 13 Patterns (2) 43 Scan Parallel Scan De parallel scan, uitgevoerd op de 32 threads in een warp (OpenCL): for( d = 0; d < log 2 n; d++ ) for all k in parallel do if k >= 2 d x[k] += x[k 2 d ] int scan_exclusive( local int* input, int lane ) { if (lane > 0 ) input[lane] += input[lane - 1]; if (lane > 1 ) input[lane] += input[lane - 2]; if (lane > 3 ) input[lane] += input[lane - 4]; if (lane > 7 ) input[lane] += input[lane - 8]; if (lane > 15) input[lane] += input[lane - 16]; return (lane > 0)? input[lane - 1] : 0; }

44 Concurrency college 13 Patterns (2) 44 Scan Parallel Scan CaveMan zal al snel meer taken dan 32 hebben. Waarom is de warp scan dan nuttig? 32 threads weten hoeveel ruimte ze samen nodig hebben in de output array; elk van de 32 threads weet welk deel van die ruimte beschikbaar is (zonder atomic); slechts één van de threads voert de atomic add uit. De warp scan beperkt dus het aantal atomics. for( d = 0; d < log 2 n; d++ ) for all k in parallel do if k >= 2 d x[k] += x[k 2 d ] Zie ook: Kepler TM GK110/210 Whitepaper, tomic operations can often be processed at rates similar to global load operations.

45 Concurrency college 13 Patterns (2) 48 Scan Parallel Scan Toepassingen: Stream Compaction : Caveman, ray tracing,... Filter : verwijder gemarkeerde elementen, QuickSort : partitioneren De parallel scan is een generieke tool.

46 genda: Collective Operations Reduce Scan Stencil Recurrence

47 Concurrency college 13 Patterns (2) 50 Stencil Een map waarbij elke output wordt bepaald op basis van een reeks inputs met een set vaste offsets t.o.v. de output positie.

48 Concurrency college 13 Patterns (2) 51 Stencil Een map waarbij elke output wordt bepaald op basis van een reeks inputs met een set vaste offsets t.o.v. de output positie.

49 Concurrency college 13 Patterns (2) 52 Stencil 2D Stencil Kenmerken: iedere kernel heeft meerdere inputs; kernels gebruiken elkaars output niet; overlap van kernel input; speciale gevallen langs de randen.

50 Concurrency college 13 Patterns (2) 53 Stencil 2D Stencil - Efficiënte uitzonderingen for( int x = 0; x < W; x++ ) { for( int y = 0; y < H; y++ ) { input1 = read_grid[y - 1][x]; input2 = read_grid[y][x + 1]; input3 = read_grid[y + 1][x]; input4 = read_grid[y][x - 1]; output = blend( input1 input4 ); } } Let op: conditional code!

51 Concurrency college 13 Patterns (2) 54 Stencil 2D Stencil - Cache for( int x = 0; x < W; x++ ) { for( int y = 0; y < H; y++ ) { input1 = read_grid[y - 1][x]; input2 = read_grid[y][x + 1]; input3 = read_grid[y + 1][x]; input4 = read_grid[y][x - 1]; output = blend( input1 input4 ); } } Let op: memory access pattern

52 Concurrency college 13 Patterns (2) 55 Stencil 2D Stencil - Cache for( int y = 0; y < H; y++ ) { for( int x = 0; x < W; x++ ) { input1 = read_grid[y - 1][x]; input2 = read_grid[y][x + 1]; input3 = read_grid[y + 1][x]; input4 = read_grid[y][x - 1]; output = blend( input1 input4 ); } }

53 Concurrency college 13 Patterns (2) 56 Stencil 2D Stencil - Tiling Voor grote datasets kan significante overlap tussen de inputs voor twee regels toch leiden tot slechte benutting van de cache.

54 Concurrency college 13 Patterns (2) 57 Stencil 2D Stencil - Tiling Voor grote datasets kan significante overlap tussen de inputs voor twee regels toch leiden tot slechte benutting van de cache. Optimale data locality wordt bereikt met een Morton curve.

55 Concurrency college 13 Patterns (2) 58 Stencil 2D Stencil Minimaliseren van branch misprediction: gebruik een kernel voor interior nodes, en één voor boundary nodes. Optimaliseren van data locality: verwerk de set zoveel mogelijk lineair; gebruik tiling, afgestemd op de grootte van de cache; gebruik een Morton curve.

56 genda: Collective Operations Reduce Scan Stencil Recurrence

57 Concurrency college 13 Patterns (2) 60 Recurrence Een map waarbij elke output wordt bepaald op basis van een reeks outputs met een set vaste offsets t.o.v. de output positie.

58 Concurrency college 13 Patterns (2) 61 Recurrence Kenmerken Geneste loop met regelmatige data dependencies Speciale gevallen langs de randen Parallelle verwerking: Separating hyperplanes Separable filters

59 Concurrency college 13 Patterns (2) 62 Recurrence Separating hyperplanes Voor cellen op een hyperplane geldt dat alle benodigde resultaten berekend zijn op een eerder verwerkt hyperplane.

60 Concurrency college 13 Patterns (2) 63 Recurrence Separating hyperplanes Voor cellen op een hyperplane geldt dat alle benodigde resultaten berekend zijn op een eerder verwerkt hyperplane. for( int y = 0; y < 4; y++ ) { for( int x = 0; x < 4; x++ ) { v[y][x] = average( v[y 1][x], v[y][x + 1], v[y + 1][x], v[y][x 1] ); } }

61 Concurrency college 13 Patterns (2) 64 Recurrence Voorbeeld: Summed rea Table Serieel: cell(x,y) += cell(x-1,y) + cell(x,y-1) cell(x-1,y-1)

62 genda: Collective Operations Reduce Scan Stencil Recurrence

63 Concurrency college 13 Patterns (2) 67 Tot Slot Collectives Verzameling van patterns voor het verwerken van verzamelingen als geheel in plaats van als individuele elementen. Reduce Scan Stencil Recurrence Deze patronen zijn vooral nuttig voor GPU en SIMD code.

64 Concurrency college 13 Patterns (2) 68 Tot Slot Leesmateriaal: Boek hoofdstuk 5 en 7

65 Concurrency Gerard Tel / Jacco Bikker - november 2016 februari 2017 EINDE van Patterns (2) volgende college: Monte Carlo