Optimize sum of Durations by using custom function

[Pazzaz]

The current impl Sum for Duration uses fold to perform several adds (or really checked_adds) of durations. In doing so, it has to guarantee the number of nanoseconds is valid after every addition. If you squeese the current implementation into a single function it looks kind of like this:

fn sum<I: Iterator<Item = Duration>>(iter: I) -> Duration {
    let mut sum = Duration::new(0, 0);
    for rhs in iter {
        if let Some(mut secs) = sum.secs.checked_add(rhs.secs) {
            let mut nanos = sum.nanos + rhs.nanos;
            if nanos >= NANOS_PER_SEC {
                nanos -= NANOS_PER_SEC;
                if let Some(new_secs) = secs.checked_add(1) {
                    secs = new_secs;
                } else {
                    panic!("overflow when adding durations");
                }
            }
            sum = Duration { secs, nanos }
        } else {
            panic!("overflow when adding durations");
        }
    }
    sum
}

We only need to check if nanos is in the correct range when giving our final answer so we can have a more optimized version like so:

fn sum<I: Iterator<Item = Duration>>(iter: I) -> Duration {
    let mut total_secs: u64 = 0;
    let mut total_nanos: u64 = 0;

    for entry in iter {
        total_secs = total_secs
            .checked_add(entry.secs)
            .expect("overflow in iter::sum over durations");
        total_nanos = match total_nanos.checked_add(entry.nanos as u64) {
            Some(n) => n,
            None => {
                total_secs = total_secs
                    .checked_add(total_nanos / NANOS_PER_SEC as u64)
                    .expect("overflow in iter::sum over durations");
                (total_nanos % NANOS_PER_SEC as u64) + entry.nanos as u64
            }
        };
    }
    total_secs = total_secs
        .checked_add(total_nanos / NANOS_PER_SEC as u64)
        .expect("overflow in iter::sum over durations");
    total_nanos = total_nanos % NANOS_PER_SEC as u64;
    Duration {
        secs: total_secs,
        nanos: total_nanos as u32,
    }
}

We now only convert total_nanos to total_secs (1) if total_nanos overflows and (2) at the end of the function when we have to output a valid Duration. This gave a 5-22% performance improvement when I benchmarked it, depending on how big the nano value of the Durations in iter were.

[pietroalbini]

r? @sfackler (someone from the libs team)

[pietroalbini]

Ping from triage @sfackler! This PR needs your review.

[sfackler]

@bors r+

Sorry for the delay!

[bors]

📌 Commit d22ad76 has been approved by sfackler

[bors]

⌛ Testing commit d22ad76 with merge 612c280...

[bors]

☀️ Test successful - status-appveyor, status-travis
Approved by: sfackler
Pushing 612c280 to master...