async_kernel v0.15.0 · OCaml Package

val events : {t}7 -> Async_kernel__Types.Job_or_event.t Timing_wheel.t

val set_execution_context : 
  {t}7 ->
  Async_kernel__Types.Execution_context.t ->
  unit

module Synchronous_time_source : sig ... end

module Event : sig ... end

module Alarm = Timing_wheel.Alarm

module Job_or_event : sig ... end

val debug : bool

module Ivar : sig ... end

module Bvar : sig ... end

module Very_low_priority_worker : sig ... end

type t = {

mutable check_access : (unit -> unit) option;
mutable job_pool : (Execution_context.t, Stdlib.Obj.t -> unit, Stdlib.Obj.t) Tuple_pool.Slots.t3 Tuple_pool.t;
normal_priority_jobs : Async_kernel__.Types.Job_queue.t;
low_priority_jobs : Async_kernel__.Types.Job_queue.t;
very_low_priority_workers : Very_low_priority_worker.t Core.Deque.t;
mutable main_execution_context : Execution_context.t;
mutable current_execution_context : Execution_context.t;
mutable uncaught_exn : (Core.Exn.t * Core.Sexp.t) option;
mutable cycle_count : int;
mutable cycle_start : Core.Time_ns.t;
mutable in_cycle : bool;
mutable run_every_cycle_start : (unit -> unit) list;
run_every_cycle_start_state : (Async_kernel__.Types.Cycle_hook_handle.t, unit -> unit) Core.Hashtbl.t;
mutable run_every_cycle_end : (unit -> unit) list;
run_every_cycle_end_state : (Async_kernel__.Types.Cycle_hook_handle.t, unit -> unit) Core.Hashtbl.t;
mutable last_cycle_time : Core.Core_private.Time_ns_alternate_sexp.Span.t;
mutable last_cycle_num_jobs : int;
mutable total_cycle_time : Core.Core_private.Time_ns_alternate_sexp.Span.t;
mutable time_source : Core.read_write Synchronous_time_source.T1.t;
external_jobs : Async_kernel__.Types.External_job.t Thread_safe_queue.t;
mutable thread_safe_external_job_hook : unit -> unit;
mutable job_queued_hook : (Priority.t -> unit) option;
mutable event_added_hook : (Core.Time_ns.t -> unit) option;
mutable yield : (unit, Core.read_write) Async_kernel__.Types.Bvar.t;
mutable yield_until_no_jobs_remain : (unit, Core.read_write) Async_kernel__.Types.Bvar.t;
mutable check_invariants : bool;
mutable max_num_jobs_per_priority_per_cycle : Async_kernel_config.Max_num_jobs_per_priority_per_cycle.t;
mutable record_backtraces : bool;

}

val record_backtraces : t -> bool

val set_record_backtraces : t -> bool -> unit

val max_num_jobs_per_priority_per_cycle : 
  t ->
  Async_kernel_config.Max_num_jobs_per_priority_per_cycle.t

val set_max_num_jobs_per_priority_per_cycle : 
  t ->
  Async_kernel_config.Max_num_jobs_per_priority_per_cycle.t ->
  unit

val check_invariants : t -> bool

val set_check_invariants : t -> bool -> unit

val yield_until_no_jobs_remain : 
  t ->
  (unit, Core.read_write) Async_kernel__.Types.Bvar.t

val set_yield_until_no_jobs_remain : 
  t ->
  (unit, Core.read_write) Async_kernel__.Types.Bvar.t ->
  unit

val yield : t -> (unit, Core.read_write) Async_kernel__.Types.Bvar.t

val set_yield : 
  t ->
  (unit, Core.read_write) Async_kernel__.Types.Bvar.t ->
  unit

val event_added_hook : t -> (Core.Time_ns.t -> unit) option

val set_event_added_hook : t -> (Core.Time_ns.t -> unit) option -> unit

val job_queued_hook : t -> (Priority.t -> unit) option

val set_job_queued_hook : t -> (Priority.t -> unit) option -> unit

val thread_safe_external_job_hook : t -> unit -> unit

val set_thread_safe_external_job_hook : t -> (unit -> unit) -> unit

val external_jobs : 
  t ->
  Async_kernel__.Types.External_job.t Thread_safe_queue.t

val time_source : t -> Core.read_write Synchronous_time_source.T1.t

val set_time_source : t -> Core.read_write Synchronous_time_source.T1.t -> unit

val total_cycle_time : t -> Core.Core_private.Time_ns_alternate_sexp.Span.t

val set_total_cycle_time : 
  t ->
  Core.Core_private.Time_ns_alternate_sexp.Span.t ->
  unit

val set_last_cycle_num_jobs : t -> int -> unit

val last_cycle_time : t -> Core.Core_private.Time_ns_alternate_sexp.Span.t

