101

假设我的 Java 程序的瓶颈确实是一些紧密循环来计算一堆矢量点积。是的，我已经分析过了，是的，这是瓶颈，是的，它很重要，是的，算法就是这样，是的，我已经运行 Proguard 来优化字节码等。

这项工作本质上是点积。如，我有两个float[50]，我需要计算成对产品的总和。我知道存在处理器指令集来快速批量执行此类操作，例如 SSE 或 MMX。

是的，我可能可以通过在 JNI 中编写一些本机代码来访问这些。事实证明，JNI 调用非常昂贵。

我知道您无法保证 JIT 将编译或不编译什么。有没有人听说过使用这些指令的 JIT 生成代码？如果是这样，Java 代码有什么可以帮助它以这种方式编译的吗？

可能是“不”；值得一问。

4

9 回答 9

46

所以，基本上，你希望你的代码运行得更快。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 缓冲区。另一方面，在这种情况下，手动展开循环并不能显着提高性能。

于 2012-05-30T02:06:53.873 回答
42

为了解决其他人在这里表达的一些怀疑，我建议任何想向自己或其他人证明的人使用以下方法：

  • 创建一个 JMH 项目
  • 写一小段可向量化的数学。
  • 在 -XX:-UseSuperWord 和 -XX:+UseSuperWord（默认）之间运行他们的基准测试
  • 如果没有观察到性能差异，则您的代码可能没有被矢量化
  • 为确保，运行您的基准测试以打印出程序集。在 linux 上，您可以使用 perfasm profiler('-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（每操作纳秒） -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

玩得开心冲进城堡！

于 2013-06-17T08:00:33.707 回答
26

在从 Java 7u40 开始的 HotSpot 版本中，服务器编译器提供对自动矢量化的支持。根据JDK-6340864

然而，这似乎只适用于“简单循环”——至少目前如此。例如，累积数组还不能向量化JDK-7192383

于 2013-11-28T13:30:13.503 回答
6

这是我朋友写的关于试验 Java 和 SIMD 指令的好文章：http: //prestodb.rocks/code/simd/

它的一般结果是您可以期望 JIT 在 1.8 中使用一些 SSE 操作（以及在 1.9 中更多）。虽然你不应该期望太多，你需要小心。

于 2017-06-28T20:09:59.877 回答
4

您可以编写 OpenCl 内核来进行计算并从 java http://www.jocl.org/运行它。

代码可以在 CPU 和/或 GPU 上运行，并且 OpenCL 语言还支持向量类型，因此您应该能够明确利用例如 SSE3/4 指令。

于 2013-02-28T15:02:34.523 回答
4

查看Java 和 JNI 之间的性能比较，以优化计算微内核的实现。他们表明，Java HotSpot VM 服务器编译器支持使用超字级并行的自动向量化，这仅限于循环内并行的简单情况。本文还将为您提供一些指导，看看您的数据大小是否足以证明采用 JNI 路线的合理性。

于 2015-12-05T23:11:34.647 回答
3

我猜你在发现 netlib-java 之前写了这个问题 ;-) 它提供了你需要的本机 API，具有机器优化的实现，并且由于内存固定，在本机边界没有任何成本。

于 2015-12-01T16:57:21.600 回答
3

Java 16 引入了 Vector API（JEP 417、JEP 414、JEP 338）。它目前正在“孵化”（即测试版），尽管任何人都可以使用它。它可能会在 Java 19 或 20 中成为 GA。

它有点冗长，但意味着可靠和便携。

可以重写以下代码：

void scalarComputation(float[] a, float[] b, float[] c) {
   assert a.length == b.length && b.length == c.length;
   for (int i = 0; i < a.length; i++) {
        c[i] = (a[i] * a[i] + b[i] * b[i]) * -1.0f;
   }
}

使用向量 API：

static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_PREFERRED;

void vectorComputation(float[] a, float[] b, float[] c) {
    assert a.length == b.length && b.length == c.length;
    int i = 0;
    int upperBound = SPECIES.loopBound(a.length);
    for (; i < upperBound; i += SPECIES.length()) {
        // FloatVector va, vb, vc;
        var va = FloatVector.fromArray(SPECIES, a, i);
        var vb = FloatVector.fromArray(SPECIES, b, i);
        var vc = va.mul(va)
                   .add(vb.mul(vb))
                   .neg();
        vc.intoArray(c, i);
    }
    for (; i < a.length; i++) {
        c[i] = (a[i] * a[i] + b[i] * b[i]) * -1.0f;
    }
}

较新的版本（即 Java 18）正试图使用​​谓词指令摆脱最后一个 for 循环，但据推测对它的支持仍然参差不齐。

于 2021-12-21T17:05:39.330 回答
-6

如果有任何虚拟机足够聪明，我不相信大多数人都可以进行这种优化。公平地说，大多数优化要简单得多，例如在 2 的幂时进行移位而不是乘法。mono 项目引入了他们自己的向量和其他方法，并带有原生支持以帮助提高性能。

于 2012-05-30T02:40:42.500 回答