कई कारण हैं कि C ++ परियोजना औसतन अन्य भाषाओं में तुलनीय परियोजनाओं की तुलना में अधिक लंबी है, जैसे कि जावा या सी #। तदनुसार, विधानसभा समय को कम करने के कई तरीके हैं। सबसे अच्छा ज्ञात में से एक precompiled हेडर का उपयोग है। आज मैं आपको बताऊंगा कि कैसे इस पद्धति का उपयोग करने से मुझे अपनी परियोजना के निर्माण समय को काफी कम करने की अनुमति मिली।

इतिहास और सिद्धांत का एक सा

अब कई वर्षों से मैं C ++ में एक परियोजना के विकास में भाग ले रहा हूं। सीएमके पर क्रॉस-प्लेटफॉर्म प्रोजेक्ट, लिनक्स के लिए मुख्य संकलक के रूप में जीसीसी का उपयोग करता है। वर्तमान में, परियोजना कोड की हजारों हजारों से अधिक हो गई है, बूस्ट लाइब्रेरी और कुछ अन्य का गहन उपयोग किया जाता है। समय के साथ, प्रोजेक्ट की असेंबली में अधिक से अधिक समय लगने लगा और परिणामस्वरूप, इंटीग्रेशन सर्वर पर स्क्रैच से पूरे प्रोजेक्ट की पूरी असेंबली में लगभग 45 मिनट लग गए।

बिल्ड प्रक्रिया को अनुकूलित करने के बारे में सोचने का समय है, और मैंने हेडर फ़ाइलों के प्रारंभिक संकलन को पेंच करने का प्रयास करने का निर्णय लिया है। इसके अलावा, CMake 3.16 संस्करण हाल ही में जारी किया गया है, जिसने इस तकनीक के लिए अंतर्निहित समर्थन जोड़ा है।

मैं विस्तार से वर्णन नहीं करूँगा कि पूर्व-संकलन समर्थन कैसे लागू किया जाता है, क्योंकि इस कार्यान्वयन का विवरण संकलक के बीच भिन्न होता है। लेकिन सामान्य शब्दों में, precompilation निम्नानुसार काम करता है। एक हेडर फ़ाइल बनाई जाती है (इसे कॉल करें precompiled.h), जिसमें प्रारंभिक संकलन के लिए हेडर फाइलें शामिल हैं। यह इस हेडर फाइल के आधार पर विशेष PCH-फ़ाइल उत्पन्न ( .pch, .gch, .pchi- संकलक पर निर्भर करता है) है, जो करने के लिए जुड़ा precompiled हेडर का परिणाम होता है precompiled.h। इसके अलावा, यदि कंपाइलर अगली इकाई का निर्माण करते समय समावेशन देखता हैprecompiled.h, तो यह इस फाइल को नहीं पढ़ता और इसका विश्लेषण करता है और इसमें शामिल सभी हेडर फाइलें, लेकिन इसके बजाय पीएसी फाइल से प्रारंभिक संकलन के परिणाम का उपयोग करता है।

, ( 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 .

हेडर को precompiling करने के अलावा, पूर्ण या आंशिक बिल्ड को तेज करने के अन्य तरीके हैं। उनमें से कुछ को स्रोत फ़ाइलों को एक निश्चित तरीके से संपादित करने और व्यवस्थित करने की आवश्यकता होती है (उदाहरण के लिए, अन्य हेडर में अनावश्यक हेडर फ़ाइलों के कनेक्शन को कम करना और उन्हें स्रोत फ़ाइलों में स्थानांतरित करना .cpp)। अन्य लोग ऐसे तरीकों का उपयोग करते हैं जिन्हें स्रोत के संपादन की आवश्यकता नहीं होती है (उदाहरण के लिए, ccache)। Ccache, उदाहरण के लिए, एक पूर्ण प्रोजेक्ट असेंबली के लिए समय को 35 से 3 मिनट तक कम करने की अनुमति है, लेकिन इसके बारे में अधिक, शायद अगली बार।

हेडर फ़ाइलों के प्रारंभिक संकलन के उपयोग के लिए, यह परियोजना के निर्माण समय को कम करने का एक बहुत प्रभावी तरीका है।

CMake + GCC पर एक प्रोजेक्ट बिल्ड को गति देना: हेडर फ़ाइलों का प्रीकम्प्लीमेंट

इतिहास और सिद्धांत का एक सा

More articles: