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.

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 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.

type alarm

An alarm is a piece of data that calls a user function at the end of each major GC cycle. The following functions are provided to create and delete alarms.

val create_alarm : (unit -> unit) -> alarm

create_alarm f will arrange for f to be called at the end of each major GC cycle, starting with the current cycle or the next one. A value of type alarm is returned that you can use to call delete_alarm.

val delete_alarm : alarm -> unit

delete_alarm a will stop the calls to the function associated to a. Calling delete_alarm a again has no effect.

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.