Control (core_kernel.Core_kernel.Gc.Control)

type t = { mutable minor_heap_size : Base.Int.t; The size (in words) of the minor heap. Changing this parameter will trigger a minor collection. Default: 262144 words / 1MB (32bit) / 2MB (64bit). mutable major_heap_increment : Base.Int.t; How much to add to the major heap when increasing it. If this number is less than or equal to 1000, it is a percentage of the current heap size (i.e. setting it to 100 will double the heap size at each increase). If it is more than 1000, it is a fixed number of words that will be added to the heap. Default: 15%. mutable space_overhead : Base.Int.t; The major GC speed is computed from this parameter. This is the memory that will be "wasted" because the GC does not immediately collect unreachable blocks. It is expressed as a percentage of the memory used for live data. The GC will work more (use more CPU time and collect blocks more eagerly) if space_overhead is smaller. Default: 80. mutable verbose : Base.Int.t; This value controls the GC messages on standard error output. It is a sum of some of the following flags, to print messages on the corresponding events: 0x001 Start of major GC cycle. 0x002 Minor collection and major GC slice. 0x004 Growing and shrinking of the heap. 0x008 Resizing of stacks and memory manager tables. 0x010 Heap compaction. 0x020 Change of GC parameters. 0x040 Computation of major GC slice size. 0x080 Calling of finalisation functions. 0x100 Bytecode executable search at start-up. 0x200 Computation of compaction triggering condition. Default: 0. mutable max_overhead : Base.Int.t; Heap compaction is triggered when the estimated amount of "wasted" memory is more than max_overhead percent of the amount of live data. If max_overhead is set to 0, heap compaction is triggered at the end of each major GC cycle (this setting is intended for testing purposes only). If max_overhead >= 1000000, compaction is never triggered. Default: 500. mutable stack_limit : Base.Int.t; The maximum size of the stack (in words). This is only relevant to the byte-code runtime, as the native code runtime uses the operating system's stack. Default: 1048576 words / 4MB (32bit) / 8MB (64bit). mutable allocation_policy : Base.Int.t; The policy used for allocating in the heap. Possible values are 0 and 1. 0 is the next-fit policy, which is quite fast but can result in fragmentation. 1 is the first-fit policy, which can be slower in some cases but can be better for programs with fragmentation problems. Default: 0. window_size : Base.Int.t; The size of the window used by the major GC for smoothing out variations in its workload. This is an integer between 1 and 50. Default: 1. since 4.03.0 custom_major_ratio : Base.Int.t; Target ratio of floating garbage to major heap size for out-of-heap memory held by custom values located in the major heap. The GC speed is adjusted to try to use this much memory for dead values that are not yet collected. Expressed as a percentage of major heap size. The default value keeps the out-of-heap floating garbage about the same size as the in-heap overhead. Note: this only applies to values allocated with caml_alloc_custom_mem (e.g. bigarrays). Default: 44. since 4.08.0 custom_minor_ratio : Base.Int.t; Bound on floating garbage for out-of-heap memory held by custom values in the minor heap. A minor GC is triggered when this much memory is held by custom values located in the minor heap. Expressed as a percentage of minor heap size. Note: this only applies to values allocated with caml_alloc_custom_mem (e.g. bigarrays). Default: 100. since 4.08.0 custom_minor_max_size : Base.Int.t; Maximum amount of out-of-heap memory for each custom value allocated in the minor heap. When a custom value is allocated on the minor heap and holds more than this many bytes, only this value is counted against custom_minor_ratio and the rest is directly counted against custom_major_ratio. Note: this only applies to values allocated with caml_alloc_custom_mem (e.g. bigarrays). Default: 8192 bytes. since 4.08.0 }

include Bin_prot.Binable.S with type t := t

include Bin_prot.Binable.S_only_functions with type t := t

val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader: This function only needs implementation if t exposed to be a polymorphic variant. Despite what the type reads, this does *not* produce a function after reading; instead it takes the constructor tag (int) before reading and reads the rest of the variant t afterwards.

val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t

include Ppx_sexp_conv_lib.Sexpable.S with type t := t

val t_of_sexp : Sexplib0.Sexp.t -> t
val sexp_of_t : t -> Sexplib0.Sexp.t

val custom_minor_max_size : t -> Base.Int.t
val custom_minor_ratio : t -> Base.Int.t
val custom_major_ratio : t -> Base.Int.t
val window_size : t -> Base.Int.t
val allocation_policy : t -> Base.Int.t
val set_allocation_policy : t -> Base.Int.t -> Base.Unit.t
val stack_limit : t -> Base.Int.t
val set_stack_limit : t -> Base.Int.t -> Base.Unit.t
val max_overhead : t -> Base.Int.t
val set_max_overhead : t -> Base.Int.t -> Base.Unit.t
val verbose : t -> Base.Int.t
val set_verbose : t -> Base.Int.t -> Base.Unit.t
val space_overhead : t -> Base.Int.t
val set_space_overhead : t -> Base.Int.t -> Base.Unit.t
val major_heap_increment : t -> Base.Int.t
val set_major_heap_increment : t -> Base.Int.t -> Base.Unit.t
val minor_heap_size : t -> Base.Int.t
val set_minor_heap_size : t -> Base.Int.t -> Base.Unit.t

module Fields : sig ... end

include Comparable.S with type t := t

include Base.Comparable.S with type t := t

include Base.Comparisons.Infix with type t := t

val (>=) : t -> t -> bool
val (<=) : t -> t -> bool
val (=) : t -> t -> bool
val (>) : t -> t -> bool
val (<) : t -> t -> bool
val (<>) : t -> t -> bool

val equal : t -> t -> bool
val compare : t -> t -> int: compare t1 t2 returns 0 if t1 is equal to t2, a negative integer if t1 is less than t2, and a positive integer if t1 is greater than t2.

val min : t -> t -> t
val max : t -> t -> t

val ascending : t -> t -> int: ascending is identical to compare. descending x y = ascending y x. These are intended to be mnemonic when used like List.sort ~compare:ascending and List.sort ~cmp:descending, since they cause the list to be sorted in ascending or descending order, respectively.

val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool: between t ~low ~high means low <= t <= high

val clamp_exn : t -> min:t -> max:t -> t

clamp_exn t ~min ~max returns t', the closest value to t such that between t' ~low:min ~high:max is true.

Raises if not (min <= max).

val clamp : t -> min:t -> max:t -> t Base.Or_error.t

include Base.Comparator.S with type t := t

type comparator_witness

val comparator : (t, comparator_witness) Base.Comparator.comparator

val validate_lbound : min:t Base.Maybe_bound.t -> t Base.Validate.check
val validate_ubound : max:t Base.Maybe_bound.t -> t Base.Validate.check
val validate_bound : min:t Base.Maybe_bound.t -> max:t Base.Maybe_bound.t -> t Base.Validate.check

module Replace_polymorphic_compare : sig ... end

module Map : Map.S with type Key.t = t with type Key.comparator_witness = comparator_witness

module Set : Set.S with type Elt.t = t with type Elt.comparator_witness = comparator_witness

`mutable minor_heap_size : Base.Int.t;`	The size (in words) of the minor heap. Changing this parameter will trigger a minor collection. Default: 262144 words / 1MB (32bit) / 2MB (64bit).
`mutable major_heap_increment : Base.Int.t;`	How much to add to the major heap when increasing it. If this number is less than or equal to 1000, it is a percentage of the current heap size (i.e. setting it to 100 will double the heap size at each increase). If it is more than 1000, it is a fixed number of words that will be added to the heap. Default: 15%.
`mutable space_overhead : Base.Int.t;`	The major GC speed is computed from this parameter. This is the memory that will be "wasted" because the GC does not immediately collect unreachable blocks. It is expressed as a percentage of the memory used for live data. The GC will work more (use more CPU time and collect blocks more eagerly) if `space_overhead` is smaller. Default: 80.
`mutable verbose : Base.Int.t;`	This value controls the GC messages on standard error output. It is a sum of some of the following flags, to print messages on the corresponding events: `0x001` Start of major GC cycle. `0x002` Minor collection and major GC slice. `0x004` Growing and shrinking of the heap. `0x008` Resizing of stacks and memory manager tables. `0x010` Heap compaction. `0x020` Change of GC parameters. `0x040` Computation of major GC slice size. `0x080` Calling of finalisation functions. `0x100` Bytecode executable search at start-up. `0x200` Computation of compaction triggering condition. Default: 0.
`mutable max_overhead : Base.Int.t;`	Heap compaction is triggered when the estimated amount of "wasted" memory is more than `max_overhead` percent of the amount of live data. If `max_overhead` is set to 0, heap compaction is triggered at the end of each major GC cycle (this setting is intended for testing purposes only). If `max_overhead >= 1000000`, compaction is never triggered. Default: 500.
`mutable stack_limit : Base.Int.t;`	The maximum size of the stack (in words). This is only relevant to the byte-code runtime, as the native code runtime uses the operating system's stack. Default: 1048576 words / 4MB (32bit) / 8MB (64bit).
`mutable allocation_policy : Base.Int.t;`	The policy used for allocating in the heap. Possible values are 0 and 1. 0 is the next-fit policy, which is quite fast but can result in fragmentation. 1 is the first-fit policy, which can be slower in some cases but can be better for programs with fragmentation problems. Default: 0.
`window_size : Base.Int.t;`	The size of the window used by the major GC for smoothing out variations in its workload. This is an integer between 1 and 50. Default: 1. since 4.03.0
`custom_major_ratio : Base.Int.t;`	Target ratio of floating garbage to major heap size for out-of-heap memory held by custom values located in the major heap. The GC speed is adjusted to try to use this much memory for dead values that are not yet collected. Expressed as a percentage of major heap size. The default value keeps the out-of-heap floating garbage about the same size as the in-heap overhead. Note: this only applies to values allocated with `caml_alloc_custom_mem` (e.g. bigarrays). Default: 44. since 4.08.0
`custom_minor_ratio : Base.Int.t;`	Bound on floating garbage for out-of-heap memory held by custom values in the minor heap. A minor GC is triggered when this much memory is held by custom values located in the minor heap. Expressed as a percentage of minor heap size. Note: this only applies to values allocated with `caml_alloc_custom_mem` (e.g. bigarrays). Default: 100. since 4.08.0
`custom_minor_max_size : Base.Int.t;`	Maximum amount of out-of-heap memory for each custom value allocated in the minor heap. When a custom value is allocated on the minor heap and holds more than this many bytes, only this value is counted against `custom_minor_ratio` and the rest is directly counted against `custom_major_ratio`. Note: this only applies to values allocated with `caml_alloc_custom_mem` (e.g. bigarrays). Default: 8192 bytes. since 4.08.0