Hay varias razones por las que un proyecto de C ++ tarda más que proyectos comparables en otros lenguajes, como Java o C #. En consecuencia, hay varias formas de reducir el tiempo de montaje. Uno de los más conocidos es el uso de encabezados precompilados. Hoy les diré cómo usar este método me permitió reducir significativamente el tiempo de construcción de mi proyecto.
Un poco de historia y teoría.
Desde hace varios años participo en el desarrollo de un proyecto en C ++. El proyecto multiplataforma, en CMake, utiliza GCC como el compilador principal para Linux. Actualmente, el proyecto ha crecido a más de cientos de miles de líneas de código, la biblioteca Boost y algunas otras se usan de manera intensiva. Con el tiempo, el ensamblaje del proyecto comenzó a tomar más y más tiempo, y como resultado, el ensamblaje completo de todo el proyecto desde cero en el servidor de integración tomó casi 45 minutos.
Es hora de pensar en optimizar el proceso de compilación, y decidí intentar atornillar la compilación preliminar de los archivos de encabezado. Además, recientemente se lanzó la versión CMake 3.16, que agregó soporte incorporado para esta técnica.
No describiré en detalle cómo se implementa el soporte de precompilación, ya que los detalles de esta implementación varían entre los compiladores. Pero en términos generales, la precompilación funciona de la siguiente manera. Se crea un archivo de encabezado (llamémoslo precompiled.h), que incluye los archivos de encabezado para la compilación preliminar. Se generó PCH-archivo especial en base a este archivo de cabecera ( .pch, .gch, .pchi- dependiendo del compilador), que contiene el resultado de los encabezados precompilados conectados a precompiled.h. Además, si el compilador ve la inclusión al construir la siguiente unidadprecompiled.h, luego no lee ni analiza este archivo ni todos los archivos de encabezado incluidos, sino que utiliza el resultado de la compilación preliminar del archivo 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 .
Además de precompilar encabezados, hay otras formas de acelerar las compilaciones completas o parciales. Algunos de ellos requieren editar y organizar los archivos de origen de una determinada manera (por ejemplo, reducir la conexión de archivos de encabezado innecesarios en otros encabezados y moverlos a los archivos de origen .cpp). Otros usan enfoques que no requieren editar la fuente (por ejemplo, ccache). Ccache, por ejemplo, permitió reducir el tiempo para un ensamblaje completo del proyecto de 35 a 3 minutos, pero más sobre eso, tal vez la próxima vez.
En cuanto al uso de la compilación preliminar de los archivos de encabezado, esta es una forma muy efectiva de reducir el tiempo de compilación del proyecto.