blob: 63f341adbf22d8eee6e5ae3ad333521d836e982e [file] [log] [blame]
<div id="qv-wrapper">
<div id="qv">
<h2>In this document</h2>
<li><a href="#overview">RenderScript System Overview</a></li>
<li><a href="#native">Native RenderScript layer</a></li>
<li><a href="#reflected">Reflected layer</a></li>
<li><a href="#framework">Android framework layer</a></li>
<a href="#mem-allocation">Memory Allocation APIs</a>
<a href="#dynamic">Dynamic Memory Allocations</a>
<li><a href="#pointers">Declaring pointers</a></li>
<li><a href="#struct-pointer-reflection">How pointers are reflected</a></li>
<li><a href="#binding">Allocating and binding memory to the RenderScript</a></li>
<li><a href="#read-write-dynamic">Reading and writing to memory</a></li>
<a href="#static">Static Memory Allocations</a>
<p>RenderScript offers a high performance 3D graphics rendering and compute API at the native
level, which you write in the C (C99 standard). The main advantages of RenderScript are:</p>
<li>Portability: RenderScript is designed to run on many types of devices with different CPU
and GPU architectures. It supports all of these architectures without having to target each
device, because the code is compiled and cached on the device at runtime.</li>
<li>Performance: RenderScript provides similar performance to OpenGL with the NDK while
offering the portability of the OpenGL APIs provided by the Android framework ({@link
android.opengl}). In addition, it also offers a high performance compute API that is not
offered by OpenGL.</li>
<li>Usability: RenderScript simplifies development when possible, such as eliminating JNI glue code
and simplifying mesh setup.</li>
<p>The main disadvantages are:</p>
<li>Development complexity: RenderScript introduces a new set of APIs that you have to learn.
RenderScript also handles memory differently compared to OpenGL with the Android framework APIs
or NDK.</li>
<li>Debugging visibility: RenderScript can potentially execute (planned feature for later releases)
on processors other than the main CPU (such as the GPU), so if this occurs, debugging becomes more difficult.
<li>Less features: RenderScript does not provide as many features as OpenGL such as all the compressed
texture formats or GL extensions.</li>
<p>You need to consider all of the aspects of RenderScript before deciding when to use it. The following list describes
general guidelines on when to use OpenGL (framework APIs or NDK) or RenderScript:</p>
<li>If you are doing simple graphics rendering and performance is not critical, you probably want to use the
Android framework OpenGL APIs, which still provide adequate performance, to eliminate the added coding and debugging complexity of
<li>If you want the most flexibility and features while maintaining relatively good debugging
support, you probably want to use OpenGL and the NDK. Applications that require this are high end
or complicated games, for example.</li>
<li>If you want a solution that is portable, has good performance,
and you don't need the full feature set of OpenGL, RenderScript is a good solution. If you also
need a high performance compute language, then RenderScript offers that as well.
Good candidates for RenderScript are graphics intensive UIs that require 3D rendering, live wallpapers,
or applications that require intensive mathematical computation.</li>
<p>For an example of RenderScript in action, install the RenderScript sample applications that
are shipped with the SDK in <code>&lt;sdk_root&gt;/samples/android-11/RenderScript</code>.
You can also see a typical use of RenderScript with the 3D carousel view in the Android 3.x
versions of Google Books and YouTube.</p>
<h2 id="overview">RenderScript System Overview</h2>
<p>The RenderScript system adopts a control and slave architecture where the low-level native
code is controlled by the higher level Android system that runs in a virtual machine (VM). The
Android VM still retains all control of memory and lifecycle management and calls the native
RenderScript code when necessary. The native code is compiled to intermediate bytecode (LLVM) and
packaged inside your application's <code>.apk</code> file. On the device, the bytecode is
compiled (just-in-time) to machine code that is further optimized for the device that it is
running on. The compiled code on the device is cached, so subsequent uses of the RenderScript
enabled application do not recompile the intermediate code. RenderScript has three layers of code
to enable communication between the native and Android framework code:</p>
<li>The native RenderScript layer does the intensive computation or graphics rendering. You
define your native code in <code>.rs</code> and <code>.rsh</code> files.</li>
<li>The reflected layer is a set of classes that are reflected from the native code. It is basically
a wrapper around the native code that allows the Android framework to interact with native RenderScripts.
The Android build tools automatically generate the classes for this layer during
the build process and eliminates the need to write JNI glue code, like with the NDK.</li>
<li>The Android framework layer is comprised of the Android framework
APIs, which include the {@link android.renderscript} package. This layer gives high level commands
like, "rotate the view" or "filter the bitmap", by calling the reflected layer, which in turn calls
the native layer. </li>
<h3 id="native">Native RenderScript layer</h3>
<p>The native RenderScript layer consists of your RenderScript code, which is compiled and
executed in a compact and well defined runtime. Your RenderScript code has access to a limited
amount of functions because it cannot access the NDK or standard C functions, since they must be guaranteed to
run on a standard CPU. The RenderScript runtime was designed to run on different types of processors,
which may not be the CPU, so it cannot guarantee support for standard C libraries. What
RenderScript does offer is an API that supports intensive computation and graphics rendering with a collection of math
and graphics APIs.</p>
<p>Some key features of the native RenderScript libraries include:</p>
<li>A large collection of math functions with both scalar and vector typed overloaded versions
of many common routines. Operations such as adding, multiplying, dot product, and cross product
are available.</li>
<li>Conversion routines for primitive data types and vectors, matrix routines, date and time
routines, and graphics routines.</li>
<li>Logging functions</li>
<li>Graphics rendering functions</li>
<li>Memory allocation request features</li>
<li>Data types and structures to support the RenderScript system such as Vector types for
defining two-, three-, or four-vectors.</li>
<p>The RenderScript header files and LLVM front-end libraries are located in the <code>include/</code> and
<code>clang-include/</code> directories in the
<code>&lt;sdk_root&gt;/platforms/android-11/renderscript/</code> directory of the Android SDK. The
headers are automatically included for you, except for the RenderScript graphics specific header file, which
you can include as follows:</p>
#include "rs_graphics.rsh"
<h3 id="reflected">Reflected layer</h3>
<p>The reflected layer is a set of classes that the Android build tools generate to allow access
to the native RenderScript code from the Android VM. This layer defines entry points for
RenderScript functions and variables, so that you can interact with them with the Android
framework. This layer also provides methods and constructors that allow you to allocate memory
for pointers that are defined in your RenderScript code. The following list describes the major
components that are reflected:</p>
<li>Every <code>.rs</code> file that you create is generated into a class named
<code>ScriptC_<em>renderscript_filename</em></code> of type {@link
android.renderscript.ScriptC}. This is the <code>.java</code> version of your <code>.rs</code>
file, which you can call from the Android framework. This class contains the following
<li>Non-static functions in your <code>.rs</code> file.</li>
<li>Non-static, global RenderScript variables. Accessor methods are generated for each
variable, so you can read and write the natively declared variables from the Android
framework. The <code>get</code> method comes with a one-way communication restriction. The
last value that is set from the Android framework is always returned during a call to a
<code>get</code> method. If the native RenderScript code changes the value, the change does
not propagate back to the Android framework layer.
If the global variables are initialized
in the native RenderScript code, those values are used to initialize the corresponding
values in the Android framework layer. If global variables are marked as
<code>const</code>, then a <code>set</code> method is not generated.</li>
<li>Global pointers generate a special method named <code>bind_<em>pointer_name</em></code>
instead of a <code>set()</code> method. This method allows you to bind the memory that is
allocated in the Android VM for the pointer to the native RenderScript (you cannot allocate
memory in your <code>.rs</code> file). You can read and write to this memory from both the
Android framework and RenderScript code. For more information, see <a href="mem-mgmt">Working
with Memory and Data</a></li>
<li>A <code>struct</code> is reflected into its own class named
<code>ScriptField_<em>struct_name</em></code>, which extends {@link
android.renderscript.Script.FieldBase}. This class represents an array of the
<code>struct</code>, which allows you to allocate memory for one or more instances of this
<h3 id="framework">Android framework layer</h3>
<p>The Android framework layer consists of the usual Android framework APIs, which include the
RenderScript APIs in {@link android.renderscript}. This layer handles things such as the
Activity lifecycle and memory management of your application. It issues high level commands to
the native RenderScript code through the reflected layer and receives events from the user such
as touch and input events and relays them to your RenderScript code, if needed.
<h2 id="mem-allocation">Memory Allocation APIs</h2>
<p>Before you begin writing your first RenderScript application, you must understand how
memory is allocated for your RenderScript code and how data is shared between the native and VM
spaces. RenderScript allows you to access allocated memory in both the native layer
and Android system layer. All dynamic and static memory is allocated by the Android VM.
The Android VM also does reference counting and garbage collection for you.
You can also explicitly free memory that you no longer need.</p>
<p class="note"><strong>Note:</strong> To declare temporary memory in your native RenderScript
code without allocating it in the Android VM, you can still do things like instantiate a scratch
buffer using an array.</p>
<p>The following classes support the memory management features of RenderScript in the Android
VM. You normally do not need to work with these classes directly, because the reflected layer
classes provide constructors and methods that set up the memory allocation for you. There are
some situations where you would want to use these classes directly to allocate memory on your
own, such as loading a bitmap from a resource or when you want to allocate memory for pointers to
primitive types.</p>
<table id="mem-mgmt-table">
<th>Android Object Type</th>
<td>{@link android.renderscript.Element}</td>
<p>An element represents one cell of a memory allocation and can have two forms: Basic or
<p>A basic element contains a single component of data of any valid RenderScript data type.
Examples of basic element data types include a single float value, a float4 vector, or a
single RGB-565 color.</p>
<p>Complex elements contain a list of basic elements and are created from
<code>struct</code>s that you declare in your RenderScript code. The most basic primitive
type determines the data alignment of the memory. For example, a float4 vector subelement
is alligned to <code>sizeof(float)</code> and not <code>sizeof(float4)</code>. The ordering
of the elements in memory are the order in which they were added, with each component
aligned as necessary.</p>
<td>{@link android.renderscript.Type}</td>
A type is a memory allocation template and consists of an element and one or more
dimensions. It describes the layout of the memory (basically an array of {@link
android.renderscript.Element}s) but does not allocate the memory for the data that it
<p>A type consists of five dimensions: X, Y, Z, LOD (level of detail), and Faces (of a cube
map). You can assign the X,Y,Z dimensions to any positive integer value within the
constraints of available memory. A single dimension allocation has an X dimension of
greater than zero while the Y and Z dimensions are zero to indicate not present. For
example, an allocation of x=10, y=1 is considered two dimensional and x=10, y=0 is
considered one dimensional. The LOD and Faces dimensions are booleans to indicate present
or not present.</p>
<td>{@link android.renderscript.Allocation}</td>
<p>An allocation provides the memory for applications based on a description of the memory
that is represented by a {@link android.renderscript.Type}. Allocated memory can exist in
many memory spaces concurrently. If memory is modified in one space, you must explicitly
synchronize the memory, so that it is updated in all the other spaces that it exists
<p>Allocation data is uploaded in one of two primary ways: type checked and type unchecked.
For simple arrays there are <code>copyFrom()</code> functions that take an array from the
Android system and copy it to the native layer memory store. The unchecked variants allow
the Android system to copy over arrays of structures because it does not support
structures. For example, if there is an allocation that is an array of n floats, the data
contained in a float[n] array or a byte[n*4] array can be copied.</p>
<h2 id="dynamic">Working with dynamic memory allocations</h2>
<p>RenderScript has support for pointers, but you must allocate the memory in your Android framework
code. When you declare a global pointer in your <code>.rs</code> file, you allocate memory
through the appropriate reflected layer class and bind that memory to the native
RenderScript layer. You can read and write to this memory from the Android framework layer as well as the
RenderScript layer, which offers you the flexibility to modify variables in the most appropriate
layer. The following sections show you how to work with pointers, allocate memory for them, and
read and write to the memory.</p>
<h3 id="pointers">Declaring pointers</h3>
<p>Because RenderScript is written in C99, declaring a pointer is done in a familiar way. You can
declare pointers to a <code>struct</code> or a primitive type, but a <code>struct</code> cannot
contain pointers or nested arrays. The following code declares a <code>struct</code>, a pointer
to that <code>struct</code>, and a pointer of primitive type <code>int32_t</code> in an <code>.rs</code> file:</p>
#pragma version(1)
#pragma rs java_package_name(com.example.renderscript)
typedef struct Point {
float2 point;
} Point_t;
Point_t *touchPoints;
int32_t *intPointer;
<p>You cannot allocate memory for these pointers in your RenderScript code, but the Android
build tools generate classes for you that allow you to allocate memory in the Android VM for use by
your RenderScript code. These classes also let you read and write to the memory. The next section
describes how these classes are generated through reflection.</p>
<h3>How pointers are reflected</h3>
<p>Global variables have a getter and setter method generated. A global pointer generates a
<code>bind_pointerName()</code> method instead of a set() method. This method allows you to bind
the memory that is allocated in the Android VM to the native RenderScript. For example, the two
pointers in the previous section generate the following accessor methods in the <code>ScriptC_<em>rs_filename</em></code> file:</p>
private ScriptField_Point mExportVar_touchPoints;
public void bind_touchPoints(ScriptField_Point v) {
mExportVar_touchPoints = v;
if (v == null) bindAllocation(null, mExportVarIdx_touchPoints);
else bindAllocation(v.getAllocation(), mExportVarIdx_touchPoints);
public ScriptField_Point get_touchPoints() {
return mExportVar_touchPoints;
private Allocation mExportVar_intPointer;
public void bind_intPointer(Allocation v) {
mExportVar_intPointer = v;
if (v == null) bindAllocation(null, mExportVarIdx_intPointer);
else bindAllocation(v, mExportVarIdx_intPointer);
public Allocation get_intPointer() {
return mExportVar_intPointer;
<h3>Allocating and binding memory to the RenderScript</h3>
<p>When the build tools generate the reflected layer, you can use the appropriate class
(<code>ScriptField_Point</code>, in our example) to allocate memory for a pointer. To do this,
you call the constructor for the {@link android.renderscript.Script.FieldBase} class and specify
the amount of structures that you want to allocate memory for. To allocate memory for a primitive
type pointer, you must build an allocation manually, using the memory management classes
described in <a href="#mem-mgmt-table">Table 1</a>. The example below allocates memory for both
the <code>intPointer</code> and <code>touchPoints</code> pointer and binds it to the
private RenderScriptGL glRenderer;
private ScriptC_example script;
private Resources resources;
public void init(RenderScriptGL rs, Resources res) {
//get the rendering context and resources from the calling method
glRenderer = rs;
resources = res;
//allocate memory for the struct pointer, calling the constructor
ScriptField_Point touchPoints = new ScriptField_Point(glRenderer, 2);
//Create an element manually and allocate memory for the int pointer
intPointer = Allocation.createSized(glRenderer, Element.I32(glRenderer), 2);
//create an instance of the RenderScript, pointing it to the bytecode resource
mScript = new ScriptC_example(glRenderer, resources, R.raw.example);
// bind the struct and int pointers to the RenderScript
//bind the RenderScript to the rendering context
<h3>Reading and writing to memory</h3>
<p>Although you have to allocate memory within the Android VM, you can work with the memory both
in your native RenderScript code and in your Android code. Once memory is bound, the native
RenderScript can read and write to the memory directly. You can also just use the accessor
methods in the reflected classes to access the memory. If you modify memory in the Android
framework, it gets automatically synchronized to the native layer. If you modify memory in the <code>.rs</code>
file, these changes do not get propagated back to the Android framework.
For example, you can modify the struct in your Android code like this:</p>
int index = 0;
boolean copyNow = true;
Float2 point = new Float2(0.0f, 0.0f);
touchPoints.set_point(index, point, copyNow);
</pre>then read it in your native RenderScript code like this:
rsDebug("Printing out a Point", touchPoints[0].point.x, touchPoints[0].point.y);
<h2>Working with statically allocated memory</h2>
<p>Non-static, global primitives and structs that you declare in your RenderScript are easier to work with,
because the memory is statically allocated at compile time. Accessor methods to set and get these
variables are generated when the Android build tools generate the reflected layer classes. You
can get and set these variables using the provided accessor methods.
<p class="note"><strong>Note:</strong> The <code>get</code> method comes with a one-way communication restriction. The last value
that is set from the Android framework is always returned during a call to a <code>get</code>
method. If the native RenderScript code changes the value, the change does not propagate back to
the Android framework layer. If the global variables are initialized in the native RenderScript
code, those values are used to initialize the corresponding values in the Android framework
layer. If global variables are marked as <code>const</code>, then a <code>set</code> method is
not generated.</p>
<p>For example, if you declare the following primitive in your RenderScript code:</p>
uint32_t unsignedInteger = 1;
<p>then the following code is generated in <code>ScriptC_<em>script_name</em>.java</code>:</p>
private final static int mExportVarIdx_unsignedInteger = 9;
private long mExportVar_unsignedInteger;
public void set_unsignedInteger(long v) {
mExportVar_unsignedInteger = v;
setVar(mExportVarIdx_unsignedInteger, v);
public long get_unsignedInteger() {
return mExportVar_unsignedInteger;
<p class="note"><strong>Note:</strong> The mExportVarIdx_unsignedInteger variable represents the
index of the <code>unsignedInteger</code>'s in an array of statically allocated primitives. You do
not need to work with or be aware of this index.</p>
<p>For a <code>struct</code>, the Android build tools generate a class named
<code>&lt;project_root&gt;/gen/com/example/renderscript/ScriptField_struct_name</code>. This
class represents an array of the <code>struct</code> and allows you to allocate memory for a
specified number of <code>struct</code>s. This class defines:</p>
<li>Overloaded constructors that allow you to allocate memory. The
<code>ScriptField_<em>struct_name</em>(RenderScript rs, int count)</code> constructor allows
you to define the number of structures that you want to allocate memory for with the
<code>count</code> parameter. The <code>ScriptField_<em>struct_name</em>(RenderScript rs, int
count, int usages)</code> constructor defines an extra parameter, <code>usages</code>, that
lets you specify the memory space of this memory allocation. There are four memory space
<li>{@link android.renderscript.Allocation#USAGE_SCRIPT}: Allocates in the script memory
space. This is the default memory space if you do not specify a memory space.</li>
<li>{@link android.renderscript.Allocation#USAGE_GRAPHICS_TEXTURE}: Allocates in the
texture memory space of the GPU.</li>
<li>{@link android.renderscript.Allocation#USAGE_GRAPHICS_VERTEX}: Allocates in the vertex
memory space of the GPU.</li>
<li>{@link android.renderscript.Allocation#USAGE_GRAPHICS_CONSTANTS}: Allocates in the
constants memory space of the GPU that is used by the various program objects.</li>
<p>You can specify one or all of these memory spaces by OR'ing them together. Doing so notifies
the RenderScript runtime that you intend on accessing the data in the specified memory spaces. The following
example allocates memory for a custom data type in both the script and vertex memory spaces:</p>
ScriptField_Point touchPoints = new ScriptField_Point(glRenderer, 2,
<p>If you modify the memory in one memory space and want to push the updates to the rest of
the memory spaces, call <code>rsgAllocationSyncAll()</code> in your RenderScript code to
synchronize the memory.</p>
<li>A static nested class, <code>Item</code>, allows you to create an instance of the
<code>struct</code>, in the form of an object. This is useful if it makes more sense to work
with the <code>struct</code> in your Android code. When you are done manipulating the object,
you can push the object to the allocated memory by calling <code>set(Item i, int index, boolean
copyNow)</code> and setting the <code>Item</code> to the desired position in the array. The
native RenderScript code automatically has access to the newly written memory.
<li>Accessor methods to get and set the values of each field in a struct. Each of these
accessor methods have an <code>index</code> parameter to specify the <code>struct</code> in the
array that you want to read or write to. Each setter method also has a <code>copyNow</code>
parameter that specifies whether or not to immediately sync this memory to the native
RenderScript layer. To sync any memory that has not been synced, call <code>copyAll()</code>.</li>
<li>The createElement() method creates an object that describes the memory layout of the struct.</li>
<li>resize() works much like a <code>realloc</code>, allowing you to expand previously
allocated memory, maintaining the current values that were previously set.</li>
<li>copyAll() synchronizes memory that was set on the framework level to the native level. When you call
a set accessor method on a member, there is an optional <code>copyNow</code> boolean parameter that you can specify. Specifying
<code>true</code> synchronizes the memory when you call the method. If you specify false, you can call <code>copyAll()</code>
once, and it synchronizes memory for the all the properties that are not synchronized.</li>
<p>The following example shows the reflected class, <code></code> that is
generated from the Point <code>struct</code>.</p>
package com.example.renderscript;
import android.renderscript.*;
import android.content.res.Resources;
public class ScriptField_Point extends android.renderscript.Script.FieldBase {
static public class Item {
public static final int sizeof = 8;
Float2 point;
Item() {
point = new Float2();
private Item mItemArray[];
private FieldPacker mIOBuffer;
public static Element createElement(RenderScript rs) {
Element.Builder eb = new Element.Builder(rs);
eb.add(Element.F32_2(rs), "point");
return eb.create();
public ScriptField_Point(RenderScript rs, int count) {
mItemArray = null;
mIOBuffer = null;
mElement = createElement(rs);
init(rs, count);
public ScriptField_Point(RenderScript rs, int count, int usages) {
mItemArray = null;
mIOBuffer = null;
mElement = createElement(rs);
init(rs, count, usages);
private void copyToArray(Item i, int index) {
if (mIOBuffer == null) mIOBuffer = new FieldPacker(Item.sizeof * getType().getX()/* count */);
mIOBuffer.reset(index * Item.sizeof);
public void set(Item i, int index, boolean copyNow) {
if (mItemArray == null) mItemArray = new Item[getType().getX() /* count */];
mItemArray[index] = i;
if (copyNow) {
copyToArray(i, index);
mAllocation.setFromFieldPacker(index, mIOBuffer);
public Item get(int index) {
if (mItemArray == null) return null;
return mItemArray[index];
public void set_point(int index, Float2 v, boolean copyNow) {
if (mIOBuffer == null) mIOBuffer = new FieldPacker(Item.sizeof * getType().getX()/* count */)fnati;
if (mItemArray == null) mItemArray = new Item[getType().getX() /* count */];
if (mItemArray[index] == null) mItemArray[index] = new Item();
mItemArray[index].point = v;
if (copyNow) {
mIOBuffer.reset(index * Item.sizeof);
FieldPacker fp = new FieldPacker(8);
mAllocation.setFromFieldPacker(index, 0, fp);
public Float2 get_point(int index) {
if (mItemArray == null) return null;
return mItemArray[index].point;
public void copyAll() {
for (int ct = 0; ct &lt; mItemArray.length; ct++) copyToArray(mItemArray[ct], ct);
mAllocation.setFromFieldPacker(0, mIOBuffer);
public void resize(int newSize) {
if (mItemArray != null) {
int oldSize = mItemArray.length;
int copySize = Math.min(oldSize, newSize);
if (newSize == oldSize) return;
Item ni[] = new Item[newSize];
System.arraycopy(mItemArray, 0, ni, 0, copySize);
mItemArray = ni;
if (mIOBuffer != null) mIOBuffer = new FieldPacker(Item.sizeof * getType().getX()/* count */);