Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r58347 - in sandbox/chrono/libs/chrono/doc: . html html/boost_chrono html/boost_chrono/appendices html/boost_chrono/overview html/boost_chrono/reference html/boost_chrono/users_guide
From: vicente.botet_at_[hidden]
Date: 2009-12-13 07:45:53

Author: viboes
Date: 2009-12-13 07:45:51 EST (Sun, 13 Dec 2009)
New Revision: 58347
URL: http://svn.boost.org/trac/boost/changeset/58347

Log:
Boost.Chrono: Version 0.2.6
* More Updated documentation

Text files modified:
   sandbox/chrono/libs/chrono/doc/chrono.qbk | 294 ++++++++++++++++++++++++++++++++++++---
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/implementation.html | 4
   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/overview/motivation.html | 105 +++++++-------
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference.html | 13 +
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/chrono_hpp.html | 42 ++++-
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/process_times_hpp.html | 257 +++++++++++++++++++++++++---------
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/timer_hpp.html | 69 +++++++--
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide/getting_started.html | 26 +-
   sandbox/chrono/libs/chrono/doc/html/index.html | 2
   11 files changed, 621 insertions(+), 203 deletions(-)

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-13 07:45:51 EST (Sun, 13 Dec 2009)
@@ -133,7 +133,7 @@

`ratio` is a general purpose utility inspired by Walter Brown allowing one to easily and safely compute rational values at compile time. The `ratio` class catches all errors (such as divide by zero and overflow) at compile time. It is used in the `duration` and `time_point` classes to efficiently create units of time. It can also be used in other "quantity" libraries (both std-defined and user-defined), or anywhere there is a rational constant which is known at compile time. The use of this utility can greatly reduce the chances of run time overflow because the `ratio` (and any ratios resulting from `ratio` arithmetic) are always reduced to lowest terms.

-`ratio` is a template taking two intmax_ts, with the second defaulted to 1. It only has two public members, both of which are static const intmax_t. One is the numerator of the `ratio` and the other is the denominator. The `ratio` is always normalized such that it is expressed in lowest terms, and the denominator is always positive. When the numerator is 0, the denominator is always 1.
+`ratio` is a template taking two intmax_ts, with the second defaulted to 1. In addition to cop^y constructors and assignement, it only has two public members, both of which are static const intmax_t. One is the numerator of the `ratio` and the other is the denominator. The `ratio` is always normalized such that it is expressed in lowest terms, and the denominator is always positive. When the numerator is 0, the denominator is always 1.

[*Example:]

@@ -141,7 +141,7 @@
 typedef ratio<25, 15> also_five_thirds; // also_five_thirds::num == 5, also_five_thirds::den == 3
 typedef ratio_divide<five_thirds, also_five_thirds>::type one; // one::num == 1, one::den == 1

-This facility also includes convenience typedefs for the SI prefixes atto through exa corresponding to their internationally recognized definitions (in terms of `ratio`). This is a tremendous syntactic convenience. It will prevent errors in specifying constants as one no longer has to double count the number of zeros when trying to write million or billion.
+This facility also includes convenience typedefs for the SI prefixes `atto` through `exa` corresponding to their internationally recognized definitions (in terms of `ratio`). This is a tremendous syntactic convenience. It will prevent errors in specifying constants as one no longer has to double count the number of zeros when trying to write million or billion.

[*Example:]

@@ -157,26 +157,26 @@

The library consists of six units of time `duration`:

-* hours
-* minutes
-* seconds
-* milliseconds
-* microseconds
-* nanoseconds
+* `hours`
+* `minutes`
+* `seconds`
+* `milliseconds`
+* `microseconds`
+* `nanoseconds`

-These units were chosen as a subset of the boost library because they are the most common units used when sleeping, waiting on a condition variable, or waiting to obtain the lock on a mutex. Each of these units is nothing but a thin wrapper around a signed integral count. That is, when you construct `minutes(3)`, all that happens is a 3 is stored inside of minutes. When you construct `microseconds(3)`, all that happens is a 3 is stored inside of microseconds.
+These units were chosen as a subset of the boost library because they are the most common units used when sleeping, waiting on a condition variable, or waiting to obtain the lock on a mutex. Each of these units is nothing but a thin wrapper around a signed integral count. That is, when you construct `minutes(3)`, all that happens is a `3` is stored inside of minutes. When you construct `microseconds(3)`, all that happens is a `3` is stored inside of microseconds.

-The only context in which these different types differ is when being converted to one another. At this time, unit-specific compile-time conversion constants are used to convert the source unit to the target unit. Only conversions from coarser units to finer units are allowed (in boost). This restriction ensures that all conversions are always exact. That is, microseconds can always represent any value minutes has.
+The only context in which these different types differ is when being converted to one another. At this time, unit-specific compile-time conversion constants are used to convert the source unit to the target unit. Only conversions from coarser units to finer units are allowed (in boost). This restriction ensures that all conversions are always exact. That is, `microseconds` can always represent any value `minutes` has.

In Boost.DateTime, these units are united via inheritance. __Boost_Chrono__ instead unites these units through the class template `duration`. That is, in __Boost_Chrono__ all six of the above units are nothing but typedefs to different instantiations of `duration`. This change from Boost.DateTime has a far reaching positive impact, while not changing the syntax of the everyday use at all.

The most immediate positive impact is that the library can immediately generate any unit, any precision it needs. This is sometimes necessary when doing comparisons or arithmetic between `duration`s of differing precision, assuming one wants the comparison and arithmetic to be exactly correct.

-A secondary benefit is that by publishing the class template `duration` interface, user code can very easily create `duration`s with any precision they desire. The `ratio` utility is used to specify the precision, so as long as the precision can be expressed by a rational constant with respect to seconds, this framework can exactly represent it (one third of a second is no problem, and neither is one third of a femto second). All of this utility and flexibility comes at no cost just by making use of the no-run-time-overhead `ratio` facility.
+A secondary benefit is that by publishing the class template `duration` interface, user code can very easily create `duration`s with any precision they desire. The `ratio` utility is used to specify the precision, so as long as the precision can be expressed by a rational constant with respect to seconds, this framework can exactly represent it (one third of a second is no problem, and neither is one third of a `femto` second). All of this utility and flexibility comes at no cost just by making use of the no-run-time-overhead `ratio` facility.

-In Boost.DateTime, hours does not have the same representation as nanoseconds. The former is usually represented with a long whereas a long long is required for the latter. The reason for this is simply range. You don't need many hours to cover an extremely large range of time. But this isn't true of nanoseconds. Being able to reduce the sizeof overhead for some units when possible, can be a significant performance advantage.
+In Boost.DateTime, `hours` does not have the same representation as `nanoseconds`. The former is usually represented with a `long` whereas a `long long` is required for the latter. The reason for this is simply range. You don't need many hours to cover an extremely large range of time. But this isn't true of nanoseconds. Being able to reduce the sizeof overhead for some units when possible, can be a significant performance advantage.

-__Boost_Chrono__ continues, and generalizes that philosophy. Not only can one specify the precision of a `duration`, one can also specify its representation. This can be any integral type, or even a floating point type. Or it can be a user-defined type which emulates an arithmetic type. The six predefined units all use signed integral types as their representation. And they all have a minimum range of +/- 292 years. nanoseconds needs 64 bits to cover that range. hours needs only 23 bits to cover that range.
+__Boost_Chrono__ continues, and generalizes that philosophy. Not only can one specify the precision of a `duration`, one can also specify its representation. This can be any integral type, or even a floating point type. Or it can be a user-defined type which emulates an arithmetic type. The six predefined units all use signed integral types as their representation. And they all have a minimum range of +/- 292 years. `nanoseconds` needs 64 bits to cover that range. `hours` needs only 23 bits to cover that range.

[heading So What Exactly is a `duration` and How Do I Use One?]

@@ -208,7 +208,7 @@

These `duration`s have very simple, very predictable, and very observable behavior. After all, this is really nothing but the time tested interface of Jeff's boost time `duration` library (unified with templates instead of inheritance).

-[heading What happens if I assign `m3 + us3` to minutes instead of microseconds?]
+[heading What happens if I assign `m3 + us3` to `minutes` instead of `microseconds`?]

 minutes m4 = m3 + us3;

@@ -445,7 +445,7 @@

The simple way is to decompress (or checkout from SVN) the file in your BOOST_ROOT directory.

