Re: [Boost-users] memory overhead of boost::function<>

Subject: Re: [Boost-users] memory overhead of boost::function<>
From: Mathias Gaunard (mathias.gaunard_at_[hidden])
Date: 2009-08-12 19:41:55

Zachary Turner wrote:

 > It's not
> easy to trace through the code and find all instances of allocations /
> deallocations and member variables.  sizeof(boost::function<T>)
> appears to be 32 on my machine for all values of T but I'm not sure if
> there are certain types of functions which might be less than this or
> more than this.

AFAIK sizeof(boost::function<T>) is the same for any T.

 > Is there an easy way to calculate the minimum and maximum memory
 > overhead required by a single instance of boost::function?

Minimum is sizeof(boost::function<T>), maximum is unbounded (as much as 
your free store can provide).

> Is there any way to reduce the memory overhead of boost::function?  32
> is quite a bit on an x86 architecture, considering a normal function
> pointer on the same machine takes only 4 bytes.

It would be possible to reduce the size to one word (4 bytes on x86), 
but 32 bytes is a better general-purpose solution to store average-sized 
function objects within the object itself and big-sized ones on the free 
store.
Indeed, keep in mind boost::function is a type erasure mechanism for the 
callable concept, and as such is a solution for arbitrarily big objects.

> I was thinking of
> using boost::function<> as the basis for a generic inter-object
> messaging system where there may be thousands of objects in the
> systems any of which might want to communicate via event sinks /
> sources implemented via boost::function<> and callback registration.
> But if the memory overhead is 32-bytes per object at a minimum, and
> possibly more with more complicated function objects or on 64-bit
> architectures, then it seems like it could quickly grow out of hand if
> there were many listeners.

Then maybe you need to build your custom solution. Like if you can 
guarantee all your function objects are two words max (one for the 
function, one for the context), then you can have a more optimal 
solution that is 8 bytes big and never needs the free store.
I believe C++0x wants to introduce one to use with lambdas.