module ParallelArray:sig..end
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.
val default_pool : ThreadPoolExecutor.tRuntime.available_processors.val shutdown_now : unit -> unitdefault_pool.val length : 'a array -> intArray.length.val get : 'a array -> int -> 'aArray.get.val set : 'a array -> int -> 'a -> unitArray.set.val make : int -> 'a -> 'a arrayArray.make.val create : int -> 'a -> 'a arrayArray.create.val make_matrix : int -> int -> 'a -> 'a array arrayArray.make_matrix.val create_matrix : int -> int -> 'a -> 'a array arrayArray.create_matrix.val append : 'a array -> 'a array -> 'a arrayArray.append.val concat : 'a array list -> 'a arrayArray.concat.val sub : 'a array -> int -> int -> 'a arrayArray.sub.val copy : 'a array -> 'a arrayArray.copy.val fill : 'a array -> int -> int -> 'a -> unitArray.fill.val blit : 'a array -> int -> 'a array -> int -> int -> unitArray.blit.val to_list : 'a array -> 'a listArray.to_list.val of_list : 'a list -> 'a arrayArray.of_list.val init : ?pool:ThreadPoolExecutor.t ->
?chunk_size:int -> int -> (int -> 'a) -> 'a arrayArray.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.
Raise Invalid_argument if passed size is negative or above
Sys.max_array_length.
Raises Runtime.Raised if the passed function raises an exception.
val iter : ?pool:ThreadPoolExecutor.t ->
?chunk_size:int -> ('a -> unit) -> 'a array -> unitArray.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.
Raises Runtime.Raised if the passed function raises an exception.
val map : ?pool:ThreadPoolExecutor.t ->
?chunk_size:int -> ('a -> 'b) -> 'a array -> 'b arrayArray.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 -> unitArray.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.
Raises Runtime.Raised if the passed function raises an exception.
val mapi : ?pool:ThreadPoolExecutor.t ->
?chunk_size:int -> (int -> 'a -> 'b) -> 'a array -> 'b arrayArray.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.
Raises Runtime.Raised if the passed function raises an exception.
val fold_left : ?pool:ThreadPoolExecutor.t ->
?chunk_size:int ->
('a -> 'b -> 'a) -> ('a -> 'a -> 'a) -> 'a -> 'b array -> 'aArray.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.
Raises Runtime.Raised if any of the passed functions raises an exception.
val fold_right : ?pool:ThreadPoolExecutor.t ->
?chunk_size:int ->
('b -> 'a -> 'a) -> ('a -> 'a -> 'a) -> 'b array -> 'a -> 'aArray.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.
Raises Runtime.Raised if any of the passed functions raises an exception.
val sort : ?pool:ThreadPoolExecutor.t ->
?chunk_size:int -> ('a -> 'a -> int) -> 'a array -> unitArray.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.
Raises Runtime.Raised if the passed function raises an exception.
val stable_sort : ?pool:ThreadPoolExecutor.t ->
?chunk_size:int -> ('a -> 'a -> int) -> 'a array -> unitParallelArray.sort.val fast_sort : ?pool:ThreadPoolExecutor.t ->
?chunk_size:int -> ('a -> 'a -> int) -> 'a array -> unitParallelArray.sort.val mem : ?pool:ThreadPoolExecutor.t -> ?chunk_size:int -> 'a -> 'a array -> boolmem ~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 -> boolmemq ~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 -> boolexists ~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 -> boolfor_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 -> 'afind ~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_index : ?pool:ThreadPoolExecutor.t ->
?chunk_size:int -> ('a -> bool) -> 'a array -> intfind, except that the index is returned.val find_all : ?pool:ThreadPoolExecutor.t ->
?chunk_size:int -> ('a -> bool) -> 'a array -> 'a listfind_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.module type OptionalParameters =sig..end
ParallelArray.Make parameter.
module type S =sig..end
module type of Array, except for fold operations.
module Make:
Array module (except for fold
operations).