Rust Compilation Speed

Some notes on rust compilation options and the effect on compile times of a moderate sized rust application (5000 lines). This looks at tweaking options in .cargo/config aswell as the Cargo.toml file.

An example .cargo/config file:

[build]
rustflags = ["-C", "target-cpu=native"]
rustc-wrapper = "sccache"

[target.x86_64-pc-windows-msvc]
linker = "rust-lld.exe"

[target.x86_64-unknown-linux-gnu]
linker = "/usr/bin/clang"
rustflags = ["-Clink-arg=-fuse-ld=lld"]

[profile.dev.package."*"]
opt-level = 3

These tests run in the following environment:

• Rust v1.55, CPU 12 core Ryzen 5900x, RAM 32GB, NVM SSD
• Using the faster lld linker unless specified
• Using the target-cpu=native option
• Dependencies are already downloaded, so only looking at compiling/linking time
• Debug opt-levels only apply to third party code to help compile iteration times

Full Rebuild Performance

• Debug can full rebuild slower than Release mode, incremental compilation is off by default for Release, but it’s still surprising
• debug levels of 0 and 1 (line number tables only) are similar, default full debug true is clearly slower (but actually useful in a debugger)
• The lto (link time optimization) option has more performance per compile time than decreasing codegen-units units (lower parallelism creates faster code/slower compile due to more optimisation context given to that codegen unit).
• The lto = thin setting can be almost as fast as the less optimized no lto
• With lto set to true or full it globally optimizes every crate in the binary, so can be heavy on RAM usage and doesn’t scale well with project size
• Using sccache may pay off for repeated full rebuilds, especially if you have a fast storage device to access the 10GB shared compilation cache. It works across projects and local build cleans. It’s less important for incremental compilation / iteration.
• sccache is not that fast with the default linker on Windows - use the faster lld linker.
• Looking at sccache stats sccache -s shows that there are some cache misses when incremental compilation is used (default in debug) and depending on the crate type, it’s just not cacheable
• sccache did not help release build with low codegen-units, so unless it’s your final optimized release build prefer the default codegen-units

Incremental Build Performance

Running cargo build after editing a string in the source code. If you just need to know if the code is correct you can run cargo check, which is much quicker, but your editor/IDE is probably already doing that.

Apart from ensuring we are using the lld linker the main speed up comes from reducing the debug level. If you can get by with line numbers only for symbols then debug = 1 instead of the default debug = true is a good idea.

Debug Code Performance

As mentioned, debug opt-levels are only applied to third party code to help compile iteration times. Opt level 0 is the default level for the dev profile with up to level 3 being full optimizations. Level 2 will unroll loops, potentially making debugging confusing. Level 3 does more vectorization and inlining. When using a debugger consider going to opt-level 0 or 1.