Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r58480 - in sandbox/chrono/libs/chrono: build doc doc/html doc/html/boost_chrono doc/html/boost_chrono/appendices doc/html/boost_chrono/examples doc/html/boost_chrono/overview doc/html/boost_chrono/reference doc/html/boost_chrono/users_guide example src src/mac src/posix src/win test
From: vicente.botet_at_[hidden]
Date: 2009-12-21 11:56:09

Next message: vicente.botet_at_[hidden]: "[Boost-commit] svn:boost r58481 - sandbox/chrono/boost/chrono"
Previous message: lists.drrngrvy_at_[hidden]: "[Boost-commit] svn:boost r58479 - sandbox/SOC/2007/cgi/branches/pickmeup/boost/cgi/fwd"

Author: viboes
Date: 2009-12-21 11:56:04 EST (Mon, 21 Dec 2009)
New Revision: 58480
URL: http://svn.boost.org/trac/boost/changeset/58480

Log:
Boost.Chrono: Version 0.3.0, New stopwatch feature
    * independent cpu clocks for real, user, system process CPU time.
    * new Stopwatch concept measuring elapsed time between different points in time associated to the operations start, stop, suspend and resume.
    * stopwatch is a model Stopwatch measuring the elapsed time between the start and the stop operations.
    * stopwatch_accumulator is a model Stopwatch allowing to accumulate several time samples and give the average, ...
    * scoped helper classes allowing to pairwise start/stop operations, suspend/resume and resume/suspend a Stopwatch.
    * new Stopwatch Formatter concept
    * stopwatch_reporter is a generic class reporting elapsed time for the Stopwatch concept.
    * process_times.hpp has been deprecated, see process_clocks.hpp, process_stopwhatches.hpp and process_stopwhatches_reporter.hpp.
    * timer.hpp has been deprecated, see stopwatch.

Added:
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/examples/process_stopwatches_reporter_example2_cpp.html (contents, props changed)
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/examples/process_stopwatches_reporter_example_cpp.html (contents, props changed)
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/cpp0x.html (contents, props changed)
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/deprecated_headers.html (contents, props changed)
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/process_cpu_related.html (contents, props changed)
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/stopwatch_reporters.html (contents, props changed)
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/stopwatches.html (contents, props changed)
   sandbox/chrono/libs/chrono/example/stopwatch_example.cpp (contents, props changed)
Text files modified:
   sandbox/chrono/libs/chrono/build/Jamfile.v2 | 2
   sandbox/chrono/libs/chrono/doc/chrono.qbk | 915 +++++++++++++++++++++++++++++++++++----
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices.html | 2
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/history.html | 56 ++
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/implementation.html | 19
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/rationale.html | 8
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/todo.html | 4
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/examples.html | 11
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/examples/a_tiny_program_that_times_how_long_until_a_key_is_struck.html | 6
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/examples/time_command.html | 8
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/overview.html | 56 +
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/overview/motivation.html | 109 +++-
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference.html | 90 +--
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide/getting_started.html | 22
   sandbox/chrono/libs/chrono/doc/html/index.html | 20
   sandbox/chrono/libs/chrono/doc/html/standalone_HTML.manifest | 14
   sandbox/chrono/libs/chrono/src/mac/process_clock.cpp | 3
   sandbox/chrono/libs/chrono/src/posix/process_clock.cpp | 2
   sandbox/chrono/libs/chrono/src/process_clock.cpp | 11
   sandbox/chrono/libs/chrono/src/run_timer.cpp | 31
   sandbox/chrono/libs/chrono/src/run_timer_static.cpp | 3
   sandbox/chrono/libs/chrono/src/win/process_clock.cpp | 3
   sandbox/chrono/libs/chrono/test/Jamfile.v2 | 6
   23 files changed, 1131 insertions(+), 270 deletions(-)

Modified: sandbox/chrono/libs/chrono/build/Jamfile.v2
==============================================================================
--- sandbox/chrono/libs/chrono/build/Jamfile.v2 (original)
+++ sandbox/chrono/libs/chrono/build/Jamfile.v2 2009-12-21 11:56:04 EST (Mon, 21 Dec 2009)
@@ -41,7 +41,7 @@
 #<link>static:<define>BOOST_CHRONO_STATIC_LINK=1
 ;

-SOURCES = chrono process_clock run_timer run_timer_static ;
+SOURCES = chrono process_clock run_timer run_timer_static cpu_clocks ;

lib boost_chrono
 : $(SOURCES).cpp

Modified: sandbox/chrono/libs/chrono/doc/chrono.qbk
==============================================================================
--- sandbox/chrono/libs/chrono/doc/chrono.qbk (original)
+++ sandbox/chrono/libs/chrono/doc/chrono.qbk 2009-12-21 11:56:04 EST (Mon, 21 Dec 2009)
@@ -56,15 +56,21 @@
 * `monotonic_clock`
 * `high_resolution_clock`

-* Class template timer, with typedefs:
- * `system_timer`
- * `monotonic_timer`
- * `high_resolution_timer`
-
-* Process clocks and timers:
- * `process_clock`, capturing real, user-CPU, and system-CPU times.
- * `process_timer`, capturing elapsed real, user-CPU, and system-CPU times.
- * `run_timer`, convenient reporting of process_timer results.
+* Process clocks:
+ * `process_real_CPU_clocks`, capturing real-CPU times.
+ * `process_user_CPU_clocks`, capturing user-CPU times.
+ * `process_system_CPU_clocks`, capturing system-CPU times.
+ * `process_clocks`, tuple-like class capturing at once real, user-CPU, and system-CPU times.
+
+* Stopwatches:
+ * `stopwatch`, capturing elapsed Clock times.
+ * `stopwatch_accumulator`, capturing cummulated elapsed Clock times.
+ * scoped helper classes allowing to pairwise start/stop operations, suspend/resume and resume/suspend a Stopwatch.
+ * `process_stopwatches`, capturing elapsed real, user-CPU, and system-CPU times.
+
+* Stopwatch reporters:
+ * `stopwatch_reporter`, convenient reporting of models of Stopwatch results.
+ * `process_stopwatches_reporter`, convenient reporting of process_stopwatches results.

[/====================================]
[heading How to Use This Documentation]
@@ -395,15 +401,51 @@
[endsect]

-[section Timers]
+[section Stopwatches]

-Knowing how long a program takes to execute is useful in both test and production environments. It is also helpful if such timing information is broken down into real (wall clock) time, CPU time spent by the user, and CPU time spent by the operating system servicing user requests.
+Knowing how long a program, a function or a specific block takes to execute is useful in both test and production environments. __Boost_Chrono__ introduces the Stopwatch concept which captures the mechanism to measure the elapsed time. `stopwatch<>` is the basic model of Stopwatch
+
+It is also interesting to have an statisitical view of these times. `stopwatch_accumulator<>` associates an accumulator with a stopwatch, so we are able to retrieve any statistical feature Boost.Accumulator provides. the Aprovides stopwatches utilities useful when the automatic reporting of `stopwatch_reporter` isn't desired.
+
+The highest level use case of measuring the elapsed time is to report these times on the display. `stopwatch_reporter<>` provides a run time reporting package that can be invoked in a single line of code to report the usage of a Clock.
+
+For example
+
+ using namespace boost::chrono;
+ int f1(long j) {
+ static stopwatch_accumulator<>::reporter sw;
+ stopwatch_accumulator<>::reporter::scoped_run _(sw);
+
+ for ( long i = 0; i < j; ++i )
+ std::sqrt( 123.456L ); // burn some time
+
+ return 0;
+ }
+ int main() {
+ f1(100000);
+ f1(200000);
+ f1(300000);
+ return 0;
+ }
+
+Will produce the following output
+
+ Count=3 times Sum=0.034s Min=0.006s Max=0.017s Mean=0.011s
+
+It is also helpful if such timing information is broken down into real (wall clock) time, CPU time spent by the user, and CPU time spent by the operating system servicing user requests. `process_real_CPU_clock`, `process_user_CPU_clock`, `process_system_CPU_clock` and `process_clocks` provides a thin wrappers around the operating system's process timer API. The first three captre the a specific time unitarily, the last captures the three times at once. For POSIX-like systems, that's the times() function, while for Windows, it's the GetProcessTimes() function.

-The Boost Chrono Library's process times components provide that information:
+As `process_clocks` do not conform to the Stopwatch concept, __Boost_Chrono__ provides the equivalent of `stopwatch<process_clocks>` and `stopwatch_reporter<process_clocks>` with the classes `process_stopwatches` and `process_stopwatches_reporter`

-* At the highest level, class `run_timer` provides a complete run time reporting package that can be invoked in a single line of code.
-* At a middle level, class `process_timer` provides a process timer useful when the automatic reporting of `run_timer` isn't desired.
-* At the lowest level, `process_clock` provides a thin wrapper around the operating system's process timer API. For POSIX-like systems, that's the times() function, while for Windows, it's the GetProcessTimes() function.
+ using namespace boost::chrono;
+ int main()
+ {
+ process_stopwatches_reporter _;
+ // ...
+ }
+
+Will produce the following output
+
+ real 0.034s, cpu 0.031s (93.0%), user 0.031s, system 0.000s

[endsect]

@@ -553,16 +595,16 @@

 // add this in the scope you want to time,
 // at the point you want the timer to start.
- boost::chrono::run_timer rt;
+ boost::chrono::process_stopwatches_reporter rt;

