R Under development (unstable) (2024-07-28 r86931 ucrt) -- "Unsuffered Consequences"
Copyright (C) 2024 The R Foundation for Statistical Computing
Platform: x86_64-w64-mingw32/x64

R is free software and comes with ABSOLUTELY NO WARRANTY.
You are welcome to redistribute it under certain conditions.
Type 'license()' or 'licence()' for distribution details.

R is a collaborative project with many contributors.
Type 'contributors()' for more information and
'citation()' on how to cite R or R packages in publications.

Type 'demo()' for some demos, 'help()' for on-line help, or
'help.start()' for an HTML browser interface to help.
Type 'q()' to quit R.

> source("incl/start.R")
[17:28:25.694] plan(): Setting new future strategy stack:
[17:28:25.696] List of future strategies:
[17:28:25.696] 1. sequential:
[17:28:25.696]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:25.696]    - tweaked: FALSE
[17:28:25.696]    - call: future::plan("sequential")
[17:28:25.725] plan(): nbrOfWorkers() = 1
> library("listenv")
> 
> message("*** multisession() ...")
*** multisession() ...
> 
> for (cores in 1:availCores) {
+   ## Speed up CRAN checks: Skip on CRAN Windows 32-bit
+   if (!fullTest && isWin32) next
+   
+   message(sprintf("Testing with %d cores ...", cores))
+   options(mc.cores = cores)
+ 
+   ## No global variables
+   f <- multisession({
+     42L
+   })
+   print(f)
+   stopifnot(inherits(f, "ClusterFuture") || (inherits(f, "SequentialFuture") && f$lazy))
+ 
+   print(resolved(f))
+   y <- value(f)
+   print(y)
+   stopifnot(y == 42L)
+ 
+ 
+   ## A global variable
+   a <- 0
+   f <- multisession({
+     b <- 3
+     c <- 2
+     a * b * c
+   }, globals = TRUE)
+   print(f)
+ 
+ 
+   ## A multisession future is evaluated in a separate
+   ## R session process.  Changing the value of a global
+   ## variable should not affect the result of the
+   ## future.
+   a <- 7  ## Make sure globals are frozen
+   v <- value(f)
+   print(v)
+   stopifnot(v == 0)
+ 
+ 
+   message("*** multisession() with globals and blocking")
+   x <- listenv()
+   for (ii in 2:1) {
+     message(sprintf(" - Creating multisession future #%d ...", ii))
+     x[[ii]] <- multisession({ ii }, globals = TRUE)
+   }
+   message(sprintf(" - Resolving %d multisession futures", length(x)))
+   v <- sapply(x, FUN = value)
+   stopifnot(all(v == 1:2))
+ 
+ 
+   message("*** multisession() - workers inherit .libPaths()")
+ 
+   libs <- value(future(.libPaths()))
+   str(list(
+     main = .libPaths(),
+     workers = libs
+   ))
+   stopifnot(identical(libs, .libPaths()))
+ 
+   message("*** multisession() and errors")
+   f <- multisession({
+     stop("Whoops!")
+     1
+   })
+   print(f)
+   v <- value(f, signal = FALSE)
+   print(v)
+   stopifnot(inherits(v, "simpleError"))
+ 
+   res <- try(value(f), silent = TRUE)
+   print(res)
+   stopifnot(inherits(res, "try-error"))
+ 
+   ## Error is repeated
+   res <- try(value(f), silent = TRUE)
+   print(res)
+   stopifnot(inherits(res, "try-error"))
+ 
+   ## Custom error class
+   f <- multisession({
+     stop(structure(list(message = "boom"),
+                    class = c("MyError", "error", "condition")))
+   })
+   print(f)
+   v <- value(f, signal = FALSE)
+   print(v)
+   stopifnot(inherits(v, "error"), inherits(v, "MyError"))
+ 
+   ## Make sure error is signaled
+   res <- tryCatch(value(f), error = identity)
+   stopifnot(inherits(res, "error"))
+ 
+   ## Issue #200: Custom condition class attributes are lost
+   ## https://github.com/HenrikBengtsson/Wishlist-for-R/issues/57
+   ## stopifnot(inherits(res, "MyError"))    
+ 
+   ## Make sure to stop these cluster processes to avoid triggering
+   ## checking for detritus in the temp directory ... NOTE
+   ClusterRegistry(action = "stop")
+ 
+   message(sprintf("Testing with %d cores ... DONE", cores))
+ } ## for (cores ...)
Testing with 1 cores ...
[17:28:25.840] getGlobalsAndPackages() ...
[17:28:25.840] Searching for globals...
[17:28:25.846] - globals found: [1] '{'
[17:28:25.847] Searching for globals ... DONE
[17:28:25.847] Resolving globals: FALSE
[17:28:25.849] 
[17:28:25.849] 
[17:28:25.849] getGlobalsAndPackages() ... DONE
SequentialFuture:
Label: '<none>'
Expression:
{
    42L
}
Lazy evaluation: TRUE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: FALSE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 12734a8a-480b-f2a5-0c96-45c13d81d854
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:25.852] Packages needed by the future expression (n = 0): <none>
[17:28:25.852] Packages needed by future strategies (n = 0): <none>
[17:28:25.854] {
[17:28:25.854]     {
[17:28:25.854]         {
[17:28:25.854]             ...future.startTime <- base::Sys.time()
[17:28:25.854]             {
[17:28:25.854]                 {
[17:28:25.854]                   {
[17:28:25.854]                     base::local({
[17:28:25.854]                       has_future <- base::requireNamespace("future", 
[17:28:25.854]                         quietly = TRUE)
[17:28:25.854]                       if (has_future) {
[17:28:25.854]                         ns <- base::getNamespace("future")
[17:28:25.854]                         version <- ns[[".package"]][["version"]]
[17:28:25.854]                         if (is.null(version)) 
[17:28:25.854]                           version <- utils::packageVersion("future")
[17:28:25.854]                       }
[17:28:25.854]                       else {
[17:28:25.854]                         version <- NULL
[17:28:25.854]                       }
[17:28:25.854]                       if (!has_future || version < "1.8.0") {
[17:28:25.854]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:25.854]                           "", base::R.version$version.string), 
[17:28:25.854]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:25.854]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:25.854]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:25.854]                             "release", "version")], collapse = " "), 
[17:28:25.854]                           hostname = base::Sys.info()[["nodename"]])
[17:28:25.854]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:25.854]                           info)
[17:28:25.854]                         info <- base::paste(info, collapse = "; ")
[17:28:25.854]                         if (!has_future) {
[17:28:25.854]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:25.854]                             info)
[17:28:25.854]                         }
[17:28:25.854]                         else {
[17:28:25.854]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:25.854]                             info, version)
[17:28:25.854]                         }
[17:28:25.854]                         base::stop(msg)
[17:28:25.854]                       }
[17:28:25.854]                     })
[17:28:25.854]                   }
[17:28:25.854]                   ...future.strategy.old <- future::plan("list")
[17:28:25.854]                   options(future.plan = NULL)
[17:28:25.854]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:25.854]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:25.854]                 }
[17:28:25.854]                 ...future.workdir <- getwd()
[17:28:25.854]             }
[17:28:25.854]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:25.854]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:25.854]         }
[17:28:25.854]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:25.854]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:25.854]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:25.854]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:25.854]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:25.854]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:25.854]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:25.854]             base::names(...future.oldOptions))
[17:28:25.854]     }
[17:28:25.854]     if (FALSE) {
[17:28:25.854]     }
[17:28:25.854]     else {
[17:28:25.854]         if (TRUE) {
[17:28:25.854]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:25.854]                 open = "w")
[17:28:25.854]         }
[17:28:25.854]         else {
[17:28:25.854]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:25.854]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:25.854]         }
[17:28:25.854]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:25.854]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:25.854]             base::sink(type = "output", split = FALSE)
[17:28:25.854]             base::close(...future.stdout)
[17:28:25.854]         }, add = TRUE)
[17:28:25.854]     }
[17:28:25.854]     ...future.frame <- base::sys.nframe()
[17:28:25.854]     ...future.conditions <- base::list()
[17:28:25.854]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:25.854]     if (FALSE) {
[17:28:25.854]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:25.854]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:25.854]     }
[17:28:25.854]     ...future.result <- base::tryCatch({
[17:28:25.854]         base::withCallingHandlers({
[17:28:25.854]             ...future.value <- base::withVisible(base::local({
[17:28:25.854]                 42L
[17:28:25.854]             }))
[17:28:25.854]             future::FutureResult(value = ...future.value$value, 
[17:28:25.854]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:25.854]                   ...future.rng), globalenv = if (FALSE) 
[17:28:25.854]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:25.854]                     ...future.globalenv.names))
[17:28:25.854]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:25.854]         }, condition = base::local({
[17:28:25.854]             c <- base::c
[17:28:25.854]             inherits <- base::inherits
[17:28:25.854]             invokeRestart <- base::invokeRestart
[17:28:25.854]             length <- base::length
[17:28:25.854]             list <- base::list
[17:28:25.854]             seq.int <- base::seq.int
[17:28:25.854]             signalCondition <- base::signalCondition
[17:28:25.854]             sys.calls <- base::sys.calls
[17:28:25.854]             `[[` <- base::`[[`
[17:28:25.854]             `+` <- base::`+`
[17:28:25.854]             `<<-` <- base::`<<-`
[17:28:25.854]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:25.854]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:25.854]                   3L)]
[17:28:25.854]             }
[17:28:25.854]             function(cond) {
[17:28:25.854]                 is_error <- inherits(cond, "error")
[17:28:25.854]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:25.854]                   NULL)
[17:28:25.854]                 if (is_error) {
[17:28:25.854]                   sessionInformation <- function() {
[17:28:25.854]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:25.854]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:25.854]                       search = base::search(), system = base::Sys.info())
[17:28:25.854]                   }
[17:28:25.854]                   ...future.conditions[[length(...future.conditions) + 
[17:28:25.854]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:25.854]                     cond$call), session = sessionInformation(), 
[17:28:25.854]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:25.854]                   signalCondition(cond)
[17:28:25.854]                 }
[17:28:25.854]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:25.854]                 "immediateCondition"))) {
[17:28:25.854]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:25.854]                   ...future.conditions[[length(...future.conditions) + 
[17:28:25.854]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:25.854]                   if (TRUE && !signal) {
[17:28:25.854]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:25.854]                     {
[17:28:25.854]                       inherits <- base::inherits
[17:28:25.854]                       invokeRestart <- base::invokeRestart
[17:28:25.854]                       is.null <- base::is.null
[17:28:25.854]                       muffled <- FALSE
[17:28:25.854]                       if (inherits(cond, "message")) {
[17:28:25.854]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:25.854]                         if (muffled) 
[17:28:25.854]                           invokeRestart("muffleMessage")
[17:28:25.854]                       }
[17:28:25.854]                       else if (inherits(cond, "warning")) {
[17:28:25.854]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:25.854]                         if (muffled) 
[17:28:25.854]                           invokeRestart("muffleWarning")
[17:28:25.854]                       }
[17:28:25.854]                       else if (inherits(cond, "condition")) {
[17:28:25.854]                         if (!is.null(pattern)) {
[17:28:25.854]                           computeRestarts <- base::computeRestarts
[17:28:25.854]                           grepl <- base::grepl
[17:28:25.854]                           restarts <- computeRestarts(cond)
[17:28:25.854]                           for (restart in restarts) {
[17:28:25.854]                             name <- restart$name
[17:28:25.854]                             if (is.null(name)) 
[17:28:25.854]                               next
[17:28:25.854]                             if (!grepl(pattern, name)) 
[17:28:25.854]                               next
[17:28:25.854]                             invokeRestart(restart)
[17:28:25.854]                             muffled <- TRUE
[17:28:25.854]                             break
[17:28:25.854]                           }
[17:28:25.854]                         }
[17:28:25.854]                       }
[17:28:25.854]                       invisible(muffled)
[17:28:25.854]                     }
[17:28:25.854]                     muffleCondition(cond, pattern = "^muffle")
[17:28:25.854]                   }
[17:28:25.854]                 }
[17:28:25.854]                 else {
[17:28:25.854]                   if (TRUE) {
[17:28:25.854]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:25.854]                     {
[17:28:25.854]                       inherits <- base::inherits
[17:28:25.854]                       invokeRestart <- base::invokeRestart
[17:28:25.854]                       is.null <- base::is.null
[17:28:25.854]                       muffled <- FALSE
[17:28:25.854]                       if (inherits(cond, "message")) {
[17:28:25.854]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:25.854]                         if (muffled) 
[17:28:25.854]                           invokeRestart("muffleMessage")
[17:28:25.854]                       }
[17:28:25.854]                       else if (inherits(cond, "warning")) {
[17:28:25.854]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:25.854]                         if (muffled) 
[17:28:25.854]                           invokeRestart("muffleWarning")
[17:28:25.854]                       }
[17:28:25.854]                       else if (inherits(cond, "condition")) {
[17:28:25.854]                         if (!is.null(pattern)) {
[17:28:25.854]                           computeRestarts <- base::computeRestarts
[17:28:25.854]                           grepl <- base::grepl
[17:28:25.854]                           restarts <- computeRestarts(cond)
[17:28:25.854]                           for (restart in restarts) {
[17:28:25.854]                             name <- restart$name
[17:28:25.854]                             if (is.null(name)) 
[17:28:25.854]                               next
[17:28:25.854]                             if (!grepl(pattern, name)) 
[17:28:25.854]                               next
[17:28:25.854]                             invokeRestart(restart)
[17:28:25.854]                             muffled <- TRUE
[17:28:25.854]                             break
[17:28:25.854]                           }
[17:28:25.854]                         }
[17:28:25.854]                       }
[17:28:25.854]                       invisible(muffled)
[17:28:25.854]                     }
[17:28:25.854]                     muffleCondition(cond, pattern = "^muffle")
[17:28:25.854]                   }
[17:28:25.854]                 }
[17:28:25.854]             }
[17:28:25.854]         }))
[17:28:25.854]     }, error = function(ex) {
[17:28:25.854]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:25.854]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:25.854]                 ...future.rng), started = ...future.startTime, 
[17:28:25.854]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:25.854]             version = "1.8"), class = "FutureResult")
[17:28:25.854]     }, finally = {
[17:28:25.854]         if (!identical(...future.workdir, getwd())) 
[17:28:25.854]             setwd(...future.workdir)
[17:28:25.854]         {
[17:28:25.854]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:25.854]                 ...future.oldOptions$nwarnings <- NULL
[17:28:25.854]             }
[17:28:25.854]             base::options(...future.oldOptions)
[17:28:25.854]             if (.Platform$OS.type == "windows") {
[17:28:25.854]                 old_names <- names(...future.oldEnvVars)
[17:28:25.854]                 envs <- base::Sys.getenv()
[17:28:25.854]                 names <- names(envs)
[17:28:25.854]                 common <- intersect(names, old_names)
[17:28:25.854]                 added <- setdiff(names, old_names)
[17:28:25.854]                 removed <- setdiff(old_names, names)
[17:28:25.854]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:25.854]                   envs[common]]
[17:28:25.854]                 NAMES <- toupper(changed)
[17:28:25.854]                 args <- list()
[17:28:25.854]                 for (kk in seq_along(NAMES)) {
[17:28:25.854]                   name <- changed[[kk]]
[17:28:25.854]                   NAME <- NAMES[[kk]]
[17:28:25.854]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:25.854]                     next
[17:28:25.854]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:25.854]                 }
[17:28:25.854]                 NAMES <- toupper(added)
[17:28:25.854]                 for (kk in seq_along(NAMES)) {
[17:28:25.854]                   name <- added[[kk]]
[17:28:25.854]                   NAME <- NAMES[[kk]]
[17:28:25.854]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:25.854]                     next
[17:28:25.854]                   args[[name]] <- ""
[17:28:25.854]                 }
[17:28:25.854]                 NAMES <- toupper(removed)
[17:28:25.854]                 for (kk in seq_along(NAMES)) {
[17:28:25.854]                   name <- removed[[kk]]
[17:28:25.854]                   NAME <- NAMES[[kk]]
[17:28:25.854]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:25.854]                     next
[17:28:25.854]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:25.854]                 }
[17:28:25.854]                 if (length(args) > 0) 
[17:28:25.854]                   base::do.call(base::Sys.setenv, args = args)
[17:28:25.854]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:25.854]             }
[17:28:25.854]             else {
[17:28:25.854]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:25.854]             }
[17:28:25.854]             {
[17:28:25.854]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:25.854]                   0L) {
[17:28:25.854]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:25.854]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:25.854]                   base::options(opts)
[17:28:25.854]                 }
[17:28:25.854]                 {
[17:28:25.854]                   {
[17:28:25.854]                     NULL
[17:28:25.854]                     RNGkind("Mersenne-Twister")
[17:28:25.854]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:25.854]                       inherits = FALSE)
[17:28:25.854]                   }
[17:28:25.854]                   options(future.plan = NULL)
[17:28:25.854]                   if (is.na(NA_character_)) 
[17:28:25.854]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:25.854]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:25.854]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:25.854]                     .init = FALSE)
[17:28:25.854]                 }
[17:28:25.854]             }
[17:28:25.854]         }
[17:28:25.854]     })
[17:28:25.854]     if (TRUE) {
[17:28:25.854]         base::sink(type = "output", split = FALSE)
[17:28:25.854]         if (TRUE) {
[17:28:25.854]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:25.854]         }
[17:28:25.854]         else {
[17:28:25.854]             ...future.result["stdout"] <- base::list(NULL)
[17:28:25.854]         }
[17:28:25.854]         base::close(...future.stdout)
[17:28:25.854]         ...future.stdout <- NULL
[17:28:25.854]     }
[17:28:25.854]     ...future.result$conditions <- ...future.conditions
[17:28:25.854]     ...future.result$finished <- base::Sys.time()
[17:28:25.854]     ...future.result
[17:28:25.854] }
[17:28:25.860] plan(): Setting new future strategy stack:
[17:28:25.860] List of future strategies:
[17:28:25.860] 1. sequential:
[17:28:25.860]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:25.860]    - tweaked: FALSE
[17:28:25.860]    - call: NULL
[17:28:25.861] plan(): nbrOfWorkers() = 1
[17:28:25.865] plan(): Setting new future strategy stack:
[17:28:25.866] List of future strategies:
[17:28:25.866] 1. sequential:
[17:28:25.866]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:25.866]    - tweaked: FALSE
[17:28:25.866]    - call: future::plan("sequential")
[17:28:25.867] plan(): nbrOfWorkers() = 1
[17:28:25.868] SequentialFuture started (and completed)
[17:28:25.869] resolved() for 'SequentialFuture' ...
[17:28:25.869] - state: 'finished'
[17:28:25.870] - run: TRUE
[17:28:25.870] - result: 'FutureResult'
[17:28:25.871] resolved() for 'SequentialFuture' ... done
[1] TRUE
[1] 42
[17:28:25.876] getGlobalsAndPackages() ...
[17:28:25.877] Searching for globals...
[17:28:25.889] - globals found: [4] '{', '<-', '*', 'a'
[17:28:25.890] Searching for globals ... DONE
[17:28:25.890] Resolving globals: FALSE
[17:28:25.892] The total size of the 1 globals is 39 bytes (39 bytes)
[17:28:25.899] The total size of the 1 globals exported for future expression ('{; b <- 3; c <- 2; a * b * c; }') is 39 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'a' (39 bytes of class 'numeric')
[17:28:25.900] - globals: [1] 'a'
[17:28:25.900] 
[17:28:25.900] getGlobalsAndPackages() ... DONE
SequentialFuture:
Label: '<none>'
Expression:
{
    b <- 3
    c <- 2
    a * b * c
}
Lazy evaluation: TRUE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 39 bytes (numeric 'a' of 39 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: FALSE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 12734a8a-480b-f2a5-0c96-45c13d81d854
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:25.903] Packages needed by the future expression (n = 0): <none>
[17:28:25.904] Packages needed by future strategies (n = 0): <none>
[17:28:25.905] {
[17:28:25.905]     {
[17:28:25.905]         {
[17:28:25.905]             ...future.startTime <- base::Sys.time()
[17:28:25.905]             {
[17:28:25.905]                 {
[17:28:25.905]                   {
[17:28:25.905]                     base::local({
[17:28:25.905]                       has_future <- base::requireNamespace("future", 
[17:28:25.905]                         quietly = TRUE)
[17:28:25.905]                       if (has_future) {
[17:28:25.905]                         ns <- base::getNamespace("future")
[17:28:25.905]                         version <- ns[[".package"]][["version"]]
[17:28:25.905]                         if (is.null(version)) 
[17:28:25.905]                           version <- utils::packageVersion("future")
[17:28:25.905]                       }
[17:28:25.905]                       else {
[17:28:25.905]                         version <- NULL
[17:28:25.905]                       }
[17:28:25.905]                       if (!has_future || version < "1.8.0") {
[17:28:25.905]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:25.905]                           "", base::R.version$version.string), 
[17:28:25.905]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:25.905]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:25.905]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:25.905]                             "release", "version")], collapse = " "), 
[17:28:25.905]                           hostname = base::Sys.info()[["nodename"]])
[17:28:25.905]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:25.905]                           info)
[17:28:25.905]                         info <- base::paste(info, collapse = "; ")
[17:28:25.905]                         if (!has_future) {
[17:28:25.905]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:25.905]                             info)
[17:28:25.905]                         }
[17:28:25.905]                         else {
[17:28:25.905]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:25.905]                             info, version)
[17:28:25.905]                         }
[17:28:25.905]                         base::stop(msg)
[17:28:25.905]                       }
[17:28:25.905]                     })
[17:28:25.905]                   }
[17:28:25.905]                   ...future.strategy.old <- future::plan("list")
[17:28:25.905]                   options(future.plan = NULL)
[17:28:25.905]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:25.905]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:25.905]                 }
[17:28:25.905]                 ...future.workdir <- getwd()
[17:28:25.905]             }
[17:28:25.905]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:25.905]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:25.905]         }
[17:28:25.905]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:25.905]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:25.905]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:25.905]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:25.905]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:25.905]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:25.905]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:25.905]             base::names(...future.oldOptions))
[17:28:25.905]     }
[17:28:25.905]     if (FALSE) {
[17:28:25.905]     }
[17:28:25.905]     else {
[17:28:25.905]         if (TRUE) {
[17:28:25.905]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:25.905]                 open = "w")
[17:28:25.905]         }
[17:28:25.905]         else {
[17:28:25.905]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:25.905]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:25.905]         }
[17:28:25.905]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:25.905]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:25.905]             base::sink(type = "output", split = FALSE)
[17:28:25.905]             base::close(...future.stdout)
[17:28:25.905]         }, add = TRUE)
[17:28:25.905]     }
[17:28:25.905]     ...future.frame <- base::sys.nframe()
[17:28:25.905]     ...future.conditions <- base::list()
[17:28:25.905]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:25.905]     if (FALSE) {
[17:28:25.905]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:25.905]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:25.905]     }
[17:28:25.905]     ...future.result <- base::tryCatch({
[17:28:25.905]         base::withCallingHandlers({
[17:28:25.905]             ...future.value <- base::withVisible(base::local({
[17:28:25.905]                 b <- 3
[17:28:25.905]                 c <- 2
[17:28:25.905]                 a * b * c
[17:28:25.905]             }))
[17:28:25.905]             future::FutureResult(value = ...future.value$value, 
[17:28:25.905]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:25.905]                   ...future.rng), globalenv = if (FALSE) 
[17:28:25.905]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:25.905]                     ...future.globalenv.names))
[17:28:25.905]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:25.905]         }, condition = base::local({
[17:28:25.905]             c <- base::c
[17:28:25.905]             inherits <- base::inherits
[17:28:25.905]             invokeRestart <- base::invokeRestart
[17:28:25.905]             length <- base::length
[17:28:25.905]             list <- base::list
[17:28:25.905]             seq.int <- base::seq.int
[17:28:25.905]             signalCondition <- base::signalCondition
[17:28:25.905]             sys.calls <- base::sys.calls
[17:28:25.905]             `[[` <- base::`[[`
[17:28:25.905]             `+` <- base::`+`
[17:28:25.905]             `<<-` <- base::`<<-`
[17:28:25.905]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:25.905]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:25.905]                   3L)]
[17:28:25.905]             }
[17:28:25.905]             function(cond) {
[17:28:25.905]                 is_error <- inherits(cond, "error")
[17:28:25.905]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:25.905]                   NULL)
[17:28:25.905]                 if (is_error) {
[17:28:25.905]                   sessionInformation <- function() {
[17:28:25.905]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:25.905]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:25.905]                       search = base::search(), system = base::Sys.info())
[17:28:25.905]                   }
[17:28:25.905]                   ...future.conditions[[length(...future.conditions) + 
[17:28:25.905]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:25.905]                     cond$call), session = sessionInformation(), 
[17:28:25.905]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:25.905]                   signalCondition(cond)
[17:28:25.905]                 }
[17:28:25.905]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:25.905]                 "immediateCondition"))) {
[17:28:25.905]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:25.905]                   ...future.conditions[[length(...future.conditions) + 
[17:28:25.905]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:25.905]                   if (TRUE && !signal) {
[17:28:25.905]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:25.905]                     {
[17:28:25.905]                       inherits <- base::inherits
[17:28:25.905]                       invokeRestart <- base::invokeRestart
[17:28:25.905]                       is.null <- base::is.null
[17:28:25.905]                       muffled <- FALSE
[17:28:25.905]                       if (inherits(cond, "message")) {
[17:28:25.905]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:25.905]                         if (muffled) 
[17:28:25.905]                           invokeRestart("muffleMessage")
[17:28:25.905]                       }
[17:28:25.905]                       else if (inherits(cond, "warning")) {
[17:28:25.905]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:25.905]                         if (muffled) 
[17:28:25.905]                           invokeRestart("muffleWarning")
[17:28:25.905]                       }
[17:28:25.905]                       else if (inherits(cond, "condition")) {
[17:28:25.905]                         if (!is.null(pattern)) {
[17:28:25.905]                           computeRestarts <- base::computeRestarts
[17:28:25.905]                           grepl <- base::grepl
[17:28:25.905]                           restarts <- computeRestarts(cond)
[17:28:25.905]                           for (restart in restarts) {
[17:28:25.905]                             name <- restart$name
[17:28:25.905]                             if (is.null(name)) 
[17:28:25.905]                               next
[17:28:25.905]                             if (!grepl(pattern, name)) 
[17:28:25.905]                               next
[17:28:25.905]                             invokeRestart(restart)
[17:28:25.905]                             muffled <- TRUE
[17:28:25.905]                             break
[17:28:25.905]                           }
[17:28:25.905]                         }
[17:28:25.905]                       }
[17:28:25.905]                       invisible(muffled)
[17:28:25.905]                     }
[17:28:25.905]                     muffleCondition(cond, pattern = "^muffle")
[17:28:25.905]                   }
[17:28:25.905]                 }
[17:28:25.905]                 else {
[17:28:25.905]                   if (TRUE) {
[17:28:25.905]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:25.905]                     {
[17:28:25.905]                       inherits <- base::inherits
[17:28:25.905]                       invokeRestart <- base::invokeRestart
[17:28:25.905]                       is.null <- base::is.null
[17:28:25.905]                       muffled <- FALSE
[17:28:25.905]                       if (inherits(cond, "message")) {
[17:28:25.905]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:25.905]                         if (muffled) 
[17:28:25.905]                           invokeRestart("muffleMessage")
[17:28:25.905]                       }
[17:28:25.905]                       else if (inherits(cond, "warning")) {
[17:28:25.905]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:25.905]                         if (muffled) 
[17:28:25.905]                           invokeRestart("muffleWarning")
[17:28:25.905]                       }
[17:28:25.905]                       else if (inherits(cond, "condition")) {
[17:28:25.905]                         if (!is.null(pattern)) {
[17:28:25.905]                           computeRestarts <- base::computeRestarts
[17:28:25.905]                           grepl <- base::grepl
[17:28:25.905]                           restarts <- computeRestarts(cond)
[17:28:25.905]                           for (restart in restarts) {
[17:28:25.905]                             name <- restart$name
[17:28:25.905]                             if (is.null(name)) 
[17:28:25.905]                               next
[17:28:25.905]                             if (!grepl(pattern, name)) 
[17:28:25.905]                               next
[17:28:25.905]                             invokeRestart(restart)
[17:28:25.905]                             muffled <- TRUE
[17:28:25.905]                             break
[17:28:25.905]                           }
[17:28:25.905]                         }
[17:28:25.905]                       }
[17:28:25.905]                       invisible(muffled)
[17:28:25.905]                     }
[17:28:25.905]                     muffleCondition(cond, pattern = "^muffle")
[17:28:25.905]                   }
[17:28:25.905]                 }
[17:28:25.905]             }
[17:28:25.905]         }))
[17:28:25.905]     }, error = function(ex) {
[17:28:25.905]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:25.905]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:25.905]                 ...future.rng), started = ...future.startTime, 
[17:28:25.905]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:25.905]             version = "1.8"), class = "FutureResult")
[17:28:25.905]     }, finally = {
[17:28:25.905]         if (!identical(...future.workdir, getwd())) 
[17:28:25.905]             setwd(...future.workdir)
[17:28:25.905]         {
[17:28:25.905]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:25.905]                 ...future.oldOptions$nwarnings <- NULL
[17:28:25.905]             }
[17:28:25.905]             base::options(...future.oldOptions)
[17:28:25.905]             if (.Platform$OS.type == "windows") {
[17:28:25.905]                 old_names <- names(...future.oldEnvVars)
[17:28:25.905]                 envs <- base::Sys.getenv()
[17:28:25.905]                 names <- names(envs)
[17:28:25.905]                 common <- intersect(names, old_names)
[17:28:25.905]                 added <- setdiff(names, old_names)
[17:28:25.905]                 removed <- setdiff(old_names, names)
[17:28:25.905]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:25.905]                   envs[common]]
[17:28:25.905]                 NAMES <- toupper(changed)
[17:28:25.905]                 args <- list()
[17:28:25.905]                 for (kk in seq_along(NAMES)) {
[17:28:25.905]                   name <- changed[[kk]]
[17:28:25.905]                   NAME <- NAMES[[kk]]
[17:28:25.905]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:25.905]                     next
[17:28:25.905]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:25.905]                 }
[17:28:25.905]                 NAMES <- toupper(added)
[17:28:25.905]                 for (kk in seq_along(NAMES)) {
[17:28:25.905]                   name <- added[[kk]]
[17:28:25.905]                   NAME <- NAMES[[kk]]
[17:28:25.905]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:25.905]                     next
[17:28:25.905]                   args[[name]] <- ""
[17:28:25.905]                 }
[17:28:25.905]                 NAMES <- toupper(removed)
[17:28:25.905]                 for (kk in seq_along(NAMES)) {
[17:28:25.905]                   name <- removed[[kk]]
[17:28:25.905]                   NAME <- NAMES[[kk]]
[17:28:25.905]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:25.905]                     next
[17:28:25.905]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:25.905]                 }
[17:28:25.905]                 if (length(args) > 0) 
[17:28:25.905]                   base::do.call(base::Sys.setenv, args = args)
[17:28:25.905]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:25.905]             }
[17:28:25.905]             else {
[17:28:25.905]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:25.905]             }
[17:28:25.905]             {
[17:28:25.905]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:25.905]                   0L) {
[17:28:25.905]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:25.905]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:25.905]                   base::options(opts)
[17:28:25.905]                 }
[17:28:25.905]                 {
[17:28:25.905]                   {
[17:28:25.905]                     NULL
[17:28:25.905]                     RNGkind("Mersenne-Twister")
[17:28:25.905]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:25.905]                       inherits = FALSE)
[17:28:25.905]                   }
[17:28:25.905]                   options(future.plan = NULL)
[17:28:25.905]                   if (is.na(NA_character_)) 
[17:28:25.905]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:25.905]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:25.905]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:25.905]                     .init = FALSE)
[17:28:25.905]                 }
[17:28:25.905]             }
[17:28:25.905]         }
[17:28:25.905]     })
[17:28:25.905]     if (TRUE) {
[17:28:25.905]         base::sink(type = "output", split = FALSE)
[17:28:25.905]         if (TRUE) {
[17:28:25.905]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:25.905]         }
[17:28:25.905]         else {
[17:28:25.905]             ...future.result["stdout"] <- base::list(NULL)
[17:28:25.905]         }
[17:28:25.905]         base::close(...future.stdout)
[17:28:25.905]         ...future.stdout <- NULL
[17:28:25.905]     }
[17:28:25.905]     ...future.result$conditions <- ...future.conditions
[17:28:25.905]     ...future.result$finished <- base::Sys.time()
[17:28:25.905]     ...future.result
[17:28:25.905] }
[17:28:25.914] assign_globals() ...
[17:28:25.914] List of 1
[17:28:25.914]  $ a: num 0
[17:28:25.914]  - attr(*, "where")=List of 1
[17:28:25.914]   ..$ a:<environment: R_EmptyEnv> 
[17:28:25.914]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:25.914]  - attr(*, "resolved")= logi FALSE
[17:28:25.914]  - attr(*, "total_size")= int 39
[17:28:25.924] - copied 'a' to environment
[17:28:25.925] assign_globals() ... done
[17:28:25.926] plan(): Setting new future strategy stack:
[17:28:25.926] List of future strategies:
[17:28:25.926] 1. sequential:
[17:28:25.926]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:25.926]    - tweaked: FALSE
[17:28:25.926]    - call: NULL
[17:28:25.927] plan(): nbrOfWorkers() = 1
[17:28:25.930] plan(): Setting new future strategy stack:
[17:28:25.930] List of future strategies:
[17:28:25.930] 1. sequential:
[17:28:25.930]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:25.930]    - tweaked: FALSE
[17:28:25.930]    - call: future::plan("sequential")
[17:28:25.932] plan(): nbrOfWorkers() = 1
[17:28:25.933] SequentialFuture started (and completed)
[1] 0
*** multisession() with globals and blocking
 - Creating multisession future #2 ...
[17:28:25.939] getGlobalsAndPackages() ...
[17:28:25.939] Searching for globals...
[17:28:25.941] - globals found: [2] '{', 'ii'
[17:28:25.941] Searching for globals ... DONE
[17:28:25.942] Resolving globals: FALSE
[17:28:25.943] The total size of the 1 globals is 35 bytes (35 bytes)
[17:28:25.944] The total size of the 1 globals exported for future expression ('{; ii; }') is 35 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'ii' (35 bytes of class 'numeric')
[17:28:25.944] - globals: [1] 'ii'
[17:28:25.945] 
[17:28:25.945] getGlobalsAndPackages() ... DONE
 - Creating multisession future #1 ...
[17:28:25.950] getGlobalsAndPackages() ...
[17:28:25.950] Searching for globals...
[17:28:25.952] - globals found: [2] '{', 'ii'
[17:28:25.952] Searching for globals ... DONE
[17:28:25.953] Resolving globals: FALSE
[17:28:25.954] The total size of the 1 globals is 35 bytes (35 bytes)
[17:28:25.955] The total size of the 1 globals exported for future expression ('{; ii; }') is 35 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'ii' (35 bytes of class 'numeric')
[17:28:25.955] - globals: [1] 'ii'
[17:28:25.956] 
[17:28:25.956] getGlobalsAndPackages() ... DONE
 - Resolving 2 multisession futures
[17:28:25.958] Packages needed by the future expression (n = 0): <none>
[17:28:25.958] Packages needed by future strategies (n = 0): <none>
[17:28:25.959] {
[17:28:25.959]     {
[17:28:25.959]         {
[17:28:25.959]             ...future.startTime <- base::Sys.time()
[17:28:25.959]             {
[17:28:25.959]                 {
[17:28:25.959]                   {
[17:28:25.959]                     base::local({
[17:28:25.959]                       has_future <- base::requireNamespace("future", 
[17:28:25.959]                         quietly = TRUE)
[17:28:25.959]                       if (has_future) {
[17:28:25.959]                         ns <- base::getNamespace("future")
[17:28:25.959]                         version <- ns[[".package"]][["version"]]
[17:28:25.959]                         if (is.null(version)) 
[17:28:25.959]                           version <- utils::packageVersion("future")
[17:28:25.959]                       }
[17:28:25.959]                       else {
[17:28:25.959]                         version <- NULL
[17:28:25.959]                       }
[17:28:25.959]                       if (!has_future || version < "1.8.0") {
[17:28:25.959]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:25.959]                           "", base::R.version$version.string), 
[17:28:25.959]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:25.959]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:25.959]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:25.959]                             "release", "version")], collapse = " "), 
[17:28:25.959]                           hostname = base::Sys.info()[["nodename"]])
[17:28:25.959]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:25.959]                           info)
[17:28:25.959]                         info <- base::paste(info, collapse = "; ")
[17:28:25.959]                         if (!has_future) {
[17:28:25.959]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:25.959]                             info)
[17:28:25.959]                         }
[17:28:25.959]                         else {
[17:28:25.959]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:25.959]                             info, version)
[17:28:25.959]                         }
[17:28:25.959]                         base::stop(msg)
[17:28:25.959]                       }
[17:28:25.959]                     })
[17:28:25.959]                   }
[17:28:25.959]                   ...future.strategy.old <- future::plan("list")
[17:28:25.959]                   options(future.plan = NULL)
[17:28:25.959]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:25.959]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:25.959]                 }
[17:28:25.959]                 ...future.workdir <- getwd()
[17:28:25.959]             }
[17:28:25.959]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:25.959]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:25.959]         }
[17:28:25.959]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:25.959]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:25.959]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:25.959]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:25.959]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:25.959]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:25.959]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:25.959]             base::names(...future.oldOptions))
[17:28:25.959]     }
[17:28:25.959]     if (FALSE) {
[17:28:25.959]     }
[17:28:25.959]     else {
[17:28:25.959]         if (TRUE) {
[17:28:25.959]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:25.959]                 open = "w")
[17:28:25.959]         }
[17:28:25.959]         else {
[17:28:25.959]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:25.959]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:25.959]         }
[17:28:25.959]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:25.959]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:25.959]             base::sink(type = "output", split = FALSE)
[17:28:25.959]             base::close(...future.stdout)
[17:28:25.959]         }, add = TRUE)
[17:28:25.959]     }
[17:28:25.959]     ...future.frame <- base::sys.nframe()
[17:28:25.959]     ...future.conditions <- base::list()
[17:28:25.959]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:25.959]     if (FALSE) {
[17:28:25.959]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:25.959]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:25.959]     }
[17:28:25.959]     ...future.result <- base::tryCatch({
[17:28:25.959]         base::withCallingHandlers({
[17:28:25.959]             ...future.value <- base::withVisible(base::local({
[17:28:25.959]                 ii
[17:28:25.959]             }))
[17:28:25.959]             future::FutureResult(value = ...future.value$value, 
[17:28:25.959]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:25.959]                   ...future.rng), globalenv = if (FALSE) 
[17:28:25.959]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:25.959]                     ...future.globalenv.names))
[17:28:25.959]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:25.959]         }, condition = base::local({
[17:28:25.959]             c <- base::c
[17:28:25.959]             inherits <- base::inherits
[17:28:25.959]             invokeRestart <- base::invokeRestart
[17:28:25.959]             length <- base::length
[17:28:25.959]             list <- base::list
[17:28:25.959]             seq.int <- base::seq.int
[17:28:25.959]             signalCondition <- base::signalCondition
[17:28:25.959]             sys.calls <- base::sys.calls
[17:28:25.959]             `[[` <- base::`[[`
[17:28:25.959]             `+` <- base::`+`
[17:28:25.959]             `<<-` <- base::`<<-`
[17:28:25.959]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:25.959]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:25.959]                   3L)]
[17:28:25.959]             }
[17:28:25.959]             function(cond) {
[17:28:25.959]                 is_error <- inherits(cond, "error")
[17:28:25.959]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:25.959]                   NULL)
[17:28:25.959]                 if (is_error) {
[17:28:25.959]                   sessionInformation <- function() {
[17:28:25.959]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:25.959]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:25.959]                       search = base::search(), system = base::Sys.info())
[17:28:25.959]                   }
[17:28:25.959]                   ...future.conditions[[length(...future.conditions) + 
[17:28:25.959]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:25.959]                     cond$call), session = sessionInformation(), 
[17:28:25.959]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:25.959]                   signalCondition(cond)
[17:28:25.959]                 }
[17:28:25.959]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:25.959]                 "immediateCondition"))) {
[17:28:25.959]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:25.959]                   ...future.conditions[[length(...future.conditions) + 
[17:28:25.959]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:25.959]                   if (TRUE && !signal) {
[17:28:25.959]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:25.959]                     {
[17:28:25.959]                       inherits <- base::inherits
[17:28:25.959]                       invokeRestart <- base::invokeRestart
[17:28:25.959]                       is.null <- base::is.null
[17:28:25.959]                       muffled <- FALSE
[17:28:25.959]                       if (inherits(cond, "message")) {
[17:28:25.959]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:25.959]                         if (muffled) 
[17:28:25.959]                           invokeRestart("muffleMessage")
[17:28:25.959]                       }
[17:28:25.959]                       else if (inherits(cond, "warning")) {
[17:28:25.959]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:25.959]                         if (muffled) 
[17:28:25.959]                           invokeRestart("muffleWarning")
[17:28:25.959]                       }
[17:28:25.959]                       else if (inherits(cond, "condition")) {
[17:28:25.959]                         if (!is.null(pattern)) {
[17:28:25.959]                           computeRestarts <- base::computeRestarts
[17:28:25.959]                           grepl <- base::grepl
[17:28:25.959]                           restarts <- computeRestarts(cond)
[17:28:25.959]                           for (restart in restarts) {
[17:28:25.959]                             name <- restart$name
[17:28:25.959]                             if (is.null(name)) 
[17:28:25.959]                               next
[17:28:25.959]                             if (!grepl(pattern, name)) 
[17:28:25.959]                               next
[17:28:25.959]                             invokeRestart(restart)
[17:28:25.959]                             muffled <- TRUE
[17:28:25.959]                             break
[17:28:25.959]                           }
[17:28:25.959]                         }
[17:28:25.959]                       }
[17:28:25.959]                       invisible(muffled)
[17:28:25.959]                     }
[17:28:25.959]                     muffleCondition(cond, pattern = "^muffle")
[17:28:25.959]                   }
[17:28:25.959]                 }
[17:28:25.959]                 else {
[17:28:25.959]                   if (TRUE) {
[17:28:25.959]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:25.959]                     {
[17:28:25.959]                       inherits <- base::inherits
[17:28:25.959]                       invokeRestart <- base::invokeRestart
[17:28:25.959]                       is.null <- base::is.null
[17:28:25.959]                       muffled <- FALSE
[17:28:25.959]                       if (inherits(cond, "message")) {
[17:28:25.959]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:25.959]                         if (muffled) 
[17:28:25.959]                           invokeRestart("muffleMessage")
[17:28:25.959]                       }
[17:28:25.959]                       else if (inherits(cond, "warning")) {
[17:28:25.959]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:25.959]                         if (muffled) 
[17:28:25.959]                           invokeRestart("muffleWarning")
[17:28:25.959]                       }
[17:28:25.959]                       else if (inherits(cond, "condition")) {
[17:28:25.959]                         if (!is.null(pattern)) {
[17:28:25.959]                           computeRestarts <- base::computeRestarts
[17:28:25.959]                           grepl <- base::grepl
[17:28:25.959]                           restarts <- computeRestarts(cond)
[17:28:25.959]                           for (restart in restarts) {
[17:28:25.959]                             name <- restart$name
[17:28:25.959]                             if (is.null(name)) 
[17:28:25.959]                               next
[17:28:25.959]                             if (!grepl(pattern, name)) 
[17:28:25.959]                               next
[17:28:25.959]                             invokeRestart(restart)
[17:28:25.959]                             muffled <- TRUE
[17:28:25.959]                             break
[17:28:25.959]                           }
[17:28:25.959]                         }
[17:28:25.959]                       }
[17:28:25.959]                       invisible(muffled)
[17:28:25.959]                     }
[17:28:25.959]                     muffleCondition(cond, pattern = "^muffle")
[17:28:25.959]                   }
[17:28:25.959]                 }
[17:28:25.959]             }
[17:28:25.959]         }))
[17:28:25.959]     }, error = function(ex) {
[17:28:25.959]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:25.959]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:25.959]                 ...future.rng), started = ...future.startTime, 
[17:28:25.959]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:25.959]             version = "1.8"), class = "FutureResult")
[17:28:25.959]     }, finally = {
[17:28:25.959]         if (!identical(...future.workdir, getwd())) 
[17:28:25.959]             setwd(...future.workdir)
[17:28:25.959]         {
[17:28:25.959]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:25.959]                 ...future.oldOptions$nwarnings <- NULL
[17:28:25.959]             }
[17:28:25.959]             base::options(...future.oldOptions)
[17:28:25.959]             if (.Platform$OS.type == "windows") {
[17:28:25.959]                 old_names <- names(...future.oldEnvVars)
[17:28:25.959]                 envs <- base::Sys.getenv()
[17:28:25.959]                 names <- names(envs)
[17:28:25.959]                 common <- intersect(names, old_names)
[17:28:25.959]                 added <- setdiff(names, old_names)
[17:28:25.959]                 removed <- setdiff(old_names, names)
[17:28:25.959]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:25.959]                   envs[common]]
[17:28:25.959]                 NAMES <- toupper(changed)
[17:28:25.959]                 args <- list()
[17:28:25.959]                 for (kk in seq_along(NAMES)) {
[17:28:25.959]                   name <- changed[[kk]]
[17:28:25.959]                   NAME <- NAMES[[kk]]
[17:28:25.959]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:25.959]                     next
[17:28:25.959]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:25.959]                 }
[17:28:25.959]                 NAMES <- toupper(added)
[17:28:25.959]                 for (kk in seq_along(NAMES)) {
[17:28:25.959]                   name <- added[[kk]]
[17:28:25.959]                   NAME <- NAMES[[kk]]
[17:28:25.959]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:25.959]                     next
[17:28:25.959]                   args[[name]] <- ""
[17:28:25.959]                 }
[17:28:25.959]                 NAMES <- toupper(removed)
[17:28:25.959]                 for (kk in seq_along(NAMES)) {
[17:28:25.959]                   name <- removed[[kk]]
[17:28:25.959]                   NAME <- NAMES[[kk]]
[17:28:25.959]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:25.959]                     next
[17:28:25.959]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:25.959]                 }
[17:28:25.959]                 if (length(args) > 0) 
[17:28:25.959]                   base::do.call(base::Sys.setenv, args = args)
[17:28:25.959]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:25.959]             }
[17:28:25.959]             else {
[17:28:25.959]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:25.959]             }
[17:28:25.959]             {
[17:28:25.959]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:25.959]                   0L) {
[17:28:25.959]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:25.959]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:25.959]                   base::options(opts)
[17:28:25.959]                 }
[17:28:25.959]                 {
[17:28:25.959]                   {
[17:28:25.959]                     NULL
[17:28:25.959]                     RNGkind("Mersenne-Twister")
[17:28:25.959]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:25.959]                       inherits = FALSE)
[17:28:25.959]                   }
[17:28:25.959]                   options(future.plan = NULL)
[17:28:25.959]                   if (is.na(NA_character_)) 
[17:28:25.959]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:25.959]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:25.959]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:25.959]                     .init = FALSE)
[17:28:25.959]                 }
[17:28:25.959]             }
[17:28:25.959]         }
[17:28:25.959]     })
[17:28:25.959]     if (TRUE) {
[17:28:25.959]         base::sink(type = "output", split = FALSE)
[17:28:25.959]         if (TRUE) {
[17:28:25.959]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:25.959]         }
[17:28:25.959]         else {
[17:28:25.959]             ...future.result["stdout"] <- base::list(NULL)
[17:28:25.959]         }
[17:28:25.959]         base::close(...future.stdout)
[17:28:25.959]         ...future.stdout <- NULL
[17:28:25.959]     }
[17:28:25.959]     ...future.result$conditions <- ...future.conditions
[17:28:25.959]     ...future.result$finished <- base::Sys.time()
[17:28:25.959]     ...future.result
[17:28:25.959] }
[17:28:25.968] assign_globals() ...
[17:28:25.968] List of 1
[17:28:25.968]  $ ii: int 1
[17:28:25.968]  - attr(*, "where")=List of 1
[17:28:25.968]   ..$ ii:<environment: R_EmptyEnv> 
[17:28:25.968]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:25.968]  - attr(*, "resolved")= logi FALSE
[17:28:25.968]  - attr(*, "total_size")= int 35
[17:28:25.974] - copied 'ii' to environment
[17:28:25.974] assign_globals() ... done
[17:28:25.975] plan(): Setting new future strategy stack:
[17:28:25.975] List of future strategies:
[17:28:25.975] 1. sequential:
[17:28:25.975]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:25.975]    - tweaked: FALSE
[17:28:25.975]    - call: NULL
[17:28:25.976] plan(): nbrOfWorkers() = 1
[17:28:25.978] plan(): Setting new future strategy stack:
[17:28:25.978] List of future strategies:
[17:28:25.978] 1. sequential:
[17:28:25.978]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:25.978]    - tweaked: FALSE
[17:28:25.978]    - call: future::plan("sequential")
[17:28:25.979] plan(): nbrOfWorkers() = 1
[17:28:25.979] SequentialFuture started (and completed)
[17:28:25.980] Packages needed by the future expression (n = 0): <none>
[17:28:25.980] Packages needed by future strategies (n = 0): <none>
[17:28:25.985] {
[17:28:25.985]     {
[17:28:25.985]         {
[17:28:25.985]             ...future.startTime <- base::Sys.time()
[17:28:25.985]             {
[17:28:25.985]                 {
[17:28:25.985]                   {
[17:28:25.985]                     base::local({
[17:28:25.985]                       has_future <- base::requireNamespace("future", 
[17:28:25.985]                         quietly = TRUE)
[17:28:25.985]                       if (has_future) {
[17:28:25.985]                         ns <- base::getNamespace("future")
[17:28:25.985]                         version <- ns[[".package"]][["version"]]
[17:28:25.985]                         if (is.null(version)) 
[17:28:25.985]                           version <- utils::packageVersion("future")
[17:28:25.985]                       }
[17:28:25.985]                       else {
[17:28:25.985]                         version <- NULL
[17:28:25.985]                       }
[17:28:25.985]                       if (!has_future || version < "1.8.0") {
[17:28:25.985]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:25.985]                           "", base::R.version$version.string), 
[17:28:25.985]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:25.985]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:25.985]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:25.985]                             "release", "version")], collapse = " "), 
[17:28:25.985]                           hostname = base::Sys.info()[["nodename"]])
[17:28:25.985]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:25.985]                           info)
[17:28:25.985]                         info <- base::paste(info, collapse = "; ")
[17:28:25.985]                         if (!has_future) {
[17:28:25.985]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:25.985]                             info)
[17:28:25.985]                         }
[17:28:25.985]                         else {
[17:28:25.985]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:25.985]                             info, version)
[17:28:25.985]                         }
[17:28:25.985]                         base::stop(msg)
[17:28:25.985]                       }
[17:28:25.985]                     })
[17:28:25.985]                   }
[17:28:25.985]                   ...future.strategy.old <- future::plan("list")
[17:28:25.985]                   options(future.plan = NULL)
[17:28:25.985]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:25.985]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:25.985]                 }
[17:28:25.985]                 ...future.workdir <- getwd()
[17:28:25.985]             }
[17:28:25.985]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:25.985]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:25.985]         }
[17:28:25.985]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:25.985]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:25.985]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:25.985]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:25.985]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:25.985]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:25.985]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:25.985]             base::names(...future.oldOptions))
[17:28:25.985]     }
[17:28:25.985]     if (FALSE) {
[17:28:25.985]     }
[17:28:25.985]     else {
[17:28:25.985]         if (TRUE) {
[17:28:25.985]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:25.985]                 open = "w")
[17:28:25.985]         }
[17:28:25.985]         else {
[17:28:25.985]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:25.985]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:25.985]         }
[17:28:25.985]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:25.985]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:25.985]             base::sink(type = "output", split = FALSE)
[17:28:25.985]             base::close(...future.stdout)
[17:28:25.985]         }, add = TRUE)
[17:28:25.985]     }
[17:28:25.985]     ...future.frame <- base::sys.nframe()
[17:28:25.985]     ...future.conditions <- base::list()
[17:28:25.985]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:25.985]     if (FALSE) {
[17:28:25.985]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:25.985]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:25.985]     }
[17:28:25.985]     ...future.result <- base::tryCatch({
[17:28:25.985]         base::withCallingHandlers({
[17:28:25.985]             ...future.value <- base::withVisible(base::local({
[17:28:25.985]                 ii
[17:28:25.985]             }))
[17:28:25.985]             future::FutureResult(value = ...future.value$value, 
[17:28:25.985]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:25.985]                   ...future.rng), globalenv = if (FALSE) 
[17:28:25.985]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:25.985]                     ...future.globalenv.names))
[17:28:25.985]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:25.985]         }, condition = base::local({
[17:28:25.985]             c <- base::c
[17:28:25.985]             inherits <- base::inherits
[17:28:25.985]             invokeRestart <- base::invokeRestart
[17:28:25.985]             length <- base::length
[17:28:25.985]             list <- base::list
[17:28:25.985]             seq.int <- base::seq.int
[17:28:25.985]             signalCondition <- base::signalCondition
[17:28:25.985]             sys.calls <- base::sys.calls
[17:28:25.985]             `[[` <- base::`[[`
[17:28:25.985]             `+` <- base::`+`
[17:28:25.985]             `<<-` <- base::`<<-`
[17:28:25.985]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:25.985]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:25.985]                   3L)]
[17:28:25.985]             }
[17:28:25.985]             function(cond) {
[17:28:25.985]                 is_error <- inherits(cond, "error")
[17:28:25.985]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:25.985]                   NULL)
[17:28:25.985]                 if (is_error) {
[17:28:25.985]                   sessionInformation <- function() {
[17:28:25.985]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:25.985]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:25.985]                       search = base::search(), system = base::Sys.info())
[17:28:25.985]                   }
[17:28:25.985]                   ...future.conditions[[length(...future.conditions) + 
[17:28:25.985]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:25.985]                     cond$call), session = sessionInformation(), 
[17:28:25.985]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:25.985]                   signalCondition(cond)
[17:28:25.985]                 }
[17:28:25.985]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:25.985]                 "immediateCondition"))) {
[17:28:25.985]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:25.985]                   ...future.conditions[[length(...future.conditions) + 
[17:28:25.985]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:25.985]                   if (TRUE && !signal) {
[17:28:25.985]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:25.985]                     {
[17:28:25.985]                       inherits <- base::inherits
[17:28:25.985]                       invokeRestart <- base::invokeRestart
[17:28:25.985]                       is.null <- base::is.null
[17:28:25.985]                       muffled <- FALSE
[17:28:25.985]                       if (inherits(cond, "message")) {
[17:28:25.985]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:25.985]                         if (muffled) 
[17:28:25.985]                           invokeRestart("muffleMessage")
[17:28:25.985]                       }
[17:28:25.985]                       else if (inherits(cond, "warning")) {
[17:28:25.985]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:25.985]                         if (muffled) 
[17:28:25.985]                           invokeRestart("muffleWarning")
[17:28:25.985]                       }
[17:28:25.985]                       else if (inherits(cond, "condition")) {
[17:28:25.985]                         if (!is.null(pattern)) {
[17:28:25.985]                           computeRestarts <- base::computeRestarts
[17:28:25.985]                           grepl <- base::grepl
[17:28:25.985]                           restarts <- computeRestarts(cond)
[17:28:25.985]                           for (restart in restarts) {
[17:28:25.985]                             name <- restart$name
[17:28:25.985]                             if (is.null(name)) 
[17:28:25.985]                               next
[17:28:25.985]                             if (!grepl(pattern, name)) 
[17:28:25.985]                               next
[17:28:25.985]                             invokeRestart(restart)
[17:28:25.985]                             muffled <- TRUE
[17:28:25.985]                             break
[17:28:25.985]                           }
[17:28:25.985]                         }
[17:28:25.985]                       }
[17:28:25.985]                       invisible(muffled)
[17:28:25.985]                     }
[17:28:25.985]                     muffleCondition(cond, pattern = "^muffle")
[17:28:25.985]                   }
[17:28:25.985]                 }
[17:28:25.985]                 else {
[17:28:25.985]                   if (TRUE) {
[17:28:25.985]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:25.985]                     {
[17:28:25.985]                       inherits <- base::inherits
[17:28:25.985]                       invokeRestart <- base::invokeRestart
[17:28:25.985]                       is.null <- base::is.null
[17:28:25.985]                       muffled <- FALSE
[17:28:25.985]                       if (inherits(cond, "message")) {
[17:28:25.985]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:25.985]                         if (muffled) 
[17:28:25.985]                           invokeRestart("muffleMessage")
[17:28:25.985]                       }
[17:28:25.985]                       else if (inherits(cond, "warning")) {
[17:28:25.985]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:25.985]                         if (muffled) 
[17:28:25.985]                           invokeRestart("muffleWarning")
[17:28:25.985]                       }
[17:28:25.985]                       else if (inherits(cond, "condition")) {
[17:28:25.985]                         if (!is.null(pattern)) {
[17:28:25.985]                           computeRestarts <- base::computeRestarts
[17:28:25.985]                           grepl <- base::grepl
[17:28:25.985]                           restarts <- computeRestarts(cond)
[17:28:25.985]                           for (restart in restarts) {
[17:28:25.985]                             name <- restart$name
[17:28:25.985]                             if (is.null(name)) 
[17:28:25.985]                               next
[17:28:25.985]                             if (!grepl(pattern, name)) 
[17:28:25.985]                               next
[17:28:25.985]                             invokeRestart(restart)
[17:28:25.985]                             muffled <- TRUE
[17:28:25.985]                             break
[17:28:25.985]                           }
[17:28:25.985]                         }
[17:28:25.985]                       }
[17:28:25.985]                       invisible(muffled)
[17:28:25.985]                     }
[17:28:25.985]                     muffleCondition(cond, pattern = "^muffle")
[17:28:25.985]                   }
[17:28:25.985]                 }
[17:28:25.985]             }
[17:28:25.985]         }))
[17:28:25.985]     }, error = function(ex) {
[17:28:25.985]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:25.985]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:25.985]                 ...future.rng), started = ...future.startTime, 
[17:28:25.985]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:25.985]             version = "1.8"), class = "FutureResult")
[17:28:25.985]     }, finally = {
[17:28:25.985]         if (!identical(...future.workdir, getwd())) 
[17:28:25.985]             setwd(...future.workdir)
[17:28:25.985]         {
[17:28:25.985]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:25.985]                 ...future.oldOptions$nwarnings <- NULL
[17:28:25.985]             }
[17:28:25.985]             base::options(...future.oldOptions)
[17:28:25.985]             if (.Platform$OS.type == "windows") {
[17:28:25.985]                 old_names <- names(...future.oldEnvVars)
[17:28:25.985]                 envs <- base::Sys.getenv()
[17:28:25.985]                 names <- names(envs)
[17:28:25.985]                 common <- intersect(names, old_names)
[17:28:25.985]                 added <- setdiff(names, old_names)
[17:28:25.985]                 removed <- setdiff(old_names, names)
[17:28:25.985]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:25.985]                   envs[common]]
[17:28:25.985]                 NAMES <- toupper(changed)
[17:28:25.985]                 args <- list()
[17:28:25.985]                 for (kk in seq_along(NAMES)) {
[17:28:25.985]                   name <- changed[[kk]]
[17:28:25.985]                   NAME <- NAMES[[kk]]
[17:28:25.985]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:25.985]                     next
[17:28:25.985]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:25.985]                 }
[17:28:25.985]                 NAMES <- toupper(added)
[17:28:25.985]                 for (kk in seq_along(NAMES)) {
[17:28:25.985]                   name <- added[[kk]]
[17:28:25.985]                   NAME <- NAMES[[kk]]
[17:28:25.985]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:25.985]                     next
[17:28:25.985]                   args[[name]] <- ""
[17:28:25.985]                 }
[17:28:25.985]                 NAMES <- toupper(removed)
[17:28:25.985]                 for (kk in seq_along(NAMES)) {
[17:28:25.985]                   name <- removed[[kk]]
[17:28:25.985]                   NAME <- NAMES[[kk]]
[17:28:25.985]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:25.985]                     next
[17:28:25.985]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:25.985]                 }
[17:28:25.985]                 if (length(args) > 0) 
[17:28:25.985]                   base::do.call(base::Sys.setenv, args = args)
[17:28:25.985]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:25.985]             }
[17:28:25.985]             else {
[17:28:25.985]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:25.985]             }
[17:28:25.985]             {
[17:28:25.985]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:25.985]                   0L) {
[17:28:25.985]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:25.985]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:25.985]                   base::options(opts)
[17:28:25.985]                 }
[17:28:25.985]                 {
[17:28:25.985]                   {
[17:28:25.985]                     NULL
[17:28:25.985]                     RNGkind("Mersenne-Twister")
[17:28:25.985]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:25.985]                       inherits = FALSE)
[17:28:25.985]                   }
[17:28:25.985]                   options(future.plan = NULL)
[17:28:25.985]                   if (is.na(NA_character_)) 
[17:28:25.985]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:25.985]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:25.985]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:25.985]                     .init = FALSE)
[17:28:25.985]                 }
[17:28:25.985]             }
[17:28:25.985]         }
[17:28:25.985]     })
[17:28:25.985]     if (TRUE) {
[17:28:25.985]         base::sink(type = "output", split = FALSE)
[17:28:25.985]         if (TRUE) {
[17:28:25.985]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:25.985]         }
[17:28:25.985]         else {
[17:28:25.985]             ...future.result["stdout"] <- base::list(NULL)
[17:28:25.985]         }
[17:28:25.985]         base::close(...future.stdout)
[17:28:25.985]         ...future.stdout <- NULL
[17:28:25.985]     }
[17:28:25.985]     ...future.result$conditions <- ...future.conditions
[17:28:25.985]     ...future.result$finished <- base::Sys.time()
[17:28:25.985]     ...future.result
[17:28:25.985] }
[17:28:25.992] assign_globals() ...
[17:28:25.992] List of 1
[17:28:25.992]  $ ii: int 2
[17:28:25.992]  - attr(*, "where")=List of 1
[17:28:25.992]   ..$ ii:<environment: R_EmptyEnv> 
[17:28:25.992]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:25.992]  - attr(*, "resolved")= logi FALSE
[17:28:25.992]  - attr(*, "total_size")= int 35
[17:28:25.998] - copied 'ii' to environment
[17:28:25.998] assign_globals() ... done
[17:28:25.999] plan(): Setting new future strategy stack:
[17:28:26.000] List of future strategies:
[17:28:26.000] 1. sequential:
[17:28:26.000]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:26.000]    - tweaked: FALSE
[17:28:26.000]    - call: NULL
[17:28:26.001] plan(): nbrOfWorkers() = 1
[17:28:26.004] plan(): Setting new future strategy stack:
[17:28:26.004] List of future strategies:
[17:28:26.004] 1. sequential:
[17:28:26.004]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:26.004]    - tweaked: FALSE
[17:28:26.004]    - call: future::plan("sequential")
[17:28:26.005] plan(): nbrOfWorkers() = 1
[17:28:26.006] SequentialFuture started (and completed)
*** multisession() - workers inherit .libPaths()
[17:28:26.007] getGlobalsAndPackages() ...
[17:28:26.007] Searching for globals...
[17:28:26.009] - globals found: [1] '.libPaths'
[17:28:26.009] Searching for globals ... DONE
[17:28:26.009] Resolving globals: FALSE
[17:28:26.010] 
[17:28:26.010] 
[17:28:26.011] getGlobalsAndPackages() ... DONE
[17:28:26.012] run() for 'Future' ...
[17:28:26.012] - state: 'created'
[17:28:26.013] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:26.014] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:26.014] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:26.014]   - Field: 'label'
[17:28:26.015]   - Field: 'local'
[17:28:26.015]   - Field: 'owner'
[17:28:26.016]   - Field: 'envir'
[17:28:26.016]   - Field: 'packages'
[17:28:26.016]   - Field: 'gc'
[17:28:26.017]   - Field: 'conditions'
[17:28:26.017]   - Field: 'expr'
[17:28:26.018]   - Field: 'uuid'
[17:28:26.018]   - Field: 'seed'
[17:28:26.018]   - Field: 'version'
[17:28:26.019]   - Field: 'result'
[17:28:26.019]   - Field: 'asynchronous'
[17:28:26.020]   - Field: 'calls'
[17:28:26.020]   - Field: 'globals'
[17:28:26.020]   - Field: 'stdout'
[17:28:26.021]   - Field: 'earlySignal'
[17:28:26.021]   - Field: 'lazy'
[17:28:26.022]   - Field: 'state'
[17:28:26.022] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:26.022] - Launch lazy future ...
[17:28:26.023] Packages needed by the future expression (n = 0): <none>
[17:28:26.023] Packages needed by future strategies (n = 0): <none>
[17:28:26.025] {
[17:28:26.025]     {
[17:28:26.025]         {
[17:28:26.025]             ...future.startTime <- base::Sys.time()
[17:28:26.025]             {
[17:28:26.025]                 {
[17:28:26.025]                   {
[17:28:26.025]                     base::local({
[17:28:26.025]                       has_future <- base::requireNamespace("future", 
[17:28:26.025]                         quietly = TRUE)
[17:28:26.025]                       if (has_future) {
[17:28:26.025]                         ns <- base::getNamespace("future")
[17:28:26.025]                         version <- ns[[".package"]][["version"]]
[17:28:26.025]                         if (is.null(version)) 
[17:28:26.025]                           version <- utils::packageVersion("future")
[17:28:26.025]                       }
[17:28:26.025]                       else {
[17:28:26.025]                         version <- NULL
[17:28:26.025]                       }
[17:28:26.025]                       if (!has_future || version < "1.8.0") {
[17:28:26.025]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:26.025]                           "", base::R.version$version.string), 
[17:28:26.025]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:26.025]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:26.025]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:26.025]                             "release", "version")], collapse = " "), 
[17:28:26.025]                           hostname = base::Sys.info()[["nodename"]])
[17:28:26.025]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:26.025]                           info)
[17:28:26.025]                         info <- base::paste(info, collapse = "; ")
[17:28:26.025]                         if (!has_future) {
[17:28:26.025]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:26.025]                             info)
[17:28:26.025]                         }
[17:28:26.025]                         else {
[17:28:26.025]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:26.025]                             info, version)
[17:28:26.025]                         }
[17:28:26.025]                         base::stop(msg)
[17:28:26.025]                       }
[17:28:26.025]                     })
[17:28:26.025]                   }
[17:28:26.025]                   ...future.strategy.old <- future::plan("list")
[17:28:26.025]                   options(future.plan = NULL)
[17:28:26.025]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:26.025]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:26.025]                 }
[17:28:26.025]                 ...future.workdir <- getwd()
[17:28:26.025]             }
[17:28:26.025]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:26.025]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:26.025]         }
[17:28:26.025]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:26.025]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:26.025]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:26.025]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:26.025]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:26.025]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:26.025]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:26.025]             base::names(...future.oldOptions))
[17:28:26.025]     }
[17:28:26.025]     if (FALSE) {
[17:28:26.025]     }
[17:28:26.025]     else {
[17:28:26.025]         if (TRUE) {
[17:28:26.025]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:26.025]                 open = "w")
[17:28:26.025]         }
[17:28:26.025]         else {
[17:28:26.025]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:26.025]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:26.025]         }
[17:28:26.025]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:26.025]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:26.025]             base::sink(type = "output", split = FALSE)
[17:28:26.025]             base::close(...future.stdout)
[17:28:26.025]         }, add = TRUE)
[17:28:26.025]     }
[17:28:26.025]     ...future.frame <- base::sys.nframe()
[17:28:26.025]     ...future.conditions <- base::list()
[17:28:26.025]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:26.025]     if (FALSE) {
[17:28:26.025]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:26.025]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:26.025]     }
[17:28:26.025]     ...future.result <- base::tryCatch({
[17:28:26.025]         base::withCallingHandlers({
[17:28:26.025]             ...future.value <- base::withVisible(base::local(.libPaths()))
[17:28:26.025]             future::FutureResult(value = ...future.value$value, 
[17:28:26.025]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:26.025]                   ...future.rng), globalenv = if (FALSE) 
[17:28:26.025]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:26.025]                     ...future.globalenv.names))
[17:28:26.025]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:26.025]         }, condition = base::local({
[17:28:26.025]             c <- base::c
[17:28:26.025]             inherits <- base::inherits
[17:28:26.025]             invokeRestart <- base::invokeRestart
[17:28:26.025]             length <- base::length
[17:28:26.025]             list <- base::list
[17:28:26.025]             seq.int <- base::seq.int
[17:28:26.025]             signalCondition <- base::signalCondition
[17:28:26.025]             sys.calls <- base::sys.calls
[17:28:26.025]             `[[` <- base::`[[`
[17:28:26.025]             `+` <- base::`+`
[17:28:26.025]             `<<-` <- base::`<<-`
[17:28:26.025]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:26.025]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:26.025]                   3L)]
[17:28:26.025]             }
[17:28:26.025]             function(cond) {
[17:28:26.025]                 is_error <- inherits(cond, "error")
[17:28:26.025]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:26.025]                   NULL)
[17:28:26.025]                 if (is_error) {
[17:28:26.025]                   sessionInformation <- function() {
[17:28:26.025]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:26.025]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:26.025]                       search = base::search(), system = base::Sys.info())
[17:28:26.025]                   }
[17:28:26.025]                   ...future.conditions[[length(...future.conditions) + 
[17:28:26.025]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:26.025]                     cond$call), session = sessionInformation(), 
[17:28:26.025]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:26.025]                   signalCondition(cond)
[17:28:26.025]                 }
[17:28:26.025]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:26.025]                 "immediateCondition"))) {
[17:28:26.025]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:26.025]                   ...future.conditions[[length(...future.conditions) + 
[17:28:26.025]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:26.025]                   if (TRUE && !signal) {
[17:28:26.025]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:26.025]                     {
[17:28:26.025]                       inherits <- base::inherits
[17:28:26.025]                       invokeRestart <- base::invokeRestart
[17:28:26.025]                       is.null <- base::is.null
[17:28:26.025]                       muffled <- FALSE
[17:28:26.025]                       if (inherits(cond, "message")) {
[17:28:26.025]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:26.025]                         if (muffled) 
[17:28:26.025]                           invokeRestart("muffleMessage")
[17:28:26.025]                       }
[17:28:26.025]                       else if (inherits(cond, "warning")) {
[17:28:26.025]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:26.025]                         if (muffled) 
[17:28:26.025]                           invokeRestart("muffleWarning")
[17:28:26.025]                       }
[17:28:26.025]                       else if (inherits(cond, "condition")) {
[17:28:26.025]                         if (!is.null(pattern)) {
[17:28:26.025]                           computeRestarts <- base::computeRestarts
[17:28:26.025]                           grepl <- base::grepl
[17:28:26.025]                           restarts <- computeRestarts(cond)
[17:28:26.025]                           for (restart in restarts) {
[17:28:26.025]                             name <- restart$name
[17:28:26.025]                             if (is.null(name)) 
[17:28:26.025]                               next
[17:28:26.025]                             if (!grepl(pattern, name)) 
[17:28:26.025]                               next
[17:28:26.025]                             invokeRestart(restart)
[17:28:26.025]                             muffled <- TRUE
[17:28:26.025]                             break
[17:28:26.025]                           }
[17:28:26.025]                         }
[17:28:26.025]                       }
[17:28:26.025]                       invisible(muffled)
[17:28:26.025]                     }
[17:28:26.025]                     muffleCondition(cond, pattern = "^muffle")
[17:28:26.025]                   }
[17:28:26.025]                 }
[17:28:26.025]                 else {
[17:28:26.025]                   if (TRUE) {
[17:28:26.025]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:26.025]                     {
[17:28:26.025]                       inherits <- base::inherits
[17:28:26.025]                       invokeRestart <- base::invokeRestart
[17:28:26.025]                       is.null <- base::is.null
[17:28:26.025]                       muffled <- FALSE
[17:28:26.025]                       if (inherits(cond, "message")) {
[17:28:26.025]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:26.025]                         if (muffled) 
[17:28:26.025]                           invokeRestart("muffleMessage")
[17:28:26.025]                       }
[17:28:26.025]                       else if (inherits(cond, "warning")) {
[17:28:26.025]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:26.025]                         if (muffled) 
[17:28:26.025]                           invokeRestart("muffleWarning")
[17:28:26.025]                       }
[17:28:26.025]                       else if (inherits(cond, "condition")) {
[17:28:26.025]                         if (!is.null(pattern)) {
[17:28:26.025]                           computeRestarts <- base::computeRestarts
[17:28:26.025]                           grepl <- base::grepl
[17:28:26.025]                           restarts <- computeRestarts(cond)
[17:28:26.025]                           for (restart in restarts) {
[17:28:26.025]                             name <- restart$name
[17:28:26.025]                             if (is.null(name)) 
[17:28:26.025]                               next
[17:28:26.025]                             if (!grepl(pattern, name)) 
[17:28:26.025]                               next
[17:28:26.025]                             invokeRestart(restart)
[17:28:26.025]                             muffled <- TRUE
[17:28:26.025]                             break
[17:28:26.025]                           }
[17:28:26.025]                         }
[17:28:26.025]                       }
[17:28:26.025]                       invisible(muffled)
[17:28:26.025]                     }
[17:28:26.025]                     muffleCondition(cond, pattern = "^muffle")
[17:28:26.025]                   }
[17:28:26.025]                 }
[17:28:26.025]             }
[17:28:26.025]         }))
[17:28:26.025]     }, error = function(ex) {
[17:28:26.025]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:26.025]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:26.025]                 ...future.rng), started = ...future.startTime, 
[17:28:26.025]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:26.025]             version = "1.8"), class = "FutureResult")
[17:28:26.025]     }, finally = {
[17:28:26.025]         if (!identical(...future.workdir, getwd())) 
[17:28:26.025]             setwd(...future.workdir)
[17:28:26.025]         {
[17:28:26.025]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:26.025]                 ...future.oldOptions$nwarnings <- NULL
[17:28:26.025]             }
[17:28:26.025]             base::options(...future.oldOptions)
[17:28:26.025]             if (.Platform$OS.type == "windows") {
[17:28:26.025]                 old_names <- names(...future.oldEnvVars)
[17:28:26.025]                 envs <- base::Sys.getenv()
[17:28:26.025]                 names <- names(envs)
[17:28:26.025]                 common <- intersect(names, old_names)
[17:28:26.025]                 added <- setdiff(names, old_names)
[17:28:26.025]                 removed <- setdiff(old_names, names)
[17:28:26.025]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:26.025]                   envs[common]]
[17:28:26.025]                 NAMES <- toupper(changed)
[17:28:26.025]                 args <- list()
[17:28:26.025]                 for (kk in seq_along(NAMES)) {
[17:28:26.025]                   name <- changed[[kk]]
[17:28:26.025]                   NAME <- NAMES[[kk]]
[17:28:26.025]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.025]                     next
[17:28:26.025]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:26.025]                 }
[17:28:26.025]                 NAMES <- toupper(added)
[17:28:26.025]                 for (kk in seq_along(NAMES)) {
[17:28:26.025]                   name <- added[[kk]]
[17:28:26.025]                   NAME <- NAMES[[kk]]
[17:28:26.025]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.025]                     next
[17:28:26.025]                   args[[name]] <- ""
[17:28:26.025]                 }
[17:28:26.025]                 NAMES <- toupper(removed)
[17:28:26.025]                 for (kk in seq_along(NAMES)) {
[17:28:26.025]                   name <- removed[[kk]]
[17:28:26.025]                   NAME <- NAMES[[kk]]
[17:28:26.025]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.025]                     next
[17:28:26.025]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:26.025]                 }
[17:28:26.025]                 if (length(args) > 0) 
[17:28:26.025]                   base::do.call(base::Sys.setenv, args = args)
[17:28:26.025]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:26.025]             }
[17:28:26.025]             else {
[17:28:26.025]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:26.025]             }
[17:28:26.025]             {
[17:28:26.025]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:26.025]                   0L) {
[17:28:26.025]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:26.025]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:26.025]                   base::options(opts)
[17:28:26.025]                 }
[17:28:26.025]                 {
[17:28:26.025]                   {
[17:28:26.025]                     NULL
[17:28:26.025]                     RNGkind("Mersenne-Twister")
[17:28:26.025]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:26.025]                       inherits = FALSE)
[17:28:26.025]                   }
[17:28:26.025]                   options(future.plan = NULL)
[17:28:26.025]                   if (is.na(NA_character_)) 
[17:28:26.025]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:26.025]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:26.025]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:26.025]                     .init = FALSE)
[17:28:26.025]                 }
[17:28:26.025]             }
[17:28:26.025]         }
[17:28:26.025]     })
[17:28:26.025]     if (TRUE) {
[17:28:26.025]         base::sink(type = "output", split = FALSE)
[17:28:26.025]         if (TRUE) {
[17:28:26.025]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:26.025]         }
[17:28:26.025]         else {
[17:28:26.025]             ...future.result["stdout"] <- base::list(NULL)
[17:28:26.025]         }
[17:28:26.025]         base::close(...future.stdout)
[17:28:26.025]         ...future.stdout <- NULL
[17:28:26.025]     }
[17:28:26.025]     ...future.result$conditions <- ...future.conditions
[17:28:26.025]     ...future.result$finished <- base::Sys.time()
[17:28:26.025]     ...future.result
[17:28:26.025] }
[17:28:26.033] plan(): Setting new future strategy stack:
[17:28:26.034] List of future strategies:
[17:28:26.034] 1. sequential:
[17:28:26.034]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:26.034]    - tweaked: FALSE
[17:28:26.034]    - call: NULL
[17:28:26.035] plan(): nbrOfWorkers() = 1
[17:28:26.037] plan(): Setting new future strategy stack:
[17:28:26.037] List of future strategies:
[17:28:26.037] 1. sequential:
[17:28:26.037]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:26.037]    - tweaked: FALSE
[17:28:26.037]    - call: future::plan("sequential")
[17:28:26.039] plan(): nbrOfWorkers() = 1
[17:28:26.039] SequentialFuture started (and completed)
[17:28:26.039] - Launch lazy future ... done
[17:28:26.040] run() for 'SequentialFuture' ... done
List of 2
 $ main   : chr [1:2] "D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda" "D:/RCompile/recent/R/library"
 $ workers: chr [1:2] "D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda" "D:/RCompile/recent/R/library"
*** multisession() and errors
[17:28:26.046] getGlobalsAndPackages() ...
[17:28:26.046] Searching for globals...
[17:28:26.049] - globals found: [2] '{', 'stop'
[17:28:26.049] Searching for globals ... DONE
[17:28:26.049] Resolving globals: FALSE
[17:28:26.050] 
[17:28:26.051] 
[17:28:26.051] getGlobalsAndPackages() ... DONE
SequentialFuture:
Label: '<none>'
Expression:
{
    stop("Whoops!")
    1
}
Lazy evaluation: TRUE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: FALSE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 12734a8a-480b-f2a5-0c96-45c13d81d854
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:26.053] Packages needed by the future expression (n = 0): <none>
[17:28:26.053] Packages needed by future strategies (n = 0): <none>
[17:28:26.054] {
[17:28:26.054]     {
[17:28:26.054]         {
[17:28:26.054]             ...future.startTime <- base::Sys.time()
[17:28:26.054]             {
[17:28:26.054]                 {
[17:28:26.054]                   {
[17:28:26.054]                     base::local({
[17:28:26.054]                       has_future <- base::requireNamespace("future", 
[17:28:26.054]                         quietly = TRUE)
[17:28:26.054]                       if (has_future) {
[17:28:26.054]                         ns <- base::getNamespace("future")
[17:28:26.054]                         version <- ns[[".package"]][["version"]]
[17:28:26.054]                         if (is.null(version)) 
[17:28:26.054]                           version <- utils::packageVersion("future")
[17:28:26.054]                       }
[17:28:26.054]                       else {
[17:28:26.054]                         version <- NULL
[17:28:26.054]                       }
[17:28:26.054]                       if (!has_future || version < "1.8.0") {
[17:28:26.054]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:26.054]                           "", base::R.version$version.string), 
[17:28:26.054]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:26.054]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:26.054]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:26.054]                             "release", "version")], collapse = " "), 
[17:28:26.054]                           hostname = base::Sys.info()[["nodename"]])
[17:28:26.054]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:26.054]                           info)
[17:28:26.054]                         info <- base::paste(info, collapse = "; ")
[17:28:26.054]                         if (!has_future) {
[17:28:26.054]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:26.054]                             info)
[17:28:26.054]                         }
[17:28:26.054]                         else {
[17:28:26.054]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:26.054]                             info, version)
[17:28:26.054]                         }
[17:28:26.054]                         base::stop(msg)
[17:28:26.054]                       }
[17:28:26.054]                     })
[17:28:26.054]                   }
[17:28:26.054]                   ...future.strategy.old <- future::plan("list")
[17:28:26.054]                   options(future.plan = NULL)
[17:28:26.054]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:26.054]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:26.054]                 }
[17:28:26.054]                 ...future.workdir <- getwd()
[17:28:26.054]             }
[17:28:26.054]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:26.054]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:26.054]         }
[17:28:26.054]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:26.054]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:26.054]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:26.054]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:26.054]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:26.054]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:26.054]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:26.054]             base::names(...future.oldOptions))
[17:28:26.054]     }
[17:28:26.054]     if (FALSE) {
[17:28:26.054]     }
[17:28:26.054]     else {
[17:28:26.054]         if (TRUE) {
[17:28:26.054]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:26.054]                 open = "w")
[17:28:26.054]         }
[17:28:26.054]         else {
[17:28:26.054]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:26.054]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:26.054]         }
[17:28:26.054]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:26.054]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:26.054]             base::sink(type = "output", split = FALSE)
[17:28:26.054]             base::close(...future.stdout)
[17:28:26.054]         }, add = TRUE)
[17:28:26.054]     }
[17:28:26.054]     ...future.frame <- base::sys.nframe()
[17:28:26.054]     ...future.conditions <- base::list()
[17:28:26.054]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:26.054]     if (FALSE) {
[17:28:26.054]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:26.054]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:26.054]     }
[17:28:26.054]     ...future.result <- base::tryCatch({
[17:28:26.054]         base::withCallingHandlers({
[17:28:26.054]             ...future.value <- base::withVisible(base::local({
[17:28:26.054]                 stop("Whoops!")
[17:28:26.054]                 1
[17:28:26.054]             }))
[17:28:26.054]             future::FutureResult(value = ...future.value$value, 
[17:28:26.054]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:26.054]                   ...future.rng), globalenv = if (FALSE) 
[17:28:26.054]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:26.054]                     ...future.globalenv.names))
[17:28:26.054]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:26.054]         }, condition = base::local({
[17:28:26.054]             c <- base::c
[17:28:26.054]             inherits <- base::inherits
[17:28:26.054]             invokeRestart <- base::invokeRestart
[17:28:26.054]             length <- base::length
[17:28:26.054]             list <- base::list
[17:28:26.054]             seq.int <- base::seq.int
[17:28:26.054]             signalCondition <- base::signalCondition
[17:28:26.054]             sys.calls <- base::sys.calls
[17:28:26.054]             `[[` <- base::`[[`
[17:28:26.054]             `+` <- base::`+`
[17:28:26.054]             `<<-` <- base::`<<-`
[17:28:26.054]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:26.054]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:26.054]                   3L)]
[17:28:26.054]             }
[17:28:26.054]             function(cond) {
[17:28:26.054]                 is_error <- inherits(cond, "error")
[17:28:26.054]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:26.054]                   NULL)
[17:28:26.054]                 if (is_error) {
[17:28:26.054]                   sessionInformation <- function() {
[17:28:26.054]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:26.054]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:26.054]                       search = base::search(), system = base::Sys.info())
[17:28:26.054]                   }
[17:28:26.054]                   ...future.conditions[[length(...future.conditions) + 
[17:28:26.054]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:26.054]                     cond$call), session = sessionInformation(), 
[17:28:26.054]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:26.054]                   signalCondition(cond)
[17:28:26.054]                 }
[17:28:26.054]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:26.054]                 "immediateCondition"))) {
[17:28:26.054]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:26.054]                   ...future.conditions[[length(...future.conditions) + 
[17:28:26.054]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:26.054]                   if (TRUE && !signal) {
[17:28:26.054]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:26.054]                     {
[17:28:26.054]                       inherits <- base::inherits
[17:28:26.054]                       invokeRestart <- base::invokeRestart
[17:28:26.054]                       is.null <- base::is.null
[17:28:26.054]                       muffled <- FALSE
[17:28:26.054]                       if (inherits(cond, "message")) {
[17:28:26.054]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:26.054]                         if (muffled) 
[17:28:26.054]                           invokeRestart("muffleMessage")
[17:28:26.054]                       }
[17:28:26.054]                       else if (inherits(cond, "warning")) {
[17:28:26.054]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:26.054]                         if (muffled) 
[17:28:26.054]                           invokeRestart("muffleWarning")
[17:28:26.054]                       }
[17:28:26.054]                       else if (inherits(cond, "condition")) {
[17:28:26.054]                         if (!is.null(pattern)) {
[17:28:26.054]                           computeRestarts <- base::computeRestarts
[17:28:26.054]                           grepl <- base::grepl
[17:28:26.054]                           restarts <- computeRestarts(cond)
[17:28:26.054]                           for (restart in restarts) {
[17:28:26.054]                             name <- restart$name
[17:28:26.054]                             if (is.null(name)) 
[17:28:26.054]                               next
[17:28:26.054]                             if (!grepl(pattern, name)) 
[17:28:26.054]                               next
[17:28:26.054]                             invokeRestart(restart)
[17:28:26.054]                             muffled <- TRUE
[17:28:26.054]                             break
[17:28:26.054]                           }
[17:28:26.054]                         }
[17:28:26.054]                       }
[17:28:26.054]                       invisible(muffled)
[17:28:26.054]                     }
[17:28:26.054]                     muffleCondition(cond, pattern = "^muffle")
[17:28:26.054]                   }
[17:28:26.054]                 }
[17:28:26.054]                 else {
[17:28:26.054]                   if (TRUE) {
[17:28:26.054]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:26.054]                     {
[17:28:26.054]                       inherits <- base::inherits
[17:28:26.054]                       invokeRestart <- base::invokeRestart
[17:28:26.054]                       is.null <- base::is.null
[17:28:26.054]                       muffled <- FALSE
[17:28:26.054]                       if (inherits(cond, "message")) {
[17:28:26.054]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:26.054]                         if (muffled) 
[17:28:26.054]                           invokeRestart("muffleMessage")
[17:28:26.054]                       }
[17:28:26.054]                       else if (inherits(cond, "warning")) {
[17:28:26.054]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:26.054]                         if (muffled) 
[17:28:26.054]                           invokeRestart("muffleWarning")
[17:28:26.054]                       }
[17:28:26.054]                       else if (inherits(cond, "condition")) {
[17:28:26.054]                         if (!is.null(pattern)) {
[17:28:26.054]                           computeRestarts <- base::computeRestarts
[17:28:26.054]                           grepl <- base::grepl
[17:28:26.054]                           restarts <- computeRestarts(cond)
[17:28:26.054]                           for (restart in restarts) {
[17:28:26.054]                             name <- restart$name
[17:28:26.054]                             if (is.null(name)) 
[17:28:26.054]                               next
[17:28:26.054]                             if (!grepl(pattern, name)) 
[17:28:26.054]                               next
[17:28:26.054]                             invokeRestart(restart)
[17:28:26.054]                             muffled <- TRUE
[17:28:26.054]                             break
[17:28:26.054]                           }
[17:28:26.054]                         }
[17:28:26.054]                       }
[17:28:26.054]                       invisible(muffled)
[17:28:26.054]                     }
[17:28:26.054]                     muffleCondition(cond, pattern = "^muffle")
[17:28:26.054]                   }
[17:28:26.054]                 }
[17:28:26.054]             }
[17:28:26.054]         }))
[17:28:26.054]     }, error = function(ex) {
[17:28:26.054]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:26.054]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:26.054]                 ...future.rng), started = ...future.startTime, 
[17:28:26.054]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:26.054]             version = "1.8"), class = "FutureResult")
[17:28:26.054]     }, finally = {
[17:28:26.054]         if (!identical(...future.workdir, getwd())) 
[17:28:26.054]             setwd(...future.workdir)
[17:28:26.054]         {
[17:28:26.054]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:26.054]                 ...future.oldOptions$nwarnings <- NULL
[17:28:26.054]             }
[17:28:26.054]             base::options(...future.oldOptions)
[17:28:26.054]             if (.Platform$OS.type == "windows") {
[17:28:26.054]                 old_names <- names(...future.oldEnvVars)
[17:28:26.054]                 envs <- base::Sys.getenv()
[17:28:26.054]                 names <- names(envs)
[17:28:26.054]                 common <- intersect(names, old_names)
[17:28:26.054]                 added <- setdiff(names, old_names)
[17:28:26.054]                 removed <- setdiff(old_names, names)
[17:28:26.054]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:26.054]                   envs[common]]
[17:28:26.054]                 NAMES <- toupper(changed)
[17:28:26.054]                 args <- list()
[17:28:26.054]                 for (kk in seq_along(NAMES)) {
[17:28:26.054]                   name <- changed[[kk]]
[17:28:26.054]                   NAME <- NAMES[[kk]]
[17:28:26.054]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.054]                     next
[17:28:26.054]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:26.054]                 }
[17:28:26.054]                 NAMES <- toupper(added)
[17:28:26.054]                 for (kk in seq_along(NAMES)) {
[17:28:26.054]                   name <- added[[kk]]
[17:28:26.054]                   NAME <- NAMES[[kk]]
[17:28:26.054]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.054]                     next
[17:28:26.054]                   args[[name]] <- ""
[17:28:26.054]                 }
[17:28:26.054]                 NAMES <- toupper(removed)
[17:28:26.054]                 for (kk in seq_along(NAMES)) {
[17:28:26.054]                   name <- removed[[kk]]
[17:28:26.054]                   NAME <- NAMES[[kk]]
[17:28:26.054]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.054]                     next
[17:28:26.054]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:26.054]                 }
[17:28:26.054]                 if (length(args) > 0) 
[17:28:26.054]                   base::do.call(base::Sys.setenv, args = args)
[17:28:26.054]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:26.054]             }
[17:28:26.054]             else {
[17:28:26.054]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:26.054]             }
[17:28:26.054]             {
[17:28:26.054]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:26.054]                   0L) {
[17:28:26.054]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:26.054]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:26.054]                   base::options(opts)
[17:28:26.054]                 }
[17:28:26.054]                 {
[17:28:26.054]                   {
[17:28:26.054]                     NULL
[17:28:26.054]                     RNGkind("Mersenne-Twister")
[17:28:26.054]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:26.054]                       inherits = FALSE)
[17:28:26.054]                   }
[17:28:26.054]                   options(future.plan = NULL)
[17:28:26.054]                   if (is.na(NA_character_)) 
[17:28:26.054]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:26.054]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:26.054]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:26.054]                     .init = FALSE)
[17:28:26.054]                 }
[17:28:26.054]             }
[17:28:26.054]         }
[17:28:26.054]     })
[17:28:26.054]     if (TRUE) {
[17:28:26.054]         base::sink(type = "output", split = FALSE)
[17:28:26.054]         if (TRUE) {
[17:28:26.054]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:26.054]         }
[17:28:26.054]         else {
[17:28:26.054]             ...future.result["stdout"] <- base::list(NULL)
[17:28:26.054]         }
[17:28:26.054]         base::close(...future.stdout)
[17:28:26.054]         ...future.stdout <- NULL
[17:28:26.054]     }
[17:28:26.054]     ...future.result$conditions <- ...future.conditions
[17:28:26.054]     ...future.result$finished <- base::Sys.time()
[17:28:26.054]     ...future.result
[17:28:26.054] }
[17:28:26.062] plan(): Setting new future strategy stack:
[17:28:26.062] List of future strategies:
[17:28:26.062] 1. sequential:
[17:28:26.062]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:26.062]    - tweaked: FALSE
[17:28:26.062]    - call: NULL
[17:28:26.063] plan(): nbrOfWorkers() = 1
[17:28:26.067] plan(): Setting new future strategy stack:
[17:28:26.071] List of future strategies:
[17:28:26.071] 1. sequential:
[17:28:26.071]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:26.071]    - tweaked: FALSE
[17:28:26.071]    - call: future::plan("sequential")
[17:28:26.073] plan(): nbrOfWorkers() = 1
[17:28:26.073] SequentialFuture started (and completed)
[17:28:26.074] signalConditions() ...
[17:28:26.074]  - include = 'immediateCondition'
[17:28:26.074]  - exclude = 
[17:28:26.075]  - resignal = FALSE
[17:28:26.075]  - Number of conditions: 1
[17:28:26.075] signalConditions() ... done
[17:28:26.075] signalConditions() ...
[17:28:26.076]  - include = 'immediateCondition'
[17:28:26.076]  - exclude = 
[17:28:26.076]  - resignal = FALSE
[17:28:26.077]  - Number of conditions: 1
[17:28:26.077] signalConditions() ... done
<simpleError in eval(quote({    stop("Whoops!")    1}), new.env()): Whoops!>
[17:28:26.078] signalConditions() ...
[17:28:26.079]  - include = 'immediateCondition'
[17:28:26.079]  - exclude = 
[17:28:26.079]  - resignal = FALSE
[17:28:26.080]  - Number of conditions: 1
[17:28:26.080] signalConditions() ... done
[17:28:26.081] Future state: 'finished'
[17:28:26.081] signalConditions() ...
[17:28:26.082]  - include = 'condition'
[17:28:26.082]  - exclude = 'immediateCondition'
[17:28:26.082]  - resignal = TRUE
[17:28:26.083]  - Number of conditions: 1
[17:28:26.083]  - Condition #1: 'simpleError', 'error', 'condition'
[17:28:26.084] signalConditions() ... done
[1] "Error in eval(quote({ : Whoops!\n"
attr(,"class")
[1] "try-error"
attr(,"condition")
<simpleError in eval(quote({    stop("Whoops!")    1}), new.env()): Whoops!>
[17:28:26.085] signalConditions() ...
[17:28:26.085]  - include = 'immediateCondition'
[17:28:26.086]  - exclude = 
[17:28:26.086]  - resignal = FALSE
[17:28:26.086]  - Number of conditions: 1
[17:28:26.087] signalConditions() ... done
[17:28:26.087] Future state: 'finished'
[17:28:26.088] signalConditions() ...
[17:28:26.088]  - include = 'condition'
[17:28:26.088]  - exclude = 'immediateCondition'
[17:28:26.089]  - resignal = TRUE
[17:28:26.089]  - Number of conditions: 1
[17:28:26.090]  - Condition #1: 'simpleError', 'error', 'condition'
[17:28:26.090] signalConditions() ... done
[1] "Error in eval(quote({ : Whoops!\n"
attr(,"class")
[1] "try-error"
attr(,"condition")
<simpleError in eval(quote({    stop("Whoops!")    1}), new.env()): Whoops!>
[17:28:26.096] getGlobalsAndPackages() ...
[17:28:26.096] Searching for globals...
[17:28:26.099] - globals found: [5] '{', 'stop', 'structure', 'list', 'c'
[17:28:26.100] Searching for globals ... DONE
[17:28:26.100] Resolving globals: FALSE
[17:28:26.101] 
[17:28:26.101] 
[17:28:26.101] getGlobalsAndPackages() ... DONE
SequentialFuture:
Label: '<none>'
Expression:
{
    stop(structure(list(message = "boom"), class = c("MyError", 
        "error", "condition")))
}
Lazy evaluation: TRUE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: FALSE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 12734a8a-480b-f2a5-0c96-45c13d81d854
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:26.103] Packages needed by the future expression (n = 0): <none>
[17:28:26.103] Packages needed by future strategies (n = 0): <none>
[17:28:26.105] {
[17:28:26.105]     {
[17:28:26.105]         {
[17:28:26.105]             ...future.startTime <- base::Sys.time()
[17:28:26.105]             {
[17:28:26.105]                 {
[17:28:26.105]                   {
[17:28:26.105]                     base::local({
[17:28:26.105]                       has_future <- base::requireNamespace("future", 
[17:28:26.105]                         quietly = TRUE)
[17:28:26.105]                       if (has_future) {
[17:28:26.105]                         ns <- base::getNamespace("future")
[17:28:26.105]                         version <- ns[[".package"]][["version"]]
[17:28:26.105]                         if (is.null(version)) 
[17:28:26.105]                           version <- utils::packageVersion("future")
[17:28:26.105]                       }
[17:28:26.105]                       else {
[17:28:26.105]                         version <- NULL
[17:28:26.105]                       }
[17:28:26.105]                       if (!has_future || version < "1.8.0") {
[17:28:26.105]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:26.105]                           "", base::R.version$version.string), 
[17:28:26.105]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:26.105]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:26.105]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:26.105]                             "release", "version")], collapse = " "), 
[17:28:26.105]                           hostname = base::Sys.info()[["nodename"]])
[17:28:26.105]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:26.105]                           info)
[17:28:26.105]                         info <- base::paste(info, collapse = "; ")
[17:28:26.105]                         if (!has_future) {
[17:28:26.105]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:26.105]                             info)
[17:28:26.105]                         }
[17:28:26.105]                         else {
[17:28:26.105]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:26.105]                             info, version)
[17:28:26.105]                         }
[17:28:26.105]                         base::stop(msg)
[17:28:26.105]                       }
[17:28:26.105]                     })
[17:28:26.105]                   }
[17:28:26.105]                   ...future.strategy.old <- future::plan("list")
[17:28:26.105]                   options(future.plan = NULL)
[17:28:26.105]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:26.105]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:26.105]                 }
[17:28:26.105]                 ...future.workdir <- getwd()
[17:28:26.105]             }
[17:28:26.105]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:26.105]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:26.105]         }
[17:28:26.105]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:26.105]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:26.105]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:26.105]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:26.105]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:26.105]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:26.105]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:26.105]             base::names(...future.oldOptions))
[17:28:26.105]     }
[17:28:26.105]     if (FALSE) {
[17:28:26.105]     }
[17:28:26.105]     else {
[17:28:26.105]         if (TRUE) {
[17:28:26.105]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:26.105]                 open = "w")
[17:28:26.105]         }
[17:28:26.105]         else {
[17:28:26.105]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:26.105]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:26.105]         }
[17:28:26.105]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:26.105]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:26.105]             base::sink(type = "output", split = FALSE)
[17:28:26.105]             base::close(...future.stdout)
[17:28:26.105]         }, add = TRUE)
[17:28:26.105]     }
[17:28:26.105]     ...future.frame <- base::sys.nframe()
[17:28:26.105]     ...future.conditions <- base::list()
[17:28:26.105]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:26.105]     if (FALSE) {
[17:28:26.105]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:26.105]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:26.105]     }
[17:28:26.105]     ...future.result <- base::tryCatch({
[17:28:26.105]         base::withCallingHandlers({
[17:28:26.105]             ...future.value <- base::withVisible(base::local({
[17:28:26.105]                 stop(structure(list(message = "boom"), class = c("MyError", 
[17:28:26.105]                   "error", "condition")))
[17:28:26.105]             }))
[17:28:26.105]             future::FutureResult(value = ...future.value$value, 
[17:28:26.105]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:26.105]                   ...future.rng), globalenv = if (FALSE) 
[17:28:26.105]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:26.105]                     ...future.globalenv.names))
[17:28:26.105]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:26.105]         }, condition = base::local({
[17:28:26.105]             c <- base::c
[17:28:26.105]             inherits <- base::inherits
[17:28:26.105]             invokeRestart <- base::invokeRestart
[17:28:26.105]             length <- base::length
[17:28:26.105]             list <- base::list
[17:28:26.105]             seq.int <- base::seq.int
[17:28:26.105]             signalCondition <- base::signalCondition
[17:28:26.105]             sys.calls <- base::sys.calls
[17:28:26.105]             `[[` <- base::`[[`
[17:28:26.105]             `+` <- base::`+`
[17:28:26.105]             `<<-` <- base::`<<-`
[17:28:26.105]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:26.105]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:26.105]                   3L)]
[17:28:26.105]             }
[17:28:26.105]             function(cond) {
[17:28:26.105]                 is_error <- inherits(cond, "error")
[17:28:26.105]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:26.105]                   NULL)
[17:28:26.105]                 if (is_error) {
[17:28:26.105]                   sessionInformation <- function() {
[17:28:26.105]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:26.105]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:26.105]                       search = base::search(), system = base::Sys.info())
[17:28:26.105]                   }
[17:28:26.105]                   ...future.conditions[[length(...future.conditions) + 
[17:28:26.105]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:26.105]                     cond$call), session = sessionInformation(), 
[17:28:26.105]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:26.105]                   signalCondition(cond)
[17:28:26.105]                 }
[17:28:26.105]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:26.105]                 "immediateCondition"))) {
[17:28:26.105]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:26.105]                   ...future.conditions[[length(...future.conditions) + 
[17:28:26.105]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:26.105]                   if (TRUE && !signal) {
[17:28:26.105]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:26.105]                     {
[17:28:26.105]                       inherits <- base::inherits
[17:28:26.105]                       invokeRestart <- base::invokeRestart
[17:28:26.105]                       is.null <- base::is.null
[17:28:26.105]                       muffled <- FALSE
[17:28:26.105]                       if (inherits(cond, "message")) {
[17:28:26.105]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:26.105]                         if (muffled) 
[17:28:26.105]                           invokeRestart("muffleMessage")
[17:28:26.105]                       }
[17:28:26.105]                       else if (inherits(cond, "warning")) {
[17:28:26.105]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:26.105]                         if (muffled) 
[17:28:26.105]                           invokeRestart("muffleWarning")
[17:28:26.105]                       }
[17:28:26.105]                       else if (inherits(cond, "condition")) {
[17:28:26.105]                         if (!is.null(pattern)) {
[17:28:26.105]                           computeRestarts <- base::computeRestarts
[17:28:26.105]                           grepl <- base::grepl
[17:28:26.105]                           restarts <- computeRestarts(cond)
[17:28:26.105]                           for (restart in restarts) {
[17:28:26.105]                             name <- restart$name
[17:28:26.105]                             if (is.null(name)) 
[17:28:26.105]                               next
[17:28:26.105]                             if (!grepl(pattern, name)) 
[17:28:26.105]                               next
[17:28:26.105]                             invokeRestart(restart)
[17:28:26.105]                             muffled <- TRUE
[17:28:26.105]                             break
[17:28:26.105]                           }
[17:28:26.105]                         }
[17:28:26.105]                       }
[17:28:26.105]                       invisible(muffled)
[17:28:26.105]                     }
[17:28:26.105]                     muffleCondition(cond, pattern = "^muffle")
[17:28:26.105]                   }
[17:28:26.105]                 }
[17:28:26.105]                 else {
[17:28:26.105]                   if (TRUE) {
[17:28:26.105]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:26.105]                     {
[17:28:26.105]                       inherits <- base::inherits
[17:28:26.105]                       invokeRestart <- base::invokeRestart
[17:28:26.105]                       is.null <- base::is.null
[17:28:26.105]                       muffled <- FALSE
[17:28:26.105]                       if (inherits(cond, "message")) {
[17:28:26.105]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:26.105]                         if (muffled) 
[17:28:26.105]                           invokeRestart("muffleMessage")
[17:28:26.105]                       }
[17:28:26.105]                       else if (inherits(cond, "warning")) {
[17:28:26.105]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:26.105]                         if (muffled) 
[17:28:26.105]                           invokeRestart("muffleWarning")
[17:28:26.105]                       }
[17:28:26.105]                       else if (inherits(cond, "condition")) {
[17:28:26.105]                         if (!is.null(pattern)) {
[17:28:26.105]                           computeRestarts <- base::computeRestarts
[17:28:26.105]                           grepl <- base::grepl
[17:28:26.105]                           restarts <- computeRestarts(cond)
[17:28:26.105]                           for (restart in restarts) {
[17:28:26.105]                             name <- restart$name
[17:28:26.105]                             if (is.null(name)) 
[17:28:26.105]                               next
[17:28:26.105]                             if (!grepl(pattern, name)) 
[17:28:26.105]                               next
[17:28:26.105]                             invokeRestart(restart)
[17:28:26.105]                             muffled <- TRUE
[17:28:26.105]                             break
[17:28:26.105]                           }
[17:28:26.105]                         }
[17:28:26.105]                       }
[17:28:26.105]                       invisible(muffled)
[17:28:26.105]                     }
[17:28:26.105]                     muffleCondition(cond, pattern = "^muffle")
[17:28:26.105]                   }
[17:28:26.105]                 }
[17:28:26.105]             }
[17:28:26.105]         }))
[17:28:26.105]     }, error = function(ex) {
[17:28:26.105]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:26.105]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:26.105]                 ...future.rng), started = ...future.startTime, 
[17:28:26.105]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:26.105]             version = "1.8"), class = "FutureResult")
[17:28:26.105]     }, finally = {
[17:28:26.105]         if (!identical(...future.workdir, getwd())) 
[17:28:26.105]             setwd(...future.workdir)
[17:28:26.105]         {
[17:28:26.105]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:26.105]                 ...future.oldOptions$nwarnings <- NULL
[17:28:26.105]             }
[17:28:26.105]             base::options(...future.oldOptions)
[17:28:26.105]             if (.Platform$OS.type == "windows") {
[17:28:26.105]                 old_names <- names(...future.oldEnvVars)
[17:28:26.105]                 envs <- base::Sys.getenv()
[17:28:26.105]                 names <- names(envs)
[17:28:26.105]                 common <- intersect(names, old_names)
[17:28:26.105]                 added <- setdiff(names, old_names)
[17:28:26.105]                 removed <- setdiff(old_names, names)
[17:28:26.105]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:26.105]                   envs[common]]
[17:28:26.105]                 NAMES <- toupper(changed)
[17:28:26.105]                 args <- list()
[17:28:26.105]                 for (kk in seq_along(NAMES)) {
[17:28:26.105]                   name <- changed[[kk]]
[17:28:26.105]                   NAME <- NAMES[[kk]]
[17:28:26.105]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.105]                     next
[17:28:26.105]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:26.105]                 }
[17:28:26.105]                 NAMES <- toupper(added)
[17:28:26.105]                 for (kk in seq_along(NAMES)) {
[17:28:26.105]                   name <- added[[kk]]
[17:28:26.105]                   NAME <- NAMES[[kk]]
[17:28:26.105]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.105]                     next
[17:28:26.105]                   args[[name]] <- ""
[17:28:26.105]                 }
[17:28:26.105]                 NAMES <- toupper(removed)
[17:28:26.105]                 for (kk in seq_along(NAMES)) {
[17:28:26.105]                   name <- removed[[kk]]
[17:28:26.105]                   NAME <- NAMES[[kk]]
[17:28:26.105]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:26.105]                     next
[17:28:26.105]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:26.105]                 }
[17:28:26.105]                 if (length(args) > 0) 
[17:28:26.105]                   base::do.call(base::Sys.setenv, args = args)
[17:28:26.105]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:26.105]             }
[17:28:26.105]             else {
[17:28:26.105]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:26.105]             }
[17:28:26.105]             {
[17:28:26.105]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:26.105]                   0L) {
[17:28:26.105]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:26.105]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:26.105]                   base::options(opts)
[17:28:26.105]                 }
[17:28:26.105]                 {
[17:28:26.105]                   {
[17:28:26.105]                     NULL
[17:28:26.105]                     RNGkind("Mersenne-Twister")
[17:28:26.105]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:26.105]                       inherits = FALSE)
[17:28:26.105]                   }
[17:28:26.105]                   options(future.plan = NULL)
[17:28:26.105]                   if (is.na(NA_character_)) 
[17:28:26.105]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:26.105]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:26.105]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:26.105]                     .init = FALSE)
[17:28:26.105]                 }
[17:28:26.105]             }
[17:28:26.105]         }
[17:28:26.105]     })
[17:28:26.105]     if (TRUE) {
[17:28:26.105]         base::sink(type = "output", split = FALSE)
[17:28:26.105]         if (TRUE) {
[17:28:26.105]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:26.105]         }
[17:28:26.105]         else {
[17:28:26.105]             ...future.result["stdout"] <- base::list(NULL)
[17:28:26.105]         }
[17:28:26.105]         base::close(...future.stdout)
[17:28:26.105]         ...future.stdout <- NULL
[17:28:26.105]     }
[17:28:26.105]     ...future.result$conditions <- ...future.conditions
[17:28:26.105]     ...future.result$finished <- base::Sys.time()
[17:28:26.105]     ...future.result
[17:28:26.105] }
[17:28:26.112] plan(): Setting new future strategy stack:
[17:28:26.112] List of future strategies:
[17:28:26.112] 1. sequential:
[17:28:26.112]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:26.112]    - tweaked: FALSE
[17:28:26.112]    - call: NULL
[17:28:26.113] plan(): nbrOfWorkers() = 1
[17:28:26.116] plan(): Setting new future strategy stack:
[17:28:26.117] List of future strategies:
[17:28:26.117] 1. sequential:
[17:28:26.117]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:26.117]    - tweaked: FALSE
[17:28:26.117]    - call: future::plan("sequential")
[17:28:26.118] plan(): nbrOfWorkers() = 1
[17:28:26.118] SequentialFuture started (and completed)
[17:28:26.119] signalConditions() ...
[17:28:26.119]  - include = 'immediateCondition'
[17:28:26.119]  - exclude = 
[17:28:26.120]  - resignal = FALSE
[17:28:26.120]  - Number of conditions: 1
[17:28:26.120] signalConditions() ... done
[17:28:26.121] signalConditions() ...
[17:28:26.121]  - include = 'immediateCondition'
[17:28:26.121]  - exclude = 
[17:28:26.122]  - resignal = FALSE
[17:28:26.122]  - Number of conditions: 1
[17:28:26.122] signalConditions() ... done
<MyError: boom>
[17:28:26.123] signalConditions() ...
[17:28:26.123]  - include = 'immediateCondition'
[17:28:26.124]  - exclude = 
[17:28:26.124]  - resignal = FALSE
[17:28:26.124]  - Number of conditions: 1
[17:28:26.125] signalConditions() ... done
[17:28:26.125] Future state: 'finished'
[17:28:26.125] signalConditions() ...
[17:28:26.126]  - include = 'condition'
[17:28:26.126]  - exclude = 'immediateCondition'
[17:28:26.126]  - resignal = TRUE
[17:28:26.127]  - Number of conditions: 1
[17:28:26.127]  - Condition #1: 'MyError', 'error', 'condition'
[17:28:26.127] signalConditions() ... done
Testing with 1 cores ... DONE
Testing with 2 cores ...
[17:28:26.134] getGlobalsAndPackages() ...
[17:28:26.135] 
[17:28:26.136] - globals: [0] <none>
[17:28:26.136] getGlobalsAndPackages() ... DONE
[17:28:26.137] [local output] makeClusterPSOCK() ...
[17:28:26.227] [local output] Workers: [n = 2] 'localhost', 'localhost'
[17:28:26.236] [local output] Base port: 22055
[17:28:26.236] [local output] Getting setup options for 2 cluster nodes ...
[17:28:26.237] [local output]  - Node #1 of 2 ...
[17:28:26.238] [local output] localMachine=TRUE => revtunnel=FALSE

[17:28:26.240] Testing if worker's PID can be inferred: '"D:/RCompile/recent/R/bin/x64/Rscript" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/Rtmp6N6urL/worker.rank=1.parallelly.parent=85924.14fa443ac33da.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/Rtmp6N6urL/worker.rank=1.parallelly.parent=85924.14fa443ac33da.pid\")"'
[17:28:26.690] - Possible to infer worker's PID: TRUE
[17:28:26.691] [local output] Rscript port: 22055

[17:28:26.692] [local output]  - Node #2 of 2 ...
[17:28:26.693] [local output] localMachine=TRUE => revtunnel=FALSE

[17:28:26.695] [local output] Rscript port: 22055

[17:28:26.696] [local output] Getting setup options for 2 cluster nodes ... done
[17:28:26.696] [local output]  - Parallel setup requested for some PSOCK nodes
[17:28:26.698] [local output] Setting up PSOCK nodes in parallel
[17:28:26.698] List of 36
[17:28:26.698]  $ worker          : chr "localhost"
[17:28:26.698]   ..- attr(*, "localhost")= logi TRUE
[17:28:26.698]  $ master          : chr "localhost"
[17:28:26.698]  $ port            : int 22055
[17:28:26.698]  $ connectTimeout  : num 120
[17:28:26.698]  $ timeout         : num 120
[17:28:26.698]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[17:28:26.698]  $ homogeneous     : logi TRUE
[17:28:26.698]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=multisession.R:85924:CRANWIN3:CR"| __truncated__
[17:28:26.698]  $ rscript_envs    : NULL
[17:28:26.698]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda" "D:/RCompile/recent/R/library"
[17:28:26.698]  $ rscript_startup : NULL
[17:28:26.698]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[17:28:26.698]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:28:26.698]  $ methods         : logi TRUE
[17:28:26.698]  $ socketOptions   : chr "no-delay"
[17:28:26.698]  $ useXDR          : logi FALSE
[17:28:26.698]  $ outfile         : chr "/dev/null"
[17:28:26.698]  $ renice          : int NA
[17:28:26.698]  $ rshcmd          : NULL
[17:28:26.698]  $ user            : chr(0) 
[17:28:26.698]  $ revtunnel       : logi FALSE
[17:28:26.698]  $ rshlogfile      : NULL
[17:28:26.698]  $ rshopts         : chr(0) 
[17:28:26.698]  $ rank            : int 1
[17:28:26.698]  $ manual          : logi FALSE
[17:28:26.698]  $ dryrun          : logi FALSE
[17:28:26.698]  $ quiet           : logi FALSE
[17:28:26.698]  $ setup_strategy  : chr "parallel"
[17:28:26.698]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:28:26.698]  $ pidfile         : chr "D:/temp/Rtmp6N6urL/worker.rank=1.parallelly.parent=85924.14fa443ac33da.pid"
[17:28:26.698]  $ rshcmd_label    : NULL
[17:28:26.698]  $ rsh_call        : NULL
[17:28:26.698]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:28:26.698]  $ localMachine    : logi TRUE
[17:28:26.698]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[17:28:26.698]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[17:28:26.698]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[17:28:26.698]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[17:28:26.698]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[17:28:26.698]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[17:28:26.698]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[17:28:26.698]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[17:28:26.698]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[17:28:26.698]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[17:28:26.698]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[17:28:26.698]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[17:28:26.698]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[17:28:26.698]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[17:28:26.698]  $ arguments       :List of 28
[17:28:26.698]   ..$ worker          : chr "localhost"
[17:28:26.698]   ..$ master          : NULL
[17:28:26.698]   ..$ port            : int 22055
[17:28:26.698]   ..$ connectTimeout  : num 120
[17:28:26.698]   ..$ timeout         : num 120
[17:28:26.698]   ..$ rscript         : NULL
[17:28:26.698]   ..$ homogeneous     : NULL
[17:28:26.698]   ..$ rscript_args    : NULL
[17:28:26.698]   ..$ rscript_envs    : NULL
[17:28:26.698]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda" "D:/RCompile/recent/R/library"
[17:28:26.698]   ..$ rscript_startup : NULL
[17:28:26.698]   ..$ rscript_sh      : chr "auto"
[17:28:26.698]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:28:26.698]   ..$ methods         : logi TRUE
[17:28:26.698]   ..$ socketOptions   : chr "no-delay"
[17:28:26.698]   ..$ useXDR          : logi FALSE
[17:28:26.698]   ..$ outfile         : chr "/dev/null"
[17:28:26.698]   ..$ renice          : int NA
[17:28:26.698]   ..$ rshcmd          : NULL
[17:28:26.698]   ..$ user            : NULL
[17:28:26.698]   ..$ revtunnel       : logi NA
[17:28:26.698]   ..$ rshlogfile      : NULL
[17:28:26.698]   ..$ rshopts         : NULL
[17:28:26.698]   ..$ rank            : int 1
[17:28:26.698]   ..$ manual          : logi FALSE
[17:28:26.698]   ..$ dryrun          : logi FALSE
[17:28:26.698]   ..$ quiet           : logi FALSE
[17:28:26.698]   ..$ setup_strategy  : chr "parallel"
[17:28:26.698]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[17:28:26.737] [local output] System call to launch all workers:
[17:28:26.737] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=multisession.R:85924:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/Rtmp6N6urL/worker.rank=1.parallelly.parent=85924.14fa443ac33da.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=22055 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[17:28:26.738] [local output] Starting PSOCK main server
[17:28:26.747] [local output] Workers launched
[17:28:26.747] [local output] Waiting for workers to connect back
[17:28:26.748]  - [local output] 0 workers out of 2 ready
[17:28:26.982]  - [local output] 0 workers out of 2 ready
[17:28:26.982]  - [local output] 1 workers out of 2 ready
[17:28:26.994]  - [local output] 1 workers out of 2 ready
[17:28:26.995]  - [local output] 2 workers out of 2 ready
[17:28:26.996] [local output] Launching of 2 workers completed
[17:28:26.996] [local output] Number of nodes in cluster: 2
[17:28:26.996] [local output] Collecting session information from 2 workers
[17:28:26.998] [local output]  - Worker #1 of 2
[17:28:27.000] [local output]  - Worker #2 of 2
[17:28:27.000] [local output] makeClusterPSOCK() ... done
[17:28:27.017] Packages needed by the future expression (n = 0): <none>
[17:28:27.018] Packages needed by future strategies (n = 0): <none>
[17:28:27.019] {
[17:28:27.019]     {
[17:28:27.019]         {
[17:28:27.019]             ...future.startTime <- base::Sys.time()
[17:28:27.019]             {
[17:28:27.019]                 {
[17:28:27.019]                   {
[17:28:27.019]                     {
[17:28:27.019]                       base::local({
[17:28:27.019]                         has_future <- base::requireNamespace("future", 
[17:28:27.019]                           quietly = TRUE)
[17:28:27.019]                         if (has_future) {
[17:28:27.019]                           ns <- base::getNamespace("future")
[17:28:27.019]                           version <- ns[[".package"]][["version"]]
[17:28:27.019]                           if (is.null(version)) 
[17:28:27.019]                             version <- utils::packageVersion("future")
[17:28:27.019]                         }
[17:28:27.019]                         else {
[17:28:27.019]                           version <- NULL
[17:28:27.019]                         }
[17:28:27.019]                         if (!has_future || version < "1.8.0") {
[17:28:27.019]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:27.019]                             "", base::R.version$version.string), 
[17:28:27.019]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:27.019]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:27.019]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:27.019]                               "release", "version")], collapse = " "), 
[17:28:27.019]                             hostname = base::Sys.info()[["nodename"]])
[17:28:27.019]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:27.019]                             info)
[17:28:27.019]                           info <- base::paste(info, collapse = "; ")
[17:28:27.019]                           if (!has_future) {
[17:28:27.019]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:27.019]                               info)
[17:28:27.019]                           }
[17:28:27.019]                           else {
[17:28:27.019]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:27.019]                               info, version)
[17:28:27.019]                           }
[17:28:27.019]                           base::stop(msg)
[17:28:27.019]                         }
[17:28:27.019]                       })
[17:28:27.019]                     }
[17:28:27.019]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:27.019]                     base::options(mc.cores = 1L)
[17:28:27.019]                   }
[17:28:27.019]                   ...future.strategy.old <- future::plan("list")
[17:28:27.019]                   options(future.plan = NULL)
[17:28:27.019]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.019]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:27.019]                 }
[17:28:27.019]                 ...future.workdir <- getwd()
[17:28:27.019]             }
[17:28:27.019]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:27.019]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:27.019]         }
[17:28:27.019]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:27.019]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:27.019]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:27.019]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:27.019]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:27.019]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:27.019]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:27.019]             base::names(...future.oldOptions))
[17:28:27.019]     }
[17:28:27.019]     if (FALSE) {
[17:28:27.019]     }
[17:28:27.019]     else {
[17:28:27.019]         if (TRUE) {
[17:28:27.019]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:27.019]                 open = "w")
[17:28:27.019]         }
[17:28:27.019]         else {
[17:28:27.019]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:27.019]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:27.019]         }
[17:28:27.019]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:27.019]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:27.019]             base::sink(type = "output", split = FALSE)
[17:28:27.019]             base::close(...future.stdout)
[17:28:27.019]         }, add = TRUE)
[17:28:27.019]     }
[17:28:27.019]     ...future.frame <- base::sys.nframe()
[17:28:27.019]     ...future.conditions <- base::list()
[17:28:27.019]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:27.019]     if (FALSE) {
[17:28:27.019]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:27.019]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:27.019]     }
[17:28:27.019]     ...future.result <- base::tryCatch({
[17:28:27.019]         base::withCallingHandlers({
[17:28:27.019]             ...future.value <- base::withVisible(base::local({
[17:28:27.019]                 ...future.makeSendCondition <- base::local({
[17:28:27.019]                   sendCondition <- NULL
[17:28:27.019]                   function(frame = 1L) {
[17:28:27.019]                     if (is.function(sendCondition)) 
[17:28:27.019]                       return(sendCondition)
[17:28:27.019]                     ns <- getNamespace("parallel")
[17:28:27.019]                     if (exists("sendData", mode = "function", 
[17:28:27.019]                       envir = ns)) {
[17:28:27.019]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:27.019]                         envir = ns)
[17:28:27.019]                       envir <- sys.frame(frame)
[17:28:27.019]                       master <- NULL
[17:28:27.019]                       while (!identical(envir, .GlobalEnv) && 
[17:28:27.019]                         !identical(envir, emptyenv())) {
[17:28:27.019]                         if (exists("master", mode = "list", envir = envir, 
[17:28:27.019]                           inherits = FALSE)) {
[17:28:27.019]                           master <- get("master", mode = "list", 
[17:28:27.019]                             envir = envir, inherits = FALSE)
[17:28:27.019]                           if (inherits(master, c("SOCKnode", 
[17:28:27.019]                             "SOCK0node"))) {
[17:28:27.019]                             sendCondition <<- function(cond) {
[17:28:27.019]                               data <- list(type = "VALUE", value = cond, 
[17:28:27.019]                                 success = TRUE)
[17:28:27.019]                               parallel_sendData(master, data)
[17:28:27.019]                             }
[17:28:27.019]                             return(sendCondition)
[17:28:27.019]                           }
[17:28:27.019]                         }
[17:28:27.019]                         frame <- frame + 1L
[17:28:27.019]                         envir <- sys.frame(frame)
[17:28:27.019]                       }
[17:28:27.019]                     }
[17:28:27.019]                     sendCondition <<- function(cond) NULL
[17:28:27.019]                   }
[17:28:27.019]                 })
[17:28:27.019]                 withCallingHandlers({
[17:28:27.019]                   {
[17:28:27.019]                     42L
[17:28:27.019]                   }
[17:28:27.019]                 }, immediateCondition = function(cond) {
[17:28:27.019]                   sendCondition <- ...future.makeSendCondition()
[17:28:27.019]                   sendCondition(cond)
[17:28:27.019]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.019]                   {
[17:28:27.019]                     inherits <- base::inherits
[17:28:27.019]                     invokeRestart <- base::invokeRestart
[17:28:27.019]                     is.null <- base::is.null
[17:28:27.019]                     muffled <- FALSE
[17:28:27.019]                     if (inherits(cond, "message")) {
[17:28:27.019]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:27.019]                       if (muffled) 
[17:28:27.019]                         invokeRestart("muffleMessage")
[17:28:27.019]                     }
[17:28:27.019]                     else if (inherits(cond, "warning")) {
[17:28:27.019]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:27.019]                       if (muffled) 
[17:28:27.019]                         invokeRestart("muffleWarning")
[17:28:27.019]                     }
[17:28:27.019]                     else if (inherits(cond, "condition")) {
[17:28:27.019]                       if (!is.null(pattern)) {
[17:28:27.019]                         computeRestarts <- base::computeRestarts
[17:28:27.019]                         grepl <- base::grepl
[17:28:27.019]                         restarts <- computeRestarts(cond)
[17:28:27.019]                         for (restart in restarts) {
[17:28:27.019]                           name <- restart$name
[17:28:27.019]                           if (is.null(name)) 
[17:28:27.019]                             next
[17:28:27.019]                           if (!grepl(pattern, name)) 
[17:28:27.019]                             next
[17:28:27.019]                           invokeRestart(restart)
[17:28:27.019]                           muffled <- TRUE
[17:28:27.019]                           break
[17:28:27.019]                         }
[17:28:27.019]                       }
[17:28:27.019]                     }
[17:28:27.019]                     invisible(muffled)
[17:28:27.019]                   }
[17:28:27.019]                   muffleCondition(cond)
[17:28:27.019]                 })
[17:28:27.019]             }))
[17:28:27.019]             future::FutureResult(value = ...future.value$value, 
[17:28:27.019]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.019]                   ...future.rng), globalenv = if (FALSE) 
[17:28:27.019]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:27.019]                     ...future.globalenv.names))
[17:28:27.019]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:27.019]         }, condition = base::local({
[17:28:27.019]             c <- base::c
[17:28:27.019]             inherits <- base::inherits
[17:28:27.019]             invokeRestart <- base::invokeRestart
[17:28:27.019]             length <- base::length
[17:28:27.019]             list <- base::list
[17:28:27.019]             seq.int <- base::seq.int
[17:28:27.019]             signalCondition <- base::signalCondition
[17:28:27.019]             sys.calls <- base::sys.calls
[17:28:27.019]             `[[` <- base::`[[`
[17:28:27.019]             `+` <- base::`+`
[17:28:27.019]             `<<-` <- base::`<<-`
[17:28:27.019]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:27.019]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:27.019]                   3L)]
[17:28:27.019]             }
[17:28:27.019]             function(cond) {
[17:28:27.019]                 is_error <- inherits(cond, "error")
[17:28:27.019]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:27.019]                   NULL)
[17:28:27.019]                 if (is_error) {
[17:28:27.019]                   sessionInformation <- function() {
[17:28:27.019]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:27.019]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:27.019]                       search = base::search(), system = base::Sys.info())
[17:28:27.019]                   }
[17:28:27.019]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.019]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:27.019]                     cond$call), session = sessionInformation(), 
[17:28:27.019]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:27.019]                   signalCondition(cond)
[17:28:27.019]                 }
[17:28:27.019]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:27.019]                 "immediateCondition"))) {
[17:28:27.019]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:27.019]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.019]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:27.019]                   if (TRUE && !signal) {
[17:28:27.019]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.019]                     {
[17:28:27.019]                       inherits <- base::inherits
[17:28:27.019]                       invokeRestart <- base::invokeRestart
[17:28:27.019]                       is.null <- base::is.null
[17:28:27.019]                       muffled <- FALSE
[17:28:27.019]                       if (inherits(cond, "message")) {
[17:28:27.019]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.019]                         if (muffled) 
[17:28:27.019]                           invokeRestart("muffleMessage")
[17:28:27.019]                       }
[17:28:27.019]                       else if (inherits(cond, "warning")) {
[17:28:27.019]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.019]                         if (muffled) 
[17:28:27.019]                           invokeRestart("muffleWarning")
[17:28:27.019]                       }
[17:28:27.019]                       else if (inherits(cond, "condition")) {
[17:28:27.019]                         if (!is.null(pattern)) {
[17:28:27.019]                           computeRestarts <- base::computeRestarts
[17:28:27.019]                           grepl <- base::grepl
[17:28:27.019]                           restarts <- computeRestarts(cond)
[17:28:27.019]                           for (restart in restarts) {
[17:28:27.019]                             name <- restart$name
[17:28:27.019]                             if (is.null(name)) 
[17:28:27.019]                               next
[17:28:27.019]                             if (!grepl(pattern, name)) 
[17:28:27.019]                               next
[17:28:27.019]                             invokeRestart(restart)
[17:28:27.019]                             muffled <- TRUE
[17:28:27.019]                             break
[17:28:27.019]                           }
[17:28:27.019]                         }
[17:28:27.019]                       }
[17:28:27.019]                       invisible(muffled)
[17:28:27.019]                     }
[17:28:27.019]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.019]                   }
[17:28:27.019]                 }
[17:28:27.019]                 else {
[17:28:27.019]                   if (TRUE) {
[17:28:27.019]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.019]                     {
[17:28:27.019]                       inherits <- base::inherits
[17:28:27.019]                       invokeRestart <- base::invokeRestart
[17:28:27.019]                       is.null <- base::is.null
[17:28:27.019]                       muffled <- FALSE
[17:28:27.019]                       if (inherits(cond, "message")) {
[17:28:27.019]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.019]                         if (muffled) 
[17:28:27.019]                           invokeRestart("muffleMessage")
[17:28:27.019]                       }
[17:28:27.019]                       else if (inherits(cond, "warning")) {
[17:28:27.019]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.019]                         if (muffled) 
[17:28:27.019]                           invokeRestart("muffleWarning")
[17:28:27.019]                       }
[17:28:27.019]                       else if (inherits(cond, "condition")) {
[17:28:27.019]                         if (!is.null(pattern)) {
[17:28:27.019]                           computeRestarts <- base::computeRestarts
[17:28:27.019]                           grepl <- base::grepl
[17:28:27.019]                           restarts <- computeRestarts(cond)
[17:28:27.019]                           for (restart in restarts) {
[17:28:27.019]                             name <- restart$name
[17:28:27.019]                             if (is.null(name)) 
[17:28:27.019]                               next
[17:28:27.019]                             if (!grepl(pattern, name)) 
[17:28:27.019]                               next
[17:28:27.019]                             invokeRestart(restart)
[17:28:27.019]                             muffled <- TRUE
[17:28:27.019]                             break
[17:28:27.019]                           }
[17:28:27.019]                         }
[17:28:27.019]                       }
[17:28:27.019]                       invisible(muffled)
[17:28:27.019]                     }
[17:28:27.019]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.019]                   }
[17:28:27.019]                 }
[17:28:27.019]             }
[17:28:27.019]         }))
[17:28:27.019]     }, error = function(ex) {
[17:28:27.019]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:27.019]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.019]                 ...future.rng), started = ...future.startTime, 
[17:28:27.019]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:27.019]             version = "1.8"), class = "FutureResult")
[17:28:27.019]     }, finally = {
[17:28:27.019]         if (!identical(...future.workdir, getwd())) 
[17:28:27.019]             setwd(...future.workdir)
[17:28:27.019]         {
[17:28:27.019]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:27.019]                 ...future.oldOptions$nwarnings <- NULL
[17:28:27.019]             }
[17:28:27.019]             base::options(...future.oldOptions)
[17:28:27.019]             if (.Platform$OS.type == "windows") {
[17:28:27.019]                 old_names <- names(...future.oldEnvVars)
[17:28:27.019]                 envs <- base::Sys.getenv()
[17:28:27.019]                 names <- names(envs)
[17:28:27.019]                 common <- intersect(names, old_names)
[17:28:27.019]                 added <- setdiff(names, old_names)
[17:28:27.019]                 removed <- setdiff(old_names, names)
[17:28:27.019]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:27.019]                   envs[common]]
[17:28:27.019]                 NAMES <- toupper(changed)
[17:28:27.019]                 args <- list()
[17:28:27.019]                 for (kk in seq_along(NAMES)) {
[17:28:27.019]                   name <- changed[[kk]]
[17:28:27.019]                   NAME <- NAMES[[kk]]
[17:28:27.019]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.019]                     next
[17:28:27.019]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.019]                 }
[17:28:27.019]                 NAMES <- toupper(added)
[17:28:27.019]                 for (kk in seq_along(NAMES)) {
[17:28:27.019]                   name <- added[[kk]]
[17:28:27.019]                   NAME <- NAMES[[kk]]
[17:28:27.019]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.019]                     next
[17:28:27.019]                   args[[name]] <- ""
[17:28:27.019]                 }
[17:28:27.019]                 NAMES <- toupper(removed)
[17:28:27.019]                 for (kk in seq_along(NAMES)) {
[17:28:27.019]                   name <- removed[[kk]]
[17:28:27.019]                   NAME <- NAMES[[kk]]
[17:28:27.019]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.019]                     next
[17:28:27.019]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.019]                 }
[17:28:27.019]                 if (length(args) > 0) 
[17:28:27.019]                   base::do.call(base::Sys.setenv, args = args)
[17:28:27.019]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:27.019]             }
[17:28:27.019]             else {
[17:28:27.019]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:27.019]             }
[17:28:27.019]             {
[17:28:27.019]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:27.019]                   0L) {
[17:28:27.019]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:27.019]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:27.019]                   base::options(opts)
[17:28:27.019]                 }
[17:28:27.019]                 {
[17:28:27.019]                   {
[17:28:27.019]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:27.019]                     NULL
[17:28:27.019]                   }
[17:28:27.019]                   options(future.plan = NULL)
[17:28:27.019]                   if (is.na(NA_character_)) 
[17:28:27.019]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.019]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:27.019]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:27.019]                     .init = FALSE)
[17:28:27.019]                 }
[17:28:27.019]             }
[17:28:27.019]         }
[17:28:27.019]     })
[17:28:27.019]     if (TRUE) {
[17:28:27.019]         base::sink(type = "output", split = FALSE)
[17:28:27.019]         if (TRUE) {
[17:28:27.019]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:27.019]         }
[17:28:27.019]         else {
[17:28:27.019]             ...future.result["stdout"] <- base::list(NULL)
[17:28:27.019]         }
[17:28:27.019]         base::close(...future.stdout)
[17:28:27.019]         ...future.stdout <- NULL
[17:28:27.019]     }
[17:28:27.019]     ...future.result$conditions <- ...future.conditions
[17:28:27.019]     ...future.result$finished <- base::Sys.time()
[17:28:27.019]     ...future.result
[17:28:27.019] }
[17:28:27.159] MultisessionFuture started
MultisessionFuture:
Label: '<none>'
Expression:
{
    42L
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[17:28:27.264] receiveMessageFromWorker() for ClusterFuture ...
[17:28:27.264] - Validating connection of MultisessionFuture
[17:28:27.265] - received message: FutureResult
[17:28:27.265] - Received FutureResult
[17:28:27.269] - Erased future from FutureRegistry
[17:28:27.270] result() for ClusterFuture ...
[17:28:27.270] - result already collected: FutureResult
[17:28:27.270] result() for ClusterFuture ... done
[17:28:27.271] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 12734a8a-480b-f2a5-0c96-45c13d81d854
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[1] TRUE
[17:28:27.271] result() for ClusterFuture ...
[17:28:27.271] - result already collected: FutureResult
[17:28:27.272] result() for ClusterFuture ... done
[17:28:27.272] result() for ClusterFuture ...
[17:28:27.272] - result already collected: FutureResult
[17:28:27.273] result() for ClusterFuture ... done
[1] 42
[17:28:27.277] getGlobalsAndPackages() ...
[17:28:27.277] Searching for globals...
[17:28:27.282] - globals found: [4] '{', '<-', '*', 'a'
[17:28:27.282] Searching for globals ... DONE
[17:28:27.283] Resolving globals: FALSE
[17:28:27.284] The total size of the 1 globals is 39 bytes (39 bytes)
[17:28:27.284] The total size of the 1 globals exported for future expression ('{; b <- 3; c <- 2; a * b * c; }') is 39 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'a' (39 bytes of class 'numeric')
[17:28:27.285] - globals: [1] 'a'
[17:28:27.285] 
[17:28:27.285] getGlobalsAndPackages() ... DONE
[17:28:27.302] Packages needed by the future expression (n = 0): <none>
[17:28:27.303] Packages needed by future strategies (n = 0): <none>
[17:28:27.304] {
[17:28:27.304]     {
[17:28:27.304]         {
[17:28:27.304]             ...future.startTime <- base::Sys.time()
[17:28:27.304]             {
[17:28:27.304]                 {
[17:28:27.304]                   {
[17:28:27.304]                     {
[17:28:27.304]                       base::local({
[17:28:27.304]                         has_future <- base::requireNamespace("future", 
[17:28:27.304]                           quietly = TRUE)
[17:28:27.304]                         if (has_future) {
[17:28:27.304]                           ns <- base::getNamespace("future")
[17:28:27.304]                           version <- ns[[".package"]][["version"]]
[17:28:27.304]                           if (is.null(version)) 
[17:28:27.304]                             version <- utils::packageVersion("future")
[17:28:27.304]                         }
[17:28:27.304]                         else {
[17:28:27.304]                           version <- NULL
[17:28:27.304]                         }
[17:28:27.304]                         if (!has_future || version < "1.8.0") {
[17:28:27.304]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:27.304]                             "", base::R.version$version.string), 
[17:28:27.304]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:27.304]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:27.304]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:27.304]                               "release", "version")], collapse = " "), 
[17:28:27.304]                             hostname = base::Sys.info()[["nodename"]])
[17:28:27.304]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:27.304]                             info)
[17:28:27.304]                           info <- base::paste(info, collapse = "; ")
[17:28:27.304]                           if (!has_future) {
[17:28:27.304]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:27.304]                               info)
[17:28:27.304]                           }
[17:28:27.304]                           else {
[17:28:27.304]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:27.304]                               info, version)
[17:28:27.304]                           }
[17:28:27.304]                           base::stop(msg)
[17:28:27.304]                         }
[17:28:27.304]                       })
[17:28:27.304]                     }
[17:28:27.304]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:27.304]                     base::options(mc.cores = 1L)
[17:28:27.304]                   }
[17:28:27.304]                   ...future.strategy.old <- future::plan("list")
[17:28:27.304]                   options(future.plan = NULL)
[17:28:27.304]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.304]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:27.304]                 }
[17:28:27.304]                 ...future.workdir <- getwd()
[17:28:27.304]             }
[17:28:27.304]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:27.304]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:27.304]         }
[17:28:27.304]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:27.304]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:27.304]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:27.304]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:27.304]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:27.304]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:27.304]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:27.304]             base::names(...future.oldOptions))
[17:28:27.304]     }
[17:28:27.304]     if (FALSE) {
[17:28:27.304]     }
[17:28:27.304]     else {
[17:28:27.304]         if (TRUE) {
[17:28:27.304]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:27.304]                 open = "w")
[17:28:27.304]         }
[17:28:27.304]         else {
[17:28:27.304]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:27.304]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:27.304]         }
[17:28:27.304]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:27.304]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:27.304]             base::sink(type = "output", split = FALSE)
[17:28:27.304]             base::close(...future.stdout)
[17:28:27.304]         }, add = TRUE)
[17:28:27.304]     }
[17:28:27.304]     ...future.frame <- base::sys.nframe()
[17:28:27.304]     ...future.conditions <- base::list()
[17:28:27.304]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:27.304]     if (FALSE) {
[17:28:27.304]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:27.304]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:27.304]     }
[17:28:27.304]     ...future.result <- base::tryCatch({
[17:28:27.304]         base::withCallingHandlers({
[17:28:27.304]             ...future.value <- base::withVisible(base::local({
[17:28:27.304]                 ...future.makeSendCondition <- base::local({
[17:28:27.304]                   sendCondition <- NULL
[17:28:27.304]                   function(frame = 1L) {
[17:28:27.304]                     if (is.function(sendCondition)) 
[17:28:27.304]                       return(sendCondition)
[17:28:27.304]                     ns <- getNamespace("parallel")
[17:28:27.304]                     if (exists("sendData", mode = "function", 
[17:28:27.304]                       envir = ns)) {
[17:28:27.304]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:27.304]                         envir = ns)
[17:28:27.304]                       envir <- sys.frame(frame)
[17:28:27.304]                       master <- NULL
[17:28:27.304]                       while (!identical(envir, .GlobalEnv) && 
[17:28:27.304]                         !identical(envir, emptyenv())) {
[17:28:27.304]                         if (exists("master", mode = "list", envir = envir, 
[17:28:27.304]                           inherits = FALSE)) {
[17:28:27.304]                           master <- get("master", mode = "list", 
[17:28:27.304]                             envir = envir, inherits = FALSE)
[17:28:27.304]                           if (inherits(master, c("SOCKnode", 
[17:28:27.304]                             "SOCK0node"))) {
[17:28:27.304]                             sendCondition <<- function(cond) {
[17:28:27.304]                               data <- list(type = "VALUE", value = cond, 
[17:28:27.304]                                 success = TRUE)
[17:28:27.304]                               parallel_sendData(master, data)
[17:28:27.304]                             }
[17:28:27.304]                             return(sendCondition)
[17:28:27.304]                           }
[17:28:27.304]                         }
[17:28:27.304]                         frame <- frame + 1L
[17:28:27.304]                         envir <- sys.frame(frame)
[17:28:27.304]                       }
[17:28:27.304]                     }
[17:28:27.304]                     sendCondition <<- function(cond) NULL
[17:28:27.304]                   }
[17:28:27.304]                 })
[17:28:27.304]                 withCallingHandlers({
[17:28:27.304]                   {
[17:28:27.304]                     b <- 3
[17:28:27.304]                     c <- 2
[17:28:27.304]                     a * b * c
[17:28:27.304]                   }
[17:28:27.304]                 }, immediateCondition = function(cond) {
[17:28:27.304]                   sendCondition <- ...future.makeSendCondition()
[17:28:27.304]                   sendCondition(cond)
[17:28:27.304]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.304]                   {
[17:28:27.304]                     inherits <- base::inherits
[17:28:27.304]                     invokeRestart <- base::invokeRestart
[17:28:27.304]                     is.null <- base::is.null
[17:28:27.304]                     muffled <- FALSE
[17:28:27.304]                     if (inherits(cond, "message")) {
[17:28:27.304]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:27.304]                       if (muffled) 
[17:28:27.304]                         invokeRestart("muffleMessage")
[17:28:27.304]                     }
[17:28:27.304]                     else if (inherits(cond, "warning")) {
[17:28:27.304]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:27.304]                       if (muffled) 
[17:28:27.304]                         invokeRestart("muffleWarning")
[17:28:27.304]                     }
[17:28:27.304]                     else if (inherits(cond, "condition")) {
[17:28:27.304]                       if (!is.null(pattern)) {
[17:28:27.304]                         computeRestarts <- base::computeRestarts
[17:28:27.304]                         grepl <- base::grepl
[17:28:27.304]                         restarts <- computeRestarts(cond)
[17:28:27.304]                         for (restart in restarts) {
[17:28:27.304]                           name <- restart$name
[17:28:27.304]                           if (is.null(name)) 
[17:28:27.304]                             next
[17:28:27.304]                           if (!grepl(pattern, name)) 
[17:28:27.304]                             next
[17:28:27.304]                           invokeRestart(restart)
[17:28:27.304]                           muffled <- TRUE
[17:28:27.304]                           break
[17:28:27.304]                         }
[17:28:27.304]                       }
[17:28:27.304]                     }
[17:28:27.304]                     invisible(muffled)
[17:28:27.304]                   }
[17:28:27.304]                   muffleCondition(cond)
[17:28:27.304]                 })
[17:28:27.304]             }))
[17:28:27.304]             future::FutureResult(value = ...future.value$value, 
[17:28:27.304]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.304]                   ...future.rng), globalenv = if (FALSE) 
[17:28:27.304]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:27.304]                     ...future.globalenv.names))
[17:28:27.304]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:27.304]         }, condition = base::local({
[17:28:27.304]             c <- base::c
[17:28:27.304]             inherits <- base::inherits
[17:28:27.304]             invokeRestart <- base::invokeRestart
[17:28:27.304]             length <- base::length
[17:28:27.304]             list <- base::list
[17:28:27.304]             seq.int <- base::seq.int
[17:28:27.304]             signalCondition <- base::signalCondition
[17:28:27.304]             sys.calls <- base::sys.calls
[17:28:27.304]             `[[` <- base::`[[`
[17:28:27.304]             `+` <- base::`+`
[17:28:27.304]             `<<-` <- base::`<<-`
[17:28:27.304]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:27.304]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:27.304]                   3L)]
[17:28:27.304]             }
[17:28:27.304]             function(cond) {
[17:28:27.304]                 is_error <- inherits(cond, "error")
[17:28:27.304]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:27.304]                   NULL)
[17:28:27.304]                 if (is_error) {
[17:28:27.304]                   sessionInformation <- function() {
[17:28:27.304]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:27.304]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:27.304]                       search = base::search(), system = base::Sys.info())
[17:28:27.304]                   }
[17:28:27.304]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.304]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:27.304]                     cond$call), session = sessionInformation(), 
[17:28:27.304]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:27.304]                   signalCondition(cond)
[17:28:27.304]                 }
[17:28:27.304]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:27.304]                 "immediateCondition"))) {
[17:28:27.304]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:27.304]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.304]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:27.304]                   if (TRUE && !signal) {
[17:28:27.304]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.304]                     {
[17:28:27.304]                       inherits <- base::inherits
[17:28:27.304]                       invokeRestart <- base::invokeRestart
[17:28:27.304]                       is.null <- base::is.null
[17:28:27.304]                       muffled <- FALSE
[17:28:27.304]                       if (inherits(cond, "message")) {
[17:28:27.304]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.304]                         if (muffled) 
[17:28:27.304]                           invokeRestart("muffleMessage")
[17:28:27.304]                       }
[17:28:27.304]                       else if (inherits(cond, "warning")) {
[17:28:27.304]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.304]                         if (muffled) 
[17:28:27.304]                           invokeRestart("muffleWarning")
[17:28:27.304]                       }
[17:28:27.304]                       else if (inherits(cond, "condition")) {
[17:28:27.304]                         if (!is.null(pattern)) {
[17:28:27.304]                           computeRestarts <- base::computeRestarts
[17:28:27.304]                           grepl <- base::grepl
[17:28:27.304]                           restarts <- computeRestarts(cond)
[17:28:27.304]                           for (restart in restarts) {
[17:28:27.304]                             name <- restart$name
[17:28:27.304]                             if (is.null(name)) 
[17:28:27.304]                               next
[17:28:27.304]                             if (!grepl(pattern, name)) 
[17:28:27.304]                               next
[17:28:27.304]                             invokeRestart(restart)
[17:28:27.304]                             muffled <- TRUE
[17:28:27.304]                             break
[17:28:27.304]                           }
[17:28:27.304]                         }
[17:28:27.304]                       }
[17:28:27.304]                       invisible(muffled)
[17:28:27.304]                     }
[17:28:27.304]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.304]                   }
[17:28:27.304]                 }
[17:28:27.304]                 else {
[17:28:27.304]                   if (TRUE) {
[17:28:27.304]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.304]                     {
[17:28:27.304]                       inherits <- base::inherits
[17:28:27.304]                       invokeRestart <- base::invokeRestart
[17:28:27.304]                       is.null <- base::is.null
[17:28:27.304]                       muffled <- FALSE
[17:28:27.304]                       if (inherits(cond, "message")) {
[17:28:27.304]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.304]                         if (muffled) 
[17:28:27.304]                           invokeRestart("muffleMessage")
[17:28:27.304]                       }
[17:28:27.304]                       else if (inherits(cond, "warning")) {
[17:28:27.304]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.304]                         if (muffled) 
[17:28:27.304]                           invokeRestart("muffleWarning")
[17:28:27.304]                       }
[17:28:27.304]                       else if (inherits(cond, "condition")) {
[17:28:27.304]                         if (!is.null(pattern)) {
[17:28:27.304]                           computeRestarts <- base::computeRestarts
[17:28:27.304]                           grepl <- base::grepl
[17:28:27.304]                           restarts <- computeRestarts(cond)
[17:28:27.304]                           for (restart in restarts) {
[17:28:27.304]                             name <- restart$name
[17:28:27.304]                             if (is.null(name)) 
[17:28:27.304]                               next
[17:28:27.304]                             if (!grepl(pattern, name)) 
[17:28:27.304]                               next
[17:28:27.304]                             invokeRestart(restart)
[17:28:27.304]                             muffled <- TRUE
[17:28:27.304]                             break
[17:28:27.304]                           }
[17:28:27.304]                         }
[17:28:27.304]                       }
[17:28:27.304]                       invisible(muffled)
[17:28:27.304]                     }
[17:28:27.304]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.304]                   }
[17:28:27.304]                 }
[17:28:27.304]             }
[17:28:27.304]         }))
[17:28:27.304]     }, error = function(ex) {
[17:28:27.304]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:27.304]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.304]                 ...future.rng), started = ...future.startTime, 
[17:28:27.304]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:27.304]             version = "1.8"), class = "FutureResult")
[17:28:27.304]     }, finally = {
[17:28:27.304]         if (!identical(...future.workdir, getwd())) 
[17:28:27.304]             setwd(...future.workdir)
[17:28:27.304]         {
[17:28:27.304]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:27.304]                 ...future.oldOptions$nwarnings <- NULL
[17:28:27.304]             }
[17:28:27.304]             base::options(...future.oldOptions)
[17:28:27.304]             if (.Platform$OS.type == "windows") {
[17:28:27.304]                 old_names <- names(...future.oldEnvVars)
[17:28:27.304]                 envs <- base::Sys.getenv()
[17:28:27.304]                 names <- names(envs)
[17:28:27.304]                 common <- intersect(names, old_names)
[17:28:27.304]                 added <- setdiff(names, old_names)
[17:28:27.304]                 removed <- setdiff(old_names, names)
[17:28:27.304]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:27.304]                   envs[common]]
[17:28:27.304]                 NAMES <- toupper(changed)
[17:28:27.304]                 args <- list()
[17:28:27.304]                 for (kk in seq_along(NAMES)) {
[17:28:27.304]                   name <- changed[[kk]]
[17:28:27.304]                   NAME <- NAMES[[kk]]
[17:28:27.304]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.304]                     next
[17:28:27.304]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.304]                 }
[17:28:27.304]                 NAMES <- toupper(added)
[17:28:27.304]                 for (kk in seq_along(NAMES)) {
[17:28:27.304]                   name <- added[[kk]]
[17:28:27.304]                   NAME <- NAMES[[kk]]
[17:28:27.304]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.304]                     next
[17:28:27.304]                   args[[name]] <- ""
[17:28:27.304]                 }
[17:28:27.304]                 NAMES <- toupper(removed)
[17:28:27.304]                 for (kk in seq_along(NAMES)) {
[17:28:27.304]                   name <- removed[[kk]]
[17:28:27.304]                   NAME <- NAMES[[kk]]
[17:28:27.304]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.304]                     next
[17:28:27.304]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.304]                 }
[17:28:27.304]                 if (length(args) > 0) 
[17:28:27.304]                   base::do.call(base::Sys.setenv, args = args)
[17:28:27.304]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:27.304]             }
[17:28:27.304]             else {
[17:28:27.304]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:27.304]             }
[17:28:27.304]             {
[17:28:27.304]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:27.304]                   0L) {
[17:28:27.304]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:27.304]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:27.304]                   base::options(opts)
[17:28:27.304]                 }
[17:28:27.304]                 {
[17:28:27.304]                   {
[17:28:27.304]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:27.304]                     NULL
[17:28:27.304]                   }
[17:28:27.304]                   options(future.plan = NULL)
[17:28:27.304]                   if (is.na(NA_character_)) 
[17:28:27.304]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.304]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:27.304]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:27.304]                     .init = FALSE)
[17:28:27.304]                 }
[17:28:27.304]             }
[17:28:27.304]         }
[17:28:27.304]     })
[17:28:27.304]     if (TRUE) {
[17:28:27.304]         base::sink(type = "output", split = FALSE)
[17:28:27.304]         if (TRUE) {
[17:28:27.304]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:27.304]         }
[17:28:27.304]         else {
[17:28:27.304]             ...future.result["stdout"] <- base::list(NULL)
[17:28:27.304]         }
[17:28:27.304]         base::close(...future.stdout)
[17:28:27.304]         ...future.stdout <- NULL
[17:28:27.304]     }
[17:28:27.304]     ...future.result$conditions <- ...future.conditions
[17:28:27.304]     ...future.result$finished <- base::Sys.time()
[17:28:27.304]     ...future.result
[17:28:27.304] }
[17:28:27.313] Exporting 1 global objects (302 bytes) to cluster node #1 ...
[17:28:27.313] Exporting 'a' (39 bytes) to cluster node #1 ...
[17:28:27.314] Exporting 'a' (39 bytes) to cluster node #1 ... DONE
[17:28:27.315] Exporting 1 global objects (302 bytes) to cluster node #1 ... DONE
[17:28:27.317] MultisessionFuture started
MultisessionFuture:
Label: '<none>'
Expression:
{
    b <- 3
    c <- 2
    a * b * c
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 39 bytes (numeric 'a' of 39 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[17:28:27.350] receiveMessageFromWorker() for ClusterFuture ...
[17:28:27.351] - Validating connection of MultisessionFuture
[17:28:27.351] - received message: FutureResult
[17:28:27.352] - Received FutureResult
[17:28:27.352] - Erased future from FutureRegistry
[17:28:27.353] result() for ClusterFuture ...
[17:28:27.353] - result already collected: FutureResult
[17:28:27.353] result() for ClusterFuture ... done
[17:28:27.354] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 12734a8a-480b-f2a5-0c96-45c13d81d854
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:27.354] result() for ClusterFuture ...
[17:28:27.354] - result already collected: FutureResult
[17:28:27.355] result() for ClusterFuture ... done
[17:28:27.355] result() for ClusterFuture ...
[17:28:27.355] - result already collected: FutureResult
[17:28:27.356] result() for ClusterFuture ... done
[1] 0
*** multisession() with globals and blocking
 - Creating multisession future #2 ...
[17:28:27.361] getGlobalsAndPackages() ...
[17:28:27.362] Searching for globals...
[17:28:27.364] - globals found: [2] '{', 'ii'
[17:28:27.364] Searching for globals ... DONE
[17:28:27.365] Resolving globals: FALSE
[17:28:27.366] The total size of the 1 globals is 35 bytes (35 bytes)
[17:28:27.367] The total size of the 1 globals exported for future expression ('{; ii; }') is 35 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'ii' (35 bytes of class 'numeric')
[17:28:27.367] - globals: [1] 'ii'
[17:28:27.368] 
[17:28:27.368] getGlobalsAndPackages() ... DONE
[17:28:27.389] Packages needed by the future expression (n = 0): <none>
[17:28:27.390] Packages needed by future strategies (n = 0): <none>
[17:28:27.391] {
[17:28:27.391]     {
[17:28:27.391]         {
[17:28:27.391]             ...future.startTime <- base::Sys.time()
[17:28:27.391]             {
[17:28:27.391]                 {
[17:28:27.391]                   {
[17:28:27.391]                     {
[17:28:27.391]                       base::local({
[17:28:27.391]                         has_future <- base::requireNamespace("future", 
[17:28:27.391]                           quietly = TRUE)
[17:28:27.391]                         if (has_future) {
[17:28:27.391]                           ns <- base::getNamespace("future")
[17:28:27.391]                           version <- ns[[".package"]][["version"]]
[17:28:27.391]                           if (is.null(version)) 
[17:28:27.391]                             version <- utils::packageVersion("future")
[17:28:27.391]                         }
[17:28:27.391]                         else {
[17:28:27.391]                           version <- NULL
[17:28:27.391]                         }
[17:28:27.391]                         if (!has_future || version < "1.8.0") {
[17:28:27.391]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:27.391]                             "", base::R.version$version.string), 
[17:28:27.391]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:27.391]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:27.391]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:27.391]                               "release", "version")], collapse = " "), 
[17:28:27.391]                             hostname = base::Sys.info()[["nodename"]])
[17:28:27.391]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:27.391]                             info)
[17:28:27.391]                           info <- base::paste(info, collapse = "; ")
[17:28:27.391]                           if (!has_future) {
[17:28:27.391]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:27.391]                               info)
[17:28:27.391]                           }
[17:28:27.391]                           else {
[17:28:27.391]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:27.391]                               info, version)
[17:28:27.391]                           }
[17:28:27.391]                           base::stop(msg)
[17:28:27.391]                         }
[17:28:27.391]                       })
[17:28:27.391]                     }
[17:28:27.391]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:27.391]                     base::options(mc.cores = 1L)
[17:28:27.391]                   }
[17:28:27.391]                   ...future.strategy.old <- future::plan("list")
[17:28:27.391]                   options(future.plan = NULL)
[17:28:27.391]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.391]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:27.391]                 }
[17:28:27.391]                 ...future.workdir <- getwd()
[17:28:27.391]             }
[17:28:27.391]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:27.391]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:27.391]         }
[17:28:27.391]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:27.391]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:27.391]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:27.391]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:27.391]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:27.391]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:27.391]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:27.391]             base::names(...future.oldOptions))
[17:28:27.391]     }
[17:28:27.391]     if (FALSE) {
[17:28:27.391]     }
[17:28:27.391]     else {
[17:28:27.391]         if (TRUE) {
[17:28:27.391]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:27.391]                 open = "w")
[17:28:27.391]         }
[17:28:27.391]         else {
[17:28:27.391]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:27.391]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:27.391]         }
[17:28:27.391]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:27.391]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:27.391]             base::sink(type = "output", split = FALSE)
[17:28:27.391]             base::close(...future.stdout)
[17:28:27.391]         }, add = TRUE)
[17:28:27.391]     }
[17:28:27.391]     ...future.frame <- base::sys.nframe()
[17:28:27.391]     ...future.conditions <- base::list()
[17:28:27.391]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:27.391]     if (FALSE) {
[17:28:27.391]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:27.391]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:27.391]     }
[17:28:27.391]     ...future.result <- base::tryCatch({
[17:28:27.391]         base::withCallingHandlers({
[17:28:27.391]             ...future.value <- base::withVisible(base::local({
[17:28:27.391]                 ...future.makeSendCondition <- base::local({
[17:28:27.391]                   sendCondition <- NULL
[17:28:27.391]                   function(frame = 1L) {
[17:28:27.391]                     if (is.function(sendCondition)) 
[17:28:27.391]                       return(sendCondition)
[17:28:27.391]                     ns <- getNamespace("parallel")
[17:28:27.391]                     if (exists("sendData", mode = "function", 
[17:28:27.391]                       envir = ns)) {
[17:28:27.391]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:27.391]                         envir = ns)
[17:28:27.391]                       envir <- sys.frame(frame)
[17:28:27.391]                       master <- NULL
[17:28:27.391]                       while (!identical(envir, .GlobalEnv) && 
[17:28:27.391]                         !identical(envir, emptyenv())) {
[17:28:27.391]                         if (exists("master", mode = "list", envir = envir, 
[17:28:27.391]                           inherits = FALSE)) {
[17:28:27.391]                           master <- get("master", mode = "list", 
[17:28:27.391]                             envir = envir, inherits = FALSE)
[17:28:27.391]                           if (inherits(master, c("SOCKnode", 
[17:28:27.391]                             "SOCK0node"))) {
[17:28:27.391]                             sendCondition <<- function(cond) {
[17:28:27.391]                               data <- list(type = "VALUE", value = cond, 
[17:28:27.391]                                 success = TRUE)
[17:28:27.391]                               parallel_sendData(master, data)
[17:28:27.391]                             }
[17:28:27.391]                             return(sendCondition)
[17:28:27.391]                           }
[17:28:27.391]                         }
[17:28:27.391]                         frame <- frame + 1L
[17:28:27.391]                         envir <- sys.frame(frame)
[17:28:27.391]                       }
[17:28:27.391]                     }
[17:28:27.391]                     sendCondition <<- function(cond) NULL
[17:28:27.391]                   }
[17:28:27.391]                 })
[17:28:27.391]                 withCallingHandlers({
[17:28:27.391]                   {
[17:28:27.391]                     ii
[17:28:27.391]                   }
[17:28:27.391]                 }, immediateCondition = function(cond) {
[17:28:27.391]                   sendCondition <- ...future.makeSendCondition()
[17:28:27.391]                   sendCondition(cond)
[17:28:27.391]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.391]                   {
[17:28:27.391]                     inherits <- base::inherits
[17:28:27.391]                     invokeRestart <- base::invokeRestart
[17:28:27.391]                     is.null <- base::is.null
[17:28:27.391]                     muffled <- FALSE
[17:28:27.391]                     if (inherits(cond, "message")) {
[17:28:27.391]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:27.391]                       if (muffled) 
[17:28:27.391]                         invokeRestart("muffleMessage")
[17:28:27.391]                     }
[17:28:27.391]                     else if (inherits(cond, "warning")) {
[17:28:27.391]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:27.391]                       if (muffled) 
[17:28:27.391]                         invokeRestart("muffleWarning")
[17:28:27.391]                     }
[17:28:27.391]                     else if (inherits(cond, "condition")) {
[17:28:27.391]                       if (!is.null(pattern)) {
[17:28:27.391]                         computeRestarts <- base::computeRestarts
[17:28:27.391]                         grepl <- base::grepl
[17:28:27.391]                         restarts <- computeRestarts(cond)
[17:28:27.391]                         for (restart in restarts) {
[17:28:27.391]                           name <- restart$name
[17:28:27.391]                           if (is.null(name)) 
[17:28:27.391]                             next
[17:28:27.391]                           if (!grepl(pattern, name)) 
[17:28:27.391]                             next
[17:28:27.391]                           invokeRestart(restart)
[17:28:27.391]                           muffled <- TRUE
[17:28:27.391]                           break
[17:28:27.391]                         }
[17:28:27.391]                       }
[17:28:27.391]                     }
[17:28:27.391]                     invisible(muffled)
[17:28:27.391]                   }
[17:28:27.391]                   muffleCondition(cond)
[17:28:27.391]                 })
[17:28:27.391]             }))
[17:28:27.391]             future::FutureResult(value = ...future.value$value, 
[17:28:27.391]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.391]                   ...future.rng), globalenv = if (FALSE) 
[17:28:27.391]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:27.391]                     ...future.globalenv.names))
[17:28:27.391]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:27.391]         }, condition = base::local({
[17:28:27.391]             c <- base::c
[17:28:27.391]             inherits <- base::inherits
[17:28:27.391]             invokeRestart <- base::invokeRestart
[17:28:27.391]             length <- base::length
[17:28:27.391]             list <- base::list
[17:28:27.391]             seq.int <- base::seq.int
[17:28:27.391]             signalCondition <- base::signalCondition
[17:28:27.391]             sys.calls <- base::sys.calls
[17:28:27.391]             `[[` <- base::`[[`
[17:28:27.391]             `+` <- base::`+`
[17:28:27.391]             `<<-` <- base::`<<-`
[17:28:27.391]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:27.391]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:27.391]                   3L)]
[17:28:27.391]             }
[17:28:27.391]             function(cond) {
[17:28:27.391]                 is_error <- inherits(cond, "error")
[17:28:27.391]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:27.391]                   NULL)
[17:28:27.391]                 if (is_error) {
[17:28:27.391]                   sessionInformation <- function() {
[17:28:27.391]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:27.391]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:27.391]                       search = base::search(), system = base::Sys.info())
[17:28:27.391]                   }
[17:28:27.391]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.391]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:27.391]                     cond$call), session = sessionInformation(), 
[17:28:27.391]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:27.391]                   signalCondition(cond)
[17:28:27.391]                 }
[17:28:27.391]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:27.391]                 "immediateCondition"))) {
[17:28:27.391]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:27.391]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.391]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:27.391]                   if (TRUE && !signal) {
[17:28:27.391]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.391]                     {
[17:28:27.391]                       inherits <- base::inherits
[17:28:27.391]                       invokeRestart <- base::invokeRestart
[17:28:27.391]                       is.null <- base::is.null
[17:28:27.391]                       muffled <- FALSE
[17:28:27.391]                       if (inherits(cond, "message")) {
[17:28:27.391]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.391]                         if (muffled) 
[17:28:27.391]                           invokeRestart("muffleMessage")
[17:28:27.391]                       }
[17:28:27.391]                       else if (inherits(cond, "warning")) {
[17:28:27.391]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.391]                         if (muffled) 
[17:28:27.391]                           invokeRestart("muffleWarning")
[17:28:27.391]                       }
[17:28:27.391]                       else if (inherits(cond, "condition")) {
[17:28:27.391]                         if (!is.null(pattern)) {
[17:28:27.391]                           computeRestarts <- base::computeRestarts
[17:28:27.391]                           grepl <- base::grepl
[17:28:27.391]                           restarts <- computeRestarts(cond)
[17:28:27.391]                           for (restart in restarts) {
[17:28:27.391]                             name <- restart$name
[17:28:27.391]                             if (is.null(name)) 
[17:28:27.391]                               next
[17:28:27.391]                             if (!grepl(pattern, name)) 
[17:28:27.391]                               next
[17:28:27.391]                             invokeRestart(restart)
[17:28:27.391]                             muffled <- TRUE
[17:28:27.391]                             break
[17:28:27.391]                           }
[17:28:27.391]                         }
[17:28:27.391]                       }
[17:28:27.391]                       invisible(muffled)
[17:28:27.391]                     }
[17:28:27.391]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.391]                   }
[17:28:27.391]                 }
[17:28:27.391]                 else {
[17:28:27.391]                   if (TRUE) {
[17:28:27.391]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.391]                     {
[17:28:27.391]                       inherits <- base::inherits
[17:28:27.391]                       invokeRestart <- base::invokeRestart
[17:28:27.391]                       is.null <- base::is.null
[17:28:27.391]                       muffled <- FALSE
[17:28:27.391]                       if (inherits(cond, "message")) {
[17:28:27.391]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.391]                         if (muffled) 
[17:28:27.391]                           invokeRestart("muffleMessage")
[17:28:27.391]                       }
[17:28:27.391]                       else if (inherits(cond, "warning")) {
[17:28:27.391]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.391]                         if (muffled) 
[17:28:27.391]                           invokeRestart("muffleWarning")
[17:28:27.391]                       }
[17:28:27.391]                       else if (inherits(cond, "condition")) {
[17:28:27.391]                         if (!is.null(pattern)) {
[17:28:27.391]                           computeRestarts <- base::computeRestarts
[17:28:27.391]                           grepl <- base::grepl
[17:28:27.391]                           restarts <- computeRestarts(cond)
[17:28:27.391]                           for (restart in restarts) {
[17:28:27.391]                             name <- restart$name
[17:28:27.391]                             if (is.null(name)) 
[17:28:27.391]                               next
[17:28:27.391]                             if (!grepl(pattern, name)) 
[17:28:27.391]                               next
[17:28:27.391]                             invokeRestart(restart)
[17:28:27.391]                             muffled <- TRUE
[17:28:27.391]                             break
[17:28:27.391]                           }
[17:28:27.391]                         }
[17:28:27.391]                       }
[17:28:27.391]                       invisible(muffled)
[17:28:27.391]                     }
[17:28:27.391]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.391]                   }
[17:28:27.391]                 }
[17:28:27.391]             }
[17:28:27.391]         }))
[17:28:27.391]     }, error = function(ex) {
[17:28:27.391]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:27.391]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.391]                 ...future.rng), started = ...future.startTime, 
[17:28:27.391]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:27.391]             version = "1.8"), class = "FutureResult")
[17:28:27.391]     }, finally = {
[17:28:27.391]         if (!identical(...future.workdir, getwd())) 
[17:28:27.391]             setwd(...future.workdir)
[17:28:27.391]         {
[17:28:27.391]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:27.391]                 ...future.oldOptions$nwarnings <- NULL
[17:28:27.391]             }
[17:28:27.391]             base::options(...future.oldOptions)
[17:28:27.391]             if (.Platform$OS.type == "windows") {
[17:28:27.391]                 old_names <- names(...future.oldEnvVars)
[17:28:27.391]                 envs <- base::Sys.getenv()
[17:28:27.391]                 names <- names(envs)
[17:28:27.391]                 common <- intersect(names, old_names)
[17:28:27.391]                 added <- setdiff(names, old_names)
[17:28:27.391]                 removed <- setdiff(old_names, names)
[17:28:27.391]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:27.391]                   envs[common]]
[17:28:27.391]                 NAMES <- toupper(changed)
[17:28:27.391]                 args <- list()
[17:28:27.391]                 for (kk in seq_along(NAMES)) {
[17:28:27.391]                   name <- changed[[kk]]
[17:28:27.391]                   NAME <- NAMES[[kk]]
[17:28:27.391]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.391]                     next
[17:28:27.391]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.391]                 }
[17:28:27.391]                 NAMES <- toupper(added)
[17:28:27.391]                 for (kk in seq_along(NAMES)) {
[17:28:27.391]                   name <- added[[kk]]
[17:28:27.391]                   NAME <- NAMES[[kk]]
[17:28:27.391]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.391]                     next
[17:28:27.391]                   args[[name]] <- ""
[17:28:27.391]                 }
[17:28:27.391]                 NAMES <- toupper(removed)
[17:28:27.391]                 for (kk in seq_along(NAMES)) {
[17:28:27.391]                   name <- removed[[kk]]
[17:28:27.391]                   NAME <- NAMES[[kk]]
[17:28:27.391]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.391]                     next
[17:28:27.391]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.391]                 }
[17:28:27.391]                 if (length(args) > 0) 
[17:28:27.391]                   base::do.call(base::Sys.setenv, args = args)
[17:28:27.391]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:27.391]             }
[17:28:27.391]             else {
[17:28:27.391]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:27.391]             }
[17:28:27.391]             {
[17:28:27.391]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:27.391]                   0L) {
[17:28:27.391]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:27.391]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:27.391]                   base::options(opts)
[17:28:27.391]                 }
[17:28:27.391]                 {
[17:28:27.391]                   {
[17:28:27.391]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:27.391]                     NULL
[17:28:27.391]                   }
[17:28:27.391]                   options(future.plan = NULL)
[17:28:27.391]                   if (is.na(NA_character_)) 
[17:28:27.391]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.391]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:27.391]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:27.391]                     .init = FALSE)
[17:28:27.391]                 }
[17:28:27.391]             }
[17:28:27.391]         }
[17:28:27.391]     })
[17:28:27.391]     if (TRUE) {
[17:28:27.391]         base::sink(type = "output", split = FALSE)
[17:28:27.391]         if (TRUE) {
[17:28:27.391]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:27.391]         }
[17:28:27.391]         else {
[17:28:27.391]             ...future.result["stdout"] <- base::list(NULL)
[17:28:27.391]         }
[17:28:27.391]         base::close(...future.stdout)
[17:28:27.391]         ...future.stdout <- NULL
[17:28:27.391]     }
[17:28:27.391]     ...future.result$conditions <- ...future.conditions
[17:28:27.391]     ...future.result$finished <- base::Sys.time()
[17:28:27.391]     ...future.result
[17:28:27.391] }
[17:28:27.398] Exporting 1 global objects (300 bytes) to cluster node #1 ...
[17:28:27.399] Exporting 'ii' (35 bytes) to cluster node #1 ...
[17:28:27.400] Exporting 'ii' (35 bytes) to cluster node #1 ... DONE
[17:28:27.400] Exporting 1 global objects (300 bytes) to cluster node #1 ... DONE
[17:28:27.401] MultisessionFuture started
 - Creating multisession future #1 ...
[17:28:27.406] getGlobalsAndPackages() ...
[17:28:27.406] Searching for globals...
[17:28:27.408] - globals found: [2] '{', 'ii'
[17:28:27.408] Searching for globals ... DONE
[17:28:27.408] Resolving globals: FALSE
[17:28:27.409] The total size of the 1 globals is 35 bytes (35 bytes)
[17:28:27.410] The total size of the 1 globals exported for future expression ('{; ii; }') is 35 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'ii' (35 bytes of class 'numeric')
[17:28:27.411] - globals: [1] 'ii'
[17:28:27.411] 
[17:28:27.411] getGlobalsAndPackages() ... DONE
[17:28:27.429] Packages needed by the future expression (n = 0): <none>
[17:28:27.429] Packages needed by future strategies (n = 0): <none>
[17:28:27.430] {
[17:28:27.430]     {
[17:28:27.430]         {
[17:28:27.430]             ...future.startTime <- base::Sys.time()
[17:28:27.430]             {
[17:28:27.430]                 {
[17:28:27.430]                   {
[17:28:27.430]                     {
[17:28:27.430]                       base::local({
[17:28:27.430]                         has_future <- base::requireNamespace("future", 
[17:28:27.430]                           quietly = TRUE)
[17:28:27.430]                         if (has_future) {
[17:28:27.430]                           ns <- base::getNamespace("future")
[17:28:27.430]                           version <- ns[[".package"]][["version"]]
[17:28:27.430]                           if (is.null(version)) 
[17:28:27.430]                             version <- utils::packageVersion("future")
[17:28:27.430]                         }
[17:28:27.430]                         else {
[17:28:27.430]                           version <- NULL
[17:28:27.430]                         }
[17:28:27.430]                         if (!has_future || version < "1.8.0") {
[17:28:27.430]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:27.430]                             "", base::R.version$version.string), 
[17:28:27.430]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:27.430]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:27.430]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:27.430]                               "release", "version")], collapse = " "), 
[17:28:27.430]                             hostname = base::Sys.info()[["nodename"]])
[17:28:27.430]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:27.430]                             info)
[17:28:27.430]                           info <- base::paste(info, collapse = "; ")
[17:28:27.430]                           if (!has_future) {
[17:28:27.430]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:27.430]                               info)
[17:28:27.430]                           }
[17:28:27.430]                           else {
[17:28:27.430]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:27.430]                               info, version)
[17:28:27.430]                           }
[17:28:27.430]                           base::stop(msg)
[17:28:27.430]                         }
[17:28:27.430]                       })
[17:28:27.430]                     }
[17:28:27.430]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:27.430]                     base::options(mc.cores = 1L)
[17:28:27.430]                   }
[17:28:27.430]                   ...future.strategy.old <- future::plan("list")
[17:28:27.430]                   options(future.plan = NULL)
[17:28:27.430]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.430]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:27.430]                 }
[17:28:27.430]                 ...future.workdir <- getwd()
[17:28:27.430]             }
[17:28:27.430]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:27.430]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:27.430]         }
[17:28:27.430]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:27.430]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:27.430]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:27.430]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:27.430]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:27.430]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:27.430]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:27.430]             base::names(...future.oldOptions))
[17:28:27.430]     }
[17:28:27.430]     if (FALSE) {
[17:28:27.430]     }
[17:28:27.430]     else {
[17:28:27.430]         if (TRUE) {
[17:28:27.430]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:27.430]                 open = "w")
[17:28:27.430]         }
[17:28:27.430]         else {
[17:28:27.430]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:27.430]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:27.430]         }
[17:28:27.430]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:27.430]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:27.430]             base::sink(type = "output", split = FALSE)
[17:28:27.430]             base::close(...future.stdout)
[17:28:27.430]         }, add = TRUE)
[17:28:27.430]     }
[17:28:27.430]     ...future.frame <- base::sys.nframe()
[17:28:27.430]     ...future.conditions <- base::list()
[17:28:27.430]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:27.430]     if (FALSE) {
[17:28:27.430]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:27.430]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:27.430]     }
[17:28:27.430]     ...future.result <- base::tryCatch({
[17:28:27.430]         base::withCallingHandlers({
[17:28:27.430]             ...future.value <- base::withVisible(base::local({
[17:28:27.430]                 ...future.makeSendCondition <- base::local({
[17:28:27.430]                   sendCondition <- NULL
[17:28:27.430]                   function(frame = 1L) {
[17:28:27.430]                     if (is.function(sendCondition)) 
[17:28:27.430]                       return(sendCondition)
[17:28:27.430]                     ns <- getNamespace("parallel")
[17:28:27.430]                     if (exists("sendData", mode = "function", 
[17:28:27.430]                       envir = ns)) {
[17:28:27.430]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:27.430]                         envir = ns)
[17:28:27.430]                       envir <- sys.frame(frame)
[17:28:27.430]                       master <- NULL
[17:28:27.430]                       while (!identical(envir, .GlobalEnv) && 
[17:28:27.430]                         !identical(envir, emptyenv())) {
[17:28:27.430]                         if (exists("master", mode = "list", envir = envir, 
[17:28:27.430]                           inherits = FALSE)) {
[17:28:27.430]                           master <- get("master", mode = "list", 
[17:28:27.430]                             envir = envir, inherits = FALSE)
[17:28:27.430]                           if (inherits(master, c("SOCKnode", 
[17:28:27.430]                             "SOCK0node"))) {
[17:28:27.430]                             sendCondition <<- function(cond) {
[17:28:27.430]                               data <- list(type = "VALUE", value = cond, 
[17:28:27.430]                                 success = TRUE)
[17:28:27.430]                               parallel_sendData(master, data)
[17:28:27.430]                             }
[17:28:27.430]                             return(sendCondition)
[17:28:27.430]                           }
[17:28:27.430]                         }
[17:28:27.430]                         frame <- frame + 1L
[17:28:27.430]                         envir <- sys.frame(frame)
[17:28:27.430]                       }
[17:28:27.430]                     }
[17:28:27.430]                     sendCondition <<- function(cond) NULL
[17:28:27.430]                   }
[17:28:27.430]                 })
[17:28:27.430]                 withCallingHandlers({
[17:28:27.430]                   {
[17:28:27.430]                     ii
[17:28:27.430]                   }
[17:28:27.430]                 }, immediateCondition = function(cond) {
[17:28:27.430]                   sendCondition <- ...future.makeSendCondition()
[17:28:27.430]                   sendCondition(cond)
[17:28:27.430]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.430]                   {
[17:28:27.430]                     inherits <- base::inherits
[17:28:27.430]                     invokeRestart <- base::invokeRestart
[17:28:27.430]                     is.null <- base::is.null
[17:28:27.430]                     muffled <- FALSE
[17:28:27.430]                     if (inherits(cond, "message")) {
[17:28:27.430]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:27.430]                       if (muffled) 
[17:28:27.430]                         invokeRestart("muffleMessage")
[17:28:27.430]                     }
[17:28:27.430]                     else if (inherits(cond, "warning")) {
[17:28:27.430]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:27.430]                       if (muffled) 
[17:28:27.430]                         invokeRestart("muffleWarning")
[17:28:27.430]                     }
[17:28:27.430]                     else if (inherits(cond, "condition")) {
[17:28:27.430]                       if (!is.null(pattern)) {
[17:28:27.430]                         computeRestarts <- base::computeRestarts
[17:28:27.430]                         grepl <- base::grepl
[17:28:27.430]                         restarts <- computeRestarts(cond)
[17:28:27.430]                         for (restart in restarts) {
[17:28:27.430]                           name <- restart$name
[17:28:27.430]                           if (is.null(name)) 
[17:28:27.430]                             next
[17:28:27.430]                           if (!grepl(pattern, name)) 
[17:28:27.430]                             next
[17:28:27.430]                           invokeRestart(restart)
[17:28:27.430]                           muffled <- TRUE
[17:28:27.430]                           break
[17:28:27.430]                         }
[17:28:27.430]                       }
[17:28:27.430]                     }
[17:28:27.430]                     invisible(muffled)
[17:28:27.430]                   }
[17:28:27.430]                   muffleCondition(cond)
[17:28:27.430]                 })
[17:28:27.430]             }))
[17:28:27.430]             future::FutureResult(value = ...future.value$value, 
[17:28:27.430]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.430]                   ...future.rng), globalenv = if (FALSE) 
[17:28:27.430]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:27.430]                     ...future.globalenv.names))
[17:28:27.430]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:27.430]         }, condition = base::local({
[17:28:27.430]             c <- base::c
[17:28:27.430]             inherits <- base::inherits
[17:28:27.430]             invokeRestart <- base::invokeRestart
[17:28:27.430]             length <- base::length
[17:28:27.430]             list <- base::list
[17:28:27.430]             seq.int <- base::seq.int
[17:28:27.430]             signalCondition <- base::signalCondition
[17:28:27.430]             sys.calls <- base::sys.calls
[17:28:27.430]             `[[` <- base::`[[`
[17:28:27.430]             `+` <- base::`+`
[17:28:27.430]             `<<-` <- base::`<<-`
[17:28:27.430]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:27.430]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:27.430]                   3L)]
[17:28:27.430]             }
[17:28:27.430]             function(cond) {
[17:28:27.430]                 is_error <- inherits(cond, "error")
[17:28:27.430]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:27.430]                   NULL)
[17:28:27.430]                 if (is_error) {
[17:28:27.430]                   sessionInformation <- function() {
[17:28:27.430]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:27.430]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:27.430]                       search = base::search(), system = base::Sys.info())
[17:28:27.430]                   }
[17:28:27.430]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.430]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:27.430]                     cond$call), session = sessionInformation(), 
[17:28:27.430]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:27.430]                   signalCondition(cond)
[17:28:27.430]                 }
[17:28:27.430]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:27.430]                 "immediateCondition"))) {
[17:28:27.430]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:27.430]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.430]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:27.430]                   if (TRUE && !signal) {
[17:28:27.430]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.430]                     {
[17:28:27.430]                       inherits <- base::inherits
[17:28:27.430]                       invokeRestart <- base::invokeRestart
[17:28:27.430]                       is.null <- base::is.null
[17:28:27.430]                       muffled <- FALSE
[17:28:27.430]                       if (inherits(cond, "message")) {
[17:28:27.430]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.430]                         if (muffled) 
[17:28:27.430]                           invokeRestart("muffleMessage")
[17:28:27.430]                       }
[17:28:27.430]                       else if (inherits(cond, "warning")) {
[17:28:27.430]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.430]                         if (muffled) 
[17:28:27.430]                           invokeRestart("muffleWarning")
[17:28:27.430]                       }
[17:28:27.430]                       else if (inherits(cond, "condition")) {
[17:28:27.430]                         if (!is.null(pattern)) {
[17:28:27.430]                           computeRestarts <- base::computeRestarts
[17:28:27.430]                           grepl <- base::grepl
[17:28:27.430]                           restarts <- computeRestarts(cond)
[17:28:27.430]                           for (restart in restarts) {
[17:28:27.430]                             name <- restart$name
[17:28:27.430]                             if (is.null(name)) 
[17:28:27.430]                               next
[17:28:27.430]                             if (!grepl(pattern, name)) 
[17:28:27.430]                               next
[17:28:27.430]                             invokeRestart(restart)
[17:28:27.430]                             muffled <- TRUE
[17:28:27.430]                             break
[17:28:27.430]                           }
[17:28:27.430]                         }
[17:28:27.430]                       }
[17:28:27.430]                       invisible(muffled)
[17:28:27.430]                     }
[17:28:27.430]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.430]                   }
[17:28:27.430]                 }
[17:28:27.430]                 else {
[17:28:27.430]                   if (TRUE) {
[17:28:27.430]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.430]                     {
[17:28:27.430]                       inherits <- base::inherits
[17:28:27.430]                       invokeRestart <- base::invokeRestart
[17:28:27.430]                       is.null <- base::is.null
[17:28:27.430]                       muffled <- FALSE
[17:28:27.430]                       if (inherits(cond, "message")) {
[17:28:27.430]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.430]                         if (muffled) 
[17:28:27.430]                           invokeRestart("muffleMessage")
[17:28:27.430]                       }
[17:28:27.430]                       else if (inherits(cond, "warning")) {
[17:28:27.430]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.430]                         if (muffled) 
[17:28:27.430]                           invokeRestart("muffleWarning")
[17:28:27.430]                       }
[17:28:27.430]                       else if (inherits(cond, "condition")) {
[17:28:27.430]                         if (!is.null(pattern)) {
[17:28:27.430]                           computeRestarts <- base::computeRestarts
[17:28:27.430]                           grepl <- base::grepl
[17:28:27.430]                           restarts <- computeRestarts(cond)
[17:28:27.430]                           for (restart in restarts) {
[17:28:27.430]                             name <- restart$name
[17:28:27.430]                             if (is.null(name)) 
[17:28:27.430]                               next
[17:28:27.430]                             if (!grepl(pattern, name)) 
[17:28:27.430]                               next
[17:28:27.430]                             invokeRestart(restart)
[17:28:27.430]                             muffled <- TRUE
[17:28:27.430]                             break
[17:28:27.430]                           }
[17:28:27.430]                         }
[17:28:27.430]                       }
[17:28:27.430]                       invisible(muffled)
[17:28:27.430]                     }
[17:28:27.430]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.430]                   }
[17:28:27.430]                 }
[17:28:27.430]             }
[17:28:27.430]         }))
[17:28:27.430]     }, error = function(ex) {
[17:28:27.430]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:27.430]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.430]                 ...future.rng), started = ...future.startTime, 
[17:28:27.430]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:27.430]             version = "1.8"), class = "FutureResult")
[17:28:27.430]     }, finally = {
[17:28:27.430]         if (!identical(...future.workdir, getwd())) 
[17:28:27.430]             setwd(...future.workdir)
[17:28:27.430]         {
[17:28:27.430]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:27.430]                 ...future.oldOptions$nwarnings <- NULL
[17:28:27.430]             }
[17:28:27.430]             base::options(...future.oldOptions)
[17:28:27.430]             if (.Platform$OS.type == "windows") {
[17:28:27.430]                 old_names <- names(...future.oldEnvVars)
[17:28:27.430]                 envs <- base::Sys.getenv()
[17:28:27.430]                 names <- names(envs)
[17:28:27.430]                 common <- intersect(names, old_names)
[17:28:27.430]                 added <- setdiff(names, old_names)
[17:28:27.430]                 removed <- setdiff(old_names, names)
[17:28:27.430]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:27.430]                   envs[common]]
[17:28:27.430]                 NAMES <- toupper(changed)
[17:28:27.430]                 args <- list()
[17:28:27.430]                 for (kk in seq_along(NAMES)) {
[17:28:27.430]                   name <- changed[[kk]]
[17:28:27.430]                   NAME <- NAMES[[kk]]
[17:28:27.430]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.430]                     next
[17:28:27.430]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.430]                 }
[17:28:27.430]                 NAMES <- toupper(added)
[17:28:27.430]                 for (kk in seq_along(NAMES)) {
[17:28:27.430]                   name <- added[[kk]]
[17:28:27.430]                   NAME <- NAMES[[kk]]
[17:28:27.430]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.430]                     next
[17:28:27.430]                   args[[name]] <- ""
[17:28:27.430]                 }
[17:28:27.430]                 NAMES <- toupper(removed)
[17:28:27.430]                 for (kk in seq_along(NAMES)) {
[17:28:27.430]                   name <- removed[[kk]]
[17:28:27.430]                   NAME <- NAMES[[kk]]
[17:28:27.430]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.430]                     next
[17:28:27.430]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.430]                 }
[17:28:27.430]                 if (length(args) > 0) 
[17:28:27.430]                   base::do.call(base::Sys.setenv, args = args)
[17:28:27.430]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:27.430]             }
[17:28:27.430]             else {
[17:28:27.430]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:27.430]             }
[17:28:27.430]             {
[17:28:27.430]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:27.430]                   0L) {
[17:28:27.430]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:27.430]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:27.430]                   base::options(opts)
[17:28:27.430]                 }
[17:28:27.430]                 {
[17:28:27.430]                   {
[17:28:27.430]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:27.430]                     NULL
[17:28:27.430]                   }
[17:28:27.430]                   options(future.plan = NULL)
[17:28:27.430]                   if (is.na(NA_character_)) 
[17:28:27.430]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.430]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:27.430]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:27.430]                     .init = FALSE)
[17:28:27.430]                 }
[17:28:27.430]             }
[17:28:27.430]         }
[17:28:27.430]     })
[17:28:27.430]     if (TRUE) {
[17:28:27.430]         base::sink(type = "output", split = FALSE)
[17:28:27.430]         if (TRUE) {
[17:28:27.430]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:27.430]         }
[17:28:27.430]         else {
[17:28:27.430]             ...future.result["stdout"] <- base::list(NULL)
[17:28:27.430]         }
[17:28:27.430]         base::close(...future.stdout)
[17:28:27.430]         ...future.stdout <- NULL
[17:28:27.430]     }
[17:28:27.430]     ...future.result$conditions <- ...future.conditions
[17:28:27.430]     ...future.result$finished <- base::Sys.time()
[17:28:27.430]     ...future.result
[17:28:27.430] }
[17:28:27.557] Exporting 1 global objects (300 bytes) to cluster node #2 ...
[17:28:27.557] Exporting 'ii' (35 bytes) to cluster node #2 ...
[17:28:27.558] Exporting 'ii' (35 bytes) to cluster node #2 ... DONE
[17:28:27.558] Exporting 1 global objects (300 bytes) to cluster node #2 ... DONE
[17:28:27.559] MultisessionFuture started
 - Resolving 2 multisession futures
[17:28:27.560] result() for ClusterFuture ...
[17:28:27.560] receiveMessageFromWorker() for ClusterFuture ...
[17:28:27.560] - Validating connection of MultisessionFuture
[17:28:27.627] - received message: FutureResult
[17:28:27.628] - Received FutureResult
[17:28:27.629] - Erased future from FutureRegistry
[17:28:27.629] result() for ClusterFuture ...
[17:28:27.629] - result already collected: FutureResult
[17:28:27.630] result() for ClusterFuture ... done
[17:28:27.630] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:27.630] result() for ClusterFuture ... done
[17:28:27.631] result() for ClusterFuture ...
[17:28:27.631] - result already collected: FutureResult
[17:28:27.631] result() for ClusterFuture ... done
[17:28:27.632] result() for ClusterFuture ...
[17:28:27.632] receiveMessageFromWorker() for ClusterFuture ...
[17:28:27.632] - Validating connection of MultisessionFuture
[17:28:27.633] - received message: FutureResult
[17:28:27.633] - Received FutureResult
[17:28:27.634] - Erased future from FutureRegistry
[17:28:27.634] result() for ClusterFuture ...
[17:28:27.634] - result already collected: FutureResult
[17:28:27.635] result() for ClusterFuture ... done
[17:28:27.635] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:27.635] result() for ClusterFuture ... done
[17:28:27.636] result() for ClusterFuture ...
[17:28:27.636] - result already collected: FutureResult
[17:28:27.636] result() for ClusterFuture ... done
*** multisession() - workers inherit .libPaths()
[17:28:27.637] getGlobalsAndPackages() ...
[17:28:27.637] Searching for globals...
[17:28:27.639] - globals found: [1] '.libPaths'
[17:28:27.639] Searching for globals ... DONE
[17:28:27.639] Resolving globals: FALSE
[17:28:27.640] 
[17:28:27.640] 
[17:28:27.641] getGlobalsAndPackages() ... DONE
[17:28:27.641] run() for 'Future' ...
[17:28:27.642] - state: 'created'
[17:28:27.642] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:27.643] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:27.643] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:27.644]   - Field: 'label'
[17:28:27.644]   - Field: 'local'
[17:28:27.644]   - Field: 'owner'
[17:28:27.644]   - Field: 'envir'
[17:28:27.644]   - Field: 'packages'
[17:28:27.645]   - Field: 'gc'
[17:28:27.645]   - Field: 'conditions'
[17:28:27.645]   - Field: 'expr'
[17:28:27.645]   - Field: 'uuid'
[17:28:27.646]   - Field: 'seed'
[17:28:27.646]   - Field: 'version'
[17:28:27.646]   - Field: 'result'
[17:28:27.646]   - Field: 'asynchronous'
[17:28:27.646]   - Field: 'calls'
[17:28:27.647]   - Field: 'globals'
[17:28:27.647]   - Field: 'stdout'
[17:28:27.647]   - Field: 'earlySignal'
[17:28:27.647]   - Field: 'lazy'
[17:28:27.647]   - Field: 'state'
[17:28:27.648] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:27.648] - Launch lazy future ...
[17:28:27.648] Packages needed by the future expression (n = 0): <none>
[17:28:27.648] Packages needed by future strategies (n = 0): <none>
[17:28:27.649] {
[17:28:27.649]     {
[17:28:27.649]         {
[17:28:27.649]             ...future.startTime <- base::Sys.time()
[17:28:27.649]             {
[17:28:27.649]                 {
[17:28:27.649]                   {
[17:28:27.649]                     base::local({
[17:28:27.649]                       has_future <- base::requireNamespace("future", 
[17:28:27.649]                         quietly = TRUE)
[17:28:27.649]                       if (has_future) {
[17:28:27.649]                         ns <- base::getNamespace("future")
[17:28:27.649]                         version <- ns[[".package"]][["version"]]
[17:28:27.649]                         if (is.null(version)) 
[17:28:27.649]                           version <- utils::packageVersion("future")
[17:28:27.649]                       }
[17:28:27.649]                       else {
[17:28:27.649]                         version <- NULL
[17:28:27.649]                       }
[17:28:27.649]                       if (!has_future || version < "1.8.0") {
[17:28:27.649]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:27.649]                           "", base::R.version$version.string), 
[17:28:27.649]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:27.649]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:27.649]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:27.649]                             "release", "version")], collapse = " "), 
[17:28:27.649]                           hostname = base::Sys.info()[["nodename"]])
[17:28:27.649]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:27.649]                           info)
[17:28:27.649]                         info <- base::paste(info, collapse = "; ")
[17:28:27.649]                         if (!has_future) {
[17:28:27.649]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:27.649]                             info)
[17:28:27.649]                         }
[17:28:27.649]                         else {
[17:28:27.649]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:27.649]                             info, version)
[17:28:27.649]                         }
[17:28:27.649]                         base::stop(msg)
[17:28:27.649]                       }
[17:28:27.649]                     })
[17:28:27.649]                   }
[17:28:27.649]                   ...future.strategy.old <- future::plan("list")
[17:28:27.649]                   options(future.plan = NULL)
[17:28:27.649]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.649]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:27.649]                 }
[17:28:27.649]                 ...future.workdir <- getwd()
[17:28:27.649]             }
[17:28:27.649]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:27.649]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:27.649]         }
[17:28:27.649]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:27.649]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:27.649]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:27.649]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:27.649]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:27.649]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:27.649]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:27.649]             base::names(...future.oldOptions))
[17:28:27.649]     }
[17:28:27.649]     if (FALSE) {
[17:28:27.649]     }
[17:28:27.649]     else {
[17:28:27.649]         if (TRUE) {
[17:28:27.649]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:27.649]                 open = "w")
[17:28:27.649]         }
[17:28:27.649]         else {
[17:28:27.649]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:27.649]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:27.649]         }
[17:28:27.649]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:27.649]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:27.649]             base::sink(type = "output", split = FALSE)
[17:28:27.649]             base::close(...future.stdout)
[17:28:27.649]         }, add = TRUE)
[17:28:27.649]     }
[17:28:27.649]     ...future.frame <- base::sys.nframe()
[17:28:27.649]     ...future.conditions <- base::list()
[17:28:27.649]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:27.649]     if (FALSE) {
[17:28:27.649]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:27.649]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:27.649]     }
[17:28:27.649]     ...future.result <- base::tryCatch({
[17:28:27.649]         base::withCallingHandlers({
[17:28:27.649]             ...future.value <- base::withVisible(base::local(.libPaths()))
[17:28:27.649]             future::FutureResult(value = ...future.value$value, 
[17:28:27.649]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.649]                   ...future.rng), globalenv = if (FALSE) 
[17:28:27.649]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:27.649]                     ...future.globalenv.names))
[17:28:27.649]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:27.649]         }, condition = base::local({
[17:28:27.649]             c <- base::c
[17:28:27.649]             inherits <- base::inherits
[17:28:27.649]             invokeRestart <- base::invokeRestart
[17:28:27.649]             length <- base::length
[17:28:27.649]             list <- base::list
[17:28:27.649]             seq.int <- base::seq.int
[17:28:27.649]             signalCondition <- base::signalCondition
[17:28:27.649]             sys.calls <- base::sys.calls
[17:28:27.649]             `[[` <- base::`[[`
[17:28:27.649]             `+` <- base::`+`
[17:28:27.649]             `<<-` <- base::`<<-`
[17:28:27.649]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:27.649]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:27.649]                   3L)]
[17:28:27.649]             }
[17:28:27.649]             function(cond) {
[17:28:27.649]                 is_error <- inherits(cond, "error")
[17:28:27.649]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:27.649]                   NULL)
[17:28:27.649]                 if (is_error) {
[17:28:27.649]                   sessionInformation <- function() {
[17:28:27.649]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:27.649]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:27.649]                       search = base::search(), system = base::Sys.info())
[17:28:27.649]                   }
[17:28:27.649]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.649]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:27.649]                     cond$call), session = sessionInformation(), 
[17:28:27.649]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:27.649]                   signalCondition(cond)
[17:28:27.649]                 }
[17:28:27.649]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:27.649]                 "immediateCondition"))) {
[17:28:27.649]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:27.649]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.649]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:27.649]                   if (TRUE && !signal) {
[17:28:27.649]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.649]                     {
[17:28:27.649]                       inherits <- base::inherits
[17:28:27.649]                       invokeRestart <- base::invokeRestart
[17:28:27.649]                       is.null <- base::is.null
[17:28:27.649]                       muffled <- FALSE
[17:28:27.649]                       if (inherits(cond, "message")) {
[17:28:27.649]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.649]                         if (muffled) 
[17:28:27.649]                           invokeRestart("muffleMessage")
[17:28:27.649]                       }
[17:28:27.649]                       else if (inherits(cond, "warning")) {
[17:28:27.649]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.649]                         if (muffled) 
[17:28:27.649]                           invokeRestart("muffleWarning")
[17:28:27.649]                       }
[17:28:27.649]                       else if (inherits(cond, "condition")) {
[17:28:27.649]                         if (!is.null(pattern)) {
[17:28:27.649]                           computeRestarts <- base::computeRestarts
[17:28:27.649]                           grepl <- base::grepl
[17:28:27.649]                           restarts <- computeRestarts(cond)
[17:28:27.649]                           for (restart in restarts) {
[17:28:27.649]                             name <- restart$name
[17:28:27.649]                             if (is.null(name)) 
[17:28:27.649]                               next
[17:28:27.649]                             if (!grepl(pattern, name)) 
[17:28:27.649]                               next
[17:28:27.649]                             invokeRestart(restart)
[17:28:27.649]                             muffled <- TRUE
[17:28:27.649]                             break
[17:28:27.649]                           }
[17:28:27.649]                         }
[17:28:27.649]                       }
[17:28:27.649]                       invisible(muffled)
[17:28:27.649]                     }
[17:28:27.649]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.649]                   }
[17:28:27.649]                 }
[17:28:27.649]                 else {
[17:28:27.649]                   if (TRUE) {
[17:28:27.649]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.649]                     {
[17:28:27.649]                       inherits <- base::inherits
[17:28:27.649]                       invokeRestart <- base::invokeRestart
[17:28:27.649]                       is.null <- base::is.null
[17:28:27.649]                       muffled <- FALSE
[17:28:27.649]                       if (inherits(cond, "message")) {
[17:28:27.649]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.649]                         if (muffled) 
[17:28:27.649]                           invokeRestart("muffleMessage")
[17:28:27.649]                       }
[17:28:27.649]                       else if (inherits(cond, "warning")) {
[17:28:27.649]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.649]                         if (muffled) 
[17:28:27.649]                           invokeRestart("muffleWarning")
[17:28:27.649]                       }
[17:28:27.649]                       else if (inherits(cond, "condition")) {
[17:28:27.649]                         if (!is.null(pattern)) {
[17:28:27.649]                           computeRestarts <- base::computeRestarts
[17:28:27.649]                           grepl <- base::grepl
[17:28:27.649]                           restarts <- computeRestarts(cond)
[17:28:27.649]                           for (restart in restarts) {
[17:28:27.649]                             name <- restart$name
[17:28:27.649]                             if (is.null(name)) 
[17:28:27.649]                               next
[17:28:27.649]                             if (!grepl(pattern, name)) 
[17:28:27.649]                               next
[17:28:27.649]                             invokeRestart(restart)
[17:28:27.649]                             muffled <- TRUE
[17:28:27.649]                             break
[17:28:27.649]                           }
[17:28:27.649]                         }
[17:28:27.649]                       }
[17:28:27.649]                       invisible(muffled)
[17:28:27.649]                     }
[17:28:27.649]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.649]                   }
[17:28:27.649]                 }
[17:28:27.649]             }
[17:28:27.649]         }))
[17:28:27.649]     }, error = function(ex) {
[17:28:27.649]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:27.649]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.649]                 ...future.rng), started = ...future.startTime, 
[17:28:27.649]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:27.649]             version = "1.8"), class = "FutureResult")
[17:28:27.649]     }, finally = {
[17:28:27.649]         if (!identical(...future.workdir, getwd())) 
[17:28:27.649]             setwd(...future.workdir)
[17:28:27.649]         {
[17:28:27.649]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:27.649]                 ...future.oldOptions$nwarnings <- NULL
[17:28:27.649]             }
[17:28:27.649]             base::options(...future.oldOptions)
[17:28:27.649]             if (.Platform$OS.type == "windows") {
[17:28:27.649]                 old_names <- names(...future.oldEnvVars)
[17:28:27.649]                 envs <- base::Sys.getenv()
[17:28:27.649]                 names <- names(envs)
[17:28:27.649]                 common <- intersect(names, old_names)
[17:28:27.649]                 added <- setdiff(names, old_names)
[17:28:27.649]                 removed <- setdiff(old_names, names)
[17:28:27.649]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:27.649]                   envs[common]]
[17:28:27.649]                 NAMES <- toupper(changed)
[17:28:27.649]                 args <- list()
[17:28:27.649]                 for (kk in seq_along(NAMES)) {
[17:28:27.649]                   name <- changed[[kk]]
[17:28:27.649]                   NAME <- NAMES[[kk]]
[17:28:27.649]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.649]                     next
[17:28:27.649]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.649]                 }
[17:28:27.649]                 NAMES <- toupper(added)
[17:28:27.649]                 for (kk in seq_along(NAMES)) {
[17:28:27.649]                   name <- added[[kk]]
[17:28:27.649]                   NAME <- NAMES[[kk]]
[17:28:27.649]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.649]                     next
[17:28:27.649]                   args[[name]] <- ""
[17:28:27.649]                 }
[17:28:27.649]                 NAMES <- toupper(removed)
[17:28:27.649]                 for (kk in seq_along(NAMES)) {
[17:28:27.649]                   name <- removed[[kk]]
[17:28:27.649]                   NAME <- NAMES[[kk]]
[17:28:27.649]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.649]                     next
[17:28:27.649]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.649]                 }
[17:28:27.649]                 if (length(args) > 0) 
[17:28:27.649]                   base::do.call(base::Sys.setenv, args = args)
[17:28:27.649]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:27.649]             }
[17:28:27.649]             else {
[17:28:27.649]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:27.649]             }
[17:28:27.649]             {
[17:28:27.649]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:27.649]                   0L) {
[17:28:27.649]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:27.649]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:27.649]                   base::options(opts)
[17:28:27.649]                 }
[17:28:27.649]                 {
[17:28:27.649]                   {
[17:28:27.649]                     NULL
[17:28:27.649]                     RNGkind("Mersenne-Twister")
[17:28:27.649]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:27.649]                       inherits = FALSE)
[17:28:27.649]                   }
[17:28:27.649]                   options(future.plan = NULL)
[17:28:27.649]                   if (is.na(NA_character_)) 
[17:28:27.649]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.649]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:27.649]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:27.649]                     .init = FALSE)
[17:28:27.649]                 }
[17:28:27.649]             }
[17:28:27.649]         }
[17:28:27.649]     })
[17:28:27.649]     if (TRUE) {
[17:28:27.649]         base::sink(type = "output", split = FALSE)
[17:28:27.649]         if (TRUE) {
[17:28:27.649]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:27.649]         }
[17:28:27.649]         else {
[17:28:27.649]             ...future.result["stdout"] <- base::list(NULL)
[17:28:27.649]         }
[17:28:27.649]         base::close(...future.stdout)
[17:28:27.649]         ...future.stdout <- NULL
[17:28:27.649]     }
[17:28:27.649]     ...future.result$conditions <- ...future.conditions
[17:28:27.649]     ...future.result$finished <- base::Sys.time()
[17:28:27.649]     ...future.result
[17:28:27.649] }
[17:28:27.654] plan(): Setting new future strategy stack:
[17:28:27.654] List of future strategies:
[17:28:27.654] 1. sequential:
[17:28:27.654]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:27.654]    - tweaked: FALSE
[17:28:27.654]    - call: NULL
[17:28:27.655] plan(): nbrOfWorkers() = 1
[17:28:27.656] plan(): Setting new future strategy stack:
[17:28:27.657] List of future strategies:
[17:28:27.657] 1. sequential:
[17:28:27.657]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:27.657]    - tweaked: FALSE
[17:28:27.657]    - call: future::plan("sequential")
[17:28:27.658] plan(): nbrOfWorkers() = 1
[17:28:27.658] SequentialFuture started (and completed)
[17:28:27.659] - Launch lazy future ... done
[17:28:27.659] run() for 'SequentialFuture' ... done
List of 2
 $ main   : chr [1:2] "D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda" "D:/RCompile/recent/R/library"
 $ workers: chr [1:2] "D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda" "D:/RCompile/recent/R/library"
*** multisession() and errors
[17:28:27.666] getGlobalsAndPackages() ...
[17:28:27.666] 
[17:28:27.667] - globals: [0] <none>
[17:28:27.667] getGlobalsAndPackages() ... DONE
[17:28:27.687] Packages needed by the future expression (n = 0): <none>
[17:28:27.688] Packages needed by future strategies (n = 0): <none>
[17:28:27.689] {
[17:28:27.689]     {
[17:28:27.689]         {
[17:28:27.689]             ...future.startTime <- base::Sys.time()
[17:28:27.689]             {
[17:28:27.689]                 {
[17:28:27.689]                   {
[17:28:27.689]                     {
[17:28:27.689]                       base::local({
[17:28:27.689]                         has_future <- base::requireNamespace("future", 
[17:28:27.689]                           quietly = TRUE)
[17:28:27.689]                         if (has_future) {
[17:28:27.689]                           ns <- base::getNamespace("future")
[17:28:27.689]                           version <- ns[[".package"]][["version"]]
[17:28:27.689]                           if (is.null(version)) 
[17:28:27.689]                             version <- utils::packageVersion("future")
[17:28:27.689]                         }
[17:28:27.689]                         else {
[17:28:27.689]                           version <- NULL
[17:28:27.689]                         }
[17:28:27.689]                         if (!has_future || version < "1.8.0") {
[17:28:27.689]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:27.689]                             "", base::R.version$version.string), 
[17:28:27.689]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:27.689]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:27.689]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:27.689]                               "release", "version")], collapse = " "), 
[17:28:27.689]                             hostname = base::Sys.info()[["nodename"]])
[17:28:27.689]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:27.689]                             info)
[17:28:27.689]                           info <- base::paste(info, collapse = "; ")
[17:28:27.689]                           if (!has_future) {
[17:28:27.689]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:27.689]                               info)
[17:28:27.689]                           }
[17:28:27.689]                           else {
[17:28:27.689]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:27.689]                               info, version)
[17:28:27.689]                           }
[17:28:27.689]                           base::stop(msg)
[17:28:27.689]                         }
[17:28:27.689]                       })
[17:28:27.689]                     }
[17:28:27.689]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:27.689]                     base::options(mc.cores = 1L)
[17:28:27.689]                   }
[17:28:27.689]                   ...future.strategy.old <- future::plan("list")
[17:28:27.689]                   options(future.plan = NULL)
[17:28:27.689]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.689]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:27.689]                 }
[17:28:27.689]                 ...future.workdir <- getwd()
[17:28:27.689]             }
[17:28:27.689]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:27.689]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:27.689]         }
[17:28:27.689]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:27.689]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:27.689]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:27.689]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:27.689]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:27.689]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:27.689]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:27.689]             base::names(...future.oldOptions))
[17:28:27.689]     }
[17:28:27.689]     if (FALSE) {
[17:28:27.689]     }
[17:28:27.689]     else {
[17:28:27.689]         if (TRUE) {
[17:28:27.689]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:27.689]                 open = "w")
[17:28:27.689]         }
[17:28:27.689]         else {
[17:28:27.689]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:27.689]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:27.689]         }
[17:28:27.689]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:27.689]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:27.689]             base::sink(type = "output", split = FALSE)
[17:28:27.689]             base::close(...future.stdout)
[17:28:27.689]         }, add = TRUE)
[17:28:27.689]     }
[17:28:27.689]     ...future.frame <- base::sys.nframe()
[17:28:27.689]     ...future.conditions <- base::list()
[17:28:27.689]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:27.689]     if (FALSE) {
[17:28:27.689]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:27.689]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:27.689]     }
[17:28:27.689]     ...future.result <- base::tryCatch({
[17:28:27.689]         base::withCallingHandlers({
[17:28:27.689]             ...future.value <- base::withVisible(base::local({
[17:28:27.689]                 ...future.makeSendCondition <- base::local({
[17:28:27.689]                   sendCondition <- NULL
[17:28:27.689]                   function(frame = 1L) {
[17:28:27.689]                     if (is.function(sendCondition)) 
[17:28:27.689]                       return(sendCondition)
[17:28:27.689]                     ns <- getNamespace("parallel")
[17:28:27.689]                     if (exists("sendData", mode = "function", 
[17:28:27.689]                       envir = ns)) {
[17:28:27.689]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:27.689]                         envir = ns)
[17:28:27.689]                       envir <- sys.frame(frame)
[17:28:27.689]                       master <- NULL
[17:28:27.689]                       while (!identical(envir, .GlobalEnv) && 
[17:28:27.689]                         !identical(envir, emptyenv())) {
[17:28:27.689]                         if (exists("master", mode = "list", envir = envir, 
[17:28:27.689]                           inherits = FALSE)) {
[17:28:27.689]                           master <- get("master", mode = "list", 
[17:28:27.689]                             envir = envir, inherits = FALSE)
[17:28:27.689]                           if (inherits(master, c("SOCKnode", 
[17:28:27.689]                             "SOCK0node"))) {
[17:28:27.689]                             sendCondition <<- function(cond) {
[17:28:27.689]                               data <- list(type = "VALUE", value = cond, 
[17:28:27.689]                                 success = TRUE)
[17:28:27.689]                               parallel_sendData(master, data)
[17:28:27.689]                             }
[17:28:27.689]                             return(sendCondition)
[17:28:27.689]                           }
[17:28:27.689]                         }
[17:28:27.689]                         frame <- frame + 1L
[17:28:27.689]                         envir <- sys.frame(frame)
[17:28:27.689]                       }
[17:28:27.689]                     }
[17:28:27.689]                     sendCondition <<- function(cond) NULL
[17:28:27.689]                   }
[17:28:27.689]                 })
[17:28:27.689]                 withCallingHandlers({
[17:28:27.689]                   {
[17:28:27.689]                     stop("Whoops!")
[17:28:27.689]                     1
[17:28:27.689]                   }
[17:28:27.689]                 }, immediateCondition = function(cond) {
[17:28:27.689]                   sendCondition <- ...future.makeSendCondition()
[17:28:27.689]                   sendCondition(cond)
[17:28:27.689]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.689]                   {
[17:28:27.689]                     inherits <- base::inherits
[17:28:27.689]                     invokeRestart <- base::invokeRestart
[17:28:27.689]                     is.null <- base::is.null
[17:28:27.689]                     muffled <- FALSE
[17:28:27.689]                     if (inherits(cond, "message")) {
[17:28:27.689]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:27.689]                       if (muffled) 
[17:28:27.689]                         invokeRestart("muffleMessage")
[17:28:27.689]                     }
[17:28:27.689]                     else if (inherits(cond, "warning")) {
[17:28:27.689]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:27.689]                       if (muffled) 
[17:28:27.689]                         invokeRestart("muffleWarning")
[17:28:27.689]                     }
[17:28:27.689]                     else if (inherits(cond, "condition")) {
[17:28:27.689]                       if (!is.null(pattern)) {
[17:28:27.689]                         computeRestarts <- base::computeRestarts
[17:28:27.689]                         grepl <- base::grepl
[17:28:27.689]                         restarts <- computeRestarts(cond)
[17:28:27.689]                         for (restart in restarts) {
[17:28:27.689]                           name <- restart$name
[17:28:27.689]                           if (is.null(name)) 
[17:28:27.689]                             next
[17:28:27.689]                           if (!grepl(pattern, name)) 
[17:28:27.689]                             next
[17:28:27.689]                           invokeRestart(restart)
[17:28:27.689]                           muffled <- TRUE
[17:28:27.689]                           break
[17:28:27.689]                         }
[17:28:27.689]                       }
[17:28:27.689]                     }
[17:28:27.689]                     invisible(muffled)
[17:28:27.689]                   }
[17:28:27.689]                   muffleCondition(cond)
[17:28:27.689]                 })
[17:28:27.689]             }))
[17:28:27.689]             future::FutureResult(value = ...future.value$value, 
[17:28:27.689]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.689]                   ...future.rng), globalenv = if (FALSE) 
[17:28:27.689]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:27.689]                     ...future.globalenv.names))
[17:28:27.689]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:27.689]         }, condition = base::local({
[17:28:27.689]             c <- base::c
[17:28:27.689]             inherits <- base::inherits
[17:28:27.689]             invokeRestart <- base::invokeRestart
[17:28:27.689]             length <- base::length
[17:28:27.689]             list <- base::list
[17:28:27.689]             seq.int <- base::seq.int
[17:28:27.689]             signalCondition <- base::signalCondition
[17:28:27.689]             sys.calls <- base::sys.calls
[17:28:27.689]             `[[` <- base::`[[`
[17:28:27.689]             `+` <- base::`+`
[17:28:27.689]             `<<-` <- base::`<<-`
[17:28:27.689]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:27.689]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:27.689]                   3L)]
[17:28:27.689]             }
[17:28:27.689]             function(cond) {
[17:28:27.689]                 is_error <- inherits(cond, "error")
[17:28:27.689]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:27.689]                   NULL)
[17:28:27.689]                 if (is_error) {
[17:28:27.689]                   sessionInformation <- function() {
[17:28:27.689]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:27.689]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:27.689]                       search = base::search(), system = base::Sys.info())
[17:28:27.689]                   }
[17:28:27.689]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.689]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:27.689]                     cond$call), session = sessionInformation(), 
[17:28:27.689]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:27.689]                   signalCondition(cond)
[17:28:27.689]                 }
[17:28:27.689]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:27.689]                 "immediateCondition"))) {
[17:28:27.689]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:27.689]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.689]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:27.689]                   if (TRUE && !signal) {
[17:28:27.689]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.689]                     {
[17:28:27.689]                       inherits <- base::inherits
[17:28:27.689]                       invokeRestart <- base::invokeRestart
[17:28:27.689]                       is.null <- base::is.null
[17:28:27.689]                       muffled <- FALSE
[17:28:27.689]                       if (inherits(cond, "message")) {
[17:28:27.689]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.689]                         if (muffled) 
[17:28:27.689]                           invokeRestart("muffleMessage")
[17:28:27.689]                       }
[17:28:27.689]                       else if (inherits(cond, "warning")) {
[17:28:27.689]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.689]                         if (muffled) 
[17:28:27.689]                           invokeRestart("muffleWarning")
[17:28:27.689]                       }
[17:28:27.689]                       else if (inherits(cond, "condition")) {
[17:28:27.689]                         if (!is.null(pattern)) {
[17:28:27.689]                           computeRestarts <- base::computeRestarts
[17:28:27.689]                           grepl <- base::grepl
[17:28:27.689]                           restarts <- computeRestarts(cond)
[17:28:27.689]                           for (restart in restarts) {
[17:28:27.689]                             name <- restart$name
[17:28:27.689]                             if (is.null(name)) 
[17:28:27.689]                               next
[17:28:27.689]                             if (!grepl(pattern, name)) 
[17:28:27.689]                               next
[17:28:27.689]                             invokeRestart(restart)
[17:28:27.689]                             muffled <- TRUE
[17:28:27.689]                             break
[17:28:27.689]                           }
[17:28:27.689]                         }
[17:28:27.689]                       }
[17:28:27.689]                       invisible(muffled)
[17:28:27.689]                     }
[17:28:27.689]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.689]                   }
[17:28:27.689]                 }
[17:28:27.689]                 else {
[17:28:27.689]                   if (TRUE) {
[17:28:27.689]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.689]                     {
[17:28:27.689]                       inherits <- base::inherits
[17:28:27.689]                       invokeRestart <- base::invokeRestart
[17:28:27.689]                       is.null <- base::is.null
[17:28:27.689]                       muffled <- FALSE
[17:28:27.689]                       if (inherits(cond, "message")) {
[17:28:27.689]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.689]                         if (muffled) 
[17:28:27.689]                           invokeRestart("muffleMessage")
[17:28:27.689]                       }
[17:28:27.689]                       else if (inherits(cond, "warning")) {
[17:28:27.689]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.689]                         if (muffled) 
[17:28:27.689]                           invokeRestart("muffleWarning")
[17:28:27.689]                       }
[17:28:27.689]                       else if (inherits(cond, "condition")) {
[17:28:27.689]                         if (!is.null(pattern)) {
[17:28:27.689]                           computeRestarts <- base::computeRestarts
[17:28:27.689]                           grepl <- base::grepl
[17:28:27.689]                           restarts <- computeRestarts(cond)
[17:28:27.689]                           for (restart in restarts) {
[17:28:27.689]                             name <- restart$name
[17:28:27.689]                             if (is.null(name)) 
[17:28:27.689]                               next
[17:28:27.689]                             if (!grepl(pattern, name)) 
[17:28:27.689]                               next
[17:28:27.689]                             invokeRestart(restart)
[17:28:27.689]                             muffled <- TRUE
[17:28:27.689]                             break
[17:28:27.689]                           }
[17:28:27.689]                         }
[17:28:27.689]                       }
[17:28:27.689]                       invisible(muffled)
[17:28:27.689]                     }
[17:28:27.689]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.689]                   }
[17:28:27.689]                 }
[17:28:27.689]             }
[17:28:27.689]         }))
[17:28:27.689]     }, error = function(ex) {
[17:28:27.689]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:27.689]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.689]                 ...future.rng), started = ...future.startTime, 
[17:28:27.689]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:27.689]             version = "1.8"), class = "FutureResult")
[17:28:27.689]     }, finally = {
[17:28:27.689]         if (!identical(...future.workdir, getwd())) 
[17:28:27.689]             setwd(...future.workdir)
[17:28:27.689]         {
[17:28:27.689]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:27.689]                 ...future.oldOptions$nwarnings <- NULL
[17:28:27.689]             }
[17:28:27.689]             base::options(...future.oldOptions)
[17:28:27.689]             if (.Platform$OS.type == "windows") {
[17:28:27.689]                 old_names <- names(...future.oldEnvVars)
[17:28:27.689]                 envs <- base::Sys.getenv()
[17:28:27.689]                 names <- names(envs)
[17:28:27.689]                 common <- intersect(names, old_names)
[17:28:27.689]                 added <- setdiff(names, old_names)
[17:28:27.689]                 removed <- setdiff(old_names, names)
[17:28:27.689]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:27.689]                   envs[common]]
[17:28:27.689]                 NAMES <- toupper(changed)
[17:28:27.689]                 args <- list()
[17:28:27.689]                 for (kk in seq_along(NAMES)) {
[17:28:27.689]                   name <- changed[[kk]]
[17:28:27.689]                   NAME <- NAMES[[kk]]
[17:28:27.689]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.689]                     next
[17:28:27.689]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.689]                 }
[17:28:27.689]                 NAMES <- toupper(added)
[17:28:27.689]                 for (kk in seq_along(NAMES)) {
[17:28:27.689]                   name <- added[[kk]]
[17:28:27.689]                   NAME <- NAMES[[kk]]
[17:28:27.689]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.689]                     next
[17:28:27.689]                   args[[name]] <- ""
[17:28:27.689]                 }
[17:28:27.689]                 NAMES <- toupper(removed)
[17:28:27.689]                 for (kk in seq_along(NAMES)) {
[17:28:27.689]                   name <- removed[[kk]]
[17:28:27.689]                   NAME <- NAMES[[kk]]
[17:28:27.689]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.689]                     next
[17:28:27.689]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.689]                 }
[17:28:27.689]                 if (length(args) > 0) 
[17:28:27.689]                   base::do.call(base::Sys.setenv, args = args)
[17:28:27.689]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:27.689]             }
[17:28:27.689]             else {
[17:28:27.689]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:27.689]             }
[17:28:27.689]             {
[17:28:27.689]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:27.689]                   0L) {
[17:28:27.689]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:27.689]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:27.689]                   base::options(opts)
[17:28:27.689]                 }
[17:28:27.689]                 {
[17:28:27.689]                   {
[17:28:27.689]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:27.689]                     NULL
[17:28:27.689]                   }
[17:28:27.689]                   options(future.plan = NULL)
[17:28:27.689]                   if (is.na(NA_character_)) 
[17:28:27.689]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.689]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:27.689]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:27.689]                     .init = FALSE)
[17:28:27.689]                 }
[17:28:27.689]             }
[17:28:27.689]         }
[17:28:27.689]     })
[17:28:27.689]     if (TRUE) {
[17:28:27.689]         base::sink(type = "output", split = FALSE)
[17:28:27.689]         if (TRUE) {
[17:28:27.689]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:27.689]         }
[17:28:27.689]         else {
[17:28:27.689]             ...future.result["stdout"] <- base::list(NULL)
[17:28:27.689]         }
[17:28:27.689]         base::close(...future.stdout)
[17:28:27.689]         ...future.stdout <- NULL
[17:28:27.689]     }
[17:28:27.689]     ...future.result$conditions <- ...future.conditions
[17:28:27.689]     ...future.result$finished <- base::Sys.time()
[17:28:27.689]     ...future.result
[17:28:27.689] }
[17:28:27.699] MultisessionFuture started
MultisessionFuture:
Label: '<none>'
Expression:
{
    stop("Whoops!")
    1
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[17:28:27.721] receiveMessageFromWorker() for ClusterFuture ...
[17:28:27.721] - Validating connection of MultisessionFuture
[17:28:27.722] - received message: FutureResult
[17:28:27.722] - Received FutureResult
[17:28:27.722] - Erased future from FutureRegistry
[17:28:27.723] result() for ClusterFuture ...
[17:28:27.723] - result already collected: FutureResult
[17:28:27.723] result() for ClusterFuture ... done
[17:28:27.723] signalConditions() ...
[17:28:27.723]  - include = 'immediateCondition'
[17:28:27.723]  - exclude = 
[17:28:27.724]  - resignal = FALSE
[17:28:27.724]  - Number of conditions: 1
[17:28:27.724] signalConditions() ... done
[17:28:27.724] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 12734a8a-480b-f2a5-0c96-45c13d81d854
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:27.725] result() for ClusterFuture ...
[17:28:27.725] - result already collected: FutureResult
[17:28:27.725] result() for ClusterFuture ... done
[17:28:27.725] result() for ClusterFuture ...
[17:28:27.725] - result already collected: FutureResult
[17:28:27.725] result() for ClusterFuture ... done
[17:28:27.725] signalConditions() ...
[17:28:27.726]  - include = 'immediateCondition'
[17:28:27.726]  - exclude = 
[17:28:27.726]  - resignal = FALSE
[17:28:27.726]  - Number of conditions: 1
[17:28:27.726] signalConditions() ... done
<simpleError in withCallingHandlers({    {        stop("Whoops!")        1    }}, immediateCondition = function(cond) {    sendCondition <- ...future.makeSendCondition()    sendCondition(cond)    muffleCondition <- function (cond, pattern = "^muffle")     {        inherits <- base::inherits        invokeRestart <- base::invokeRestart        is.null <- base::is.null        muffled <- FALSE        if (inherits(cond, "message")) {            muffled <- grepl(pattern, "muffleMessage")            if (muffled)                 invokeRestart("muffleMessage")        }        else if (inherits(cond, "warning")) {            muffled <- grepl(pattern, "muffleWarning")            if (muffled)                 invokeRestart("muffleWarning")        }        else if (inherits(cond, "condition")) {            if (!is.null(pattern)) {                computeRestarts <- base::computeRestarts                grepl <- base::grepl                restarts <- computeRestarts(cond)                for (restart in restarts) {                  name <- restart$name                  if (is.null(name))                     next                  if (!grepl(pattern, name))                     next                  invokeRestart(restart)                  muffled <- TRUE                  break                }            }        }        invisible(muffled)    }    muffleCondition(cond)}): Whoops!>
[17:28:27.727] result() for ClusterFuture ...
[17:28:27.727] - result already collected: FutureResult
[17:28:27.727] result() for ClusterFuture ... done
[17:28:27.728] result() for ClusterFuture ...
[17:28:27.728] - result already collected: FutureResult
[17:28:27.728] result() for ClusterFuture ... done
[17:28:27.728] signalConditions() ...
[17:28:27.728]  - include = 'immediateCondition'
[17:28:27.729]  - exclude = 
[17:28:27.729]  - resignal = FALSE
[17:28:27.729]  - Number of conditions: 1
[17:28:27.730] signalConditions() ... done
[17:28:27.730] Future state: 'finished'
[17:28:27.730] result() for ClusterFuture ...
[17:28:27.730] - result already collected: FutureResult
[17:28:27.731] result() for ClusterFuture ... done
[17:28:27.731] signalConditions() ...
[17:28:27.731]  - include = 'condition'
[17:28:27.731]  - exclude = 'immediateCondition'
[17:28:27.732]  - resignal = TRUE
[17:28:27.732]  - Number of conditions: 1
[17:28:27.732]  - Condition #1: 'simpleError', 'error', 'condition'
[17:28:27.733] signalConditions() ... done
[1] "Error in withCallingHandlers({ : Whoops!\n"
attr(,"class")
[1] "try-error"
attr(,"condition")
<simpleError in withCallingHandlers({    {        stop("Whoops!")        1    }}, immediateCondition = function(cond) {    sendCondition <- ...future.makeSendCondition()    sendCondition(cond)    muffleCondition <- function (cond, pattern = "^muffle")     {        inherits <- base::inherits        invokeRestart <- base::invokeRestart        is.null <- base::is.null        muffled <- FALSE        if (inherits(cond, "message")) {            muffled <- grepl(pattern, "muffleMessage")            if (muffled)                 invokeRestart("muffleMessage")        }        else if (inherits(cond, "warning")) {            muffled <- grepl(pattern, "muffleWarning")            if (muffled)                 invokeRestart("muffleWarning")        }        else if (inherits(cond, "condition")) {            if (!is.null(pattern)) {                computeRestarts <- base::computeRestarts                grepl <- base::grepl                restarts <- computeRestarts(cond)                for (restart in restarts) {                  name <- restart$name                  if (is.null(name))                     next                  if (!grepl(pattern, name))                     next                  invokeRestart(restart)                  muffled <- TRUE                  break                }            }        }        invisible(muffled)    }    muffleCondition(cond)}): Whoops!>
[17:28:27.734] result() for ClusterFuture ...
[17:28:27.734] - result already collected: FutureResult
[17:28:27.735] result() for ClusterFuture ... done
[17:28:27.735] result() for ClusterFuture ...
[17:28:27.735] - result already collected: FutureResult
[17:28:27.736] result() for ClusterFuture ... done
[17:28:27.736] signalConditions() ...
[17:28:27.736]  - include = 'immediateCondition'
[17:28:27.736]  - exclude = 
[17:28:27.737]  - resignal = FALSE
[17:28:27.737]  - Number of conditions: 1
[17:28:27.738] signalConditions() ... done
[17:28:27.738] Future state: 'finished'
[17:28:27.738] result() for ClusterFuture ...
[17:28:27.739] - result already collected: FutureResult
[17:28:27.739] result() for ClusterFuture ... done
[17:28:27.739] signalConditions() ...
[17:28:27.740]  - include = 'condition'
[17:28:27.740]  - exclude = 'immediateCondition'
[17:28:27.740]  - resignal = TRUE
[17:28:27.741]  - Number of conditions: 1
[17:28:27.741]  - Condition #1: 'simpleError', 'error', 'condition'
[17:28:27.741] signalConditions() ... done
[1] "Error in withCallingHandlers({ : Whoops!\n"
attr(,"class")
[1] "try-error"
attr(,"condition")
<simpleError in withCallingHandlers({    {        stop("Whoops!")        1    }}, immediateCondition = function(cond) {    sendCondition <- ...future.makeSendCondition()    sendCondition(cond)    muffleCondition <- function (cond, pattern = "^muffle")     {        inherits <- base::inherits        invokeRestart <- base::invokeRestart        is.null <- base::is.null        muffled <- FALSE        if (inherits(cond, "message")) {            muffled <- grepl(pattern, "muffleMessage")            if (muffled)                 invokeRestart("muffleMessage")        }        else if (inherits(cond, "warning")) {            muffled <- grepl(pattern, "muffleWarning")            if (muffled)                 invokeRestart("muffleWarning")        }        else if (inherits(cond, "condition")) {            if (!is.null(pattern)) {                computeRestarts <- base::computeRestarts                grepl <- base::grepl                restarts <- computeRestarts(cond)                for (restart in restarts) {                  name <- restart$name                  if (is.null(name))                     next                  if (!grepl(pattern, name))                     next                  invokeRestart(restart)                  muffled <- TRUE                  break                }            }        }        invisible(muffled)    }    muffleCondition(cond)}): Whoops!>
[17:28:27.747] getGlobalsAndPackages() ...
[17:28:27.747] 
[17:28:27.747] - globals: [0] <none>
[17:28:27.748] getGlobalsAndPackages() ... DONE
[17:28:27.763] Packages needed by the future expression (n = 0): <none>
[17:28:27.763] Packages needed by future strategies (n = 0): <none>
[17:28:27.764] {
[17:28:27.764]     {
[17:28:27.764]         {
[17:28:27.764]             ...future.startTime <- base::Sys.time()
[17:28:27.764]             {
[17:28:27.764]                 {
[17:28:27.764]                   {
[17:28:27.764]                     {
[17:28:27.764]                       base::local({
[17:28:27.764]                         has_future <- base::requireNamespace("future", 
[17:28:27.764]                           quietly = TRUE)
[17:28:27.764]                         if (has_future) {
[17:28:27.764]                           ns <- base::getNamespace("future")
[17:28:27.764]                           version <- ns[[".package"]][["version"]]
[17:28:27.764]                           if (is.null(version)) 
[17:28:27.764]                             version <- utils::packageVersion("future")
[17:28:27.764]                         }
[17:28:27.764]                         else {
[17:28:27.764]                           version <- NULL
[17:28:27.764]                         }
[17:28:27.764]                         if (!has_future || version < "1.8.0") {
[17:28:27.764]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:27.764]                             "", base::R.version$version.string), 
[17:28:27.764]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:27.764]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:27.764]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:27.764]                               "release", "version")], collapse = " "), 
[17:28:27.764]                             hostname = base::Sys.info()[["nodename"]])
[17:28:27.764]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:27.764]                             info)
[17:28:27.764]                           info <- base::paste(info, collapse = "; ")
[17:28:27.764]                           if (!has_future) {
[17:28:27.764]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:27.764]                               info)
[17:28:27.764]                           }
[17:28:27.764]                           else {
[17:28:27.764]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:27.764]                               info, version)
[17:28:27.764]                           }
[17:28:27.764]                           base::stop(msg)
[17:28:27.764]                         }
[17:28:27.764]                       })
[17:28:27.764]                     }
[17:28:27.764]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:27.764]                     base::options(mc.cores = 1L)
[17:28:27.764]                   }
[17:28:27.764]                   ...future.strategy.old <- future::plan("list")
[17:28:27.764]                   options(future.plan = NULL)
[17:28:27.764]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.764]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:27.764]                 }
[17:28:27.764]                 ...future.workdir <- getwd()
[17:28:27.764]             }
[17:28:27.764]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:27.764]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:27.764]         }
[17:28:27.764]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:27.764]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:27.764]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:27.764]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:27.764]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:27.764]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:27.764]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:27.764]             base::names(...future.oldOptions))
[17:28:27.764]     }
[17:28:27.764]     if (FALSE) {
[17:28:27.764]     }
[17:28:27.764]     else {
[17:28:27.764]         if (TRUE) {
[17:28:27.764]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:27.764]                 open = "w")
[17:28:27.764]         }
[17:28:27.764]         else {
[17:28:27.764]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:27.764]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:27.764]         }
[17:28:27.764]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:27.764]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:27.764]             base::sink(type = "output", split = FALSE)
[17:28:27.764]             base::close(...future.stdout)
[17:28:27.764]         }, add = TRUE)
[17:28:27.764]     }
[17:28:27.764]     ...future.frame <- base::sys.nframe()
[17:28:27.764]     ...future.conditions <- base::list()
[17:28:27.764]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:27.764]     if (FALSE) {
[17:28:27.764]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:27.764]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:27.764]     }
[17:28:27.764]     ...future.result <- base::tryCatch({
[17:28:27.764]         base::withCallingHandlers({
[17:28:27.764]             ...future.value <- base::withVisible(base::local({
[17:28:27.764]                 ...future.makeSendCondition <- base::local({
[17:28:27.764]                   sendCondition <- NULL
[17:28:27.764]                   function(frame = 1L) {
[17:28:27.764]                     if (is.function(sendCondition)) 
[17:28:27.764]                       return(sendCondition)
[17:28:27.764]                     ns <- getNamespace("parallel")
[17:28:27.764]                     if (exists("sendData", mode = "function", 
[17:28:27.764]                       envir = ns)) {
[17:28:27.764]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:27.764]                         envir = ns)
[17:28:27.764]                       envir <- sys.frame(frame)
[17:28:27.764]                       master <- NULL
[17:28:27.764]                       while (!identical(envir, .GlobalEnv) && 
[17:28:27.764]                         !identical(envir, emptyenv())) {
[17:28:27.764]                         if (exists("master", mode = "list", envir = envir, 
[17:28:27.764]                           inherits = FALSE)) {
[17:28:27.764]                           master <- get("master", mode = "list", 
[17:28:27.764]                             envir = envir, inherits = FALSE)
[17:28:27.764]                           if (inherits(master, c("SOCKnode", 
[17:28:27.764]                             "SOCK0node"))) {
[17:28:27.764]                             sendCondition <<- function(cond) {
[17:28:27.764]                               data <- list(type = "VALUE", value = cond, 
[17:28:27.764]                                 success = TRUE)
[17:28:27.764]                               parallel_sendData(master, data)
[17:28:27.764]                             }
[17:28:27.764]                             return(sendCondition)
[17:28:27.764]                           }
[17:28:27.764]                         }
[17:28:27.764]                         frame <- frame + 1L
[17:28:27.764]                         envir <- sys.frame(frame)
[17:28:27.764]                       }
[17:28:27.764]                     }
[17:28:27.764]                     sendCondition <<- function(cond) NULL
[17:28:27.764]                   }
[17:28:27.764]                 })
[17:28:27.764]                 withCallingHandlers({
[17:28:27.764]                   {
[17:28:27.764]                     stop(structure(list(message = "boom"), class = c("MyError", 
[17:28:27.764]                       "error", "condition")))
[17:28:27.764]                   }
[17:28:27.764]                 }, immediateCondition = function(cond) {
[17:28:27.764]                   sendCondition <- ...future.makeSendCondition()
[17:28:27.764]                   sendCondition(cond)
[17:28:27.764]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.764]                   {
[17:28:27.764]                     inherits <- base::inherits
[17:28:27.764]                     invokeRestart <- base::invokeRestart
[17:28:27.764]                     is.null <- base::is.null
[17:28:27.764]                     muffled <- FALSE
[17:28:27.764]                     if (inherits(cond, "message")) {
[17:28:27.764]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:27.764]                       if (muffled) 
[17:28:27.764]                         invokeRestart("muffleMessage")
[17:28:27.764]                     }
[17:28:27.764]                     else if (inherits(cond, "warning")) {
[17:28:27.764]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:27.764]                       if (muffled) 
[17:28:27.764]                         invokeRestart("muffleWarning")
[17:28:27.764]                     }
[17:28:27.764]                     else if (inherits(cond, "condition")) {
[17:28:27.764]                       if (!is.null(pattern)) {
[17:28:27.764]                         computeRestarts <- base::computeRestarts
[17:28:27.764]                         grepl <- base::grepl
[17:28:27.764]                         restarts <- computeRestarts(cond)
[17:28:27.764]                         for (restart in restarts) {
[17:28:27.764]                           name <- restart$name
[17:28:27.764]                           if (is.null(name)) 
[17:28:27.764]                             next
[17:28:27.764]                           if (!grepl(pattern, name)) 
[17:28:27.764]                             next
[17:28:27.764]                           invokeRestart(restart)
[17:28:27.764]                           muffled <- TRUE
[17:28:27.764]                           break
[17:28:27.764]                         }
[17:28:27.764]                       }
[17:28:27.764]                     }
[17:28:27.764]                     invisible(muffled)
[17:28:27.764]                   }
[17:28:27.764]                   muffleCondition(cond)
[17:28:27.764]                 })
[17:28:27.764]             }))
[17:28:27.764]             future::FutureResult(value = ...future.value$value, 
[17:28:27.764]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.764]                   ...future.rng), globalenv = if (FALSE) 
[17:28:27.764]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:27.764]                     ...future.globalenv.names))
[17:28:27.764]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:27.764]         }, condition = base::local({
[17:28:27.764]             c <- base::c
[17:28:27.764]             inherits <- base::inherits
[17:28:27.764]             invokeRestart <- base::invokeRestart
[17:28:27.764]             length <- base::length
[17:28:27.764]             list <- base::list
[17:28:27.764]             seq.int <- base::seq.int
[17:28:27.764]             signalCondition <- base::signalCondition
[17:28:27.764]             sys.calls <- base::sys.calls
[17:28:27.764]             `[[` <- base::`[[`
[17:28:27.764]             `+` <- base::`+`
[17:28:27.764]             `<<-` <- base::`<<-`
[17:28:27.764]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:27.764]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:27.764]                   3L)]
[17:28:27.764]             }
[17:28:27.764]             function(cond) {
[17:28:27.764]                 is_error <- inherits(cond, "error")
[17:28:27.764]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:27.764]                   NULL)
[17:28:27.764]                 if (is_error) {
[17:28:27.764]                   sessionInformation <- function() {
[17:28:27.764]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:27.764]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:27.764]                       search = base::search(), system = base::Sys.info())
[17:28:27.764]                   }
[17:28:27.764]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.764]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:27.764]                     cond$call), session = sessionInformation(), 
[17:28:27.764]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:27.764]                   signalCondition(cond)
[17:28:27.764]                 }
[17:28:27.764]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:27.764]                 "immediateCondition"))) {
[17:28:27.764]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:27.764]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.764]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:27.764]                   if (TRUE && !signal) {
[17:28:27.764]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.764]                     {
[17:28:27.764]                       inherits <- base::inherits
[17:28:27.764]                       invokeRestart <- base::invokeRestart
[17:28:27.764]                       is.null <- base::is.null
[17:28:27.764]                       muffled <- FALSE
[17:28:27.764]                       if (inherits(cond, "message")) {
[17:28:27.764]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.764]                         if (muffled) 
[17:28:27.764]                           invokeRestart("muffleMessage")
[17:28:27.764]                       }
[17:28:27.764]                       else if (inherits(cond, "warning")) {
[17:28:27.764]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.764]                         if (muffled) 
[17:28:27.764]                           invokeRestart("muffleWarning")
[17:28:27.764]                       }
[17:28:27.764]                       else if (inherits(cond, "condition")) {
[17:28:27.764]                         if (!is.null(pattern)) {
[17:28:27.764]                           computeRestarts <- base::computeRestarts
[17:28:27.764]                           grepl <- base::grepl
[17:28:27.764]                           restarts <- computeRestarts(cond)
[17:28:27.764]                           for (restart in restarts) {
[17:28:27.764]                             name <- restart$name
[17:28:27.764]                             if (is.null(name)) 
[17:28:27.764]                               next
[17:28:27.764]                             if (!grepl(pattern, name)) 
[17:28:27.764]                               next
[17:28:27.764]                             invokeRestart(restart)
[17:28:27.764]                             muffled <- TRUE
[17:28:27.764]                             break
[17:28:27.764]                           }
[17:28:27.764]                         }
[17:28:27.764]                       }
[17:28:27.764]                       invisible(muffled)
[17:28:27.764]                     }
[17:28:27.764]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.764]                   }
[17:28:27.764]                 }
[17:28:27.764]                 else {
[17:28:27.764]                   if (TRUE) {
[17:28:27.764]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.764]                     {
[17:28:27.764]                       inherits <- base::inherits
[17:28:27.764]                       invokeRestart <- base::invokeRestart
[17:28:27.764]                       is.null <- base::is.null
[17:28:27.764]                       muffled <- FALSE
[17:28:27.764]                       if (inherits(cond, "message")) {
[17:28:27.764]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.764]                         if (muffled) 
[17:28:27.764]                           invokeRestart("muffleMessage")
[17:28:27.764]                       }
[17:28:27.764]                       else if (inherits(cond, "warning")) {
[17:28:27.764]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.764]                         if (muffled) 
[17:28:27.764]                           invokeRestart("muffleWarning")
[17:28:27.764]                       }
[17:28:27.764]                       else if (inherits(cond, "condition")) {
[17:28:27.764]                         if (!is.null(pattern)) {
[17:28:27.764]                           computeRestarts <- base::computeRestarts
[17:28:27.764]                           grepl <- base::grepl
[17:28:27.764]                           restarts <- computeRestarts(cond)
[17:28:27.764]                           for (restart in restarts) {
[17:28:27.764]                             name <- restart$name
[17:28:27.764]                             if (is.null(name)) 
[17:28:27.764]                               next
[17:28:27.764]                             if (!grepl(pattern, name)) 
[17:28:27.764]                               next
[17:28:27.764]                             invokeRestart(restart)
[17:28:27.764]                             muffled <- TRUE
[17:28:27.764]                             break
[17:28:27.764]                           }
[17:28:27.764]                         }
[17:28:27.764]                       }
[17:28:27.764]                       invisible(muffled)
[17:28:27.764]                     }
[17:28:27.764]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.764]                   }
[17:28:27.764]                 }
[17:28:27.764]             }
[17:28:27.764]         }))
[17:28:27.764]     }, error = function(ex) {
[17:28:27.764]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:27.764]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.764]                 ...future.rng), started = ...future.startTime, 
[17:28:27.764]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:27.764]             version = "1.8"), class = "FutureResult")
[17:28:27.764]     }, finally = {
[17:28:27.764]         if (!identical(...future.workdir, getwd())) 
[17:28:27.764]             setwd(...future.workdir)
[17:28:27.764]         {
[17:28:27.764]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:27.764]                 ...future.oldOptions$nwarnings <- NULL
[17:28:27.764]             }
[17:28:27.764]             base::options(...future.oldOptions)
[17:28:27.764]             if (.Platform$OS.type == "windows") {
[17:28:27.764]                 old_names <- names(...future.oldEnvVars)
[17:28:27.764]                 envs <- base::Sys.getenv()
[17:28:27.764]                 names <- names(envs)
[17:28:27.764]                 common <- intersect(names, old_names)
[17:28:27.764]                 added <- setdiff(names, old_names)
[17:28:27.764]                 removed <- setdiff(old_names, names)
[17:28:27.764]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:27.764]                   envs[common]]
[17:28:27.764]                 NAMES <- toupper(changed)
[17:28:27.764]                 args <- list()
[17:28:27.764]                 for (kk in seq_along(NAMES)) {
[17:28:27.764]                   name <- changed[[kk]]
[17:28:27.764]                   NAME <- NAMES[[kk]]
[17:28:27.764]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.764]                     next
[17:28:27.764]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.764]                 }
[17:28:27.764]                 NAMES <- toupper(added)
[17:28:27.764]                 for (kk in seq_along(NAMES)) {
[17:28:27.764]                   name <- added[[kk]]
[17:28:27.764]                   NAME <- NAMES[[kk]]
[17:28:27.764]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.764]                     next
[17:28:27.764]                   args[[name]] <- ""
[17:28:27.764]                 }
[17:28:27.764]                 NAMES <- toupper(removed)
[17:28:27.764]                 for (kk in seq_along(NAMES)) {
[17:28:27.764]                   name <- removed[[kk]]
[17:28:27.764]                   NAME <- NAMES[[kk]]
[17:28:27.764]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.764]                     next
[17:28:27.764]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.764]                 }
[17:28:27.764]                 if (length(args) > 0) 
[17:28:27.764]                   base::do.call(base::Sys.setenv, args = args)
[17:28:27.764]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:27.764]             }
[17:28:27.764]             else {
[17:28:27.764]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:27.764]             }
[17:28:27.764]             {
[17:28:27.764]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:27.764]                   0L) {
[17:28:27.764]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:27.764]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:27.764]                   base::options(opts)
[17:28:27.764]                 }
[17:28:27.764]                 {
[17:28:27.764]                   {
[17:28:27.764]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:27.764]                     NULL
[17:28:27.764]                   }
[17:28:27.764]                   options(future.plan = NULL)
[17:28:27.764]                   if (is.na(NA_character_)) 
[17:28:27.764]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.764]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:27.764]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:27.764]                     .init = FALSE)
[17:28:27.764]                 }
[17:28:27.764]             }
[17:28:27.764]         }
[17:28:27.764]     })
[17:28:27.764]     if (TRUE) {
[17:28:27.764]         base::sink(type = "output", split = FALSE)
[17:28:27.764]         if (TRUE) {
[17:28:27.764]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:27.764]         }
[17:28:27.764]         else {
[17:28:27.764]             ...future.result["stdout"] <- base::list(NULL)
[17:28:27.764]         }
[17:28:27.764]         base::close(...future.stdout)
[17:28:27.764]         ...future.stdout <- NULL
[17:28:27.764]     }
[17:28:27.764]     ...future.result$conditions <- ...future.conditions
[17:28:27.764]     ...future.result$finished <- base::Sys.time()
[17:28:27.764]     ...future.result
[17:28:27.764] }
[17:28:27.772] MultisessionFuture started
MultisessionFuture:
Label: '<none>'
Expression:
{
    stop(structure(list(message = "boom"), class = c("MyError", 
        "error", "condition")))
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[17:28:27.803] receiveMessageFromWorker() for ClusterFuture ...
[17:28:27.804] - Validating connection of MultisessionFuture
[17:28:27.805] - received message: FutureResult
[17:28:27.805] - Received FutureResult
[17:28:27.805] - Erased future from FutureRegistry
[17:28:27.806] result() for ClusterFuture ...
[17:28:27.806] - result already collected: FutureResult
[17:28:27.806] result() for ClusterFuture ... done
[17:28:27.807] signalConditions() ...
[17:28:27.807]  - include = 'immediateCondition'
[17:28:27.807]  - exclude = 
[17:28:27.808]  - resignal = FALSE
[17:28:27.808]  - Number of conditions: 1
[17:28:27.808] signalConditions() ... done
[17:28:27.809] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 12734a8a-480b-f2a5-0c96-45c13d81d854
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:27.809] result() for ClusterFuture ...
[17:28:27.809] - result already collected: FutureResult
[17:28:27.810] result() for ClusterFuture ... done
[17:28:27.810] result() for ClusterFuture ...
[17:28:27.810] - result already collected: FutureResult
[17:28:27.810] result() for ClusterFuture ... done
[17:28:27.811] signalConditions() ...
[17:28:27.811]  - include = 'immediateCondition'
[17:28:27.811]  - exclude = 
[17:28:27.812]  - resignal = FALSE
[17:28:27.812]  - Number of conditions: 1
[17:28:27.812] signalConditions() ... done
<MyError: boom>
[17:28:27.813] result() for ClusterFuture ...
[17:28:27.813] - result already collected: FutureResult
[17:28:27.814] result() for ClusterFuture ... done
[17:28:27.814] result() for ClusterFuture ...
[17:28:27.814] - result already collected: FutureResult
[17:28:27.815] result() for ClusterFuture ... done
[17:28:27.815] signalConditions() ...
[17:28:27.815]  - include = 'immediateCondition'
[17:28:27.815]  - exclude = 
[17:28:27.816]  - resignal = FALSE
[17:28:27.816]  - Number of conditions: 1
[17:28:27.816] signalConditions() ... done
[17:28:27.817] Future state: 'finished'
[17:28:27.817] result() for ClusterFuture ...
[17:28:27.817] - result already collected: FutureResult
[17:28:27.818] result() for ClusterFuture ... done
[17:28:27.818] signalConditions() ...
[17:28:27.818]  - include = 'condition'
[17:28:27.819]  - exclude = 'immediateCondition'
[17:28:27.819]  - resignal = TRUE
[17:28:27.819]  - Number of conditions: 1
[17:28:27.820]  - Condition #1: 'MyError', 'error', 'condition'
[17:28:27.820] signalConditions() ... done
Testing with 2 cores ... DONE
> 
> 
> message("*** multisession() - too large globals ... DONE")
*** multisession() - too large globals ... DONE
> 
> message("*** multisession(..., workers = 1L) ...")
*** multisession(..., workers = 1L) ...
> 
> a <- 2
> b <- 3
> yTruth <- a * b
> 
> f <- multisession({ a * b }, globals = TRUE, workers = 1L)
[17:28:27.828] getGlobalsAndPackages() ...
[17:28:27.828] Searching for globals...
[17:28:27.831] - globals found: [4] '{', '*', 'a', 'b'
[17:28:27.831] Searching for globals ... DONE
[17:28:27.831] Resolving globals: FALSE
[17:28:27.832] The total size of the 2 globals is 78 bytes (78 bytes)
[17:28:27.833] The total size of the 2 globals exported for future expression ('{; a * b; }') is 78 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'a' (39 bytes of class 'numeric') and 'b' (39 bytes of class 'numeric')
[17:28:27.833] - globals: [2] 'a', 'b'
[17:28:27.834] 
[17:28:27.834] getGlobalsAndPackages() ... DONE
> rm(list = c("a", "b"))
> 
> v <- value(f)
[17:28:27.835] Packages needed by the future expression (n = 0): <none>
[17:28:27.835] Packages needed by future strategies (n = 0): <none>
[17:28:27.836] {
[17:28:27.836]     {
[17:28:27.836]         {
[17:28:27.836]             ...future.startTime <- base::Sys.time()
[17:28:27.836]             {
[17:28:27.836]                 {
[17:28:27.836]                   {
[17:28:27.836]                     base::local({
[17:28:27.836]                       has_future <- base::requireNamespace("future", 
[17:28:27.836]                         quietly = TRUE)
[17:28:27.836]                       if (has_future) {
[17:28:27.836]                         ns <- base::getNamespace("future")
[17:28:27.836]                         version <- ns[[".package"]][["version"]]
[17:28:27.836]                         if (is.null(version)) 
[17:28:27.836]                           version <- utils::packageVersion("future")
[17:28:27.836]                       }
[17:28:27.836]                       else {
[17:28:27.836]                         version <- NULL
[17:28:27.836]                       }
[17:28:27.836]                       if (!has_future || version < "1.8.0") {
[17:28:27.836]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:27.836]                           "", base::R.version$version.string), 
[17:28:27.836]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:27.836]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:27.836]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:27.836]                             "release", "version")], collapse = " "), 
[17:28:27.836]                           hostname = base::Sys.info()[["nodename"]])
[17:28:27.836]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:27.836]                           info)
[17:28:27.836]                         info <- base::paste(info, collapse = "; ")
[17:28:27.836]                         if (!has_future) {
[17:28:27.836]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:27.836]                             info)
[17:28:27.836]                         }
[17:28:27.836]                         else {
[17:28:27.836]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:27.836]                             info, version)
[17:28:27.836]                         }
[17:28:27.836]                         base::stop(msg)
[17:28:27.836]                       }
[17:28:27.836]                     })
[17:28:27.836]                   }
[17:28:27.836]                   ...future.strategy.old <- future::plan("list")
[17:28:27.836]                   options(future.plan = NULL)
[17:28:27.836]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.836]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:27.836]                 }
[17:28:27.836]                 ...future.workdir <- getwd()
[17:28:27.836]             }
[17:28:27.836]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:27.836]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:27.836]         }
[17:28:27.836]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:27.836]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:27.836]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:27.836]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:27.836]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:27.836]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:27.836]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:27.836]             base::names(...future.oldOptions))
[17:28:27.836]     }
[17:28:27.836]     if (FALSE) {
[17:28:27.836]     }
[17:28:27.836]     else {
[17:28:27.836]         if (TRUE) {
[17:28:27.836]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:27.836]                 open = "w")
[17:28:27.836]         }
[17:28:27.836]         else {
[17:28:27.836]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:27.836]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:27.836]         }
[17:28:27.836]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:27.836]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:27.836]             base::sink(type = "output", split = FALSE)
[17:28:27.836]             base::close(...future.stdout)
[17:28:27.836]         }, add = TRUE)
[17:28:27.836]     }
[17:28:27.836]     ...future.frame <- base::sys.nframe()
[17:28:27.836]     ...future.conditions <- base::list()
[17:28:27.836]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:27.836]     if (FALSE) {
[17:28:27.836]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:27.836]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:27.836]     }
[17:28:27.836]     ...future.result <- base::tryCatch({
[17:28:27.836]         base::withCallingHandlers({
[17:28:27.836]             ...future.value <- base::withVisible(base::local({
[17:28:27.836]                 a * b
[17:28:27.836]             }))
[17:28:27.836]             future::FutureResult(value = ...future.value$value, 
[17:28:27.836]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.836]                   ...future.rng), globalenv = if (FALSE) 
[17:28:27.836]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:27.836]                     ...future.globalenv.names))
[17:28:27.836]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:27.836]         }, condition = base::local({
[17:28:27.836]             c <- base::c
[17:28:27.836]             inherits <- base::inherits
[17:28:27.836]             invokeRestart <- base::invokeRestart
[17:28:27.836]             length <- base::length
[17:28:27.836]             list <- base::list
[17:28:27.836]             seq.int <- base::seq.int
[17:28:27.836]             signalCondition <- base::signalCondition
[17:28:27.836]             sys.calls <- base::sys.calls
[17:28:27.836]             `[[` <- base::`[[`
[17:28:27.836]             `+` <- base::`+`
[17:28:27.836]             `<<-` <- base::`<<-`
[17:28:27.836]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:27.836]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:27.836]                   3L)]
[17:28:27.836]             }
[17:28:27.836]             function(cond) {
[17:28:27.836]                 is_error <- inherits(cond, "error")
[17:28:27.836]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:27.836]                   NULL)
[17:28:27.836]                 if (is_error) {
[17:28:27.836]                   sessionInformation <- function() {
[17:28:27.836]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:27.836]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:27.836]                       search = base::search(), system = base::Sys.info())
[17:28:27.836]                   }
[17:28:27.836]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.836]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:27.836]                     cond$call), session = sessionInformation(), 
[17:28:27.836]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:27.836]                   signalCondition(cond)
[17:28:27.836]                 }
[17:28:27.836]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:27.836]                 "immediateCondition"))) {
[17:28:27.836]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:27.836]                   ...future.conditions[[length(...future.conditions) + 
[17:28:27.836]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:27.836]                   if (TRUE && !signal) {
[17:28:27.836]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.836]                     {
[17:28:27.836]                       inherits <- base::inherits
[17:28:27.836]                       invokeRestart <- base::invokeRestart
[17:28:27.836]                       is.null <- base::is.null
[17:28:27.836]                       muffled <- FALSE
[17:28:27.836]                       if (inherits(cond, "message")) {
[17:28:27.836]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.836]                         if (muffled) 
[17:28:27.836]                           invokeRestart("muffleMessage")
[17:28:27.836]                       }
[17:28:27.836]                       else if (inherits(cond, "warning")) {
[17:28:27.836]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.836]                         if (muffled) 
[17:28:27.836]                           invokeRestart("muffleWarning")
[17:28:27.836]                       }
[17:28:27.836]                       else if (inherits(cond, "condition")) {
[17:28:27.836]                         if (!is.null(pattern)) {
[17:28:27.836]                           computeRestarts <- base::computeRestarts
[17:28:27.836]                           grepl <- base::grepl
[17:28:27.836]                           restarts <- computeRestarts(cond)
[17:28:27.836]                           for (restart in restarts) {
[17:28:27.836]                             name <- restart$name
[17:28:27.836]                             if (is.null(name)) 
[17:28:27.836]                               next
[17:28:27.836]                             if (!grepl(pattern, name)) 
[17:28:27.836]                               next
[17:28:27.836]                             invokeRestart(restart)
[17:28:27.836]                             muffled <- TRUE
[17:28:27.836]                             break
[17:28:27.836]                           }
[17:28:27.836]                         }
[17:28:27.836]                       }
[17:28:27.836]                       invisible(muffled)
[17:28:27.836]                     }
[17:28:27.836]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.836]                   }
[17:28:27.836]                 }
[17:28:27.836]                 else {
[17:28:27.836]                   if (TRUE) {
[17:28:27.836]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:27.836]                     {
[17:28:27.836]                       inherits <- base::inherits
[17:28:27.836]                       invokeRestart <- base::invokeRestart
[17:28:27.836]                       is.null <- base::is.null
[17:28:27.836]                       muffled <- FALSE
[17:28:27.836]                       if (inherits(cond, "message")) {
[17:28:27.836]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:27.836]                         if (muffled) 
[17:28:27.836]                           invokeRestart("muffleMessage")
[17:28:27.836]                       }
[17:28:27.836]                       else if (inherits(cond, "warning")) {
[17:28:27.836]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:27.836]                         if (muffled) 
[17:28:27.836]                           invokeRestart("muffleWarning")
[17:28:27.836]                       }
[17:28:27.836]                       else if (inherits(cond, "condition")) {
[17:28:27.836]                         if (!is.null(pattern)) {
[17:28:27.836]                           computeRestarts <- base::computeRestarts
[17:28:27.836]                           grepl <- base::grepl
[17:28:27.836]                           restarts <- computeRestarts(cond)
[17:28:27.836]                           for (restart in restarts) {
[17:28:27.836]                             name <- restart$name
[17:28:27.836]                             if (is.null(name)) 
[17:28:27.836]                               next
[17:28:27.836]                             if (!grepl(pattern, name)) 
[17:28:27.836]                               next
[17:28:27.836]                             invokeRestart(restart)
[17:28:27.836]                             muffled <- TRUE
[17:28:27.836]                             break
[17:28:27.836]                           }
[17:28:27.836]                         }
[17:28:27.836]                       }
[17:28:27.836]                       invisible(muffled)
[17:28:27.836]                     }
[17:28:27.836]                     muffleCondition(cond, pattern = "^muffle")
[17:28:27.836]                   }
[17:28:27.836]                 }
[17:28:27.836]             }
[17:28:27.836]         }))
[17:28:27.836]     }, error = function(ex) {
[17:28:27.836]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:27.836]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:27.836]                 ...future.rng), started = ...future.startTime, 
[17:28:27.836]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:27.836]             version = "1.8"), class = "FutureResult")
[17:28:27.836]     }, finally = {
[17:28:27.836]         if (!identical(...future.workdir, getwd())) 
[17:28:27.836]             setwd(...future.workdir)
[17:28:27.836]         {
[17:28:27.836]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:27.836]                 ...future.oldOptions$nwarnings <- NULL
[17:28:27.836]             }
[17:28:27.836]             base::options(...future.oldOptions)
[17:28:27.836]             if (.Platform$OS.type == "windows") {
[17:28:27.836]                 old_names <- names(...future.oldEnvVars)
[17:28:27.836]                 envs <- base::Sys.getenv()
[17:28:27.836]                 names <- names(envs)
[17:28:27.836]                 common <- intersect(names, old_names)
[17:28:27.836]                 added <- setdiff(names, old_names)
[17:28:27.836]                 removed <- setdiff(old_names, names)
[17:28:27.836]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:27.836]                   envs[common]]
[17:28:27.836]                 NAMES <- toupper(changed)
[17:28:27.836]                 args <- list()
[17:28:27.836]                 for (kk in seq_along(NAMES)) {
[17:28:27.836]                   name <- changed[[kk]]
[17:28:27.836]                   NAME <- NAMES[[kk]]
[17:28:27.836]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.836]                     next
[17:28:27.836]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.836]                 }
[17:28:27.836]                 NAMES <- toupper(added)
[17:28:27.836]                 for (kk in seq_along(NAMES)) {
[17:28:27.836]                   name <- added[[kk]]
[17:28:27.836]                   NAME <- NAMES[[kk]]
[17:28:27.836]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.836]                     next
[17:28:27.836]                   args[[name]] <- ""
[17:28:27.836]                 }
[17:28:27.836]                 NAMES <- toupper(removed)
[17:28:27.836]                 for (kk in seq_along(NAMES)) {
[17:28:27.836]                   name <- removed[[kk]]
[17:28:27.836]                   NAME <- NAMES[[kk]]
[17:28:27.836]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:27.836]                     next
[17:28:27.836]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:27.836]                 }
[17:28:27.836]                 if (length(args) > 0) 
[17:28:27.836]                   base::do.call(base::Sys.setenv, args = args)
[17:28:27.836]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:27.836]             }
[17:28:27.836]             else {
[17:28:27.836]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:27.836]             }
[17:28:27.836]             {
[17:28:27.836]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:27.836]                   0L) {
[17:28:27.836]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:27.836]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:27.836]                   base::options(opts)
[17:28:27.836]                 }
[17:28:27.836]                 {
[17:28:27.836]                   {
[17:28:27.836]                     NULL
[17:28:27.836]                     RNGkind("Mersenne-Twister")
[17:28:27.836]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:27.836]                       inherits = FALSE)
[17:28:27.836]                   }
[17:28:27.836]                   options(future.plan = NULL)
[17:28:27.836]                   if (is.na(NA_character_)) 
[17:28:27.836]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:27.836]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:27.836]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:27.836]                     .init = FALSE)
[17:28:27.836]                 }
[17:28:27.836]             }
[17:28:27.836]         }
[17:28:27.836]     })
[17:28:27.836]     if (TRUE) {
[17:28:27.836]         base::sink(type = "output", split = FALSE)
[17:28:27.836]         if (TRUE) {
[17:28:27.836]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:27.836]         }
[17:28:27.836]         else {
[17:28:27.836]             ...future.result["stdout"] <- base::list(NULL)
[17:28:27.836]         }
[17:28:27.836]         base::close(...future.stdout)
[17:28:27.836]         ...future.stdout <- NULL
[17:28:27.836]     }
[17:28:27.836]     ...future.result$conditions <- ...future.conditions
[17:28:27.836]     ...future.result$finished <- base::Sys.time()
[17:28:27.836]     ...future.result
[17:28:27.836] }
[17:28:27.842] assign_globals() ...
[17:28:27.842] List of 2
[17:28:27.842]  $ a: num 2
[17:28:27.842]  $ b: num 3
[17:28:27.842]  - attr(*, "where")=List of 2
[17:28:27.842]   ..$ a:<environment: R_EmptyEnv> 
[17:28:27.842]   ..$ b:<environment: R_EmptyEnv> 
[17:28:27.842]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:27.842]  - attr(*, "resolved")= logi FALSE
[17:28:27.842]  - attr(*, "total_size")= int 78
[17:28:27.848] - copied 'a' to environment
[17:28:27.848] - copied 'b' to environment
[17:28:27.849] assign_globals() ... done
[17:28:27.849] plan(): Setting new future strategy stack:
[17:28:27.850] List of future strategies:
[17:28:27.850] 1. sequential:
[17:28:27.850]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:27.850]    - tweaked: FALSE
[17:28:27.850]    - call: NULL
[17:28:27.851] plan(): nbrOfWorkers() = 1
[17:28:27.853] plan(): Setting new future strategy stack:
[17:28:27.853] List of future strategies:
[17:28:27.853] 1. sequential:
[17:28:27.853]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:27.853]    - tweaked: FALSE
[17:28:27.853]    - call: future::plan("sequential")
[17:28:27.854] plan(): nbrOfWorkers() = 1
[17:28:27.854] SequentialFuture started (and completed)
> print(v)
[1] 6
> stopifnot(v == yTruth)
> 
> message("*** multisession(..., workers = 1L) ... DONE")
*** multisession(..., workers = 1L) ... DONE
> 
> 
> message("*** multisession(..., gc = TRUE) ...")
*** multisession(..., gc = TRUE) ...
> plan(multisession, workers = 2L)
[17:28:27.856] plan(): Setting new future strategy stack:
[17:28:27.856] List of future strategies:
[17:28:27.856] 1. multisession:
[17:28:27.856]    - args: function (..., workers = 2L, envir = parent.frame())
[17:28:27.856]    - tweaked: TRUE
[17:28:27.856]    - call: plan(multisession, workers = 2L)
[17:28:27.879] plan(): plan_init() of 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[17:28:27.879] multisession:
[17:28:27.879] - args: function (..., workers = 2L, envir = parent.frame())
[17:28:27.879] - tweaked: TRUE
[17:28:27.879] - call: plan(multisession, workers = 2L)
[17:28:27.880] getGlobalsAndPackages() ...
[17:28:27.881] Not searching for globals
[17:28:27.881] - globals: [0] <none>
[17:28:27.881] getGlobalsAndPackages() ... DONE
[17:28:27.882] [local output] makeClusterPSOCK() ...
[17:28:27.886] [local output] Workers: [n = 2] 'localhost', 'localhost'
[17:28:27.889] [local output] Base port: 37945
[17:28:27.890] [local output] Getting setup options for 2 cluster nodes ...
[17:28:27.890] [local output]  - Node #1 of 2 ...
[17:28:27.891] [local output] localMachine=TRUE => revtunnel=FALSE

[17:28:27.893] [local output] Rscript port: 37945

[17:28:27.894] [local output]  - Node #2 of 2 ...
[17:28:27.895] [local output] localMachine=TRUE => revtunnel=FALSE

[17:28:27.896] [local output] Rscript port: 37945

[17:28:27.897] [local output] Getting setup options for 2 cluster nodes ... done
[17:28:27.897] [local output]  - Parallel setup requested for some PSOCK nodes
[17:28:27.898] [local output] Setting up PSOCK nodes in parallel
[17:28:27.898] List of 36
[17:28:27.898]  $ worker          : chr "localhost"
[17:28:27.898]   ..- attr(*, "localhost")= logi TRUE
[17:28:27.898]  $ master          : chr "localhost"
[17:28:27.898]  $ port            : int 37945
[17:28:27.898]  $ connectTimeout  : num 120
[17:28:27.898]  $ timeout         : num 120
[17:28:27.898]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[17:28:27.898]  $ homogeneous     : logi TRUE
[17:28:27.898]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=multisession.R:85924:CRANWIN3:CR"| __truncated__
[17:28:27.898]  $ rscript_envs    : NULL
[17:28:27.898]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda" "D:/RCompile/recent/R/library"
[17:28:27.898]  $ rscript_startup : NULL
[17:28:27.898]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[17:28:27.898]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:28:27.898]  $ methods         : logi TRUE
[17:28:27.898]  $ socketOptions   : chr "no-delay"
[17:28:27.898]  $ useXDR          : logi FALSE
[17:28:27.898]  $ outfile         : chr "/dev/null"
[17:28:27.898]  $ renice          : int NA
[17:28:27.898]  $ rshcmd          : NULL
[17:28:27.898]  $ user            : chr(0) 
[17:28:27.898]  $ revtunnel       : logi FALSE
[17:28:27.898]  $ rshlogfile      : NULL
[17:28:27.898]  $ rshopts         : chr(0) 
[17:28:27.898]  $ rank            : int 1
[17:28:27.898]  $ manual          : logi FALSE
[17:28:27.898]  $ dryrun          : logi FALSE
[17:28:27.898]  $ quiet           : logi FALSE
[17:28:27.898]  $ setup_strategy  : chr "parallel"
[17:28:27.898]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:28:27.898]  $ pidfile         : chr "D:/temp/Rtmp6N6urL/worker.rank=1.parallelly.parent=85924.14fa41c286640.pid"
[17:28:27.898]  $ rshcmd_label    : NULL
[17:28:27.898]  $ rsh_call        : NULL
[17:28:27.898]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:28:27.898]  $ localMachine    : logi TRUE
[17:28:27.898]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[17:28:27.898]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[17:28:27.898]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[17:28:27.898]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[17:28:27.898]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[17:28:27.898]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[17:28:27.898]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[17:28:27.898]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[17:28:27.898]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[17:28:27.898]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[17:28:27.898]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[17:28:27.898]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[17:28:27.898]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[17:28:27.898]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[17:28:27.898]  $ arguments       :List of 28
[17:28:27.898]   ..$ worker          : chr "localhost"
[17:28:27.898]   ..$ master          : NULL
[17:28:27.898]   ..$ port            : int 37945
[17:28:27.898]   ..$ connectTimeout  : num 120
[17:28:27.898]   ..$ timeout         : num 120
[17:28:27.898]   ..$ rscript         : NULL
[17:28:27.898]   ..$ homogeneous     : NULL
[17:28:27.898]   ..$ rscript_args    : NULL
[17:28:27.898]   ..$ rscript_envs    : NULL
[17:28:27.898]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda" "D:/RCompile/recent/R/library"
[17:28:27.898]   ..$ rscript_startup : NULL
[17:28:27.898]   ..$ rscript_sh      : chr "auto"
[17:28:27.898]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:28:27.898]   ..$ methods         : logi TRUE
[17:28:27.898]   ..$ socketOptions   : chr "no-delay"
[17:28:27.898]   ..$ useXDR          : logi FALSE
[17:28:27.898]   ..$ outfile         : chr "/dev/null"
[17:28:27.898]   ..$ renice          : int NA
[17:28:27.898]   ..$ rshcmd          : NULL
[17:28:27.898]   ..$ user            : NULL
[17:28:27.898]   ..$ revtunnel       : logi NA
[17:28:27.898]   ..$ rshlogfile      : NULL
[17:28:27.898]   ..$ rshopts         : NULL
[17:28:27.898]   ..$ rank            : int 1
[17:28:27.898]   ..$ manual          : logi FALSE
[17:28:27.898]   ..$ dryrun          : logi FALSE
[17:28:27.898]   ..$ quiet           : logi FALSE
[17:28:27.898]   ..$ setup_strategy  : chr "parallel"
[17:28:27.898]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[17:28:27.928] [local output] System call to launch all workers:
[17:28:27.928] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=multisession.R:85924:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/Rtmp6N6urL/worker.rank=1.parallelly.parent=85924.14fa41c286640.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=37945 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[17:28:27.928] [local output] Starting PSOCK main server
[17:28:27.935] [local output] Workers launched
[17:28:27.935] [local output] Waiting for workers to connect back
[17:28:27.935]  - [local output] 0 workers out of 2 ready
[17:28:28.189]  - [local output] 0 workers out of 2 ready
[17:28:28.190]  - [local output] 1 workers out of 2 ready
[17:28:28.223]  - [local output] 1 workers out of 2 ready
[17:28:28.224]  - [local output] 2 workers out of 2 ready
[17:28:28.224] [local output] Launching of 2 workers completed
[17:28:28.224] [local output] Number of nodes in cluster: 2
[17:28:28.228] [local output] Collecting session information from 2 workers
[17:28:28.229] [local output]  - Worker #1 of 2
[17:28:28.230] [local output]  - Worker #2 of 2
[17:28:28.230] [local output] makeClusterPSOCK() ... done
[17:28:28.246] Packages needed by the future expression (n = 0): <none>
[17:28:28.246] Packages needed by future strategies (n = 0): <none>
[17:28:28.247] {
[17:28:28.247]     {
[17:28:28.247]         {
[17:28:28.247]             ...future.startTime <- base::Sys.time()
[17:28:28.247]             {
[17:28:28.247]                 {
[17:28:28.247]                   {
[17:28:28.247]                     {
[17:28:28.247]                       base::local({
[17:28:28.247]                         has_future <- base::requireNamespace("future", 
[17:28:28.247]                           quietly = TRUE)
[17:28:28.247]                         if (has_future) {
[17:28:28.247]                           ns <- base::getNamespace("future")
[17:28:28.247]                           version <- ns[[".package"]][["version"]]
[17:28:28.247]                           if (is.null(version)) 
[17:28:28.247]                             version <- utils::packageVersion("future")
[17:28:28.247]                         }
[17:28:28.247]                         else {
[17:28:28.247]                           version <- NULL
[17:28:28.247]                         }
[17:28:28.247]                         if (!has_future || version < "1.8.0") {
[17:28:28.247]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:28.247]                             "", base::R.version$version.string), 
[17:28:28.247]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:28.247]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:28.247]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:28.247]                               "release", "version")], collapse = " "), 
[17:28:28.247]                             hostname = base::Sys.info()[["nodename"]])
[17:28:28.247]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:28.247]                             info)
[17:28:28.247]                           info <- base::paste(info, collapse = "; ")
[17:28:28.247]                           if (!has_future) {
[17:28:28.247]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:28.247]                               info)
[17:28:28.247]                           }
[17:28:28.247]                           else {
[17:28:28.247]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:28.247]                               info, version)
[17:28:28.247]                           }
[17:28:28.247]                           base::stop(msg)
[17:28:28.247]                         }
[17:28:28.247]                       })
[17:28:28.247]                     }
[17:28:28.247]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:28.247]                     base::options(mc.cores = 1L)
[17:28:28.247]                   }
[17:28:28.247]                   ...future.strategy.old <- future::plan("list")
[17:28:28.247]                   options(future.plan = NULL)
[17:28:28.247]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:28.247]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:28.247]                 }
[17:28:28.247]                 ...future.workdir <- getwd()
[17:28:28.247]             }
[17:28:28.247]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:28.247]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:28.247]         }
[17:28:28.247]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:28.247]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:28.247]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:28.247]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:28.247]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:28.247]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:28.247]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:28.247]             base::names(...future.oldOptions))
[17:28:28.247]     }
[17:28:28.247]     if (FALSE) {
[17:28:28.247]     }
[17:28:28.247]     else {
[17:28:28.247]         if (TRUE) {
[17:28:28.247]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:28.247]                 open = "w")
[17:28:28.247]         }
[17:28:28.247]         else {
[17:28:28.247]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:28.247]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:28.247]         }
[17:28:28.247]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:28.247]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:28.247]             base::sink(type = "output", split = FALSE)
[17:28:28.247]             base::close(...future.stdout)
[17:28:28.247]         }, add = TRUE)
[17:28:28.247]     }
[17:28:28.247]     ...future.frame <- base::sys.nframe()
[17:28:28.247]     ...future.conditions <- base::list()
[17:28:28.247]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:28.247]     if (FALSE) {
[17:28:28.247]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:28.247]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:28.247]     }
[17:28:28.247]     ...future.result <- base::tryCatch({
[17:28:28.247]         base::withCallingHandlers({
[17:28:28.247]             ...future.value <- base::withVisible(base::local({
[17:28:28.247]                 ...future.makeSendCondition <- base::local({
[17:28:28.247]                   sendCondition <- NULL
[17:28:28.247]                   function(frame = 1L) {
[17:28:28.247]                     if (is.function(sendCondition)) 
[17:28:28.247]                       return(sendCondition)
[17:28:28.247]                     ns <- getNamespace("parallel")
[17:28:28.247]                     if (exists("sendData", mode = "function", 
[17:28:28.247]                       envir = ns)) {
[17:28:28.247]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:28.247]                         envir = ns)
[17:28:28.247]                       envir <- sys.frame(frame)
[17:28:28.247]                       master <- NULL
[17:28:28.247]                       while (!identical(envir, .GlobalEnv) && 
[17:28:28.247]                         !identical(envir, emptyenv())) {
[17:28:28.247]                         if (exists("master", mode = "list", envir = envir, 
[17:28:28.247]                           inherits = FALSE)) {
[17:28:28.247]                           master <- get("master", mode = "list", 
[17:28:28.247]                             envir = envir, inherits = FALSE)
[17:28:28.247]                           if (inherits(master, c("SOCKnode", 
[17:28:28.247]                             "SOCK0node"))) {
[17:28:28.247]                             sendCondition <<- function(cond) {
[17:28:28.247]                               data <- list(type = "VALUE", value = cond, 
[17:28:28.247]                                 success = TRUE)
[17:28:28.247]                               parallel_sendData(master, data)
[17:28:28.247]                             }
[17:28:28.247]                             return(sendCondition)
[17:28:28.247]                           }
[17:28:28.247]                         }
[17:28:28.247]                         frame <- frame + 1L
[17:28:28.247]                         envir <- sys.frame(frame)
[17:28:28.247]                       }
[17:28:28.247]                     }
[17:28:28.247]                     sendCondition <<- function(cond) NULL
[17:28:28.247]                   }
[17:28:28.247]                 })
[17:28:28.247]                 withCallingHandlers({
[17:28:28.247]                   NA
[17:28:28.247]                 }, immediateCondition = function(cond) {
[17:28:28.247]                   sendCondition <- ...future.makeSendCondition()
[17:28:28.247]                   sendCondition(cond)
[17:28:28.247]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:28.247]                   {
[17:28:28.247]                     inherits <- base::inherits
[17:28:28.247]                     invokeRestart <- base::invokeRestart
[17:28:28.247]                     is.null <- base::is.null
[17:28:28.247]                     muffled <- FALSE
[17:28:28.247]                     if (inherits(cond, "message")) {
[17:28:28.247]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:28.247]                       if (muffled) 
[17:28:28.247]                         invokeRestart("muffleMessage")
[17:28:28.247]                     }
[17:28:28.247]                     else if (inherits(cond, "warning")) {
[17:28:28.247]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:28.247]                       if (muffled) 
[17:28:28.247]                         invokeRestart("muffleWarning")
[17:28:28.247]                     }
[17:28:28.247]                     else if (inherits(cond, "condition")) {
[17:28:28.247]                       if (!is.null(pattern)) {
[17:28:28.247]                         computeRestarts <- base::computeRestarts
[17:28:28.247]                         grepl <- base::grepl
[17:28:28.247]                         restarts <- computeRestarts(cond)
[17:28:28.247]                         for (restart in restarts) {
[17:28:28.247]                           name <- restart$name
[17:28:28.247]                           if (is.null(name)) 
[17:28:28.247]                             next
[17:28:28.247]                           if (!grepl(pattern, name)) 
[17:28:28.247]                             next
[17:28:28.247]                           invokeRestart(restart)
[17:28:28.247]                           muffled <- TRUE
[17:28:28.247]                           break
[17:28:28.247]                         }
[17:28:28.247]                       }
[17:28:28.247]                     }
[17:28:28.247]                     invisible(muffled)
[17:28:28.247]                   }
[17:28:28.247]                   muffleCondition(cond)
[17:28:28.247]                 })
[17:28:28.247]             }))
[17:28:28.247]             future::FutureResult(value = ...future.value$value, 
[17:28:28.247]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:28.247]                   ...future.rng), globalenv = if (FALSE) 
[17:28:28.247]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:28.247]                     ...future.globalenv.names))
[17:28:28.247]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:28.247]         }, condition = base::local({
[17:28:28.247]             c <- base::c
[17:28:28.247]             inherits <- base::inherits
[17:28:28.247]             invokeRestart <- base::invokeRestart
[17:28:28.247]             length <- base::length
[17:28:28.247]             list <- base::list
[17:28:28.247]             seq.int <- base::seq.int
[17:28:28.247]             signalCondition <- base::signalCondition
[17:28:28.247]             sys.calls <- base::sys.calls
[17:28:28.247]             `[[` <- base::`[[`
[17:28:28.247]             `+` <- base::`+`
[17:28:28.247]             `<<-` <- base::`<<-`
[17:28:28.247]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:28.247]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:28.247]                   3L)]
[17:28:28.247]             }
[17:28:28.247]             function(cond) {
[17:28:28.247]                 is_error <- inherits(cond, "error")
[17:28:28.247]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:28.247]                   NULL)
[17:28:28.247]                 if (is_error) {
[17:28:28.247]                   sessionInformation <- function() {
[17:28:28.247]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:28.247]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:28.247]                       search = base::search(), system = base::Sys.info())
[17:28:28.247]                   }
[17:28:28.247]                   ...future.conditions[[length(...future.conditions) + 
[17:28:28.247]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:28.247]                     cond$call), session = sessionInformation(), 
[17:28:28.247]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:28.247]                   signalCondition(cond)
[17:28:28.247]                 }
[17:28:28.247]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:28.247]                 "immediateCondition"))) {
[17:28:28.247]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:28.247]                   ...future.conditions[[length(...future.conditions) + 
[17:28:28.247]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:28.247]                   if (TRUE && !signal) {
[17:28:28.247]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:28.247]                     {
[17:28:28.247]                       inherits <- base::inherits
[17:28:28.247]                       invokeRestart <- base::invokeRestart
[17:28:28.247]                       is.null <- base::is.null
[17:28:28.247]                       muffled <- FALSE
[17:28:28.247]                       if (inherits(cond, "message")) {
[17:28:28.247]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:28.247]                         if (muffled) 
[17:28:28.247]                           invokeRestart("muffleMessage")
[17:28:28.247]                       }
[17:28:28.247]                       else if (inherits(cond, "warning")) {
[17:28:28.247]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:28.247]                         if (muffled) 
[17:28:28.247]                           invokeRestart("muffleWarning")
[17:28:28.247]                       }
[17:28:28.247]                       else if (inherits(cond, "condition")) {
[17:28:28.247]                         if (!is.null(pattern)) {
[17:28:28.247]                           computeRestarts <- base::computeRestarts
[17:28:28.247]                           grepl <- base::grepl
[17:28:28.247]                           restarts <- computeRestarts(cond)
[17:28:28.247]                           for (restart in restarts) {
[17:28:28.247]                             name <- restart$name
[17:28:28.247]                             if (is.null(name)) 
[17:28:28.247]                               next
[17:28:28.247]                             if (!grepl(pattern, name)) 
[17:28:28.247]                               next
[17:28:28.247]                             invokeRestart(restart)
[17:28:28.247]                             muffled <- TRUE
[17:28:28.247]                             break
[17:28:28.247]                           }
[17:28:28.247]                         }
[17:28:28.247]                       }
[17:28:28.247]                       invisible(muffled)
[17:28:28.247]                     }
[17:28:28.247]                     muffleCondition(cond, pattern = "^muffle")
[17:28:28.247]                   }
[17:28:28.247]                 }
[17:28:28.247]                 else {
[17:28:28.247]                   if (TRUE) {
[17:28:28.247]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:28.247]                     {
[17:28:28.247]                       inherits <- base::inherits
[17:28:28.247]                       invokeRestart <- base::invokeRestart
[17:28:28.247]                       is.null <- base::is.null
[17:28:28.247]                       muffled <- FALSE
[17:28:28.247]                       if (inherits(cond, "message")) {
[17:28:28.247]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:28.247]                         if (muffled) 
[17:28:28.247]                           invokeRestart("muffleMessage")
[17:28:28.247]                       }
[17:28:28.247]                       else if (inherits(cond, "warning")) {
[17:28:28.247]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:28.247]                         if (muffled) 
[17:28:28.247]                           invokeRestart("muffleWarning")
[17:28:28.247]                       }
[17:28:28.247]                       else if (inherits(cond, "condition")) {
[17:28:28.247]                         if (!is.null(pattern)) {
[17:28:28.247]                           computeRestarts <- base::computeRestarts
[17:28:28.247]                           grepl <- base::grepl
[17:28:28.247]                           restarts <- computeRestarts(cond)
[17:28:28.247]                           for (restart in restarts) {
[17:28:28.247]                             name <- restart$name
[17:28:28.247]                             if (is.null(name)) 
[17:28:28.247]                               next
[17:28:28.247]                             if (!grepl(pattern, name)) 
[17:28:28.247]                               next
[17:28:28.247]                             invokeRestart(restart)
[17:28:28.247]                             muffled <- TRUE
[17:28:28.247]                             break
[17:28:28.247]                           }
[17:28:28.247]                         }
[17:28:28.247]                       }
[17:28:28.247]                       invisible(muffled)
[17:28:28.247]                     }
[17:28:28.247]                     muffleCondition(cond, pattern = "^muffle")
[17:28:28.247]                   }
[17:28:28.247]                 }
[17:28:28.247]             }
[17:28:28.247]         }))
[17:28:28.247]     }, error = function(ex) {
[17:28:28.247]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:28.247]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:28.247]                 ...future.rng), started = ...future.startTime, 
[17:28:28.247]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:28.247]             version = "1.8"), class = "FutureResult")
[17:28:28.247]     }, finally = {
[17:28:28.247]         if (!identical(...future.workdir, getwd())) 
[17:28:28.247]             setwd(...future.workdir)
[17:28:28.247]         {
[17:28:28.247]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:28.247]                 ...future.oldOptions$nwarnings <- NULL
[17:28:28.247]             }
[17:28:28.247]             base::options(...future.oldOptions)
[17:28:28.247]             if (.Platform$OS.type == "windows") {
[17:28:28.247]                 old_names <- names(...future.oldEnvVars)
[17:28:28.247]                 envs <- base::Sys.getenv()
[17:28:28.247]                 names <- names(envs)
[17:28:28.247]                 common <- intersect(names, old_names)
[17:28:28.247]                 added <- setdiff(names, old_names)
[17:28:28.247]                 removed <- setdiff(old_names, names)
[17:28:28.247]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:28.247]                   envs[common]]
[17:28:28.247]                 NAMES <- toupper(changed)
[17:28:28.247]                 args <- list()
[17:28:28.247]                 for (kk in seq_along(NAMES)) {
[17:28:28.247]                   name <- changed[[kk]]
[17:28:28.247]                   NAME <- NAMES[[kk]]
[17:28:28.247]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:28.247]                     next
[17:28:28.247]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:28.247]                 }
[17:28:28.247]                 NAMES <- toupper(added)
[17:28:28.247]                 for (kk in seq_along(NAMES)) {
[17:28:28.247]                   name <- added[[kk]]
[17:28:28.247]                   NAME <- NAMES[[kk]]
[17:28:28.247]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:28.247]                     next
[17:28:28.247]                   args[[name]] <- ""
[17:28:28.247]                 }
[17:28:28.247]                 NAMES <- toupper(removed)
[17:28:28.247]                 for (kk in seq_along(NAMES)) {
[17:28:28.247]                   name <- removed[[kk]]
[17:28:28.247]                   NAME <- NAMES[[kk]]
[17:28:28.247]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:28.247]                     next
[17:28:28.247]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:28.247]                 }
[17:28:28.247]                 if (length(args) > 0) 
[17:28:28.247]                   base::do.call(base::Sys.setenv, args = args)
[17:28:28.247]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:28.247]             }
[17:28:28.247]             else {
[17:28:28.247]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:28.247]             }
[17:28:28.247]             {
[17:28:28.247]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:28.247]                   0L) {
[17:28:28.247]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:28.247]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:28.247]                   base::options(opts)
[17:28:28.247]                 }
[17:28:28.247]                 {
[17:28:28.247]                   {
[17:28:28.247]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:28.247]                     NULL
[17:28:28.247]                   }
[17:28:28.247]                   options(future.plan = NULL)
[17:28:28.247]                   if (is.na(NA_character_)) 
[17:28:28.247]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:28.247]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:28.247]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:28.247]                     .init = FALSE)
[17:28:28.247]                 }
[17:28:28.247]             }
[17:28:28.247]         }
[17:28:28.247]     })
[17:28:28.247]     if (TRUE) {
[17:28:28.247]         base::sink(type = "output", split = FALSE)
[17:28:28.247]         if (TRUE) {
[17:28:28.247]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:28.247]         }
[17:28:28.247]         else {
[17:28:28.247]             ...future.result["stdout"] <- base::list(NULL)
[17:28:28.247]         }
[17:28:28.247]         base::close(...future.stdout)
[17:28:28.247]         ...future.stdout <- NULL
[17:28:28.247]     }
[17:28:28.247]     ...future.result$conditions <- ...future.conditions
[17:28:28.247]     ...future.result$finished <- base::Sys.time()
[17:28:28.247]     ...future.result
[17:28:28.247] }
[17:28:28.379] MultisessionFuture started
[17:28:28.379] result() for ClusterFuture ...
[17:28:28.380] receiveMessageFromWorker() for ClusterFuture ...
[17:28:28.380] - Validating connection of MultisessionFuture
[17:28:28.470] - received message: FutureResult
[17:28:28.471] - Received FutureResult
[17:28:28.471] - Erased future from FutureRegistry
[17:28:28.472] result() for ClusterFuture ...
[17:28:28.472] - result already collected: FutureResult
[17:28:28.472] result() for ClusterFuture ... done
[17:28:28.473] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:28.473] result() for ClusterFuture ... done
[17:28:28.473] result() for ClusterFuture ...
[17:28:28.473] - result already collected: FutureResult
[17:28:28.473] result() for ClusterFuture ... done
[17:28:28.474] plan(): plan_init() of 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[17:28:28.474] plan(): nbrOfWorkers() = 2
> 
> f <- future({ gc() })
[17:28:28.475] getGlobalsAndPackages() ...
[17:28:28.475] Searching for globals...
[17:28:28.477] - globals found: [2] '{', 'gc'
[17:28:28.477] Searching for globals ... DONE
[17:28:28.477] Resolving globals: FALSE
[17:28:28.478] 
[17:28:28.478] 
[17:28:28.478] getGlobalsAndPackages() ... DONE
[17:28:28.479] run() for 'Future' ...
[17:28:28.479] - state: 'created'
[17:28:28.479] - Future backend: 'FutureStrategy', 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:28.494] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:28.494] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:28.495]   - Field: 'node'
[17:28:28.495]   - Field: 'label'
[17:28:28.495]   - Field: 'local'
[17:28:28.496]   - Field: 'owner'
[17:28:28.496]   - Field: 'envir'
[17:28:28.496]   - Field: 'workers'
[17:28:28.496]   - Field: 'packages'
[17:28:28.497]   - Field: 'gc'
[17:28:28.497]   - Field: 'conditions'
[17:28:28.497]   - Field: 'persistent'
[17:28:28.497]   - Field: 'expr'
[17:28:28.498]   - Field: 'uuid'
[17:28:28.498]   - Field: 'seed'
[17:28:28.498]   - Field: 'version'
[17:28:28.498]   - Field: 'result'
[17:28:28.498]   - Field: 'asynchronous'
[17:28:28.499]   - Field: 'calls'
[17:28:28.499]   - Field: 'globals'
[17:28:28.499]   - Field: 'stdout'
[17:28:28.499]   - Field: 'earlySignal'
[17:28:28.500]   - Field: 'lazy'
[17:28:28.500]   - Field: 'state'
[17:28:28.500] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:28.500] - Launch lazy future ...
[17:28:28.501] Packages needed by the future expression (n = 0): <none>
[17:28:28.501] Packages needed by future strategies (n = 0): <none>
[17:28:28.502] {
[17:28:28.502]     {
[17:28:28.502]         {
[17:28:28.502]             ...future.startTime <- base::Sys.time()
[17:28:28.502]             {
[17:28:28.502]                 {
[17:28:28.502]                   {
[17:28:28.502]                     {
[17:28:28.502]                       base::local({
[17:28:28.502]                         has_future <- base::requireNamespace("future", 
[17:28:28.502]                           quietly = TRUE)
[17:28:28.502]                         if (has_future) {
[17:28:28.502]                           ns <- base::getNamespace("future")
[17:28:28.502]                           version <- ns[[".package"]][["version"]]
[17:28:28.502]                           if (is.null(version)) 
[17:28:28.502]                             version <- utils::packageVersion("future")
[17:28:28.502]                         }
[17:28:28.502]                         else {
[17:28:28.502]                           version <- NULL
[17:28:28.502]                         }
[17:28:28.502]                         if (!has_future || version < "1.8.0") {
[17:28:28.502]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:28.502]                             "", base::R.version$version.string), 
[17:28:28.502]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:28.502]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:28.502]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:28.502]                               "release", "version")], collapse = " "), 
[17:28:28.502]                             hostname = base::Sys.info()[["nodename"]])
[17:28:28.502]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:28.502]                             info)
[17:28:28.502]                           info <- base::paste(info, collapse = "; ")
[17:28:28.502]                           if (!has_future) {
[17:28:28.502]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:28.502]                               info)
[17:28:28.502]                           }
[17:28:28.502]                           else {
[17:28:28.502]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:28.502]                               info, version)
[17:28:28.502]                           }
[17:28:28.502]                           base::stop(msg)
[17:28:28.502]                         }
[17:28:28.502]                       })
[17:28:28.502]                     }
[17:28:28.502]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:28.502]                     base::options(mc.cores = 1L)
[17:28:28.502]                   }
[17:28:28.502]                   ...future.strategy.old <- future::plan("list")
[17:28:28.502]                   options(future.plan = NULL)
[17:28:28.502]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:28.502]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:28.502]                 }
[17:28:28.502]                 ...future.workdir <- getwd()
[17:28:28.502]             }
[17:28:28.502]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:28.502]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:28.502]         }
[17:28:28.502]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:28.502]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:28.502]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:28.502]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:28.502]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:28.502]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:28.502]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:28.502]             base::names(...future.oldOptions))
[17:28:28.502]     }
[17:28:28.502]     if (FALSE) {
[17:28:28.502]     }
[17:28:28.502]     else {
[17:28:28.502]         if (TRUE) {
[17:28:28.502]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:28.502]                 open = "w")
[17:28:28.502]         }
[17:28:28.502]         else {
[17:28:28.502]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:28.502]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:28.502]         }
[17:28:28.502]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:28.502]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:28.502]             base::sink(type = "output", split = FALSE)
[17:28:28.502]             base::close(...future.stdout)
[17:28:28.502]         }, add = TRUE)
[17:28:28.502]     }
[17:28:28.502]     ...future.frame <- base::sys.nframe()
[17:28:28.502]     ...future.conditions <- base::list()
[17:28:28.502]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:28.502]     if (FALSE) {
[17:28:28.502]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:28.502]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:28.502]     }
[17:28:28.502]     ...future.result <- base::tryCatch({
[17:28:28.502]         base::withCallingHandlers({
[17:28:28.502]             ...future.value <- base::withVisible(base::local({
[17:28:28.502]                 ...future.makeSendCondition <- base::local({
[17:28:28.502]                   sendCondition <- NULL
[17:28:28.502]                   function(frame = 1L) {
[17:28:28.502]                     if (is.function(sendCondition)) 
[17:28:28.502]                       return(sendCondition)
[17:28:28.502]                     ns <- getNamespace("parallel")
[17:28:28.502]                     if (exists("sendData", mode = "function", 
[17:28:28.502]                       envir = ns)) {
[17:28:28.502]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:28.502]                         envir = ns)
[17:28:28.502]                       envir <- sys.frame(frame)
[17:28:28.502]                       master <- NULL
[17:28:28.502]                       while (!identical(envir, .GlobalEnv) && 
[17:28:28.502]                         !identical(envir, emptyenv())) {
[17:28:28.502]                         if (exists("master", mode = "list", envir = envir, 
[17:28:28.502]                           inherits = FALSE)) {
[17:28:28.502]                           master <- get("master", mode = "list", 
[17:28:28.502]                             envir = envir, inherits = FALSE)
[17:28:28.502]                           if (inherits(master, c("SOCKnode", 
[17:28:28.502]                             "SOCK0node"))) {
[17:28:28.502]                             sendCondition <<- function(cond) {
[17:28:28.502]                               data <- list(type = "VALUE", value = cond, 
[17:28:28.502]                                 success = TRUE)
[17:28:28.502]                               parallel_sendData(master, data)
[17:28:28.502]                             }
[17:28:28.502]                             return(sendCondition)
[17:28:28.502]                           }
[17:28:28.502]                         }
[17:28:28.502]                         frame <- frame + 1L
[17:28:28.502]                         envir <- sys.frame(frame)
[17:28:28.502]                       }
[17:28:28.502]                     }
[17:28:28.502]                     sendCondition <<- function(cond) NULL
[17:28:28.502]                   }
[17:28:28.502]                 })
[17:28:28.502]                 withCallingHandlers({
[17:28:28.502]                   {
[17:28:28.502]                     gc()
[17:28:28.502]                   }
[17:28:28.502]                 }, immediateCondition = function(cond) {
[17:28:28.502]                   sendCondition <- ...future.makeSendCondition()
[17:28:28.502]                   sendCondition(cond)
[17:28:28.502]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:28.502]                   {
[17:28:28.502]                     inherits <- base::inherits
[17:28:28.502]                     invokeRestart <- base::invokeRestart
[17:28:28.502]                     is.null <- base::is.null
[17:28:28.502]                     muffled <- FALSE
[17:28:28.502]                     if (inherits(cond, "message")) {
[17:28:28.502]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:28.502]                       if (muffled) 
[17:28:28.502]                         invokeRestart("muffleMessage")
[17:28:28.502]                     }
[17:28:28.502]                     else if (inherits(cond, "warning")) {
[17:28:28.502]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:28.502]                       if (muffled) 
[17:28:28.502]                         invokeRestart("muffleWarning")
[17:28:28.502]                     }
[17:28:28.502]                     else if (inherits(cond, "condition")) {
[17:28:28.502]                       if (!is.null(pattern)) {
[17:28:28.502]                         computeRestarts <- base::computeRestarts
[17:28:28.502]                         grepl <- base::grepl
[17:28:28.502]                         restarts <- computeRestarts(cond)
[17:28:28.502]                         for (restart in restarts) {
[17:28:28.502]                           name <- restart$name
[17:28:28.502]                           if (is.null(name)) 
[17:28:28.502]                             next
[17:28:28.502]                           if (!grepl(pattern, name)) 
[17:28:28.502]                             next
[17:28:28.502]                           invokeRestart(restart)
[17:28:28.502]                           muffled <- TRUE
[17:28:28.502]                           break
[17:28:28.502]                         }
[17:28:28.502]                       }
[17:28:28.502]                     }
[17:28:28.502]                     invisible(muffled)
[17:28:28.502]                   }
[17:28:28.502]                   muffleCondition(cond)
[17:28:28.502]                 })
[17:28:28.502]             }))
[17:28:28.502]             future::FutureResult(value = ...future.value$value, 
[17:28:28.502]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:28.502]                   ...future.rng), globalenv = if (FALSE) 
[17:28:28.502]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:28.502]                     ...future.globalenv.names))
[17:28:28.502]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:28.502]         }, condition = base::local({
[17:28:28.502]             c <- base::c
[17:28:28.502]             inherits <- base::inherits
[17:28:28.502]             invokeRestart <- base::invokeRestart
[17:28:28.502]             length <- base::length
[17:28:28.502]             list <- base::list
[17:28:28.502]             seq.int <- base::seq.int
[17:28:28.502]             signalCondition <- base::signalCondition
[17:28:28.502]             sys.calls <- base::sys.calls
[17:28:28.502]             `[[` <- base::`[[`
[17:28:28.502]             `+` <- base::`+`
[17:28:28.502]             `<<-` <- base::`<<-`
[17:28:28.502]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:28.502]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:28.502]                   3L)]
[17:28:28.502]             }
[17:28:28.502]             function(cond) {
[17:28:28.502]                 is_error <- inherits(cond, "error")
[17:28:28.502]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:28.502]                   NULL)
[17:28:28.502]                 if (is_error) {
[17:28:28.502]                   sessionInformation <- function() {
[17:28:28.502]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:28.502]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:28.502]                       search = base::search(), system = base::Sys.info())
[17:28:28.502]                   }
[17:28:28.502]                   ...future.conditions[[length(...future.conditions) + 
[17:28:28.502]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:28.502]                     cond$call), session = sessionInformation(), 
[17:28:28.502]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:28.502]                   signalCondition(cond)
[17:28:28.502]                 }
[17:28:28.502]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:28.502]                 "immediateCondition"))) {
[17:28:28.502]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:28.502]                   ...future.conditions[[length(...future.conditions) + 
[17:28:28.502]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:28.502]                   if (TRUE && !signal) {
[17:28:28.502]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:28.502]                     {
[17:28:28.502]                       inherits <- base::inherits
[17:28:28.502]                       invokeRestart <- base::invokeRestart
[17:28:28.502]                       is.null <- base::is.null
[17:28:28.502]                       muffled <- FALSE
[17:28:28.502]                       if (inherits(cond, "message")) {
[17:28:28.502]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:28.502]                         if (muffled) 
[17:28:28.502]                           invokeRestart("muffleMessage")
[17:28:28.502]                       }
[17:28:28.502]                       else if (inherits(cond, "warning")) {
[17:28:28.502]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:28.502]                         if (muffled) 
[17:28:28.502]                           invokeRestart("muffleWarning")
[17:28:28.502]                       }
[17:28:28.502]                       else if (inherits(cond, "condition")) {
[17:28:28.502]                         if (!is.null(pattern)) {
[17:28:28.502]                           computeRestarts <- base::computeRestarts
[17:28:28.502]                           grepl <- base::grepl
[17:28:28.502]                           restarts <- computeRestarts(cond)
[17:28:28.502]                           for (restart in restarts) {
[17:28:28.502]                             name <- restart$name
[17:28:28.502]                             if (is.null(name)) 
[17:28:28.502]                               next
[17:28:28.502]                             if (!grepl(pattern, name)) 
[17:28:28.502]                               next
[17:28:28.502]                             invokeRestart(restart)
[17:28:28.502]                             muffled <- TRUE
[17:28:28.502]                             break
[17:28:28.502]                           }
[17:28:28.502]                         }
[17:28:28.502]                       }
[17:28:28.502]                       invisible(muffled)
[17:28:28.502]                     }
[17:28:28.502]                     muffleCondition(cond, pattern = "^muffle")
[17:28:28.502]                   }
[17:28:28.502]                 }
[17:28:28.502]                 else {
[17:28:28.502]                   if (TRUE) {
[17:28:28.502]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:28.502]                     {
[17:28:28.502]                       inherits <- base::inherits
[17:28:28.502]                       invokeRestart <- base::invokeRestart
[17:28:28.502]                       is.null <- base::is.null
[17:28:28.502]                       muffled <- FALSE
[17:28:28.502]                       if (inherits(cond, "message")) {
[17:28:28.502]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:28.502]                         if (muffled) 
[17:28:28.502]                           invokeRestart("muffleMessage")
[17:28:28.502]                       }
[17:28:28.502]                       else if (inherits(cond, "warning")) {
[17:28:28.502]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:28.502]                         if (muffled) 
[17:28:28.502]                           invokeRestart("muffleWarning")
[17:28:28.502]                       }
[17:28:28.502]                       else if (inherits(cond, "condition")) {
[17:28:28.502]                         if (!is.null(pattern)) {
[17:28:28.502]                           computeRestarts <- base::computeRestarts
[17:28:28.502]                           grepl <- base::grepl
[17:28:28.502]                           restarts <- computeRestarts(cond)
[17:28:28.502]                           for (restart in restarts) {
[17:28:28.502]                             name <- restart$name
[17:28:28.502]                             if (is.null(name)) 
[17:28:28.502]                               next
[17:28:28.502]                             if (!grepl(pattern, name)) 
[17:28:28.502]                               next
[17:28:28.502]                             invokeRestart(restart)
[17:28:28.502]                             muffled <- TRUE
[17:28:28.502]                             break
[17:28:28.502]                           }
[17:28:28.502]                         }
[17:28:28.502]                       }
[17:28:28.502]                       invisible(muffled)
[17:28:28.502]                     }
[17:28:28.502]                     muffleCondition(cond, pattern = "^muffle")
[17:28:28.502]                   }
[17:28:28.502]                 }
[17:28:28.502]             }
[17:28:28.502]         }))
[17:28:28.502]     }, error = function(ex) {
[17:28:28.502]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:28.502]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:28.502]                 ...future.rng), started = ...future.startTime, 
[17:28:28.502]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:28.502]             version = "1.8"), class = "FutureResult")
[17:28:28.502]     }, finally = {
[17:28:28.502]         if (!identical(...future.workdir, getwd())) 
[17:28:28.502]             setwd(...future.workdir)
[17:28:28.502]         {
[17:28:28.502]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:28.502]                 ...future.oldOptions$nwarnings <- NULL
[17:28:28.502]             }
[17:28:28.502]             base::options(...future.oldOptions)
[17:28:28.502]             if (.Platform$OS.type == "windows") {
[17:28:28.502]                 old_names <- names(...future.oldEnvVars)
[17:28:28.502]                 envs <- base::Sys.getenv()
[17:28:28.502]                 names <- names(envs)
[17:28:28.502]                 common <- intersect(names, old_names)
[17:28:28.502]                 added <- setdiff(names, old_names)
[17:28:28.502]                 removed <- setdiff(old_names, names)
[17:28:28.502]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:28.502]                   envs[common]]
[17:28:28.502]                 NAMES <- toupper(changed)
[17:28:28.502]                 args <- list()
[17:28:28.502]                 for (kk in seq_along(NAMES)) {
[17:28:28.502]                   name <- changed[[kk]]
[17:28:28.502]                   NAME <- NAMES[[kk]]
[17:28:28.502]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:28.502]                     next
[17:28:28.502]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:28.502]                 }
[17:28:28.502]                 NAMES <- toupper(added)
[17:28:28.502]                 for (kk in seq_along(NAMES)) {
[17:28:28.502]                   name <- added[[kk]]
[17:28:28.502]                   NAME <- NAMES[[kk]]
[17:28:28.502]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:28.502]                     next
[17:28:28.502]                   args[[name]] <- ""
[17:28:28.502]                 }
[17:28:28.502]                 NAMES <- toupper(removed)
[17:28:28.502]                 for (kk in seq_along(NAMES)) {
[17:28:28.502]                   name <- removed[[kk]]
[17:28:28.502]                   NAME <- NAMES[[kk]]
[17:28:28.502]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:28.502]                     next
[17:28:28.502]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:28.502]                 }
[17:28:28.502]                 if (length(args) > 0) 
[17:28:28.502]                   base::do.call(base::Sys.setenv, args = args)
[17:28:28.502]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:28.502]             }
[17:28:28.502]             else {
[17:28:28.502]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:28.502]             }
[17:28:28.502]             {
[17:28:28.502]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:28.502]                   0L) {
[17:28:28.502]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:28.502]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:28.502]                   base::options(opts)
[17:28:28.502]                 }
[17:28:28.502]                 {
[17:28:28.502]                   {
[17:28:28.502]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:28.502]                     NULL
[17:28:28.502]                   }
[17:28:28.502]                   options(future.plan = NULL)
[17:28:28.502]                   if (is.na(NA_character_)) 
[17:28:28.502]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:28.502]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:28.502]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:28.502]                     .init = FALSE)
[17:28:28.502]                 }
[17:28:28.502]             }
[17:28:28.502]         }
[17:28:28.502]     })
[17:28:28.502]     if (TRUE) {
[17:28:28.502]         base::sink(type = "output", split = FALSE)
[17:28:28.502]         if (TRUE) {
[17:28:28.502]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:28.502]         }
[17:28:28.502]         else {
[17:28:28.502]             ...future.result["stdout"] <- base::list(NULL)
[17:28:28.502]         }
[17:28:28.502]         base::close(...future.stdout)
[17:28:28.502]         ...future.stdout <- NULL
[17:28:28.502]     }
[17:28:28.502]     ...future.result$conditions <- ...future.conditions
[17:28:28.502]     ...future.result$finished <- base::Sys.time()
[17:28:28.502]     ...future.result
[17:28:28.502] }
[17:28:28.511] MultisessionFuture started
[17:28:28.512] - Launch lazy future ... done
[17:28:28.512] run() for 'MultisessionFuture' ... done
> v <- value(f)
[17:28:28.513] result() for ClusterFuture ...
[17:28:28.513] receiveMessageFromWorker() for ClusterFuture ...
[17:28:28.513] - Validating connection of MultisessionFuture
[17:28:28.567] - received message: FutureResult
[17:28:28.568] - Received FutureResult
[17:28:28.568] - Erased future from FutureRegistry
[17:28:28.568] result() for ClusterFuture ...
[17:28:28.569] - result already collected: FutureResult
[17:28:28.569] result() for ClusterFuture ... done
[17:28:28.569] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:28.570] result() for ClusterFuture ... done
[17:28:28.570] result() for ClusterFuture ...
[17:28:28.570] - result already collected: FutureResult
[17:28:28.571] result() for ClusterFuture ... done
> print(v)
         used (Mb) gc trigger (Mb) max used (Mb)
Ncells 417168 22.3     875778 46.8   632260 33.8
Vcells 742996  5.7    8388608 64.0  2032848 15.6
> 
> f <- future({ integer(10e6) })
[17:28:28.571] getGlobalsAndPackages() ...
[17:28:28.572] Searching for globals...
[17:28:28.573] - globals found: [2] '{', 'integer'
[17:28:28.574] Searching for globals ... DONE
[17:28:28.574] Resolving globals: FALSE
[17:28:28.575] 
[17:28:28.575] 
[17:28:28.575] getGlobalsAndPackages() ... DONE
[17:28:28.576] run() for 'Future' ...
[17:28:28.576] - state: 'created'
[17:28:28.577] - Future backend: 'FutureStrategy', 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:28.593] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:28.593] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:28.593]   - Field: 'node'
[17:28:28.594]   - Field: 'label'
[17:28:28.594]   - Field: 'local'
[17:28:28.594]   - Field: 'owner'
[17:28:28.594]   - Field: 'envir'
[17:28:28.594]   - Field: 'workers'
[17:28:28.595]   - Field: 'packages'
[17:28:28.595]   - Field: 'gc'
[17:28:28.595]   - Field: 'conditions'
[17:28:28.595]   - Field: 'persistent'
[17:28:28.595]   - Field: 'expr'
[17:28:28.595]   - Field: 'uuid'
[17:28:28.596]   - Field: 'seed'
[17:28:28.596]   - Field: 'version'
[17:28:28.596]   - Field: 'result'
[17:28:28.597]   - Field: 'asynchronous'
[17:28:28.597]   - Field: 'calls'
[17:28:28.597]   - Field: 'globals'
[17:28:28.598]   - Field: 'stdout'
[17:28:28.598]   - Field: 'earlySignal'
[17:28:28.598]   - Field: 'lazy'
[17:28:28.599]   - Field: 'state'
[17:28:28.599] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:28.599] - Launch lazy future ...
[17:28:28.600] Packages needed by the future expression (n = 0): <none>
[17:28:28.600] Packages needed by future strategies (n = 0): <none>
[17:28:28.601] {
[17:28:28.601]     {
[17:28:28.601]         {
[17:28:28.601]             ...future.startTime <- base::Sys.time()
[17:28:28.601]             {
[17:28:28.601]                 {
[17:28:28.601]                   {
[17:28:28.601]                     {
[17:28:28.601]                       base::local({
[17:28:28.601]                         has_future <- base::requireNamespace("future", 
[17:28:28.601]                           quietly = TRUE)
[17:28:28.601]                         if (has_future) {
[17:28:28.601]                           ns <- base::getNamespace("future")
[17:28:28.601]                           version <- ns[[".package"]][["version"]]
[17:28:28.601]                           if (is.null(version)) 
[17:28:28.601]                             version <- utils::packageVersion("future")
[17:28:28.601]                         }
[17:28:28.601]                         else {
[17:28:28.601]                           version <- NULL
[17:28:28.601]                         }
[17:28:28.601]                         if (!has_future || version < "1.8.0") {
[17:28:28.601]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:28.601]                             "", base::R.version$version.string), 
[17:28:28.601]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:28.601]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:28.601]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:28.601]                               "release", "version")], collapse = " "), 
[17:28:28.601]                             hostname = base::Sys.info()[["nodename"]])
[17:28:28.601]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:28.601]                             info)
[17:28:28.601]                           info <- base::paste(info, collapse = "; ")
[17:28:28.601]                           if (!has_future) {
[17:28:28.601]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:28.601]                               info)
[17:28:28.601]                           }
[17:28:28.601]                           else {
[17:28:28.601]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:28.601]                               info, version)
[17:28:28.601]                           }
[17:28:28.601]                           base::stop(msg)
[17:28:28.601]                         }
[17:28:28.601]                       })
[17:28:28.601]                     }
[17:28:28.601]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:28.601]                     base::options(mc.cores = 1L)
[17:28:28.601]                   }
[17:28:28.601]                   ...future.strategy.old <- future::plan("list")
[17:28:28.601]                   options(future.plan = NULL)
[17:28:28.601]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:28.601]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:28.601]                 }
[17:28:28.601]                 ...future.workdir <- getwd()
[17:28:28.601]             }
[17:28:28.601]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:28.601]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:28.601]         }
[17:28:28.601]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:28.601]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:28.601]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:28.601]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:28.601]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:28.601]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:28.601]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:28.601]             base::names(...future.oldOptions))
[17:28:28.601]     }
[17:28:28.601]     if (FALSE) {
[17:28:28.601]     }
[17:28:28.601]     else {
[17:28:28.601]         if (TRUE) {
[17:28:28.601]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:28.601]                 open = "w")
[17:28:28.601]         }
[17:28:28.601]         else {
[17:28:28.601]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:28.601]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:28.601]         }
[17:28:28.601]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:28.601]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:28.601]             base::sink(type = "output", split = FALSE)
[17:28:28.601]             base::close(...future.stdout)
[17:28:28.601]         }, add = TRUE)
[17:28:28.601]     }
[17:28:28.601]     ...future.frame <- base::sys.nframe()
[17:28:28.601]     ...future.conditions <- base::list()
[17:28:28.601]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:28.601]     if (FALSE) {
[17:28:28.601]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:28.601]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:28.601]     }
[17:28:28.601]     ...future.result <- base::tryCatch({
[17:28:28.601]         base::withCallingHandlers({
[17:28:28.601]             ...future.value <- base::withVisible(base::local({
[17:28:28.601]                 ...future.makeSendCondition <- base::local({
[17:28:28.601]                   sendCondition <- NULL
[17:28:28.601]                   function(frame = 1L) {
[17:28:28.601]                     if (is.function(sendCondition)) 
[17:28:28.601]                       return(sendCondition)
[17:28:28.601]                     ns <- getNamespace("parallel")
[17:28:28.601]                     if (exists("sendData", mode = "function", 
[17:28:28.601]                       envir = ns)) {
[17:28:28.601]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:28.601]                         envir = ns)
[17:28:28.601]                       envir <- sys.frame(frame)
[17:28:28.601]                       master <- NULL
[17:28:28.601]                       while (!identical(envir, .GlobalEnv) && 
[17:28:28.601]                         !identical(envir, emptyenv())) {
[17:28:28.601]                         if (exists("master", mode = "list", envir = envir, 
[17:28:28.601]                           inherits = FALSE)) {
[17:28:28.601]                           master <- get("master", mode = "list", 
[17:28:28.601]                             envir = envir, inherits = FALSE)
[17:28:28.601]                           if (inherits(master, c("SOCKnode", 
[17:28:28.601]                             "SOCK0node"))) {
[17:28:28.601]                             sendCondition <<- function(cond) {
[17:28:28.601]                               data <- list(type = "VALUE", value = cond, 
[17:28:28.601]                                 success = TRUE)
[17:28:28.601]                               parallel_sendData(master, data)
[17:28:28.601]                             }
[17:28:28.601]                             return(sendCondition)
[17:28:28.601]                           }
[17:28:28.601]                         }
[17:28:28.601]                         frame <- frame + 1L
[17:28:28.601]                         envir <- sys.frame(frame)
[17:28:28.601]                       }
[17:28:28.601]                     }
[17:28:28.601]                     sendCondition <<- function(cond) NULL
[17:28:28.601]                   }
[17:28:28.601]                 })
[17:28:28.601]                 withCallingHandlers({
[17:28:28.601]                   {
[17:28:28.601]                     integer(1e+07)
[17:28:28.601]                   }
[17:28:28.601]                 }, immediateCondition = function(cond) {
[17:28:28.601]                   sendCondition <- ...future.makeSendCondition()
[17:28:28.601]                   sendCondition(cond)
[17:28:28.601]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:28.601]                   {
[17:28:28.601]                     inherits <- base::inherits
[17:28:28.601]                     invokeRestart <- base::invokeRestart
[17:28:28.601]                     is.null <- base::is.null
[17:28:28.601]                     muffled <- FALSE
[17:28:28.601]                     if (inherits(cond, "message")) {
[17:28:28.601]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:28.601]                       if (muffled) 
[17:28:28.601]                         invokeRestart("muffleMessage")
[17:28:28.601]                     }
[17:28:28.601]                     else if (inherits(cond, "warning")) {
[17:28:28.601]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:28.601]                       if (muffled) 
[17:28:28.601]                         invokeRestart("muffleWarning")
[17:28:28.601]                     }
[17:28:28.601]                     else if (inherits(cond, "condition")) {
[17:28:28.601]                       if (!is.null(pattern)) {
[17:28:28.601]                         computeRestarts <- base::computeRestarts
[17:28:28.601]                         grepl <- base::grepl
[17:28:28.601]                         restarts <- computeRestarts(cond)
[17:28:28.601]                         for (restart in restarts) {
[17:28:28.601]                           name <- restart$name
[17:28:28.601]                           if (is.null(name)) 
[17:28:28.601]                             next
[17:28:28.601]                           if (!grepl(pattern, name)) 
[17:28:28.601]                             next
[17:28:28.601]                           invokeRestart(restart)
[17:28:28.601]                           muffled <- TRUE
[17:28:28.601]                           break
[17:28:28.601]                         }
[17:28:28.601]                       }
[17:28:28.601]                     }
[17:28:28.601]                     invisible(muffled)
[17:28:28.601]                   }
[17:28:28.601]                   muffleCondition(cond)
[17:28:28.601]                 })
[17:28:28.601]             }))
[17:28:28.601]             future::FutureResult(value = ...future.value$value, 
[17:28:28.601]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:28.601]                   ...future.rng), globalenv = if (FALSE) 
[17:28:28.601]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:28.601]                     ...future.globalenv.names))
[17:28:28.601]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:28.601]         }, condition = base::local({
[17:28:28.601]             c <- base::c
[17:28:28.601]             inherits <- base::inherits
[17:28:28.601]             invokeRestart <- base::invokeRestart
[17:28:28.601]             length <- base::length
[17:28:28.601]             list <- base::list
[17:28:28.601]             seq.int <- base::seq.int
[17:28:28.601]             signalCondition <- base::signalCondition
[17:28:28.601]             sys.calls <- base::sys.calls
[17:28:28.601]             `[[` <- base::`[[`
[17:28:28.601]             `+` <- base::`+`
[17:28:28.601]             `<<-` <- base::`<<-`
[17:28:28.601]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:28.601]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:28.601]                   3L)]
[17:28:28.601]             }
[17:28:28.601]             function(cond) {
[17:28:28.601]                 is_error <- inherits(cond, "error")
[17:28:28.601]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:28.601]                   NULL)
[17:28:28.601]                 if (is_error) {
[17:28:28.601]                   sessionInformation <- function() {
[17:28:28.601]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:28.601]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:28.601]                       search = base::search(), system = base::Sys.info())
[17:28:28.601]                   }
[17:28:28.601]                   ...future.conditions[[length(...future.conditions) + 
[17:28:28.601]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:28.601]                     cond$call), session = sessionInformation(), 
[17:28:28.601]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:28.601]                   signalCondition(cond)
[17:28:28.601]                 }
[17:28:28.601]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:28.601]                 "immediateCondition"))) {
[17:28:28.601]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:28.601]                   ...future.conditions[[length(...future.conditions) + 
[17:28:28.601]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:28.601]                   if (TRUE && !signal) {
[17:28:28.601]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:28.601]                     {
[17:28:28.601]                       inherits <- base::inherits
[17:28:28.601]                       invokeRestart <- base::invokeRestart
[17:28:28.601]                       is.null <- base::is.null
[17:28:28.601]                       muffled <- FALSE
[17:28:28.601]                       if (inherits(cond, "message")) {
[17:28:28.601]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:28.601]                         if (muffled) 
[17:28:28.601]                           invokeRestart("muffleMessage")
[17:28:28.601]                       }
[17:28:28.601]                       else if (inherits(cond, "warning")) {
[17:28:28.601]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:28.601]                         if (muffled) 
[17:28:28.601]                           invokeRestart("muffleWarning")
[17:28:28.601]                       }
[17:28:28.601]                       else if (inherits(cond, "condition")) {
[17:28:28.601]                         if (!is.null(pattern)) {
[17:28:28.601]                           computeRestarts <- base::computeRestarts
[17:28:28.601]                           grepl <- base::grepl
[17:28:28.601]                           restarts <- computeRestarts(cond)
[17:28:28.601]                           for (restart in restarts) {
[17:28:28.601]                             name <- restart$name
[17:28:28.601]                             if (is.null(name)) 
[17:28:28.601]                               next
[17:28:28.601]                             if (!grepl(pattern, name)) 
[17:28:28.601]                               next
[17:28:28.601]                             invokeRestart(restart)
[17:28:28.601]                             muffled <- TRUE
[17:28:28.601]                             break
[17:28:28.601]                           }
[17:28:28.601]                         }
[17:28:28.601]                       }
[17:28:28.601]                       invisible(muffled)
[17:28:28.601]                     }
[17:28:28.601]                     muffleCondition(cond, pattern = "^muffle")
[17:28:28.601]                   }
[17:28:28.601]                 }
[17:28:28.601]                 else {
[17:28:28.601]                   if (TRUE) {
[17:28:28.601]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:28.601]                     {
[17:28:28.601]                       inherits <- base::inherits
[17:28:28.601]                       invokeRestart <- base::invokeRestart
[17:28:28.601]                       is.null <- base::is.null
[17:28:28.601]                       muffled <- FALSE
[17:28:28.601]                       if (inherits(cond, "message")) {
[17:28:28.601]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:28.601]                         if (muffled) 
[17:28:28.601]                           invokeRestart("muffleMessage")
[17:28:28.601]                       }
[17:28:28.601]                       else if (inherits(cond, "warning")) {
[17:28:28.601]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:28.601]                         if (muffled) 
[17:28:28.601]                           invokeRestart("muffleWarning")
[17:28:28.601]                       }
[17:28:28.601]                       else if (inherits(cond, "condition")) {
[17:28:28.601]                         if (!is.null(pattern)) {
[17:28:28.601]                           computeRestarts <- base::computeRestarts
[17:28:28.601]                           grepl <- base::grepl
[17:28:28.601]                           restarts <- computeRestarts(cond)
[17:28:28.601]                           for (restart in restarts) {
[17:28:28.601]                             name <- restart$name
[17:28:28.601]                             if (is.null(name)) 
[17:28:28.601]                               next
[17:28:28.601]                             if (!grepl(pattern, name)) 
[17:28:28.601]                               next
[17:28:28.601]                             invokeRestart(restart)
[17:28:28.601]                             muffled <- TRUE
[17:28:28.601]                             break
[17:28:28.601]                           }
[17:28:28.601]                         }
[17:28:28.601]                       }
[17:28:28.601]                       invisible(muffled)
[17:28:28.601]                     }
[17:28:28.601]                     muffleCondition(cond, pattern = "^muffle")
[17:28:28.601]                   }
[17:28:28.601]                 }
[17:28:28.601]             }
[17:28:28.601]         }))
[17:28:28.601]     }, error = function(ex) {
[17:28:28.601]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:28.601]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:28.601]                 ...future.rng), started = ...future.startTime, 
[17:28:28.601]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:28.601]             version = "1.8"), class = "FutureResult")
[17:28:28.601]     }, finally = {
[17:28:28.601]         if (!identical(...future.workdir, getwd())) 
[17:28:28.601]             setwd(...future.workdir)
[17:28:28.601]         {
[17:28:28.601]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:28.601]                 ...future.oldOptions$nwarnings <- NULL
[17:28:28.601]             }
[17:28:28.601]             base::options(...future.oldOptions)
[17:28:28.601]             if (.Platform$OS.type == "windows") {
[17:28:28.601]                 old_names <- names(...future.oldEnvVars)
[17:28:28.601]                 envs <- base::Sys.getenv()
[17:28:28.601]                 names <- names(envs)
[17:28:28.601]                 common <- intersect(names, old_names)
[17:28:28.601]                 added <- setdiff(names, old_names)
[17:28:28.601]                 removed <- setdiff(old_names, names)
[17:28:28.601]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:28.601]                   envs[common]]
[17:28:28.601]                 NAMES <- toupper(changed)
[17:28:28.601]                 args <- list()
[17:28:28.601]                 for (kk in seq_along(NAMES)) {
[17:28:28.601]                   name <- changed[[kk]]
[17:28:28.601]                   NAME <- NAMES[[kk]]
[17:28:28.601]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:28.601]                     next
[17:28:28.601]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:28.601]                 }
[17:28:28.601]                 NAMES <- toupper(added)
[17:28:28.601]                 for (kk in seq_along(NAMES)) {
[17:28:28.601]                   name <- added[[kk]]
[17:28:28.601]                   NAME <- NAMES[[kk]]
[17:28:28.601]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:28.601]                     next
[17:28:28.601]                   args[[name]] <- ""
[17:28:28.601]                 }
[17:28:28.601]                 NAMES <- toupper(removed)
[17:28:28.601]                 for (kk in seq_along(NAMES)) {
[17:28:28.601]                   name <- removed[[kk]]
[17:28:28.601]                   NAME <- NAMES[[kk]]
[17:28:28.601]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:28.601]                     next
[17:28:28.601]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:28.601]                 }
[17:28:28.601]                 if (length(args) > 0) 
[17:28:28.601]                   base::do.call(base::Sys.setenv, args = args)
[17:28:28.601]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:28.601]             }
[17:28:28.601]             else {
[17:28:28.601]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:28.601]             }
[17:28:28.601]             {
[17:28:28.601]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:28.601]                   0L) {
[17:28:28.601]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:28.601]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:28.601]                   base::options(opts)
[17:28:28.601]                 }
[17:28:28.601]                 {
[17:28:28.601]                   {
[17:28:28.601]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:28.601]                     NULL
[17:28:28.601]                   }
[17:28:28.601]                   options(future.plan = NULL)
[17:28:28.601]                   if (is.na(NA_character_)) 
[17:28:28.601]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:28.601]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:28.601]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:28.601]                     .init = FALSE)
[17:28:28.601]                 }
[17:28:28.601]             }
[17:28:28.601]         }
[17:28:28.601]     })
[17:28:28.601]     if (TRUE) {
[17:28:28.601]         base::sink(type = "output", split = FALSE)
[17:28:28.601]         if (TRUE) {
[17:28:28.601]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:28.601]         }
[17:28:28.601]         else {
[17:28:28.601]             ...future.result["stdout"] <- base::list(NULL)
[17:28:28.601]         }
[17:28:28.601]         base::close(...future.stdout)
[17:28:28.601]         ...future.stdout <- NULL
[17:28:28.601]     }
[17:28:28.601]     ...future.result$conditions <- ...future.conditions
[17:28:28.601]     ...future.result$finished <- base::Sys.time()
[17:28:28.601]     ...future.result
[17:28:28.601] }
[17:28:28.611] MultisessionFuture started
[17:28:28.611] - Launch lazy future ... done
[17:28:28.611] run() for 'MultisessionFuture' ... done
> v <- value(f)
[17:28:28.612] result() for ClusterFuture ...
[17:28:28.612] receiveMessageFromWorker() for ClusterFuture ...
[17:28:28.613] - Validating connection of MultisessionFuture
[17:28:28.742] - received message: FutureResult
[17:28:28.743] - Received FutureResult
[17:28:28.743] - Erased future from FutureRegistry
[17:28:28.743] result() for ClusterFuture ...
[17:28:28.744] - result already collected: FutureResult
[17:28:28.744] result() for ClusterFuture ... done
[17:28:28.745] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:28.745] result() for ClusterFuture ... done
[17:28:28.745] result() for ClusterFuture ...
[17:28:28.746] - result already collected: FutureResult
[17:28:28.746] result() for ClusterFuture ... done
> str(v)
 int [1:10000000] 0 0 0 0 0 0 0 0 0 0 ...
> 
> f <- future({ gc() })
[17:28:28.747] getGlobalsAndPackages() ...
[17:28:28.748] Searching for globals...
[17:28:28.750] - globals found: [2] '{', 'gc'
[17:28:28.750] Searching for globals ... DONE
[17:28:28.751] Resolving globals: FALSE
[17:28:28.751] 
[17:28:28.752] 
[17:28:28.752] getGlobalsAndPackages() ... DONE
[17:28:28.753] run() for 'Future' ...
[17:28:28.753] - state: 'created'
[17:28:28.754] - Future backend: 'FutureStrategy', 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:28.771] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:28.772] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:28.772]   - Field: 'node'
[17:28:28.773]   - Field: 'label'
[17:28:28.773]   - Field: 'local'
[17:28:28.773]   - Field: 'owner'
[17:28:28.774]   - Field: 'envir'
[17:28:28.774]   - Field: 'workers'
[17:28:28.775]   - Field: 'packages'
[17:28:28.775]   - Field: 'gc'
[17:28:28.775]   - Field: 'conditions'
[17:28:28.776]   - Field: 'persistent'
[17:28:28.776]   - Field: 'expr'
[17:28:28.776]   - Field: 'uuid'
[17:28:28.777]   - Field: 'seed'
[17:28:28.777]   - Field: 'version'
[17:28:28.777]   - Field: 'result'
[17:28:28.778]   - Field: 'asynchronous'
[17:28:28.778]   - Field: 'calls'
[17:28:28.778]   - Field: 'globals'
[17:28:28.779]   - Field: 'stdout'
[17:28:28.779]   - Field: 'earlySignal'
[17:28:28.779]   - Field: 'lazy'
[17:28:28.780]   - Field: 'state'
[17:28:28.780] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:28.780] - Launch lazy future ...
[17:28:28.781] Packages needed by the future expression (n = 0): <none>
[17:28:28.782] Packages needed by future strategies (n = 0): <none>
[17:28:28.783] {
[17:28:28.783]     {
[17:28:28.783]         {
[17:28:28.783]             ...future.startTime <- base::Sys.time()
[17:28:28.783]             {
[17:28:28.783]                 {
[17:28:28.783]                   {
[17:28:28.783]                     {
[17:28:28.783]                       base::local({
[17:28:28.783]                         has_future <- base::requireNamespace("future", 
[17:28:28.783]                           quietly = TRUE)
[17:28:28.783]                         if (has_future) {
[17:28:28.783]                           ns <- base::getNamespace("future")
[17:28:28.783]                           version <- ns[[".package"]][["version"]]
[17:28:28.783]                           if (is.null(version)) 
[17:28:28.783]                             version <- utils::packageVersion("future")
[17:28:28.783]                         }
[17:28:28.783]                         else {
[17:28:28.783]                           version <- NULL
[17:28:28.783]                         }
[17:28:28.783]                         if (!has_future || version < "1.8.0") {
[17:28:28.783]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:28.783]                             "", base::R.version$version.string), 
[17:28:28.783]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:28.783]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:28.783]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:28.783]                               "release", "version")], collapse = " "), 
[17:28:28.783]                             hostname = base::Sys.info()[["nodename"]])
[17:28:28.783]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:28.783]                             info)
[17:28:28.783]                           info <- base::paste(info, collapse = "; ")
[17:28:28.783]                           if (!has_future) {
[17:28:28.783]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:28.783]                               info)
[17:28:28.783]                           }
[17:28:28.783]                           else {
[17:28:28.783]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:28.783]                               info, version)
[17:28:28.783]                           }
[17:28:28.783]                           base::stop(msg)
[17:28:28.783]                         }
[17:28:28.783]                       })
[17:28:28.783]                     }
[17:28:28.783]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:28.783]                     base::options(mc.cores = 1L)
[17:28:28.783]                   }
[17:28:28.783]                   ...future.strategy.old <- future::plan("list")
[17:28:28.783]                   options(future.plan = NULL)
[17:28:28.783]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:28.783]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:28.783]                 }
[17:28:28.783]                 ...future.workdir <- getwd()
[17:28:28.783]             }
[17:28:28.783]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:28.783]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:28.783]         }
[17:28:28.783]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:28.783]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:28.783]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:28.783]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:28.783]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:28.783]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:28.783]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:28.783]             base::names(...future.oldOptions))
[17:28:28.783]     }
[17:28:28.783]     if (FALSE) {
[17:28:28.783]     }
[17:28:28.783]     else {
[17:28:28.783]         if (TRUE) {
[17:28:28.783]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:28.783]                 open = "w")
[17:28:28.783]         }
[17:28:28.783]         else {
[17:28:28.783]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:28.783]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:28.783]         }
[17:28:28.783]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:28.783]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:28.783]             base::sink(type = "output", split = FALSE)
[17:28:28.783]             base::close(...future.stdout)
[17:28:28.783]         }, add = TRUE)
[17:28:28.783]     }
[17:28:28.783]     ...future.frame <- base::sys.nframe()
[17:28:28.783]     ...future.conditions <- base::list()
[17:28:28.783]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:28.783]     if (FALSE) {
[17:28:28.783]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:28.783]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:28.783]     }
[17:28:28.783]     ...future.result <- base::tryCatch({
[17:28:28.783]         base::withCallingHandlers({
[17:28:28.783]             ...future.value <- base::withVisible(base::local({
[17:28:28.783]                 ...future.makeSendCondition <- base::local({
[17:28:28.783]                   sendCondition <- NULL
[17:28:28.783]                   function(frame = 1L) {
[17:28:28.783]                     if (is.function(sendCondition)) 
[17:28:28.783]                       return(sendCondition)
[17:28:28.783]                     ns <- getNamespace("parallel")
[17:28:28.783]                     if (exists("sendData", mode = "function", 
[17:28:28.783]                       envir = ns)) {
[17:28:28.783]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:28.783]                         envir = ns)
[17:28:28.783]                       envir <- sys.frame(frame)
[17:28:28.783]                       master <- NULL
[17:28:28.783]                       while (!identical(envir, .GlobalEnv) && 
[17:28:28.783]                         !identical(envir, emptyenv())) {
[17:28:28.783]                         if (exists("master", mode = "list", envir = envir, 
[17:28:28.783]                           inherits = FALSE)) {
[17:28:28.783]                           master <- get("master", mode = "list", 
[17:28:28.783]                             envir = envir, inherits = FALSE)
[17:28:28.783]                           if (inherits(master, c("SOCKnode", 
[17:28:28.783]                             "SOCK0node"))) {
[17:28:28.783]                             sendCondition <<- function(cond) {
[17:28:28.783]                               data <- list(type = "VALUE", value = cond, 
[17:28:28.783]                                 success = TRUE)
[17:28:28.783]                               parallel_sendData(master, data)
[17:28:28.783]                             }
[17:28:28.783]                             return(sendCondition)
[17:28:28.783]                           }
[17:28:28.783]                         }
[17:28:28.783]                         frame <- frame + 1L
[17:28:28.783]                         envir <- sys.frame(frame)
[17:28:28.783]                       }
[17:28:28.783]                     }
[17:28:28.783]                     sendCondition <<- function(cond) NULL
[17:28:28.783]                   }
[17:28:28.783]                 })
[17:28:28.783]                 withCallingHandlers({
[17:28:28.783]                   {
[17:28:28.783]                     gc()
[17:28:28.783]                   }
[17:28:28.783]                 }, immediateCondition = function(cond) {
[17:28:28.783]                   sendCondition <- ...future.makeSendCondition()
[17:28:28.783]                   sendCondition(cond)
[17:28:28.783]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:28.783]                   {
[17:28:28.783]                     inherits <- base::inherits
[17:28:28.783]                     invokeRestart <- base::invokeRestart
[17:28:28.783]                     is.null <- base::is.null
[17:28:28.783]                     muffled <- FALSE
[17:28:28.783]                     if (inherits(cond, "message")) {
[17:28:28.783]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:28.783]                       if (muffled) 
[17:28:28.783]                         invokeRestart("muffleMessage")
[17:28:28.783]                     }
[17:28:28.783]                     else if (inherits(cond, "warning")) {
[17:28:28.783]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:28.783]                       if (muffled) 
[17:28:28.783]                         invokeRestart("muffleWarning")
[17:28:28.783]                     }
[17:28:28.783]                     else if (inherits(cond, "condition")) {
[17:28:28.783]                       if (!is.null(pattern)) {
[17:28:28.783]                         computeRestarts <- base::computeRestarts
[17:28:28.783]                         grepl <- base::grepl
[17:28:28.783]                         restarts <- computeRestarts(cond)
[17:28:28.783]                         for (restart in restarts) {
[17:28:28.783]                           name <- restart$name
[17:28:28.783]                           if (is.null(name)) 
[17:28:28.783]                             next
[17:28:28.783]                           if (!grepl(pattern, name)) 
[17:28:28.783]                             next
[17:28:28.783]                           invokeRestart(restart)
[17:28:28.783]                           muffled <- TRUE
[17:28:28.783]                           break
[17:28:28.783]                         }
[17:28:28.783]                       }
[17:28:28.783]                     }
[17:28:28.783]                     invisible(muffled)
[17:28:28.783]                   }
[17:28:28.783]                   muffleCondition(cond)
[17:28:28.783]                 })
[17:28:28.783]             }))
[17:28:28.783]             future::FutureResult(value = ...future.value$value, 
[17:28:28.783]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:28.783]                   ...future.rng), globalenv = if (FALSE) 
[17:28:28.783]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:28.783]                     ...future.globalenv.names))
[17:28:28.783]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:28.783]         }, condition = base::local({
[17:28:28.783]             c <- base::c
[17:28:28.783]             inherits <- base::inherits
[17:28:28.783]             invokeRestart <- base::invokeRestart
[17:28:28.783]             length <- base::length
[17:28:28.783]             list <- base::list
[17:28:28.783]             seq.int <- base::seq.int
[17:28:28.783]             signalCondition <- base::signalCondition
[17:28:28.783]             sys.calls <- base::sys.calls
[17:28:28.783]             `[[` <- base::`[[`
[17:28:28.783]             `+` <- base::`+`
[17:28:28.783]             `<<-` <- base::`<<-`
[17:28:28.783]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:28.783]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:28.783]                   3L)]
[17:28:28.783]             }
[17:28:28.783]             function(cond) {
[17:28:28.783]                 is_error <- inherits(cond, "error")
[17:28:28.783]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:28.783]                   NULL)
[17:28:28.783]                 if (is_error) {
[17:28:28.783]                   sessionInformation <- function() {
[17:28:28.783]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:28.783]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:28.783]                       search = base::search(), system = base::Sys.info())
[17:28:28.783]                   }
[17:28:28.783]                   ...future.conditions[[length(...future.conditions) + 
[17:28:28.783]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:28.783]                     cond$call), session = sessionInformation(), 
[17:28:28.783]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:28.783]                   signalCondition(cond)
[17:28:28.783]                 }
[17:28:28.783]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:28.783]                 "immediateCondition"))) {
[17:28:28.783]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:28.783]                   ...future.conditions[[length(...future.conditions) + 
[17:28:28.783]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:28.783]                   if (TRUE && !signal) {
[17:28:28.783]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:28.783]                     {
[17:28:28.783]                       inherits <- base::inherits
[17:28:28.783]                       invokeRestart <- base::invokeRestart
[17:28:28.783]                       is.null <- base::is.null
[17:28:28.783]                       muffled <- FALSE
[17:28:28.783]                       if (inherits(cond, "message")) {
[17:28:28.783]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:28.783]                         if (muffled) 
[17:28:28.783]                           invokeRestart("muffleMessage")
[17:28:28.783]                       }
[17:28:28.783]                       else if (inherits(cond, "warning")) {
[17:28:28.783]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:28.783]                         if (muffled) 
[17:28:28.783]                           invokeRestart("muffleWarning")
[17:28:28.783]                       }
[17:28:28.783]                       else if (inherits(cond, "condition")) {
[17:28:28.783]                         if (!is.null(pattern)) {
[17:28:28.783]                           computeRestarts <- base::computeRestarts
[17:28:28.783]                           grepl <- base::grepl
[17:28:28.783]                           restarts <- computeRestarts(cond)
[17:28:28.783]                           for (restart in restarts) {
[17:28:28.783]                             name <- restart$name
[17:28:28.783]                             if (is.null(name)) 
[17:28:28.783]                               next
[17:28:28.783]                             if (!grepl(pattern, name)) 
[17:28:28.783]                               next
[17:28:28.783]                             invokeRestart(restart)
[17:28:28.783]                             muffled <- TRUE
[17:28:28.783]                             break
[17:28:28.783]                           }
[17:28:28.783]                         }
[17:28:28.783]                       }
[17:28:28.783]                       invisible(muffled)
[17:28:28.783]                     }
[17:28:28.783]                     muffleCondition(cond, pattern = "^muffle")
[17:28:28.783]                   }
[17:28:28.783]                 }
[17:28:28.783]                 else {
[17:28:28.783]                   if (TRUE) {
[17:28:28.783]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:28.783]                     {
[17:28:28.783]                       inherits <- base::inherits
[17:28:28.783]                       invokeRestart <- base::invokeRestart
[17:28:28.783]                       is.null <- base::is.null
[17:28:28.783]                       muffled <- FALSE
[17:28:28.783]                       if (inherits(cond, "message")) {
[17:28:28.783]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:28.783]                         if (muffled) 
[17:28:28.783]                           invokeRestart("muffleMessage")
[17:28:28.783]                       }
[17:28:28.783]                       else if (inherits(cond, "warning")) {
[17:28:28.783]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:28.783]                         if (muffled) 
[17:28:28.783]                           invokeRestart("muffleWarning")
[17:28:28.783]                       }
[17:28:28.783]                       else if (inherits(cond, "condition")) {
[17:28:28.783]                         if (!is.null(pattern)) {
[17:28:28.783]                           computeRestarts <- base::computeRestarts
[17:28:28.783]                           grepl <- base::grepl
[17:28:28.783]                           restarts <- computeRestarts(cond)
[17:28:28.783]                           for (restart in restarts) {
[17:28:28.783]                             name <- restart$name
[17:28:28.783]                             if (is.null(name)) 
[17:28:28.783]                               next
[17:28:28.783]                             if (!grepl(pattern, name)) 
[17:28:28.783]                               next
[17:28:28.783]                             invokeRestart(restart)
[17:28:28.783]                             muffled <- TRUE
[17:28:28.783]                             break
[17:28:28.783]                           }
[17:28:28.783]                         }
[17:28:28.783]                       }
[17:28:28.783]                       invisible(muffled)
[17:28:28.783]                     }
[17:28:28.783]                     muffleCondition(cond, pattern = "^muffle")
[17:28:28.783]                   }
[17:28:28.783]                 }
[17:28:28.783]             }
[17:28:28.783]         }))
[17:28:28.783]     }, error = function(ex) {
[17:28:28.783]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:28.783]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:28.783]                 ...future.rng), started = ...future.startTime, 
[17:28:28.783]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:28.783]             version = "1.8"), class = "FutureResult")
[17:28:28.783]     }, finally = {
[17:28:28.783]         if (!identical(...future.workdir, getwd())) 
[17:28:28.783]             setwd(...future.workdir)
[17:28:28.783]         {
[17:28:28.783]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:28.783]                 ...future.oldOptions$nwarnings <- NULL
[17:28:28.783]             }
[17:28:28.783]             base::options(...future.oldOptions)
[17:28:28.783]             if (.Platform$OS.type == "windows") {
[17:28:28.783]                 old_names <- names(...future.oldEnvVars)
[17:28:28.783]                 envs <- base::Sys.getenv()
[17:28:28.783]                 names <- names(envs)
[17:28:28.783]                 common <- intersect(names, old_names)
[17:28:28.783]                 added <- setdiff(names, old_names)
[17:28:28.783]                 removed <- setdiff(old_names, names)
[17:28:28.783]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:28.783]                   envs[common]]
[17:28:28.783]                 NAMES <- toupper(changed)
[17:28:28.783]                 args <- list()
[17:28:28.783]                 for (kk in seq_along(NAMES)) {
[17:28:28.783]                   name <- changed[[kk]]
[17:28:28.783]                   NAME <- NAMES[[kk]]
[17:28:28.783]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:28.783]                     next
[17:28:28.783]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:28.783]                 }
[17:28:28.783]                 NAMES <- toupper(added)
[17:28:28.783]                 for (kk in seq_along(NAMES)) {
[17:28:28.783]                   name <- added[[kk]]
[17:28:28.783]                   NAME <- NAMES[[kk]]
[17:28:28.783]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:28.783]                     next
[17:28:28.783]                   args[[name]] <- ""
[17:28:28.783]                 }
[17:28:28.783]                 NAMES <- toupper(removed)
[17:28:28.783]                 for (kk in seq_along(NAMES)) {
[17:28:28.783]                   name <- removed[[kk]]
[17:28:28.783]                   NAME <- NAMES[[kk]]
[17:28:28.783]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:28.783]                     next
[17:28:28.783]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:28.783]                 }
[17:28:28.783]                 if (length(args) > 0) 
[17:28:28.783]                   base::do.call(base::Sys.setenv, args = args)
[17:28:28.783]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:28.783]             }
[17:28:28.783]             else {
[17:28:28.783]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:28.783]             }
[17:28:28.783]             {
[17:28:28.783]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:28.783]                   0L) {
[17:28:28.783]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:28.783]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:28.783]                   base::options(opts)
[17:28:28.783]                 }
[17:28:28.783]                 {
[17:28:28.783]                   {
[17:28:28.783]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:28.783]                     NULL
[17:28:28.783]                   }
[17:28:28.783]                   options(future.plan = NULL)
[17:28:28.783]                   if (is.na(NA_character_)) 
[17:28:28.783]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:28.783]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:28.783]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:28.783]                     .init = FALSE)
[17:28:28.783]                 }
[17:28:28.783]             }
[17:28:28.783]         }
[17:28:28.783]     })
[17:28:28.783]     if (TRUE) {
[17:28:28.783]         base::sink(type = "output", split = FALSE)
[17:28:28.783]         if (TRUE) {
[17:28:28.783]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:28.783]         }
[17:28:28.783]         else {
[17:28:28.783]             ...future.result["stdout"] <- base::list(NULL)
[17:28:28.783]         }
[17:28:28.783]         base::close(...future.stdout)
[17:28:28.783]         ...future.stdout <- NULL
[17:28:28.783]     }
[17:28:28.783]     ...future.result$conditions <- ...future.conditions
[17:28:28.783]     ...future.result$finished <- base::Sys.time()
[17:28:28.783]     ...future.result
[17:28:28.783] }
[17:28:28.794] MultisessionFuture started
[17:28:28.794] - Launch lazy future ... done
[17:28:28.795] run() for 'MultisessionFuture' ... done
> v <- value(f)
[17:28:28.795] result() for ClusterFuture ...
[17:28:28.796] receiveMessageFromWorker() for ClusterFuture ...
[17:28:28.796] - Validating connection of MultisessionFuture
[17:28:28.862] - received message: FutureResult
[17:28:28.862] - Received FutureResult
[17:28:28.863] - Erased future from FutureRegistry
[17:28:28.863] result() for ClusterFuture ...
[17:28:28.863] - result already collected: FutureResult
[17:28:28.864] result() for ClusterFuture ... done
[17:28:28.864] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:28.864] result() for ClusterFuture ... done
[17:28:28.864] result() for ClusterFuture ...
[17:28:28.865] - result already collected: FutureResult
[17:28:28.865] result() for ClusterFuture ... done
> print(v)
         used (Mb) gc trigger (Mb) max used (Mb)
Ncells 417169 22.3     875778 46.8   666050 35.6
Vcells 743004  5.7    8388608 64.0  5870235 44.8
> 
> f <- future({ integer(10e6) }, gc = TRUE)
[17:28:28.866] getGlobalsAndPackages() ...
[17:28:28.866] Searching for globals...
[17:28:28.868] - globals found: [2] '{', 'integer'
[17:28:28.868] Searching for globals ... DONE
[17:28:28.869] Resolving globals: FALSE
[17:28:28.869] 
[17:28:28.870] 
[17:28:28.870] getGlobalsAndPackages() ... DONE
[17:28:28.871] run() for 'Future' ...
[17:28:28.871] - state: 'created'
[17:28:28.871] - Future backend: 'FutureStrategy', 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:28.889] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:28.889] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:28.890]   - Field: 'node'
[17:28:28.890]   - Field: 'label'
[17:28:28.890]   - Field: 'local'
[17:28:28.891]   - Field: 'owner'
[17:28:28.891]   - Field: 'envir'
[17:28:28.891]   - Field: 'workers'
[17:28:28.892]   - Field: 'packages'
[17:28:28.892]   - Field: 'gc'
[17:28:28.892]   - Field: 'conditions'
[17:28:28.893]   - Field: 'persistent'
[17:28:28.893]   - Field: 'expr'
[17:28:28.893]   - Field: 'uuid'
[17:28:28.894]   - Field: 'seed'
[17:28:28.894]   - Field: 'version'
[17:28:28.894]   - Field: 'result'
[17:28:28.895]   - Field: 'asynchronous'
[17:28:28.895]   - Field: 'calls'
[17:28:28.895]   - Field: 'globals'
[17:28:28.896]   - Field: 'stdout'
[17:28:28.896]   - Field: 'earlySignal'
[17:28:28.896]   - Field: 'lazy'
[17:28:28.897]   - Field: 'state'
[17:28:28.897] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:28.897] - Launch lazy future ...
[17:28:28.898] Packages needed by the future expression (n = 0): <none>
[17:28:28.898] Packages needed by future strategies (n = 0): <none>
[17:28:28.900] {
[17:28:28.900]     {
[17:28:28.900]         {
[17:28:28.900]             ...future.startTime <- base::Sys.time()
[17:28:28.900]             {
[17:28:28.900]                 {
[17:28:28.900]                   {
[17:28:28.900]                     {
[17:28:28.900]                       base::local({
[17:28:28.900]                         has_future <- base::requireNamespace("future", 
[17:28:28.900]                           quietly = TRUE)
[17:28:28.900]                         if (has_future) {
[17:28:28.900]                           ns <- base::getNamespace("future")
[17:28:28.900]                           version <- ns[[".package"]][["version"]]
[17:28:28.900]                           if (is.null(version)) 
[17:28:28.900]                             version <- utils::packageVersion("future")
[17:28:28.900]                         }
[17:28:28.900]                         else {
[17:28:28.900]                           version <- NULL
[17:28:28.900]                         }
[17:28:28.900]                         if (!has_future || version < "1.8.0") {
[17:28:28.900]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:28.900]                             "", base::R.version$version.string), 
[17:28:28.900]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:28.900]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:28.900]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:28.900]                               "release", "version")], collapse = " "), 
[17:28:28.900]                             hostname = base::Sys.info()[["nodename"]])
[17:28:28.900]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:28.900]                             info)
[17:28:28.900]                           info <- base::paste(info, collapse = "; ")
[17:28:28.900]                           if (!has_future) {
[17:28:28.900]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:28.900]                               info)
[17:28:28.900]                           }
[17:28:28.900]                           else {
[17:28:28.900]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:28.900]                               info, version)
[17:28:28.900]                           }
[17:28:28.900]                           base::stop(msg)
[17:28:28.900]                         }
[17:28:28.900]                       })
[17:28:28.900]                     }
[17:28:28.900]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:28.900]                     base::options(mc.cores = 1L)
[17:28:28.900]                   }
[17:28:28.900]                   ...future.strategy.old <- future::plan("list")
[17:28:28.900]                   options(future.plan = NULL)
[17:28:28.900]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:28.900]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:28.900]                 }
[17:28:28.900]                 ...future.workdir <- getwd()
[17:28:28.900]             }
[17:28:28.900]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:28.900]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:28.900]         }
[17:28:28.900]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:28.900]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:28.900]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:28.900]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:28.900]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:28.900]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:28.900]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:28.900]             base::names(...future.oldOptions))
[17:28:28.900]     }
[17:28:28.900]     if (FALSE) {
[17:28:28.900]     }
[17:28:28.900]     else {
[17:28:28.900]         if (TRUE) {
[17:28:28.900]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:28.900]                 open = "w")
[17:28:28.900]         }
[17:28:28.900]         else {
[17:28:28.900]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:28.900]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:28.900]         }
[17:28:28.900]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:28.900]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:28.900]             base::sink(type = "output", split = FALSE)
[17:28:28.900]             base::close(...future.stdout)
[17:28:28.900]         }, add = TRUE)
[17:28:28.900]     }
[17:28:28.900]     ...future.frame <- base::sys.nframe()
[17:28:28.900]     ...future.conditions <- base::list()
[17:28:28.900]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:28.900]     if (FALSE) {
[17:28:28.900]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:28.900]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:28.900]     }
[17:28:28.900]     ...future.result <- base::tryCatch({
[17:28:28.900]         base::withCallingHandlers({
[17:28:28.900]             ...future.value <- base::withVisible(base::local({
[17:28:28.900]                 ...future.makeSendCondition <- base::local({
[17:28:28.900]                   sendCondition <- NULL
[17:28:28.900]                   function(frame = 1L) {
[17:28:28.900]                     if (is.function(sendCondition)) 
[17:28:28.900]                       return(sendCondition)
[17:28:28.900]                     ns <- getNamespace("parallel")
[17:28:28.900]                     if (exists("sendData", mode = "function", 
[17:28:28.900]                       envir = ns)) {
[17:28:28.900]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:28.900]                         envir = ns)
[17:28:28.900]                       envir <- sys.frame(frame)
[17:28:28.900]                       master <- NULL
[17:28:28.900]                       while (!identical(envir, .GlobalEnv) && 
[17:28:28.900]                         !identical(envir, emptyenv())) {
[17:28:28.900]                         if (exists("master", mode = "list", envir = envir, 
[17:28:28.900]                           inherits = FALSE)) {
[17:28:28.900]                           master <- get("master", mode = "list", 
[17:28:28.900]                             envir = envir, inherits = FALSE)
[17:28:28.900]                           if (inherits(master, c("SOCKnode", 
[17:28:28.900]                             "SOCK0node"))) {
[17:28:28.900]                             sendCondition <<- function(cond) {
[17:28:28.900]                               data <- list(type = "VALUE", value = cond, 
[17:28:28.900]                                 success = TRUE)
[17:28:28.900]                               parallel_sendData(master, data)
[17:28:28.900]                             }
[17:28:28.900]                             return(sendCondition)
[17:28:28.900]                           }
[17:28:28.900]                         }
[17:28:28.900]                         frame <- frame + 1L
[17:28:28.900]                         envir <- sys.frame(frame)
[17:28:28.900]                       }
[17:28:28.900]                     }
[17:28:28.900]                     sendCondition <<- function(cond) NULL
[17:28:28.900]                   }
[17:28:28.900]                 })
[17:28:28.900]                 withCallingHandlers({
[17:28:28.900]                   {
[17:28:28.900]                     integer(1e+07)
[17:28:28.900]                   }
[17:28:28.900]                 }, immediateCondition = function(cond) {
[17:28:28.900]                   sendCondition <- ...future.makeSendCondition()
[17:28:28.900]                   sendCondition(cond)
[17:28:28.900]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:28.900]                   {
[17:28:28.900]                     inherits <- base::inherits
[17:28:28.900]                     invokeRestart <- base::invokeRestart
[17:28:28.900]                     is.null <- base::is.null
[17:28:28.900]                     muffled <- FALSE
[17:28:28.900]                     if (inherits(cond, "message")) {
[17:28:28.900]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:28.900]                       if (muffled) 
[17:28:28.900]                         invokeRestart("muffleMessage")
[17:28:28.900]                     }
[17:28:28.900]                     else if (inherits(cond, "warning")) {
[17:28:28.900]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:28.900]                       if (muffled) 
[17:28:28.900]                         invokeRestart("muffleWarning")
[17:28:28.900]                     }
[17:28:28.900]                     else if (inherits(cond, "condition")) {
[17:28:28.900]                       if (!is.null(pattern)) {
[17:28:28.900]                         computeRestarts <- base::computeRestarts
[17:28:28.900]                         grepl <- base::grepl
[17:28:28.900]                         restarts <- computeRestarts(cond)
[17:28:28.900]                         for (restart in restarts) {
[17:28:28.900]                           name <- restart$name
[17:28:28.900]                           if (is.null(name)) 
[17:28:28.900]                             next
[17:28:28.900]                           if (!grepl(pattern, name)) 
[17:28:28.900]                             next
[17:28:28.900]                           invokeRestart(restart)
[17:28:28.900]                           muffled <- TRUE
[17:28:28.900]                           break
[17:28:28.900]                         }
[17:28:28.900]                       }
[17:28:28.900]                     }
[17:28:28.900]                     invisible(muffled)
[17:28:28.900]                   }
[17:28:28.900]                   muffleCondition(cond)
[17:28:28.900]                 })
[17:28:28.900]             }))
[17:28:28.900]             future::FutureResult(value = ...future.value$value, 
[17:28:28.900]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:28.900]                   ...future.rng), globalenv = if (FALSE) 
[17:28:28.900]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:28.900]                     ...future.globalenv.names))
[17:28:28.900]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:28.900]         }, condition = base::local({
[17:28:28.900]             c <- base::c
[17:28:28.900]             inherits <- base::inherits
[17:28:28.900]             invokeRestart <- base::invokeRestart
[17:28:28.900]             length <- base::length
[17:28:28.900]             list <- base::list
[17:28:28.900]             seq.int <- base::seq.int
[17:28:28.900]             signalCondition <- base::signalCondition
[17:28:28.900]             sys.calls <- base::sys.calls
[17:28:28.900]             `[[` <- base::`[[`
[17:28:28.900]             `+` <- base::`+`
[17:28:28.900]             `<<-` <- base::`<<-`
[17:28:28.900]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:28.900]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:28.900]                   3L)]
[17:28:28.900]             }
[17:28:28.900]             function(cond) {
[17:28:28.900]                 is_error <- inherits(cond, "error")
[17:28:28.900]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:28.900]                   NULL)
[17:28:28.900]                 if (is_error) {
[17:28:28.900]                   sessionInformation <- function() {
[17:28:28.900]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:28.900]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:28.900]                       search = base::search(), system = base::Sys.info())
[17:28:28.900]                   }
[17:28:28.900]                   ...future.conditions[[length(...future.conditions) + 
[17:28:28.900]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:28.900]                     cond$call), session = sessionInformation(), 
[17:28:28.900]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:28.900]                   signalCondition(cond)
[17:28:28.900]                 }
[17:28:28.900]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:28.900]                 "immediateCondition"))) {
[17:28:28.900]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:28.900]                   ...future.conditions[[length(...future.conditions) + 
[17:28:28.900]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:28.900]                   if (TRUE && !signal) {
[17:28:28.900]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:28.900]                     {
[17:28:28.900]                       inherits <- base::inherits
[17:28:28.900]                       invokeRestart <- base::invokeRestart
[17:28:28.900]                       is.null <- base::is.null
[17:28:28.900]                       muffled <- FALSE
[17:28:28.900]                       if (inherits(cond, "message")) {
[17:28:28.900]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:28.900]                         if (muffled) 
[17:28:28.900]                           invokeRestart("muffleMessage")
[17:28:28.900]                       }
[17:28:28.900]                       else if (inherits(cond, "warning")) {
[17:28:28.900]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:28.900]                         if (muffled) 
[17:28:28.900]                           invokeRestart("muffleWarning")
[17:28:28.900]                       }
[17:28:28.900]                       else if (inherits(cond, "condition")) {
[17:28:28.900]                         if (!is.null(pattern)) {
[17:28:28.900]                           computeRestarts <- base::computeRestarts
[17:28:28.900]                           grepl <- base::grepl
[17:28:28.900]                           restarts <- computeRestarts(cond)
[17:28:28.900]                           for (restart in restarts) {
[17:28:28.900]                             name <- restart$name
[17:28:28.900]                             if (is.null(name)) 
[17:28:28.900]                               next
[17:28:28.900]                             if (!grepl(pattern, name)) 
[17:28:28.900]                               next
[17:28:28.900]                             invokeRestart(restart)
[17:28:28.900]                             muffled <- TRUE
[17:28:28.900]                             break
[17:28:28.900]                           }
[17:28:28.900]                         }
[17:28:28.900]                       }
[17:28:28.900]                       invisible(muffled)
[17:28:28.900]                     }
[17:28:28.900]                     muffleCondition(cond, pattern = "^muffle")
[17:28:28.900]                   }
[17:28:28.900]                 }
[17:28:28.900]                 else {
[17:28:28.900]                   if (TRUE) {
[17:28:28.900]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:28.900]                     {
[17:28:28.900]                       inherits <- base::inherits
[17:28:28.900]                       invokeRestart <- base::invokeRestart
[17:28:28.900]                       is.null <- base::is.null
[17:28:28.900]                       muffled <- FALSE
[17:28:28.900]                       if (inherits(cond, "message")) {
[17:28:28.900]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:28.900]                         if (muffled) 
[17:28:28.900]                           invokeRestart("muffleMessage")
[17:28:28.900]                       }
[17:28:28.900]                       else if (inherits(cond, "warning")) {
[17:28:28.900]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:28.900]                         if (muffled) 
[17:28:28.900]                           invokeRestart("muffleWarning")
[17:28:28.900]                       }
[17:28:28.900]                       else if (inherits(cond, "condition")) {
[17:28:28.900]                         if (!is.null(pattern)) {
[17:28:28.900]                           computeRestarts <- base::computeRestarts
[17:28:28.900]                           grepl <- base::grepl
[17:28:28.900]                           restarts <- computeRestarts(cond)
[17:28:28.900]                           for (restart in restarts) {
[17:28:28.900]                             name <- restart$name
[17:28:28.900]                             if (is.null(name)) 
[17:28:28.900]                               next
[17:28:28.900]                             if (!grepl(pattern, name)) 
[17:28:28.900]                               next
[17:28:28.900]                             invokeRestart(restart)
[17:28:28.900]                             muffled <- TRUE
[17:28:28.900]                             break
[17:28:28.900]                           }
[17:28:28.900]                         }
[17:28:28.900]                       }
[17:28:28.900]                       invisible(muffled)
[17:28:28.900]                     }
[17:28:28.900]                     muffleCondition(cond, pattern = "^muffle")
[17:28:28.900]                   }
[17:28:28.900]                 }
[17:28:28.900]             }
[17:28:28.900]         }))
[17:28:28.900]     }, error = function(ex) {
[17:28:28.900]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:28.900]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:28.900]                 ...future.rng), started = ...future.startTime, 
[17:28:28.900]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:28.900]             version = "1.8"), class = "FutureResult")
[17:28:28.900]     }, finally = {
[17:28:28.900]         if (!identical(...future.workdir, getwd())) 
[17:28:28.900]             setwd(...future.workdir)
[17:28:28.900]         {
[17:28:28.900]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:28.900]                 ...future.oldOptions$nwarnings <- NULL
[17:28:28.900]             }
[17:28:28.900]             base::options(...future.oldOptions)
[17:28:28.900]             if (.Platform$OS.type == "windows") {
[17:28:28.900]                 old_names <- names(...future.oldEnvVars)
[17:28:28.900]                 envs <- base::Sys.getenv()
[17:28:28.900]                 names <- names(envs)
[17:28:28.900]                 common <- intersect(names, old_names)
[17:28:28.900]                 added <- setdiff(names, old_names)
[17:28:28.900]                 removed <- setdiff(old_names, names)
[17:28:28.900]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:28.900]                   envs[common]]
[17:28:28.900]                 NAMES <- toupper(changed)
[17:28:28.900]                 args <- list()
[17:28:28.900]                 for (kk in seq_along(NAMES)) {
[17:28:28.900]                   name <- changed[[kk]]
[17:28:28.900]                   NAME <- NAMES[[kk]]
[17:28:28.900]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:28.900]                     next
[17:28:28.900]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:28.900]                 }
[17:28:28.900]                 NAMES <- toupper(added)
[17:28:28.900]                 for (kk in seq_along(NAMES)) {
[17:28:28.900]                   name <- added[[kk]]
[17:28:28.900]                   NAME <- NAMES[[kk]]
[17:28:28.900]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:28.900]                     next
[17:28:28.900]                   args[[name]] <- ""
[17:28:28.900]                 }
[17:28:28.900]                 NAMES <- toupper(removed)
[17:28:28.900]                 for (kk in seq_along(NAMES)) {
[17:28:28.900]                   name <- removed[[kk]]
[17:28:28.900]                   NAME <- NAMES[[kk]]
[17:28:28.900]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:28.900]                     next
[17:28:28.900]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:28.900]                 }
[17:28:28.900]                 if (length(args) > 0) 
[17:28:28.900]                   base::do.call(base::Sys.setenv, args = args)
[17:28:28.900]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:28.900]             }
[17:28:28.900]             else {
[17:28:28.900]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:28.900]             }
[17:28:28.900]             {
[17:28:28.900]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:28.900]                   0L) {
[17:28:28.900]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:28.900]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:28.900]                   base::options(opts)
[17:28:28.900]                 }
[17:28:28.900]                 {
[17:28:28.900]                   {
[17:28:28.900]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:28.900]                     NULL
[17:28:28.900]                   }
[17:28:28.900]                   options(future.plan = NULL)
[17:28:28.900]                   if (is.na(NA_character_)) 
[17:28:28.900]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:28.900]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:28.900]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:28.900]                     .init = FALSE)
[17:28:28.900]                 }
[17:28:28.900]             }
[17:28:28.900]         }
[17:28:28.900]     })
[17:28:28.900]     if (TRUE) {
[17:28:28.900]         base::sink(type = "output", split = FALSE)
[17:28:28.900]         if (TRUE) {
[17:28:28.900]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:28.900]         }
[17:28:28.900]         else {
[17:28:28.900]             ...future.result["stdout"] <- base::list(NULL)
[17:28:28.900]         }
[17:28:28.900]         base::close(...future.stdout)
[17:28:28.900]         ...future.stdout <- NULL
[17:28:28.900]     }
[17:28:28.900]     ...future.result$conditions <- ...future.conditions
[17:28:28.900]     ...future.result$finished <- base::Sys.time()
[17:28:28.900]     ...future.result
[17:28:28.900] }
[17:28:28.910] MultisessionFuture started
[17:28:28.910] - Launch lazy future ... done
[17:28:28.910] run() for 'MultisessionFuture' ... done
> v <- value(f)
[17:28:28.911] result() for ClusterFuture ...
[17:28:28.911] receiveMessageFromWorker() for ClusterFuture ...
[17:28:28.911] - Validating connection of MultisessionFuture
[17:28:29.049] - received message: FutureResult
[17:28:29.049] - Received FutureResult
[17:28:29.050] - Erased future from FutureRegistry
[17:28:29.050] result() for ClusterFuture ...
[17:28:29.051] - result already collected: FutureResult
[17:28:29.051] result() for ClusterFuture ... done
[17:28:29.051] - Garbage collecting worker ...
[17:28:29.457] - Garbage collecting worker ... done
[17:28:29.457] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:29.457] result() for ClusterFuture ... done
[17:28:29.458] result() for ClusterFuture ...
[17:28:29.458] - result already collected: FutureResult
[17:28:29.458] result() for ClusterFuture ... done
> str(v)
 int [1:10000000] 0 0 0 0 0 0 0 0 0 0 ...
> 
> f <- future({ gc() })
[17:28:29.459] getGlobalsAndPackages() ...
[17:28:29.460] Searching for globals...
[17:28:29.461] - globals found: [2] '{', 'gc'
[17:28:29.461] Searching for globals ... DONE
[17:28:29.462] Resolving globals: FALSE
[17:28:29.462] 
[17:28:29.462] 
[17:28:29.463] getGlobalsAndPackages() ... DONE
[17:28:29.463] run() for 'Future' ...
[17:28:29.464] - state: 'created'
[17:28:29.464] - Future backend: 'FutureStrategy', 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:29.480] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:29.481] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:29.481]   - Field: 'node'
[17:28:29.481]   - Field: 'label'
[17:28:29.482]   - Field: 'local'
[17:28:29.482]   - Field: 'owner'
[17:28:29.482]   - Field: 'envir'
[17:28:29.483]   - Field: 'workers'
[17:28:29.483]   - Field: 'packages'
[17:28:29.483]   - Field: 'gc'
[17:28:29.484]   - Field: 'conditions'
[17:28:29.484]   - Field: 'persistent'
[17:28:29.484]   - Field: 'expr'
[17:28:29.485]   - Field: 'uuid'
[17:28:29.485]   - Field: 'seed'
[17:28:29.485]   - Field: 'version'
[17:28:29.485]   - Field: 'result'
[17:28:29.486]   - Field: 'asynchronous'
[17:28:29.486]   - Field: 'calls'
[17:28:29.486]   - Field: 'globals'
[17:28:29.487]   - Field: 'stdout'
[17:28:29.487]   - Field: 'earlySignal'
[17:28:29.487]   - Field: 'lazy'
[17:28:29.487]   - Field: 'state'
[17:28:29.488] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:29.488] - Launch lazy future ...
[17:28:29.489] Packages needed by the future expression (n = 0): <none>
[17:28:29.489] Packages needed by future strategies (n = 0): <none>
[17:28:29.490] {
[17:28:29.490]     {
[17:28:29.490]         {
[17:28:29.490]             ...future.startTime <- base::Sys.time()
[17:28:29.490]             {
[17:28:29.490]                 {
[17:28:29.490]                   {
[17:28:29.490]                     {
[17:28:29.490]                       base::local({
[17:28:29.490]                         has_future <- base::requireNamespace("future", 
[17:28:29.490]                           quietly = TRUE)
[17:28:29.490]                         if (has_future) {
[17:28:29.490]                           ns <- base::getNamespace("future")
[17:28:29.490]                           version <- ns[[".package"]][["version"]]
[17:28:29.490]                           if (is.null(version)) 
[17:28:29.490]                             version <- utils::packageVersion("future")
[17:28:29.490]                         }
[17:28:29.490]                         else {
[17:28:29.490]                           version <- NULL
[17:28:29.490]                         }
[17:28:29.490]                         if (!has_future || version < "1.8.0") {
[17:28:29.490]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:29.490]                             "", base::R.version$version.string), 
[17:28:29.490]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:29.490]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:29.490]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:29.490]                               "release", "version")], collapse = " "), 
[17:28:29.490]                             hostname = base::Sys.info()[["nodename"]])
[17:28:29.490]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:29.490]                             info)
[17:28:29.490]                           info <- base::paste(info, collapse = "; ")
[17:28:29.490]                           if (!has_future) {
[17:28:29.490]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:29.490]                               info)
[17:28:29.490]                           }
[17:28:29.490]                           else {
[17:28:29.490]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:29.490]                               info, version)
[17:28:29.490]                           }
[17:28:29.490]                           base::stop(msg)
[17:28:29.490]                         }
[17:28:29.490]                       })
[17:28:29.490]                     }
[17:28:29.490]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:29.490]                     base::options(mc.cores = 1L)
[17:28:29.490]                   }
[17:28:29.490]                   ...future.strategy.old <- future::plan("list")
[17:28:29.490]                   options(future.plan = NULL)
[17:28:29.490]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:29.490]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:29.490]                 }
[17:28:29.490]                 ...future.workdir <- getwd()
[17:28:29.490]             }
[17:28:29.490]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:29.490]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:29.490]         }
[17:28:29.490]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:29.490]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:29.490]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:29.490]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:29.490]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:29.490]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:29.490]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:29.490]             base::names(...future.oldOptions))
[17:28:29.490]     }
[17:28:29.490]     if (FALSE) {
[17:28:29.490]     }
[17:28:29.490]     else {
[17:28:29.490]         if (TRUE) {
[17:28:29.490]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:29.490]                 open = "w")
[17:28:29.490]         }
[17:28:29.490]         else {
[17:28:29.490]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:29.490]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:29.490]         }
[17:28:29.490]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:29.490]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:29.490]             base::sink(type = "output", split = FALSE)
[17:28:29.490]             base::close(...future.stdout)
[17:28:29.490]         }, add = TRUE)
[17:28:29.490]     }
[17:28:29.490]     ...future.frame <- base::sys.nframe()
[17:28:29.490]     ...future.conditions <- base::list()
[17:28:29.490]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:29.490]     if (FALSE) {
[17:28:29.490]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:29.490]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:29.490]     }
[17:28:29.490]     ...future.result <- base::tryCatch({
[17:28:29.490]         base::withCallingHandlers({
[17:28:29.490]             ...future.value <- base::withVisible(base::local({
[17:28:29.490]                 ...future.makeSendCondition <- base::local({
[17:28:29.490]                   sendCondition <- NULL
[17:28:29.490]                   function(frame = 1L) {
[17:28:29.490]                     if (is.function(sendCondition)) 
[17:28:29.490]                       return(sendCondition)
[17:28:29.490]                     ns <- getNamespace("parallel")
[17:28:29.490]                     if (exists("sendData", mode = "function", 
[17:28:29.490]                       envir = ns)) {
[17:28:29.490]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:29.490]                         envir = ns)
[17:28:29.490]                       envir <- sys.frame(frame)
[17:28:29.490]                       master <- NULL
[17:28:29.490]                       while (!identical(envir, .GlobalEnv) && 
[17:28:29.490]                         !identical(envir, emptyenv())) {
[17:28:29.490]                         if (exists("master", mode = "list", envir = envir, 
[17:28:29.490]                           inherits = FALSE)) {
[17:28:29.490]                           master <- get("master", mode = "list", 
[17:28:29.490]                             envir = envir, inherits = FALSE)
[17:28:29.490]                           if (inherits(master, c("SOCKnode", 
[17:28:29.490]                             "SOCK0node"))) {
[17:28:29.490]                             sendCondition <<- function(cond) {
[17:28:29.490]                               data <- list(type = "VALUE", value = cond, 
[17:28:29.490]                                 success = TRUE)
[17:28:29.490]                               parallel_sendData(master, data)
[17:28:29.490]                             }
[17:28:29.490]                             return(sendCondition)
[17:28:29.490]                           }
[17:28:29.490]                         }
[17:28:29.490]                         frame <- frame + 1L
[17:28:29.490]                         envir <- sys.frame(frame)
[17:28:29.490]                       }
[17:28:29.490]                     }
[17:28:29.490]                     sendCondition <<- function(cond) NULL
[17:28:29.490]                   }
[17:28:29.490]                 })
[17:28:29.490]                 withCallingHandlers({
[17:28:29.490]                   {
[17:28:29.490]                     gc()
[17:28:29.490]                   }
[17:28:29.490]                 }, immediateCondition = function(cond) {
[17:28:29.490]                   sendCondition <- ...future.makeSendCondition()
[17:28:29.490]                   sendCondition(cond)
[17:28:29.490]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:29.490]                   {
[17:28:29.490]                     inherits <- base::inherits
[17:28:29.490]                     invokeRestart <- base::invokeRestart
[17:28:29.490]                     is.null <- base::is.null
[17:28:29.490]                     muffled <- FALSE
[17:28:29.490]                     if (inherits(cond, "message")) {
[17:28:29.490]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:29.490]                       if (muffled) 
[17:28:29.490]                         invokeRestart("muffleMessage")
[17:28:29.490]                     }
[17:28:29.490]                     else if (inherits(cond, "warning")) {
[17:28:29.490]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:29.490]                       if (muffled) 
[17:28:29.490]                         invokeRestart("muffleWarning")
[17:28:29.490]                     }
[17:28:29.490]                     else if (inherits(cond, "condition")) {
[17:28:29.490]                       if (!is.null(pattern)) {
[17:28:29.490]                         computeRestarts <- base::computeRestarts
[17:28:29.490]                         grepl <- base::grepl
[17:28:29.490]                         restarts <- computeRestarts(cond)
[17:28:29.490]                         for (restart in restarts) {
[17:28:29.490]                           name <- restart$name
[17:28:29.490]                           if (is.null(name)) 
[17:28:29.490]                             next
[17:28:29.490]                           if (!grepl(pattern, name)) 
[17:28:29.490]                             next
[17:28:29.490]                           invokeRestart(restart)
[17:28:29.490]                           muffled <- TRUE
[17:28:29.490]                           break
[17:28:29.490]                         }
[17:28:29.490]                       }
[17:28:29.490]                     }
[17:28:29.490]                     invisible(muffled)
[17:28:29.490]                   }
[17:28:29.490]                   muffleCondition(cond)
[17:28:29.490]                 })
[17:28:29.490]             }))
[17:28:29.490]             future::FutureResult(value = ...future.value$value, 
[17:28:29.490]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:29.490]                   ...future.rng), globalenv = if (FALSE) 
[17:28:29.490]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:29.490]                     ...future.globalenv.names))
[17:28:29.490]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:29.490]         }, condition = base::local({
[17:28:29.490]             c <- base::c
[17:28:29.490]             inherits <- base::inherits
[17:28:29.490]             invokeRestart <- base::invokeRestart
[17:28:29.490]             length <- base::length
[17:28:29.490]             list <- base::list
[17:28:29.490]             seq.int <- base::seq.int
[17:28:29.490]             signalCondition <- base::signalCondition
[17:28:29.490]             sys.calls <- base::sys.calls
[17:28:29.490]             `[[` <- base::`[[`
[17:28:29.490]             `+` <- base::`+`
[17:28:29.490]             `<<-` <- base::`<<-`
[17:28:29.490]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:29.490]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:29.490]                   3L)]
[17:28:29.490]             }
[17:28:29.490]             function(cond) {
[17:28:29.490]                 is_error <- inherits(cond, "error")
[17:28:29.490]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:29.490]                   NULL)
[17:28:29.490]                 if (is_error) {
[17:28:29.490]                   sessionInformation <- function() {
[17:28:29.490]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:29.490]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:29.490]                       search = base::search(), system = base::Sys.info())
[17:28:29.490]                   }
[17:28:29.490]                   ...future.conditions[[length(...future.conditions) + 
[17:28:29.490]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:29.490]                     cond$call), session = sessionInformation(), 
[17:28:29.490]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:29.490]                   signalCondition(cond)
[17:28:29.490]                 }
[17:28:29.490]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:29.490]                 "immediateCondition"))) {
[17:28:29.490]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:29.490]                   ...future.conditions[[length(...future.conditions) + 
[17:28:29.490]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:29.490]                   if (TRUE && !signal) {
[17:28:29.490]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:29.490]                     {
[17:28:29.490]                       inherits <- base::inherits
[17:28:29.490]                       invokeRestart <- base::invokeRestart
[17:28:29.490]                       is.null <- base::is.null
[17:28:29.490]                       muffled <- FALSE
[17:28:29.490]                       if (inherits(cond, "message")) {
[17:28:29.490]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:29.490]                         if (muffled) 
[17:28:29.490]                           invokeRestart("muffleMessage")
[17:28:29.490]                       }
[17:28:29.490]                       else if (inherits(cond, "warning")) {
[17:28:29.490]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:29.490]                         if (muffled) 
[17:28:29.490]                           invokeRestart("muffleWarning")
[17:28:29.490]                       }
[17:28:29.490]                       else if (inherits(cond, "condition")) {
[17:28:29.490]                         if (!is.null(pattern)) {
[17:28:29.490]                           computeRestarts <- base::computeRestarts
[17:28:29.490]                           grepl <- base::grepl
[17:28:29.490]                           restarts <- computeRestarts(cond)
[17:28:29.490]                           for (restart in restarts) {
[17:28:29.490]                             name <- restart$name
[17:28:29.490]                             if (is.null(name)) 
[17:28:29.490]                               next
[17:28:29.490]                             if (!grepl(pattern, name)) 
[17:28:29.490]                               next
[17:28:29.490]                             invokeRestart(restart)
[17:28:29.490]                             muffled <- TRUE
[17:28:29.490]                             break
[17:28:29.490]                           }
[17:28:29.490]                         }
[17:28:29.490]                       }
[17:28:29.490]                       invisible(muffled)
[17:28:29.490]                     }
[17:28:29.490]                     muffleCondition(cond, pattern = "^muffle")
[17:28:29.490]                   }
[17:28:29.490]                 }
[17:28:29.490]                 else {
[17:28:29.490]                   if (TRUE) {
[17:28:29.490]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:29.490]                     {
[17:28:29.490]                       inherits <- base::inherits
[17:28:29.490]                       invokeRestart <- base::invokeRestart
[17:28:29.490]                       is.null <- base::is.null
[17:28:29.490]                       muffled <- FALSE
[17:28:29.490]                       if (inherits(cond, "message")) {
[17:28:29.490]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:29.490]                         if (muffled) 
[17:28:29.490]                           invokeRestart("muffleMessage")
[17:28:29.490]                       }
[17:28:29.490]                       else if (inherits(cond, "warning")) {
[17:28:29.490]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:29.490]                         if (muffled) 
[17:28:29.490]                           invokeRestart("muffleWarning")
[17:28:29.490]                       }
[17:28:29.490]                       else if (inherits(cond, "condition")) {
[17:28:29.490]                         if (!is.null(pattern)) {
[17:28:29.490]                           computeRestarts <- base::computeRestarts
[17:28:29.490]                           grepl <- base::grepl
[17:28:29.490]                           restarts <- computeRestarts(cond)
[17:28:29.490]                           for (restart in restarts) {
[17:28:29.490]                             name <- restart$name
[17:28:29.490]                             if (is.null(name)) 
[17:28:29.490]                               next
[17:28:29.490]                             if (!grepl(pattern, name)) 
[17:28:29.490]                               next
[17:28:29.490]                             invokeRestart(restart)
[17:28:29.490]                             muffled <- TRUE
[17:28:29.490]                             break
[17:28:29.490]                           }
[17:28:29.490]                         }
[17:28:29.490]                       }
[17:28:29.490]                       invisible(muffled)
[17:28:29.490]                     }
[17:28:29.490]                     muffleCondition(cond, pattern = "^muffle")
[17:28:29.490]                   }
[17:28:29.490]                 }
[17:28:29.490]             }
[17:28:29.490]         }))
[17:28:29.490]     }, error = function(ex) {
[17:28:29.490]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:29.490]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:29.490]                 ...future.rng), started = ...future.startTime, 
[17:28:29.490]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:29.490]             version = "1.8"), class = "FutureResult")
[17:28:29.490]     }, finally = {
[17:28:29.490]         if (!identical(...future.workdir, getwd())) 
[17:28:29.490]             setwd(...future.workdir)
[17:28:29.490]         {
[17:28:29.490]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:29.490]                 ...future.oldOptions$nwarnings <- NULL
[17:28:29.490]             }
[17:28:29.490]             base::options(...future.oldOptions)
[17:28:29.490]             if (.Platform$OS.type == "windows") {
[17:28:29.490]                 old_names <- names(...future.oldEnvVars)
[17:28:29.490]                 envs <- base::Sys.getenv()
[17:28:29.490]                 names <- names(envs)
[17:28:29.490]                 common <- intersect(names, old_names)
[17:28:29.490]                 added <- setdiff(names, old_names)
[17:28:29.490]                 removed <- setdiff(old_names, names)
[17:28:29.490]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:29.490]                   envs[common]]
[17:28:29.490]                 NAMES <- toupper(changed)
[17:28:29.490]                 args <- list()
[17:28:29.490]                 for (kk in seq_along(NAMES)) {
[17:28:29.490]                   name <- changed[[kk]]
[17:28:29.490]                   NAME <- NAMES[[kk]]
[17:28:29.490]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:29.490]                     next
[17:28:29.490]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:29.490]                 }
[17:28:29.490]                 NAMES <- toupper(added)
[17:28:29.490]                 for (kk in seq_along(NAMES)) {
[17:28:29.490]                   name <- added[[kk]]
[17:28:29.490]                   NAME <- NAMES[[kk]]
[17:28:29.490]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:29.490]                     next
[17:28:29.490]                   args[[name]] <- ""
[17:28:29.490]                 }
[17:28:29.490]                 NAMES <- toupper(removed)
[17:28:29.490]                 for (kk in seq_along(NAMES)) {
[17:28:29.490]                   name <- removed[[kk]]
[17:28:29.490]                   NAME <- NAMES[[kk]]
[17:28:29.490]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:29.490]                     next
[17:28:29.490]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:29.490]                 }
[17:28:29.490]                 if (length(args) > 0) 
[17:28:29.490]                   base::do.call(base::Sys.setenv, args = args)
[17:28:29.490]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:29.490]             }
[17:28:29.490]             else {
[17:28:29.490]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:29.490]             }
[17:28:29.490]             {
[17:28:29.490]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:29.490]                   0L) {
[17:28:29.490]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:29.490]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:29.490]                   base::options(opts)
[17:28:29.490]                 }
[17:28:29.490]                 {
[17:28:29.490]                   {
[17:28:29.490]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:29.490]                     NULL
[17:28:29.490]                   }
[17:28:29.490]                   options(future.plan = NULL)
[17:28:29.490]                   if (is.na(NA_character_)) 
[17:28:29.490]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:29.490]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:29.490]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:29.490]                     .init = FALSE)
[17:28:29.490]                 }
[17:28:29.490]             }
[17:28:29.490]         }
[17:28:29.490]     })
[17:28:29.490]     if (TRUE) {
[17:28:29.490]         base::sink(type = "output", split = FALSE)
[17:28:29.490]         if (TRUE) {
[17:28:29.490]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:29.490]         }
[17:28:29.490]         else {
[17:28:29.490]             ...future.result["stdout"] <- base::list(NULL)
[17:28:29.490]         }
[17:28:29.490]         base::close(...future.stdout)
[17:28:29.490]         ...future.stdout <- NULL
[17:28:29.490]     }
[17:28:29.490]     ...future.result$conditions <- ...future.conditions
[17:28:29.490]     ...future.result$finished <- base::Sys.time()
[17:28:29.490]     ...future.result
[17:28:29.490] }
[17:28:29.500] MultisessionFuture started
[17:28:29.500] - Launch lazy future ... done
[17:28:29.500] run() for 'MultisessionFuture' ... done
> v <- value(f)
[17:28:29.501] result() for ClusterFuture ...
[17:28:29.501] receiveMessageFromWorker() for ClusterFuture ...
[17:28:29.501] - Validating connection of MultisessionFuture
[17:28:29.543] - received message: FutureResult
[17:28:29.544] - Received FutureResult
[17:28:29.544] - Erased future from FutureRegistry
[17:28:29.545] result() for ClusterFuture ...
[17:28:29.545] - result already collected: FutureResult
[17:28:29.545] result() for ClusterFuture ... done
[17:28:29.546] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:29.546] result() for ClusterFuture ... done
[17:28:29.546] result() for ClusterFuture ...
[17:28:29.547] - result already collected: FutureResult
[17:28:29.547] result() for ClusterFuture ... done
> print(v)
         used (Mb) gc trigger  (Mb) max used  (Mb)
Ncells 417303 22.3     875778  46.8   666050  35.6
Vcells 743079  5.7   13490050 103.0 15823171 120.8
> 
> message("*** multisession(..., gc = TRUE) ... TRUE")
*** multisession(..., gc = TRUE) ... TRUE
> 
> 
> message("*** multisession(...) - stopping with plan() change ...")
*** multisession(...) - stopping with plan() change ...
>   
> plan(multisession, workers = 2L)
[17:28:29.549] plan(): Setting new future strategy stack:
[17:28:29.549] List of future strategies:
[17:28:29.549] 1. multisession:
[17:28:29.549]    - args: function (..., workers = 2L, envir = parent.frame())
[17:28:29.549]    - tweaked: TRUE
[17:28:29.549]    - call: plan(multisession, workers = 2L)
[17:28:29.559] plan(): plan_init() of 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[17:28:29.560] multisession:
[17:28:29.560] - args: function (..., workers = 2L, envir = parent.frame())
[17:28:29.560] - tweaked: TRUE
[17:28:29.560] - call: plan(multisession, workers = 2L)
[17:28:29.561] getGlobalsAndPackages() ...
[17:28:29.561] Not searching for globals
[17:28:29.562] - globals: [0] <none>
[17:28:29.562] getGlobalsAndPackages() ... DONE
[17:28:29.563] [local output] makeClusterPSOCK() ...
[17:28:29.566] [local output] Workers: [n = 2] 'localhost', 'localhost'
[17:28:29.570] [local output] Base port: 32337
[17:28:29.570] [local output] Getting setup options for 2 cluster nodes ...
[17:28:29.570] [local output]  - Node #1 of 2 ...
[17:28:29.571] [local output] localMachine=TRUE => revtunnel=FALSE

[17:28:29.573] [local output] Rscript port: 32337

[17:28:29.574] [local output]  - Node #2 of 2 ...
[17:28:29.575] [local output] localMachine=TRUE => revtunnel=FALSE

[17:28:29.577] [local output] Rscript port: 32337

[17:28:29.577] [local output] Getting setup options for 2 cluster nodes ... done
[17:28:29.578] [local output]  - Parallel setup requested for some PSOCK nodes
[17:28:29.578] [local output] Setting up PSOCK nodes in parallel
[17:28:29.579] List of 36
[17:28:29.579]  $ worker          : chr "localhost"
[17:28:29.579]   ..- attr(*, "localhost")= logi TRUE
[17:28:29.579]  $ master          : chr "localhost"
[17:28:29.579]  $ port            : int 32337
[17:28:29.579]  $ connectTimeout  : num 120
[17:28:29.579]  $ timeout         : num 120
[17:28:29.579]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[17:28:29.579]  $ homogeneous     : logi TRUE
[17:28:29.579]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=multisession.R:85924:CRANWIN3:CR"| __truncated__
[17:28:29.579]  $ rscript_envs    : NULL
[17:28:29.579]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda" "D:/RCompile/recent/R/library"
[17:28:29.579]  $ rscript_startup : NULL
[17:28:29.579]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[17:28:29.579]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:28:29.579]  $ methods         : logi TRUE
[17:28:29.579]  $ socketOptions   : chr "no-delay"
[17:28:29.579]  $ useXDR          : logi FALSE
[17:28:29.579]  $ outfile         : chr "/dev/null"
[17:28:29.579]  $ renice          : int NA
[17:28:29.579]  $ rshcmd          : NULL
[17:28:29.579]  $ user            : chr(0) 
[17:28:29.579]  $ revtunnel       : logi FALSE
[17:28:29.579]  $ rshlogfile      : NULL
[17:28:29.579]  $ rshopts         : chr(0) 
[17:28:29.579]  $ rank            : int 1
[17:28:29.579]  $ manual          : logi FALSE
[17:28:29.579]  $ dryrun          : logi FALSE
[17:28:29.579]  $ quiet           : logi FALSE
[17:28:29.579]  $ setup_strategy  : chr "parallel"
[17:28:29.579]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:28:29.579]  $ pidfile         : chr "D:/temp/Rtmp6N6urL/worker.rank=1.parallelly.parent=85924.14fa477101ad7.pid"
[17:28:29.579]  $ rshcmd_label    : NULL
[17:28:29.579]  $ rsh_call        : NULL
[17:28:29.579]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:28:29.579]  $ localMachine    : logi TRUE
[17:28:29.579]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[17:28:29.579]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[17:28:29.579]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[17:28:29.579]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[17:28:29.579]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[17:28:29.579]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[17:28:29.579]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[17:28:29.579]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[17:28:29.579]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[17:28:29.579]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[17:28:29.579]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[17:28:29.579]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[17:28:29.579]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[17:28:29.579]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[17:28:29.579]  $ arguments       :List of 28
[17:28:29.579]   ..$ worker          : chr "localhost"
[17:28:29.579]   ..$ master          : NULL
[17:28:29.579]   ..$ port            : int 32337
[17:28:29.579]   ..$ connectTimeout  : num 120
[17:28:29.579]   ..$ timeout         : num 120
[17:28:29.579]   ..$ rscript         : NULL
[17:28:29.579]   ..$ homogeneous     : NULL
[17:28:29.579]   ..$ rscript_args    : NULL
[17:28:29.579]   ..$ rscript_envs    : NULL
[17:28:29.579]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda" "D:/RCompile/recent/R/library"
[17:28:29.579]   ..$ rscript_startup : NULL
[17:28:29.579]   ..$ rscript_sh      : chr "auto"
[17:28:29.579]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:28:29.579]   ..$ methods         : logi TRUE
[17:28:29.579]   ..$ socketOptions   : chr "no-delay"
[17:28:29.579]   ..$ useXDR          : logi FALSE
[17:28:29.579]   ..$ outfile         : chr "/dev/null"
[17:28:29.579]   ..$ renice          : int NA
[17:28:29.579]   ..$ rshcmd          : NULL
[17:28:29.579]   ..$ user            : NULL
[17:28:29.579]   ..$ revtunnel       : logi NA
[17:28:29.579]   ..$ rshlogfile      : NULL
[17:28:29.579]   ..$ rshopts         : NULL
[17:28:29.579]   ..$ rank            : int 1
[17:28:29.579]   ..$ manual          : logi FALSE
[17:28:29.579]   ..$ dryrun          : logi FALSE
[17:28:29.579]   ..$ quiet           : logi FALSE
[17:28:29.579]   ..$ setup_strategy  : chr "parallel"
[17:28:29.579]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[17:28:29.611] [local output] System call to launch all workers:
[17:28:29.611] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=multisession.R:85924:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/Rtmp6N6urL/worker.rank=1.parallelly.parent=85924.14fa477101ad7.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=32337 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[17:28:29.612] [local output] Starting PSOCK main server
[17:28:29.621] [local output] Workers launched
[17:28:29.621] [local output] Waiting for workers to connect back
[17:28:29.622]  - [local output] 0 workers out of 2 ready
[17:28:29.850]  - [local output] 0 workers out of 2 ready
[17:28:29.850]  - [local output] 1 workers out of 2 ready
[17:28:29.860]  - [local output] 1 workers out of 2 ready
[17:28:29.861]  - [local output] 2 workers out of 2 ready
[17:28:29.861] [local output] Launching of 2 workers completed
[17:28:29.861] [local output] Number of nodes in cluster: 2
[17:28:29.862] [local output] Collecting session information from 2 workers
[17:28:29.863] [local output]  - Worker #1 of 2
[17:28:29.864] [local output]  - Worker #2 of 2
[17:28:29.864] [local output] makeClusterPSOCK() ... done
[17:28:29.879] Packages needed by the future expression (n = 0): <none>
[17:28:29.880] Packages needed by future strategies (n = 0): <none>
[17:28:29.881] {
[17:28:29.881]     {
[17:28:29.881]         {
[17:28:29.881]             ...future.startTime <- base::Sys.time()
[17:28:29.881]             {
[17:28:29.881]                 {
[17:28:29.881]                   {
[17:28:29.881]                     {
[17:28:29.881]                       base::local({
[17:28:29.881]                         has_future <- base::requireNamespace("future", 
[17:28:29.881]                           quietly = TRUE)
[17:28:29.881]                         if (has_future) {
[17:28:29.881]                           ns <- base::getNamespace("future")
[17:28:29.881]                           version <- ns[[".package"]][["version"]]
[17:28:29.881]                           if (is.null(version)) 
[17:28:29.881]                             version <- utils::packageVersion("future")
[17:28:29.881]                         }
[17:28:29.881]                         else {
[17:28:29.881]                           version <- NULL
[17:28:29.881]                         }
[17:28:29.881]                         if (!has_future || version < "1.8.0") {
[17:28:29.881]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:29.881]                             "", base::R.version$version.string), 
[17:28:29.881]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:29.881]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:29.881]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:29.881]                               "release", "version")], collapse = " "), 
[17:28:29.881]                             hostname = base::Sys.info()[["nodename"]])
[17:28:29.881]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:29.881]                             info)
[17:28:29.881]                           info <- base::paste(info, collapse = "; ")
[17:28:29.881]                           if (!has_future) {
[17:28:29.881]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:29.881]                               info)
[17:28:29.881]                           }
[17:28:29.881]                           else {
[17:28:29.881]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:29.881]                               info, version)
[17:28:29.881]                           }
[17:28:29.881]                           base::stop(msg)
[17:28:29.881]                         }
[17:28:29.881]                       })
[17:28:29.881]                     }
[17:28:29.881]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:29.881]                     base::options(mc.cores = 1L)
[17:28:29.881]                   }
[17:28:29.881]                   ...future.strategy.old <- future::plan("list")
[17:28:29.881]                   options(future.plan = NULL)
[17:28:29.881]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:29.881]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:29.881]                 }
[17:28:29.881]                 ...future.workdir <- getwd()
[17:28:29.881]             }
[17:28:29.881]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:29.881]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:29.881]         }
[17:28:29.881]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:29.881]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:29.881]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:29.881]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:29.881]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:29.881]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:29.881]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:29.881]             base::names(...future.oldOptions))
[17:28:29.881]     }
[17:28:29.881]     if (FALSE) {
[17:28:29.881]     }
[17:28:29.881]     else {
[17:28:29.881]         if (TRUE) {
[17:28:29.881]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:29.881]                 open = "w")
[17:28:29.881]         }
[17:28:29.881]         else {
[17:28:29.881]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:29.881]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:29.881]         }
[17:28:29.881]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:29.881]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:29.881]             base::sink(type = "output", split = FALSE)
[17:28:29.881]             base::close(...future.stdout)
[17:28:29.881]         }, add = TRUE)
[17:28:29.881]     }
[17:28:29.881]     ...future.frame <- base::sys.nframe()
[17:28:29.881]     ...future.conditions <- base::list()
[17:28:29.881]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:29.881]     if (FALSE) {
[17:28:29.881]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:29.881]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:29.881]     }
[17:28:29.881]     ...future.result <- base::tryCatch({
[17:28:29.881]         base::withCallingHandlers({
[17:28:29.881]             ...future.value <- base::withVisible(base::local({
[17:28:29.881]                 ...future.makeSendCondition <- base::local({
[17:28:29.881]                   sendCondition <- NULL
[17:28:29.881]                   function(frame = 1L) {
[17:28:29.881]                     if (is.function(sendCondition)) 
[17:28:29.881]                       return(sendCondition)
[17:28:29.881]                     ns <- getNamespace("parallel")
[17:28:29.881]                     if (exists("sendData", mode = "function", 
[17:28:29.881]                       envir = ns)) {
[17:28:29.881]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:29.881]                         envir = ns)
[17:28:29.881]                       envir <- sys.frame(frame)
[17:28:29.881]                       master <- NULL
[17:28:29.881]                       while (!identical(envir, .GlobalEnv) && 
[17:28:29.881]                         !identical(envir, emptyenv())) {
[17:28:29.881]                         if (exists("master", mode = "list", envir = envir, 
[17:28:29.881]                           inherits = FALSE)) {
[17:28:29.881]                           master <- get("master", mode = "list", 
[17:28:29.881]                             envir = envir, inherits = FALSE)
[17:28:29.881]                           if (inherits(master, c("SOCKnode", 
[17:28:29.881]                             "SOCK0node"))) {
[17:28:29.881]                             sendCondition <<- function(cond) {
[17:28:29.881]                               data <- list(type = "VALUE", value = cond, 
[17:28:29.881]                                 success = TRUE)
[17:28:29.881]                               parallel_sendData(master, data)
[17:28:29.881]                             }
[17:28:29.881]                             return(sendCondition)
[17:28:29.881]                           }
[17:28:29.881]                         }
[17:28:29.881]                         frame <- frame + 1L
[17:28:29.881]                         envir <- sys.frame(frame)
[17:28:29.881]                       }
[17:28:29.881]                     }
[17:28:29.881]                     sendCondition <<- function(cond) NULL
[17:28:29.881]                   }
[17:28:29.881]                 })
[17:28:29.881]                 withCallingHandlers({
[17:28:29.881]                   NA
[17:28:29.881]                 }, immediateCondition = function(cond) {
[17:28:29.881]                   sendCondition <- ...future.makeSendCondition()
[17:28:29.881]                   sendCondition(cond)
[17:28:29.881]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:29.881]                   {
[17:28:29.881]                     inherits <- base::inherits
[17:28:29.881]                     invokeRestart <- base::invokeRestart
[17:28:29.881]                     is.null <- base::is.null
[17:28:29.881]                     muffled <- FALSE
[17:28:29.881]                     if (inherits(cond, "message")) {
[17:28:29.881]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:29.881]                       if (muffled) 
[17:28:29.881]                         invokeRestart("muffleMessage")
[17:28:29.881]                     }
[17:28:29.881]                     else if (inherits(cond, "warning")) {
[17:28:29.881]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:29.881]                       if (muffled) 
[17:28:29.881]                         invokeRestart("muffleWarning")
[17:28:29.881]                     }
[17:28:29.881]                     else if (inherits(cond, "condition")) {
[17:28:29.881]                       if (!is.null(pattern)) {
[17:28:29.881]                         computeRestarts <- base::computeRestarts
[17:28:29.881]                         grepl <- base::grepl
[17:28:29.881]                         restarts <- computeRestarts(cond)
[17:28:29.881]                         for (restart in restarts) {
[17:28:29.881]                           name <- restart$name
[17:28:29.881]                           if (is.null(name)) 
[17:28:29.881]                             next
[17:28:29.881]                           if (!grepl(pattern, name)) 
[17:28:29.881]                             next
[17:28:29.881]                           invokeRestart(restart)
[17:28:29.881]                           muffled <- TRUE
[17:28:29.881]                           break
[17:28:29.881]                         }
[17:28:29.881]                       }
[17:28:29.881]                     }
[17:28:29.881]                     invisible(muffled)
[17:28:29.881]                   }
[17:28:29.881]                   muffleCondition(cond)
[17:28:29.881]                 })
[17:28:29.881]             }))
[17:28:29.881]             future::FutureResult(value = ...future.value$value, 
[17:28:29.881]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:29.881]                   ...future.rng), globalenv = if (FALSE) 
[17:28:29.881]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:29.881]                     ...future.globalenv.names))
[17:28:29.881]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:29.881]         }, condition = base::local({
[17:28:29.881]             c <- base::c
[17:28:29.881]             inherits <- base::inherits
[17:28:29.881]             invokeRestart <- base::invokeRestart
[17:28:29.881]             length <- base::length
[17:28:29.881]             list <- base::list
[17:28:29.881]             seq.int <- base::seq.int
[17:28:29.881]             signalCondition <- base::signalCondition
[17:28:29.881]             sys.calls <- base::sys.calls
[17:28:29.881]             `[[` <- base::`[[`
[17:28:29.881]             `+` <- base::`+`
[17:28:29.881]             `<<-` <- base::`<<-`
[17:28:29.881]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:29.881]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:29.881]                   3L)]
[17:28:29.881]             }
[17:28:29.881]             function(cond) {
[17:28:29.881]                 is_error <- inherits(cond, "error")
[17:28:29.881]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:29.881]                   NULL)
[17:28:29.881]                 if (is_error) {
[17:28:29.881]                   sessionInformation <- function() {
[17:28:29.881]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:29.881]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:29.881]                       search = base::search(), system = base::Sys.info())
[17:28:29.881]                   }
[17:28:29.881]                   ...future.conditions[[length(...future.conditions) + 
[17:28:29.881]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:29.881]                     cond$call), session = sessionInformation(), 
[17:28:29.881]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:29.881]                   signalCondition(cond)
[17:28:29.881]                 }
[17:28:29.881]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:29.881]                 "immediateCondition"))) {
[17:28:29.881]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:29.881]                   ...future.conditions[[length(...future.conditions) + 
[17:28:29.881]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:29.881]                   if (TRUE && !signal) {
[17:28:29.881]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:29.881]                     {
[17:28:29.881]                       inherits <- base::inherits
[17:28:29.881]                       invokeRestart <- base::invokeRestart
[17:28:29.881]                       is.null <- base::is.null
[17:28:29.881]                       muffled <- FALSE
[17:28:29.881]                       if (inherits(cond, "message")) {
[17:28:29.881]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:29.881]                         if (muffled) 
[17:28:29.881]                           invokeRestart("muffleMessage")
[17:28:29.881]                       }
[17:28:29.881]                       else if (inherits(cond, "warning")) {
[17:28:29.881]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:29.881]                         if (muffled) 
[17:28:29.881]                           invokeRestart("muffleWarning")
[17:28:29.881]                       }
[17:28:29.881]                       else if (inherits(cond, "condition")) {
[17:28:29.881]                         if (!is.null(pattern)) {
[17:28:29.881]                           computeRestarts <- base::computeRestarts
[17:28:29.881]                           grepl <- base::grepl
[17:28:29.881]                           restarts <- computeRestarts(cond)
[17:28:29.881]                           for (restart in restarts) {
[17:28:29.881]                             name <- restart$name
[17:28:29.881]                             if (is.null(name)) 
[17:28:29.881]                               next
[17:28:29.881]                             if (!grepl(pattern, name)) 
[17:28:29.881]                               next
[17:28:29.881]                             invokeRestart(restart)
[17:28:29.881]                             muffled <- TRUE
[17:28:29.881]                             break
[17:28:29.881]                           }
[17:28:29.881]                         }
[17:28:29.881]                       }
[17:28:29.881]                       invisible(muffled)
[17:28:29.881]                     }
[17:28:29.881]                     muffleCondition(cond, pattern = "^muffle")
[17:28:29.881]                   }
[17:28:29.881]                 }
[17:28:29.881]                 else {
[17:28:29.881]                   if (TRUE) {
[17:28:29.881]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:29.881]                     {
[17:28:29.881]                       inherits <- base::inherits
[17:28:29.881]                       invokeRestart <- base::invokeRestart
[17:28:29.881]                       is.null <- base::is.null
[17:28:29.881]                       muffled <- FALSE
[17:28:29.881]                       if (inherits(cond, "message")) {
[17:28:29.881]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:29.881]                         if (muffled) 
[17:28:29.881]                           invokeRestart("muffleMessage")
[17:28:29.881]                       }
[17:28:29.881]                       else if (inherits(cond, "warning")) {
[17:28:29.881]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:29.881]                         if (muffled) 
[17:28:29.881]                           invokeRestart("muffleWarning")
[17:28:29.881]                       }
[17:28:29.881]                       else if (inherits(cond, "condition")) {
[17:28:29.881]                         if (!is.null(pattern)) {
[17:28:29.881]                           computeRestarts <- base::computeRestarts
[17:28:29.881]                           grepl <- base::grepl
[17:28:29.881]                           restarts <- computeRestarts(cond)
[17:28:29.881]                           for (restart in restarts) {
[17:28:29.881]                             name <- restart$name
[17:28:29.881]                             if (is.null(name)) 
[17:28:29.881]                               next
[17:28:29.881]                             if (!grepl(pattern, name)) 
[17:28:29.881]                               next
[17:28:29.881]                             invokeRestart(restart)
[17:28:29.881]                             muffled <- TRUE
[17:28:29.881]                             break
[17:28:29.881]                           }
[17:28:29.881]                         }
[17:28:29.881]                       }
[17:28:29.881]                       invisible(muffled)
[17:28:29.881]                     }
[17:28:29.881]                     muffleCondition(cond, pattern = "^muffle")
[17:28:29.881]                   }
[17:28:29.881]                 }
[17:28:29.881]             }
[17:28:29.881]         }))
[17:28:29.881]     }, error = function(ex) {
[17:28:29.881]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:29.881]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:29.881]                 ...future.rng), started = ...future.startTime, 
[17:28:29.881]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:29.881]             version = "1.8"), class = "FutureResult")
[17:28:29.881]     }, finally = {
[17:28:29.881]         if (!identical(...future.workdir, getwd())) 
[17:28:29.881]             setwd(...future.workdir)
[17:28:29.881]         {
[17:28:29.881]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:29.881]                 ...future.oldOptions$nwarnings <- NULL
[17:28:29.881]             }
[17:28:29.881]             base::options(...future.oldOptions)
[17:28:29.881]             if (.Platform$OS.type == "windows") {
[17:28:29.881]                 old_names <- names(...future.oldEnvVars)
[17:28:29.881]                 envs <- base::Sys.getenv()
[17:28:29.881]                 names <- names(envs)
[17:28:29.881]                 common <- intersect(names, old_names)
[17:28:29.881]                 added <- setdiff(names, old_names)
[17:28:29.881]                 removed <- setdiff(old_names, names)
[17:28:29.881]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:29.881]                   envs[common]]
[17:28:29.881]                 NAMES <- toupper(changed)
[17:28:29.881]                 args <- list()
[17:28:29.881]                 for (kk in seq_along(NAMES)) {
[17:28:29.881]                   name <- changed[[kk]]
[17:28:29.881]                   NAME <- NAMES[[kk]]
[17:28:29.881]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:29.881]                     next
[17:28:29.881]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:29.881]                 }
[17:28:29.881]                 NAMES <- toupper(added)
[17:28:29.881]                 for (kk in seq_along(NAMES)) {
[17:28:29.881]                   name <- added[[kk]]
[17:28:29.881]                   NAME <- NAMES[[kk]]
[17:28:29.881]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:29.881]                     next
[17:28:29.881]                   args[[name]] <- ""
[17:28:29.881]                 }
[17:28:29.881]                 NAMES <- toupper(removed)
[17:28:29.881]                 for (kk in seq_along(NAMES)) {
[17:28:29.881]                   name <- removed[[kk]]
[17:28:29.881]                   NAME <- NAMES[[kk]]
[17:28:29.881]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:29.881]                     next
[17:28:29.881]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:29.881]                 }
[17:28:29.881]                 if (length(args) > 0) 
[17:28:29.881]                   base::do.call(base::Sys.setenv, args = args)
[17:28:29.881]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:29.881]             }
[17:28:29.881]             else {
[17:28:29.881]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:29.881]             }
[17:28:29.881]             {
[17:28:29.881]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:29.881]                   0L) {
[17:28:29.881]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:29.881]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:29.881]                   base::options(opts)
[17:28:29.881]                 }
[17:28:29.881]                 {
[17:28:29.881]                   {
[17:28:29.881]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:29.881]                     NULL
[17:28:29.881]                   }
[17:28:29.881]                   options(future.plan = NULL)
[17:28:29.881]                   if (is.na(NA_character_)) 
[17:28:29.881]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:29.881]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:29.881]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:29.881]                     .init = FALSE)
[17:28:29.881]                 }
[17:28:29.881]             }
[17:28:29.881]         }
[17:28:29.881]     })
[17:28:29.881]     if (TRUE) {
[17:28:29.881]         base::sink(type = "output", split = FALSE)
[17:28:29.881]         if (TRUE) {
[17:28:29.881]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:29.881]         }
[17:28:29.881]         else {
[17:28:29.881]             ...future.result["stdout"] <- base::list(NULL)
[17:28:29.881]         }
[17:28:29.881]         base::close(...future.stdout)
[17:28:29.881]         ...future.stdout <- NULL
[17:28:29.881]     }
[17:28:29.881]     ...future.result$conditions <- ...future.conditions
[17:28:29.881]     ...future.result$finished <- base::Sys.time()
[17:28:29.881]     ...future.result
[17:28:29.881] }
[17:28:30.031] MultisessionFuture started
[17:28:30.032] result() for ClusterFuture ...
[17:28:30.032] receiveMessageFromWorker() for ClusterFuture ...
[17:28:30.033] - Validating connection of MultisessionFuture
[17:28:30.116] - received message: FutureResult
[17:28:30.116] - Received FutureResult
[17:28:30.117] - Erased future from FutureRegistry
[17:28:30.117] result() for ClusterFuture ...
[17:28:30.117] - result already collected: FutureResult
[17:28:30.117] result() for ClusterFuture ... done
[17:28:30.118] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:30.118] result() for ClusterFuture ... done
[17:28:30.118] result() for ClusterFuture ...
[17:28:30.118] - result already collected: FutureResult
[17:28:30.119] result() for ClusterFuture ... done
[17:28:30.119] plan(): plan_init() of 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[17:28:30.120] plan(): nbrOfWorkers() = 2
> f <- future(1L)
[17:28:30.120] getGlobalsAndPackages() ...
[17:28:30.120] Searching for globals...
[17:28:30.121] 
[17:28:30.121] Searching for globals ... DONE
[17:28:30.121] - globals: [0] <none>
[17:28:30.122] getGlobalsAndPackages() ... DONE
[17:28:30.122] run() for 'Future' ...
[17:28:30.123] - state: 'created'
[17:28:30.123] - Future backend: 'FutureStrategy', 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:30.139] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:30.139] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:30.140]   - Field: 'node'
[17:28:30.140]   - Field: 'label'
[17:28:30.140]   - Field: 'local'
[17:28:30.140]   - Field: 'owner'
[17:28:30.141]   - Field: 'envir'
[17:28:30.141]   - Field: 'workers'
[17:28:30.141]   - Field: 'packages'
[17:28:30.142]   - Field: 'gc'
[17:28:30.142]   - Field: 'conditions'
[17:28:30.142]   - Field: 'persistent'
[17:28:30.142]   - Field: 'expr'
[17:28:30.143]   - Field: 'uuid'
[17:28:30.143]   - Field: 'seed'
[17:28:30.143]   - Field: 'version'
[17:28:30.143]   - Field: 'result'
[17:28:30.144]   - Field: 'asynchronous'
[17:28:30.144]   - Field: 'calls'
[17:28:30.145]   - Field: 'globals'
[17:28:30.145]   - Field: 'stdout'
[17:28:30.145]   - Field: 'earlySignal'
[17:28:30.146]   - Field: 'lazy'
[17:28:30.146]   - Field: 'state'
[17:28:30.146] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:30.147] - Launch lazy future ...
[17:28:30.147] Packages needed by the future expression (n = 0): <none>
[17:28:30.148] Packages needed by future strategies (n = 0): <none>
[17:28:30.149] {
[17:28:30.149]     {
[17:28:30.149]         {
[17:28:30.149]             ...future.startTime <- base::Sys.time()
[17:28:30.149]             {
[17:28:30.149]                 {
[17:28:30.149]                   {
[17:28:30.149]                     {
[17:28:30.149]                       base::local({
[17:28:30.149]                         has_future <- base::requireNamespace("future", 
[17:28:30.149]                           quietly = TRUE)
[17:28:30.149]                         if (has_future) {
[17:28:30.149]                           ns <- base::getNamespace("future")
[17:28:30.149]                           version <- ns[[".package"]][["version"]]
[17:28:30.149]                           if (is.null(version)) 
[17:28:30.149]                             version <- utils::packageVersion("future")
[17:28:30.149]                         }
[17:28:30.149]                         else {
[17:28:30.149]                           version <- NULL
[17:28:30.149]                         }
[17:28:30.149]                         if (!has_future || version < "1.8.0") {
[17:28:30.149]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:30.149]                             "", base::R.version$version.string), 
[17:28:30.149]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:30.149]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:30.149]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:30.149]                               "release", "version")], collapse = " "), 
[17:28:30.149]                             hostname = base::Sys.info()[["nodename"]])
[17:28:30.149]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:30.149]                             info)
[17:28:30.149]                           info <- base::paste(info, collapse = "; ")
[17:28:30.149]                           if (!has_future) {
[17:28:30.149]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:30.149]                               info)
[17:28:30.149]                           }
[17:28:30.149]                           else {
[17:28:30.149]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:30.149]                               info, version)
[17:28:30.149]                           }
[17:28:30.149]                           base::stop(msg)
[17:28:30.149]                         }
[17:28:30.149]                       })
[17:28:30.149]                     }
[17:28:30.149]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:30.149]                     base::options(mc.cores = 1L)
[17:28:30.149]                   }
[17:28:30.149]                   ...future.strategy.old <- future::plan("list")
[17:28:30.149]                   options(future.plan = NULL)
[17:28:30.149]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:30.149]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:30.149]                 }
[17:28:30.149]                 ...future.workdir <- getwd()
[17:28:30.149]             }
[17:28:30.149]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:30.149]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:30.149]         }
[17:28:30.149]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:30.149]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:30.149]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:30.149]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:30.149]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:30.149]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:30.149]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:30.149]             base::names(...future.oldOptions))
[17:28:30.149]     }
[17:28:30.149]     if (FALSE) {
[17:28:30.149]     }
[17:28:30.149]     else {
[17:28:30.149]         if (TRUE) {
[17:28:30.149]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:30.149]                 open = "w")
[17:28:30.149]         }
[17:28:30.149]         else {
[17:28:30.149]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:30.149]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:30.149]         }
[17:28:30.149]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:30.149]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:30.149]             base::sink(type = "output", split = FALSE)
[17:28:30.149]             base::close(...future.stdout)
[17:28:30.149]         }, add = TRUE)
[17:28:30.149]     }
[17:28:30.149]     ...future.frame <- base::sys.nframe()
[17:28:30.149]     ...future.conditions <- base::list()
[17:28:30.149]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:30.149]     if (FALSE) {
[17:28:30.149]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:30.149]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:30.149]     }
[17:28:30.149]     ...future.result <- base::tryCatch({
[17:28:30.149]         base::withCallingHandlers({
[17:28:30.149]             ...future.value <- base::withVisible(base::local({
[17:28:30.149]                 ...future.makeSendCondition <- base::local({
[17:28:30.149]                   sendCondition <- NULL
[17:28:30.149]                   function(frame = 1L) {
[17:28:30.149]                     if (is.function(sendCondition)) 
[17:28:30.149]                       return(sendCondition)
[17:28:30.149]                     ns <- getNamespace("parallel")
[17:28:30.149]                     if (exists("sendData", mode = "function", 
[17:28:30.149]                       envir = ns)) {
[17:28:30.149]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:30.149]                         envir = ns)
[17:28:30.149]                       envir <- sys.frame(frame)
[17:28:30.149]                       master <- NULL
[17:28:30.149]                       while (!identical(envir, .GlobalEnv) && 
[17:28:30.149]                         !identical(envir, emptyenv())) {
[17:28:30.149]                         if (exists("master", mode = "list", envir = envir, 
[17:28:30.149]                           inherits = FALSE)) {
[17:28:30.149]                           master <- get("master", mode = "list", 
[17:28:30.149]                             envir = envir, inherits = FALSE)
[17:28:30.149]                           if (inherits(master, c("SOCKnode", 
[17:28:30.149]                             "SOCK0node"))) {
[17:28:30.149]                             sendCondition <<- function(cond) {
[17:28:30.149]                               data <- list(type = "VALUE", value = cond, 
[17:28:30.149]                                 success = TRUE)
[17:28:30.149]                               parallel_sendData(master, data)
[17:28:30.149]                             }
[17:28:30.149]                             return(sendCondition)
[17:28:30.149]                           }
[17:28:30.149]                         }
[17:28:30.149]                         frame <- frame + 1L
[17:28:30.149]                         envir <- sys.frame(frame)
[17:28:30.149]                       }
[17:28:30.149]                     }
[17:28:30.149]                     sendCondition <<- function(cond) NULL
[17:28:30.149]                   }
[17:28:30.149]                 })
[17:28:30.149]                 withCallingHandlers({
[17:28:30.149]                   1L
[17:28:30.149]                 }, immediateCondition = function(cond) {
[17:28:30.149]                   sendCondition <- ...future.makeSendCondition()
[17:28:30.149]                   sendCondition(cond)
[17:28:30.149]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:30.149]                   {
[17:28:30.149]                     inherits <- base::inherits
[17:28:30.149]                     invokeRestart <- base::invokeRestart
[17:28:30.149]                     is.null <- base::is.null
[17:28:30.149]                     muffled <- FALSE
[17:28:30.149]                     if (inherits(cond, "message")) {
[17:28:30.149]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:30.149]                       if (muffled) 
[17:28:30.149]                         invokeRestart("muffleMessage")
[17:28:30.149]                     }
[17:28:30.149]                     else if (inherits(cond, "warning")) {
[17:28:30.149]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:30.149]                       if (muffled) 
[17:28:30.149]                         invokeRestart("muffleWarning")
[17:28:30.149]                     }
[17:28:30.149]                     else if (inherits(cond, "condition")) {
[17:28:30.149]                       if (!is.null(pattern)) {
[17:28:30.149]                         computeRestarts <- base::computeRestarts
[17:28:30.149]                         grepl <- base::grepl
[17:28:30.149]                         restarts <- computeRestarts(cond)
[17:28:30.149]                         for (restart in restarts) {
[17:28:30.149]                           name <- restart$name
[17:28:30.149]                           if (is.null(name)) 
[17:28:30.149]                             next
[17:28:30.149]                           if (!grepl(pattern, name)) 
[17:28:30.149]                             next
[17:28:30.149]                           invokeRestart(restart)
[17:28:30.149]                           muffled <- TRUE
[17:28:30.149]                           break
[17:28:30.149]                         }
[17:28:30.149]                       }
[17:28:30.149]                     }
[17:28:30.149]                     invisible(muffled)
[17:28:30.149]                   }
[17:28:30.149]                   muffleCondition(cond)
[17:28:30.149]                 })
[17:28:30.149]             }))
[17:28:30.149]             future::FutureResult(value = ...future.value$value, 
[17:28:30.149]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:30.149]                   ...future.rng), globalenv = if (FALSE) 
[17:28:30.149]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:30.149]                     ...future.globalenv.names))
[17:28:30.149]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:30.149]         }, condition = base::local({
[17:28:30.149]             c <- base::c
[17:28:30.149]             inherits <- base::inherits
[17:28:30.149]             invokeRestart <- base::invokeRestart
[17:28:30.149]             length <- base::length
[17:28:30.149]             list <- base::list
[17:28:30.149]             seq.int <- base::seq.int
[17:28:30.149]             signalCondition <- base::signalCondition
[17:28:30.149]             sys.calls <- base::sys.calls
[17:28:30.149]             `[[` <- base::`[[`
[17:28:30.149]             `+` <- base::`+`
[17:28:30.149]             `<<-` <- base::`<<-`
[17:28:30.149]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:30.149]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:30.149]                   3L)]
[17:28:30.149]             }
[17:28:30.149]             function(cond) {
[17:28:30.149]                 is_error <- inherits(cond, "error")
[17:28:30.149]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:30.149]                   NULL)
[17:28:30.149]                 if (is_error) {
[17:28:30.149]                   sessionInformation <- function() {
[17:28:30.149]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:30.149]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:30.149]                       search = base::search(), system = base::Sys.info())
[17:28:30.149]                   }
[17:28:30.149]                   ...future.conditions[[length(...future.conditions) + 
[17:28:30.149]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:30.149]                     cond$call), session = sessionInformation(), 
[17:28:30.149]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:30.149]                   signalCondition(cond)
[17:28:30.149]                 }
[17:28:30.149]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:30.149]                 "immediateCondition"))) {
[17:28:30.149]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:30.149]                   ...future.conditions[[length(...future.conditions) + 
[17:28:30.149]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:30.149]                   if (TRUE && !signal) {
[17:28:30.149]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:30.149]                     {
[17:28:30.149]                       inherits <- base::inherits
[17:28:30.149]                       invokeRestart <- base::invokeRestart
[17:28:30.149]                       is.null <- base::is.null
[17:28:30.149]                       muffled <- FALSE
[17:28:30.149]                       if (inherits(cond, "message")) {
[17:28:30.149]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:30.149]                         if (muffled) 
[17:28:30.149]                           invokeRestart("muffleMessage")
[17:28:30.149]                       }
[17:28:30.149]                       else if (inherits(cond, "warning")) {
[17:28:30.149]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:30.149]                         if (muffled) 
[17:28:30.149]                           invokeRestart("muffleWarning")
[17:28:30.149]                       }
[17:28:30.149]                       else if (inherits(cond, "condition")) {
[17:28:30.149]                         if (!is.null(pattern)) {
[17:28:30.149]                           computeRestarts <- base::computeRestarts
[17:28:30.149]                           grepl <- base::grepl
[17:28:30.149]                           restarts <- computeRestarts(cond)
[17:28:30.149]                           for (restart in restarts) {
[17:28:30.149]                             name <- restart$name
[17:28:30.149]                             if (is.null(name)) 
[17:28:30.149]                               next
[17:28:30.149]                             if (!grepl(pattern, name)) 
[17:28:30.149]                               next
[17:28:30.149]                             invokeRestart(restart)
[17:28:30.149]                             muffled <- TRUE
[17:28:30.149]                             break
[17:28:30.149]                           }
[17:28:30.149]                         }
[17:28:30.149]                       }
[17:28:30.149]                       invisible(muffled)
[17:28:30.149]                     }
[17:28:30.149]                     muffleCondition(cond, pattern = "^muffle")
[17:28:30.149]                   }
[17:28:30.149]                 }
[17:28:30.149]                 else {
[17:28:30.149]                   if (TRUE) {
[17:28:30.149]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:30.149]                     {
[17:28:30.149]                       inherits <- base::inherits
[17:28:30.149]                       invokeRestart <- base::invokeRestart
[17:28:30.149]                       is.null <- base::is.null
[17:28:30.149]                       muffled <- FALSE
[17:28:30.149]                       if (inherits(cond, "message")) {
[17:28:30.149]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:30.149]                         if (muffled) 
[17:28:30.149]                           invokeRestart("muffleMessage")
[17:28:30.149]                       }
[17:28:30.149]                       else if (inherits(cond, "warning")) {
[17:28:30.149]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:30.149]                         if (muffled) 
[17:28:30.149]                           invokeRestart("muffleWarning")
[17:28:30.149]                       }
[17:28:30.149]                       else if (inherits(cond, "condition")) {
[17:28:30.149]                         if (!is.null(pattern)) {
[17:28:30.149]                           computeRestarts <- base::computeRestarts
[17:28:30.149]                           grepl <- base::grepl
[17:28:30.149]                           restarts <- computeRestarts(cond)
[17:28:30.149]                           for (restart in restarts) {
[17:28:30.149]                             name <- restart$name
[17:28:30.149]                             if (is.null(name)) 
[17:28:30.149]                               next
[17:28:30.149]                             if (!grepl(pattern, name)) 
[17:28:30.149]                               next
[17:28:30.149]                             invokeRestart(restart)
[17:28:30.149]                             muffled <- TRUE
[17:28:30.149]                             break
[17:28:30.149]                           }
[17:28:30.149]                         }
[17:28:30.149]                       }
[17:28:30.149]                       invisible(muffled)
[17:28:30.149]                     }
[17:28:30.149]                     muffleCondition(cond, pattern = "^muffle")
[17:28:30.149]                   }
[17:28:30.149]                 }
[17:28:30.149]             }
[17:28:30.149]         }))
[17:28:30.149]     }, error = function(ex) {
[17:28:30.149]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:30.149]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:30.149]                 ...future.rng), started = ...future.startTime, 
[17:28:30.149]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:30.149]             version = "1.8"), class = "FutureResult")
[17:28:30.149]     }, finally = {
[17:28:30.149]         if (!identical(...future.workdir, getwd())) 
[17:28:30.149]             setwd(...future.workdir)
[17:28:30.149]         {
[17:28:30.149]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:30.149]                 ...future.oldOptions$nwarnings <- NULL
[17:28:30.149]             }
[17:28:30.149]             base::options(...future.oldOptions)
[17:28:30.149]             if (.Platform$OS.type == "windows") {
[17:28:30.149]                 old_names <- names(...future.oldEnvVars)
[17:28:30.149]                 envs <- base::Sys.getenv()
[17:28:30.149]                 names <- names(envs)
[17:28:30.149]                 common <- intersect(names, old_names)
[17:28:30.149]                 added <- setdiff(names, old_names)
[17:28:30.149]                 removed <- setdiff(old_names, names)
[17:28:30.149]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:30.149]                   envs[common]]
[17:28:30.149]                 NAMES <- toupper(changed)
[17:28:30.149]                 args <- list()
[17:28:30.149]                 for (kk in seq_along(NAMES)) {
[17:28:30.149]                   name <- changed[[kk]]
[17:28:30.149]                   NAME <- NAMES[[kk]]
[17:28:30.149]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:30.149]                     next
[17:28:30.149]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:30.149]                 }
[17:28:30.149]                 NAMES <- toupper(added)
[17:28:30.149]                 for (kk in seq_along(NAMES)) {
[17:28:30.149]                   name <- added[[kk]]
[17:28:30.149]                   NAME <- NAMES[[kk]]
[17:28:30.149]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:30.149]                     next
[17:28:30.149]                   args[[name]] <- ""
[17:28:30.149]                 }
[17:28:30.149]                 NAMES <- toupper(removed)
[17:28:30.149]                 for (kk in seq_along(NAMES)) {
[17:28:30.149]                   name <- removed[[kk]]
[17:28:30.149]                   NAME <- NAMES[[kk]]
[17:28:30.149]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:30.149]                     next
[17:28:30.149]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:30.149]                 }
[17:28:30.149]                 if (length(args) > 0) 
[17:28:30.149]                   base::do.call(base::Sys.setenv, args = args)
[17:28:30.149]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:30.149]             }
[17:28:30.149]             else {
[17:28:30.149]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:30.149]             }
[17:28:30.149]             {
[17:28:30.149]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:30.149]                   0L) {
[17:28:30.149]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:30.149]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:30.149]                   base::options(opts)
[17:28:30.149]                 }
[17:28:30.149]                 {
[17:28:30.149]                   {
[17:28:30.149]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:30.149]                     NULL
[17:28:30.149]                   }
[17:28:30.149]                   options(future.plan = NULL)
[17:28:30.149]                   if (is.na(NA_character_)) 
[17:28:30.149]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:30.149]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:30.149]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:30.149]                     .init = FALSE)
[17:28:30.149]                 }
[17:28:30.149]             }
[17:28:30.149]         }
[17:28:30.149]     })
[17:28:30.149]     if (TRUE) {
[17:28:30.149]         base::sink(type = "output", split = FALSE)
[17:28:30.149]         if (TRUE) {
[17:28:30.149]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:30.149]         }
[17:28:30.149]         else {
[17:28:30.149]             ...future.result["stdout"] <- base::list(NULL)
[17:28:30.149]         }
[17:28:30.149]         base::close(...future.stdout)
[17:28:30.149]         ...future.stdout <- NULL
[17:28:30.149]     }
[17:28:30.149]     ...future.result$conditions <- ...future.conditions
[17:28:30.149]     ...future.result$finished <- base::Sys.time()
[17:28:30.149]     ...future.result
[17:28:30.149] }
[17:28:30.156] MultisessionFuture started
[17:28:30.156] - Launch lazy future ... done
[17:28:30.156] run() for 'MultisessionFuture' ... done
> 
> ## Collect value, to speep up the stopping of the parallel workers,
> ## and to make sure we're not leaving any stray processes behind.
> v <- value(f)
[17:28:30.156] result() for ClusterFuture ...
[17:28:30.157] receiveMessageFromWorker() for ClusterFuture ...
[17:28:30.157] - Validating connection of MultisessionFuture
[17:28:30.180] - received message: FutureResult
[17:28:30.180] - Received FutureResult
[17:28:30.181] - Erased future from FutureRegistry
[17:28:30.181] result() for ClusterFuture ...
[17:28:30.181] - result already collected: FutureResult
[17:28:30.181] result() for ClusterFuture ... done
[17:28:30.182] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:30.182] result() for ClusterFuture ... done
[17:28:30.182] result() for ClusterFuture ...
[17:28:30.182] - result already collected: FutureResult
[17:28:30.183] result() for ClusterFuture ... done
> 
> cl <- ClusterRegistry("get")
> stopifnot(inherits(cl, "cluster"), length(cl) >= 1L)
> 
> plan(sequential)
[17:28:30.183] plan(): Setting new future strategy stack:
[17:28:30.184] List of future strategies:
[17:28:30.184] 1. sequential:
[17:28:30.184]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:30.184]    - tweaked: FALSE
[17:28:30.184]    - call: plan(sequential)
[17:28:30.193] plan(): nbrOfWorkers() = 1
> cl <- ClusterRegistry("get")
> stopifnot(is.null(cl), length(cl) == 0L)
>   
> message("*** multisession(...) - stopping with plan() change ... DONE")
*** multisession(...) - stopping with plan() change ... DONE
> 
> message("*** multisession() ... DONE")
*** multisession() ... DONE
> 
> source("incl/end.R")
[17:28:30.195] plan(): Setting new future strategy stack:
[17:28:30.195] List of future strategies:
[17:28:30.195] 1. FutureStrategy:
[17:28:30.195]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:30.195]    - tweaked: FALSE
[17:28:30.195]    - call: future::plan(oplan)
[17:28:30.196] plan(): nbrOfWorkers() = 1
Failed to undo environment variables:
 - Expected environment variables: [n=205] '!ExitCode', 'ALLUSERSPROFILE', 'APPDATA', 'BIBINPUTS', 'BINDIR', 'BSTINPUTS', 'COMMONPROGRAMFILES', 'COMPUTERNAME', 'COMSPEC', 'CURL_CA_BUNDLE', 'CYGWIN', 'CommonProgramFiles(x86)', 'CommonProgramW6432', 'DriverData', 'HOME', 'HOMEDRIVE', 'HOMEPATH', 'JAGS_ROOT', 'JAVA_HOME', 'LANGUAGE', 'LC_COLLATE', 'LC_MONETARY', 'LC_TIME', 'LOCALAPPDATA', 'LOGONSERVER', 'LS_HOME', 'LS_LICENSE_PATH', 'MAKE', 'MAKEFLAGS', 'MAKELEVEL', 'MFLAGS', 'MSMPI_BENCHMARKS', 'MSMPI_BIN', 'MSYS2_ENV_CONV_EXCL', 'NUMBER_OF_PROCESSORS', 'OCL', 'OMP_THREAD_LIMIT', 'OS', 'PATH', 'PATHEXT', 'PROCESSOR_ARCHITECTURE', 'PROCESSOR_IDENTIFIER', 'PROCESSOR_LEVEL', 'PROCESSOR_REVISION', 'PROGRAMFILES', 'PROMPT', 'PSModulePath', 'PUBLIC', 'PWD', 'ProgramData', 'ProgramFiles(x86)', 'ProgramW6432', 'RTOOLS43_HOME', 'RTOOLS44_HOME', 'R_ARCH', 'R_BROWSER', 'R_BZIPCMD', 'R_CMD', 'R_COMPILED_BY', 'R_CRAN_WEB', 'R_CUSTOM_TOOLS_PATH', 'R_CUSTOM_TOOLS_SOFT', 'R_DOC_DIR', 'R_ENVIRON_USER', 'R_GSCMD', 'R_GZIPCMD', 'R_HOME', 'R_INCLUDE_DIR', 'R_INSTALL_TAR', 'R_LIBS', 'R_LIBS_SITE', 'R_LIBS_USER', 'R_MAX_NUM_DLLS', 'R_OSTYPE', 'R_PAPERSIZE', 'R_PAPERSIZE_USER', 'R_PARALLELLY_MAKENODEPSOCK_AUTOKILL', 'R_PARALLELLY_MAKENODEPSOCK_CONNECTTIMEOUT', 'R_PARALLELLY_MAKENODEPSOCK_RSCRIPT_LABEL', 'R_PARALLELLY_MAKENODEPSOCK_SESSIONINFO_PKGS', 'R_PARALLELLY_MAKENODEPSOCK_TIMEOUT', 'R_PARALLELLY_RANDOM_PORTS', 'R_PARALLEL_PORT', 'R_RD4PDF', 'R_RTOOLS44_PATH', 'R_SCRIPT_LEGACY', 'R_SHARE_DIR', 'R_TESTS', 'R_UNZIPCMD', 'R_USER', 'R_VERSION', 'R_ZIPCMD', 'SED', 'SHLVL', 'SYSTEMDRIVE', 'SYSTEMROOT', 'TAR', 'TAR_OPTIONS', 'TEMP', 'TERM', 'TEXINPUTS', 'TMP', 'TMPDIR', 'USERDOMAIN', 'USERDOMAIN_ROAMINGPROFILE', 'USERNAME', 'USERPROFILE', 'WINDIR', '_', '_R_CHECK_AUTOCONF_', '_R_CHECK_BOGUS_RETURN_', '_R_CHECK_BROWSER_NONINTERACTIVE_', '_R_CHECK_BUILD_VIGNETTES_SEPARATELY_', '_R_CHECK_CODETOOLS_PROFILE_', '_R_CHECK_CODE_ASSIGN_TO_GLOBALENV_', '_R_CHECK_CODE_ATTACH_', '_R_CHECK_CODE_CLASS_IS_STRING_', '_R_CHECK_CODE_DATA_INTO_GLOBALENV_', '_R_CHECK_CODE_USAGE_VIA_NAMESPACES_', '_R_CHECK_CODE_USAGE_WITHOUT_LOADING_', '_R_CHECK_CODE_USAGE_WITH_ONLY_BASE_ATTACHED_', '_R_CHECK_CODOC_VARIABLES_IN_USAGES_', '_R_CHECK_COMPACT_DATA2_', '_R_CHECK_COMPILATION_FLAGS_', '_R_CHECK_CONNECTIONS_LEFT_OPEN_', '_R_CHECK_CRAN_INCOMING_', '_R_CHECK_CRAN_INCOMING_CHECK_FILE_URIS_', '_R_CHECK_CRAN_INCOMING_CHECK_URLS_IN_PARALLEL_', '_R_CHECK_CRAN_INCOMING_NOTE_GNU_MAKE_', '_R_CHECK_CRAN_INCOMING_REMOTE_', '_R_CHECK_CRAN_INCOMING_USE_ASPELL_', '_R_CHECK_DATALIST_', '_R_CHECK_DEPRECATED_DEFUNCT_', '_R_CHECK_DOC_SIZES2_', '_R_CHECK_DOT_FIRSTLIB_', '_R_CHECK_DOT_INTERNAL_', '_R_CHECK_EXAMPLE_TIMING_THRESHOLD_', '_R_CHECK_EXECUTABLES_', '_R_CHECK_EXECUTABLES_EXCLUSIONS_', '_R_CHECK_FF_CALLS_', '_R_CHECK_FF_DUP_', '_R_CHECK_FORCE_SUGGESTS_', '_R_CHECK_FUTURE_FILE_TIMESTAMPS_', '_R_CHECK_FUTURE_FILE_TIMESTAMPS_LEEWAY_', '_R_CHECK_HAVE_MYSQL_', '_R_CHECK_HAVE_ODBC_', '_R_CHECK_HAVE_PERL_', '_R_CHECK_HAVE_POSTGRES_', '_R_CHECK_INSTALL_DEPENDS_', '_R_CHECK_INTERNALS2_', '_R_CHECK_LENGTH_1_CONDITION_', '_R_CHECK_LICENSE_', '_R_CHECK_LIMIT_CORES_', '_R_CHECK_MATRIX_DATA_', '_R_CHECK_MBCS_CONVERSION_FAILURE_', '_R_CHECK_NATIVE_ROUTINE_REGISTRATION_', '_R_CHECK_NEWS_IN_PLAIN_TEXT_', '_R_CHECK_NO_RECOMMENDED_', '_R_CHECK_NO_STOP_ON_TEST_ERROR_', '_R_CHECK_ORPHANED_', '_R_CHECK_OVERWRITE_REGISTERED_S3_METHODS_', '_R_CHECK_PACKAGES_USED_IGNORE_UNUSED_IMPORTS_', '_R_CHECK_PACKAGES_USED_IN_TESTS_USE_SUBDIRS_', '_R_CHECK_PACKAGE_DATASETS_SUPPRESS_NOTES_', '_R_CHECK_PACKAGE_NAME_', '_R_CHECK_PKG_SIZES_', '_R_CHECK_PKG_SIZES_THRESHOLD_', '_R_CHECK_PRAGMAS_', '_R_CHECK_RD_EXAMPLES_T_AND_F_', '_R_CHECK_RD_LINE_WIDTHS_', '_R_CHECK_RD_MATH_RENDERING_', '_R_CHECK_RD_NOTE_LOST_BRACES_', '_R_CHECK_RD_VALIDATE_RD2HTML_', '_R_CHECK_REPLACING_IMPORTS_', '_R_CHECK_R_DEPENDS_', '_R_CHECK_S3_METHODS_SHOW_POSSIBLE_ISSUES_', '_R_CHECK_SCREEN_DEVICE_', '_R_CHECK_SERIALIZATION_', '_R_CHECK_SHLIB_OPENMP_FLAGS_', '_R_CHECK_SRC_MINUS_W_IMPLICIT_', '_R_CHECK_SUBDIRS_NOCASE_', '_R_CHECK_SUGGESTS_ONLY_', '_R_CHECK_SYSTEM_CLOCK_', '_R_CHECK_TESTS_NLINES_', '_R_CHECK_TEST_TIMING_', '_R_CHECK_TIMINGS_', '_R_CHECK_TOPLEVEL_FILES_', '_R_CHECK_UNDOC_USE_ALL_NAMES_', '_R_CHECK_UNSAFE_CALLS_', '_R_CHECK_URLS_SHOW_301_STATUS_', '_R_CHECK_VC_DIRS_', '_R_CHECK_VIGNETTES_NLINES_', '_R_CHECK_VIGNETTES_SKIP_RUN_MAYBE_', '_R_CHECK_VIGNETTE_TIMING_', '_R_CHECK_VIGNETTE_TITLES_', '_R_CHECK_WINDOWS_DEVICE_', '_R_CHECK_XREFS_NOTE_MISSING_PACKAGE_ANCHORS_', '_R_CHECK_XREFS_USE_ALIASES_FROM_CRAN_', '_R_CLASS_MATRIX_ARRAY_', '_R_DEPRECATED_IS_R_', '_R_S3_METHOD_LOOKUP_BASEENV_AFTER_GLOBALENV_', '_R_SHLIB_BUILD_OBJECTS_SYMBOL_TABLES_', '__R_CHECK_DOC_FILES_NOTE_IF_ALL_SPECIAL__', 'maj.version', 'nextArg--timingsnextArg--install'
 - Environment variables still there: [n=0] 
 - Environment variables missing: [n=1] 'MAKEFLAGS'
Differences environment variable by environment variable:
List of 3
 $ name    : chr "MAKEFLAGS"
 $ expected: 'Dlist' chr ""
 $ actual  : 'Dlist' chr NA
> 
> proc.time()
   user  system elapsed 
   1.81    0.46    4.93