If we are talking about data-parallel architectures, CUDA is definitely coming to mobile platforms: the new Tegra platform that Nvidia will release this year will have the same Kepler core as the GeForce and Tesla cards. Even last year's Tegra supported something they called "Computational Photography".

At least one OpenCL compiler exists for multicore ARM CPUs; it is developed by The Portland Group. As far as I understand, some ARM Mali GPUs also support OpenCL 1.1.

So yes, theoretically it is possible to do SIMD tasks on phones. The question is whether the respective platforms will provide tools for developers to actually use them. For instance, I doubt if it is a simple matter to initiate a CUDA call from an Android app running on Dalvik.

Most mobile GPU vendors like ARM (Mali), Imagination Tech (PowerVR) and Qualcomm (Adreno) have or are working on embedded OpenCL drivers and tools.

On Android, you can use the NDK, with C++ support to access the OpenCL libraries.

There is also an alternative for Android, which is Renderscript. It's a language developed by Google, so it's embedded in every Android device, and capable of accessing the GPU since version 4.2.2 if I remember correctly.

iOS should be OpenCL capable, since Apple is one of the inventors of the language. I never tried this though.

First of all, CUDA is an NVIDIA-only thing. So, certainly you would need the Tegra platform for this. This also means that your application would not be portable between different Android phones.

OpenCL on the other hand is more promising. It is an open standard that has been adopted by many companies. Apple being the inventor of OpenCL one would expect that they make it available on iOS. As far as I know OpenCL is integrated into iOS, but deemed a private API. That is it is very complicated to program against OpenCL and it is against Apple's AppStore rules. This basically means that you could not publish any application using OpenCL (with OpenGLES 3.0 you could do it the old way by writing special vertex shaders to do the computations). My guess is that Apple does not want you to use your mobile devices for GPGPU because it would severely impact your battery life.

You should also be more careful with the wording of your question. To me parallel programming starts with multicore programming. Things like OpenMP and MPI come to mind. Probably, you will not have these two libraries on your mobile device, but there are many other ways to explicitly use multiple cores on mobile devices (there are already some octacore Android phones). So, to me parallel programming is a very broad term, when you just mean GPGPU computing.

Parallel computing in mobile devices is still not really straightforward.

Multicore ARMs can be programed using ARM tools. An OpenCL implementation for multicore ARMs (by Portland Group) was available for regular developers but it is not anymore.

I assume you are asking about asymmetrical multiprocessing or heterogeneous computing.

- Mobile GPUs can be accesed using OpenGL ES, but it is not easy at all, since architectural details of the chips are not fully disclosed and the implementation of OpenGL ES is optimized for graphics processing, not for general purpose computation.

- Since the previous approach is not optima, also OpenCL implementations exist for ARM Mali GPUs and Qualcomm Adreno's GPUs. There is an OpenCL SDK available for Adreno's GPUs that can be used almost out of the box. It works fine with developmend boards (DSKs). However, commercial OpenCL support has been taken officially out of the Android platform. It is still possible to access OpenCL with a "hack". So no chance of using OpenCL in an android phone officially.

- As far as I know, accessing the DSPs included in the SoC with standard C code is not supported in commercial mobile devices. It is possible to do it with development boards though.

- The Google alternative to avoid all this is Renderscript. This API works transparently to the user. You implement something in renderscript and it is executed wherever the API decides it is better, be it the CPU, GPU or DSP.

- CUDA is still unsupported in commercial boards (nVidia says it is coming but they have been saying this for ages).

- The computational photography platform of nVidia is basically an architecture called Fcam, ported from Nokia/Standford ideas, and although it uses the GPU and DPS for some tasks it is not really thought for heterogeous computing.

So summarizing:

In development boards (DSK) you can use:

Open GL ES + OpenCL to use the GPU

C code to use the DSP or the multicore ARM

Some extensions to use the CODECs and IVA

In commercial Android devices you have:

Java+C code for the multicore ARMs

Renderscript for the GPU+DSP+multicore ARM

OpenGL ES for the GPU

Unofficially OpenCL for GPU and ARM

In other platforms (windows Phone, iOS) seems to be similar.

Greats and very illustratives answers, thanks i think my research interest should focus in other topic in the mobile world less difficutl, like depevelopment enterprise mobile apps or mobile computer visionr apps, using OpenCV, subjects that interests me too, any suggestions?

Computer Vision apps using openCV is a very nice topic. And maybe in the future (or slowly) you can move some of the computationally intensive operations of your CV applications to other devices included in the mobile SoCs.

Also, If you are looking for some small collaboration, I am open to the idea.

that sounds nice, Miguel, when i go deep in the OpenCV library running on android and start to develop more complex applications, surely i will need some help,

You can check also here: https://www.montblanc-project.eu/home and here: https://www.montblanc-project.eu/project/objectives

I am not really related to the project but seems promising of course you can not achieve similar performance to other mainstream processors but the main purpose is to scale with energy-efficient hardware. The first phase of the project was mainly focus on hardware though. More will follow from what I know from people working on this.

Currently for parallel tasks, multi threading concepts and AsyncTask is there in Android.

As far as about using multiple cores of the processor, one has to go to the hardware level not just high level programming.

This could be done in using OpenCL libraries in C++ using NDK, as said by others also.