Module Arrayjit.Utils

module Set_O : sig ... end
val no_ints : (Base.Int.t, Base.Int.comparator_witness) Base.Set.t
val one_int : Base.Int.t -> (Base.Int.t, Base.Int.comparator_witness) Base.Set.t
val map_merge : ('a, 'b, 'c) Base.Map.t -> ('a, 'b, 'c) Base.Map.t -> f:('b -> 'b -> 'b) -> ('a, 'b, 'c) Base.Map.t
val mref_add : ('a, 'b, 'c) Base.Map.t Base.ref -> key:'a -> data:'b -> or_:('b -> Base.unit) -> Base.unit
val mref_add_missing : ('a, 'b, 'c) Base.Map.t Base.ref -> 'a -> f:(unit -> 'b) -> Base.unit
type settings = {
  1. mutable log_level : Base.int;
  2. mutable debug_log_from_routines : Base.bool;
    (*

    If the debug_log_from_routines flag is true _and_ the flag log_level > 1, backends should generate code (e.g. fprintf statements) to log the execution, and arrange for the logs to be emitted via ppx_minidebug.

    *)
  3. mutable output_debug_files_in_build_directory : Base.bool;
    (*

    Writes compilation related files in the build_files subdirectory of the run directory (additional files, or files that would otherwise be in temp directory). When both output_debug_files_in_build_directory = true and log_level > 1, compilation should also preserve debug and line information for runtime debugging.

    *)
  4. mutable fixed_state_for_init : Base.int Base.option;
  5. mutable print_decimals_precision : Base.int;
    (*

    When rendering arrays etc., outputs this many decimal digits.

    *)
  6. mutable check_half_prec_constants_cutoff : Base.float Base.option;
    (*

    If given, generic code optimization should fail if a half precision FP16 constant exceeds the cutoff.

    *)
  7. mutable automatic_host_transfers : Base.bool;
    (*

    If true, from_host and to_host happen automatically in specific situations.

    • When a host array is about to be read, we transfer to host from the context that most recently updated the node.
    • When a routine is about to be run, we transfer the routine's inputs from host to the routine's context if the host array was not yet transfered since its creation or most recent modification.
    *)
}
val settings_of_sexp : Sexplib0.Sexp.t -> settings
val sexp_of_settings : settings -> Sexplib0.Sexp.t
val settings : settings
val accessed_global_args : Base.String.t Base.Hash_set.t
val str_nonempty : f:(Base.String.t -> 'a) -> Base.String.t -> 'a option
val pair : 'a -> 'b -> 'a * 'b
val read_cmdline_or_env_var : Base.string -> Base.String.t option
val filename_parts : string -> string list
val filename_of_parts : string list -> string
val config_file_args : (Base.String.t, Base.String.t) Base.Hashtbl.t
val get_global_arg : default:Base.String.t -> arg_name:Base.string -> Base.String.t

Retrieves arg_name argument from the command line or from an environment variable, returns default if none found.

val original_log_level : Base.Int.t
val filename_concat : Base.String.t -> Base.String.t -> Base.String.t
val build_file : Base.String.t -> Base.String.t
val diagn_log_file : Base.String.t -> Base.String.t
val get_local_debug_runtime : unit -> (module Minidebug_runtime.Debug_runtime)
val _get_local_debug_runtime : unit -> (module Minidebug_runtime.Debug_runtime)
val set_log_level : Base.int -> unit
val restore_settings : unit -> unit
val with_runtime_debug : unit -> Base.bool
val debug_log_from_routines : unit -> Base.bool
val never_capture_stdout : unit -> Base.Bool.t
val enable_runtime_debug : unit -> unit
val union_find : equal:('a -> 'a -> bool) -> ('a, 'a, 'b) Base.Map.t -> key:'a -> rank:Base__Int.t -> 'a * Base__Int.t
val union_add : equal:('a -> 'a -> bool) -> ('a, 'a, 'b) Base.Map.t -> 'a -> 'a -> ('a, 'a, 'b) Base.Map.t
val unique_keep_first : equal:('a -> 'a -> bool) -> 'a list -> 'a Base.List.t

Filters the list keeping the first occurrence of each element.

val sorted_diff : compare:('a -> 'b -> int) -> 'a Base.List.t -> 'b list -> 'a Base.List.t
val parallel_merge : (from:Base__Int.t -> to_:Base__Int.t -> unit) -> Base.int -> Base.unit

parallel_merge merge num_devices progressively invokes the pairwise merge callback, converging on the 0th position, with from ranging from 1 to num_devices - 1, and to_ < from.

val (!@) : 'a Stdlib.Atomic.t -> 'a
type atomic_bool = Base.bool Stdlib.Atomic.t
val sexp_of_atomic_bool : Base.bool Stdlib.Atomic.t -> Sexplib0.Sexp.t
type atomic_int = Base.int Stdlib.Atomic.t
val sexp_of_atomic_int : Base.int Stdlib.Atomic.t -> Sexplib0.Sexp.t
val sexp_append : elem:Base.Sexp.t -> Base.Sexp.t -> Base.Sexp.t
val sexp_mem : elem:Base.Sexp.t -> Base.Sexp.t -> bool
val sexp_deep_mem : elem:Base.Sexp.t -> Base.Sexp.t -> Base.bool
val split_with_seps : Re.re -> string -> string Base.List.t
module Lazy : sig ... end
type requirement =
  1. | Skip
  2. | Required
  3. | Optional of {
    1. callback_if_missing : Base.unit -> Base.unit;
    }
val compare_requirement : requirement -> requirement -> Base.int
val requirement_of_sexp : Sexplib0.Sexp.t -> requirement
val sexp_of_requirement : requirement -> Sexplib0.Sexp.t
val get_debug_formatter : fname:Base.String.t -> Stdlib.Format.formatter option
exception User_error of Base.string
val header_sep : Re.re
val log_trace_tree : Base.String.t Base.List.t -> unit
type 'a mutable_list =
  1. | Empty
  2. | Cons of {
    1. hd : 'a;
    2. mutable tl : 'a mutable_list;
    }
val equal_mutable_list : 'a. ('a -> 'a -> Base.bool) -> 'a mutable_list -> 'a mutable_list -> Base.bool
val mutable_list_of_sexp : 'a. (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a mutable_list
val sexp_of_mutable_list : 'a. ('a -> Sexplib0.Sexp.t) -> 'a mutable_list -> Sexplib0.Sexp.t
val empty : 'a mutable_list
val cons : hd:'a -> tl:'a mutable_list -> 'a mutable_list
val is_empty : 'a mutable_list -> bool
val is_cons : 'a mutable_list -> bool
val empty_val : 'a mutable_list -> unit Stdlib.Option.t
val cons_val : 'a mutable_list -> ([> `hd of 'a ] * [> `tl of 'a mutable_list ]) Stdlib.Option.t
module Variants_of_mutable_list : sig ... end
val insert : next:'a -> 'a mutable_list -> 'a mutable_list
val tl_exn : 'a mutable_list -> 'a mutable_list
type pp_file = {
  1. f_name : Base.string;
  2. ppf : Stdlib.Format.formatter;
  3. finalize : Base.unit -> Base.unit;
}
val pp_file : base_name:Base.String.t -> extension:Base.String.t -> pp_file
val captured_log_prefix : string Base.ref
val advance_captured_logs : (unit -> unit) option Base.ref

To avoid the complication of a concurrent thread, we expose a callback for collaborative log processing.

type captured_log_processor = {
  1. log_processor_prefix : Base.string;
  2. process_logs : Base.string Base.list -> Base.unit;
}
val captured_log_processors : captured_log_processor Base.list Base.ref
val add_log_processor : prefix:Base.string -> (Base.string Base.list -> Base.unit) -> Base.unit
val input_scan_line : Stdlib.in_channel -> Base.int
val input_line : Stdlib.in_channel -> bool * Base.String.t
val capture_stdout_logs : (unit -> 'a) -> 'a
type 'a weak_dynarray = 'a Stdlib.Weak.t Base.ref
val weak_create : unit -> 'a weak_dynarray
val sexp_of_weak_dynarray : ('a -> Sexplib0.Sexp.t) -> 'a Stdlib.Weak.t Base.ref -> Sexplib0.Sexp.t
val register_new : 'a weak_dynarray -> ?grow_by:Base__Int.t -> (int -> 'a) -> 'a
val weak_iter : 'a weak_dynarray -> f:('a -> unit) -> unit