How to design class hierarchy to make use of Bimorphic inlining

Question

I have a question regarding the optimum number of implementations you can have of an interface.
I have 1 interface and 2 main implementations. All the methods except one very rarely invoked method in those two main sub-classes are frozen using final.
interface Foo{
  void hotMethod1();
  void rarelyUsedMethod();
class A implements Foo{
  final void hotMethod1(){.. .. ..}
  //Non final!!
  void rarelyUsedMethod(){.. .. ..}
class B implements Foo{
  final void hotMethod1(){.. .. ..}
  //Non final!!
  void rarelyUsedMethod(){.. .. ..}
}Then there are many (more than 20!) sub-classes of these 2 main sub-classes - dynamically generated bytecode.
class Aee26671 extends A{
  void rarelyUsedMethod(){.. .. ..}
class B33423 extends B{
  void rarelyUsedMethod(){.. .. ..}
class C12ds423 extends A{
  void rarelyUsedMethod(){.. .. ..}
and so on...All these second level sub-classes just override the rarelyUsedMethod().If in some caller method I do this:
x(Foo foo){
  foo.hotMethod1();
}Does the Hotspot compiler recognize that there are only 2 possible targets because A and B have their implementations marked as final?
I've heard of Bimorphic inlining. But does it look just at candidate Sub-classes - in this case there are more than 2 sub-classes.
Or, does it realize that the actual candidate implementations of the hot method are just 2 (A and B) because they are "final" and optimize it?
PS: Does Hotspot do Bi or Polymorphic inlining?

Answer 1

Hi Ashwin,
as far as I understand, the bi-morphic case is really a special optimization that occurs when there are only two possible classes (not necessarily methods) involved. You can easily test that by adapting my newsletter: [Polymorphism Performance Mysteries Explained|http://www.javaspecialists.eu/archive/Issue158.html]
Here is how I tested it:
import java.util.Random;
public class PolymorphismTest {
  private static final int UPTO = 100 * 1000 * 1000;
  public static void main(String[] args) throws Exception {
    int offset = Integer.parseInt(args[0]);
    Foo[] tests = generateTestData(offset);
    System.out.println("Warmup");
    test_all(tests);
    System.out.println("Actual run");
    printHeader(tests);
    test_all(tests);
  private static void test_all(Foo[] tests) {
    for (int j = 0; j < 10; j++) {
      run_tests(tests);
  public static void run_tests(Foo[] tests) {
    long time = System.currentTimeMillis();
    test(tests);
    time = System.currentTimeMillis() - time;
    System.out.print(time + "\t");
    System.out.flush();
    System.out.println();
  public static void test(Foo[] sources) {
    Foo t0 = makeRandomTest(sources);
    Foo t1 = makeRandomTest(sources);
    Foo t2 = makeRandomTest(sources);
    Foo t3 = makeRandomTest(sources);
    Foo t4 = makeRandomTest(sources);
    Foo t5 = makeRandomTest(sources);
    Foo t6 = makeRandomTest(sources);
    Foo t7 = makeRandomTest(sources);
    Foo t8 = makeRandomTest(sources);
    Foo t9 = makeRandomTest(sources);
    for (int i = 0; i < UPTO / 10; i++) {
      t0.hotMethod1();
      t1.hotMethod1();
      t2.hotMethod1();
      t3.hotMethod1();
      t4.hotMethod1();
      t5.hotMethod1();
      t6.hotMethod1();
      t7.hotMethod1();
      t8.hotMethod1();
      t9.hotMethod1();
  private static Foo makeRandomTest(Foo[] sources) {
    return sources[((int) (Math.random() * sources.length))];
  private static void printHeader(Foo[] tests) {
    System.out.print(tests[0].getClass().getSimpleName());
    System.out.print('\t');
    System.out.println();
  private static Foo[] generateTestData(int offset)
      throws Exception {
    switch (offset) {
      default:
        throw new IllegalArgumentException("offset:" + offset);
      case 0:
        return fillSources(A.class);
      case 1:
        return fillSources(A.class, B.class);
      case 2:
        return fillSources(A.class, B.class, Aee26671.class);
      case 3:
        return fillSources(A.class, B.class, Aee26671.class, B33423.class);
  private static Foo[] fillSources(
      Class<? extends Foo>... fooClasses)
      throws Exception {
    Foo[] sources = new Foo[1000];
    Random rand = new Random(0);
    for (int i = 0; i < sources.length; i++) {
      int offset = Math.abs(rand.nextInt() % fooClasses.length);
      sources[i] = fooClasses[offset].newInstance();
    return sources;
}On my machine, the results are as follows:
1 class: average=0, stdev=0
2 classes: average=103, stdev=4
3 classes: average=672, stdev=26
4 classes: average=666, stdev=0.4
As I thought, the bi-morphic optimization is only applied on a class instance basis, rather than a method basis.
More information in my newsletter: [Polymorphism Performance Mysteries Explained|http://www.javaspecialists.eu/archive/Issue158.html]
Regards
Heinz