-Here is a complete program (run_timer_example.cpp):
+Here is a complete program (process_stopwatches_reporter_example.cpp):

 #include <boost/chrono/process_times.hpp>
 #include <cmath>

 int main()
 {
- boost::chrono::run_timer t;
+ boost::chrono::process_stopwatches_reporter t;

 for ( long i = 0; i < 10000000; ++i )
 std::sqrt( 123.456L ); // burn some time
@@ -621,6 +663,7 @@
[section:reference Reference ]
[/=================]

+[section:cpp0x Included on the C++0x recommendation]

[/===================================================================]
[section:common_type_hpp Header `<boost/type_traits/common_type.hpp>`]
@@ -1777,18 +1820,24 @@

[endsect]

-[/ comment
-[/==================================================]
-[section:cpu_clocks_hpp Header `<boost/chrono/cpu_clocks.hpp>`]
-[/==================================================]
+[endsect]
+
+[section Process CPU related]
+
+[/==================================================================]
+[section:process_clocks_hpp Header `<boost/chrono/process_clocks.hpp>`]
+[/==================================================================]

Knowing how long a program takes to execute is useful in both test and production environments. It is also helpful if such timing information is broken down into real (wall clock) time, CPU time spent by the user, and CPU time spent by the operating system servicing user requests.

- namespace boost { namespace chrono {
+ namespace boost { namespace chrono {
+
 class process_real_cpu_clock;
 class process_user_cpu_clock;
 class process_system_cpu_clock;
- }}
+ class process_clocks;
+
+ } }

[section Class `process_real_cpu_clock`]

@@ -1849,162 +1898,794 @@

[endsect]

+[section Class `process_clocks`]
+
+`process_clocks` can be considered as a `tuple<process_real_cpu_clock, process_user_cpu_clock, process_system_cpu_clock>`. Obviously it doesn't satisfy the Clock Requirements.
+
+`process_clocks` provides a thin wrapper around the operating system's process timer API. For POSIX-like systems, that's the times() function, while for Windows, it's the GetProcessTimes() function.
+
+The process relative real, user and system current time can be obtained at once by calling `process_clocks::now()`.
+
+
+ class process_clocks {
+ public:
+ typedef nanoseconds duration;
+ typedef duration::rep rep;
+ typedef duration::period period;
+ typedef chrono::time_point<process_clocks> time_point;
+ static const bool is_monotonic = true;
+
+ struct durations;
+ static void now( process_clocks::durations & times,
+ system::error_code & ec = system::throws );
+ };
+
+[section Class `durations`]
+
+ struct durations {
+ process_clocks::duration real; // real (i.e wall clock) time
+ process_clocks::duration user; // user cpu time
+ process_clocks::duration system; // system cpu time
+ };
+
+[endsect]
+
+[endsect]
+
+
+[endsect]
+
+
+[endsect]
+
+[/==================================================]
+[section Stopwatches]
+[/==================================================]
+[section `Stopwatch` Requirements]
+
+A Stopwatch measure the amount of time elapsed from a particular time when activated to when it is deactivated, or the accumulation of them.
+
+A Stopwatch must meet the requirements in the following Table.
+
+In this table `S`, `S1` and `S2` denote stopwatches types. `s` is an instance of `S`.
+
+[table Stopwatch Requirements
+ [[expression] [return type] [operational semantics]]
+ [[`S::clock`] [A model of the CLock concept.] [The clock associated to this Stopwatch.]]
+ [[`S::duration`] [`S::clock::duration`] [The `duration` type of the `clock`.]]
+ [[`S::time_point`] [`S::clock::time_point`] [The `time_point` type of the `clock`.]]
+ [[`s.start()`] [`S::time_point`] [starts a Stopwatch.]]
+ [[`s.restart()`] [`std::paire<S::duration,S::time_point>`] [restarts a Stopwatch.]]
+ [[`s.stop()`] [`S::duration`] [stops a Stopwatch.]]
+ [[`s.resume()`] [`S::time_point`] [starts a Stopwatch.]]
+ [[`s.suspend()`] [`S::duration`] [stops a Stopwatch.]]
+ [[`s.elapsed()`] [`S::duration`] [the elapsed time while the Stopwatch was running.]]
+]

[endsect]
-comment ]
[/==================================================]
-[section:timer_hpp Header `<boost/chrono/timer.hpp>`]
+[section:stopwatch_hpp Header `<boost/chrono/stopwatch.hpp>`]
[/==================================================]

 namespace boost { namespace chrono {
- template <class Clock> class timer;
- typedef <see above> system_timer;
+ struct dont_start_t;
+ static const dont_start_t dont_start;
+
+ template <class Clock=high_resolution_clock> class stopwatch;
+
+ typedef <see above> system_stopwatch;
 #ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
- typedef <see above> monotonic_timer;
+ typedef <see above> monotonic_stopwatch;
 #endif
- typedef <see above> high_resolution_timer;
+ typedef <see above> high_resolution_stopwatch;
+ typedef <see above> process_real_cpu_stopwatch;
+ typedef <see above> process_user_cpu_stopwatch;
+ typedef <see above> process_system_cpu_stopwatch;
 }}

-[/
- typedef <see above> process_real_cpu_timer;
- typedef <see above> process_user_cpu_timer;
- typedef <see above> process_system_cpu_timer;
-]
-[section Template Class `timer<>`]
+[section Template Class `stopwatch<>`]
+
+`stopwatch<>` is a model of a `Stopwatch`.

Knowing how long a part of a program takes to execute is useful in both test and production environments.
-A `timer` object measures elapsed time. It is recommended to use it with clocks that measure wall clock rather than CPU time since the intended use is performance measurement on systems where total elapsed time is more important than just process or CPU time.
+A `stopwatch` object measures elapsed time. It is recommended to use it with clocks that measure wall clock rather than CPU time since the intended use is performance measurement on systems where total elapsed time is more important than just process or CPU time.

The maximum measurable elapsed time depends on the Clock parameter. The accuracy of timings depends on the
accuracy of timing information provided the Clock, and this coudl varies a great deal from one clock to another.

- template <class Clock> class timer {
+ template <class Clock> class stopwatch {
 public:
 typedef Clock clock;
 typedef typename Clock::duration duration;
 typedef typename Clock::time_point time_point;

- explicit timer( system::error_code & ec = system::throws );
+ explicit stopwatch( system::error_code & ec = system::throws );
+ explicit stopwatch( const dont_start_t& t );

 ~timer();

- void start( system::error_code & ec = system::throws );
+ time_point start( system::error_code & ec = system::throws );
+ duration stop( system::error_code & ec = system::throws );
+ std::pair<duration,time_point> restart( system::error_code & ec = system::throws );
+
+ duration suspend( system::error_code & ec = system::throws );
+ time_point resume( system::error_code & ec = system::throws );
+
 duration elapsed( system::error_code & ec = system::throws );
+
+ typedef stopwatch_runner<stopwatch<Clock> > scoped_run;
+ typedef stopwatch_suspender<stopwatch<Clock> > scoped_suspend;
+ typedef stopwatch_resumer<stopwatch<Clock> > scoped_resume;
+ typedef stopwatch_reporter<stopwatch<Clock> > reporter;

 };

[endsect]

-[section `timer` useful typedefs]
+[section `stopwatch` useful typedefs]

- typedef boost::chrono::timer< boost::chrono::system_clock > system_timer;
+ typedef boost::chrono::stopwatch< boost::chrono::system_clock > system_stopwatch;
 #ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
- typedef boost::chrono::timer< boost::chrono::monotonic_clock > monotonic_timer;
+ typedef boost::chrono::stopwatch< boost::chrono::monotonic_clock > monotonic_stopwatch;
 #endif
- typedef boost::chrono::timer< boost::chrono::high_resolution_clock > high_resolution_timer;
+ typedef boost::chrono::stopwatch< boost::chrono::high_resolution_clock > high_resolution_stopwatch;
+
+ typedef boost::chrono::stopwatch< boost::chrono::process_real_cpu_clock > process_real_cpu_stopwatch;
+ typedef boost::chrono::stopwatch< boost::chrono::process_user_cpu_clock > process_user_cpu_stopwatch;
+ typedef boost::chrono::stopwatch< boost::chrono::process_system_cpu_clock > process_system_cpu_stopwatch;
+
+[endsect]
+[endsect]
+
+[/==================================================]
+[section:stopwatch_accumulator_hpp Header `<boost/chrono/stopwatch_accumulator.hpp>`]
+[/==================================================]
+
+ namespace boost { namespace chrono {
+ template <class Clock, class Accumulator> class stopwatch_accumulator;
+ typedef <see below> system_stopwatch_accumulator;
+ #ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
+ typedef <see below> monotonic_stopwatch_accumulator;
+ #endif
+ typedef <see below> high_resolution_stopwatch_accumulator;
+
+ typedef <see below> process_real_cpu_stopwatch_accumulator;
+ typedef <see below> process_user_cpu_stopwatch_accumulator;
+ typedef <see below> process_system_cpu_stopwatch_accumulator;
+
+ }}
+
+
+[section Template Class `stopwatch_accumulator<>`]
+
+A `stopwatch_accumulator<>` is a model of a Stopwatch that allows to accumulate the time in several times instead of at once as it is the case of the class `stopwatch<>`.
+
+ template <class Clock> class stopwatch_accumulator {
+ public:
+ typedef Clock clock;
+ typedef typename Clock::duration duration;
+ typedef typename Clock::time_point time_point;
+ typedef Accumulator accumulator;
+
+ stopwatch_accumulator();
+
+ time_point start( system::error_code & ec = system::throws );
+ duration stop( system::error_code & ec = system::throws );
+ std::pair<duration,time_point> restart( system::error_code & ec = system::throws );
+
+ duration suspend( system::error_code & ec = system::throws );
+ time_point resume( system::error_code & ec = system::throws );
+
+ duration elapsed(system::error_code & ec = system::throws);
+
+ accumulator& accumulated( );
+ void reset();
+
+ typedef stopwatch_runner<stopwatch_accumulator<Clock> > scoped_run;
+ typedef stopwatch_suspender<stopwatch_accumulator<Clock> > scoped_suspend;
+ typedef stopwatch_resumer<stopwatch_accumulator<Clock> > scoped_resume;
+ typedef stopwatch_reporter<stopwatch_accumulator<Clock> > reporter;
+ };
+
+[section:stopwatch_accumulator_c Constructor `stopwatch_accumulator()`]
+
+ stopwatch_accumulator();
+
+[*Effect:] Initialize the elapsed duration and the times counter to 0.
+
+[endsect]
+[section:stopwatch_accumulator_start Member function`start()`]
+
+ time_point start( system::error_code & ec = system::throws );
+
+[*Effect:] Starts running the stopwatch.
+
+[*Returns:] the starting time point.
+
+[*Throw:] Any exception the Clock::now function can throw.
+
+[endsect]
+[section:stopwatch_accumulator_stop Member function`stop()`]
+
+ duration stop( system::error_code & ec = system::throws );
+
+[*Effect:] Stops running the stopwatch. Accumulates the elapsed time since the last start-like operation + the partial accumulated by resume/suspend operation.
+
+[*Returns:] The cummulated elapsed time.
+
+[*Throw:] Any exception the Clock::now function can throw.
+
+[endsect]
+[section:stopwatch_accumulator_suspend Member function`suspend()`]
+
+ duration suspend( system::error_code & ec = system::throws );
+
+[*Effect:] Suspends the stopwatch. Accumulates the elapsed time since the last start-like operation on a partial duration.
+
+[*Throw:] Any exception the Clock::now function can throw.
+
+[endsect]
+[section:stopwatch_accumulator_resume Member function`resume()`]
+
+ time_point resume( system::error_code & ec = system::throws );
+
+[*Effect:] Resumes the stopwatch.
+
+[*Returns:] the starting time point.
+
+[*Throw:] Any exception the Clock::now function can throw.
+
+[endsect]
+
+[section:stopwatch_accumulator_restart Member function`restart()`]
+
+ time_point restart( system::error_code & ec = system::throws );
+
+[*Effect:] Stop/Start the stopwatch.
+
+[*Returns:] the starting time point.
+
+[*Throw:] Any exception the Clock::now function can throw.
+
+[endsect]
+[section:stopwatch_accumulator_reset Member function`reset()`]
+
+ void reset( );
+
+[*Effect:] Stop the stopwatch and reset the accumulator.
+
+[*Throw:] Nothing.
+
+[endsect]
+[section:stopwatch_accumulator_elapsed Member function`elapsed()`]
+
+ duration elapsed(system::error_code & ec = system::throws) const;
+
+[*Returns:] the cumulated elapsed time.
+
+[*Throw:] Nothing.
+
+[*Note:] the system::error_code & parameter is here to conform to the Timer concept.
+
+[endsect]
+
+[section:stopwatch_accumulator_accumulated Member function`accumulated()`]
+
+ accumulator& accumulated();
+
+[*Returns:] the assocaited accumulator.
+
+[*Throw:] Nothing.
+
+[endsect]
+
+[endsect]
+
+[section `stopwatch_accumulator` useful typedefs]
+
+ typedef boost::chrono::stopwatch_accumulator< boost::chrono::system_clock > system_stopwatch_accumulator;
+#ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
+ typedef boost::chrono::stopwatch_accumulator< boost::chrono::monotonic_clock > monotonic_stopwatch_accumulator;
+#endif
+ typedef boost::chrono::stopwatch_accumulator< boost::chrono::high_resolution_clock > high_resolution_stopwatch_accumulator;

-[/
- typedef boost::chrono::timer< boost::chrono::process_real_cpu_clock > process_real_cpu_timer;
- typedef boost::chrono::timer< boost::chrono::process_user_cpu_clock > process_user_cpu_timer;
- typedef boost::chrono::timer< boost::chrono::process_system_cpu_clock > process_system_cpu_timer;
-]
+ typedef boost::chrono::stopwatch_accumulator< boost::chrono::process_real_cpu_clock > process_real_cpu_stopwatch_accumulator;
+ typedef boost::chrono::stopwatch_accumulator< boost::chrono::process_user_cpu_clock > process_user_cpu_stopwatch_accumulator;
+ typedef boost::chrono::stopwatch_accumulator< boost::chrono::process_system_cpu_clock > process_system_cpu_stopwatch_accumulator;
+
[endsect]
[endsect]

-[/
[/==================================================]
-[section:timer_hpp Header `<boost/chrono/reporting_timer.hpp>`]
+[section:stopwatch_scoped_hpp Header `<boost/chrono/stopwatch_scoped.hpp>`]
+[/==================================================]
+
+ namespace boost { namespace chrono {
+ template <class Clock> class stopwatch_runner;
+ template <class Clock> class stopwatch_suspender;
+ template <class Clock> class stopwatch_resumer;
+ }}
+
+Boost.Chrono provides some helper classes ensuring pairwised operations (start/stop, suspend/resume, resule/suspend).
+
+[section Template Class `stopwatch_runner<>`]
+
+This helper class ensures that the start/stop are pairwised. Start the associated accumulator at construction time, and stop it at destruction time.
+
+ template <class Stopwatch> class stopwatch_runner {
+ public:
+ typedef Stopwatch stopwatch_type;
+ stopwatch_runner(stopwatch_type & a, system::error_code & ec = system::throws);
+ ~stopwatch_runner();
+ stopwatch_runner() = delete;
+ stopwatch_runner(const stopwatch_runner&) = delete;
+ stopwatch_runner& operator=(const stopwatch_runner&) = delete;
+ };
+
+Usage
+
+ void f1()
+ {
+ static stopwatch_accumulator<> t;
+ stopwatch_runner<stopwatch_accumulator<> > _(t);
+ // ...
+ }
+
+[endsect]
+[section Template Class `stopwatch_suspender<>`]
+
+This helper class ensures that the suspend/resume are pairwised. Suspend the associated accumulator at construction time, and resume it at destruction time.
+
+ template <class Stopwatch> class stopwatch_suspender {
+ public:
+ typedef Stopwatch stopwatch_type;
+ stopwatch_suspender(stopwatch_type & a, system::error_code & ec = system::throws);
+ ~stopwatch_suspender();
+ stopwatch_suspender() = delete;
+ stopwatch_suspender(const stopwatch_suspender&) = delete;
+ stopwatch_suspender& operator=(const stopwatch_suspender&) = delete;
+ }
+
+Usage
+
+ void f1()
+ {
+ static stopwatch_accumulator<> t;
+ stopwatch_runner<stopwatch_accumulator<> > _(t);
+ // ...
+
+ // call to some function we don't want to measure
+ {
+ stopwatch_suspender<stopwatch_accumulator<> > _(t);
+ external_function();
+ }
+ }
+
+[endsect]
+
+[section Template Class `stopwatch_resumer<>`]
+
+This helper class ensures that the resume/suspend are pairwised. Resume the associated accumulator at construction time, and suspecd it at destruction time.
+
+ template <class Stopwatch> class stopwatch_resumer {
+ public:
+ typedef Stopwatch stopwatch_type;
+ stopwatch_resumer(stopwatch_type & a, system::error_code & ec = system::throws);
+ ~stopwatch_resumer();
+ stopwatch_resumer() = delete;
+ stopwatch_resumer(const stopwatch_resumer&) = delete;
+ stopwatch_resumer& operator=(const stopwatch_resumer&) = delete;
+ }
+
+Usage
+
+ void f1()
+ {
+ static stopwatch_accumulator<> t;
+ stopwatch_runner<stopwatch_accumulator<> > _(t);
+ // ...
+
+ // call to some function we don't want to measure
+ {
+ stopwatch_suspender<stopwatch_accumulator<> > _(t);
+
+ {
+ stopwatch_resumer<stopwatch_accumulator<> > _(t);
+
+ }
+ }
+ }
+
+[endsect]
+
+[endsect]
+
+[/==================================================================]
+[section:process_stopwatches_hpp Header `<boost/chrono/process_stopwatches.hpp>`]
+[/==================================================================]
+
+
+ namespace boost { namespace chrono {
+
+ class process_stopwatches;
+
+ } }
+
+
+[section Class `process_stopwatches`]
+
+Knowing how long a program takes to execute is useful in both test and production environments. It is also helpful if such timing information is broken down into real (wall clock) time, CPU time spent by the user, and CPU time spent by the operating system servicing user requests.
+
+`process_stopwatches` is the `stopwatches<>` equivalent associated to the pseudo-clock `process_clocks`. It behaves like `stopwatches<>` but it uses the specific `process_clocks:now()` function.
+
+ class process_stopwatches {
+ public:
+ typedef process_clocks clock;
+ typedef process_clocks::duration duration;
+ typedef process_clocks::time_point time_point;
+
+ explicit process_stopwatches( system::error_code & ec = system::throws );
+
+ ~process_stopwatches();
+ void start( system::error_code & ec = system::throws );
+ void elapsed( process_clocks::durations & times, system::error_code & ec = system::throws );
+ };
+
+[endsect]
+[endsect]
+[endsect]
+[section Stopwatch Reporters]
+
+[/==================================================]
+[section:stopwatch_reporter_hpp Header `<boost/chrono/stopwatch_reporter.hpp>`]
[/==================================================]

 namespace boost { namespace chrono {
- template <class Clock> class reporting_timer;
- typedef <see above> system_reporting_timer;
+ template <class Stopwatch>
+ struct stopwatch_reporter_default_formatter;
+
+ template <class Stopwatch, class Formatter=typename stopwatch_reporter_default_formatter<Stopwatch>::type>
+ class stopwatch_reporter;
+ typedef <see above> system_stopwatch_reporter;
 #ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
- typedef <see above> monotonic_reporting_timer;
+ typedef <see above> monotonic_stopwatch_reporter;
 #endif
- typedef <see above> high_resolution_reporting_timer;
- typedef <see above> process_real_cpu_reporting_timer;
- typedef <see above> process_user_cpu_reporting_timer;
- typedef <see above> process_system_cpu_reporting_timer;
+ typedef <see above> high_resolution_stopwatch_reporter;
+ typedef <see above> process_real_cpu_stopwatch_reporter;
+ typedef <see above> process_user_cpu_stopwatch_reporter;
+ typedef <see above> process_system_cpu_stopwatch_reporter;
 }}

-[section Class `reporting_timer<>`]
+[section `Formatter` Requirements]
+
+A Formatter outputs on a given ostream a formatted string combining informations from a Stopwatch and the format and the double precission.
+
+A Stopwatch must meet the requirements in the following Table.
+
+In this table `F` denote Fromaters types, `S` is a Stopwatch and `s` is an instance of `S`, `f` is `const char *` , `p` is and int, and `os` is a `std::ostream`, ec is a system::error_code
+
+[table Stopwatch Requirements
+ [[expression] [return type] [operational semantics]]
+ [[`F::output()`] [std::otream&] [The output stream.]]
+ [[`F::default_places()`] [`std::size_t`] [The precission when displaying a double.]]
+ [[`F::default_format()`] [`const char*`] [The default format.]]
+ [[`F::show_time(s,f,p,os,ec)`] [`S::time_point`] [outputs on `os` a formatted string combining informations from the Stopwatch `s`, the format `f` and the double precission `p`.]]
+]
+
+[endsect]
+
+[section `Formatter` related traits]
+
+ template <class Stopwatch>
+ struct stopwatch_reporter_default_formatter {
+ typedef <see below> type;
+ };
+
+The nested typedef `type` defines the default formatter used by the `stopwatch_reporter` class when the `Formatter` parameter is not explicit.
+
+[endsect]
+
+[section Template Class `stopwatch_reporter<>`]

-class `reporting_timer` provides a everything `timer<>` provides and in adds reporting capabilities that can be invoked in a single line of code. The reporting is controleed by two parameters:
+class `stopwatch_reporter` provides a everything a Timer provides and it adds reporting capabilities that can be invoked in a single line of code. The reporting is controleed by two parameters:

* format : The output format
* places(precission): the number of decimal placess used.

+The default places is given by Formatter::default_places.
+The default format is given by Formatter::default_format.
+
+ template <class Stopwatch, class Formatter>
+ class stopwatch_reporter : public Stopwatch {
+ public:
+ explicit stopwatch_reporter( system::error_code & ec = system::throws );
+ explicit stopwatch_reporter( std::ostream & os,
+ system::error_code & ec = system::throws );
+
+ explicit stopwatch_reporter( const std::string & format,
+ system::error_code & ec = system::throws );
+ explicit stopwatch_reporter( std::ostream & os, const std::string & format,
+ system::error_code & ec = system::throws );
+
+ explicit stopwatch_reporter( const std::string & format, int places,
+ system::error_code & ec = system::throws );
+ explicit stopwatch_reporter( std::ostream & os, const std::string & format, int places,
+ system::error_code & ec = system::throws );
+
+ explicit stopwatch_reporter( int places,
+ system::error_code & ec = system::throws );
+ explicit stopwatch_reporter( std::ostream & os, int places,
+ system::error_code & ec = system::throws );
+
+ explicit stopwatch_reporter( int places, const std::string & format,
+ system::error_code & ec = system::throws );
+ explicit stopwatch_reporter( std::ostream & os, int places, const std::string & format,
+ system::error_code & ec = system::throws );
+
+ ~stopwatch_reporter();
+
+ void report( system::error_code & ec = system::throws );
+ bool reported() const;
+
+
+ typedef stopwatch_runner<stopwatch_reporter<Stopwatch> > scoped_run;
+ typedef stopwatch_suspender<stopwatch_reporter<Stopwatch> > scoped_suspend;
+ typedef stopwatch_resumer<stopwatch_reporter<Stopwatch> > scoped_resume;
+ };
+
+Usage
+
+ void f1()
+ {
+ typedef stopwatch_reporter<stopwatch_accumulator<> > accumulator;
+ static accumulator t;
+ accumulator::scoped_run _(t);
+ // ...
+
+ // call to some function we don't want to measure
+ {
+ accumulator::scoped_suspend _(t);
+ external_function();
+ }
+ }
+
+[endsect]
+
+[section `stopwatch_reporter` useful typedefs]
+
+ typedef boost::chrono::stopwatch_reporter< boost::chrono::system_clock > system_stopwatch_reporter;
+ #ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
+ typedef boost::chrono::stopwatch_reporter< boost::chrono::monotonic_clock > monotonic_stopwatch_reporter;
+ #endif
+ typedef boost::chrono::stopwatch_reporter< boost::chrono::high_resolution_clock > high_resolution_stopwatch_reporter;
+ typedef boost::chrono::stopwatch_reporter< boost::chrono::process_real_cpu_clock > process_real_cpu_stopwatch_reporter;
+ typedef boost::chrono::stopwatch_reporter< boost::chrono::process_user_cpu_clock > process_user_cpu_stopwatch_reporter;
+ typedef boost::chrono::stopwatch_reporter< boost::chrono::process_system_cpu_clock > process_system_cpu_stopwatch_reporter;
+
+[endsect]
+
+[endsect]
+
+
+[/==================================================]
+[section:stopwatch_formatter_hpp Header `<boost/chrono/stopwatch_formatter.hpp>`]
+[/==================================================]
+
+ namespace boost { namespace chrono {
+ class stopwatch_formatter;
+ }}
+
+[section Class `stopwatch_formatter`]
+
+`stopwatch_formatter` is a model of `Formatter`.
+
+ class stopwatch_formatter {
+ public:
+ static std::ostream & m_cout();
+ static const int m_default_places = 3;
+ static const char * default_format;
+ static int default_places() { return m_default_places; }
+
+ template < class Stopwatch >
+ static void show_time( Stopwatch & stopwatch_, const char * format, int places, std::ostream & os, system::error_code & ec);
+ };
+
The default places is given by default_places and is 3.
The default format is "\\n%ts\\n", where

-* `%t` : the result of elapsed() when the reporting is done.
+* `%d` : the result of elapsed() when the reporting is done.

The time is given using the suffix "s" following the System International d'Unites Std.

- template <class Clock> class reporting_timer : timer<Clock> {
+[endsect]
+[endsect]
+
+[/==================================================]
+[section:stopwatch_accumulator_formatter_hpp Header `<boost/chrono/stopwatch_accumulator_formatter.hpp>`]
+[/==================================================]
+
+ namespace boost { namespace chrono {
+ class stopwatch_accumulator_formatter;
+ }}
+
+[section Class `stopwatch_accumulator_formatter`]
+
+`stopwatch_accumulator_formatter` is a model of `Formatter`
+
+ class stopwatch_accumulator_formatter {
+ public:
+ static std::ostream & m_cout();
+ static const int m_default_places = 3;
+ static const char * default_format;
+ static int default_places() { return m_default_places; }
+
+ template <class Stopwatch >
+ static void show_time( Stopwatch & stopwatch_, const char * format, int places, std::ostream & os, system::error_code & ec);
+ };
+
+The default places is given by default_places and is 3.
+The default format is "\\n"Count=%c times Sum=%ss Min=%ms Max=%Ms Mean=%as\\n", where
+
+* `%c` : the counter of the number of times the pair srat/stop has been called.
+* `%s` : the sum of the samples of elapsed time between the call to start/stop.
+* `%m` : the min of the samples of elapsed time between the call to start/stop.
+* `%M` : the max of the samples of elapsed time between the call to start/stop.
+* `%a` : the mean of the samples of elapsed time between the call to start/stop.
+
+The time is given using the suffix "s" following the System International d'Unites Std.
+
+[endsect]
+
+[endsect]
+
+[/==================================================================]
+[section:process_process_stopwatches_reporter_hpp Header `<boost/chrono/process_stopwatches_reporter.hpp>`]
+[/==================================================================]
+
+
+ namespace boost { namespace chrono {
+
+ class process_stopwatches_reporter;
+
+ } }
+
+[section Class `process_stopwatches_reporter`]
+
+`process_stopwatches_reporter` is the `stopwatches_reporter<>` associated to the clock tuple `process_clocks`.
+
+class `process_stopwatches_reporter` provides a complete run time reporting package that can be invoked in a single line of code. The reporting is controled by two parameters:
+
+* format : The output format
+* places(precission): the number of decimal placess used.
+
+The default places is given by default_places and is 3.
+The default format is "\\nreal %rs, cpu %cs (%p%), user %us, system %ss\\n", where
+
+* `%r` : real process clock
+* `%u` : user process clock
+* `%s` : system process clock
+* `%c` : user+system process clock
+* `%p` : percentage (user+system)/real process clock
+
+All the units are given using the suffix "s" following the System International d'Unites Std.
+
+ class process_stopwatches_reporter : public process_timer {
 public:
- explicit reporting_timer( system::error_code & ec = system::throws );
- explicit reporting_timer( std::ostream & os,
+ explicit process_stopwatches_reporter( system::error_code & ec = system::throws );
+ explicit process_stopwatches_reporter( std::ostream & os,
 system::error_code & ec = system::throws );

- explicit reporting_timer( const std::string & format,
+ explicit process_stopwatches_reporter( const std::string & format,
 system::error_code & ec = system::throws );
- explicit reporting_timer( std::ostream & os, const std::string & format,
+ process_stopwatches_reporter( std::ostream & os, const std::string & format,
 system::error_code & ec = system::throws );

- explicit reporting_timer( const std::string & format, int places,
+ process_stopwatches_reporter( const std::string & format, int places,
 system::error_code & ec = system::throws );
- explicit reporting_timer( std::ostream & os, const std::string & format, int places,
+ process_stopwatches_reporter( std::ostream & os, const std::string & format, int places,
 system::error_code & ec = system::throws );

- explicit reporting_timer( int places,
+ explicit process_stopwatches_reporter( int places,
 system::error_code & ec = system::throws );
- explicit reporting_timer( std::ostream & os, int places,
+ process_stopwatches_reporter( std::ostream & os, int places,
 system::error_code & ec = system::throws );

- explicit reporting_timer( int places, const std::string & format,
+ process_stopwatches_reporter( int places, const std::string & format,
 system::error_code & ec = system::throws );
- explicit reporting_timer( std::ostream & os, int places, const std::string & format,
+ process_stopwatches_reporter( std::ostream & os, int places, const std::string & format,
 system::error_code & ec = system::throws );

- ~reporting_timer();
+ ~process_stopwatches_reporter();
+
+ void start( system::error_code & ec = system::throws );

 void report( system::error_code & ec = system::throws );
+
+ void test_report( duration real_, duration user_, duration system_ );
 bool reported() const;
-
 static int default_places();
 };

[endsect]

-[section `reporting_timer` useful typedefs]
+[endsect]
+

- typedef boost::chrono::reporting_timer< boost::chrono::system_clock > system_reporting_timer;
+[endsect]
+[section Deprecated Headers]
+[/==================================================]
+[section:timer_hpp Deprecated Header `<boost/chrono/timer.hpp>`]
+[/==================================================]
+
+This header has been replaced by the header <boost/chrono/stopwatch.hpp>.
+
+ namespace boost { namespace chrono {
+ template <class Clock=high_resolution_clock> class timer;
+ typedef <see above> system_timer;
 #ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
- typedef boost::chrono::reporting_timer< boost::chrono::monotonic_clock > monotonic_reporting_timer;
+ typedef <see above> monotonic_timer;
 #endif
- typedef boost::chrono::reporting_timer< boost::chrono::high_resolution_clock > high_resolution_reporting_timer;
- typedef boost::chrono::reporting_timer< boost::chrono::process_real_cpu_clock > process_real_cpu_reporting_timer;
- typedef boost::chrono::reporting_timer< boost::chrono::process_user_cpu_clock > process_user_cpu_reporting_timer;
- typedef boost::chrono::reporting_timer< boost::chrono::process_system_cpu_clock > process_system_cpu_reporting_timer;
+ typedef <see above> high_resolution_timer;
+ }}

-[endsect]
+[/
+ typedef <see above> process_real_cpu_timer;
+ typedef <see above> process_user_cpu_timer;
+ typedef <see above> process_system_cpu_timer;
+]
+[section Template Class `timer<>`]
+
+Knowing how long a part of a program takes to execute is useful in both test and production environments.
+A `timer` object measures elapsed time. It is recommended to use it with clocks that measure wall clock rather than CPU time since the intended use is performance measurement on systems where total elapsed time is more important than just process or CPU time.
+
+The maximum measurable elapsed time depends on the Clock parameter. The accuracy of timings depends on the
+accuracy of timing information provided the Clock, and this coudl varies a great deal from one clock to another.
+
+ template <class Clock> class timer {
+ public:
+ typedef Clock clock;
+ typedef typename Clock::duration duration;
+ typedef typename Clock::time_point time_point;
+
+ explicit timer( system::error_code & ec = system::throws );
+
+ ~timer();
+
+ void start( system::error_code & ec = system::throws );
+ duration elapsed( system::error_code & ec = system::throws );
+
+ };

[endsect]

-Comment ]
+[section `timer` useful typedefs]
+
+ typedef boost::chrono::timer< boost::chrono::system_clock > system_timer;
+ #ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
+ typedef boost::chrono::timer< boost::chrono::monotonic_clock > monotonic_timer;
+ #endif
+ typedef boost::chrono::timer< boost::chrono::high_resolution_clock > high_resolution_timer;
+
+[/
+ typedef boost::chrono::timer< boost::chrono::process_real_cpu_clock > process_real_cpu_timer;
+ typedef boost::chrono::timer< boost::chrono::process_user_cpu_clock > process_user_cpu_timer;
+ typedef boost::chrono::timer< boost::chrono::process_system_cpu_clock > process_system_cpu_timer;
+]
+[endsect]
+[endsect]

[/==================================================================]
-[section:process_times_hpp Header `<boost/chrono/process_times.hpp>`]
+[section:process_times_hpp Deprecated Header `<boost/chrono/process_times.hpp>`]
[/==================================================================]

+This header has been deprecated. See the `<boost/chrono/process_clocks.hpp>`, `<boost/chrono/process_stopwatches.hpp>` and `<boost/chrono/process_stopwatches_reporter.hpp>` files.

 namespace boost { namespace chrono {

 class process_clock;
+ typedef <see below> process_times;
 class process_timer;
 class run_timer;

@@ -2035,14 +2716,21 @@
[section Class `process_times`]

 struct process_times {
- process_clock::duration real; // real (i.e wall clock) time
- process_clock::duration user; // user cpu time
- process_clock::duration system; // system cpu time
+ process_clock::duration real; // real (i.e wall clock) time
+ process_clock::duration user; // user cpu time
+ process_clock::duration system; // system cpu time
 };

[endsect]

[endsect]
+[section Typedef `process_times`]
+
+ typedef process_clock::process_times process_times;
+
+This is a synonym of process_clock::process_times included for backward compatibility.
+
+[endsect]

[section Class `process_timer`]

@@ -2066,7 +2754,7 @@
[endsect]
[section Class `run_timer`]

-class `run_timer` provides a complete run time reporting package that can be invoked in a single line of code. The reporting is controleed by two parameters:
+class `run_timer` provides a complete run time reporting package that can be invoked in a single line of code. The reporting is controled by two parameters:

* format : The output format
* places(precission): the number of decimal placess used.
@@ -2126,6 +2814,8 @@

[endsect]

+[endsect]
+

[/===============]
[section Examples]
@@ -3012,20 +3702,20 @@
[endsect]

[/============================]
-[section run_timer_example.cpp]
+[section process_stopwatches_reporter_example.cpp]

-Here is the run_timer_example.cpp program supplied with the Boost Chrono library:
+Here is the process_stopwatches_reporter_example.cpp program supplied with the Boost Chrono library:

-[/run_timer_example_cpp]
+[/process_stopwatches_reporter_example_cpp]

-When the run_timer t object is created, it starts timing. When it is destroyed at the end of the program, its destructor stops the timer and displays timing information on cout.
+When the process_stopwatches_reporter t object is created, it starts timing. When it is destroyed at the end of the program, its destructor stops the timer and displays timing information on cout.

 #include <boost/chrono/process_times.hpp>
 #include <cmath>

 int main()
 {
- boost::chrono::run_timer t;
+ boost::chrono::process_stopwatches_reporter t;

 for ( long i = 0; i < 10000000; ++i )
 std::sqrt( 123.456L ); // burn some time
@@ -3043,9 +3733,9 @@

[/=============================]
-[section run_timer_example2.cpp]
+[section process_stopwatches_reporter_example2.cpp]

-The run_timer_example2.cpp program is the same, except that it supplies additional constructor arguments from the command line:
+The process_stopwatches_reporter_example2.cpp program is the same, except that it supplies additional constructor arguments from the command line:

 #include <boost/system/timer.hpp>
 #include <cmath>
@@ -3055,7 +3745,7 @@
 const char * format = argc > 1 ? argv[1] : "%t cpu seconds\n";
 int places = argc > 2 ? std::atoi( argv[2] ) : 2;

- boost::chrono::run_timer t( format, places );
+ boost::chrono::process_stopwatches_reporter t( format, places );

 for ( long i = 0; i < 10000000; ++i )
 std::sqrt( 123.456L ); // burn some time
@@ -3065,16 +3755,16 @@

Here is the output for this program for several sets of command line arguments:

- run_timer_example2
+ process_stopwatches_reporter_example2
 0.42 cpu seconds

- run_timer_example2 "%w wall clock seconds\n"
+ process_stopwatches_reporter_example2 "%w wall clock seconds\n"
 0.41 wall clock seconds

- run_timer_example2 "%w wall clock seconds\n" 6
+ process_stopwatches_reporter_example2 "%w wall clock seconds\n" 6
 0.421875 wall clock seconds

- run_timer_example2 "%t total CPU seconds\n" 3
+ process_stopwatches_reporter_example2 "%t total CPU seconds\n" 3
 0.422 total CPU seconds

[endsect]
@@ -3116,7 +3806,7 @@
 if ( verbose )
 { std::cout << "command: \"" << s.c_str() << "\"\n"; }

- boost::chrono::run_timer t;
+ boost::chrono::process_stopwatches_reporter t;

 return std::system( s.c_str() );
 }
@@ -3131,6 +3821,25 @@
[section:history Appendix A: History]
[/==================================]

+[section [*Version 0.3.0, December 20, 2009] ['New stopwatch feature + Bug fixes]]
+[*Features:]
+
+* independent cpu clocks for real, user, system process CPU time.
+* new Stopwatch concept measuring elapsed time between different points in time associated to the operations start, stop, suspend and resume.
+* stopwatch is a model Stopwatch measuring the elapsed time between the start and the stop operations.
+* stopwatch_accumulator is a model Stopwatch allowing to accumulate several time samples and give the average, ...
+* scoped helper classes allowing to pairwise start/stop operations, suspend/resume and resume/suspend a Stopwatch.
+* new Stopwatch Formatter concept
+* stopwatch_reporter is a generic class reporting elapsed time for the Stopwatch concept.
+* process_times.hpp has been deprecated, see process_clocks.hpp, process_stopwhatches.hpp and process_stopwhatches_reporter.hpp.
+* timer.hpp has been deprecated, see stopwatch.
+
+[*Bug Fixes]
+
+* Try to correct warning C4251: 'boost::chrono::run_timer::m_format' : class 'std::basic_string<_Elem,_Traits,_Ax>' needs to have dll-interface to be used by clients of class 'boost::chrono::run_timer', by don't including inlines functions using the std::string m_format.
+
+[endsect]
+
[section [*Version 0.2.1, December 13, 2009] ['Bug fixes]]

[*Bug Fixes]
@@ -3293,11 +4002,11 @@
[section:implementation Appendix C: Implementation Notes]

-[heading Why does run_timer only display millisecond place precision when the underlying timer has nanosecond precision?]
+[heading Why does process_stopwatches_reporter only display millisecond place precision when the underlying timer has nanosecond precision?]

To avoid giving the impression of precision where none exists. See Caveat emptor. You can always specify additional decimal places if you want to live dangerously.

-[heading Why does run_timer sometimes report more cpu seconds than real seconds?]
+[heading Why does process_stopwatches_reporter sometimes report more cpu seconds than real seconds?]

Ask your operating system supplier. The results have been inspected with a debugger, and both for Windows and Linux, that's what the OS appears to be reporting at times.

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices.html 2009-12-21 11:56:04 EST (Mon, 21 Dec 2009)
@@ -29,6 +29,8 @@
<div class="toc"><dl>
<dt> Appendix A: History</dt>
<dd><dl>
+<dt><a href="appendices/history.html#boost_chrono.appendices.history.__version_0_3_0__december_20__2009____new_stopwatch_feature___bug_fixes_">Version 0.3.0, December 20, 2009 New stopwatch
+ feature + Bug fixes</a></dt>
<dt>Version 0.2.1, December 13, 2009 Bug fixes</dt>
<dt><a href="appendices/history.html#boost_chrono.appendices.history.__version_0_2_0__december_8__2009______features___bug_fixes___updated_documentation_">Version 0.2.0, December 8, 2009 + Features
+ Bug fixes + Updated documentation</a></dt>

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/history.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/history.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/history.html 2009-12-21 11:56:04 EST (Mon, 21 Dec 2009)
@@ -27,6 +27,8 @@
<a name="boost_chrono.appendices.history"></a> Appendix A: History
</h3></div></div></div>
<div class="toc"><dl>
+<dt><a href="history.html#boost_chrono.appendices.history.__version_0_3_0__december_20__2009____new_stopwatch_feature___bug_fixes_">Version 0.3.0, December 20, 2009 New stopwatch
+ feature + Bug fixes</a></dt>
<dt>Version 0.2.1, December 13, 2009 Bug fixes</dt>
<dt><a href="history.html#boost_chrono.appendices.history.__version_0_2_0__december_8__2009______features___bug_fixes___updated_documentation_">Version 0.2.0, December 8, 2009 + Features
+ Bug fixes + Updated documentation</a></dt>
@@ -35,6 +37,60 @@
</dl></div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_chrono.appendices.history.__version_0_3_0__december_20__2009____new_stopwatch_feature___bug_fixes_"></a><a href="history.html#boost_chrono.appendices.history.__version_0_3_0__december_20__2009____new_stopwatch_feature___bug_fixes_" title="Version 0.3.0, December 20, 2009 New stopwatch
+ feature + Bug fixes">Version 0.3.0, December 20, 2009 New stopwatch
+ feature + Bug fixes</a>
+</h4></div></div></div>
+
+ Features:
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+ independent cpu clocks for real, user, system process CPU time.
+ </li>
+<li>
+ new Stopwatch concept measuring elapsed time between different points
+ in time associated to the operations start, stop, suspend and resume.
+ </li>
+<li>
+ stopwatch is a model Stopwatch measuring the elapsed time between the
+ start and the stop operations.
+ </li>
+<li>
+ stopwatch_accumulator is a model Stopwatch allowing to accumulate several
+ time samples and give the average, ...
+ </li>
+<li>
+ scoped helper classes allowing to pairwise start/stop operations, suspend/resume
+ and resume/suspend a Stopwatch.
+ </li>
+<li>
+ new Stopwatch Formatter concept
+ </li>
+<li>
+ stopwatch_reporter is a generic class reporting elapsed time for the
+ Stopwatch concept.
+ </li>
+<li>
+ process_times.hpp has been deprecated, see process_clocks.hpp, process_stopwhatches.hpp
+ and process_stopwhatches_reporter.hpp.
+ </li>
+<li>
+ timer.hpp has been deprecated, see stopwatch.
+ </li>
+</ul></div>
+
+ Bug Fixes
+ 
+<div class="itemizedlist"><ul type="disc"><li>
+ Try to correct warning C4251: 'boost::chrono::run_timer::m_format' :
+ class 'std::basic_string<_Elem,_Traits,_Ax>' needs to have dll-interface
+ to be used by clients of class 'boost::chrono::run_timer', by don't including
+ inlines functions using the std::string m_format.
+ </li></ul></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
<a name="boost_chrono.appendices.history.__version_0_2_1__december_13__2009____bug_fixes_"></a>Version 0.2.1, December 13, 2009 Bug fixes
</h4></div></div></div>

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/implementation.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/implementation.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/implementation.html 2009-12-21 11:56:04 EST (Mon, 21 Dec 2009)
@@ -30,21 +30,22 @@
 Implementation Notes"> Appendix C:
 Implementation Notes</a>
</h3></div></div></div>
-<a name="boost_chrono.appendices.implementation.why_does_run_timer_only_display_millisecond_place_precision_when_the_underlying_timer_has_nanosecond_precision_"></a><h4>
-<a name="id4882086"></a>
- <a href="implementation.html#boost_chrono.appendices.implementation.why_does_run_timer_only_display_millisecond_place_precision_when_the_underlying_timer_has_nanosecond_precision_">Why
- does run_timer only display millisecond place precision when the underlying
- timer has nanosecond precision?</a>
+<a name="boost_chrono.appendices.implementation.why_does_process_stopwatches_reporter_only_display_millisecond_place_precision_when_the_underlying_timer_has_nanosecond_precision_"></a><h4>
+<a name="id4899920"></a>
+ <a href="implementation.html#boost_chrono.appendices.implementation.why_does_process_stopwatches_reporter_only_display_millisecond_place_precision_when_the_underlying_timer_has_nanosecond_precision_">Why
+ does process_stopwatches_reporter only display millisecond place precision
+ when the underlying timer has nanosecond precision?</a>
 </h4>

 To avoid giving the impression of precision where none exists. See Caveat
 emptor. You can always specify additional decimal places if you want to live
 dangerously.
 
-<a name="boost_chrono.appendices.implementation.why_does_run_timer_sometimes_report_more_cpu_seconds_than_real_seconds_"></a><h4>
-<a name="id4882127"></a>
- <a href="implementation.html#boost_chrono.appendices.implementation.why_does_run_timer_sometimes_report_more_cpu_seconds_than_real_seconds_">Why
- does run_timer sometimes report more cpu seconds than real seconds?</a>
+<a name="boost_chrono.appendices.implementation.why_does_process_stopwatches_reporter_sometimes_report_more_cpu_seconds_than_real_seconds_"></a><h4>
+<a name="id4899959"></a>
+ <a href="implementation.html#boost_chrono.appendices.implementation.why_does_process_stopwatches_reporter_sometimes_report_more_cpu_seconds_than_real_seconds_">Why
+ does process_stopwatches_reporter sometimes report more cpu seconds than
+ real seconds?</a>
 </h4>

 Ask your operating system supplier. The results have been inspected with

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/rationale.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/rationale.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/rationale.html 2009-12-21 11:56:04 EST (Mon, 21 Dec 2009)
@@ -33,7 +33,7 @@
 are an extract from this document.
 
<a name="boost_chrono.appendices.rationale.is_it_possible_for_the_user_to_pass_a__code__phrase_role__identifier__duration__phrase___code__to_a_function_with_the_units_being_ambiguous_"></a><h4>
-<a name="id4880918"></a>
+<a name="id4898752"></a>
 <a href="rationale.html#boost_chrono.appendices.rationale.is_it_possible_for_the_user_to_pass_a__code__phrase_role__identifier__duration__phrase___code__to_a_function_with_the_units_being_ambiguous_">Is
 it possible for the user to pass a <code class="computeroutput">duration</code>
 to a function with the units being ambiguous?</a>
@@ -45,7 +45,7 @@
<pre class="programlisting">f(3); // Will not compile, 3 is not implicitly convertible to any `duration`
</pre>
<a name="boost_chrono.appendices.rationale.why_duration_needs_operator_"></a><h4>
-<a name="id4881008"></a>
+<a name="id4898840"></a>
 <a href="rationale.html#boost_chrono.appendices.rationale.why_duration_needs_operator_">Why
 duration needs operator%</a>
 </h4>
@@ -73,7 +73,7 @@
};
</pre>
<a name="boost_chrono.appendices.rationale.why_ratio_needs_copyconstruction_and_assignment_from_ratios_having_the_same_normalized_form"></a><h4>
-<a name="id4881586"></a>
+<a name="id4899419"></a>
 <a href="rationale.html#boost_chrono.appendices.rationale.why_ratio_needs_copyconstruction_and_assignment_from_ratios_having_the_same_normalized_form">Why
 ratio needs CopyConstruction and Assignment from ratios having the same normalized
 form</a>
@@ -102,7 +102,7 @@
 succeeds.
 
<a name="boost_chrono.appendices.rationale.why_ratio_needs_the_nested_normalizer_typedef_type"></a><h4>
-<a name="id4881875"></a>
+<a name="id4899708"></a>
 <a href="rationale.html#boost_chrono.appendices.rationale.why_ratio_needs_the_nested_normalizer_typedef_type">Why
 ratio needs the nested normalizer typedef type</a>
 </h4>

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/todo.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/todo.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/todo.html 2009-12-21 11:56:04 EST (Mon, 21 Dec 2009)
@@ -27,7 +27,7 @@
<a name="boost_chrono.appendices.todo"></a> Appendix F: Future plans
</h3></div></div></div>
<a name="boost_chrono.appendices.todo.tasks_to_do_before_review"></a><h4>
-<a name="id4882722"></a>
+<a name="id4900558"></a>
 <a href="todo.html#boost_chrono.appendices.todo.tasks_to_do_before_review">Tasks
 to do before review</a>
 </h4>
@@ -61,7 +61,7 @@
 > high resolution timers to avoid these issues.
 
<a name="boost_chrono.appendices.todo.for_later_releases"></a><h4>
-<a name="id4882780"></a>
+<a name="id4900616"></a>
 <a href="todo.html#boost_chrono.appendices.todo.for_later_releases">For later
 releases</a>
 </h4>

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/examples.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/examples.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/examples.html 2009-12-21 11:56:04 EST (Mon, 21 Dec 2009)
@@ -6,7 +6,8 @@
<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
<link rel="start" href="../index.html" title="Boost.Chrono">
<link rel="up" href="../index.html" title="Boost.Chrono">
-<link rel="prev" href="reference/process_times_hpp.html" title=" Header <boost/chrono/process_times.hpp>">
+<link rel="prev" href="reference/deprecated_headers.html" title="Deprecated
+ Headers">
<link rel="next" href="examples/si_units.html" title="SI-units">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -20,7 +21,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="reference/process_times_hpp.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="examples/si_units.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="reference/deprecated_headers.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="examples/si_units.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
@@ -42,8 +43,8 @@
Hinnant's original demonstration program</a></dt>
<dt><a href="examples/a_tiny_program_that_times_how_long_until_a_key_is_struck.html">A
tiny program that times how long until a key is struck</a></dt>
-<dt>run_timer_example.cpp</dt>
-<dt>run_timer_example2.cpp</dt>
+<dt>process_stopwatches_reporter_example.cpp</dt>
+<dt>process_stopwatches_reporter_example2.cpp</dt>
<dt>time command</dt>
</dl></div>
</div>
@@ -57,7 +58,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="reference/process_times_hpp.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="examples/si_units.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="reference/deprecated_headers.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="examples/si_units.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
</body>
</html>

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/examples/a_tiny_program_that_times_how_long_until_a_key_is_struck.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/examples/a_tiny_program_that_times_how_long_until_a_key_is_struck.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/examples/a_tiny_program_that_times_how_long_until_a_key_is_struck.html 2009-12-21 11:56:04 EST (Mon, 21 Dec 2009)
@@ -9,7 +9,7 @@
<link rel="up" href="../examples.html" title="Examples">
<link rel="prev" href="howard_hinnant_s_original_demonstration_program.html" title="Howard
Hinnant's original demonstration program">
-<link rel="next" href="run_timer_example_cpp.html" title="run_timer_example.cpp">
+<link rel="next" href="process_stopwatches_reporter_example_cpp.html" title="process_stopwatches_reporter_example.cpp">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
@@ -22,7 +22,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="howard_hinnant_s_original_demonstration_program.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="run_timer_example_cpp.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="howard_hinnant_s_original_demonstration_program.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="process_stopwatches_reporter_example_cpp.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h3 class="title">
@@ -106,7 +106,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="howard_hinnant_s_original_demonstration_program.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="run_timer_example_cpp.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="howard_hinnant_s_original_demonstration_program.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="process_stopwatches_reporter_example_cpp.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
</body>
</html>

Added: sandbox/chrono/libs/chrono/doc/html/boost_chrono/examples/process_stopwatches_reporter_example2_cpp.html
==============================================================================
--- (empty file)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/examples/process_stopwatches_reporter_example2_cpp.html 2009-12-21 11:56:04 EST (Mon, 21 Dec 2009)
@@ -0,0 +1,78 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>process_stopwatches_reporter_example2.cpp</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="../../index.html" title="Boost.Chrono">
+<link rel="up" href="../examples.html" title="Examples">
+<link rel="prev" href="process_stopwatches_reporter_example_cpp.html" title="process_stopwatches_reporter_example.cpp">
+<link rel="next" href="time_command.html" title="time command">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="process_stopwatches_reporter_example_cpp.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="time_command.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_chrono.examples.process_stopwatches_reporter_example2_cpp"></a>process_stopwatches_reporter_example2.cpp
+</h3></div></div></div>
+
+ The process_stopwatches_reporter_example2.cpp program is the same, except
+ that it supplies additional constructor arguments from the command line:
+ 
+<pre class="programlisting">#include <boost/system/timer.hpp>
+#include <cmath>
+
+int main( int argc, char * argv[] )
+{
+ const char * format = argc > 1 ? argv[1] : "%t cpu seconds\n";
+ int places = argc > 2 ? std::atoi( argv[2] ) : 2;
+
+ boost::chrono::process_stopwatches_reporter t( format, places );
+
+ for ( long i = 0; i < 10000000; ++i )
+ std::sqrt( 123.456L ); // burn some time
+
+ return 0;
+}
+</pre>
+
+ Here is the output for this program for several sets of command line arguments:
+ 
+<pre class="programlisting">process_stopwatches_reporter_example2
+0.42 cpu seconds
+
+process_stopwatches_reporter_example2 "%w wall clock seconds\n"
+0.41 wall clock seconds
+
+process_stopwatches_reporter_example2 "%w wall clock seconds\n" 6
+0.421875 wall clock seconds
+
+process_stopwatches_reporter_example2 "%t total CPU seconds\n" 3
+0.422 total CPU seconds
+</pre>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 Howard Hinnant Copyright © 2006 , 2008 Beman Dawes Copyright © 2009 Vicente J. Botet Escriba
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="process_stopwatches_reporter_example_cpp.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="time_command.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/chrono/libs/chrono/doc/html/boost_chrono/examples/process_stopwatches_reporter_example_cpp.html
==============================================================================
--- (empty file)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/examples/process_stopwatches_reporter_example_cpp.html 2009-12-21 11:56:04 EST (Mon, 21 Dec 2009)
@@ -0,0 +1,77 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>process_stopwatches_reporter_example.cpp</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="../../index.html" title="Boost.Chrono">
+<link rel="up" href="../examples.html" title="Examples">
+<link rel="prev" href="a_tiny_program_that_times_how_long_until_a_key_is_struck.html" title="A
+ tiny program that times how long until a key is struck">
+<link rel="next" href="process_stopwatches_reporter_example2_cpp.html" title="process_stopwatches_reporter_example2.cpp">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="a_tiny_program_that_times_how_long_until_a_key_is_struck.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="process_stopwatches_reporter_example2_cpp.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_chrono.examples.process_stopwatches_reporter_example_cpp"></a>process_stopwatches_reporter_example.cpp
+</h3></div></div></div>
+
+ Here is the process_stopwatches_reporter_example.cpp program supplied with
+ the Boost Chrono library:
+ 
+
+ When the process_stopwatches_reporter t object is created, it starts timing.
+ When it is destroyed at the end of the program, its destructor stops the
+ timer and displays timing information on cout.
+ 
+<pre class="programlisting">#include <boost/chrono/process_times.hpp>
+#include <cmath>
+
+int main()
+{
+ boost::chrono::process_stopwatches_reporter t;
+
+ for ( long i = 0; i < 10000000; ++i )
+ std::sqrt( 123.456L ); // burn some time
+
+ return 0;
+}
+</pre>
+
+ The output of this program run on a circa 2006 processor looks was this:
+ 
+<pre class="programlisting">wall 0.42 s, user 0.41 s + system 0.00 s = total cpu 0.41 s, (96.3%)
+</pre>
+
+ In other words, this program ran in 0.42 seconds as would be measured by
+ a clock on the wall, the operating system charged it for 0.41 seconds of
+ user CPU time and 0 seconds of system CPU time, the total of these two was
+ 0.41, and that represented 96.3 percent of the wall clock time.
+ 
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 Howard Hinnant Copyright © 2006 , 2008 Beman Dawes Copyright © 2009 Vicente J. Botet Escriba
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="a_tiny_program_that_times_how_long_until_a_key_is_struck.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="process_stopwatches_reporter_example2_cpp.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/examples/time_command.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/examples/time_command.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/examples/time_command.html 2009-12-21 11:56:04 EST (Mon, 21 Dec 2009)
@@ -6,7 +6,7 @@
<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
<link rel="start" href="../../index.html" title="Boost.Chrono">
<link rel="up" href="../examples.html" title="Examples">
-<link rel="prev" href="run_timer_example2_cpp.html" title="run_timer_example2.cpp">
+<link rel="prev" href="process_stopwatches_reporter_example2_cpp.html" title="process_stopwatches_reporter_example2.cpp">
<link rel="next" href="../appendices.html" title="Appendices">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -20,7 +20,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="run_timer_example2_cpp.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="../appendices.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="process_stopwatches_reporter_example2_cpp.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="../appendices.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h3 class="title">
@@ -60,7 +60,7 @@
 if ( verbose )
 { std::cout << "command: \"" << s.c_str() << "\"\n"; }

- boost::chrono::run_timer t;
+ boost::chrono::process_stopwatches_reporter t;

 return std::system( s.c_str() );
}
@@ -76,7 +76,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="run_timer_example2_cpp.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="../appendices.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="process_stopwatches_reporter_example2_cpp.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="../appendices.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
</body>
</html>

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/overview.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/overview.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/overview.html 2009-12-21 11:56:04 EST (Mon, 21 Dec 2009)
@@ -35,7 +35,7 @@
<dt>Duration</dt>
<dt>Clocks</dt>
<dt>Time Point</dt>
-<dt>Timers</dt>
+<dt>Stopwatches</dt>
</dl></dd>
<dt>Caveat emptor</dt>
</dl></div>
@@ -73,33 +73,63 @@
</ul></div>
</li>
<li>
- Class template timer, with typedefs:
+ Process clocks:
 <div class="itemizedlist"><ul type="circle">
-<li><code class="computeroutput">system_timer</code></li>
-<li><code class="computeroutput">monotonic_timer</code></li>
-<li><code class="computeroutput">high_resolution_timer</code></li>
+<li>
+<code class="computeroutput">process_real_CPU_clocks</code>,
+ capturing real-CPU times.
+ </li>
+<li>
+<code class="computeroutput">process_user_CPU_clocks</code>,
+ capturing user-CPU times.
+ </li>
+<li>
+<code class="computeroutput">process_system_CPU_clocks</code>,
+ capturing system-CPU times.
+ </li>
+<li>
+<code class="computeroutput">process_clocks</code>, tuple-like
+ class capturing at once real, user-CPU, and system-CPU times.
+ </li>
</ul></div>
</li>
<li>
- Process clocks and timers:
+ Stopwatches:
 <div class="itemizedlist"><ul type="circle">
<li>
-<code class="computeroutput">process_clock</code>, capturing
- real, user-CPU, and system-CPU times.
+<code class="computeroutput">stopwatch</code>, capturing
+ elapsed Clock times.
+ </li>
+<li>
+<code class="computeroutput">stopwatch_accumulator</code>,
+ capturing cummulated elapsed Clock times.
+ </li>
+<li>
+ scoped helper classes allowing to pairwise start/stop operations, suspend/resume
+ and resume/suspend a Stopwatch.
+ </li>
+<li>
+<code class="computeroutput">process_stopwatches</code>,
+ capturing elapsed real, user-CPU, and system-CPU times.
 </li>
+</ul></div>
+</li>
+<li>
+ Stopwatch reporters:
+ <div class="itemizedlist"><ul type="circle">
<li>
-<code class="computeroutput">process_timer</code>, capturing
- elapsed real, user-CPU, and system-CPU times.
+<code class="computeroutput">stopwatch_reporter</code>, convenient
+ reporting of models of Stopwatch results.
 </li>
<li>
-<code class="computeroutput">run_timer</code>, convenient
- reporting of process_timer results.
+<code class="computeroutput">process_stopwatches_reporter</code>,
+ convenient reporting of process_stopwatches results.
 </li>
</ul></div>
</li>
</ul></div>
<a name="boost_chrono.overview.how_to_use_this_documentation"></a><h3>
-<a name="id4764955"></a>
+<a name="id4765014"></a>
 <a href="overview.html#boost_chrono.overview.how_to_use_this_documentation">How to
 Use This Documentation</a>
 </h3>

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/overview/motivation.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/overview/motivation.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/overview/motivation.html 2009-12-21 11:56:04 EST (Mon, 21 Dec 2009)
@@ -33,7 +33,7 @@
<dt>Duration</dt>
<dt>Clocks</dt>
<dt>Time Point</dt>
-<dt>Timers</dt>
+<dt>Stopwatches</dt>
</dl></div>

 See N2661 - A Foundation to Sleep On which is
@@ -237,7 +237,7 @@
 needs only 23 bits to cover that range.
 
<a name="boost_chrono.overview.motivation.duration.so_what_exactly_is_a__code__phrase_role__identifier__duration__phrase___code__and_how_do_i_use_one_"></a><h5>
-<a name="id4759345"></a>
+<a name="id4759672"></a>
 <a href="motivation.html#boost_chrono.overview.motivation.duration.so_what_exactly_is_a__code__phrase_role__identifier__duration__phrase___code__and_how_do_i_use_one_">So
 What Exactly is a <code class="computeroutput">duration</code>
 and How Do I Use One?</a>
@@ -295,7 +295,7 @@
 instead of inheritance).
 
<a name="boost_chrono.overview.motivation.duration.what_happens_if_i_assign__code__phrase_role__identifier__m3__phrase___phrase_role__special_____phrase___phrase_role__identifier__us3__phrase___code__to__code__phrase_role__identifier__minutes__phrase___code__instead_of__code__phrase_role__identifier__microseconds__phrase___code__"></a><h5>
-<a name="id4759354"></a>
+<a name="id4813150"></a>
 <a href="motivation.html#boost_chrono.overview.motivation.duration.what_happens_if_i_assign__code__phrase_role__identifier__m3__phrase___phrase_role__special_____phrase___phrase_role__identifier__us3__phrase___code__to__code__phrase_role__identifier__minutes__phrase___code__instead_of__code__phrase_role__identifier__microseconds__phrase___code__">What
 happens if I assign <code class="computeroutput">m3 + us3</code>
 to <code class="computeroutput">minutes</code> instead of
@@ -312,7 +312,7 @@
 ignored. This is similar to the problem of assigning a double to an <code class="computeroutput">int</code>: the fractional part gets silently discarded.
 
<a name="boost_chrono.overview.motivation.duration.but_what_if_the_truncation_behavior_is_what_i_want_to_do_"></a><h5>
-<a name="id4813279"></a>
+<a name="id4813318"></a>
 <a href="motivation.html#boost_chrono.overview.motivation.duration.but_what_if_the_truncation_behavior_is_what_i_want_to_do_">But
 what if the truncation behavior is what I want to do?</a>
 </h5>
@@ -332,7 +332,7 @@
 as often as it can.
 
<a name="boost_chrono.overview.motivation.duration.i_m_trafficking_in_floating_point__code__phrase_role__identifier__duration__phrase___code_s__i_don_t_want_to_deal_with_writing__code__phrase_role__identifier__duration_cast__phrase___code__all_over_the_place__i_m_content_with_the_precision_of_my_floating_point_representation"></a><h5>
-<a name="id4813416"></a>
+<a name="id4813455"></a>
 <a href="motivation.html#boost_chrono.overview.motivation.duration.i_m_trafficking_in_floating_point__code__phrase_role__identifier__duration__phrase___code_s__i_don_t_want_to_deal_with_writing__code__phrase_role__identifier__duration_cast__phrase___code__all_over_the_place__i_m_content_with_the_precision_of_my_floating_point_representation">I'm
 trafficking in floating point <code class="computeroutput">duration</code>s.
 I don't want to deal with writing <code class="computeroutput">duration_cast</code>
@@ -347,7 +347,7 @@
dminutes dm4 = m3 + us3; // dm4.count() == 5.000000083333333
</pre>
<a name="boost_chrono.overview.motivation.duration.how_expensive_is_all_of_this_"></a><h5>
-<a name="id4813578"></a>
+<a name="id4813617"></a>
 <a href="motivation.html#boost_chrono.overview.motivation.duration.how_expensive_is_all_of_this_">How
 expensive is all of this?</a>
 </h5>
@@ -361,7 +361,7 @@
 tick counts.
 
<a name="boost_chrono.overview.motivation.duration.how_complicated_is_it_to_build_a_function_taking_a__code__phrase_role__identifier__duration__phrase___code__parameter_"></a><h5>
-<a name="id4813628"></a>
+<a name="id4813667"></a>
 <a href="motivation.html#boost_chrono.overview.motivation.duration.how_complicated_is_it_to_build_a_function_taking_a__code__phrase_role__identifier__duration__phrase___code__parameter_">How
 complicated is it to build a function taking a <code class="computeroutput">duration</code>
 parameter?</a>
@@ -583,7 +583,7 @@
 the relationship between the epochs associated with each clock is known.
 
<a name="boost_chrono.overview.motivation.time_point.so_what_exactly_is_a__code__phrase_role__identifier__time_point__phrase___code__and_how_do_i_use_one_"></a><h5>
-<a name="id4815433"></a>
+<a name="id4815472"></a>
 <a href="motivation.html#boost_chrono.overview.motivation.time_point.so_what_exactly_is_a__code__phrase_role__identifier__time_point__phrase___code__and_how_do_i_use_one_">So
 What Exactly is a <code class="computeroutput">time_point</code>
 and How Do I Use One?</a>
@@ -666,34 +666,81 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h4 class="title">
-<a name="boost_chrono.overview.motivation.timers"></a>Timers
+<a name="boost_chrono.overview.motivation.stopwatches"></a>Stopwatches
</h4></div></div></div>

- Knowing how long a program takes to execute is useful in both test and
- production environments. It is also helpful if such timing information
- is broken down into real (wall clock) time, CPU time spent by the user,
- and CPU time spent by the operating system servicing user requests.
+ Knowing how long a program, a function or a specific block takes to execute
+ is useful in both test and production environments. Boost.Chrono
+ introduces the Stopwatch concept which captures the mechanism to measure
+ the elapsed time. <code class="computeroutput">stopwatch<></code> is the basic model of Stopwatch
 

- The Boost Chrono Library's process times components provide that information:
+ It is also interesting to have an statisitical view of these times. <code class="computeroutput">stopwatch_accumulator<></code>
+ associates an accumulator with a stopwatch, so we are able to retrieve
+ any statistical feature Boost.Accumulator provides. the Aprovides stopwatches
+ utilities useful when the automatic reporting of <code class="computeroutput">stopwatch_reporter</code>
+ isn't desired.
 
-<div class="itemizedlist"><ul type="disc">
-<li>
- At the highest level, class <code class="computeroutput">run_timer</code>
- provides a complete run time reporting package that can be invoked in
- a single line of code.
- </li>
-<li>
- At a middle level, class <code class="computeroutput">process_timer</code>
- provides a process timer useful when the automatic reporting of <code class="computeroutput">run_timer</code> isn't desired.
- </li>
-<li>
- At the lowest level, <code class="computeroutput">process_clock</code>
- provides a thin wrapper around the operating system's process timer API.
- For POSIX-like systems, that's the times() function, while for Windows,
- it's the GetProcessTimes() function.
- </li>
-</ul></div>
+
+ The highest level use case of measuring the elapsed time is to report these
+ times on the display. <code class="computeroutput">stopwatch_reporter<></code> provides a run time reporting package
+ that can be invoked in a single line of code to report the usage of a Clock.
+ 
+
+ For example
+ 
+<pre class="programlisting">using namespace boost::chrono;
+int f1(long j) {
+ static stopwatch_accumulator<>::reporter sw;
+ stopwatch_accumulator<>::reporter::scoped_run _(sw);
+
+ for ( long i = 0; i < j; ++i )
+ std::sqrt( 123.456L ); // burn some time
+
+ return 0;
+}
+int main() {
+ f1(100000);
+ f1(200000);
+ f1(300000);
+ return 0;
+}
+</pre>
+
+ Will produce the following output
+ 
+<pre class="programlisting">Count=3 times Sum=0.034s Min=0.006s Max=0.017s Mean=0.011s
+</pre>
+
+ It is also helpful if such timing information is broken down into real
+ (wall clock) time, CPU time spent by the user, and CPU time spent by the
+ operating system servicing user requests. <code class="computeroutput">process_real_CPU_clock</code>,
+ <code class="computeroutput">process_user_CPU_clock</code>,
+ <code class="computeroutput">process_system_CPU_clock</code>
+ and <code class="computeroutput">process_clocks</code> provides
+ a thin wrappers around the operating system's process timer API. The first
+ three captre the a specific time unitarily, the last captures the three
+ times at once. For POSIX-like systems, that's the times() function, while
+ for Windows, it's the GetProcessTimes() function.
+ 
+
+ As <code class="computeroutput">process_clocks</code> do not
+ conform to the Stopwatch concept, Boost.Chrono
+ provides the equivalent of <code class="computeroutput">stopwatch<process_clocks></code> and <code class="computeroutput">stopwatch_reporter<process_clocks></code> with the classes <code class="computeroutput">process_stopwatches</code>
+ and <code class="computeroutput">process_stopwatches_reporter</code>
+ 
+<pre class="programlisting">using namespace boost::chrono;
+int main()
+{
+ process_stopwatches_reporter _;
+ // ...
+}
+</pre>
+
+ Will produce the following output
+ 
+<pre class="programlisting">real 0.034s, cpu 0.031s (93.0%), user 0.031s, system 0.000s
+</pre>
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference.html 2009-12-21 11:56:04 EST (Mon, 21 Dec 2009)
@@ -7,7 +7,8 @@
<link rel="start" href="../index.html" title="Boost.Chrono">
<link rel="up" href="../index.html" title="Boost.Chrono">
<link rel="prev" href="users_guide/ext_references.html" title=" References">
-<link rel="next" href="reference/common_type_hpp.html" title=" Header <boost/type_traits/common_type.hpp>">
+<link rel="next" href="reference/cpp0x.html" title=" Included on the C++0x
+ recommendation">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
@@ -20,67 +21,56 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="users_guide/ext_references.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="reference/common_type_hpp.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="users_guide/ext_references.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="reference/cpp0x.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="boost_chrono.reference"></a> Reference
</h2></div></div></div>
<div class="toc"><dl>
-<dt> Header <boost/type_traits/common_type.hpp></dt>
-<dd><dl><dt><a href="reference/common_type_hpp.html#boost_chrono.reference.common_type_hpp.common_type">
- Class Template <code class="computeroutput">common_type</code></a></dt></dl></dd>
-<dt> Header <boost/ratio.hpp></dt>
+<dt><a href="reference/cpp0x.html"> Included on the C++0x
+ recommendation</a></dt>
<dd><dl>
-<dt><a href="reference/ratio_hpp.html#boost_chrono.reference.ratio_hpp.ratio"> Class Template
- <code class="computeroutput">ratio<></code></a></dt>
-<dt><a href="reference/ratio_hpp.html#boost_chrono.reference.ratio_hpp.ratio_arithmetic">
- <code class="computeroutput">ratio</code> arithmetic</a></dt>
-<dt><a href="reference/ratio_hpp.html#boost_chrono.reference.ratio_hpp.ratio_comparison">
- <code class="computeroutput">ratio</code> comparison</a></dt>
-<dt><a href="reference/ratio_hpp.html#boost_chrono.reference.ratio_hpp.ration_SI_typedefs">
- SI typedefs</a></dt>
+<dt><a href="reference/cpp0x.html#boost_chrono.reference.cpp0x.common_type_hpp"> Header
+ <code class="computeroutput"><boost/type_traits/common_type.hpp></code></a></dt>
+<dt> Header <boost/ratio.hpp></dt>
+<dt> Header <boost/chrono.hpp></dt>
</dl></dd>
-<dt> Header <boost/chrono.hpp></dt>
+<dt><a href="reference/process_cpu_related.html">Process CPU
+ related</a></dt>
+<dd><dl><dt><a href="reference/process_cpu_related.html#boost_chrono.reference.process_cpu_related.process_clocks_hpp">
+ Header <code class="computeroutput"><boost/chrono/process_clocks.hpp></code></a></dt></dl></dd>
+<dt>Stopwatches</dt>
<dd><dl>
-<dt>Clock Requirements</dt>
-<dt><a href="reference/chrono_hpp.html#boost_chrono.reference.chrono_hpp.time_related_traits">Time-related
- traits</a></dt>
-<dt><a href="reference/chrono_hpp.html#boost_chrono.reference.chrono_hpp.class_template__duration_">Class
- template <code class="computeroutput">duration</code></a></dt>
-<dt><a href="reference/chrono_hpp.html#boost_chrono.reference.chrono_hpp.duration_non_member_arithmetic">duration
- non-member arithmetic</a></dt>
-<dt><a href="reference/chrono_hpp.html#boost_chrono.reference.chrono_hpp.duration_comparaisons">duration
- comparaisons</a></dt>
-<dt><a href="reference/chrono_hpp.html#boost_chrono.reference.chrono_hpp.duration_cast"> Non-Member
- function <code class="computeroutput">duration_cast(duration)</code></a></dt>
-<dt><a href="reference/chrono_hpp.html#boost_chrono.reference.chrono_hpp.class_template__time_point_">Class
- template <code class="computeroutput">time_point</code></a></dt>
-<dt><a href="reference/chrono_hpp.html#boost_chrono.reference.chrono_hpp.time_point_non_member_arithmetic">time_point
- non-member arithmetic</a></dt>
-<dt><a href="reference/chrono_hpp.html#boost_chrono.reference.chrono_hpp.time_point_comparisons">time_point
- comparisons</a></dt>
-<dt><a href="reference/chrono_hpp.html#boost_chrono.reference.chrono_hpp.class__system_clock_">Class
- <code class="computeroutput">system_clock</code></a></dt>
-<dt><a href="reference/chrono_hpp.html#boost_chrono.reference.chrono_hpp.class__monotonic_clock_">Class
- <code class="computeroutput">monotonic_clock</code></a></dt>
-<dt><a href="reference/chrono_hpp.html#boost_chrono.reference.chrono_hpp.class__high_resolution_clock_">Class
- <code class="computeroutput">high_resolution_clock</code></a></dt>
+<dt>Stopwatch Requirements</dt>
+<dt><a href="reference/stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_hpp">
+ Header <code class="computeroutput"><boost/chrono/stopwatch.hpp></code></a></dt>
+<dt><a href="reference/stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp">
+ Header <code class="computeroutput"><boost/chrono/stopwatch_accumulator.hpp></code></a></dt>
+<dt><a href="reference/stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_scoped_hpp">
+ Header <code class="computeroutput"><boost/chrono/stopwatch_scoped.hpp></code></a></dt>
+<dt><a href="reference/stopwatches.html#boost_chrono.reference.stopwatches.process_stopwatches_hpp">
+ Header <code class="computeroutput"><boost/chrono/process_stopwatches.hpp></code></a></dt>
</dl></dd>
-<dt> Header <boost/chrono/timer.hpp></dt>
+<dt><a href="reference/stopwatch_reporters.html">Stopwatch
+ Reporters</a></dt>
<dd><dl>
-<dt><a href="reference/timer_hpp.html#boost_chrono.reference.timer_hpp.template_class__timer___">Template
- Class <code class="computeroutput">timer<></code></a></dt>
-<dt>timer useful typedefs</dt>
+<dt><a href="reference/stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopwatch_reporter_hpp">
+ Header <code class="computeroutput"><boost/chrono/stopwatch_reporter.hpp></code></a></dt>
+<dt><a href="reference/stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopwatch_formatter_hpp">
+ Header <code class="computeroutput"><boost/chrono/stopwatch_formatter.hpp></code></a></dt>
+<dt><a href="reference/stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopwatch_accumulator_formatter_hpp">
+ Header <code class="computeroutput"><boost/chrono/stopwatch_accumulator_formatter.hpp></code></a></dt>
+<dt><a href="reference/stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.process_process_stopwatches_reporter_hpp">
+ Header <code class="computeroutput"><boost/chrono/process_stopwatches_reporter.hpp></code></a></dt>
</dl></dd>
-<dt> Header <boost/chrono/process_times.hpp></dt>
+<dt><a href="reference/deprecated_headers.html">Deprecated
+ Headers</a></dt>
<dd><dl>
-<dt><a href="reference/process_times_hpp.html#boost_chrono.reference.process_times_hpp.class__process_clock_">Class
- <code class="computeroutput">process_clock</code></a></dt>
-<dt><a href="reference/process_times_hpp.html#boost_chrono.reference.process_times_hpp.class__process_timer_">Class
- <code class="computeroutput">process_timer</code></a></dt>
-<dt><a href="reference/process_times_hpp.html#boost_chrono.reference.process_times_hpp.class__run_timer_">Class
- <code class="computeroutput">run_timer</code></a></dt>
+<dt><a href="reference/deprecated_headers.html#boost_chrono.reference.deprecated_headers.timer_hpp">
+ Deprecated Header <code class="computeroutput"><boost/chrono/timer.hpp></code></a></dt>
+<dt><a href="reference/deprecated_headers.html#boost_chrono.reference.deprecated_headers.process_times_hpp">
+ Deprecated Header <code class="computeroutput"><boost/chrono/process_times.hpp></code></a></dt>
</dl></dd>
</dl></div>
</div>
@@ -94,7 +84,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="users_guide/ext_references.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="reference/common_type_hpp.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="users_guide/ext_references.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="reference/cpp0x.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
</body>
</html>

Added: sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/cpp0x.html
==============================================================================
--- (empty file)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/cpp0x.html 2009-12-21 11:56:04 EST (Mon, 21 Dec 2009)
@@ -0,0 +1,2183 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title> Included on the C++0x
+ recommendation</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="../../index.html" title="Boost.Chrono">
+<link rel="up" href="../reference.html" title=" Reference ">
+<link rel="prev" href="../reference.html" title=" Reference ">
+<link rel="next" href="process_cpu_related.html" title="Process CPU
+ related">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../reference.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="process_cpu_related.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_chrono.reference.cpp0x"></a><a href="cpp0x.html" title=" Included on the C++0x
+ recommendation"> Included on the C++0x
+ recommendation</a>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.common_type_hpp"> Header
+ <code class="computeroutput"><boost/type_traits/common_type.hpp></code></a></dt>
+<dd><dl><dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.common_type_hpp.common_type">
+ Class Template <code class="computeroutput">common_type</code></a></dt></dl></dd>
+<dt> Header <boost/ratio.hpp></dt>
+<dd><dl>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio"> Class
+ Template <code class="computeroutput">ratio<></code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_arithmetic">
+ <code class="computeroutput">ratio</code> arithmetic</a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_comparison">
+ <code class="computeroutput">ratio</code> comparison</a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ration_SI_typedefs">
+ SI typedefs</a></dt>
+</dl></dd>
+<dt> Header <boost/chrono.hpp></dt>
+<dd><dl>
+<dt>Clock Requirements</dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_related_traits">Time-related
+ traits</a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_">Class
+ template <code class="computeroutput">duration</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.duration_non_member_arithmetic">duration
+ non-member arithmetic</a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.duration_comparaisons">duration
+ comparaisons</a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.duration_cast">
+ Non-Member function <code class="computeroutput">duration_cast(duration)</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__time_point_">Class
+ template <code class="computeroutput">time_point</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_point_non_member_arithmetic">time_point
+ non-member arithmetic</a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_point_comparisons">time_point
+ comparisons</a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class__system_clock_">Class
+ <code class="computeroutput">system_clock</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class__monotonic_clock_">Class
+ <code class="computeroutput">monotonic_clock</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class__high_resolution_clock_">Class
+ <code class="computeroutput">high_resolution_clock</code></a></dt>
+</dl></dd>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_chrono.reference.cpp0x.common_type_hpp"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.common_type_hpp" title=" Header
+ <boost/type_traits/common_type.hpp>"> Header
+ <code class="computeroutput"><boost/type_traits/common_type.hpp></code></a>
+</h4></div></div></div>
+<div class="toc"><dl><dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.common_type_hpp.common_type">
+ Class Template <code class="computeroutput">common_type</code></a></dt></dl></div>
+<pre class="programlisting">namespace boost {
+ template <class ...T> struct common_type;
+}
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.cpp0x.common_type_hpp.common_type"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.common_type_hpp.common_type" title="
+ Class Template common_type">
+ Class Template <code class="computeroutput">common_type</code></a>
+</h5></div></div></div>
+
+ <code class="computeroutput">common_type</code> is a facility
+ which is useful in specifying the type of the result of functions and
+ operators which take a variety of types (e.g. "mixed mode"
+ complex arithmetic).
+ 
+
+ The nested typedef <code class="computeroutput">common_type::type</code>
+ could be defined as follows:
+ 
+<pre class="programlisting">template <class T, class U = void, class V = void>
+struct common_type {
+ typedef typename common_type<typename common_type<T, U>::type, V>::type type;
+};
+
+template <class T>
+struct common_type<T, void, void> {
+ typedef T type;
+};
+
+template <class T, class U>
+struct common_type<T, U, void> {
+private:
+ static T m_t();
+ static U m_u();
+ static bool m_f(); // workaround gcc bug; not required by std
+public:
+ typedef BOOST_TYPEOF_TPL(m_f() ? m_t() : m_u()) type;
+};
+</pre>
+
+ All parameter types must be complete. This trait is permitted to be specialized
+ by a user if at least one template parameter is a user-defined type.
+ 
+
+ Note: Such specializations are required
+ when only explicit conversions are desired among the <code class="computeroutput">common_type</code>
+ arguments.
+ 
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_chrono.reference.cpp0x.ratio_hpp"></a> Header <boost/ratio.hpp>
+</h4></div></div></div>
+<div class="toc"><dl>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio"> Class
+ Template <code class="computeroutput">ratio<></code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_arithmetic">
+ <code class="computeroutput">ratio</code> arithmetic</a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_comparison">
+ <code class="computeroutput">ratio</code> comparison</a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ration_SI_typedefs">
+ SI typedefs</a></dt>
+</dl></div>
+
+ <code class="computeroutput">ratio</code> is a facility which
+ is useful in specifying compile time rational constants. Compile time rational
+ arithmetic is supported with protection against overflow and divide by
+ zero. Such a facility is very handy when needing to efficiently represent
+ 1/3 of a nanosecond, or specifying an inch in terms of meters (for example
+ 254/10000 meters - which <code class="computeroutput">ratio</code>
+ will reduce to 127/5000 meters).
+ 
+<pre class="programlisting">namespace boost {
+
+ template <boost::intmax_t N, boost::intmax_t D = 1> class ratio;
+
+ // ratio arithmetic
+ template <class R1, class R2> struct ratio_add;
+ template <class R1, class R2> struct ratio_subtract;
+ template <class R1, class R2> struct ratio_multiply;
+ template <class R1, class R2> struct ratio_divide;
+
+ // ratio comparison
+ template <class R1, class R2> struct ratio_equal;
+ template <class R1, class R2> struct ratio_not_equal;
+ template <class R1, class R2> struct ratio_less;
+ template <class R1, class R2> struct ratio_less_equal;
+ template <class R1, class R2> struct ratio_greater;
+ template <class R1, class R2> struct ratio_greater_equal;
+
+ // convenience SI typedefs
+ typedef ratio<1LL, 1000000000000000000LL> atto;
+ typedef ratio<1LL, 1000000000000000LL> femto;
+ typedef ratio<1LL, 1000000000000LL> pico;
+ typedef ratio<1LL, 1000000000LL> nano;
+ typedef ratio<1LL, 1000000LL> micro;
+ typedef ratio<1LL, 1000LL> milli;
+ typedef ratio<1LL, 100LL> centi;
+ typedef ratio<1LL, 10LL> deci;
+ typedef ratio< 10LL, 1LL> deca;
+ typedef ratio< 100LL, 1LL> hecto;
+ typedef ratio< 1000LL, 1LL> kilo;
+ typedef ratio< 1000000LL, 1LL> mega;
+ typedef ratio< 1000000000LL, 1LL> giga;
+ typedef ratio< 1000000000000LL, 1LL> tera;
+ typedef ratio< 1000000000000000LL, 1LL> peta;
+ typedef ratio<1000000000000000000LL, 1LL> exa;
+}
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.cpp0x.ratio_hpp.ratio"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
+ Template ratio<>"> Class
+ Template <code class="computeroutput">ratio<></code></a>
+</h5></div></div></div>
+<div class="toc"><dl><dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio.construction_and_assignment">Construction
+ and assignment</a></dt></dl></div>
+<pre class="programlisting">template <boost::intmax_t N, boost::intmax_t D>
+class ratio {
+public:
+ static const boost::intmax_t num;
+ static const boost::intmax_t den;
+ typedef ratio<num, den> type;
+
+ ratio() {}
+
+ template <intmax_t _N2, intmax_t _D2>
+ ratio(const ratio<_N2, _D2>&,
+ typename enable_if_c
+ <
+ ratio<_N2, _D2>::num == num &&
+ ratio<_N2, _D2>::den == den
+ >::type* = 0) {}
+
+ template <intmax_t _N2, intmax_t _D2>
+ typename enable_if_c
+ <
+ ratio<_N2, _D2>::num == num &&
+ ratio<_N2, _D2>::den == den,
+ ratio&
+ >::type
+ operator=(const ratio<_N2, _D2>&) {return *this;}
+};
+</pre>
+
+ A diagnostic will be emitted if <code class="computeroutput">ratio</code>
+ is instantiated with <code class="computeroutput">D == 0</code>, or
+ if the absolute value of <code class="computeroutput">N</code>
+ or <code class="computeroutput">D</code> can not be represented.
+ Note: These rules ensure that infinite
+ ratios are avoided and that for any negative input, there exists a representable
+ value of its absolute value which is positive. In a two's complement
+ representation, this excludes the most negative value.
+ 
+
+ Let <code class="computeroutput">gcd</code> denote the greatest
+ common divisor of <code class="computeroutput">N</code>'s
+ absolute value and of <code class="computeroutput">D</code>'s
+ absolute value.
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+<code class="computeroutput">num</code> has the value
+ <code class="computeroutput">sign(N)*sign(D)*abs(N)/gcd</code>.
+ </li>
+<li>
+<code class="computeroutput">den</code> has the value
+ <code class="computeroutput">abs(D)/gcd</code>.
+ </li>
+</ul></div>
+
+ The nested typedef <code class="computeroutput">type</code>
+ denotes the normalized form of this ratio type. It should be used when
+ the template parameters don't give a normalized form.
+ 
+
+ Two <code class="computeroutput">ratio</code> classes <code class="computeroutput">ratio<N1,D1></code>
+ and <code class="computeroutput">ratio<N2,D2></code>
+ have the same normalized form if <code class="computeroutput">ratio<N1,D1>::type</code>
+ is the same type as <code class="computeroutput">ratio<N2,D2>::type</code>
+ 
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.ratio_hpp.ratio.construction_and_assignment"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio.construction_and_assignment" title="Construction
+ and assignment">Construction
+ and assignment</a>
+</h6></div></div></div>
+<pre class="programlisting">template <intmax_t N2, intmax_t D2>
+ ratio(const ratio<N2, D2>& r);
+</pre>
+
+ Effects: Constructs a <code class="computeroutput">ratio</code> object.
+ 
+
+ Remarks: This constructor will not
+ participate in overload resolution unless <code class="computeroutput">r</code>
+ has the same normalized form as <code class="computeroutput">*this</code>.
+ 
+<pre class="programlisting">template <intmax_t N2, intmax_t D2>
+ ratio& operator=(const ratio<N2, D2>& r);
+</pre>
+
+ Effects: Assigns a <code class="computeroutput">ratio</code>
+ object.
+ 
+
+ Returns: *this.
+ 
+
+ Remarks: This operator will not participate
+ in overload resolution unless <code class="computeroutput">r</code>
+ has the same normalized form as <code class="computeroutput">*this</code>.
+ 
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.cpp0x.ratio_hpp.ratio_arithmetic"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_arithmetic" title="
+ ratio arithmetic">
+ <code class="computeroutput">ratio</code> arithmetic</a>
+</h5></div></div></div>
+
+ For each of the class templates in this clause, each template parameter
+ refers to a <code class="computeroutput">ratio</code>. If
+ the implementation is unable to form the indicated <code class="computeroutput">ratio</code>
+ due to overflow, a diagnostic will be issued.
+ 
+<pre class="programlisting">template <class R1, class R2> struct ratio_add {
+ typedef [/see below] type;
+};
+</pre>
+
+ The nested typedef <code class="computeroutput">type</code>
+ is a synonym for <code class="computeroutput">ratio<R1::num * R2::den + R2::num * R1::den, R1::den * R2::den>::type</code>.
+ 
+<pre class="programlisting">template <class R1, class R2> struct ratio_subtract {
+ typedef [/see below] type;
+};
+</pre>
+
+ The nested typedef <code class="computeroutput">type</code>
+ is a synonym for <code class="computeroutput">ratio<R1::num * R2::den - R2::num * R1::den, R1::den * R2::den>::type</code>.
+ 
+<pre class="programlisting">template <class R1, class R2> struct ratio_multiply {
+ typedef [/see below] type;
+};
+</pre>
+
+ The nested typedef <code class="computeroutput">type</code>
+ is a synonym for <code class="computeroutput">ratio<R1::num * R2::num, R1::den * R2::den>::type</code>.
+ 
+<pre class="programlisting">template <class R1, class R2> struct ratio_divide {
+ typedef [/see below] type;
+};
+</pre>
+
+ The nested typedef <code class="computeroutput">type</code>
+ is a synonym for <code class="computeroutput">ratio<R1::num * R2::den, R2::num * R1::den>::type</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.cpp0x.ratio_hpp.ratio_comparison"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio_comparison" title="
+ ratio comparison">
+ <code class="computeroutput">ratio</code> comparison</a>
+</h5></div></div></div>
+<pre class="programlisting">template <class R1, class R2> struct ratio_equal
+ : public boost::integral_constant<bool, [/see below] > {};
+</pre>
+
+ If R1::num <code class="literal">= R2::num && R1::den =</code> R2::den,
+ ratio_equal derives from true_type, else derives from false_type.
+ 
+<pre class="programlisting">template <class R1, class R2>
+struct ratio_less
+ : public boost::integral_constant<bool, [/see below] > {};
+</pre>
+
+ If R1::num * R2::den < R2::num * R1::den, ratio_less derives from
+ true_type, else derives from false_type. Implementations are permitted
+ to use more complex algorithms to compute the above relationship to avoid
+ overflow. If the implementation is not able to avoid overflow, a diagnostic
+ is emitted.
+ 
+<pre class="programlisting">template <class R1, class R2> struct ratio_not_equal
+ : public boost::integral_constant<bool, !ratio_equal<R1, R2>::value> {};
+
+template <class R1, class R2> struct ratio_less_equal
+ : public boost::integral_constant<bool, !ratio_less<R2, R1>::value> {};
+
+template <class R1, class R2> struct ratio_greater
+ : public boost::integral_constant<bool, ratio_less<R2, R1>::value> {};
+
+template <class R1, class R2> struct ratio_greater_equal
+ : public boost::integral_constant<bool, !ratio_less<R1, R2>::value> {};
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.cpp0x.ratio_hpp.ration_SI_typedefs"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ration_SI_typedefs" title="
+ SI typedefs">
+ SI typedefs</a>
+</h5></div></div></div>
+<pre class="programlisting">// convenience SI typedefs
+typedef ratio<1LL, 1000000000000000000LL> atto;
+typedef ratio<1LL, 1000000000000000LL> femto;
+typedef ratio<1LL, 1000000000000LL> pico;
+typedef ratio<1LL, 1000000000LL> nano;
+typedef ratio<1LL, 1000000LL> micro;
+typedef ratio<1LL, 1000LL> milli;
+typedef ratio<1LL, 100LL> centi;
+typedef ratio<1LL, 10LL> deci;
+typedef ratio< 10LL, 1LL> deca;
+typedef ratio< 100LL, 1LL> hecto;
+typedef ratio< 1000LL, 1LL> kilo;
+typedef ratio< 1000000LL, 1LL> mega;
+typedef ratio< 1000000000LL, 1LL> giga;
+typedef ratio< 1000000000000LL, 1LL> tera;
+typedef ratio< 1000000000000000LL, 1LL> peta;
+typedef ratio<1000000000000000000LL, 1LL> exa;
+</pre>
+
+ Four of the typedefs in the recomendation which can be conditionally
+ supported are not supported: yocto, zepto, zetta and yotta.
+ 
+<pre class="programlisting">typedef ratio<1, 1000000000000000000000000> yocto; // conditionally supported
+typedef ratio<1, 1000000000000000000000> zepto; // conditionally supported
+typedef ratio< 1000000000000000000000, 1> zetta; // conditionally supported
+typedef ratio<1000000000000000000000000, 1> yotta; // conditionally supported
+</pre>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp"></a> Header <boost/chrono.hpp>
+</h4></div></div></div>
+<div class="toc"><dl>
+<dt>Clock Requirements</dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_related_traits">Time-related
+ traits</a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_">Class
+ template <code class="computeroutput">duration</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.duration_non_member_arithmetic">duration
+ non-member arithmetic</a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.duration_comparaisons">duration
+ comparaisons</a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.duration_cast">
+ Non-Member function <code class="computeroutput">duration_cast(duration)</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__time_point_">Class
+ template <code class="computeroutput">time_point</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_point_non_member_arithmetic">time_point
+ non-member arithmetic</a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_point_comparisons">time_point
+ comparisons</a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class__system_clock_">Class
+ <code class="computeroutput">system_clock</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class__monotonic_clock_">Class
+ <code class="computeroutput">monotonic_clock</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class__high_resolution_clock_">Class
+ <code class="computeroutput">high_resolution_clock</code></a></dt>
+</dl></div>
+<pre class="programlisting">namespace boost {
+namespace chrono {
+
+ template <class Rep, class Period = ratio<1> > class duration;
+ template <class Clock, class Duration = typename Clock::duration> class time_point;
+
+}
+ template <class Rep1, class Period1, class Rep2, class Period2>
+ struct common_type<chrono::duration<Rep1, Period1>,
+ chrono::duration<Rep2, Period2> >;
+
+ template <class Clock, class Duration1, class Duration2>
+ struct common_type<chrono::time_point<Clock, Duration1>,
+ chrono::time_point<Clock, Duration2> >;
+
+namespace chrono {
+
+ // customization traits
+ template <class Rep> struct treat_as_floating_point;
+ template <class Rep> struct duration_values;
+
+ // duration arithmetic
+ template <class Rep1, class Period1, class Rep2, class Period2>
+ typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
+ operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+
+ template <class Rep1, class Period1, class Rep2, class Period2>
+ typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
+ operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+
+ template <class Rep1, class Period, class Rep2>
+ duration<typename common_type<Rep1, Rep2>::type, Period>
+ operator*(const duration<Rep1, Period>& d, const Rep2& s);
+
+ template <class Rep1, class Period, class Rep2>
+ duration<typename common_type<Rep1, Rep2>::type, Period>
+ operator*(const Rep1& s, const duration<Rep2, Period>& d);
+
+ template <class Rep1, class Period, class Rep2>
+ duration<typename common_type<Rep1, Rep2>::type, Period>
+ operator/(const duration<Rep1, Period>& d, const Rep2& s);
+
+ template <class Rep1, class Period1, class Rep2, class Period2>
+ typename common_type<Rep1, Rep2>::type
+ operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+
+ // duration comparisons
+ template <class Rep1, class Period1, class Rep2, class Period2>
+ bool operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+
+ template <class Rep1, class Period1, class Rep2, class Period2>
+ bool operator!=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+
+ template <class Rep1, class Period1, class Rep2, class Period2>
+ bool operator< (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+ template <class Rep1, class Period1, class Rep2, class Period2>
+ bool operator<=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+
+ template <class Rep1, class Period1, class Rep2, class Period2>
+ bool operator> (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+ template <class Rep1, class Period1, class Rep2, class Period2>
+ bool operator>=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+
+ // duration_cast
+
+ template <class ToDuration, class Rep, class Period>
+ ToDuration duration_cast(const duration<Rep, Period>& d);
+
+ // convenience typedefs
+ typedef duration<boost::int_least64_t, nano> nanoseconds; // at least 64 bits needed
+ typedef duration<boost::int_least64_t, micro> microseconds; // at least 55 bits needed
+ typedef duration<boost::int_least64_t, milli> milliseconds; // at least 45 bits needed
+ typedef duration<boost::int_least64_t> seconds; // at least 35 bits needed
+ typedef duration<boost::int_least32_t, ratio< 60> > minutes; // at least 29 bits needed
+ typedef duration<boost::int_least32_t, ratio<3600> > hours; // at least 23 bits needed
+
+ // time_point arithmetic
+ template <class Clock, class Duration1, class Rep2, class Period2>
+ time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2> >::type>
+ operator+(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
+
+ template <class Rep1, class Period1, class Clock, class Duration2>
+ time_point<Clock, typename common_type<duration<Rep1, Period1>, Duration2>::type>
+ operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs);
+
+ template <class Clock, class Duration1, class Rep2, class Period2>
+ time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2> >::type>
+ operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
+
+ template <class Clock, class Duration1, class Duration2>
+ typename common_type<Duration1, Duration2>::type
+ operator-(const time_point<Clock, Duration1>& lhs, const time_point<Clock,
+ Duration2>& rhs);
+
+ // time_point comparisons
+ template <class Clock, class Duration1, class Duration2>
+ bool operator==(const time_point<Clock, Duration1>& lhs, const time_point<Clock,
+ Duration2>& rhs);
+ template <class Clock, class Duration1, class Duration2>
+ bool operator!=(const time_point<Clock, Duration1>& lhs, const time_point<Clock,
+ Duration2>& rhs);
+ template <class Clock, class Duration1, class Duration2>
+ bool operator< (const time_point<Clock, Duration1>& lhs, const time_point<Clock,
+ Duration2>& rhs);
+ template <class Clock, class Duration1, class Duration2>
+ bool operator<=(const time_point<Clock, Duration1>& lhs, const time_point<Clock,
+ Duration2>& rhs);
+ template <class Clock, class Duration1, class Duration2>
+ bool operator> (const time_point<Clock, Duration1>& lhs, const time_point<Clock,
+ Duration2>& rhs);
+ template <class Clock, class Duration1, class Duration2>
+ bool operator>=(const time_point<Clock, Duration1>& lhs, const time_point<Clock,
+ Duration2>& rhs);
+
+ // time_point_cast
+ template <class ToDuration, class Clock, class Duration>
+ time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration>& t);
+
+ // Clocks
+ class system_clock;
+ class monotonic_clock;
+ class high_resolution_clock;
+
+}
+}
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp._clock__requirements"></a>Clock Requirements
+</h5></div></div></div>
+
+ A clock represents a bundle consisting of a native <code class="computeroutput">duration</code>,
+ a native <code class="computeroutput">time_point</code>,
+ and a function <code class="computeroutput">now()</code>
+ to get the current <code class="computeroutput">time_point</code>.
+ A clock must meet the requirements in the following Table.
+ 
+
+ In this table <code class="computeroutput">C1</code> and
+ <code class="computeroutput">C2</code> denote <code class="computeroutput">clock</code> types. <code class="computeroutput">t1</code>
+ and <code class="computeroutput">t2</code> are values returned
+ from <code class="computeroutput">C1::now()</code>
+ where the call returning <code class="computeroutput">t1</code>
+ happens before the call returning <code class="computeroutput">t2</code>
+ and both of these calls happen before <code class="computeroutput">C1::time_point::max()</code>.
+ 
+<div class="table">
+<a name="id4830558"></a>Table 1. Clock Requirements
+<table class="table" summary="Clock Requirements">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ expression
+ 
+ </th>
+<th>
+ 
+ return type
+ 
+ </th>
+<th>
+ 
+ operational semantics
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ <code class="computeroutput">C1::rep</code>
+ 
+ </td>
+<td>
+ 
+ An arithmetic type or class emulating an arithmetic type.
+ 
+ </td>
+<td>
+ 
+ The representation type of the native <code class="computeroutput">duration</code>
+ and <code class="computeroutput">time_point</code>.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">C1::period</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">ratio</code>
+ 
+ </td>
+<td>
+ 
+ The tick period of the clock in seconds.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">C1::duration</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">chrono::duration<C1::rep,
+ C1::period></code>
+ 
+ </td>
+<td>
+ 
+ The native <code class="computeroutput">duration</code>
+ type of the <code class="computeroutput">clock</code>.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">C1::time_point</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">chrono::time_point<C1>
+ or chrono::time_point<C2, C1::duration></code>
+ 
+ </td>
+<td>
+ 
+ The native <code class="computeroutput">time_point</code>
+ type of the <code class="computeroutput">clock</code>.
+ Different clocks are permitted to share a <code class="computeroutput">time_point</code>
+ definition if it is valid to compare their time_points by comparing
+ their respective <code class="computeroutput">duration</code>s.
+ <code class="computeroutput">C1</code> and <code class="computeroutput">C2</code> must refer to the same epoch.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">C1::is_monotonic</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">const bool</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">true</code> if <code class="computeroutput">t1 <=
+ t2</code> is always <code class="computeroutput">true</code>, else <code class="computeroutput">false</code>.
+ Note: A <code class="computeroutput">clock</code>
+ that can be adjusted backwards is not monotonic
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">C1::now()</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">C1::time_point</code>
+ 
+ </td>
+<td>
+ 
+ Returns a <code class="computeroutput">time_point</code>
+ representing the current point in time.
+ 
+ </td>
+</tr>
+</tbody>
+</table>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.time_related_traits"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_related_traits" title="Time-related
+ traits">Time-related
+ traits</a>
+</h5></div></div></div>
+<div class="toc"><dl>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_related_traits.treat_as_floating_point">
+ Metafunction <code class="computeroutput">treat_as_floating_point<></code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_related_traits.duration_values">
+ Class template <code class="computeroutput">duration_values</code></a></dt>
+<dt>common_type specializations</dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.time_related_traits.treat_as_floating_point"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_related_traits.treat_as_floating_point" title="
+ Metafunction treat_as_floating_point<>">
+ Metafunction <code class="computeroutput">treat_as_floating_point<></code></a>
+</h6></div></div></div>
+<pre class="programlisting">template <class Rep> struct treat_as_floating_point
+ : boost::is_floating_point<Rep> {};
+</pre>
+
+ The <code class="computeroutput">duration</code> template
+ uses the <code class="computeroutput">treat_as_floating_point</code>
+ trait to help determine if a <code class="computeroutput">duration</code>
+ with one tick period can be converted to another <code class="computeroutput">duration</code>
+ with a different tick period. If <code class="computeroutput">treat_as_floating_point<Rep>::value</code>
+ is <code class="computeroutput">true</code>, then <code class="computeroutput">Rep</code> is a floating point type and
+ implicit conversions are allowed among <code class="computeroutput">duration</code>s.
+ Otherwise, the implicit convertibility depends on the tick periods
+ of the <code class="computeroutput">duration</code>s. If
+ <code class="computeroutput">Rep</code> is a class type
+ which emulates a floating point type, the author of <code class="computeroutput">Rep</code>
+ can specialize <code class="computeroutput">treat_as_floating_point</code>
+ so that <code class="computeroutput">duration</code> will
+ treat this <code class="computeroutput">Rep</code> as if
+ it were a floating point type. Otherwise <code class="computeroutput">Rep</code>
+ is assumed to be an integral type, or a class emulating an integral
+ type.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.time_related_traits.duration_values"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_related_traits.duration_values" title="
+ Class template duration_values">
+ Class template <code class="computeroutput">duration_values</code></a>
+</h6></div></div></div>
+<div class="toc"><dl>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_related_traits.duration_values.zero">
+ Static member function<code class="computeroutput">zero()</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_related_traits.duration_values.max">
+ Static member function <code class="computeroutput">max()</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_related_traits.duration_values.min">
+ Static member function <code class="computeroutput">min()</code></a></dt>
+</dl></div>
+<pre class="programlisting">template <class Rep>
+struct duration_values
+{
+public:
+ static BOOST_CONSTEXPR Rep zero();
+ static BOOST_CONSTEXPR Rep max();
+ static BOOST_CONSTEXPR Rep min();
+};
+</pre>
+
+ The <code class="computeroutput">duration</code> template
+ uses the <code class="computeroutput">duration_values</code>
+ trait to construct special values of the <code class="computeroutput">duration</code>s
+ representation (<code class="computeroutput">Rep</code>).
+ This is done because the representation might be a class type with
+ behavior which requires some other implementation to return these special
+ values. In that case, the author of that class type should specialize
+ <code class="computeroutput">duration_values</code> to
+ return the indicated values.
+ 
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.time_related_traits.duration_values.zero"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_related_traits.duration_values.zero" title="
+ Static member functionzero()">
+ Static member function<code class="computeroutput">zero()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">static BOOST_CONSTEXPR Rep zero();
+</pre>
+
+ Returns: <code class="computeroutput">Rep(0)</code>. Note:
+ <code class="computeroutput">Rep(0)</code>
+ is specified instead of <code class="computeroutput">Rep()</code> since <code class="computeroutput">Rep()</code> may have some other meaning, such
+ as an uninitialized value.
+ 
+
+ Remarks: The value returned corresponds
+ to the additive identity.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.time_related_traits.duration_values.max"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_related_traits.duration_values.max" title="
+ Static member function max()">
+ Static member function <code class="computeroutput">max()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">static BOOST_CONSTEXPR Rep max();
+</pre>
+
+ Returns: <code class="computeroutput">numeric_limits<Rep>::max()</code>.
+ 
+
+ Remarks: The value returned compares
+ greater than zero().
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.time_related_traits.duration_values.min"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_related_traits.duration_values.min" title="
+ Static member function min()">
+ Static member function <code class="computeroutput">min()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">static BOOST_CONSTEXPR Rep min();
+</pre>
+
+ Returns: <code class="computeroutput">numeric_limits<Rep>::lowest()</code>.
+ 
+
+ Remarks: The value returned compares
+ less than or equal to <code class="computeroutput">zero()</code>.
+ 
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.time_related_traits._common_type__specializations"></a>common_type specializations
+</h6></div></div></div>
+<pre class="programlisting">template <class Rep1, class Period1, class Rep2, class Period2>
+struct common_type<chrono::duration<Rep1, Period1>, chrono::duration<Rep2, Period2> >
+{
+ typedef chrono::duration<typename common_type<Rep1, Rep2>::type, see below> type;
+};
+</pre>
+
+ The period of the <code class="computeroutput">duration</code>
+ indicated by this specialization of <code class="computeroutput">common_type</code>
+ is the greatest common divisor of <code class="computeroutput">Period1</code>
+ and <code class="computeroutput">Period2</code>. This can
+ be computed by forming a <code class="computeroutput">ratio</code>
+ of the greatest common divisor of <code class="computeroutput">Period1::num</code>
+ and <code class="computeroutput">Period2::num</code>, and the least common multiple
+ of <code class="computeroutput">Period1::den</code> and <code class="computeroutput">Period2::den</code>.
+ 
+
+ Note: The typedef type is the <code class="computeroutput">duration</code> with the largest tick period
+ possible where both <code class="computeroutput">duration</code>
+ arguments will convert to it without requiring a division operation.
+ The representation of this type is intended to be able to hold any
+ value resulting from this conversion, with the possible exception of
+ round-off error when floating point <code class="computeroutput">duration</code>s
+ are involved (but not truncation error).
+ 
+<pre class="programlisting">template <class Clock, class Duration1, class Duration2>
+struct common_type<chrono::time_point<Clock, Duration1>, chrono::time_point<Clock, Duration2> >
+{
+ typedef chrono::time_point<Clock, typename common_type<Duration1, Duration2>::type> type;
+};
+</pre>
+
+ The <code class="computeroutput">common_type</code> of
+ two <code class="computeroutput">time_point</code>s is
+ a <code class="computeroutput">time_point</code> with the
+ same <code class="computeroutput">clock</code> (both have
+ the same <code class="computeroutput">clock</code>), and
+ the <code class="computeroutput">common_type</code> of
+ the two <code class="computeroutput">duration</code>s.
+ 
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_" title="Class
+ template duration">Class
+ template <code class="computeroutput">duration</code></a>
+</h5></div></div></div>
+<div class="toc"><dl>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_c_1">
+ Constructor <code class="computeroutput">duration(const Rep2&)</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_c_2">
+ Constructor <code class="computeroutput">duration(const duration&)</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.count">
+ Member function <code class="computeroutput">count() const</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_p">
+ Member function <code class="computeroutput">operator+() const</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_m">
+ Member function <code class="computeroutput">operator+() const</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_pp">
+ Member function <code class="computeroutput">operator++()</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_pp2">
+ Member function <code class="computeroutput">operator++(int)</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_mm">
+ Member function <code class="computeroutput">operator++()</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_mm2">
+ Member function <code class="computeroutput">operator++(int)</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_pa">
+ Member function <code class="computeroutput">operator+=(const duration&)</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_ma">
+ Member function <code class="computeroutput">operator-=(const duration&)</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_moda">
+ Member function <code class="computeroutput">operator%=(const duration&)</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_proda">
+ Member function <code class="computeroutput">operator*=(const rep&)</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_da">
+ Member function <code class="computeroutput">operator/=(const rep&)</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_moda_2">
+ Member function <code class="computeroutput">operator%=(const rep&)</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_zero">
+ Static Member function <code class="computeroutput">zero()</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_min">
+ Static Member function <code class="computeroutput">min()</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_max">
+ Static Member function <code class="computeroutput">max()</code></a></dt>
+</dl></div>
+
+ A <code class="computeroutput">duration</code> measures time
+ between two points in time (<code class="computeroutput">time_point</code>).
+ A <code class="computeroutput">duration</code> has a representation
+ which holds a count of ticks, and a tick period. The tick period is the
+ amount of time which occurs from one tick to another in units of a second.
+ It is expressed as a rational constant using <code class="computeroutput">ratio</code>.
+ 
+<pre class="programlisting">namespace boost { namespace chrono {
+
+ template <class Rep, class Period>
+ class duration {
+ public:
+ typedef Rep rep;
+ typedef Period period;
+ private:
+ rep rep_; // exposition only
+ public:
+ BOOST_CONSTEXPR duration() {} // = default;
+ template <class Rep2>
+ BOOST_CONSTEXPR explicit duration(const Rep2& r,
+ typename boost::enable_if_c
+ <
+ boost::is_convertible<Rep2, rep>::value
+ && (treat_as_floating_point<rep>::value
+ || (!treat_as_floating_point<rep>::value
+ && !treat_as_floating_point<Rep2>::value))
+ >::type* = 0);
+
+ template <class Rep2, class Period2>
+ BOOST_CONSTEXPR duration(const duration<Rep2, Period2>& d,
+ typename boost::enable_if_c
+ <
+ treat_as_floating_point<rep>::value
+ || (ratio_divide<Period2, period>::type::den == 1
+ && !treat_as_floating_point<Rep2>::value)
+ >::type* = 0);
+
+ //~duration() = default;
+ //duration(const duration&) = default;
+ //duration& operator=(const duration&) = default;
+
+ BOOST_CONSTEXPR rep count() const;
+
+ BOOST_CONSTEXPR duration operator+();
+ BOOST_CONSTEXPR duration operator-();
+ duration& operator++();
+ duration operator++(int);
+ duration& operator--();
+ duration operator--(int);
+
+ duration& operator+=(const duration& d);
+ duration& operator-=(const duration& d);
+
+ duration& operator*=(const rep& rhs);
+ duration& operator/=(const rep& rhs);
+ duration& operator%=(const rep& rhs);
+ duration& operator%=(const duration& rhs);
+
+ static BOOST_CONSTEXPR duration zero();
+ static BOOST_CONSTEXPR duration min();
+ static BOOST_CONSTEXPR duration max();
+ };
+
+}}
+</pre>
+
+ Rep must be an arithmetic type, or a class emulating an arithmetic type.
+ If <code class="computeroutput">duration</code> is instantiated
+ with the type of <code class="computeroutput">Rep</code>
+ being a <code class="computeroutput">duration</code>, a diagnostic
+ is required.
+ 
+
+ Period must be an instantiation of <code class="computeroutput">ratio</code>,
+ compile diagnostic otherwise.
+ 
+
+ Period::num must be positive, compile diagnostic otherwise.
+ 
+
+ Examples:
+ 
+<pre class="programlisting">duration<long, ratio<60> > holds a count of minutes using a long.
+
+duration<long long, milli> holds a count of milliseconds using a long long.
+
+duration<double, ratio<1, 30> > holds a count using a double with a tick period of 1/30 second (a tick fre
quency of 30 Hz).
+</pre>
+
+ The following members of <code class="computeroutput">duration</code>
+ do not throw an exception unless the indicated operations on the representations
+ throw an exception.
+ 
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_c_1"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_c_1" title="
+ Constructor duration(const Rep2&)">
+ Constructor <code class="computeroutput">duration(const Rep2&)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">template <class Rep2>
+BOOST_CONSTEXPR explicit duration(const Rep2& r);
+</pre>
+
+ Requires: <code class="computeroutput">Rep2</code>
+ is implicitly convertible to <code class="computeroutput">rep</code>,
+ and
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+<code class="computeroutput">treat_as_floating_point<rep>::value</code>
+ is <code class="computeroutput">true</code>, or
+ </li>
+<li>
+<code class="computeroutput">!treat_as_floating_point<rep>::value
+ && !treat_as_floating_point<Rep2>::value</code> is <code class="computeroutput">true</code>.
+ </li>
+</ul></div>
+
+ A diagnostic is required if this requirement is not met. Note: This requirement prevents construction
+ of an integral-based <code class="computeroutput">duration</code>
+ with a floating point representation. Such a construction could easily
+ lead to confusion about the value of the <code class="computeroutput">duration</code>.
+ 
+
+ Example:
+ 
+<pre class="programlisting">duration<int, milli> d(3.5); // do not compile
+duration<int, milli> d(3); // ok
+</pre>
+
+ Effects: Constructs an object of type
+ <code class="computeroutput">duration</code>.
+ 
+
+ PostConditions: <code class="computeroutput">count() == static_cast<rep>(r)</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_c_2"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_c_2" title="
+ Constructor duration(const duration&)">
+ Constructor <code class="computeroutput">duration(const duration&)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">template <class Rep2, class Period2>
+BOOST_CONSTEXPR duration(const duration<Rep2, Period2>& d);
+</pre>
+
+ Requires: <code class="computeroutput">treat_as_floating_point<rep>::value</code>,
+ or <code class="computeroutput">ratio_divide<Period2,
+ period>::type::den ==
+ 1</code>.
+ 
+<pre class="programlisting">A diagnostic is required if this requirement is not met.
+</pre>
+
+ note This requirement prevents implicit
+ truncation error when converting between integral-based <code class="computeroutput">duration</code>s. Such a construction could
+ easily lead to confusion about the value of the <code class="computeroutput">duration</code>.
+ 
+
+ Example:
+ 
+<pre class="programlisting">duration<int, milli> ms(3);
+duration<int, micro> us = ms; // ok
+duration<int, milli> ms2 = us; // do not compile
+</pre>
+
+ Effects: Constructs an object of type
+ <code class="computeroutput">duration</code>, constructing
+ <code class="computeroutput">rep_</code> from <code class="computeroutput">duration_cast<duration>(d).count()</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.count"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.count" title="
+ Member function count() const">
+ Member function <code class="computeroutput">count() const</code></a>
+</h6></div></div></div>
+<pre class="programlisting">BOOST_CONSTEXPR rep count() const;
+</pre>
+
+ Returns: `rep_v.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_p"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_p" title="
+ Member function operator+() const">
+ Member function <code class="computeroutput">operator+() const</code></a>
+</h6></div></div></div>
+<pre class="programlisting">BOOST_CONSTEXPR duration operator+() const;
+</pre>
+
+ Returns: <code class="computeroutput">*this</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_m"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_m" title="
+ Member function operator+() const">
+ Member function <code class="computeroutput">operator+() const</code></a>
+</h6></div></div></div>
+<pre class="programlisting">BOOST_CONSTEXPR duration operator-() const;
+</pre>
+
+ Returns: <code class="computeroutput">duration(-rep_)</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_pp"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_pp" title="
+ Member function operator++()">
+ Member function <code class="computeroutput">operator++()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">duration& operator++();
+</pre>
+
+ Effects: <code class="computeroutput">++rep_</code>.
+ 
+
+ Returns: <code class="computeroutput">*this</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_pp2"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_pp2" title="
+ Member function operator++(int)">
+ Member function <code class="computeroutput">operator++(int)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">duration operator++(int);
+</pre>
+
+ Returns: `duration(rep_++)v.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_mm"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_mm" title="
+ Member function operator++()">
+ Member function <code class="computeroutput">operator++()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">duration& operator--();
+</pre>
+
+ Effects: <code class="computeroutput">--rep_</code>.
+ 
+
+ Returns: <code class="computeroutput">*this</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_mm2"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_mm2" title="
+ Member function operator++(int)">
+ Member function <code class="computeroutput">operator++(int)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">duration operator--(int);
+</pre>
+
+ Returns: <code class="computeroutput">duration(rep_--)</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_pa"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_pa" title="
+ Member function operator+=(const duration&)">
+ Member function <code class="computeroutput">operator+=(const duration&)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">duration& operator+=(const duration& d);
+</pre>
+
+ Effects: <code class="computeroutput">rep_
+ += d.count()</code>.
+ 
+
+ Returns: <code class="computeroutput">*this</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_ma"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_ma" title="
+ Member function operator-=(const duration&)">
+ Member function <code class="computeroutput">operator-=(const duration&)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">duration& operator-=(const duration& d);
+</pre>
+
+ Effects: <code class="computeroutput">rep_
+ -= d.count()</code>.
+ 
+
+ Returns: <code class="computeroutput">*this</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_moda"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_moda" title="
+ Member function operator%=(const duration&)">
+ Member function <code class="computeroutput">operator%=(const duration&)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">duration& operator%=(const duration& d);
+</pre>
+
+ Effects: <code class="computeroutput">rep_
+ %= d.count()</code>.
+ 
+
+ Returns: <code class="computeroutput">*this</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_proda"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_proda" title="
+ Member function operator*=(const rep&)">
+ Member function <code class="computeroutput">operator*=(const rep&)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">duration& operator*=(const rep& rhs);
+</pre>
+
+ Effects: <code class="computeroutput">rep_
+ *= rhs</code>.
+ 
+
+ Returns: <code class="computeroutput">*this</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_da"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_da" title="
+ Member function operator/=(const rep&)">
+ Member function <code class="computeroutput">operator/=(const rep&)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">duration& operator/=(const rep& rhs);
+</pre>
+
+ Effects: <code class="computeroutput">rep_
+ /= rhs</code>.
+ 
+
+ Returns: <code class="computeroutput">*this</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_moda_2"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_operator_moda_2" title="
+ Member function operator%=(const rep&)">
+ Member function <code class="computeroutput">operator%=(const rep&)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">duration& operator%=(const rep& rhs);
+</pre>
+
+ Effects: <code class="computeroutput">rep_
+ %= rhs</code>.
+ 
+
+ Returns: <code class="computeroutput">*this</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_zero"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_zero" title="
+ Static Member function zero()">
+ Static Member function <code class="computeroutput">zero()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">static duration zero();
+</pre>
+
+ Returns: <code class="computeroutput">duration(duration_values<rep>::zero())</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_min"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_min" title="
+ Static Member function min()">
+ Static Member function <code class="computeroutput">min()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">static duration min();
+</pre>
+
+ Returns: <code class="computeroutput">duration(duration_values<rep>::min()).</code>
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_max"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__duration_.duration_max" title="
+ Static Member function max()">
+ Static Member function <code class="computeroutput">max()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">static constexpr duration max();
+</pre>
+
+ Returns: <code class="computeroutput">duration(duration_values<rep>::max())</code>.
+ 
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.duration_non_member_arithmetic"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.duration_non_member_arithmetic" title="duration
+ non-member arithmetic">duration
+ non-member arithmetic</a>
+</h5></div></div></div>
+<div class="toc"><dl>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.duration_non_member_arithmetic.duration_operator_p_1">
+ Non-Member function <code class="computeroutput">operator+(duration,duration)</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.duration_non_member_arithmetic.duration_operator_m_1">
+ Non-Member function <code class="computeroutput">operator-(duration,duration)</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.duration_non_member_arithmetic.duration_operator_prod_1">
+ Non-Member function <code class="computeroutput">operator*(Rep1,duration)</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.duration_non_member_arithmetic.duration_operator_d_1">
+ Non-Member function <code class="computeroutput">operator/(duration,Rep2)</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.duration_non_member_arithmetic.duration_operator_d_2">
+ Non-Member function <code class="computeroutput">operator/(duration,duration)</code></a></dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.duration_non_member_arithmetic.duration_operator_p_1"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.duration_non_member_arithmetic.duration_operator_p_1" title="
+ Non-Member function operator+(duration,duration)">
+ Non-Member function <code class="computeroutput">operator+(duration,duration)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">template <class Rep1, class Period1, class Rep2, class Period2>
+typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
+operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+</pre>
+
+ Returns: <code class="computeroutput">CD(lhs) += rhs</code> where <code class="computeroutput">CD</code>
+ is the type of the return value.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.duration_non_member_arithmetic.duration_operator_m_1"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.duration_non_member_arithmetic.duration_operator_m_1" title="
+ Non-Member function operator-(duration,duration)">
+ Non-Member function <code class="computeroutput">operator-(duration,duration)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">template <class Rep1, class Period1, class Rep2, class Period2>
+typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
+operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+</pre>
+
+ Returns: <code class="computeroutput">CD(lhs) -= rhs</code> where <code class="computeroutput">CD</code>
+ is the type of the return value.
+ 
+<pre class="programlisting">template <class Rep1, class Period, class Rep2>
+duration<typename common_type<Rep1, Rep2>::type, Period>
+operator*(const duration<Rep1, Period>& d, const Rep2& s);
+</pre>
+
+ Requires: Let <code class="computeroutput">CR</code>
+ represent the <code class="computeroutput">common_type</code>
+ of <code class="computeroutput">Rep1</code> and <code class="computeroutput">Rep2</code>. This function will not participate
+ in overload resolution unless both <code class="computeroutput">Rep1</code>
+ and <code class="computeroutput">Rep2</code> are implicitly
+ convertible to <code class="computeroutput">CR</code>.
+ 
+
+ Returns: <code class="computeroutput">duration<CR, Period>(d) *= s</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.duration_non_member_arithmetic.duration_operator_prod_1"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.duration_non_member_arithmetic.duration_operator_prod_1" title="
+ Non-Member function operator*(Rep1,duration)">
+ Non-Member function <code class="computeroutput">operator*(Rep1,duration)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">template <class Rep1, class Period, class Rep2>
+duration<typename common_type<Rep1, Rep2>::type, Period>
+operator*(const Rep1& s, const duration<Rep2, Period>& d);
+</pre>
+
+ Requires: Let <code class="computeroutput">CR</code>
+ represent the <code class="computeroutput">common_type</code>
+ of <code class="computeroutput">Rep1</code> and <code class="computeroutput">Rep2</code>. This function will not participate
+ in overload resolution unless both <code class="computeroutput">Rep1</code>
+ and <code class="computeroutput">Rep2</code> are implicitly
+ convertible to <code class="computeroutput">CR</code>.
+ 
+
+ Returns: <code class="computeroutput">d
+ * s</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.duration_non_member_arithmetic.duration_operator_d_1"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.duration_non_member_arithmetic.duration_operator_d_1" title="
+ Non-Member function operator/(duration,Rep2)">
+ Non-Member function <code class="computeroutput">operator/(duration,Rep2)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">template <class Rep1, class Period, class Rep2>
+duration<typename common_type<Rep1, Rep2>::type, Period>
+operator/(const duration<Rep1, Period>& d, const Rep2& s);
+</pre>
+
+ Requires: Let <code class="computeroutput">CR</code>
+ represent the <code class="computeroutput">common_type</code>
+ of <code class="computeroutput">Rep1</code> and <code class="computeroutput">Rep2</code>. This function will not participate
+ in overload resolution unless both <code class="computeroutput">Rep1</code>
+ and <code class="computeroutput">Rep2</code> are implicitly
+ convertible to <code class="computeroutput">CR</code>,
+ and <code class="computeroutput">Rep2</code> is not an
+ instantiation of <code class="computeroutput">duration</code>.
+ 
+
+ Returns: <code class="computeroutput">duration<CR, Period>(d) /= s</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.duration_non_member_arithmetic.duration_operator_d_2"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.duration_non_member_arithmetic.duration_operator_d_2" title="
+ Non-Member function operator/(duration,duration)">
+ Non-Member function <code class="computeroutput">operator/(duration,duration)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">template <class Rep1, class Period1, class Rep2, class Period2>
+typename common_type<Rep1, Rep2>::type
+operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+</pre>
+
+ Returns: Let <code class="computeroutput">CD</code>
+ represent the <code class="computeroutput">common_type</code>
+ of the two <code class="computeroutput">duration</code>
+ arguments. Returns <code class="computeroutput">CD(lhs).count() / CD(rhs).count()</code>.
+ 
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.duration_comparaisons"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.duration_comparaisons" title="duration
+ comparaisons">duration
+ comparaisons</a>
+</h5></div></div></div>
+<div class="toc"><dl>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.duration_comparaisons.duration_operator_eq_1">
+ Non-Member function <code class="computeroutput">operator==(duration,duration)</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.duration_comparaisons.duration_operator_neq_1">
+ Non-Member function <code class="computeroutput">operator!=(duration,duration)</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.duration_comparaisons.duration_operator_lt_1">
+ Non-Member function <code class="computeroutput">operator<(duration,duration)</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.duration_comparaisons.duration_operator_leq_1">
+ Non-Member function <code class="computeroutput">operator<=(duration,duration)</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.duration_comparaisons.duration_operator_gt_1">
+ Non-Member function <code class="computeroutput">operator>(duration,duration)</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.duration_comparaisons.duration_operator_gteq_1">
+ Non-Member function <code class="computeroutput">operator>=(duration,duration)</code></a></dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.duration_comparaisons.duration_operator_eq_1"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.duration_comparaisons.duration_operator_eq_1" title="
+ Non-Member function operator==(duration,duration)">
+ Non-Member function <code class="computeroutput">operator==(duration,duration)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">template <class Rep1, class Period1, class Rep2, class Period2>
+bool operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+</pre>
+
+ Returns: Let <code class="computeroutput">CD</code>
+ represent the <code class="computeroutput">common_type</code>
+ of the two <code class="computeroutput">duration</code>
+ arguments. Returns <code class="computeroutput">CD(lhs).count() == CD(rhs).count()</code>
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.duration_comparaisons.duration_operator_neq_1"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.duration_comparaisons.duration_operator_neq_1" title="
+ Non-Member function operator!=(duration,duration)">
+ Non-Member function <code class="computeroutput">operator!=(duration,duration)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">template <class Rep1, class Period1, class Rep2, class Period2>
+bool operator!=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+</pre>
+
+ Returns: <code class="computeroutput">!(lhs ==
+ rhs)</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.duration_comparaisons.duration_operator_lt_1"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.duration_comparaisons.duration_operator_lt_1" title="
+ Non-Member function operator<(duration,duration)">
+ Non-Member function <code class="computeroutput">operator<(duration,duration)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">template <class Rep1, class Period1, class Rep2, class Period2>
+bool operator< (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+</pre>
+
+ Returns: Let <code class="computeroutput">CD</code>
+ represent the <code class="computeroutput">common_type</code>
+ of the two <code class="computeroutput">duration</code>
+ arguments. Returns <code class="computeroutput">CD(lhs).count() < CD(rhs).count()</code>
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.duration_comparaisons.duration_operator_leq_1"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.duration_comparaisons.duration_operator_leq_1" title="
+ Non-Member function operator<=(duration,duration)">
+ Non-Member function <code class="computeroutput">operator<=(duration,duration)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">template <class Rep1, class Period1, class Rep2, class Period2>
+bool operator<=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+</pre>
+
+ Returns: <code class="computeroutput">!(rhs <
+ lhs)</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.duration_comparaisons.duration_operator_gt_1"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.duration_comparaisons.duration_operator_gt_1" title="
+ Non-Member function operator>(duration,duration)">
+ Non-Member function <code class="computeroutput">operator>(duration,duration)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">template <class Rep1, class Period1, class Rep2, class Period2>
+bool operator> (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+</pre>
+
+ Returns: <code class="computeroutput">rhs
+ < lhs</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.duration_comparaisons.duration_operator_gteq_1"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.duration_comparaisons.duration_operator_gteq_1" title="
+ Non-Member function operator>=(duration,duration)">
+ Non-Member function <code class="computeroutput">operator>=(duration,duration)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">template <class Rep1, class Period1, class Rep2, class Period2>
+bool operator>=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+</pre>
+
+ Returns: <code class="computeroutput">!(lhs <
+ rhs)</code>.
+ 
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.duration_cast"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.duration_cast" title="
+ Non-Member function duration_cast(duration)">
+ Non-Member function <code class="computeroutput">duration_cast(duration)</code></a>
+</h5></div></div></div>
+<pre class="programlisting">template <class ToDuration, class Rep, class Period>
+ToDuration duration_cast(const duration<Rep, Period>& d);
+</pre>
+
+ Requires: This function will not participate
+ in overload resolution unless <code class="computeroutput">ToDuration</code>
+ is an instantiation of <code class="computeroutput">duration</code>.
+ 
+
+ Returns: Forms <code class="computeroutput">CF</code>
+ which is a <code class="computeroutput">ratio</code> resulting
+ from <code class="computeroutput">ratio_divide<Period, typename ToDuration::period>::type</code>.
+ Let <code class="computeroutput">CR</code> be the <code class="computeroutput">common_type</code> of <code class="computeroutput">ToDuration::rep</code>,
+ <code class="computeroutput">Rep</code>, and <code class="computeroutput">intmax_t</code>.
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+ If <code class="computeroutput">CF::num ==
+ 1</code> and <code class="computeroutput">CF::den == 1</code>,
+ then returns <code class="computeroutput">ToDuration(static_cast<typename
+ ToDuration::rep>(d.count()))
+ </code>
+</li>
+<li>
+ else if <code class="computeroutput">CF::num !=
+ 1</code> and <code class="computeroutput">CF::den == 1</code>,
+ then returns <code class="computeroutput">ToDuration(static_cast<typename
+ ToDuration::rep>(static_cast<CR>(d.count())
+ * static_cast<CR>(CF::num)))</code>
+</li>
+<li>
+ else if <code class="computeroutput">CF::num ==
+ 1</code> and <code class="computeroutput">CF::den != 1</code>,
+ then returns <code class="computeroutput">ToDuration(static_cast<typename
+ ToDuration::rep>(static_cast<CR>(d.count())
+ / static_cast<CR>(CF::den)))</code>
+</li>
+<li>
+ else returns <code class="computeroutput">ToDuration(static_cast<typename
+ ToDuration::rep>(static_cast<CR>(d.count())
+ * static_cast<CR>(CF::num) / static_cast<CR>(CF::den)))</code>
+</li>
+</ul></div>
+
+ Remarks: This function does not rely
+ on any implicit conversions. All conversions must be accomplished through
+ <code class="computeroutput">static_cast</code>. The implementation
+ avoids all multiplications or divisions when it is known at compile time
+ that it can be avoided because one or more arguments are <code class="computeroutput">1</code>. All intermediate computations are carried
+ out in the widest possible representation and only converted to the destination
+ representation at the final step.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.class_template__time_point_"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__time_point_" title="Class
+ template time_point">Class
+ template <code class="computeroutput">time_point</code></a>
+</h5></div></div></div>
+<div class="toc"><dl>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__time_point_.time_point_c_1">
+ Constructor <code class="computeroutput">time_point()</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__time_point_.time_point_c_2">
+ Constructor <code class="computeroutput">time_point(const duration&)</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__time_point_.time_point_c_3">
+ Constructor <code class="computeroutput">time_point(const duration&)</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__time_point_.time_since_epoch">
+ Member function <code class="computeroutput">time_since_epoch() const</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__time_point_.time_point_operator_pe">
+ Member function <code class="computeroutput">operator+=</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__time_point_.time_point_operator_me">
+ Member function <code class="computeroutput">operator-=</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__time_point_.time_point_min">
+ Static Member function <code class="computeroutput">min</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__time_point_.time_point_max">
+ Static Member function <code class="computeroutput">max</code></a></dt>
+</dl></div>
+
+ A <code class="computeroutput">time_point</code> represents
+ a point in time with respect to a specific clock.
+ 
+<pre class="programlisting">template <class Clock, class Duration>
+class time_point {
+public:
+ typedef Clock clock;
+ typedef Duration duration;
+ typedef typename duration::rep rep;
+ typedef typename duration::period period;
+private:
+ duration d_; // exposition only
+public:
+ time_point();
+ explicit time_point(const duration& d);
+
+ // conversions
+ template <class Duration2>
+ time_point(const time_point<clock, Duration2>& t,
+ typename boost::enable_if
+ <
+ boost::is_convertible<Duration2, duration>
+ >::type* = 0);
+
+ // observer
+
+ duration time_since_epoch() const;
+
+ // arithmetic
+
+ time_point& operator+=(const duration& d);
+ time_point& operator-=(const duration& d);
+
+ // special values
+
+ static BOOST_CONSTEXPR time_point min();
+ static BOOST_CONSTEXPR time_point max();
+};
+</pre>
+
+ Clock must meet the Clock Requirements.
+ 
+
+ Duration must be an instantiation of <code class="computeroutput">duration</code>,
+ compile diagnostic otherwise.
+ 
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.class_template__time_point_.time_point_c_1"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__time_point_.time_point_c_1" title="
+ Constructor time_point()">
+ Constructor <code class="computeroutput">time_point()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">time_point();
+</pre>
+
+ Effects: Constructs an object of
+ <code class="computeroutput">time_point</code>, initializing
+ <code class="computeroutput">d_</code> with <code class="computeroutput">duration::zero()</code>.
+ This <code class="computeroutput">time_point</code> represents
+ the epoch.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.class_template__time_point_.time_point_c_2"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__time_point_.time_point_c_2" title="
+ Constructor time_point(const duration&)">
+ Constructor <code class="computeroutput">time_point(const duration&)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">time_point(const duration& d);
+</pre>
+
+ Effects: Constructs an object of
+ <code class="computeroutput">time_point</code>, initializing
+ <code class="computeroutput">d_</code> with <code class="computeroutput">d</code>. This <code class="computeroutput">time_point</code>
+ represents the epoch <code class="computeroutput">+ d</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.class_template__time_point_.time_point_c_3"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__time_point_.time_point_c_3" title="
+ Constructor time_point(const duration&)">
+ Constructor <code class="computeroutput">time_point(const duration&)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">template <class Duration2> time_point(const time_point<clock, Duration2>& t);
+</pre>
+
+ Requires: This function will not participate
+ in overload resolution unless <code class="computeroutput">Duration2</code>
+ is implicitly convertible to <code class="computeroutput">duration</code>.
+ 
+
+ Effects: Constructs an object of
+ <code class="computeroutput">time_point</code>, initializing
+ <code class="computeroutput">d_</code> with <code class="computeroutput">t.time_since_epoch()</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.class_template__time_point_.time_since_epoch"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__time_point_.time_since_epoch" title="
+ Member function time_since_epoch() const">
+ Member function <code class="computeroutput">time_since_epoch() const</code></a>
+</h6></div></div></div>
+<pre class="programlisting">duration time_since_epoch() const;
+</pre>
+
+ Returns: <code class="computeroutput">d_</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.class_template__time_point_.time_point_operator_pe"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__time_point_.time_point_operator_pe" title="
+ Member function operator+=">
+ Member function <code class="computeroutput">operator+=</code></a>
+</h6></div></div></div>
+<pre class="programlisting">time_point& operator+=(const duration& d);
+</pre>
+
+ Effects: <code class="computeroutput">d_
+ += d</code>.
+ 
+
+ Returns: <code class="computeroutput">*this</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.class_template__time_point_.time_point_operator_me"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__time_point_.time_point_operator_me" title="
+ Member function operator-=">
+ Member function <code class="computeroutput">operator-=</code></a>
+</h6></div></div></div>
+<pre class="programlisting">time_point& operator-=(const duration& d);
+</pre>
+
+ Effects: <code class="computeroutput">d_
+ -= d</code>
+ 
+
+ Returns: <code class="computeroutput">*this</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.class_template__time_point_.time_point_min"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__time_point_.time_point_min" title="
+ Static Member function min">
+ Static Member function <code class="computeroutput">min</code></a>
+</h6></div></div></div>
+<pre class="programlisting">static BOOST_CONSTEXPR time_point min();
+</pre>
+
+ Returns: <code class="computeroutput">time_point(duration::min())</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.class_template__time_point_.time_point_max"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class_template__time_point_.time_point_max" title="
+ Static Member function max">
+ Static Member function <code class="computeroutput">max</code></a>
+</h6></div></div></div>
+<pre class="programlisting">static BOOST_CONSTEXPR time_point max();
+</pre>
+
+ Returns: <code class="computeroutput">time_point(duration::max())</code>.
+ 
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.time_point_non_member_arithmetic"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_point_non_member_arithmetic" title="time_point
+ non-member arithmetic">time_point
+ non-member arithmetic</a>
+</h5></div></div></div>
+<div class="toc"><dl>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_point_non_member_arithmetic.time_point_operator_p_1">
+ Non-Member function <code class="computeroutput">operator+(time_point,duration)</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_point_non_member_arithmetic.time_point_operator_p_2">
+ Non-Member function <code class="computeroutput">operator+(duration,time_point)</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_point_non_member_arithmetic.time_point_operator_m_1">
+ Non-Member function <code class="computeroutput">operator-(time_point,duration)</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_point_non_member_arithmetic.time_point_operator_m_2">
+ Non-Member function <code class="computeroutput">operator-(duration,time_point)</code></a></dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.time_point_non_member_arithmetic.time_point_operator_p_1"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_point_non_member_arithmetic.time_point_operator_p_1" title="
+ Non-Member function operator+(time_point,duration)">
+ Non-Member function <code class="computeroutput">operator+(time_point,duration)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">template <class Clock, class Duration1, class Rep2, class Period2>
+time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2> >::type>
+operator+(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
+</pre>
+
+ Returns: <code class="computeroutput">CT(lhs) += rhs</code> where <code class="computeroutput">CT</code>
+ is the type of the return value.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.time_point_non_member_arithmetic.time_point_operator_p_2"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_point_non_member_arithmetic.time_point_operator_p_2" title="
+ Non-Member function operator+(duration,time_point)">
+ Non-Member function <code class="computeroutput">operator+(duration,time_point)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">template <class Rep1, class Period1, class Clock, class Duration2>
+time_point<Clock, typename common_type<duration<Rep1, Period1>, Duration2>::type>
+operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs);
+</pre>
+
+ Returns: <code class="computeroutput">rhs
+ + lhs</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.time_point_non_member_arithmetic.time_point_operator_m_1"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_point_non_member_arithmetic.time_point_operator_m_1" title="
+ Non-Member function operator-(time_point,duration)">
+ Non-Member function <code class="computeroutput">operator-(time_point,duration)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">template <class Clock, class Duration1, class Rep2, class Period2>
+time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2> >::type>
+operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
+</pre>
+
+ Returns: <code class="computeroutput">lhs
+ + (-rhs)</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.time_point_non_member_arithmetic.time_point_operator_m_2"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_point_non_member_arithmetic.time_point_operator_m_2" title="
+ Non-Member function operator-(duration,time_point)">
+ Non-Member function <code class="computeroutput">operator-(duration,time_point)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">template <class Clock, class Duration1, class Duration2>
+typename common_type<Duration1, Duration2>::type
+operator-(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
+</pre>
+
+ Returns: <code class="computeroutput">lhs.time_since_epoch() - rhs.time_since_epoch()</code>.
+ 
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.time_point_comparisons"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_point_comparisons" title="time_point
+ comparisons">time_point
+ comparisons</a>
+</h5></div></div></div>
+<div class="toc"><dl>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_point_comparisons.time_point_operator_eq">
+ Non-Member function <code class="computeroutput">operator==(time_point,time_point)</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_point_comparisons.time_point_operator_neq">
+ Non-Member function <code class="computeroutput">operator!=(time_point,time_point)</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_point_comparisons.time_point_operator_lt">
+ Non-Member function <code class="computeroutput">operator<(time_point,time_point)</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_point_comparisons.time_point_operator_leq">
+ Non-Member function <code class="computeroutput">operator<=(time_point,time_point)</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_point_comparisons.time_point_operator_gt">
+ Non-Member function <code class="computeroutput">operator>(time_point,time_point)</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_point_comparisons.time_point_operator_geq">
+ Non-Member function <code class="computeroutput">operator>=(time_point,time_point)</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_point_comparisons.time_point_cast">
+ Non-Member function <code class="computeroutput">time_point_cast(time_point)</code></a></dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.time_point_comparisons.time_point_operator_eq"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_point_comparisons.time_point_operator_eq" title="
+ Non-Member function operator==(time_point,time_point)">
+ Non-Member function <code class="computeroutput">operator==(time_point,time_point)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">template <class Clock, class Duration1, class Duration2>
+bool operator==(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
+</pre>
+
+ Returns: <code class="computeroutput">lhs.time_since_epoch() == rhs.time_since_epoch()</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.time_point_comparisons.time_point_operator_neq"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_point_comparisons.time_point_operator_neq" title="
+ Non-Member function operator!=(time_point,time_point)">
+ Non-Member function <code class="computeroutput">operator!=(time_point,time_point)</code></a>
+</h6></div></div></div>
+
+ template <class Clock, class Duration1, class Duration2> bool
+ operator!=(const time_point<Clock, Duration1>& lhs, const
+ time_point<Clock, Duration2>& rhs);
+ 
+
+ Returns: <code class="computeroutput">!(lhs ==
+ rhs)</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.time_point_comparisons.time_point_operator_lt"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_point_comparisons.time_point_operator_lt" title="
+ Non-Member function operator<(time_point,time_point)">
+ Non-Member function <code class="computeroutput">operator<(time_point,time_point)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">template <class Clock, class Duration1, class Duration2>
+bool operator< (const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
+</pre>
+
+ Returns: lhs.time_since_epoch() <
+ rhs.time_since_epoch().
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.time_point_comparisons.time_point_operator_leq"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_point_comparisons.time_point_operator_leq" title="
+ Non-Member function operator<=(time_point,time_point)">
+ Non-Member function <code class="computeroutput">operator<=(time_point,time_point)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">template <class Clock, class Duration1, class Duration2>
+bool operator<=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
+</pre>
+
+ Returns: <code class="computeroutput">!(rhs <
+ lhs)</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.time_point_comparisons.time_point_operator_gt"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_point_comparisons.time_point_operator_gt" title="
+ Non-Member function operator>(time_point,time_point)">
+ Non-Member function <code class="computeroutput">operator>(time_point,time_point)</code></a>
+</h6></div></div></div>
+
+ template <class Clock, class Duration1, class Duration2> bool
+ operator> (const time_point<Clock, Duration1>& lhs, const
+ time_point<Clock, Duration2>& rhs);
+ 
+
+ Returns: <code class="computeroutput">rhs
+ < lhs</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.time_point_comparisons.time_point_operator_geq"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_point_comparisons.time_point_operator_geq" title="
+ Non-Member function operator>=(time_point,time_point)">
+ Non-Member function <code class="computeroutput">operator>=(time_point,time_point)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">template <class Clock, class Duration1, class Duration2>
+bool operator>=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
+</pre>
+
+ Returns: <code class="computeroutput">!(lhs <
+ rhs)</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.time_point_comparisons.time_point_cast"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.time_point_comparisons.time_point_cast" title="
+ Non-Member function time_point_cast(time_point)">
+ Non-Member function <code class="computeroutput">time_point_cast(time_point)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">template <class ToDuration, class Clock, class Duration>
+time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration>& t);
+</pre>
+
+ Requires: This function will not participate
+ in overload resolution unless <code class="computeroutput">ToDuration</code>
+ is an instantiation of <code class="computeroutput">duration</code>.
+ 
+
+ Returns: <code class="computeroutput">time_point<Clock, ToDuration>(duration_cast<ToDuration>(t.time_since_epoch()))</code>.
+ 
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.class__system_clock_"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class__system_clock_" title="Class
+ system_clock">Class
+ <code class="computeroutput">system_clock</code></a>
+</h5></div></div></div>
+<div class="toc"><dl>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class__system_clock_.to_time_t">
+ Static member function <code class="computeroutput">to_time_t(time_point)</code></a></dt>
+<dt><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class__system_clock_.from_time_t">
+ Static member function <code class="computeroutput">from_time_t(time_t)</code></a></dt>
+</dl></div>
+
+ The <code class="computeroutput">system_clock</code> class
+ provides a means of obtaining the current wall-clock time from the system-wide
+ real-time clock. The current time can be obtained by calling <code class="computeroutput">system_clock::now()</code>.
+ Instances of <code class="computeroutput">system_clock::time_point</code>
+ can be converted to and from time_t with the <code class="computeroutput">system_clock::to_time_t()</code> and <code class="computeroutput">system_clock::to_time_point()</code> functions. If system clock is not monotonic,
+ a subsequent call to <code class="computeroutput">system_clock::now()</code> may return an earlier time than a previous
+ call (e.g. if the operating system clock is manually adjusted, or synchronized
+ with an external clock).
+ 
+<pre class="programlisting">class system_clock {
+public:
+ typedef BOOST_SYSTEM_CLOCK_DURATION duration;
+ typedef duration::rep rep;
+ typedef duration::period period;
+ typedef chrono::time_point<system_clock> time_point;
+ static const bool is_monotonic = false;
+
+ static time_point now(); // throws on error
+ static time_point now(system::error_code & ec); // never throws
+
+ static std::time_t to_time_t(const time_point& t);
+ static time_point from_time_t(std::time_t t);
+};
+</pre>
+
+ <code class="computeroutput">system_clock</code> satisfy
+ the Clock Requirements. In addition:
+ 
+<div class="itemizedlist"><ul type="disc"><li>
+<code class="computeroutput">system_clock::duration::min() < system_clock::duration::zero()</code> is <code class="computeroutput">true</code>.
+ </li></ul></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.class__system_clock_.to_time_t"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class__system_clock_.to_time_t" title="
+ Static member function to_time_t(time_point)">
+ Static member function <code class="computeroutput">to_time_t(time_point)</code></a>
+</h6></div></div></div>
+
+ time_t to_time_t(const time_point& t);
+ 
+
+ Returns: A <code class="computeroutput">time_t</code>
+ such that the <code class="computeroutput">time_t</code>
+ and <code class="computeroutput">t</code> represent the
+ same point in time, truncated to the courser of the precisions among
+ <code class="computeroutput">time_t</code> and <code class="computeroutput">t</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.class__system_clock_.from_time_t"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class__system_clock_.from_time_t" title="
+ Static member function from_time_t(time_t)">
+ Static member function <code class="computeroutput">from_time_t(time_t)</code></a>
+</h6></div></div></div>
+<pre class="programlisting">time_point from_time_t(time_t t);
+</pre>
+
+ Returns: A <code class="computeroutput">time_point</code>
+ such that the <code class="computeroutput">time_point</code>
+ and <code class="computeroutput">t</code> represent the
+ same point in time, truncated to the courser of the precisions among
+ <code class="computeroutput">time_point</code> and <code class="computeroutput">t</code>.
+ 
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.class__monotonic_clock_"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class__monotonic_clock_" title="Class
+ monotonic_clock">Class
+ <code class="computeroutput">monotonic_clock</code></a>
+</h5></div></div></div>
+
+ <code class="computeroutput">monotonic_clock</code> satisfy
+ the Clock Requirements.
+ 
+
+ <code class="computeroutput">monotonic_clock</code> class
+ provides access to the system-wide monotonic clock. The current time
+ can be obtained by calling <code class="computeroutput">monotonic_clock::now()</code>. There is no fixed relationship between
+ values returned by <code class="computeroutput">monotonic_clock::now()</code> and wall-clock time.
+ 
+<pre class="programlisting">#ifdef BOOST_HAS_CLOCK_MONOTONIC
+ class BOOST_CHRONO_DECL monotonic_clock {
+ public:
+ typedef nanoseconds duration;
+ typedef duration::rep rep;
+ typedef duration::period period;
+ typedef chrono::time_point<monotonic_clock> time_point;
+ static const bool is_monotonic = true;
+
+ static time_point now(); // throws on error
+ static time_point now(system::error_code & ec); // never throws
+ };
+#endif
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.cpp0x.chrono_hpp.class__high_resolution_clock_"></a><a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_hpp.class__high_resolution_clock_" title="Class
+ high_resolution_clock">Class
+ <code class="computeroutput">high_resolution_clock</code></a>
+</h5></div></div></div>
+
+ <code class="computeroutput">high_resolution_clock</code>
+ satisfy the Clock Requirements.
+ 
+<pre class="programlisting">#ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
+ typedef monotonic_clock high_resolution_clock; // as permitted by [time.clock.hires]
+#else
+ typedef system_clock high_resolution_clock; // as permitted by [time.clock.hires]
+#endif
+</pre>
+</div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 Howard Hinnant Copyright © 2006 , 2008 Beman Dawes Copyright © 2009 Vicente J. Botet Escriba
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../reference.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="process_cpu_related.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/deprecated_headers.html
==============================================================================
--- (empty file)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/deprecated_headers.html 2009-12-21 11:56:04 EST (Mon, 21 Dec 2009)
@@ -0,0 +1,352 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Deprecated
+ Headers</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="../../index.html" title="Boost.Chrono">
+<link rel="up" href="../reference.html" title=" Reference ">
+<link rel="prev" href="stopwatch_reporters.html" title="Stopwatch
+ Reporters">
+<link rel="next" href="../examples.html" title="Examples">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="stopwatch_reporters.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="../examples.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_chrono.reference.deprecated_headers"></a><a href="deprecated_headers.html" title="Deprecated
+ Headers">Deprecated
+ Headers</a>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="deprecated_headers.html#boost_chrono.reference.deprecated_headers.timer_hpp">
+ Deprecated Header <code class="computeroutput"><boost/chrono/timer.hpp></code></a></dt>
+<dd><dl>
+<dt><a href="deprecated_headers.html#boost_chrono.reference.deprecated_headers.timer_hpp.template_class__timer___">Template
+ Class <code class="computeroutput">timer<></code></a></dt>
+<dt>timer useful typedefs</dt>
+</dl></dd>
+<dt><a href="deprecated_headers.html#boost_chrono.reference.deprecated_headers.process_times_hpp">
+ Deprecated Header <code class="computeroutput"><boost/chrono/process_times.hpp></code></a></dt>
+<dd><dl>
+<dt><a href="deprecated_headers.html#boost_chrono.reference.deprecated_headers.process_times_hpp.class__process_clock_">Class
+ <code class="computeroutput">process_clock</code></a></dt>
+<dt><a href="deprecated_headers.html#boost_chrono.reference.deprecated_headers.process_times_hpp.typedef__process_times_">Typedef
+ <code class="computeroutput">process_times</code></a></dt>
+<dt><a href="deprecated_headers.html#boost_chrono.reference.deprecated_headers.process_times_hpp.class__process_timer_">Class
+ <code class="computeroutput">process_timer</code></a></dt>
+<dt><a href="deprecated_headers.html#boost_chrono.reference.deprecated_headers.process_times_hpp.class__run_timer_">Class
+ <code class="computeroutput">run_timer</code></a></dt>
+</dl></dd>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_chrono.reference.deprecated_headers.timer_hpp"></a><a href="deprecated_headers.html#boost_chrono.reference.deprecated_headers.timer_hpp" title="
+ Deprecated Header <boost/chrono/timer.hpp>">
+ Deprecated Header <code class="computeroutput"><boost/chrono/timer.hpp></code></a>
+</h4></div></div></div>
+<div class="toc"><dl>
+<dt><a href="deprecated_headers.html#boost_chrono.reference.deprecated_headers.timer_hpp.template_class__timer___">Template
+ Class <code class="computeroutput">timer<></code></a></dt>
+<dt>timer useful typedefs</dt>
+</dl></div>
+
+ This header has been replaced by the header <boost/chrono/stopwatch.hpp>.
+ 
+<pre class="programlisting">namespace boost { namespace chrono {
+ template <class Clock=high_resolution_clock> class timer;
+ typedef <see above> system_timer;
+ #ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
+ typedef <see above> monotonic_timer;
+ #endif
+ typedef <see above> high_resolution_timer;
+}}
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.deprecated_headers.timer_hpp.template_class__timer___"></a><a href="deprecated_headers.html#boost_chrono.reference.deprecated_headers.timer_hpp.template_class__timer___" title="Template
+ Class timer<>">Template
+ Class <code class="computeroutput">timer<></code></a>
+</h5></div></div></div>
+
+ Knowing how long a part of a program takes to execute is useful in both
+ test and production environments. A <code class="computeroutput">timer</code>
+ object measures elapsed time. It is recommended to use it with clocks
+ that measure wall clock rather than CPU time since the intended use is
+ performance measurement on systems where total elapsed time is more important
+ than just process or CPU time.
+ 
+
+ The maximum measurable elapsed time depends on the Clock parameter. The
+ accuracy of timings depends on the accuracy of timing information provided
+ the Clock, and this coudl varies a great deal from one clock to another.
+ 
+<pre class="programlisting">template <class Clock> class timer {
+public:
+ typedef Clock clock;
+ typedef typename Clock::duration duration;
+ typedef typename Clock::time_point time_point;
+
+ explicit timer( system::error_code & ec = system::throws );
+
+ ~timer();
+
+ void start( system::error_code & ec = system::throws );
+ duration elapsed( system::error_code & ec = system::throws );
+
+};
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.deprecated_headers.timer_hpp._timer__useful_typedefs"></a>timer useful typedefs
+</h5></div></div></div>
+<pre class="programlisting">typedef boost::chrono::timer< boost::chrono::system_clock > system_timer;
+#ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
+typedef boost::chrono::timer< boost::chrono::monotonic_clock > monotonic_timer;
+#endif
+typedef boost::chrono::timer< boost::chrono::high_resolution_clock > high_resolution_timer;
+</pre>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_chrono.reference.deprecated_headers.process_times_hpp"></a><a href="deprecated_headers.html#boost_chrono.reference.deprecated_headers.process_times_hpp" title="
+ Deprecated Header <boost/chrono/process_times.hpp>">
+ Deprecated Header <code class="computeroutput"><boost/chrono/process_times.hpp></code></a>
+</h4></div></div></div>
+<div class="toc"><dl>
+<dt><a href="deprecated_headers.html#boost_chrono.reference.deprecated_headers.process_times_hpp.class__process_clock_">Class
+ <code class="computeroutput">process_clock</code></a></dt>
+<dt><a href="deprecated_headers.html#boost_chrono.reference.deprecated_headers.process_times_hpp.typedef__process_times_">Typedef
+ <code class="computeroutput">process_times</code></a></dt>
+<dt><a href="deprecated_headers.html#boost_chrono.reference.deprecated_headers.process_times_hpp.class__process_timer_">Class
+ <code class="computeroutput">process_timer</code></a></dt>
+<dt><a href="deprecated_headers.html#boost_chrono.reference.deprecated_headers.process_times_hpp.class__run_timer_">Class
+ <code class="computeroutput">run_timer</code></a></dt>
+</dl></div>
+
+ This header has been deprecated. See the <code class="computeroutput"><boost/chrono/process_clocks.hpp></code>,
+ <code class="computeroutput"><boost/chrono/process_stopwatches.hpp></code> and <code class="computeroutput"><boost/chrono/process_stopwatches_reporter.hpp></code>
+ files.
+ 
+<pre class="programlisting">namespace boost { namespace chrono {
+
+ class process_clock;
+ typedef <see below> process_times;
+ class process_timer;
+ class run_timer;
+
+} }
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.deprecated_headers.process_times_hpp.class__process_clock_"></a><a href="deprecated_headers.html#boost_chrono.reference.deprecated_headers.process_times_hpp.class__process_clock_" title="Class
+ process_clock">Class
+ <code class="computeroutput">process_clock</code></a>
+</h5></div></div></div>
+<div class="toc"><dl><dt><a href="deprecated_headers.html#boost_chrono.reference.deprecated_headers.process_times_hpp.class__process_clock_.class__process_times_">Class
+ <code class="computeroutput">process_times</code></a></dt></dl></div>
+
+ <code class="computeroutput">process_clock</code> doesn't
+ satisfy the Clock Requirements as the function now do not follows the
+ Clock prototype.
+ 
+
+ <code class="computeroutput">process_clock</code> provides
+ a thin wrapper around the operating system's process timer API. For POSIX-like
+ systems, that's the times() function, while for Windows, it's the GetProcessTimes()
+ function.
+ 
+
+ The process relative real, user and system current time can be obtained
+ at once by calling <code class="computeroutput">process_clock::now()</code>.
+ 
+<pre class="programlisting">class process_clock {
+public:
+ typedef nanoseconds duration;
+ typedef duration::rep rep;
+ typedef duration::period period;
+ typedef chrono::time_point<process_clock> time_point;
+ static const bool is_monotonic = true;
+
+ struct process_times;
+ static void now( process_times & times,
+ system::error_code & ec = system::throws );
+};
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.deprecated_headers.process_times_hpp.class__process_clock_.class__process_times_"></a><a href="deprecated_headers.html#boost_chrono.reference.deprecated_headers.process_times_hpp.class__process_clock_.class__process_times_" title="Class
+ process_times">Class
+ <code class="computeroutput">process_times</code></a>
+</h6></div></div></div>
+<pre class="programlisting">struct process_times {
+ process_clock::duration real; // real (i.e wall clock) time
+ process_clock::duration user; // user cpu time
+ process_clock::duration system; // system cpu time
+};
+</pre>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.deprecated_headers.process_times_hpp.typedef__process_times_"></a><a href="deprecated_headers.html#boost_chrono.reference.deprecated_headers.process_times_hpp.typedef__process_times_" title="Typedef
+ process_times">Typedef
+ <code class="computeroutput">process_times</code></a>
+</h5></div></div></div>
+<pre class="programlisting">typedef process_clock::process_times process_times;
+</pre>
+
+ This is a synonym of process_clock::process_times included for backward
+ compatibility.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.deprecated_headers.process_times_hpp.class__process_timer_"></a><a href="deprecated_headers.html#boost_chrono.reference.deprecated_headers.process_times_hpp.class__process_timer_" title="Class
+ process_timer">Class
+ <code class="computeroutput">process_timer</code></a>
+</h5></div></div></div>
+
+ Knowing how long a program takes to execute is useful in both test and
+ production environments. It is also helpful if such timing information
+ is broken down into real (wall clock) time, CPU time spent by the user,
+ and CPU time spent by the operating system servicing user requests.
+ 
+
+ <code class="computeroutput">process_timer<></code>
+ is the <code class="computeroutput">timer<></code>
+ equivalent associated to the pseudo-clock <code class="computeroutput">process_clock</code>.
+ It behaves like <code class="computeroutput">timer<></code> but it uses the specific <code class="computeroutput">process_clock:now()</code>
+ function.
+ 
+<pre class="programlisting">class process_timer {
+public:
+ typedef process_clock clock;
+ typedef process_clock::duration duration;
+ typedef process_clock::time_point time_point;
+
+ explicit process_timer( system::error_code & ec = system::throws );
+
+ ~process_timer();
+ void start( system::error_code & ec = system::throws );
+ void elapsed( process_times & times, system::error_code & ec = system::throws );
+};
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.deprecated_headers.process_times_hpp.class__run_timer_"></a><a href="deprecated_headers.html#boost_chrono.reference.deprecated_headers.process_times_hpp.class__run_timer_" title="Class
+ run_timer">Class
+ <code class="computeroutput">run_timer</code></a>
+</h5></div></div></div>
+
+ class <code class="computeroutput">run_timer</code> provides
+ a complete run time reporting package that can be invoked in a single
+ line of code. The reporting is controled by two parameters:
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+ format : The output format
+ </li>
+<li>
+ places(precission): the number of decimal placess used.
+ </li>
+</ul></div>
+
+ The default places is given by default_places and is 3. The default format
+ is "\nreal %rs, cpu %cs (%p%), user %us, system %ss\n", where
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+<code class="computeroutput">%r</code>
+ : real process clock
+ </li>
+<li>
+<code class="computeroutput">%u</code>
+ : user process clock
+ </li>
+<li>
+<code class="computeroutput">%s</code>
+ : system process clock
+ </li>
+<li>
+<code class="computeroutput">%c</code>
+ : user+system process clock
+ </li>
+<li>
+<code class="computeroutput">%p</code>
+ : percentage (user+system)/real process clock
+ </li>
+</ul></div>
+
+ All the units are given using the suffix "s" following the
+ System International d'Unites Std.
+ 
+<pre class="programlisting">class run_timer : public process_timer {
+public:
+ explicit run_timer( system::error_code & ec = system::throws );
+ explicit run_timer( std::ostream & os,
+ system::error_code & ec = system::throws );
+
+ explicit run_timer( const std::string & format,
+ system::error_code & ec = system::throws );
+ explicit run_timer( std::ostream & os, const std::string & format,
+ system::error_code & ec = system::throws );
+
+ explicit run_timer( const std::string & format, int places,
+ system::error_code & ec = system::throws );
+ explicit run_timer( std::ostream & os, const std::string & format, int places,
+ system::error_code & ec = system::throws );
+
+ explicit run_timer( int places,
+ system::error_code & ec = system::throws );
+ explicit run_timer( std::ostream & os, int places,
+ system::error_code & ec = system::throws );
+
+ explicit run_timer( int places, const std::string & format,
+ system::error_code & ec = system::throws );
+ explicit run_timer( std::ostream & os, int places, const std::string & format,
+ system::error_code & ec = system::throws );
+
+ ~run_timer();
+
+ void start( system::error_code & ec = system::throws );
+
+ void report( system::error_code & ec = system::throws );
+
+ void test_report( duration real_, duration user_, duration system_ );
+ bool reported() const;
+ static int default_places();
+};
+</pre>
+</div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 Howard Hinnant Copyright © 2006 , 2008 Beman Dawes Copyright © 2009 Vicente J. Botet Escriba
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="stopwatch_reporters.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="../examples.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/process_cpu_related.html
==============================================================================
--- (empty file)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/process_cpu_related.html 2009-12-21 11:56:04 EST (Mon, 21 Dec 2009)
@@ -0,0 +1,227 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Process CPU
+ related</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="../../index.html" title="Boost.Chrono">
+<link rel="up" href="../reference.html" title=" Reference ">
+<link rel="prev" href="cpp0x.html" title=" Included on the C++0x
+ recommendation">
+<link rel="next" href="stopwatches.html" title="Stopwatches">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="cpp0x.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="stopwatches.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_chrono.reference.process_cpu_related"></a><a href="process_cpu_related.html" title="Process CPU
+ related">Process CPU
+ related</a>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="process_cpu_related.html#boost_chrono.reference.process_cpu_related.process_clocks_hpp">
+ Header <code class="computeroutput"><boost/chrono/process_clocks.hpp></code></a></dt>
+<dd><dl>
+<dt><a href="process_cpu_related.html#boost_chrono.reference.process_cpu_related.process_clocks_hpp.class__process_real_cpu_clock_">Class
+ <code class="computeroutput">process_real_cpu_clock</code></a></dt>
+<dt><a href="process_cpu_related.html#boost_chrono.reference.process_cpu_related.process_clocks_hpp.class__process_user_cpu_clock_">Class
+ <code class="computeroutput">process_user_cpu_clock</code></a></dt>
+<dt><a href="process_cpu_related.html#boost_chrono.reference.process_cpu_related.process_clocks_hpp.class__process_system_cpu_clock_">Class
+ <code class="computeroutput">process_system_cpu_clock</code></a></dt>
+<dt><a href="process_cpu_related.html#boost_chrono.reference.process_cpu_related.process_clocks_hpp.class__process_clocks_">Class
+ <code class="computeroutput">process_clocks</code></a></dt>
+</dl></dd>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_chrono.reference.process_cpu_related.process_clocks_hpp"></a><a href="process_cpu_related.html#boost_chrono.reference.process_cpu_related.process_clocks_hpp" title="
+ Header <boost/chrono/process_clocks.hpp>">
+ Header <code class="computeroutput"><boost/chrono/process_clocks.hpp></code></a>
+</h4></div></div></div>
+<div class="toc"><dl>
+<dt><a href="process_cpu_related.html#boost_chrono.reference.process_cpu_related.process_clocks_hpp.class__process_real_cpu_clock_">Class
+ <code class="computeroutput">process_real_cpu_clock</code></a></dt>
+<dt><a href="process_cpu_related.html#boost_chrono.reference.process_cpu_related.process_clocks_hpp.class__process_user_cpu_clock_">Class
+ <code class="computeroutput">process_user_cpu_clock</code></a></dt>
+<dt><a href="process_cpu_related.html#boost_chrono.reference.process_cpu_related.process_clocks_hpp.class__process_system_cpu_clock_">Class
+ <code class="computeroutput">process_system_cpu_clock</code></a></dt>
+<dt><a href="process_cpu_related.html#boost_chrono.reference.process_cpu_related.process_clocks_hpp.class__process_clocks_">Class
+ <code class="computeroutput">process_clocks</code></a></dt>
+</dl></div>
+
+ Knowing how long a program takes to execute is useful in both test and
+ production environments. It is also helpful if such timing information
+ is broken down into real (wall clock) time, CPU time spent by the user,
+ and CPU time spent by the operating system servicing user requests.
+ 
+<pre class="programlisting">namespace boost { namespace chrono {
+
+ class process_real_cpu_clock;
+ class process_user_cpu_clock;
+ class process_system_cpu_clock;
+ class process_clocks;
+
+} }
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.process_cpu_related.process_clocks_hpp.class__process_real_cpu_clock_"></a><a href="process_cpu_related.html#boost_chrono.reference.process_cpu_related.process_clocks_hpp.class__process_real_cpu_clock_" title="Class
+ process_real_cpu_clock">Class
+ <code class="computeroutput">process_real_cpu_clock</code></a>
+</h5></div></div></div>
+
+ <code class="computeroutput">process_real_cpu_clock</code>
+ satisfy the Clock Requirements.
+ 
+
+ <code class="computeroutput">process_real_cpu_clock</code>
+ class provides access to the real process wall-clock monotonic clock,
+ i.e. the real CPU-time clock of the calling process. The process relative
+ current time can be obtained by calling <code class="computeroutput">process_real_cpu_clock::now()</code>.
+ 
+<pre class="programlisting">class process_real_cpu_clock {
+public:
+ typedef nanoseconds duration;
+ typedef duration::rep rep;
+ typedef duration::period period;
+ typedef chrono::time_point<process_real_cpu_clock> time_point;
+ static const bool is_monotonic = true;
+
+ static time_point now( system::error_code & ec = system::throws );
+};
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.process_cpu_related.process_clocks_hpp.class__process_user_cpu_clock_"></a><a href="process_cpu_related.html#boost_chrono.reference.process_cpu_related.process_clocks_hpp.class__process_user_cpu_clock_" title="Class
+ process_user_cpu_clock">Class
+ <code class="computeroutput">process_user_cpu_clock</code></a>
+</h5></div></div></div>
+
+ <code class="computeroutput">process_user_cpu_clock</code>
+ satisfy the Clock Requirements.
+ 
+
+ <code class="computeroutput">process_user_cpu_clock</code>
+ class provides access to the user CPU-time monotonic clock of the calling
+ process. The process relative user current time can be obtained by calling
+ <code class="computeroutput">process_user_cpu_clock::now()</code>.
+ 
+<pre class="programlisting">class process_user_cpu_clock {
+public:
+ typedef nanoseconds duration;
+ typedef duration::rep rep;
+ typedef duration::period period;
+ typedef chrono::time_point<process_user_cpu_clock> time_point;
+ static const bool is_monotonic = true;
+
+ static time_point now( system::error_code & ec = system::throws );
+};
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.process_cpu_related.process_clocks_hpp.class__process_system_cpu_clock_"></a><a href="process_cpu_related.html#boost_chrono.reference.process_cpu_related.process_clocks_hpp.class__process_system_cpu_clock_" title="Class
+ process_system_cpu_clock">Class
+ <code class="computeroutput">process_system_cpu_clock</code></a>
+</h5></div></div></div>
+
+ <code class="computeroutput">process_system_cpu_clock</code>
+ satisfy the Clock Requirements.
+ 
+
+ <code class="computeroutput">process_system_cpu_clock</code>
+ class provides access to the system CPU-time monotonic clockof the calling
+ process. The process relative system current time can be obtained by
+ calling <code class="computeroutput">process_system_cpu_clock::now()</code>.
+ 
+<pre class="programlisting">class process_system_cpu_clock {
+public:
+ typedef nanoseconds duration;
+ typedef duration::rep rep;
+ typedef duration::period period;
+ typedef chrono::time_point<process_system_cpu_clock> time_point;
+ static const bool is_monotonic = true;
+
+ static time_point now( system::error_code & ec = system::throws );
+};
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.process_cpu_related.process_clocks_hpp.class__process_clocks_"></a><a href="process_cpu_related.html#boost_chrono.reference.process_cpu_related.process_clocks_hpp.class__process_clocks_" title="Class
+ process_clocks">Class
+ <code class="computeroutput">process_clocks</code></a>
+</h5></div></div></div>
+<div class="toc"><dl><dt><a href="process_cpu_related.html#boost_chrono.reference.process_cpu_related.process_clocks_hpp.class__process_clocks_.class__durations_">Class
+ <code class="computeroutput">durations</code></a></dt></dl></div>
+
+ <code class="computeroutput">process_clocks</code> can be
+ considered as a <code class="computeroutput">tuple<process_real_cpu_clock, process_user_cpu_clock, process_system_cpu_clock></code>. Obviously it doesn't satisfy the
+ Clock Requirements.
+ 
+
+ <code class="computeroutput">process_clocks</code> provides
+ a thin wrapper around the operating system's process timer API. For POSIX-like
+ systems, that's the times() function, while for Windows, it's the GetProcessTimes()
+ function.
+ 
+
+ The process relative real, user and system current time can be obtained
+ at once by calling <code class="computeroutput">process_clocks::now()</code>.
+ 
+<pre class="programlisting">class process_clocks {
+public:
+ typedef nanoseconds duration;
+ typedef duration::rep rep;
+ typedef duration::period period;
+ typedef chrono::time_point<process_clocks> time_point;
+ static const bool is_monotonic = true;
+
+ struct durations;
+ static void now( process_clocks::durations & times,
+ system::error_code & ec = system::throws );
+};
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.process_cpu_related.process_clocks_hpp.class__process_clocks_.class__durations_"></a><a href="process_cpu_related.html#boost_chrono.reference.process_cpu_related.process_clocks_hpp.class__process_clocks_.class__durations_" title="Class
+ durations">Class
+ <code class="computeroutput">durations</code></a>
+</h6></div></div></div>
+<pre class="programlisting">struct durations {
+ process_clocks::duration real; // real (i.e wall clock) time
+ process_clocks::duration user; // user cpu time
+ process_clocks::duration system; // system cpu time
+};
+</pre>
+</div>
+</div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 Howard Hinnant Copyright © 2006 , 2008 Beman Dawes Copyright © 2009 Vicente J. Botet Escriba
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="cpp0x.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="stopwatches.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/stopwatch_reporters.html
==============================================================================
--- (empty file)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/stopwatch_reporters.html 2009-12-21 11:56:04 EST (Mon, 21 Dec 2009)
@@ -0,0 +1,550 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Stopwatch
+ Reporters</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="../../index.html" title="Boost.Chrono">
+<link rel="up" href="../reference.html" title=" Reference ">
+<link rel="prev" href="stopwatches.html" title="Stopwatches">
+<link rel="next" href="deprecated_headers.html" title="Deprecated
+ Headers">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="stopwatches.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="deprecated_headers.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_chrono.reference.stopwatch_reporters"></a><a href="stopwatch_reporters.html" title="Stopwatch
+ Reporters">Stopwatch
+ Reporters</a>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopwatch_reporter_hpp">
+ Header <code class="computeroutput"><boost/chrono/stopwatch_reporter.hpp></code></a></dt>
+<dd><dl>
+<dt>Formatter Requirements</dt>
+<dt>Formatter related traits</dt>
+<dt><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopwatch_reporter_hpp.template_class__stopwatch_reporter___">Template
+ Class <code class="computeroutput">stopwatch_reporter<></code></a></dt>
+<dt>stopwatch_reporter useful typedefs</dt>
+</dl></dd>
+<dt><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopwatch_formatter_hpp">
+ Header <code class="computeroutput"><boost/chrono/stopwatch_formatter.hpp></code></a></dt>
+<dd><dl><dt><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopwatch_formatter_hpp.class__stopwatch_formatter_">Class
+ <code class="computeroutput">stopwatch_formatter</code></a></dt></dl></dd>
+<dt><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopwatch_accumulator_formatter_hpp">
+ Header <code class="computeroutput"><boost/chrono/stopwatch_accumulator_formatter.hpp></code></a></dt>
+<dd><dl><dt><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopwatch_accumulator_formatter_hpp.class__stopwatch_accumulator_formatter_">Class
+ <code class="computeroutput">stopwatch_accumulator_formatter</code></a></dt></dl></dd>
+<dt><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.process_process_stopwatches_reporter_hpp">
+ Header <code class="computeroutput"><boost/chrono/process_stopwatches_reporter.hpp></code></a></dt>
+<dd><dl><dt><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.process_process_stopwatches_reporter_hpp.class__process_stopwatches_reporter_">Class
+ <code class="computeroutput">process_stopwatches_reporter</code></a></dt></dl></dd>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_chrono.reference.stopwatch_reporters.stopwatch_reporter_hpp"></a><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopwatch_reporter_hpp" title="
+ Header <boost/chrono/stopwatch_reporter.hpp>">
+ Header <code class="computeroutput"><boost/chrono/stopwatch_reporter.hpp></code></a>
+</h4></div></div></div>
+<div class="toc"><dl>
+<dt>Formatter Requirements</dt>
+<dt>Formatter related traits</dt>
+<dt><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopwatch_reporter_hpp.template_class__stopwatch_reporter___">Template
+ Class <code class="computeroutput">stopwatch_reporter<></code></a></dt>
+<dt>stopwatch_reporter useful typedefs</dt>
+</dl></div>
+<pre class="programlisting">namespace boost { namespace chrono {
+ template <class Stopwatch>
+ struct stopwatch_reporter_default_formatter;
+
+ template <class Stopwatch, class Formatter=typename stopwatch_reporter_default_formatter<Stopwatch>::type>
+ class stopwatch_reporter;
+ typedef <see above> system_stopwatch_reporter;
+ #ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
+ typedef <see above> monotonic_stopwatch_reporter;
+ #endif
+ typedef <see above> high_resolution_stopwatch_reporter;
+ typedef <see above> process_real_cpu_stopwatch_reporter;
+ typedef <see above> process_user_cpu_stopwatch_reporter;
+ typedef <see above> process_system_cpu_stopwatch_reporter;
+}}
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.stopwatch_reporters.stopwatch_reporter_hpp._formatter__requirements"></a>Formatter Requirements
+</h5></div></div></div>
+
+ A Formatter outputs on a given ostream a formatted string combining informations
+ from a Stopwatch and the format and the double precission.
+ 
+
+ A Stopwatch must meet the requirements in the following Table.
+ 
+
+ In this table <code class="computeroutput">F</code> denote
+ Fromaters types, <code class="computeroutput">S</code> is
+ a Stopwatch and <code class="computeroutput">s</code> is
+ an instance of <code class="computeroutput">S</code>, <code class="computeroutput">f</code> is <code class="computeroutput">const
+ char *</code>
+ , <code class="computeroutput">p</code> is and int, and
+ <code class="computeroutput">os</code> is a <code class="computeroutput">std::ostream</code>, ec is a system::error_code
+ 
+<div class="table">
+<a name="id4860232"></a>Table 3. Stopwatch Requirements
+<table class="table" summary="Stopwatch Requirements">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ expression
+ 
+ </th>
+<th>
+ 
+ return type
+ 
+ </th>
+<th>
+ 
+ operational semantics
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ <code class="computeroutput">F::output()</code>
+ 
+ </td>
+<td>
+ 
+ std::otream&
+ 
+ </td>
+<td>
+ 
+ The output stream.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">F::default_places()</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">std::size_t</code>
+ 
+ </td>
+<td>
+ 
+ The precission when displaying a double.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">F::default_format()</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">const char*</code>
+ 
+ </td>
+<td>
+ 
+ The default format.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">F::show_time(s,f,p,os,ec)</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">S::time_point</code>
+ 
+ </td>
+<td>
+ 
+ outputs on <code class="computeroutput">os</code> a
+ formatted string combining informations from the Stopwatch <code class="computeroutput">s</code>, the format <code class="computeroutput">f</code>
+ and the double precission <code class="computeroutput">p</code>.
+ 
+ </td>
+</tr>
+</tbody>
+</table>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.stopwatch_reporters.stopwatch_reporter_hpp._formatter__related_traits"></a>Formatter related traits
+</h5></div></div></div>
+<pre class="programlisting">template <class Stopwatch>
+struct stopwatch_reporter_default_formatter {
+ typedef <see below> type;
+};
+</pre>
+
+ The nested typedef <code class="computeroutput">type</code>
+ defines the default formatter used by the <code class="computeroutput">stopwatch_reporter</code>
+ class when the <code class="computeroutput">Formatter</code>
+ parameter is not explicit.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.stopwatch_reporters.stopwatch_reporter_hpp.template_class__stopwatch_reporter___"></a><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopwatch_reporter_hpp.template_class__stopwatch_reporter___" title="Template
+ Class stopwatch_reporter<>">Template
+ Class <code class="computeroutput">stopwatch_reporter<></code></a>
+</h5></div></div></div>
+
+ class <code class="computeroutput">stopwatch_reporter</code>
+ provides a everything a Timer provides and it adds reporting capabilities
+ that can be invoked in a single line of code. The reporting is controleed
+ by two parameters:
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+ format : The output format
+ </li>
+<li>
+ places(precission): the number of decimal placess used.
+ </li>
+</ul></div>
+
+ The default places is given by Formatter::default_places. The default
+ format is given by Formatter::default_format.
+ 
+<pre class="programlisting">template <class Stopwatch, class Formatter>
+class stopwatch_reporter : public Stopwatch {
+public:
+ explicit stopwatch_reporter( system::error_code & ec = system::throws );
+ explicit stopwatch_reporter( std::ostream & os,
+ system::error_code & ec = system::throws );
+
+ explicit stopwatch_reporter( const std::string & format,
+ system::error_code & ec = system::throws );
+ explicit stopwatch_reporter( std::ostream & os, const std::string & format,
+ system::error_code & ec = system::throws );
+
+ explicit stopwatch_reporter( const std::string & format, int places,
+ system::error_code & ec = system::throws );
+ explicit stopwatch_reporter( std::ostream & os, const std::string & format, int places,
+ system::error_code & ec = system::throws );
+
+ explicit stopwatch_reporter( int places,
+ system::error_code & ec = system::throws );
+ explicit stopwatch_reporter( std::ostream & os, int places,
+ system::error_code & ec = system::throws );
+
+ explicit stopwatch_reporter( int places, const std::string & format,
+ system::error_code & ec = system::throws );
+ explicit stopwatch_reporter( std::ostream & os, int places, const std::string & format,
+ system::error_code & ec = system::throws );
+
+ ~stopwatch_reporter();
+
+ void report( system::error_code & ec = system::throws );
+ bool reported() const;
+
+
+ typedef stopwatch_runner<stopwatch_reporter<Stopwatch> > scoped_run;
+ typedef stopwatch_suspender<stopwatch_reporter<Stopwatch> > scoped_suspend;
+ typedef stopwatch_resumer<stopwatch_reporter<Stopwatch> > scoped_resume;
+};
+</pre>
+
+ Usage
+ 
+<pre class="programlisting">void f1()
+{
+ typedef stopwatch_reporter<stopwatch_accumulator<> > accumulator;
+ static accumulator t;
+ accumulator::scoped_run _(t);
+ // ...
+
+ // call to some function we don't want to measure
+ {
+ accumulator::scoped_suspend _(t);
+ external_function();
+ }
+}
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.stopwatch_reporters.stopwatch_reporter_hpp._stopwatch_reporter__useful_typedefs"></a>stopwatch_reporter useful typedefs
+</h5></div></div></div>
+<pre class="programlisting">typedef boost::chrono::stopwatch_reporter< boost::chrono::system_clock > system_stopwatch_reporter;
+#ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
+typedef boost::chrono::stopwatch_reporter< boost::chrono::monotonic_clock > monotonic_stopwatch_reporter;
+#endif
+typedef boost::chrono::stopwatch_reporter< boost::chrono::high_resolution_clock > high_resolution_stopwatch_reporter;
+typedef boost::chrono::stopwatch_reporter< boost::chrono::process_real_cpu_clock > process_real_cpu_stopwatch_reporter;
+typedef boost::chrono::stopwatch_reporter< boost::chrono::process_user_cpu_clock > process_user_cpu_stopwatch_reporter;
+typedef boost::chrono::stopwatch_reporter< boost::chrono::process_system_cpu_clock > process_system_cpu_stopwatch_reporter;
+</pre>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_chrono.reference.stopwatch_reporters.stopwatch_formatter_hpp"></a><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopwatch_formatter_hpp" title="
+ Header <boost/chrono/stopwatch_formatter.hpp>">
+ Header <code class="computeroutput"><boost/chrono/stopwatch_formatter.hpp></code></a>
+</h4></div></div></div>
+<div class="toc"><dl><dt><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopwatch_formatter_hpp.class__stopwatch_formatter_">Class
+ <code class="computeroutput">stopwatch_formatter</code></a></dt></dl></div>
+<pre class="programlisting">namespace boost { namespace chrono {
+ class stopwatch_formatter;
+}}
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.stopwatch_reporters.stopwatch_formatter_hpp.class__stopwatch_formatter_"></a><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopwatch_formatter_hpp.class__stopwatch_formatter_" title="Class
+ stopwatch_formatter">Class
+ <code class="computeroutput">stopwatch_formatter</code></a>
+</h5></div></div></div>
+
+ <code class="computeroutput">stopwatch_formatter</code> is
+ a model of <code class="computeroutput">Formatter</code>.
+ 
+<pre class="programlisting">class stopwatch_formatter {
+public:
+ static std::ostream & m_cout();
+ static const int m_default_places = 3;
+ static const char * default_format;
+ static int default_places() { return m_default_places; }
+
+ template < class Stopwatch >
+ static void show_time( Stopwatch & stopwatch_, const char * format, int places, std::ostream & os, system::error_code & ec);
+};
+</pre>
+
+ The default places is given by default_places and is 3. The default format
+ is "\n%ts\n", where
+ 
+<div class="itemizedlist"><ul type="disc"><li>
+<code class="computeroutput">%d</code>
+ : the result of elapsed() when the reporting is done.
+ </li></ul></div>
+
+ The time is given using the suffix "s" following the System
+ International d'Unites Std.
+ 
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_chrono.reference.stopwatch_reporters.stopwatch_accumulator_formatter_hpp"></a><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopwatch_accumulator_formatter_hpp" title="
+ Header <boost/chrono/stopwatch_accumulator_formatter.hpp>">
+ Header <code class="computeroutput"><boost/chrono/stopwatch_accumulator_formatter.hpp></code></a>
+</h4></div></div></div>
+<div class="toc"><dl><dt><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopwatch_accumulator_formatter_hpp.class__stopwatch_accumulator_formatter_">Class
+ <code class="computeroutput">stopwatch_accumulator_formatter</code></a></dt></dl></div>
+<pre class="programlisting">namespace boost { namespace chrono {
+ class stopwatch_accumulator_formatter;
+}}
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.stopwatch_reporters.stopwatch_accumulator_formatter_hpp.class__stopwatch_accumulator_formatter_"></a><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopwatch_accumulator_formatter_hpp.class__stopwatch_accumulator_formatter_" title="Class
+ stopwatch_accumulator_formatter">Class
+ <code class="computeroutput">stopwatch_accumulator_formatter</code></a>
+</h5></div></div></div>
+
+ <code class="computeroutput">stopwatch_accumulator_formatter</code>
+ is a model of <code class="computeroutput">Formatter</code>
+ 
+<pre class="programlisting">class stopwatch_accumulator_formatter {
+public:
+ static std::ostream & m_cout();
+ static const int m_default_places = 3;
+ static const char * default_format;
+ static int default_places() { return m_default_places; }
+
+ template <class Stopwatch >
+ static void show_time( Stopwatch & stopwatch_, const char * format, int places, std::ostream & os, system::error_code & ec);
+};
+</pre>
+
+ The default places is given by default_places and is 3. The default format
+ is "\n"Count<code class="literal">%c times Sum</code>%ss Min<code class="literal">%ms
+ Max</code>%Ms Mean=%as\n", where
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+<code class="computeroutput">%c</code>
+ : the counter of the number of times the pair srat/stop has been called.
+ </li>
+<li>
+<code class="computeroutput">%s</code>
+ : the sum of the samples of elapsed time between the call to start/stop.
+ </li>
+<li>
+<code class="computeroutput">%m</code>
+ : the min of the samples of elapsed time between the call to start/stop.
+ </li>
+<li>
+<code class="computeroutput">%M</code>
+ : the max of the samples of elapsed time between the call to start/stop.
+ </li>
+<li>
+<code class="computeroutput">%a</code>
+ : the mean of the samples of elapsed time between the call to start/stop.
+ </li>
+</ul></div>
+
+ The time is given using the suffix "s" following the System
+ International d'Unites Std.
+ 
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_chrono.reference.stopwatch_reporters.process_process_stopwatches_reporter_hpp"></a><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.process_process_stopwatches_reporter_hpp" title="
+ Header <boost/chrono/process_stopwatches_reporter.hpp>">
+ Header <code class="computeroutput"><boost/chrono/process_stopwatches_reporter.hpp></code></a>
+</h4></div></div></div>
+<div class="toc"><dl><dt><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.process_process_stopwatches_reporter_hpp.class__process_stopwatches_reporter_">Class
+ <code class="computeroutput">process_stopwatches_reporter</code></a></dt></dl></div>
+<pre class="programlisting">namespace boost { namespace chrono {
+
+ class process_stopwatches_reporter;
+
+} }
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.stopwatch_reporters.process_process_stopwatches_reporter_hpp.class__process_stopwatches_reporter_"></a><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.process_process_stopwatches_reporter_hpp.class__process_stopwatches_reporter_" title="Class
+ process_stopwatches_reporter">Class
+ <code class="computeroutput">process_stopwatches_reporter</code></a>
+</h5></div></div></div>
+
+ <code class="computeroutput">process_stopwatches_reporter</code>
+ is the <code class="computeroutput">stopwatches_reporter<></code> associated to the clock tuple
+ <code class="computeroutput">process_clocks</code>.
+ 
+
+ class <code class="computeroutput">process_stopwatches_reporter</code>
+ provides a complete run time reporting package that can be invoked in
+ a single line of code. The reporting is controled by two parameters:
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+ format : The output format
+ </li>
+<li>
+ places(precission): the number of decimal placess used.
+ </li>
+</ul></div>
+
+ The default places is given by default_places and is 3. The default format
+ is "\nreal %rs, cpu %cs (%p%), user %us, system %ss\n", where
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+<code class="computeroutput">%r</code>
+ : real process clock
+ </li>
+<li>
+<code class="computeroutput">%u</code>
+ : user process clock
+ </li>
+<li>
+<code class="computeroutput">%s</code>
+ : system process clock
+ </li>
+<li>
+<code class="computeroutput">%c</code>
+ : user+system process clock
+ </li>
+<li>
+<code class="computeroutput">%p</code>
+ : percentage (user+system)/real process clock
+ </li>
+</ul></div>
+
+ All the units are given using the suffix "s" following the
+ System International d'Unites Std.
+ 
+<pre class="programlisting">class process_stopwatches_reporter : public process_timer {
+public:
+ explicit process_stopwatches_reporter( system::error_code & ec = system::throws );
+ explicit process_stopwatches_reporter( std::ostream & os,
+ system::error_code & ec = system::throws );
+
+ explicit process_stopwatches_reporter( const std::string & format,
+ system::error_code & ec = system::throws );
+ process_stopwatches_reporter( std::ostream & os, const std::string & format,
+ system::error_code & ec = system::throws );
+
+ process_stopwatches_reporter( const std::string & format, int places,
+ system::error_code & ec = system::throws );
+ process_stopwatches_reporter( std::ostream & os, const std::string & format, int places,
+ system::error_code & ec = system::throws );
+
+ explicit process_stopwatches_reporter( int places,
+ system::error_code & ec = system::throws );
+ process_stopwatches_reporter( std::ostream & os, int places,
+ system::error_code & ec = system::throws );
+
+ process_stopwatches_reporter( int places, const std::string & format,
+ system::error_code & ec = system::throws );
+ process_stopwatches_reporter( std::ostream & os, int places, const std::string & format,
+ system::error_code & ec = system::throws );
+
+ ~process_stopwatches_reporter();
+
+ void start( system::error_code & ec = system::throws );
+
+ void report( system::error_code & ec = system::throws );
+
+ void test_report( duration real_, duration user_, duration system_ );
+ bool reported() const;
+ static int default_places();
+};
+</pre>
+</div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 Howard Hinnant Copyright © 2006 , 2008 Beman Dawes Copyright © 2009 Vicente J. Botet Escriba
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="stopwatches.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="deprecated_headers.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/stopwatches.html
==============================================================================
--- (empty file)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/stopwatches.html 2009-12-21 11:56:04 EST (Mon, 21 Dec 2009)
@@ -0,0 +1,817 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Stopwatches</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="../../index.html" title="Boost.Chrono">
+<link rel="up" href="../reference.html" title=" Reference ">
+<link rel="prev" href="process_cpu_related.html" title="Process CPU
+ related">
+<link rel="next" href="stopwatch_reporters.html" title="Stopwatch
+ Reporters">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="process_cpu_related.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="stopwatch_reporters.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_chrono.reference.stopwatches"></a>Stopwatches
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt>Stopwatch Requirements</dt>
+<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_hpp">
+ Header <code class="computeroutput"><boost/chrono/stopwatch.hpp></code></a></dt>
+<dd><dl>
+<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_hpp.template_class__stopwatch___">Template
+ Class <code class="computeroutput">stopwatch<></code></a></dt>
+<dt>stopwatch useful typedefs</dt>
+</dl></dd>
+<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp">
+ Header <code class="computeroutput"><boost/chrono/stopwatch_accumulator.hpp></code></a></dt>
+<dd><dl>
+<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.template_class__stopwatch_accumulator___">Template
+ Class <code class="computeroutput">stopwatch_accumulator<></code></a></dt>
+<dt>stopwatch_accumulator useful typedefs</dt>
+</dl></dd>
+<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_scoped_hpp">
+ Header <code class="computeroutput"><boost/chrono/stopwatch_scoped.hpp></code></a></dt>
+<dd><dl>
+<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_scoped_hpp.template_class__stopwatch_runner___">Template
+ Class <code class="computeroutput">stopwatch_runner<></code></a></dt>
+<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_scoped_hpp.template_class__stopwatch_suspender___">Template
+ Class <code class="computeroutput">stopwatch_suspender<></code></a></dt>
+<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_scoped_hpp.template_class__stopwatch_resumer___">Template
+ Class <code class="computeroutput">stopwatch_resumer<></code></a></dt>
+</dl></dd>
+<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.process_stopwatches_hpp">
+ Header <code class="computeroutput"><boost/chrono/process_stopwatches.hpp></code></a></dt>
+<dd><dl><dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.process_stopwatches_hpp.class__process_stopwatches_">Class
+ <code class="computeroutput">process_stopwatches</code></a></dt></dl></dd>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_chrono.reference.stopwatches._stopwatch__requirements"></a>Stopwatch Requirements
+</h4></div></div></div>
+
+ A Stopwatch measure the amount of time elapsed from a particular time when
+ activated to when it is deactivated, or the accumulation of them.
+ 
+
+ A Stopwatch must meet the requirements in the following Table.
+ 
+
+ In this table <code class="computeroutput">S</code>, <code class="computeroutput">S1</code> and <code class="computeroutput">S2</code>
+ denote stopwatches types. <code class="computeroutput">s</code>
+ is an instance of <code class="computeroutput">S</code>.
+ 
+<div class="table">
+<a name="id4851680"></a>Table 2. Stopwatch Requirements
+<table class="table" summary="Stopwatch Requirements">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ expression
+ 
+ </th>
+<th>
+ 
+ return type
+ 
+ </th>
+<th>
+ 
+ operational semantics
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ <code class="computeroutput">S::clock</code>
+ 
+ </td>
+<td>
+ 
+ A model of the CLock concept.
+ 
+ </td>
+<td>
+ 
+ The clock associated to this Stopwatch.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">S::duration</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">S::clock::duration</code>
+ 
+ </td>
+<td>
+ 
+ The <code class="computeroutput">duration</code> type
+ of the <code class="computeroutput">clock</code>.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">S::time_point</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">S::clock::time_point</code>
+ 
+ </td>
+<td>
+ 
+ The <code class="computeroutput">time_point</code> type
+ of the <code class="computeroutput">clock</code>.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">s.start()</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">S::time_point</code>
+ 
+ </td>
+<td>
+ 
+ starts a Stopwatch.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">s.restart()</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">std::paire<S::duration,S::time_point></code>
+ 
+ </td>
+<td>
+ 
+ restarts a Stopwatch.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">s.stop()</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">S::duration</code>
+ 
+ </td>
+<td>
+ 
+ stops a Stopwatch.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">s.resume()</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">S::time_point</code>
+ 
+ </td>
+<td>
+ 
+ starts a Stopwatch.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">s.suspend()</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">S::duration</code>
+ 
+ </td>
+<td>
+ 
+ stops a Stopwatch.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">s.elapsed()</code>
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">S::duration</code>
+ 
+ </td>
+<td>
+ 
+ the elapsed time while the Stopwatch was running.
+ 
+ </td>
+</tr>
+</tbody>
+</table>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_chrono.reference.stopwatches.stopwatch_hpp"></a><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_hpp" title="
+ Header <boost/chrono/stopwatch.hpp>">
+ Header <code class="computeroutput"><boost/chrono/stopwatch.hpp></code></a>
+</h4></div></div></div>
+<div class="toc"><dl>
+<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_hpp.template_class__stopwatch___">Template
+ Class <code class="computeroutput">stopwatch<></code></a></dt>
+<dt>stopwatch useful typedefs</dt>
+</dl></div>
+<pre class="programlisting">namespace boost { namespace chrono {
+ struct dont_start_t;
+ static const dont_start_t dont_start;
+
+ template <class Clock=high_resolution_clock> class stopwatch;
+
+ typedef <see above> system_stopwatch;
+ #ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
+ typedef <see above> monotonic_stopwatch;
+ #endif
+ typedef <see above> high_resolution_stopwatch;
+ typedef <see above> process_real_cpu_stopwatch;
+ typedef <see above> process_user_cpu_stopwatch;
+ typedef <see above> process_system_cpu_stopwatch;
+}}
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.stopwatches.stopwatch_hpp.template_class__stopwatch___"></a><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_hpp.template_class__stopwatch___" title="Template
+ Class stopwatch<>">Template
+ Class <code class="computeroutput">stopwatch<></code></a>
+</h5></div></div></div>
+
+ <code class="computeroutput">stopwatch<></code>
+ is a model of a <code class="computeroutput">Stopwatch</code>.
+ 
+
+ Knowing how long a part of a program takes to execute is useful in both
+ test and production environments. A <code class="computeroutput">stopwatch</code>
+ object measures elapsed time. It is recommended to use it with clocks
+ that measure wall clock rather than CPU time since the intended use is
+ performance measurement on systems where total elapsed time is more important
+ than just process or CPU time.
+ 
+
+ The maximum measurable elapsed time depends on the Clock parameter. The
+ accuracy of timings depends on the accuracy of timing information provided
+ the Clock, and this coudl varies a great deal from one clock to another.
+ 
+<pre class="programlisting">template <class Clock> class stopwatch {
+public:
+ typedef Clock clock;
+ typedef typename Clock::duration duration;
+ typedef typename Clock::time_point time_point;
+
+ explicit stopwatch( system::error_code & ec = system::throws );
+ explicit stopwatch( const dont_start_t& t );
+
+ ~timer();
+
+ time_point start( system::error_code & ec = system::throws );
+ duration stop( system::error_code & ec = system::throws );
+ std::pair<duration,time_point> restart( system::error_code & ec = system::throws );
+
+ duration suspend( system::error_code & ec = system::throws );
+ time_point resume( system::error_code & ec = system::throws );
+
+ duration elapsed( system::error_code & ec = system::throws );
+
+ typedef stopwatch_runner<stopwatch<Clock> > scoped_run;
+ typedef stopwatch_suspender<stopwatch<Clock> > scoped_suspend;
+ typedef stopwatch_resumer<stopwatch<Clock> > scoped_resume;
+ typedef stopwatch_reporter<stopwatch<Clock> > reporter;
+
+};
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.stopwatches.stopwatch_hpp._stopwatch__useful_typedefs"></a>stopwatch useful typedefs
+</h5></div></div></div>
+<pre class="programlisting">typedef boost::chrono::stopwatch< boost::chrono::system_clock > system_stopwatch;
+#ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
+typedef boost::chrono::stopwatch< boost::chrono::monotonic_clock > monotonic_stopwatch;
+#endif
+typedef boost::chrono::stopwatch< boost::chrono::high_resolution_clock > high_resolution_stopwatch;
+
+typedef boost::chrono::stopwatch< boost::chrono::process_real_cpu_clock > process_real_cpu_stopwatch;
+typedef boost::chrono::stopwatch< boost::chrono::process_user_cpu_clock > process_user_cpu_stopwatch;
+typedef boost::chrono::stopwatch< boost::chrono::process_system_cpu_clock > process_system_cpu_stopwatch;
+</pre>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp"></a><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp" title="
+ Header <boost/chrono/stopwatch_accumulator.hpp>">
+ Header <code class="computeroutput"><boost/chrono/stopwatch_accumulator.hpp></code></a>
+</h4></div></div></div>
+<div class="toc"><dl>
+<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.template_class__stopwatch_accumulator___">Template
+ Class <code class="computeroutput">stopwatch_accumulator<></code></a></dt>
+<dt>stopwatch_accumulator useful typedefs</dt>
+</dl></div>
+<pre class="programlisting">namespace boost { namespace chrono {
+ template <class Clock, class Accumulator> class stopwatch_accumulator;
+ typedef <see below> system_stopwatch_accumulator;
+#ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
+ typedef <see below> monotonic_stopwatch_accumulator;
+#endif
+ typedef <see below> high_resolution_stopwatch_accumulator;
+
+ typedef <see below> process_real_cpu_stopwatch_accumulator;
+ typedef <see below> process_user_cpu_stopwatch_accumulator;
+ typedef <see below> process_system_cpu_stopwatch_accumulator;
+
+}}
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.template_class__stopwatch_accumulator___"></a><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.template_class__stopwatch_accumulator___" title="Template
+ Class stopwatch_accumulator<>">Template
+ Class <code class="computeroutput">stopwatch_accumulator<></code></a>
+</h5></div></div></div>
+<div class="toc"><dl>
+<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.template_class__stopwatch_accumulator___.stopwatch_accumulator_c">
+ Constructor <code class="computeroutput">stopwatch_accumulator()</code></a></dt>
+<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.template_class__stopwatch_accumulator___.stopwatch_accumulator_start">
+ Member function<code class="computeroutput">start()</code></a></dt>
+<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.template_class__stopwatch_accumulator___.stopwatch_accumulator_stop">
+ Member function<code class="computeroutput">stop()</code></a></dt>
+<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.template_class__stopwatch_accumulator___.stopwatch_accumulator_suspend">
+ Member function<code class="computeroutput">suspend()</code></a></dt>
+<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.template_class__stopwatch_accumulator___.stopwatch_accumulator_resume">
+ Member function<code class="computeroutput">resume()</code></a></dt>
+<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.template_class__stopwatch_accumulator___.stopwatch_accumulator_restart">
+ Member function<code class="computeroutput">restart()</code></a></dt>
+<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.template_class__stopwatch_accumulator___.stopwatch_accumulator_reset">
+ Member function<code class="computeroutput">reset()</code></a></dt>
+<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.template_class__stopwatch_accumulator___.stopwatch_accumulator_elapsed">
+ Member function<code class="computeroutput">elapsed()</code></a></dt>
+<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.template_class__stopwatch_accumulator___.stopwatch_accumulator_accumulated">
+ Member function<code class="computeroutput">accumulated()</code></a></dt>
+</dl></div>
+
+ A <code class="computeroutput">stopwatch_accumulator<></code> is a model of a Stopwatch that
+ allows to accumulate the time in several times instead of at once as
+ it is the case of the class <code class="computeroutput">stopwatch<></code>.
+ 
+<pre class="programlisting">template <class Clock> class stopwatch_accumulator {
+public:
+ typedef Clock clock;
+ typedef typename Clock::duration duration;
+ typedef typename Clock::time_point time_point;
+ typedef Accumulator accumulator;
+
+ stopwatch_accumulator();
+
+ time_point start( system::error_code & ec = system::throws );
+ duration stop( system::error_code & ec = system::throws );
+ std::pair<duration,time_point> restart( system::error_code & ec = system::throws );
+
+ duration suspend( system::error_code & ec = system::throws );
+ time_point resume( system::error_code & ec = system::throws );
+
+ duration elapsed(system::error_code & ec = system::throws);
+
+ accumulator& accumulated( );
+ void reset();
+
+ typedef stopwatch_runner<stopwatch_accumulator<Clock> > scoped_run;
+ typedef stopwatch_suspender<stopwatch_accumulator<Clock> > scoped_suspend;
+ typedef stopwatch_resumer<stopwatch_accumulator<Clock> > scoped_resume;
+ typedef stopwatch_reporter<stopwatch_accumulator<Clock> > reporter;
+};
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.template_class__stopwatch_accumulator___.stopwatch_accumulator_c"></a><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.template_class__stopwatch_accumulator___.stopwatch_accumulator_c" title="
+ Constructor stopwatch_accumulator()">
+ Constructor <code class="computeroutput">stopwatch_accumulator()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">stopwatch_accumulator();
+</pre>
+
+ Effect: Initialize the elapsed duration
+ and the times counter to 0.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.template_class__stopwatch_accumulator___.stopwatch_accumulator_start"></a><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.template_class__stopwatch_accumulator___.stopwatch_accumulator_start" title="
+ Member functionstart()">
+ Member function<code class="computeroutput">start()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">time_point start( system::error_code & ec = system::throws );
+</pre>
+
+ Effect: Starts running the stopwatch.
+ 
+
+ Returns: the starting time point.
+ 
+
+ Throw: Any exception the Clock::now
+ function can throw.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.template_class__stopwatch_accumulator___.stopwatch_accumulator_stop"></a><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.template_class__stopwatch_accumulator___.stopwatch_accumulator_stop" title="
+ Member functionstop()">
+ Member function<code class="computeroutput">stop()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">duration stop( system::error_code & ec = system::throws );
+</pre>
+
+ Effect: Stops running the stopwatch.
+ Accumulates the elapsed time since the last start-like operation +
+ the partial accumulated by resume/suspend operation.
+ 
+
+ Returns: The cummulated elapsed time.
+ 
+
+ Throw: Any exception the Clock::now
+ function can throw.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.template_class__stopwatch_accumulator___.stopwatch_accumulator_suspend"></a><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.template_class__stopwatch_accumulator___.stopwatch_accumulator_suspend" title="
+ Member functionsuspend()">
+ Member function<code class="computeroutput">suspend()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">duration suspend( system::error_code & ec = system::throws );
+</pre>
+
+ Effect: Suspends the stopwatch. Accumulates
+ the elapsed time since the last start-like operation on a partial duration.
+ 
+
+ Throw: Any exception the Clock::now
+ function can throw.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.template_class__stopwatch_accumulator___.stopwatch_accumulator_resume"></a><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.template_class__stopwatch_accumulator___.stopwatch_accumulator_resume" title="
+ Member functionresume()">
+ Member function<code class="computeroutput">resume()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">time_point resume( system::error_code & ec = system::throws );
+</pre>
+
+ Effect: Resumes the stopwatch.
+ 
+
+ Returns: the starting time point.
+ 
+
+ Throw: Any exception the Clock::now
+ function can throw.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.template_class__stopwatch_accumulator___.stopwatch_accumulator_restart"></a><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.template_class__stopwatch_accumulator___.stopwatch_accumulator_restart" title="
+ Member functionrestart()">
+ Member function<code class="computeroutput">restart()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">time_point restart( system::error_code & ec = system::throws );
+</pre>
+
+ Effect: Stop/Start the stopwatch.
+ 
+
+ Returns: the starting time point.
+ 
+
+ Throw: Any exception the Clock::now
+ function can throw.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.template_class__stopwatch_accumulator___.stopwatch_accumulator_reset"></a><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.template_class__stopwatch_accumulator___.stopwatch_accumulator_reset" title="
+ Member functionreset()">
+ Member function<code class="computeroutput">reset()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">void reset( );
+</pre>
+
+ Effect: Stop the stopwatch and reset
+ the accumulator.
+ 
+
+ Throw: Nothing.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.template_class__stopwatch_accumulator___.stopwatch_accumulator_elapsed"></a><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.template_class__stopwatch_accumulator___.stopwatch_accumulator_elapsed" title="
+ Member functionelapsed()">
+ Member function<code class="computeroutput">elapsed()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">duration elapsed(system::error_code & ec = system::throws) const;
+</pre>
+
+ Returns: the cumulated elapsed time.
+ 
+
+ Throw: Nothing.
+ 
+
+ Note: the system::error_code &
+ parameter is here to conform to the Timer concept.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.template_class__stopwatch_accumulator___.stopwatch_accumulator_accumulated"></a><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.template_class__stopwatch_accumulator___.stopwatch_accumulator_accumulated" title="
+ Member functionaccumulated()">
+ Member function<code class="computeroutput">accumulated()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">accumulator& accumulated();
+</pre>
+
+ Returns: the assocaited accumulator.
+ 
+
+ Throw: Nothing.
+ 
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp._stopwatch_accumulator__useful_typedefs"></a>stopwatch_accumulator useful typedefs
+</h5></div></div></div>
+<pre class="programlisting">typedef boost::chrono::stopwatch_accumulator< boost::chrono::system_clock > system_stopwatch_accumulator;
+</pre>
+
+ typedef boost::chrono::stopwatch_accumulator< boost::chrono::system_clock
+ > system_stopwatch_accumulator; #ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
+ typedef boost::chrono::stopwatch_accumulator< boost::chrono::monotonic_clock
+ > monotonic_stopwatch_accumulator; #endif typedef boost::chrono::stopwatch_accumulator<
+ boost::chrono::high_resolution_clock > high_resolution_stopwatch_accumulator;
+ 
+<pre class="programlisting">typedef boost::chrono::stopwatch_accumulator< boost::chrono::process_real_cpu_clock > process_real_cpu_stopwatch_accumulator;
+typedef boost::chrono::stopwatch_accumulator< boost::chrono::process_user_cpu_clock > process_user_cpu_stopwatch_accumulator;
+typedef boost::chrono::stopwatch_accumulator< boost::chrono::process_system_cpu_clock > process_system_cpu_stopwatch_accumulator;
+</pre>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_chrono.reference.stopwatches.stopwatch_scoped_hpp"></a><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_scoped_hpp" title="
+ Header <boost/chrono/stopwatch_scoped.hpp>">
+ Header <code class="computeroutput"><boost/chrono/stopwatch_scoped.hpp></code></a>
+</h4></div></div></div>
+<div class="toc"><dl>
+<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_scoped_hpp.template_class__stopwatch_runner___">Template
+ Class <code class="computeroutput">stopwatch_runner<></code></a></dt>
+<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_scoped_hpp.template_class__stopwatch_suspender___">Template
+ Class <code class="computeroutput">stopwatch_suspender<></code></a></dt>
+<dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_scoped_hpp.template_class__stopwatch_resumer___">Template
+ Class <code class="computeroutput">stopwatch_resumer<></code></a></dt>
+</dl></div>
+<pre class="programlisting">namespace boost { namespace chrono {
+ template <class Clock> class stopwatch_runner;
+ template <class Clock> class stopwatch_suspender;
+ template <class Clock> class stopwatch_resumer;
+}}
+</pre>
+
+ Boost.Chrono provides some helper classes ensuring pairwised operations
+ (start/stop, suspend/resume, resule/suspend).
+ 
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.stopwatches.stopwatch_scoped_hpp.template_class__stopwatch_runner___"></a><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_scoped_hpp.template_class__stopwatch_runner___" title="Template
+ Class stopwatch_runner<>">Template
+ Class <code class="computeroutput">stopwatch_runner<></code></a>
+</h5></div></div></div>
+
+ This helper class ensures that the start/stop are pairwised. Start the
+ associated accumulator at construction time, and stop it at destruction
+ time.
+ 
+<pre class="programlisting">template <class Stopwatch> class stopwatch_runner {
+public:
+ typedef Stopwatch stopwatch_type;
+ stopwatch_runner(stopwatch_type & a, system::error_code & ec = system::throws);
+ ~stopwatch_runner();
+ stopwatch_runner() = delete;
+ stopwatch_runner(const stopwatch_runner&) = delete;
+ stopwatch_runner& operator=(const stopwatch_runner&) = delete;
+};
+</pre>
+
+ Usage
+ 
+<pre class="programlisting">void f1()
+{
+ static stopwatch_accumulator<> t;
+ stopwatch_runner<stopwatch_accumulator<> > _(t);
+ // ...
+}
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.stopwatches.stopwatch_scoped_hpp.template_class__stopwatch_suspender___"></a><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_scoped_hpp.template_class__stopwatch_suspender___" title="Template
+ Class stopwatch_suspender<>">Template
+ Class <code class="computeroutput">stopwatch_suspender<></code></a>
+</h5></div></div></div>
+
+ This helper class ensures that the suspend/resume are pairwised. Suspend
+ the associated accumulator at construction time, and resume it at destruction
+ time.
+ 
+<pre class="programlisting">template <class Stopwatch> class stopwatch_suspender {
+public:
+ typedef Stopwatch stopwatch_type;
+ stopwatch_suspender(stopwatch_type & a, system::error_code & ec = system::throws);
+ ~stopwatch_suspender();
+ stopwatch_suspender() = delete;
+ stopwatch_suspender(const stopwatch_suspender&) = delete;
+ stopwatch_suspender& operator=(const stopwatch_suspender&) = delete;
+}
+</pre>
+
+ Usage
+ 
+<pre class="programlisting">void f1()
+{
+ static stopwatch_accumulator<> t;
+ stopwatch_runner<stopwatch_accumulator<> > _(t);
+ // ...
+
+ // call to some function we don't want to measure
+ {
+ stopwatch_suspender<stopwatch_accumulator<> > _(t);
+ external_function();
+ }
+}
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.stopwatches.stopwatch_scoped_hpp.template_class__stopwatch_resumer___"></a><a href="stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_scoped_hpp.template_class__stopwatch_resumer___" title="Template
+ Class stopwatch_resumer<>">Template
+ Class <code class="computeroutput">stopwatch_resumer<></code></a>
+</h5></div></div></div>
+
+ This helper class ensures that the resume/suspend are pairwised. Resume
+ the associated accumulator at construction time, and suspecd it at destruction
+ time.
+ 
+<pre class="programlisting">template <class Stopwatch> class stopwatch_resumer {
+public:
+ typedef Stopwatch stopwatch_type;
+ stopwatch_resumer(stopwatch_type & a, system::error_code & ec = system::throws);
+ ~stopwatch_resumer();
+ stopwatch_resumer() = delete;
+ stopwatch_resumer(const stopwatch_resumer&) = delete;
+ stopwatch_resumer& operator=(const stopwatch_resumer&) = delete;
+}
+</pre>
+
+ Usage
+ 
+<pre class="programlisting">void f1()
+{
+ static stopwatch_accumulator<> t;
+ stopwatch_runner<stopwatch_accumulator<> > _(t);
+ // ...
+
+ // call to some function we don't want to measure
+ {
+ stopwatch_suspender<stopwatch_accumulator<> > _(t);
+
+ {
+ stopwatch_resumer<stopwatch_accumulator<> > _(t);
+
+ }
+ }
+}
+</pre>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_chrono.reference.stopwatches.process_stopwatches_hpp"></a><a href="stopwatches.html#boost_chrono.reference.stopwatches.process_stopwatches_hpp" title="
+ Header <boost/chrono/process_stopwatches.hpp>">
+ Header <code class="computeroutput"><boost/chrono/process_stopwatches.hpp></code></a>
+</h4></div></div></div>
+<div class="toc"><dl><dt><a href="stopwatches.html#boost_chrono.reference.stopwatches.process_stopwatches_hpp.class__process_stopwatches_">Class
+ <code class="computeroutput">process_stopwatches</code></a></dt></dl></div>
+<pre class="programlisting">namespace boost { namespace chrono {
+
+ class process_stopwatches;
+
+} }
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.stopwatches.process_stopwatches_hpp.class__process_stopwatches_"></a><a href="stopwatches.html#boost_chrono.reference.stopwatches.process_stopwatches_hpp.class__process_stopwatches_" title="Class
+ process_stopwatches">Class
+ <code class="computeroutput">process_stopwatches</code></a>
+</h5></div></div></div>
+
+ Knowing how long a program takes to execute is useful in both test and
+ production environments. It is also helpful if such timing information
+ is broken down into real (wall clock) time, CPU time spent by the user,
+ and CPU time spent by the operating system servicing user requests.
+ 
+
+ <code class="computeroutput">process_stopwatches</code> is
+ the <code class="computeroutput">stopwatches<></code>
+ equivalent associated to the pseudo-clock <code class="computeroutput">process_clocks</code>.
+ It behaves like <code class="computeroutput">stopwatches<></code> but it uses the specific <code class="computeroutput">process_clocks:now()</code>
+ function.
+ 
+<pre class="programlisting">class process_stopwatches {
+public:
+ typedef process_clocks clock;
+ typedef process_clocks::duration duration;
+ typedef process_clocks::time_point time_point;
+
+ explicit process_stopwatches( system::error_code & ec = system::throws );
+
+ ~process_stopwatches();
+ void start( system::error_code & ec = system::throws );
+ void elapsed( process_clocks::durations & times, system::error_code & ec = system::throws );
+};
+</pre>
+</div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 Howard Hinnant Copyright © 2006 , 2008 Beman Dawes Copyright © 2009 Vicente J. Botet Escriba
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="process_cpu_related.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="stopwatch_reporters.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide/getting_started.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide/getting_started.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide/getting_started.html 2009-12-21 11:56:04 EST (Mon, 21 Dec 2009)
@@ -39,7 +39,7 @@
 Installing Chrono</a>
</h4></div></div></div>
<a name="boost_chrono.users_guide.getting_started.install.getting__emphasis_role__bold__boost_chrono__emphasis__"></a><h5>
-<a name="id4816278"></a>
+<a name="id4817069"></a>
 <a href="getting_started.html#boost_chrono.users_guide.getting_started.install.getting__emphasis_role__bold__boost_chrono__emphasis__">Getting
 Boost.Chrono </a>
 </h5>
@@ -53,7 +53,7 @@
 Sandbox</a>.
 
<a name="boost_chrono.users_guide.getting_started.install.where_to_install__emphasis_role__bold__boost_chrono__emphasis___"></a><h5>
-<a name="id4816338"></a>
+<a name="id4817130"></a>
 <a href="getting_started.html#boost_chrono.users_guide.getting_started.install.where_to_install__emphasis_role__bold__boost_chrono__emphasis___">Where
 to install Boost.Chrono? </a>
 </h5>
@@ -69,7 +69,7 @@
 variable. Any help is welcome.
 
<a name="boost_chrono.users_guide.getting_started.install.building__emphasis_role__bold__boost_chrono__emphasis__"></a><h5>
-<a name="id4816381"></a>
+<a name="id4817172"></a>
 <a href="getting_started.html#boost_chrono.users_guide.getting_started.install.building__emphasis_role__bold__boost_chrono__emphasis__">Building
 Boost.Chrono </a>
 </h5>
@@ -80,7 +80,7 @@
<pre class="programlisting">bjam libs/chrono/build
</pre>
<a name="boost_chrono.users_guide.getting_started.install.requirements"></a><h5>
-<a name="id4816449"></a>
+<a name="id4817240"></a>
 <a href="getting_started.html#boost_chrono.users_guide.getting_started.install.requirements">Requirements</a>
 </h5>

@@ -125,7 +125,7 @@
</dl>
</div>
<a name="boost_chrono.users_guide.getting_started.install.building_an_executable_that_uses__emphasis_role__bold__boost_chrono__emphasis__"></a><h5>
-<a name="id4816630"></a>
+<a name="id4817421"></a>
 <a href="getting_started.html#boost_chrono.users_guide.getting_started.install.building_an_executable_that_uses__emphasis_role__bold__boost_chrono__emphasis__">Building
 an executable that uses Boost.Chrono
 </a>
@@ -135,7 +135,7 @@
 with the Boost System library.
 
<a name="boost_chrono.users_guide.getting_started.install.exceptions_safety_"></a><h5>
-<a name="id4816666"></a>
+<a name="id4817457"></a>
 <a href="getting_started.html#boost_chrono.users_guide.getting_started.install.exceptions_safety_">Exceptions
 safety </a>
 </h5>
@@ -144,7 +144,7 @@
 of exception safety as long as the underlying parameters provide it.
 
<a name="boost_chrono.users_guide.getting_started.install.thread_safety_"></a><h5>
-<a name="id4816692"></a>
+<a name="id4817483"></a>
 <a href="getting_started.html#boost_chrono.users_guide.getting_started.install.thread_safety_">Thread
 safety </a>
 </h5>
@@ -152,7 +152,7 @@
 All functions in the library are thread-unsafe except when noted explicitly.
 
<a name="boost_chrono.users_guide.getting_started.install.tested_compilers_"></a><h5>
-<a name="id4816717"></a>
+<a name="id4817508"></a>
 <a href="getting_started.html#boost_chrono.users_guide.getting_started.install.tested_compilers_">Tested
 compilers </a>
 </h5>
@@ -218,17 +218,17 @@

// add this in the scope you want to time,
// at the point you want the timer to start.
-boost::chrono::run_timer rt;
+boost::chrono::process_stopwatches_reporter rt;
</pre>

- Here is a complete program (run_timer_example.cpp):
+ Here is a complete program (process_stopwatches_reporter_example.cpp):
 
<pre class="programlisting">#include <boost/chrono/process_times.hpp>
#include <cmath>

int main()
{
- boost::chrono::run_timer t;
+ boost::chrono::process_stopwatches_reporter t;

 for ( long i = 0; i < 10000000; ++i )
 std::sqrt( 123.456L ); // burn some time

Modified: sandbox/chrono/libs/chrono/doc/html/index.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/index.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/index.html 2009-12-21 11:56:04 EST (Mon, 21 Dec 2009)
@@ -62,11 +62,15 @@
</dl></dd>
<dt> Reference </dt>
<dd><dl>
-<dt> Header <boost/type_traits/common_type.hpp></dt>
-<dt> Header <boost/ratio.hpp></dt>
-<dt> Header <boost/chrono.hpp></dt>
-<dt> Header <boost/chrono/timer.hpp></dt>
-<dt> Header <boost/chrono/process_times.hpp></dt>
+<dt><a href="boost_chrono/reference/cpp0x.html"> Included on the C++0x
+ recommendation</a></dt>
+<dt><a href="boost_chrono/reference/process_cpu_related.html">Process CPU
+ related</a></dt>
+<dt>Stopwatches</dt>
+<dt><a href="boost_chrono/reference/stopwatch_reporters.html">Stopwatch
+ Reporters</a></dt>
+<dt><a href="boost_chrono/reference/deprecated_headers.html">Deprecated
+ Headers</a></dt>
</dl></dd>
<dt>Examples</dt>
<dd><dl>
@@ -85,8 +89,8 @@
Hinnant's original demonstration program</a></dt>
<dt><a href="boost_chrono/examples/a_tiny_program_that_times_how_long_until_a_key_is_struck.html">A
tiny program that times how long until a key is struck</a></dt>
-<dt>run_timer_example.cpp</dt>
-<dt>run_timer_example2.cpp</dt>
+<dt>process_stopwatches_reporter_example.cpp</dt>
+<dt>process_stopwatches_reporter_example2.cpp</dt>
<dt>time command</dt>
</dl></dd>
<dt>Appendices</dt>
@@ -116,7 +120,7 @@
</table></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left">Last revised: December 13, 2009 at 22:03:26 GMT</td>
+<td align="left">Last revised: December 21, 2009 at 12:50:52 GMT</td>
<td align="right"><div class="copyright-footer"></div></td>
</tr></table>
<hr>

Modified: sandbox/chrono/libs/chrono/doc/html/standalone_HTML.manifest
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/standalone_HTML.manifest (original)
+++ sandbox/chrono/libs/chrono/doc/html/standalone_HTML.manifest 2009-12-21 11:56:04 EST (Mon, 21 Dec 2009)
@@ -7,11 +7,11 @@
boost_chrono/users_guide/tutorial.html
boost_chrono/users_guide/ext_references.html
boost_chrono/reference.html
-boost_chrono/reference/common_type_hpp.html
-boost_chrono/reference/ratio_hpp.html
-boost_chrono/reference/chrono_hpp.html
-boost_chrono/reference/timer_hpp.html
-boost_chrono/reference/process_times_hpp.html
+boost_chrono/reference/cpp0x.html
+boost_chrono/reference/process_cpu_related.html
+boost_chrono/reference/stopwatches.html
+boost_chrono/reference/stopwatch_reporters.html
+boost_chrono/reference/deprecated_headers.html
boost_chrono/examples.html
boost_chrono/examples/si_units.html
boost_chrono/examples/how_you_override_the_duration_s_default_constructor.html
@@ -24,8 +24,8 @@
boost_chrono/examples/saturating.html
boost_chrono/examples/howard_hinnant_s_original_demonstration_program.html
boost_chrono/examples/a_tiny_program_that_times_how_long_until_a_key_is_struck.html
-boost_chrono/examples/run_timer_example_cpp.html
-boost_chrono/examples/run_timer_example2_cpp.html
+boost_chrono/examples/process_stopwatches_reporter_example_cpp.html
+boost_chrono/examples/process_stopwatches_reporter_example2_cpp.html
boost_chrono/examples/time_command.html
boost_chrono/appendices.html
boost_chrono/appendices/history.html

Added: sandbox/chrono/libs/chrono/example/stopwatch_example.cpp
==============================================================================
--- (empty file)
+++ sandbox/chrono/libs/chrono/example/stopwatch_example.cpp 2009-12-21 11:56:04 EST (Mon, 21 Dec 2009)
@@ -0,0 +1,51 @@
+// run_timer_example.cpp ---------------------------------------------------//
+
+// Copyright Beman Dawes 2006, 2008
+
+// 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 <iostream>
+#include <boost/chrono/process_times.hpp>
+#include <boost/chrono/stopwatch.hpp>
+#include <boost/chrono/stopwatch_accumulator.hpp>
+#include <boost/chrono/cpu_clocks.hpp>
+#include <cmath>
+
+//#include <boost/accumulators/framework/accumulator_set.hpp>
+#include <boost/accumulators/accumulators.hpp>
+#include <boost/accumulators/statistics.hpp>
+#include <boost/accumulators/statistics/stats.hpp>
+#include <boost/accumulators/statistics/sum.hpp>
+#include <boost/accumulators/statistics/min.hpp>
+#include <boost/accumulators/statistics/max.hpp>
+#include <boost/accumulators/statistics/mean.hpp>
+#include <boost/accumulators/statistics/weighted_sum.hpp>
+
+int f1(long j)
+{
+ static boost::chrono::stopwatch_accumulator<boost::chrono::process_real_cpu_clock>::reporter t(
+ "\nf1 Count=%c times Sum=%ss Min=%ms Max=%Ms Mean=%as\n");
+ boost::chrono::stopwatch_accumulator<boost::chrono::process_real_cpu_clock>::reporter::scoped_run _(t);
+ boost::chrono::stopwatch<boost::chrono::process_real_cpu_clock>::reporter x("\nF1 %dsec\n");
+ boost::chrono::run_timer y;
+
+
+ for ( long i = 0; i < j; ++i )
+ std::sqrt( 123.456L ); // burn some time
+
+ return 0;
+}
+int main()
+{
+ boost::chrono::stopwatch<boost::chrono::process_real_cpu_clock>::reporter _("\nMain %dsec\n");
+ boost::chrono::run_timer z;
+
+
+ f1(100000);
+ f1(200000);
+ f1(300000);
+ return 0;
+}

Modified: sandbox/chrono/libs/chrono/src/mac/process_clock.cpp
==============================================================================
--- sandbox/chrono/libs/chrono/src/mac/process_clock.cpp (original)
+++ sandbox/chrono/libs/chrono/src/mac/process_clock.cpp 2009-12-21 11:56:04 EST (Mon, 21 Dec 2009)
@@ -1,6 +1,7 @@
// boost process_timer.cpp -----------------------------------------------------------//

// Copyright Beman Dawes 1994, 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
@@ -50,7 +51,7 @@
   namespace chrono
   {

- void process_clock::now( process_times & times_, system::error_code & ec )
+ void process_clocks::now( process_times & times_, system::error_code & ec )
     {

       tms tm;

Modified: sandbox/chrono/libs/chrono/src/posix/process_clock.cpp
==============================================================================
--- sandbox/chrono/libs/chrono/src/posix/process_clock.cpp (original)
+++ sandbox/chrono/libs/chrono/src/posix/process_clock.cpp 2009-12-21 11:56:04 EST (Mon, 21 Dec 2009)
@@ -44,7 +44,7 @@

namespace boost { namespace chrono {

- void process_clock::now( process_times & times_, system::error_code & ec ) {
+ void process_clocks::now( process_times & times_, system::error_code & ec ) {

tms tm;
clock_t c = ::times( &tm );

Modified: sandbox/chrono/libs/chrono/src/process_clock.cpp
==============================================================================
--- sandbox/chrono/libs/chrono/src/process_clock.cpp (original)
+++ sandbox/chrono/libs/chrono/src/process_clock.cpp 2009-12-21 11:56:04 EST (Mon, 21 Dec 2009)
@@ -1,6 +1,7 @@
// boost process_timer.cpp -----------------------------------------------------------//

// Copyright Beman Dawes 1994, 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
@@ -36,5 +37,15 @@
#include "posix/process_clock.cpp"

#endif // POSIX
+namespace boost { namespace chrono {

+ void process_clocks::now( time_points & tps, system::error_code & ec ) {
+ process_times t;
+ process_clock::now(t,ec);
+ tps.real=process_clock::time_point(t.real);
+ tps.user=process_clock::time_point(t.user);
+ tps.system=process_clock::time_point(t.system);
+
+ }

+}}

Modified: sandbox/chrono/libs/chrono/src/run_timer.cpp
==============================================================================
--- sandbox/chrono/libs/chrono/src/run_timer.cpp (original)
+++ sandbox/chrono/libs/chrono/src/run_timer.cpp 2009-12-21 11:56:04 EST (Mon, 21 Dec 2009)
@@ -1,6 +1,7 @@
-// boost run_timer.cpp ---------------------------------------------------------------//
+// boost process_stopwatches_reporter.cpp ---------------------------------------------------------------//

// Copyright Beman Dawes 1994, 2006, 2008
+// Copyright 2009-2010 Vicente J. Botet Escriba

// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
@@ -92,43 +93,43 @@
   {


- run_timer::run_timer( system::error_code & ec )
+ process_stopwatches_reporter::process_stopwatches_reporter( system::error_code & ec )
         : m_places(m_default_places), m_os(m_cout()) { start(ec); }
- run_timer::run_timer( std::ostream & os,
+ process_stopwatches_reporter::process_stopwatches_reporter( std::ostream & os,
         system::error_code & ec )
         : m_places(m_default_places), m_os(os) { start(ec); }

- run_timer::run_timer( const std::string & format,
+ process_stopwatches_reporter::process_stopwatches_reporter( const std::string & format,
         system::error_code & ec )
         : m_places(m_default_places), m_os(m_cout()), m_format(format) { start(ec); }
- run_timer::run_timer( std::ostream & os, const std::string & format,
+ process_stopwatches_reporter::process_stopwatches_reporter( std::ostream & os, const std::string & format,
         system::error_code & ec )
         : m_places(m_default_places), m_os(os), m_format(format) { start(ec); }

- run_timer::run_timer( const std::string & format, int places,
+ process_stopwatches_reporter::process_stopwatches_reporter( const std::string & format, int places,
         system::error_code & ec )
         : m_places(places), m_os(m_cout()), m_format(format) { start(ec); }
- run_timer::run_timer( std::ostream & os, const std::string & format,
+ process_stopwatches_reporter::process_stopwatches_reporter( std::ostream & os, const std::string & format,
         int places, system::error_code & ec )
         : m_places(places), m_os(os), m_format(format) { start(ec); }

- run_timer::run_timer( int places,
+ process_stopwatches_reporter::process_stopwatches_reporter( int places,
         system::error_code & ec )
         : m_places(places), m_os(m_cout()) { start(ec); }
- run_timer::run_timer( std::ostream & os, int places,
+ process_stopwatches_reporter::process_stopwatches_reporter( std::ostream & os, int places,
         system::error_code & ec )
         : m_places(places), m_os(os) { start(ec); }

- run_timer::run_timer( int places, const std::string & format,
+ process_stopwatches_reporter::process_stopwatches_reporter( int places, const std::string & format,
         system::error_code & ec )
         : m_places(places), m_os(m_cout()), m_format(format) { start(ec); }
- run_timer::run_timer( std::ostream & os, int places, const std::string & format,
+ process_stopwatches_reporter::process_stopwatches_reporter( std::ostream & os, int places, const std::string & format,
         system::error_code & ec )
         : m_places(places), m_os(os), m_format(format) { start(ec); }

- // run_timer::report -------------------------------------------------------------//
+ // process_stopwatches_reporter::report -------------------------------------------------------------//

- void run_timer::report( system::error_code & ec )
+ void process_stopwatches_reporter::report( system::error_code & ec )
     {
       m_reported = true;
       if ( m_format.empty() ) m_format = default_format;
@@ -156,9 +157,9 @@
       }
     }

- // run_timer::test_report --------------------------------------------------------//
+ // process_stopwatches_reporter::test_report --------------------------------------------------------//

- void run_timer::test_report( duration real_, duration user_, duration system_ )
+ void process_stopwatches_reporter::test_report( duration real_, duration user_, duration system_ )
     {
       if ( m_format.empty() ) m_format = default_format;

Modified: sandbox/chrono/libs/chrono/src/run_timer_static.cpp
==============================================================================
--- sandbox/chrono/libs/chrono/src/run_timer_static.cpp (original)
+++ sandbox/chrono/libs/chrono/src/run_timer_static.cpp 2009-12-21 11:56:04 EST (Mon, 21 Dec 2009)
@@ -1,6 +1,7 @@
// boost run_timer_static.cpp --------------------------------------------------------//

// Copyright Beman Dawes 2008
+// Copyright 2009-2010 Vicente J. Botet Escriba

// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
@@ -28,7 +29,7 @@
   namespace chrono
   {

- std::ostream & run_timer::m_cout() { return std::cout; }
+ std::ostream & process_stopwatches_reporter::m_cout() { return std::cout; }

   } // namespace chrono
} // namespace boost

Modified: sandbox/chrono/libs/chrono/src/win/process_clock.cpp
==============================================================================
--- sandbox/chrono/libs/chrono/src/win/process_clock.cpp (original)
+++ sandbox/chrono/libs/chrono/src/win/process_clock.cpp 2009-12-21 11:56:04 EST (Mon, 21 Dec 2009)
@@ -1,6 +1,7 @@
// boost process_timer.cpp -----------------------------------------------------------//

// Copyright Beman Dawes 1994, 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
@@ -24,7 +25,7 @@
   namespace chrono
   {

- void process_clock::now( process_times & times_, system::error_code & ec )
+ void process_clocks::now( process_times & times_, system::error_code & ec )
     {

       // note that Windows uses 100 nanosecond ticks for FILETIME

Modified: sandbox/chrono/libs/chrono/test/Jamfile.v2
==============================================================================
--- sandbox/chrono/libs/chrono/test/Jamfile.v2 (original)
+++ sandbox/chrono/libs/chrono/test/Jamfile.v2 2009-12-21 11:56:04 EST (Mon, 21 Dec 2009)
@@ -87,3 +87,9 @@
 [ run run_timer_test.cpp : : : <library>/boost/system//boost_system : run_timer_test_dll ]
 [ run test_minmax.cpp : : : <library>/boost/system//boost_system : test_min_max_dll ]
 ;
+
+ test-suite "stopwatch"
+ :
+ [ run ../example/stopwatch_example.cpp : : : <link>static ]
+ [ run ../example/stopwatch_example.cpp : : : <library>/boost/system//boost_system : stopwatch_example_dll ]
+ ;
\ No newline at end of file

Next message: vicente.botet_at_[hidden]: "[Boost-commit] svn:boost r58481 - sandbox/chrono/boost/chrono"
Previous message: lists.drrngrvy_at_[hidden]: "[Boost-commit] svn:boost r58479 - sandbox/SOC/2007/cgi/branches/pickmeup/boost/cgi/fwd"

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk