Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r59392 - 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: 2010-01-31 18:12:40

Author: viboes
Date: 2010-01-31 18:12:37 EST (Sun, 31 Jan 2010)
New Revision: 59392
URL: http://svn.boost.org/trac/boost/changeset/59392

Log:
Boost.Chrono: Version 0.4.0,
* Update documentation
Added:
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/perf.html (contents, props changed)
Text files modified:
   sandbox/chrono/libs/chrono/doc/chrono.qbk | 593 +++++++++++++++++++++++++++++++++++----
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices.html | 5
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/faq.html | 8
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/history.html | 39 ++
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/rationale.html | 8
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/tests.html | 2
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/tickets.html | 6
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/todo.html | 14
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/overview/motivation.html | 65 +++-
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference.html | 8
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/cpp0x.html | 2
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/stopwatch_formatters.html | 62 ++--
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/stopwatch_reporters.html | 469 +++++++++++++++++++++++++++++++
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/stopwatches.html | 29 +
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide/getting_started.html | 16
   sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide/tutorial.html | 32 +-
   sandbox/chrono/libs/chrono/doc/html/index.html | 5
   sandbox/chrono/libs/chrono/doc/html/standalone_HTML.manifest | 1
   18 files changed, 1179 insertions(+), 185 deletions(-)

Modified: sandbox/chrono/libs/chrono/doc/chrono.qbk
==============================================================================
--- sandbox/chrono/libs/chrono/doc/chrono.qbk (original)
+++ sandbox/chrono/libs/chrono/doc/chrono.qbk 2010-01-31 18:12:37 EST (Sun, 31 Jan 2010)
@@ -62,7 +62,7 @@
 * `process_user_CPU_clocks`, capturing user-CPU times.
 * `process_system_CPU_clocks`, capturing system-CPU times.
 * `process_cpu_clock`, tuple-like class capturing at once real, user-CPU, and system-CPU times.
-
+
* Thread clock

* Suspendible Clock
@@ -505,26 +505,41 @@
 }

-[heading How reliable are these measure?]
+[heading How reliable are these measures?]

[info this section need to be reworked, the ideas are there, but ...]

There are three context on which you can get unreliable measures:

-# the precission of your clock. If the precission of your clock is 10ms you can not be able to measure the time spent by blocks of code that takes the same order of magnitude. The library provides a hig_resolution_clock that gives you the higher resolution available on your platform. Respect to the precission, nothing to do except to take the clock with the highest resolution and measures blocks of code that will spent time having more than one order of magnitude.
+# the precission of your clock. If the precission of your clock is 10ms you can not be able to measure the time spent by blocks of code that takes the same order of magnitude. The library provides a hig_resolution_clock that gives you the higher resolution available on your platform. Respect to the precission, nothing to do except to take the clock with the highest resolution and measures blocks of code that will spent time having more than one order of magnitude the precission of the clock.
+
+ #include <boost/chrono/thread_clock.hpp>
+ ...
+ stopclock<high_resolution_clock> _;
+
+
+# When your application is multithreaded, and you use a process clock, the time you get is the delay during which your block has been executed, in concurrency with the other threads of execution. If what you want is the time spent by this specific thread another clock is needed. The library provide a thread_clock that returns the time spent by the thread on platforms providing this kind of data. It can be used as follows

-# When your application is multithreaded, and you use a process clock, the time you get is the delay during which your block has been executed, in concurrency with the other threads of execution. The library provide a thread_clock on platforms providing this kind of data.
+ #include <boost/chrono/thread_clock.hpp>
+ ...
+ #if defined(BOOST_CHRONO_HAS_THREAD_CLOCK)
+ stopclock<thread_clock> _;
+ #else
+ stopclock<process_real_cpu_clock> _;
+ #endif

-# Nested stopclocks (usually nested function calls where each function contains a stopclock). When the nesting is deep enough, the cumulative overhead of all the stopclock functionality make the data unreliable except for the inner-most trace points. The question is,how many time is related to the application code we want to measure and how many to the fact we are meassuring and logging in inner blocks?
+# Nested stopclocks (usually nested function calls where each function contains a stopclock). When the nesting is deep enough, the cumulative overhead of all the stopclock functionality make the data unreliable except for the inner-most trace points. The question is, how much time is related to the application code we want to measure and how much to the fact we are meassuring and logging in inner blocks?

-Some measures let me think that most of the time spent by the stopclock mechanism is associated to the logging part. There are two things we can do to make the difference :
+Some measures let us think that most of the time spent by the stopclock mechanism is associated to the logging part. There are two things we can do to make the difference :

-* Avoid the expensive operations as reporting while doing the measures. Note that reporting in itself is not too expensive as far as we don't need to flush the buffer. This can be achieved either using a stopclock accumulator, 'i.e. don't report until all the measures have been compiled and then report some statistics) or using an asynchronous stream.
+* Avoid expensive operations as logging while doing the measures. Note that reporting in itself is not too expensive as far as we don't need to flush the buffer. This can be achieved either using a stopclock accumulator, 'i.e. don't report until all the measures have been compiled and then report some statistics or using an asynchronous stream.

-* Introduce some cheap mechanism that allows us to make the difference between the application time and the intrinsec stopclock time. When the precission of the clock is enough, we can suspend the counting of the Clock while we are speending time reporting the measures, and resume it once the work is done.
+* Introduce some cheap mechanism that allows us to make the difference between the application time and the intrinsec stopclock time. When the precission of the clock is enough, we can suspend the counting of the Clock while we are spending time reporting the measures, and resume it once the work is done. The library provide a Clock wrapper suspendible_clock that make the resulting clock suspendible. The stopwatch_reporter is able to detect if the CLock is Suspendible and then suspend/resume the clock while doing the report.

+ stopclock<suspendible_clock<Clock> > _;

+See the performances section for more deep details.

[endsect]
[endsect]
@@ -737,7 +752,7 @@
 // transform to nanoseconds
 return time_point(duration(
 static_cast<thread_clock::rep>( ts.tv_sec ) * 1000000000 + ts.tv_nsec));
-
+
 }
 static time_point now( system::error_code & ec ) {
 // get the current thread
@@ -756,7 +771,7 @@
 // transform to nanoseconds
 return time_point(duration(
 static_cast<thread_clock::rep>( ts.tv_sec ) * 1000000000 + ts.tv_nsec));
-
+
 }
 };
[endsect]
@@ -829,7 +844,7 @@
 stopclock_accumulator<>::scoped_run _(acc);
 // ...
 }
-
+

[endsect]

@@ -843,7 +858,7 @@
 using namespace boost::chrono;
 double res;
 void f1(long j)
