|
|
 |
|
|
perl-Time-HiRes rpm build for : OpenSuSE. For other distributions click perl-Time-HiRes.
| Name : perl-Time-HiRes
| | | Version : 1.9764
| Vendor : obs://build_opensuse_org/devel:languages:perl
| | Release : lp156.1.1
| Date : 2024-07-03 19:18:33
| | Group : Development/Libraries/Perl
| Source RPM : perl-Time-HiRes-1.9764-lp156.1.1.src.rpm
| | Size : 0.11 MB
| | | Packager : https://www_suse_com/
| | | Summary : High resolution alarm, sleep, gettimeofday, interval timers
| Description :
The \'Time::HiRes\' module implements a Perl interface to the \'usleep\',
\'nanosleep\', \'ualarm\', \'gettimeofday\', and \'setitimer\'/\'getitimer\' system
calls, in other words, high resolution time and timers. See the EXAMPLES
section below and the test scripts for usage; see your system documentation
for the description of the underlying \'nanosleep\' or \'usleep\', \'ualarm\',
\'gettimeofday\', and \'setitimer\'/\'getitimer\' calls.
If your system lacks \'gettimeofday()\' or an emulation of it you don\'t get
\'gettimeofday()\' or the one-argument form of \'tv_interval()\'. If your
system lacks all of \'nanosleep()\', \'usleep()\', \'select()\', and \'poll\', you
don\'t get \'Time::HiRes::usleep()\', \'Time::HiRes::nanosleep()\', or
\'Time::HiRes::sleep()\'. If your system lacks both \'ualarm()\' and
\'setitimer()\' you don\'t get \'Time::HiRes::ualarm()\' or
\'Time::HiRes::alarm()\'.
If you try to import an unimplemented function in the \'use\' statement it
will fail at compile time.
If your subsecond sleeping is implemented with \'nanosleep()\' instead of
\'usleep()\', you can mix subsecond sleeping with signals since \'nanosleep()\'
does not use signals. This, however, is not portable, and you should first
check for the truth value of \'&Time::HiRes::d_nanosleep\' to see whether you
have nanosleep, and then carefully read your \'nanosleep()\' C API
documentation for any peculiarities.
If you are using \'nanosleep\' for something else than mixing sleeping with
signals, give some thought to whether Perl is the tool you should be using
for work requiring nanosecond accuracies.
Remember that unless you are working on a _hard realtime_ system, any
clocks and timers will be imprecise, especially so if you are working in a
pre-emptive multiuser system. Understand the difference between _wallclock
time_ and process time (in UNIX-like systems the sum of _user_ and _system_
times). Any attempt to sleep for X seconds will most probably end up
sleeping *more* than that, but don\'t be surprised if you end up sleeping
slightly *less*.
The following functions can be imported from this module. No functions are
exported by default.
* gettimeofday ()
In array context returns a two-element array with the seconds and
microseconds since the epoch. In scalar context returns floating seconds
like \'Time::HiRes::time()\' (see below).
* usleep ( $useconds )
Sleeps for the number of microseconds (millionths of a second) specified.
Returns the number of microseconds actually slept. Can sleep for more than
one second, unlike the \'usleep\' system call. Can also sleep for zero
seconds, which often works like a _thread yield_. See also
\'Time::HiRes::sleep()\', and \'clock_nanosleep()\'.
Do not expect usleep() to be exact down to one microsecond.
* nanosleep ( $nanoseconds )
Sleeps for the number of nanoseconds (1e9ths of a second) specified.
Returns the number of nanoseconds actually slept (accurate only to
microseconds, the nearest thousand of them). Can sleep for more than one
second. Can also sleep for zero seconds, which often works like a _thread
yield_. See also \'Time::HiRes::sleep()\', \'Time::HiRes::usleep()\', and
\'clock_nanosleep()\'.
Do not expect nanosleep() to be exact down to one nanosecond. Getting even
accuracy of one thousand nanoseconds is good.
* ualarm ( $useconds [, $interval_useconds ] )
Issues a \'ualarm\' call; the \'$interval_useconds\' is optional and will be
zero if unspecified, resulting in \'alarm\'-like behaviour.
Returns the remaining time in the alarm in microseconds, or \'undef\' if an
error occurred.
ualarm(0) will cancel an outstanding ualarm().
Note that the interaction between alarms and sleeps is unspecified.
* tv_interval
tv_interval ( $ref_to_gettimeofday [, $ref_to_later_gettimeofday] )
Returns the floating seconds between the two times, which should have been
returned by \'gettimeofday()\'. If the second argument is omitted, then the
current time is used.
* time ()
Returns a floating seconds since the epoch. This function can be imported,
resulting in a nice drop-in replacement for the \'time\' provided with core
Perl; see the EXAMPLES below.
*NOTE 1*: This higher resolution timer can return values either less or
more than the core \'time()\', depending on whether your platform rounds the
higher resolution timer values up, down, or to the nearest second to get
the core \'time()\', but naturally the difference should be never more than
half a second. See also clock_getres, if available in your system.
*NOTE 2*: Since Sunday, September 9th, 2001 at 01:46:40 AM GMT, when the
\'time()\' seconds since epoch rolled over to 1_000_000_000, the default
floating point format of Perl and the seconds since epoch have conspired to
produce an apparent bug: if you print the value of \'Time::HiRes::time()\'
you seem to be getting only five decimals, not six as promised
(microseconds). Not to worry, the microseconds are there (assuming your
platform supports such granularity in the first place). What is going on is
that the default floating point format of Perl only outputs 15 digits. In
this case that means ten digits before the decimal separator and five
after. To see the microseconds you can use either \'printf\'/\'sprintf\' with
\'\"%.6f\"\', or the \'gettimeofday()\' function in list context, which will give
you the seconds and microseconds as two separate values.
* sleep ( $floating_seconds )
Sleeps for the specified amount of seconds. Returns the number of seconds
actually slept (a floating point value). This function can be imported,
resulting in a nice drop-in replacement for the \'sleep\' provided with perl,
see the EXAMPLES below.
Note that the interaction between alarms and sleeps is unspecified.
* alarm ( $floating_seconds [, $interval_floating_seconds ] )
The \'SIGALRM\' signal is sent after the specified number of seconds.
Implemented using \'setitimer()\' if available, \'ualarm()\' if not. The
\'$interval_floating_seconds\' argument is optional and will be zero if
unspecified, resulting in \'alarm()\'-like behaviour. This function can be
imported, resulting in a nice drop-in replacement for the \'alarm\' provided
with perl, see the EXAMPLES below.
Returns the remaining time in the alarm in seconds, or \'undef\' if an error
occurred.
*NOTE 1*: With some combinations of operating systems and Perl releases
\'SIGALRM\' restarts \'select()\', instead of interrupting it. This means that
an \'alarm()\' followed by a \'select()\' may together take the sum of the
times specified for the \'alarm()\' and the \'select()\', not just the time of
the \'alarm()\'.
Note that the interaction between alarms and sleeps is unspecified.
* setitimer ( $which, $floating_seconds [, $interval_floating_seconds ] )
Start up an interval timer: after a certain time, a signal ($which)
arrives, and more signals may keep arriving at certain intervals. To
disable an \"itimer\", use \'$floating_seconds\' of zero. If the
\'$interval_floating_seconds\' is set to zero (or unspecified), the timer is
disabled *after* the next delivered signal.
Use of interval timers may interfere with \'alarm()\', \'sleep()\', and
\'usleep()\'. In standard-speak the \"interaction is unspecified\", which means
that _anything_ may happen: it may work, it may not.
In scalar context, the remaining time in the timer is returned.
In list context, both the remaining time and the interval are returned.
There are usually three or four interval timers (signals) available: the
\'$which\' can be \'ITIMER_REAL\', \'ITIMER_VIRTUAL\', \'ITIMER_PROF\', or
\'ITIMER_REALPROF\'. Note that which ones are available depends: true UNIX
platforms usually have the first three, but only Solaris seems to have
\'ITIMER_REALPROF\' (which is used to profile multithreaded programs). Win32
unfortunately does not have interval timers.
\'ITIMER_REAL\' results in \'alarm()\'-like behaviour. Time is counted in _real
time_; that is, wallclock time. \'SIGALRM\' is delivered when the timer
expires.
\'ITIMER_VIRTUAL\' counts time in (process) _virtual time_; that is, only
when the process is running. In multiprocessor/user/CPU systems this may be
more or less than real or wallclock time. (This time is also known as the
_user time_.) \'SIGVTALRM\' is delivered when the timer expires.
\'ITIMER_PROF\' counts time when either the process virtual time or when the
operating system is running on behalf of the process (such as I/O). (This
time is also known as the _system time_.) (The sum of user time and system
time is known as the _CPU time_.) \'SIGPROF\' is delivered when the timer
expires. \'SIGPROF\' can interrupt system calls.
The semantics of interval timers for multithreaded programs are
system-specific, and some systems may support additional interval timers.
For example, it is unspecified which thread gets the signals. See your
\'setitimer(2)\' documentation.
* getitimer ( $which )
Return the remaining time in the interval timer specified by \'$which\'.
In scalar context, the remaining time is returned.
In list context, both the remaining time and the interval are returned. The
interval is always what you put in using \'setitimer()\'.
* clock_gettime ( $which )
Return as seconds the current value of the POSIX high resolution timer
specified by \'$which\'. All implementations that support POSIX high
resolution timers are supposed to support at least the \'$which\' value of
\'CLOCK_REALTIME\', which is supposed to return results close to the results
of \'gettimeofday\', or the number of seconds since 00:00:00:00 January 1,
1970 Greenwich Mean Time (GMT). Do not assume that CLOCK_REALTIME is zero,
it might be one, or something else. Another potentially useful (but not
available everywhere) value is \'CLOCK_MONOTONIC\', which guarantees a
monotonically increasing time value (unlike time() or gettimeofday(), which
can be adjusted). See your system documentation for other possibly
supported values.
* clock_getres ( $which )
Return as seconds the resolution of the POSIX high resolution timer
specified by \'$which\'. All implementations that support POSIX high
resolution timers are supposed to support at least the \'$which\' value of
\'CLOCK_REALTIME\', see clock_gettime.
*NOTE*: the resolution returned may be highly optimistic. Even if the
resolution is high (a small number), all it means is that you\'ll be able to
specify the arguments to clock_gettime() and clock_nanosleep() with that
resolution. The system might not actually be able to measure events at that
resolution, and the various overheads and the overall system load are
certain to affect any timings.
* clock_nanosleep ( $which, $nanoseconds, $flags = 0)
Sleeps for the number of nanoseconds (1e9ths of a second) specified.
Returns the number of nanoseconds actually slept. The $which is the \"clock
id\", as with clock_gettime() and clock_getres(). The flags default to zero
but \'TIMER_ABSTIME\' can specified (must be exported explicitly) which means
that \'$nanoseconds\' is not a time interval (as is the default) but instead
an absolute time. Can sleep for more than one second. Can also sleep for
zero seconds, which often works like a _thread yield_. See also
\'Time::HiRes::sleep()\', \'Time::HiRes::usleep()\', and
\'Time::HiRes::nanosleep()\'.
Do not expect clock_nanosleep() to be exact down to one nanosecond. Getting
even accuracy of one thousand nanoseconds is good.
* clock()
Return as seconds the _process time_ (user + system time) spent by the
process since the first call to clock() (the definition is *not* \"since the
start of the process\", though if you are lucky these times may be quite
close to each other, depending on the system). What this means is that you
probably need to store the result of your first call to clock(), and
subtract that value from the following results of clock().
The time returned also includes the process times of the terminated child
processes for which wait() has been executed. This value is somewhat like
the second value returned by the times() of core Perl, but not necessarily
identical. Note that due to backward compatibility limitations the returned
value may wrap around at about 2147 seconds or at about 36 minutes.
* stat
* stat FH
* stat EXPR
* lstat
* lstat FH
* lstat EXPR
As perlfunc/stat or perlfunc/lstat but with the access/modify/change file
timestamps in subsecond resolution, if the operating system and the
filesystem both support such timestamps. To override the standard stat():
use Time::HiRes qw(stat);
Test for the value of &Time::HiRes::d_hires_stat to find out whether the
operating system supports subsecond file timestamps: a value larger than
zero means yes. There are unfortunately no easy ways to find out whether
the filesystem supports such timestamps. UNIX filesystems often do; NTFS
does; FAT doesn\'t (FAT timestamp granularity is *two* seconds).
A zero return value of &Time::HiRes::d_hires_stat means that
Time::HiRes::stat is a no-op passthrough for CORE::stat() (and likewise for
lstat), and therefore the timestamps will stay integers. The same thing
will happen if the filesystem does not do subsecond timestamps, even if the
&Time::HiRes::d_hires_stat is non-zero.
In any case do not expect nanosecond resolution, or even a microsecond
resolution. Also note that the modify/access timestamps might have
different resolutions, and that they need not be synchronized, e.g. if the
operations are
write
stat # t1
read
stat # t2
the access time stamp from t2 need not be greater-than the modify time
stamp from t1: it may be equal or _less_.
* utime LIST
As perlfunc/utime but with the ability to set the access/modify file
timestamps in subsecond resolution, if the operating system and the
filesystem, and the mount options of the filesystem, all support such
timestamps.
To override the standard utime():
use Time::HiRes qw(utime);
Test for the value of &Time::HiRes::d_hires_utime to find out whether the
operating system supports setting subsecond file timestamps.
As with CORE::utime(), passing undef as both the atime and mtime will call
the syscall with a NULL argument.
The actual achievable subsecond resolution depends on the combination of
the operating system and the filesystem.
Modifying the timestamps may not be possible at all: for example, the
\'noatime\' filesystem mount option may prohibit you from changing the access
time timestamp.
Returns the number of files successfully changed.
|
RPM found in directory: /packages/linux-pbone/ftp5.gwdg.de/pub/opensuse/repositories/devel:/languages:/perl:/CPAN-T/15.6/x86_64 |
Content of RPM
Provides
Requires
Provides :
perl(Time::HiRes)
perl-Time-HiRes
perl-Time-HiRes(x86-64)
Requires :
Content of RPM :
/usr/lib/perl5/vendor_perl/5.26.1/x86_64-linux-thread-multi
/usr/lib/perl5/vendor_perl/5.26.1/x86_64-linux-thread-multi/Time
/usr/lib/perl5/vendor_perl/5.26.1/x86_64-linux-thread-multi/Time/HiRes.pm
/usr/lib/perl5/vendor_perl/5.26.1/x86_64-linux-thread-multi/auto/Time
/usr/lib/perl5/vendor_perl/5.26.1/x86_64-linux-thread-multi/auto/Time/HiRes
/usr/lib/perl5/vendor_perl/5.26.1/x86_64-linux-thread-multi/auto/Time/HiRes/HiRes.so
/usr/share/doc/packages/perl-Time-HiRes
/usr/share/doc/packages/perl-Time-HiRes/Changes
/usr/share/doc/packages/perl-Time-HiRes/README
/usr/share/doc/packages/perl-Time-HiRes/TODO
/usr/share/man/man3/Time::HiRes.3pmc.gz
|
|
|
