# Module Stdlib.Domain

    module Domain: Domain

- Alert unstable. The Domain interface may change in incompatible ways in the future.

    type !'a t

A domain of type `'a t` runs independently, eventually producing a result of type 'a, or an exception

    val spawn : (unit -> 'a) -> 'a t

`spawn f` creates a new domain that runs in parallel with the current domain.

- Raises `Failure` if the program has insufficient resources to create another domain.

    val join : 'a t -> 'a

`join d` blocks until domain `d` runs to completion. If `d` results in a value, then that is returned by `join d`. If `d` raises an uncaught exception, then that is re-raised by `join d`.

If the domain has created any systhreads (via `Thread.create`), then it tries to join those systhreads (same as calling `Thread.join`) before returning.

    type id = private int

Domains have unique integer identifiers

    val get_id : 'a t -> id

`get_id d` returns the identifier of the domain `d`

    val self : unit -> id

`self ()` is the identifier of the currently running domain

    val before_first_spawn : (unit -> unit) -> unit

`before_first_spawn f` registers `f` to be called before the first domain is spawned by the program. The functions registered with `before_first_spawn` are called on the main (initial) domain. The functions registered with `before_first_spawn` are called in 'first in, first out' order: the oldest function added with `before_first_spawn` is called first.

- Raises `Invalid_argument` if the program has already spawned a domain.

    val at_exit : (unit -> unit) -> unit

`at_exit f` registers `f` to be called when the current domain exits. Note that `at_exit` callbacks are domain-local and only apply to the calling domain. The registered functions are called in 'last in, first out' order: the function most recently added with `at_exit` is called first. An example:

    let temp_file_key = Domain.DLS.new_key (fun _ ->
      let tmp = snd (Filename.open_temp_file "" "") in
      Domain.at_exit (fun () -> close_out_noerr tmp);
      tmp)

The snippet above creates a key that when retrieved for the first time will open a temporary file and register an `at_exit` callback to close it, thus guaranteeing the descriptor is not leaked in case the current domain exits.

    val cpu_relax : unit -> unit

If busy-waiting, calling cpu_relax () between iterations will improve performance on some CPU architectures

    val is_main_domain : unit -> bool

`is_main_domain ()` returns true if called from the initial domain.

    val count : unit -> int

The number of domains that have been spawned (including the initial domain) and have not yet terminated.

- Since 5.5

    val recommended_domain_count : unit -> int

The recommended maximum number of domains which should be running simultaneously (including domains already running).

The value returned is at least `1`.

    val self_index : unit -> int

The index of the current domain. It is an integer unique among currently-running domains, in the interval `0; N-1` where N is the peak number of domains running simultaneously so far.

The index of a terminated domain may be reused for a new domain. Use `(Domain.self () :> int)` instead for an identifier unique among all domains ever created by the program.

- Since 5.3

    module DLS: sig .. end