mutable minor_heap_size : int;
The size (in words) of the minor heap. Changing this parameter will trigger a minor collection. Default: 256k.
mutable major_heap_increment : int;
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 : int;
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 : int;
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 and shared library search at start-up.
0x200 Computation of compaction-triggering condition.
0x400 Output GC statistics at program exit. Default: 0.
mutable max_overhead : int;
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. If compaction is permanently disabled, it is strongly suggested to set
allocation_policy to 2. Default: 500.
mutable stack_limit : int;
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: 1024k.
mutable allocation_policy : int;
The policy used for allocating in the major heap. Possible values are 0, 1 and 2.
- 0 is the next-fit policy, which is usually fast but can result in fragmentation, increasing memory consumption.
- 1 is the first-fit policy, which avoids fragmentation but has corner cases (in certain realistic workloads) where it is sensibly slower.
- 2 is the best-fit policy, which is fast and avoids fragmentation. In our experiments it is faster and uses less memory than both next-fit and first-fit. (since OCaml 4.10)
The current default is next-fit, as the best-fit policy is new and not yet widely tested. We expect best-fit to become the default in the future.
On one example that was known to be bad for next-fit and first-fit, next-fit takes 28s using 855Mio of memory, first-fit takes 47s using 566Mio of memory, best-fit takes 27s using 545Mio of memory.
Note: When changing to a low-fragmentation policy, you may need to augment the
space_overhead setting, for example using
100 instead of the default
80 which is tuned for next-fit. Indeed, the difference in fragmentation behavior means that different policies will have different proportion of "wasted space" for a given program. Less fragmentation means a smaller heap so, for the same amount of wasted space, a higher proportion of wasted space. This makes the GC work harder, unless you relax it by increasing
Note: changing the allocation policy at run-time forces a heap compaction, which is a lengthy operation unless the heap is small (e.g. at the start of the program).
window_size : int;
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.
custom_major_ratio : int;
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.
custom_minor_ratio : int;
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.
custom_minor_max_size : int;
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.