Memory                 package:base                 R Documentation

_M_e_m_o_r_y _A_v_a_i_l_a_b_l_e _f_o_r _D_a_t_a _S_t_o_r_a_g_e

_D_e_s_c_r_i_p_t_i_o_n:

     Use command line options to control the memory available for R.

_U_s_a_g_e:

     R --min-vsize=vl --max-vsize=vu --min-nsize=nl --max-nsize=nu --max-ppsize=N

     mem.limits(nsize = NA, vsize = NA)

_A_r_g_u_m_e_n_t_s:

vl, vu, vsize: Heap memory in bytes.

nl, nu, nsize: Number of cons cells.

       N: Number of nested 'PROTECT' calls.

     .

_D_e_t_a_i_l_s:

     R has a variable-sized workspace (from version 1.2.0). There is
     now much less need to set memory options than previously, and most
     users will never need to set these.  They are provided both as a
     way to control the overall memory usage (which can also be done by
     operating-system facilities such as 'limit' on Unix), and since
     setting larger values of the minima will make R slightly more
     efficient on large tasks.

     To understand the options, one needs to know that 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. 
     Effectively, the inputs 'vl' and 'vu' are rounded up to the next
     multiple of 8.

     Each cons cell occupies 28 bytes on a 32-bit machine, (usually) 56
     bytes on a 64-bit machine.

     The '--*-nsize' options can be used to specify the number of cons
     cells and the '--*-vsize' options specify the size of the vector
     heap in bytes.  Both options must be integers or integers followed
     by 'G', 'M', 'K', or 'k' meaning 'Giga' (2^{30} = 1073741824)
     _Mega_ (2^{20} = 1048576), (computer) _Kilo_ (2^{10} = 1024), or
     regular _kilo_ (1000).

     The '--min-*' options set the minimal sizes for the number of cons
     cells and for the vector heap.  These values are also the initial
     values, but thereafter R will grow or shrink the areas depending
     on usage, but never exceeding the limits set by the '--max-*'
     options nor decreasing below the initial values.

     The default values are currently minima of 350k cons cells, 6Mb of
     vector heap and no maxima (other than machine resources).  The
     maxima can be changed during an R session by calling 'mem.limits'.
     (If this is called with the default values, it reports the current
     settings.)

     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 'gcinfo(TRUE)', automatic garbage
     collection always prints memory use statistics.  Maxima will never
     be reduced below the current values for triggering garbage
     collection, and attempts to do so will be silently ignored.

     The 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.

_V_a_l_u_e:

     'mem.limits()' returns an integer vector giving the current
     settings of the maxima, possibly 'NA'.

_S_e_e _A_l_s_o:

     _An Introduction to R_ for more command-line options

     'Memory-limits' for the design limitations.

     'gc' for information on the garbage collector and total memory
     usage,  'object.size(a)' for the (approximate) size of R object
     'a'.  'memory.profile' for profiling the usage of cons cells.

_E_x_a_m_p_l_e_s:

     # Start R with 10MB of heap memory and 500k cons cells, limit to
     # 100Mb and 1M cells
     ## Not run: 
     ## Unix
     R --min-vsize=10M --max-vsize=100M --min-nsize=500k --max-nsize=1M
     ## End(Not run)

