Lowered_backend_missing (arrayjit.Arrayjit.Lowered_backend

include Backend_impl.Lowered_backend

include Backend_intf.Backend_device_common

include Backend_intf.Device

include Backend_intf.Device_types

include Backend_intf.Device_config

include Backend_intf.Buffer

type buffer_ptr

include sig ... end

type dev

Interface to a device driver.

type runner

Interface to a stream driver.

type event

An event tracks if a stream finished computing past a particular point in its schedue. These values are used internally for scheduling across streams of the backend, and can be used for explicit scheduling.

include Backend_intf.Alloc_buffer
  with type buffer_ptr := buffer_ptr
   and type stream := (buffer_ptr, dev, runner, event) Backend_intf.stream

include Backend_intf.Buffer with type buffer_ptr := buffer_ptr

include sig ... end

include Backend_intf.Backend_any_common with type buffer_ptr := buffer_ptr

include Backend_intf.Buffer with type buffer_ptr := buffer_ptr

include sig ... end

include Backend_impl.No_buffer_retrieval_or_syncing
  with type buffer_ptr := buffer_ptr
   and type dev := dev
   and type runner := runner
   and type event := event

include Backend_impl.Backend_impl_common with type buffer_ptr := buffer_ptr

include Backend_intf.Buffer with type buffer_ptr := buffer_ptr

include sig ... end

val use_host_memory : (Base.unit Ctypes.ptr -> buffer_ptr) Base.option

If not None, the backend will read from and write to the host memory directly whenever reasonable.

use_host_memory can only be Some on unified memory devices, like CPU and Apple Metal.

include Backend_intf.Backend_device_common
  with type buffer_ptr := buffer_ptr
  with type dev := dev
  with type runner := runner
  with type event := event

include Backend_intf.Device
  with type buffer_ptr := buffer_ptr
  with type dev := dev
  with type runner := runner
  with type event := event

include Backend_intf.Device_types
  with type buffer_ptr := buffer_ptr
  with type dev := dev
  with type runner := runner
  with type event := event

include Backend_intf.Device_config
  with type buffer_ptr := buffer_ptr
  with type dev := dev
  with type runner := runner
  with type event := event

include Backend_intf.Buffer with type buffer_ptr := buffer_ptr

include sig ... end

val sexp_of_dev : dev -> Sexplib0.Sexp.t

val sexp_of_runner : runner -> Sexplib0.Sexp.t

val sexp_of_event : event -> Sexplib0.Sexp.t

val name : Base.string

type nonrec device = (buffer_ptr, dev, runner, event) Backend_intf.device

val sexp_of_device : device -> Sexplib0.Sexp.t

type nonrec stream = (buffer_ptr, dev, runner, event) Backend_intf.stream

val sexp_of_stream : stream -> Sexplib0.Sexp.t

type nonrec context = (buffer_ptr, stream) Backend_intf.context

val sexp_of_context : context -> Sexplib0.Sexp.t

include Backend_intf.Alloc_buffer
  with type buffer_ptr := buffer_ptr
   and type stream := stream

include Backend_intf.Buffer with type buffer_ptr := buffer_ptr

include sig ... end

val alloc_buffer : 
  ?old_buffer:buffer_ptr Backend_intf.buffer ->
  size_in_bytes:Base.int ->
  stream ->
  buffer_ptr Backend_intf.buffer

val alloc_zero_init_array : 
  Ops.prec ->
  dims:Base.int Base.array ->
  stream ->
  buffer_ptr

val free_buffer : (stream -> buffer_ptr -> Base.unit) Base.option

val make_device : dev -> ordinal:Base.int -> device

val make_stream : device -> runner -> stream

val make_context : 
  ?ctx_arrays:buffer_ptr Backend_intf.ctx_arrays ->
  stream ->
  context

Returns a context without a parent.

val make_child : 
  ?ctx_arrays:buffer_ptr Backend_intf.ctx_arrays ->
  context ->
  context

Returns a context with the same stream, and ctx_arrays if omitted, as the given context's, which is also the parent.

val get_name : stream -> Base.string

include Backend_intf.Backend_any_common with type buffer_ptr := buffer_ptr

include Backend_intf.Buffer with type buffer_ptr := buffer_ptr

val sexp_of_buffer_ptr : buffer_ptr -> Sexplib0.Sexp.t

include sig ... end

type nonrec buffer = buffer_ptr Backend_intf.buffer

val sexp_of_buffer : buffer -> Sexplib0.Sexp.t

type nonrec ctx_arrays = buffer_ptr Backend_intf.ctx_arrays

val sexp_of_ctx_arrays : ctx_arrays -> Sexplib0.Sexp.t

val initialize : Backend_intf.config -> Base.unit

Initializes a backend before first use. Typically does nothing if the backend is already initialized, but some backends can do some safe cleanups.

val is_initialized : Base.unit -> Base.bool

Returns false if there was no previous initialize call. If it returns false, one must call initialize before using the backend.

val sync : event -> Base.unit

Blocks till the event completes, if it's not done already.

It is rarely needed to call sync explicitly, because it should always be called internally when necessary, in particular before extracting values from host.

val is_done : event -> Base.bool

Whether the event completed.

val will_wait_for : context -> event -> Base.unit

Schedules waiting for the given event on the context's stream.

NOTE: it should rarely be needed to call will_wait_for explicitly, because it should always be called internally when necessary.

val get_used_memory : device -> Base.int

Returns (an upper bound of) the memory used for arrays, in bytes.

val get_global_debug_info : Base.unit -> Base.Sexp.t

Global debug information; backend-specific and might evolve independently on the backends.

val get_debug_info : stream -> Base.Sexp.t

Per-stream debug information; backend-specific and might evolve independently on the backends

val await : stream -> Base.unit

Blocks till the stream becomes idle, i.e. synchronizes the stream.

val all_work : stream -> event

Returns the event indicating if any currently running or scheduled computations on the stream have completed.

val is_idle : stream -> Base.bool

Whether the stream is currently waiting for work.

val get_device : ordinal:Base.int -> device

val num_devices : Base.unit -> Base.int

val suggested_num_streams : device -> Base.int

The optimal number of streams for the given device to follow the config strategy.

val new_stream : device -> stream

val from_host : dst_ptr:buffer_ptr -> dst:context -> Ndarray.t -> Base.unit

Like Backend.from_host, but without synchronization and buffer retrieval.

val to_host : src_ptr:buffer_ptr -> src:context -> Ndarray.t -> Base.unit

Like Backend.to_host, but without synchronization events and buffer retrieval.

val device_to_device : 
  Tnode.t ->
  into_merge_buffer:Backend_intf.merge_buffer_use ->
  dst_ptr:buffer_ptr Base.option ->
  dst:context ->
  src_ptr:buffer_ptr ->
  src:context ->
  Base.unit

Like Backend.device_to_device, but without synchronization events and buffer retrieval. Raises Invalid_argument if into_merge_buffer = No and dst_ptr = None.

type code

val sexp_of_code : code -> Sexplib0.Sexp.t

type code_batch

val sexp_of_code_batch : code_batch -> Sexplib0.Sexp.t

val compile : 
  name:Base.string ->
  Indexing.unit_bindings ->
  Low_level.optimized ->
  code

val compile_batch : 
  names:Base.string Base.option Base.array ->
  Indexing.unit_bindings ->
  Low_level.optimized Base.option Base.array ->
  code_batch

val link : context -> code -> ctx_arrays -> Indexing.lowered_bindings * Task.t

context is the prior context, while ctx_arrays are the arrays of the resulting context. The results correspond to the fields Backend_intf.routine.bindings and Backend_intf.routine.schedule of Backend_intf.routine.

val link_batch : 
  context ->
  code_batch ->
  ctx_arrays Base.option Base.array ->
  Indexing.lowered_bindings * Task.t Base.option Base.array

context is the prior context, while the ctx_arrays are the arrays of the resulting contexts. Returns the schedule tasks for the procedures included in the code batch.