Index of values

add t f adds function f to the set t.

Async supports "busy polling", which runs a thread that busy loops running user-supplied polling functions.

add_exn t fd fails if the file descriptor for fd is already in t.

add_work ?priority ?name t f enqueues f to be done by some thread in the pool.

add_work_for_helper_thread ?priority ?name t helper_thread f enqueues f on helper_thread's work queue.

am_holding_async_lock () returns true if the currently running thread is holding the async lock.

at_shutdown f causes f () to be run when shutdown is called, and for shutdown to wait until the returned deferred finishes.

bind socket addr sets close_on_exec for the fd of socket.

block_on_async f runs f () in the async world and blocks until the result becomes determined.

bytes_received t returns how many bytes have been received by the writer.

bytes_to_write t returns how many bytes have been requested to write but have not yet been written.

bytes_written t returns how many bytes have been written.

clear t causes read_fd t to become not ready for reading.

clear_nonblock t clears the ``non-blocking'' flag on t and causes and causes async to treat the fd as though it doesn't support nonblocking I/O.

close ?force_close t waits for the writer to be flushed, and then calls Unix.close on the underlying file descriptor.

close t prevents further use of t and closes t's underlying file descriptor.

close fd closes the file descriptor fd, and raises an exception if fd has already been closed.

close t prevents further use of t, and closes the underlying file descriptor once all the current uses are finished.

closed writer blocks the current thread until the pipe is closed.

consumer_left t returns a deferred that becomes determined when t attempts to write to a pipe that broke because the consumer on the other side left.

contents t returns the string corresponding to the full contents (up to EOF) of the reader.

cores () Returns the number of cores

create ~max_num_threads returns a new thread pool.

create ?buf_len ?syscall ?buffer_age_limit fd creates a new writer.

create () returns a reader end, which must be used inside async, and a writer end, which must be used outside async.

create creates and returns a signal manager t.

create ~buf_len fd creates a new reader that is reading from fd.

create ~prog ~args ?working_dir ?env () uses fork+exec to create a child process that runs the executable prog with args as arguments.

create ?name () creates a new helper thread.

create ~num_file_descrs creates a new file-descr-watcher that is able to watch file descriptors in

 [0, num_file_descrs) 

.

create kind file_descr creates a new t of the underlying kind and file descriptor.

create () creates a new empty set.

create_helper_thread ?priority ?name t creates a new helper thread.

cycle_count () returns the total number of async cycles that have happened.

cycle_start () returns the result of Time.now () called at the beginning of cycle.

cycle_times () returns a stream that will have one element for each cycle that Async runs, with the amount of time that the cycle took (as determined by calls to Time.now at the beginning and end of the cycle).

default_name t returns the name that will be used for work performed by t, unless that work is added with an overriding name

default_priority t returns the priority that will be used for work performed by t, unless that work is added with an overriding priority.

default_priority t returns the priority that will be used for work performed by t, unless that work is added with an overriding priority.

deferred () returns (d, fill) where d is a deferred that will become determined with value v once fill v is called.

don't_finish_before d causes shutdown to wait until d becomes determined before finishing.

drain t reads and ignores all data from t until it hits EOF, and then closes t.

env specifies how to construct the environment that the child process will start with.

Returns the underlying epoll value.

every_ready_to t read_write f x is like interruptible_every_ready_to, but without the possibility of interruption.

exit ?force status is shutdown ?force status; Deferred.never ().

fcntl_getfl and fcntl_setf are deferred wrappers around the corresponding functions in Core.Unix for accessing the open-file-descriptor table.

fd t

fd t

file_contents file returns the string with the full contents of the file

file_descr_exn t returns the file descriptor underlying t, unless is_closed t, in which case it raises.

file_lines file returns a list of the lines in the file.

find_local key returns the value associated to key in the current execution context.

finished_with t makes it an error to subsequently call add_work* t or create_helper_thread t.

