

   MMeemmoorryy AAvvaaiillaabbllee ffoorr DDaattaa SSttoorraaggee

        R --vsize v --nsize n

   AArrgguummeennttss::

          v: Use `v' megabytes of heap memory

          n: Use `n' cons cells.

   DDeessccrriippttiioonn::

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

   DDeettaaiills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''.  The `--nsize' option can be
        used to specify the number of cons cells (each occupy-
        ing 16 bytes) which R is to use (the default is
        200000), and the `--vsize' option to  specify the size
        of the vector heap in million bytes (the default is 2).
        Only integers are allowed for both options.

        E.g., to read in a table of 5000 observations on 40
        numeric variables, `R --vsize 6' should do.

        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 col-
        lection always prints memory use statistics.

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

        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Seeee AAllssoo::

        `gc' for information on the garbage collector.

   EExxaammpplleess::

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

        R --vsize 15 --nsize 1000000

