Boost-Commit :

Date view	Thread view	Subject view	Author view

From: bdawes_at_[hidden]
Date: 2007-10-08 13:52:46

Next message: bdawes_at_[hidden]: "[Boost-commit] svn:boost r39804 - sandbox/committee/LWG"
Previous message: bdawes_at_[hidden]: "[Boost-commit] svn:boost r39802 - sandbox/committee/LWG"

Author: bemandawes
Date: 2007-10-08 13:52:46 EDT (Mon, 08 Oct 2007)
New Revision: 39803
URL: http://svn.boost.org/trac/boost/changeset/39803

Log:
thread8 - Updates to the thread section of the paper
Text files modified:
sandbox/committee/LWG/thread_library.html | 658 +++++++++++++++++++++------------------
1 files changed, 350 insertions(+), 308 deletions(-)

Modified: sandbox/committee/LWG/thread_library.html
==============================================================================
--- sandbox/committee/LWG/thread_library.html (original)
+++ sandbox/committee/LWG/thread_library.html 2007-10-08 13:52:46 EDT (Mon, 08 Oct 2007)
@@ -107,12 +107,48 @@

<hr/>

-<h2>Chapter 30   Multi-threading library</h2>
+<h3>20.5 Function objects [function.objects]</h3>
+
+
+Modify paragraph 2 as follows:
+
+
+<blockquote>
+ Header <code>functional</code> synopsis
+
+ <pre>
+ namespace std {
+ ...
+ // Hash function specializations
+ ...
+ <ins class="diff modified">struct hash<std::thread::id>; //should not be in this header file ?</ins>
+ }
+ </pre>
+</blockquote>
+
+<h3>20.5.15 Class template <code>hash</code> [unord.hash]</h3>
+
+Modify paragraph 1 as follows:
+
+<blockquote>
+The unordered associative containers defined in clause 23.4 use
+specializations
+of <code>hash</code> as the default hash function. This class template
+is only
+required to be instantiable for integer types (3.9.1), floating point
+types
+(3.9.1), pointer types (8.3.1), and <code>std::string</code>,
+<code>std::u16string</code>, <code>std::u32string</code>,<del
+class="diff modified">
+and</del> <code>std::wstring</code><ins class="diff modified">, and
+<code>std::thread::id</code></ins>.
+</blockquote>

<hr/>

-
-This clause describes components that C++ programs may use to create and manage <del class="diff modified">multi-threaded </del><ins class="diff modified">additional threads of execution in </ins>programs.
+<h2>Chapter 30   Multi-threading library</h2>
+
+<hr/>


The following subclauses describe components to create and manage
@@ -164,14 +200,6 @@
void swap(thread&& x, thread& y);
void swap(thread& x, thread&& y);

