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像素的RGB成分值已预先乘以alpha值。

这两种方法都为相同的输入返回相同的值，但它们的实现是不同的。个人，我发现后一种实现更容易阅读，但我担心它可能性能较差。两个实现的字节码包含在下面，对于那些感兴趣的人（它是使用IntelliJ＆＃39; s＆＃34; Show Bytecode＆＃34; view）生成的：

  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

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

在这种情况下，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 benchmark验证所有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

Answer 2

对于Oracle VM，您可以使用-XX:+PrintAssembly检查JIT输出。

（为了让JIT启动，你的测试程序应该至少调用10 000次感兴趣的方法。）

Java的JIT编译器＆＃34;扩展＆＃34;琐碎的循环？

2 个答案: