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 set the memory available for R.

_U_s_a_g_e:

     R --vsize=v --nsize=n

_A_r_g_u_m_e_n_t_s:

       v: Use `v' bytes of heap memory

       n: Use `n' cons cells.

_D_e_t_a_i_l_s:

     R (currently) uses a static memory model.  This means that when it
     starts up, it asks the operating system to reserve a fixed amount
     of memory for it.  The size of this chunk cannot be changed
     subsequently. Hence, it can happen that not enough memory was
     allocated, e.g., when trying to read large data sets into R.

     In these cases, you should restart R (after saving your current
     workspace) with more memory available, using the command line
     options `--nsize' and `--vsize'.  To understand these 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'' (see `gc()["Vcells","total"]') of 8 bytes
     each.  Effectively, the input `v' is therefore truncated to the
     nearest multiple of 8.

     The `--nsize' option can be used to specify the number of cons
     cells (each occupying 20 bytes on a 32-bit machine) which R is to
     use (the default is 250000), and the `--vsize' option to specify
     the size of the vector heap in bytes (the default is 6 MB).  Both
     options must be integers or integers ending with `M', `K', or `k'
     meaning Mega (2^{20} = 1048576), (computer) Kilo (2^{10} = 1024),
     or regular kilo (1000). (The minimum allowed values are 200000 and
     2M.)

     E.g., to read in a table of 10000 observations on 40 numeric
     variables, `R --vsize=10M' should do; for sourcing a large file,
     you would use `R --nsize=500k'.

     Note that the information on where to find vectors and strings on
     the heap is stored using cons cells.  Thus, it may also be
     necessary to allocate more space for cons cells in order to
     perform computations with very ``large'' variable-size objects.

     You can find out the current memory consumption (the proportion of
     heap and cons cells used) by typing `gc()' at the R prompt.  This
     may help you in finding out whether to increase `--vsize' or
     `--nsize'.  Note that following `gcinfo(TRUE)', automatic garbage
     collection always prints memory use statistics.

     R will tell you whether you ran out of cons or heap memory.

     The defaults for `--nsize' and `--vsize' can be changed by setting
     the environment variables `R_NSIZE' and `R_VSIZE' respectively,
     perhaps most conveniently in the file `.Renviron' or
     `~/.Renviron'.

     When using `read.table', the memory requirements are in fact
     higher than anticipated, because the file is first read in as one
     long string which is then split again.  Use `scan' if possible in
     case you run out of memory when reading in a large table.

_S_e_e _A_l_s_o:

     `gc' for information on the garbage collector, `memory.profile'
     for profiling the usage of cons cells.

_E_x_a_m_p_l_e_s:

     # Start R with 15MB of heap memory and 1 million cons cells

     ## Unix
     R --vsize=15M --nsize=1000k

