mirror of
https://github.com/c-cube/moonpool.git
synced 2025-12-12 14:00:41 -05:00
76ca0f2d88
futures, chans, etc. should use the `Runner.t` abstraction and not depend on the exact pool implementation to run tasks. For now `Pool.create` is the only implementation of a runner, but now it's possible to implement alternatives.
64 lines
1.9 KiB
OCaml
64 lines
1.9 KiB
OCaml
(** Abstract runner.
|
|
|
|
This provides an abstraction for running tasks in the background.
|
|
@since NEXT_RELEASE
|
|
*)
|
|
|
|
type task = unit -> unit
|
|
|
|
type t = private {
|
|
run_async: task -> unit;
|
|
shutdown: wait:bool -> unit -> unit;
|
|
size: unit -> int;
|
|
num_tasks: unit -> int;
|
|
}
|
|
(** A runner.
|
|
|
|
If a runner is no longer needed, {!shutdown} can be used to signal all
|
|
worker threads
|
|
in it to stop (after they finish their work), and wait for them to stop.
|
|
|
|
The threads are distributed across a fixed domain pool
|
|
(whose size is determined by {!Domain.recommended_domain_count} on OCaml 5, and
|
|
simple the single runtime on OCaml 4). *)
|
|
|
|
val size : t -> int
|
|
(** Number of threads/workers. *)
|
|
|
|
val num_tasks : t -> int
|
|
(** Current number of tasks. This is at best a snapshot, useful for metrics
|
|
and debugging. *)
|
|
|
|
val shutdown : t -> unit
|
|
(** Shutdown the runner and wait for it to terminate. Idempotent. *)
|
|
|
|
val shutdown_without_waiting : t -> unit
|
|
(** Shutdown the pool, and do not wait for it to terminate. Idempotent. *)
|
|
|
|
exception Shutdown
|
|
|
|
val run_async : t -> task -> unit
|
|
(** [run_async pool f] schedules [f] for later execution on the runner
|
|
in one of the threads. [f()] will run on one of the runner's
|
|
worker threads/domains.
|
|
@raise Shutdown if the runner was shut down before [run_async] was called. *)
|
|
|
|
val run_wait_block : t -> (unit -> 'a) -> 'a
|
|
(** [run_wait_block pool f] schedules [f] for later execution
|
|
on the pool, like {!run_async}.
|
|
It then blocks the current thread until [f()] is done executing,
|
|
and returns its result. If [f()] raises an exception, then [run_wait_block pool f]
|
|
will raise it as well.
|
|
|
|
{b NOTE} be careful with deadlocks (see notes in {!Fut.wait_block}). *)
|
|
|
|
module For_runner_implementors : sig
|
|
val create :
|
|
size:(unit -> int) ->
|
|
num_tasks:(unit -> int) ->
|
|
shutdown:(wait:bool -> unit -> unit) ->
|
|
run_async:(task -> unit) ->
|
|
unit ->
|
|
t
|
|
(** Create a new runner. *)
|
|
end
|