I tend to write rather large templated header-only C++ libraries and my users commonly complain about compilation times. After thinking about the matter, it occurred to me that I have no idea where the time is going. Is there some simple way to profile the C++ compilation process with common compilers, such as g++, icc, and xlC? For instance, is it possible to get an idea of how much time is spent within each of the phases of C++ compilation?
For GCC there are debugging options to find
how much time is spent within each of the phases of C++ compilation?
Makes the compiler print out each function name as it is compiled, and print some statistics about each pass when it finishes.
Makes the compiler print some statistics about the time consumed by each pass when it finishes.
Passes are described in GCCINT 9: Passes and Files of the Compiler.
For compilers other than GCC (or GCC more ancient than 3.3.6) see the other options in this thread.
There’s a tool from the Boost project, which could be useful for pretty much any compiler and build system.
The tool requires source code instrumentation with
TEMPLATE_PROFILE_EXIT() macro calls. These macros then generate specific diagnostics (warnings) at compile-time, which are timed and collected along with instantiation callstacks (which consequently allow building and visualizing callgraphs) by a script. Not bad, IMO.
I didn’t use it yet though.
You can separate them out to some extent (I’m assuming
- add a build rule that only preprocesses files (using the
-Eswitch), and a
.PHONYtarget that depends on the preprocessor output files just like the normal binary target depends on
.ofiles. Measure how long it takes to build this target
- add a
'PHONYtarget that depends on all the
.ofiles but doesn’t link them. Measure how long it takes to build this target (from clean)
- measure how long it takes to do a clean build of the usual binary
Now you have some idea how long it takes to pre-process, compile, and link. You can also compare optimized and non-optimized (
-O0) versions of the second and third target, to see how long is spent in the optimizer.
I have not yet tried it, but templight looks VERY promising: https://github.com/mikael-s-persson/templight
You might be able to get some traction with some variant on
strace -e trace=process -f -r -ttt -T, at least for compilers like g++ that are broken up into many processes.