src/xbt/xbt_os_time.c

   1 /* xbt_os_time.c -- portable interface to time-related functions            */
   2
   3 /* Copyright (c) 2007-2010, 2012-2013. 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) || 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(_XBT_WIN32)
 255   timer->elapse.tv_sec = 0;
 256   timer->elapse.tv_usec = 0;
 257 #  if defined(WIN32_WCE) || (_WIN32_WINNT < 0x0400)
 258   THROW_UNIMPLEMENTED;
 259 #  else
 260   HANDLE h = GetCurrentProcess();
 261   FILETIME creationTime, exitTime, kernelTime, userTime;
 262   GetProcessTimes(h, &creationTime, &exitTime, &kernelTime, &userTime);
 263   unsigned __int64 ktm, utm;
 264   ktm = (unsigned __int64) kernelTime.dwHighDateTime << 32;
 265   ktm |= kernelTime.dwLowDateTime;
 266   ktm /= 10;
 267   utm = (unsigned __int64) userTime.dwHighDateTime << 32;
 268   utm |= userTime.dwLowDateTime;
 269   utm /= 10;
 270   timer->start.tv_sec = (long) (ktm / 1000000L) + (long) (utm / 1000000L);
 271   timer->start.tv_usec = (long) (ktm % 1000000L) + (long) (utm % 1000000L);
 272 #  endif                        /* windows version checker */
 273 #endif
 274 }
 275
 276 void xbt_os_cputimer_resume(xbt_os_timer_t timer)
 277 {
 278 #ifdef HAVE_POSIX_GETTIME
 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   clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &(timer->start));
 282 #elif defined(_XBT_WIN32)
 283   timer->elapse.tv_sec += timer->stop.tv_sec - timer->start.tv_sec;
 284   timer->elapse.tv_usec += timer->stop.tv_usec - timer->start.tv_usec;
 285 #  if defined(WIN32_WCE) || (_WIN32_WINNT < 0x0400)
 286   THROW_UNIMPLEMENTED;
 287 #  else
 288   HANDLE h = GetCurrentProcess();
 289   FILETIME creationTime, exitTime, kernelTime, userTime;
 290   GetProcessTimes(h, &creationTime, &exitTime, &kernelTime, &userTime);
 291   unsigned __int64 ktm, utm;
 292   ktm = (unsigned __int64) kernelTime.dwHighDateTime << 32;
 293   ktm |= kernelTime.dwLowDateTime;
 294   ktm /= 10;
 295   utm = (unsigned __int64) userTime.dwHighDateTime << 32;
 296   utm |= userTime.dwLowDateTime;
 297   utm /= 10;
 298   timer->start.tv_sec = (long) (ktm / 1000000L) + (long) (utm / 1000000L);
 299   timer->start.tv_usec = (long) (ktm % 1000000L) + (long) (utm % 1000000L);
 300 #  endif                        /* windows version checker */
 301
 302 #endif
 303 }
 304
 305 void xbt_os_cputimer_stop(xbt_os_timer_t timer)
 306 {
 307 #ifdef HAVE_POSIX_GETTIME
 308   clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &(timer->stop));
 309 #elif defined(_XBT_WIN32)
 310 #  if defined(WIN32_WCE) || (_WIN32_WINNT < 0x0400)
 311   THROW_UNIMPLEMENTED;
 312 #  else
 313   HANDLE h = GetCurrentProcess();
 314   FILETIME creationTime, exitTime, kernelTime, userTime;
 315   GetProcessTimes(h, &creationTime, &exitTime, &kernelTime, &userTime);
 316   unsigned __int64 ktm, utm;
 317   ktm = (unsigned __int64) kernelTime.dwHighDateTime << 32;
 318   ktm |= kernelTime.dwLowDateTime;
 319   ktm /= 10;
 320   utm = (unsigned __int64) userTime.dwHighDateTime << 32;
 321   utm |= userTime.dwLowDateTime;
 322   utm /= 10;
 323   timer->stop.tv_sec = (long) (ktm / 1000000L) + (long) (utm / 1000000L);
 324   timer->stop.tv_usec = (long) (ktm % 1000000L) + (long) (utm % 1000000L);
 325 #  endif                        /* windows version checker */
 326 #endif
 327 }
 328
 329 void xbt_os_threadtimer_start(xbt_os_timer_t timer)
 330 {
 331 #ifdef HAVE_POSIX_GETTIME
 332   timer->elapse.tv_sec = 0;
 333   timer->elapse.tv_nsec = 0;
 334   clock_gettime(CLOCK_THREAD_CPUTIME_ID, &(timer->start));
 335 #elif defined(_XBT_WIN32)
 336   struct timeval tv;
 337 #  if defined(WIN32_WCE) || (_WIN32_WINNT < 0x0400)
 338   THROW_UNIMPLEMENTED;
 339 #  else
 340   HANDLE h = GetCurrentThread();
 341   FILETIME creationTime, exitTime, kernelTime, userTime;
 342   GetThreadTimes(h, &creationTime, &exitTime, &kernelTime, &userTime);
 343   unsigned __int64 ktm, utm;
 344   ktm = (unsigned __int64) kernelTime.dwHighDateTime << 32;
 345   ktm |= kernelTime.dwLowDateTime;
 346   ktm /= 10;
 347   utm = (unsigned __int64) userTime.dwHighDateTime << 32;
 348   utm |= userTime.dwLowDateTime;
 349   utm /= 10;
 350   timer->start.tv_sec = (long) (ktm / 1000000L) + (long) (utm / 1000000L);
 351   timer->start.tv_usec = (long) (ktm % 1000000L) + (long) (utm % 1000000L);
 352 #  endif                        /* windows version checker */
 353 #endif
 354 }
 355
 356 void xbt_os_threadtimer_resume(xbt_os_timer_t timer)
 357 {
 358 #ifdef HAVE_POSIX_GETTIME
 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   clock_gettime(CLOCK_THREAD_CPUTIME_ID, &(timer->start));
 362 #elif defined(_XBT_WIN32)
 363   timer->elapse.tv_sec += timer->stop.tv_sec - timer->start.tv_sec;
 364   timer->elapse.tv_usec += timer->stop.tv_usec - timer->start.tv_usec;
 365 #  if defined(WIN32_WCE) || (_WIN32_WINNT < 0x0400)
 366   THROW_UNIMPLEMENTED;
 367 #  else
 368   HANDLE h = GetCurrentThread();
 369   FILETIME creationTime, exitTime, kernelTime, userTime;
 370   GetThreadTimes(h, &creationTime, &exitTime, &kernelTime, &userTime);
 371   unsigned __int64 ktm, utm;
 372   ktm = (unsigned __int64) kernelTime.dwHighDateTime << 32;
 373   ktm |= kernelTime.dwLowDateTime;
 374   ktm /= 10;
 375   utm = (unsigned __int64) userTime.dwHighDateTime << 32;
 376   utm |= userTime.dwLowDateTime;
 377   utm /= 10;
 378   timer->start.tv_sec = (long) (ktm / 1000000L) + (long) (utm / 1000000L);
 379   timer->start.tv_usec = (long) (ktm % 1000000L) + (long) (utm % 1000000L);
 380 #  endif                        /* windows version checker */
 381 #endif
 382 }
 383
 384 void xbt_os_threadtimer_stop(xbt_os_timer_t timer)
 385 {
 386 #ifdef HAVE_POSIX_GETTIME
 387   clock_gettime(CLOCK_THREAD_CPUTIME_ID, &(timer->stop));
 388 #elif defined(_XBT_WIN32)
 389 #  if defined(WIN32_WCE) || (_WIN32_WINNT < 0x0400)
 390   THROW_UNIMPLEMENTED;
 391 #  else
 392   HANDLE h = GetCurrentThread();
 393   FILETIME creationTime, exitTime, kernelTime, userTime;
 394   GetThreadTimes(h, &creationTime, &exitTime, &kernelTime, &userTime);
 395   unsigned __int64 ktm, utm;
 396   ktm = (unsigned __int64) kernelTime.dwHighDateTime << 32;
 397   ktm |= kernelTime.dwLowDateTime;
 398   ktm /= 10;
 399   utm = (unsigned __int64) userTime.dwHighDateTime << 32;
 400   utm |= userTime.dwLowDateTime;
 401   utm /= 10;
 402   timer->stop.tv_sec = (long) (ktm / 1000000L) + (long) (utm / 1000000L);
 403   timer->stop.tv_usec = (long) (ktm % 1000000L) + (long) (utm % 1000000L);
 404 #  endif                        /* windows version checker */
 405 #endif
 406 }