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

Subject: [Boost-commit] svn:boost r86773 - trunk/libs/thread/doc
From: vicente.botet_at_[hidden]
Date: 2013-11-19 17:08:29

Author: viboes
Date: 2013-11-19 17:08:29 EST (Tue, 19 Nov 2013)
New Revision: 86773
URL: http://svn.boost.org/trac/boost/changeset/86773

Log:
Thread: update doc with last features changes.

Added:
   trunk/libs/thread/doc/async_executors.qbk   (contents, props changed)
Text files modified: 
   trunk/libs/thread/doc/compliance.qbk      |    87 ++++++++++++------------                
   trunk/libs/thread/doc/future_ref.qbk      |    14 +++                                     
   trunk/libs/thread/doc/sync_queues_ref.qbk |   142 +++++++++++++++++++++++++++++++++++---- 
   trunk/libs/thread/doc/thread.qbk          |     4                                         
   4 files changed, 185 insertions(+), 62 deletions(-)

Added: trunk/libs/thread/doc/async_executors.qbk
==============================================================================

Modified: trunk/libs/thread/doc/compliance.qbk
==============================================================================
--- trunk/libs/thread/doc/compliance.qbk	Tue Nov 19 17:00:56 2013	(r86772)
+++ trunk/libs/thread/doc/compliance.qbk	2013-11-19 17:08:29 EST (Tue, 19 Nov 2013)	(r86773)
@@ -1,5 +1,5 @@
 [/
-  (C) Copyright 2011-12 Vicente J. Botet Escriba.
+  (C) Copyright 2011-2013 Vicente J. Botet Escriba.
   Distributed under the Boost Software License, Version 1.0.
   (See accompanying file LICENSE_1_0.txt or copy at
   http://www.boost.org/LICENSE_1_0.txt).
@@ -9,7 +9,7 @@
 
 [section:cpp11 C++11 standard Thread library]
 
-[note [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3376.html C++11 standard]]
+[note [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3376.html C++11 - Standard for Programming Language C++]]]
 
 
 [table C++11 standard Conformance
@@ -73,24 +73,25 @@
     [[30.6.9]        [Class template packaged_task]  [Yes] [-] [-]]
 ]
 
-[/
+
 [table Extension
     [[Section]     [Description]   [Comments]]
     [[30.3.1.5.x]        [interrupt]   [-]]
     [[30.3.2.x]        [Interruption]  [-]]
     [[30.3.2.y]        [at_thread_exit]  [-]]
     [[30.4.3.x]        [Generic locking algorithms begin/end]  [-]]
-    [[30.x]        [Barriers]  [-]]
-    [[30.y]        [Thread Local Storage]  [-]]
-    [[30.z]        [Class thread_group]  [-]]
 ]
+
+[/
+    [[30.x]        [Thread Local Storage]  [-]]
+    [[30.y]        [Class thread_group]  [-]]
 ]
 [endsect]
 
 
 [section:cxx14 C++14 standard Thread library - accepted changes]
 
-[note [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3485.html C++14 on-going standard]]
+[note [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3797.html Working Draft, Standard for Programming Language C++]]
 
 
 [table [@http://isocpp.org/files/papers/N3659.html N3659 Shared locking in C++ revision 2] Conformance
@@ -106,8 +107,8 @@
 
 [section:latch C++ Latches and Barriers]
 
-[note [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3600.html N3659 C++ Latches and Barriers]]
-[note [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3666.html N3659 C++ Latches and Barriers]]
+[note [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3600.html N3600 C++ Latches and Barriers]]
+[note [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3817.html N3817 C++ Latches and Barriers]]
 
 [table C++ Latches and Barriers Conformance
     [[Section]  [Description]  [Status] [Comments]]
@@ -124,34 +125,34 @@
     [[Section]  [Description]  [Status] [Comments]]
     [[X.1]      [Conceptual interface]  [Partial] [ The interface provided has some differences respect to this proposal. All the functions having a queue_op_status are not provided. No lock-free concrete classes ]]
     [[X.1.1]      [Basic Operations]  [Partial] [ - ]]
-    [[X.1.1.1]      [push]  [yes] [ - ]]
-    [[X.1.1.2]      [value_pop]  [no] [ renamed pull with two flavors + a ptr_pull that returns a sharted_ptr<>. ]]
+    [[X.1.1.1]      [push]  [yes] [ renamed push_back. ]]
+    [[X.1.1.2]      [value_pop]  [no] [ renamed pull_front with two flavors. ]]
     [[X.1.2]      [Non-waiting operations]  [ - ] [ - ]]
-    [[X.1.2.1]      [try_push]  [Partial] [ return bool instead ]]
-    [[X.1.2.2]      [try_pop]  [Partial] [ renamed try_pull, returns null ]]
+    [[X.1.2.1]      [try_push]  [yes] [ renamed try_push_back ]]
+    [[X.1.2.2]      [try_pop]  [yes] [ renamed try_pull_back ]]
     [[X.1.3]      [Non-blocking operations]  [ - ] [ - ]]
-    [[X.1.3.1]      [nonblocking_push]  [Partial] [ renamed try_push(no_block,  ]]
-    [[X.1.3.2]      [nonblocking_pop]  [Partial] [ renamed try_pop(no_block,  ]]
+    [[X.1.3.1]      [nonblocking_push]  [Partial] [ renamed nonblocking_push_back  ]]
+    [[X.1.3.2]      [nonblocking_pop]  [Partial] [ renamed nonblocking_pull_front  ]]
     [[X.1.4]      [Push-front operations]  [No] [ - ]]
     [[X.1.5]      [Closed queues]  [Partial] [ - ]]
     [[X.1.5.1]      [close]  [Yes] [ - ]]
-    [[X.1.5.2]      [is_closed]  [Yes] [ - ]]
-    [[X.1.5.3]      [wait_push]  [Partial] [ - ]]
-    [[X.1.5.4]      [wait_pop]  [Partial] [ - ]]
+    [[X.1.5.2]      [is_closed]  [Yes] [ renamed closed ]]
+    [[X.1.5.3]      [wait_push]  [No] [ - ]]
+    [[X.1.5.4]      [wait_pop]  [No] [ - ]]
     [[X.1.5.5]      [wait_push_front]  [no] [ - ]]
     [[X.1.5.6]      [wait_pop]  [Partial] [ - ]]
     [[X.1.5.6]      [open]  [no] [ - ]]
     [[X.1.6]      [Empty and Full Queues]  [Yes] [ - ]]
     [[X.1.6.1]      [is_empty]  [Yes] [ - ]]
     [[X.1.6.2]      [is_full]  [Yes] [ Added capacity ]]
-    [[X.1.7]      [Queue Names]  [No] [ Not considere a must for the time been. ]]
+    [[X.1.7]      [Queue Names]  [No] [ Not considered a must for the time been. ]]
     [[X.1.8]      [Element Type Requirements]  [Yes?] [ - ]]
     [[X.1.9]      [Exception Handling]  [Yes?] [ - ]]
     [[X.1.10]      [Queue Ordering]  [Yes?] [ - ]]
-    [[X.1.11]      [Lock-Free Implementations]  [No] [ waiting to stabilize the lock-based interface. Will use Boost.LockFree once it is Move aware. ]]
+    [[X.1.11]      [Lock-Free Implementations]  [No] [ waiting to stabilize the lock-based interface. Will use Boost.LockFree once it is Boost.Move aware. ]]
     [[X.2]      [Concrete queues]  [Partial] [ - ]]
     [[X.2.1]      [Locking Buffer Queue]  [Partial] [ classes sync_queue and a sync_bounded_queue. ]]
-    [[X.2.1]      [Lock-Free Buffer Queue]  [No] [ - ]]
+    [[X.2.1]      [Lock-Free Buffer Queue]  [No] [ waiting to stabilize the lock-based interface. Will use Boost.LockFree once it is Boost.Move aware. ]]
     [[X.3]      [Additional Conceptual Tools]  [No] [ - ]]
     [[X.3.1]      [Fronts and Backs]  [No] [ - ]]
     [[X.3.2]      [Streaming Iterators]  [No] [ - ]]
@@ -166,25 +167,24 @@
 
 While Boost.Thread implementation of executors would not use dynamic polymorphism, it is worth comparing with the current trend on the standard.
 
-[note [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3378.pdf N3378 A preliminary proposal for work executors]]
+[note [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3785.pdf N3785 Executors and Schedulers]]
 
 
 [table Asynchronous Executors
     [[Section]  [Description]  [Status] [Comments]]
-    [[30.X.1]      [Class executor]  [No] [ - ]]
-    [[30.X.1.1]      [add]  [No] [ renamed with a function template submit   ]]
-    [[30.X.1.1]      [num_of_pendin_closures]  [??] [    ]]
+    [[30.X.1]      [Class executor]  [Yes] [ - ]]
+    [[30.X.1.1]      [add]  [Yes] [ renamed with a function template submit   ]]
+    [[30.X.1.1]      [num_of_pendin_closures]  [No] [    ]]
     [[30.X.2]      [Class sceduled_executor]  [No] [ - ]]
     [[30.X.2.1]      [add_at]  [No] [ renamed with a function template submit_at   ]]
     [[30.X.2.2]      [add_after]  [No] [ renamed with a function template submit_after   ]]
     [[30.X.3]      [Executor utilities functions]  [No] [ - ]]
     [[30.X.3.1]      [default_executor]  [No] [ - ]]
     [[30.X.3.2]      [set_default_executor]  [No] [ - ]]
-    [[30.X.3.3]      [singleton_inline_executor]  [No] [ - ]]
     [[30.X.4]      [Concrete executor classes]  [No] [ - ]]
-    [[30.X.4.1]      [loop_executor]  [No] [ - ]]
+    [[30.X.4.1]      [loop_executor]  [Yes] [ static version user_scheduler, dynamic one execduler_adaptor<user_scheduler> ]]
     [[30.X.4.1]      [serial_executor]  [No] [ - ]]
-    [[30.X.4.1]      [thread_pool]  [No] [ #8513 ]]
+    [[30.X.4.1]      [thread_pool]  [Yes] [ static version thread_pool, dynamic one execduler_adaptor<thread_pool> ]]
 ]
 
 [endsect]
@@ -193,22 +193,23 @@
 [section:async A Standardized Representation of Asynchronous Operations]
 
 [note [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3558.pdf N3558 A Standardized Representation of Asynchronous Operations]]
-[note These functions are based on the [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3634.pdf [*N3634 - Improvements to std::future<T> and related APIs]] C++1y proposal by N. Gustafsson, A. Laksberg, H. Sutter, S. Mithani.]
+
+[note These functions are based on [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3634.pdf [*N3634 - Improvements to std::future<T> and related APIs]] C++1y proposal by N. Gustafsson, A. Laksberg, H. Sutter, S. Mithani.]
 
 [table Improvements to std::future<T> and related APIs]
     [[Section]  [Description]  [Status] [Comments]]
     [[30.6.6]      [Class template future]  [Partial] [ - ]]
-    [[30.6.6.1]      [then]  [Partial] [ executor interface missing #8516  ]]
+    [[30.6.6.1]      [then]  [No] [ executor interface missing #8516  ]]
     [[30.6.6.2]      [unwrap]  [Yes] [ - ]]
     [[30.6.6.3]      [ready]  [Partial] [ is_ready  ]]
     [[30.6.7]      [Class template shared_future]  [Partial] [ - ]]
-    [[30.6.7.1]      [then]  [Yes] [ executor interface missing #8516 ]]
-    [[30.6.7.2]      [unwrap]  [No] [ #XXXX ]]
+    [[30.6.7.1]      [then]  [No] [ executor interface missing #8516 ]]
+    [[30.6.7.2]      [unwrap]  [Yes] [ #XXXX ]]
     [[30.6.7.3]      [ready]  [Partial] [ is_ready  ]]
-    [[30.6.X]      [Function template when_any]  [No] [ #7446  ]]
-    [[30.6.X]      [Function template when_all]  [No] [ #7447  ]]
+    [[30.6.X]      [Function template when_any]  [Partial] [ interface not complete #7446  ]]
+    [[30.6.X]      [Function template when_all]  [Partial] [ interface not complete #7447  ]]
     [[30.6.X]      [Function template make_ready_future]  [Yes] [ - ]]
-    [[30.6.8]      [Function template async ]  [No] [ executor interface missing #7448    ]]
+    [[30.6.8]      [Function template async ]  [Partial] [ executor interface not complete #7448    ]]
 ]
 
 [endsect]
@@ -217,12 +218,14 @@
 
 While Boost.Thread implementation of stream mutexes differ in the approach, it is worth comparing with the current trend on the standard.
 
-[note [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3535.html N3535 - C++ Stream Mutexes]. This has been replaced already by N3678 - C++ Stream Guards.]
+[note These functions are based on [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3535.html [*N3535 - C++ Stream Mutexes]] by Lawrence Crowl.]
+
+[note This proposal has been replaced already by [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3678.html N3678 - C++ Stream Guards], which has been replaced by [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3678.html N3665 - Uninterleaved String Output Streaming] and [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3678.html N3750 - C++ Ostream Buffers]]
 
-[table C++ C++ Stream MutexesConformance
+[table C++ C++ Stream Mutexes Conformance
     [[Section]  [Description]  [Status] [Comments]]
-    [[X.1]      [Class template stream_mutex]  [Partial] [ externally_locked_stream<> ]]
-    [[X.2.1]      [constructor]  [Partial] [ externally_locked_stream needs a mutex in addition as argumement. ]]
+    [[X.1]      [Class template stream_mutex]  [Partial] [ Renamed externally_locked_stream<> ]]
+    [[X.2.1]      [constructor]  [Partial] [ externally_locked_stream needs a mutex in addition as argument. ]]
     [[X.2.2]      [lock]  [yes] [ - ]]
     [[X.2.3]      [unlock]  [yes] [ - ]]
     [[X.2.4]      [try_lock]  [yes] [ - ]]
@@ -232,12 +235,10 @@
     [[X.2.1]      [stream_guard]  [Yes] [ - ]]
     [[X.2.2]      [~stream_guard]  [Yes] [ - ]]
     [[X.2.3]      [bypass]  [Yes] [ - ]]
-    [[X.3]      [Stream Operators]  [Yes] [.]]
-    [[X.4]      [Predefined Objects]  [No] [.]]
+    [[X.3]      [Stream Operators]  [Yes] [-]]
+    [[X.4]      [Predefined Objects]  [No] [-]]
 ]
 
-[note [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3678.html N3678 - C++ Stream Guards]]
-
 
 [endsect]
 

Modified: trunk/libs/thread/doc/future_ref.qbk
==============================================================================
--- trunk/libs/thread/doc/future_ref.qbk	Tue Nov 19 17:00:56 2013	(r86772)
+++ trunk/libs/thread/doc/future_ref.qbk	2013-11-19 17:08:29 EST (Tue, 19 Nov 2013)	(r86773)
@@ -30,6 +30,7 @@
     {
       async = unspecified,
       deferred = unspecified,
+      executor = unspecified,
       any = async | deferred
     };
     
@@ -88,6 +89,9 @@
     template <class F, class... Args>
     future<typename result_of<typename decay<F>::type(typename decay<Args>::type...)>::type>
     async(launch policy, F&& f, Args&&... args);
+    template <class Executor, class F, class... Args>
+    future<typename result_of<typename decay<F>::type(typename decay<Args>::type...)>::type>
+    async(Executor &ex, F&& f, Args&&... args);
     
     template<typename Iterator>
     void wait_for_all(Iterator begin,Iterator end); // EXTENSION
@@ -147,6 +151,7 @@
     {
       async = unspecified,
       deferred = unspecified,
+      executor = unspecified,
       any = async | deferred
     };
 
@@ -1892,7 +1897,9 @@
     template <class F>
     __unique_future__<typename result_of<typename decay<F>::type()>::type>
     async(launch policy, F&& f);
-
+    template <class Executor, class F>
+    __unique_future__<typename result_of<typename decay<F>::type(typename decay<Args>::type...)>::type>
+    async(Executor &ex, F&& f, Args&&... args);
 [variablelist
 
 [[Requires:] [
@@ -1957,7 +1964,10 @@
     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);
-
+    template <class Executor, class F, class... Args>
+    __unique_future__<typename result_of<typename decay<F>::type(typename decay<Args>::type...)>::type>
+    async(Executor &ex, 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

Modified: trunk/libs/thread/doc/sync_queues_ref.qbk
==============================================================================
--- trunk/libs/thread/doc/sync_queues_ref.qbk	Tue Nov 19 17:00:56 2013	(r86772)
+++ trunk/libs/thread/doc/sync_queues_ref.qbk	2013-11-19 17:08:29 EST (Tue, 19 Nov 2013)	(r86773)
@@ -5,6 +5,7 @@
  / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  /]
 
+[/////////////////////////////////////]
 [section:synchronized_queues Synchronized Queues -- EXPERIMENTAL]
 
 [warning These features are experimental and subject to change in future versions. There are not too much tests yet, so it is possible that you can find out some trivial bugs :(] 
@@ -12,6 +13,13 @@
 [note These features are based on the [@http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3533.html [*N3533 - C++ Concurrent Queues]] C++1y proposal from Lawrence Crowl and Chris Mysen and [@http://www.manning.com/williams/ [*C++ Concurrency in Action]] from Anthony Williams.]
 
 
+[////////////////////]
+[section Introduction]
+
+
+[endsect]
+
+[/////////////////////////////////////]
 [section:tutorial Tutorial]
 
 Concurrent queues are a well know mechanism for communicating data between different threads.
@@ -19,7 +27,13 @@
 Concurrent queues have inherently copy/move semantics for the data handling operation. Reference-returning interfaces are forbidden as multiple access to these references can not be thread-safe.
 
 [endsect]
+[////////////////]
+[section Examples]
+
 
+[endsect]
+
+[/////////////////////////////////////]
 [section:ref Reference]
 
 [section:sync_queue_req Synchronized Queue Model]
@@ -37,16 +51,15 @@
 Lock-free queues will have some trouble waiting for the queue to be non-empty or non-full queues. These queues can not define operations such as push (and pull for bounded queues). That is, it could have blocking operations (presumably emulated with busy wait) but not waiting operations. 
 
 [endsect]
-
+[/////////////////////////////////////]
 [section:closed Closed Queue]
 
 Threads using a queue for communication need some mechanism to signal when the queue is no longer needed. The usual approach is add an additional out-of-band signal. However, this approach suffers from the flaw that threads waiting on either full or empty queues need to be woken up when the queue is no longer needed. Rather than require an out-of-band signal, we chose to directly support such a signal in the queue itself, which considerably simplifies coding.
 
 To achieve this signal, a thread may close a queue. Once closed, no new elements may be pushed onto the queue. Push operations on a closed queue will either return queue_op_status::closed (when they have a queue_op_status return type), set the closed parameter if it has one or throw sync_queue::closed (when they do not). Elements already on the queue may be pulled off. When a queue is empty and closed, pull operations will either return queue_op_status::closed (when they have a status return), set the closed parameter if it has one or throw sync_queue::closed (when they do not). 
 
-
 [endsect]
-
+[/////////////////////////////////////]
 [section:exception Concurrent Queues Throw specification]
 [section:locking Locking]
 
@@ -57,6 +70,7 @@
 ]
 
 [endsect]
+[/////////////////////////////////////]
 [section:bad_alloc Allocation]
 
 All the functions that allocate a resource are defined as if we had in addition to its specific Throw specification the following:
@@ -67,7 +81,7 @@
 
 [endsect]
 [endsect]
-
+[/////////////////////////////////////]
 [section:BasicConcurrentQueue Basic Concurrent Queue Operations]
 
 The essential solution to the problem of concurrent queuing is to shift to value-based operations, rather than reference-based operations. 
@@ -96,6 +110,7 @@
 * `spe` denotes a shared_ptr<Q::value_type>
 
 
+[/////////////////////////////////////]
 [section:push `q.push(e);`]
 
 [variablelist
@@ -115,6 +130,7 @@
 ]
 
 [endsect]
+[/////////////////////////////////////]
 [section:push_m `q.push(rve);`]
 
 [variablelist
@@ -134,8 +150,7 @@
 ]
 
 [endsect]
-
-
+[/////////////////////////////////////]
 [section:pull_lv `q.pull(lve)`]
 
 [variablelist
@@ -155,7 +170,7 @@
 ]
 
 [endsect]
-
+[/////////////////////////////////////]
 [section:pull `e = q.pull()`]
 
 [variablelist
@@ -179,7 +194,7 @@
 ]
 
 [endsect]
-
+[/////////////////////////////////////]
 [section:ptr_pull `spe = q.ptr_pull()`]
 
 [variablelist
@@ -204,10 +219,9 @@
 
 [endsect]
 
-
-
 [endsect]
 
+[/////////////////////////////////////]
 [section:non_waaiting Non-waiting Concurrent Queue Operations]
 
 The ConcurrentQueue concept models a queue with .
@@ -229,6 +243,7 @@
 * `spe` denotes a shared_ptr<Q::value_type>
 
 
+[/////////////////////////////////////]
 [section:try_push `q.try_push(e);`]
 
 [variablelist
@@ -250,6 +265,7 @@
 ]
 
 [endsect]
+[/////////////////////////////////////]
 [section:try_push_m `q.try_push(rve());`]
 
 [variablelist
@@ -271,6 +287,7 @@
 ]
 
 [endsect]
+[/////////////////////////////////////]
 [section:pull_lv `b = q.try_pull(lve)`]
 
 [variablelist
@@ -293,7 +310,7 @@
 
 [endsect]
 [endsect]
-
+[/////////////////////////////////////]
 [section:non_blocking Non-blocking Concurrent Queue Operations]
 
 For cases when blocking for mutual exclusion is undesirable, we have non-blocking operations. The interface is the same as the try operations but is allowed to also return queue_op_status::busy in case the operation is unable to complete without blocking. 
@@ -316,7 +333,7 @@
 
 
 [endsect]
-
+[/////////////////////////////////////]
 [section:bounded Bounded Concurrent Queue Operations]
 
 Bounded queues add the following valid expressions
@@ -326,7 +343,7 @@
 * `u = q.capacity();`
 
 [endsect]
-
+[/////////////////////////////////////]
 [section:closed_op Closed Concurrent Queue Operations]
 
 
@@ -356,7 +373,7 @@
 [endsect]
 
 [endsect]
-
+[/////////////////////////////////////]
 [section:sync_bounded_queue_ref Synchronized Bounded Queue]
 
   #include <boost/thread/sync_bounded_queue.hpp>
@@ -377,6 +394,7 @@
     sync_bounded_queue<ValueType>& operator>>(sync_bounded_queue<ValueType>& sbq, ValueType &elem);
   }
 
+[/////////////////////////////////////]
 [section:sync_queue_is_closed Class `sync_queue_is_closed`]
 
   #include <boost/thread/sync_bounded_queue.hpp>
@@ -387,7 +405,7 @@
   }
 
 [endsect]
-
+[/////////////////////////////////////]
 [section:sync_bounded_queue Class template `sync_bounded_queue<>`]
 
   #include <boost/thread/sync_bounded_queue.hpp>
@@ -434,8 +452,39 @@
     };
   }
 
+[/////////////////////////////////////]
+[section:constructor Constructor `sync_bounded_queue(size_type)`]
+
+      explicit sync_bounded_queue(size_type max_elems);
+
+[variablelist
+
+[[Effects:] [Constructs a sync_bounded_queue with a maximum number of elements given by `max_elems`. ]]
+
+[[Throws:] [any exception that can be throw because of resources unavailable. ]]
+
+]
+
+
+[endsect]
+[/////////////////////////////////////]
+[section:constructort Template Constructor `sync_bounded_queue(size_type, Range)`]
+
+      template <typename Range>
+      sync_bounded_queue(size_type max_elems, Range range);
+
+[variablelist
+
+[[Effects:] [Constructs a sync_bounded_queue with a maximum number of elements given by `max_elems` and push the elements of the range. ]]
+
+[[Throws:] [any exception that can be throw because of resources unavailable. ]]
+
+]
+
 [endsect]
 
+[endsect]
+[/////////////////////////////////////]
 [section:stream_out_operators Non-Member Function `operator<<()`]
 
   #include <boost/thread/sync_bounded_queue.hpp>
@@ -448,6 +497,7 @@
   }
 
 [endsect]
+[/////////////////////////////////////]
 [section:stream_in_operators Non-Member Function `operator>>()`]
 
   #include <boost/thread/sync_bounded_queue.hpp>
@@ -460,6 +510,7 @@
 [endsect]
 [endsect]
 
+[/////////////////////////////////////]
 [section:sync_queue_ref Synchronized Unbounded Queue]
 
   #include <boost/thread/sync_queue.hpp>
@@ -477,6 +528,7 @@
     sync_queue<ValueType>& operator>>(sync_queue<ValueType>& sbq, ValueType &elem);
   }
 
+[/////////////////////////////////////]
 [section:sync_queue Class template `sync_queue<>`]
 
   #include <boost/thread/sync_queue.hpp>
@@ -488,6 +540,7 @@
     {
     public:
       typedef ValueType value_type;
+      typedef csbl::deque<ValueType> underlying_queue_type;
       typedef std::size_t size_type;
 
       sync_queue(sync_queue const&) = delete;
@@ -519,12 +572,70 @@
       bool try_pull(no_block_tag,value_type&);
       shared_ptr<ValueType> try_pull();
 
+      underlying_queue_type underlying_queue() noexcept;
+
       void close();
     };
   }
 
+[/////////////////////////////////////]
+[section:constructor Constructor `sync_bounded_queue(size_type)`]
+
+      explicit sync_queue();
+
+[variablelist
+
+[[Effects:] [Constructs an empty sync_queue. ]]
+
+[[Throws:] [any exception that can be throw because of resources unavailable. ]]
+
+]
+
+
+[endsect]
+[/////////////////////////////////////]
+[section:constructort Template Constructor `sync_bounded_queue(size_type, Range)`]
+
+      template <typename Range>
+      sync_bounded_queue(size_type max_elems, Range range);
+
+[variablelist
+
+[[Effects:] [Constructs an sync_queue with all the elements of the range. ]]
+
+[[Throws:] [any exception that can be throw because of resources unavailable. ]]
+
+]
+
+[endsect]
+[/////////////////////////////////////]
+[section:full Member Function `full()`]
+
+      bool full() const;
+
+[variablelist
+
+[[Returns:] [false. ]]
+
+]
+
+[endsect]
+[/////////////////////////////////////]
+[section:constructor Member Function `underlying_queue()`]
+
+      underlying_queue_type underlying_queue() noexcept;
+
+[variablelist
+
+[[Returns:] [Moves internal queue. ]]
+
+]
+
+[endsect]
+
 [endsect]
 
+[/////////////////////////////////////]
 [section:stream_out_operators Non-Member Function `operator<<()`]
 
   #include <boost/thread/sync_queue.hpp>
@@ -537,6 +648,7 @@
   }
 
 [endsect]
+[/////////////////////////////////////]
 [section:stream_in_operators Non-Member Function `operator>>()`]
 
   #include <boost/thread/sync_queue.hpp>

Modified: trunk/libs/thread/doc/thread.qbk
==============================================================================
--- trunk/libs/thread/doc/thread.qbk	Tue Nov 19 17:00:56 2013	(r86772)
+++ trunk/libs/thread/doc/thread.qbk	2013-11-19 17:08:29 EST (Tue, 19 Nov 2013)	(r86773)
@@ -239,9 +239,9 @@
 [include condition_variables.qbk]
 [include once.qbk]
 [include barrier.qbk]
-[/include latch.qbk]
+[include latch.qbk]
+[include async_executors.qbk]
 [include futures.qbk]
-[/include async_executors.qbk]
 [endsect]