-class thread::id;
-bool operator==(const thread::id& x, const thread::id& y);
-bool operator!=(const thread::id& x, const thread::id& y);
-
-template<class charT, class traits>
-basic_ostream<charT, traits>&
-operator<< (basic_ostream<charT, traits>&& out, const thread::id& id);
-
namespace this_thread
{
 thread::id get_id();
@@ -199,80 +227,86 @@
<h4>Class thread</h4>


-An object of class <code>thread</code> <del class="diff modified">launches </del><ins class="diff modified">encapsulates a thread of execution.
-It provides a mechanism to create </ins>a new thread of <del class="diff modified">execution,
-and provides mechanisms </del><ins class="diff modified">execution,
-</ins>for the current thread of execution to wait for
-completion of the launched <del class="diff modified">thread, </del><ins class="diff modified">thread of execution, </ins>and <ins class="diff">to </ins>perform other operations to manage and query the <del class="diff modified">thread's
-</del><ins class="diff modified">thread
-of execution's </ins>state.
+An object of class <code>thread</code> manages a thread of execution.
+It provides a mechanism to create a new thread of execution,
+for the current thread of execution to wait for
+completion of a thread of execution, and to perform other operations to manage and query the state of the thread of execution.


<blockquote><pre>class thread
{
public:
+ // types:
+ class id;
+ typedef implementation-defined native_handle_type;
+
+ // construct/copy/destroy:
 thread();
 template <class F, class ...Args> explicit thread(F f, Args&&... args);
 ~thread();
-
 thread(const thread&) = delete;
- thread& operator=(const thread&) = delete;
-
 thread(thread&&);
+ thread& operator=(const thread&) = delete;
 thread& operator=(thread&&);

+ // members:
 void swap(thread&&);
-
 bool joinable() const;
 void join();
 void detach();
-
- class id
- {
- public:
- id();
- friend bool operator==(const id& x, const id& y);
- friend bool operator!=(const id& x, const id& y);
- friend bool operator<(const id& x, const id& y);
- friend bool operator<=(const id& x, const id& y);
- friend bool operator>(const id& x, const id& y);
- friend bool operator>=(const id& x, const id& y);
- };
-
 id get_id() const;
-
- typedef implementation-defined native_handle_type;
 native_handle_type native_handle();

+ // static members:
 static unsigned hardware_concurrency();
};
</pre></blockquote>


Class <tt>thread</tt> and class <tt>thread::id</tt> shall be standard-layout
-types ([?]).
+types ([?]).


-<blockquote>
-<pre>thread();
-</pre>
-<blockquote>

-Effects: Constructs a <tt>thread</tt> object not attached to any thread
-of execution. [Note: This is the state of a <tt>thread</tt>
-object after <tt>detach</tt> or <tt>join</tt> is successfully called. -- end note]
+If and only if the <tt>thread</tt> type is internally represented by a single data structure which can be passed to operating system specific interfaces, then there shall be a nested implementation-defined typedef <tt>native_handle_type</tt> that is an alias to this native type if it is copyable. Otherwise, if the native type is not copyable, it is a pointer to this native type. The implementation shall document whether or not the <tt>native_handle_type</tt> typedef is present.

+

-Postconditions:
+If the nested typedef <tt>native_handle_type</tt> exists, then there
+also shall be a member function <tt>native_handle()</tt> which returns the
+underlying representation.

-<blockquote><pre>get_id() == thread::id()
-&& joinable() == false
-</pre></blockquote>
+
+<h5><tt>thread</tt> types</h5>
+<h6>Class <tt>thread::id</tt></h6>
+<pre>
+ class thread::id
+ {
+ public:
+ id();
+ };
+
+ bool operator==(const thread::id& x, const thread::id& y);
+ bool operator!=(const thread::id& x, const thread::id& y);
+ bool operator<(const thread::id& x, const thread::id& y);
+ bool operator<=(const thread::id& x, const thread::id& y);
+ bool operator>(const thread::id& x, const thread::id& y);
+ bool operator>=(const thread::id& x, const thread::id& y);
+
+ template<class charT, class traits>
+ basic_ostream<charT, traits>&
+ operator<< (basic_ostream<charT, traits>&& out, const thread::id& id);
+
+</pre>
+ Objects of type <tt>thread::id</tt> uniquely identify threads of execution.
+
+<blockquote><pre>id();
+</pre>
+
+<blockquote>

-Remarks: <tt>get_id()</tt> returns an identity that refers to
-not any thread. This identity compares equal to other
-non-<tt>join</tt>able <tt>thread</tt>s, and compares not equal to all
-other <tt>join</tt>able <tt>thread</tt>s.
+Effects: Constructs an object of type <tt>id</tt> which compares
+equal to other default constructed <tt>id</tt> objects.


Throws: Nothing.
@@ -280,41 +314,28 @@
</blockquote>
</blockquote>

-<blockquote><pre>template <class F, class ...Args> explicit thread(F f, Args&&... args);
+<blockquote><pre>bool operator==(const thread::id& x, const thread::id& y);
</pre>

<blockquote>

-Requires: <tt>F</tt> is a callable type [func.def]. If <tt>f</tt> is an lvalue, <tt>F</tt> must be <tt>CopyConstructible</tt>.
-If <tt>f</tt> is an rvalue, <tt>F</tt> must only be <tt>MoveConstructible</tt>.
-
-
-Effects: Constructs an object of type <tt>thread</tt> and executes <tt>INVOKE(f, t1, t2, ..., tN)</tt>
-in a new thread of execution, where <tt>t1, t2,
-..., tN</tt> are the values in <tt>args...</tt>. Any return value from <tt>f</tt> is ignored. If <tt>f</tt> terminates with an uncaught
-exception, <tt>std::terminate()</tt> shall be called.
-
-
-Postconditions:
+Returns: If neither <tt>x</tt> nor <tt>y</tt> identifies
+a thread of execution, returns <tt>true</tt>. Otherwise if
+<tt>x</tt> and <tt>y</tt> identify the same thread of execution,
+returns <tt>true</tt>. Otherwise returns <tt>false</tt>.

-<blockquote><pre>get_id() != thread::id()
-&& joinable() == true
-</pre>
-<code>*this</code> represents the newly started thread of execution.
-</blockquote>

-Throws: <tt>system_error</tt> if unable to start the new thread of execution.
+Throws: Nothing.

</blockquote>
</blockquote>

-<blockquote><pre>~thread()
+<blockquote><pre>bool operator!=(const thread::id& x, const thread::id& y);
</pre>

<blockquote>

-Effects: If <tt>joinable()</tt> then <tt><del class="diff modified">join()</del><ins class="diff modified">detach()</ins></tt>,
-otherwise no effects.
+Returns: <tt>!(x == y)</tt>


Throws: Nothing.
@@ -322,19 +343,17 @@
</blockquote>
</blockquote>

-<blockquote><pre>thread(thread&& x)
+
+<blockquote>
+<pre>bool operator<(const thread::id& x, const thread::id& y);
</pre>

<blockquote>

-Effects: Constructs an object of type <tt>thread</tt> from <tt>x</tt>.
+Returns: a value such that <tt>operator<</tt> is a total ordering as described in [alg.sorting].


-Postconditions: <tt>x.joinable()</tt> is <tt>false</tt>.
-<tt>x.get_id() == thread().get_id()</tt>. <tt>joinable()</tt>
-returns the value of <tt>x.joinable()</tt> prior to the start of construction.
-<tt>get_id()</tt> returns the value of <tt>x.get_id()</tt> prior to the
-start of construction.
+[Note: Defining a comparison operator allows <tt>thread::id</tt> objects to be used as keys in associative containers. --end note]


Throws: Nothing.
@@ -342,93 +361,79 @@
</blockquote>
</blockquote>

-<blockquote><pre>thread& operator=(thread&& x)
+<blockquote>
+<pre>bool operator<=(const thread::id& x, const thread::id& y);
</pre>
-
<blockquote>

-Effects: If <tt>this</tt> currently refers to a <tt>joinable</tt> <del class="diff modified">thread, </del><ins class="diff modified">thread object, </ins>calls
-<ins><tt><del class="diff modified">join()</del><ins class="diff modified">detach()</ins></tt></ins>. Then assigns the state of <tt>x</tt> to <tt>*this</tt>
-and sets <tt>x</tt> to a default constructed state.
-
+Returns: <tt>!(y < x)</tt> 

-Postconditions: <tt>x.joinable()</tt> is <tt>false</tt>.
-<tt>x.get_id() == thread().get_id()</tt>. <tt>joinable()</tt> returns the
-value of <tt>x.joinable()</tt> prior to the
-assignment.
-<tt>get_id()</tt> returns the value of <tt>x.get_id()</tt> prior to the
-assignment.
+Throws: Nothing.

-
-<del class="diff"><del></del>Throws: <del class="diff modified">Nothing.</del>
-</del><ins class="diff modified">Throws: Nothing.
-</ins>
</blockquote>
</blockquote>

-<blockquote><pre>void swap(thread&& x)
+<blockquote>
+<pre>bool operator>(const thread::id& x, const thread::id& y);
</pre>
-
<blockquote>

-Effects: Swaps the state of <tt>*this</tt> and <tt>x</tt>.
-
+Returns: <tt>y < x</tt> 

Throws: Nothing.

</blockquote>
</blockquote>

-<blockquote><pre>bool joinable() const
+<blockquote>
+<pre>bool operator>=(const thread::id& x, const thread::id& y);
</pre>
-
<blockquote>

-Returns: <tt>get_id() != id()</tt>.
-
+Returns: <tt>!(x < y)</tt> 

Throws: Nothing.

</blockquote>
</blockquote>

-<blockquote><pre>void join()
+<blockquote><pre>template<class charT, class traits>
+basic_ostream<charT, traits>&
+operator<< (basic_ostream<charT, traits>&& out, const thread::id& id);
</pre>

<blockquote>

-Preconditions: <tt>joinable()</tt> is <tt>true</tt>.
-
-
-Effects: The current thread of execution blocks until the thread of execution
-represented by <code>*this</code> completes.
-
-Postconditions: After a normal return of <tt>join()</tt>,
-<tt>joinable()</tt> is <tt>false</tt>. If <tt>join()</tt> throws an exception, the thread of execution represented by
-<tt>*this</tt> remains <tt>joinable</tt>.
+Effects: Inserts an unspecified text representation of the <tt>thread::id</tt> into
+the stream <tt>out</tt>.

-

-Throws: May throw <tt>system_error</tt>.
+Returns: <tt>out</tt>.

</blockquote>
</blockquote>

-<blockquote><pre>void detach()
+<h5><tt>thread</tt> constructors</h5>
+<blockquote>
+<pre>thread();
</pre>
-
<blockquote>

-Preconditions: <tt>joinable()</tt> is <tt>true</tt>.
+Effects: Constructs a <tt>thread</tt> object not attached to any thread
+of execution. [Note: This is the state of a <tt>thread</tt>
+object after <tt>detach</tt> or <tt>join</tt> is successfully called. -- end note]


-Effects: The thread of execution represented by
-<tt>*this</tt> continues execution. When the thread of execution represented by
-<tt>*this</tt> ends execution it shall release any owned resources.
+Postconditions:

+<blockquote><pre>get_id() == thread::id()
+&& joinable() == false
+</pre></blockquote>

-Postconditions: <tt>joinable()</tt> is <tt>false</tt>. <tt>*this</tt>
-does not represent a thread of execution.
+Remarks: <tt>get_id()</tt> returns an identity that refers to
+not any thread. This identity compares equal to other
+non-<tt>join</tt>able <tt>thread</tt>s, and compares not equal to all
+other <tt>join</tt>able <tt>thread</tt>s.


Throws: Nothing.
@@ -436,45 +441,62 @@
</blockquote>
</blockquote>

-<blockquote><pre>id get_id() const
+<blockquote><pre>template <class F, class ...Args> explicit thread(F f, Args&&... args);
</pre>

<blockquote>

-Returns: A <tt>thread::id</tt> which refers to the thread of execution
-represented by
-<tt>*this</tt>. If this
-<tt>thread</tt> is not <tt>joinable()</tt> returns a default constructed <tt>id</tt>.
+Requires: <tt>F</tt> is a callable type [func.def]. If <tt>f</tt> is an lvalue, <tt>F</tt> must be <tt>CopyConstructible</tt>.
+If <tt>f</tt> is an rvalue, <tt>F</tt> must only be <tt>MoveConstructible</tt>.


-Throws: Nothing.
+Effects: Constructs an object of type <tt>thread</tt> and executes <tt>INVOKE(f, t1, t2, ..., tN)</tt>
+in a new thread of execution, where <tt>t1, t2,
+..., tN</tt> are the values in <tt>args...</tt>. Any return value from <tt>f</tt> is ignored. If <tt>f</tt> terminates with an uncaught
+exception, <tt>std::terminate()</tt> shall be called.
+
+
+Postconditions:
+
+<blockquote><pre>get_id() != thread::id()
+&& joinable() == true
+</pre>
+<code>*this</code> represents the newly started thread of execution.
+</blockquote>
+
+Throws: <tt>system_error</tt> if unable to start the new thread of execution.

</blockquote>
</blockquote>

-<blockquote><pre>native_handle_type native_handle()
+<blockquote><pre>thread(thread&& x);
</pre>

<blockquote>

-Returns: An implementation defined type representing the underlying OS <ins class="diff">handle to the </ins>thread <del class="diff modified">handle.
-</del><ins class="diff modified">of execution.
-</ins>
+Effects: Constructs an object of type <tt>thread</tt> from <tt>x</tt>.
+
+
+Postconditions: <tt>x.joinable()</tt> is <tt>false</tt>.
+<tt>x.get_id() == thread().get_id()</tt>. <tt>joinable()</tt>
+returns the value of <tt>x.joinable()</tt> prior to the start of construction.
+<tt>get_id()</tt> returns the value of <tt>x.get_id()</tt> prior to the
+start of construction.
+

Throws: Nothing.

</blockquote>
</blockquote>

-<blockquote><pre>unsigned hardware_concurrency()
+<h5><tt>thread</tt> destructor</h5>
+<blockquote><pre>~thread();
</pre>

<blockquote>

-Returns: The number of threads <ins class="diff">of execution </ins>that can reasonably be expected to
-execute concurrently. [Note: This value should only be considered to be a hint.
---end note] If this value is not computable or well defined a
-return value of 1 is recommended, but not required.
+Effects: If <tt>joinable()</tt> then <tt>detach()</tt>,
+otherwise no effects.


Throws: Nothing.
@@ -482,48 +504,50 @@
</blockquote>
</blockquote>

-<blockquote>
-<pre>void swap(thread& x, thread& y);
-void swap(thread&& x, thread& y);
-void swap(thread& x, thread&& y);
+<h5><tt>thread</tt> assignment</h5>
+<blockquote><pre>thread& operator=(thread&& x);
</pre>
+
<blockquote>

-Effects: <tt>x.swap(y)</tt>.
+Effects: If <tt>this</tt> currently refers to a <tt>joinable</tt> thread object, calls
+<tt>detach()</tt>. Then assigns the state of <tt>x</tt> to <tt>*this</tt>
+and sets <tt>x</tt> to a default constructed state.
+
+
+Postconditions: <tt>x.joinable()</tt> is <tt>false</tt>.
+<tt>x.get_id() == thread().get_id()</tt>. <tt>joinable()</tt> returns the
+value of <tt>x.joinable()</tt> prior to the
+assignment.
+<tt>get_id()</tt> returns the value of <tt>x.get_id()</tt> prior to the
+assignment.
+
+
+Throws: Nothing.

</blockquote>
</blockquote>

-<blockquote><pre>template<class charT, class traits>
-basic_ostream<charT, traits>&
-operator<< (basic_ostream<charT, traits>&& out, const thread::id& id);
+<h5><tt>thread</tt> members</h5>
+<blockquote><pre>void swap(thread&& x);
</pre>

<blockquote>

-Effects: Inserts an unspecified text representation of the <tt>thread::id</tt> into
-the stream <tt>out</tt>.
+Effects: Swaps the state of <tt>*this</tt> and <tt>x</tt>.


-Returns: <tt>out</tt>.
+Throws: Nothing.

</blockquote>
</blockquote>

-<h5>Class <tt>thread::id</tt></h5>
-
-
-<tt>id</tt> is a nested class of <tt>thread</tt> which represents the identity of
-a thread of execution.
-
-
-<blockquote><pre>id()
+<blockquote><pre>bool joinable() const;
</pre>

<blockquote>

-Effects: Constructs an object of type <tt>id</tt> which compares
-equal to other default constructed <tt>id</tt> objects.
+Returns: <tt>get_id() != id()</tt>.


Throws: Nothing.
@@ -531,28 +555,43 @@
</blockquote>
</blockquote>

-<blockquote><pre>bool operator==(const id& x, const id& y)
+<blockquote><pre>void join();
</pre>

<blockquote>

-Returns: If <tt>x</tt> and <tt>y</tt> both represent
-not any thread, then returns <tt>true</tt>. Otherwise if
-<tt>x</tt> and <tt>y</tt> represent the same thread of execution, then
-returns <tt>true</tt>. Otherwise returns <tt>false</tt>.
+Preconditions: <tt>joinable()</tt> is <tt>true</tt>.


-Throws: Nothing.
+Effects: The current thread of execution blocks until the thread of execution
+represented by <code>*this</code> completes.
+
+Postconditions: After a normal return of <tt>join()</tt>,
+<tt>joinable()</tt> is <tt>false</tt>. If <tt>join()</tt> throws an exception, the thread of execution represented by
+<tt>*this</tt> remains <tt>joinable</tt>.
+
+
+
+Throws: May throw <tt>system_error</tt>.

</blockquote>
</blockquote>

-<blockquote><pre>bool operator!=(const id& x, const id& y)
+<blockquote><pre>void detach();
</pre>

<blockquote>

-Returns: <tt>!(x == y)</tt>
+Preconditions: <tt>joinable()</tt> is <tt>true</tt>.
+
+
+Effects: The thread of execution represented by
+<tt>*this</tt> continues execution. When the thread of execution represented by
+<tt>*this</tt> ends execution it shall release any owned resources.
+
+
+Postconditions: <tt>joinable()</tt> is <tt>false</tt>. <tt>*this</tt>
+does not represent a thread of execution.


Throws: Nothing.
@@ -560,20 +599,15 @@
</blockquote>
</blockquote>

-
-<blockquote>
-<pre>bool operator<(const id& x, const id& y)
+<blockquote><pre>id get_id() const;
</pre>

<blockquote>

-Returns: Provides an ordering for all objects of type <code>id</code>, such that
-objects of type <code>id</code> can be used as a key in Associate Containers.
-For two objects of type <code>id</code>,
-<code>x</code> and <code>y</code>, if
-<code>x == y</code> returns <code>true</code>, both <code>x < y</code> and <code>y < x</code> shall return
-<code>false</code>. Otherwise, precisely one of <code>x < y</code> and <code>y < x</code> shall return
-<code>true</code>.
+Returns: An object of type <tt>thread::id</tt> which identifies the thread of execution
+represented by
+<tt>*this</tt>. If this
+<tt>thread</tt> is not <tt>joinable()</tt> returns a default constructed <tt>thread::id</tt>.


Throws: Nothing.
@@ -581,42 +615,51 @@
</blockquote>
</blockquote>

-<blockquote>
-<pre>bool operator<=(const id& x, const id& y)
+<blockquote><pre>native_handle_type native_handle();
</pre>
+
<blockquote>

-Returns: <tt>!(y < x)</tt> 
+Returns: The underlying representation of the thread object.
+

Throws: Nothing.

</blockquote>
</blockquote>

-<blockquote>
-<pre>bool operator>(const id& x, const id& y)
+<h5><tt>thread</tt> static members</h5>
+<blockquote><pre>unsigned hardware_concurrency();
</pre>
+
<blockquote>

-Returns: <tt>y < x</tt> 
+Returns: The number of threads of execution that can reasonably be expected to
+execute concurrently. [Note: This value should only be considered to be a hint.
+--end note] If this value is not computable or well defined a
+return value of 1 is recommended, but not required.
+

Throws: Nothing.

</blockquote>
</blockquote>

+<h5><tt>thread</tt> specialized algorithms</h5>
<blockquote>
-<pre>bool operator>=(const id& x, const id& y)
+<pre>void swap(thread& x, thread& y);
+void swap(thread&& x, thread& y);
+void swap(thread& x, thread&& y);
</pre>
<blockquote>

-Returns: <tt>!(x < y)</tt> 
-
-Throws: Nothing.
+Effects: <tt>x.swap(y)</tt>.

</blockquote>
</blockquote>

+
+
<h4>Namespace <tt>this_thread</tt></h4>

<blockquote><pre>namespace this_thread
@@ -630,13 +673,12 @@
} // this_thread
</pre></blockquote>

