These functions provide several ways to parallelize computations using a cluster.
clusterCall(cl = NULL, fun, ...)
clusterApply(cl = NULL, x, fun, ...)
clusterApplyLB(cl = NULL, x, fun, ...)
clusterEvalQ(cl = NULL, expr)
clusterExport(cl = NULL, varlist, envir = .GlobalEnv)
clusterMap(cl = NULL, fun, ..., MoreArgs = NULL, RECYCLE = TRUE,
SIMPLIFY = FALSE, USE.NAMES = TRUE,
.scheduling = c("static", "dynamic"))
clusterSplit(cl = NULL, seq)parLapply(cl = NULL, X, fun, ...)
parSapply(cl = NULL, X, FUN, ..., simplify = TRUE,
USE.NAMES = TRUE)
parApply(cl = NULL, X, MARGIN, FUN, ...)
parRapply(cl = NULL, x, FUN, ...)
parCapply(cl = NULL, x, FUN, ...)
parLapplyLB(cl = NULL, X, fun, ...)
parSapplyLB(cl = NULL, X, FUN, ..., simplify = TRUE,
USE.NAMES = TRUE)
a cluster object, created by this package or by package
snow. If NULL, use the registered default cluster.
function or character string naming a function.
expression to evaluate.
vector to split.
character vector of names of objects to export.
environment from which t export variables
a vector for clusterApply and clusterApplyLB, a
matrix for parRapply and parCapply.
additional arguments to pass to fun or FUN:
beware of partial matching to earlier arguments.
additional arguments for fun.
logical; if true shorter arguments are recycled.
A vector (atomic or list) for parLapply and
parSapply, an array for parApply.
vector specifying the dimensions to use.
logical; see sapply.
logical; see mapply.
should tasks be statically allocated to nodes or dynamic load-balancing used?
For clusterCall, clusterEvalQ and clusterSplit, a
list with one element per node.
For clusterApply and clusterApplyLB, a list the same
length as seq.
clusterMap follows mapply.
clusterExport returns nothing.
parLapply returns a list the length of X.
parSapply and parApply follow sapply and
apply respectively.
parRapply and parCapply always return a vector. If
FUN always returns a scalar result this will be of length the
number of rows or columns: otherwise it will be the concatenation of
the returned values.
An error is signalled on the master if any of the workers produces an error.
clusterCall calls a function fun with identical
arguments ... on each node.
clusterEvalQ evaluates a literal expression on each cluster
node. It is a parallel version of evalq, and is a
convenience function invoking clusterCall.
clusterApply calls fun on the first node with
arguments seq[[1]] and ..., on the second node with
seq[[2]] and ..., and so on, recycling nodes as needed.
clusterApplyLB is a load balancing version of
clusterApply. If the length p of seq is not
greater than the number of nodes n, then a job is sent to
p nodes. Otherwise the first n jobs are placed in order
on the n nodes. When the first job completes, the next job is
placed on the node that has become free; this continues until all jobs
are complete. Using clusterApplyLB can result in better
cluster utilization than using clusterApply, but increased
communication can reduce performance. Furthermore, the node that
executes a particular job is non-deterministic.
clusterMap is a multi-argument version of clusterApply,
analogous to mapply and Map. If
RECYCLE is true shorter arguments are recycled (and either none
or all must be of length zero); otherwise, the result length is the
length of the shortest argument. Nodes are recycled if the length of
the result is greater than the number of nodes. (mapply always
uses RECYCLE = TRUE, and has argument SIMPLIFY = TRUE.
Map always uses RECYCLE = TRUE.)
clusterExport assigns the values on the master R process of
the variables named in varlist to variables of the same names
in the global environment (aka ‘workspace’) of each node. The
environment on the master from which variables are exported defaults
to the global environment.
clusterSplit splits seq into a consecutive piece for
each cluster and returns the result as a list with length equal to the
number of nodes. Currently the pieces are chosen to be close
to equal in length: the computation is done on the master.
parLapply, parSapply, and parApply are parallel
versions of lapply, sapply and apply.
parLapplyLB, parSapplyLB are load-balancing versions,
intended for use when applying FUN to different elements of
X takes quite variable amounts of time, and either the function
is deterministic or reproducible results are not required.
parRapply and parCapply are parallel row and column
apply functions for a matrix x; they may be slightly
more efficient than parApply but do less post-processing of the
result.