Have the ideas behind the Fast Delegate (et al) been used to optimize std::function?

Asked 2012-06-20T18:52:12.933

There have been proposals for C++ "delegates" which have lower overhead than boost::function:

Have any of those ideas been used to implement std::function, resulting in better performance than boost::function? Has anyone compared the performance of std::function vs boost::function?

I want to know this specifically for the GCC compiler and libstdc++ on Intel 64-bit architectures, but information on other compilers is welcome (such as Clang).

Edit Report

2 Answers

In libstdc++'s std::function we use a union type that is suitably sized and aligned to store pointers, function pointers or pointers to member functions. We avoid a heap allocation for any function object that can be stored in that size and alignment, but only if it is "location invariant"

/**
 *  Trait identifying "location-invariant" types, meaning that the
 *  address of the object (or any of its members) will not escape.
 *  Also implies a trivial copy constructor and assignment operator.
 */

The code is based on the std::tr1::function implementation and that part hasn't changed significantly. I think that could be simplified using std::aligned_storage and could be improved by specializing the trait so that more types are identified as location invariant.

Invoking the target object is done without any virtual function calls, the type erasure is done by storing a single function pointer in the std::function which is the address of a function template specialization. All operations are done by calling that function template through the stored pointer and passing in an enum identifying what operation it is being asked to perform. This means no vtable and only a single function pointer needs to be stored in the object.

This design was contributed by the original boost::function author and I believe it is close to the boost implementation. See the Performance docs for Boost.Function for some rationale. That means it's pretty unlikely that GCC's std::function is any faster than boost::function, because it's a similar design by the same person.

N.B. our std::function doesn't support construction with an allocator yet, any allocations it needs to do will be done using new


                            answered 2012-06-20T20:34:32.587


            
            
                
                    
                        
                            
                            
                        
                        4
                        
                            
                            
                        
                        
                    
                    
                        
                        As noted in the comments, std::function is only an interface, and different implementations may do different things, but it's worth noting that the standard does actually have something to say about this matter.  From 20.8.11.2.1/5 (which looks more like an IP address than a part of the standard):


  Note: Implementations are encouraged to avoid the use of dynamically
  allocated memory for small callable objects, for example, where f’s
  target is an object holding only a pointer or reference to an object
  and a member function pointer. —end note


This is the standard's way of encouraging implementers to employ the "small function optimization," which was motivated by the cited articles on delegates.  (The articles themselves don't actually talk about delegates in the .NET sense. Rather, they use the term "delegate" to mean bound member functions.)

                        
                        
                            answered 2012-10-21T16:59:18.840



        
        
            Your Answer