Генерируют ли какие-либо JIT-компиляторы JVM код, использующий векторизованные инструкции с плавающей запятой?

Скажем, узким местом моей 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 @ 2,80 ГГц, 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 нс / операцию (наносекунды на операцию) -XX: -UseSuperWord: 3376,364 ± 233,211 нс / операцию

Сборка для горячего цикла немного сложна для форматирования и вставки здесь, но вот фрагмент (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

Удачи штурму замка!

В версиях HotSpot, начиная с Java 7u40, серверный компилятор обеспечивает поддержку автоматической векторизации. Согласно JDK-6340864

Однако, похоже, это верно только для «простых циклов» - по крайней мере, на данный момент. Например, накопление массива пока не может быть векторизовано JDK-7192383

Вот хорошая статья об экспериментах с инструкциями Java и SIMD, написанная моим другом: http://prestodb.rocks/code/simd/

Его общий результат состоит в том, что вы можете ожидать, что JIT будет использовать некоторые операции SSE в 1.8 (и некоторые другие в 1.9). Хотя многого ожидать не стоит и нужно быть осторожным.

Вы можете написать ядро ​​OpenCl для выполнения вычислений и запустить его с java http://www.jocl.org/ .

Код может запускаться на CPU и / или GPU, а язык OpenCL поддерживает также векторные типы, поэтому вы должны иметь возможность явно воспользоваться преимуществами, например, инструкций SSE3 / 4.

Взгляните на Сравнение производительности Java и JNI для оптимальной реализации вычислительных микроядер . Они показывают, что серверный компилятор Java HotSpot VM поддерживает автоматическую векторизацию с использованием параллелизма на уровне сверхслова, который ограничен простыми случаями параллелизма внутри цикла. Эта статья также подскажет, достаточно ли велик ваш размер данных, чтобы оправдать переход по маршруту JNI.

Я предполагаю, что вы написали этот вопрос до того, как узнали о netlib-java ;-) он предоставляет именно тот собственный API, который вам нужен, с оптимизированными для машины реализациями и не имеет никаких затрат на родной границе благодаря закреплению памяти.

Я не верю, что большинство виртуальных машин будут достаточно умными для такого рода оптимизаций. Честно говоря, большинство оптимизаций намного проще, например, сдвиг вместо умножения в степени двойки. В монопроекте были представлены собственные векторные и другие методы с нативной поддержкой для повышения производительности.