College 4: Mechanismen

Transcriptie

1 Concurrency Gerard Tel / Jacco Bikker - november 2017 februari 2018 College 4: Mechanismen Welkom!

2 Agenda: Wat vooraf ging Hardware

3 Electronic components are submerged into a bath of dielectric heat transfer liquids, which are much better heat conductors than air, water or oil. With their various low boiling points (ie. 49 C vs. 100 C in water), the fluids boil on the surface of heat generating components and rising vapor passively takes care of heat transfer.

4 Concurrency College 4 Mechanismen 4 Previously in Concurrency Alles Parallel: Desktops, laptops, consoles, handhelds, telefoons, smartwatches: vrijwel iedere processor heeft meerdere cores. Power Wall + IP Wall + Memory Wall = Brick Wall Optimaal gebruik van rekencapaciteit vereist parallellisme: meerdere cores instruction-level parallelism heterogene architecturen

5 Concurrency College 4 Mechanismen 5 Previously in Concurrency Alles Parallel: Desktops, laptops, consoles, handhelds, telefoons, smartwatches: vrijwel iedere processor heeft meerdere cores. Power Wall + IP Wall + Memory Wall = Brick Wall Optimaal gebruik van rekencapaciteit vereist parallellisme. Het verdelen van werk over threads heeft beperkingen: het schaalt slecht parallellisme is efficiënter wanneer we de verdeling over hardware loskoppelen van de opdeling in taken.

6 Concurrency College 4 Mechanismen 6 Previously in Concurrency Doelstellingen In de toepassing van parallellisme streven we naar Performance (en schaalbaarheid) Productiviteit (inclusief correctheid, duidelijkheid, voorspelbaarheid) Portability Programming should focus on the decomposition of the problem and the design of the algorithm rather than the specific mechanisms by which it will be parallelized.

7 Agenda: Wat vooraf ging Hardware

8 Concurrency College 4 Mechanismen 8 Taak versus Data Doelen: Schaalbaarheid: meer cores is meer performance Performance: dubbel zo veel cores dubbele performance Correctheid: bij parallelliseren blijft de code zoveel mogelijk ongewijzigd Voorspelbaarheid: liefst met weinig synchronisatie Portability: fijn als de parallelle code ook makkelijk op bijv. een GPU kan draaien Veel van deze doelen zijn makkelijker te realiseren wanneer we overstappen van taak-parallellisme op data-parallellisme.

9 Concurrency College 4 Mechanismen 9 Taak versus Data We kennen taken en data van Object Oriented Programming: een class heeft properties en methods we hebben gewoonlijk meerdere instances van de class dezelfde method wordt gewoonlijk voor meerdere instances uitgevoerd. Vaak is hierbij sprake van afhankelijkheden (dependencies), die parallelle uitvoering in de weg staan.

10 Concurrency College 4 Mechanismen 10 Afhankelijkheden / Dependencies We moeten eerst de positie van de auto updaten voordat we kunnen testen of de auto iets raakt. vec3 Position vec3 Velocity float Weight float RPM bool brake void Accelerate(); void UpdatePosition(); void HandleCollision(); Op kleinere schaal: We moeten eerst de kwadraten van de componenten optellen voordat we met een wortel de lengte van een vector kunnen bepalen vec3 xyz; void Normalize(); float ength(); void Scale( float s );

11 Concurrency College 4 Mechanismen 11 Afhankelijkheden / Dependencies camera world T camera T buggy T car1 T plane1 T car2 T plane2 car plane car plane buggy wheel wheel wheel wheel wheel wheel wheel wheel wheel wheel wheel wheel turret turret dude dude dude

12 Concurrency College 4 Mechanismen 12 Afhankelijkheden / Dependencies Taak Y kan pas uitgevoerd worden nadat taak X is afgerond. void prefix_sum( int* a, int N ) for( int i = 1; i < N; i++ ) a[i] = a[i] + a[i 1]; In: 2, 1, 5, 0, 1, 4 Uit: 0, 2, 3, 8, 8, 9 int Pivot( a[], first, last )... void QuickSort( a[], first, last) if (first >= last) return; pivotelement = Pivot( a, first, last ); QuickSort( a, first, pivotelement - 1 ); QuickSort( a, pivotelement + 1, last );

13 Concurrency College 4 Mechanismen 13 Afhankelijkheden / Dependencies Taak Y kan pas uitgevoerd worden nadat taak X is afgerond. User input Physics AI Game logic Networking Sound Rendering

