College 11: OpenCL (2)

Transcriptie

1 Concurrency Gerard Tel / Jacco Bikker - november 2017 februari 2018 College 11: OpenCL (2) Welkom!

2 Agenda: Recap Bouncers - Intro Bouncers - Voorbereiding Bouncers OpenCL Conclusie

3 Previously in Concurrency

4 Concurrency college 11 OpenCL (2) 4 Recap Occupancy Wanneer we de totale taak als een 2D probleem beschouwen verbeterd de occupancy: Tiles hebben een betere program flow coherence dan regels.

5 Concurrency college 11 OpenCL (2) 5 Interop GL Interop Data flow in Mandelbrot: screen (template) texture Buffer (host) t ReadFromBuffer Buffer (device, write-only) host Execute device

6 Concurrency college 11 OpenCL (2) 6 Interop GL Interop OpenCL kan een OpenGL texture gebruiken als input / output. Voordeel: de data is al op de GPU, geen verkeer. Voorwaarden: OpenGL context moet gekoppeld worden aan OpenCL context OpenGL texture moet gelocked worden voor OpenCL

7 Concurrency college 11 OpenCL (2) 7 Interop GL Interop OpenCL / OpenGL koppelen: [System.Runtime.InteropServices.DllImport("opengl32", SetLastError = true)] static extern IntPtr wglgetcurrentdc(); IntPtr glhandle = (GraphicsContext.CurrentContext as IGraphicsContextInternal).Context.Handle; IntPtr wglhandle = wglgetcurrentdc(); var p1 = new ComputeContextProperty(ComputeContextPropertyName.Platform, platform.handle.value); var p2 = new ComputeContextProperty(ComputeContextPropertyName.CL_GL_CONTEXT_KHR, glhandle); var p3 = new ComputeContextProperty(ComputeContextPropertyName.CL_WGL_HDC_KHR, wglhandle); var cpl = new ComputeContextPropertyList(new ComputeContextProperty[] p1, p2, p3 ); context = new ComputeContext( ComputeDeviceTypes.Gpu, cpl, null, IntPtr.Zero );

8 Concurrency college 11 OpenCL (2) 8 Interop GL Interop OpenGL texture voor interop aanmaken: float [] texdata = new float[512 * 512 * 4]; ComputeImage2D texbuffer; int texid = GL.GenTexture(); GL.BindTexture( TextureTarget.Texture2D, texid ); GL.TexParameter( TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)textureminfilter.nearest ); GL.TexParameter( TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)texturemagfilter.nearest ); GL.TexImage2D( TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba32f, 512, 512, 0, OpenTK.Graphics.OpenGL.PixelFormat.Rgb, PixelType.Float, texdata ); flags = ComputeMemoryFlags.WriteOnly; texbuffer = ComputeImage2D.CreateFromGLTexture2D( context, flags, (int)texturetarget.texture2d, 0, texid );

9 Concurrency college 11 OpenCL (2) 9 Interop GL Interop OpenGL texture locken / unlocken: List<ComputeMemory> c = new List<ComputeMemory>() texbuffer ; queue.acquireglobjects( c, null ); queue.execute( kernel, null, worksize, localsize, null ); queue.finish(); queue.releaseglobjects( c, null );

10 Concurrency college 11 OpenCL (2) 10 Interop GL Interop Render-to-texture is de meest gebruikte toepassing voor GL interop. Andere toepassingen: Mesh simplification Procedural landscapes / meshes Particle systems

11 Concurrency college 11 OpenCL (2) 11 Recap Literatuur NVIDIA s Fermi: The First Complete GPU Computing Architecture The_First_Complete_GPU_Architecture.pdf Boek: 2.4.3, 2.4.4

12 Concurrency college 11 OpenCL (2) 13 Recap

13 Concurrency college 11 OpenCL (2) 14 Recap

