EQ2EMu/EQ2/source/depends/boost_1_72_0/libs/chrono/test/run_timer_test.cpp

//  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();
}