mirror of https://github.com/mkerrisk/man-pages
319 lines
9.7 KiB
Groff
319 lines
9.7 KiB
Groff
'\" t
|
|
.\" Copyright (c) 2012 by Michael Kerrisk <mtk.manpages@gmail.com>
|
|
.\"
|
|
.\" %%%LICENSE_START(VERBATIM)
|
|
.\" Permission is granted to make and distribute verbatim copies of this
|
|
.\" manual provided the copyright notice and this permission notice are
|
|
.\" preserved on all copies.
|
|
.\"
|
|
.\" Permission is granted to copy and distribute modified versions of this
|
|
.\" manual under the conditions for verbatim copying, provided that the
|
|
.\" entire resulting derived work is distributed under the terms of a
|
|
.\" permission notice identical to this one.
|
|
.\"
|
|
.\" Since the Linux kernel and libraries are constantly changing, this
|
|
.\" manual page may be incorrect or out-of-date. The author(s) assume no
|
|
.\" responsibility for errors or omissions, or for damages resulting from
|
|
.\" the use of the information contained herein. The author(s) may not
|
|
.\" have taken the same level of care in the production of this manual,
|
|
.\" which is licensed free of charge, as they might when working
|
|
.\" professionally.
|
|
.\"
|
|
.\" Formatted or processed versions of this manual, if unaccompanied by
|
|
.\" the source, must acknowledge the copyright and authors of this work.
|
|
.\" %%%LICENSE_END
|
|
.\"
|
|
.TH MALLINFO 3 2019-03-06 "Linux" "Linux Programmer's Manual"
|
|
.SH NAME
|
|
mallinfo \- obtain memory allocation information
|
|
.SH SYNOPSIS
|
|
.B #include <malloc.h>
|
|
.PP
|
|
.B struct mallinfo mallinfo(void);
|
|
.SH DESCRIPTION
|
|
The
|
|
.BR mallinfo ()
|
|
function returns a copy of a structure containing information about
|
|
memory allocations performed by
|
|
.BR malloc (3)
|
|
and related functions.
|
|
.PP
|
|
Note that not all allocations are visible to
|
|
.BR mallinfo ();
|
|
see BUGS and consider using
|
|
.BR malloc_info (3)
|
|
instead.
|
|
.PP
|
|
The returned structure is defined as follows:
|
|
.PP
|
|
.in +4n
|
|
.EX
|
|
struct mallinfo {
|
|
int arena; /* Non-mmapped space allocated (bytes) */
|
|
int ordblks; /* Number of free chunks */
|
|
int smblks; /* Number of free fastbin blocks */
|
|
int hblks; /* Number of mmapped regions */
|
|
int hblkhd; /* Space allocated in mmapped regions (bytes) */
|
|
int usmblks; /* Maximum total allocated space (bytes) */
|
|
int fsmblks; /* Space in freed fastbin blocks (bytes) */
|
|
int uordblks; /* Total allocated space (bytes) */
|
|
int fordblks; /* Total free space (bytes) */
|
|
int keepcost; /* Top-most, releasable space (bytes) */
|
|
};
|
|
.EE
|
|
.in
|
|
.PP
|
|
The fields of the
|
|
.I mallinfo
|
|
structure contain the following information:
|
|
.TP 10
|
|
.I arena
|
|
The total amount of memory allocated by means other than
|
|
.BR mmap (2)
|
|
(i.e., memory allocated on the heap).
|
|
This figure includes both in-use blocks and blocks on the free list.
|
|
.TP
|
|
.I ordblks
|
|
The number of ordinary (i.e., non-fastbin) free blocks.
|
|
.TP
|
|
.I smblks
|
|
The number of fastbin free blocks (see
|
|
.BR mallopt (3)).
|
|
.TP
|
|
.I hblks
|
|
The number of blocks currently allocated using
|
|
.BR mmap (2).
|
|
(See the discussion of
|
|
.B M_MMAP_THRESHOLD
|
|
in
|
|
.BR mallopt (3).)
|
|
.TP
|
|
.I hblkhd
|
|
The number of bytes in blocks currently allocated using
|
|
.BR mmap (2).
|
|
.TP
|
|
.I usmblks
|
|
The "highwater mark" for allocated space\(emthat is,
|
|
the maximum amount of space that was ever allocated.
|
|
This field is maintained only in nonthreading environments.
|
|
.TP
|
|
.I fsmblks
|
|
The total number of bytes in fastbin free blocks.
|
|
.TP
|
|
.I uordblks
|
|
The total number of bytes used by in-use allocations.
|
|
.TP
|
|
.I fordblks
|
|
The total number of bytes in free blocks.
|
|
.TP
|
|
.I keepcost
|
|
The total amount of releasable free space at the top
|
|
of the heap.
|
|
This is the maximum number of bytes that could ideally
|
|
(i.e., ignoring page alignment restrictions, and so on) be released by
|
|
.BR malloc_trim (3).
|
|
.\" .SH VERSIONS
|
|
.\" Available already in glibc 2.0, possibly earlier
|
|
.SH ATTRIBUTES
|
|
For an explanation of the terms used in this section, see
|
|
.BR attributes (7).
|
|
.TS
|
|
allbox;
|
|
lb lb lbw28
|
|
l l l.
|
|
Interface Attribute Value
|
|
T{
|
|
.BR mallinfo ()
|
|
T} Thread safety MT-Unsafe init const:mallopt
|
|
.TE
|
|
.sp 1
|
|
.BR mallinfo ()
|
|
would access some global internal objects.
|
|
If modify them with non-atomically,
|
|
may get inconsistent results.
|
|
The identifier
|
|
.I mallopt
|
|
in
|
|
.I const:mallopt
|
|
mean that
|
|
.BR mallopt ()
|
|
would modify the global internal objects with atomics, that make sure
|
|
.BR mallinfo ()
|
|
is safe enough, others modify with non-atomically maybe not.
|
|
.SH CONFORMING TO
|
|
This function is not specified by POSIX or the C standards.
|
|
A similar function exists on many System V derivatives,
|
|
and was specified in the SVID.
|
|
.SH BUGS
|
|
.\" FIXME . http://sourceware.org/bugzilla/show_bug.cgi?id=208
|
|
.\" See the 24 Aug 2011 mail by Paul Pluzhnikov:
|
|
.\" "[patch] Fix mallinfo() to accumulate results for all arenas"
|
|
.\" on libc-alpha@sourceware.org
|
|
.B Information is returned for only the main memory allocation area.
|
|
Allocations in other arenas are excluded.
|
|
See
|
|
.BR malloc_stats (3)
|
|
and
|
|
.BR malloc_info (3)
|
|
for alternatives that include information about other arenas.
|
|
.PP
|
|
The fields of the
|
|
.I mallinfo
|
|
structure are typed as
|
|
.IR int .
|
|
However, because some internal bookkeeping values may be of type
|
|
.IR long ,
|
|
the reported values may wrap around zero and thus be inaccurate.
|
|
.SH EXAMPLE
|
|
The program below employs
|
|
.BR mallinfo ()
|
|
to retrieve memory allocation statistics before and after
|
|
allocating and freeing some blocks of memory.
|
|
The statistics are displayed on standard output.
|
|
.PP
|
|
The first two command-line arguments specify the number and size of
|
|
blocks to be allocated with
|
|
.BR malloc (3).
|
|
.PP
|
|
The remaining three arguments specify which of the allocated blocks
|
|
should be freed with
|
|
.BR free (3).
|
|
These three arguments are optional, and specify (in order):
|
|
the step size to be used in the loop that frees blocks
|
|
(the default is 1, meaning free all blocks in the range);
|
|
the ordinal position of the first block to be freed
|
|
(default 0, meaning the first allocated block);
|
|
and a number one greater than the ordinal position
|
|
of the last block to be freed
|
|
(default is one greater than the maximum block number).
|
|
If these three arguments are omitted,
|
|
then the defaults cause all allocated blocks to be freed.
|
|
.PP
|
|
In the following example run of the program,
|
|
1000 allocations of 100 bytes are performed,
|
|
and then every second allocated block is freed:
|
|
.PP
|
|
.in +4n
|
|
.EX
|
|
$ \fB./a.out 1000 100 2\fP
|
|
============== Before allocating blocks ==============
|
|
Total non\-mmapped bytes (arena): 0
|
|
# of free chunks (ordblks): 1
|
|
# of free fastbin blocks (smblks): 0
|
|
# of mapped regions (hblks): 0
|
|
Bytes in mapped regions (hblkhd): 0
|
|
Max. total allocated space (usmblks): 0
|
|
Free bytes held in fastbins (fsmblks): 0
|
|
Total allocated space (uordblks): 0
|
|
Total free space (fordblks): 0
|
|
Topmost releasable block (keepcost): 0
|
|
|
|
============== After allocating blocks ==============
|
|
Total non\-mmapped bytes (arena): 135168
|
|
# of free chunks (ordblks): 1
|
|
# of free fastbin blocks (smblks): 0
|
|
# of mapped regions (hblks): 0
|
|
Bytes in mapped regions (hblkhd): 0
|
|
Max. total allocated space (usmblks): 0
|
|
Free bytes held in fastbins (fsmblks): 0
|
|
Total allocated space (uordblks): 104000
|
|
Total free space (fordblks): 31168
|
|
Topmost releasable block (keepcost): 31168
|
|
|
|
============== After freeing blocks ==============
|
|
Total non\-mmapped bytes (arena): 135168
|
|
# of free chunks (ordblks): 501
|
|
# of free fastbin blocks (smblks): 0
|
|
# of mapped regions (hblks): 0
|
|
Bytes in mapped regions (hblkhd): 0
|
|
Max. total allocated space (usmblks): 0
|
|
Free bytes held in fastbins (fsmblks): 0
|
|
Total allocated space (uordblks): 52000
|
|
Total free space (fordblks): 83168
|
|
Topmost releasable block (keepcost): 31168
|
|
.EE
|
|
.in
|
|
.SS Program source
|
|
\&
|
|
.EX
|
|
#include <malloc.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
static void
|
|
display_mallinfo(void)
|
|
{
|
|
struct mallinfo mi;
|
|
|
|
mi = mallinfo();
|
|
|
|
printf("Total non\-mmapped bytes (arena): %d\en", mi.arena);
|
|
printf("# of free chunks (ordblks): %d\en", mi.ordblks);
|
|
printf("# of free fastbin blocks (smblks): %d\en", mi.smblks);
|
|
printf("# of mapped regions (hblks): %d\en", mi.hblks);
|
|
printf("Bytes in mapped regions (hblkhd): %d\en", mi.hblkhd);
|
|
printf("Max. total allocated space (usmblks): %d\en", mi.usmblks);
|
|
printf("Free bytes held in fastbins (fsmblks): %d\en", mi.fsmblks);
|
|
printf("Total allocated space (uordblks): %d\en", mi.uordblks);
|
|
printf("Total free space (fordblks): %d\en", mi.fordblks);
|
|
printf("Topmost releasable block (keepcost): %d\en", mi.keepcost);
|
|
}
|
|
|
|
int
|
|
main(int argc, char *argv[])
|
|
{
|
|
#define MAX_ALLOCS 2000000
|
|
char *alloc[MAX_ALLOCS];
|
|
int numBlocks, j, freeBegin, freeEnd, freeStep;
|
|
size_t blockSize;
|
|
|
|
if (argc < 3 || strcmp(argv[1], "\-\-help") == 0) {
|
|
fprintf(stderr, "%s num\-blocks block\-size [free\-step "
|
|
"[start\-free [end\-free]]]\en", argv[0]);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
numBlocks = atoi(argv[1]);
|
|
blockSize = atoi(argv[2]);
|
|
freeStep = (argc > 3) ? atoi(argv[3]) : 1;
|
|
freeBegin = (argc > 4) ? atoi(argv[4]) : 0;
|
|
freeEnd = (argc > 5) ? atoi(argv[5]) : numBlocks;
|
|
|
|
printf("============== Before allocating blocks ==============\en");
|
|
display_mallinfo();
|
|
|
|
for (j = 0; j < numBlocks; j++) {
|
|
if (numBlocks >= MAX_ALLOCS) {
|
|
fprintf(stderr, "Too many allocations\en");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
alloc[j] = malloc(blockSize);
|
|
if (alloc[j] == NULL) {
|
|
perror("malloc");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
}
|
|
|
|
printf("\en============== After allocating blocks ==============\en");
|
|
display_mallinfo();
|
|
|
|
for (j = freeBegin; j < freeEnd; j += freeStep)
|
|
free(alloc[j]);
|
|
|
|
printf("\en============== After freeing blocks ==============\en");
|
|
display_mallinfo();
|
|
|
|
exit(EXIT_SUCCESS);
|
|
}
|
|
.EE
|
|
.SH SEE ALSO
|
|
.ad l
|
|
.nh
|
|
.BR mmap (2),
|
|
.BR malloc (3),
|
|
.BR malloc_info (3),
|
|
.BR malloc_stats (3),
|
|
.BR malloc_trim (3),
|
|
.BR mallopt (3)
|