Chained iterators cause 2x slowdown in micro-benchmark.

[mahkoh]

Consider the following benchmark:

extern crate test;

fn init() -> [u8, ..1024] {
    let mut x: [u8, ..1024] = unsafe { std::mem::zeroed() };
    for i in range(0, x.len()) {
        x[i] = i as u8;
    }
    x
}

#[bench]
fn unrolled(b: &mut test::Bencher) {
    let x = init();
    b.iter(|| {
        for &y in x.iter() {
            test::black_box(y);
        }
        test::black_box(0u8);
    });
}

#[bench]
fn chained(b: &mut test::Bencher) {
    let x = init();
    b.iter(|| {
        for &y in x.iter().chain([0].iter()) {
            test::black_box(y);
        }
    });
}

And the results:

test chained  ... bench:      1889 ns/iter (+/- 2)
test unrolled ... bench:       956 ns/iter (+/- 1)

[huonw]

Is our generated code particularly bad, or is the implementation of chain slower than necessary?

For the most part, this seems like entirely expected and unavoidable behaviour: adding extra branches will make code slower.

[mahkoh]

A zero-cost chain could replace a loop with two chained iterators by two loops without chained iterators. Iterators are advertised as zero-cost and this code is more natural than two loops if the loop-body is non-trivial.

[mahkoh]

NB: I've seen this 2x slowdown in real programs that are not micro benchmarks.

[jonhoo]

#38038 would presumably address this.