X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmisc%2Fmtime.c;h=9966e473bec8f5a046fcf1b92ccbb132331bba48;hb=a46fb0e4e14d971e7482b010bb42c6bc93df66f7;hp=b67f3f7d13a358f627026dc62596258cbd2a96f8;hpb=0d2e22a5410b19b3206b575359cbe56c54a1d3fb;p=vlc diff --git a/src/misc/mtime.c b/src/misc/mtime.c index b67f3f7d13..9966e473be 100644 --- a/src/misc/mtime.c +++ b/src/misc/mtime.c @@ -1,12 +1,14 @@ /***************************************************************************** * mtime.c: high resolution time management functions - * Functions are prototyped in mtime.h. + * Functions are prototyped in vlc_mtime.h. ***************************************************************************** - * Copyright (C) 1998-2004 the VideoLAN team + * Copyright (C) 1998-2007 the VideoLAN team + * Copyright © 2006-2007 Rémi Denis-Courmont * $Id$ * * Authors: Vincent Seguin * Rémi Denis-Courmont + * Gisle Vanem * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -27,16 +29,15 @@ * Preamble *****************************************************************************/ -#include - -#include /* sprintf() */ -#include /* clock_gettime(), clock_nanosleep() */ -#include /* lldiv() */ +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif +#include -#if defined( PTH_INIT_IN_PTH_H ) /* GNU Pth */ -# include -#endif +#include /* clock_gettime(), clock_nanosleep() */ +#include +#include #ifdef HAVE_UNISTD_H # include /* select() */ @@ -48,11 +49,18 @@ #if defined( WIN32 ) || defined( UNDER_CE ) # include -#else +# include +#endif + +#if defined( UNDER_CE ) +# include +#endif + +#if defined(HAVE_SYS_TIME_H) # include #endif -#if defined(HAVE_NANOSLEEP) && !defined(HAVE_STRUCT_TIMESPEC) +#if !defined(HAVE_STRUCT_TIMESPEC) struct timespec { time_t tv_sec; @@ -64,6 +72,24 @@ struct timespec int nanosleep(struct timespec *, struct timespec *); #endif +#if !defined (_POSIX_CLOCK_SELECTION) +# define _POSIX_CLOCK_SELECTION (-1) +#endif + +# if (_POSIX_CLOCK_SELECTION < 0) +/* + * We cannot use the monotonic clock is clock selection is not available, + * as it would screw vlc_cond_timedwait() completely. Instead, we have to + * stick to the realtime clock. Nevermind it screws everything when ntpdate + * warps the wall clock. + */ +# undef CLOCK_MONOTONIC +# define CLOCK_MONOTONIC CLOCK_REALTIME +#elif !defined (HAVE_CLOCK_NANOSLEEP) +/* Clock selection without clock in the first place, I don't think so. */ +# error We have quite a situation here! Fix me if it ever happens. +#endif + /** * Return a date in a readable format * @@ -99,44 +125,83 @@ char *mstrtime( char *psz_buffer, mtime_t date ) */ char *secstotimestr( char *psz_buffer, int i_seconds ) { - snprintf( psz_buffer, MSTRTIME_MAX_SIZE, "%d:%2.2d:%2.2d", - (int) (i_seconds / (60 *60)), - (int) ((i_seconds / 60) % 60), - (int) (i_seconds % 60) ); + int i_hours, i_mins; + i_mins = i_seconds / 60; + i_hours = i_mins / 60 ; + if( i_hours ) + { + snprintf( psz_buffer, MSTRTIME_MAX_SIZE, "%d:%2.2d:%2.2d", + (int) i_hours, + (int) (i_mins % 60), + (int) (i_seconds % 60) ); + } + else + { + snprintf( psz_buffer, MSTRTIME_MAX_SIZE, "%2.2d:%2.2d", + (int) i_mins , + (int) (i_seconds % 60) ); + } return( psz_buffer ); } +#if defined (HAVE_CLOCK_NANOSLEEP) +static unsigned prec = 0; + +static void mprec_once( void ) +{ + struct timespec ts; + if( clock_getres( CLOCK_MONOTONIC, &ts )) + clock_getres( CLOCK_REALTIME, &ts ); + + prec = ts.tv_nsec / 1000; +} +#endif + +/** + * Return a value that is no bigger than the clock precision + * (possibly zero). + */ +static inline unsigned mprec( void ) +{ +#if defined (HAVE_CLOCK_NANOSLEEP) + static pthread_once_t once = PTHREAD_ONCE_INIT; + pthread_once( &once, mprec_once ); + return prec; +#else + return 0; +#endif +} /** * Return high precision date * - * Uses the gettimeofday() function when possible (1 MHz resolution) or the - * ftime() function (1 kHz resolution). + * Use a 1 MHz clock when possible, or 1 kHz + * + * Beware ! It doesn't reflect the actual date (since epoch), but can be the machine's uptime or anything (when monotonic clock is used) */ mtime_t mdate( void ) { + mtime_t res; + #if defined (HAVE_CLOCK_NANOSLEEP) struct timespec ts; -# if (_POSIX_MONOTONIC_CLOCK - 0 >= 0) /* Try to use POSIX monotonic clock if available */ - if( clock_gettime( CLOCK_MONOTONIC, &ts ) ) -# endif + if( clock_gettime( CLOCK_MONOTONIC, &ts ) == EINVAL ) /* Run-time fallback to real-time clock (always available) */ (void)clock_gettime( CLOCK_REALTIME, &ts ); - return ((mtime_t)ts.tv_sec * (mtime_t)1000000) + res = ((mtime_t)ts.tv_sec * (mtime_t)1000000) + (mtime_t)(ts.tv_nsec / 1000); #elif defined( HAVE_KERNEL_OS_H ) - return( real_time_clock_usecs() ); + res = real_time_clock_usecs(); #elif defined( WIN32 ) || defined( UNDER_CE ) /* We don't need the real date, just the value of a high precision timer */ - static mtime_t freq = I64C(-1); - mtime_t usec_time; + static mtime_t freq = INT64_C(-1); - if( freq == I64C(-1) ) + if( freq == INT64_C(-1) ) { /* Extract from the Tcl source code: * (http://www.cs.man.ac.uk/fellowsd-bin/TIP/7.html) @@ -159,56 +224,94 @@ mtime_t mdate( void ) LARGE_INTEGER buf; freq = ( QueryPerformanceFrequency( &buf ) && - (freq == I64C(1193182) || freq == I64C(3579545) ) ) + (buf.QuadPart == INT64_C(1193182) || buf.QuadPart == INT64_C(3579545) ) ) ? buf.QuadPart : 0; + +#if defined( WIN32 ) + /* on windows 2000, XP and Vista detect if there are two + cores there - that makes QueryPerformanceFrequency in + any case not trustable? + (may also be true, for single cores with adaptive + CPU frequency and active power management?) + */ + HINSTANCE h_Kernel32 = LoadLibrary(_T("kernel32.dll")); + if(h_Kernel32) + { + void WINAPI (*pf_GetSystemInfo)(LPSYSTEM_INFO); + pf_GetSystemInfo = (void WINAPI (*)(LPSYSTEM_INFO)) + GetProcAddress(h_Kernel32, _T("GetSystemInfo")); + if(pf_GetSystemInfo) + { + SYSTEM_INFO system_info; + pf_GetSystemInfo(&system_info); + if(system_info.dwNumberOfProcessors > 1) + freq = 0; + } + FreeLibrary(h_Kernel32); + } +#endif } if( freq != 0 ) { - /* Microsecond resolution */ - QueryPerformanceCounter( (LARGE_INTEGER *)&usec_time ); - return ( usec_time * 1000000 ) / freq; + LARGE_INTEGER counter; + QueryPerformanceCounter (&counter); + + /* Convert to from (1/freq) to microsecond resolution */ + /* We need to split the division to avoid 63-bits overflow */ + lldiv_t d = lldiv (counter.QuadPart, freq); + + res = (d.quot * 1000000) + ((d.rem * 1000000) / freq); } else { - /* Fallback on GetTickCount() which has a milisecond resolution - * (actually, best case is about 10 ms resolution) - * GetTickCount() only returns a DWORD thus will wrap after + /* Fallback on timeGetTime() which has a milisecond resolution + * (actually, best case is about 5 ms resolution) + * timeGetTime() only returns a DWORD thus will wrap after * about 49.7 days so we try to detect the wrapping. */ static CRITICAL_SECTION date_lock; - static mtime_t i_previous_time = I64C(-1); + static mtime_t i_previous_time = INT64_C(-1); static int i_wrap_counts = -1; if( i_wrap_counts == -1 ) { /* Initialization */ - i_previous_time = I64C(1000) * GetTickCount(); +#if defined( WIN32 ) + i_previous_time = INT64_C(1000) * timeGetTime(); +#else + i_previous_time = INT64_C(1000) * GetTickCount(); +#endif InitializeCriticalSection( &date_lock ); i_wrap_counts = 0; } EnterCriticalSection( &date_lock ); - usec_time = I64C(1000) * - (i_wrap_counts * I64C(0x100000000) + GetTickCount()); - if( i_previous_time > usec_time ) +#if defined( WIN32 ) + res = INT64_C(1000) * + (i_wrap_counts * INT64_C(0x100000000) + timeGetTime()); +#else + res = INT64_C(1000) * + (i_wrap_counts * INT64_C(0x100000000) + GetTickCount()); +#endif + if( i_previous_time > res ) { /* Counter wrapped */ i_wrap_counts++; - usec_time += I64C(0x100000000000); + res += INT64_C(0x100000000) * 1000; } - i_previous_time = usec_time; + i_previous_time = res; LeaveCriticalSection( &date_lock ); - - return usec_time; } #else struct timeval tv_date; /* gettimeofday() cannot fail given &tv_date is a valid address */ (void)gettimeofday( &tv_date, NULL ); - return( (mtime_t) tv_date.tv_sec * 1000000 + (mtime_t) tv_date.tv_usec ); + res = (mtime_t) tv_date.tv_sec * 1000000 + (mtime_t) tv_date.tv_usec; #endif + + return res; } /** @@ -221,17 +324,25 @@ mtime_t mdate( void ) */ void mwait( mtime_t date ) { + /* If the deadline is already elapsed, or within the clock precision, + * do not even bother the system timer. */ + date -= mprec(); + #if defined (HAVE_CLOCK_NANOSLEEP) lldiv_t d = lldiv( date, 1000000 ); struct timespec ts = { d.quot, d.rem * 1000 }; -# if (_POSIX_MONOTONIC_CLOCK - 0 >= 0) - if( clock_nanosleep( CLOCK_MONOTONIC, TIMER_ABSTIME, &ts, NULL ) ) -# endif - clock_nanosleep( CLOCK_REALTIME, TIMER_ABSTIME, &ts, NULL ); + int val; + while( ( val = clock_nanosleep( CLOCK_MONOTONIC, TIMER_ABSTIME, &ts, + NULL ) ) == EINTR ); + if( val == EINVAL ) + { + ts.tv_sec = d.quot; ts.tv_nsec = d.rem * 1000; + while( clock_nanosleep( CLOCK_REALTIME, 0, &ts, NULL ) == EINTR ); + } #else - mtime_t delay = mdate() - date; + mtime_t delay = date - mdate(); if( delay > 0 ) msleep( delay ); @@ -246,26 +357,23 @@ void mwait( mtime_t date ) */ void msleep( mtime_t delay ) { -#if defined( HAVE_CLOCK_NANOSLEEP ) +#if defined( HAVE_CLOCK_NANOSLEEP ) lldiv_t d = lldiv( delay, 1000000 ); struct timespec ts = { d.quot, d.rem * 1000 }; -# if (_POSIX_MONOTONIC_CLOCK - 0 >= 0) - if( clock_nanosleep( CLOCK_MONOTONIC, 0, &ts, NULL ) ) -# endif - clock_nanosleep( CLOCK_REALTIME, 0, &ts, NULL ); + int val; + while( ( val = clock_nanosleep( CLOCK_MONOTONIC, 0, &ts, &ts ) ) == EINTR ); + if( val == EINVAL ) + { + ts.tv_sec = d.quot; ts.tv_nsec = d.rem * 1000; + while( clock_nanosleep( CLOCK_REALTIME, 0, &ts, &ts ) == EINTR ); + } #elif defined( HAVE_KERNEL_OS_H ) snooze( delay ); -#elif defined( PTH_INIT_IN_PTH_H ) - pth_usleep( delay ); - -#elif defined( ST_INIT_IN_ST_H ) - st_usleep( delay ); - #elif defined( WIN32 ) || defined( UNDER_CE ) - Sleep( (int) (delay / 1000) ); + Sleep( (DWORD) (delay / 1000) ); #elif defined( HAVE_NANOSLEEP ) struct timespec ts_delay; @@ -273,7 +381,7 @@ void msleep( mtime_t delay ) ts_delay.tv_sec = delay / 1000000; ts_delay.tv_nsec = (delay % 1000000) * 1000; - nanosleep( &ts_delay, NULL ); + while( nanosleep( &ts_delay, &ts_delay ) && ( errno == EINTR ) ); #else struct timeval tv_delay; @@ -281,10 +389,8 @@ void msleep( mtime_t delay ) tv_delay.tv_sec = delay / 1000000; tv_delay.tv_usec = delay % 1000000; - /* select() return value should be tested, since several possible errors - * can occur. However, they should only happen in very particular occasions - * (i.e. when a signal is sent to the thread, or when memory is full), and - * can be ignored. */ + /* If a signal is caught, you are screwed. Update your OS to nanosleep() + * or clock_nanosleep() if this is an issue. */ select( 0, NULL, NULL, NULL, &tv_delay ); #endif } @@ -380,3 +486,79 @@ mtime_t date_Increment( date_t *p_date, uint32_t i_nb_samples ) return p_date->date; } + +#ifndef HAVE_GETTIMEOFDAY + +#ifdef WIN32 + +/* + * Number of micro-seconds between the beginning of the Windows epoch + * (Jan. 1, 1601) and the Unix epoch (Jan. 1, 1970). + * + * This assumes all Win32 compilers have 64-bit support. + */ +#if defined(_MSC_VER) || defined(_MSC_EXTENSIONS) || defined(__WATCOMC__) +# define DELTA_EPOCH_IN_USEC 11644473600000000Ui64 +#else +# define DELTA_EPOCH_IN_USEC 11644473600000000ULL +#endif + +static uint64_t filetime_to_unix_epoch (const FILETIME *ft) +{ + uint64_t res = (uint64_t) ft->dwHighDateTime << 32; + + res |= ft->dwLowDateTime; + res /= 10; /* from 100 nano-sec periods to usec */ + res -= DELTA_EPOCH_IN_USEC; /* from Win epoch to Unix epoch */ + return (res); +} + +static int gettimeofday (struct timeval *tv, void *tz ) +{ + FILETIME ft; + uint64_t tim; + + if (!tv) { + return VLC_EGENERIC; + } + GetSystemTimeAsFileTime (&ft); + tim = filetime_to_unix_epoch (&ft); + tv->tv_sec = (long) (tim / 1000000L); + tv->tv_usec = (long) (tim % 1000000L); + return (0); +} + +#endif + +#endif + +/** + * @return NTP 64-bits timestamp in host byte order. + */ +uint64_t NTPtime64 (void) +{ + struct timespec ts; +#if defined (CLOCK_REALTIME) + clock_gettime (CLOCK_REALTIME, &ts); +#else + { + struct timeval tv; + gettimeofday (&tv, NULL); + ts.tv_sec = tv.tv_sec; + ts.tv_nsec = tv.tv_usec * 1000; + } +#endif + + /* Convert nanoseconds to 32-bits fraction (232 picosecond units) */ + uint64_t t = (uint64_t)(ts.tv_nsec) << 32; + t /= 1000000000; + + + /* There is 70 years (incl. 17 leap ones) offset to the Unix Epoch. + * No leap seconds during that period since they were not invented yet. + */ + assert (t < 0x100000000); + t |= ((70LL * 365 + 17) * 24 * 60 * 60 + ts.tv_sec) << 32; + return t; +} +