-<blockquote><pre>thread::id this_thread::get_id()
+<blockquote><pre>thread::id this_thread::get_id();
</pre>

<blockquote>

-Returns: Returns the <tt>id</tt> of the current <del class="diff modified">thread. </del><ins class="diff modified">thread of execution. </ins> The return shall not be
-equal to a default constructed <tt>thread::id</tt>.
+Returns: Returns an object of type <tt>thread::id</tt> that uniquely identifies the current thread of execution. The object returned shall not compare equal to a default constructed <tt>thread::id</tt>.


Throws: Nothing.
@@ -644,14 +686,12 @@
</blockquote>
</blockquote>

-<blockquote><pre>void yield()
+<blockquote><pre>void yield();
</pre>

<blockquote>

-Effects: Offers the operating system the chance to schedule another <del class="diff modified">thread.
-</del><ins class="diff modified">thread of execution.
-</ins>
+Effects: Offers the operating system the opportunity to schedule another thread of execution.

Throws: Nothing.

@@ -659,7 +699,7 @@
</blockquote>

<blockquote><pre>template <class ElapsedTime>
- void sleep(const ElapsedTime& rel_t)
+ void sleep(const ElapsedTime& rel_t);
</pre>

<blockquote>
@@ -702,7 +742,7 @@
<blockquote>

