Por que long é mais lento do que int em x64 Java?

Estou executando o Windows 8.1 x64 com Java 7 atualização 45 x64 (sem Java de 32 bits instalado) em um tablet Surface Pro 2.

O código a seguir leva 1688ms quando o tipo de i é longo e 109ms quando i é um int. Por que long (um tipo de 64 bits) é uma ordem de magnitude mais lento do que int em uma plataforma de 64 bits com uma JVM de 64 bits?

Minha única especulação é que a CPU demora mais para adicionar um inteiro de 64 bits do que um de 32 bits, mas isso parece improvável. Suspeito que Haswell não usa somadores de propagação de ondulação.

Estou executando isso no Eclipse Kepler SR1, btw.

public class Main {

    private static long i = Integer.MAX_VALUE;

    public static void main(String[] args) {    
        System.out.println("Starting the loop");
        long startTime = System.currentTimeMillis();
        while(!decrementAndCheck()){
        }
        long endTime = System.currentTimeMillis();
        System.out.println("Finished the loop in " + (endTime - startTime) + "ms");
    }

    private static boolean decrementAndCheck() {
        return --i < 0;
    }

}

Editar: Aqui estão os resultados do código C ++ equivalente compilado pelo VS 2013 (abaixo), mesmo sistema. long: 72265ms int: 74656ms Esses resultados estavam no modo de depuração de 32 bits.

No modo de liberação de 64 bits: long: 875ms long long: 906ms int: 1047ms

Isso sugere que o resultado que observei é a estranheza da otimização da JVM, e não as limitações da CPU.

#include "stdafx.h"
#include "iostream"
#include "windows.h"
#include "limits.h"

long long i = INT_MAX;

using namespace std;


boolean decrementAndCheck() {
return --i < 0;
}


int _tmain(int argc, _TCHAR* argv[])
{


cout << "Starting the loop" << endl;

unsigned long startTime = GetTickCount64();
while (!decrementAndCheck()){
}
unsigned long endTime = GetTickCount64();

cout << "Finished the loop in " << (endTime - startTime) << "ms" << endl;



}

Edit: Apenas tentei isso novamente em Java 8 RTM, nenhuma mudança significativa.

Minha JVM faz uma coisa bem direta com o loop interno quando você usa longs:

0x00007fdd859dbb80: test   %eax,0x5f7847a(%rip)  /* fun JVM hack */
0x00007fdd859dbb86: dec    %r11                  /* i-- */
0x00007fdd859dbb89: mov    %r11,0x258(%r10)      /* store i to memory */
0x00007fdd859dbb90: test   %r11,%r11             /* unnecessary test */
0x00007fdd859dbb93: jge    0x00007fdd859dbb80    /* go back to the loop top */

É cheats, difícil, quando você usa ints; primeiro, há algumas coisas complicadas que eu não pretendo entender, mas parece uma configuração para um loop desenrolado:

0x00007f3dc290b5a1: mov    %r11d,%r9d
0x00007f3dc290b5a4: dec    %r9d
0x00007f3dc290b5a7: mov    %r9d,0x258(%r10)
0x00007f3dc290b5ae: test   %r9d,%r9d
0x00007f3dc290b5b1: jl     0x00007f3dc290b662
0x00007f3dc290b5b7: add    $0xfffffffffffffffe,%r11d
0x00007f3dc290b5bb: mov    %r9d,%ecx
0x00007f3dc290b5be: dec    %ecx              
0x00007f3dc290b5c0: mov    %ecx,0x258(%r10)   
0x00007f3dc290b5c7: cmp    %r11d,%ecx
0x00007f3dc290b5ca: jle    0x00007f3dc290b5d1
0x00007f3dc290b5cc: mov    %ecx,%r9d
0x00007f3dc290b5cf: jmp    0x00007f3dc290b5bb
0x00007f3dc290b5d1: and    $0xfffffffffffffffe,%r9d
0x00007f3dc290b5d5: mov    %r9d,%r8d
0x00007f3dc290b5d8: neg    %r8d
0x00007f3dc290b5db: sar    $0x1f,%r8d
0x00007f3dc290b5df: shr    $0x1f,%r8d
0x00007f3dc290b5e3: sub    %r9d,%r8d
0x00007f3dc290b5e6: sar    %r8d
0x00007f3dc290b5e9: neg    %r8d
0x00007f3dc290b5ec: and    $0xfffffffffffffffe,%r8d
0x00007f3dc290b5f0: shl    %r8d
0x00007f3dc290b5f3: mov    %r8d,%r11d
0x00007f3dc290b5f6: neg    %r11d
0x00007f3dc290b5f9: sar    $0x1f,%r11d
0x00007f3dc290b5fd: shr    $0x1e,%r11d
0x00007f3dc290b601: sub    %r8d,%r11d
0x00007f3dc290b604: sar    $0x2,%r11d
0x00007f3dc290b608: neg    %r11d
0x00007f3dc290b60b: and    $0xfffffffffffffffe,%r11d
0x00007f3dc290b60f: shl    $0x2,%r11d
0x00007f3dc290b613: mov    %r11d,%r9d
0x00007f3dc290b616: neg    %r9d
0x00007f3dc290b619: sar    $0x1f,%r9d
0x00007f3dc290b61d: shr    $0x1d,%r9d
0x00007f3dc290b621: sub    %r11d,%r9d
0x00007f3dc290b624: sar    $0x3,%r9d
0x00007f3dc290b628: neg    %r9d
0x00007f3dc290b62b: and    $0xfffffffffffffffe,%r9d
0x00007f3dc290b62f: shl    $0x3,%r9d
0x00007f3dc290b633: mov    %ecx,%r11d
0x00007f3dc290b636: sub    %r9d,%r11d
0x00007f3dc290b639: cmp    %r11d,%ecx
0x00007f3dc290b63c: jle    0x00007f3dc290b64f
0x00007f3dc290b63e: xchg   %ax,%ax /* OK, fine; I know what a nop looks like */