-Othesewise, if you decompress in another directory, you will need to comment some lines, and uncomment and change others in the build/Jamfile and test/Jamfile. Sorry for this, but I have not reached yet to write a Jamfile that is able to work in both environements and use the BOOST_ROOT variable. Any help is welcome.
+Othesewise, if you decompress in a different directory, you will need to comment some lines, and uncomment and change others in the build/Jamfile and test/Jamfile. Sorry for this, but I have not reached yet to write a Jamfile that is able to work in both environements and use the BOOST_ROOT variable. Any help is welcome.

[/=================================]
[heading Building __Boost_Chrono__ ]
@@ -1703,6 +1703,7 @@

[section Class `system_clock`]

+The `system_clock` 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 `system_clock::now()`. Instances of `system_clock::time_point` can be converted to and from time_t with the `system_clock::to_time_t()` and `system_clock::to_time_point()` functions. If system clock is not monotonic, a subsequent call to `system_clock::now()` 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).

 class system_clock {
 public:
@@ -1710,7 +1711,7 @@
 typedef duration::rep rep;
 typedef duration::period period;
 typedef chrono::time_point<system_clock> time_point;
- static const bool is_monotonic = <unspecified>;
+ static const bool is_monotonic = false;

 static time_point now(); // throws on error
 static time_point now(system::error_code & ec); // never throws
@@ -1719,17 +1720,19 @@
 static time_point from_time_t(std::time_t t);
 };

-`system_clock::duration::min() < system_clock::duration::zero()` shall be `true`.
+`system_clock` satisfy the Clock Requirements. In addition:

+* `system_clock::duration::min() < system_clock::duration::zero()` is `true`.

-[section:to_time_t Non-Member function `to_time_t(time_point)`]
+
+[section:to_time_t Static member function `to_time_t(time_point)`]

time_t to_time_t(const time_point& t);

[*Returns:] A `time_t` such that the `time_t` and `t` represent the same point in time, truncated to the courser of the precisions among `time_t` and `t`.

[endsect]
-[section:from_time_t Non-Member function `from_time_t(time_t)`]
+[section:from_time_t Static member function `from_time_t(time_t)`]

 time_point from_time_t(time_t t);

@@ -1742,6 +1745,8 @@

`monotonic_clock` satisfy the Clock Requirements.

