mirror of
https://github.com/boostorg/thread.git
synced 2026-02-03 09:42:16 +00:00
Compare commits
6 Commits
feature/ad
...
boost-1.33
| Author | SHA1 | Date | |
|---|---|---|---|
|
283ce1df6c | ||
|
e552e010fd | ||
|
c52357636b | ||
|
|
2cb4dbb07f | ||
|
|
9ca3c5b13f | ||
|
|
7445f79dd4 |
@@ -30,7 +30,6 @@ import ./threads ;
|
||||
mutex
|
||||
once
|
||||
recursive_mutex
|
||||
read_write_mutex
|
||||
thread
|
||||
tss_hooks
|
||||
tss_dll
|
||||
|
||||
@@ -12,14 +12,8 @@ last-revision="$Date$">
|
||||
<para>Mac OS Carbon implementation written by Mac Murrett.</para>
|
||||
<para>Dave Moore provided initial submissions and further comments on the
|
||||
<code>barrier</code>
|
||||
,
|
||||
<code>thread_pool</code>
|
||||
,
|
||||
<code>read_write_mutex</code>
|
||||
,
|
||||
<code>read_write_try_mutex</code>
|
||||
and
|
||||
<code>read_write_timed_mutex</code>
|
||||
<code>thread_pool</code>
|
||||
classes.</para>
|
||||
<para>Important contributions were also made by Jeremy Siek (lots of input
|
||||
on the design and on the implementation), Alexander Terekhov (lots of input
|
||||
|
||||
1561
doc/concepts.xml
1561
doc/concepts.xml
File diff suppressed because it is too large
Load Diff
@@ -1,458 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
|
||||
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd" [
|
||||
<!ENTITY % threads.entities SYSTEM "entities.xml">
|
||||
%threads.entities;
|
||||
]>
|
||||
<header name="boost/thread/read_write_mutex.hpp"
|
||||
last-revision="$Date$">
|
||||
<namespace name="boost">
|
||||
<namespace name="read_write_scheduling_policy">
|
||||
<enum name="read_write_scheduling_policy">
|
||||
<enumvalue name="writer_priority" />
|
||||
<enumvalue name="reader_priority" />
|
||||
<enumvalue name="alternating_many_reads" />
|
||||
<enumvalue name="alternating_single_read" />
|
||||
|
||||
<purpose>
|
||||
<para>Specifies the
|
||||
<link linkend="threads.concepts.read-write-scheduling-policies.inter-class">inter-class sheduling policy</link>
|
||||
to use when a set of threads try to obtain different types of
|
||||
locks simultaneously.</para>
|
||||
</purpose>
|
||||
|
||||
<description>
|
||||
<para>The only clock type supported by &Boost.Threads; is
|
||||
<code>TIME_UTC</code>. The epoch for <code>TIME_UTC</code>
|
||||
is 1970-01-01 00:00:00.</para>
|
||||
</description>
|
||||
</enum>
|
||||
</namespace>
|
||||
|
||||
<class name="read_write_mutex">
|
||||
<purpose>
|
||||
<para>The <classname>read_write_mutex</classname> class is a model of the
|
||||
<link linkend="threads.concepts.ReadWriteMutex">ReadWriteMutex</link> concept.</para>
|
||||
</purpose>
|
||||
|
||||
<description>
|
||||
<para>The <classname>read_write_mutex</classname> class is a model of the
|
||||
<link linkend="threads.concepts.ReadWriteMutex">ReadWriteMutex</link> concept.
|
||||
It should be used to synchronize access to shared resources using
|
||||
<link linkend="threads.concepts.read-write-locking-strategies.unspecified">Unspecified</link>
|
||||
locking mechanics.</para>
|
||||
|
||||
<para>For classes that model related mutex concepts, see
|
||||
<classname>try_read_write_mutex</classname> and <classname>timed_read_write_mutex</classname>.</para>
|
||||
|
||||
<para>The <classname>read_write_mutex</classname> class supplies the following typedefs,
|
||||
which <link linkend="threads.concepts.read-write-lock-models">model</link>
|
||||
the specified locking strategies:
|
||||
|
||||
<informaltable>
|
||||
<tgroup cols="2" align="left">
|
||||
<thead>
|
||||
<row>
|
||||
<entry>Lock Name</entry>
|
||||
<entry>Lock Concept</entry>
|
||||
</row>
|
||||
</thead>
|
||||
<tbody>
|
||||
<row>
|
||||
<entry>scoped_read_write_lock</entry>
|
||||
<entry><link linkend="threads.concepts.ScopedReadWriteLock">ScopedReadWriteLock</link></entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>scoped_read_lock</entry>
|
||||
<entry><link linkend="threads.concepts.ScopedLock">ScopedLock</link></entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>scoped_write_lock</entry>
|
||||
<entry><link linkend="threads.concepts.ScopedLock">ScopedLock</link></entry>
|
||||
</row>
|
||||
</tbody>
|
||||
</tgroup>
|
||||
</informaltable>
|
||||
</para>
|
||||
|
||||
<para>The <classname>read_write_mutex</classname> class uses an
|
||||
<link linkend="threads.concepts.read-write-locking-strategies.unspecified">Unspecified</link>
|
||||
locking strategy, so attempts to recursively lock a <classname>read_write_mutex</classname>
|
||||
object or attempts to unlock one by threads that don't own a lock on it result in
|
||||
<emphasis role="bold">undefined behavior</emphasis>.
|
||||
This strategy allows implementations to be as efficient as possible
|
||||
on any given platform. It is, however, recommended that
|
||||
implementations include debugging support to detect misuse when
|
||||
<code>NDEBUG</code> is not defined.</para>
|
||||
|
||||
<para>Like all
|
||||
<link linkend="threads.concepts.read-write-mutex-models">read/write mutex models</link>
|
||||
in &Boost.Threads;, <classname>read_write_mutex</classname> has two types of
|
||||
<link linkend="threads.concepts.read-write-scheduling-policies">scheduling policies</link>, an
|
||||
<link linkend="threads.concepts.read-write-scheduling-policies.inter-class">inter-class sheduling policy</link>
|
||||
between threads trying to obtain different types of locks and an
|
||||
<link linkend="threads.concepts.read-write-scheduling-policies.intra-class">intra-class sheduling policy</link>
|
||||
between threads trying to obtain the same type of lock.
|
||||
The <classname>read_write_mutex</classname> class allows the
|
||||
programmer to choose what
|
||||
<link linkend="threads.concepts.read-write-scheduling-policies.inter-class">inter-class sheduling policy</link>
|
||||
will be used; however, like all read/write mutex models,
|
||||
<classname>read_write_mutex</classname> leaves the
|
||||
<link linkend="threads.concepts.read-write-scheduling-policies.intra-class">intra-class sheduling policy</link> as
|
||||
<link linkend="threads.concepts.read-write-locking-strategies.unspecified">Unspecified</link>.
|
||||
</para>
|
||||
|
||||
<note>Self-deadlock is virtually guaranteed if a thread tries to
|
||||
lock the same <classname>read_write_mutex</classname> multiple times
|
||||
unless all locks are read-locks (but see below)</note>
|
||||
</description>
|
||||
|
||||
<inherit access="private">
|
||||
<type><classname>boost::noncopyable</classname></type>
|
||||
<purpose>Exposition only</purpose>
|
||||
</inherit>
|
||||
|
||||
<inherit access="private">
|
||||
<type><classname>boost::noncopyable</classname></type>
|
||||
<purpose>Exposition only</purpose>
|
||||
</inherit>
|
||||
|
||||
<typedef name="scoped_read_write_lock">
|
||||
<type><emphasis>implementation-defined</emphasis></type>
|
||||
</typedef>
|
||||
|
||||
<typedef name="scoped_read_lock">
|
||||
<type><emphasis>implementation-defined</emphasis></type>
|
||||
</typedef>
|
||||
|
||||
<typedef name="scoped_write_lock">
|
||||
<type><emphasis>implementation-defined</emphasis></type>
|
||||
</typedef>
|
||||
|
||||
<constructor>
|
||||
<parameter name="count">
|
||||
<paramtype>boost::read_write_scheduling_policy</paramtype>
|
||||
</parameter>
|
||||
|
||||
<effects>Constructs a <classname>read_write_mutex</classname> object.
|
||||
</effects>
|
||||
|
||||
<postconditions><code>*this</code> is in an unlocked state.
|
||||
</postconditions>
|
||||
</constructor>
|
||||
|
||||
<destructor>
|
||||
<effects>Destroys a <classname>read_write_mutex</classname> object.</effects>
|
||||
|
||||
<requires><code>*this</code> is in an unlocked state.</requires>
|
||||
|
||||
<notes><emphasis role="bold">Danger:</emphasis> Destruction of a
|
||||
locked mutex is a serious programming error resulting in undefined
|
||||
behavior such as a program crash.</notes>
|
||||
</destructor>
|
||||
</class>
|
||||
|
||||
<class name="try_read_write_mutex">
|
||||
<purpose>
|
||||
<para>The <classname>try_read_write_mutex</classname> class is a model of the
|
||||
<link linkend="threads.concepts.TryReadWriteMutex">TryReadWriteMutex</link> concept.</para>
|
||||
</purpose>
|
||||
|
||||
<description>
|
||||
<para>The <classname>try_read_write_mutex</classname> class is a model of the
|
||||
<link linkend="threads.concepts.TryReadWriteMutex">TryReadWriteMutex</link> concept.
|
||||
It should be used to synchronize access to shared resources using
|
||||
<link linkend="threads.concepts.read-write-locking-strategies.unspecified">Unspecified</link>
|
||||
locking mechanics.</para>
|
||||
|
||||
<para>For classes that model related mutex concepts, see
|
||||
<classname>read_write_mutex</classname> and <classname>timed_read_write_mutex</classname>.</para>
|
||||
|
||||
<para>The <classname>try_read_write_mutex</classname> class supplies the following typedefs,
|
||||
which <link linkend="threads.concepts.read-write-lock-models">model</link>
|
||||
the specified locking strategies:
|
||||
|
||||
<informaltable>
|
||||
<tgroup cols="2" align="left">
|
||||
<thead>
|
||||
<row>
|
||||
<entry>Lock Name</entry>
|
||||
<entry>Lock Concept</entry>
|
||||
</row>
|
||||
</thead>
|
||||
<tbody>
|
||||
<row>
|
||||
<entry>scoped_read_write_lock</entry>
|
||||
<entry><link linkend="threads.concepts.ScopedReadWriteLock">ScopedReadWriteLock</link></entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>scoped_try_read_write_lock</entry>
|
||||
<entry><link linkend="threads.concepts.ScopedTryReadWriteLock">ScopedTryReadWriteLock</link></entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>scoped_read_lock</entry>
|
||||
<entry><link linkend="threads.concepts.ScopedLock">ScopedLock</link></entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>scoped_try_read_lock</entry>
|
||||
<entry><link linkend="threads.concepts.ScopedTryLock">ScopedTryLock</link></entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>scoped_write_lock</entry>
|
||||
<entry><link linkend="threads.concepts.ScopedLock">ScopedLock</link></entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>scoped_try_write_lock</entry>
|
||||
<entry><link linkend="threads.concepts.ScopedTryLock">ScopedTryLock</link></entry>
|
||||
</row>
|
||||
</tbody>
|
||||
</tgroup>
|
||||
</informaltable>
|
||||
</para>
|
||||
|
||||
<para>The <classname>try_read_write_mutex</classname> class uses an
|
||||
<link linkend="threads.concepts.read-write-locking-strategies.unspecified">Unspecified</link>
|
||||
locking strategy, so attempts to recursively lock a <classname>try_read_write_mutex</classname>
|
||||
object or attempts to unlock one by threads that don't own a lock on it result in
|
||||
<emphasis role="bold">undefined behavior</emphasis>.
|
||||
This strategy allows implementations to be as efficient as possible
|
||||
on any given platform. It is, however, recommended that
|
||||
implementations include debugging support to detect misuse when
|
||||
<code>NDEBUG</code> is not defined.</para>
|
||||
|
||||
<para>Like all
|
||||
<link linkend="threads.concepts.read-write-mutex-models">read/write mutex models</link>
|
||||
in &Boost.Threads;, <classname>try_read_write_mutex</classname> has two types of
|
||||
<link linkend="threads.concepts.read-write-scheduling-policies">scheduling policies</link>, an
|
||||
<link linkend="threads.concepts.read-write-scheduling-policies.inter-class">inter-class sheduling policy</link>
|
||||
between threads trying to obtain different types of locks and an
|
||||
<link linkend="threads.concepts.read-write-scheduling-policies.intra-class">intra-class sheduling policy</link>
|
||||
between threads trying to obtain the same type of lock.
|
||||
The <classname>try_read_write_mutex</classname> class allows the
|
||||
programmer to choose what
|
||||
<link linkend="threads.concepts.read-write-scheduling-policies.inter-class">inter-class sheduling policy</link>
|
||||
will be used; however, like all read/write mutex models,
|
||||
<classname>try_read_write_mutex</classname> leaves the
|
||||
<link linkend="threads.concepts.read-write-scheduling-policies.intra-class">intra-class sheduling policy</link> as
|
||||
<link linkend="threads.concepts.unspecified-scheduling-policy">Unspecified</link>.
|
||||
</para>
|
||||
|
||||
<note>Self-deadlock is virtually guaranteed if a thread tries to
|
||||
lock the same <classname>try_read_write_mutex</classname> multiple times
|
||||
unless all locks are read-locks (but see below)</note>
|
||||
</description>
|
||||
|
||||
<inherit access="private">
|
||||
<type><classname>boost::noncopyable</classname></type>
|
||||
<purpose>Exposition only</purpose>
|
||||
</inherit>
|
||||
|
||||
<typedef name="scoped_read_write_lock">
|
||||
<type><emphasis>implementation-defined</emphasis></type>
|
||||
</typedef>
|
||||
|
||||
<typedef name="scoped_try_read_write_lock">
|
||||
<type><emphasis>implementation-defined</emphasis></type>
|
||||
</typedef>
|
||||
|
||||
<typedef name="scoped_read_lock">
|
||||
<type><emphasis>implementation-defined</emphasis></type>
|
||||
</typedef>
|
||||
|
||||
<typedef name="scoped_try_read_lock">
|
||||
<type><emphasis>implementation-defined</emphasis></type>
|
||||
</typedef>
|
||||
|
||||
<typedef name="scoped_write_lock">
|
||||
<type><emphasis>implementation-defined</emphasis></type>
|
||||
</typedef>
|
||||
|
||||
<typedef name="scoped_try_write_lock">
|
||||
<type><emphasis>implementation-defined</emphasis></type>
|
||||
</typedef>
|
||||
|
||||
<constructor>
|
||||
<parameter name="count">
|
||||
<paramtype>boost::read_write_scheduling_policy</paramtype>
|
||||
</parameter>
|
||||
|
||||
<effects>Constructs a <classname>try_read_write_mutex</classname> object.
|
||||
</effects>
|
||||
|
||||
<postconditions><code>*this</code> is in an unlocked state.
|
||||
</postconditions>
|
||||
</constructor>
|
||||
|
||||
<destructor>
|
||||
<effects>Destroys a <classname>try_read_write_mutex</classname> object.</effects>
|
||||
|
||||
<requires><code>*this</code> is in an unlocked state.</requires>
|
||||
|
||||
<notes><emphasis role="bold">Danger:</emphasis> Destruction of a
|
||||
locked mutex is a serious programming error resulting in undefined
|
||||
behavior such as a program crash.</notes>
|
||||
</destructor>
|
||||
</class>
|
||||
|
||||
<class name="timed_read_write_mutex">
|
||||
<purpose>
|
||||
<para>The <classname>timed_read_write_mutex</classname> class is a model of the
|
||||
<link linkend="threads.concepts.TimedReadWriteMutex">TimedReadWriteMutex</link> concept.</para>
|
||||
</purpose>
|
||||
|
||||
<description>
|
||||
<para>The <classname>timed_read_write_mutex</classname> class is a model of the
|
||||
<link linkend="threads.concepts.TimedReadWriteMutex">TimedReadWriteMutex</link> concept.
|
||||
It should be used to synchronize access to shared resources using
|
||||
<link linkend="threads.concepts.read-write-locking-strategies.unspecified">Unspecified</link>
|
||||
locking mechanics.</para>
|
||||
|
||||
<para>For classes that model related mutex concepts, see
|
||||
<classname>read_write_mutex</classname> and <classname>try_read_write_mutex</classname>.</para>
|
||||
|
||||
<para>The <classname>timed_read_write_mutex</classname> class supplies the following typedefs,
|
||||
which <link linkend="threads.concepts.read-write-lock-models">model</link>
|
||||
the specified locking strategies:
|
||||
|
||||
<informaltable>
|
||||
<tgroup cols="2" align="left">
|
||||
<thead>
|
||||
<row>
|
||||
<entry>Lock Name</entry>
|
||||
<entry>Lock Concept</entry>
|
||||
</row>
|
||||
</thead>
|
||||
<tbody>
|
||||
<row>
|
||||
<entry>scoped_read_write_lock</entry>
|
||||
<entry><link linkend="threads.concepts.ScopedReadWriteLock">ScopedReadWriteLock</link></entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>scoped_try_read_write_lock</entry>
|
||||
<entry><link linkend="threads.concepts.ScopedTryReadWriteLock">ScopedTryReadWriteLock</link></entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>scoped_timed_read_write_lock</entry>
|
||||
<entry><link linkend="threads.concepts.ScopedTimedReadWriteLock">ScopedTimedReadWriteLock</link></entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>scoped_read_lock</entry>
|
||||
<entry><link linkend="threads.concepts.ScopedLock">ScopedLock</link></entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>scoped_try_read_lock</entry>
|
||||
<entry><link linkend="threads.concepts.ScopedTryLock">ScopedTryLock</link></entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>scoped_timed_read_lock</entry>
|
||||
<entry><link linkend="threads.concepts.ScopedTimedLock">ScopedTimedLock</link></entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>scoped_write_lock</entry>
|
||||
<entry><link linkend="threads.concepts.ScopedLock">ScopedLock</link></entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>scoped_try_write_lock</entry>
|
||||
<entry><link linkend="threads.concepts.ScopedTryLock">ScopedTryLock</link></entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>scoped_timed_write_lock</entry>
|
||||
<entry><link linkend="threads.concepts.ScopedTimedLock">ScopedTimedLock</link></entry>
|
||||
</row>
|
||||
</tbody>
|
||||
</tgroup>
|
||||
</informaltable>
|
||||
</para>
|
||||
|
||||
<para>The <classname>timed_read_write_mutex</classname> class uses an
|
||||
<link linkend="threads.concepts.read-write-locking-strategies.unspecified">Unspecified</link>
|
||||
locking strategy, so attempts to recursively lock a <classname>timed_read_write_mutex</classname>
|
||||
object or attempts to unlock one by threads that don't own a lock on it result in
|
||||
<emphasis role="bold">undefined behavior</emphasis>.
|
||||
This strategy allows implementations to be as efficient as possible
|
||||
on any given platform. It is, however, recommended that
|
||||
implementations include debugging support to detect misuse when
|
||||
<code>NDEBUG</code> is not defined.</para>
|
||||
|
||||
<para>Like all
|
||||
<link linkend="threads.concepts.read-write-mutex-models">read/write mutex models</link>
|
||||
in &Boost.Threads;, <classname>timed_read_write_mutex</classname> has two types of
|
||||
<link linkend="threads.concepts.read-write-scheduling-policies">scheduling policies</link>, an
|
||||
<link linkend="threads.concepts.read-write-scheduling-policies.inter-class">inter-class sheduling policy</link>
|
||||
between threads trying to obtain different types of locks and an
|
||||
<link linkend="threads.concepts.read-write-scheduling-policies.intra-class">intra-class sheduling policy</link>
|
||||
between threads trying to obtain the same type of lock.
|
||||
The <classname>timed_read_write_mutex</classname> class allows the
|
||||
programmer to choose what
|
||||
<link linkend="threads.concepts.read-write-scheduling-policies.inter-class">inter-class sheduling policy</link>
|
||||
will be used; however, like all read/write mutex models,
|
||||
<classname>timed_read_write_mutex</classname> leaves the
|
||||
<link linkend="threads.concepts.read-write-scheduling-policies.intra-class">intra-class sheduling policy</link> as
|
||||
<link linkend="threads.concepts.unspecified-scheduling-policy">Unspecified</link>.
|
||||
</para>
|
||||
|
||||
<note>Self-deadlock is virtually guaranteed if a thread tries to
|
||||
lock the same <classname>timed_read_write_mutex</classname> multiple times
|
||||
unless all locks are read-locks (but see below)</note>
|
||||
</description>
|
||||
|
||||
<typedef name="scoped_read_write_lock">
|
||||
<type><emphasis>implementation-defined</emphasis></type>
|
||||
</typedef>
|
||||
|
||||
<typedef name="scoped_try_read_write_lock">
|
||||
<type><emphasis>implementation-defined</emphasis></type>
|
||||
</typedef>
|
||||
|
||||
<typedef name="scoped_timed_read_write_lock">
|
||||
<type><emphasis>implementation-defined</emphasis></type>
|
||||
</typedef>
|
||||
|
||||
<typedef name="scoped_read_lock">
|
||||
<type><emphasis>implementation-defined</emphasis></type>
|
||||
</typedef>
|
||||
|
||||
<typedef name="scoped_try_read_lock">
|
||||
<type><emphasis>implementation-defined</emphasis></type>
|
||||
</typedef>
|
||||
|
||||
<typedef name="scoped_timed_read_lock">
|
||||
<type><emphasis>implementation-defined</emphasis></type>
|
||||
</typedef>
|
||||
|
||||
<typedef name="scoped_write_lock">
|
||||
<type><emphasis>implementation-defined</emphasis></type>
|
||||
</typedef>
|
||||
|
||||
<typedef name="scoped_try_write_lock">
|
||||
<type><emphasis>implementation-defined</emphasis></type>
|
||||
</typedef>
|
||||
|
||||
<typedef name="scoped_timed_write_lock">
|
||||
<type><emphasis>implementation-defined</emphasis></type>
|
||||
</typedef>
|
||||
|
||||
<constructor>
|
||||
<parameter name="count">
|
||||
<paramtype>boost::read_write_scheduling_policy</paramtype>
|
||||
</parameter>
|
||||
|
||||
<effects>Constructs a <classname>timed_read_write_mutex</classname> object.
|
||||
</effects>
|
||||
|
||||
<postconditions><code>*this</code> is in an unlocked state.
|
||||
</postconditions>
|
||||
</constructor>
|
||||
|
||||
<destructor>
|
||||
<effects>Destroys a <classname>timed_read_write_mutex</classname> object.</effects>
|
||||
|
||||
<requires><code>*this</code> is in an unlocked state.</requires>
|
||||
|
||||
<notes><emphasis role="bold">Danger:</emphasis> Destruction of a
|
||||
locked mutex is a serious programming error resulting in undefined
|
||||
behavior such as a program crash.</notes>
|
||||
</destructor>
|
||||
</class>
|
||||
</namespace>
|
||||
</header>
|
||||
@@ -13,7 +13,6 @@
|
||||
<xi:include href="mutex-ref.xml"/>
|
||||
<xi:include href="once-ref.xml"/>
|
||||
<xi:include href="recursive_mutex-ref.xml"/>
|
||||
<xi:include href="read_write_mutex-ref.xml"/>
|
||||
<xi:include href="thread-ref.xml"/>
|
||||
<xi:include href="tss-ref.xml"/>
|
||||
<xi:include href="xtime-ref.xml"/>
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,283 +0,0 @@
|
||||
// Copyright (C) 2002-2003
|
||||
// David Moore, William E. Kempf, Michael Glassford
|
||||
//
|
||||
// Permission to use, copy, modify, distribute and sell this software
|
||||
// and its documentation for any purpose is hereby granted without fee,
|
||||
// provided that the above copyright notice appear in all copies and
|
||||
// that both that copyright notice and this permission notice appear
|
||||
// in supporting documentation. David Moore makes no representations
|
||||
// about the suitability of this software for any purpose.
|
||||
// It is provided "as is" without express or implied warranty.
|
||||
|
||||
// A Boost::threads implementation of a synchronization
|
||||
// primitive which can allow multiple readers or a single
|
||||
// writer to have access to a shared resource.
|
||||
|
||||
#ifndef BOOST_READ_WRITE_MUTEX_JDM030602_HPP
|
||||
#define BOOST_READ_WRITE_MUTEX_JDM030602_HPP
|
||||
|
||||
#include <boost/thread/detail/config.hpp>
|
||||
|
||||
#include <boost/utility.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
#include <boost/thread/mutex.hpp>
|
||||
#include <boost/thread/detail/lock.hpp>
|
||||
#include <boost/thread/detail/read_write_lock.hpp>
|
||||
#include <boost/thread/condition.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
namespace read_write_scheduling_policy {
|
||||
enum read_write_scheduling_policy_enum
|
||||
{
|
||||
writer_priority, //Prefer writers; can starve readers
|
||||
reader_priority, //Prefer readers; can starve writers
|
||||
alternating_many_reads, //Alternate readers and writers; before a writer, release all queued readers
|
||||
alternating_single_read //Alternate readers and writers; before a writer, release only one queued reader
|
||||
};
|
||||
} // namespace read_write_scheduling_policy
|
||||
|
||||
namespace detail {
|
||||
|
||||
namespace thread {
|
||||
|
||||
// Shared implementation construct for explicit Scheduling Policies
|
||||
// This implementation is susceptible to self-deadlock, though....
|
||||
template<typename Mutex>
|
||||
struct read_write_mutex_impl
|
||||
{
|
||||
typedef Mutex mutex_type;
|
||||
typedef detail::thread::scoped_lock<Mutex> scoped_lock;
|
||||
typedef detail::thread::scoped_try_lock<Mutex> scoped_try_lock;
|
||||
typedef detail::thread::scoped_timed_lock<Mutex> scoped_timed_lock;
|
||||
|
||||
read_write_mutex_impl(read_write_scheduling_policy::read_write_scheduling_policy_enum sp);
|
||||
#if !BOOST_WORKAROUND(__BORLANDC__,<= 0x564)
|
||||
~read_write_mutex_impl();
|
||||
#endif
|
||||
|
||||
Mutex m_prot;
|
||||
|
||||
const read_write_scheduling_policy::read_write_scheduling_policy_enum m_sp;
|
||||
int m_state; //-1 = write lock; 0 = unlocked; >0 = read locked
|
||||
|
||||
boost::condition m_waiting_writers;
|
||||
boost::condition m_waiting_readers;
|
||||
boost::condition m_waiting_promotion;
|
||||
int m_num_waiting_writers;
|
||||
int m_num_waiting_readers;
|
||||
bool m_state_waiting_promotion;
|
||||
|
||||
int m_num_waking_writers;
|
||||
int m_num_waking_readers;
|
||||
int m_num_max_waking_writers; //Debug only
|
||||
int m_num_max_waking_readers; //Debug only
|
||||
|
||||
bool m_readers_next;
|
||||
|
||||
void do_read_lock();
|
||||
void do_write_lock();
|
||||
void do_write_unlock();
|
||||
void do_read_unlock();
|
||||
bool do_try_write_lock();
|
||||
bool do_try_read_lock();
|
||||
bool do_timed_write_lock(const xtime &xt);
|
||||
bool do_timed_read_lock(const xtime &xt);
|
||||
|
||||
void do_demote_to_read_lock();
|
||||
bool do_try_demote_to_read_lock();
|
||||
bool do_timed_demote_to_read_lock(const xtime &xt);
|
||||
|
||||
void do_promote_to_write_lock();
|
||||
bool do_try_promote_to_write_lock();
|
||||
bool do_timed_promote_to_write_lock(const xtime &xt);
|
||||
|
||||
bool locked();
|
||||
read_write_lock_state::read_write_lock_state_enum state();
|
||||
|
||||
private:
|
||||
|
||||
bool do_demote_to_read_lock_impl();
|
||||
|
||||
enum scheduling_reason
|
||||
{
|
||||
scheduling_reason_unlock,
|
||||
scheduling_reason_timeout,
|
||||
scheduling_reason_demote
|
||||
};
|
||||
|
||||
void do_scheduling_impl(const scheduling_reason reason);
|
||||
bool do_wake_one_reader(void);
|
||||
bool do_wake_all_readers(void);
|
||||
bool do_wake_writer(void);
|
||||
bool waker_exists(void);
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
} // namespace thread
|
||||
|
||||
class BOOST_THREAD_DECL read_write_mutex : private noncopyable
|
||||
{
|
||||
public:
|
||||
|
||||
read_write_mutex(read_write_scheduling_policy::read_write_scheduling_policy_enum sp);
|
||||
~read_write_mutex();
|
||||
|
||||
read_write_scheduling_policy::read_write_scheduling_policy_enum policy() const { return m_impl.m_sp; }
|
||||
|
||||
friend class detail::thread::read_write_lock_ops<read_write_mutex>;
|
||||
|
||||
typedef detail::thread::scoped_read_write_lock<
|
||||
read_write_mutex> scoped_read_write_lock;
|
||||
|
||||
typedef detail::thread::scoped_read_lock<
|
||||
read_write_mutex> scoped_read_lock;
|
||||
|
||||
typedef detail::thread::scoped_write_lock<
|
||||
read_write_mutex> scoped_write_lock;
|
||||
|
||||
private:
|
||||
|
||||
// Operations that will eventually be done only
|
||||
// via lock types
|
||||
void do_write_lock();
|
||||
void do_read_lock();
|
||||
void do_write_unlock();
|
||||
void do_read_unlock();
|
||||
|
||||
void do_demote_to_read_lock();
|
||||
|
||||
void do_promote_to_write_lock();
|
||||
|
||||
bool locked();
|
||||
read_write_lock_state::read_write_lock_state_enum state();
|
||||
|
||||
detail::thread::read_write_mutex_impl<mutex> m_impl;
|
||||
};
|
||||
|
||||
class BOOST_THREAD_DECL try_read_write_mutex : private noncopyable
|
||||
{
|
||||
public:
|
||||
|
||||
try_read_write_mutex(read_write_scheduling_policy::read_write_scheduling_policy_enum sp);
|
||||
~try_read_write_mutex();
|
||||
|
||||
read_write_scheduling_policy::read_write_scheduling_policy_enum policy() const { return m_impl.m_sp; }
|
||||
|
||||
friend class detail::thread::read_write_lock_ops<try_read_write_mutex>;
|
||||
|
||||
typedef detail::thread::scoped_read_write_lock<
|
||||
try_read_write_mutex> scoped_read_write_lock;
|
||||
typedef detail::thread::scoped_try_read_write_lock<
|
||||
try_read_write_mutex> scoped_try_read_write_lock;
|
||||
|
||||
typedef detail::thread::scoped_read_lock<
|
||||
try_read_write_mutex> scoped_read_lock;
|
||||
typedef detail::thread::scoped_try_read_lock<
|
||||
try_read_write_mutex> scoped_try_read_lock;
|
||||
|
||||
typedef detail::thread::scoped_write_lock<
|
||||
try_read_write_mutex> scoped_write_lock;
|
||||
typedef detail::thread::scoped_try_write_lock<
|
||||
try_read_write_mutex> scoped_try_write_lock;
|
||||
|
||||
private:
|
||||
|
||||
// Operations that will eventually be done only
|
||||
// via lock types
|
||||
void do_write_lock();
|
||||
void do_read_lock();
|
||||
void do_write_unlock();
|
||||
void do_read_unlock();
|
||||
bool do_try_write_lock();
|
||||
bool do_try_read_lock();
|
||||
|
||||
|
||||
void do_demote_to_read_lock();
|
||||
bool do_try_demote_to_read_lock();
|
||||
|
||||
void do_promote_to_write_lock();
|
||||
bool do_try_promote_to_write_lock();
|
||||
|
||||
bool locked();
|
||||
read_write_lock_state::read_write_lock_state_enum state();
|
||||
|
||||
detail::thread::read_write_mutex_impl<try_mutex> m_impl;
|
||||
};
|
||||
|
||||
class BOOST_THREAD_DECL timed_read_write_mutex : private noncopyable
|
||||
{
|
||||
public:
|
||||
|
||||
timed_read_write_mutex(read_write_scheduling_policy::read_write_scheduling_policy_enum sp);
|
||||
~timed_read_write_mutex();
|
||||
|
||||
read_write_scheduling_policy::read_write_scheduling_policy_enum policy() const { return m_impl.m_sp; }
|
||||
|
||||
friend class detail::thread::read_write_lock_ops<timed_read_write_mutex>;
|
||||
|
||||
typedef detail::thread::scoped_read_write_lock<
|
||||
timed_read_write_mutex> scoped_read_write_lock;
|
||||
typedef detail::thread::scoped_try_read_write_lock<
|
||||
timed_read_write_mutex> scoped_try_read_write_lock;
|
||||
typedef detail::thread::scoped_timed_read_write_lock<
|
||||
timed_read_write_mutex> scoped_timed_read_write_lock;
|
||||
|
||||
typedef detail::thread::scoped_read_lock<
|
||||
timed_read_write_mutex> scoped_read_lock;
|
||||
typedef detail::thread::scoped_try_read_lock<
|
||||
timed_read_write_mutex> scoped_try_read_lock;
|
||||
typedef detail::thread::scoped_timed_read_lock<
|
||||
timed_read_write_mutex> scoped_timed_read_lock;
|
||||
|
||||
typedef detail::thread::scoped_write_lock<
|
||||
timed_read_write_mutex> scoped_write_lock;
|
||||
typedef detail::thread::scoped_try_write_lock<
|
||||
timed_read_write_mutex> scoped_try_write_lock;
|
||||
typedef detail::thread::scoped_timed_write_lock<
|
||||
timed_read_write_mutex> scoped_timed_write_lock;
|
||||
|
||||
private:
|
||||
|
||||
// Operations that will eventually be done only
|
||||
// via lock types
|
||||
void do_write_lock();
|
||||
void do_read_lock();
|
||||
void do_write_unlock();
|
||||
void do_read_unlock();
|
||||
bool do_try_write_lock();
|
||||
bool do_try_read_lock();
|
||||
bool do_timed_write_lock(const xtime &xt);
|
||||
bool do_timed_read_lock(const xtime &xt);
|
||||
|
||||
void do_demote_to_read_lock();
|
||||
bool do_try_demote_to_read_lock();
|
||||
bool do_timed_demote_to_read_lock(const xtime &xt);
|
||||
|
||||
void do_promote_to_write_lock();
|
||||
bool do_try_promote_to_write_lock();
|
||||
bool do_timed_promote_to_write_lock(const xtime &xt);
|
||||
|
||||
bool locked();
|
||||
read_write_lock_state::read_write_lock_state_enum state();
|
||||
|
||||
detail::thread::read_write_mutex_impl<timed_mutex> m_impl;
|
||||
};
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif
|
||||
|
||||
// Change Log:
|
||||
// 10 Mar 02
|
||||
// Original version.
|
||||
// 4 May 04 GlassfordM
|
||||
// Implement lock promotion and demotion.
|
||||
// Add locked() and state() member functions for debugging
|
||||
// (should these be made public?).
|
||||
// Rename to improve consistency and eliminate abbreviations:
|
||||
// Use "read" and "write" instead of "shared" and "exclusive".
|
||||
// Change "rd" to "read", "wr" to "write", "rw" to "read_write".
|
||||
// Add mutex_type typdef.
|
||||
File diff suppressed because it is too large
Load Diff
@@ -38,7 +38,7 @@ import testing ;
|
||||
<define>BOOST_ALL_NO_LIB=1
|
||||
<define>BOOST_THREAD_USE_LIB=1
|
||||
<define>BOOST_THREAD_TEST=1
|
||||
<runtime-link>static
|
||||
#<runtime-link>static
|
||||
<threading>multi
|
||||
: ## default build ##
|
||||
;
|
||||
@@ -69,7 +69,6 @@ import testing ;
|
||||
[ run test_once.cpp <template>boost_thread_test_dll ]
|
||||
[ run test_xtime.cpp <template>boost_thread_test_dll ]
|
||||
[ run test_barrier.cpp <template>boost_thread_test_dll ]
|
||||
[ run test_read_write_mutex.cpp <template>boost_thread_test_dll ]
|
||||
|
||||
[ run test_thread.cpp <template>boost_thread_test_lib : : : : test_thread_lib ]
|
||||
[ run test_mutex.cpp <template>boost_thread_test_lib : : : : test_mutex_lib ]
|
||||
@@ -78,6 +77,5 @@ import testing ;
|
||||
[ run test_once.cpp <template>boost_thread_test_lib : : : : test_once_lib ]
|
||||
[ run test_xtime.cpp <template>boost_thread_test_lib : : : : test_xtime_lib ]
|
||||
[ run test_barrier.cpp <template>boost_thread_test_lib : : : : test_barrier_lib ]
|
||||
[ run test_read_write_mutex.cpp <template>boost_thread_test_lib : : : : test_read_write_mutex_lib ]
|
||||
;
|
||||
}
|
||||
|
||||
@@ -1,791 +0,0 @@
|
||||
// Copyright (C) 2001-2003
|
||||
// William E. Kempf
|
||||
//
|
||||
// Permission to use, copy, modify, distribute and sell this software
|
||||
// and its documentation for any purpose is hereby granted without fee,
|
||||
// provided that the above copyright notice appear in all copies and
|
||||
// that both that copyright notice and this permission notice appear
|
||||
// in supporting documentation. William E. Kempf makes no representations
|
||||
// about the suitability of this software for any purpose.
|
||||
// It is provided "as is" without express or implied warranty.
|
||||
|
||||
#include <boost/thread/detail/config.hpp>
|
||||
|
||||
#include <boost/thread/thread.hpp>
|
||||
#include <boost/thread/xtime.hpp>
|
||||
#include <boost/thread/read_write_mutex.hpp>
|
||||
|
||||
#include <boost/test/unit_test.hpp>
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#define TS_CHECK(pred) \
|
||||
do { if (!(pred)) BOOST_ERROR (#pred); } while (0)
|
||||
#define TS_CHECK_MSG(pred, msg) \
|
||||
do { if (!(pred)) BOOST_ERROR (msg); } while (0)
|
||||
|
||||
namespace {
|
||||
|
||||
int shared_val = 0;
|
||||
|
||||
boost::xtime xsecs(int secs)
|
||||
{
|
||||
//Create an xtime that is secs seconds from now
|
||||
boost::xtime ret;
|
||||
TS_CHECK (boost::TIME_UTC == boost::xtime_get(&ret, boost::TIME_UTC));
|
||||
ret.sec += secs;
|
||||
return ret;
|
||||
}
|
||||
|
||||
#define MESSAGE "w1=" << w1.value_ << ", w2=" << w2.value_ << ", r1=" << r1.value_ << ", r2=" << r2.value_
|
||||
|
||||
template <typename RW>
|
||||
class thread_adapter
|
||||
{
|
||||
public:
|
||||
|
||||
thread_adapter(
|
||||
void (*func)(void*, RW&),
|
||||
void* param1,
|
||||
RW ¶m2
|
||||
)
|
||||
: func_(func)
|
||||
, param1_(param1)
|
||||
, param2_(param2)
|
||||
{}
|
||||
|
||||
void operator()() const
|
||||
{
|
||||
func_(param1_, param2_);
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
void (*func_)(void*, RW&);
|
||||
void* param1_;
|
||||
RW& param2_;
|
||||
};
|
||||
|
||||
const int k_data_init = -1;
|
||||
|
||||
template <typename RW>
|
||||
struct data
|
||||
{
|
||||
data(
|
||||
int id,
|
||||
RW& m,
|
||||
int wait_for_lock_secs,
|
||||
int sleep_with_lock_secs,
|
||||
bool demote_after_write = false
|
||||
)
|
||||
: id_(id)
|
||||
, wait_for_lock_secs_(wait_for_lock_secs)
|
||||
, sleep_with_lock_secs_(sleep_with_lock_secs)
|
||||
, test_promotion_and_demotion_(demote_after_write)
|
||||
, value_(k_data_init)
|
||||
, rw_(m)
|
||||
{}
|
||||
|
||||
int id_;
|
||||
int wait_for_lock_secs_;
|
||||
int sleep_with_lock_secs_;
|
||||
bool test_promotion_and_demotion_;
|
||||
int value_;
|
||||
|
||||
RW& rw_;
|
||||
};
|
||||
|
||||
template<typename RW>
|
||||
void plain_writer(void* arg, RW& rw)
|
||||
{
|
||||
try
|
||||
{
|
||||
data<RW>* pdata = (data<RW>*) arg;
|
||||
TS_CHECK_MSG(pdata->wait_for_lock_secs_ == 0, "pdata->wait_for_lock_secs_: " << pdata->wait_for_lock_secs_);
|
||||
|
||||
typename RW::scoped_read_write_lock l(
|
||||
rw,
|
||||
pdata->test_promotion_and_demotion_
|
||||
? boost::read_write_lock_state::read_locked
|
||||
: boost::read_write_lock_state::write_locked
|
||||
);
|
||||
|
||||
bool succeeded = true;
|
||||
|
||||
if (pdata->test_promotion_and_demotion_)
|
||||
{
|
||||
try
|
||||
{
|
||||
l.promote();
|
||||
}
|
||||
catch(const boost::lock_error&)
|
||||
{
|
||||
succeeded = false;
|
||||
}
|
||||
}
|
||||
|
||||
if (succeeded)
|
||||
{
|
||||
if (pdata->sleep_with_lock_secs_ > 0)
|
||||
boost::thread::sleep(xsecs(pdata->sleep_with_lock_secs_));
|
||||
|
||||
shared_val += 10;
|
||||
|
||||
if (pdata->test_promotion_and_demotion_)
|
||||
l.demote();
|
||||
|
||||
pdata->value_ = shared_val;
|
||||
}
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
TS_CHECK_MSG(false, "plain_writer() exception!");
|
||||
throw;
|
||||
}
|
||||
}
|
||||
|
||||
template<typename RW>
|
||||
void plain_reader(void* arg, RW& rw)
|
||||
{
|
||||
try
|
||||
{
|
||||
data<RW>* pdata = (data<RW>*)arg;
|
||||
TS_CHECK(!pdata->test_promotion_and_demotion_);
|
||||
TS_CHECK_MSG(pdata->wait_for_lock_secs_ == 0, "pdata->wait_for_lock_secs_: " << pdata->wait_for_lock_secs_);
|
||||
|
||||
typename RW::scoped_read_write_lock l(rw, boost::read_write_lock_state::read_locked);
|
||||
|
||||
if (pdata->sleep_with_lock_secs_ > 0)
|
||||
boost::thread::sleep(xsecs(pdata->sleep_with_lock_secs_));
|
||||
|
||||
pdata->value_ = shared_val;
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
TS_CHECK_MSG(false, "plain_reader() exception!");
|
||||
throw;
|
||||
}
|
||||
}
|
||||
|
||||
template<typename RW>
|
||||
void try_writer(void* arg, RW& rw)
|
||||
{
|
||||
try
|
||||
{
|
||||
data<RW>* pdata = (data<RW>*) arg;
|
||||
TS_CHECK_MSG(pdata->wait_for_lock_secs_ == 0, "pdata->wait_for_lock_secs_: " << pdata->wait_for_lock_secs_);
|
||||
|
||||
typename RW::scoped_try_read_write_lock l(rw, boost::read_write_lock_state::unlocked);
|
||||
|
||||
bool succeeded = false;
|
||||
|
||||
if (pdata->test_promotion_and_demotion_)
|
||||
succeeded = l.try_read_lock() && l.try_promote();
|
||||
else
|
||||
succeeded = l.try_write_lock();
|
||||
|
||||
if (succeeded)
|
||||
{
|
||||
if (pdata->sleep_with_lock_secs_ > 0)
|
||||
boost::thread::sleep(xsecs(pdata->sleep_with_lock_secs_));
|
||||
|
||||
shared_val += 10;
|
||||
|
||||
if (pdata->test_promotion_and_demotion_)
|
||||
l.demote();
|
||||
|
||||
pdata->value_ = shared_val;
|
||||
}
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
TS_CHECK_MSG(false, "try_writer() exception!");
|
||||
throw;
|
||||
}
|
||||
}
|
||||
|
||||
template<typename RW>
|
||||
void try_reader(void*arg, RW& rw)
|
||||
{
|
||||
try
|
||||
{
|
||||
data<RW>* pdata = (data<RW>*)arg;
|
||||
TS_CHECK(!pdata->test_promotion_and_demotion_);
|
||||
TS_CHECK_MSG(pdata->wait_for_lock_secs_ == 0, "pdata->wait_for_lock_secs_: " << pdata->wait_for_lock_secs_);
|
||||
|
||||
typename RW::scoped_try_read_write_lock l(rw, boost::read_write_lock_state::unlocked);
|
||||
|
||||
if (l.try_read_lock())
|
||||
{
|
||||
if (pdata->sleep_with_lock_secs_ > 0)
|
||||
boost::thread::sleep(xsecs(pdata->sleep_with_lock_secs_));
|
||||
|
||||
pdata->value_ = shared_val;
|
||||
}
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
TS_CHECK_MSG(false, "try_reader() exception!");
|
||||
throw;
|
||||
}
|
||||
}
|
||||
|
||||
template<typename RW>
|
||||
void timed_writer(void* arg, RW& rw)
|
||||
{
|
||||
try
|
||||
{
|
||||
data<RW>* pdata = (data<RW>*)arg;
|
||||
|
||||
typename RW::scoped_timed_read_write_lock l(rw, boost::read_write_lock_state::unlocked);
|
||||
|
||||
bool succeeded = false;
|
||||
|
||||
boost::xtime xt = xsecs(pdata->wait_for_lock_secs_);
|
||||
if (pdata->test_promotion_and_demotion_)
|
||||
succeeded = l.timed_read_lock(xt) && l.timed_promote(xt);
|
||||
else
|
||||
succeeded = l.timed_write_lock(xt);
|
||||
|
||||
if (succeeded)
|
||||
{
|
||||
if (pdata->sleep_with_lock_secs_ > 0)
|
||||
boost::thread::sleep(xsecs(pdata->sleep_with_lock_secs_));
|
||||
|
||||
shared_val += 10;
|
||||
|
||||
if (pdata->test_promotion_and_demotion_)
|
||||
l.demote();
|
||||
|
||||
pdata->value_ = shared_val;
|
||||
}
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
TS_CHECK_MSG(false, "timed_writer() exception!");
|
||||
throw;
|
||||
}
|
||||
}
|
||||
|
||||
template<typename RW>
|
||||
void timed_reader(void* arg, RW& rw)
|
||||
{
|
||||
try
|
||||
{
|
||||
data<RW>* pdata = (data<RW>*)arg;
|
||||
TS_CHECK(!pdata->test_promotion_and_demotion_);
|
||||
|
||||
typename RW::scoped_timed_read_write_lock l(rw,boost::read_write_lock_state::unlocked);
|
||||
|
||||
boost::xtime xt = xsecs(pdata->wait_for_lock_secs_);
|
||||
if (l.timed_read_lock(xt))
|
||||
{
|
||||
if (pdata->sleep_with_lock_secs_ > 0)
|
||||
boost::thread::sleep(xsecs(pdata->sleep_with_lock_secs_));
|
||||
|
||||
pdata->value_ = shared_val;
|
||||
}
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
TS_CHECK_MSG(false, "timed_reader() exception!");
|
||||
throw;
|
||||
}
|
||||
}
|
||||
|
||||
template<typename RW>
|
||||
void clear_data(data<RW>& data1, data<RW>& data2, data<RW>& data3, data<RW>& data4)
|
||||
{
|
||||
shared_val = 0;
|
||||
data1.value_ = k_data_init;
|
||||
data2.value_ = k_data_init;
|
||||
data3.value_ = k_data_init;
|
||||
data4.value_ = k_data_init;
|
||||
}
|
||||
|
||||
bool shared_test_writelocked = false;
|
||||
bool shared_test_readlocked = false;
|
||||
bool shared_test_unlocked = false;
|
||||
|
||||
template<typename RW>
|
||||
void run_try_tests(void* arg, RW& rw)
|
||||
{
|
||||
try
|
||||
{
|
||||
TS_CHECK(shared_test_writelocked || shared_test_readlocked || shared_test_unlocked);
|
||||
|
||||
typename RW::scoped_try_read_write_lock l(rw, boost::read_write_lock_state::unlocked);
|
||||
|
||||
if (shared_test_writelocked)
|
||||
{
|
||||
//Verify that write lock blocks other write locks
|
||||
TS_CHECK(!l.try_write_lock());
|
||||
|
||||
//Verify that write lock blocks read locks
|
||||
TS_CHECK(!l.try_read_lock());
|
||||
}
|
||||
else if (shared_test_readlocked)
|
||||
{
|
||||
//Verify that read lock blocks write locks
|
||||
TS_CHECK(!l.try_write_lock());
|
||||
|
||||
//Verify that read lock does not block other read locks
|
||||
TS_CHECK(l.try_read_lock());
|
||||
|
||||
//Verify that read lock blocks promotion
|
||||
TS_CHECK(!l.try_promote());
|
||||
}
|
||||
else if (shared_test_unlocked)
|
||||
{
|
||||
//Verify that unlocked does not blocks write locks
|
||||
TS_CHECK(l.try_write_lock());
|
||||
|
||||
//Verify that unlocked does not block demotion
|
||||
TS_CHECK(l.try_demote());
|
||||
|
||||
l.unlock();
|
||||
|
||||
//Verify that unlocked does not block read locks
|
||||
TS_CHECK(l.try_read_lock());
|
||||
|
||||
//Verify that unlocked does not block promotion
|
||||
TS_CHECK(l.try_promote());
|
||||
|
||||
l.unlock();
|
||||
}
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
TS_CHECK_MSG(false, "run_try_tests() exception!");
|
||||
throw;
|
||||
}
|
||||
}
|
||||
|
||||
template<typename RW>
|
||||
void test_plain_read_write_mutex(RW& rw, bool test_promotion_and_demotion)
|
||||
{
|
||||
//Verify that a write lock prevents both readers and writers from obtaining a lock
|
||||
{
|
||||
shared_val = 0;
|
||||
data<RW> r1(1, rw, 0, 0);
|
||||
data<RW> r2(2, rw, 0, 0);
|
||||
data<RW> w1(3, rw, 0, 0);
|
||||
data<RW> w2(4, rw, 0, 0);
|
||||
|
||||
//Write-lock the mutex and queue up other readers and writers
|
||||
|
||||
typename RW::scoped_read_write_lock l(rw, boost::read_write_lock_state::write_locked);
|
||||
|
||||
boost::thread tr1(thread_adapter<RW>(plain_reader, &r1, rw));
|
||||
boost::thread tr2(thread_adapter<RW>(plain_reader, &r2, rw));
|
||||
boost::thread tw1(thread_adapter<RW>(plain_writer, &w1, rw));
|
||||
boost::thread tw2(thread_adapter<RW>(plain_writer, &w2, rw));
|
||||
|
||||
boost::thread::sleep(xsecs(1));
|
||||
|
||||
//At this point, neither queued readers nor queued writers should have obtained access
|
||||
|
||||
TS_CHECK_MSG(w1.value_ == k_data_init, MESSAGE);
|
||||
TS_CHECK_MSG(w2.value_ == k_data_init, MESSAGE);
|
||||
TS_CHECK_MSG(r1.value_ == k_data_init, MESSAGE);
|
||||
TS_CHECK_MSG(r2.value_ == k_data_init, MESSAGE);
|
||||
|
||||
if (test_promotion_and_demotion)
|
||||
{
|
||||
l.demote();
|
||||
boost::thread::sleep(xsecs(1));
|
||||
//:boost::thread tr3(thread_adapter<RW>(plain_reader, &r3, rw));
|
||||
|
||||
if (rw.policy() == boost::read_write_scheduling_policy::writer_priority)
|
||||
{
|
||||
//Expected result:
|
||||
//Since writers have priority, demotion doesn't release any readers.
|
||||
TS_CHECK_MSG(w1.value_ == k_data_init, MESSAGE);
|
||||
TS_CHECK_MSG(w2.value_ == k_data_init, MESSAGE);
|
||||
TS_CHECK_MSG(r1.value_ == k_data_init, MESSAGE);
|
||||
TS_CHECK_MSG(r2.value_ == k_data_init, MESSAGE);
|
||||
}
|
||||
else if (rw.policy() == boost::read_write_scheduling_policy::reader_priority)
|
||||
{
|
||||
//Expected result:
|
||||
//Since readers have priority, demotion releases all readers.
|
||||
TS_CHECK_MSG(w1.value_ == k_data_init, MESSAGE);
|
||||
TS_CHECK_MSG(w2.value_ == k_data_init, MESSAGE);
|
||||
TS_CHECK_MSG(r1.value_ == 0, MESSAGE);
|
||||
TS_CHECK_MSG(r2.value_ == 0, MESSAGE);
|
||||
}
|
||||
else if (rw.policy() == boost::read_write_scheduling_policy::alternating_many_reads)
|
||||
{
|
||||
//Expected result:
|
||||
//Since readers can be released many at a time, demotion releases all queued readers.
|
||||
TS_CHECK_MSG(w1.value_ == k_data_init, MESSAGE);
|
||||
TS_CHECK_MSG(w2.value_ == k_data_init, MESSAGE);
|
||||
TS_CHECK_MSG(r1.value_ == 0, MESSAGE);
|
||||
TS_CHECK_MSG(r2.value_ == 0, MESSAGE);
|
||||
//:TS_CHECK_MSG(r3.value_ == k_data_init, MESSAGE);
|
||||
}
|
||||
else if (rw.policy() == boost::read_write_scheduling_policy::alternating_single_read)
|
||||
{
|
||||
//Expected result:
|
||||
//Since readers can be released only one at a time, demotion releases one queued reader.
|
||||
TS_CHECK_MSG(w1.value_ == k_data_init, MESSAGE);
|
||||
TS_CHECK_MSG(w2.value_ == k_data_init, MESSAGE);
|
||||
TS_CHECK_MSG(r1.value_ == k_data_init || r1.value_ == 0, MESSAGE);
|
||||
TS_CHECK_MSG(r2.value_ == k_data_init || r2.value_ == 0, MESSAGE);
|
||||
TS_CHECK_MSG(r1.value_ != r2.value_, MESSAGE);
|
||||
}
|
||||
}
|
||||
|
||||
l.unlock();
|
||||
|
||||
tr2.join();
|
||||
tr1.join();
|
||||
tw2.join();
|
||||
tw1.join();
|
||||
|
||||
if (rw.policy() == boost::read_write_scheduling_policy::writer_priority)
|
||||
{
|
||||
if (!test_promotion_and_demotion)
|
||||
{
|
||||
//Expected result:
|
||||
//1) either w1 or w2 obtains and releases the lock
|
||||
//2) the other of w1 and w2 obtains and releases the lock
|
||||
//3) r1 and r2 obtain and release the lock "simultaneously"
|
||||
TS_CHECK_MSG(w1.value_ == 10 || w1.value_ == 20, MESSAGE);
|
||||
TS_CHECK_MSG(w2.value_ == 10 || w2.value_ == 20, MESSAGE);
|
||||
TS_CHECK_MSG(w1.value_ != w2.value_, MESSAGE);
|
||||
TS_CHECK_MSG(r1.value_ == 20, MESSAGE);
|
||||
TS_CHECK_MSG(r2.value_ == 20, MESSAGE);
|
||||
}
|
||||
else
|
||||
{
|
||||
//Expected result:
|
||||
//The same, except that either w1 or w2 (but not both) may
|
||||
//fail to promote to a write lock,
|
||||
//and r1, r2, or both may "sneak in" ahead of w1 and/or w2
|
||||
//by obtaining a read lock before w1 or w2 can promote
|
||||
//their initial read lock to a write lock.
|
||||
TS_CHECK_MSG(w1.value_ == k_data_init || w1.value_ == 10 || w1.value_ == 20, MESSAGE);
|
||||
TS_CHECK_MSG(w2.value_ == k_data_init || w2.value_ == 10 || w2.value_ == 20, MESSAGE);
|
||||
TS_CHECK_MSG(w1.value_ != w2.value_, MESSAGE);
|
||||
TS_CHECK_MSG(r1.value_ == k_data_init || r1.value_ == 10 || r1.value_ == 20, MESSAGE);
|
||||
TS_CHECK_MSG(r2.value_ == k_data_init || r2.value_ == 10 || r2.value_ == 20, MESSAGE);
|
||||
}
|
||||
}
|
||||
else if (rw.policy() == boost::read_write_scheduling_policy::reader_priority)
|
||||
{
|
||||
if (!test_promotion_and_demotion)
|
||||
{
|
||||
//Expected result:
|
||||
//1) r1 and r2 obtain and release the lock "simultaneously"
|
||||
//2) either w1 or w2 obtains and releases the lock
|
||||
//3) the other of w1 and w2 obtains and releases the lock
|
||||
TS_CHECK_MSG(w1.value_ == 10 || w1.value_ == 20, MESSAGE);
|
||||
TS_CHECK_MSG(w2.value_ == 10 || w2.value_ == 20, MESSAGE);
|
||||
TS_CHECK_MSG(w1.value_ != w2.value_, MESSAGE);
|
||||
TS_CHECK_MSG(r1.value_ == 0, MESSAGE);
|
||||
TS_CHECK_MSG(r2.value_ == 0, MESSAGE);
|
||||
}
|
||||
else
|
||||
{
|
||||
//Expected result:
|
||||
//The same, except that either w1 or w2 (but not both) may
|
||||
//fail to promote to a write lock.
|
||||
TS_CHECK_MSG(w1.value_ == k_data_init || w1.value_ == 10 || w1.value_ == 20, MESSAGE);
|
||||
TS_CHECK_MSG(w2.value_ == k_data_init || w2.value_ == 10 || w2.value_ == 20, MESSAGE);
|
||||
TS_CHECK_MSG(w1.value_ != w2.value_, MESSAGE);
|
||||
TS_CHECK_MSG(r1.value_ == 0, MESSAGE);
|
||||
TS_CHECK_MSG(r2.value_ == 0, MESSAGE);
|
||||
}
|
||||
}
|
||||
else if (rw.policy() == boost::read_write_scheduling_policy::alternating_many_reads)
|
||||
{
|
||||
if (!test_promotion_and_demotion)
|
||||
{
|
||||
//Expected result:
|
||||
//1) r1 and r2 obtain and release the lock "simultaneously"
|
||||
//2) either w1 or w2 obtains and releases the lock
|
||||
//3) the other of w1 and w2 obtains and releases the lock
|
||||
TS_CHECK_MSG(w1.value_ == 10 || w1.value_ == 20, MESSAGE);
|
||||
TS_CHECK_MSG(w2.value_ == 10 || w2.value_ == 20, MESSAGE);
|
||||
TS_CHECK_MSG(w1.value_ != w2.value_, MESSAGE);
|
||||
TS_CHECK_MSG(r1.value_ == 0, MESSAGE);
|
||||
TS_CHECK_MSG(r2.value_ == 0, MESSAGE);
|
||||
}
|
||||
else
|
||||
{
|
||||
//Expected result:
|
||||
//The same, except that either w1 or w2 (but not both) may
|
||||
//fail to promote to a write lock.
|
||||
TS_CHECK_MSG(w1.value_ == k_data_init || w1.value_ == 10 || w1.value_ == 20, MESSAGE);
|
||||
TS_CHECK_MSG(w2.value_ == k_data_init || w2.value_ == 10 || w2.value_ == 20, MESSAGE);
|
||||
TS_CHECK_MSG(w1.value_ != w2.value_, MESSAGE);
|
||||
TS_CHECK_MSG(r1.value_ == 0, MESSAGE);
|
||||
TS_CHECK_MSG(r2.value_ == 0, MESSAGE);
|
||||
}
|
||||
}
|
||||
else if (rw.policy() == boost::read_write_scheduling_policy::alternating_single_read)
|
||||
{
|
||||
if (!test_promotion_and_demotion)
|
||||
{
|
||||
//Expected result:
|
||||
//1) either r1 or r2 obtains and releases the lock
|
||||
//2) either w1 or w2 obtains and releases the lock
|
||||
//3) the other of r1 and r2 obtains and releases the lock
|
||||
//4) the other of w1 and w2 obtains and release the lock
|
||||
TS_CHECK_MSG(w1.value_ == 10 || w1.value_ == 20, MESSAGE);
|
||||
TS_CHECK_MSG(w2.value_ == 10 || w2.value_ == 20, MESSAGE);
|
||||
TS_CHECK_MSG(w1.value_ != w2.value_, MESSAGE);
|
||||
TS_CHECK_MSG(r1.value_ == 0 || r1.value_ == 10, MESSAGE);
|
||||
TS_CHECK_MSG(r2.value_ == 0 || r2.value_ == 10, MESSAGE);
|
||||
TS_CHECK_MSG(r1.value_ != r2.value_, MESSAGE);
|
||||
}
|
||||
else
|
||||
{
|
||||
//Expected result:
|
||||
//Since w1 and w2 start as read locks, r1, r2, w1, and w2
|
||||
//obtain read locks "simultaneously". Each of w1 and w2,
|
||||
//after it obtain a read lock, attempts to promote to a
|
||||
//write lock; this attempt fails if the other has
|
||||
//already done so and currently holds the write lock;
|
||||
//otherwise it will succeed as soon as any other
|
||||
//read locks have been released.
|
||||
//In other words, any ordering is possible, and either
|
||||
//w1 or w2 (but not both) may fail to obtain the lock
|
||||
//altogether.
|
||||
TS_CHECK_MSG(w1.value_ == k_data_init || w1.value_ == 10 || w1.value_ == 20, MESSAGE);
|
||||
TS_CHECK_MSG(w2.value_ == k_data_init || w2.value_ == 10 || w2.value_ == 20, MESSAGE);
|
||||
TS_CHECK_MSG(w1.value_ != w2.value_, MESSAGE);
|
||||
TS_CHECK_MSG(r1.value_ == 0 || r1.value_ == 10 || r1.value_ == 20, MESSAGE);
|
||||
TS_CHECK_MSG(r2.value_ == 0 || r2.value_ == 10 || r2.value_ == 20, MESSAGE);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//Verify that a read lock prevents readers but not writers from obtaining a lock
|
||||
{
|
||||
shared_val = 0;
|
||||
data<RW> r1(1, rw, 0, 0);
|
||||
data<RW> r2(2, rw, 0, 0);
|
||||
data<RW> w1(3, rw, 0, 0);
|
||||
data<RW> w2(4, rw, 0, 0);
|
||||
|
||||
//Read-lock the mutex and queue up other readers and writers
|
||||
|
||||
typename RW::scoped_read_write_lock l(rw, boost::read_write_lock_state::read_locked);
|
||||
|
||||
boost::thread tr1(thread_adapter<RW>(plain_reader, &r1, rw));
|
||||
boost::thread tr2(thread_adapter<RW>(plain_reader, &r2, rw));
|
||||
|
||||
boost::thread::sleep(xsecs(1));
|
||||
|
||||
boost::thread tw1(thread_adapter<RW>(plain_writer, &w1, rw));
|
||||
boost::thread tw2(thread_adapter<RW>(plain_writer, &w2, rw));
|
||||
|
||||
boost::thread::sleep(xsecs(1));
|
||||
|
||||
//Expected result: all readers passed through before the writers entered
|
||||
TS_CHECK_MSG(w1.value_ == k_data_init, MESSAGE);
|
||||
TS_CHECK_MSG(w2.value_ == k_data_init, MESSAGE);
|
||||
TS_CHECK_MSG(r1.value_ == 0, MESSAGE);
|
||||
TS_CHECK_MSG(r2.value_ == 0, MESSAGE);
|
||||
|
||||
if (test_promotion_and_demotion)
|
||||
{
|
||||
l.promote();
|
||||
}
|
||||
|
||||
l.unlock();
|
||||
|
||||
tr2.join();
|
||||
tr1.join();
|
||||
tw2.join();
|
||||
tw1.join();
|
||||
}
|
||||
|
||||
//Verify that a read lock prevents readers but not writers from obtaining a lock
|
||||
{
|
||||
shared_val = 0;
|
||||
data<RW> r1(1, rw, 0, 0);
|
||||
data<RW> r2(2, rw, 0, 0);
|
||||
data<RW> w1(3, rw, 0, 0);
|
||||
data<RW> w2(4, rw, 0, 0);
|
||||
|
||||
//Read-lock the mutex and queue up other readers and writers
|
||||
|
||||
typename RW::scoped_read_write_lock l(rw, boost::read_write_lock_state::read_locked);
|
||||
|
||||
boost::thread tw1(thread_adapter<RW>(plain_writer, &w1, rw));
|
||||
boost::thread tw2(thread_adapter<RW>(plain_writer, &w2, rw));
|
||||
|
||||
boost::thread::sleep(xsecs(1));
|
||||
|
||||
boost::thread tr1(thread_adapter<RW>(plain_reader, &r1, rw));
|
||||
boost::thread tr2(thread_adapter<RW>(plain_reader, &r2, rw));
|
||||
|
||||
boost::thread::sleep(xsecs(1));
|
||||
|
||||
if (rw.policy() == boost::read_write_scheduling_policy::writer_priority)
|
||||
{
|
||||
//Expected result:
|
||||
//Writers have priority, so no readers have been released
|
||||
TS_CHECK_MSG(w1.value_ == k_data_init, MESSAGE);
|
||||
TS_CHECK_MSG(w2.value_ == k_data_init, MESSAGE);
|
||||
TS_CHECK_MSG(r1.value_ == k_data_init, MESSAGE);
|
||||
TS_CHECK_MSG(r2.value_ == k_data_init, MESSAGE);
|
||||
}
|
||||
else if (rw.policy() == boost::read_write_scheduling_policy::reader_priority)
|
||||
{
|
||||
//Expected result:
|
||||
//Readers have priority, so all readers have been released
|
||||
TS_CHECK_MSG(w1.value_ == k_data_init, MESSAGE);
|
||||
TS_CHECK_MSG(w2.value_ == k_data_init, MESSAGE);
|
||||
TS_CHECK_MSG(r1.value_ == 0, MESSAGE);
|
||||
TS_CHECK_MSG(r2.value_ == 0, MESSAGE);
|
||||
}
|
||||
else if (rw.policy() == boost::read_write_scheduling_policy::alternating_many_reads)
|
||||
{
|
||||
//Expected result:
|
||||
//It's the writers' turn, so no readers have been released
|
||||
TS_CHECK_MSG(w1.value_ == k_data_init, MESSAGE);
|
||||
TS_CHECK_MSG(w2.value_ == k_data_init, MESSAGE);
|
||||
TS_CHECK_MSG(r1.value_ == k_data_init, MESSAGE);
|
||||
TS_CHECK_MSG(r2.value_ == k_data_init, MESSAGE);
|
||||
}
|
||||
else if (rw.policy() == boost::read_write_scheduling_policy::alternating_single_read)
|
||||
{
|
||||
//Expected result:
|
||||
//It's the writers' turn, so no readers have been released
|
||||
TS_CHECK_MSG(w1.value_ == k_data_init, MESSAGE);
|
||||
TS_CHECK_MSG(w2.value_ == k_data_init, MESSAGE);
|
||||
TS_CHECK_MSG(r1.value_ == k_data_init, MESSAGE);
|
||||
TS_CHECK_MSG(r2.value_ == k_data_init, MESSAGE);
|
||||
}
|
||||
|
||||
if (test_promotion_and_demotion)
|
||||
{
|
||||
l.promote();
|
||||
}
|
||||
|
||||
l.unlock();
|
||||
|
||||
tr2.join();
|
||||
tr1.join();
|
||||
tw2.join();
|
||||
tw1.join();
|
||||
}
|
||||
}
|
||||
|
||||
template<typename RW>
|
||||
void test_try_read_write_mutex(RW& rw, bool test_promotion_and_demotion)
|
||||
{
|
||||
//Repeat the plain tests with the try lock.
|
||||
//This is important to verify that try locks are proper
|
||||
//read_write_mutexes as well.
|
||||
|
||||
test_plain_read_write_mutex(rw, test_promotion_and_demotion);
|
||||
|
||||
//Verify try_* operations with write-locked mutex
|
||||
{
|
||||
typename RW::scoped_try_read_write_lock l(rw, boost::read_write_lock_state::write_locked);
|
||||
|
||||
shared_test_writelocked = true;
|
||||
shared_test_readlocked = false;
|
||||
shared_test_unlocked = false;
|
||||
|
||||
boost::thread test_thread(thread_adapter<RW>(run_try_tests, NULL, rw));
|
||||
test_thread.join();
|
||||
}
|
||||
|
||||
//Verify try_* operations with read-locked mutex
|
||||
{
|
||||
typename RW::scoped_try_read_write_lock l(rw, boost::read_write_lock_state::read_locked);
|
||||
|
||||
shared_test_writelocked = false;
|
||||
shared_test_readlocked = true;
|
||||
shared_test_unlocked = false;
|
||||
|
||||
boost::thread test_thread(thread_adapter<RW>(run_try_tests, NULL, rw));
|
||||
test_thread.join();
|
||||
}
|
||||
|
||||
//Verify try_* operations with unlocked mutex
|
||||
{
|
||||
shared_test_writelocked = false;
|
||||
shared_test_readlocked = false;
|
||||
shared_test_unlocked = true;
|
||||
|
||||
boost::thread test_thread(thread_adapter<RW>(run_try_tests, NULL, rw));
|
||||
test_thread.join();
|
||||
}
|
||||
}
|
||||
|
||||
template<typename RW>
|
||||
void test_timed_read_write_mutex(RW& rw, bool test_promotion_and_demotion)
|
||||
{
|
||||
//Repeat the try tests with the timed lock.
|
||||
//This is important to verify that timed locks are proper
|
||||
//try locks as well.
|
||||
|
||||
test_try_read_write_mutex(rw, test_promotion_and_demotion);
|
||||
|
||||
//:More tests here
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
void do_test_read_write_mutex(bool test_promotion_and_demotion)
|
||||
{
|
||||
//Run every test for each scheduling policy
|
||||
|
||||
for(int i = (int) boost::read_write_scheduling_policy::writer_priority;
|
||||
i <= (int) boost::read_write_scheduling_policy::alternating_single_read;
|
||||
i++)
|
||||
{
|
||||
std::cout << "plain test, sp=" << i
|
||||
<< (test_promotion_and_demotion ? " with promotion & demotion" : " without promotion & demotion")
|
||||
<< "\n";
|
||||
std::cout.flush();
|
||||
|
||||
{
|
||||
boost::read_write_mutex plain_rw(static_cast<boost::read_write_scheduling_policy::read_write_scheduling_policy_enum>(i));
|
||||
test_plain_read_write_mutex(plain_rw, test_promotion_and_demotion);
|
||||
}
|
||||
|
||||
std::cout << "try test, sp=" << i
|
||||
<< (test_promotion_and_demotion ? " with promotion & demotion" : " without promotion & demotion")
|
||||
<< "\n";
|
||||
std::cout.flush();
|
||||
|
||||
{
|
||||
boost::try_read_write_mutex try_rw(static_cast<boost::read_write_scheduling_policy::read_write_scheduling_policy_enum>(i));
|
||||
test_try_read_write_mutex(try_rw, test_promotion_and_demotion);
|
||||
}
|
||||
|
||||
std::cout << "timed test, sp=" << i
|
||||
<< (test_promotion_and_demotion ? " with promotion & demotion" : " without promotion & demotion")
|
||||
<< "\n";
|
||||
std::cout.flush();
|
||||
|
||||
{
|
||||
boost::timed_read_write_mutex timed_rw(static_cast<boost::read_write_scheduling_policy::read_write_scheduling_policy_enum>(i));
|
||||
test_timed_read_write_mutex(timed_rw, test_promotion_and_demotion);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void test_read_write_mutex()
|
||||
{
|
||||
do_test_read_write_mutex(false);
|
||||
do_test_read_write_mutex(true);
|
||||
}
|
||||
|
||||
boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
|
||||
{
|
||||
boost::unit_test_framework::test_suite* test =
|
||||
BOOST_TEST_SUITE("Boost.Threads: read_write_mutex test suite");
|
||||
|
||||
test->add(BOOST_TEST_CASE(&test_read_write_mutex));
|
||||
|
||||
return test;
|
||||
}
|
||||
@@ -41,7 +41,7 @@ void test_sleep()
|
||||
|
||||
// Ensure it's in a range instead of checking actual equality due to time
|
||||
// lapse
|
||||
BOOST_CHECK(in_range(xt));
|
||||
BOOST_CHECK(in_range(xt, 2));
|
||||
}
|
||||
|
||||
void do_test_creation()
|
||||
|
||||
Reference in New Issue
Block a user