Concurrency. Gerard Tel / Jacco Bikker - november 2015 januari Welkom!

Transcriptie

1 Concurrency Gerard Tel / Jacco Bikker - november 2015 januari 2016 Welkom!

2 Agenda: Introductie OpenCL OpenCL / C# Workgroups Tot Slot

3 Concurrency college 11 OpenCL Primer 3 Introductie Heterogene Systemen Een modern system heeft naast 1 (of 2) CPUs een grafische co-processor: de GPU.

4 Concurrency college 11 OpenCL Primer 4 Introductie The GPU Hardware and Software Model: The GPU is not a PRAM (but it s not far off), John Owens, UC Davis,

5 Concurrency college 11 OpenCL Primer 5 Introductie Heterogene Systemen Een modern system heeft naast 1 (of 2) CPUs een grafische co-processor: de GPU. GPU: veel rekenkracht: 7 Tflops (Xeon: 256 Gflops) veel bandbreedte: 336.5GB/s (Xeon: 118GB/s)

6 Concurrency college 11 OpenCL Primer 6 Introductie GPU Performance Rekenkracht: Beperkt executiemodel 32-wide SIMT Bandbreedte: Streaming executiemodel Expliciete geheugenarchitectuur

7 Concurrency college 11 OpenCL Primer 7 Introductie Beperkt Executiemodel Geen branch prediction Een taak tegelijk Geen context switching Beperkte super-scalar pipeline Geen out-of-order execution En: Lage kloksnelheid (~1Ghz)

8 Concurrency college 11 OpenCL Primer 8 Introductie GPU: Massively Parallel Een GPU bestaat uit: * 24 Shading Multiprocessors Per SM: 128 CUDA cores (4 groepen van 32) Totaal: 3072 CUDA cores. Eén SM kan maximaal 2048 threads uitvoeren: 16 per CUDA core. Het mechanisme wat hier voor gebruikt wordt lijkt op hyperthreading. Het maximale aantal threads is dus 49,152. * Titan X / Maxwell architectuur

9 Concurrency college 11 OpenCL Primer 9 Introductie Beperkt Executiemodel Een GPU groepeert de threads in warps van 32 threads, en voert deze uit met SIMT: Single Instruction, Multiple Thread Een GPU is dus eigenlijk een 32-wide vector machine. Een moderne GPU kan maximaal 4 verschillende programma s tegelijk uitvoeren.

10 Concurrency college 11 OpenCL Primer 10 Introductie GPGPU Samenvatting: Tienduizenden threads In groepen van 32 Maximaal 16 verschillende kernels Een GPU is ongeschikt voor taak-parallellisme. Een GPU is zeer geschikt voor data parallellisme, maar: alleen wanneer de parallelle taken een identieke flow hebben.

11 Concurrency college 11 OpenCL Primer 11 Introductie GPGPU CPU GPU

12 Concurrency college 11 OpenCL Primer 12 If you were plowing a field, which would you rather use? Two strong oxen, or 1024 chickens? - Seymour Cray

13 Concurrency college 11 OpenCL Primer 13 Introductie Heterogene Systemen In een heterogeen systeem kan een applicatie zowel de CPU als de GPU benutten. Doel: data-parallelle taken uitvoeren op de GPU; taak-parallel werk en serieel werk op de CPU. De GPU is dus géén vervanging voor de CPU.

14 Agenda: Introductie OpenCL OpenCL / C# Workgroups Tot Slot

15 Concurrency college 11 OpenCL Primer 15 OpenCL OpenCL Standaard Framework voor het ontwikkelen van software die uitgevoerd kan worden op heterogene platformen, bestaande uit CPUs, GPUs, DSPs, FPGAs en andere processoren. Computing System Compute Devices Compute Units Processing Elements Memory Hierarchy: Global memory Read-only memory Local memory Per-element private memory CPU Cores SIMD Lanes GPU SMs CUDA cores

16 Concurrency college 11 OpenCL Primer 16 OpenCL OpenCL Standaard Het OpenCL executiemodel is fundamenteel parallel, en gaat uit van regular parallelism: meerdere processing elements voeren dezelfde code uit: een kernel.

17 Concurrency college 11 OpenCL Primer 17 OpenCL Kernel Voorbeelden: GLSL / ShaderToy Online editing systeem voor GLSL shaders via WebGL.

