1. mzR
  2. Commit 86b5dcddca1e6bb52cc9bbb1ec28dbc6aed5a8a5
Browse code

Add some mac stuff

Steffen Neumann authored on 27/11/2021 17:37:38
Showing 3 changed files
src/boost/chrono/detail/inlined/mac/chrono.hpp
History View file @ 86b5dcddc
1 1 
new file mode 100755
... ... 
@@ -0,0 +1,242 @@
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
src/boost/chrono/detail/inlined/mac/process_cpu_clocks.hpp
History View file @ 86b5dcddc
0 243 
new file mode 100755
... ... 
@@ -0,0 +1,356 @@
1 
+//  boost process_cpu_clocks.cpp  -----------------------------------------------------------//
2 
+
3 
+//  Copyright Beman Dawes 1994, 2006, 2008
4 
+//  Copyright Vicente J. Botet Escriba 2009
5 
+
6 
+//  Distributed under the Boost Software License, Version 1.0.
7 
+//  See http://www.boost.org/LICENSE_1_0.txt
8 
+
9 
+//  See http://www.boost.org/libs/chrono for documentation.
10 
+
11 
+//--------------------------------------------------------------------------------------//
12 
+
13 
+#include <boost/chrono/config.hpp>
14 
+#include <boost/chrono/process_cpu_clocks.hpp>
15 
+#include <boost/assert.hpp>
16 
+
17 
+#include <sys/time.h> //for gettimeofday and timeval
18 
+#include <sys/times.h> //for times
19 
+# include <unistd.h>
20 
+
21 
+namespace boost
22 
+{
23 
+  namespace chrono
24 
+  {
25 
+    namespace chrono_detail
26 
+    {
27 
+
28 
+      inline long tick_factor() // multiplier to convert ticks
29 
+      //  to nanoseconds; -1 if unknown
30 
+      {
31 
+        long factor = 0;
32 
+        if (!factor)
33 
+        {
34 
+          if ((factor = ::sysconf(_SC_CLK_TCK)) <= 0)
35 
+            factor = -1;
36 
+          else
37 
+          {
38 
+            BOOST_ASSERT(factor <= 1000000000l); // doesn't handle large ticks
39 
+            factor = 1000000000l / factor; // compute factor
40 
+            if (!factor)
41 
+              factor = -1;
42 
+          }
43 
+        }
44 
+        return factor;
45 
+      }
46 
+    }
47 
+
48 
+
49 
+    process_real_cpu_clock::time_point process_real_cpu_clock::now() BOOST_NOEXCEPT
50 
+    {
51 
+#if 1
52 
+      tms tm;
53 
+      clock_t c = ::times(&tm);
54 
+      if (c == clock_t(-1)) // error
55 
+      {
56 
+        BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
57 
+      } else
58 
+      {
59 
+        long factor = chrono_detail::tick_factor();
60 
+        if (factor != -1)
61 
+        {
62 
+          return time_point(nanoseconds(c * factor));
63 
+        } else
64 
+        {
65 
+          BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
66 
+        }
67 
+      }
68 
+      return time_point();
69 
+#else
70 
+      clock_t c = ::clock();
71 
+      if (c == clock_t(-1)) // error
72 
+      {
73 
+        BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
74 
+      } else
75 
+      {
76 
+        long factor = chrono_detail::tick_factor();
77 
+        if (factor != -1)
78 
+        {
79 
+          return time_point(nanoseconds(c * factor));
80 
+        } else
81 
+        {
82 
+          BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
83 
+        }
84 
+      }
85 
+      return time_point();
86 
+#endif
87 
+    }
88 
+
89 
+#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
90 
+    process_real_cpu_clock::time_point process_real_cpu_clock::now(system::error_code & ec)
91 
+    {
92 
+
93 
+#if 1
94 
+      tms tm;
95 
+      clock_t c = ::times(&tm);
96 
+      if (c == clock_t(-1)) // error
97 
+      {
98 
+        if (::boost::chrono::is_throws(ec))
99 
+        {
100 
+          boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_real_cpu_clock"));
101 
+        } else
102 
+        {
103 
+          ec.assign(errno, ::boost::system::system_category());
104 
+          return time_point();
105 
+        }
106 
+      } else
107 
+      {
108 
+        long factor = chrono_detail::tick_factor();
109 
+        if (factor != -1)
110 
+        {
111 
+          if (!::boost::chrono::is_throws(ec))
112 
+          {
113 
+            ec.clear();
114 
+          }
115 
+          return time_point(nanoseconds(c * factor));
116 
+        } else
117 
+        {
118 
+          if (::boost::chrono::is_throws(ec))
119 
+          {
120 
+            boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_real_cpu_clock"));
121 
+          } else
122 
+          {
123 
+            ec.assign(errno, ::boost::system::system_category());
124 
+            return time_point();
125 
+          }
126 
+        }
127 
+      }
128 
+#else
129 
+      clock_t c = ::clock();
130 
+      if (c == clock_t(-1)) // error
131 
+      {
132 
+        if (::boost::chrono::is_throws(ec))
133 
+        {
134 
+          boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_real_cpu_clock"));
135 
+        } else
136 
+        {
137 
+          ec.assign(errno, ::boost::system::system_category());
138 
+          return time_point();
139 
+        }
140 
+      } else
141 
+      {
142 
+        long factor = chrono_detail::tick_factor();
143 
+        if (factor != -1)
144 
+        {
145 
+          if (!::boost::chrono::is_throws(ec))
146 
+          {
147 
+            ec.clear();
148 
+          }
149 
+          return time_point(nanoseconds(c * factor));
150 
+        } else
151 
+        {
152 
+          if (::boost::chrono::is_throws(ec))
153 
+          {
154 
+            boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_real_cpu_clock"));
155 
+          } else
156 
+          {
157 
+            ec.assign(errno, ::boost::system::system_category());
158 
+            return time_point();
159 
+          }
160 
+        }
161 
+      }
162 
+#endif
163 
+
164 
+    }
165 
+#endif
166 
+
167 
+#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
168 
+    process_user_cpu_clock::time_point process_user_cpu_clock::now(system::error_code & ec)
169 
+    {
170 
+      tms tm;
171 
+      clock_t c = ::times(&tm);
172 
+      if (c == clock_t(-1)) // error
173 
+      {
174 
+        if (::boost::chrono::is_throws(ec))
175 
+        {
176 
+          boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_user_cpu_clock"));
177 
+        } else
178 
+        {
179 
+          ec.assign(errno, ::boost::system::system_category());
180 
+          return time_point();
181 
+        }
182 
+      } else
183 
+      {
184 
+        long factor = chrono_detail::tick_factor();
185 
+        if (factor != -1)
186 
+        {
187 
+          if (!::boost::chrono::is_throws(ec))
188 
+          {
189 
+            ec.clear();
190 
+          }
191 
+          return time_point(nanoseconds((tm.tms_utime + tm.tms_cutime) * factor));
192 
+        } else
193 
+        {
194 
+          if (::boost::chrono::is_throws(ec))
195 
+          {
196 
+            boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_user_cpu_clock"));
197 
+          } else
198 
+          {
199 
+            ec.assign(errno, ::boost::system::system_category());
200 
+            return time_point();
201 
+          }
202 
+        }
203 
+      }
204 
+    }
205 
+#endif
206 
+
207 
+    process_user_cpu_clock::time_point process_user_cpu_clock::now() BOOST_NOEXCEPT
208 
+    {
209 
+      tms tm;
210 
+      clock_t c = ::times(&tm);
211 
+      if (c == clock_t(-1)) // error
212 
+      {
213 
+        BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
214 
+      } else
215 
+      {
216 
+        long factor = chrono_detail::tick_factor();
217 
+        if (factor != -1)
218 
+        {
219 
+          return time_point(nanoseconds((tm.tms_utime + tm.tms_cutime)
220 
+              * factor));
221 
+        } else
222 
+        {
223 
+          BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
224 
+        }
225 
+      }
226 
+      return time_point();
227 
+    }
228 
+    process_system_cpu_clock::time_point process_system_cpu_clock::now() BOOST_NOEXCEPT
229 
+    {
230 
+      tms tm;
231 
+      clock_t c = ::times(&tm);
232 
+      if (c == clock_t(-1)) // error
233 
+      {
234 
+        BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
235 
+      } else
236 
+      {
237 
+        long factor = chrono_detail::tick_factor();
238 
+        if (factor != -1)
239 
+        {
240 
+          return time_point(nanoseconds((tm.tms_stime + tm.tms_cstime)
241 
+              * factor));
242 
+        } else
243 
+        {
244 
+          BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
245 
+        }
246 
+      }
247 
+      return time_point();
248 
+    }
249 
+
250 
+#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
251 
+    process_system_cpu_clock::time_point process_system_cpu_clock::now(system::error_code & ec)
252 
+    {
253 
+      tms tm;
254 
+      clock_t c = ::times(&tm);
255 
+      if (c == clock_t(-1)) // error
256 
+      {
257 
+        if (::boost::chrono::is_throws(ec))
258 
+        {
259 
+          boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_system_cpu_clock"));
260 
+        } else
261 
+        {
262 
+          ec.assign(errno, ::boost::system::system_category());
263 
+          return time_point();
264 
+        }
265 
+      } else
266 
+      {
267 
+        long factor = chrono_detail::tick_factor();
268 
+        if (factor != -1)
269 
+        {
270 
+          if (!::boost::chrono::is_throws(ec))
271 
+          {
272 
+            ec.clear();
273 
+          }
274 
+          return time_point(nanoseconds((tm.tms_stime + tm.tms_cstime) * factor));
275 
+        } else
276 
+        {
277 
+          if (::boost::chrono::is_throws(ec))
278 
+          {
279 
+            boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_system_cpu_clock"));
280 
+          } else
281 
+          {
282 
+            ec.assign(errno, ::boost::system::system_category());
283 
+            return time_point();
284 
+          }
285 
+        }
286 
+      }
287 
+    }
288 
+#endif
289 
+
290 
+    process_cpu_clock::time_point process_cpu_clock::now() BOOST_NOEXCEPT
291 
+    {
292 
+      tms tm;
293 
+      clock_t c = ::times(&tm);
294 
+      if (c == clock_t(-1)) // error
295 
+      {
296 
+        BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
297 
+      } else
298 
+      {
299 
+        long factor = chrono_detail::tick_factor();
300 
+        if (factor != -1)
301 
+        {
302 
+          time_point::rep
303 
+              r(c * factor, (tm.tms_utime + tm.tms_cutime) * factor, (tm.tms_stime
304 
+                  + tm.tms_cstime) * factor);
305 
+          return time_point(duration(r));
306 
+        } else
307 
+        {
308 
+          BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
309 
+        }
310 
+      }
311 
+      return time_point();
312 
+    }
313 
+
314 
+#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
315 
+    process_cpu_clock::time_point process_cpu_clock::now(system::error_code & ec)
316 
+    {
317 
+
318 
+      tms tm;
319 
+      clock_t c = ::times(&tm);
320 
+      if (c == clock_t(-1)) // error
321 
+      {
322 
+        if (::boost::chrono::is_throws(ec))
323 
+        {
324 
+          boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_clock"));
325 
+        } else
326 
+        {
327 
+          ec.assign(errno, ::boost::system::system_category());
328 
+          return time_point();
329 
+        }
330 
+      } else
331 
+      {
332 
+        long factor = chrono_detail::tick_factor();
333 
+        if (factor != -1)
334 
+        {
335 
+          time_point::rep
336 
+              r(c * factor, (tm.tms_utime + tm.tms_cutime) * factor, (tm.tms_stime
337 
+                  + tm.tms_cstime) * factor);
338 
+          return time_point(duration(r));
339 
+        } else
340 
+        {
341 
+          if (::boost::chrono::is_throws(ec))
342 
+          {
343 
+            boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_clock"));
344 
+          } else
345 
+          {
346 
+            ec.assign(errno, ::boost::system::system_category());
347 
+            return time_point();
348 
+          }
349 
+        }
350 
+      }
351 
+
352 
+    }
353 
+#endif
354 
+
355 
+  }
356 
+}
src/boost/chrono/detail/inlined/mac/thread_clock.hpp
History View file @ 86b5dcddc
0 357 
new file mode 100755
... ... 
@@ -0,0 +1,92 @@
1 
+//  boost thread_clock.cpp  -----------------------------------------------------------//
2 
+
3 
+//  Copyright Beman Dawes 1994, 2006, 2008
4 
+//  Copyright Vicente J. Botet Escriba 2009-2011
5 
+//  Copyright Christopher Brown 2013
6 
+
7 
+//  Distributed under the Boost Software License, Version 1.0.
8 
+//  See http://www.boost.org/LICENSE_1_0.txt
9 
+
10 
+//  See http://www.boost.org/libs/chrono for documentation.
11 
+
12 
+//--------------------------------------------------------------------------------------//
13 
+
14 
+#include <boost/chrono/config.hpp>
15 
+#include <boost/chrono/thread_clock.hpp>
16 
+#include <cassert>
17 
+#include <boost/assert.hpp>
18 
+
19 
+# include <pthread.h>
20 
+# include <mach/thread_act.h>
21 
+
22 
+namespace boost { namespace chrono {
23 
+
24 
+    thread_clock::time_point thread_clock::now( ) BOOST_NOEXCEPT
25 
+    {
26 
+        // get the thread port (borrowing pthread's reference)
27 
+        mach_port_t port = pthread_mach_thread_np(pthread_self());
28 
+
29 
+        // get the thread info
30 
+        thread_basic_info_data_t info;
31 
+        mach_msg_type_number_t count = THREAD_BASIC_INFO_COUNT;
32 
+        if ( thread_info(port, THREAD_BASIC_INFO, (thread_info_t)&info, &count) != KERN_SUCCESS )
33 
+        {
34 
+            BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
35 
+            return time_point();
36 
+        }
37 
+
38 
+        // convert to nanoseconds
39 
+        duration user = duration(
40 
+                static_cast<thread_clock::rep>( info.user_time.seconds ) * 1000000000
41 
+                        + static_cast<thread_clock::rep>(info.user_time.microseconds ) * 1000);
42 
+
43 
+        duration system = duration(
44 
+                static_cast<thread_clock::rep>( info.system_time.seconds ) * 1000000000
45 
+                        + static_cast<thread_clock::rep>( info.system_time.microseconds ) * 1000);
46 
+
47 
+        return time_point( user + system );
48 
+    }
49 
+
50 
+#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
51 
+    thread_clock::time_point thread_clock::now( system::error_code & ec )
52 
+    {
53 
+        // get the thread port (borrowing pthread's reference)
54 
+        mach_port_t port = pthread_mach_thread_np(pthread_self());
55 
+
56 
+        // get the thread info
57 
+        thread_basic_info_data_t info;
58 
+        mach_msg_type_number_t count = THREAD_BASIC_INFO_COUNT;
59 
+        if ( thread_info(port, THREAD_BASIC_INFO, (thread_info_t)&info, &count) != KERN_SUCCESS )
60 
+        {
61 
+            if (::boost::chrono::is_throws(ec))
62 
+            {
63 
+                boost::throw_exception(
64 
+                        system::system_error(
65 
+                                EINVAL,
66 
+                                ::boost::system::system_category(),
67 
+                                "chrono::thread_clock" ));
68 
+            }
69 
+            else
70 
+            {
71 
+                ec.assign( errno, ::boost::system::system_category() );
72 
+                return time_point();
73 
+            }
74 
+        }
75 
+        if (!::boost::chrono::is_throws(ec))
76 
+        {
77 
+            ec.clear();
78 
+        }
79 
+
80 
+        // convert to nanoseconds
81 
+        duration user = duration(
82 
+                static_cast<thread_clock::rep>( info.user_time.seconds ) * 1000000000
83 
+                        + static_cast<thread_clock::rep>(info.user_time.microseconds ) * 1000);
84 
+
85 
+        duration system = duration(
86 
+                static_cast<thread_clock::rep>( info.system_time.seconds ) * 1000000000
87 
+                        + static_cast<thread_clock::rep>( info.system_time.microseconds ) * 1000);
88 
+
89 
+        return time_point( user + system );
90 
+    }
91 
+#endif
92 
+} }