Poor performance on u64 and i64

[YjyJeff]

I tried to test the performance of SIMD on my machine. The test code is as follows:

const STEP_BY: usize = 8;

fn fast_sum(x: &[f64]) -> f64 {
    assert!(x.len() % 8 == 0);
    let mut sum = f64x8::splat(0.); // [0., 0., 0., 0.]
    for i in (0..x.len()).step_by(STEP_BY) {
        sum += f64x8::from_slice(&x[i..]);
    }
    sum.reduce_sum()
}

fn slow_sum(x: &[f64]) -> f64 {
    assert!(x.len() % 8 == 0);
    let mut sum: f64 = 0.;
    for i in (0..x.len()).step_by(STEP_BY) {
        sum += f64x8::from_slice(&x[i..]).reduce_sum();
    }
    sum
}

#[bench]
fn bench_fast(b: &mut Bencher) {
    let data = (0..1024000).map(|v| v as f64).collect::<Vec<_>>();
    b.iter(|| fast_sum(&data))
}

#[bench]
fn bench_slow(b: &mut Bencher) {
    let data = (0..1024000).map(|v| v as f64).collect::<Vec<_>>();
    b.iter(|| slow_sum(&data))
}

fn normal_sum(x: &[f64]) -> f64 {
    let mut sum = 0.0;
    x.iter().for_each(|&val| sum += val);
    sum
}

#[bench]
fn bench_normal(b: &mut Bencher) {
    let data = (0..1024000).map(|v| v as f64).collect::<Vec<_>>();
    b.iter(|| normal_sum(&data))
}

I run the benchmark with : RUSTFLAGS='-C target-cpu=native' cargo bench and my cpu is Intel(R) Xeon(R) Platinum 8255C CPU @ 2.50GHz it support avx512. The result is awesome, SIMD outperforms normal sum a lot

test bench_fast   ... bench:     333,909 ns/iter (+/- 12,105)
test bench_normal ... bench:   1,333,889 ns/iter (+/- 6,561)
test bench_slow   ... bench:     386,461 ns/iter (+/- 5,928)

However, when I replace the f64 with u64 or i64, SIMD version is slower than the normal sum:

test bench_fast   ... bench:     339,867 ns/iter (+/- 16,114)
test bench_normal ... bench:     327,762 ns/iter (+/- 8,146)
test bench_slow   ... bench:     347,187 ns/iter (+/- 8,486)

Why does it happens?

[bjorn3]

It is the non-SIMD version which got much faster. The difference between the u64 and f64 version of the SIMD benchmarks is likely caused by noise in measurements. If you do 333,909 + 12,105 the result is bigger than 339,867.

[YjyJeff]

333,909 + 12,105

Got it. Another question might be: why the non-SIMD version of u64 is much much faster than f64? But the SIMD version of u64 almost equals f64.

[bjorn3]

Not sure. You will likely have to look at the assembly to see what is different.

[workingjubilee]

Rust's built-in benchmarking tools are unfortunately very poor, I recommend caution when trying to derive statistical data from them.

[scottmcm]

why the non-SIMD version of u64 is much much faster than f64?

Almost certainly because u64 addition is associative, and thus the obvious loop gets auto-vectorized (https://rust.godbolt.org/z/TxGhTesKK) and it does so in a way that's target-aware (especially if you use native) and thus picks a better width than manually vectorizing.

(That same code but with f64 doesn't vectorize: https://rust.godbolt.org/z/85W7Kf9YK.)