Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r85811 - in trunk: boost/sync/detail boost/sync/detail/event boost/sync/detail/mutexes boost/sync/mutexes boost/sync/support libs/sync/test/run
From: andrey.semashev_at_[hidden]
Date: 2013-09-21 15:03:30


Author: andysem
Date: 2013-09-21 15:03:30 EDT (Sat, 21 Sep 2013)
New Revision: 85811
URL: http://svn.boost.org/trac/boost/changeset/85811

Log:
Ported timed mutex for Windows. Changed time units to allow for non-system clocks. Minor fixes.

Added:
   trunk/boost/sync/detail/mutexes/timed_mutex_windows.hpp (contents, props changed)
Text files modified:
   trunk/boost/sync/detail/event/event_futex.hpp | 18 +--
   trunk/boost/sync/detail/mutexes/mutex_windows.hpp | 10 +
   trunk/boost/sync/detail/mutexes/timed_mutex_posix.hpp | 37 +++++++
   trunk/boost/sync/detail/mutexes/timed_mutex_windows.hpp | 175 ++++++++++++++++++++++++++++++++++++++
   trunk/boost/sync/detail/time_units.hpp | 182 ++++++++++++++++++++++-----------------
   trunk/boost/sync/mutexes/timed_mutex.hpp | 36 +++++++
   trunk/boost/sync/support/date_time.hpp | 22 ++--
   trunk/libs/sync/test/run/mutex_test.cpp | 2
   8 files changed, 373 insertions(+), 109 deletions(-)

Modified: trunk/boost/sync/detail/event/event_futex.hpp
==============================================================================
--- trunk/boost/sync/detail/event/event_futex.hpp Sat Sep 21 12:45:07 2013 (r85810)
+++ trunk/boost/sync/detail/event/event_futex.hpp 2013-09-21 15:03:30 EDT (Sat, 21 Sep 2013) (r85811)
@@ -9,20 +9,18 @@
 #ifndef BOOST_SYNC_DETAIL_EVENT_EVENT_FUTEX_HPP_INCLUDED
 #define BOOST_SYNC_DETAIL_EVENT_EVENT_FUTEX_HPP_INCLUDED
 
-#include <boost/thread/condition_variable.hpp>
-#include <boost/thread/shared_mutex.hpp>
-#include <boost/thread/locks.hpp>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/syscall.h>
+#include <linux/futex.h>
 
+#include <limits>
+#include <boost/assert.hpp>
+#include <boost/atomic.hpp>
 #include <boost/sync/detail/config.hpp>
 #include <boost/sync/detail/header.hpp>
 
-#include <boost/atomic.hpp>
-
-#include <sys/time.h>
-#include <linux/futex.h>
-#include <unistd.h>
-#include <sys/syscall.h>
-
 namespace boost {
 namespace sync {
 BOOST_SYNC_DETAIL_OPEN_ABI_NAMESPACE {

Modified: trunk/boost/sync/detail/mutexes/mutex_windows.hpp
==============================================================================
--- trunk/boost/sync/detail/mutexes/mutex_windows.hpp Sat Sep 21 12:45:07 2013 (r85810)
+++ trunk/boost/sync/detail/mutexes/mutex_windows.hpp 2013-09-21 15:03:30 EDT (Sat, 21 Sep 2013) (r85811)
@@ -39,8 +39,12 @@
 
 BOOST_SYNC_DETAIL_OPEN_ABI_NAMESPACE {
 
+class timed_mutex;
+
 class mutex
 {
+ friend class timed_mutex;
+
 private:
     enum
     {
@@ -102,7 +106,7 @@
         }
     }
 
- bool try_lock() BOOST_NOEXCEPT
+ bool try_lock()
     {
         return !sync::detail::windows::interlocked_bit_test_and_set(&m_active_count, lock_flag_bit);
     }
@@ -170,7 +174,7 @@
     }
 };
 
-} // namespace posix
+} // namespace winnt
 
 } // namespace sync
 
@@ -178,4 +182,4 @@
 
 #include <boost/sync/detail/footer.hpp>
 
-#endif // BOOST_SYNC_DETAIL_MUTEXES_MUTEX_POSIX_HPP_INCLUDED_
+#endif // BOOST_SYNC_DETAIL_MUTEXES_MUTEX_WINDOWS_HPP_INCLUDED_

