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
now()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
now(system::error_code & ec)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
to_time_t(const time_point & 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
from_time_t(time_t t)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
steady_simplified()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
steady_simplified_ec(system::error_code & ec)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
compute_steady_factor(kern_return_t & err)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
steady_full()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
steady_full_ec(system::error_code & ec)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
init_steady_clock(kern_return_t & err)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
init_steady_clock_ec(kern_return_t & err)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
now()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
now(system::error_code & ec)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
243