Module Core_kernel.Gc

This is a wrapper around INRIA's standard Gc module. Provides memory management control and statistics, and finalized values.

module Stat : sig ... end
type stat = Stat.t
module Control : sig ... end
type control = Control.t
val stat : Core_kernel__.Import.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 : Core_kernel__.Import.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 : Core_kernel__.Import.unit -> Core_kernel__.Import.float * Core_kernel__.Import.float * Core_kernel__.Import.float

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

val minor_words : Core_kernel__.Import.unit ->

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 : Core_kernel__.Import.unit ->
val promoted_words : Core_kernel__.Import.unit ->
val minor_collections : Core_kernel__.Import.unit ->
val major_collections : Core_kernel__.Import.unit ->
val heap_words : Core_kernel__.Import.unit ->
val heap_chunks : Core_kernel__.Import.unit ->
val compactions : Core_kernel__.Import.unit ->
val top_heap_words : Core_kernel__.Import.unit ->
val major_plus_minor_words : Core_kernel__.Import.unit ->

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 : Core_kernel__.Import.unit -> control

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

val set : control -> Core_kernel__.Import.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 : Core_kernel__.Import.unit -> Core_kernel__.Import.unit

Trigger a minor collection.

val major_slice : ->

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 : Core_kernel__.Import.unit -> Core_kernel__.Import.unit

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

val full_major : Core_kernel__.Import.unit -> Core_kernel__.Import.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 : Core_kernel__.Import.unit -> Core_kernel__.Import.unit

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

val print_stat : Stdlib.out_channel -> Core_kernel__.Import.unit

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

val allocated_bytes : Core_kernel__.Import.unit -> Core_kernel__.Import.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 : _ -> Core_kernel__.Import.unit

keep_alive a ensures that a is live at the point where keep_alive a is called. It is like ignore a, except that the compiler won't be able to simplify it and potentially collect a too soon.

module Allocation_policy : sig ... end

The policy used for allocating in the heap.

val tune : ?⁠logger:(Core_kernel__.Import.string -> Core_kernel__.Import.unit) -> ?⁠ -> ?⁠ -> ?⁠ -> ?⁠ -> ?⁠ -> ?⁠ -> ?⁠allocation_policy:Allocation_policy.t -> ?⁠ -> ?⁠ -> ?⁠ -> ?⁠ -> Core_kernel__.Import.unit -> Core_kernel__.Import.unit

Adjust the specified GC parameters.

val disable_compaction : ?⁠logger:(Core_kernel__.Import.string -> Core_kernel__.Import.unit) -> allocation_policy:[ `Don't_change | `Set_to of Allocation_policy.t ] -> Core_kernel__.Import.unit -> Core_kernel__.Import.unit
module Expert : sig ... end

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

module Stable : sig ... end