[Boost-commit] svn:boost r47700 - in branches/release: boost/thread boost/thread/detail libs/thread/src/pthread libs/thread/test

From: anthony_at_[hidden]
Date: 2008-07-23 05:35:41

Author: anthonyw
Date: 2008-07-23 05:35:40 EDT (Wed, 23 Jul 2008)
New Revision: 47700
URL: http://svn.boost.org/trac/boost/changeset/47700

Log:
Merged changes over from trunk
Text files modified: 
   branches/release/boost/thread/detail/move.hpp            |     4                                         
   branches/release/boost/thread/detail/thread.hpp          |    11 +                                       
   branches/release/boost/thread/locks.hpp                  |   322 +++++++++++++++++++++++++++++---------- 
   branches/release/libs/thread/src/pthread/thread.cpp      |     4                                         
   branches/release/libs/thread/test/test_generic_locks.cpp |    10 +                                       
   5 files changed, 267 insertions(+), 84 deletions(-)

Modified: branches/release/boost/thread/detail/move.hpp
==============================================================================
--- branches/release/boost/thread/detail/move.hpp	(original)
+++ branches/release/boost/thread/detail/move.hpp	2008-07-23 05:35:40 EDT (Wed, 23 Jul 2008)
@@ -6,8 +6,10 @@
 #ifndef BOOST_THREAD_MOVE_HPP
 #define BOOST_THREAD_MOVE_HPP
 
+#ifndef BOOST_NO_SFINAE
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_convertible.hpp>
+#endif
 
 #include <boost/config/abi_prefix.hpp>
 
@@ -37,11 +39,13 @@
         };
     }
 
+#ifndef BOOST_NO_SFINAE
     template<typename T>
     typename enable_if<boost::is_convertible<T&,detail::thread_move_t<T> >, detail::thread_move_t<T> >::type move(T& t)
     {
         return t;
     }
+#endif
     
     template<typename T>
     detail::thread_move_t<T> move(detail::thread_move_t<T> t)

Modified: branches/release/boost/thread/detail/thread.hpp
==============================================================================
--- branches/release/boost/thread/detail/thread.hpp	(original)
+++ branches/release/boost/thread/detail/thread.hpp	2008-07-23 05:35:40 EDT (Wed, 23 Jul 2008)
@@ -173,15 +173,24 @@
         }
         
 #else
+#ifdef BOOST_NO_SFINAE
+        template <class F>
+        explicit thread(F f):
+            thread_info(make_thread_info(f))
+        {
+            start_thread();
+        }
+#else
         template <class F>
         explicit thread(F f,typename disable_if<boost::is_convertible<F&,detail::thread_move_t<F> >, dummy* >::type=0):
             thread_info(make_thread_info(f))
         {
             start_thread();
         }
+#endif
         
         template <class F>
-        thread(detail::thread_move_t<F> f):
+        explicit thread(detail::thread_move_t<F> f):
             thread_info(make_thread_info(f))
         {
             start_thread();

Modified: branches/release/boost/thread/locks.hpp
==============================================================================
--- branches/release/boost/thread/locks.hpp	(original)
+++ branches/release/boost/thread/locks.hpp	2008-07-23 05:35:40 EDT (Wed, 23 Jul 2008)
@@ -10,14 +10,21 @@
 #include <algorithm>
 #include <iterator>
 #include <boost/thread/thread_time.hpp>
-#include <boost/utility/enable_if.hpp>
+#include <boost/detail/workaround.hpp>
 
 #include <boost/config/abi_prefix.hpp>
 
 namespace boost
 {
     struct xtime;
-    
+
+#if defined(BOOST_NO_SFINAE) ||                           \
+    BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600)) || \
+    BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
+#define BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES
+#endif
+
+#ifndef BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES
     namespace detail
     {
         template<typename T>
@@ -79,7 +86,13 @@
                               detail::has_member_try_lock<T>::value);
         
     };
