如何加快C++代码的编译速度 转 ccache

http://www.cnblogs.com/baiyanhuang/archive/2010/01/17/1730717.html

 

C++代码一直以其运行时的高性能高调面对世人， 但是说起编译速度，却只有低调的份了。比如我现在工作的源代码，哪怕使用Incredibuild调动近百台机子，一个完整的build也需要四个小时，恐怖！！！虽然平时开发一般不需要在本地做完整的build，但编译几个相关的工程就够你等上好一段时间的了（老外管这个叫monkey around，相当形象）。想想若干年在一台单核2.8GHZ上工作时的场景 - 面前放本书，一点build按钮，就低头读一会书~~~往事不堪回首。

可以想象，如果不加以重视，编译速度极有可能会成为开发过程中的一个瓶颈。那么，为什么C++它就编译的这么慢呢？

我想最重要的一个原因应该是C++基本的"头文件-源文件"的编译模型：

1. 每个源文件作为一个编译单元，可能会包含上百甚至上千个头文件，而在每一个编译单元，这些头文件都会被从硬盘读进来一遍，然后被解析一遍。
2. 每个编译单元都会产生一个obj文件，然后所以这些obj文件会被link到一起，并且这个过程很难并行。

这里，问题在于无数头文件的重复load与解析，以及密集的磁盘操作。

下面从各个角度给出一些加快编译速度的做法，主要还是针对上面提出的这个关键问题。

代码角度

• 在头文件中使用前置声明，而不是直接包含头文件。 
  不要以为你只是多加了一个头文件，由于头文件的"被包含"特性，这种效果可能会被无限放大。所以，要尽一切可能使头文件精简。很多时候前置申明某个namespace中的类会比较痛苦，而直接include会方便很多，千万要抵制住这种诱惑；类的成员，函数参数等也尽量用引用，指针，为前置声明创造条件。
• 使用Pimpl模式 
  Pimpl全称为Private Implementation。传统的C++的类的接口与实现是混淆在一起的，而Pimpl这种做法使得类的接口与实现得以完全分离。如此，只要类的公共接口保持不变，对类实现的修改始终只需编译该cpp；同时，该类提供给外界的头文件也会精简许多。
• 高度模块化 
  模块化就是低耦合，就是尽可能的减少相互依赖。这里其实有两个层面的意思。一是文件与文件之间，一个头文件的变化，尽量不要引起其他文件的重新编译；二是工程与工程之间，对一个工程的修改，尽量不要引起太多其他工程的编译。这就要求头文件，或者工程的内容一定要单一，不要什么东西都往里面塞，从而引起不必要的依赖。这也可以说是内聚性吧。

  以头文件为例，不要把两个不相关的类，或者没什么联系的宏定义放到一个头文件里。内容要尽量单一，从而不会使包含他们的文件包含了不需要的内容。记得我们曾经做过这么一个事，把代码中最"hot"的那些头文件找出来，然后分成多个独立的小文件，效果相当可观。

  其实我们去年做过的refactoring，把众多DLL分离成UI与Core两个部分，也是有着相同的效果的 - 提高开发效率。

• 删除冗余的头文件 
  一些代码经过上十年的开发与维护，经手的人无数，很有可能出现包含了没用的头文件，或重复包含的现象，去掉这些冗余的include是相当必要的。当然，这主要是针对cpp的，因为对于一个头文件，其中的某个include是否冗余很难界定，得看是否在最终的编译单元中用到了，而这样又可能出现在一个编译单元用到了，而在另外一个编译单元中没用到的情况。 
  之前曾写过一个Perl脚本用来自动去除这些冗余的头文件，在某个工程中竟然去掉多达了5000多个的include。
• 特别注意inline和template 
  这是C++中两种比较"先进"的机制，但是它们却又强制我们在头文件中包含实现，这对增加头文件的内容，从而减慢编译速度有着很大的贡献。使用之前，权衡一下。

综合技巧

• 预编译头文件（PCH） 
  把一些常用但不常改动的头文件放在预编译头文件中。这样，至少在单个工程中你不需要在每个编译单元里一遍又一遍的load与解析同一个头文件了。
• Unity Build 
  Unity Build做法很简单，把所有的cpp包含到一个cpp中(all.cpp) ,然后只编译all.cpp。这样我们就只有一个编译单元，这意味着不需要重复load与解析同一个头文件了，同时因为只产生一个obj文件，在链接的时候也不需要那么密集的磁盘操作了,估计能有10x的提高，看看这个视频感受一下其做法与速度吧。
• ccache 
  compiler cache, 通过cache上一次编译的结果，使rebuild在保持结果相同的情况下，极大的提高速度。我们知道如果是build，系统会对比源代码与目标代码的时间来决定是否要重新编译某个文件，这个方法其实并不完全可靠(比如从svn上拿了上个版本的代码)，而ccache判断的原则则是文件的内容，相对来讲要可靠的多。很可惜的是，Visual Studio现在还不支持这个功能 - 其实完全可以加一个新的命令，比如cache build，介于build与rebuild之间，这样，rebuild就可以基本不用了。
