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).