How to speed up Compile Time of my CMake enabled C++ Project?

by

Here’s what I had good results with using CMake and Visual Studio or GNU toolchains:

  1. Exchange GNU make with Ninja. It’s faster, makes use of all available CPU cores automatically and has a good dependency management. Just be aware of

    a.) You need to setup the target dependencies in CMake correctly. If you get to a point where the build has a dependency to another artifact, it has to wait until those are compiled (synchronization points).

    $ time -p cmake -G "Ninja" ..
-- The CXX compiler identification is GNU 4.8.1
...
real 11.06
user 0.00
sys 0.00

$ time -p ninja
...
[202/202] Linking CXX executable CMakeTest.exe
real 40.31
user 0.01
sys 0.01

    b.) Linking is always such a synchronization point. So you can make more use of CMake’s Object Libraries to reduce those, but it makes your CMake code a little bit uglier.

    $ time -p ninja
...
[102/102] Linking CXX executable CMakeTest.exe
real 27.62
user 0.00
sys 0.04

  2. Split less frequently changed or stable code parts into separate CMake projects and use CMake’s ExternalProject_Add() or – if you e.g. switch to binary delivery of some libraries – find_library().

  3. Think of a different set of compiler/linker options for your daily work (but only if you also have some test time/experience with the final release build options).

    a.) Skip the optimization parts

    b.) Try incremental linking

  4. If you often do changes to the CMake code itself, think about rebuilding CMake from sources optimized for your machine’s architecture. CMake’s officially distributed binaries are just a compromise to work on every possible CPU architecture.

    When I use MinGW64/MSYS to rebuild CMake 3.5.2 with e.g.

    cmake -DCMAKE_BUILD_TYPE:STRING="Release"
      -DCMAKE_CXX_FLAGS:STRING="-march=native -m64 -Ofast -flto" 
      -DCMAKE_EXE_LINKER_FLAGS:STRING="-Wl,--allow-multiple-definition"
      -G "MSYS Makefiles" ..

    I can accelerate the first part:

    $ time -p [...]/MSYS64/bin/cmake.exe -G "Ninja" ..
real 6.46
user 0.03
sys 0.01

  5. If your file I/O is very slow and since CMake works with dedicated binary output directories, make use of a RAM disk. If you still use a hard drive, consider switching to a solid state disk.

  6. Depending of your final output file, exchange the GNU standard linker with the Gold Linker. Even faster than Gold Linker is lld from the LLVM project. You have to check whether it supports already the needed features on your platform.

  7. Use Clang/c2 instead of Visual C++ compiler. For the Visual C++ compiler performance recommendations are provided from the Visual C++ team, see https://blogs.msdn.microsoft.com/vcblog/2016/10/26/recommendations-to-speed-c-builds-in-visual-studio/

  8. Increadibuild can boost the compilation time.

References

More Related Contents:

  1. Speed up the loop operation in R
  2. One could use a profiler, but why not just halt the program? [closed]
  3. Spark functions vs UDF performance?
  4. Why does changing 0.1f to 0 slow down performance by 10x?
  5. Adding a redundant assignment speeds up code when compiled without optimization
  6. Why is this SSE code 6 times slower without VZEROUPPER on Skylake?
  7. How many Include I can use on ObjectSet in EntityFramework to retain performance?
  8. Faster way to find the first empty row in a Google Sheet column
  9. 32-byte aligned routine does not fit the uops cache
  10. Why is SSE scalar sqrt(x) slower than rsqrt(x) * x?
  11. Haskell foldl’ poor performance with (++)
  12. Which Intel microarchitecture introduced the ADC reg,0 single-uop special case?
  13. Storing Documents as Blobs in a Database – Any disadvantages?
  14. Can modern x86 implementations store-forward from more than one prior store?
  15. Cellfun versus Simple Matlab Loop performance
  16. timing code in matlab
  17. Minimizing overhead due to the large number of Numpy dot calls
  18. Simulating Slow Internet Connection [closed]
  19. Compiling a static executable with CMake
  20. What is the difference between spark.sql.shuffle.partitions and spark.default.parallelism?
  21. What’s the actual effect of successful unaligned accesses on x86?
  22. Getting total row count from OFFSET / FETCH NEXT
  23. How to find pair with kth largest sum?
  24. Does Scala support tail recursion optimization?
  25. MongoDB ‘count()’ is very slow. How do we refine/work around with it?
  26. Memory Allocation/Deallocation Bottleneck?
  27. Move all odd positioned element to left half and even positioned to right half in-place
  28. preallocate list in R
  29. How to analyze golang memory?
  30. How to avoid Query Plan re-compilation when using IEnumerable.Contains in Entity Framework LINQ queries?

Leave a Comment