source: src/libcfa/time@ bd87b138

ADT aaron-thesis arm-eh ast-experimental cleanup-dtors deferred_resn demangler enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox new-ast new-ast-unique-expr new-env no_list persistent-indexer pthread-emulation qualifiedEnum with_gc
Last change on this file since bd87b138 was 6ecc079, checked in by Peter A. Buhr <pabuhr@…>, 8 years ago

first draft of time package
  • Property mode set to 100644
File size: 14.8 KB
RevLine 
[6ecc079]1//
2// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// calendar --
8//
9// Author : Peter A. Buhr
10// Created On : Wed Mar 14 23:18:57 2018
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Thu Mar 22 17:11:19 2018
13// Update Count : 495
14//
15
16#pragma once
17
18// http://en.cppreference.com/w/cpp/header/chrono
19// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0355r5.html#refcc
20
21#include <time.h>
22extern "C" {
23#include <sys/time.h>
24int snprintf( char * buf, size_t size, const char * fmt, ... );
25}
26#include <fstream>
27
28enum {
29 CLOCKGRAN = 15_000_000L, // ALWAYS in nanoseconds, MUST BE less than 1 second
30 TIMEGRAN = 1_000_000_000L // nanosecond granularity, except for timeval
31};
32
33
34#if defined( REALTIME_POSIX )
35#define tv_XSEC tv_nsec
36#else
37#define tv_XSEC tv_usec
38#endif
39
40
41#if defined( __linux__ )
42// fake a few things
43#define CLOCK_REALTIME 0 // real (clock on the wall) time
44#endif
45
46// conversions for existing time types
47static inline void ?{}( timeval & t ) {}
48static inline void ?{}( timeval & t, time_t sec ) { t.tv_sec = sec; t.tv_usec = 0; }
49static inline void ?{}( timeval & t, time_t sec, suseconds_t usec ) { t.tv_sec = sec; t.tv_usec = usec; }
50
51static inline void ?{}( timespec & t ) {}
52static inline void ?{}( timespec & t, time_t sec ) { t.tv_sec = sec; t.tv_nsec = 0; }
53static inline void ?{}( timespec & t, time_t sec, __syscall_slong_t nsec ) { t.tv_sec = sec; t.tv_nsec = nsec; }
54
55static inline char * ctime( time_t tp ) { char * buf = ctime( &tp ); buf[24] = '\0'; return buf; }
56static inline char * ctime_r( time_t tp, char * buf ) { ctime_r( &tp, buf ); buf[24] = '\0'; return buf; }
57static inline tm * gmtime( time_t tp ) { return gmtime( &tp ); }
58static inline tm * gmtime_r( time_t tp, tm * result ) { return gmtime_r( &tp, result ); }
59static inline tm * localtime( time_t tp ) { return localtime( &tp ); }
60static inline tm * localtime_r( time_t tp, tm * result ) { return localtime_r( &tp, result ); }
61
62
63//######################### Duration #########################
64
65struct Duration {
66 int64_t tv;
67};
68
69static inline void ?{}( Duration & dur ) with( dur ) { tv = 0; }
70static inline void ?{}( Duration & dur, Duration d ) with( dur ) { tv = d.tv; }
71
72static inline void ?{}( Duration & dur, timeval t ) with( dur ) {
73 tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * 1000;
74} // Duration
75
76static inline void ?{}( Duration & dur, timespec t ) with( dur ) {
77 tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec;
78} // Duration
79
80static inline Duration ?=?( Duration & dur, timeval t ) with( dur ) {
81 tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * 1000;
82 return dur;
83} // ?=?
84
85static inline Duration ?=?( Duration & dur, timespec t ) with( dur ) {
86 tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec;
87 return dur;
88} // ?=? timespec
89
90static inline void ?{}( timeval & t, Duration dur ) with( dur ) {
91 t.tv_sec = tv / TIMEGRAN; // seconds
92 t.tv_usec = tv % TIMEGRAN / ( TIMEGRAN / 1000000L ); // microseconds
93} // ?{}
94
95static inline void ?{}( timespec & t, Duration dur ) with( dur ) {
96 t.tv_sec = tv / TIMEGRAN; // seconds
97 t.tv_nsec = tv % TIMEGRAN; // nanoseconds
98} // Timespec
99
100static inline int64_t nsecs( Duration dur ) with( dur ) { return tv; }
101
102static inline Duration +?( Duration rhs ) with( rhs ) { return (Duration)@{ +tv }; }
103static inline Duration ?+?( Duration & lhs, Duration rhs ) { return (Duration)@{ lhs.tv + rhs.tv }; }
104static inline Duration ?+=?( Duration & lhs, Duration rhs ) { lhs = lhs + rhs; return lhs; }
105
106static inline Duration -?( Duration rhs ) with( rhs ) { return (Duration)@{ -tv }; }
107static inline Duration ?-?( Duration & lhs, Duration rhs ) { return (Duration)@{ lhs.tv - rhs.tv }; }
108static inline Duration ?-=?( Duration & lhs, Duration rhs ) { lhs = lhs - rhs; return lhs; }
109
110static inline Duration ?*?( Duration lhs, int64_t rhs ) { return (Duration)@{ lhs.tv * rhs }; }
111static inline Duration ?*?( int64_t lhs, Duration rhs ) { return (Duration)@{ lhs * rhs.tv }; }
112static inline Duration ?*=?( Duration & lhs, int64_t rhs ) { lhs = lhs * rhs; return lhs; }
113
114static inline Duration ?/?( Duration lhs, int64_t rhs ) { return (Duration)@{ lhs.tv / rhs }; }
115static inline int64_t ?/?( Duration lhs, Duration rhs ) { return lhs.tv / rhs.tv; }
116static inline Duration ?/=?( Duration & lhs, int64_t rhs ) { lhs = lhs / rhs; return lhs; }
117
118static inline Duration ?%?( Duration lhs, int64_t rhs ) { return (Duration)@{ lhs.tv % rhs }; }
119static inline int64_t ?%?( int64_t lhs, Duration rhs ) { return lhs % (rhs.tv / TIMEGRAN); }
120static inline int64_t ?%?( Duration lhs, Duration rhs ) { return lhs.tv % rhs.tv; }
121
122static inline _Bool ?==?( Duration lhs, Duration rhs ) { return lhs.tv == rhs.tv; }
123static inline _Bool ?!=?( Duration lhs, Duration rhs ) { return lhs.tv != rhs.tv; }
124static inline _Bool ?<?( Duration lhs, Duration rhs ) { return lhs.tv < rhs.tv; }
125static inline _Bool ?<=?( Duration lhs, Duration rhs ) { return lhs.tv <= rhs.tv; }
126static inline _Bool ?>?( Duration lhs, Duration rhs ) { return lhs.tv > rhs.tv; }
127static inline _Bool ?>=?( Duration lhs, Duration rhs ) { return lhs.tv >= rhs.tv; }
128
129static inline Duration abs( Duration lhs ) {
130 return lhs.tv >= 0 ? lhs : -lhs;
131} // abs
132
133static inline forall( dtype ostype | ostream( ostype ) )
134ostype & ?|?( ostype & os, Duration dur ) with( dur ) {
135 os | tv / TIMEGRAN;
136 char buf[16];
137 snprintf( buf, 16, "%09ld", ((tv < 0 ? -tv : tv) % TIMEGRAN) );
138 int i;
139 for ( i = 8; i >= 0 && buf[i] == '0' ; i -= 1 ); // find least significant digit
140 if ( i != -1 ) { buf[i + 1] = '\0'; os | '.' | buf; }
141 return os;
142}
143
144static inline Duration ?`ns( int64_t nsec ) { return (Duration)@{ nsec }; }
145static inline Duration ?`us( int64_t usec ) { return (Duration)@{ usec * (TIMEGRAN / 1_000l) }; }
146static inline Duration ?`ms( int64_t msec ) { return (Duration)@{ msec * (TIMEGRAN / 1_000_000l) }; }
147static inline Duration ?`s ( int64_t sec ) { return (Duration)@{ sec * TIMEGRAN }; }
148static inline Duration ?`s ( double sec ) { return (Duration)@{ sec * TIMEGRAN }; }
149static inline Duration ?`m ( int64_t min ) { return (Duration)@{ min * (60L * TIMEGRAN) }; }
150static inline Duration ?`m ( double min ) { return (Duration)@{ min * (60L * TIMEGRAN) }; }
151static inline Duration ?`h ( int64_t hours ) { return (Duration)@{ hours * (3600L * TIMEGRAN) }; }
152static inline Duration ?`h ( double hours ) { return (Duration)@{ hours * (3600L * TIMEGRAN) }; }
153static inline Duration ?`d ( int64_t days ) { return (Duration)@{ days * (24L * 3600L * TIMEGRAN) }; }
154static inline Duration ?`d ( double days ) { return (Duration)@{ days * (24L * 3600L * TIMEGRAN) }; }
155static inline Duration ?`w ( int64_t weeks ) { return (Duration)@{ weeks * (7L * 24L * 3600L * TIMEGRAN) }; }
156static inline Duration ?`f ( int64_t fortnight ) { return (Duration)@{ fortnight * (14L * 24L * 3600L * TIMEGRAN) }; }
157
158static inline int64_t ?`s ( Duration dur ) { return dur.tv / TIMEGRAN; }
159static inline int64_t ?`m ( Duration dur ) { return dur.tv / (60L * TIMEGRAN); }
160static inline int64_t ?`h ( Duration dur ) { return dur.tv / (3600L * TIMEGRAN); }
161static inline int64_t ?`d ( Duration dur ) { return dur.tv / (24L * 3600L * TIMEGRAN); }
162static inline int64_t ?`w ( Duration dur ) { return dur.tv / (7L * 24L * 3600L * TIMEGRAN); }
163static inline int64_t ?`f ( Duration dur ) { return dur.tv / (14L * 24L * 3600L * TIMEGRAN); }
164
165
166//######################### Time #########################
167
168
169struct Time {
170 uint64_t tv;
171};
172
173#ifdef __CFA_DEBUG__
174#define CreateFmt "Attempt to create Time( year=%d, month=%d, day=%d, hour=%d, min=%d, sec=%d, nsec=%d ), " \
175 "which exceeds range 00:00:00 UTC, January 1, 1970 to 03:14:07 UTC, January 19, 2038."
176#endif // __CFA_DEBUG__
177
178void mktime( Time & time, int year, int month, int day, int hour, int min, int sec, int nsec ) with( time ) {
179 tm tm;
180
181// tzset(); // initialize time global variables
182 tm.tm_isdst = -1; // let mktime determine if alternate timezone is in effect
183 tm.tm_year = year - 1900; // mktime uses 1900 as its starting point
184 tm.tm_mon = month - 1;
185 tm.tm_mday = day; // mktime uses range 1-31
186 tm.tm_hour = hour;
187 tm.tm_min = min;
188 tm.tm_sec = sec;
189 time_t epochsec = mktime( &tm );
190#ifdef __CFA_DEBUG__
191 if ( epochsec == (time_t)-1 ) {
192 abort( CreateFmt, year, month, day, hour, min, sec, nsec );
193 } // if
194#endif // __CFA_DEBUG__
195 tv = (int64_t)(epochsec) * TIMEGRAN + nsec; // convert to nanoseconds
196#ifdef __CFA_DEBUG__
197 if ( tv > 2147483647LL * TIMEGRAN ) { // between 00:00:00 UTC, January 1, 1970 and 03:14:07 UTC, January 19, 2038.
198 abort( CreateFmt, year, month, day, hour, min, sec, nsec );
199 } // if
200#endif // __CFA_DEBUG__
201} // mktime
202
203static inline void ?{}( Time & t ) with( t ) {
204 tv = 0;
205} // Time
206
207// These two constructors must not call mktime because it calls malloc. The malloc calls lead to recursion problems
208// because Time values are created from the sigalrm handler in composing the next context switch event.
209
210static inline void ?{}( Time & t, int sec ) with( t ) {
211#ifdef __CFA_DEBUG__
212 if ( tv < 0 || tv > 2147483647LL ) { // between 00:00:00 UTC, January 1, 1970 and 03:14:07 UTC, January 19, 2038.
213 abort( CreateFmt, 1970, 0, 0, 0, 0, sec, 0 );
214 } // if
215#endif // __CFA_DEBUG__
216 tv = (int64_t)sec * TIMEGRAN;
217} // Time
218
219static inline void ?{}( Time & t, int sec, int nsec ) with( t ) {
220#ifdef __U_DEBUG__
221 if ( tv < 0 || tv > 2147483647LL || nsec < 0 ) { // between 00:00:00 UTC, January 1, 1970 and 03:14:07 UTC, January 19, 2038.
222 abort( CreateFmt, 1970, 0, 0, 0, 0, sec, nsec );
223 } // if
224#endif // __U_DEBUG__
225 tv = (int64_t)sec * TIMEGRAN + nsec;
226} // Time
227
228static inline void ?{}( Time & time, int min, int sec, long int nsec ) {
229 mktime( time, 1970, 1, 1, 0, min, sec, nsec );
230} // Time
231
232static inline void ?{}( Time & time, int hour, int min, int sec, long int nsec ) {
233 mktime( time, 1970, 1, 1, hour, min, sec, nsec );
234} // Time
235
236static inline void ?{}( Time & time, int day, int hour, int min, int sec, long int nsec ) {
237 mktime( time, 1970, 1, day, hour, min, sec, nsec );
238} // Time
239
240static inline void ?{}( Time & time, int month, int day, int hour, int min, int sec, long int nsec ) {
241 mktime( time, 1970, month, day, hour, min, sec, nsec );
242} // Time
243
244static inline void ?{}( Time & time, int year, int month, int day, int hour, int min, int sec, long int nsec ) {
245 mktime( time, year, month, day, hour, min, sec, nsec );
246} // Time
247
248static inline void ?{}( Time & time, timeval t ) with( time ) {
249 tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * 1000;
250} // Time
251
252static inline void ?{}( Time & time, timespec t ) with( time ) {
253 tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec;
254} // Time
255
256static inline Time ?=?( Time & time, timeval t ) with( time ) {
257 tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * 1000;
258 return time;
259} // ?=?
260
261static inline Time ?=?( Time & time, timespec t ) with( time ) {
262 tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec;
263 return time;
264} // ?=?
265
266static inline void ?{}( timeval & t, Time time ) with( time ) {
267 t.tv_sec = tv / TIMEGRAN; // seconds
268 t.tv_usec = tv % TIMEGRAN / ( TIMEGRAN / 1_000_000L ); // microseconds
269} // ?{}
270
271static inline void ?{}( timespec & t, Time time ) with( time ) {
272 t.tv_sec = tv / TIMEGRAN; // seconds
273 t.tv_nsec = tv % TIMEGRAN; // nanoseconds
274} // ?{}
275
276static inline int64_t nsec( Time time ) with( time ) { return tv; }
277
278static inline Time ?+?( Time & lhs, Duration rhs ) { return (Time)@{ lhs.tv + rhs.tv }; }
279static inline Time ?+?( Duration lhs, Time rhs ) { return rhs + lhs; }
280static inline Time ?+=?( Time & lhs, Duration rhs ) { lhs = lhs + rhs; return lhs; }
281
282static inline Duration ?-?( Time lhs, Time rhs ) { return (Duration)@{ lhs.tv - rhs.tv }; }
283static inline Time ?-?( Time lhs, Duration rhs ) { return (Time)@{ lhs.tv - rhs.tv }; }
284static inline Time ?-=?( Time & lhs, Duration rhs ) { lhs = lhs - rhs; return lhs; }
285static inline _Bool ?==?( Time lhs, Time rhs ) { return lhs.tv == rhs.tv; }
286static inline _Bool ?!=?( Time lhs, Time rhs ) { return lhs.tv != rhs.tv; }
287static inline _Bool ?<?( Time lhs, Time rhs ) { return lhs.tv < rhs.tv; }
288static inline _Bool ?<=?( Time lhs, Time rhs ) { return lhs.tv <= rhs.tv; }
289static inline _Bool ?>?( Time lhs, Time rhs ) { return lhs.tv > rhs.tv; }
290static inline _Bool ?>=?( Time lhs, Time rhs ) { return lhs.tv >= rhs.tv; }
291
292static inline char * yymmd( Time time, char * buf ) with( time ) {
293 tm tm;
294 time_t s = tv / TIMEGRAN;
295 gmtime_r( &s, &tm );
296 snprintf( buf, 9, "%02d/%02d/%02d", tm.tm_year % 99, tm.tm_mon, tm.tm_mday );
297 return buf;
298} // yymmd
299
300static inline char * mmyyd( Time time, char * buf ) with( time ) {
301 tm tm;
302 time_t s = tv / TIMEGRAN;
303 gmtime_r( &s, &tm );
304 snprintf( buf, 9, "%02d/%02d/%02d", tm.tm_mon, tm.tm_year % 99, tm.tm_mday );
305 return buf;
306} // yymmd
307
308static inline char * dmmyy( Time time, char * buf ) with( time ) {
309 tm tm;
310 time_t s = tv / TIMEGRAN;
311 gmtime_r( &s, &tm );
312 snprintf( buf, 9, "%02d/%02d/%02d", tm.tm_mday, tm.tm_mon, tm.tm_year % 99 );
313 return buf;
314} // yymmd
315
316static inline forall( dtype ostype | ostream( ostype ) )
317ostype & ?|?( ostype & os, Time time ) with( time ) {
318 char buf[32]; // at least 26
319 time_t s = tv / TIMEGRAN;
320 tm tm;
321 gmtime_r( &s, &tm ); // ctime_r adjusts for timezone
322 asctime_r( &tm, (char *)&buf );
323 buf[24] = '\0'; // remove trailing '\n'
324 long int ns = (tv < 0 ? -tv : tv) % TIMEGRAN;
325 if ( ns == 0 ) {
326 os | buf;
327 } else {
328 buf[19] = '\0';
329 os | buf;
330 char buf2[16];
331 snprintf( buf2, 16, "%09ld", ns );
332 int i;
333 for ( i = 8; i >= 0 && buf2[i] == '0' ; i -= 1 ); // find least significant digit
334 if ( i != -1 ) { buf2[i + 1] = '\0'; os | '.' | buf2; }
335 os | ' ' | &buf[20];
336 } // if
337 return os;
338} // ?|?
339
340//######################### Clock #########################
341
342
343struct Clock {
344 Duration offset; // for virtual clock: contains offset from real-time
345 int clocktype; // implementation only -1 (virtual), CLOCK_REALTIME
346};
347
348void resetClock( Clock & clk ) with( clk ) {
349 clocktype = CLOCK_REALTIME;
350} // Clock::resetClock
351
352void resetClock( Clock & clk, Duration adj ) with( clk ) {
353 clocktype = -1;
354 Duration tz = (timeval){ timezone, 0 };
355 offset = adj + tz;
356} // resetClock
357
358void ?{}( Clock & clk ) {
359 resetClock( clk );
360} // Clock
361
362void ?{}( Clock & clk, Duration adj ) {
363 resetClock( clk, adj );
364} // Clock
365
366Duration getRes() {
367 struct timespec res;
368 clock_getres( CLOCK_REALTIME, &res );
369 return (Duration){ res };
370} // getRes
371
372Time getTime() {
373 timespec curr;
374 clock_gettime( CLOCK_REALTIME_COARSE, &curr );
375 return (Time){ curr };
376} // getTime
377
378Time getTime( Clock & clk ) with( clk ) {
379 return getTime() + offset;
380} // getTime
381
382Time ?()( Clock & clk ) with( clk ) { // alternative syntax
383 return getTime() + offset;
384} // getTime
385
386timeval getTime( Clock & clk ) {
387 return (timeval){ clk() };
388} // getTime
389
390tm getTime( Clock & clk ) with( clk ) {
391 tm ret;
392 localtime_r( getTime( clk ).tv_sec, &ret );
393 return ret;
394} // getTime
395
396// Local Variables: //
397// mode: c //
398// tab-width: 4 //
399// End: //
400
Note: See TracBrowser for help on using the repository browser.