ClusterFuture

ClusterFuture-class

MultisessionFuture

MultisessionFuture-class

An R <a rd-options="base" href="/link/expression?package=future&version=1.0.1&to=base" data-mini-rdoc="base::expression">expression</a>.

expr

The <a rd-options="" href="/link/environment?package=future&version=1.0.1" data-mini-rdoc="future::environment">environment</a> in which the evaluation
is done (or inherits from if <code>local</code> is TRUE).

envir

If TRUE, argument <code>expr</code> is
<code><a rd-options="base" href="/link/substitute?package=future&version=1.0.1&to=base" data-mini-rdoc="base::substitute">substitute</a>()</code>:ed, otherwise not.

substitute

If TRUE, the expression is evaluated such that
all assignments are done to local temporary environment, otherwise
the assignments are done in the global environment of the cluster node.

local

If TRUE, the garbage collector run after the future
is resolved (in the process that evaluated the future).

If FALSE, the evaluation environment is cleared
from objects prior to the evaluation of the future.

persistent

A <code><a rd-options="parallel:makeCluster" href="/link/cluster?package=future&version=1.0.1&to=parallel%3AmakeCluster" data-mini-rdoc="parallel:makeCluster::cluster">cluster</a></code>.
Alternatively, a character vector of host names or a numeric scalar,
for creating a cluster via <code><a rd-options="parallel" href="/link/makeCluster?package=future&version=1.0.1&to=parallel" data-mini-rdoc="parallel::makeCluster">makeCluster</a>(workers)</code>.

workers


A cluster future is a future whose value will be resolved asynchroneously in a parallel process


internal

A Future API for R is provided. In programming, a future is an
abstraction for a value that may be available at some point in the future.
The state of a future can either be unresolved or resolved. As soon as it is
resolved, the value is available. Futures are useful constructs in for instance
concurrent evaluation, e.g. parallel processing and distributed processing on
compute clusters. The purpose of this package is to provide a lightweight
interface for using futures in R. Functions 'future()' and 'value()' exist for
creating futures and requesting their values, e.g.
'f <- future({ mandelbrot(-0.75, 0, side=3) })' and 'v <- value(f)'.
The 'resolved()' function can be used to check if a future is resolved or not.
An infix assignment operator '%<-%' exists for creating futures whose values
are accessible by the assigned variables (as promises), e.g.
'v %<-% { mandelbrot(-0.75, 0, side=3) }'.
This package implements synchronous "lazy" and "eager" futures, and asynchronous
"multicore", "multisession" and ad hoc "cluster" futures.
Globals variables and functions are automatically identified and exported.
Required packages are attached in external R sessions whenever needed.
All types of futures are designed to behave the same such that the exact
same code work regardless of futures used or number of cores, background
sessions or cluster nodes available.
Additional types of futures are provided by other packages enhancing
this package.

Henrik Bengtsson

future

A Future API for R

ClusterFuture-class function

An R <a rd-options='base' href='expression'>expression</a>.

The <a rd-options='' href='environment'>environment</a> in which the evaluation
is done (or inherits from if <code>local</code> is TRUE).

If TRUE, argument <code>expr</code> is
<code><a rd-options='base' href='substitute'>substitute</a>()</code>:ed, otherwise not.

A <code><a rd-options='parallel:makeCluster' href='cluster'>cluster</a></code>.
Alternatively, a character vector of host names or a numeric scalar,
for creating a cluster via <code><a rd-options='parallel' href='makeCluster'>makeCluster</a>(workers)</code>.

ClusterFuture-class: A cluster future is a future whose value will be resolved asynchroneously in a parallel process

Description

Usage

Arguments

Value

See Also