Algum compilador JIT da JVM gera código que usa instruções de ponto flutuante vetorizadas?

Digamos que o gargalo do meu programa Java realmente sejam alguns loops apertados para calcular um monte de produtos de ponto vetorial. Sim, fiz o perfil, sim, é o gargalo, sim é significativo, sim é assim que o algoritmo é, sim, executei o Proguard para otimizar o código de bytes, etc.

O trabalho é, essencialmente, produtos escalares. Como em, tenho dois float[50]e preciso calcular a soma dos produtos em pares. Eu sei que os conjuntos de instruções do processador existem para realizar esse tipo de operação rapidamente e em massa, como SSE ou MMX.

Sim, provavelmente posso acessá-los escrevendo algum código nativo em JNI. A ligação do JNI acabou sendo muito cara.

Eu sei que você não pode garantir o que um JIT irá compilar ou não. Alguém já ouviu falar de um código de geração de JIT que usa essas instruções? Em caso afirmativo, há algo sobre o código Java que ajuda a torná-lo compilável dessa maneira?

Provavelmente um "não"; vale a pena perguntar.

Então, basicamente, você deseja que seu código seja executado mais rapidamente. JNI é a resposta. Eu sei que você disse que não funcionou para você, mas deixe-me mostrar que você está errado.

Aqui está Dot.java:

import java.nio.FloatBuffer;
import org.bytedeco.javacpp.*;
import org.bytedeco.javacpp.annotation.*;

@Platform(include = "Dot.h", compiler = "fastfpu")
public class Dot {
    static { Loader.load(); }

    static float[] a = new float[50], b = new float[50];
    static float dot() {
        float sum = 0;
        for (int i = 0; i < 50; i++) {
            sum += a[i]*b[i];
        }
        return sum;
    }
    static native @MemberGetter FloatPointer ac();
    static native @MemberGetter FloatPointer bc();
    static native @NoException float dotc();

    public static void main(String[] args) {
        FloatBuffer ab = ac().capacity(50).asBuffer();
        FloatBuffer bb = bc().capacity(50).asBuffer();

        for (int i = 0; i < 10000000; i++) {
            a[i%50] = b[i%50] = dot();
            float sum = dotc();
            ab.put(i%50, sum);
            bb.put(i%50, sum);
        }
        long t1 = System.nanoTime();
        for (int i = 0; i < 10000000; i++) {
            a[i%50] = b[i%50] = dot();
        }
        long t2 = System.nanoTime();
        for (int i = 0; i < 10000000; i++) {
            float sum = dotc();
            ab.put(i%50, sum);
            bb.put(i%50, sum);
        }
        long t3 = System.nanoTime();
        System.out.println("dot(): " + (t2 - t1)/10000000 + " ns");
        System.out.println("dotc(): "  + (t3 - t2)/10000000 + " ns");
    }
}

e Dot.h:

float ac[50], bc[50];

inline float dotc() {
    float sum = 0;
    for (int i = 0; i < 50; i++) {
        sum += ac[i]*bc[i];
    }
    return sum;
}

Podemos compilar e executar isso com JavaCPP usando este comando:

$ java -jar javacpp.jar Dot.java -exec

Com uma CPU Intel (R) Core (TM) i7-7700HQ a 2,80 GHz, Fedora 30, GCC 9.1.1 e OpenJDK 8 ou 11, recebo este tipo de resultado:

dot(): 39 ns
dotc(): 16 ns

Ou cerca de 2,4 vezes mais rápido. Precisamos usar buffers NIO diretos em vez de arrays, mas o HotSpot pode acessar os buffers NIO diretos tão rápido quanto os arrays . Por outro lado, desenrolar manualmente o loop não fornece um aumento mensurável no desempenho, neste caso.

Para abordar parte do ceticismo expresso por outros aqui, sugiro que qualquer pessoa que queira provar a si mesma ou outra pessoa use o seguinte método:

• Crie um projeto JMH
• Escreva um pequeno trecho de matemática vetorizável.
• Execute seu benchmark alternando entre -XX: -UseSuperWord e -XX: + UseSuperWord (padrão)
• Se nenhuma diferença no desempenho for observada, seu código provavelmente não foi vetorizado
• Para ter certeza, execute seu benchmark de forma que ele imprima o conjunto. No linux você pode aproveitar o perfasm profiler ('- prof perfasm'), dar uma olhada e ver se as instruções que você espera são geradas.

Exemplo:

