Can modular JVMs optimize different instances of the same class in different ways?

Question

Let's say I have 2 instances of the same class, but they behave differently (follow different code paths) based on the final Boolean field set during construction. so something like:

public class Foo { private final boolean flag; public Foo(boolean flagValue) { this.flag = flagValue; } public void f() { if (flag) { doSomething(); } else { doSomethingElse(); } } } 

2 instances of Foo with different values ​​for flag can theoretically be supported by two different assemblies, thereby eliminating the cost of if (sorry for a far-fetched example, the easiest of which I could come up with).

so my question is: are any JVMs really doing this? or is it one class always supported by one assembly?

Answer 1

Yes, JVMs do this form of optimization. In your case, this will be the result of embedding and adaptive optimization in order to be value always, to be true. Consider the following code:

 Foo foo = new Foo(true); foo.f(); 

It’s trivial to prove to HotSpot that Foo always the actual instance of Foo on the call site f , which allows the virtual machine to simply copy-paste the method code, thereby eliminating virtual sending. After insertion, the example boils down to:

 Foo foo = new Foo(true); if (foo.flag) { doSomething(); } else { doSomethingElse(); } 

This again reduces the code to:

 Foo foo = new Foo(true); foo.doSomething(); 

If optimization can be applied, therefore, it depends on the monomorphism of the call site foo and the stability of the flag on this call site. (The VM profiles your methods for such patterns.) The less VM can predict the outcome of your program, the less optimization there will be.

If the example was as trivial as the code above, the JIT will probably also remove the selection of the object and just call doSomething . In addition, for the trivial example case where the field value can be true trivial, the virtual machine does not need to optimize adaptively, but simply applies the above optimization. There is a great tool called JITWatch that allows you to learn how your code will be optimized.

Answer 2

For hotspot, other JVMs can apply various optimizations.

If these instances in the queue are assigned to static final fields and then refer to another code, and the virtual machine starts with -XX:+TrustFinalNonStaticFields , then these instances can participate in a permanent fold, and the CONSTANT.f() attachment can lead to different branches will be eliminated.

Another approach available for privileged code is to create anonymous classes instead of instances using sun.misc.Unsafe.defineAnonymousClass(Class<?>, byte[], Object[]) and fix the class constant for each class, but ultimately it you also need to be referenced using the class constant in order to have any effect on the optimization.