boost/thread/pthread/condition_variable.hpp

   1 #ifndef BOOST_THREAD_CONDITION_VARIABLE_PTHREAD_HPP
   2 #define BOOST_THREAD_CONDITION_VARIABLE_PTHREAD_HPP
   3 // Distributed under the Boost Software License, Version 1.0. (See
   4 // accompanying file LICENSE_1_0.txt or copy at
   5 // http://www.boost.org/LICENSE_1_0.txt)
   6 // (C) Copyright 2007-8 Anthony Williams
   7
   8 #include "timespec.hpp"
   9 #include "pthread_mutex_scoped_lock.hpp"
  10 #include "thread_data.hpp"
  11 #include "condition_variable_fwd.hpp"
  12
  13 #include <boost/config/abi_prefix.hpp>
  14
  15 namespace boost
  16 {
  17     inline void condition_variable::wait(unique_lock<mutex>& m)
  18     {
  19         detail::interruption_checker check_for_interruption(&cond);
  20         BOOST_VERIFY(!pthread_cond_wait(&cond,m.mutex()->native_handle()));
  21     }
  22
  23     inline bool condition_variable::timed_wait(unique_lock<mutex>& m,boost::system_time const& wait_until)
  24     {
  25         detail::interruption_checker check_for_interruption(&cond);
  26         struct timespec const timeout=detail::get_timespec(wait_until);
  27         int const cond_res=pthread_cond_timedwait(&cond,m.mutex()->native_handle(),&timeout);
  28         if(cond_res==ETIMEDOUT)
  29         {
  30             return false;
  31         }
  32         BOOST_ASSERT(!cond_res);
  33         return true;
  34     }
  35
  36     inline void condition_variable::notify_one()
  37     {
  38         BOOST_VERIFY(!pthread_cond_signal(&cond));
  39     }
  40
  41     inline void condition_variable::notify_all()
  42     {
  43         BOOST_VERIFY(!pthread_cond_broadcast(&cond));
  44     }
  45
  46     class condition_variable_any
  47     {
  48         pthread_mutex_t internal_mutex;
  49         pthread_cond_t cond;
  50
  51         condition_variable_any(condition_variable&);
  52         condition_variable_any& operator=(condition_variable&);
  53
  54     public:
  55         condition_variable_any()
  56         {
  57             int const res=pthread_mutex_init(&internal_mutex,NULL);
  58             if(res)
  59             {
  60                 throw thread_resource_error();
  61             }
  62             int const res2=pthread_cond_init(&cond,NULL);
  63             if(res2)
  64             {
  65                 BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
  66                 throw thread_resource_error();
  67             }
  68         }
  69         ~condition_variable_any()
  70         {
  71             BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
  72             BOOST_VERIFY(!pthread_cond_destroy(&cond));
  73         }
  74
  75         template<typename lock_type>
  76         void wait(lock_type& m)
  77         {
  78             int res=0;
  79             {
  80                 detail::interruption_checker check_for_interruption(&cond);
  81                 {
  82                     boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
  83                     m.unlock();
  84                     res=pthread_cond_wait(&cond,&internal_mutex);
  85                 }
  86                 m.lock();
  87             }
  88             if(res)
  89             {
  90                 throw condition_error();
  91             }
  92         }
  93
  94         template<typename lock_type,typename predicate_type>
  95         void wait(lock_type& m,predicate_type pred)
  96         {
  97             while(!pred()) wait(m);
  98         }
  99
 100         template<typename lock_type>
 101         bool timed_wait(lock_type& m,boost::system_time const& wait_until)
 102         {
 103             struct timespec const timeout=detail::get_timespec(wait_until);
 104             int res=0;
 105             {
 106                 detail::interruption_checker check_for_interruption(&cond);
 107                 {
 108                     boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
 109                     m.unlock();
 110                     res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout);
 111                 }
 112                 m.lock();
 113             }
 114             if(res==ETIMEDOUT)
 115             {
 116                 return false;
 117             }
 118             if(res)
 119             {
 120                 throw condition_error();
 121             }
 122             return true;
 123         }
 124         template<typename lock_type>
 125         bool timed_wait(lock_type& m,xtime const& wait_until)
 126         {
 127             return timed_wait(m,system_time(wait_until));
 128         }
 129
 130         template<typename lock_type,typename duration_type>
 131         bool timed_wait(lock_type& m,duration_type const& wait_duration)
 132         {
 133             return timed_wait(m,get_system_time()+wait_duration);
 134         }
 135
 136         template<typename lock_type,typename predicate_type>
 137         bool timed_wait(lock_type& m,boost::system_time const& wait_until,predicate_type pred)
 138         {
 139             while (!pred())
 140             {
 141                 if(!timed_wait(m, wait_until))
 142                     return pred();
 143             }
 144             return true;
 145         }
 146
 147         template<typename lock_type,typename predicate_type>
 148         bool timed_wait(lock_type& m,xtime const& wait_until,predicate_type pred)
 149         {
 150             return timed_wait(m,system_time(wait_until),pred);
 151         }
 152
 153         template<typename lock_type,typename duration_type,typename predicate_type>
 154         bool timed_wait(lock_type& m,duration_type const& wait_duration,predicate_type pred)
 155         {
 156             return timed_wait(m,get_system_time()+wait_duration,pred);
 157         }
 158
 159         void notify_one()
 160         {
 161             boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
 162             BOOST_VERIFY(!pthread_cond_signal(&cond));
 163         }
 164
 165         void notify_all()
 166         {
 167             boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
 168             BOOST_VERIFY(!pthread_cond_broadcast(&cond));
 169         }
 170     };
 171
 172 }
 173
 174 #include <boost/config/abi_suffix.hpp>
 175
 176 #endif