Subject: C440 JGSI Review Resent-Date: Thu, 30 Sep 1999 23:19:22 -0400 Resent-From: Geoffrey Fox Resent-To: p_gcf@npac.syr.edu Date: Mon, 20 Sep 1999 11:44:49 -0400 (EDT) From: Bill Pugh To: gcf@npac.syr.edu Paper: C440 Title: An Annotation aware JVM implementation Authors: Ana Azevedo, Alex Nicolau, and Joe Hummel Overall recommendation: The paper raising an interesting issue but doesn't answer any of the important questions about it. Weak recommendation against publication. The authors describe techniques for annotating class files with additional information to assist in performing compilation to efficient native code. The basic problem is that the paper doesn't address the difficult and important topics associated with this issue. The empirical results in the paper show that using annotations, it is possible to generate better native code than the lame and unoptimized native code generated by kaffe 0.9.2. That was never in question, and all commercial JIT's that I know of do better code generation than kaffe 0.9.2. The interesting issues are: * Compare two methods for generating code: 1) Generate good native code directly from bytecode. algorithm at JIT time. 2) Generate the same quality native code, but assisted by classfile annotations. What takes longer? Generating code directly (method 1), or downloading and verifying the class annotations and then generating code using the annotations (method 2)? * How much do you lose by trying to do machine independent annotations? Different targets have widely varying number of registers, and some machines have constraints on which registers can be used for which operations. * Many high performance JIT's do massive amounts of inlining. Is information like this useful in such a context? The people I talked to on the HotSpot project thought that such information would be useless for them. * How many of the problems that the author's raise could be addressed by bytecode optimization and transformation? Clearly not all of them, but certainly some. Wouldn't it be better to solve as many as possible through bytecode optimizations?