The garbage collector looks at a number of environment variables which are,
then, used to affect its operation.

GC_INITIAL_HEAP_SIZE=<bytes> -  Initial heap size in bytes.  May speed up
                                process start-up.  Optionally, may be
                                specified with a multiplier ('k', 'M' or 'G')
                                suffix.

GC_MAXIMUM_HEAP_SIZE=<bytes> - Maximum collected heap size.  Allows
                               a multiplier suffix.

GC_LOOP_ON_ABORT - Causes the collector abort routine to enter a tight loop.
                   This may make it easier to debug, such a process, especially
                   for multi-threaded platforms that don't produce usable core
                   files, or if a core file would be too large.  On some
                   platforms, this also causes SIGSEGV to be caught and
                   result in an infinite loop in a handler, allowing
                   similar debugging techniques.

GC_PRINT_STATS - Turn on GC logging.  Not functional with SMALL_CONFIG.

GC_LOG_FILE - The name of the log file.  Stderr by default.  Not functional
              with SMALL_CONFIG.

GC_ONLY_LOG_TO_FILE - Turns off redirection of GC stdout and stderr to the log
                      file specified by GC_LOG_FILE.  Has no effect unless
                      GC_LOG_FILE is set.  Not functional with SMALL_CONFIG.

GC_PRINT_VERBOSE_STATS - Turn on even more logging.  Not functional with
                         SMALL_CONFIG.

GC_DUMP_REGULARLY - Generate a GC debugging dump (by GC_dump_named) on startup
                    and during every collection.  Very verbose.  Useful
                    if you have a bug to report, but please include only the
                    last complete dump.

GC_COLLECT_AT_MALLOC=<n> - Override the default value specified by
                           GC_COLLECT_AT_MALLOC macro.  Has no effect unless
                           GC is built with GC_COLLECT_AT_MALLOC defined.

GC_BACKTRACES=<n> - Generate n random back-traces (for heap profiling) after
                    each GC.  Collector must have been built with
                    KEEP_BACK_PTRS.  This won't generate useful output unless
                    most objects in the heap were allocated through debug
                    allocators.  This is intended to be only a statistical
                    sample;  individual traces may be erroneous due to
                    concurrent heap mutation.

GC_PRINT_ADDRESS_MAP - Linux only.  Dump /proc/self/maps, i.e. various address
                       maps for the process, to stderr on every GC.  Useful for
                       mapping root addresses to source for deciphering leak
                       reports.

GC_NPROCS=<n> - Linux w/threads only.  Explicitly sets the number of processors
                that the GC should expect to use.  Note that setting this to 1
                when multiple processors are available will preserve
                correctness, but may lead to really horrible performance,
                since the lock implementation will immediately yield without
                first spinning.

GC_MARKERS=<n> - Only if compiled with PARALLEL_MARK.  Set the number
                of marker threads.  This is normally set to the number of
                processors.  It is safer to adjust GC_MARKERS than GC_NPROCS,
                since GC_MARKERS has no impact on the lock implementation.

GC_NO_BLACKLIST_WARNING - Prevents the collector from issuing
                warnings about allocations of very large blocks.
                Deprecated.  Use GC_LARGE_ALLOC_WARN_INTERVAL instead.

GC_LARGE_ALLOC_WARN_INTERVAL=<n> - Print every nth warning about very large
                block allocations, starting with the nth one.  Small values
                of n are generally benign, in that a bounded number of
                such warnings generally indicate at most a bounded leak.
                For best results it should be set at 1 during testing.
                Default is 5.  Very large numbers effectively disable the
                warning.

GC_IGNORE_GCJ_INFO - Ignore the type descriptors implicitly supplied by
                     GC_gcj_malloc and friends.  This is useful for debugging
                     descriptor generation problems, and possibly for
                     temporarily working around such problems.  It forces a
                     fully conservative scan of all heap objects except
                     those known to be pointer-free, and may thus have other
                     adverse effects.

