multiplication/bitshift 优化是否应该在 java 字节码中可见

Question

我一直在读到不需要位移位，因为编译器优化会将乘法转换为位移位。比如Should I bit-shift to divide by 2 in Java? and Is shifting bits faster than multiplying and dividing in Java? .NET?

我不是在这里询问性能差异，我可以自己测试一下。但我觉得奇怪的是，有几个人提到它将是 "compiled to the same thing"。这似乎不是真的。我写了一小段代码。

private static void multi()
{
    int a = 3;
    int b = a * 2;
    System.out.println(b);
}

private static void shift()
{
    int a = 3;
    int b = a << 1L;
    System.out.println(b);
}

结果相同，只是打印出来。

当我查看生成的 Java 字节码时，显示如下。

private static void multi();
Code:
   0: iconst_3
   1: istore_0
   2: iload_0
   3: iconst_2
   4: imul
   5: istore_1
   6: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
   9: iload_1
  10: invokevirtual #5                  // Method java/io/PrintStream.println:(I)V
  13: return

private static void shift();
Code:
   0: iconst_3
   1: istore_0
   2: iload_0
   3: iconst_1
   4: ishl
   5: istore_1
   6: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
   9: iload_1
  10: invokevirtual #5                  // Method java/io/PrintStream.println:(I)V
  13: return

现在我们可以看到"imul"和"ishl"之间的区别了。

我的问题是：显然在 java 字节码中看不到所说的优化。我仍然假设优化确实发生了，那么它只是发生在较低的水平上吗？或者，或者因为它是 Java，JVM 在遇到 imul 语句时是否以某种方式知道它应该被翻译成其他东西。如果是这样，将非常感激任何关于如何处理的资源。

（作为旁注，我并不是要证明位移位的必要性。我认为它会降低可读性，至少对于习惯 Java 的人来说，对于 C++ 来说可能会有所不同。我只是在尝试查看优化发生的位置）。

Answer 1

标题中的问题听起来与文本中的问题有点不同。引用的移位和乘法将是 "compiled to the same thing" 的陈述是正确的。但它还不适用于字节码。

通常，Java 字节码相当 un-optimized。非常几乎没有完成优化——主要是常量的内联。除此之外，Java 字节码只是原始程序的中间表示。从 Java 到 Java 字节码的转换是 "literally".

_{（我认为这是一件好事。字节码仍然非常类似于原始 Java 代码。所有 nitty-gritty（平台特定！）优化可能可能留给虚拟机，这里有更多选项。}

所有进一步的优化，如算术优化、死代码消除或方法内联，都由 JIT (Just-In-Time-Compiler) 在运行时完成。 Just-In-Time 编译器还应用了用移位替换乘法的优化。

由于多种原因，您提供的示例使显示效果有点困难。由于内联和调用此方法的一般先决条件，方法中包含 System.out.println 的事实往往会使实际机器代码变大。但更重要的是，移位 1，对应于乘以 2，也对应于将值加到自身。因此，您不会在 multi 方法的结果机器代码中观察 shl (left-shift) 汇编程序指令，您可能会在 multi- 和 shift 方法。

但是，这是一个非常实用的示例，它执行 left-shift 乘以 8，对应于与 256 的乘法：

class BitShiftOptimization
{
    public static void main(String args[])
    {
        int blackHole = 0;
        for (int i=0; i<1000000; i++)
        {
            blackHole += testMulti(i);
            blackHole += testShift(i);
        }
        System.out.println(blackHole);

    }

    public static int testMulti(int a)
    {
        int b = a * 256;
        return b;
    }

    public static int testShift(int a)
    {
        int b = a << 8L;
        return b;
    }
}

