[PATCH] minor regex cleanup: use switch for enum

[Peter Levart]

On 04/24/2018 12:41 PM, Peter Levart wrote:
> public class Code {l
>
>     static class m$switch$1 {
>         static final int[] caseindex = new int[X.values().length];
>         static {
>             caseindex[X.A.ordinal()] = 1;
>             caseindex[X.B.ordinal()] = 2;
>             caseindex[X.C.ordinal()] = 3;
>         }
>     }
>
>     public void m(X x) {
>         switch (m$switch$1.caseindex[x.ordinal()]) {
>             case 1: // ... branch A
>                 break;
>             case 2: // ... branch B
>                 break;
>             case 3: // ... branch C
>                 break;
>             default: // ... default branch        }
>     }
> }
>
>
> Pefrormance-wise this is similar to switch on int. So pretty optimal. 
> Decision should only be made on the count of code clarity here.
>
> While speaking of performance of enum switches, I have a question for 
> a more knowledgeable person...
>
> Should JIT be able to fold above 'x' variable/parameter into a 
> constant (suppose m() was called in a loop with an explicitly 
> specified constant value such as X.A), it could further expand this 
> decision to the x.ordinal() value (if the final instance 'ordinal' 
> field in the X enum class was marked with @Stable), it could then 
> further expand this decision to the looked up value of the 
> m$switch$1.caseindex[] slot if caseindex array field in sytnhetic 
> class was marked with @Stable, therefore transforming the switch to a 
> switch on int constant, optimizing the JITed code to directly execute 
> branch A and eliminate all other branches from generated code.
>
> The question is whether JIT is presently treating those fields (and 
> array) as @Stable or not? 

It seems not. Here's a benchmark:

http://cr.openjdk.java.net/~plevart/misc/SwitchBench/SwitchBench.java


See enumConstSwitch between "Original JDK 10" and "JDK 10 + @Stable 
Enum.ordinal field".

Interesting thing is that JDK 9 seems to be better at JITing code than 
JDK 10 in these tests. Why is that?

I included results for Graal JIT compiler which shows that it probably 
does not contain support for @Stable annotation.


The relevant part for this "minor regex cleanup" patch is the following:

SwitchBench.enumConstIf      avgt   10  2.125 ± 0.002  ns/op
SwitchBench.enumConstSwitch  avgt   10  2.501 ± 0.025 ns/op
SwitchBench.enumVarIf        avgt   10  2.593 ± 0.004 ns/op
SwitchBench.enumVarSwitch    avgt   10  2.862 ± 0.053 ns/op

which indicates that "switch" is a little slower, but with @Stable 
Enum.ordinal field, it is on par with "if" at least for constant folded 
switched on values:

SwitchBench.enumConstIf      avgt   10  2.126 ± 0.007 ns/op
SwitchBench.enumConstSwitch  avgt   10  2.159 ± 0.003 ns/op
SwitchBench.enumVarIf        avgt   10  2.593 ± 0.004 ns/op
SwitchBench.enumVarSwitch    avgt   10  2.842 ± 0.006 ns/op


Regards, Peter