7

Running: gcc version 4.2.1 (Apple Inc. build 5664)

I created an apple XCode project with a default precompiled header. It appears to be very slow, and a trivial main file with a main function no includes no code takes 6 seconds to compile, which is after I upgraded to a new SSD drive. I am on a laptop, but I have reservations that upgrading to a workstation would alleviate my problem. If I turn off the precompiled header then the main file compiles in under a second. It appears that using a precompiled header puts a penalty across all files. This delay is makes me want to avoid compiling and experimenting with code which is not good. Here is what I am including in my precompiled header:

#pragma once

#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <valarray>
#include <vector>

#include <boost/smart_ptr/scoped_ptr.hpp>
#include <boost/smart_ptr/scoped_array.hpp>
#include <boost/smart_ptr/shared_ptr.hpp>
#include <boost/smart_ptr/shared_array.hpp>
#include <boost/smart_ptr/make_shared.hpp>  
#include <boost/smart_ptr/weak_ptr.hpp>
#include <boost/smart_ptr/intrusive_ptr.hpp>

#include <boost/regex.hpp>
#include <boost/thread.hpp>
#include <boost/bind/bind.hpp>
#include <boost/bind/apply.hpp>
#include <boost/bind/protect.hpp>
#include <boost/bind/make_adaptable.hpp>

#include <boost/asio.hpp>
//#include <boost/asio/ssl.hpp>


#include <boost/property_tree/ptree.hpp>
#include <boost/random.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/date_time/gregorian/gregorian.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/date_time/local_time/local_time.hpp>
#include <boost/date_time/time_zone_base.hpp>
#include <boost/circular_buffer.hpp>
#include <boost/accumulators/accumulators.hpp>
#include <boost/accumulators/statistics.hpp>

I have not included spirit, which really makes the compile time go up.

user805547
  • 1,245
  • 1
  • 15
  • 23
  • So a "trivial main file with a main function no includes no code" takes a lot less time to compile than a project with all the includes listed above? Should that not be expected? – jedwards Jun 09 '12 at 07:01
  • Also, my understanding of precompiled headers is that they only tend to save compile time when otherwise they'd be compiled repeatedly, through `include`s from multiple sources. This is not the case for you, so I'd imagine your compile time with using precompiled headers would be similar to without. That is, you wouldn't realize much of a gain by using precompiled headers. You really should limit your includes to what you need on a source-file-specific basis. – jedwards Jun 09 '12 at 07:07
  • And what does this mean: "This delay is makes me want to avoid compiling and experimenting with code which is not good."? – jedwards Jun 09 '12 at 07:07

1 Answers1

8

GCC's precompiled headers work in a very particular way. Only one precompiled header file can be used in any given source file. Use -H to show whether a given header file is using a precompiled version or not.

Moreover, you must compile the header file with the exact same compiler flags as the source file that uses it.

The typical way to set up a PCH environment is like this:

main.cpp:

#include "allheaders.hpp"

int main() { /* ... */ }

allheaders.hpp:

#include <algorithm>
// ... everything you need

Compilation:

g++ $CXXFLAGS allheaders.hpp                 # 1
g++ $CXXFLAGS -H -c -o main.o main.cpp       # 2
g++ $LDFLAGS -o myprogram main.o             # 3

After Step #1 you should end up with a file allheaders.hpp.gch, which should be pretty big. In Step #2 the -H flag should produce additional output that tells you that the precompiled header file is being used. Step #3 links the executable.

The idea is that Step #1 can potentially take a very long time, but Step #2 should become a lot faster.

Kerrek SB
  • 464,522
  • 92
  • 875
  • 1,084
  • 1
    I have analyzed the GCC command and it is referencing a 308 MB pseudo-text file that appears to be a processed precompiled header. The precompiled header is auto-included for every source file, which some people don't seem to get, and introduces a latency of about 6 seconds. I do not recall having this problem with visual studio although with VS I always run it on a beefier workstation. A 6 second lag-time when I change one letter in a file is unacceptable and adds up to minutes/hours/days of wasted time over the development cycle. – user805547 Jun 09 '12 at 12:26
  • Well, you should be sort of smart about which headers to precompile. Of course you shouldn't have a single one-size-fits-all PCH. Ideally you'd make a separate "all headers" header for *every* source file individually. Practically, I'd reserve that treatment for those files which actually implement all the heavy Boost stuff. – Kerrek SB Jun 09 '12 at 12:48
  • I use boost pretty much everywhere so not putting these in the PCH will just cause individual files to compile slowly. I am starting to think that this laptop and software is too slow for serious C++ development. It's fine for Cocoa but Boost and its heavy use of templates and metaprogramming is a killer. – user805547 Jun 09 '12 at 12:53
  • Seeing your precompiled header, you could stand to refactor some of those Boost Utilities into their own little implementation files. For some tasks, Boost is pretty much a thornyard of `#define` and `#include` with just a little code in between, like for `scoped_ptr<>` that can just be implemented in its own little header, with (almost) no dependencies and no compiler-dependant decisions and no sweat. Regrouping and refactoring Boost utilities has saved me about ~35% compile time and ~80% "headache from reading source" time. – Luis Machuca Jun 09 '12 at 17:06