ceph/src/boost/boost/chrono/detail/inlined/mac/chrono.hpp

   1 //  mac/chrono.cpp  --------------------------------------------------------------//
   2
   3 //  Copyright Beman Dawes 2008
   4 //  Copyright 2009-2010 Vicente J. Botet Escriba
   5
   6 //  Distributed under the Boost Software License, Version 1.0.
   7 //  See http://www.boost.org/LICENSE_1_0.txt
   8
   9
  10 //----------------------------------------------------------------------------//
  11 //                                 Mac                                        //
  12 //----------------------------------------------------------------------------//
  13
  14 #include <sys/time.h> //for gettimeofday and timeval
  15 #include <mach/mach_time.h>  // mach_absolute_time, mach_timebase_info_data_t
  16 #include <boost/assert.hpp>
  17
  18 namespace boost
  19 {
  20 namespace chrono
  21 {
  22
  23 // system_clock
  24
  25 // gettimeofday is the most precise "system time" available on this platform.
  26 // It returns the number of microseconds since New Years 1970 in a struct called timeval
  27 // which has a field for seconds and a field for microseconds.
  28 //    Fill in the timeval and then convert that to the time_point
  29 system_clock::time_point
  30 system_clock::now() BOOST_NOEXCEPT
  31 {
  32     timeval tv;
  33     gettimeofday(&tv, 0);
  34     return time_point(seconds(tv.tv_sec) + microseconds(tv.tv_usec));
  35 }
  36
  37 #if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
  38 system_clock::time_point
  39 system_clock::now(system::error_code & ec)
  40 {
  41     timeval tv;
  42     gettimeofday(&tv, 0);
  43     if (!::boost::chrono::is_throws(ec))
  44     {
  45         ec.clear();
  46     }
  47     return time_point(seconds(tv.tv_sec) + microseconds(tv.tv_usec));
  48 }
  49 #endif
  50 // Take advantage of the fact that on this platform time_t is nothing but
  51 //    an integral count of seconds since New Years 1970 (same epoch as timeval).
  52 //    Just get the duration out of the time_point and truncate it to seconds.
  53 time_t
  54 system_clock::to_time_t(const time_point& t) BOOST_NOEXCEPT
  55 {
  56     return time_t(duration_cast<seconds>(t.time_since_epoch()).count());
  57 }
  58
  59 // Just turn the time_t into a count of seconds and construct a time_point with it.
  60 system_clock::time_point
  61 system_clock::from_time_t(time_t t) BOOST_NOEXCEPT
  62 {
  63     return system_clock::time_point(seconds(t));
  64 }
  65
  66 namespace chrono_detail
  67 {
  68
  69 // steady_clock
  70
  71 // Note, in this implementation steady_clock and high_resolution_clock
  72 //   are the same clock.  They are both based on mach_absolute_time().
  73 //   mach_absolute_time() * MachInfo.numer / MachInfo.denom is the number of
  74 //   nanoseconds since the computer booted up.  MachInfo.numer and MachInfo.denom
  75 //   are run time constants supplied by the OS.  This clock has no relationship
  76 //   to the Gregorian calendar.  It's main use is as a high resolution timer.
  77
  78 // MachInfo.numer / MachInfo.denom is often 1 on the latest equipment.  Specialize
  79 //   for that case as an optimization.
  80 BOOST_CHRONO_STATIC
  81 steady_clock::rep
  82 steady_simplified()
  83 {
  84     return mach_absolute_time();
  85 }
  86
  87 #if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
  88 BOOST_CHRONO_STATIC
  89 steady_clock::rep
  90 steady_simplified_ec(system::error_code & ec)
  91 {
  92     if (!::boost::chrono::is_throws(ec))
  93     {
  94         ec.clear();
  95     }
  96     return mach_absolute_time();
  97 }
  98 #endif
  99
 100 BOOST_CHRONO_STATIC
 101 double
 102 compute_steady_factor(kern_return_t& err)
 103 {
 104     mach_timebase_info_data_t MachInfo;
 105     err = mach_timebase_info(&MachInfo);
 106     if ( err != 0  ) {
 107         return 0;
 108     }
 109     return static_cast<double>(MachInfo.numer) / MachInfo.denom;
 110 }
 111
 112 BOOST_CHRONO_STATIC
 113 steady_clock::rep
 114 steady_full()
 115 {
 116     kern_return_t err;
 117     const double factor = chrono_detail::compute_steady_factor(err);
 118     if (err != 0)
 119     {
 120       BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
 121     }
 122     return static_cast<steady_clock::rep>(mach_absolute_time() * factor);
 123 }
 124
 125 #if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
 126 BOOST_CHRONO_STATIC
 127 steady_clock::rep
 128 steady_full_ec(system::error_code & ec)
 129 {
 130     kern_return_t err;
 131     const double factor = chrono_detail::compute_steady_factor(err);
 132     if (err != 0)
 133     {
 134         if (::boost::chrono::is_throws(ec))
 135         {
 136             boost::throw_exception(
 137                     system::system_error(
 138                             err,
 139                             ::boost::system::system_category(),
 140                             "chrono::steady_clock" ));
 141         }
 142         else
 143         {
 144             ec.assign( errno, ::boost::system::system_category() );
 145             return steady_clock::rep();
 146         }
 147     }
 148     if (!::boost::chrono::is_throws(ec))
 149     {
 150         ec.clear();
 151     }
 152     return static_cast<steady_clock::rep>(mach_absolute_time() * factor);
 153 }
 154 #endif
 155
 156 typedef steady_clock::rep (*FP)();
 157 #if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
 158 typedef steady_clock::rep (*FP_ec)(system::error_code &);
 159 #endif
 160
 161 BOOST_CHRONO_STATIC
 162 FP
 163 init_steady_clock(kern_return_t & err)
 164 {
 165     mach_timebase_info_data_t MachInfo;
 166     err = mach_timebase_info(&MachInfo);
 167     if ( err != 0  )
 168     {
 169         return 0;
 170     }
 171
 172     if (MachInfo.numer == MachInfo.denom)
 173     {
 174         return &chrono_detail::steady_simplified;
 175     }
 176     return &chrono_detail::steady_full;
 177 }
 178
 179 #if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
 180 BOOST_CHRONO_STATIC
 181 FP_ec
 182 init_steady_clock_ec(kern_return_t & err)
 183 {
 184     mach_timebase_info_data_t MachInfo;
 185     err = mach_timebase_info(&MachInfo);
 186     if ( err != 0  )
 187     {
 188         return 0;
 189     }
 190
 191     if (MachInfo.numer == MachInfo.denom)
 192     {
 193         return &chrono_detail::steady_simplified_ec;
 194     }
 195     return &chrono_detail::steady_full_ec;
 196 }
 197 #endif
 198 }
 199
 200 steady_clock::time_point
 201 steady_clock::now() BOOST_NOEXCEPT
 202 {
 203     kern_return_t err;
 204     chrono_detail::FP fp = chrono_detail::init_steady_clock(err);
 205     if ( err != 0  )
 206     {
 207       BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
 208     }
 209     return time_point(duration(fp()));
 210 }
 211
 212 #if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
 213 steady_clock::time_point
 214 steady_clock::now(system::error_code & ec)
 215 {
 216     kern_return_t err;
 217     chrono_detail::FP_ec fp = chrono_detail::init_steady_clock_ec(err);
 218     if ( err != 0  )
 219     {
 220         if (::boost::chrono::is_throws(ec))
 221         {
 222             boost::throw_exception(
 223                     system::system_error(
 224                             err,
 225                             ::boost::system::system_category(),
 226                             "chrono::steady_clock" ));
 227         }
 228         else
 229         {
 230             ec.assign( err, ::boost::system::system_category() );
 231             return time_point();
 232         }
 233     }
 234     if (!::boost::chrono::is_throws(ec))
 235     {
 236         ec.clear();
 237     }
 238     return time_point(duration(fp(ec)));
 239 }
 240 #endif
 241 }  // namespace chrono
 242 }  // namespace boost