College 17: Monte-Carlo

Transcriptie

1 Concurrency Gerard Tel / Jacco Bikker - november 2017 februari 2018 College 17: Monte-Carlo Welkom!

2 Agenda: Monte-Carlo Heterogeneous Computing Brigade Toets 2

3 Concurrency college 17 Monte-Carlo 3 Monte-Carlo Integreren PI: Of gewoon: de oppervlakte van een circel met radius 1. (want: oppervlakte = πr 2 ) Of: De oppervlakte van de cirkel gedeeld door de oppervlakte van het rode vierkant, maal 4. (want: 4 π 4 = π) Of: p in π = 4 p in + p out

4 Concurrency college 17 Monte-Carlo 4 Monte-Carlo Integreren Riemann som: න f x dx f(x i )(x i x i 1 ) A B i=1 De som convergeert naar de correcte oplossing wanneer N oneindig wordt. N x i : x i 1 x i x i Hier: right Riemann sum A B Probleem: aantal dimensies.

5 Concurrency college 17 Monte-Carlo 5 E X Monte-Carlo Integreren Monte-Carlo: න f x dx = A B B A E f(x) E[f X ] is de correcte oplossing; de uitkomst convergeert naar de correcte oplossing voor N =. B A N N i=1 f(x) A B A De integraal is ongeveer het gemiddelde van de willekeurig gekozen punten op de functie, maal de grootte van het domein. B

6 Concurrency college 17 Monte-Carlo 6 Monte-Carlo Integreren A B B A Monte-Carlo: න f x dx = B A E f(x) N Voor een kleine N kunnen we een hoge variantie verwachten. N i=1 f(x)

7 Concurrency college 17 Monte-Carlo 7 Monte-Carlo Integreren A B B A Monte-Carlo: න f x dx = B A E f(x) N Voor een kleine N kunnen we een hoge variantie verwachten. N i=1 f(x)

8 Concurrency college 17 Monte-Carlo 8 Monte-Carlo Integreren Variantie kan worden gereduceerd met stratification. A B

9 Concurrency college 17 Monte-Carlo 9 Monte-Carlo Integreren Variantie kan gereduceerd worden met stratification. A B stratum 1 stratum 2 stratum 3 stratum 4

10 Concurrency college 17 Monte-Carlo 10 Monte-Carlo Integreren Variantie kan gereduceerd worden met stratification. 36 samples, zonder stratificatie 36 samples, 6x6 stratificatie

11 Concurrency college 17 Monte-Carlo 11 Monte-Carlo Integreren Variantie kan verder teruggebracht worden met importance sampling. Experiment: we werpen twee dubbelstenen. De score van een worp is: 1x de eerste dobbelsteen, plus 6x de tweede. We willen graag weten wat de gemiddelde uitkomst van een worp is. Uitkomst: E f(x) voor dobbelsteen 1: 3.5. E g(x) voor dobbelsteen 2: 3.5 6, som: Hoe vaak moeten we de dobbelstenen werpen om een betrouwbare uitkomst te krijgen? Kan dat beter?

12 Concurrency college 17 Monte-Carlo 12 Monte-Carlo Integreren Variantie kan verder teruggebracht worden met importance sampling. Stel, we werpen de eerste dobbelsteen 10 maal, en de tweede dobbelsteen 20 maal. (want: de tweede heeft meer invloed op de uitkomst) We moeten dan wel de som van de worpen van dobbelsteen 1 door 10 delen, en van dobbelsteen 2 door 20. Stel, we kiezen steeds een willekeurige dobbelsteen. De uitkomst van de worpen vermenigvuldigen we nu met 2 (want: twee dobbelstenen). Stel, we kiezen steeds een willekeurige dobbelsteen, maar de tweede dobbelsteen kiezen we met een zes maal zo grote waarschijnlijkheid. De uitkomst van iedere individuele worp delen we door de kans dat we die dobbelsteen kiezen. Dus: dobbelsteen 1 door 1 7, dobbelsteen 2 door 6 7.

13 Concurrency college 17 Monte-Carlo 13 Monte-Carlo Integreren De bijdrage van de vier strata is niet hetzelfde. Stel dat we dit weten (wellicht bij benadering?). De importance van de individuele strata is niet hetzelfde: we kunnen dit benutten. Stap 1: gebruik een willekeurig getal tussen 0 en 1 om het stratum te kiezen. Stap 2: kies, binnen het stratum, een willekeurige positie in het domein en evalueer de functie. Stap 3: deel het resultaat door de kans die hoort bij het gekozen stratum. A B stratum 1 stratum 2 stratum 3 stratum 4 25% 20% 45% 10%

