[boost] Re: [Review] Named parameters library

From: David Abrahams (dave_at_[hidden])
Date: 2004-11-18 12:25:45

"Thorsten Ottosen" <nesotto_at_[hidden]> writes:

> "David Abrahams" <dave_at_[hidden]> wrote in message
> news:uis8350ii.fsf_at_boost-consulting.com...
> | "Thorsten Ottosen" <nesotto_at_[hidden]> writes:
>
> | > Hm...I ran the code...it's as fast as passing the object directly to the
> | > function.
> |
> | Fine, show me your test and I'll show you what's wrong with it.
>
> Sorry, I thought it was attached earlier. Here it is.
>
> -Thorsten

Here we go:

> #include <vector>
> #include <iostream>
> 
> 
> std::vector<int> foo();
> 
> template< class V >
> long print( const V& v )
> {
>     long l = 0;
>     
>     for( size_t i = 0; i != v.size(); ++i )
>         l += v[i];

Spending time looping here just serves to help erase the differences
in time caused by the extra copy.  I replaced it with:

    if (!v.empty())
        l += v[v.size() / 2];

>     return l; 
> }
> 
> template< class V >
> struct Foo
> {
>     V v;
> };
> 
> #include <boost/progress.hpp>
> 
> int main()
> {
>     const int sz = 10000;

On my 1GhZ PIII with most compilers, that number is fine.  With Intel
C++ 7/8 it seems to be too low to show the difference.  Multiply it by
10.

>     {
>         boost::progress_timer t;
> 
>         long l = 0;
>         for( int i = 0; i != sz; ++i )
>             l += print( foo() );
> 
>         std::cout << l << " ";

You're also counting the time it takes to do I/O here, which similarly
serves to erase the differences in time.  I/O is expensive and it can
swamp the costs of allocating the new vector.

>     }
> 
>     {
>         boost::progress_timer t;
> 
>         long l = 0;
> 
>         for( int i = 0; i != sz; ++i )
>         {
>             //const std::vector<int>& v = foo();
>             //l += print( v );
>             Foo< std::vector<int> > f;
>             f.v = foo();
>             l += print( f.v );
> 
>         }
> 
>         std::cout << l << " ";

Likewise.

>     }
> 
> }
> 
> std::vector<int> foo_impl()
> {
>     const int sz = 3000;
>     std::vector<int> v;
>     for( int i = 0; i != sz; ++i )
>         v.push_back( i );
>     return v;
> }
> 
> std::vector<int> foo()
> {
>     static std::vector<int> v( foo_impl() );
>     return v;
> }

The enclosed will show the difference on any compiler I can get my
hands on.  I'd be happy to show you the output if you need proof.  On
most compilers it's a factor of 2.



-- 
Dave Abrahams
Boost Consulting
http://www.boost-consulting.com