Modified: trunk/boost/sync/detail/mutexes/timed_mutex_posix.hpp
==============================================================================
--- trunk/boost/sync/detail/mutexes/timed_mutex_posix.hpp Sat Sep 21 12:45:07 2013 (r85810)
+++ trunk/boost/sync/detail/mutexes/timed_mutex_posix.hpp 2013-09-21 15:03:30 EDT (Sat, 21 Sep 2013) (r85811)
@@ -199,6 +199,18 @@
         return priv_timed_lock(sync::detail::time_traits< Time >::to_sync_unit(t));
     }
 
+ template< typename Duration >
+ typename detail::enable_if_tag< Duration, detail::time_duration_tag, bool >::type try_lock_for(Duration const& rel_time)
+ {
+ return priv_timed_lock(sync::detail::time_traits< Duration >::to_sync_unit(t));
+ }
+
+ template< typename TimePoint >
+ typename detail::enable_if_tag< TimePoint, detail::time_point_tag, bool >::type try_lock_until(TimePoint const& abs_time)
+ {
+ return priv_timed_lock(sync::detail::time_traits< TimePoint >::to_sync_unit(t));
+ }
+
     native_handle_type native_handle() BOOST_NOEXCEPT
     {
         return &m_mutex;
@@ -208,12 +220,12 @@
     BOOST_DELETED_FUNCTION(timed_mutex& operator= (timed_mutex const&))
 
 private:
- bool priv_timed_lock(sync::detail::duration dur)
+ bool priv_timed_lock(sync::detail::system_duration dur)
     {
- return priv_timed_lock(sync::detail::time_point::now() + dur);
+ return priv_timed_lock(sync::detail::system_time_point::now() + dur);
     }
 
- bool priv_timed_lock(sync::detail::time_point const& t)
+ bool priv_timed_lock(sync::detail::system_time_point const& t)
     {
 #if defined(BOOST_SYNC_DETAIL_PTHREAD_HAS_TIMEDLOCK)
 
@@ -241,6 +253,25 @@
 
 #endif // defined(BOOST_SYNC_DETAIL_PTHREAD_HAS_TIMEDLOCK)
     }
+
+ template< typename TimePoint >
+ bool priv_timed_lock(sync::detail::chrono_time_point< TimePoint > const& t)
+ {
+ if (m_mutex.try_lock())
+ return true;
+
+ typedef TimePoint time_point;
+ typedef typename time_point::clock clock;
+ typedef typename time_point::duration duration;
+ time_point now = clock::now();
+ while (now < t.get())
+ {
+ if (priv_timed_lock(sync::detail::time_traits< duration >::to_sync_unit(t.get() - now)))
+ return true;
+ now = clock::now();
+ }
+ return false;
+ }
 };
 
 } // namespace posix

