Java的JIT编译器是否"扩展"了琐碎的循环？

Question

我正在编写我的应用程序的性能敏感部分,我很好奇JIT编译器(如果有的话)将如何优化以下方法:

private static int alphaBlend(int foreground, int background) {
    int alpha = (foreground >> 24) & 0xFF;
    int subAlpha = 0xFF - alpha;
    return ((((((foreground >> 16) & 0xFF) * alpha) + (((background >> 16) & 0xFF)) * subAlpha) >> 8) << 16)
            | ((((((foreground >> 8) & 0xFF) * alpha) + (((background >> 8) & 0xFF)) * subAlpha) >> 8) << 8)
            | ((((foreground & 0xFF) * alpha) + ((background & 0xFF)) * subAlpha) >> 8);
}

private static int alphaBlendLoop(int foreground, int background) {
    int alpha = (foreground >> 24) & 0xFF;
    int subAlpha = 0xFF - alpha;
    int blended = 0;
    for (int shift = 16; shift >= 0; shift -= 8) {
        blended |= (((((foreground >> shift) & 0xFF) * alpha) + (((background >> shift) & 0xFF)) * subAlpha) >> 8) << shift;
    }
    return blended;
}

这些方法执行alpha混合.基本上,它们将前景RGBA像素与背景RGB像素组合,其RGB分量值已预先乘以α值.

这两种方法都为相同的输入返回相同的值,但它们的实现是不同的.就个人而言,我发现后一种实现更容易阅读,但我担心它可能性能较差.对于那些感兴趣的人(它是使用IntelliJ的"Show Bytecode"视图生成),下面包含了两种实现的字节码:

  private static alphaBlend(II)I
   L0
    LINENUMBER 95 L0
    ILOAD 0
    BIPUSH 24
    ISHR
    SIPUSH 255
    IAND
    ISTORE 2
   L1
    LINENUMBER 96 L1
    SIPUSH 255
    ILOAD 2
    ISUB
    ISTORE 3
   L2
    LINENUMBER 97 L2
    ILOAD 0
    BIPUSH 16
    ISHR
    SIPUSH 255
    IAND
    ILOAD 2
    IMUL
    ILOAD 1
    BIPUSH 16
    ISHR
    SIPUSH 255
    IAND
    ILOAD 3
    IMUL
    IADD
    BIPUSH 8
    ISHR
    BIPUSH 16
    ISHL
    ILOAD 0
    BIPUSH 8
    ISHR
    SIPUSH 255
    IAND
    ILOAD 2
    IMUL
    ILOAD 1
    BIPUSH 8
    ISHR
    SIPUSH 255
    IAND
    ILOAD 3
    IMUL
    IADD
    BIPUSH 8
    ISHR
    BIPUSH 8
    ISHL
    IOR
    ILOAD 0
    SIPUSH 255
    IAND
    ILOAD 2
    IMUL
    ILOAD 1
    SIPUSH 255
    IAND
    ILOAD 3
    IMUL
    IADD
    BIPUSH 8
    ISHR
    IOR
    IRETURN
   L3
    LOCALVARIABLE foreground I L0 L3 0
    LOCALVARIABLE background I L0 L3 1
    LOCALVARIABLE alpha I L1 L3 2
    LOCALVARIABLE subAlpha I L2 L3 3
    MAXSTACK = 4
    MAXLOCALS = 4

  private static alphaBlendLoop(II)I
   L0
    LINENUMBER 103 L0
    ILOAD 0
    BIPUSH 24
    ISHR
    SIPUSH 255
    IAND
    ISTORE 2
   L1
    LINENUMBER 104 L1
    SIPUSH 255
    ILOAD 2
    ISUB
    ISTORE 3
   L2
    LINENUMBER 105 L2
    ICONST_0
    ISTORE 4
   L3
    LINENUMBER 106 L3
    BIPUSH 16
    ISTORE 5
   L4
   FRAME FULL [I I I I I I] []
    ILOAD 5
    IFLT L5
   L6
    LINENUMBER 107 L6
    ILOAD 4
    ILOAD 0
    ILOAD 5
    ISHR
    SIPUSH 255
    IAND
    ILOAD 2
    IMUL
    ILOAD 1
    ILOAD 5
    ISHR
    SIPUSH 255
    IAND
    ILOAD 3
    IMUL
    IADD
    BIPUSH 8
    ISHR
    ILOAD 5
    ISHL
    IOR
    ISTORE 4
   L7
    LINENUMBER 106 L7
    IINC 5 -8
    GOTO L4
   L5
    LINENUMBER 109 L5
   FRAME CHOP 1
    ILOAD 4
    IRETURN
   L8
    LOCALVARIABLE shift I L4 L5 5
    LOCALVARIABLE foreground I L0 L8 0
    LOCALVARIABLE background I L0 L8 1
    LOCALVARIABLE alpha I L1 L8 2
    LOCALVARIABLE subAlpha I L2 L8 3
    LOCALVARIABLE blended I L3 L8 4
    MAXSTACK = 4
    MAXLOCALS = 6

直观地说,循环需要更多的"工作"和操作(跳跃,评估条件,减少等).但是,循环也是非常可预测的; 它将始终执行三次,并且在其范围内定义的变量将始终具有相同的三个值.

在这种情况下,JIT编译器(或更智能的静态编译器？)是否能够通过将其扩展为如alphaBlend实现中所见的长单行来优化这样的简单循环？或者循环通常是不能以这种方式优化的东西？

Answer 1

是的,HotSpot JIT支持循环展开和常量传播优化,可以转换alphaBlendLoop为类似于手动展开的东西alphaBlend.

我个人更喜欢第三种选择:一个小帮助函数,使代码更具可读性:

private static int blend(int foreground, int background, int alpha, int shift) {
    int fg = (foreground >>> shift) & 0xff;
    int bg = (background >>> shift) & 0xff;
    return (fg * alpha + bg * (256 - alpha)) >>> 8 << shift;
}

public static int alphaBlend(int foreground, int background) {
    int alpha = foreground >>> 24;
    int R = blend(foreground, background, alpha, 0);
    int G = blend(foreground, background, alpha, 8);
    int B = blend(foreground, background, alpha, 16);
    return R | G | B;
}

我已经制作了一个JMH基准来验证所有3个选项的性能是否相似.
在Java 8u77 x64上测试.

Benchmark               Mode  Cnt  Score   Error  Units
Blend.alphaBlendInline  avgt   10  7,831 ± 0,045  ns/op
Blend.alphaBlendLoop    avgt   10  7,860 ± 0,025  ns/op
Blend.alphaBlendMethod  avgt   10  7,769 ± 0,056  ns/op