• 不要有太多的Additional Include Directories 
  编译器定位你include的头文件，是根据你提供的include directories进行搜索的。可以想象，如果你提供了100个包含目录，而某个头文件是在第100个目录下，定位它的过程是非常痛苦的。组织好你的包含目录，并尽量保持简洁。

编译资源

要提高速度，要么减少任务，要么加派人手，前面两个方面讲得都是减少任务，而事实上，在提高编译速度这块，加派人手还是有着非常重要的作用的。

• 并行编译 
  买个4核的，或者8核的cpu，每次一build，就是8个文件并行着编，那速度，看着都爽。 要是你们老板不同意，让他读读这篇文章：Hardware is Cheap, Programmers are Expensive
• 更好的磁盘 
  我们知道，编译速度慢很大一部分原因是磁盘操作，那么除了尽可能的减少磁盘操作，我们还可以做的就是加快磁盘速度。比如上面8个核一块工作的时候，磁盘极有可能成为最大的瓶颈。买个15000转的磁盘，或者SSD，或者RAID0的，总之，越快越好。
• 分布式编译 
  一台机子的性能始终是有限的，利用网络中空闲的cpu资源，以及专门用来编译的build server来帮助你编译才能从根本上解决我们编译速度的问题，想想原来要build 1个多小时工程的在2分钟内就能搞定，你就知道你一定不能没有它 -Incredibuild。
• 并行，其实还可以这么做。 
  这是一个比较极端的情况，如果你用了Incredibuild，对最终的编译速度还是不满意，怎么办？其实只要跳出思维的框架，编译速度还是可以有质的飞跃的 - 前提是你有足够多的机器：
  

  假设你有solution A和solution B，B依赖于A，所以必须在A之后Build B。其中A，B Build各需要1个小时，那么总共要2个小时。可是B一定要在A之后build吗？跳出这个思维框架，你就有了下述方案：

  • 同时开始build A和B 。
  • A的build成功，这里虽然B的build失败了，但都只是失败在最后的link上。
  • 重新link B中的project。

  这样，通过让A的build与B的编译并行，最后link一下B中的project，整个编译速度应该能够控制在1个小时15分钟之内。

另外，这本书谈了很多这方面的内容：大规模C++程序设计。

 

 

CCache

Using CCache to speed up compilation

CCache is nothing more than a cache for your compiler. ccache is usually very easy to install. Here’s an example for Ubuntu systems:
sudo apt-get install ccache
ccache will cache previous compilations, detect when the same compilation is being done again, and reuse its cache instead of recompiling the source code again. This can speed up your compilation by many orders of magnitude, especially in those situations where your file timestamps change, and make is triggering a recompile.
To enable ccache, simply add ‘/usr/lib/ccache’ to the beginning of your PATH. This directory contains symlinks to ccache, and ccache is smart enough to look at the name of the calling executable to determine which real executable to run. I.e. there is a symlink from ‘/usr/lib/ccache/g++’ to just ‘ccache’, but it actually runs the equivalent of ‘ccache g++’.
Using colorgcc to colorize output

colorgcc is a colorizer for the output of GCC, and allows you to better interpret the compiler warnings/errors.
To enable both colorgcc and ccache, perform the following steps:
Install colorgcc on an Ubuntu system with
sudo apt-get install colorgcc
To enable colorgcc, perform the following steps:
cp /etc/colorgcc/colorgccrc $HOME/.colorgccrc
edit the $HOME/.colorgccrc file, search for the following lines:
g++: /usr/bin/g++
gcc: /usr/bin/gcc
c++: /usr/bin/g++
cc: /usr/bin/gcc
g77: /usr/bin/g77
f77: /usr/bin/g77
gcj: /usr/bin/gcj
and replace them with:
g++: ccache /usr/bin/g++
gcc: ccache /usr/bin/gcc
c++: ccache /usr/bin/g++
cc: ccache /usr/bin/gcc
g77: ccache /usr/bin/g77
f77: ccache /usr/bin/g77
gcj: ccache /usr/bin/gcj
create a $HOME/bin or $HOME/sbin directory, and create the following softlinks in it
ln -s /usr/bin/colorgcc c++
ln -s /usr/bin/colorgcc cc
ln -s /usr/bin/colorgcc g++
ln -s /usr/bin/colorgcc gcc
make sure that $HOME/bin or $HOME/sbin is the first directory in your $PATH, e.g.:
export PATH=$HOME/bin:$PATH
or:
export PATH=$HOME/sbin:$PATH
depending on where you stored the colorgcc softlinks, so that when cc/gcc/g++/c++ is invoked the freshly created softlinks get activated first and not the global /usr/bin/{cc,gcc,g++,c++}.