A | |
Address [Unix_syscalls.Socket] | |
Async_print |
Non-blocking, Async-friendly print functions
|
Async_sys |
This module overrides everything in the
Sys module that might block.
|
C | |
Check_result [File_descr_watcher_intf.S] | thread_safe_check t pre ~timeout checks the file descriptors for their status and
returns when at least one is available, or the timeout passes.
|
Config [Import] | |
Core_scheduler [Raw_scheduler] | |
D | |
Debug [Import] | |
Direct [Unix_syscalls.Group.Fields] | |
Direct [Unix_syscalls.Passwd.Fields] | |
Direct [Unix_syscalls.Stats.Fields] | |
Direct [Raw_scheduler.Fields] | |
Direct [Raw_fd.T.Fields] | |
E | |
Epoll_file_descr_watcher |
Returns the underlying epoll value.
|
Exit [Unix_syscalls] | |
Exit_or_signal [Unix_syscalls] | |
Exit_or_signal_or_stop [Unix_syscalls] | |
Export [Read_write] | |
F | |
Family [Unix_syscalls.Socket] | |
Fd [Unix] | |
Fd [Std] | |
Fd [Raw_scheduler] | |
Fd |
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.
|
Fd_by_descr | Fd_by_descr is a table of the open Fd.t s, indexed by file descriptor number.
|
Fields [Unix_syscalls.Group] | |
Fields [Unix_syscalls.Passwd] | |
Fields [Unix_syscalls.Stats] | |
Fields [Raw_scheduler] | |
Fields [Raw_fd.T] | |
File_descr [Raw_fd] | |
File_descr [Import] | |
File_descr_watcher [Raw_scheduler] | |
File_descr_watcher_intf | File_descr_watcher_intf.S provides an API for for watching a set of file descriptors
to see if they are ready for reading or writing.
|
File_kind [Unix_syscalls] | |
G | |
Group [Unix_syscalls] |
Structure of entries in the
groups database.
|
H | |
Handler [Raw_signal_manager] | |
Handlers [Raw_signal_manager] | |
Helper_thread [Thread_pool] | |
Helper_thread [In_thread] | |
Host [Unix_syscalls] | |
I | |
Id [Writer] | |
Id [Reader] | |
Immutable [Read_write] | |
Import | |
In_thread [Std] | |
In_thread |
The
In_thread module has functions for interaction between the Async world and other
(kernel) threads.
|
Inet [Unix_syscalls.Socket.Address] | |
Inet_addr [Unix_syscalls] | |
Interruptor |
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.
|
Io_stats [Std] | |
Io_stats | |
K | |
Key [Read_write] | |
Kind [Raw_fd] | |
Kind [Fd] | |
M | |
Mutable [Read_write] | |
O | |
Opt [Unix_syscalls.Socket] | |
Output [Process] | wait t closes stdin t and then begins collecting the output produced on t 's
stdout and stderr , continuing to collect output until t terminates.
|
P | |
Passwd [Unix_syscalls] |
Structure of entries in the
passwd database.
|
Post [File_descr_watcher_intf] | |
Pre [File_descr_watcher_intf.S] | pre_check t does whatever non-thread-safe work is necessary to prepare for the
system call that checks file descriptors being ready for read or write.
|
Print [Std] | |
Priority [Thread_pool] | |
Priority [In_thread] | |
Process [Std] | |
Process | Async.Process is for creating child processes of the current process, and
communicating with children via their stdin, stdout, and stderr.
|
Protocol_family [Unix_syscalls] | |
R | |
Raw_fd | |
Raw_scheduler | |
Raw_signal_manager | |
Read_only [Read_write] | |
Read_result [Reader] | |
Read_write | Read_write is like Dirpair , except "buy/sell" has been changed to "read/write".
|
Reader [Std] | |
Reader | Reader is Async's main API for buffered input from a file descriptor.
|
S | |
Scheduler [Std] | |
Scheduler |
Threading model:
|
Select_file_descr_watcher | |
Shutdown [Std] | |
Shutdown | shutdown ?force status initiates shutdown, which runs all the at_shutdown
functions, waits for them to finish, and then exits with the supplied status.
|
Signal [Std] | |
Signal |
We override values from
Core.Signal that we don't want people to use with
Async.
|
Signal [Raw_signal_manager] | |
Signal [Raw_scheduler] | |
Signal_manager |
A signal manager keeps track of a set of signals to be managed and the signal handlers
for them.
|
Socket [Unix_syscalls] | |
Socket [Std] | |
State [Raw_fd] | |
Stats [Unix_syscalls] | |
Std | |
Sys [Std] | |
Syscall | |
T | |
T [Raw_fd] | |
Terminal_io [Unix_syscalls] | |
Thread_pool |
A thread pool is a set of OCaml threads used to do work, where each piece of work is
simply a thunk.
|
Thread_safe |
The
Thread_safe module has functions that are safe to call from threads outside
async.
|
Thread_safe [Std] | |
Thread_safe_pipe |
A thread-safe pipe is a thread-safe interface to the write end of a normal
Async.Pipe .
|
Thread_safe_pipe [Std] | |
Timeout [File_descr_watcher_intf] | |
Timerfd [Raw_scheduler] | |
Type [Unix_syscalls.Socket] | |
U | |
Unix [Std] | |
Unix [Unix_syscalls.Socket.Address] | |
Unix_syscalls | Unix_syscalls provides an interface to many of the functions in OCaml's standard
Unix module.
|
W | |
Watching [Raw_scheduler] | |
Watching [Raw_fd] | |
Writer | Writer is Async's main API for output to a file descriptor.
|
Writer [Std] |