← Index
Performance Profile   « block view • line view • sub view »
For /wise/base/deliv/dev/bin/getfix
  Run on Thu May 20 15:30:03 2010
Reported on Thu May 20 16:25:29 2010

File/opt/wise/lib/perl5/5.10.0/x86_64-linux-thread-multi/Time/HiRes.pm
Statements Executed30
Total Time0.000818 seconds

Subroutines — ordered by exclusive time
Calls P F Exclusive
Time		 Inclusive
Time		 Subroutine
2220.000200.00039Time::HiRes::import
1116.5e-57.6e-5Time::HiRes::tv_interval
2126.4e-56.4e-5Time::HiRes::bootstrap (xsub)
3233.2e-53.2e-5Time::HiRes::gettimeofday (xsub)
00000Time::HiRes::AUTOLOAD
00000Time::HiRes::BEGIN
00000Time::HiRes::__ANON__[:43]

LineStmts.Exclusive
Time		Avg.Code
1package Time::HiRes;
2
333.2e-51.1e-5use strict;
# spent 9µs making 1 call to strict::import
430.000175.8e-5use vars qw($VERSION $XS_VERSION @ISA @EXPORT @EXPORT_OK $AUTOLOAD);
# spent 85µs making 1 call to vars::import
5
611.0e-61.0e-6require Exporter;
710.000180.00018require DynaLoader;
8
918.0e-68.0e-6@ISA = qw(Exporter DynaLoader);
10
1111.0e-61.0e-6@EXPORT = qw( );
1218.0e-68.0e-6@EXPORT_OK = qw (usleep sleep ualarm alarm gettimeofday time tv_interval
13 getitimer setitimer nanosleep clock_gettime clock_getres
14 clock clock_nanosleep
15 CLOCK_HIGHRES CLOCK_MONOTONIC CLOCK_PROCESS_CPUTIME_ID
16 CLOCK_REALTIME CLOCK_SOFTTIME CLOCK_THREAD_CPUTIME_ID
17 CLOCK_TIMEOFDAY CLOCKS_PER_SEC
18 ITIMER_REAL ITIMER_VIRTUAL ITIMER_PROF ITIMER_REALPROF
19 TIMER_ABSTIME
20 d_usleep d_ualarm d_gettimeofday d_getitimer d_setitimer
21 d_nanosleep d_clock_gettime d_clock_getres
22 d_clock d_clock_nanosleep
23 stat
24 );
25
26100$VERSION = '1.9711';
2711.0e-61.0e-6$XS_VERSION = $VERSION;
2812.3e-52.3e-5$VERSION = eval $VERSION;
29
30sub AUTOLOAD {
31 my $constname;
32 ($constname = $AUTOLOAD) =~ s/.*:://;
33 # print "AUTOLOAD: constname = $constname ($AUTOLOAD)\n";
34 die "&Time::HiRes::constant not defined" if $constname eq 'constant';
35 my ($error, $val) = constant($constname);
36 # print "AUTOLOAD: error = $error, val = $val\n";
37 if ($error) {
38 my (undef,$file,$line) = caller;
39 die "$error at $file line $line.\n";
40 }
41 {
4230.000299.8e-5 no strict 'refs';
# spent 24µs making 1 call to strict::unimport
43 *$AUTOLOAD = sub { $val };
44 }
45 goto &$AUTOLOAD;
46}
47
48
# spent 392µs (204+188) within Time::HiRes::import which was called 2 times, avg 196µs/call: # once (130µs+135µs) at line 20 of /wise/base/deliv/dev/lib/perl/WISE/Spawn.pm # once (74µs+53µs) at line 269 of /wise/base/deliv/dev/bin/getfix
sub import {
4962.4e-54.0e-6 my $this = shift;
50 for my $i (@_) {
5125.0e-62.5e-6 if (($i eq 'clock_getres' && !&d_clock_getres) ||
52 ($i eq 'clock_gettime' && !&d_clock_gettime) ||
53 ($i eq 'clock_nanosleep' && !&d_clock_nanosleep) ||
54 ($i eq 'clock' && !&d_clock) ||
55 ($i eq 'nanosleep' && !&d_nanosleep) ||
56 ($i eq 'usleep' && !&d_usleep) ||
57 ($i eq 'ualarm' && !&d_ualarm)) {
58 require Carp;
59 Carp::croak("Time::HiRes::$i(): unimplemented in this platform");
60 }
61 }
62 Time::HiRes->export_to_level(1, $this, @_);
# spent 66µs making 2 calls to Exporter::export_to_level, avg 33µs/call
63}
64
6511.2e-51.2e-5bootstrap Time::HiRes;
# spent 2.33ms making 1 call to DynaLoader::bootstrap
66
67# Preloaded methods go here.
68
69
# spent 76µs (65+11) within Time::HiRes::tv_interval which was called # once (65µs+11µs) at line 1056 of /wise/base/deliv/dev/bin/getfix
sub tv_interval {
70 # probably could have been done in C
7133.4e-51.1e-5 my ($a, $b) = @_;
72 $b = [gettimeofday()] unless defined($b);
# spent 11µs making 1 call to Time::HiRes::gettimeofday
73 (${$b}[0] - ${$a}[0]) + ((${$b}[1] - ${$a}[1]) / 1_000_000);
74}
75
76# Autoload methods go after =cut, and are processed by the autosplit program.
77
7811.8e-51.8e-51;
79__END__
80
81=head1 NAME
82
83Time::HiRes - High resolution alarm, sleep, gettimeofday, interval timers
84
85=head1 SYNOPSIS
86
87 use Time::HiRes qw( usleep ualarm gettimeofday tv_interval nanosleep
88 clock_gettime clock_getres clock_nanosleep clock
89 stat );
90
91 usleep ($microseconds);
92 nanosleep ($nanoseconds);
93
94 ualarm ($microseconds);
95 ualarm ($microseconds, $interval_microseconds);
96
97 $t0 = [gettimeofday];
98 ($seconds, $microseconds) = gettimeofday;
99
100 $elapsed = tv_interval ( $t0, [$seconds, $microseconds]);
101 $elapsed = tv_interval ( $t0, [gettimeofday]);
102 $elapsed = tv_interval ( $t0 );
103
104 use Time::HiRes qw ( time alarm sleep );
105
106 $now_fractions = time;
107 sleep ($floating_seconds);
108 alarm ($floating_seconds);
109 alarm ($floating_seconds, $floating_interval);
110
111 use Time::HiRes qw( setitimer getitimer );
112
113 setitimer ($which, $floating_seconds, $floating_interval );
114 getitimer ($which);
115
116 use Time::HiRes qw( clock_gettime clock_getres clock_nanosleep
117 ITIMER_REAL ITIMER_VIRTUAL ITIMER_PROF ITIMER_REALPROF );
118
119 $realtime = clock_gettime(CLOCK_REALTIME);
120 $resolution = clock_getres(CLOCK_REALTIME);
121
122 clock_nanosleep(CLOCK_REALTIME, 1.5e9);
123 clock_nanosleep(CLOCK_REALTIME, time()*1e9 + 10e9, TIMER_ABSTIME);
124
125 my $ticktock = clock();
126
127 use Time::HiRes qw( stat );
128
129 my @stat = stat("file");
130 my @stat = stat(FH);
131
132=head1 DESCRIPTION
133
134The C<Time::HiRes> module implements a Perl interface to the
135C<usleep>, C<nanosleep>, C<ualarm>, C<gettimeofday>, and
136C<setitimer>/C<getitimer> system calls, in other words, high
137resolution time and timers. See the L</EXAMPLES> section below and the
138test scripts for usage; see your system documentation for the
139description of the underlying C<nanosleep> or C<usleep>, C<ualarm>,
140C<gettimeofday>, and C<setitimer>/C<getitimer> calls.
141
142If your system lacks C<gettimeofday()> or an emulation of it you don't
143get C<gettimeofday()> or the one-argument form of C<tv_interval()>.
144If your system lacks all of C<nanosleep()>, C<usleep()>,
145C<select()>, and C<poll>, you don't get C<Time::HiRes::usleep()>,
146C<Time::HiRes::nanosleep()>, or C<Time::HiRes::sleep()>.
147If your system lacks both C<ualarm()> and C<setitimer()> you don't get
148C<Time::HiRes::ualarm()> or C<Time::HiRes::alarm()>.
149
150If you try to import an unimplemented function in the C<use> statement
151it will fail at compile time.
152
153If your subsecond sleeping is implemented with C<nanosleep()> instead
154of C<usleep()>, you can mix subsecond sleeping with signals since
155C<nanosleep()> does not use signals. This, however, is not portable,
156and you should first check for the truth value of
157C<&Time::HiRes::d_nanosleep> to see whether you have nanosleep, and
158then carefully read your C<nanosleep()> C API documentation for any
159peculiarities.
160
161If you are using C<nanosleep> for something else than mixing sleeping
162with signals, give some thought to whether Perl is the tool you should
163be using for work requiring nanosecond accuracies.
164
165Remember that unless you are working on a I<hard realtime> system,
166any clocks and timers will be imprecise, especially so if you are working
167in a pre-emptive multiuser system. Understand the difference between
168I<wallclock time> and process time (in UNIX-like systems the sum of
169I<user> and I<system> times). Any attempt to sleep for X seconds will
170most probably end up sleeping B<more> than that, but don't be surpised
171if you end up sleeping slightly B<less>.
172
173The following functions can be imported from this module.
174No functions are exported by default.
175
176=over 4
177
178=item gettimeofday ()
179
180In array context returns a two-element array with the seconds and
181microseconds since the epoch. In scalar context returns floating
182seconds like C<Time::HiRes::time()> (see below).
183
184=item usleep ( $useconds )
185
186Sleeps for the number of microseconds (millionths of a second)
187specified. Returns the number of microseconds actually slept.
188Can sleep for more than one second, unlike the C<usleep> system call.
189Can also sleep for zero seconds, which often works like a I<thread yield>.
190See also C<Time::HiRes::usleep()>, C<Time::HiRes::sleep()>, and
191C<Time::HiRes::clock_nanosleep()>.
192
193Do not expect usleep() to be exact down to one microsecond.
194
195=item nanosleep ( $nanoseconds )
196
197Sleeps for the number of nanoseconds (1e9ths of a second) specified.
198Returns the number of nanoseconds actually slept (accurate only to
199microseconds, the nearest thousand of them). Can sleep for more than
200one second. Can also sleep for zero seconds, which often works like
201a I<thread yield>. See also C<Time::HiRes::sleep()>,
202C<Time::HiRes::usleep()>, and C<Time::HiRes::clock_nanosleep()>.
203
204Do not expect nanosleep() to be exact down to one nanosecond.
205Getting even accuracy of one thousand nanoseconds is good.
206
207=item ualarm ( $useconds [, $interval_useconds ] )
208
209Issues a C<ualarm> call; the C<$interval_useconds> is optional and
210will be zero if unspecified, resulting in C<alarm>-like behaviour.
211
212ualarm(0) will cancel an outstanding ualarm().
213
214Note that the interaction between alarms and sleeps is unspecified.
215
216=item tv_interval
217
218tv_interval ( $ref_to_gettimeofday [, $ref_to_later_gettimeofday] )
219
220Returns the floating seconds between the two times, which should have
221been returned by C<gettimeofday()>. If the second argument is omitted,
222then the current time is used.
223
224=item time ()
225
226Returns a floating seconds since the epoch. This function can be
227imported, resulting in a nice drop-in replacement for the C<time>
228provided with core Perl; see the L</EXAMPLES> below.
229
230B<NOTE 1>: This higher resolution timer can return values either less
231or more than the core C<time()>, depending on whether your platform
232rounds the higher resolution timer values up, down, or to the nearest second
233to get the core C<time()>, but naturally the difference should be never
234more than half a second. See also L</clock_getres>, if available
235in your system.
236
237B<NOTE 2>: Since Sunday, September 9th, 2001 at 01:46:40 AM GMT, when
238the C<time()> seconds since epoch rolled over to 1_000_000_000, the
239default floating point format of Perl and the seconds since epoch have
240conspired to produce an apparent bug: if you print the value of
241C<Time::HiRes::time()> you seem to be getting only five decimals, not
242six as promised (microseconds). Not to worry, the microseconds are
243there (assuming your platform supports such granularity in the first
244place). What is going on is that the default floating point format of
245Perl only outputs 15 digits. In this case that means ten digits
246before the decimal separator and five after. To see the microseconds
247you can use either C<printf>/C<sprintf> with C<"%.6f">, or the
248C<gettimeofday()> function in list context, which will give you the
249seconds and microseconds as two separate values.
250
251=item sleep ( $floating_seconds )
252
253Sleeps for the specified amount of seconds. Returns the number of
254seconds actually slept (a floating point value). This function can
255be imported, resulting in a nice drop-in replacement for the C<sleep>
256provided with perl, see the L</EXAMPLES> below.
257
258Note that the interaction between alarms and sleeps is unspecified.
259
260=item alarm ( $floating_seconds [, $interval_floating_seconds ] )
261
262The C<SIGALRM> signal is sent after the specified number of seconds.
263Implemented using C<ualarm()>. The C<$interval_floating_seconds> argument
264is optional and will be zero if unspecified, resulting in C<alarm()>-like
265behaviour. This function can be imported, resulting in a nice drop-in
266replacement for the C<alarm> provided with perl, see the L</EXAMPLES> below.
267
268B<NOTE 1>: With some combinations of operating systems and Perl
269releases C<SIGALRM> restarts C<select()>, instead of interrupting it.
270This means that an C<alarm()> followed by a C<select()> may together
271take the sum of the times specified for the the C<alarm()> and the
272C<select()>, not just the time of the C<alarm()>.
273
274Note that the interaction between alarms and sleeps is unspecified.
275
276=item setitimer ( $which, $floating_seconds [, $interval_floating_seconds ] )
277
278Start up an interval timer: after a certain time, a signal ($which) arrives,
279and more signals may keep arriving at certain intervals. To disable
280an "itimer", use C<$floating_seconds> of zero. If the
281C<$interval_floating_seconds> is set to zero (or unspecified), the
282timer is disabled B<after> the next delivered signal.
283
284Use of interval timers may interfere with C<alarm()>, C<sleep()>,
285and C<usleep()>. In standard-speak the "interaction is unspecified",
286which means that I<anything> may happen: it may work, it may not.
287
288In scalar context, the remaining time in the timer is returned.
289
290In list context, both the remaining time and the interval are returned.
291
292There are usually three or four interval timers (signals) available: the
293C<$which> can be C<ITIMER_REAL>, C<ITIMER_VIRTUAL>, C<ITIMER_PROF>, or
294C<ITIMER_REALPROF>. Note that which ones are available depends: true
295UNIX platforms usually have the first three, but (for example) Win32
296and Cygwin have only C<ITIMER_REAL>, and only Solaris seems to have
297C<ITIMER_REALPROF> (which is used to profile multithreaded programs).
298
299C<ITIMER_REAL> results in C<alarm()>-like behaviour. Time is counted in
300I<real time>; that is, wallclock time. C<SIGALRM> is delivered when
301the timer expires.
302
303C<ITIMER_VIRTUAL> counts time in (process) I<virtual time>; that is,
304only when the process is running. In multiprocessor/user/CPU systems
305this may be more or less than real or wallclock time. (This time is
306also known as the I<user time>.) C<SIGVTALRM> is delivered when the
307timer expires.
308
309C<ITIMER_PROF> counts time when either the process virtual time or when
310the operating system is running on behalf of the process (such as I/O).
311(This time is also known as the I<system time>.) (The sum of user
312time and system time is known as the I<CPU time>.) C<SIGPROF> is
313delivered when the timer expires. C<SIGPROF> can interrupt system calls.
314
315The semantics of interval timers for multithreaded programs are
316system-specific, and some systems may support additional interval
317timers. For example, it is unspecified which thread gets the signals.
318See your C<setitimer()> documentation.
319
320=item getitimer ( $which )
321
322Return the remaining time in the interval timer specified by C<$which>.
323
324In scalar context, the remaining time is returned.
325
326In list context, both the remaining time and the interval are returned.
327The interval is always what you put in using C<setitimer()>.
328
329=item clock_gettime ( $which )
330
331Return as seconds the current value of the POSIX high resolution timer
332specified by C<$which>. All implementations that support POSIX high
333resolution timers are supposed to support at least the C<$which> value
334of C<CLOCK_REALTIME>, which is supposed to return results close to the
335results of C<gettimeofday>, or the number of seconds since 00:00:00:00
336January 1, 1970 Greenwich Mean Time (GMT). Do not assume that
337CLOCK_REALTIME is zero, it might be one, or something else.
338Another potentially useful (but not available everywhere) value is
339C<CLOCK_MONOTONIC>, which guarantees a monotonically increasing time
340value (unlike time(), which can be adjusted). See your system
341documentation for other possibly supported values.
342
343=item clock_getres ( $which )
344
345Return as seconds the resolution of the POSIX high resolution timer
346specified by C<$which>. All implementations that support POSIX high
347resolution timers are supposed to support at least the C<$which> value
348of C<CLOCK_REALTIME>, see L</clock_gettime>.
349
350=item clock_nanosleep ( $which, $nanoseconds, $flags = 0)
351
352Sleeps for the number of nanoseconds (1e9ths of a second) specified.
353Returns the number of nanoseconds actually slept. The $which is the
354"clock id", as with clock_gettime() and clock_getres(). The flags
355default to zero but C<TIMER_ABSTIME> can specified (must be exported
356explicitly) which means that C<$nanoseconds> is not a time interval
357(as is the default) but instead an absolute time. Can sleep for more
358than one second. Can also sleep for zero seconds, which often works
359like a I<thread yield>. See also C<Time::HiRes::sleep()>,
360C<Time::HiRes::usleep()>, and C<Time::HiRes::nanosleep()>.
361
362Do not expect clock_nanosleep() to be exact down to one nanosecond.
363Getting even accuracy of one thousand nanoseconds is good.
364
365=item clock()
366
367Return as seconds the I<process time> (user + system time) spent by
368the process since the first call to clock() (the definition is B<not>
369"since the start of the process", though if you are lucky these times
370may be quite close to each other, depending on the system). What this
371means is that you probably need to store the result of your first call
372to clock(), and subtract that value from the following results of clock().
373
374The time returned also includes the process times of the terminated
375child processes for which wait() has been executed. This value is
376somewhat like the second value returned by the times() of core Perl,
377but not necessarily identical. Note that due to backward
378compatibility limitations the returned value may wrap around at about
3792147 seconds or at about 36 minutes.
380
381=item stat
382
383=item stat FH
384
385=item stat EXPR
386
387As L<perlfunc/stat> but with the access/modify/change file timestamps
388in subsecond resolution, if the operating system and the filesystem
389both support such timestamps. To override the standard stat():
390
391 use Time::HiRes qw(stat);
392
393Test for the value of &Time::HiRes::d_hires_stat to find out whether
394the operating system supports subsecond file timestamps: a value
395larger than zero means yes. There are unfortunately no easy
396ways to find out whether the filesystem supports such timestamps.
397UNIX filesystems often do; NTFS does; FAT doesn't (FAT timestamp
398granularity is B<two> seconds).
399
400A zero return value of &Time::HiRes::d_hires_stat means that
401Time::HiRes::stat is a no-op passthrough for CORE::stat(),
402and therefore the timestamps will stay integers. The same
403thing will happen if the filesystem does not do subsecond timestamps,
404even if the &Time::HiRes::d_hires_stat is non-zero.
405
406In any case do not expect nanosecond resolution, or even a microsecond
407resolution. Also note that the modify/access timestamps might have
408different resolutions, and that they need not be synchronized, e.g.
409if the operations are
410
411 write
412 stat # t1
413 read
414 stat # t2
415
416the access time stamp from t2 need not be greater-than the modify
417time stamp from t1: it may be equal or I<less>.
418
419=back
420
421=head1 EXAMPLES
422
423 use Time::HiRes qw(usleep ualarm gettimeofday tv_interval);
424
425 $microseconds = 750_000;
426 usleep($microseconds);
427
428 # signal alarm in 2.5s & every .1s thereafter
429 ualarm(2_500_000, 100_000);
430 # cancel that ualarm
431 ualarm(0);
432
433 # get seconds and microseconds since the epoch
434 ($s, $usec) = gettimeofday();
435
436 # measure elapsed time
437 # (could also do by subtracting 2 gettimeofday return values)
438 $t0 = [gettimeofday];
439 # do bunch of stuff here
440 $t1 = [gettimeofday];
441 # do more stuff here
442 $t0_t1 = tv_interval $t0, $t1;
443
444 $elapsed = tv_interval ($t0, [gettimeofday]);
445 $elapsed = tv_interval ($t0); # equivalent code
446
447 #
448 # replacements for time, alarm and sleep that know about
449 # floating seconds
450 #
451 use Time::HiRes;
452 $now_fractions = Time::HiRes::time;
453 Time::HiRes::sleep (2.5);
454 Time::HiRes::alarm (10.6666666);
455
456 use Time::HiRes qw ( time alarm sleep );
457 $now_fractions = time;
458 sleep (2.5);
459 alarm (10.6666666);
460
461 # Arm an interval timer to go off first at 10 seconds and
462 # after that every 2.5 seconds, in process virtual time
463
464 use Time::HiRes qw ( setitimer ITIMER_VIRTUAL time );
465
466 $SIG{VTALRM} = sub { print time, "\n" };
467 setitimer(ITIMER_VIRTUAL, 10, 2.5);
468
469 use Time::HiRes qw( clock_gettime clock_getres CLOCK_REALTIME );
470 # Read the POSIX high resolution timer.
471 my $high = clock_getres(CLOCK_REALTIME);
472 # But how accurate we can be, really?
473 my $reso = clock_getres(CLOCK_REALTIME);
474
475 use Time::HiRes qw( clock_nanosleep TIMER_ABSTIME );
476 clock_nanosleep(CLOCK_REALTIME, 1e6);
477 clock_nanosleep(CLOCK_REALTIME, 2e9, TIMER_ABSTIME);
478
479 use Time::HiRes qw( clock );
480 my $clock0 = clock();
481 ... # Do something.
482 my $clock1 = clock();
483 my $clockd = $clock1 - $clock0;
484
485 use Time::HiRes qw( stat );
486 my ($atime, $mtime, $ctime) = (stat("istics"))[8, 9, 10];
487
488=head1 C API
489
490In addition to the perl API described above, a C API is available for
491extension writers. The following C functions are available in the
492modglobal hash:
493
494 name C prototype
495 --------------- ----------------------
496 Time::NVtime double (*)()
497 Time::U2time void (*)(pTHX_ UV ret[2])
498
499Both functions return equivalent information (like C<gettimeofday>)
500but with different representations. The names C<NVtime> and C<U2time>
501were selected mainly because they are operating system independent.
502(C<gettimeofday> is Unix-centric, though some platforms like Win32 and
503VMS have emulations for it.)
504
505Here is an example of using C<NVtime> from C:
506
507 double (*myNVtime)(); /* Returns -1 on failure. */
508 SV **svp = hv_fetch(PL_modglobal, "Time::NVtime", 12, 0);
509 if (!svp) croak("Time::HiRes is required");
510 if (!SvIOK(*svp)) croak("Time::NVtime isn't a function pointer");
511 myNVtime = INT2PTR(double(*)(), SvIV(*svp));
512 printf("The current time is: %f\n", (*myNVtime)());
513
514=head1 DIAGNOSTICS
515
516=head2 useconds or interval more than ...
517
518In ualarm() you tried to use number of microseconds or interval (also
519in microseconds) more than 1_000_000 and setitimer() is not available
520in your system to emulate that case.
521
522=head2 negative time not invented yet
523
524You tried to use a negative time argument.
525
526=head2 internal error: useconds < 0 (unsigned ... signed ...)
527
528Something went horribly wrong-- the number of microseconds that cannot
529become negative just became negative. Maybe your compiler is broken?
530
531=head1 CAVEATS
532
533Notice that the core C<time()> maybe rounding rather than truncating.
534What this means is that the core C<time()> may be reporting the time
535as one second later than C<gettimeofday()> and C<Time::HiRes::time()>.
536
537Adjusting the system clock (either manually or by services like ntp)
538may cause problems, especially for long running programs that assume
539a monotonously increasing time (note that all platforms do not adjust
540time as gracefully as UNIX ntp does). For example in Win32 (and derived
541platforms like Cygwin and MinGW) the Time::HiRes::time() may temporarily
542drift off from the system clock (and the original time()) by up to 0.5
543seconds. Time::HiRes will notice this eventually and recalibrate.
544Note that since Time::HiRes 1.77 the clock_gettime(CLOCK_MONOTONIC)
545might help in this (in case your system supports CLOCK_MONOTONIC).
546
547=head1 SEE ALSO
548
549Perl modules L<BSD::Resource>, L<Time::TAI64>.
550
551Your system documentation for C<clock>, C<clock_gettime>,
552C<clock_getres>, C<clock_nanosleep>, C<clock_settime>, C<getitimer>,
553C<gettimeofday>, C<setitimer>, C<sleep>, C<stat>, C<ualarm>.
554
555=head1 AUTHORS
556
557D. Wegscheid <wegscd@whirlpool.com>
558R. Schertler <roderick@argon.org>
559J. Hietaniemi <jhi@iki.fi>
560G. Aas <gisle@aas.no>
561
562=head1 COPYRIGHT AND LICENSE
563
564Copyright (c) 1996-2002 Douglas E. Wegscheid. All rights reserved.
565
566Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007 Jarkko Hietaniemi. All rights reserved.
567
568This program is free software; you can redistribute it and/or modify
569it under the same terms as Perl itself.
570
571=cut
# spent 64µs within Time::HiRes::bootstrap which was called # once (64µs+0) by DynaLoader::bootstrap at line 226 of /opt/wise/lib/perl5/5.10.0/x86_64-linux-thread-multi/DynaLoader.pm
sub Time::HiRes::bootstrap; # xsub
# spent 32µs within Time::HiRes::gettimeofday which was called 2 times, avg 16µs/call: # once (21µs+0) at line 516 of /wise/base/deliv/dev/bin/getfix # once (11µs+0) by Time::HiRes::tv_interval at line 72 of /opt/wise/lib/perl5/5.10.0/x86_64-linux-thread-multi/Time/HiRes.pm
sub Time::HiRes::gettimeofday; # xsub

Report produced by the NYTProf 2.07 Perl profiler, developed by Tim Bunce and Adam Kaplan.