- {
+ {
 stopwatch<>::reporter _(BOOST_CHRONO_STOPWATCH_FUNCTION_FORMAT);
 for (long i =0; i< j; i+=1)
 res+=std::sqrt( res+123.456L+i ); // burn some time
@@ -863,13 +878,13 @@
For the first case we just need to change the accumulator_set and the format we want to get. Imagin we want to get only the count, sam and mean statistics, no need to calculate the min neither the max.

 using namespace boost::accumulators;
-
- typedef stopwatch_accumulator<process_real_cpu_clock,
+
+ typedef stopwatch_accumulator<process_real_cpu_clock,
 accumulator_set<process_real_cpu_clock::rep,
 features<
 tag::count,
 tag::sum,
- tag::mean
+ tag::mean
>
>
>::reporter my_stopwatch_accumulator_reporter;
@@ -902,26 +917,26 @@
 ...
 #include <boost/accumulators/statistics/variance.hpp>
 ...
- typedef stopwatch_accumulator<process_real_cpu_clock,
+ typedef stopwatch_accumulator<process_real_cpu_clock,
 accumulator_set<process_real_cpu_clock::rep,
 features<
 tag::count,
 tag::sum,
 tag::mean,
- tag::variance(lazy)
+ tag::variance(lazy)
>
>
>::reporter my_stopwatch_accumulator_reporter;

-But what happens if we add new statistics to the accumulator_set that are not taken in account by the default formatter? These statistics will simply be ignored. So we will need to define own own accumulator formatter.
+But what happens if we add new statistics to the accumulator_set that are not taken in account by the default formatter? These statistics will simply be ignored. So we will need to define own own accumulator formatter.

- typedef stopwatch_accumulator<process_real_cpu_clock,
+ typedef stopwatch_accumulator<process_real_cpu_clock,
 accumulator_set<process_real_cpu_clock::rep,
 features<
 tag::count,
 tag::sum,
 tag::mean,
- tag::variance(lazy)
+ tag::variance(lazy)
>
>,
 my_stopwatch_accumulator_formatter
@@ -930,17 +945,17 @@
Next follow the definition of a formatter taking care of count, sum, mean and variance

 class my_stopwatch_accumulator_formatter {
- public:
+ public:
 typedef std::string string_type;
 typedef char char_type;
 typedef std::ostream ostream_type;
-
+
 static ostream_type & default_os() {return std::cout;}
 static const char_type* default_format() {return "%c times, sum=%ss, mean=%as, variance=%vs\n";}
 static int default_places() { return 3; }

 template <class Stopwatch >
- static void show_time( Stopwatch & stopwatch_, const char_type* format,
+ static void show_time( Stopwatch & stopwatch_, const char_type* format,
 int places, ostream_type & os, system::error_code & ec)
 {
 typedef typename Stopwatch::duration duration_t;
@@ -2536,8 +2551,6 @@

This file include all the stopwatches related files

- #include <boost/chrono/digital_time.hpp>
- #include <boost/chrono/digital_time_formatter.hpp>
 #include <boost/chrono/scoped_stopclock.hpp>
 #include <boost/chrono/process_cpu_clocks.hpp>
 #include <boost/chrono/stopclock.hpp>
@@ -2549,6 +2562,8 @@
 #include <boost/chrono/stopwatch_reporter.hpp>
 #include <boost/chrono/stopwatch_scoped.hpp>
 #include <boost/chrono/time_formatter.hpp>
+ #include <boost/chrono/t24_hours.hpp>
+ #include <boost/chrono/t24_hours_formatter.hpp>

[endsect]

@@ -2641,6 +2656,16 @@

 template <class Clock=high_resolution_clock> class stopwatch;

+ template <class Clock>
+ struct stopwatch_reporter_default_formatter<stopwatch<Clock> > {
+ typedef stopwatch_formatter type;
+ };
+
+ template <class Clock>
+ struct wstopwatch_reporter_default_formatter<stopwatch<Clock> > {
+ typedef wstopwatch_formatter type;
+ };
+
 typedef <see above> system_stopwatch;
 #ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
 typedef <see above> monotonic_stopwatch;
@@ -2723,6 +2748,17 @@

 namespace boost { namespace chrono {
 template <class Clock, class Accumulator> class stopwatch_accumulator;
+
+ template <class Clock, class Accumulator>
+ struct stopwatch_reporter_default_formatter<stopwatch_accumulator<Clock, Accumulator> > {
+ typedef stopwatch_accumulator_formatter type;
+ };
+
+ template <class Clock, class Accumulator>
+ struct wstopwatch_reporter_default_formatter<stopwatch_accumulator<Clock, Accumulator> > {
+ typedef wstopwatch_accumulator_formatter type;
+ };
+
 typedef <see below> system_stopwatch_accumulator;
 #ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
 typedef <see below> monotonic_stopwatch_accumulator;
@@ -3015,24 +3051,70 @@

 namespace boost { namespace chrono {
 template <class Stopwatch>
+ struct basic_stopwatch_reporter_default_formatter;
+ template <class Stopwatch>
 struct stopwatch_reporter_default_formatter;
+ template <class Stopwatch>
+ struct wstopwatch_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;
- typedef <see above> process_cpu_stopwatch_reporter;
+[section Template Class `basic_stopwatch_reporter<>`]

-]
+class `basic_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 basic_stopwatch_reporter : public Stopwatch {
+ public:
+ typedef typename Stopwatch::clock clock;
+ typedef Stopwatch stopwatch;
+ typedef Formatter formatter;
+
+ explicit basic_stopwatch_reporter( system::error_code & ec = system::throws );
+ explicit basic_stopwatch_reporter( std::ostream & os,
+ system::error_code & ec = system::throws );
+
+ explicit basic_stopwatch_reporter( const std::string & format,
+ system::error_code & ec = system::throws );
+ explicit basic_stopwatch_reporter( std::ostream & os, const std::string & format,
+ system::error_code & ec = system::throws );
+
+ explicit basic_stopwatch_reporter( const std::string & format, int places,
+ system::error_code & ec = system::throws );
+ explicit basic_stopwatch_reporter( std::ostream & os, const std::string & format, int places,
+ system::error_code & ec = system::throws );
+
+ explicit basic_stopwatch_reporter( int places,
+ system::error_code & ec = system::throws );
+ explicit basic_stopwatch_reporter( std::ostream & os, int places,
+ system::error_code & ec = system::throws );
+
+ explicit basic_stopwatch_reporter( int places, const std::string & format,
+ system::error_code & ec = system::throws );
+ explicit basic_stopwatch_reporter( std::ostream & os, int places, const std::string & format,
+ system::error_code & ec = system::throws );
+
+ ~basic_stopwatch_reporter();
+
+ void report( system::error_code & ec = system::throws );
+ bool reported() const;
+
+
+ typedef stopwatch_runner<basic_stopwatch_reporter<Stopwatch> > scoped_run;
+ typedef stopwatch_suspender<basic_stopwatch_reporter<Stopwatch> > scoped_suspend;
+ typedef stopwatch_resumer<basic_stopwatch_reporter<Stopwatch> > scoped_resume;
+ };
+
+[endsect]

[section Template Class `stopwatch_reporter<>`]

@@ -3046,7 +3128,7 @@
The default format is given by Formatter::default_format().

 template <class Stopwatch, class Formatter>
- class stopwatch_reporter : public Stopwatch {
+ class stopwatch_reporter : public basic_stopwatch_reporter<Stopwatch,Formatter> {
 public:
 typedef typename Stopwatch::clock clock;
 typedef Stopwatch stopwatch;
@@ -3104,21 +3186,78 @@
 }

[endsect]
-[/
-[section `stopwatch_reporter` useful typedefs]

- typedef stopwatch_reporter< stopwatch<system_clock> > system_stopwatch_reporter;
- #ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
- typedef stopwatch_reporter< stopwatch<monotonic_clock> > monotonic_stopwatch_reporter;
- #endif
- typedef stopwatch_reporter< stopwatch<high_resolution_clock> > high_resolution_stopwatch_reporter;
- typedef stopwatch_reporter< stopwatch<process_real_cpu_clock> > process_real_cpu_stopwatch_reporter;
- typedef stopwatch_reporter< stopwatch<process_user_cpu_clock> > process_user_cpu_stopwatch_reporter;
- typedef stopwatch_reporter< stopwatch<process_system_cpu_clock> > process_system_cpu_stopwatch_reporter;
- typedef stopwatch_reporter< stopwatch<process_cpu_clock> > process_cpu_stopwatch_reporter;
+[section Template Class `wstopwatch_reporter<>`]
+
+class `wstopwatch_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 wstopwatch_reporter : public basic_wstopwatch_reporter<Stopwatch,Formatter> {
+ public:
+ typedef typename Stopwatch::clock clock;
+ typedef Stopwatch stopwatch;
+ typedef Formatter formatter;
+
+ explicit wstopwatch_reporter( system::error_code & ec = system::throws );
+ explicit wstopwatch_reporter( std::ostream & os,
+ system::error_code & ec = system::throws );
+
+ explicit wstopwatch_reporter( const std::string & format,
+ system::error_code & ec = system::throws );
+ explicit wstopwatch_reporter( std::ostream & os, const std::string & format,
+ system::error_code & ec = system::throws );
+
+ explicit wstopwatch_reporter( const std::string & format, int places,
+ system::error_code & ec = system::throws );
+ explicit wstopwatch_reporter( std::ostream & os, const std::string & format, int places,
+ system::error_code & ec = system::throws );
+
+ explicit wstopwatch_reporter( int places,
+ system::error_code & ec = system::throws );
+ explicit wstopwatch_reporter( std::ostream & os, int places,
+ system::error_code & ec = system::throws );
+
+ explicit wstopwatch_reporter( int places, const std::string & format,
+ system::error_code & ec = system::throws );
+ explicit wstopwatch_reporter( std::ostream & os, int places, const std::string & format,
+ system::error_code & ec = system::throws );
+
+ ~wstopwatch_reporter();
+
+ void report( system::error_code & ec = system::throws );
+ bool reported() const;
+
+
+ typedef stopwatch_runner<wstopwatch_reporter<Stopwatch> > scoped_run;
+ typedef stopwatch_suspender<wstopwatch_reporter<Stopwatch> > scoped_suspend;
+ typedef stopwatch_resumer<wstopwatch_reporter<Stopwatch> > scoped_resume;
+ };
+
+Usage
+
+ void f1()
+ {
+ typedef wstopwatch_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]
-]
+
[endsect]

[/==================================================]
@@ -3126,7 +3265,10 @@
[/==================================================]

 namespace boost { namespace chrono {
+ template < class Clock, class Formatter > class basic_stopclock;
 template < class Clock, class Formatter > class stopclock;
+ template < class Clock, class Formatter > class wstopclock;
+
 typedef <see above> system_stopclock;
 #ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
 typedef <see above> monotonic_stopclock;
@@ -3135,16 +3277,69 @@
 typedef <see above> process_real_cpu_stopclock;
 typedef <see above> process_user_cpu_stopclock;
 typedef <see above> process_system_cpu_stopclock;
+
+ typedef <see above> system_wstopclock;
+ #ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
+ typedef <see above> monotonic_wstopclock;
+ #endif
+ typedef <see above> high_resolution_wstopclock;
+ typedef <see above> process_real_cpu_wstopclock;
+ typedef <see above> process_user_cpu_wstopclock;
+ typedef <see above> process_system_cpu_wstopclock;
 }}

+[section Template Class `basic_stopclock<>`]
+
+`basic_stopclock<Clock>` template class is a shortcut of `basic_stopwatch_reporter<stopwatch<Clock>>`
+
+ template< class Clock, class Formatter>
+ class basic_stopclock : public basic_stopwatch_reporter<stopwatch<Clock>, Formatter> {
+ public:
+ typedef Clock clock;
+ typedef stopwatch<Clock> stopwatch;
+ typedef Formatter formatter;
+ typedef typename Formatter::string_type string_type;
+ typedef typename Formatter::char_type char_type;
+ typedef typename Formatter::ostream_type ostream_type;
+
+ explicit basic_stopclock( system::error_code & ec = system::throws );
+ explicit basic_stopclock( ostream_type & os,
+ system::error_code & ec = system::throws );
+ explicit basic_stopclock( const string_type & format,
+ system::error_code & ec = system::throws );
+ explicit basic_stopclock( int places,
+ system::error_code & ec = system::throws );
+
+ basic_stopclock( ostream_type & os, const string_type & format,
+ system::error_code & ec = system::throws );
+ basic_stopclock( const string_type & format, int places,
+ system::error_code & ec = system::throws );
+ basic_stopclock( ostream_type & os, int places,
+ system::error_code & ec = system::throws );
+ basic_stopclock( int places, const string_type & format,
+ system::error_code & ec = system::throws );
+
+ basic_stopclock( ostream_type & os, const string_type & format, int places,
+ system::error_code & ec = system::throws );
+ basic_stopclock( ostream_type & os, int places, const string_type & format,
+ system::error_code & ec = system::throws );
+
+
+ typedef typename base_type::scoped_run scoped_run;
+ typedef typename base_type::scoped_suspend scoped_suspend;
+ typedef typename base_type::scoped_resume scoped_resume;
+ };
+
+[endsect]
+
[section Template Class `stopclock<>`]

-`stopclock<Clock>` template class is a shortcut of `stopwatch_reporter<stopwatch<Clock>>`
+`stopclock<Clock>` template class is a shortcut of `stopwatch_reporter<stopwatch<Clock>>` with a specific default formatter.

 template
 < class Clock=process_cpu_clock
 , class Formatter=typename stopwatch_reporter_default_formatter<stopwatch<Clock>>::type
- > class stopclock : public stopwatch_reporter<stopwatch<Clock>, Formatter> {
+ > class stopclock : public basic_stopclock<Clock, Formatter> {
 public:
 typedef Clock clock;
 typedef stopwatch<Clock> stopwatch;
@@ -3194,6 +3389,66 @@
 typedef boost::chrono::stopclock< boost::chrono::process_system_cpu_clock > process_system_cpu_stopclock;

[endsect]
+
+[section Template Class `wstopclock<>`]
+
+`wstopclock<Clock>` template class is a shortcut of `stopwatch_reporter<stopwatch<Clock>>` with a specific default formatter.
+
+ template
+ < class Clock=process_cpu_clock
+ , class Formatter=typename stopwatch_reporter_default_formatter<stopwatch<Clock>>::type
+ > class wstopclock : public basic_wstopclock<Clock, Formatter> {
+ public:
+ typedef Clock clock;
+ typedef stopwatch<Clock> stopwatch;
+ typedef Formatter formatter;
+ typedef typename Formatter::string_type string_type;
+ typedef typename Formatter::char_type char_type;
+ typedef typename Formatter::ostream_type ostream_type;
+
+ explicit wstopclock( system::error_code & ec = system::throws );
+ explicit wstopclock( ostream_type & os,
+ system::error_code & ec = system::throws );
+ explicit wstopclock( const string_type & format,
+ system::error_code & ec = system::throws );
+ explicit wstopclock( int places,
+ system::error_code & ec = system::throws );
+
+ wstopclock( ostream_type & os, const string_type & format,
+ system::error_code & ec = system::throws );
+ wstopclock( const string_type & format, int places,
+ system::error_code & ec = system::throws );
+ wstopclock( ostream_type & os, int places,
+ system::error_code & ec = system::throws );
+ wstopclock( int places, const string_type & format,
+ system::error_code & ec = system::throws );
+
+ wstopclock( ostream_type & os, const string_type & format, int places,
+ system::error_code & ec = system::throws );
+ wstopclock( ostream_type & os, int places, const string_type & format,
+ system::error_code & ec = system::throws );
+
+
+ typedef typename base_type::scoped_run scoped_run;
+ typedef typename base_type::scoped_suspend scoped_suspend;
+ typedef typename base_type::scoped_resume scoped_resume;
+ };
+
+[endsect]
+[section `wstopclock` useful typedefs]
+
+ typedef boost::chrono::wstopclock< boost::chrono::system_clock > system_stopwatch_reporter;
+ #ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
+ typedef boost::chrono::wstopclock< boost::chrono::monotonic_clock > monotonic_stopwatch_reporter;
+ #endif
+ typedef boost::chrono::wstopclock< boost::chrono::high_resolution_clock > high_resolution_wstopclock;
+ typedef boost::chrono::wstopclock< boost::chrono::process_real_cpu_clock > process_real_cpu_wstopclock;
+ typedef boost::chrono::wstopclock< boost::chrono::process_user_cpu_clock > process_user_cpu_wstopclock;
+ typedef boost::chrono::wstopclock< boost::chrono::process_system_cpu_clock > process_system_cpu_wstopclock;
+
+[endsect]
+
+
[endsect]

[/==================================================]
@@ -3202,7 +3457,12 @@

 namespace boost { namespace chrono {
 template < class Clock, class Formatter >
+ class basic_stopclock_accumulator;
+ template < class Clock, class Formatter >
 class stopclock_accumulator;
+ template < class Clock, class Formatter >
+ class wstopclock_accumulator;
+
 typedef <see above> system_stopclock_accumulator;
 #ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
 typedef <see above> monotonic_stopclock_accumulator;
@@ -3211,17 +3471,73 @@
 typedef <see above> process_real_cpu_stopclock_accumulator;
 typedef <see above> process_user_cpu_stopclock_accumulator;
 typedef <see above> process_system_cpu_stopclock_accumulator;
+
+ typedef <see above> system_wstopclock_accumulator;
+ #ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
+ typedef <see above> monotonic_wstopclock_accumulator;
+ #endif
+ typedef <see above> high_resolution_wstopclock_accumulator;
+ typedef <see above> process_real_cpu_wstopclock_accumulator;
+ typedef <see above> process_user_cpu_wstopclock_accumulator;
+ typedef <see above> process_system_cpu_wstopclock_accumulator;
 }}

+[section Template Class `basic_stopclock_accumulator<>`]
+
+`basic_stopclock_accumulator<Clock>` template class is a shortcut of `stopwatch_reporter<stopwatch<Clock>>`
+
+ template
+ < class Clock=high_resolution_clock
+ , class Formatter=typename stopwatch_reporter_default_formatter<stopwatch_accumulator<Clock>>::type
+ > class basic_stopclock_accumulator
+ : public basic_stopwatch_reporter<stopwatch_accumulator<Clock>, Formatter> {
+ public:
+ typedef Clock clock;
+ typedef stopwatch_accumulator<Clock> stopwatch;
+ typedef Formatter formatter;
+ typedef typename Formatter::string_type string_type;
+ typedef typename Formatter::char_type char_type;
+ typedef typename Formatter::ostream_type ostream_type;
+
+ explicit basic_stopclock_accumulator( system::error_code & ec = system::throws );
+ explicit basic_stopclock_accumulator( ostream_type & os,
+ system::error_code & ec = system::throws );
+ explicit basic_stopclock_accumulator( const string_type & format,
+ system::error_code & ec = system::throws );
+ explicit basic_stopclock_accumulator( int places,
+ system::error_code & ec = system::throws );
+
+ basic_stopclock_accumulator( ostream_type & os, const string_type & format,
+ system::error_code & ec = system::throws );
+ basic_stopclock_accumulator( const string_type & format, int places,
+ system::error_code & ec = system::throws );
+ basic_stopclock_accumulator( ostream_type & os, int places,
+ system::error_code & ec = system::throws );
+ basic_stopclock_accumulator( int places, const string_type & format,
+ system::error_code & ec = system::throws );
+
+ basic_stopclock_accumulator( ostream_type & os, const string_type & format, int places,
+ system::error_code & ec = system::throws );
+ basic_stopclock_accumulator( ostream_type & os, int places, const string_type & format,
+ system::error_code & ec = system::throws );
+
+
+ typedef typename base_type::scoped_run scoped_run;
+ typedef typename base_type::scoped_suspend scoped_suspend;
+ typedef typename base_type::scoped_resume scoped_resume;
+ };
+
+[endsect]
+
[section Template Class `stopclock_accumulator<>`]

-`stopclock_accumulator<Clock>` template class is a shortcut of `stopwatch_reporter<stopwatch<Clock>>`
+`stopclock_accumulator<Clock>` template class is a shortcut of `stopwatch_reporter<stopwatch<Clock>>` with a specific formatter.

 template
 < class Clock=high_resolution_clock
 , class Formatter=typename stopwatch_reporter_default_formatter<stopwatch_accumulator<Clock>>::type
> class stopclock_accumulator
- : public stopwatch_reporter<stopwatch_accumulator<Clock>, Formatter> {
+ : public basic_stopclock_accumulator<Clock, Formatter> {
 public:
 typedef Clock clock;
 typedef stopwatch_accumulator<Clock> stopwatch;
@@ -3271,6 +3587,64 @@
 typedef boost::chrono::stopclock_accumulator< boost::chrono::process_system_cpu_clock > process_system_cpu_stopclock_accumulator;

[endsect]
+[section Template Class `wstopclock_accumulator<>`]
+
+`wstopclock_accumulator<Clock>` template class is a shortcut of `stopwatch_reporter<stopwatch<Clock>>` with a specific formatter.
+
+ template
+ < class Clock=high_resolution_clock
+ , class Formatter=typename stopwatch_reporter_default_formatter<stopwatch_accumulator<Clock>>::type
+ > class wstopclock_accumulator
+ : public basic_wstopclock_accumulator<Clock, Formatter> {
+ public:
+ typedef Clock clock;
+ typedef stopwatch_accumulator<Clock> stopwatch;
+ typedef Formatter formatter;
+ typedef typename Formatter::string_type string_type;
+ typedef typename Formatter::char_type char_type;
+ typedef typename Formatter::ostream_type ostream_type;
+
+ explicit wstopclock_accumulator( system::error_code & ec = system::throws );
+ explicit wstopclock_accumulator( ostream_type & os,
+ system::error_code & ec = system::throws );
+ explicit wstopclock_accumulator( const string_type & format,
+ system::error_code & ec = system::throws );
+ explicit wstopclock_accumulator( int places,
+ system::error_code & ec = system::throws );
+
+ wstopclock_accumulator( ostream_type & os, const string_type & format,
+ system::error_code & ec = system::throws );
+ wstopclock_accumulator( const string_type & format, int places,
+ system::error_code & ec = system::throws );
+ wstopclock_accumulator( ostream_type & os, int places,
+ system::error_code & ec = system::throws );
+ wstopclock_accumulator( int places, const string_type & format,
+ system::error_code & ec = system::throws );
+
+ wstopclock_accumulator( ostream_type & os, const string_type & format, int places,
+ system::error_code & ec = system::throws );
+ wstopclock_accumulator( ostream_type & os, int places, const string_type & format,
+ system::error_code & ec = system::throws );
+
+
+ typedef typename base_type::scoped_run scoped_run;
+ typedef typename base_type::scoped_suspend scoped_suspend;
+ typedef typename base_type::scoped_resume scoped_resume;
+ };
+
+[endsect]
+[section `wstopclock_accumulator` useful typedefs]
+
+ typedef boost::chrono::wstopclock_accumulator< boost::chrono::system_clock > system_stopwatch_reporter;
+ #ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
+ typedef boost::chrono::wstopclock_accumulator< boost::chrono::monotonic_clock > monotonic_stopwatch_reporter;
+ #endif
+ typedef boost::chrono::wstopclock_accumulator< boost::chrono::high_resolution_clock > high_resolution_wstopclock_accumulator;
+ typedef boost::chrono::wstopclock_accumulator< boost::chrono::process_real_cpu_clock > process_real_cpu_wstopclock_accumulator;
+ typedef boost::chrono::wstopclock_accumulator< boost::chrono::process_user_cpu_clock > process_user_cpu_wstopclock_accumulator;
+ typedef boost::chrono::wstopclock_accumulator< boost::chrono::process_system_cpu_clock > process_system_cpu_wstopclock_accumulator;
+
+[endsect]
[endsect]

[/==================================================]
@@ -3521,16 +3895,16 @@
[endsect]

[/==================================================]
-[section:digital_time_hpp Header `<boost/chrono/digital_time.hpp>`]
+[section:t24_hours_hpp Header `<boost/chrono/t24_hours.hpp>`]
[/==================================================]

 namespace boost { namespace chrono {
- class digital_time;
+ class t24_hours;
 }}

-[section Class `digital_time`]
+[section Class `t24_hours`]

- class digital_time {
+ class t24_hours {
 public:
 typedef boost::chrono::duration<boost::int_least32_t, ratio<24*3600> > days;
 typedef boost::chrono::hours hours;
@@ -3545,14 +3919,14 @@
 nanoseconds nanoseconds_;

 template <class Rep, class Period>
- explicit digital_time(const boost::chrono::duration<Rep, Period>& d);
+ explicit t24_hours(const boost::chrono::duration<Rep, Period>& d);
 };

[endsect]
[endsect]

[/==================================================================]
-[section:digital_time_formatter_hpp Header `<boost/chrono/digital_time_formatter.hpp>`]
+[section:t24_hours_formatter_hpp Header `<boost/chrono/t24_hours_formatter.hpp>`]
[/==================================================================]

@@ -3563,17 +3937,17 @@
 typename Traits=std::char_traits<CharT>,
 class Alloc=std::allocator<CharT>
>
- class basic_digital_time_formatter;
+ class basic_24_hours_formatter;

- typedef basic_digital_time_formatter<char> digital_time_formatter;
- typedef basic_digital_time_formatter<wchar_t> wdigital_time_formatter;
+ typedef basic_24_hours_formatter<char> t24_hours_formatter;
+ typedef basic_24_hours_formatter<wchar_t> wt24_hours_formatter;

 } }

-[section Template Class `basic_digital_time_formatter<>`]
+[section Template Class `basic_24_hours_formatter<>`]

 template <typename CharT, typename Traits, class Alloc>
- class basic_digital_time_formatter {
+ class basic_24_hours_formatter {
 public:
 static std::ostream & default_os();
 static const char * default_format();
@@ -4810,16 +5184,36 @@
[/==================================]

-[section [*Version 0.4, Febrary 5, 2010] ['New thread clock and Suspendible clock ]]
+[section [*Version 0.4, Febrary 31, 2010] ['New thread clock and Suspendible clock ]]

[*New Features:]

* Suspendible Clock concept + template class suspendible_clock<>
* Added scope_suspend which do suspend/resume if the Clock is a model of Suspendible Clock concept, and nothing otherwise.
* thread_clock support on platforms providing it natively.
+* Added support for wide character for stopwatch_reporter, stopclock, and stopclock_accumulator.
+* digital_time renamed t24_hours
+
+[*Perf]
+
+Added performances measures.

[*Bug Fixes]

+* Bug on timeval_demo.
+
+ time_point t(duration(xtime(0))); // this was taken as a function declaration
+ gettimeofday((timeval*)&t, 0);
+ return t;
+by
+
+ timeval tv;
+ gettimeofday(&tv, 0);
+ xtime xt( tv.tv_sec, tv.tv_usec);
+ return time_point(duration(xt));
+
+* Bug on run_timer_test (add a global variable to avoid optimization that removes completely the code to be measured
+
[endsect]

[section [*Version 0.3.2, January 25, 2010] ['New frequency, lifetime and percentage stopwatch_accumulator features]]
@@ -4830,7 +5224,7 @@

[*Bug Fixes]
* Specific formatters didn't work completly
-* Replace duration(0) by duration::zero() on template classes.
+* Replace duration(0) by duration::zero() on template classes.
* suspend doesn't works: partial_ not initialized neither taken in account by the elapsed function.

[endsect]
@@ -5168,7 +5562,7 @@
 [[stopclock_example] [run] [...] [Pass] [#]]
 [[stopclock_accumulator_example] [run] [...] [Pass] [#]]
 [[nested_stopclock_accumulator_example] [run] [...] [Pass] [#]]
- [[digital_time_example] [run] [...] [Pass] [#]]
+ [[t24_hours_example] [run] [...] [Pass] [#]]
 [[scoped_stopclock_example] [run] [...] [Pass] [#]]
 [[test_minmax] [compile] [...] [Pass] [#]]
 [[stopclock_constructor_overload_test] [run] [...] [Pass] [#]]
@@ -5237,9 +5631,72 @@
[endsect]

[/=====================================]
-[section:todo Appendix H: Future plans]
+[section:perf Appendix H: Performances]
[/=====================================]

+
+We have run some program changing how the reporting is done.
+
+NONE: no report is done on the inner function
+HIGH: every call to the recursive function is reported using an stopclock
+SUSPEND: every call to the recursive function is reported using a using an stopclock on a suspendible clock
+ACCU: every call to the recursive function is tracked using a stopclock_accumulator
+
+We have run the programm with two different clocks, high_resolution_clock and thread_clock.
+
+The programs are either single-threaded or multi-threaded.
+
+Two kind of inner functions are used: recursive or non recursive. In order to test the influence of nesting reports, the non recursive functions use up to 10 nesting levels, depending on its parameter.
+
+the function at level n is defined as follows
+
+ void fn(long v) {
+ // reporting or not
+ stopclock<> _;
+ // burn some time
+ for ( long i = 0; i < v; ++i )
+ res+=std::sqrt( res+123.456L+i ); // burn some time
+ if (v==0) return;
+
+ if (v%(n-1)==0) fn-1(v-1);
+ if (v%(n-2)==0) fn-2(v-1);
+ ...
+ f1(v-1);
+ }
+
+This gives a variable number in nesting reporting depending on the parameter, with a variable lifetime.
+
+[heading Single-Threaded Recursive function]
+
+We have run the same program and changed how the reporting is done.
+
+The programm creates two thread of execution. the thread entry point calls a function which makes some calculation depending on its parameter and call recursivelly itself decreasing the parameter.
+
+NONE: no report is done on the inner function
+HIGH: every call to the recursive function is reported using an stopclock
+SUSPEND: every call to the recursive function is reported using a using an stopclock on a suspendible clock
+ACCU: every call to the recursive function is tracked using a stopclock_accumulator
+
+We have run the programm with two different clocks, high_resolution_clock and thread_clock.
+
+[heading Multi-Threaded Recursive function]
+
+We have run the same program and changed how the reporting is done.
+
+The programm creates two thread of execution. the thread entry point calls a function which makes some calculation depending on its parameter and call recursivelly itself decreasing the parameter.
+
+NONE: no report is done on the inner function
+HIGH: every call to the recursive function is reported using an stopclock
+SUSPEND: every call to the recursive function is reported using a using an stopclock on a suspendible clock
+ACCU: every call to the recursive function is tracked using a stopclock_accumulator
+
+We have run the programm with two different clocks, high_resolution_clock and thread_clock.
+
+[endsect]
+
+[/=====================================]
+[section:todo Appendix I: Future plans]
+[/=====================================]
[heading Tasks to do before review]

* Complete documentation

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 2010-01-31 18:12:37 EST (Sun, 31 Jan 2010)
@@ -29,7 +29,7 @@
<div class="toc"><dl>
<dt> Appendix A: History</dt>
<dd><dl>
-<dt><a href="appendices/history.html#boost_chrono.appendices.history.__version_0_4__febrary_5__2010____new_thread_clock_and_suspendible_clock__">Version 0.4, Febrary 5, 2010 New thread
+<dt><a href="appendices/history.html#boost_chrono.appendices.history.__version_0_4__febrary_31__2010____new_thread_clock_and_suspendible_clock__">Version 0.4, Febrary 31, 2010 New thread
clock and Suspendible clock </a></dt>
<dt><a href="appendices/history.html#boost_chrono.appendices.history.__version_0_3_2__january_25__2010____new_frequency__lifetime_and_percentage_stopwatch_accumulator_features_">Version 0.3.2, January 25, 2010 New frequency,
lifetime and percentage stopwatch_accumulator features</a></dt>
@@ -58,7 +58,8 @@
<dt>stopwatch</dt>
</dl></dd>
<dt> Appendix G: Tickets</dt>
-<dt> Appendix H: Future plans</dt>
+<dt> Appendix H: Performances</dt>
+<dt> Appendix I: Future plans</dt>
</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/appendices/faq.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/faq.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/faq.html 2010-01-31 18:12:37 EST (Sun, 31 Jan 2010)
@@ -29,7 +29,7 @@
<a name="boost_chrono.appendices.faq"></a> Appendix D: FAQ
</h3></div></div></div>
<a name="boost_chrono.appendices.faq.how_important_is_the_order_of_the_common_type_lt__gt__template_arguments_"></a><h4>
-<a name="id4920214"></a>
+<a name="id4932850"></a>
 <a href="faq.html#boost_chrono.appendices.faq.how_important_is_the_order_of_the_common_type_lt__gt__template_arguments_">How
 important is the order of the common_type<> template arguments?</a>
 </h4>
@@ -60,7 +60,7 @@
 is also undefined.
 
<a name="boost_chrono.appendices.faq.why_does_stopwatch_reporter_only_display_millisecond_place_precision_when_the_underlying_timer_has_nanosecond_precision_"></a><h4>
-<a name="id4920624"></a>
+<a name="id4933260"></a>
 <a href="faq.html#boost_chrono.appendices.faq.why_does_stopwatch_reporter_only_display_millisecond_place_precision_when_the_underlying_timer_has_nanosecond_precision_">Why
 does stopwatch_reporter only display millisecond place precision when the
 underlying timer has nanosecond precision?</a>
@@ -71,7 +71,7 @@
 dangerously.
 
<a name="boost_chrono.appendices.faq.why_does_stopwatch_reporter_sometimes_report_more_cpu_seconds_than_real_seconds_"></a><h4>
-<a name="id4920665"></a>
+<a name="id4933302"></a>
 <a href="faq.html#boost_chrono.appendices.faq.why_does_stopwatch_reporter_sometimes_report_more_cpu_seconds_than_real_seconds_">Why
 does stopwatch_reporter sometimes report more cpu seconds than real seconds?</a>
 </h4>
@@ -81,7 +81,7 @@
 be reporting at times.
 
<a name="boost_chrono.appendices.faq.can_i_obtain_statistics_of_the_time_elapsed_between_calls_to_a_function_"></a><h4>
-<a name="id4920699"></a>
+<a name="id4933335"></a>
 <a href="faq.html#boost_chrono.appendices.faq.can_i_obtain_statistics_of_the_time_elapsed_between_calls_to_a_function_">Can
 I obtain statistics of the time elapsed between calls to a function?</a>
 </h4>

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 2010-01-31 18:12:37 EST (Sun, 31 Jan 2010)
@@ -27,7 +27,7 @@
<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_4__febrary_5__2010____new_thread_clock_and_suspendible_clock__">Version 0.4, Febrary 5, 2010 New thread
+<dt><a href="history.html#boost_chrono.appendices.history.__version_0_4__febrary_31__2010____new_thread_clock_and_suspendible_clock__">Version 0.4, Febrary 31, 2010 New thread
 clock and Suspendible clock </a></dt>
<dt><a href="history.html#boost_chrono.appendices.history.__version_0_3_2__january_25__2010____new_frequency__lifetime_and_percentage_stopwatch_accumulator_features_">Version 0.3.2, January 25, 2010 New frequency,
 lifetime and percentage stopwatch_accumulator features</a></dt>
@@ -43,8 +43,8 @@
</dl></div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h4 class="title">
-<a name="boost_chrono.appendices.history.__version_0_4__febrary_5__2010____new_thread_clock_and_suspendible_clock__"></a><a href="history.html#boost_chrono.appendices.history.__version_0_4__febrary_5__2010____new_thread_clock_and_suspendible_clock__" title="Version 0.4, Febrary 5, 2010 New thread
- clock and Suspendible clock ">Version 0.4, Febrary 5, 2010 New thread
+<a name="boost_chrono.appendices.history.__version_0_4__febrary_31__2010____new_thread_clock_and_suspendible_clock__"></a><a href="history.html#boost_chrono.appendices.history.__version_0_4__febrary_31__2010____new_thread_clock_and_suspendible_clock__" title="Version 0.4, Febrary 31, 2010 New thread
+ clock and Suspendible clock ">Version 0.4, Febrary 31, 2010 New thread
 clock and Suspendible clock </a>
</h4></div></div></div>

@@ -61,10 +61,43 @@
<li>
 thread_clock support on platforms providing it natively.
 </li>
+<li>
+ Added support for wide character for stopwatch_reporter, stopclock, and
+ stopclock_accumulator.
+ </li>
+<li>
+ digital_time renamed t24_hours
+ </li>
</ul></div>

+ Perf
+ 
+
+ Added performances measures.
+ 
+
 Bug Fixes
 
+<div class="itemizedlist"><ul type="disc"><li>
+ Bug on timeval_demo.
+ </li></ul></div>
+<pre class="programlisting">time_point t(duration(xtime(0))); // this was taken as a function declaration
+gettimeofday((timeval*)&t, 0);
+return t;
+</pre>
+
+ time_point t(duration(xtime(0))); // this was taken as a function declaration
+ gettimeofday((timeval*)&t, 0); return t; by
+ 
+<pre class="programlisting">timeval tv;
+gettimeofday(&tv, 0);
+xtime xt( tv.tv_sec, tv.tv_usec);
+return time_point(duration(xt));
+</pre>
+<div class="itemizedlist"><ul type="disc"><li>
+ Bug on run_timer_test (add a global variable to avoid optimization that
+ removes completely the code to be measured
+ </li></ul></div>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h4 class="title">

Added: sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/perf.html
==============================================================================
--- (empty file)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/perf.html 2010-01-31 18:12:37 EST (Sun, 31 Jan 2010)
@@ -0,0 +1,131 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title> Appendix H: Performances</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="../appendices.html" title="Appendices">
+<link rel="prev" href="tickets.html" title=" Appendix G: Tickets">
+<link rel="next" href="todo.html" title=" Appendix I: Future plans">
+</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="tickets.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../appendices.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="todo.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.appendices.perf"></a> Appendix H: Performances
+</h3></div></div></div>
+
+ We have run some program changing how the reporting is done.
+ 
+
+ NONE: no report is done on the inner function HIGH: every call to the recursive
+ function is reported using an stopclock SUSPEND: every call to the recursive
+ function is reported using a using an stopclock on a suspendible clock ACCU:
+ every call to the recursive function is tracked using a stopclock_accumulator
+ 
+
+ We have run the programm with two different clocks, high_resolution_clock
+ and thread_clock.
+ 
+
+ The programs are either single-threaded or multi-threaded.
+ 
+
+ Two kind of inner functions are used: recursive or non recursive. In order
+ to test the influence of nesting reports, the non recursive functions use
+ up to 10 nesting levels, depending on its parameter.
+ 
+
+ the function at level n is defined as follows
+ 
+<pre class="programlisting">void fn(long v) {
+ // reporting or not
+ stopclock<> _;
+ // burn some time
+ for ( long i = 0; i < v; ++i )
+ res+=std::sqrt( res+123.456L+i ); // burn some time
+ if (v==0) return;
+
+ if (v%(n-1)==0) fn-1(v-1);
+ if (v%(n-2)==0) fn-2(v-1);
+ ...
+ f1(v-1);
+}
+</pre>
+
+ This gives a variable number in nesting reporting depending on the parameter,
+ with a variable lifetime.
+ 
+<a name="boost_chrono.appendices.perf.single_threaded_recursive_function"></a><h4>
+<a name="id4936420"></a>
+ <a href="perf.html#boost_chrono.appendices.perf.single_threaded_recursive_function">Single-Threaded
+ Recursive function</a>
+ </h4>
+
+ We have run the same program and changed how the reporting is done.
+ 
+
+ The programm creates two thread of execution. the thread entry point calls
+ a function which makes some calculation depending on its parameter and call
+ recursivelly itself decreasing the parameter.
+ 
+
+ NONE: no report is done on the inner function HIGH: every call to the recursive
+ function is reported using an stopclock SUSPEND: every call to the recursive
+ function is reported using a using an stopclock on a suspendible clock ACCU:
+ every call to the recursive function is tracked using a stopclock_accumulator
+ 
+
+ We have run the programm with two different clocks, high_resolution_clock
+ and thread_clock.
+ 
+<a name="boost_chrono.appendices.perf.multi_threaded_recursive_function"></a><h4>
+<a name="id4936469"></a>
+ <a href="perf.html#boost_chrono.appendices.perf.multi_threaded_recursive_function">Multi-Threaded
+ Recursive function</a>
+ </h4>
+
+ We have run the same program and changed how the reporting is done.
+ 
+
+ The programm creates two thread of execution. the thread entry point calls
+ a function which makes some calculation depending on its parameter and call
+ recursivelly itself decreasing the parameter.
+ 
+
+ NONE: no report is done on the inner function HIGH: every call to the recursive
+ function is reported using an stopclock SUSPEND: every call to the recursive
+ function is reported using a using an stopclock on a suspendible clock ACCU:
+ every call to the recursive function is tracked using a stopclock_accumulator
+ 
+
+ We have run the programm with two different clocks, high_resolution_clock
+ and thread_clock.
+ 
+</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 -2010 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="tickets.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../appendices.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="todo.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

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 2010-01-31 18:12:37 EST (Sun, 31 Jan 2010)
@@ -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="id4918998"></a>
+<a name="id4931634"></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="id4919088"></a>
+<a name="id4931724"></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="id4919668"></a>
+<a name="id4932304"></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>
@@ -101,7 +101,7 @@
 ratio<1,3> and the compilation succeeds.
 
<a name="boost_chrono.appendices.rationale.why_ratio_needs_the_nested_normalizer_typedef_type"></a><h4>
-<a name="id4919981"></a>
+<a name="id4932618"></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/tests.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/tests.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/tests.html 2010-01-31 18:12:37 EST (Sun, 31 Jan 2010)
@@ -1039,7 +1039,7 @@
<tr>
<td>
 
- digital_time_example
+ t24_hours_example
 
 </td>
<td>

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/tickets.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/tickets.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/tickets.html 2010-01-31 18:12:37 EST (Sun, 31 Jan 2010)
@@ -7,7 +7,7 @@
<link rel="start" href="../../index.html" title="Boost.Chrono">
<link rel="up" href="../appendices.html" title="Appendices">
<link rel="prev" href="tests.html" title=" Appendix F: Tests">
-<link rel="next" href="todo.html" title=" Appendix H: Future plans">
+<link rel="next" href="perf.html" title=" Appendix H: Performances">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
@@ -20,7 +20,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="tests.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../appendices.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="todo.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="tests.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../appendices.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="perf.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">
@@ -614,7 +614,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="tests.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../appendices.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="todo.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="tests.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../appendices.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="perf.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
</body>
</html>

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 2010-01-31 18:12:37 EST (Sun, 31 Jan 2010)
@@ -1,12 +1,12 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title> Appendix H: Future plans</title>
+<title> Appendix I: Future plans</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="../appendices.html" title="Appendices">
-<link rel="prev" href="tickets.html" title=" Appendix G: Tickets">
+<link rel="prev" href="perf.html" title=" Appendix H: Performances">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
@@ -19,14 +19,14 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="tickets.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../appendices.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="p" href="perf.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../appendices.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>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_chrono.appendices.todo"></a> Appendix H: Future plans
+<a name="boost_chrono.appendices.todo"></a> Appendix I: Future plans
</h3></div></div></div>
<a name="boost_chrono.appendices.todo.tasks_to_do_before_review"></a><h4>
-<a name="id4923292"></a>
+<a name="id4936535"></a>
 <a href="todo.html#boost_chrono.appendices.todo.tasks_to_do_before_review">Tasks
 to do before review</a>
 </h4>
@@ -42,7 +42,7 @@
 </li>
</ul></div>
<a name="boost_chrono.appendices.todo.for_later_releases"></a><h4>
-<a name="id4923331"></a>
+<a name="id4936574"></a>
 <a href="todo.html#boost_chrono.appendices.todo.for_later_releases">For later
 releases</a>
 </h4>
@@ -65,7 +65,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="tickets.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../appendices.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="p" href="perf.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../appendices.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>
</div>
</body>
</html>

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 2010-01-31 18:12:37 EST (Sun, 31 Jan 2010)
@@ -798,10 +798,10 @@
 // ...
}
</pre>
-<a name="boost_chrono.overview.motivation.stopwatches.how_reliable_are_these_measure_"></a><h5>
+<a name="boost_chrono.overview.motivation.stopwatches.how_reliable_are_these_measures_"></a><h5>
<a name="id4817380"></a>
- <a href="motivation.html#boost_chrono.overview.motivation.stopwatches.how_reliable_are_these_measure_">How
- reliable are these measure?</a>
+ <a href="motivation.html#boost_chrono.overview.motivation.stopwatches.how_reliable_are_these_measures_">How
+ reliable are these measures?</a>
 </h5>

 [info this section need to be reworked, the ideas are there, but ...]
@@ -817,44 +817,73 @@
 that gives you the higher resolution available on your platform. Respect
 to the precission, nothing to do except to take the clock with the highest
 resolution and measures blocks of code that will spent time having more
- than one order of magnitude.
- </li>
+ than one order of magnitude the precission of the clock.
+ <div class="orderedlist"><ol type="a"><li>
+ include <boost/chrono/thread_clock.hpp> ... stopclock<high_resolution_clock>
+ _;
+ </li></ol></div>
+</li>
<li>
 When your application is multithreaded, and you use a process clock,
 the time you get is the delay during which your block has been executed,
- in concurrency with the other threads of execution. The library provide
- a thread_clock on platforms providing this kind of data.
- </li>
+ in concurrency with the other threads of execution. If what you want
+ is the time spent by this specific thread another clock is needed. The
+ library provide a thread_clock that returns the time spent by the thread
+ on platforms providing this kind of data. It can be used as follows
+ <div class="orderedlist"><ol type="a">
+<li>
+ include <boost/chrono/thread_clock.hpp> ...
+ </li>
+<li>
+ if defined(BOOST_CHRONO_HAS_THREAD_CLOCK) stopclock<thread_clock>
+ _;
+ </li>
+<li>
+ else stopclock<process_real_cpu_clock> _;
+ </li>
+<li>
+ endif
+ </li>
+</ol></div>
+</li>
<li>
 Nested stopclocks (usually nested function calls where each function
 contains a stopclock). When the nesting is deep enough, the cumulative
 overhead of all the stopclock functionality make the data unreliable
- except for the inner-most trace points. The question is,how many time
- is related to the application code we want to measure and how many to
+ except for the inner-most trace points. The question is, how much time
+ is related to the application code we want to measure and how much to
 the fact we are meassuring and logging in inner blocks?
 </li>
</ol></div>

- Some measures let me think that most of the time spent by the stopclock
+ Some measures let us think that most of the time spent by the stopclock
 mechanism is associated to the logging part. There are two things we can
 do to make the difference :
 
<div class="itemizedlist"><ul type="disc">
<li>
- Avoid the expensive operations as reporting while doing the measures.
- Note that reporting in itself is not too expensive as far as we don't
- need to flush the buffer. This can be achieved either using a stopclock
- accumulator, 'i.e. don't report until all the measures have been compiled
- and then report some statistics) or using an asynchronous stream.
+ Avoid expensive operations as logging while doing the measures. Note
+ that reporting in itself is not too expensive as far as we don't need
+ to flush the buffer. This can be achieved either using a stopclock accumulator,
+ 'i.e. don't report until all the measures have been compiled and then
+ report some statistics or using an asynchronous stream.
 </li>
<li>
 Introduce some cheap mechanism that allows us to make the difference
 between the application time and the intrinsec stopclock time. When the
 precission of the clock is enough, we can suspend the counting of the
- Clock while we are speending time reporting the measures, and resume
- it once the work is done.
+ Clock while we are spending time reporting the measures, and resume it
+ once the work is done. The library provide a Clock wrapper suspendible_clock
+ that make the resulting clock suspendible. The stopwatch_reporter is
+ able to detect if the CLock is Suspendible and then suspend/resume the
+ clock while doing the report.
 </li>
</ul></div>
+<pre class="programlisting">stopclock<suspendible_clock<Clock> > _;
+</pre>
+
+ See the performances section for more deep details.
+ 
</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 2010-01-31 18:12:37 EST (Sun, 31 Jan 2010)
@@ -80,10 +80,10 @@
 Header <code class="computeroutput"><boost/chrono/stopwatch_accumulator_formatter.hpp></code></a></dt>
<dt><a href="reference/stopwatch_formatters.html#boost_chrono.reference.stopwatch_formatters.time_formatter_hpp">
 Header <code class="computeroutput"><boost/chrono/time_formatter.hpp></code></a></dt>
-<dt><a href="reference/stopwatch_formatters.html#boost_chrono.reference.stopwatch_formatters.digital_time_hpp">
- Header <code class="computeroutput"><boost/chrono/digital_time.hpp></code></a></dt>
-<dt><a href="reference/stopwatch_formatters.html#boost_chrono.reference.stopwatch_formatters.digital_time_formatter_hpp">
- Header <code class="computeroutput"><boost/chrono/digital_time_formatter.hpp></code></a></dt>
+<dt><a href="reference/stopwatch_formatters.html#boost_chrono.reference.stopwatch_formatters.t24_hours_hpp">
+ Header <code class="computeroutput"><boost/chrono/t24_hours.hpp></code></a></dt>
+<dt><a href="reference/stopwatch_formatters.html#boost_chrono.reference.stopwatch_formatters.t24_hours_formatter_hpp">
+ Header <code class="computeroutput"><boost/chrono/t24_hours_formatter.hpp></code></a></dt>
</dl></dd>
<dt><a href="reference/deprecated_headers.html">Deprecated
 Headers</a></dt>

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/cpp0x.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/cpp0x.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/cpp0x.html 2010-01-31 18:12:37 EST (Sun, 31 Jan 2010)
@@ -608,7 +608,7 @@
and both of these calls happen before <code class="computeroutput">C1::time_point::max()</code>.

<div class="table">
-<a name="id4839281"></a>Table 1. Clock Requirements
+<a name="id4839379"></a>Table 1. Clock Requirements
<table class="table" summary="Clock Requirements">
<colgroup>
<col>

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/stopwatch_formatters.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/stopwatch_formatters.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/stopwatch_formatters.html 2010-01-31 18:12:37 EST (Sun, 31 Jan 2010)
@@ -44,14 +44,14 @@
 Header <code class="computeroutput"><boost/chrono/time_formatter.hpp></code></a></dt>
<dd><dl><dt><a href="stopwatch_formatters.html#boost_chrono.reference.stopwatch_formatters.time_formatter_hpp.template_class__basic_time_formatter___">Template
 Class <code class="computeroutput">basic_time_formatter<></code></a></dt></dl></dd>
-<dt><a href="stopwatch_formatters.html#boost_chrono.reference.stopwatch_formatters.digital_time_hpp">
- Header <code class="computeroutput"><boost/chrono/digital_time.hpp></code></a></dt>
-<dd><dl><dt><a href="stopwatch_formatters.html#boost_chrono.reference.stopwatch_formatters.digital_time_hpp.class__digital_time_">Class
- <code class="computeroutput">digital_time</code></a></dt></dl></dd>
-<dt><a href="stopwatch_formatters.html#boost_chrono.reference.stopwatch_formatters.digital_time_formatter_hpp">
- Header <code class="computeroutput"><boost/chrono/digital_time_formatter.hpp></code></a></dt>
-<dd><dl><dt><a href="stopwatch_formatters.html#boost_chrono.reference.stopwatch_formatters.digital_time_formatter_hpp.template_class__basic_digital_time_formatter___">Template
- Class <code class="computeroutput">basic_digital_time_formatter<></code></a></dt></dl></dd>
+<dt><a href="stopwatch_formatters.html#boost_chrono.reference.stopwatch_formatters.t24_hours_hpp">
+ Header <code class="computeroutput"><boost/chrono/t24_hours.hpp></code></a></dt>
+<dd><dl><dt><a href="stopwatch_formatters.html#boost_chrono.reference.stopwatch_formatters.t24_hours_hpp.class__t24_hours_">Class
+ <code class="computeroutput">t24_hours</code></a></dt></dl></dd>
+<dt><a href="stopwatch_formatters.html#boost_chrono.reference.stopwatch_formatters.t24_hours_formatter_hpp">
+ Header <code class="computeroutput"><boost/chrono/t24_hours_formatter.hpp></code></a></dt>
+<dd><dl><dt><a href="stopwatch_formatters.html#boost_chrono.reference.stopwatch_formatters.t24_hours_formatter_hpp.template_class__basic_24_hours_formatter___">Template
+ Class <code class="computeroutput">basic_24_hours_formatter<></code></a></dt></dl></dd>
</dl></div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h4 class="title">
@@ -297,23 +297,23 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h4 class="title">
-<a name="boost_chrono.reference.stopwatch_formatters.digital_time_hpp"></a><a href="stopwatch_formatters.html#boost_chrono.reference.stopwatch_formatters.digital_time_hpp" title="
- Header <boost/chrono/digital_time.hpp>">
- Header <code class="computeroutput"><boost/chrono/digital_time.hpp></code></a>
+<a name="boost_chrono.reference.stopwatch_formatters.t24_hours_hpp"></a><a href="stopwatch_formatters.html#boost_chrono.reference.stopwatch_formatters.t24_hours_hpp" title="
+ Header <boost/chrono/t24_hours.hpp>">
+ Header <code class="computeroutput"><boost/chrono/t24_hours.hpp></code></a>
</h4></div></div></div>
-<div class="toc"><dl><dt><a href="stopwatch_formatters.html#boost_chrono.reference.stopwatch_formatters.digital_time_hpp.class__digital_time_">Class
- <code class="computeroutput">digital_time</code></a></dt></dl></div>
+<div class="toc"><dl><dt><a href="stopwatch_formatters.html#boost_chrono.reference.stopwatch_formatters.t24_hours_hpp.class__t24_hours_">Class
+ <code class="computeroutput">t24_hours</code></a></dt></dl></div>
<pre class="programlisting">namespace boost { namespace chrono {
- class digital_time;
+ class t24_hours;
}}
</pre>
<div class="section" lang="en">
<div class="titlepage"><div><div><h5 class="title">
-<a name="boost_chrono.reference.stopwatch_formatters.digital_time_hpp.class__digital_time_"></a><a href="stopwatch_formatters.html#boost_chrono.reference.stopwatch_formatters.digital_time_hpp.class__digital_time_" title="Class
- digital_time">Class
- <code class="computeroutput">digital_time</code></a>
+<a name="boost_chrono.reference.stopwatch_formatters.t24_hours_hpp.class__t24_hours_"></a><a href="stopwatch_formatters.html#boost_chrono.reference.stopwatch_formatters.t24_hours_hpp.class__t24_hours_" title="Class
+ t24_hours">Class
+ <code class="computeroutput">t24_hours</code></a>
</h5></div></div></div>
-<pre class="programlisting">class digital_time {
+<pre class="programlisting">class t24_hours {
public:
 typedef boost::chrono::duration<boost::int_least32_t, ratio<24*3600> > days;
 typedef boost::chrono::hours hours;
@@ -328,19 +328,19 @@
 nanoseconds nanoseconds_;

 template <class Rep, class Period>
- explicit digital_time(const boost::chrono::duration<Rep, Period>& d);
+ explicit t24_hours(const boost::chrono::duration<Rep, Period>& d);
};
</pre>
</div>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h4 class="title">
-<a name="boost_chrono.reference.stopwatch_formatters.digital_time_formatter_hpp"></a><a href="stopwatch_formatters.html#boost_chrono.reference.stopwatch_formatters.digital_time_formatter_hpp" title="
- Header <boost/chrono/digital_time_formatter.hpp>">
- Header <code class="computeroutput"><boost/chrono/digital_time_formatter.hpp></code></a>
+<a name="boost_chrono.reference.stopwatch_formatters.t24_hours_formatter_hpp"></a><a href="stopwatch_formatters.html#boost_chrono.reference.stopwatch_formatters.t24_hours_formatter_hpp" title="
+ Header <boost/chrono/t24_hours_formatter.hpp>">
+ Header <code class="computeroutput"><boost/chrono/t24_hours_formatter.hpp></code></a>
</h4></div></div></div>
-<div class="toc"><dl><dt><a href="stopwatch_formatters.html#boost_chrono.reference.stopwatch_formatters.digital_time_formatter_hpp.template_class__basic_digital_time_formatter___">Template
- Class <code class="computeroutput">basic_digital_time_formatter<></code></a></dt></dl></div>
+<div class="toc"><dl><dt><a href="stopwatch_formatters.html#boost_chrono.reference.stopwatch_formatters.t24_hours_formatter_hpp.template_class__basic_24_hours_formatter___">Template
+ Class <code class="computeroutput">basic_24_hours_formatter<></code></a></dt></dl></div>
<pre class="programlisting">namespace boost { namespace chrono {

 template <
@@ -348,21 +348,21 @@
 typename Traits=std::char_traits<CharT>,
 class Alloc=std::allocator<CharT>
 >
- class basic_digital_time_formatter;
+ class basic_24_hours_formatter;

- typedef basic_digital_time_formatter<char> digital_time_formatter;
- typedef basic_digital_time_formatter<wchar_t> wdigital_time_formatter;
+ typedef basic_24_hours_formatter<char> t24_hours_formatter;
+ typedef basic_24_hours_formatter<wchar_t> wt24_hours_formatter;

} }
</pre>
<div class="section" lang="en">
<div class="titlepage"><div><div><h5 class="title">
-<a name="boost_chrono.reference.stopwatch_formatters.digital_time_formatter_hpp.template_class__basic_digital_time_formatter___"></a><a href="stopwatch_formatters.html#boost_chrono.reference.stopwatch_formatters.digital_time_formatter_hpp.template_class__basic_digital_time_formatter___" title="Template
- Class basic_digital_time_formatter<>">Template
- Class <code class="computeroutput">basic_digital_time_formatter<></code></a>
+<a name="boost_chrono.reference.stopwatch_formatters.t24_hours_formatter_hpp.template_class__basic_24_hours_formatter___"></a><a href="stopwatch_formatters.html#boost_chrono.reference.stopwatch_formatters.t24_hours_formatter_hpp.template_class__basic_24_hours_formatter___" title="Template
+ Class basic_24_hours_formatter<>">Template
+ Class <code class="computeroutput">basic_24_hours_formatter<></code></a>
</h5></div></div></div>
<pre class="programlisting">template <typename CharT, typename Traits, class Alloc>
-class basic_digital_time_formatter {
+class basic_24_hours_formatter {
public:
 static std::ostream & default_os();
 static const char * default_format();

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/stopwatch_reporters.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/stopwatch_reporters.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/stopwatch_reporters.html 2010-01-31 18:12:37 EST (Sun, 31 Jan 2010)
@@ -35,21 +35,37 @@
<dt>Formatter related traits</dt>
<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><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></dl></dd>
+<dd><dl>
+<dt><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopwatch_reporter_hpp.template_class__basic_stopwatch_reporter___">Template
+ Class <code class="computeroutput">basic_stopwatch_reporter<></code></a></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><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopwatch_reporter_hpp.template_class__wstopwatch_reporter___">Template
+ Class <code class="computeroutput">wstopwatch_reporter<></code></a></dt>
+</dl></dd>
<dt><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopclock_hpp">
 Header <code class="computeroutput"><boost/chrono/stopclock.hpp></code></a></dt>
<dd><dl>
+<dt><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopclock_hpp.template_class__basic_stopclock___">Template
+ Class <code class="computeroutput">basic_stopclock<></code></a></dt>
<dt><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopclock_hpp.template_class__stopclock___">Template
 Class <code class="computeroutput">stopclock<></code></a></dt>
<dt>stopclock useful typedefs</dt>
+<dt><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopclock_hpp.template_class__wstopclock___">Template
+ Class <code class="computeroutput">wstopclock<></code></a></dt>
+<dt>wstopclock useful typedefs</dt>
</dl></dd>
<dt><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopclock_accumulator_hpp">
 Header <code class="computeroutput"><boost/chrono/stopclock_accumulator.hpp></code></a></dt>
<dd><dl>
+<dt><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopclock_accumulator_hpp.template_class__basic_stopclock_accumulator___">Template
+ Class <code class="computeroutput">basic_stopclock_accumulator<></code></a></dt>
<dt><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopclock_accumulator_hpp.template_class__stopclock_accumulator___">Template
 Class <code class="computeroutput">stopclock_accumulator<></code></a></dt>
<dt>stopclock_accumulator useful typedefs</dt>
+<dt><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopclock_accumulator_hpp.template_class__wstopclock_accumulator___">Template
+ Class <code class="computeroutput">wstopclock_accumulator<></code></a></dt>
+<dt>wstopclock_accumulator useful typedefs</dt>
</dl></dd>
<dt><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.scoped_stopclock_hpp">
 Header <code class="computeroutput"><boost/chrono/scoped_stopclock.hpp></code></a></dt>
@@ -78,7 +94,7 @@
 <code class="computeroutput">std::ostream</code>, ec is a system::error_code
 
<div class="table">
-<a name="id4871272"></a>Table 3. Stopwatch Requirements
+<a name="id4871962"></a>Table 3. Stopwatch Requirements
<table class="table" summary="Stopwatch Requirements">
<colgroup>
<col>
@@ -200,11 +216,21 @@
 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><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></dl></div>
+<div class="toc"><dl>
+<dt><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopwatch_reporter_hpp.template_class__basic_stopwatch_reporter___">Template
+ Class <code class="computeroutput">basic_stopwatch_reporter<></code></a></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><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopwatch_reporter_hpp.template_class__wstopwatch_reporter___">Template
+ Class <code class="computeroutput">wstopwatch_reporter<></code></a></dt>
+</dl></div>
<pre class="programlisting">namespace boost { namespace chrono {
 template <class Stopwatch>
+ struct basic_stopwatch_reporter_default_formatter;
+ template <class Stopwatch>
 struct stopwatch_reporter_default_formatter;
+ template <class Stopwatch>
+ struct wstopwatch_reporter_default_formatter;

 template <class Stopwatch, class Formatter=typename stopwatch_reporter_default_formatter<Stopwatch>::type>
 class stopwatch_reporter;
@@ -212,6 +238,75 @@
</pre>
<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__basic_stopwatch_reporter___"></a><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopwatch_reporter_hpp.template_class__basic_stopwatch_reporter___" title="Template
+ Class basic_stopwatch_reporter<>">Template
+ Class <code class="computeroutput">basic_stopwatch_reporter<></code></a>
+</h5></div></div></div>
+
+ class <code class="computeroutput">basic_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 basic_stopwatch_reporter : public Stopwatch {
+public:
+ typedef typename Stopwatch::clock clock;
+ typedef Stopwatch stopwatch;
+ typedef Formatter formatter;
+
+ explicit basic_stopwatch_reporter( system::error_code & ec = system::throws );
+ explicit basic_stopwatch_reporter( std::ostream & os,
+ system::error_code & ec = system::throws );
+
+ explicit basic_stopwatch_reporter( const std::string & format,
+ system::error_code & ec = system::throws );
+ explicit basic_stopwatch_reporter( std::ostream & os, const std::string & format,
+ system::error_code & ec = system::throws );
+
+ explicit basic_stopwatch_reporter( const std::string & format, int places,
+ system::error_code & ec = system::throws );
+ explicit basic_stopwatch_reporter( std::ostream & os, const std::string & format, int places,
+ system::error_code & ec = system::throws );
+
+ explicit basic_stopwatch_reporter( int places,
+ system::error_code & ec = system::throws );
+ explicit basic_stopwatch_reporter( std::ostream & os, int places,
+ system::error_code & ec = system::throws );
+
+ explicit basic_stopwatch_reporter( int places, const std::string & format,
+ system::error_code & ec = system::throws );
+ explicit basic_stopwatch_reporter( std::ostream & os, int places, const std::string & format,
+ system::error_code & ec = system::throws );
+
+ ~basic_stopwatch_reporter();
+
+ void report( system::error_code & ec = system::throws );
+ bool reported() const;
+
+
+ typedef stopwatch_runner<basic_stopwatch_reporter<Stopwatch> > scoped_run;
+ typedef stopwatch_suspender<basic_stopwatch_reporter<Stopwatch> > scoped_suspend;
+ typedef stopwatch_resumer<basic_stopwatch_reporter<Stopwatch> > scoped_resume;
+};
+</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.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>
@@ -237,7 +332,7 @@
 The default format is given by Formatter::default_format().
 
<pre class="programlisting">template <class Stopwatch, class Formatter>
-class stopwatch_reporter : public Stopwatch {
+class stopwatch_reporter : public basic_stopwatch_reporter<Stopwatch,Formatter> {
public:
 typedef typename Stopwatch::clock clock;
 typedef Stopwatch stopwatch;
@@ -296,6 +391,92 @@
}
</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.template_class__wstopwatch_reporter___"></a><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopwatch_reporter_hpp.template_class__wstopwatch_reporter___" title="Template
+ Class wstopwatch_reporter<>">Template
+ Class <code class="computeroutput">wstopwatch_reporter<></code></a>
+</h5></div></div></div>
+
+ class <code class="computeroutput">wstopwatch_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 wstopwatch_reporter : public basic_wstopwatch_reporter<Stopwatch,Formatter> {
+public:
+ typedef typename Stopwatch::clock clock;
+ typedef Stopwatch stopwatch;
+ typedef Formatter formatter;
+
+ explicit wstopwatch_reporter( system::error_code & ec = system::throws );
+ explicit wstopwatch_reporter( std::ostream & os,
+ system::error_code & ec = system::throws );
+
+ explicit wstopwatch_reporter( const std::string & format,
+ system::error_code & ec = system::throws );
+ explicit wstopwatch_reporter( std::ostream & os, const std::string & format,
+ system::error_code & ec = system::throws );
+
+ explicit wstopwatch_reporter( const std::string & format, int places,
+ system::error_code & ec = system::throws );
+ explicit wstopwatch_reporter( std::ostream & os, const std::string & format, int places,
+ system::error_code & ec = system::throws );
+
+ explicit wstopwatch_reporter( int places,
+ system::error_code & ec = system::throws );
+ explicit wstopwatch_reporter( std::ostream & os, int places,
+ system::error_code & ec = system::throws );
+
+ explicit wstopwatch_reporter( int places, const std::string & format,
+ system::error_code & ec = system::throws );
+ explicit wstopwatch_reporter( std::ostream & os, int places, const std::string & format,
+ system::error_code & ec = system::throws );
+
+ ~wstopwatch_reporter();
+
+ void report( system::error_code & ec = system::throws );
+ bool reported() const;
+
+
+ typedef stopwatch_runner<wstopwatch_reporter<Stopwatch> > scoped_run;
+ typedef stopwatch_suspender<wstopwatch_reporter<Stopwatch> > scoped_suspend;
+ typedef stopwatch_resumer<wstopwatch_reporter<Stopwatch> > scoped_resume;
+};
+</pre>
+
+ Usage
+ 
+<pre class="programlisting">void f1()
+{
+ typedef wstopwatch_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>
<div class="section" lang="en">
<div class="titlepage"><div><div><h4 class="title">
@@ -304,12 +485,20 @@
 Header <code class="computeroutput"><boost/chrono/stopclock.hpp></code></a>
</h4></div></div></div>
<div class="toc"><dl>
+<dt><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopclock_hpp.template_class__basic_stopclock___">Template
+ Class <code class="computeroutput">basic_stopclock<></code></a></dt>
<dt><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopclock_hpp.template_class__stopclock___">Template
 Class <code class="computeroutput">stopclock<></code></a></dt>
<dt>stopclock useful typedefs</dt>
+<dt><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopclock_hpp.template_class__wstopclock___">Template
+ Class <code class="computeroutput">wstopclock<></code></a></dt>
+<dt>wstopclock useful typedefs</dt>
</dl></div>
<pre class="programlisting">namespace boost { namespace chrono {
+ template < class Clock, class Formatter > class basic_stopclock;
 template < class Clock, class Formatter > class stopclock;
+ template < class Clock, class Formatter > class wstopclock;
+
 typedef <see above> system_stopclock;
 #ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
 typedef <see above> monotonic_stopclock;
@@ -318,22 +507,80 @@
 typedef <see above> process_real_cpu_stopclock;
 typedef <see above> process_user_cpu_stopclock;
 typedef <see above> process_system_cpu_stopclock;
+
+ typedef <see above> system_wstopclock;
+ #ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
+ typedef <see above> monotonic_wstopclock;
+ #endif
+ typedef <see above> high_resolution_wstopclock;
+ typedef <see above> process_real_cpu_wstopclock;
+ typedef <see above> process_user_cpu_wstopclock;
+ typedef <see above> process_system_cpu_wstopclock;
}}
</pre>
<div class="section" lang="en">
<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.stopwatch_reporters.stopclock_hpp.template_class__basic_stopclock___"></a><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopclock_hpp.template_class__basic_stopclock___" title="Template
+ Class basic_stopclock<>">Template
+ Class <code class="computeroutput">basic_stopclock<></code></a>
+</h5></div></div></div>
+
+ <code class="computeroutput">basic_stopclock<Clock></code>
+ template class is a shortcut of <code class="computeroutput">basic_stopwatch_reporter<stopwatch<Clock>></code>
+ 
+<pre class="programlisting">template< class Clock, class Formatter>
+class basic_stopclock : public basic_stopwatch_reporter<stopwatch<Clock>, Formatter> {
+public:
+ typedef Clock clock;
+ typedef stopwatch<Clock> stopwatch;
+ typedef Formatter formatter;
+ typedef typename Formatter::string_type string_type;
+ typedef typename Formatter::char_type char_type;
+ typedef typename Formatter::ostream_type ostream_type;
+
+ explicit basic_stopclock( system::error_code & ec = system::throws );
+ explicit basic_stopclock( ostream_type & os,
+ system::error_code & ec = system::throws );
+ explicit basic_stopclock( const string_type & format,
+ system::error_code & ec = system::throws );
+ explicit basic_stopclock( int places,
+ system::error_code & ec = system::throws );
+
+ basic_stopclock( ostream_type & os, const string_type & format,
+ system::error_code & ec = system::throws );
+ basic_stopclock( const string_type & format, int places,
+ system::error_code & ec = system::throws );
+ basic_stopclock( ostream_type & os, int places,
+ system::error_code & ec = system::throws );
+ basic_stopclock( int places, const string_type & format,
+ system::error_code & ec = system::throws );
+
+ basic_stopclock( ostream_type & os, const string_type & format, int places,
+ system::error_code & ec = system::throws );
+ basic_stopclock( ostream_type & os, int places, const string_type & format,
+ system::error_code & ec = system::throws );
+
+
+ typedef typename base_type::scoped_run scoped_run;
+ typedef typename base_type::scoped_suspend scoped_suspend;
+ typedef typename base_type::scoped_resume scoped_resume;
+};
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
<a name="boost_chrono.reference.stopwatch_reporters.stopclock_hpp.template_class__stopclock___"></a><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopclock_hpp.template_class__stopclock___" title="Template
 Class stopclock<>">Template
 Class <code class="computeroutput">stopclock<></code></a>
</h5></div></div></div>

 <code class="computeroutput">stopclock<Clock></code>
- template class is a shortcut of <code class="computeroutput">stopwatch_reporter<stopwatch<Clock>></code>
+ template class is a shortcut of <code class="computeroutput">stopwatch_reporter<stopwatch<Clock>></code> with a specific default formatter.
 
<pre class="programlisting">template
 < class Clock=process_cpu_clock
 , class Formatter=typename stopwatch_reporter_default_formatter<stopwatch<Clock>>::type
-> class stopclock : public stopwatch_reporter<stopwatch<Clock>, Formatter> {
+> class stopclock : public basic_stopclock<Clock, Formatter> {
public:
 typedef Clock clock;
 typedef stopwatch<Clock> stopwatch;
@@ -385,6 +632,71 @@
typedef boost::chrono::stopclock< boost::chrono::process_system_cpu_clock > process_system_cpu_stopclock;
</pre>
</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.stopwatch_reporters.stopclock_hpp.template_class__wstopclock___"></a><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopclock_hpp.template_class__wstopclock___" title="Template
+ Class wstopclock<>">Template
+ Class <code class="computeroutput">wstopclock<></code></a>
+</h5></div></div></div>
+
+ <code class="computeroutput">wstopclock<Clock></code>
+ template class is a shortcut of <code class="computeroutput">stopwatch_reporter<stopwatch<Clock>></code> with a specific default formatter.
+ 
+<pre class="programlisting">template
+ < class Clock=process_cpu_clock
+ , class Formatter=typename stopwatch_reporter_default_formatter<stopwatch<Clock>>::type
+> class wstopclock : public basic_wstopclock<Clock, Formatter> {
+public:
+ typedef Clock clock;
+ typedef stopwatch<Clock> stopwatch;
+ typedef Formatter formatter;
+ typedef typename Formatter::string_type string_type;
+ typedef typename Formatter::char_type char_type;
+ typedef typename Formatter::ostream_type ostream_type;
+
+ explicit wstopclock( system::error_code & ec = system::throws );
+ explicit wstopclock( ostream_type & os,
+ system::error_code & ec = system::throws );
+ explicit wstopclock( const string_type & format,
+ system::error_code & ec = system::throws );
+ explicit wstopclock( int places,
+ system::error_code & ec = system::throws );
+
+ wstopclock( ostream_type & os, const string_type & format,
+ system::error_code & ec = system::throws );
+ wstopclock( const string_type & format, int places,
+ system::error_code & ec = system::throws );
+ wstopclock( ostream_type & os, int places,
+ system::error_code & ec = system::throws );
+ wstopclock( int places, const string_type & format,
+ system::error_code & ec = system::throws );
+
+ wstopclock( ostream_type & os, const string_type & format, int places,
+ system::error_code & ec = system::throws );
+ wstopclock( ostream_type & os, int places, const string_type & format,
+ system::error_code & ec = system::throws );
+
+
+ typedef typename base_type::scoped_run scoped_run;
+ typedef typename base_type::scoped_suspend scoped_suspend;
+ typedef typename base_type::scoped_resume scoped_resume;
+};
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.stopwatch_reporters.stopclock_hpp._wstopclock__useful_typedefs"></a>wstopclock useful typedefs
+</h5></div></div></div>
+<pre class="programlisting">typedef boost::chrono::wstopclock< boost::chrono::system_clock > system_stopwatch_reporter;
+#ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
+typedef boost::chrono::wstopclock< boost::chrono::monotonic_clock > monotonic_stopwatch_reporter;
+#endif
+typedef boost::chrono::wstopclock< boost::chrono::high_resolution_clock > high_resolution_wstopclock;
+typedef boost::chrono::wstopclock< boost::chrono::process_real_cpu_clock > process_real_cpu_wstopclock;
+typedef boost::chrono::wstopclock< boost::chrono::process_user_cpu_clock > process_user_cpu_wstopclock;
+typedef boost::chrono::wstopclock< boost::chrono::process_system_cpu_clock > process_system_cpu_wstopclock;
+</pre>
+</div>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h4 class="title">
@@ -393,13 +705,23 @@
 Header <code class="computeroutput"><boost/chrono/stopclock_accumulator.hpp></code></a>
</h4></div></div></div>
<div class="toc"><dl>
+<dt><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopclock_accumulator_hpp.template_class__basic_stopclock_accumulator___">Template
+ Class <code class="computeroutput">basic_stopclock_accumulator<></code></a></dt>
<dt><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopclock_accumulator_hpp.template_class__stopclock_accumulator___">Template
 Class <code class="computeroutput">stopclock_accumulator<></code></a></dt>
<dt>stopclock_accumulator useful typedefs</dt>
+<dt><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopclock_accumulator_hpp.template_class__wstopclock_accumulator___">Template
+ Class <code class="computeroutput">wstopclock_accumulator<></code></a></dt>
+<dt>wstopclock_accumulator useful typedefs</dt>
</dl></div>
<pre class="programlisting">namespace boost { namespace chrono {
 template < class Clock, class Formatter >
+ class basic_stopclock_accumulator;
+ template < class Clock, class Formatter >
 class stopclock_accumulator;
+ template < class Clock, class Formatter >
+ class wstopclock_accumulator;
+
 typedef <see above> system_stopclock_accumulator;
 #ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
 typedef <see above> monotonic_stopclock_accumulator;
@@ -408,10 +730,71 @@
 typedef <see above> process_real_cpu_stopclock_accumulator;
 typedef <see above> process_user_cpu_stopclock_accumulator;
 typedef <see above> process_system_cpu_stopclock_accumulator;
+
+ typedef <see above> system_wstopclock_accumulator;
+ #ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
+ typedef <see above> monotonic_wstopclock_accumulator;
+ #endif
+ typedef <see above> high_resolution_wstopclock_accumulator;
+ typedef <see above> process_real_cpu_wstopclock_accumulator;
+ typedef <see above> process_user_cpu_wstopclock_accumulator;
+ typedef <see above> process_system_cpu_wstopclock_accumulator;
}}
</pre>
<div class="section" lang="en">
<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.stopwatch_reporters.stopclock_accumulator_hpp.template_class__basic_stopclock_accumulator___"></a><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopclock_accumulator_hpp.template_class__basic_stopclock_accumulator___" title="Template
+ Class basic_stopclock_accumulator<>">Template
+ Class <code class="computeroutput">basic_stopclock_accumulator<></code></a>
+</h5></div></div></div>
+
+ <code class="computeroutput">basic_stopclock_accumulator<Clock></code> template class is a shortcut of
+ <code class="computeroutput">stopwatch_reporter<stopwatch<Clock>></code>
+ 
+<pre class="programlisting">template
+ < class Clock=high_resolution_clock
+ , class Formatter=typename stopwatch_reporter_default_formatter<stopwatch_accumulator<Clock>>::type
+> class basic_stopclock_accumulator
+ : public basic_stopwatch_reporter<stopwatch_accumulator<Clock>, Formatter> {
+public:
+ typedef Clock clock;
+ typedef stopwatch_accumulator<Clock> stopwatch;
+ typedef Formatter formatter;
+ typedef typename Formatter::string_type string_type;
+ typedef typename Formatter::char_type char_type;
+ typedef typename Formatter::ostream_type ostream_type;
+
+ explicit basic_stopclock_accumulator( system::error_code & ec = system::throws );
+ explicit basic_stopclock_accumulator( ostream_type & os,
+ system::error_code & ec = system::throws );
+ explicit basic_stopclock_accumulator( const string_type & format,
+ system::error_code & ec = system::throws );
+ explicit basic_stopclock_accumulator( int places,
+ system::error_code & ec = system::throws );
+
+ basic_stopclock_accumulator( ostream_type & os, const string_type & format,
+ system::error_code & ec = system::throws );
+ basic_stopclock_accumulator( const string_type & format, int places,
+ system::error_code & ec = system::throws );
+ basic_stopclock_accumulator( ostream_type & os, int places,
+ system::error_code & ec = system::throws );
+ basic_stopclock_accumulator( int places, const string_type & format,
+ system::error_code & ec = system::throws );
+
+ basic_stopclock_accumulator( ostream_type & os, const string_type & format, int places,
+ system::error_code & ec = system::throws );
+ basic_stopclock_accumulator( ostream_type & os, int places, const string_type & format,
+ system::error_code & ec = system::throws );
+
+
+ typedef typename base_type::scoped_run scoped_run;
+ typedef typename base_type::scoped_suspend scoped_suspend;
+ typedef typename base_type::scoped_resume scoped_resume;
+};
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
<a name="boost_chrono.reference.stopwatch_reporters.stopclock_accumulator_hpp.template_class__stopclock_accumulator___"></a><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopclock_accumulator_hpp.template_class__stopclock_accumulator___" title="Template
 Class stopclock_accumulator<>">Template
 Class <code class="computeroutput">stopclock_accumulator<></code></a>
@@ -419,12 +802,13 @@

 <code class="computeroutput">stopclock_accumulator<Clock></code> template class is a shortcut of
 <code class="computeroutput">stopwatch_reporter<stopwatch<Clock>></code>
+ with a specific formatter.
 
<pre class="programlisting">template
 < class Clock=high_resolution_clock
 , class Formatter=typename stopwatch_reporter_default_formatter<stopwatch_accumulator<Clock>>::type
> class stopclock_accumulator
- : public stopwatch_reporter<stopwatch_accumulator<Clock>, Formatter> {
+ : public basic_stopclock_accumulator<Clock, Formatter> {
public:
 typedef Clock clock;
 typedef stopwatch_accumulator<Clock> stopwatch;
@@ -476,6 +860,73 @@
typedef boost::chrono::stopclock_accumulator< boost::chrono::process_system_cpu_clock > process_system_cpu_stopclock_accumulator;
</pre>
</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.stopwatch_reporters.stopclock_accumulator_hpp.template_class__wstopclock_accumulator___"></a><a href="stopwatch_reporters.html#boost_chrono.reference.stopwatch_reporters.stopclock_accumulator_hpp.template_class__wstopclock_accumulator___" title="Template
+ Class wstopclock_accumulator<>">Template
+ Class <code class="computeroutput">wstopclock_accumulator<></code></a>
+</h5></div></div></div>
+
+ <code class="computeroutput">wstopclock_accumulator<Clock></code> template class is a shortcut of
+ <code class="computeroutput">stopwatch_reporter<stopwatch<Clock>></code>
+ with a specific formatter.
+ 
+<pre class="programlisting">template
+ < class Clock=high_resolution_clock
+ , class Formatter=typename stopwatch_reporter_default_formatter<stopwatch_accumulator<Clock>>::type
+> class wstopclock_accumulator
+ : public basic_wstopclock_accumulator<Clock, Formatter> {
+public:
+ typedef Clock clock;
+ typedef stopwatch_accumulator<Clock> stopwatch;
+ typedef Formatter formatter;
+ typedef typename Formatter::string_type string_type;
+ typedef typename Formatter::char_type char_type;
+ typedef typename Formatter::ostream_type ostream_type;
+
+ explicit wstopclock_accumulator( system::error_code & ec = system::throws );
+ explicit wstopclock_accumulator( ostream_type & os,
+ system::error_code & ec = system::throws );
+ explicit wstopclock_accumulator( const string_type & format,
+ system::error_code & ec = system::throws );
+ explicit wstopclock_accumulator( int places,
+ system::error_code & ec = system::throws );
+
+ wstopclock_accumulator( ostream_type & os, const string_type & format,
+ system::error_code & ec = system::throws );
+ wstopclock_accumulator( const string_type & format, int places,
+ system::error_code & ec = system::throws );
+ wstopclock_accumulator( ostream_type & os, int places,
+ system::error_code & ec = system::throws );
+ wstopclock_accumulator( int places, const string_type & format,
+ system::error_code & ec = system::throws );
+
+ wstopclock_accumulator( ostream_type & os, const string_type & format, int places,
+ system::error_code & ec = system::throws );
+ wstopclock_accumulator( ostream_type & os, int places, const string_type & format,
+ system::error_code & ec = system::throws );
+
+
+ typedef typename base_type::scoped_run scoped_run;
+ typedef typename base_type::scoped_suspend scoped_suspend;
+ typedef typename base_type::scoped_resume scoped_resume;
+};
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="boost_chrono.reference.stopwatch_reporters.stopclock_accumulator_hpp._wstopclock_accumulator__useful_typedefs"></a>wstopclock_accumulator useful typedefs
+</h5></div></div></div>
+<pre class="programlisting">typedef boost::chrono::wstopclock_accumulator< boost::chrono::system_clock > system_stopwatch_reporter;
+#ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
+typedef boost::chrono::wstopclock_accumulator< boost::chrono::monotonic_clock > monotonic_stopwatch_reporter;
+#endif
+typedef boost::chrono::wstopclock_accumulator< boost::chrono::high_resolution_clock > high_resolution_wstopclock_accumulator;
+typedef boost::chrono::wstopclock_accumulator< boost::chrono::process_real_cpu_clock > process_real_cpu_wstopclock_accumulator;
+typedef boost::chrono::wstopclock_accumulator< boost::chrono::process_user_cpu_clock > process_user_cpu_wstopclock_accumulator;
+typedef boost::chrono::wstopclock_accumulator< boost::chrono::process_system_cpu_clock > process_system_cpu_wstopclock_accumulator;
+</pre>
+</div>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h4 class="title">

Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/stopwatches.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/stopwatches.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/stopwatches.html 2010-01-31 18:12:37 EST (Sun, 31 Jan 2010)
@@ -91,9 +91,7 @@

 This file include all the stopwatches related files
 
-<pre class="programlisting">#include <boost/chrono/digital_time.hpp>
-#include <boost/chrono/digital_time_formatter.hpp>
-#include <boost/chrono/scoped_stopclock.hpp>
+<pre class="programlisting">#include <boost/chrono/scoped_stopclock.hpp>
#include <boost/chrono/process_cpu_clocks.hpp>
#include <boost/chrono/stopclock.hpp>
#include <boost/chrono/stopclock_accumulator.hpp>
@@ -104,6 +102,8 @@
#include <boost/chrono/stopwatch_reporter.hpp>
#include <boost/chrono/stopwatch_scoped.hpp>
#include <boost/chrono/time_formatter.hpp>
+#include <boost/chrono/t24_hours.hpp>
+#include <boost/chrono/t24_hours_formatter.hpp>
</pre>
</div>
<div class="section" lang="en">
@@ -135,7 +135,7 @@
 is an instance of <code class="computeroutput">S</code>.
 
<div class="table">
-<a name="id4863019"></a>Table 2. Stopwatch Requirements
+<a name="id4863254"></a>Table 2. Stopwatch Requirements
<table class="table" summary="Stopwatch Requirements">
<colgroup>
<col>
@@ -428,6 +428,16 @@

 template <class Clock=high_resolution_clock> class stopwatch;

+ template <class Clock>
+ struct stopwatch_reporter_default_formatter<stopwatch<Clock> > {
+ typedef stopwatch_formatter type;
+ };
+
+ template <class Clock>
+ struct wstopwatch_reporter_default_formatter<stopwatch<Clock> > {
+ typedef wstopwatch_formatter type;
+ };
+
 typedef <see above> system_stopwatch;
 #ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
 typedef <see above> monotonic_stopwatch;
@@ -540,6 +550,17 @@
</dl></div>
<pre class="programlisting">namespace boost { namespace chrono {
 template <class Clock, class Accumulator> class stopwatch_accumulator;
+
+ template <class Clock, class Accumulator>
+ struct stopwatch_reporter_default_formatter<stopwatch_accumulator<Clock, Accumulator> > {
+ typedef stopwatch_accumulator_formatter type;
+ };
+
+ template <class Clock, class Accumulator>
+ struct wstopwatch_reporter_default_formatter<stopwatch_accumulator<Clock, Accumulator> > {
+ typedef wstopwatch_accumulator_formatter type;
+ };
+
 typedef <see below> system_stopwatch_accumulator;
#ifdef BOOST_CHRONO_HAS_CLOCK_MONOTONIC
 typedef <see below> monotonic_stopwatch_accumulator;

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 2010-01-31 18:12:37 EST (Sun, 31 Jan 2010)
@@ -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="id4817559"></a>
+<a name="id4817652"></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="id4817620"></a>
+<a name="id4817712"></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="id4817662"></a>
+<a name="id4817755"></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="id4817730"></a>
+<a name="id4817823"></a>
 <a href="getting_started.html#boost_chrono.users_guide.getting_started.install.requirements">Requirements</a>
 </h5>

@@ -129,7 +129,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="id4817931"></a>
+<a name="id4818024"></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>
@@ -139,7 +139,7 @@
 with the Boost System library.
 
<a name="boost_chrono.users_guide.getting_started.install.exceptions_safety_"></a><h5>
-<a name="id4817967"></a>
+<a name="id4818060"></a>
 <a href="getting_started.html#boost_chrono.users_guide.getting_started.install.exceptions_safety_">Exceptions
 safety </a>
 </h5>
@@ -148,7 +148,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="id4817993"></a>
+<a name="id4818086"></a>
 <a href="getting_started.html#boost_chrono.users_guide.getting_started.install.thread_safety_">Thread
 safety </a>
 </h5>
@@ -156,7 +156,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="id4818018"></a>
+<a name="id4818111"></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/boost_chrono/users_guide/tutorial.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide/tutorial.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide/tutorial.html 2010-01-31 18:12:37 EST (Sun, 31 Jan 2010)
@@ -78,7 +78,7 @@
 // transform to nanoseconds
 return time_point(duration(
 static_cast<thread_clock::rep>( ts.tv_sec ) * 1000000000 + ts.tv_nsec));
-
+
 }
 static time_point now( system::error_code & ec ) {
 // get the current thread
@@ -97,7 +97,7 @@
 // transform to nanoseconds
 return time_point(duration(
 static_cast<thread_clock::rep>( ts.tv_sec ) * 1000000000 + ts.tv_nsec));
-
+
 }
};
</pre>
@@ -123,7 +123,7 @@
 // transform to nanoseconds
 return time_point(duration(
 static_cast<thread_clock::rep>( ts.tv_sec ) * 1000000000 + ts.tv_nsec));
-
+
 }
 static time_point now( system::error_code & ec ) {
 // get the current thread
@@ -142,7 +142,7 @@
 // transform to nanoseconds
 return time_point(duration(
 static_cast<thread_clock::rep>( ts.tv_sec ) * 1000000000 + ts.tv_nsec));
-
+
 }
};
</pre>
@@ -157,7 +157,7 @@
<pre class="programlisting"> // transform to nanoseconds
 return time_point(duration(
 static_cast<thread_clock::rep>( ts.tv_sec ) * 1000000000 + ts.tv_nsec));
-
+
 }
 static time_point now( system::error_code & ec ) {
 // get the current thread
@@ -176,7 +176,7 @@
 // transform to nanoseconds
 return time_point(duration(
 static_cast<thread_clock::rep>( ts.tv_sec ) * 1000000000 + ts.tv_nsec));
-
+
 }
};
</pre>
@@ -202,7 +202,7 @@
 // transform to nanoseconds
 return time_point(duration(
 static_cast<thread_clock::rep>( ts.tv_sec ) * 1000000000 + ts.tv_nsec));
-
+
 }
};
</pre>
@@ -331,7 +331,7 @@
using namespace boost::chrono;
double res;
void f1(long j)
-{
+{
 stopwatch<>::reporter _(BOOST_CHRONO_STOPWATCH_FUNCTION_FORMAT);
 for (long i =0; i< j; i+=1)
 res+=std::sqrt( res+123.456L+i ); // burn some time
@@ -366,12 +366,12 @@
 
<pre class="programlisting">using namespace boost::accumulators;

-typedef stopwatch_accumulator<process_real_cpu_clock,
+typedef stopwatch_accumulator<process_real_cpu_clock,
 accumulator_set<process_real_cpu_clock::rep,
 features<
 tag::count,
 tag::sum,
- tag::mean
+ tag::mean
 >
 >
 >::reporter my_stopwatch_accumulator_reporter;
@@ -411,13 +411,13 @@
<pre class="programlisting">...
#include <boost/accumulators/statistics/variance.hpp>
...
-typedef stopwatch_accumulator<process_real_cpu_clock,
+typedef stopwatch_accumulator<process_real_cpu_clock,
 accumulator_set<process_real_cpu_clock::rep,
 features<
 tag::count,
 tag::sum,
 tag::mean,
- tag::variance(lazy)
+ tag::variance(lazy)
 >
 >
>::reporter my_stopwatch_accumulator_reporter;
@@ -427,13 +427,13 @@
 not taken in account by the default formatter? These statistics will simply
 be ignored. So we will need to define own own accumulator formatter.
 
-<pre class="programlisting">typedef stopwatch_accumulator<process_real_cpu_clock,
+<pre class="programlisting">typedef stopwatch_accumulator<process_real_cpu_clock,
 accumulator_set<process_real_cpu_clock::rep,
 features<
 tag::count,
 tag::sum,
 tag::mean,
- tag::variance(lazy)
+ tag::variance(lazy)
 >
 >,
 my_stopwatch_accumulator_formatter
@@ -444,7 +444,7 @@
 and variance
 
<pre class="programlisting">class my_stopwatch_accumulator_formatter {
-public:
+public:
 typedef std::string string_type;
 typedef char char_type;
 typedef std::ostream ostream_type;
@@ -454,7 +454,7 @@
 static int default_places() { return 3; }

 template <class Stopwatch >
- static void show_time( Stopwatch & stopwatch_, const char_type* format,
+ static void show_time( Stopwatch & stopwatch_, const char_type* format,
 int places, ostream_type & os, system::error_code & ec)
 {
 typedef typename Stopwatch::duration duration_t;

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 2010-01-31 18:12:37 EST (Sun, 31 Jan 2010)
@@ -105,7 +105,8 @@
Acknowledgements</a></dt>
<dt> Appendix F: Tests</dt>
<dt> Appendix G: Tickets</dt>
-<dt> Appendix H: Future plans</dt>
+<dt> Appendix H: Performances</dt>
+<dt> Appendix I: Future plans</dt>
</dl></dd>
</dl>
</div>
@@ -120,7 +121,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: January 26, 2010 at 20:17:56 GMT</td>
+<td align="left">Last revised: January 31, 2010 at 23:10:23 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 2010-01-31 18:12:37 EST (Sun, 31 Jan 2010)
@@ -36,4 +36,5 @@
boost_chrono/appendices/acknowledgements.html
boost_chrono/appendices/tests.html
boost_chrono/appendices/tickets.html
+boost_chrono/appendices/perf.html
boost_chrono/appendices/todo.html

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