-    
+#else
+    template<typename T>
+    struct is_mutex_type
+    {
+        BOOST_STATIC_CONSTANT(bool, value = false);
+    };
+#endif    
 
     struct defer_lock_t
     {};
@@ -99,6 +112,74 @@
     class upgrade_lock;
 
     template<typename Mutex>
+    class unique_lock;
+
+    namespace detail
+    {
+        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> >
+    {
+        BOOST_STATIC_CONSTANT(bool, value = true);
+    };
+
+    template<typename T>
+    struct is_mutex_type<shared_lock<T> >
+    {
+        BOOST_STATIC_CONSTANT(bool, value = true);
+    };
+
+    template<typename T>
+    struct is_mutex_type<upgrade_lock<T> >
+    {
+        BOOST_STATIC_CONSTANT(bool, value = true);
+    };
+    
+    template<typename T>
+    struct is_mutex_type<detail::try_lock_wrapper<T> >
+    {
+        BOOST_STATIC_CONSTANT(bool, value = true);
+    };
+
+    class mutex;
+    class timed_mutex;
+    class recursive_mutex;
+    class recursive_timed_mutex;
+    class shared_mutex;
+    
+    template<>
+    struct is_mutex_type<mutex>
+    {
+        BOOST_STATIC_CONSTANT(bool, value = true);
+    };
+    template<>
+    struct is_mutex_type<timed_mutex>
+    {
+        BOOST_STATIC_CONSTANT(bool, value = true);
+    };
+    template<>
+    struct is_mutex_type<recursive_mutex>
+    {
+        BOOST_STATIC_CONSTANT(bool, value = true);
+    };
+    template<>
+    struct is_mutex_type<recursive_timed_mutex>
+    {
+        BOOST_STATIC_CONSTANT(bool, value = true);
+    };
+    template<>
+    struct is_mutex_type<shared_mutex>
+    {
+        BOOST_STATIC_CONSTANT(bool, value = true);
+    };
+
+#endif
+
+    template<typename Mutex>
     class lock_guard
     {
     private:
@@ -449,7 +530,7 @@
             std::swap(m,other.m);
             std::swap(is_locked,other.is_locked);
         }
-        void swap(boost::detail::thread_move_t<shared_lock> other)
+        void swap(boost::detail::thread_move_t<shared_lock<Mutex> > other)
         {
             std::swap(m,other->m);
             std::swap(is_locked,other->is_locked);
@@ -515,7 +596,7 @@
             is_locked=false;
         }
             
-        typedef void (shared_lock::*bool_type)();
+        typedef void (shared_lock<Mutex>::*bool_type)();
         operator bool_type() const
         {
             return is_locked?&shared_lock::lock:0;
@@ -846,7 +927,7 @@
             typedef typename base::bool_type bool_type;
             operator bool_type() const
             {
-                return static_cast<base const&>(*this);
+                return base::operator bool_type();
             }
         };
 
@@ -987,28 +1068,63 @@
         }
     }
 
-    template<typename MutexType1,typename MutexType2>
-    typename enable_if<is_mutex_type<MutexType1>, void>::type lock(MutexType1& m1,MutexType2& m2)
+    namespace detail
     {
-        unsigned const lock_count=2;
-        unsigned lock_first=0;
-        while(true)
+        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>)
         {
-            switch(lock_first)
+            unsigned const lock_count=2;
+            unsigned lock_first=0;
+            while(true)
             {
-            case 0:
-                lock_first=detail::lock_helper(m1,m2);
-                if(!lock_first)
-                    return;
-                break;
-            case 1:
-                lock_first=detail::lock_helper(m2,m1);
-                if(!lock_first)
-                    return;
-                lock_first=(lock_first+1)%lock_count;
-                break;
+                switch(lock_first)
+                {
+                case 0:
+                    lock_first=detail::lock_helper(m1,m2);
+                    if(!lock_first)
+                        return;
+                    break;
+                case 1:
+                    lock_first=detail::lock_helper(m2,m1);
+                    if(!lock_first)
+                        return;
+                    lock_first=(lock_first+1)%lock_count;
+                    break;
+                }
             }
         }
