# Module Core_gc

    module Core_gc: sig .. end

Memory management control and statistics; finalised values.

    module Stat: sig .. end

    type stat = Stat.t

The memory management counters are returned in a `stat` record.

The total amount of memory allocated by the program since it was started is (in words) `minor_words + major_words - promoted_words`. Multiply by the word size (4 on a 32-bit machine, 8 on a 64-bit machine) to get the number of bytes.

    module Control: sig .. end

    type control = Control.t

The GC parameters are given as a `control` record. Note that these parameters can also be initialised by setting the OCAMLRUNPARAM environment variable. See the documentation of ocamlrun.

    val stat : unit -> stat

Return the current values of the memory management counters in a `stat` record. This function examines every heap block to get the statistics.

    val quick_stat : unit -> stat

Same as `stat` except that `live_words`, `live_blocks`, `free_words`, `free_blocks`, `largest_free`, and `fragments` are set to 0. This function is much faster than `stat` because it does not need to go through the heap.

    val counters : unit -> float * float * float

Return `(minor_words, promoted_words, major_words)`. This function is as fast at `quick_stat`.

    val minor_words : unit -> int

The following functions return the same as `(Gc.quick_stat ()).Stat.f`, avoiding any allocation (of the `stat` record or a float). On 32-bit machines the `int` may overflow.

Note that `minor_words` does not allocate, but we do not annotate it as `noalloc` because we want the compiler to save the value of the allocation pointer register (%r15 on x86-64) to the global variable `caml_young_ptr` before the C stub tries to read its value.

    val major_words : unit -> int

    val promoted_words : unit -> int

    val minor_collections : unit -> int

    val major_collections : unit -> int

    val heap_words : unit -> int

    val heap_chunks : unit -> int

    val compactions : unit -> int

    val top_heap_words : unit -> int

    val major_plus_minor_words : unit -> int

This function returns `major_words () + minor_words ()`. It exists purely for speed (one call into C rather than two). Like `major_words` and `minor_words`, `major_plus_minor_words` avoids allocating a `stat` record or a float, and may overflow on 32-bit machines.

This function is not marked `"noalloc"` to ensure that the allocation pointer is up-to-date when the minor-heap measurement is made.

    val get : unit -> control

Return the current values of the GC parameters in a `control` record.

    val set : control -> unit

`set r` changes the GC parameters according to the `control` record `r`. The normal usage is: `Gc.set { (Gc.get()) with Gc.Control.verbose = 0x00d }`

    val minor : unit -> unit

Trigger a minor collection.

    val major_slice : int -> int

Do a minor collection and a slice of major collection. The argument is the size of the slice, 0 to use the automatically-computed slice size. In all cases, the result is the computed slice size.

    val major : unit -> unit

Do a minor collection and finish the current major collection cycle.

    val full_major : unit -> unit

Do a minor collection, finish the current major collection cycle, and perform a complete new cycle. This will collect all currently unreachable blocks.

    val compact : unit -> unit

Perform a full major collection and compact the heap. Note that heap compaction is a lengthy operation.

    val print_stat : Pervasives.out_channel -> unit

Print the current values of the memory management counters (in human-readable form) into the channel argument.

    val allocated_bytes : unit -> float

Return the total number of bytes allocated since the program was started. It is returned as a `float` to avoid overflow problems with `int` on 32-bit machines.

    val keep_alive : 'a -> unit

    val tune : ?logger:(string -> unit) ->
           ?minor_heap_size:int ->
           ?major_heap_increment:int ->
           ?space_overhead:int ->
           ?verbose:int ->
           ?max_overhead:int ->
           ?stack_limit:int -> ?allocation_policy:int -> unit -> unit

Adjust the specified GC parameters.

    module Allocation_policy: sig .. end

The policy used for allocating in the heap.

    val disable_compaction : ?logger:(string -> unit) ->
           allocation_policy:[ `Don't_change | `Set_to of Allocation_policy.t ] ->
           unit -> unit

    module Expert: sig .. end

The `Expert` module contains functions that novice users should not use, due to their complexity.