|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r64778 - 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-08-13 04:17:16
Author: viboes
Date: 2010-08-13 04:17:10 EDT (Fri, 13 Aug 2010)
New Revision: 64778
URL: http://svn.boost.org/trac/boost/changeset/64778
Log:
Update doc
Text files modified:
sandbox/chrono/libs/chrono/doc/chrono.qbk | 191 ++++++++++++++++++++++-----------------
sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/faq.html | 12 +-
sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/perf.html | 4
sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/rationale.html | 8
sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/todo.html | 4
sandbox/chrono/libs/chrono/doc/html/boost_chrono/overview.html | 178 +------------------------------------
sandbox/chrono/libs/chrono/doc/html/boost_chrono/overview/motivation.html | 159 +++++++++++++-------------------
sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/cpp0x.html | 30 +++--
sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/deprecated.html | 2
sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/reporters.html | 16 +-
sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide.html | 6
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 | 57 ++++++-----
sandbox/chrono/libs/chrono/doc/html/index.html | 7 +
sandbox/chrono/libs/chrono/doc/html/standalone_HTML.manifest | 1
15 files changed, 265 insertions(+), 426 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-08-13 04:17:10 EDT (Fri, 13 Aug 2010)
@@ -107,16 +107,17 @@
[def __clock_concept_type__ [clock_concept_link `Clock`]]
[def __clock_req__ [clock_concept_link `Clock` requirements]]
[def __Clock__ [clock_concept_link `Clock`]]
+[def __Clock_s__ [clock_concept_link `Clock`'s]]
[template duration_link[link_text] [link boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration [link_text]]]
[def __duration__ [duration_link `duration`]]
-[def __duration_s__ [duration_link `duration`s]]
+[def __duration_s__ [duration_link `duration`'s]]
[/==================]
[template time_point_link[link_text] [link boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point [link_text]]]
[def __time_point__ [time_point_link `time_point`]]
-[def __time_point_s__ [time_point_link `time_point`s]]
+[def __time_point_s__ [time_point_link `time_point`'s]]
[/==================]
[template system_clock_link[link_text] [link boost_chrono.reference.cpp0x.chrono_chrono_hpp.system_clock [link_text]]]
@@ -142,6 +143,7 @@
[def __seconds__ [duration_typedefs `seconds`]]
[def __minutes__ [duration_typedefs `minutes`]]
[def __hours__ [duration_typedefs `hours`]]
+[def __days__ [duration_typedefs `days`]]
[def __common_type_spe__ [link boost_chrono.reference.cpp0x.chrono_chrono_hpp.common_type_spe `common_type`]]
@@ -217,54 +219,6 @@
[:["What is time, then? If nobody asks me, I know; if I have to explain it to someone who has asked me, I do not know.]]
[:[*['-- Augustine ]]]
-[/==================]
-[heading Description]
-[/==================]
-
-The __Boost_Chrono__ library provides:
-
-* One facility for representing time durations: __duration__. Examples of time durations include __seconds__, __minutes__ and __nanoseconds__. All of these units of time duration are united with a generic interface by the __duration__ facility.
-* One facility for representing points in time: __time_point__. A __time_point__ represents an epoch plus or minus a __duration__. The library leaves epochs unspecified. A __time_point__ is associated with a /clock/.
-* Several clocks, some of which may not be available on any given platform: __system_clock__, __monotonic_clock__ and __high_resolution_clock__. A clock is a symbolic bundle of a native __time_point__ and __duration__, and a function which returns a __time_point__ representing ['now].
-
-Additionally, a minimal amount of general purpose infrastructure is provided which will support both the interface and implementation of the /clocks/, __time_point_s__ and __duration_s__ proposed herein. It is expected that these general purpose facilities will also find utility in far ranging user applications as well.
-
-* __common_type__ is a facility which is useful in specifying the type of the result of functions and operators which take a variety of types (e.g. "mixed mode" complex arithmetic).
-* __ratio__ is a facility which is useful in specifying compile time rational constants. Compile time rational arithmetic is supported with protection against overflow and divide by zero. Such a facility is very handy when needing to efficiently represent 1/3 of a nanosecond, or specifying an inch in terms of meters (for example 254/10000 meters - which __ratio__ will reduce to 127/5000 meters).
-
-Knowing how long a program takes to execute is useful in both test and production environments. On top of the standard facilities __Boost_Chrono__ includes:
-
-* a Stopwatch middle layer: providing operations to start, stop, suspend or resume a __Stopwatch__ to measure the elapsed time.
- * __Stopwatch__ concept
- * Scoped helper classes allowing to pairwise start/stop operations, suspend/resume and resume/suspend a __Stopwatch__.
- * __stopwatch__, model of __Stopwatch__ capturing elapsed __Clock__ times.
- * __stopwatch_accumulator__, model of __Stopwatch__ capturing cummulated elapsed Clock times.
-
-* a Stopclocks higher layer: provide a complete stopclock reporting package that can be invoked in a single line of code.
- * __stopwatch_reporter__, convenient reporting of models of __Stopwatch__ results.
- * __stopclock_clock__ shortcut of `__stopwatch_reporter__<__stopwatch__<Clock>>`
- * Allows wide characters
-
-It is also helpful if such timing information is broken down into real (wall clock) time, CPU time spent by the user, and CPU time spent by the operating system servicing user requests. process clocks provide a thin wrapper around the operating system's process timer API. For POSIX-like systems, that's the times() function, while for Windows, it's the GetProcessTimes() function.
-
-* __process_real_cpu_clock__, capturing real-CPU times.
-* __process_user_cpu_clock__, capturing user-CPU times.
-* __process_system_cpu_clock__, capturing system-CPU times.
-* `process_cpu_clock`, tuple-like class capturing at once real, user-CPU, and system-CPU times.
-
-To complete the clocks __Boost_Chrono__ provides, in platforms having the needed support, thread clocks.
-
-
-[/
-
-* Suspendible clock
- * __SuspendibleClock__ concept
- * scope_suspend which do suspend/resume if the __Clock__ is a model of __SuspendibleClock__ concept, and nothing otherwise.
- * template class __suspendible_clock__
-]
-
-Last, __Boost_Chrono__ include typeof registration for classes __duration__ and __time_point__ so you can used auto emulated on C++03 compilers.
-
[/====================================]
[heading How to Use This Documentation]
@@ -274,8 +228,7 @@
* Code is in `fixed width font` and is syntax-highlighted.
* Replaceable text that you will need to supply is in [~italics].
-* If a name refers to a free function, it is specified like this:
- `free_function()`; that is, it is in code font and its name is followed by `()` to indicate that it is a free function.
+* Free functions are rendered in the code font followed by (), as in free_function().
* If a name refers to a class template, it is specified like this: `class_template<>`; that is, it is in code font and its name is followed by `<>` to indicate that it is a class template.
* If a name refers to a function-like macro, it is specified like this: `MACRO()`;
that is, it is uppercase in code font and its name is followed by `()` to indicate that it is a function-like macro. Object-like macros appear without the trailing `()`.
@@ -297,21 +250,32 @@
[heading Time]
-We all deal with time every day of our lives. We've intuitively known it since birth. Thus we are all very familiar with it and believe it to be a simple matter. The modeling of time in computer programs should be similarly simple.
+We all deal with time every day of our lives. We've intuitively known it since birth. Thus we are all very familiar with it and believe it to be a simple matter. The modeling of time in computer programs should be similarly simple. The unfortunate truth is that this perceived simplicity is only skin deep. Fortunately however, we do not need a terribly complicated solution to meet the bulk of our needs. However, overly simplistic solutions can be dangerous and inefficient, and won't adapt as the computer industry evolves.
-The unfortunate truth is that this perceived simplicity is only skin deep. Fortunately however, we do not need a terribly complicated solution to meet the bulk of our needs. However, overly simplistic solutions are fraught with danger, inherent inefficiency, and lack the ability to adapt as the computer industry evolves over decades.
+__Boost_Chrono__ aims to implement the new time facilities in C++0x, as proposed in [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2661.htm [*N2661 - A Foundation to Sleep On]]. That document provides background and motivation for key design decisions and is the source of a good deal of information in this documentation.
+[/
__Boost_Chrono__ proposes a solution that is precision neutral, with a very simple end user interface which supports multiple clocks, multiple precisions (both coarser and finer than we will ever need), separate types for points in time and time durations, efficiency, and compile time enforced safety.
+]
-[/In addition to the clocks provided by the standard proposal, __Boost_Chrono__ provides specific process clocks and a thread clock.]
+[/
+In addition to the clocks provided by the standard proposal, __Boost_Chrono__ provides specific process clocks and a thread clock.
+]
+[/
See [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2661.htm [*N2661 - A Foundation to Sleep On]] which is very informative and provides motivation for key design decisions for __common_type__, __ratio__ and `chrono`. This documentation contains a lot of extracts from this document.
+]
[heading Wall clock versus system and user time]
+To make the timing facilities of Boost.Chrono more generally useful, the library provides a number of clocks that are thin wrappers around the operating system's process time API, thereby allowing the extraction of read (wall clock) time, user CPU time, and system CPU time. (On POSIX-like systems, this relies on times(). On Windows, it relies on GetProcessTimes().)
+
+[/
It is also helpful if such timing information is broken down into real (wall clock) time, CPU time spent by the user, and CPU time spent by the operating system servicing user requests.
+]
-[/3 concrete process clocks:
+[/
+3 concrete process clocks:
# __process_real_CPU_clock__,
# __process_user_CPU_clock__,
@@ -319,8 +283,10 @@
providing a
]
-__Boost_Chrono__ provides
+
+[/__Boost_Chrono__ provides
thin wrappers around the operating system's process timer API. For POSIX-like systems, that's the times() function, while for Windows, it's the GetProcessTimes() function.
+]
[/These clocks capture the specific time unitarily. __Boost_Chrono__ provides also a clock __process_cpu_clock__ that captures the three times at once.
]
@@ -347,29 +313,27 @@
}
]
-[heading Reporting slapsed time]
+[heading Reporting elapsed time]
-Knowing how long a program, a function or a specific block takes to execute is useful in both test and production environments.
-__Boost_Chrono__ introduces the __Stopwatch__ concept which captures the mechanism to measure the elapsed time.
-A Stopwatch allows to start, stop, suspend and resume the measure of the eleapsed time.
-__stopwatch__`<>` is the basic model of __Stopwatch__ allowing to make a single measure.
+Knowing how long a program, a function or a specific code block takes to execute is useful in both test and production environments.
+__Boost_Chrono__ introduces the __Stopwatch__ concept which is a mechanism to measure the elapsed time.
+A Stopwatch allows to start, stop, suspend and resume the measure of the elapsed time.
+__stopwatch__`<>` is the basic model of __Stopwatch__.
At the user level, the main use case of measuring the elapsed time is to report these measures on the display.
__stopwatch_reporter__`<>` provides a run time reporting package that can be invoked in a single line of code to report the usage of a Clock.
-[heading Caveat emptor]
-
-The underlying clocks provided by operating systems are subject to many seemingly arbitrary policies and implementation irregularities. That's a polite way of saying they tend to be flakey, and each operating system or even each clock has its own cruel and unusual forms of flakiness. Don't bet the farm on their accuracy, unless you have become deeply familiar with exactly what the specific operating system is guaranteeing, which is often very little.
[heading How reliable are these measures?]
[/note this section need to be reworked, the ideas are there, but ...]
-There are three context on which you can get unreliable measures:
+There are three cases which can lead to get unreliable measures:
+
+* precision of your clock. It is not possible to measure events that transpire at rates of the same order of magnitude as the clock's precision with any reliability. For example, a 10ms clock cannot be used reliably to measure elapsed times of tens of milliseconds. The library provides a [high_resolution_clock] that gives you the highest resolution time available on your platform. That will give the best precision, but can only be used for reliable measurement of events that elapse about an order of magnitude slower than that clock's precision.
-* 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/chrono.hpp>
@@ -377,15 +341,18 @@
__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.
+* Using a process clock in a multithreaded application will give elapsed time for the process as a whole, including threads other than the calling thread. To get time elapsed for a specific thread, use the supplied __thread_clock__ which returns time elapsed for the calling thread only, if supported by the platform.
+
+* When stopclocks are nested, usually from stopclocks appearing in each of several nested function calls, the overhead of the stopclock processing begins to be significant relative to run time of the code being measured. The innermost measurements remain accurate, but those in the outermost layers can measure too much overhead to be trustworthy.
* 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 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 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 __stopwatch_accumulator__, 'i.e. don't report until all the measures have been compiled and then report some statistics or using an asynchronous stream.
+Most of the stopclock overhead is likely due to logging. There are two things we can do to make the difference :
+
+* Don't flush log information while measuring elapsed time. A __stopwatch_accumulator__ can make that possible, because it don't report until all the measures have been compiled and then report some statistics. Alternatively, an asynchronous stream would permit normal logging but by a thread other than the one being measured.
-* 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 a __SuspendibleClock__ and then suspend/resume the clock while doing the report.
+* Add a mechanism to track the difference between the application time and stopclock time. If a __Clock__ models __SuspendibleClock__ and its precision is sufficiently fine, this mechanism could suspend the __Clock_s__ counting while reporting measurements and resume it thereafter.
[/
stopclock<suspendible_clock<Clock> > _;
@@ -395,6 +362,64 @@
]
[endsect]
+[/==================]
+[section Description]
+[/==================]
+
+The __Boost_Chrono__ library provides:
+
+* A means to represent time durations: managed by the generic __duration__ class . Examples of time durations include __days__, __minutes__, __seconds__ and __nanoseconds__, which can be represented with a fixed number of clock ticks per unit. All of these units of time duration are united with a generic interface by the __duration__ facility.
+* A type for representing points in time: __time_point__. A __time_point__ represents an epoch plus or minus a __duration__. The library leaves epochs unspecified. A __time_point__ is associated with a /clock/.
+* Several clocks, some of which may not be available on a particular platform: __system_clock__, __monotonic_clock__ and __high_resolution_clock__. A clock is a pairing of a __time_point__ and __duration__, and a function which returns a __time_point__ representing ['now].
+
+Additionally, a minimal amount of general purpose infrastructure is provided which will support both the interface and implementation of the /clocks/, __time_point_s__ and __duration_s__ proposed herein. It is expected that these general purpose facilities will also find utility in far ranging user applications as well.
+
+* __common_type__ is a traits class used to deduce a type common to a several types, useful as the return type of functions operating on multiple input types such as in mixed-mode arithmetic.
+[/* __ratio__ is a facility which is useful in specifying compile time rational constants. Compile time rational arithmetic is supported with protection against overflow and divide by zero. Such a facility is very handy when needing to efficiently represent 1/3 of a nanosecond, or specifying an inch in terms of meters (for example 254/10000 meters - which __ratio__ will reduce to 127/5000 meters).
+]
+* A class template, __ratio__, for specifying compile time rational constants such as 1/3 of a nanosecond or the number of inches per meter. __ratio__ represents a compile time ratio of compile time constants with support for compile time arithmetic with overflow and division by zero protection
+
+Knowing how long a program takes to execute is useful in both test and production environments. On top of the standard facilities __Boost_Chrono__ includes:
+
+* Stopwatches: A facility to measure elapsed time with the ability to start, stop, suspend, or resume measurement.
+ * __Stopwatch__ concept
+ * Scoped helper classes allowing to pairwise start/stop operations, suspend/resume and resume/suspend a __Stopwatch__.
+ * __stopwatch__, model of __Stopwatch__ capturing elapsed __Clock__ times.
+ * __stopwatch_accumulator__, model of __Stopwatch__ capturing cummulated elapsed Clock times.
+
+* a Stopclocks higher layer: provide a complete stopclock reporting package that can be invoked in a single line of code.
+ * __stopwatch_reporter__, convenient reporting to an output stream (including wide char streams) of the elapsed time of models of __Stopwatch__ results.
+ * __stopclock_clock__ shortcut of `__stopwatch_reporter__<__stopwatch__<Clock>>`
+
+To make the timing facilities more generally useful, __Boost_Chrono__ provides a number of clocks that are thin wrappers around the operating system's time APIs, thereby allowing the extraction of read (wall clock) time, user CPU time, system CPU time,
+
+* __process_real_cpu_clock__, captures real (wall clock) CPU times.
+* __process_user_cpu_clock__, captures user-CPU times.
+* __process_system_cpu_clock__, captures system-CPU times.
+* A tuple-like class `process_cpu_clock`, that captures real, user-CPU, and system-CPU times together.
+* Thread clocks, when supported by a platform.
+
+
+[/It is also helpful if such timing information is broken down into real (wall clock) time, CPU time spent by the user, and CPU time spent by the operating system servicing user requests. process clocks provide a thin wrapper around the operating system's process timer API. For POSIX-like systems, that's the times() function, while for Windows, it's the GetProcessTimes() function.
+]
+
+
+[/
+
+* Suspendible clock
+ * __SuspendibleClock__ concept
+ * scope_suspend which do suspend/resume if the __Clock__ is a model of __SuspendibleClock__ concept, and nothing otherwise.
+ * template class __suspendible_clock__
+]
+
+Lastly, __Boost_Chrono__ includes [@http://www.boost.org/libs/typeof typeof] registration for __duration__ and __time_point__ to permit using emulated auto with C++03 compilers.
+
+
+[heading Caveat emptor]
+
+The underlying clocks provided by operating systems are subject to many seemingly arbitrary policies and implementation irregularities. That's a polite way of saying they tend to be flakey, and each operating system or even each clock has its own cruel and unusual forms of flakiness. Don't bet the farm on their accuracy, unless you have become deeply familiar with exactly what the specific operating system is guaranteeing, which is often very little.
+
+[endsect]
[endsect]
@@ -1017,7 +1042,7 @@
Knowing how long a program, a function or a specific block takes to execute is useful in both test and production environments.
__Boost_Chrono__ introduces the __Stopwatch__ concept which captures the mechanism to measure the elapsed time.
-A __Stopwatch__ allows to `start`, `stop`, `suspend` and `resume` the measure of the eleapsed time.
+A __Stopwatch__ allows to `start`, `stop`, `suspend` and `resume` the measure of the elapsed time.
__stopwatch__`<>` is the basic model of __Stopwatch__ allowing to make a single measure.
At the user level, the main use case of measuring the elapsed time is to report these measures on the display.
@@ -1084,7 +1109,7 @@
There are three context on which you can get unreliable measures:
-* 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.
+* precision of your clock. If the precision 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 precision, 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 precision of the clock.
``
#include <boost/chrono/chrono.hpp>
@@ -1110,7 +1135,7 @@
* 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 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.
+* Introduce some cheap mechanism that allows us to make the difference between the application time and the intrinsic __stopclock__ time. When the precision 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> > _;
@@ -2492,7 +2517,7 @@
[section:common_type Class Template `common_type<>`]
-__common_type__ is a facility which is useful in specifying the type of the result of functions and operators which take a variety of types (e.g. "mixed mode" complex arithmetic).
+__common_type__ is a traits class used to deduce a type common to a several types, useful as the return type of functions operating on multiple input types such as in mixed-mode arithmetic..
The nested typedef __common_type__::type` could be defined as follows:
@@ -4629,7 +4654,7 @@
[section:reporters Stopwatch Reporters]
[section:formatter_req `Formatter` Requirements]
-A Formatter outputs on a given ostream a formatted string combining informations from a Stopwatch and the format and the double precission.
+A Formatter outputs on a given ostream a formatted string combining informations from a Stopwatch and the format and the double precision.
A Formatter must meet the requirements in the following Table.
@@ -4638,9 +4663,9 @@
[table Formatter Requirements
[[expression] [return type] [operational semantics]]
[[`F::default_os()`] [std::otream&] [The output stream.]]
- [[`F::default_places()`] [`std::size_t`] [The precission when displaying a double.]]
+ [[`F::default_places()`] [`std::size_t`] [The precision when displaying a double.]]
[[`F::default_format()`] [`const char*`] [The default format.]]
- [[`F::show_time(s,f,p,os,ec)`] [`S::time_point`] [outputs on `os` a formatted string combining informations from the Stopwatch `s`, the format `f` and the double precission `p`.]]
+ [[`F::show_time(s,f,p,os,ec)`] [`S::time_point`] [outputs on `os` a formatted string combining informations from the Stopwatch `s`, the format `f` and the double precision `p`.]]
]
@@ -4688,10 +4713,10 @@
[section:basic_stopwatch_reporter Template Class `basic_stopwatch_reporter<>`]
-class `basic_stopwatch_reporter` provides a everything a `Stopwatch` provides and it adds reporting capabilities that can be invoked in a single line of code. The reporting is controleed by two parameters:
+class `basic_stopwatch_reporter` provides everything a `Stopwatch` 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.
+* places(precision): the number of decimal placess used.
The default places is given by Formatter::default_places().
@@ -4746,7 +4771,7 @@
class __stopwatch_reporter__ provides a everything a `Stopwatch` 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.
+* places(precision): the number of decimal placess used.
The default places is given by Formatter::default_places().
@@ -4817,7 +4842,7 @@
class `wstopwatch_reporter` provides a everything a `Stopwatch` 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.
+* places(precision): the number of decimal placess used.
The default places is given by Formatter::default_places().
@@ -5845,7 +5870,7 @@
class `run_timer` provides a complete run time reporting package that can be invoked in a single line of code. The reporting is controled by two parameters:
* format : The output format
-* places(precission): the number of decimal placess used.
+* places(precision): the number of decimal placess used.
The default places is given by default_places and is 3.
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-08-13 04:17:10 EDT (Fri, 13 Aug 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___link_linkend__boost_chrono_reference_cpp0x_common_type_hpp_common_type___code__phrase_role__identifier__common_type__phrase___code___link__lt__gt__template_arguments_"></a><h4>
-<a name="id4947186"></a>
+<a name="id4947115"></a>
<a href="faq.html#boost_chrono.appendices.faq.how_important_is_the_order_of_the___link_linkend__boost_chrono_reference_cpp0x_common_type_hpp_common_type___code__phrase_role__identifier__common_type__phrase___code___link__lt__gt__template_arguments_">How
important is the order of the <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.common_type_hpp.common_type" title="
Class Template common_type<>"><code class="computeroutput"><span class="identifier">common_type</span></code></a><> template arguments?</a>
@@ -70,7 +70,7 @@
also undefined.
</p>
<a name="boost_chrono.appendices.faq.why_does_stopwatch_reporter_only_display_millisecond_place_precision_when_the_underlying_clock_has_nanosecond_precision_"></a><h4>
-<a name="id4947740"></a>
+<a name="id4947668"></a>
<a href="faq.html#boost_chrono.appendices.faq.why_does_stopwatch_reporter_only_display_millisecond_place_precision_when_the_underlying_clock_has_nanosecond_precision_">Why
does stopwatch_reporter only display millisecond place precision when the
underlying Clock has nanosecond precision?</a>
@@ -81,7 +81,7 @@
dangerously.
</p>
<a name="boost_chrono.appendices.faq.why_does_stopwatch_reporter_sometimes_report_more_cpu_seconds_than_real_seconds_"></a><h4>
-<a name="id4947781"></a>
+<a name="id4947710"></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>
@@ -91,7 +91,7 @@
be reporting at times.
</p>
<a name="boost_chrono.appendices.faq.can_i_obtain_statistics_of_the_time_elapsed_between_calls_to_a_function_"></a><h4>
-<a name="id4947815"></a>
+<a name="id4947744"></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>
@@ -99,13 +99,13 @@
The library do not provides this feature.
</p>
<a name="boost_chrono.appendices.faq.what_happens_if_i_press_ctrl_c_and_program_terminates__what_log_would_boost_chrono_output_"></a><h4>
-<a name="id4947843"></a>
+<a name="id4947772"></a>
<a href="faq.html#boost_chrono.appendices.faq.what_happens_if_i_press_ctrl_c_and_program_terminates__what_log_would_boost_chrono_output_">What
happens if I press Ctrl+C and program terminates? What log would Boost.chrono
output?</a>
</h4>
<a name="boost_chrono.appendices.faq.can_you_explain_the_pros_cons_of___link_linkend__boost_chrono_reference_cpp0x_common_type_hpp_common_type___code__phrase_role__identifier__common_type__phrase___code___link__against_boost_typeof_"></a><h4>
-<a name="id4947872"></a>
+<a name="id4947801"></a>
<a href="faq.html#boost_chrono.appendices.faq.can_you_explain_the_pros_cons_of___link_linkend__boost_chrono_reference_cpp0x_common_type_hpp_common_type___code__phrase_role__identifier__common_type__phrase___code___link__against_boost_typeof_">Can
you explain the pros/cons of <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.common_type_hpp.common_type" title="
Class Template common_type<>"><code class="computeroutput"><span class="identifier">common_type</span></code></a> against Boost.Typeof?</a>
Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/perf.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/perf.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/perf.html 2010-08-13 04:17:10 EDT (Fri, 13 Aug 2010)
@@ -69,7 +69,7 @@
with a variable lifetime.
</p>
<a name="boost_chrono.appendices.perf.single_threaded_recursive_function"></a><h4>
-<a name="id4951713"></a>
+<a name="id4951642"></a>
<a href="perf.html#boost_chrono.appendices.perf.single_threaded_recursive_function">Single-Threaded
Recursive function</a>
</h4>
@@ -92,7 +92,7 @@
and thread_clock.
</p>
<a name="boost_chrono.appendices.perf.multi_threaded_recursive_function"></a><h4>
-<a name="id4951763"></a>
+<a name="id4951692"></a>
<a href="perf.html#boost_chrono.appendices.perf.multi_threaded_recursive_function">Multi-Threaded
Recursive function</a>
</h4>
Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/rationale.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/rationale.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/rationale.html 2010-08-13 04:17:10 EDT (Fri, 13 Aug 2010)
@@ -33,7 +33,7 @@
are an extract from this document.
</p>
<a name="boost_chrono.appendices.rationale.is_it_possible_for_the_user_to_pass_a___link_linkend__boost_chrono_reference_cpp0x_chrono_chrono_hpp_duration___code__phrase_role__identifier__duration__phrase___code___link__to_a_function_with_the_units_being_ambiguous_"></a><h4>
-<a name="id4945817"></a>
+<a name="id4945746"></a>
<a href="rationale.html#boost_chrono.appendices.rationale.is_it_possible_for_the_user_to_pass_a___link_linkend__boost_chrono_reference_cpp0x_chrono_chrono_hpp_duration___code__phrase_role__identifier__duration__phrase___code___link__to_a_function_with_the_units_being_ambiguous_">Is
it possible for the user to pass a <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code></a> to a function with the
@@ -46,7 +46,7 @@
<pre class="programlisting"><span class="identifier">f</span><span class="special">(</span><span class="number">3</span><span class="special">);</span> <span class="comment">// Will not compile, 3 is not implicitly convertible to any __duration__
</span></pre>
<a name="boost_chrono.appendices.rationale.why_duration_needs_operator_"></a><h4>
-<a name="id4945916"></a>
+<a name="id4945845"></a>
<a href="rationale.html#boost_chrono.appendices.rationale.why_duration_needs_operator_">Why
duration needs operator%</a>
</h4>
@@ -74,7 +74,7 @@
<span class="special">};</span>
</pre>
<a name="boost_chrono.appendices.rationale.why_ratio_needs_copyconstruction_and_assignment_from_ratios_having_the_same_normalized_form"></a><h4>
-<a name="id4946497"></a>
+<a name="id4946426"></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>
@@ -109,7 +109,7 @@
succeeds.
</p>
<a name="boost_chrono.appendices.rationale.why_ratio_needs_the_nested_normalizer_typedef_type"></a><h4>
-<a name="id4946906"></a>
+<a name="id4946835"></a>
<a href="rationale.html#boost_chrono.appendices.rationale.why_ratio_needs_the_nested_normalizer_typedef_type">Why
ratio needs the nested normalizer typedef type</a>
</h4>
Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/todo.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/todo.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/appendices/todo.html 2010-08-13 04:17:10 EDT (Fri, 13 Aug 2010)
@@ -26,7 +26,7 @@
<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="id4951830"></a>
+<a name="id4951758"></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="id4951869"></a>
+<a name="id4951798"></a>
<a href="todo.html#boost_chrono.appendices.todo.for_later_releases">For later
releases</a>
</h4>
Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/overview.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/overview.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/overview.html 2010-08-13 04:17:10 EDT (Fri, 13 Aug 2010)
@@ -26,7 +26,10 @@
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="boost_chrono.overview"></a>Overview
</h2></div></div></div>
-<div class="toc"><dl><dt><span class="section">Motivation</span></dt></dl></div>
+<div class="toc"><dl>
+<dt><span class="section">Motivation</span></dt>
+<dt><span class="section">Description</span></dt>
+</dl></div>
<div class="blockquote"><blockquote class="blockquote">
<p>
</p>
@@ -46,175 +49,8 @@
<p>
</p>
</blockquote></div>
-<a name="boost_chrono.overview.description"></a><h3>
-<a name="id4765050"></a>
- Description
- </h3>
-<p>
- The <span class="bold"><strong>Boost.Chrono</strong></span> library provides:
- </p>
-<div class="itemizedlist"><ul type="disc">
-<li>
- One facility for representing time durations: <a href="reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code></a>. Examples of time durations
- include <a href="reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration_typedefs" title="
- duration typedefs"><code class="computeroutput"><span class="identifier">seconds</span></code></a>, <a href="reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration_typedefs" title="
- duration typedefs"><code class="computeroutput"><span class="identifier">minutes</span></code></a> and <a href="reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration_typedefs" title="
- duration typedefs"><code class="computeroutput"><span class="identifier">nanoseconds</span></code></a>. All of these units
- of time duration are united with a generic interface by the <a href="reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code></a> facility.
- </li>
-<li>
- One facility for representing points in time: <a href="reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code></a>. A <a href="reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code></a> represents an epoch plus
- or minus a <a href="reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code></a>. The library leaves epochs
- unspecified. A <a href="reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code></a> is associated with a
- <span class="emphasis"><em>clock</em></span>.
- </li>
-<li>
- Several clocks, some of which may not be available on any given platform:
- <a href="reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.system_clock" title="
- Class system_clock"><code class="computeroutput"><span class="identifier">system_clock</span></code></a>, <a href="reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.monotonic_clock" title="
- Class monotonic_clock"><code class="computeroutput"><span class="identifier">monotonic_clock</span></code></a> and <a href="reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.high_resolution_clock" title="
- Class high_resolution_clock"><code class="computeroutput"><span class="identifier">high_resolution_clock</span></code></a>. A clock is
- a symbolic bundle of a native <a href="reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code></a> and <a href="reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code></a>, and a function which returns
- a <a href="reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code></a> representing <span class="emphasis"><em>now</em></span>.
- </li>
-</ul></div>
-<p>
- Additionally, a minimal amount of general purpose infrastructure is provided
- which will support both the interface and implementation of the <span class="emphasis"><em>clocks</em></span>,
- <a href="reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code>s</a> and <a href="reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>s</a> proposed herein. It is expected
- that these general purpose facilities will also find utility in far ranging
- user applications as well.
- </p>
-<div class="itemizedlist"><ul type="disc">
-<li>
-<a href="reference/cpp0x.html#boost_chrono.reference.cpp0x.common_type_hpp.common_type" title="
- Class Template common_type<>"><code class="computeroutput"><span class="identifier">common_type</span></code></a> is a facility which
- is useful in specifying the type of the result of functions and operators
- which take a variety of types (e.g. "mixed mode" complex arithmetic).
- </li>
-<li>
-<a href="reference/cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
- Template ratio<>"><code class="computeroutput"><span class="identifier">ratio</span></code></a> is a facility which is useful
- in specifying compile time rational constants. Compile time rational arithmetic
- is supported with protection against overflow and divide by zero. Such a
- facility is very handy when needing to efficiently represent 1/3 of a nanosecond,
- or specifying an inch in terms of meters (for example 254/10000 meters -
- which <a href="reference/cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
- Template ratio<>"><code class="computeroutput"><span class="identifier">ratio</span></code></a> will reduce to 127/5000 meters).
- </li>
-</ul></div>
-<p>
- Knowing how long a program takes to execute is useful in both test and production
- environments. On top of the standard facilities <span class="bold"><strong>Boost.Chrono</strong></span>
- includes:
- </p>
-<div class="itemizedlist"><ul type="disc">
-<li>
- a Stopwatch middle layer: providing operations to start, stop, suspend or
- resume a <a href="reference/stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_req" title="
- Stopwatch Requirements"><code class="computeroutput"><span class="identifier">Stopwatch</span></code></a> to measure the elapsed
- time.
- <div class="itemizedlist"><ul type="circle">
-<li>
-<a href="reference/stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_req" title="
- Stopwatch Requirements"><code class="computeroutput"><span class="identifier">Stopwatch</span></code></a> concept
- </li>
-<li>
- Scoped helper classes allowing to pairwise start/stop operations, suspend/resume
- and resume/suspend a <a href="reference/stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_req" title="
- Stopwatch Requirements"><code class="computeroutput"><span class="identifier">Stopwatch</span></code></a>.
- </li>
-<li>
-<a href="reference/stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_hpp.stopwatch" title="
- Template Class stopwatch<>"><code class="computeroutput"><span class="identifier">stopwatch</span></code></a>, model of <a href="reference/stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_req" title="
- Stopwatch Requirements"><code class="computeroutput"><span class="identifier">Stopwatch</span></code></a> capturing elapsed
- <a href="reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.clock" title="
- Clock Requirements"><code class="computeroutput"><span class="identifier">Clock</span></code></a> times.
- </li>
-<li>
-<a href="reference/stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.stopwatch_accumulator" title="
- Template Class stopwatch_accumulator<>"><code class="computeroutput"><span class="identifier">stopwatch_accumulator</span></code></a>, model
- of <a href="reference/stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_req" title="
- Stopwatch Requirements"><code class="computeroutput"><span class="identifier">Stopwatch</span></code></a> capturing cummulated
- elapsed Clock times.
- </li>
-</ul></div>
-</li>
-<li>
- a Stopclocks higher layer: provide a complete stopclock reporting package
- that can be invoked in a single line of code.
- <div class="itemizedlist"><ul type="circle">
-<li>
-<a href="reference/reporters.html#boost_chrono.reference.reporters.stopwatch_reporter_hpp.stopwatch_reporter" title="
- Template Class stopwatch_reporter<>"><code class="computeroutput"><span class="identifier">stopwatch_reporter</span></code></a>, convenient
- reporting of models of <a href="reference/stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_req" title="
- Stopwatch Requirements"><code class="computeroutput"><span class="identifier">Stopwatch</span></code></a> results.
- </li>
-<li>
-<a href="reference/reporters.html#boost_chrono.reference.reporters.stopclock_hpp.stopclock" title="
- Template Class stopclock<>"><code class="computeroutput"><span class="identifier">stopclock</span><span class="special"><</span><span class="identifier">Clock</span><span class="special">></span></code></a>
- shortcut of <code class="computeroutput"><a href="reference/reporters.html#boost_chrono.reference.reporters.stopwatch_reporter_hpp.stopwatch_reporter" title="
- Template Class stopwatch_reporter<>"><code class="computeroutput"><span class="identifier">stopwatch_reporter</span></code></a><span class="special"><</span><a href="reference/stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_hpp.stopwatch" title="
- Template Class stopwatch<>"><code class="computeroutput"><span class="identifier">stopwatch</span></code></a><span class="special"><</span><span class="identifier">Clock</span><span class="special">>></span></code>
-</li>
-<li>
- Allows wide characters
- </li>
-</ul></div>
-</li>
-</ul></div>
-<p>
- It is also helpful if such timing information is broken down into real (wall
- clock) time, CPU time spent by the user, and CPU time spent by the operating
- system servicing user requests. process clocks provide a thin wrapper around
- the operating system's process timer API. For POSIX-like systems, that's the
- times() function, while for Windows, it's the GetProcessTimes() function.
- </p>
-<div class="itemizedlist"><ul type="disc">
-<li>
-<a href="reference/other_clocks.html#boost_chrono.reference.other_clocks.process_cpu_clocks_hpp.process_real_cpu_clock" title="
- Class process_real_cpu_clock"><code class="computeroutput"><span class="identifier">process_real_cpu_clock</span></code></a>, capturing
- real-CPU times.
- </li>
-<li>
-<a href="reference/other_clocks.html#boost_chrono.reference.other_clocks.process_cpu_clocks_hpp.process_user_cpu_clock" title="
- Class process_user_cpu_clock"><code class="computeroutput"><span class="identifier">process_user_cpu_clock</span></code></a>, capturing
- user-CPU times.
- </li>
-<li>
-<a href="reference/other_clocks.html#boost_chrono.reference.other_clocks.process_cpu_clocks_hpp.process_system_cpu_clock" title="
- Class process_system_cpu_clock"><code class="computeroutput"><span class="identifier">process_system_cpu_clock</span></code></a>, capturing
- system-CPU times.
- </li>
-<li>
-<code class="computeroutput"><span class="identifier">process_cpu_clock</span></code>, tuple-like
- class capturing at once real, user-CPU, and system-CPU times.
- </li>
-</ul></div>
-<p>
- To complete the clocks <span class="bold"><strong>Boost.Chrono</strong></span> provides,
- in platforms having the needed support, thread clocks.
- </p>
-<p>
- Last, <span class="bold"><strong>Boost.Chrono</strong></span> include typeof registration
- for classes <a href="reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code></a> and <a href="reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code></a> so you can used auto emulated
- on C++03 compilers.
- </p>
<a name="boost_chrono.overview.how_to_use_this_documentation"></a><h3>
-<a name="id4804281"></a>
+<a name="id4765053"></a>
<a href="overview.html#boost_chrono.overview.how_to_use_this_documentation">How to
Use This Documentation</a>
</h3>
@@ -230,9 +66,7 @@
Replaceable text that you will need to supply is in <em class="replaceable"><code>italics</code></em>.
</li>
<li>
- If a name refers to a free function, it is specified like this: <code class="computeroutput"><span class="identifier">free_function</span><span class="special">()</span></code>;
- that is, it is in code font and its name is followed by <code class="computeroutput"><span class="special">()</span></code>
- to indicate that it is a free function.
+ Free functions are rendered in the code font followed by (), as in free_function().
</li>
<li>
If a name refers to a class template, it is specified like this: <code class="computeroutput"><span class="identifier">class_template</span><span class="special"><></span></code>;
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-08-13 04:17:10 EDT (Fri, 13 Aug 2010)
@@ -7,7 +7,7 @@
<link rel="start" href="../../index.html" title="Boost.Chrono">
<link rel="up" href="../overview.html" title="Overview">
<link rel="prev" href="../overview.html" title="Overview">
-<link rel="next" href="../users_guide.html" title=" Users'Guide">
+<link rel="next" href="description.html" title="Description">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
@@ -20,74 +20,58 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="../overview.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../overview.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="../users_guide.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="../overview.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../overview.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="description.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.overview.motivation"></a>Motivation
</h3></div></div></div>
<a name="boost_chrono.overview.motivation.time"></a><h4>
-<a name="id4758575"></a>
+<a name="id4803513"></a>
<a href="motivation.html#boost_chrono.overview.motivation.time">Time</a>
</h4>
<p>
We all deal with time every day of our lives. We've intuitively known it
since birth. Thus we are all very familiar with it and believe it to be a
simple matter. The modeling of time in computer programs should be similarly
- simple.
+ simple. The unfortunate truth is that this perceived simplicity is only skin
+ deep. Fortunately however, we do not need a terribly complicated solution
+ to meet the bulk of our needs. However, overly simplistic solutions can be
+ dangerous and inefficient, and won't adapt as the computer industry evolves.
</p>
<p>
- The unfortunate truth is that this perceived simplicity is only skin deep.
- Fortunately however, we do not need a terribly complicated solution to meet
- the bulk of our needs. However, overly simplistic solutions are fraught with
- danger, inherent inefficiency, and lack the ability to adapt as the computer
- industry evolves over decades.
- </p>
-<p>
- <span class="bold"><strong>Boost.Chrono</strong></span> proposes a solution that is
- precision neutral, with a very simple end user interface which supports multiple
- clocks, multiple precisions (both coarser and finer than we will ever need),
- separate types for points in time and time durations, efficiency, and compile
- time enforced safety.
- </p>
-<p>
- See N2661 - A Foundation to Sleep On which is
- very informative and provides motivation for key design decisions for <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.common_type_hpp.common_type" title="
- Class Template common_type<>"><code class="computeroutput"><span class="identifier">common_type</span></code></a>, <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
- Template ratio<>"><code class="computeroutput"><span class="identifier">ratio</span></code></a> and <code class="computeroutput"><span class="identifier">chrono</span></code>.
- This documentation contains a lot of extracts from this document.
+ <span class="bold"><strong>Boost.Chrono</strong></span> aims to implement the new time
+ facilities in C++0x, as proposed in N2661 - A Foundation to Sleep On. That document
+ provides background and motivation for key design decisions and is the source
+ of a good deal of information in this documentation.
</p>
<a name="boost_chrono.overview.motivation.wall_clock_versus_system_and_user_time"></a><h4>
-<a name="id4758685"></a>
+<a name="id4803571"></a>
<a href="motivation.html#boost_chrono.overview.motivation.wall_clock_versus_system_and_user_time">Wall
clock versus system and user time</a>
</h4>
<p>
- It is also helpful if such timing information is broken down into real (wall
- clock) time, CPU time spent by the user, and CPU time spent by the operating
- system servicing user requests.
- </p>
-<p>
- <span class="bold"><strong>Boost.Chrono</strong></span> provides thin wrappers around
- the operating system's process timer API. For POSIX-like systems, that's
- the times() function, while for Windows, it's the GetProcessTimes() function.
- </p>
-<a name="boost_chrono.overview.motivation.reporting_slapsed_time"></a><h4>
-<a name="id4758725"></a>
- <a href="motivation.html#boost_chrono.overview.motivation.reporting_slapsed_time">Reporting
- slapsed time</a>
+ To make the timing facilities of Boost.Chrono more generally useful, the
+ library provides a number of clocks that are thin wrappers around the operating
+ system's process time API, thereby allowing the extraction of read (wall
+ clock) time, user CPU time, and system CPU time. (On POSIX-like systems,
+ this relies on times(). On Windows, it relies on GetProcessTimes().)
+ </p>
+<a name="boost_chrono.overview.motivation.reporting_elapsed_time"></a><h4>
+<a name="id4803615"></a>
+ <a href="motivation.html#boost_chrono.overview.motivation.reporting_elapsed_time">Reporting
+ elapsed time</a>
</h4>
<p>
- Knowing how long a program, a function or a specific block takes to execute
- is useful in both test and production environments. <span class="bold"><strong>Boost.Chrono</strong></span>
+ Knowing how long a program, a function or a specific code block takes to
+ execute is useful in both test and production environments. <span class="bold"><strong>Boost.Chrono</strong></span>
introduces the <a href="../reference/stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_req" title="
- Stopwatch Requirements"><code class="computeroutput"><span class="identifier">Stopwatch</span></code></a> concept which captures
- the mechanism to measure the elapsed time. A Stopwatch allows to start, stop,
- suspend and resume the measure of the eleapsed time. <a href="../reference/stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_hpp.stopwatch" title="
+ Stopwatch Requirements"><code class="computeroutput"><span class="identifier">Stopwatch</span></code></a> concept which is a mechanism
+ to measure the elapsed time. A Stopwatch allows to start, stop, suspend and
+ resume the measure of the elapsed time. <a href="../reference/stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_hpp.stopwatch" title="
Template Class stopwatch<>"><code class="computeroutput"><span class="identifier">stopwatch</span></code></a><code class="computeroutput"><span class="special"><></span></code>
is the basic model of <a href="../reference/stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_req" title="
- Stopwatch Requirements"><code class="computeroutput"><span class="identifier">Stopwatch</span></code></a> allowing to make a single
- measure.
+ Stopwatch Requirements"><code class="computeroutput"><span class="identifier">Stopwatch</span></code></a>.
</p>
<p>
At the user level, the main use case of measuring the elapsed time is to
@@ -95,34 +79,23 @@
Template Class stopwatch_reporter<>"><code class="computeroutput"><span class="identifier">stopwatch_reporter</span></code></a><code class="computeroutput"><span class="special"><></span></code> provides a run time reporting package
that can be invoked in a single line of code to report the usage of a Clock.
</p>
-<a name="boost_chrono.overview.motivation.caveat_emptor"></a><h4>
-<a name="id4758849"></a>
- Caveat emptor
- </h4>
-<p>
- The underlying clocks provided by operating systems are subject to many seemingly
- arbitrary policies and implementation irregularities. That's a polite way
- of saying they tend to be flakey, and each operating system or even each
- clock has its own cruel and unusual forms of flakiness. Don't bet the farm
- on their accuracy, unless you have become deeply familiar with exactly what
- the specific operating system is guaranteeing, which is often very little.
- </p>
<a name="boost_chrono.overview.motivation.how_reliable_are_these_measures_"></a><h4>
-<a name="id4758879"></a>
+<a name="id4803738"></a>
<a href="motivation.html#boost_chrono.overview.motivation.how_reliable_are_these_measures_">How
reliable are these measures?</a>
</h4>
<p>
- There are three context on which you can get unreliable measures:
+ There are three cases which can lead to get unreliable measures:
</p>
<div class="itemizedlist"><ul type="disc"><li>
- 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.
+ precision of your clock. It is not possible to measure events that transpire
+ at rates of the same order of magnitude as the clock's precision with any
+ reliability. For example, a 10ms clock cannot be used reliably to measure
+ elapsed times of tens of milliseconds. The library provides a [high_resolution_clock]
+ that gives you the highest resolution time available on your platform.
+ That will give the best precision, but can only be used for reliable measurement
+ of events that elapse about an order of magnitude slower than that clock's
+ precision.
</li></ul></div>
<p>
@@ -137,13 +110,18 @@
</p>
<div class="itemizedlist"><ul type="disc">
<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. If what you want is the
- time spent by this specific thread another clock is needed. The library
- provide a <a href="../reference/other_clocks.html#boost_chrono.reference.other_clocks.thread_clock_hpp.thread_clock" title="
- Class thread_clock"><code class="computeroutput"><span class="identifier">thread_clock</span></code></a> that returns the
- time spent by the thread on platforms providing this kind of data.
+ Using a process clock in a multithreaded application will give elapsed
+ time for the process as a whole, including threads other than the calling
+ thread. To get time elapsed for a specific thread, use the supplied <a href="../reference/other_clocks.html#boost_chrono.reference.other_clocks.thread_clock_hpp.thread_clock" title="
+ Class thread_clock"><code class="computeroutput"><span class="identifier">thread_clock</span></code></a> which returns time
+ elapsed for the calling thread only, if supported by the platform.
+ </li>
+<li>
+ When stopclocks are nested, usually from stopclocks appearing in each of
+ several nested function calls, the overhead of the stopclock processing
+ begins to be significant relative to run time of the code being measured.
+ The innermost measurements remain accurate, but those in the outermost
+ layers can measure too much overhead to be trustworthy.
</li>
<li>
Nested stopclocks (usually nested function calls where each function contains
@@ -155,31 +133,26 @@
</li>
</ul></div>
<p>
- 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 :
+ Most of the stopclock overhead is likely due to logging. There are two things
+ we can do to make the difference :
</p>
<div class="itemizedlist"><ul type="disc">
<li>
- 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 <a href="../reference/stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.stopwatch_accumulator" title="
- Template Class stopwatch_accumulator<>"><code class="computeroutput"><span class="identifier">stopwatch_accumulator</span></code></a>, 'i.e. don't
- report until all the measures have been compiled and then report some statistics
- or using an asynchronous stream.
+ Don't flush log information while measuring elapsed time. A <a href="../reference/stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_accumulator_hpp.stopwatch_accumulator" title="
+ Template Class stopwatch_accumulator<>"><code class="computeroutput"><span class="identifier">stopwatch_accumulator</span></code></a> can make
+ that possible, because it don't report until all the measures have been
+ compiled and then report some statistics. Alternatively, an asynchronous
+ stream would permit normal logging but by a thread other than the one being
+ measured.
</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 spending time reporting the measures, and resume it once the work
- is done. The library provide a Clock wrapper <a href="../reference/other_clocks.html#boost_chrono.reference.other_clocks.suspendible_clock_hpp.suspendible_clock" title="
- Template Class suspendible_clock<>"><code class="computeroutput"><span class="identifier">suspendible_clock</span></code></a> that make the
- resulting clock suspendible. The stopwatch_reporter is able to detect if
- the <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.clock" title="
- Clock Requirements"><code class="computeroutput"><span class="identifier">Clock</span></code></a> is a <a href="../reference/other_clocks.html#boost_chrono.reference.other_clocks.suspendible_clock_req" title="
- SuspendibleClock Requirements"><code class="computeroutput"><span class="identifier">SuspendibleClock</span></code></a> and then suspend/resume
- the clock while doing the report.
+ Add a mechanism to track the difference between the application time and
+ stopclock time. If a <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.clock" title="
+ Clock Requirements"><code class="computeroutput"><span class="identifier">Clock</span></code></a> models <a href="../reference/other_clocks.html#boost_chrono.reference.other_clocks.suspendible_clock_req" title="
+ SuspendibleClock Requirements"><code class="computeroutput"><span class="identifier">SuspendibleClock</span></code></a> and its precision
+ is sufficiently fine, this mechanism could suspend the <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.clock" title="
+ Clock Requirements"><code class="computeroutput"><span class="identifier">Clock</span></code>'s</a> counting while reporting
+ measurements and resume it thereafter.
</li>
</ul></div>
</div>
@@ -193,7 +166,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="../overview.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../overview.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="../users_guide.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="../overview.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../overview.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="description.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
</body>
</html>
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-08-13 04:17:10 EDT (Fri, 13 Aug 2010)
@@ -181,9 +181,10 @@
</h5></div></div></div>
<p>
<a href="cpp0x.html#boost_chrono.reference.cpp0x.common_type_hpp.common_type" title="
- Class Template common_type<>"><code class="computeroutput"><span class="identifier">common_type</span></code></a> is a facility which
- is useful in specifying the type of the result of functions and operators
- which take a variety of types (e.g. "mixed mode" complex arithmetic).
+ Class Template common_type<>"><code class="computeroutput"><span class="identifier">common_type</span></code></a> is a traits class
+ used to deduce a type common to a several types, useful as the return
+ type of functions operating on multiple input types such as in mixed-mode
+ arithmetic..
</p>
<p>
The nested typedef <a href="cpp0x.html#boost_chrono.reference.cpp0x.common_type_hpp.common_type" title="
@@ -997,7 +998,7 @@
Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code></a> definition
if it is valid to compare their time_points by comparing their
respective <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>s</a>. <code class="computeroutput"><span class="identifier">C1</span></code> and <code class="computeroutput"><span class="identifier">C2</span></code>
+ Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>'s</a>. <code class="computeroutput"><span class="identifier">C1</span></code> and <code class="computeroutput"><span class="identifier">C2</span></code>
must refer to the same epoch.
</p>
</td>
@@ -1097,9 +1098,9 @@
tick period. If <code class="computeroutput"><span class="identifier">treat_as_floating_point</span><span class="special"><</span><span class="identifier">Rep</span><span class="special">>::</span><span class="identifier">value</span></code>
is <code class="computeroutput"><span class="keyword">true</span></code>, then <code class="computeroutput"><span class="identifier">Rep</span></code> is a floating point type and
implicit conversions are allowed among <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>s</a>. Otherwise, the
+ Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>'s</a>. Otherwise, the
implicit convertibility depends on the tick periods of the <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>s</a>. If <code class="computeroutput"><span class="identifier">Rep</span></code> is a class type which emulates
+ Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>'s</a>. If <code class="computeroutput"><span class="identifier">Rep</span></code> is a class type which emulates
a floating point type, the author of <code class="computeroutput"><span class="identifier">Rep</span></code>
can specialize <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.traits.treat_as_floating_point" title="
Metafunction treat_as_floating_point<>"><code class="computeroutput"><span class="identifier">treat_as_floating_point</span></code></a> so
@@ -1143,10 +1144,11 @@
<a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.traits.duration_values" title="
Class template duration_values"><code class="computeroutput"><span class="identifier">duration_values</span></code></a> trait to construct
special values of the <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>s</a> representation (<code class="computeroutput"><span class="identifier">Rep</span></code>). This is done because the representation
- might be a class type with behavior which requires some other implementation
- to return these special values. In that case, the author of that class
- type should specialize <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.traits.duration_values" title="
+ Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>'s</a> representation
+ (<code class="computeroutput"><span class="identifier">Rep</span></code>). This is done
+ because the representation might be a class type with behavior which
+ requires some other implementation to return these special values.
+ In that case, the author of that class type should specialize <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.traits.duration_values" title="
Class template duration_values"><code class="computeroutput"><span class="identifier">duration_values</span></code></a> to return
the indicated values.
</p>
@@ -1241,7 +1243,7 @@
to it without requiring a division operation. The representation of this
type is intended to be able to hold any value resulting from this conversion,
with the possible exception of round-off error when floating point <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>s</a> are involved (but
+ Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>'s</a> are involved (but
not truncation error).
</p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Duration1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Duration2</span><span class="special">></span>
@@ -1258,10 +1260,10 @@
<p>
The <a href="cpp0x.html#boost_chrono.reference.cpp0x.common_type_hpp.common_type" title="
Class Template common_type<>"><code class="computeroutput"><span class="identifier">common_type</span></code></a> of two <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code>s</a> is a <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
+ Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code>'s</a> is a <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code></a> with the same <code class="computeroutput"><span class="identifier">clock</span></code> (both have the same <code class="computeroutput"><span class="identifier">clock</span></code>), and the <a href="cpp0x.html#boost_chrono.reference.cpp0x.common_type_hpp.common_type" title="
Class Template common_type<>"><code class="computeroutput"><span class="identifier">common_type</span></code></a> of the two <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>s</a>.
+ Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>'s</a>.
</p>
</div>
<div class="section" lang="en">
@@ -1480,7 +1482,7 @@
not participate in overload resolution. <span class="bold"><strong>note</strong></span>
This requirement prevents implicit truncation error when converting
between integral-based <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>s</a>. Such a construction
+ Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>'s</a>. Such a construction
could easily lead to confusion about the value of the <a href="cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code></a>.
</p>
Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/deprecated.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/deprecated.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/deprecated.html 2010-08-13 04:17:10 EDT (Fri, 13 Aug 2010)
@@ -269,7 +269,7 @@
format : The output format
</li>
<li>
- places(precission): the number of decimal placess used.
+ places(precision): the number of decimal placess used.
</li>
</ul></div>
<p>
Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/reporters.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/reporters.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/reference/reporters.html 2010-08-13 04:17:10 EDT (Fri, 13 Aug 2010)
@@ -80,7 +80,7 @@
</h4></div></div></div>
<p>
A Formatter outputs on a given ostream a formatted string combining informations
- from a Stopwatch and the format and the double precission.
+ from a Stopwatch and the format and the double precision.
</p>
<p>
A Formatter must meet the requirements in the following Table.
@@ -150,7 +150,7 @@
</td>
<td>
<p>
- The precission when displaying a double.
+ The precision when displaying a double.
</p>
</td>
</tr>
@@ -188,7 +188,7 @@
a formatted string combining informations from the Stopwatch
<code class="computeroutput"><span class="identifier">s</span></code>, the format
<code class="computeroutput"><span class="identifier">f</span></code> and the double
- precission <code class="computeroutput"><span class="identifier">p</span></code>.
+ precision <code class="computeroutput"><span class="identifier">p</span></code>.
</p>
</td>
</tr>
@@ -266,7 +266,7 @@
</h5></div></div></div>
<p>
class <code class="computeroutput"><span class="identifier">basic_stopwatch_reporter</span></code>
- provides a everything a <code class="computeroutput"><span class="identifier">Stopwatch</span></code>
+ provides everything a <code class="computeroutput"><span class="identifier">Stopwatch</span></code>
provides and it adds reporting capabilities that can be invoked in a
single line of code. The reporting is controleed by two parameters:
</p>
@@ -275,7 +275,7 @@
format : The output format
</li>
<li>
- places(precission): the number of decimal placess used.
+ places(precision): the number of decimal placess used.
</li>
</ul></div>
<p>
@@ -345,7 +345,7 @@
format : The output format
</li>
<li>
- places(precission): the number of decimal placess used.
+ places(precision): the number of decimal placess used.
</li>
</ul></div>
<p>
@@ -431,7 +431,7 @@
format : The output format
</li>
<li>
- places(precission): the number of decimal placess used.
+ places(precision): the number of decimal placess used.
</li>
</ul></div>
<p>
@@ -1070,7 +1070,7 @@
<span class="special">}</span>
</pre>
<a name="boost_chrono.reference.reporters.scoped_stopclock_hpp.scoped_stopclock.synopsis"></a><h6>
-<a name="id4930411"></a>
+<a name="id4930340"></a>
<a href="reporters.html#boost_chrono.reference.reporters.scoped_stopclock_hpp.scoped_stopclock.synopsis">Synopsis</a>
</h6>
<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span> <span class="keyword">class</span> <span class="identifier">Clock</span><span class="special">=</span><span class="identifier">process_cpu_clock</span>
Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide.html 2010-08-13 04:17:10 EDT (Fri, 13 Aug 2010)
@@ -6,7 +6,7 @@
<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
<link rel="start" href="../index.html" title="Boost.Chrono">
<link rel="up" href="../index.html" title="Boost.Chrono">
-<link rel="prev" href="overview/motivation.html" title="Motivation">
+<link rel="prev" href="overview/description.html" title="Description">
<link rel="next" href="users_guide/getting_started.html" title=" Getting Started">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -20,7 +20,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="overview/motivation.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="users_guide/getting_started.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="overview/description.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="users_guide/getting_started.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
@@ -72,7 +72,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="overview/motivation.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="users_guide/getting_started.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="overview/description.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="users_guide/getting_started.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
</body>
</html>
Modified: sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide/getting_started.html
==============================================================================
--- sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide/getting_started.html (original)
+++ sandbox/chrono/libs/chrono/doc/html/boost_chrono/users_guide/getting_started.html 2010-08-13 04:17:10 EDT (Fri, 13 Aug 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="id4759218"></a>
+<a name="id4759002"></a>
<a href="getting_started.html#boost_chrono.users_guide.getting_started.install.getting__emphasis_role__bold__boost_chrono__emphasis__">Getting
<span class="bold"><strong>Boost.Chrono</strong></span> </a>
</h5>
@@ -54,7 +54,7 @@
and follow the instructions there for anonymous SVN access.
</p>
<a name="boost_chrono.users_guide.getting_started.install.where_to_install__emphasis_role__bold__boost_chrono__emphasis___"></a><h5>
-<a name="id4759288"></a>
+<a name="id4759074"></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 <span class="bold"><strong>Boost.Chrono</strong></span>? </a>
</h5>
@@ -70,7 +70,7 @@
variable. Any help is welcome.
</p>
<a name="boost_chrono.users_guide.getting_started.install.building__emphasis_role__bold__boost_chrono__emphasis__"></a><h5>
-<a name="id4759330"></a>
+<a name="id4759389"></a>
<a href="getting_started.html#boost_chrono.users_guide.getting_started.install.building__emphasis_role__bold__boost_chrono__emphasis__">Building
<span class="bold"><strong>Boost.Chrono</strong></span> </a>
</h5>
@@ -81,7 +81,7 @@
<pre class="programlisting"><span class="identifier">bjam</span> <span class="identifier">libs</span><span class="special">/</span><span class="identifier">chrono</span><span class="special">/</span><span class="identifier">build</span>
</pre>
<a name="boost_chrono.users_guide.getting_started.install.requirements"></a><h5>
-<a name="id4759401"></a>
+<a name="id4759461"></a>
<a href="getting_started.html#boost_chrono.users_guide.getting_started.install.requirements">Requirements</a>
</h5>
<p>
@@ -144,7 +144,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="id4759657"></a>
+<a name="id4759716"></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 <span class="bold"><strong>Boost.Chrono</strong></span>
</a>
@@ -154,7 +154,7 @@
with the Boost System library.
</p>
<a name="boost_chrono.users_guide.getting_started.install.exceptions_safety_"></a><h5>
-<a name="id4759692"></a>
+<a name="id4759751"></a>
<a href="getting_started.html#boost_chrono.users_guide.getting_started.install.exceptions_safety_">Exceptions
safety </a>
</h5>
@@ -163,7 +163,7 @@
of exception safety as long as the underlying parameters provide it.
</p>
<a name="boost_chrono.users_guide.getting_started.install.thread_safety_"></a><h5>
-<a name="id4759719"></a>
+<a name="id4759779"></a>
<a href="getting_started.html#boost_chrono.users_guide.getting_started.install.thread_safety_">Thread
safety </a>
</h5>
@@ -171,7 +171,7 @@
All functions in the library are thread-unsafe except when noted explicitly.
</p>
<a name="boost_chrono.users_guide.getting_started.install.tested_compilers_"></a><h5>
-<a name="id4759745"></a>
+<a name="id4759804"></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-08-13 04:17:10 EDT (Fri, 13 Aug 2010)
@@ -283,7 +283,7 @@
Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code></a> is the heart of this
library. The interface that the user will see in everyday use is nearly
identical to that of Boost.DateTime time <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>s</a> authored by Jeff Garland,
+ Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>'s</a> authored by Jeff Garland,
both in syntax and in behavior. This has been a very popular boost library
for 7 years. There is an enormous positive history with this interface.
</p>
@@ -342,15 +342,15 @@
The most immediate positive impact is that the library can immediately
generate any unit, any precision it needs. This is sometimes necessary
when doing comparisons or arithmetic between <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>s</a> of differing precision,
+ Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>'s</a> of differing precision,
assuming one wants the comparison and arithmetic to be exactly correct.
</p>
<p>
A secondary benefit is that by publishing the class template <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code></a> interface, user code
can very easily create <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>s</a> with any precision they
- desire. The <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
+ Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>'s</a> with any precision
+ they desire. The <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.ratio_hpp.ratio" title=" Class
Template ratio<>"><code class="computeroutput"><span class="identifier">ratio</span></code></a> utility is used to specify
the precision, so as long as the precision can be expressed by a rational
constant with respect to seconds, this framework can exactly represent
@@ -414,7 +414,7 @@
Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code></a>'s is attempted. The
tick period is completely ignored when simply doing arithmetic among
like <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>s</a>.
+ Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>'s</a>.
</p>
<p>
<span class="bold"><strong>Example:</strong></span>
@@ -448,7 +448,7 @@
</span></pre>
<p>
These <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>s</a> have very simple,
+ Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>'s</a> have very simple,
very predictable, and very observable behavior. After all, this is really
nothing but the time tested interface of Jeff's boost time <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code></a> library (unified with
@@ -477,7 +477,7 @@
fractional part gets silently discarded.
</p>
<a name="boost_chrono.users_guide.tutorial.duration.what_happens_if_i_assign__m3___us3__to__minutes__instead_of__microseconds__.but_what_if_the_truncation_behavior_is_what_i_want_to_do_"></a><h6>
-<a name="id4816133"></a>
+<a name="id4816056"></a>
<a href="tutorial.html#boost_chrono.users_guide.tutorial.duration.what_happens_if_i_assign__m3___us3__to__minutes__instead_of__microseconds__.but_what_if_the_truncation_behavior_is_what_i_want_to_do_">But
what if the truncation behavior is what I want to do?</a>
</h6>
@@ -555,8 +555,8 @@
If the author of the function wants to accept any <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code></a>, and is willing to
work in floating point <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>s</a>, he can simply use
- any floating point <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
+ Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>'s</a>, he can simply
+ use any floating point <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code></a> as the parameter:
</li></ul></div>
<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">duration</span><span class="special"><</span><span class="keyword">double</span><span class="special">></span> <span class="identifier">d</span><span class="special">)</span> <span class="comment">// accept floating point seconds
@@ -568,7 +568,7 @@
</pre>
<div class="itemizedlist"><ul type="disc"><li>
If the author of the function wants to traffic only in integral <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>s</a>, and is content
+ Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>'s</a>, and is content
with handling nothing finer than say nanoseconds (just as an example),
he can simply specify nanoseconds as the parameter:
</li></ul></div>
@@ -623,7 +623,7 @@
<div class="itemizedlist"><ul type="disc"><li>
If the author in the example does not want to accept floating point
based <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>s</a>, he can enforce
+ Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>'s</a>, he can enforce
that behavior like so:
</li></ul></div>
<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">Period</span><span class="special">></span>
@@ -642,7 +642,7 @@
</span></pre>
<p>
Clients with floating point <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>s</a> who want to use f
+ Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>'s</a> who want to use f
will now have to convert to an integral <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code></a> themselves before passing
the result to f.
@@ -661,13 +661,13 @@
</h4></div></div></div>
<p>
While <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
- Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>s</a> only have precision
+ Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code>'s</a> only have precision
and representation to concern themselves, clocks and <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code>s</a> are intimately related
+ Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code>'s</a> are intimately related
and refer to one another. Because clocks are simpler to explain, we will
do so first without fully explaining <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code>s</a>. Once clocks are introduced,
- it will be easier to then fill in what a <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
+ Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code>'s</a>. Once clocks are
+ introduced, it will be easier to then fill in what a <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code></a> is.
</p>
<p>
@@ -731,7 +731,7 @@
<p>
And one can get the time <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code></a> between two <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code>s</a> associated with Clock
+ Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code>'s</a> associated with Clock
with:
</p>
<pre class="programlisting"><span class="identifier">Clock</span><span class="special">::</span><span class="identifier">duration</span> <span class="identifier">d</span> <span class="special">=</span> <span class="identifier">t1</span> <span class="special">-</span> <span class="identifier">Clock</span><span class="special">::</span><span class="identifier">now</span><span class="special">();</span>
@@ -776,7 +776,7 @@
Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code></a> represents an epoch
plus or minus a <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code></a>. Examples of <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code>s</a> include:
+ Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code>'s</a> include:
</p>
<div class="itemizedlist"><ul type="disc">
<li>
@@ -794,7 +794,7 @@
an epoch has meaning for several millennia. Other times the meaning of
an epoch is lost after a while (such as the start of a timer, or when the
computer booted). However, if two <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code>s</a> are known to share
+ Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code>'s</a> are known to share
the same epoch, they can be subtracted, yielding a valid <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code></a>, even if the definition
of the epoch no longer has meaning.
@@ -803,10 +803,11 @@
In <span class="bold"><strong>Boost.Chrono</strong></span>, an epoch is a purely
abstract and unspecified concept. There is no type representing an epoch.
It is simply an idea that relates (or doesn't) <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code>s</a> to a clock, and in
+ Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code>'s</a> to a clock, and in
the case that they share a clock, <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code>s</a> to one another. <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code>s</a> associated with different
+ Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code>'s</a> to one another.
+ <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
+ Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code>'s</a> associated with different
clocks are generally not interoperable unless the relationship between
the epochs associated with each clock is known.
</p>
@@ -836,10 +837,10 @@
<div class="orderedlist"><ol type="1">
<li>
Because <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code>s</a> originating from
+ Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code>'s</a> originating from
different clocks have different types, the compiler can be instructed
to fail if incompatible <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code>s</a> are used in inappropriate
+ Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code>'s</a> are used in inappropriate
ways.
</li>
<li>
@@ -858,7 +859,7 @@
Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code></a> is stored as the only
data member of the <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code></a>. Thus <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code>s</a> and their corresponding
+ Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code>'s</a> and their corresponding
<a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code></a> have exactly the same
layout. But they have very different meanings. For example, it is one
@@ -886,8 +887,8 @@
Note that if one is using the <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code></a> between two clock
<a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.time_point" title="
- Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code>s</a> in a way where the
- precision of the <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
+ Class template time_point<>"><code class="computeroutput"><span class="identifier">time_point</span></code>'s</a> in a way where
+ the precision of the <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code></a> matters, it is good
practice to convert the clock's native <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
Class template duration<>"><code class="computeroutput"><span class="identifier">duration</span></code></a> to a known <a href="../reference/cpp0x.html#boost_chrono.reference.cpp0x.chrono_chrono_hpp.duration" title="
@@ -1045,7 +1046,7 @@
Stopwatch Requirements"><code class="computeroutput"><span class="identifier">Stopwatch</span></code></a> concept which captures
the mechanism to measure the elapsed time. A <a href="../reference/stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_req" title="
Stopwatch Requirements"><code class="computeroutput"><span class="identifier">Stopwatch</span></code></a> allows to <code class="computeroutput"><span class="identifier">start</span></code>, <code class="computeroutput"><span class="identifier">stop</span></code>,
- <code class="computeroutput"><span class="identifier">suspend</span></code> and <code class="computeroutput"><span class="identifier">resume</span></code> the measure of the eleapsed time.
+ <code class="computeroutput"><span class="identifier">suspend</span></code> and <code class="computeroutput"><span class="identifier">resume</span></code> the measure of the elapsed time.
<a href="../reference/stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_hpp.stopwatch" title="
Template Class stopwatch<>"><code class="computeroutput"><span class="identifier">stopwatch</span></code></a><code class="computeroutput"><span class="special"><></span></code>
is the basic model of <a href="../reference/stopwatches.html#boost_chrono.reference.stopwatches.stopwatch_req" title="
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-08-13 04:17:10 EDT (Fri, 13 Aug 2010)
@@ -50,7 +50,10 @@
<p><b>Table of Contents</b></p>
<dl>
<dt><span class="section">Overview</span></dt>
-<dd><dl><dt><span class="section">Motivation</span></dt></dl></dd>
+<dd><dl>
+<dt><span class="section">Motivation</span></dt>
+<dt><span class="section">Description</span></dt>
+</dl></dd>
<dt><span class="section"> Users'Guide</span></dt>
<dd><dl>
<dt><span class="section"> Getting Started</span></dt>
@@ -95,7 +98,7 @@
</table></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"><p><small>Last revised: August 10, 2010 at 07:11:11 GMT</small></p></td>
+<td align="left"><p><small>Last revised: August 13, 2010 at 08:06:51 GMT</small></p></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-08-13 04:17:10 EDT (Fri, 13 Aug 2010)
@@ -1,6 +1,7 @@
index.html
boost_chrono/overview.html
boost_chrono/overview/motivation.html
+boost_chrono/overview/description.html
boost_chrono/users_guide.html
boost_chrono/users_guide/getting_started.html
boost_chrono/users_guide/tutorial.html
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