use BSD::Resource;
#
# the process resource consumption so far
#
($usertime, $systemtime,
$maxrss, $ixrss, $idrss, $isrss, $minflt, $majflt, $nswap,
$inblock, $oublock, $msgsnd, $msgrcv,
$nsignals, $nvcsw, $nivcsw) = getrusage($ru_who);
$rusage = getrusage($ru_who);
#
# the process resource limits
#
($nowsoft, $nowhard) = getrlimit($resource);
$rlimit = getrlimit($resource);
$success = setrlimit($resource, $newsoft, $newhard);
#
# the process scheduling priority
#
$nowpriority = getpriority($pr_which, $pr_who);
$success = setpriority($pr_which, $pr_who, $priority);
# The following is not a BSD function.
# It is a Perlish utility for the users of BSD::Resource.
$rlimits = get_rlimits();
($usertime, $systemtime,
$maxrss, $ixrss, $idrss, $isrss, $minflt, $majflt, $nswap,
$inblock, $oublock, $msgsnd, $msgrcv,
$nsignals, $nvcsw, $nivcsw) = getrusage($ru_who);
$rusage = getrusage($ru_who);
# $ru_who argument is optional; it defaults to RUSAGE_SELF
$rusage = getrusage();
The $ru_who argument is either RUSAGE_SELF (the current process) or
RUSAGE_CHILDREN (all the child processes of the current process) or it maybe left away in
which case RUSAGE_SELF is used.
The RUSAGE_CHILDREN is the total sum of all the so far
terminated (either successfully or unsuccessfully) child processes: there is no way to
find out information about child processes still running.
On some systems (those supporting both getrusage() and the
POSIX threads) there is also RUSAGE_THREAD. The BSD::Resource supports the
RUSAGE_THREAD if it is present but understands nothing more about the POSIX threads
themselves.
In list context getrusage() returns the current resource
usages as a list. On failure it returns an empty list.
The elements of the list are, in order:
index name meaning usually (quite system dependent)
0 utime user time
1 stime system time
2 maxrss maximum shared memory
3 ixrss integral shared memory
4 idrss integral unshared data
5 isrss integral unshared stack
6 minflt page reclaims
7 majflt page faults
8 nswap swaps
9 inblock block input operations
10 oublock block output operations
11 msgsnd messages sent
12 msgrcv messaged received
13 nsignals signals received
14 nvcsw voluntary context switches
15 nivcsw involuntary context switches
In scalar context getrusage() returns the current resource
usages as a an object. The object can be queried via methods named exactly
like the middle column, name, in the above table.
$ru = getrusage();
print $ru->stime, "\n";
$total_context_switches = $ru->nvcsw + $ru->nivcsw;
For a detailed description about the values returned by
getrusage() please consult your usual C programming
documentation about getrusage() and also the header file <sys/resource.h>. (In Solaris, this might be <sys/rusage.h>).
Note 1: officially HP-UX does not support getrusage() at all but for the time being, it
does seem to.
Note 2: Because not all kernels are BSD and also because of the sloppy
support of getrusage() by many vendors many of the values may
not be updated. For example Solaris 1 claims in <sys/rusage.h>
that the ixrss and the isrss fields are always zero.
($nowsoft, $nowhard) = getrlimit($resource);
$rlimit = getrlimit($resource);
The $resource argument can be one of
$resource usual meaning usual unit
RLIMIT_CPU CPU time seconds
RLIMIT_FSIZE file size bytes
RLIMIT_DATA data size bytes
RLIMIT_STACK stack size bytes
RLIMIT_CORE coredump size bytes
RLIMIT_RSS resident set size bytes
RLIMIT_MEMLOCK memory locked data size bytes
RLIMIT_NPROC number of processes -
RLIMIT_NOFILE number of open files -
RLIMIT_OPEN_MAX number of open files -
RLIMIT_AS (virtual) address space bytes
RLIMIT_VMEM virtual memory (space) bytes
What limits are available depends on the operating system. See below for get_rlimits() on how to find out which limits are available. The last two pairs (NO_FILE, OPEN_MAX) and (AS, VMEM) are the same, the former being the BSD names and the latter SVR4 names.
Two meta-resource-symbols might exist
RLIM_NLIMITS
RLIM_INFINITY
RLIM_NLIMITS being the number of possible (but not necessarily fully supported) resource
limits, see also the get_rlimits() call below.
RLIM_INFINITY is useful in setrlimit(), the RLIM_INFINITY is represented as -1.
In list context getrlimit() returns the current soft and hard resource limits as a list. On failure it
returns an empty list.
Processes have soft and hard resource limits. On crossing the soft limit
they receive a signal (for example the XCPU or XFSZ, corresponding to the RLIMIT_CPU and RLIMIT_FSIZE, respectively). The processes can trap and handle some of these signals,
please see
perlipc. After the hard limit the processes will be ruthlessly killed by the KILL signal which cannot be caught.
NOTE: the level of 'support' for a resource varies. Not all the systems
a) even recognise all those limits
b) really track the consumption of a resource
c) care (send those signals) if a resource limit get exceeded
Again, please consult your usual C programming documentation.
One notable exception for the better: officially HP-UX does not support getrlimit() at all but for the time being, it
does seem to.
In scalar context getrlimit() returns the current soft and
hard resource limits as an object. The object can be queried via methods
cur and max, the current and maximum resource limits for the
$resource, respectively.
$nowpriority = getpriority($pr_which, $pr_who);
# the default $pr_who is 0 (the current $pr_which)
$nowpriority = getpriority($pr_which);
# the default $pr_which is PRIO_PROCESS (the process priority)
$nowpriority = getpriority();
getpriority() returns the current priority. NOTE: getpriority() can return zero or negative values completely
legally. On failure getpriority() returns undef (and $! is set as usual).
The priorities returned by getpriority() are in the
(inclusive) range
PRIO_MIN...PRIO_MAX. The $pr_which argument can be any of PRIO_PROCESS (a
process) PRIO_USER (a user), or PRIO_PGRP (a process group). The $pr_who argument tells which
process/user/process group, 0 signifying the current one.
Usual values for PRIO_MIN, PRIO_MAX, are -20, 20. A negative value means better priority (more impolite
process), a positive value means worse priority (more polite process).
NOTE: in AIX if the BSD compatibility library is not installed or not found by the
installation procedure of the BSD::Resource the
PRIO_MIN is 0 (corresponding to -20) and PRIO_MAX is 39 (corresponding to 19, the BSD priority 20 is unreachable).
$success = setrlimit($resource, $newsoft, $newhard);
setrlimit() returns true on success and undef on failure.
NOTE: A normal user process can only lower its resource limits. Soft or hard
limit RLIM_INFINITY means as much as possible, the real hard limits are normally buried inside
the kernel and are very
system-dependent.
$success = setpriority($pr_which, $pr_who, $priority);
# NOTE! If there are two arguments the second one is
# the new $priority (not $pr_who) and the $pr_who is
# defaulted to 0 (the current $pr_which)
$success = setpriority($pr_which, $priority);
# The $pr_who defaults to 0 (the current $pr_which) and
# the $priority defaults to half of the PRIO_MAX, usually
# that amounts to 10 (being a nice $pr_which).
$success = setpriority($pr_which);
# The $pr_which defaults to PRIO_PROCESS,
$success = setpriority();
setpriority() is used to change the scheduling priority. A
positive priority means a more polite process/process group/user; a
negative priority means a more impoite process/process group/user. The
priorities handled by setpriority() are [PRIO_MIN,PRIO_MAX]. A normal user process can only lower its priority (make it more
positive).
NOTE: A successful call returns 1, a failed one .
$rlimits = get_rlimits();
NOTE: This is not a real BSD function. It is a convenience function.
get_rlimits() returns a reference to hash which has the names
of the available resource limits as keys and their indices (those which are
needed as the first argument to getrlimit() and
setrlimit()) as values. For example:
$r = get_rlimits();
print "ok.\n" if ($r->{'RLIM_STACK'} == RLIM_STACK);
# the user and system times so far by the process itself
($usertime, $systemtime) = getrusage();
# ditto in OO way
$ru = getrusage();
$usertime = $ru->utime;
$systemtime = $ru->stime;
# get the current priority level of this process
$currprio = getpriority();
jhi@iki.fi