<pre>template<class Callable, class Args...>
-void call_once(once_flag& flag, Callable func, Args... args);
+void call_once(once_flag& flag, Callable func, Args&&... args);
</pre>

 <blockquote>
@@ -720,7 +760,7 @@
 called multiple times for the same <code>once_flag</code> object. If multiple
 calls to <code>call_once</code> with the same <code>once_flag</code> object
 occur in separate threads of execution, only one
- thread <ins class="diff">of execution </ins>shall call <code>func</code>, and none of the threads <ins class="diff">of execution </ins>shall proceed until the call to <code>func</code> has completed.
+ thread of execution shall call <code>func</code>, and none shall proceed until the call to <code>func</code> has completed.
 If the invocation of <code>func</code> results in an exception being thrown,
 the exception is propagated to the caller and the effects are as-if this
 invocation of <code>call_once</code> did not occur.
@@ -1666,51 +1706,45 @@

<h3><a name="ConditionVariablesWording">Condition variables</a></h3>

-<condition_variable> synopsis
+<cond_varcondition_variable> synopsis

<blockquote><pre>namespace std {

-class condition_variable;
-class condition_variable_any;
+class cond_varcondition_variable;
+class gen_cond_vargeneral_condition_variable;

} // std
</pre></blockquote>

-<h4>Class condition_variable</h4>
+<h4>Class cond_varcondition_variable</h4>


