src/xbt/xbt_os_time.c

   1 /* xbt_os_time.c -- portable interface to time-related functions            */
   2
   3 /* Copyright (c) 2007, 2008, 2009, 2010. The SimGrid Team.
   4  * All rights reserved.                                                     */
   5
   6 /* This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the license (GNU LGPL) which comes with this package. */
   8
   9 #include "xbt/sysdep.h"
  10 #include "xbt/xbt_os_time.h"    /* this module */
  11 #include "xbt/log.h"
  12 #include "portable.h"
  13 #include <math.h>               /* floor */
  14
  15 #ifdef _XBT_WIN32
  16 #include <sys/timeb.h>
  17 #include <windows.h>
  18 #endif
  19
  20 //Freebsd doesn't provide this clock_gettime flag yet, because it was added too recently (after 1993)
  21 #ifdef __FreeBSD__
  22 #define CLOCK_PROCESS_CPUTTIME_ID CLOCK_PROF
  23 #endif
  24
  25 double xbt_os_time(void)
  26 {
  27 #ifdef HAVE_GETTIMEOFDAY
  28   struct timeval tv;
  29   gettimeofday(&tv, NULL);
  30 #elif defined(_XBT_WIN32)
  31   struct timeval tv;
  32 #  if defined(WIN32_WCE) || (_WIN32_WINNT < 0x0400)
  33   struct _timeb tm;
  34
  35   _ftime(&tm);
  36
  37   tv.tv_sec = tm.time;
  38   tv.tv_usec = tm.millitm * 1000;
  39
  40 #  else
  41   FILETIME ft;
  42   unsigned __int64 tm;
  43
  44   GetSystemTimeAsFileTime(&ft);
  45   tm = (unsigned __int64) ft.dwHighDateTime << 32;
  46   tm |= ft.dwLowDateTime;
  47   tm /= 10;
  48   tm -= 11644473600000000ULL;
  49
  50   tv.tv_sec = (long) (tm / 1000000L);
  51   tv.tv_usec = (long) (tm % 1000000L);
  52 #  endif                        /* windows version checker */
  53
  54 #else                           /* not windows, no gettimeofday => poor resolution */
  55   return (double) (time(NULL));
  56 #endif                          /* HAVE_GETTIMEOFDAY? */
  57
  58   return (double) (tv.tv_sec + tv.tv_usec / 1000000.0);
  59 }
  60
  61 void xbt_os_sleep(double sec)
  62 {
  63
  64 #ifdef _XBT_WIN32
  65   Sleep((floor(sec) * 1000) + ((sec - floor(sec)) * 1000));
  66
  67 #elif HAVE_NANOSLEEP
  68   struct timespec ts;
  69   ts.tv_sec = sec;
  70   ts.tv_nsec = (sec - floor(sec)) * 1e9;
  71   nanosleep (&ts, NULL);
  72 #else                           /* don't have nanosleep. Use select to sleep less than one second */
  73   struct timeval timeout;
  74
  75   timeout.tv_sec = (unsigned long) (sec);
  76   timeout.tv_usec = (sec - floor(sec)) * 1000000;
  77
  78   select(0, NULL, NULL, NULL, &timeout);
  79 #endif
  80 }
  81
  82 /* TSC (tick-level) timers are said to be unreliable on SMP hosts and thus
  83    disabled in SDL source code */
  84
  85
  86 /* \defgroup XBT_sysdep All system dependency
  87  * \brief This section describes many macros/functions that can serve as
  88  *  an OS abstraction.
  89  */
  90
  91
  92 struct s_xbt_os_timer {
  93 #ifdef HAVE_POSIX_GETTIME
  94   struct timespec start, stop, elapse;
  95 #elif defined(HAVE_GETTIMEOFDAY)
  96   struct timeval start, stop, elapse;
  97 #else
  98   unsigned long int start, stop, elapse;
  99 #endif
 100 };
 101
 102 xbt_os_timer_t xbt_os_timer_new(void)
 103 {
 104   return xbt_new0(struct s_xbt_os_timer, 1);
 105 }
 106
 107 void xbt_os_timer_free(xbt_os_timer_t timer)
 108 {
 109   free(timer);
 110 }
 111
 112 double xbt_os_timer_elapsed(xbt_os_timer_t timer)
 113 {
 114 #ifdef HAVE_POSIX_GETTIME
 115   return ((double) timer->stop.tv_sec) - ((double) timer->start.tv_sec) +
 116                                           ((double) timer->elapse.tv_sec ) +
 117       ((((double) timer->stop.tv_nsec) -
 118         ((double) timer->start.tv_nsec) + ((double) timer->elapse.tv_nsec )) / 1e9);
 119 #elif defined(HAVE_GETTIMEOFDAY) || defined(_XBT_WIN32)
 120   return ((double) timer->stop.tv_sec) - ((double) timer->start.tv_sec)
 121     + ((double) timer->elapse.tv_sec ) +
 122       ((((double) timer->stop.tv_usec) -
 123         ((double) timer->start.tv_usec) + ((double) timer->elapse.tv_usec )) / 1000000.0);
 124 #else
 125   return (double) timer->stop - (double) timer->start + (double)
 126     timer->elapse;
 127 #endif
 128 }
 129
 130 void xbt_os_walltimer_start(xbt_os_timer_t timer)
 131 {
 132 #ifdef HAVE_POSIX_GETTIME
 133   timer->elapse.tv_sec = 0;
 134   timer->elapse.tv_nsec = 0;
 135   clock_gettime(CLOCK_REALTIME, &(timer->start));
 136 #elif defined(HAVE_GETTIMEOFDAY)
 137   timer->elapse.tv_sec = 0;
 138   timer->elapse.tv_usec = 0;
 139   gettimeofday(&(timer->start), NULL);
 140 #elif defined(_XBT_WIN32)
 141   timer->elapse.tv_sec = 0;
 142   timer->elapse.tv_usec = 0;
 143 #  if defined(WIN32_WCE) || (_WIN32_WINNT < 0x0400)
 144   struct _timeb tm;
 145
 146   _ftime(&tm);
 147
 148   timer->start.tv_sec = tm.time;
 149   timer->start.tv_usec = tm.millitm * 1000;
 150
 151 #  else
 152   FILETIME ft;
 153   unsigned __int64 tm;
 154
 155   GetSystemTimeAsFileTime(&ft);
 156   tm = (unsigned __int64) ft.dwHighDateTime << 32;
 157   tm |= ft.dwLowDateTime;
 158   tm /= 10;
 159   tm -= 11644473600000000ULL;
 160
 161   timer->start.tv_sec = (long) (tm / 1000000L);
 162   timer->start.tv_usec = (long) (tm % 1000000L);
 163 #  endif                        /* windows version checker */
 164 #else
 165   timer->elapse = 0;
 166   timer->start = (unsigned long int) (time(NULL));
 167 #endif
 168 }
 169
 170 void xbt_os_walltimer_resume(xbt_os_timer_t timer)
 171 {
 172 #ifdef HAVE_POSIX_GETTIME
 173   timer->elapse.tv_sec += timer->stop.tv_sec - timer->start.tv_sec;
 174
 175    timer->elapse.tv_nsec += timer->stop.tv_nsec - timer->start.tv_nsec;
 176   clock_gettime(CLOCK_REALTIME, &(timer->start));
 177 #elif defined(HAVE_GETTIMEOFDAY)
 178   timer->elapse.tv_sec += timer->stop.tv_sec - timer->start.tv_sec;
 179   timer->elapse.tv_usec += timer->stop.tv_usec - timer->start.tv_usec;
 180   gettimeofday(&(timer->start), NULL);
 181 #elif defined(_XBT_WIN32)
 182   timer->elapse.tv_sec += timer->stop.tv_sec - timer->start.tv_sec;
 183   timer->elapse.tv_usec += timer->stop.tv_usec - timer->start.tv_usec;
 184 #  if defined(WIN32_WCE) || (_WIN32_WINNT < 0x0400)
 185   struct _timeb tm;
 186
 187   _ftime(&tm);
 188
 189   timer->start.tv_sec = tm.time;
 190   timer->start.tv_usec = tm.millitm * 1000;
 191
 192 #  else
 193   FILETIME ft;
 194   unsigned __int64 tm;
 195
 196   GetSystemTimeAsFileTime(&ft);
 197   tm = (unsigned __int64) ft.dwHighDateTime << 32;
 198   tm |= ft.dwLowDateTime;
 199   tm /= 10;
 200   tm -= 11644473600000000ULL;
 201
 202   timer->start.tv_sec = (long) (tm / 1000000L);
 203   timer->start.tv_usec = (long) (tm % 1000000L);
 204 #  endif
 205 #else
 206   timer->elapse = timer->stop - timer->start;
 207   timer->start = (unsigned long int) (time(NULL));
 208 #endif
 209 }
 210
 211 void xbt_os_walltimer_stop(xbt_os_timer_t timer)
 212 {
 213 #ifdef HAVE_POSIX_GETTIME
 214   clock_gettime(CLOCK_REALTIME, &(timer->stop));
 215 #elif defined(HAVE_GETTIMEOFDAY)
 216   gettimeofday(&(timer->stop), NULL);
 217 #elif defined(_XBT_WIN32)
 218 #  if defined(WIN32_WCE) || (_WIN32_WINNT < 0x0400)
 219   struct _timeb tm;
 220
 221   _ftime(&tm);
 222
 223   timer->stop.tv_sec = tm.time;
 224   timer->stop.tv_usec = tm.millitm * 1000;
 225
 226 #  else
 227   FILETIME ft;
 228   unsigned __int64 tm;
 229
 230   GetSystemTimeAsFileTime(&ft);
 231   tm = (unsigned __int64) ft.dwHighDateTime << 32;
 232   tm |= ft.dwLowDateTime;
 233   tm /= 10;
 234   tm -= 11644473600000000ULL;
 235
 236   timer->stop.tv_sec = (long) (tm / 1000000L);
 237   timer->stop.tv_usec = (long) (tm % 1000000L);
 238 #  endif
 239 #else
 240   timer->stop = (unsigned long int) (time(NULL));
 241 #endif
 242 }
 243
 244 void xbt_os_cputimer_start(xbt_os_timer_t timer)
 245 {
 246 #ifdef HAVE_POSIX_GETTIME
 247   timer->elapse.tv_sec = 0;
 248   timer->elapse.tv_nsec = 0;
 249   clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &(timer->start));
 250 #elif defined(_XBT_WIN32)
 251   timer->elapse.tv_sec = 0;
 252   timer->elapse.tv_nsec = 0;
 253 #  if defined(WIN32_WCE) || (_WIN32_WINNT < 0x0400)
 254   THROW_UNIMPLEMENTED;
 255 #  else
 256   HANDLE h = GetCurrentProcess();
 257   FILETIME creationTime, exitTime, kernelTime, userTime;
 258   GetProcessTimes(h, &creationTime, &exitTime, &kernelTime, &userTime);
 259   unsigned __int64 ktm, utm;
 260   ktm = (unsigned __int64) kernelTime.dwHighDateTime << 32;
 261   ktm |= kernelTime.dwLowDateTime;
 262   ktm /= 10;
 263   utm = (unsigned __int64) userTime.dwHighDateTime << 32;
 264   utm |= userTime.dwLowDateTime;
 265   utm /= 10;
 266   timer->start.tv_sec = (long) (ktm / 1000000L) + (long) (utm / 1000000L);
 267   timer->start.tv_usec = (long) (ktm % 1000000L) + (long) (utm % 1000000L);
 268 #  endif                        /* windows version checker */
 269 #endif
 270 }
 271
 272 void xbt_os_cputimer_resume(xbt_os_timer_t timer)
 273 {
 274 #ifdef HAVE_POSIX_GETTIME
 275   timer->elapse.tv_sec += timer->stop.tv_sec - timer->start.tv_sec;
 276   timer->elapse.tv_nsec += timer->stop.tv_nsec - timer->start.tv_nsec;
 277   clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &(timer->start));
 278 #elif defined(_XBT_WIN32)
 279   timer->elapse.tv_sec += timer->stop.tv_sec - timer->start.tv_sec;
 280   timer->elapse.tv_nsec += timer->stop.tv_nsec - timer->start.tv_nsec;
 281 #  if defined(WIN32_WCE) || (_WIN32_WINNT < 0x0400)
 282   THROW_UNIMPLEMENTED;
 283 #  else
 284   HANDLE h = GetCurrentProcess();
 285   FILETIME creationTime, exitTime, kernelTime, userTime;
 286   GetProcessTimes(h, &creationTime, &exitTime, &kernelTime, &userTime);
 287   unsigned __int64 ktm, utm;
 288   ktm = (unsigned __int64) kernelTime.dwHighDateTime << 32;
 289   ktm |= kernelTime.dwLowDateTime;
 290   ktm /= 10;
 291   utm = (unsigned __int64) userTime.dwHighDateTime << 32;
 292   utm |= userTime.dwLowDateTime;
 293   utm /= 10;
 294   timer->start.tv_sec = (long) (ktm / 1000000L) + (long) (utm / 1000000L);
 295   timer->start.tv_usec = (long) (ktm % 1000000L) + (long) (utm % 1000000L);
 296 #  endif                        /* windows version checker */
 297
 298 #endif
 299 }
 300
 301 void xbt_os_cputimer_stop(xbt_os_timer_t timer)
 302 {
 303 #ifdef HAVE_POSIX_GETTIME
 304   clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &(timer->stop));
 305 #elif defined(_XBT_WIN32)
 306 #  if defined(WIN32_WCE) || (_WIN32_WINNT < 0x0400)
 307   THROW_UNIMPLEMENTED;
 308 #  else
 309   HANDLE h = GetCurrentProcess();
 310   FILETIME creationTime, exitTime, kernelTime, userTime;
 311   GetProcessTimes(h, &creationTime, &exitTime, &kernelTime, &userTime);
 312   unsigned __int64 ktm, utm;
 313   ktm = (unsigned __int64) kernelTime.dwHighDateTime << 32;
 314   ktm |= kernelTime.dwLowDateTime;
 315   ktm /= 10;
 316   utm = (unsigned __int64) userTime.dwHighDateTime << 32;
 317   utm |= userTime.dwLowDateTime;
 318   utm /= 10;
 319   timer->stop.tv_sec = (long) (ktm / 1000000L) + (long) (utm / 1000000L);
 320   timer->stop.tv_usec = (long) (ktm % 1000000L) + (long) (utm % 1000000L);
 321 #  endif                        /* windows version checker */
 322 #endif
 323 }
 324
 325 void xbt_os_threadtimer_start(xbt_os_timer_t timer)
 326 {
 327 #ifdef HAVE_POSIX_GETTIME
 328   timer->elapse.tv_sec = 0;
 329   timer->elapse.tv_nsec = 0;
 330   clock_gettime(CLOCK_THREAD_CPUTIME_ID, &(timer->start));
 331 #elif defined(_XBT_WIN32)
 332   struct timeval tv;
 333 #  if defined(WIN32_WCE) || (_WIN32_WINNT < 0x0400)
 334   THROW_UNIMPLEMENTED;
 335 #  else
 336   HANDLE h = GetCurrentThread();
 337   FILETIME creationTime, exitTime, kernelTime, userTime;
 338   GetThreadTimes(h, &creationTime, &exitTime, &kernelTime, &userTime);
 339   unsigned __int64 ktm, utm;
 340   ktm = (unsigned __int64) kernelTime.dwHighDateTime << 32;
 341   ktm |= kernelTime.dwLowDateTime;
 342   ktm /= 10;
 343   utm = (unsigned __int64) userTime.dwHighDateTime << 32;
 344   utm |= userTime.dwLowDateTime;
 345   utm /= 10;
 346   timer->start.tv_sec = (long) (ktm / 1000000L) + (long) (utm / 1000000L);
 347   timer->start.tv_usec = (long) (ktm % 1000000L) + (long) (utm % 1000000L);
 348 #  endif                        /* windows version checker */
 349 #endif
 350 }
 351
 352 void xbt_os_threadtimer_resume(xbt_os_timer_t timer)
 353 {
 354 #ifdef HAVE_POSIX_GETTIME
 355   timer->elapse.tv_sec += timer->stop.tv_sec - timer->start.tv_sec;
 356   timer->elapse.tv_nsec += timer->stop.tv_nsec - timer->start.tv_nsec;
 357   clock_gettime(CLOCK_THREAD_CPUTIME_ID, &(timer->start));
 358 #elif defined(_XBT_WIN32)
 359   timer->elapse.tv_sec += timer->stop.tv_sec - timer->start.tv_sec;
 360   timer->elapse.tv_nsec += timer->stop.tv_nsec - timer->start.tv_nsec;
 361 #  if defined(WIN32_WCE) || (_WIN32_WINNT < 0x0400)
 362   THROW_UNIMPLEMENTED;
 363 #  else
 364   HANDLE h = GetCurrentThread();
 365   FILETIME creationTime, exitTime, kernelTime, userTime;
 366   GetThreadTimes(h, &creationTime, &exitTime, &kernelTime, &userTime);
 367   unsigned __int64 ktm, utm;
 368   ktm = (unsigned __int64) kernelTime.dwHighDateTime << 32;
 369   ktm |= kernelTime.dwLowDateTime;
 370   ktm /= 10;
 371   utm = (unsigned __int64) userTime.dwHighDateTime << 32;
 372   utm |= userTime.dwLowDateTime;
 373   utm /= 10;
 374   timer->start.tv_sec = (long) (ktm / 1000000L) + (long) (utm / 1000000L);
 375   timer->start.tv_usec = (long) (ktm % 1000000L) + (long) (utm % 1000000L);
 376 #  endif                        /* windows version checker */
 377 #endif
 378 }
 379
 380 void xbt_os_threadtimer_stop(xbt_os_timer_t timer)
 381 {
 382 #ifdef HAVE_POSIX_GETTIME
 383   clock_gettime(CLOCK_THREAD_CPUTIME_ID, &(timer->stop));
 384 #elif defined(_XBT_WIN32)
 385 #  if defined(WIN32_WCE) || (_WIN32_WINNT < 0x0400)
 386   THROW_UNIMPLEMENTED;
 387 #  else
 388   HANDLE h = GetCurrentThread();
 389   FILETIME creationTime, exitTime, kernelTime, userTime;
 390   GetThreadTimes(h, &creationTime, &exitTime, &kernelTime, &userTime);
 391   unsigned __int64 ktm, utm;
 392   ktm = (unsigned __int64) kernelTime.dwHighDateTime << 32;
 393   ktm |= kernelTime.dwLowDateTime;
 394   ktm /= 10;
 395   utm = (unsigned __int64) userTime.dwHighDateTime << 32;
 396   utm |= userTime.dwLowDateTime;
 397   utm /= 10;
 398   timer->stop.tv_sec = (long) (ktm / 1000000L) + (long) (utm / 1000000L);
 399   timer->stop.tv_usec = (long) (ktm % 1000000L) + (long) (utm % 1000000L);
 400 #  endif                        /* windows version checker */
 401 #endif
 402 }