Rust
Horizontal ops
Use horizontal operations like horizontal_reduce.
Horizontal operations
Lane-wise operations are "vertical" (lane i with lane i). Operations combining a vector's own lanes are "horizontal": reduce_sum, reduce_max, reduce_and. Horizontal operations are expensive, so they're done once at the end of the loop:
// nightly std::simd
let v = f32x8::from_array([1., 2., 3., 4., 5., 6., 7., 8.]);
let t = v.reduce_sum(); // 36
let m = v.reduce_max(); // 8
Hardware usually does this as a "tree": first it adds the halves, then the quarters, until a single value remains.
Tree reduction
Summing by folding the lanes in half shows how horizontal reduction works:
fn yatay_toplam(v: [f32; 8]) -> f32 {
let d4: [f32; 4] = std::array::from_fn(|i| v[i] + v[i + 4]);
let d2: [f32; 2] = std::array::from_fn(|i| d4[i] + d4[i + 2]);
d2[0] + d2[1]
}
At each step half of the array is added lane-wise to the other half; 8 → 4 → 2 → 1.
Exercise Horizontal sum
Write the yatay_toplam function above. For [1.0, 2.0, ..., 8.0], print the result and the largest lane found with fold(f32::MIN, f32::max), separated by a space.
Show example solution
fn yatay_toplam(v: [f32; 8]) -> f32 {
let d4: [f32; 4] = std::array::from_fn(|i| v[i] + v[i + 4]);
let d2: [f32; 2] = std::array::from_fn(|i| d4[i] + d4[i + 2]);
d2[0] + d2[1]
}
fn main() {
let v = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0];
let m = v.iter().copied().fold(f32::MIN, f32::max);
println!("{} {}", yatay_toplam(v), m);
}
Test yourself
-
Does tree-shaped summation give the same result as left-to-right summation (f32)?
- Different only for integers
- Not always; floating-point addition isn't associative, small differences can occur
- Always the same
- Never
Show answer
Not always; floating-point addition isn't associative, small differences can occur — That's why the compiler doesn't reorder f32 sum loops by itself; explicit permission (or manual multiple accumulators) is needed.
-
Fold in half
let d4: [f32; 4] = std::array::from_fn(|i| v[i] + v[i + ____]);
Show answer
let d4: [f32; 4] = std::array::from_fn(|i| v[i] + v[i + 4]);
-
Operation and direction
- a + b
- Vertical
- reduce_sum
- Horizontal
- reduce_max
- Horizontal (max)
- splat
- Broadcast
Next lesson: Auto-vectorization
