Domain Specific Languages and runtime code generation

One area in which Java has an advantage over typical HPC languages
(C/C++/Fortran) is its ability to use information at runtime to fine tune the
code. If used well, this allows you to write code that is a bit more general without
sacrificing performance, as the code will get "re-specialized" at runtime. 
While in C/C++ sometimes you are stuck with macros or preprocessing scripts, in Java I have been
finding a few different techniques. The last few nights I have been working on another one: runtime compilation of Domain Specific Language expressions.

As much as I'd like to show the actual code, it wouldn't really fit in a blog
entry... But the code is in the Jabble CVS repository, so I'll provide links
here and there for the curious reader. The flow is something like this:

• developer/user specifies at runtime a String that represents
  an expression like
  
  
  
  where phi[x,y] is the field 'phi' at the offset from the current point (The above
  expression is a second order derivative).

• the String is passed to an ANTLR
  generated parser, which return the
  Abstract Syntax Tree
  
  

• the AST is passed to an
  expression builder, which creates a Jabble
  specific tree that is able to calculate the expression at runtime, and aids
  the Java source creation
  
  

• the expression tree is transformed to
  a String that represents a Java
  class that makes that same computation. The Java class will implement the FiniteExpression interface.
  
  

• the java source is
  passed to the JSR199 compiler, which returns a binary
  representation of the bytecode
  
  

• the bytecode is given to a
  memory ClassLoader, so that it can be
  accessed by the running JVM.
  
  

• the ClassLoader is used to create an instance of the newly compiled
  class, which will be handled as a FiniteExpression type object.
  
  

In short: at runtime you can quickly specify an expression (in your code or
through a UI), which gets compiled to Java code, and which is going to take
advantage of all of the Java optimizations. To give you the picture: the calls
made by the runtime generated code are going to be inlined!

There are other, even more interesting possibilities. Given that I have the
domain model expression, I can provide functionalities and optimizations that
are specific to it. For example, I can simplify the expression; I can also
determine the order in which to compute the different fields. (For example, I
can easily understand that "beta[0,0] =  alpha[1,0] - 2 * alpha[0,0] +
alpha[-1,0]" has to be calculated before and in a different Grid iteration than
"gamma[0,0] = beta[1,0] - beta[-1,0] + alpha[0,0]")

The only catch? I have to wait for JDK6 to be available on a Mac to add this
to a Jabble release...