Há várias razões pelas quais um projeto C ++ está, em média, demorando mais do que projetos comparáveis em outras linguagens, como Java ou C #. Conseqüentemente, existem várias maneiras de reduzir o tempo de montagem. Um dos mais conhecidos é o uso de cabeçalhos pré-compilados. Hoje vou lhe dizer como o uso desse método me permitiu reduzir significativamente o tempo de construção do meu projeto.
Um pouco de história e teoria
Há vários anos, participo do desenvolvimento de um projeto em C ++. O projeto de plataforma cruzada, no CMake, usa o GCC como o principal compilador para Linux. Atualmente, o projeto cresceu para mais de centenas de milhares de linhas de código, a biblioteca Boost e algumas outras são usadas intensivamente. Com o tempo, a montagem do projeto começou a demorar cada vez mais e, como resultado, a montagem completa de todo o projeto do zero no servidor de integração levou quase 45 minutos.
É hora de pensar em otimizar o processo de compilação e decidi tentar estragar a compilação preliminar dos arquivos de cabeçalho. Além disso, a versão do CMake 3.16 foi lançada recentemente, o que adicionou suporte interno a essa técnica.
Não descreverei em detalhes como o suporte à pré-compilação é implementado, pois os detalhes dessa implementação variam entre os compiladores. Mas, em termos gerais, a pré-compilação funciona da seguinte maneira. Um arquivo de cabeçalho é criado (vamos chamá-lo precompiled.h), que inclui os arquivos de cabeçalho para compilação preliminar. Gerou-PCH ficheiro especial com base neste ficheiro de cabeçalho ( .pch, .gch, .pchi- dependendo do compilador), que contém o resultado da pré-compilado cabeçalhos ligados a precompiled.h. Além disso, se o compilador vir a inclusão ao criar a próxima unidadeprecompiled.h, ele não lê e analisa esse arquivo e todos os arquivos de cabeçalho incluídos nele, mas usa o resultado da compilação preliminar do arquivo 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 .
Além de pré-compilar cabeçalhos, existem outras maneiras de acelerar compilações totais ou parciais. Alguns deles requerem edição e organização dos arquivos de origem de uma certa maneira (por exemplo, reduzindo a conexão de arquivos de cabeçalho desnecessários em outros cabeçalhos e movendo-os para os arquivos de origem .cpp). Outros usam abordagens que não exigem edição da fonte (por exemplo, ccache). O Ccache, por exemplo, permitiu reduzir o tempo para uma montagem completa do projeto de 35 para 3 minutos, mas mais sobre isso, talvez da próxima vez.
Quanto ao uso da compilação preliminar de arquivos de cabeçalho, essa é uma maneira muito eficaz de reduzir o tempo de construção do projeto.