On Tue, Feb 16, 2010 at 2:59 AM, Blake McBride blake@mcbride.name wrote:
I do: (let ((meth (jmethod "java.lang...." "javaMethodName" "arg-type")) (cls (jclass "java.lang....."))) (defun lisp-fun (arg) (jcall meth cls arg))) Rather than: (defun lisp-fun (arg) (jcall (jmethod "java.lang...." "javaMethodName" "arg-type") (jclass "java.lang.....") arg)) In order to cache the jmethod and jclass calls. I read in another post that this had no value because (essentially) this is what the compiler is doing anyway. Is this true? Does it make any difference which way I do it in terms of speed?
AFAIK, the compiler already caches the class and method metaobject on a per-call-site basis, obviously only if it knows at compile time all the parameters to the jcall/jmethod call. I'd like eventually to make the compiler even smarter and generate directly the bytecode to invoke the method if it has all the information to do so; this means that in the future it might be actually more efficient *not* to cache methods and classes! (*if and only if* everything is known at compile time i.e. all the arguments to jmethod/jclass are constantp). For all the other cases - in interpreted code, or when the arguments are variable and not entirely known at compile time - caching methods and classes is useful performance-wise.
Cheers, Alessio