Added: trunk/boost/sync/detail/mutexes/timed_mutex_windows.hpp
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/boost/sync/detail/mutexes/timed_mutex_windows.hpp 2013-09-21 15:03:30 EDT (Sat, 21 Sep 2013) (r85811)
@@ -0,0 +1,175 @@
+/*
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * (C) Copyright 2007-2008 Anthony Williams
+ * (C) Copyright 2012-2013 Vicente J. Botet Escriba
+ * (C) Copyright 2013 Andrey Semashev
+ */
+/*!
+ * \file detail/mutexes/timed_mutex_windows.hpp
+ *
+ * \brief This header is the Boost.Sync library implementation, see the library documentation
+ * at http://www.boost.org/doc/libs/release/libs/sync/doc/html/index.html.
+ */
+
+#ifndef BOOST_SYNC_DETAIL_MUTEXES_TIMED_MUTEX_WINDOWS_HPP_INCLUDED_
+#define BOOST_SYNC_DETAIL_MUTEXES_TIMED_MUTEX_WINDOWS_HPP_INCLUDED_
+
+#include <cstddef>
+#include <limits>
+#include <boost/cstdint.hpp>
+#include <boost/assert.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/detail/winapi/handles.hpp>
+#include <boost/detail/winapi/synchronization.hpp>
+#include <boost/sync/exceptions/lock_error.hpp>
+#include <boost/sync/exceptions/resource_error.hpp>
+#include <boost/sync/detail/config.hpp>
+#include <boost/sync/detail/interlocked.hpp>
+#include <boost/sync/detail/time_traits.hpp>
+#include <boost/sync/detail/time_units.hpp>
+#include <boost/sync/detail/mutexes/mutex_windows.hpp>
+
+#include <boost/sync/detail/header.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace boost {
+
+namespace sync {
+
+BOOST_SYNC_DETAIL_OPEN_ABI_NAMESPACE {
+
+class timed_mutex
+{
+private:
+ mutex m_mutex;
+
+public:
+ BOOST_CONSTEXPR timed_mutex() BOOST_NOEXCEPT : m_mutex()
+ {
+ }
+
+ void lock()
+ {
+ m_mutex.lock();
+ }
+
+ void unlock() BOOST_NOEXCEPT
+ {
+ m_mutex.unlock();
+ }
+
+ bool try_lock()
+ {
+ return m_mutex.try_lock();
+ }
+
+ template< typename Time >
+ typename enable_if_c< sync::detail::time_traits< Time >::is_specialized, bool >::type timed_lock(Time const& t)
+ {
+ return priv_timed_lock(sync::detail::time_traits< Time >::to_sync_unit(t));
+ }
+
+ template< typename Duration >
+ typename detail::enable_if_tag< Duration, detail::time_duration_tag, bool >::type try_lock_for(Duration const& rel_time)
+ {
+ return priv_timed_lock(sync::detail::time_traits< Duration >::to_sync_unit(t));
+ }
+
+ template< typename TimePoint >
+ typename detail::enable_if_tag< TimePoint, detail::time_point_tag, bool >::type try_lock_until(TimePoint const& abs_time)
+ {
+ return priv_timed_lock(sync::detail::time_traits< TimePoint >::to_sync_unit(t));
+ }
+
+ BOOST_DELETED_FUNCTION(timed_mutex(timed_mutex const&))
+ BOOST_DELETED_FUNCTION(timed_mutex& operator= (timed_mutex const&))
+
+private:
+ bool priv_timed_lock(sync::detail::system_time_point const& t)
+ {
+ return priv_timed_lock(t - sync::detail::system_time_point::now());
+ }
+
+ bool priv_timed_lock(sync::detail::system_duration const& t)
+ {
+ if (m_mutex.try_lock())
+ return true;
+
+ long old_count = m_mutex.m_active_count;
+ m_mutex.mark_waiting_and_try_lock(old_count);
+
+ if ((old_count & mutex::lock_flag_value) != 0)
+ {
+ bool lock_acquired = false;
+ boost::detail::winapi::HANDLE_ const evt = m_mutex.get_event();
+
+ uint64_t time_left = t.get();
+ do
+ {
+ const unsigned int dur = time_left > (std::numeric_limits< int >::max)() ?
+ static_cast< unsigned int >((std::numeric_limits< int >::max)()) : static_cast< unsigned int >(time_left);
+ const boost::detail::winapi::DWORD_ res = boost::detail::winapi::WaitForSingleObject(evt, dur);
+ switch (res)
+ {
+ case boost::detail::winapi::wait_object_0:
+ m_mutex.clear_waiting_and_try_lock(old_count);
+ lock_acquired = (old_count & mutex::lock_flag_value) == 0;
+ break;
+
+ case boost::detail::winapi::wait_timeout:
+ time_left -= dur;
+ break;
+
+ default:
+ BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD(&m_mutex.m_active_count, -1);
+ BOOST_THROW_EXCEPTION(lock_error(res, "boost: timed_mutex timedlock failed in WaitForSingleObject"));
+ }
+ }
+ while (!lock_acquired && time_left > 0);
+
+ if (!lock_acquired)
+ {
+ BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD(&m_mutex.m_active_count, -1);
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ template< typename TimePoint >
+ bool priv_timed_lock(sync::detail::chrono_time_point< TimePoint > const& t)
+ {
+ if (m_mutex.try_lock())
+ return true;
+
+ typedef TimePoint time_point;
+ typedef typename time_point::clock clock;
+ typedef typename time_point::duration duration;
+ time_point now = clock::now();
+ while (now < t.get())
+ {
+ if (priv_timed_lock(sync::detail::time_traits< duration >::to_sync_unit(t.get() - now)))
+ return true;
+ now = clock::now();
+ }
+ return false;
+ }
+};
+
+} // namespace winnt
+
+} // namespace sync
+
+} // namespace boost
+
+#include <boost/sync/detail/footer.hpp>
+
+#endif // BOOST_SYNC_DETAIL_MUTEXES_TIMED_MUTEX_WINDOWS_HPP_INCLUDED_

Modified: trunk/boost/sync/detail/time_units.hpp
==============================================================================
--- trunk/boost/sync/detail/time_units.hpp Sat Sep 21 12:45:07 2013 (r85810)
+++ trunk/boost/sync/detail/time_units.hpp 2013-09-21 15:03:30 EDT (Sat, 21 Sep 2013) (r85811)
@@ -34,64 +34,70 @@
 
 namespace detail {
 
-#if defined(BOOST_SYNC_DETAIL_PLATFORM_PTHREAD)
-
-class duration
+class system_duration
 {
 public:
     typedef int64_t native_type;
+
+#if defined(BOOST_SYNC_DETAIL_PLATFORM_PTHREAD)
     // The native duration is in nanoseconds
     static BOOST_CONSTEXPR_OR_CONST uint64_t subsecond_fraction = 1000000000u;
+#elif defined(BOOST_SYNC_DETAIL_PLATFORM_WINAPI)
+ // The native duration is in milliseconds
+ static BOOST_CONSTEXPR_OR_CONST uint64_t subsecond_fraction = 1000u;
+#endif
 
 private:
     native_type m_value;
 
 public:
- duration() : m_value(0) {}
- explicit duration(native_type value) : m_value(value) {}
+ system_duration() : m_value(0) {}
+ explicit system_duration(native_type value) : m_value(value) {}
 
     native_type get() const { return m_value; }
 
- duration& operator+= (duration const& that)
+ system_duration& operator+= (system_duration const& that)
     {
         m_value += that.m_value;
         return *this;
     }
- duration& operator-= (duration const& that)
+ system_duration& operator-= (system_duration const& that)
     {
         m_value -= that.m_value;
         return *this;
     }
- duration operator- () const
+ system_duration operator- () const
     {
- return duration(-m_value);
+ return system_duration(-m_value);
     }
 
- friend duration operator+ (duration left, duration const& right)
+ friend system_duration operator+ (system_duration left, system_duration const& right)
     {
         left += right;
         return left;
     }
- friend duration operator- (duration left, duration const& right)
+ friend system_duration operator- (system_duration left, system_duration const& right)
     {
         left -= right;
         return left;
     }
 };
 
-class time_point
+#if defined(BOOST_SYNC_DETAIL_PLATFORM_PTHREAD)
+
+class system_time_point
 {
 public:
     typedef struct ::timespec native_type;
     // The native subsecond precision is nanoseconds
- static BOOST_CONSTEXPR_OR_CONST uint64_t subsecond_fraction = duration::subsecond_fraction;
+ static BOOST_CONSTEXPR_OR_CONST uint64_t subsecond_fraction = system_duration::subsecond_fraction;
 
 private:
     native_type m_value;
 
 public:
- time_point() : m_value() {}
- explicit time_point(time_t t, unsigned int subsecond = 0)
+ system_time_point() : m_value() {}
+ explicit system_time_point(time_t t, unsigned int subsecond = 0)
     {
         m_value.tv_sec = t;
         m_value.tv_nsec = subsecond;
@@ -99,119 +105,76 @@
 
     native_type const& get() const { return m_value; }
 
- static time_point now()
+ static system_time_point now()
     {
 #if defined(BOOST_HAS_CLOCK_GETTIME)
- time_point t;
+ system_time_point t;
         ::clock_gettime(CLOCK_REALTIME, &t.m_value);
         return t;
 #else
- return time_point(::time(0));
+ return system_time_point(::time(0));
 #endif
     }
 
- time_point& operator+= (duration const& dur)
+ system_time_point& operator+= (system_duration const& dur)
     {
         int64_t nsec = static_cast< int64_t >(m_value.tv_nsec) + dur.get();
- int64_t tv_nsec = nsec % duration::subsecond_fraction;
+ int64_t tv_nsec = nsec % system_duration::subsecond_fraction;
         if (tv_nsec < 0)
         {
             tv_nsec += subsecond_fraction;
             --m_value.tv_sec;
         }
         m_value.tv_nsec = tv_nsec;
- m_value.tv_sec += nsec / duration::subsecond_fraction;
+ m_value.tv_sec += nsec / system_duration::subsecond_fraction;
 
         return *this;
     }
- time_point& operator-= (duration const& dur)
+ system_time_point& operator-= (system_duration const& dur)
     {
         return operator+= (-dur);
     }
 
- friend time_point operator+ (time_point left, duration const& right)
+ friend system_time_point operator+ (system_time_point left, system_duration const& right)
     {
         left += right;
         return left;
     }
- friend time_point operator- (time_point left, duration const& right)
+ friend system_time_point operator- (system_time_point left, system_duration const& right)
     {
         left -= right;
         return left;
     }
 
- friend duration operator- (time_point const& left, time_point const& right)
+ friend system_duration operator- (system_time_point const& left, system_time_point const& right)
     {
         int64_t seconds = static_cast< int64_t >(left.m_value.tv_sec) - static_cast< int64_t >(right.m_value.tv_sec);
         int64_t nseconds = static_cast< int64_t >(left.m_value.tv_nsec) - static_cast< int64_t >(right.m_value.tv_nsec);
- return duration(seconds * duration::subsecond_fraction + nseconds);
+ return system_duration(seconds * system_duration::subsecond_fraction + nseconds);
     }
 };
 
 #elif defined(BOOST_SYNC_DETAIL_PLATFORM_WINAPI)
 
-class duration
-{
-public:
- typedef int64_t native_type;
- // The native duration is in milliseconds
- static BOOST_CONSTEXPR_OR_CONST uint64_t subsecond_fraction = 1000u;
-
-private:
- native_type m_value;
-
-public:
- duration() : m_value(0) {}
- explicit duration(native_type value) : m_value(value) {}
-
- native_type get() const { return m_value; }
-
- duration& operator+= (duration const& that)
- {
- m_value += that.m_value;
- return *this;
- }
- duration& operator-= (duration const& that)
- {
- m_value -= that.m_value;
- return *this;
- }
- duration operator- () const
- {
- return duration(-m_value);
- }
-
- friend duration operator+ (duration left, duration const& right)
- {
- left += right;
- return left;
- }
- friend duration operator- (duration left, duration const& right)
- {
- left -= right;
- return left;
- }
-};
-
-class time_point
+class system_time_point
 {
 public:
     typedef uint64_t native_type;
     // The native subsecond precision is milliseconds
- static BOOST_CONSTEXPR_OR_CONST uint64_t subsecond_fraction = duration::subsecond_fraction;
+ static BOOST_CONSTEXPR_OR_CONST uint64_t subsecond_fraction = system_duration::subsecond_fraction;
 
 private:
     native_type m_value;
 
 public:
- time_point() : m_value(0) {}
- explicit time_point(time_t t, unsigned int subsecond = 0) : m_value(static_cast< uint64_t >(t) * subsecond_fraction + subsecond)
+ system_time_point() : m_value(0) {}
+ explicit system_time_point(time_t t, unsigned int subsecond = 0) : m_value(static_cast< uint64_t >(t) * subsecond_fraction + subsecond)
     {
     }
 
     native_type const& get() const { return m_value; }
 
- static time_point now()
+ static system_time_point now()
     {
         union
         {
@@ -228,41 +191,98 @@
         // Convert to milliseconds
         caster.as_uint64 /= 10000u;
 
- time_point res;
+ system_time_point res;
         res.m_value = caster.as_uint64;
         return res;
     }
 
- time_point& operator+= (duration const& dur)
+ system_time_point& operator+= (system_duration const& dur)
     {
         m_value += dur.get();
         return *this;
     }
- time_point& operator-= (duration const& dur)
+ system_time_point& operator-= (system_duration const& dur)
     {
         m_value -= dur.get();
         return *this;
     }
 
- friend time_point operator+ (time_point left, duration const& right)
+ friend system_time_point operator+ (system_time_point left, system_duration const& right)
     {
         left += right;
         return left;
     }
- friend time_point operator- (time_point left, duration const& right)
+ friend system_time_point operator- (system_time_point left, system_duration const& right)
     {
         left -= right;
         return left;
     }
 
- friend duration operator- (time_point const& left, time_point const& right)
+ friend system_duration operator- (system_time_point const& left, system_time_point const& right)
     {
- return duration(static_cast< duration::native_type >(left.m_value - right.m_value));
+ return system_duration(static_cast< system_duration::native_type >(left.m_value - right.m_value));
     }
 };
 
 #endif
 
+template< typename TimePoint >
+class chrono_time_point :
+ public TimePoint
+{
+public:
+ typedef TimePoint time_point;
+ typedef typename time_point::clock clock;
+ typedef typename time_point::duration duration;
+
+private:
+ time_point m_value;
+
+public:
+ BOOST_DEFAULTED_FUNCTION(chrono_time_point(), : m_value() {})
+ BOOST_DEFAULTED_FUNCTION(chrono_time_point(chrono_time_point const& that), : m_value(that.m_value) {})
+
+ explicit chrono_time_point(time_point const& that) : m_value(that)
+ {
+ }
+
+ template< typename T >
+ explicit chrono_time_point(T const& arg) : base_type(arg)
+ {
+ }
+
+ time_point const& get() const { return m_value; }
+
+ static chrono_time_point now() { return chrono_time_point(clock::now()); }
+
+ chrono_time_point& operator+= (duration const& dur)
+ {
+ m_value += dur;
+ return *this;
+ }
+ chrono_time_point& operator-= (duration const& dur)
+ {
+ m_value -= dur;
+ return *this;
+ }
+
+ friend chrono_time_point operator+ (chrono_time_point left, duration const& right)
+ {
+ left.m_value += right;
+ return left;
+ }
+ friend chrono_time_point operator- (chrono_time_point left, duration const& right)
+ {
+ left.m_value -= right;
+ return left;
+ }
+
+ friend duration operator- (chrono_time_point const& left, chrono_time_point const& right)
+ {
+ return left.m_value - right.m_value;
+ }
+};
+
 } // namespace detail
 
 } // namespace sync

Modified: trunk/boost/sync/mutexes/timed_mutex.hpp
==============================================================================
--- trunk/boost/sync/mutexes/timed_mutex.hpp Sat Sep 21 12:45:07 2013 (r85810)
+++ trunk/boost/sync/mutexes/timed_mutex.hpp 2013-09-21 15:03:30 EDT (Sat, 21 Sep 2013) (r85811)
@@ -76,6 +76,8 @@
      * which can be an absolute time point or a duration. If the operation completes successfully until the timeout expires, \c true is returned.
      * Otherwise, returns \c false.
      *
+ * \param time Relative or absolute timeout. If timeout is relative, the time is measured according to the system clock.
+ *
      * \b Throws: An exception in case if the operating system is unable to fulfill the request.
      *
      * \note In order to use this method, a supplementary header must be included from boost/sync/support to enable support for particular time units.
@@ -84,6 +86,38 @@
     bool timed_lock(Time time);
 
     /*!
+ * \brief Attempts to lock the mutex within the specified timeout
+ *
+ * If the mutex is not locked, the method locks it and returns \c true. Otherwise the method blocks for up to \a time timeout,
+ * which is a duration. If the operation completes successfully until the timeout expires, \c true is returned.
+ * Otherwise, returns \c false.
+ *
+ * \param rel_timeout Relative timeout. The time is measured according to the system clock.
+ *
+ * \b Throws: An exception in case if the operating system is unable to fulfill the request.
+ *
+ * \note In order to use this method, a supplementary header must be included from boost/sync/support to enable support for particular time units.
+ */
+ template< typename Duration >
+ bool try_lock_for(Duration rel_timeout);
+
+ /*!
+ * \brief Attempts to lock the mutex within the specified timeout
+ *
+ * If the mutex is not locked, the method locks it and returns \c true. Otherwise the method blocks for up to \a time timeout,
+ * which is an absolute time point. If the operation completes successfully until the timeout expires, \c true is returned.
+ * Otherwise, returns \c false.
+ *
+ * \param abs_timeout Absolute timeout. If the time point clock is not compatible with system clock the operation may take considerably longer than the specified timeout.
+ *
+ * \b Throws: An exception in case if the operating system is unable to fulfill the request.
+ *
+ * \note In order to use this method, a supplementary header must be included from boost/sync/support to enable support for particular time units.
+ */
+ template< typename TimePoint >
+ bool try_lock_until(TimePoint abs_timeout);
+
+ /*!
      * \brief Unlocks the mutex
      *
      * Releases the mutex that has been locked by the current thread.
@@ -115,7 +149,7 @@
 #if defined(BOOST_SYNC_DETAIL_PLATFORM_PTHREAD)
 #include <boost/sync/detail/mutexes/timed_mutex_posix.hpp>
 #elif defined(BOOST_SYNC_DETAIL_PLATFORM_WINAPI)
-//#include <boost/sync/detail/mutexes/timed_mutex_windows.hpp>
+#include <boost/sync/detail/mutexes/timed_mutex_windows.hpp>
 #else
 #error Boost.Sync: Unsupported threading API
 #endif

Modified: trunk/boost/sync/support/date_time.hpp
==============================================================================
--- trunk/boost/sync/support/date_time.hpp Sat Sep 21 12:45:07 2013 (r85810)
+++ trunk/boost/sync/support/date_time.hpp 2013-09-21 15:03:30 EDT (Sat, 21 Sep 2013) (r85811)
@@ -38,16 +38,17 @@
 
     static BOOST_CONSTEXPR_OR_CONST bool is_specialized = true;
 
- static duration to_sync_unit(T const& dur)
+ static system_duration to_sync_unit(T const& dur)
     {
         typedef typename T::traits_type traits_type;
         enum
         {
- conversion_ratio = traits_type::ticks_per_second >= duration::subsecond_fraction ?
- traits_type::ticks_per_second / duration::subsecond_fraction :
- duration::subsecond_fraction / traits_type::ticks_per_second
+ conversion_ratio = traits_type::ticks_per_second >= system_duration::subsecond_fraction ?
+ traits_type::ticks_per_second / system_duration::subsecond_fraction :
+ system_duration::subsecond_fraction / traits_type::ticks_per_second
         };
- return duration(traits_type::ticks_per_second >= duration::subsecond_fraction ? dur.ticks() / conversion_ratio : dur.ticks() * conversion_ratio);
+ return system_duration(traits_type::ticks_per_second >= system_duration::subsecond_fraction ?
+ dur.ticks() / conversion_ratio : dur.ticks() * conversion_ratio);
     }
 };
 
@@ -58,7 +59,7 @@
 
     static BOOST_CONSTEXPR_OR_CONST bool is_specialized = true;
 
- static time_point to_sync_unit(T const& point)
+ static system_time_point to_sync_unit(T const& point)
     {
         typedef typename T::date_type date_type;
         typedef typename T::time_duration_type time_duration_type;
@@ -70,11 +71,12 @@
         typedef typename time_duration_type::traits_type traits_type;
         enum
         {
- conversion_ratio = traits_type::ticks_per_second >= time_point::subsecond_fraction ?
- traits_type::ticks_per_second / time_point::subsecond_fraction :
- time_point::subsecond_fraction / traits_type::ticks_per_second
+ conversion_ratio = traits_type::ticks_per_second >= system_time_point::subsecond_fraction ?
+ traits_type::ticks_per_second / system_time_point::subsecond_fraction :
+ system_time_point::subsecond_fraction / traits_type::ticks_per_second
         };
- return time_point(seconds, traits_type::ticks_per_second >= time_point::subsecond_fraction ? fractional_seconds / conversion_ratio : fractional_seconds * conversion_ratio);
+ return system_time_point(seconds, traits_type::ticks_per_second >= time_point::subsecond_fraction ?
+ fractional_seconds / conversion_ratio : fractional_seconds * conversion_ratio);
     }
 };
 

Modified: trunk/libs/sync/test/run/mutex_test.cpp
==============================================================================
--- trunk/libs/sync/test/run/mutex_test.cpp Sat Sep 21 12:45:07 2013 (r85810)
+++ trunk/libs/sync/test/run/mutex_test.cpp 2013-09-21 15:03:30 EDT (Sat, 21 Sep 2013) (r85811)
@@ -179,7 +179,7 @@
 struct test_timedlock
 {
     typedef M mutex_type;
- typedef typename M::scoped_timed_lock timed_lock_type;
+ typedef boost::sync::unique_lock< mutex_type > lock_type;
 
     static bool fake_predicate()
     {


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