I am using Visual Studio, and it seems that getting rid of unused references and using statements speeds up my build time on larger projects. Are there other known ways of speeding up build time. What about for other languages and build environments?
What is typically the bottleneck during build/compile? Disk, CPU, Memory?
What is a list of/are good references for distributed builds?
Visual Studio supports parallel builds, which can help, but the true bottleneck is Disk IO.
In C for instance - if you generate LST files your compile will take ages.
At my previous job we had big problems with compilation time and one of the strategies we used was called the Envelope pattern see here.
Basically it attempts to minimize the amount of code copied in headers by the pre-processor by minimizing header size. It did this by moving anything that wasn't public to a private friend class, here's an example.
foo.h:
class FooPrivate;
class Foo
{
public:
Foo();
virtual ~Foo();
void bar();
private:
friend class FooPrivate;
FooPrivate *foo;
};
foo.cpp:
Foo::Foo()
{
foo = new FooPrivate();
}
class FooPrivate
{
int privData;
char *morePrivData;
};
The more include files you do this with the more it adds up. It really does help your compilation time.
It does make things difficult to debug in VC6 though as I learned the hard way. There's a reason it's a previous job.
The biggest improvement we made for our large C++ project was from distributing our builds. A couple of years ago, a full build would take about half an hour, while it's now about three minutes, of which one third is link time.
We're using a proprietary build system, but IncrediBuild is working fine for a lot of people (we couldn't get it to work reliably).
Hope this helps.
Regards,
Sebastiaan
If you're using a lot of files and a lot of templated code (STL / BOOST / etc.), then Bulk or Unity builds should cut down on build and link times.
The idea of Bulk Builds to break your project down into subsections and include all the CPP files in that subsection into a single file. Unity builds take this further by having a Single CPP file that is compiled that inludes all other CPP files.
The reason this is often faster is:
1) Templates are only evaluated once per Bulk File
2) Include files are opened / processed only once per Bulk File (assuming there is a proper #ifndef FILE__FILENAME__H / #define FILE__FILENAME__H / #endif wrapper in the include file). Reducing total I/O is a good thing for compile times.
3) The linker has much less data to work with (Single Unity OBJ file or several Bulk OBJ files) and is less likely to page to virtual memory.
EDIT Adding a couple of links here on stack overflow about Unity Builds.
Be wary of broad-sweeping "consider this directory and all subdirectories for header inclusion" type settings in your project. This will cause the compiler to have to iterate every directory until the header file requested is found, and can be a very expensive operation for however many headers you include in your project.