Don't try to understand my first version too much, the second function is much simpler. It's simply comparing two 3x3x3 patches of data in a 11x11x11 image and returning a score. I refactored this function from
fn test_loop(data: &[f64], m: usize, n: usize, o: usize) -> f64 {
let pl = 3;
let br = 4;
let bl = 11;
let bl2 = bl * bl;
let mut sum = 0.0;
for a in 0..pl {
let idx1_a = (br + a) * bl2;
let idx2_a = (m + a) * bl2;
for b in 0..pl {
let idx1_b = (br + b) * bl;
let idx2_b = (n + b) * bl;
for c in 0..pl {
let idx1 = idx1_a + idx1_b + br + c;
let idx2 = idx2_a + idx2_b + o + c;
let diff = (data[idx1] - data[idx2]).powi(2);
sum += diff;
}
}
}
sum
}
to
fn test_slice(data: &Array3<f64>, m: usize, n: usize, o: usize) -> f64 {
let pl = 3;
let br = 4;
let s1 = data.slice(s![br..br+pl, br..br+pl, br..br+pl]);
let s2 = data.slice(s![m..m+pl, n..n+pl, o..o+pl]);
let mut sum = 0.0;
azip!(s1, s2 in { sum += (s1 - s2).powi(2) });
sum
}
Of course, I'm happy with the code quality now (!), but the clean version is surprisingly slow. I benched those 2 functions using the same data, with test_loop using &data.as_slice().unwrap() instead of &data
test bench_loop ... bench: 25 ns/iter (+/- 5)
test bench_slice ... bench: 142 ns/iter (+/- 1)
Are those results surprising to you? Both versions don't allocate, calculate the indices (in src or lib) and the sum, etc. I fail to see why the clean version is almost 6 times slower. Is slice doing something really complex?
Don't try to understand my first version too much, the second function is much simpler. It's simply comparing two 3x3x3 patches of data in a 11x11x11 image and returning a score. I refactored this function from
to
Of course, I'm happy with the code quality now (!), but the clean version is surprisingly slow. I benched those 2 functions using the same data, with
test_loopusing&data.as_slice().unwrap()instead of&dataAre those results surprising to you? Both versions don't allocate, calculate the indices (in src or lib) and the sum, etc. I fail to see why the clean version is almost 6 times slower. Is
slicedoing something really complex?