Context: Context
| Context | R Documentation |
Context
Description
This class represents the base context for interacting with
Backend implementations via the BackendService
interface.
Details
This class is a vanilla wrapper around a Backend implementation.
It registers a backend instance and forwards all BackendService
methods calls to the backend instance. Subclasses can override any of the
BackendService methods to decorate the backend instance with
additional functionality (e.g., see the ProgressTrackingContext
class for an example).
Super class
parabar::BackendService -> Context
Active bindings
backendThe
Backendobject registered with the context.
Methods
Public methods
Method new()
Create a new Context object.
Usage
Context$new()
Returns
An object of class Context.
Method set_backend()
Set the backend instance to be used by the context.
Usage
Context$set_backend(backend)
Arguments
backendAn object of class
Backendthat implements theBackendServiceinterface.
Method start()
Start the backend.
Usage
Context$start(specification)
Arguments
specificationAn object of class
Specificationthat contains the backend configuration.
Returns
This method returns void. The resulting backend must be stored in the
.cluster private field on the Backend abstract class,
and accessible to any concrete backend implementations via the active
binding cluster.
Method stop()
Stop the backend.
Usage
Context$stop()
Returns
This method returns void.
Method clear()
Remove all objects from the backend. This function is equivalent to
calling rm(list = ls(all.names = TRUE)) on each node in the
backend.
Usage
Context$clear()
Returns
This method returns void.
Method peek()
Inspect the backend for variables available in the .GlobalEnv.
Usage
Context$peek()
Returns
This method returns a list of character vectors, where each element
corresponds to a node in the backend. The character vectors contain
the names of the variables available in the .GlobalEnv on each
node.
Method export()
Export variables from a given environment to the backend.
Usage
Context$export(variables, environment)
Arguments
variablesA character vector of variable names to export.
environmentAn environment object from which to export the variables. Defaults to the parent frame.
Returns
This method returns void.
Method evaluate()
Evaluate an arbitrary expression on the backend.
Usage
Context$evaluate(expression)
Arguments
expressionAn unquoted expression to evaluate on the backend.
Returns
This method returns the result of the expression evaluation.
Method sapply()
Run a task on the backend akin to parallel::parSapply().
Usage
Context$sapply(x, fun, ...)
Arguments
xAn atomic vector or list to pass to the
funfunction.funA function to apply to each element of
x....Additional arguments to pass to the
funfunction.
Returns
This method returns void. The output of the task execution must be
stored in the private field .output on the Backend
abstract class, and is accessible via the get_output() method.
Method lapply()
Run a task on the backend akin to parallel::parLapply().
Usage
Context$lapply(x, fun, ...)
Arguments
xAn atomic vector or list to pass to the
funfunction.funA function to apply to each element of
x....Additional arguments to pass to the
funfunction.
Returns
This method returns void. The output of the task execution must be
stored in the private field .output on the Backend
abstract class, and is accessible via the get_output() method.
Method apply()
Run a task on the backend akin to parallel::parApply().
Usage
Context$apply(x, margin, fun, ...)
Arguments
xAn array to pass to the
funfunction.marginA numeric vector indicating the dimensions of
xthefunfunction should be applied over. For example, for a matrix,margin = 1indicates applyingfunrows-wise,margin = 2indicates applyingfuncolumns-wise, andmargin = c(1, 2)indicates applyingfunelement-wise. Named dimensions are also possible depending onx. Seeparallel::parApply()andbase::apply()for more details.funA function to apply to
xaccording to themargin....Additional arguments to pass to the
funfunction.
Returns
This method returns void. The output of the task execution must be
stored in the private field .output on the Backend
abstract class, and is accessible via the get_output() method.
Method get_output()
Get the output of the task execution.
Usage
Context$get_output(...)
Arguments
...Additional arguments to pass to the backend registered with the context. This is useful for backends that require additional arguments to fetch the output (e.g.,
AsyncBackend$get_output(wait = TRUE)).
Details
This method fetches the output of the task execution after calling
the sapply() method. It returns the output and immediately removes
it from the backend. Therefore, subsequent calls to this method are
not advised. This method should be called after the execution of a
task.
Returns
A vector, matrix, or list of the same length as x, containing the
results of the fun. The output format differs based on the specific
operation employed. Check out the documentation for the apply
operations of parallel::parallel for more information.
Method clone()
The objects of this class are cloneable with this method.
Usage
Context$clone(deep = FALSE)
Arguments
deepWhether to make a deep clone.
See Also
ProgressTrackingContext, BackendService,
Backend, and SyncBackend.
Examples
# Define a task to run in parallel.
task <- function(x, y) {
# Sleep a bit.
Sys.sleep(0.25)
# Return the result of a computation.
return(x + y)
}
# Create a specification object.
specification <- Specification$new()
# Set the number of cores.
specification$set_cores(cores = 2)
# Set the cluster type.
specification$set_type(type = "psock")
# Create a backend factory.
backend_factory <- BackendFactory$new()
# Get a synchronous backend instance.
backend <- backend_factory$get("sync")
# Create a base context object.
context <- Context$new()
# Register the backend with the context.
context$set_backend(backend)
# From now all, all backend operations are intercepted by the context.
# Start the backend.
context$start(specification)
# Run a task in parallel (i.e., approx. 1.25 seconds).
context$sapply(x = 1:10, fun = task, y = 10)
# Get the task output.
context$get_output()
# Close the backend.
context$stop()
# Get an asynchronous backend instance.
backend <- backend_factory$get("async")
# Register the backend with the same context object.
context$set_backend(backend)
# Start the backend reusing the specification object.
context$start(specification)
# Run a task in parallel (i.e., approx. 1.25 seconds).
context$sapply(x = 1:10, fun = task, y = 10)
# Get the task output.
backend$get_output(wait = TRUE)
# Close the backend.
context$stop()
