5 ms·
I'm not familiar with the term "Heldencompilers", but this describes compilers for all modern languages. :P C++ moreso than C, but even C can need cajoling to g
by kibwen 10y ago
I'm not familiar with the term "Heldencompilers", but this describes compilers for all modern languages. :P C++ moreso than C, but even C can need cajoling to get it to conform to the specific structures that modern optimizers recognize (and that structure can even differ from compiler to compiler), especially for stuff like autovectorization.
Also note that Swift doesn't have the same performance goals that Rust does, preferring to trade some off in favor of ergonomics.
- Gankro 10y agoSwift's long term goals are to handle the exact same space as Rust, and that means the exact same performance/control goals. We're just starting higher up, and working our way down. Rust is a lot more mature! RIP libgreen.
- Manishearth 10y agoCan't wait to hear more about swift's opt in borrowing!
- mpweiher 10y ago> this describes compilers for all modern languages Yes, this is the current trend. And the results don't really justify the cost: http://www.complang.tuwien.ac.at/kps2015/proceedings/KPS_2015_submission_29.pdf http://www.complang.tuwien.ac.at/kps2015/proceedings/KPS_201... http://proebsting.cs.arizona.edu/law.html http://proebsting.cs.arizona.edu/law.html Which is why I (roughly) agree with Daniel Bernstein's polemic "The Death of Optimizing Compilers" https://cr.yp.to/talks/2015.04.16/slides-djb-20150416-a4.pdf https://cr.yp.to/talks/2015.04.16/slides-djb-20150416-a4.pdf (I frequently make code 10x to 1000x or more faster, and compilers' contributions to that total tend to be fairly minimal, though larger than zero and usually worthwhile. But not worth the current shenanigans and not worth having no idea how the code is going to turn out)
- vog 10y agoThis also explains the shift in functional programming from languages with good reasoning about correctness (Haskell, but also SQL) to languages which additionally allow of good reasoning of performance (OCaml, Rust, etc.). Moreover, this explains the NASA coding rule that all loops shall have an explicit upper bound. The deeper issue seems to be: If you write code in a fashion that you can reason easily about its performance, then you might not get the optimal performance in all cases, but you establish an minimum level of performance. So performance stability is more important than reaching optimal performance, because the latter may be easily destroyed accidentally in future versions of the software. The only exception are well-defined tasks with stable input/output definitions (e.g. numeric primitives like matrix multiplication, fourier transformation, etc.) where the whole point of newer versions is performance improvements and nothing else.
- vkjv 10y agoI don't doubt that you make code 10x to 1000x faster, but could this be selection bias? I.e., you are focusing on the code that is slow and not the code that the compiler has already had substantial impact on?
- daemin 10y agoYou make code 10x 1000x faster by changing the algorithm or data layout that you use instead of just emitting different instructions for the same higher level code.
- sqeaky 10y agoI don't think anyone who mattered ever argued than an optimizing compiler could or should attempt to turn bad algorithms into good ones. It seems clear to me that at the present state of tech that Most developers are better at picking algorithms while compilers are better at picking which low level instructions. Clearly there are some exceptions, but things like gotoBLAS are clearly exceptions and not the rule.
- daemin 10y agoNo, but there can be this myth that certain things will be "optimised away" by the compiler, which is why you can get single digit or fractional speedups by just tuning the optimisation level.
- sqeaky 10y agoI would much rather deal those "myths" than with the class of myths surrounding i++ being faster/lower than ++i or any of the non-sense around divisions. At least people claiming something will be optimized away can readily be empirically tested in a way that most will listen to. I have no problem testing the / operator, but I have never had holders of such beliefs accept my results, but people claiming something like "virtual function calls can be optimized away" can handle it when I can demonstrated that inside a single binary they can be but at places like library boundaries they cannot.