Poor inlining of closures for vec::from_fn<T>()

[dotdash]

When there are multiple calls to vec::from_fn<T>() with the same type T but different closures, the compiler chooses to generate only one copy of vec::from_fn<T>() and pass the closure as an argument. This is really bad for simple closures like the ones in vec::from_elem<int>() or vec::to_owned<int>()

extern mod std;

#[bench]
fn to_owned(b: &mut std::test::BenchHarness) {
  let x = [0, ..1000];
  do b.iter {
    vec::to_owned(x);
  }
}

#[bench]
fn from_elem(b: &mut std::test::BenchHarness) {
  do b.iter {
    vec::from_elem(1000, 0);
  }
}

fn main() {
}

Running these gives:

running 2 tests
test from_elem ... bench: 2060 ns/iter (+/- 0)
test to_owned ... bench: 2306 ns/iter (+/- 3)

But if I remove one of the functions and only keep the other, I get:

running 1 test
test from_elem ... bench: 425 ns/iter (+/- 3)

and

running 1 test
test to_owned ... bench: 883 ns/iter (+/- 0)

This causes a 10% performance hit for rustc --no-trans. 0m14.664s vs. 13.592s with from_elem modified not to call from_fn but having a literal copy of the code.

[dotdash]

Seems to be fixed now, probably by #6881

[dotdash]

For the record, I now get:

running 2 tests
test from_elem ... bench: 407 ns/iter (+/- 0)
test to_owned ... bench: 886 ns/iter (+/- 0)

result: ok. 0 passed; 0 failed; 0 ignored

[dotdash]

Actually, @huonw made me aware that from_elem was adjusted to work around this issue. It's actually not fixed. New test code that only uses from_fn:

extern mod extra;

use std::vec;

#[bench]
fn test1(b: &mut extra::test::BenchHarness) {
    do b.iter {
        vec::from_fn(1000, |_| 0);
    }
}

#[bench]
fn test2(b: &mut extra::test::BenchHarness) {
    do b.iter {
        vec::from_fn(1000, |_| 1);
    }
}

fn main() {
}

Results:

running 2 tests
test test1 ... bench: 2064 ns/iter (+/- 6)
test test2 ... bench: 2071 ns/iter (+/- 0)

result: ok. 0 passed; 0 failed; 0 ignored


running 1 test
test test1 ... bench: 422 ns/iter (+/- 0)

result: ok. 0 passed; 0 failed; 0 ignored


running 1 test
test test2 ... bench: 423 ns/iter (+/- 0)

result: ok. 0 passed; 0 failed; 0 ignored

[emberian]

Still very relevant, reproduces.

[pcwalton]

Have you tried with -Z no-monomorphic-collapse?

[dotdash]

I don't think I did, and I can't try right now, but I fail to see why that would possibly make a difference. The closures don't differ in their type signature but only in their constant return value. How would monomorphization make any difference?

[pcwalton]

Oh, I see, you're right.

[thestinger]

I don't think this can be considered a bug, it's a consequence of only having boxed closures.