JVM의 JIT 컴파일러가 벡터화 된 부동 소수점 명령어를 사용하는 코드를 생성합니까?

내 Java 프로그램의 병목 현상이 실제로 많은 벡터 내적을 계산하기위한 타이트한 루프라고 가정 해 보겠습니다. 예, 프로필을 작성했습니다. 예, 병목 현상입니다. 예, 중요합니다. 예, 알고리즘이 그렇습니다. 예, 바이트 코드를 최적화하기 위해 Proguard를 실행했습니다.

작업은 본질적으로 내적입니다. 에서와 같이 두 개가 float[50]있고 쌍을 이루는 곱의 합을 계산해야합니다. SSE 또는 MMX와 ​​같이 이러한 종류의 작업을 대량으로 신속하게 수행하기 위해 프로세서 명령 세트가 존재한다는 것을 알고 있습니다.

예, JNI에서 일부 네이티브 코드를 작성하여 액세스 할 수 있습니다. JNI 호출은 상당히 비쌉니다.

JIT가 컴파일하거나 컴파일하지 않을 것을 보장 할 수 없다는 것을 알고 있습니다. 사람이나요 지금 이 지침을 사용하는 JIT 생성 코드 들어? 그렇다면 Java 코드에 대해 이러한 방식으로 컴파일 할 수 있도록 도와주는 것이 있습니까?

아마도 "아니오"일 것입니다. 물어볼 가치가 있습니다.

따라서 기본적으로 코드가 더 빠르게 실행되기를 원합니다. JNI가 답입니다. 당신이 그것이 당신에게 효과가 없다고 말한 것을 알고 있지만 당신이 틀렸다는 것을 보여 드리겠습니다.

여기 있습니다 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");
    }
}

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

다음 명령을 사용하여 JavaCPP로 컴파일하고 실행할 수 있습니다 .

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

Intel (R) Core (TM) i7-7700HQ CPU @ 2.80GHz, Fedora 30, GCC 9.1.1 및 OpenJDK 8 또는 11을 사용하면 다음과 같은 출력이 나타납니다.

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

또는 대략 2.4 배 더 빠릅니다. 어레이 대신 직접 NIO 버퍼를 사용해야하지만 HotSpot은 어레이만큼 빠르게 직접 NIO 버퍼에 액세스 할 수 있습니다 . 반면에 루프를 수동으로 풀면이 경우 성능이 크게 향상되지 않습니다.

여기에서 다른 사람들이 표현한 회의론을 다루기 위해 본인 또는 다른 사람에게 증명하고 싶은 사람은 누구나 다음 방법을 사용할 것을 제안합니다.

• JMH 프로젝트 만들기
• 벡터화 가능한 수학의 작은 조각을 작성하십시오.
• -XX : -UseSuperWord와 -XX ​​: + UseSuperWord (기본값) 사이에서 벤치 마크 뒤집기를 실행합니다.
• 성능 차이가 관찰되지 않으면 코드가 벡터화되지 않은 것입니다.
• 확인하려면 어셈블리를 인쇄하도록 벤치 마크를 실행하십시오. Linux에서는 perfasm 프로파일 러 ( '-prof perfasm')를보고 예상 한 지침이 생성되는지 확인할 수 있습니다.

예:

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

플래그를 포함하거나 포함하지 않은 결과 (최신 Haswell 랩톱, Oracle JDK 8u60) : -XX : + UseSuperWord : 475.073 ± 44.579 ns / op (op 당 나노초) -XX : -UseSuperWord : 3376.364 ± 233.211 ns / op

핫 루프에 대한 어셈블리는 형식을 지정하고 여기에 고정해야하지만 여기에 스 니펫이 있습니다 (hsdis.so는 일부 AVX2 벡터 명령의 형식을 지정하지 못하므로 -XX : UseAVX = 1) : -XX : + UseSuperWord ( '-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

성을 습격하는 재미를 느껴보세요!

Java 7u40으로 시작하는 HotSpot 버전에서 서버 컴파일러는 자동 벡터화를 지원합니다. 에 따르면 JDK-6340864

그러나 이것은 "단순 루프"에 대해서만 사실 인 것 같습니다-적어도 현재로서는. 예를 들어 배열 누적은 아직 벡터화 할 수 없습니다. JDK-7192383

내 친구가 작성한 Java 및 SIMD 지침을 실험하는 방법에 대한 좋은 기사가 있습니다. http://prestodb.rocks/code/simd/

일반적인 결과는 JIT가 1.8에서 일부 SSE 작업을 사용하고 1.9에서 더 많이 사용할 것으로 예상 할 수 있다는 것입니다. 많은 것을 기 대해서는 안되며 조심해야합니다.

OpenCl 커널을 작성하여 컴퓨팅을 수행하고 java http://www.jocl.org/ 에서 실행할 수 있습니다 .

코드는 CPU 및 / 또는 GPU에서 실행할 수 있으며 OpenCL 언어는 벡터 유형도 지원하므로 SSE3 / 4 명령어 등을 명시 적으로 활용할 수 있어야합니다.

컴퓨팅 마이크로 커널의 최적 구현을 ​​위해 Java와 JNI 간의 성능 비교를 살펴보십시오 . 그들은 Java HotSpot VM 서버 컴파일러가 내부 루프 병렬 처리의 단순한 경우로 제한되는 수퍼 워드 레벨 병렬 처리를 사용하여 자동 벡터화를 지원함을 보여줍니다. 이 기사는 또한 데이터 크기가 JNI 경로를 정당화 할만큼 충분히 큰지에 대한 지침을 제공합니다.

netlib-java에 대해 알기 전에이 질문을 썼다고 생각합니다. ;-) 기계 최적화 구현과 함께 필요한 기본 API를 정확히 제공하며 메모리 고정 덕분에 기본 경계에서 비용이 발생하지 않습니다.

나는 어떤 VM이 이런 종류의 최적화를 위해 충분히 똑똑하다고 믿지 않는다. 공정하게 말하면 대부분의 최적화는 2의 거듭 제곱 일 때 곱하기 대신 이동하는 것과 같이 훨씬 더 간단합니다. 모노 프로젝트는 성능을 돕기 위해 네이티브 백업과 함께 자체 벡터 및 기타 방법을 도입했습니다.