top | item 45381200 Wild: A Fast Linker Written in Rust, Aims to Outperform Mold Linker 18 points| newman314 | 5 months ago |phoronix.com 2 comments order hn newest setheron|5 months ago What's the rationale not to try incremental linking ? Is it such an incredibly complex problem that it likely induces performance overhead killing the optimization itself ? c0balt|5 months ago You might be interested in the following discussions on this topic [0].In general, the complexity ime is at least,1. It can make builds non-deterministic (meaning potentially unreproducible, which is table stakes for most "release" builds today)2. It can make Link time code optimization (LTO) hard(er)3. It requires tracking of changes (to know when to relink), that means either some external system or integration with the compilerAt least 3. introduces a good chunk of complexity. There is also the minor issue that modern linkers are fast enough-ish without incremental linking.[0]: https://news.ycombinator.com/item?id=13672120
setheron|5 months ago What's the rationale not to try incremental linking ? Is it such an incredibly complex problem that it likely induces performance overhead killing the optimization itself ? c0balt|5 months ago You might be interested in the following discussions on this topic [0].In general, the complexity ime is at least,1. It can make builds non-deterministic (meaning potentially unreproducible, which is table stakes for most "release" builds today)2. It can make Link time code optimization (LTO) hard(er)3. It requires tracking of changes (to know when to relink), that means either some external system or integration with the compilerAt least 3. introduces a good chunk of complexity. There is also the minor issue that modern linkers are fast enough-ish without incremental linking.[0]: https://news.ycombinator.com/item?id=13672120
c0balt|5 months ago You might be interested in the following discussions on this topic [0].In general, the complexity ime is at least,1. It can make builds non-deterministic (meaning potentially unreproducible, which is table stakes for most "release" builds today)2. It can make Link time code optimization (LTO) hard(er)3. It requires tracking of changes (to know when to relink), that means either some external system or integration with the compilerAt least 3. introduces a good chunk of complexity. There is also the minor issue that modern linkers are fast enough-ish without incremental linking.[0]: https://news.ycombinator.com/item?id=13672120
setheron|5 months ago
c0balt|5 months ago
In general, the complexity ime is at least,
1. It can make builds non-deterministic (meaning potentially unreproducible, which is table stakes for most "release" builds today)
2. It can make Link time code optimization (LTO) hard(er)
3. It requires tracking of changes (to know when to relink), that means either some external system or integration with the compiler
At least 3. introduces a good chunk of complexity. There is also the minor issue that modern linkers are fast enough-ish without incremental linking.
[0]: https://news.ycombinator.com/item?id=13672120