Module Async_kernel__.Limiter.Throttle

Implements a basic throttle meant to bound the number of jobs that can concurrently run. Additionally the ~burst_size and ~sustained_rate_per_sec arguments can be used to control how many jobs can be spawned in a burst, and how quickly jobs can be spawned over time. If these options are not given to create_exn they are unbounded.

concurrent_jobs_target is the desired maximum number of concurrent jobs. If the value is never changed, then this is in fact a hard upper bound. The value is mutable, however, and so may be violated temporarily if the value is reduced.

type t
include sig ... end
val sexp_of_t : t ‑> Sexplib.Sexp.t
val create_exn : concurrent_jobs_target:int ‑> continue_on_error:bool ‑> ?burst_size:int ‑> ?sustained_rate_per_sec:float ‑> unit ‑> t
val concurrent_jobs_target : t ‑> int
val num_jobs_waiting_to_start : t ‑> int
val num_jobs_running : t ‑> int
val enqueue_exn : t ‑> ?allow_immediate_run:bool ‑> ('a ‑> unit) ‑> 'a ‑> unit
val enqueue' : t ‑> ('a ‑> 'b Async_kernel.Deferred.t) ‑> 'a ‑> 'b Outcome.t Async_kernel.Deferred.t
type 'a u = t

Include Common, with the hack to remove the type parameter

include Common with type a t := a u
type _ t
val kill : _ t ‑> unit

kills t, which aborts all enqueued jobs that haven't started and all jobs enqueued in the future. If t has already been killed, then calling kill t has no effect. Note that kill does not effect currently running jobs in any way.

val is_dead : _ t ‑> bool

is_dead t returns true if t was killed, either by kill or by an unhandled exception in a job.

val to_limiter : _ t ‑> limiter

Convert to a limiter