¿Algún compilador JIT de JVM genera código que utiliza instrucciones de punto flotante vectorizadas?

Digamos que el cuello de botella de mi programa Java son realmente algunos bucles ajustados para calcular un montón de productos punto vectoriales. Sí, he perfilado, sí, es el cuello de botella, sí, es significativo, sí, así es como es el algoritmo, sí, he ejecutado Proguard para optimizar el código de bytes, etc.

El trabajo es, esencialmente, productos punto. Como en, tengo dos float[50]y necesito calcular la suma de productos por pares. Sé que existen conjuntos de instrucciones de procesador para realizar este tipo de operaciones de forma rápida y masiva, como SSE o MMX.

Sí, probablemente pueda acceder a estos escribiendo código nativo en JNI. La llamada JNI resulta bastante cara.

Sé que no puede garantizar lo que compilará o no compilará un JIT. ¿Alguien ha oído hablar de un código de generación JIT que utilice estas instrucciones? y si es así, ¿hay algo en el código Java que ayude a que sea compilable de esta manera?

Probablemente un "no"; vale la pena preguntar.

Entonces, básicamente, desea que su código se ejecute más rápido. JNI es la respuesta. Sé que dijiste que no te funcionó, pero déjame mostrarte que estás equivocado.

Aquí 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");
    }
}

y 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 y ejecutar eso con JavaCPP usando este comando:

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

Con una CPU Intel (R) Core (TM) i7-7700HQ a 2.80GHz, Fedora 30, GCC 9.1.1 y OpenJDK 8 u 11, obtengo este tipo de salida:

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

O aproximadamente 2,4 veces más rápido. Necesitamos utilizar búferes NIO directos en lugar de matrices, pero HotSpot puede acceder a búferes NIO directos tan rápido como matrices . Por otro lado, desenrollar manualmente el lazo no proporciona un aumento mensurable en el rendimiento, en este caso.

Para abordar parte del escepticismo expresado por otros aquí, sugiero que cualquiera que quiera probarse a sí mismo oa otros use el siguiente método:

• Crea un proyecto JMH
• Escribe un pequeño fragmento de matemáticas vectorizables.
• Ejecute su punto de referencia cambiando entre -XX: -UseSuperWord y -XX: + UseSuperWord (predeterminado)
• Si no se observa ninguna diferencia en el rendimiento, es probable que su código no se haya vectorizado
• Para asegurarse, ejecute su punto de referencia de manera que imprima el ensamblaje. En Linux, puede disfrutar del perfasm profiler ('- prof perfasm'). Eche un vistazo y vea si se generan las instrucciones que espera.

Ejemplo:

@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
}

El resultado con y sin el indicador (en la computadora portátil Haswell reciente, Oracle JDK 8u60): -XX: + UseSuperWord: 475.073 ± 44.579 ns / op (nanosegundos por operación) -XX: -UseSuperWord: 3376.364 ± 233.211 ns / op

El ensamblaje para el bucle activo es un poco difícil de formatear y pegar aquí, pero aquí hay un fragmento (hsdis.so no puede formatear algunas de las instrucciones vectoriales AVX2, así que ejecuté con -XX: UseAVX = 1): -XX: + UseSuperWord (con '-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

¡Diviértete atacando el castillo?

En las versiones de HotSpot que comienzan con Java 7u40, el compilador del servidor brinda soporte para la vectorización automática. Según JDK-6340864

Sin embargo, esto parece ser cierto solo para los "bucles simples", al menos por el momento. Por ejemplo, la acumulación de una matriz aún no se puede vectorizar JDK-7192383

Aquí hay un buen artículo sobre cómo experimentar con Java y las instrucciones SIMD escritas por mi amigo: http://prestodb.rocks/code/simd/

Su resultado general es que puede esperar que JIT use algunas operaciones SSE en 1.8 (y algunas más en 1.9). Aunque no debes esperar mucho y debes tener cuidado.

Puede escribir el kernel OpenCl para hacer la computación y ejecutarlo desde java http://www.jocl.org/ .

El código se puede ejecutar en CPU y / o GPU y el lenguaje OpenCL también admite tipos de vector, por lo que debería poder aprovechar explícitamente, por ejemplo, las instrucciones SSE3 / 4.

Eche un vistazo a la comparación de rendimiento entre Java y JNI para una implementación óptima de micro-kernels computacionales . Muestran que el compilador del servidor Java HotSpot VM admite la vectorización automática mediante el paralelismo de nivel de superpalabra, que se limita a casos simples de paralelismo dentro del ciclo. Este artículo también le dará una guía sobre si el tamaño de sus datos es lo suficientemente grande como para justificar la ruta JNI.

Supongo que escribió esta pregunta antes de descubrir netlib-java ;-) proporciona exactamente la API nativa que necesita, con implementaciones optimizadas para la máquina, y no tiene ningún costo en el límite nativo debido a la fijación de memoria.

No creo que la mayoría de las máquinas virtuales sean lo suficientemente inteligentes para este tipo de optimizaciones. Para ser justos, la mayoría de las optimizaciones son mucho más simples, como cambiar en lugar de multiplicar cuando se trata de una potencia de dos. El proyecto mono introdujo su propio vector y otros métodos con respaldo nativo para ayudar al rendimiento.