Subject: [Boost-commit] svn:boost r81088 - trunk/boost/thread
From: vicente.botet_at_[hidden]
Date: 2012-10-28 21:12:57
Author: viboes
Date: 2012-10-28 21:12:57 EDT (Sun, 28 Oct 2012)
New Revision: 81088
URL: http://svn.boost.org/trac/boost/changeset/81088
Log:
Thread: Added testable_mutex
Added:
trunk/boost/thread/is_locked_by_this_thread.hpp (contents, props changed)
trunk/boost/thread/testable_mutex.hpp (contents, props changed)
Added: trunk/boost/thread/is_locked_by_this_thread.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/thread/is_locked_by_this_thread.hpp 2012-10-28 21:12:57 EDT (Sun, 28 Oct 2012)
@@ -0,0 +1,39 @@
+// (C) Copyright 2012 Vicente J. Botet Escriba
+// 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)
+
+
+#ifndef BOOST_THREAD_IS_LOCKED_BY_THIS_THREAD_HPP
+#define BOOST_THREAD_IS_LOCKED_BY_THIS_THREAD_HPP
+
+#include <boost/thread/detail/config.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+ template <typename Lockable>
+ class testable_mutex;
+
+ /**
+ * Overloaded function used to check if the mutex is locked when it is testable and do nothing otherwise.
+ *
+ * This function is used usually to assert the pre-condition when the function can only be called when the mutex
+ * must be locked by the current thread.
+ */
+ template <typename Lockable>
+ bool is_locked_by_this_thread(testable_mutex<Lockable> const& mtx)
+ {
+ return mtx.is_locked();
+ }
+ template <typename Lockable>
+ bool is_locked_by_this_thread(Lockable const&)
+ {
+ return true;
+ }
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif // header
Added: trunk/boost/thread/testable_mutex.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/thread/testable_mutex.hpp 2012-10-28 21:12:57 EDT (Sun, 28 Oct 2012)
@@ -0,0 +1,142 @@
+// (C) Copyright 2012 Vicente J. Botet Escriba
+// 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)
+
+
+#ifndef BOOST_THREAD_TESTABLE_LOCKABLE_HPP
+#define BOOST_THREAD_TESTABLE_LOCKABLE_HPP
+
+#include <boost/thread/detail/config.hpp>
+
+#include <boost/thread/detail/thread.hpp>
+
+#include <boost/atomic.hpp>
+#include <boost/assert.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+ /**
+ * Based on Associate Mutexes with Data to Prevent Races, By Herb Sutter, May 13, 2010
+ * http://www.drdobbs.com/windows/associate-mutexes-with-data-to-prevent-r/224701827?pgno=3
+ *
+ * Make our mutex testable if it isn't already.
+ *
+ * Many mutex services (including boost::mutex) don't provide a way to ask,
+ * "Do I already hold a lock on this mutex?"
+ * Sometimes it is needed to know if a method like is_held to be available.
+ * This wrapper associates an arbitrary lockable type with a thread id that stores the ID of the thread that
+ * currently holds the lockable. The thread id initially holds an invalid value that means no threads own the mutex.
+ * When we acquire a lock, we set the thread id; and when we release a lock, we reset it back to its default no id state.
+ *
+ */
+ template <typename Lockable>
+ class testable_mutex
+ {
+ Lockable mtx_;
+ atomic<thread::id> id_;
+ public:
+ /// the type of the wrapped lockable
+ typedef Lockable lockable_type;
+
+ /// Non copyable
+ BOOST_THREAD_NO_COPYABLE(testable_mutex)
+
+ void lock()
+ {
+ mtx_.lock();
+ id_ = this_thread::get_id();
+ }
+
+ void unlock()
+ {
+ BOOST_ASSERT(is_locked(mtx_));
+ id_ = thread::id();
+ mtx_.unlock();
+ }
+
+ bool try_lock()
+ {
+ if (mtx_.try_lock())
+ {
+ id_ = this_thread::get_id();
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+ }
+#ifdef BOOST_THREAD_USES_CHRONO
+ template <class Rep, class Period>
+ bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
+ {
+ if (mtx_.try_lock_for(rel_time))
+ {
+ id_ = this_thread::get_id();
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+ }
+ template <class Clock, class Duration>
+ bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time)
+ {
+ if (mtx_.try_lock_until(abs_time))
+ {
+ id_ = this_thread::get_id();
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+ }
+#endif
+
+ bool is_locked_by_this_thread()
+ {
+ return this_thread::get_id() == id_;
+ }
+
+ bool get_id()
+ {
+ return id_;
+ }
+
+ // todo add the shared and upgrade mutex functions
+ };
+
+ template <typename Lockable>
+ struct is_testable_lockable : false_type
+ {};
+
+ template <typename Lockable>
+ struct is_testable_lockable<testable_mutex<Lockable> > : true_type
+ {};
+
+// /**
+// * Overloaded function used to check if the mutex is locked when it is testable and do nothing otherwise.
+// *
+// * This function is used usually to assert the pre-condition when the function can only be called when the mutex
+// * must be locked by the current thread.
+// */
+// template <typename Lockable>
+// bool is_locked_by_this_thread(testable_mutex<Lockable> const& mtx)
+// {
+// return mtx.is_locked();
+// }
+// template <typename Lockable>
+// bool is_locked_by_this_thread(Lockable const&)
+// {
+// return true;
+// }
+}
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif // header