mpi 1.05 · OCaml Package

exception Error of string

type communicator

type rank = int

val comm_world : communicator

val comm_size : communicator -> int

val comm_rank : communicator -> rank

type tag = int

val send : 'a -> rank -> tag -> communicator -> unit

val receive : rank -> tag -> communicator -> 'a

val receive_status : rank -> tag -> communicator -> 'a * rank * tag

val probe : rank -> tag -> communicator -> rank * tag

val iprobe : rank -> tag -> communicator -> (rank * tag) option

val any_tag : tag

val any_source : rank

val send_int : int -> rank -> tag -> communicator -> unit

val receive_int : rank -> tag -> communicator -> int

val send_float : float -> rank -> tag -> communicator -> unit

val receive_float : rank -> tag -> communicator -> float

val send_int_array : int array -> rank -> tag -> communicator -> unit

val receive_int_array : int array -> rank -> tag -> communicator -> unit

val send_float_array : float array -> rank -> tag -> communicator -> unit

val receive_float_array : float array -> rank -> tag -> communicator -> unit

val send_bigarray : 
  ('a, 'b, 'c) Bigarray.Genarray.t ->
  rank ->
  tag ->
  communicator ->
  unit

val send_bigarray0 : 
  ('a, 'b, 'c) Bigarray.Array0.t ->
  rank ->
  tag ->
  communicator ->
  unit

val send_bigarray1 : 
  ('a, 'b, 'c) Bigarray.Array1.t ->
  rank ->
  tag ->
  communicator ->
  unit

val send_bigarray2 : 
  ('a, 'b, 'c) Bigarray.Array2.t ->
  rank ->
  tag ->
  communicator ->
  unit

val send_bigarray3 : 
  ('a, 'b, 'c) Bigarray.Array3.t ->
  rank ->
  tag ->
  communicator ->
  unit

val receive_bigarray : 
  ('a, 'b, 'c) Bigarray.Genarray.t ->
  rank ->
  tag ->
  communicator ->
  unit

val receive_bigarray0 : 
  ('a, 'b, 'c) Bigarray.Array0.t ->
  rank ->
  tag ->
  communicator ->
  unit

val receive_bigarray1 : 
  ('a, 'b, 'c) Bigarray.Array1.t ->
  rank ->
  tag ->
  communicator ->
  unit

val receive_bigarray2 : 
  ('a, 'b, 'c) Bigarray.Array2.t ->
  rank ->
  tag ->
  communicator ->
  unit

val receive_bigarray3 : 
  ('a, 'b, 'c) Bigarray.Array3.t ->
  rank ->
  tag ->
  communicator ->
  unit

type request

val null_request : request

val isend : 'a -> rank -> tag -> communicator -> request

val isend_varlength : 'a -> rank -> tag -> communicator -> request * request

val ireceive : int -> rank -> tag -> communicator -> request

val ireceive_varlength : rank -> tag -> communicator -> request

val wait : request -> unit

val wait_pair : (request * request) -> unit

val wait_receive : request -> 'a

val barrier : communicator -> unit

val broadcast : 'a -> rank -> communicator -> 'a

val broadcast_opt : 'a option -> rank -> communicator -> 'a

val broadcast_int : int -> rank -> communicator -> int

val broadcast_float : float -> rank -> communicator -> float

val broadcast_int_array : int array -> rank -> communicator -> unit

val broadcast_float_array : float array -> rank -> communicator -> unit

val broadcast_bigarray : 
  ('a, 'b, 'c) Bigarray.Genarray.t ->
  rank ->
  communicator ->
  unit

val broadcast_bigarray0 : 
  ('a, 'b, 'c) Bigarray.Array0.t ->
  rank ->
  communicator ->
  unit

val broadcast_bigarray1 : 
  ('a, 'b, 'c) Bigarray.Array1.t ->
  rank ->
  communicator ->
  unit

val broadcast_bigarray2 : 
  ('a, 'b, 'c) Bigarray.Array2.t ->
  rank ->
  communicator ->
  unit

val broadcast_bigarray3 : 
  ('a, 'b, 'c) Bigarray.Array3.t ->
  rank ->
  communicator ->
  unit

val scatter : 'a array -> rank -> communicator -> 'a

val scatter_int : int array -> rank -> communicator -> int

val scatter_float : float array -> rank -> communicator -> float

val scatter_from_bigarray : 
  ('a, 'b, 'c) Bigarray.Genarray.t ->
  rank ->
  communicator ->
  'a

val scatter_from_bigarray1 : 
  ('a, 'b, 'c) Bigarray.Array1.t ->
  rank ->
  communicator ->
  'a

val scatter_from_bigarray2 : 
  ('a, 'b, 'c) Bigarray.Array2.t ->
  rank ->
  communicator ->
  'a

val scatter_from_bigarray3 : 
  ('a, 'b, 'c) Bigarray.Array3.t ->
  rank ->
  communicator ->
  'a

val scatter_int_array : int array -> int array -> rank -> communicator -> unit

val scatter_float_array : 
  float array ->
  float array ->
  rank ->
  communicator ->
  unit

val scatter_bigarray : 
  ('a, 'b, 'c) Bigarray.Genarray.t ->
  ('a, 'b, 'c) Bigarray.Genarray.t ->
  rank ->
  communicator ->
  unit

val scatter_bigarray1 : 
  ('a, 'b, 'c) Bigarray.Array1.t ->
  ('a, 'b, 'c) Bigarray.Array1.t ->
  rank ->
  communicator ->
  unit

val gather : 'a -> rank -> communicator -> 'a array

val gather_int : int -> int array -> rank -> communicator -> unit

val gather_float : float -> float array -> rank -> communicator -> unit

val gather_to_bigarray : 
  'a ->
  ('a, 'b, 'c) Bigarray.Genarray.t ->
  rank ->
  communicator ->
  unit

val gather_to_bigarray1 : 
  'a ->
  ('a, 'b, 'c) Bigarray.Array1.t ->
  rank ->
  communicator ->
  unit

val gather_to_bigarray2 : 
  'a ->
  ('a, 'b, 'c) Bigarray.Array2.t ->
  rank ->
  communicator ->
  unit

val gather_to_bigarray3 : 
  'a ->
  ('a, 'b, 'c) Bigarray.Array3.t ->
  rank ->
  communicator ->
  unit

val gather_int_array : int array -> int array -> rank -> communicator -> unit

val gather_float_array : 
  float array ->
  float array ->
  rank ->
  communicator ->
  unit

val gather_bigarray : 
  ('a, 'b, 'c) Bigarray.Genarray.t ->
  ('a, 'b, 'c) Bigarray.Genarray.t ->
  rank ->
  communicator ->
  unit

val gather_bigarray1 : 
  ('a, 'b, 'c) Bigarray.Array1.t ->
  ('a, 'b, 'c) Bigarray.Array1.t ->
  rank ->
  communicator ->
  unit

val allgather : 'a -> communicator -> 'a array

val allgather_int : int -> int array -> communicator -> unit

val allgather_float : float -> float array -> communicator -> unit

val allgather_to_bigarray : 
  'a ->
  ('a, 'b, 'c) Bigarray.Genarray.t ->
  communicator ->
  unit

val allgather_to_bigarray1 : 
  'a ->
  ('a, 'b, 'c) Bigarray.Array1.t ->
  communicator ->
  unit

val allgather_to_bigarray2 : 
  'a ->
  ('a, 'b, 'c) Bigarray.Array2.t ->
  communicator ->
  unit

val allgather_to_bigarray3 : 
  'a ->
  ('a, 'b, 'c) Bigarray.Array3.t ->
  communicator ->
  unit

val allgather_int_array : int array -> int array -> communicator -> unit

val allgather_float_array : float array -> float array -> communicator -> unit

val allgather_bigarray : 
  ('a, 'b, 'c) Bigarray.Genarray.t ->
  ('a, 'b, 'c) Bigarray.Genarray.t ->
  communicator ->
  unit

val allgather_bigarray1 : 
  ('a, 'b, 'c) Bigarray.Array1.t ->
  ('a, 'b, 'c) Bigarray.Array1.t ->
  communicator ->
  unit

val alltoall : 'a array -> communicator -> 'a array

val alltoall_int_array : int array -> int array -> communicator -> unit

val alltoall_float_array : float array -> float array -> communicator -> unit

val alltoall_bigarray : 
  ('a, 'b, 'c) Bigarray.Genarray.t ->
  ('a, 'b, 'c) Bigarray.Genarray.t ->
  communicator ->
  unit

val alltoall_bigarray1 : 
  ('a, 'b, 'c) Bigarray.Array1.t ->
  ('a, 'b, 'c) Bigarray.Array1.t ->
  communicator ->
  unit

val alltoall_bigarray2 : 
  ('a, 'b, 'c) Bigarray.Array2.t ->
  ('a, 'b, 'c) Bigarray.Array2.t ->
  communicator ->
  unit

val alltoall_bigarray3 : 
  ('a, 'b, 'c) Bigarray.Array3.t ->
  ('a, 'b, 'c) Bigarray.Array3.t ->
  communicator ->
  unit

type !_ op =

| Max : [< `Float | `Int ] op
| Min : [< `Float | `Int ] op
| Sum : [< `Float | `Int ] op
| Prod : [< `Float | `Int ] op
| Land : [< `Int ] op
| Lor : [< `Int ] op
| Xor : [< `Int ] op
| Int_max : [< `Int ] op
| Int_min : [< `Int ] op
| Int_sum : [< `Int ] op
| Int_prod : [< `Int ] op
| Int_land : [< `Int ] op
| Int_lor : [< `Int ] op
| Int_xor : [< `Int ] op
| Float_max : [< `Float ] op
| Float_min : [< `Float ] op
| Float_sum : [< `Float ] op
| Float_prod : [< `Float ] op

val reduce_int : int -> [ `Int ] op -> rank -> communicator -> int

val reduce_float : float -> [ `Float ] op -> rank -> communicator -> float

val reduce_int_array : 
  int array ->
  int array ->
  [ `Int ] op ->
  rank ->
  communicator ->
  unit

val reduce_float_array : 
  float array ->
  float array ->
  [ `Float ] op ->
  rank ->
  communicator ->
  unit

val reduce_bigarray : 
  ('a, 'b, 'c) Bigarray.Genarray.t ->
  ('a, 'b, 'c) Bigarray.Genarray.t ->
  'any op ->
  rank ->
  communicator ->
  unit

val reduce_bigarray0 : 
  ('a, 'b, 'c) Bigarray.Array0.t ->
  ('a, 'b, 'c) Bigarray.Array0.t ->
  'any op ->
  rank ->
  communicator ->
  unit

val reduce_bigarray1 : 
  ('a, 'b, 'c) Bigarray.Array1.t ->
  ('a, 'b, 'c) Bigarray.Array1.t ->
  'any op ->
  rank ->
  communicator ->
  unit

val reduce_bigarray2 : 
  ('a, 'b, 'c) Bigarray.Array2.t ->
  ('a, 'b, 'c) Bigarray.Array2.t ->
  'any op ->
  rank ->
  communicator ->
  unit

val reduce_bigarray3 : 
  ('a, 'b, 'c) Bigarray.Array3.t ->
  ('a, 'b, 'c) Bigarray.Array3.t ->
  'any op ->
  rank ->
  communicator ->
  unit

val allreduce_int : int -> [ `Int ] op -> communicator -> int

val allreduce_float : float -> [ `Float ] op -> communicator -> float

val allreduce_int_array : 
  int array ->
  int array ->
  [ `Int ] op ->
  communicator ->
  unit

val allreduce_float_array : 
  float array ->
  float array ->
  [ `Float ] op ->
  communicator ->
  unit

val allreduce_bigarray : 
  ('a, 'b, 'c) Bigarray.Genarray.t ->
  ('a, 'b, 'c) Bigarray.Genarray.t ->
  'any op ->
  communicator ->
  unit

val allreduce_bigarray0 : 
  ('a, 'b, 'c) Bigarray.Array0.t ->
  ('a, 'b, 'c) Bigarray.Array0.t ->
  'any op ->
  communicator ->
  unit

val allreduce_bigarray1 : 
  ('a, 'b, 'c) Bigarray.Array1.t ->
  ('a, 'b, 'c) Bigarray.Array1.t ->
  'any op ->
  communicator ->
  unit

val allreduce_bigarray2 : 
  ('a, 'b, 'c) Bigarray.Array2.t ->
  ('a, 'b, 'c) Bigarray.Array2.t ->
  'any op ->
  communicator ->
  unit

val allreduce_bigarray3 : 
  ('a, 'b, 'c) Bigarray.Array3.t ->
  ('a, 'b, 'c) Bigarray.Array3.t ->
  'any op ->
  communicator ->
  unit

val scan_int : int -> [ `Int ] op -> communicator -> int

val scan_float : float -> [ `Float ] op -> communicator -> float

val scan_int_array : 
  int array ->
  int array ->
  [ `Int ] op ->
  communicator ->
  unit

val scan_float_array : 
  float array ->
  float array ->
  [ `Float ] op ->
  communicator ->
  unit

val scan_bigarray : 
  ('a, 'b, 'c) Bigarray.Genarray.t ->
  ('a, 'b, 'c) Bigarray.Genarray.t ->
  'any op ->
  communicator ->
  unit

val scan_bigarray0 : 
  ('a, 'b, 'c) Bigarray.Array0.t ->
  ('a, 'b, 'c) Bigarray.Array0.t ->
  'any op ->
  communicator ->
  unit

val scan_bigarray1 : 
  ('a, 'b, 'c) Bigarray.Array1.t ->
  ('a, 'b, 'c) Bigarray.Array1.t ->
  'any op ->
  communicator ->
  unit

val scan_bigarray2 : 
  ('a, 'b, 'c) Bigarray.Array2.t ->
  ('a, 'b, 'c) Bigarray.Array2.t ->
  'any op ->
  communicator ->
  unit

val scan_bigarray3 : 
  ('a, 'b, 'c) Bigarray.Array3.t ->
  ('a, 'b, 'c) Bigarray.Array3.t ->
  'any op ->
  communicator ->
  unit

val comm_compare : communicator -> communicator -> bool

type color = int

val comm_split : communicator -> color -> int -> communicator

val color_none : color

val cart_create : 
  communicator ->
  int array ->
  bool array ->
  bool ->
  communicator

val dims_create : int -> int array -> int array

val cart_rank : communicator -> int array -> rank

val cart_coords : communicator -> rank -> int array

type group

val comm_create : communicator -> group -> communicator

val group_size : group -> int

val group_rank : group -> rank

val group_translate_ranks : group -> rank array -> group -> rank array

val comm_group : communicator -> group

val group_union : group -> group -> group

val group_intersection : group -> group -> group

val group_difference : group -> group -> group

val group_incl : group -> rank array -> group

val group_excl : group -> rank array -> group

type group_range = {

range_first : int;
range_last : int;
range_stride : int;

}

val group_range_incl : group -> group_range array -> group

val group_range_excl : group -> group_range array -> group

val wtime : unit -> float

package mpi