Rust: Zero-Cost Abstraction in Action
idursun.com
Rust: Zero-Cost Abstraction in Action
1–10 of 46 posts
Re: Rust: Zero-Cost Abstraction in Action
#2There is nothing about zero const abstractions in this article, just basic compiler optimizations.
Re: Rust: Zero-Cost Abstraction in Action
#3The earlier transformations are actually more impressive. Constant folding is almost always has a good RoI, so lots of compilers do it, and it's simple because, well, it's a constant there is no variables or partial eval needed. The others require lots of inlining before the final rule fires, and so are more ambitious.
Seeing what
pub fn sum3(n: i32) -> i32 {
(1..n).sum() + (1..2*n).sum() + (1..(n + 2)).sum()
}
Also, while all the inline is rustc, I assume the "triangle number trick" is LLVM.
Re: Rust: Zero-Cost Abstraction in Action
#4Are compiler optimizations like summing a series done on an ad-hoc basis? Certainly the compiler couldn’t have discovered or inferred (not sure what term to use) that formula, no?
Just generally curious.
Re: Rust: Zero-Cost Abstraction in Action
#5This is neat but there is still cost in compile time
Re: Rust: Zero-Cost Abstraction in Action
#6There is nothing about zero const abstractions in this article, just basic compiler optimizations.
Well, functions are abstractions too, but yes to me the interesting part of "zero const abstraction" is "zero cost data structure composition", and that indeed is not covered.
Re: Rust: Zero-Cost Abstraction in Action
#7This isn’t really talking about Rust, it’s actually talking about the optimization capabilities of LLVM (the compiler backend, which quite a lot of languages use, such as Clang for C++, Rust, Swift, Julia, Zig, ...) These languages all have similar chances of performing those same optimizations, at least in those simple cases.
What I’m interested is how the IL code for the compiler frontends for each of those languages are more well-optimizable for LLVM (in practical situations, not just a few lines of simple numerical code.) I’ve heard that you need to be careful about encoding IL code in the right way such that LLVM does not generate needless memcpy’s or something but I’m not that much of a compiler expert...
Re: Rust: Zero-Cost Abstraction in Action
#8Are compiler optimizations like summing a series done on an ad-hoc basis? Certainly the compiler couldn’t have discovered or inferred (not sure what term to use) that formula, no? Just generally curious.
Those optimizations are happening on LLVM's end (though the higher-level language will have to expose sufficiently transparent abstractions to make these optimizations possible). I'd love to read a book on the optimization techniques that are implemented in LLVM/GCC to make transformations like this possible.
Re: Rust: Zero-Cost Abstraction in Action
#9Are compiler optimizations like summing a series done on an ad-hoc basis? Certainly the compiler couldn’t have discovered or inferred (not sure what term to use) that formula, no? Just generally curious.
Ad-hoc basis. Usually comes out of studying the most common classes of computation and optimizing for it. For example, the "summing a series" probably falls out of loop optimizations: https://en.wikipedia.org/wiki/Loop_optimization
Re: Rust: Zero-Cost Abstraction in Action
#10For anyone interested in reading more about this, I would recommend Zero Cost Abstractions[1] by withoutboats, who is a contributor to Rust.
1: https://boats.gitlab.io/blog/post/zero-cost-abstractions/