Download - Android High performance in GPU using opengles and renderscript

Limitless Arvind Devaraj

High Performance Graphics and Compute

OpenGLES and RenderScript

Arvind Devaraj


slideshare.net/darvind/


Agenda

● Introduction : Graphics terms

● Graphics on GPU

● OpenGL Android Graphics

● Graphics Pipeline

● Shaders

● High Performance Compute on GPU

● RenderScript


CPU versus GPU

● CPU

– good at executing sequential code

– Handles branches well

● GPU

– Same code, multiple data

– Parallelism (ideal for image rendering)


Graphics Terms

● OpenGLES : Graphics API for doing 3D operations on GPU / CPU

● Primitives : lines, point, triangles

● Texture : make the image realistic by adding bitmap


Graphics on GPU

Wireframe of modelPolygonated


Graphics Pipeline

VertexTransformation

Pixel operationsVertex

Rasterize the triangle to pixels


OpenGL Driver

Converts API call to commands – glDraw()

Commands executed in GPU / CPU

Implementation of the Graphics Pipeline


OpenGLES Android Graphics

● Graphics Library for 3D


Android Graphics Classes

GLSurfaceViewGLSurfaceView.Renderer

➢ View - connects SurfaceView to OpenGLES library

➢ Renderer - responsible for rendering a frame


GLSurfaceView

GLSurfaceView view = new GLSurfaceView(this);

view.setRenderer(new SquareRenderer());


GLSurfaceView.Renderer

public class SquareRenderer implements GLSurfaceView.Renderer {

public void onSurfaceCreated(GL10 unused, EGLConfig config) { } public void onDrawFrame(GL10 unused) {

} public void onSurfaceChanged(GL10 unused, int width, int height) {

}}

When surface is changed (rotated etc)

draw() - Code for drawing the frame ( Square )

Code when surface is created


GLSurfaceView.Renderer

● The renderer is responsible for making OpenGL calls to render a frame.

– onDrawFrame() responsible for drawing the current frame

– OnSurfaceChanged() called when surface size changes

– OnSurfaceCreated() called when surface is created


draw() {

float coords[] = { .... };

vertex 'buffer' created with the coords

glVertexPointer(buffer) :

glDrawArrays(TRIANGLE_STRIP, ...);}

Drawing a Square


draw() {

float squareCoords[] = { .... };

ByteBuffer vbb = ....

squareVB = vbb.asFloatBuffer(); squareVB.put(squareCoords);

gl.glVertexPointer(3, GL10.GL_FLOAT, 0, vertexBuffer);

gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 0, vertices.length / 3);}

Full code:https://github.com/arvind-devaraj/android-opengles/blob/master/3_SquareRenderer/src/com/example/graphics1/Square.java

Drawing a Square


OpenGL Rendering Pipeline


Shaders

● Shaders are programs that execute on the GPU

● Shader programs operate on

– Each vertex

– Each pixel


Shader Programs

• Vertex Shader – operates on each vertex

• Fragment Shader – operates on each pixel

• Shaders are compiled and linked ( like any program )

• Executable is sent to the GPU


Vertex Shader

Fragment Shader

attribute vec4 vertexPosition;void main(){ gl_Position = vertexPosition * 2;

}

precision mediump float;void main(){ gl_FragColor = ( color.r + color.g + color.b ) / 3;}


Program running on GPU/CPU


CPU – GPU communication


GPU for General Programs

● Graphics is accelerated by the GPU

● Can GPU accelerate other programs ?

– e.g. Matrix multiply, encryption

● OpenCL, CUDA, Renderscript are API

– used for general purpose GPU


RenderScript

● A high level API to access GPU● Provides high performance Compute● Provides uniform API across multiple SoC● Alternative is NDK (but NDK is platform

specific)


RenderScript – Use cases

● What functions can be accelerated

– Graphics

– Image Processing

– Encryption

– Signal processing

– Mathematical functions


RenderScript - Flow


RenderScript – CPU side

Class Hello extends Activity {

Allocation input, output;

Create a script (kernel) that specifies the function

Run script for each element in allocation }

Allocation is how you get data to RS, so that it is processed by kernel


RenderScript – CPU side

Class Hello extends Activity {

Allocation input; Allocation output;

RenderScript rs = new RenderScript() ScriptC_func script = new ScriptC_func(...)

script.forEach_root(input, output) }

Allocation is how you get data to RS, so that it is processed by kernel


Renderscript Java interaction


RenderScript – GPU side

func.rs

void root (char *in , char *out) { *out = *in * 2

}

Renderscript code is compiled to device independent Bitcode

Bitcode is dynamically interpreted by runtime for specifi GPU


RenderScript

● Advantages : Compared to NDK, provides an easy device agnostic way to accelerate performance on GPU

● Disadvantages : C99 standard, debugging is restricted


Renderscipt - Summary

● Renderscript is an API to access GPU

● Used for High Performance

● High Performance Compute / Graphics

● Compute, Math , FFT, convolution, Signal processing

● Support Graphics – but not a replacement for OpenGL

● Works on all GPUs ( if supported by SoC ) otherwise on CPU


Renderscript potential

Limitless

[email protected]

arvinddevaraj

github, linkedin,twitter

mailto:[email protected]