Browse code

Add some mac stuff

Steffen Neumann authored on 27/11/2021 17:37:38
Showing3 changed files

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
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
+}
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
+} }