R Under development (unstable) (2023-12-20 r85713 ucrt) -- "Unsuffered Consequences"
Copyright (C) 2023 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")
[01:28:22.193] plan(): Setting new future strategy stack:
[01:28:22.194] List of future strategies:
[01:28:22.194] 1. sequential:
[01:28:22.194]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:22.194]    - tweaked: FALSE
[01:28:22.194]    - call: future::plan("sequential")
[01:28:22.221] 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"))    
+ 
+   message(sprintf("Testing with %d cores ... DONE", cores))
+ } ## for (cores ...)
Testing with 1 cores ...
[01:28:22.288] getGlobalsAndPackages() ...
[01:28:22.288] Searching for globals...
[01:28:22.292] - globals found: [1] '{'
[01:28:22.293] Searching for globals ... DONE
[01:28:22.293] Resolving globals: FALSE
[01:28:22.294] 
[01:28:22.294] 
[01:28:22.294] 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: cfeec5f2-987d-97c4-cbb0-b2e17579921c
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:22.296] Packages needed by the future expression (n = 0): <none>
[01:28:22.296] Packages needed by future strategies (n = 0): <none>
[01:28:22.298] {
[01:28:22.298]     {
[01:28:22.298]         {
[01:28:22.298]             ...future.startTime <- base::Sys.time()
[01:28:22.298]             {
[01:28:22.298]                 {
[01:28:22.298]                   {
[01:28:22.298]                     base::local({
[01:28:22.298]                       has_future <- base::requireNamespace("future", 
[01:28:22.298]                         quietly = TRUE)
[01:28:22.298]                       if (has_future) {
[01:28:22.298]                         ns <- base::getNamespace("future")
[01:28:22.298]                         version <- ns[[".package"]][["version"]]
[01:28:22.298]                         if (is.null(version)) 
[01:28:22.298]                           version <- utils::packageVersion("future")
[01:28:22.298]                       }
[01:28:22.298]                       else {
[01:28:22.298]                         version <- NULL
[01:28:22.298]                       }
[01:28:22.298]                       if (!has_future || version < "1.8.0") {
[01:28:22.298]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:22.298]                           "", base::R.version$version.string), 
[01:28:22.298]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:22.298]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:22.298]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:22.298]                             "release", "version")], collapse = " "), 
[01:28:22.298]                           hostname = base::Sys.info()[["nodename"]])
[01:28:22.298]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:22.298]                           info)
[01:28:22.298]                         info <- base::paste(info, collapse = "; ")
[01:28:22.298]                         if (!has_future) {
[01:28:22.298]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:22.298]                             info)
[01:28:22.298]                         }
[01:28:22.298]                         else {
[01:28:22.298]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:22.298]                             info, version)
[01:28:22.298]                         }
[01:28:22.298]                         base::stop(msg)
[01:28:22.298]                       }
[01:28:22.298]                     })
[01:28:22.298]                   }
[01:28:22.298]                   options(future.plan = NULL)
[01:28:22.298]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:22.298]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:22.298]                 }
[01:28:22.298]                 ...future.workdir <- getwd()
[01:28:22.298]             }
[01:28:22.298]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:22.298]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:22.298]         }
[01:28:22.298]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:22.298]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:22.298]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:22.298]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:22.298]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:22.298]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:22.298]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:22.298]             base::names(...future.oldOptions))
[01:28:22.298]     }
[01:28:22.298]     if (FALSE) {
[01:28:22.298]     }
[01:28:22.298]     else {
[01:28:22.298]         if (TRUE) {
[01:28:22.298]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:22.298]                 open = "w")
[01:28:22.298]         }
[01:28:22.298]         else {
[01:28:22.298]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:22.298]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:22.298]         }
[01:28:22.298]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:22.298]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:22.298]             base::sink(type = "output", split = FALSE)
[01:28:22.298]             base::close(...future.stdout)
[01:28:22.298]         }, add = TRUE)
[01:28:22.298]     }
[01:28:22.298]     ...future.frame <- base::sys.nframe()
[01:28:22.298]     ...future.conditions <- base::list()
[01:28:22.298]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:22.298]     if (FALSE) {
[01:28:22.298]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:22.298]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:22.298]     }
[01:28:22.298]     ...future.result <- base::tryCatch({
[01:28:22.298]         base::withCallingHandlers({
[01:28:22.298]             ...future.value <- base::withVisible(base::local({
[01:28:22.298]                 42L
[01:28:22.298]             }))
[01:28:22.298]             future::FutureResult(value = ...future.value$value, 
[01:28:22.298]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:22.298]                   ...future.rng), globalenv = if (FALSE) 
[01:28:22.298]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:22.298]                     ...future.globalenv.names))
[01:28:22.298]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:22.298]         }, condition = base::local({
[01:28:22.298]             c <- base::c
[01:28:22.298]             inherits <- base::inherits
[01:28:22.298]             invokeRestart <- base::invokeRestart
[01:28:22.298]             length <- base::length
[01:28:22.298]             list <- base::list
[01:28:22.298]             seq.int <- base::seq.int
[01:28:22.298]             signalCondition <- base::signalCondition
[01:28:22.298]             sys.calls <- base::sys.calls
[01:28:22.298]             `[[` <- base::`[[`
[01:28:22.298]             `+` <- base::`+`
[01:28:22.298]             `<<-` <- base::`<<-`
[01:28:22.298]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:22.298]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:22.298]                   3L)]
[01:28:22.298]             }
[01:28:22.298]             function(cond) {
[01:28:22.298]                 is_error <- inherits(cond, "error")
[01:28:22.298]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:22.298]                   NULL)
[01:28:22.298]                 if (is_error) {
[01:28:22.298]                   sessionInformation <- function() {
[01:28:22.298]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:22.298]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:22.298]                       search = base::search(), system = base::Sys.info())
[01:28:22.298]                   }
[01:28:22.298]                   ...future.conditions[[length(...future.conditions) + 
[01:28:22.298]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:22.298]                     cond$call), session = sessionInformation(), 
[01:28:22.298]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:22.298]                   signalCondition(cond)
[01:28:22.298]                 }
[01:28:22.298]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:22.298]                 "immediateCondition"))) {
[01:28:22.298]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:22.298]                   ...future.conditions[[length(...future.conditions) + 
[01:28:22.298]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:22.298]                   if (TRUE && !signal) {
[01:28:22.298]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:22.298]                     {
[01:28:22.298]                       inherits <- base::inherits
[01:28:22.298]                       invokeRestart <- base::invokeRestart
[01:28:22.298]                       is.null <- base::is.null
[01:28:22.298]                       muffled <- FALSE
[01:28:22.298]                       if (inherits(cond, "message")) {
[01:28:22.298]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:22.298]                         if (muffled) 
[01:28:22.298]                           invokeRestart("muffleMessage")
[01:28:22.298]                       }
[01:28:22.298]                       else if (inherits(cond, "warning")) {
[01:28:22.298]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:22.298]                         if (muffled) 
[01:28:22.298]                           invokeRestart("muffleWarning")
[01:28:22.298]                       }
[01:28:22.298]                       else if (inherits(cond, "condition")) {
[01:28:22.298]                         if (!is.null(pattern)) {
[01:28:22.298]                           computeRestarts <- base::computeRestarts
[01:28:22.298]                           grepl <- base::grepl
[01:28:22.298]                           restarts <- computeRestarts(cond)
[01:28:22.298]                           for (restart in restarts) {
[01:28:22.298]                             name <- restart$name
[01:28:22.298]                             if (is.null(name)) 
[01:28:22.298]                               next
[01:28:22.298]                             if (!grepl(pattern, name)) 
[01:28:22.298]                               next
[01:28:22.298]                             invokeRestart(restart)
[01:28:22.298]                             muffled <- TRUE
[01:28:22.298]                             break
[01:28:22.298]                           }
[01:28:22.298]                         }
[01:28:22.298]                       }
[01:28:22.298]                       invisible(muffled)
[01:28:22.298]                     }
[01:28:22.298]                     muffleCondition(cond, pattern = "^muffle")
[01:28:22.298]                   }
[01:28:22.298]                 }
[01:28:22.298]                 else {
[01:28:22.298]                   if (TRUE) {
[01:28:22.298]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:22.298]                     {
[01:28:22.298]                       inherits <- base::inherits
[01:28:22.298]                       invokeRestart <- base::invokeRestart
[01:28:22.298]                       is.null <- base::is.null
[01:28:22.298]                       muffled <- FALSE
[01:28:22.298]                       if (inherits(cond, "message")) {
[01:28:22.298]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:22.298]                         if (muffled) 
[01:28:22.298]                           invokeRestart("muffleMessage")
[01:28:22.298]                       }
[01:28:22.298]                       else if (inherits(cond, "warning")) {
[01:28:22.298]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:22.298]                         if (muffled) 
[01:28:22.298]                           invokeRestart("muffleWarning")
[01:28:22.298]                       }
[01:28:22.298]                       else if (inherits(cond, "condition")) {
[01:28:22.298]                         if (!is.null(pattern)) {
[01:28:22.298]                           computeRestarts <- base::computeRestarts
[01:28:22.298]                           grepl <- base::grepl
[01:28:22.298]                           restarts <- computeRestarts(cond)
[01:28:22.298]                           for (restart in restarts) {
[01:28:22.298]                             name <- restart$name
[01:28:22.298]                             if (is.null(name)) 
[01:28:22.298]                               next
[01:28:22.298]                             if (!grepl(pattern, name)) 
[01:28:22.298]                               next
[01:28:22.298]                             invokeRestart(restart)
[01:28:22.298]                             muffled <- TRUE
[01:28:22.298]                             break
[01:28:22.298]                           }
[01:28:22.298]                         }
[01:28:22.298]                       }
[01:28:22.298]                       invisible(muffled)
[01:28:22.298]                     }
[01:28:22.298]                     muffleCondition(cond, pattern = "^muffle")
[01:28:22.298]                   }
[01:28:22.298]                 }
[01:28:22.298]             }
[01:28:22.298]         }))
[01:28:22.298]     }, error = function(ex) {
[01:28:22.298]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:22.298]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:22.298]                 ...future.rng), started = ...future.startTime, 
[01:28:22.298]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:22.298]             version = "1.8"), class = "FutureResult")
[01:28:22.298]     }, finally = {
[01:28:22.298]         if (!identical(...future.workdir, getwd())) 
[01:28:22.298]             setwd(...future.workdir)
[01:28:22.298]         {
[01:28:22.298]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:22.298]                 ...future.oldOptions$nwarnings <- NULL
[01:28:22.298]             }
[01:28:22.298]             base::options(...future.oldOptions)
[01:28:22.298]             if (.Platform$OS.type == "windows") {
[01:28:22.298]                 old_names <- names(...future.oldEnvVars)
[01:28:22.298]                 envs <- base::Sys.getenv()
[01:28:22.298]                 names <- names(envs)
[01:28:22.298]                 common <- intersect(names, old_names)
[01:28:22.298]                 added <- setdiff(names, old_names)
[01:28:22.298]                 removed <- setdiff(old_names, names)
[01:28:22.298]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:22.298]                   envs[common]]
[01:28:22.298]                 NAMES <- toupper(changed)
[01:28:22.298]                 args <- list()
[01:28:22.298]                 for (kk in seq_along(NAMES)) {
[01:28:22.298]                   name <- changed[[kk]]
[01:28:22.298]                   NAME <- NAMES[[kk]]
[01:28:22.298]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:22.298]                     next
[01:28:22.298]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:22.298]                 }
[01:28:22.298]                 NAMES <- toupper(added)
[01:28:22.298]                 for (kk in seq_along(NAMES)) {
[01:28:22.298]                   name <- added[[kk]]
[01:28:22.298]                   NAME <- NAMES[[kk]]
[01:28:22.298]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:22.298]                     next
[01:28:22.298]                   args[[name]] <- ""
[01:28:22.298]                 }
[01:28:22.298]                 NAMES <- toupper(removed)
[01:28:22.298]                 for (kk in seq_along(NAMES)) {
[01:28:22.298]                   name <- removed[[kk]]
[01:28:22.298]                   NAME <- NAMES[[kk]]
[01:28:22.298]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:22.298]                     next
[01:28:22.298]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:22.298]                 }
[01:28:22.298]                 if (length(args) > 0) 
[01:28:22.298]                   base::do.call(base::Sys.setenv, args = args)
[01:28:22.298]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:22.298]             }
[01:28:22.298]             else {
[01:28:22.298]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:22.298]             }
[01:28:22.298]             {
[01:28:22.298]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:22.298]                   0L) {
[01:28:22.298]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:22.298]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:22.298]                   base::options(opts)
[01:28:22.298]                 }
[01:28:22.298]                 {
[01:28:22.298]                   {
[01:28:22.298]                     NULL
[01:28:22.298]                     RNGkind("Mersenne-Twister")
[01:28:22.298]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:22.298]                       inherits = FALSE)
[01:28:22.298]                   }
[01:28:22.298]                   options(future.plan = NULL)
[01:28:22.298]                   if (is.na(NA_character_)) 
[01:28:22.298]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:22.298]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:22.298]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:22.298]                   {
[01:28:22.298]                     future <- SequentialFuture(..., envir = envir)
[01:28:22.298]                     if (!future$lazy) 
[01:28:22.298]                       future <- run(future)
[01:28:22.298]                     invisible(future)
[01:28:22.298]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:22.298]                 }
[01:28:22.298]             }
[01:28:22.298]         }
[01:28:22.298]     })
[01:28:22.298]     if (TRUE) {
[01:28:22.298]         base::sink(type = "output", split = FALSE)
[01:28:22.298]         if (TRUE) {
[01:28:22.298]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:22.298]         }
[01:28:22.298]         else {
[01:28:22.298]             ...future.result["stdout"] <- base::list(NULL)
[01:28:22.298]         }
[01:28:22.298]         base::close(...future.stdout)
[01:28:22.298]         ...future.stdout <- NULL
[01:28:22.298]     }
[01:28:22.298]     ...future.result$conditions <- ...future.conditions
[01:28:22.298]     ...future.result$finished <- base::Sys.time()
[01:28:22.298]     ...future.result
[01:28:22.298] }
[01:28:22.302] plan(): Setting new future strategy stack:
[01:28:22.302] List of future strategies:
[01:28:22.302] 1. sequential:
[01:28:22.302]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:22.302]    - tweaked: FALSE
[01:28:22.302]    - call: NULL
[01:28:22.303] plan(): nbrOfWorkers() = 1
[01:28:22.305] plan(): Setting new future strategy stack:
[01:28:22.305] List of future strategies:
[01:28:22.305] 1. sequential:
[01:28:22.305]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:22.305]    - tweaked: FALSE
[01:28:22.305]    - call: future::plan("sequential")
[01:28:22.306] plan(): nbrOfWorkers() = 1
[01:28:22.306] SequentialFuture started (and completed)
[01:28:22.307] resolved() for 'SequentialFuture' ...
[01:28:22.307] - state: 'finished'
[01:28:22.307] - run: TRUE
[01:28:22.307] - result: 'FutureResult'
[01:28:22.307] resolved() for 'SequentialFuture' ... done
[1] TRUE
[1] 42
[01:28:22.310] getGlobalsAndPackages() ...
[01:28:22.311] Searching for globals...
[01:28:22.317] - globals found: [4] '{', '<-', '*', 'a'
[01:28:22.317] Searching for globals ... DONE
[01:28:22.317] Resolving globals: FALSE
[01:28:22.319] The total size of the 1 globals is 56 bytes (56 bytes)
[01:28:22.319] The total size of the 1 globals exported for future expression ('{; b <- 3; c <- 2; a * b * c; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'a' (56 bytes of class 'numeric')
[01:28:22.319] - globals: [1] 'a'
[01:28:22.320] 
[01:28:22.320] 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 56 bytes (numeric 'a' of 56 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: FALSE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: cfeec5f2-987d-97c4-cbb0-b2e17579921c
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:22.321] Packages needed by the future expression (n = 0): <none>
[01:28:22.321] Packages needed by future strategies (n = 0): <none>
[01:28:22.322] {
[01:28:22.322]     {
[01:28:22.322]         {
[01:28:22.322]             ...future.startTime <- base::Sys.time()
[01:28:22.322]             {
[01:28:22.322]                 {
[01:28:22.322]                   {
[01:28:22.322]                     base::local({
[01:28:22.322]                       has_future <- base::requireNamespace("future", 
[01:28:22.322]                         quietly = TRUE)
[01:28:22.322]                       if (has_future) {
[01:28:22.322]                         ns <- base::getNamespace("future")
[01:28:22.322]                         version <- ns[[".package"]][["version"]]
[01:28:22.322]                         if (is.null(version)) 
[01:28:22.322]                           version <- utils::packageVersion("future")
[01:28:22.322]                       }
[01:28:22.322]                       else {
[01:28:22.322]                         version <- NULL
[01:28:22.322]                       }
[01:28:22.322]                       if (!has_future || version < "1.8.0") {
[01:28:22.322]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:22.322]                           "", base::R.version$version.string), 
[01:28:22.322]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:22.322]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:22.322]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:22.322]                             "release", "version")], collapse = " "), 
[01:28:22.322]                           hostname = base::Sys.info()[["nodename"]])
[01:28:22.322]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:22.322]                           info)
[01:28:22.322]                         info <- base::paste(info, collapse = "; ")
[01:28:22.322]                         if (!has_future) {
[01:28:22.322]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:22.322]                             info)
[01:28:22.322]                         }
[01:28:22.322]                         else {
[01:28:22.322]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:22.322]                             info, version)
[01:28:22.322]                         }
[01:28:22.322]                         base::stop(msg)
[01:28:22.322]                       }
[01:28:22.322]                     })
[01:28:22.322]                   }
[01:28:22.322]                   options(future.plan = NULL)
[01:28:22.322]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:22.322]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:22.322]                 }
[01:28:22.322]                 ...future.workdir <- getwd()
[01:28:22.322]             }
[01:28:22.322]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:22.322]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:22.322]         }
[01:28:22.322]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:22.322]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:22.322]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:22.322]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:22.322]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:22.322]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:22.322]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:22.322]             base::names(...future.oldOptions))
[01:28:22.322]     }
[01:28:22.322]     if (FALSE) {
[01:28:22.322]     }
[01:28:22.322]     else {
[01:28:22.322]         if (TRUE) {
[01:28:22.322]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:22.322]                 open = "w")
[01:28:22.322]         }
[01:28:22.322]         else {
[01:28:22.322]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:22.322]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:22.322]         }
[01:28:22.322]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:22.322]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:22.322]             base::sink(type = "output", split = FALSE)
[01:28:22.322]             base::close(...future.stdout)
[01:28:22.322]         }, add = TRUE)
[01:28:22.322]     }
[01:28:22.322]     ...future.frame <- base::sys.nframe()
[01:28:22.322]     ...future.conditions <- base::list()
[01:28:22.322]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:22.322]     if (FALSE) {
[01:28:22.322]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:22.322]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:22.322]     }
[01:28:22.322]     ...future.result <- base::tryCatch({
[01:28:22.322]         base::withCallingHandlers({
[01:28:22.322]             ...future.value <- base::withVisible(base::local({
[01:28:22.322]                 b <- 3
[01:28:22.322]                 c <- 2
[01:28:22.322]                 a * b * c
[01:28:22.322]             }))
[01:28:22.322]             future::FutureResult(value = ...future.value$value, 
[01:28:22.322]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:22.322]                   ...future.rng), globalenv = if (FALSE) 
[01:28:22.322]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:22.322]                     ...future.globalenv.names))
[01:28:22.322]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:22.322]         }, condition = base::local({
[01:28:22.322]             c <- base::c
[01:28:22.322]             inherits <- base::inherits
[01:28:22.322]             invokeRestart <- base::invokeRestart
[01:28:22.322]             length <- base::length
[01:28:22.322]             list <- base::list
[01:28:22.322]             seq.int <- base::seq.int
[01:28:22.322]             signalCondition <- base::signalCondition
[01:28:22.322]             sys.calls <- base::sys.calls
[01:28:22.322]             `[[` <- base::`[[`
[01:28:22.322]             `+` <- base::`+`
[01:28:22.322]             `<<-` <- base::`<<-`
[01:28:22.322]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:22.322]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:22.322]                   3L)]
[01:28:22.322]             }
[01:28:22.322]             function(cond) {
[01:28:22.322]                 is_error <- inherits(cond, "error")
[01:28:22.322]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:22.322]                   NULL)
[01:28:22.322]                 if (is_error) {
[01:28:22.322]                   sessionInformation <- function() {
[01:28:22.322]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:22.322]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:22.322]                       search = base::search(), system = base::Sys.info())
[01:28:22.322]                   }
[01:28:22.322]                   ...future.conditions[[length(...future.conditions) + 
[01:28:22.322]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:22.322]                     cond$call), session = sessionInformation(), 
[01:28:22.322]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:22.322]                   signalCondition(cond)
[01:28:22.322]                 }
[01:28:22.322]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:22.322]                 "immediateCondition"))) {
[01:28:22.322]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:22.322]                   ...future.conditions[[length(...future.conditions) + 
[01:28:22.322]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:22.322]                   if (TRUE && !signal) {
[01:28:22.322]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:22.322]                     {
[01:28:22.322]                       inherits <- base::inherits
[01:28:22.322]                       invokeRestart <- base::invokeRestart
[01:28:22.322]                       is.null <- base::is.null
[01:28:22.322]                       muffled <- FALSE
[01:28:22.322]                       if (inherits(cond, "message")) {
[01:28:22.322]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:22.322]                         if (muffled) 
[01:28:22.322]                           invokeRestart("muffleMessage")
[01:28:22.322]                       }
[01:28:22.322]                       else if (inherits(cond, "warning")) {
[01:28:22.322]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:22.322]                         if (muffled) 
[01:28:22.322]                           invokeRestart("muffleWarning")
[01:28:22.322]                       }
[01:28:22.322]                       else if (inherits(cond, "condition")) {
[01:28:22.322]                         if (!is.null(pattern)) {
[01:28:22.322]                           computeRestarts <- base::computeRestarts
[01:28:22.322]                           grepl <- base::grepl
[01:28:22.322]                           restarts <- computeRestarts(cond)
[01:28:22.322]                           for (restart in restarts) {
[01:28:22.322]                             name <- restart$name
[01:28:22.322]                             if (is.null(name)) 
[01:28:22.322]                               next
[01:28:22.322]                             if (!grepl(pattern, name)) 
[01:28:22.322]                               next
[01:28:22.322]                             invokeRestart(restart)
[01:28:22.322]                             muffled <- TRUE
[01:28:22.322]                             break
[01:28:22.322]                           }
[01:28:22.322]                         }
[01:28:22.322]                       }
[01:28:22.322]                       invisible(muffled)
[01:28:22.322]                     }
[01:28:22.322]                     muffleCondition(cond, pattern = "^muffle")
[01:28:22.322]                   }
[01:28:22.322]                 }
[01:28:22.322]                 else {
[01:28:22.322]                   if (TRUE) {
[01:28:22.322]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:22.322]                     {
[01:28:22.322]                       inherits <- base::inherits
[01:28:22.322]                       invokeRestart <- base::invokeRestart
[01:28:22.322]                       is.null <- base::is.null
[01:28:22.322]                       muffled <- FALSE
[01:28:22.322]                       if (inherits(cond, "message")) {
[01:28:22.322]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:22.322]                         if (muffled) 
[01:28:22.322]                           invokeRestart("muffleMessage")
[01:28:22.322]                       }
[01:28:22.322]                       else if (inherits(cond, "warning")) {
[01:28:22.322]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:22.322]                         if (muffled) 
[01:28:22.322]                           invokeRestart("muffleWarning")
[01:28:22.322]                       }
[01:28:22.322]                       else if (inherits(cond, "condition")) {
[01:28:22.322]                         if (!is.null(pattern)) {
[01:28:22.322]                           computeRestarts <- base::computeRestarts
[01:28:22.322]                           grepl <- base::grepl
[01:28:22.322]                           restarts <- computeRestarts(cond)
[01:28:22.322]                           for (restart in restarts) {
[01:28:22.322]                             name <- restart$name
[01:28:22.322]                             if (is.null(name)) 
[01:28:22.322]                               next
[01:28:22.322]                             if (!grepl(pattern, name)) 
[01:28:22.322]                               next
[01:28:22.322]                             invokeRestart(restart)
[01:28:22.322]                             muffled <- TRUE
[01:28:22.322]                             break
[01:28:22.322]                           }
[01:28:22.322]                         }
[01:28:22.322]                       }
[01:28:22.322]                       invisible(muffled)
[01:28:22.322]                     }
[01:28:22.322]                     muffleCondition(cond, pattern = "^muffle")
[01:28:22.322]                   }
[01:28:22.322]                 }
[01:28:22.322]             }
[01:28:22.322]         }))
[01:28:22.322]     }, error = function(ex) {
[01:28:22.322]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:22.322]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:22.322]                 ...future.rng), started = ...future.startTime, 
[01:28:22.322]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:22.322]             version = "1.8"), class = "FutureResult")
[01:28:22.322]     }, finally = {
[01:28:22.322]         if (!identical(...future.workdir, getwd())) 
[01:28:22.322]             setwd(...future.workdir)
[01:28:22.322]         {
[01:28:22.322]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:22.322]                 ...future.oldOptions$nwarnings <- NULL
[01:28:22.322]             }
[01:28:22.322]             base::options(...future.oldOptions)
[01:28:22.322]             if (.Platform$OS.type == "windows") {
[01:28:22.322]                 old_names <- names(...future.oldEnvVars)
[01:28:22.322]                 envs <- base::Sys.getenv()
[01:28:22.322]                 names <- names(envs)
[01:28:22.322]                 common <- intersect(names, old_names)
[01:28:22.322]                 added <- setdiff(names, old_names)
[01:28:22.322]                 removed <- setdiff(old_names, names)
[01:28:22.322]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:22.322]                   envs[common]]
[01:28:22.322]                 NAMES <- toupper(changed)
[01:28:22.322]                 args <- list()
[01:28:22.322]                 for (kk in seq_along(NAMES)) {
[01:28:22.322]                   name <- changed[[kk]]
[01:28:22.322]                   NAME <- NAMES[[kk]]
[01:28:22.322]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:22.322]                     next
[01:28:22.322]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:22.322]                 }
[01:28:22.322]                 NAMES <- toupper(added)
[01:28:22.322]                 for (kk in seq_along(NAMES)) {
[01:28:22.322]                   name <- added[[kk]]
[01:28:22.322]                   NAME <- NAMES[[kk]]
[01:28:22.322]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:22.322]                     next
[01:28:22.322]                   args[[name]] <- ""
[01:28:22.322]                 }
[01:28:22.322]                 NAMES <- toupper(removed)
[01:28:22.322]                 for (kk in seq_along(NAMES)) {
[01:28:22.322]                   name <- removed[[kk]]
[01:28:22.322]                   NAME <- NAMES[[kk]]
[01:28:22.322]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:22.322]                     next
[01:28:22.322]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:22.322]                 }
[01:28:22.322]                 if (length(args) > 0) 
[01:28:22.322]                   base::do.call(base::Sys.setenv, args = args)
[01:28:22.322]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:22.322]             }
[01:28:22.322]             else {
[01:28:22.322]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:22.322]             }
[01:28:22.322]             {
[01:28:22.322]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:22.322]                   0L) {
[01:28:22.322]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:22.322]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:22.322]                   base::options(opts)
[01:28:22.322]                 }
[01:28:22.322]                 {
[01:28:22.322]                   {
[01:28:22.322]                     NULL
[01:28:22.322]                     RNGkind("Mersenne-Twister")
[01:28:22.322]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:22.322]                       inherits = FALSE)
[01:28:22.322]                   }
[01:28:22.322]                   options(future.plan = NULL)
[01:28:22.322]                   if (is.na(NA_character_)) 
[01:28:22.322]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:22.322]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:22.322]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:22.322]                   {
[01:28:22.322]                     future <- SequentialFuture(..., envir = envir)
[01:28:22.322]                     if (!future$lazy) 
[01:28:22.322]                       future <- run(future)
[01:28:22.322]                     invisible(future)
[01:28:22.322]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:22.322]                 }
[01:28:22.322]             }
[01:28:22.322]         }
[01:28:22.322]     })
[01:28:22.322]     if (TRUE) {
[01:28:22.322]         base::sink(type = "output", split = FALSE)
[01:28:22.322]         if (TRUE) {
[01:28:22.322]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:22.322]         }
[01:28:22.322]         else {
[01:28:22.322]             ...future.result["stdout"] <- base::list(NULL)
[01:28:22.322]         }
[01:28:22.322]         base::close(...future.stdout)
[01:28:22.322]         ...future.stdout <- NULL
[01:28:22.322]     }
[01:28:22.322]     ...future.result$conditions <- ...future.conditions
[01:28:22.322]     ...future.result$finished <- base::Sys.time()
[01:28:22.322]     ...future.result
[01:28:22.322] }
[01:28:22.326] assign_globals() ...
[01:28:22.327] List of 1
[01:28:22.327]  $ a: num 0
[01:28:22.327]  - attr(*, "where")=List of 1
[01:28:22.327]   ..$ a:<environment: R_EmptyEnv> 
[01:28:22.327]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:22.327]  - attr(*, "resolved")= logi FALSE
[01:28:22.327]  - attr(*, "total_size")= num 56
[01:28:22.333] - copied 'a' to environment
[01:28:22.333] assign_globals() ... done
[01:28:22.334] plan(): Setting new future strategy stack:
[01:28:22.334] List of future strategies:
[01:28:22.334] 1. sequential:
[01:28:22.334]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:22.334]    - tweaked: FALSE
[01:28:22.334]    - call: NULL
[01:28:22.334] plan(): nbrOfWorkers() = 1
[01:28:22.336] plan(): Setting new future strategy stack:
[01:28:22.336] List of future strategies:
[01:28:22.336] 1. sequential:
[01:28:22.336]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:22.336]    - tweaked: FALSE
[01:28:22.336]    - call: future::plan("sequential")
[01:28:22.337] plan(): nbrOfWorkers() = 1
[01:28:22.337] SequentialFuture started (and completed)
[1] 0
*** multisession() with globals and blocking
 - Creating multisession future #2 ...
[01:28:22.343] getGlobalsAndPackages() ...
[01:28:22.343] Searching for globals...
[01:28:22.344] - globals found: [2] '{', 'ii'
[01:28:22.344] Searching for globals ... DONE
[01:28:22.345] Resolving globals: FALSE
[01:28:22.345] The total size of the 1 globals is 56 bytes (56 bytes)
[01:28:22.346] The total size of the 1 globals exported for future expression ('{; ii; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'ii' (56 bytes of class 'numeric')
[01:28:22.346] - globals: [1] 'ii'
[01:28:22.346] 
[01:28:22.346] getGlobalsAndPackages() ... DONE
 - Creating multisession future #1 ...
[01:28:22.349] getGlobalsAndPackages() ...
[01:28:22.349] Searching for globals...
[01:28:22.350] - globals found: [2] '{', 'ii'
[01:28:22.350] Searching for globals ... DONE
[01:28:22.350] Resolving globals: FALSE
[01:28:22.351] The total size of the 1 globals is 56 bytes (56 bytes)
[01:28:22.351] The total size of the 1 globals exported for future expression ('{; ii; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'ii' (56 bytes of class 'numeric')
[01:28:22.352] - globals: [1] 'ii'
[01:28:22.352] 
[01:28:22.352] getGlobalsAndPackages() ... DONE
 - Resolving 2 multisession futures
[01:28:22.353] Packages needed by the future expression (n = 0): <none>
[01:28:22.353] Packages needed by future strategies (n = 0): <none>
[01:28:22.353] {
[01:28:22.353]     {
[01:28:22.353]         {
[01:28:22.353]             ...future.startTime <- base::Sys.time()
[01:28:22.353]             {
[01:28:22.353]                 {
[01:28:22.353]                   {
[01:28:22.353]                     base::local({
[01:28:22.353]                       has_future <- base::requireNamespace("future", 
[01:28:22.353]                         quietly = TRUE)
[01:28:22.353]                       if (has_future) {
[01:28:22.353]                         ns <- base::getNamespace("future")
[01:28:22.353]                         version <- ns[[".package"]][["version"]]
[01:28:22.353]                         if (is.null(version)) 
[01:28:22.353]                           version <- utils::packageVersion("future")
[01:28:22.353]                       }
[01:28:22.353]                       else {
[01:28:22.353]                         version <- NULL
[01:28:22.353]                       }
[01:28:22.353]                       if (!has_future || version < "1.8.0") {
[01:28:22.353]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:22.353]                           "", base::R.version$version.string), 
[01:28:22.353]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:22.353]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:22.353]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:22.353]                             "release", "version")], collapse = " "), 
[01:28:22.353]                           hostname = base::Sys.info()[["nodename"]])
[01:28:22.353]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:22.353]                           info)
[01:28:22.353]                         info <- base::paste(info, collapse = "; ")
[01:28:22.353]                         if (!has_future) {
[01:28:22.353]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:22.353]                             info)
[01:28:22.353]                         }
[01:28:22.353]                         else {
[01:28:22.353]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:22.353]                             info, version)
[01:28:22.353]                         }
[01:28:22.353]                         base::stop(msg)
[01:28:22.353]                       }
[01:28:22.353]                     })
[01:28:22.353]                   }
[01:28:22.353]                   options(future.plan = NULL)
[01:28:22.353]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:22.353]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:22.353]                 }
[01:28:22.353]                 ...future.workdir <- getwd()
[01:28:22.353]             }
[01:28:22.353]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:22.353]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:22.353]         }
[01:28:22.353]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:22.353]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:22.353]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:22.353]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:22.353]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:22.353]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:22.353]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:22.353]             base::names(...future.oldOptions))
[01:28:22.353]     }
[01:28:22.353]     if (FALSE) {
[01:28:22.353]     }
[01:28:22.353]     else {
[01:28:22.353]         if (TRUE) {
[01:28:22.353]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:22.353]                 open = "w")
[01:28:22.353]         }
[01:28:22.353]         else {
[01:28:22.353]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:22.353]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:22.353]         }
[01:28:22.353]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:22.353]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:22.353]             base::sink(type = "output", split = FALSE)
[01:28:22.353]             base::close(...future.stdout)
[01:28:22.353]         }, add = TRUE)
[01:28:22.353]     }
[01:28:22.353]     ...future.frame <- base::sys.nframe()
[01:28:22.353]     ...future.conditions <- base::list()
[01:28:22.353]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:22.353]     if (FALSE) {
[01:28:22.353]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:22.353]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:22.353]     }
[01:28:22.353]     ...future.result <- base::tryCatch({
[01:28:22.353]         base::withCallingHandlers({
[01:28:22.353]             ...future.value <- base::withVisible(base::local({
[01:28:22.353]                 ii
[01:28:22.353]             }))
[01:28:22.353]             future::FutureResult(value = ...future.value$value, 
[01:28:22.353]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:22.353]                   ...future.rng), globalenv = if (FALSE) 
[01:28:22.353]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:22.353]                     ...future.globalenv.names))
[01:28:22.353]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:22.353]         }, condition = base::local({
[01:28:22.353]             c <- base::c
[01:28:22.353]             inherits <- base::inherits
[01:28:22.353]             invokeRestart <- base::invokeRestart
[01:28:22.353]             length <- base::length
[01:28:22.353]             list <- base::list
[01:28:22.353]             seq.int <- base::seq.int
[01:28:22.353]             signalCondition <- base::signalCondition
[01:28:22.353]             sys.calls <- base::sys.calls
[01:28:22.353]             `[[` <- base::`[[`
[01:28:22.353]             `+` <- base::`+`
[01:28:22.353]             `<<-` <- base::`<<-`
[01:28:22.353]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:22.353]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:22.353]                   3L)]
[01:28:22.353]             }
[01:28:22.353]             function(cond) {
[01:28:22.353]                 is_error <- inherits(cond, "error")
[01:28:22.353]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:22.353]                   NULL)
[01:28:22.353]                 if (is_error) {
[01:28:22.353]                   sessionInformation <- function() {
[01:28:22.353]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:22.353]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:22.353]                       search = base::search(), system = base::Sys.info())
[01:28:22.353]                   }
[01:28:22.353]                   ...future.conditions[[length(...future.conditions) + 
[01:28:22.353]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:22.353]                     cond$call), session = sessionInformation(), 
[01:28:22.353]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:22.353]                   signalCondition(cond)
[01:28:22.353]                 }
[01:28:22.353]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:22.353]                 "immediateCondition"))) {
[01:28:22.353]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:22.353]                   ...future.conditions[[length(...future.conditions) + 
[01:28:22.353]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:22.353]                   if (TRUE && !signal) {
[01:28:22.353]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:22.353]                     {
[01:28:22.353]                       inherits <- base::inherits
[01:28:22.353]                       invokeRestart <- base::invokeRestart
[01:28:22.353]                       is.null <- base::is.null
[01:28:22.353]                       muffled <- FALSE
[01:28:22.353]                       if (inherits(cond, "message")) {
[01:28:22.353]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:22.353]                         if (muffled) 
[01:28:22.353]                           invokeRestart("muffleMessage")
[01:28:22.353]                       }
[01:28:22.353]                       else if (inherits(cond, "warning")) {
[01:28:22.353]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:22.353]                         if (muffled) 
[01:28:22.353]                           invokeRestart("muffleWarning")
[01:28:22.353]                       }
[01:28:22.353]                       else if (inherits(cond, "condition")) {
[01:28:22.353]                         if (!is.null(pattern)) {
[01:28:22.353]                           computeRestarts <- base::computeRestarts
[01:28:22.353]                           grepl <- base::grepl
[01:28:22.353]                           restarts <- computeRestarts(cond)
[01:28:22.353]                           for (restart in restarts) {
[01:28:22.353]                             name <- restart$name
[01:28:22.353]                             if (is.null(name)) 
[01:28:22.353]                               next
[01:28:22.353]                             if (!grepl(pattern, name)) 
[01:28:22.353]                               next
[01:28:22.353]                             invokeRestart(restart)
[01:28:22.353]                             muffled <- TRUE
[01:28:22.353]                             break
[01:28:22.353]                           }
[01:28:22.353]                         }
[01:28:22.353]                       }
[01:28:22.353]                       invisible(muffled)
[01:28:22.353]                     }
[01:28:22.353]                     muffleCondition(cond, pattern = "^muffle")
[01:28:22.353]                   }
[01:28:22.353]                 }
[01:28:22.353]                 else {
[01:28:22.353]                   if (TRUE) {
[01:28:22.353]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:22.353]                     {
[01:28:22.353]                       inherits <- base::inherits
[01:28:22.353]                       invokeRestart <- base::invokeRestart
[01:28:22.353]                       is.null <- base::is.null
[01:28:22.353]                       muffled <- FALSE
[01:28:22.353]                       if (inherits(cond, "message")) {
[01:28:22.353]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:22.353]                         if (muffled) 
[01:28:22.353]                           invokeRestart("muffleMessage")
[01:28:22.353]                       }
[01:28:22.353]                       else if (inherits(cond, "warning")) {
[01:28:22.353]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:22.353]                         if (muffled) 
[01:28:22.353]                           invokeRestart("muffleWarning")
[01:28:22.353]                       }
[01:28:22.353]                       else if (inherits(cond, "condition")) {
[01:28:22.353]                         if (!is.null(pattern)) {
[01:28:22.353]                           computeRestarts <- base::computeRestarts
[01:28:22.353]                           grepl <- base::grepl
[01:28:22.353]                           restarts <- computeRestarts(cond)
[01:28:22.353]                           for (restart in restarts) {
[01:28:22.353]                             name <- restart$name
[01:28:22.353]                             if (is.null(name)) 
[01:28:22.353]                               next
[01:28:22.353]                             if (!grepl(pattern, name)) 
[01:28:22.353]                               next
[01:28:22.353]                             invokeRestart(restart)
[01:28:22.353]                             muffled <- TRUE
[01:28:22.353]                             break
[01:28:22.353]                           }
[01:28:22.353]                         }
[01:28:22.353]                       }
[01:28:22.353]                       invisible(muffled)
[01:28:22.353]                     }
[01:28:22.353]                     muffleCondition(cond, pattern = "^muffle")
[01:28:22.353]                   }
[01:28:22.353]                 }
[01:28:22.353]             }
[01:28:22.353]         }))
[01:28:22.353]     }, error = function(ex) {
[01:28:22.353]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:22.353]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:22.353]                 ...future.rng), started = ...future.startTime, 
[01:28:22.353]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:22.353]             version = "1.8"), class = "FutureResult")
[01:28:22.353]     }, finally = {
[01:28:22.353]         if (!identical(...future.workdir, getwd())) 
[01:28:22.353]             setwd(...future.workdir)
[01:28:22.353]         {
[01:28:22.353]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:22.353]                 ...future.oldOptions$nwarnings <- NULL
[01:28:22.353]             }
[01:28:22.353]             base::options(...future.oldOptions)
[01:28:22.353]             if (.Platform$OS.type == "windows") {
[01:28:22.353]                 old_names <- names(...future.oldEnvVars)
[01:28:22.353]                 envs <- base::Sys.getenv()
[01:28:22.353]                 names <- names(envs)
[01:28:22.353]                 common <- intersect(names, old_names)
[01:28:22.353]                 added <- setdiff(names, old_names)
[01:28:22.353]                 removed <- setdiff(old_names, names)
[01:28:22.353]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:22.353]                   envs[common]]
[01:28:22.353]                 NAMES <- toupper(changed)
[01:28:22.353]                 args <- list()
[01:28:22.353]                 for (kk in seq_along(NAMES)) {
[01:28:22.353]                   name <- changed[[kk]]
[01:28:22.353]                   NAME <- NAMES[[kk]]
[01:28:22.353]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:22.353]                     next
[01:28:22.353]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:22.353]                 }
[01:28:22.353]                 NAMES <- toupper(added)
[01:28:22.353]                 for (kk in seq_along(NAMES)) {
[01:28:22.353]                   name <- added[[kk]]
[01:28:22.353]                   NAME <- NAMES[[kk]]
[01:28:22.353]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:22.353]                     next
[01:28:22.353]                   args[[name]] <- ""
[01:28:22.353]                 }
[01:28:22.353]                 NAMES <- toupper(removed)
[01:28:22.353]                 for (kk in seq_along(NAMES)) {
[01:28:22.353]                   name <- removed[[kk]]
[01:28:22.353]                   NAME <- NAMES[[kk]]
[01:28:22.353]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:22.353]                     next
[01:28:22.353]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:22.353]                 }
[01:28:22.353]                 if (length(args) > 0) 
[01:28:22.353]                   base::do.call(base::Sys.setenv, args = args)
[01:28:22.353]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:22.353]             }
[01:28:22.353]             else {
[01:28:22.353]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:22.353]             }
[01:28:22.353]             {
[01:28:22.353]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:22.353]                   0L) {
[01:28:22.353]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:22.353]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:22.353]                   base::options(opts)
[01:28:22.353]                 }
[01:28:22.353]                 {
[01:28:22.353]                   {
[01:28:22.353]                     NULL
[01:28:22.353]                     RNGkind("Mersenne-Twister")
[01:28:22.353]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:22.353]                       inherits = FALSE)
[01:28:22.353]                   }
[01:28:22.353]                   options(future.plan = NULL)
[01:28:22.353]                   if (is.na(NA_character_)) 
[01:28:22.353]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:22.353]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:22.353]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:22.353]                   {
[01:28:22.353]                     future <- SequentialFuture(..., envir = envir)
[01:28:22.353]                     if (!future$lazy) 
[01:28:22.353]                       future <- run(future)
[01:28:22.353]                     invisible(future)
[01:28:22.353]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:22.353]                 }
[01:28:22.353]             }
[01:28:22.353]         }
[01:28:22.353]     })
[01:28:22.353]     if (TRUE) {
[01:28:22.353]         base::sink(type = "output", split = FALSE)
[01:28:22.353]         if (TRUE) {
[01:28:22.353]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:22.353]         }
[01:28:22.353]         else {
[01:28:22.353]             ...future.result["stdout"] <- base::list(NULL)
[01:28:22.353]         }
[01:28:22.353]         base::close(...future.stdout)
[01:28:22.353]         ...future.stdout <- NULL
[01:28:22.353]     }
[01:28:22.353]     ...future.result$conditions <- ...future.conditions
[01:28:22.353]     ...future.result$finished <- base::Sys.time()
[01:28:22.353]     ...future.result
[01:28:22.353] }
[01:28:22.357] assign_globals() ...
[01:28:22.357] List of 1
[01:28:22.357]  $ ii: int 1
[01:28:22.357]  - attr(*, "where")=List of 1
[01:28:22.357]   ..$ ii:<environment: R_EmptyEnv> 
[01:28:22.357]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:22.357]  - attr(*, "resolved")= logi FALSE
[01:28:22.357]  - attr(*, "total_size")= num 56
[01:28:22.360] - copied 'ii' to environment
[01:28:22.360] assign_globals() ... done
[01:28:22.361] plan(): Setting new future strategy stack:
[01:28:22.361] List of future strategies:
[01:28:22.361] 1. sequential:
[01:28:22.361]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:22.361]    - tweaked: FALSE
[01:28:22.361]    - call: NULL
[01:28:22.362] plan(): nbrOfWorkers() = 1
[01:28:22.363] plan(): Setting new future strategy stack:
[01:28:22.363] List of future strategies:
[01:28:22.363] 1. sequential:
[01:28:22.363]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:22.363]    - tweaked: FALSE
[01:28:22.363]    - call: future::plan("sequential")
[01:28:22.364] plan(): nbrOfWorkers() = 1
[01:28:22.364] SequentialFuture started (and completed)
[01:28:22.364] Packages needed by the future expression (n = 0): <none>
[01:28:22.365] Packages needed by future strategies (n = 0): <none>
[01:28:22.365] {
[01:28:22.365]     {
[01:28:22.365]         {
[01:28:22.365]             ...future.startTime <- base::Sys.time()
[01:28:22.365]             {
[01:28:22.365]                 {
[01:28:22.365]                   {
[01:28:22.365]                     base::local({
[01:28:22.365]                       has_future <- base::requireNamespace("future", 
[01:28:22.365]                         quietly = TRUE)
[01:28:22.365]                       if (has_future) {
[01:28:22.365]                         ns <- base::getNamespace("future")
[01:28:22.365]                         version <- ns[[".package"]][["version"]]
[01:28:22.365]                         if (is.null(version)) 
[01:28:22.365]                           version <- utils::packageVersion("future")
[01:28:22.365]                       }
[01:28:22.365]                       else {
[01:28:22.365]                         version <- NULL
[01:28:22.365]                       }
[01:28:22.365]                       if (!has_future || version < "1.8.0") {
[01:28:22.365]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:22.365]                           "", base::R.version$version.string), 
[01:28:22.365]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:22.365]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:22.365]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:22.365]                             "release", "version")], collapse = " "), 
[01:28:22.365]                           hostname = base::Sys.info()[["nodename"]])
[01:28:22.365]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:22.365]                           info)
[01:28:22.365]                         info <- base::paste(info, collapse = "; ")
[01:28:22.365]                         if (!has_future) {
[01:28:22.365]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:22.365]                             info)
[01:28:22.365]                         }
[01:28:22.365]                         else {
[01:28:22.365]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:22.365]                             info, version)
[01:28:22.365]                         }
[01:28:22.365]                         base::stop(msg)
[01:28:22.365]                       }
[01:28:22.365]                     })
[01:28:22.365]                   }
[01:28:22.365]                   options(future.plan = NULL)
[01:28:22.365]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:22.365]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:22.365]                 }
[01:28:22.365]                 ...future.workdir <- getwd()
[01:28:22.365]             }
[01:28:22.365]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:22.365]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:22.365]         }
[01:28:22.365]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:22.365]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:22.365]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:22.365]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:22.365]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:22.365]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:22.365]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:22.365]             base::names(...future.oldOptions))
[01:28:22.365]     }
[01:28:22.365]     if (FALSE) {
[01:28:22.365]     }
[01:28:22.365]     else {
[01:28:22.365]         if (TRUE) {
[01:28:22.365]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:22.365]                 open = "w")
[01:28:22.365]         }
[01:28:22.365]         else {
[01:28:22.365]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:22.365]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:22.365]         }
[01:28:22.365]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:22.365]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:22.365]             base::sink(type = "output", split = FALSE)
[01:28:22.365]             base::close(...future.stdout)
[01:28:22.365]         }, add = TRUE)
[01:28:22.365]     }
[01:28:22.365]     ...future.frame <- base::sys.nframe()
[01:28:22.365]     ...future.conditions <- base::list()
[01:28:22.365]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:22.365]     if (FALSE) {
[01:28:22.365]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:22.365]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:22.365]     }
[01:28:22.365]     ...future.result <- base::tryCatch({
[01:28:22.365]         base::withCallingHandlers({
[01:28:22.365]             ...future.value <- base::withVisible(base::local({
[01:28:22.365]                 ii
[01:28:22.365]             }))
[01:28:22.365]             future::FutureResult(value = ...future.value$value, 
[01:28:22.365]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:22.365]                   ...future.rng), globalenv = if (FALSE) 
[01:28:22.365]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:22.365]                     ...future.globalenv.names))
[01:28:22.365]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:22.365]         }, condition = base::local({
[01:28:22.365]             c <- base::c
[01:28:22.365]             inherits <- base::inherits
[01:28:22.365]             invokeRestart <- base::invokeRestart
[01:28:22.365]             length <- base::length
[01:28:22.365]             list <- base::list
[01:28:22.365]             seq.int <- base::seq.int
[01:28:22.365]             signalCondition <- base::signalCondition
[01:28:22.365]             sys.calls <- base::sys.calls
[01:28:22.365]             `[[` <- base::`[[`
[01:28:22.365]             `+` <- base::`+`
[01:28:22.365]             `<<-` <- base::`<<-`
[01:28:22.365]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:22.365]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:22.365]                   3L)]
[01:28:22.365]             }
[01:28:22.365]             function(cond) {
[01:28:22.365]                 is_error <- inherits(cond, "error")
[01:28:22.365]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:22.365]                   NULL)
[01:28:22.365]                 if (is_error) {
[01:28:22.365]                   sessionInformation <- function() {
[01:28:22.365]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:22.365]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:22.365]                       search = base::search(), system = base::Sys.info())
[01:28:22.365]                   }
[01:28:22.365]                   ...future.conditions[[length(...future.conditions) + 
[01:28:22.365]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:22.365]                     cond$call), session = sessionInformation(), 
[01:28:22.365]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:22.365]                   signalCondition(cond)
[01:28:22.365]                 }
[01:28:22.365]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:22.365]                 "immediateCondition"))) {
[01:28:22.365]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:22.365]                   ...future.conditions[[length(...future.conditions) + 
[01:28:22.365]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:22.365]                   if (TRUE && !signal) {
[01:28:22.365]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:22.365]                     {
[01:28:22.365]                       inherits <- base::inherits
[01:28:22.365]                       invokeRestart <- base::invokeRestart
[01:28:22.365]                       is.null <- base::is.null
[01:28:22.365]                       muffled <- FALSE
[01:28:22.365]                       if (inherits(cond, "message")) {
[01:28:22.365]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:22.365]                         if (muffled) 
[01:28:22.365]                           invokeRestart("muffleMessage")
[01:28:22.365]                       }
[01:28:22.365]                       else if (inherits(cond, "warning")) {
[01:28:22.365]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:22.365]                         if (muffled) 
[01:28:22.365]                           invokeRestart("muffleWarning")
[01:28:22.365]                       }
[01:28:22.365]                       else if (inherits(cond, "condition")) {
[01:28:22.365]                         if (!is.null(pattern)) {
[01:28:22.365]                           computeRestarts <- base::computeRestarts
[01:28:22.365]                           grepl <- base::grepl
[01:28:22.365]                           restarts <- computeRestarts(cond)
[01:28:22.365]                           for (restart in restarts) {
[01:28:22.365]                             name <- restart$name
[01:28:22.365]                             if (is.null(name)) 
[01:28:22.365]                               next
[01:28:22.365]                             if (!grepl(pattern, name)) 
[01:28:22.365]                               next
[01:28:22.365]                             invokeRestart(restart)
[01:28:22.365]                             muffled <- TRUE
[01:28:22.365]                             break
[01:28:22.365]                           }
[01:28:22.365]                         }
[01:28:22.365]                       }
[01:28:22.365]                       invisible(muffled)
[01:28:22.365]                     }
[01:28:22.365]                     muffleCondition(cond, pattern = "^muffle")
[01:28:22.365]                   }
[01:28:22.365]                 }
[01:28:22.365]                 else {
[01:28:22.365]                   if (TRUE) {
[01:28:22.365]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:22.365]                     {
[01:28:22.365]                       inherits <- base::inherits
[01:28:22.365]                       invokeRestart <- base::invokeRestart
[01:28:22.365]                       is.null <- base::is.null
[01:28:22.365]                       muffled <- FALSE
[01:28:22.365]                       if (inherits(cond, "message")) {
[01:28:22.365]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:22.365]                         if (muffled) 
[01:28:22.365]                           invokeRestart("muffleMessage")
[01:28:22.365]                       }
[01:28:22.365]                       else if (inherits(cond, "warning")) {
[01:28:22.365]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:22.365]                         if (muffled) 
[01:28:22.365]                           invokeRestart("muffleWarning")
[01:28:22.365]                       }
[01:28:22.365]                       else if (inherits(cond, "condition")) {
[01:28:22.365]                         if (!is.null(pattern)) {
[01:28:22.365]                           computeRestarts <- base::computeRestarts
[01:28:22.365]                           grepl <- base::grepl
[01:28:22.365]                           restarts <- computeRestarts(cond)
[01:28:22.365]                           for (restart in restarts) {
[01:28:22.365]                             name <- restart$name
[01:28:22.365]                             if (is.null(name)) 
[01:28:22.365]                               next
[01:28:22.365]                             if (!grepl(pattern, name)) 
[01:28:22.365]                               next
[01:28:22.365]                             invokeRestart(restart)
[01:28:22.365]                             muffled <- TRUE
[01:28:22.365]                             break
[01:28:22.365]                           }
[01:28:22.365]                         }
[01:28:22.365]                       }
[01:28:22.365]                       invisible(muffled)
[01:28:22.365]                     }
[01:28:22.365]                     muffleCondition(cond, pattern = "^muffle")
[01:28:22.365]                   }
[01:28:22.365]                 }
[01:28:22.365]             }
[01:28:22.365]         }))
[01:28:22.365]     }, error = function(ex) {
[01:28:22.365]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:22.365]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:22.365]                 ...future.rng), started = ...future.startTime, 
[01:28:22.365]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:22.365]             version = "1.8"), class = "FutureResult")
[01:28:22.365]     }, finally = {
[01:28:22.365]         if (!identical(...future.workdir, getwd())) 
[01:28:22.365]             setwd(...future.workdir)
[01:28:22.365]         {
[01:28:22.365]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:22.365]                 ...future.oldOptions$nwarnings <- NULL
[01:28:22.365]             }
[01:28:22.365]             base::options(...future.oldOptions)
[01:28:22.365]             if (.Platform$OS.type == "windows") {
[01:28:22.365]                 old_names <- names(...future.oldEnvVars)
[01:28:22.365]                 envs <- base::Sys.getenv()
[01:28:22.365]                 names <- names(envs)
[01:28:22.365]                 common <- intersect(names, old_names)
[01:28:22.365]                 added <- setdiff(names, old_names)
[01:28:22.365]                 removed <- setdiff(old_names, names)
[01:28:22.365]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:22.365]                   envs[common]]
[01:28:22.365]                 NAMES <- toupper(changed)
[01:28:22.365]                 args <- list()
[01:28:22.365]                 for (kk in seq_along(NAMES)) {
[01:28:22.365]                   name <- changed[[kk]]
[01:28:22.365]                   NAME <- NAMES[[kk]]
[01:28:22.365]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:22.365]                     next
[01:28:22.365]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:22.365]                 }
[01:28:22.365]                 NAMES <- toupper(added)
[01:28:22.365]                 for (kk in seq_along(NAMES)) {
[01:28:22.365]                   name <- added[[kk]]
[01:28:22.365]                   NAME <- NAMES[[kk]]
[01:28:22.365]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:22.365]                     next
[01:28:22.365]                   args[[name]] <- ""
[01:28:22.365]                 }
[01:28:22.365]                 NAMES <- toupper(removed)
[01:28:22.365]                 for (kk in seq_along(NAMES)) {
[01:28:22.365]                   name <- removed[[kk]]
[01:28:22.365]                   NAME <- NAMES[[kk]]
[01:28:22.365]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:22.365]                     next
[01:28:22.365]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:22.365]                 }
[01:28:22.365]                 if (length(args) > 0) 
[01:28:22.365]                   base::do.call(base::Sys.setenv, args = args)
[01:28:22.365]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:22.365]             }
[01:28:22.365]             else {
[01:28:22.365]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:22.365]             }
[01:28:22.365]             {
[01:28:22.365]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:22.365]                   0L) {
[01:28:22.365]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:22.365]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:22.365]                   base::options(opts)
[01:28:22.365]                 }
[01:28:22.365]                 {
[01:28:22.365]                   {
[01:28:22.365]                     NULL
[01:28:22.365]                     RNGkind("Mersenne-Twister")
[01:28:22.365]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:22.365]                       inherits = FALSE)
[01:28:22.365]                   }
[01:28:22.365]                   options(future.plan = NULL)
[01:28:22.365]                   if (is.na(NA_character_)) 
[01:28:22.365]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:22.365]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:22.365]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:22.365]                   {
[01:28:22.365]                     future <- SequentialFuture(..., envir = envir)
[01:28:22.365]                     if (!future$lazy) 
[01:28:22.365]                       future <- run(future)
[01:28:22.365]                     invisible(future)
[01:28:22.365]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:22.365]                 }
[01:28:22.365]             }
[01:28:22.365]         }
[01:28:22.365]     })
[01:28:22.365]     if (TRUE) {
[01:28:22.365]         base::sink(type = "output", split = FALSE)
[01:28:22.365]         if (TRUE) {
[01:28:22.365]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:22.365]         }
[01:28:22.365]         else {
[01:28:22.365]             ...future.result["stdout"] <- base::list(NULL)
[01:28:22.365]         }
[01:28:22.365]         base::close(...future.stdout)
[01:28:22.365]         ...future.stdout <- NULL
[01:28:22.365]     }
[01:28:22.365]     ...future.result$conditions <- ...future.conditions
[01:28:22.365]     ...future.result$finished <- base::Sys.time()
[01:28:22.365]     ...future.result
[01:28:22.365] }
[01:28:22.369] assign_globals() ...
[01:28:22.369] List of 1
[01:28:22.369]  $ ii: int 2
[01:28:22.369]  - attr(*, "where")=List of 1
[01:28:22.369]   ..$ ii:<environment: R_EmptyEnv> 
[01:28:22.369]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:22.369]  - attr(*, "resolved")= logi FALSE
[01:28:22.369]  - attr(*, "total_size")= num 56
[01:28:22.372] - copied 'ii' to environment
[01:28:22.372] assign_globals() ... done
[01:28:22.373] plan(): Setting new future strategy stack:
[01:28:22.373] List of future strategies:
[01:28:22.373] 1. sequential:
[01:28:22.373]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:22.373]    - tweaked: FALSE
[01:28:22.373]    - call: NULL
[01:28:22.373] plan(): nbrOfWorkers() = 1
[01:28:22.375] plan(): Setting new future strategy stack:
[01:28:22.375] List of future strategies:
[01:28:22.375] 1. sequential:
[01:28:22.375]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:22.375]    - tweaked: FALSE
[01:28:22.375]    - call: future::plan("sequential")
[01:28:22.375] plan(): nbrOfWorkers() = 1
[01:28:22.376] SequentialFuture started (and completed)
*** multisession() - workers inherit .libPaths()
[01:28:22.376] getGlobalsAndPackages() ...
[01:28:22.376] Searching for globals...
[01:28:22.377] - globals found: [1] '.libPaths'
[01:28:22.377] Searching for globals ... DONE
[01:28:22.377] Resolving globals: FALSE
[01:28:22.378] 
[01:28:22.378] 
[01:28:22.378] getGlobalsAndPackages() ... DONE
[01:28:22.378] run() for 'Future' ...
[01:28:22.379] - state: 'created'
[01:28:22.379] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:22.379] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:22.379] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:22.380]   - Field: 'label'
[01:28:22.380]   - Field: 'local'
[01:28:22.380]   - Field: 'owner'
[01:28:22.380]   - Field: 'envir'
[01:28:22.380]   - Field: 'packages'
[01:28:22.381]   - Field: 'gc'
[01:28:22.381]   - Field: 'conditions'
[01:28:22.381]   - Field: 'expr'
[01:28:22.381]   - Field: 'uuid'
[01:28:22.381]   - Field: 'seed'
[01:28:22.381]   - Field: 'version'
[01:28:22.382]   - Field: 'result'
[01:28:22.382]   - Field: 'asynchronous'
[01:28:22.382]   - Field: 'calls'
[01:28:22.382]   - Field: 'globals'
[01:28:22.382]   - Field: 'stdout'
[01:28:22.384]   - Field: 'earlySignal'
[01:28:22.384]   - Field: 'lazy'
[01:28:22.384]   - Field: 'state'
[01:28:22.384] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:22.384] - Launch lazy future ...
[01:28:22.385] Packages needed by the future expression (n = 0): <none>
[01:28:22.385] Packages needed by future strategies (n = 0): <none>
[01:28:22.385] {
[01:28:22.385]     {
[01:28:22.385]         {
[01:28:22.385]             ...future.startTime <- base::Sys.time()
[01:28:22.385]             {
[01:28:22.385]                 {
[01:28:22.385]                   {
[01:28:22.385]                     base::local({
[01:28:22.385]                       has_future <- base::requireNamespace("future", 
[01:28:22.385]                         quietly = TRUE)
[01:28:22.385]                       if (has_future) {
[01:28:22.385]                         ns <- base::getNamespace("future")
[01:28:22.385]                         version <- ns[[".package"]][["version"]]
[01:28:22.385]                         if (is.null(version)) 
[01:28:22.385]                           version <- utils::packageVersion("future")
[01:28:22.385]                       }
[01:28:22.385]                       else {
[01:28:22.385]                         version <- NULL
[01:28:22.385]                       }
[01:28:22.385]                       if (!has_future || version < "1.8.0") {
[01:28:22.385]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:22.385]                           "", base::R.version$version.string), 
[01:28:22.385]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:22.385]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:22.385]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:22.385]                             "release", "version")], collapse = " "), 
[01:28:22.385]                           hostname = base::Sys.info()[["nodename"]])
[01:28:22.385]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:22.385]                           info)
[01:28:22.385]                         info <- base::paste(info, collapse = "; ")
[01:28:22.385]                         if (!has_future) {
[01:28:22.385]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:22.385]                             info)
[01:28:22.385]                         }
[01:28:22.385]                         else {
[01:28:22.385]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:22.385]                             info, version)
[01:28:22.385]                         }
[01:28:22.385]                         base::stop(msg)
[01:28:22.385]                       }
[01:28:22.385]                     })
[01:28:22.385]                   }
[01:28:22.385]                   options(future.plan = NULL)
[01:28:22.385]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:22.385]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:22.385]                 }
[01:28:22.385]                 ...future.workdir <- getwd()
[01:28:22.385]             }
[01:28:22.385]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:22.385]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:22.385]         }
[01:28:22.385]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:22.385]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:22.385]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:22.385]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:22.385]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:22.385]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:22.385]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:22.385]             base::names(...future.oldOptions))
[01:28:22.385]     }
[01:28:22.385]     if (FALSE) {
[01:28:22.385]     }
[01:28:22.385]     else {
[01:28:22.385]         if (TRUE) {
[01:28:22.385]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:22.385]                 open = "w")
[01:28:22.385]         }
[01:28:22.385]         else {
[01:28:22.385]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:22.385]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:22.385]         }
[01:28:22.385]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:22.385]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:22.385]             base::sink(type = "output", split = FALSE)
[01:28:22.385]             base::close(...future.stdout)
[01:28:22.385]         }, add = TRUE)
[01:28:22.385]     }
[01:28:22.385]     ...future.frame <- base::sys.nframe()
[01:28:22.385]     ...future.conditions <- base::list()
[01:28:22.385]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:22.385]     if (FALSE) {
[01:28:22.385]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:22.385]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:22.385]     }
[01:28:22.385]     ...future.result <- base::tryCatch({
[01:28:22.385]         base::withCallingHandlers({
[01:28:22.385]             ...future.value <- base::withVisible(base::local(.libPaths()))
[01:28:22.385]             future::FutureResult(value = ...future.value$value, 
[01:28:22.385]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:22.385]                   ...future.rng), globalenv = if (FALSE) 
[01:28:22.385]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:22.385]                     ...future.globalenv.names))
[01:28:22.385]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:22.385]         }, condition = base::local({
[01:28:22.385]             c <- base::c
[01:28:22.385]             inherits <- base::inherits
[01:28:22.385]             invokeRestart <- base::invokeRestart
[01:28:22.385]             length <- base::length
[01:28:22.385]             list <- base::list
[01:28:22.385]             seq.int <- base::seq.int
[01:28:22.385]             signalCondition <- base::signalCondition
[01:28:22.385]             sys.calls <- base::sys.calls
[01:28:22.385]             `[[` <- base::`[[`
[01:28:22.385]             `+` <- base::`+`
[01:28:22.385]             `<<-` <- base::`<<-`
[01:28:22.385]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:22.385]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:22.385]                   3L)]
[01:28:22.385]             }
[01:28:22.385]             function(cond) {
[01:28:22.385]                 is_error <- inherits(cond, "error")
[01:28:22.385]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:22.385]                   NULL)
[01:28:22.385]                 if (is_error) {
[01:28:22.385]                   sessionInformation <- function() {
[01:28:22.385]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:22.385]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:22.385]                       search = base::search(), system = base::Sys.info())
[01:28:22.385]                   }
[01:28:22.385]                   ...future.conditions[[length(...future.conditions) + 
[01:28:22.385]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:22.385]                     cond$call), session = sessionInformation(), 
[01:28:22.385]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:22.385]                   signalCondition(cond)
[01:28:22.385]                 }
[01:28:22.385]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:22.385]                 "immediateCondition"))) {
[01:28:22.385]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:22.385]                   ...future.conditions[[length(...future.conditions) + 
[01:28:22.385]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:22.385]                   if (TRUE && !signal) {
[01:28:22.385]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:22.385]                     {
[01:28:22.385]                       inherits <- base::inherits
[01:28:22.385]                       invokeRestart <- base::invokeRestart
[01:28:22.385]                       is.null <- base::is.null
[01:28:22.385]                       muffled <- FALSE
[01:28:22.385]                       if (inherits(cond, "message")) {
[01:28:22.385]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:22.385]                         if (muffled) 
[01:28:22.385]                           invokeRestart("muffleMessage")
[01:28:22.385]                       }
[01:28:22.385]                       else if (inherits(cond, "warning")) {
[01:28:22.385]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:22.385]                         if (muffled) 
[01:28:22.385]                           invokeRestart("muffleWarning")
[01:28:22.385]                       }
[01:28:22.385]                       else if (inherits(cond, "condition")) {
[01:28:22.385]                         if (!is.null(pattern)) {
[01:28:22.385]                           computeRestarts <- base::computeRestarts
[01:28:22.385]                           grepl <- base::grepl
[01:28:22.385]                           restarts <- computeRestarts(cond)
[01:28:22.385]                           for (restart in restarts) {
[01:28:22.385]                             name <- restart$name
[01:28:22.385]                             if (is.null(name)) 
[01:28:22.385]                               next
[01:28:22.385]                             if (!grepl(pattern, name)) 
[01:28:22.385]                               next
[01:28:22.385]                             invokeRestart(restart)
[01:28:22.385]                             muffled <- TRUE
[01:28:22.385]                             break
[01:28:22.385]                           }
[01:28:22.385]                         }
[01:28:22.385]                       }
[01:28:22.385]                       invisible(muffled)
[01:28:22.385]                     }
[01:28:22.385]                     muffleCondition(cond, pattern = "^muffle")
[01:28:22.385]                   }
[01:28:22.385]                 }
[01:28:22.385]                 else {
[01:28:22.385]                   if (TRUE) {
[01:28:22.385]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:22.385]                     {
[01:28:22.385]                       inherits <- base::inherits
[01:28:22.385]                       invokeRestart <- base::invokeRestart
[01:28:22.385]                       is.null <- base::is.null
[01:28:22.385]                       muffled <- FALSE
[01:28:22.385]                       if (inherits(cond, "message")) {
[01:28:22.385]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:22.385]                         if (muffled) 
[01:28:22.385]                           invokeRestart("muffleMessage")
[01:28:22.385]                       }
[01:28:22.385]                       else if (inherits(cond, "warning")) {
[01:28:22.385]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:22.385]                         if (muffled) 
[01:28:22.385]                           invokeRestart("muffleWarning")
[01:28:22.385]                       }
[01:28:22.385]                       else if (inherits(cond, "condition")) {
[01:28:22.385]                         if (!is.null(pattern)) {
[01:28:22.385]                           computeRestarts <- base::computeRestarts
[01:28:22.385]                           grepl <- base::grepl
[01:28:22.385]                           restarts <- computeRestarts(cond)
[01:28:22.385]                           for (restart in restarts) {
[01:28:22.385]                             name <- restart$name
[01:28:22.385]                             if (is.null(name)) 
[01:28:22.385]                               next
[01:28:22.385]                             if (!grepl(pattern, name)) 
[01:28:22.385]                               next
[01:28:22.385]                             invokeRestart(restart)
[01:28:22.385]                             muffled <- TRUE
[01:28:22.385]                             break
[01:28:22.385]                           }
[01:28:22.385]                         }
[01:28:22.385]                       }
[01:28:22.385]                       invisible(muffled)
[01:28:22.385]                     }
[01:28:22.385]                     muffleCondition(cond, pattern = "^muffle")
[01:28:22.385]                   }
[01:28:22.385]                 }
[01:28:22.385]             }
[01:28:22.385]         }))
[01:28:22.385]     }, error = function(ex) {
[01:28:22.385]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:22.385]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:22.385]                 ...future.rng), started = ...future.startTime, 
[01:28:22.385]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:22.385]             version = "1.8"), class = "FutureResult")
[01:28:22.385]     }, finally = {
[01:28:22.385]         if (!identical(...future.workdir, getwd())) 
[01:28:22.385]             setwd(...future.workdir)
[01:28:22.385]         {
[01:28:22.385]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:22.385]                 ...future.oldOptions$nwarnings <- NULL
[01:28:22.385]             }
[01:28:22.385]             base::options(...future.oldOptions)
[01:28:22.385]             if (.Platform$OS.type == "windows") {
[01:28:22.385]                 old_names <- names(...future.oldEnvVars)
[01:28:22.385]                 envs <- base::Sys.getenv()
[01:28:22.385]                 names <- names(envs)
[01:28:22.385]                 common <- intersect(names, old_names)
[01:28:22.385]                 added <- setdiff(names, old_names)
[01:28:22.385]                 removed <- setdiff(old_names, names)
[01:28:22.385]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:22.385]                   envs[common]]
[01:28:22.385]                 NAMES <- toupper(changed)
[01:28:22.385]                 args <- list()
[01:28:22.385]                 for (kk in seq_along(NAMES)) {
[01:28:22.385]                   name <- changed[[kk]]
[01:28:22.385]                   NAME <- NAMES[[kk]]
[01:28:22.385]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:22.385]                     next
[01:28:22.385]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:22.385]                 }
[01:28:22.385]                 NAMES <- toupper(added)
[01:28:22.385]                 for (kk in seq_along(NAMES)) {
[01:28:22.385]                   name <- added[[kk]]
[01:28:22.385]                   NAME <- NAMES[[kk]]
[01:28:22.385]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:22.385]                     next
[01:28:22.385]                   args[[name]] <- ""
[01:28:22.385]                 }
[01:28:22.385]                 NAMES <- toupper(removed)
[01:28:22.385]                 for (kk in seq_along(NAMES)) {
[01:28:22.385]                   name <- removed[[kk]]
[01:28:22.385]                   NAME <- NAMES[[kk]]
[01:28:22.385]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:22.385]                     next
[01:28:22.385]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:22.385]                 }
[01:28:22.385]                 if (length(args) > 0) 
[01:28:22.385]                   base::do.call(base::Sys.setenv, args = args)
[01:28:22.385]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:22.385]             }
[01:28:22.385]             else {
[01:28:22.385]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:22.385]             }
[01:28:22.385]             {
[01:28:22.385]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:22.385]                   0L) {
[01:28:22.385]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:22.385]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:22.385]                   base::options(opts)
[01:28:22.385]                 }
[01:28:22.385]                 {
[01:28:22.385]                   {
[01:28:22.385]                     NULL
[01:28:22.385]                     RNGkind("Mersenne-Twister")
[01:28:22.385]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:22.385]                       inherits = FALSE)
[01:28:22.385]                   }
[01:28:22.385]                   options(future.plan = NULL)
[01:28:22.385]                   if (is.na(NA_character_)) 
[01:28:22.385]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:22.385]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:22.385]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:22.385]                   {
[01:28:22.385]                     future <- SequentialFuture(..., envir = envir)
[01:28:22.385]                     if (!future$lazy) 
[01:28:22.385]                       future <- run(future)
[01:28:22.385]                     invisible(future)
[01:28:22.385]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:22.385]                 }
[01:28:22.385]             }
[01:28:22.385]         }
[01:28:22.385]     })
[01:28:22.385]     if (TRUE) {
[01:28:22.385]         base::sink(type = "output", split = FALSE)
[01:28:22.385]         if (TRUE) {
[01:28:22.385]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:22.385]         }
[01:28:22.385]         else {
[01:28:22.385]             ...future.result["stdout"] <- base::list(NULL)
[01:28:22.385]         }
[01:28:22.385]         base::close(...future.stdout)
[01:28:22.385]         ...future.stdout <- NULL
[01:28:22.385]     }
[01:28:22.385]     ...future.result$conditions <- ...future.conditions
[01:28:22.385]     ...future.result$finished <- base::Sys.time()
[01:28:22.385]     ...future.result
[01:28:22.385] }
[01:28:22.390] plan(): Setting new future strategy stack:
[01:28:22.390] List of future strategies:
[01:28:22.390] 1. sequential:
[01:28:22.390]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:22.390]    - tweaked: FALSE
[01:28:22.390]    - call: NULL
[01:28:22.390] plan(): nbrOfWorkers() = 1
[01:28:22.392] plan(): Setting new future strategy stack:
[01:28:22.392] List of future strategies:
[01:28:22.392] 1. sequential:
[01:28:22.392]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:22.392]    - tweaked: FALSE
[01:28:22.392]    - call: future::plan("sequential")
[01:28:22.392] plan(): nbrOfWorkers() = 1
[01:28:22.393] SequentialFuture started (and completed)
[01:28:22.393] - Launch lazy future ... done
[01:28:22.393] run() for 'SequentialFuture' ... done
List of 2
 $ main   : chr [1:2] "D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47" "D:/RCompile/recent/R/library"
 $ workers: chr [1:2] "D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47" "D:/RCompile/recent/R/library"
*** multisession() and errors
[01:28:22.396] getGlobalsAndPackages() ...
[01:28:22.397] Searching for globals...
[01:28:22.398] - globals found: [2] '{', 'stop'
[01:28:22.398] Searching for globals ... DONE
[01:28:22.398] Resolving globals: FALSE
[01:28:22.398] 
[01:28:22.399] 
[01:28:22.399] 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: cfeec5f2-987d-97c4-cbb0-b2e17579921c
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:22.400] Packages needed by the future expression (n = 0): <none>
[01:28:22.400] Packages needed by future strategies (n = 0): <none>
[01:28:22.400] {
[01:28:22.400]     {
[01:28:22.400]         {
[01:28:22.400]             ...future.startTime <- base::Sys.time()
[01:28:22.400]             {
[01:28:22.400]                 {
[01:28:22.400]                   {
[01:28:22.400]                     base::local({
[01:28:22.400]                       has_future <- base::requireNamespace("future", 
[01:28:22.400]                         quietly = TRUE)
[01:28:22.400]                       if (has_future) {
[01:28:22.400]                         ns <- base::getNamespace("future")
[01:28:22.400]                         version <- ns[[".package"]][["version"]]
[01:28:22.400]                         if (is.null(version)) 
[01:28:22.400]                           version <- utils::packageVersion("future")
[01:28:22.400]                       }
[01:28:22.400]                       else {
[01:28:22.400]                         version <- NULL
[01:28:22.400]                       }
[01:28:22.400]                       if (!has_future || version < "1.8.0") {
[01:28:22.400]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:22.400]                           "", base::R.version$version.string), 
[01:28:22.400]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:22.400]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:22.400]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:22.400]                             "release", "version")], collapse = " "), 
[01:28:22.400]                           hostname = base::Sys.info()[["nodename"]])
[01:28:22.400]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:22.400]                           info)
[01:28:22.400]                         info <- base::paste(info, collapse = "; ")
[01:28:22.400]                         if (!has_future) {
[01:28:22.400]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:22.400]                             info)
[01:28:22.400]                         }
[01:28:22.400]                         else {
[01:28:22.400]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:22.400]                             info, version)
[01:28:22.400]                         }
[01:28:22.400]                         base::stop(msg)
[01:28:22.400]                       }
[01:28:22.400]                     })
[01:28:22.400]                   }
[01:28:22.400]                   options(future.plan = NULL)
[01:28:22.400]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:22.400]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:22.400]                 }
[01:28:22.400]                 ...future.workdir <- getwd()
[01:28:22.400]             }
[01:28:22.400]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:22.400]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:22.400]         }
[01:28:22.400]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:22.400]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:22.400]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:22.400]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:22.400]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:22.400]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:22.400]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:22.400]             base::names(...future.oldOptions))
[01:28:22.400]     }
[01:28:22.400]     if (FALSE) {
[01:28:22.400]     }
[01:28:22.400]     else {
[01:28:22.400]         if (TRUE) {
[01:28:22.400]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:22.400]                 open = "w")
[01:28:22.400]         }
[01:28:22.400]         else {
[01:28:22.400]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:22.400]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:22.400]         }
[01:28:22.400]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:22.400]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:22.400]             base::sink(type = "output", split = FALSE)
[01:28:22.400]             base::close(...future.stdout)
[01:28:22.400]         }, add = TRUE)
[01:28:22.400]     }
[01:28:22.400]     ...future.frame <- base::sys.nframe()
[01:28:22.400]     ...future.conditions <- base::list()
[01:28:22.400]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:22.400]     if (FALSE) {
[01:28:22.400]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:22.400]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:22.400]     }
[01:28:22.400]     ...future.result <- base::tryCatch({
[01:28:22.400]         base::withCallingHandlers({
[01:28:22.400]             ...future.value <- base::withVisible(base::local({
[01:28:22.400]                 stop("Whoops!")
[01:28:22.400]                 1
[01:28:22.400]             }))
[01:28:22.400]             future::FutureResult(value = ...future.value$value, 
[01:28:22.400]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:22.400]                   ...future.rng), globalenv = if (FALSE) 
[01:28:22.400]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:22.400]                     ...future.globalenv.names))
[01:28:22.400]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:22.400]         }, condition = base::local({
[01:28:22.400]             c <- base::c
[01:28:22.400]             inherits <- base::inherits
[01:28:22.400]             invokeRestart <- base::invokeRestart
[01:28:22.400]             length <- base::length
[01:28:22.400]             list <- base::list
[01:28:22.400]             seq.int <- base::seq.int
[01:28:22.400]             signalCondition <- base::signalCondition
[01:28:22.400]             sys.calls <- base::sys.calls
[01:28:22.400]             `[[` <- base::`[[`
[01:28:22.400]             `+` <- base::`+`
[01:28:22.400]             `<<-` <- base::`<<-`
[01:28:22.400]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:22.400]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:22.400]                   3L)]
[01:28:22.400]             }
[01:28:22.400]             function(cond) {
[01:28:22.400]                 is_error <- inherits(cond, "error")
[01:28:22.400]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:22.400]                   NULL)
[01:28:22.400]                 if (is_error) {
[01:28:22.400]                   sessionInformation <- function() {
[01:28:22.400]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:22.400]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:22.400]                       search = base::search(), system = base::Sys.info())
[01:28:22.400]                   }
[01:28:22.400]                   ...future.conditions[[length(...future.conditions) + 
[01:28:22.400]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:22.400]                     cond$call), session = sessionInformation(), 
[01:28:22.400]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:22.400]                   signalCondition(cond)
[01:28:22.400]                 }
[01:28:22.400]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:22.400]                 "immediateCondition"))) {
[01:28:22.400]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:22.400]                   ...future.conditions[[length(...future.conditions) + 
[01:28:22.400]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:22.400]                   if (TRUE && !signal) {
[01:28:22.400]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:22.400]                     {
[01:28:22.400]                       inherits <- base::inherits
[01:28:22.400]                       invokeRestart <- base::invokeRestart
[01:28:22.400]                       is.null <- base::is.null
[01:28:22.400]                       muffled <- FALSE
[01:28:22.400]                       if (inherits(cond, "message")) {
[01:28:22.400]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:22.400]                         if (muffled) 
[01:28:22.400]                           invokeRestart("muffleMessage")
[01:28:22.400]                       }
[01:28:22.400]                       else if (inherits(cond, "warning")) {
[01:28:22.400]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:22.400]                         if (muffled) 
[01:28:22.400]                           invokeRestart("muffleWarning")
[01:28:22.400]                       }
[01:28:22.400]                       else if (inherits(cond, "condition")) {
[01:28:22.400]                         if (!is.null(pattern)) {
[01:28:22.400]                           computeRestarts <- base::computeRestarts
[01:28:22.400]                           grepl <- base::grepl
[01:28:22.400]                           restarts <- computeRestarts(cond)
[01:28:22.400]                           for (restart in restarts) {
[01:28:22.400]                             name <- restart$name
[01:28:22.400]                             if (is.null(name)) 
[01:28:22.400]                               next
[01:28:22.400]                             if (!grepl(pattern, name)) 
[01:28:22.400]                               next
[01:28:22.400]                             invokeRestart(restart)
[01:28:22.400]                             muffled <- TRUE
[01:28:22.400]                             break
[01:28:22.400]                           }
[01:28:22.400]                         }
[01:28:22.400]                       }
[01:28:22.400]                       invisible(muffled)
[01:28:22.400]                     }
[01:28:22.400]                     muffleCondition(cond, pattern = "^muffle")
[01:28:22.400]                   }
[01:28:22.400]                 }
[01:28:22.400]                 else {
[01:28:22.400]                   if (TRUE) {
[01:28:22.400]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:22.400]                     {
[01:28:22.400]                       inherits <- base::inherits
[01:28:22.400]                       invokeRestart <- base::invokeRestart
[01:28:22.400]                       is.null <- base::is.null
[01:28:22.400]                       muffled <- FALSE
[01:28:22.400]                       if (inherits(cond, "message")) {
[01:28:22.400]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:22.400]                         if (muffled) 
[01:28:22.400]                           invokeRestart("muffleMessage")
[01:28:22.400]                       }
[01:28:22.400]                       else if (inherits(cond, "warning")) {
[01:28:22.400]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:22.400]                         if (muffled) 
[01:28:22.400]                           invokeRestart("muffleWarning")
[01:28:22.400]                       }
[01:28:22.400]                       else if (inherits(cond, "condition")) {
[01:28:22.400]                         if (!is.null(pattern)) {
[01:28:22.400]                           computeRestarts <- base::computeRestarts
[01:28:22.400]                           grepl <- base::grepl
[01:28:22.400]                           restarts <- computeRestarts(cond)
[01:28:22.400]                           for (restart in restarts) {
[01:28:22.400]                             name <- restart$name
[01:28:22.400]                             if (is.null(name)) 
[01:28:22.400]                               next
[01:28:22.400]                             if (!grepl(pattern, name)) 
[01:28:22.400]                               next
[01:28:22.400]                             invokeRestart(restart)
[01:28:22.400]                             muffled <- TRUE
[01:28:22.400]                             break
[01:28:22.400]                           }
[01:28:22.400]                         }
[01:28:22.400]                       }
[01:28:22.400]                       invisible(muffled)
[01:28:22.400]                     }
[01:28:22.400]                     muffleCondition(cond, pattern = "^muffle")
[01:28:22.400]                   }
[01:28:22.400]                 }
[01:28:22.400]             }
[01:28:22.400]         }))
[01:28:22.400]     }, error = function(ex) {
[01:28:22.400]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:22.400]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:22.400]                 ...future.rng), started = ...future.startTime, 
[01:28:22.400]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:22.400]             version = "1.8"), class = "FutureResult")
[01:28:22.400]     }, finally = {
[01:28:22.400]         if (!identical(...future.workdir, getwd())) 
[01:28:22.400]             setwd(...future.workdir)
[01:28:22.400]         {
[01:28:22.400]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:22.400]                 ...future.oldOptions$nwarnings <- NULL
[01:28:22.400]             }
[01:28:22.400]             base::options(...future.oldOptions)
[01:28:22.400]             if (.Platform$OS.type == "windows") {
[01:28:22.400]                 old_names <- names(...future.oldEnvVars)
[01:28:22.400]                 envs <- base::Sys.getenv()
[01:28:22.400]                 names <- names(envs)
[01:28:22.400]                 common <- intersect(names, old_names)
[01:28:22.400]                 added <- setdiff(names, old_names)
[01:28:22.400]                 removed <- setdiff(old_names, names)
[01:28:22.400]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:22.400]                   envs[common]]
[01:28:22.400]                 NAMES <- toupper(changed)
[01:28:22.400]                 args <- list()
[01:28:22.400]                 for (kk in seq_along(NAMES)) {
[01:28:22.400]                   name <- changed[[kk]]
[01:28:22.400]                   NAME <- NAMES[[kk]]
[01:28:22.400]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:22.400]                     next
[01:28:22.400]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:22.400]                 }
[01:28:22.400]                 NAMES <- toupper(added)
[01:28:22.400]                 for (kk in seq_along(NAMES)) {
[01:28:22.400]                   name <- added[[kk]]
[01:28:22.400]                   NAME <- NAMES[[kk]]
[01:28:22.400]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:22.400]                     next
[01:28:22.400]                   args[[name]] <- ""
[01:28:22.400]                 }
[01:28:22.400]                 NAMES <- toupper(removed)
[01:28:22.400]                 for (kk in seq_along(NAMES)) {
[01:28:22.400]                   name <- removed[[kk]]
[01:28:22.400]                   NAME <- NAMES[[kk]]
[01:28:22.400]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:22.400]                     next
[01:28:22.400]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:22.400]                 }
[01:28:22.400]                 if (length(args) > 0) 
[01:28:22.400]                   base::do.call(base::Sys.setenv, args = args)
[01:28:22.400]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:22.400]             }
[01:28:22.400]             else {
[01:28:22.400]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:22.400]             }
[01:28:22.400]             {
[01:28:22.400]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:22.400]                   0L) {
[01:28:22.400]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:22.400]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:22.400]                   base::options(opts)
[01:28:22.400]                 }
[01:28:22.400]                 {
[01:28:22.400]                   {
[01:28:22.400]                     NULL
[01:28:22.400]                     RNGkind("Mersenne-Twister")
[01:28:22.400]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:22.400]                       inherits = FALSE)
[01:28:22.400]                   }
[01:28:22.400]                   options(future.plan = NULL)
[01:28:22.400]                   if (is.na(NA_character_)) 
[01:28:22.400]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:22.400]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:22.400]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:22.400]                   {
[01:28:22.400]                     future <- SequentialFuture(..., envir = envir)
[01:28:22.400]                     if (!future$lazy) 
[01:28:22.400]                       future <- run(future)
[01:28:22.400]                     invisible(future)
[01:28:22.400]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:22.400]                 }
[01:28:22.400]             }
[01:28:22.400]         }
[01:28:22.400]     })
[01:28:22.400]     if (TRUE) {
[01:28:22.400]         base::sink(type = "output", split = FALSE)
[01:28:22.400]         if (TRUE) {
[01:28:22.400]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:22.400]         }
[01:28:22.400]         else {
[01:28:22.400]             ...future.result["stdout"] <- base::list(NULL)
[01:28:22.400]         }
[01:28:22.400]         base::close(...future.stdout)
[01:28:22.400]         ...future.stdout <- NULL
[01:28:22.400]     }
[01:28:22.400]     ...future.result$conditions <- ...future.conditions
[01:28:22.400]     ...future.result$finished <- base::Sys.time()
[01:28:22.400]     ...future.result
[01:28:22.400] }
[01:28:22.404] plan(): Setting new future strategy stack:
[01:28:22.405] List of future strategies:
[01:28:22.405] 1. sequential:
[01:28:22.405]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:22.405]    - tweaked: FALSE
[01:28:22.405]    - call: NULL
[01:28:22.405] plan(): nbrOfWorkers() = 1
[01:28:22.407] plan(): Setting new future strategy stack:
[01:28:22.407] List of future strategies:
[01:28:22.407] 1. sequential:
[01:28:22.407]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:22.407]    - tweaked: FALSE
[01:28:22.407]    - call: future::plan("sequential")
[01:28:22.408] plan(): nbrOfWorkers() = 1
[01:28:22.408] SequentialFuture started (and completed)
[01:28:22.408] signalConditions() ...
[01:28:22.408]  - include = 'immediateCondition'
[01:28:22.409]  - exclude = 
[01:28:22.409]  - resignal = FALSE
[01:28:22.409]  - Number of conditions: 1
[01:28:22.409] signalConditions() ... done
[01:28:22.409] signalConditions() ...
[01:28:22.410]  - include = 'immediateCondition'
[01:28:22.410]  - exclude = 
[01:28:22.410]  - resignal = FALSE
[01:28:22.410]  - Number of conditions: 1
[01:28:22.410] signalConditions() ... done
<simpleError in eval(quote({    stop("Whoops!")    1}), new.env()): Whoops!>
[01:28:22.411] signalConditions() ...
[01:28:22.411]  - include = 'immediateCondition'
[01:28:22.411]  - exclude = 
[01:28:22.411]  - resignal = FALSE
[01:28:22.411]  - Number of conditions: 1
[01:28:22.412] signalConditions() ... done
[01:28:22.412] Future state: 'finished'
[01:28:22.412] signalConditions() ...
[01:28:22.412]  - include = 'condition'
[01:28:22.412]  - exclude = 'immediateCondition'
[01:28:22.413]  - resignal = TRUE
[01:28:22.413]  - Number of conditions: 1
[01:28:22.413]  - Condition #1: 'simpleError', 'error', 'condition'
[01:28:22.413] 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!>
[01:28:22.414] signalConditions() ...
[01:28:22.414]  - include = 'immediateCondition'
[01:28:22.414]  - exclude = 
[01:28:22.414]  - resignal = FALSE
[01:28:22.414]  - Number of conditions: 1
[01:28:22.415] signalConditions() ... done
[01:28:22.415] Future state: 'finished'
[01:28:22.415] signalConditions() ...
[01:28:22.415]  - include = 'condition'
[01:28:22.415]  - exclude = 'immediateCondition'
[01:28:22.415]  - resignal = TRUE
[01:28:22.416]  - Number of conditions: 1
[01:28:22.416]  - Condition #1: 'simpleError', 'error', 'condition'
[01:28:22.416] 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!>
[01:28:22.418] getGlobalsAndPackages() ...
[01:28:22.419] Searching for globals...
[01:28:22.420] - globals found: [5] '{', 'stop', 'structure', 'list', 'c'
[01:28:22.420] Searching for globals ... DONE
[01:28:22.420] Resolving globals: FALSE
[01:28:22.421] 
[01:28:22.421] 
[01:28:22.421] 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: cfeec5f2-987d-97c4-cbb0-b2e17579921c
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:22.422] Packages needed by the future expression (n = 0): <none>
[01:28:22.422] Packages needed by future strategies (n = 0): <none>
[01:28:22.423] {
[01:28:22.423]     {
[01:28:22.423]         {
[01:28:22.423]             ...future.startTime <- base::Sys.time()
[01:28:22.423]             {
[01:28:22.423]                 {
[01:28:22.423]                   {
[01:28:22.423]                     base::local({
[01:28:22.423]                       has_future <- base::requireNamespace("future", 
[01:28:22.423]                         quietly = TRUE)
[01:28:22.423]                       if (has_future) {
[01:28:22.423]                         ns <- base::getNamespace("future")
[01:28:22.423]                         version <- ns[[".package"]][["version"]]
[01:28:22.423]                         if (is.null(version)) 
[01:28:22.423]                           version <- utils::packageVersion("future")
[01:28:22.423]                       }
[01:28:22.423]                       else {
[01:28:22.423]                         version <- NULL
[01:28:22.423]                       }
[01:28:22.423]                       if (!has_future || version < "1.8.0") {
[01:28:22.423]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:22.423]                           "", base::R.version$version.string), 
[01:28:22.423]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:22.423]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:22.423]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:22.423]                             "release", "version")], collapse = " "), 
[01:28:22.423]                           hostname = base::Sys.info()[["nodename"]])
[01:28:22.423]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:22.423]                           info)
[01:28:22.423]                         info <- base::paste(info, collapse = "; ")
[01:28:22.423]                         if (!has_future) {
[01:28:22.423]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:22.423]                             info)
[01:28:22.423]                         }
[01:28:22.423]                         else {
[01:28:22.423]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:22.423]                             info, version)
[01:28:22.423]                         }
[01:28:22.423]                         base::stop(msg)
[01:28:22.423]                       }
[01:28:22.423]                     })
[01:28:22.423]                   }
[01:28:22.423]                   options(future.plan = NULL)
[01:28:22.423]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:22.423]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:22.423]                 }
[01:28:22.423]                 ...future.workdir <- getwd()
[01:28:22.423]             }
[01:28:22.423]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:22.423]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:22.423]         }
[01:28:22.423]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:22.423]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:22.423]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:22.423]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:22.423]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:22.423]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:22.423]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:22.423]             base::names(...future.oldOptions))
[01:28:22.423]     }
[01:28:22.423]     if (FALSE) {
[01:28:22.423]     }
[01:28:22.423]     else {
[01:28:22.423]         if (TRUE) {
[01:28:22.423]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:22.423]                 open = "w")
[01:28:22.423]         }
[01:28:22.423]         else {
[01:28:22.423]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:22.423]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:22.423]         }
[01:28:22.423]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:22.423]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:22.423]             base::sink(type = "output", split = FALSE)
[01:28:22.423]             base::close(...future.stdout)
[01:28:22.423]         }, add = TRUE)
[01:28:22.423]     }
[01:28:22.423]     ...future.frame <- base::sys.nframe()
[01:28:22.423]     ...future.conditions <- base::list()
[01:28:22.423]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:22.423]     if (FALSE) {
[01:28:22.423]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:22.423]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:22.423]     }
[01:28:22.423]     ...future.result <- base::tryCatch({
[01:28:22.423]         base::withCallingHandlers({
[01:28:22.423]             ...future.value <- base::withVisible(base::local({
[01:28:22.423]                 stop(structure(list(message = "boom"), class = c("MyError", 
[01:28:22.423]                   "error", "condition")))
[01:28:22.423]             }))
[01:28:22.423]             future::FutureResult(value = ...future.value$value, 
[01:28:22.423]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:22.423]                   ...future.rng), globalenv = if (FALSE) 
[01:28:22.423]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:22.423]                     ...future.globalenv.names))
[01:28:22.423]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:22.423]         }, condition = base::local({
[01:28:22.423]             c <- base::c
[01:28:22.423]             inherits <- base::inherits
[01:28:22.423]             invokeRestart <- base::invokeRestart
[01:28:22.423]             length <- base::length
[01:28:22.423]             list <- base::list
[01:28:22.423]             seq.int <- base::seq.int
[01:28:22.423]             signalCondition <- base::signalCondition
[01:28:22.423]             sys.calls <- base::sys.calls
[01:28:22.423]             `[[` <- base::`[[`
[01:28:22.423]             `+` <- base::`+`
[01:28:22.423]             `<<-` <- base::`<<-`
[01:28:22.423]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:22.423]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:22.423]                   3L)]
[01:28:22.423]             }
[01:28:22.423]             function(cond) {
[01:28:22.423]                 is_error <- inherits(cond, "error")
[01:28:22.423]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:22.423]                   NULL)
[01:28:22.423]                 if (is_error) {
[01:28:22.423]                   sessionInformation <- function() {
[01:28:22.423]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:22.423]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:22.423]                       search = base::search(), system = base::Sys.info())
[01:28:22.423]                   }
[01:28:22.423]                   ...future.conditions[[length(...future.conditions) + 
[01:28:22.423]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:22.423]                     cond$call), session = sessionInformation(), 
[01:28:22.423]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:22.423]                   signalCondition(cond)
[01:28:22.423]                 }
[01:28:22.423]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:22.423]                 "immediateCondition"))) {
[01:28:22.423]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:22.423]                   ...future.conditions[[length(...future.conditions) + 
[01:28:22.423]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:22.423]                   if (TRUE && !signal) {
[01:28:22.423]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:22.423]                     {
[01:28:22.423]                       inherits <- base::inherits
[01:28:22.423]                       invokeRestart <- base::invokeRestart
[01:28:22.423]                       is.null <- base::is.null
[01:28:22.423]                       muffled <- FALSE
[01:28:22.423]                       if (inherits(cond, "message")) {
[01:28:22.423]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:22.423]                         if (muffled) 
[01:28:22.423]                           invokeRestart("muffleMessage")
[01:28:22.423]                       }
[01:28:22.423]                       else if (inherits(cond, "warning")) {
[01:28:22.423]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:22.423]                         if (muffled) 
[01:28:22.423]                           invokeRestart("muffleWarning")
[01:28:22.423]                       }
[01:28:22.423]                       else if (inherits(cond, "condition")) {
[01:28:22.423]                         if (!is.null(pattern)) {
[01:28:22.423]                           computeRestarts <- base::computeRestarts
[01:28:22.423]                           grepl <- base::grepl
[01:28:22.423]                           restarts <- computeRestarts(cond)
[01:28:22.423]                           for (restart in restarts) {
[01:28:22.423]                             name <- restart$name
[01:28:22.423]                             if (is.null(name)) 
[01:28:22.423]                               next
[01:28:22.423]                             if (!grepl(pattern, name)) 
[01:28:22.423]                               next
[01:28:22.423]                             invokeRestart(restart)
[01:28:22.423]                             muffled <- TRUE
[01:28:22.423]                             break
[01:28:22.423]                           }
[01:28:22.423]                         }
[01:28:22.423]                       }
[01:28:22.423]                       invisible(muffled)
[01:28:22.423]                     }
[01:28:22.423]                     muffleCondition(cond, pattern = "^muffle")
[01:28:22.423]                   }
[01:28:22.423]                 }
[01:28:22.423]                 else {
[01:28:22.423]                   if (TRUE) {
[01:28:22.423]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:22.423]                     {
[01:28:22.423]                       inherits <- base::inherits
[01:28:22.423]                       invokeRestart <- base::invokeRestart
[01:28:22.423]                       is.null <- base::is.null
[01:28:22.423]                       muffled <- FALSE
[01:28:22.423]                       if (inherits(cond, "message")) {
[01:28:22.423]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:22.423]                         if (muffled) 
[01:28:22.423]                           invokeRestart("muffleMessage")
[01:28:22.423]                       }
[01:28:22.423]                       else if (inherits(cond, "warning")) {
[01:28:22.423]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:22.423]                         if (muffled) 
[01:28:22.423]                           invokeRestart("muffleWarning")
[01:28:22.423]                       }
[01:28:22.423]                       else if (inherits(cond, "condition")) {
[01:28:22.423]                         if (!is.null(pattern)) {
[01:28:22.423]                           computeRestarts <- base::computeRestarts
[01:28:22.423]                           grepl <- base::grepl
[01:28:22.423]                           restarts <- computeRestarts(cond)
[01:28:22.423]                           for (restart in restarts) {
[01:28:22.423]                             name <- restart$name
[01:28:22.423]                             if (is.null(name)) 
[01:28:22.423]                               next
[01:28:22.423]                             if (!grepl(pattern, name)) 
[01:28:22.423]                               next
[01:28:22.423]                             invokeRestart(restart)
[01:28:22.423]                             muffled <- TRUE
[01:28:22.423]                             break
[01:28:22.423]                           }
[01:28:22.423]                         }
[01:28:22.423]                       }
[01:28:22.423]                       invisible(muffled)
[01:28:22.423]                     }
[01:28:22.423]                     muffleCondition(cond, pattern = "^muffle")
[01:28:22.423]                   }
[01:28:22.423]                 }
[01:28:22.423]             }
[01:28:22.423]         }))
[01:28:22.423]     }, error = function(ex) {
[01:28:22.423]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:22.423]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:22.423]                 ...future.rng), started = ...future.startTime, 
[01:28:22.423]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:22.423]             version = "1.8"), class = "FutureResult")
[01:28:22.423]     }, finally = {
[01:28:22.423]         if (!identical(...future.workdir, getwd())) 
[01:28:22.423]             setwd(...future.workdir)
[01:28:22.423]         {
[01:28:22.423]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:22.423]                 ...future.oldOptions$nwarnings <- NULL
[01:28:22.423]             }
[01:28:22.423]             base::options(...future.oldOptions)
[01:28:22.423]             if (.Platform$OS.type == "windows") {
[01:28:22.423]                 old_names <- names(...future.oldEnvVars)
[01:28:22.423]                 envs <- base::Sys.getenv()
[01:28:22.423]                 names <- names(envs)
[01:28:22.423]                 common <- intersect(names, old_names)
[01:28:22.423]                 added <- setdiff(names, old_names)
[01:28:22.423]                 removed <- setdiff(old_names, names)
[01:28:22.423]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:22.423]                   envs[common]]
[01:28:22.423]                 NAMES <- toupper(changed)
[01:28:22.423]                 args <- list()
[01:28:22.423]                 for (kk in seq_along(NAMES)) {
[01:28:22.423]                   name <- changed[[kk]]
[01:28:22.423]                   NAME <- NAMES[[kk]]
[01:28:22.423]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:22.423]                     next
[01:28:22.423]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:22.423]                 }
[01:28:22.423]                 NAMES <- toupper(added)
[01:28:22.423]                 for (kk in seq_along(NAMES)) {
[01:28:22.423]                   name <- added[[kk]]
[01:28:22.423]                   NAME <- NAMES[[kk]]
[01:28:22.423]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:22.423]                     next
[01:28:22.423]                   args[[name]] <- ""
[01:28:22.423]                 }
[01:28:22.423]                 NAMES <- toupper(removed)
[01:28:22.423]                 for (kk in seq_along(NAMES)) {
[01:28:22.423]                   name <- removed[[kk]]
[01:28:22.423]                   NAME <- NAMES[[kk]]
[01:28:22.423]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:22.423]                     next
[01:28:22.423]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:22.423]                 }
[01:28:22.423]                 if (length(args) > 0) 
[01:28:22.423]                   base::do.call(base::Sys.setenv, args = args)
[01:28:22.423]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:22.423]             }
[01:28:22.423]             else {
[01:28:22.423]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:22.423]             }
[01:28:22.423]             {
[01:28:22.423]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:22.423]                   0L) {
[01:28:22.423]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:22.423]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:22.423]                   base::options(opts)
[01:28:22.423]                 }
[01:28:22.423]                 {
[01:28:22.423]                   {
[01:28:22.423]                     NULL
[01:28:22.423]                     RNGkind("Mersenne-Twister")
[01:28:22.423]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:22.423]                       inherits = FALSE)
[01:28:22.423]                   }
[01:28:22.423]                   options(future.plan = NULL)
[01:28:22.423]                   if (is.na(NA_character_)) 
[01:28:22.423]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:22.423]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:22.423]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:22.423]                   {
[01:28:22.423]                     future <- SequentialFuture(..., envir = envir)
[01:28:22.423]                     if (!future$lazy) 
[01:28:22.423]                       future <- run(future)
[01:28:22.423]                     invisible(future)
[01:28:22.423]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:22.423]                 }
[01:28:22.423]             }
[01:28:22.423]         }
[01:28:22.423]     })
[01:28:22.423]     if (TRUE) {
[01:28:22.423]         base::sink(type = "output", split = FALSE)
[01:28:22.423]         if (TRUE) {
[01:28:22.423]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:22.423]         }
[01:28:22.423]         else {
[01:28:22.423]             ...future.result["stdout"] <- base::list(NULL)
[01:28:22.423]         }
[01:28:22.423]         base::close(...future.stdout)
[01:28:22.423]         ...future.stdout <- NULL
[01:28:22.423]     }
[01:28:22.423]     ...future.result$conditions <- ...future.conditions
[01:28:22.423]     ...future.result$finished <- base::Sys.time()
[01:28:22.423]     ...future.result
[01:28:22.423] }
[01:28:22.427] plan(): Setting new future strategy stack:
[01:28:22.427] List of future strategies:
[01:28:22.427] 1. sequential:
[01:28:22.427]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:22.427]    - tweaked: FALSE
[01:28:22.427]    - call: NULL
[01:28:22.429] plan(): nbrOfWorkers() = 1
[01:28:22.430] plan(): Setting new future strategy stack:
[01:28:22.431] List of future strategies:
[01:28:22.431] 1. sequential:
[01:28:22.431]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:22.431]    - tweaked: FALSE
[01:28:22.431]    - call: future::plan("sequential")
[01:28:22.431] plan(): nbrOfWorkers() = 1
[01:28:22.432] SequentialFuture started (and completed)
[01:28:22.432] signalConditions() ...
[01:28:22.432]  - include = 'immediateCondition'
[01:28:22.432]  - exclude = 
[01:28:22.432]  - resignal = FALSE
[01:28:22.432]  - Number of conditions: 1
[01:28:22.433] signalConditions() ... done
[01:28:22.433] signalConditions() ...
[01:28:22.433]  - include = 'immediateCondition'
[01:28:22.433]  - exclude = 
[01:28:22.433]  - resignal = FALSE
[01:28:22.433]  - Number of conditions: 1
[01:28:22.434] signalConditions() ... done
<MyError: boom>
[01:28:22.434] signalConditions() ...
[01:28:22.434]  - include = 'immediateCondition'
[01:28:22.434]  - exclude = 
[01:28:22.434]  - resignal = FALSE
[01:28:22.435]  - Number of conditions: 1
[01:28:22.435] signalConditions() ... done
[01:28:22.435] Future state: 'finished'
[01:28:22.435] signalConditions() ...
[01:28:22.435]  - include = 'condition'
[01:28:22.435]  - exclude = 'immediateCondition'
[01:28:22.436]  - resignal = TRUE
[01:28:22.436]  - Number of conditions: 1
[01:28:22.436]  - Condition #1: 'MyError', 'error', 'condition'
[01:28:22.436] signalConditions() ... done
Testing with 1 cores ... DONE
Testing with 2 cores ...
[01:28:22.441] getGlobalsAndPackages() ...
[01:28:22.441] 
[01:28:22.441] - globals: [0] <none>
[01:28:22.441] getGlobalsAndPackages() ... DONE
[01:28:22.442] [local output] makeClusterPSOCK() ...
[01:28:22.537] [local output] Workers: [n = 2] 'localhost', 'localhost'
[01:28:22.543] [local output] Base port: 27027
[01:28:22.544] [local output] Getting setup options for 2 cluster nodes ...
[01:28:22.544] [local output]  - Node 1 of 2 ...
[01:28:22.545] [local output] localMachine=TRUE => revtunnel=FALSE

[01:28:22.546] Testing if worker's PID can be inferred: '"D:/RCompile/recent/R/bin/x64/Rscript" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpSkOF3d/worker.rank=1.parallelly.parent=13328.3410765f59da.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/RtmpSkOF3d/worker.rank=1.parallelly.parent=13328.3410765f59da.pid\")"'
[01:28:22.981] - Possible to infer worker's PID: TRUE
[01:28:22.982] [local output] Rscript port: 27027

[01:28:22.982] [local output]  - Node 2 of 2 ...
[01:28:22.983] [local output] localMachine=TRUE => revtunnel=FALSE

[01:28:22.984] [local output] Rscript port: 27027

[01:28:22.985] [local output] Getting setup options for 2 cluster nodes ... done
[01:28:22.985] [local output]  - Parallel setup requested for some PSOCK nodes
[01:28:22.986] [local output] Setting up PSOCK nodes in parallel
[01:28:22.986] List of 36
[01:28:22.986]  $ worker          : chr "localhost"
[01:28:22.986]   ..- attr(*, "localhost")= logi TRUE
[01:28:22.986]  $ master          : chr "localhost"
[01:28:22.986]  $ port            : int 27027
[01:28:22.986]  $ connectTimeout  : num 120
[01:28:22.986]  $ timeout         : num 120
[01:28:22.986]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[01:28:22.986]  $ homogeneous     : logi TRUE
[01:28:22.986]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=multisession.R:13328:CRANWIN3:CR"| __truncated__
[01:28:22.986]  $ rscript_envs    : NULL
[01:28:22.986]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47" "D:/RCompile/recent/R/library"
[01:28:22.986]  $ rscript_startup : NULL
[01:28:22.986]  $ rscript_sh      : chr "cmd"
[01:28:22.986]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[01:28:22.986]  $ methods         : logi TRUE
[01:28:22.986]  $ socketOptions   : chr "no-delay"
[01:28:22.986]  $ useXDR          : logi FALSE
[01:28:22.986]  $ outfile         : chr "/dev/null"
[01:28:22.986]  $ renice          : int NA
[01:28:22.986]  $ rshcmd          : NULL
[01:28:22.986]  $ user            : chr(0) 
[01:28:22.986]  $ revtunnel       : logi FALSE
[01:28:22.986]  $ rshlogfile      : NULL
[01:28:22.986]  $ rshopts         : chr(0) 
[01:28:22.986]  $ rank            : int 1
[01:28:22.986]  $ manual          : logi FALSE
[01:28:22.986]  $ dryrun          : logi FALSE
[01:28:22.986]  $ quiet           : logi FALSE
[01:28:22.986]  $ setup_strategy  : chr "parallel"
[01:28:22.986]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[01:28:22.986]  $ pidfile         : chr "D:/temp/RtmpSkOF3d/worker.rank=1.parallelly.parent=13328.3410765f59da.pid"
[01:28:22.986]  $ rshcmd_label    : NULL
[01:28:22.986]  $ rsh_call        : NULL
[01:28:22.986]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[01:28:22.986]  $ localMachine    : logi TRUE
[01:28:22.986]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[01:28:22.986]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[01:28:22.986]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[01:28:22.986]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[01:28:22.986]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[01:28:22.986]         "cmd", "sh"), default_packages = c("datasets", "utils", "grDevices", 
[01:28:22.986]         "graphics", "stats", if (methods) "methods"), methods = TRUE, socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[01:28:22.986]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[01:28:22.986]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[01:28:22.986]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[01:28:22.986]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[01:28:22.986]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[01:28:22.986]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[01:28:22.986]  $ arguments       :List of 28
[01:28:22.986]   ..$ worker          : chr "localhost"
[01:28:22.986]   ..$ master          : NULL
[01:28:22.986]   ..$ port            : int 27027
[01:28:22.986]   ..$ connectTimeout  : num 120
[01:28:22.986]   ..$ timeout         : num 120
[01:28:22.986]   ..$ rscript         : NULL
[01:28:22.986]   ..$ homogeneous     : NULL
[01:28:22.986]   ..$ rscript_args    : NULL
[01:28:22.986]   ..$ rscript_envs    : NULL
[01:28:22.986]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47" "D:/RCompile/recent/R/library"
[01:28:22.986]   ..$ rscript_startup : NULL
[01:28:22.986]   ..$ rscript_sh      : chr [1:3] "auto" "cmd" "sh"
[01:28:22.986]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[01:28:22.986]   ..$ methods         : logi TRUE
[01:28:22.986]   ..$ socketOptions   : chr "no-delay"
[01:28:22.986]   ..$ useXDR          : logi FALSE
[01:28:22.986]   ..$ outfile         : chr "/dev/null"
[01:28:22.986]   ..$ renice          : int NA
[01:28:22.986]   ..$ rshcmd          : NULL
[01:28:22.986]   ..$ user            : NULL
[01:28:22.986]   ..$ revtunnel       : logi NA
[01:28:22.986]   ..$ rshlogfile      : NULL
[01:28:22.986]   ..$ rshopts         : NULL
[01:28:22.986]   ..$ rank            : int 1
[01:28:22.986]   ..$ manual          : logi FALSE
[01:28:22.986]   ..$ dryrun          : logi FALSE
[01:28:22.986]   ..$ quiet           : logi FALSE
[01:28:22.986]   ..$ setup_strategy  : chr "parallel"
[01:28:22.986]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[01:28:23.008] [local output] System call to launch all workers:
[01:28:23.008] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=multisession.R:13328:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpSkOF3d/worker.rank=1.parallelly.parent=13328.3410765f59da.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=27027 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[01:28:23.008] [local output] Starting PSOCK main server
[01:28:23.014] [local output] Workers launched
[01:28:23.015] [local output] Waiting for workers to connect back
[01:28:23.015]  - [local output] 0 workers out of 2 ready
[01:28:23.194]  - [local output] 0 workers out of 2 ready
[01:28:23.194]  - [local output] 1 workers out of 2 ready
[01:28:23.198]  - [local output] 1 workers out of 2 ready
[01:28:23.198]  - [local output] 2 workers out of 2 ready
[01:28:23.199] [local output] Launching of workers completed
[01:28:23.199] [local output] Collecting session information from workers
[01:28:23.200] [local output]  - Worker #1 of 2
[01:28:23.201] [local output]  - Worker #2 of 2
[01:28:23.201] [local output] makeClusterPSOCK() ... done
[01:28:23.214] Packages needed by the future expression (n = 0): <none>
[01:28:23.215] Packages needed by future strategies (n = 0): <none>
[01:28:23.215] {
[01:28:23.215]     {
[01:28:23.215]         {
[01:28:23.215]             ...future.startTime <- base::Sys.time()
[01:28:23.215]             {
[01:28:23.215]                 {
[01:28:23.215]                   {
[01:28:23.215]                     {
[01:28:23.215]                       base::local({
[01:28:23.215]                         has_future <- base::requireNamespace("future", 
[01:28:23.215]                           quietly = TRUE)
[01:28:23.215]                         if (has_future) {
[01:28:23.215]                           ns <- base::getNamespace("future")
[01:28:23.215]                           version <- ns[[".package"]][["version"]]
[01:28:23.215]                           if (is.null(version)) 
[01:28:23.215]                             version <- utils::packageVersion("future")
[01:28:23.215]                         }
[01:28:23.215]                         else {
[01:28:23.215]                           version <- NULL
[01:28:23.215]                         }
[01:28:23.215]                         if (!has_future || version < "1.8.0") {
[01:28:23.215]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:23.215]                             "", base::R.version$version.string), 
[01:28:23.215]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:23.215]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:23.215]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:23.215]                               "release", "version")], collapse = " "), 
[01:28:23.215]                             hostname = base::Sys.info()[["nodename"]])
[01:28:23.215]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:23.215]                             info)
[01:28:23.215]                           info <- base::paste(info, collapse = "; ")
[01:28:23.215]                           if (!has_future) {
[01:28:23.215]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:23.215]                               info)
[01:28:23.215]                           }
[01:28:23.215]                           else {
[01:28:23.215]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:23.215]                               info, version)
[01:28:23.215]                           }
[01:28:23.215]                           base::stop(msg)
[01:28:23.215]                         }
[01:28:23.215]                       })
[01:28:23.215]                     }
[01:28:23.215]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:23.215]                     base::options(mc.cores = 1L)
[01:28:23.215]                   }
[01:28:23.215]                   options(future.plan = NULL)
[01:28:23.215]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:23.215]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:23.215]                 }
[01:28:23.215]                 ...future.workdir <- getwd()
[01:28:23.215]             }
[01:28:23.215]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:23.215]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:23.215]         }
[01:28:23.215]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:23.215]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:23.215]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:23.215]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:23.215]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:23.215]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:23.215]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:23.215]             base::names(...future.oldOptions))
[01:28:23.215]     }
[01:28:23.215]     if (FALSE) {
[01:28:23.215]     }
[01:28:23.215]     else {
[01:28:23.215]         if (TRUE) {
[01:28:23.215]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:23.215]                 open = "w")
[01:28:23.215]         }
[01:28:23.215]         else {
[01:28:23.215]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:23.215]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:23.215]         }
[01:28:23.215]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:23.215]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:23.215]             base::sink(type = "output", split = FALSE)
[01:28:23.215]             base::close(...future.stdout)
[01:28:23.215]         }, add = TRUE)
[01:28:23.215]     }
[01:28:23.215]     ...future.frame <- base::sys.nframe()
[01:28:23.215]     ...future.conditions <- base::list()
[01:28:23.215]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:23.215]     if (FALSE) {
[01:28:23.215]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:23.215]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:23.215]     }
[01:28:23.215]     ...future.result <- base::tryCatch({
[01:28:23.215]         base::withCallingHandlers({
[01:28:23.215]             ...future.value <- base::withVisible(base::local({
[01:28:23.215]                 ...future.makeSendCondition <- base::local({
[01:28:23.215]                   sendCondition <- NULL
[01:28:23.215]                   function(frame = 1L) {
[01:28:23.215]                     if (is.function(sendCondition)) 
[01:28:23.215]                       return(sendCondition)
[01:28:23.215]                     ns <- getNamespace("parallel")
[01:28:23.215]                     if (exists("sendData", mode = "function", 
[01:28:23.215]                       envir = ns)) {
[01:28:23.215]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:23.215]                         envir = ns)
[01:28:23.215]                       envir <- sys.frame(frame)
[01:28:23.215]                       master <- NULL
[01:28:23.215]                       while (!identical(envir, .GlobalEnv) && 
[01:28:23.215]                         !identical(envir, emptyenv())) {
[01:28:23.215]                         if (exists("master", mode = "list", envir = envir, 
[01:28:23.215]                           inherits = FALSE)) {
[01:28:23.215]                           master <- get("master", mode = "list", 
[01:28:23.215]                             envir = envir, inherits = FALSE)
[01:28:23.215]                           if (inherits(master, c("SOCKnode", 
[01:28:23.215]                             "SOCK0node"))) {
[01:28:23.215]                             sendCondition <<- function(cond) {
[01:28:23.215]                               data <- list(type = "VALUE", value = cond, 
[01:28:23.215]                                 success = TRUE)
[01:28:23.215]                               parallel_sendData(master, data)
[01:28:23.215]                             }
[01:28:23.215]                             return(sendCondition)
[01:28:23.215]                           }
[01:28:23.215]                         }
[01:28:23.215]                         frame <- frame + 1L
[01:28:23.215]                         envir <- sys.frame(frame)
[01:28:23.215]                       }
[01:28:23.215]                     }
[01:28:23.215]                     sendCondition <<- function(cond) NULL
[01:28:23.215]                   }
[01:28:23.215]                 })
[01:28:23.215]                 withCallingHandlers({
[01:28:23.215]                   {
[01:28:23.215]                     42L
[01:28:23.215]                   }
[01:28:23.215]                 }, immediateCondition = function(cond) {
[01:28:23.215]                   sendCondition <- ...future.makeSendCondition()
[01:28:23.215]                   sendCondition(cond)
[01:28:23.215]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:23.215]                   {
[01:28:23.215]                     inherits <- base::inherits
[01:28:23.215]                     invokeRestart <- base::invokeRestart
[01:28:23.215]                     is.null <- base::is.null
[01:28:23.215]                     muffled <- FALSE
[01:28:23.215]                     if (inherits(cond, "message")) {
[01:28:23.215]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:23.215]                       if (muffled) 
[01:28:23.215]                         invokeRestart("muffleMessage")
[01:28:23.215]                     }
[01:28:23.215]                     else if (inherits(cond, "warning")) {
[01:28:23.215]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:23.215]                       if (muffled) 
[01:28:23.215]                         invokeRestart("muffleWarning")
[01:28:23.215]                     }
[01:28:23.215]                     else if (inherits(cond, "condition")) {
[01:28:23.215]                       if (!is.null(pattern)) {
[01:28:23.215]                         computeRestarts <- base::computeRestarts
[01:28:23.215]                         grepl <- base::grepl
[01:28:23.215]                         restarts <- computeRestarts(cond)
[01:28:23.215]                         for (restart in restarts) {
[01:28:23.215]                           name <- restart$name
[01:28:23.215]                           if (is.null(name)) 
[01:28:23.215]                             next
[01:28:23.215]                           if (!grepl(pattern, name)) 
[01:28:23.215]                             next
[01:28:23.215]                           invokeRestart(restart)
[01:28:23.215]                           muffled <- TRUE
[01:28:23.215]                           break
[01:28:23.215]                         }
[01:28:23.215]                       }
[01:28:23.215]                     }
[01:28:23.215]                     invisible(muffled)
[01:28:23.215]                   }
[01:28:23.215]                   muffleCondition(cond)
[01:28:23.215]                 })
[01:28:23.215]             }))
[01:28:23.215]             future::FutureResult(value = ...future.value$value, 
[01:28:23.215]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:23.215]                   ...future.rng), globalenv = if (FALSE) 
[01:28:23.215]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:23.215]                     ...future.globalenv.names))
[01:28:23.215]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:23.215]         }, condition = base::local({
[01:28:23.215]             c <- base::c
[01:28:23.215]             inherits <- base::inherits
[01:28:23.215]             invokeRestart <- base::invokeRestart
[01:28:23.215]             length <- base::length
[01:28:23.215]             list <- base::list
[01:28:23.215]             seq.int <- base::seq.int
[01:28:23.215]             signalCondition <- base::signalCondition
[01:28:23.215]             sys.calls <- base::sys.calls
[01:28:23.215]             `[[` <- base::`[[`
[01:28:23.215]             `+` <- base::`+`
[01:28:23.215]             `<<-` <- base::`<<-`
[01:28:23.215]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:23.215]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:23.215]                   3L)]
[01:28:23.215]             }
[01:28:23.215]             function(cond) {
[01:28:23.215]                 is_error <- inherits(cond, "error")
[01:28:23.215]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:23.215]                   NULL)
[01:28:23.215]                 if (is_error) {
[01:28:23.215]                   sessionInformation <- function() {
[01:28:23.215]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:23.215]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:23.215]                       search = base::search(), system = base::Sys.info())
[01:28:23.215]                   }
[01:28:23.215]                   ...future.conditions[[length(...future.conditions) + 
[01:28:23.215]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:23.215]                     cond$call), session = sessionInformation(), 
[01:28:23.215]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:23.215]                   signalCondition(cond)
[01:28:23.215]                 }
[01:28:23.215]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:23.215]                 "immediateCondition"))) {
[01:28:23.215]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:23.215]                   ...future.conditions[[length(...future.conditions) + 
[01:28:23.215]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:23.215]                   if (TRUE && !signal) {
[01:28:23.215]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:23.215]                     {
[01:28:23.215]                       inherits <- base::inherits
[01:28:23.215]                       invokeRestart <- base::invokeRestart
[01:28:23.215]                       is.null <- base::is.null
[01:28:23.215]                       muffled <- FALSE
[01:28:23.215]                       if (inherits(cond, "message")) {
[01:28:23.215]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:23.215]                         if (muffled) 
[01:28:23.215]                           invokeRestart("muffleMessage")
[01:28:23.215]                       }
[01:28:23.215]                       else if (inherits(cond, "warning")) {
[01:28:23.215]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:23.215]                         if (muffled) 
[01:28:23.215]                           invokeRestart("muffleWarning")
[01:28:23.215]                       }
[01:28:23.215]                       else if (inherits(cond, "condition")) {
[01:28:23.215]                         if (!is.null(pattern)) {
[01:28:23.215]                           computeRestarts <- base::computeRestarts
[01:28:23.215]                           grepl <- base::grepl
[01:28:23.215]                           restarts <- computeRestarts(cond)
[01:28:23.215]                           for (restart in restarts) {
[01:28:23.215]                             name <- restart$name
[01:28:23.215]                             if (is.null(name)) 
[01:28:23.215]                               next
[01:28:23.215]                             if (!grepl(pattern, name)) 
[01:28:23.215]                               next
[01:28:23.215]                             invokeRestart(restart)
[01:28:23.215]                             muffled <- TRUE
[01:28:23.215]                             break
[01:28:23.215]                           }
[01:28:23.215]                         }
[01:28:23.215]                       }
[01:28:23.215]                       invisible(muffled)
[01:28:23.215]                     }
[01:28:23.215]                     muffleCondition(cond, pattern = "^muffle")
[01:28:23.215]                   }
[01:28:23.215]                 }
[01:28:23.215]                 else {
[01:28:23.215]                   if (TRUE) {
[01:28:23.215]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:23.215]                     {
[01:28:23.215]                       inherits <- base::inherits
[01:28:23.215]                       invokeRestart <- base::invokeRestart
[01:28:23.215]                       is.null <- base::is.null
[01:28:23.215]                       muffled <- FALSE
[01:28:23.215]                       if (inherits(cond, "message")) {
[01:28:23.215]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:23.215]                         if (muffled) 
[01:28:23.215]                           invokeRestart("muffleMessage")
[01:28:23.215]                       }
[01:28:23.215]                       else if (inherits(cond, "warning")) {
[01:28:23.215]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:23.215]                         if (muffled) 
[01:28:23.215]                           invokeRestart("muffleWarning")
[01:28:23.215]                       }
[01:28:23.215]                       else if (inherits(cond, "condition")) {
[01:28:23.215]                         if (!is.null(pattern)) {
[01:28:23.215]                           computeRestarts <- base::computeRestarts
[01:28:23.215]                           grepl <- base::grepl
[01:28:23.215]                           restarts <- computeRestarts(cond)
[01:28:23.215]                           for (restart in restarts) {
[01:28:23.215]                             name <- restart$name
[01:28:23.215]                             if (is.null(name)) 
[01:28:23.215]                               next
[01:28:23.215]                             if (!grepl(pattern, name)) 
[01:28:23.215]                               next
[01:28:23.215]                             invokeRestart(restart)
[01:28:23.215]                             muffled <- TRUE
[01:28:23.215]                             break
[01:28:23.215]                           }
[01:28:23.215]                         }
[01:28:23.215]                       }
[01:28:23.215]                       invisible(muffled)
[01:28:23.215]                     }
[01:28:23.215]                     muffleCondition(cond, pattern = "^muffle")
[01:28:23.215]                   }
[01:28:23.215]                 }
[01:28:23.215]             }
[01:28:23.215]         }))
[01:28:23.215]     }, error = function(ex) {
[01:28:23.215]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:23.215]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:23.215]                 ...future.rng), started = ...future.startTime, 
[01:28:23.215]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:23.215]             version = "1.8"), class = "FutureResult")
[01:28:23.215]     }, finally = {
[01:28:23.215]         if (!identical(...future.workdir, getwd())) 
[01:28:23.215]             setwd(...future.workdir)
[01:28:23.215]         {
[01:28:23.215]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:23.215]                 ...future.oldOptions$nwarnings <- NULL
[01:28:23.215]             }
[01:28:23.215]             base::options(...future.oldOptions)
[01:28:23.215]             if (.Platform$OS.type == "windows") {
[01:28:23.215]                 old_names <- names(...future.oldEnvVars)
[01:28:23.215]                 envs <- base::Sys.getenv()
[01:28:23.215]                 names <- names(envs)
[01:28:23.215]                 common <- intersect(names, old_names)
[01:28:23.215]                 added <- setdiff(names, old_names)
[01:28:23.215]                 removed <- setdiff(old_names, names)
[01:28:23.215]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:23.215]                   envs[common]]
[01:28:23.215]                 NAMES <- toupper(changed)
[01:28:23.215]                 args <- list()
[01:28:23.215]                 for (kk in seq_along(NAMES)) {
[01:28:23.215]                   name <- changed[[kk]]
[01:28:23.215]                   NAME <- NAMES[[kk]]
[01:28:23.215]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:23.215]                     next
[01:28:23.215]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:23.215]                 }
[01:28:23.215]                 NAMES <- toupper(added)
[01:28:23.215]                 for (kk in seq_along(NAMES)) {
[01:28:23.215]                   name <- added[[kk]]
[01:28:23.215]                   NAME <- NAMES[[kk]]
[01:28:23.215]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:23.215]                     next
[01:28:23.215]                   args[[name]] <- ""
[01:28:23.215]                 }
[01:28:23.215]                 NAMES <- toupper(removed)
[01:28:23.215]                 for (kk in seq_along(NAMES)) {
[01:28:23.215]                   name <- removed[[kk]]
[01:28:23.215]                   NAME <- NAMES[[kk]]
[01:28:23.215]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:23.215]                     next
[01:28:23.215]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:23.215]                 }
[01:28:23.215]                 if (length(args) > 0) 
[01:28:23.215]                   base::do.call(base::Sys.setenv, args = args)
[01:28:23.215]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:23.215]             }
[01:28:23.215]             else {
[01:28:23.215]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:23.215]             }
[01:28:23.215]             {
[01:28:23.215]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:23.215]                   0L) {
[01:28:23.215]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:23.215]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:23.215]                   base::options(opts)
[01:28:23.215]                 }
[01:28:23.215]                 {
[01:28:23.215]                   {
[01:28:23.215]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:23.215]                     NULL
[01:28:23.215]                   }
[01:28:23.215]                   options(future.plan = NULL)
[01:28:23.215]                   if (is.na(NA_character_)) 
[01:28:23.215]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:23.215]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:23.215]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:23.215]                   {
[01:28:23.215]                     future <- SequentialFuture(..., envir = envir)
[01:28:23.215]                     if (!future$lazy) 
[01:28:23.215]                       future <- run(future)
[01:28:23.215]                     invisible(future)
[01:28:23.215]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:23.215]                 }
[01:28:23.215]             }
[01:28:23.215]         }
[01:28:23.215]     })
[01:28:23.215]     if (TRUE) {
[01:28:23.215]         base::sink(type = "output", split = FALSE)
[01:28:23.215]         if (TRUE) {
[01:28:23.215]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:23.215]         }
[01:28:23.215]         else {
[01:28:23.215]             ...future.result["stdout"] <- base::list(NULL)
[01:28:23.215]         }
[01:28:23.215]         base::close(...future.stdout)
[01:28:23.215]         ...future.stdout <- NULL
[01:28:23.215]     }
[01:28:23.215]     ...future.result$conditions <- ...future.conditions
[01:28:23.215]     ...future.result$finished <- base::Sys.time()
[01:28:23.215]     ...future.result
[01:28:23.215] }
[01:28:23.301] 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)
[01:28:23.402] receiveMessageFromWorker() for ClusterFuture ...
[01:28:23.402] - Validating connection of MultisessionFuture
[01:28:23.403] - received message: FutureResult
[01:28:23.403] - Received FutureResult
[01:28:23.406] - Erased future from FutureRegistry
[01:28:23.407] result() for ClusterFuture ...
[01:28:23.407] - result already collected: FutureResult
[01:28:23.407] result() for ClusterFuture ... done
[01:28:23.407] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: cfeec5f2-987d-97c4-cbb0-b2e17579921c
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[1] TRUE
[01:28:23.408] result() for ClusterFuture ...
[01:28:23.408] - result already collected: FutureResult
[01:28:23.408] result() for ClusterFuture ... done
[01:28:23.408] result() for ClusterFuture ...
[01:28:23.408] - result already collected: FutureResult
[01:28:23.409] result() for ClusterFuture ... done
[1] 42
[01:28:23.411] getGlobalsAndPackages() ...
[01:28:23.411] Searching for globals...
[01:28:23.414] - globals found: [4] '{', '<-', '*', 'a'
[01:28:23.414] Searching for globals ... DONE
[01:28:23.415] Resolving globals: FALSE
[01:28:23.415] The total size of the 1 globals is 56 bytes (56 bytes)
[01:28:23.416] The total size of the 1 globals exported for future expression ('{; b <- 3; c <- 2; a * b * c; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'a' (56 bytes of class 'numeric')
[01:28:23.416] - globals: [1] 'a'
[01:28:23.416] 
[01:28:23.416] getGlobalsAndPackages() ... DONE
[01:28:23.429] Packages needed by the future expression (n = 0): <none>
[01:28:23.430] Packages needed by future strategies (n = 0): <none>
[01:28:23.430] {
[01:28:23.430]     {
[01:28:23.430]         {
[01:28:23.430]             ...future.startTime <- base::Sys.time()
[01:28:23.430]             {
[01:28:23.430]                 {
[01:28:23.430]                   {
[01:28:23.430]                     {
[01:28:23.430]                       base::local({
[01:28:23.430]                         has_future <- base::requireNamespace("future", 
[01:28:23.430]                           quietly = TRUE)
[01:28:23.430]                         if (has_future) {
[01:28:23.430]                           ns <- base::getNamespace("future")
[01:28:23.430]                           version <- ns[[".package"]][["version"]]
[01:28:23.430]                           if (is.null(version)) 
[01:28:23.430]                             version <- utils::packageVersion("future")
[01:28:23.430]                         }
[01:28:23.430]                         else {
[01:28:23.430]                           version <- NULL
[01:28:23.430]                         }
[01:28:23.430]                         if (!has_future || version < "1.8.0") {
[01:28:23.430]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:23.430]                             "", base::R.version$version.string), 
[01:28:23.430]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:23.430]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:23.430]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:23.430]                               "release", "version")], collapse = " "), 
[01:28:23.430]                             hostname = base::Sys.info()[["nodename"]])
[01:28:23.430]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:23.430]                             info)
[01:28:23.430]                           info <- base::paste(info, collapse = "; ")
[01:28:23.430]                           if (!has_future) {
[01:28:23.430]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:23.430]                               info)
[01:28:23.430]                           }
[01:28:23.430]                           else {
[01:28:23.430]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:23.430]                               info, version)
[01:28:23.430]                           }
[01:28:23.430]                           base::stop(msg)
[01:28:23.430]                         }
[01:28:23.430]                       })
[01:28:23.430]                     }
[01:28:23.430]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:23.430]                     base::options(mc.cores = 1L)
[01:28:23.430]                   }
[01:28:23.430]                   options(future.plan = NULL)
[01:28:23.430]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:23.430]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:23.430]                 }
[01:28:23.430]                 ...future.workdir <- getwd()
[01:28:23.430]             }
[01:28:23.430]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:23.430]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:23.430]         }
[01:28:23.430]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:23.430]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:23.430]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:23.430]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:23.430]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:23.430]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:23.430]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:23.430]             base::names(...future.oldOptions))
[01:28:23.430]     }
[01:28:23.430]     if (FALSE) {
[01:28:23.430]     }
[01:28:23.430]     else {
[01:28:23.430]         if (TRUE) {
[01:28:23.430]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:23.430]                 open = "w")
[01:28:23.430]         }
[01:28:23.430]         else {
[01:28:23.430]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:23.430]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:23.430]         }
[01:28:23.430]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:23.430]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:23.430]             base::sink(type = "output", split = FALSE)
[01:28:23.430]             base::close(...future.stdout)
[01:28:23.430]         }, add = TRUE)
[01:28:23.430]     }
[01:28:23.430]     ...future.frame <- base::sys.nframe()
[01:28:23.430]     ...future.conditions <- base::list()
[01:28:23.430]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:23.430]     if (FALSE) {
[01:28:23.430]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:23.430]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:23.430]     }
[01:28:23.430]     ...future.result <- base::tryCatch({
[01:28:23.430]         base::withCallingHandlers({
[01:28:23.430]             ...future.value <- base::withVisible(base::local({
[01:28:23.430]                 ...future.makeSendCondition <- base::local({
[01:28:23.430]                   sendCondition <- NULL
[01:28:23.430]                   function(frame = 1L) {
[01:28:23.430]                     if (is.function(sendCondition)) 
[01:28:23.430]                       return(sendCondition)
[01:28:23.430]                     ns <- getNamespace("parallel")
[01:28:23.430]                     if (exists("sendData", mode = "function", 
[01:28:23.430]                       envir = ns)) {
[01:28:23.430]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:23.430]                         envir = ns)
[01:28:23.430]                       envir <- sys.frame(frame)
[01:28:23.430]                       master <- NULL
[01:28:23.430]                       while (!identical(envir, .GlobalEnv) && 
[01:28:23.430]                         !identical(envir, emptyenv())) {
[01:28:23.430]                         if (exists("master", mode = "list", envir = envir, 
[01:28:23.430]                           inherits = FALSE)) {
[01:28:23.430]                           master <- get("master", mode = "list", 
[01:28:23.430]                             envir = envir, inherits = FALSE)
[01:28:23.430]                           if (inherits(master, c("SOCKnode", 
[01:28:23.430]                             "SOCK0node"))) {
[01:28:23.430]                             sendCondition <<- function(cond) {
[01:28:23.430]                               data <- list(type = "VALUE", value = cond, 
[01:28:23.430]                                 success = TRUE)
[01:28:23.430]                               parallel_sendData(master, data)
[01:28:23.430]                             }
[01:28:23.430]                             return(sendCondition)
[01:28:23.430]                           }
[01:28:23.430]                         }
[01:28:23.430]                         frame <- frame + 1L
[01:28:23.430]                         envir <- sys.frame(frame)
[01:28:23.430]                       }
[01:28:23.430]                     }
[01:28:23.430]                     sendCondition <<- function(cond) NULL
[01:28:23.430]                   }
[01:28:23.430]                 })
[01:28:23.430]                 withCallingHandlers({
[01:28:23.430]                   {
[01:28:23.430]                     b <- 3
[01:28:23.430]                     c <- 2
[01:28:23.430]                     a * b * c
[01:28:23.430]                   }
[01:28:23.430]                 }, immediateCondition = function(cond) {
[01:28:23.430]                   sendCondition <- ...future.makeSendCondition()
[01:28:23.430]                   sendCondition(cond)
[01:28:23.430]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:23.430]                   {
[01:28:23.430]                     inherits <- base::inherits
[01:28:23.430]                     invokeRestart <- base::invokeRestart
[01:28:23.430]                     is.null <- base::is.null
[01:28:23.430]                     muffled <- FALSE
[01:28:23.430]                     if (inherits(cond, "message")) {
[01:28:23.430]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:23.430]                       if (muffled) 
[01:28:23.430]                         invokeRestart("muffleMessage")
[01:28:23.430]                     }
[01:28:23.430]                     else if (inherits(cond, "warning")) {
[01:28:23.430]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:23.430]                       if (muffled) 
[01:28:23.430]                         invokeRestart("muffleWarning")
[01:28:23.430]                     }
[01:28:23.430]                     else if (inherits(cond, "condition")) {
[01:28:23.430]                       if (!is.null(pattern)) {
[01:28:23.430]                         computeRestarts <- base::computeRestarts
[01:28:23.430]                         grepl <- base::grepl
[01:28:23.430]                         restarts <- computeRestarts(cond)
[01:28:23.430]                         for (restart in restarts) {
[01:28:23.430]                           name <- restart$name
[01:28:23.430]                           if (is.null(name)) 
[01:28:23.430]                             next
[01:28:23.430]                           if (!grepl(pattern, name)) 
[01:28:23.430]                             next
[01:28:23.430]                           invokeRestart(restart)
[01:28:23.430]                           muffled <- TRUE
[01:28:23.430]                           break
[01:28:23.430]                         }
[01:28:23.430]                       }
[01:28:23.430]                     }
[01:28:23.430]                     invisible(muffled)
[01:28:23.430]                   }
[01:28:23.430]                   muffleCondition(cond)
[01:28:23.430]                 })
[01:28:23.430]             }))
[01:28:23.430]             future::FutureResult(value = ...future.value$value, 
[01:28:23.430]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:23.430]                   ...future.rng), globalenv = if (FALSE) 
[01:28:23.430]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:23.430]                     ...future.globalenv.names))
[01:28:23.430]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:23.430]         }, condition = base::local({
[01:28:23.430]             c <- base::c
[01:28:23.430]             inherits <- base::inherits
[01:28:23.430]             invokeRestart <- base::invokeRestart
[01:28:23.430]             length <- base::length
[01:28:23.430]             list <- base::list
[01:28:23.430]             seq.int <- base::seq.int
[01:28:23.430]             signalCondition <- base::signalCondition
[01:28:23.430]             sys.calls <- base::sys.calls
[01:28:23.430]             `[[` <- base::`[[`
[01:28:23.430]             `+` <- base::`+`
[01:28:23.430]             `<<-` <- base::`<<-`
[01:28:23.430]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:23.430]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:23.430]                   3L)]
[01:28:23.430]             }
[01:28:23.430]             function(cond) {
[01:28:23.430]                 is_error <- inherits(cond, "error")
[01:28:23.430]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:23.430]                   NULL)
[01:28:23.430]                 if (is_error) {
[01:28:23.430]                   sessionInformation <- function() {
[01:28:23.430]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:23.430]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:23.430]                       search = base::search(), system = base::Sys.info())
[01:28:23.430]                   }
[01:28:23.430]                   ...future.conditions[[length(...future.conditions) + 
[01:28:23.430]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:23.430]                     cond$call), session = sessionInformation(), 
[01:28:23.430]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:23.430]                   signalCondition(cond)
[01:28:23.430]                 }
[01:28:23.430]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:23.430]                 "immediateCondition"))) {
[01:28:23.430]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:23.430]                   ...future.conditions[[length(...future.conditions) + 
[01:28:23.430]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:23.430]                   if (TRUE && !signal) {
[01:28:23.430]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:23.430]                     {
[01:28:23.430]                       inherits <- base::inherits
[01:28:23.430]                       invokeRestart <- base::invokeRestart
[01:28:23.430]                       is.null <- base::is.null
[01:28:23.430]                       muffled <- FALSE
[01:28:23.430]                       if (inherits(cond, "message")) {
[01:28:23.430]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:23.430]                         if (muffled) 
[01:28:23.430]                           invokeRestart("muffleMessage")
[01:28:23.430]                       }
[01:28:23.430]                       else if (inherits(cond, "warning")) {
[01:28:23.430]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:23.430]                         if (muffled) 
[01:28:23.430]                           invokeRestart("muffleWarning")
[01:28:23.430]                       }
[01:28:23.430]                       else if (inherits(cond, "condition")) {
[01:28:23.430]                         if (!is.null(pattern)) {
[01:28:23.430]                           computeRestarts <- base::computeRestarts
[01:28:23.430]                           grepl <- base::grepl
[01:28:23.430]                           restarts <- computeRestarts(cond)
[01:28:23.430]                           for (restart in restarts) {
[01:28:23.430]                             name <- restart$name
[01:28:23.430]                             if (is.null(name)) 
[01:28:23.430]                               next
[01:28:23.430]                             if (!grepl(pattern, name)) 
[01:28:23.430]                               next
[01:28:23.430]                             invokeRestart(restart)
[01:28:23.430]                             muffled <- TRUE
[01:28:23.430]                             break
[01:28:23.430]                           }
[01:28:23.430]                         }
[01:28:23.430]                       }
[01:28:23.430]                       invisible(muffled)
[01:28:23.430]                     }
[01:28:23.430]                     muffleCondition(cond, pattern = "^muffle")
[01:28:23.430]                   }
[01:28:23.430]                 }
[01:28:23.430]                 else {
[01:28:23.430]                   if (TRUE) {
[01:28:23.430]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:23.430]                     {
[01:28:23.430]                       inherits <- base::inherits
[01:28:23.430]                       invokeRestart <- base::invokeRestart
[01:28:23.430]                       is.null <- base::is.null
[01:28:23.430]                       muffled <- FALSE
[01:28:23.430]                       if (inherits(cond, "message")) {
[01:28:23.430]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:23.430]                         if (muffled) 
[01:28:23.430]                           invokeRestart("muffleMessage")
[01:28:23.430]                       }
[01:28:23.430]                       else if (inherits(cond, "warning")) {
[01:28:23.430]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:23.430]                         if (muffled) 
[01:28:23.430]                           invokeRestart("muffleWarning")
[01:28:23.430]                       }
[01:28:23.430]                       else if (inherits(cond, "condition")) {
[01:28:23.430]                         if (!is.null(pattern)) {
[01:28:23.430]                           computeRestarts <- base::computeRestarts
[01:28:23.430]                           grepl <- base::grepl
[01:28:23.430]                           restarts <- computeRestarts(cond)
[01:28:23.430]                           for (restart in restarts) {
[01:28:23.430]                             name <- restart$name
[01:28:23.430]                             if (is.null(name)) 
[01:28:23.430]                               next
[01:28:23.430]                             if (!grepl(pattern, name)) 
[01:28:23.430]                               next
[01:28:23.430]                             invokeRestart(restart)
[01:28:23.430]                             muffled <- TRUE
[01:28:23.430]                             break
[01:28:23.430]                           }
[01:28:23.430]                         }
[01:28:23.430]                       }
[01:28:23.430]                       invisible(muffled)
[01:28:23.430]                     }
[01:28:23.430]                     muffleCondition(cond, pattern = "^muffle")
[01:28:23.430]                   }
[01:28:23.430]                 }
[01:28:23.430]             }
[01:28:23.430]         }))
[01:28:23.430]     }, error = function(ex) {
[01:28:23.430]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:23.430]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:23.430]                 ...future.rng), started = ...future.startTime, 
[01:28:23.430]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:23.430]             version = "1.8"), class = "FutureResult")
[01:28:23.430]     }, finally = {
[01:28:23.430]         if (!identical(...future.workdir, getwd())) 
[01:28:23.430]             setwd(...future.workdir)
[01:28:23.430]         {
[01:28:23.430]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:23.430]                 ...future.oldOptions$nwarnings <- NULL
[01:28:23.430]             }
[01:28:23.430]             base::options(...future.oldOptions)
[01:28:23.430]             if (.Platform$OS.type == "windows") {
[01:28:23.430]                 old_names <- names(...future.oldEnvVars)
[01:28:23.430]                 envs <- base::Sys.getenv()
[01:28:23.430]                 names <- names(envs)
[01:28:23.430]                 common <- intersect(names, old_names)
[01:28:23.430]                 added <- setdiff(names, old_names)
[01:28:23.430]                 removed <- setdiff(old_names, names)
[01:28:23.430]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:23.430]                   envs[common]]
[01:28:23.430]                 NAMES <- toupper(changed)
[01:28:23.430]                 args <- list()
[01:28:23.430]                 for (kk in seq_along(NAMES)) {
[01:28:23.430]                   name <- changed[[kk]]
[01:28:23.430]                   NAME <- NAMES[[kk]]
[01:28:23.430]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:23.430]                     next
[01:28:23.430]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:23.430]                 }
[01:28:23.430]                 NAMES <- toupper(added)
[01:28:23.430]                 for (kk in seq_along(NAMES)) {
[01:28:23.430]                   name <- added[[kk]]
[01:28:23.430]                   NAME <- NAMES[[kk]]
[01:28:23.430]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:23.430]                     next
[01:28:23.430]                   args[[name]] <- ""
[01:28:23.430]                 }
[01:28:23.430]                 NAMES <- toupper(removed)
[01:28:23.430]                 for (kk in seq_along(NAMES)) {
[01:28:23.430]                   name <- removed[[kk]]
[01:28:23.430]                   NAME <- NAMES[[kk]]
[01:28:23.430]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:23.430]                     next
[01:28:23.430]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:23.430]                 }
[01:28:23.430]                 if (length(args) > 0) 
[01:28:23.430]                   base::do.call(base::Sys.setenv, args = args)
[01:28:23.430]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:23.430]             }
[01:28:23.430]             else {
[01:28:23.430]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:23.430]             }
[01:28:23.430]             {
[01:28:23.430]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:23.430]                   0L) {
[01:28:23.430]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:23.430]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:23.430]                   base::options(opts)
[01:28:23.430]                 }
[01:28:23.430]                 {
[01:28:23.430]                   {
[01:28:23.430]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:23.430]                     NULL
[01:28:23.430]                   }
[01:28:23.430]                   options(future.plan = NULL)
[01:28:23.430]                   if (is.na(NA_character_)) 
[01:28:23.430]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:23.430]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:23.430]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:23.430]                   {
[01:28:23.430]                     future <- SequentialFuture(..., envir = envir)
[01:28:23.430]                     if (!future$lazy) 
[01:28:23.430]                       future <- run(future)
[01:28:23.430]                     invisible(future)
[01:28:23.430]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:23.430]                 }
[01:28:23.430]             }
[01:28:23.430]         }
[01:28:23.430]     })
[01:28:23.430]     if (TRUE) {
[01:28:23.430]         base::sink(type = "output", split = FALSE)
[01:28:23.430]         if (TRUE) {
[01:28:23.430]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:23.430]         }
[01:28:23.430]         else {
[01:28:23.430]             ...future.result["stdout"] <- base::list(NULL)
[01:28:23.430]         }
[01:28:23.430]         base::close(...future.stdout)
[01:28:23.430]         ...future.stdout <- NULL
[01:28:23.430]     }
[01:28:23.430]     ...future.result$conditions <- ...future.conditions
[01:28:23.430]     ...future.result$finished <- base::Sys.time()
[01:28:23.430]     ...future.result
[01:28:23.430] }
[01:28:23.436] Exporting 1 global objects (56 bytes) to cluster node #1 ...
[01:28:23.437] Exporting 'a' (56 bytes) to cluster node #1 ...
[01:28:23.437] Exporting 'a' (56 bytes) to cluster node #1 ... DONE
[01:28:23.437] Exporting 1 global objects (56 bytes) to cluster node #1 ... DONE
[01:28:23.438] 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 56 bytes (numeric 'a' of 56 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[01:28:23.468] receiveMessageFromWorker() for ClusterFuture ...
[01:28:23.468] - Validating connection of MultisessionFuture
[01:28:23.468] - received message: FutureResult
[01:28:23.469] - Received FutureResult
[01:28:23.469] - Erased future from FutureRegistry
[01:28:23.469] result() for ClusterFuture ...
[01:28:23.469] - result already collected: FutureResult
[01:28:23.469] result() for ClusterFuture ... done
[01:28:23.470] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: cfeec5f2-987d-97c4-cbb0-b2e17579921c
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:23.470] result() for ClusterFuture ...
[01:28:23.470] - result already collected: FutureResult
[01:28:23.470] result() for ClusterFuture ... done
[01:28:23.470] result() for ClusterFuture ...
[01:28:23.471] - result already collected: FutureResult
[01:28:23.471] result() for ClusterFuture ... done
[1] 0
*** multisession() with globals and blocking
 - Creating multisession future #2 ...
[01:28:23.474] getGlobalsAndPackages() ...
[01:28:23.474] Searching for globals...
[01:28:23.475] - globals found: [2] '{', 'ii'
[01:28:23.475] Searching for globals ... DONE
[01:28:23.475] Resolving globals: FALSE
[01:28:23.476] The total size of the 1 globals is 56 bytes (56 bytes)
[01:28:23.476] The total size of the 1 globals exported for future expression ('{; ii; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'ii' (56 bytes of class 'numeric')
[01:28:23.477] - globals: [1] 'ii'
[01:28:23.477] 
[01:28:23.477] getGlobalsAndPackages() ... DONE
[01:28:23.490] Packages needed by the future expression (n = 0): <none>
[01:28:23.490] Packages needed by future strategies (n = 0): <none>
[01:28:23.491] {
[01:28:23.491]     {
[01:28:23.491]         {
[01:28:23.491]             ...future.startTime <- base::Sys.time()
[01:28:23.491]             {
[01:28:23.491]                 {
[01:28:23.491]                   {
[01:28:23.491]                     {
[01:28:23.491]                       base::local({
[01:28:23.491]                         has_future <- base::requireNamespace("future", 
[01:28:23.491]                           quietly = TRUE)
[01:28:23.491]                         if (has_future) {
[01:28:23.491]                           ns <- base::getNamespace("future")
[01:28:23.491]                           version <- ns[[".package"]][["version"]]
[01:28:23.491]                           if (is.null(version)) 
[01:28:23.491]                             version <- utils::packageVersion("future")
[01:28:23.491]                         }
[01:28:23.491]                         else {
[01:28:23.491]                           version <- NULL
[01:28:23.491]                         }
[01:28:23.491]                         if (!has_future || version < "1.8.0") {
[01:28:23.491]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:23.491]                             "", base::R.version$version.string), 
[01:28:23.491]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:23.491]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:23.491]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:23.491]                               "release", "version")], collapse = " "), 
[01:28:23.491]                             hostname = base::Sys.info()[["nodename"]])
[01:28:23.491]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:23.491]                             info)
[01:28:23.491]                           info <- base::paste(info, collapse = "; ")
[01:28:23.491]                           if (!has_future) {
[01:28:23.491]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:23.491]                               info)
[01:28:23.491]                           }
[01:28:23.491]                           else {
[01:28:23.491]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:23.491]                               info, version)
[01:28:23.491]                           }
[01:28:23.491]                           base::stop(msg)
[01:28:23.491]                         }
[01:28:23.491]                       })
[01:28:23.491]                     }
[01:28:23.491]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:23.491]                     base::options(mc.cores = 1L)
[01:28:23.491]                   }
[01:28:23.491]                   options(future.plan = NULL)
[01:28:23.491]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:23.491]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:23.491]                 }
[01:28:23.491]                 ...future.workdir <- getwd()
[01:28:23.491]             }
[01:28:23.491]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:23.491]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:23.491]         }
[01:28:23.491]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:23.491]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:23.491]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:23.491]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:23.491]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:23.491]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:23.491]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:23.491]             base::names(...future.oldOptions))
[01:28:23.491]     }
[01:28:23.491]     if (FALSE) {
[01:28:23.491]     }
[01:28:23.491]     else {
[01:28:23.491]         if (TRUE) {
[01:28:23.491]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:23.491]                 open = "w")
[01:28:23.491]         }
[01:28:23.491]         else {
[01:28:23.491]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:23.491]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:23.491]         }
[01:28:23.491]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:23.491]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:23.491]             base::sink(type = "output", split = FALSE)
[01:28:23.491]             base::close(...future.stdout)
[01:28:23.491]         }, add = TRUE)
[01:28:23.491]     }
[01:28:23.491]     ...future.frame <- base::sys.nframe()
[01:28:23.491]     ...future.conditions <- base::list()
[01:28:23.491]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:23.491]     if (FALSE) {
[01:28:23.491]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:23.491]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:23.491]     }
[01:28:23.491]     ...future.result <- base::tryCatch({
[01:28:23.491]         base::withCallingHandlers({
[01:28:23.491]             ...future.value <- base::withVisible(base::local({
[01:28:23.491]                 ...future.makeSendCondition <- base::local({
[01:28:23.491]                   sendCondition <- NULL
[01:28:23.491]                   function(frame = 1L) {
[01:28:23.491]                     if (is.function(sendCondition)) 
[01:28:23.491]                       return(sendCondition)
[01:28:23.491]                     ns <- getNamespace("parallel")
[01:28:23.491]                     if (exists("sendData", mode = "function", 
[01:28:23.491]                       envir = ns)) {
[01:28:23.491]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:23.491]                         envir = ns)
[01:28:23.491]                       envir <- sys.frame(frame)
[01:28:23.491]                       master <- NULL
[01:28:23.491]                       while (!identical(envir, .GlobalEnv) && 
[01:28:23.491]                         !identical(envir, emptyenv())) {
[01:28:23.491]                         if (exists("master", mode = "list", envir = envir, 
[01:28:23.491]                           inherits = FALSE)) {
[01:28:23.491]                           master <- get("master", mode = "list", 
[01:28:23.491]                             envir = envir, inherits = FALSE)
[01:28:23.491]                           if (inherits(master, c("SOCKnode", 
[01:28:23.491]                             "SOCK0node"))) {
[01:28:23.491]                             sendCondition <<- function(cond) {
[01:28:23.491]                               data <- list(type = "VALUE", value = cond, 
[01:28:23.491]                                 success = TRUE)
[01:28:23.491]                               parallel_sendData(master, data)
[01:28:23.491]                             }
[01:28:23.491]                             return(sendCondition)
[01:28:23.491]                           }
[01:28:23.491]                         }
[01:28:23.491]                         frame <- frame + 1L
[01:28:23.491]                         envir <- sys.frame(frame)
[01:28:23.491]                       }
[01:28:23.491]                     }
[01:28:23.491]                     sendCondition <<- function(cond) NULL
[01:28:23.491]                   }
[01:28:23.491]                 })
[01:28:23.491]                 withCallingHandlers({
[01:28:23.491]                   {
[01:28:23.491]                     ii
[01:28:23.491]                   }
[01:28:23.491]                 }, immediateCondition = function(cond) {
[01:28:23.491]                   sendCondition <- ...future.makeSendCondition()
[01:28:23.491]                   sendCondition(cond)
[01:28:23.491]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:23.491]                   {
[01:28:23.491]                     inherits <- base::inherits
[01:28:23.491]                     invokeRestart <- base::invokeRestart
[01:28:23.491]                     is.null <- base::is.null
[01:28:23.491]                     muffled <- FALSE
[01:28:23.491]                     if (inherits(cond, "message")) {
[01:28:23.491]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:23.491]                       if (muffled) 
[01:28:23.491]                         invokeRestart("muffleMessage")
[01:28:23.491]                     }
[01:28:23.491]                     else if (inherits(cond, "warning")) {
[01:28:23.491]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:23.491]                       if (muffled) 
[01:28:23.491]                         invokeRestart("muffleWarning")
[01:28:23.491]                     }
[01:28:23.491]                     else if (inherits(cond, "condition")) {
[01:28:23.491]                       if (!is.null(pattern)) {
[01:28:23.491]                         computeRestarts <- base::computeRestarts
[01:28:23.491]                         grepl <- base::grepl
[01:28:23.491]                         restarts <- computeRestarts(cond)
[01:28:23.491]                         for (restart in restarts) {
[01:28:23.491]                           name <- restart$name
[01:28:23.491]                           if (is.null(name)) 
[01:28:23.491]                             next
[01:28:23.491]                           if (!grepl(pattern, name)) 
[01:28:23.491]                             next
[01:28:23.491]                           invokeRestart(restart)
[01:28:23.491]                           muffled <- TRUE
[01:28:23.491]                           break
[01:28:23.491]                         }
[01:28:23.491]                       }
[01:28:23.491]                     }
[01:28:23.491]                     invisible(muffled)
[01:28:23.491]                   }
[01:28:23.491]                   muffleCondition(cond)
[01:28:23.491]                 })
[01:28:23.491]             }))
[01:28:23.491]             future::FutureResult(value = ...future.value$value, 
[01:28:23.491]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:23.491]                   ...future.rng), globalenv = if (FALSE) 
[01:28:23.491]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:23.491]                     ...future.globalenv.names))
[01:28:23.491]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:23.491]         }, condition = base::local({
[01:28:23.491]             c <- base::c
[01:28:23.491]             inherits <- base::inherits
[01:28:23.491]             invokeRestart <- base::invokeRestart
[01:28:23.491]             length <- base::length
[01:28:23.491]             list <- base::list
[01:28:23.491]             seq.int <- base::seq.int
[01:28:23.491]             signalCondition <- base::signalCondition
[01:28:23.491]             sys.calls <- base::sys.calls
[01:28:23.491]             `[[` <- base::`[[`
[01:28:23.491]             `+` <- base::`+`
[01:28:23.491]             `<<-` <- base::`<<-`
[01:28:23.491]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:23.491]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:23.491]                   3L)]
[01:28:23.491]             }
[01:28:23.491]             function(cond) {
[01:28:23.491]                 is_error <- inherits(cond, "error")
[01:28:23.491]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:23.491]                   NULL)
[01:28:23.491]                 if (is_error) {
[01:28:23.491]                   sessionInformation <- function() {
[01:28:23.491]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:23.491]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:23.491]                       search = base::search(), system = base::Sys.info())
[01:28:23.491]                   }
[01:28:23.491]                   ...future.conditions[[length(...future.conditions) + 
[01:28:23.491]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:23.491]                     cond$call), session = sessionInformation(), 
[01:28:23.491]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:23.491]                   signalCondition(cond)
[01:28:23.491]                 }
[01:28:23.491]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:23.491]                 "immediateCondition"))) {
[01:28:23.491]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:23.491]                   ...future.conditions[[length(...future.conditions) + 
[01:28:23.491]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:23.491]                   if (TRUE && !signal) {
[01:28:23.491]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:23.491]                     {
[01:28:23.491]                       inherits <- base::inherits
[01:28:23.491]                       invokeRestart <- base::invokeRestart
[01:28:23.491]                       is.null <- base::is.null
[01:28:23.491]                       muffled <- FALSE
[01:28:23.491]                       if (inherits(cond, "message")) {
[01:28:23.491]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:23.491]                         if (muffled) 
[01:28:23.491]                           invokeRestart("muffleMessage")
[01:28:23.491]                       }
[01:28:23.491]                       else if (inherits(cond, "warning")) {
[01:28:23.491]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:23.491]                         if (muffled) 
[01:28:23.491]                           invokeRestart("muffleWarning")
[01:28:23.491]                       }
[01:28:23.491]                       else if (inherits(cond, "condition")) {
[01:28:23.491]                         if (!is.null(pattern)) {
[01:28:23.491]                           computeRestarts <- base::computeRestarts
[01:28:23.491]                           grepl <- base::grepl
[01:28:23.491]                           restarts <- computeRestarts(cond)
[01:28:23.491]                           for (restart in restarts) {
[01:28:23.491]                             name <- restart$name
[01:28:23.491]                             if (is.null(name)) 
[01:28:23.491]                               next
[01:28:23.491]                             if (!grepl(pattern, name)) 
[01:28:23.491]                               next
[01:28:23.491]                             invokeRestart(restart)
[01:28:23.491]                             muffled <- TRUE
[01:28:23.491]                             break
[01:28:23.491]                           }
[01:28:23.491]                         }
[01:28:23.491]                       }
[01:28:23.491]                       invisible(muffled)
[01:28:23.491]                     }
[01:28:23.491]                     muffleCondition(cond, pattern = "^muffle")
[01:28:23.491]                   }
[01:28:23.491]                 }
[01:28:23.491]                 else {
[01:28:23.491]                   if (TRUE) {
[01:28:23.491]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:23.491]                     {
[01:28:23.491]                       inherits <- base::inherits
[01:28:23.491]                       invokeRestart <- base::invokeRestart
[01:28:23.491]                       is.null <- base::is.null
[01:28:23.491]                       muffled <- FALSE
[01:28:23.491]                       if (inherits(cond, "message")) {
[01:28:23.491]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:23.491]                         if (muffled) 
[01:28:23.491]                           invokeRestart("muffleMessage")
[01:28:23.491]                       }
[01:28:23.491]                       else if (inherits(cond, "warning")) {
[01:28:23.491]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:23.491]                         if (muffled) 
[01:28:23.491]                           invokeRestart("muffleWarning")
[01:28:23.491]                       }
[01:28:23.491]                       else if (inherits(cond, "condition")) {
[01:28:23.491]                         if (!is.null(pattern)) {
[01:28:23.491]                           computeRestarts <- base::computeRestarts
[01:28:23.491]                           grepl <- base::grepl
[01:28:23.491]                           restarts <- computeRestarts(cond)
[01:28:23.491]                           for (restart in restarts) {
[01:28:23.491]                             name <- restart$name
[01:28:23.491]                             if (is.null(name)) 
[01:28:23.491]                               next
[01:28:23.491]                             if (!grepl(pattern, name)) 
[01:28:23.491]                               next
[01:28:23.491]                             invokeRestart(restart)
[01:28:23.491]                             muffled <- TRUE
[01:28:23.491]                             break
[01:28:23.491]                           }
[01:28:23.491]                         }
[01:28:23.491]                       }
[01:28:23.491]                       invisible(muffled)
[01:28:23.491]                     }
[01:28:23.491]                     muffleCondition(cond, pattern = "^muffle")
[01:28:23.491]                   }
[01:28:23.491]                 }
[01:28:23.491]             }
[01:28:23.491]         }))
[01:28:23.491]     }, error = function(ex) {
[01:28:23.491]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:23.491]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:23.491]                 ...future.rng), started = ...future.startTime, 
[01:28:23.491]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:23.491]             version = "1.8"), class = "FutureResult")
[01:28:23.491]     }, finally = {
[01:28:23.491]         if (!identical(...future.workdir, getwd())) 
[01:28:23.491]             setwd(...future.workdir)
[01:28:23.491]         {
[01:28:23.491]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:23.491]                 ...future.oldOptions$nwarnings <- NULL
[01:28:23.491]             }
[01:28:23.491]             base::options(...future.oldOptions)
[01:28:23.491]             if (.Platform$OS.type == "windows") {
[01:28:23.491]                 old_names <- names(...future.oldEnvVars)
[01:28:23.491]                 envs <- base::Sys.getenv()
[01:28:23.491]                 names <- names(envs)
[01:28:23.491]                 common <- intersect(names, old_names)
[01:28:23.491]                 added <- setdiff(names, old_names)
[01:28:23.491]                 removed <- setdiff(old_names, names)
[01:28:23.491]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:23.491]                   envs[common]]
[01:28:23.491]                 NAMES <- toupper(changed)
[01:28:23.491]                 args <- list()
[01:28:23.491]                 for (kk in seq_along(NAMES)) {
[01:28:23.491]                   name <- changed[[kk]]
[01:28:23.491]                   NAME <- NAMES[[kk]]
[01:28:23.491]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:23.491]                     next
[01:28:23.491]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:23.491]                 }
[01:28:23.491]                 NAMES <- toupper(added)
[01:28:23.491]                 for (kk in seq_along(NAMES)) {
[01:28:23.491]                   name <- added[[kk]]
[01:28:23.491]                   NAME <- NAMES[[kk]]
[01:28:23.491]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:23.491]                     next
[01:28:23.491]                   args[[name]] <- ""
[01:28:23.491]                 }
[01:28:23.491]                 NAMES <- toupper(removed)
[01:28:23.491]                 for (kk in seq_along(NAMES)) {
[01:28:23.491]                   name <- removed[[kk]]
[01:28:23.491]                   NAME <- NAMES[[kk]]
[01:28:23.491]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:23.491]                     next
[01:28:23.491]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:23.491]                 }
[01:28:23.491]                 if (length(args) > 0) 
[01:28:23.491]                   base::do.call(base::Sys.setenv, args = args)
[01:28:23.491]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:23.491]             }
[01:28:23.491]             else {
[01:28:23.491]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:23.491]             }
[01:28:23.491]             {
[01:28:23.491]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:23.491]                   0L) {
[01:28:23.491]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:23.491]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:23.491]                   base::options(opts)
[01:28:23.491]                 }
[01:28:23.491]                 {
[01:28:23.491]                   {
[01:28:23.491]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:23.491]                     NULL
[01:28:23.491]                   }
[01:28:23.491]                   options(future.plan = NULL)
[01:28:23.491]                   if (is.na(NA_character_)) 
[01:28:23.491]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:23.491]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:23.491]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:23.491]                   {
[01:28:23.491]                     future <- SequentialFuture(..., envir = envir)
[01:28:23.491]                     if (!future$lazy) 
[01:28:23.491]                       future <- run(future)
[01:28:23.491]                     invisible(future)
[01:28:23.491]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:23.491]                 }
[01:28:23.491]             }
[01:28:23.491]         }
[01:28:23.491]     })
[01:28:23.491]     if (TRUE) {
[01:28:23.491]         base::sink(type = "output", split = FALSE)
[01:28:23.491]         if (TRUE) {
[01:28:23.491]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:23.491]         }
[01:28:23.491]         else {
[01:28:23.491]             ...future.result["stdout"] <- base::list(NULL)
[01:28:23.491]         }
[01:28:23.491]         base::close(...future.stdout)
[01:28:23.491]         ...future.stdout <- NULL
[01:28:23.491]     }
[01:28:23.491]     ...future.result$conditions <- ...future.conditions
[01:28:23.491]     ...future.result$finished <- base::Sys.time()
[01:28:23.491]     ...future.result
[01:28:23.491] }
[01:28:23.496] Exporting 1 global objects (56 bytes) to cluster node #1 ...
[01:28:23.497] Exporting 'ii' (56 bytes) to cluster node #1 ...
[01:28:23.497] Exporting 'ii' (56 bytes) to cluster node #1 ... DONE
[01:28:23.497] Exporting 1 global objects (56 bytes) to cluster node #1 ... DONE
[01:28:23.498] MultisessionFuture started
 - Creating multisession future #1 ...
[01:28:23.501] getGlobalsAndPackages() ...
[01:28:23.501] Searching for globals...
[01:28:23.502] - globals found: [2] '{', 'ii'
[01:28:23.502] Searching for globals ... DONE
[01:28:23.503] Resolving globals: FALSE
[01:28:23.503] The total size of the 1 globals is 56 bytes (56 bytes)
[01:28:23.504] The total size of the 1 globals exported for future expression ('{; ii; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'ii' (56 bytes of class 'numeric')
[01:28:23.504] - globals: [1] 'ii'
[01:28:23.504] 
[01:28:23.504] getGlobalsAndPackages() ... DONE
[01:28:23.517] Packages needed by the future expression (n = 0): <none>
[01:28:23.517] Packages needed by future strategies (n = 0): <none>
[01:28:23.518] {
[01:28:23.518]     {
[01:28:23.518]         {
[01:28:23.518]             ...future.startTime <- base::Sys.time()
[01:28:23.518]             {
[01:28:23.518]                 {
[01:28:23.518]                   {
[01:28:23.518]                     {
[01:28:23.518]                       base::local({
[01:28:23.518]                         has_future <- base::requireNamespace("future", 
[01:28:23.518]                           quietly = TRUE)
[01:28:23.518]                         if (has_future) {
[01:28:23.518]                           ns <- base::getNamespace("future")
[01:28:23.518]                           version <- ns[[".package"]][["version"]]
[01:28:23.518]                           if (is.null(version)) 
[01:28:23.518]                             version <- utils::packageVersion("future")
[01:28:23.518]                         }
[01:28:23.518]                         else {
[01:28:23.518]                           version <- NULL
[01:28:23.518]                         }
[01:28:23.518]                         if (!has_future || version < "1.8.0") {
[01:28:23.518]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:23.518]                             "", base::R.version$version.string), 
[01:28:23.518]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:23.518]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:23.518]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:23.518]                               "release", "version")], collapse = " "), 
[01:28:23.518]                             hostname = base::Sys.info()[["nodename"]])
[01:28:23.518]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:23.518]                             info)
[01:28:23.518]                           info <- base::paste(info, collapse = "; ")
[01:28:23.518]                           if (!has_future) {
[01:28:23.518]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:23.518]                               info)
[01:28:23.518]                           }
[01:28:23.518]                           else {
[01:28:23.518]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:23.518]                               info, version)
[01:28:23.518]                           }
[01:28:23.518]                           base::stop(msg)
[01:28:23.518]                         }
[01:28:23.518]                       })
[01:28:23.518]                     }
[01:28:23.518]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:23.518]                     base::options(mc.cores = 1L)
[01:28:23.518]                   }
[01:28:23.518]                   options(future.plan = NULL)
[01:28:23.518]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:23.518]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:23.518]                 }
[01:28:23.518]                 ...future.workdir <- getwd()
[01:28:23.518]             }
[01:28:23.518]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:23.518]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:23.518]         }
[01:28:23.518]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:23.518]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:23.518]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:23.518]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:23.518]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:23.518]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:23.518]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:23.518]             base::names(...future.oldOptions))
[01:28:23.518]     }
[01:28:23.518]     if (FALSE) {
[01:28:23.518]     }
[01:28:23.518]     else {
[01:28:23.518]         if (TRUE) {
[01:28:23.518]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:23.518]                 open = "w")
[01:28:23.518]         }
[01:28:23.518]         else {
[01:28:23.518]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:23.518]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:23.518]         }
[01:28:23.518]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:23.518]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:23.518]             base::sink(type = "output", split = FALSE)
[01:28:23.518]             base::close(...future.stdout)
[01:28:23.518]         }, add = TRUE)
[01:28:23.518]     }
[01:28:23.518]     ...future.frame <- base::sys.nframe()
[01:28:23.518]     ...future.conditions <- base::list()
[01:28:23.518]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:23.518]     if (FALSE) {
[01:28:23.518]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:23.518]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:23.518]     }
[01:28:23.518]     ...future.result <- base::tryCatch({
[01:28:23.518]         base::withCallingHandlers({
[01:28:23.518]             ...future.value <- base::withVisible(base::local({
[01:28:23.518]                 ...future.makeSendCondition <- base::local({
[01:28:23.518]                   sendCondition <- NULL
[01:28:23.518]                   function(frame = 1L) {
[01:28:23.518]                     if (is.function(sendCondition)) 
[01:28:23.518]                       return(sendCondition)
[01:28:23.518]                     ns <- getNamespace("parallel")
[01:28:23.518]                     if (exists("sendData", mode = "function", 
[01:28:23.518]                       envir = ns)) {
[01:28:23.518]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:23.518]                         envir = ns)
[01:28:23.518]                       envir <- sys.frame(frame)
[01:28:23.518]                       master <- NULL
[01:28:23.518]                       while (!identical(envir, .GlobalEnv) && 
[01:28:23.518]                         !identical(envir, emptyenv())) {
[01:28:23.518]                         if (exists("master", mode = "list", envir = envir, 
[01:28:23.518]                           inherits = FALSE)) {
[01:28:23.518]                           master <- get("master", mode = "list", 
[01:28:23.518]                             envir = envir, inherits = FALSE)
[01:28:23.518]                           if (inherits(master, c("SOCKnode", 
[01:28:23.518]                             "SOCK0node"))) {
[01:28:23.518]                             sendCondition <<- function(cond) {
[01:28:23.518]                               data <- list(type = "VALUE", value = cond, 
[01:28:23.518]                                 success = TRUE)
[01:28:23.518]                               parallel_sendData(master, data)
[01:28:23.518]                             }
[01:28:23.518]                             return(sendCondition)
[01:28:23.518]                           }
[01:28:23.518]                         }
[01:28:23.518]                         frame <- frame + 1L
[01:28:23.518]                         envir <- sys.frame(frame)
[01:28:23.518]                       }
[01:28:23.518]                     }
[01:28:23.518]                     sendCondition <<- function(cond) NULL
[01:28:23.518]                   }
[01:28:23.518]                 })
[01:28:23.518]                 withCallingHandlers({
[01:28:23.518]                   {
[01:28:23.518]                     ii
[01:28:23.518]                   }
[01:28:23.518]                 }, immediateCondition = function(cond) {
[01:28:23.518]                   sendCondition <- ...future.makeSendCondition()
[01:28:23.518]                   sendCondition(cond)
[01:28:23.518]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:23.518]                   {
[01:28:23.518]                     inherits <- base::inherits
[01:28:23.518]                     invokeRestart <- base::invokeRestart
[01:28:23.518]                     is.null <- base::is.null
[01:28:23.518]                     muffled <- FALSE
[01:28:23.518]                     if (inherits(cond, "message")) {
[01:28:23.518]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:23.518]                       if (muffled) 
[01:28:23.518]                         invokeRestart("muffleMessage")
[01:28:23.518]                     }
[01:28:23.518]                     else if (inherits(cond, "warning")) {
[01:28:23.518]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:23.518]                       if (muffled) 
[01:28:23.518]                         invokeRestart("muffleWarning")
[01:28:23.518]                     }
[01:28:23.518]                     else if (inherits(cond, "condition")) {
[01:28:23.518]                       if (!is.null(pattern)) {
[01:28:23.518]                         computeRestarts <- base::computeRestarts
[01:28:23.518]                         grepl <- base::grepl
[01:28:23.518]                         restarts <- computeRestarts(cond)
[01:28:23.518]                         for (restart in restarts) {
[01:28:23.518]                           name <- restart$name
[01:28:23.518]                           if (is.null(name)) 
[01:28:23.518]                             next
[01:28:23.518]                           if (!grepl(pattern, name)) 
[01:28:23.518]                             next
[01:28:23.518]                           invokeRestart(restart)
[01:28:23.518]                           muffled <- TRUE
[01:28:23.518]                           break
[01:28:23.518]                         }
[01:28:23.518]                       }
[01:28:23.518]                     }
[01:28:23.518]                     invisible(muffled)
[01:28:23.518]                   }
[01:28:23.518]                   muffleCondition(cond)
[01:28:23.518]                 })
[01:28:23.518]             }))
[01:28:23.518]             future::FutureResult(value = ...future.value$value, 
[01:28:23.518]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:23.518]                   ...future.rng), globalenv = if (FALSE) 
[01:28:23.518]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:23.518]                     ...future.globalenv.names))
[01:28:23.518]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:23.518]         }, condition = base::local({
[01:28:23.518]             c <- base::c
[01:28:23.518]             inherits <- base::inherits
[01:28:23.518]             invokeRestart <- base::invokeRestart
[01:28:23.518]             length <- base::length
[01:28:23.518]             list <- base::list
[01:28:23.518]             seq.int <- base::seq.int
[01:28:23.518]             signalCondition <- base::signalCondition
[01:28:23.518]             sys.calls <- base::sys.calls
[01:28:23.518]             `[[` <- base::`[[`
[01:28:23.518]             `+` <- base::`+`
[01:28:23.518]             `<<-` <- base::`<<-`
[01:28:23.518]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:23.518]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:23.518]                   3L)]
[01:28:23.518]             }
[01:28:23.518]             function(cond) {
[01:28:23.518]                 is_error <- inherits(cond, "error")
[01:28:23.518]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:23.518]                   NULL)
[01:28:23.518]                 if (is_error) {
[01:28:23.518]                   sessionInformation <- function() {
[01:28:23.518]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:23.518]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:23.518]                       search = base::search(), system = base::Sys.info())
[01:28:23.518]                   }
[01:28:23.518]                   ...future.conditions[[length(...future.conditions) + 
[01:28:23.518]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:23.518]                     cond$call), session = sessionInformation(), 
[01:28:23.518]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:23.518]                   signalCondition(cond)
[01:28:23.518]                 }
[01:28:23.518]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:23.518]                 "immediateCondition"))) {
[01:28:23.518]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:23.518]                   ...future.conditions[[length(...future.conditions) + 
[01:28:23.518]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:23.518]                   if (TRUE && !signal) {
[01:28:23.518]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:23.518]                     {
[01:28:23.518]                       inherits <- base::inherits
[01:28:23.518]                       invokeRestart <- base::invokeRestart
[01:28:23.518]                       is.null <- base::is.null
[01:28:23.518]                       muffled <- FALSE
[01:28:23.518]                       if (inherits(cond, "message")) {
[01:28:23.518]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:23.518]                         if (muffled) 
[01:28:23.518]                           invokeRestart("muffleMessage")
[01:28:23.518]                       }
[01:28:23.518]                       else if (inherits(cond, "warning")) {
[01:28:23.518]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:23.518]                         if (muffled) 
[01:28:23.518]                           invokeRestart("muffleWarning")
[01:28:23.518]                       }
[01:28:23.518]                       else if (inherits(cond, "condition")) {
[01:28:23.518]                         if (!is.null(pattern)) {
[01:28:23.518]                           computeRestarts <- base::computeRestarts
[01:28:23.518]                           grepl <- base::grepl
[01:28:23.518]                           restarts <- computeRestarts(cond)
[01:28:23.518]                           for (restart in restarts) {
[01:28:23.518]                             name <- restart$name
[01:28:23.518]                             if (is.null(name)) 
[01:28:23.518]                               next
[01:28:23.518]                             if (!grepl(pattern, name)) 
[01:28:23.518]                               next
[01:28:23.518]                             invokeRestart(restart)
[01:28:23.518]                             muffled <- TRUE
[01:28:23.518]                             break
[01:28:23.518]                           }
[01:28:23.518]                         }
[01:28:23.518]                       }
[01:28:23.518]                       invisible(muffled)
[01:28:23.518]                     }
[01:28:23.518]                     muffleCondition(cond, pattern = "^muffle")
[01:28:23.518]                   }
[01:28:23.518]                 }
[01:28:23.518]                 else {
[01:28:23.518]                   if (TRUE) {
[01:28:23.518]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:23.518]                     {
[01:28:23.518]                       inherits <- base::inherits
[01:28:23.518]                       invokeRestart <- base::invokeRestart
[01:28:23.518]                       is.null <- base::is.null
[01:28:23.518]                       muffled <- FALSE
[01:28:23.518]                       if (inherits(cond, "message")) {
[01:28:23.518]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:23.518]                         if (muffled) 
[01:28:23.518]                           invokeRestart("muffleMessage")
[01:28:23.518]                       }
[01:28:23.518]                       else if (inherits(cond, "warning")) {
[01:28:23.518]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:23.518]                         if (muffled) 
[01:28:23.518]                           invokeRestart("muffleWarning")
[01:28:23.518]                       }
[01:28:23.518]                       else if (inherits(cond, "condition")) {
[01:28:23.518]                         if (!is.null(pattern)) {
[01:28:23.518]                           computeRestarts <- base::computeRestarts
[01:28:23.518]                           grepl <- base::grepl
[01:28:23.518]                           restarts <- computeRestarts(cond)
[01:28:23.518]                           for (restart in restarts) {
[01:28:23.518]                             name <- restart$name
[01:28:23.518]                             if (is.null(name)) 
[01:28:23.518]                               next
[01:28:23.518]                             if (!grepl(pattern, name)) 
[01:28:23.518]                               next
[01:28:23.518]                             invokeRestart(restart)
[01:28:23.518]                             muffled <- TRUE
[01:28:23.518]                             break
[01:28:23.518]                           }
[01:28:23.518]                         }
[01:28:23.518]                       }
[01:28:23.518]                       invisible(muffled)
[01:28:23.518]                     }
[01:28:23.518]                     muffleCondition(cond, pattern = "^muffle")
[01:28:23.518]                   }
[01:28:23.518]                 }
[01:28:23.518]             }
[01:28:23.518]         }))
[01:28:23.518]     }, error = function(ex) {
[01:28:23.518]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:23.518]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:23.518]                 ...future.rng), started = ...future.startTime, 
[01:28:23.518]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:23.518]             version = "1.8"), class = "FutureResult")
[01:28:23.518]     }, finally = {
[01:28:23.518]         if (!identical(...future.workdir, getwd())) 
[01:28:23.518]             setwd(...future.workdir)
[01:28:23.518]         {
[01:28:23.518]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:23.518]                 ...future.oldOptions$nwarnings <- NULL
[01:28:23.518]             }
[01:28:23.518]             base::options(...future.oldOptions)
[01:28:23.518]             if (.Platform$OS.type == "windows") {
[01:28:23.518]                 old_names <- names(...future.oldEnvVars)
[01:28:23.518]                 envs <- base::Sys.getenv()
[01:28:23.518]                 names <- names(envs)
[01:28:23.518]                 common <- intersect(names, old_names)
[01:28:23.518]                 added <- setdiff(names, old_names)
[01:28:23.518]                 removed <- setdiff(old_names, names)
[01:28:23.518]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:23.518]                   envs[common]]
[01:28:23.518]                 NAMES <- toupper(changed)
[01:28:23.518]                 args <- list()
[01:28:23.518]                 for (kk in seq_along(NAMES)) {
[01:28:23.518]                   name <- changed[[kk]]
[01:28:23.518]                   NAME <- NAMES[[kk]]
[01:28:23.518]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:23.518]                     next
[01:28:23.518]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:23.518]                 }
[01:28:23.518]                 NAMES <- toupper(added)
[01:28:23.518]                 for (kk in seq_along(NAMES)) {
[01:28:23.518]                   name <- added[[kk]]
[01:28:23.518]                   NAME <- NAMES[[kk]]
[01:28:23.518]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:23.518]                     next
[01:28:23.518]                   args[[name]] <- ""
[01:28:23.518]                 }
[01:28:23.518]                 NAMES <- toupper(removed)
[01:28:23.518]                 for (kk in seq_along(NAMES)) {
[01:28:23.518]                   name <- removed[[kk]]
[01:28:23.518]                   NAME <- NAMES[[kk]]
[01:28:23.518]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:23.518]                     next
[01:28:23.518]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:23.518]                 }
[01:28:23.518]                 if (length(args) > 0) 
[01:28:23.518]                   base::do.call(base::Sys.setenv, args = args)
[01:28:23.518]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:23.518]             }
[01:28:23.518]             else {
[01:28:23.518]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:23.518]             }
[01:28:23.518]             {
[01:28:23.518]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:23.518]                   0L) {
[01:28:23.518]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:23.518]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:23.518]                   base::options(opts)
[01:28:23.518]                 }
[01:28:23.518]                 {
[01:28:23.518]                   {
[01:28:23.518]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:23.518]                     NULL
[01:28:23.518]                   }
[01:28:23.518]                   options(future.plan = NULL)
[01:28:23.518]                   if (is.na(NA_character_)) 
[01:28:23.518]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:23.518]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:23.518]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:23.518]                   {
[01:28:23.518]                     future <- SequentialFuture(..., envir = envir)
[01:28:23.518]                     if (!future$lazy) 
[01:28:23.518]                       future <- run(future)
[01:28:23.518]                     invisible(future)
[01:28:23.518]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:23.518]                 }
[01:28:23.518]             }
[01:28:23.518]         }
[01:28:23.518]     })
[01:28:23.518]     if (TRUE) {
[01:28:23.518]         base::sink(type = "output", split = FALSE)
[01:28:23.518]         if (TRUE) {
[01:28:23.518]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:23.518]         }
[01:28:23.518]         else {
[01:28:23.518]             ...future.result["stdout"] <- base::list(NULL)
[01:28:23.518]         }
[01:28:23.518]         base::close(...future.stdout)
[01:28:23.518]         ...future.stdout <- NULL
[01:28:23.518]     }
[01:28:23.518]     ...future.result$conditions <- ...future.conditions
[01:28:23.518]     ...future.result$finished <- base::Sys.time()
[01:28:23.518]     ...future.result
[01:28:23.518] }
[01:28:23.610] Exporting 1 global objects (56 bytes) to cluster node #2 ...
[01:28:23.610] Exporting 'ii' (56 bytes) to cluster node #2 ...
[01:28:23.610] Exporting 'ii' (56 bytes) to cluster node #2 ... DONE
[01:28:23.611] Exporting 1 global objects (56 bytes) to cluster node #2 ... DONE
[01:28:23.612] MultisessionFuture started
 - Resolving 2 multisession futures
[01:28:23.612] result() for ClusterFuture ...
[01:28:23.612] receiveMessageFromWorker() for ClusterFuture ...
[01:28:23.612] - Validating connection of MultisessionFuture
[01:28:23.666] - received message: FutureResult
[01:28:23.666] - Received FutureResult
[01:28:23.666] - Erased future from FutureRegistry
[01:28:23.667] result() for ClusterFuture ...
[01:28:23.667] - result already collected: FutureResult
[01:28:23.667] result() for ClusterFuture ... done
[01:28:23.668] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:23.668] result() for ClusterFuture ... done
[01:28:23.668] result() for ClusterFuture ...
[01:28:23.668] - result already collected: FutureResult
[01:28:23.669] result() for ClusterFuture ... done
[01:28:23.669] result() for ClusterFuture ...
[01:28:23.669] receiveMessageFromWorker() for ClusterFuture ...
[01:28:23.669] - Validating connection of MultisessionFuture
[01:28:23.670] - received message: FutureResult
[01:28:23.670] - Received FutureResult
[01:28:23.670] - Erased future from FutureRegistry
[01:28:23.670] result() for ClusterFuture ...
[01:28:23.671] - result already collected: FutureResult
[01:28:23.671] result() for ClusterFuture ... done
[01:28:23.671] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:23.671] result() for ClusterFuture ... done
[01:28:23.671] result() for ClusterFuture ...
[01:28:23.672] - result already collected: FutureResult
[01:28:23.672] result() for ClusterFuture ... done
*** multisession() - workers inherit .libPaths()
[01:28:23.672] getGlobalsAndPackages() ...
[01:28:23.672] Searching for globals...
[01:28:23.673] - globals found: [1] '.libPaths'
[01:28:23.673] Searching for globals ... DONE
[01:28:23.674] Resolving globals: FALSE
[01:28:23.674] 
[01:28:23.674] 
[01:28:23.674] getGlobalsAndPackages() ... DONE
[01:28:23.675] run() for 'Future' ...
[01:28:23.675] - state: 'created'
[01:28:23.675] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:23.676] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:23.676] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:23.676]   - Field: 'label'
[01:28:23.677]   - Field: 'local'
[01:28:23.677]   - Field: 'owner'
[01:28:23.677]   - Field: 'envir'
[01:28:23.677]   - Field: 'packages'
[01:28:23.677]   - Field: 'gc'
[01:28:23.678]   - Field: 'conditions'
[01:28:23.678]   - Field: 'expr'
[01:28:23.678]   - Field: 'uuid'
[01:28:23.678]   - Field: 'seed'
[01:28:23.678]   - Field: 'version'
[01:28:23.679]   - Field: 'result'
[01:28:23.679]   - Field: 'asynchronous'
[01:28:23.679]   - Field: 'calls'
[01:28:23.679]   - Field: 'globals'
[01:28:23.679]   - Field: 'stdout'
[01:28:23.680]   - Field: 'earlySignal'
[01:28:23.680]   - Field: 'lazy'
[01:28:23.680]   - Field: 'state'
[01:28:23.680] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:23.681] - Launch lazy future ...
[01:28:23.681] Packages needed by the future expression (n = 0): <none>
[01:28:23.681] Packages needed by future strategies (n = 0): <none>
[01:28:23.682] {
[01:28:23.682]     {
[01:28:23.682]         {
[01:28:23.682]             ...future.startTime <- base::Sys.time()
[01:28:23.682]             {
[01:28:23.682]                 {
[01:28:23.682]                   {
[01:28:23.682]                     base::local({
[01:28:23.682]                       has_future <- base::requireNamespace("future", 
[01:28:23.682]                         quietly = TRUE)
[01:28:23.682]                       if (has_future) {
[01:28:23.682]                         ns <- base::getNamespace("future")
[01:28:23.682]                         version <- ns[[".package"]][["version"]]
[01:28:23.682]                         if (is.null(version)) 
[01:28:23.682]                           version <- utils::packageVersion("future")
[01:28:23.682]                       }
[01:28:23.682]                       else {
[01:28:23.682]                         version <- NULL
[01:28:23.682]                       }
[01:28:23.682]                       if (!has_future || version < "1.8.0") {
[01:28:23.682]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:23.682]                           "", base::R.version$version.string), 
[01:28:23.682]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:23.682]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:23.682]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:23.682]                             "release", "version")], collapse = " "), 
[01:28:23.682]                           hostname = base::Sys.info()[["nodename"]])
[01:28:23.682]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:23.682]                           info)
[01:28:23.682]                         info <- base::paste(info, collapse = "; ")
[01:28:23.682]                         if (!has_future) {
[01:28:23.682]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:23.682]                             info)
[01:28:23.682]                         }
[01:28:23.682]                         else {
[01:28:23.682]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:23.682]                             info, version)
[01:28:23.682]                         }
[01:28:23.682]                         base::stop(msg)
[01:28:23.682]                       }
[01:28:23.682]                     })
[01:28:23.682]                   }
[01:28:23.682]                   options(future.plan = NULL)
[01:28:23.682]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:23.682]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:23.682]                 }
[01:28:23.682]                 ...future.workdir <- getwd()
[01:28:23.682]             }
[01:28:23.682]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:23.682]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:23.682]         }
[01:28:23.682]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:23.682]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:23.682]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:23.682]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:23.682]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:23.682]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:23.682]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:23.682]             base::names(...future.oldOptions))
[01:28:23.682]     }
[01:28:23.682]     if (FALSE) {
[01:28:23.682]     }
[01:28:23.682]     else {
[01:28:23.682]         if (TRUE) {
[01:28:23.682]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:23.682]                 open = "w")
[01:28:23.682]         }
[01:28:23.682]         else {
[01:28:23.682]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:23.682]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:23.682]         }
[01:28:23.682]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:23.682]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:23.682]             base::sink(type = "output", split = FALSE)
[01:28:23.682]             base::close(...future.stdout)
[01:28:23.682]         }, add = TRUE)
[01:28:23.682]     }
[01:28:23.682]     ...future.frame <- base::sys.nframe()
[01:28:23.682]     ...future.conditions <- base::list()
[01:28:23.682]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:23.682]     if (FALSE) {
[01:28:23.682]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:23.682]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:23.682]     }
[01:28:23.682]     ...future.result <- base::tryCatch({
[01:28:23.682]         base::withCallingHandlers({
[01:28:23.682]             ...future.value <- base::withVisible(base::local(.libPaths()))
[01:28:23.682]             future::FutureResult(value = ...future.value$value, 
[01:28:23.682]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:23.682]                   ...future.rng), globalenv = if (FALSE) 
[01:28:23.682]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:23.682]                     ...future.globalenv.names))
[01:28:23.682]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:23.682]         }, condition = base::local({
[01:28:23.682]             c <- base::c
[01:28:23.682]             inherits <- base::inherits
[01:28:23.682]             invokeRestart <- base::invokeRestart
[01:28:23.682]             length <- base::length
[01:28:23.682]             list <- base::list
[01:28:23.682]             seq.int <- base::seq.int
[01:28:23.682]             signalCondition <- base::signalCondition
[01:28:23.682]             sys.calls <- base::sys.calls
[01:28:23.682]             `[[` <- base::`[[`
[01:28:23.682]             `+` <- base::`+`
[01:28:23.682]             `<<-` <- base::`<<-`
[01:28:23.682]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:23.682]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:23.682]                   3L)]
[01:28:23.682]             }
[01:28:23.682]             function(cond) {
[01:28:23.682]                 is_error <- inherits(cond, "error")
[01:28:23.682]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:23.682]                   NULL)
[01:28:23.682]                 if (is_error) {
[01:28:23.682]                   sessionInformation <- function() {
[01:28:23.682]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:23.682]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:23.682]                       search = base::search(), system = base::Sys.info())
[01:28:23.682]                   }
[01:28:23.682]                   ...future.conditions[[length(...future.conditions) + 
[01:28:23.682]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:23.682]                     cond$call), session = sessionInformation(), 
[01:28:23.682]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:23.682]                   signalCondition(cond)
[01:28:23.682]                 }
[01:28:23.682]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:23.682]                 "immediateCondition"))) {
[01:28:23.682]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:23.682]                   ...future.conditions[[length(...future.conditions) + 
[01:28:23.682]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:23.682]                   if (TRUE && !signal) {
[01:28:23.682]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:23.682]                     {
[01:28:23.682]                       inherits <- base::inherits
[01:28:23.682]                       invokeRestart <- base::invokeRestart
[01:28:23.682]                       is.null <- base::is.null
[01:28:23.682]                       muffled <- FALSE
[01:28:23.682]                       if (inherits(cond, "message")) {
[01:28:23.682]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:23.682]                         if (muffled) 
[01:28:23.682]                           invokeRestart("muffleMessage")
[01:28:23.682]                       }
[01:28:23.682]                       else if (inherits(cond, "warning")) {
[01:28:23.682]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:23.682]                         if (muffled) 
[01:28:23.682]                           invokeRestart("muffleWarning")
[01:28:23.682]                       }
[01:28:23.682]                       else if (inherits(cond, "condition")) {
[01:28:23.682]                         if (!is.null(pattern)) {
[01:28:23.682]                           computeRestarts <- base::computeRestarts
[01:28:23.682]                           grepl <- base::grepl
[01:28:23.682]                           restarts <- computeRestarts(cond)
[01:28:23.682]                           for (restart in restarts) {
[01:28:23.682]                             name <- restart$name
[01:28:23.682]                             if (is.null(name)) 
[01:28:23.682]                               next
[01:28:23.682]                             if (!grepl(pattern, name)) 
[01:28:23.682]                               next
[01:28:23.682]                             invokeRestart(restart)
[01:28:23.682]                             muffled <- TRUE
[01:28:23.682]                             break
[01:28:23.682]                           }
[01:28:23.682]                         }
[01:28:23.682]                       }
[01:28:23.682]                       invisible(muffled)
[01:28:23.682]                     }
[01:28:23.682]                     muffleCondition(cond, pattern = "^muffle")
[01:28:23.682]                   }
[01:28:23.682]                 }
[01:28:23.682]                 else {
[01:28:23.682]                   if (TRUE) {
[01:28:23.682]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:23.682]                     {
[01:28:23.682]                       inherits <- base::inherits
[01:28:23.682]                       invokeRestart <- base::invokeRestart
[01:28:23.682]                       is.null <- base::is.null
[01:28:23.682]                       muffled <- FALSE
[01:28:23.682]                       if (inherits(cond, "message")) {
[01:28:23.682]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:23.682]                         if (muffled) 
[01:28:23.682]                           invokeRestart("muffleMessage")
[01:28:23.682]                       }
[01:28:23.682]                       else if (inherits(cond, "warning")) {
[01:28:23.682]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:23.682]                         if (muffled) 
[01:28:23.682]                           invokeRestart("muffleWarning")
[01:28:23.682]                       }
[01:28:23.682]                       else if (inherits(cond, "condition")) {
[01:28:23.682]                         if (!is.null(pattern)) {
[01:28:23.682]                           computeRestarts <- base::computeRestarts
[01:28:23.682]                           grepl <- base::grepl
[01:28:23.682]                           restarts <- computeRestarts(cond)
[01:28:23.682]                           for (restart in restarts) {
[01:28:23.682]                             name <- restart$name
[01:28:23.682]                             if (is.null(name)) 
[01:28:23.682]                               next
[01:28:23.682]                             if (!grepl(pattern, name)) 
[01:28:23.682]                               next
[01:28:23.682]                             invokeRestart(restart)
[01:28:23.682]                             muffled <- TRUE
[01:28:23.682]                             break
[01:28:23.682]                           }
[01:28:23.682]                         }
[01:28:23.682]                       }
[01:28:23.682]                       invisible(muffled)
[01:28:23.682]                     }
[01:28:23.682]                     muffleCondition(cond, pattern = "^muffle")
[01:28:23.682]                   }
[01:28:23.682]                 }
[01:28:23.682]             }
[01:28:23.682]         }))
[01:28:23.682]     }, error = function(ex) {
[01:28:23.682]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:23.682]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:23.682]                 ...future.rng), started = ...future.startTime, 
[01:28:23.682]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:23.682]             version = "1.8"), class = "FutureResult")
[01:28:23.682]     }, finally = {
[01:28:23.682]         if (!identical(...future.workdir, getwd())) 
[01:28:23.682]             setwd(...future.workdir)
[01:28:23.682]         {
[01:28:23.682]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:23.682]                 ...future.oldOptions$nwarnings <- NULL
[01:28:23.682]             }
[01:28:23.682]             base::options(...future.oldOptions)
[01:28:23.682]             if (.Platform$OS.type == "windows") {
[01:28:23.682]                 old_names <- names(...future.oldEnvVars)
[01:28:23.682]                 envs <- base::Sys.getenv()
[01:28:23.682]                 names <- names(envs)
[01:28:23.682]                 common <- intersect(names, old_names)
[01:28:23.682]                 added <- setdiff(names, old_names)
[01:28:23.682]                 removed <- setdiff(old_names, names)
[01:28:23.682]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:23.682]                   envs[common]]
[01:28:23.682]                 NAMES <- toupper(changed)
[01:28:23.682]                 args <- list()
[01:28:23.682]                 for (kk in seq_along(NAMES)) {
[01:28:23.682]                   name <- changed[[kk]]
[01:28:23.682]                   NAME <- NAMES[[kk]]
[01:28:23.682]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:23.682]                     next
[01:28:23.682]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:23.682]                 }
[01:28:23.682]                 NAMES <- toupper(added)
[01:28:23.682]                 for (kk in seq_along(NAMES)) {
[01:28:23.682]                   name <- added[[kk]]
[01:28:23.682]                   NAME <- NAMES[[kk]]
[01:28:23.682]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:23.682]                     next
[01:28:23.682]                   args[[name]] <- ""
[01:28:23.682]                 }
[01:28:23.682]                 NAMES <- toupper(removed)
[01:28:23.682]                 for (kk in seq_along(NAMES)) {
[01:28:23.682]                   name <- removed[[kk]]
[01:28:23.682]                   NAME <- NAMES[[kk]]
[01:28:23.682]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:23.682]                     next
[01:28:23.682]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:23.682]                 }
[01:28:23.682]                 if (length(args) > 0) 
[01:28:23.682]                   base::do.call(base::Sys.setenv, args = args)
[01:28:23.682]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:23.682]             }
[01:28:23.682]             else {
[01:28:23.682]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:23.682]             }
[01:28:23.682]             {
[01:28:23.682]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:23.682]                   0L) {
[01:28:23.682]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:23.682]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:23.682]                   base::options(opts)
[01:28:23.682]                 }
[01:28:23.682]                 {
[01:28:23.682]                   {
[01:28:23.682]                     NULL
[01:28:23.682]                     RNGkind("Mersenne-Twister")
[01:28:23.682]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:23.682]                       inherits = FALSE)
[01:28:23.682]                   }
[01:28:23.682]                   options(future.plan = NULL)
[01:28:23.682]                   if (is.na(NA_character_)) 
[01:28:23.682]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:23.682]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:23.682]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:23.682]                   {
[01:28:23.682]                     future <- SequentialFuture(..., envir = envir)
[01:28:23.682]                     if (!future$lazy) 
[01:28:23.682]                       future <- run(future)
[01:28:23.682]                     invisible(future)
[01:28:23.682]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:23.682]                 }
[01:28:23.682]             }
[01:28:23.682]         }
[01:28:23.682]     })
[01:28:23.682]     if (TRUE) {
[01:28:23.682]         base::sink(type = "output", split = FALSE)
[01:28:23.682]         if (TRUE) {
[01:28:23.682]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:23.682]         }
[01:28:23.682]         else {
[01:28:23.682]             ...future.result["stdout"] <- base::list(NULL)
[01:28:23.682]         }
[01:28:23.682]         base::close(...future.stdout)
[01:28:23.682]         ...future.stdout <- NULL
[01:28:23.682]     }
[01:28:23.682]     ...future.result$conditions <- ...future.conditions
[01:28:23.682]     ...future.result$finished <- base::Sys.time()
[01:28:23.682]     ...future.result
[01:28:23.682] }
[01:28:23.686] plan(): Setting new future strategy stack:
[01:28:23.686] List of future strategies:
[01:28:23.686] 1. sequential:
[01:28:23.686]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:23.686]    - tweaked: FALSE
[01:28:23.686]    - call: NULL
[01:28:23.687] plan(): nbrOfWorkers() = 1
[01:28:23.688] plan(): Setting new future strategy stack:
[01:28:23.689] List of future strategies:
[01:28:23.689] 1. sequential:
[01:28:23.689]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:23.689]    - tweaked: FALSE
[01:28:23.689]    - call: future::plan("sequential")
[01:28:23.689] plan(): nbrOfWorkers() = 1
[01:28:23.690] SequentialFuture started (and completed)
[01:28:23.690] - Launch lazy future ... done
[01:28:23.690] run() for 'SequentialFuture' ... done
List of 2
 $ main   : chr [1:2] "D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47" "D:/RCompile/recent/R/library"
 $ workers: chr [1:2] "D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47" "D:/RCompile/recent/R/library"
*** multisession() and errors
[01:28:23.697] getGlobalsAndPackages() ...
[01:28:23.697] 
[01:28:23.697] - globals: [0] <none>
[01:28:23.697] getGlobalsAndPackages() ... DONE
[01:28:23.709] Packages needed by the future expression (n = 0): <none>
[01:28:23.710] Packages needed by future strategies (n = 0): <none>
[01:28:23.710] {
[01:28:23.710]     {
[01:28:23.710]         {
[01:28:23.710]             ...future.startTime <- base::Sys.time()
[01:28:23.710]             {
[01:28:23.710]                 {
[01:28:23.710]                   {
[01:28:23.710]                     {
[01:28:23.710]                       base::local({
[01:28:23.710]                         has_future <- base::requireNamespace("future", 
[01:28:23.710]                           quietly = TRUE)
[01:28:23.710]                         if (has_future) {
[01:28:23.710]                           ns <- base::getNamespace("future")
[01:28:23.710]                           version <- ns[[".package"]][["version"]]
[01:28:23.710]                           if (is.null(version)) 
[01:28:23.710]                             version <- utils::packageVersion("future")
[01:28:23.710]                         }
[01:28:23.710]                         else {
[01:28:23.710]                           version <- NULL
[01:28:23.710]                         }
[01:28:23.710]                         if (!has_future || version < "1.8.0") {
[01:28:23.710]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:23.710]                             "", base::R.version$version.string), 
[01:28:23.710]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:23.710]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:23.710]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:23.710]                               "release", "version")], collapse = " "), 
[01:28:23.710]                             hostname = base::Sys.info()[["nodename"]])
[01:28:23.710]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:23.710]                             info)
[01:28:23.710]                           info <- base::paste(info, collapse = "; ")
[01:28:23.710]                           if (!has_future) {
[01:28:23.710]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:23.710]                               info)
[01:28:23.710]                           }
[01:28:23.710]                           else {
[01:28:23.710]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:23.710]                               info, version)
[01:28:23.710]                           }
[01:28:23.710]                           base::stop(msg)
[01:28:23.710]                         }
[01:28:23.710]                       })
[01:28:23.710]                     }
[01:28:23.710]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:23.710]                     base::options(mc.cores = 1L)
[01:28:23.710]                   }
[01:28:23.710]                   options(future.plan = NULL)
[01:28:23.710]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:23.710]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:23.710]                 }
[01:28:23.710]                 ...future.workdir <- getwd()
[01:28:23.710]             }
[01:28:23.710]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:23.710]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:23.710]         }
[01:28:23.710]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:23.710]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:23.710]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:23.710]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:23.710]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:23.710]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:23.710]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:23.710]             base::names(...future.oldOptions))
[01:28:23.710]     }
[01:28:23.710]     if (FALSE) {
[01:28:23.710]     }
[01:28:23.710]     else {
[01:28:23.710]         if (TRUE) {
[01:28:23.710]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:23.710]                 open = "w")
[01:28:23.710]         }
[01:28:23.710]         else {
[01:28:23.710]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:23.710]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:23.710]         }
[01:28:23.710]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:23.710]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:23.710]             base::sink(type = "output", split = FALSE)
[01:28:23.710]             base::close(...future.stdout)
[01:28:23.710]         }, add = TRUE)
[01:28:23.710]     }
[01:28:23.710]     ...future.frame <- base::sys.nframe()
[01:28:23.710]     ...future.conditions <- base::list()
[01:28:23.710]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:23.710]     if (FALSE) {
[01:28:23.710]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:23.710]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:23.710]     }
[01:28:23.710]     ...future.result <- base::tryCatch({
[01:28:23.710]         base::withCallingHandlers({
[01:28:23.710]             ...future.value <- base::withVisible(base::local({
[01:28:23.710]                 ...future.makeSendCondition <- base::local({
[01:28:23.710]                   sendCondition <- NULL
[01:28:23.710]                   function(frame = 1L) {
[01:28:23.710]                     if (is.function(sendCondition)) 
[01:28:23.710]                       return(sendCondition)
[01:28:23.710]                     ns <- getNamespace("parallel")
[01:28:23.710]                     if (exists("sendData", mode = "function", 
[01:28:23.710]                       envir = ns)) {
[01:28:23.710]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:23.710]                         envir = ns)
[01:28:23.710]                       envir <- sys.frame(frame)
[01:28:23.710]                       master <- NULL
[01:28:23.710]                       while (!identical(envir, .GlobalEnv) && 
[01:28:23.710]                         !identical(envir, emptyenv())) {
[01:28:23.710]                         if (exists("master", mode = "list", envir = envir, 
[01:28:23.710]                           inherits = FALSE)) {
[01:28:23.710]                           master <- get("master", mode = "list", 
[01:28:23.710]                             envir = envir, inherits = FALSE)
[01:28:23.710]                           if (inherits(master, c("SOCKnode", 
[01:28:23.710]                             "SOCK0node"))) {
[01:28:23.710]                             sendCondition <<- function(cond) {
[01:28:23.710]                               data <- list(type = "VALUE", value = cond, 
[01:28:23.710]                                 success = TRUE)
[01:28:23.710]                               parallel_sendData(master, data)
[01:28:23.710]                             }
[01:28:23.710]                             return(sendCondition)
[01:28:23.710]                           }
[01:28:23.710]                         }
[01:28:23.710]                         frame <- frame + 1L
[01:28:23.710]                         envir <- sys.frame(frame)
[01:28:23.710]                       }
[01:28:23.710]                     }
[01:28:23.710]                     sendCondition <<- function(cond) NULL
[01:28:23.710]                   }
[01:28:23.710]                 })
[01:28:23.710]                 withCallingHandlers({
[01:28:23.710]                   {
[01:28:23.710]                     stop("Whoops!")
[01:28:23.710]                     1
[01:28:23.710]                   }
[01:28:23.710]                 }, immediateCondition = function(cond) {
[01:28:23.710]                   sendCondition <- ...future.makeSendCondition()
[01:28:23.710]                   sendCondition(cond)
[01:28:23.710]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:23.710]                   {
[01:28:23.710]                     inherits <- base::inherits
[01:28:23.710]                     invokeRestart <- base::invokeRestart
[01:28:23.710]                     is.null <- base::is.null
[01:28:23.710]                     muffled <- FALSE
[01:28:23.710]                     if (inherits(cond, "message")) {
[01:28:23.710]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:23.710]                       if (muffled) 
[01:28:23.710]                         invokeRestart("muffleMessage")
[01:28:23.710]                     }
[01:28:23.710]                     else if (inherits(cond, "warning")) {
[01:28:23.710]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:23.710]                       if (muffled) 
[01:28:23.710]                         invokeRestart("muffleWarning")
[01:28:23.710]                     }
[01:28:23.710]                     else if (inherits(cond, "condition")) {
[01:28:23.710]                       if (!is.null(pattern)) {
[01:28:23.710]                         computeRestarts <- base::computeRestarts
[01:28:23.710]                         grepl <- base::grepl
[01:28:23.710]                         restarts <- computeRestarts(cond)
[01:28:23.710]                         for (restart in restarts) {
[01:28:23.710]                           name <- restart$name
[01:28:23.710]                           if (is.null(name)) 
[01:28:23.710]                             next
[01:28:23.710]                           if (!grepl(pattern, name)) 
[01:28:23.710]                             next
[01:28:23.710]                           invokeRestart(restart)
[01:28:23.710]                           muffled <- TRUE
[01:28:23.710]                           break
[01:28:23.710]                         }
[01:28:23.710]                       }
[01:28:23.710]                     }
[01:28:23.710]                     invisible(muffled)
[01:28:23.710]                   }
[01:28:23.710]                   muffleCondition(cond)
[01:28:23.710]                 })
[01:28:23.710]             }))
[01:28:23.710]             future::FutureResult(value = ...future.value$value, 
[01:28:23.710]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:23.710]                   ...future.rng), globalenv = if (FALSE) 
[01:28:23.710]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:23.710]                     ...future.globalenv.names))
[01:28:23.710]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:23.710]         }, condition = base::local({
[01:28:23.710]             c <- base::c
[01:28:23.710]             inherits <- base::inherits
[01:28:23.710]             invokeRestart <- base::invokeRestart
[01:28:23.710]             length <- base::length
[01:28:23.710]             list <- base::list
[01:28:23.710]             seq.int <- base::seq.int
[01:28:23.710]             signalCondition <- base::signalCondition
[01:28:23.710]             sys.calls <- base::sys.calls
[01:28:23.710]             `[[` <- base::`[[`
[01:28:23.710]             `+` <- base::`+`
[01:28:23.710]             `<<-` <- base::`<<-`
[01:28:23.710]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:23.710]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:23.710]                   3L)]
[01:28:23.710]             }
[01:28:23.710]             function(cond) {
[01:28:23.710]                 is_error <- inherits(cond, "error")
[01:28:23.710]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:23.710]                   NULL)
[01:28:23.710]                 if (is_error) {
[01:28:23.710]                   sessionInformation <- function() {
[01:28:23.710]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:23.710]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:23.710]                       search = base::search(), system = base::Sys.info())
[01:28:23.710]                   }
[01:28:23.710]                   ...future.conditions[[length(...future.conditions) + 
[01:28:23.710]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:23.710]                     cond$call), session = sessionInformation(), 
[01:28:23.710]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:23.710]                   signalCondition(cond)
[01:28:23.710]                 }
[01:28:23.710]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:23.710]                 "immediateCondition"))) {
[01:28:23.710]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:23.710]                   ...future.conditions[[length(...future.conditions) + 
[01:28:23.710]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:23.710]                   if (TRUE && !signal) {
[01:28:23.710]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:23.710]                     {
[01:28:23.710]                       inherits <- base::inherits
[01:28:23.710]                       invokeRestart <- base::invokeRestart
[01:28:23.710]                       is.null <- base::is.null
[01:28:23.710]                       muffled <- FALSE
[01:28:23.710]                       if (inherits(cond, "message")) {
[01:28:23.710]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:23.710]                         if (muffled) 
[01:28:23.710]                           invokeRestart("muffleMessage")
[01:28:23.710]                       }
[01:28:23.710]                       else if (inherits(cond, "warning")) {
[01:28:23.710]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:23.710]                         if (muffled) 
[01:28:23.710]                           invokeRestart("muffleWarning")
[01:28:23.710]                       }
[01:28:23.710]                       else if (inherits(cond, "condition")) {
[01:28:23.710]                         if (!is.null(pattern)) {
[01:28:23.710]                           computeRestarts <- base::computeRestarts
[01:28:23.710]                           grepl <- base::grepl
[01:28:23.710]                           restarts <- computeRestarts(cond)
[01:28:23.710]                           for (restart in restarts) {
[01:28:23.710]                             name <- restart$name
[01:28:23.710]                             if (is.null(name)) 
[01:28:23.710]                               next
[01:28:23.710]                             if (!grepl(pattern, name)) 
[01:28:23.710]                               next
[01:28:23.710]                             invokeRestart(restart)
[01:28:23.710]                             muffled <- TRUE
[01:28:23.710]                             break
[01:28:23.710]                           }
[01:28:23.710]                         }
[01:28:23.710]                       }
[01:28:23.710]                       invisible(muffled)
[01:28:23.710]                     }
[01:28:23.710]                     muffleCondition(cond, pattern = "^muffle")
[01:28:23.710]                   }
[01:28:23.710]                 }
[01:28:23.710]                 else {
[01:28:23.710]                   if (TRUE) {
[01:28:23.710]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:23.710]                     {
[01:28:23.710]                       inherits <- base::inherits
[01:28:23.710]                       invokeRestart <- base::invokeRestart
[01:28:23.710]                       is.null <- base::is.null
[01:28:23.710]                       muffled <- FALSE
[01:28:23.710]                       if (inherits(cond, "message")) {
[01:28:23.710]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:23.710]                         if (muffled) 
[01:28:23.710]                           invokeRestart("muffleMessage")
[01:28:23.710]                       }
[01:28:23.710]                       else if (inherits(cond, "warning")) {
[01:28:23.710]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:23.710]                         if (muffled) 
[01:28:23.710]                           invokeRestart("muffleWarning")
[01:28:23.710]                       }
[01:28:23.710]                       else if (inherits(cond, "condition")) {
[01:28:23.710]                         if (!is.null(pattern)) {
[01:28:23.710]                           computeRestarts <- base::computeRestarts
[01:28:23.710]                           grepl <- base::grepl
[01:28:23.710]                           restarts <- computeRestarts(cond)
[01:28:23.710]                           for (restart in restarts) {
[01:28:23.710]                             name <- restart$name
[01:28:23.710]                             if (is.null(name)) 
[01:28:23.710]                               next
[01:28:23.710]                             if (!grepl(pattern, name)) 
[01:28:23.710]                               next
[01:28:23.710]                             invokeRestart(restart)
[01:28:23.710]                             muffled <- TRUE
[01:28:23.710]                             break
[01:28:23.710]                           }
[01:28:23.710]                         }
[01:28:23.710]                       }
[01:28:23.710]                       invisible(muffled)
[01:28:23.710]                     }
[01:28:23.710]                     muffleCondition(cond, pattern = "^muffle")
[01:28:23.710]                   }
[01:28:23.710]                 }
[01:28:23.710]             }
[01:28:23.710]         }))
[01:28:23.710]     }, error = function(ex) {
[01:28:23.710]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:23.710]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:23.710]                 ...future.rng), started = ...future.startTime, 
[01:28:23.710]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:23.710]             version = "1.8"), class = "FutureResult")
[01:28:23.710]     }, finally = {
[01:28:23.710]         if (!identical(...future.workdir, getwd())) 
[01:28:23.710]             setwd(...future.workdir)
[01:28:23.710]         {
[01:28:23.710]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:23.710]                 ...future.oldOptions$nwarnings <- NULL
[01:28:23.710]             }
[01:28:23.710]             base::options(...future.oldOptions)
[01:28:23.710]             if (.Platform$OS.type == "windows") {
[01:28:23.710]                 old_names <- names(...future.oldEnvVars)
[01:28:23.710]                 envs <- base::Sys.getenv()
[01:28:23.710]                 names <- names(envs)
[01:28:23.710]                 common <- intersect(names, old_names)
[01:28:23.710]                 added <- setdiff(names, old_names)
[01:28:23.710]                 removed <- setdiff(old_names, names)
[01:28:23.710]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:23.710]                   envs[common]]
[01:28:23.710]                 NAMES <- toupper(changed)
[01:28:23.710]                 args <- list()
[01:28:23.710]                 for (kk in seq_along(NAMES)) {
[01:28:23.710]                   name <- changed[[kk]]
[01:28:23.710]                   NAME <- NAMES[[kk]]
[01:28:23.710]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:23.710]                     next
[01:28:23.710]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:23.710]                 }
[01:28:23.710]                 NAMES <- toupper(added)
[01:28:23.710]                 for (kk in seq_along(NAMES)) {
[01:28:23.710]                   name <- added[[kk]]
[01:28:23.710]                   NAME <- NAMES[[kk]]
[01:28:23.710]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:23.710]                     next
[01:28:23.710]                   args[[name]] <- ""
[01:28:23.710]                 }
[01:28:23.710]                 NAMES <- toupper(removed)
[01:28:23.710]                 for (kk in seq_along(NAMES)) {
[01:28:23.710]                   name <- removed[[kk]]
[01:28:23.710]                   NAME <- NAMES[[kk]]
[01:28:23.710]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:23.710]                     next
[01:28:23.710]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:23.710]                 }
[01:28:23.710]                 if (length(args) > 0) 
[01:28:23.710]                   base::do.call(base::Sys.setenv, args = args)
[01:28:23.710]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:23.710]             }
[01:28:23.710]             else {
[01:28:23.710]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:23.710]             }
[01:28:23.710]             {
[01:28:23.710]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:23.710]                   0L) {
[01:28:23.710]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:23.710]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:23.710]                   base::options(opts)
[01:28:23.710]                 }
[01:28:23.710]                 {
[01:28:23.710]                   {
[01:28:23.710]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:23.710]                     NULL
[01:28:23.710]                   }
[01:28:23.710]                   options(future.plan = NULL)
[01:28:23.710]                   if (is.na(NA_character_)) 
[01:28:23.710]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:23.710]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:23.710]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:23.710]                   {
[01:28:23.710]                     future <- SequentialFuture(..., envir = envir)
[01:28:23.710]                     if (!future$lazy) 
[01:28:23.710]                       future <- run(future)
[01:28:23.710]                     invisible(future)
[01:28:23.710]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:23.710]                 }
[01:28:23.710]             }
[01:28:23.710]         }
[01:28:23.710]     })
[01:28:23.710]     if (TRUE) {
[01:28:23.710]         base::sink(type = "output", split = FALSE)
[01:28:23.710]         if (TRUE) {
[01:28:23.710]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:23.710]         }
[01:28:23.710]         else {
[01:28:23.710]             ...future.result["stdout"] <- base::list(NULL)
[01:28:23.710]         }
[01:28:23.710]         base::close(...future.stdout)
[01:28:23.710]         ...future.stdout <- NULL
[01:28:23.710]     }
[01:28:23.710]     ...future.result$conditions <- ...future.conditions
[01:28:23.710]     ...future.result$finished <- base::Sys.time()
[01:28:23.710]     ...future.result
[01:28:23.710] }
[01:28:23.716] 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)
[01:28:23.734] receiveMessageFromWorker() for ClusterFuture ...
[01:28:23.734] - Validating connection of MultisessionFuture
[01:28:23.734] - received message: FutureResult
[01:28:23.735] - Received FutureResult
[01:28:23.735] - Erased future from FutureRegistry
[01:28:23.735] result() for ClusterFuture ...
[01:28:23.735] - result already collected: FutureResult
[01:28:23.735] result() for ClusterFuture ... done
[01:28:23.735] signalConditions() ...
[01:28:23.736]  - include = 'immediateCondition'
[01:28:23.736]  - exclude = 
[01:28:23.736]  - resignal = FALSE
[01:28:23.736]  - Number of conditions: 1
[01:28:23.736] signalConditions() ... done
[01:28:23.736] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: cfeec5f2-987d-97c4-cbb0-b2e17579921c
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:23.737] result() for ClusterFuture ...
[01:28:23.737] - result already collected: FutureResult
[01:28:23.737] result() for ClusterFuture ... done
[01:28:23.737] result() for ClusterFuture ...
[01:28:23.737] - result already collected: FutureResult
[01:28:23.738] result() for ClusterFuture ... done
[01:28:23.738] signalConditions() ...
[01:28:23.738]  - include = 'immediateCondition'
[01:28:23.738]  - exclude = 
[01:28:23.738]  - resignal = FALSE
[01:28:23.738]  - Number of conditions: 1
[01:28:23.739] 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!>
[01:28:23.739] result() for ClusterFuture ...
[01:28:23.739] - result already collected: FutureResult
[01:28:23.740] result() for ClusterFuture ... done
[01:28:23.740] result() for ClusterFuture ...
[01:28:23.740] - result already collected: FutureResult
[01:28:23.740] result() for ClusterFuture ... done
[01:28:23.740] signalConditions() ...
[01:28:23.740]  - include = 'immediateCondition'
[01:28:23.741]  - exclude = 
[01:28:23.741]  - resignal = FALSE
[01:28:23.741]  - Number of conditions: 1
[01:28:23.741] signalConditions() ... done
[01:28:23.741] Future state: 'finished'
[01:28:23.741] result() for ClusterFuture ...
[01:28:23.742] - result already collected: FutureResult
[01:28:23.742] result() for ClusterFuture ... done
[01:28:23.742] signalConditions() ...
[01:28:23.742]  - include = 'condition'
[01:28:23.742]  - exclude = 'immediateCondition'
[01:28:23.742]  - resignal = TRUE
[01:28:23.743]  - Number of conditions: 1
[01:28:23.743]  - Condition #1: 'simpleError', 'error', 'condition'
[01:28:23.743] 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!>
[01:28:23.744] result() for ClusterFuture ...
[01:28:23.744] - result already collected: FutureResult
[01:28:23.744] result() for ClusterFuture ... done
[01:28:23.744] result() for ClusterFuture ...
[01:28:23.744] - result already collected: FutureResult
[01:28:23.745] result() for ClusterFuture ... done
[01:28:23.745] signalConditions() ...
[01:28:23.745]  - include = 'immediateCondition'
[01:28:23.745]  - exclude = 
[01:28:23.745]  - resignal = FALSE
[01:28:23.745]  - Number of conditions: 1
[01:28:23.746] signalConditions() ... done
[01:28:23.746] Future state: 'finished'
[01:28:23.746] result() for ClusterFuture ...
[01:28:23.746] - result already collected: FutureResult
[01:28:23.746] result() for ClusterFuture ... done
[01:28:23.746] signalConditions() ...
[01:28:23.747]  - include = 'condition'
[01:28:23.747]  - exclude = 'immediateCondition'
[01:28:23.747]  - resignal = TRUE
[01:28:23.747]  - Number of conditions: 1
[01:28:23.747]  - Condition #1: 'simpleError', 'error', 'condition'
[01:28:23.747] 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!>
[01:28:23.750] getGlobalsAndPackages() ...
[01:28:23.750] 
[01:28:23.751] - globals: [0] <none>
[01:28:23.751] getGlobalsAndPackages() ... DONE
[01:28:23.763] Packages needed by the future expression (n = 0): <none>
[01:28:23.763] Packages needed by future strategies (n = 0): <none>
[01:28:23.764] {
[01:28:23.764]     {
[01:28:23.764]         {
[01:28:23.764]             ...future.startTime <- base::Sys.time()
[01:28:23.764]             {
[01:28:23.764]                 {
[01:28:23.764]                   {
[01:28:23.764]                     {
[01:28:23.764]                       base::local({
[01:28:23.764]                         has_future <- base::requireNamespace("future", 
[01:28:23.764]                           quietly = TRUE)
[01:28:23.764]                         if (has_future) {
[01:28:23.764]                           ns <- base::getNamespace("future")
[01:28:23.764]                           version <- ns[[".package"]][["version"]]
[01:28:23.764]                           if (is.null(version)) 
[01:28:23.764]                             version <- utils::packageVersion("future")
[01:28:23.764]                         }
[01:28:23.764]                         else {
[01:28:23.764]                           version <- NULL
[01:28:23.764]                         }
[01:28:23.764]                         if (!has_future || version < "1.8.0") {
[01:28:23.764]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:23.764]                             "", base::R.version$version.string), 
[01:28:23.764]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:23.764]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:23.764]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:23.764]                               "release", "version")], collapse = " "), 
[01:28:23.764]                             hostname = base::Sys.info()[["nodename"]])
[01:28:23.764]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:23.764]                             info)
[01:28:23.764]                           info <- base::paste(info, collapse = "; ")
[01:28:23.764]                           if (!has_future) {
[01:28:23.764]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:23.764]                               info)
[01:28:23.764]                           }
[01:28:23.764]                           else {
[01:28:23.764]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:23.764]                               info, version)
[01:28:23.764]                           }
[01:28:23.764]                           base::stop(msg)
[01:28:23.764]                         }
[01:28:23.764]                       })
[01:28:23.764]                     }
[01:28:23.764]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:23.764]                     base::options(mc.cores = 1L)
[01:28:23.764]                   }
[01:28:23.764]                   options(future.plan = NULL)
[01:28:23.764]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:23.764]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:23.764]                 }
[01:28:23.764]                 ...future.workdir <- getwd()
[01:28:23.764]             }
[01:28:23.764]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:23.764]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:23.764]         }
[01:28:23.764]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:23.764]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:23.764]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:23.764]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:23.764]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:23.764]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:23.764]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:23.764]             base::names(...future.oldOptions))
[01:28:23.764]     }
[01:28:23.764]     if (FALSE) {
[01:28:23.764]     }
[01:28:23.764]     else {
[01:28:23.764]         if (TRUE) {
[01:28:23.764]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:23.764]                 open = "w")
[01:28:23.764]         }
[01:28:23.764]         else {
[01:28:23.764]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:23.764]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:23.764]         }
[01:28:23.764]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:23.764]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:23.764]             base::sink(type = "output", split = FALSE)
[01:28:23.764]             base::close(...future.stdout)
[01:28:23.764]         }, add = TRUE)
[01:28:23.764]     }
[01:28:23.764]     ...future.frame <- base::sys.nframe()
[01:28:23.764]     ...future.conditions <- base::list()
[01:28:23.764]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:23.764]     if (FALSE) {
[01:28:23.764]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:23.764]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:23.764]     }
[01:28:23.764]     ...future.result <- base::tryCatch({
[01:28:23.764]         base::withCallingHandlers({
[01:28:23.764]             ...future.value <- base::withVisible(base::local({
[01:28:23.764]                 ...future.makeSendCondition <- base::local({
[01:28:23.764]                   sendCondition <- NULL
[01:28:23.764]                   function(frame = 1L) {
[01:28:23.764]                     if (is.function(sendCondition)) 
[01:28:23.764]                       return(sendCondition)
[01:28:23.764]                     ns <- getNamespace("parallel")
[01:28:23.764]                     if (exists("sendData", mode = "function", 
[01:28:23.764]                       envir = ns)) {
[01:28:23.764]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:23.764]                         envir = ns)
[01:28:23.764]                       envir <- sys.frame(frame)
[01:28:23.764]                       master <- NULL
[01:28:23.764]                       while (!identical(envir, .GlobalEnv) && 
[01:28:23.764]                         !identical(envir, emptyenv())) {
[01:28:23.764]                         if (exists("master", mode = "list", envir = envir, 
[01:28:23.764]                           inherits = FALSE)) {
[01:28:23.764]                           master <- get("master", mode = "list", 
[01:28:23.764]                             envir = envir, inherits = FALSE)
[01:28:23.764]                           if (inherits(master, c("SOCKnode", 
[01:28:23.764]                             "SOCK0node"))) {
[01:28:23.764]                             sendCondition <<- function(cond) {
[01:28:23.764]                               data <- list(type = "VALUE", value = cond, 
[01:28:23.764]                                 success = TRUE)
[01:28:23.764]                               parallel_sendData(master, data)
[01:28:23.764]                             }
[01:28:23.764]                             return(sendCondition)
[01:28:23.764]                           }
[01:28:23.764]                         }
[01:28:23.764]                         frame <- frame + 1L
[01:28:23.764]                         envir <- sys.frame(frame)
[01:28:23.764]                       }
[01:28:23.764]                     }
[01:28:23.764]                     sendCondition <<- function(cond) NULL
[01:28:23.764]                   }
[01:28:23.764]                 })
[01:28:23.764]                 withCallingHandlers({
[01:28:23.764]                   {
[01:28:23.764]                     stop(structure(list(message = "boom"), class = c("MyError", 
[01:28:23.764]                       "error", "condition")))
[01:28:23.764]                   }
[01:28:23.764]                 }, immediateCondition = function(cond) {
[01:28:23.764]                   sendCondition <- ...future.makeSendCondition()
[01:28:23.764]                   sendCondition(cond)
[01:28:23.764]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:23.764]                   {
[01:28:23.764]                     inherits <- base::inherits
[01:28:23.764]                     invokeRestart <- base::invokeRestart
[01:28:23.764]                     is.null <- base::is.null
[01:28:23.764]                     muffled <- FALSE
[01:28:23.764]                     if (inherits(cond, "message")) {
[01:28:23.764]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:23.764]                       if (muffled) 
[01:28:23.764]                         invokeRestart("muffleMessage")
[01:28:23.764]                     }
[01:28:23.764]                     else if (inherits(cond, "warning")) {
[01:28:23.764]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:23.764]                       if (muffled) 
[01:28:23.764]                         invokeRestart("muffleWarning")
[01:28:23.764]                     }
[01:28:23.764]                     else if (inherits(cond, "condition")) {
[01:28:23.764]                       if (!is.null(pattern)) {
[01:28:23.764]                         computeRestarts <- base::computeRestarts
[01:28:23.764]                         grepl <- base::grepl
[01:28:23.764]                         restarts <- computeRestarts(cond)
[01:28:23.764]                         for (restart in restarts) {
[01:28:23.764]                           name <- restart$name
[01:28:23.764]                           if (is.null(name)) 
[01:28:23.764]                             next
[01:28:23.764]                           if (!grepl(pattern, name)) 
[01:28:23.764]                             next
[01:28:23.764]                           invokeRestart(restart)
[01:28:23.764]                           muffled <- TRUE
[01:28:23.764]                           break
[01:28:23.764]                         }
[01:28:23.764]                       }
[01:28:23.764]                     }
[01:28:23.764]                     invisible(muffled)
[01:28:23.764]                   }
[01:28:23.764]                   muffleCondition(cond)
[01:28:23.764]                 })
[01:28:23.764]             }))
[01:28:23.764]             future::FutureResult(value = ...future.value$value, 
[01:28:23.764]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:23.764]                   ...future.rng), globalenv = if (FALSE) 
[01:28:23.764]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:23.764]                     ...future.globalenv.names))
[01:28:23.764]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:23.764]         }, condition = base::local({
[01:28:23.764]             c <- base::c
[01:28:23.764]             inherits <- base::inherits
[01:28:23.764]             invokeRestart <- base::invokeRestart
[01:28:23.764]             length <- base::length
[01:28:23.764]             list <- base::list
[01:28:23.764]             seq.int <- base::seq.int
[01:28:23.764]             signalCondition <- base::signalCondition
[01:28:23.764]             sys.calls <- base::sys.calls
[01:28:23.764]             `[[` <- base::`[[`
[01:28:23.764]             `+` <- base::`+`
[01:28:23.764]             `<<-` <- base::`<<-`
[01:28:23.764]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:23.764]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:23.764]                   3L)]
[01:28:23.764]             }
[01:28:23.764]             function(cond) {
[01:28:23.764]                 is_error <- inherits(cond, "error")
[01:28:23.764]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:23.764]                   NULL)
[01:28:23.764]                 if (is_error) {
[01:28:23.764]                   sessionInformation <- function() {
[01:28:23.764]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:23.764]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:23.764]                       search = base::search(), system = base::Sys.info())
[01:28:23.764]                   }
[01:28:23.764]                   ...future.conditions[[length(...future.conditions) + 
[01:28:23.764]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:23.764]                     cond$call), session = sessionInformation(), 
[01:28:23.764]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:23.764]                   signalCondition(cond)
[01:28:23.764]                 }
[01:28:23.764]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:23.764]                 "immediateCondition"))) {
[01:28:23.764]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:23.764]                   ...future.conditions[[length(...future.conditions) + 
[01:28:23.764]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:23.764]                   if (TRUE && !signal) {
[01:28:23.764]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:23.764]                     {
[01:28:23.764]                       inherits <- base::inherits
[01:28:23.764]                       invokeRestart <- base::invokeRestart
[01:28:23.764]                       is.null <- base::is.null
[01:28:23.764]                       muffled <- FALSE
[01:28:23.764]                       if (inherits(cond, "message")) {
[01:28:23.764]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:23.764]                         if (muffled) 
[01:28:23.764]                           invokeRestart("muffleMessage")
[01:28:23.764]                       }
[01:28:23.764]                       else if (inherits(cond, "warning")) {
[01:28:23.764]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:23.764]                         if (muffled) 
[01:28:23.764]                           invokeRestart("muffleWarning")
[01:28:23.764]                       }
[01:28:23.764]                       else if (inherits(cond, "condition")) {
[01:28:23.764]                         if (!is.null(pattern)) {
[01:28:23.764]                           computeRestarts <- base::computeRestarts
[01:28:23.764]                           grepl <- base::grepl
[01:28:23.764]                           restarts <- computeRestarts(cond)
[01:28:23.764]                           for (restart in restarts) {
[01:28:23.764]                             name <- restart$name
[01:28:23.764]                             if (is.null(name)) 
[01:28:23.764]                               next
[01:28:23.764]                             if (!grepl(pattern, name)) 
[01:28:23.764]                               next
[01:28:23.764]                             invokeRestart(restart)
[01:28:23.764]                             muffled <- TRUE
[01:28:23.764]                             break
[01:28:23.764]                           }
[01:28:23.764]                         }
[01:28:23.764]                       }
[01:28:23.764]                       invisible(muffled)
[01:28:23.764]                     }
[01:28:23.764]                     muffleCondition(cond, pattern = "^muffle")
[01:28:23.764]                   }
[01:28:23.764]                 }
[01:28:23.764]                 else {
[01:28:23.764]                   if (TRUE) {
[01:28:23.764]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:23.764]                     {
[01:28:23.764]                       inherits <- base::inherits
[01:28:23.764]                       invokeRestart <- base::invokeRestart
[01:28:23.764]                       is.null <- base::is.null
[01:28:23.764]                       muffled <- FALSE
[01:28:23.764]                       if (inherits(cond, "message")) {
[01:28:23.764]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:23.764]                         if (muffled) 
[01:28:23.764]                           invokeRestart("muffleMessage")
[01:28:23.764]                       }
[01:28:23.764]                       else if (inherits(cond, "warning")) {
[01:28:23.764]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:23.764]                         if (muffled) 
[01:28:23.764]                           invokeRestart("muffleWarning")
[01:28:23.764]                       }
[01:28:23.764]                       else if (inherits(cond, "condition")) {
[01:28:23.764]                         if (!is.null(pattern)) {
[01:28:23.764]                           computeRestarts <- base::computeRestarts
[01:28:23.764]                           grepl <- base::grepl
[01:28:23.764]                           restarts <- computeRestarts(cond)
[01:28:23.764]                           for (restart in restarts) {
[01:28:23.764]                             name <- restart$name
[01:28:23.764]                             if (is.null(name)) 
[01:28:23.764]                               next
[01:28:23.764]                             if (!grepl(pattern, name)) 
[01:28:23.764]                               next
[01:28:23.764]                             invokeRestart(restart)
[01:28:23.764]                             muffled <- TRUE
[01:28:23.764]                             break
[01:28:23.764]                           }
[01:28:23.764]                         }
[01:28:23.764]                       }
[01:28:23.764]                       invisible(muffled)
[01:28:23.764]                     }
[01:28:23.764]                     muffleCondition(cond, pattern = "^muffle")
[01:28:23.764]                   }
[01:28:23.764]                 }
[01:28:23.764]             }
[01:28:23.764]         }))
[01:28:23.764]     }, error = function(ex) {
[01:28:23.764]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:23.764]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:23.764]                 ...future.rng), started = ...future.startTime, 
[01:28:23.764]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:23.764]             version = "1.8"), class = "FutureResult")
[01:28:23.764]     }, finally = {
[01:28:23.764]         if (!identical(...future.workdir, getwd())) 
[01:28:23.764]             setwd(...future.workdir)
[01:28:23.764]         {
[01:28:23.764]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:23.764]                 ...future.oldOptions$nwarnings <- NULL
[01:28:23.764]             }
[01:28:23.764]             base::options(...future.oldOptions)
[01:28:23.764]             if (.Platform$OS.type == "windows") {
[01:28:23.764]                 old_names <- names(...future.oldEnvVars)
[01:28:23.764]                 envs <- base::Sys.getenv()
[01:28:23.764]                 names <- names(envs)
[01:28:23.764]                 common <- intersect(names, old_names)
[01:28:23.764]                 added <- setdiff(names, old_names)
[01:28:23.764]                 removed <- setdiff(old_names, names)
[01:28:23.764]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:23.764]                   envs[common]]
[01:28:23.764]                 NAMES <- toupper(changed)
[01:28:23.764]                 args <- list()
[01:28:23.764]                 for (kk in seq_along(NAMES)) {
[01:28:23.764]                   name <- changed[[kk]]
[01:28:23.764]                   NAME <- NAMES[[kk]]
[01:28:23.764]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:23.764]                     next
[01:28:23.764]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:23.764]                 }
[01:28:23.764]                 NAMES <- toupper(added)
[01:28:23.764]                 for (kk in seq_along(NAMES)) {
[01:28:23.764]                   name <- added[[kk]]
[01:28:23.764]                   NAME <- NAMES[[kk]]
[01:28:23.764]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:23.764]                     next
[01:28:23.764]                   args[[name]] <- ""
[01:28:23.764]                 }
[01:28:23.764]                 NAMES <- toupper(removed)
[01:28:23.764]                 for (kk in seq_along(NAMES)) {
[01:28:23.764]                   name <- removed[[kk]]
[01:28:23.764]                   NAME <- NAMES[[kk]]
[01:28:23.764]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:23.764]                     next
[01:28:23.764]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:23.764]                 }
[01:28:23.764]                 if (length(args) > 0) 
[01:28:23.764]                   base::do.call(base::Sys.setenv, args = args)
[01:28:23.764]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:23.764]             }
[01:28:23.764]             else {
[01:28:23.764]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:23.764]             }
[01:28:23.764]             {
[01:28:23.764]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:23.764]                   0L) {
[01:28:23.764]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:23.764]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:23.764]                   base::options(opts)
[01:28:23.764]                 }
[01:28:23.764]                 {
[01:28:23.764]                   {
[01:28:23.764]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:23.764]                     NULL
[01:28:23.764]                   }
[01:28:23.764]                   options(future.plan = NULL)
[01:28:23.764]                   if (is.na(NA_character_)) 
[01:28:23.764]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:23.764]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:23.764]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:23.764]                   {
[01:28:23.764]                     future <- SequentialFuture(..., envir = envir)
[01:28:23.764]                     if (!future$lazy) 
[01:28:23.764]                       future <- run(future)
[01:28:23.764]                     invisible(future)
[01:28:23.764]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:23.764]                 }
[01:28:23.764]             }
[01:28:23.764]         }
[01:28:23.764]     })
[01:28:23.764]     if (TRUE) {
[01:28:23.764]         base::sink(type = "output", split = FALSE)
[01:28:23.764]         if (TRUE) {
[01:28:23.764]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:23.764]         }
[01:28:23.764]         else {
[01:28:23.764]             ...future.result["stdout"] <- base::list(NULL)
[01:28:23.764]         }
[01:28:23.764]         base::close(...future.stdout)
[01:28:23.764]         ...future.stdout <- NULL
[01:28:23.764]     }
[01:28:23.764]     ...future.result$conditions <- ...future.conditions
[01:28:23.764]     ...future.result$finished <- base::Sys.time()
[01:28:23.764]     ...future.result
[01:28:23.764] }
[01:28:23.769] 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)
[01:28:23.786] receiveMessageFromWorker() for ClusterFuture ...
[01:28:23.786] - Validating connection of MultisessionFuture
[01:28:23.786] - received message: FutureResult
[01:28:23.786] - Received FutureResult
[01:28:23.787] - Erased future from FutureRegistry
[01:28:23.787] result() for ClusterFuture ...
[01:28:23.787] - result already collected: FutureResult
[01:28:23.787] result() for ClusterFuture ... done
[01:28:23.787] signalConditions() ...
[01:28:23.787]  - include = 'immediateCondition'
[01:28:23.788]  - exclude = 
[01:28:23.788]  - resignal = FALSE
[01:28:23.788]  - Number of conditions: 1
[01:28:23.788] signalConditions() ... done
[01:28:23.788] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: cfeec5f2-987d-97c4-cbb0-b2e17579921c
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:23.789] result() for ClusterFuture ...
[01:28:23.789] - result already collected: FutureResult
[01:28:23.789] result() for ClusterFuture ... done
[01:28:23.789] result() for ClusterFuture ...
[01:28:23.789] - result already collected: FutureResult
[01:28:23.789] result() for ClusterFuture ... done
[01:28:23.790] signalConditions() ...
[01:28:23.790]  - include = 'immediateCondition'
[01:28:23.790]  - exclude = 
[01:28:23.790]  - resignal = FALSE
[01:28:23.790]  - Number of conditions: 1
[01:28:23.790] signalConditions() ... done
<MyError: boom>
[01:28:23.791] result() for ClusterFuture ...
[01:28:23.791] - result already collected: FutureResult
[01:28:23.791] result() for ClusterFuture ... done
[01:28:23.791] result() for ClusterFuture ...
[01:28:23.791] - result already collected: FutureResult
[01:28:23.791] result() for ClusterFuture ... done
[01:28:23.792] signalConditions() ...
[01:28:23.792]  - include = 'immediateCondition'
[01:28:23.792]  - exclude = 
[01:28:23.792]  - resignal = FALSE
[01:28:23.792]  - Number of conditions: 1
[01:28:23.792] signalConditions() ... done
[01:28:23.793] Future state: 'finished'
[01:28:23.793] result() for ClusterFuture ...
[01:28:23.793] - result already collected: FutureResult
[01:28:23.794] result() for ClusterFuture ... done
[01:28:23.794] signalConditions() ...
[01:28:23.794]  - include = 'condition'
[01:28:23.794]  - exclude = 'immediateCondition'
[01:28:23.795]  - resignal = TRUE
[01:28:23.795]  - Number of conditions: 1
[01:28:23.795]  - Condition #1: 'MyError', 'error', 'condition'
[01:28:23.795] signalConditions() ... done
Testing with 2 cores ... DONE
> 
> 
> message("*** multisession() - too large globals ...")
*** multisession() - too large globals ...
> ooptsT <- options(future.globals.maxSize = object.size(1:1014))
> 
> limit <- getOption("future.globals.maxSize")
> cat(sprintf("Max total size of globals: %g bytes\n", limit))
Max total size of globals: 4104 bytes
> 
> for (workers in unique(c(1L, availableCores()))) {
+   ## Speed up CRAN checks: Skip on CRAN Windows 32-bit
+   if (!fullTest && isWin32) next
+   
+   message("Max number of sessions: ", workers)
+ 
+   ## A large object
+   a <- 1:1014
+   yTruth <- sum(a)
+   size <- object.size(a)
+   cat(sprintf("a: %g bytes\n", size))
+   f <- multisession({ sum(a) }, globals = TRUE, workers = workers)
+   print(f)
+   rm(list = "a")
+   v <- value(f)
+   print(v)
+   stopifnot(v == yTruth)
+ 
+ 
+   ## A too large object
+   a <- 1:1015
+   yTruth <- sum(a)
+   size <- object.size(a)
+   cat(sprintf("a: %g bytes\n", size))
+   res <- try(f <- multisession({ sum(a) }, globals = TRUE, workers = workers), silent = TRUE)
+   rm(list = "a")
+   stopifnot(inherits(res, "try-error"))
+ } ## for (workers in ...)
Max number of sessions: 1
a: 4104 bytes
[01:28:23.818] getGlobalsAndPackages() ...
[01:28:23.818] Searching for globals...
[01:28:23.819] - globals found: [3] '{', 'sum', 'a'
[01:28:23.820] Searching for globals ... DONE
[01:28:23.820] Resolving globals: FALSE
[01:28:23.820] The total size of the 1 globals is 4.01 KiB (4104 bytes)
[01:28:23.821] The total size of the 1 globals exported for future expression ('{; sum(a); }') is 4.01 KiB.. This exceeds the maximum allowed size of 4.01 KiB (option 'future.globals.maxSize'). There is one global: 'a' (4.01 KiB of class 'numeric')
[01:28:23.821] - globals: [1] 'a'
[01:28:23.821] 
[01:28:23.821] getGlobalsAndPackages() ... DONE
SequentialFuture:
Label: '<none>'
Expression:
{
    sum(a)
}
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 4.01 KiB (integer 'a' of 4.01 KiB)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: FALSE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: cfeec5f2-987d-97c4-cbb0-b2e17579921c
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:23.822] Packages needed by the future expression (n = 0): <none>
[01:28:23.823] Packages needed by future strategies (n = 0): <none>
[01:28:23.823] {
[01:28:23.823]     {
[01:28:23.823]         {
[01:28:23.823]             ...future.startTime <- base::Sys.time()
[01:28:23.823]             {
[01:28:23.823]                 {
[01:28:23.823]                   {
[01:28:23.823]                     base::local({
[01:28:23.823]                       has_future <- base::requireNamespace("future", 
[01:28:23.823]                         quietly = TRUE)
[01:28:23.823]                       if (has_future) {
[01:28:23.823]                         ns <- base::getNamespace("future")
[01:28:23.823]                         version <- ns[[".package"]][["version"]]
[01:28:23.823]                         if (is.null(version)) 
[01:28:23.823]                           version <- utils::packageVersion("future")
[01:28:23.823]                       }
[01:28:23.823]                       else {
[01:28:23.823]                         version <- NULL
[01:28:23.823]                       }
[01:28:23.823]                       if (!has_future || version < "1.8.0") {
[01:28:23.823]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:23.823]                           "", base::R.version$version.string), 
[01:28:23.823]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:23.823]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:23.823]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:23.823]                             "release", "version")], collapse = " "), 
[01:28:23.823]                           hostname = base::Sys.info()[["nodename"]])
[01:28:23.823]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:23.823]                           info)
[01:28:23.823]                         info <- base::paste(info, collapse = "; ")
[01:28:23.823]                         if (!has_future) {
[01:28:23.823]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:23.823]                             info)
[01:28:23.823]                         }
[01:28:23.823]                         else {
[01:28:23.823]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:23.823]                             info, version)
[01:28:23.823]                         }
[01:28:23.823]                         base::stop(msg)
[01:28:23.823]                       }
[01:28:23.823]                     })
[01:28:23.823]                   }
[01:28:23.823]                   options(future.plan = NULL)
[01:28:23.823]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:23.823]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:23.823]                 }
[01:28:23.823]                 ...future.workdir <- getwd()
[01:28:23.823]             }
[01:28:23.823]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:23.823]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:23.823]         }
[01:28:23.823]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:23.823]             future.globals.maxSize = 4104, future.globals.method = NULL, 
[01:28:23.823]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:23.823]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:23.823]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:23.823]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:23.823]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:23.823]             base::names(...future.oldOptions))
[01:28:23.823]     }
[01:28:23.823]     if (FALSE) {
[01:28:23.823]     }
[01:28:23.823]     else {
[01:28:23.823]         if (TRUE) {
[01:28:23.823]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:23.823]                 open = "w")
[01:28:23.823]         }
[01:28:23.823]         else {
[01:28:23.823]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:23.823]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:23.823]         }
[01:28:23.823]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:23.823]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:23.823]             base::sink(type = "output", split = FALSE)
[01:28:23.823]             base::close(...future.stdout)
[01:28:23.823]         }, add = TRUE)
[01:28:23.823]     }
[01:28:23.823]     ...future.frame <- base::sys.nframe()
[01:28:23.823]     ...future.conditions <- base::list()
[01:28:23.823]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:23.823]     if (FALSE) {
[01:28:23.823]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:23.823]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:23.823]     }
[01:28:23.823]     ...future.result <- base::tryCatch({
[01:28:23.823]         base::withCallingHandlers({
[01:28:23.823]             ...future.value <- base::withVisible(base::local({
[01:28:23.823]                 sum(a)
[01:28:23.823]             }))
[01:28:23.823]             future::FutureResult(value = ...future.value$value, 
[01:28:23.823]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:23.823]                   ...future.rng), globalenv = if (FALSE) 
[01:28:23.823]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:23.823]                     ...future.globalenv.names))
[01:28:23.823]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:23.823]         }, condition = base::local({
[01:28:23.823]             c <- base::c
[01:28:23.823]             inherits <- base::inherits
[01:28:23.823]             invokeRestart <- base::invokeRestart
[01:28:23.823]             length <- base::length
[01:28:23.823]             list <- base::list
[01:28:23.823]             seq.int <- base::seq.int
[01:28:23.823]             signalCondition <- base::signalCondition
[01:28:23.823]             sys.calls <- base::sys.calls
[01:28:23.823]             `[[` <- base::`[[`
[01:28:23.823]             `+` <- base::`+`
[01:28:23.823]             `<<-` <- base::`<<-`
[01:28:23.823]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:23.823]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:23.823]                   3L)]
[01:28:23.823]             }
[01:28:23.823]             function(cond) {
[01:28:23.823]                 is_error <- inherits(cond, "error")
[01:28:23.823]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:23.823]                   NULL)
[01:28:23.823]                 if (is_error) {
[01:28:23.823]                   sessionInformation <- function() {
[01:28:23.823]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:23.823]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:23.823]                       search = base::search(), system = base::Sys.info())
[01:28:23.823]                   }
[01:28:23.823]                   ...future.conditions[[length(...future.conditions) + 
[01:28:23.823]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:23.823]                     cond$call), session = sessionInformation(), 
[01:28:23.823]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:23.823]                   signalCondition(cond)
[01:28:23.823]                 }
[01:28:23.823]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:23.823]                 "immediateCondition"))) {
[01:28:23.823]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:23.823]                   ...future.conditions[[length(...future.conditions) + 
[01:28:23.823]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:23.823]                   if (TRUE && !signal) {
[01:28:23.823]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:23.823]                     {
[01:28:23.823]                       inherits <- base::inherits
[01:28:23.823]                       invokeRestart <- base::invokeRestart
[01:28:23.823]                       is.null <- base::is.null
[01:28:23.823]                       muffled <- FALSE
[01:28:23.823]                       if (inherits(cond, "message")) {
[01:28:23.823]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:23.823]                         if (muffled) 
[01:28:23.823]                           invokeRestart("muffleMessage")
[01:28:23.823]                       }
[01:28:23.823]                       else if (inherits(cond, "warning")) {
[01:28:23.823]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:23.823]                         if (muffled) 
[01:28:23.823]                           invokeRestart("muffleWarning")
[01:28:23.823]                       }
[01:28:23.823]                       else if (inherits(cond, "condition")) {
[01:28:23.823]                         if (!is.null(pattern)) {
[01:28:23.823]                           computeRestarts <- base::computeRestarts
[01:28:23.823]                           grepl <- base::grepl
[01:28:23.823]                           restarts <- computeRestarts(cond)
[01:28:23.823]                           for (restart in restarts) {
[01:28:23.823]                             name <- restart$name
[01:28:23.823]                             if (is.null(name)) 
[01:28:23.823]                               next
[01:28:23.823]                             if (!grepl(pattern, name)) 
[01:28:23.823]                               next
[01:28:23.823]                             invokeRestart(restart)
[01:28:23.823]                             muffled <- TRUE
[01:28:23.823]                             break
[01:28:23.823]                           }
[01:28:23.823]                         }
[01:28:23.823]                       }
[01:28:23.823]                       invisible(muffled)
[01:28:23.823]                     }
[01:28:23.823]                     muffleCondition(cond, pattern = "^muffle")
[01:28:23.823]                   }
[01:28:23.823]                 }
[01:28:23.823]                 else {
[01:28:23.823]                   if (TRUE) {
[01:28:23.823]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:23.823]                     {
[01:28:23.823]                       inherits <- base::inherits
[01:28:23.823]                       invokeRestart <- base::invokeRestart
[01:28:23.823]                       is.null <- base::is.null
[01:28:23.823]                       muffled <- FALSE
[01:28:23.823]                       if (inherits(cond, "message")) {
[01:28:23.823]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:23.823]                         if (muffled) 
[01:28:23.823]                           invokeRestart("muffleMessage")
[01:28:23.823]                       }
[01:28:23.823]                       else if (inherits(cond, "warning")) {
[01:28:23.823]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:23.823]                         if (muffled) 
[01:28:23.823]                           invokeRestart("muffleWarning")
[01:28:23.823]                       }
[01:28:23.823]                       else if (inherits(cond, "condition")) {
[01:28:23.823]                         if (!is.null(pattern)) {
[01:28:23.823]                           computeRestarts <- base::computeRestarts
[01:28:23.823]                           grepl <- base::grepl
[01:28:23.823]                           restarts <- computeRestarts(cond)
[01:28:23.823]                           for (restart in restarts) {
[01:28:23.823]                             name <- restart$name
[01:28:23.823]                             if (is.null(name)) 
[01:28:23.823]                               next
[01:28:23.823]                             if (!grepl(pattern, name)) 
[01:28:23.823]                               next
[01:28:23.823]                             invokeRestart(restart)
[01:28:23.823]                             muffled <- TRUE
[01:28:23.823]                             break
[01:28:23.823]                           }
[01:28:23.823]                         }
[01:28:23.823]                       }
[01:28:23.823]                       invisible(muffled)
[01:28:23.823]                     }
[01:28:23.823]                     muffleCondition(cond, pattern = "^muffle")
[01:28:23.823]                   }
[01:28:23.823]                 }
[01:28:23.823]             }
[01:28:23.823]         }))
[01:28:23.823]     }, error = function(ex) {
[01:28:23.823]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:23.823]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:23.823]                 ...future.rng), started = ...future.startTime, 
[01:28:23.823]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:23.823]             version = "1.8"), class = "FutureResult")
[01:28:23.823]     }, finally = {
[01:28:23.823]         if (!identical(...future.workdir, getwd())) 
[01:28:23.823]             setwd(...future.workdir)
[01:28:23.823]         {
[01:28:23.823]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:23.823]                 ...future.oldOptions$nwarnings <- NULL
[01:28:23.823]             }
[01:28:23.823]             base::options(...future.oldOptions)
[01:28:23.823]             if (.Platform$OS.type == "windows") {
[01:28:23.823]                 old_names <- names(...future.oldEnvVars)
[01:28:23.823]                 envs <- base::Sys.getenv()
[01:28:23.823]                 names <- names(envs)
[01:28:23.823]                 common <- intersect(names, old_names)
[01:28:23.823]                 added <- setdiff(names, old_names)
[01:28:23.823]                 removed <- setdiff(old_names, names)
[01:28:23.823]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:23.823]                   envs[common]]
[01:28:23.823]                 NAMES <- toupper(changed)
[01:28:23.823]                 args <- list()
[01:28:23.823]                 for (kk in seq_along(NAMES)) {
[01:28:23.823]                   name <- changed[[kk]]
[01:28:23.823]                   NAME <- NAMES[[kk]]
[01:28:23.823]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:23.823]                     next
[01:28:23.823]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:23.823]                 }
[01:28:23.823]                 NAMES <- toupper(added)
[01:28:23.823]                 for (kk in seq_along(NAMES)) {
[01:28:23.823]                   name <- added[[kk]]
[01:28:23.823]                   NAME <- NAMES[[kk]]
[01:28:23.823]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:23.823]                     next
[01:28:23.823]                   args[[name]] <- ""
[01:28:23.823]                 }
[01:28:23.823]                 NAMES <- toupper(removed)
[01:28:23.823]                 for (kk in seq_along(NAMES)) {
[01:28:23.823]                   name <- removed[[kk]]
[01:28:23.823]                   NAME <- NAMES[[kk]]
[01:28:23.823]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:23.823]                     next
[01:28:23.823]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:23.823]                 }
[01:28:23.823]                 if (length(args) > 0) 
[01:28:23.823]                   base::do.call(base::Sys.setenv, args = args)
[01:28:23.823]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:23.823]             }
[01:28:23.823]             else {
[01:28:23.823]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:23.823]             }
[01:28:23.823]             {
[01:28:23.823]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:23.823]                   0L) {
[01:28:23.823]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:23.823]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:23.823]                   base::options(opts)
[01:28:23.823]                 }
[01:28:23.823]                 {
[01:28:23.823]                   {
[01:28:23.823]                     NULL
[01:28:23.823]                     RNGkind("Mersenne-Twister")
[01:28:23.823]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:23.823]                       inherits = FALSE)
[01:28:23.823]                   }
[01:28:23.823]                   options(future.plan = NULL)
[01:28:23.823]                   if (is.na(NA_character_)) 
[01:28:23.823]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:23.823]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:23.823]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:23.823]                   {
[01:28:23.823]                     future <- SequentialFuture(..., envir = envir)
[01:28:23.823]                     if (!future$lazy) 
[01:28:23.823]                       future <- run(future)
[01:28:23.823]                     invisible(future)
[01:28:23.823]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:23.823]                 }
[01:28:23.823]             }
[01:28:23.823]         }
[01:28:23.823]     })
[01:28:23.823]     if (TRUE) {
[01:28:23.823]         base::sink(type = "output", split = FALSE)
[01:28:23.823]         if (TRUE) {
[01:28:23.823]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:23.823]         }
[01:28:23.823]         else {
[01:28:23.823]             ...future.result["stdout"] <- base::list(NULL)
[01:28:23.823]         }
[01:28:23.823]         base::close(...future.stdout)
[01:28:23.823]         ...future.stdout <- NULL
[01:28:23.823]     }
[01:28:23.823]     ...future.result$conditions <- ...future.conditions
[01:28:23.823]     ...future.result$finished <- base::Sys.time()
[01:28:23.823]     ...future.result
[01:28:23.823] }
[01:28:23.827] assign_globals() ...
[01:28:23.827] List of 1
[01:28:23.827]  $ a: int [1:1014] 1 2 3 4 5 6 7 8 9 10 ...
[01:28:23.827]  - attr(*, "where")=List of 1
[01:28:23.827]   ..$ a:<environment: R_EmptyEnv> 
[01:28:23.827]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:23.827]  - attr(*, "resolved")= logi FALSE
[01:28:23.827]  - attr(*, "total_size")= num 4104
[01:28:23.830] - copied 'a' to environment
[01:28:23.830] assign_globals() ... done
[01:28:23.830] plan(): Setting new future strategy stack:
[01:28:23.831] List of future strategies:
[01:28:23.831] 1. sequential:
[01:28:23.831]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:23.831]    - tweaked: FALSE
[01:28:23.831]    - call: NULL
[01:28:23.831] plan(): nbrOfWorkers() = 1
[01:28:23.832] plan(): Setting new future strategy stack:
[01:28:23.833] List of future strategies:
[01:28:23.833] 1. sequential:
[01:28:23.833]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:23.833]    - tweaked: FALSE
[01:28:23.833]    - call: future::plan("sequential")
[01:28:23.833] plan(): nbrOfWorkers() = 1
[01:28:23.833] SequentialFuture started (and completed)
[1] 514605
a: 4112 bytes
[01:28:23.834] getGlobalsAndPackages() ...
[01:28:23.834] Searching for globals...
[01:28:23.835] - globals found: [3] '{', 'sum', 'a'
[01:28:23.835] Searching for globals ... DONE
[01:28:23.835] Resolving globals: FALSE
[01:28:23.836] The total size of the 1 globals is 4.02 KiB (4112 bytes)
[01:28:23.836] The total size of the 1 globals exported for future expression ('{; sum(a); }') is 4.02 KiB.. This exceeds the maximum allowed size of 4.01 KiB (option 'future.globals.maxSize'). There is one global: 'a' (4.02 KiB of class 'numeric')
Max number of sessions: 2
a: 4104 bytes
[01:28:23.837] getGlobalsAndPackages() ...
[01:28:23.837] Searching for globals...
[01:28:23.838] - globals found: [3] '{', 'sum', 'a'
[01:28:23.838] Searching for globals ... DONE
[01:28:23.839] Resolving globals: FALSE
[01:28:23.839] The total size of the 1 globals is 4.01 KiB (4104 bytes)
[01:28:23.840] The total size of the 1 globals exported for future expression ('{; sum(a); }') is 4.01 KiB.. This exceeds the maximum allowed size of 4.01 KiB (option 'future.globals.maxSize'). There is one global: 'a' (4.01 KiB of class 'numeric')
[01:28:23.840] - globals: [1] 'a'
[01:28:23.840] 
[01:28:23.840] getGlobalsAndPackages() ... DONE
[01:28:23.852] Packages needed by the future expression (n = 0): <none>
[01:28:23.852] Packages needed by future strategies (n = 0): <none>
[01:28:23.853] {
[01:28:23.853]     {
[01:28:23.853]         {
[01:28:23.853]             ...future.startTime <- base::Sys.time()
[01:28:23.853]             {
[01:28:23.853]                 {
[01:28:23.853]                   {
[01:28:23.853]                     {
[01:28:23.853]                       base::local({
[01:28:23.853]                         has_future <- base::requireNamespace("future", 
[01:28:23.853]                           quietly = TRUE)
[01:28:23.853]                         if (has_future) {
[01:28:23.853]                           ns <- base::getNamespace("future")
[01:28:23.853]                           version <- ns[[".package"]][["version"]]
[01:28:23.853]                           if (is.null(version)) 
[01:28:23.853]                             version <- utils::packageVersion("future")
[01:28:23.853]                         }
[01:28:23.853]                         else {
[01:28:23.853]                           version <- NULL
[01:28:23.853]                         }
[01:28:23.853]                         if (!has_future || version < "1.8.0") {
[01:28:23.853]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:23.853]                             "", base::R.version$version.string), 
[01:28:23.853]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:23.853]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:23.853]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:23.853]                               "release", "version")], collapse = " "), 
[01:28:23.853]                             hostname = base::Sys.info()[["nodename"]])
[01:28:23.853]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:23.853]                             info)
[01:28:23.853]                           info <- base::paste(info, collapse = "; ")
[01:28:23.853]                           if (!has_future) {
[01:28:23.853]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:23.853]                               info)
[01:28:23.853]                           }
[01:28:23.853]                           else {
[01:28:23.853]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:23.853]                               info, version)
[01:28:23.853]                           }
[01:28:23.853]                           base::stop(msg)
[01:28:23.853]                         }
[01:28:23.853]                       })
[01:28:23.853]                     }
[01:28:23.853]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:23.853]                     base::options(mc.cores = 1L)
[01:28:23.853]                   }
[01:28:23.853]                   options(future.plan = NULL)
[01:28:23.853]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:23.853]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:23.853]                 }
[01:28:23.853]                 ...future.workdir <- getwd()
[01:28:23.853]             }
[01:28:23.853]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:23.853]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:23.853]         }
[01:28:23.853]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:23.853]             future.globals.maxSize = 4104, future.globals.method = NULL, 
[01:28:23.853]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:23.853]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:23.853]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:23.853]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:23.853]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:23.853]             base::names(...future.oldOptions))
[01:28:23.853]     }
[01:28:23.853]     if (FALSE) {
[01:28:23.853]     }
[01:28:23.853]     else {
[01:28:23.853]         if (TRUE) {
[01:28:23.853]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:23.853]                 open = "w")
[01:28:23.853]         }
[01:28:23.853]         else {
[01:28:23.853]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:23.853]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:23.853]         }
[01:28:23.853]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:23.853]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:23.853]             base::sink(type = "output", split = FALSE)
[01:28:23.853]             base::close(...future.stdout)
[01:28:23.853]         }, add = TRUE)
[01:28:23.853]     }
[01:28:23.853]     ...future.frame <- base::sys.nframe()
[01:28:23.853]     ...future.conditions <- base::list()
[01:28:23.853]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:23.853]     if (FALSE) {
[01:28:23.853]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:23.853]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:23.853]     }
[01:28:23.853]     ...future.result <- base::tryCatch({
[01:28:23.853]         base::withCallingHandlers({
[01:28:23.853]             ...future.value <- base::withVisible(base::local({
[01:28:23.853]                 ...future.makeSendCondition <- base::local({
[01:28:23.853]                   sendCondition <- NULL
[01:28:23.853]                   function(frame = 1L) {
[01:28:23.853]                     if (is.function(sendCondition)) 
[01:28:23.853]                       return(sendCondition)
[01:28:23.853]                     ns <- getNamespace("parallel")
[01:28:23.853]                     if (exists("sendData", mode = "function", 
[01:28:23.853]                       envir = ns)) {
[01:28:23.853]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:23.853]                         envir = ns)
[01:28:23.853]                       envir <- sys.frame(frame)
[01:28:23.853]                       master <- NULL
[01:28:23.853]                       while (!identical(envir, .GlobalEnv) && 
[01:28:23.853]                         !identical(envir, emptyenv())) {
[01:28:23.853]                         if (exists("master", mode = "list", envir = envir, 
[01:28:23.853]                           inherits = FALSE)) {
[01:28:23.853]                           master <- get("master", mode = "list", 
[01:28:23.853]                             envir = envir, inherits = FALSE)
[01:28:23.853]                           if (inherits(master, c("SOCKnode", 
[01:28:23.853]                             "SOCK0node"))) {
[01:28:23.853]                             sendCondition <<- function(cond) {
[01:28:23.853]                               data <- list(type = "VALUE", value = cond, 
[01:28:23.853]                                 success = TRUE)
[01:28:23.853]                               parallel_sendData(master, data)
[01:28:23.853]                             }
[01:28:23.853]                             return(sendCondition)
[01:28:23.853]                           }
[01:28:23.853]                         }
[01:28:23.853]                         frame <- frame + 1L
[01:28:23.853]                         envir <- sys.frame(frame)
[01:28:23.853]                       }
[01:28:23.853]                     }
[01:28:23.853]                     sendCondition <<- function(cond) NULL
[01:28:23.853]                   }
[01:28:23.853]                 })
[01:28:23.853]                 withCallingHandlers({
[01:28:23.853]                   {
[01:28:23.853]                     sum(a)
[01:28:23.853]                   }
[01:28:23.853]                 }, immediateCondition = function(cond) {
[01:28:23.853]                   sendCondition <- ...future.makeSendCondition()
[01:28:23.853]                   sendCondition(cond)
[01:28:23.853]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:23.853]                   {
[01:28:23.853]                     inherits <- base::inherits
[01:28:23.853]                     invokeRestart <- base::invokeRestart
[01:28:23.853]                     is.null <- base::is.null
[01:28:23.853]                     muffled <- FALSE
[01:28:23.853]                     if (inherits(cond, "message")) {
[01:28:23.853]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:23.853]                       if (muffled) 
[01:28:23.853]                         invokeRestart("muffleMessage")
[01:28:23.853]                     }
[01:28:23.853]                     else if (inherits(cond, "warning")) {
[01:28:23.853]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:23.853]                       if (muffled) 
[01:28:23.853]                         invokeRestart("muffleWarning")
[01:28:23.853]                     }
[01:28:23.853]                     else if (inherits(cond, "condition")) {
[01:28:23.853]                       if (!is.null(pattern)) {
[01:28:23.853]                         computeRestarts <- base::computeRestarts
[01:28:23.853]                         grepl <- base::grepl
[01:28:23.853]                         restarts <- computeRestarts(cond)
[01:28:23.853]                         for (restart in restarts) {
[01:28:23.853]                           name <- restart$name
[01:28:23.853]                           if (is.null(name)) 
[01:28:23.853]                             next
[01:28:23.853]                           if (!grepl(pattern, name)) 
[01:28:23.853]                             next
[01:28:23.853]                           invokeRestart(restart)
[01:28:23.853]                           muffled <- TRUE
[01:28:23.853]                           break
[01:28:23.853]                         }
[01:28:23.853]                       }
[01:28:23.853]                     }
[01:28:23.853]                     invisible(muffled)
[01:28:23.853]                   }
[01:28:23.853]                   muffleCondition(cond)
[01:28:23.853]                 })
[01:28:23.853]             }))
[01:28:23.853]             future::FutureResult(value = ...future.value$value, 
[01:28:23.853]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:23.853]                   ...future.rng), globalenv = if (FALSE) 
[01:28:23.853]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:23.853]                     ...future.globalenv.names))
[01:28:23.853]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:23.853]         }, condition = base::local({
[01:28:23.853]             c <- base::c
[01:28:23.853]             inherits <- base::inherits
[01:28:23.853]             invokeRestart <- base::invokeRestart
[01:28:23.853]             length <- base::length
[01:28:23.853]             list <- base::list
[01:28:23.853]             seq.int <- base::seq.int
[01:28:23.853]             signalCondition <- base::signalCondition
[01:28:23.853]             sys.calls <- base::sys.calls
[01:28:23.853]             `[[` <- base::`[[`
[01:28:23.853]             `+` <- base::`+`
[01:28:23.853]             `<<-` <- base::`<<-`
[01:28:23.853]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:23.853]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:23.853]                   3L)]
[01:28:23.853]             }
[01:28:23.853]             function(cond) {
[01:28:23.853]                 is_error <- inherits(cond, "error")
[01:28:23.853]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:23.853]                   NULL)
[01:28:23.853]                 if (is_error) {
[01:28:23.853]                   sessionInformation <- function() {
[01:28:23.853]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:23.853]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:23.853]                       search = base::search(), system = base::Sys.info())
[01:28:23.853]                   }
[01:28:23.853]                   ...future.conditions[[length(...future.conditions) + 
[01:28:23.853]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:23.853]                     cond$call), session = sessionInformation(), 
[01:28:23.853]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:23.853]                   signalCondition(cond)
[01:28:23.853]                 }
[01:28:23.853]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:23.853]                 "immediateCondition"))) {
[01:28:23.853]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:23.853]                   ...future.conditions[[length(...future.conditions) + 
[01:28:23.853]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:23.853]                   if (TRUE && !signal) {
[01:28:23.853]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:23.853]                     {
[01:28:23.853]                       inherits <- base::inherits
[01:28:23.853]                       invokeRestart <- base::invokeRestart
[01:28:23.853]                       is.null <- base::is.null
[01:28:23.853]                       muffled <- FALSE
[01:28:23.853]                       if (inherits(cond, "message")) {
[01:28:23.853]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:23.853]                         if (muffled) 
[01:28:23.853]                           invokeRestart("muffleMessage")
[01:28:23.853]                       }
[01:28:23.853]                       else if (inherits(cond, "warning")) {
[01:28:23.853]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:23.853]                         if (muffled) 
[01:28:23.853]                           invokeRestart("muffleWarning")
[01:28:23.853]                       }
[01:28:23.853]                       else if (inherits(cond, "condition")) {
[01:28:23.853]                         if (!is.null(pattern)) {
[01:28:23.853]                           computeRestarts <- base::computeRestarts
[01:28:23.853]                           grepl <- base::grepl
[01:28:23.853]                           restarts <- computeRestarts(cond)
[01:28:23.853]                           for (restart in restarts) {
[01:28:23.853]                             name <- restart$name
[01:28:23.853]                             if (is.null(name)) 
[01:28:23.853]                               next
[01:28:23.853]                             if (!grepl(pattern, name)) 
[01:28:23.853]                               next
[01:28:23.853]                             invokeRestart(restart)
[01:28:23.853]                             muffled <- TRUE
[01:28:23.853]                             break
[01:28:23.853]                           }
[01:28:23.853]                         }
[01:28:23.853]                       }
[01:28:23.853]                       invisible(muffled)
[01:28:23.853]                     }
[01:28:23.853]                     muffleCondition(cond, pattern = "^muffle")
[01:28:23.853]                   }
[01:28:23.853]                 }
[01:28:23.853]                 else {
[01:28:23.853]                   if (TRUE) {
[01:28:23.853]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:23.853]                     {
[01:28:23.853]                       inherits <- base::inherits
[01:28:23.853]                       invokeRestart <- base::invokeRestart
[01:28:23.853]                       is.null <- base::is.null
[01:28:23.853]                       muffled <- FALSE
[01:28:23.853]                       if (inherits(cond, "message")) {
[01:28:23.853]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:23.853]                         if (muffled) 
[01:28:23.853]                           invokeRestart("muffleMessage")
[01:28:23.853]                       }
[01:28:23.853]                       else if (inherits(cond, "warning")) {
[01:28:23.853]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:23.853]                         if (muffled) 
[01:28:23.853]                           invokeRestart("muffleWarning")
[01:28:23.853]                       }
[01:28:23.853]                       else if (inherits(cond, "condition")) {
[01:28:23.853]                         if (!is.null(pattern)) {
[01:28:23.853]                           computeRestarts <- base::computeRestarts
[01:28:23.853]                           grepl <- base::grepl
[01:28:23.853]                           restarts <- computeRestarts(cond)
[01:28:23.853]                           for (restart in restarts) {
[01:28:23.853]                             name <- restart$name
[01:28:23.853]                             if (is.null(name)) 
[01:28:23.853]                               next
[01:28:23.853]                             if (!grepl(pattern, name)) 
[01:28:23.853]                               next
[01:28:23.853]                             invokeRestart(restart)
[01:28:23.853]                             muffled <- TRUE
[01:28:23.853]                             break
[01:28:23.853]                           }
[01:28:23.853]                         }
[01:28:23.853]                       }
[01:28:23.853]                       invisible(muffled)
[01:28:23.853]                     }
[01:28:23.853]                     muffleCondition(cond, pattern = "^muffle")
[01:28:23.853]                   }
[01:28:23.853]                 }
[01:28:23.853]             }
[01:28:23.853]         }))
[01:28:23.853]     }, error = function(ex) {
[01:28:23.853]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:23.853]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:23.853]                 ...future.rng), started = ...future.startTime, 
[01:28:23.853]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:23.853]             version = "1.8"), class = "FutureResult")
[01:28:23.853]     }, finally = {
[01:28:23.853]         if (!identical(...future.workdir, getwd())) 
[01:28:23.853]             setwd(...future.workdir)
[01:28:23.853]         {
[01:28:23.853]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:23.853]                 ...future.oldOptions$nwarnings <- NULL
[01:28:23.853]             }
[01:28:23.853]             base::options(...future.oldOptions)
[01:28:23.853]             if (.Platform$OS.type == "windows") {
[01:28:23.853]                 old_names <- names(...future.oldEnvVars)
[01:28:23.853]                 envs <- base::Sys.getenv()
[01:28:23.853]                 names <- names(envs)
[01:28:23.853]                 common <- intersect(names, old_names)
[01:28:23.853]                 added <- setdiff(names, old_names)
[01:28:23.853]                 removed <- setdiff(old_names, names)
[01:28:23.853]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:23.853]                   envs[common]]
[01:28:23.853]                 NAMES <- toupper(changed)
[01:28:23.853]                 args <- list()
[01:28:23.853]                 for (kk in seq_along(NAMES)) {
[01:28:23.853]                   name <- changed[[kk]]
[01:28:23.853]                   NAME <- NAMES[[kk]]
[01:28:23.853]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:23.853]                     next
[01:28:23.853]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:23.853]                 }
[01:28:23.853]                 NAMES <- toupper(added)
[01:28:23.853]                 for (kk in seq_along(NAMES)) {
[01:28:23.853]                   name <- added[[kk]]
[01:28:23.853]                   NAME <- NAMES[[kk]]
[01:28:23.853]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:23.853]                     next
[01:28:23.853]                   args[[name]] <- ""
[01:28:23.853]                 }
[01:28:23.853]                 NAMES <- toupper(removed)
[01:28:23.853]                 for (kk in seq_along(NAMES)) {
[01:28:23.853]                   name <- removed[[kk]]
[01:28:23.853]                   NAME <- NAMES[[kk]]
[01:28:23.853]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:23.853]                     next
[01:28:23.853]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:23.853]                 }
[01:28:23.853]                 if (length(args) > 0) 
[01:28:23.853]                   base::do.call(base::Sys.setenv, args = args)
[01:28:23.853]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:23.853]             }
[01:28:23.853]             else {
[01:28:23.853]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:23.853]             }
[01:28:23.853]             {
[01:28:23.853]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:23.853]                   0L) {
[01:28:23.853]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:23.853]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:23.853]                   base::options(opts)
[01:28:23.853]                 }
[01:28:23.853]                 {
[01:28:23.853]                   {
[01:28:23.853]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:23.853]                     NULL
[01:28:23.853]                   }
[01:28:23.853]                   options(future.plan = NULL)
[01:28:23.853]                   if (is.na(NA_character_)) 
[01:28:23.853]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:23.853]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:23.853]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:23.853]                   {
[01:28:23.853]                     future <- SequentialFuture(..., envir = envir)
[01:28:23.853]                     if (!future$lazy) 
[01:28:23.853]                       future <- run(future)
[01:28:23.853]                     invisible(future)
[01:28:23.853]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:23.853]                 }
[01:28:23.853]             }
[01:28:23.853]         }
[01:28:23.853]     })
[01:28:23.853]     if (TRUE) {
[01:28:23.853]         base::sink(type = "output", split = FALSE)
[01:28:23.853]         if (TRUE) {
[01:28:23.853]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:23.853]         }
[01:28:23.853]         else {
[01:28:23.853]             ...future.result["stdout"] <- base::list(NULL)
[01:28:23.853]         }
[01:28:23.853]         base::close(...future.stdout)
[01:28:23.853]         ...future.stdout <- NULL
[01:28:23.853]     }
[01:28:23.853]     ...future.result$conditions <- ...future.conditions
[01:28:23.853]     ...future.result$finished <- base::Sys.time()
[01:28:23.853]     ...future.result
[01:28:23.853] }
[01:28:23.861] Exporting 1 global objects (4.01 KiB) to cluster node #1 ...
[01:28:23.861] Exporting 'a' (4.01 KiB) to cluster node #1 ...
[01:28:23.862] Exporting 'a' (4.01 KiB) to cluster node #1 ... DONE
[01:28:23.862] Exporting 1 global objects (4.01 KiB) to cluster node #1 ... DONE
[01:28:23.863] MultisessionFuture started
MultisessionFuture:
Label: '<none>'
Expression:
{
    sum(a)
}
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 4.01 KiB (integer 'a' of 4.01 KiB)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[01:28:23.877] receiveMessageFromWorker() for ClusterFuture ...
[01:28:23.878] - Validating connection of MultisessionFuture
[01:28:23.878] - received message: FutureResult
[01:28:23.878] - Received FutureResult
[01:28:23.878] - Erased future from FutureRegistry
[01:28:23.879] result() for ClusterFuture ...
[01:28:23.879] - result already collected: FutureResult
[01:28:23.879] result() for ClusterFuture ... done
[01:28:23.879] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: cfeec5f2-987d-97c4-cbb0-b2e17579921c
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:23.879] result() for ClusterFuture ...
[01:28:23.879] - result already collected: FutureResult
[01:28:23.880] result() for ClusterFuture ... done
[01:28:23.880] result() for ClusterFuture ...
[01:28:23.880] - result already collected: FutureResult
[01:28:23.880] result() for ClusterFuture ... done
[1] 514605
a: 4112 bytes
[01:28:23.880] getGlobalsAndPackages() ...
[01:28:23.881] Searching for globals...
[01:28:23.882] - globals found: [3] '{', 'sum', 'a'
[01:28:23.882] Searching for globals ... DONE
[01:28:23.882] Resolving globals: FALSE
[01:28:23.883] The total size of the 1 globals is 4.02 KiB (4112 bytes)
[01:28:23.883] The total size of the 1 globals exported for future expression ('{; sum(a); }') is 4.02 KiB.. This exceeds the maximum allowed size of 4.01 KiB (option 'future.globals.maxSize'). There is one global: 'a' (4.02 KiB of class 'numeric')
> 
> ## Undo options changed in this test
> options(ooptsT)
> 
> 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)
[01:28:23.884] getGlobalsAndPackages() ...
[01:28:23.884] Searching for globals...
[01:28:23.885] - globals found: [4] '{', '*', 'a', 'b'
[01:28:23.885] Searching for globals ... DONE
[01:28:23.885] Resolving globals: FALSE
[01:28:23.886] The total size of the 2 globals is 112 bytes (112 bytes)
[01:28:23.886] The total size of the 2 globals exported for future expression ('{; a * b; }') is 112 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'a' (56 bytes of class 'numeric') and 'b' (56 bytes of class 'numeric')
[01:28:23.887] - globals: [2] 'a', 'b'
[01:28:23.887] 
[01:28:23.887] getGlobalsAndPackages() ... DONE
> rm(list = c("a", "b"))
> 
> v <- value(f)
[01:28:23.888] Packages needed by the future expression (n = 0): <none>
[01:28:23.888] Packages needed by future strategies (n = 0): <none>
[01:28:23.888] {
[01:28:23.888]     {
[01:28:23.888]         {
[01:28:23.888]             ...future.startTime <- base::Sys.time()
[01:28:23.888]             {
[01:28:23.888]                 {
[01:28:23.888]                   {
[01:28:23.888]                     base::local({
[01:28:23.888]                       has_future <- base::requireNamespace("future", 
[01:28:23.888]                         quietly = TRUE)
[01:28:23.888]                       if (has_future) {
[01:28:23.888]                         ns <- base::getNamespace("future")
[01:28:23.888]                         version <- ns[[".package"]][["version"]]
[01:28:23.888]                         if (is.null(version)) 
[01:28:23.888]                           version <- utils::packageVersion("future")
[01:28:23.888]                       }
[01:28:23.888]                       else {
[01:28:23.888]                         version <- NULL
[01:28:23.888]                       }
[01:28:23.888]                       if (!has_future || version < "1.8.0") {
[01:28:23.888]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:23.888]                           "", base::R.version$version.string), 
[01:28:23.888]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:23.888]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:23.888]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:23.888]                             "release", "version")], collapse = " "), 
[01:28:23.888]                           hostname = base::Sys.info()[["nodename"]])
[01:28:23.888]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:23.888]                           info)
[01:28:23.888]                         info <- base::paste(info, collapse = "; ")
[01:28:23.888]                         if (!has_future) {
[01:28:23.888]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:23.888]                             info)
[01:28:23.888]                         }
[01:28:23.888]                         else {
[01:28:23.888]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:23.888]                             info, version)
[01:28:23.888]                         }
[01:28:23.888]                         base::stop(msg)
[01:28:23.888]                       }
[01:28:23.888]                     })
[01:28:23.888]                   }
[01:28:23.888]                   options(future.plan = NULL)
[01:28:23.888]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:23.888]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:23.888]                 }
[01:28:23.888]                 ...future.workdir <- getwd()
[01:28:23.888]             }
[01:28:23.888]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:23.888]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:23.888]         }
[01:28:23.888]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:23.888]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:23.888]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:23.888]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:23.888]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:23.888]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:23.888]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:23.888]             base::names(...future.oldOptions))
[01:28:23.888]     }
[01:28:23.888]     if (FALSE) {
[01:28:23.888]     }
[01:28:23.888]     else {
[01:28:23.888]         if (TRUE) {
[01:28:23.888]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:23.888]                 open = "w")
[01:28:23.888]         }
[01:28:23.888]         else {
[01:28:23.888]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:23.888]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:23.888]         }
[01:28:23.888]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:23.888]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:23.888]             base::sink(type = "output", split = FALSE)
[01:28:23.888]             base::close(...future.stdout)
[01:28:23.888]         }, add = TRUE)
[01:28:23.888]     }
[01:28:23.888]     ...future.frame <- base::sys.nframe()
[01:28:23.888]     ...future.conditions <- base::list()
[01:28:23.888]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:23.888]     if (FALSE) {
[01:28:23.888]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:23.888]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:23.888]     }
[01:28:23.888]     ...future.result <- base::tryCatch({
[01:28:23.888]         base::withCallingHandlers({
[01:28:23.888]             ...future.value <- base::withVisible(base::local({
[01:28:23.888]                 a * b
[01:28:23.888]             }))
[01:28:23.888]             future::FutureResult(value = ...future.value$value, 
[01:28:23.888]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:23.888]                   ...future.rng), globalenv = if (FALSE) 
[01:28:23.888]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:23.888]                     ...future.globalenv.names))
[01:28:23.888]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:23.888]         }, condition = base::local({
[01:28:23.888]             c <- base::c
[01:28:23.888]             inherits <- base::inherits
[01:28:23.888]             invokeRestart <- base::invokeRestart
[01:28:23.888]             length <- base::length
[01:28:23.888]             list <- base::list
[01:28:23.888]             seq.int <- base::seq.int
[01:28:23.888]             signalCondition <- base::signalCondition
[01:28:23.888]             sys.calls <- base::sys.calls
[01:28:23.888]             `[[` <- base::`[[`
[01:28:23.888]             `+` <- base::`+`
[01:28:23.888]             `<<-` <- base::`<<-`
[01:28:23.888]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:23.888]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:23.888]                   3L)]
[01:28:23.888]             }
[01:28:23.888]             function(cond) {
[01:28:23.888]                 is_error <- inherits(cond, "error")
[01:28:23.888]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:23.888]                   NULL)
[01:28:23.888]                 if (is_error) {
[01:28:23.888]                   sessionInformation <- function() {
[01:28:23.888]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:23.888]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:23.888]                       search = base::search(), system = base::Sys.info())
[01:28:23.888]                   }
[01:28:23.888]                   ...future.conditions[[length(...future.conditions) + 
[01:28:23.888]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:23.888]                     cond$call), session = sessionInformation(), 
[01:28:23.888]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:23.888]                   signalCondition(cond)
[01:28:23.888]                 }
[01:28:23.888]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:23.888]                 "immediateCondition"))) {
[01:28:23.888]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:23.888]                   ...future.conditions[[length(...future.conditions) + 
[01:28:23.888]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:23.888]                   if (TRUE && !signal) {
[01:28:23.888]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:23.888]                     {
[01:28:23.888]                       inherits <- base::inherits
[01:28:23.888]                       invokeRestart <- base::invokeRestart
[01:28:23.888]                       is.null <- base::is.null
[01:28:23.888]                       muffled <- FALSE
[01:28:23.888]                       if (inherits(cond, "message")) {
[01:28:23.888]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:23.888]                         if (muffled) 
[01:28:23.888]                           invokeRestart("muffleMessage")
[01:28:23.888]                       }
[01:28:23.888]                       else if (inherits(cond, "warning")) {
[01:28:23.888]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:23.888]                         if (muffled) 
[01:28:23.888]                           invokeRestart("muffleWarning")
[01:28:23.888]                       }
[01:28:23.888]                       else if (inherits(cond, "condition")) {
[01:28:23.888]                         if (!is.null(pattern)) {
[01:28:23.888]                           computeRestarts <- base::computeRestarts
[01:28:23.888]                           grepl <- base::grepl
[01:28:23.888]                           restarts <- computeRestarts(cond)
[01:28:23.888]                           for (restart in restarts) {
[01:28:23.888]                             name <- restart$name
[01:28:23.888]                             if (is.null(name)) 
[01:28:23.888]                               next
[01:28:23.888]                             if (!grepl(pattern, name)) 
[01:28:23.888]                               next
[01:28:23.888]                             invokeRestart(restart)
[01:28:23.888]                             muffled <- TRUE
[01:28:23.888]                             break
[01:28:23.888]                           }
[01:28:23.888]                         }
[01:28:23.888]                       }
[01:28:23.888]                       invisible(muffled)
[01:28:23.888]                     }
[01:28:23.888]                     muffleCondition(cond, pattern = "^muffle")
[01:28:23.888]                   }
[01:28:23.888]                 }
[01:28:23.888]                 else {
[01:28:23.888]                   if (TRUE) {
[01:28:23.888]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:23.888]                     {
[01:28:23.888]                       inherits <- base::inherits
[01:28:23.888]                       invokeRestart <- base::invokeRestart
[01:28:23.888]                       is.null <- base::is.null
[01:28:23.888]                       muffled <- FALSE
[01:28:23.888]                       if (inherits(cond, "message")) {
[01:28:23.888]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:23.888]                         if (muffled) 
[01:28:23.888]                           invokeRestart("muffleMessage")
[01:28:23.888]                       }
[01:28:23.888]                       else if (inherits(cond, "warning")) {
[01:28:23.888]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:23.888]                         if (muffled) 
[01:28:23.888]                           invokeRestart("muffleWarning")
[01:28:23.888]                       }
[01:28:23.888]                       else if (inherits(cond, "condition")) {
[01:28:23.888]                         if (!is.null(pattern)) {
[01:28:23.888]                           computeRestarts <- base::computeRestarts
[01:28:23.888]                           grepl <- base::grepl
[01:28:23.888]                           restarts <- computeRestarts(cond)
[01:28:23.888]                           for (restart in restarts) {
[01:28:23.888]                             name <- restart$name
[01:28:23.888]                             if (is.null(name)) 
[01:28:23.888]                               next
[01:28:23.888]                             if (!grepl(pattern, name)) 
[01:28:23.888]                               next
[01:28:23.888]                             invokeRestart(restart)
[01:28:23.888]                             muffled <- TRUE
[01:28:23.888]                             break
[01:28:23.888]                           }
[01:28:23.888]                         }
[01:28:23.888]                       }
[01:28:23.888]                       invisible(muffled)
[01:28:23.888]                     }
[01:28:23.888]                     muffleCondition(cond, pattern = "^muffle")
[01:28:23.888]                   }
[01:28:23.888]                 }
[01:28:23.888]             }
[01:28:23.888]         }))
[01:28:23.888]     }, error = function(ex) {
[01:28:23.888]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:23.888]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:23.888]                 ...future.rng), started = ...future.startTime, 
[01:28:23.888]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:23.888]             version = "1.8"), class = "FutureResult")
[01:28:23.888]     }, finally = {
[01:28:23.888]         if (!identical(...future.workdir, getwd())) 
[01:28:23.888]             setwd(...future.workdir)
[01:28:23.888]         {
[01:28:23.888]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:23.888]                 ...future.oldOptions$nwarnings <- NULL
[01:28:23.888]             }
[01:28:23.888]             base::options(...future.oldOptions)
[01:28:23.888]             if (.Platform$OS.type == "windows") {
[01:28:23.888]                 old_names <- names(...future.oldEnvVars)
[01:28:23.888]                 envs <- base::Sys.getenv()
[01:28:23.888]                 names <- names(envs)
[01:28:23.888]                 common <- intersect(names, old_names)
[01:28:23.888]                 added <- setdiff(names, old_names)
[01:28:23.888]                 removed <- setdiff(old_names, names)
[01:28:23.888]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:23.888]                   envs[common]]
[01:28:23.888]                 NAMES <- toupper(changed)
[01:28:23.888]                 args <- list()
[01:28:23.888]                 for (kk in seq_along(NAMES)) {
[01:28:23.888]                   name <- changed[[kk]]
[01:28:23.888]                   NAME <- NAMES[[kk]]
[01:28:23.888]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:23.888]                     next
[01:28:23.888]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:23.888]                 }
[01:28:23.888]                 NAMES <- toupper(added)
[01:28:23.888]                 for (kk in seq_along(NAMES)) {
[01:28:23.888]                   name <- added[[kk]]
[01:28:23.888]                   NAME <- NAMES[[kk]]
[01:28:23.888]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:23.888]                     next
[01:28:23.888]                   args[[name]] <- ""
[01:28:23.888]                 }
[01:28:23.888]                 NAMES <- toupper(removed)
[01:28:23.888]                 for (kk in seq_along(NAMES)) {
[01:28:23.888]                   name <- removed[[kk]]
[01:28:23.888]                   NAME <- NAMES[[kk]]
[01:28:23.888]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:23.888]                     next
[01:28:23.888]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:23.888]                 }
[01:28:23.888]                 if (length(args) > 0) 
[01:28:23.888]                   base::do.call(base::Sys.setenv, args = args)
[01:28:23.888]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:23.888]             }
[01:28:23.888]             else {
[01:28:23.888]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:23.888]             }
[01:28:23.888]             {
[01:28:23.888]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:23.888]                   0L) {
[01:28:23.888]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:23.888]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:23.888]                   base::options(opts)
[01:28:23.888]                 }
[01:28:23.888]                 {
[01:28:23.888]                   {
[01:28:23.888]                     NULL
[01:28:23.888]                     RNGkind("Mersenne-Twister")
[01:28:23.888]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:23.888]                       inherits = FALSE)
[01:28:23.888]                   }
[01:28:23.888]                   options(future.plan = NULL)
[01:28:23.888]                   if (is.na(NA_character_)) 
[01:28:23.888]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:23.888]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:23.888]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:23.888]                   {
[01:28:23.888]                     future <- SequentialFuture(..., envir = envir)
[01:28:23.888]                     if (!future$lazy) 
[01:28:23.888]                       future <- run(future)
[01:28:23.888]                     invisible(future)
[01:28:23.888]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:23.888]                 }
[01:28:23.888]             }
[01:28:23.888]         }
[01:28:23.888]     })
[01:28:23.888]     if (TRUE) {
[01:28:23.888]         base::sink(type = "output", split = FALSE)
[01:28:23.888]         if (TRUE) {
[01:28:23.888]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:23.888]         }
[01:28:23.888]         else {
[01:28:23.888]             ...future.result["stdout"] <- base::list(NULL)
[01:28:23.888]         }
[01:28:23.888]         base::close(...future.stdout)
[01:28:23.888]         ...future.stdout <- NULL
[01:28:23.888]     }
[01:28:23.888]     ...future.result$conditions <- ...future.conditions
[01:28:23.888]     ...future.result$finished <- base::Sys.time()
[01:28:23.888]     ...future.result
[01:28:23.888] }
[01:28:23.892] assign_globals() ...
[01:28:23.892] List of 2
[01:28:23.892]  $ a: num 2
[01:28:23.892]  $ b: num 3
[01:28:23.892]  - attr(*, "where")=List of 2
[01:28:23.892]   ..$ a:<environment: R_EmptyEnv> 
[01:28:23.892]   ..$ b:<environment: R_EmptyEnv> 
[01:28:23.892]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:23.892]  - attr(*, "resolved")= logi FALSE
[01:28:23.892]  - attr(*, "total_size")= num 112
[01:28:23.896] - copied 'a' to environment
[01:28:23.896] - copied 'b' to environment
[01:28:23.896] assign_globals() ... done
[01:28:23.897] plan(): Setting new future strategy stack:
[01:28:23.897] List of future strategies:
[01:28:23.897] 1. sequential:
[01:28:23.897]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:23.897]    - tweaked: FALSE
[01:28:23.897]    - call: NULL
[01:28:23.897] plan(): nbrOfWorkers() = 1
[01:28:23.899] plan(): Setting new future strategy stack:
[01:28:23.899] List of future strategies:
[01:28:23.899] 1. sequential:
[01:28:23.899]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:23.899]    - tweaked: FALSE
[01:28:23.899]    - call: future::plan("sequential")
[01:28:23.899] plan(): nbrOfWorkers() = 1
[01:28:23.900] 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)
[01:28:23.901] plan(): Setting new future strategy stack:
[01:28:23.901] List of future strategies:
[01:28:23.901] 1. multisession:
[01:28:23.901]    - args: function (..., workers = 2L, envir = parent.frame())
[01:28:23.901]    - tweaked: TRUE
[01:28:23.901]    - call: plan(multisession, workers = 2L)
[01:28:23.925] plan(): plan_init() of 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[01:28:23.925] multisession:
[01:28:23.925] - args: function (..., workers = 2L, envir = parent.frame())
[01:28:23.925] - tweaked: TRUE
[01:28:23.925] - call: plan(multisession, workers = 2L)
[01:28:23.926] getGlobalsAndPackages() ...
[01:28:23.926] Not searching for globals
[01:28:23.927] - globals: [0] <none>
[01:28:23.927] getGlobalsAndPackages() ... DONE
[01:28:23.928] [local output] makeClusterPSOCK() ...
[01:28:23.928] [local output] Workers: [n = 2] 'localhost', 'localhost'
[01:28:23.932] [local output] Base port: 25704
[01:28:23.932] [local output] Getting setup options for 2 cluster nodes ...
[01:28:23.932] [local output]  - Node 1 of 2 ...
[01:28:23.933] [local output] localMachine=TRUE => revtunnel=FALSE

[01:28:23.935] [local output] Rscript port: 25704

[01:28:23.936] [local output]  - Node 2 of 2 ...
[01:28:23.937] [local output] localMachine=TRUE => revtunnel=FALSE

[01:28:23.938] [local output] Rscript port: 25704

[01:28:23.939] [local output] Getting setup options for 2 cluster nodes ... done
[01:28:23.939] [local output]  - Parallel setup requested for some PSOCK nodes
[01:28:23.940] [local output] Setting up PSOCK nodes in parallel
[01:28:23.940] List of 36
[01:28:23.940]  $ worker          : chr "localhost"
[01:28:23.940]   ..- attr(*, "localhost")= logi TRUE
[01:28:23.940]  $ master          : chr "localhost"
[01:28:23.940]  $ port            : int 25704
[01:28:23.940]  $ connectTimeout  : num 120
[01:28:23.940]  $ timeout         : num 120
[01:28:23.940]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[01:28:23.940]  $ homogeneous     : logi TRUE
[01:28:23.940]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=multisession.R:13328:CRANWIN3:CR"| __truncated__
[01:28:23.940]  $ rscript_envs    : NULL
[01:28:23.940]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47" "D:/RCompile/recent/R/library"
[01:28:23.940]  $ rscript_startup : NULL
[01:28:23.940]  $ rscript_sh      : chr "cmd"
[01:28:23.940]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[01:28:23.940]  $ methods         : logi TRUE
[01:28:23.940]  $ socketOptions   : chr "no-delay"
[01:28:23.940]  $ useXDR          : logi FALSE
[01:28:23.940]  $ outfile         : chr "/dev/null"
[01:28:23.940]  $ renice          : int NA
[01:28:23.940]  $ rshcmd          : NULL
[01:28:23.940]  $ user            : chr(0) 
[01:28:23.940]  $ revtunnel       : logi FALSE
[01:28:23.940]  $ rshlogfile      : NULL
[01:28:23.940]  $ rshopts         : chr(0) 
[01:28:23.940]  $ rank            : int 1
[01:28:23.940]  $ manual          : logi FALSE
[01:28:23.940]  $ dryrun          : logi FALSE
[01:28:23.940]  $ quiet           : logi FALSE
[01:28:23.940]  $ setup_strategy  : chr "parallel"
[01:28:23.940]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[01:28:23.940]  $ pidfile         : chr "D:/temp/RtmpSkOF3d/worker.rank=1.parallelly.parent=13328.34107737120.pid"
[01:28:23.940]  $ rshcmd_label    : NULL
[01:28:23.940]  $ rsh_call        : NULL
[01:28:23.940]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[01:28:23.940]  $ localMachine    : logi TRUE
[01:28:23.940]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[01:28:23.940]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[01:28:23.940]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[01:28:23.940]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[01:28:23.940]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[01:28:23.940]         "cmd", "sh"), default_packages = c("datasets", "utils", "grDevices", 
[01:28:23.940]         "graphics", "stats", if (methods) "methods"), methods = TRUE, socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[01:28:23.940]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[01:28:23.940]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[01:28:23.940]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[01:28:23.940]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[01:28:23.940]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[01:28:23.940]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[01:28:23.940]  $ arguments       :List of 28
[01:28:23.940]   ..$ worker          : chr "localhost"
[01:28:23.940]   ..$ master          : NULL
[01:28:23.940]   ..$ port            : int 25704
[01:28:23.940]   ..$ connectTimeout  : num 120
[01:28:23.940]   ..$ timeout         : num 120
[01:28:23.940]   ..$ rscript         : NULL
[01:28:23.940]   ..$ homogeneous     : NULL
[01:28:23.940]   ..$ rscript_args    : NULL
[01:28:23.940]   ..$ rscript_envs    : NULL
[01:28:23.940]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47" "D:/RCompile/recent/R/library"
[01:28:23.940]   ..$ rscript_startup : NULL
[01:28:23.940]   ..$ rscript_sh      : chr [1:3] "auto" "cmd" "sh"
[01:28:23.940]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[01:28:23.940]   ..$ methods         : logi TRUE
[01:28:23.940]   ..$ socketOptions   : chr "no-delay"
[01:28:23.940]   ..$ useXDR          : logi FALSE
[01:28:23.940]   ..$ outfile         : chr "/dev/null"
[01:28:23.940]   ..$ renice          : int NA
[01:28:23.940]   ..$ rshcmd          : NULL
[01:28:23.940]   ..$ user            : NULL
[01:28:23.940]   ..$ revtunnel       : logi NA
[01:28:23.940]   ..$ rshlogfile      : NULL
[01:28:23.940]   ..$ rshopts         : NULL
[01:28:23.940]   ..$ rank            : int 1
[01:28:23.940]   ..$ manual          : logi FALSE
[01:28:23.940]   ..$ dryrun          : logi FALSE
[01:28:23.940]   ..$ quiet           : logi FALSE
[01:28:23.940]   ..$ setup_strategy  : chr "parallel"
[01:28:23.940]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[01:28:23.970] [local output] System call to launch all workers:
[01:28:23.970] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=multisession.R:13328:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpSkOF3d/worker.rank=1.parallelly.parent=13328.34107737120.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=25704 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[01:28:23.970] [local output] Starting PSOCK main server
[01:28:23.976] [local output] Workers launched
[01:28:23.977] [local output] Waiting for workers to connect back
[01:28:23.977]  - [local output] 0 workers out of 2 ready
[01:28:24.155]  - [local output] 0 workers out of 2 ready
[01:28:24.155]  - [local output] 1 workers out of 2 ready
[01:28:24.179]  - [local output] 1 workers out of 2 ready
[01:28:24.180]  - [local output] 2 workers out of 2 ready
[01:28:24.180] [local output] Launching of workers completed
[01:28:24.180] [local output] Collecting session information from workers
[01:28:24.181] [local output]  - Worker #1 of 2
[01:28:24.181] [local output]  - Worker #2 of 2
[01:28:24.182] [local output] makeClusterPSOCK() ... done
[01:28:24.195] Packages needed by the future expression (n = 0): <none>
[01:28:24.195] Packages needed by future strategies (n = 0): <none>
[01:28:24.196] {
[01:28:24.196]     {
[01:28:24.196]         {
[01:28:24.196]             ...future.startTime <- base::Sys.time()
[01:28:24.196]             {
[01:28:24.196]                 {
[01:28:24.196]                   {
[01:28:24.196]                     {
[01:28:24.196]                       base::local({
[01:28:24.196]                         has_future <- base::requireNamespace("future", 
[01:28:24.196]                           quietly = TRUE)
[01:28:24.196]                         if (has_future) {
[01:28:24.196]                           ns <- base::getNamespace("future")
[01:28:24.196]                           version <- ns[[".package"]][["version"]]
[01:28:24.196]                           if (is.null(version)) 
[01:28:24.196]                             version <- utils::packageVersion("future")
[01:28:24.196]                         }
[01:28:24.196]                         else {
[01:28:24.196]                           version <- NULL
[01:28:24.196]                         }
[01:28:24.196]                         if (!has_future || version < "1.8.0") {
[01:28:24.196]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:24.196]                             "", base::R.version$version.string), 
[01:28:24.196]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:24.196]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:24.196]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:24.196]                               "release", "version")], collapse = " "), 
[01:28:24.196]                             hostname = base::Sys.info()[["nodename"]])
[01:28:24.196]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:24.196]                             info)
[01:28:24.196]                           info <- base::paste(info, collapse = "; ")
[01:28:24.196]                           if (!has_future) {
[01:28:24.196]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:24.196]                               info)
[01:28:24.196]                           }
[01:28:24.196]                           else {
[01:28:24.196]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:24.196]                               info, version)
[01:28:24.196]                           }
[01:28:24.196]                           base::stop(msg)
[01:28:24.196]                         }
[01:28:24.196]                       })
[01:28:24.196]                     }
[01:28:24.196]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:24.196]                     base::options(mc.cores = 1L)
[01:28:24.196]                   }
[01:28:24.196]                   options(future.plan = NULL)
[01:28:24.196]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:24.196]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:24.196]                 }
[01:28:24.196]                 ...future.workdir <- getwd()
[01:28:24.196]             }
[01:28:24.196]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:24.196]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:24.196]         }
[01:28:24.196]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:24.196]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:24.196]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:24.196]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:24.196]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:24.196]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:24.196]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:24.196]             base::names(...future.oldOptions))
[01:28:24.196]     }
[01:28:24.196]     if (FALSE) {
[01:28:24.196]     }
[01:28:24.196]     else {
[01:28:24.196]         if (TRUE) {
[01:28:24.196]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:24.196]                 open = "w")
[01:28:24.196]         }
[01:28:24.196]         else {
[01:28:24.196]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:24.196]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:24.196]         }
[01:28:24.196]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:24.196]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:24.196]             base::sink(type = "output", split = FALSE)
[01:28:24.196]             base::close(...future.stdout)
[01:28:24.196]         }, add = TRUE)
[01:28:24.196]     }
[01:28:24.196]     ...future.frame <- base::sys.nframe()
[01:28:24.196]     ...future.conditions <- base::list()
[01:28:24.196]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:24.196]     if (FALSE) {
[01:28:24.196]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:24.196]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:24.196]     }
[01:28:24.196]     ...future.result <- base::tryCatch({
[01:28:24.196]         base::withCallingHandlers({
[01:28:24.196]             ...future.value <- base::withVisible(base::local({
[01:28:24.196]                 ...future.makeSendCondition <- base::local({
[01:28:24.196]                   sendCondition <- NULL
[01:28:24.196]                   function(frame = 1L) {
[01:28:24.196]                     if (is.function(sendCondition)) 
[01:28:24.196]                       return(sendCondition)
[01:28:24.196]                     ns <- getNamespace("parallel")
[01:28:24.196]                     if (exists("sendData", mode = "function", 
[01:28:24.196]                       envir = ns)) {
[01:28:24.196]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:24.196]                         envir = ns)
[01:28:24.196]                       envir <- sys.frame(frame)
[01:28:24.196]                       master <- NULL
[01:28:24.196]                       while (!identical(envir, .GlobalEnv) && 
[01:28:24.196]                         !identical(envir, emptyenv())) {
[01:28:24.196]                         if (exists("master", mode = "list", envir = envir, 
[01:28:24.196]                           inherits = FALSE)) {
[01:28:24.196]                           master <- get("master", mode = "list", 
[01:28:24.196]                             envir = envir, inherits = FALSE)
[01:28:24.196]                           if (inherits(master, c("SOCKnode", 
[01:28:24.196]                             "SOCK0node"))) {
[01:28:24.196]                             sendCondition <<- function(cond) {
[01:28:24.196]                               data <- list(type = "VALUE", value = cond, 
[01:28:24.196]                                 success = TRUE)
[01:28:24.196]                               parallel_sendData(master, data)
[01:28:24.196]                             }
[01:28:24.196]                             return(sendCondition)
[01:28:24.196]                           }
[01:28:24.196]                         }
[01:28:24.196]                         frame <- frame + 1L
[01:28:24.196]                         envir <- sys.frame(frame)
[01:28:24.196]                       }
[01:28:24.196]                     }
[01:28:24.196]                     sendCondition <<- function(cond) NULL
[01:28:24.196]                   }
[01:28:24.196]                 })
[01:28:24.196]                 withCallingHandlers({
[01:28:24.196]                   NA
[01:28:24.196]                 }, immediateCondition = function(cond) {
[01:28:24.196]                   sendCondition <- ...future.makeSendCondition()
[01:28:24.196]                   sendCondition(cond)
[01:28:24.196]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:24.196]                   {
[01:28:24.196]                     inherits <- base::inherits
[01:28:24.196]                     invokeRestart <- base::invokeRestart
[01:28:24.196]                     is.null <- base::is.null
[01:28:24.196]                     muffled <- FALSE
[01:28:24.196]                     if (inherits(cond, "message")) {
[01:28:24.196]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:24.196]                       if (muffled) 
[01:28:24.196]                         invokeRestart("muffleMessage")
[01:28:24.196]                     }
[01:28:24.196]                     else if (inherits(cond, "warning")) {
[01:28:24.196]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:24.196]                       if (muffled) 
[01:28:24.196]                         invokeRestart("muffleWarning")
[01:28:24.196]                     }
[01:28:24.196]                     else if (inherits(cond, "condition")) {
[01:28:24.196]                       if (!is.null(pattern)) {
[01:28:24.196]                         computeRestarts <- base::computeRestarts
[01:28:24.196]                         grepl <- base::grepl
[01:28:24.196]                         restarts <- computeRestarts(cond)
[01:28:24.196]                         for (restart in restarts) {
[01:28:24.196]                           name <- restart$name
[01:28:24.196]                           if (is.null(name)) 
[01:28:24.196]                             next
[01:28:24.196]                           if (!grepl(pattern, name)) 
[01:28:24.196]                             next
[01:28:24.196]                           invokeRestart(restart)
[01:28:24.196]                           muffled <- TRUE
[01:28:24.196]                           break
[01:28:24.196]                         }
[01:28:24.196]                       }
[01:28:24.196]                     }
[01:28:24.196]                     invisible(muffled)
[01:28:24.196]                   }
[01:28:24.196]                   muffleCondition(cond)
[01:28:24.196]                 })
[01:28:24.196]             }))
[01:28:24.196]             future::FutureResult(value = ...future.value$value, 
[01:28:24.196]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:24.196]                   ...future.rng), globalenv = if (FALSE) 
[01:28:24.196]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:24.196]                     ...future.globalenv.names))
[01:28:24.196]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:24.196]         }, condition = base::local({
[01:28:24.196]             c <- base::c
[01:28:24.196]             inherits <- base::inherits
[01:28:24.196]             invokeRestart <- base::invokeRestart
[01:28:24.196]             length <- base::length
[01:28:24.196]             list <- base::list
[01:28:24.196]             seq.int <- base::seq.int
[01:28:24.196]             signalCondition <- base::signalCondition
[01:28:24.196]             sys.calls <- base::sys.calls
[01:28:24.196]             `[[` <- base::`[[`
[01:28:24.196]             `+` <- base::`+`
[01:28:24.196]             `<<-` <- base::`<<-`
[01:28:24.196]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:24.196]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:24.196]                   3L)]
[01:28:24.196]             }
[01:28:24.196]             function(cond) {
[01:28:24.196]                 is_error <- inherits(cond, "error")
[01:28:24.196]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:24.196]                   NULL)
[01:28:24.196]                 if (is_error) {
[01:28:24.196]                   sessionInformation <- function() {
[01:28:24.196]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:24.196]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:24.196]                       search = base::search(), system = base::Sys.info())
[01:28:24.196]                   }
[01:28:24.196]                   ...future.conditions[[length(...future.conditions) + 
[01:28:24.196]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:24.196]                     cond$call), session = sessionInformation(), 
[01:28:24.196]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:24.196]                   signalCondition(cond)
[01:28:24.196]                 }
[01:28:24.196]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:24.196]                 "immediateCondition"))) {
[01:28:24.196]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:24.196]                   ...future.conditions[[length(...future.conditions) + 
[01:28:24.196]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:24.196]                   if (TRUE && !signal) {
[01:28:24.196]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:24.196]                     {
[01:28:24.196]                       inherits <- base::inherits
[01:28:24.196]                       invokeRestart <- base::invokeRestart
[01:28:24.196]                       is.null <- base::is.null
[01:28:24.196]                       muffled <- FALSE
[01:28:24.196]                       if (inherits(cond, "message")) {
[01:28:24.196]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:24.196]                         if (muffled) 
[01:28:24.196]                           invokeRestart("muffleMessage")
[01:28:24.196]                       }
[01:28:24.196]                       else if (inherits(cond, "warning")) {
[01:28:24.196]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:24.196]                         if (muffled) 
[01:28:24.196]                           invokeRestart("muffleWarning")
[01:28:24.196]                       }
[01:28:24.196]                       else if (inherits(cond, "condition")) {
[01:28:24.196]                         if (!is.null(pattern)) {
[01:28:24.196]                           computeRestarts <- base::computeRestarts
[01:28:24.196]                           grepl <- base::grepl
[01:28:24.196]                           restarts <- computeRestarts(cond)
[01:28:24.196]                           for (restart in restarts) {
[01:28:24.196]                             name <- restart$name
[01:28:24.196]                             if (is.null(name)) 
[01:28:24.196]                               next
[01:28:24.196]                             if (!grepl(pattern, name)) 
[01:28:24.196]                               next
[01:28:24.196]                             invokeRestart(restart)
[01:28:24.196]                             muffled <- TRUE
[01:28:24.196]                             break
[01:28:24.196]                           }
[01:28:24.196]                         }
[01:28:24.196]                       }
[01:28:24.196]                       invisible(muffled)
[01:28:24.196]                     }
[01:28:24.196]                     muffleCondition(cond, pattern = "^muffle")
[01:28:24.196]                   }
[01:28:24.196]                 }
[01:28:24.196]                 else {
[01:28:24.196]                   if (TRUE) {
[01:28:24.196]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:24.196]                     {
[01:28:24.196]                       inherits <- base::inherits
[01:28:24.196]                       invokeRestart <- base::invokeRestart
[01:28:24.196]                       is.null <- base::is.null
[01:28:24.196]                       muffled <- FALSE
[01:28:24.196]                       if (inherits(cond, "message")) {
[01:28:24.196]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:24.196]                         if (muffled) 
[01:28:24.196]                           invokeRestart("muffleMessage")
[01:28:24.196]                       }
[01:28:24.196]                       else if (inherits(cond, "warning")) {
[01:28:24.196]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:24.196]                         if (muffled) 
[01:28:24.196]                           invokeRestart("muffleWarning")
[01:28:24.196]                       }
[01:28:24.196]                       else if (inherits(cond, "condition")) {
[01:28:24.196]                         if (!is.null(pattern)) {
[01:28:24.196]                           computeRestarts <- base::computeRestarts
[01:28:24.196]                           grepl <- base::grepl
[01:28:24.196]                           restarts <- computeRestarts(cond)
[01:28:24.196]                           for (restart in restarts) {
[01:28:24.196]                             name <- restart$name
[01:28:24.196]                             if (is.null(name)) 
[01:28:24.196]                               next
[01:28:24.196]                             if (!grepl(pattern, name)) 
[01:28:24.196]                               next
[01:28:24.196]                             invokeRestart(restart)
[01:28:24.196]                             muffled <- TRUE
[01:28:24.196]                             break
[01:28:24.196]                           }
[01:28:24.196]                         }
[01:28:24.196]                       }
[01:28:24.196]                       invisible(muffled)
[01:28:24.196]                     }
[01:28:24.196]                     muffleCondition(cond, pattern = "^muffle")
[01:28:24.196]                   }
[01:28:24.196]                 }
[01:28:24.196]             }
[01:28:24.196]         }))
[01:28:24.196]     }, error = function(ex) {
[01:28:24.196]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:24.196]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:24.196]                 ...future.rng), started = ...future.startTime, 
[01:28:24.196]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:24.196]             version = "1.8"), class = "FutureResult")
[01:28:24.196]     }, finally = {
[01:28:24.196]         if (!identical(...future.workdir, getwd())) 
[01:28:24.196]             setwd(...future.workdir)
[01:28:24.196]         {
[01:28:24.196]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:24.196]                 ...future.oldOptions$nwarnings <- NULL
[01:28:24.196]             }
[01:28:24.196]             base::options(...future.oldOptions)
[01:28:24.196]             if (.Platform$OS.type == "windows") {
[01:28:24.196]                 old_names <- names(...future.oldEnvVars)
[01:28:24.196]                 envs <- base::Sys.getenv()
[01:28:24.196]                 names <- names(envs)
[01:28:24.196]                 common <- intersect(names, old_names)
[01:28:24.196]                 added <- setdiff(names, old_names)
[01:28:24.196]                 removed <- setdiff(old_names, names)
[01:28:24.196]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:24.196]                   envs[common]]
[01:28:24.196]                 NAMES <- toupper(changed)
[01:28:24.196]                 args <- list()
[01:28:24.196]                 for (kk in seq_along(NAMES)) {
[01:28:24.196]                   name <- changed[[kk]]
[01:28:24.196]                   NAME <- NAMES[[kk]]
[01:28:24.196]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:24.196]                     next
[01:28:24.196]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:24.196]                 }
[01:28:24.196]                 NAMES <- toupper(added)
[01:28:24.196]                 for (kk in seq_along(NAMES)) {
[01:28:24.196]                   name <- added[[kk]]
[01:28:24.196]                   NAME <- NAMES[[kk]]
[01:28:24.196]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:24.196]                     next
[01:28:24.196]                   args[[name]] <- ""
[01:28:24.196]                 }
[01:28:24.196]                 NAMES <- toupper(removed)
[01:28:24.196]                 for (kk in seq_along(NAMES)) {
[01:28:24.196]                   name <- removed[[kk]]
[01:28:24.196]                   NAME <- NAMES[[kk]]
[01:28:24.196]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:24.196]                     next
[01:28:24.196]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:24.196]                 }
[01:28:24.196]                 if (length(args) > 0) 
[01:28:24.196]                   base::do.call(base::Sys.setenv, args = args)
[01:28:24.196]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:24.196]             }
[01:28:24.196]             else {
[01:28:24.196]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:24.196]             }
[01:28:24.196]             {
[01:28:24.196]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:24.196]                   0L) {
[01:28:24.196]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:24.196]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:24.196]                   base::options(opts)
[01:28:24.196]                 }
[01:28:24.196]                 {
[01:28:24.196]                   {
[01:28:24.196]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:24.196]                     NULL
[01:28:24.196]                   }
[01:28:24.196]                   options(future.plan = NULL)
[01:28:24.196]                   if (is.na(NA_character_)) 
[01:28:24.196]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:24.196]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:24.196]                   future::plan(list(function (..., workers = 2L, 
[01:28:24.196]                     envir = parent.frame()) 
[01:28:24.196]                   strategy(..., workers = workers, envir = envir)), 
[01:28:24.196]                     .cleanup = FALSE, .init = FALSE)
[01:28:24.196]                 }
[01:28:24.196]             }
[01:28:24.196]         }
[01:28:24.196]     })
[01:28:24.196]     if (TRUE) {
[01:28:24.196]         base::sink(type = "output", split = FALSE)
[01:28:24.196]         if (TRUE) {
[01:28:24.196]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:24.196]         }
[01:28:24.196]         else {
[01:28:24.196]             ...future.result["stdout"] <- base::list(NULL)
[01:28:24.196]         }
[01:28:24.196]         base::close(...future.stdout)
[01:28:24.196]         ...future.stdout <- NULL
[01:28:24.196]     }
[01:28:24.196]     ...future.result$conditions <- ...future.conditions
[01:28:24.196]     ...future.result$finished <- base::Sys.time()
[01:28:24.196]     ...future.result
[01:28:24.196] }
[01:28:24.276] MultisessionFuture started
[01:28:24.276] result() for ClusterFuture ...
[01:28:24.276] receiveMessageFromWorker() for ClusterFuture ...
[01:28:24.277] - Validating connection of MultisessionFuture
[01:28:24.330] - received message: FutureResult
[01:28:24.331] - Received FutureResult
[01:28:24.331] - Erased future from FutureRegistry
[01:28:24.331] result() for ClusterFuture ...
[01:28:24.331] - result already collected: FutureResult
[01:28:24.331] result() for ClusterFuture ... done
[01:28:24.332] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:24.332] result() for ClusterFuture ... done
[01:28:24.332] result() for ClusterFuture ...
[01:28:24.332] - result already collected: FutureResult
[01:28:24.332] result() for ClusterFuture ... done
[01:28:24.333] plan(): plan_init() of 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[01:28:24.333] plan(): nbrOfWorkers() = 2
> 
> f <- future({ gc() })
[01:28:24.333] getGlobalsAndPackages() ...
[01:28:24.333] Searching for globals...
[01:28:24.335] - globals found: [2] '{', 'gc'
[01:28:24.335] Searching for globals ... DONE
[01:28:24.335] Resolving globals: FALSE
[01:28:24.335] 
[01:28:24.336] 
[01:28:24.336] getGlobalsAndPackages() ... DONE
[01:28:24.336] run() for 'Future' ...
[01:28:24.336] - state: 'created'
[01:28:24.337] - Future backend: 'FutureStrategy', 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:24.350] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:24.350] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:24.350]   - Field: 'node'
[01:28:24.350]   - Field: 'label'
[01:28:24.351]   - Field: 'local'
[01:28:24.351]   - Field: 'owner'
[01:28:24.351]   - Field: 'envir'
[01:28:24.351]   - Field: 'workers'
[01:28:24.351]   - Field: 'packages'
[01:28:24.351]   - Field: 'gc'
[01:28:24.352]   - Field: 'conditions'
[01:28:24.352]   - Field: 'persistent'
[01:28:24.352]   - Field: 'expr'
[01:28:24.352]   - Field: 'uuid'
[01:28:24.352]   - Field: 'seed'
[01:28:24.353]   - Field: 'version'
[01:28:24.353]   - Field: 'result'
[01:28:24.353]   - Field: 'asynchronous'
[01:28:24.353]   - Field: 'calls'
[01:28:24.353]   - Field: 'globals'
[01:28:24.353]   - Field: 'stdout'
[01:28:24.354]   - Field: 'earlySignal'
[01:28:24.354]   - Field: 'lazy'
[01:28:24.354]   - Field: 'state'
[01:28:24.354] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:24.354] - Launch lazy future ...
[01:28:24.355] Packages needed by the future expression (n = 0): <none>
[01:28:24.355] Packages needed by future strategies (n = 0): <none>
[01:28:24.356] {
[01:28:24.356]     {
[01:28:24.356]         {
[01:28:24.356]             ...future.startTime <- base::Sys.time()
[01:28:24.356]             {
[01:28:24.356]                 {
[01:28:24.356]                   {
[01:28:24.356]                     {
[01:28:24.356]                       base::local({
[01:28:24.356]                         has_future <- base::requireNamespace("future", 
[01:28:24.356]                           quietly = TRUE)
[01:28:24.356]                         if (has_future) {
[01:28:24.356]                           ns <- base::getNamespace("future")
[01:28:24.356]                           version <- ns[[".package"]][["version"]]
[01:28:24.356]                           if (is.null(version)) 
[01:28:24.356]                             version <- utils::packageVersion("future")
[01:28:24.356]                         }
[01:28:24.356]                         else {
[01:28:24.356]                           version <- NULL
[01:28:24.356]                         }
[01:28:24.356]                         if (!has_future || version < "1.8.0") {
[01:28:24.356]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:24.356]                             "", base::R.version$version.string), 
[01:28:24.356]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:24.356]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:24.356]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:24.356]                               "release", "version")], collapse = " "), 
[01:28:24.356]                             hostname = base::Sys.info()[["nodename"]])
[01:28:24.356]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:24.356]                             info)
[01:28:24.356]                           info <- base::paste(info, collapse = "; ")
[01:28:24.356]                           if (!has_future) {
[01:28:24.356]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:24.356]                               info)
[01:28:24.356]                           }
[01:28:24.356]                           else {
[01:28:24.356]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:24.356]                               info, version)
[01:28:24.356]                           }
[01:28:24.356]                           base::stop(msg)
[01:28:24.356]                         }
[01:28:24.356]                       })
[01:28:24.356]                     }
[01:28:24.356]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:24.356]                     base::options(mc.cores = 1L)
[01:28:24.356]                   }
[01:28:24.356]                   options(future.plan = NULL)
[01:28:24.356]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:24.356]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:24.356]                 }
[01:28:24.356]                 ...future.workdir <- getwd()
[01:28:24.356]             }
[01:28:24.356]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:24.356]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:24.356]         }
[01:28:24.356]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:24.356]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:24.356]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:24.356]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:24.356]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:24.356]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:24.356]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:24.356]             base::names(...future.oldOptions))
[01:28:24.356]     }
[01:28:24.356]     if (FALSE) {
[01:28:24.356]     }
[01:28:24.356]     else {
[01:28:24.356]         if (TRUE) {
[01:28:24.356]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:24.356]                 open = "w")
[01:28:24.356]         }
[01:28:24.356]         else {
[01:28:24.356]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:24.356]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:24.356]         }
[01:28:24.356]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:24.356]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:24.356]             base::sink(type = "output", split = FALSE)
[01:28:24.356]             base::close(...future.stdout)
[01:28:24.356]         }, add = TRUE)
[01:28:24.356]     }
[01:28:24.356]     ...future.frame <- base::sys.nframe()
[01:28:24.356]     ...future.conditions <- base::list()
[01:28:24.356]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:24.356]     if (FALSE) {
[01:28:24.356]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:24.356]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:24.356]     }
[01:28:24.356]     ...future.result <- base::tryCatch({
[01:28:24.356]         base::withCallingHandlers({
[01:28:24.356]             ...future.value <- base::withVisible(base::local({
[01:28:24.356]                 ...future.makeSendCondition <- base::local({
[01:28:24.356]                   sendCondition <- NULL
[01:28:24.356]                   function(frame = 1L) {
[01:28:24.356]                     if (is.function(sendCondition)) 
[01:28:24.356]                       return(sendCondition)
[01:28:24.356]                     ns <- getNamespace("parallel")
[01:28:24.356]                     if (exists("sendData", mode = "function", 
[01:28:24.356]                       envir = ns)) {
[01:28:24.356]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:24.356]                         envir = ns)
[01:28:24.356]                       envir <- sys.frame(frame)
[01:28:24.356]                       master <- NULL
[01:28:24.356]                       while (!identical(envir, .GlobalEnv) && 
[01:28:24.356]                         !identical(envir, emptyenv())) {
[01:28:24.356]                         if (exists("master", mode = "list", envir = envir, 
[01:28:24.356]                           inherits = FALSE)) {
[01:28:24.356]                           master <- get("master", mode = "list", 
[01:28:24.356]                             envir = envir, inherits = FALSE)
[01:28:24.356]                           if (inherits(master, c("SOCKnode", 
[01:28:24.356]                             "SOCK0node"))) {
[01:28:24.356]                             sendCondition <<- function(cond) {
[01:28:24.356]                               data <- list(type = "VALUE", value = cond, 
[01:28:24.356]                                 success = TRUE)
[01:28:24.356]                               parallel_sendData(master, data)
[01:28:24.356]                             }
[01:28:24.356]                             return(sendCondition)
[01:28:24.356]                           }
[01:28:24.356]                         }
[01:28:24.356]                         frame <- frame + 1L
[01:28:24.356]                         envir <- sys.frame(frame)
[01:28:24.356]                       }
[01:28:24.356]                     }
[01:28:24.356]                     sendCondition <<- function(cond) NULL
[01:28:24.356]                   }
[01:28:24.356]                 })
[01:28:24.356]                 withCallingHandlers({
[01:28:24.356]                   {
[01:28:24.356]                     gc()
[01:28:24.356]                   }
[01:28:24.356]                 }, immediateCondition = function(cond) {
[01:28:24.356]                   sendCondition <- ...future.makeSendCondition()
[01:28:24.356]                   sendCondition(cond)
[01:28:24.356]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:24.356]                   {
[01:28:24.356]                     inherits <- base::inherits
[01:28:24.356]                     invokeRestart <- base::invokeRestart
[01:28:24.356]                     is.null <- base::is.null
[01:28:24.356]                     muffled <- FALSE
[01:28:24.356]                     if (inherits(cond, "message")) {
[01:28:24.356]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:24.356]                       if (muffled) 
[01:28:24.356]                         invokeRestart("muffleMessage")
[01:28:24.356]                     }
[01:28:24.356]                     else if (inherits(cond, "warning")) {
[01:28:24.356]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:24.356]                       if (muffled) 
[01:28:24.356]                         invokeRestart("muffleWarning")
[01:28:24.356]                     }
[01:28:24.356]                     else if (inherits(cond, "condition")) {
[01:28:24.356]                       if (!is.null(pattern)) {
[01:28:24.356]                         computeRestarts <- base::computeRestarts
[01:28:24.356]                         grepl <- base::grepl
[01:28:24.356]                         restarts <- computeRestarts(cond)
[01:28:24.356]                         for (restart in restarts) {
[01:28:24.356]                           name <- restart$name
[01:28:24.356]                           if (is.null(name)) 
[01:28:24.356]                             next
[01:28:24.356]                           if (!grepl(pattern, name)) 
[01:28:24.356]                             next
[01:28:24.356]                           invokeRestart(restart)
[01:28:24.356]                           muffled <- TRUE
[01:28:24.356]                           break
[01:28:24.356]                         }
[01:28:24.356]                       }
[01:28:24.356]                     }
[01:28:24.356]                     invisible(muffled)
[01:28:24.356]                   }
[01:28:24.356]                   muffleCondition(cond)
[01:28:24.356]                 })
[01:28:24.356]             }))
[01:28:24.356]             future::FutureResult(value = ...future.value$value, 
[01:28:24.356]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:24.356]                   ...future.rng), globalenv = if (FALSE) 
[01:28:24.356]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:24.356]                     ...future.globalenv.names))
[01:28:24.356]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:24.356]         }, condition = base::local({
[01:28:24.356]             c <- base::c
[01:28:24.356]             inherits <- base::inherits
[01:28:24.356]             invokeRestart <- base::invokeRestart
[01:28:24.356]             length <- base::length
[01:28:24.356]             list <- base::list
[01:28:24.356]             seq.int <- base::seq.int
[01:28:24.356]             signalCondition <- base::signalCondition
[01:28:24.356]             sys.calls <- base::sys.calls
[01:28:24.356]             `[[` <- base::`[[`
[01:28:24.356]             `+` <- base::`+`
[01:28:24.356]             `<<-` <- base::`<<-`
[01:28:24.356]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:24.356]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:24.356]                   3L)]
[01:28:24.356]             }
[01:28:24.356]             function(cond) {
[01:28:24.356]                 is_error <- inherits(cond, "error")
[01:28:24.356]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:24.356]                   NULL)
[01:28:24.356]                 if (is_error) {
[01:28:24.356]                   sessionInformation <- function() {
[01:28:24.356]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:24.356]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:24.356]                       search = base::search(), system = base::Sys.info())
[01:28:24.356]                   }
[01:28:24.356]                   ...future.conditions[[length(...future.conditions) + 
[01:28:24.356]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:24.356]                     cond$call), session = sessionInformation(), 
[01:28:24.356]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:24.356]                   signalCondition(cond)
[01:28:24.356]                 }
[01:28:24.356]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:24.356]                 "immediateCondition"))) {
[01:28:24.356]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:24.356]                   ...future.conditions[[length(...future.conditions) + 
[01:28:24.356]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:24.356]                   if (TRUE && !signal) {
[01:28:24.356]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:24.356]                     {
[01:28:24.356]                       inherits <- base::inherits
[01:28:24.356]                       invokeRestart <- base::invokeRestart
[01:28:24.356]                       is.null <- base::is.null
[01:28:24.356]                       muffled <- FALSE
[01:28:24.356]                       if (inherits(cond, "message")) {
[01:28:24.356]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:24.356]                         if (muffled) 
[01:28:24.356]                           invokeRestart("muffleMessage")
[01:28:24.356]                       }
[01:28:24.356]                       else if (inherits(cond, "warning")) {
[01:28:24.356]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:24.356]                         if (muffled) 
[01:28:24.356]                           invokeRestart("muffleWarning")
[01:28:24.356]                       }
[01:28:24.356]                       else if (inherits(cond, "condition")) {
[01:28:24.356]                         if (!is.null(pattern)) {
[01:28:24.356]                           computeRestarts <- base::computeRestarts
[01:28:24.356]                           grepl <- base::grepl
[01:28:24.356]                           restarts <- computeRestarts(cond)
[01:28:24.356]                           for (restart in restarts) {
[01:28:24.356]                             name <- restart$name
[01:28:24.356]                             if (is.null(name)) 
[01:28:24.356]                               next
[01:28:24.356]                             if (!grepl(pattern, name)) 
[01:28:24.356]                               next
[01:28:24.356]                             invokeRestart(restart)
[01:28:24.356]                             muffled <- TRUE
[01:28:24.356]                             break
[01:28:24.356]                           }
[01:28:24.356]                         }
[01:28:24.356]                       }
[01:28:24.356]                       invisible(muffled)
[01:28:24.356]                     }
[01:28:24.356]                     muffleCondition(cond, pattern = "^muffle")
[01:28:24.356]                   }
[01:28:24.356]                 }
[01:28:24.356]                 else {
[01:28:24.356]                   if (TRUE) {
[01:28:24.356]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:24.356]                     {
[01:28:24.356]                       inherits <- base::inherits
[01:28:24.356]                       invokeRestart <- base::invokeRestart
[01:28:24.356]                       is.null <- base::is.null
[01:28:24.356]                       muffled <- FALSE
[01:28:24.356]                       if (inherits(cond, "message")) {
[01:28:24.356]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:24.356]                         if (muffled) 
[01:28:24.356]                           invokeRestart("muffleMessage")
[01:28:24.356]                       }
[01:28:24.356]                       else if (inherits(cond, "warning")) {
[01:28:24.356]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:24.356]                         if (muffled) 
[01:28:24.356]                           invokeRestart("muffleWarning")
[01:28:24.356]                       }
[01:28:24.356]                       else if (inherits(cond, "condition")) {
[01:28:24.356]                         if (!is.null(pattern)) {
[01:28:24.356]                           computeRestarts <- base::computeRestarts
[01:28:24.356]                           grepl <- base::grepl
[01:28:24.356]                           restarts <- computeRestarts(cond)
[01:28:24.356]                           for (restart in restarts) {
[01:28:24.356]                             name <- restart$name
[01:28:24.356]                             if (is.null(name)) 
[01:28:24.356]                               next
[01:28:24.356]                             if (!grepl(pattern, name)) 
[01:28:24.356]                               next
[01:28:24.356]                             invokeRestart(restart)
[01:28:24.356]                             muffled <- TRUE
[01:28:24.356]                             break
[01:28:24.356]                           }
[01:28:24.356]                         }
[01:28:24.356]                       }
[01:28:24.356]                       invisible(muffled)
[01:28:24.356]                     }
[01:28:24.356]                     muffleCondition(cond, pattern = "^muffle")
[01:28:24.356]                   }
[01:28:24.356]                 }
[01:28:24.356]             }
[01:28:24.356]         }))
[01:28:24.356]     }, error = function(ex) {
[01:28:24.356]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:24.356]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:24.356]                 ...future.rng), started = ...future.startTime, 
[01:28:24.356]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:24.356]             version = "1.8"), class = "FutureResult")
[01:28:24.356]     }, finally = {
[01:28:24.356]         if (!identical(...future.workdir, getwd())) 
[01:28:24.356]             setwd(...future.workdir)
[01:28:24.356]         {
[01:28:24.356]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:24.356]                 ...future.oldOptions$nwarnings <- NULL
[01:28:24.356]             }
[01:28:24.356]             base::options(...future.oldOptions)
[01:28:24.356]             if (.Platform$OS.type == "windows") {
[01:28:24.356]                 old_names <- names(...future.oldEnvVars)
[01:28:24.356]                 envs <- base::Sys.getenv()
[01:28:24.356]                 names <- names(envs)
[01:28:24.356]                 common <- intersect(names, old_names)
[01:28:24.356]                 added <- setdiff(names, old_names)
[01:28:24.356]                 removed <- setdiff(old_names, names)
[01:28:24.356]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:24.356]                   envs[common]]
[01:28:24.356]                 NAMES <- toupper(changed)
[01:28:24.356]                 args <- list()
[01:28:24.356]                 for (kk in seq_along(NAMES)) {
[01:28:24.356]                   name <- changed[[kk]]
[01:28:24.356]                   NAME <- NAMES[[kk]]
[01:28:24.356]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:24.356]                     next
[01:28:24.356]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:24.356]                 }
[01:28:24.356]                 NAMES <- toupper(added)
[01:28:24.356]                 for (kk in seq_along(NAMES)) {
[01:28:24.356]                   name <- added[[kk]]
[01:28:24.356]                   NAME <- NAMES[[kk]]
[01:28:24.356]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:24.356]                     next
[01:28:24.356]                   args[[name]] <- ""
[01:28:24.356]                 }
[01:28:24.356]                 NAMES <- toupper(removed)
[01:28:24.356]                 for (kk in seq_along(NAMES)) {
[01:28:24.356]                   name <- removed[[kk]]
[01:28:24.356]                   NAME <- NAMES[[kk]]
[01:28:24.356]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:24.356]                     next
[01:28:24.356]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:24.356]                 }
[01:28:24.356]                 if (length(args) > 0) 
[01:28:24.356]                   base::do.call(base::Sys.setenv, args = args)
[01:28:24.356]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:24.356]             }
[01:28:24.356]             else {
[01:28:24.356]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:24.356]             }
[01:28:24.356]             {
[01:28:24.356]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:24.356]                   0L) {
[01:28:24.356]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:24.356]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:24.356]                   base::options(opts)
[01:28:24.356]                 }
[01:28:24.356]                 {
[01:28:24.356]                   {
[01:28:24.356]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:24.356]                     NULL
[01:28:24.356]                   }
[01:28:24.356]                   options(future.plan = NULL)
[01:28:24.356]                   if (is.na(NA_character_)) 
[01:28:24.356]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:24.356]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:24.356]                   future::plan(list(function (..., workers = 2L, 
[01:28:24.356]                     envir = parent.frame()) 
[01:28:24.356]                   strategy(..., workers = workers, envir = envir)), 
[01:28:24.356]                     .cleanup = FALSE, .init = FALSE)
[01:28:24.356]                 }
[01:28:24.356]             }
[01:28:24.356]         }
[01:28:24.356]     })
[01:28:24.356]     if (TRUE) {
[01:28:24.356]         base::sink(type = "output", split = FALSE)
[01:28:24.356]         if (TRUE) {
[01:28:24.356]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:24.356]         }
[01:28:24.356]         else {
[01:28:24.356]             ...future.result["stdout"] <- base::list(NULL)
[01:28:24.356]         }
[01:28:24.356]         base::close(...future.stdout)
[01:28:24.356]         ...future.stdout <- NULL
[01:28:24.356]     }
[01:28:24.356]     ...future.result$conditions <- ...future.conditions
[01:28:24.356]     ...future.result$finished <- base::Sys.time()
[01:28:24.356]     ...future.result
[01:28:24.356] }
[01:28:24.365] MultisessionFuture started
[01:28:24.365] - Launch lazy future ... done
[01:28:24.365] run() for 'MultisessionFuture' ... done
> v <- value(f)
[01:28:24.366] result() for ClusterFuture ...
[01:28:24.366] receiveMessageFromWorker() for ClusterFuture ...
[01:28:24.366] - Validating connection of MultisessionFuture
[01:28:24.400] - received message: FutureResult
[01:28:24.400] - Received FutureResult
[01:28:24.400] - Erased future from FutureRegistry
[01:28:24.401] result() for ClusterFuture ...
[01:28:24.401] - result already collected: FutureResult
[01:28:24.401] result() for ClusterFuture ... done
[01:28:24.401] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:24.401] result() for ClusterFuture ... done
[01:28:24.401] result() for ClusterFuture ...
[01:28:24.402] - result already collected: FutureResult
[01:28:24.402] result() for ClusterFuture ... done
> print(v)
         used (Mb) gc trigger (Mb) max used (Mb)
Ncells 407839 21.8     848270 45.4   633968 33.9
Vcells 725496  5.6    8388608 64.0  2002214 15.3
> 
> f <- future({ integer(10e6) })
[01:28:24.402] getGlobalsAndPackages() ...
[01:28:24.403] Searching for globals...
[01:28:24.403] - globals found: [2] '{', 'integer'
[01:28:24.404] Searching for globals ... DONE
[01:28:24.404] Resolving globals: FALSE
[01:28:24.404] 
[01:28:24.404] 
[01:28:24.405] getGlobalsAndPackages() ... DONE
[01:28:24.405] run() for 'Future' ...
[01:28:24.405] - state: 'created'
[01:28:24.405] - Future backend: 'FutureStrategy', 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:24.418] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:24.418] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:24.418]   - Field: 'node'
[01:28:24.418]   - Field: 'label'
[01:28:24.418]   - Field: 'local'
[01:28:24.419]   - Field: 'owner'
[01:28:24.419]   - Field: 'envir'
[01:28:24.419]   - Field: 'workers'
[01:28:24.419]   - Field: 'packages'
[01:28:24.419]   - Field: 'gc'
[01:28:24.419]   - Field: 'conditions'
[01:28:24.420]   - Field: 'persistent'
[01:28:24.420]   - Field: 'expr'
[01:28:24.420]   - Field: 'uuid'
[01:28:24.420]   - Field: 'seed'
[01:28:24.420]   - Field: 'version'
[01:28:24.421]   - Field: 'result'
[01:28:24.421]   - Field: 'asynchronous'
[01:28:24.421]   - Field: 'calls'
[01:28:24.421]   - Field: 'globals'
[01:28:24.421]   - Field: 'stdout'
[01:28:24.421]   - Field: 'earlySignal'
[01:28:24.422]   - Field: 'lazy'
[01:28:24.422]   - Field: 'state'
[01:28:24.422] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:24.422] - Launch lazy future ...
[01:28:24.422] Packages needed by the future expression (n = 0): <none>
[01:28:24.423] Packages needed by future strategies (n = 0): <none>
[01:28:24.423] {
[01:28:24.423]     {
[01:28:24.423]         {
[01:28:24.423]             ...future.startTime <- base::Sys.time()
[01:28:24.423]             {
[01:28:24.423]                 {
[01:28:24.423]                   {
[01:28:24.423]                     {
[01:28:24.423]                       base::local({
[01:28:24.423]                         has_future <- base::requireNamespace("future", 
[01:28:24.423]                           quietly = TRUE)
[01:28:24.423]                         if (has_future) {
[01:28:24.423]                           ns <- base::getNamespace("future")
[01:28:24.423]                           version <- ns[[".package"]][["version"]]
[01:28:24.423]                           if (is.null(version)) 
[01:28:24.423]                             version <- utils::packageVersion("future")
[01:28:24.423]                         }
[01:28:24.423]                         else {
[01:28:24.423]                           version <- NULL
[01:28:24.423]                         }
[01:28:24.423]                         if (!has_future || version < "1.8.0") {
[01:28:24.423]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:24.423]                             "", base::R.version$version.string), 
[01:28:24.423]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:24.423]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:24.423]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:24.423]                               "release", "version")], collapse = " "), 
[01:28:24.423]                             hostname = base::Sys.info()[["nodename"]])
[01:28:24.423]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:24.423]                             info)
[01:28:24.423]                           info <- base::paste(info, collapse = "; ")
[01:28:24.423]                           if (!has_future) {
[01:28:24.423]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:24.423]                               info)
[01:28:24.423]                           }
[01:28:24.423]                           else {
[01:28:24.423]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:24.423]                               info, version)
[01:28:24.423]                           }
[01:28:24.423]                           base::stop(msg)
[01:28:24.423]                         }
[01:28:24.423]                       })
[01:28:24.423]                     }
[01:28:24.423]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:24.423]                     base::options(mc.cores = 1L)
[01:28:24.423]                   }
[01:28:24.423]                   options(future.plan = NULL)
[01:28:24.423]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:24.423]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:24.423]                 }
[01:28:24.423]                 ...future.workdir <- getwd()
[01:28:24.423]             }
[01:28:24.423]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:24.423]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:24.423]         }
[01:28:24.423]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:24.423]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:24.423]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:24.423]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:24.423]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:24.423]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:24.423]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:24.423]             base::names(...future.oldOptions))
[01:28:24.423]     }
[01:28:24.423]     if (FALSE) {
[01:28:24.423]     }
[01:28:24.423]     else {
[01:28:24.423]         if (TRUE) {
[01:28:24.423]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:24.423]                 open = "w")
[01:28:24.423]         }
[01:28:24.423]         else {
[01:28:24.423]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:24.423]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:24.423]         }
[01:28:24.423]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:24.423]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:24.423]             base::sink(type = "output", split = FALSE)
[01:28:24.423]             base::close(...future.stdout)
[01:28:24.423]         }, add = TRUE)
[01:28:24.423]     }
[01:28:24.423]     ...future.frame <- base::sys.nframe()
[01:28:24.423]     ...future.conditions <- base::list()
[01:28:24.423]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:24.423]     if (FALSE) {
[01:28:24.423]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:24.423]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:24.423]     }
[01:28:24.423]     ...future.result <- base::tryCatch({
[01:28:24.423]         base::withCallingHandlers({
[01:28:24.423]             ...future.value <- base::withVisible(base::local({
[01:28:24.423]                 ...future.makeSendCondition <- base::local({
[01:28:24.423]                   sendCondition <- NULL
[01:28:24.423]                   function(frame = 1L) {
[01:28:24.423]                     if (is.function(sendCondition)) 
[01:28:24.423]                       return(sendCondition)
[01:28:24.423]                     ns <- getNamespace("parallel")
[01:28:24.423]                     if (exists("sendData", mode = "function", 
[01:28:24.423]                       envir = ns)) {
[01:28:24.423]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:24.423]                         envir = ns)
[01:28:24.423]                       envir <- sys.frame(frame)
[01:28:24.423]                       master <- NULL
[01:28:24.423]                       while (!identical(envir, .GlobalEnv) && 
[01:28:24.423]                         !identical(envir, emptyenv())) {
[01:28:24.423]                         if (exists("master", mode = "list", envir = envir, 
[01:28:24.423]                           inherits = FALSE)) {
[01:28:24.423]                           master <- get("master", mode = "list", 
[01:28:24.423]                             envir = envir, inherits = FALSE)
[01:28:24.423]                           if (inherits(master, c("SOCKnode", 
[01:28:24.423]                             "SOCK0node"))) {
[01:28:24.423]                             sendCondition <<- function(cond) {
[01:28:24.423]                               data <- list(type = "VALUE", value = cond, 
[01:28:24.423]                                 success = TRUE)
[01:28:24.423]                               parallel_sendData(master, data)
[01:28:24.423]                             }
[01:28:24.423]                             return(sendCondition)
[01:28:24.423]                           }
[01:28:24.423]                         }
[01:28:24.423]                         frame <- frame + 1L
[01:28:24.423]                         envir <- sys.frame(frame)
[01:28:24.423]                       }
[01:28:24.423]                     }
[01:28:24.423]                     sendCondition <<- function(cond) NULL
[01:28:24.423]                   }
[01:28:24.423]                 })
[01:28:24.423]                 withCallingHandlers({
[01:28:24.423]                   {
[01:28:24.423]                     integer(1e+07)
[01:28:24.423]                   }
[01:28:24.423]                 }, immediateCondition = function(cond) {
[01:28:24.423]                   sendCondition <- ...future.makeSendCondition()
[01:28:24.423]                   sendCondition(cond)
[01:28:24.423]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:24.423]                   {
[01:28:24.423]                     inherits <- base::inherits
[01:28:24.423]                     invokeRestart <- base::invokeRestart
[01:28:24.423]                     is.null <- base::is.null
[01:28:24.423]                     muffled <- FALSE
[01:28:24.423]                     if (inherits(cond, "message")) {
[01:28:24.423]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:24.423]                       if (muffled) 
[01:28:24.423]                         invokeRestart("muffleMessage")
[01:28:24.423]                     }
[01:28:24.423]                     else if (inherits(cond, "warning")) {
[01:28:24.423]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:24.423]                       if (muffled) 
[01:28:24.423]                         invokeRestart("muffleWarning")
[01:28:24.423]                     }
[01:28:24.423]                     else if (inherits(cond, "condition")) {
[01:28:24.423]                       if (!is.null(pattern)) {
[01:28:24.423]                         computeRestarts <- base::computeRestarts
[01:28:24.423]                         grepl <- base::grepl
[01:28:24.423]                         restarts <- computeRestarts(cond)
[01:28:24.423]                         for (restart in restarts) {
[01:28:24.423]                           name <- restart$name
[01:28:24.423]                           if (is.null(name)) 
[01:28:24.423]                             next
[01:28:24.423]                           if (!grepl(pattern, name)) 
[01:28:24.423]                             next
[01:28:24.423]                           invokeRestart(restart)
[01:28:24.423]                           muffled <- TRUE
[01:28:24.423]                           break
[01:28:24.423]                         }
[01:28:24.423]                       }
[01:28:24.423]                     }
[01:28:24.423]                     invisible(muffled)
[01:28:24.423]                   }
[01:28:24.423]                   muffleCondition(cond)
[01:28:24.423]                 })
[01:28:24.423]             }))
[01:28:24.423]             future::FutureResult(value = ...future.value$value, 
[01:28:24.423]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:24.423]                   ...future.rng), globalenv = if (FALSE) 
[01:28:24.423]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:24.423]                     ...future.globalenv.names))
[01:28:24.423]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:24.423]         }, condition = base::local({
[01:28:24.423]             c <- base::c
[01:28:24.423]             inherits <- base::inherits
[01:28:24.423]             invokeRestart <- base::invokeRestart
[01:28:24.423]             length <- base::length
[01:28:24.423]             list <- base::list
[01:28:24.423]             seq.int <- base::seq.int
[01:28:24.423]             signalCondition <- base::signalCondition
[01:28:24.423]             sys.calls <- base::sys.calls
[01:28:24.423]             `[[` <- base::`[[`
[01:28:24.423]             `+` <- base::`+`
[01:28:24.423]             `<<-` <- base::`<<-`
[01:28:24.423]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:24.423]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:24.423]                   3L)]
[01:28:24.423]             }
[01:28:24.423]             function(cond) {
[01:28:24.423]                 is_error <- inherits(cond, "error")
[01:28:24.423]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:24.423]                   NULL)
[01:28:24.423]                 if (is_error) {
[01:28:24.423]                   sessionInformation <- function() {
[01:28:24.423]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:24.423]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:24.423]                       search = base::search(), system = base::Sys.info())
[01:28:24.423]                   }
[01:28:24.423]                   ...future.conditions[[length(...future.conditions) + 
[01:28:24.423]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:24.423]                     cond$call), session = sessionInformation(), 
[01:28:24.423]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:24.423]                   signalCondition(cond)
[01:28:24.423]                 }
[01:28:24.423]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:24.423]                 "immediateCondition"))) {
[01:28:24.423]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:24.423]                   ...future.conditions[[length(...future.conditions) + 
[01:28:24.423]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:24.423]                   if (TRUE && !signal) {
[01:28:24.423]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:24.423]                     {
[01:28:24.423]                       inherits <- base::inherits
[01:28:24.423]                       invokeRestart <- base::invokeRestart
[01:28:24.423]                       is.null <- base::is.null
[01:28:24.423]                       muffled <- FALSE
[01:28:24.423]                       if (inherits(cond, "message")) {
[01:28:24.423]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:24.423]                         if (muffled) 
[01:28:24.423]                           invokeRestart("muffleMessage")
[01:28:24.423]                       }
[01:28:24.423]                       else if (inherits(cond, "warning")) {
[01:28:24.423]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:24.423]                         if (muffled) 
[01:28:24.423]                           invokeRestart("muffleWarning")
[01:28:24.423]                       }
[01:28:24.423]                       else if (inherits(cond, "condition")) {
[01:28:24.423]                         if (!is.null(pattern)) {
[01:28:24.423]                           computeRestarts <- base::computeRestarts
[01:28:24.423]                           grepl <- base::grepl
[01:28:24.423]                           restarts <- computeRestarts(cond)
[01:28:24.423]                           for (restart in restarts) {
[01:28:24.423]                             name <- restart$name
[01:28:24.423]                             if (is.null(name)) 
[01:28:24.423]                               next
[01:28:24.423]                             if (!grepl(pattern, name)) 
[01:28:24.423]                               next
[01:28:24.423]                             invokeRestart(restart)
[01:28:24.423]                             muffled <- TRUE
[01:28:24.423]                             break
[01:28:24.423]                           }
[01:28:24.423]                         }
[01:28:24.423]                       }
[01:28:24.423]                       invisible(muffled)
[01:28:24.423]                     }
[01:28:24.423]                     muffleCondition(cond, pattern = "^muffle")
[01:28:24.423]                   }
[01:28:24.423]                 }
[01:28:24.423]                 else {
[01:28:24.423]                   if (TRUE) {
[01:28:24.423]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:24.423]                     {
[01:28:24.423]                       inherits <- base::inherits
[01:28:24.423]                       invokeRestart <- base::invokeRestart
[01:28:24.423]                       is.null <- base::is.null
[01:28:24.423]                       muffled <- FALSE
[01:28:24.423]                       if (inherits(cond, "message")) {
[01:28:24.423]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:24.423]                         if (muffled) 
[01:28:24.423]                           invokeRestart("muffleMessage")
[01:28:24.423]                       }
[01:28:24.423]                       else if (inherits(cond, "warning")) {
[01:28:24.423]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:24.423]                         if (muffled) 
[01:28:24.423]                           invokeRestart("muffleWarning")
[01:28:24.423]                       }
[01:28:24.423]                       else if (inherits(cond, "condition")) {
[01:28:24.423]                         if (!is.null(pattern)) {
[01:28:24.423]                           computeRestarts <- base::computeRestarts
[01:28:24.423]                           grepl <- base::grepl
[01:28:24.423]                           restarts <- computeRestarts(cond)
[01:28:24.423]                           for (restart in restarts) {
[01:28:24.423]                             name <- restart$name
[01:28:24.423]                             if (is.null(name)) 
[01:28:24.423]                               next
[01:28:24.423]                             if (!grepl(pattern, name)) 
[01:28:24.423]                               next
[01:28:24.423]                             invokeRestart(restart)
[01:28:24.423]                             muffled <- TRUE
[01:28:24.423]                             break
[01:28:24.423]                           }
[01:28:24.423]                         }
[01:28:24.423]                       }
[01:28:24.423]                       invisible(muffled)
[01:28:24.423]                     }
[01:28:24.423]                     muffleCondition(cond, pattern = "^muffle")
[01:28:24.423]                   }
[01:28:24.423]                 }
[01:28:24.423]             }
[01:28:24.423]         }))
[01:28:24.423]     }, error = function(ex) {
[01:28:24.423]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:24.423]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:24.423]                 ...future.rng), started = ...future.startTime, 
[01:28:24.423]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:24.423]             version = "1.8"), class = "FutureResult")
[01:28:24.423]     }, finally = {
[01:28:24.423]         if (!identical(...future.workdir, getwd())) 
[01:28:24.423]             setwd(...future.workdir)
[01:28:24.423]         {
[01:28:24.423]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:24.423]                 ...future.oldOptions$nwarnings <- NULL
[01:28:24.423]             }
[01:28:24.423]             base::options(...future.oldOptions)
[01:28:24.423]             if (.Platform$OS.type == "windows") {
[01:28:24.423]                 old_names <- names(...future.oldEnvVars)
[01:28:24.423]                 envs <- base::Sys.getenv()
[01:28:24.423]                 names <- names(envs)
[01:28:24.423]                 common <- intersect(names, old_names)
[01:28:24.423]                 added <- setdiff(names, old_names)
[01:28:24.423]                 removed <- setdiff(old_names, names)
[01:28:24.423]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:24.423]                   envs[common]]
[01:28:24.423]                 NAMES <- toupper(changed)
[01:28:24.423]                 args <- list()
[01:28:24.423]                 for (kk in seq_along(NAMES)) {
[01:28:24.423]                   name <- changed[[kk]]
[01:28:24.423]                   NAME <- NAMES[[kk]]
[01:28:24.423]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:24.423]                     next
[01:28:24.423]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:24.423]                 }
[01:28:24.423]                 NAMES <- toupper(added)
[01:28:24.423]                 for (kk in seq_along(NAMES)) {
[01:28:24.423]                   name <- added[[kk]]
[01:28:24.423]                   NAME <- NAMES[[kk]]
[01:28:24.423]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:24.423]                     next
[01:28:24.423]                   args[[name]] <- ""
[01:28:24.423]                 }
[01:28:24.423]                 NAMES <- toupper(removed)
[01:28:24.423]                 for (kk in seq_along(NAMES)) {
[01:28:24.423]                   name <- removed[[kk]]
[01:28:24.423]                   NAME <- NAMES[[kk]]
[01:28:24.423]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:24.423]                     next
[01:28:24.423]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:24.423]                 }
[01:28:24.423]                 if (length(args) > 0) 
[01:28:24.423]                   base::do.call(base::Sys.setenv, args = args)
[01:28:24.423]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:24.423]             }
[01:28:24.423]             else {
[01:28:24.423]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:24.423]             }
[01:28:24.423]             {
[01:28:24.423]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:24.423]                   0L) {
[01:28:24.423]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:24.423]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:24.423]                   base::options(opts)
[01:28:24.423]                 }
[01:28:24.423]                 {
[01:28:24.423]                   {
[01:28:24.423]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:24.423]                     NULL
[01:28:24.423]                   }
[01:28:24.423]                   options(future.plan = NULL)
[01:28:24.423]                   if (is.na(NA_character_)) 
[01:28:24.423]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:24.423]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:24.423]                   future::plan(list(function (..., workers = 2L, 
[01:28:24.423]                     envir = parent.frame()) 
[01:28:24.423]                   strategy(..., workers = workers, envir = envir)), 
[01:28:24.423]                     .cleanup = FALSE, .init = FALSE)
[01:28:24.423]                 }
[01:28:24.423]             }
[01:28:24.423]         }
[01:28:24.423]     })
[01:28:24.423]     if (TRUE) {
[01:28:24.423]         base::sink(type = "output", split = FALSE)
[01:28:24.423]         if (TRUE) {
[01:28:24.423]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:24.423]         }
[01:28:24.423]         else {
[01:28:24.423]             ...future.result["stdout"] <- base::list(NULL)
[01:28:24.423]         }
[01:28:24.423]         base::close(...future.stdout)
[01:28:24.423]         ...future.stdout <- NULL
[01:28:24.423]     }
[01:28:24.423]     ...future.result$conditions <- ...future.conditions
[01:28:24.423]     ...future.result$finished <- base::Sys.time()
[01:28:24.423]     ...future.result
[01:28:24.423] }
[01:28:24.429] MultisessionFuture started
[01:28:24.429] - Launch lazy future ... done
[01:28:24.429] run() for 'MultisessionFuture' ... done
> v <- value(f)
[01:28:24.430] result() for ClusterFuture ...
[01:28:24.430] receiveMessageFromWorker() for ClusterFuture ...
[01:28:24.430] - Validating connection of MultisessionFuture
[01:28:24.516] - received message: FutureResult
[01:28:24.517] - Received FutureResult
[01:28:24.518] - Erased future from FutureRegistry
[01:28:24.518] result() for ClusterFuture ...
[01:28:24.518] - result already collected: FutureResult
[01:28:24.519] result() for ClusterFuture ... done
[01:28:24.519] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:24.519] result() for ClusterFuture ... done
[01:28:24.519] result() for ClusterFuture ...
[01:28:24.519] - result already collected: FutureResult
[01:28:24.520] result() for ClusterFuture ... done
> str(v)
 int [1:10000000] 0 0 0 0 0 0 0 0 0 0 ...
> 
> f <- future({ gc() })
[01:28:24.521] getGlobalsAndPackages() ...
[01:28:24.521] Searching for globals...
[01:28:24.523] - globals found: [2] '{', 'gc'
[01:28:24.523] Searching for globals ... DONE
[01:28:24.523] Resolving globals: FALSE
[01:28:24.524] 
[01:28:24.524] 
[01:28:24.524] getGlobalsAndPackages() ... DONE
[01:28:24.525] run() for 'Future' ...
[01:28:24.525] - state: 'created'
[01:28:24.525] - Future backend: 'FutureStrategy', 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:24.539] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:24.539] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:24.539]   - Field: 'node'
[01:28:24.539]   - Field: 'label'
[01:28:24.540]   - Field: 'local'
[01:28:24.540]   - Field: 'owner'
[01:28:24.540]   - Field: 'envir'
[01:28:24.540]   - Field: 'workers'
[01:28:24.540]   - Field: 'packages'
[01:28:24.541]   - Field: 'gc'
[01:28:24.541]   - Field: 'conditions'
[01:28:24.541]   - Field: 'persistent'
[01:28:24.541]   - Field: 'expr'
[01:28:24.541]   - Field: 'uuid'
[01:28:24.541]   - Field: 'seed'
[01:28:24.542]   - Field: 'version'
[01:28:24.542]   - Field: 'result'
[01:28:24.542]   - Field: 'asynchronous'
[01:28:24.542]   - Field: 'calls'
[01:28:24.545]   - Field: 'globals'
[01:28:24.545]   - Field: 'stdout'
[01:28:24.546]   - Field: 'earlySignal'
[01:28:24.546]   - Field: 'lazy'
[01:28:24.546]   - Field: 'state'
[01:28:24.546] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:24.546] - Launch lazy future ...
[01:28:24.547] Packages needed by the future expression (n = 0): <none>
[01:28:24.547] Packages needed by future strategies (n = 0): <none>
[01:28:24.548] {
[01:28:24.548]     {
[01:28:24.548]         {
[01:28:24.548]             ...future.startTime <- base::Sys.time()
[01:28:24.548]             {
[01:28:24.548]                 {
[01:28:24.548]                   {
[01:28:24.548]                     {
[01:28:24.548]                       base::local({
[01:28:24.548]                         has_future <- base::requireNamespace("future", 
[01:28:24.548]                           quietly = TRUE)
[01:28:24.548]                         if (has_future) {
[01:28:24.548]                           ns <- base::getNamespace("future")
[01:28:24.548]                           version <- ns[[".package"]][["version"]]
[01:28:24.548]                           if (is.null(version)) 
[01:28:24.548]                             version <- utils::packageVersion("future")
[01:28:24.548]                         }
[01:28:24.548]                         else {
[01:28:24.548]                           version <- NULL
[01:28:24.548]                         }
[01:28:24.548]                         if (!has_future || version < "1.8.0") {
[01:28:24.548]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:24.548]                             "", base::R.version$version.string), 
[01:28:24.548]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:24.548]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:24.548]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:24.548]                               "release", "version")], collapse = " "), 
[01:28:24.548]                             hostname = base::Sys.info()[["nodename"]])
[01:28:24.548]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:24.548]                             info)
[01:28:24.548]                           info <- base::paste(info, collapse = "; ")
[01:28:24.548]                           if (!has_future) {
[01:28:24.548]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:24.548]                               info)
[01:28:24.548]                           }
[01:28:24.548]                           else {
[01:28:24.548]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:24.548]                               info, version)
[01:28:24.548]                           }
[01:28:24.548]                           base::stop(msg)
[01:28:24.548]                         }
[01:28:24.548]                       })
[01:28:24.548]                     }
[01:28:24.548]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:24.548]                     base::options(mc.cores = 1L)
[01:28:24.548]                   }
[01:28:24.548]                   options(future.plan = NULL)
[01:28:24.548]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:24.548]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:24.548]                 }
[01:28:24.548]                 ...future.workdir <- getwd()
[01:28:24.548]             }
[01:28:24.548]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:24.548]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:24.548]         }
[01:28:24.548]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:24.548]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:24.548]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:24.548]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:24.548]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:24.548]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:24.548]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:24.548]             base::names(...future.oldOptions))
[01:28:24.548]     }
[01:28:24.548]     if (FALSE) {
[01:28:24.548]     }
[01:28:24.548]     else {
[01:28:24.548]         if (TRUE) {
[01:28:24.548]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:24.548]                 open = "w")
[01:28:24.548]         }
[01:28:24.548]         else {
[01:28:24.548]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:24.548]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:24.548]         }
[01:28:24.548]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:24.548]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:24.548]             base::sink(type = "output", split = FALSE)
[01:28:24.548]             base::close(...future.stdout)
[01:28:24.548]         }, add = TRUE)
[01:28:24.548]     }
[01:28:24.548]     ...future.frame <- base::sys.nframe()
[01:28:24.548]     ...future.conditions <- base::list()
[01:28:24.548]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:24.548]     if (FALSE) {
[01:28:24.548]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:24.548]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:24.548]     }
[01:28:24.548]     ...future.result <- base::tryCatch({
[01:28:24.548]         base::withCallingHandlers({
[01:28:24.548]             ...future.value <- base::withVisible(base::local({
[01:28:24.548]                 ...future.makeSendCondition <- base::local({
[01:28:24.548]                   sendCondition <- NULL
[01:28:24.548]                   function(frame = 1L) {
[01:28:24.548]                     if (is.function(sendCondition)) 
[01:28:24.548]                       return(sendCondition)
[01:28:24.548]                     ns <- getNamespace("parallel")
[01:28:24.548]                     if (exists("sendData", mode = "function", 
[01:28:24.548]                       envir = ns)) {
[01:28:24.548]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:24.548]                         envir = ns)
[01:28:24.548]                       envir <- sys.frame(frame)
[01:28:24.548]                       master <- NULL
[01:28:24.548]                       while (!identical(envir, .GlobalEnv) && 
[01:28:24.548]                         !identical(envir, emptyenv())) {
[01:28:24.548]                         if (exists("master", mode = "list", envir = envir, 
[01:28:24.548]                           inherits = FALSE)) {
[01:28:24.548]                           master <- get("master", mode = "list", 
[01:28:24.548]                             envir = envir, inherits = FALSE)
[01:28:24.548]                           if (inherits(master, c("SOCKnode", 
[01:28:24.548]                             "SOCK0node"))) {
[01:28:24.548]                             sendCondition <<- function(cond) {
[01:28:24.548]                               data <- list(type = "VALUE", value = cond, 
[01:28:24.548]                                 success = TRUE)
[01:28:24.548]                               parallel_sendData(master, data)
[01:28:24.548]                             }
[01:28:24.548]                             return(sendCondition)
[01:28:24.548]                           }
[01:28:24.548]                         }
[01:28:24.548]                         frame <- frame + 1L
[01:28:24.548]                         envir <- sys.frame(frame)
[01:28:24.548]                       }
[01:28:24.548]                     }
[01:28:24.548]                     sendCondition <<- function(cond) NULL
[01:28:24.548]                   }
[01:28:24.548]                 })
[01:28:24.548]                 withCallingHandlers({
[01:28:24.548]                   {
[01:28:24.548]                     gc()
[01:28:24.548]                   }
[01:28:24.548]                 }, immediateCondition = function(cond) {
[01:28:24.548]                   sendCondition <- ...future.makeSendCondition()
[01:28:24.548]                   sendCondition(cond)
[01:28:24.548]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:24.548]                   {
[01:28:24.548]                     inherits <- base::inherits
[01:28:24.548]                     invokeRestart <- base::invokeRestart
[01:28:24.548]                     is.null <- base::is.null
[01:28:24.548]                     muffled <- FALSE
[01:28:24.548]                     if (inherits(cond, "message")) {
[01:28:24.548]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:24.548]                       if (muffled) 
[01:28:24.548]                         invokeRestart("muffleMessage")
[01:28:24.548]                     }
[01:28:24.548]                     else if (inherits(cond, "warning")) {
[01:28:24.548]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:24.548]                       if (muffled) 
[01:28:24.548]                         invokeRestart("muffleWarning")
[01:28:24.548]                     }
[01:28:24.548]                     else if (inherits(cond, "condition")) {
[01:28:24.548]                       if (!is.null(pattern)) {
[01:28:24.548]                         computeRestarts <- base::computeRestarts
[01:28:24.548]                         grepl <- base::grepl
[01:28:24.548]                         restarts <- computeRestarts(cond)
[01:28:24.548]                         for (restart in restarts) {
[01:28:24.548]                           name <- restart$name
[01:28:24.548]                           if (is.null(name)) 
[01:28:24.548]                             next
[01:28:24.548]                           if (!grepl(pattern, name)) 
[01:28:24.548]                             next
[01:28:24.548]                           invokeRestart(restart)
[01:28:24.548]                           muffled <- TRUE
[01:28:24.548]                           break
[01:28:24.548]                         }
[01:28:24.548]                       }
[01:28:24.548]                     }
[01:28:24.548]                     invisible(muffled)
[01:28:24.548]                   }
[01:28:24.548]                   muffleCondition(cond)
[01:28:24.548]                 })
[01:28:24.548]             }))
[01:28:24.548]             future::FutureResult(value = ...future.value$value, 
[01:28:24.548]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:24.548]                   ...future.rng), globalenv = if (FALSE) 
[01:28:24.548]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:24.548]                     ...future.globalenv.names))
[01:28:24.548]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:24.548]         }, condition = base::local({
[01:28:24.548]             c <- base::c
[01:28:24.548]             inherits <- base::inherits
[01:28:24.548]             invokeRestart <- base::invokeRestart
[01:28:24.548]             length <- base::length
[01:28:24.548]             list <- base::list
[01:28:24.548]             seq.int <- base::seq.int
[01:28:24.548]             signalCondition <- base::signalCondition
[01:28:24.548]             sys.calls <- base::sys.calls
[01:28:24.548]             `[[` <- base::`[[`
[01:28:24.548]             `+` <- base::`+`
[01:28:24.548]             `<<-` <- base::`<<-`
[01:28:24.548]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:24.548]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:24.548]                   3L)]
[01:28:24.548]             }
[01:28:24.548]             function(cond) {
[01:28:24.548]                 is_error <- inherits(cond, "error")
[01:28:24.548]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:24.548]                   NULL)
[01:28:24.548]                 if (is_error) {
[01:28:24.548]                   sessionInformation <- function() {
[01:28:24.548]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:24.548]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:24.548]                       search = base::search(), system = base::Sys.info())
[01:28:24.548]                   }
[01:28:24.548]                   ...future.conditions[[length(...future.conditions) + 
[01:28:24.548]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:24.548]                     cond$call), session = sessionInformation(), 
[01:28:24.548]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:24.548]                   signalCondition(cond)
[01:28:24.548]                 }
[01:28:24.548]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:24.548]                 "immediateCondition"))) {
[01:28:24.548]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:24.548]                   ...future.conditions[[length(...future.conditions) + 
[01:28:24.548]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:24.548]                   if (TRUE && !signal) {
[01:28:24.548]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:24.548]                     {
[01:28:24.548]                       inherits <- base::inherits
[01:28:24.548]                       invokeRestart <- base::invokeRestart
[01:28:24.548]                       is.null <- base::is.null
[01:28:24.548]                       muffled <- FALSE
[01:28:24.548]                       if (inherits(cond, "message")) {
[01:28:24.548]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:24.548]                         if (muffled) 
[01:28:24.548]                           invokeRestart("muffleMessage")
[01:28:24.548]                       }
[01:28:24.548]                       else if (inherits(cond, "warning")) {
[01:28:24.548]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:24.548]                         if (muffled) 
[01:28:24.548]                           invokeRestart("muffleWarning")
[01:28:24.548]                       }
[01:28:24.548]                       else if (inherits(cond, "condition")) {
[01:28:24.548]                         if (!is.null(pattern)) {
[01:28:24.548]                           computeRestarts <- base::computeRestarts
[01:28:24.548]                           grepl <- base::grepl
[01:28:24.548]                           restarts <- computeRestarts(cond)
[01:28:24.548]                           for (restart in restarts) {
[01:28:24.548]                             name <- restart$name
[01:28:24.548]                             if (is.null(name)) 
[01:28:24.548]                               next
[01:28:24.548]                             if (!grepl(pattern, name)) 
[01:28:24.548]                               next
[01:28:24.548]                             invokeRestart(restart)
[01:28:24.548]                             muffled <- TRUE
[01:28:24.548]                             break
[01:28:24.548]                           }
[01:28:24.548]                         }
[01:28:24.548]                       }
[01:28:24.548]                       invisible(muffled)
[01:28:24.548]                     }
[01:28:24.548]                     muffleCondition(cond, pattern = "^muffle")
[01:28:24.548]                   }
[01:28:24.548]                 }
[01:28:24.548]                 else {
[01:28:24.548]                   if (TRUE) {
[01:28:24.548]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:24.548]                     {
[01:28:24.548]                       inherits <- base::inherits
[01:28:24.548]                       invokeRestart <- base::invokeRestart
[01:28:24.548]                       is.null <- base::is.null
[01:28:24.548]                       muffled <- FALSE
[01:28:24.548]                       if (inherits(cond, "message")) {
[01:28:24.548]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:24.548]                         if (muffled) 
[01:28:24.548]                           invokeRestart("muffleMessage")
[01:28:24.548]                       }
[01:28:24.548]                       else if (inherits(cond, "warning")) {
[01:28:24.548]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:24.548]                         if (muffled) 
[01:28:24.548]                           invokeRestart("muffleWarning")
[01:28:24.548]                       }
[01:28:24.548]                       else if (inherits(cond, "condition")) {
[01:28:24.548]                         if (!is.null(pattern)) {
[01:28:24.548]                           computeRestarts <- base::computeRestarts
[01:28:24.548]                           grepl <- base::grepl
[01:28:24.548]                           restarts <- computeRestarts(cond)
[01:28:24.548]                           for (restart in restarts) {
[01:28:24.548]                             name <- restart$name
[01:28:24.548]                             if (is.null(name)) 
[01:28:24.548]                               next
[01:28:24.548]                             if (!grepl(pattern, name)) 
[01:28:24.548]                               next
[01:28:24.548]                             invokeRestart(restart)
[01:28:24.548]                             muffled <- TRUE
[01:28:24.548]                             break
[01:28:24.548]                           }
[01:28:24.548]                         }
[01:28:24.548]                       }
[01:28:24.548]                       invisible(muffled)
[01:28:24.548]                     }
[01:28:24.548]                     muffleCondition(cond, pattern = "^muffle")
[01:28:24.548]                   }
[01:28:24.548]                 }
[01:28:24.548]             }
[01:28:24.548]         }))
[01:28:24.548]     }, error = function(ex) {
[01:28:24.548]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:24.548]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:24.548]                 ...future.rng), started = ...future.startTime, 
[01:28:24.548]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:24.548]             version = "1.8"), class = "FutureResult")
[01:28:24.548]     }, finally = {
[01:28:24.548]         if (!identical(...future.workdir, getwd())) 
[01:28:24.548]             setwd(...future.workdir)
[01:28:24.548]         {
[01:28:24.548]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:24.548]                 ...future.oldOptions$nwarnings <- NULL
[01:28:24.548]             }
[01:28:24.548]             base::options(...future.oldOptions)
[01:28:24.548]             if (.Platform$OS.type == "windows") {
[01:28:24.548]                 old_names <- names(...future.oldEnvVars)
[01:28:24.548]                 envs <- base::Sys.getenv()
[01:28:24.548]                 names <- names(envs)
[01:28:24.548]                 common <- intersect(names, old_names)
[01:28:24.548]                 added <- setdiff(names, old_names)
[01:28:24.548]                 removed <- setdiff(old_names, names)
[01:28:24.548]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:24.548]                   envs[common]]
[01:28:24.548]                 NAMES <- toupper(changed)
[01:28:24.548]                 args <- list()
[01:28:24.548]                 for (kk in seq_along(NAMES)) {
[01:28:24.548]                   name <- changed[[kk]]
[01:28:24.548]                   NAME <- NAMES[[kk]]
[01:28:24.548]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:24.548]                     next
[01:28:24.548]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:24.548]                 }
[01:28:24.548]                 NAMES <- toupper(added)
[01:28:24.548]                 for (kk in seq_along(NAMES)) {
[01:28:24.548]                   name <- added[[kk]]
[01:28:24.548]                   NAME <- NAMES[[kk]]
[01:28:24.548]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:24.548]                     next
[01:28:24.548]                   args[[name]] <- ""
[01:28:24.548]                 }
[01:28:24.548]                 NAMES <- toupper(removed)
[01:28:24.548]                 for (kk in seq_along(NAMES)) {
[01:28:24.548]                   name <- removed[[kk]]
[01:28:24.548]                   NAME <- NAMES[[kk]]
[01:28:24.548]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:24.548]                     next
[01:28:24.548]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:24.548]                 }
[01:28:24.548]                 if (length(args) > 0) 
[01:28:24.548]                   base::do.call(base::Sys.setenv, args = args)
[01:28:24.548]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:24.548]             }
[01:28:24.548]             else {
[01:28:24.548]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:24.548]             }
[01:28:24.548]             {
[01:28:24.548]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:24.548]                   0L) {
[01:28:24.548]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:24.548]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:24.548]                   base::options(opts)
[01:28:24.548]                 }
[01:28:24.548]                 {
[01:28:24.548]                   {
[01:28:24.548]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:24.548]                     NULL
[01:28:24.548]                   }
[01:28:24.548]                   options(future.plan = NULL)
[01:28:24.548]                   if (is.na(NA_character_)) 
[01:28:24.548]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:24.548]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:24.548]                   future::plan(list(function (..., workers = 2L, 
[01:28:24.548]                     envir = parent.frame()) 
[01:28:24.548]                   strategy(..., workers = workers, envir = envir)), 
[01:28:24.548]                     .cleanup = FALSE, .init = FALSE)
[01:28:24.548]                 }
[01:28:24.548]             }
[01:28:24.548]         }
[01:28:24.548]     })
[01:28:24.548]     if (TRUE) {
[01:28:24.548]         base::sink(type = "output", split = FALSE)
[01:28:24.548]         if (TRUE) {
[01:28:24.548]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:24.548]         }
[01:28:24.548]         else {
[01:28:24.548]             ...future.result["stdout"] <- base::list(NULL)
[01:28:24.548]         }
[01:28:24.548]         base::close(...future.stdout)
[01:28:24.548]         ...future.stdout <- NULL
[01:28:24.548]     }
[01:28:24.548]     ...future.result$conditions <- ...future.conditions
[01:28:24.548]     ...future.result$finished <- base::Sys.time()
[01:28:24.548]     ...future.result
[01:28:24.548] }
[01:28:24.554] MultisessionFuture started
[01:28:24.554] - Launch lazy future ... done
[01:28:24.554] run() for 'MultisessionFuture' ... done
> v <- value(f)
[01:28:24.554] result() for ClusterFuture ...
[01:28:24.554] receiveMessageFromWorker() for ClusterFuture ...
[01:28:24.555] - Validating connection of MultisessionFuture
[01:28:24.597] - received message: FutureResult
[01:28:24.597] - Received FutureResult
[01:28:24.597] - Erased future from FutureRegistry
[01:28:24.598] result() for ClusterFuture ...
[01:28:24.598] - result already collected: FutureResult
[01:28:24.598] result() for ClusterFuture ... done
[01:28:24.598] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:24.598] result() for ClusterFuture ... done
[01:28:24.598] result() for ClusterFuture ...
[01:28:24.599] - result already collected: FutureResult
[01:28:24.599] result() for ClusterFuture ... done
> print(v)
         used (Mb) gc trigger (Mb) max used (Mb)
Ncells 407840 21.8     848270 45.4   655684 35.1
Vcells 725502  5.6    8388608 64.0  5854878 44.7
> 
> f <- future({ integer(10e6) }, gc = TRUE)
[01:28:24.599] getGlobalsAndPackages() ...
[01:28:24.599] Searching for globals...
[01:28:24.601] - globals found: [2] '{', 'integer'
[01:28:24.601] Searching for globals ... DONE
[01:28:24.601] Resolving globals: FALSE
[01:28:24.601] 
[01:28:24.602] 
[01:28:24.602] getGlobalsAndPackages() ... DONE
[01:28:24.602] run() for 'Future' ...
[01:28:24.602] - state: 'created'
[01:28:24.603] - Future backend: 'FutureStrategy', 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:24.617] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:24.618] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:24.618]   - Field: 'node'
[01:28:24.618]   - Field: 'label'
[01:28:24.618]   - Field: 'local'
[01:28:24.618]   - Field: 'owner'
[01:28:24.619]   - Field: 'envir'
[01:28:24.619]   - Field: 'workers'
[01:28:24.619]   - Field: 'packages'
[01:28:24.619]   - Field: 'gc'
[01:28:24.619]   - Field: 'conditions'
[01:28:24.620]   - Field: 'persistent'
[01:28:24.620]   - Field: 'expr'
[01:28:24.620]   - Field: 'uuid'
[01:28:24.620]   - Field: 'seed'
[01:28:24.620]   - Field: 'version'
[01:28:24.621]   - Field: 'result'
[01:28:24.621]   - Field: 'asynchronous'
[01:28:24.621]   - Field: 'calls'
[01:28:24.622]   - Field: 'globals'
[01:28:24.622]   - Field: 'stdout'
[01:28:24.622]   - Field: 'earlySignal'
[01:28:24.622]   - Field: 'lazy'
[01:28:24.622]   - Field: 'state'
[01:28:24.623] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:24.623] - Launch lazy future ...
[01:28:24.623] Packages needed by the future expression (n = 0): <none>
[01:28:24.623] Packages needed by future strategies (n = 0): <none>
[01:28:24.624] {
[01:28:24.624]     {
[01:28:24.624]         {
[01:28:24.624]             ...future.startTime <- base::Sys.time()
[01:28:24.624]             {
[01:28:24.624]                 {
[01:28:24.624]                   {
[01:28:24.624]                     {
[01:28:24.624]                       base::local({
[01:28:24.624]                         has_future <- base::requireNamespace("future", 
[01:28:24.624]                           quietly = TRUE)
[01:28:24.624]                         if (has_future) {
[01:28:24.624]                           ns <- base::getNamespace("future")
[01:28:24.624]                           version <- ns[[".package"]][["version"]]
[01:28:24.624]                           if (is.null(version)) 
[01:28:24.624]                             version <- utils::packageVersion("future")
[01:28:24.624]                         }
[01:28:24.624]                         else {
[01:28:24.624]                           version <- NULL
[01:28:24.624]                         }
[01:28:24.624]                         if (!has_future || version < "1.8.0") {
[01:28:24.624]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:24.624]                             "", base::R.version$version.string), 
[01:28:24.624]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:24.624]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:24.624]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:24.624]                               "release", "version")], collapse = " "), 
[01:28:24.624]                             hostname = base::Sys.info()[["nodename"]])
[01:28:24.624]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:24.624]                             info)
[01:28:24.624]                           info <- base::paste(info, collapse = "; ")
[01:28:24.624]                           if (!has_future) {
[01:28:24.624]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:24.624]                               info)
[01:28:24.624]                           }
[01:28:24.624]                           else {
[01:28:24.624]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:24.624]                               info, version)
[01:28:24.624]                           }
[01:28:24.624]                           base::stop(msg)
[01:28:24.624]                         }
[01:28:24.624]                       })
[01:28:24.624]                     }
[01:28:24.624]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:24.624]                     base::options(mc.cores = 1L)
[01:28:24.624]                   }
[01:28:24.624]                   options(future.plan = NULL)
[01:28:24.624]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:24.624]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:24.624]                 }
[01:28:24.624]                 ...future.workdir <- getwd()
[01:28:24.624]             }
[01:28:24.624]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:24.624]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:24.624]         }
[01:28:24.624]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:24.624]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:24.624]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:24.624]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:24.624]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:24.624]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:24.624]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:24.624]             base::names(...future.oldOptions))
[01:28:24.624]     }
[01:28:24.624]     if (FALSE) {
[01:28:24.624]     }
[01:28:24.624]     else {
[01:28:24.624]         if (TRUE) {
[01:28:24.624]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:24.624]                 open = "w")
[01:28:24.624]         }
[01:28:24.624]         else {
[01:28:24.624]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:24.624]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:24.624]         }
[01:28:24.624]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:24.624]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:24.624]             base::sink(type = "output", split = FALSE)
[01:28:24.624]             base::close(...future.stdout)
[01:28:24.624]         }, add = TRUE)
[01:28:24.624]     }
[01:28:24.624]     ...future.frame <- base::sys.nframe()
[01:28:24.624]     ...future.conditions <- base::list()
[01:28:24.624]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:24.624]     if (FALSE) {
[01:28:24.624]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:24.624]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:24.624]     }
[01:28:24.624]     ...future.result <- base::tryCatch({
[01:28:24.624]         base::withCallingHandlers({
[01:28:24.624]             ...future.value <- base::withVisible(base::local({
[01:28:24.624]                 ...future.makeSendCondition <- base::local({
[01:28:24.624]                   sendCondition <- NULL
[01:28:24.624]                   function(frame = 1L) {
[01:28:24.624]                     if (is.function(sendCondition)) 
[01:28:24.624]                       return(sendCondition)
[01:28:24.624]                     ns <- getNamespace("parallel")
[01:28:24.624]                     if (exists("sendData", mode = "function", 
[01:28:24.624]                       envir = ns)) {
[01:28:24.624]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:24.624]                         envir = ns)
[01:28:24.624]                       envir <- sys.frame(frame)
[01:28:24.624]                       master <- NULL
[01:28:24.624]                       while (!identical(envir, .GlobalEnv) && 
[01:28:24.624]                         !identical(envir, emptyenv())) {
[01:28:24.624]                         if (exists("master", mode = "list", envir = envir, 
[01:28:24.624]                           inherits = FALSE)) {
[01:28:24.624]                           master <- get("master", mode = "list", 
[01:28:24.624]                             envir = envir, inherits = FALSE)
[01:28:24.624]                           if (inherits(master, c("SOCKnode", 
[01:28:24.624]                             "SOCK0node"))) {
[01:28:24.624]                             sendCondition <<- function(cond) {
[01:28:24.624]                               data <- list(type = "VALUE", value = cond, 
[01:28:24.624]                                 success = TRUE)
[01:28:24.624]                               parallel_sendData(master, data)
[01:28:24.624]                             }
[01:28:24.624]                             return(sendCondition)
[01:28:24.624]                           }
[01:28:24.624]                         }
[01:28:24.624]                         frame <- frame + 1L
[01:28:24.624]                         envir <- sys.frame(frame)
[01:28:24.624]                       }
[01:28:24.624]                     }
[01:28:24.624]                     sendCondition <<- function(cond) NULL
[01:28:24.624]                   }
[01:28:24.624]                 })
[01:28:24.624]                 withCallingHandlers({
[01:28:24.624]                   {
[01:28:24.624]                     integer(1e+07)
[01:28:24.624]                   }
[01:28:24.624]                 }, immediateCondition = function(cond) {
[01:28:24.624]                   sendCondition <- ...future.makeSendCondition()
[01:28:24.624]                   sendCondition(cond)
[01:28:24.624]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:24.624]                   {
[01:28:24.624]                     inherits <- base::inherits
[01:28:24.624]                     invokeRestart <- base::invokeRestart
[01:28:24.624]                     is.null <- base::is.null
[01:28:24.624]                     muffled <- FALSE
[01:28:24.624]                     if (inherits(cond, "message")) {
[01:28:24.624]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:24.624]                       if (muffled) 
[01:28:24.624]                         invokeRestart("muffleMessage")
[01:28:24.624]                     }
[01:28:24.624]                     else if (inherits(cond, "warning")) {
[01:28:24.624]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:24.624]                       if (muffled) 
[01:28:24.624]                         invokeRestart("muffleWarning")
[01:28:24.624]                     }
[01:28:24.624]                     else if (inherits(cond, "condition")) {
[01:28:24.624]                       if (!is.null(pattern)) {
[01:28:24.624]                         computeRestarts <- base::computeRestarts
[01:28:24.624]                         grepl <- base::grepl
[01:28:24.624]                         restarts <- computeRestarts(cond)
[01:28:24.624]                         for (restart in restarts) {
[01:28:24.624]                           name <- restart$name
[01:28:24.624]                           if (is.null(name)) 
[01:28:24.624]                             next
[01:28:24.624]                           if (!grepl(pattern, name)) 
[01:28:24.624]                             next
[01:28:24.624]                           invokeRestart(restart)
[01:28:24.624]                           muffled <- TRUE
[01:28:24.624]                           break
[01:28:24.624]                         }
[01:28:24.624]                       }
[01:28:24.624]                     }
[01:28:24.624]                     invisible(muffled)
[01:28:24.624]                   }
[01:28:24.624]                   muffleCondition(cond)
[01:28:24.624]                 })
[01:28:24.624]             }))
[01:28:24.624]             future::FutureResult(value = ...future.value$value, 
[01:28:24.624]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:24.624]                   ...future.rng), globalenv = if (FALSE) 
[01:28:24.624]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:24.624]                     ...future.globalenv.names))
[01:28:24.624]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:24.624]         }, condition = base::local({
[01:28:24.624]             c <- base::c
[01:28:24.624]             inherits <- base::inherits
[01:28:24.624]             invokeRestart <- base::invokeRestart
[01:28:24.624]             length <- base::length
[01:28:24.624]             list <- base::list
[01:28:24.624]             seq.int <- base::seq.int
[01:28:24.624]             signalCondition <- base::signalCondition
[01:28:24.624]             sys.calls <- base::sys.calls
[01:28:24.624]             `[[` <- base::`[[`
[01:28:24.624]             `+` <- base::`+`
[01:28:24.624]             `<<-` <- base::`<<-`
[01:28:24.624]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:24.624]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:24.624]                   3L)]
[01:28:24.624]             }
[01:28:24.624]             function(cond) {
[01:28:24.624]                 is_error <- inherits(cond, "error")
[01:28:24.624]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:24.624]                   NULL)
[01:28:24.624]                 if (is_error) {
[01:28:24.624]                   sessionInformation <- function() {
[01:28:24.624]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:24.624]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:24.624]                       search = base::search(), system = base::Sys.info())
[01:28:24.624]                   }
[01:28:24.624]                   ...future.conditions[[length(...future.conditions) + 
[01:28:24.624]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:24.624]                     cond$call), session = sessionInformation(), 
[01:28:24.624]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:24.624]                   signalCondition(cond)
[01:28:24.624]                 }
[01:28:24.624]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:24.624]                 "immediateCondition"))) {
[01:28:24.624]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:24.624]                   ...future.conditions[[length(...future.conditions) + 
[01:28:24.624]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:24.624]                   if (TRUE && !signal) {
[01:28:24.624]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:24.624]                     {
[01:28:24.624]                       inherits <- base::inherits
[01:28:24.624]                       invokeRestart <- base::invokeRestart
[01:28:24.624]                       is.null <- base::is.null
[01:28:24.624]                       muffled <- FALSE
[01:28:24.624]                       if (inherits(cond, "message")) {
[01:28:24.624]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:24.624]                         if (muffled) 
[01:28:24.624]                           invokeRestart("muffleMessage")
[01:28:24.624]                       }
[01:28:24.624]                       else if (inherits(cond, "warning")) {
[01:28:24.624]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:24.624]                         if (muffled) 
[01:28:24.624]                           invokeRestart("muffleWarning")
[01:28:24.624]                       }
[01:28:24.624]                       else if (inherits(cond, "condition")) {
[01:28:24.624]                         if (!is.null(pattern)) {
[01:28:24.624]                           computeRestarts <- base::computeRestarts
[01:28:24.624]                           grepl <- base::grepl
[01:28:24.624]                           restarts <- computeRestarts(cond)
[01:28:24.624]                           for (restart in restarts) {
[01:28:24.624]                             name <- restart$name
[01:28:24.624]                             if (is.null(name)) 
[01:28:24.624]                               next
[01:28:24.624]                             if (!grepl(pattern, name)) 
[01:28:24.624]                               next
[01:28:24.624]                             invokeRestart(restart)
[01:28:24.624]                             muffled <- TRUE
[01:28:24.624]                             break
[01:28:24.624]                           }
[01:28:24.624]                         }
[01:28:24.624]                       }
[01:28:24.624]                       invisible(muffled)
[01:28:24.624]                     }
[01:28:24.624]                     muffleCondition(cond, pattern = "^muffle")
[01:28:24.624]                   }
[01:28:24.624]                 }
[01:28:24.624]                 else {
[01:28:24.624]                   if (TRUE) {
[01:28:24.624]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:24.624]                     {
[01:28:24.624]                       inherits <- base::inherits
[01:28:24.624]                       invokeRestart <- base::invokeRestart
[01:28:24.624]                       is.null <- base::is.null
[01:28:24.624]                       muffled <- FALSE
[01:28:24.624]                       if (inherits(cond, "message")) {
[01:28:24.624]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:24.624]                         if (muffled) 
[01:28:24.624]                           invokeRestart("muffleMessage")
[01:28:24.624]                       }
[01:28:24.624]                       else if (inherits(cond, "warning")) {
[01:28:24.624]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:24.624]                         if (muffled) 
[01:28:24.624]                           invokeRestart("muffleWarning")
[01:28:24.624]                       }
[01:28:24.624]                       else if (inherits(cond, "condition")) {
[01:28:24.624]                         if (!is.null(pattern)) {
[01:28:24.624]                           computeRestarts <- base::computeRestarts
[01:28:24.624]                           grepl <- base::grepl
[01:28:24.624]                           restarts <- computeRestarts(cond)
[01:28:24.624]                           for (restart in restarts) {
[01:28:24.624]                             name <- restart$name
[01:28:24.624]                             if (is.null(name)) 
[01:28:24.624]                               next
[01:28:24.624]                             if (!grepl(pattern, name)) 
[01:28:24.624]                               next
[01:28:24.624]                             invokeRestart(restart)
[01:28:24.624]                             muffled <- TRUE
[01:28:24.624]                             break
[01:28:24.624]                           }
[01:28:24.624]                         }
[01:28:24.624]                       }
[01:28:24.624]                       invisible(muffled)
[01:28:24.624]                     }
[01:28:24.624]                     muffleCondition(cond, pattern = "^muffle")
[01:28:24.624]                   }
[01:28:24.624]                 }
[01:28:24.624]             }
[01:28:24.624]         }))
[01:28:24.624]     }, error = function(ex) {
[01:28:24.624]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:24.624]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:24.624]                 ...future.rng), started = ...future.startTime, 
[01:28:24.624]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:24.624]             version = "1.8"), class = "FutureResult")
[01:28:24.624]     }, finally = {
[01:28:24.624]         if (!identical(...future.workdir, getwd())) 
[01:28:24.624]             setwd(...future.workdir)
[01:28:24.624]         {
[01:28:24.624]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:24.624]                 ...future.oldOptions$nwarnings <- NULL
[01:28:24.624]             }
[01:28:24.624]             base::options(...future.oldOptions)
[01:28:24.624]             if (.Platform$OS.type == "windows") {
[01:28:24.624]                 old_names <- names(...future.oldEnvVars)
[01:28:24.624]                 envs <- base::Sys.getenv()
[01:28:24.624]                 names <- names(envs)
[01:28:24.624]                 common <- intersect(names, old_names)
[01:28:24.624]                 added <- setdiff(names, old_names)
[01:28:24.624]                 removed <- setdiff(old_names, names)
[01:28:24.624]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:24.624]                   envs[common]]
[01:28:24.624]                 NAMES <- toupper(changed)
[01:28:24.624]                 args <- list()
[01:28:24.624]                 for (kk in seq_along(NAMES)) {
[01:28:24.624]                   name <- changed[[kk]]
[01:28:24.624]                   NAME <- NAMES[[kk]]
[01:28:24.624]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:24.624]                     next
[01:28:24.624]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:24.624]                 }
[01:28:24.624]                 NAMES <- toupper(added)
[01:28:24.624]                 for (kk in seq_along(NAMES)) {
[01:28:24.624]                   name <- added[[kk]]
[01:28:24.624]                   NAME <- NAMES[[kk]]
[01:28:24.624]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:24.624]                     next
[01:28:24.624]                   args[[name]] <- ""
[01:28:24.624]                 }
[01:28:24.624]                 NAMES <- toupper(removed)
[01:28:24.624]                 for (kk in seq_along(NAMES)) {
[01:28:24.624]                   name <- removed[[kk]]
[01:28:24.624]                   NAME <- NAMES[[kk]]
[01:28:24.624]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:24.624]                     next
[01:28:24.624]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:24.624]                 }
[01:28:24.624]                 if (length(args) > 0) 
[01:28:24.624]                   base::do.call(base::Sys.setenv, args = args)
[01:28:24.624]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:24.624]             }
[01:28:24.624]             else {
[01:28:24.624]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:24.624]             }
[01:28:24.624]             {
[01:28:24.624]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:24.624]                   0L) {
[01:28:24.624]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:24.624]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:24.624]                   base::options(opts)
[01:28:24.624]                 }
[01:28:24.624]                 {
[01:28:24.624]                   {
[01:28:24.624]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:24.624]                     NULL
[01:28:24.624]                   }
[01:28:24.624]                   options(future.plan = NULL)
[01:28:24.624]                   if (is.na(NA_character_)) 
[01:28:24.624]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:24.624]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:24.624]                   future::plan(list(function (..., workers = 2L, 
[01:28:24.624]                     envir = parent.frame()) 
[01:28:24.624]                   strategy(..., workers = workers, envir = envir)), 
[01:28:24.624]                     .cleanup = FALSE, .init = FALSE)
[01:28:24.624]                 }
[01:28:24.624]             }
[01:28:24.624]         }
[01:28:24.624]     })
[01:28:24.624]     if (TRUE) {
[01:28:24.624]         base::sink(type = "output", split = FALSE)
[01:28:24.624]         if (TRUE) {
[01:28:24.624]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:24.624]         }
[01:28:24.624]         else {
[01:28:24.624]             ...future.result["stdout"] <- base::list(NULL)
[01:28:24.624]         }
[01:28:24.624]         base::close(...future.stdout)
[01:28:24.624]         ...future.stdout <- NULL
[01:28:24.624]     }
[01:28:24.624]     ...future.result$conditions <- ...future.conditions
[01:28:24.624]     ...future.result$finished <- base::Sys.time()
[01:28:24.624]     ...future.result
[01:28:24.624] }
[01:28:24.630] MultisessionFuture started
[01:28:24.630] - Launch lazy future ... done
[01:28:24.630] run() for 'MultisessionFuture' ... done
> v <- value(f)
[01:28:24.630] result() for ClusterFuture ...
[01:28:24.630] receiveMessageFromWorker() for ClusterFuture ...
[01:28:24.631] - Validating connection of MultisessionFuture
[01:28:24.727] - received message: FutureResult
[01:28:24.728] - Received FutureResult
[01:28:24.728] - Erased future from FutureRegistry
[01:28:24.728] result() for ClusterFuture ...
[01:28:24.728] - result already collected: FutureResult
[01:28:24.728] result() for ClusterFuture ... done
[01:28:24.728] - Garbage collecting worker ...
[01:28:25.037] - Garbage collecting worker ... done
[01:28:25.037] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:25.037] result() for ClusterFuture ... done
[01:28:25.038] result() for ClusterFuture ...
[01:28:25.038] - result already collected: FutureResult
[01:28:25.038] result() for ClusterFuture ... done
> str(v)
 int [1:10000000] 0 0 0 0 0 0 0 0 0 0 ...
> 
> f <- future({ gc() })
[01:28:25.039] getGlobalsAndPackages() ...
[01:28:25.039] Searching for globals...
[01:28:25.040] - globals found: [2] '{', 'gc'
[01:28:25.040] Searching for globals ... DONE
[01:28:25.040] Resolving globals: FALSE
[01:28:25.041] 
[01:28:25.041] 
[01:28:25.041] getGlobalsAndPackages() ... DONE
[01:28:25.042] run() for 'Future' ...
[01:28:25.042] - state: 'created'
[01:28:25.042] - Future backend: 'FutureStrategy', 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:25.054] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:25.054] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:25.055]   - Field: 'node'
[01:28:25.055]   - Field: 'label'
[01:28:25.055]   - Field: 'local'
[01:28:25.055]   - Field: 'owner'
[01:28:25.055]   - Field: 'envir'
[01:28:25.056]   - Field: 'workers'
[01:28:25.056]   - Field: 'packages'
[01:28:25.056]   - Field: 'gc'
[01:28:25.056]   - Field: 'conditions'
[01:28:25.056]   - Field: 'persistent'
[01:28:25.056]   - Field: 'expr'
[01:28:25.057]   - Field: 'uuid'
[01:28:25.057]   - Field: 'seed'
[01:28:25.057]   - Field: 'version'
[01:28:25.057]   - Field: 'result'
[01:28:25.057]   - Field: 'asynchronous'
[01:28:25.058]   - Field: 'calls'
[01:28:25.058]   - Field: 'globals'
[01:28:25.058]   - Field: 'stdout'
[01:28:25.058]   - Field: 'earlySignal'
[01:28:25.058]   - Field: 'lazy'
[01:28:25.058]   - Field: 'state'
[01:28:25.059] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:25.059] - Launch lazy future ...
[01:28:25.059] Packages needed by the future expression (n = 0): <none>
[01:28:25.059] Packages needed by future strategies (n = 0): <none>
[01:28:25.060] {
[01:28:25.060]     {
[01:28:25.060]         {
[01:28:25.060]             ...future.startTime <- base::Sys.time()
[01:28:25.060]             {
[01:28:25.060]                 {
[01:28:25.060]                   {
[01:28:25.060]                     {
[01:28:25.060]                       base::local({
[01:28:25.060]                         has_future <- base::requireNamespace("future", 
[01:28:25.060]                           quietly = TRUE)
[01:28:25.060]                         if (has_future) {
[01:28:25.060]                           ns <- base::getNamespace("future")
[01:28:25.060]                           version <- ns[[".package"]][["version"]]
[01:28:25.060]                           if (is.null(version)) 
[01:28:25.060]                             version <- utils::packageVersion("future")
[01:28:25.060]                         }
[01:28:25.060]                         else {
[01:28:25.060]                           version <- NULL
[01:28:25.060]                         }
[01:28:25.060]                         if (!has_future || version < "1.8.0") {
[01:28:25.060]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:25.060]                             "", base::R.version$version.string), 
[01:28:25.060]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:25.060]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:25.060]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:25.060]                               "release", "version")], collapse = " "), 
[01:28:25.060]                             hostname = base::Sys.info()[["nodename"]])
[01:28:25.060]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:25.060]                             info)
[01:28:25.060]                           info <- base::paste(info, collapse = "; ")
[01:28:25.060]                           if (!has_future) {
[01:28:25.060]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:25.060]                               info)
[01:28:25.060]                           }
[01:28:25.060]                           else {
[01:28:25.060]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:25.060]                               info, version)
[01:28:25.060]                           }
[01:28:25.060]                           base::stop(msg)
[01:28:25.060]                         }
[01:28:25.060]                       })
[01:28:25.060]                     }
[01:28:25.060]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:25.060]                     base::options(mc.cores = 1L)
[01:28:25.060]                   }
[01:28:25.060]                   options(future.plan = NULL)
[01:28:25.060]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:25.060]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:25.060]                 }
[01:28:25.060]                 ...future.workdir <- getwd()
[01:28:25.060]             }
[01:28:25.060]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:25.060]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:25.060]         }
[01:28:25.060]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:25.060]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:25.060]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:25.060]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:25.060]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:25.060]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:25.060]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:25.060]             base::names(...future.oldOptions))
[01:28:25.060]     }
[01:28:25.060]     if (FALSE) {
[01:28:25.060]     }
[01:28:25.060]     else {
[01:28:25.060]         if (TRUE) {
[01:28:25.060]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:25.060]                 open = "w")
[01:28:25.060]         }
[01:28:25.060]         else {
[01:28:25.060]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:25.060]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:25.060]         }
[01:28:25.060]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:25.060]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:25.060]             base::sink(type = "output", split = FALSE)
[01:28:25.060]             base::close(...future.stdout)
[01:28:25.060]         }, add = TRUE)
[01:28:25.060]     }
[01:28:25.060]     ...future.frame <- base::sys.nframe()
[01:28:25.060]     ...future.conditions <- base::list()
[01:28:25.060]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:25.060]     if (FALSE) {
[01:28:25.060]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:25.060]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:25.060]     }
[01:28:25.060]     ...future.result <- base::tryCatch({
[01:28:25.060]         base::withCallingHandlers({
[01:28:25.060]             ...future.value <- base::withVisible(base::local({
[01:28:25.060]                 ...future.makeSendCondition <- base::local({
[01:28:25.060]                   sendCondition <- NULL
[01:28:25.060]                   function(frame = 1L) {
[01:28:25.060]                     if (is.function(sendCondition)) 
[01:28:25.060]                       return(sendCondition)
[01:28:25.060]                     ns <- getNamespace("parallel")
[01:28:25.060]                     if (exists("sendData", mode = "function", 
[01:28:25.060]                       envir = ns)) {
[01:28:25.060]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:25.060]                         envir = ns)
[01:28:25.060]                       envir <- sys.frame(frame)
[01:28:25.060]                       master <- NULL
[01:28:25.060]                       while (!identical(envir, .GlobalEnv) && 
[01:28:25.060]                         !identical(envir, emptyenv())) {
[01:28:25.060]                         if (exists("master", mode = "list", envir = envir, 
[01:28:25.060]                           inherits = FALSE)) {
[01:28:25.060]                           master <- get("master", mode = "list", 
[01:28:25.060]                             envir = envir, inherits = FALSE)
[01:28:25.060]                           if (inherits(master, c("SOCKnode", 
[01:28:25.060]                             "SOCK0node"))) {
[01:28:25.060]                             sendCondition <<- function(cond) {
[01:28:25.060]                               data <- list(type = "VALUE", value = cond, 
[01:28:25.060]                                 success = TRUE)
[01:28:25.060]                               parallel_sendData(master, data)
[01:28:25.060]                             }
[01:28:25.060]                             return(sendCondition)
[01:28:25.060]                           }
[01:28:25.060]                         }
[01:28:25.060]                         frame <- frame + 1L
[01:28:25.060]                         envir <- sys.frame(frame)
[01:28:25.060]                       }
[01:28:25.060]                     }
[01:28:25.060]                     sendCondition <<- function(cond) NULL
[01:28:25.060]                   }
[01:28:25.060]                 })
[01:28:25.060]                 withCallingHandlers({
[01:28:25.060]                   {
[01:28:25.060]                     gc()
[01:28:25.060]                   }
[01:28:25.060]                 }, immediateCondition = function(cond) {
[01:28:25.060]                   sendCondition <- ...future.makeSendCondition()
[01:28:25.060]                   sendCondition(cond)
[01:28:25.060]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:25.060]                   {
[01:28:25.060]                     inherits <- base::inherits
[01:28:25.060]                     invokeRestart <- base::invokeRestart
[01:28:25.060]                     is.null <- base::is.null
[01:28:25.060]                     muffled <- FALSE
[01:28:25.060]                     if (inherits(cond, "message")) {
[01:28:25.060]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:25.060]                       if (muffled) 
[01:28:25.060]                         invokeRestart("muffleMessage")
[01:28:25.060]                     }
[01:28:25.060]                     else if (inherits(cond, "warning")) {
[01:28:25.060]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:25.060]                       if (muffled) 
[01:28:25.060]                         invokeRestart("muffleWarning")
[01:28:25.060]                     }
[01:28:25.060]                     else if (inherits(cond, "condition")) {
[01:28:25.060]                       if (!is.null(pattern)) {
[01:28:25.060]                         computeRestarts <- base::computeRestarts
[01:28:25.060]                         grepl <- base::grepl
[01:28:25.060]                         restarts <- computeRestarts(cond)
[01:28:25.060]                         for (restart in restarts) {
[01:28:25.060]                           name <- restart$name
[01:28:25.060]                           if (is.null(name)) 
[01:28:25.060]                             next
[01:28:25.060]                           if (!grepl(pattern, name)) 
[01:28:25.060]                             next
[01:28:25.060]                           invokeRestart(restart)
[01:28:25.060]                           muffled <- TRUE
[01:28:25.060]                           break
[01:28:25.060]                         }
[01:28:25.060]                       }
[01:28:25.060]                     }
[01:28:25.060]                     invisible(muffled)
[01:28:25.060]                   }
[01:28:25.060]                   muffleCondition(cond)
[01:28:25.060]                 })
[01:28:25.060]             }))
[01:28:25.060]             future::FutureResult(value = ...future.value$value, 
[01:28:25.060]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:25.060]                   ...future.rng), globalenv = if (FALSE) 
[01:28:25.060]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:25.060]                     ...future.globalenv.names))
[01:28:25.060]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:25.060]         }, condition = base::local({
[01:28:25.060]             c <- base::c
[01:28:25.060]             inherits <- base::inherits
[01:28:25.060]             invokeRestart <- base::invokeRestart
[01:28:25.060]             length <- base::length
[01:28:25.060]             list <- base::list
[01:28:25.060]             seq.int <- base::seq.int
[01:28:25.060]             signalCondition <- base::signalCondition
[01:28:25.060]             sys.calls <- base::sys.calls
[01:28:25.060]             `[[` <- base::`[[`
[01:28:25.060]             `+` <- base::`+`
[01:28:25.060]             `<<-` <- base::`<<-`
[01:28:25.060]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:25.060]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:25.060]                   3L)]
[01:28:25.060]             }
[01:28:25.060]             function(cond) {
[01:28:25.060]                 is_error <- inherits(cond, "error")
[01:28:25.060]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:25.060]                   NULL)
[01:28:25.060]                 if (is_error) {
[01:28:25.060]                   sessionInformation <- function() {
[01:28:25.060]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:25.060]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:25.060]                       search = base::search(), system = base::Sys.info())
[01:28:25.060]                   }
[01:28:25.060]                   ...future.conditions[[length(...future.conditions) + 
[01:28:25.060]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:25.060]                     cond$call), session = sessionInformation(), 
[01:28:25.060]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:25.060]                   signalCondition(cond)
[01:28:25.060]                 }
[01:28:25.060]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:25.060]                 "immediateCondition"))) {
[01:28:25.060]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:25.060]                   ...future.conditions[[length(...future.conditions) + 
[01:28:25.060]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:25.060]                   if (TRUE && !signal) {
[01:28:25.060]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:25.060]                     {
[01:28:25.060]                       inherits <- base::inherits
[01:28:25.060]                       invokeRestart <- base::invokeRestart
[01:28:25.060]                       is.null <- base::is.null
[01:28:25.060]                       muffled <- FALSE
[01:28:25.060]                       if (inherits(cond, "message")) {
[01:28:25.060]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:25.060]                         if (muffled) 
[01:28:25.060]                           invokeRestart("muffleMessage")
[01:28:25.060]                       }
[01:28:25.060]                       else if (inherits(cond, "warning")) {
[01:28:25.060]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:25.060]                         if (muffled) 
[01:28:25.060]                           invokeRestart("muffleWarning")
[01:28:25.060]                       }
[01:28:25.060]                       else if (inherits(cond, "condition")) {
[01:28:25.060]                         if (!is.null(pattern)) {
[01:28:25.060]                           computeRestarts <- base::computeRestarts
[01:28:25.060]                           grepl <- base::grepl
[01:28:25.060]                           restarts <- computeRestarts(cond)
[01:28:25.060]                           for (restart in restarts) {
[01:28:25.060]                             name <- restart$name
[01:28:25.060]                             if (is.null(name)) 
[01:28:25.060]                               next
[01:28:25.060]                             if (!grepl(pattern, name)) 
[01:28:25.060]                               next
[01:28:25.060]                             invokeRestart(restart)
[01:28:25.060]                             muffled <- TRUE
[01:28:25.060]                             break
[01:28:25.060]                           }
[01:28:25.060]                         }
[01:28:25.060]                       }
[01:28:25.060]                       invisible(muffled)
[01:28:25.060]                     }
[01:28:25.060]                     muffleCondition(cond, pattern = "^muffle")
[01:28:25.060]                   }
[01:28:25.060]                 }
[01:28:25.060]                 else {
[01:28:25.060]                   if (TRUE) {
[01:28:25.060]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:25.060]                     {
[01:28:25.060]                       inherits <- base::inherits
[01:28:25.060]                       invokeRestart <- base::invokeRestart
[01:28:25.060]                       is.null <- base::is.null
[01:28:25.060]                       muffled <- FALSE
[01:28:25.060]                       if (inherits(cond, "message")) {
[01:28:25.060]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:25.060]                         if (muffled) 
[01:28:25.060]                           invokeRestart("muffleMessage")
[01:28:25.060]                       }
[01:28:25.060]                       else if (inherits(cond, "warning")) {
[01:28:25.060]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:25.060]                         if (muffled) 
[01:28:25.060]                           invokeRestart("muffleWarning")
[01:28:25.060]                       }
[01:28:25.060]                       else if (inherits(cond, "condition")) {
[01:28:25.060]                         if (!is.null(pattern)) {
[01:28:25.060]                           computeRestarts <- base::computeRestarts
[01:28:25.060]                           grepl <- base::grepl
[01:28:25.060]                           restarts <- computeRestarts(cond)
[01:28:25.060]                           for (restart in restarts) {
[01:28:25.060]                             name <- restart$name
[01:28:25.060]                             if (is.null(name)) 
[01:28:25.060]                               next
[01:28:25.060]                             if (!grepl(pattern, name)) 
[01:28:25.060]                               next
[01:28:25.060]                             invokeRestart(restart)
[01:28:25.060]                             muffled <- TRUE
[01:28:25.060]                             break
[01:28:25.060]                           }
[01:28:25.060]                         }
[01:28:25.060]                       }
[01:28:25.060]                       invisible(muffled)
[01:28:25.060]                     }
[01:28:25.060]                     muffleCondition(cond, pattern = "^muffle")
[01:28:25.060]                   }
[01:28:25.060]                 }
[01:28:25.060]             }
[01:28:25.060]         }))
[01:28:25.060]     }, error = function(ex) {
[01:28:25.060]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:25.060]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:25.060]                 ...future.rng), started = ...future.startTime, 
[01:28:25.060]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:25.060]             version = "1.8"), class = "FutureResult")
[01:28:25.060]     }, finally = {
[01:28:25.060]         if (!identical(...future.workdir, getwd())) 
[01:28:25.060]             setwd(...future.workdir)
[01:28:25.060]         {
[01:28:25.060]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:25.060]                 ...future.oldOptions$nwarnings <- NULL
[01:28:25.060]             }
[01:28:25.060]             base::options(...future.oldOptions)
[01:28:25.060]             if (.Platform$OS.type == "windows") {
[01:28:25.060]                 old_names <- names(...future.oldEnvVars)
[01:28:25.060]                 envs <- base::Sys.getenv()
[01:28:25.060]                 names <- names(envs)
[01:28:25.060]                 common <- intersect(names, old_names)
[01:28:25.060]                 added <- setdiff(names, old_names)
[01:28:25.060]                 removed <- setdiff(old_names, names)
[01:28:25.060]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:25.060]                   envs[common]]
[01:28:25.060]                 NAMES <- toupper(changed)
[01:28:25.060]                 args <- list()
[01:28:25.060]                 for (kk in seq_along(NAMES)) {
[01:28:25.060]                   name <- changed[[kk]]
[01:28:25.060]                   NAME <- NAMES[[kk]]
[01:28:25.060]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:25.060]                     next
[01:28:25.060]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:25.060]                 }
[01:28:25.060]                 NAMES <- toupper(added)
[01:28:25.060]                 for (kk in seq_along(NAMES)) {
[01:28:25.060]                   name <- added[[kk]]
[01:28:25.060]                   NAME <- NAMES[[kk]]
[01:28:25.060]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:25.060]                     next
[01:28:25.060]                   args[[name]] <- ""
[01:28:25.060]                 }
[01:28:25.060]                 NAMES <- toupper(removed)
[01:28:25.060]                 for (kk in seq_along(NAMES)) {
[01:28:25.060]                   name <- removed[[kk]]
[01:28:25.060]                   NAME <- NAMES[[kk]]
[01:28:25.060]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:25.060]                     next
[01:28:25.060]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:25.060]                 }
[01:28:25.060]                 if (length(args) > 0) 
[01:28:25.060]                   base::do.call(base::Sys.setenv, args = args)
[01:28:25.060]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:25.060]             }
[01:28:25.060]             else {
[01:28:25.060]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:25.060]             }
[01:28:25.060]             {
[01:28:25.060]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:25.060]                   0L) {
[01:28:25.060]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:25.060]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:25.060]                   base::options(opts)
[01:28:25.060]                 }
[01:28:25.060]                 {
[01:28:25.060]                   {
[01:28:25.060]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:25.060]                     NULL
[01:28:25.060]                   }
[01:28:25.060]                   options(future.plan = NULL)
[01:28:25.060]                   if (is.na(NA_character_)) 
[01:28:25.060]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:25.060]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:25.060]                   future::plan(list(function (..., workers = 2L, 
[01:28:25.060]                     envir = parent.frame()) 
[01:28:25.060]                   strategy(..., workers = workers, envir = envir)), 
[01:28:25.060]                     .cleanup = FALSE, .init = FALSE)
[01:28:25.060]                 }
[01:28:25.060]             }
[01:28:25.060]         }
[01:28:25.060]     })
[01:28:25.060]     if (TRUE) {
[01:28:25.060]         base::sink(type = "output", split = FALSE)
[01:28:25.060]         if (TRUE) {
[01:28:25.060]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:25.060]         }
[01:28:25.060]         else {
[01:28:25.060]             ...future.result["stdout"] <- base::list(NULL)
[01:28:25.060]         }
[01:28:25.060]         base::close(...future.stdout)
[01:28:25.060]         ...future.stdout <- NULL
[01:28:25.060]     }
[01:28:25.060]     ...future.result$conditions <- ...future.conditions
[01:28:25.060]     ...future.result$finished <- base::Sys.time()
[01:28:25.060]     ...future.result
[01:28:25.060] }
[01:28:25.066] MultisessionFuture started
[01:28:25.066] - Launch lazy future ... done
[01:28:25.066] run() for 'MultisessionFuture' ... done
> v <- value(f)
[01:28:25.066] result() for ClusterFuture ...
[01:28:25.067] receiveMessageFromWorker() for ClusterFuture ...
[01:28:25.067] - Validating connection of MultisessionFuture
[01:28:25.099] - received message: FutureResult
[01:28:25.099] - Received FutureResult
[01:28:25.100] - Erased future from FutureRegistry
[01:28:25.100] result() for ClusterFuture ...
[01:28:25.100] - result already collected: FutureResult
[01:28:25.100] result() for ClusterFuture ... done
[01:28:25.100] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:25.100] result() for ClusterFuture ... done
[01:28:25.101] result() for ClusterFuture ...
[01:28:25.101] - result already collected: FutureResult
[01:28:25.101] result() for ClusterFuture ... done
> print(v)
         used (Mb) gc trigger  (Mb) max used  (Mb)
Ncells 407982 21.8     848270  45.4   655684  35.1
Vcells 725590  5.6   13473020 102.8 15800996 120.6
> 
> message("*** multisession(..., gc = TRUE) ... TRUE")
*** multisession(..., gc = TRUE) ... TRUE
> 
> 
> message("*** multisession(...) - stopping with plan() change ...")
*** multisession(...) - stopping with plan() change ...
>   
> plan(multisession, workers = 2L)
[01:28:25.102] plan(): Setting new future strategy stack:
[01:28:25.102] List of future strategies:
[01:28:25.102] 1. multisession:
[01:28:25.102]    - args: function (..., workers = 2L, envir = parent.frame())
[01:28:25.102]    - tweaked: TRUE
[01:28:25.102]    - call: plan(multisession, workers = 2L)
[01:28:25.103] plan(): plan_init() of 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[01:28:25.103] multisession:
[01:28:25.103] - args: function (..., workers = 2L, envir = parent.frame())
[01:28:25.103] - tweaked: TRUE
[01:28:25.103] - call: plan(multisession, workers = 2L)
[01:28:25.104] getGlobalsAndPackages() ...
[01:28:25.104] Not searching for globals
[01:28:25.104] - globals: [0] <none>
[01:28:25.104] getGlobalsAndPackages() ... DONE
[01:28:25.105] [local output] makeClusterPSOCK() ...
[01:28:25.105] [local output] Workers: [n = 2] 'localhost', 'localhost'
[01:28:25.108] [local output] Base port: 35335
[01:28:25.108] [local output] Getting setup options for 2 cluster nodes ...
[01:28:25.108] [local output]  - Node 1 of 2 ...
[01:28:25.109] [local output] localMachine=TRUE => revtunnel=FALSE

[01:28:25.110] [local output] Rscript port: 35335

[01:28:25.111] [local output]  - Node 2 of 2 ...
[01:28:25.111] [local output] localMachine=TRUE => revtunnel=FALSE

[01:28:25.112] [local output] Rscript port: 35335

[01:28:25.113] [local output] Getting setup options for 2 cluster nodes ... done
[01:28:25.113] [local output]  - Parallel setup requested for some PSOCK nodes
[01:28:25.114] [local output] Setting up PSOCK nodes in parallel
[01:28:25.114] List of 36
[01:28:25.114]  $ worker          : chr "localhost"
[01:28:25.114]   ..- attr(*, "localhost")= logi TRUE
[01:28:25.114]  $ master          : chr "localhost"
[01:28:25.114]  $ port            : int 35335
[01:28:25.114]  $ connectTimeout  : num 120
[01:28:25.114]  $ timeout         : num 120
[01:28:25.114]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[01:28:25.114]  $ homogeneous     : logi TRUE
[01:28:25.114]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=multisession.R:13328:CRANWIN3:CR"| __truncated__
[01:28:25.114]  $ rscript_envs    : NULL
[01:28:25.114]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47" "D:/RCompile/recent/R/library"
[01:28:25.114]  $ rscript_startup : NULL
[01:28:25.114]  $ rscript_sh      : chr "cmd"
[01:28:25.114]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[01:28:25.114]  $ methods         : logi TRUE
[01:28:25.114]  $ socketOptions   : chr "no-delay"
[01:28:25.114]  $ useXDR          : logi FALSE
[01:28:25.114]  $ outfile         : chr "/dev/null"
[01:28:25.114]  $ renice          : int NA
[01:28:25.114]  $ rshcmd          : NULL
[01:28:25.114]  $ user            : chr(0) 
[01:28:25.114]  $ revtunnel       : logi FALSE
[01:28:25.114]  $ rshlogfile      : NULL
[01:28:25.114]  $ rshopts         : chr(0) 
[01:28:25.114]  $ rank            : int 1
[01:28:25.114]  $ manual          : logi FALSE
[01:28:25.114]  $ dryrun          : logi FALSE
[01:28:25.114]  $ quiet           : logi FALSE
[01:28:25.114]  $ setup_strategy  : chr "parallel"
[01:28:25.114]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[01:28:25.114]  $ pidfile         : chr "D:/temp/RtmpSkOF3d/worker.rank=1.parallelly.parent=13328.3410429e3151.pid"
[01:28:25.114]  $ rshcmd_label    : NULL
[01:28:25.114]  $ rsh_call        : NULL
[01:28:25.114]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[01:28:25.114]  $ localMachine    : logi TRUE
[01:28:25.114]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[01:28:25.114]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[01:28:25.114]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[01:28:25.114]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[01:28:25.114]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[01:28:25.114]         "cmd", "sh"), default_packages = c("datasets", "utils", "grDevices", 
[01:28:25.114]         "graphics", "stats", if (methods) "methods"), methods = TRUE, socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[01:28:25.114]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[01:28:25.114]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[01:28:25.114]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[01:28:25.114]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[01:28:25.114]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[01:28:25.114]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[01:28:25.114]  $ arguments       :List of 28
[01:28:25.114]   ..$ worker          : chr "localhost"
[01:28:25.114]   ..$ master          : NULL
[01:28:25.114]   ..$ port            : int 35335
[01:28:25.114]   ..$ connectTimeout  : num 120
[01:28:25.114]   ..$ timeout         : num 120
[01:28:25.114]   ..$ rscript         : NULL
[01:28:25.114]   ..$ homogeneous     : NULL
[01:28:25.114]   ..$ rscript_args    : NULL
[01:28:25.114]   ..$ rscript_envs    : NULL
[01:28:25.114]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47" "D:/RCompile/recent/R/library"
[01:28:25.114]   ..$ rscript_startup : NULL
[01:28:25.114]   ..$ rscript_sh      : chr [1:3] "auto" "cmd" "sh"
[01:28:25.114]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[01:28:25.114]   ..$ methods         : logi TRUE
[01:28:25.114]   ..$ socketOptions   : chr "no-delay"
[01:28:25.114]   ..$ useXDR          : logi FALSE
[01:28:25.114]   ..$ outfile         : chr "/dev/null"
[01:28:25.114]   ..$ renice          : int NA
[01:28:25.114]   ..$ rshcmd          : NULL
[01:28:25.114]   ..$ user            : NULL
[01:28:25.114]   ..$ revtunnel       : logi NA
[01:28:25.114]   ..$ rshlogfile      : NULL
[01:28:25.114]   ..$ rshopts         : NULL
[01:28:25.114]   ..$ rank            : int 1
[01:28:25.114]   ..$ manual          : logi FALSE
[01:28:25.114]   ..$ dryrun          : logi FALSE
[01:28:25.114]   ..$ quiet           : logi FALSE
[01:28:25.114]   ..$ setup_strategy  : chr "parallel"
[01:28:25.114]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[01:28:25.138] [local output] System call to launch all workers:
[01:28:25.138] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=multisession.R:13328:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpSkOF3d/worker.rank=1.parallelly.parent=13328.3410429e3151.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=35335 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[01:28:25.138] [local output] Starting PSOCK main server
[01:28:25.145] [local output] Workers launched
[01:28:25.145] [local output] Waiting for workers to connect back
[01:28:25.145]  - [local output] 0 workers out of 2 ready
[01:28:25.327]  - [local output] 0 workers out of 2 ready
[01:28:25.328]  - [local output] 1 workers out of 2 ready
[01:28:25.350]  - [local output] 1 workers out of 2 ready
[01:28:25.351]  - [local output] 2 workers out of 2 ready
[01:28:25.351] [local output] Launching of workers completed
[01:28:25.351] [local output] Collecting session information from workers
[01:28:25.352] [local output]  - Worker #1 of 2
[01:28:25.353] [local output]  - Worker #2 of 2
[01:28:25.353] [local output] makeClusterPSOCK() ... done
[01:28:25.366] Packages needed by the future expression (n = 0): <none>
[01:28:25.367] Packages needed by future strategies (n = 0): <none>
[01:28:25.367] {
[01:28:25.367]     {
[01:28:25.367]         {
[01:28:25.367]             ...future.startTime <- base::Sys.time()
[01:28:25.367]             {
[01:28:25.367]                 {
[01:28:25.367]                   {
[01:28:25.367]                     {
[01:28:25.367]                       base::local({
[01:28:25.367]                         has_future <- base::requireNamespace("future", 
[01:28:25.367]                           quietly = TRUE)
[01:28:25.367]                         if (has_future) {
[01:28:25.367]                           ns <- base::getNamespace("future")
[01:28:25.367]                           version <- ns[[".package"]][["version"]]
[01:28:25.367]                           if (is.null(version)) 
[01:28:25.367]                             version <- utils::packageVersion("future")
[01:28:25.367]                         }
[01:28:25.367]                         else {
[01:28:25.367]                           version <- NULL
[01:28:25.367]                         }
[01:28:25.367]                         if (!has_future || version < "1.8.0") {
[01:28:25.367]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:25.367]                             "", base::R.version$version.string), 
[01:28:25.367]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:25.367]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:25.367]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:25.367]                               "release", "version")], collapse = " "), 
[01:28:25.367]                             hostname = base::Sys.info()[["nodename"]])
[01:28:25.367]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:25.367]                             info)
[01:28:25.367]                           info <- base::paste(info, collapse = "; ")
[01:28:25.367]                           if (!has_future) {
[01:28:25.367]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:25.367]                               info)
[01:28:25.367]                           }
[01:28:25.367]                           else {
[01:28:25.367]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:25.367]                               info, version)
[01:28:25.367]                           }
[01:28:25.367]                           base::stop(msg)
[01:28:25.367]                         }
[01:28:25.367]                       })
[01:28:25.367]                     }
[01:28:25.367]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:25.367]                     base::options(mc.cores = 1L)
[01:28:25.367]                   }
[01:28:25.367]                   options(future.plan = NULL)
[01:28:25.367]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:25.367]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:25.367]                 }
[01:28:25.367]                 ...future.workdir <- getwd()
[01:28:25.367]             }
[01:28:25.367]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:25.367]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:25.367]         }
[01:28:25.367]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:25.367]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:25.367]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:25.367]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:25.367]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:25.367]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:25.367]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:25.367]             base::names(...future.oldOptions))
[01:28:25.367]     }
[01:28:25.367]     if (FALSE) {
[01:28:25.367]     }
[01:28:25.367]     else {
[01:28:25.367]         if (TRUE) {
[01:28:25.367]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:25.367]                 open = "w")
[01:28:25.367]         }
[01:28:25.367]         else {
[01:28:25.367]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:25.367]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:25.367]         }
[01:28:25.367]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:25.367]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:25.367]             base::sink(type = "output", split = FALSE)
[01:28:25.367]             base::close(...future.stdout)
[01:28:25.367]         }, add = TRUE)
[01:28:25.367]     }
[01:28:25.367]     ...future.frame <- base::sys.nframe()
[01:28:25.367]     ...future.conditions <- base::list()
[01:28:25.367]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:25.367]     if (FALSE) {
[01:28:25.367]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:25.367]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:25.367]     }
[01:28:25.367]     ...future.result <- base::tryCatch({
[01:28:25.367]         base::withCallingHandlers({
[01:28:25.367]             ...future.value <- base::withVisible(base::local({
[01:28:25.367]                 ...future.makeSendCondition <- base::local({
[01:28:25.367]                   sendCondition <- NULL
[01:28:25.367]                   function(frame = 1L) {
[01:28:25.367]                     if (is.function(sendCondition)) 
[01:28:25.367]                       return(sendCondition)
[01:28:25.367]                     ns <- getNamespace("parallel")
[01:28:25.367]                     if (exists("sendData", mode = "function", 
[01:28:25.367]                       envir = ns)) {
[01:28:25.367]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:25.367]                         envir = ns)
[01:28:25.367]                       envir <- sys.frame(frame)
[01:28:25.367]                       master <- NULL
[01:28:25.367]                       while (!identical(envir, .GlobalEnv) && 
[01:28:25.367]                         !identical(envir, emptyenv())) {
[01:28:25.367]                         if (exists("master", mode = "list", envir = envir, 
[01:28:25.367]                           inherits = FALSE)) {
[01:28:25.367]                           master <- get("master", mode = "list", 
[01:28:25.367]                             envir = envir, inherits = FALSE)
[01:28:25.367]                           if (inherits(master, c("SOCKnode", 
[01:28:25.367]                             "SOCK0node"))) {
[01:28:25.367]                             sendCondition <<- function(cond) {
[01:28:25.367]                               data <- list(type = "VALUE", value = cond, 
[01:28:25.367]                                 success = TRUE)
[01:28:25.367]                               parallel_sendData(master, data)
[01:28:25.367]                             }
[01:28:25.367]                             return(sendCondition)
[01:28:25.367]                           }
[01:28:25.367]                         }
[01:28:25.367]                         frame <- frame + 1L
[01:28:25.367]                         envir <- sys.frame(frame)
[01:28:25.367]                       }
[01:28:25.367]                     }
[01:28:25.367]                     sendCondition <<- function(cond) NULL
[01:28:25.367]                   }
[01:28:25.367]                 })
[01:28:25.367]                 withCallingHandlers({
[01:28:25.367]                   NA
[01:28:25.367]                 }, immediateCondition = function(cond) {
[01:28:25.367]                   sendCondition <- ...future.makeSendCondition()
[01:28:25.367]                   sendCondition(cond)
[01:28:25.367]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:25.367]                   {
[01:28:25.367]                     inherits <- base::inherits
[01:28:25.367]                     invokeRestart <- base::invokeRestart
[01:28:25.367]                     is.null <- base::is.null
[01:28:25.367]                     muffled <- FALSE
[01:28:25.367]                     if (inherits(cond, "message")) {
[01:28:25.367]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:25.367]                       if (muffled) 
[01:28:25.367]                         invokeRestart("muffleMessage")
[01:28:25.367]                     }
[01:28:25.367]                     else if (inherits(cond, "warning")) {
[01:28:25.367]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:25.367]                       if (muffled) 
[01:28:25.367]                         invokeRestart("muffleWarning")
[01:28:25.367]                     }
[01:28:25.367]                     else if (inherits(cond, "condition")) {
[01:28:25.367]                       if (!is.null(pattern)) {
[01:28:25.367]                         computeRestarts <- base::computeRestarts
[01:28:25.367]                         grepl <- base::grepl
[01:28:25.367]                         restarts <- computeRestarts(cond)
[01:28:25.367]                         for (restart in restarts) {
[01:28:25.367]                           name <- restart$name
[01:28:25.367]                           if (is.null(name)) 
[01:28:25.367]                             next
[01:28:25.367]                           if (!grepl(pattern, name)) 
[01:28:25.367]                             next
[01:28:25.367]                           invokeRestart(restart)
[01:28:25.367]                           muffled <- TRUE
[01:28:25.367]                           break
[01:28:25.367]                         }
[01:28:25.367]                       }
[01:28:25.367]                     }
[01:28:25.367]                     invisible(muffled)
[01:28:25.367]                   }
[01:28:25.367]                   muffleCondition(cond)
[01:28:25.367]                 })
[01:28:25.367]             }))
[01:28:25.367]             future::FutureResult(value = ...future.value$value, 
[01:28:25.367]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:25.367]                   ...future.rng), globalenv = if (FALSE) 
[01:28:25.367]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:25.367]                     ...future.globalenv.names))
[01:28:25.367]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:25.367]         }, condition = base::local({
[01:28:25.367]             c <- base::c
[01:28:25.367]             inherits <- base::inherits
[01:28:25.367]             invokeRestart <- base::invokeRestart
[01:28:25.367]             length <- base::length
[01:28:25.367]             list <- base::list
[01:28:25.367]             seq.int <- base::seq.int
[01:28:25.367]             signalCondition <- base::signalCondition
[01:28:25.367]             sys.calls <- base::sys.calls
[01:28:25.367]             `[[` <- base::`[[`
[01:28:25.367]             `+` <- base::`+`
[01:28:25.367]             `<<-` <- base::`<<-`
[01:28:25.367]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:25.367]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:25.367]                   3L)]
[01:28:25.367]             }
[01:28:25.367]             function(cond) {
[01:28:25.367]                 is_error <- inherits(cond, "error")
[01:28:25.367]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:25.367]                   NULL)
[01:28:25.367]                 if (is_error) {
[01:28:25.367]                   sessionInformation <- function() {
[01:28:25.367]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:25.367]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:25.367]                       search = base::search(), system = base::Sys.info())
[01:28:25.367]                   }
[01:28:25.367]                   ...future.conditions[[length(...future.conditions) + 
[01:28:25.367]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:25.367]                     cond$call), session = sessionInformation(), 
[01:28:25.367]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:25.367]                   signalCondition(cond)
[01:28:25.367]                 }
[01:28:25.367]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:25.367]                 "immediateCondition"))) {
[01:28:25.367]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:25.367]                   ...future.conditions[[length(...future.conditions) + 
[01:28:25.367]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:25.367]                   if (TRUE && !signal) {
[01:28:25.367]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:25.367]                     {
[01:28:25.367]                       inherits <- base::inherits
[01:28:25.367]                       invokeRestart <- base::invokeRestart
[01:28:25.367]                       is.null <- base::is.null
[01:28:25.367]                       muffled <- FALSE
[01:28:25.367]                       if (inherits(cond, "message")) {
[01:28:25.367]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:25.367]                         if (muffled) 
[01:28:25.367]                           invokeRestart("muffleMessage")
[01:28:25.367]                       }
[01:28:25.367]                       else if (inherits(cond, "warning")) {
[01:28:25.367]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:25.367]                         if (muffled) 
[01:28:25.367]                           invokeRestart("muffleWarning")
[01:28:25.367]                       }
[01:28:25.367]                       else if (inherits(cond, "condition")) {
[01:28:25.367]                         if (!is.null(pattern)) {
[01:28:25.367]                           computeRestarts <- base::computeRestarts
[01:28:25.367]                           grepl <- base::grepl
[01:28:25.367]                           restarts <- computeRestarts(cond)
[01:28:25.367]                           for (restart in restarts) {
[01:28:25.367]                             name <- restart$name
[01:28:25.367]                             if (is.null(name)) 
[01:28:25.367]                               next
[01:28:25.367]                             if (!grepl(pattern, name)) 
[01:28:25.367]                               next
[01:28:25.367]                             invokeRestart(restart)
[01:28:25.367]                             muffled <- TRUE
[01:28:25.367]                             break
[01:28:25.367]                           }
[01:28:25.367]                         }
[01:28:25.367]                       }
[01:28:25.367]                       invisible(muffled)
[01:28:25.367]                     }
[01:28:25.367]                     muffleCondition(cond, pattern = "^muffle")
[01:28:25.367]                   }
[01:28:25.367]                 }
[01:28:25.367]                 else {
[01:28:25.367]                   if (TRUE) {
[01:28:25.367]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:25.367]                     {
[01:28:25.367]                       inherits <- base::inherits
[01:28:25.367]                       invokeRestart <- base::invokeRestart
[01:28:25.367]                       is.null <- base::is.null
[01:28:25.367]                       muffled <- FALSE
[01:28:25.367]                       if (inherits(cond, "message")) {
[01:28:25.367]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:25.367]                         if (muffled) 
[01:28:25.367]                           invokeRestart("muffleMessage")
[01:28:25.367]                       }
[01:28:25.367]                       else if (inherits(cond, "warning")) {
[01:28:25.367]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:25.367]                         if (muffled) 
[01:28:25.367]                           invokeRestart("muffleWarning")
[01:28:25.367]                       }
[01:28:25.367]                       else if (inherits(cond, "condition")) {
[01:28:25.367]                         if (!is.null(pattern)) {
[01:28:25.367]                           computeRestarts <- base::computeRestarts
[01:28:25.367]                           grepl <- base::grepl
[01:28:25.367]                           restarts <- computeRestarts(cond)
[01:28:25.367]                           for (restart in restarts) {
[01:28:25.367]                             name <- restart$name
[01:28:25.367]                             if (is.null(name)) 
[01:28:25.367]                               next
[01:28:25.367]                             if (!grepl(pattern, name)) 
[01:28:25.367]                               next
[01:28:25.367]                             invokeRestart(restart)
[01:28:25.367]                             muffled <- TRUE
[01:28:25.367]                             break
[01:28:25.367]                           }
[01:28:25.367]                         }
[01:28:25.367]                       }
[01:28:25.367]                       invisible(muffled)
[01:28:25.367]                     }
[01:28:25.367]                     muffleCondition(cond, pattern = "^muffle")
[01:28:25.367]                   }
[01:28:25.367]                 }
[01:28:25.367]             }
[01:28:25.367]         }))
[01:28:25.367]     }, error = function(ex) {
[01:28:25.367]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:25.367]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:25.367]                 ...future.rng), started = ...future.startTime, 
[01:28:25.367]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:25.367]             version = "1.8"), class = "FutureResult")
[01:28:25.367]     }, finally = {
[01:28:25.367]         if (!identical(...future.workdir, getwd())) 
[01:28:25.367]             setwd(...future.workdir)
[01:28:25.367]         {
[01:28:25.367]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:25.367]                 ...future.oldOptions$nwarnings <- NULL
[01:28:25.367]             }
[01:28:25.367]             base::options(...future.oldOptions)
[01:28:25.367]             if (.Platform$OS.type == "windows") {
[01:28:25.367]                 old_names <- names(...future.oldEnvVars)
[01:28:25.367]                 envs <- base::Sys.getenv()
[01:28:25.367]                 names <- names(envs)
[01:28:25.367]                 common <- intersect(names, old_names)
[01:28:25.367]                 added <- setdiff(names, old_names)
[01:28:25.367]                 removed <- setdiff(old_names, names)
[01:28:25.367]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:25.367]                   envs[common]]
[01:28:25.367]                 NAMES <- toupper(changed)
[01:28:25.367]                 args <- list()
[01:28:25.367]                 for (kk in seq_along(NAMES)) {
[01:28:25.367]                   name <- changed[[kk]]
[01:28:25.367]                   NAME <- NAMES[[kk]]
[01:28:25.367]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:25.367]                     next
[01:28:25.367]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:25.367]                 }
[01:28:25.367]                 NAMES <- toupper(added)
[01:28:25.367]                 for (kk in seq_along(NAMES)) {
[01:28:25.367]                   name <- added[[kk]]
[01:28:25.367]                   NAME <- NAMES[[kk]]
[01:28:25.367]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:25.367]                     next
[01:28:25.367]                   args[[name]] <- ""
[01:28:25.367]                 }
[01:28:25.367]                 NAMES <- toupper(removed)
[01:28:25.367]                 for (kk in seq_along(NAMES)) {
[01:28:25.367]                   name <- removed[[kk]]
[01:28:25.367]                   NAME <- NAMES[[kk]]
[01:28:25.367]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:25.367]                     next
[01:28:25.367]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:25.367]                 }
[01:28:25.367]                 if (length(args) > 0) 
[01:28:25.367]                   base::do.call(base::Sys.setenv, args = args)
[01:28:25.367]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:25.367]             }
[01:28:25.367]             else {
[01:28:25.367]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:25.367]             }
[01:28:25.367]             {
[01:28:25.367]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:25.367]                   0L) {
[01:28:25.367]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:25.367]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:25.367]                   base::options(opts)
[01:28:25.367]                 }
[01:28:25.367]                 {
[01:28:25.367]                   {
[01:28:25.367]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:25.367]                     NULL
[01:28:25.367]                   }
[01:28:25.367]                   options(future.plan = NULL)
[01:28:25.367]                   if (is.na(NA_character_)) 
[01:28:25.367]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:25.367]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:25.367]                   future::plan(list(function (..., workers = 2L, 
[01:28:25.367]                     envir = parent.frame()) 
[01:28:25.367]                   strategy(..., workers = workers, envir = envir)), 
[01:28:25.367]                     .cleanup = FALSE, .init = FALSE)
[01:28:25.367]                 }
[01:28:25.367]             }
[01:28:25.367]         }
[01:28:25.367]     })
[01:28:25.367]     if (TRUE) {
[01:28:25.367]         base::sink(type = "output", split = FALSE)
[01:28:25.367]         if (TRUE) {
[01:28:25.367]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:25.367]         }
[01:28:25.367]         else {
[01:28:25.367]             ...future.result["stdout"] <- base::list(NULL)
[01:28:25.367]         }
[01:28:25.367]         base::close(...future.stdout)
[01:28:25.367]         ...future.stdout <- NULL
[01:28:25.367]     }
[01:28:25.367]     ...future.result$conditions <- ...future.conditions
[01:28:25.367]     ...future.result$finished <- base::Sys.time()
[01:28:25.367]     ...future.result
[01:28:25.367] }
[01:28:25.452] MultisessionFuture started
[01:28:25.452] result() for ClusterFuture ...
[01:28:25.452] receiveMessageFromWorker() for ClusterFuture ...
[01:28:25.452] - Validating connection of MultisessionFuture
[01:28:25.506] - received message: FutureResult
[01:28:25.506] - Received FutureResult
[01:28:25.506] - Erased future from FutureRegistry
[01:28:25.507] result() for ClusterFuture ...
[01:28:25.507] - result already collected: FutureResult
[01:28:25.507] result() for ClusterFuture ... done
[01:28:25.507] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:25.507] result() for ClusterFuture ... done
[01:28:25.507] result() for ClusterFuture ...
[01:28:25.508] - result already collected: FutureResult
[01:28:25.508] result() for ClusterFuture ... done
[01:28:25.508] plan(): plan_init() of 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[01:28:25.508] plan(): nbrOfWorkers() = 2
> f <- future(1L)
[01:28:25.509] getGlobalsAndPackages() ...
[01:28:25.509] Searching for globals...
[01:28:25.509] 
[01:28:25.509] Searching for globals ... DONE
[01:28:25.510] - globals: [0] <none>
[01:28:25.510] getGlobalsAndPackages() ... DONE
[01:28:25.510] run() for 'Future' ...
[01:28:25.510] - state: 'created'
[01:28:25.511] - Future backend: 'FutureStrategy', 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:25.523] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:25.524] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:25.524]   - Field: 'node'
[01:28:25.524]   - Field: 'label'
[01:28:25.524]   - Field: 'local'
[01:28:25.525]   - Field: 'owner'
[01:28:25.525]   - Field: 'envir'
[01:28:25.525]   - Field: 'workers'
[01:28:25.525]   - Field: 'packages'
[01:28:25.525]   - Field: 'gc'
[01:28:25.526]   - Field: 'conditions'
[01:28:25.526]   - Field: 'persistent'
[01:28:25.526]   - Field: 'expr'
[01:28:25.526]   - Field: 'uuid'
[01:28:25.526]   - Field: 'seed'
[01:28:25.527]   - Field: 'version'
[01:28:25.527]   - Field: 'result'
[01:28:25.527]   - Field: 'asynchronous'
[01:28:25.527]   - Field: 'calls'
[01:28:25.527]   - Field: 'globals'
[01:28:25.528]   - Field: 'stdout'
[01:28:25.528]   - Field: 'earlySignal'
[01:28:25.528]   - Field: 'lazy'
[01:28:25.528]   - Field: 'state'
[01:28:25.528] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:25.529] - Launch lazy future ...
[01:28:25.529] Packages needed by the future expression (n = 0): <none>
[01:28:25.529] Packages needed by future strategies (n = 0): <none>
[01:28:25.530] {
[01:28:25.530]     {
[01:28:25.530]         {
[01:28:25.530]             ...future.startTime <- base::Sys.time()
[01:28:25.530]             {
[01:28:25.530]                 {
[01:28:25.530]                   {
[01:28:25.530]                     {
[01:28:25.530]                       base::local({
[01:28:25.530]                         has_future <- base::requireNamespace("future", 
[01:28:25.530]                           quietly = TRUE)
[01:28:25.530]                         if (has_future) {
[01:28:25.530]                           ns <- base::getNamespace("future")
[01:28:25.530]                           version <- ns[[".package"]][["version"]]
[01:28:25.530]                           if (is.null(version)) 
[01:28:25.530]                             version <- utils::packageVersion("future")
[01:28:25.530]                         }
[01:28:25.530]                         else {
[01:28:25.530]                           version <- NULL
[01:28:25.530]                         }
[01:28:25.530]                         if (!has_future || version < "1.8.0") {
[01:28:25.530]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:25.530]                             "", base::R.version$version.string), 
[01:28:25.530]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:25.530]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:25.530]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:25.530]                               "release", "version")], collapse = " "), 
[01:28:25.530]                             hostname = base::Sys.info()[["nodename"]])
[01:28:25.530]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:25.530]                             info)
[01:28:25.530]                           info <- base::paste(info, collapse = "; ")
[01:28:25.530]                           if (!has_future) {
[01:28:25.530]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:25.530]                               info)
[01:28:25.530]                           }
[01:28:25.530]                           else {
[01:28:25.530]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:25.530]                               info, version)
[01:28:25.530]                           }
[01:28:25.530]                           base::stop(msg)
[01:28:25.530]                         }
[01:28:25.530]                       })
[01:28:25.530]                     }
[01:28:25.530]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:25.530]                     base::options(mc.cores = 1L)
[01:28:25.530]                   }
[01:28:25.530]                   options(future.plan = NULL)
[01:28:25.530]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:25.530]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:25.530]                 }
[01:28:25.530]                 ...future.workdir <- getwd()
[01:28:25.530]             }
[01:28:25.530]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:25.530]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:25.530]         }
[01:28:25.530]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:25.530]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:25.530]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:25.530]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:25.530]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:25.530]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:25.530]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:25.530]             base::names(...future.oldOptions))
[01:28:25.530]     }
[01:28:25.530]     if (FALSE) {
[01:28:25.530]     }
[01:28:25.530]     else {
[01:28:25.530]         if (TRUE) {
[01:28:25.530]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:25.530]                 open = "w")
[01:28:25.530]         }
[01:28:25.530]         else {
[01:28:25.530]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:25.530]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:25.530]         }
[01:28:25.530]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:25.530]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:25.530]             base::sink(type = "output", split = FALSE)
[01:28:25.530]             base::close(...future.stdout)
[01:28:25.530]         }, add = TRUE)
[01:28:25.530]     }
[01:28:25.530]     ...future.frame <- base::sys.nframe()
[01:28:25.530]     ...future.conditions <- base::list()
[01:28:25.530]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:25.530]     if (FALSE) {
[01:28:25.530]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:25.530]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:25.530]     }
[01:28:25.530]     ...future.result <- base::tryCatch({
[01:28:25.530]         base::withCallingHandlers({
[01:28:25.530]             ...future.value <- base::withVisible(base::local({
[01:28:25.530]                 ...future.makeSendCondition <- base::local({
[01:28:25.530]                   sendCondition <- NULL
[01:28:25.530]                   function(frame = 1L) {
[01:28:25.530]                     if (is.function(sendCondition)) 
[01:28:25.530]                       return(sendCondition)
[01:28:25.530]                     ns <- getNamespace("parallel")
[01:28:25.530]                     if (exists("sendData", mode = "function", 
[01:28:25.530]                       envir = ns)) {
[01:28:25.530]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:25.530]                         envir = ns)
[01:28:25.530]                       envir <- sys.frame(frame)
[01:28:25.530]                       master <- NULL
[01:28:25.530]                       while (!identical(envir, .GlobalEnv) && 
[01:28:25.530]                         !identical(envir, emptyenv())) {
[01:28:25.530]                         if (exists("master", mode = "list", envir = envir, 
[01:28:25.530]                           inherits = FALSE)) {
[01:28:25.530]                           master <- get("master", mode = "list", 
[01:28:25.530]                             envir = envir, inherits = FALSE)
[01:28:25.530]                           if (inherits(master, c("SOCKnode", 
[01:28:25.530]                             "SOCK0node"))) {
[01:28:25.530]                             sendCondition <<- function(cond) {
[01:28:25.530]                               data <- list(type = "VALUE", value = cond, 
[01:28:25.530]                                 success = TRUE)
[01:28:25.530]                               parallel_sendData(master, data)
[01:28:25.530]                             }
[01:28:25.530]                             return(sendCondition)
[01:28:25.530]                           }
[01:28:25.530]                         }
[01:28:25.530]                         frame <- frame + 1L
[01:28:25.530]                         envir <- sys.frame(frame)
[01:28:25.530]                       }
[01:28:25.530]                     }
[01:28:25.530]                     sendCondition <<- function(cond) NULL
[01:28:25.530]                   }
[01:28:25.530]                 })
[01:28:25.530]                 withCallingHandlers({
[01:28:25.530]                   1L
[01:28:25.530]                 }, immediateCondition = function(cond) {
[01:28:25.530]                   sendCondition <- ...future.makeSendCondition()
[01:28:25.530]                   sendCondition(cond)
[01:28:25.530]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:25.530]                   {
[01:28:25.530]                     inherits <- base::inherits
[01:28:25.530]                     invokeRestart <- base::invokeRestart
[01:28:25.530]                     is.null <- base::is.null
[01:28:25.530]                     muffled <- FALSE
[01:28:25.530]                     if (inherits(cond, "message")) {
[01:28:25.530]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:25.530]                       if (muffled) 
[01:28:25.530]                         invokeRestart("muffleMessage")
[01:28:25.530]                     }
[01:28:25.530]                     else if (inherits(cond, "warning")) {
[01:28:25.530]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:25.530]                       if (muffled) 
[01:28:25.530]                         invokeRestart("muffleWarning")
[01:28:25.530]                     }
[01:28:25.530]                     else if (inherits(cond, "condition")) {
[01:28:25.530]                       if (!is.null(pattern)) {
[01:28:25.530]                         computeRestarts <- base::computeRestarts
[01:28:25.530]                         grepl <- base::grepl
[01:28:25.530]                         restarts <- computeRestarts(cond)
[01:28:25.530]                         for (restart in restarts) {
[01:28:25.530]                           name <- restart$name
[01:28:25.530]                           if (is.null(name)) 
[01:28:25.530]                             next
[01:28:25.530]                           if (!grepl(pattern, name)) 
[01:28:25.530]                             next
[01:28:25.530]                           invokeRestart(restart)
[01:28:25.530]                           muffled <- TRUE
[01:28:25.530]                           break
[01:28:25.530]                         }
[01:28:25.530]                       }
[01:28:25.530]                     }
[01:28:25.530]                     invisible(muffled)
[01:28:25.530]                   }
[01:28:25.530]                   muffleCondition(cond)
[01:28:25.530]                 })
[01:28:25.530]             }))
[01:28:25.530]             future::FutureResult(value = ...future.value$value, 
[01:28:25.530]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:25.530]                   ...future.rng), globalenv = if (FALSE) 
[01:28:25.530]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:25.530]                     ...future.globalenv.names))
[01:28:25.530]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:25.530]         }, condition = base::local({
[01:28:25.530]             c <- base::c
[01:28:25.530]             inherits <- base::inherits
[01:28:25.530]             invokeRestart <- base::invokeRestart
[01:28:25.530]             length <- base::length
[01:28:25.530]             list <- base::list
[01:28:25.530]             seq.int <- base::seq.int
[01:28:25.530]             signalCondition <- base::signalCondition
[01:28:25.530]             sys.calls <- base::sys.calls
[01:28:25.530]             `[[` <- base::`[[`
[01:28:25.530]             `+` <- base::`+`
[01:28:25.530]             `<<-` <- base::`<<-`
[01:28:25.530]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:25.530]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:25.530]                   3L)]
[01:28:25.530]             }
[01:28:25.530]             function(cond) {
[01:28:25.530]                 is_error <- inherits(cond, "error")
[01:28:25.530]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:25.530]                   NULL)
[01:28:25.530]                 if (is_error) {
[01:28:25.530]                   sessionInformation <- function() {
[01:28:25.530]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:25.530]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:25.530]                       search = base::search(), system = base::Sys.info())
[01:28:25.530]                   }
[01:28:25.530]                   ...future.conditions[[length(...future.conditions) + 
[01:28:25.530]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:25.530]                     cond$call), session = sessionInformation(), 
[01:28:25.530]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:25.530]                   signalCondition(cond)
[01:28:25.530]                 }
[01:28:25.530]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:25.530]                 "immediateCondition"))) {
[01:28:25.530]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:25.530]                   ...future.conditions[[length(...future.conditions) + 
[01:28:25.530]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:25.530]                   if (TRUE && !signal) {
[01:28:25.530]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:25.530]                     {
[01:28:25.530]                       inherits <- base::inherits
[01:28:25.530]                       invokeRestart <- base::invokeRestart
[01:28:25.530]                       is.null <- base::is.null
[01:28:25.530]                       muffled <- FALSE
[01:28:25.530]                       if (inherits(cond, "message")) {
[01:28:25.530]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:25.530]                         if (muffled) 
[01:28:25.530]                           invokeRestart("muffleMessage")
[01:28:25.530]                       }
[01:28:25.530]                       else if (inherits(cond, "warning")) {
[01:28:25.530]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:25.530]                         if (muffled) 
[01:28:25.530]                           invokeRestart("muffleWarning")
[01:28:25.530]                       }
[01:28:25.530]                       else if (inherits(cond, "condition")) {
[01:28:25.530]                         if (!is.null(pattern)) {
[01:28:25.530]                           computeRestarts <- base::computeRestarts
[01:28:25.530]                           grepl <- base::grepl
[01:28:25.530]                           restarts <- computeRestarts(cond)
[01:28:25.530]                           for (restart in restarts) {
[01:28:25.530]                             name <- restart$name
[01:28:25.530]                             if (is.null(name)) 
[01:28:25.530]                               next
[01:28:25.530]                             if (!grepl(pattern, name)) 
[01:28:25.530]                               next
[01:28:25.530]                             invokeRestart(restart)
[01:28:25.530]                             muffled <- TRUE
[01:28:25.530]                             break
[01:28:25.530]                           }
[01:28:25.530]                         }
[01:28:25.530]                       }
[01:28:25.530]                       invisible(muffled)
[01:28:25.530]                     }
[01:28:25.530]                     muffleCondition(cond, pattern = "^muffle")
[01:28:25.530]                   }
[01:28:25.530]                 }
[01:28:25.530]                 else {
[01:28:25.530]                   if (TRUE) {
[01:28:25.530]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:25.530]                     {
[01:28:25.530]                       inherits <- base::inherits
[01:28:25.530]                       invokeRestart <- base::invokeRestart
[01:28:25.530]                       is.null <- base::is.null
[01:28:25.530]                       muffled <- FALSE
[01:28:25.530]                       if (inherits(cond, "message")) {
[01:28:25.530]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:25.530]                         if (muffled) 
[01:28:25.530]                           invokeRestart("muffleMessage")
[01:28:25.530]                       }
[01:28:25.530]                       else if (inherits(cond, "warning")) {
[01:28:25.530]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:25.530]                         if (muffled) 
[01:28:25.530]                           invokeRestart("muffleWarning")
[01:28:25.530]                       }
[01:28:25.530]                       else if (inherits(cond, "condition")) {
[01:28:25.530]                         if (!is.null(pattern)) {
[01:28:25.530]                           computeRestarts <- base::computeRestarts
[01:28:25.530]                           grepl <- base::grepl
[01:28:25.530]                           restarts <- computeRestarts(cond)
[01:28:25.530]                           for (restart in restarts) {
[01:28:25.530]                             name <- restart$name
[01:28:25.530]                             if (is.null(name)) 
[01:28:25.530]                               next
[01:28:25.530]                             if (!grepl(pattern, name)) 
[01:28:25.530]                               next
[01:28:25.530]                             invokeRestart(restart)
[01:28:25.530]                             muffled <- TRUE
[01:28:25.530]                             break
[01:28:25.530]                           }
[01:28:25.530]                         }
[01:28:25.530]                       }
[01:28:25.530]                       invisible(muffled)
[01:28:25.530]                     }
[01:28:25.530]                     muffleCondition(cond, pattern = "^muffle")
[01:28:25.530]                   }
[01:28:25.530]                 }
[01:28:25.530]             }
[01:28:25.530]         }))
[01:28:25.530]     }, error = function(ex) {
[01:28:25.530]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:25.530]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:25.530]                 ...future.rng), started = ...future.startTime, 
[01:28:25.530]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:25.530]             version = "1.8"), class = "FutureResult")
[01:28:25.530]     }, finally = {
[01:28:25.530]         if (!identical(...future.workdir, getwd())) 
[01:28:25.530]             setwd(...future.workdir)
[01:28:25.530]         {
[01:28:25.530]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:25.530]                 ...future.oldOptions$nwarnings <- NULL
[01:28:25.530]             }
[01:28:25.530]             base::options(...future.oldOptions)
[01:28:25.530]             if (.Platform$OS.type == "windows") {
[01:28:25.530]                 old_names <- names(...future.oldEnvVars)
[01:28:25.530]                 envs <- base::Sys.getenv()
[01:28:25.530]                 names <- names(envs)
[01:28:25.530]                 common <- intersect(names, old_names)
[01:28:25.530]                 added <- setdiff(names, old_names)
[01:28:25.530]                 removed <- setdiff(old_names, names)
[01:28:25.530]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:25.530]                   envs[common]]
[01:28:25.530]                 NAMES <- toupper(changed)
[01:28:25.530]                 args <- list()
[01:28:25.530]                 for (kk in seq_along(NAMES)) {
[01:28:25.530]                   name <- changed[[kk]]
[01:28:25.530]                   NAME <- NAMES[[kk]]
[01:28:25.530]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:25.530]                     next
[01:28:25.530]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:25.530]                 }
[01:28:25.530]                 NAMES <- toupper(added)
[01:28:25.530]                 for (kk in seq_along(NAMES)) {
[01:28:25.530]                   name <- added[[kk]]
[01:28:25.530]                   NAME <- NAMES[[kk]]
[01:28:25.530]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:25.530]                     next
[01:28:25.530]                   args[[name]] <- ""
[01:28:25.530]                 }
[01:28:25.530]                 NAMES <- toupper(removed)
[01:28:25.530]                 for (kk in seq_along(NAMES)) {
[01:28:25.530]                   name <- removed[[kk]]
[01:28:25.530]                   NAME <- NAMES[[kk]]
[01:28:25.530]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:25.530]                     next
[01:28:25.530]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:25.530]                 }
[01:28:25.530]                 if (length(args) > 0) 
[01:28:25.530]                   base::do.call(base::Sys.setenv, args = args)
[01:28:25.530]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:25.530]             }
[01:28:25.530]             else {
[01:28:25.530]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:25.530]             }
[01:28:25.530]             {
[01:28:25.530]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:25.530]                   0L) {
[01:28:25.530]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:25.530]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:25.530]                   base::options(opts)
[01:28:25.530]                 }
[01:28:25.530]                 {
[01:28:25.530]                   {
[01:28:25.530]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:25.530]                     NULL
[01:28:25.530]                   }
[01:28:25.530]                   options(future.plan = NULL)
[01:28:25.530]                   if (is.na(NA_character_)) 
[01:28:25.530]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:25.530]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:25.530]                   future::plan(list(function (..., workers = 2L, 
[01:28:25.530]                     envir = parent.frame()) 
[01:28:25.530]                   strategy(..., workers = workers, envir = envir)), 
[01:28:25.530]                     .cleanup = FALSE, .init = FALSE)
[01:28:25.530]                 }
[01:28:25.530]             }
[01:28:25.530]         }
[01:28:25.530]     })
[01:28:25.530]     if (TRUE) {
[01:28:25.530]         base::sink(type = "output", split = FALSE)
[01:28:25.530]         if (TRUE) {
[01:28:25.530]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:25.530]         }
[01:28:25.530]         else {
[01:28:25.530]             ...future.result["stdout"] <- base::list(NULL)
[01:28:25.530]         }
[01:28:25.530]         base::close(...future.stdout)
[01:28:25.530]         ...future.stdout <- NULL
[01:28:25.530]     }
[01:28:25.530]     ...future.result$conditions <- ...future.conditions
[01:28:25.530]     ...future.result$finished <- base::Sys.time()
[01:28:25.530]     ...future.result
[01:28:25.530] }
[01:28:25.535] MultisessionFuture started
[01:28:25.536] - Launch lazy future ... done
[01:28:25.536] run() for 'MultisessionFuture' ... done
> cl <- ClusterRegistry("get")
> stopifnot(inherits(cl, "cluster"), length(cl) >= 1L)
> 
> plan(sequential)
[01:28:25.536] plan(): Setting new future strategy stack:
[01:28:25.537] List of future strategies:
[01:28:25.537] 1. sequential:
[01:28:25.537]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:25.537]    - tweaked: FALSE
[01:28:25.537]    - call: plan(sequential)
[01:28:25.537] 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")
[01:28:25.539] plan(): Setting new future strategy stack:
[01:28:25.539] List of future strategies:
[01:28:25.539] 1. FutureStrategy:
[01:28:25.539]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:25.539]    - tweaked: FALSE
[01:28:25.539]    - call: future::plan(oplan)
[01:28:25.540] plan(): nbrOfWorkers() = 1
Failed to undo environment variables:
 - Expected environment variables: [n=204] '!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', '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_RTOOLS43_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_SUBDIRS_STRICT_', '_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_USE_ALIASES_FROM_CRAN_', '_R_CLASS_MATRIX_ARRAY_', '_R_INSTALL_TIME_PATCHES_', '_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.34    0.37    3.67