-An object of class <tt>condition_variable</tt> is a synchronization primitive
+An object of class <tt>cond_varcondition_variable</tt> is a synchronization primitive
used to cause a thread of execution to wait until notified by some other
thread of execution that some condition is met, or a UTC[(?)] time is reached.


-
-If and only if the condition variable type is internally represented by an object
-which can be passed to operating system specific interfaces, then there shall be a
-implementation-defined member typedef <tt>native_handle_type</tt> that is an alias
-to this native type, if it is copyable, or if the native type is not copyable,
-a pointer to this native type. The implementation shall document whether the
-<tt>native_handle_type</tt> member typedef is present.
-
-
-
-If the nested typedef <tt>native_handle_type</tt> exists, then there
-also shall be a member function <tt>native_handle()</tt> which returns the
-underlying representation.
-
-
<blockquote><pre>namespace std {

-class condition_variable
+class cond_varcondition_variable
{
public:
- typedef implementation-defined native_handle_type;
-
- condition_variable();
- ~condition_variable();
-
- condition_variable(const condition_variable&) = delete;
- condition_variable& operator=(const condition_variable&) = delete;
+ cond_varcondition_variable();
+ ~cond_varcondition_variable();
+
+ cond_varcondition_variable(const cond_varcondition_variable&) = delete;
+ cond_varcondition_variable& operator=(const cond_varcondition_variable&) = delete;

 void notify_one();
 void notify_all();
@@ -1720,24 +1754,26 @@
 bool timed_wait(unique_lock<mutex>& lock, const utc_time& abs_time);
 template <class Predicate>
 bool timed_wait(unique_lock<mutex>& lock, const utc_time& abs_time, Predicate pred);
- native_handle_type native_handle();
};

} // std
</pre></blockquote>

