undefined | Better HN

0 pointschakkepolja4y ago0 comments

We don't know of a way to implement generic types without (vtable dispatch + boxing) cost AND without monomorphization cost. Some languages do former, some latter, some combination of 2.

Monomorphization: * code bloat * slow compiles * debug builds may be slow (esp c++)

Dynamic dispatch & boxing (Usually both are needed): * not zero cost

Pick your poison

0 comments

2 comments · 1 top-level

SomeCallMeTim4y ago· 1 in thread

"Zero-cost" in that context refers to runtime performance. It always refers to runtime performance.

And code bloat, as I've said elsewhere, is vastly overblown as a problem. Another commenter pointed out that link-time optimization removes most of the bloat. The rest is customized code that's optimized per-instantiation.

Slow compiles are an issue with C++ templates. They're literally a Turing-complete code-generation language of their own, and they can perform complex calculations at compile time, so yes, they tend to make compiles take longer when you're using them extensively. But the point I was making was about runtime performance. That's why C++ compilers often perform incremental compilation, which can limit the development time cost.

Debug builds can simply be slow in C++ with or without templates. C++ templates really don't affect debug build runtime performance in any material fashion; writing the code out customized for each given type should have identical performance to the template-generated version of the code, unless there's some obscure corner case I'm not considering.

chakkepoljaOP4y ago

> Slow compiles are an issue with C++ templates.

As far as I know

Rust has the same problem although to lesser extent. Monomorphization works well with judicious use. C++ STL is not written like that, they depend on 11111 layers of inlining to work well. Rust libraries aren't much better in this regard.

LTO removed some code bloat, but LTO itself takes more time. until thinLTO summary pass / equivalent pass in GCC WHOPR at least, middle end and early IR optimizations still have to happen, and Go wants to avoid that. I think that's a fine design choice. In Go's design, they have decided virtual calls aren't a cost they'd care anyway, pre 1.8 Go heavily used interfaces and that's not going to change.

> writing the code out customized for each given type should have identical performance to the template-generated version of the code

In theory yeah, but templates tend to generate more instantiations than strictly what you'd write by hand.

Also, obscure corner cases exist, but not big enough, thanks to those numerous man years spent on GCC and LLVM. https://travisdowns.github.io/blog/2020/01/20/zero.html

j / k navigate · click thread line to collapse