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.
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.
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 : Base.Unit.t ->Base.Float.t * Base.Float.t * Base.Float.t
Return (minor_words, promoted_words, major_words). This function is as fast at quick_stat.
val minor_words : Base.Unit.t ->Base.Int.t
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 : Base.Unit.t ->Base.Int.t
val promoted_words : Base.Unit.t ->Base.Int.t
val minor_collections : Base.Unit.t ->Base.Int.t
val major_collections : Base.Unit.t ->Base.Int.t
val compactions : Base.Unit.t ->Base.Int.t
val major_plus_minor_words : Base.Unit.t ->Base.Int.t
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 allocated_words : Base.Unit.t ->Base.Int.t
This function returns major_words () - promoted_words () + minor_words (), as fast as possible. As major_plus_minor_words, we avoid allocating but cannot be marked @@noalloc yet. It may overflow in 32-bit mode.
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 : Base.Unit.t ->Base.Unit.t
Trigger a minor collection.
val major_slice : Base.Int.t ->Base.Int.t
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 : Base.Unit.t ->Base.Unit.t
Do a minor collection and finish the current major collection cycle.
val full_major : Base.Unit.t ->Base.Unit.t
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 : Base.Unit.t ->Base.Unit.t
Perform a full major collection and compact the heap. Note that heap compaction is a lengthy operation.
val print_stat : Stdlib.out_channel ->Base.Unit.t
Print the current values of the memory management counters (in human-readable form) into the channel argument.
val allocated_bytes : Base.Unit.t ->Base.Float.t
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 : _->Base.Unit.t
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.