为什么Rust中的对数比Java慢？

Question

如果我在Rust中运行这些基准测试：

#[bench]
fn bench_rnd(b: &mut Bencher) {
    let mut rng = rand::weak_rng();
    b.iter(|| rng.gen_range::<f64>(2.0, 100.0));
}

#[bench]
fn bench_ln(b: &mut Bencher) {
    let mut rng = rand::weak_rng();
    b.iter(|| rng.gen_range::<f64>(2.0, 100.0).ln());
}

结果是：

test tests::bench_ln             ... bench:        121 ns/iter (+/- 2)
test tests::bench_rnd            ... bench:          6 ns/iter (+/- 0)

每次通话121-6=115纳秒。

但Java的基准相同：

@State(Scope.Benchmark)
public static class Rnd {
    final double x = ThreadLocalRandom.current().nextDouble(2, 100);
}

@Benchmark
public double testLog(Rnd rnd) {
    return Math.log(rnd.x);
}

给我：

Benchmark    Mode Cnt  Score  Error Units
Main.testLog avgt  20 31,555 ± 0,234 ns/op

Rust中的原木速度约为Java中的3.7倍（115/31）。

当我测试斜边实现（hypot）时，Rust中的实现速度是Java中的15.8倍。

我是否编写了糟糕的基准测试，或者这是一个性能问题？

回复评论中提出的问题：

>

我使用总是在发布模式下运行的cargo bench运行Rust的基准测试。

Java基准测试框架（JavaBenchmarkFramework，JMH）为每个调用创建一个新对象，即使它是静态类和最终变量。如果我在测试方法中添加一个随机创建，我得到43 ns/op。

Answer 1

我将提供另一半的解释，因为我不知道<代码>数学。日志用@hospotintrisccandidate注释，这意味着对于这样的操作，它将被本机CPU指令替换：thinkInteger。位计数可以进行大量移位，也可以使用速度更快的直接CPU指令。

有这样一个非常简单的程序：

public static void main(String[] args) {
    System.out.println(mathLn(20_000));
}

private static long mathLn(int x) {
    long result = 0L;
    for (int i = 0; i < x; ++i) {
        result = result + ln(i);
    }
    return result;
}

private static final long ln(int x) {
    return (long) Math.log(x);
}

并运行它：

 java -XX:+UnlockDiagnosticVMOptions  
      -XX:+PrintInlining 
      -XX:+PrintIntrinsics 
      -XX:CICompilerCount=2 
      -XX:+PrintCompilation  
      package/Classname 

它将生成许多行，但其中之一是：

 @ 2   java.lang.Math::log (5 bytes)   intrinsic

使这个代码非常快。

我真的不知道这是什么时候发生的，是怎么发生的。。。

Answer 2

答案由@kennytm给出：

export RUSTFLAGS='-Ctarget-cpu=native'

修复问题。之后，结果是：

test tests::bench_ln              ... bench:          43 ns/iter (+/- 3)
test tests::bench_rnd             ... bench:           5 ns/iter (+/- 0)

我认为38（±3）足够接近31.555（±0.234）。