14 Concurrency college 11 OpenCL (2) 15 Template! OpenCL the Easy Way class Game // load the OpenCL program; this creates the OpenCL context static OpenCLProgram ocl = new OpenCLProgram( "../../program.cl" ); // find the kernel named 'device_function' in the program OpenCLKernel kernel = new OpenCLKernel( ocl, "device_function" ); // create a regular buffer; by default this resides on both the host and the device OpenCLBuffer<int> buffer = new OpenCLBuffer<int>( ocl, 512 * 512 ); // create an OpenGL texture to which OpenCL can send data OpenCLImage<int> image = new OpenCLImage<int>( ocl, 512, 512 );...

15 Concurrency college 11 OpenCL (2) 16 Template! OpenCL the Easy Way public void Tick() GL.Finish(); kernel.setargument( 0, buffer ); kernel.setargument( 1, t ); long [] worksize = 512, 512 ; long [] localsize = 32, 4 ; kernel.execute( worksize, localsize ); // get the data from the device to the host buffer.copyfromdevice();

17 Concurrency college 11 OpenCL (2) 18 Bouncers Particle Effect: Bouncers Ingredienten: 5 particle spawners Positie Richting Kleur Obstakels Normaal Begin- en eindpunt Particle gedrag Zwaartekracht Collision detection Einde levenscyclus Respawn Reflectie Nieuwe richting

18 Concurrency college 11 OpenCL (2) 19 Bouncers Particle Effect: Bouncers Ingredienten: 5 particle spawners Positie Richting Kleur Obstakels Normaal Begin- en eindpunt Particle gedrag Zwaartekracht Collision detection Einde levenscyclus Respawn Reflectie Nieuwe richting abstract class ParticleSource public List<Particle> particles; public int count; public void Tick() foreach( Particle p in particles ) p.tick(); class BouncerSource : ParticleSource public BouncerSource( Vector2 position, Vector2 direction, int color ) particles = new List<Particle>(); count = 16384; for ( int i = 0; i < count; i++ ) Bouncer bouncer = new Bouncer( position, direction, color ); bouncer.spawn(); particles.add( bouncer );

19 Concurrency college 11 OpenCL (2) 20 Bouncers Particle Effect: Bouncers Ingredienten: 5 particle spawners Positie Richting Kleur Obstakels Normaal Begin- en eindpunt Particle gedrag Zwaartekracht Collision detection Einde levenscyclus Respawn Reflectie Nieuwe richting abstract class Particle // properties public Vector2 position, velocity; public static Random rng = new Random(); // constructor public Particle() position = new Vector2( 0, 0 ); velocity = new Vector2( 0, 0 ); // abstract methods public abstract void Spawn(); public abstract void Tick();

20 Concurrency college 11 OpenCL (2) 21 Bouncers Particle Effect: Bouncers Ingredienten: 5 particle spawners Positie Richting Kleur Obstakels Normaal Begin- en eindpunt Particle gedrag Zwaartekracht Collision detection Einde levenscyclus Respawn Reflectie Nieuwe richting class Occluder public Vector2 p1, p2, N; public Occluder( Vector2 A, Vector2 B )... public void Render()... public bool Intersect( Vector2 A, Vector2 B, ref float Ix, ref float Iy )... public Vector2 Reflect( Vector2 D )...

21 Concurrency college 11 OpenCL (2) 22 Bouncers Particle Effect: Bouncers Ingredienten: 5 particle spawners Positie Richting Kleur Obstakels Normaal Begin- en eindpunt Particle gedrag Zwaartekracht Collision detection Einde levenscyclus Respawn Reflectie Nieuwe richting public override void Tick() if (out_of_screen) // particle left the screen; respawn Spawn(); else // continue path Vector2 prevpos = position; position += velocity * Game.animationSpeed; foreach( Occluder o in Game.occluders ) float ix = 0, iy = 0; if (o.intersect( prevpos, position, ref ix, ref iy ))... return; velocity.y += 0.001f; Game.screen.Plot(... );

