package uwt

You can search for identifiers within the package.

in-package search v0.2.0

package uwt

uwt.async
- Uwt
  - Async
  - C_worker
  - Conv
  - Debug
  - Dns
  - Fs
  - Fs_event
  - Fs_functions
  - Fs_poll
  - Fs_types
  - Handle
  - Handle_ext
  - Handle_fileno
  - Int_result
  - Iovec_write
  - Main
  - Misc
  - Pipe
  - Poll
  - Process
  - Signal
  - Stream
  - Sys_info
  - Tcp
  - Timer
  - Tty
  - Udp
  - Unix
uwt.base
- Uwt_base
  - Conv
  - Fs_functions
  - Fs_types
  - Int_result
  - Iovec_write
  - Misc
  - Sys_info
- Uwt_bytes
uwt.compat
- Uwt_compat
  - Lwt_unix
    
    LargeFile
uwt.ext
- Uwt_chan
- Uwt_io
  - BE
  - LE
  - NumberIO
- Uwt_log
  - Section
- Uwt_process
- Uwt_throttle
  - Make
  - S
- Uwt_timeout
uwt.preemptive
- Uwt_preemptive
uwt.sync
- Uv_fs_sync

Legend:
Library
Module
Module type
Parameter
Class
Class type

Async handles allow the user to "wakeup" the event loop and get a callback called from another (system) thread.

type t

include module type of Handle with type t := t

val close : t -> Int_result.unit

Handles are closed automatically, if they are not longer referenced from the OCaml heap. Nevertheless, you should nearly always close them with close, because:

if they wrap a file descriptor, you will sooner or later run out of file descriptors. The OCaml garbage collector doesn't give any guarantee, when orphaned memory blocks are removed.

you might have registered some repeatedly called action (e.g. timeout, read_start,...), that prevent that all references get removed from the OCaml heap.

However, it's safe to write code in this manner:

let s = Uwt.Tcp.init () in
let c = Uwt.Tcp.init () in
Uwt.Tcp.nodelay s false;
Uwt.Tcp.simultaneous_accepts true;
if foobar () then (* no file descriptor yet assigned, no need to worry
                     about exceptions inside foobar,... *)
  Lwt.return_unit (* no need to close *)
else
  ...

If you want - for whatever reason - keep a file descriptor open for the whole lifetime of your process, remember to keep a reference to its handle.

val close_noerr : t -> unit

val close_wait : t -> unit Lwt.t

Prefer close or close_noerr to close_wait. close or close_noerr return immediately (there are no useful error messages, beside perhaps a notice, that you've already closed that handle).

close_wait is only useful, if you intend to wait until all concurrent write and read threads related to this handle are canceled.

val is_active : t -> bool

Returns non-zero if the handle is active, zero if it's inactive. What "active" means depends on the type of handle:

A Async.t handle is always active and cannot be deactivated, except by closing it with uv_close().

A Pipe.t, Tcp.t, Udp.t, etc. handle - basically any handle that deals with i/o - is active when it is doing something that involves i/o, like reading, writing, connecting, accepting new connections, etc.

Rule of thumb: if a handle of type Uwt.Foo.t has a uv_foo_start() function, then it's active from the moment that function is called. Likewise, uv_foo_stop() deactivates the handle again.

val ref' : t -> unit

Reference the given handle. References are idempotent, that is, if a handle is already referenced calling this function again will have no effect.

val unref : t -> unit

Un-reference the given handle. References are idempotent, that is, if a handle is not referenced calling this function again will have no effect.

val has_ref : t -> bool

Returns non-zero if the handle is referenced, zero otherwise.

val to_handle : t -> Handle.t

val create : (t -> unit) -> t uv_result

Creates a new async handle. The handle is not active immediately. You have to use start

val start : t -> Int_result.unit

This will increase the reference count of the async handle. Main.run will wait until send is called, if there are no other pendings tasks.

val stop : t -> Int_result.unit

Decrease the reference count again

val send : t -> Int_result.unit

Wakeup the event loop and call the async handle's callback.

It's safe to call this function from any system thread. The callback will be called on the loop thread. create, start, and stop however must be called from the main thread.

Warning: libuv will coalesce calls to send, that is, not every call to it will yield an execution of the callback. For example: if send is called 5 times in a row before the callback is called, the callback will only be called once. If send is called again after the callback was called, it will be called again.