One running sum vs. four partial sums

Assume floating-point add has a 4-cycle latency but the core can issue a new independent add every cycle (throughput 1/cycle across multiple FP add pipelines/ports). Version A accumulates into a single running sum. Version B unrolls by 4 and accumulates into four independent partial sums, combined only once at the very end. The array is large but stays resident in cache, so neither version is limited by memory bandwidth. What's the realistic throughput difference?

main.cpp
// Version A: single accumulator
double sum = 0;
for (int i = 0; i < n; ++i) sum += a[i];

// Version B: 4 independent accumulators
double s0 = 0, s1 = 0, s2 = 0, s3 = 0;
for (int i = 0; i < n; i += 4) {
    s0 += a[i];
    s1 += a[i + 1];
    s2 += a[i + 2];
    s3 += a[i + 3];
}
double sum = (s0 + s1) + (s2 + s3);

28 of 47 in Computer Architecture