假设我的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缓冲区。另一方面，在这种情况下，手动展开循环并不能提供可衡量的性能提升。
为了应对这里其他人提出的一些怀疑，我建议任何想要向自己或他人证明的人使用以下方法：
例子：
@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
玩得开心，攻陷城堡！
请查看Java和JNI在计算微内核最佳实现方面的性能比较。他们表明，Java HotSpot VM服务器编译器支持使用超字级并行性进行自动向量化，但仅限于简单的循环内部并行性。本文还将为您提供一些指导，以确定您的数据大小是否足够大，以证明使用JNI路线是有必要的。
我猜你在了解netlib-java之前写下了这个问题；-) 它提供了你所需的本地API，具有机器优化实现，并且由于内存固定而不会在本地边界上产生任何成本。
Java 16引入了向量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）正在尝试使用谓词指令来消除最后一个循环，但据说对其的支持还不稳定。
我不相信大多数或任何虚拟机都足够聪明以进行此类优化。公平地说，大多数优化要简单得多，例如在乘幂为2时进行移位而非乘法。Mono项目引入了自己的矢量和其他具有本地支持的方法以帮助提高性能。
-XX:+UnlockDiagnosticVMOptions -XX:+PrintAssembly -XX:+LogCompilation输出生成的汇编代码。您需要一个运行可向量化方法足够次数使其“热”的程序。 - Louis Wasserman