+
+        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)
+    {
+        detail::lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
+    }
+
+    template<typename MutexType1,typename MutexType2>
+    void lock(const MutexType1& m1,MutexType2& m2)
+    {
+        detail::lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
+    }
+
+    template<typename MutexType1,typename MutexType2>
+    void lock(MutexType1& m1,const MutexType2& m2)
+    {
+        detail::lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
+    }
+
+    template<typename MutexType1,typename MutexType2>
+    void lock(const MutexType1& m1,const MutexType2& m2)
+    {
+        detail::lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
     }
 
     template<typename MutexType1,typename MutexType2,typename MutexType3>
@@ -1123,10 +1239,52 @@
         }
     }
 
+    namespace detail
+    {
+        template<typename Mutex,bool x=is_mutex_type<Mutex>::value>
+        struct try_lock_impl_return
+        {
+            typedef int type;
+        };
+        
+        template<typename Iterator>
+        struct try_lock_impl_return<Iterator,false>
+        {
+            typedef Iterator type;
+        };
+
+        template<typename MutexType1,typename MutexType2>
+        int try_lock_impl(MutexType1& m1,MutexType2& m2,is_mutex_type_wrapper<true>)
+        {
+            return ((int)detail::try_lock_internal(m1,m2))-1;
+        }
+
+        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)
+    {
+        return detail::try_lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
+    }
+
+    template<typename MutexType1,typename MutexType2>
+    typename detail::try_lock_impl_return<MutexType1>::type try_lock(const MutexType1& m1,MutexType2& m2)
+    {
+        return detail::try_lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
+    }
+
+    template<typename MutexType1,typename MutexType2>
+    typename detail::try_lock_impl_return<MutexType1>::type try_lock(MutexType1& m1,const MutexType2& m2)
+    {
+        return detail::try_lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
+    }
+
     template<typename MutexType1,typename MutexType2>
-    typename enable_if<is_mutex_type<MutexType1>, int>::type try_lock(MutexType1& m1,MutexType2& m2)
+    typename detail::try_lock_impl_return<MutexType1>::type try_lock(const MutexType1& m1,const MutexType2& m2)
     {
-        return ((int)detail::try_lock_internal(m1,m2))-1;
+        return detail::try_lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>());
     }
 
     template<typename MutexType1,typename MutexType2,typename MutexType3>
@@ -1148,9 +1306,6 @@
     }
     
 
-    template<typename Iterator>
-    typename disable_if<is_mutex_type<Iterator>, void>::type lock(Iterator begin,Iterator end);
-    
     namespace detail
     {
         template<typename Iterator>
@@ -1178,70 +1333,59 @@
                 }
             }
         };
-    }
 
-    template<typename Iterator>
-    typename disable_if<is_mutex_type<Iterator>, Iterator>::type try_lock(Iterator begin,Iterator end)
-    {
-        if(begin==end)
-        {
-            return end;
-        }
-        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;
-        }
-        Iterator const failed=try_lock(++begin,end);
-        if(failed==end)
+        template<typename Iterator>
+        Iterator try_lock_impl(Iterator begin,Iterator end,is_mutex_type_wrapper<false>)
+
         {
-            guard.release();
+            if(begin==end)
+            {
+                return end;
+            }
+            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;
+            }
+            Iterator const failed=try_lock(++begin,end);
+            if(failed==end)
+            {
+                guard.release();
+            }
+            
+            return failed;
         }
-        
-        return failed;
     }
+    
 
