killNode() now support also worker processes that run on remote machines. They do this by connecting to the remote machine using the same method used to launch the worker, which is typically SSH, and do their R calls that way.
cloneNode(), which can be used to “restart”
RichSOCKnode cluster nodes.
makeNodePSOCK() now takes the optional, logical attribute
localhost to manually specify that the worker is a localhost worker.
RichSOCKcluster report on nodes with broken connections.
RichSOCKnode, which returns a
Introduce R option
parallelly.supportsMulticore.disableOn to control where multicore processing is disabled by default.
RichSOCKnode node could theoretically kill a process on the current machine with the same process ID (PID), although the parallel worker (node) is running on another machine.
RichSOCKnode node could theoretically return TRUE because there was a process with the same process ID (PID) on the current machine, although the parallel worker (node) is running on another machine.
SOCK0node was not declared an S3 method.
default = NA_integer_, so that
NA_integer_is returned when no free port could be found. However, in R (< 4.0.0), which does not support port querying, we use
default = "random".
rscript_sh = "cmd"is needed if the remote machines run MS Windows.
makeClusterPSOCK(..., verbose = TRUE) would not show verbose output. One still had to set option
parallelly.debug to TRUE.
availableWorkers() could produce false sanity-check warnings on mismatching ‘PE_HOSTFILE’ content and ‘NSLOTS’ for certain SGE-cluster configurations.
availableWorkers(constraints = "connections"), which limits the number of workers that can be be used to the current number of free R connections according to
freeConnections(). This is the maximum number of PSOCK, SOCK, and MPI parallel cluster nodes we can open without running out of available R connections.
availableCores() would produce a warning
In is.na(constraints) : is.na() applied to non-(list or vector) of type 'NULL' when running with R (< 4.0.0).
availableWorkers() did not acknowledge the
"Bioconductor" methods added to
availableCores() in parallelly 1.33.0 (2022-12-13). It also did not acknowledge methods
"cgroups.cpuquota" added in parallelly 1.31.0 (2022-04-07), and
"nproc" added in parallelly 1.26.1 (2021-06-29).
makeClusterPSOCK() failed to connect to all parallel workers within the
connectTimeout time limit, could either produce
Error in sprintf(ngettext(failed, "Cluster setup failed (connectTimeout=%.1f seconds). %d worker of %d failed to connect.", : invalid format '%d'; use format %f, %e, %g or %a for numeric objects instead of an informative error message, or an error message with the incorrect information.
makeClusterPSOCK() and likes now assert the running R session has enough permissions on the operating system to do system calls such as
system2("Rscript --version"). If not, an informative error message is produced.
availableCores() queries also control groups v2 (cgroups2) field
cpu.max for a possible CPU quota allocation. If a CPU quota is set, then the number of CPUs is rounded to the nearest integer, unless its less that 0.5, in case it’s rounded up to a single CPU. An example, where cgroups CPU quotas can be set to limit the total CPU load, is with Linux containers, e.g.
docker run --cpus=3.5 ....
Add support for
availableCores(methods = "connections"), which returns the current number of free R connections per
freeConnections(). This is the maximum number of PSOCK, SOCK, and MPI parallel cluster nodes we can open without running out of available R connections. A convenient way to use this and all other methods is
availableCores(constraints = "connections").
availableCores() recognizes environment variable
IS_BIOC_BUILD_MACHINE, which is set to true by the Bioconductor (>= 3.16) check servers. If true, then a maximum of four (4) cores is returned. This new environment variable replaces legacy variable
BBS_HOME used in Bioconductor (<= 3.15).
availableCores() splits up method
"BiocParallel" into two;
"Bioconductor". The former queries environment variable
BIOCPARALLEL_WORKER_NUMBER and the latter
IS_BIOC_BUILD_MACHINE. This means
availableCores(which = "all") now reports on both.
isNodeAlive() will now produce a once-per-session informative warning when it detects that it is not possible to check whether another process is alive on the current machine.
Add section to
help("makeClusterPSOCK", package = "parallelly") explaining why
R CMD check may produce “checking for detritus in the temp directory … NOTE” and how to avoid them.
Add section ‘For package developers’ to
help("makeClusterPSOCK", package = "parallelly") reminding us that we need to stop all clusters we created in package examples, tests, and vignettes.
isNodeAlive()failed to record which method works for testing if a process exists or not, which meant it would keep trying all methods each time. Similarly, if none works, it would still keep trying each time instead of returning NA immediately. On some systems, failing to check whether a process exists could result in one or more warnings, in which case those warnings would be produced for each call to
hostelement of the
SOCKnodeobjects created by
localhostfor localhost workers. This made some error messages from the future package less informative.
makeNodePSOCK(), and therefore also of
makeClusterPSOCK(), is now
NA, which means it’s agile to whether
rshcmdspecifies an SSH client, or not. If SSH is used, then it will resolve to
revtunnel = TRUE, otherwise to
revtunnel = FALSE. This removed the need for setting
revtunnel = FALSE, when non-SSH clients are used.
makeClusterPSOCK() would fail with
Error: node$session_info$process$pid == pid is not TRUE when running R in Simplified Chinese (
LANGUAGE=zh_CN), Traditional Chinese (Taiwan) (
LANGUAGE=zh_TW), or Korean (
Some warnings and errors showed the wrong call.
Changes to option
parallelly.availableCores.system would be ignored if done after the first call to
availableCores() with option
parallelly.availableCores.system set to less that
parallel::detectCores() would produce a warning, e.g. “[INTERNAL]: Will ignore the cgroups CPU set, because it contains one or more CPU indices that is out of range [0,0]: 0-7”.
"random", which used to be
"first". The main reason for this is to make sure the default behavior is to return a random port also on R (< 4.0.0) where we cannot test whether or not a port is available.
availableCores() now queries also control groups (cgroups) fields
cpu.cfs_period_us, for a possible CPU quota allocation. If a CPU quota is set, then the number of CPUs is rounded to the nearest integer, unless its less that 0.5, in case it’s rounded up to a single CPU. An example, where cgroups CPU quotas can be set to limit the total CPU load, is with Linux containers, e.g.
docker run --cpus=3.5 ....
In addition to cgroups CPU quotas,
availableCores() also queries cgroups for a possible CPU affinity, which is available in field
cpuset.set. This should give the same result as what the already existing ‘nproc’ method gives. However, not all systems have the
nproc tool installed, in which case this new approach should work. Some high-performance compute (HPC) environments set the CPU affinity so that jobs do not overuse the CPUs. It may also be set by Linux containers, e.g.
docker run --cpuset-cpus=0-2,8 ....
The minimum value returned by
availableCores() is one (1). This can be overridden by new option
parallelly.availableCores.min. This can be used to test parallelization methods on single-core machines, e.g.
options(parallelly.availableCores.min = 2L).
The ‘nproc’ result for
availableCores() was ignored if nproc > 9.
availableCores() would return the ‘fallback’ value when only ‘system’ and ‘nproc’ information was available. However, in this case, we do want it to return ‘nproc’ when ‘nproc’ != ‘system’, because that is a strong indication that the number of CPU cores is limited by control groups (cgroups) on Linux. If ‘nproc’ == ‘system’, we cannot tell whether cgroups is enabled or not, which means we will fall back to the ‘fallback’ value if there is no other evidence that another number of cores are available to the current R process.
canPortBeUsed() could falsely return FALSE if the port check was interrupted by, say, a user interrupt.
freePort(ports, default = "random") would always use return
ports if the system does not allow testing if a port is available or not, or if none of the specified ports are available.
makeNodePSOCK(), and therefore also
makeClusterPSOCK(), gained argument
rscript_sh, which controls how
Rscript arguments are shell quoted. The default is to make a best guess on what type of shell is used where each cluster node is launched. If launched locally, then it whatever platform the current R session is running, i.e. either a POSIX shell (
"sh") or MS Windows (
"cmd"). If remotely, then the assumption is that a POSIX shell (
"sh") is used.
makeNodePSOCK(), and therefore also
makeClusterPSOCK(), gained argument
default_packages, which controls the default set of R packages to be attached on each cluster node at startup. Moreover, if argument
rscript specifies an ‘Rscript’ executable, then argument
default_packages is used to populate Rscript command-line option
rscript specifies something else, e.g. an ‘R’ or ‘Rterm’ executable, then environment variable
R_DEFAULT_PACKAGES=... is set accordingly when launching each cluster node.
makeClusterPSOCK() now supports
"*" values. When used, the corresponding element will be replaced with the internally added Rscript command-line options. If not specified, such options are appended at the end.
makeClusterPSOCK() did not support backslashes (
rscript_libs, backslashes that may originate from, for example, Windows network drives. The result was that the worker would silently ignore any
rscript_libs components with backslashes.
The package detects when
R CMD check runs and adjust default settings via environment variables in order to play nicer with the machine where the checks are running. Some of these environment variables were in this case ignored since parallelly 1.26.0.
makeClusterPSOCK()launches parallel workers with option
"no-delay"by default. This decreases the communication latency between workers and the main R session, significantly so on Unix. This option requires R (>= 4.1.0) and has no effect in early versions of R.
makeClusterPSOCK(), which sets the corresponding R option on each cluster node when they are launched.
makeClusterPSOCK() can also be used to unset environment variables cluster nodes. Any named element with value
NA_character_ will be unset.
makeClusterPSOCK() now supports
"*" values. When used, the corresponding element will be replaced with the
"Rscript", or if
homogenous = TRUE, then absolute path to current ‘Rscript’.
makeClusterPSOCK()example on how to launch workers distributed across multiple CPU Groups on MS Windows 10.
R_PARALLELLY_SUPPORTSMULTICORE_UNSTABLE was incorrectly parsed as a logical instead of a character string. If the variables was set to, say,
"quiet", this would cause an error when the package was loaded.
makeClusterPSOCK() failed to fall back to
setup_strategy = "sequential", when not supported by the current R version.
parallel::makeCluster()failed with error “Cluster setup failed.
setup_strategy = "parallel"and when the tcltk package is loaded when running R (>= 4.0.0 && <= 4.1.0) on macOS. Now parallelly forces
setup_strategy = "sequential"when the tcltk package is loaded on these R versions.
makeClusterPSOCK(..., setup_strategy = "parallel") would forget to close an socket connection used to set up the workers. This socket connection would be closed by the garbage collector eventually with a warning.
parallelly::makeClusterPSOCK() would fail with “Error in freePort(port) : Unknown value on argument ‘port’: ‘auto’” if environment variable
R_PARALLEL_PORT was set to a port number.
parallelly::availableCores() would produce ‘Error in if (grepl(“^ [1-9]$”, res)) return(as.integer(res)) : argument is of length zero’ on Linux systems without
RichSOCKclustermentions when the cluster is registered to be automatically stopped by the garbage collector.
setup_strategy = "parallel"when using
parallel::makeCluster(). The symptom is that they, after a long wait, result in “Error in makeClusterPSOCK(workers, …) : Cluster setup failed.
setup_strategy = "sequentialfor parallelly and parallel when running in the RStudio Console. If you wish to override this behavior, you can always set option
"parallel", e.g. in your
~/.Rprofilefile. Alternatively, you can set the environment variable
R_PARALLELLY_MAKENODEPSOCK_SETUP_STRATEGY=parallel, e.g. in your
availableCores()would be limited by environment variables
OMP_THREAD_LIMIT, if set. For example, on conservative systems that set
OMP_NUM_THREADS=1as the default,
availableCores()would pick this up via
nprocand return 1. This was not the intended behavior. Now those environment variables are temporarily unset before querying
R_FUTURE_*) environment variables are now only read when the parallelly package is loaded, where they set the corresponding
parallelly.*option. Previously, some of these environment variables were queried by different functions as a fallback to when an option was not set. By only parsing them when the package is loaded, it decrease the overhead in functions, and it clarifies that options can be changed at runtime whereas environment variables should only be set at startup.
makeClusterPSOCK() now support setting up cluster nodes in parallel similarly to how
parallel::makePSOCKcluster() does it. This significantly reduces the setup turnaround time. This is only supported in R (>= 4.0.0). To revert to the sequential setup strategy, set R option
freePort() to get a random TCP port that can be opened.
parallelly.availableCores.fallbackand environment variable
R_PARALLELLY_AVAILABLECORES_FALLBACKwas ignored since parallelly 1.22.0, when support for ‘nproc’ was added to
sshclient. This means that regardless whether you are on Linux, macOS, or Windows 10, setting up parallel workers on external machines over SSH finally works out of the box without having to install PuTTY or other SSH clients. This was possible because a workaround was found for a Windows 10 bug preventing us from using reverse tunneling over SSH. It turns out the bug reveals itself when using hostname ‘localhost’ but not ‘127.0.0.1’, so we use the latter.
omitto make it easier to put aside zero or more cores from being used in parallel processing. For example, on a system with four cores,
availableCores(omit = 1)returns 3. Importantly, since
availableCores()is guaranteed to always return a positive integer,
availableCores(omit = 4) == 1, even on systems with four or fewer cores. Using
availableCores() - 4on such systems would return a non-positive value, which would give an error downstream.
makeClusterPSOCK(), or actually
makeNodePSOCK(), did not accept all types of environment variable names when using
rscript_envs, e.g. it would give an error if we tried to pass
makeClusterPSOCK() had a “length > 1 in coercion to logical” bug that could affect especially MS Windows 10 users.
plinkof the PuTTY software, (ii)
sshin the RStudio distribution, and (iii)
sshof Windows 10. Previously, the latter was considered first but that still has a bug preventing us from using reverse tunneling.
cluster objects now warns about duplicated cluster nodes.
isForkedNode() to test if a cluster node runs in a forked process.
isLocalhostNode() to test if a cluster node runs on the current machine.
availableWorkers() now recognizes the Slurm environment variable
"dev1,n[3-4,095-120]". It will use
scontrol show hostnames "$SLURM_JOB_NODELIST" to expand it, if supported on the current machine, otherwise it will attempt to parse and expand the nodelist specification using R. If either of environment variable
SLURM_TASKS_PER_NODE is set, then each node in the nodelist will be represented that number of times. If in addition, environment variable
SLURM_CPUS_PER_TASK (always a scalar), then that is also respected.
parallelly.prefix for options and the
R_PARALLELLY_prefix for environment variables. Settings that use the corresponding
R_FUTURE_prefixes are still recognized.
availableCores() did not respect environment variable
SLURM_TASKS_PER_NODE when the job was allocated more than one node.
quiet was introduced in future 1.19.1 but was mistakenly dropped from parallelly 1.20.0 when that was released, and therefore also from future (>= 1.20.0).
freeCores() gained argument
logical, which is passed down to
parallel::detectCores() as-is. The default is TRUE but it can be changed by setting the R option
parallelly.availableCores.logical. This option can in turn be set via environment variable
R_PARALLELLY_AVAILABLECORES_LOGICAL which is applied (only) when the package is loaded.
makeClusterPSOCK() asserts that there are enough free connections available before attempting to create the parallel workers. If too many workers are requested, an informative error message is produced.
freeConnections() to infer the maximum number of connections that the current R installation can have open at any time and how many of those are currently free to be used. This limit is typically 128 but may be different in custom R installations that are built from source.
availableCores() queries also Unix command
nproc, if available. This will make it respect the number of CPU/cores limited by ‘cgroups’ and Linux containers.
PSOCK cluster workers are now set up to communicate using little endian (
useXDR = FALSE) instead of big endian (
useXDR = TRUE). Since most modern systems use little endian,
useXDR = FALSE speeds up the communication noticeably (10-15%) on those systems. The default value of this argument can be controlled by the R option
parallelly.makeNodePSOCK.useXDR or the corresponding environment variable
find_rshcmd()which was never meant to be exported.
makeClusterPSOCK() gained argument
validate to control whether or not the nodes should be tested after they’ve been created. The validation is done by querying each node for its session information, which is then saved as attribute
session_info on the cluster node object. This information is also used in error messages, if available. This validation has been done since version 1.5.0 but now it can be disabled. The default of argument
validate can be controlled via an R options and an environment variable.
makeNodePSOCK(..., rscript_envs = "UNKNOWN") produces an informative warning on non-existing environment variables that was skipped.
makeClusterPSOCK() would produce an error on ‘one node produced an error: could not find function “getOptionOrEnvVar”’ if parallelly is not available on the node.
makeClusterPSOCK() would attempt to load parallelly on the worker. If it’s not available on the worker, it would result in a silent warning on the worker. Now parallelly is not loaded.
makeClusterPSOCK(..., tries = n) would retry to setup a cluster node also on errors that were unrelated to node setup or node connection errors.
The error message on using an invalid
rscript_envs argument for
makeClusterPSOCK() reported on the value of
makeNodePSOCK(..., rscript_envs = "UNKNOWN") would result in an error when trying to launch the cluster node.
find_rshcmd()which was never meant to be exported.
availableCores() better supports Slurm. Specifically, if environment variable
SLURM_CPUS_PER_TASK is not set, which requires that option
--slurm-cpus-per-task=n is specified and
SLURM_JOB_NUM_NODES=1, then it falls back to using
SLURM_CPUS_ON_NODE, e.g. when using
makeClusterPSOCK() will now retry to create a cluster node up to
tries (default: 3) times before giving up. If argument
port species more than one port (e.g.
port = "random") then it will also attempt find a valid random port up to
tries times before giving up. The pre-validation of the random port is only supported in R (>= 4.0.0) and skipped otherwise.
makeClusterPSOCK() skips shell quoting of the elements in
rscript if it inherits from
plan(cluster, workers = <number>), and
makeClusterPSOCK()which they both use internally, sets up localhost workers twice as fast compared to versions since future 1.12.0, which brings it back to par with a bare-bone
parallel::makeCluster(..., setup_strategy = "sequential")setup. The slowdown was introduced in future 1.12.0 (2019-03-07) when protection against leaving stray R processes behind from failed worker startup was implemented. This protection now makes use of memoization for speedup.
RichSOCKcluster gives information not only on the name of the host but also on the version of R and the platform of each node (“worker”), e.g. “Socket cluster with 3 nodes where 2 nodes are on host ‘localhost’ (R version 4.0.0 (2020-04-24), platform x86_64-w64-mingw32), 1 node is on host ‘n3’ (R version 3.6.3 (2020-02-29), platform x86_64-pc-linux-gnu)”.
It is now possible to set environment variables on workers before they are launched by
makeClusterPSOCK() by specify them as as
<name>=<value> as part of the
rscript vector argument, e.g.
rscript=c("ABC=123", "DEF='hello world'", "Rscript"). This works because elements in
rscript that match regular expression
"^ [[:alpha:]_][[:alnum:]_]*=.*" are no longer shell quoted.
makeClusterPSOCK() now returns a cluster that in addition to inheriting from
SOCKcluster it will also inherit from
makeClusterPSOCK(..., rscript) will not try to locate
rscript if argument
homogeneous is FALSE (or inferred to be FALSE).
makeClusterPSOCK(..., rscript_envs) would result in a syntax error when starting the workers due to non-ASCII quotation marks if option
useFancyQuotes was not set to FALSE.
rscript_envsfor setting environment variables in workers on startup, e.g.
rscript_envs = c(FOO = "3.14", "BAR").
_R_CHECK_LIMIT_CORES_set. To better emulate CRAN submission checks, the future package will, when loaded, set this environment variable to TRUE if unset and if
R CMD checkis running. Note that
_R_CHECK_LIMIT_CORES_and returns at most
2L(two cores) if detected.
makeClusterPSOCK()draws a random port from (when argument
portis not specified) can now be controlled by environment variable
R_FUTURE_RANDOM_PORTS. The default range is still
11000:11999as with the parallel package.
?makeClusterPSOCKwith instructions on how to troubleshoot when the setup of local and remote clusters fail.
availableCores() also recognizes PBS environment variable
NCPUS, because the PBSPro scheduler does not set
future.availableCores.custom is set to a function, then
availableCores() will call that function and interpret its value as number of cores. Analogously, option
future.availableWorkers.custom can be used to specify a hostnames of a set of workers that
availableWorkers() sees. These new options provide a mechanism for anyone to customize
availableWorkers() in case they do not (yet) recognize, say, environment variables that are specific the user’s compute environment or HPC scheduler.
makeClusterPSOCK() gained support for argument
rscript_startup for evaluating one or more R expressions in the background R worker prior to the worker event loop launching. This provides a more convenient approach than having to use, say,
rscript_args = c("-e", sQuote(code)).
makeClusterPSOCK() gained support for argument
rscript_libs to control the R package library search path on the workers. For example, to prepend the folder
~/R-libs on the workers, use
rscript_libs = c("~/R-libs", "*"), where
"*" will be resolved to the current
.libPaths() on the workers.
makeClusterPSOCK()did not shell quote the Rscript executable when running its pre-tests checking whether localhost Rscript processes can be killed by their PIDs or not.
makeClusterPSOCK()fails to create one of many nodes, then it will attempt to stop any nodes that were successfully created. This lowers the risk for leaving R worker processes behind.
makeClusterPSOCK()in future (>= 1.11.1) produced warnings when argument
length(rscript) > 1.
makeClusterPSOCK()fails to connect to a worker, it produces an error with detailed information on what could have happened. In rare cases, another error could be produced when generating the information on what the workers PID is.
R CMD checkis running or not. If it is, then a few future-specific environment variables are adjusted such that the tests play nice with the testing environment. For instance, it sets the socket connection timeout for PSOCK cluster workers to 120 seconds (instead of the default 30 days!). This will lower the risk for more and more zombie worker processes cluttering up the test machine (e.g. CRAN servers) in case a worker process is left behind despite the main R processes is terminated. Note that these adjustments are applied automatically to the checks of any package that depends on, or imports, the future package.
makeClusterPSOCK()would fail to connect to a worker, for instance due to a port clash, then it would leave the R worker process running - also after the main R process terminated. When the worker is running on the same machine,
makeClusterPSOCK()will now attempt to kill such stray R processes. Note that
parallel::makePSOCKcluster()still has this problem.
makeClusterPSOCK() produces more informative error messages whenever the setup of R workers fails. Also, its verbose messages are now prefixed with “[local output]” to help distinguish the output produced by the current R session from that produced by background workers.
It is now possible to specify what type of SSH clients
makeClusterPSOCK() automatically searches for and in what order, e.g.
rshcmd = c("<rstudio-ssh>", "<putty-plink>").
makeClusterPSOCK() preserves the global RNG state (
.Random.seed) also when it draws a random port number.
makeClusterPSOCK() gained argument
makeClusterMPI(n) for creating MPI-based clusters of a similar kind as
parallel::makeCluster(n, type = "MPI") but that also attempts to workaround issues where
parallel::stopCluster() causes R to stall.
makeClusterPSOCK()produced a warning when environment variable
R_PARALLEL_PORTwas set to
random(e.g. as on CRAN).
makeClusterPSOCK()now produces a more informative warning if environment variable
R_PARALLEL_PORTspecifies a non-numeric port.
makeClusterPSOCK(), and therefore
plan(multiprocess), will use the SSH client distributed with RStudio as a fallback if neither
plinkis available on the system
makeClusterPSOCK(..., renice = 19)would launch each PSOCK worker via
nice +19resulting in the error “nice: ‘+19’: No such file or directory”. This bug was inherited from
parallel::makePSOCKcluster(). Now using
makeClusterPSOCK() now defaults to use the Windows PuTTY software’s SSH client
plink -ssh, if
ssh is not found.
makeNodePSOCK(), a helper function of
makeClusterPSOCK(), will default to FALSE also if the hostname is a fully qualified domain name (FQDN), that is, it “contains periods”. For instance,
c('node1', 'node2.server.org') will use
homogeneous = TRUE for the first worker and
homogeneous = FALSE for the second.
makeClusterPSOCK() now asserts that each cluster node is functioning by retrieving and recording the node’s session information including the process ID of the corresponding R process.
makeClusterPSOCK()gained more detailed descriptions on arguments and what their defaults are.
makeNodePSOCK()can now be controlled via global options.
makeClusterPSOCK() treats workers that refer to a local machine by its local or canonical hostname as
"localhost". This avoids having to launch such workers over SSH, which may not be supported on all systems / compute cluster.
availableWorkers(). By default it returns localhost workers according to
availableCores(). In addition, it detects common HPC allocations given in environment variables set by the HPC scheduler.
future.availableCores.fallback, which defaults to environment variable
R_FUTURE_AVAILABLECORES_FALLBACK can now be used to specify the default number of cores / workers returned by
availableWorkers() when no other settings are available. For instance, if
R_FUTURE_AVAILABLECORES_FALLBACK=1 is set system wide in an HPC environment, then all R processes that uses
availableCores() to detect how many cores can be used will run as single-core processes. Without this fallback setting, and without other core-specifying settings, the default will be to use all cores on the machine, which does not play well on multi-user systems.
makeClusterPSOCK() - a version of
parallel::makePSOCKcluster() that allows for more flexible control of how PSOCK cluster workers are set up and how they are launched and communicated with if running on external machines.
as.cluster() for coercing objects to cluster objects to be used as in
plan(cluster, workers = as.cluster(x)). Also added a
c() implementation for cluster objects such that multiple cluster objects can be combined into a single one.
workers = "localhost"they (again) use the exact same R executable as the main / calling R session (in all other cases it uses whatever
Rscriptis found on the
PATH). This was already indeed implemented in 1.0.1, but with the added support for reverse SSH tunnels in 1.1.0 this default behavior was lost.
remote()to connect to remote clusters / machines. As long as you can connect via SSH to those machines, it works also with these future. The new code completely avoids incoming firewall and incoming port forwarding issues previously needed. This is done by using reverse SSH tunneling. There is also no need to worry about internal or external IP numbers.
availableCores()also acknowledges environment variable
NSLOTSset by Sun/Oracle Grid Engine (SGE).
2L+1L) instead of
availableCores()also acknowledges the number of CPUs allotted by Slurm.