<blockquote>
-<pre>condition_variable();
+<pre>cond_varcondition_variable();
</pre>
<blockquote>

-Effects: Constructs an object of class <tt>condition_variable</tt>.
+Effects: Constructs an object of class <tt>cond_varcondition_variable</tt>.

</blockquote>
</blockquote>

<blockquote>
-<pre>~condition_variable();
+<pre>~cond_varcondition_variable();
</pre>
<blockquote>

@@ -1755,11 +1791,12 @@
<blockquote>

Effects: If any threads of execution are blocked waiting for <code>*this</code>,
-unblocks at least one those threads of execution.
+unblocks at least one those threads of execution.

Thread safety: Calls to the <code>wait</code>,
<code>timed_wait</code>, <code>notify_one</code> or
-<code>notify_all</code> member functions of the same <tt>condition_variable</tt>
+<code>notify_all</code> member functions of the same <tt>condition_variable</tt>
object from different threads of execution shall not result in data
races or deadlocks.

@@ -1771,12 +1808,13 @@
</pre>
<blockquote>

-Effects: Unblock all threads of execution that are blocked waiting for <code>*this</code>.
+Effects: Unblock all threads of execution that are blocked waiting for <code>*this</code>.


Thread safety: Calls to the <code>wait</code>,
<code>timed_wait</code>, <code>notify_one</code> or
-<code>notify_all</code> member functions of the same <tt>condition_variable</tt>
+<code>notify_all</code> member functions of the same <tt>condition_variable</tt>
object from different threads of execution shall not result in data
races or deadlocks.

@@ -1789,15 +1827,19 @@
<blockquote>

Precondition: <tt>lock</tt> is locked by the current thread of execution. No
-other thread of execution is waiting on this <tt>condition_variable</tt> object unless <tt>lock</tt>
+other thread of execution is waiting on this <tt>cond_varcondition_variable</tt> object unless <tt>lock</tt>
refers to the same underlying <tt>mutex</tt> object.


Effects: Atomically blocks and releases the lock on
<tt>lock</tt>. If the <tt>wait</tt> should throw an exception for any
-reason, <tt>lock</tt> will be locked as the exception propagates.
-This thread of execution shall unblock when another threadof execution issues a
-notification to this blocked thread of execution. The current thread of execution may
+reason, <tt>lock</tt> will be locked as the exception propagates out.
+This thread of execution shall unblock when another thread
+of execution issues a
+notification to this blocked thread
+of execution . The current thread of execution may
unblock and return even in the absence of a notification.