22 Concurrency college 11 OpenCL (2) 23 Bouncers Particle Effect: Bouncers Ingredienten: 5 particle spawners Positie Richting Kleur Obstakels Normaal Begin- en eindpunt public void Tick() timer.reset(); timer.start(); // render the background cave.copyto( screen, 0, 0 ); // draw occluders foreach( Occluder o in occluders ) o.render(); // update particles foreach( ParticleSource s in sources ) s.tick(); // report double elapsed = timer.elapsed.totalmilliseconds; Console.Write( elapsed ); Console.WriteLine(); Particle gedrag Zwaartekracht Collision detection Einde levenscyclus Respawn public Vector2 Reflect( Vector2 D ) return D - ((2.0f * (N.X * D.X + N.Y * D.Y)) * N); Reflectie Nieuwe richting

23 Concurrency college 11 OpenCL (2) 24 Bouncers Particle Effect: Bouncers Karakteristieken: 5 x particles Particles zijn onafhankelijk Gebruik van List, foreach Random number generator Overerving Output puur grafisch Net wel/niet snel genoeg

24 Concurrency college 11 OpenCL (2) 25 Bouncers Particle Effect: Bouncers Karakteristieken: 5 x particles Particles zijn onafhankelijk Gebruik van List, foreach Random number generator Overerving Output puur grafisch Net wel/niet snel genoeg Voldoende werk voor GPU threads Geen synchronizatie nodig, volgorde irrelevant Niet bepaald C code Heeft OpenCL niet (en is lastig) Mooi voor uitbreidbaarheid, maar wordt hier niet gebruikt GL-interop : output direct naar OpenGL texture Goede reden om de hulp van de GPU in te roepen.

26 Concurrency college 11 OpenCL (2) 27 Voorbereiding C# versus OpenCL Spawners, particles en obstakels zijn gedefinieerd als classes. Binnen deze classes treffen we veelvuldig Vector2 objecten aan. OpenCL ondersteunt geen classes Wel structs, maar we moeten voorzichtig zijn met data alignment Vector2 lijkt op float2, maar wederom is alignment een probleem Floats zijn de veiligste optie.

27 Concurrency college 11 OpenCL (2) 28 Voorbereiding De Spawners public static List<ParticleSource> sources = new List<ParticleSource>(); Inhoud: 5x particles. Per particle: positie, snelheid, spawn richting, spawn positie, kleur. const int nrpertype = 16384; const int nrsources = 5; float[] pos_x = new float[nrpertype * nrsources]; // position float[] pos_y = new float[nrpertype * nrsources]; float[] vel_x = new float[nrpertype * nrsources]; // velocity float[] vel_y = new float[nrpertype * nrsources]; float[] dir_x = new float[nrpertype * nrsources]; // direction float[] dir_y = new float[nrpertype * nrsources]; float[] org_x = new float[nrpertype * nrsources]; // origin float[] org_y = new float[nrpertype * nrsources]; int[] col = new int[nrpertype * nrsources]; // color

28 Concurrency college 11 OpenCL (2) 29 Voorbereiding De Spawners Voor het vullen van deze data nemen we de functionaliteit van de constructor over: void CreateParticleSource( int idx, Vector2 pos, Vector2 aim, int color ) if (aim.length > 0) aim.normalize(); aim *= 0.01f; for( int i = 0; i < nrpertype; i++ ) int a = idx * nrpertype + i; // positie in de array voor source idx org_x[a] = pos.x; org_y[a] = pos.y; dir_x[a] = aim.x; dir_y[a] = aim.y; col[a] = color; SpawnParticle( a ); void SpawnParticle( int a ) pos_x[a] = org_x[a]; pos_y[a] = org_y[a]; float vx = (float)rng.nextdouble() * 0.01f f; float vy = (float)rng.nextdouble() * 0.01f f; vel_x[a] = dir_x[a] + vx; vel_y[a] = dir_y[a] + vy;

29 Concurrency college 11 OpenCL (2) 30 Voorbereiding De Spawners Nu kunnen we ook de particle Tick converteren: void TickParticle( int a ) if (pos_y[a] > 1 pos_x[a] < 0 pos_x[a] > 1) // particle left the screen; respawn SpawnParticle( a ); else // continue path...