val set_last_cycle_time : 
  t ->
  Core.Core_private.Time_ns_alternate_sexp.Span.t ->
  unit

val run_every_cycle_end_state : 
  t ->
  (Async_kernel__.Types.Cycle_hook_handle.t, unit -> unit) Core.Hashtbl.t

val run_every_cycle_end : t -> (unit -> unit) list

val set_run_every_cycle_end : t -> (unit -> unit) list -> unit

val run_every_cycle_start_state : 
  t ->
  (Async_kernel__.Types.Cycle_hook_handle.t, unit -> unit) Core.Hashtbl.t

val run_every_cycle_start : t -> (unit -> unit) list

val set_run_every_cycle_start : t -> (unit -> unit) list -> unit

val in_cycle : t -> bool

val set_in_cycle : t -> bool -> unit

val cycle_start : t -> Core.Time_ns.t

val set_cycle_start : t -> Core.Time_ns.t -> unit

val cycle_count : t -> int

val set_cycle_count : t -> int -> unit

val set_uncaught_exn : t -> (Core.Exn.t * Core.Sexp.t) option -> unit

val set_current_execution_context : t -> Execution_context.t -> unit

val main_execution_context : t -> Execution_context.t

val set_main_execution_context : t -> Execution_context.t -> unit

val very_low_priority_workers : t -> Very_low_priority_worker.t Core.Deque.t

val low_priority_jobs : t -> Async_kernel__.Types.Job_queue.t

val normal_priority_jobs : t -> Async_kernel__.Types.Job_queue.t

val job_pool : 
  t ->
  (Execution_context.t, Stdlib.Obj.t -> unit, Stdlib.Obj.t) Tuple_pool.Slots.t3
    Tuple_pool.t

val set_job_pool : 
  t ->
  (Execution_context.t, Stdlib.Obj.t -> unit, Stdlib.Obj.t) Tuple_pool.Slots.t3
    Tuple_pool.t ->
  unit

module Fields : sig ... end

val sexp_of_t : t -> Sexplib0.Sexp.t

val uncaught_exn_unwrapped : t -> (Core.Exn.t * Core.Sexp.t) option

val uncaught_exn : t -> Core.Error.t option

val num_pending_jobs : t -> int

val num_jobs_run : t -> int

val last_cycle_num_jobs : t -> int

val unordered_is_sublist : 
  equal:('a -> 'b -> bool) ->
  sublist:'b list ->
  'a list ->
  bool

val check_hook_table_invariant : ('a, 'b) Core.Hashtbl.t -> 'b list -> unit

val invariant : t -> unit

val free_job : 
  t ->
  (Execution_context.t, Stdlib.Obj.t -> unit, Stdlib.Obj.t) Tuple_pool.Slots.t3
    Tuple_pool.Pointer.t ->
  unit

val enqueue : t -> Execution_context.t -> ('a -> unit) -> 'a -> unit

val enqueue_job : 
  t ->
  (Execution_context.t * (Stdlib.Obj.t -> unit) * Stdlib.Obj.t,
    [ `S0 of Execution_context.t
    | `S1 of Stdlib.Obj.t -> unit
    | `S2 of Stdlib.Obj.t ])
    Tuple_pool.Slots.t
    Tuple_pool.Pointer.t ->
  free_job:bool ->
  unit

val handle_fired : 
  'a Synchronous_time_source.T1.t ->
  Async_kernel__.Types.Job_or_event.t ->
  unit

val create : unit -> t

val is_dead : t -> bool

val set_check_access : t -> (unit -> unit) option -> unit

val t_ref : t Core.ref

val check_access : t -> unit

val t : unit -> t

val current_execution_context : t -> Execution_context.t

val with_execution_context1 : 
  t ->
  Async_kernel__Types.Execution_context.t ->
  f:('a -> 'b) ->
  'a ->
  'b

val with_execution_context : 
  t ->
  Async_kernel__Types.Execution_context.t ->
  f:(unit -> 'a) ->
  'a

val create_job : 
  t ->
  Execution_context.t ->
  ('a -> unit) ->
  'a ->
  (Execution_context.t, Stdlib.Obj.t -> unit, Stdlib.Obj.t) Tuple_pool.Slots.t3
    Tuple_pool.Pointer.t

val got_uncaught_exn : t -> Core.Exn.t -> Core.Sexp.t -> unit

val start_cycle : 
  t ->
  max_num_jobs_per_priority:
    Async_kernel_config.Max_num_jobs_per_priority_per_cycle.t ->
  unit

val run_jobs : t -> (unit, exn * Core.Backtrace.t) Core._result

val stabilize : t -> (unit, exn) Core._result

val create_time_source : 
  ?timing_wheel_config:Timing_wheel.Config.t ->
  now:Core.Time_ns.t ->
  unit ->
  'a Synchronous_time_source.T1.t

val wall_clock : unit -> Synchronous_time_source.t

package async_kernel