lib/os_time.c

   1 /* File: "os_time.c", Time-stamp: <2011-03-22 14:38:49 feeley> */
   2
   3 /* Copyright (c) 1994-2008 by Marc Feeley, All Rights Reserved. */
   4
   5 /*
   6  * This module implements the operating system specific routines
   7  * related to time.
   8  */
   9
  10 #define ___INCLUDED_FROM_OS_TIME
  11 #define ___VERSION 406003
  12 #include "gambit.h"
  13
  14 #include "os_base.h"
  15 #include "os_time.h"
  16
  17
  18 /*---------------------------------------------------------------------------*/
  19
  20
  21 ___time_module ___time_mod =
  22 {
  23   0,
  24   TIME_POS_INFINITY,
  25   TIME_NEG_INFINITY,
  26   0.0,
  27   -1.0,
  28   NULL
  29
  30 #ifdef ___TIME_MODULE_INIT
  31   ___TIME_MODULE_INIT
  32 #endif
  33 };
  34
  35
  36 /*---------------------------------------------------------------------------*/
  37
  38 /* Time management. */
  39
  40
  41 void ___time_from_nsecs
  42    ___P((___time *tim,
  43          ___SM32 secs,
  44          ___SM32 nsecs),
  45         (tim,
  46          secs,
  47          nsecs)
  48 ___time *tim;
  49 ___SM32 secs;
  50 ___SM32 nsecs;)
  51 {
  52 #ifdef ___FLOAT_TIME_REPRESENTATION
  53   *tim = secs + nsecs / 1000000000.0;
  54 #endif
  55
  56 #ifdef ___INT_TIME_REPRESENTATION
  57   tim->secs = secs + nsecs / 1000000000;
  58   tim->nsecs = nsecs % 1000000000;
  59 #endif
  60 }
  61
  62
  63 void ___time_add
  64    ___P((___time *tim1,
  65          ___time tim2),
  66         (tim1,
  67          tim2)
  68 ___time *tim1;
  69 ___time tim2;)
  70 {
  71 #ifdef ___FLOAT_TIME_REPRESENTATION
  72   *tim1 += tim2;
  73 #endif
  74
  75 #ifdef ___INT_TIME_REPRESENTATION
  76   ___SM32 total_secs = tim1->secs + tim2.secs;
  77   ___SM32 total_nsecs = tim1->nsecs + tim2.nsecs;
  78   tim1->secs += tim2.secs + total_nsecs / 1000000000;
  79   tim1->nsecs = total_nsecs % 1000000000;
  80 #endif
  81 }
  82
  83
  84 void ___time_subtract
  85    ___P((___time *tim1,
  86          ___time tim2),
  87         (tim1,
  88          tim2)
  89 ___time *tim1;
  90 ___time tim2;)
  91 {
  92 #ifdef ___FLOAT_TIME_REPRESENTATION
  93   *tim1 -= tim2;
  94 #endif
  95
  96 #ifdef ___INT_TIME_REPRESENTATION
  97   ___SM32 total_nsecs;
  98
  99   if (tim2.nsecs > tim1->nsecs)
 100     {
 101       tim1->secs -= tim2.secs + 1;
 102       tim1->nsecs += 1000000000 - tim2.nsecs;
 103     }
 104   else
 105     {
 106       tim1->secs -= tim2.secs;
 107       tim1->nsecs -= tim2.nsecs;
 108     }
 109 #endif
 110 }
 111
 112
 113 ___BOOL ___time_equal
 114    ___P((___time tim1,
 115          ___time tim2),
 116         (tim1,
 117          tim2)
 118 ___time tim1;
 119 ___time tim2;)
 120 {
 121 #ifdef ___FLOAT_TIME_REPRESENTATION
 122   return (tim1 == tim2);
 123 #endif
 124
 125 #ifdef ___INT_TIME_REPRESENTATION
 126   return (tim1.secs == tim2.secs && tim1.nsecs == tim2.nsecs);
 127 #endif
 128 }
 129
 130
 131 ___BOOL ___time_less
 132    ___P((___time tim1,
 133          ___time tim2),
 134         (tim1,
 135          tim2)
 136 ___time tim1;
 137 ___time tim2;)
 138 {
 139 #ifdef ___FLOAT_TIME_REPRESENTATION
 140   return (tim1 < tim2);
 141 #endif
 142
 143 #ifdef ___INT_TIME_REPRESENTATION
 144   return (tim1.secs < tim2.secs ||
 145           (tim1.secs == tim2.secs && tim1.nsecs < tim2.nsecs));
 146 #endif
 147 }
 148
 149
 150 ___BOOL ___time_positive
 151    ___P((___time tim),
 152         (tim)
 153 ___time tim;)
 154 {
 155 #ifdef ___FLOAT_TIME_REPRESENTATION
 156   return (tim > 0.0);
 157 #endif
 158
 159 #ifdef ___INT_TIME_REPRESENTATION
 160   return (tim.secs > 0 ||
 161           (tim.secs == 0 && tim.nsecs > 0));
 162 #endif
 163 }
 164
 165
 166 void ___time_get_current_time
 167    ___P((___time *tim),
 168         (tim)
 169 ___time *tim;)
 170 {
 171 #ifndef USE_clock_gettime
 172 #ifndef USE_getclock
 173 #ifndef USE_GetSystemTime
 174 #ifndef USE_gettimeofday
 175 #ifndef USE_ftime
 176 #ifndef USE_time
 177 #ifndef USE_CLASSIC_MACOS
 178
 179   *tim = ___time_mod.time_neg_infinity;
 180
 181 #endif
 182 #endif
 183 #endif
 184 #endif
 185 #endif
 186 #endif
 187 #endif
 188
 189 #ifdef USE_clock_gettime
 190
 191   /* The clock_gettime function is in POSIX.1b (realtime programming). */
 192
 193   struct timespec ts;
 194   if (clock_gettime (CLOCK_REALTIME, &ts) == 0)
 195     ___time_from_nsecs (tim, ts.tv_sec-JAN_1(1970), ts.tv_nsec);
 196   else
 197     *tim = ___time_mod.time_neg_infinity;
 198
 199 #endif
 200
 201 #ifdef USE_getclock
 202
 203   /* The getclock function is in the Tru64 UNIX standard C library. */
 204
 205   struct timespec ts;
 206   if (getclock (TIMEOFDAY, &ts) == 0)
 207     ___time_from_nsecs (tim, ts.tv_sec-JAN_1(1970), ts.tv_nsec);
 208   else
 209     *tim = ___time_mod.time_neg_infinity;
 210
 211 #endif
 212
 213 #ifdef USE_GetSystemTime
 214
 215   SYSTEMTIME st;
 216   FILETIME ft;
 217   GetSystemTime (&st);
 218   if (SystemTimeToFileTime (&st, &ft))
 219     {
 220       LONGLONG x = *___CAST(LONGLONG*,&ft);
 221       ___SM32 secs = x / 10000000 - JAN_1(1601LL);
 222       ___SM32 nsecs = x % 10000000 * 100;
 223       ___time_from_nsecs (tim, secs, nsecs);
 224     }
 225   else
 226     *tim = ___time_mod.time_neg_infinity;
 227
 228 #endif
 229
 230 #ifdef USE_gettimeofday
 231
 232   struct timeval tv;
 233   if (gettimeofday (&tv, NULL) == 0)
 234     ___time_from_nsecs (tim, tv.tv_sec-JAN_1(1970), tv.tv_usec*1000);
 235   else
 236     *tim = ___time_mod.time_neg_infinity;
 237
 238 #endif
 239
 240 #ifdef USE_ftime
 241
 242   struct timeb tb;
 243   ftime (&tb);
 244   ___time_from_nsecs (tim, tb.time-JAN_1(1970), tb.millitm*1000000);
 245
 246 #endif
 247
 248 #ifdef USE_time
 249
 250   time_t t;
 251   time (&t);
 252   ___time_from_nsecs (tim, t-JAN_1(1970), 0);
 253
 254 #endif
 255
 256 #ifdef USE_CLASSIC_MACOS
 257
 258   if (has_GetUTCDateTime)
 259     {
 260       UTCDateTime dt;
 261
 262       if (GetUTCDateTime (&dt, kUTCDefaultOptions) == noErr)
 263         ___time_from_nsecs (tim,
 264                             dt.lowSeconds-JAN_1(1904),
 265                             ___CAST(___SM32,dt.fraction)*15258 +
 266                             ((___CAST(___SM32,dt.fraction)*101)>>7));
 267       else
 268         *tim = ___time_mod.time_neg_infinity;
 269     }
 270   else if (has_GetDateTime)
 271     {
 272       unsigned long t;
 273
 274       GetDateTime (&t);  /* Get seconds since 01-01-1904 in local time. */
 275
 276       if (has_ReadLocation)
 277         {
 278           /* Adjust to UTC based on machine location. */
 279
 280           MachineLocation here;
 281           long offset;
 282
 283           ReadLocation (&here);
 284           offset = here.u.gmtDelta & 0x00ffffff;
 285           if (offset & 0x00800000)
 286             offset |= 0xff000000;
 287           t -= offset;
 288         }
 289
 290       ___time_from_nsecs (tim, t-JAN_1(1904), 0);
 291     }
 292   else
 293     *tim = ___time_mod.time_neg_infinity;
 294
 295 #endif
 296 }
 297
 298
 299 void ___time_to_seconds
 300    ___P((___time tim,
 301          ___F64 *seconds),
 302         (tim,
 303          seconds)
 304 ___time tim;
 305 ___F64 *seconds;)
 306 {
 307 #ifdef ___FLOAT_TIME_REPRESENTATION
 308   *seconds = tim;
 309 #endif
 310
 311 #ifdef ___INT_TIME_REPRESENTATION
 312   *seconds = tim.secs + tim.nsecs / 1000000000.0;
 313 #endif
 314 }
 315
 316
 317 void ___time_from_seconds
 318    ___P((___time *tim,
 319          ___F64 seconds),
 320         (tim,
 321          seconds)
 322 ___time *tim;
 323 ___F64 seconds;)
 324 {
 325 #ifdef ___FLOAT_TIME_REPRESENTATION
 326   *tim = seconds;
 327 #endif
 328
 329 #ifdef ___INT_TIME_REPRESENTATION
 330   if (seconds >= 2147483648.0) /* more than 68 years is pos infinity! */
 331     *tim = ___time_mod.time_pos_infinity;
 332   else if (seconds < -2147483648.0) /* less than -68 years is neg infinity! */
 333     *tim = ___time_mod.time_neg_infinity;
 334   else
 335     {
 336       ___SM32 secs = seconds;
 337       ___SM32 nsecs = (seconds - secs) * 1000000000.0;
 338       if (nsecs < 0)
 339         {
 340           secs--;
 341           nsecs += 1000000000;
 342         }
 343       tim->secs = secs;
 344       tim->nsecs = nsecs;
 345     }
 346 #endif
 347 }
 348
 349
 350 void ___absolute_time_to_relative_time
 351    ___P((___time tim,
 352          ___time *rtim),
 353         (tim,
 354          rtim)
 355 ___time tim;
 356 ___time *rtim;)
 357 {
 358   if (___time_less (tim, ___time_mod.time_pos_infinity))
 359     {
 360       ___time now;
 361       *rtim = tim;
 362       ___time_get_current_time (&now);
 363       ___time_subtract (rtim, now);
 364     }
 365   else
 366     *rtim = ___time_mod.time_pos_infinity;
 367 }
 368
 369
 370 #ifndef LINEEDITOR_WITH_NONBLOCKING_IO
 371
 372
 373 void ___absolute_time_sleep
 374    ___P((___time tim),
 375         (tim)
 376 ___time tim;)
 377 {
 378   ___absolute_time_to_relative_time (tim, &tim);
 379
 380   if (___time_positive (tim))
 381     {
 382       ___SM32 nsecs;
 383
 384 #ifdef ___FLOAT_TIME_REPRESENTATION
 385       if (tim > 2.0)
 386         nsecs = 2000000000;
 387       else
 388         nsecs = ___CAST(___SM32,tim * 1000000000.0);
 389 #endif
 390
 391 #ifdef ___INT_TIME_REPRESENTATION
 392       if (tim.secs > 2)
 393         nsecs = 2000000000;
 394       else
 395         nsecs = tim.secs * 1000000000 + tim.nsecs;
 396 #endif
 397
 398 #ifndef USE_nanosleep
 399 #ifndef USE_Sleep
 400 #ifndef USE_sleep
 401 #ifndef USE_CLASSIC_MACOS
 402       /* Can't sleep... so stay awake! */
 403 #endif
 404 #endif
 405 #endif
 406 #endif
 407
 408 #ifdef USE_nanosleep
 409       {
 410         /* The nanosleep function is in POSIX.1b (realtime programming). */
 411         struct timespec ts;
 412         ts.tv_sec = nsecs / 1000000000;
 413         ts.tv_nsec = nsecs;
 414         nanosleep (&ts, NULL);
 415       }
 416 #endif
 417
 418 #ifdef USE_Sleep
 419       Sleep (nsecs / 1000000);
 420 #endif
 421
 422 #ifdef USE_sleep
 423       sleep (nsecs / 1000000000);
 424 #endif
 425
 426 #ifdef USE_CLASSIC_MACOS
 427       {
 428         ___U32 ticks = nsecs / 16666666;
 429         if (has_IdleUpdate)
 430           IdleUpdate ();
 431         if (has_WaitNextEvent)
 432           {
 433             EventRecord er;
 434             WaitNextEvent (0, &er, ticks, NULL);
 435           }
 436         else if (has_Delay)
 437           Delay (ticks, &ticks);
 438       }
 439 #endif
 440     }
 441 }
 442
 443
 444 #endif
 445
 446
 447 #ifdef USE_select
 448
 449
 450 #ifdef ___TIMEVAL_NOT_LIMITED
 451 #define ___TIMEVAL_SEC_LIMIT 2147483647 /* in seconds = 68 years */
 452 #else
 453 /* Mac OS X gives an error when the seconds > 100000000 (3.2 years) */
 454 /* We'll be conservative in case other systems have limits */
 455 #define ___TIMEVAL_SEC_LIMIT 9999999 /* in seconds = 118 days */
 456 #endif
 457
 458
 459 void ___absolute_time_to_nonnegative_timeval
 460    ___P((___time tim,
 461          struct timeval **tv),
 462         (tim,
 463          tv)
 464 ___time tim;
 465 struct timeval **tv;)
 466 {
 467   if (___time_less (tim, ___time_mod.time_pos_infinity))
 468     {
 469       struct timeval *t = *tv;
 470
 471       if (___time_positive (tim))
 472         {
 473 #ifdef ___FLOAT_TIME_REPRESENTATION
 474           if (tim >= (___TIMEVAL_SEC_LIMIT+1.0))
 475             {
 476               t->tv_sec = ___TIMEVAL_SEC_LIMIT;
 477               t->tv_usec = 999999;
 478             }
 479           else
 480             {
 481               t->tv_sec = ___CAST(int,tim);
 482               t->tv_usec = ___CAST(int,(tim - t->tv_sec) * 1000000.0);
 483             }
 484 #endif
 485
 486 #ifdef ___INT_TIME_REPRESENTATION
 487           if (tim.secs > ___TIMEVAL_SEC_LIMIT)
 488             {
 489               t->tv_sec = ___TIMEVAL_SEC_LIMIT;
 490               t->tv_usec = 999999;
 491             }
 492           else
 493             {
 494               t->tv_sec = tim.secs;
 495               t->tv_usec = tim.nsecs / 1000;
 496             }
 497 #endif
 498         }
 499       else
 500         {
 501           t->tv_sec = 0;
 502           t->tv_usec = 0;
 503         }
 504     }
 505   else
 506     *tv = NULL;
 507 }
 508
 509
 510 #endif
 511
 512
 513 #ifdef USE_MsgWaitForMultipleObjects
 514
 515
 516 void ___absolute_time_to_nonnegative_msecs
 517    ___P((___time tim,
 518          DWORD *ms),
 519         (tim,
 520          ms)
 521 ___time tim;
 522 DWORD *ms;)
 523 {
 524   if (___time_less (tim, ___time_mod.time_pos_infinity))
 525     {
 526       if (___time_positive (tim))
 527         {
 528 #ifdef ___FLOAT_TIME_REPRESENTATION
 529
 530           ___F64 msecs = tim * 1000.0;
 531
 532           if (msecs >= 4294967294.0) /* upper bound is 49.6 days! */
 533             *ms = 4294967294UL; /* note that INFINITE = 4294967295 */
 534           else
 535             *ms = ___CAST(DWORD,msecs);
 536
 537 #endif
 538
 539 #ifdef ___INT_TIME_REPRESENTATION
 540
 541           if (tim.secs > 4294968 || /* upper bound is 49.6 days! */
 542               (tim.secs == 4294967 && tim.nsecs >= 294000000))
 543             *ms = 4294967294UL; /* note that INFINITE = 4294967295 */
 544           else
 545             *ms = tim.secs * 1000 + tim.nsecs / 1000000;
 546
 547 #endif
 548         }
 549       else
 550         *ms = 0;
 551     }
 552   else
 553     *ms = INFINITE;
 554 }
 555
 556
 557 #endif
 558
 559
 560 /*---------------------------------------------------------------------------*/
 561
 562 /* Measurement of process times. */
 563
 564
 565 void ___process_times
 566    ___P((___F64 *user,
 567          ___F64 *sys,
 568          ___F64 *real),
 569         (user,
 570          sys,
 571          real)
 572 ___F64 *user;
 573 ___F64 *sys;
 574 ___F64 *real;)
 575 {
 576 #ifndef USE_GetProcessTimes
 577 #ifndef USE_getrusage
 578 #ifndef USE_times
 579 #ifndef USE_clock
 580 #ifndef USE_DosQuerySysInfo
 581 #ifndef USE_CLASSIC_MACOS
 582
 583   *user = 0.0; /* can't get time... result is 0 */
 584   *sys = 0.0;
 585
 586 #endif
 587 #endif
 588 #endif
 589 #endif
 590 #endif
 591 #endif
 592
 593 #ifdef USE_GetProcessTimes
 594
 595   HANDLE p;
 596   FILETIME creation_time, exit_time, sys_time, user_time;
 597
 598   p = GetCurrentProcess ();
 599
 600   if (GetProcessTimes (p, &creation_time, &exit_time, &sys_time, &user_time))
 601     {
 602       *user = FILETIME_TO_SECONDS(user_time);
 603       *sys = FILETIME_TO_SECONDS(sys_time);;
 604     }
 605   else
 606     {
 607       *user = 0.0; /* can't get time... result is 0 */
 608       *sys = 0.0;
 609     }
 610
 611 #endif
 612
 613 #ifdef USE_getrusage
 614
 615   struct rusage ru;
 616
 617   if (getrusage (RUSAGE_SELF, &ru) == 0)
 618     {
 619       *user = ru.ru_utime.tv_sec + ___CAST(___F64,ru.ru_utime.tv_usec) / 1.0e6;
 620       *sys = ru.ru_stime.tv_sec + ___CAST(___F64,ru.ru_stime.tv_usec) / 1.0e6;
 621     }
 622   else
 623     {
 624       *user = 0.0; /* can't get time... result is 0 */
 625       *sys = 0.0;
 626     }
 627
 628 #endif
 629
 630 #ifdef USE_times
 631
 632 #ifdef CLK_TCK
 633 #define CLOCK_TICKS_PER_SEC CLK_TCK
 634 #else
 635 #ifdef USE_sysconf
 636 #ifdef _SC_CLK_TCK
 637 #define CLOCK_TICKS_PER_SEC sysconf (_SC_CLK_TCK)
 638 #else
 639 #ifdef _SC_CLOCKS_PER_SEC
 640 #define CLOCK_TICKS_PER_SEC sysconf (_SC_CLOCKS_PER_SEC)
 641 #endif
 642 #endif
 643 #endif
 644 #endif
 645
 646 #ifndef CLOCK_TICKS_PER_SEC
 647 @error Cannot find a definition for CLOCK_TICKS_PER_SEC
 648 #endif
 649
 650   struct tms t;
 651
 652   static long clock_ticks_per_sec = 0;
 653
 654   if (clock_ticks_per_sec == 0)
 655     clock_ticks_per_sec = CLOCK_TICKS_PER_SEC;
 656
 657   times (&t);
 658
 659   *user = ___CAST(___F64,t.tms_utime) / clock_ticks_per_sec;
 660   *sys = ___CAST(___F64,t.tms_stime) / clock_ticks_per_sec;
 661
 662 #endif
 663
 664 #ifdef USE_clock
 665
 666   *user = ___CAST(___F64,clock ()) / CLOCKS_PER_SEC;
 667   *sys = 0.0; /* fake system time */
 668
 669 #endif
 670
 671 #ifdef USE_DosQuerySysInfo
 672
 673   static ___U32 origin = 0;
 674   ___U32 now;
 675
 676   while (origin == 0)
 677     DosQuerySysInfo (QSV_MS_COUNT, QSV_MS_COUNT, &origin, sizeof (origin));
 678
 679   DosQuerySysInfo (QSV_MS_COUNT, QSV_MS_COUNT, &now, sizeof (now));
 680
 681   *user = ___CAST(___F64,(now-origin)) / 1.0e3; /* are the units right? */
 682   *sys = 0.0; /* fake system time */
 683
 684 #endif
 685
 686 #ifdef USE_CLASSIC_MACOS
 687
 688   static ___U32 origin = 0;
 689   ___U32 now;
 690
 691   while (origin == 0)
 692     origin = TickCount ();
 693
 694   now = TickCount ();
 695
 696   *user = ___CAST(___F64,(now-origin)) / 60;
 697   *sys = 0.0; /* fake system time */
 698
 699 #endif
 700
 701   {
 702     ___time now;
 703     ___F64 seconds;
 704
 705     ___time_get_current_time (&now);
 706     ___time_to_seconds (now, &seconds);
 707
 708     *real = seconds - ___time_mod.process_start_seconds;
 709   }
 710 }
 711
 712
 713 ___HIDDEN void setup_process_times ___PVOID
 714 {
 715   ___F64 user, sys;
 716
 717   ___time_mod.process_start_seconds = 0.0;
 718   ___process_times (&user, &sys, &___time_mod.process_start_seconds);
 719
 720 }
 721
 722
 723 ___HIDDEN void cleanup_process_times ___PVOID
 724 {
 725 }
 726
 727
 728 /*---------------------------------------------------------------------------*/
 729
 730 /* Heartbeat interrupt handling. */
 731
 732
 733 #ifndef USE_setitimer
 734 #ifndef USE_dos_setvect_1Ch
 735 #ifndef USE_DosStartTimer
 736 #ifndef USE_VInstall
 737 #ifndef USE_CreateThread
 738
 739
 740 ___F64 ___set_heartbeat_interval
 741    ___P((___F64 seconds),
 742         (seconds)
 743 ___F64 seconds;)
 744 {
 745   ___time_mod.current_heartbeat_interval = seconds;
 746   return 0.0;
 747 }
 748
 749
 750 void ___disable_heartbeat_interrupts ___PVOID
 751 {
 752 }
 753
 754
 755 void ___enable_heartbeat_interrupts ___PVOID
 756 {
 757 }
 758
 759
 760 ___SCMOBJ ___setup_heartbeat_interrupt_handling ___PVOID
 761 {
 762   return ___FIX(___NO_ERR);
 763 }
 764
 765
 766 void ___cleanup_heartbeat_interrupt_handling ___PVOID
 767 {
 768 }
 769
 770
 771 #endif
 772 #endif
 773 #endif
 774 #endif
 775 #endif
 776
 777
 778 #ifdef USE_setitimer
 779
 780
 781 ___HIDDEN void heartbeat_interrupt_handler
 782    ___P((int sig),
 783         (sig)
 784 int sig;)
 785 {
 786 #ifdef USE_signal
 787   ___set_signal_handler (HEARTBEAT_SIG, heartbeat_interrupt_handler);
 788 #endif
 789
 790   ___time_mod.heartbeat_interrupt_handler ();
 791 }
 792
 793
 794 ___F64 ___set_heartbeat_interval
 795    ___P((___F64 seconds),
 796         (seconds)
 797 ___F64 seconds;)
 798 {
 799   struct itimerval tv;
 800
 801   ___time_mod.current_heartbeat_interval = seconds;
 802
 803   if (seconds < 0.0) /* turn heartbeat off */
 804     {
 805       tv.it_interval.tv_sec  = 0;
 806       tv.it_interval.tv_usec = 0;
 807       tv.it_value.tv_sec     = 0;
 808       tv.it_value.tv_usec    = 0;
 809       setitimer (HEARTBEAT_ITIMER, &tv, 0);
 810       return 0.0;
 811     }
 812   else
 813     {
 814       int secs;
 815       int usecs;
 816
 817       if (seconds >= 2147483648.0) /* upper bound is 68 years! */
 818         {
 819           secs = 2147483647;
 820           usecs = 999999;
 821         }
 822       else
 823         {
 824           secs = ___CAST(int,seconds);
 825           usecs = ___CAST(int,(seconds - secs) * 1000000.0);
 826           if (secs <= 0 && usecs < 1) /* use smallest interval */
 827             {
 828               secs = 0;
 829               usecs = 1;
 830             }
 831         }
 832
 833       tv.it_interval.tv_sec  = secs;
 834       tv.it_interval.tv_usec = usecs;
 835       tv.it_value.tv_sec     = secs;
 836       tv.it_value.tv_usec    = usecs;
 837       setitimer (HEARTBEAT_ITIMER, &tv, 0);
 838       getitimer (HEARTBEAT_ITIMER, &tv);
 839       return tv.it_interval.tv_sec + tv.it_interval.tv_usec / 1000000.0;
 840     }
 841 }
 842
 843
 844 void ___disable_heartbeat_interrupts ___PVOID
 845 {
 846   ___F64 save_heartbeat_interval = ___time_mod.current_heartbeat_interval;
 847   ___set_heartbeat_interval (-1.0);
 848   ___time_mod.current_heartbeat_interval = save_heartbeat_interval;
 849 #ifdef USE_POSIX
 850   ___set_signal_handler (HEARTBEAT_SIG, SIG_IGN);
 851 #endif
 852 }
 853
 854
 855 void ___enable_heartbeat_interrupts ___PVOID
 856 {
 857   ___set_heartbeat_interval (___time_mod.current_heartbeat_interval);
 858 #ifdef USE_POSIX
 859   ___set_signal_handler (HEARTBEAT_SIG, heartbeat_interrupt_handler);
 860 #endif
 861 }
 862
 863
 864 ___SCMOBJ ___setup_heartbeat_interrupt_handling ___PVOID
 865 {
 866   ___enable_heartbeat_interrupts ();
 867   return ___FIX(___NO_ERR);
 868 }
 869
 870
 871 void ___cleanup_heartbeat_interrupt_handling ___PVOID
 872 {
 873   ___disable_heartbeat_interrupts ();
 874 }
 875
 876
 877 #endif
 878
 879
 880 #ifdef USE_dos_setvect_1Ch
 881
 882
 883 /* 1Ch = timer tick vector */
 884
 885
 886 ___HIDDEN void __interrupt __far heartbeat_interrupt_handler ___PVOID
 887 {
 888   if (___time_mod.heartbeat_countdown > 1)
 889     ___time_mod.heartbeat_countdown--;
 890   else if (___time_mod.heartbeat_countdown == 1
 891            && ___time_mod.heartbeat_enabled)
 892     {
 893       ___time_mod.heartbeat_countdown = ___time_mod.heartbeat_interval;
 894       ___time_mod.heartbeat_interrupt_handler ();
 895     }
 896   _chain_intr (prev_vector_1Ch);
 897 }
 898
 899
 900 ___F64 ___set_heartbeat_interval
 901    ___P((___F64 seconds),
 902         (seconds)
 903 ___F64 seconds;)
 904 {
 905   ___time_mod.current_heartbeat_interval = seconds;
 906
 907   if (seconds < 0.0) /* turn heartbeat off */
 908     {
 909       _dos_setvect (0x1C, prev_vector_1Ch);
 910       return 0.0;
 911     }
 912   else
 913     {
 914       ___F64 ticks = seconds * 18.2; /* 18.2 ticks/sec */
 915       int t;
 916
 917       if (ticks >= 2147483648.0) /* upper bound is 3.7 years! */
 918         t = 2147483647;
 919       else
 920         {
 921           t = ticks;
 922           if (t <= 0) /* use smallest interval */
 923             t = 1;
 924         }
 925
 926       ___time_mod.heartbeat_interval = t;
 927       ___time_mod.heartbeat_countdown = ___time_mod.heartbeat_interval;
 928       _dos_setvect (0x1C, ___time_mod.heartbeat_interrupt_handler);
 929       return t / 18.2;
 930     }
 931 }
 932
 933
 934 void ___disable_heartbeat_interrupts ___PVOID
 935 {
 936   ___time_mod.heartbeat_enabled = 0;
 937 }
 938
 939
 940 void ___enable_heartbeat_interrupts ___PVOID
 941 {
 942   ___time_mod.heartbeat_enabled = 1;
 943 }
 944
 945
 946 ___SCMOBJ ___setup_heartbeat_interrupt_handling ___PVOID
 947 {
 948   prev_vector_1Ch = _dos_getvect (0x1C);
 949   ___time_mod.heartbeat_enabled = 1;
 950   ___set_heartbeat_interval (-1.0);
 951   return ___FIX(___NO_ERR);
 952 }
 953
 954
 955 void ___cleanup_heartbeat_interrupt_handling ___PVOID
 956 {
 957   ___set_heartbeat_interval (-1.0);
 958   ___time_mod.heartbeat_enabled = 0;
 959 }
 960
 961
 962 #endif
 963
 964
 965 #ifdef USE_DosStartTimer
 966
 967
 968 ___HIDDEN void APIENTRY heartbeat_thread_code
 969    ___P((ULONG param),
 970         (param)
 971 ULONG param;)
 972 {
 973   ULONG pc = 0;
 974   for (;;)
 975     {
 976       DosWaitEventSem (___time_mod.hev, SEM_INDEFINITE_WAIT);
 977       DosResetEventSem (___time_mod.hev, &pc);
 978       if (___time_mod.heartbeat_enabled)
 979         {
 980           DosEnterCritSec ();
 981           ___time_mod.heartbeat_interrupt_handler ();
 982           DosExitCritSec ();
 983         }
 984     }
 985 }
 986
 987
 988 ___F64 ___set_heartbeat_interval
 989    ___P((___F64 seconds),
 990         (seconds)
 991 ___F64 seconds;)
 992 {
 993   ___time_mod.current_heartbeat_interval = seconds;
 994
 995   if (!___time_mod.heartbeat_hev || !___time_mod.heartbeat_tid)
 996     return 0.0;
 997   if (___time_mod.heartbeat_htimer)
 998     {
 999       DosStopTimer (___time_mod.htimer);
1000       ___time_mod.heartbeat_htimer = 0;
1001     }
1002   if (seconds < 0.0) /* turn heartbeat off */
1003     return 0.0;
1004   else
1005     {
1006       ___F64 msecs = seconds * 1000.0;
1007       ULONG m;
1008
1009       if (msecs >= 4294967295.0) /* upper bound is 49.7 days! */
1010         m = 4294967295;
1011       else
1012         {
1013           m = msecs;
1014           if (m == 0) /* use smallest interval */
1015             m = 1;
1016         }
1017
1018       if (DosStartTimer (m, ___CAST(HSEM,___time_mod.hev), &___time_mod.htimer)
1019           == NO_ERROR)
1020         {
1021           ___time_mod.heartbeat_htimer = 1;
1022           return m / 1000.0;
1023         }
1024       else
1025         return 0.0;
1026     }
1027 }
1028
1029
1030 void ___disable_heartbeat_interrupts ___PVOID
1031 {
1032   ___time_mod.heartbeat_enabled = 0;
1033 }
1034
1035
1036 void ___enable_heartbeat_interrupts ___PVOID
1037 {
1038   ___time_mod.heartbeat_enabled = 1;
1039 }
1040
1041
1042 ___SCMOBJ ___setup_heartbeat_interrupt_handling ___PVOID
1043 {
1044   ___time_mod.heartbeat_enabled = 0;
1045   ___time_mod.heartbeat_hev     = 0;
1046   ___time_mod.heartbeat_tid     = 0;
1047   ___time_mod.heartbeat_htimer  = 0;
1048   if (DosCreateEventSem (0, &___time_mod.hev, DC_SEM_SHARED, FALSE) != NO_ERROR)
1049     return ___FIX(___UNKNOWN_ERR);
1050   ___time_mod.heartbeat_hev = 1;
1051   if (DosCreateThread (&___time_mod.tid,
1052                        heartbeat_thread_code,
1053                        0,
1054                        CREATE_READY|STACK_COMMITTED,
1055                        4096)
1056       != NO_ERROR)
1057     return ___FIX(___UNKNOWN_ERR);
1058   ___time_mod.heartbeat_tid = 1;
1059   DosSetPriority (PRTYS_THREAD, PRTYC_NOCHANGE, PRTYD_MAXIMUM, ___time_mod.tid);
1060   ___time_mod.heartbeat_enabled = 1;
1061
1062   return ___FIX(___NO_ERR);
1063 }
1064
1065
1066 void ___cleanup_heartbeat_interrupt_handling ___PVOID
1067 {
1068   ___time_mod.heartbeat_enabled = 0;
1069   if (___time_mod.heartbeat_htimer)
1070     {
1071       DosStopTimer (___time_mod.htimer);
1072       ___time_mod.heartbeat_htimer = 0;
1073     }
1074   if (___time_mod.heartbeat_tid)
1075     {
1076       DosKillThread (___time_mod.tid);
1077       ___time_mod.heartbeat_tid = 0;
1078     }
1079   if (___time_mod.heartbeat_hev)
1080     {
1081       DosCloseEventSem (___time_mod.hev);
1082       ___time_mod.heartbeat_hev = 0;
1083     }
1084 }
1085
1086
1087 #endif
1088
1089
1090 #ifdef USE_VInstall
1091
1092
1093 ___HIDDEN ___BOOL heartbeat_task_installed;
1094 ___HIDDEN short heartbeat_task_ticks;
1095 ___HIDDEN VBLTask heartbeat_task;
1096 ___HIDDEN ___BOOL heartbeat_enabled;
1097
1098
1099 ___HIDDEN void heartbeat_task_code ___PVOID
1100 {
1101   if (___time_mod.heartbeat_enabled)
1102     ___time_mod.heartbeat_interrupt_handler ();
1103   ___time_mod.heartbeat_task.vblCount = ___time_mod.heartbeat_task_ticks;
1104 }
1105
1106
1107 #ifdef __POWERPC__
1108
1109 #define heartbeat_task_proc heartbeat_task_code
1110
1111 #else
1112
1113 ___HIDDEN asm void heartbeat_task_proc ___PVOID
1114 {
1115     move.l a5,-(sp)
1116     move.l 0x904,a5
1117     jsr    heartbeat_task_code
1118     move.l (sp)+,a5
1119     rts
1120 }
1121
1122 #endif
1123
1124
1125 ___F64 ___set_heartbeat_interval
1126    ___P((___F64 seconds),
1127         (seconds)
1128 ___F64 seconds;)
1129 {
1130   ___time_mod.current_heartbeat_interval = seconds;
1131
1132   if (___time_mod.heartbeat_task_installed)
1133     if (VRemove (___CAST(QElemPtr,&___time_mod.heartbeat_task)) != noErr)
1134       {
1135         ___time_mod.heartbeat_task_installed = 0;
1136         return 0.0;
1137       }
1138
1139   if (seconds < 0.0) /* turn heartbeat off */
1140     return 0.0;
1141   else
1142     {
1143       ___F64 ticks = seconds * 60.0; /* 60 ticks/sec */
1144       short t;
1145
1146       if (ticks >= 32767.0) /* upper bound is 9 minutes! */
1147         t = 32767;
1148       else
1149         {
1150           t = ticks;
1151           if (t <= 0) /* use smallest interval */
1152             t = 1;
1153         }
1154
1155       ___time_mod.heartbeat_task_ticks    = t;
1156       ___time_mod.heartbeat_task.qType    = vType;
1157       ___time_mod.heartbeat_task.vblAddr  = NewVBLProc (heartbeat_task_proc);
1158       ___time_mod.heartbeat_task.vblCount = t;
1159       ___time_mod.heartbeat_task.vblPhase = 0;
1160       if (VInstall (___CAST(QElemPtr,&___time_mod.heartbeat_task)) == noErr)
1161         {
1162           ___time_mod.heartbeat_task_installed = 1;
1163           return t / 60.0;
1164         }
1165       else
1166         return 0.0;
1167     }
1168 }
1169
1170
1171 void ___disable_heartbeat_interrupts ___PVOID
1172 {
1173   ___time_mod.heartbeat_enabled = 0;
1174 }
1175
1176
1177 void ___enable_heartbeat_interrupts ___PVOID
1178 {
1179   ___time_mod.heartbeat_enabled = 1;
1180 }
1181
1182
1183 ___SCMOBJ ___setup_heartbeat_interrupt_handling ___PVOID
1184 {
1185   ___time_mod.heartbeat_enabled = 1;
1186   ___time_mod.heartbeat_task_installed = 0;
1187   return ___FIX(___NO_ERR);
1188 }
1189
1190
1191 void ___cleanup_heartbeat_interrupt_handling ___PVOID
1192 {
1193   ___set_heartbeat_interval (-1.0);
1194   ___time_mod.heartbeat_enabled = 0;
1195 }
1196
1197
1198 #endif
1199
1200
1201 #ifdef USE_CreateThread
1202
1203
1204 /*
1205  * The HEARTBEAT_PRIORITY should be high so that heartbeats will occur
1206  * as close as possible to the correct time.
1207  */
1208
1209 #define HEARTBEAT_PRIORITY THREAD_PRIORITY_HIGHEST
1210
1211
1212 ___HIDDEN DWORD WINAPI heartbeat_thread_proc
1213    ___P((LPVOID param),
1214         (param)
1215 LPVOID param;)
1216 {
1217   DWORD interval = ___time_mod.heartbeat_interval;
1218
1219   for (;;)
1220     {
1221       DWORD n = WaitForSingleObject (___time_mod.heartbeat_update, interval);
1222
1223       interval = ___time_mod.heartbeat_interval;
1224
1225       if (interval == 0)
1226         return 0;
1227
1228       switch (n)
1229         {
1230         case WAIT_ABANDONED:
1231         case WAIT_OBJECT_0:
1232           break;
1233
1234         case WAIT_TIMEOUT:
1235           if (___time_mod.heartbeat_enabled)
1236             ___time_mod.heartbeat_interrupt_handler ();
1237           break;
1238
1239         default: /* WAIT_FAILED */
1240           return 0;
1241         }
1242     }
1243
1244   return 0;
1245 }
1246
1247
1248 ___F64 ___set_heartbeat_interval
1249    ___P((___F64 seconds),
1250         (seconds)
1251 ___F64 seconds;)
1252 {
1253   ___time_mod.current_heartbeat_interval = seconds;
1254
1255   if (seconds < 0.0) /* turn heartbeat off */
1256     {
1257       ___time_mod.heartbeat_interval = INFINITE;
1258       SetEvent (___time_mod.heartbeat_update); /* ignore error */
1259       return 0.0;
1260     }
1261   else
1262     {
1263       ___F64 msecs = seconds * 1000.0;
1264       DWORD m;
1265
1266       if (msecs >= 4294967294.0) /* upper bound is 49.6 days! */
1267         m = 4294967294UL; /* note that INFINITE = 4294967295 */
1268       else
1269         {
1270           m = ___CAST(DWORD,msecs);
1271           if (m == 0) /* use smallest interval */
1272             m = 1;
1273         }
1274
1275       ___time_mod.heartbeat_interval = m;
1276       SetEvent (___time_mod.heartbeat_update); /* ignore error */
1277       return m / 1000.0;
1278     }
1279 }
1280
1281
1282 void ___disable_heartbeat_interrupts ___PVOID
1283 {
1284   ___time_mod.heartbeat_enabled = 0;
1285 }
1286
1287
1288 void ___enable_heartbeat_interrupts ___PVOID
1289 {
1290   ___time_mod.heartbeat_enabled = 1;
1291 }
1292
1293
1294 ___SCMOBJ ___setup_heartbeat_interrupt_handling ___PVOID
1295 {
1296   ___SCMOBJ e;
1297   DWORD thread_id;
1298   HANDLE thread;
1299   HANDLE update;
1300
1301   ___time_mod.heartbeat_enabled = 1;
1302   ___time_mod.heartbeat_interval = INFINITE;
1303
1304   if ((update = CreateEvent (NULL,  /* can't inherit */
1305                              FALSE, /* auto reset */
1306                              FALSE, /* not signaled */
1307                              NULL)) /* no name */
1308       == NULL)
1309     e = err_code_from_GetLastError ();
1310   else
1311     {
1312       ___time_mod.heartbeat_update = update;
1313
1314       if ((thread = CreateThread (NULL,  /* no security attributes        */
1315                                   65536, /* committed stack size          */
1316                                   heartbeat_thread_proc,
1317                                   0,     /* argument to thread function   */
1318                                   0,     /* use default creation flags    */
1319                                   &thread_id))
1320           == NULL)
1321         e = err_code_from_GetLastError ();
1322       else
1323         {
1324           ___time_mod.heartbeat_thread = thread;
1325
1326           if (!SetThreadPriority (thread, HEARTBEAT_PRIORITY))
1327             e = err_code_from_GetLastError ();
1328           else
1329             return ___FIX(___NO_ERR);
1330
1331           ___time_mod.heartbeat_interval = 0;
1332           SetEvent (update); /* ignore error */
1333           WaitForSingleObject (thread, INFINITE); /* ignore error */
1334           CloseHandle (thread); /* ignore error */
1335         }
1336
1337       CloseHandle (update); /* ignore error */
1338     }
1339
1340   return e;
1341 }
1342
1343
1344 void ___cleanup_heartbeat_interrupt_handling ___PVOID
1345 {
1346   if (___time_mod.heartbeat_thread != NULL)
1347     {
1348       ___time_mod.heartbeat_enabled = 0;
1349       ___time_mod.heartbeat_interval = 0;
1350       SetEvent (___time_mod.heartbeat_update); /* ignore error */
1351       WaitForSingleObject (___time_mod.heartbeat_thread, INFINITE); /* ignore error */
1352       CloseHandle (___time_mod.heartbeat_thread); /* ignore error */
1353       CloseHandle (___time_mod.heartbeat_update); /* ignore error */
1354       ___time_mod.heartbeat_update = NULL;
1355       ___time_mod.heartbeat_thread = NULL;
1356     }
1357 }
1358
1359
1360 #endif
1361
1362
1363 /*---------------------------------------------------------------------------*/
1364
1365 /* Time module initialization/finalization. */
1366
1367
1368 ___SCMOBJ ___setup_time_module
1369    ___P((void (*heartbeat_interrupt_handler) ___PVOID),
1370         (heartbeat_interrupt_handler)
1371 void (*heartbeat_interrupt_handler) ___PVOID;)
1372 {
1373   ___SCMOBJ e;
1374   if (!___time_mod.setup)
1375     {
1376       ___time_mod.heartbeat_interrupt_handler = heartbeat_interrupt_handler;
1377       setup_process_times ();
1378       if ((e = ___setup_heartbeat_interrupt_handling ()) != ___FIX(___NO_ERR))
1379         return e;
1380       ___time_mod.setup = 1;
1381       return ___FIX(___NO_ERR);
1382     }
1383
1384   return ___FIX(___UNKNOWN_ERR);
1385 }
1386
1387
1388 void ___cleanup_time_module ___PVOID
1389 {
1390   if (___time_mod.setup)
1391     {
1392       ___cleanup_heartbeat_interrupt_handling ();
1393       cleanup_process_times ();
1394       ___time_mod.setup = 0;
1395     }
1396 }
1397
1398
1399 /*---------------------------------------------------------------------------*/