30 Concurrency college 11 OpenCL (2) 31 Voorbereiding De Occluders public static List<Occluder> occluders = new List<Occluder>(); Inhoud: 6 occluders. Per occluder: P1, P2, N. const int nroccluders = 6; float[] p1x = new float[nroccluders]; float[] p1y = new float[nroccluders]; float[] p2x = new float[nroccluders]; float[] p2y = new float[nroccluders]; float[] Nx = new float[nroccluders]; float[] Ny = new float[nroccluders]; Hierna kunnen we ook de Intersect en Reflect methoden converteren. // create an occluder // this mimics the constructor void CreateOccluder( int idx, Vector2 A, Vector2 B ) p1x[idx] = A.X; p1y[idx] = A.Y; p2x[idx] = B.X; p2y[idx] = B.Y; Vector2 N = new Vector2( A.Y - B.Y, B.X - A.X ); N.Normalize(); Nx[idx] = N.X; Ny[idx] = N.Y;

31 Concurrency college 11 OpenCL (2) 32 Voorbereiding

32 Concurrency college 11 OpenCL (2) 33 Voorbereiding De RNG static Random rng = new Random(); De RNG vervangen we door Marsaglia s Xor32 RNG: uint seed = 1000; uint RandomInt() // Marsaglia Xor32; see seed ^= seed << 13; seed ^= seed >> 17; seed ^= seed << 5; return seed; float RandomFloat() return RandomInt() * e-10f; // 1 / 2^32

34 Concurrency college 11 OpenCL (2) 35 OpenCL Cloo Voor OpenCL gebruiken we Cloo en de nieuwe OpenCL template. class Game // load the OpenCL program; this creates the OpenCL context static OpenCLProgram ocl = new OpenCLProgram( "../../program.cl" ); // find the kernel named 'device_function' in the program OpenCLKernel kernel = new OpenCLKernel( ocl, "device_function" ); // create a regular buffer; by default this resides on both the host and the device OpenCLBuffer<int> buffer = new OpenCLBuffer<int>( ocl, 512 * 512 ); // create an OpenGL texture to which OpenCL can send data OpenCLImage<int> image = new OpenCLImage<int>( ocl, 512, 512 );...

35 Concurrency college 11 OpenCL (2) 36 OpenCL Cloo Voor OpenCL gebruiken we Cloo en de nieuwe OpenCL template. We testen met een dummy kernel: kernel void device_function( write_only image2d_t a ) int idx = get_global_id( 0 ); int idy = get_global_id( 1 ); int id = idx * idy; if (id >= (960 * 600)) return; int2 pos = (int2)( idx, idy ); write_imagef( a, pos, (float4)(idx / 960.0f, idy / 960.0f, 0, 1 ) ); Let op: dit gebeurt.

36 Concurrency college 11 OpenCL (2) 37 OpenCL Cloo Voor OpenCL gebruiken we Cloo en de nieuwe OpenCL template. We testen met een dummy kernel: // do random OCL stuff GL.Finish(); kernel.setargument( 0, image ); long [] worksize = 960, 600 ; long [] localsize = 32, 4 ; kernel.lockopenglobject( image.texbuffer ); kernel.execute( worksize, localsize ); kernel.unlockopenglobject( image.texbuffer ); public void Render() GL.LoadIdentity(); GL.BindTexture( TextureTarget.Texture2D, texid ); GL.Begin( PrimitiveType.Quads ); GL.TexCoord2( 0.0f, 1.0f ); GL.Vertex2( -1.0f, -1.0f ); GL.TexCoord2( 1.0f, 1.0f ); GL.Vertex2( 1.0f, -1.0f ); GL.TexCoord2( 1.0f, 0.0f ); GL.Vertex2( 1.0f, 1.0f ); GL.TexCoord2( 0.0f, 0.0f ); GL.Vertex2( -1.0f, 1.0f ); GL.End();

37 Concurrency college 11 OpenCL (2) 38 OpenCL Tip Implementeer altijd eerst de minimale functionaliteit. Bouw daarna langzaam op, zodat een eventuele fout maar in een klein stuk code kan zitten.

