sig
  module Execution_context :
    sig
      module Monitor :
        sig
          type 'execution_context t_ =
            'execution_context Raw_monitor.t_ = {
            name : Core.Std.Info.t;
            here : Core.Std.Source_code_position.t option;
            id : int;
            parent : 'execution_context t_ option;
            errors : (exn, 'execution_context) Raw_tail.t;
            mutable has_seen_error : bool;
            mutable someone_is_listening : bool;
          }
          val someone_is_listening : 'a t_ -> bool
          val set_someone_is_listening : 'a t_ -> bool -> unit
          val has_seen_error : 'a t_ -> bool
          val set_has_seen_error : 'a t_ -> bool -> unit
          val errors : 'a t_ -> (exn, 'a) Raw_tail.t
          val parent : 'a t_ -> 'a t_ option
          val id : 'a t_ -> int
          val here : 'a t_ -> Core.Std.Source_code_position.t option
          val name : 'a t_ -> Core.Std.Info.t
          module Fields :
            sig
              val someone_is_listening : ('a t_, bool) Fieldslib.Field.t
              val has_seen_error : ('a t_, bool) Fieldslib.Field.t
              val errors :
                ('execution_context t_, (exn, 'execution_context) Raw_tail.t)
                Fieldslib.Field.t
              val parent :
                ('execution_context t_, 'execution_context t_ option)
                Fieldslib.Field.t
              val id : ('a t_, int) Fieldslib.Field.t
              val here :
                ('a t_, Core.Std.Source_code_position.t option)
                Fieldslib.Field.t
              val name : ('a t_, Core.Std.Info.t) Fieldslib.Field.t
            end
          module Pretty :
            sig
              type one =
                Raw_monitor.Pretty.one = {
                name : Core.Std.Info.t;
                here : Core.Std.Source_code_position.t option;
                id : int;
                has_seen_error : bool;
                someone_is_listening : bool;
              }
              val sexp_of_one : one -> Sexplib.Sexp.t
              type t = one list
              val sexp_of_t : one list -> Sexplib.Sexp.t
            end
          val to_pretty : 'a t_ -> Pretty.one Core.Std.List.t
          val sexp_of_t_ : 'a -> 'b t_ -> Sexplib.Sexp.t
          exception Shutdown
          val ounit_tests : unit -> OUnit.test
        end
      type t =
        Execution_context.t = {
        work_group : Work_group.t Backpatched.t;
        monitor : t Monitor.t_ Backpatched.t;
        priority : Priority.t;
        backtrace_history : Core.Std.Backtrace.t list;
      }
      val sexp_of_t : t -> Sexplib.Sexp.t
      val backtrace_history : t -> Core.Std.Backtrace.t list
      val priority : t -> Priority.t
      module Fields :
        sig
          val names : string list
          val backtrace_history :
            (t, Core.Std.Backtrace.t list) Fieldslib.Field.t
          val priority : (t, Priority.t) Fieldslib.Field.t
          val monitor : (t, t Monitor.t_ Backpatched.t) Fieldslib.Field.t
          val work_group : (t, Work_group.t Backpatched.t) Fieldslib.Field.t
          val make_creator :
            work_group:((t, Work_group.t Backpatched.t) Fieldslib.Field.t ->
                        'a -> ('b -> Work_group.t Backpatched.t) * 'c) ->
            monitor:((t, t Monitor.t_ Backpatched.t) Fieldslib.Field.t ->
                     'c -> ('b -> t Monitor.t_ Backpatched.t) * 'd) ->
            priority:((t, Priority.t) Fieldslib.Field.t ->
                      'd -> ('b -> Priority.t) * 'e) ->
            backtrace_history:((t, Core.Std.Backtrace.t list)
                               Fieldslib.Field.t ->
                               'e -> ('b -> Core.Std.Backtrace.t list) * 'f) ->
            'a -> ('b -> t) * 'f
          val create :
            work_group:Work_group.t Backpatched.t ->
            monitor:t Monitor.t_ Backpatched.t ->
            priority:Priority.t ->
            backtrace_history:Core.Std.Backtrace.t list -> t
          val iter :
            work_group:((t, Work_group.t Backpatched.t) Fieldslib.Field.t ->
                        unit) ->
            monitor:((t, t Monitor.t_ Backpatched.t) Fieldslib.Field.t ->
                     unit) ->
            priority:((t, Priority.t) Fieldslib.Field.t -> unit) ->
            backtrace_history:((t, Core.Std.Backtrace.t list)
                               Fieldslib.Field.t -> 'a) ->
            'a
          val fold :
            init:'a ->
            work_group:('a ->
                        (t, Work_group.t Backpatched.t) Fieldslib.Field.t ->
                        'b) ->
            monitor:('b ->
                     (t, t Monitor.t_ Backpatched.t) Fieldslib.Field.t -> 'c) ->
            priority:('c -> (t, Priority.t) Fieldslib.Field.t -> 'd) ->
            backtrace_history:('d ->
                               (t, Core.Std.Backtrace.t list)
                               Fieldslib.Field.t -> 'e) ->
            'e
          val map :
            work_group:((t, Work_group.t Backpatched.t) Fieldslib.Field.t ->
                        Work_group.t Backpatched.t) ->
            monitor:((t, t Monitor.t_ Backpatched.t) Fieldslib.Field.t ->
                     t Monitor.t_ Backpatched.t) ->
            priority:((t, Priority.t) Fieldslib.Field.t -> Priority.t) ->
            backtrace_history:((t, Core.Std.Backtrace.t list)
                               Fieldslib.Field.t -> Core.Std.Backtrace.t list) ->
            t
          val map_poly : (t, 'a) Fieldslib.Field.user -> 'a list
          val for_all :
            work_group:((t, Work_group.t Backpatched.t) Fieldslib.Field.t ->
                        bool) ->
            monitor:((t, t Monitor.t_ Backpatched.t) Fieldslib.Field.t ->
                     bool) ->
            priority:((t, Priority.t) Fieldslib.Field.t -> bool) ->
            backtrace_history:((t, Core.Std.Backtrace.t list)
                               Fieldslib.Field.t -> bool) ->
            bool
          val exists :
            work_group:((t, Work_group.t Backpatched.t) Fieldslib.Field.t ->
                        bool) ->
            monitor:((t, t Monitor.t_ Backpatched.t) Fieldslib.Field.t ->
                     bool) ->
            priority:((t, Priority.t) Fieldslib.Field.t -> bool) ->
            backtrace_history:((t, Core.Std.Backtrace.t list)
                               Fieldslib.Field.t -> bool) ->
            bool
          val to_list :
            work_group:((t, Work_group.t Backpatched.t) Fieldslib.Field.t ->
                        'a) ->
            monitor:((t, t Monitor.t_ Backpatched.t) Fieldslib.Field.t -> 'a) ->
            priority:((t, Priority.t) Fieldslib.Field.t -> 'a) ->
            backtrace_history:((t, Core.Std.Backtrace.t list)
                               Fieldslib.Field.t -> 'a) ->
            'a list
          module Direct :
            sig
              val iter :
                t ->
                work_group:((t, Work_group.t Backpatched.t) Fieldslib.Field.t ->
                            t -> Work_group.t Backpatched.t -> unit) ->
                monitor:((t, t Monitor.t_ Backpatched.t) Fieldslib.Field.t ->
                         t -> t Monitor.t_ Backpatched.t -> unit) ->
                priority:((t, Priority.t) Fieldslib.Field.t ->
                          t -> Priority.t -> unit) ->
                backtrace_history:((t, Core.Std.Backtrace.t list)
                                   Fieldslib.Field.t ->
                                   t -> Core.Std.Backtrace.t list -> 'a) ->
                'a
              val fold :
                t ->
                init:'a ->
                work_group:('a ->
                            (t, Work_group.t Backpatched.t) Fieldslib.Field.t ->
                            t -> Work_group.t Backpatched.t -> 'b) ->
                monitor:('b ->
                         (t, t Monitor.t_ Backpatched.t) Fieldslib.Field.t ->
                         t -> t Monitor.t_ Backpatched.t -> 'c) ->
                priority:('c ->
                          (t, Priority.t) Fieldslib.Field.t ->
                          t -> Priority.t -> 'd) ->
                backtrace_history:('d ->
                                   (t, Core.Std.Backtrace.t list)
                                   Fieldslib.Field.t ->
                                   t -> Core.Std.Backtrace.t list -> 'e) ->
                'e
            end
        end
      val invariant : t -> unit
      val main_work_group_hole : Work_group.t Backpatched.Hole.t
      val main_monitor_hole : t Monitor.t_ Backpatched.Hole.t
      val main : t
      val work_group : t -> Work_group.t
      val monitor : t -> t Monitor.t_
      val create_like :
        ?work_group:Work_group.t ->
        ?monitor:t Monitor.t_ -> ?priority:Priority.t -> t -> t
      val record_backtrace : t -> t
      val ounit_tests : unit -> OUnit.test
    end
  module Clock_event :
    sig
      module Ivar :
        sig
          module Handler :
            sig
              type ('a, 'execution_context) t =
                  ('a, 'execution_context) Raw_ivar.Handler.t
            end
          type ('a, 'execution_context) t =
              ('a, 'execution_context) Raw_ivar.t
          type ('a, 'execution_context) ivar = ('a, 'execution_context) t
          val invariant :
            'a Core.Std.Invariant.inv ->
            'b Core.Std.Invariant.inv -> ('a, 'b) t Core.Std.Invariant.inv
          val create : unit -> ('a, 'b) t
          val peek : ('a, 'b) t -> 'a option
          val is_empty : ('a, 'b) t -> bool
          val is_full : ('a, 'b) t -> bool
          module Scheduler_dependent :
            functor (Scheduler : Import.Basic_scheduler) ->
              functor
                (Ivar : sig
                          type 'a t
                          val of_raw :
                            ('a, Scheduler.Execution_context.t) ivar -> 'a t
                          val to_raw :
                            'a t -> ('a, Scheduler.Execution_context.t) ivar
                        end) ->
                sig
                  type 'a t = 'a Ivar.t
                  val equal : 'a t -> 'a t -> bool
                  val create : unit -> 'a t
                  val create_full : 'a -> 'a t
                  val peek : 'a t -> 'a option
                  val is_empty : 'a t -> bool
                  val is_full : 'a t -> bool
                  val connect : bind_result:'a t -> bind_rhs:'a t -> unit
                  val fill : 'a t -> 'a -> unit
                  val install_removable_handler :
                    'a t ->
                    ('a, Scheduler.Execution_context.t) Raw_handler.t ->
                    Unregister.t
                  val upon : 'a t -> ('a -> unit) -> unit
                  val upon' : 'a t -> ('a -> unit) -> Unregister.t
                  val of_raw :
                    ('a, Scheduler.Execution_context.t) ivar -> 'a t
                  val to_raw :
                    'a t -> ('a, Scheduler.Execution_context.t) ivar
                  val sexp_of_t :
                    ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                end
          val debug_space_leaks : int option ref
          val sexp_of_t :
            ('a -> Sexplib.Sexp.t) ->
            ('execution_context -> Sexplib.Sexp.t) ->
            ('a, 'execution_context) t -> Sexplib.Sexp.t
          val ounit_tests : unit -> OUnit.test
        end
      module T :
        sig
          type 'execution_context t =
            'execution_context Raw_clock_event.T.t = {
            mutable state : 'execution_context state;
          }
          and 'execution_context state =
            'execution_context Raw_clock_event.T.state =
              Uninitialized
            | Aborted
            | Happened
            | Waiting of 'execution_context waiting
          and 'execution_context waiting =
            'execution_context Raw_clock_event.T.waiting = {
            event : 'execution_context t Core.Std.sexp_opaque Events.Event.t;
            ready : ([ `Aborted | `Happened ], 'execution_context) Ivar.t;
          }
          val sexp_of_t :
            ('execution_context -> Sexplib.Sexp.t) ->
            'execution_context t -> Sexplib.Sexp.t
          val sexp_of_state :
            ('execution_context -> Sexplib.Sexp.t) ->
            'execution_context state -> Sexplib.Sexp.t
          val sexp_of_waiting :
            ('execution_context -> Sexplib.Sexp.t) ->
            'execution_context waiting -> Sexplib.Sexp.t
        end
      type 'execution_context t =
        'execution_context T.t = {
        mutable state : 'execution_context state;
      }
      and 'execution_context state =
        'execution_context T.state =
          Uninitialized
        | Aborted
        | Happened
        | Waiting of 'execution_context waiting
      and 'execution_context waiting =
        'execution_context T.waiting = {
        event : 'execution_context t Core.Std.sexp_opaque Events.Event.t;
        ready : ([ `Aborted | `Happened ], 'execution_context) Ivar.t;
      }
      val sexp_of_t :
        ('execution_context -> Sexplib.Sexp.t) ->
        'execution_context t -> Sexplib.Sexp.t
      val sexp_of_state :
        ('execution_context -> Sexplib.Sexp.t) ->
        'execution_context state -> Sexplib.Sexp.t
      val sexp_of_waiting :
        ('execution_context -> Sexplib.Sexp.t) ->
        'execution_context waiting -> Sexplib.Sexp.t
      val ounit_tests : unit -> OUnit.test
    end
  module Ivar :
    sig
      module Handler :
        sig
          type ('a, 'execution_context) t =
              ('a, 'execution_context) Raw_ivar.Handler.t
        end
      type ('a, 'execution_context) t = ('a, 'execution_context) Raw_ivar.t
      type ('a, 'execution_context) ivar = ('a, 'execution_context) t
      val invariant :
        'a Core.Std.Invariant.inv ->
        'b Core.Std.Invariant.inv -> ('a, 'b) t Core.Std.Invariant.inv
      val create : unit -> ('a, 'b) t
      val peek : ('a, 'b) t -> 'a option
      val is_empty : ('a, 'b) t -> bool
      val is_full : ('a, 'b) t -> bool
      module Scheduler_dependent :
        functor (Scheduler : Import.Basic_scheduler) ->
          functor
            (Ivar : sig
                      type 'a t
                      val of_raw :
                        ('a, Scheduler.Execution_context.t) ivar -> 'a t
                      val to_raw :
                        'a t -> ('a, Scheduler.Execution_context.t) ivar
                    end) ->
            sig
              type 'a t = 'a Ivar.t
              val equal : 'a t -> 'a t -> bool
              val create : unit -> 'a t
              val create_full : 'a -> 'a t
              val peek : 'a t -> 'a option
              val is_empty : 'a t -> bool
              val is_full : 'a t -> bool
              val connect : bind_result:'a t -> bind_rhs:'a t -> unit
              val fill : 'a t -> 'a -> unit
              val install_removable_handler :
                'a t ->
                ('a, Scheduler.Execution_context.t) Raw_handler.t ->
                Unregister.t
              val upon : 'a t -> ('a -> unit) -> unit
              val upon' : 'a t -> ('a -> unit) -> Unregister.t
              val of_raw : ('a, Scheduler.Execution_context.t) ivar -> 'a t
              val to_raw : 'a t -> ('a, Scheduler.Execution_context.t) ivar
              val sexp_of_t :
                ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
            end
      val debug_space_leaks : int option ref
      val sexp_of_t :
        ('a -> Sexplib.Sexp.t) ->
        ('execution_context -> Sexplib.Sexp.t) ->
        ('a, 'execution_context) t -> Sexplib.Sexp.t
      val ounit_tests : unit -> OUnit.test
    end
  module Tail :
    sig
      module Deferred :
        sig
          type ('a, 'execution_context) t =
              ('a, 'execution_context) Raw_deferred.t
          type ('a, 'execution_context) deferred = ('a, 'execution_context) t
          val of_ivar :
            ('a, 'execution_context) Raw_ivar.t -> ('a, 'execution_context) t
          val peek : ('a, 'b) t -> 'a option
          module Scheduler_dependent :
            functor (Scheduler : Import.Basic_scheduler) ->
              functor
                (Deferred : sig
                              type 'a t
                              val of_raw :
                                ('a, Scheduler.Execution_context.t) t -> 'a t
                              val to_raw :
                                'a t -> ('a, Scheduler.Execution_context.t) t
                            end) ->
                functor
                  (Ivar : sig
                            type 'a t
                            val of_raw :
                              ('a, Scheduler.Execution_context.t) Raw_ivar.t ->
                              'a t
                            val to_raw :
                              'a t ->
                              ('a, Scheduler.Execution_context.t) Raw_ivar.t
                          end) ->
                  sig
                    type 'a t = 'a Deferred.t
                    val create : ('a Ivar.t -> unit) -> 'a t
                    val peek : 'a t -> 'a option
                    val is_determined : 'a t -> bool
                    val return : 'a -> 'a t
                    val upon : 'a t -> ('a -> unit) -> unit
                    val upon' : 'a t -> ('a -> unit) -> Unregister.t
                    val bind : 'a t -> ('a -> 'b t) -> 'b t
                    val install_removable_handler :
                      'a t ->
                      ('a, Scheduler.Execution_context.t) Raw_handler.t ->
                      Unregister.t
                    val of_raw :
                      ('a, Scheduler.Execution_context.t) deferred -> 'a t
                    val to_raw :
                      'a t -> ('a, Scheduler.Execution_context.t) deferred
                    val sexp_of_t :
                      ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                  end
          val sexp_of_t :
            ('a -> Sexplib.Sexp.t) ->
            ('execution_context -> Sexplib.Sexp.t) ->
            ('a, 'execution_context) t -> Sexplib.Sexp.t
          val ounit_tests : unit -> OUnit.test
        end
      module Ivar :
        sig
          module Handler :
            sig
              type ('a, 'execution_context) t =
                  ('a, 'execution_context) Raw_ivar.Handler.t
            end
          type ('a, 'execution_context) t =
              ('a, 'execution_context) Raw_ivar.t
          type ('a, 'execution_context) ivar = ('a, 'execution_context) t
          val invariant :
            'a Core.Std.Invariant.inv ->
            'b Core.Std.Invariant.inv -> ('a, 'b) t Core.Std.Invariant.inv
          val create : unit -> ('a, 'b) t
          val peek : ('a, 'b) t -> 'a option
          val is_empty : ('a, 'b) t -> bool
          val is_full : ('a, 'b) t -> bool
          module Scheduler_dependent :
            functor (Scheduler : Import.Basic_scheduler) ->
              functor
                (Ivar : sig
                          type 'a t
                          val of_raw :
                            ('a, Scheduler.Execution_context.t) ivar -> 'a t
                          val to_raw :
                            'a t -> ('a, Scheduler.Execution_context.t) ivar
                        end) ->
                sig
                  type 'a t = 'a Ivar.t
                  val equal : 'a t -> 'a t -> bool
                  val create : unit -> 'a t
                  val create_full : 'a -> 'a t
                  val peek : 'a t -> 'a option
                  val is_empty : 'a t -> bool
                  val is_full : 'a t -> bool
                  val connect : bind_result:'a t -> bind_rhs:'a t -> unit
                  val fill : 'a t -> 'a -> unit
                  val install_removable_handler :
                    'a t ->
                    ('a, Scheduler.Execution_context.t) Raw_handler.t ->
                    Unregister.t
                  val upon : 'a t -> ('a -> unit) -> unit
                  val upon' : 'a t -> ('a -> unit) -> Unregister.t
                  val of_raw :
                    ('a, Scheduler.Execution_context.t) ivar -> 'a t
                  val to_raw :
                    'a t -> ('a, Scheduler.Execution_context.t) ivar
                  val sexp_of_t :
                    ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                end
          val debug_space_leaks : int option ref
          val sexp_of_t :
            ('a -> Sexplib.Sexp.t) ->
            ('execution_context -> Sexplib.Sexp.t) ->
            ('a, 'execution_context) t -> Sexplib.Sexp.t
          val ounit_tests : unit -> OUnit.test
        end
      module Stream :
        sig
          module Deferred :
            sig
              type ('a, 'execution_context) t =
                  ('a, 'execution_context) Raw_deferred.t
              type ('a, 'execution_context) deferred =
                  ('a, 'execution_context) t
              val of_ivar :
                ('a, 'execution_context) Raw_ivar.t ->
                ('a, 'execution_context) t
              val peek : ('a, 'b) t -> 'a option
              module Scheduler_dependent :
                functor (Scheduler : Import.Basic_scheduler) ->
                  functor
                    (Deferred : sig
                                  type 'a t
                                  val of_raw :
                                    ('a, Scheduler.Execution_context.t) t ->
                                    'a t
                                  val to_raw :
                                    'a t ->
                                    ('a, Scheduler.Execution_context.t) t
                                end) ->
                    functor
                      (Ivar : sig
                                type 'a t
                                val of_raw :
                                  ('a, Scheduler.Execution_context.t)
                                  Raw_ivar.t -> 'a t
                                val to_raw :
                                  'a t ->
                                  ('a, Scheduler.Execution_context.t)
                                  Raw_ivar.t
                              end) ->
                      sig
                        type 'a t = 'a Deferred.t
                        val create : ('a Ivar.t -> unit) -> 'a t
                        val peek : 'a t -> 'a option
                        val is_determined : 'a t -> bool
                        val return : 'a -> 'a t
                        val upon : 'a t -> ('a -> unit) -> unit
                        val upon' : 'a t -> ('a -> unit) -> Unregister.t
                        val bind : 'a t -> ('a -> 'b t) -> 'b t
                        val install_removable_handler :
                          'a t ->
                          ('a, Scheduler.Execution_context.t) Raw_handler.t ->
                          Unregister.t
                        val of_raw :
                          ('a, Scheduler.Execution_context.t) deferred ->
                          'a t
                        val to_raw :
                          'a t ->
                          ('a, Scheduler.Execution_context.t) deferred
                        val sexp_of_t :
                          ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                      end
              val sexp_of_t :
                ('a -> Sexplib.Sexp.t) ->
                ('execution_context -> Sexplib.Sexp.t) ->
                ('a, 'execution_context) t -> Sexplib.Sexp.t
              val ounit_tests : unit -> OUnit.test
            end
          type ('a, 'execution_context) t =
              (('a, 'execution_context) next, 'execution_context) Deferred.t
          and ('a, 'execution_context) next =
            ('a, 'execution_context) Raw_stream.next =
              Nil
            | Cons of 'a * ('a, 'execution_context) t
          val sexp_of_t :
            ('a -> Core.Std.Sexp.t) ->
            'b -> (('a, 'c) next, 'c) Deferred.t -> Core.Std.Sexp.t
          val ounit_tests : unit -> OUnit.test
        end
      type ('a, 'execution_context) t =
        ('a, 'execution_context) Raw_tail.t = {
        mutable next :
          (('a, 'execution_context) Stream.next, 'execution_context) Ivar.t;
      }
      val sexp_of_t : 'a -> 'b -> ('c, 'd) t -> Core.Std.Sexp.t
      val create : unit -> ('a, 'b) t
      val ounit_tests : unit -> OUnit.test
    end
  val debug : bool
  type 'a tail = ('a, Execution_context.t) Tail.t
  val sexp_of_tail : ('a -> Sexplib.Sexp.t) -> 'a tail -> Sexplib.Sexp.t
  module T :
    sig
      type t =
        Raw_scheduler.T.t = {
        mutable check_access : (unit -> unit) option;
        jobs : Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque;
        mutable main_execution_context : Execution_context.t;
        mutable current_execution_context : Execution_context.t;
        mutable max_num_jobs_per_priority_per_cycle : int;
        mutable uncaught_exn : Core.Std.Error.t option;
        mutable num_jobs_run : int;
        mutable cycle_count : int;
        mutable cycle_start : Core.Std.Time.t;
        mutable last_cycle_time : Core.Std.Time.Span.t;
        cycle_times : Core.Std.Time.Span.t tail;
        mutable last_cycle_num_jobs : int;
        cycle_num_jobs : int tail;
        events : Execution_context.t Clock_event.t Events.t;
        finalizer_jobs :
          Execution_context.t Job.t Core.Std.Thread_safe_queue.t
          Core.Std.sexp_opaque;
        mutable thread_safe_finalizer_hook : unit -> unit;
      }
      val sexp_of_t : t -> Sexplib.Sexp.t
      val thread_safe_finalizer_hook : t -> unit -> unit
      val set_thread_safe_finalizer_hook : t -> (unit -> unit) -> unit
      val finalizer_jobs :
        t ->
        Execution_context.t Job.t Core.Std.Thread_safe_queue.t
        Core.Std.sexp_opaque
      val events : t -> Execution_context.t Clock_event.t Events.t
      val cycle_num_jobs : t -> int tail
      val last_cycle_num_jobs : t -> int
      val set_last_cycle_num_jobs : t -> int -> unit
      val cycle_times : t -> Core.Std.Time.Span.t tail
      val last_cycle_time : t -> Core.Std.Time.Span.t
      val set_last_cycle_time : t -> Core.Std.Time.Span.t -> unit
      val cycle_start : t -> Core.Std.Time.t
      val set_cycle_start : t -> Core.Std.Time.t -> unit
      val cycle_count : t -> int
      val set_cycle_count : t -> int -> unit
      val num_jobs_run : t -> int
      val set_num_jobs_run : t -> int -> unit
      val uncaught_exn : t -> Core.Std.Error.t option
      val set_uncaught_exn : t -> Core.Std.Error.t option -> unit
      val max_num_jobs_per_priority_per_cycle : t -> int
      val set_max_num_jobs_per_priority_per_cycle : t -> int -> unit
      val current_execution_context : t -> Execution_context.t
      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 jobs : t -> Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque
      val check_access : t -> (unit -> unit) option
      val set_check_access : t -> (unit -> unit) option -> unit
      module Fields :
        sig
          val names : string list
          val thread_safe_finalizer_hook :
            (t, unit -> unit) Fieldslib.Field.t
          val finalizer_jobs :
            (t,
             Execution_context.t Job.t Core.Std.Thread_safe_queue.t
             Core.Std.sexp_opaque)
            Fieldslib.Field.t
          val events :
            (t, Execution_context.t Clock_event.t Events.t) Fieldslib.Field.t
          val cycle_num_jobs : (t, int tail) Fieldslib.Field.t
          val last_cycle_num_jobs : (t, int) Fieldslib.Field.t
          val cycle_times : (t, Core.Std.Time.Span.t tail) Fieldslib.Field.t
          val last_cycle_time : (t, Core.Std.Time.Span.t) Fieldslib.Field.t
          val cycle_start : (t, Core.Std.Time.t) Fieldslib.Field.t
          val cycle_count : (t, int) Fieldslib.Field.t
          val num_jobs_run : (t, int) Fieldslib.Field.t
          val uncaught_exn : (t, Core.Std.Error.t option) Fieldslib.Field.t
          val max_num_jobs_per_priority_per_cycle :
            (t, int) Fieldslib.Field.t
          val current_execution_context :
            (t, Execution_context.t) Fieldslib.Field.t
          val main_execution_context :
            (t, Execution_context.t) Fieldslib.Field.t
          val jobs :
            (t, Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque)
            Fieldslib.Field.t
          val check_access : (t, (unit -> unit) option) Fieldslib.Field.t
          val make_creator :
            check_access:((t, (unit -> unit) option) Fieldslib.Field.t ->
                          'a -> ('b -> (unit -> unit) option) * 'c) ->
            jobs:((t, Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque)
                  Fieldslib.Field.t ->
                  'c ->
                  ('b ->
                   Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque) *
                  'd) ->
            main_execution_context:((t, Execution_context.t)
                                    Fieldslib.Field.t ->
                                    'd -> ('b -> Execution_context.t) * 'e) ->
            current_execution_context:((t, Execution_context.t)
                                       Fieldslib.Field.t ->
                                       'e -> ('b -> Execution_context.t) * 'f) ->
            max_num_jobs_per_priority_per_cycle:((t, int) Fieldslib.Field.t ->
                                                 'f -> ('b -> int) * 'g) ->
            uncaught_exn:((t, Core.Std.Error.t option) Fieldslib.Field.t ->
                          'g -> ('b -> Core.Std.Error.t option) * 'h) ->
            num_jobs_run:((t, int) Fieldslib.Field.t ->
                          'h -> ('b -> int) * 'i) ->
            cycle_count:((t, int) Fieldslib.Field.t -> 'i -> ('b -> int) * 'j) ->
            cycle_start:((t, Core.Std.Time.t) Fieldslib.Field.t ->
                         'j -> ('b -> Core.Std.Time.t) * 'k) ->
            last_cycle_time:((t, Core.Std.Time.Span.t) Fieldslib.Field.t ->
                             'k -> ('b -> Core.Std.Time.Span.t) * 'l) ->
            cycle_times:((t, Core.Std.Time.Span.t tail) Fieldslib.Field.t ->
                         'l -> ('b -> Core.Std.Time.Span.t tail) * 'm) ->
            last_cycle_num_jobs:((t, int) Fieldslib.Field.t ->
                                 'm -> ('b -> int) * 'n) ->
            cycle_num_jobs:((t, int tail) Fieldslib.Field.t ->
                            'n -> ('b -> int tail) * 'o) ->
            events:((t, Execution_context.t Clock_event.t Events.t)
                    Fieldslib.Field.t ->
                    'o ->
                    ('b -> Execution_context.t Clock_event.t Events.t) * 'p) ->
            finalizer_jobs:((t,
                             Execution_context.t Job.t
                             Core.Std.Thread_safe_queue.t
                             Core.Std.sexp_opaque)
                            Fieldslib.Field.t ->
                            'p ->
                            ('b ->
                             Execution_context.t Job.t
                             Core.Std.Thread_safe_queue.t
                             Core.Std.sexp_opaque) *
                            'q) ->
            thread_safe_finalizer_hook:((t, unit -> unit) Fieldslib.Field.t ->
                                        'q -> ('b -> unit -> unit) * 'r) ->
            'a -> ('b -> t) * 'r
          val create :
            check_access:(unit -> unit) option ->
            jobs:Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque ->
            main_execution_context:Execution_context.t ->
            current_execution_context:Execution_context.t ->
            max_num_jobs_per_priority_per_cycle:int ->
            uncaught_exn:Core.Std.Error.t option ->
            num_jobs_run:int ->
            cycle_count:int ->
            cycle_start:Core.Std.Time.t ->
            last_cycle_time:Core.Std.Time.Span.t ->
            cycle_times:Core.Std.Time.Span.t tail ->
            last_cycle_num_jobs:int ->
            cycle_num_jobs:int tail ->
            events:Execution_context.t Clock_event.t Events.t ->
            finalizer_jobs:Execution_context.t Job.t
                           Core.Std.Thread_safe_queue.t Core.Std.sexp_opaque ->
            thread_safe_finalizer_hook:(unit -> unit) -> t
          val iter :
            check_access:((t, (unit -> unit) option) Fieldslib.Field.t ->
                          unit) ->
            jobs:((t, Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque)
                  Fieldslib.Field.t -> unit) ->
            main_execution_context:((t, Execution_context.t)
                                    Fieldslib.Field.t -> unit) ->
            current_execution_context:((t, Execution_context.t)
                                       Fieldslib.Field.t -> unit) ->
            max_num_jobs_per_priority_per_cycle:((t, int) Fieldslib.Field.t ->
                                                 unit) ->
            uncaught_exn:((t, Core.Std.Error.t option) Fieldslib.Field.t ->
                          unit) ->
            num_jobs_run:((t, int) Fieldslib.Field.t -> unit) ->
            cycle_count:((t, int) Fieldslib.Field.t -> unit) ->
            cycle_start:((t, Core.Std.Time.t) Fieldslib.Field.t -> unit) ->
            last_cycle_time:((t, Core.Std.Time.Span.t) Fieldslib.Field.t ->
                             unit) ->
            cycle_times:((t, Core.Std.Time.Span.t tail) Fieldslib.Field.t ->
                         unit) ->
            last_cycle_num_jobs:((t, int) Fieldslib.Field.t -> unit) ->
            cycle_num_jobs:((t, int tail) Fieldslib.Field.t -> unit) ->
            events:((t, Execution_context.t Clock_event.t Events.t)
                    Fieldslib.Field.t -> unit) ->
            finalizer_jobs:((t,
                             Execution_context.t Job.t
                             Core.Std.Thread_safe_queue.t
                             Core.Std.sexp_opaque)
                            Fieldslib.Field.t -> unit) ->
            thread_safe_finalizer_hook:((t, unit -> unit) Fieldslib.Field.t ->
                                        'a) ->
            'a
          val fold :
            init:'a ->
            check_access:('a ->
                          (t, (unit -> unit) option) Fieldslib.Field.t -> 'b) ->
            jobs:('b ->
                  (t, Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque)
                  Fieldslib.Field.t -> 'c) ->
            main_execution_context:('c ->
                                    (t, Execution_context.t)
                                    Fieldslib.Field.t -> 'd) ->
            current_execution_context:('d ->
                                       (t, Execution_context.t)
                                       Fieldslib.Field.t -> 'e) ->
            max_num_jobs_per_priority_per_cycle:('e ->
                                                 (t, int) Fieldslib.Field.t ->
                                                 'f) ->
            uncaught_exn:('f ->
                          (t, Core.Std.Error.t option) Fieldslib.Field.t ->
                          'g) ->
            num_jobs_run:('g -> (t, int) Fieldslib.Field.t -> 'h) ->
            cycle_count:('h -> (t, int) Fieldslib.Field.t -> 'i) ->
            cycle_start:('i -> (t, Core.Std.Time.t) Fieldslib.Field.t -> 'j) ->
            last_cycle_time:('j ->
                             (t, Core.Std.Time.Span.t) Fieldslib.Field.t ->
                             'k) ->
            cycle_times:('k ->
                         (t, Core.Std.Time.Span.t tail) Fieldslib.Field.t ->
                         'l) ->
            last_cycle_num_jobs:('l -> (t, int) Fieldslib.Field.t -> 'm) ->
            cycle_num_jobs:('m -> (t, int tail) Fieldslib.Field.t -> 'n) ->
            events:('n ->
                    (t, Execution_context.t Clock_event.t Events.t)
                    Fieldslib.Field.t -> 'o) ->
            finalizer_jobs:('o ->
                            (t,
                             Execution_context.t Job.t
                             Core.Std.Thread_safe_queue.t
                             Core.Std.sexp_opaque)
                            Fieldslib.Field.t -> 'p) ->
            thread_safe_finalizer_hook:('p ->
                                        (t, unit -> unit) Fieldslib.Field.t ->
                                        'q) ->
            'q
          val map :
            check_access:((t, (unit -> unit) option) Fieldslib.Field.t ->
                          (unit -> unit) option) ->
            jobs:((t, Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque)
                  Fieldslib.Field.t ->
                  Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque) ->
            main_execution_context:((t, Execution_context.t)
                                    Fieldslib.Field.t -> Execution_context.t) ->
            current_execution_context:((t, Execution_context.t)
                                       Fieldslib.Field.t ->
                                       Execution_context.t) ->
            max_num_jobs_per_priority_per_cycle:((t, int) Fieldslib.Field.t ->
                                                 int) ->
            uncaught_exn:((t, Core.Std.Error.t option) Fieldslib.Field.t ->
                          Core.Std.Error.t option) ->
            num_jobs_run:((t, int) Fieldslib.Field.t -> int) ->
            cycle_count:((t, int) Fieldslib.Field.t -> int) ->
            cycle_start:((t, Core.Std.Time.t) Fieldslib.Field.t ->
                         Core.Std.Time.t) ->
            last_cycle_time:((t, Core.Std.Time.Span.t) Fieldslib.Field.t ->
                             Core.Std.Time.Span.t) ->
            cycle_times:((t, Core.Std.Time.Span.t tail) Fieldslib.Field.t ->
                         Core.Std.Time.Span.t tail) ->
            last_cycle_num_jobs:((t, int) Fieldslib.Field.t -> int) ->
            cycle_num_jobs:((t, int tail) Fieldslib.Field.t -> int tail) ->
            events:((t, Execution_context.t Clock_event.t Events.t)
                    Fieldslib.Field.t ->
                    Execution_context.t Clock_event.t Events.t) ->
            finalizer_jobs:((t,
                             Execution_context.t Job.t
                             Core.Std.Thread_safe_queue.t
                             Core.Std.sexp_opaque)
                            Fieldslib.Field.t ->
                            Execution_context.t Job.t
                            Core.Std.Thread_safe_queue.t Core.Std.sexp_opaque) ->
            thread_safe_finalizer_hook:((t, unit -> unit) Fieldslib.Field.t ->
                                        unit -> unit) ->
            t
          val map_poly : (t, 'a) Fieldslib.Field.user -> 'a list
          val for_all :
            check_access:((t, (unit -> unit) option) Fieldslib.Field.t ->
                          bool) ->
            jobs:((t, Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque)
                  Fieldslib.Field.t -> bool) ->
            main_execution_context:((t, Execution_context.t)
                                    Fieldslib.Field.t -> bool) ->
            current_execution_context:((t, Execution_context.t)
                                       Fieldslib.Field.t -> bool) ->
            max_num_jobs_per_priority_per_cycle:((t, int) Fieldslib.Field.t ->
                                                 bool) ->
            uncaught_exn:((t, Core.Std.Error.t option) Fieldslib.Field.t ->
                          bool) ->
            num_jobs_run:((t, int) Fieldslib.Field.t -> bool) ->
            cycle_count:((t, int) Fieldslib.Field.t -> bool) ->
            cycle_start:((t, Core.Std.Time.t) Fieldslib.Field.t -> bool) ->
            last_cycle_time:((t, Core.Std.Time.Span.t) Fieldslib.Field.t ->
                             bool) ->
            cycle_times:((t, Core.Std.Time.Span.t tail) Fieldslib.Field.t ->
                         bool) ->
            last_cycle_num_jobs:((t, int) Fieldslib.Field.t -> bool) ->
            cycle_num_jobs:((t, int tail) Fieldslib.Field.t -> bool) ->
            events:((t, Execution_context.t Clock_event.t Events.t)
                    Fieldslib.Field.t -> bool) ->
            finalizer_jobs:((t,
                             Execution_context.t Job.t
                             Core.Std.Thread_safe_queue.t
                             Core.Std.sexp_opaque)
                            Fieldslib.Field.t -> bool) ->
            thread_safe_finalizer_hook:((t, unit -> unit) Fieldslib.Field.t ->
                                        bool) ->
            bool
          val exists :
            check_access:((t, (unit -> unit) option) Fieldslib.Field.t ->
                          bool) ->
            jobs:((t, Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque)
                  Fieldslib.Field.t -> bool) ->
            main_execution_context:((t, Execution_context.t)
                                    Fieldslib.Field.t -> bool) ->
            current_execution_context:((t, Execution_context.t)
                                       Fieldslib.Field.t -> bool) ->
            max_num_jobs_per_priority_per_cycle:((t, int) Fieldslib.Field.t ->
                                                 bool) ->
            uncaught_exn:((t, Core.Std.Error.t option) Fieldslib.Field.t ->
                          bool) ->
            num_jobs_run:((t, int) Fieldslib.Field.t -> bool) ->
            cycle_count:((t, int) Fieldslib.Field.t -> bool) ->
            cycle_start:((t, Core.Std.Time.t) Fieldslib.Field.t -> bool) ->
            last_cycle_time:((t, Core.Std.Time.Span.t) Fieldslib.Field.t ->
                             bool) ->
            cycle_times:((t, Core.Std.Time.Span.t tail) Fieldslib.Field.t ->
                         bool) ->
            last_cycle_num_jobs:((t, int) Fieldslib.Field.t -> bool) ->
            cycle_num_jobs:((t, int tail) Fieldslib.Field.t -> bool) ->
            events:((t, Execution_context.t Clock_event.t Events.t)
                    Fieldslib.Field.t -> bool) ->
            finalizer_jobs:((t,
                             Execution_context.t Job.t
                             Core.Std.Thread_safe_queue.t
                             Core.Std.sexp_opaque)
                            Fieldslib.Field.t -> bool) ->
            thread_safe_finalizer_hook:((t, unit -> unit) Fieldslib.Field.t ->
                                        bool) ->
            bool
          val to_list :
            check_access:((t, (unit -> unit) option) Fieldslib.Field.t -> 'a) ->
            jobs:((t, Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque)
                  Fieldslib.Field.t -> 'a) ->
            main_execution_context:((t, Execution_context.t)
                                    Fieldslib.Field.t -> 'a) ->
            current_execution_context:((t, Execution_context.t)
                                       Fieldslib.Field.t -> 'a) ->
            max_num_jobs_per_priority_per_cycle:((t, int) Fieldslib.Field.t ->
                                                 'a) ->
            uncaught_exn:((t, Core.Std.Error.t option) Fieldslib.Field.t ->
                          'a) ->
            num_jobs_run:((t, int) Fieldslib.Field.t -> 'a) ->
            cycle_count:((t, int) Fieldslib.Field.t -> 'a) ->
            cycle_start:((t, Core.Std.Time.t) Fieldslib.Field.t -> 'a) ->
            last_cycle_time:((t, Core.Std.Time.Span.t) Fieldslib.Field.t ->
                             'a) ->
            cycle_times:((t, Core.Std.Time.Span.t tail) Fieldslib.Field.t ->
                         'a) ->
            last_cycle_num_jobs:((t, int) Fieldslib.Field.t -> 'a) ->
            cycle_num_jobs:((t, int tail) Fieldslib.Field.t -> 'a) ->
            events:((t, Execution_context.t Clock_event.t Events.t)
                    Fieldslib.Field.t -> 'a) ->
            finalizer_jobs:((t,
                             Execution_context.t Job.t
                             Core.Std.Thread_safe_queue.t
                             Core.Std.sexp_opaque)
                            Fieldslib.Field.t -> 'a) ->
            thread_safe_finalizer_hook:((t, unit -> unit) Fieldslib.Field.t ->
                                        'a) ->
            'a list
          module Direct :
            sig
              val iter :
                t ->
                check_access:((t, (unit -> unit) option) Fieldslib.Field.t ->
                              t -> (unit -> unit) option -> unit) ->
                jobs:((t,
                       Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque)
                      Fieldslib.Field.t ->
                      t ->
                      Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque ->
                      unit) ->
                main_execution_context:((t, Execution_context.t)
                                        Fieldslib.Field.t ->
                                        t -> Execution_context.t -> unit) ->
                current_execution_context:((t, Execution_context.t)
                                           Fieldslib.Field.t ->
                                           t -> Execution_context.t -> unit) ->
                max_num_jobs_per_priority_per_cycle:((t, int)
                                                     Fieldslib.Field.t ->
                                                     t -> int -> unit) ->
                uncaught_exn:((t, Core.Std.Error.t option) Fieldslib.Field.t ->
                              t -> Core.Std.Error.t option -> unit) ->
                num_jobs_run:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
                cycle_count:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
                cycle_start:((t, Core.Std.Time.t) Fieldslib.Field.t ->
                             t -> Core.Std.Time.t -> unit) ->
                last_cycle_time:((t, Core.Std.Time.Span.t) Fieldslib.Field.t ->
                                 t -> Core.Std.Time.Span.t -> unit) ->
                cycle_times:((t, Core.Std.Time.Span.t tail) Fieldslib.Field.t ->
                             t -> Core.Std.Time.Span.t tail -> unit) ->
                last_cycle_num_jobs:((t, int) Fieldslib.Field.t ->
                                     t -> int -> unit) ->
                cycle_num_jobs:((t, int tail) Fieldslib.Field.t ->
                                t -> int tail -> unit) ->
                events:((t, Execution_context.t Clock_event.t Events.t)
                        Fieldslib.Field.t ->
                        t ->
                        Execution_context.t Clock_event.t Events.t -> unit) ->
                finalizer_jobs:((t,
                                 Execution_context.t Job.t
                                 Core.Std.Thread_safe_queue.t
                                 Core.Std.sexp_opaque)
                                Fieldslib.Field.t ->
                                t ->
                                Execution_context.t Job.t
                                Core.Std.Thread_safe_queue.t
                                Core.Std.sexp_opaque -> unit) ->
                thread_safe_finalizer_hook:((t, unit -> unit)
                                            Fieldslib.Field.t ->
                                            t -> (unit -> unit) -> 'a) ->
                'a
              val fold :
                t ->
                init:'a ->
                check_access:('a ->
                              (t, (unit -> unit) option) Fieldslib.Field.t ->
                              t -> (unit -> unit) option -> 'b) ->
                jobs:('b ->
                      (t,
                       Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque)
                      Fieldslib.Field.t ->
                      t ->
                      Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque ->
                      'c) ->
                main_execution_context:('c ->
                                        (t, Execution_context.t)
                                        Fieldslib.Field.t ->
                                        t -> Execution_context.t -> 'd) ->
                current_execution_context:('d ->
                                           (t, Execution_context.t)
                                           Fieldslib.Field.t ->
                                           t -> Execution_context.t -> 'e) ->
                max_num_jobs_per_priority_per_cycle:('e ->
                                                     (t, int)
                                                     Fieldslib.Field.t ->
                                                     t -> int -> 'f) ->
                uncaught_exn:('f ->
                              (t, Core.Std.Error.t option) Fieldslib.Field.t ->
                              t -> Core.Std.Error.t option -> 'g) ->
                num_jobs_run:('g ->
                              (t, int) Fieldslib.Field.t -> t -> int -> 'h) ->
                cycle_count:('h ->
                             (t, int) Fieldslib.Field.t -> t -> int -> 'i) ->
                cycle_start:('i ->
                             (t, Core.Std.Time.t) Fieldslib.Field.t ->
                             t -> Core.Std.Time.t -> 'j) ->
                last_cycle_time:('j ->
                                 (t, Core.Std.Time.Span.t) Fieldslib.Field.t ->
                                 t -> Core.Std.Time.Span.t -> 'k) ->
                cycle_times:('k ->
                             (t, Core.Std.Time.Span.t tail) Fieldslib.Field.t ->
                             t -> Core.Std.Time.Span.t tail -> 'l) ->
                last_cycle_num_jobs:('l ->
                                     (t, int) Fieldslib.Field.t ->
                                     t -> int -> 'm) ->
                cycle_num_jobs:('m ->
                                (t, int tail) Fieldslib.Field.t ->
                                t -> int tail -> 'n) ->
                events:('n ->
                        (t, Execution_context.t Clock_event.t Events.t)
                        Fieldslib.Field.t ->
                        t -> Execution_context.t Clock_event.t Events.t -> 'o) ->
                finalizer_jobs:('o ->
                                (t,
                                 Execution_context.t Job.t
                                 Core.Std.Thread_safe_queue.t
                                 Core.Std.sexp_opaque)
                                Fieldslib.Field.t ->
                                t ->
                                Execution_context.t Job.t
                                Core.Std.Thread_safe_queue.t
                                Core.Std.sexp_opaque -> 'p) ->
                thread_safe_finalizer_hook:('p ->
                                            (t, unit -> unit)
                                            Fieldslib.Field.t ->
                                            t -> (unit -> unit) -> 'q) ->
                'q
            end
        end
    end
  type t =
    T.t = {
    mutable check_access : (unit -> unit) option;
    jobs : Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque;
    mutable main_execution_context : Execution_context.t;
    mutable current_execution_context : Execution_context.t;
    mutable max_num_jobs_per_priority_per_cycle : int;
    mutable uncaught_exn : Core.Std.Error.t option;
    mutable num_jobs_run : int;
    mutable cycle_count : int;
    mutable cycle_start : Core.Std.Time.t;
    mutable last_cycle_time : Core.Std.Time.Span.t;
    cycle_times : Core.Std.Time.Span.t tail;
    mutable last_cycle_num_jobs : int;
    cycle_num_jobs : int tail;
    events : Execution_context.t Clock_event.t Events.t;
    finalizer_jobs :
      Execution_context.t Job.t Core.Std.Thread_safe_queue.t
      Core.Std.sexp_opaque;
    mutable thread_safe_finalizer_hook : unit -> unit;
  }
  val sexp_of_t : t -> Sexplib.Sexp.t
  val thread_safe_finalizer_hook : t -> unit -> unit
  val set_thread_safe_finalizer_hook : t -> (unit -> unit) -> unit
  val finalizer_jobs :
    t ->
    Execution_context.t Job.t Core.Std.Thread_safe_queue.t
    Core.Std.sexp_opaque
  val events : t -> Execution_context.t Clock_event.t Events.t
  val cycle_num_jobs : t -> int tail
  val last_cycle_num_jobs : t -> int
  val set_last_cycle_num_jobs : t -> int -> unit
  val cycle_times : t -> Core.Std.Time.Span.t tail
  val last_cycle_time : t -> Core.Std.Time.Span.t
  val set_last_cycle_time : t -> Core.Std.Time.Span.t -> unit
  val cycle_start : t -> Core.Std.Time.t
  val set_cycle_start : t -> Core.Std.Time.t -> unit
  val cycle_count : t -> int
  val set_cycle_count : t -> int -> unit
  val num_jobs_run : t -> int
  val set_num_jobs_run : t -> int -> unit
  val uncaught_exn : t -> Core.Std.Error.t option
  val set_uncaught_exn : t -> Core.Std.Error.t option -> unit
  val max_num_jobs_per_priority_per_cycle : t -> int
  val set_max_num_jobs_per_priority_per_cycle : t -> int -> 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 jobs : t -> Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque
  module Fields :
    sig
      val names : string list
      val thread_safe_finalizer_hook : (t, unit -> unit) Fieldslib.Field.t
      val finalizer_jobs :
        (t,
         Execution_context.t Job.t Core.Std.Thread_safe_queue.t
         Core.Std.sexp_opaque)
        Fieldslib.Field.t
      val events :
        (t, Execution_context.t Clock_event.t Events.t) Fieldslib.Field.t
      val cycle_num_jobs : (t, int tail) Fieldslib.Field.t
      val last_cycle_num_jobs : (t, int) Fieldslib.Field.t
      val cycle_times : (t, Core.Std.Time.Span.t tail) Fieldslib.Field.t
      val last_cycle_time : (t, Core.Std.Time.Span.t) Fieldslib.Field.t
      val cycle_start : (t, Core.Std.Time.t) Fieldslib.Field.t
      val cycle_count : (t, int) Fieldslib.Field.t
      val num_jobs_run : (t, int) Fieldslib.Field.t
      val uncaught_exn : (t, Core.Std.Error.t option) Fieldslib.Field.t
      val max_num_jobs_per_priority_per_cycle : (t, int) Fieldslib.Field.t
      val current_execution_context :
        (t, Execution_context.t) Fieldslib.Field.t
      val main_execution_context : (t, Execution_context.t) Fieldslib.Field.t
      val jobs :
        (t, Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque)
        Fieldslib.Field.t
      val check_access : (t, (unit -> unit) option) Fieldslib.Field.t
      val make_creator :
        check_access:((t, (unit -> unit) option) Fieldslib.Field.t ->
                      'a -> ('b -> (unit -> unit) option) * 'c) ->
        jobs:((t, Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque)
              Fieldslib.Field.t ->
              'c ->
              ('b -> Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque) *
              'd) ->
        main_execution_context:((t, Execution_context.t) Fieldslib.Field.t ->
                                'd -> ('b -> Execution_context.t) * 'e) ->
        current_execution_context:((t, Execution_context.t) Fieldslib.Field.t ->
                                   'e -> ('b -> Execution_context.t) * 'f) ->
        max_num_jobs_per_priority_per_cycle:((t, int) Fieldslib.Field.t ->
                                             'f -> ('b -> int) * 'g) ->
        uncaught_exn:((t, Core.Std.Error.t option) Fieldslib.Field.t ->
                      'g -> ('b -> Core.Std.Error.t option) * 'h) ->
        num_jobs_run:((t, int) Fieldslib.Field.t -> 'h -> ('b -> int) * 'i) ->
        cycle_count:((t, int) Fieldslib.Field.t -> 'i -> ('b -> int) * 'j) ->
        cycle_start:((t, Core.Std.Time.t) Fieldslib.Field.t ->
                     'j -> ('b -> Core.Std.Time.t) * 'k) ->
        last_cycle_time:((t, Core.Std.Time.Span.t) Fieldslib.Field.t ->
                         'k -> ('b -> Core.Std.Time.Span.t) * 'l) ->
        cycle_times:((t, Core.Std.Time.Span.t tail) Fieldslib.Field.t ->
                     'l -> ('b -> Core.Std.Time.Span.t tail) * 'm) ->
        last_cycle_num_jobs:((t, int) Fieldslib.Field.t ->
                             'm -> ('b -> int) * 'n) ->
        cycle_num_jobs:((t, int tail) Fieldslib.Field.t ->
                        'n -> ('b -> int tail) * 'o) ->
        events:((t, Execution_context.t Clock_event.t Events.t)
                Fieldslib.Field.t ->
                'o -> ('b -> Execution_context.t Clock_event.t Events.t) * 'p) ->
        finalizer_jobs:((t,
                         Execution_context.t Job.t
                         Core.Std.Thread_safe_queue.t Core.Std.sexp_opaque)
                        Fieldslib.Field.t ->
                        'p ->
                        ('b ->
                         Execution_context.t Job.t
                         Core.Std.Thread_safe_queue.t Core.Std.sexp_opaque) *
                        'q) ->
        thread_safe_finalizer_hook:((t, unit -> unit) Fieldslib.Field.t ->
                                    'q -> ('b -> unit -> unit) * 'r) ->
        'a -> ('b -> t) * 'r
      val create :
        check_access:(unit -> unit) option ->
        jobs:Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque ->
        main_execution_context:Execution_context.t ->
        current_execution_context:Execution_context.t ->
        max_num_jobs_per_priority_per_cycle:int ->
        uncaught_exn:Core.Std.Error.t option ->
        num_jobs_run:int ->
        cycle_count:int ->
        cycle_start:Core.Std.Time.t ->
        last_cycle_time:Core.Std.Time.Span.t ->
        cycle_times:Core.Std.Time.Span.t tail ->
        last_cycle_num_jobs:int ->
        cycle_num_jobs:int tail ->
        events:Execution_context.t Clock_event.t Events.t ->
        finalizer_jobs:Execution_context.t Job.t Core.Std.Thread_safe_queue.t
                       Core.Std.sexp_opaque ->
        thread_safe_finalizer_hook:(unit -> unit) -> t
      val iter :
        check_access:((t, (unit -> unit) option) Fieldslib.Field.t -> unit) ->
        jobs:((t, Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque)
              Fieldslib.Field.t -> unit) ->
        main_execution_context:((t, Execution_context.t) Fieldslib.Field.t ->
                                unit) ->
        current_execution_context:((t, Execution_context.t) Fieldslib.Field.t ->
                                   unit) ->
        max_num_jobs_per_priority_per_cycle:((t, int) Fieldslib.Field.t ->
                                             unit) ->
        uncaught_exn:((t, Core.Std.Error.t option) Fieldslib.Field.t -> unit) ->
        num_jobs_run:((t, int) Fieldslib.Field.t -> unit) ->
        cycle_count:((t, int) Fieldslib.Field.t -> unit) ->
        cycle_start:((t, Core.Std.Time.t) Fieldslib.Field.t -> unit) ->
        last_cycle_time:((t, Core.Std.Time.Span.t) Fieldslib.Field.t -> unit) ->
        cycle_times:((t, Core.Std.Time.Span.t tail) Fieldslib.Field.t -> unit) ->
        last_cycle_num_jobs:((t, int) Fieldslib.Field.t -> unit) ->
        cycle_num_jobs:((t, int tail) Fieldslib.Field.t -> unit) ->
        events:((t, Execution_context.t Clock_event.t Events.t)
                Fieldslib.Field.t -> unit) ->
        finalizer_jobs:((t,
                         Execution_context.t Job.t
                         Core.Std.Thread_safe_queue.t Core.Std.sexp_opaque)
                        Fieldslib.Field.t -> unit) ->
        thread_safe_finalizer_hook:((t, unit -> unit) Fieldslib.Field.t -> 'a) ->
        'a
      val fold :
        init:'a ->
        check_access:('a ->
                      (t, (unit -> unit) option) Fieldslib.Field.t -> 'b) ->
        jobs:('b ->
              (t, Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque)
              Fieldslib.Field.t -> 'c) ->
        main_execution_context:('c ->
                                (t, Execution_context.t) Fieldslib.Field.t ->
                                'd) ->
        current_execution_context:('d ->
                                   (t, Execution_context.t) Fieldslib.Field.t ->
                                   'e) ->
        max_num_jobs_per_priority_per_cycle:('e ->
                                             (t, int) Fieldslib.Field.t -> 'f) ->
        uncaught_exn:('f ->
                      (t, Core.Std.Error.t option) Fieldslib.Field.t -> 'g) ->
        num_jobs_run:('g -> (t, int) Fieldslib.Field.t -> 'h) ->
        cycle_count:('h -> (t, int) Fieldslib.Field.t -> 'i) ->
        cycle_start:('i -> (t, Core.Std.Time.t) Fieldslib.Field.t -> 'j) ->
        last_cycle_time:('j ->
                         (t, Core.Std.Time.Span.t) Fieldslib.Field.t -> 'k) ->
        cycle_times:('k ->
                     (t, Core.Std.Time.Span.t tail) Fieldslib.Field.t -> 'l) ->
        last_cycle_num_jobs:('l -> (t, int) Fieldslib.Field.t -> 'm) ->
        cycle_num_jobs:('m -> (t, int tail) Fieldslib.Field.t -> 'n) ->
        events:('n ->
                (t, Execution_context.t Clock_event.t Events.t)
                Fieldslib.Field.t -> 'o) ->
        finalizer_jobs:('o ->
                        (t,
                         Execution_context.t Job.t
                         Core.Std.Thread_safe_queue.t Core.Std.sexp_opaque)
                        Fieldslib.Field.t -> 'p) ->
        thread_safe_finalizer_hook:('p ->
                                    (t, unit -> unit) Fieldslib.Field.t -> 'q) ->
        'q
      val map :
        check_access:((t, (unit -> unit) option) Fieldslib.Field.t ->
                      (unit -> unit) option) ->
        jobs:((t, Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque)
              Fieldslib.Field.t ->
              Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque) ->
        main_execution_context:((t, Execution_context.t) Fieldslib.Field.t ->
                                Execution_context.t) ->
        current_execution_context:((t, Execution_context.t) Fieldslib.Field.t ->
                                   Execution_context.t) ->
        max_num_jobs_per_priority_per_cycle:((t, int) Fieldslib.Field.t ->
                                             int) ->
        uncaught_exn:((t, Core.Std.Error.t option) Fieldslib.Field.t ->
                      Core.Std.Error.t option) ->
        num_jobs_run:((t, int) Fieldslib.Field.t -> int) ->
        cycle_count:((t, int) Fieldslib.Field.t -> int) ->
        cycle_start:((t, Core.Std.Time.t) Fieldslib.Field.t ->
                     Core.Std.Time.t) ->
        last_cycle_time:((t, Core.Std.Time.Span.t) Fieldslib.Field.t ->
                         Core.Std.Time.Span.t) ->
        cycle_times:((t, Core.Std.Time.Span.t tail) Fieldslib.Field.t ->
                     Core.Std.Time.Span.t tail) ->
        last_cycle_num_jobs:((t, int) Fieldslib.Field.t -> int) ->
        cycle_num_jobs:((t, int tail) Fieldslib.Field.t -> int tail) ->
        events:((t, Execution_context.t Clock_event.t Events.t)
                Fieldslib.Field.t ->
                Execution_context.t Clock_event.t Events.t) ->
        finalizer_jobs:((t,
                         Execution_context.t Job.t
                         Core.Std.Thread_safe_queue.t Core.Std.sexp_opaque)
                        Fieldslib.Field.t ->
                        Execution_context.t Job.t
                        Core.Std.Thread_safe_queue.t Core.Std.sexp_opaque) ->
        thread_safe_finalizer_hook:((t, unit -> unit) Fieldslib.Field.t ->
                                    unit -> unit) ->
        t
      val map_poly : (t, 'a) Fieldslib.Field.user -> 'a list
      val for_all :
        check_access:((t, (unit -> unit) option) Fieldslib.Field.t -> bool) ->
        jobs:((t, Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque)
              Fieldslib.Field.t -> bool) ->
        main_execution_context:((t, Execution_context.t) Fieldslib.Field.t ->
                                bool) ->
        current_execution_context:((t, Execution_context.t) Fieldslib.Field.t ->
                                   bool) ->
        max_num_jobs_per_priority_per_cycle:((t, int) Fieldslib.Field.t ->
                                             bool) ->
        uncaught_exn:((t, Core.Std.Error.t option) Fieldslib.Field.t -> bool) ->
        num_jobs_run:((t, int) Fieldslib.Field.t -> bool) ->
        cycle_count:((t, int) Fieldslib.Field.t -> bool) ->
        cycle_start:((t, Core.Std.Time.t) Fieldslib.Field.t -> bool) ->
        last_cycle_time:((t, Core.Std.Time.Span.t) Fieldslib.Field.t -> bool) ->
        cycle_times:((t, Core.Std.Time.Span.t tail) Fieldslib.Field.t -> bool) ->
        last_cycle_num_jobs:((t, int) Fieldslib.Field.t -> bool) ->
        cycle_num_jobs:((t, int tail) Fieldslib.Field.t -> bool) ->
        events:((t, Execution_context.t Clock_event.t Events.t)
                Fieldslib.Field.t -> bool) ->
        finalizer_jobs:((t,
                         Execution_context.t Job.t
                         Core.Std.Thread_safe_queue.t Core.Std.sexp_opaque)
                        Fieldslib.Field.t -> bool) ->
        thread_safe_finalizer_hook:((t, unit -> unit) Fieldslib.Field.t ->
                                    bool) ->
        bool
      val exists :
        check_access:((t, (unit -> unit) option) Fieldslib.Field.t -> bool) ->
        jobs:((t, Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque)
              Fieldslib.Field.t -> bool) ->
        main_execution_context:((t, Execution_context.t) Fieldslib.Field.t ->
                                bool) ->
        current_execution_context:((t, Execution_context.t) Fieldslib.Field.t ->
                                   bool) ->
        max_num_jobs_per_priority_per_cycle:((t, int) Fieldslib.Field.t ->
                                             bool) ->
        uncaught_exn:((t, Core.Std.Error.t option) Fieldslib.Field.t -> bool) ->
        num_jobs_run:((t, int) Fieldslib.Field.t -> bool) ->
        cycle_count:((t, int) Fieldslib.Field.t -> bool) ->
        cycle_start:((t, Core.Std.Time.t) Fieldslib.Field.t -> bool) ->
        last_cycle_time:((t, Core.Std.Time.Span.t) Fieldslib.Field.t -> bool) ->
        cycle_times:((t, Core.Std.Time.Span.t tail) Fieldslib.Field.t -> bool) ->
        last_cycle_num_jobs:((t, int) Fieldslib.Field.t -> bool) ->
        cycle_num_jobs:((t, int tail) Fieldslib.Field.t -> bool) ->
        events:((t, Execution_context.t Clock_event.t Events.t)
                Fieldslib.Field.t -> bool) ->
        finalizer_jobs:((t,
                         Execution_context.t Job.t
                         Core.Std.Thread_safe_queue.t Core.Std.sexp_opaque)
                        Fieldslib.Field.t -> bool) ->
        thread_safe_finalizer_hook:((t, unit -> unit) Fieldslib.Field.t ->
                                    bool) ->
        bool
      val to_list :
        check_access:((t, (unit -> unit) option) Fieldslib.Field.t -> 'a) ->
        jobs:((t, Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque)
              Fieldslib.Field.t -> 'a) ->
        main_execution_context:((t, Execution_context.t) Fieldslib.Field.t ->
                                'a) ->
        current_execution_context:((t, Execution_context.t) Fieldslib.Field.t ->
                                   'a) ->
        max_num_jobs_per_priority_per_cycle:((t, int) Fieldslib.Field.t -> 'a) ->
        uncaught_exn:((t, Core.Std.Error.t option) Fieldslib.Field.t -> 'a) ->
        num_jobs_run:((t, int) Fieldslib.Field.t -> 'a) ->
        cycle_count:((t, int) Fieldslib.Field.t -> 'a) ->
        cycle_start:((t, Core.Std.Time.t) Fieldslib.Field.t -> 'a) ->
        last_cycle_time:((t, Core.Std.Time.Span.t) Fieldslib.Field.t -> 'a) ->
        cycle_times:((t, Core.Std.Time.Span.t tail) Fieldslib.Field.t -> 'a) ->
        last_cycle_num_jobs:((t, int) Fieldslib.Field.t -> 'a) ->
        cycle_num_jobs:((t, int tail) Fieldslib.Field.t -> 'a) ->
        events:((t, Execution_context.t Clock_event.t Events.t)
                Fieldslib.Field.t -> 'a) ->
        finalizer_jobs:((t,
                         Execution_context.t Job.t
                         Core.Std.Thread_safe_queue.t Core.Std.sexp_opaque)
                        Fieldslib.Field.t -> 'a) ->
        thread_safe_finalizer_hook:((t, unit -> unit) Fieldslib.Field.t -> 'a) ->
        'a list
      module Direct :
        sig
          val iter :
            t ->
            check_access:((t, (unit -> unit) option) Fieldslib.Field.t ->
                          t -> (unit -> unit) option -> unit) ->
            jobs:((t, Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque)
                  Fieldslib.Field.t ->
                  t ->
                  Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque ->
                  unit) ->
            main_execution_context:((t, Execution_context.t)
                                    Fieldslib.Field.t ->
                                    t -> Execution_context.t -> unit) ->
            current_execution_context:((t, Execution_context.t)
                                       Fieldslib.Field.t ->
                                       t -> Execution_context.t -> unit) ->
            max_num_jobs_per_priority_per_cycle:((t, int) Fieldslib.Field.t ->
                                                 t -> int -> unit) ->
            uncaught_exn:((t, Core.Std.Error.t option) Fieldslib.Field.t ->
                          t -> Core.Std.Error.t option -> unit) ->
            num_jobs_run:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
            cycle_count:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
            cycle_start:((t, Core.Std.Time.t) Fieldslib.Field.t ->
                         t -> Core.Std.Time.t -> unit) ->
            last_cycle_time:((t, Core.Std.Time.Span.t) Fieldslib.Field.t ->
                             t -> Core.Std.Time.Span.t -> unit) ->
            cycle_times:((t, Core.Std.Time.Span.t tail) Fieldslib.Field.t ->
                         t -> Core.Std.Time.Span.t tail -> unit) ->
            last_cycle_num_jobs:((t, int) Fieldslib.Field.t ->
                                 t -> int -> unit) ->
            cycle_num_jobs:((t, int tail) Fieldslib.Field.t ->
                            t -> int tail -> unit) ->
            events:((t, Execution_context.t Clock_event.t Events.t)
                    Fieldslib.Field.t ->
                    t -> Execution_context.t Clock_event.t Events.t -> unit) ->
            finalizer_jobs:((t,
                             Execution_context.t Job.t
                             Core.Std.Thread_safe_queue.t
                             Core.Std.sexp_opaque)
                            Fieldslib.Field.t ->
                            t ->
                            Execution_context.t Job.t
                            Core.Std.Thread_safe_queue.t Core.Std.sexp_opaque ->
                            unit) ->
            thread_safe_finalizer_hook:((t, unit -> unit) Fieldslib.Field.t ->
                                        t -> (unit -> unit) -> 'a) ->
            'a
          val fold :
            t ->
            init:'a ->
            check_access:('a ->
                          (t, (unit -> unit) option) Fieldslib.Field.t ->
                          t -> (unit -> unit) option -> 'b) ->
            jobs:('b ->
                  (t, Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque)
                  Fieldslib.Field.t ->
                  t ->
                  Execution_context.t Job.t Jobs.t Core.Std.sexp_opaque -> 'c) ->
            main_execution_context:('c ->
                                    (t, Execution_context.t)
                                    Fieldslib.Field.t ->
                                    t -> Execution_context.t -> 'd) ->
            current_execution_context:('d ->
                                       (t, Execution_context.t)
                                       Fieldslib.Field.t ->
                                       t -> Execution_context.t -> 'e) ->
            max_num_jobs_per_priority_per_cycle:('e ->
                                                 (t, int) Fieldslib.Field.t ->
                                                 t -> int -> 'f) ->
            uncaught_exn:('f ->
                          (t, Core.Std.Error.t option) Fieldslib.Field.t ->
                          t -> Core.Std.Error.t option -> 'g) ->
            num_jobs_run:('g -> (t, int) Fieldslib.Field.t -> t -> int -> 'h) ->
            cycle_count:('h -> (t, int) Fieldslib.Field.t -> t -> int -> 'i) ->
            cycle_start:('i ->
                         (t, Core.Std.Time.t) Fieldslib.Field.t ->
                         t -> Core.Std.Time.t -> 'j) ->
            last_cycle_time:('j ->
                             (t, Core.Std.Time.Span.t) Fieldslib.Field.t ->
                             t -> Core.Std.Time.Span.t -> 'k) ->
            cycle_times:('k ->
                         (t, Core.Std.Time.Span.t tail) Fieldslib.Field.t ->
                         t -> Core.Std.Time.Span.t tail -> 'l) ->
            last_cycle_num_jobs:('l ->
                                 (t, int) Fieldslib.Field.t -> t -> int -> 'm) ->
            cycle_num_jobs:('m ->
                            (t, int tail) Fieldslib.Field.t ->
                            t -> int tail -> 'n) ->
            events:('n ->
                    (t, Execution_context.t Clock_event.t Events.t)
                    Fieldslib.Field.t ->
                    t -> Execution_context.t Clock_event.t Events.t -> 'o) ->
            finalizer_jobs:('o ->
                            (t,
                             Execution_context.t Job.t
                             Core.Std.Thread_safe_queue.t
                             Core.Std.sexp_opaque)
                            Fieldslib.Field.t ->
                            t ->
                            Execution_context.t Job.t
                            Core.Std.Thread_safe_queue.t Core.Std.sexp_opaque ->
                            'p) ->
            thread_safe_finalizer_hook:('p ->
                                        (t, unit -> unit) Fieldslib.Field.t ->
                                        t -> (unit -> unit) -> 'q) ->
            'q
        end
    end
  val invariant : t -> unit
  val create : unit -> t
  val set_check_access : t -> (unit -> unit) -> unit
  val t_ref : t ref
  val check_access : t -> unit
  val t : unit -> t
  val current_execution_context : t -> Execution_context.t
  val set_execution_context : t -> Execution_context.t -> unit
  val with_execution_context :
    t -> Execution_context.t -> f:(unit -> 'a) -> 'a
  val add_job : t -> Execution_context.t Job.t -> unit
  val got_uncaught_exn : t -> Core.Std.Error.t -> unit
  val ounit_tests : unit -> OUnit.test
end