cmake: compilation statistics per transation unit

Question

I need to figure out which translation units need to be restructured to improve compile times, How do I get hold of the compilation time, using cmake, for my translation units ?

Answer 1

Following properties could be used to time compiler and linker invocations:

• RULE_LAUNCH_COMPILE
• RULE_LAUNCH_CUSTOM
• RULE_LAUNCH_LINK

Those properties could be set globally, per directory and per target. That way you can only have a subset of your targets (say tests) to be impacted by this property. Also you can have different "launchers" for each target that also could be useful.

Keep in mind, that using "time" directly is not portable, because this utility is not available on all platforms supported by CMake. However, CMake provides "time" functionality in its command-line tool mode. For example:

# Set global property (all targets are impacted)
set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CMAKE_COMMAND} -E time")
# Set property for my_target only
set_property(TARGET my_target PROPERTY RULE_LAUNCH_COMPILE "${CMAKE_COMMAND} -E time")

Example CMake output:

[ 65%] Built target my_target
[ 67%] Linking C executable my_target
Elapsed time: 0 s. (time), 0.000672 s. (clock)

Note, that as of CMake 3.4 only Makefile and Ninja generators support this properties.

Also note, that as of CMake 3.4 cmake -E time has problems with spaces inside arguments. For example:

cmake -E time cmake "-GUnix Makefiles"

will be interpreted as:

cmake -E time cmake "-GUnix" "Makefiles"

I submitted patch that fixes this problem.

Answer 2

I would expect to replace the compiler (and/or linker) with 'time original-cmd'. Using plain 'make', I'd say:

make CC="time gcc"

The 'time' program would run the command and report on the time it took. The equivalent mechanism would work with 'cmake'. If you need to capture the command as well as the time, then you can write your own command analogous to time (a shell script would do) that records the data you want in the way you want.

Answer 3

To expand on the previous answer, here's a concrete solution that I just wrote up — which is to say, it definitely works in practice, not just in theory, but it has been used by only one person for approximately three minutes, so it probably has some infelicities.

#!/bin/bash
{ time clang "$@"; } 2> >(cat <(echo "clang $@") - >> /tmp/results.txt)

I put the above two lines in /tmp/time-clang and then ran

chmod +x /tmp/time-clang
cmake .. -DCMAKE_C_COMPILER=/tmp/time-clang
make

You can use -DCMAKE_CXX_COMPILER= to hook the C++ compiler in exactly the same way.

• I didn't use make -j8 because I didn't want the results to get interleaved in weird ways.

• I had to put an explicit hashbang #!/bin/bash on my script because the default shell (dash, I think?) on Ubuntu 12.04 wasn't happy with those redirection operators.

Answer 4

I think that the best option is to use:

set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "time -v")
set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK "time -v")

Despite what has been said above:

Keep in mind, that using "time" directly is not portable, because this utility is not available on all platforms supported by CMake. However, CMake provides "time"... https://stackoverflow.com/a/34888291/5052296

If your system contain it, you will get much better results with the -v flag.

e.g.

time -v  /usr/bin/c++     CMakeFiles/basic_ex.dir/main.cpp.o  -o basic_ex 
    Command being timed: "/usr/bin/c++ CMakeFiles/basic_ex.dir/main.cpp.o -o basic_ex"
    User time (seconds): 0.07
    System time (seconds): 0.01
    Percent of CPU this job got: 33%
    Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.26
    Average shared text size (kbytes): 0
    Average unshared data size (kbytes): 0
    Average stack size (kbytes): 0
    Average total size (kbytes): 0
    Maximum resident set size (kbytes): 16920
    Average resident set size (kbytes): 0
    Major (requiring I/O) page faults: 0
    Minor (reclaiming a frame) page faults: 6237
    Voluntary context switches: 7
    Involuntary context switches: 23
    Swaps: 0
    File system inputs: 0
    File system outputs: 48
    Socket messages sent: 0
    Socket messages received: 0
    Signals delivered: 0
    Page size (bytes): 4096
    Exit status: 0