This is the mail archive of the
mailing list for the GCC project.
Re: Faster compilation speed
- From: Michael Matz <matz at suse dot de>
- To: David Edelsohn <dje at watson dot ibm dot com>
- Cc: <gcc at gcc dot gnu dot org>
- Date: Wed, 14 Aug 2002 22:20:54 +0200 (CEST)
- Subject: Re: Faster compilation speed
On Wed, 14 Aug 2002, David Edelsohn wrote:
> |> Places where GCC could benefit from spacial locality is by
> |> allocating the instruction list and pseudo registers from a large, static
> |> virtual memory array instead of allocating individual objects dynamically.
> Andreas> Obstacks?
> I thought that obstacks are created dynamically, not statically.
Sort of. Obstacks have the ability to grow an object which isn't yet
finalized, and in that process there might be some copying (the canonical
example is a string, which is created character by character). After
finalization it doesn't change it's address anymore, but still is part of
One would not use that functionality, but simply use obstacks as
convenient containers for small objects, which are allocated already
finalized. It allocates memory in blocks, and then gives out part of the
current block as long as enough is free in it, and the request is not
larger than a certain size (in which case it gets it's own block). This
makes for extremely fast allocation (just a pointer increment in the
general case). One can't deallocate objects in an obstack (or better only
all objects allocated after a certain one). And it creates good space
locality, and needs less memory then a general allocator like malloc (in
case many small objects are allocated).
But that one can't free objects is a quite severe limitation (I wrote one
for KDE, in which you can free objects, but it has certain restrictions).
But it's still usable. E.g. I use an obstack in the new register
allocator to allocate most of my small objects from it (nodes and edges of
the graph), and then simply free the whole thing once at the end of that
phase. But that's not possible e.g. with the current RTL of the function,
there you really don't want to use an obstack.
> One does not want to ever copy or grow the array.
As explained, this doesn't happen if one uses the obstack without growing
> Statically allocating some of the large, persistent, sequential
> collections of objects would help locality.
This would lead to the idea of obstacks (without growing obstacks) per
data structure type, IOW to a zone allocator, which is not a bad thing.