ComputedConstant condenser

[Remi Forax]

Hi Per, hi all,
When coming back from the JVM Languages Summit, I've written a bytecode rewriter [1] (using ASM) that removes the private static final ConputedConstant inside the static block (<clinit>) and uses invokedynamic + constant dynamic when the methods ComputedConstant.get()/orElse()/orElseThrow() are called to initialize the value of the computed constant (once). If the static final ComputedConstant is needed for other methods or thing like an acmp, a shim is produced on the spot. I believe it's a valid semantics given that a ComputedConstant is a value based class.

I've used the idea of John to group all the initializations inside a static method ($staticInit$) that takes the name of the constant and call the corresponging desugared lambda body (bypassing the lambda creation). The metafactory for the invokedynamic and constant dynamic is here [2].

For example for the code,

public class Main {
  private static final ComputedConstant<String> TEXT =
      ComputedConstant.of(() -> "Hello");

  public static String message() {
    return TEXT.get();
  }

  static class Nested {
    public static String message2() {
      return TEXT.get();
    }
  }

  public static void main(String[] args) {
    System.out.println(message());
    System.out.println(TEXT.isBound());   // this one need a shim ComputedConstant
    System.out.println(Nested.message2());
  }
}


The bytecode rewriter produces the following bytecode (you can notice that the <clinit> is empty !)

Compiled from "Main.java"
public class com.github.forax.concurrent.constant.Main {
  public com.github.forax.concurrent.constant.Main();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static java.lang.String message();
    Code:
       0: invokedynamic #114,  0            // InvokeDynamic #2:get:()Ljava/lang/Object;
       5: checkcast     #19                 // class java/lang/String
       8: areturn

  public static void main(java.lang.String[]);
    Code:
       0: getstatic     #21                 // Field java/lang/System.out:Ljava/io/PrintStream;
       3: invokestatic  #27                 // Method message:()Ljava/lang/String;
       6: invokevirtual #31                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       9: getstatic     #21                 // Field java/lang/System.out:Ljava/io/PrintStream;
      12: invokestatic  #118                // Method java/lang/invoke/MethodHandles.lookup:()Ljava/lang/invoke/MethodHandles$Lookup;
      15: ldc           #8                  // class com/github/forax/concurrent/constant/Main
      17: ldc           #119                // String TEXT
      19: invokestatic  #123                // Method com/github/forax/concurrent/constant/ComputedConstantMetafactory.ofShim:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/Class;Ljava/lang/String;)Lcom/github/forax/concurrent/constant/ComputedConstant;
      22: invokeinterface #37,  1           // InterfaceMethod com/github/forax/concurrent/constant/ComputedConstant.isBound:()Z
      27: invokevirtual #41                 // Method java/io/PrintStream.println:(Z)V
      30: getstatic     #21                 // Field java/lang/System.out:Ljava/io/PrintStream;
      33: invokestatic  #44                 // Method com/github/forax/concurrent/constant/Main$Nested.message2:()Ljava/lang/String;
      36: invokevirtual #31                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      39: return

  private static java.lang.String lambda$static$0();
    Code:
       0: ldc           #49                 // String Hello
       2: areturn

  static {};
    Code:
       0: return

  public static java.lang.Object $staticInit$(java.lang.String);
    Code:
       0: aload_0
       1: invokevirtual #127                // Method java/lang/String.hashCode:()I
       4: lookupswitch  { // 1
               2571565: 24
               default: 40
          }
      24: aload_0
      25: ldc           #119                // String TEXT
      27: invokevirtual #131                // Method java/lang/String.equals:(Ljava/lang/Object;)Z
      30: ifeq          37
      33: invokestatic  #77                 // Method lambda$static$0:()Ljava/lang/String;
      36: areturn
      37: goto          40
      40: new           #133                // class java/lang/AssertionError
      43: dup
      44: aload_0
      45: invokespecial #136                // Method java/lang/AssertionError."<init>":(Ljava/lang/Object;)V
      48: athrow
}

I still think that using a keyword is better than using an API. It's too easy to forget "final" or "private" when declaring a static computed constant or to think that a computed constant is a real object always available at runtime.

The API of ComputedConstant also shows too much. All the methods is* should not be part of the public API so a condenser has more freedom in term of implementation and the user has less chance to see that a computed constant is perhaps not equals to itself (at least until the first part of Valhalla lands).

The rewriter is pretty basic, it's one pass on the bytecode (no computed constant propagation) so for example storing a computed constant in a local variable inside the <clinit> is enough to avoid the computed consatnt to be optimized.
I'm also pretty sure that this condenser may not work if a private static final computed constant is access by a nestmate class, but I have not taken a look yet.

regards,
Rémi


[1] https://github.com/forax/computed-constant/blob/master/constant/src/main/java/com/github/forax/concurrent/constant/condenser/ComputedConstantRewriter.java
[2] https://github.com/forax/computed-constant/blob/master/constant/src/main/java/com/github/forax/concurrent/constant/ComputedConstantMetafactory.java