GPGPU Programming @DroidconNL 2012 by Alten

Technology Consulting and Engineering

GPGPU Programming
on Android devices
Alten droidconNL 2012

ALTEN | 11/22/12

Welcome

• Alten PTS; leading service provider in the field of technical
consultancy and engineering
 Eindhoven, Capelle aan de IJssel and Apeldoorn

• ir. Arjan Somers

Alten-droidconNL 2012 Slide 2

Goals

●What is GPGPU?
●How is it done on current Android devices?

●When is GPGPU programming useful?


Contents

●What
●Why

●How

●When

●Example


What

●GPGPU programming is using the GPU to
perform general purpose calculations
● Data manipulation using the graphic card


What

A little bit of history
●

● GPU's and OpenGL

● Parallel vector based operations

● Programmable (Shaders)

Battlezone (1980) Crysis 3 (2013)


What

A little bit of history
●

● GPU's and OpenGL

● Parallel vector based operations

● Programmable (Shaders)


What: parallel proccessing

Parallel vector based operations
●

● Process vertices / pixels

● Independent/parallel processing


What: programmable GPU's

Displacement mapping
●

● Requires control over

vertex and fragment
processing



OpenGL Pipeline
●



OpenGL Pipeline
●

Shaders



●Shaders

Vertex Fragment

void main(void) void main(void)
{ {
gl_Position = gl_Vertex; gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0);
} }



A fragment shader
●

void main(void)
{
vec2 pos = mod(gl_FragCoord.xy, vec2(50.0)) - vec2(25.0);
float dist_squared = dot(pos, pos);

gl_FragColor = (dist_squared < 400.0)
? vec4(.90, .90, .90, 1.0)
: vec4(.20, .20, .40, 1.0);
}


What: General calculations

Simple GPGPU
●

● Upload input data in textures

● Render quad

● Perform calculations in pixel shader

● Read back results



Java
App



Upload()

Upload()
Java
App



Java
App
Draw()



Java
App

Read()


What

A CPU program vs a GPU Program
●

int[] a; int[] b=F(a); int[] b;

Texture draw() pixel-buffer

int[] a; int[] b;


Why

●Additional computational power
● Can run in parallel with CPU

●Greater computational power

● Galaxy S2

● CPU 4 GFlops

● GPU 10 GFlops


How

1) Parallelize code
2) Data packing
3) Implement OpenGL ES 2.0 Shaders
4) Drawing and Input/Output


How: Parallelize code

Pixel-shader parallel code:

public void foo(int[] a, int[] b){
int[] c = new int[a.length];

for(int i=0; i<a.length; i++){
c[i] = a[i] + 2*b[i];
}
}



Not Pixel-shader parallel code:
(Mobile GPU have no geometry shaders)

public int[] bar(int[] a, int[] b, int[] c){
int[] d = new int[a.length];

for(int i=0; i<a.length; i++){
d[b[i]] += a[i];
d[c[i]] += a[i];
}
return d;
}



Not Pixel-shader parallel code:
● Sequence of calculations


How: Data packing

Current mobile GPU's only have
● 8bpp buffers and textures

● single render target


How: Data packing

Packing uses
●

● Floating point in/out-put

● Physics simulation

requiring multiple outputs


How: Implement Shaders

Will be shown later in detail
●

● Use OpenGL ES 2.0

● No CUDA, OpenCL or similar


How: Drawing and Input/Output

Transfer is slow
●

Texture draw() pixel-buffer

Int[] a; Int[] b;


When: What works, what not

●Parallelism
● No geometry shaders

●Limited precision / Single Render Target

●Limited data transfer

●Not yet as fast a desktop


Example

AES encryption on the GPU
●

“Hello droiconNL!”

Encryption

U2FsdGVkX18UAXwN1I7bomP0kuKNXwQ8h
2NHb8lZ5sAG6uaLjZxzkn/ik9QPv8Pq

Decryption

“Hello droiconNL!”


Example

Encoding Decoding


Example

Encoding Decoding

Not GPU-Parallel GPU-Parallel


Example


Example

Are all parts implementable on gpu?


Example

Are all parts implementable on gpu?

Parallelizable?
Packing required?


Example

Implementing shader

Dec Hex
0 00
25 19
255 FF


Example

Implementing shader
●Parallelizable?
●Packing?

●Steps:

● Find row/column using hex-digits

● Find new value in substitution table


Example

uniform sampler2D SBox;
uniform sampler2D InputTexture;
varying vec2 vTexCoord;

void main(void)
{
vec4 inputValues = texture2D(InputTexture, vTexCoord) * 256.0; //four values range [0.255]

vec4 firstHexDigits = floor(inputValues / 16.0) / 16.0;
vec4 lastHexDigits = mod(inputValues, 16.0) / 16.0;

gl_FragColor = vec4(
texture2D(SBox, vec2(firstHexDigits.x, lastHexDigits.x)).x),
texture2D(SBox, vec2(firstHexDigits.y, lastHexDigits.y)).x),
texture2D(SBox, vec2(firstHexDigits.z, lastHexDigits.z)).x),
texture2D(SBox, vec2(firstHexDigits.w, lastHexDigits.w)).x));
}


Example

uniform sampler2D InputTexture; Get four bytes from input

void main(void)
{


}


Example

uniform sampler2D InputTexture; Convert from [0, 1) to [0, 255]

void main(void)
{


}


Example

No bitshifting, but some build-in functions
uniform sampler2D InputTexture; floor(X / 16) = floor(X / 2^4) = X << 4
varying vec2 vTexCoord; Scale back to [0, 1) range
void main(void)
{


}


Example

uniform sampler2D SBox; No masking, but some build-in functions
uniform sampler2D InputTexture; mod(X / 16) = mod(X / 2^4) = X & 0x0F

void main(void)
{


}


Example

uniform sampler2D InputTexture; Find the new value in the s-box

void main(void)
{


}


Example

uniform sampler2D InputTexture; Pack four values in output pixel

void main(void)
{


}


My experiences

●OpenGL ES is limited vs Desktop
● Geometry shaders

● Buffer formats / no MRT's

●Sometimes difficult to debug

● Dithering

● NPOT

●Complex algorithms are possible

● Computer vision implemented

●Large speed gains are possible


Conclusion

●How is GPGPU programming performed on
Android devices?
● Trough the use of shaders and textures

●When is GPGPU a viable option?

● Calculations are consuming too much time

● Calculations are parallelizable

● Can be implemented using 32 bit buffers

● Limited transfer GPU-CPU memory

required


Conclusion

●GPGPU programming has high potential
●Mobile GPU are becoming faster

●GPGPU programming is fun


GPGPU Programming @DroidconNL 2012 by Alten

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

En vedette

En vedette (18)

Similaire à GPGPU Programming @DroidconNL 2012 by Alten

Similaire à GPGPU Programming @DroidconNL 2012 by Alten (20)

Dernier

Dernier (20)

GPGPU Programming @DroidconNL 2012 by Alten