123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226 |
- // boost run_timer_test.cpp -----------------------------------------------------//
- // Copyright Beman Dawes 2006, 2008
- // Copyright 2009 Vicente J. Botet Escriba
- // Distributed under the Boost Software License, Version 1.0.
- // See http://www.boost.org/LICENSE_1_0.txt
- // See http://www.boost.org/libs/chrono for documentation.
- #include <boost/chrono/process_times.hpp>
- #include <boost/chrono/timer.hpp>
- #include <cstdlib> // for atol()
- #include <iostream>
- #include <sstream>
- #include <locale>
- #include <ctime>
- #include <cmath> // for sqrt(), used to burn time
- using boost::chrono::run_timer;
- using boost::system::error_code;
- #include <boost/detail/lightweight_test.hpp>
- //#define BOOST_TEST(expr) if (!(expr)) std::cout << "*****ERROR*****\n"
- #define CHECK_REPORT(Timer,String_Stream,R,U,S,Expected_String) \
- check_report(Timer, String_Stream, R, U, S, Expected_String, __LINE__)
- namespace
- {
- typedef boost::chrono::nanoseconds ns;
- bool check_report( run_timer & tmr, std::stringstream & ss,
- run_timer::duration r, run_timer::duration u, run_timer::duration s,
- const std::string & expected, int line )
- {
- tmr.test_report(r,u,s);
- bool result(true);
- if ( ss.str() != expected )
- {
- std::cout << "run_timer_test.cpp(" << line << ") : error: actual output \""
- << ss.str() << "\" != expected \"" << expected << "\"\n";
- result = false;
- }
- return result;
- }
- void run_timer_constructor_overload_test()
- {
- // exercise each supported combination of constructor arguments
- std::ostream & os = std::cout;
- const int pl = 9;
- boost::system::error_code ec;
- run_timer t1;
- run_timer t2( os );
- run_timer t3( ec );
- run_timer t4( os, ec );
- run_timer t5( pl );
- run_timer t6( os, pl );
- run_timer t7( pl, ec );
- run_timer t8( os, pl, ec );
- run_timer t9( "t9, default places, r %r, c %c, p %p, u %u, s %s\n" );
- run_timer t10( os, "t10, default places, r %r, c %c, p %p, u %u, s %s\n" );
- run_timer t11( "t11, default places, r %r, c %c, p %p, u %u, s %s\n", ec );
- run_timer t12( os, "t12, default places, r %r, c %c, p %p, u %u, s %s\n", ec );
- run_timer t13( pl, "t13, explicitly code places, r %r, c %c, p %p, u %u, s %s\n" );
- run_timer t14( "t14, explicitly code places, r %r, c %c, p %p, u %u, s %s\n", pl );
- run_timer t15( os, pl, "t15, explicitly code places, r %r, c %c, p %p, u %u, s %s\n" );
- run_timer t16( os, "t16, explicitly code places, r %r, c %c, p %p, u %u, s %s\n", pl );
- run_timer t17( pl, "t17, explicitly code places, r %r, c %c, p %p, u %u, s %s\n", ec );
- run_timer t18( "t18, explicitly code places, r %r, c %c, p %p, u %u, s %s\n", pl, ec );
- run_timer t19( os, pl, "t19, explicitly code places, r %r, c %c, p %p, u %u, s %s\n", ec );
- run_timer t20( os, "t20, explicitly code places, r %r, c %c, p %p, u %u, s %s\n", pl, ec );
- std::cout << "Burn some time so run_timers have something to report...";
- boost::chrono::timer<boost::chrono::high_resolution_clock> t;
- while ( t.elapsed() < boost::chrono::seconds(1) ) {}
- std::cout << "\n";
- std::cout << run_timer::default_places() << " default places\n";
- std::cout << pl << " explicitly coded places\n";
- }
- // accuracy test
- void accuracy_test( int argc, char * argv[] )
- {
- long timeout_in_secs = 1;
- if ( argc > 1 ) timeout_in_secs = std::atol( argv[1] );
- std::cout << "accuracy test for " << timeout_in_secs << " second(s)...";
- std::clock_t timeout_in_clock_t = std::clock();
- timeout_in_clock_t += (timeout_in_secs * CLOCKS_PER_SEC);
- boost::chrono::system_timer sys;
- #ifdef BOOST_CHRONO_HAS_CLOCK_STEADY
- boost::chrono::steady_timer mono;
- #endif
- boost::chrono::high_resolution_timer hires;
- boost::chrono::process_timer process;
- std::clock_t now;
- do
- {
- now = std::clock();
- } while ( now < timeout_in_clock_t );
- boost::chrono::system_timer::duration sys_dur = sys.elapsed();
- #ifdef BOOST_CHRONO_HAS_CLOCK_STEADY
- boost::chrono::steady_timer::duration mono_dur = mono.elapsed();
- #endif
- boost::chrono::high_resolution_timer::duration hires_dur = hires.elapsed();
- boost::chrono::process_times times;
- process.elapsed( times );
- std::cout << std::endl;
- ns timeout_in_nanoseconds( static_cast<long long>(timeout_in_secs) * 1000000000LL );
- // Allow 20% leeway. Particularly on Linux, there seems to be a large discrepancy
- // between std::clock() and higher resolution clocks.
- ns maximum_delta ( static_cast<long long>(timeout_in_nanoseconds.count() * 0.20 ) );
- std::cout << timeout_in_nanoseconds.count() << " timeout_in_nanoseconds\n";
- std::cout << maximum_delta.count() << " maximum_delta\n";
- std::cout << sys_dur.count() << " sys_dur\n";
- BOOST_TEST( sys_dur > timeout_in_nanoseconds - maximum_delta
- && sys_dur < timeout_in_nanoseconds + maximum_delta );
- #ifdef BOOST_CHRONO_HAS_CLOCK_STEADY
- std::cout << mono_dur.count() << " mono_dur\n";
- BOOST_TEST( mono_dur > timeout_in_nanoseconds - maximum_delta
- && mono_dur < timeout_in_nanoseconds + maximum_delta );
- #endif
- std::cout << hires_dur.count() << " hires_dur\n";
- BOOST_TEST( hires_dur > timeout_in_nanoseconds - maximum_delta
- && hires_dur < timeout_in_nanoseconds + maximum_delta );
- std::cout << times.real.count() << " times.real\n";
- BOOST_TEST( times.real > timeout_in_nanoseconds - maximum_delta
- && times.real < timeout_in_nanoseconds + maximum_delta );
- }
- // report test
- void report_test()
- {
- {
- std::stringstream ss;
- run_timer t(ss);
- BOOST_TEST( CHECK_REPORT(t, ss, ns(0), ns(0), ns(0),
- "\nreal 0.000s, cpu 0.000s (0.0%), user 0.000s, system 0.000s\n" ) );
- }
- {
- std::stringstream ss;
- run_timer t(ss);
- BOOST_TEST( CHECK_REPORT(t, ss, ns(3000000000LL), ns(2000000000LL), ns(1000000000LL),
- "\nreal 3.000s, cpu 3.000s (100.0%), user 2.000s, system 1.000s\n" ) );
- }
- {
- std::stringstream ss;
- run_timer t( ss, "9 places: r %r, c %c, p %p, u %u, s %s", 9 );
- BOOST_TEST( CHECK_REPORT(t, ss, ns(3000000003LL), ns(2000000002LL), ns(1000000001LL),
- "9 places: "
- "r 3.000000003, c 3.000000003, p 100.0, u 2.000000002, s 1.000000001" ) );
- }
- }
- // process_timer_test
- void process_timer_test()
- {
- std::cout << "process_timer_test..." << std::flush;
- boost::chrono::process_timer t;
- double res=0; // avoids optimization
- for (long i = 0; i < 10000000L; ++i)
- {
- res+=std::sqrt( static_cast<double>(i) ); // avoids optimization
- }
- boost::chrono::process_times times;
- times.real = times.system = times.user = ns(0);
- BOOST_TEST( times.real == ns(0) );
- BOOST_TEST( times.user == ns(0) );
- BOOST_TEST( times.system == ns(0) );
- t.elapsed( times );
- std::cout << "\n";
- std::cout << times.real.count() << " times.real\n";
- std::cout << times.user.count() << " times.user\n";
- std::cout << times.system.count() << " times.system\n";
- std::cout << (times.user+times.system).count() << " times.user+system\n";
- BOOST_TEST( times.real > ns(1) );
- BOOST_TEST( times.user+times.system > ns(1) );
- std::cout << "complete " << res << std::endl;
- }
- }
- int main( int argc, char * argv[] )
- {
- std::locale loc( "" ); // test with appropriate locale
- std::cout.imbue( loc );
- accuracy_test( argc, argv );
- run_timer_constructor_overload_test();
- process_timer_test();
- report_test();
- return boost::report_errors();
- }
|