[Solved] How to use OpenCL on Android?

For plattform independence (desktop, cloud, mobile, …) it would be great to use OpenCL for GPGPU development when speed does matter. I know Google pushes RenderScript as an alternative, but it seems to be only be available for Android and is unlikely to be ever included in iOS.

Therefore I seek for a solution to execute OpenCL code within Android Apps.

Enquirer: Rodja

||

Solution #1:

The only Android devices I know that support OpenCL are the ones based on the Mali T600 family of chips (article here). They have an OpenCL SDK. Apparently it is OpenCL 1.1 full profile as well.

The Nexus 10 is a device that uses such a chip. The Samsung Exynos 5 dual SoC uses a Mali T604, so anything using this supposedly could be used with the Mali T600 OpenCL SDK (havne’t tried any of this myself).

The author of the OpenCL blog is trying to have a go with this, so it might be worth following his series of articles.

But, OpenCL support on Android is brand new (as of 16/2/2013) so, while great for experimentation, it might be worth being cautious until there is more support (who says how buggy the intitial support of OpenCL 1.1 is)

Respondent: prunge

Solution #2:

Although time has passed since the original question was asked, I think this is still a question for a lot of developers.

There are two aspects in the answer.
First, unfortunately, Google doesn’t support OpenCL officially.

Second, fortunately, many chip vendors provide their libraries to support OpenCL. As the time for now, most of the flagship and middle-tier smartphones (with Qualcomm Adreno GPU, ARM Mali GPU, or Imagination PowerVR GPU) include the OpenCL libraries.

To use OpenCL on Android, there are several steps:

  1. check if there is OpenCL library on the device. This can be done by using OpenCL-Z Android. This is a great tool to check the OpenCL availability on Android devices, and it also provides raw compute performance metrics, which could be very helpful.

The OpenCL libraries for the major chip vendors can be found in the devices:
The followings are the location of the OpenCL library:

Qualcomm Adreno:

/system/vendor/lib/libOpenCL.so
or /system/lib/libOpenCL.so (older devices)

ARM Mali:

/system/vendor/lib/egl/libGLES_mali.so
or /system/lib/egl/libGLES_mali.so

PowerVR:

/system/vendor/lib/libPVROCL.so
  1. Write your OpenCL program using C or C++

  2. Create NDK project to compile your C/C++ code, and test them on the device as executable.

  3. Create JNI interface for your NDK program functions.

  4. Create Android project, using JNI functions in the JAVA code to call native functions involving with OpenCL.

The sony tutorial is a good source to refer. The techniques presented in that tutorial can be applied to any Qualcomm Adreno GPU. With very minimal modification, that code and makefiles can also run on other OpenCL-capable devices (such as Mali and PowerVR).

Hope this helps.

Respondent: Robert Wang

Solution #3:

Checkout an Android OpenCL demo over at Sony developer world, complete project with source, where a bilateral filtering of an image is done in OpenCL and compared to a single threaded C implementation. Some information on what kind of support is expected in Sony devices etc can be found in the article as well.

Article:

Boost the performance of your Android app with OpenCL

Source for article:

Source to OpenCl Android project

Disclaimer: I’m a consultant at Sony Mobile

Respondent: Magnus

Solution #4:

In 2018, you can use openCL to develop Android app with Android Studio.

In order to use openCL with Android Studio, you will need to do several things.

  1. Check to see if your device supports openCL and what version using the OpenCL-Z Android and copy the prebuilt library into your computer like Robert Wang said.
  2. Download Android Studio.
  3. Create a project C/C++ support.
  4. Copy your libOpenCL.so to the folder /<your_project>/app/src/main/jniLibs/<architecture>/(You will have to create the folder yourself).
  5. Create your native C/C++ file if it is not created yet and link it with the prebuilt library in Cmake. Also, add your native C/C++ file as a library for the android project. https://developer.android.com/studio/projects/configure-cmake.
  6. Config your module(app) build.gradle file.

    android{
       ...
       default_config{
           externalNativeBuild{
              cmake {
                 // Filter based on your device architecture
                 abiFilters 'armeabi-v7a'
              }
            }
            ...
       }
       sourceSets {
          main {
             jniLibs.srcDirs = ['src/main/jniLibs']
          }
       }
       ...
    }
    
Respondent: Khoa Tran

Solution #5:

You should use RenderScript Compute instead:
http://developer.android.com/guide/topics/renderscript/compute.html

Using OpenCL is not very safe because the library (or capability) may not be available on the target device. To be honest, I don’t even know if any Android device out there actually supports it. RenderScript will fall back to CPU computation if the GPU on the device is not capable of executing whatever program you want to run.

However, if you still want to use OpenCL, heres something that may help you
http://www.pgroup.com/lit/articles/insider/v4n2a3.htm

You might want/need the device-specific SDK (like the nVidia Tegra SDK) in order to have proper control.

Respondent: silverclaw

Solution #6:

All Qualcomm Adreno 300 serials support OpenCL 1.1 embedded profile. To use OpenCL, you need to develop NDK code as OpenCL is not supported by google at Java layer. It is pretty straighforward to write OpenCL code if you know how to develop NDK code. You need to have the libOpenCL.so available, which can be fetched from the OpenCL capable device, such as HTC one, Moto X, and Samsung Note/Galaxy versions that use Snapdragon.

Respondent: Hunter Wang

Solution #7:

Khronos released OpenCL 2.0 including official support for Android:
https://www.khronos.org/news/press/khronos-releases-opencl-2.0

Respondent: peter rautek

Solution #8:

Just look at the open source arm compute library (ACL), which contains OpenCL kernels:
https://developer.arm.com/technologies/compute-library

It has a documentation site:
https://arm-software.github.io/ComputeLibrary/latest/

and a github site:
https://github.com/ARM-software/ComputeLibrary

Look also for Qualcomm SNPE SDK (it uses OpenCL: https://developer.qualcomm.com/forum/qdn-forums/software/snapdragon-neural-processing-engine-sdk/34526): https://developer.qualcomm.com/docs/snpe/overview.html

https://www.youtube.com/watch?v=h3T1ekJ_iXM

You can also see Tensorflow Lite for mobile apps: https://www.tensorflow.org/lite/

Maybe in future it will support OpenCL in the way of ACL (now it is Android 8.1 NNAPI solution – https://www.slideshare.net/kstan2/open-source-nn-frameworks-on-cellphones):

https://github.com/tensorflow/tensorflow/issues/18324

Tensorflow Lite GPU acceleration – does it work for all OS versions or only for 8.1?

http://jevois.org/qa/index.php?qa=2057&qa_1=can-tensorflow-lite-use-the-gpu

A fine example programmed with Kotlin is here:
https://github.com/eddywm/KTFLITE

For caffe2 using also NNAPI or OpenGL, there is some hope for OpenCL in future:
https://github.com/laMia482/caffe2_android

Respondent: 42n4

The answers/resolutions are collected from stackoverflow, are licensed under cc by-sa 2.5 , cc by-sa 3.0 and cc by-sa 4.0 .

Leave a Reply

Your email address will not be published.