package eio

You can search for identifiers within the package.

in-package search v0.2.0

eio
- Eio
  - Buf_read
    
    BE
    
    LE
    
    Syntax
  - Buf_write
    
    BE
    
    LE
  - Cancel
  - Condition
  - Debug
  - Domain_manager
    
    Pi
    
    MGR
  - Executor_pool
  - Exn
    
    Backend
  - Fiber
    
    List
  - File
    
    Pi
    
    READ
    
    WRITE
    
    Stat
    
    Unix_perm
  - Flow
    
    Pi
    
    SHUTDOWN
    
    SINK
    
    SOURCE
    
    TWO_WAY
  - Fs
    
    Pi
    
    DIR
  - Lazy
  - Mutex
  - Net
    
    Ipaddr
    
    V4
    
    V6
    
    Pi
    
    DATAGRAM_SOCKET
    
    LISTENING_SOCKET
    
    NETWORK
    
    STREAM_SOCKET
    
    Sockaddr
  - Path
  - Pool
  - Private
    
    Broadcast
    
    Cells
    
    CELL
    
    Make
    
    Cell
    
    Debug
    
    Dla
    
    Effects
    
    Fiber_context
    
    Suspend
    
    Trace
  - Process
    
    Pi
    
    MGR
    
    PROCESS
  - Promise
  - Resource
  - Semaphore
  - Std
  - Stdenv
  - Stream
  - Switch
  - Time
    
    Mono
    
    Pi
    
    CLOCK
    
    Timeout
eio.mock
- Eio_mock
  - Action
  - Backend
  - Clock
    
    Mono
    
    S
  - Domain_manager
  - Flow
  - Handler
  - Net
eio.runtime_events
- Eio_runtime_events
eio.unix
- Eio_unix
  - Fd
  - Net
    
    Ipaddr
  - Pi
    
    DATAGRAM_SOCKET
    
    FLOW
    
    LISTENING_SOCKET
    
    STREAM_SOCKET
  - Private
    
    Rcfd
    
    Thread_pool
  - Process
    
    Make_mgr
    
    X
    
    Pi
    
    MGR
  - Resource
  - Stdenv
eio.utils
- Eio_utils
  - Lf_queue
  - Suspended
  - Zzz
    
    Key

Legend:
Library
Module
Module type
Parameter
Class
Class type

A pool of domains for executing jobs.

An executor pool distributes jobs (functions to execute) among a pool of domain workers (threads).

Domains are reused and can execute multiple jobs concurrently. Jobs are queued up if they cannot be started immediately due to all workers being busy.

Eio.Executor_pool is the recommended way of leveraging OCaml 5's multicore capabilities. It is built on top of the low level Eio.Domain_manager.

Usually you will only want one pool for an entire application, so the pool is typically created when the application starts:

let () =
  Eio_main.run @@ fun env ->
  Switch.run @@ fun sw ->
  let pool =
    Eio.Executor_pool.create
      ~sw (Eio.Stdenv.domain_mgr env)
      ~domain_count:4
  in
  main ~pool

The pool starts its domain workers (threads) immediately upon creation.

type t

An executor pool.

val create : sw:Switch.t -> domain_count:int -> _ Domain_manager.t -> t

create ~sw ~domain_count dm creates a new executor pool.

The executor pool will not block switch sw from completing; when the switch finishes, all domain workers and running jobs are cancelled.

parameter domain_count
The number of domain workers to create. The total number of domains should not exceed Domain.recommended_domain_count or the number of cores on your system. Additionally, consider reducing this number by 1 if your original domain will be performing CPU intensive work at the same time as the Executor_pool.

val submit : t -> weight:float -> (unit -> 'a) -> ('a, exn) Stdlib.result

submit t ~weight fn runs fn () using this executor pool.

The job is added to the back of the queue.

parameter weight
This value represents the anticipated proportion of a CPU core used by the job. This value must be >= 0.0 and <= 1.0; Example: given an IO-bound job that averages 2% of a CPU core, pass ~weight:0.02. Each domain worker starts new jobs until the total ~weight of its running jobs reaches 1.0

val submit_exn : t -> weight:float -> (unit -> 'a) -> 'a

Same as submit but raises if the job fails.

val submit_fork : 
  sw:Switch.t ->
  t ->
  weight:float ->
  (unit -> 'a) ->
  'a Promise.or_exn

Same as submit but returns immediately, without blocking.