14 Concurrency College 4 Mechanismen 14 Particle engine: DATA Spawn Particles Apply Forces Trace Particles to New Positions Update Particle Path Render Particles Kill Particles at End of ife Vervang inactieve particles Bereken som van wind, zwaartekracht etc. Beweeg particles, check obstakels Pas richting aan na eventuele botsing Teken actieve particles Elimineer particles meer TAKEN dependencies Performance (en schaalbaarheid)? Productiviteit (inclusief correctheid, duidelijkheid, voorspelbaarheid)? Portability?

15 Concurrency College 4 Mechanismen 15 Afhankelijkheden / Dependencies Taak Y kan pas uitgevoerd worden nadat taak X is afgerond. // Created by inigo quilez - iq/2013 // icense Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported icense. float f(vec3 p) p.z+=iglobaltime; return length(.05*cos(9.*p.y*p.x)+cos(p)-.1*cos(9.*(p.z+.3*p.x-p.y)))-1.; void mainimage( out vec4 c, vec2 p ) vec3 d=.5-vec3(p,1)/iresolution.x,o=d;for(int i=0;i<99;i++)o+=f(o)*d; c=vec4(abs(f(o-d)*vec3(0,.1,.2)+f(o-.6)*vec3(.2,.1,0))*(10.-o.z),1); Pixel shaders (GPU): iedere pixel is een taak pixels communiceren niet onderling.

16 Concurrency College 4 Mechanismen 16 Afhankelijkheden / Dependencies Taak Y kan pas uitgevoerd worden nadat taak X is afgerond. void mainimage( out vec4 c, vec2 p ) vec2 d =.5 - p / iresolution.y; float dist = sqrt( dot( d, d ) ); c = (dist < 0.2)? vec4( 1, 0, 0, 0 ) : vec4( 0, 0, 0, 0 ); void mainimage( out vec4 c, vec2 p ) vec2 d =.5 - p / iresolution.y; d.x += 0.4 * cos( p.y * iglobaltime ); float dist = sqrt( dot( d, d ) ); c = (dist < 0.2)? vec4( 1, 0, 0, 0 ) : vec4( 0, 0, 0, 0 );

17 Concurrency College 4 Mechanismen 17

18 Concurrency College 4 Mechanismen 18 public void BlurCopy( Surface source, Surface target ) // blur the image int src = 5 * source.width, dst = 5 * target.width; for( int y = 5; y < target.height - 6; y++ ) for( int x = 5; x < target.width - 6; x++ ) int red = 0, green = 0, blue = 0; for( int v = -5; v < 6; v++ ) for( int u = -5; u < 6; u++ ) int pixelidx = src + x + u + v * source.width; red += (source.pixels[pixelidx] >> 16) & 255; green += (source.pixels[pixelidx] >> 8) & 255; blue += source.pixels[pixelidx] & 255; red = (red * 34663) >> 22; // fixed point division by 121 green = (green * 34663) >> 22; blue = (blue * 34663) >> 22; target.pixels[dst + x] = blue + (green << 8) + (red << 16); dst += target.width; src += source.width;

19 Concurrency College 4 Mechanismen 19 Sneller filteren: Summed Area Table I Σ x, y = i(x, y ) CDBA A B x x y y Met een SAT kunnen we een box filter van willekeurige grootte bepalen in O(1) tijd: D C V = I C I D I B + I A w h

20 Concurrency College 4 Mechanismen 20 Sneller filteren: Summed Area Table I Σ x, y = x x y y i(x, y ) void prefix_sum( int* a, int N ) a[0] = 0; for( int i = 1; i < N; i++ ) a[i] = a[i] + a[i 1]; In: 3, 1, 2, 0, 2, 4 Uit: 0, 3, 4, 6, 6, 8

21 Concurrency College 4 Mechanismen 21 Dependency: Taak Y kan pas uitgevoerd worden nadat taak X is afgerond. prefix_sum: algoritme in de huidige vorm kan alleen sequentieel worden uitgevoerd; iedere iteratie van de for-loop heeft het resultaat van de vorige nodig. Game engine: user input, physics, AI, game logic en audio zijn onafhankelijk van elkaar (in dit voorbeeld). De eerste vier moeten echter klaar zijn voordat rendering kan beginnen. Pixel shader: de berekening van iedere pixel is volledig onafhankelijk van de andere pixels: embarrassingly parallel.

22 Concurrency College 4 Mechanismen 22 Taken en data De game engine en de pixel shader voorbeelden laten nog wat anders zien: In de pixel shader schaalt het aantal taken met de omvang van de invoer: input data = pixel positie N = pixel count In de game engine ligt het aantal taken vast (al kunnen we dit wel verhogen door een taak verder op te delen). Het eerste noemen we data parallellisme; het tweede noemen we taak parallellisme. Boek: regular parallelism en irregular parallelism. Schaalbaarheid wordt bereikt met data parallellisme.

