package async_unix

This module is internal to Async. It is included in std.ml so that any code that uses Async_unix.Std does the top-level side effect in this module to assign Async_kernel.Monitor0.try_with_log_exn.

Non-blocking, Async-friendly print functions

This module overrides everything in the Sys module that might block. Functions do the same thing as their counterparts in Sys, but instead return deferreds. For a description of their semantics see the documentation for the Sys module.

A set of busy-poll functions.

Dump core if jobs are delayed, to get additional debug information when running on UNIX systems that support core dumps.

An Fd.t is a wrapper around a Unix file descriptor, with additional information about the kind of file descriptor and logic to ensure that we don't use a file descriptor that has been closed, or close a file descriptor that is in use. Since Async uses multiple threads to make read/write and other system calls on file descriptors, and Unix reuses descriptors after they are closed, Async has to be very careful that the file descriptor passed to a system call is referring to the file it intends, and not some other completely unrelated file that Unix has decided to assign to the same descriptor.

Fd_by_descr is a table of the open Fd.ts, indexed by file descriptor number.

The In_thread module has functions for interaction between the Async world and other (kernel) threads. The name is to remind us to think about threads and race conditions.

An interruptor provides a file descriptor that can be used to cause a file-descr-watcher to detect the file descriptor is ready for reading. We use an interruptor when a thread needs the Async scheduler to service a request.

Read_write is like Dirpair, except "buy/sell" has been changed to "read/write".

Reader is Async's main API for buffered input from a file descriptor. It is the analog of Core.In_channel.

Threading model:

A signal manager keeps track of a set of signals to be managed and the signal handlers for them. When a signal manager is managing a signal, it installs its own OCaml handler for that signal that records delivery of the signal. It then later, upon request, will deliver the signal to all its handlers.

Automatically retrying system calls that may be interrupted with EINTR.

A thread pool is a set of OCaml threads used to do work, where each piece of work is simply a thunk. One creates a thread pool, and then uses add_work to submit work to it. Work is done first-come-first-served by available threads in the pool. Any of the available threads in the pool could be used to do work submitted to the pool (except helper threads, see below).

The Thread_safe module has functions that are safe to call from threads outside Async.

A simple thread-safe ivar implementation.

A thread-safe pipe is a thread-safe interface to the write end of a normal Async.Pipe. All operations except for create must be called from threads outside Async. create can be called from inside or outside Async.

Unix_syscalls provides an interface to many of the functions in OCaml's standard Unix module. It uses a deferred in the return type of functions that would block. The idea is that in an Async program one does not use the standard Unix module, since in doing so one could accidentally block the whole program.