18 Concurrency college 11 OpenCL Primer 18 OpenCL Kernel #define C(p) min(1.,sqrt(10.*abs(length(p-.5)-.4))) #define D(p,o) ((d=length(p-o)*5.)<=.6? d:1.) void mainimage( out vec4 O, in vec2 pos ) { float d; vec2 R = iresolution.xy, p = 20.*(pos+pos/R)/R.y, f = fract(p); p = floor(p); float t = (p.x+p.y)*.3+iglobaltime*9.; vec2 o = vec2(cos(t),sin(t))*.4+.5; O.xyz = vec3(c(f)*d(f,o));

19 Concurrency college 11 OpenCL Primer 19 OpenCL Kernel #define C(p) min(1.,sqrt(10.*abs(length(p-.5)-.4))) #define D(p,o) ((d=length(p-o)*5.)<=.6? d:1.) void mainimage( out vec4 O, in vec2 pos ) { vec2 res = iresolution.xy; vec2 C = vec2( 0.5, 0.5 ); vec2 d = pos / res - C; if (length( d ) <.2) O.xyz = vec3( 1, 0, 0 ); else O.xyz = vec3( 0, 0, 0 );

20 Concurrency college 11 OpenCL Primer 20 OpenCL Kernel bool test( out vec3 N, in vec3 D, in vec3 s, in float r ) { float A = dot( D, D ), B = dot( D, s )*(-2.0); float C = dot( s, s ) - r*r, det = B*B - 4.0*A*C; if (det < 0.0 ) return false; float t = (-B+sqrt(det)) / (2.0*A); N = normalize( D*t - s ); return true; void mainimage( out vec4 color, in vec2 pos ) { float Y = pos.y / iresolution.y; vec3 N, Sky = vec3( 0.45, 0.75, 1.0 )*Y*0.4; vec3 V = normalize( vec3( (pos.xy - iresolution.xy*0.5) / iresolution.xx, 1.0 )); color = vec4(sky,1.0); if (!test( N, V, vec4(0,0,5), 1.0 )) return; vec3 H = normalize( V - reflect(v,n)), L = normalize( vec3(1.0,1.0,1.0)); float dotnl = max(dot(n,l),0.), dothl = max(dot(h,l),0.), spec = pow(dothl,32.); color = vec4(vec3(1,0.5,0.5)*dotnl*0.9 + vec3(1,1,1)*spec*0.9 + Sky,1.);

21 Concurrency college 11 OpenCL Primer 21 OpenCL Kernel Shaders op Shadertoy: korte programma s die uitgevoerd worden voor elke pixel van een bitmap. Regular parallelism / Map Geen synchronisatie tussen threads. Uitvoer is 1 pixel, op een vaste locatie. pos pos pos pos pos pos pos pos K K K K K K K K Executie op GPU hardware: Elke pixel van de bitmap is een thread. Groepering van threads in warps en de verdeling over SMs wordt overgelaten aan WebGL / de driver. Eventuele input data voor een kernel wordt aangeboden in de vorm van textures. color color color color color color color color

22 Concurrency college 11 OpenCL Primer 22 OpenCL Kernel Shaders in OpenCL: korte programma s die uitgevoerd worden voor elke taak in een lijst. Regular parallelism / Map Synchronisatie tussen threads is mogelijk. In- en uitvoer kan complex zijn. in in in in in in in in K K K K K K K K Executie op GPU hardware: Elke pixel van de bitmap is een thread. Groepering van threads in warps en de verdeling over SMs kan expliciet gespecificeerd worden. Input- en output data in de vorm van textures en/of generieke buffers. Expliciete controle over de memory hierarchy. out out out out out out out out

23 Concurrency college 11 OpenCL Primer 23 OpenCL OpenCL Specificatie Gebaseerd op C99 Extensies: address space qualifiers work-items workgroups vector types synchronizatie Ingebouwde functies: image manipulation work item manipulation math functies Beperkingen: geen functiepointers geen recursie kernel void SAXPY( global float* x, global float* y, float a, write_only image2d_t image ) { int i = get_global_id( 0 ); y[i] += a * cos( x[i] ); y[i] += a * native_cos( x[i] ); float3 tmp = (float3)(a, a, a ); int2 pos = (int2)(i,0); write_imagef( image, pos, tmp ); tmp = native_cos( tmp ); y[i] += tmp.x; y[i] += tmp.y; y[i] += tmp.z;

24 Agenda: Introductie OpenCL OpenCL / C# Workgroups Tot Slot

25 Concurrency college 11 OpenCL Primer 25 OpenCL / C# OpenTK / Cloo OpenCL kan in C# gebruikt worden via de Cloo library: using Cloo; Om een OpenCL kernel te kunnen gebruiken hebben we nodig: een compute platform een OpenCL context een OpenCL command queue een OpenCL program de kernel

26 Concurrency college 11 OpenCL Primer 26 OpenCL / C# Devices & Vendors: Compute Platform Het Compute Platform is de interface naar de vendor-specific implementatie van OpenCL. In een systeem met een NVidia GPU zijn in ieder geval twee OpenCL platforms aanwezig: 1. De NVidia OpenCL implementatie; 2. De Intel OpenCL implementatie (voor de CPU). Platform ComputePlatform platform = ComputePlatform.Platforms[0]; Console.Write( platform.name ); // NVIDIA CUDA Console.Write( platform.profile ); // FULL PROFILE

27 Concurrency college 11 OpenCL Primer 27 OpenCL / C# OpenCL Context In de context wordt de state van de OpenCL API bijgehouden. ComputeContext context = new ComputeContext( ComputeDeviceTypes.Gpu, new ComputeContextPropertyList( platform ), null, IntPtr.Zero ); Platform Context

28 Concurrency college 11 OpenCL Primer 28 OpenCL / C# Program Een OpenCL program is een collectie kernels. Ook wanneer we maar één kernel hebben wordt deze ondergebracht in een program. var streamreader = new StreamReader( "../../program.cl" ); string clsource = streamreader.readtoend(); streamreader.close(); // create program with opencl source ComputeProgram program = new ComputeProgram( context, clsource ); Compileren van OpenCL code: program.build( null, null, null, IntPtr.Zero ); Platform Context Program

29 Concurrency college 11 OpenCL Primer 29 OpenCL / C# Kernel We kunnen nu de kernel opvragen: ComputeKernel kernel = program.createkernel( "device_function" ); Platform Context Program Kernel

30 Concurrency college 11 OpenCL Primer 30 OpenCL / C# Kernel Arguments Stel dat we de volgende kernel willen aanroepen: kernel void device_function( global float* x, float a ) { int i = get_global_id( 0 ); x[i] *= a; Deze kernel heeft twee arguments. We geven de data door vanuit C# met: kernel.setmemoryargument( 0, buffer ); kernel.setvalueargument( 1, f ); Platform Context Program Kernel Arguments

31 Concurrency college 11 OpenCL Primer 31 OpenCL / C# Buffers In het voorbeeld is een van de argumenten een array van floats. kernel void device_function( global float* x, float a ) { int i = get_global_id( 0 ); x[i] *= a; Platform Context Program Kernel Arguments Buffers In C#: float [] data = new float[65536]; We maken hier een buffer van waarmee OpenCL kan werken: var flags = ComputeMemoryFlags.ReadWrite ComputeMemoryFlags.UseHostPointer; buffer = new ComputeBuffer<int>( context, flags, data );

32 Concurrency college 11 OpenCL Primer 32 OpenCL / C# Queue Alles staat nu klaar om uitgevoerd te worden. Kernel execution gaat via een job queue: ComputeCommandQueue queue = new ComputeCommandQueue( context, context.devices[0], 0 ); queue.execute( kernel, null, new long [] { 512 * 512, null, null ); queue.finish(); Als laatste stap lezen we de GPU buffer terug naar de C# array. queue.readfrombuffer( buffer, ref data, true, null ); Platform Context Program Kernel Arguments Buffers Queue

33 Concurrency college 11 OpenCL Primer 33 OpenCL / C# Recap Voor het uitvoeren van een kernel hebben we nodig: een OpenCL platform: platform = ComputePlatform.Platforms[0]; een OpenCL context: context = new ComputeContext( ); een program: program = new ComputeProgram( context, clsource ); de kernel: kernel = program.createkernel( "device_function" ); een job queue: queue = new ComputeCommandQueue( ); We zetten (eenmalig / voor updates) de arguments van de kernel met: SetMemoryArgument / SetValueArgument De kernel wordt uitgevoerd door een job aan de queue toe te voegen: queue.execute( kernel, null, new long [] { N, null, null ); Platform Context Program Kernel Arguments Buffers Queue

34 Concurrency college 11 OpenCL Primer 34 OpenCL / C# Voorbeeld Het berekenen van de Mandelbrot set: M = cεc lim n Z n, Z 0 = c, Z n+1 = Z n 2 + c De verzameling M van alle complexe getallen waarvoor geldt dat de recursieve functie Z n voor c niet naar oneindig gaat. In pseudocode: Z re = c re, Z im = c im isinside = true for( n = 0; n < iterations; n++ ) { if (Z 2 re + Z 2 im > 4) { isinside = false; break; Z im = 2 Z re Z im + c im Z re = Z 2 re Z 2 im + c re

35 Concurrency college 11 OpenCL Primer 35 OpenCL / C# Mandelbrot kernel void device_function( global int* a, float t ) { // adapted from inigo quilez - iq/2013 int id = get_global_id( 0 ); if (id >= (512 * 512)) return; float2 fragcoord = (float2)( (id & 511), (float)(id >> 9) ), resolution = (float2)( 512, 512 ); float3 col = (float3)( 0.f, 0.f, 0.f ); for( int m = 0; m < 2; m++ ) for( int n = 0; n < 2; n++ ) { float2 p = -resolution + 2.f * (fragcoord + (float2)(.5f * (float)m,.5f * (float)n )); float w = (float)( 2 * m + n ), l = 0.0f; float time = t +.5f * (1.f / 24.f) * w / 4.f; float zoo =.32f +.2f * cos(.07f * time ); float coa = cos(.15f * (1.f - zoo) * time ); float sia = sin(.15f * (1.f - zoo) * time ); zoo = pow( zoo, 8.f ); float2 xy = (float2)( p.x * coa - p.y * sia, p.x * sia + p.y * coa ); float2 c = (float2)( -.745f,.186f ) + xy * zoo, z = (float2)( 0.f, 0.f ); for( int i = 0; i < 256; i++ ) { z = (float2)( z.x * z.x - z.y * z.y, 2.f * z.x * z.y ) + c; if (dot( z, z ) > f) break; else l += 1.f; float sl = l - log2( log2( dot( z, z ) ) ) + 4.f; float al = smoothstep( -.1f, 0.f, 1.f ); l = mix( l, sl, al ); col +=.5f +.5f * cos( 3.f + l * 0.15f + (float3)(.0f,.6f, 1.f ) ); int r = (int)min( 255.0f, 64.0f * col.x ); int g = (int)min( 255.0f, 64.0f * col.y ); int b = (int)min( 255.0f, 64.0f * col.z ); a[id] = (r << 16) + (g << 8) + b;

36 Concurrency college 11 OpenCL Primer 36 OpenCL / C#

37 Concurrency college 11 OpenCL Primer 37 OpenCL / C#

38 Agenda: Introductie OpenCL OpenCL / C# Workgroups Tot Slot

39 Concurrency college 11 OpenCL Primer 39 Workgroups Verdeling van Threads over de SMs In de Mandelbrot renderer hebben we: 512 * 512 = threads. De Titan X kan maximaal threads tegelijk uitvoeren. De output wordt dus door minstens 5 batches van pixels en 1 batch van pixels verwerkt. Bij deze batch-grootte zijn er per SM /24 = 2048 threads actief, in 64 warps. Workgroup.

40 Concurrency college 11 OpenCL Primer 40 Workgroups Verdeling van Threads over de SMs per SM zijn 2048 threads actief, in 64 warps. In het Mandelbrot voorbeeld: 2048 threads voor 2048 pixels, bij een resolutie van 512x512: de pixels van de eerste 4 regels. for( int i = 0; i < 256; i++ ) { z = (float2)(z.x*z.x-z.y*z.y, 2.f*z.x*z.y) + c; if (dot( z, z ) > f) break; else l += 1.f; Wat gebeurd er als 1 thread een break doet, en de andere threads door willen gaan?

41 Concurrency college 11 OpenCL Primer 41 Workgroups Occupancy z=5; if (cond1) 1111 Wat gebeurd er als 1 thread een break doet, en de andere threads door willen gaan? De threads in een warp worden in lockstep uitgevoerd: iedere thread voert dezelfde instructie uit. Masking wordt gebruikt om streams tijdelijk uit te schakelen. Een break in sommige threads in een warp betekent dat sommige threads inactief worden. Occupancy: aantal actieve threads per SM maximaal aantal threads per SM x = y + z; if (cond2) w = t + u; else w = t u; p = q + r; else x = y z; x++;

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

43 Concurrency college 11 OpenCL Primer 43 Workgroups Verdeling van Threads over de SMs per SM zijn 2048 threads actief, in 64 warps. 2. Wat is het optimale aantal threads per SM? a) Zoveel mogelijk b)

44 Concurrency college 11 OpenCL Primer 44 Workgroups Experiment queue.execute( kernel, null, new long [] { 512 * 512, null, null ); wordt: int [] worksize = { 512, 512 ; queue.execute( kernel, null, worksize, null, null ); Voor t = 21.5: fps = 30.0 int [] worksize = { 512, 512 ; int [] localsize = { 32,... ; // 2, 4, 8, 16 queue.execute( kernel, null, worksize, localsize, null ); fps = 60.0

45 Concurrency college 11 OpenCL Primer 45 Workgroups Workgroup Size Waarom is de workgroup size van belang? Een SM heeft een beperkt aantal registers: 64K voor Kepler en Maxwell threads = bitregisters per thread. Wanneer de compiler onvoldoende registers beschikbaar heeft wordt local memory gebruikt.

46 Concurrency college 11 OpenCL Primer 46 Workgroups Workgroup Size Waarom is de workgroup size van belang? Een SM heeft snel local memory dat toegankelijk is voor alle threads op de SM.

47 Concurrency college 11 OpenCL Primer 47 Workgroups Workgroup Size Waarom is de workgroup size van belang? De threads in een workgroup kunnen barriers gebruiken voor synchronisatie.

48 Agenda: Introductie OpenCL OpenCL / C# Workgroups Tot Slot

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

50 Concurrency college 11 OpenCL Primer 50 Tot Slot 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

51 Concurrency college 11 OpenCL Primer 51 Tot Slot 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 );

52 Concurrency college 11 OpenCL Primer 52 Tot Slot 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 );

53 Concurrency college 11 OpenCL Primer 53 Tot Slot 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 );

54 Concurrency college 11 OpenCL Primer 54 Tot Slot GL Interop Render-to-texture is de meest gebruikte toepassing voor GL interop. Andere toepassingen: Mesh simplification Procedural landscapes / meshes Particle systems

55 Agenda: Introductie OpenCL OpenCL / C# Workgroups Tot Slot

56 Concurrency college 11 OpenCL Primer 56 Tot Slot Literatuur NVIDIA s Fermi: The First Complete GPU Computing Architecture p.glaskowsky_nvidia's_fermi-the_first_complete_gpu_architecture.pdf Boek: 2.4.3, 2.4.4

57 Concurrency Gerard Tel / Jacco Bikker - november 2015 januari 2016 EINDE van OpenCL Primer volgende college: Patterns (3)

58 using System; using System.IO; using System.Collections.Generic; using System.Diagnostics; using System.Threading.Tasks; using Cloo; using OpenTK.Graphics; using OpenTK.Graphics.OpenGL; namespace Template { game.cs class Game { public Surface screen; bool GLInterop = true; Stopwatch timer = new Stopwatch(); ComputeContext context; ComputeCommandQueue queue; ComputeProgram program; ComputeKernel kernel; ComputeBuffer<int> buffer; static int [] data; static float [] texdata = new float[512 * 512 * 4]; static int texid; ComputeImage2D texbuffer; [System.Runtime.InteropServices.DllImport("opengl32", SetLastError = true)] static extern IntPtr wglgetcurrentdc(); public void Init() { // pick first platform var platform = ComputePlatform.Platforms[2]; Console.Write( "initializing OpenCL... " + platform.name + " (" + platform.profile + ").\n" ); // create context with all gpu devices if (GLInterop) { 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 ); else { context = new ComputeContext( ComputeDeviceTypes.Gpu, new ComputeContextPropertyList( platform ), null, IntPtr.Zero ); // load opencl source var streamreader = new StreamReader( "../../program.cl" ); string clsource = streamreader.readtoend(); streamreader.close(); // create program with opencl source program = new ComputeProgram( context, clsource ); // compile opencl source try { program.build( null, null, null, IntPtr.Zero ); catch { Console.Write( "error in kernel code:\n" ); Console.Write( program.getbuildlog( context.devices[0] ) + "\n" ); // create a command queue with first gpu found queue = new ComputeCommandQueue( context, context.devices[0], 0 ); // load chosen kernel from program kernel = program.createkernel( "device_function" ); // create some data data = new int[512 * 512]; // allocate a memory buffer with the message (the int array) var flags = ComputeMemoryFlags.WriteOnly ComputeMemoryFlags.UseHostPointer; buffer = new ComputeBuffer<int>( context, flags, data ); // create a texture to draw to from OpenCL if (GLInterop) { 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 ); float t = 21.5f; public void Tick() { GL.Finish(); // clear the screen screen.clear( 0 ); // do opencl stuff if (GLInterop) { kernel.setmemoryargument( 0, texbuffer ); else { kernel.setmemoryargument( 0, buffer ); kernel.setvalueargument( 1, t ); t += 0.1f; // execute kernel long [] worksize = { 512, 512 ; long [] localsize = { 32, 4 ; // long [] worksize = { 512 * 512 ; if (GLInterop) { List<ComputeMemory> c = new List<ComputeMemory>() { texbuffer ; queue.acquireglobjects( c, null ); queue.execute( kernel, null, worksize, localsize, null ); queue.finish(); queue.releaseglobjects( c, null ); else { queue.execute( kernel, null, worksize, localsize, null ); queue.finish(); // fetch results if (!GLInterop) { queue.readfrombuffer( buffer, ref data, true, null ); // visualize result for( int y = 0; y < 512; y++ ) for( int x = 0; x < 512; x++ ) { screen.pixels[x (y + 5) * screen.width] = data[x + y * 512]; public void Render() { // draw a quad using the texture that was filled by OpenCL if (GLInterop) { 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(); // namespace Template #define GLINTEROP #ifdef GLINTEROP kernel void device_function( write_only image2d_t a, float t ) #else kernel void device_function( global int* a, float t ) #endif { // adapted from inigo quilez - iq/2013 int idx = get_global_id( 0 ); int idy = get_global_id( 1 ); int id = idx * idy; if (id >= (512 * 512)) return; float2 fragcoord = (float2)( (float)idx, (float)idy ), resolution = (float2)( 512, 512 ); float3 col = (float3)( 0.f, 0.f, 0.f ); for( int m = 0; m < 4; m++ ) for( int n = 0; n < 4; n++ ) { float2 p = -resolution + 2.f * (fragcoord + (float2)(.5f * (float)m,.5f * (float)n )); float w = (float)( 2 * m + n ), l = 0.0f; float time = t +.5f * (1.f / 24.f) * w / 4.f; float zoo =.32f +.2f * cos(.07f * time ); float coa = cos(.15f * (1.f - zoo) * time ); float sia = sin(.15f * (1.f - zoo) * time ); zoo = pow( zoo, 8.f ); float2 xy = (float2)( p.x * coa - p.y * sia, p.x * sia + p.y * coa ); float2 c = (float2)( -.745f,.186f ) + xy * zoo, z = (float2)( 0.f, 0.f ); for( int i = 0; i < 256; i++ ) { z = (float2)( z.x * z.x - z.y * z.y, 2.f * z.x * z.y ) + c; if (dot( z, z ) > f) break; else l += 1.f; float sl = l - log2( log2( dot( z, z ) ) ) + 4.f; float al = smoothstep( -.1f, 0.f, 1.f ); l = mix( l, sl, al ); col +=.5f +.5f * cos( 3.f + l * 0.15f + (float3)(.0f,.6f, 1.f ) ); #ifdef GLINTEROP int2 pos = (int2)(idx,idy); write_imagef( a, pos, (float4)(col * (1.0f / 16.0f), 1.0f ) ); #else int r = (int)clamp( 16.0f * col.x, 0.f, 255.f ); int g = (int)clamp( 16.0f * col.y, 0.f, 255.f ); int b = (int)clamp( 16.0f * col.z, 0.f, 255.f ); a[id] = (r << 16) + (g << 8) + b; #endif program.cl