@@ -1809,7 +1851,8 @@

Thread safety: Calls to the <code>wait</code>,
<code>timed_wait</code>, <code>notify_one</code> or
-<code>notify_all</code> member functions of the same <tt>condition_variable</tt>
+<code>notify_all</code> member functions of the same <tt>condition_variable</tt>
object from different threads of execution shall not result in data
races or deadlocks.

@@ -1837,7 +1880,8 @@
<blockquote>

Precondition: The <tt>lock</tt> is locked by the current thread of execution. No
-other thread of execution is waiting on this <tt>condition_variable</tt> object unless <tt>lock</tt>
+other thread of execution is waiting on this <tt>cond_varcondition_variable</tt> object unless <tt>lock</tt>
refers to, the same underlying <tt>mutex</tt> object.


@@ -1846,10 +1890,13 @@
any reason, <tt>lock</tt> will be locked as the exception propagates
out. If the absolute time specified by <tt>abs_time</tt> passes (that
is, system time equals or exceeds <tt>abs_time</tt>) before the
-<tt>condition_variable</tt> is notified, or if the absolute time specified by
+<tt>condition_variable</tt> is notified, or if the absolute time specified by
<tt>abs_time</tt> has already been passed at the time of the call, then
<tt>false</tt> is returned. This thread of execution shall unblock when
-another thread of execution issues a notification to this blocked thread of execution . The current
+another thread
+of execution issues a notification to this blocked thread
+of execution . The current
thread of execution may unblock and return even in the absence of a
notification.

@@ -1867,14 +1914,15 @@

Thread safety: Calls to the <code>wait</code>,
<code>timed_wait</code>, <code>notify_one</code> or
-<code>notify_all</code> member functions of the same <tt>condition_variable</tt>
+<code>notify_all</code> member functions of the same <tt>condition_variable</tt>
object from different threads of execution shall not result in data
races or deadlocks.
</blockquote>
</blockquote>

<blockquote>
-<pre>template <class Predicate>
+<pre>template <class _Predicate>
 bool timed_wait(unique_lock<mutex>& lock, const utc_time& abs_time, Predicate pred);
</pre>
<blockquote>
@@ -1899,25 +1947,17 @@
</blockquote>
</blockquote>

-<blockquote>
-<pre>native_handle_type native_handle();
-</pre>
-<blockquote>
-
-Returns: the representation of the underlying object used to implement <tt>*this</tt>.
-
-</blockquote>
-</blockquote>
-
-

-<tt>condition_variable</tt> shall be a standard-layout type ([?]).
+<tt>cond_varcondition_variable</tt> shall be a standard-layout type ([?]).


-<h4>Class condition_variable_any</h4>
+<h4>Class gen_cond_vargeneral_condition_variable</h4>


-An object of class <tt>condition_variable_any</tt> is a synchronization primitive
+An object of class <tt>gen_cond_vargeneral_condition_variable</tt> is a synchronization primitive
used to cause a thread of execution to wait until notified by some other
thread of execution that some condition is met, or a UTC[(?)] time is reached.

@@ -1928,33 +1968,23 @@
meet this requirement.


-
-If and only if the <tt>condition_variable_any</tt> type is internally represented by an
-an object or objects which can be passed to operating system specific interfaces, then
-there shall be a nested implementation-defined typedef <tt>native_handle_type</tt> that
-is an alias to a type providing access to the object or objects. The type
-<tt>native_handle_type</tt> must be copyable; if the object or objects are not copyable,
-<tt>native_handle_type</tt> must be a pointer type. The implementation shall document
-whether the <tt>native_handle_type</tt> typedef is present.
-
-
-
-If the nested typedef <tt>native_handle_type</tt> exists, then there
-also shall be a member function <tt>native_handle()</tt> which returns the
-underlying representation.
-
-
<blockquote><pre>namespace std {

-class condition_variable_any
+class gen_cond_vargeneral_condition_variable
{
public:
- typedef implementation-defined native_handle_type;
- condition_variable_any();
- ~condition_variable_any();
-
- condition_variable_any(const condition_variable_any&) = delete;
- condition_variable_any& operator=(const condition_variable_any&) = delete;
+ gen_cond_vargeneral_condition_variable();
+ ~gen_cond_vargeneral_condition_variable();
+
+ gen_cond_vargeneral_condition_variable(const gen_cond_vargeneral_condition_variable&) = delete;
+ gen_cond_vargeneral_condition_variable& operator=(const gen_cond_vargeneral_condition_variable&) = delete;

 void notify_one();
 void notify_all();
@@ -1966,24 +1996,26 @@
 bool timed_wait(Lock& lock, const utc_time& abs_time);
 template <class Lock, class Predicate>
 bool timed_wait(Lock& lock, const utc_time& abs_time, Predicate pred);
- native_handle_type native_handle();
};

} // std
</pre></blockquote>

<blockquote>
-<pre>condition_variable_any();
+<pre>gen_cond_vargeneral_condition_variable();
</pre>
<blockquote>

