src/xbt/xbt_os_time.c

   1 /* xbt_os_time.c -- portable interface to time-related functions            */
   2
   3 /* Copyright (c) 2007-2010, 2012-2014. 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_CPUTIME_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) || defined(_XBT_WIN32)
  96   struct timeval start, stop, elapse;
  97 #else
  98   unsigned long int start, stop, elapse;
  99 #endif
 100 };
 101
 102 size_t xbt_os_timer_size(void){
 103   return sizeof(struct s_xbt_os_timer);
 104 }
 105
 106 xbt_os_timer_t xbt_os_timer_new(void)
 107 {
 108   return xbt_new0(struct s_xbt_os_timer, 1);
 109 }
 110
 111 void xbt_os_timer_free(xbt_os_timer_t timer)
 112 {
 113   free(timer);
 114 }
 115
 116 double xbt_os_timer_elapsed(xbt_os_timer_t timer)
 117 {
 118 #ifdef HAVE_POSIX_GETTIME
 119   return ((double) timer->stop.tv_sec) - ((double) timer->start.tv_sec) +
 120                                           ((double) timer->elapse.tv_sec ) +
 121       ((((double) timer->stop.tv_nsec) -
 122         ((double) timer->start.tv_nsec) + ((double) timer->elapse.tv_nsec )) / 1e9);
 123 #elif defined(HAVE_GETTIMEOFDAY) || defined(_XBT_WIN32)
 124   return ((double) timer->stop.tv_sec) - ((double) timer->start.tv_sec)
 125     + ((double) timer->elapse.tv_sec ) +
 126       ((((double) timer->stop.tv_usec) -
 127         ((double) timer->start.tv_usec) + ((double) timer->elapse.tv_usec )) / 1000000.0);
 128 #else
 129   return (double) timer->stop - (double) timer->start + (double)
 130     timer->elapse;
 131 #endif
 132 }
 133
 134 void xbt_os_walltimer_start(xbt_os_timer_t timer)
 135 {
 136 #ifdef HAVE_POSIX_GETTIME
 137   timer->elapse.tv_sec = 0;
 138   timer->elapse.tv_nsec = 0;
 139   clock_gettime(CLOCK_REALTIME, &(timer->start));
 140 #elif defined(HAVE_GETTIMEOFDAY)
 141   timer->elapse.tv_sec = 0;
 142   timer->elapse.tv_usec = 0;
 143   gettimeofday(&(timer->start), NULL);
 144 #elif defined(_XBT_WIN32)
 145   timer->elapse.tv_sec = 0;
 146   timer->elapse.tv_usec = 0;
 147 #  if defined(WIN32_WCE) || (_WIN32_WINNT < 0x0400)
 148   struct _timeb tm;
 149
 150   _ftime(&tm);
 151
 152   timer->start.tv_sec = tm.time;
 153   timer->start.tv_usec = tm.millitm * 1000;
 154
 155 #  else
 156   FILETIME ft;
 157   unsigned __int64 tm;
 158
 159   GetSystemTimeAsFileTime(&ft);
 160   tm = (unsigned __int64) ft.dwHighDateTime << 32;
 161   tm |= ft.dwLowDateTime;
 162   tm /= 10;
 163   tm -= 11644473600000000ULL;
 164
 165   timer->start.tv_sec = (long) (tm / 1000000L);
 166   timer->start.tv_usec = (long) (tm % 1000000L);
 167 #  endif                        /* windows version checker */
 168 #else
 169   timer->elapse = 0;
 170   timer->start = (unsigned long int) (time(NULL));
 171 #endif
 172 }
 173
 174 void xbt_os_walltimer_resume(xbt_os_timer_t timer)
 175 {
 176 #ifdef HAVE_POSIX_GETTIME
 177   timer->elapse.tv_sec += timer->stop.tv_sec - timer->start.tv_sec;
 178
 179    timer->elapse.tv_nsec += timer->stop.tv_nsec - timer->start.tv_nsec;
 180   clock_gettime(CLOCK_REALTIME, &(timer->start));
 181 #elif defined(HAVE_GETTIMEOFDAY)
 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   gettimeofday(&(timer->start), NULL);
 185 #elif defined(_XBT_WIN32)
 186   timer->elapse.tv_sec += timer->stop.tv_sec - timer->start.tv_sec;
 187   timer->elapse.tv_usec += timer->stop.tv_usec - timer->start.tv_usec;
 188 #  if defined(WIN32_WCE) || (_WIN32_WINNT < 0x0400)
 189   struct _timeb tm;
 190
 191   _ftime(&tm);
 192
 193   timer->start.tv_sec = tm.time;
 194   timer->start.tv_usec = tm.millitm * 1000;
 195
 196 #  else
 197   FILETIME ft;
 198   unsigned __int64 tm;
 199
 200   GetSystemTimeAsFileTime(&ft);
 201   tm = (unsigned __int64) ft.dwHighDateTime << 32;
 202   tm |= ft.dwLowDateTime;
 203   tm /= 10;
 204   tm -= 11644473600000000ULL;
 205
 206   timer->start.tv_sec = (long) (tm / 1000000L);
 207   timer->start.tv_usec = (long) (tm % 1000000L);
 208 #  endif
 209 #else
 210   timer->elapse = timer->stop - timer->start;
 211   timer->start = (unsigned long int) (time(NULL));
 212 #endif
 213 }
 214
 215 void xbt_os_walltimer_stop(xbt_os_timer_t timer)
 216 {
 217 #ifdef HAVE_POSIX_GETTIME
 218   clock_gettime(CLOCK_REALTIME, &(timer->stop));
 219 #elif defined(HAVE_GETTIMEOFDAY)
 220   gettimeofday(&(timer->stop), NULL);
 221 #elif defined(_XBT_WIN32)
 222 #  if defined(WIN32_WCE) || (_WIN32_WINNT < 0x0400)
 223   struct _timeb tm;
 224
 225   _ftime(&tm);
 226
 227   timer->stop.tv_sec = tm.time;
 228   timer->stop.tv_usec = tm.millitm * 1000;
 229
 230 #  else
 231   FILETIME ft;
 232   unsigned __int64 tm;
 233
 234   GetSystemTimeAsFileTime(&ft);
 235   tm = (unsigned __int64) ft.dwHighDateTime << 32;
 236   tm |= ft.dwLowDateTime;
 237   tm /= 10;
 238   tm -= 11644473600000000ULL;
 239
 240   timer->stop.tv_sec = (long) (tm / 1000000L);
 241   timer->stop.tv_usec = (long) (tm % 1000000L);
 242 #  endif
 243 #else
 244   timer->stop = (unsigned long int) (time(NULL));
 245 #endif
 246 }
 247
 248 void xbt_os_cputimer_start(xbt_os_timer_t timer)
 249 {
 250 #ifdef HAVE_POSIX_GETTIME
 251   timer->elapse.tv_sec = 0;
 252   timer->elapse.tv_nsec = 0;
 253   clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &(timer->start));
 254 #elif defined(HAVE_GETTIMEOFDAY)//return time and not cputime in this case
 255   timer->elapse.tv_sec = 0;
 256   timer->elapse.tv_usec = 0;
 257   gettimeofday(&(timer->start), NULL);
 258 #elif defined(_XBT_WIN32)
 259   timer->elapse.tv_sec = 0;
 260   timer->elapse.tv_usec = 0;
 261 #  if defined(WIN32_WCE) || (_WIN32_WINNT < 0x0400)
 262   THROW_UNIMPLEMENTED;
 263 #  else
 264   HANDLE h = GetCurrentProcess();
 265   FILETIME creationTime, exitTime, kernelTime, userTime;
 266   GetProcessTimes(h, &creationTime, &exitTime, &kernelTime, &userTime);
 267   unsigned __int64 ktm, utm;
 268   ktm = (unsigned __int64) kernelTime.dwHighDateTime << 32;
 269   ktm |= kernelTime.dwLowDateTime;
 270   ktm /= 10;
 271   utm = (unsigned __int64) userTime.dwHighDateTime << 32;
 272   utm |= userTime.dwLowDateTime;
 273   utm /= 10;
 274   timer->start.tv_sec = (long) (ktm / 1000000L) + (long) (utm / 1000000L);
 275   timer->start.tv_usec = (long) (ktm % 1000000L) + (long) (utm % 1000000L);
 276 #  endif                        /* windows version checker */
 277 #endif
 278 }
 279
 280 void xbt_os_cputimer_resume(xbt_os_timer_t timer)
 281 {
 282 #ifdef HAVE_POSIX_GETTIME
 283   timer->elapse.tv_sec += timer->stop.tv_sec - timer->start.tv_sec;
 284   timer->elapse.tv_nsec += timer->stop.tv_nsec - timer->start.tv_nsec;
 285   clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &(timer->start));
 286 #elif defined(HAVE_GETTIMEOFDAY)
 287   timer->elapse.tv_sec += timer->stop.tv_sec - timer->start.tv_sec;
 288   timer->elapse.tv_usec += timer->stop.tv_usec - timer->start.tv_usec;
 289   gettimeofday(&(timer->start), NULL);
 290 #elif defined(_XBT_WIN32)
 291   timer->elapse.tv_sec += timer->stop.tv_sec - timer->start.tv_sec;
 292   timer->elapse.tv_usec += timer->stop.tv_usec - timer->start.tv_usec;
 293 #  if defined(WIN32_WCE) || (_WIN32_WINNT < 0x0400)
 294   THROW_UNIMPLEMENTED;
 295 #  else
 296   HANDLE h = GetCurrentProcess();
 297   FILETIME creationTime, exitTime, kernelTime, userTime;
 298   GetProcessTimes(h, &creationTime, &exitTime, &kernelTime, &userTime);
 299   unsigned __int64 ktm, utm;
 300   ktm = (unsigned __int64) kernelTime.dwHighDateTime << 32;
 301   ktm |= kernelTime.dwLowDateTime;
 302   ktm /= 10;
 303   utm = (unsigned __int64) userTime.dwHighDateTime << 32;
 304   utm |= userTime.dwLowDateTime;
 305   utm /= 10;
 306   timer->start.tv_sec = (long) (ktm / 1000000L) + (long) (utm / 1000000L);
 307   timer->start.tv_usec = (long) (ktm % 1000000L) + (long) (utm % 1000000L);
 308 #  endif                        /* windows version checker */
 309
 310 #endif
 311 }
 312
 313 void xbt_os_cputimer_stop(xbt_os_timer_t timer)
 314 {
 315 #ifdef HAVE_POSIX_GETTIME
 316   clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &(timer->stop));
 317 #elif defined(HAVE_GETTIMEOFDAY)
 318   gettimeofday(&(timer->stop), NULL);
 319 #elif defined(_XBT_WIN32)
 320 #  if defined(WIN32_WCE) || (_WIN32_WINNT < 0x0400)
 321   THROW_UNIMPLEMENTED;
 322 #  else
 323   HANDLE h = GetCurrentProcess();
 324   FILETIME creationTime, exitTime, kernelTime, userTime;
 325   GetProcessTimes(h, &creationTime, &exitTime, &kernelTime, &userTime);
 326   unsigned __int64 ktm, utm;
 327   ktm = (unsigned __int64) kernelTime.dwHighDateTime << 32;
 328   ktm |= kernelTime.dwLowDateTime;
 329   ktm /= 10;
 330   utm = (unsigned __int64) userTime.dwHighDateTime << 32;
 331   utm |= userTime.dwLowDateTime;
 332   utm /= 10;
 333   timer->stop.tv_sec = (long) (ktm / 1000000L) + (long) (utm / 1000000L);
 334   timer->stop.tv_usec = (long) (ktm % 1000000L) + (long) (utm % 1000000L);
 335 #  endif                        /* windows version checker */
 336 #endif
 337 }
 338
 339 void xbt_os_threadtimer_start(xbt_os_timer_t timer)
 340 {
 341 #ifdef HAVE_POSIX_GETTIME
 342   timer->elapse.tv_sec = 0;
 343   timer->elapse.tv_nsec = 0;
 344   clock_gettime(CLOCK_THREAD_CPUTIME_ID, &(timer->start));
 345 #elif defined(HAVE_GETTIMEOFDAY)//return time and not cputime in this case
 346   timer->elapse.tv_sec = 0;
 347   timer->elapse.tv_usec = 0;
 348   gettimeofday(&(timer->start), NULL);
 349 #elif defined(_XBT_WIN32)
 350   struct timeval tv;
 351 #  if defined(WIN32_WCE) || (_WIN32_WINNT < 0x0400)
 352   THROW_UNIMPLEMENTED;
 353 #  else
 354   HANDLE h = GetCurrentThread();
 355   FILETIME creationTime, exitTime, kernelTime, userTime;
 356   GetThreadTimes(h, &creationTime, &exitTime, &kernelTime, &userTime);
 357   unsigned __int64 ktm, utm;
 358   ktm = (unsigned __int64) kernelTime.dwHighDateTime << 32;
 359   ktm |= kernelTime.dwLowDateTime;
 360   ktm /= 10;
 361   utm = (unsigned __int64) userTime.dwHighDateTime << 32;
 362   utm |= userTime.dwLowDateTime;
 363   utm /= 10;
 364   timer->start.tv_sec = (long) (ktm / 1000000L) + (long) (utm / 1000000L);
 365   timer->start.tv_usec = (long) (ktm % 1000000L) + (long) (utm % 1000000L);
 366 #  endif                        /* windows version checker */
 367 #endif
 368 }
 369
 370 void xbt_os_threadtimer_resume(xbt_os_timer_t timer)
 371 {
 372 #ifdef HAVE_POSIX_GETTIME
 373   timer->elapse.tv_sec += timer->stop.tv_sec - timer->start.tv_sec;
 374   timer->elapse.tv_nsec += timer->stop.tv_nsec - timer->start.tv_nsec;
 375   clock_gettime(CLOCK_THREAD_CPUTIME_ID, &(timer->start));
 376 #elif defined(HAVE_GETTIMEOFDAY)
 377   timer->elapse.tv_sec += timer->stop.tv_sec - timer->start.tv_sec;
 378   timer->elapse.tv_usec += timer->stop.tv_usec - timer->start.tv_usec;
 379   gettimeofday(&(timer->start), NULL);
 380 #elif defined(_XBT_WIN32)
 381   timer->elapse.tv_sec += timer->stop.tv_sec - timer->start.tv_sec;
 382   timer->elapse.tv_usec += timer->stop.tv_usec - timer->start.tv_usec;
 383 #  if defined(WIN32_WCE) || (_WIN32_WINNT < 0x0400)
 384   THROW_UNIMPLEMENTED;
 385 #  else
 386   HANDLE h = GetCurrentThread();
 387   FILETIME creationTime, exitTime, kernelTime, userTime;
 388   GetThreadTimes(h, &creationTime, &exitTime, &kernelTime, &userTime);
 389   unsigned __int64 ktm, utm;
 390   ktm = (unsigned __int64) kernelTime.dwHighDateTime << 32;
 391   ktm |= kernelTime.dwLowDateTime;
 392   ktm /= 10;
 393   utm = (unsigned __int64) userTime.dwHighDateTime << 32;
 394   utm |= userTime.dwLowDateTime;
 395   utm /= 10;
 396   timer->start.tv_sec = (long) (ktm / 1000000L) + (long) (utm / 1000000L);
 397   timer->start.tv_usec = (long) (ktm % 1000000L) + (long) (utm % 1000000L);
 398 #  endif                        /* windows version checker */
 399 #endif
 400 }
 401
 402 void xbt_os_threadtimer_stop(xbt_os_timer_t timer)
 403 {
 404 #ifdef HAVE_POSIX_GETTIME
 405   clock_gettime(CLOCK_THREAD_CPUTIME_ID, &(timer->stop));
 406 #elif defined(HAVE_GETTIMEOFDAY)//if nothing else is available, return just time
 407   gettimeofday(&(timer->stop), NULL);
 408 #elif defined(_XBT_WIN32)
 409 #  if defined(WIN32_WCE) || (_WIN32_WINNT < 0x0400)
 410   THROW_UNIMPLEMENTED;
 411 #  else
 412   HANDLE h = GetCurrentThread();
 413   FILETIME creationTime, exitTime, kernelTime, userTime;
 414   GetThreadTimes(h, &creationTime, &exitTime, &kernelTime, &userTime);
 415   unsigned __int64 ktm, utm;
 416   ktm = (unsigned __int64) kernelTime.dwHighDateTime << 32;
 417   ktm |= kernelTime.dwLowDateTime;
 418   ktm /= 10;
 419   utm = (unsigned __int64) userTime.dwHighDateTime << 32;
 420   utm |= userTime.dwLowDateTime;
 421   utm /= 10;
 422   timer->stop.tv_sec = (long) (ktm / 1000000L) + (long) (utm / 1000000L);
 423   timer->stop.tv_usec = (long) (ktm % 1000000L) + (long) (utm % 1000000L);
 424 #  endif                        /* windows version checker */
 425 #endif
 426 }