static int ev_gettimeofday (struct timeval *tv, struct timezone *tz) { struct _timeb tb; _ftime (&tb); tv->tv_sec = (long)tb.time; tv->tv_usec = ((long)tb.millitm) * 1000; return 0; }
/** * gettimeofday() not in Win32 */ EXP_FUNC void STDCALL gettimeofday(struct timeval* t, void* timezone) { #if defined(_WIN32_WCE) t->tv_sec = time(NULL); t->tv_usec = 0; /* 1sec precision only */ #else struct _timeb timebuffer; _ftime(&timebuffer); t->tv_sec = (long)timebuffer.time; t->tv_usec = 1000 * timebuffer.millitm; /* 1ms precision */ #endif }
double Time( void ) { #ifdef WIN32 struct _timeb t; _ftime(&t); return double(t.time)+double(t.millitm)/1000.0; #else // WIN32 struct timeval t; gettimeofday(&t,NULL); return t.tv_sec+(double)t.tv_usec/1000000; #endif // WIN32 }
STDINLINE stdcode stdtime_now(stdtime *abs_time) #if defined(_WIN32) { struct _timeb t; _ftime(&t); abs_time->sec = t.time; abs_time->nano = t.millitm * STD1MILLION; return STDESUCCESS; }
/* * init_random, written by Syzop. * This function tries to initialize the arc4 random number generator securely. */ void init_random() { struct { #ifdef USE_SSL char egd[32]; /* from EGD */ #endif #ifndef _WIN32 struct timeval nowt; /* time */ char rnd[32]; /* /dev/urandom */ #else MEMORYSTATUS mstat; /* memory status */ struct _timeb nowt; /* time */ #endif } rdat; int n; #ifndef _WIN32 int fd; #else MEMORYSTATUS mstat; #endif arc4_init(); /* Grab non-OS specific "random" data */ #ifdef USE_SSL #if OPENSSL_VERSION_NUMBER >= 0x000907000 if (EGD_PATH) { n = RAND_query_egd_bytes(EGD_PATH, rdat.egd, sizeof(rdat.egd)); } #endif #endif /* Grab OS specific "random" data */ #ifndef _WIN32 gettimeofday(&rdat.nowt, NULL); fd = open("/dev/urandom", O_RDONLY); if (fd) { n = read(fd, &rdat.rnd, sizeof(rdat.rnd)); Debug((DEBUG_INFO, "init_random: read from /dev/urandom returned %d", n)); close(fd); } /* TODO: more!?? */ #else _ftime(&rdat.nowt); GlobalMemoryStatus (&rdat.mstat); #endif arc4_addrandom(&rdat, sizeof(rdat)); /* NOTE: addtional entropy is added by add_entropy_* function(s) */ }
void CTimer::TotalTime()//输出累计总时间 { _ftime( &timebuffer_end);//获取结束时间 double dEndTime = GetSeconds(timebuffer_end); double dElapsed_time = dEndTime - m_dBeginTime; if(stream == NULL) return; fprintf( stream, m_strTitle + " \nElapsed time :%.4f seconds\n\n",dElapsed_time ); }
int64_t av_gettime(void) { #ifdef CONFIG_WIN32 struct timeb tb; _ftime(&tb); return ((int64_t)tb.time * int64_t_C(1000) + (int64_t)tb.millitm) * int64_t_C(1000); #else struct timeval tv; gettimeofday(&tv,NULL); return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec; #endif }
// Get the global time with at least millisecond resolution. double CS315::getTime(void) { #ifdef WIN32 struct _timeb tbuf; _ftime(&tbuf); return ((double)tbuf.time + 0.001 * (double)(tbuf.millitm)); #else struct timeval time; gettimeofday(&time, NULL); return ((double)time.tv_sec + 0.000001 * (double)time.tv_usec); #endif }
LPCTSTR CreateTimeStamp(LPTSTR lpBuffer, size_t iBufferSize) { struct _timeb tb; _ftime(&tb); size_t len = _tcsftime(lpBuffer, iBufferSize, _T("%b %d %H:%M:%S"), localtime(&tb.time)); if (len && len+4 < iBufferSize) { if (_sntprintf(lpBuffer+len, iBufferSize-len-1, _T(".%03d"), tb.millitm) < 0) { lpBuffer[iBufferSize-len-1] = 0; } } return lpBuffer; }
double TimeOfDay() { #if defined(WIN32) && !defined(__CYGWIN__) struct _timeb localTime; _ftime(&localTime); return localTime.time + 1.e-3 * localTime.millitm; #else struct timeval t; gettimeofday(&t, NULL); return t.tv_sec + 1.e-6 * t.tv_usec; #endif }
int get_clock_ms(void) { #ifdef CONFIG_WIN32 struct _timeb tb; _ftime(&tb); return tb.time * 1000 + tb.millitm; #else struct timeval tv; gettimeofday(&tv, NULL); return tv.tv_sec * 1000 + (tv.tv_usec / 1000); #endif }
void CMessage::error(const int iErrorCode, const char *pcErrorMessage,...)const { ENTERCS; va_list args; va_start(args, pcErrorMessage); #if defined(__QNX__) timespec nowTimeVal; clock_gettime(CLOCK_REALTIME,&nowTimeVal); double fSeconds = (nowTimeVal.tv_sec +(double(nowTimeVal.tv_nsec)/1e+9)) - m_fInitTime; #elif defined(_WIN32) _timeb nowTimeVal; _ftime(&nowTimeVal); double fSeconds = (nowTimeVal.time +(double(nowTimeVal.millitm)/1e+3)) - m_fInitTime; #else timeval nowTimeVal; gettimeofday(&nowTimeVal,0); double fSeconds = (nowTimeVal.tv_sec +(double(nowTimeVal.tv_usec)/1e+6)) - m_fInitTime; #endif static char acBuffer[255]; static char acOutBuffer[300]; vsprintf(acBuffer, pcErrorMessage, args); sprintf(acOutBuffer, "\nERROR: #%i %5.3f %s::%s", iErrorCode, fSeconds, m_acClassName, acBuffer); if (m_bDebugFile==true) { FILE* hFile; hFile=fopen(g_pcDebugFileName,"a+"); if(hFile != NULL) { fprintf(hFile, "%s", acOutBuffer); fclose(hFile); } } #ifdef WIN32 OutputDebugString(acOutBuffer); #else fprintf(stderr, "%s", acOutBuffer); #endif LEAVECS; exit(-1); };
static void WaitMonitorThread(void *arg) { PRIntervalTime timeout = (PRIntervalTime) arg; PRIntervalTime elapsed; #if defined(XP_UNIX) || defined(WIN32) PRInt32 timeout_msecs = PR_IntervalToMilliseconds(timeout); PRInt32 elapsed_msecs; #endif #if defined(XP_UNIX) struct timeval end_time_tv; #endif #if defined(WIN32) struct _timeb end_time_tb; #endif PRMonitor *mon; mon = PR_NewMonitor(); if (mon == NULL) { fprintf(stderr, "PR_NewMonitor failed\n"); exit(1); } PR_EnterMonitor(mon); PR_Wait(mon, timeout); PR_ExitMonitor(mon); elapsed = (PRIntervalTime)(PR_IntervalNow() - start_time); if (elapsed + tolerance < timeout || elapsed > timeout + tolerance) { fprintf(stderr, "timeout wrong\n"); exit(1); } #if defined(XP_UNIX) gettimeofday(&end_time_tv, NULL); elapsed_msecs = 1000*(end_time_tv.tv_sec - start_time_tv.tv_sec) + (end_time_tv.tv_usec - start_time_tv.tv_usec)/1000; #endif #if defined(WIN32) _ftime(&end_time_tb); elapsed_msecs = 1000*(end_time_tb.time - start_time_tb.time) + (end_time_tb.millitm - start_time_tb.millitm); #endif #if defined(XP_UNIX) || defined(WIN32) if (elapsed_msecs + tolerance_msecs < timeout_msecs || elapsed_msecs > timeout_msecs + tolerance_msecs) { fprintf(stderr, "timeout wrong\n"); exit(1); } #endif PR_DestroyMonitor(mon); if (debug_mode) { fprintf(stderr, "wait monitor thread (scope %d) done\n", PR_GetThreadScope(PR_GetCurrentThread())); } }
static void BasicHttpGetTimeOfDay(VmTimeType *time) // OUT { #if _WIN32 struct _timeb t; _ftime(&t); *time = (t.time * 1000000) + t.millitm * 1000; #else // Linux struct timeval tv; gettimeofday(&tv, NULL); *time = ((VmTimeType)tv.tv_sec * 1000000) + tv.tv_usec; #endif }
double current_time() { #if defined(HAVE__FTIME) struct _timeb timebuffer; _ftime( &timebuffer ); return ( timebuffer.time + (timebuffer.millitm * 0.001) ); #elif defined(HAVE_GETTIMEOFDAY) struct timeval tv; gettimeofday( &tv, NULL ); return ( tv.tv_sec + ( tv.tv_usec * 0.000001 ) ); #else return 0.0; #endif }
int evutil_gettimeofday(struct timeval *tv, struct timezone *tz) { struct _timeb tb; if(tv == NULL) return -1; _ftime(&tb); tv->tv_sec = (long) tb.time; tv->tv_usec = ((int) tb.millitm) * 1000; return 0; }
int gettimeofday(struct timeval *tp, void *tzp) { #ifdef WIN32 struct _timeb timebuffer; _ftime(&timebuffer); tp->tv_sec = (long)timebuffer.time; tp->tv_usec = timebuffer.millitm * 1000; #else tp->tv_sec = time(NULL); tp->tv_usec = 0; #endif return 0; }
void __eXosip_clock_gettime (unsigned int clock_id, struct timespec *time) { struct _timeb time_val; if (clock_id != OSIP_CLOCK_REALTIME) return; _ftime (&time_val); time->tv_sec = time_val.time; time->tv_nsec = time_val.millitm * 1000000; return; }
int64_t p264_mdate( void ) { #if !(defined(_MSC_VER) || defined(__MINGW32__)) struct timeval tv_date; gettimeofday( &tv_date, NULL ); return( (int64_t) tv_date.tv_sec * 1000000 + (int64_t) tv_date.tv_usec ); #else struct _timeb tb; _ftime(&tb); return ((int64_t)tb.time * (1000) + (int64_t)tb.millitm) * (1000); #endif }
int gettimeofday(struct timeval *tv, struct timezone *tz) { struct _timeb tb; if(tv==NULL) { return -1; } _ftime(&tb); tv->tv_sec = (unsigned long)tb.time; tv->tv_usec = ((int) tb.millitm) * 1000; return 0; }
void msec::refresh() { // CK Ng added #ifdef WIN32 #ifdef WIN32 struct _timeb timebuffer; _ftime( &timebuffer ); m_time.tv_usec = timebuffer.millitm; m_time.tv_sec = timebuffer.time; #else class timezone tzone; gettimeofday((timeval *)&m_time, &tzone); m_time.tv_usec /= 1000; // convert usec to millisec #endif }
// D: initializes the high resolution timer void InitializeHighResolutionTimer() { // obtain the counter frequency (ticks per second) QueryPerformanceFrequency(&iHighResCounterFrequency); // obtain the current time (starting time) (actually sit in a loop // until the current time changes so that we can avoid as much as // possible granularity effects _timeb tTimeNow, tLastTime; _ftime(&tTimeNow); do { tLastTime = tTimeNow; _ftime(&tTimeNow); } while(tTimeNow.millitm == tLastTime.millitm); tStartUpTime = tTimeNow; // and obtain the current initial counter time QueryPerformanceCounter(&iStartUpCounterValue); // converts it into milliseconds iStartUpTimestamp = 1000*iStartUpCounterValue.QuadPart/ iHighResCounterFrequency.QuadPart; }
int main() { int i; pthread_t t[NUMTHREADS + 1]; int result = 0; struct _timeb currSysTime; const DWORD NANOSEC_PER_MILLISEC = 1000000; assert(pthread_cond_init(&cv, NULL) == 0); assert(pthread_mutex_init(&mutex, NULL) == 0); /* get current system time */ _ftime(&currSysTime); abstime.tv_sec = currSysTime.time; abstime.tv_nsec = NANOSEC_PER_MILLISEC * currSysTime.millitm; abstime.tv_sec += 5; assert(pthread_mutex_lock(&mutex) == 0); for (i = 1; i <= NUMTHREADS; i++) { assert(pthread_create(&t[i], NULL, mythread, (void *) i) == 0); } assert(pthread_mutex_unlock(&mutex) == 0); for (i = 1; i <= NUMTHREADS; i++) { assert(pthread_join(t[i], (void **) &result) == 0); assert(result == i); } { int result = pthread_cond_destroy(&cv); if (result != 0) { fprintf(stderr, "Result = %s\n", error_string[result]); fprintf(stderr, "\tWaitersBlocked = %ld\n", cv->nWaitersBlocked); fprintf(stderr, "\tWaitersGone = %ld\n", cv->nWaitersGone); fprintf(stderr, "\tWaitersToUnblock = %ld\n", cv->nWaitersToUnblock); fflush(stderr); } assert(result == 0); } return 0; }
double getTime() { #ifdef _WIN32 time_t ltime; _timeb tstruct; time( <ime ); _ftime( &tstruct ); return (double) (ltime + 1e-3*(tstruct.millitm)); #else struct timeval t; gettimeofday( &t, NULL ); return (double)(t.tv_sec + 1e-6*t.tv_usec); #endif }
/** * gets the current time in micro seconds. */ int64_t av_gettime(void) { #if defined(CONFIG_WINCE) return timeGetTime() * INT64_C(1000); #elif defined(__MINGW32__) struct timeb tb; _ftime(&tb); return ((int64_t)tb.time * INT64_C(1000) + (int64_t)tb.millitm) * INT64_C(1000); #else struct timeval tv; gettimeofday(&tv,NULL); return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec; #endif }
/* This function will begin to fail in the year 2038 */ int afs_gettimeofday(struct timeval *tv, struct timezone *tz) { struct _timeb myTime; _ftime(&myTime); tv->tv_sec = myTime.time; tv->tv_usec = myTime.millitm * 1000; if (tz) { tz->tz_minuteswest = myTime.timezone; tz->tz_dsttime = myTime.dstflag; } return 0; }
/******************* check whether time has expired *********************/ int bInchiTimeIsOver( e_inchiTime *TickEnd ) { struct _timeb timeb; if ( !TickEnd ) return 0; _ftime( &timeb ); if ( TickEnd->clockTime > (unsigned long)timeb.time ) return 0; if ( TickEnd->clockTime < (unsigned long)timeb.time || TickEnd->millitime < (long)timeb.millitm ) { return 1; } return 0; }
/* ================ Sys_DoubleTime ================ */ double Sys_DoubleTime (void) { double t; struct _timeb tstruct; static int starttime; _ftime( &tstruct ); if (!starttime) starttime = tstruct.time; t = (tstruct.time-starttime) + tstruct.millitm*0.001; return t; }
//--------------------------------------------------------------- // gettime(timeval&) const (Private) // Get the current time. // void Eventloop::gettime(timeval& timeval) const { #if defined(WIN32) _timeb currTime; _ftime(&currTime); timeval.tv_sec = currTime.time; timeval.tv_usec = currTime.millitm * USECS_PER_MSEC; #else (void) gettimeofday(&timeval, NULL); #endif return; } // end of Eventloop::gettime(timeval&) const
static void SleepThread(void *arg) { PRIntervalTime timeout = (PRIntervalTime) arg; PRIntervalTime elapsed; #if defined(XP_UNIX) || defined(WIN32) PRInt32 timeout_msecs = PR_IntervalToMilliseconds(timeout); PRInt32 elapsed_msecs; #endif #if defined(XP_UNIX) struct timeval end_time_tv; #endif #if defined(WIN32) && !defined(WINCE) struct _timeb end_time_tb; #endif if (PR_Sleep(timeout) == PR_FAILURE) { fprintf(stderr, "PR_Sleep failed\n"); exit(1); } elapsed = (PRIntervalTime)(PR_IntervalNow() - start_time); if (elapsed + tolerance < timeout || elapsed > timeout + tolerance) { fprintf(stderr, "timeout wrong\n"); exit(1); } #if defined(XP_UNIX) gettimeofday(&end_time_tv, NULL); elapsed_msecs = 1000*(end_time_tv.tv_sec - start_time_tv.tv_sec) + (end_time_tv.tv_usec - start_time_tv.tv_usec)/1000; #endif #if defined(WIN32) #if defined(WINCE) elapsed_msecs = GetTickCount() - start_time_tick; #else _ftime(&end_time_tb); elapsed_msecs = 1000*(end_time_tb.time - start_time_tb.time) + (end_time_tb.millitm - start_time_tb.millitm); #endif #endif #if defined(XP_UNIX) || defined(WIN32) if (elapsed_msecs + tolerance_msecs < timeout_msecs || elapsed_msecs > timeout_msecs + tolerance_msecs) { fprintf(stderr, "timeout wrong\n"); exit(1); } #endif if (debug_mode) { fprintf(stderr, "Sleep thread (scope %d) done\n", PR_GetThreadScope(PR_GetCurrentThread())); } }