23 Agenda: Wat vooraf ging Hardware

24 Concurrency College 4 Mechanismen 24 Thread Parallellisme Taken worden parallel uitgevoerd door threads. Een multi-core processor heeft hardware support voor threads: Minimaal een thread per core; In geval van hyperthreading doet elke core zich voor als twee cores. Threads kunnen ook door het OS gesimuleerd worden: dit noemen we software threads.

25 Concurrency College 4 Mechanismen 25 Thread Parallellisme Windows en inux zijn voorbeelden van operating systems die preemptive multitasking toepassen. Preemption: het tijdelijk onderbreken van een taak, waarbij het de bedoeling is dat die taak later voortgezet wordt. Windows 3.1 gebruikte cooperative multitasking: ieder proces diende ervoor te zorgen dat het regelmatig de controle teruggaf aan het systeem. Het wisselen van actieve taak heet een context switch. De tijd die een taak mag gebruiken voordat het OS een andere taak actief maakt heet een time slice. Het wisselen van taken gebeurd door de scheduler. De scheduler zelf wordt geactiveerd door interrupts.

26 Concurrency College 4 Mechanismen 26 Thread Parallellisme Threads op een hyperthreaded core worden niet door het OS gewisseld. Het OS ziet in plaats van de hyperthreaded core twee cores; de CPU zelf wisselt tussen de taken op de twee cores. De hyperthreaded core wisselt taken wanneer er sprake is van latency, bijvoorbeeld bij het lezen van geheugen.

27 Concurrency College 4 Mechanismen 27 Vector Parallellisme Meerdere (bijna) identieke taken kunnen uitgevoerd worden met vector instructies (SIMD*). m128 x4 = _mm_set_ps( 1, 5, 3.14, 0.1 ); m128 y4 = _mm_set_ps( 2, 2, 2, 2 ); m128 result4 = _mm_add_ps( x4, y4 ); // result: 3, 7, 5.14, 2.1 Dit noemen we ook instruction level parallelism. Vector instructies verwerken gewoonlijk 4 (SSE) of 8 (AVX) streams. Een enkele thread in een vector flow noemen we een lane. Vector parallellisme vereist data parallellisme. *: SIMD: Single Instruction Multiple Data. Meer in lecture 7.

28 Concurrency College 4 Mechanismen 28 Vector Parallellisme core 0 core 1 core 2 core 3 T0 T1 T2 T3 T4 T5 T6 T Quad-core processor: = 32 lanes E v3, 18 cores, AVX: = 288 lanes Hoeveel data gebruiken deze CPUs per kloktik? i7: 32 * sizeof( float ) = 128 bytes E7: 288 * sizeof( float ) = 1152 bytes

29 Concurrency College 4 Mechanismen 29 CPU Architectuur Een quad-core CPU heeft 8 logische cores. T0 T1 1 I-$ 1 D-$ 2 $ Elke core heeft een kleine hoeveelheid cache geheugen, de 1 cache (onderverdeeld in instruction cache en data cache). Elke core heeft een grotere (maar langzamere) 2 cache. T2 T3 T4 T5 1 I-$ 1 D-$ 1 I-$ 1 D-$ 2 $ 2 $ 3 $ Alle cores delen gezamenlijk de 3 cache. T6 T7 1 I-$ 1 D-$ 2 $

30 Concurrency College 4 Mechanismen 30 CPU Architectuur Waarom heeft een CPU caches nodig? aten we aannemen dat de CPU op 4.2 Ghz draait. Wat is dan de maximale afstand tussen RAM en CPU, als we onze data binnen 1 cycle willen hebben? ichtsnelheid (vacuüm): m/s. Per cycle: m 3.6 cm heen en weer

31 Concurrency College 4 Mechanismen 31 CPU Architectuur Fysieke afstand tussen RAM en CPU is niet het enige probleem. Bij het lezen en schrijven van en naar RAM spelen twee factoren een rol: 1. latency: de tijd tussen het aanvragen en ontvangen van data; 2. bandbreedte: de hoeveelheid data die in een bepaalde tijd verplaatst kan worden.

32 Concurrency College 4 Mechanismen 32 CPU Architectuur Voorbeeld: New Horizons communiceert met een bandbreedte van 1 kbit/s met de aarde*. Responsetijd (latency) is 540 minuten (2 x 4.5 uur). Voor RAM is dit: atency: cycles Bandbreedte: ~12.8GB/s** * **

