avalon-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Leo Simons <leosim...@apache.org>
Subject Re: Excalibur Phase III Release Candidate 1
Date Thu, 24 Apr 2003 13:08:29 GMT
Nicola Ken Barozzi wrote:
> Leo Simons wrote, On 24/04/2003 14.46:
> 
>> marking classes as final often results in more inlining which speeds 
>> things up considerably depending on your jvm.
> 
> ;-)) Read the article...

"Like many myths about Java performance, the erroneous belief that 
declaring classes or methods as final results in better performance is 
widely held but rarely examined. The argument goes that declaring a 
method or class as final means that the compiler can inline method calls 
more aggressively, because it knows that at run time this is definitely 
the version of the method that's going to be called. But this is simply 
not true. Just because class X is compiled against final class Y doesn't 
mean that the same version of class Y will be loaded at run time. So the 
compiler cannot inline such cross-class method calls safely, final or 
not. Only if a method is private can the compiler inline it freely, and 
in that case, the final keyword would be redundant.

On the other hand, the run-time environment and JIT compiler have more 
information about what classes are actually loaded, and can make much 
better optimization decisions than the compiler can. If the run-time 
environment knows that no classes are loaded that extend Y, then it can 
safely inline calls to methods of Y, regardless of whether Y is final 
(as long as it can invalidate such JIT-compiled code if a subclass of Y 
is later loaded). So the reality is that while final might be a useful 
hint to a dumb run-time optimizer that doesn't perform any global 
dependency analysis, its use doesn't actually enable very many 
compile-time optimizations, and is not needed by a smart JIT to perform 
run-time optimizations."

jada jada jada :P. Nice theory, but my reality is that marking methods 
as final *does* speed things up. Of course, we don't want to optimize 
prematurely, but in the case of (for example) 
AbstractLogEnabled.getLogger(), the final really has been proven to help 
in some jvms.

cheers!

- Leo



---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@avalon.apache.org
For additional commands, e-mail: dev-help@avalon.apache.org


Mime
View raw message