finished_with_helper_thread t helper_thread informs thread pool t that no future work will be added for helper_thread, and makes it an error to in the future add work for helper_thread.

flushed t returns a deferred that will become determined when all prior writes complete (i.e.

force_current_cycle_to_end () causes no more normal priority jobs to run in the current cycle, and for the end-of-cycle jobs (i.e.

fork_exec ~prog ~args ?path ?env forks and execs prog with args, and returns the child pid.

Return the login name of the user executing the process.

go ?raise_unhandled_exn () passes control to Async, at which point Async starts running handlers, one by one without interruption, until there are no more handlers to run.

go_main is like go, except that one supplies a main function that will be run to initialize the async computation, and that go_main will fail if any async has been used prior to go_main being called.

handle ?stop signals ~f arranges so that whenever a signal in signals is delivered, f is called on that signal.

We override values from Core.Std.Signal that we don't want people to use with Async.

handle_delivered t runs all signal handlers on the signals that have been delivered but not yet handled.

handle_thread_pool_stuck f causes f to run whenever async detects its thread pool is stuck (i.e.

has_thread_available t returns true if t has a thread available to do work.

id t

id t

interruptible_every_ready_to t read_write ~interrupt f a enqueus a job to run f a every time the file descriptor underlying t can be read from or written to without blocking and returns a deferred that will become determined when interrupt becomes determined or the file descriptor is closed.

interruptible_ready_to t read_write ~interrupt returns a deferred that will become determined when the file descriptor underlying t can be read from or written to without blocking, or when interrupt becomes determined.

io_stats Overall IO statistics for all writers

io_stats Overall IO statistics for all readers

is_managed_by_async signal returns true iff signal is being managed by async, and hence its default behavior is no longer in effect.

is_managing t signal returns true iff manage t signal has been called

is_open t is not (is_closed t)

is_running () returns true if the scheduler has been started.

iter t ~f iterates over every file descriptor in the map, apply f to it once for each of {`Read,`Write} that it is being watched for.

kind t returns the kind of file descriptor that t is.

last_read_time t returns time of the most recent read system call that returned data.

lines t reads all the lines from t and puts them in the pipe, one line per pipe element.

127.0.0.1

(::1)

lockf fd read_or_write ?len exclusively locks for reading/writing the section of the open file fd specified by the current file position and len (see man lockf).

lseek t offset ~mode clears t's buffer and calls Unix.lseek on t's file descriptor.

manage t signal causes t to manage signal, thus overriding default_sys_behavior for that signal, and any other OCaml handler for that signal.

max_num_threads t returns the maximum number of threads that t is allowed to create.

Create a named pipe with the given permissions.

mkstemp prefix creates and opens a unique temporary file with prefix, automatically appending a suffix of six random characters to make the name unique.

monitor t returns the writer's monitor.

newline t is write_char t '\n'

num_threads t returns the number of threads that the pool t has created.

of_in_channel and of_out_channel create an fd from their underlying file descriptor.

of_in_channel_auto ic is just like of_in_channel, but uses fstat to determine the kind.

of_out_channel_auto ic is just like of_out_channel, but uses fstat to determine the kind.

of_pipe info pipe_w returns a writer t such that data written to t will appear on pipe_w.

of_pipe info pipe_r returns a reader t that receives all the data from pipe_r.

of_string_or_getbyname hostname does a DNS lookup of hostname and returns the resulting IP address.

open_file file opens file for writing and returns a writer for it.

open_file file opens file for reading and returns a reader reading from it.

pipe t returns the writing end of a pipe attached to t that pushes back when t cannot keep up with the data being pushed in.

pipe t returns the reader end of a pipe that will continually be filled with chunks of data from the underlying Reader.t.

The info supplied to pipe is debugging information that will be included in the returned Fds.

pipe_of_squeue squeue returns a pipe p and consumes the contents squeue, placing them in p.

poll t runs every function in the set t.

post_check t check_result returns the file descriptors available for read and write.

preserve_execution_context t f saves the current execution context and returns a function g such that g a runs f a in the saved execution context.

pushback writer blocks the current thread until the pipe is empty or closed.

read t ?pos ?len buf reads up to len bytes into buf, blocking until some data is available or end-of-input is reached.

read_all t read_one returns a pipe that receives all values read from t by repeatedly using read_one t.

read_bin_prot ?max_len t bp_reader reads the next binary protocol message using binary protocol reader bp_reader.

read_line t reads up to, and including the next newline (\n) character (or \r\n) and returns a freshly-allocated string containing everything up to but not including the newline character.

Like read_marshal_raw, but unmarshal the value after reading it

Read and return a buffer containing one marshaled value, but don't unmarshal it.

read_sexp t reads the next sexp.

read_sexps t reads all the sexps and returns them as a pipe.

read_substring t ss reads up to Substring.length ss bytes into ss, blocking until some data is available or Eof is reched.

read_until t pred ~keep_delim reads until it hits a delimiter c such that:

just like read_until, except you have the option of specifiying a maximum number of chars to read.

ready_fold t ~init ~f folds f over t, handling EWOULDBLOCK/EAGAIN and EINTR by retrying when ready.

ready_to t read_write is like interruptible_ready_to, but without the possibility of interruption.

really_read t buf ?pos ?len reads until it fills len bytes of buf starting at pos or runs out of input.

really_read_line ~wait_time t reads up to, and including the next newline (\n) character and returns an optional, freshly-allocated string containing everything up to but not including the newline character.

recv t returns a string that was written with Writer.send

remove_handler handler causes the particular handler to no longer handle the signals it was registered to handle.

replace t kind is for internal use only, by Unix_syscalls.

report_long_cycle_times ?cutoff () sets up something that will print a warning to stderr whenever there is an async cycle that is too long, as specified by cutoff, whose default is 1s.

If a process that has already created, but not started, the async scheduler would like to fork, and would like the child to have a clean async, i.e.

run creates a process and waits for it to complete.

run ?priority ?thread ?name f runs f () in another thread and returns the result as a Deferred in the Async world.

run_in_async f acquires the async lock and runs f () while holding the lock.

run_in_async_wait f is like block_on_async f, except that it must be called from a thread outside async.

run_in_async_with_optional_cycle f acquires the async lock and runs f () while holding the lock.

run_lines is like run but returns the lines of stdout as a string list, using String.split_lines.

save_lines file lines writes all lines in lines to file, with each line followed by a newline.

save_sexp t sexp writes sexp to t, followed by a newline.

Just like schedule', but doesn't require thunk to return a deferred.

Just like within', but instead of running thunk right now, adds it to the async queue to be run with other async jobs.

schedule_bigstring t bstr schedules a write of bigstring bstr.

schedule_iovec t iovec schedules a write of I/O-vector iovec.

schedule_iovecs t iovecs like Writer.schedule_iovec, but takes a whole queue iovecs of I/O-vectors as argument.

send t s writes a string to the channel that can be read back using Reader.recv

set alters the map of file descriptors being watched.

set_buffer_age_limit t buffer_age_limit replaces the existing buffer age limit with the new one.

set_check_invariants do_check sets whether async should check invariants of its internal data structures.

set_detect_invalid_access_from_thread do_check sets whether async routines should check if they are being accessed from some thread other than the thread currently holding the async lock, which is not allowed and can lead to very confusing behavior.

set_fd t fd sets the fd used by t for its underlying system calls.

set_max_inter_cycle_timeout span sets the maximum amount of time the scheduler will remain blocked (on epoll or select) between cycles.

set_max_num_jobs_per_priority_per_cycle int sets the maximum number of jobs that will be done at each priority within each async cycle.

set_raise_when_consumer_leaves t bool sets the raise_when_consumer_leaves flag of t, which determies how t responds to a write system call raising EPIPE and ECONNRESET (see create).

set_record_backtraces do_record sets whether async should keep in the execution context the history of stack backtraces (obtained via Backtrace.get) that led to the current job.

read_one_chunk_at_a_time t ~handle_chunk reads into t's internal buffer, and whenever bytes are available, applies handle_chunk to them.

shutdown ?force status initiates shutdown, which runs all the at_shutdown functions, waits for them to finish, and then exits with the supplied status.

shutting_down () reports whether we are currently shutting down, and if so, with what status.

stdin is a reader for file descriptor 0.

stdin, stdout, and stderr are wrappers around the standard Unix file descriptors.

stdout and stderr are writers for file descriptors 1 and 2.

supports_nonblock t returns true if t supports nonblocking system calls.

syscall f runs f, which should be a single system call, and returns the result, handling the restarting of interrupted system calls.

syscall t f runs Async_unix.syscall with f on the file descriptor underlying t, if is_open t, and returns `Ok or `Error according to f.

syscall_exn t f is like syscall, except it raises rather than return `Already_closed or `Error.

syscall_in_thread t f runs In_thread.syscall with f on the file descriptor underlying t, if is_open t, and returns a deferred that becomes determined with `Ok or `Error when the system call completes.

syscall_in_thread_exn is like syscall_in_thread, except it raises rather than return `Already_closed or `Error.

t () returns the async scheduler.

terminating is a list of signals that can be supplied to handle and whose default behavior is to terminate the program: alrm hup int term usr1 usr2.

lockf_is_locked fd ?len checks the lock on section of the open file fd specified by the current file position and len (see man lockf).

this_process_became_child_of_init returns a deferred that becomes determined when the current process becomes a child of init(8).

thread_safe_interrupt t causes read_fd t to become ready for reading.

to_formatter t

to_int_exn t returns the the underlying file descriptor as an int.

to_string t returns a pretty sexp of the representation of t

transfer t pipe_r f repeatedly pulls values from pipe_r, and feeds them to f, which should in turn write them to t.

transfer t pipe_w transfers data from t into pipe_w one chunk at a time (whatever is read from the underlying file descriptor without post-processing).

try_lockf fd read_or_write ?len attempts to exclusively lock for reading/writing the section of the open file fd specified by the current file position and len (see man lockf).

unlockf fd ?len unlocks the section of the open file fd specified by the current file position and len (see man lockf).

waitpid pid returns a deferred that becomes determined with the child's exit status, when the child process with process id pid exits.

when_file_exists ?poll_delay file returns a deferred that becomes determined when file exists.

with_close t f applies f to t, returns the result of f, and closes t.

with_file ~file f opens file for writing, creates a writer t, and runs f t to obtain a deferred d.

with_file file f opens files, creates a reader with it, and passes the reader to f.

with_file file ~mode ~perm ~f ?exclusive opens file, and applies f to the resulting file descriptor.

with_file_descr t f runs f on the file descriptor underlying t, if is_open t, and returns `Ok or `Error according to f.

with_file_descr_deferred t f runs f on the file descriptor underlying t, if is_open t, and returns `Ok or `Error according to f.

with_file_descr_exn is like with_file_descr except that it raises rather than return `Already_closed or `Error.

with_local key value ~f runs f right now with the binding key = value.

within is like within', but doesn't require thunk to return a deferred.

within' f ~monitor ~priority runs f () right now, with the specified block group, monitor, and priority set as specified.

within_context context f runs f () right now with the specified execution context.

within_v is like within, but allows a value to be returned by f.

write ?pos ?len t s adds a job to the writer's queue of pending writes.

write' and write transfer the element(s) into the pipe and block the current thread until the pipe is empty or closed (like Thread_safe_pipe.pushback).

write_bin_prot writes out a value using its bin_prot sizer/writer pair.

write_byte t i writes one 8-bit integer (as the single character with that code).

write_char t c writes the character

write_line t s is write t s; newline t.

Serialize data using marshal and write it to the writer

write_without_pushback' and write_without_pushback transfer the element(s) into the pipe and return immediately.