Dlaczego logarytm jest wolniejszy w Rust niż w Javie?

Question

Gdybym uruchomić te standardy w 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()); 
} 

Wynikiem jest:

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

121-6 = 115 ns na ln rozmowy.

Ale ten sam punkt odniesienia w Javie:

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

Daje mi:

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

Rejestr jest ~ 3,7 razy wolniej (115/31) w Rust niż w Javie.

Kiedy testuję wykonanie przeciwprostokątnej (hypot), implementacja w Rust jest 15,8 razy szybsza niż w Javie.

Czy napisałem złe testy porównawcze lub jest to problem z wydajnością?

Odpowiedzi na pytania zadane w komentarzach:

1. "" jest separator dziesiętny w moim kraju.

2. Prowadzę benchmark Rusta przy użyciu cargo bench, który zawsze działa w trybie zwolnienia.

3. Środowisko testowe Java (JMH) tworzy nowy obiekt dla każdego połączenia, mimo że jest to klasa static i final zmienna. Jeśli dodaję losową kreację do testowanej metody, otrzymam 43 ns/op.

Answer 1

Odpowiedź była given by @kennytm:

export RUSTFLAGS='-Ctarget-cpu=native' 

rozwiązuje problem. Następnie wyniki:

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

Myślę, że 38 (± 3) jest wystarczająco blisko 31,555 (± 0,234).

Answer 2

Mam zamiar podać drugą połowę wyjaśnienia, ponieważ nie znam Rusta. Math.log jest opatrzone komentarzem o numerze @HotSpotIntrinsicCandidate, co oznacza, że ​​zostanie zastąpione przez natywną instrukcję procesora dla takiej operacji: pomyśl o Integer.bitCount, które albo wykonałoby wiele zmian, albo użyje instrukcji bezpośredniego procesora, która robi to znacznie szybciej.

uwzględniając niezwykle prosty program tak:

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

i uruchomienie go z:

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

To będzie generować wiele wierszy, ale jeden z nich jest:

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

ten kod jest niezwykle szybki.

Naprawdę nie wiem, kiedy i jak to się dzieje w Rust ...