1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
#include "common.h"
#ifndef HAVE_CLOCK_GETTIME
inline int clock_gettime(clockid_t clk_id, struct timespec *ts) {
struct timeval tv;
if(unlikely(gettimeofday(&tv, NULL) == -1))
return -1;
ts->tv_sec = tv.tv_sec;
ts->tv_nsec = (tv.tv_usec % USEC_PER_SEC) * NSEC_PER_USEC;
return 0;
}
#endif
static inline time_t now_sec(clockid_t clk_id) {
struct timespec ts;
if(unlikely(clock_gettime(clk_id, &ts) == -1))
return 0;
return ts.tv_sec;
}
static inline usec_t now_usec(clockid_t clk_id) {
struct timespec ts;
if(unlikely(clock_gettime(clk_id, &ts) == -1))
return 0;
return (usec_t)ts.tv_sec * USEC_PER_SEC + (ts.tv_nsec % NSEC_PER_SEC) / NSEC_PER_USEC;
}
static inline int now_timeval(clockid_t clk_id, struct timeval *tv) {
struct timespec ts;
if(unlikely(clock_gettime(clk_id, &ts) == -1)) {
tv->tv_sec = 0;
tv->tv_usec = 0;
return -1;
}
tv->tv_sec = ts.tv_sec;
tv->tv_usec = (suseconds_t)((ts.tv_nsec % NSEC_PER_SEC) / NSEC_PER_USEC);
return 0;
}
inline time_t now_realtime_sec(void) {
return now_sec(CLOCK_REALTIME);
}
inline usec_t now_realtime_usec(void) {
return now_usec(CLOCK_REALTIME);
}
inline int now_realtime_timeval(struct timeval *tv) {
return now_timeval(CLOCK_REALTIME, tv);
}
inline time_t now_monotonic_sec(void) {
return now_sec(CLOCK_MONOTONIC);
}
inline usec_t now_monotonic_usec(void) {
return now_usec(CLOCK_MONOTONIC);
}
inline int now_monotonic_timeval(struct timeval *tv) {
return now_timeval(CLOCK_MONOTONIC, tv);
}
inline time_t now_boottime_sec(void) {
return now_sec(CLOCK_BOOTTIME);
}
inline usec_t now_boottime_usec(void) {
return now_usec(CLOCK_BOOTTIME);
}
inline int now_boottime_timeval(struct timeval *tv) {
return now_timeval(CLOCK_BOOTTIME, tv);
}
inline usec_t timeval_usec(struct timeval *tv) {
return (usec_t)tv->tv_sec * USEC_PER_SEC + (tv->tv_usec % USEC_PER_SEC);
}
inline msec_t timeval_msec(struct timeval *tv) {
return (msec_t)tv->tv_sec * MSEC_PER_SEC + ((tv->tv_usec % USEC_PER_SEC) / MSEC_PER_SEC);
}
inline susec_t dt_usec_signed(struct timeval *now, struct timeval *old) {
usec_t ts1 = timeval_usec(now);
usec_t ts2 = timeval_usec(old);
if(likely(ts1 >= ts2)) return (susec_t)(ts1 - ts2);
return -((susec_t)(ts2 - ts1));
}
inline usec_t dt_usec(struct timeval *now, struct timeval *old) {
usec_t ts1 = timeval_usec(now);
usec_t ts2 = timeval_usec(old);
return (ts1 > ts2) ? (ts1 - ts2) : (ts2 - ts1);
}
inline void heartbeat_init(heartbeat_t *hb)
{
*hb = 0ULL;
}
usec_t heartbeat_next(heartbeat_t *hb, usec_t tick)
{
heartbeat_t now = now_monotonic_usec();
usec_t next = now - (now % tick) + tick;
while(now < next) {
sleep_usec(next - now);
now = now_monotonic_usec();
}
if(likely(*hb != 0ULL)) {
usec_t dt = now - *hb;
*hb = now;
if(unlikely(dt >= tick + tick / 2)) {
errno = 0;
error("heartbeat missed %llu microseconds", dt - tick);
}
return dt;
}
else {
*hb = now;
return 0ULL;
}
}
inline usec_t heartbeat_dt_usec(heartbeat_t *hb)
{
if(!*hb)
return 0ULL;
return now_monotonic_usec() - *hb;
}
|
