Module Raw_scheduler

module Raw_scheduler: sig .. end

val __pa_ounit_275876e34cf609db118f3d84b799a790 : string

module Core_scheduler: Async_core.Scheduler

module Fd: Raw_fd

module Watching: Fd.Watching

module Signal: Core.Signal

val debug : bool

module type File_descr_watcher = File_descr_watcher_intf.S

val file_descr_watcher : t -> File_descr_watcher.t

module File_descr_watcher:  (val ... 

type 'a with_options = 'a Core_scheduler.with_options 

include struct ... end

val cycle_count : unit -> int

val cycle_start : unit -> Core.Std.Time.t

val cycle_times : unit -> Core.Std.Time.Span.t Async_core.Async_stream.t

val set_max_num_jobs_per_priority_per_cycle : int -> unit

val force_current_cycle_to_end : unit -> unit

type t = {

val sexp_of_t : t -> Sexplib.Sexp.t

val core_scheduler : t -> Core_scheduler.t

val thread_pool : t -> Import.Thread_pool.t

val signal_manager : t -> Raw_signal_manager.t

val interruptor : t -> Interruptor.t

val scheduler_thread_id : t -> int

val set_scheduler_thread_id : t -> int -> unit

val fd_by_descr : t -> Fd_by_descr.t

val file_descr_watcher : t -> File_descr_watcher.t

val fds_whose_watching_has_changed : t -> Fd.t list

val set_fds_whose_watching_has_changed : t -> Fd.t list -> unit

val have_called_go : t -> bool

val set_have_called_go : t -> bool -> unit

val is_running : unit -> bool

val set_is_running : t -> bool -> unit

val mutex : t -> Core.Std.Nano_mutex.t

module Fields: sig .. end

val current_execution_context : t -> Async_core.Execution_context.t

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

val preserve_execution_context : t -> ('a -> unit) -> ('a -> unit) Core.Std.Staged.t

val create_fd : t ->
       Fd.Kind.t ->
       Core.Unix.File_descr.t -> Core.Std.Info.t -> Fd.t

val lock : t -> unit

val try_lock : t -> bool

val unlock : t -> unit

val with_lock : t -> (unit -> 'a) -> 'a

val am_holding_lock : t -> bool

type the_one_and_only = 

val mutex_for_initializing_the_one_and_only_ref : Core.Std.Nano_mutex.t

val the_one_and_only_ref : the_one_and_only Pervasives.ref

val is_ready_to_initialize : unit -> bool

val the_one_and_only_uncommon_case : should_lock:bool -> t

val the_one_and_only : should_lock:bool -> t

val current_thread_id : unit -> int

val is_main_thread : unit -> bool

val remove_fd : t -> Raw_fd.t -> unit

val maybe_start_closing_fd : t -> Fd.t -> unit

val dec_num_active_syscalls_fd : t -> Fd.t -> unit

val invariant : t -> unit

val create : unit -> t

val init : unit -> unit

val reset_in_forked_process : unit -> unit

val thread_safe_wakeup_scheduler : t -> unit

val i_am_the_scheduler : t -> bool

val have_lock_do_cycle : t -> unit

val set_fd_desired_watching : t ->
       Fd.t -> Read_write.Key.t -> Fd.Watching.t -> unit

val request_start_watching : t ->
       Fd.t ->
       Read_write.Key.t ->
       [> `Already_closed
        | `Already_watching
        | `Unsupported
        | `Watching of Fd.ready_to_result Import.Ivar.t ]

val request_stop_watching : t ->
       Fd.t ->
       Read_write.Key.t -> Fd.ready_to_result -> unit

val sync_changed_fds_to_file_descr_watcher : t -> unit

val be_the_scheduler : ?raise_unhandled_exn:bool -> t -> 'a

val add_finalizer : t ->
       'a Core.Std.Heap_block.t -> ('a Core.Std.Heap_block.t -> unit) -> unit

val add_finalizer_exn : t -> 'a -> ('a -> unit) -> unit

val go : ?raise_unhandled_exn:bool -> unit -> Core.Std_internal.never_returns

val go_main : ?raise_unhandled_exn:bool ->
       main:(unit -> unit) -> unit -> Core.Std_internal.never_returns

val is_running : unit -> bool

val report_long_cycle_times : ?cutoff:Core.Std.Time.Span.t -> unit -> unit

type 'b folder = {

val t : unit -> t

val fold_fields : init:'a -> 'a folder -> 'a