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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
|
#ifndef _XOPEN_SOURCE
#define _XOPEN_SOURCE 600
#endif
#if !defined(OS_WIN32) && (defined(_WIN32) || defined(__WIN32__) || defined(WIN32))
#define OS_WIN32
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#endif
#ifdef __APPLE__
#include <mach/clock.h>
#include <mach/mach.h>
#endif
#ifndef OS_WIN32
#include <sys/time.h>
#endif
#include "mono_time.h"
#include <stdlib.h>
#include <time.h>
#include "ccompat.h"
/* don't call into system billions of times for no reason */
struct Mono_Time {
uint64_t time;
uint64_t base_time;
};
Mono_Time *mono_time_new(void)
{
Mono_Time *monotime = (Mono_Time *)malloc(sizeof(Mono_Time));
if (monotime == nullptr) {
return nullptr;
}
monotime->time = 0;
monotime->base_time = 0;
return monotime;
}
void mono_time_free(Mono_Time *monotime)
{
free(monotime);
}
void mono_time_update(Mono_Time *monotime)
{
if (monotime->base_time == 0) {
monotime->base_time = ((uint64_t)time(nullptr) - (current_time_monotonic() / 1000ULL));
}
monotime->time = (current_time_monotonic() / 1000ULL) + monotime->base_time;
}
uint64_t mono_time_get(const Mono_Time *monotime)
{
return monotime->time;
}
bool mono_time_is_timeout(const Mono_Time *monotime, uint64_t timestamp, uint64_t timeout)
{
return timestamp + timeout <= mono_time_get(monotime);
}
//!TOKSTYLE-
// No global mutable state in Tokstyle.
static Mono_Time global_time;
//!TOKSTYLE+
/* XXX: note that this is not thread-safe; if multiple threads call unix_time_update() concurrently, the return value of
* unix_time() may fail to increase monotonically with increasing time */
void unix_time_update(void)
{
mono_time_update(&global_time);
}
uint64_t unix_time(void)
{
return mono_time_get(&global_time);
}
int is_timeout(uint64_t timestamp, uint64_t timeout)
{
return mono_time_is_timeout(&global_time, timestamp, timeout);
}
/* return current UNIX time in microseconds (us). */
uint64_t current_time_actual(void)
{
uint64_t time;
#ifdef OS_WIN32
/* This probably works fine */
FILETIME ft;
GetSystemTimeAsFileTime(&ft);
time = ft.dwHighDateTime;
time <<= 32;
time |= ft.dwLowDateTime;
time -= 116444736000000000ULL;
return time / 10;
#else
struct timeval a;
gettimeofday(&a, nullptr);
time = 1000000ULL * a.tv_sec + a.tv_usec;
return time;
#endif
}
//!TOKSTYLE-
// No global mutable state in Tokstyle.
#ifdef OS_WIN32
static uint64_t last_monotime;
static uint64_t add_monotime;
#endif
//!TOKSTYLE+
/* return current monotonic time in milliseconds (ms). */
uint64_t current_time_monotonic(void)
{
uint64_t time;
#ifdef OS_WIN32
uint64_t old_add_monotime = add_monotime;
time = (uint64_t)GetTickCount() + add_monotime;
/* Check if time has decreased because of 32 bit wrap from GetTickCount(), while avoiding false positives from race
* conditions when multiple threads call this function at once */
if (time + 0x10000 < last_monotime) {
uint32_t add = ~0;
/* use old_add_monotime rather than simply incrementing add_monotime, to handle the case that many threads
* simultaneously detect an overflow */
add_monotime = old_add_monotime + add;
time += add;
}
last_monotime = time;
#else
struct timespec monotime;
#if defined(__linux__) && defined(CLOCK_MONOTONIC_RAW)
clock_gettime(CLOCK_MONOTONIC_RAW, &monotime);
#elif defined(__APPLE__)
clock_serv_t muhclock;
mach_timespec_t machtime;
host_get_clock_service(mach_host_self(), SYSTEM_CLOCK, &muhclock);
clock_get_time(muhclock, &machtime);
mach_port_deallocate(mach_task_self(), muhclock);
monotime.tv_sec = machtime.tv_sec;
monotime.tv_nsec = machtime.tv_nsec;
#else
clock_gettime(CLOCK_MONOTONIC, &monotime);
#endif
time = 1000ULL * monotime.tv_sec + (monotime.tv_nsec / 1000000ULL);
#endif
return time;
}
|