38 Concurrency college 11 OpenCL (2) 39 OpenCL Data Transport De data voor de simulatie moet beschikbaar zijn op de GPU. Eerst de occluders: OpenCLBuffer<float> p1xdata, p1ydata,p2xdata, p2ydata,nxxdata, NyyData; void CreateOccluderBuffers() p1xdata = new OpenCLBuffer<float>( ocl, p1x ); p1ydata = new OpenCLBuffer<float>( ocl, p1y ); p2xdata = new OpenCLBuffer<float>( ocl, p2x ); p2ydata = new OpenCLBuffer<float>( ocl, p2y ); NxxData = new OpenCLBuffer<float>( ocl, Nx ); NyyData = new OpenCLBuffer<float>( ocl, Ny );

39 Concurrency college 11 OpenCL (2) 40 OpenCL Data Transport De particles: OpenCLBuffer<float> pxdata, pydata, vxdata, vydata, dxdata, dydata, oxdata, oydata; OpenCLBuffer<int>; void CreateParticleBuffers() pxdata = new OpenCLBuffer<float>( ocl, pos_x ); pydata = new OpenCLBuffer<float>( ocl, pos_y ); vxdata = new OpenCLBuffer<float>( ocl, vel_x ); vydata = new OpenCLBuffer<float>( ocl, vel_y ); dxdata = new OpenCLBuffer<float>( ocl, dir_x ); dydata = new OpenCLBuffer<float>( ocl, dir_y ); oxdata = new OpenCLBuffer<float>( ocl, org_x ); oydata = new OpenCLBuffer<float>( ocl, org_y ); cldata = new OpenCLBuffer<int>( ocl, col );

40 Concurrency college 11 OpenCL (2) 41 OpenCL Data Transport We testen de data met een eenvoudige versie van de particle Tick in OpenCL. kernel void device_function( write_only image2d_t a, global float* px, global float* py, global float* vx, global float* vy ) // get the thread id; this will be our particle id int id = get_global_id( 0 ); // make sure we're still inside our arrays if (id >= (16384 * 5)) return; // update position, apply gravity px[id] += vx[id]; py[id] += vy[id]; vy[id] += 0.001f; // plot the particle int ix = (int)(px[id] * 960.0f); int iy = (int)(py[id] * 600.0f); write_imagef( a, (int2)(ix, iy), (float4)( 1, 1, 1, 1 ) ); kernel.setargument( 1, pxdata ); kernel.setargument( 2, pydata ); kernel.setargument( 3, vxdata ); kernel.setargument( 4, vydata );

41 Concurrency college 11 OpenCL (2) 42 OpenCL Data Transport const int nrpertype = 16384; const int nrsources = 5; if (id >= (16384 * 5)) return; De grootte van onze arrays is nu wel erg hardcoded : deze constanten worden momenteel in zowel de OpenCL code als de C# code vermeldt. We kunnen dit voorkomen door het aantal particles als parameter mee te geven aan de OpenCL code.

42 Concurrency college 11 OpenCL (2) 43 OpenCL

43 Concurrency college 11 OpenCL (2) 44 OpenCL Functionaliteit De buffers zijn goed aangekomen. Volgende stappen: De particles trekken sporen; de achtergrond wordt niet gewist. De achtergrond is een plaatje. Particles die het beeld verlaten schrijven buiten de texture.

44 Concurrency college 11 OpenCL (2) 45 OpenCL Scherm Wissen Om het scherm te wissen vervangen we de texture door de background. Benodigdheden: 1. Een kopie van de background, met occluders, in floating point formaat 2. Een kernel die deze achtergrond naar de texture kopieert.

45 Concurrency college 11 OpenCL (2) 46 OpenCL Background We maken een float buffer voor de achtergrond: OpenCLBuffer<float> background; void CreateBackgroundBuffer() float[] data = new float[960 * 600 * 4]; cave.copyto( screen, 0, 0 ); RenderOccluders(); for( int y = 0; y < 600; y++ ) for( int x = 0; x < 960; x++ ) float r = (float)((screen.pixels[x + y * 960] >> 16) & 255) / 256.0f; float g = (float)((screen.pixels[x + y * 960] >> 8) & 255) / 256.0f; float b = (float)(screen.pixels[x + y * 960] & 255) / 256.0f; data[(x + y * 960) * 4 + 0] = r; data[(x + y * 960) * 4 + 1] = g; data[(x + y * 960) * 4 + 2] = b; data[(x + y * 960) * 4 + 3] = 1; background = new OpenCLBuffer<float>( ocl, data );

