Optimize counting digits in line numbers during error reporting

[nhwn]

Replaces .to_string().len() with simple loop and integer division, which avoids an unnecessary allocation.

Although I couldn't figure out how to directly profile rustc's error reporting, I ran a microbenchmark on my machine (2.9 GHz Dual-Core Intel Core i5) on the two strategies for 0..100_000, and the results seem promising:

test to_string_len ... bench:  12,124,792 ns/iter (+/- 700,652)
test while_loop    ... bench:      30,333 ns/iter (+/- 562)

The x86_64 disassembly reduces integer division to a multiplication + shift, so I don't think there's any problems with using integer division.

For more (micro)optimization, it would be nice if we could avoid the initial check to see if the line number is nonzero, but I don't think self.get_max_line_num(span, children) guarantees a nonzero line number.

[rust-highfive]

r? @varkor

(rust-highfive has picked a reviewer for you, use r? to override)

[leonardo-m]

An alternative version:

let mut num_digits = 0;
loop {
    num_digits += 1;
    n /= 10;
    if n == 0 { break; }
}
num_digits

[nhwn]

An alternative version:

let mut num_digits = 0;
loop {
    num_digits += 1;
    n /= 10;
    if n == 0 { break; }
}
num_digits

That's a much better implementation than the original one, thanks!

[varkor]

Could you add a comment explaining why we calculate the number of digits this way? (To make sure someone doesn't revert this change without realising it's intentional, later.)

[nhwn]

Added an explanatory comment.

[varkor]

Could you squash the commits? Thanks.

[varkor]

Thanks!

@bors r+ rollup

[bors]

📌 Commit 2cd7a5148ce00e403f030e1b9437bd99e93cb08e has been approved by varkor

[nhwn]

It seems my tidy hook didn't auto-run when I rebased, so a pesky space slipped through in the comment. Sorry about that.

[varkor]

@bors r+ rollup

[bors]

📌 Commit 8a5c568 has been approved by varkor

[matthieu-m]

I actually just realized there's doesn't appear to be a fast way to compute the number of (decimal) digits that an integer would take.

I find it surprising, as I would have expected integer formatting to make use of this. For reference, a simple version is to switch on the number of bits (playground):

fn count_digits(i: u32) -> u32 {
    if i < 10 {
        return 1;
    }
    if i < 100 {
        return 2;
    }

    match 32 - i.leading_zeros() {
        0 | 1 | 2 | 3 | 4 | 5 | 6
            //  100 takes 7 bits, and anything < 100 is already handled.
            => unsafe { hint::unreachable_unchecked() },
        7 | 8 | 9 | 10
            => 3 + if i < 1_000 { 0 } else { 1 },
        11 | 12 | 13 | 14
            => 4 + if i < 10_000 { 0 } else { 1 },
        15 | 16 | 17
            => 5 + if i < 100_000 { 0 } else { 1 },
        18 | 19 | 20
            => 6 + if i < 1_000_000 { 0 } else { 1 },
        21 | 22 | 23 | 24
            => 7 + if i < 10_000_000 { 0 } else { 1 },
        25 | 26 | 27
            => 8 + if i < 100_000_000 { 0 } else { 1 },
        28 | 29 | 30
            => 9 + if i < 1_000_000_000 { 0 } else { 1 },
        31 | 32 => 10,
        //  There are not more than 32 bits in a 32 bits integer
        _ => unsafe { hint::unreachable_unchecked() },
    }
}

It may be a useful addition to the standard library.

[toothbrush7777777]

I actually just realized there's doesn't appear to be a fast way to compute the number of (decimal) digits that an integer would take.
[…]

Basically, you want ceil(log10(n)).