1/*
2 * Copyright (c) Yann Collet, Facebook, Inc.
3 * All rights reserved.
4 *
5 * This source code is licensed under both the BSD-style license (found in the
6 * LICENSE file in the root directory of this source tree) and the GPLv2 (found
7 * in the COPYING file in the root directory of this source tree).
8 * You may select, at your option, one of the above-listed licenses.
9 */
10
11
12/* ===  Dependencies  === */
13
14#include "timefn.h"
15
16
17/*-****************************************
18*  Time functions
19******************************************/
20
21#if defined(_WIN32)   /* Windows */
22
23#include <stdlib.h>   /* abort */
24#include <stdio.h>    /* perror */
25
26UTIL_time_t UTIL_getTime(void) { UTIL_time_t x; QueryPerformanceCounter(&x); return x; }
27
28PTime UTIL_getSpanTimeMicro(UTIL_time_t clockStart, UTIL_time_t clockEnd)
29{
30    static LARGE_INTEGER ticksPerSecond;
31    static int init = 0;
32    if (!init) {
33        if (!QueryPerformanceFrequency(&ticksPerSecond)) {
34            perror("timefn::QueryPerformanceFrequency");
35            abort();
36        }
37        init = 1;
38    }
39    return 1000000ULL*(clockEnd.QuadPart - clockStart.QuadPart)/ticksPerSecond.QuadPart;
40}
41
42PTime UTIL_getSpanTimeNano(UTIL_time_t clockStart, UTIL_time_t clockEnd)
43{
44    static LARGE_INTEGER ticksPerSecond;
45    static int init = 0;
46    if (!init) {
47        if (!QueryPerformanceFrequency(&ticksPerSecond)) {
48            perror("timefn::QueryPerformanceFrequency");
49            abort();
50        }
51        init = 1;
52    }
53    return 1000000000ULL*(clockEnd.QuadPart - clockStart.QuadPart)/ticksPerSecond.QuadPart;
54}
55
56
57
58#elif defined(__APPLE__) && defined(__MACH__)
59
60UTIL_time_t UTIL_getTime(void) { return mach_absolute_time(); }
61
62PTime UTIL_getSpanTimeMicro(UTIL_time_t clockStart, UTIL_time_t clockEnd)
63{
64    static mach_timebase_info_data_t rate;
65    static int init = 0;
66    if (!init) {
67        mach_timebase_info(&rate);
68        init = 1;
69    }
70    return (((clockEnd - clockStart) * (PTime)rate.numer) / ((PTime)rate.denom))/1000ULL;
71}
72
73PTime UTIL_getSpanTimeNano(UTIL_time_t clockStart, UTIL_time_t clockEnd)
74{
75    static mach_timebase_info_data_t rate;
76    static int init = 0;
77    if (!init) {
78        mach_timebase_info(&rate);
79        init = 1;
80    }
81    return ((clockEnd - clockStart) * (PTime)rate.numer) / ((PTime)rate.denom);
82}
83
84
85/* C11 requires timespec_get, but FreeBSD 11 lacks it, while still claiming C11 compliance.
86   Android also lacks it but does define TIME_UTC. */
87#elif (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) /* C11 */) \
88    && defined(TIME_UTC) && !defined(__ANDROID__)
89
90#include <stdlib.h>   /* abort */
91#include <stdio.h>    /* perror */
92
93UTIL_time_t UTIL_getTime(void)
94{
95    /* time must be initialized, othersize it may fail msan test.
96     * No good reason, likely a limitation of timespec_get() for some target */
97    UTIL_time_t time = UTIL_TIME_INITIALIZER;
98    if (timespec_get(&time, TIME_UTC) != TIME_UTC) {
99        perror("timefn::timespec_get");
100        abort();
101    }
102    return time;
103}
104
105static UTIL_time_t UTIL_getSpanTime(UTIL_time_t begin, UTIL_time_t end)
106{
107    UTIL_time_t diff;
108    if (end.tv_nsec < begin.tv_nsec) {
109        diff.tv_sec = (end.tv_sec - 1) - begin.tv_sec;
110        diff.tv_nsec = (end.tv_nsec + 1000000000ULL) - begin.tv_nsec;
111    } else {
112        diff.tv_sec = end.tv_sec - begin.tv_sec;
113        diff.tv_nsec = end.tv_nsec - begin.tv_nsec;
114    }
115    return diff;
116}
117
118PTime UTIL_getSpanTimeMicro(UTIL_time_t begin, UTIL_time_t end)
119{
120    UTIL_time_t const diff = UTIL_getSpanTime(begin, end);
121    PTime micro = 0;
122    micro += 1000000ULL * diff.tv_sec;
123    micro += diff.tv_nsec / 1000ULL;
124    return micro;
125}
126
127PTime UTIL_getSpanTimeNano(UTIL_time_t begin, UTIL_time_t end)
128{
129    UTIL_time_t const diff = UTIL_getSpanTime(begin, end);
130    PTime nano = 0;
131    nano += 1000000000ULL * diff.tv_sec;
132    nano += diff.tv_nsec;
133    return nano;
134}
135
136
137
138#else   /* relies on standard C90 (note : clock_t measurements can be wrong when using multi-threading) */
139
140UTIL_time_t UTIL_getTime(void) { return clock(); }
141PTime UTIL_getSpanTimeMicro(UTIL_time_t clockStart, UTIL_time_t clockEnd) { return 1000000ULL * (clockEnd - clockStart) / CLOCKS_PER_SEC; }
142PTime UTIL_getSpanTimeNano(UTIL_time_t clockStart, UTIL_time_t clockEnd) { return 1000000000ULL * (clockEnd - clockStart) / CLOCKS_PER_SEC; }
143
144#endif
145
146
147
148/* returns time span in microseconds */
149PTime UTIL_clockSpanMicro(UTIL_time_t clockStart )
150{
151    UTIL_time_t const clockEnd = UTIL_getTime();
152    return UTIL_getSpanTimeMicro(clockStart, clockEnd);
153}
154
155/* returns time span in microseconds */
156PTime UTIL_clockSpanNano(UTIL_time_t clockStart )
157{
158    UTIL_time_t const clockEnd = UTIL_getTime();
159    return UTIL_getSpanTimeNano(clockStart, clockEnd);
160}
161
162void UTIL_waitForNextTick(void)
163{
164    UTIL_time_t const clockStart = UTIL_getTime();
165    UTIL_time_t clockEnd;
166    do {
167        clockEnd = UTIL_getTime();
168    } while (UTIL_getSpanTimeNano(clockStart, clockEnd) == 0);
169}
170