ext/Time/HiRes/HiRes.pm

   1 package Time::HiRes;
   2
   3 use strict;
   4 use vars qw($VERSION $XS_VERSION @ISA @EXPORT @EXPORT_OK $AUTOLOAD);
   5
   6 require Exporter;
   7 require DynaLoader;
   8
   9 @ISA = qw(Exporter);
  10
  11 @EXPORT = qw( );
  12 @EXPORT_OK = qw (usleep sleep ualarm alarm gettimeofday time tv_interval
  13                  getitimer setitimer nanosleep
  14                  ITIMER_REAL ITIMER_VIRTUAL ITIMER_PROF ITIMER_REALPROF
  15                  d_usleep d_ualarm d_gettimeofday d_getitimer d_setitimer
  16                  d_nanosleep);
  17
  18 $VERSION = '1.70';
  19 $XS_VERSION = $VERSION;
  20 $VERSION = eval $VERSION;
  21
  22 sub AUTOLOAD {
  23     my $constname;
  24     ($constname = $AUTOLOAD) =~ s/.*:://;
  25     die "&Time::HiRes::constant not defined" if $constname eq 'constant';
  26     my ($error, $val) = constant($constname);
  27     if ($error) { die $error; }
  28     {
  29         no strict 'refs';
  30         *$AUTOLOAD = sub { $val };
  31     }
  32     goto &$AUTOLOAD;
  33 }
  34
  35 eval {
  36     require XSLoader;
  37     XSLoader::load('Time::HiRes', $XS_VERSION);
  38     1;
  39 } or do {
  40     require DynaLoader;
  41     local @ISA = qw(DynaLoader);
  42     bootstrap Time::HiRes $XS_VERSION;
  43 };
  44
  45 # Preloaded methods go here.
  46
  47 sub tv_interval {
  48     # probably could have been done in C
  49     my ($a, $b) = @_;
  50     $b = [gettimeofday()] unless defined($b);
  51     (${$b}[0] - ${$a}[0]) + ((${$b}[1] - ${$a}[1]) / 1_000_000);
  52 }
  53
  54 # Autoload methods go after =cut, and are processed by the autosplit program.
  55
  56 1;
  57 __END__
  58
  59 =head1 NAME
  60
  61 Time::HiRes - High resolution alarm, sleep, gettimeofday, interval timers
  62
  63 =head1 SYNOPSIS
  64
  65   use Time::HiRes qw( usleep ualarm gettimeofday tv_interval nanosleep );
  66
  67   usleep ($microseconds);
  68   nanosleep ($nanoseconds);
  69
  70   ualarm ($microseconds);
  71   ualarm ($microseconds, $interval_microseconds);
  72
  73   $t0 = [gettimeofday];
  74   ($seconds, $microseconds) = gettimeofday;
  75
  76   $elapsed = tv_interval ( $t0, [$seconds, $microseconds]);
  77   $elapsed = tv_interval ( $t0, [gettimeofday]);
  78   $elapsed = tv_interval ( $t0 );
  79
  80   use Time::HiRes qw ( time alarm sleep );
  81
  82   $now_fractions = time;
  83   sleep ($floating_seconds);
  84   alarm ($floating_seconds);
  85   alarm ($floating_seconds, $floating_interval);
  86
  87   use Time::HiRes qw( setitimer getitimer
  88                       ITIMER_REAL ITIMER_VIRTUAL ITIMER_PROF ITIMER_REALPROF );
  89
  90   setitimer ($which, $floating_seconds, $floating_interval );
  91   getitimer ($which);
  92
  93 =head1 DESCRIPTION
  94
  95 The C<Time::HiRes> module implements a Perl interface to the
  96 C<usleep>, C<nanosleep>, C<ualarm>, C<gettimeofday>, and
  97 C<setitimer>/C<getitimer> system calls, in other words, high
  98 resolution time and timers. See the L</EXAMPLES> section below and the
  99 test scripts for usage; see your system documentation for the
 100 description of the underlying C<nanosleep> or C<usleep>, C<ualarm>,
 101 C<gettimeofday>, and C<setitimer>/C<getitimer> calls.
 102
 103 If your system lacks C<gettimeofday()> or an emulation of it you don't
 104 get C<gettimeofday()> or the one-argument form of C<tv_interval()>.
 105 If your system lacks all of C<nanosleep()>, C<usleep()>, and
 106 C<select()>, you don't get C<Time::HiRes::usleep()>,
 107 C<Time::HiRes::nanosleep()>, or C<Time::HiRes::sleep()>.  If your
 108 system lacks both C<ualarm()> and C<setitimer()> you don't get
 109 C<Time::HiRes::ualarm()> or C<Time::HiRes::alarm()>.
 110
 111 If you try to import an unimplemented function in the C<use> statement
 112 it will fail at compile time.
 113
 114 If your subsecond sleeping is implemented with C<nanosleep()> instead
 115 of C<usleep()>, you can mix subsecond sleeping with signals since
 116 C<nanosleep()> does not use signals.  This, however, is not portable,
 117 and you should first check for the truth value of
 118 C<&Time::HiRes::d_nanosleep> to see whether you have nanosleep, and
 119 then carefully read your C<nanosleep()> C API documentation for any
 120 peculiarities.
 121
 122 Unless using C<nanosleep> for mixing sleeping with signals, give
 123 some thought to whether Perl is the tool you should be using for
 124 work requiring nanosecond accuracies.
 125
 126 The following functions can be imported from this module.
 127 No functions are exported by default.
 128
 129 =over 4
 130
 131 =item gettimeofday ()
 132
 133 In array context returns a two-element array with the seconds and
 134 microseconds since the epoch.  In scalar context returns floating
 135 seconds like C<Time::HiRes::time()> (see below).
 136
 137 =item usleep ( $useconds )
 138
 139 Sleeps for the number of microseconds (millionths of a second)
 140 specified.  Returns the number of microseconds actually slept.  Can
 141 sleep for more than one second, unlike the C<usleep> system call. See
 142 also C<Time::HiRes::usleep()> and C<Time::HiRes::sleep()>.
 143
 144 Do not expect usleep() to be exact down to one microsecond.
 145
 146 =item nanosleep ( $nanoseconds )
 147
 148 Sleeps for the number of nanoseconds (1e9ths of a second) specified.
 149 Returns the number of nanoseconds actually slept (accurate only to
 150 microseconds, the nearest thousand of them).  Can sleep for more than
 151 one second.  See also C<Time::HiRes::sleep()> and
 152 C<Time::HiRes::usleep()>.
 153
 154 Do not expect nanosleep() to be exact down to one nanosecond.
 155 Getting even accuracy of one thousand nanoseconds is good.
 156
 157 =item ualarm ( $useconds [, $interval_useconds ] )
 158
 159 Issues a C<ualarm> call; the C<$interval_useconds> is optional and
 160 will be zero if unspecified, resulting in C<alarm>-like behaviour.
 161
 162 Note that the interaction between alarms and sleeps is unspecified.
 163
 164 =item tv_interval
 165
 166 tv_interval ( $ref_to_gettimeofday [, $ref_to_later_gettimeofday] )
 167
 168 Returns the floating seconds between the two times, which should have
 169 been returned by C<gettimeofday()>. If the second argument is omitted,
 170 then the current time is used.
 171
 172 =item time ()
 173
 174 Returns a floating seconds since the epoch. This function can be
 175 imported, resulting in a nice drop-in replacement for the C<time>
 176 provided with core Perl; see the L</EXAMPLES> below.
 177
 178 B<NOTE 1>: This higher resolution timer can return values either less
 179 or more than the core C<time()>, depending on whether your platform
 180 rounds the higher resolution timer values up, down, or to the nearest second
 181 to get the core C<time()>, but naturally the difference should be never
 182 more than half a second.
 183
 184 B<NOTE 2>: Since Sunday, September 9th, 2001 at 01:46:40 AM GMT, when
 185 the C<time()> seconds since epoch rolled over to 1_000_000_000, the
 186 default floating point format of Perl and the seconds since epoch have
 187 conspired to produce an apparent bug: if you print the value of
 188 C<Time::HiRes::time()> you seem to be getting only five decimals, not
 189 six as promised (microseconds).  Not to worry, the microseconds are
 190 there (assuming your platform supports such granularity in the first
 191 place).  What is going on is that the default floating point format of
 192 Perl only outputs 15 digits.  In this case that means ten digits
 193 before the decimal separator and five after.  To see the microseconds
 194 you can use either C<printf>/C<sprintf> with C<"%.6f">, or the
 195 C<gettimeofday()> function in list context, which will give you the
 196 seconds and microseconds as two separate values.
 197
 198 =item sleep ( $floating_seconds )
 199
 200 Sleeps for the specified amount of seconds.  Returns the number of
 201 seconds actually slept (a floating point value).  This function can
 202 be imported, resulting in a nice drop-in replacement for the C<sleep>
 203 provided with perl, see the L</EXAMPLES> below.
 204
 205 Note that the interaction between alarms and sleeps is unspecified.
 206
 207 =item alarm ( $floating_seconds [, $interval_floating_seconds ] )
 208
 209 The C<SIGALRM> signal is sent after the specified number of seconds.
 210 Implemented using C<ualarm()>.  The C<$interval_floating_seconds> argument
 211 is optional and will be zero if unspecified, resulting in C<alarm()>-like
 212 behaviour.  This function can be imported, resulting in a nice drop-in
 213 replacement for the C<alarm> provided with perl, see the L</EXAMPLES> below.
 214
 215 B<NOTE 1>: With some combinations of operating systems and Perl
 216 releases C<SIGALRM> restarts C<select()>, instead of interrupting it.
 217 This means that an C<alarm()> followed by a C<select()> may together
 218 take the sum of the times specified for the the C<alarm()> and the
 219 C<select()>, not just the time of the C<alarm()>.
 220
 221 Note that the interaction between alarms and sleeps is unspecified.
 222
 223 =item setitimer ( $which, $floating_seconds [, $interval_floating_seconds ] )
 224
 225 Start up an interval timer: after a certain time, a signal arrives,
 226 and more signals may keep arriving at certain intervals.  To disable
 227 an "itimer", use C<$floating_seconds> of zero.  If the
 228 C<$interval_floating_seconds> is set to zero (or unspecified), the
 229 timer is disabled B<after> the next delivered signal.
 230
 231 Use of interval timers may interfere with C<alarm()>, C<sleep()>,
 232 and C<usleep()>.  In standard-speak the "interaction is unspecified",
 233 which means that I<anything> may happen: it may work, it may not.
 234
 235 In scalar context, the remaining time in the timer is returned.
 236
 237 In list context, both the remaining time and the interval are returned.
 238
 239 There are usually three or four interval timers available: the
 240 C<$which> can be C<ITIMER_REAL>, C<ITIMER_VIRTUAL>, C<ITIMER_PROF>, or
 241 C<ITIMER_REALPROF>.  Note that which ones are available depends: true
 242 UNIX platforms usually have the first three, but (for example) Win32
 243 and Cygwin have only C<ITIMER_REAL>, and only Solaris seems to have
 244 C<ITIMER_REALPROF> (which is used to profile multithreaded programs).
 245
 246 C<ITIMER_REAL> results in C<alarm()>-like behaviour.  Time is counted in
 247 I<real time>; that is, wallclock time.  C<SIGALRM> is delivered when
 248 the timer expires.
 249
 250 C<ITIMER_VIRTUAL> counts time in (process) I<virtual time>; that is,
 251 only when the process is running.  In multiprocessor/user/CPU systems
 252 this may be more or less than real or wallclock time.  (This time is
 253 also known as the I<user time>.)  C<SIGVTALRM> is delivered when the
 254 timer expires.
 255
 256 C<ITIMER_PROF> counts time when either the process virtual time or when
 257 the operating system is running on behalf of the process (such as I/O).
 258 (This time is also known as the I<system time>.)  (The sum of user
 259 time and system time is known as the I<CPU time>.)  C<SIGPROF> is
 260 delivered when the timer expires.  C<SIGPROF> can interrupt system calls.
 261
 262 The semantics of interval timers for multithreaded programs are
 263 system-specific, and some systems may support additional interval
 264 timers.  See your C<setitimer()> documentation.
 265
 266 =item getitimer ( $which )
 267
 268 Return the remaining time in the interval timer specified by C<$which>.
 269
 270 In scalar context, the remaining time is returned.
 271
 272 In list context, both the remaining time and the interval are returned.
 273 The interval is always what you put in using C<setitimer()>.
 274
 275 =back
 276
 277 =head1 EXAMPLES
 278
 279   use Time::HiRes qw(usleep ualarm gettimeofday tv_interval);
 280
 281   $microseconds = 750_000;
 282   usleep $microseconds;
 283
 284   # signal alarm in 2.5s & every .1s thereafter
 285   ualarm 2_500_000, 100_000;
 286
 287   # get seconds and microseconds since the epoch
 288   ($s, $usec) = gettimeofday;
 289
 290   # measure elapsed time
 291   # (could also do by subtracting 2 gettimeofday return values)
 292   $t0 = [gettimeofday];
 293   # do bunch of stuff here
 294   $t1 = [gettimeofday];
 295   # do more stuff here
 296   $t0_t1 = tv_interval $t0, $t1;
 297
 298   $elapsed = tv_interval ($t0, [gettimeofday]);
 299   $elapsed = tv_interval ($t0); # equivalent code
 300
 301   #
 302   # replacements for time, alarm and sleep that know about
 303   # floating seconds
 304   #
 305   use Time::HiRes;
 306   $now_fractions = Time::HiRes::time;
 307   Time::HiRes::sleep (2.5);
 308   Time::HiRes::alarm (10.6666666);
 309
 310   use Time::HiRes qw ( time alarm sleep );
 311   $now_fractions = time;
 312   sleep (2.5);
 313   alarm (10.6666666);
 314
 315   # Arm an interval timer to go off first at 10 seconds and
 316   # after that every 2.5 seconds, in process virtual time
 317
 318   use Time::HiRes qw ( setitimer ITIMER_VIRTUAL time );
 319
 320   $SIG{VTALRM} = sub { print time, "\n" };
 321   setitimer(ITIMER_VIRTUAL, 10, 2.5);
 322
 323 =head1 C API
 324
 325 In addition to the perl API described above, a C API is available for
 326 extension writers.  The following C functions are available in the
 327 modglobal hash:
 328
 329   name             C prototype
 330   ---------------  ----------------------
 331   Time::NVtime     double (*)()
 332   Time::U2time     void (*)(UV ret[2])
 333
 334 Both functions return equivalent information (like C<gettimeofday>)
 335 but with different representations.  The names C<NVtime> and C<U2time>
 336 were selected mainly because they are operating system independent.
 337 (C<gettimeofday> is Unix-centric, though some platforms like VMS have
 338 emulations for it.)
 339
 340 Here is an example of using C<NVtime> from C:
 341
 342   double (*myNVtime)(); /* Returns -1 on failure. */
 343   SV **svp = hv_fetch(PL_modglobal, "Time::NVtime", 12, 0);
 344   if (!svp)         croak("Time::HiRes is required");
 345   if (!SvIOK(*svp)) croak("Time::NVtime isn't a function pointer");
 346   myNVtime = INT2PTR(double(*)(), SvIV(*svp));
 347   printf("The current time is: %f\n", (*myNVtime)());
 348
 349 =head1 DIAGNOSTICS
 350
 351 =head2 negative time not invented yet
 352
 353 You tried to use a negative time argument.
 354
 355 =head2 internal error: useconds < 0 (unsigned ... signed ...)
 356
 357 Something went horribly wrong-- the number of microseconds that cannot
 358 become negative just became negative.  Maybe your compiler is broken?
 359
 360 =head1 CAVEATS
 361
 362 Notice that the core C<time()> maybe rounding rather than truncating.
 363 What this means is that the core C<time()> may be reporting the time
 364 as one second later than C<gettimeofday()> and C<Time::HiRes::time()>.
 365
 366 Adjusting the system clock (either manually or by services like ntp)
 367 may cause problems, especially for long running programs that assume
 368 a monotonously increasing time (note that all platforms do not adjust
 369 time as gracefully as UNIX ntp does).  For example in Win32 (and derived
 370 platforms like Cygwin and MinGW) the Time::HiRes::time() may temporarily
 371 drift off from the system clock (and the original time())  by up to 0.5
 372 seconds. Time::HiRes will notice this eventually and recalibrate.
 373
 374 =head1 SEE ALSO
 375
 376 L<BSD::Resource>, L<Time::TAI64>.
 377
 378 =head1 AUTHORS
 379
 380 D. Wegscheid <wegscd@whirlpool.com>
 381 R. Schertler <roderick@argon.org>
 382 J. Hietaniemi <jhi@iki.fi>
 383 G. Aas <gisle@aas.no>
 384
 385 =head1 COPYRIGHT AND LICENSE
 386
 387 Copyright (c) 1996-2002 Douglas E. Wegscheid.  All rights reserved.
 388
 389 Copyright (c) 2002,2003,2004,2005 Jarkko Hietaniemi.  All rights reserved.
 390
 391 This program is free software; you can redistribute it and/or modify
 392 it under the same terms as Perl itself.
 393
 394 =cut