diff --git a/src/clock.cpp b/src/clock.cpp index f0a29ad01e..209da7f3a6 100644 --- a/src/clock.cpp +++ b/src/clock.cpp @@ -1,13 +1,14 @@ /* SPDX-License-Identifier: MPL-2.0 */ -#include "precompiled.hpp" #include "clock.hpp" -#include "likely.hpp" + +#include + #include "config.hpp" #include "err.hpp" +#include "likely.hpp" #include "mutex.hpp" - -#include +#include "precompiled.hpp" #if defined _MSC_VER #if defined _WIN32_WCE @@ -33,70 +34,71 @@ #endif #if defined ZMQ_HAVE_OSX -int alt_clock_gettime (int clock_id, timespec *ts) -{ - clock_serv_t cclock; - mach_timespec_t mts; - host_get_clock_service (mach_host_self (), clock_id, &cclock); - clock_get_time (cclock, &mts); - mach_port_deallocate (mach_task_self (), cclock); - ts->tv_sec = mts.tv_sec; - ts->tv_nsec = mts.tv_nsec; - return 0; +int alt_clock_gettime(int clock_id, timespec* ts) { + clock_serv_t cclock; + mach_timespec_t mts; + kern_return_t kr; + + kr = host_get_clock_service(mach_host_self(), clock_id, &cclock); + if (kr == KERN_SUCCESS) { + kr = clock_get_time(cclock, &mts); + mach_port_deallocate(mach_task_self(), cclock); + } + + if (kr != KERN_SUCCESS) return -1; + + ts->tv_sec = mts.tv_sec; + ts->tv_nsec = mts.tv_nsec; + return 0; } #endif #ifdef ZMQ_HAVE_WINDOWS -typedef ULONGLONG (*f_compatible_get_tick_count64) (); +typedef ULONGLONG (*f_compatible_get_tick_count64)(); static zmq::mutex_t compatible_get_tick_count64_mutex; -ULONGLONG compatible_get_tick_count64 () -{ +ULONGLONG compatible_get_tick_count64() { #ifdef ZMQ_HAVE_WINDOWS_UWP - const ULONGLONG result = ::GetTickCount64 (); - return result; + const ULONGLONG result = ::GetTickCount64(); + return result; #else - zmq::scoped_lock_t locker (compatible_get_tick_count64_mutex); + zmq::scoped_lock_t locker(compatible_get_tick_count64_mutex); - static DWORD s_wrap = 0; - static DWORD s_last_tick = 0; - const DWORD current_tick = ::GetTickCount (); + static DWORD s_wrap = 0; + static DWORD s_last_tick = 0; + const DWORD current_tick = ::GetTickCount(); - if (current_tick < s_last_tick) - ++s_wrap; + if (current_tick < s_last_tick) ++s_wrap; - s_last_tick = current_tick; - const ULONGLONG result = (static_cast (s_wrap) << 32) - + static_cast (current_tick); + s_last_tick = current_tick; + const ULONGLONG result = (static_cast(s_wrap) << 32) + + static_cast(current_tick); - return result; + return result; #endif } -f_compatible_get_tick_count64 init_compatible_get_tick_count64 () -{ - f_compatible_get_tick_count64 func = NULL; +f_compatible_get_tick_count64 init_compatible_get_tick_count64() { + f_compatible_get_tick_count64 func = NULL; #if !defined ZMQ_HAVE_WINDOWS_UWP - const HMODULE module = ::LoadLibraryA ("Kernel32.dll"); - if (module != NULL) - func = reinterpret_cast ( - ::GetProcAddress (module, "GetTickCount64")); + const HMODULE module = ::LoadLibraryA("Kernel32.dll"); + if (module != NULL) + func = reinterpret_cast( + ::GetProcAddress(module, "GetTickCount64")); #endif - if (func == NULL) - func = compatible_get_tick_count64; + if (func == NULL) func = compatible_get_tick_count64; #if !defined ZMQ_HAVE_WINDOWS_UWP - if (module != NULL) - ::FreeLibrary (module); + if (module != NULL) ::FreeLibrary(module); #endif - return func; + return func; } static f_compatible_get_tick_count64 my_get_tick_count64 = - init_compatible_get_tick_count64 (); + init_compatible_get_tick_count64(); #endif #ifndef ZMQ_HAVE_WINDOWS @@ -105,154 +107,150 @@ const uint64_t nsecs_per_usec = 1000; #endif const uint64_t usecs_per_sec = 1000000; -zmq::clock_t::clock_t () : - _last_tsc (rdtsc ()), +zmq::clock_t::clock_t() + : _last_tsc(rdtsc()), #ifdef ZMQ_HAVE_WINDOWS - _last_time (static_cast ((*my_get_tick_count64) ())) + _last_time(static_cast((*my_get_tick_count64)())) #else - _last_time (now_us () / usecs_per_msec) + _last_time(now_us() / usecs_per_msec) #endif { } -uint64_t zmq::clock_t::now_us () -{ +uint64_t zmq::clock_t::now_us() { #if defined ZMQ_HAVE_WINDOWS - // Get the high resolution counter's accuracy. - // While QueryPerformanceFrequency only needs to be called once, since its - // value does not change during runtime, we query it here since this is a - // static function. It might make sense to cache it, though. - LARGE_INTEGER ticks_per_second; - QueryPerformanceFrequency (&ticks_per_second); + // Get the high resolution counter's accuracy. + // While QueryPerformanceFrequency only needs to be called once, since its + // value does not change during runtime, we query it here since this is a + // static function. It might make sense to cache it, though. + LARGE_INTEGER ticks_per_second; + QueryPerformanceFrequency(&ticks_per_second); - // What time is it? - LARGE_INTEGER tick; - QueryPerformanceCounter (&tick); + // What time is it? + LARGE_INTEGER tick; + QueryPerformanceCounter(&tick); - // Convert the tick number into the number of seconds - // since the system was started. - const double ticks_div = - static_cast (ticks_per_second.QuadPart) / usecs_per_sec; - return static_cast (tick.QuadPart / ticks_div); + // Convert the tick number into the number of seconds + // since the system was started. + const double ticks_div = + static_cast(ticks_per_second.QuadPart) / usecs_per_sec; + return static_cast(tick.QuadPart / ticks_div); -#elif defined HAVE_CLOCK_GETTIME \ - && (defined CLOCK_MONOTONIC || defined ZMQ_HAVE_VXWORKS) +#elif defined HAVE_CLOCK_GETTIME && \ + (defined CLOCK_MONOTONIC || defined ZMQ_HAVE_VXWORKS) - // Use POSIX clock_gettime function to get precise monotonic time. - struct timespec tv; + // Use POSIX clock_gettime function to get precise monotonic time. + struct timespec tv; -#if defined ZMQ_HAVE_OSX \ - && __MAC_OS_X_VERSION_MIN_REQUIRED < 101200 // less than macOS 10.12 - int rc = alt_clock_gettime (SYSTEM_CLOCK, &tv); +#if defined ZMQ_HAVE_OSX && \ + __MAC_OS_X_VERSION_MIN_REQUIRED < 101200 // less than macOS 10.12 + int rc = alt_clock_gettime(SYSTEM_CLOCK, &tv); #else - int rc = clock_gettime (CLOCK_MONOTONIC, &tv); + int rc = clock_gettime(CLOCK_MONOTONIC, &tv); #endif - // Fix case where system has clock_gettime but CLOCK_MONOTONIC is not supported. - // This should be a configuration check, but I looked into it and writing an - // AC_FUNC_CLOCK_MONOTONIC seems beyond my powers. - if (rc != 0) { + // Fix case where system has clock_gettime but CLOCK_MONOTONIC is not + // supported. This should be a configuration check, but I looked into it and + // writing an AC_FUNC_CLOCK_MONOTONIC seems beyond my powers. + if (rc != 0) { #ifndef ZMQ_HAVE_VXWORKS - // Use POSIX gettimeofday function to get precise time. - struct timeval tv; - int rc = gettimeofday (&tv, NULL); - errno_assert (rc == 0); - return tv.tv_sec * usecs_per_sec + tv.tv_usec; + // Use POSIX gettimeofday function to get precise time. + struct timeval tv; + int rc = gettimeofday(&tv, NULL); + errno_assert(rc == 0); + return tv.tv_sec * usecs_per_sec + tv.tv_usec; #endif - } - return tv.tv_sec * usecs_per_sec + tv.tv_nsec / nsecs_per_usec; + } + return tv.tv_sec * usecs_per_sec + tv.tv_nsec / nsecs_per_usec; #elif defined HAVE_GETHRTIME - return gethrtime () / nsecs_per_usec; + return gethrtime() / nsecs_per_usec; #else - LIBZMQ_UNUSED (nsecs_per_usec); - // Use POSIX gettimeofday function to get precise time. - struct timeval tv; - int rc = gettimeofday (&tv, NULL); - errno_assert (rc == 0); - return tv.tv_sec * usecs_per_sec + tv.tv_usec; + LIBZMQ_UNUSED(nsecs_per_usec); + // Use POSIX gettimeofday function to get precise time. + struct timeval tv; + int rc = gettimeofday(&tv, NULL); + errno_assert(rc == 0); + return tv.tv_sec * usecs_per_sec + tv.tv_usec; #endif } -uint64_t zmq::clock_t::now_ms () -{ - const uint64_t tsc = rdtsc (); +uint64_t zmq::clock_t::now_ms() { + const uint64_t tsc = rdtsc(); - // If TSC is not supported, get precise time and chop off the microseconds. - if (!tsc) { + // If TSC is not supported, get precise time and chop off the microseconds. + if (!tsc) { #ifdef ZMQ_HAVE_WINDOWS - // Under Windows, now_us is not so reliable since QueryPerformanceCounter - // does not guarantee that it will use a hardware that offers a monotonic timer. - // So, lets use GetTickCount when GetTickCount64 is not available with an workaround - // to its 32 bit limitation. - return static_cast ((*my_get_tick_count64) ()); + // Under Windows, now_us is not so reliable since QueryPerformanceCounter + // does not guarantee that it will use a hardware that offers a monotonic + // timer. So, lets use GetTickCount when GetTickCount64 is not available + // with an workaround to its 32 bit limitation. + return static_cast((*my_get_tick_count64)()); #else - return now_us () / usecs_per_msec; + return now_us() / usecs_per_msec; #endif - } + } - // If TSC haven't jumped back (in case of migration to a different - // CPU core) and if not too much time elapsed since last measurement, - // we can return cached time value. - if (likely (tsc - _last_tsc <= (clock_precision / 2) && tsc >= _last_tsc)) - return _last_time; + // If TSC haven't jumped back (in case of migration to a different + // CPU core) and if not too much time elapsed since last measurement, + // we can return cached time value. + if (likely(tsc - _last_tsc <= (clock_precision / 2) && tsc >= _last_tsc)) + return _last_time; - _last_tsc = tsc; + _last_tsc = tsc; #ifdef ZMQ_HAVE_WINDOWS - _last_time = static_cast ((*my_get_tick_count64) ()); + _last_time = static_cast((*my_get_tick_count64)()); #else - _last_time = now_us () / usecs_per_msec; + _last_time = now_us() / usecs_per_msec; #endif - return _last_time; + return _last_time; } -uint64_t zmq::clock_t::rdtsc () -{ +uint64_t zmq::clock_t::rdtsc() { #if (defined _MSC_VER && (defined _M_IX86 || defined _M_X64)) - return __rdtsc (); -#elif defined(_MSC_VER) && defined(_M_ARM) // NC => added for windows ARM - return __rdpmccntr64 (); -#elif defined(_MSC_VER) && defined(_M_ARM64) // NC => added for windows ARM64 - const int64_t pmccntr_el0 = (((3 & 1) << 14) | // op0 - ((3 & 7) << 11) | // op1 - ((9 & 15) << 7) | // crn - ((13 & 15) << 3) | // crm - ((0 & 7) << 0)); // op2 - return _ReadStatusReg (pmccntr_el0); + return __rdtsc(); +#elif defined(_MSC_VER) && defined(_M_ARM) // NC => added for windows ARM + return __rdpmccntr64(); +#elif defined(_MSC_VER) && defined(_M_ARM64) // NC => added for windows ARM64 + const int64_t pmccntr_el0 = (((3 & 1) << 14) | // op0 + ((3 & 7) << 11) | // op1 + ((9 & 15) << 7) | // crn + ((13 & 15) << 3) | // crm + ((0 & 7) << 0)); // op2 + return _ReadStatusReg(pmccntr_el0); #elif (defined(_WIN32) && defined(__GNUC__) && defined(__aarch64__)) - uint64_t val; - __asm__ volatile ("mrs %0, pmccntr_el0" : "=r"(val)); - return val; + uint64_t val; + __asm__ volatile("mrs %0, pmccntr_el0" : "=r"(val)); + return val; #elif (defined __GNUC__ && (defined __i386__ || defined __x86_64__)) - uint32_t low, high; - __asm__ volatile ("rdtsc" : "=a"(low), "=d"(high)); - return static_cast (high) << 32 | low; -#elif (defined __SUNPRO_CC && (__SUNPRO_CC >= 0x5100) \ - && (defined __i386 || defined __amd64 || defined __x86_64)) - union - { - uint64_t u64val; - uint32_t u32val[2]; - } tsc; - asm ("rdtsc" : "=a"(tsc.u32val[0]), "=d"(tsc.u32val[1])); - return tsc.u64val; + uint32_t low, high; + __asm__ volatile("rdtsc" : "=a"(low), "=d"(high)); + return static_cast(high) << 32 | low; +#elif (defined __SUNPRO_CC && (__SUNPRO_CC >= 0x5100) && \ + (defined __i386 || defined __amd64 || defined __x86_64)) + union { + uint64_t u64val; + uint32_t u32val[2]; + } tsc; + asm("rdtsc" : "=a"(tsc.u32val[0]), "=d"(tsc.u32val[1])); + return tsc.u64val; #elif defined(__s390__) - uint64_t tsc; - asm ("\tstck\t%0\n" : "=Q"(tsc) : : "cc"); - return tsc; + uint64_t tsc; + asm("\tstck\t%0\n" : "=Q"(tsc) : : "cc"); + return tsc; #else - struct timespec ts; -#if defined ZMQ_HAVE_OSX \ - && __MAC_OS_X_VERSION_MIN_REQUIRED < 101200 // less than macOS 10.12 - alt_clock_gettime (SYSTEM_CLOCK, &ts); + struct timespec ts; +#if defined ZMQ_HAVE_OSX && \ + __MAC_OS_X_VERSION_MIN_REQUIRED < 101200 // less than macOS 10.12 + alt_clock_gettime(SYSTEM_CLOCK, &ts); #else - clock_gettime (CLOCK_MONOTONIC, &ts); + clock_gettime(CLOCK_MONOTONIC, &ts); #endif - return static_cast (ts.tv_sec) * nsecs_per_usec * usecs_per_sec - + ts.tv_nsec; + return static_cast(ts.tv_sec) * nsecs_per_usec * usecs_per_sec + + ts.tv_nsec; #endif }