PossibleAparapiLambdaSyntaxOptions.md

#PossibleAparapiLambdaSyntaxOptions syntax suggestions for HSA enabled Aparapi

#Introduction Now that Java 8 is nearly upon us and HSA enabled Aparapi 'lambda' branch is usable (though in no way complete) I figured we could use this page to discuss the 'programming model' we might prefer for Aparapi, and contrast with the API's for the new Java 8 lambda based stream APIs.

##Converting between Aparapi HSA + Java 8 enabled Aparapi Our hello world app has always been the ''vector add''. In classic Aparapi we could transform

final float inA[] = .... // get a float array from somewhere
final float inB[] = .... // get a float from somewhere
                     // assume (inA.length==inB.length)
final float result = new float[inA.length];

for (int i=0; i<array.length; i++){
    result[i]=intA[i]+inB[i];
}

to

Kernel kernel = new Kernel(){
   @Override public void run(){
      int i= getGlobalId();
      result[i]=intA[i]+inB[i];
   }
};
Range range = Range.create(result.length);
kernel.execute(range);

For the lambda aparapi branch we can currently use

Device.hsa().forEach(result.length, i-> result[i]=intA[i]+inB[i]);

Note that the closest Java 8 construct is

IntStream.range(0, result.length).parallel().forEach(i-> result[i]=intA[i]+inB[i]);

Aparapi and Java 8 stream API's both use IntConsumer as the lambda type. So you can reuse the lambda.

IntConsumer lambda = i-> result[i]=intA[i]+inB[i];

IntStream.range(0, result.length).parallel().forEach(lambda);
Device.hsa().forEach(result.length, lambda);

Exposing the Deviceness of this was a conscious effort. We may also hide it completely.

IntConsumer lambda = i-> result[i]=intA[i]+inB[i];

IntStream.range(0, result.length).parallel().forEach(lambda);
Aparapi.forEach(result.length, lambda);

I am toying with providing an API which maps more closely to the Stream API from Java 8.

Maybe

IntStream.range(0, result.length).parallel().forEach(lambda);
Aparapi.range(0, result.length).parallel().forEach(lambda);

This way users can more readily swap between the two.

For collections/arrays in Aparapi we can also offer

T[] arr = // get an array of T from somewhere
ArrayList<T> list = // get an array backed list of T from somewhere

Aparapi.range(arr).forEach(t -> /* do something with each T */);

We can create special cases. Say for mutating images

BufferedImage in, out;
Aparapi.forEachPixel(in, out, rgb[] -> rgb[0] = 0 );

We may also need select operations for associative operations

class Person{
    int age;
    String first;
    String last;
};

Aparapi.selectOne(Person[] people, (p1,p2)-> p1.age>p2.age?p1:p2 );

##A case for map reduce A mapper maps from one type to another. Possibly by extracting state. Here is a mapper which maps each String in an array of Strings to its length.

As if the mapper was

interface mapToInt<T>{ int map(T v); }

Here it is in action.

Aparapi.range(strings).map(s->string.length())...

Now the result is a stream of int's which can be 'reduced' by a reduction lambda.

In this case the reduction reduces two int's to one, by choosing the max of k and v. All reductions must be commutative style operations (max, min, add) where the order of execution is not important.

int lengthOfLongestString = Aparapi.range(strings).map(s->string.length()).reduce((k,v)-> k>v?k:v);

Here we had a sum reduction.

int sumOfLengths = Aparapi.range(strings).map(s ->string.length()).reduce((k,v)-> k+v);

Some of these may be common enough that we offer direct functionality.

int sumOfLengths = Aparapi.range(strings).map(s ->string.length()).sum();
int maxOfLengths = Aparapi.range(strings).map(s ->string.length()).max();
int minOfLengths = Aparapi.range(strings).map(s ->string.length()).min();
String string = Aparapi.range(strings).map(s->string.length()).select((k,v)-> k>v);

This last one needs some explaining. We map String to int then select the String whose length is the greatest.