14 Concurrency college 17 Monte-Carlo 14 Monte-Carlo Samenvatting Monte-Carlo Integratie: Een stochastisch experiment waarmee we (vaak complexe, meer-dimensionale) integralen benaderen. De samples zijn onafhankelijk van elkaar Hoe meer samples, hoe lager de variantie Breed inzetbaar (hoe zorgen we dat deze bal niet door de grond valt en aan het eind netjes op de muur afstuitert?) We checken in 4 willekeurige richtingen of er iets in de bal zit We kiezen 1 richting in elk kwadrant We kiezen de onderste kwadranten vaker

15 Agenda: Monte-Carlo Heterogeneous Computing Brigade Toets 2

16 Concurrency college 17 Monte-Carlo 16 Heterogeen Heterogeen Systeem: één of meer CPUs; één of meer GPUs; systemen verbonden via netwerk; DSPs, audio processors, physics processors;

17 Concurrency college 17 Monte-Carlo 17 Heterogeen Benutting De processoren in een heterogeen systeem hebben verschillende eigenschappen: CPU: klein aantal generieke cores grote caches veel geheugen toegang tot massa-opslag en randapparatuur GPU: co-processor; niet zelfstandig groot aantal streaming cores hoge bandbreedte hoge verwerkingssnelheid latency hiding door grootschalige hyperthreading

18 Concurrency college 17 Monte-Carlo 18 Heterogeen Benutting De processoren in een heterogeen systeem hebben verschillende eigenschappen: CPU: klein aantal generieke cores grote caches veel geheugen toegang tot massa-opslag en randapparatuur GPU: co-processor; niet zelfstandig groot aantal streaming cores hoge bandbreedte hoge verwerkingssnelheid latency hiding door grootschalige hyperthreading? Algorithm X

19 Concurrency college 17 Monte-Carlo 19 Heterogeen Benutting De processoren in een heterogeen systeem hebben verschillende eigenschappen: CPU: klein aantal generieke cores grote caches veel geheugen toegang tot massa-opslag en randapparatuur CPU: AI, physics, game logic, audio, GPU: rendering, physics?, GPU: co-processor; niet zelfstandig groot aantal streaming cores hoge bandbreedte hoge verwerkingssnelheid latency hiding door grootschalige hyperthreading

20 Concurrency college 17 Monte-Carlo 20 Heterogeen Crysis: Elite Dangerous: The Witcher 3: Battlefield 4: StarCraft 2: Deus Ex: HR: Games gebruiken zelden 100% van de CPU cycles: De GPU is de bottleneck Grafisch werk (deels) naar de CPU verplaatsen is zinvol Taken van de CPU naar de GPU verplaatsen maakt de game trager, zelfs wanneer de GPU het sneller kan. CPU: AI, physics, game logic, audio, GPU: rendering, physics?,

21 Concurrency college 17 Monte-Carlo 21 Heterogeen Toewijzing Taken 1. Op basis van geschiktheid Sommige taken zijn geschikter voor de GPU dan voor de CPU. Sommige taken zijn sneller uit te voeren op de GPU dan op de CPU. 2. Op basis van beschikbaarheid Een taak die meer tijd kost op de CPU kan soms toch beter aan de CPU toegewezen worden als het alternatief is dat de CPU een deel van de tijd niets doet.

22 Concurrency college 17 Monte-Carlo 22 Heterogeen Checklist Heterogeen: Welke processor is geschikt voor de taak? Welke processor kan de taak het snelst uitvoeren? Welke processor is beschikbaar / onvolledig benut? Verandert dit in een bepaalde fase? Is de taak op te splitsen? Levert dit taken op voor beide processoren? Wat is de overhead van deze opsplitsing? (Wat is de engineering cost van deze opsplitsing?) Ideale situatie: 100% belasting van alle processoren Maximale performance (Makkelijke implementatie en onderhoud)

23 Agenda: Monte-Carlo Heterogeneous Computing Brigade Toets 2