-    template<typename Iterator>
-    typename disable_if<is_mutex_type<Iterator>, void>::type lock(Iterator begin,Iterator end)
+    namespace detail
     {
-        typedef typename std::iterator_traits<Iterator>::value_type lock_type;
-        
-        if(begin==end)
+        template<typename Iterator>
+        void lock_impl(Iterator begin,Iterator end,is_mutex_type_wrapper<false>)
         {
-            return;
-        }
-        bool start_with_begin=true;
-        Iterator second=begin;
-        ++second;
-        Iterator next=second;
+            typedef typename std::iterator_traits<Iterator>::value_type lock_type;
         
-        for(;;)
-        {
-            unique_lock<lock_type> begin_lock(*begin,defer_lock);
-            if(start_with_begin)
+            if(begin==end)
             {
-                begin_lock.lock();
-                Iterator const failed_lock=try_lock(next,end);
-                if(failed_lock==end)
-                {
-                    begin_lock.release();
-                    return;
-                }
-                start_with_begin=false;
-                next=failed_lock;
+                return;
             }
-            else
+            bool start_with_begin=true;
+            Iterator second=begin;
+            ++second;
+            Iterator next=second;
+        
+            for(;;)
             {
-                detail::range_lock_guard<Iterator> guard(next,end);
-                if(begin_lock.try_lock())
+                unique_lock<lock_type> begin_lock(*begin,defer_lock);
+                if(start_with_begin)
                 {
-                    Iterator const failed_lock=try_lock(second,next);
-                    if(failed_lock==next)
+                    begin_lock.lock();
+                    Iterator const failed_lock=try_lock(next,end);
+                    if(failed_lock==end)
                     {
                         begin_lock.release();
-                        guard.release();
                         return;
                     }
                     start_with_begin=false;
@@ -1249,16 +1393,32 @@
                 }
                 else
                 {
-                    start_with_begin=true;
-                    next=second;
+                    detail::range_lock_guard<Iterator> guard(next,end);
+                    if(begin_lock.try_lock())
+                    {
+                        Iterator const failed_lock=try_lock(second,next);
+                        if(failed_lock==next)
+                        {
+                            begin_lock.release();
+                            guard.release();
+                            return;
+                        }
+                        start_with_begin=false;
+                        next=failed_lock;
+                    }
+                    else
+                    {
+                        start_with_begin=true;
+                        next=second;
+                    }
                 }
             }
         }
+        
     }
     
 }
 
 #include <boost/config/abi_suffix.hpp>
-#include <boost/mpl/identity.hpp>
 
 #endif

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	2008-07-23 05:35:40 EDT (Wed, 23 Jul 2008)
@@ -18,7 +18,7 @@
 #elif defined(__APPLE__) || defined(__FreeBSD__)
 #include <sys/types.h>
 #include <sys/sysctl.h>
-#elif defined(__sun) || defined(__CYGWIN__)
+#elif defined BOOST_HAS_UNISTD_H
 #include <unistd.h>
 #endif
 
@@ -394,7 +394,7 @@
         int count;
         size_t size=sizeof(count);
         return sysctlbyname("hw.ncpu",&count,&size,NULL,0)?0:count;
-#elif defined(__sun) || defined(__CYGWIN__)
+#elif defined(BOOST_HAS_UNISTD_H) && defined(_SC_NPROCESSORS_ONLN)
         int const count=sysconf(_SC_NPROCESSORS_ONLN);
         return (count>0)?count:0;
 #else

Modified: branches/release/libs/thread/test/test_generic_locks.cpp
==============================================================================
--- branches/release/libs/thread/test/test_generic_locks.cpp	(original)
+++ branches/release/libs/thread/test/test_generic_locks.cpp	2008-07-23 05:35:40 EDT (Wed, 23 Jul 2008)
@@ -272,6 +272,16 @@
     }
 };
 
+namespace boost
+{
+    template<>
+    struct is_mutex_type<dummy_mutex>
+    {
+        BOOST_STATIC_CONSTANT(bool, value = true);
+    };
+}
+
+
 
 void test_lock_five_in_range()
 {