GC_PRINT_BACK_HEIGHT - Print max length of chain through unreachable objects
                     ending in a reachable one.  If this number remains
                     bounded, then the program is "GC robust".  This ensures
                     that a fixed number of misidentified pointers can only
                     result in a bounded space leak.  This currently only
                     works if debugging allocation is used throughout.
                     It increases GC space and time requirements appreciably.
                     This feature is still somewhat experimental, and requires
                     that the collector have been built with MAKE_BACK_GRAPH
                     defined.  For details, see Boehm, "Bounding Space Usage
                     of Conservative Garbage Collectors", POPL 2001
                     (http://www.hpl.hp.com/techreports/2001/HPL-2001-251.html).

GC_RETRY_SIGNALS -   Try to compensate for lost
                     thread suspend and restart signals (Pthreads only).
                     On by default for OSF1 (Tru64) or if the library is
                     sanitized, off otherwise.  Since we've previously seen
                     similar issues on some other operating systems, it
                     was turned into a runtime flag to enable last-minute
                     work-arounds.  "0" value means "do not retry signals".

GC_USE_GETWRITEWATCH=<n> - Only if MPROTECT_VDB and (GWW_VDB or SOFT_VDB) are
                     both defined (Win32 and Linux only).  Explicitly specify
                     which strategy of keeping track of dirtied pages should
                     be used.  If n=0, then fall back to protecting pages and
                     catching memory faults strategy), else the collector
                     tries to use GetWriteWatch-based strategy (GWW_VDB) or
                     soft-dirty bits strategy (SOFT_VDB) first if available.

GC_DISABLE_INCREMENTAL - Ignore runtime requests to enable incremental GC.
                     Useful for debugging.

The following turn on runtime flags that are also program settable.  Checked
only during initialization.  We expect that they will usually be set through
other means, but this may help with debugging and testing:

GC_ENABLE_INCREMENTAL - Turn on incremental collection at startup.  Note that,
                     depending on platform and collector configuration, this
                     may involve write protecting pieces of the heap to
                     track modifications.  These pieces may include
                     pointer-free objects or not.  Although this is intended
                     to be transparent, it may cause unintended system call
                     failures.  Use with caution.

GC_PAUSE_TIME_TARGET - Set the desired garbage collector pause time in
                     milliseconds (ms).  This only has an effect if incremental
                     collection is enabled.  If a collection requires
                     appreciably more time than this, the client will be
                     restarted, and the collector will need to do additional
                     work to compensate.  The special value "999999" indicates
                     that pause time is unlimited, and the incremental
                     collector will behave completely like a simple
                     generational collector.  Any value, except for the given
                     special one, disables parallel marker (almost fully) for
                     now.

GC_FULL_FREQUENCY - Set the desired number of partial collections between full
                    collections.  Matters only if GC_incremental is set.
                    Not functional with SMALL_CONFIG.

GC_FREE_SPACE_DIVISOR - Set GC_free_space_divisor to the indicated value.
                      Setting it to larger values decreases space consumption
                      and increases GC frequency.

GC_UNMAP_THRESHOLD - Set the desired memory blocks unmapping threshold (the
                   number of sequential garbage collections for which
                   a candidate block for unmapping should remain free).  The
                   special value "0" completely disables unmapping.

GC_FORCE_UNMAP_ON_GCOLLECT - Turn "unmap as much as possible on explicit GC"
                mode on (overrides the default value).  Has no effect on
                implicitly-initiated garbage collections.  Has no effect if
                memory unmapping is disabled (or not compiled in) or if the
                unmapping threshold is 1.

GC_FIND_LEAK - Turns on GC_find_leak and thus leak detection.  Forces a
               collection at program termination to detect leaks that would
               otherwise occur after the last GC.

GC_FINDLEAK_DELAY_FREE - Turns on deferred freeing of objects in the
                       leak-finding mode (see the corresponding macro
                       description for more information).

GC_ABORT_ON_LEAK - Causes the application to be terminated once leaked or
                   smashed objects are found.

GC_ALL_INTERIOR_POINTERS - Turns on GC_all_interior_pointers and thus interior
                           pointer recognition.

GC_DONT_GC - Turns off garbage collection.  Use cautiously.

GC_USE_ENTIRE_HEAP - Set desired GC_use_entire_heap value at start-up.  See
                     the similar macro description in README.macros.

GC_TRACE=addr - Intended for collector debugging.  Requires that the collector
                have been built with ENABLE_TRACE defined.  Causes the debugger
                to log information about the tracing of address ranges
                containing addr.  Typically addr is the address that contains
                a pointer to an object that mysteriously failed to get marked.
                Addr must be specified as a hexadecimal integer.
