1002 lines
18 KiB
HTML
1002 lines
18 KiB
HTML
|
|
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
|
|
<HTML><HEAD><TITLE>Man page of Stdlib.Gc</TITLE>
|
|
</HEAD><BODY>
|
|
<H1>Stdlib.Gc</H1>
|
|
Section: OCaml library (3o)<BR>Updated: 2020-01-30<BR><A HREF="#index">Index</A>
|
|
<A HREF="/cgi-bin/man/man2html">Return to Main Contents</A><HR>
|
|
|
|
<A NAME="lbAB"> </A>
|
|
<H2>NAME</H2>
|
|
|
|
Stdlib.Gc - no description
|
|
<A NAME="lbAC"> </A>
|
|
<H2>Module</H2>
|
|
|
|
Module Stdlib.Gc
|
|
<A NAME="lbAD"> </A>
|
|
<H2>Documentation</H2>
|
|
|
|
<P>
|
|
Module
|
|
<B>Gc</B>
|
|
|
|
<BR> :
|
|
<B>(module Stdlib__gc)</B>
|
|
|
|
<P>
|
|
<P>
|
|
<P>
|
|
<P>
|
|
<P>
|
|
<P>
|
|
<P>
|
|
<I>type stat </I>
|
|
|
|
= {
|
|
<BR> minor_words :
|
|
<B>float</B>
|
|
|
|
; (* Number of words allocated in the minor heap since
|
|
the program was started. This number is accurate in
|
|
byte-code programs, but only an approximation in programs
|
|
compiled to native code.
|
|
<BR> *)
|
|
<BR> promoted_words :
|
|
<B>float</B>
|
|
|
|
; (* Number of words allocated in the minor heap that
|
|
survived a minor collection and were moved to the major heap
|
|
since the program was started.
|
|
<BR> *)
|
|
<BR> major_words :
|
|
<B>float</B>
|
|
|
|
; (* Number of words allocated in the major heap, including
|
|
the promoted words, since the program was started.
|
|
<BR> *)
|
|
<BR> minor_collections :
|
|
<B>int</B>
|
|
|
|
; (* Number of minor collections since the program was started.
|
|
<BR> *)
|
|
<BR> major_collections :
|
|
<B>int</B>
|
|
|
|
; (* Number of major collection cycles completed since the program
|
|
was started.
|
|
<BR> *)
|
|
<BR> heap_words :
|
|
<B>int</B>
|
|
|
|
; (* Total size of the major heap, in words.
|
|
<BR> *)
|
|
<BR> heap_chunks :
|
|
<B>int</B>
|
|
|
|
; (* Number of contiguous pieces of memory that make up the major heap.
|
|
<BR> *)
|
|
<BR> live_words :
|
|
<B>int</B>
|
|
|
|
; (* Number of words of live data in the major heap, including the header
|
|
words.
|
|
<BR> *)
|
|
<BR> live_blocks :
|
|
<B>int</B>
|
|
|
|
; (* Number of live blocks in the major heap.
|
|
<BR> *)
|
|
<BR> free_words :
|
|
<B>int</B>
|
|
|
|
; (* Number of words in the free list.
|
|
<BR> *)
|
|
<BR> free_blocks :
|
|
<B>int</B>
|
|
|
|
; (* Number of blocks in the free list.
|
|
<BR> *)
|
|
<BR> largest_free :
|
|
<B>int</B>
|
|
|
|
; (* Size (in words) of the largest block in the free list.
|
|
<BR> *)
|
|
<BR> fragments :
|
|
<B>int</B>
|
|
|
|
; (* Number of wasted words due to fragmentation. These are
|
|
1-words free blocks placed between two live blocks. They
|
|
are not available for allocation.
|
|
<BR> *)
|
|
<BR> compactions :
|
|
<B>int</B>
|
|
|
|
; (* Number of heap compactions since the program was started.
|
|
<BR> *)
|
|
<BR> top_heap_words :
|
|
<B>int</B>
|
|
|
|
; (* Maximum size reached by the major heap, in words.
|
|
<BR> *)
|
|
<BR> stack_size :
|
|
<B>int</B>
|
|
|
|
; (* Current size of the stack, in words.
|
|
<P>
|
|
<P>
|
|
<B>Since</B>
|
|
|
|
3.12.0
|
|
<BR> *)
|
|
<BR> }
|
|
<P>
|
|
<P>
|
|
The memory management counters are returned in a
|
|
<B>stat</B>
|
|
|
|
record.
|
|
<P>
|
|
The total amount of memory allocated by the program since it was started
|
|
is (in words)
|
|
<B>minor_words + major_words - promoted_words</B>
|
|
|
|
. Multiply by
|
|
the word size (4 on a 32-bit machine, 8 on a 64-bit machine) to get
|
|
the number of bytes.
|
|
<P>
|
|
<P>
|
|
<I>type control </I>
|
|
|
|
= {
|
|
<P>
|
|
<B>mutable </B>
|
|
|
|
minor_heap_size :
|
|
<B>int</B>
|
|
|
|
; (* The size (in words) of the minor heap. Changing
|
|
this parameter will trigger a minor collection. Default: 256k.
|
|
<BR> *)
|
|
<P>
|
|
<B>mutable </B>
|
|
|
|
major_heap_increment :
|
|
<B>int</B>
|
|
|
|
; (* 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.
|
|
<BR> *)
|
|
<P>
|
|
<B>mutable </B>
|
|
|
|
space_overhead :
|
|
<B>int</B>
|
|
|
|
; (* 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
|
|
<B>space_overhead</B>
|
|
|
|
is smaller.
|
|
Default: 80.
|
|
<BR> *)
|
|
<P>
|
|
<B>mutable </B>
|
|
|
|
verbose :
|
|
<B>int</B>
|
|
|
|
; (* 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:
|
|
<P>
|
|
-
|
|
<B>0x001</B>
|
|
|
|
Start of major GC cycle.
|
|
<P>
|
|
-
|
|
<B>0x002</B>
|
|
|
|
Minor collection and major GC slice.
|
|
<P>
|
|
-
|
|
<B>0x004</B>
|
|
|
|
Growing and shrinking of the heap.
|
|
<P>
|
|
-
|
|
<B>0x008</B>
|
|
|
|
Resizing of stacks and memory manager tables.
|
|
<P>
|
|
-
|
|
<B>0x010</B>
|
|
|
|
Heap compaction.
|
|
<P>
|
|
-
|
|
<B>0x020</B>
|
|
|
|
Change of GC parameters.
|
|
<P>
|
|
-
|
|
<B>0x040</B>
|
|
|
|
Computation of major GC slice size.
|
|
<P>
|
|
-
|
|
<B>0x080</B>
|
|
|
|
Calling of finalisation functions.
|
|
<P>
|
|
-
|
|
<B>0x100</B>
|
|
|
|
Bytecode executable and shared library search at start-up.
|
|
<P>
|
|
-
|
|
<B>0x200</B>
|
|
|
|
Computation of compaction-triggering condition.
|
|
<P>
|
|
-
|
|
<B>0x400</B>
|
|
|
|
Output GC statistics at program exit.
|
|
Default: 0.
|
|
<P>
|
|
<BR> *)
|
|
<P>
|
|
<B>mutable </B>
|
|
|
|
max_overhead :
|
|
<B>int</B>
|
|
|
|
; (* Heap compaction is triggered when the estimated amount
|
|
of "wasted" memory is more than
|
|
<B>max_overhead</B>
|
|
|
|
percent of the
|
|
amount of live data. If
|
|
<B>max_overhead</B>
|
|
|
|
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
|
|
<B>max_overhead >= 1000000</B>
|
|
|
|
, compaction is never triggered.
|
|
If compaction is permanently disabled, it is strongly suggested
|
|
to set
|
|
<B>allocation_policy</B>
|
|
|
|
to 1.
|
|
Default: 500.
|
|
<BR> *)
|
|
<P>
|
|
<B>mutable </B>
|
|
|
|
stack_limit :
|
|
<B>int</B>
|
|
|
|
; (* 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.
|
|
<BR> *)
|
|
<P>
|
|
<B>mutable </B>
|
|
|
|
allocation_policy :
|
|
<B>int</B>
|
|
|
|
; (* 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.
|
|
<P>
|
|
<P>
|
|
<B>Since</B>
|
|
|
|
3.11.0
|
|
<BR> *)
|
|
<BR> window_size :
|
|
<B>int</B>
|
|
|
|
; (* 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.
|
|
<P>
|
|
<P>
|
|
<B>Since</B>
|
|
|
|
4.03.0
|
|
<BR> *)
|
|
<BR> custom_major_ratio :
|
|
<B>int</B>
|
|
|
|
; (* 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
|
|
<B>caml_alloc_custom_mem</B>
|
|
|
|
(e.g. bigarrays).
|
|
Default: 44.
|
|
<P>
|
|
<P>
|
|
<B>Since</B>
|
|
|
|
4.08.0
|
|
<BR> *)
|
|
<BR> custom_minor_ratio :
|
|
<B>int</B>
|
|
|
|
; (* 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
|
|
<B>caml_alloc_custom_mem</B>
|
|
|
|
(e.g. bigarrays).
|
|
Default: 100.
|
|
<P>
|
|
<P>
|
|
<B>Since</B>
|
|
|
|
4.08.0
|
|
<BR> *)
|
|
<BR> custom_minor_max_size :
|
|
<B>int</B>
|
|
|
|
; (* 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
|
|
<B>custom_minor_ratio</B>
|
|
|
|
and the
|
|
rest is directly counted against
|
|
<B>custom_major_ratio</B>
|
|
|
|
.
|
|
Note: this only applies to values allocated with
|
|
<B>caml_alloc_custom_mem</B>
|
|
|
|
(e.g. bigarrays).
|
|
Default: 8192 bytes.
|
|
<P>
|
|
<P>
|
|
<B>Since</B>
|
|
|
|
4.08.0
|
|
<BR> *)
|
|
<BR> }
|
|
<P>
|
|
<P>
|
|
The GC parameters are given as a
|
|
<B>control</B>
|
|
|
|
record. Note that
|
|
these parameters can also be initialised by setting the
|
|
OCAMLRUNPARAM environment variable. See the documentation of
|
|
<B>ocamlrun</B>
|
|
|
|
.
|
|
<P>
|
|
<P>
|
|
<P>
|
|
<I>val stat </I>
|
|
|
|
:
|
|
<B>unit -> stat</B>
|
|
|
|
<P>
|
|
Return the current values of the memory management counters in a
|
|
<B>stat</B>
|
|
|
|
record. This function examines every heap block to get the
|
|
statistics.
|
|
<P>
|
|
<P>
|
|
<P>
|
|
<I>val quick_stat </I>
|
|
|
|
:
|
|
<B>unit -> stat</B>
|
|
|
|
<P>
|
|
Same as
|
|
<B>stat</B>
|
|
|
|
except that
|
|
<B>live_words</B>
|
|
|
|
,
|
|
<B>live_blocks</B>
|
|
|
|
,
|
|
<B>free_words</B>
|
|
|
|
,
|
|
<B>free_blocks</B>
|
|
|
|
,
|
|
<B>largest_free</B>
|
|
|
|
, and
|
|
<B>fragments</B>
|
|
|
|
are set to 0. This
|
|
function is much faster than
|
|
<B>stat</B>
|
|
|
|
because it does not need to go
|
|
through the heap.
|
|
<P>
|
|
<P>
|
|
<P>
|
|
<I>val counters </I>
|
|
|
|
:
|
|
<B>unit -> float * float * float</B>
|
|
|
|
<P>
|
|
Return
|
|
<B>(minor_words, promoted_words, major_words)</B>
|
|
|
|
. This function
|
|
is as fast as
|
|
<B>quick_stat</B>
|
|
|
|
.
|
|
<P>
|
|
<P>
|
|
<P>
|
|
<I>val minor_words </I>
|
|
|
|
:
|
|
<B>unit -> float</B>
|
|
|
|
<P>
|
|
Number of words allocated in the minor heap since the program was
|
|
started. This number is accurate in byte-code programs, but only an
|
|
approximation in programs compiled to native code.
|
|
<P>
|
|
In native code this function does not allocate.
|
|
<P>
|
|
<P>
|
|
<B>Since</B>
|
|
|
|
4.04
|
|
<P>
|
|
<P>
|
|
<P>
|
|
<I>val get </I>
|
|
|
|
:
|
|
<B>unit -> control</B>
|
|
|
|
<P>
|
|
Return the current values of the GC parameters in a
|
|
<B>control</B>
|
|
|
|
record.
|
|
<P>
|
|
<P>
|
|
<P>
|
|
<I>val set </I>
|
|
|
|
:
|
|
<B>control -> unit</B>
|
|
|
|
<P>
|
|
<P>
|
|
<B>set r</B>
|
|
|
|
changes the GC parameters according to the
|
|
<B>control</B>
|
|
|
|
record
|
|
<B>r</B>
|
|
|
|
.
|
|
The normal usage is:
|
|
<B>Gc.set { (Gc.get()) with Gc.verbose = 0x00d }</B>
|
|
|
|
<P>
|
|
<P>
|
|
<P>
|
|
<P>
|
|
<I>val minor </I>
|
|
|
|
:
|
|
<B>unit -> unit</B>
|
|
|
|
<P>
|
|
Trigger a minor collection.
|
|
<P>
|
|
<P>
|
|
<P>
|
|
<I>val major_slice </I>
|
|
|
|
:
|
|
<B>int -> int</B>
|
|
|
|
<P>
|
|
<P>
|
|
<B>major_slice n</B>
|
|
|
|
Do a minor collection and a slice of major collection.
|
|
<B>n</B>
|
|
|
|
is the
|
|
size of the slice: the GC will do enough work to free (on average)
|
|
<B>n</B>
|
|
|
|
words of memory. If
|
|
<B>n</B>
|
|
|
|
= 0, the GC will try to do enough work
|
|
to ensure that the next automatic slice has no work to do.
|
|
This function returns an unspecified integer (currently: 0).
|
|
<P>
|
|
<P>
|
|
<P>
|
|
<I>val major </I>
|
|
|
|
:
|
|
<B>unit -> unit</B>
|
|
|
|
<P>
|
|
Do a minor collection and finish the current major collection cycle.
|
|
<P>
|
|
<P>
|
|
<P>
|
|
<I>val full_major </I>
|
|
|
|
:
|
|
<B>unit -> unit</B>
|
|
|
|
<P>
|
|
Do a minor collection, finish the current major collection cycle,
|
|
and perform a complete new cycle. This will collect all currently
|
|
unreachable blocks.
|
|
<P>
|
|
<P>
|
|
<P>
|
|
<I>val compact </I>
|
|
|
|
:
|
|
<B>unit -> unit</B>
|
|
|
|
<P>
|
|
Perform a full major collection and compact the heap. Note that heap
|
|
compaction is a lengthy operation.
|
|
<P>
|
|
<P>
|
|
<P>
|
|
<I>val print_stat </I>
|
|
|
|
:
|
|
<B>out_channel -> unit</B>
|
|
|
|
<P>
|
|
Print the current values of the memory management counters (in
|
|
human-readable form) into the channel argument.
|
|
<P>
|
|
<P>
|
|
<P>
|
|
<I>val allocated_bytes </I>
|
|
|
|
:
|
|
<B>unit -> float</B>
|
|
|
|
<P>
|
|
Return the total number of bytes allocated since the program was
|
|
started. It is returned as a
|
|
<B>float</B>
|
|
|
|
to avoid overflow problems
|
|
with
|
|
<B>int</B>
|
|
|
|
on 32-bit machines.
|
|
<P>
|
|
<P>
|
|
<P>
|
|
<I>val get_minor_free </I>
|
|
|
|
:
|
|
<B>unit -> int</B>
|
|
|
|
<P>
|
|
Return the current size of the free space inside the minor heap.
|
|
<P>
|
|
<P>
|
|
<B>Since</B>
|
|
|
|
4.03.0
|
|
<P>
|
|
<P>
|
|
<P>
|
|
<I>val get_bucket </I>
|
|
|
|
:
|
|
<B>int -> int</B>
|
|
|
|
<P>
|
|
<P>
|
|
<B>get_bucket n</B>
|
|
|
|
returns the current size of the
|
|
<B>n</B>
|
|
|
|
-th future bucket
|
|
of the GC smoothing system. The unit is one millionth of a full GC.
|
|
Raise
|
|
<B>Invalid_argument</B>
|
|
|
|
if
|
|
<B>n</B>
|
|
|
|
is negative, return 0 if n is larger
|
|
than the smoothing window.
|
|
<P>
|
|
<P>
|
|
<B>Since</B>
|
|
|
|
4.03.0
|
|
<P>
|
|
<P>
|
|
<P>
|
|
<I>val get_credit </I>
|
|
|
|
:
|
|
<B>unit -> int</B>
|
|
|
|
<P>
|
|
<P>
|
|
<B>get_credit ()</B>
|
|
|
|
returns the current size of the "work done in advance"
|
|
counter of the GC smoothing system. The unit is one millionth of a
|
|
full GC.
|
|
<P>
|
|
<P>
|
|
<B>Since</B>
|
|
|
|
4.03.0
|
|
<P>
|
|
<P>
|
|
<P>
|
|
<I>val huge_fallback_count </I>
|
|
|
|
:
|
|
<B>unit -> int</B>
|
|
|
|
<P>
|
|
Return the number of times we tried to map huge pages and had to fall
|
|
back to small pages. This is always 0 if
|
|
<B>OCAMLRUNPARAM</B>
|
|
|
|
contains
|
|
<B>H=1</B>
|
|
|
|
.
|
|
<P>
|
|
<P>
|
|
<B>Since</B>
|
|
|
|
4.03.0
|
|
<P>
|
|
<P>
|
|
<P>
|
|
<I>val finalise </I>
|
|
|
|
:
|
|
<B>('a -> unit) -> 'a -> unit</B>
|
|
|
|
<P>
|
|
<P>
|
|
<B>finalise f v</B>
|
|
|
|
registers
|
|
<B>f</B>
|
|
|
|
as a finalisation function for
|
|
<B>v</B>
|
|
|
|
.
|
|
<B>v</B>
|
|
|
|
must be heap-allocated.
|
|
<B>f</B>
|
|
|
|
will be called with
|
|
<B>v</B>
|
|
|
|
as
|
|
argument at some point between the first time
|
|
<B>v</B>
|
|
|
|
becomes unreachable
|
|
(including through weak pointers) and the time
|
|
<B>v</B>
|
|
|
|
is collected by
|
|
the GC. Several functions can
|
|
be registered for the same value, or even several instances of the
|
|
same function. Each instance will be called once (or never,
|
|
if the program terminates before
|
|
<B>v</B>
|
|
|
|
becomes unreachable).
|
|
<P>
|
|
The GC will call the finalisation functions in the order of
|
|
deallocation. When several values become unreachable at the
|
|
same time (i.e. during the same GC cycle), the finalisation
|
|
functions will be called in the reverse order of the corresponding
|
|
calls to
|
|
<B>finalise</B>
|
|
|
|
. If
|
|
<B>finalise</B>
|
|
|
|
is called in the same order
|
|
as the values are allocated, that means each value is finalised
|
|
before the values it depends upon. Of course, this becomes
|
|
false if additional dependencies are introduced by assignments.
|
|
<P>
|
|
In the presence of multiple OCaml threads it should be assumed that
|
|
any particular finaliser may be executed in any of the threads.
|
|
<P>
|
|
Anything reachable from the closure of finalisation functions
|
|
is considered reachable, so the following code will not work
|
|
as expected:
|
|
<P>
|
|
-
|
|
<B>let v = ... in Gc.finalise (fun _ -> ...v...) v </B>
|
|
|
|
<P>
|
|
Instead you should make sure that
|
|
<B>v</B>
|
|
|
|
is not in the closure of
|
|
the finalisation function by writing:
|
|
<P>
|
|
-
|
|
<B>let f = fun x -> ... let v = ... in Gc.finalise f v </B>
|
|
|
|
<P>
|
|
The
|
|
<B>f</B>
|
|
|
|
function can use all features of OCaml, including
|
|
assignments that make the value reachable again. It can also
|
|
loop forever (in this case, the other
|
|
finalisation functions will not be called during the execution of f,
|
|
unless it calls
|
|
<B>finalise_release</B>
|
|
|
|
).
|
|
It can call
|
|
<B>finalise</B>
|
|
|
|
on
|
|
<B>v</B>
|
|
|
|
or other values to register other
|
|
functions or even itself. It can raise an exception; in this case
|
|
the exception will interrupt whatever the program was doing when
|
|
the function was called.
|
|
<P>
|
|
<P>
|
|
<B>finalise</B>
|
|
|
|
will raise
|
|
<B>Invalid_argument</B>
|
|
|
|
if
|
|
<B>v</B>
|
|
|
|
is not
|
|
guaranteed to be heap-allocated. Some examples of values that are not
|
|
heap-allocated are integers, constant constructors, booleans,
|
|
the empty array, the empty list, the unit value. The exact list
|
|
of what is heap-allocated or not is implementation-dependent.
|
|
Some constant values can be heap-allocated but never deallocated
|
|
during the lifetime of the program, for example a list of integer
|
|
constants; this is also implementation-dependent.
|
|
Note that values of types
|
|
<B>float</B>
|
|
|
|
are sometimes allocated and
|
|
sometimes not, so finalising them is unsafe, and
|
|
<B>finalise</B>
|
|
|
|
will
|
|
also raise
|
|
<B>Invalid_argument</B>
|
|
|
|
for them. Values of type
|
|
<B>'a Lazy.t</B>
|
|
|
|
(for any
|
|
<B>'a</B>
|
|
|
|
) are like
|
|
<B>float</B>
|
|
|
|
in this respect, except that the
|
|
compiler sometimes optimizes them in a way that prevents
|
|
<B>finalise</B>
|
|
|
|
from detecting them. In this case, it will not raise
|
|
<B>Invalid_argument</B>
|
|
|
|
, but you should still avoid calling
|
|
<B>finalise</B>
|
|
|
|
on lazy values.
|
|
<P>
|
|
The results of calling
|
|
<B>String.make</B>
|
|
|
|
,
|
|
<B>Bytes.make</B>
|
|
|
|
,
|
|
<B>Bytes.create</B>
|
|
|
|
,
|
|
<B>Array.make</B>
|
|
|
|
, and
|
|
<B>ref</B>
|
|
|
|
are guaranteed to be
|
|
heap-allocated and non-constant except when the length argument is
|
|
<B>0</B>
|
|
|
|
.
|
|
<P>
|
|
<P>
|
|
<P>
|
|
<I>val finalise_last </I>
|
|
|
|
:
|
|
<B>(unit -> unit) -> 'a -> unit</B>
|
|
|
|
<P>
|
|
same as
|
|
<B>Gc.finalise</B>
|
|
|
|
except the value is not given as argument. So
|
|
you can't use the given value for the computation of the
|
|
finalisation function. The benefit is that the function is called
|
|
after the value is unreachable for the last time instead of the
|
|
first time. So contrary to
|
|
<B>Gc.finalise</B>
|
|
|
|
the value will never be
|
|
reachable again or used again. In particular every weak pointer
|
|
and ephemeron that contained this value as key or data is unset
|
|
before running the finalisation function. Moreover the finalisation
|
|
functions attached with
|
|
<B>Gc.finalise</B>
|
|
|
|
are always called before the
|
|
finalisation functions attached with
|
|
<B>Gc.finalise_last</B>
|
|
|
|
.
|
|
<P>
|
|
<P>
|
|
<B>Since</B>
|
|
|
|
4.04
|
|
<P>
|
|
<P>
|
|
<P>
|
|
<I>val finalise_release </I>
|
|
|
|
:
|
|
<B>unit -> unit</B>
|
|
|
|
<P>
|
|
A finalisation function may call
|
|
<B>finalise_release</B>
|
|
|
|
to tell the
|
|
GC that it can launch the next finalisation function without waiting
|
|
for the current one to return.
|
|
<P>
|
|
<P>
|
|
<I>type alarm </I>
|
|
|
|
<P>
|
|
<P>
|
|
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.
|
|
<P>
|
|
<P>
|
|
<P>
|
|
<I>val create_alarm </I>
|
|
|
|
:
|
|
<B>(unit -> unit) -> alarm</B>
|
|
|
|
<P>
|
|
<P>
|
|
<B>create_alarm f</B>
|
|
|
|
will arrange for
|
|
<B>f</B>
|
|
|
|
to be called at the end of each
|
|
major GC cycle, starting with the current cycle or the next one.
|
|
A value of type
|
|
<B>alarm</B>
|
|
|
|
is returned that you can
|
|
use to call
|
|
<B>delete_alarm</B>
|
|
|
|
.
|
|
<P>
|
|
<P>
|
|
<P>
|
|
<I>val delete_alarm </I>
|
|
|
|
:
|
|
<B>alarm -> unit</B>
|
|
|
|
<P>
|
|
<P>
|
|
<B>delete_alarm a</B>
|
|
|
|
will stop the calls to the function associated
|
|
to
|
|
<B>a</B>
|
|
|
|
. Calling
|
|
<B>delete_alarm a</B>
|
|
|
|
again has no effect.
|
|
<P>
|
|
<P>
|
|
<P>
|
|
|
|
<HR>
|
|
<A NAME="index"> </A><H2>Index</H2>
|
|
<DL>
|
|
<DT id="1"><A HREF="#lbAB">NAME</A><DD>
|
|
<DT id="2"><A HREF="#lbAC">Module</A><DD>
|
|
<DT id="3"><A HREF="#lbAD">Documentation</A><DD>
|
|
</DL>
|
|
<HR>
|
|
This document was created by
|
|
<A HREF="/cgi-bin/man/man2html">man2html</A>,
|
|
using the manual pages.<BR>
|
|
Time: 00:05:57 GMT, March 31, 2021
|
|
</BODY>
|
|
</HTML>
|