46 Concurrency college 11 OpenCL (2) 47 OpenCL Background De clear kernel: kernel void clear_function( write_only image2d_t a, global float4* background ) // get the thread id; this will be our pixel id int id = get_global_id( 0 ); if (id >= (960 * 600)) return; int x = id % 960; int y = id / 960; write_imagef( a, (int2)(x, y), background[id] ); Vanuit C# stuurden we een float*, die we nu opeens float4* noemen. Dit mag: het (device) address blijft hetzelfde, maar wijst nu naar vectoren. Dit is handig wanneer we de background pixels vullen met write_imagef. Merk op dat we ook een int* op deze manier mogen casten naar een float*, of zelfs een char*... Hier zit geen enkele check op.

47 Concurrency college 11 OpenCL (2) 48 OpenCL Vectoren in OpenCL In de clear kernel gebruikten we het float4 type. Vectoren worden uitgebreid ondersteunt in OpenCL. Een vector initialiseren: float4 a = (float4)(1, 2, 3, 4 ); Rekenen met vectoren: float4 c = a + b; Componenten van vectoren: float x = position.x; float2 xy = pos3d.xy; float4 strange = pos3d.zxyy; // swizzle

48 Concurrency college 11 OpenCL (2) 49 OpenCL Respawn Om de particles die het scherm verlaten opnieuw te laten spawnen hebben we flink wat extra functionaliteit nodig: 1. de test op het verlaten van het scherm; 2. de spawn functie, te gebruiken wanneer de test dit aangeeft; 3. de rng die we in de spawn functie gebruiken; 4. de data die we tot nu toe nog niet gebruikten: direction, origin, color.

49 Concurrency college 11 OpenCL (2) 50 OpenCL Nieuwe Parameters kernel void device_function( write_only image2d_t a, global float* px, global float* py, global float* vx, global float* vy, global float* dx, global float* dy, global float* ox, global float* oy, global int* col, int baseseed )... kernel.setmemoryargument( 5, dxdata ); kernel.setmemoryargument( 6, dydata ); kernel.setmemoryargument( 7, oxdata ); kernel.setmemoryargument( 8, oydata ); kernel.setmemoryargument( 9, cldata ); kernel.setvalueargument<int>( 10, (int)randomint() );

50 Concurrency college 11 OpenCL (2) 51 OpenCL De Xor32 RNG uint RandomInt( uint* seed ) *seed ^= *seed << 13; *seed ^= *seed >> 17; *seed ^= *seed << 5; return *seed; float RandomFloat( uint* seed ) return RandomInt( seed ) * e-10f; Cicades leven 13 of 17 jaar ondergronds, waarna ze bovengronds paren. Deze priemgetallen helpen de Cicades overleven te midden van jagers waarvan de populatie iedere 2-5 jaar een piek kent. Groot priemgetal int id = get_global_id( 0 ); uint seed = (id + baseseed * ) * UL;

51 Concurrency college 11 OpenCL (2) 52 OpenCL By Reference C#: C++: uint RandomInt( ref uint seed ) uint RandomInt( uint& seed ) seed ^= seed << 13; seed ^= seed << 13; seed ^= seed >> 17; seed ^= seed >> 17; seed ^= seed << 5; seed ^= seed << 5; return seed; return seed; OpenCL: uint RandomInt( uint* seed ) *seed ^= *seed << 13; *seed ^= *seed >> 17; *seed ^= *seed << 5; return *seed; C kent by reference niet. In plaats daarvan sturen we het adres van een variabele: een pointer dus. Om de waarde op dat adres te lezen of te schrijven gebruiken we * : dus *seed. De waarde van seed zelf is nog steeds een adres; dit wil je niet veranderen!

