getrusage(3) C LIBRARY FUNCTIONS 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.
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
Last change: BSD Compatibility Package 1
getrusage(3) C LIBRARY FUNCTIONS getrusage(3)
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.
Last change: BSD Compatibility Package 2
getrusage(3) C LIBRARY FUNCTIONS 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 addi-
tion 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 pro-
cess 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 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 ter-
minated.
Last change: BSD Compatibility Package 3