|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r82029 - in branches/release: boost/thread boost/thread/detail libs/thread libs/thread/build libs/thread/example libs/thread/src libs/thread/src/pthread libs/thread/src/win32 libs/thread/test libs/thread/test/sync/futures/future libs/thread/test/sync/futures/packaged_task libs/thread/test/sync/futures/promise libs/thread/test/sync/mutual_exclusion/locks/nested_strict_lock libs/thread/test/sync/mutual_exclusion/locks/strict_lock
From: vicente.botet_at_[hidden]
Date: 2012-12-16 14:01:47
Author: viboes
Date: 2012-12-16 14:01:45 EST (Sun, 16 Dec 2012)
New Revision: 82029
URL: http://svn.boost.org/trac/boost/changeset/82029
Log:
Merge from trunk 1.53
Added:
branches/release/boost/thread/detail/lockable_wrapper.hpp
- copied unchanged from r82018, /trunk/boost/thread/detail/lockable_wrapper.hpp
branches/release/boost/thread/future_error_code.hpp
- copied unchanged from r82018, /trunk/boost/thread/future_error_code.hpp
Properties modified:
branches/release/boost/thread/ (props changed)
branches/release/libs/thread/ (props changed)
Text files modified:
branches/release/boost/thread/detail/thread.hpp | 2
branches/release/boost/thread/externally_locked.hpp | 16
branches/release/boost/thread/future.hpp | 254 ++++++++++-----------------
branches/release/boost/thread/lock_guard.hpp | 28 --
branches/release/boost/thread/strict_lock.hpp | 43 ++++
branches/release/boost/thread/synchronized_value.hpp | 361 +++++++++++++++++++++++----------------
branches/release/libs/thread/build/Jamfile.v2 | 4
branches/release/libs/thread/example/future_then.cpp | 5
branches/release/libs/thread/example/synchronized_person.cpp | 25 ++
branches/release/libs/thread/example/synchronized_value.cpp | 8
branches/release/libs/thread/src/future.cpp | 6
branches/release/libs/thread/src/pthread/thread.cpp | 2
branches/release/libs/thread/src/win32/thread.cpp | 2
branches/release/libs/thread/test/Jamfile.v2 | 14
branches/release/libs/thread/test/sync/futures/future/get_pass.cpp | 51 ++++-
branches/release/libs/thread/test/sync/futures/future/then_pass.cpp | 19 +
branches/release/libs/thread/test/sync/futures/packaged_task/make_ready_at_thread_exit_pass.cpp | 39 ++++
branches/release/libs/thread/test/sync/futures/promise/set_exception_at_thread_exit_pass.cpp | 21 ++
branches/release/libs/thread/test/sync/futures/promise/set_value_at_thread_exit_const_pass.cpp | 7
branches/release/libs/thread/test/sync/futures/promise/set_value_at_thread_exit_void_pass.cpp | 38 +++
branches/release/libs/thread/test/sync/mutual_exclusion/locks/nested_strict_lock/copy_ctor_fail.cpp | 4
branches/release/libs/thread/test/sync/mutual_exclusion/locks/nested_strict_lock/make_nested_strict_lock_pass.cpp | 4
branches/release/libs/thread/test/sync/mutual_exclusion/locks/strict_lock/make_strict_lock_pass.cpp | 2
23 files changed, 557 insertions(+), 398 deletions(-)
Modified: branches/release/boost/thread/detail/thread.hpp
==============================================================================
--- branches/release/boost/thread/detail/thread.hpp (original)
+++ branches/release/boost/thread/detail/thread.hpp 2012-12-16 14:01:45 EST (Sun, 16 Dec 2012)
@@ -731,7 +731,7 @@
namespace this_thread
{
- thread::id get_id() BOOST_NOEXCEPT
+ inline thread::id get_id() BOOST_NOEXCEPT
{
#if defined BOOST_THREAD_PROVIDES_BASIC_THREAD_ID
return pthread_self();
Modified: branches/release/boost/thread/externally_locked.hpp
==============================================================================
--- branches/release/boost/thread/externally_locked.hpp (original)
+++ branches/release/boost/thread/externally_locked.hpp 2012-12-16 14:01:45 EST (Sun, 16 Dec 2012)
@@ -53,7 +53,7 @@
/**
* Requires: T is a model of Movable.
- * Effects: Constructs an externally locked object copying the cloaked type.
+ * Effects: Constructs an externally locked object by moving the cloaked type.
*/
BOOST_CONSTEXPR externally_locked(mutex_type& mtx, BOOST_THREAD_RV_REF(T) obj) :
obj_(move(obj)), mtx_(&mtx)
@@ -83,7 +83,7 @@
*
* Returns: The address of the cloaked object..
*
- * Throws: lock_error if BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_SAME is not defined and the lk parameter doesn't satisfy the preconditions
+ * Throws: lock_error if BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED is not defined and the lk parameter doesn't satisfy the preconditions
*/
T& get(strict_lock<mutex_type>& lk)
{
@@ -117,7 +117,7 @@
* Requires: The lk parameter must be locking the associated mtx.
* Returns: The address of the cloaked object..
*
- * Throws: lock_error if BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_SAME is not defined and the lk parameter doesn't satisfy the preconditions
+ * Throws: lock_error if BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED is not defined and the lk parameter doesn't satisfy the preconditions
*/
template <class Lock>
T& get(Lock& lk)
@@ -203,7 +203,7 @@
*
* Returns: The address of the cloaked object..
*
- * Throws: lock_error if BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_SAME is not defined and the lk parameter doesn't satisfy the preconditions
+ * Throws: lock_error if BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED is not defined and the lk parameter doesn't satisfy the preconditions
*/
T& get(strict_lock<mutex_type> const& lk)
{
@@ -237,7 +237,7 @@
* Requires: The lk parameter must be locking the associated mtx.
* Returns: The address of the cloaked object..
*
- * Throws: lock_error if BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_SAME is not defined and the lk parameter doesn't satisfy the preconditions
+ * Throws: lock_error if BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED is not defined and the lk parameter doesn't satisfy the preconditions
*/
template <class Lock>
T& get(Lock const& lk)
@@ -245,7 +245,7 @@
BOOST_CONCEPT_ASSERT(( StrictLock<Lock> ));
BOOST_STATIC_ASSERT( (is_strict_lock<Lock>::value)); /*< lk is a strict lock "sur parolle" >*/
BOOST_STATIC_ASSERT( (is_same<mutex_type, typename Lock::mutex_type>::value)); /*< that locks the same type >*/
- BOOST_THREAD_ASSERT_PRECONDITION( lk.owns_lock(), lock_error() ); /*< run time check throw if no locked >*/
+ //BOOST_THREAD_ASSERT_PRECONDITION( lk.owns_lock(), lock_error() ); /*< run time check throw if no locked >*/
BOOST_THREAD_ASSERT_PRECONDITION( lk.owns_lock(mtx_), lock_error() ); /*< run time check throw if not locks the same >*/
return *obj_;
}
@@ -254,7 +254,7 @@
* Requires: The lk parameter must be locking the associated mtx.
* Returns: The address of the cloaked object..
*
- * Throws: lock_error if BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_SAME is not defined and the lk parameter doesn't satisfy the preconditions
+ * Throws: lock_error if BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED is not defined and the lk parameter doesn't satisfy the preconditions
*/
template <class Lock>
T const& get(Lock const& lk) const
@@ -262,7 +262,7 @@
BOOST_CONCEPT_ASSERT(( StrictLock<Lock> ));
BOOST_STATIC_ASSERT( (is_strict_lock<Lock>::value)); /*< lk is a strict lock "sur parolle" >*/
BOOST_STATIC_ASSERT( (is_same<mutex_type, typename Lock::mutex_type>::value)); /*< that locks the same type >*/
- BOOST_THREAD_ASSERT_PRECONDITION( lk.owns_lock(), lock_error() ); /*< run time check throw if no locked >*/
+ //BOOST_THREAD_ASSERT_PRECONDITION( lk.owns_lock(), lock_error() ); /*< run time check throw if no locked >*/
BOOST_THREAD_ASSERT_PRECONDITION( lk.owns_lock(mtx_), lock_error() ); /*< run time check throw if not locks the same >*/
return *obj_;
}
Modified: branches/release/boost/thread/future.hpp
==============================================================================
--- branches/release/boost/thread/future.hpp (original)
+++ branches/release/boost/thread/future.hpp 2012-12-16 14:01:45 EST (Sun, 16 Dec 2012)
@@ -15,6 +15,7 @@
#ifndef BOOST_NO_EXCEPTIONS
+//#include <boost/thread/detail/log.hpp>
#include <boost/detail/scoped_enum_emulation.hpp>
#include <stdexcept>
#include <boost/thread/detail/move.hpp>
@@ -45,7 +46,7 @@
#include <boost/next_prior.hpp>
#include <vector>
-#include <boost/system/error_code.hpp>
+#include <boost/thread/future_error_code.hpp>
#ifdef BOOST_THREAD_USES_CHRONO
#include <boost/chrono/system_clocks.hpp>
#endif
@@ -66,87 +67,46 @@
namespace boost
{
-
- //enum class future_errc
- BOOST_SCOPED_ENUM_DECLARE_BEGIN(future_errc)
- {
- broken_promise = 1,
- future_already_retrieved,
- promise_already_satisfied,
- no_state
- }
- BOOST_SCOPED_ENUM_DECLARE_END(future_errc)
-
- namespace system
- {
- template <>
- struct BOOST_SYMBOL_VISIBLE is_error_code_enum<future_errc> : public true_type {};
-
- #ifdef BOOST_NO_CXX11_SCOPED_ENUMS
- template <>
- struct BOOST_SYMBOL_VISIBLE is_error_code_enum<future_errc::enum_type> : public true_type { };
- #endif
- }
-
- //enum class launch
- BOOST_SCOPED_ENUM_DECLARE_BEGIN(launch)
- {
- async = 1,
- deferred = 2,
- any = async | deferred
- }
- BOOST_SCOPED_ENUM_DECLARE_END(launch)
-
- //enum class future_status
- BOOST_SCOPED_ENUM_DECLARE_BEGIN(future_status)
- {
- ready,
- timeout,
- deferred
- }
- BOOST_SCOPED_ENUM_DECLARE_END(future_status)
-
- BOOST_THREAD_DECL
- const system::error_category& future_category() BOOST_NOEXCEPT;
-
- namespace system
- {
- inline
- error_code
- make_error_code(future_errc e) //BOOST_NOEXCEPT
+ //enum class launch
+ BOOST_SCOPED_ENUM_DECLARE_BEGIN(launch)
{
- return error_code(underlying_cast<int>(e), boost::future_category());
+ none = 0,
+ async = 1,
+ deferred = 2,
+ any = async | deferred
}
+ BOOST_SCOPED_ENUM_DECLARE_END(launch)
- inline
- error_condition
- make_error_condition(future_errc e) //BOOST_NOEXCEPT
+ //enum class future_status
+ BOOST_SCOPED_ENUM_DECLARE_BEGIN(future_status)
{
- return error_condition(underlying_cast<int>(e), future_category());
+ ready,
+ timeout,
+ deferred
}
- }
+ BOOST_SCOPED_ENUM_DECLARE_END(future_status)
- class BOOST_SYMBOL_VISIBLE future_error
- : public std::logic_error
- {
- system::error_code ec_;
- public:
- future_error(system::error_code ec)
- : logic_error(ec.message()),
- ec_(ec)
- {
- }
+ class BOOST_SYMBOL_VISIBLE future_error
+ : public std::logic_error
+ {
+ system::error_code ec_;
+ public:
+ future_error(system::error_code ec)
+ : logic_error(ec.message()),
+ ec_(ec)
+ {
+ }
- const system::error_code& code() const BOOST_NOEXCEPT
- {
- return ec_;
- }
- const char* what() const BOOST_THREAD_NOEXCEPT_OR_THROW
- {
- return code().message().c_str();
- }
+ const system::error_code& code() const BOOST_NOEXCEPT
+ {
+ return ec_;
+ }
+ const char* what() const BOOST_THREAD_NOEXCEPT_OR_THROW
+ {
+ return code().message().c_str();
+ }
- };
+ };
class BOOST_SYMBOL_VISIBLE future_uninitialized:
public future_error
@@ -190,23 +150,23 @@
{}
};
- class BOOST_SYMBOL_VISIBLE task_moved:
- public future_error
- {
- public:
- task_moved():
- future_error(system::make_error_code(future_errc::no_state))
- {}
- };
+ class BOOST_SYMBOL_VISIBLE task_moved:
+ public future_error
+ {
+ public:
+ task_moved():
+ future_error(system::make_error_code(future_errc::no_state))
+ {}
+ };
- class promise_moved:
- public future_error
- {
- public:
- promise_moved():
- future_error(system::make_error_code(future_errc::no_state))
- {}
- };
+ class promise_moved:
+ public future_error
+ {
+ public:
+ promise_moved():
+ future_error(system::make_error_code(future_errc::no_state))
+ {}
+ };
namespace future_state
{
@@ -283,7 +243,7 @@
future_object_base():
done(false),
is_deferred_(false),
- policy_(launch::any),
+ policy_(launch::none),
is_constructed(false)
//#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
, thread_was_interrupted(false)
@@ -295,8 +255,19 @@
virtual ~future_object_base()
{}
- void set_deferred() {is_deferred_ = true;}
- void set_launch_policy(launch policy) {policy_ = policy;}
+ void set_deferred()
+ {
+ is_deferred_ = true;
+ set_launch_policy(launch::deferred);
+ }
+ void set_async()
+ {
+ set_launch_policy(launch::async);
+ }
+ void set_launch_policy(launch policy)
+ {
+ policy_ = policy;
+ }
waiter_list::iterator register_external_waiter(boost::condition_variable_any& cv)
{
@@ -508,7 +479,9 @@
#endif
);
}
- void is_deferred() {is_deferred_ = true;}
+ bool is_deferred() const BOOST_NOEXCEPT {
+ return is_deferred_ == true;
+ }
launch launch_policy() const BOOST_NOEXCEPT
{
@@ -518,6 +491,7 @@
template<typename F,typename U>
void set_wait_callback(F f,U* u)
{
+ boost::lock_guard<boost::mutex> lock(mutex);
callback=boost::bind(f,boost::ref(*u));
}
virtual void execute(boost::unique_lock<boost::mutex>&) {}
@@ -861,35 +835,41 @@
future_object& operator=(future_object const&);
};
+ /////////////////////////
/// future_async_object
+ /////////////////////////
template<typename Rp, typename Fp>
struct future_async_object: future_object<Rp>
{
typedef future_object<Rp> base_type;
+ typedef typename base_type::move_dest_type move_dest_type;
+
boost::thread thr_;
public:
- #if ! defined BOOST_NO_CXX11_RVALUE_REFERENCES
- explicit future_async_object(Fp&& f)
- :
- #else
- explicit future_async_object(BOOST_THREAD_FWD_REF(Fp) f)
- :
- #endif
- thr_(&future_async_object::run, this, boost::forward<Fp>(f))
+ explicit future_async_object(BOOST_THREAD_FWD_REF(Fp) f) :
+ thr_(&future_async_object::run, this, boost::forward<Fp>(f))
{
+ this->set_async();
}
~future_async_object()
{
- thr_.join();
+ if (thr_.joinable()) thr_.join();
+ }
+
+ move_dest_type get()
+ {
+ if (thr_.joinable()) thr_.join();
+ // fixme Is the lock needed during the whole scope?
+ //this->wait();
+ boost::unique_lock<boost::mutex> lock(this->mutex);
+ this->wait_internal(lock);
+
+ return static_cast<move_dest_type>(*(this->result));
}
-#if ! defined BOOST_NO_CXX11_RVALUE_REFERENCES
- static void run(future_async_object* that, Fp&& f)
-#else
static void run(future_async_object* that, BOOST_THREAD_FWD_REF(Fp) f)
-#endif
{
try
{
@@ -912,30 +892,22 @@
struct future_async_object<void, Fp>: public future_object<void>
{
typedef future_object<void> base_type;
+
boost::thread thr_;
public:
- #if ! defined BOOST_NO_CXX11_RVALUE_REFERENCES
- explicit future_async_object(Fp&& f)
- :
- #else
- explicit future_async_object(BOOST_THREAD_FWD_REF(Fp) f)
- :
- #endif
- thr_(&future_async_object::run, this, boost::forward<Fp>(f))
+ explicit future_async_object(BOOST_THREAD_FWD_REF(Fp) f) :
+ thr_(&future_async_object::run, this, boost::forward<Fp>(f))
{
+ this->set_async();
}
~future_async_object()
{
- thr_.join();
+ if (thr_.joinable()) thr_.join();
}
-#if ! defined BOOST_NO_CXX11_RVALUE_REFERENCES
- static void run(future_async_object* that, Fp&& f)
-#else
static void run(future_async_object* that, BOOST_THREAD_FWD_REF(Fp) f)
-#endif
{
try
{
@@ -954,7 +926,9 @@
}
}
};
+ //////////////////////////
/// future_deferred_object
+ //////////////////////////
template<typename Rp, typename Fp>
struct future_deferred_object: future_object<Rp>
{
@@ -962,13 +936,8 @@
Fp func_;
public:
- #if ! defined BOOST_NO_CXX11_RVALUE_REFERENCES
- explicit future_deferred_object(Fp&& f)
+ explicit future_deferred_object(BOOST_THREAD_FWD_REF(Fp) f)
: func_(boost::forward<Fp>(f))
- #else
- explicit future_deferred_object(Fp f)
- : func_(f)
- #endif
{
this->set_deferred();
}
@@ -992,13 +961,8 @@
Fp func_;
public:
- #if ! defined BOOST_NO_CXX11_RVALUE_REFERENCES
- explicit future_deferred_object(Fp&& f)
+ explicit future_deferred_object(BOOST_THREAD_FWD_REF(Fp) f)
: func_(boost::forward<Fp>(f))
- #else
- explicit future_deferred_object(Fp f)
- : func_(f)
- #endif
{
this->set_deferred();
}
@@ -1333,7 +1297,7 @@
launch launch_policy() const BOOST_NOEXCEPT
{
if ( future_ ) return future_->launch_policy();
- else return launch(launch::any);
+ else return launch(launch::none);
}
bool valid() const BOOST_NOEXCEPT
@@ -1396,19 +1360,11 @@
{
template <class Rp, class Fp>
BOOST_THREAD_FUTURE<Rp>
- #if ! defined BOOST_NO_CXX11_RVALUE_REFERENCES
- make_future_async_object(Fp&& f);
- #else
make_future_async_object(BOOST_THREAD_FWD_REF(Fp) f);
- #endif
template <class Rp, class Fp>
BOOST_THREAD_FUTURE<Rp>
- #if ! defined BOOST_NO_CXX11_RVALUE_REFERENCES
- make_future_deferred_object(Fp&& f);
- #else
make_future_deferred_object(BOOST_THREAD_FWD_REF(Fp) f);
- #endif
}
template <typename R>
@@ -1433,19 +1389,11 @@
template <class Rp, class Fp>
friend BOOST_THREAD_FUTURE<Rp>
- #if ! defined BOOST_NO_CXX11_RVALUE_REFERENCES
- detail::make_future_async_object(Fp&& f);
- #else
detail::make_future_async_object(BOOST_THREAD_FWD_REF(Fp) f);
- #endif
template <class Rp, class Fp>
friend BOOST_THREAD_FUTURE<Rp>
- #if ! defined BOOST_NO_CXX11_RVALUE_REFERENCES
- detail::make_future_deferred_object(Fp&& f);
- #else
detail::make_future_deferred_object(BOOST_THREAD_FWD_REF(Fp) f);
- #endif
typedef typename detail::future_traits<R>::move_dest_type move_dest_type;
@@ -2856,11 +2804,7 @@
////////////////////////////////
template <class Rp, class Fp>
BOOST_THREAD_FUTURE<Rp>
- #if ! defined BOOST_NO_CXX11_RVALUE_REFERENCES
- make_future_deferred_object(Fp&& f)
- #else
make_future_deferred_object(BOOST_THREAD_FWD_REF(Fp) f)
- #endif
{
shared_ptr<future_deferred_object<Rp, Fp> >
h(new future_deferred_object<Rp, Fp>(boost::forward<Fp>(f)));
@@ -2872,11 +2816,7 @@
////////////////////////////////
template <class Rp, class Fp>
BOOST_THREAD_FUTURE<Rp>
- #if ! defined BOOST_NO_CXX11_RVALUE_REFERENCES
- make_future_async_object(Fp&& f)
- #else
make_future_async_object(BOOST_THREAD_FWD_REF(Fp) f)
- #endif
{
shared_ptr<future_async_object<Rp, Fp> >
h(new future_async_object<Rp, Fp>(boost::forward<Fp>(f)));
Modified: branches/release/boost/thread/lock_guard.hpp
==============================================================================
--- branches/release/boost/thread/lock_guard.hpp (original)
+++ branches/release/boost/thread/lock_guard.hpp 2012-12-16 14:01:45 EST (Sun, 16 Dec 2012)
@@ -9,42 +9,18 @@
#include <boost/thread/detail/delete.hpp>
#include <boost/thread/detail/move.hpp>
+#include <boost/thread/detail/lockable_wrapper.hpp>
#include <boost/thread/lock_options.hpp>
#if ! defined BOOST_THREAD_PROVIDES_NESTED_LOCKS
#include <boost/thread/is_locked_by_this_thread.hpp>
-#endif
#include <boost/assert.hpp>
-#include <iostream>
-#if ! defined BOOST_NO_CXX11_HDR_INITIALIZER_LIST
-#include <initializer_list>
#endif
+
#include <boost/config/abi_prefix.hpp>
namespace boost
{
-#if ! defined BOOST_NO_CXX11_HDR_INITIALIZER_LIST
- namespace thread_detail
- {
- template <typename Mutex>
- struct lockable_wrapper
- {
- Mutex* m;
- explicit lockable_wrapper(Mutex& m_) :
- m(&m_)
- {}
- };
- template <typename Mutex>
- struct lockable_adopt_wrapper
- {
- Mutex* m;
- explicit lockable_adopt_wrapper(Mutex& m_) :
- m(&m_)
- {}
- };
- }
-#endif
-
template <typename Mutex>
class lock_guard
{
Modified: branches/release/boost/thread/strict_lock.hpp
==============================================================================
--- branches/release/boost/thread/strict_lock.hpp (original)
+++ branches/release/boost/thread/strict_lock.hpp 2012-12-16 14:01:45 EST (Sun, 16 Dec 2012)
@@ -7,6 +7,7 @@
#define BOOST_THREAD_STRICT_LOCK_HPP
#include <boost/thread/detail/delete.hpp>
+#include <boost/thread/detail/lockable_wrapper.hpp>
#include <boost/thread/lock_options.hpp>
#include <boost/thread/lock_traits.hpp>
#include <boost/thread/lockable_traits.hpp>
@@ -48,6 +49,15 @@
mtx.lock();
} /*< locks on construction >*/
+
+#if ! defined BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+ strict_lock(std::initializer_list<thread_detail::lockable_wrapper<Lockable> > l_) :
+ mtx_(*(const_cast<thread_detail::lockable_wrapper<Lockable>*>(l_.begin())->m))
+ {
+ mtx_.lock();
+ }
+#endif
+
/**
* Destructor
*
@@ -97,7 +107,7 @@
/**
* A nested strict lock is a scoped lock guard ensuring the mutex is locked on its
- * scope, by taking ownership of an nesting lock, and locking the mutex on construction if not already locked
+ * scope, by taking ownership of an nesting lock, locking the mutex on construction if not already locked
* and restoring the ownership to the nesting lock on destruction.
*/
//[nested_strict_lock
@@ -117,8 +127,8 @@
*
* __Requires: <c>lk.mutex() != null_ptr</c>
* __Effects: Stores the reference to the lock parameter and takes ownership on it.
- * If the lock doesn't owns the mutex @mtx lock it.
- * __Postconditions: @c owns_lock()
+ * If the lock doesn't owns the mutex @c mtx lock it.
+ * __Postconditions: @c owns_lock(lk.mutex())
* __StrongException
* __Throws:
*
@@ -127,7 +137,7 @@
* - Any exception that @c lk.lock() can throw.
*
*/
- nested_strict_lock(Lock& lk) :
+ explicit nested_strict_lock(Lock& lk) :
lk_(lk) /*< Store reference to lk >*/
{
/*< Define BOOST_THREAD_DONT_CHECK_PRECONDITIONS if you don't want to check lk ownership >*/
@@ -138,6 +148,19 @@
tmp_lk_ = move(lk); /*< Move ownership to temporary lk >*/
}
+#if ! defined BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+ nested_strict_lock(std::initializer_list<thread_detail::lockable_wrapper<Lock> > l_) :
+ lk_(*(const_cast<thread_detail::lockable_wrapper<Lock>*>(l_.begin())->m))
+ {
+ /*< Define BOOST_THREAD_DONT_CHECK_PRECONDITIONS if you don't want to check lk ownership >*/
+ BOOST_THREAD_ASSERT_PRECONDITION( lk_.mutex() != 0,
+ lock_error()
+ );
+ if (!lk_.owns_lock()) lk_.lock(); /*< ensures it is locked >*/
+ tmp_lk_ = move(lk_); /*< Move ownership to temporary lk >*/
+ }
+#endif
+
/**
* Destructor
*
@@ -180,6 +203,18 @@
{
};
+#if ! defined BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+ template <typename Lockable>
+ strict_lock<Lockable> make_strict_lock(Lockable& mtx)
+ {
+ return { thread_detail::lockable_wrapper<Lockable>(mtx) };
+ }
+ template <typename Lock>
+ nested_strict_lock<Lock> make_nested_strict_lock(Lock& lk)
+ {
+ return { thread_detail::lockable_wrapper<Lock>(lk) };
+ }
+#endif
}
#include <boost/config/abi_suffix.hpp>
Modified: branches/release/boost/thread/synchronized_value.hpp
==============================================================================
--- branches/release/boost/thread/synchronized_value.hpp (original)
+++ branches/release/boost/thread/synchronized_value.hpp 2012-12-16 14:01:45 EST (Sun, 16 Dec 2012)
@@ -23,6 +23,195 @@
namespace boost
{
+
+ /**
+ *
+ */
+ template <typename T, typename Lockable = mutex>
+ class const_strict_lock_ptr
+ {
+ public:
+ typedef T value_type;
+ typedef Lockable lockable_type;
+ protected:
+
+ // this should be a strict_lock, but we need to be able to return it.
+ boost::unique_lock<lockable_type> lk_;
+ T const& value_;
+
+ public:
+ BOOST_THREAD_MOVABLE_ONLY( const_strict_lock_ptr )
+
+ const_strict_lock_ptr(T const& value, Lockable & mtx) :
+ lk_(mtx), value_(value)
+ {
+ }
+
+ const_strict_lock_ptr(BOOST_THREAD_RV_REF(const_strict_lock_ptr) other)
+ : lk_(boost::move(BOOST_THREAD_RV(other).lk_)),value_(BOOST_THREAD_RV(other).value_)
+ {
+ }
+
+ ~const_strict_lock_ptr()
+ {
+ }
+
+ const T* operator->() const
+ {
+ return &value_;
+ }
+
+ const T& operator*() const
+ {
+ return value_;
+ }
+
+ };
+
+ /**
+ *
+ */
+ template <typename T, typename Lockable = mutex>
+ class strict_lock_ptr : public const_strict_lock_ptr<T,Lockable>
+ {
+ typedef const_strict_lock_ptr<T,Lockable> base_type;
+ public:
+ BOOST_THREAD_MOVABLE_ONLY( strict_lock_ptr )
+
+ strict_lock_ptr(T & value, Lockable & mtx) :
+ base_type(value, mtx)
+ {
+ }
+
+ strict_lock_ptr(BOOST_THREAD_RV_REF(strict_lock_ptr) other)
+ : base_type(boost::move(static_cast<base_type&>(other)))
+ {
+ }
+
+ ~strict_lock_ptr()
+ {
+ }
+
+ T* operator->()
+ {
+ return const_cast<T*>(&this->value_);
+ }
+
+ T& operator*()
+ {
+ return const_cast<T&>(this->value_);
+ }
+
+ };
+
+ /**
+ *
+ */
+ template <typename T, typename Lockable = mutex>
+ class const_unique_lock_ptr : public unique_lock<Lockable>
+ {
+ typedef unique_lock<Lockable> base_type;
+ public:
+ typedef T value_type;
+ typedef Lockable lockable_type;
+ protected:
+ T const& value_;
+
+ public:
+ BOOST_THREAD_MOVABLE_ONLY(const_unique_lock_ptr)
+
+ const_unique_lock_ptr(T const& value, Lockable & mtx)
+ : base_type(mtx), value_(value)
+ {
+ }
+ const_unique_lock_ptr(T const& value, Lockable & mtx, adopt_lock_t)
+ : base_type(mtx, adopt_lock), value_(value)
+ {
+ }
+ const_unique_lock_ptr(T const& value, Lockable & mtx, defer_lock_t)
+ : base_type(mtx, defer_lock), value_(value)
+ {
+ }
+ const_unique_lock_ptr(T const& value, Lockable & mtx, try_to_lock_t)
+ : base_type(mtx, try_to_lock), value_(value)
+ {
+ }
+ const_unique_lock_ptr(BOOST_THREAD_RV_REF(const_unique_lock_ptr) other)
+ : base_type(boost::move(static_cast<base_type&>(other))), value_(BOOST_THREAD_RV(other).value_)
+ {
+ }
+
+ ~const_unique_lock_ptr()
+ {
+ }
+
+ const T* operator->() const
+ {
+ BOOST_ASSERT (this->owns_lock());
+ return &value_;
+ }
+
+ const T& operator*() const
+ {
+ BOOST_ASSERT (this->owns_lock());
+ return value_;
+ }
+
+ };
+
+ /**
+ *
+ */
+ template <typename T, typename Lockable = mutex>
+ class unique_lock_ptr : public const_unique_lock_ptr<T, Lockable>
+ {
+ typedef const_unique_lock_ptr<T, Lockable> base_type;
+ public:
+ typedef T value_type;
+ typedef Lockable lockable_type;
+
+ BOOST_THREAD_MOVABLE_ONLY(unique_lock_ptr)
+
+ unique_lock_ptr(T & value, Lockable & mtx)
+ : base_type(value, mtx)
+ {
+ }
+ unique_lock_ptr(T & value, Lockable & mtx, adopt_lock_t)
+ : base_type(value, mtx, adopt_lock)
+ {
+ }
+ unique_lock_ptr(T & value, Lockable & mtx, defer_lock_t)
+ : base_type(value, mtx, defer_lock)
+ {
+ }
+ unique_lock_ptr(T & value, Lockable & mtx, try_to_lock_t)
+ : base_type(value, mtx, try_to_lock)
+ {
+ }
+ unique_lock_ptr(BOOST_THREAD_RV_REF(unique_lock_ptr) other)
+ : base_type(boost::move(static_cast<base_type&>(other)))
+ {
+ }
+
+ ~unique_lock_ptr()
+ {
+ }
+
+ T* operator->()
+ {
+ BOOST_ASSERT (this->owns_lock());
+ return const_cast<T*>(&this->value_);
+ }
+
+ T& operator*()
+ {
+ BOOST_ASSERT (this->owns_lock());
+ return const_cast<T&>(this->value_);
+ }
+
+
+ };
+
/**
*
*/
@@ -181,99 +370,24 @@
boost::swap(value_, rhs.value_);
}
- /**
- *
- */
- struct const_strict_synchronizer
- {
- protected:
- friend class synchronized_value;
-
- // this should be a strict_lock, but we need to be able to return it.
- boost::unique_lock<lockable_type> lk_;
- T const& value_;
-
- explicit const_strict_synchronizer(synchronized_value const& outer) :
- lk_(outer.mtx_), value_(outer.value_)
- {
- }
- public:
- BOOST_THREAD_MOVABLE_ONLY( const_strict_synchronizer )
-
- const_strict_synchronizer(BOOST_THREAD_RV_REF(const_strict_synchronizer) other)
- : lk_(boost::move(BOOST_THREAD_RV(other).lk_)),value_(BOOST_THREAD_RV(other).value_)
- {
- }
-
- ~const_strict_synchronizer()
- {
- }
-
- const T* operator->() const
- {
- return &value_;
- }
-
- const T& operator*() const
- {
- return value_;
- }
-
- };
-
- /**
- *
- */
- struct strict_synchronizer : const_strict_synchronizer
- {
- protected:
- friend class synchronized_value;
-
- explicit strict_synchronizer(synchronized_value& outer) :
- const_strict_synchronizer(const_cast<synchronized_value&>(outer))
- {
- }
- public:
- BOOST_THREAD_MOVABLE_ONLY( strict_synchronizer )
-
- strict_synchronizer(BOOST_THREAD_RV_REF(strict_synchronizer) other)
- : const_strict_synchronizer(boost::move(static_cast<const_strict_synchronizer&>(other)))
- {
- }
-
- ~strict_synchronizer()
- {
- }
-
- T* operator->()
- {
- return const_cast<T*>(&this->value_);
- }
-
- T& operator*()
- {
- return const_cast<T&>(this->value_);
- }
-
- };
/**
* Essentially calling a method obj->foo(x, y, z) calls the method foo(x, y, z) inside a critical section as
* long-lived as the call itself.
*/
- strict_synchronizer operator->()
+ strict_lock_ptr<T,Lockable> operator->()
{
- return BOOST_THREAD_MAKE_RV_REF(strict_synchronizer(*this));
+ return BOOST_THREAD_MAKE_RV_REF((strict_lock_ptr<T,Lockable>(value_, mtx_)));
}
/**
* If the synchronized_value object involved is const-qualified, then you'll only be able to call const methods
* through operator->. So, for example, vec->push_back("xyz") won't work if vec were const-qualified.
* The locking mechanism capitalizes on the assumption that const methods don't modify their underlying data.
*/
- const_strict_synchronizer operator->() const
+ const_strict_lock_ptr<T,Lockable> operator->() const
{
- return BOOST_THREAD_MAKE_RV_REF(const_strict_synchronizer(*this));
+ return BOOST_THREAD_MAKE_RV_REF((const_strict_lock_ptr<T,Lockable>(value_, mtx_)));
}
/**
@@ -288,83 +402,32 @@
* assert(vec.back() == 42);
* }
*/
- strict_synchronizer synchronize()
+ strict_lock_ptr<T,Lockable> synchronize()
{
- return BOOST_THREAD_MAKE_RV_REF(strict_synchronizer(*this));
+ return BOOST_THREAD_MAKE_RV_REF((strict_lock_ptr<T,Lockable>(value_, mtx_)));
}
- const_strict_synchronizer synchronize() const
+ const_strict_lock_ptr<T,Lockable> synchronize() const
{
- return BOOST_THREAD_MAKE_RV_REF(const_strict_synchronizer(*this));
+ return BOOST_THREAD_MAKE_RV_REF((const_strict_lock_ptr<T,Lockable>(value_, mtx_)));
}
- /**
- *
- */
- struct unique_synchronizer : unique_lock<lockable_type>
+ unique_lock_ptr<T,Lockable> unique_synchronize()
{
- private:
- //friend class synchronized_value;
- typedef unique_lock<lockable_type> base_type;
-
- T& value_;
-
- public:
- BOOST_THREAD_MOVABLE_ONLY(unique_synchronizer)
-
- explicit unique_synchronizer(synchronized_value& outer)
- : base_type(outer.mtx_), value_(outer.value_)
- {
- }
- unique_synchronizer(synchronized_value& outer, adopt_lock_t)
- : base_type(outer.mtx_, adopt_lock), value_(outer.value_)
- {
- }
- unique_synchronizer(synchronized_value& outer, defer_lock_t)
- : base_type(outer.mtx_, defer_lock), value_(outer.value_)
- {
- }
- unique_synchronizer(synchronized_value& outer, try_to_lock_t)
- : base_type(outer.mtx_, try_to_lock), value_(outer.value_)
- {
- }
- unique_synchronizer(BOOST_THREAD_RV_REF(unique_synchronizer) other)
- : base_type(boost::move(other)),value_(BOOST_THREAD_RV(other).value_)
- {
- }
-
- ~unique_synchronizer()
- {
- }
-
- T* operator->()
- {
- if (this->owns_lock())
- return &value_;
- else
- return 0;
- }
-
- const T* operator->() const
- {
- if (this->owns_lock())
- return &value_;
- else
- return 0;
- }
-
- T& operator*()
- {
- BOOST_ASSERT (this->owns_lock());
- return value_;
- }
-
- const T& operator*() const
- {
- BOOST_ASSERT (this->owns_lock());
- return value_;
- }
+ return BOOST_THREAD_MAKE_RV_REF((unique_lock_ptr<T,Lockable>(value_, mtx_)));
+ }
+ unique_lock_ptr<T,Lockable> unique_synchronize(defer_lock_t tag)
+ {
+ return BOOST_THREAD_MAKE_RV_REF((unique_lock_ptr<T,Lockable>(value_, mtx_, tag)));
+ }
+ const_unique_lock_ptr<T,Lockable> unique_synchronize() const
+ {
+ return BOOST_THREAD_MAKE_RV_REF((const_unique_lock_ptr<T,Lockable>(value_, mtx_)));
+ }
+ const_unique_lock_ptr<T,Lockable> unique_synchronize(defer_lock_t tag) const
+ {
+ return BOOST_THREAD_MAKE_RV_REF((const_unique_lock_ptr<T,Lockable>(value_, mtx_, tag)));
+ }
- };
private:
class deref_value
Modified: branches/release/libs/thread/build/Jamfile.v2
==============================================================================
--- branches/release/libs/thread/build/Jamfile.v2 (original)
+++ branches/release/libs/thread/build/Jamfile.v2 2012-12-16 14:01:45 EST (Sun, 16 Dec 2012)
@@ -48,7 +48,7 @@
<tag>@$(__name__).tag
<toolset>gcc:<cxxflags>-Wno-long-long
<define>BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED
- <define>BOOST_SYSTEM_NO_DEPRECATED
+ #<define>BOOST_SYSTEM_NO_DEPRECATED
#<define>BOOST_THREAD_DONT_PROVIDE_INTERRUPTIONS
<library>/boost/system//boost_system
@@ -114,7 +114,7 @@
<link>static:<define>BOOST_THREAD_BUILD_LIB=1
<link>shared:<define>BOOST_THREAD_BUILD_DLL=1
<define>BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED
- <define>BOOST_SYSTEM_NO_DEPRECATED
+ #<define>BOOST_SYSTEM_NO_DEPRECATED
<library>/boost/system//boost_system
;
Modified: branches/release/libs/thread/example/future_then.cpp
==============================================================================
--- branches/release/libs/thread/example/future_then.cpp (original)
+++ branches/release/libs/thread/example/future_then.cpp 2012-12-16 14:01:45 EST (Sun, 16 Dec 2012)
@@ -4,8 +4,9 @@
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//#define BOOST_THREAD_VERSION 4
-#define BOOST_THREAD_USES_LOG
-#define BOOST_THREAD_DONT_PROVIDE_FUTURE_INVALID_AFTER_GET
+//#define BOOST_THREAD_USES_LOG
+#define BOOST_THREAD_USES_LOG_THREAD_ID
+//#define BOOST_THREAD_DONT_PROVIDE_FUTURE_INVALID_AFTER_GET
#include <boost/thread/detail/log.hpp>
#include <boost/thread/future.hpp>
Modified: branches/release/libs/thread/example/synchronized_person.cpp
==============================================================================
--- branches/release/libs/thread/example/synchronized_person.cpp (original)
+++ branches/release/libs/thread/example/synchronized_person.cpp 2012-12-16 14:01:45 EST (Sun, 16 Dec 2012)
@@ -158,7 +158,7 @@
#if ! defined BOOST_NO_CXX11_AUTO_DECLARATIONS
auto memberSync = member.synchronize();
#else
- boost::synchronized_value<Member>::const_strict_synchronizer memberSync = member.synchronize();
+ boost::const_strict_lock_ptr<Member> memberSync = member.synchronize();
#endif
Invariant(memberSync);
return memberSync->name;
@@ -167,7 +167,7 @@
#if ! defined BOOST_NO_CXX11_AUTO_DECLARATIONS
auto memberSync = member.synchronize();
#else
- boost::synchronized_value<Member>::strict_synchronizer memberSync = member.synchronize();
+ boost::strict_lock_ptr<Member> memberSync = member.synchronize();
#endif
Invariant(memberSync);
memberSync->name = newName;
@@ -180,7 +180,7 @@
std::string name;
unsigned int age;
};
- void Invariant(boost::synchronized_value<Member>::const_strict_synchronizer & mbr) const
+ void Invariant(boost::const_strict_lock_ptr<Member> & mbr) const
{
if (mbr->age < 1) throw std::runtime_error("Age cannot be negative");
}
@@ -236,5 +236,24 @@
Person3_ts p(1);
p->SetName("Vicente");
}
+ {
+ Person3_ts p1(1);
+ Person3_ts p2(2);
+ Person3_ts p3(3);
+#if ! defined BOOST_NO_CXX11_AUTO_DECLARATIONS
+ auto lk1 = p1.unique_synchronize(boost::defer_lock);
+ auto lk2 = p2.unique_synchronize(boost::defer_lock);
+ auto lk3 = p3.unique_synchronize(boost::defer_lock);
+#else
+ boost::unique_lock_ptr<Person3> lk1 = p1.unique_synchronize(boost::defer_lock);
+ boost::unique_lock_ptr<Person3> lk2 = p2.unique_synchronize(boost::defer_lock);
+ boost::unique_lock_ptr<Person3> lk3 = p3.unique_synchronize(boost::defer_lock);
+#endif
+ boost::lock(lk1,lk2,lk3);
+
+ lk1->SetName("Carmen");
+ lk2->SetName("Javier");
+ lk3->SetName("Matias");
+ }
return 0;
}
Modified: branches/release/libs/thread/example/synchronized_value.cpp
==============================================================================
--- branches/release/libs/thread/example/synchronized_value.cpp (original)
+++ branches/release/libs/thread/example/synchronized_value.cpp 2012-12-16 14:01:45 EST (Sun, 16 Dec 2012)
@@ -12,7 +12,7 @@
void addTrailingSlashIfMissing(boost::synchronized_value<std::string> & path)
{
- boost::synchronized_value<std::string>::strict_synchronizer u=path.synchronize();
+ boost::strict_lock_ptr<std::string> u=path.synchronize();
if(u->empty() || (*u->rbegin()!='/'))
{
@@ -24,13 +24,13 @@
std::cout<<"v="<<*v<<std::endl;
}
-void g(const boost::synchronized_value<int>::const_strict_synchronizer &v) {
+void g(const boost::const_strict_lock_ptr<int> &v) {
std::cout<<"v="<<*v<<std::endl;
}
bool checkIfMissingTrailingSlash(boost::synchronized_value<std::string> & path)
{
- boost::synchronized_value<std::string>::strict_synchronizer u=path.synchronize();
+ boost::strict_lock_ptr<std::string> u=path.synchronize();
return (u->empty() || (*u->rbegin()!='/'));
}
@@ -46,7 +46,7 @@
std::cout<<"i="<<i<<std::endl;
{
- boost::synchronized_value<int>::strict_synchronizer u=v1.synchronize();
+ boost::strict_lock_ptr<int> u=v1.synchronize();
*u+=43;
std::cout<<"v1="<<*u<<std::endl;
Modified: branches/release/libs/thread/src/future.cpp
==============================================================================
--- branches/release/libs/thread/src/future.cpp (original)
+++ branches/release/libs/thread/src/future.cpp 2012-12-16 14:01:45 EST (Sun, 16 Dec 2012)
@@ -7,7 +7,7 @@
#ifndef BOOST_NO_EXCEPTIONS
-#include <boost/thread/future.hpp>
+#include <boost/thread/future_error_code.hpp>
namespace boost
{
@@ -19,12 +19,12 @@
public boost::system::error_category
{
public:
- virtual const char* name() const; //BOOST_NOEXCEPT;
+ virtual const char* name() const BOOST_NOEXCEPT;
virtual std::string message(int ev) const;
};
const char*
- future_error_category::name() const //BOOST_NOEXCEPT
+ future_error_category::name() const BOOST_NOEXCEPT
{
return "future";
}
Modified: branches/release/libs/thread/src/pthread/thread.cpp
==============================================================================
--- branches/release/libs/thread/src/pthread/thread.cpp (original)
+++ branches/release/libs/thread/src/pthread/thread.cpp 2012-12-16 14:01:45 EST (Sun, 16 Dec 2012)
@@ -395,7 +395,7 @@
bool thread::joinable() const BOOST_NOEXCEPT
{
- return (get_thread_info)()!=0;
+ return (get_thread_info)()?true:false;
}
Modified: branches/release/libs/thread/src/win32/thread.cpp
==============================================================================
--- branches/release/libs/thread/src/win32/thread.cpp (original)
+++ branches/release/libs/thread/src/win32/thread.cpp 2012-12-16 14:01:45 EST (Sun, 16 Dec 2012)
@@ -330,7 +330,7 @@
bool thread::joinable() const BOOST_NOEXCEPT
{
- return (get_thread_info)() != 0;
+ return (get_thread_info)() ? true : false;
}
bool thread::join_noexcept()
{
Modified: branches/release/libs/thread/test/Jamfile.v2
==============================================================================
--- branches/release/libs/thread/test/Jamfile.v2 (original)
+++ branches/release/libs/thread/test/Jamfile.v2 2012-12-16 14:01:45 EST (Sun, 16 Dec 2012)
@@ -228,7 +228,7 @@
[ thread-run test_5542_2.cpp ]
[ thread-run test_5542_3.cpp ]
[ thread-run test_5891.cpp ]
- [ thread-run test_6130.cpp ]
+ #[ thread-run test_6130.cpp ]
#[ thread-run test_6170.cpp ]
[ thread-run test_6174.cpp ]
#[ thread-run test_7160.cpp ]
@@ -480,7 +480,7 @@
[ thread-run2-noit ./sync/mutual_exclusion/locks/strict_lock/default_pass.cpp : strict_lock__cons__default_p ]
[ thread-run2-noit ./sync/mutual_exclusion/locks/strict_lock/owns_lock_pass.cpp : strict_lock__owns_lock_p ]
[ thread-run2-noit ./sync/mutual_exclusion/locks/strict_lock/types_pass.cpp : strict_lock__types_p ]
- #[ thread-run2-noit ./sync/mutual_exclusion/locks/strict_lock/make_strict_lock_pass.cpp : make_strict_lock_p ]
+ [ thread-run2-noit ./sync/mutual_exclusion/locks/strict_lock/make_strict_lock_pass.cpp : make_strict_lock_p ]
;
#explicit ts_nested_strict_lock ;
@@ -491,7 +491,7 @@
[ thread-run2-noit ./sync/mutual_exclusion/locks/nested_strict_lock/default_pass.cpp : nested_strict_lock__cons__default_p ]
[ thread-run2-noit ./sync/mutual_exclusion/locks/nested_strict_lock/owns_lock_pass.cpp : nested_strict_lock__owns_lock_p ]
[ thread-run2-noit ./sync/mutual_exclusion/locks/nested_strict_lock/types_pass.cpp : nested_strict_lock__types_p ]
- #[ thread-run2-noit ./sync/mutual_exclusion/locks/nested_strict_lock/make_nested_strict_lock_pass.cpp : make_nested_strict_lock_p ]
+ [ thread-run2-noit ./sync/mutual_exclusion/locks/nested_strict_lock/make_nested_strict_lock_pass.cpp : make_nested_strict_lock_p ]
;
@@ -662,11 +662,11 @@
explicit ts_ ;
test-suite ts_
:
- [ thread-run2-noit ./sync/conditions/notify_all_at_thread_exit_pass.cpp : notify_all_at_thread_exit_p2 ]
- [ thread-run2-noit ./threads/thread/members/try_join_until_pass.cpp : thread__join_until_p2 ]
- [ thread-run2-noit ./threads/thread/members/try_join_for_pass.cpp : thread__join_for_p2 ]
- [ thread-run2-noit ./sync/futures/async/async_pass.cpp : async__async_p2 ]
+ #[ thread-run2-noit ./sync/futures/future/then_pass.cpp : future__then_p ]
+ #[ thread-run ../example/test_so.cpp ]
+ #[ thread-run ../example/test_so2.cpp ]
+ #[ compile virtual_noexcept.cpp ]
#[ thread-run test_7665.cpp ]
#[ thread-run test_7666.cpp ]
#[ thread-run ../example/unwrap.cpp ]
Modified: branches/release/libs/thread/test/sync/futures/future/get_pass.cpp
==============================================================================
--- branches/release/libs/thread/test/sync/futures/future/get_pass.cpp (original)
+++ branches/release/libs/thread/test/sync/futures/future/get_pass.cpp 2012-12-16 14:01:45 EST (Sun, 16 Dec 2012)
@@ -22,6 +22,9 @@
//#define BOOST_THREAD_VERSION 3
#define BOOST_THREAD_VERSION 4
+#define BOOST_THREAD_USES_LOG
+#define BOOST_THREAD_USES_LOG_THREAD_ID
+#include <boost/thread/detail/log.hpp>
#include <boost/thread/future.hpp>
#include <boost/thread/thread.hpp>
@@ -87,49 +90,65 @@
int main()
{
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
{
typedef int T;
+// {
+// boost::promise<T> p;
+// boost::future<T> f = p.get_future();
+//#if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
+// boost::thread(func1, boost::move(p)).detach();
+//#else
+// p.set_value(3);
+//#endif
+// BOOST_TEST(f.valid());
+// BOOST_TEST(f.get() == 3);
+//#ifdef BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET
+// BOOST_TEST(!f.valid());
+//#endif
+// }
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
{
boost::promise<T> p;
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
boost::future<T> f = p.get_future();
-#if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
- boost::thread(func1, boost::move(p)).detach();
-#else
- p.set_value(3);
-#endif
- BOOST_TEST(f.valid());
- BOOST_TEST(f.get() == 3);
-#ifdef BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET
- BOOST_TEST(!f.valid());
-#endif
- }
- {
- boost::promise<T> p;
- boost::future<T> f = p.get_future();
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
#if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
boost::thread(func2, boost::move(p)).detach();
#else
p.set_exception(boost::make_exception_ptr(3));
#endif
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
try
{
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
BOOST_TEST(f.valid());
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
BOOST_TEST(f.get() == 3);
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
BOOST_TEST(false);
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
}
catch (boost::wrap<int> const& i)
{
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
BOOST_TEST(i.value == 3);
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
}
catch (...)
{
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
BOOST_TEST(false);
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
}
#ifdef BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
BOOST_TEST(!f.valid());
#endif
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
}
}
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
{
typedef int& T;
{
@@ -147,6 +166,7 @@
BOOST_TEST(!f.valid());
#endif
}
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
{
boost::promise<T> p;
boost::future<T> f = p.get_future();
@@ -170,6 +190,7 @@
#endif
}
}
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
typedef void T;
{
@@ -186,6 +207,7 @@
BOOST_TEST(!f.valid());
#endif
}
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
{
boost::promise<T> p;
boost::future<T> f = p.get_future();
@@ -212,6 +234,7 @@
BOOST_TEST(!f.valid());
#endif
}
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
return boost::report_errors();
}
Modified: branches/release/libs/thread/test/sync/futures/future/then_pass.cpp
==============================================================================
--- branches/release/libs/thread/test/sync/futures/future/then_pass.cpp (original)
+++ branches/release/libs/thread/test/sync/futures/future/then_pass.cpp 2012-12-16 14:01:45 EST (Sun, 16 Dec 2012)
@@ -8,10 +8,13 @@
// class future<R>
// template<typename F>
-// auto then(F&& func) -> BOOST_THREAD_FUTURE<decltype(func(*this))>;
+// auto then(F&& func) -> future<decltype(func(*this))>;
#define BOOST_THREAD_VERSION 4
#define BOOST_THREAD_DONT_PROVIDE_FUTURE_INVALID_AFTER_GET
+//#define BOOST_THREAD_USES_LOG
+#define BOOST_THREAD_USES_LOG_THREAD_ID
+#include <boost/thread/detail/log.hpp>
#include <boost/thread/future.hpp>
#include <boost/detail/lightweight_test.hpp>
@@ -30,23 +33,37 @@
int main()
{
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
{
boost::future<int> f1 = boost::async(p1);
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
boost::future<int> f2 = f1.then(p2);
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
BOOST_TEST(f2.get()==2);
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
}
{
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
boost::future<int> f2 = boost::async(p1).then(p2);
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
BOOST_TEST(f2.get()==2);
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
}
{
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
boost::future<int> f1 = boost::async(p1);
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
boost::future<int> f2 = f1.then(p2).then(p2);
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
BOOST_TEST(f2.get()==4);
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
}
{
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
boost::future<int> f2 = boost::async(p1).then(p2).then(p2);
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
BOOST_TEST(f2.get()==4);
+ BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
}
return boost::report_errors();
Modified: branches/release/libs/thread/test/sync/futures/packaged_task/make_ready_at_thread_exit_pass.cpp
==============================================================================
--- branches/release/libs/thread/test/sync/futures/packaged_task/make_ready_at_thread_exit_pass.cpp (original)
+++ branches/release/libs/thread/test/sync/futures/packaged_task/make_ready_at_thread_exit_pass.cpp 2012-12-16 14:01:45 EST (Sun, 16 Dec 2012)
@@ -99,7 +99,14 @@
{
boost::packaged_task<double(int, char)> p(A(5));
boost::future<double> f = p.get_future();
- // BUG boost::thread(func0, boost::move(p)).detach();
+ // fixme BUG boost::thread(func0, boost::move(p)).detach();
+ boost::thread(func0, &p).detach();
+ BOOST_TEST(f.get() == 105.0);
+ }
+ {
+ boost::packaged_task<double(int, char)> p2(A(5));
+ boost::future<double> f = p2.get_future();
+ boost::packaged_task<double(int, char)> p = boost::move(p2);
boost::thread(func0, &p).detach();
BOOST_TEST(f.get() == 105.0);
}
@@ -119,6 +126,21 @@
}
}
{
+ boost::packaged_task<double(int, char)> p2(A(5));
+ boost::future<double> f = p2.get_future();
+ boost::packaged_task<double(int, char)> p = boost::move(p2);
+ boost::thread(func1, &p).detach();
+ try
+ {
+ f.get();
+ BOOST_TEST(false);
+ }
+ catch (const E& e)
+ {
+ BOOST_TEST(e.data == 6);
+ }
+ }
+ {
boost::packaged_task<double(int, char)> p(A(5));
boost::future<double> f = p.get_future();
//boost::thread(func2, boost::move(p)).detach();
@@ -126,11 +148,24 @@
BOOST_TEST(f.get() == 105.0);
}
{
- boost::packaged_task<double(int, char)> p;
+ boost::packaged_task<double(int, char)> p2(A(5));
+ boost::future<double> f = p2.get_future();
+ boost::packaged_task<double(int, char)> p = boost::move(p2);
+ boost::thread(func2, &p).detach();
+ BOOST_TEST(f.get() == 105.0);
+ }
+ {
+ boost::packaged_task<double(int, char)> p(A(5));
//boost::thread t(func3, boost::move(p));
boost::thread t(func3, &p);
t.join();
}
+ {
+ boost::packaged_task<double(int, char)> p2(A(5));
+ boost::packaged_task<double(int, char)> p = boost::move(p2);
+ boost::thread t(func3, &p);
+ t.join();
+ }
return boost::report_errors();
}
Modified: branches/release/libs/thread/test/sync/futures/promise/set_exception_at_thread_exit_pass.cpp
==============================================================================
--- branches/release/libs/thread/test/sync/futures/promise/set_exception_at_thread_exit_pass.cpp (original)
+++ branches/release/libs/thread/test/sync/futures/promise/set_exception_at_thread_exit_pass.cpp 2012-12-16 14:01:45 EST (Sun, 16 Dec 2012)
@@ -73,6 +73,27 @@
BOOST_TEST(false);
}
}
+ {
+ typedef int T;
+ boost::promise<T> p2;
+ boost::future<T> f = p2.get_future();
+ //boost::thread(func, boost::move(p)).detach();
+ p = boost::move(p2);
+ boost::thread(func).detach();
+ try
+ {
+ f.get();
+ BOOST_TEST(false);
+ }
+ catch (boost::wrap<int> i)
+ {
+ BOOST_TEST(i.value == 3);
+ }
+ catch (...)
+ {
+ BOOST_TEST(false);
+ }
+ }
return boost::report_errors();
}
Modified: branches/release/libs/thread/test/sync/futures/promise/set_value_at_thread_exit_const_pass.cpp
==============================================================================
--- branches/release/libs/thread/test/sync/futures/promise/set_value_at_thread_exit_const_pass.cpp (original)
+++ branches/release/libs/thread/test/sync/futures/promise/set_value_at_thread_exit_const_pass.cpp 2012-12-16 14:01:45 EST (Sun, 16 Dec 2012)
@@ -40,6 +40,13 @@
boost::thread(func).detach();
BOOST_TEST(f.get() == 5);
}
+ {
+ boost::promise<int> p2;
+ boost::future<int> f = p2.get_future();
+ p = boost::move(p2);
+ boost::thread(func).detach();
+ BOOST_TEST(f.get() == 5);
+ }
return boost::report_errors();
}
Modified: branches/release/libs/thread/test/sync/futures/promise/set_value_at_thread_exit_void_pass.cpp
==============================================================================
--- branches/release/libs/thread/test/sync/futures/promise/set_value_at_thread_exit_void_pass.cpp (original)
+++ branches/release/libs/thread/test/sync/futures/promise/set_value_at_thread_exit_void_pass.cpp 2012-12-16 14:01:45 EST (Sun, 16 Dec 2012)
@@ -19,8 +19,11 @@
// void promise<void>::set_value_at_thread_exit();
#define BOOST_THREAD_VERSION 4
+#define BOOST_THREAD_USES_LOG
+#define BOOST_THREAD_USES_LOG_THREAD_ID
#include <boost/thread/future.hpp>
+#include <boost/thread/detail/log.hpp>
#include <boost/detail/lightweight_test.hpp>
int i = 0;
@@ -35,7 +38,7 @@
void func2(boost::promise<void> p2)
{
p2.set_value_at_thread_exit();
- i = 1;
+ i = 2;
}
int main()
@@ -57,20 +60,39 @@
BOOST_TEST(false);
}
+ try
+ {
+ boost::promise<void> p2;
+ boost::future<void> f = p2.get_future();
+ p = boost::move(p2);
+ boost::thread(func).detach();
+ f.get();
+ BOOST_TEST(i == 1);
+
+ }
+ catch(std::exception ex)
+ {
+ std::cout << __FILE__ << ":" << __LINE__ << " " << ex.what() << std::endl;
+ BOOST_TEST(false);
+ }
+ catch(...)
+ {
+ BOOST_TEST(false);
+ }
// BUG when moving promise. fixme
// try
// {
-// std::cout << __FILE__ << ":" << __LINE__ <<std::endl;
+// BOOST_THREAD_LOG << BOOST_THREAD_END_LOG
// boost::promise<void> p2; // BUG
-// std::cout << __FILE__ << ":" << __LINE__ <<std::endl;
+// BOOST_THREAD_LOG << BOOST_THREAD_END_LOG
// boost::future<void> f = p2.get_future();
-// std::cout << __FILE__ << ":" << __LINE__ <<std::endl;
+// BOOST_THREAD_LOG << BOOST_THREAD_END_LOG
// boost::thread(func2, boost::move(p2)).detach(); // BUG
-// std::cout << __FILE__ << ":" << __LINE__ <<std::endl;
+// BOOST_THREAD_LOG << BOOST_THREAD_END_LOG
// f.get();
-// std::cout << __FILE__ << ":" << __LINE__ <<std::endl;
-// BOOST_TEST(i == 1);
-// std::cout << __FILE__ << ":" << __LINE__ <<std::endl;
+// BOOST_THREAD_LOG << BOOST_THREAD_END_LOG
+// BOOST_TEST(i == 2);
+// BOOST_THREAD_LOG << BOOST_THREAD_END_LOG
//
// }
// catch(std::exception ex)
Modified: branches/release/libs/thread/test/sync/mutual_exclusion/locks/nested_strict_lock/copy_ctor_fail.cpp
==============================================================================
--- branches/release/libs/thread/test/sync/mutual_exclusion/locks/nested_strict_lock/copy_ctor_fail.cpp (original)
+++ branches/release/libs/thread/test/sync/mutual_exclusion/locks/nested_strict_lock/copy_ctor_fail.cpp 2012-12-16 14:01:45 EST (Sun, 16 Dec 2012)
@@ -20,8 +20,8 @@
int main()
{
- boost::nested_strict_lock<boost::mutex> lk0(m0);
- boost::nested_strict_lock<boost::mutex> lk1 = lk0;
+ boost::nested_strict_lock<boost::unique_lock<boost::mutex> > lk0(m0);
+ boost::nested_strict_lock<boost::unique_lock<boost::mutex> > lk1 = lk0;
}
#include "../../../../remove_error_code_unused_warning.hpp"
Modified: branches/release/libs/thread/test/sync/mutual_exclusion/locks/nested_strict_lock/make_nested_strict_lock_pass.cpp
==============================================================================
--- branches/release/libs/thread/test/sync/mutual_exclusion/locks/nested_strict_lock/make_nested_strict_lock_pass.cpp (original)
+++ branches/release/libs/thread/test/sync/mutual_exclusion/locks/nested_strict_lock/make_nested_strict_lock_pass.cpp 2012-12-16 14:01:45 EST (Sun, 16 Dec 2012)
@@ -30,7 +30,7 @@
boost::mutex m;
-#if ! defined(BOOST_NO_CXX11_AUTO) && ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ! defined BOOST_NO_CXX11_HDR_INITIALIZER_LIST && BOOST_THREAD_USES_CHRONO
+#if ! defined(BOOST_NO_CXX11_AUTO) && ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ! defined BOOST_NO_CXX11_HDR_INITIALIZER_LIST && defined BOOST_THREAD_USES_CHRONO
void f()
{
@@ -38,7 +38,7 @@
time_point t1;
boost::unique_lock<boost::mutex> lg(m);
{
- const auto&& nlg = boost::make_strict_lock(lg); (void)nlg;
+ const auto&& nlg = boost::make_nested_strict_lock(lg); (void)nlg;
t1 = Clock::now();
BOOST_THREAD_TRACE;
}
Modified: branches/release/libs/thread/test/sync/mutual_exclusion/locks/strict_lock/make_strict_lock_pass.cpp
==============================================================================
--- branches/release/libs/thread/test/sync/mutual_exclusion/locks/strict_lock/make_strict_lock_pass.cpp (original)
+++ branches/release/libs/thread/test/sync/mutual_exclusion/locks/strict_lock/make_strict_lock_pass.cpp 2012-12-16 14:01:45 EST (Sun, 16 Dec 2012)
@@ -29,7 +29,7 @@
boost::mutex m;
-#if ! defined(BOOST_NO_CXX11_AUTO) && ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ! defined BOOST_NO_CXX11_HDR_INITIALIZER_LIST && BOOST_THREAD_USES_CHRONO
+#if ! defined(BOOST_NO_CXX11_AUTO) && ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ! defined BOOST_NO_CXX11_HDR_INITIALIZER_LIST && defined BOOST_THREAD_USES_CHRONO
void f()
{
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