24 Concurrency college 17 Monte-Carlo 24 Brigade Path Tracing Color Sample( Ray ray ) { // trace ray I, N, material = FindIntersection( ray ); // terminate if ray left the scene if (ray.nohit) return BLACK; // terminate if we hit a light source if (material.islight) return emittance; // continue in random direction R = RandomDirectionInHemisphere( N ); Ray r = new Ray( I, R ); // update throughput BRDF = material.color / PI; irradiance = Sample( r ) * (N R); return PI * 2.0f * BRDF * irradiance; }

25 Concurrency college 17 Monte-Carlo 25 Brigade Path Tracing Color Sample( Ray ray ) { // trace ray I, N, material = FindIntersection( ray ); // terminate if ray left the scene if (ray.nohit) return BLACK; // terminate if we hit a light source if (material.islight) return emittance; // continue in random direction R = RandomDirectionInHemisphere( N ); Ray r = new Ray( I, R ); // update throughput BRDF = material.color / PI; irradiance = Sample( r ) * (N R); return PI * 2.0f * BRDF * irradiance; }

26 Concurrency college 17 Monte-Carlo 26 Brigade Path Tracing Color Sample( Ray ray ) { // trace ray I, N, material = FindIntersection( ray ); // terminate if ray left the scene if (ray.nohit) return BLACK; // terminate if we hit a light source if (material.islight) return emittance; // continue in random direction R = RandomDirectionInHemisphere( N ); Ray r = new Ray( I, R ); // update throughput BRDF = material.color / PI; irradiance = Sample( r ) * (N R); return PI * 2.0f * BRDF * irradiance; }

27 Concurrency college 17 Monte-Carlo 27 Brigade Path Tracing Color Sample( Ray ray ) { // trace ray I, N, material = FindIntersection( ray ); // terminate if ray left the scene if (ray.nohit) return BLACK; // terminate if we hit a light source if (material.islight) return emittance; // continue in random direction R = RandomDirectionInHemisphere( N ); Ray r = new Ray( I, R ); // update throughput BRDF = material.color / PI; irradiance = Sample( r ) * (N R); return PI * 2.0f * BRDF * irradiance; }

28 Concurrency college 17 Monte-Carlo 28 Brigade Path Tracing Color Sample( Ray ray ) { // trace ray I, N, material = FindIntersection( ray ); // terminate if ray left the scene if (ray.nohit) return BLACK; // terminate if we hit a light source if (material.islight) return emittance; // continue in random direction R = RandomDirectionInHemisphere( N ); Ray r = new Ray( I, R ); // update throughput BRDF = material.color / PI; irradiance = Sample( r ) * (N R); return PI * 2.0f * BRDF * irradiance; }

29 Concurrency college 17 Monte-Carlo 29 Brigade Path Tracing Color Sample( Ray ray ) { // trace ray I, N, material = FindIntersection( ray ); // terminate if ray left the scene if (ray.nohit) return BLACK; // terminate if we hit a light source if (material.islight) return emittance; // continue in random direction R = RandomDirectionInHemisphere( N ); Ray r = new Ray( I, R ); // update throughput BRDF = material.color / PI; irradiance = Sample( r ) * (N R); return PI * 2.0f * BRDF * irradiance; }

30 Concurrency college 17 Monte-Carlo 30 Brigade Path Tracing Color Sample( Ray ray ) { // trace ray I, N, material = FindIntersection( ray ); // terminate if ray left the scene if (ray.nohit) return BLACK; // terminate if we hit a light source if (material.islight) return emittance; // continue in random direction R = RandomDirectionInHemisphere( N ); Ray r = new Ray( I, R ); // update throughput BRDF = material.color / PI; irradiance = Sample( r ) * (N R); return PI * 2.0f * BRDF * irradiance; }

31 Concurrency college 17 Monte-Carlo 31 Brigade Path Tracing Color Sample( Ray ray ) { // trace ray I, N, material = FindIntersection( ray ); // terminate if ray left the scene if (ray.nohit) return BLACK; // terminate if we hit a light source if (material.islight) return emittance; // continue in random direction R = RandomDirectionInHemisphere( N ); Ray r = new Ray( I, R ); // update throughput BRDF = material.color / PI; irradiance = Sample( r ) * (N R); return PI * 2.0f * BRDF * irradiance; }

32 Concurrency college 17 Monte-Carlo 32 Brigade Monte-Carlo Path Tracing: Embarrassingly Parallel : Individuele pixels delen geen data Individuele samples delen geen data Geschikt voor uitvoering op CPU en/of GPU Zeer veel rekenwerk Vereist ondersteunende datastructuur (CPU werk) Perfecte klus voor een heterogeen rendering systeem.

33 Concurrency college 17 Monte-Carlo 33 Brigade Reflect (Game)

34 Concurrency college 17 Monte-Carlo 34 Brigade It s About Time (Game)

35 Concurrency college 17 Monte-Carlo 35 Brigade applicatie Architectuur physics AI scene abstraction audio BRIGADE scene data & scene graph core accstruc updater tracer OpenGL

36 Concurrency college 17 Monte-Carlo 36 Brigade applicatie Architectuur physics AI scene audio tracer OpenGL scene graph core accstruc updater tracer tracer

37 Concurrency college 17 Monte-Carlo 37 Brigade in: camera, scene Architectuur core SyncScene() UpdateAccStruc() SyncAccStruc() Render() Combine() Present() tracer Render GenerateRay() Intersect() Shade() TraceShadow()

38 Concurrency college 17 Monte-Carlo 38 Brigade Architectuur CPU Update AccStruc() Sync() Render Combine Present GPU 1 Render() GPU 2 Render() frame

39 Concurrency college 17 Monte-Carlo 39 Heterogeen Architectuur CPU Update AccStruc() Render(n) Combine/ Present Sync Update AccStruc() Render(n+1) Combine/ Present Sync GPU 1 Render(n-1) Render(n) GPU 2 Render(n-1) Render(n)

40 Concurrency college 17 Monte-Carlo 40 Heterogeen Architectuur CPU Update AccStruc() Sync Render(n) C/P Update AccStruc() Sync Render(n+1) C/P GPU 1 GPU 2 Render(n-1) Render(n-1) Sync Sync Render(n) Render(n) Sync Sync

41 Concurrency college 17 Monte-Carlo 41 Load Balancing Load Balancing: Brigade CPU Tracer Workerthreads: 1 per core Threads blijven op deze core Threads fight for food : while (true) { WaitForSignal( gosignal[threadidx] ); while (true) { if (waiting > 0) { LONG w = AtomicDecrement( &waiting ); if (w >= 0) RenderTile( w ); } else { Signal( donesignal[threadidx] ); break; } } }

42 Concurrency college 17 Monte-Carlo 42 Load Balancing Load Balancing: Meerdere Tracers Tracer 1: GPU, GTX580 Tracer 2: GPU, GTX480 Tracer 3: CPU, 2x Intel Xeon, 6-core Per frame: Iedere tracer werkt aan 1/3de van het beeld Na het renderen meten we de rendertijd per tracer Voor het volgende frame wordt de werklast aangepast

43 Concurrency college 17 Monte-Carlo 43 Load Balancing Aanpassen Werklast Methode 1: Perfect Bereken welk deel elke tracer had moeten renderen, en gebruik dit voor het volgende frame. Methode 2: Robin Hood De tracer die het eerst klaar was staat een work unit af aan de tracer die het laatst klaar was. Methode 3: Perfect Smoothed Zelfde als Perfect, maar nu wordt de workload per tracer geleidelijk naar de ideale waarde aangepast.

44 Concurrency college 17 Monte-Carlo 44 Load Balancing Langzame camerabewegingen Snelle camerabewegingen Vertikaal: idle frame time (%) door vroegtijdige afronding taak. 2 GPUs

45 Concurrency college 17 Monte-Carlo 45 Load Balancing Langzame camerabewegingen Snelle camerabewegingen Vertikaal: idle frame time (%) door vroegtijdige afronding taak. 3 GPUs

46 Concurrency college 17 Monte-Carlo 46 Load Balancing Load Balancing in een Heterogeen Systeem Oplossing Brigade: Schat de hoeveelheid werk die een compute unit per frame kan uitvoeren, en stel dit voortdurend bij op basis van de realiteit. Voordelen: Compute units werken geheel autonoom Geen communicatie Efficiency close enough to ideal (1.4% 6.2% verlies)

47

48 Agenda: Monte-Carlo Heterogeneous Computing Brigade Toets 2

49 Concurrency college 17 Monte-Carlo 49 Toets 2 Donderdagonderwerpen : OpenCL Multithreading in Game Engines Patterns 2: reduce, scan, stencil, recurrence + leesmateriaal Monte Carlo & Heterogeen Zie ook de toetsen van vorig jaar.

50 Concurrency college 17 Monte-Carlo 50 Toets 2 RLE reading material answers: 1. RLE yields compressed data if on average each span is at least two characters. 2. RLE would do a terrible job on a gradient. However, it would work great on the first order difference over this data. Interestingly, the first order difference does not affect performance for data that already compressed well. 3. backwardmask[0] == 1 because at position 0 a new span starts. 4. I don t know; all entries are one too large. It seems that the library the author is using does not have an exclusive scan. But now at least you thought about the difference, which is good. ;) 5. No. This would yield the same amount of output data, but potentially garbled. 6. This is explained in the text. 7. countsout: {2,1,4,3}; backwardmask: {1,0,1,1,0,0,0,1,0,0}; scannedbackwardmask: {1,1,2,3,3,3,3,4,4,4}; compactedbackwardmask: {0,2,3,7,10}; symbolsout: {A,C,F,D}. 8. On the GPU, the number of jobs is related to the number of spans in many stages of the algorithm. On the CPU, we go through the input data from begin to end; starting a new span or writing another character to the current span is pretty much the same amount of work. The number of spans is thus irrelevant on the CPU.

51 Concurrency college 17 Monte-Carlo 51 Toets 2 Laatste Loodjes: straks: Laatste werkcollege 1 februari: Toets 2, 08:30, EDUC-GAMMA 3 februari: Deadline opdracht 3

52 Concurrency Gerard Tel / Jacco Bikker - november 2017 februari 2018 EINDE