Memory Available for Data Storage
How R manages its workspace.
R has a variable-sized workspace. There are (rarely-used)
command-line options to control its minimum size, but no longer any to
control the maximum size. On Windows the --max-mem-size option (or environment variable
R_MAX_MEM_SIZE) sets the maximum (virtual) memory allocation: it
has a minimum allowed value of 32M. This is intended to catch
attempts to allocate excessive amounts of memory which may cause other
processes to run out of resources. See also
memory.limit. R maintains separate areas for fixed and variable sized objects. The
first of these is allocated as an array of cons cells (Lisp
programmers will know what they are, others may think of them as the
building blocks of the language itself, parse trees, etc.), and the
second are thrown on a heap of ‘Vcells’ of 8 bytes each.
Each cons cell occupies 28 bytes on a 32-bit build of R, (usually) 56
bytes on a 64-bit build. The default values are (currently) an initial setting of 350k cons
cells and 6Mb of vector heap. Note that the areas are not actually
allocated initially: rather these values are the sizes for triggering
garbage collection. These values can be set by the command line
options --min-nsize and --min-vsize (or if they are
not used, the environment variables
when R is started. Thereafter R will grow or shrink the areas
depending on usage, never decreasing below the initial values. How much time R spends in the garbage collector will depend on these
initial settings and on the trade-off the memory manager makes, when
memory fills up, between collecting garbage to free up unused memory
and growing these areas. The strategy used for growth can be
specified by setting the environment variable
an integer value between 0 and 3. This variable is read at
start-up. Higher values grow the heap more aggressively, thus reducing
garbage collection time but using more memory. You can find out the current memory consumption (the heap and cons
cells used as numbers and megabytes) by typing
gc() at the
R prompt. Note that following
garbage collection always prints memory use statistics. The command-line option --max-ppsize controls the maximum
size of the pointer protection stack. This defaults to 50000, but can
be increased to allow deep recursion or large and complicated
calculations to be done. Note that parts of the garbage
collection process goes through the full reserved pointer protection
stack and hence becomes slower when the size is increased. Currently
the maximum value accepted is 500000.
An Introduction to R for more command-line options.
Memory-limits for the design limitations.
gc for information on the garbage collector and total
object.size(a) for the (approximate)
size of R object
profiling the usage of cons cells.
memory.size to monitor total memory usage,
memory.limit for the current limit.