(它接收要移动的值作为参数，以防止它被优化为常量。它多次调用这些方法以触发 JIT。它 returns 并收集两种方法的值，以防止方法调用被优化掉。同样，这非常实用，但足以显示效果）

运行这在热点反汇编器 VM 中

java -server -XX:+UnlockDiagnosticVMOptions -XX:+TraceClassLoading -XX:+LogCompilation -XX:+PrintInlining -XX:+PrintAssembly BitShiftOptimization

将为 testMulti 方法生成以下汇编代码：

Decoding compiled method 0x000000000286fbd0:
Code:
[Entry Point]
[Verified Entry Point]
[Constants]
  # {method} {0x000000001c0003b0} &apos;testMulti&apos; &apos;(I)I&apos; in &apos;BitShiftOptimization&apos;
  # parm0:    rdx       = int
  #           [sp+0x40]  (sp of caller)
  0x000000000286fd20: mov    %eax,-0x6000(%rsp)
  0x000000000286fd27: push   %rbp
  0x000000000286fd28: sub    [=12=]x30,%rsp
  0x000000000286fd2c: movabs [=12=]x1c0005a8,%rax   ;   {metadata(method data for {method} {0x000000001c0003b0} &apos;testMulti&apos; &apos;(I)I&apos; in &apos;BitShiftOptimization&apos;)}
  0x000000000286fd36: mov    0xdc(%rax),%esi
  0x000000000286fd3c: add    [=12=]x8,%esi
  0x000000000286fd3f: mov    %esi,0xdc(%rax)
  0x000000000286fd45: movabs [=12=]x1c0003a8,%rax   ;   {metadata({method} {0x000000001c0003b0} &apos;testMulti&apos; &apos;(I)I&apos; in &apos;BitShiftOptimization&apos;)}
  0x000000000286fd4f: and    [=12=]x1ff8,%esi
  0x000000000286fd55: cmp    [=12=]x0,%esi
  0x000000000286fd58: je     0x000000000286fd70  ;*iload_0
                        ; - BitShiftOptimization::testMulti@0 (line 17)

  0x000000000286fd5e: shl    [=12=]x8,%edx
  0x000000000286fd61: mov    %rdx,%rax
  0x000000000286fd64: add    [=12=]x30,%rsp
  0x000000000286fd68: pop    %rbp
  0x000000000286fd69: test   %eax,-0x273fc6f(%rip)        # 0x0000000000130100
                        ;   {poll_return}
  0x000000000286fd6f: retq   
  0x000000000286fd70: mov    %rax,0x8(%rsp)
  0x000000000286fd75: movq   [=12=]xffffffffffffffff,(%rsp)
  0x000000000286fd7d: callq  0x000000000285f160  ; OopMap{off=98}
                        ;*synchronization entry
                        ; - BitShiftOptimization::testMulti@-1 (line 17)
                        ;   {runtime_call}
  0x000000000286fd82: jmp    0x000000000286fd5e
  0x000000000286fd84: nop
  0x000000000286fd85: nop
  0x000000000286fd86: mov    0x2a8(%r15),%rax
  0x000000000286fd8d: movabs [=12=]x0,%r10
  0x000000000286fd97: mov    %r10,0x2a8(%r15)
  0x000000000286fd9e: movabs [=12=]x0,%r10
  0x000000000286fda8: mov    %r10,0x2b0(%r15)
  0x000000000286fdaf: add    [=12=]x30,%rsp
  0x000000000286fdb3: pop    %rbp
  0x000000000286fdb4: jmpq   0x0000000002859420  ;   {runtime_call}
  0x000000000286fdb9: hlt    
  0x000000000286fdba: hlt    
  0x000000000286fdbb: hlt    
  0x000000000286fdbc: hlt    
  0x000000000286fdbd: hlt    
  0x000000000286fdbe: hlt

（testShift 方法的代码有 相同的 说明，顺便说一下）。

这里的相关行是

  0x000000000286fd5e: shl    [=13=]x8,%edx

相当于left-shift乘以8.

multiplication/bitshift 优化是否应该在 java 字节码中可见

Should multiplication/bitshift optimization be visible in java bytecode

java

bytecode

compilation