-Effects: Constructs an object of class <tt>condition_variable_any</tt>.
+Effects: Constructs an object of class <tt>gen_cond_vargeneral_condition_variable</tt>.

</blockquote>
</blockquote>

<blockquote>
-<pre>~condition_variable_any();
+<pre>~gen_cond_vargeneral_condition_variable();
</pre>
<blockquote>

@@ -2001,11 +2033,13 @@
<blockquote>

Effects: If any threads of execution are blocked waiting for <code>*this</code>,
-unblocks at least one those threads of execution.
+unblocks at least one those threads of execution.

Thread safety: Calls to the <code>wait</code>,
<code>timed_wait</code>, <code>notify_one</code> or
-<code>notify_all</code> member functions of the same <tt>condition_variable_any</tt>
+<code>notify_all</code> member functions of the same <tt>general_condition_variable</tt>
object from different threads of execution shall not result in data
races or deadlocks.

@@ -2017,12 +2051,15 @@
</pre>
<blockquote>

-Effects: Unblock all threads of execution that are blocked waiting for <code>*this</code>.
+Effects: Unblock all threads 
+of executionthat are blocked waiting for <code>*this</code>.


Thread safety: Calls to the <code>wait</code>,
<code>timed_wait</code>, <code>notify_one</code> or
-<code>notify_all</code> member functions of the same <tt>condition_variable_any</tt>
+<code>notify_all</code> member functions of the same <tt>general_condition_variable</tt>
object from different threads of execution shall not result in data
races or deadlocks.

@@ -2036,15 +2073,19 @@

Precondition: <tt>lock</tt> is locked by the current thread of execution. If
<tt>Lock</tt> supports recursive locking, the lock count is one. No
-other thread of execution is waiting on this <tt>condition_variable_any</tt> object unless <tt>lock</tt>
+other thread of execution is waiting on this <tt>gen_cond_vargeneral_condition_variable</tt> object unless <tt>lock</tt>
is, or refers to, the same underlying mutex object.


Effects: Atomically blocks and releases the lock on
<tt>lock</tt>. If the <tt>wait</tt> should throw an exception for any
-reason, <tt>lock</tt> will be locked as the exception propagates.
-This thread of execution shall unblock when another thread of execution issues a
-notification to this blocked thread of execution. The current thread of execution may
+reason, <tt>lock</tt> will be locked as the exception propagates out.
+This thread of execution shall unblock when another thread
+of execution issues a
+notification to this blocked thread
+of execution. The current thread of execution may
unblock and return even in the absence of a notification.


@@ -2056,7 +2097,9 @@

Thread safety: Calls to the <code>wait</code>,
<code>timed_wait</code>, <code>notify_one</code> or
-<code>notify_all</code> member functions of the same <tt>condition_variable_any</tt>
+<code>notify_all</code> member functions of the same <tt>general_condition_variable</tt>
object from different threads of execution shall not result in data
races or deadlocks.

@@ -2085,7 +2128,8 @@

Precondition: The <tt>lock</tt> is locked by the current thread of execution. If
<tt>Lock</tt> supports recursive locking, the lock count is one. No
-other thread of execution is waiting on this <tt>condition_variable_any</tt> object unless <tt>lock</tt>
+other thread of execution is waiting on this <tt>gen_cond_vargeneral_condition_variable</tt> object unless <tt>lock</tt>
is, or refers to, the same underlying mutex object.


@@ -2094,10 +2138,14 @@
any reason, <tt>lock</tt> will be locked as the exception propagates
out. If the absolute time specified by <tt>abs_time</tt> passes (that
is, system time equals or exceeds <tt>abs_time</tt>) before the
-<tt>condition_variable_any</tt> is notified, or if the absolute time specified by
+<tt>general_condition_variable</tt> is notified, or if the absolute time specified by
<tt>abs_time</tt> has already been passed at the time of the call, then
<tt>false</tt> is returned. This thread of execution shall unblock when
-another thread of execution issues a notification to this blocked thread of execution. The current
+another thread
+of execution issues a notification to this blocked thread
+of execution. The current
thread of execution may unblock and return even in the absence of a
notification.

@@ -2115,7 +2163,9 @@

Thread safety: Calls to the <code>wait</code>,
<code>timed_wait</code>, <code>notify_one</code> or
-<code>notify_all</code> member functions of the same <tt>condition_variable_any</tt>
+<code>notify_all</code> member functions of the same <tt>general_condition_variable</tt>
object from different threads of execution shall not result in data
races or deadlocks.
</blockquote>
@@ -2147,15 +2197,6 @@
</blockquote>
</blockquote>

-<blockquote>
-<pre>native_handle_type native_handle();
-</pre>
-<blockquote>
-
-Returns: the representation of the underlying object or objects used to implement <tt>*this</tt>.
-
-</blockquote>
-</blockquote>

<hr/>

@@ -3115,3 +3156,4 @@

</div></body></html><ins class="diff">
</ins>
+

Next message: bdawes_at_[hidden]: "[Boost-commit] svn:boost r39804 - sandbox/committee/LWG"
Previous message: bdawes_at_[hidden]: "[Boost-commit] svn:boost r39802 - sandbox/committee/LWG"

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk