Annotation of embedaddon/curl/lib/timeval.c, revision 1.1
1.1 ! misho 1: /***************************************************************************
! 2: * _ _ ____ _
! 3: * Project ___| | | | _ \| |
! 4: * / __| | | | |_) | |
! 5: * | (__| |_| | _ <| |___
! 6: * \___|\___/|_| \_\_____|
! 7: *
! 8: * Copyright (C) 1998 - 2020, Daniel Stenberg, <daniel@haxx.se>, et al.
! 9: *
! 10: * This software is licensed as described in the file COPYING, which
! 11: * you should have received as part of this distribution. The terms
! 12: * are also available at https://curl.haxx.se/docs/copyright.html.
! 13: *
! 14: * You may opt to use, copy, modify, merge, publish, distribute and/or sell
! 15: * copies of the Software, and permit persons to whom the Software is
! 16: * furnished to do so, under the terms of the COPYING file.
! 17: *
! 18: * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
! 19: * KIND, either express or implied.
! 20: *
! 21: ***************************************************************************/
! 22:
! 23: #include "timeval.h"
! 24:
! 25: #if defined(WIN32) && !defined(MSDOS)
! 26:
! 27: /* set in win32_init() */
! 28: extern LARGE_INTEGER Curl_freq;
! 29: extern bool Curl_isVistaOrGreater;
! 30:
! 31: /* In case of bug fix this function has a counterpart in tool_util.c */
! 32: struct curltime Curl_now(void)
! 33: {
! 34: struct curltime now;
! 35: if(Curl_isVistaOrGreater) { /* QPC timer might have issues pre-Vista */
! 36: LARGE_INTEGER count;
! 37: QueryPerformanceCounter(&count);
! 38: now.tv_sec = (time_t)(count.QuadPart / Curl_freq.QuadPart);
! 39: now.tv_usec = (int)((count.QuadPart % Curl_freq.QuadPart) * 1000000 /
! 40: Curl_freq.QuadPart);
! 41: }
! 42: else {
! 43: /* Disable /analyze warning that GetTickCount64 is preferred */
! 44: #if defined(_MSC_VER)
! 45: #pragma warning(push)
! 46: #pragma warning(disable:28159)
! 47: #endif
! 48: DWORD milliseconds = GetTickCount();
! 49: #if defined(_MSC_VER)
! 50: #pragma warning(pop)
! 51: #endif
! 52:
! 53: now.tv_sec = milliseconds / 1000;
! 54: now.tv_usec = (milliseconds % 1000) * 1000;
! 55: }
! 56: return now;
! 57: }
! 58:
! 59: #elif defined(HAVE_CLOCK_GETTIME_MONOTONIC)
! 60:
! 61: struct curltime Curl_now(void)
! 62: {
! 63: /*
! 64: ** clock_gettime() is granted to be increased monotonically when the
! 65: ** monotonic clock is queried. Time starting point is unspecified, it
! 66: ** could be the system start-up time, the Epoch, or something else,
! 67: ** in any case the time starting point does not change once that the
! 68: ** system has started up.
! 69: */
! 70: #ifdef HAVE_GETTIMEOFDAY
! 71: struct timeval now;
! 72: #endif
! 73: struct curltime cnow;
! 74: struct timespec tsnow;
! 75:
! 76: /*
! 77: ** clock_gettime() may be defined by Apple's SDK as weak symbol thus
! 78: ** code compiles but fails during run-time if clock_gettime() is
! 79: ** called on unsupported OS version.
! 80: */
! 81: #if defined(__APPLE__) && (HAVE_BUILTIN_AVAILABLE == 1)
! 82: bool have_clock_gettime = FALSE;
! 83: if(__builtin_available(macOS 10.12, iOS 10, tvOS 10, watchOS 3, *))
! 84: have_clock_gettime = TRUE;
! 85: #endif
! 86:
! 87: if(
! 88: #if defined(__APPLE__) && (HAVE_BUILTIN_AVAILABLE == 1)
! 89: have_clock_gettime &&
! 90: #endif
! 91: (0 == clock_gettime(CLOCK_MONOTONIC, &tsnow))) {
! 92: cnow.tv_sec = tsnow.tv_sec;
! 93: cnow.tv_usec = (unsigned int)(tsnow.tv_nsec / 1000);
! 94: }
! 95: /*
! 96: ** Even when the configure process has truly detected monotonic clock
! 97: ** availability, it might happen that it is not actually available at
! 98: ** run-time. When this occurs simply fallback to other time source.
! 99: */
! 100: #ifdef HAVE_GETTIMEOFDAY
! 101: else {
! 102: (void)gettimeofday(&now, NULL);
! 103: cnow.tv_sec = now.tv_sec;
! 104: cnow.tv_usec = (unsigned int)now.tv_usec;
! 105: }
! 106: #else
! 107: else {
! 108: cnow.tv_sec = time(NULL);
! 109: cnow.tv_usec = 0;
! 110: }
! 111: #endif
! 112: return cnow;
! 113: }
! 114:
! 115: #elif defined(HAVE_MACH_ABSOLUTE_TIME)
! 116:
! 117: #include <stdint.h>
! 118: #include <mach/mach_time.h>
! 119:
! 120: struct curltime Curl_now(void)
! 121: {
! 122: /*
! 123: ** Monotonic timer on Mac OS is provided by mach_absolute_time(), which
! 124: ** returns time in Mach "absolute time units," which are platform-dependent.
! 125: ** To convert to nanoseconds, one must use conversion factors specified by
! 126: ** mach_timebase_info().
! 127: */
! 128: static mach_timebase_info_data_t timebase;
! 129: struct curltime cnow;
! 130: uint64_t usecs;
! 131:
! 132: if(0 == timebase.denom)
! 133: (void) mach_timebase_info(&timebase);
! 134:
! 135: usecs = mach_absolute_time();
! 136: usecs *= timebase.numer;
! 137: usecs /= timebase.denom;
! 138: usecs /= 1000;
! 139:
! 140: cnow.tv_sec = usecs / 1000000;
! 141: cnow.tv_usec = (int)(usecs % 1000000);
! 142:
! 143: return cnow;
! 144: }
! 145:
! 146: #elif defined(HAVE_GETTIMEOFDAY)
! 147:
! 148: struct curltime Curl_now(void)
! 149: {
! 150: /*
! 151: ** gettimeofday() is not granted to be increased monotonically, due to
! 152: ** clock drifting and external source time synchronization it can jump
! 153: ** forward or backward in time.
! 154: */
! 155: struct timeval now;
! 156: struct curltime ret;
! 157: (void)gettimeofday(&now, NULL);
! 158: ret.tv_sec = now.tv_sec;
! 159: ret.tv_usec = (int)now.tv_usec;
! 160: return ret;
! 161: }
! 162:
! 163: #else
! 164:
! 165: struct curltime Curl_now(void)
! 166: {
! 167: /*
! 168: ** time() returns the value of time in seconds since the Epoch.
! 169: */
! 170: struct curltime now;
! 171: now.tv_sec = time(NULL);
! 172: now.tv_usec = 0;
! 173: return now;
! 174: }
! 175:
! 176: #endif
! 177:
! 178: /*
! 179: * Returns: time difference in number of milliseconds. For too large diffs it
! 180: * returns max value.
! 181: *
! 182: * @unittest: 1323
! 183: */
! 184: timediff_t Curl_timediff(struct curltime newer, struct curltime older)
! 185: {
! 186: timediff_t diff = (timediff_t)newer.tv_sec-older.tv_sec;
! 187: if(diff >= (TIMEDIFF_T_MAX/1000))
! 188: return TIMEDIFF_T_MAX;
! 189: else if(diff <= (TIMEDIFF_T_MIN/1000))
! 190: return TIMEDIFF_T_MIN;
! 191: return diff * 1000 + (newer.tv_usec-older.tv_usec)/1000;
! 192: }
! 193:
! 194: /*
! 195: * Returns: time difference in number of microseconds. For too large diffs it
! 196: * returns max value.
! 197: */
! 198: timediff_t Curl_timediff_us(struct curltime newer, struct curltime older)
! 199: {
! 200: timediff_t diff = (timediff_t)newer.tv_sec-older.tv_sec;
! 201: if(diff >= (TIMEDIFF_T_MAX/1000000))
! 202: return TIMEDIFF_T_MAX;
! 203: else if(diff <= (TIMEDIFF_T_MIN/1000000))
! 204: return TIMEDIFF_T_MIN;
! 205: return diff * 1000000 + newer.tv_usec-older.tv_usec;
! 206: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to timeval.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / lib