então o próprio loop desenrolado:

0x00007f3dc290b640: add    $0xfffffffffffffff0,%ecx
0x00007f3dc290b643: mov    %ecx,0x258(%r10)
0x00007f3dc290b64a: cmp    %r11d,%ecx
0x00007f3dc290b64d: jg     0x00007f3dc290b640

em seguida, o código de desmontagem para o loop desenrolado, ele próprio um teste e um loop direto:

0x00007f3dc290b64f: cmp    $0xffffffffffffffff,%ecx
0x00007f3dc290b652: jle    0x00007f3dc290b662
0x00007f3dc290b654: dec    %ecx
0x00007f3dc290b656: mov    %ecx,0x258(%r10)
0x00007f3dc290b65d: cmp    $0xffffffffffffffff,%ecx
0x00007f3dc290b660: jg     0x00007f3dc290b654

Portanto, ele é 16 vezes mais rápido para o ints porque o JIT desenrolou o intloop 16 vezes, mas não o desenrolou de forma longalguma.

Para completar, aqui está o código que realmente tentei:

public class foo136 {
  private static int i = Integer.MAX_VALUE;
  public static void main(String[] args) {
    System.out.println("Starting the loop");
    for (int foo = 0; foo < 100; foo++)
      doit();
  }

  static void doit() {
    i = Integer.MAX_VALUE;
    long startTime = System.currentTimeMillis();
    while(!decrementAndCheck()){
    }
    long endTime = System.currentTimeMillis();
    System.out.println("Finished the loop in " + (endTime - startTime) + "ms");
  }

  private static boolean decrementAndCheck() {
    return --i < 0;
  }
}

Os dumps de montagem foram gerados usando as opções -XX:+UnlockDiagnosticVMOptions -XX:+PrintAssembly. Observe que você precisa mexer na instalação da JVM para que isso funcione para você também; você precisa colocar alguma biblioteca compartilhada aleatória exatamente no lugar certo ou ela irá falhar.

A pilha JVM é definida em termos de palavras , cujo tamanho é um detalhe de implementação, mas deve ter pelo menos 32 bits de largura. O implementador de JVM pode usar palavras de 64 bits, mas o bytecode não pode contar com isso e, portanto, as operações com valores longou doubledevem ser tratadas com cuidado extra. Em particular, as instruções de ramificação de inteiro da JVM são definidas exatamente no tipo int.

No caso do seu código, a desmontagem é instrutiva. Este é o bytecode para a intversão compilada pelo Oracle JDK 7:

private static boolean decrementAndCheck();
  Code:
     0: getstatic     #14  // Field i:I
     3: iconst_1      
     4: isub          
     5: dup           
     6: putstatic     #14  // Field i:I
     9: ifge          16
    12: iconst_1      
    13: goto          17
    16: iconst_0      
    17: ireturn       

Observe que a JVM carregará o valor do seu estático i(0), subtrairá um (3-4), duplicará o valor na pilha (5) e o empurrará de volta para a variável (6). Em seguida, ele faz uma comparação com zero e retorna.

A versão com longé um pouco mais complicada:

private static boolean decrementAndCheck();
  Code:
     0: getstatic     #14  // Field i:J
     3: lconst_1      
     4: lsub          
     5: dup2          
     6: putstatic     #14  // Field i:J
     9: lconst_0      
    10: lcmp          
    11: ifge          18
    14: iconst_1      
    15: goto          19
    18: iconst_0      
    19: ireturn       

Primeiro, quando a JVM duplica o novo valor na pilha (5), ela precisa duplicar duas palavras da pilha. No seu caso, é bem possível que isso não seja mais caro do que duplicar um, já que o JVM é livre para usar uma palavra de 64 bits se for conveniente. No entanto, você notará que a lógica do branch é mais longa aqui. A JVM não tem uma instrução para comparar a longcom zero, então ela precisa colocar uma constante 0Lna pilha (9), fazer uma longcomparação geral (10) e então desviar para o valor desse cálculo.

Aqui estão dois cenários plausíveis:

