C++Talk.NET

Allan Odgaard · Guest

The standard library (STL) implementations which I am familiar with
all seem to concern themselve with generating the best possible code
-- e.g. unfolding std::find when handed random access iterators, using
memcpy for std::copy when the iterators are pointers etc.

This result in a lot of code which affect compile time (and also code
size, since the standard algorithms are maybe 10 lines instead of 3).
A simple program like the following, using some standard includes:

#include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <string>
#include <vector>

int main (int argc, char const* argv[])
{
return 0;
}

Takes 4-5 seconds to compile on my 733 MHz G4, using gcc 3.3 from
Apple (after the headers have been cached). Since these files are
probably included in most of my sources, it would seem that the
minimum compile time for any of my sources is around 5 seconds, which
is a rather high price IMHO.

Including only vector takes around a second, whereas writing my own
(partly complying) std::vector replacement takes virtually no time to
compile.

So I was curious if others have investigated this subject? and if
anyone knows of a simpler STL implementation? I would certainly favor
something simple if it means that the include overhead goes from 5
seconds to 1 pr. source.

Also, I wonder if the optimizations in the (gcc, previously SGI) STL
really matters, or actually just makes things worse. At least for many
of the things I do, I would probably be better off without the fancy
optimizations, for example I use only user types with std::copy, so I
pay for having the iterators copied 4 times, but still do not get to
an implementation more "optimized" than a standard loop, I use
std::find generally for small datasets, and so the unrolled version
just result in code bloat, and insert for std::vector also seem to be
geared toward inserting large quantities of data, at least inserting 2
elements in a std::vector 10 million times is significantly slower
than doing the same with the array provided by my operating system,
where each insertion goes through dynamic dispatch. But looking at the
code for std::vector::insert also show that there is some overhead
again trying to find the optimal way to insert the values (which,
although much resolved at compile time, is slower than the dynamic
dispatch done by the ObjC run-time that my OS uses for calling member
functions on an array object).

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Ben Hutchings · Guest

Allan Odgaard wrote: