Bigstring (parallel.parallel.arrays.Parallel

module Kind : sig ... end

type 'a t = private {

kind : 'a Kind.t;
data : Base_bigstring.t;

}

val sexp_of_t : ('a -> Sexplib0.Sexp.t) -> 'a t -> Sexplib0.Sexp.t

val with_kind_exn : 'a Bigstring.Kind.t -> Base_bigstring.t -> 'a t

val length : 'a t @ contended -> Base.int

length t returns the number of elements in t.

To read a value from a parallel array, we must prove that it does not escape its capsule. This is the case if its type crosses contention, or if it is manipulated within a portable function.

val get : 'a. 'a t -> Base.int -> 'a

get t i reads the element at index i. Raises Invalid_arg if i is not in the range [0..length t).

val unsafe_get : 'a. 'a t -> Base.int -> 'a

unsafe_get t i unsafely reads the element at index i.

val extract : 
  'a t ->
  Base.int ->
  ('a -> 'b @ portable contended) @ local once portable ->
  'b @ portable contended

extract t i f applies f with the element read from index i. Raises Invalid_arg if i is not in the range [0..length t).

val unsafe_extract : 
  'a t ->
  Base.int ->
  ('a -> 'b @ portable contended) @ local once portable ->
  'b @ portable contended

unsafe_extract t i f applies f with the element unsafely read from index i.

To store a value in a parallel array, we must prove that it does not share unsynchronized state with any other elements. This is the case if its type crosses contention or it lives in a fresh capsule.

val set : 'a. 'a t -> Base.int -> 'a -> Base.unit @@ portable

set t i a stores the element a at index i. Raises Invalid_arg if i is not in the range [0..length t).

val unsafe_set : 'a. 'a t -> Base.int -> 'a -> Base.unit @@ portable

unsafe_set t i a unsafely stores the element a at index i.

val insert : 
  'a t ->
  Base.int ->
  (Base.unit -> 'a) @ local once portable ->
  Base.unit @@ portable

insert t i f stores f () at index i. Raises Invalid_arg if i is not in the range [0..length t).

val unsafe_insert : 
  'a t ->
  Base.int ->
  (Base.unit -> 'a) @ local once portable ->
  Base.unit @@ portable

unsafe_insert t i f unsafely stores f () at index i.

module Slice : Slice with type 'a array := 'a t

val of_slice : 'a Slice.t @ local -> 'a t

val of_string : ?pos:Base.int -> ?len:Base.int -> Base.string -> Base.char t

of_string s is a new character bigstring initialized by copying the contents of the string s. The optional arguments pos and len are forwarded to Base_bigstring.of_string

val init : 
  Parallel_kernel.t @ local ->
  (('a Kind.t * Base.int) ->
  (f:(Parallel_kernel.t @ local -> (Base.int -> 'a) @ local) @ shareable ->
  'a t) @ local) @ local @@ portable

init parallel n ~f initializes an array with the result of f applied to the integers 0..n-1.

val iter : 
  Parallel_kernel.t @ local ->
  ('a t ->
  (f:(Parallel_kernel.t @ local -> ('a -> Base.unit) @ local) @ shareable ->
  Base.unit) @ local) @ local

iter parallel t ~f applies f to each element of t.

val iteri : 
  Parallel_kernel.t @ local ->
  ('a t ->
  (f:
     (Parallel_kernel.t @ local ->
       (Base.int ->
       ('a ->
       Base.unit) @ local) @ local) @ shareable ->
  Base.unit) @ local) @ local

iteri parallel t ~f applies f to each element of t and its index.

val find : 
  Parallel_kernel.t @ local ->
  ('a t ->
  (f:(Parallel_kernel.t @ local -> ('a -> Base.bool) @ local) @ shareable ->
  'a Base.option) @ local) @ local

find parallel t ~f returns the first element of t for which f returns true, if it exists. f will always be applied to every element of t.

val findi : 
  Parallel_kernel.t @ local ->
  ('a t ->
  (f:
     (Parallel_kernel.t @ local ->
       (Base.int ->
       ('a ->
       Base.bool) @ local) @ local) @ shareable ->
  'a Base.option) @ local) @ local

findi parallel t ~f returns the first element of t for which f returns true, if it exists. f will always be applied to every element of t and its index.

val reduce : 
  Parallel_kernel.t @ local ->
  ('a t ->
  (f:
     (Parallel_kernel.t @ local ->
       ('a @ shared ->
       ('a @ shared ->
       'a) @ local) @ local) @ shareable ->
  'a Base.option) @ local) @ local

reduce parallel t ~f folds f over the elements of t. f must be associative. If t is empty, reduce returns None.

val min_elt : 
  Parallel_kernel.t @ local ->
  ('a t ->
  (compare:
     (Parallel_kernel.t @ local ->
       ('a @ local shared ->
       ('a @ local shared ->
       Base.int) @ local) @ local) @ shareable ->
  'a Base.option) @ local) @ local

min_elt parallel t ~compare is the minimum element of t according to compare. If t is empty, returns None.

val max_elt : 
  Parallel_kernel.t @ local ->
  ('a t ->
  (compare:
     (Parallel_kernel.t @ local ->
       ('a @ local shared ->
       ('a @ local shared ->
       Base.int) @ local) @ local) @ shareable ->
  'a Base.option) @ local) @ local

max_elt parallel t ~compare is the maximum element of t according to compare. If t is empty, returns None.

val fold : 
  Parallel_kernel.t @ local ->
  ('a t @ shared ->
  (init:(Base.unit -> 'acc) @ portable ->
  (f:
     (Parallel_kernel.t @ local ->
       ('acc ->
       ('a @ shared ->
       'acc) @ local) @ local) @ shareable ->
  (combine:
     (Parallel_kernel.t @ local -> ('acc -> ('acc -> 'acc) @ local) @ local) @ shareable ->
  'acc) @ local) @ local) @ local) @ local @@ portable

fold parallel t ~init ~f ~combine folds combine over the result of map parallel t ~f. combine must be associative and combine init x must equal x.

val foldi : 
  Parallel_kernel.t @ local ->
  ('a t @ shared ->
  (init:(Base.unit -> 'acc) @ portable ->
  (f:
     (Parallel_kernel.t @ local ->
       (Base.int ->
       ('acc ->
       ('a @ shared ->
       'acc) @ local) @ local) @ local) @ shareable ->
  (combine:
     (Parallel_kernel.t @ local -> ('acc -> ('acc -> 'acc) @ local) @ local) @ shareable ->
  'acc) @ local) @ local) @ local) @ local @@ portable

foldi parallel t ~init ~f ~combine folds combine over the result of mapi parallel t ~f. combine must be associative and combine init x must equal x.

val sort : 
  Parallel_kernel.t @ local ->
  ('a t ->
  (compare:
     (Parallel_kernel.t @ local ->
       ('a @ local shared ->
       ('a @ local shared ->
       Base.int) @ local) @ local) @ shareable ->
  'a t) @ local) @ local

sort parallel t ~compare initializes an array with the contents of t unstably sorted with respect to compare.

val stable_sort : 
  Parallel_kernel.t @ local ->
  ('a t ->
  (compare:
     (Parallel_kernel.t @ local ->
       ('a @ local shared ->
       ('a @ local shared ->
       Base.int) @ local) @ local) @ shareable ->
  'a t) @ local) @ local

stable_sort parallel t ~compare initializes an array with the contents of t stably sorted with respect to compare.

val scan : 
  Parallel_kernel.t @ local ->
  ('a t ->
  (init:'a ->
  (f:
     (Parallel_kernel.t @ local ->
       ('a @ shared ->
       ('a @ shared ->
       'a) @ local) @ local) @ shareable ->
  'a t * 'a) @ local) @ local) @ local

scan parallel t ~init ~f initialises an array containing the exclusive prefix sums of t with respect to f. The first element is init and the full reduction of t is returned separately. f must be associative and f init x must equal x.

val scan_inclusive : 
  Parallel_kernel.t @ local ->
  ('a t ->
  (init:'a ->
  (f:
     (Parallel_kernel.t @ local ->
       ('a @ shared ->
       ('a @ shared ->
       'a) @ local) @ local) @ shareable ->
  'a t) @ local) @ local) @ local

scan_inclusive parallel t ~init ~f initialises an array containing the inclusive prefix sums of t with respect to f. The first element is the first element of t. f must be associative and f init x must equal x.

val filter : 
  Parallel_kernel.t @ local ->
  ('a t ->
  (f:(Parallel_kernel.t @ local -> ('a -> Base.bool) @ local) @ shareable ->
  'a t) @ local) @ local

filter parallel t ~f initialises an array containing the elements of t that satisfy the predicate f.

val filteri : 
  Parallel_kernel.t @ local ->
  ('a t ->
  (f:
     (Parallel_kernel.t @ local ->
       (Base.int ->
       ('a ->
       Base.bool) @ local) @ local) @ shareable ->
  'a t) @ local) @ local

filteri parallel t ~f initialises an array containing the elements of t that, alongside their index, satisfy the predicate f.

val map_inplace : 
  Parallel_kernel.t @ local ->
  ('a t ->
  (f:(Parallel_kernel.t @ local -> ('a -> 'a) @ local) @ shareable ->
  Base.unit) @ local) @ local @@ portable

map_inplace parallel t ~f overwrites an array with the result of f applied to each of its elements.

val mapi_inplace : 
  Parallel_kernel.t @ local ->
  ('a t ->
  (f:
     (Parallel_kernel.t @ local -> (Base.int -> ('a -> 'a) @ local) @ local) @ shareable ->
  Base.unit) @ local) @ local @@ portable

mapi_inplace parallel t ~f overwrites an array with the result of f applied to each of its elements and their indices.

val init_inplace : 
  Parallel_kernel.t @ local ->
  ('a t ->
  (f:(Parallel_kernel.t @ local -> (Base.int -> 'a) @ local) @ shareable ->
  Base.unit) @ local) @ local @@ portable

init_inplace parallel t ~f overwrites an array with the result of f applied to each array index. This can be much faster than using mapi_inplace since it does not need to read the array.

val sort_inplace : 
  Parallel_kernel.t @ local ->
  ('a t ->
  (compare:
     (Parallel_kernel.t @ local ->
       ('a @ local shared ->
       ('a @ local shared ->
       Base.int) @ local) @ local) @ shareable ->
  Base.unit) @ local) @ local @@ portable

sort_inplace parallel t ~compare unstably sorts t with respect to compare.

val stable_sort_inplace : 
  Parallel_kernel.t @ local ->
  ('a t ->
  (compare:
     (Parallel_kernel.t @ local ->
       ('a @ local shared ->
       ('a @ local shared ->
       Base.int) @ local) @ local) @ shareable ->
  Base.unit) @ local) @ local @@ portable

stable_sort_inplace parallel t ~compare stably sorts t with respect to compare.

val scan_inplace : 
  Parallel_kernel.t @ local ->
  ('a t ->
  (init:'a ->
  (f:
     (Parallel_kernel.t @ local ->
       ('a @ shared ->
       ('a @ shared ->
       'a) @ local) @ local) @ shareable ->
  'a) @ local) @ local) @ local @@ portable

scan_inplace parallel t ~init ~f overwrites t to contain the its exclusive prefix sums with respect to f. The first element becomes init and the full reduction of t is returned. f must be associative and f init x must equal x.

val scan_inclusive_inplace : 
  Parallel_kernel.t @ local ->
  ('a t ->
  (init:'a ->
  (f:
     (Parallel_kernel.t @ local ->
       ('a @ shared ->
       ('a @ shared ->
       'a) @ local) @ local) @ shareable ->
  Base.unit) @ local) @ local) @ local @@ portable

scan_inclusive_inplace parallel t ~init ~f overwrites t to contain its inclusive prefix sums with respect to f. The first element is unchanged. f must be associative and f init x must equal x.