• A JVM está seguindo exatamente o caminho do bytecode. Nesse caso, ele está fazendo mais trabalho na longversão, empurrando e removendo vários valores extras, e estes estão na pilha gerenciada virtual , não na pilha real de CPU assistida por hardware. Se for esse o caso, você ainda verá uma diferença significativa de desempenho após o aquecimento.
• A JVM percebe que pode otimizar esse código. Nesse caso, está levando um tempo extra para otimizar algumas das lógicas push / compare praticamente desnecessárias. Se for esse o caso, você verá muito pouca diferença de desempenho após o aquecimento.

Eu recomendo que você escreva um microbenchmark correto para eliminar o efeito de ter o JIT ativado, e também tentar isso com uma condição final que não seja zero, para forçar o JVM a fazer a mesma comparação no intque faz com o long.

A unidade básica de dados em uma Java Virtual Machine é a palavra. A escolha do tamanho correto da palavra é deixada após a implementação da JVM. Uma implementação JVM deve escolher um tamanho mínimo de palavra de 32 bits. Ele pode escolher um tamanho de palavra maior para ganhar eficiência. Também não há nenhuma restrição de que uma JVM de 64 bits deve escolher apenas palavras de 64 bits.

A arquitetura subjacente não determina que o tamanho da palavra também seja o mesmo. JVM lê / grava dados palavra por palavra. Esta é a razão por que ele pode ser levando mais tempo para uma longa do que um int .

Aqui você pode encontrar mais informações sobre o mesmo assunto.

Acabei de escrever um benchmark usando compasso de calibre .

Os resultados são bastante consistentes com o código original: uma aceleração de ~ 12x para usar intover long. Certamente parece que o desenrolamento de loop relatado por tmyklebu ou algo muito semelhante está acontecendo.

timeIntDecrements         195,266,845.000
timeLongDecrements      2,321,447,978.000

Este é o meu código; observe que ele usa um instantâneo recém-criado de caliper, já que não consegui descobrir como codificar em relação à versão beta existente.

package test;

import com.google.caliper.Benchmark;
import com.google.caliper.Param;

public final class App {

    @Param({""+1}) int number;

    private static class IntTest {
        public static int v;
        public static void reset() {
            v = Integer.MAX_VALUE;
        }
        public static boolean decrementAndCheck() {
            return --v < 0;
        }
    }

    private static class LongTest {
        public static long v;
        public static void reset() {
            v = Integer.MAX_VALUE;
        }
        public static boolean decrementAndCheck() {
            return --v < 0;
        }
    }

    @Benchmark
    int timeLongDecrements(int reps) {
        int k=0;
        for (int i=0; i<reps; i++) {
            LongTest.reset();
            while (!LongTest.decrementAndCheck()) { k++; }
        }
        return (int)LongTest.v | k;
    }    

    @Benchmark
    int timeIntDecrements(int reps) {
        int k=0;
        for (int i=0; i<reps; i++) {
            IntTest.reset();
            while (!IntTest.decrementAndCheck()) { k++; }
        }
        return IntTest.v | k;
    }
}

Para que conste, esta versão faz um "aquecimento" bruto:

public class LongSpeed {

    private static long i = Integer.MAX_VALUE;
    private static int j = Integer.MAX_VALUE;

    public static void main(String[] args) {

        for (int x = 0; x < 10; x++) {
            runLong();
            runWord();
        }
    }

    private static void runLong() {
        System.out.println("Starting the long loop");
        i = Integer.MAX_VALUE;
        long startTime = System.currentTimeMillis();
        while(!decrementAndCheckI()){

        }
        long endTime = System.currentTimeMillis();

        System.out.println("Finished the long loop in " + (endTime - startTime) + "ms");
    }

    private static void runWord() {
        System.out.println("Starting the word loop");
        j = Integer.MAX_VALUE;
        long startTime = System.currentTimeMillis();
        while(!decrementAndCheckJ()){

        }
        long endTime = System.currentTimeMillis();

        System.out.println("Finished the word loop in " + (endTime - startTime) + "ms");
    }

    private static boolean decrementAndCheckI() {
        return --i < 0;
    }

    private static boolean decrementAndCheckJ() {
        return --j < 0;
    }

}

Os tempos gerais melhoram cerca de 30%, mas a proporção entre os dois permanece praticamente a mesma.

Para os registros:

se eu usar

boolean decrementAndCheckLong() {
    lo = lo - 1l;
    return lo < -1l;
}

(alterado "l--" para "l = l - 1l") o desempenho longo melhora em ~ 50%

Não tenho uma máquina de 64 bits para testar, mas a diferença bastante grande sugere que há mais do que o bytecode um pouco mais longo em ação.

Vejo tempos muito próximos para long / int (4400 vs 4800ms) no meu 1.7.0_45 de 32 bits.

Isso é apenas uma suposição , mas suspeito fortemente que seja o efeito de uma penalidade de desalinhamento de memória. Para confirmar / negar a suspeita, tente adicionar um public static int dummy = 0; antes da declaração de i. Isso empurra i para baixo em 4 bytes no layout de memória e pode torná-lo devidamente alinhado para melhor desempenho. Confirmado que não está causando o problema.

EDITAR: O raciocínio por trás disso é que o VM não pode reordenar os campos em seu lazer adicionando preenchimento para alinhamento ideal, uma vez que isso pode interferir com JNI (Não é o caso).