[Boost-commit] svn:boost r83910 - trunk/libs/thread/doc

Subject: [Boost-commit] svn:boost r83910 - trunk/libs/thread/doc
From: vicente.botet_at_[hidden]
Date: 2013-04-14 19:07:11

Author: viboes
Date: 2013-04-14 19:07:10 EDT (Sun, 14 Apr 2013)
New Revision: 83910
URL: http://svn.boost.org/trac/boost/changeset/83910

Log:
Thread: update history.
Text files modified: 
   trunk/libs/thread/doc/changes.qbk    |     9 +++++++                                 
   trunk/libs/thread/doc/future_ref.qbk |    48 +++++++++++++++++++++++---------------- 
   2 files changed, 37 insertions(+), 20 deletions(-)

Modified: trunk/libs/thread/doc/changes.qbk
==============================================================================
--- trunk/libs/thread/doc/changes.qbk	(original)
+++ trunk/libs/thread/doc/changes.qbk	2013-04-14 19:07:10 EDT (Sun, 14 Apr 2013)
@@ -30,10 +30,16 @@
 
 [*Fixed Bugs:]
 
+* [@http://svn.boost.org/trac/boost/ticket/4878 #4878] MinGW 4.5.0 undefined reference to bool interruptible_wait(detail::win32::handle handle_to_wait_for,detail::t imeout target_time).
 * [@http://svn.boost.org/trac/boost/ticket/4882 #4882] Win32 shared_mutex does not handle timeouts correctly.
+* [@http://svn.boost.org/trac/boost/ticket/5752 #5752] boost::call_once() is unreliable on some platforms
 * [@http://svn.boost.org/trac/boost/ticket/6652 #6652] Boost.Thread shared_mutex.hpp:50:99: warning: dereferencing type-punned pointer will break strict-aliasing rules [-Wstrict-aliasing]
+* [@http://svn.boost.org/trac/boost/ticket/6843 #6843] [Intel C++] Compile Errors with '#include <atomic>'
+* [@http://svn.boost.org/trac/boost/ticket/6966 #6966] future boost::future_category inconsistent dll linkage
 * [@http://svn.boost.org/trac/boost/ticket/7720 #7720] exception lock_error while intensive locking/unlocking of mutex
 * [@http://svn.boost.org/trac/boost/ticket/7755 #7755] Thread: deadlock with shared_mutex on Windows
+* [@http://svn.boost.org/trac/boost/ticket/7980 #7980] Build error: msvc-11.0 and BOOST_THREAD_DONT_USE_DATETIME
+* [@http://svn.boost.org/trac/boost/ticket/7982 #7982] pthread_delay_np() parm compile error on AIX
 * [@http://svn.boost.org/trac/boost/ticket/8027 #8027] thread library fails to compile with Visual Studio 2003
 * [@http://svn.boost.org/trac/boost/ticket/8070 #8070] prefer GetTickCount64 over GetTickCount
 * [@http://svn.boost.org/trac/boost/ticket/8136 #8136] boost::this_thread::sleep_for() sleeps longer than it should in Windows
@@ -42,6 +48,9 @@
 * [@http://svn.boost.org/trac/boost/ticket/8239 #8239] barrier::wait() not marked as interruption_point
 * [@http://svn.boost.org/trac/boost/ticket/8323 #8323] boost::thread::try_join_for/try_join_until may block indefinitely due to a combination of problems in Boost.Thread and Boost.Chrono 	
 * [@http://svn.boost.org/trac/boost/ticket/8337 #8337] The internal representation of "std::string(this->code()->message())" escapes, but is destroyed when it exits scope.
+* [@http://svn.boost.org/trac/boost/ticket/8371 #8371] C++11 once_flag enabled when constexpr is not available
+
+
 
 
 [heading Version 4.0.0 - boost 1.53]

Modified: trunk/libs/thread/doc/future_ref.qbk
==============================================================================
--- trunk/libs/thread/doc/future_ref.qbk	(original)
+++ trunk/libs/thread/doc/future_ref.qbk	2013-04-14 19:07:10 EDT (Sun, 14 Apr 2013)
@@ -1609,30 +1609,21 @@
 
 [section:async Non-member function `async()`]
 
-    template <class F>
-    __unique_future__<typename result_of<typename decay<F>::type()>::type>
-    async(F&& f);
-    template <class F>
-    __unique_future__<typename result_of<typename decay<F>::type()>::type>
-    async(launch policy, F&& f);
-
-    template <class F, class... Args>
-    __unique_future__<typename result_of<typename decay<F>::type(typename decay<Args>::type...)>::type>
-    async(F&& f, Args&&... args);
-    template <class F, class... Args>
-    __unique_future__<typename result_of<typename decay<F>::type(typename decay<Args>::type...)>::type>
-    async(launch policy, F&& f, Args&&... args);
-
    
 The function template async provides a mechanism to launch a function potentially in a new thread and
 provides the result of the function in a future object with which it shares a shared state.
 
 [warning `async(launch::deferred, F)` is NOT YET IMPLEMENTED!]
 
-[warning the variadic prototype is provided only on C++11 compilers supporting rvalue references, variadic templates, decltype and a standard library providing <tuple> (waiting for a boost::tuple that is move aware), and BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK is defined.]
-
 [heading Non-Variadic variant]
 
+    template <class F>
+    __unique_future__<typename result_of<typename decay<F>::type()>::type>
+    async(F&& f);
+    template <class F>
+    __unique_future__<typename result_of<typename decay<F>::type()>::type>
+    async(launch policy, F&& f);
+
 [variablelist
 
 [[Requires:] [
@@ -1644,8 +1635,11 @@
 shall be a valid expression.
 ]]
 
-[[Effects] [The first function behaves the same as a call to the second function with a policy argument of
- `launch::async | launch::deferred` and the same arguments for `F`. The second function creates a shared state that is associated with the returned future object.
+[[Effects] [
+The first function behaves the same as a call to the second function with a policy argument of
+ `launch::async | launch::deferred` and the same arguments for `F`. 
+ 
+The second function creates a shared state that is associated with the returned future object.
 
 The further behavior of the second function depends on the policy argument as follows (if more than one of these conditions applies, the implementation may choose any of the corresponding policies):
 
@@ -1653,6 +1647,8 @@
 
 - if `policy & launch::deferred` is non-zero - Stores `decay_copy(boost::forward<F>(f))` in the shared state. This copy of `f` constitute a deferred function. Invocation of the deferred function evaluates `boost::move(g)()` where `g` is the stored value of `decay_copy(boost::forward<F>(f))`. The shared state is not made ready until the function has completed. The first call to a non-timed waiting function on an asynchronous return object referring to this shared state shall invoke the deferred function in the thread that called the waiting function. Once evaluation of `boost::move(g)()` begins, the function is no longer considered deferred. (Note: If this policy is specified together with other policies, such as when using a policy value of `launch::async | launch::deferred`, implementations should defer invocation or the selection of the policy when no more concurrency can be effectively exploited.)
 
+- if no valid launch policy is provided the behaviour is undefined.
+
 ]]
 
 [[Returns:] [An object of type `__unique_future__<typename result_of<typename decay<F>::type()>::type>` that refers to the shared state created by this call to `async`.]]
@@ -1665,7 +1661,7 @@
 
 If the implementation chooses the `launch::async` policy,
 
-- a call to a non-timed waiting function on an asynchronous return object that shares the shared state created by this async call shall block until the associated thread has completed, as if joined;
+- a call to a non-timed waiting function on an asynchronous return object that shares the shared state created by this async call shall block until the associated thread has completed, as if joined, or else time out;
 
 - the associated thread completion synchronizes with the return from the first function that successfully detects the ready status of the shared state or with the return from the last function that releases the shared state, whichever happens first.
 ]]
@@ -1686,6 +1682,15 @@
 
 [heading Variadic variant]
 
+    template <class F, class... Args>
+    __unique_future__<typename result_of<typename decay<F>::type(typename decay<Args>::type...)>::type>
+    async(F&& f, Args&&... args);
+    template <class F, class... Args>
+    __unique_future__<typename result_of<typename decay<F>::type(typename decay<Args>::type...)>::type>
+    async(launch policy, F&& f, Args&&... args);
+
+[warning the variadic prototype is provided only on C++11 compilers supporting rvalue references, variadic templates, decltype and a standard library providing <tuple> (waiting for a boost::tuple that is move aware), and BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK is defined.]
+
 [variablelist
 
 [[Requires:] [
@@ -1718,6 +1723,8 @@
   an asynchronous return object referring to this shared state shall invoke the deferred function in the thread that called the waiting function. 
   Once evaluation of `invoke(move(g), move(xyz))` begins, the function is no longer considered deferred.
 
+  - if no valid launch policy is provided the behaviour is undefined.
+   
 ]]
 
 [[Note:] [If this policy is specified together with other policies, such as when using a policy value of `launch::async | launch::deferred`, 
@@ -1731,10 +1738,11 @@
 - the invocation of async synchronizes with the invocation of `f`. (Note: This statement applies even when the corresponding future object is moved to another thread.); and
 
 - the completion of the function `f` is sequenced before the shared state is made ready. (Note: f might not be called at all, so its completion might never happen.)
+
 If the implementation chooses the `launch::async` policy,
 
 - a call to a waiting function on an asynchronous return object that shares the shared state created by this async call 
-shall block until the associated thread has completed, as if joined;
+shall block until the associated thread has completed, as if joined, or else time out;
 
 - the associated thread completion synchronizes with the return from the first function that successfully detects the ready status of the shared state or 
 with the return from the last function that releases the shared state, whichever happens first.