[PPL-devel] On the performance and expressiveness of the PPL java bindings

[Gianluca Amato]

Hi all,
I am using the PPL library from Java (hmm.. Scala, actually) to make 
experiments on abstract interpretation based static analysis. I would 
like to share some considerations about a couple of aspects of the Java 
bindings which I believe could be improved.

First aspect is performance. Obviously, using native libraries in the 
JVM always incurs a certain amount of performance penalty. I tried to 
develop a native implementation of Double_Box, and it is much faster 
than using the Double_Box fron PPL (the native implementation is not 
safe since I cannot control rounding mode within Java, but I do not 
think this impacts performance a lot). Obviously for more complex 
domains the overhead of calling native methods is proportionally lower.

My question is: is it possible to improve performance of the Java 
bindings? I am not an expert in JNI, but from a fast scan of the code, 
it seems the Java code passes to the native methods an object. The 
native code calls some accessor function to get the ptr field (which is 
the pointer to the native PPL object). It should be possible to rewrite 
the native functions so that they receive directly the pointer, and 
therefore do not need to call the accessor methods. From what I have 
heard, calling accessor methods is slow. Has this approach been pursued 
and abandoned or not? Do you think it could produce a noticeable 
improvement in performance?

The other point regards expressiveness. Java classes in PPL form a flat 
hierarchy. This makes difficult to write generic code, parametric w.r.t. 
the abstract domain. In C++ there is a flat hierarchy,  too, but there 
templates may be used to write generic code effectively. In Java, the 
only choices to write generic code are either to use reflection (which 
is quite costly) or to write thin wrappers over the PPL classes, and put 
wrappers in a hierarchy, (which is tedious). Who works in Scala may use 
macros, but in any case, writing generic code is cumbersome, and the 
model of a flat hierarchy is against standard Java best-practices.

Would it be possible to define an interface which declares all the 
methods in common between the PPL domains? The domains could implement 
this interface. This would allow to write generic code by just 
exploiting the subclass relationship.

Sorry for the long mail. I am very interested to know the opinion of the 
PPL developer and users on this points.

Cheers,
--gianluca