Generieren die JIT-Compiler einer JVM Code, der vektorisierte Gleitkommaanweisungen verwendet?

Angenommen, der Engpass meines Java-Programms besteht in einigen engen Schleifen, um eine Reihe von Vektorpunktprodukten zu berechnen. Ja, ich habe ein Profil erstellt, ja, es ist der Engpass, ja, es ist signifikant, ja, so ist der Algorithmus, ja, ich habe Proguard ausgeführt, um den Bytecode zu optimieren usw.

Die Arbeit besteht im Wesentlichen aus Punktprodukten. Wie in habe ich zwei float[50]und ich muss die Summe der paarweisen Produkte berechnen. Ich weiß, dass Prozessorbefehlssätze existieren, um diese Art von Operationen schnell und in großen Mengen auszuführen, wie z. B. SSE oder MMX.

Ja, ich kann wahrscheinlich darauf zugreifen, indem ich nativen Code in JNI schreibe. Der JNI-Anruf erweist sich als ziemlich teuer.

Ich weiß, dass Sie nicht garantieren können, was eine JIT kompiliert oder nicht kompiliert. Hat jemand jemals von einem JIT-Generierungscode gehört, der diese Anweisungen verwendet? Und wenn ja, gibt es irgendetwas an dem Java-Code, das dazu beiträgt, ihn auf diese Weise kompilierbar zu machen?

Wahrscheinlich ein "Nein"; es lohnt sich zu fragen.

Grundsätzlich möchten Sie, dass Ihr Code schneller ausgeführt wird. JNI ist die Antwort. Ich weiß, dass du gesagt hast, dass es bei dir nicht funktioniert hat, aber ich möchte dir zeigen, dass du falsch liegst.

Hier ist 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");
    }
}

und 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;
}

Mit diesem Befehl können wir das mit JavaCPP kompilieren und ausführen :

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

Mit einer Intel (R) Core (TM) i7-7700HQ-CPU bei 2,80 GHz, Fedora 30, GCC 9.1.1 und OpenJDK 8 oder 11 erhalte ich diese Art von Ausgabe:

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

Oder ungefähr 2,4 mal schneller. Wir müssen direkte NIO-Puffer anstelle von Arrays verwenden, aber HotSpot kann genauso schnell wie Arrays auf direkte NIO-Puffer zugreifen . Andererseits führt das manuelle Abrollen der Schleife in diesem Fall nicht zu einer messbaren Leistungssteigerung.

Um einige der hier von anderen geäußerten Skepsis anzusprechen, schlage ich jedem vor, der sich selbst oder anderen beweisen möchte, die folgende Methode anzuwenden:

• Erstellen Sie ein JMH-Projekt
• Schreiben Sie einen kleinen Ausschnitt aus vektorisierbarer Mathematik.
• Führen Sie den Benchmark-Wechsel zwischen -XX: -UseSuperWord und -XX: + UseSuperWord aus (Standard).
• Wenn kein Leistungsunterschied festgestellt wird, wurde Ihr Code wahrscheinlich nicht vektorisiert
• Führen Sie Ihren Benchmark so aus, dass die Baugruppe ausgedruckt wird. Unter Linux können Sie den Perfasm-Profiler ('- prof perfasm') genießen. Schauen Sie nach, ob die erwarteten Anweisungen generiert werden.

Beispiel:

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

Das Ergebnis mit und ohne Flag (auf dem aktuellen Haswell-Laptop Oracle JDK 8u60): -XX: + UseSuperWord: 475,073 ± 44,579 ns / op (Nanosekunden pro op) -XX: -UseSuperWord: 3376,364 ± 233,211 ns / op

Die Assembly für die Hot-Loop ist ein bisschen viel zu formatieren und hier zu bleiben, aber hier ist ein Ausschnitt (hsdis.so kann einige der AVX2-Vektoranweisungen nicht formatieren, daher habe ich -XX: UseAVX = 1 ausgeführt): -XX: + UseSuperWord (mit '-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

Viel Spaß beim Stürmen der Burg!

In HotSpot-Versionen, die mit Java 7u40 beginnen, bietet der Server-Compiler Unterstützung für die automatische Vektorisierung. Laut JDK-6340864

Dies scheint jedoch nur für "einfache Schleifen" zu gelten - zumindest für den Moment. Beispielsweise kann das Akkumulieren eines Arrays noch nicht vektorisiert werden. JDK-7192383

Hier ist ein schöner Artikel über das Experimentieren mit Java- und SIMD-Anweisungen, den mein Freund geschrieben hat: http://prestodb.rocks/code/simd/

Das allgemeine Ergebnis ist, dass Sie davon ausgehen können, dass JIT in 1.8 einige SSE-Operationen verwendet (und in 1.9 weitere). Sie sollten jedoch nicht viel erwarten und müssen vorsichtig sein.

Sie können den OpenCl-Kernel schreiben, um die Datenverarbeitung durchzuführen, und ihn unter Java http://www.jocl.org/ ausführen .

Code kann auf CPU und / oder GPU ausgeführt werden, und die OpenCL-Sprache unterstützt auch Vektortypen, sodass Sie z. B. SSE3 / 4-Anweisungen explizit nutzen können sollten.

Schauen Sie sich den Leistungsvergleich zwischen Java und JNI an, um eine optimale Implementierung von rechnergestützten Mikrokernen zu erhalten . Sie zeigen, dass der Java HotSpot VM-Server-Compiler die automatische Vektorisierung mithilfe der Super-Word-Level-Parallelität unterstützt, die auf einfache Fälle von Parallelität innerhalb der Schleife beschränkt ist. In diesem Artikel erfahren Sie auch, ob Ihre Datengröße groß genug ist, um eine JNI-Route zu rechtfertigen.

Ich vermute, Sie haben diese Frage geschrieben, bevor Sie von netlib-java erfahren haben.

Ich glaube nicht, dass die meisten VMs jemals intelligent genug für diese Art von Optimierungen sind. Um fair zu sein, sind die meisten Optimierungen viel einfacher, z. B. Verschieben statt Multiplizieren bei einer Zweierpotenz. Das Mono-Projekt führte einen eigenen Vektor und andere Methoden mit nativen Backings ein, um die Leistung zu verbessern.