perf(codegen): inline Codegen::print_list (#5221)

Revert #5192 and add a comment that it's not a perf gain.

This was really surprising to me, but the benchmarks do demonstrate it.

Please see the benchmarks commit-by-commit on this PR. Adding `#[inline]` to the function does give +1% gain, but it's no better than it was before #5192. So I think preferable to just revert to the simpler original.

I think likely explanation is that the compiler is already performing this optimization itself. And if it does it itself, then it understands the code better, and can then make better decisions about inlining.

https://godbolt.org/z/xzhWWeMoe seems to demonstrate this - there are 2 calls to `Item::gen` in the generated assembly, so it has split the loop into 2.
This commit is contained in:
overlookmotel 2024-08-26 10:28:48 +00:00
parent 1686920e23
commit 12a7607bac

View file

@ -411,13 +411,25 @@ impl<'a> Codegen<'a> {
self.needs_semicolon = false;
}
// We tried optimizing this to move the `index != 0` check out of the loop:
// ```
// let mut iter = items.iter();
// let Some(item) = iter.next() else { return };
// item.gen(self, ctx);
// for item in iter {
// self.print_comma();
// self.print_soft_space();
// item.gen(self, ctx);
// }
// ```
// But it turned out this was actually a bit slower.
// <https://github.com/oxc-project/oxc/pull/5221>
fn print_list<T: Gen>(&mut self, items: &[T], ctx: Context) {
let mut iter = items.iter();
let Some(item) = iter.next() else { return };
item.gen(self, ctx);
for item in iter {
self.print_comma();
self.print_soft_space();
for (index, item) in items.iter().enumerate() {
if index != 0 {
self.print_comma();
self.print_soft_space();
}
item.gen(self, ctx);
}
}