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 init : int -> (int -> 'a) -> 'a arrayArray.init.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 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.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.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.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.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.
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.
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.
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.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).