Return to README.environment CVS log

Up to [local] / OpenXM_contrib2 / asir2000 / gc / doc

Annotation of OpenXM_contrib2/asir2000/gc/doc/README.environment, Revision 1.1

1.1     ! noro        1: The garbage collector looks at a number of environment variables which are
        !             2: then used to affect its operation.  These are examined only on Un*x-like
        !             3: platforms.
        !             4:
        !             5: GC_INITIAL_HEAP_SIZE=<bytes> - Initial heap size in bytes.  May speed up
        !             6:                                process start-up.
        !             7:
        !             8: GC_LOOP_ON_ABORT - Causes the collector abort routine to enter a tight loop.
        !             9:                   This may make it easier to debug, such a process, especially
        !            10:                   for multithreaded platforms that don't produce usable core
        !            11:                   files, or if a core file would be too large.  On some
        !            12:                   platforms, this also causes SIGSEGV to be caught and
        !            13:                   result in an infinite loop in a handler, allowing
        !            14:                   similar debugging techniques.
        !            15:
        !            16: GC_PRINT_STATS - Turn on as much logging as is easily feasible without
        !            17:                 adding signifcant runtime overhead.  Doesn't work if
        !            18:                 the collector is built with SMALL_CONFIG.  Overridden
        !            19:                 by setting GC_quiet.  On by default if the collector
        !            20:                 was built without -DSILENT.
        !            21:
        !            22: GC_PRINT_ADDRESS_MAP - Linux only.  Dump /proc/self/maps, i.e. various address
        !            23:                       maps for the process, to stderr on every GC.  Useful for
        !            24:                       mapping root addresses to source for deciphering leak
        !            25:                       reports.
        !            26:
        !            27: GC_NPROCS=<n> - Linux w/threads only.  Explicitly sets the number of processors
        !            28:                that the GC should expect to use.  Note that setting this to 1
        !            29:                when multiple processors are available will preserve
        !            30:                correctness, but may lead to really horrible performance,
        !            31:                since the lock implementation will immediately yield without
        !            32:                first spinning.
        !            33:
        !            34: GC_MARKERS=<n> - Linux w/threads and parallel marker only.  Set the number
        !            35:                of marker threads.  This is normaly set to the number of
        !            36:                processors.  It is safer to adjust GC_MARKERS than GC_NPROCS,
        !            37:                since GC_MARKERS has no impact on the lock implementation.
        !            38:
        !            39: GC_NO_BLACKLIST_WARNING - Prevents the collector from issuing
        !            40:                warnings about allocations of very large blocks.
        !            41:                Deprecated.  Use GC_LARGE_ALLOC_WARN_INTERVAL instead.
        !            42:
        !            43: GC_LARGE_ALLOC_WARN_INTERVAL=<n> - Print every nth warning about very large
        !            44:                block allocations, starting with the nth one.  Small values
        !            45:                of n are generally benign, in that a bounded number of
        !            46:                such warnings generally indicate at most a bounded leak.
        !            47:                For best results it should be set at 1 during testing.
        !            48:                Default is 5.  Very large numbers effectively disable the
        !            49:                warning.
        !            50:
        !            51: GC_IGNORE_GCJ_INFO - Ignore the type descriptors implicitly supplied by
        !            52:                     GC_gcj_malloc and friends.  This is useful for debugging
        !            53:                     descriptor generation problems, and possibly for
        !            54:                     temporarily working around such problems.  It forces a
        !            55:                     fully conservative scan of all heap objects except
        !            56:                     those known to be pointerfree, and may thus have other
        !            57:                     adverse effects.
        !            58:
        !            59: GC_PRINT_BACK_HEIGHT - Print max length of chain through unreachable objects
        !            60:                     ending in a reachable one.  If this number remains
        !            61:                     bounded, then the program is "GC robust".  This ensures
        !            62:                     that a fixed number of misidentified pointers can only
        !            63:                     result in a bounded space leak.  This currently only
        !            64:                     works if debugging allocation is used throughout.
        !            65:                     It increases GC space and time requirements appreciably.
        !            66:                     This feature is still somewhat experimental, and requires
        !            67:                     that the collector have been built with MAKE_BACK_GRAPH
        !            68:                     defined.  For details, see Boehm, "Bounding Space Usage
        !            69:                     of Conservative Garbage Collectors", POPL 2001, or
        !            70:                     http://lib.hpl.hp.com/techpubs/2001/HPL-2001-251.html .
        !            71:
        !            72: The following turn on runtime flags that are also program settable.  Checked
        !            73: only during initialization.  We expect that they will usually be set through
        !            74: other means, but this may help with debugging and testing:
        !            75:
        !            76: GC_ENABLE_INCREMENTAL - Turn on incremental collection at startup.  Note that,
        !            77:                     depending on platform and collector configuration, this
        !            78:                     may involve write protecting pieces of the heap to
        !            79:                     track modifications.  These pieces may include pointerfree
        !            80:                     objects or not.  Although this is intended to be
        !            81:                     transparent, it may cause unintended system call failures.
        !            82:                     Use with caution.
        !            83:
        !            84: GC_PAUSE_TIME_TARGET - Set the desired garbage collector pause time in msecs.
        !            85:                     This only has an effect if incremental collection is
        !            86:                     enabled.  If a collection requires appreciably more time
        !            87:                     than this, the client will be restarted, and the collector
        !            88:                     will need to do additional work to compensate.  The
        !            89:                     special value "999999" indicates that pause time is
        !            90:                     unlimited, and the incremental collector will behave
        !            91:                     completely like a simple generational collector.  If
        !            92:                     the collector is configured for parallel marking, and
        !            93:                     run on a multiprocessor, incremental collection should
        !            94:                     only be used with unlimited pause time.
        !            95:
        !            96: GC_FIND_LEAK - Turns on GC_find_leak and thus leak detection.
        !            97:
        !            98: GC_ALL_INTERIOR_POINTERS - Turns on GC_all_interior_pointers and thus interior
        !            99:                           pointer recognition.
        !           100:
        !           101: GC_DONT_GC - Turns off garbage collection.  Use cautiously.