33 Concurrency College 4 Mechanismen 33 CPU Architectuur Caches reduceren de vertraging als gevolg van memory access op door een subset van het geheugen dichtbij de CPU, in zeer snel geheugen op te slaan. Uitwisseling van data tussen RAM en de verschillende caches gebeurd met 64 bytes tegelijk. 32KB I / 32KB D per core 256KB per core 8MB x GB registers: 0 cycles level 1 cache: 4 cycles level 2 cache: 11 cycles level 3 cache: 39 cycles RAM: 107 cycles

34 Concurrency College 4 Mechanismen 34 CPU Architectuur Het gebruik van caches heeft gevolgen: T0 T1 1 I-$ 1 D-$ 2 $ Wanneer fysieke cores naar dezelfde geheugenadressen schrijven moeten de caches gescynchroniseerd worden. Voorbeeld: 8 threads werken aan een lijst taken: T2 T3 T4 T5 1 I-$ 1 D-$ 1 I-$ 1 D-$ 2 $ 2 $ 3 $ while (numtasks > 0) int mytask = --numtasks; ExecuteTask( mytask ); T6 T7 1 I-$ 1 D-$ 2 $ Dit is een voorbeeld van false sharing.

35 Concurrency College 4 Mechanismen 35 CPU Architectuur Het gebruik van caches heeft gevolgen: T0 T1 1 I-$ 1 D-$ 2 $ Data gelezen door een thread wordt gecached door een core. Het is van belang dat een volgende time slice van deze thread door dezelfde core wordt uitgevoerd. T2 T3 T4 T5 1 I-$ 1 D-$ 1 I-$ 1 D-$ 2 $ 2 $ 3 $ T6 T7 1 I-$ 1 D-$ 2 $

36 Concurrency College 4 Mechanismen 36 CPU Architectuur Het gebruik van caches heeft gevolgen: T0 T1 1 I-$ 1 D-$ 2 $ 1 cache wordt gedeeld door twee logische cores. Wanneer deze twee cores aan verschillende data werken hebben ze dus elk de helft van de ruimte. Dit is uiteraard niet het geval wanneer beide cores dezelfde data nodig hebben. T2 T3 T4 T5 1 I-$ 1 D-$ 1 I-$ 1 D-$ 2 $ 2 $ 3 $ T6 T7 1 I-$ 1 D-$ 2 $

37 Concurrency College 4 Mechanismen 37 CPU Architectuur Het lezen en schrijven van complete cache lines heeft gevolgen: Bandbreedte wordt optimaal benut wanneer we alle data van een cache line benutten. T0 T1 T2 T3 T4 T5 1 I-$ 1 D-$ 1 I-$ 1 D-$ 1 I-$ 1 D-$ 2 $ 2 $ 2 $ 3 $ T6 T7 1 I-$ 1 D-$ 2 $

38 Concurrency College 4 Mechanismen 38 CPU Architectuur class CacheTest static int[] data = new int[1024 * 1024 * 16]; public static void Init() for( int i = 0; i < 1024 * 1024 * 16; i++ ) data[i] = i; public static void Main() Init(); while (true) // for( int i = 0; i < 1024 * 1024 * 16; i++ ) data[i] *= 2; for( int i = 0; i < 1024 * 1024 * 16; i += 16 ) data[i] *= 2;

39 Concurrency College 4 Mechanismen 39 CPU Architectuur Het lezen en schrijven van complete cache lines heeft gevolgen: Bandbreedte wordt optimaal benut wanneer we alle data van een cache line benutten. Schrijven naar geheugen is gewoonlijk duurder dan lezen. False sharing treedt niet alleen op wanneer verschillende cores naar hetzelfde adres schrijven, maar ook wanneer verschillende cores naar dezelfde cache line schrijven. T0 T1 T2 T3 T4 T5 T6 T7 1 I-$ 1 D-$ 1 I-$ 1 D-$ 1 I-$ 1 D-$ 1 I-$ 1 D-$ 2 $ 2 $ 2 $ 2 $ 3 $

40 Concurrency College 4 Mechanismen 40 CPU Architectuur False sharing voorbeeld 2: int aantal[4] = 0, 0, 0, 0 ; void SorteerKaarten() kaartnr = --stapel.hoogte; switch (kaart[kaartnr].kleur) case SCHOPPEN: aantal[0]++; break; case HARTEN: aantal[1]++; break; case RUITEN: aantal[2]++; break; case KAVEREN: aantal[3]++; break;

41