|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r62134 - in sandbox/chrono/boost/thread: . detail pthread win32
From: vicente.botet_at_[hidden]
Date: 2010-05-21 20:35:47
Author: viboes
Date: 2010-05-21 20:35:45 EDT (Fri, 21 May 2010)
New Revision: 62134
URL: http://svn.boost.org/trac/boost/changeset/62134
Log:
Boost.Chrono 0.5:
* Add Boost.Thread using Boost.Chrono
Text files modified:
sandbox/chrono/boost/thread/condition_variable.hpp | 1
sandbox/chrono/boost/thread/detail/thread.hpp | 93 ++++++++++-------
sandbox/chrono/boost/thread/future.hpp | 208 ++++++++++++++++++++++++++-------------
sandbox/chrono/boost/thread/locks.hpp | 143 ++++++++++++++++++---------
sandbox/chrono/boost/thread/pthread/condition_variable.hpp | 45 +++++++-
sandbox/chrono/boost/thread/pthread/condition_variable_fwd.hpp | 36 ++++++
sandbox/chrono/boost/thread/pthread/mutex.hpp | 12 ++
sandbox/chrono/boost/thread/pthread/recursive_mutex.hpp | 32 ++++-
sandbox/chrono/boost/thread/pthread/shared_mutex.hpp | 60 +++++++++--
sandbox/chrono/boost/thread/win32/basic_recursive_mutex.hpp | 23 +++
sandbox/chrono/boost/thread/win32/basic_timed_mutex.hpp | 31 ++++-
sandbox/chrono/boost/thread/win32/condition_variable.hpp | 110 ++++++++++++++++----
sandbox/chrono/boost/thread/win32/shared_mutex.hpp | 62 ++++++++---
13 files changed, 611 insertions(+), 245 deletions(-)
Modified: sandbox/chrono/boost/thread/condition_variable.hpp
==============================================================================
--- sandbox/chrono/boost/thread/condition_variable.hpp (original)
+++ sandbox/chrono/boost/thread/condition_variable.hpp 2010-05-21 20:35:45 EDT (Fri, 21 May 2010)
@@ -10,6 +10,7 @@
// http://www.boost.org/LICENSE_1_0.txt)
#include <boost/thread/detail/platform.hpp>
+#include <boost/thread/detail/cv_status.hpp>
#if defined(BOOST_THREAD_PLATFORM_WIN32)
#include <boost/thread/win32/condition_variable.hpp>
#elif defined(BOOST_THREAD_PLATFORM_PTHREAD)
Modified: sandbox/chrono/boost/thread/detail/thread.hpp
==============================================================================
--- sandbox/chrono/boost/thread/detail/thread.hpp (original)
+++ sandbox/chrono/boost/thread/detail/thread.hpp 2010-05-21 20:35:45 EDT (Fri, 21 May 2010)
@@ -4,7 +4,7 @@
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
// (C) Copyright 2007-8 Anthony Williams
-
+
#include <boost/thread/exceptions.hpp>
#include <ostream>
#include <boost/thread/detail/move.hpp>
@@ -22,6 +22,11 @@
#include <memory>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/remove_reference.hpp>
+#include <boost/chrono.hpp>
+#include <boost/conversion/boost/chrono_duration_to_posix_time_duration.hpp>
+#include <boost/conversion/boost/chrono_time_point_to_posix_time_ptime.hpp>
+
+
#include <boost/config/abi_prefix.hpp>
@@ -53,7 +58,7 @@
thread_data(detail::thread_move_t<F> f_):
f(f_)
{}
-#endif
+#endif
void run()
{
f();
@@ -78,7 +83,7 @@
thread_data(boost::reference_wrapper<F> f_):
f(f_)
{}
-
+
void run()
{
f();
@@ -97,14 +102,14 @@
thread_data(const boost::reference_wrapper<F> f_):
f(f_)
{}
-
+
void run()
{
f();
}
};
}
-
+
class BOOST_THREAD_DECL thread
{
private:
@@ -112,12 +117,12 @@
thread& operator=(thread&);
void release_handle();
-
+
mutable boost::mutex thread_info_mutex;
detail::thread_data_ptr thread_info;
void start_thread();
-
+
explicit thread(detail::thread_data_ptr data);
detail::thread_data_ptr get_thread_info() const;
@@ -147,9 +152,9 @@
#endif
struct dummy;
public:
-#ifdef __SUNPRO_CC
- thread(const volatile thread&);
-#endif
+#ifdef __SUNPRO_CC
+ thread(const volatile thread&);
+#endif
thread();
~thread();
@@ -174,7 +179,7 @@
{
thread_info.swap(other.thread_info);
}
-
+
thread& operator=(thread&& other)
{
thread_info=other.thread_info;
@@ -186,7 +191,7 @@
{
return static_cast<thread&&>(*this);
}
-
+
#else
#ifdef BOOST_NO_SFINAE
template <class F>
@@ -203,7 +208,7 @@
start_thread();
}
#endif
-
+
template <class F>
explicit thread(detail::thread_move_t<F> f):
thread_info(make_thread_info(f))
@@ -216,13 +221,13 @@
thread_info=x->thread_info;
x->thread_info.reset();
}
-
-#ifdef __SUNPRO_CC
- thread& operator=(thread x)
- {
- swap(x);
- return *this;
- }
+
+#ifdef __SUNPRO_CC
+ thread& operator=(thread x)
+ {
+ swap(x);
+ return *this;
+ }
#else
thread& operator=(detail::thread_move_t<thread> x)
{
@@ -230,12 +235,12 @@
swap(new_thread);
return *this;
}
-#endif
+#endif
operator detail::thread_move_t<thread>()
{
return move();
}
-
+
detail::thread_move_t<thread> move()
{
detail::thread_move_t<thread> x(*this);
@@ -339,12 +344,13 @@
{
this_thread::yield();
}
-
+
static inline void sleep(const system_time& xt)
{
this_thread::sleep(xt);
}
+
// extensions
void interrupt();
bool interruption_requested() const;
@@ -354,7 +360,7 @@
{
return lhs.swap(rhs);
}
-
+
#ifndef BOOST_NO_RVALUE_REFERENCES
inline thread&& move(thread& t)
{
@@ -383,13 +389,22 @@
{
sleep(system_time(abs_time));
}
+ template <class Clock, class Duration>
+ void sleep_until(const chrono::time_point<Clock, Duration>& abs_time) {
+ sleep(convert_to<system_time>(abs_time));
+ }
+ template <class Rep, class Period>
+ void sleep_for(const chrono::duration<Rep, Period>& rel_time) {
+ sleep(convert_to<posix_time::time_duration>(rel_time));
+ }
+
}
class thread::id
{
private:
detail::thread_data_ptr thread_data;
-
+
id(detail::thread_data_ptr thread_data_):
thread_data(thread_data_)
{}
@@ -399,39 +414,39 @@
id():
thread_data()
{}
-
+
bool operator==(const id& y) const
{
return thread_data==y.thread_data;
}
-
+
bool operator!=(const id& y) const
{
return thread_data!=y.thread_data;
}
-
+
bool operator<(const id& y) const
{
return thread_data<y.thread_data;
}
-
+
bool operator>(const id& y) const
{
return y.thread_data<thread_data;
}
-
+
bool operator<=(const id& y) const
{
return !(y.thread_data<thread_data);
}
-
+
bool operator>=(const id& y) const
{
return !(thread_data<y.thread_data);
}
template<class charT, class traits>
- friend std::basic_ostream<charT, traits>&
+ friend std::basic_ostream<charT, traits>&
operator<<(std::basic_ostream<charT, traits>& os, const id& x)
{
if(x.thread_data)
@@ -449,12 +464,12 @@
{
return get_id()==other.get_id();
}
-
+
inline bool thread::operator!=(const thread& other) const
{
return get_id()!=other.get_id();
}
-
+
namespace detail
{
struct thread_exit_function_base
@@ -463,26 +478,26 @@
{}
virtual void operator()()=0;
};
-
+
template<typename F>
struct thread_exit_function:
thread_exit_function_base
{
F f;
-
+
thread_exit_function(F f_):
f(f_)
{}
-
+
void operator()()
{
f();
}
};
-
+
void BOOST_THREAD_DECL add_thread_exit_function(thread_exit_function_base*);
}
-
+
namespace this_thread
{
template<typename F>
Modified: sandbox/chrono/boost/thread/future.hpp
==============================================================================
--- sandbox/chrono/boost/thread/future.hpp (original)
+++ sandbox/chrono/boost/thread/future.hpp 2010-05-21 20:35:45 EDT (Fri, 21 May 2010)
@@ -1,4 +1,4 @@
-// (C) Copyright 2008-10 Anthony Williams
+// (C) Copyright 2008-10 Anthony Williams
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
@@ -27,8 +27,36 @@
#include <boost/next_prior.hpp>
#include <vector>
+#include <boost/chrono.hpp>
+#include <boost/conversion/boost/chrono_duration_to_posix_time_duration.hpp>
+#include <boost/conversion/boost/chrono_time_point_to_posix_time_ptime.hpp>
+
+#ifndef BOOST_ENUM_CLASS
+#if defined(BOOST_NO_SCOPED_ENUMS)
+#define BOOST_ENUM_CLASS(T) T::type
+#else
+#define BOOST_ENUM_CLASS(T) T
+#endif
+#endif
+
namespace boost
{
+#if defined(BOOST_NO_SCOPED_ENUMS)
+ namespace future_status {
+ enum type {
+ ready,
+ timeout,
+ deferred
+ };
+ }
+#else
+ enum class future_status {
+ ready,
+ timeout,
+ deferred
+ };
+#endif
+
class future_uninitialized:
public std::logic_error
{
@@ -109,7 +137,7 @@
do_callback(lock);
return external_waiters.insert(external_waiters.end(),&cv);
}
-
+
void remove_external_waiter(waiter_list::iterator it)
{
boost::lock_guard<boost::mutex> lock(mutex);
@@ -130,7 +158,7 @@
struct relocker
{
boost::unique_lock<boost::mutex>& lock;
-
+
relocker(boost::unique_lock<boost::mutex>& lock_):
lock(lock_)
{
@@ -151,7 +179,7 @@
local_callback();
}
}
-
+
void wait(bool rethrow=true)
{
@@ -181,7 +209,21 @@
}
return true;
}
-
+
+ template <class Rep, class Period>
+ BOOST_ENUM_CLASS(future_status) wait_for(const chrono::duration<Rep, Period>& rel_time) {
+ return (timed_wait_until(convert_to<posix_time::time_duration>(rel_time)))
+ ? future_status::timeout
+ : future_status::ready;
+ }
+
+ template <class Clock, class Duration>
+ BOOST_ENUM_CLASS(future_status) wait_until(const chrono::time_point<Clock, Duration>& abs_time) {
+ return (timed_wait_until(convert_to<system_time>(abs_time)))
+ ? future_status::timeout
+ : future_status::ready;
+ }
+
void mark_exceptional_finish_internal(boost::exception_ptr const& e)
{
exception=e;
@@ -209,7 +251,7 @@
{
callback=boost::bind(f,boost::ref(*u));
}
-
+
private:
future_object_base(future_object_base const&);
future_object_base& operator=(future_object_base const&);
@@ -234,7 +276,7 @@
{
storage.reset(new T(t));
}
-
+
static void init(storage_type& storage,rvalue_source_type t)
{
storage.reset(new T(static_cast<rvalue_source_type>(t)));
@@ -245,7 +287,7 @@
storage.reset();
}
};
-
+
template<typename T>
struct future_traits<T&>
{
@@ -292,7 +334,7 @@
typedef typename future_traits<T>::source_reference_type source_reference_type;
typedef typename future_traits<T>::rvalue_source_type rvalue_source_type;
typedef typename future_traits<T>::move_dest_type move_dest_type;
-
+
storage_type result;
future_object():
@@ -367,7 +409,7 @@
{
wait();
}
-
+
future_state::state get_state()
{
boost::lock_guard<boost::mutex> guard(mutex);
@@ -401,13 +443,13 @@
{}
};
-
+
struct all_futures_lock
{
typedef std::vector<registered_waiter>::size_type count_type;
count_type count;
boost::scoped_array<boost::unique_lock<boost::mutex> > locks;
-
+
all_futures_lock(std::vector<registered_waiter>& futures):
count(futures.size()),locks(new boost::unique_lock<boost::mutex>[count])
{
@@ -416,12 +458,12 @@
locks[i]=boost::unique_lock<boost::mutex>(futures[i].future->mutex);
}
}
-
+
void lock()
{
boost::lock(locks.get(),locks.get()+count);
}
-
+
void unlock()
{
for(unsigned i=0;i<count;++i)
@@ -430,16 +472,16 @@
}
}
};
-
+
boost::condition_variable_any cv;
std::vector<registered_waiter> futures;
unsigned future_count;
-
+
public:
future_waiter():
future_count(0)
{}
-
+
template<typename F>
void add(F& f)
{
@@ -465,7 +507,7 @@
cv.wait(lk);
}
}
-
+
~future_waiter()
{
for(unsigned i=0;i<futures.size();++i)
@@ -473,9 +515,9 @@
futures[i].future->remove_external_waiter(futures[i].wait_iterator);
}
}
-
+
};
-
+
}
template <typename R>
@@ -489,13 +531,13 @@
{
BOOST_STATIC_CONSTANT(bool, value=false);
};
-
+
template<typename T>
struct is_future_type<unique_future<T> >
{
BOOST_STATIC_CONSTANT(bool, value=true);
};
-
+
template<typename T>
struct is_future_type<shared_future<T> >
{
@@ -525,7 +567,7 @@
f2.wait();
f3.wait();
}
-
+
template<typename F1,typename F2,typename F3,typename F4>
void wait_for_all(F1& f1,F2& f2,F3& f3,F4& f4)
{
@@ -574,7 +616,7 @@
waiter.add(f3);
return waiter.wait();
}
-
+
template<typename F1,typename F2,typename F3,typename F4>
unsigned wait_for_any(F1& f1,F2& f2,F3& f3,F4& f4)
{
@@ -597,7 +639,7 @@
waiter.add(f5);
return waiter.wait();
}
-
+
template <typename R>
class promise;
@@ -611,7 +653,7 @@
unique_future& operator=(unique_future& rhs);// = delete;
typedef boost::shared_ptr<detail::future_object<R> > future_ptr;
-
+
future_ptr future;
friend class shared_future<R>;
@@ -630,7 +672,7 @@
unique_future()
{}
-
+
~unique_future()
{}
@@ -680,7 +722,7 @@
return future->get();
}
-
+
// functions to check state, and wait for ready
state get_state() const
{
@@ -690,23 +732,23 @@
}
return future->get_state();
}
-
+
bool is_ready() const
{
return get_state()==future_state::ready;
}
-
+
bool has_exception() const
{
return future && future->has_exception();
}
-
+
bool has_value() const
{
return future && future->has_value();
}
-
+
void wait() const
{
if(!future)
@@ -715,13 +757,13 @@
}
future->wait(false);
}
-
+
template<typename Duration>
bool timed_wait(Duration const& rel_time) const
{
return timed_wait_until(boost::get_system_time()+rel_time);
}
-
+
bool timed_wait_until(boost::system_time const& abs_time) const
{
if(!future)
@@ -730,14 +772,27 @@
}
return future->timed_wait_until(abs_time);
}
-
+ template <class Rep, class Period>
+ BOOST_ENUM_CLASS(future_status) wait_for(const chrono::duration<Rep, Period>& rel_time) {
+ return (timed_wait(convert_to<posix_time::time_duration>(rel_time)))
+ ? future_status::timeout
+ : future_status::ready;
+ }
+
+ template <class Clock, class Duration>
+ BOOST_ENUM_CLASS(future_status) wait_until(const chrono::time_point<Clock, Duration>& abs_time) {
+ return (timed_wait_until(convert_to<system_time>(abs_time)))
+ ? future_status::timeout
+ : future_status::ready;
+ }
+
};
template <typename R>
class shared_future
{
typedef boost::shared_ptr<detail::future_object<R> > future_ptr;
-
+
future_ptr future;
// shared_future(const unique_future<R>& other);
@@ -746,7 +801,7 @@
friend class detail::future_waiter;
friend class promise<R>;
friend class packaged_task<R>;
-
+
shared_future(future_ptr future_):
future(future_)
{}
@@ -790,7 +845,7 @@
other.future.reset();
return *this;
}
-#else
+#else
shared_future(boost::detail::thread_move_t<shared_future> other):
future(other->future)
{
@@ -837,7 +892,7 @@
return future->get();
}
-
+
// functions to check state, and wait for ready
state get_state() const
{
@@ -847,18 +902,18 @@
}
return future->get_state();
}
-
+
bool is_ready() const
{
return get_state()==future_state::ready;
}
-
+
bool has_exception() const
{
return future && future->has_exception();
}
-
+
bool has_value() const
{
return future && future->has_value();
@@ -872,13 +927,13 @@
}
future->wait(false);
}
-
+
template<typename Duration>
bool timed_wait(Duration const& rel_time) const
{
return timed_wait_until(boost::get_system_time()+rel_time);
}
-
+
bool timed_wait_until(boost::system_time const& abs_time) const
{
if(!future)
@@ -887,17 +942,30 @@
}
return future->timed_wait_until(abs_time);
}
-
+ template <class Rep, class Period>
+ BOOST_ENUM_CLASS(future_status) wait_for(const chrono::duration<Rep, Period>& rel_time) {
+ return (timed_wait(convert_to<posix_time::time_duration>(rel_time)))
+ ? future_status::timeout
+ : future_status::ready;
+ }
+
+ template <class Clock, class Duration>
+ BOOST_ENUM_CLASS(future_status) wait_until(const chrono::time_point<Clock, Duration>& abs_time) {
+ return (timed_wait_until(convert_to<system_time>(abs_time)))
+ ? future_status::timeout
+ : future_status::ready;
+ }
+
};
template <typename R>
class promise
{
typedef boost::shared_ptr<detail::future_object<R> > future_ptr;
-
+
future_ptr future;
bool future_obtained;
-
+
promise(promise & rhs);// = delete;
promise & operator=(promise & rhs);// = delete;
@@ -909,14 +977,14 @@
future.reset(new detail::future_object<R>);
}
}
-
+
public:
// template <class Allocator> explicit promise(Allocator a);
promise():
future(),future_obtained(false)
{}
-
+
~promise()
{
if(future)
@@ -962,8 +1030,8 @@
{
return boost::detail::thread_move_t<promise>(*this);
}
-#endif
-
+#endif
+
void swap(promise& other)
{
future.swap(other.future);
@@ -1022,17 +1090,17 @@
lazy_init();
future->set_wait_callback(f,this);
}
-
+
};
template <>
class promise<void>
{
typedef boost::shared_ptr<detail::future_object<void> > future_ptr;
-
+
future_ptr future;
bool future_obtained;
-
+
promise(promise & rhs);// = delete;
promise & operator=(promise & rhs);// = delete;
@@ -1050,7 +1118,7 @@
promise():
future(),future_obtained(false)
{}
-
+
~promise()
{
if(future)
@@ -1097,7 +1165,7 @@
return boost::detail::thread_move_t<promise>(*this);
}
#endif
-
+
void swap(promise& other)
{
future.swap(other.future);
@@ -1108,7 +1176,7 @@
unique_future<void> get_future()
{
lazy_init();
-
+
if(future_obtained)
{
boost::throw_exception(future_already_retrieved());
@@ -1145,7 +1213,7 @@
lazy_init();
future->set_wait_callback(f,this);
}
-
+
};
namespace detail
@@ -1182,12 +1250,12 @@
this->mark_exceptional_finish_internal(boost::copy_exception(boost::broken_promise()));
}
}
-
-
+
+
virtual void do_run()=0;
};
-
-
+
+
template<typename R,typename F>
struct task_object:
task_base<R>
@@ -1199,7 +1267,7 @@
task_object(boost::detail::thread_move_t<F> f_):
f(f_)
{}
-
+
void do_run()
{
try
@@ -1224,7 +1292,7 @@
task_object(boost::detail::thread_move_t<F> f_):
f(f_)
{}
-
+
void do_run()
{
try
@@ -1240,7 +1308,7 @@
};
}
-
+
template<typename R>
class packaged_task
@@ -1250,12 +1318,12 @@
packaged_task(packaged_task&);// = delete;
packaged_task& operator=(packaged_task&);// = delete;
-
+
public:
packaged_task():
future_obtained(false)
{}
-
+
// construction and destruction
template <class F>
explicit packaged_task(F const& f):
@@ -1264,7 +1332,7 @@
explicit packaged_task(R(*f)()):
task(new detail::task_object<R,R(*)()>(f)),future_obtained(false)
{}
-
+
template <class F>
explicit packaged_task(boost::detail::thread_move_t<F> f):
task(new detail::task_object<R,F>(f)),future_obtained(false)
@@ -1340,7 +1408,7 @@
boost::throw_exception(future_already_retrieved());
}
}
-
+
// execution
void operator()()
@@ -1357,7 +1425,7 @@
{
task->set_wait_callback(f,this);
}
-
+
};
}
Modified: sandbox/chrono/boost/thread/locks.hpp
==============================================================================
--- sandbox/chrono/boost/thread/locks.hpp (original)
+++ sandbox/chrono/boost/thread/locks.hpp 2010-05-21 20:35:45 EDT (Fri, 21 May 2010)
@@ -12,10 +12,15 @@
#include <boost/thread/thread_time.hpp>
#include <boost/detail/workaround.hpp>
+#include <boost/chrono/chrono.hpp>
+#include <boost/conversion/boost/chrono_duration_to_posix_time_duration.hpp>
+#include <boost/conversion/boost/chrono_time_point_to_posix_time_ptime.hpp>
+
#include <boost/config/abi_prefix.hpp>
namespace boost
{
+
struct xtime;
#if defined(BOOST_NO_SFINAE) || \
@@ -35,11 +40,11 @@
{
true_type dummy[2];
};
-
+
template<typename U>
static true_type has_member(U*,void (U::*dummy)()=&U::lock);
static false_type has_member(void*);
-
+
BOOST_STATIC_CONSTANT(bool, value=sizeof(has_member_lock<T>::has_member((T*)NULL))==sizeof(true_type));
};
@@ -51,14 +56,14 @@
{
true_type dummy[2];
};
-
+
template<typename U>
static true_type has_member(U*,void (U::*dummy)()=&U::unlock);
static false_type has_member(void*);
-
+
BOOST_STATIC_CONSTANT(bool, value=sizeof(has_member_unlock<T>::has_member((T*)NULL))==sizeof(true_type));
};
-
+
template<typename T>
struct has_member_try_lock
{
@@ -67,16 +72,16 @@
{
true_type dummy[2];
};
-
+
template<typename U>
static true_type has_member(U*,bool (U::*dummy)()=&U::try_lock);
static false_type has_member(void*);
-
+
BOOST_STATIC_CONSTANT(bool, value=sizeof(has_member_try_lock<T>::has_member((T*)NULL))==sizeof(true_type));
};
}
-
+
template<typename T>
struct is_mutex_type
@@ -84,7 +89,7 @@
BOOST_STATIC_CONSTANT(bool, value = detail::has_member_lock<T>::value &&
detail::has_member_unlock<T>::value &&
detail::has_member_try_lock<T>::value);
-
+
};
#else
template<typename T>
@@ -92,7 +97,7 @@
{
BOOST_STATIC_CONSTANT(bool, value = false);
};
-#endif
+#endif
struct defer_lock_t
{};
@@ -100,7 +105,7 @@
{};
struct adopt_lock_t
{};
-
+
const defer_lock_t defer_lock={};
const try_to_lock_t try_to_lock={};
const adopt_lock_t adopt_lock={};
@@ -119,7 +124,7 @@
template<typename Mutex>
class try_lock_wrapper;
}
-
+
#ifdef BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES
template<typename T>
struct is_mutex_type<unique_lock<T> >
@@ -138,7 +143,7 @@
{
BOOST_STATIC_CONSTANT(bool, value = true);
};
-
+
template<typename T>
struct is_mutex_type<detail::try_lock_wrapper<T> >
{
@@ -150,7 +155,7 @@
class recursive_mutex;
class recursive_timed_mutex;
class shared_mutex;
-
+
template<>
struct is_mutex_type<mutex>
{
@@ -214,13 +219,13 @@
unique_lock& operator=(unique_lock&);
unique_lock& operator=(upgrade_lock<Mutex>& other);
public:
-#ifdef __SUNPRO_CC
- unique_lock(const volatile unique_lock&);
+#ifdef __SUNPRO_CC
+ unique_lock(const volatile unique_lock&);
#endif
unique_lock():
m(0),is_locked(false)
{}
-
+
explicit unique_lock(Mutex& m_):
m(&m_),is_locked(false)
{
@@ -248,6 +253,19 @@
{
timed_lock(target_time);
}
+ template <class Clock, class Duration>
+ unique_lock(Mutex& m_, chrono::time_point<Clock, Duration> const & abs_time) :
+ m(&m_),is_locked(false)
+ {
+ timed_lock(convert_to<system_time>(abs_time));
+ }
+ template <class Rep, class Period>
+ unique_lock(Mutex& m_, const chrono::duration<Rep, Period>& rel_time) :
+ m(&m_),is_locked(false)
+ {
+ timed_lock(convert_to<posix_time::time_duration>(rel_time));
+ }
+
#ifndef BOOST_NO_RVALUE_REFERENCES
unique_lock(unique_lock&& other):
m(other.m),is_locked(other.is_locked)
@@ -301,11 +319,11 @@
}
#ifdef __SUNPRO_CC
- unique_lock& operator=(unique_lock<Mutex> other)
- {
- swap(other);
- return *this;
- }
+ unique_lock& operator=(unique_lock<Mutex> other)
+ {
+ swap(other);
+ return *this;
+ }
#else
unique_lock& operator=(detail::thread_move_t<unique_lock<Mutex> > other)
{
@@ -332,7 +350,7 @@
std::swap(m,other.m);
std::swap(is_locked,other.is_locked);
}
-
+
~unique_lock()
{
if(owns_lock())
@@ -364,7 +382,7 @@
is_locked=m->timed_lock(relative_time);
return is_locked;
}
-
+
bool timed_lock(::boost::system_time const& absolute_time)
{
is_locked=m->timed_lock(absolute_time);
@@ -375,6 +393,14 @@
is_locked=m->timed_lock(absolute_time);
return is_locked;
}
+ template <class Rep, class Period>
+ bool try_lock_for(const chrono::duration<Rep, Period>& rel_time) {
+ return timed_lock(convert_to<posix_time::time_duration>(rel_time));
+ }
+ template <class Clock, class Duration>
+ bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time) {
+ return timed_lock(convert_to<system_time>(abs_time));
+ }
void unlock()
{
if(!owns_lock())
@@ -384,7 +410,7 @@
m->unlock();
is_locked=false;
}
-
+
typedef void (unique_lock::*bool_type)();
operator bool_type() const
{
@@ -456,7 +482,7 @@
shared_lock():
m(0),is_locked(false)
{}
-
+
explicit shared_lock(Mutex& m_):
m(&m_),is_locked(false)
{
@@ -478,6 +504,18 @@
{
timed_lock(target_time);
}
+ template <class Clock, class Duration>
+ shared_lock(Mutex& m_, const chrono::time_point<Clock, Duration>& abs_time) :
+ m(&m_),is_locked(false)
+ {
+ timed_lock(convert_to<system_time>(abs_time));
+ }
+ template <class Rep, class Period>
+ shared_lock(Mutex& m_, const chrono::duration<Rep, Period>& rel_time) :
+ m(&m_),is_locked(false)
+ {
+ timed_lock(get_system_time()+convert_to<posix_time::time_duration>(rel_time));
+ }
shared_lock(detail::thread_move_t<shared_lock<Mutex> > other):
m(other->m),is_locked(other->is_locked)
@@ -563,7 +601,7 @@
{
return m;
}
-
+
~shared_lock()
{
if(owns_lock())
@@ -608,6 +646,15 @@
is_locked=m->timed_lock_shared(target_time);
return is_locked;
}
+ template <class Rep, class Period>
+ bool try_lock_for(const chrono::duration<Rep, Period>& rel_time) {
+ return timed_lock(convert_to<posix_time::time_duration>(rel_time));
+ }
+ template <class Clock, class Duration>
+ bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time) {
+ return timed_lock(convert_to<system_time>(abs_time));
+ }
+
void unlock()
{
if(!owns_lock())
@@ -617,7 +664,7 @@
m->unlock_shared();
is_locked=false;
}
-
+
typedef void (shared_lock<Mutex>::*bool_type)();
operator bool_type() const
{
@@ -661,7 +708,7 @@
upgrade_lock():
m(0),is_locked(false)
{}
-
+
explicit upgrade_lock(Mutex& m_):
m(&m_),is_locked(false)
{
@@ -726,7 +773,7 @@
std::swap(m,other.m);
std::swap(is_locked,other.is_locked);
}
-
+
~upgrade_lock()
{
if(owns_lock())
@@ -761,7 +808,7 @@
m->unlock_upgrade();
is_locked=false;
}
-
+
typedef void (upgrade_lock::*bool_type)();
operator bool_type() const
{
@@ -829,7 +876,7 @@
{
other->source=0;
}
-
+
upgrade_to_unique_lock& operator=(detail::thread_move_t<upgrade_to_unique_lock<Mutex> > other)
{
upgrade_to_unique_lock temp(other);
@@ -866,7 +913,7 @@
public:
try_lock_wrapper()
{}
-
+
explicit try_lock_wrapper(Mutex& m):
base(m,try_to_lock)
{}
@@ -981,7 +1028,7 @@
lhs.swap(rhs);
}
#endif
-
+
template<typename MutexType1,typename MutexType2>
unsigned try_lock_internal(MutexType1& m1,MutexType2& m2)
{
@@ -1110,7 +1157,7 @@
template<bool x>
struct is_mutex_type_wrapper
{};
-
+
template<typename MutexType1,typename MutexType2>
void lock_impl(MutexType1& m1,MutexType2& m2,is_mutex_type_wrapper<true>)
{
@@ -1138,7 +1185,7 @@
template<typename Iterator>
void lock_impl(Iterator begin,Iterator end,is_mutex_type_wrapper<false>);
}
-
+
template<typename MutexType1,typename MutexType2>
void lock(MutexType1& m1,MutexType2& m2)
@@ -1283,7 +1330,7 @@
{
typedef int type;
};
-
+
template<typename Iterator>
struct try_lock_impl_return<Iterator,false>
{
@@ -1299,7 +1346,7 @@
template<typename Iterator>
Iterator try_lock_impl(Iterator begin,Iterator end,is_mutex_type_wrapper<false>);
}
-
+
template<typename MutexType1,typename MutexType2>
typename detail::try_lock_impl_return<MutexType1>::type try_lock(MutexType1& m1,MutexType2& m2)
{
@@ -1341,7 +1388,7 @@
{
return ((int)detail::try_lock_internal(m1,m2,m3,m4,m5))-1;
}
-
+
namespace detail
{
@@ -1350,13 +1397,13 @@
{
Iterator begin;
Iterator end;
-
+
range_lock_guard(Iterator begin_,Iterator end_):
begin(begin_),end(end_)
{
lock(begin,end);
}
-
+
void release()
{
begin=end;
@@ -1381,7 +1428,7 @@
}
typedef typename std::iterator_traits<Iterator>::value_type lock_type;
unique_lock<lock_type> guard(*begin,try_to_lock);
-
+
if(!guard.owns_lock())
{
return begin;
@@ -1391,11 +1438,11 @@
{
guard.release();
}
-
+
return failed;
}
}
-
+
namespace detail
{
@@ -1403,7 +1450,7 @@
void lock_impl(Iterator begin,Iterator end,is_mutex_type_wrapper<false>)
{
typedef typename std::iterator_traits<Iterator>::value_type lock_type;
-
+
if(begin==end)
{
return;
@@ -1412,7 +1459,7 @@
Iterator second=begin;
++second;
Iterator next=second;
-
+
for(;;)
{
unique_lock<lock_type> begin_lock(*begin,defer_lock);
@@ -1451,9 +1498,9 @@
}
}
}
-
+
}
-
+
}
#include <boost/config/abi_suffix.hpp>
Modified: sandbox/chrono/boost/thread/pthread/condition_variable.hpp
==============================================================================
--- sandbox/chrono/boost/thread/pthread/condition_variable.hpp (original)
+++ sandbox/chrono/boost/thread/pthread/condition_variable.hpp 2010-05-21 20:35:45 EDT (Fri, 21 May 2010)
@@ -10,6 +10,10 @@
#include "thread_data.hpp"
#include "condition_variable_fwd.hpp"
+#include <boost/chrono.hpp>
+#include <boost/conversion/boost/chrono_duration_to_posix_time_duration.hpp>
+#include <boost/conversion/boost/chrono_time_point_to_posix_time_ptime.hpp>
+
#include <boost/config/abi_prefix.hpp>
namespace boost
@@ -37,19 +41,19 @@
{
BOOST_VERIFY(!pthread_cond_signal(&cond));
}
-
+
inline void condition_variable::notify_all()
{
BOOST_VERIFY(!pthread_cond_broadcast(&cond));
}
-
+
class condition_variable_any
{
pthread_mutex_t internal_mutex;
pthread_cond_t cond;
- condition_variable_any(condition_variable&);
- condition_variable_any& operator=(condition_variable&);
+ condition_variable_any(condition_variable_any&);
+ condition_variable_any& operator=(condition_variable_any&);
public:
condition_variable_any()
@@ -71,7 +75,7 @@
BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
BOOST_VERIFY(!pthread_cond_destroy(&cond));
}
-
+
template<typename lock_type>
void wait(lock_type& m)
{
@@ -96,7 +100,7 @@
{
while(!pred()) wait(m);
}
-
+
template<typename lock_type>
bool timed_wait(lock_type& m,boost::system_time const& wait_until)
{
@@ -156,12 +160,39 @@
return timed_wait(m,get_system_time()+wait_duration,pred);
}
+ template <typename lock_type,class Clock, class Duration>
+ BOOST_ENUM_CLASS(cv_status) wait_until(lock_type& lock,
+ const chrono::time_point<Clock, Duration>& abs_time) {
+ return (timed_wait(lock, convert_to<system_time>(abs_time)))
+ ? cv_status::timeout
+ : cv_status::no_timeout;
+ }
+ template <typename lock_type,class Clock, class Duration, class Predicate>
+ bool wait_until(lock_type& lock,
+ const chrono::time_point<Clock, Duration>& abs_time,
+ Predicate pred) {
+ return timed_wait(lock, convert_to<system_time>(abs_time), pred);
+ }
+ template <typename lock_type,class Rep, class Period>
+ BOOST_ENUM_CLASS(cv_status) wait_for(lock_type& lock,
+ const chrono::duration<Rep, Period>& rel_time) {
+ return (timed_wait(lock, convert_to<posix_time::time_duration>(rel_time)))
+ ? cv_status::timeout
+ : cv_status::no_timeout;
+ }
+ template <typename lock_type,class Rep, class Period, class Predicate>
+ bool wait_for(lock_type& lock,
+ const chrono::duration<Rep, Period>& rel_time,
+ Predicate pred) {
+ return timed_wait(lock, convert_to<posix_time::time_duration>(rel_time), pred);
+ }
+
void notify_one()
{
boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
BOOST_VERIFY(!pthread_cond_signal(&cond));
}
-
+
void notify_all()
{
boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
Modified: sandbox/chrono/boost/thread/pthread/condition_variable_fwd.hpp
==============================================================================
--- sandbox/chrono/boost/thread/pthread/condition_variable_fwd.hpp (original)
+++ sandbox/chrono/boost/thread/pthread/condition_variable_fwd.hpp 2010-05-21 20:35:45 EDT (Fri, 21 May 2010)
@@ -5,6 +5,8 @@
// http://www.boost.org/LICENSE_1_0.txt)
// (C) Copyright 2007-8 Anthony Williams
+#include <boost/config.hpp>
+
#include <boost/assert.hpp>
#include <boost/throw_exception.hpp>
#include <pthread.h>
@@ -13,6 +15,11 @@
#include <boost/thread/thread_time.hpp>
#include <boost/thread/xtime.hpp>
+#include <boost/chrono.hpp>
+#include <boost/conversion/boost/chrono_duration_to_posix_time_duration.hpp>
+#include <boost/conversion/boost/chrono_time_point_to_posix_time_ptime.hpp>
+#include <boost/thread/detail/cv_status.hpp>
+
#include <boost/config/abi_prefix.hpp>
namespace boost
@@ -21,7 +28,7 @@
{
private:
pthread_cond_t cond;
-
+
condition_variable(condition_variable&);
condition_variable& operator=(condition_variable&);
@@ -82,6 +89,33 @@
return timed_wait(m,get_system_time()+wait_duration,pred);
}
+ template <class Clock, class Duration>
+ BOOST_ENUM_CLASS(cv_status) wait_until(unique_lock<mutex>& lock,
+ const chrono::time_point<Clock, Duration>& abs_time) {
+ return (timed_wait(lock, convert_to<system_time>(abs_time)))
+ ? cv_status::timeout
+ : cv_status::no_timeout;
+ }
+ template <class Clock, class Duration, class Predicate>
+ bool wait_until(unique_lock<mutex>& lock,
+ const chrono::time_point<Clock, Duration>& abs_time,
+ Predicate pred) {
+ return timed_wait(lock, convert_to<system_time>(abs_time), pred);
+ }
+ template <class Rep, class Period>
+ BOOST_ENUM_CLASS(cv_status) wait_for(unique_lock<mutex>& lock,
+ const chrono::duration<Rep, Period>& rel_time) {
+ return (timed_wait(lock, convert_to<posix_time::time_duration>(rel_time)))
+ ? cv_status::timeout
+ : cv_status::no_timeout;
+ }
+ template <class Rep, class Period, class Predicate>
+ bool wait_for(unique_lock<mutex>& lock,
+ const chrono::duration<Rep, Period>& rel_time,
+ Predicate pred) {
+ return timed_wait(lock, convert_to<posix_time::time_duration>(rel_time), pred);
+ }
+
typedef pthread_cond_t* native_handle_type;
native_handle_type native_handle()
{
Modified: sandbox/chrono/boost/thread/pthread/mutex.hpp
==============================================================================
--- sandbox/chrono/boost/thread/pthread/mutex.hpp (original)
+++ sandbox/chrono/boost/thread/pthread/mutex.hpp 2010-05-21 20:35:45 EDT (Fri, 21 May 2010)
@@ -23,6 +23,10 @@
#endif
#endif
+#include <boost/chrono.hpp>
+#include <boost/conversion/boost/chrono_duration_to_posix_time_duration.hpp>
+#include <boost/conversion/boost/chrono_time_point_to_posix_time_ptime.hpp>
+
#include <boost/config/abi_prefix.hpp>
namespace boost
@@ -119,6 +123,14 @@
{
return timed_lock(system_time(absolute_time));
}
+ template <class Rep, class Period>
+ bool try_lock_for(chrono::duration<Rep, Period> const & rel_time) {
+ return timed_lock(convert_to<posix_time::time_duration>(rel_time));
+ }
+ template <class Clock, class Duration>
+ bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time) {
+ return timed_lock(convert_to<system_time>(abs_time));
+ }
#ifdef BOOST_PTHREAD_HAS_TIMEDLOCK
void lock()
Modified: sandbox/chrono/boost/thread/pthread/recursive_mutex.hpp
==============================================================================
--- sandbox/chrono/boost/thread/pthread/recursive_mutex.hpp (original)
+++ sandbox/chrono/boost/thread/pthread/recursive_mutex.hpp 2010-05-21 20:35:45 EDT (Fri, 21 May 2010)
@@ -26,6 +26,10 @@
#endif
#endif
+#include <boost/chrono.hpp>
+#include <boost/conversion/boost/chrono_duration_to_posix_time_duration.hpp>
+#include <boost/conversion/boost/chrono_time_point_to_posix_time_ptime.hpp>
+
#include <boost/config/abi_prefix.hpp>
namespace boost
@@ -39,7 +43,7 @@
recursive_mutex()
{
pthread_mutexattr_t attr;
-
+
int const init_attr_res=pthread_mutexattr_init(&attr);
if(init_attr_res)
{
@@ -50,7 +54,7 @@
{
boost::throw_exception(thread_resource_error());
}
-
+
int const res=pthread_mutex_init(&m,&attr);
if(res)
{
@@ -62,7 +66,7 @@
{
BOOST_VERIFY(!pthread_mutex_destroy(&m));
}
-
+
void lock()
{
BOOST_VERIFY(!pthread_mutex_lock(&m));
@@ -72,7 +76,7 @@
{
BOOST_VERIFY(!pthread_mutex_unlock(&m));
}
-
+
bool try_lock()
{
int const res=pthread_mutex_trylock(&m);
@@ -108,7 +112,7 @@
{
#ifdef BOOST_PTHREAD_HAS_TIMEDLOCK
pthread_mutexattr_t attr;
-
+
int const init_attr_res=pthread_mutexattr_init(&attr);
if(init_attr_res)
{
@@ -119,7 +123,7 @@
{
boost::throw_exception(thread_resource_error());
}
-
+
int const res=pthread_mutex_init(&m,&attr);
if(res)
{
@@ -157,6 +161,16 @@
return timed_lock(get_system_time()+relative_time);
}
+ template <class Rep, class Period>
+ bool try_lock_for(const chrono::duration<Rep, Period>& rel_time) {
+ return timed_lock(convert_to<posix_time::time_duration>(rel_time));
+ }
+
+ template <class Clock, class Duration>
+ bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time) {
+ return timed_lock(convert_to<system_time>(abs_time));
+ }
+
#ifdef BOOST_PTHREAD_HAS_TIMEDLOCK
void lock()
{
@@ -167,7 +181,7 @@
{
BOOST_VERIFY(!pthread_mutex_unlock(&m));
}
-
+
bool try_lock()
{
int const res=pthread_mutex_trylock(&m);
@@ -197,7 +211,7 @@
++count;
return;
}
-
+
while(is_locked)
{
BOOST_VERIFY(!pthread_cond_wait(&cond,&m));
@@ -216,7 +230,7 @@
}
BOOST_VERIFY(!pthread_cond_signal(&cond));
}
-
+
bool try_lock()
{
boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
Modified: sandbox/chrono/boost/thread/pthread/shared_mutex.hpp
==============================================================================
--- sandbox/chrono/boost/thread/pthread/shared_mutex.hpp (original)
+++ sandbox/chrono/boost/thread/pthread/shared_mutex.hpp 2010-05-21 20:35:45 EDT (Fri, 21 May 2010)
@@ -13,6 +13,10 @@
#include <boost/thread/condition_variable.hpp>
#include <boost/thread/detail/thread_interruption.hpp>
+#include <boost/chrono.hpp>
+#include <boost/conversion/boost/chrono_duration_to_posix_time_duration.hpp>
+#include <boost/conversion/boost/chrono_time_point_to_posix_time_ptime.hpp>
+
#include <boost/config/abi_prefix.hpp>
namespace boost
@@ -27,7 +31,7 @@
bool upgrade;
bool exclusive_waiting_blocked;
};
-
+
state_data state;
@@ -41,7 +45,7 @@
exclusive_cond.notify_one();
shared_cond.notify_all();
}
-
+
public:
shared_mutex()
@@ -58,7 +62,7 @@
{
boost::this_thread::disable_interruption do_not_disturb;
boost::mutex::scoped_lock lk(state_change);
-
+
while(state.exclusive || state.exclusive_waiting_blocked)
{
shared_cond.wait(lk);
@@ -69,7 +73,7 @@
bool try_lock_shared()
{
boost::mutex::scoped_lock lk(state_change);
-
+
if(state.exclusive || state.exclusive_waiting_blocked)
{
return false;
@@ -85,7 +89,7 @@
{
boost::this_thread::disable_interruption do_not_disturb;
boost::mutex::scoped_lock lk(state_change);
-
+
while(state.exclusive || state.exclusive_waiting_blocked)
{
if(!shared_cond.timed_wait(lk,timeout))
@@ -103,11 +107,21 @@
return timed_lock_shared(get_system_time()+relative_time);
}
+ template <class Rep, class Period>
+ bool try_lock_shared_for(const chrono::duration<Rep, Period>& rel_time) {
+ return timed_lock_shared(convert_to<posix_time::time_duration>(rel_time));
+ }
+
+ template <class Clock, class Duration>
+ bool try_lock_shared_until(const chrono::time_point<Clock, Duration>& abs_time) {
+ return timed_lock_shared(convert_to<system_time>(abs_time));
+ }
+
void unlock_shared()
{
boost::mutex::scoped_lock lk(state_change);
bool const last_reader=!--state.shared_count;
-
+
if(last_reader)
{
if(state.upgrade)
@@ -128,7 +142,7 @@
{
boost::this_thread::disable_interruption do_not_disturb;
boost::mutex::scoped_lock lk(state_change);
-
+
while(state.shared_count || state.exclusive)
{
state.exclusive_waiting_blocked=true;
@@ -165,11 +179,21 @@
{
return timed_lock(get_system_time()+relative_time);
}
+
+ template <class Rep, class Period>
+ bool try_lock_for(const chrono::duration<Rep, Period>& rel_time) {
+ return timed_lock(convert_to<posix_time::time_duration>(rel_time));
+ }
+
+ template <class Clock, class Duration>
+ bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time) {
+ return timed_lock(convert_to<system_time>(abs_time));
+ }
bool try_lock()
{
boost::mutex::scoped_lock lk(state_change);
-
+
if(state.shared_count || state.exclusive)
{
return false;
@@ -179,7 +203,7 @@
state.exclusive=true;
return true;
}
-
+
}
void unlock()
@@ -225,7 +249,17 @@
template<typename TimeDuration>
bool timed_lock_upgrade(TimeDuration const & relative_time)
{
- return timed_lock(get_system_time()+relative_time);
+ return timed_lock_upgrade(get_system_time()+relative_time);
+ }
+
+ template <class Rep, class Period>
+ bool try_lock_upgrade_for(const chrono::duration<Rep, Period>& rel_time) {
+ return timed_lock_upgrade(convert_to<posix_time::time_duration>(rel_time));
+ }
+
+ template <class Clock, class Duration>
+ bool try_lock_upgrade_until(const chrono::time_point<Clock, Duration>& abs_time) {
+ return timed_lock_upgrade(convert_to<system_time>(abs_time));
}
bool try_lock_upgrade()
@@ -248,7 +282,7 @@
boost::mutex::scoped_lock lk(state_change);
state.upgrade=false;
bool const last_reader=!--state.shared_count;
-
+
if(last_reader)
{
state.exclusive_waiting_blocked=false;
@@ -278,7 +312,7 @@
state.exclusive_waiting_blocked=false;
release_waiters();
}
-
+
void unlock_and_lock_shared()
{
boost::mutex::scoped_lock lk(state_change);
@@ -287,7 +321,7 @@
state.exclusive_waiting_blocked=false;
release_waiters();
}
-
+
void unlock_upgrade_and_lock_shared()
{
boost::mutex::scoped_lock lk(state_change);
Modified: sandbox/chrono/boost/thread/win32/basic_recursive_mutex.hpp
==============================================================================
--- sandbox/chrono/boost/thread/win32/basic_recursive_mutex.hpp (original)
+++ sandbox/chrono/boost/thread/win32/basic_recursive_mutex.hpp 2010-05-21 20:35:45 EDT (Fri, 21 May 2010)
@@ -3,7 +3,7 @@
// basic_recursive_mutex.hpp
//
-// (C) Copyright 2006-8 Anthony Williams
+// (C) Copyright 2006-8 Anthony Williams
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
@@ -12,6 +12,9 @@
#include "thread_primitives.hpp"
#include "basic_timed_mutex.hpp"
+#include <boost/chrono.hpp>
+#include <boost/conversion/boost/chrono_duration_to_posix_time_duration.hpp>
+#include <boost/conversion/boost/chrono_time_point_to_posix_time_ptime.hpp>
#include <boost/config/abi_prefix.hpp>
namespace boost
@@ -42,7 +45,7 @@
long const current_thread_id=win32::GetCurrentThreadId();
return try_recursive_lock(current_thread_id) || try_basic_lock(current_thread_id);
}
-
+
void lock()
{
long const current_thread_id=win32::GetCurrentThreadId();
@@ -64,6 +67,16 @@
return timed_lock(get_system_time()+timeout);
}
+ template <class Rep, class Period>
+ bool try_lock_for(const chrono::duration<Rep, Period>& rel_time) {
+ return timed_lock(convert_to<posix_time::time_duration>(rel_time));
+ }
+
+ template <class Clock, class Duration>
+ bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time) {
+ return timed_lock(convert_to<system_time>(abs_time));
+ }
+
void unlock()
{
if(!--recursion_count)
@@ -83,7 +96,7 @@
}
return false;
}
-
+
bool try_basic_lock(long current_thread_id)
{
if(mutex.try_lock())
@@ -94,7 +107,7 @@
}
return false;
}
-
+
bool try_timed_lock(long current_thread_id,::boost::system_time const& target)
{
if(mutex.timed_lock(target))
@@ -105,7 +118,7 @@
}
return false;
}
-
+
};
typedef basic_recursive_mutex_impl<basic_timed_mutex> basic_recursive_mutex;
Modified: sandbox/chrono/boost/thread/win32/basic_timed_mutex.hpp
==============================================================================
--- sandbox/chrono/boost/thread/win32/basic_timed_mutex.hpp (original)
+++ sandbox/chrono/boost/thread/win32/basic_timed_mutex.hpp 2010-05-21 20:35:45 EDT (Fri, 21 May 2010)
@@ -3,7 +3,7 @@
// basic_timed_mutex_win32.hpp
//
-// (C) Copyright 2006-8 Anthony Williams
+// (C) Copyright 2006-8 Anthony Williams
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
@@ -16,6 +16,9 @@
#include <boost/thread/xtime.hpp>
#include <boost/detail/interlocked.hpp>
+#include <boost/chrono.hpp>
+#include <boost/conversion/boost/chrono_duration_to_posix_time_duration.hpp>
+#include <boost/conversion/boost/chrono_time_point_to_posix_time_ptime.hpp>
#include <boost/config/abi_prefix.hpp>
namespace boost
@@ -52,13 +55,13 @@
win32::CloseHandle(old_event);
}
}
-
-
+
+
bool try_lock()
{
return !win32::interlocked_bit_test_and_set(&active_count,lock_flag_bit);
}
-
+
void lock()
{
if(try_lock())
@@ -112,8 +115,8 @@
old_count=current;
}
}
-
-
+
+
bool timed_lock(::boost::system_time const& wait_until)
{
if(try_lock())
@@ -154,6 +157,16 @@
return timed_lock(system_time(timeout));
}
+ template <class Rep, class Period>
+ bool try_lock_for(const chrono::duration<Rep, Period>& rel_time) {
+ return timed_lock(convert_to<posix_time::time_duration>(rel_time));
+ }
+
+ template <class Clock, class Duration>
+ bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time) {
+ return timed_lock(convert_to<system_time>(abs_time));
+ }
+
void unlock()
{
long const offset=lock_flag_value;
@@ -171,7 +184,7 @@
void* get_event()
{
void* current_event=::boost::detail::interlocked_read_acquire(&event);
-
+
if(!current_event)
{
void* const new_event=win32::create_anonymous_event(win32::auto_reset_event,win32::event_initially_reset);
@@ -196,9 +209,9 @@
}
return current_event;
}
-
+
};
-
+
}
}
Modified: sandbox/chrono/boost/thread/win32/condition_variable.hpp
==============================================================================
--- sandbox/chrono/boost/thread/win32/condition_variable.hpp (original)
+++ sandbox/chrono/boost/thread/win32/condition_variable.hpp 2010-05-21 20:35:45 EDT (Fri, 21 May 2010)
@@ -17,6 +17,9 @@
#include <vector>
#include <boost/intrusive_ptr.hpp>
+#include <boost/chrono.hpp>
+#include <boost/conversion/boost/chrono_duration_to_posix_time_duration.hpp>
+#include <boost/conversion/boost/chrono_time_point_to_posix_time_ptime.hpp>
#include <boost/config/abi_prefix.hpp>
namespace boost
@@ -26,7 +29,7 @@
class basic_cv_list_entry;
void intrusive_ptr_add_ref(basic_cv_list_entry * p);
void intrusive_ptr_release(basic_cv_list_entry * p);
-
+
class basic_cv_list_entry
{
private:
@@ -38,7 +41,7 @@
basic_cv_list_entry(basic_cv_list_entry&);
void operator=(basic_cv_list_entry&);
-
+
public:
explicit basic_cv_list_entry(detail::win32::handle_manager const& wake_sem_):
semaphore(detail::win32::create_anonymous_semaphore(0,LONG_MAX)),
@@ -55,7 +58,7 @@
{
BOOST_INTERLOCKED_INCREMENT(&waiters);
}
-
+
void remove_waiter()
{
BOOST_INTERLOCKED_DECREMENT(&waiters);
@@ -97,7 +100,7 @@
{
BOOST_INTERLOCKED_INCREMENT(&p->references);
}
-
+
inline void intrusive_ptr_release(basic_cv_list_entry * p)
{
if(!BOOST_INTERLOCKED_DECREMENT(&p->references))
@@ -125,13 +128,13 @@
detail::interlocked_write_release(&total_count,total_count-count_to_wake);
detail::win32::ReleaseSemaphore(wake_sem,count_to_wake,0);
}
-
+
template<typename lock_type>
struct relocker
{
lock_type& lock;
bool unlocked;
-
+
relocker(lock_type& lock_):
lock(lock_),unlocked(false)
{}
@@ -146,13 +149,13 @@
{
lock.lock();
}
-
+
}
private:
relocker(relocker&);
void operator=(relocker&);
};
-
+
entry_ptr get_wait_entry()
{
@@ -177,15 +180,15 @@
return generations.back();
}
}
-
+
struct entry_manager
{
entry_ptr const entry;
-
+
entry_manager(entry_ptr const& entry_):
entry(entry_)
{}
-
+
~entry_manager()
{
entry->remove_waiter();
@@ -200,14 +203,14 @@
void operator=(entry_manager&);
entry_manager(entry_manager&);
};
-
+
protected:
template<typename lock_type>
bool do_wait(lock_type& lock,timeout wait_until)
{
relocker<lock_type> locker(lock);
-
+
entry_manager entry(get_wait_entry());
locker.unlock();
@@ -219,7 +222,7 @@
{
return false;
}
-
+
woken=entry->woken();
}
return woken;
@@ -235,7 +238,7 @@
}
return true;
}
-
+
basic_condition_variable(const basic_condition_variable& other);
basic_condition_variable& operator=(const basic_condition_variable& other);
@@ -243,7 +246,7 @@
basic_condition_variable():
total_count(0),active_generation_count(0),wake_sem(0)
{}
-
+
~basic_condition_variable()
{}
@@ -267,7 +270,7 @@
generations.erase(std::remove_if(generations.begin(),generations.end(),&basic_cv_list_entry::no_waiters),generations.end());
}
}
-
+
void notify_all()
{
if(detail::interlocked_read_acquire(&total_count))
@@ -288,7 +291,7 @@
wake_sem=detail::win32::handle(0);
}
}
-
+
};
}
@@ -301,10 +304,10 @@
public:
condition_variable()
{}
-
+
using detail::basic_condition_variable::notify_one;
using detail::basic_condition_variable::notify_all;
-
+
void wait(unique_lock<mutex>& m)
{
do_wait(m,detail::timeout::sentinel());
@@ -315,7 +318,7 @@
{
while(!pred()) wait(m);
}
-
+
bool timed_wait(unique_lock<mutex>& m,boost::system_time const& wait_until)
{
@@ -347,8 +350,35 @@
{
return do_wait(m,wait_duration.total_milliseconds(),pred);
}
+
+ template <class Clock, class Duration>
+ BOOST_ENUM_CLASS(cv_status) wait_until(unique_lock<mutex>& lock,
+ const chrono::time_point<Clock, Duration>& abs_time) {
+ return (timed_wait(lock, convert_to<system_time>(abs_time)))
+ ? cv_status::timeout
+ : cv_status::no_timeout;
+ }
+ template <class Clock, class Duration, class Predicate>
+ bool wait_until(unique_lock<mutex>& lock,
+ const chrono::time_point<Clock, Duration>& abs_time,
+ Predicate pred) {
+ return timed_wait(lock, convert_to<system_time>(abs_time), pred);
+ }
+ template <class Rep, class Period>
+ BOOST_ENUM_CLASS(cv_status) wait_for(unique_lock<mutex>& lock,
+ const chrono::duration<Rep, Period>& rel_time) {
+ return (timed_wait(lock, convert_to<posix_time::time_duration>(rel_time)))
+ ? cv_status::timeout
+ : cv_status::no_timeout;
+ }
+ template <class Rep, class Period, class Predicate>
+ bool wait_for(unique_lock<mutex>& lock,
+ const chrono::duration<Rep, Period>& rel_time,
+ Predicate pred) {
+ return timed_wait(lock, convert_to<posix_time::time_duration>(rel_time), pred);
+ }
};
-
+
class condition_variable_any:
private detail::basic_condition_variable
{
@@ -358,10 +388,10 @@
public:
condition_variable_any()
{}
-
+
using detail::basic_condition_variable::notify_one;
using detail::basic_condition_variable::notify_all;
-
+
template<typename lock_type>
void wait(lock_type& m)
{
@@ -373,7 +403,7 @@
{
while(!pred()) wait(m);
}
-
+
template<typename lock_type>
bool timed_wait(lock_type& m,boost::system_time const& wait_until)
{
@@ -409,6 +439,36 @@
{
return do_wait(m,wait_duration.total_milliseconds(),pred);
}
+
+ template <typename lock_type,class Clock, class Duration>
+ BOOST_ENUM_CLASS(cv_status) wait_until(lock_type& lock,
+ const chrono::time_point<Clock, Duration>& abs_time) {
+ return (timed_wait(lock, convert_to<system_time>(abs_time)))
+ ? cv_status::timeout
+ : cv_status::no_timeout;
+ }
+
+ template <typename lock_type,class Clock, class Duration, class Predicate>
+ bool wait_until(lock_type& lock,
+ const chrono::time_point<Clock, Duration>& abs_time,
+ Predicate pred) {
+ return timed_wait(lock, convert_to<system_time>(abs_time), pred);
+ }
+
+ template <typename lock_type,class Rep, class Period>
+ BOOST_ENUM_CLASS(cv_status) wait_for(lock_type& lock,
+ const chrono::duration<Rep, Period>& rel_time) {
+ return (timed_wait(lock, convert_to<posix_time::time_duration>(rel_time)))
+ ? cv_status::timeout
+ : cv_status::no_timeout;
+ }
+
+ template <typename lock_type,class Rep, class Period, class Predicate>
+ bool wait_for(lock_type& lock,
+ const chrono::duration<Rep, Period>& rel_time,
+ Predicate pred) {
+ return timed_wait(lock, convert_to<posix_time::time_duration>(rel_time), pred);
+ }
};
}
Modified: sandbox/chrono/boost/thread/win32/shared_mutex.hpp
==============================================================================
--- sandbox/chrono/boost/thread/win32/shared_mutex.hpp (original)
+++ sandbox/chrono/boost/thread/win32/shared_mutex.hpp 2010-05-21 20:35:45 EDT (Fri, 21 May 2010)
@@ -15,6 +15,10 @@
#include <boost/utility.hpp>
#include <boost/thread/thread_time.hpp>
+#include <boost/chrono.hpp>
+#include <boost/conversion/boost/chrono_duration_to_posix_time_duration.hpp>
+#include <boost/conversion/boost/chrono_time_point_to_posix_time_ptime.hpp>
+
#include <boost/config/abi_prefix.hpp>
namespace boost
@@ -37,7 +41,7 @@
return *reinterpret_cast<unsigned const*>(&lhs)==*reinterpret_cast<unsigned const*>(&rhs);
}
};
-
+
template<typename T>
T interlocked_compare_exchange(T* target,T new_value,T comparand)
@@ -61,18 +65,18 @@
{
BOOST_VERIFY(detail::win32::ReleaseSemaphore(exclusive_sem,1,0)!=0);
}
-
+
if(old_state.shared_waiting || old_state.exclusive_waiting)
{
BOOST_VERIFY(detail::win32::ReleaseSemaphore(unlock_sem,old_state.shared_waiting + (old_state.exclusive_waiting?1:0),0)!=0);
}
}
-
+
public:
shared_mutex():
unlock_sem(semaphores[0]),
- exclusive_sem(semaphores[1])
+ exclusive_sem(semaphores[1])
{
unlock_sem=detail::win32::create_anonymous_semaphore(0,LONG_MAX);
exclusive_sem=detail::win32::create_anonymous_semaphore(0,LONG_MAX);
@@ -98,7 +102,7 @@
{
++new_state.shared_count;
}
-
+
state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
if(current_state==old_state)
{
@@ -149,7 +153,7 @@
{
return true;
}
-
+
unsigned long const res=detail::win32::WaitForSingleObject(unlock_sem,::boost::detail::get_milliseconds_until(wait_until));
if(res==detail::win32::timeout)
{
@@ -182,11 +186,21 @@
}
return false;
}
-
+
BOOST_ASSERT(res==0);
}
}
+ template <class Rep, class Period>
+ bool try_lock_shared_for(const chrono::duration<Rep, Period>& rel_time) {
+ return timed_lock_shared(convert_to<posix_time::time_duration>(rel_time));
+ }
+
+ template <class Clock, class Duration>
+ bool try_lock_shared_until(const chrono::time_point<Clock, Duration>& abs_time) {
+ return timed_lock_shared(convert_to<system_time>(abs_time));
+ }
+
void unlock_shared()
{
state_data old_state=state;
@@ -194,7 +208,7 @@
{
state_data new_state=old_state;
bool const last_reader=!--new_state.shared_count;
-
+
if(last_reader)
{
if(new_state.upgrade)
@@ -212,7 +226,7 @@
new_state.shared_waiting=0;
}
}
-
+
state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
if(current_state==old_state)
{
@@ -258,7 +272,7 @@
{
new_state.exclusive=true;
}
-
+
state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
if(current_state==old_state)
{
@@ -339,6 +353,16 @@
}
}
+ template <class Rep, class Period>
+ bool try_lock_for(const chrono::duration<Rep, Period>& rel_time) {
+ return timed_lock(convert_to<posix_time::time_duration>(rel_time));
+ }
+
+ template <class Clock, class Duration>
+ bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time) {
+ return timed_lock(convert_to<system_time>(abs_time));
+ }
+
void unlock()
{
state_data old_state=state;
@@ -393,7 +417,7 @@
{
return;
}
-
+
BOOST_VERIFY(!detail::win32::WaitForSingleObject(unlock_sem,detail::win32::infinite));
}
}
@@ -413,7 +437,7 @@
++new_state.shared_count;
new_state.upgrade=true;
}
-
+
state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
if(current_state==old_state)
{
@@ -432,7 +456,7 @@
state_data new_state=old_state;
new_state.upgrade=false;
bool const last_reader=!--new_state.shared_count;
-
+
if(last_reader)
{
if(new_state.exclusive_waiting)
@@ -442,7 +466,7 @@
}
new_state.shared_waiting=0;
}
-
+
state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
if(current_state==old_state)
{
@@ -463,13 +487,13 @@
{
state_data new_state=old_state;
bool const last_reader=!--new_state.shared_count;
-
+
if(last_reader)
{
new_state.upgrade=false;
new_state.exclusive=true;
}
-
+
state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
if(current_state==old_state)
{
@@ -508,7 +532,7 @@
}
release_waiters(old_state);
}
-
+
void unlock_and_lock_shared()
{
state_data old_state=state;
@@ -533,7 +557,7 @@
}
release_waiters(old_state);
}
-
+
void unlock_upgrade_and_lock_shared()
{
state_data old_state=state;
@@ -557,7 +581,7 @@
}
release_waiters(old_state);
}
-
+
};
}
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