getrusage(3) (BSD Compatibility Package) getrusage(3)
NAME
getrusage - get information about resource utilization
SYNOPSIS
cc [ flag... ] file ... -lucb
#include <sys/time.h>
#include <sys/resource.h>
getrusage(who, rusage)
int who;
struct rusage *rusage;
DESCRIPTION
getrusage returns information about the resources utilized by the
current process, or all its terminated child processes. The
interpretation for some values reported, such as ruidrss, are
dependent on the clock tick interval. This interval is an
implementation dependent value.
The who parameter is one of RUSAGESELF or RUSAGECHILDREN. The
buffer to which rusage points will be filled in with the following
structure:
struct rusage {
struct timeval ruutime;/* user time used */
struct timeval rustime;/* system time used */
int rumaxrss; /* maximum resident set size */
int ruixrss; /* currently 0 */
int ruidrss; /* integral resident set size */
int ruisrss; /* currently 0 */
int ruminflt; /* page faults not requiring physical I/O */
int rumajflt; /* page faults requiring physical I/O */
int runswap; /* swaps */
int ruinblock; /* block input operations */
int ruoublock; /* block output operations */
int rumsgsnd; /* messages sent */
int rumsgrcv; /* messages received */
int runsignals; /* signals received */
int runvcsw; /* voluntary context switches */
int runivcsw; /* involuntary context switches */
};
The fields are interpreted as follows:
ruutime The total amount of time spent executing in user mode.
Time is given in seconds and microseconds.
8/91 Page 1
getrusage(3) (BSD Compatibility Package) getrusage(3)
rustime The total amount of time spent executing in system
mode. Time is given in seconds and microseconds.
rumaxrss The maximum resident set size. Size is given in pages
(the size of a page, in bytes, is given by the
getpagesize(3) system call). Also, see NOTES.
ruixrss Currently returns 0.
ruidrss An integral value indicating the amount of memory in
use by a process while the process is running. This
value is the sum of the resident set sizes of the
process running when a clock tick occurs. The value
is given in pages times clock ticks. Note: it does
not take sharing into account. Also, see NOTES.
ruisrss Currently returns 0.
ruminflt The number of page faults serviced which did not
require any physical I/O activity. Also, see NOTES.
rumajflt The number of page faults serviced which required
physical I/O activity. This could include page ahead
operations by the kernel. Also, see NOTES.
runswap The number of times a process was swapped out of main
memory.
ruinblock The number of times the file system had to perform
input in servicing a read(2) request.
ruoublock The number of times the file system had to perform
output in servicing a write(2) request.
rumsgsnd The number of messages sent over sockets.
rumsgrcv The number of messages received from sockets.
runsignals The number of signals delivered.
runvcsw The number of times a context switch resulted due to a
process voluntarily giving up the processor before its
time slice was completed (usually to await
availability of a resource).
runivcsw The number of times a context switch resulted due to a
higher priority process becoming runnable or because
the current process exceeded its time slice.
Page 2 8/91
getrusage(3) (BSD Compatibility Package) getrusage(3)
RETURN VALUE
If successful, the value of the appropriate structure is filled in,
and 0 is returned. If the call fails, a -1 is returned.
ERRORS
getrusage will fail if:
EINVAL The who parameter is not a valid value.
EFAULT The address specified by the rusage argument is not in a
valid portion of the process's address space.
SEE ALSO
sar(1M) in the System Administrator's Reference Manual.
gettimeofday(3), read(2), times(2), wait(3), write(2) in the
Programmer's Reference Manual.
NOTES
Only the timeval fields of struct rusage are supported in this
implementation.
The numbers ruinblock and ruoublock account only for real I/O, and
are approximate measures at best. Data supplied by the caching
mechanism is charged only to the first process to read and the last
process to write the data.
The way resident set size is calculated is an approximation, and
could misrepresent the true resident set size.
Page faults can be generated from a variety of sources and for a
variety of reasons. The customary cause for a page fault is a direct
reference by the program to a page which is not in memory. Now,
however, the kernel can generate page faults on behalf of the user,
for example, servicing read(2) and write(2) system calls. Also, a
page fault can be caused by an absent hardware translation to a page,
even though the page is in physical memory.
In addition to hardware detected page faults, the kernel may cause
pseudo page faults in order to perform some housekeeping. For
example, the kernel may generate page faults, even if the pages exist
in physical memory, in order to lock down pages involved in a raw I/O
request.
By definition, major page faults require physical I/O, while minor
page faults do not require physical I/O. For example, reclaiming the
page from the free list would avoid I/O and generate a minor page
fault. More commonly, minor page faults occur during process startup
as references to pages which are already in memory. For example, if
an address space faults on some hot executable or shared library,
this results in a minor page fault for the address space. Also, any
one doing a read(2) or write(2) to something that is in the page
8/91 Page 3
getrusage(3) (BSD Compatibility Package) getrusage(3)
cache will get a minor page fault(s) as well.
There is no way to obtain information about a child process which has
not yet terminated.
Page 4 8/91