LCOV - code coverage report
Current view: top level - usr/include/boost/thread/pthread - condition_variable_fwd.hpp (source / functions) Hit Total Coverage
Test: bitcoincash_test.info Lines: 15 18 83.3 %
Date: 2018-04-13 15:12:50 Functions: 2 2 100.0 %

          Line data    Source code
       1             : #ifndef BOOST_THREAD_PTHREAD_CONDITION_VARIABLE_FWD_HPP
       2             : #define BOOST_THREAD_PTHREAD_CONDITION_VARIABLE_FWD_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             : // (C) Copyright 2011-2012 Vicente J. Botet Escriba
       8             : 
       9             : #include <boost/assert.hpp>
      10             : #include <boost/throw_exception.hpp>
      11             : #include <pthread.h>
      12             : #include <boost/thread/cv_status.hpp>
      13             : #include <boost/thread/mutex.hpp>
      14             : #include <boost/thread/lock_types.hpp>
      15             : #include <boost/thread/thread_time.hpp>
      16             : #include <boost/thread/pthread/timespec.hpp>
      17             : #if defined BOOST_THREAD_USES_DATETIME
      18             : #include <boost/thread/xtime.hpp>
      19             : #endif
      20             : #ifdef BOOST_THREAD_USES_CHRONO
      21             : #include <boost/chrono/system_clocks.hpp>
      22             : #include <boost/chrono/ceil.hpp>
      23             : #endif
      24             : #include <boost/thread/detail/delete.hpp>
      25             : #include <boost/date_time/posix_time/posix_time_duration.hpp>
      26             : 
      27             : #include <boost/config/abi_prefix.hpp>
      28             : 
      29             : namespace boost
      30             : {
      31             : 
      32             :     class condition_variable
      33             :     {
      34             :     private:
      35             : #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
      36             :         pthread_mutex_t internal_mutex;
      37             : #endif
      38             :         pthread_cond_t cond;
      39             : 
      40             :     public:
      41             :     //private: // used by boost::thread::try_join_until
      42             : 
      43             :         inline bool do_wait_until(
      44             :             unique_lock<mutex>& lock,
      45             :             struct timespec const &timeout);
      46             : 
      47             :         bool do_wait_for(
      48             :             unique_lock<mutex>& lock,
      49             :             struct timespec const &timeout)
      50             :         {
      51             :           return do_wait_until(lock, boost::detail::timespec_plus(timeout, boost::detail::timespec_now()));
      52             :         }
      53             : 
      54             :     public:
      55             :       BOOST_THREAD_NO_COPYABLE(condition_variable)
      56         298 :         condition_variable()
      57             :         {
      58             : #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
      59         298 :             int const res=pthread_mutex_init(&internal_mutex,NULL);
      60         298 :             if(res)
      61             :             {
      62           0 :                 boost::throw_exception(thread_resource_error(res, "boost::condition_variable::condition_variable() constructor failed in pthread_mutex_init"));
      63             :             }
      64             : #endif
      65         298 :             int const res2=pthread_cond_init(&cond,NULL);
      66         298 :             if(res2)
      67             :             {
      68             : #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
      69           0 :                 BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
      70             : #endif
      71           0 :                 boost::throw_exception(thread_resource_error(res2, "boost::condition_variable::condition_variable() constructor failed in pthread_cond_init"));
      72             :             }
      73         298 :         }
      74         126 :         ~condition_variable()
      75         126 :         {
      76             :             int ret;
      77             : #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
      78             :             do {
      79         126 :               ret = pthread_mutex_destroy(&internal_mutex);
      80         126 :             } while (ret == EINTR);
      81         126 :             BOOST_ASSERT(!ret);
      82             : #endif
      83             :             do {
      84         126 :               ret = pthread_cond_destroy(&cond);
      85         126 :             } while (ret == EINTR);
      86         126 :             BOOST_ASSERT(!ret);
      87         126 :         }
      88             : 
      89             :         void wait(unique_lock<mutex>& m);
      90             : 
      91             :         template<typename predicate_type>
      92             :         void wait(unique_lock<mutex>& m,predicate_type pred)
      93             :         {
      94             :             while(!pred()) wait(m);
      95             :         }
      96             : 
      97             : 
      98             : #if defined BOOST_THREAD_USES_DATETIME
      99             :         inline bool timed_wait(
     100             :             unique_lock<mutex>& m,
     101             :             boost::system_time const& abs_time)
     102             :         {
     103             : #if defined BOOST_THREAD_WAIT_BUG
     104             :             struct timespec const timeout=detail::to_timespec(abs_time + BOOST_THREAD_WAIT_BUG);
     105             :             return do_wait_until(m, timeout);
     106             : #else
     107             :             struct timespec const timeout=detail::to_timespec(abs_time);
     108             :             return do_wait_until(m, timeout);
     109             : #endif
     110             :         }
     111             :         bool timed_wait(
     112             :             unique_lock<mutex>& m,
     113             :             xtime const& abs_time)
     114             :         {
     115             :             return timed_wait(m,system_time(abs_time));
     116             :         }
     117             : 
     118             :         template<typename duration_type>
     119             :         bool timed_wait(
     120             :             unique_lock<mutex>& m,
     121             :             duration_type const& wait_duration)
     122             :         {
     123             :             return timed_wait(m,get_system_time()+wait_duration);
     124             :         }
     125             : 
     126             :         template<typename predicate_type>
     127             :         bool timed_wait(
     128             :             unique_lock<mutex>& m,
     129             :             boost::system_time const& abs_time,predicate_type pred)
     130             :         {
     131             :             while (!pred())
     132             :             {
     133             :                 if(!timed_wait(m, abs_time))
     134             :                     return pred();
     135             :             }
     136             :             return true;
     137             :         }
     138             : 
     139             :         template<typename predicate_type>
     140             :         bool timed_wait(
     141             :             unique_lock<mutex>& m,
     142             :             xtime const& abs_time,predicate_type pred)
     143             :         {
     144             :             return timed_wait(m,system_time(abs_time),pred);
     145             :         }
     146             : 
     147             :         template<typename duration_type,typename predicate_type>
     148             :         bool timed_wait(
     149             :             unique_lock<mutex>& m,
     150             :             duration_type const& wait_duration,predicate_type pred)
     151             :         {
     152             :             return timed_wait(m,get_system_time()+wait_duration,pred);
     153             :         }
     154             : #endif
     155             : 
     156             : #ifdef BOOST_THREAD_USES_CHRONO
     157             : 
     158             :         template <class Duration>
     159             :         cv_status
     160             :         wait_until(
     161             :                 unique_lock<mutex>& lock,
     162             :                 const chrono::time_point<chrono::system_clock, Duration>& t)
     163             :         {
     164             :           using namespace chrono;
     165             :           typedef time_point<system_clock, nanoseconds> nano_sys_tmpt;
     166             :           wait_until(lock,
     167             :                         nano_sys_tmpt(ceil<nanoseconds>(t.time_since_epoch())));
     168             :           return system_clock::now() < t ? cv_status::no_timeout :
     169             :                                              cv_status::timeout;
     170             :         }
     171             : 
     172             :         template <class Clock, class Duration>
     173             :         cv_status
     174             :         wait_until(
     175             :                 unique_lock<mutex>& lock,
     176             :                 const chrono::time_point<Clock, Duration>& t)
     177             :         {
     178             :           using namespace chrono;
     179             :           system_clock::time_point     s_now = system_clock::now();
     180             :           typename Clock::time_point  c_now = Clock::now();
     181             :           wait_until(lock, s_now + ceil<nanoseconds>(t - c_now));
     182             :           return Clock::now() < t ? cv_status::no_timeout : cv_status::timeout;
     183             :         }
     184             : 
     185             :         template <class Clock, class Duration, class Predicate>
     186             :         bool
     187             :         wait_until(
     188             :                 unique_lock<mutex>& lock,
     189             :                 const chrono::time_point<Clock, Duration>& t,
     190             :                 Predicate pred)
     191             :         {
     192             :             while (!pred())
     193             :             {
     194             :                 if (wait_until(lock, t) == cv_status::timeout)
     195             :                     return pred();
     196             :             }
     197             :             return true;
     198             :         }
     199             : 
     200             : 
     201             :         template <class Rep, class Period>
     202             :         cv_status
     203             :         wait_for(
     204             :                 unique_lock<mutex>& lock,
     205             :                 const chrono::duration<Rep, Period>& d)
     206             :         {
     207             :           using namespace chrono;
     208             :           system_clock::time_point s_now = system_clock::now();
     209             :           steady_clock::time_point c_now = steady_clock::now();
     210             :           wait_until(lock, s_now + ceil<nanoseconds>(d));
     211             :           return steady_clock::now() - c_now < d ? cv_status::no_timeout :
     212             :                                                    cv_status::timeout;
     213             : 
     214             :         }
     215             : 
     216             : 
     217             :         template <class Rep, class Period, class Predicate>
     218             :         bool
     219             :         wait_for(
     220             :                 unique_lock<mutex>& lock,
     221             :                 const chrono::duration<Rep, Period>& d,
     222             :                 Predicate pred)
     223             :         {
     224             :           return wait_until(lock, chrono::steady_clock::now() + d, boost::move(pred));
     225             : 
     226             : //          while (!pred())
     227             : //          {
     228             : //              if (wait_for(lock, d) == cv_status::timeout)
     229             : //                  return pred();
     230             : //          }
     231             : //          return true;
     232             :         }
     233             : #endif
     234             : 
     235             : #define BOOST_THREAD_DEFINES_CONDITION_VARIABLE_NATIVE_HANDLE
     236             :         typedef pthread_cond_t* native_handle_type;
     237             :         native_handle_type native_handle()
     238             :         {
     239             :             return &cond;
     240             :         }
     241             : 
     242             :         void notify_one() BOOST_NOEXCEPT;
     243             :         void notify_all() BOOST_NOEXCEPT;
     244             : 
     245             : #ifdef BOOST_THREAD_USES_CHRONO
     246             :         inline cv_status wait_until(
     247             :             unique_lock<mutex>& lk,
     248             :             chrono::time_point<chrono::system_clock, chrono::nanoseconds> tp)
     249             :         {
     250             :             using namespace chrono;
     251             :             nanoseconds d = tp.time_since_epoch();
     252             :             timespec ts = boost::detail::to_timespec(d);
     253             :             if (do_wait_until(lk, ts)) return cv_status::no_timeout;
     254             :             else return cv_status::timeout;
     255             :         }
     256             : #endif
     257             :     };
     258             : 
     259             :     BOOST_THREAD_DECL void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
     260             : 
     261             : }
     262             : 
     263             : 
     264             : #include <boost/config/abi_suffix.hpp>
     265             : 
     266             : #endif

Generated by: LCOV version 1.12