module ParallelArray: sig .. end
Parallel operations over arrays.
Most operations have the same signature as their original
counterparts, but fold operations need an additional function
in order to be able to "merge" the computations done on sub arrays.
Operations doing computations in parallel can be passed two optional
parameters to set thread pool, and chunk size. It is possible to get
rid of these optional parameters through the use of the Make
functor.
If any parallel operation is used with a given pool, it is necessary
to shutdown the pool. This applies in particular to default_pool,
that can be shutdown through the shutdown_now function.
Thread pool
val default_pool : ThreadPoolExecutor.t
The default pool used for parallel computations, initialized with the
number of available (logical) processors.
val shutdown_now : unit -> unit
Shutdowns default_pool.
Synonyms for sequential operations
val length : 'a array -> int
val get : 'a array -> int -> 'a
val set : 'a array -> int -> 'a -> unit
val make : int -> 'a -> 'a array
val create : int -> 'a -> 'a array
val make_matrix : int -> int -> 'a -> 'a array array
val create_matrix : int -> int -> 'a -> 'a array array
val append : 'a array -> 'a array -> 'a array
val concat : 'a array list -> 'a array
val sub : 'a array -> int -> int -> 'a array
val copy : 'a array -> 'a array
val fill : 'a array -> int -> int -> 'a -> unit
val blit : 'a array -> int -> 'a array -> int -> int -> unit
val to_list : 'a array -> 'a list
val of_list : 'a list -> 'a array
Parallel operations
val init : ?pool:ThreadPoolExecutor.t ->
?chunk_size:int -> int -> (int -> 'a) -> 'a array
Similar to
Array.init, except that computations are done in
parallel;
pool indicates the thread pool to use (defaulting to
default_pool), while
chunk_size indicates the size of each chunk
to be allocated to a thread.
Raises Invalid_argument if passed size is negative or above
Sys.max_array_length
val iter : ?pool:ThreadPoolExecutor.t ->
?chunk_size:int -> ('a -> unit) -> 'a array -> unit
Similar to
Array.iter, except that computations are done in
parallel;
pool indicates the thread pool to use (defaulting to
default_pool), while
chunk_size indicates the size of each chunk
to be allocated to a thread.
val map : ?pool:ThreadPoolExecutor.t ->
?chunk_size:int -> ('a -> 'b) -> 'a array -> 'b array
Similar to
Array.map, except that computations are done in
parallel;
pool indicates the thread pool to use (defaulting to
default_pool), while
chunk_size indicates the size of each chunk
to be allocated to a thread.
Raises
Runtime.Raised if the passed function raises an exception.
val iteri : ?pool:ThreadPoolExecutor.t ->
?chunk_size:int -> (int -> 'a -> unit) -> 'a array -> unit
Similar to
Array.iteri, except that computations are done in
parallel;
pool indicates the thread pool to use (defaulting to
default_pool), while
chunk_size indicates the size of each chunk
to be allocated to a thread.
val mapi : ?pool:ThreadPoolExecutor.t ->
?chunk_size:int -> (int -> 'a -> 'b) -> 'a array -> 'b array
Similar to
Array.mapi, except that computations are done in
parallel;
pool indicates the thread pool to use (defaulting to
default_pool), while
chunk_size indicates the size of each chunk
to be allocated to a thread.
val fold_left : ?pool:ThreadPoolExecutor.t ->
?chunk_size:int ->
('a -> 'b -> 'a) -> ('a -> 'a -> 'a) -> 'a -> 'b array -> 'a
Similar to
Array.fold_left, except that computations are done in
parallel;
pool indicates the thread pool to use (defaulting to
default_pool), while
chunk_size indicates the size of each chunk
to be allocated to a thread.
This version uses an additional function in order to be able to
"merge" the computations done on sub arrrays.
val fold_right : ?pool:ThreadPoolExecutor.t ->
?chunk_size:int ->
('b -> 'a -> 'a) -> ('a -> 'a -> 'a) -> 'b array -> 'a -> 'a
Similar to
Array.fold_right, except that computations are done in
parallel;
pool indicates the thread pool to use (defaulting to
default_pool), while
chunk_size indicates the size of each chunk
to be allocated to a thread.
This version uses an additional function in order to be able to
"merge" the computations done on sub arrrays.
val sort : ?pool:ThreadPoolExecutor.t ->
?chunk_size:int -> ('a -> 'a -> int) -> 'a array -> unit
Similar to
Array.sort, except that computations are done in
parallel;
pool indicates the thread pool to use (defaulting to
default_pool), while
chunk_size indicates the size of each chunk
to be allocated to a thread.
The current implementation has a
O(n) space complexity.
val stable_sort : ?pool:ThreadPoolExecutor.t ->
?chunk_size:int -> ('a -> 'a -> int) -> 'a array -> unit
val fast_sort : ?pool:ThreadPoolExecutor.t ->
?chunk_size:int -> ('a -> 'a -> int) -> 'a array -> unit
Additional parallel operations
val mem : ?pool:ThreadPoolExecutor.t -> ?chunk_size:int -> 'a -> 'a array -> bool
mem ~pool ~chunk_size x a returns true iff there is an element
e of a such that e = x. pool indicates the thread pool to use
(defaulting to default_pool), while chunk_size indicates the size
of each chunk to be allocated to a thread.
val memq : ?pool:ThreadPoolExecutor.t -> ?chunk_size:int -> 'a -> 'a array -> bool
memq ~pool ~chunk_size x a returns true iff there is an element
e of a such that e == x. pool indicates the thread pool to use
(defaulting to default_pool), while chunk_size indicates the size
of each chunk to be allocated to a thread.
val exists : ?pool:ThreadPoolExecutor.t ->
?chunk_size:int -> ('a -> bool) -> 'a array -> bool
exists ~pool ~chunk_size f a returns true iff there is an element
e of a such that f e = true. pool indicates the thread pool
to use (defaulting to default_pool), while chunk_size indicates
the size of each chunk to be allocated to a thread.
val for_all : ?pool:ThreadPoolExecutor.t ->
?chunk_size:int -> ('a -> bool) -> 'a array -> bool
for_all ~pool ~chunk_size f a returns true iff there is no element
e of a such that f e = false. pool indicates the thread pool
to use (defaulting to default_pool), while chunk_size indicates
the size of each chunk to be allocated to a thread.
val find : ?pool:ThreadPoolExecutor.t ->
?chunk_size:int -> ('a -> bool) -> 'a array -> 'a
find ~pool ~chunk_size f a returns an element e of a such that
f e = true, raising Not_found if there is no such element in a.
pool indicates the thread pool to use (defaulting to
default_pool), while chunk_size indicates the size of each chunk
to be allocated to a thread.
Returns any element matching the condition, not guaranteeing that
the one with the lowest index is returned.
val find_all : ?pool:ThreadPoolExecutor.t ->
?chunk_size:int -> ('a -> bool) -> 'a array -> 'a list
find_all ~pool ~chunk_size f a returns all the elements of a that
return true when applied to f, preserving the order of the
elements in a.
Functor
module type S = sig .. end
Similar to module type of Array, except for fold operations.
module Make:
Functor building an implementation with no optional parameter,
thus compatible with the Array module (except for fold
operations).