run() for CallrFuture would update the RNG
state, because callr::r_bg(), used to launch the future,
does so. This would compromise numeric reproducibility, where the
callr future backend would not give the same random numbers
as other future backends. Now run() launches the future in
stealth RNG mode, i.e. gives r_bg() a semi-random initial
seed to work with (by removing .Random.seed) and then undo
the RNG state at the very end.Now resolved() supports early signaling.
Now result() and value() gives a
slightly more informative error message in case the
callr process failed with a non-zero exit
code.
Add option to configure callr futures to be
“supervised” by the callr package when setting up the
plan, i.e. plan(callr, supervise = TRUE).
Now callr-specific orchestration errors are of class
CallrFutureError, which provides information also on the
future that failed.
await(), which was used for
internal purposes.nbrOfFreeWorkers().await(), which was used for
internal purposes.resolved() for CallrFuture will launch
lazy futures [future (>= 1.15.0)].top) via a dummy
--future-label="<label>" argument in the
callr system call.plan(callr, workers) where workers being a
function would result in an error when a future was created.plan(list(callr, callr)) the second layer of
futures would use the same number of workers as the first layer.Argument workers of future strategies may now also
be a function, which is called without argument when the future strategy
is set up and used as is. For instance,
plan(callr, workers = halfCores) where
halfCores <- function() { max(1, round(availableCores() / 2)) }
will use half of the number of available cores. This is useful when
using nested future strategies with remote machines.
Gathering of results from background processes is made a little bit more robust against slow file systems by retrying a few times before accepting an error as an error.
future.wait.timeout.FutureError where
applicable.plan(callr, workers = n) was not
respected.plan(callr) or
plan(callr, workers = 4L).