Subject: [Boost-commit] svn:boost r60419 - sandbox/odeint/libs/numeric/odeint/stuff
From: karsten.ahnert_at_[hidden]
Date: 2010-03-10 10:02:23
Author: karsten
Date: 2010-03-10 10:02:22 EST (Wed, 10 Mar 2010)
New Revision: 60419
URL: http://svn.boost.org/trac/boost/changeset/60419
Log:
added some performance checks
Added:
sandbox/odeint/libs/numeric/odeint/stuff/transform_cmp.cc (contents, props changed)
Added: sandbox/odeint/libs/numeric/odeint/stuff/transform_cmp.cc
==============================================================================
--- (empty file)
+++ sandbox/odeint/libs/numeric/odeint/stuff/transform_cmp.cc 2010-03-10 10:02:22 EST (Wed, 10 Mar 2010)
@@ -0,0 +1,219 @@
+#include <algorithm>
+#include <vector>
+#include <iostream>
+
+#include <boost/accumulators/accumulators.hpp>
+#include <boost/accumulators/statistics.hpp>
+#include <boost/iterator/zip_iterator.hpp>
+
+#include <boost/timer.hpp>
+
+#define tab "\t"
+
+using namespace std;
+using namespace boost::accumulators;
+
+using boost::make_zip_iterator;
+using boost::make_tuple;
+using boost::tuples::get;
+
+
+
+typedef accumulator_set<
+ double , stats< tag::mean , tag::variance >
+ > accumulator_type;
+
+typedef boost::timer timer_type;
+
+ostream& operator<<( ostream& out , accumulator_type &acc )
+{
+ out << boost::accumulators::mean( acc ) << tab;
+// out << boost::accumulators::variance( acc ) << tab;
+ return out;
+}
+
+
+
+// computes y = x1 + alpha2*x2 + alpha3*x3
+template < class Iterator1 , class Iterator2 , class Iterator3 , class T >
+inline void scale_sum( Iterator1 first1 , Iterator1 last1 ,
+ T a1 , Iterator2 first2 ,
+ T a2 , Iterator3 first3 )
+{
+ while( first1 != last1 )
+ (*first1++) = a1 * (*first2++) + a2 * (*first3++);
+}
+
+template < class Iterator1 , class Iterator2 , class Iterator3 , class Operator >
+void transform3_1( Iterator1 first1 , Iterator1 last1,
+ Iterator2 first2 , Iterator3 first3 ,
+ Operator op )
+{
+ while( first1 != last1 ) op( *first1++ , *first2++ , *first3++ );
+}
+
+template < class Iterator1 , class Iterator2 , class Iterator3 , class Operator >
+void transform3_2( Iterator1 first1 , Iterator1 last1,
+ Iterator2 first2 , Iterator3 first3 ,
+ Operator op )
+{
+ for( ; first1 != last1 ; ++first1 , ++first2 , ++first3 )
+ op( *first1 , *first2 , *first3 );
+}
+
+template < class Iterator1 , class Iterator2 , class Iterator3 , class Operator >
+void transform3_3( Iterator1 first1 , Iterator1 last1,
+ Iterator2 first2 , Iterator3 first3 ,
+ Operator op )
+{
+ while( first1 != last1 )
+ {
+ op( *first1 , *first2 , *first3 );
+ ++first1;
+ ++first2;
+ ++first3;
+ }
+}
+
+struct scale_sum_op
+{
+ double a1 , a2;
+
+ scale_sum_op( double _a1 , double _a2 )
+ : a1( _a1 ) , a2( _a2 ) {}
+
+ template< class T >
+ void operator()( T &x1 , T &x2 , T &x3 )
+ {
+ x1 = a1 * x2 + a2 * x3;
+ }
+};
+
+struct scale_sum_op_tuple
+{
+ double a1 , a2;
+ scale_sum_op_tuple( double _a1 , double _a2 )
+ : a1( _a1 ) , a2( _a2 ) {}
+
+ template< class Tuple >
+ void operator()( const Tuple &t ) const
+ {
+ get<0>(t) = a1 * get<1>(t) + a2 * get<2>(t);
+ }
+};
+
+
+int main( int argc , char **argv )
+{
+ const size_t n = 1024 * 1024;
+ const size_t num_of_iterations = 16;
+ double a1 = 0.25 , a2 = 1.25;
+
+
+ accumulator_type acc1 , acc2 , acc3 , acc4 , acc5;
+ timer_type timer;
+
+
+ size_t count = 0;
+ clog.precision(4);
+ while( true )
+ {
+ vector< double > org1( n ) , org2( n ) , org3( n );
+ generate( org1.begin() , org1.end() , drand48 );
+ generate( org2.begin() , org2.end() , drand48 );
+ generate( org3.begin() , org3.end() , drand48 );
+
+ vector< double > v1( org1 ) , v2( org2 ) , v3( org3 );
+ vector< double > w1( org1 ) , w2( org2 ) , w3( org3 );
+ vector< double > u1( org1 ) , u2( org2 ) , u3( org3 );
+ vector< double > x1( org1 ) , x2( org2 ) , x3( org3 );
+
+ timer.restart();
+ for( size_t i=0 ; i<num_of_iterations ; ++i )
+ scale_sum( v1.begin() , v1.end() , a1 , v2.begin() , a2 , v3.begin() );
+ double res1 = accumulate( v1.begin() , v1.end() , 0.0 );
+ acc1( timer.elapsed() );
+
+ timer.restart();
+ for( size_t i=0 ; i<num_of_iterations ; ++i )
+ transform3_1( w1.begin() , w1.end() , w2.begin() , w3.begin() ,
+ scale_sum_op( a1 , a2 ) );
+ double res2 = accumulate( w1.begin() , w1.end() , 0.0 );
+ acc2( timer.elapsed() );
+
+
+ timer.restart();
+ for( size_t i=0 ; i<num_of_iterations ; ++i )
+ std::for_each(
+ make_zip_iterator( make_tuple( u1.begin() , u2.begin() , u3.begin() ) ) ,
+ make_zip_iterator( make_tuple( u1.end() , u2.end() , u3.end() ) ) ,
+ scale_sum_op_tuple( a1 , a2 )
+ );
+ double res3 = accumulate( u1.begin() , u1.end() , 0.0 );
+ acc3( timer.elapsed() );
+
+ timer.restart();
+ for( size_t i=0 ; i<num_of_iterations ; ++i )
+ transform3_2( x1.begin() , x1.end() , x2.begin() , x3.begin() ,
+ scale_sum_op( a1 , a2 ) );
+ double res4 = accumulate( x1.begin() , x1.end() , 0.0 );
+ acc4( timer.elapsed() );
+
+ timer.restart();
+ for( size_t i=0 ; i<num_of_iterations ; ++i )
+ transform3_3( x1.begin() , x1.end() , x2.begin() , x3.begin() ,
+ scale_sum_op( a1 , a2 ) );
+ double res5 = accumulate( x1.begin() , x1.end() , 0.0 );
+ acc5( timer.elapsed() );
+
+ if( ( res1 != res2 ) ||
+ ( res2 != res3 ) ||
+ ( res3 != res4 ) ||
+ ( res4 != res5 ) )
+ clog << "error" << endl;
+
+ ++count;
+
+ clog << count << tab;
+ clog << acc1 << tab;
+ clog << acc2 << tab;
+ clog << acc3 << tab;
+ clog << acc4 << tab;
+ clog << acc5 << tab;
+/* clog << tab;
+ clog << res1 << tab;
+ clog << res2 << tab;
+ clog << res3 << tab;
+ clog << res4 << tab;
+ clog << res5 << tab;*/
+
+ clog << endl;
+ }
+
+ return 0;
+}
+
+
+
+
+
+
+/*
+ Results, average time in
+
+ scale_sum transform3_1 for_each(zip_iterator) transform3_2 transform3_3
+
+ kink with gcc-4.2
+
+ 0.153 0.1521 0.151 0.1483 0.1472
+
+ photon with gcc-4.4, kann verfaelscht sein, weil viel laeuft
+
+ 0.163 0.1606 0.1646 0.1696 0.1694
+
+ quark with gcc-4.4, kann verfaelscht sein
+
+ 0.1574 0.1629 0.1686 0.1731 0.1732
+
+*/
+