Module Core_kernel__.Gc
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 thatlive_words
,live_blocks
,free_words
,free_blocks
,largest_free
, andfragments
are set to 0. This function is much faster thanstat
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 atquick_stat
.
val minor_words : Core_kernel__.Import.unit -> Core_kernel__.Import.int
The following functions return the same as
(Gc.quick_stat ()).Stat.f
, avoiding any allocation (of thestat
record or a float). On 32-bit machines theint
may overflow.Note that
minor_words
does not allocate, but we do not annotate it asnoalloc
because we want the compiler to save the value of the allocation pointer register (%r15 on x86-64) to the global variablecaml_young_ptr
before the C stub tries to read its value.
val major_words : Core_kernel__.Import.unit -> Core_kernel__.Import.int
val promoted_words : Core_kernel__.Import.unit -> Core_kernel__.Import.int
val minor_collections : Core_kernel__.Import.unit -> Core_kernel__.Import.int
val major_collections : Core_kernel__.Import.unit -> Core_kernel__.Import.int
val heap_words : Core_kernel__.Import.unit -> Core_kernel__.Import.int
val heap_chunks : Core_kernel__.Import.unit -> Core_kernel__.Import.int
val compactions : Core_kernel__.Import.unit -> Core_kernel__.Import.int
val top_heap_words : Core_kernel__.Import.unit -> Core_kernel__.Import.int
val major_plus_minor_words : Core_kernel__.Import.unit -> Core_kernel__.Import.int
This function returns
major_words () + minor_words ()
. It exists purely for speed (one call into C rather than two). Likemajor_words
andminor_words
,major_plus_minor_words
avoids allocating astat
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 thecontrol
recordr
. 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 : Core_kernel__.Import.int -> Core_kernel__.Import.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 : 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 withint
on 32-bit machines.
val keep_alive : _ -> Core_kernel__.Import.unit
keep_alive a
ensures thata
is live at the point wherekeep_alive a
is called. It is likeignore a
, except that the compiler won't be able to simplify it and potentially collecta
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) -> ?minor_heap_size:Core_kernel__.Import.int -> ?major_heap_increment:Core_kernel__.Import.int -> ?space_overhead:Core_kernel__.Import.int -> ?verbose:Core_kernel__.Import.int -> ?max_overhead:Core_kernel__.Import.int -> ?stack_limit:Core_kernel__.Import.int -> ?allocation_policy:Allocation_policy.t -> ?window_size:Core_kernel__.Import.int -> ?custom_major_ratio:Core_kernel__.Import.int -> ?custom_minor_ratio:Core_kernel__.Import.int -> ?custom_minor_max_size:Core_kernel__.Import.int -> 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