@Benchmark
@CompilerControl(CompilerControl.Mode.DONT_INLINE) //makes looking at assembly easier
public void inc() {
    for (int i=0;i<a.length;i++)
        a[i]++;// a is an int[], I benchmarked with size 32K
}

O resultado com e sem o sinalizador (no laptop Haswell recente, Oracle JDK 8u60): -XX: + UseSuperWord: 475,073 ± 44,579 ns / op (nanossegundos por op) -XX: -UseSuperWord: 3376,364 ± 233,211 ns / op

A montagem do hot loop é um pouco demais para formatar e colar aqui, mas aqui está um trecho (hsdis.so não está formatando algumas das instruções do vetor AVX2, então executei com -XX: UseAVX = 1): -XX: + UseSuperWord (com '-prof perfasm: intelSyntax = true')

  9.15%   10.90%  │││ │↗    0x00007fc09d1ece60: vmovdqu xmm1,XMMWORD PTR [r10+r9*4+0x18]
 10.63%    9.78%  │││ ││    0x00007fc09d1ece67: vpaddd xmm1,xmm1,xmm0
 12.47%   12.67%  │││ ││    0x00007fc09d1ece6b: movsxd r11,r9d
  8.54%    7.82%  │││ ││    0x00007fc09d1ece6e: vmovdqu xmm2,XMMWORD PTR [r10+r11*4+0x28]
                  │││ ││                                                  ;*iaload
                  │││ ││                                                  ; - psy.lob.saw.VectorMath::inc@17 (line 45)
 10.68%   10.36%  │││ ││    0x00007fc09d1ece75: vmovdqu XMMWORD PTR [r10+r9*4+0x18],xmm1
 10.65%   10.44%  │││ ││    0x00007fc09d1ece7c: vpaddd xmm1,xmm2,xmm0
 10.11%   11.94%  │││ ││    0x00007fc09d1ece80: vmovdqu XMMWORD PTR [r10+r11*4+0x28],xmm1
                  │││ ││                                                  ;*iastore
                  │││ ││                                                  ; - psy.lob.saw.VectorMath::inc@20 (line 45)
 11.19%   12.65%  │││ ││    0x00007fc09d1ece87: add    r9d,0x8            ;*iinc
                  │││ ││                                                  ; - psy.lob.saw.VectorMath::inc@21 (line 44)
  8.38%    9.50%  │││ ││    0x00007fc09d1ece8b: cmp    r9d,ecx
                  │││ │╰    0x00007fc09d1ece8e: jl     0x00007fc09d1ece60  ;*if_icmpge

Divirta-se atacando o castelo!

Nas versões HotSpot começando com Java 7u40, o compilador de servidor fornece suporte para autovetorização. De acordo com JDK-6340864

No entanto, isso parece ser verdade apenas para "loops simples" - pelo menos por enquanto. Por exemplo, a acumulação de uma matriz ainda não pode ser vetorizada JDK-7192383

Aqui está um bom artigo sobre como experimentar as instruções Java e SIMD escritas por meu amigo: http://prestodb.rocks/code/simd/

O resultado geral é que você pode esperar que o JIT use algumas operações SSE no 1.8 (e algumas mais no 1.9). Embora você não deva esperar muito e precise ter cuidado.

Você pode escrever o kernel OpenCl para fazer a computação e executá-lo a partir de java http://www.jocl.org/ .

O código pode ser executado na CPU e / ou GPU e a linguagem OpenCL também suporta tipos de vetor, portanto, você deve ser capaz de tirar vantagem explicitamente, por exemplo, das instruções SSE3 / 4.

Dê uma olhada na comparação de desempenho entre Java e JNI para uma implementação ideal de micro-kernels computacionais . Eles mostram que o compilador do servidor Java HotSpot VM suporta a autovetorização usando o paralelismo de nível de superpalavra, que é limitado a casos simples de paralelismo dentro do loop. Este artigo também lhe dará alguma orientação se o tamanho dos dados é grande o suficiente para justificar a rota JNI.

Suponho que você escreveu esta pergunta antes de descobrir sobre o netlib-java ;-) ele fornece exatamente a API nativa que você precisa, com implementações otimizadas para máquina, e não tem nenhum custo no limite nativo devido à fixação de memória.

Eu não acredito que a maioria das VMs sejam inteligentes o suficiente para esse tipo de otimizações. Para ser justo, a maioria das otimizações é muito mais simples, como mudar em vez de multiplicação quando é uma potência de dois. O projeto mono introduziu seu próprio vetor e outros métodos com apoios nativos para ajudar no desempenho.