Domainslib.TaskSourceType of task
Type of promises
Type of task pool
Sets up a task execution pool with num_additional_domains + 1 domains including the current domain. If name is provided, the pool is mapped to name which can be looked up later with lookup_pool name.
Raises Invalid_argument when num_additional_domains is less than 0.
lookup_pool name returns Some pool if pool is associated to name or returns None if no value is associated to it.
get_num_domains pool returns the total number of domains in pool including the parent domain.
run p t runs the task t synchronously in the pool p. If the task t blocks on a promise, then tasks from the pool p are executed until the promise blocking t is resolved.
This function should be used at the top level to enclose the calls to other functions that may await on promises. This includes await, parallel_for and its variants. Otherwise, those functions will raise Unhandled exception.
async p t runs the task t asynchronously in the pool p. The function returns a promise r in which the result of the task t will be stored.
await p r waits for the promise to be resolved. If the task associated with the promise had completed sucessfully, then the result of the task will be returned. If the task had raised an exception, then await raises the same exception.
Must be called with a call to run in the dynamic scope.
val parallel_for :
?chunk_size:int ->
start:int ->
finish:int ->
body:(int -> unit) ->
pool ->
unitparallel_for c s f b p behaves similar to for i=s to f do b i done, but runs the for loop in parallel. The chunk size c determines the number of body applications done in one task; this will default to max(1, (finish-start + 1) / (8 * num_domains)). Individual iterations may be run in any order. Tasks are distributed to workers using a divide-and-conquer scheme.
Must be called with a call to run in the dynamic scope.
val parallel_for_reduce :
?chunk_size:int ->
start:int ->
finish:int ->
body:(int -> 'a) ->
pool ->
('a -> 'a -> 'a) ->
'a ->
'aparallel_for_reduce c s f b p r i is similar to parallel_for except that the result returned by each iteration is reduced with r with initial value i. The reduce operations are performed in an arbitrary order and the reduce function needs to be commutative and associative in order to obtain a deterministic result.
Must be called with a call to run in the dynamic scope.
parallel_scan p op a computes the scan of the array a in parallel with binary operator op and returns the result array. Scan is similar to Array.fold_left but returns an array of reduced intermediate values. The reduce operations are performed in an arbitrary order and the reduce function needs to be commutative and associative in order to obtain a deterministic result.
Must be called with a call to run in the dynamic scope.