Get best of the week

加快基于CMake + GCC的项目构建：头文件的预编译

C ++项目平均比其他语言（例如Java或C＃）的同类项目花费更长的时间有几个原因。因此，有几种减少组装时间的方法。最著名的方法之一是使用预编译头。今天，我将告诉您使用这种方法如何使我显着减少项目的构建时间。


一点历史和理论


几年来，我一直在参与C ++项目的开发。CMake上的跨平台项目使用GCC作为Linux的主要编译器。当前，该项目已发展到成千上万行代码，Boost库和其他一些代码被大量使用。随着时间的流逝，项目的组装开始花费越来越多的时间，结果，从头开始在集成服务器上完成整个项目的整个组装花费了将近45分钟。


现在是时候考虑优化构建过程了，我决定尝试破坏头文件的初步编译。此外，最近发布了CMake 3.16版本，该版本增加了对该技术的内置支持。


我不会详细描述如何实现预编译支持，因为此实现的详细信息在编译器之间会有所不同。但是总的来说，预编译的工作方式如下。将创建一个头文件（我们称之为precompiled.h），其中包括用于初步编译的头文件。它产生特殊的PCH-文件基于该头文件（.pch，.gch，.pchi-取决于编译器），其中包含连接到预编译的头的结果precompiled.h。此外，如果编译器在构建下一个单元时看到包含项precompiled.h，则它不会读取和分析此文件及其中包含的所有头文件，而是使用pch文件中的初步编译结果。


将特定头文件包含在候选文件中以进行初步编译的标准（属于precompiled.h），一些。首先，此类文件应该相对很少更改。否则，将过多地重新创建pch文件，这会否定使用预编译的所有好处。首先，创建pch文件本身是一个相对较长的操作。其次，更改pch文件后，您将需要重建所有依赖于该文件的文件。另一个标准是源文件中头文件的使用频率。取决于头文件的单元数越大，预编译此类头文件的含义就越大。同样，头文件本身越大，或头文件包含的其他头文件越多，通常从预编译中获得的收益就越大。


. , . , . , Visual C++ :


//   
#include "stdafx.h"
#include "internal-header.h"
...

( stdafx.h — precompiled.h) , . . , stdafx.h . . .


Visual C++ :


//   
#include <vector>
#include <map>
#include "stdafx.h" // :    
                    //      
#include "internal-header.h"
...

, -, , — . , , , . stdafx.h #ifdef', .


, , GCC , stdafx.h . , #ifdef' stdafx.h, :


//   
#include "stdafx.h"
#include <vector>
#include <map>
#include "internal-header.h"
...

. , (#ifdef guard'), .


, . , precompiled.h stdafx.h, , (force include) (-include GCC /FI Visual C++). , , . .


CMake. CMake 3.16 target_precompiled_headers(). , (target') CMake-. , , stdafx.h precompiled.h, , pch-. -include /FI .


, target_precompiled_headers(<target1> REUSE FROM <target2>), pch- target1, target2. , , target1 target2 , (preprocessor defines).



. , , . , . CMake , "" :


set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CMAKE_COMMAND} -E time")
set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK "${CMAKE_COMMAND} -E time")

:


[ 60%] Building CXX object source1.cpp.o
Elapsed time: 3 s. (time), 0.002645 s. (clock)
[ 64%] Building CXX object source2.cpp.o
Elapsed time: 4 s. (time), 0.001367 s. (clock)
[ 67%] Linking C executable my_target
Elapsed time: 0 s. (time), 0.000672 s. (clock)

, GCC:


-Winvalid-pch -       gch-
-H -

CMake :


add_compile_options(-Winvalid-pch)
add_compile_options(-H)

, GCC -ftime-report:


add_compile_options(-ftime-report)

, :