52 Concurrency college 11 OpenCL (2) 53 OpenCL By Reference OpenCL: Beter: uint RandomInt( uint* seed ) uint RandomInt( uint* seedptr ) *seed ^= *seed << 13; *seedptr ^= *seedptr << 13; *seed ^= *seed >> 17; *seedptr ^= *seedptr >> 17; *seed ^= *seed << 5; *seedptr ^= *seedptr << 5; return *seed; return *seedptr; Stel dat RandomInt een andere functie wil aanroepen die ook een uint* als parameter heeft. In dat geval sturen we seedptr, dus niet *seedptr: uint RandomInt( uint* seed ) uint* RandomInt( uint* seed ) ProcessSeed( seed ); ProcessSeed( seed ); return *seed; return *seed; // return uint pointer

53 Concurrency college 11 OpenCL (2) 54 OpenCL SpawnParticle De functie SpawnParticle heeft bijna alle data nodig: void SpawnParticle( int a, global float* px, global float* py, global float* vx, global float* vy, global float* dx, global float* dy, global float* ox, global float* oy, uint* seed ) px[a] = ox[a]; py[a] = oy[a]; float x = RandomFloat( seed ) * 0.01f f; float y = RandomFloat( seed ) * 0.01f f; vx[a] = dx[a] + x; vy[a] = dy[a] + y;

54 Concurrency college 11 OpenCL (2) 55 OpenCL Particle Tick Voorkomen dat een particle zomaar het scherm verlaat: if (py[id] >= 1 px[id] < 0 px[id] >= 1) SpawnParticle( id, px, py, vx, vy, dx, dy, ox, oy, &seed ); Integer kleur omzetten naar floating point kleur: float r = ((col[id] >> 16) & 255) / 256.0f; float g = ((col[id] >> 8) & 255) / 256.0f; float b = (col[id] & 255) / 256.0f; write_imagef( a, (int2)(ix, iy), (float4)( r, g, b, 1 ) );

55 Concurrency college 11 OpenCL (2) 56 OpenCL

56 Concurrency college 11 OpenCL (2) 57 OpenCL Functionaliteit Voor de laatste functionaliteit implementeren we het gedrag van de occluders. we zenden de occluder data mee met de kernel aanroep; we implementeren Intersect en Reflect in OpenCL; we maken de ParticleTick functie af.

57 Concurrency college 11 OpenCL (2) 58 OpenCL Occluder Data kernel void device_function( write_only image2d_t a, global float* px, global float* py, global float* vx, global float* vy, global float* dx, global float* dy, global float* ox, global float* oy, global float* p1x, global float* p1y, global float* p2x, global float* p2y, global float* Nx, global float* Ny, global int* col, int baseseed )

58 Concurrency college 11 OpenCL (2) 59 OpenCL Intersect bool Intersect( int idx, float2 A, float2 B, float* Ix, float* Iy, global float* p1x, global float* p1y, global float* p2x, global float* p2y, global float* Nx, global float* Ny ) // calculate intersection point of line (P1,P2) and occluder // float den = (A.x - B.x) * (p1y[idx] - p2y[idx]) - (A.y - B.y) * (p1x[idx] - p2x[idx]); if (den == 0) return false; float v0 = A.x * B.y - A.y * B.x, v1 = p1x[idx] * p2y[idx] - p1y[idx] * p2x[idx]; *Ix = (v0 * (p1x[idx] - p2x[idx]) - (A.x - B.x) * v1) / den; *Iy = (v0 * (p1y[idx] - p2y[idx]) - (A.y - B.y) * v1) / den; // see if intersection point is on both lines float t0 = (*Ix - A.x) / (B.x - A.x); float t1 = (*Ix - p1x[idx]) / (p2x[idx] - p1x[idx]); return (t0 > 0 && t0 < 1 && t1 > 0 && t1 < 1);

59 Concurrency college 11 OpenCL (2) 60 OpenCL Reflect float2 Reflect( int idx, float2 D, global float* Nx, global float* Ny ) return D - ((2.0f * (Nx[idx] * D.x + Ny[idx] * D.y)) * (float2)( Nx[idx], Ny[idx] ) );