+`monotonic_clock` class provides access to the system-wide monotonic clock. The current time can be obtained by calling `monotonic_clock::now()`. There is no fixed relationship between values returned by `monotonic_clock::now()` and wall-clock time.
+
 #ifdef BOOST_HAS_CLOCK_MONOTONIC
 class BOOST_CHRONO_DECL monotonic_clock {
 public:
@@ -1772,11 +1777,107 @@

[endsect]

+[/ comment
+[/==================================================]
+[section:cpu_clocks_hpp Header `<boost/chrono/cpu_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 {
+ class process_real_cpu_clock;
+ class process_user_cpu_clock;
+ class process_system_cpu_clock;
+ }}
+
+[section Class `process_real_cpu_clock`]
+
+`process_real_cpu_clock` satisfy the Clock Requirements.
+
+`process_real_cpu_clock` 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 `process_real_cpu_clock::now()`.
+
+ 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 );
+ };
+
+
+[endsect]
+[section Class `process_user_cpu_clock`]
+
+`process_user_cpu_clock` satisfy the Clock Requirements.
+
+`process_user_cpu_clock` 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 `process_user_cpu_clock::now()`.
+
+ 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 );
+ };
+
+
+[endsect]
+
+[section Class `process_system_cpu_clock`]
+
+`process_system_cpu_clock` satisfy the Clock Requirements.
+
+`process_system_cpu_clock` class provides access to the system CPU-time monotonic clockof the calling process. The process relative system current time can be obtained by calling `process_system_cpu_clock::now()`.
+
+ 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 );
+ };
+
+
+[endsect]
+
+
+[endsect]
+comment ]
[/==================================================]
[section:timer_hpp Header `<boost/chrono/timer.hpp>`]
[/==================================================]

+
 namespace boost { namespace chrono {
+ template <class 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;
+ }}
+
+[/
+ 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:
@@ -1793,24 +1894,130 @@

 };

+[endsect]
+
+[section `timer` useful typedefs]
+
 typedef boost::chrono::timer< boost::chrono::system_clock > system_timer;
- #ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
+ #ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
 typedef boost::chrono::timer< boost::chrono::monotonic_clock > monotonic_timer;
- #endif
+ #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:timer_hpp Header `<boost/chrono/reporting_timer.hpp>`]
+[/==================================================]
+
+ namespace boost { namespace chrono {
+ template <class Clock> class reporting_timer;
+ typedef <see above> system_reporting_timer;
+ #ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
+ typedef <see above> monotonic_reporting_timer;
+ #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;
+ }}
+
+[section Class `reporting_timer<>`]
+
+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:
+
+* 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 "\\n%ts\\n", where
+
+* `%t` : 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> {
+ public:
+ explicit reporting_timer( system::error_code & ec = system::throws );
+ explicit reporting_timer( std::ostream & os,
+ system::error_code & ec = system::throws );
+
+ explicit reporting_timer( const std::string & format,
+ system::error_code & ec = system::throws );
+ explicit reporting_timer( std::ostream & os, const std::string & format,
+ system::error_code & ec = system::throws );
+
+ explicit reporting_timer( const std::string & format, int places,
+ system::error_code & ec = system::throws );
+ explicit reporting_timer( std::ostream & os, const std::string & format, int places,
+ system::error_code & ec = system::throws );
+
+ explicit reporting_timer( int places,
+ system::error_code & ec = system::throws );
+ explicit reporting_timer( std::ostream & os, int places,
+ system::error_code & ec = system::throws );
+
+ explicit reporting_timer( int places, const std::string & format,
+ system::error_code & ec = system::throws );
+ explicit reporting_timer( std::ostream & os, int places, const std::string & format,
+ system::error_code & ec = system::throws );
+
+ ~reporting_timer();
+
+ void report( system::error_code & ec = system::throws );
+ bool reported() const;
+
+ static int default_places();
+ };

- } }

+[endsect]
+
+[section `reporting_timer` useful typedefs]
+
+ typedef boost::chrono::reporting_timer< boost::chrono::system_clock > system_reporting_timer;
+ #ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
+ typedef boost::chrono::reporting_timer< boost::chrono::monotonic_clock > monotonic_reporting_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;
+
+[endsect]

[endsect]

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

+
 namespace boost { namespace chrono {

- struct process_times;
+ class process_clock;
+ class process_timer;
+ class run_timer;
+
+ } }
+
+[section Class `process_clock`]
+
+`process_clock` doesn't satisfy the Clock Requirements as the function now do not follows the Clock prototype.
+
+`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.
+
+The process relative real, user and system current time can be obtained at once by calling `process_clock::now()`.
+

 class process_clock {
 public:
@@ -1820,16 +2027,29 @@
 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 );
 };

+[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
 };

+[endsect]
+
+[endsect]
+
+[section Class `process_timer`]
+
+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_timer<>` is the `timer<>` equivalent associated to the pseudo-clock `process_clock`. It behaves like `timer<>` but it uses the specific `process_clock:now()` function.
+
 class process_timer {
 public:
 typedef process_clock clock;
@@ -1843,9 +2063,27 @@
 void elapsed( process_times & times, system::error_code & ec = system::throws );
 };

+[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:
+
+* 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 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 );
@@ -1881,9 +2119,8 @@
 static int default_places();
 };

- } // namespace chrono
- } // namespace boost

+[endsect]

[endsect]

@@ -2894,7 +3131,7 @@
[section:history Appendix A: History]
[/==================================]

-[section [*Version 0.2.1, December 12, 2009] ['Bug fixes]]
+[section [*Version 0.2.1, December 13, 2009] ['Bug fixes]]

[*Bug Fixes]

@@ -2914,6 +3151,9 @@
* removal of conversion warning in test_duration
* manage with MSVC reporting a warning instead of an error when there is an integral constant overflow

+[*Documentation:]
+
+More updated documentation.

[endsect]

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-13 07:45:51 EST (Sun, 13 Dec 2009)
@@ -31,7 +31,7 @@
 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="id4880856"></a>
+<a name="id4882056"></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>
@@ -42,7 +42,7 @@
 dangerously.
 
<a name="boost_chrono.appendices.implementation.why_does_run_timer_sometimes_report_more_cpu_seconds_than_real_seconds_"></a><h4>
-<a name="id4880896"></a>
+<a name="id4882097"></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>
 </h4>

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-13 07:45:51 EST (Sun, 13 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="id4879701"></a>
+<a name="id4880902"></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="id4879791"></a>
+<a name="id4880992"></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="id4880370"></a>
+<a name="id4881570"></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="id4880659"></a>
+<a name="id4881859"></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-13 07:45:51 EST (Sun, 13 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="id4881491"></a>
+<a name="id4882691"></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="id4881550"></a>
+<a name="id4882750"></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/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-13 07:45:51 EST (Sun, 13 Dec 2009)
@@ -116,11 +116,13 @@
 

 <code class="computeroutput">ratio</code> is a template taking
- two intmax_ts, with the second defaulted to 1. It only has two public members,
- both of which are static const intmax_t. One is the numerator of the <code class="computeroutput">ratio</code> and the other is the denominator.
- The <code class="computeroutput">ratio</code> is always normalized
- such that it is expressed in lowest terms, and the denominator is always
- positive. When the numerator is 0, the denominator is always 1.
+ two intmax_ts, with the second defaulted to 1. In addition to cop^y constructors
+ and assignement, it only has two public members, both of which are static
+ const intmax_t. One is the numerator of the <code class="computeroutput">ratio</code>
+ and the other is the denominator. The <code class="computeroutput">ratio</code>
+ is always normalized such that it is expressed in lowest terms, and the
+ denominator is always positive. When the numerator is 0, the denominator
+ is always 1.
 

 Example:
@@ -130,12 +132,12 @@
typedef ratio_divide<five_thirds, also_five_thirds>::type one; // one::num == 1, one::den == 1
</pre>

- This facility also includes convenience typedefs for the SI prefixes atto
- through exa corresponding to their internationally recognized definitions
- (in terms of <code class="computeroutput">ratio</code>). This
- is a tremendous syntactic convenience. It will prevent errors in specifying
- constants as one no longer has to double count the number of zeros when
- trying to write million or billion.
+ This facility also includes convenience typedefs for the SI prefixes <code class="computeroutput">atto</code> through <code class="computeroutput">exa</code>
+ corresponding to their internationally recognized definitions (in terms
+ of <code class="computeroutput">ratio</code>). This is a tremendous
+ syntactic convenience. It will prevent errors in specifying constants as
+ one no longer has to double count the number of zeros when trying to write
+ million or billion.
 

 Example:
@@ -160,24 +162,12 @@
 The library consists of six units of time <code class="computeroutput">duration</code>:
 
<div class="itemizedlist"><ul type="disc">
-<li>
- hours
- </li>
-<li>
- minutes
- </li>
-<li>
- seconds
- </li>
-<li>
- milliseconds
- </li>
-<li>
- microseconds
- </li>
-<li>
- nanoseconds
- </li>
+<li><code class="computeroutput">hours</code></li>
+<li><code class="computeroutput">minutes</code></li>
+<li><code class="computeroutput">seconds</code></li>
+<li><code class="computeroutput">milliseconds</code></li>
+<li><code class="computeroutput">microseconds</code></li>
+<li><code class="computeroutput">nanoseconds</code></li>
</ul></div>

 These units were chosen as a subset of the boost library because they are
@@ -185,16 +175,19 @@
 or waiting to obtain the lock on a mutex. Each of these units is nothing
 but a thin wrapper around a signed integral count. That is, when you construct
 <code class="computeroutput">minutes(3)</code>, all that
- happens is a 3 is stored inside of minutes. When you construct <code class="computeroutput">microseconds(3)</code>, all that
- happens is a 3 is stored inside of microseconds.
+ happens is a <code class="computeroutput">3</code> is stored inside
+ of minutes. When you construct <code class="computeroutput">microseconds(3)</code>,
+ all that happens is a <code class="computeroutput">3</code> is
+ stored inside of microseconds.
 

 The only context in which these different types differ is when being converted
 to one another. At this time, unit-specific compile-time conversion constants
 are used to convert the source unit to the target unit. Only conversions
 from coarser units to finer units are allowed (in boost). This restriction
- ensures that all conversions are always exact. That is, microseconds can
- always represent any value minutes has.
+ ensures that all conversions are always exact. That is, <code class="computeroutput">microseconds</code>
+ can always represent any value <code class="computeroutput">minutes</code>
+ has.
 

 In Boost.DateTime, these units are united via inheritance. Boost.Chrono
@@ -218,16 +211,20 @@
 utility is used to specify the precision, so as long as the precision can
 be expressed by a rational constant with respect to seconds, this framework
 can exactly represent it (one third of a second is no problem, and neither
- is one third of a femto second). All of this utility and flexibility comes
- at no cost just by making use of the no-run-time-overhead <code class="computeroutput">ratio</code> facility.
+ is one third of a <code class="computeroutput">femto</code>
+ second). All of this utility and flexibility comes at no cost just by making
+ use of the no-run-time-overhead <code class="computeroutput">ratio</code>
+ facility.
 

- In Boost.DateTime, hours does not have the same representation as nanoseconds.
- The former is usually represented with a long whereas a long long is required
- for the latter. The reason for this is simply range. You don't need many
- hours to cover an extremely large range of time. But this isn't true of
- nanoseconds. Being able to reduce the sizeof overhead for some units when
- possible, can be a significant performance advantage.
+ In Boost.DateTime, <code class="computeroutput">hours</code>
+ does not have the same representation as <code class="computeroutput">nanoseconds</code>.
+ The former is usually represented with a <code class="computeroutput">long</code>
+ whereas a <code class="computeroutput">long long</code>
+ is required for the latter. The reason for this is simply range. You don't
+ need many hours to cover an extremely large range of time. But this isn't
+ true of nanoseconds. Being able to reduce the sizeof overhead for some
+ units when possible, can be a significant performance advantage.
 

 Boost.Chrono continues, and generalizes
@@ -235,11 +232,12 @@
 This can be any integral type, or even a floating point type. Or it can
 be a user-defined type which emulates an arithmetic type. The six predefined
 units all use signed integral types as their representation. And they all
- have a minimum range of +/- 292 years. nanoseconds needs 64 bits to cover
- that range. hours needs only 23 bits to cover that range.
+ have a minimum range of +/- 292 years. <code class="computeroutput">nanoseconds</code>
+ needs 64 bits to cover that range. <code class="computeroutput">hours</code>
+ 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="id4759410"></a>
+<a name="id4759345"></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>
@@ -296,11 +294,12 @@
 is really nothing but the time tested interface of Jeff's boost time <code class="computeroutput">duration</code> library (unified with templates
 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_minutes_instead_of_microseconds_"></a><h5>
-<a name="id4758314"></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_minutes_instead_of_microseconds_">What
+<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 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 minutes instead of microseconds?</a>
+ to <code class="computeroutput">minutes</code> instead of
+ <code class="computeroutput">microseconds</code>?</a>
 </h5>
<pre class="programlisting">minutes m4 = m3 + us3;
</pre>
@@ -313,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="id4813058"></a>
+<a name="id4813279"></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>
@@ -333,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="id4813194"></a>
+<a name="id4813416"></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>
@@ -348,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="id4813357"></a>
+<a name="id4813578"></a>
 <a href="motivation.html#boost_chrono.overview.motivation.duration.how_expensive_is_all_of_this_">How
 expensive is all of this?</a>
 </h5>
@@ -362,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="id4813407"></a>
+<a name="id4813628"></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>
@@ -584,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="id4815212"></a>
+<a name="id4815433"></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>

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-13 07:45:51 EST (Sun, 13 Dec 2009)
@@ -68,7 +68,20 @@
<code class="computeroutput">high_resolution_clock</code></a></dt>
</dl></dd>
<dt> Header <boost/chrono/timer.hpp></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>
+</dl></dd>
<dt> Header <boost/chrono/process_times.hpp></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>
+</dl></dd>
</dl></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/chrono_hpp.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/chrono_hpp.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/chrono_hpp.html 2009-12-13 07:45:51 EST (Sun, 13 Dec 2009)
@@ -166,9 +166,9 @@
 <code class="computeroutput">system_clock</code></a></dt>
<dd><dl>
<dt><a href="chrono_hpp.html#boost_chrono.reference.chrono_hpp.class__system_clock_.to_time_t">
- Non-Member function <code class="computeroutput">to_time_t(time_point)</code></a></dt>
+ Static member function <code class="computeroutput">to_time_t(time_point)</code></a></dt>
<dt><a href="chrono_hpp.html#boost_chrono.reference.chrono_hpp.class__system_clock_.from_time_t">
- Non-Member function <code class="computeroutput">from_time_t(time_t)</code></a></dt>
+ Static member function <code class="computeroutput">from_time_t(time_t)</code></a></dt>
</dl></dd>
<dt><a href="chrono_hpp.html#boost_chrono.reference.chrono_hpp.class__monotonic_clock_">Class
 <code class="computeroutput">monotonic_clock</code></a></dt>
@@ -320,7 +320,7 @@
 and both of these calls happen before <code class="computeroutput">C1::time_point::max()</code>.
 
<div class="table">
-<a name="id4829407"></a>Table 1. Clock Requirements
+<a name="id4829640"></a>Table 1. Clock Requirements
<table class="table" summary="Clock Requirements">
<colgroup>
<col>
@@ -1760,17 +1760,27 @@
</h4></div></div></div>
<div class="toc"><dl>
<dt><a href="chrono_hpp.html#boost_chrono.reference.chrono_hpp.class__system_clock_.to_time_t">
- Non-Member function <code class="computeroutput">to_time_t(time_point)</code></a></dt>
+ Static member function <code class="computeroutput">to_time_t(time_point)</code></a></dt>
<dt><a href="chrono_hpp.html#boost_chrono.reference.chrono_hpp.class__system_clock_.from_time_t">
- Non-Member function <code class="computeroutput">from_time_t(time_t)</code></a></dt>
+ 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 = <unspecified>;
+ static const bool is_monotonic = false;

 static time_point now(); // throws on error
 static time_point now(system::error_code & ec); // never throws
@@ -1780,13 +1790,17 @@
};
</pre>

- <code class="computeroutput">system_clock::duration::min() < system_clock::duration::zero()</code> shall be <code class="computeroutput">true</code>.
+ <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><h5 class="title">
<a name="boost_chrono.reference.chrono_hpp.class__system_clock_.to_time_t"></a><a href="chrono_hpp.html#boost_chrono.reference.chrono_hpp.class__system_clock_.to_time_t" title="
- Non-Member function to_time_t(time_point)">
- Non-Member function <code class="computeroutput">to_time_t(time_point)</code></a>
+ Static member function to_time_t(time_point)">
+ Static member function <code class="computeroutput">to_time_t(time_point)</code></a>
</h5></div></div></div>

 time_t to_time_t(const time_point& t);
@@ -1801,8 +1815,8 @@
<div class="section" lang="en">
<div class="titlepage"><div><div><h5 class="title">
<a name="boost_chrono.reference.chrono_hpp.class__system_clock_.from_time_t"></a><a href="chrono_hpp.html#boost_chrono.reference.chrono_hpp.class__system_clock_.from_time_t" title="
- Non-Member function from_time_t(time_t)">
- Non-Member function <code class="computeroutput">from_time_t(time_t)</code></a>
+ Static member function from_time_t(time_t)">
+ Static member function <code class="computeroutput">from_time_t(time_t)</code></a>
</h5></div></div></div>
<pre class="programlisting">time_point from_time_t(time_t t);
</pre>
@@ -1824,6 +1838,12 @@
 <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:

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/process_times_hpp.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/process_times_hpp.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/process_times_hpp.html 2009-12-13 07:45:51 EST (Sun, 13 Dec 2009)
@@ -26,82 +26,193 @@
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_chrono.reference.process_times_hpp"></a> Header <boost/chrono/process_times.hpp>
</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="process_times_hpp.html#boost_chrono.reference.process_times_hpp.class__process_clock_">Class
+ <code class="computeroutput">process_clock</code></a></dt>
+<dd><dl><dt><a href="process_times_hpp.html#boost_chrono.reference.process_times_hpp.class__process_clock_.class__process_times_">Class
+ <code class="computeroutput">process_times</code></a></dt></dl></dd>
+<dt><a href="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="process_times_hpp.html#boost_chrono.reference.process_times_hpp.class__run_timer_">Class
+ <code class="computeroutput">run_timer</code></a></dt>
+</dl></div>
<pre class="programlisting">namespace boost { namespace chrono {

- struct process_times;
+ class process_clock;
+ class process_timer;
+ class run_timer;
+
+} }
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_chrono.reference.process_times_hpp.class__process_clock_"></a><a href="process_times_hpp.html#boost_chrono.reference.process_times_hpp.class__process_clock_" title="Class
+ process_clock">Class
+ <code class="computeroutput">process_clock</code></a>
+</h4></div></div></div>
+<div class="toc"><dl><dt><a href="process_times_hpp.html#boost_chrono.reference.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;

- 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;
-
- static void now( process_times & times,
- system::error_code & ec = system::throws );
- };
-
- 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
- };
-
- 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 );
- };
-
- 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();
- };
-
- } // namespace chrono
-} // namespace boost
-</pre>
+ 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><h5 class="title">
+<a name="boost_chrono.reference.process_times_hpp.class__process_clock_.class__process_times_"></a><a href="process_times_hpp.html#boost_chrono.reference.process_times_hpp.class__process_clock_.class__process_times_" title="Class
+ process_times">Class
+ <code class="computeroutput">process_times</code></a>
+</h5></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><h4 class="title">
+<a name="boost_chrono.reference.process_times_hpp.class__process_timer_"></a><a href="process_times_hpp.html#boost_chrono.reference.process_times_hpp.class__process_timer_" title="Class
+ process_timer">Class
+ <code class="computeroutput">process_timer</code></a>
+</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.
+ 
+
+ <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><h4 class="title">
+<a name="boost_chrono.reference.process_times_hpp.class__run_timer_"></a><a href="process_times_hpp.html#boost_chrono.reference.process_times_hpp.class__run_timer_" title="Class
+ run_timer">Class
+ <code class="computeroutput">run_timer</code></a>
+</h4></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 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 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>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/timer_hpp.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/timer_hpp.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/timer_hpp.html 2009-12-13 07:45:51 EST (Sun, 13 Dec 2009)
@@ -26,32 +26,67 @@
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_chrono.reference.timer_hpp"></a> Header <boost/chrono/timer.hpp>
</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="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>
+</dl></div>
<pre class="programlisting">namespace boost { namespace chrono {
+ template <class 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><h4 class="title">
+<a name="boost_chrono.reference.timer_hpp.template_class__timer___"></a><a href="timer_hpp.html#boost_chrono.reference.timer_hpp.template_class__timer___" title="Template
+ Class timer<>">Template
+ Class <code class="computeroutput">timer<></code></a>
+</h4></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;

- 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();
+ explicit timer( system::error_code & ec = system::throws );

- void start( system::error_code & ec = system::throws );
- duration elapsed( system::error_code & ec = system::throws );
+ ~timer();

- };
+ void start( system::error_code & ec = system::throws );
+ duration elapsed( system::error_code & ec = system::throws );

- typedef boost::chrono::timer< boost::chrono::system_clock > system_timer;
+};
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_chrono.reference.timer_hpp._timer__useful_typedefs"></a>timer useful typedefs
+</h4></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;
+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::high_resolution_clock > high_resolution_timer;
</pre>
</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

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-13 07:45:51 EST (Sun, 13 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="id4816056"></a>
+<a name="id4816278"></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="id4816117"></a>
+<a name="id4816338"></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>
@@ -62,14 +62,14 @@
 BOOST_ROOT directory.
 

- Othesewise, if you decompress in another directory, you will need to comment
- some lines, and uncomment and change others in the build/Jamfile and test/Jamfile.
- Sorry for this, but I have not reached yet to write a Jamfile that is able
- to work in both environements and use the BOOST_ROOT variable. Any help
- is welcome.
+ Othesewise, if you decompress in a different directory, you will need to
+ comment some lines, and uncomment and change others in the build/Jamfile
+ and test/Jamfile. Sorry for this, but I have not reached yet to write a
+ Jamfile that is able to work in both environements and use the BOOST_ROOT
+ 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="id4816159"></a>
+<a name="id4816381"></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="id4816227"></a>
+<a name="id4816449"></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="id4816408"></a>
+<a name="id4816630"></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="id4816444"></a>
+<a name="id4816666"></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="id4816471"></a>
+<a name="id4816692"></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="id4816495"></a>
+<a name="id4816717"></a>
 <a href="getting_started.html#boost_chrono.users_guide.getting_started.install.tested_compilers_">Tested
 compilers </a>
 </h5>

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-13 07:45:51 EST (Sun, 13 Dec 2009)
@@ -116,7 +116,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 12, 2009 at 18:38:26 GMT</td>
+<td align="left">Last revised: December 13, 2009 at 12:44:57 GMT</td>
<td align="right"><div class="copyright-footer"></div></td>
</tr></table>
<hr>

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