Execution times (seconds)
 phase setup             :   0.01 ( 4%) usr   0.00 ( 0%) sys   0.01 ( 3%) wall    1223 kB ( 8%) ggc
 phase parsing           :   0.21 (81%) usr   0.10 (100%) sys   0.33 (87%) wall   13896 kB (88%) ggc
 phase opt and generate  :   0.03 (12%) usr   0.00 ( 0%) sys   0.03 ( 8%) wall     398 kB ( 3%) ggc
 phase last asm          :   0.01 ( 4%) usr   0.00 ( 0%) sys   0.01 ( 3%) wall     237 kB ( 2%) ggc
 |name lookup            :   0.05 (19%) usr   0.02 (20%) sys   0.03 ( 8%) wall     806 kB ( 5%) ggc
 |overload resolution    :   0.00 ( 0%) usr   0.01 (10%) sys   0.02 ( 5%) wall      68 kB ( 0%) ggc
 dump files              :   0.00 ( 0%) usr   0.00 ( 0%) sys   0.01 ( 3%) wall       0 kB ( 0%) ggc
 preprocessing           :   0.06 (23%) usr   0.04 (40%) sys   0.12 (32%) wall    1326 kB ( 8%) ggc
 parser (global)         :   0.06 (23%) usr   0.02 (20%) sys   0.11 (29%) wall    6783 kB (43%) ggc
 ...
 TOTAL                 :   0.26             0.10             0.38              15783 kB

- , Python, -, .


, , ( ):


PHASES SUMMARY
   phase opt and generate                   : 1309.1 s. = 21.8 m. ( 50 %)  --->  1577.5 s. = 26.3 m. ( 74 %)
   deferred                                 :  135.0 s. =  2.3 m. (  5 %)  --->   221.4 s. =  3.7 m. ( 10 %)
   integration                              :   62.2 s. =  1.0 m. (  2 %)  --->    85.1 s. =  1.4 m. (  4 %)
   template instantiation                   :  224.3 s. =  3.7 m. (  9 %)  --->   246.5 s. =  4.1 m. ( 12 %)
   callgraph optimization                   :   32.9 s. =  0.5 m. (  1 %)  --->    48.5 s. =  0.8 m. (  2 %)
   unaccounted todo                         :   36.5 s. =  0.6 m. (  1 %)  --->    49.7 s. =  0.8 m. (  2 %)
   |overload resolution                     :   82.1 s. =  1.4 m. (  3 %)  --->    95.2 s. =  1.6 m. (  4 %)
                                                        ...
   parser enumerator list                   :    2.1 s. =  0.0 m. (  0 %)  --->     0.5 s. =  0.0 m. (  0 %)
   parser function body                     :   32.0 s. =  0.5 m. (  1 %)  --->     9.3 s. =  0.2 m. (  0 %)
   garbage collection                       :   55.3 s. =  0.9 m. (  2 %)  --->    16.7 s. =  0.3 m. (  1 %)
   |name lookup                             :  132.8 s. =  2.2 m. (  5 %)  --->    63.5 s. =  1.1 m. (  3 %)
   body                                     :   87.5 s. =  1.5 m. (  3 %)  --->    18.2 s. =  0.3 m. (  1 %)
   parser struct body                       :  113.4 s. =  1.9 m. (  4 %)  --->    21.1 s. =  0.4 m. (  1 %)
   parser (global)                          :  158.0 s. =  2.6 m. (  6 %)  --->    25.8 s. =  0.4 m. (  1 %)
   preprocessing                            :  548.1 s. =  9.1 m. ( 21 %)  --->    88.0 s. =  1.5 m. (  4 %)
   phase parsing                            : 1119.7 s. = 18.7 m. ( 43 %)  --->   228.3 s. =  3.8 m. ( 11 %)
  TOTAL : 2619.2 s. = 43.7 m.  --->  2118.4 s. = 35.3 m.

, (parsing, preprocessing). , . , , . , , .


. . Boost . , . , , Boost. . , Boost. — , Boost, , .


pch- , target_precompiled_headers(<target1> REUSE FROM <target2>). .



, , 43 35 .


除了预编译头文件外，还有其他方法可以加快完整或部分构建的速度。其中一些需要以某种方式编辑和组织源文件（例如，减少其他头文件中不必要的头文件的连接并将它们移动到源文件中.cpp）。其他人则使用不需要编辑源代码的方法（例如，ccache）。例如，Ccache允许将一个完整的项目组装时间从35分钟减少到3分钟，但是更多的时间可能是在下一次。


至于头文件的初步编译，这是减少项目构建时间的非常有效的方法。

More articles:


All Articles